VERSION=$( mysql -u$user -p$password -S $socket -e"SELECT VERSION();" | cut -f1,2 -d. )
 if [ $VERSION = '5.0' ]; then
  # Execute 5.0 code
 elif [ $VERSION = '4.1' ]; then
  # Execute 4.1 code
 elif [ $VERSION = '4.0' ]; then
  # Execute 4.0 code
 else
  echo "Unable to determine version
  exit 1

This method involved a lot of code duplication. Yesterday, a co-worker mentioned using MySQL version specific comments, which I had seen before, but never fully understood.

Most of you have probably seen MySQL Comments before, whether you know it or not. They take the form of:

/*!40101 SET NAMES utf8 */;
/*!40103 SET TIME_ZONE='+00:00' */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;

These types of comments are most popular in MySQL Dumps. Once you understand what they mean, they’re very easy to use. Here are the basics:

• MySQL version specific comments start with /*!
• And end with */
• Version numbers are always 5 digits
• Version numbers are in the format major release number, minor release number, revision number with the major being 1 digit and the minor and revision being 2 digits left-padded with 0’s
• Version specific comments will target any version equal to or higher than the version number listed

So in the examples above, the comments will target versions 4.1.1+ (40101), 4.1.3+ (40103), 4.0.14+ (40014), and 4.1.11+ (40111) respectively. Any version below these, will simply read those lines as comments and ignore them.

So, if you were to take the following SQL code:

SELECT 1 /*!40122 , 2 */ /*!50067 , 3 */;

and run that on servers running 4.0. 4.1.22, and 5.0.67, you would get the following output:
4.0

mysql> SELECT 1 /*!40122 , 2 */ /*!50067 , 3 */;
+---+
| 1 |
+---+
| 1 |
+---+

4.1.22

mysql> SELECT 1 /*!40122 , 2 */ /*!50067 , 3 */;
+---+---+
| 1 | 2 |
+---+---+
| 1 | 2 |
+---+---+

5.0.67

mysql> SELECT 1 /*!40122 , 2 */ /*!50067 , 3 */;
+---+---+---+
| 1 | 2 | 3 |
+---+---+---+
| 1 | 2 | 3 |
+---+---+---+

Remember that the comments target all versions equal to or higher, so 4.0 will only see SELECT 1;, 4.1.22 will see SELECT 1, 2;, and 5.0.67 will see SELECT 1, 2, 3;. The rest of the code will just be read as inline comments.

Hopefully this helps to understand MySQL version specific conditional comments a little bit better.

Comments or questions are welcome and encouraged.

 OLDIFS=$IFS

I forgot to set it back at the end of my one-liner, which caused some problems for me. I tried checking another server to see what the default is, but if you just run the command

# echo $IFS
#

you see that you just get a blank line. The way to show all non-printing characters is to pipe the output into cat with a couple of switches.

# echo "$IFS" | cat -vTE
 ^I$
$
#

The switches stand for the following:

-v, –show-nonprinting

use ^ and M- notation, except for LFD and TAB

-T, –show-tabs

display TAB characters as ^I

-E, –show-ends

display $ at end of each line

**Note -t can be substituted for -vT; -e can be substituted for -vE

So our output above, indicates that the default setting for the $IFS variable is: a space, followed by a tab, followed by a new line character.

Once I had this information, it was very easy to then reset the $IFS variable back to it’s default. While trying to set this, I had problems with the tab (for some reason it wasn’t registering) so I just wrote it as ‘^I’. Once set, run the

echo "$IFS" | cat -vTE

command again to verify and make sure it matches the output above and you’ll be all set.

What I cannot create, I do not understand.
Richard Feynman

In a nutshell, we can not solve the problem if we don’t understand what the problem is.

Mike utilized the following exploits/weaknesses to take over an installation of PHP Nuke and enable a remote code execution:

• OWASP A1 – SQL Injection
• OWASP A3 – Broken Authentication and Session Management
• CWE-200: Information Exposure
• OWASP A1 – SQL Injection
• CWE-98: Improper Control of Filename for Include/Require Statement in PHP Program (‘PHP File Inclusion’)

