1. Wildcard: 192.168.10.*
2. Start-End range: 10.1.0.0-10.1.255.255
3. CIDR*: 172.16.1.0/24

* Classless Inter-Domain Routing

The Wildcard method, or "classy", allows you to work at Class A (10.*.*.*), Class B (172.16.*.*) or Class C (192.168.10.*) levels of granularity which is how we used to do things in the old days (before the Web decided to make the Internet popular).  But, increasingly, this just isn't granular enough for practical purposes.

Thus was born CIDR (yes, I'm skipping talking about Start-End ranges for now).  CIDR brought about the concept that we really didn't need to break networks on 8, 16, 24 bit boundaries and we could be more granular by allowing the use of any number (from 2-30) to specify a range of networks.  Details on why you can't use "31" is beyond the scope of this article.

CIDR renamed the former Class A, B and C networks as /8, /16 and /24 respectively and reflects the left-most significant bits of the 32-bit IP address.  Thus was born the ability to specify very specific IP ranges in the form a.b.c.d/xx.   However, part of the problem with this is that although it concisely describes the network start and end, most normal mortal humans couldn't decipher it. CIDR addressing can also be specified in the form of a longer netmask, e.g. a.b.c.d/255.255.255.224

Thus, the simplified form of Start IP - End IP was put in place for mere mortals and is typically used by those without a networking background.  It also features heavily in consumer broadband routers and notably in Microsoft Windows DHCP server.

So having explained how a range, and by inference, that a netmask is, how can we use this knowledge to help us in determining if an IP is within a range?

What this article will attempt to do is guide you though the construction of algorithms to make the checking of IPs simpler.

Logically, Method 1 (the Wildcard), can be easily converted to Method 2 (Start-End range) by using setting Start and End to the Wildcard string and replacing the "*" character with 0 for the Start and 255 for the End, thus for example, "192.168.10.*" becomes "192.168.10.0-192.168.10.255" which should (I hope) be obvious to everyone.

We can then proceed to evaluate both Method1 and Method2 in the same way.  In this we're simply going to use the PHP built in function ip2long() on all 3 values and perform a mathematical check for Start <= IP <= End.

      list($lower, $upper) = explode('-', $range, 2);
      $lower_dec = ip2long($lower);
      $upper_dec = ip2long($upper);
      $ip_dec = ip2long($ip);
      return ( ($ip_dec>=$lower_dec) && ($ip_dec<=$upper_dec) );

We have, however, a complicating factor here - PHP does not do unsigned integers (32 bit) - which would be necessary for this math to work properly.  We can negate this by switing to floating point data types.  PHP stores  floating types as 64 bit and so will have no problem with IPv4 address space (note - this obviously isn't granular enough for 128bit IPv6 addressing). Therefore the simplest way to solve the Start <= IP <= End problem with IPs and floating point numers is the following piece of code:

      $lower_dec = (float)sprintf("%u",ip2long($lower));
      $upper_dec = (float)sprintf("%u",ip2long($upper));
      $ip_dec = (float)sprintf("%u",ip2long($ip));
      return ( ($ip_dec>=$lower_dec) && ($ip_dec<=$upper_dec) );


Next we have the challenge of handing the CIDR netmasks. What we could do is to take a CIDR format IPaddress/netmask and calculate the Start and End IPs of that block and proceed as before - but that would be no fun - and would mean I haven't really taught anything through this article. 

The method we're going to use here is how all the world's Internet routers determine if a destination IP is in a specific CIDR address space. And we're going to get down and dirty with bitmasks and logical bitwise operators.

So using a real world example, my webserver IP 80.76.201.37 and the netblock within which it resides is 80.76.201.32/27, how does this all work?

Well the /27 indicates that the first 27 bits of the IP address are the same network and IP address in that network (range) will have those same identical first 27 bits.  Bits 28-32 are variable and allow 5 bits of variation.  If you know your binary, then this means 32 possible IPs. (However with routing, you can't use the bottom and top IP from any range as these are special and mean the network and broadcast addresses respectively. [This is also why a /31 isn't much use (except for PPP links) as you can't use the 2 addresses that space gives you]).

So thinking logically, bitwise, if I take my IP address and the CIDR spec, then all I have to do is check that the first 27 bits all match and I'm good. Correct.  So how would we do this in PHP? Sound's simple, lets just use PHP's bitwise logical AND operator: &
Again, correct. 

In order to do this we need to convert 27 into what 27 really means - a 32 bit number of 27 ones and 5 zeros in binary (which is what 255.255.255.224 really looks like).

In pseudo-code you could then do if (IP & BITMASK) == (RANGE & BITMASK) then all is good and you know that the IP is within the range.

Visualising this using our real IP address (using the very handy unix tool ipcalc):

Address:   80.76.201.37    01010000.01001100.11001001.00100101
Netmask:   255.255.255.224 11111111.11111111.11111111.11100000
Wildcard:  0.0.0.31        00000000.00000000.00000000.00011111

Network:   80.76.201.32/27 01010000.01001100.11001001.00100000
HostMin:   80.76.201.33    01010000.01001100.11001001.00100001
HostMax:   80.76.201.62    01010000.01001100.11001001.00111110
Broadcast: 80.76.201.63    01010000.01001100.11001001.00111111
Hosts/Net: 30

$ip = "80.76.201.37";
$range = "80.76.201.32";
$netmask = 27;

$range_dec = ip2long($range);
$ip_dec = ip2long($ip);

$netmask_dec = bindec( str_pad('', $netmask, '1')
                     . str_pad('', 32-$netmask, '0') );

$wildcard_dec = pow(2, (32-$netmask)) - 1;
$netmask_dec = ~ $wildcard_dec;

return (($ip_dec & $netmask_dec) == ($range_dec & $netmask_dec));

http://pgregg.com/projects/php/ip_in_range/ip_in_range.phps

http://pgregg.com/projects/php/ip_in_range/test.php

I hope this article has been educational, please feel free to leave comments or feedback.

Update: There have been questions about PHP's signed integers and my use of bit operations in the code.   It is important to recognise that when dealing with signed or unsigned 32 bit integers purely as bit patterns for masking with a netmask or broadcast address pattern - the fact that a number (128.0.0.0 or above) really is negative, doesn't have any impact on the validity of the result.  The only impact to not having signed 32 bit integers is in the Start-End range check (example 2 above: 10.1.0.0-10.1.255.255) where a range spanning the switch from positive to negative would be catastrophic to the check.  We can safely work around that problem by using floating point numbers as we are only doing <= and >= comparisons and not attempting any bitwise operators (which don't work on floats).

• Reading enough lines in
• as few reads as possible

$linecount  = 10;  // Number of lines we want to read
$linelength = 160; // Apache's logs are typically ~200+ chars
// I've set this to < 200 to show the dynamic nature of the algorithm
// offset correction.
$file = '/usr/local/apache2/logs/access_log.demo';
$fsize = filesize($file);

// check if file is smaller than possible max lines
$offset = ($linecount+1) * $linelength;
if ($offset > $fsize) $offset = $fsize;

$fp = fopen($file, 'r');
if ($fp === false) exit;

$lines = array(); // array to store the lines we read.

$readloop = true;
while($readloop) {
  // we will finish reading when we have read $linecount lines, or the file
  // just doesn't have $linecount lines

  // seek to $offset bytes from the end of the file
  fseek($fp, 0 - $offset, SEEK_END);

  // discard the first line as it won't be a complete line
  // unless we're right at the start of the file
  if ($offset != $fsize) fgets($fp);

  // tally of the number of bytes in each line we read
  $linesize = 0;

  // read from here till the end of the file and remember each line
  while($line = fgets($fp)) {
    array_push($lines, $line);
    $linesize += strlen($line); // total up the char count

    // if we've been able to get more lines than we need
    // lose the first entry in the queue
    // Logically we should decrement $linesize too, but if we
    // hit the magic number of lines, we are never going to use it
    if (count($lines) > $linecount) array_shift($lines);
  }

  // We have now read all the lines from $offset until the end of the file
  if (count($lines) == $linecount) {
    // perfect - have enough lines, can exit the loop
    $readloop = false;
  } elseif ($offset >= $fsize) {
    // file is too small - nothing more we can do, we must exit the loop
    $readloop = false;
  } elseif (count($lines) < $linecount) {
    // try again with a bigger offset
    $offset = intval($offset * 1.1);  // increase offset 10%
    // but also work out what the offset could be if based on the lines we saw
    $offset2 = intval($linesize/count($lines) * ($linecount+1));
    // and if it is larger, then use that one instead (self-tuning)
    if ($offset2 > $offset) $offset = $offset2;
    // Also remember we can't seek back past the start of the file
    if ($offset > $fsize) $offset = $fsize;
    echo 'Trying with a bigger offset: ', $offset, "\n";
    // and reset
    $lines = array();
  }
}

// Let's have a look at the lines we read.
print_r($lines);

http://pgregg.com/projects/php/code/tail-10.phps

http://pgregg.com/projects/php/code/tail-10.php