wp-includes/SimplePie/Net/IPv6.php

   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 }