While Mike said it took over a year to develop the exploit, it seemed very easy. However, I’m sure there is a lot of “guess and check” involved in hacking. Maybe by easy, to me it seems that some very basic security measures would have prevented this, measures that PHP Nuke isn’t taking, but very easily could. Things like

• Proper usage of MySQL Data Types
• Proper management of user sessions
• Better MySQL input sanitzation
• Proper login methods

These are just a few of the things that could help prevent against this exploit. More than anything, what I was amazed at was that Mike was able to login to the admin portion of the (his) site without having to decrypt the md5 password hash due to the shoddy session management. Apparently, this has been a well-documented PHP Nuke exploit for years, however he had to use some clever hacking first to obtain the information necessary.

Like I said, I learned a lot (much more than I though I was going to) at the meeting and look forward to attending every month. I highly suggest checking for an OWASP chapter in your area and attending monthly meetings. In closing, I’d like to leave a list of some of the things I took away from this meeting:

• Modules (to any web app) are a major risk for attack (I pretty much knew this one already, just wanted to share it)
• Do not mix XSS and SQL Injection sanitization methods in the same function
• Limit the abilities of what even the admin of your application can do so even if it gets popped, the damage can be minimized
• Do not use md5 for password hashing! Instead use sha1 or sha256 (this was news to me)
• Don’t manage your sessions yourself, let php manage them with session_start()
• Use PhpSecInfo
• Granting MySQL FILE privileges are worse than granting GRANT privileges
• Security through Obscurity is not security at all, instead it is merely a stop-gap
• I will NEVER use, work on, or support PHP Nuke (it has more holes than swiss cheese)

alter table wp_statpress
 modify column date int(8) NULL NULL,
 modify column time time NULL NULL,
 modify column ip varchar(15) NULL NULL,
 modify column nation varchar(10) NULL NULL,
 modify column os varchar(64) NULL NULL,
 modify column browser varchar(64) NULL NULL,
 modify column searchengine varchar(64) NULL NULL,
 modify column spider varchar(64) NULL NULL,
 modify column feed varchar(32) NULL NULL,
 modify column user varchar(64) NULL NULL,
 modify column timestamp timestamp NULL NULL,
 add index spider_nation (spider, nation),
 add index ip_date (ip, date),
 add index (agent(255)),
 add index (search(255)),
 add index (referrer(255)),
 add index feed_spider_os (feed, spider, os),
 add index (os),
 add index date_feed_spider (date, feed, spider),
 add index feed_spider_browser (feed, spider, browser),
 add index (browser);

**Note: This code assumes your StatPress table name is wp_statpress. If it is not, make sure you update the code to reflect the name of your StatPress table.

This will set proper data types on the StatPress table as well as add indexes to the columns that are regularly queried by the plugin. Hopefully with these changes, you will start to notice a performance improvement in your blog as well as a significant improvement on your StatPress plugin page on your dashboard.

Please let me know if this helps you out, or if you have any problems executing the code, by commenting below.

What is heredoc?

Heredoc syntax is a way to delimit strings in PHP (and other languages) with 3 “less than” symbols: <<<.

After this operator, an identifier is provided, then a newline. The string itself follows, and then the same identifier again to close the quotation.

The closing identifier must begin in the first column of the line. Also, the identifier must follow the same naming rules as any other label in PHP: it must contain only alphanumeric characters and underscores, and must start with a non-digit character or underscore.
PHP: Strings – Manual

An example may help:

<?php
echo <<<EOD
Example of string
spanning multiple lines
using heredoc syntax.
EOD;
?>

This will output:
“Example of string
spanning multiple lines
using heredoc syntax”

Not very impressive. However, where the handiness comes in is in the following:

Heredoc text behaves just like a double-quoted string, without the double quotes. This means that quotes in a heredoc do not need to be escaped. Variables are expanded, but the same care must be taken when expressing complex variables inside a heredoc as with strings.
PHP: Strings – Manual

This allows you to use variables and quotes in your heredocs without having to escape every single quote you want to use. It makes it very useful for printing out extremely long strings of text.

