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 }