For the last two years, we’ve had some version of an autorun virus floating around on the old macs.  When you plugged your flash drive into the mac, it would write an autorun.inf file and a hidden .exe file onto the flash drive.

Now, we’ve upgraded to PCs with Windows XP.  It only took a few months for the entire network to become infected.  I think the tech coordinator may have quashed the virus in the media center computers, but I think it’s still alive and kicking in my classroom.  Unfortunately, due to the user permissions she set, I can’t effectively clean it off my computer.

Instead, I follow a ritual in cleaning the files off my flash drive. If you’re facing a similar problem, check out the quick guide I wrote for Associated Content on how to clean an autorun.inf file off your flash drive. It shows you how to delete the files from a command prompt as well as how to write a batch file to automatically delete the files with a simple click of the mouse.

The plugin allows you to insert a Digg This badge in  your posts, but only have it appear if your post has a certain number of Diggs.  The idea is that you don’t want to promote the fact that your article only has one Digg – you only want to brag when it has 10, 20, or 100s.

The plugin ran into some problems, and I ran out of time to fix them.  As a result it’s dead.  However, I’ve recently had a few ideas on how to revive it and make it much more efficient.

The Old Plugin Method

The old plugin worked, but it was plagued with problems.  Most notably, it had a delayed effect and the badge wouldn’t show up for 10 or 15 seconds.  If it was used on an index page, it would slow down the loading of the page terribly.  It also broke when WordPress moved to version 2.5.

Most of the problems, I think, come from the way I designed the plugin.  I had just begun tinkering with the Digg API to grab information from the Digg database, so I thought this plug-in would be a useful way to fetch information about an article and have it dynamically update the way the article is displayed.

The plug-in relied on a bit of Javascript to insert or remove the Digg Badge.  The JS used AJAX to contact the Digg API via a tiny php script.  If there was a sufficient number of diggs, the Digg Badge would be inserted.  Otherwise, the container div would just remain empty.

A Better Method – No More AJAX

Recently, I had an idea on how the plugin could be improved and re-implemented.  The loading problems seemed to derive from the Digg API – it sometimes lagging in response time, which prevented the Digg This Badge from appearing in a timely fashion.

A more streamlined method would be to use CSS to toggle the display of Badge on and off and use JS to find out how many Diggs the article has.

The Digg This Badge is contained in an iframe, which contains in its source the number of Diggs the post currently has.  If you look in the source of your page, you’ll see the src of the iframe.  Load that page and view its source.  You’ll see a line like…

<strong>1767</strong> diggs

It should be possible to use Javascript (and possibly jQuery for convenience) to access the iframe’s source, dig up the number of diggs, and then toggle the display attribute of the iframe on and off.

I tried testing this out last night, but I ran into some browser compatibility issues.  In Firefox, I was able to access the contents of the iframe.  However, both Google Chrome (my browser of choice) and Internet Explorer balked at the code.  It generated an error somewhere inside the jquery file itself, and any time I tried to access the contents of the iframe the script aborted.

The concept seems sound.  I just need to find a way to make the javascript work in Explorer.  Regardless, I’ll work up some code examples later on how to use jQuery to access an iframe.

The advantage of this method is that there should be no lag time at all.  As soon as the Badge would normally load, it should be a fraction of a second before the Javascript function to evaluate its logic and turn on the display attribute of the iframe.

However, you may find a time to work with data at the binary level in PHP (and many other programming languages). Here’s a quick guide to understanding binary numbers and the common operators for handling them.

“Normal” Numbers – Base Ten, Decimal System

When you deal with numbers, you are probably using the “Base Ten” or “Decimal” number system. These are numbers made up of a set of ten different digits – zero through nine.

A given quantity – like 512 – is created with a series of digits. The position of the digit tells us how much the digit actually represents. The ’2′ here is in the units place, so it simply represents 2. The 1 is in the tens place, so it actually represents 10. The 5 is in the hundreds place, so it represents 500.

The number could be re-written as:

500 + 10 + 2 = 512

You’ll notice a pattern here. Each new place is worth ten times the previous place. The third digit (the hundreds place) is worth 10 * 10. If we added a fourth place, it would be worth 10 * 100 (1000).

