Evolution Systems - Matt's Blog

Validating Url Strings In PHP

Matthew Jakeman — 2008-09-25T10:25:31+01:00

I was writing a form a little while ago that requests a url from a user. Obviously it would be nice to validate the string the user input in some way. I am not a fan of writing a regex for something like this when I know that there are bound to be many examples of doing this knocking about already so to save time I once again headed over to google to look around.

I came across this link which has a nice little example of a regex to achieve a good validation.

Below is a copy and paste of building the regex string from that site with brief explanations of what each part achieves.

// SCHEME
$urlregex = "^(https?|ftp)\:\/\/";

// USER AND PASS (optional)
$urlregex .= "([a-z0-9+!*(),;?&=\$_.-]+(\:[a-z0-9+!*(),;?&=\$_.-]+)?@)?";
// HOSTNAME OR IP
$urlregex .= "[a-z0-9+\$_-]+(\.[a-z0-9+\$_-]+)*";
// PORT (optional)
$urlregex .= "(\:[0-9]{2,5})?"; 
// PATH  (optional)
$urlregex .= "(\/([a-z0-9+\$_-]\.?)+)*\/?";// GET Query (optional)
$urlregex .= "(\?[a-z+&\$_.-][a-z0-9;:@/&%=+\$_.-]*)?";// ANCHOR (optional)
$urlregex .= "(#[a-z_.-][a-z0-9+\$_.-]*)?\$";

This builds a nice regex string which can be used with the eregi() function to validate a url string like so:

if (eregi($urlregex, $url))
{
  echo "URL Valid";
}
else
{
  echo "URL Invalid";
}

This regex will validate nearly all valid url's and is handy to have knocking about.

Thanks to the original author, whoever that may be.....

Get Next Auto Increment Value

Matthew Jakeman — 2008-09-24T20:46:11+01:00

Earlier today I had the need to try and discover the next auto increment value in a MySQL table. I haven't needed to do this before so I headed over to google to have a look for how to accomplish it.

A lot of information I found said to use a 'SELECT MAX...'. This would work fine as long as nothing gets deleted from the end of the database. I ended up finding a nice blog entry here that explains exactly how to do it. The following code snippet taken from the site above shows how to get the next value.

$tablename 		= "tablename";
$next_increment 	= 0;
$qShowStatus 		= "SHOW TABLE STATUS LIKE '$tablename'";
$qShowStatusResult 	= mysql_query($qShowStatus);

$row = mysql_fetch_assoc($qShowStatusResult);
$next_increment = $row['Auto_increment'];

echo "next increment number: [$next_increment]";

?>

Quite a useful piece of info...

SSHFS - Mounting Remote Directories Over SSH

Matthew Jakeman — 2008-06-20T12:45:46+01:00

For a while now I have been wondering how easy it is to mount a remote directory. I have always known there must be a way to do it but had never actually got around to looking it up. It was only the other day when someone showed me SftpDrive, an application for windows that allows you to mount remote directories over SFTP.

This got me searching around for a similar method for Linux. I just wanted to be able to mount a directory on a remote machine and be able to access it as though it was a directory on my local machine. My searching led me to SSHFS.

SSHFS allowed me to do exactly what i want. A simple 'apt-get' in Ubuntu installed it and I was ready to go. You need to add yourself to the fuse group after it has been installed (adduser fuse) and then restart your terminal. (You may also need to 'modprobe fuse')

Once this is done you are ready to go, simply mount a remote directory using a command like 'sshfs username@hostnema:/remote/path/ /local/path'

Make sure you have made a directory somewhere on your local machine to be the mount point and chown'd it using 'sudo chown your-username /local/path'.

All being well you should now have your remote directory mounted as if it was on your own machine. I have found this extremely useful for working on a few web based projects. Another thing that it is very useful for is running backups of my remote servers. A simple cron job running a script to backup your remote servers works a treat.

Linux and TCP Congestion Control

Matthew Jakeman — 2008-06-12T10:56:10+01:00

I saw a question on the Ubuntu forums this morning from someone who has recently started using a satellite connection and was getting poor performance loading web pages, which is to be expected really with the high Bandwidth Delay Product (BDP) of satellite links.

The question was asking if there are any ways to tune TCP in Linux to perform better over this type of connection. There are obviously various TCP congestion control algorithms knocking about, cubic, reno, vegas, hybla etc but up until now I thought you had to recompile the kernel in order to change the algorithm being used. I was wrong.

It appears that since Linux kernel version 2.6.13 a new feature, pluggable congestion avoidance modules, has been supported. This enables the changing of the algorithm being used by simply issuing a sysctl command.

The available algorithms have to be configured when the kernel is compiled but once they have been set up they can be easily changed in a running kernel. In order to see what algorithms are already in your running kernel you can issue the command :


sysctl net.ipv4.tcp_available_congestion_control

If the algorithm you wish to use is not already in your running kernel you can find a list of them and compile them in in the following place using make menuconfig/xconfig :


Networking --->
Networking options --->
TCP: advanced congestion control --->
TCP congestion control --->

