yum fun

Every once in a while you may need to install a specific version of a package on your system. If you're using the yum package manager, it isn't blatantly obvious how to do this, even after pouring over the man pages.

So let's do this thing.

First, if you've already installed a newer version of the package, you'll have to downgrade it. In that case, make sure you've got yum's downgrade plugin installed:

# yum install yum-allowdowngrade

Second, do you know exactly which package version you want to install? If not, list the all available versions using the --showduplicates flag. This example looks for available versions of the GD extension for PHP.

# yum --showduplicates list php-gd

Available Packages
php-gd.i386                    5.2.3-3.el5s2                        testing
php-gd.i386                    5.2.6-2.el5s2                        testing
php-gd.i386                    5.2.9-2.el5.centos                   testing
php-gd.i386                    5.2.10-1.el5.centos                  testing

Yum is based on the RPM package manager, and it's package names are based on the RPM package label format. In the above example, the first column displays the package name and architecture in the format NAME.ARCHITECTURE. The middle column displays the version and release info in the format VERSION-RELEASE. Don't ask me why yum rearranges the RPM package label format.

Anyways, if you're downgrading, remove the previous package:

# yum remove php-gd

Now that you know which version to install, it's a matter of specifying the package name with the version. Use the format NAME-VERSION.

# yum install php-gd-5.2.6

Or if you want to get even more specific, use NAME-VERSION-RELEASE (which might be easier to copy/paste since VERSION-RELEASE is the second column).

# yum install php-gd-5.2.6-2.el5s2

If you're downgrading, you may need to throw in the --allow-downgrade flag.

# yum --allow-downgrade install php-gd-5.2.6

And you should be good to go. If you want to lock the version you installed to prevent any future updates, install the versionlock plugin.

# yum install yum-versionlock

Then lock it.

# yum versionlock php-gd

Ping a Windows box

Platforms:
any *nix distro

What You'll Need:
Samba

In a heterogeneous LAN it is often useful to resolve network addresses by a computer's name (ie. netbios name). This is especially true if the LAN does not have a DNS server so that host names can be used instead of IP addresses (which if dynamically assigned, could change often).

To enable Windows netbios name resolution from a Linux computer, make sure that Samba is installed (although the smb service does not need to be running). The Samba suite includes winbind, which enables Windows host names to be resolved.

Then edit /etc/nsswitch.conf and change this line:

hosts:      files dns

to this:

hosts:      files dns wins

Then test by pinging the computer name of Windows machine on the LAN:

$ ping windowsbox
PING windowsbox (192.168.0.100) 56(84) bytes of data.
64 bytes from 192.168.0.100: icmp_seq=1 ttl=128 time=0.117 ms
64 bytes from 192.168.0.100: icmp_seq=2 ttl=128 time=0.127 ms
64 bytes from 192.168.0.100: icmp_seq=3 ttl=128 time=0.127 ms
64 bytes from 192.168.0.100: icmp_seq=4 ttl=128 time=0.127 ms
64 bytes from 192.168.0.100: icmp_seq=5 ttl=128 time=0.128 ms

This setting really comes in handy when mounting a shared folder of a dynamically IP'ed Windows box from Linux. Instead of using the Windows' box IP address, just specify it's netbios name. Example entry in /etc/fstab:

//windowsbox/my_share/ /mnt/my_mount_point/ cifs rw,username=xxx,password=xxx,domain=xxx 0 0

javascript array

AJAX communication between the client browser and web server is a handy method of transferring data without forcing the user to refresh the page. Typically, the data sent to the server is a simple set of form fields or flags. However, it is also possible to submit more complex structured data. This tutorial will demonstrate 3 different methods used to pass multidimensional javascript arrays using jQuery and AJAX to a PHP web server.

The Wrong Way

My first instinct was that multidimensional JS arrays could be passed directly to jQuery's AJAX functions. I expected that the array would be automatically preserved in the request, and show up in PHP's $_GET/$_POST variables. The following example shows this doesn't work.