Things to remember about using heredoc

Heredocs are a great way to simplify your code and print out long strings. Here is just a few things to keep in mind when using them:

• Heredocs start with “<<<IDENTIFIER where IDENTIFIER must follow the same naming conventions of PHP variables.
• The closing identifier must be the same as the opening identifier
• The line with the closing identifier must contain no other characters, except possibly a semicolon (;). That means especially that the identifier may not be indented, and there may not be any spaces or tabs before or after the semicolon
• Quotes and double quotes do not need to be escaped
• Variables are expanded

For more information, refer to the PHP: Strings Manual on php.net

Bonus: Heredocs for bash scripting

Heredocs for bash work pretty much the exact same way as they do for PHP but are delimited by 2 “less than” symbols:” << instead of 3. Here is a handy way to output large fields of text into a file through a bash script:

#!/bin/bash
cat <<OUTPUT > /etc/my.cnf
[mysqld]
socket=/tmp/mysql.sock
port=3306
user=mysql
password=supersecretpassword
log-bin=mysql-bin
server-id=1
OUTPUT

What about you? What new things have you learned from reading other peoples’ code? Share with us and we’ll all learn something new.

I was working on a new web design last night early this morning I found myself struggling (probably more than I should have been) with creating tabbed content switcher (hover over one element changes the content of another). I knew the right way to go was jQuery, and I wanted to avoid downloading a plugin as that would likely end up with more code and another HTTP request to the server. As I was working on the content switcher, I had one of those “Let’s try this and see what it does” moments (those tend to work all to often for me). It turned out that it did half of what I needed, so I removed another line and voila! I had my content switcher. So without further ado, here it is.

The Story

This project was a site I took over from another developer. My responsibilities were to finish the project and clean things up. The previous developer went 95 yards, I needed to put the ball in the end zone. For legal reasons, I can not show a screenshot of the full comp unfortunately. I initially was just going to clean up code and fix validation, CSS, and jQuery. However, I quickly realized that would end up making it harder. So I decided to rewrite the HTML and CSS and duplicate the look and feel of the previous version. An added benefit to rewriting the code my own way, in addition to being more familiar with the code and all the CSS hooks, is that I could focus on reducing code bloat and cut down on the amount of images being used to help deliver a better performing site to the client. Here is a look at the tabs themselves. Hovering over each tab changes the content below:

The HTML

My first goal was to create the tabs and still make them SEO friendly by having all the content actually in the markup, and not added/removed as needed. The markup for the tabs are as follows:

     <div id="main_middle">
      <ul>
       <li id="tab-1"><a href="#" class="active_tab">Tab 1</a></li>
       <li id="tab-2"><a href="#">Tab 2</a></li>
       <li id="tab-3"><a href="#">Tab 3</a></li>
       <li id="tab-4"><a href="#">Tab 4</a></li>
       <li id="tab-5"><a href="#">Tab 5</a></li>
      </ul>
      <p class="active_tab_content">Content 1 - Lorem ipsum dolor sit amet, consectetur adipiscing elit.</p>
      <p>Content 2 - Mauris ornare suscipit lacus eget lobortis. Vestibulum quis purus metus, sed condimentum magna.</p>
      <p>Content 3 - Nunc et turpis laoreet mi dapibus pulvinar. Nunc a facilisis mauris. Nulla facilisi. Morbi sed volutpat elit. Cras varius sollicitudin mi at imperdiet.</p>
      <p>Content 4 - Ut a consectetur quam. Nulla ut consequat metus. Nunc molestie erat sit amet tortor faucibus elementum. Praesent eu luctus nulla.</p>
      <p>Content 5 - Proin porttitor mattis erat eget ullamcorper. Lorem ipsum dolor sit amet, consectetur adipiscing elit.</p>
     </div>

As you can see, the HTML is only 14 lines long: a container element, an unordered list, and paragraph elements (one for each tab). This is a far cry from the 47 lines of HTML with divs nested 3 deep the previous developer was using. Additionally, the container has an id as well as each tab, plus a class for the active tab and paragraph and that’s it. This can be done without the id’s, I have them in there for CSS sprite functionality. The active_tab class is not required, again it’s something I use for my sprites.