This gives us a nifty little mathematical formula – which is why this is called “base ten” numbering. The nth digit (where zero is the right-most digit) is worth 10^n. Here’s the number 1024 re-written to illustrate this.

(1 * 10^3) + (0 * 10^2) + (2 * 10^1) + (4 * 10^0) = 1024

This is a lot of work to read a number that we intuitively know is worth 1,024. However, it helps to understand how binary numbers work.

Binary Numbers – The Base Two System

While base ten numbers are simple enough for humans to work with, computers are designed to use a binary or base two numbering system.

The simplest unit of information is a binary bit – a 0 or a 1.

To create complex numbers, we can string together 0′s and 1′s. For example, a number could be written as 0010 0101.

To understand what this value means, we can apply the same rules as we did above. However, since this is a base two system instead of a base ten system, each place is multiplied by 2^n.

Let’s start with a smaller example – 1111.

(1 * 2^3) + (1 * 2^2) + (1 * 2^1) + (1 * 2^0)
    = 8 + 4 + 2 + 1
    = 15

These rules can be expanded to represent byte-sized numbers (8-bits, or 2^8, or 255) or even larger numbers.

Manipulating Bits and Bytes – Bitwise Operators

Most programming languages come with some built in operators to handle bits. These help make very basic comparisons and manipulations of numbers.

These typically include the ‘and’ or intersection operator, the ‘or’ or union operator, and the ‘xor’ or exclusive-or operator. We’ll just take a look at the ‘and’ and ‘or’ operators right now. [Note: I use the terms intersection and union because I think they make it much easier to understand, if you are at all familiar with math sets and statistics. They aren’t typical ‘coding’ terms).

The ‘and’ or intersection operator – the ‘&’ character in PHP – compares two binary numbers and returns a new binary number with a ’1′ in every unit in which both numbers have a ’1′. If both numbers have a value in the second place, then the return number will have a value in the second place. If only one number has a value in the third place, then the return number will have no value in the third place.

0111 & 0101 = 0101
0101 & 1010 = 0000
1111 & 1111 = 1111

If you imagine ’0111′ and ’0101′ as sets of numbers ({4, 2, 1} and {4, 1} respectively), then the result of a bitwise ‘and’ operation is the simple intersection of the two sets.

The bitwise ‘or’ operator – a | in PHP – returns a value in each place that either number has a value. So if only one number has a value in the first place, the result will have a value in the first place. A place will only have no value if neither number had a value there.

0111 | 0101 = 0111
0101 1110 | 1010 0001 = 1111 1111
0000 1111 | 1111 0000 = 1111 1111

These operators aren’t used very much, but it is important to recognize them. If you don’t know what they are, it is easy to confuse them with the standard logical operators – || and &&.

For example, the following two lines of code have very different meanings.

$x = 124;
$y = 36;
$bitwise = $x & $y;
$logical = $x && $y;

In the first comparison ($x & $y), we’re finding the bitwise intersection of the two values. This would be…

0111 1100 & 0010 0100 = 0010 0100

In base ten terms, $bitwise would be equal to 36. In the second example ($x && $y), we’re looking for a simple boolean comparison. In this case, both $x and $y have a value, so the comparison will return ’1′ or ‘true’.

Is This Useful…? Comparing Constant Flags

You may be thinking to yourself, “When will I ever use this?”

While anyone working with computer code should understand how binary numbers work, there will probably be very few cases in which you manipulate numerical values in a binary format. The rest of the world works with decimal numbers – and your programming language is designed to do the same thing.

However, there are some cases where you will want to use bitwise numbers and comparisons. A perfect example is the use of constants and flags.

Let’s say that a function takes 16 parameters. Each of these parameters is a simple “True” or “False.”

You could write the function take sixteen different parameters and use sixteen different variables. However, this would make function calls quite long – especially if you usually only make two or three parameters true.

Instead, you can pass one value as a parameter. This value – 16 bits long – includes 16 individual flags to tell the function whether a specific parameter is true or false.

If every parameter is set to true, this value would be “1111 1111 1111 1111″. If only the first parameter should be set to true, this value would be “0000 0000 0000 0001″.