The code below attempts to post a JS associative array ("data", line 9) to the web server using jQuery's $.ajax() function. The $.ajax() function is jQuery's lowest level AJAX function, but still provides a high level approach and lots of options.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" dir="ltr" lang="en-US">
    <head profile="http://gmpg.org/xfn/11">
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>jQuery AJAX arrays</title>
        <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"></script>
        <script type="text/javascript">
                sendAjax = function(){
                    var data = {
                                  foo:  123,
                                  bar:  456,
                                  rows: [
                                          {
                                            column1 : 'hello',
                                            column2 : 'hola',
                                            column3 : 'bonjour',
                                          },
                                          {
                                            column1 : 'goodbye',
                                            column2 : 'hasta luego',
                                            column3 : 'au revoir',
                                          },
                                        ],
                                  test1:{
                                          test2: {
                                                   test3:  'baz'
                                                 }
                                        }
                                };

                    $.ajax({
                            type:           'post',
                            cache:          false,
                            url:            './ajax/',
                            data:           data
                           });
                }

        </script>
    </head>
    <body>
        <input type="button" style="width: 130px; height: 60px" value="send AJAX" onclick="sendAjax();" />
    </body>
</html>

When the button is clicked, the following data shows up in PHP's $_POST variable:

Array
(
    [foo] => 123
    [bar] => 456
    [rows] => [object Object]
    [test1] => [object Object]
)

As shown, the first level of the array data is preserved (keys "foo" and "bar"). However, jQuery simply calls .toString() on the nested arrays at keys "rows" and "test1", and they get passed to PHP with the useless values "[object Object]".

Method 1 - Form input arrays

It's possible to name the keys of the JS array as HTML form input arrays (ie. named with square brackets) so that PHP decodes the array's key names as nested arrays. I don't recommend this method because it does not maintain the JS array's original structure in the Javascript. However, it can be used if you just need to get the AJAX request working without using JSON.

The original JS "data" array can be renamed/restructured as:

sendAjax = function(){
	var data = {
				  foo:  123,
				  bar:  456,
				  'rows[0][column1]':    'hello',
				  'rows[0][column2]':    'hola',
				  'rows[0][column3]':    'bonjour',
				  'rows[1][column1]':    'goodbye',
				  'rows[1][column2]':    'hasta luego',
				  'rows[1][column3]':    'au revoir',
				  'test1[test2][test3]': 'baz'
				};
	$.ajax({
			type:           'post',
			cache:          false,
			url:            './ajax/',
			data:           data
		   });
}

And the data is correctly received in PHP's $_POST variable:

Array
(
    [foo] => 123
    [bar] => 456
    [rows] => Array
        (
            [0] => Array
                (
                    [column1] => hello
                    [column2] => hola
                    [column3] => bonjour
                )

            [1] => Array
                (
                    [column1] => goodbye
                    [column2] => hasta luego
                    [column3] => au revoir
                )
        )

    [test1] => Array
        (
            [test2] => Array
                (
                    [test3] => baz
                )
        )
)

Method 2 - JSON string parameter

This method converts the JS array to a JSON string, and passes it as a POST or GET parameter, which can be manually decoded back into an array by PHP. Modern browsers (Firefox 3, IE 8) now have a native JSON object that can be used to stringify JS arrays to JSON strings. The following example uses the YUI JSON utility to convert the JS array to a string ( json2 is another populary lightweight utility for handling JSON).

sendAjax = function(){
	var data = {
				  foo:  123,
				  bar:  456,
				  rows: [
						  {
							column1 : 'hello',
							column2 : 'hola',
							column3 : 'bonjour',
						  },
						  {
							column1 : 'goodbye',
							column2 : 'hasta luego',
							column3 : 'au revoir',
						  },
						],
				  test1:{
						  test2: {
								   test3:  'baz'
								 }
						}
				};
	data = YAHOO.lang.JSON.stringify(data);

	$.ajax({
			type:           'post',
			cache:          false,
			url:            './ajax/',
			data:           {myJson:  data}
		   });
}

On the PHP side, it's necessary to use json_decode() to convert the JSON $_POST parameter string (named "myJson") to an array:

<?php
$data = json_decode($_POST['myJson'], true);
print_r($data);

And the array is good to go:

