What we did this time round is get a really, really short url - something memorable too… So we bought url.co.uk.

We decided that we'd start off by offering something 'new' as well - where possible, we'll check the destination URL against a frequently updated database of known phishing sites. We don't want to send you and your visitors to a malicious site that looks like Paypal, but isn't Paypal!

We've got more features in the pipeline, but I'd urge you to give it a shot, and see what you think.

As always, I'd appreciate any comments you have on the service!

Usage:

Just ensure that you pass it two timestamps, the first one being the date FROM when you want to calculate, the second one being where you want it calculated TO. Tip: You can get the current timestamp by using time().

Enjoy!

However, there is a script around that makes this a lot easier by handling all the donkey work - PHPMailer. PHPMailer can handle almost anything you want to throw at it, including embedding images within the email, full blown HTML emails, using external SMTP servers to send the emails and so on. However, today, we're going to just concentrate on using PHPMailer to send an email with an attachment.

PHPMailer is a class based script, which means that you just need to include it into your PHP code, and fire it up:

As you can see, we've set the From details up, as well as the subject and body text. We can then add the recipient address, the attachment, and then send. That's all there is to it!

You can keep adding attachments as shown above. Just ensure that you provide the right path to the files!

This can be enabled in PHP 5.2. by passing TRUE as the 7th paramenter in setcookie() and setrawcookie(). In versions below 5.2, you can set this by passing an additional header.

However, browser compatibility is not complete. It is available in MSIE, but is lacking in Mozilla, Firefox and Safari. More discussion on the benefits of this cookie can be found on the Mozilla Bugzilla.

You can download PHP 5.2.-dev from the PHP Website. It however, has not yet been released as a public stable, so precaution is necessary for production servers.

Good database design should adhere to the third normal form, or "3NF". In a nutshell, relating bits of data to other bits of data with minimal memory/storage overheads. In order to utilise a 3NF database effectively, table joins (linking and extracting data from two different internal sources) are an absolute must. In standard Structured Query Language syntax, there are two main join-types: theta and ANSI. Here's an example of each, using the common book/author database example:

# This is a theta join example
SELECT
b.`title`,
CONCAT_WS(' ',a.`firstname`,a.`surname`) AS `author`
FROM
`books` b,  `authors` a
WHERE
b.`author_id` = a.`author_id`

Here you can see that the table join takes place in the WHERE clause, so we only pull out records where the books table's author_id foreign key column matches the authors table's primary key of the same name.

The equivalent as an ANSI join is as follows:

SELECT
b.`title`,
CONCAT_WS(' ',a.`firstname`,a.`surname`) AS `author`
FROM
`books` b
INNER JOIN  # "INNER" is not required, however it is considered best practice
`authors` a ON b.`author_id` = a.`author_id`

Like the theta example, this will pull out everything from books, where there's an author to go with it. Now suppose we haven't yet stored the author data for a given book, but we still want to extract a list of all of the books in our example - with an ANSI join is nice and easy, just swap the word INNER for LEFT, meaning that the left-hand table (books) takes precidence and does not depend upon there being a corresponding record (or set of) from the joined table.

So how would you replicate that with a theta join? Let's take a look:

SELECT
b.`title`,
CONCAT_WS(' ',a.`firstname`,a.`surname`) AS `author`
FROM
`books` b,
`authors` a
WHERE
b.`author_id` = a.`author_id`
OR a.`author_id` IS NULL

Not as elegant, is it? It's also far easier to create accidental cartesian joins using the theta method, which is not a good situation to be in, especially when your row count goes into the hundreds on either table - the result is very CPU/Memory hungry and can even bring a user's browser, and even a server, to a grinding halt. Theta style joins in general (and in my experience) are notably resource intenstive compared to ANSI equivalents.
It's also worth noting that in versions of MySQL prior to 5.x, it was acceptible to mix join types, i.e. use theta and ANSI joins in one query, like so:

SELECT
b.`title`,
CONCAT_WS(' ',a.`firstname`,a.`surname`) AS `author`
FROM
`reading_list` rl,
`books` b
# Here's the ANSI join...
INNER JOIN
`authors` a ON b.`author_id` = a.`author_id`
# ...and here's the theta join
WHERE
rl.`book_id` = b.`book_id`

I hope that it goes without saying that this is very bad programming practice; it's illogical use two different tools (simultaneously) to do the same job! So much so that the chaps at MySQL have opted to flat-out deny mixed join types in the same query.

For further reading, I can thoroughly recommend Jon Stephens/Chad Russels article on the subject, taken from the book "Beginning MySQL Database Design and Optimization: From Novice to Professional" (ISBN 1-59059-332-4).

However, a quick look at the PHP Manual showed a much easier way of determining whether a number is odd or even:

The '&' sign represents the bitwise 'AND' operator, and the appropriate user comment explains:

The reason the bitwise AND ("&") operator works to determine whether a number is odd or even is because odd numbers expressed in binary always have the rightmost (2^0) bit = 1 and even numbers always have the 2^0 bit = 0.

So if you do a " 1 & $num", it will return zero if the number is even (since xxxxxxx0 [the even number in binary] and 00000001 [the 1]) don't share any bits, and will return 1 if the number is odd (xxxxxx1 and 000001).

It's nice little tips like these found in PHP keeps me going throughout the day!

The Functions

Before you can concoct a regular expression, you need to know how to use them and what all those 'weird characters' do. In PHP, there are several POSIX-type regex functions, and the most common ones are:

• preg_match / preg_match_all
• preg_replace (which we'll cover another day!)

Rather than go on about how they all work, I think the best way is to show them in use with an example. Ignore the regular expression patterns for now, they will be explained in depth later!

Phone Number Example

Matching with Regular Expressions

Matching with regex can also be thought of as 'searching' or 'finding' with regex. You supply the pattern, and the preg_match* functions will deliver the goods. The beauty of the functions mean that the function will return true if a match is successfully made, and you can also optionally retrieve the 'found' contents by supplying a variable name as the third parameter, $matches in this case.

To demonstrate, lets take a look at the following. Our user has input their phone number, but we want to store the area code separately from the rest of the number. For the sake of arguments, lets assume the phone number is input as xxx xxx xxxx with the separator being either a space, a hyphen or nothing at all:

$matches gives:

Array
(
    [0] => 123-
    [1] => 123
)

As you can see, we get a 'true' return from preg_match and our $matches variable contains the information matched by our expression, /^(\d{3})[\s-]?/. Regular expressions will match and return patterns surrounded in round brackets, as you can see in the above example with /^(\d{3})[\s-]?/. The first element in the $matches array is always the entire result of the regex match. Subsequent matches are stored in the array in the order of the matching brackets in the regex.

The trick to dealing with regex patterns is to take it one character at a time. Looking at the above regex, lets dismantle it and take it piece by piece:

Dismantling "/^(\d{3})[\s-]?/"

As you can see, when you break up the regular expression, things do appear more simple. We've covered a lot in the above expression, and so I will try to elaborate a bit more below.

Anchors

There are only two anchors I want to bring into the equation for now:

^ - will match the beginning of a line/string when it is not present in a [...] character class.
$ - will match the end of a line/string

Character Classes

There are two sorts of character classes. One's within square brackets, and others that are shorthand, like \d above. Within square brackets, you can list characters that you want to be accepted or rejected:

[abc] - will match a or b or c
[^abc] - will match anything BUT a or b or c - i.e. any character that is not a or b or c

You can include ranged of information:

[a-zA-Z] - will match a-z letters in both upper and lower case
[0-9] - will match digits 0-9

If you want to match a hyphen, then you need to have the hyphen as the last character:

[a-z-] - will match a-z in lowercase only, and hyphens

There are other character classes that are shorthand:

\s - matches whitespace characters: n, r (both new lines), t (tabs) and f (form feeds - not use often). Equivalent to [nrtf]
\S - matches all non-whitespace characters. Equivalent to [^nrtf]
\d - matches 0-9. Equivalent to [0-9]
\D - matches all non-digits. Equivalent to [^0-9]
\w - matches a word character: a-z, A-Z and 0-9. Equivalent to [a-zA-Z0-9]
\W - matches all non-word characters. Equivalent to [^a-zA-Z0-9]
. - the period matches any character apart from new lines. If you wish to match an actual period, you need to escape it using a backslash: \.

Ranges

As we saw above with {3} you can specify the number of times you wish to match the previous expression. Above we used \d{3} but we could have easily used \d\d\d - but using a range is a lot more neater, and readable.

However, a range can be as you'd expect: a range from x through to y. For example, {3,5} means that the previous expression must be matched at least 3 times and at most 5 times. So for:

preg_match("/\d{3,5}/",$var);

we will get a true return from preg_match() if $var ranges from 100 through to 99999.

Now, what if you want $var to range from 100 until infinity? This can be done by not providing a second digit in the range: {3,} - will match at least three digits.

Ranges are simple, and can be a great help

Wildcards

The last thing I want to discuss are expression wildcards. There are three wildcards that are used regularly:

? - The question mark will match the preceeding expression 0 or 1 times. This is very handy for when you want the input to have an optional character. We used this above to account for a hyphen, space or nothing as our separator in the phone number
+ - A plus sign will match the preceeding expression 1 or more times. This is useful for when you require something to be present.
* - An asterisk wildcard will match the preceeding expression 0 or more times. There is an unlimited times that it will match. For example, .* will match every character in a line.

A final example

Using the information we have above, let's create a regular expression that will match a hex colour that will end up in a CSS stylesheet. Hex colours have 6 characters that range from 0-9 or A-F. To check this using a regular expression, we need to start at the beginning of our string, so we start with a ^. We want to check for a # sign so we add that to our expression so far:

/^#/

We now need to add the juicy bit, which is checking for A-F, a-f and 0-9 only 6 characters allowed from that list:

/^#[a-fA-F0-9]{6}/

We finish the expression by ensuring we are checking the entire string. We can do this by using the end of line character, $. This, combined with ^ means we check from the beginning of the input through to the end of the input, and the only characters allowed are those in our expression. This gives our final expression:

/^#[a-fA-F0-9]{6}$/

This has been a whistle-stop tour of basic regular expression. There is a lot more that can be done, and a lot that I have missed out for the sake of simplicity. Keep an eye out for a follow up explaining more of the world of regular expressions.

Luckily, this is quite easy if you have the Curl extension installed.

Using Curl in PHP

Curl is a collection of client URL library functions that we can use to perform a multitude of URL related activities. You can send a POST or file upload to a URL, use it as a proxy, send/receive XML requests, and much more. In fact, there are over 100 configuration options that can customise this to your needs.

Still, for this tutorial, all we want is to check that a URL exists. We can do this by using curl to grab the headers when requesting the URL and check the Status: header returned.

The result from running the above code is:

HTTP/1.1 200 OK
Date: Wed, 31 May 2006 12:25:26 GMT
Server: Apache
X-Powered-By: PHP/5.1.2
X-Pingback: http://www.jellyandcustard.com/xmlrpc.php
Status: 200 OK
Content-Type: text/html; charset=UTF-8

As you can see, we have our Status: 200 OK HTTP Code which means the page exists. If we get a 404 HTTP code then the page doesn't exist. A list of HTTP Codes can be found at Wikipedia.

If the domain can't be resolved, then $data will return false, which we can check against with a simple if() statement.

In order to utilise the information returned, we need to use a regular expression to grab the HTTP code, and then based upon that, we can let the user know our results:

Array
(
    [0] => Status: 200
    [1] => 200
)

So $matches[1] has our error code. If this matches 200 then the page exists, and if it is 404, then our page doesn't exist.

A slight change has to be made for pages that use a 301/302/307 redirect. We need to instruct Curl to follow the redirect, and report what's found. These redirects produce a lot of headers, as seen when testing http://ukdomains.jellyandcustard.com:

HTTP/1.1 302 Found
Date: Wed, 31 May 2006 12:50:38 GMT
Server: Apache
Location: http://www.123-reg.co.uk/affiliate.cgi?id=AF106554
Content-Type: text/html; charset=iso-8859-1

HTTP/1.1 302 Found
Date: Wed, 31 May 2006 12:50:42 GMT
Server: Apache/2.0.53
URL: http://www.123-reg.co.uk/
Set-Cookie: 123reg_affiliate=106554-92bab777b0ae96c938107985db7a98e4; path=/secure/; expires=Sat, 28-May-2016 12:50:43 GMT; secure
Location: http://www.123-reg.co.uk/
Content-Type: text/html; charset=iso-8859-1

HTTP/1.1 200 OK
Date: Wed, 31 May 2006 12:50:43 GMT
Server: Apache/2.0.53
Accept-Ranges: bytes
Content-Length: 33854
Content-Type: text/html

Array
(
    [0] => Array
        (
            [0] => HTTP/1.1 302
            [1] => HTTP/1.1 302
            [2] => HTTP/1.1 200
        )

    [1] => Array
        (
            [0] => 302
            [1] => 302
            [2] => 200
        )

)

Our Status code can be found by:

Which we can now check for 200 or 404 etc to make sure that you've been given a real URL, and not one that is made up. So the entire code all together:

Enjoy!

This is in fact very easy to set up, however for those of you on shared hosts (without access to httpd.conf) your host will need to aid you in one or two steps.Here's how I did it:

1. First up, you need to be able to accept all traffic to your domain's subdomains. You need to create a wildcard DNS record for your subdomains - in this case *.jellyandcustard.com. If you have no idea how to do this, then the best step is to contact your webhost, who will be able to assist you.
2. Second up is to let your webserver know that you are accepting all traffic for your subdomains. This can be done in your apache httpd.conf by adding ServerAlias *.domain.com to your site's Virtual Host. If you do not have root access to your webserver, chances are you will have to get your host to add this in.
3. Finally, once this is done, you can start utilising the subdomains by using mod_rewrite in a .htaccess file. Here's what I've done for ukdomains.jellyandcustard.com:
   

   RewriteEngine On

   RewriteCond %{HTTP_HOST} ^ukdomains.jellyandcustard.com$ [NC]
   RewriteRule ^(.*)$ http://www.123-reg.co.uk/affiliate.cgi?id=AF106554 [L,R=302]

Simply rinse and repeat for any other domains that you need. Wonder if it actually works? Give it a try! You do not need to repeat the RewriteEngine On line once it has already been added.