Parsing the header is straightforward; the mime-types are separated by commas (note that the top-level separation is the comma, not the semicolon) and within each mime-type description the parameters are separated by semicolons. The first field is the mime-type itself (with possible wild card '*'), the second (if present) is the quality factor, "q={number from 0 to 1}" which describes how much the requestor wants that particular mime-type, and the remainder of the fields are other parameters.

As the specification says, parameters in the Accept: header are rare, and my programs don't use them, so we will ignore them. That means that Accept: text/html; q=0.8; level=2, text/html; q=0.2; level=1 is interpreted the same as Accept: text/html; q=0.2; not exactly the same as the spec but easier to code.

The q parameter technically should be weighted by how much the host wants to send that type. Thus, Accept: image/jpeg; q=1, image/gif; q=0.2 means "Send me a png; I'll accept a jpeg, but I'll be only 20% as happy." If the host feels that the gif is 10 times better than the jpeg, it should rank the gif as 10*0.2 = 2 and the jpeg as 1*1 = 1, and send the gif. My code doesn't have such strong feelings and ignores such niceties.

A q parameter of 0 should be interpreted as "never send me this type" but my code simply ignores it and, if there are no other mime-types in the Accept: header, sends the default. If it's the default type that has the q=0, then the requestor loses.

One subtle trick from Kris Jordan's Recess: wild card ('text/*' and '*/*') types should rank below more specific types with the same q parameter. We subtract 0.0001 from the stated q to push them lower; the specification says the value cannot have more than 3 decimal places.

function parseAccept ($accept){
	$mimetypes = array( // associate types with file extensions
		'*/*' => 'html',
		'text/*' => 'txt',
		'text/plain' => 'txt',
		'text/html' => 'html',
		'text/csv' => 'csv',
		'text/javascript' => 'js',
		'image/*' => 'png',
		'image/png' => 'png',
		'image/gif' => 'gif',
		'image/jpeg' => 'jpg',
		'application/*' => 'js',
		'application/json' => 'js',
		'application/xml' => 'xml'
	);

	$types = array();
	foreach (explode(',', $accept) as $mediaRange){
		@list ($type, $qparam) = preg_split ('/\s*;\s*/', $mediaRange); // the q parameter must be the first one according to the RFC
		$q = substr ($qparam, 0, 2) == 'q=' ? floatval(substr($qparam,2)) : 1;
		if ($q <= 0) continue;
		if (substr($type, -1) == '*') $q -= 0.0001;
		if (@$type[0] == '*') $q -= 0.0001;
		$types[$type] = $q;
	}
	arsort ($types); // sort from highest to lowest q value
	foreach ($types as $type => $q){
		if (isset ($mimetypes[$type])) return $mimetypes[$type];
	}
	return 'html';
}

The same sort of code would work for Accept-Encoding: and the other Accept-type headers.

I want to get it to parse the Accept: header, so users can leave out the file extensions, but it looks like browsers don't implement that correctly, so I'll have to keep using extensions as well.

I still need to learn more about caching and effectively using eTags and all the headers that go with it. It always makes my brain hurt.

1. Create the new folder, bililite.com/blog/
2. Create a new mySQL database on bililite.com
3. Copy all of youngisrael-stl.org/wordpress/ into bililite.com/blog/
4. Edit the wp-config.php file to reflect the new database name/user/password
5. Backup the youngisrael-stl.org database into an SQL file with phpMyAdmin or some other tool
6. In a text editor, change all the "http://youngisrael-stl.org/wordpress" to "http://bililite.com/blog" and "/wordpress" to "/blog". note that there are both absolute and relative URL's in there, and I was changing both the domain and the subdirectory, so I had to do two replacements. I couldn't just change "http://youngisrael-stl.org" because I didn't want to change links to the actual site.
7. Run the edited SQL file on the bililite.com database
8. In the youngisrael-stl.org/.htaccess , add the line "Redirect permanent /wordpress http://bililite.com/blog" to let browsers know I've moved
9. Actually announce the change on mailing lists of people who actually read the site

They key is that while I can't schedule tasks to run, I can count on one event happening at least a couple times a day: hits on the website. So I add a require_once('/path/to/scripts/scheduler.php') at the start of every page, and, as long as the scheduled tasks don't take too long, the website user never notices that I'm taking advantage of him.

At each call, the script pulls a single job to run from a mySQL database, runs it and updates the next scheduled time.

The table 'schedule' has 4 fields:

id: Varchar

Unique identifier for that job.

frequency: Varchar

How often to run the job. Will be passed to strtotime. Typical values 'next week', 'next Sunday', 'next month', 'next year'.

If it evaluates to a day in the past, the year is incremented until it is in the future. That way 'April 15' will be the coming April 15.

Special case: numbers are interpreted as days of the month (at midnight); '28' will run on the next 28th of the month. Use 0 for the last of the month, -1 for the second to last of the month.

Note that this uses mktime which corrects dates forward; so a frequency of 31 will trigger on Jan 31, Mar 2, Mar 31, May 1, May 31, Jul 1, Jul 31, Aug 31, Oct 1, Oct 31 and Dec 1. Again, use 0 for the last day of the month

Note: you can do things like '+6 hours' for time scheduling as well, though I haven't tested this.

scheduled: Datetime

The next scheduled run time; set to NULL or a point in the past to have the job run immediately