Array
(
    [foo] => 123
    [bar] => 456
    [rows] => Array
        (
            [0] => Array
                (
                    [column1] => hello
                    [column2] => hola
                    [column3] => bonjour
                )

            [1] => Array
                (
                    [column1] => goodbye
                    [column2] => hasta luego
                    [column3] => au revoir
                )
        )

    [test1] => Array
        (
            [test2] => Array
                (
                    [test3] => baz
                )
        )
)

Method 3 - JSON content-type

My favorite method is to simply JSON stringify the JS array, and pass it as the AJAX request's body. This requires that the content-type of the request be changed from the default "application/x-www-form-urlencoded" to "application/json", and that $.ajax()'s processData parameter be set to false so that the JSON data is not converted into a query string. Also, the type of request must be POST, as the GET method does not support submitting data in the request body.

sendAjax = function(){
	var data = {
				  foo:  123,
				  bar:  456,
				  rows: [
						  {
							column1 : 'hello',
							column2 : 'hola',
							column3 : 'bonjour',
						  },
						  {
							column1 : 'goodbye',
							column2 : 'hasta luego',
							column3 : 'au revoir',
						  },
						],
				  test1:{
						  test2: {
								   test3:  'baz'
								 }
						}
				};
	data = YAHOO.lang.JSON.stringify(data);

	$.ajax({
			type:           'post',
			cache:          false,
			url:            './ajax/',
			data:           data,
			processData:    false,
			contentType:   'application/json'
		   });
}

On the PHP side, it's necessary to manually read the JSON string directly from the request body using the php://input stream. The returned string can then be decoded into an array:

<?php
$data = file_get_contents('php://input');
$data = json_decode($data, true);
print_r($data);

Which gives us the array:

Array
(
    [foo] => 123
    [bar] => 456
    [rows] => Array
        (
            [0] => Array
                (
                    [column1] => hello
                    [column2] => hola
                    [column3] => bonjour
                )

            [1] => Array
                (
                    [column1] => goodbye
                    [column2] => hasta luego
                    [column3] => au revoir
                )
        )

    [test1] => Array
        (
            [test2] => Array
                (
                    [test3] => baz
                )
        )
)

Hopefully this tutorial has helped you get multidimensional array data passed to your webserver using AJAX. If you know of another method, please submit it in the comments - thanks!

PuTTY

By default, your keyboard's numlock enabled number pad doesn't work well with console applications running on a PuTTY SSH connection. The numpad's numbers seem to get mapped to inserting the characters "q" thru "y". This is especially annoying when using vim.

To get numlock working, open PuTTY's configuration window, goto Terminal > Features. Enable the "Disable application keypad mode" checkbox.

If you want this setting to persist, make sure to select a saved session and click "Save".

Close the browser's connection

Sometimes you need to execute a really long process after displaying a web page. For example, you may need to evaluate the data a user submitted, and that operation may take a lot of time. And since you're a thoughtful programmer, you don't want make the user stare at a blank page while they wait for the process to finish.

A good solution is to display a confirmation page and then close the browser's connection to the web server. Closing the browser's connection will cause the browser to stop "spinning" and display a "Done" status. The user can then feel assured that their part in the matter is over with, and can navigate elsewhere. In the meantime, your PHP (or whatever language) continues executing on the server. You could even get fancy with it, and use AJAX to display the script's execution progress to the user on the confirmation page.

The key to doing this are the two HTTP header fields:

Connection: close
Content-Length: n (n = size of output in bytes )

The "Connection: close" header lets the browser know that it should not maintain a persistent connection. The "Content-Length: " header tells the browser how much data to expect. Thus, it's necessary to supply the size of the output (in bytes) using "Content-Length: ". Then the browser knows when it's downloaded everything and can terminate the connection.

Example 1 - Basic Usage

<?php
// buffer all upcoming output
ob_start();
echo "Here's my awesome web page";

// get the size of the output
$size = ob_get_length();

// send headers to tell the browser to close the connection
header("Content-Length: $size");
header('Connection: close');

// flush all output
ob_end_flush();
ob_flush();
flush();

/******** background process starts here ********/

