[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * SimplePie
   4   *
   5   * A PHP-Based RSS and Atom Feed Framework.
   6   * Takes the hard work out of managing a complete RSS/Atom solution.
   7   *
   8   * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
   9   * All rights reserved.
  10   *
  11   * Redistribution and use in source and binary forms, with or without modification, are
  12   * permitted provided that the following conditions are met:
  13   *
  14   *     * Redistributions of source code must retain the above copyright notice, this list of
  15   *       conditions and the following disclaimer.
  16   *
  17   *     * Redistributions in binary form must reproduce the above copyright notice, this list
  18   *       of conditions and the following disclaimer in the documentation and/or other materials
  19   *       provided with the distribution.
  20   *
  21   *     * Neither the name of the SimplePie Team nor the names of its contributors may be used
  22   *       to endorse or promote products derived from this software without specific prior
  23   *       written permission.
  24   *
  25   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
  26   * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  27   * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
  28   * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  30   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  31   * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  32   * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33   * POSSIBILITY OF SUCH DAMAGE.
  34   *
  35   * @package SimplePie
  36   * @version 1.3.1
  37   * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
  38   * @author Ryan Parman
  39   * @author Geoffrey Sneddon
  40   * @author Ryan McCue
  41   * @link http://simplepie.org/ SimplePie
  42   * @license http://www.opensource.org/licenses/bsd-license.php BSD License
  43   */
  44  
  45  
  46  /**
  47   * Class to validate and to work with IPv6 addresses.
  48   *
  49   * @package SimplePie
  50   * @subpackage HTTP
  51   * @copyright 2003-2005 The PHP Group
  52   * @license http://www.opensource.org/licenses/bsd-license.php
  53   * @link http://pear.php.net/package/Net_IPv6
  54   * @author Alexander Merz <alexander.merz@web.de>
  55   * @author elfrink at introweb dot nl
  56   * @author Josh Peck <jmp at joshpeck dot org>
  57   * @author Geoffrey Sneddon <geoffers@gmail.com>
  58   */
  59  class SimplePie_Net_IPv6
  60  {
  61      /**
  62       * Uncompresses an IPv6 address
  63       *
  64       * RFC 4291 allows you to compress concecutive zero pieces in an address to
  65       * '::'. This method expects a valid IPv6 address and expands the '::' to
  66       * the required number of zero pieces.
  67       *
  68       * Example:  FF01::101   ->  FF01:0:0:0:0:0:0:101
  69       *           ::1         ->  0:0:0:0:0:0:0:1
  70       *
  71       * @author Alexander Merz <alexander.merz@web.de>
  72       * @author elfrink at introweb dot nl
  73       * @author Josh Peck <jmp at joshpeck dot org>
  74       * @copyright 2003-2005 The PHP Group
  75       * @license http://www.opensource.org/licenses/bsd-license.php
  76       * @param string $ip An IPv6 address
  77       * @return string The uncompressed IPv6 address
  78       */
  79  	public static function uncompress($ip)
  80      {
  81          $c1 = -1;
  82          $c2 = -1;
  83          if (substr_count($ip, '::') === 1)
  84          {
  85              list($ip1, $ip2) = explode('::', $ip);
  86              if ($ip1 === '')
  87              {
  88                  $c1 = -1;
  89              }
  90              else
  91              {
  92                  $c1 = substr_count($ip1, ':');
  93              }
  94              if ($ip2 === '')
  95              {
  96                  $c2 = -1;
  97              }
  98              else
  99              {
 100                  $c2 = substr_count($ip2, ':');
 101              }
 102              if (strpos($ip2, '.') !== false)
 103              {
 104                  $c2++;
 105              }
 106              // ::
 107              if ($c1 === -1 && $c2 === -1)
 108              {
 109                  $ip = '0:0:0:0:0:0:0:0';
 110              }
 111              // ::xxx
 112              else if ($c1 === -1)
 113              {
 114                  $fill = str_repeat('0:', 7 - $c2);
 115                  $ip = str_replace('::', $fill, $ip);
 116              }
 117              // xxx::
 118              else if ($c2 === -1)
 119              {
 120                  $fill = str_repeat(':0', 7 - $c1);
 121                  $ip = str_replace('::', $fill, $ip);
 122              }
 123              // xxx::xxx
 124              else
 125              {
 126                  $fill = ':' . str_repeat('0:', 6 - $c2 - $c1);
 127                  $ip = str_replace('::', $fill, $ip);
 128              }
 129          }
 130          return $ip;
 131      }
 132  
 133      /**
 134       * Compresses an IPv6 address
 135       *
 136       * RFC 4291 allows you to compress concecutive zero pieces in an address to
 137       * '::'. This method expects a valid IPv6 address and compresses consecutive
 138       * zero pieces to '::'.
 139       *
 140       * Example:  FF01:0:0:0:0:0:0:101   ->  FF01::101
 141       *           0:0:0:0:0:0:0:1        ->  ::1
 142       *
 143       * @see uncompress()
 144       * @param string $ip An IPv6 address
 145       * @return string The compressed IPv6 address
 146       */
 147  	public static function compress($ip)
 148      {
 149          // Prepare the IP to be compressed
 150          $ip = self::uncompress($ip);
 151          $ip_parts = self::split_v6_v4($ip);
 152  
 153          // Replace all leading zeros
 154          $ip_parts[0] = preg_replace('/(^|:)0+([0-9])/', '\1\2', $ip_parts[0]);
 155  
 156          // Find bunches of zeros
 157          if (preg_match_all('/(?:^|:)(?:0(?::|$))+/', $ip_parts[0], $matches, PREG_OFFSET_CAPTURE))
 158          {
 159              $max = 0;
 160              $pos = null;
 161              foreach ($matches[0] as $match)
 162              {
 163                  if (strlen($match[0]) > $max)
 164                  {
 165                      $max = strlen($match[0]);
 166                      $pos = $match[1];
 167                  }
 168              }
 169  
 170              $ip_parts[0] = substr_replace($ip_parts[0], '::', $pos, $max);
 171          }
 172  
 173          if ($ip_parts[1] !== '')
 174          {
 175              return implode(':', $ip_parts);
 176          }
 177          else
 178          {
 179              return $ip_parts[0];
 180          }
 181      }
 182  
 183      /**
 184       * Splits an IPv6 address into the IPv6 and IPv4 representation parts
 185       *
 186       * RFC 4291 allows you to represent the last two parts of an IPv6 address
 187       * using the standard IPv4 representation
 188       *
 189       * Example:  0:0:0:0:0:0:13.1.68.3
 190       *           0:0:0:0:0:FFFF:129.144.52.38
 191       *
 192       * @param string $ip An IPv6 address
 193       * @return array [0] contains the IPv6 represented part, and [1] the IPv4 represented part
 194       */
 195  	private static function split_v6_v4($ip)
 196      {
 197          if (strpos($ip, '.') !== false)
 198          {
 199              $pos = strrpos($ip, ':');
 200              $ipv6_part = substr($ip, 0, $pos);
 201              $ipv4_part = substr($ip, $pos + 1);
 202              return array($ipv6_part, $ipv4_part);
 203          }
 204          else
 205          {
 206              return array($ip, '');
 207          }
 208      }
 209  
 210      /**
 211       * Checks an IPv6 address
 212       *
 213       * Checks if the given IP is a valid IPv6 address
 214       *
 215       * @param string $ip An IPv6 address
 216       * @return bool true if $ip is a valid IPv6 address
 217       */
 218  	public static function check_ipv6($ip)
 219      {
 220          $ip = self::uncompress($ip);
 221          list($ipv6, $ipv4) = self::split_v6_v4($ip);
 222          $ipv6 = explode(':', $ipv6);
 223          $ipv4 = explode('.', $ipv4);
 224          if (count($ipv6) === 8 && count($ipv4) === 1 || count($ipv6) === 6 && count($ipv4) === 4)
 225          {
 226              foreach ($ipv6 as $ipv6_part)
 227              {
 228                  // The section can't be empty
 229                  if ($ipv6_part === '')
 230                      return false;
 231  
 232                  // Nor can it be over four characters
 233                  if (strlen($ipv6_part) > 4)
 234                      return false;
 235  
 236                  // Remove leading zeros (this is safe because of the above)
 237                  $ipv6_part = ltrim($ipv6_part, '0');
 238                  if ($ipv6_part === '')
 239                      $ipv6_part = '0';
 240  
 241                  // Check the value is valid
 242                  $value = hexdec($ipv6_part);
 243                  if (dechex($value) !== strtolower($ipv6_part) || $value < 0 || $value > 0xFFFF)
 244                      return false;
 245              }
 246              if (count($ipv4) === 4)
 247              {
 248                  foreach ($ipv4 as $ipv4_part)
 249                  {
 250                      $value = (int) $ipv4_part;
 251                      if ((string) $value !== $ipv4_part || $value < 0 || $value > 0xFF)
 252                          return false;
 253                  }
 254              }
 255              return true;
 256          }
 257          else
 258          {
 259              return false;
 260          }
 261      }
 262  
 263      /**
 264       * Checks if the given IP is a valid IPv6 address
 265       *
 266       * @codeCoverageIgnore
 267       * @deprecated Use {@see SimplePie_Net_IPv6::check_ipv6()} instead
 268       * @see check_ipv6
 269       * @param string $ip An IPv6 address
 270       * @return bool true if $ip is a valid IPv6 address
 271       */
 272  	public static function checkIPv6($ip)
 273      {
 274          return self::check_ipv6($ip);
 275      }
 276  }