Each flag is represented by a specific place in this binary number. The first flag is “0001,” the second flag is “0010,” the third flag is “0100,” etc.

Your code wouldn’t be very readable if you referred to each flag by its numerical value. Instead, you can define constant values. For example, FUNCTION_FLAG_ONE would represent “0001,” “FUNCTION_FLAG_TWO would represent “0010,” etc. These constants would follow whatever naming convention you usually use.

The value of this is that you can easily set any number of flags with the use of the bitwise ‘or’ operator.

For example, let’s say you want to set flags one, seven, and fifteen to true.

$flags = FUNCTION_FLAG_ONE |
    FUNCTION_FLAG_SEVEN | FUNCTION_FLAG_FIFTEEN;

The result would be ’0100 0000 0100 0001.’

Inside the function, you could then use the bitwise ‘and’ operator to see which flags were set. For example, this would let you check to see if the fifteenth flag was set to true.

$fifteen = $flags & FUNCTION_FLAG_FIFTEEN;

Although your function’s code will have to do some legwork to find out which flags were set and which ones were not, this makes the function call itself much more efficient and readable.

Assuming you do know what a trackback is, how do you send one – technically speaking? And how can we write a php script to send one?

A trackback is a simple ping – an HTTP Request. It is specially formatted with a limited amount of information. The receiving server is set up to handle that information and use it to create the comment based on your trackback ping.

The Trackback API As Per Moveable Type

Since Moveable Type introduced the trackback, they were the ones responsible for writing the standards and API. You can read through the trackback technical specs on the SixApart website.

In order to send a trackback ping with a PHP script, there’s a few things we need to know…

• The ping is in the form of an HTTP Post Request.
• The ping is sent to the trackback URI of the receiving post.
• The request must have a content-type header defining it as application/x-www-url-encoded
• All of the parameters included in the content should be url encoded.
• The standard parameters are “title,” “excerpt,” “url,” and “blog.” Only the “url” parameter is required.
• The server will send a short XML response – containing <error>0</error> if there was no error, and <error>1</error> along with a <message></message> element if there was an error.

With that in mind, we can begin to write our script. We need to do four things.

• Receive input from the user (the blog url, title, excerpt, etc).
• Create the header and format the information correctly
• Send the header and get a response
• Read the XML to see if it was successful or not

Getting Input From the User

Getting input is pretty simple. We’ll create a form in HTML, set the action to the page containing the script, and set the method to post.

You’ll want a text input for the URL, title, and blog. You could use either a text input or a small textarea box to take the excerpt.

Here’s some sample HTML to create the form. You’d want to add some css to make it look pretty, but you can do that some other time.

<form id="trackback-form" action="trackback.html" method="post"><fieldset id="trackback"><label for="trackback-uri">Trackback URI:</label>
<input id="trackback-uri" name="trackback-uri" type="text" />
 
<label for="title">Post Title:</label>
<input id="title" name="title" type="text" />
 
<label for="url">Post URL:</label>
<input id="url" name="url" type="text" />
 
<label for="excerpt">Excerpt:</label>
<input id="excerpt" name="excerpt" type="text" />
 
<label for="blog">Blog Name:</label>
<input id="blog" name="blog" type="text" />
 
<label for="submit"></label>
<input id="submit" name="submit" type="submit" value="Send Trackback Ping" /> </fieldset></form>

Simple… but effective. Set the “action” to the name of the file with the form in it. We’ll add the php script to the top, and the form will just return the information to itself.

Reading the Information from the Form and Encoding It

Once you hit submit, all of the form information will get sent to the file so that the script – at the beginning of the file – can handle it.

All of this form information is in the $_POST array. The ‘key’ for each element is the ‘name’ attribute of the form element.

We’ll also need to use the urlencode() function. This takes the input and escapes any special characters (like spaces) so that the input is in the proper format.

Here’s a snippet to read the $_POST variables, encode them, and store the information in some new variables. Note that you’d probably want to include some error checking (i.e. check to see if the $_POST[] element is empty, and set an error message if it is). I’ll leave that up to you.