Example 2 - embedded PHP with execution progress updates

View the demo

This basic example executes some arbitrary time consuming code in the background, after the user clicks the submit button. Notice that after clicking submit, the browser displays the web page and stops downloading. Also, as a bonus, the execution progress of the script is displayed periodically using Prototype's PeriodicUpdater ajax calls.

• Lines 02 - 19:  AJAX handler that returns the progress of the background execution to the AJAX calls. It's basically reading the contents of the progress file to the browser.
• Lines 22 - 35:  Creates a uniquely named temporary file to track the background process's execution. It also buffers all output (Line 034) so that we can calculate the size of all the content. The size will be sent in the "Content-Length: " header.
• Lines 37 - 85:  HTML content. The javascript in Lines 68 - 80 setup a Prototype PeriodicUpdater. It checks on the status of the background script every 1 second.
• Line 88:  Calculates the size of the buffered output in bytes.
• Lines 90 -98:  Sends the 2 necessary headers to the browser, and flushes all buffered output to the browser.
• Lines 100 - 115:  This is where the background process should be executed. In the example, some time consuming code is executed, and it's progress (ie. "Executing step n...") is written to a temporary progress file.

Demo source code

<?php
    // ajax updater handler
    if (isset($_POST['ajax']) && $_POST['pidFile']){
        // clean input
        $pidFile = preg_replace('/[^\w\d]/', '', $_POST['pidFile']);
        $pidFile = "../cache/$pidFile";

        if (! file_exists($pidFile)){
            header('HTTP/1.1 500 Internal Server Error');
            exit;
        }
        if(! $progress = file_get_contents($pidFile)){
            header('HTTP/1.1 500 Internal Server Error');
            exit;
        }

        echo nl2br($progress);
        exit;
    }

    // was form submitted?
    if(isset($_POST['submitted'])){
        // create a unique file to track script progress
        $pidFile = tempnam('../cache', '');

        // create the file for writing
        $fh = fopen($pidFile, 'wrx+');
        if (! $fh){
            print "failed to create the file";
            exit;
        }

        // buffer all upcoming output
        ob_start();
    }
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
    <head profile="http://gmpg.org/xfn/11">
        <title>Zulius :: Close Browser Connection :: Example #1 Inline PHP</title>
        <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/prototype/1.6.1.0/prototype.js"></script>
        <style>
            body{ text-align: center; margin: 20px auto; font-family: Arial, Helvetica, sans-serif;}
            div#progress{ min-height: 220px; margin: 10px auto}
        </style>
    </head>
    <body>
        <h1>
        <?php
        if(isset($_POST['submitted'])){
            echo 'background process started';
        }
        else{
            echo 'click to start background process';
        }
        ?>
        </h1>
        <div id="progress">
        </div>
        <form method="POST">
            <input type="submit" name="submitted" value="Go!">
        </form>
    </body>
    <?php
        if(isset($_POST['submitted'])){
        // show progress in browser
    ?>
        <script type="text/javascript">
            updater = new Ajax.PeriodicalUpdater({success: 'progress'}, '<?php echo $_SERVER['REQUEST_URI'] ?>',
                                                { method: 'post',
                                                  frequency: 1,
                                                  decay: 1,
                                                  parameters: {
                                                               ajax: 1,
                                                               pidFile: '<?php echo basename($pidFile) ?>'
                                                             },
                                                  onFailure: function(){ this.stop(); }
                                                });
            setTimeout('updater.stop()', 15000);
        </script>
    <?php
        }
    ?>
</html>
<?php
if(isset($_POST['submitted'])){
    // get the size of the output
    $contentLength = ob_get_length();

    // these headers tell the browser to close the connection
    // once all content has been transmitted
    header("Content-Length: $contentLength");
    header('Connection: close');

    // flush all output
    ob_end_flush();
    ob_flush();
    flush();

    /******** background process starts here ********/
    for($i=1;$i<=10;$i++){
        if(fwrite($fh, "Executing step $i...\n") == false){
            print "failed to write to the file: " . error_get_last();
            exit;
        }
        sleep(1);
    }

    fwrite($fh, "Done!\n");
    sleep(2);

    fclose($fh);

    // delete the progress file
    unlink($pidFile);

}