command: Text

Text that will be passed unchanged to eval.

// for debugging, use 'example.com/scheduler.php?scheduledebugdate=2009-02-12' to force the script
// to pretend that the current time is 2009-02-12
	$now = $_GET['scheduledebugdate'] ? strtotime($_GET['scheduledebugdate']) : time();
	$sqlnow = date ('Y-m-d H:i:s', $now);
	$sql = mysql_connect($server, $user, $password); mysql_select_db ($database, $sql);
	$result = mysql_query ("SELECT * FROM schedule WHERE `scheduled` IS NULL OR `scheduled` <= '$sqlnow' LIMIT 1", $sql);
	// note only one job at a time; otherwise the website user who doesn't know he's triggering
	// this code may wait forever. Change the LIMIT term if you want to run more than one job
	while ($row = mysql_fetch_assoc ($result)) {
		eval($row['command']);
		$f = $row['frequency'];
		if (is_numeric($f)){
			$d = getdate($now);
			do {
				$nexttime = mktime($d['hours'], $d['minutes'], $d['seconds'], $d['mon']++, $f, $d['year']);
			}while ($nexttime <= $now);
		}else{
			$nexttime = strtotime($f, $now);
			while ($nexttime <= $now) $nexttime = strtotime('+1 year', $nexttime);
		}
		$nexttime = date ('Y-m-d H:i:s', $nexttime);
		mysql_query ("UPDATE schedule SET `scheduled`='$nexttime' WHERE `id` = '${row['id']}'", $sql);
	}

So I had to write my own backup, going through each database on a server then each table in the database, writing the appropriate INSERT INTO commands (thank goodness the SHOW CREATE DATABASE and SHOW CREATE TABLE commands work correctly). It wasn't terribly miserable (not nearly as miserable it was trying to use someone else's tool that doesn't work), and now I get my  אריאל מאיר יעקב בן דוד אברהם just fine, and the backup works. I import the generated file into my local copy of mySQL and it regenerates the databases.

// if this file is called directly from the web, run the backup on the requested databases
if (realpath(__FILE__) == realpath($_SERVER['SCRIPT_FILENAME'])) db_backup($_REQUEST['database']);

function db_backup($databases){
	if (!is_array($databases)) $databases = array($databases);
	$dir = '/backup'; // change this as desired
	if( !is_dir( $dir ) && !mkdir( $dir )) die('<h1>Could not create backup directory</h1>'); 
	foreach ($databases as $database){
		list($host, $name, $user, $password) = explode('/', $database);
		$now = date('Y-m-d'); // change this as desired
		@mysql_connect($host, $user, $password) or die ("<h1>Could not connect to $host</h1>");
		file_put_contents("$dir/$name-$now.sql", dump_dbs());
	}
}

// based on http://davidwalsh.name/backup-mysql-database-php
function dump_dbs(){
	$ret = '';
	$dbs = mysql_list_dbs();
	while ($db_row = mysql_fetch_object($dbs)) {
		$db = $db_row->Database;
		if ($db == 'information_schema') continue;
		mysql_select_db ($db);
		mysql_query("SET NAMES 'utf8'");  // magic command to make mySQL output UTF8 to PHP
		$ret = "DROP DATABASE IF EXISTS `$db`;\n";
		$createdb = mysql_fetch_row(mysql_query("SHOW CREATE DATABASE `$db`"));
		$ret .= $createdb[1].";\nUSE `$db`;\n";
		$tables = mysql_query('SHOW TABLES');
		while($table = mysql_fetch_row($tables)){
			$ret .= dump_table($table[0]);
		}
	} // while
	return $ret;
}

function dump_table($table){
	$ret = "\nDROP TABLE IF EXISTS `$table`;\n";
	$createtable = mysql_fetch_row(mysql_query("SHOW CREATE TABLE `$table`"));
	$ret .= $createtable[1].";\n";
	$dbresult = mysql_query ("SELECT * FROM `$table`");
	while($row = mysql_fetch_assoc($dbresult)) {
		$keys = fixkeys(array_keys($row));
		$values = fixvalues(array_values($row));
		$ret .= "\tINSERT INTO `$table` (".join(',', $keys).') VALUES ('.join(',',$values).");\n";
	}
	return $ret;
}
function fixkeys ($arr){
	foreach ($arr as &$i){
		$i = "`$i`";
	}
	return $arr;
}
function fixvalues($arr){
	foreach ($arr as &$i){
		$i = is_null($i) ? 'NULL' : "'".preg_replace("/\r\n|\n|\r/",'\n',addslashes($i))."'";
	}
	return $arr;
}

The main function db_backup takes a string or an array of strings that describe the databases to be backed up, of the form 'host/name/user/password'. For the databases that my host provides it would look like 'db12345.perfora.net/descriptivename/dbo45678/password', where descriptivename is whatever you want prepended to the backup file, which is named 'descriptivename-2009-02-09.sql' or whatever the date is.

If it is called directly as a web page, the database strings are taken from the query string with key "database". If you want to pass more than one database, don't forget to use database[]= to make it into a PHP array. Thus,

http://example.com/db_backup.php?database=db12345.perfora.net/serverdata/dbo45678/password

or

http://example.com/db_backup.php?database[]=db12345.perfora.net/serverdata/dbo45678/password&database[]=localhost/localdata

I hope this saves someone a whole lot of agony!