$title = urlencode($_POST['title']);
$url = urlencode($_POST['url']);
$excerpt = urlencode($_POST['excerpt']);
$blog_name = urlencode($_POST['blog']);
 
$trackback_uri = $_POST['trackback-uri'];

Now that have all of our information, we need to create the HTTP header.

You could format this as a special string, but php has a built in function – stream_context_create – that will take a formatted array and use it to send an HTTP header. That’s what we’ll be using.

A HTTP header looks something like this…

POST http://targeturl.com
Content-Type: application/x-www-form-urlencoded;
charset=utf-8&paramvar=Param+Value&paramvar2=Param+Value+2

In order to use stream_context_create, we need to create an array in the following format.

• $params['http']['method'] is the method (POST)
• $params['http']['header'] is the optional headers (in this case the Content-Type)
• $params['http']['content'] is the actual content – the parameter variables and values. This will be the string containing all of the trackback information (the post url, post title, blog name, and excerpt).

So, to create the array we need, here’s a short snippet of code, picking up where we left off before…

$params['http']['method'] = "POST";
$params['http']['header'] = "Content-Type:
    application/x-www-form-urlencoded";
$params['http']['content'] = "title=$title&url=$url&
    blog_name=$blog_name&excerpt=$excerpt";

Note that because we used double-quotes (” “) when declaring $params['http']['content'], we could simply include the variables in the string – and PHP will punch in the values for us.

Send the Header! Pings Away!

Now that we’ve created the array, we’re ready to create a context and actually send the HTTP request to the target website.

Like I said before, we’ll use the function stream_context_create to do the work. Then we’ll fopen the target, write the header, fclose the target, and save the response.

stream_context_create just needs one parameter – our formatted array.

fopen will take a few parameters – the target URL ($trackback_uri), the mode (‘rb’ for read-only, binary), a boolean option which is false for us, and the context we created with stream_context_create.

Here’s the actual code snippet. (Note: You can only use a context in fopen() in PHP 5 or greater. You’ll need to manually make the header if you’re using PHP 4)

//  Create the context from the formatted array
$context = stream_context_create($params);
 
//  Open a stream to the url, save it in the pointer $fp
$fp = @fopen($trackback_uri, 'rb', false, $context);
 
//  Send the header and get the results, saved in $response
$response = @stream_get_contents($fp);
 
//  Always close for good measure
fclose($fp);

At this point, you should be able to send trackbacks just fine.

Read the Result Message – Error or No?

Now we need to read the results (saved in $response) and find out if we were successful.

You could just echo it. The xml tags will be hidden by the browser, so the user will just see the output. However I like to have the script read it so that I can output a customized message.

One way to do this would be to build an xml parser and find out directly what’s in the element. This is a lot of work for one error message, though.

Instead, we can use our knowledge of the standard format of the message to good use.

First, we know that a success is always returned with . If we do a stripos or substr search to see if that string is included in $response, we’ll know if the test was successful or not.

Then, we can isolate the element and echo that.

Here’s the code I used to do it. Not sure if it’s the most efficient way to do it, but it works… so why not?

//  If this is true, there was no error
if (stripos($response, '0'))
    $outcome = "All clear! Trackback
        was sent successfully.";
else
    {
    //  Find the beginning and end of the message element
    $start_resp = stripos($response, '');
    $end_resp = stripos($response, '');
 
    //  substr will return the actual message element,
    //    with the tags included
    $outcome = substr($response, $start_resp,
        $end_resp - $start_resp - 1);
 
    //  Replace the tags with blank space
    $outcome = str_replace('', '', $outcome);
    $outcome = str_replace('', '', $outcome);
    $outcome = "Error: " . $outcome;
    }
 
//  Echo the results.  I formatted 'error' to be red.
echo "
 
$outcome
 
";

Recap

Well, there you have it. Put all that code together and you should have a functioning example.

Even if you’re not going to use this on your own site, this is a pretty cool learning activity.  You get to see how contexts and streams work, sending an HTTP header to get a response.

We also make use of the urlencode() function and use stripos() and substr() to do some half-assed xml parsing. You could use a similar method for reading HTML and parsing tags.

Enjoy, and be sure to leave a comment if there’s something else you’d like to see explained in a tutorial.