The CSS

Here is the pertinent CSS to making this work. I have a bunch extra for my sprites, but that’s beside the point:

#main_middle ul li {
 display: -moz-inline-stack;
 display: inline-block;
 zoom: 1;
 *display: inline;
 text-align: center;
 vertical-align: text-top;
}

#main_middle ul li a {
 display: block;
 width: 100%;
 height: 100%;
}

#main_middle p {
 background: url(../images/tab_content_bg.png) 50% 0 no-repeat transparent;
 display: none;
}

#main_middle .active_tab_content {
 display: -moz-inline-stack;
 display: inline-block;
 zoom: 1;
 *display: inline;
}

#main_middle ul #tab-2 a { /* Example of Sprite Usage */
 background-position: -95px 0;
}

#main_middle ul #tab-2 .active_tab { /* Example of Sprite Usage  */
 background-position: -95px -79px;

The display/zoom lines is for cross-browser inline-block display. The code for the anchor elements simply sets them to a block the full size of the list item parent. Next, all paragraph elements are hidden and only the one with the “active_tab_content” class is displayed. The background is set for all the paragraph elements, although I could’ve just as easily set it for just the display content only.

Here is my sprite so you get the idea of what I’m doing with that code:

The jQuery

The biggest problem I was encountering while writing the jQuery was that when the user stops mousing over the tabs, the last tab moused over should remain visible, and not revert back to the “active_tab” and “active_tab_content” tab.

$(function() {
 $("#main_middle ul li a").each(function(index) {
  $(this).hover(function() {
   $("#main_middle ul li a").each(function() { $(this).removeClass("active_tab"); });
   $("#main_middle p").each(function() { $(this).removeClass("active_tab_content"); });
   $(this).addClass("active_tab");
   $("#main_middle p:eq("+index+")").addClass("active_tab_content");
  });
 });
});

The jQuery code loops through each of the anchor elements and assigns a hover function to them. The first thing this hover function does is loops through all anchors (tabs) and all paragraphs (tab content) and removes the classes. It then adds the “active_tab” class to the current tab and the “active_tab_content” class to the respective paragraph. It does this through the use of indexes. One each pass through the anchors, the current element index is passed through the function and then used to select the paragraph with the equivalent index via the eq selector. And that’s it. My mistake that I kept running into, was assigning second function to the hover() to activate on mouseout. This function was removing the classes that were being added. This was my moment of brilliance luck when I removed that code by chance and everything worked.

See the code in action here

You can use this code to make as many tabs as you need. Just make sure you have as many paragraph elements as you do list elements and that the content for list item 1 corresponds with the content for paragraph 1. I used inline tabs, but this can easily be done with vertical tabs as well, the logic is still the same. Feel free to copy/use this code for your own purposes. Share a link to your implementations in the comments below and/or how you would have done this differently. Comments are welcome and enjoyed.

I came across an interesting post today titled CSS Sprites w/out Using Background Images. Now obviously I was intrigued as I’ve discussed how to use CSS Sprites before and have really been getting into them lately with some new killer projects I’ve been contracted to do. But this post, I just had to read.

If you read that post, and I suggest you do, you’ll see that the author talks about using Sprites without the use of a CSS Background Image. When I rolled over the examples though, I got a basic sprite functionality. But that’s what he was talking about. Although he mentioned they were just <img /> tags. I just wasn’t seeing it.

Soh Tanaka mentions that the goal was to make it simple for a client who may have multiple affiliate banners to upload and didn’t want his client trying to have to mess with CSS and creating custom classes and code. Good point. The way Soh went about achieving this was simple: Instead of moving the background image of an element, use an <img /> tag with the same sprite image and move the <img /> tag up with negative margins. The theory is identical, the execution is just different.

Instead of setting a background image on the element and doing a background-position: 0 -182px; on the :hover Soh does uses an actual <img /> tag and sets a margin-top: -182px on it (182px was the size of the image, or half of it).