Example 3 - include embedded PHP file

If you've separated the HTML from your main script, it's very easy to close the browser connection. Just capture the output from your include command, get the size of the content, and send the headers and content:

// capture output of include file in buffer
ob_start();
include '/path/to/your/content/file';

// get the size of the output
$contentLength = ob_get_length();

// these headers tell the browser to close the connection
// once all content has been transmitted
header("Content-Length: $contentLength");
header('Connection: close');

// flush all output
ob_end_flush();
ob_flush();
flush();

/******** background process code here ********/

Background Process

If your background process is vital and could take a lot of time, make sure to set these flags at the top of your script:

ignore_user_abort(true);
set_time_limit(0);

ignore_user_abort(true) will prevent the script from halting if the user happens to push the browser's stop button before the connection is closed. set_time_limit(0) will prevent your script from being terminated if it surpasses the max_execution_time set in php.ini.

Related post: Close browser connection with Zend Framework

Postfix config

Platforms:
any Linux distro

What You'll Need:
Postfix 2.2+
cyrus-sasl 2.1.19+
email account

A typical email scenario: you're a developer, and you've got a development Linux box at home. You need to be able to send emails from your code or cron jobs, but you're too lazy to set up a full fledged email server on your LAN. Or you just want to use your email account provided by your ISP.

Enter the Postfix.

Most Linux distros come with Sendmail already installed, and is usually the default mail client used by the running services. However, Postfix beats the crap out of Sendmail and is a complete, seamless replacement. Here's how I got it going on my CentOS box.

Install

Install Postfix and cyrus-sasl with your application manager of choice. If you're compiling from source, be sure to make Postfix with the -DUSE_SASL_AUTH flag for SASL support and -DUSE_TLS for TLS support.

$ yum install postfix cyrus-sasl

Stop the sendmail service

$ /etc/init.d/sendmail stop

Remove sendmail from the startup runlevels

$ chkconfig --del sendmail

Typical Setup

Edit /etc/postfix/main.cf

# Set this to your server's fully qualified domain name.
# If you don't have a internet domain name,
# use the default or your email addy's domain - it'll keep
# postfix from generating warnings all the time in the logs
mydomain = local.domain
myhostname = host.local.domain

# Set this to your email provider's smtp server.
# A lot of ISP's (ie. Cox) block the default port 25
# to prevent spamming.  So we'll use port 80
relayhost = yourisp.smtp.servername:80

smtpd_sasl_auth_enable = yes
smtpd_sasl_path = smtpd
smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd
smtp_sasl_type = cyrus
smtp_sasl_auth_enable = yes

# optional: necessary if email provider uses load balancing and
# forwards emails to another smtp server
# for delivery (ie: smtp.yahoo.com --> smtp.phx.1.yahoo.com)
smtp_cname_overrides_servername = no

# optional: necessary if email provider
# requires passwords sent in clear text
smtp_sasl_security_options = noanonymous

There's roughly a 99.9% chance that your email provider's SMTP server requires authentication. We need to set that up with the username and password given by your email provider.

Add the following line to /etc/postfix/sasl_passwd

# The server info must exactly match the value
# for "relayhost" in /etc/postfix/main.cf
yourisp.smtp.servername:80 username:password

Generate a postfix lookup table from the previous file

$ postmap hash:/etc/postfix/sasl_passwd

Test the lookup table, if all is good then the following will return the specified username:password

$ postmap -q yourisp.smtp.servername:80 /etc/postfix/sasl_passwd

Get rid of the clear text password file

$ rm /etc/postfix/sasl_passwd

Add postfix to be started at boot

$ chkconfig --add postfix

Fire up Postfix

$ /etc/init.d/postfix start

Test it out using sendmail from the command prompt

$ sendmail email@example.com
Postfix is all up in dis hizzle.
.

Gmail Setup

If you're attempting to relay mail using Gmail, then it will be necessary to use TLS with Postfix. You'll have to point Postfix at your server's trusted CA root certificate bundle, but luckily "...client-side certificates are not required when relaying mail to GMail".