Once you have all the algorithms you want in your running kernel it is a simple matter to switch between them, for example to change to using the hybla algorithm (ideal for satellite links as it tries to keep the window size as large as possible on high BDP links) you just issue the following command (as root):


sysctl -w net.ipv4.tcp_congestion_control=hybla

This is a nifty little addition to the Linux kernel that could prove very useful, especially for people with mobile devices that constantly use networks with varying characteristics.

Conditional Statements Explained

Matthew Jakeman — 2008-06-11T15:53:07+01:00

I have often used #if, #ifdef, #if defined() etc as conditional preprocessor directives but haven't really thought in depth about the differences between them. It was only when someone asked the question in a C channel on freenode that it made me think.

A quick search of google brought me across a nice little explanation. Rather than recycling the information here is the link :

Conditional Compilation (#if, #ifdef, ..#endif)

Quite an interesting little read.

Building A Kernel In Ubuntu

Matthew Jakeman — 2008-05-01T10:56:59+01:00

As I mentioned in a previous blog entry, I have started using Ubuntu for pretty much all of my Linux needs over the past few years. However, up until now all of my kernel development work has been done using other distros.

Yesterday I decided to start doing some kernel development in Ubuntu for a project I am working on. The kernel compilation process is a bit different to the traditional method and this post simply lists how to compile a kernel using the Ubuntu tools. Please note that a lot of the commands listed hereafter will need to be executed as root.

First of all you need to grab the source of the kernel version you wish to compile. For me this is the Mobile IP version of the kernel from The Nautilus6 working group. This should be done from the directory in which you want the source directory to be, usually this would be /usr/src.

#cd /usr/src
#apt-get source linux-image-2.6.22-10-mip6

This should grab all of the source for you and put it in the directory /usr/src/linux-source-2.6.22-2.6.22.

Often it is a good idea to use the configuration file from the currently running kernel as a base for the kernel you are going to build. This should ease the transition from a stock kernel to one you have customised. This is done as follows :

#cp /boot/config-`uname -r` ./.configNow you are ready to start configuring your kernel.

#make menuconfigThis will bring up an ncurses based menu system that will allow you to configure your kernel options. If you prefer a more graphical environment in which to perform the configuration you can use the following :

#make xconfigNote that if you are using xconfig you should run it with either `gksudo` or `kdesudo` rather than just `sudo`. Although this shouldn't be an issue in this case it is a good habit to get into as described here.

Once you have decided what configuration options you want for your kernel you are ready to build it. This is done using the following two commands.

#make-kpkg clean
#fakeroot make-kpkg --initrd --append-to-version=-your_kernel_name
kernel_image kernel_headers

The string after `--append-to-version`can be anything you want to distinguish this kernel from the others on the system.. Note that it must begin with a `-` and must not contain any whitespace.

Now you might want to go grab a coffee as this compilation will take quite a while, obviously the amount of time is dependent on your machine spec and your kernel configuration.

Once the compilation has successfully completed you should find two new .deb files in /usr/src. The name of these will vary depending on which kernel source you are using and what you appended to the kernel name. On my build they are named :

linux-headers-2.6.22.9-custom_2.6.22.9-custom-10.00.Custom_i386.deb
linux-image-2.6.22.9-custom_2.6.22.9-custom-10.00.Custom_i386.deb

All that is left to do now is to install these files using dpkg :

#dpkg -i linux-headers-2.6.22.9-custom_2.6.22.9-custom-10.00.Custom_i386.deb
#dpkg -i linux-image-2.6.22.9-custom_2.6.22.9-custom-10.00.Custom_i386.deb

Your new kernel should now be installed and ready to go if all the above steps went smoothly so just restart your machine and you should be running your home built kernel. To check this is the case once the machine has restarted just do the following in a terminal.

#uname -rThis should display to you the name of your home built kernel and you are ready to start experimenting with different configurations or why not start hacking about with the code and see what happens :)

This blog entry went on for a bit longer than i anticipated so for the impatient here is a quick fire list of commands for compiling the kernel in Ubuntu (change names in dpkg commands as necessary) :)

#cd /usr/src
#apt-get source linux-image-2.6.22-10-mip6
#cp /boot/config-`uname -r` ./.config
#make menuconfig
#make-kpkg clean
#fakeroot make-kpkg --initrd --append-to-version=-your_kernel_name
 kernel_image kernel_headers
#dpkg -i linux-headers-2.6.22.9-custom_2.6.22.9-custom-10.00.Custom_i386.deb
#dpkg -i linux-image-2.6.22.9-custom_2.6.22.9-custom-10.00.Custom_i386.deb

Hope you found this useful and good luck with your new kernel.

Linux XFRM Framework Selectors

Matthew Jakeman — 2008-04-17T12:21:34+01:00

Whilst progressing some code I have been writing I was recently introduced to Linux's XFRM (transform) framework. I had not heard of this before but it can be a very useful tool for manipulating packets.

The one big downside to XFRM is there is virtually no documentation on it yet. This can make working with it quite tricky. I am documenting what I find out from using it here in the hope that others will find it useful.

