00001 <?php
00002
00003
00004
00005
00006
00007
00008
00009
00010 define( 'RE_IP_BYTE', '(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|0?[0-9]?[0-9])');
00011 define( 'RE_IP_ADD' , RE_IP_BYTE . '\.' . RE_IP_BYTE . '\.' . RE_IP_BYTE . '\.' . RE_IP_BYTE );
00012
00013 define( 'RE_IP_PREFIX', '(3[0-2]|[12]?\d)');
00014 define( 'RE_IP_BLOCK', RE_IP_ADD . '\/' . RE_IP_PREFIX);
00015
00016 define( 'RE_IPV6_WORD', '([0-9A-Fa-f]{1,4})' );
00017 define( 'RE_IPV6_GAP', ':(?:0+:)*(?::(?:0+:)*)?' );
00018 define( 'RE_IPV6_V4_PREFIX', '0*' . RE_IPV6_GAP . '(?:ffff:)?' );
00019
00020 define( 'RE_IPV6_PREFIX', '(12[0-8]|1[01][0-9]|[1-9]?\d)');
00021
00022 define( 'RE_IPV6_ADD', '(:(:' . RE_IPV6_WORD . '){1,7}|' . RE_IPV6_WORD . '(:{1,2}' . RE_IPV6_WORD . '|::$){1,7})' );
00023 define( 'RE_IPV6_BLOCK', RE_IPV6_ADD . '\/' . RE_IPV6_PREFIX );
00024
00025 define( 'IP_ADDRESS_STRING',
00026 '(?:' .
00027 RE_IP_ADD . '(\/' . RE_IP_PREFIX . '|)' .
00028 '|' .
00029 RE_IPV6_ADD . '(\/' . RE_IPV6_PREFIX . '|)' .
00030 ')' );
00031
00036 class IP {
00043 public static function isIPAddress( $ip ) {
00044 if ( !$ip ) return false;
00045 if ( is_array( $ip ) ) {
00046 throw new MWException( "invalid value passed to " . __METHOD__ );
00047 }
00048
00049 return preg_match( '/^' . IP_ADDRESS_STRING . '$/', $ip) && ( substr_count($ip, '::') < 2 );
00050 }
00051
00052 public static function isIPv6( $ip ) {
00053 if ( !$ip ) return false;
00054 if( is_array( $ip ) ) {
00055 throw new MWException( "invalid value passed to " . __METHOD__ );
00056 }
00057
00058 return preg_match( '/^' . RE_IPV6_ADD . '(\/' . RE_IPV6_PREFIX . '|)$/', $ip) && ( substr_count($ip, '::') < 2);
00059 }
00060
00061 public static function isIPv4( $ip ) {
00062 if ( !$ip ) return false;
00063 return preg_match( '/^' . RE_IP_ADD . '(\/' . RE_IP_PREFIX . '|)$/', $ip);
00064 }
00065
00073 public static function IPv4toIPv6( $ip ) {
00074 if ( !$ip ) return null;
00075
00076 if ( self::isIPv6( $ip ) ) return $ip;
00077
00078 if ( strpos( $ip, '/' ) !== false ) {
00079 $parts = explode( '/', $ip, 2 );
00080 if ( count( $parts ) != 2 ) {
00081 return false;
00082 }
00083 $network = self::toUnsigned( $parts[0] );
00084 if ( $network !== false && is_numeric( $parts[1] ) && $parts[1] >= 0 && $parts[1] <= 32 ) {
00085 $bits = $parts[1] + 96;
00086 return self::toOctet( $network ) . "/$bits";
00087 } else {
00088 return false;
00089 }
00090 }
00091 return self::toOctet( self::toUnsigned( $ip ) );
00092 }
00093
00099 public static function toUnsigned6( $ip ) {
00100 if ( !$ip ) return null;
00101 $ip = explode(':', self::sanitizeIP( $ip ) );
00102 $r_ip = '';
00103 foreach ($ip as $v) {
00104 $r_ip .= str_pad( $v, 4, 0, STR_PAD_LEFT );
00105 }
00106 $r_ip = wfBaseConvert( $r_ip, 16, 10 );
00107 return $r_ip;
00108 }
00109
00116 public static function sanitizeIP( $ip ) {
00117 $ip = trim( $ip );
00118 if ( $ip === '' ) return null;
00119
00120 if ( self::isIPv4($ip) ) return $ip;
00121
00122 if ( !self::isIPv6($ip) ) return $ip;
00123
00124 $ip = strtoupper( $ip );
00125
00126 if ( strpos( $ip, '::' ) !== false ) {
00127 $ip = str_replace('::', str_repeat(':0', 8 - substr_count($ip, ':')) . ':', $ip);
00128 }
00129
00130 if ( $ip[0] == ':' ) $ip = "0$ip";
00131
00132 $ip = preg_replace( '/(^|:)0+' . RE_IPV6_WORD . '/', '$1$2', $ip );
00133 return $ip;
00134 }
00135
00141 public static function toOctet( $ip_int ) {
00142
00143 $ip_hex = wfBaseConvert($ip_int, 10, 16, 32, false);
00144
00145 $ip_oct = substr( $ip_hex, 0, 4 );
00146 for ($n=1; $n < 8; $n++) {
00147 $ip_oct .= ':' . substr($ip_hex, 4*$n, 4);
00148 }
00149
00150 $ip_oct = preg_replace( '/(^|:)0+' . RE_IPV6_WORD . '/', '$1$2', $ip_oct );
00151 return $ip_oct;
00152 }
00153
00159 public static function HextoOctet( $ip_hex ) {
00160
00161 $ip_hex = str_pad( strtoupper($ip_hex), 32, '0');
00162
00163 $ip_oct = substr( $ip_hex, 0, 4 );
00164 for ($n=1; $n < 8; $n++) {
00165 $ip_oct .= ':' . substr($ip_hex, 4*$n, 4);
00166 }
00167
00168 $ip_oct = preg_replace( '/(^|:)0+' . RE_IPV6_WORD . '/', '$1$2', $ip_oct );
00169 return $ip_oct;
00170 }
00171
00177 public static function hexToQuad( $ip ) {
00178
00179 $dec = wfBaseConvert( $ip, 16, 10 );
00180 $parts[3] = $dec % 256;
00181 $dec /= 256;
00182 $parts[2] = $dec % 256;
00183 $dec /= 256;
00184 $parts[1] = $dec % 256;
00185 $parts[0] = $dec / 256;
00186 return implode( '.', array_reverse( $parts ) );
00187 }
00188
00193 public static function parseCIDR6( $range ) {
00194 # Expand any IPv6 IP
00195 $parts = explode( '/', IP::sanitizeIP( $range ), 2 );
00196 if ( count( $parts ) != 2 ) {
00197 return array( false, false );
00198 }
00199 $network = self::toUnsigned6( $parts[0] );
00200 if ( $network !== false && is_numeric( $parts[1] ) && $parts[1] >= 0 && $parts[1] <= 128 ) {
00201 $bits = $parts[1];
00202 if ( $bits == 0 ) {
00203 $network = 0;
00204 } else {
00205 # Native 32 bit functions WONT work here!!!
00206 # Convert to a padded binary number
00207 $network = wfBaseConvert( $network, 10, 2, 128 );
00208 # Truncate the last (128-$bits) bits and replace them with zeros
00209 $network = str_pad( substr( $network, 0, $bits ), 128, 0, STR_PAD_RIGHT );
00210 # Convert back to an integer
00211 $network = wfBaseConvert( $network, 2, 10 );
00212 }
00213 } else {
00214 $network = false;
00215 $bits = false;
00216 }
00217 return array( $network, $bits );
00218 }
00219
00230 public static function parseRange6( $range ) {
00231 # Expand any IPv6 IP
00232 $range = IP::sanitizeIP( $range );
00233 if ( strpos( $range, '/' ) !== false ) {
00234 # CIDR
00235 list( $network, $bits ) = self::parseCIDR6( $range );
00236 if ( $network === false ) {
00237 $start = $end = false;
00238 } else {
00239 $start = wfBaseConvert( $network, 10, 16, 32, false );
00240 # Turn network to binary (again)
00241 $end = wfBaseConvert( $network, 10, 2, 128 );
00242 # Truncate the last (128-$bits) bits and replace them with ones
00243 $end = str_pad( substr( $end, 0, $bits ), 128, 1, STR_PAD_RIGHT );
00244 # Convert to hex
00245 $end = wfBaseConvert( $end, 2, 16, 32, false );
00246 # see toHex() comment
00247 $start = "v6-$start"; $end = "v6-$end";
00248 }
00249 } elseif ( strpos( $range, '-' ) !== false ) {
00250 # Explicit range
00251 list( $start, $end ) = array_map( 'trim', explode( '-', $range, 2 ) );
00252 $start = self::toUnsigned6( $start ); $end = self::toUnsigned6( $end );
00253 if ( $start > $end ) {
00254 $start = $end = false;
00255 } else {
00256 $start = wfBaseConvert( $start, 10, 16, 32, false );
00257 $end = wfBaseConvert( $end, 10, 16, 32, false );
00258 }
00259 # see toHex() comment
00260 $start = "v6-$start"; $end = "v6-$end";
00261 } else {
00262 # Single IP
00263 $start = $end = self::toHex( $range );
00264 }
00265 if ( $start === false || $end === false ) {
00266 return array( false, false );
00267 } else {
00268 return array( $start, $end );
00269 }
00270 }
00271
00276 public static function isValid( $ip ) {
00277 return ( preg_match( '/^' . RE_IP_ADD . '$/', $ip) || preg_match( '/^' . RE_IPV6_ADD . '$/', $ip) );
00278 }
00279
00284 public static function isValidBlock( $ipblock ) {
00285 return ( count(self::toArray($ipblock)) == 1 + 5 );
00286 }
00287
00293 public static function isPublic( $ip ) {
00294 $n = self::toUnsigned( $ip );
00295 if ( !$n ) {
00296 return false;
00297 }
00298
00299
00300
00301 if( $ip != long2ip( $n ) ) {
00302 return false;
00303 }
00304
00305 static $privateRanges = false;
00306 if ( !$privateRanges ) {
00307 $privateRanges = array(
00308 array( '10.0.0.0', '10.255.255.255' ), # RFC 1918 (private)
00309 array( '172.16.0.0', '172.31.255.255' ), # "
00310 array( '192.168.0.0', '192.168.255.255' ), # "
00311 array( '0.0.0.0', '0.255.255.255' ), # this network
00312 array( '127.0.0.0', '127.255.255.255' ), # loopback
00313 );
00314 }
00315
00316 foreach ( $privateRanges as $r ) {
00317 $start = self::toUnsigned( $r[0] );
00318 $end = self::toUnsigned( $r[1] );
00319 if ( $n >= $start && $n <= $end ) {
00320 return false;
00321 }
00322 }
00323 return true;
00324 }
00325
00333 public static function toArray( $ipblock ) {
00334 $matches = array();
00335 if( preg_match( '/^' . RE_IP_ADD . '(?:\/(?:'.RE_IP_PREFIX.'))?' . '$/', $ipblock, $matches ) ) {
00336 return $matches;
00337 } else if ( preg_match( '/^' . RE_IPV6_ADD . '(?:\/(?:'.RE_IPV6_PREFIX.'))?' . '$/', $ipblock, $matches ) ) {
00338 return $matches;
00339 } else {
00340 return false;
00341 }
00342 }
00343
00355 public static function toHex( $ip ) {
00356 $n = self::toUnsigned( $ip );
00357 if ( $n !== false ) {
00358 $n = self::isIPv6($ip) ? "v6-" . wfBaseConvert( $n, 10, 16, 32, false ) : wfBaseConvert( $n, 10, 16, 8, false );
00359 }
00360 return $n;
00361 }
00362
00370 public static function toUnsigned( $ip ) {
00371
00372 if ( self::isIPv6( $ip ) ) {
00373 return self::toUnsigned6( $ip );
00374 }
00375 if ( $ip == '255.255.255.255' ) {
00376 $n = -1;
00377 } else {
00378 $n = ip2long( $ip );
00379 if ( $n == -1 || $n === false ) { # Return value on error depends on PHP version
00380 $n = false;
00381 }
00382 }
00383 if ( $n < 0 ) {
00384 $n += pow( 2, 32 );
00385 }
00386 return $n;
00387 }
00388
00393 public static function toSigned( $ip ) {
00394 if ( $ip == '255.255.255.255' ) {
00395 $n = -1;
00396 } else {
00397 $n = ip2long( $ip );
00398 if ( $n == -1 ) {
00399 $n = false;
00400 }
00401 }
00402 return $n;
00403 }
00404
00409 public static function parseCIDR( $range ) {
00410 $parts = explode( '/', $range, 2 );
00411 if ( count( $parts ) != 2 ) {
00412 return array( false, false );
00413 }
00414 $network = self::toSigned( $parts[0] );
00415 if ( $network !== false && is_numeric( $parts[1] ) && $parts[1] >= 0 && $parts[1] <= 32 ) {
00416 $bits = $parts[1];
00417 if ( $bits == 0 ) {
00418 $network = 0;
00419 } else {
00420 $network &= ~((1 << (32 - $bits)) - 1);
00421 }
00422 # Convert to unsigned
00423 if ( $network < 0 ) {
00424 $network += pow( 2, 32 );
00425 }
00426 } else {
00427 $network = false;
00428 $bits = false;
00429 }
00430 return array( $network, $bits );
00431 }
00432
00447 public static function parseRange( $range ) {
00448
00449 if ( self::isIPv6( $range ) ) {
00450 return self::parseRange6( $range );
00451 }
00452 if ( strpos( $range, '/' ) !== false ) {
00453 # CIDR
00454 list( $network, $bits ) = self::parseCIDR( $range );
00455 if ( $network === false ) {
00456 $start = $end = false;
00457 } else {
00458 $start = sprintf( '%08X', $network );
00459 $end = sprintf( '%08X', $network + pow( 2, (32 - $bits) ) - 1 );
00460 }
00461 } elseif ( strpos( $range, '-' ) !== false ) {
00462 # Explicit range
00463 list( $start, $end ) = array_map( 'trim', explode( '-', $range, 2 ) );
00464 if( self::isIPAddress( $start ) && self::isIPAddress( $end ) ) {
00465 $start = self::toUnsigned( $start ); $end = self::toUnsigned( $end );
00466 if ( $start > $end ) {
00467 $start = $end = false;
00468 } else {
00469 $start = sprintf( '%08X', $start );
00470 $end = sprintf( '%08X', $end );
00471 }
00472 } else {
00473 $start = $end = false;
00474 }
00475 } else {
00476 # Single IP
00477 $start = $end = self::toHex( $range );
00478 }
00479 if ( $start === false || $end === false ) {
00480 return array( false, false );
00481 } else {
00482 return array( $start, $end );
00483 }
00484 }
00485
00492 public static function isInRange( $addr, $range ) {
00493
00494 $unsignedIP = self::toHex( $addr );
00495 list( $start, $end ) = self::parseRange( $range );
00496 return (($unsignedIP >= $start) && ($unsignedIP <= $end));
00497 }
00498
00509 public static function canonicalize( $addr ) {
00510 if ( self::isValid( $addr ) )
00511 return $addr;
00512
00513
00514 if ( strpos($addr,':') !==false && strpos($addr,'.') !==false ) {
00515 $addr = str_replace( '.', ':', $addr );
00516 if( IP::isIPv6( $addr ) )
00517 return $addr;
00518 }
00519
00520
00521 $m = array();
00522 if ( preg_match( '/^0*' . RE_IPV6_GAP . '1$/', $addr, $m ) )
00523 return '127.0.0.1';
00524
00525
00526 if ( preg_match( '/^' . RE_IPV6_V4_PREFIX . '(' . RE_IP_ADD . ')$/i', $addr, $m ) )
00527 return $m[1];
00528 if ( preg_match( '/^' . RE_IPV6_V4_PREFIX . RE_IPV6_WORD . ':' . RE_IPV6_WORD . '$/i', $addr, $m ) )
00529 return long2ip( ( hexdec( $m[1] ) << 16 ) + hexdec( $m[2] ) );
00530
00531 return null;
00532 }
00533 }