Sadly, Spurl was overwhelmed by spam and disappeared. After that I bumbled around trying to find another service that provided the same functionality. It seemed obvious that lots of people would want this. But no. I managed to get something similar working with Furl.net. But then that was taken over by Diigo (a problem with these services is that they keep disappearing or being taken over). Diigo claimed I could do the same thing, but no matter what I did, it refused to show more than the 3 newest links in a particular category. Not very useful for a blogroll (although I do use it for recent links here — see the sidebar on the home page). Del.icio.us doesn’t seem to have any functionality like this.

Yesterday, while half-heartedly trying to resolve this problem, I happened across Sitebar. Yes, another bookmark manager. But this one is open source, and you can install it on your own server. Complete control! Hastily I installed it (a 5-minute job). Added a few bookmarks and experimented with the RSS feed. Once I’d figured that out, some googling and digging in the WordPress codex came up with a way to get WordPress to read the RSS feed and display it in the sidebar.

<div id="sitebar_linkroll" >
<?php
// Get RSS Feed(s)
include_once(ABSPATH . WPINC . '/feed.php');
// Get a SimplePie feed object from the specified feed source.
$rss = fetch_feed('http://www.archetype-it.com/sitebar/index.php?hits=0&w=rss&mix=nodes&root=16');
if (!is_wp_error( $rss ) ) : // Checks that the object is created correctly
// Figure out how many total items there are, but limit it to 20.
$maxitems = $rss->get_item_quantity(20);
// Build an array of all the items, starting with element 0 (first element).
$rss_items = $rss->get_items(0, $maxitems);
endif;
?>

<ul>
<?php if ($maxitems == 0) echo '<li>No items.</li>';
else
// Loop through each feed item and display each item as a hyperlink.
foreach ( $rss_items as $item ) : ?>
<li>
<a href='<?php echo esc_url( $item->get_permalink() ); ?>'
title='<?php echo 'Posted '.$item->get_date('j F Y | g:i a'); ?>'>
<?php echo esc_html( $item->get_title() ); ?></a>
</li>
<?php endforeach; ?>
</ul>
</div>


Ta-dah! This may seem a bit overkill for a blogroll, but it solves a problem for me. And Sitebar is a nice links manager in itself, even if it looks a little old-fashioned (no trendy tags, just folders!) and hasn’t been updated since 2007. There is a hosted version with free and paid options, but hosting it myself means I don’t need to worry about the service disappearing or changing its terms, and if it does what I want it doesn’t really matter if it’s not being actively maintained. It’s designed to be used in the panel/sidebar area of a browser, hence the name. So I’ve added it to Opera as a panel, where it’s easily accessible for adding links (there’s a Javascript bookmarklet too, for one-click adding, though I haven’t got that working in Opera yet).

Note, of course, that you can use this same PHP code for any RSS feed that you want to incorporate into a WordPress site — just edit the feed URL.

I think this book will be much more accessible than the Williams and Lane one, which had great detailed coverage of PHP and MySQL, but was over-complicated in places. But I’m a little disappointed with several aspects.

By far the biggest disappointment: no coverage of exceptions, a key feature of PHP5. Second biggest: the whole chapter on OOP is pretty inadequate. I don’t teach OOP on my course, but I do encourage students to use pre-built classes for some tasks, such as data validation or sending mail. This chapter takes that approach, but doesn’t explain why using the MySQLi class is any better than just using the non-OOP mysqli_ functions. He could at least have covered PDO here, as it’s more versatile than MySQLi. But again, PDO isn’t mentioned at all — a very surprising omission.

I was also disappointed that while he briefly discusses user-defined functions in the early chapters, he makes no effort to encourage the reader to actually use them in the exercises and case-studies later in the book. All the code is inline, including in places that are crying out for use of functions, such as the shopping cart, user registration, and forum examples. This book is not intended for complete beginners, so it really should do more to encourage good practice and maintainable code. It is nice to include a chapter on using jQuery and AJAX with PHP, but frankly I’d have rather seen this chapter omitted in favour of more coverage of the above topics. I know there’s only so much you can cover in 600 pages (especially when the layout is so inefficient), and different readers’ needs will vary, but some of the priorities here seem wrong to me.

Good points: the coverage of MySQL queries is pretty good, but for my purposes I’d have liked to see better discussion and explanation of database design and ERDs. The Williams and Lane book had a very good appendix covering this. There’s a whole chapter on security, with useful and realistic examples, and Ullman addresses security aspects such as input filtering and escaping throughout the book (often a weak point in introductory PHP books, happily littered with examples using unfiltered POST and GET input “for clarity” — the ever-popular PHP and MySQL Web Development by Welling and Thompson is an egregious example). Finally, he does a good job of building up examples and leading the reader through them. The chapter on form handling is particularly good, and there’s also a whole chapter on regular expressions which does a better job than most of demystifying them. If you are an intermediate PHP coder, you’ll probably find this book useful to improve your skills, and I’m glad to find an up-to-date PHP book I can use for my course. But I’m still looking for the perfect intermediate PHP book!

One last black mark for Peachpit: the 2-column layout really doesn’t work for this material. Code listings drag on for pages because they are squashed into a narrow column, and the whole thibg looks untidy. Why they didn’t use a single-column design is beyond me.

and then a virtual host section for each site, for example:

<virtualhost *:80>
DocumentRoot /Users/myusername/Sites/site1
ServerName site1
</virtualhost *:80>