First, double-check that Postfix was configured with SSL support (ie. ldd should return at least one line starting with libssl):

$ whereis -b postfix
postfix: /usr/sbin/postfix /etc/postfix /usr/libexec/postfix
$ ldd /usr/sbin/postfix
...
libssl.so.6 => /lib/libssl.so.6 (0x00111000)
...

Now we need to find your server's CA root certificate bundle, which is typically distributed with openssl. The bundle file is used by Postfix to verify Gmail's SSL certificate (signed by Thawte). On my CentOS server, this file was located at /etc/pki/tls/certs/ca-bundle.crt, but may be in a different location on your box (ie. /etc/ssl/certs).

$ locate ca-bundle.crt
/etc/pki/tls/certs/ca-bundle.crt

Edit /etc/postfix/main.cf with the following values:

relayhost = smtp.gmail.com:587

# your FQDN, or default value below
mydomain = local.domain

# your local machine name, or default value below
myhostname = host.local.domain
myorigin = $myhostname

# SASL
smtpd_sasl_path = smtpd
smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd
smtp_sasl_type = cyrus
smtp_sasl_auth_enable = yes
smtp_sasl_security_options = noanonymous

# TLS
smtp_sasl_tls_security_options = noanonymous
smtp_use_tls  = yes
smtp_tls_CAfile = /path/to/your/ca-bundle.crt
smtp_sasl_tls_security_options = noanonymous

If you haven't already, add the following to /etc/postfix/sasl_passwd

# The server info must exactly match the value
# for "relayhost" in /etc/postfix/main.cf
smtp.gmail.com:587 username:password

Generate a postfix lookup table from the previous file

$ postmap hash:/etc/postfix/sasl_passwd

Get rid of the clear text password file

$ rm /etc/postfix/sasl_passwd

Restart postfix and send a test email

$ postfix reload
$ sendmail email@example.com
Test relay thru Gmail
.

Troubleshooting

Monitor postfix mail log in a separate session with the following command

$ tail -f /var/log/maillog

If the log is displaying the following error

(Authentication failed: cannot SASL authenticate to server ...: no mechanism available)

then set this variable in /etc/postfix/main.cf

smtp_sasl_security_options = noanonymous

If the log is displaying this error

553 Sorry, that domain isn't in my list of allowed rcpthosts. (in reply to RCPT TO command)

check your username and password in /etc/postfix/sasl_passwd. Your user name is usually your full email address. If you have to fix it, don't forget to use postmap to generate a new lookup table.

Noise on a commit failure

TortoiseSVN is an excellent Subersion client for Windows. By default, TortoiseSVN makes noise when it encounters a warning or an error. This almost made me crap a brick when TortoiseSVN failed on a commit and I forgot I had my speakers cranked to eleven.

TortoiseSVN does not have an internal setting to disable sounds, so we'll have to manually disable it's noise in the Windows control panel:

1. Right click anywhere, select TortoiseSVN > Settings > General Menu > Click "Configure" button next to System Sounds. Or go to Start > Control Panel > Sounds and Audio Devices > Sounds Tab.

   

2. Look in the “Program Events” box for TortoiseSVN:

   

3. Click on each of TortoiseSVN's events, and select "(None)" from the Sounds dropdown.
4. Click OK.

grep returns .svn metadata files

What You'll Need:
grep 2.5.3+

I can't count how many times a day I use grep. It is an indispensable tool for searching the contents of configuration files, data files, and source code.

One of the annoying side effects of grep is when searching a Subversion working copy recursively, all the hidden .svn directories also get searched. This can yield a lot of false positive matches since these directories contain "pristine copies of all version-controlled files".

If you've got grep 2.5.3 or higher, it's easy to ignore .svn directories with the "--exclude-dir" option:

$ grep -r --exclude-dir='.svn' 'my search string' /some/directory