The basic idea behind XFRM is that it allows you to select a packet based on a number of factors. These are all defined in /usr/include/linux/xfrm.h in a struct named xfrm_selector as defined below :

struct xfrm_selector
{
    xfrm_address_t  daddr;
    xfrm_address_t  saddr;
    __be16  dport;
    __be16  dport_mask;
    __be16  sport;
    __be16  sport_mask;
    __u16   family;
    __u8    prefixlen_d;
    __u8    prefixlen_s;
    __u8    proto;
    int ifindex;
    uid_t   user;
};

Creating a struct of this type and setting the fields such as the source/destination addresses, ports, address masks etc, allows a packet to be selected, based on this criteria, to allow it to be transformed. By passing this information into the kernel using a nlmsghdr struct and the addattr_l() function along with a template (struct xfmr_user_tmpl) describing what action to take on the packet we can alter certain packets however we wish.

This is proving very useful to me in some of my current work and I will continue to post anything I think might be useful to others working in the same area on this blog.

Xajax

Matthew Jakeman — 2008-04-03T13:08:32+01:00

I have been doing some form submission for a site I am working on and was thinking it would be nice to use a bit of AJAX to check the forms and display altered content after the form had been submitted, as opposed to simply reloading the page with different parameters.

I went on over to google and started searching to see if I could find any nice libraries that would make the job a little simpler and came across xajax.

This is a really nice PHP toolkit that enables you to add ajax functionality into your web pages extremely easily. All you have to do is include the xajax libraries, create a new xajax object, register a function with the xajax object and include a call to the xajax registered function in your html form, on a button click for example.

Once inside the xajax function you can perform any processing you wish and then return a bunch of html code to be placed inside a container (a div for example) on the calling page.

There are some great little tutorials on the xajax homepage to get you started on your way to lovely ajax enabled web pages.

Structure Packing in GCC

Matthew Jakeman — 2008-03-26T16:49:01+01:00

I have recently been doing a lot of coding using the NEPL NEMO Implementation as a part of a project I am working on. This has proved to be very interesting work and has brought about lots of interesting problems.

One of the most recent problems I faced involved a packet I was sending over the network using a header I had constructed using a struct as follows.

struct Nino
{
  uint8_t type;
  uint8_t length;
  uint8_t prefix_len;
  uint8_t res_l_4;
  uint32_t nino_lifetime;
  uint32_t reserved2;
  uint8_t nino_depth;
  uint8_t reserved3;
  uint16_t nino_seq;
  struct in6_addr _prefix_in6_addr;
};

This was the exact packet header format that I required but when I received a packet and checked it using a version of Wireshark I had modified to recognise the header format, I was getting what seemed like an erroneous 2 Bytes of data (set to 0's) at the beginning of the in6_addr. This puzzled me for a while until I started to think about how GCC would lay out the fields in the struct. Of course GCC tries to optimise the struct for passing across the hardware and pads it if it feels it is necessary.

For my purposes this ruins the whole layout of the packet header for processing so I had a look around and found that GCC has an attribute named __packed__ that will force it not to pad the struct out. Or in the terms of the GCC Manual :

"a variable or structure field should have the smallest possible alignment--one byte for a variable, and one bit for a field, unless you specify a larger value with the aligned attribute."

This was exactly what I wanted. So by changing the struct definition from that above, to :

struct Nino
{
  uint8_t type;
  uint8_t length;
  uint8_t prefix_len;
  uint8_t res_l_4;
  uint32_t nino_lifetime;
  uint32_t reserved2;
  uint8_t nino_depth;
  uint8_t reserved3;
  uint16_t nino_seq;
  struct in6_addr _prefix_in6_addr;
}__attribute__((__packed__));

My code behaved exactly as I required. Problem solved. This is a handy little function of GCC especially when dealing with network packets to make sure you know exactly how the compiler is behaving and hence avoiding any unwanted surprised.

A slightly more in depth look at the packed attribute can be found here.

Ubuntu 8.04 Beta Released

Matthew Jakeman — 2008-03-22T12:32:39+01:00

The team over at Ubuntu have released the latest beta of Ubuntu 8.04 (Hardy Heron). There are lots of upgrades to the existing software packages including the following :

Xorg 7.3
Linux kernel 2.6.24
GNOME 2.22
PolicyKit
PulseAudio
Firefox 3 Beta 4
Transmission BitTorrent Client
Wubi

This is the best release yet for 'converting' windows users to the world of open source software using Wubi to enable it to be easily installed and used as a dual boot system without any complicated partitioning needed. This is a great way to try Linux without having to compromise the integrity of your windows partition in any way.

I will be upgrading to 8.04 on all of my machines as soon as it goes to stable. I have been totally converted to Ubuntu for my desktop OS over the past year. As an avid Linux user for the past 6 or 7 years using a myriad of different distributions. College Linux whilst I was on the development team there before it was dissolved, Debian for years, a bit of Gentoo mixed in as well but none have come close to Ubuntu for ease of usability and I will continue using it as my primary desktop OS for the foreseeable future.