Now as author Chris Heilmann mentioned in the comments, this isn’t the best use of sprites in the world, and kind of defeats the purpose. But the functionality is there and it was something Soh did to make it easier on his client (which we’ve all done) and was just showing the technique for technique’s sake. By the way, Chris authored a fantastic JavaScript/DOM Scripting/AJAX book I have in my Tech Library. It’s definitely worth the read.

Anyways, I just wanted to drop this tip as I stared at it for a while utterly confused and wondering how this tip was any different as all I could see was the same sprite functionality. But, like I said, that’s the point. It still functions the same.

WordPress Woot Watcher

WordPress Woot Watcher, will monitor and check woot, shirt.woot, kids.woot, wine.woot and sellout.woot for new products every 10 hours. When a woot-off is launched, the widget will update the woot product every 30 seconds. WordPress Woot Watcher is a sidebar widget that enables select the woot sites you want to monitor in the administration section. The default installation selects woot.com only.

For all the details, installation, and more, visit the WordPress Woot Watcher page.

array=( ${array[@]-} $(echo "$variable") )

The code above reads as follows:

array=( ….. ) : Set your array variable named, appropriately enough: array.

${array[@]-} : Read all variables from the array array. The hyphen at the end prevents an “unbound variable” error when -u or -o nounset is set and array is an empty array. This is useful for appending the first value to an empty array in the event that one of the aforementioned flags is set.

$(echo “$variable”) : Add the variable $variable to the array through the use of command substitution $(…) by reading the output of echo “$variable” as the input value for the array. The reason for command substitution is that if you try it without the $(…), bash will read echo and “$variable” as separate entries into the array instead of just the value of $variable

One of daily responsibilities as a database administrator is maintaining the health of our shared hosting environment. In doing so, I deal with plenty of WordPress blogs daily. The one thing I have noticed is that many WordPress plugins are very poorly designed and can cause problems in a shared hosting environment. WordPress at it’s core though, is very well designed, although I have noticed some areas of possible improvement. As I come across common issues, I will post the fixes for them here for all to use.

The following is one of the most common queries I see all the time that actually comes from the WordPress core:
SELECT comment_date_gmt
FROM wp_comments
WHERE comment_author_IP = '94.142.131.22' OR
comment_author_email = 'yigrzds@tkgmd.com'
ORDER BY comment_date DESC
LIMIT 1


The IP and email is obviously only sample data. On the example server, the MySQL Explain for the query showed the following:

id: 1
select_type: SIMPLE
table: wp_comments
type: ALL
possible_keys: NULL
key: NULL
key_len: NULL
ref: NULL
rows: 76845
Extra: Using where; Using filesort

Now, a query that examines 76,000+ rows is not the end of the world, but with enough traffic, it can slow down the server immensely, mainly because the explain above indicates that no key is being used on the query and therefore a full table scan is being performed.

To help alleviate this, the following code can be executed from a MySQL command prompt, or a management type interface like phpMyAdmin:

mysql> ALTER TABLE wp_comments ADD INDEX(comment_author_IP), ADD INDEX(comment_author_email)

**Note: The above optimization assumes the default database prefix of “wp”. If your database prefix is different, replace “wp” in the above query with your databases prefix.**

Afterward, the explain on the exact same query returns the following:

id: 1
select_type: SIMPLE
table: wp_comments
type: index_merge
possible_keys: comment_author_IP,comment_author_email
key: comment_author_IP,comment_author_email
key_len: 302,302
ref: NULL
rows: 2139
Extra: Using union(comment_author_IP,comment_author_email); Using where; Using filesort

As you can see, the query now examines 2139 rows as opposed to 76,000+ by using an Index Merge, which means the query is pulling data using two different indexes on the same query. Now keep in mind, index merges are only available in MySQL 5.0+. If you are using MySQL 4.1 or below, an index merge will not work, and I would suggest adding an index on the comment_author_IP field as it will tend to have more unique values. Simply remove everything after the comma in the above command.

This optimization will improve the speed of the query on your database and will provide better performance on your WordPress blog. Please share your thoughts below on this hack and the results for you.