But that's a lot to type in each time you want to search your source code. To save keystrokes, try setting up an alias in your home directory's .bashrc file that utilizes the --exclude-dir option (for Mac, use your home directory's .profile file.). I call mine devgrep:

alias devgrep="grep --exclude-dir='.svn'"

After adding the alias, don't forget to source your .bashrc:

$ source ~/.bashrc

Now whenever you need to search a Subversion working copy recursively, use the new alias to skip .svn directories:

$ devgrep -rin 'doctype' /var/www/html/templates
./foo.tpl:1:<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
./bar.tpl:1:<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
./baz.phtml:1:<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">

You can also exclude file types when grep'ing. If you're a vim user, it can be helpful to skip .swp files in your alias:

alias devgrep="grep --exclude-dir='.svn' --exclude='*.swp'"

Yet another workaround would be to use ack - a Perl based, juiced up version of grep with a lot more features.

The Symptoms

There are quite a few things that can cause the Wordpress WYSIWYG editor to break. Using GoDaddy's free hosting service is certainly one of them. A couple ways that you can tell you're experiencing the "GoDaddy" problem:

1. On the "Write Post" page, the post toolbar looks like this:

Instead of this:

2. After browsing to the "Write Post" page in Firefox, open the error console by going to Tools > Error Console. This will is displayed:

3. Clicking the "HTML" button does nothing.

The Fix

Correcting this error involves a slight edit to one of the core Wordpress PHP files, namely "script-loader.php". Please do so at your own risk. This fix has been tested on Wordpress 2.6.3 with IE7 and Firefox 3.

Step 1

Fire up your FTP client and FTP into the website you've got hosted on GoDaddy's server. I used FireFTP in this example. From here on, we'll assume that Wordpress is installed in the "/blog" directory.

Step 2

We've got to get the TinyMCE Javascript code from the Javascript cache on the server. Browse to the "/blog/wp-content/uploads/js_cache" directory in your FTP client.

Look for a file named like this:

tinymce_(a bunch of numbers and letters).gz

Download it. Extract the contents of the file (you can use WinRar, Winzip, or 7-Zip). Rename the extracted javascript file from:

tinymce_(a bunch of numbers and letters)

to:

tinymce_fixed.js

Upload tinymce_fixed.js to the "/blog/wp-content/uploads/js_cache" directory on the GoDaddy server.

Note: If the file "tinymce_(a bunch of numbers and letters).gz" doesn't exist on the GoDaddy server, but a file named "tinymce_(a bunch of numbers and letters).js" does, then rename the .js file to "tinymce_fixed.js" without the quotes. No downloading or extracting is required.

If the js_cache directory doesn't exist, then either Wordpress doesn't have write permission to the wp-content folder, or you haven't opened the "Write Post" page yet.

Step 3

In your FTP client, download the file "/blog/wp-includes/script-loader.php".

Open script-loader.php in your favorite editor, and comment out line 41. Beneath that, insert the following new line of code:

$scripts->add( 'tiny_mce', '/wp-content/uploads/js_cache/tinymce_fixed.js', array('editor_functions'), $mce_version );

The code should now look like this:

//$scripts->add( 'tiny_mce', '/wp-includes/js/tinymce/tiny_mce_config.php', array('editor_functions'), $mce_version );
$scripts->add( 'tiny_mce', '/wp-content/uploads/js_cache/tinymce_fixed.js', array('editor_functions'), $mce_version );

Upload and replace the script-loader.php file on the GoDaddy server. You should then be good to go. Also, make sure the "Use the visual editor when writing" option is enabled on your Wordpress profile page.

Notes

Please be aware that if you upgrade Wordpress, you'll have to repeat this process to get the visual editor working again. Same thing if you re-configure TinyMCE's settings in any way.

Conclusion

GoDaddy's free hosting service places an ad at the top of your content using injected Javascript. This seems to happen regardless of the response content-type headers when a PHP page is requested.

As a programmer, I went far too long not knowing how to do this with vim (one of my favorite editors). It's so easy, even Mike Tyson could do it. And he never learned to read.

1. Enter VISUAL LINE mode by holding [SHIFT] and hitting the "v" key.
2. Use the arrow keys or "j" and "k" to select the lines you want to indent.
3. Hit the ">" character (hold [SHIFT] and hit the "." key) to indent.

Then, you can repeat the indent using the "." key. Likewise, you can type the "<" character to outdent the selected lines.