That sets up the Apache side of things. In order for my computer to know what address to map the site names to, I now need to edit my hosts file. On the Mac it’s in /etc/hosts; on Windows it’s more deeply buried in C:\Windows\System32\drivers\etc. In both cases you need administrator privileges to edit it. Easy enough on the Mac; in Windows you’ll need to run Notepad or another text editor of your choice as administrator (right-click on it in the Start menu as choose “run as administrator”).

For each virtual host that I set up in the Apache config file, I add a line to my hosts file:
127.0.0.1 site1
and that provides the mapping I need so that I can use my browser to go to http://site1 and Apache will serve up the correct site. The address 127.0.0.1 always maps to the local computer (i.e. localhost). But what if I want to access site1 from another computer on the LAN? How will it know where site1 is? That turns out to be easy-peasy.

First, find out the IP address of the computer hosting site1. For example 192.168.1.10. On the second computer, edit the hosts file. Add the line:
192.168.1.10 site1
Et voilà! Now, when I enter http://site1 on the second computer, it will find it on the first computer, even if it’s not the default served up by Apache.

Note, you may hit snags with this system if you use DHCP on your LAN, because the IP addresses of the host computers may change from time to time (e.g. if you reboot them). I recommend using static IPs on your local network for this reason, at least for those computers you are using to host websites.

And in MySQL:
INSERT INTO atable(column1,column2) SELECT 1, 'text' FROM DUAL WHERE NOT EXISTS (SELECT column1 FROM atable WHERE column1=1 AND column2='text' LIMIT 1)

Notice that in MySQL you have to use the dummy DUAL table (which suggests to me that this syntax might work in Oracle too; I haven’t tried it).

But I needed to massage some of the rows in the recordset before writing them to the file. I struggled for a while before finding RSFilter:
$rs2 = RSFilter($rs, 'callbackfunction');

The callback function takes two arguments: the recordset and an array (passed by reference) representing a single row of the recordset (see the example in the link to the documentation above). RSFilter deals with running the function on each row, and returns the duly massaged recordset ready for output to the file.

Most solutions simply display another image (as polite or as rude as you like) in place of the hotlinked image. But I was curious to know who was linking to which images. Some of them might be legitimate users, in which case I could unblock them. Others might need to get a stiff warning about copyright.

For the .htaccess file, I used the technique here. But the author was actually redirecting to another page with the requested image embedded in it. Hey, I’m trying to save bandwidth here! So I wrote a PHP script that would log the access and then display a small generic image advertising the website from which the image had been, er, “borrowed”. Here’s the .htaccess file:

RewriteEngine On
# hotlinked images
RewriteCond %{REQUEST_FILENAME} \.(gif|jpe?g|png)$ [NC]
RewriteCond %{HTTP_REFERER} !^$
RewriteCond %{HTTP_REFERER} !mydomain\.com [NC]
RewriteCond %{HTTP_REFERER} !myotherdomain\.com [NC]
RewriteCond %{HTTP_REFERER} !alegitimatedomain\.com [NC]
RewriteRule (.*) /blockimage.php?imagename=$1 [NC,L]
# end hotlinked images

This file, placed in the images directory, blocks all but the authorised domains and any blank referrers from accessing images. Notice that the image requested is passed to my blockimage.php script in the query string (that’s what the $1 does), because I’m going to use it later.

I could have logged accesses to a text file, but I have a MySQL database so I might as well use it; it will let me do further statistical analysis of the accesses too. I created the following table:

CREATE TABLE Hotlinks (
hotlinkid int(10) unsigned NOT NULL auto_increment,
referrer varchar(255) NOT NULL default '',
imagename varchar(255) NOT NULL default '',
linktime timestamp NOT NULL default CURRENT_TIMESTAMP,
PRIMARY KEY (hotlinkid)
) ENGINE=InnoDB;

I used INNODB for the table type because I reckoned it would be quicker for frequent writes and infrequent reads, but you can use MyISAM if INNODB isn’t available on your server.

Now the PHP code:

<?php
// called when an image is hotlinked
// ... snipped code to connect to database ...
// get the referrer and image name
// first initialise an empty array to hold them
$values = array();
$values['referrer'] = mysql_real_escape_string($_SERVER['HTTP_REFERER']);
// get the image name from the query string thanks to .htaccess
$values['imagename'] = mysql_real_escape_string($_GET['imagename']);
// write it to Hotlinks table using my own insertrow function
$result = insertrow($DB, 'Hotlinks', $values);
// show a nice image advertising my site
$mimetype = 'image/jpeg';
$filename= $_SERVER['DOCUMENT_ROOT'].'/images/sitelogo.jpg';
header('content-type: '.$mimetype);
header('content-length: '.filesize($filename));
readfile($filename);
?>

So after silently logging the access, the PHP code sets the mime type to what the calling page is expecting (an image) and then returns the specified image to the browser. Remember you can’t have any other output (including white space) before the calls to the header function.

Now I can check the database table to see who is accessing what, and if I see any legitimate domains there, I can add them to the “allowed” list in .htaccess.

Ironically I ended up not using this code on the site it was intended for, for various reasons. But I think it’s an interesting and potentially useful technique, so I’m posting it here anyway.


(document).ready(function() {
$("td.standard").click(
function(){
var currentclass = $(this).attr("class");
if (currentclass.indexOf("highlightcell") == -1) {
$(this).addClass("highlightcell");
} else {
$(this).removeClass("highlightcell");
}
}
);
});


Voilà!