MediaWiki  1.23.2
IP.php
Go to the documentation of this file.
1 <?php
24 // Some regex definition to "play" with IP address and IP address blocks
25 
26 // An IPv4 address is made of 4 bytes from x00 to xFF which is d0 to d255
27 define( 'RE_IP_BYTE', '(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|0?[0-9]?[0-9])' );
28 define( 'RE_IP_ADD', RE_IP_BYTE . '\.' . RE_IP_BYTE . '\.' . RE_IP_BYTE . '\.' . RE_IP_BYTE );
29 // An IPv4 block is an IP address and a prefix (d1 to d32)
30 define( 'RE_IP_PREFIX', '(3[0-2]|[12]?\d)' );
31 define( 'RE_IP_BLOCK', RE_IP_ADD . '\/' . RE_IP_PREFIX );
32 
33 // An IPv6 address is made up of 8 words (each x0000 to xFFFF).
34 // However, the "::" abbreviation can be used on consecutive x0000 words.
35 define( 'RE_IPV6_WORD', '([0-9A-Fa-f]{1,4})' );
36 define( 'RE_IPV6_PREFIX', '(12[0-8]|1[01][0-9]|[1-9]?\d)' );
37 define( 'RE_IPV6_ADD',
38  '(?:' . // starts with "::" (including "::")
39  ':(?::|(?::' . RE_IPV6_WORD . '){1,7})' .
40  '|' . // ends with "::" (except "::")
41  RE_IPV6_WORD . '(?::' . RE_IPV6_WORD . '){0,6}::' .
42  '|' . // contains one "::" in the middle (the ^ makes the test fail if none found)
43  RE_IPV6_WORD . '(?::((?(-1)|:))?' . RE_IPV6_WORD . '){1,6}(?(-2)|^)' .
44  '|' . // contains no "::"
45  RE_IPV6_WORD . '(?::' . RE_IPV6_WORD . '){7}' .
46  ')'
47 );
48 // An IPv6 block is an IP address and a prefix (d1 to d128)
49 define( 'RE_IPV6_BLOCK', RE_IPV6_ADD . '\/' . RE_IPV6_PREFIX );
50 // For IPv6 canonicalization (NOT for strict validation; these are quite lax!)
51 define( 'RE_IPV6_GAP', ':(?:0+:)*(?::(?:0+:)*)?' );
52 define( 'RE_IPV6_V4_PREFIX', '0*' . RE_IPV6_GAP . '(?:ffff:)?' );
53 
54 // This might be useful for regexps used elsewhere, matches any IPv6 or IPv6 address or network
55 define( 'IP_ADDRESS_STRING',
56  '(?:' .
57  RE_IP_ADD . '(?:\/' . RE_IP_PREFIX . ')?' . // IPv4
58  '|' .
59  RE_IPV6_ADD . '(?:\/' . RE_IPV6_PREFIX . ')?' . // IPv6
60  ')'
61 );
62 
67 class IP {
76  public static function isIPAddress( $ip ) {
77  return (bool)preg_match( '/^' . IP_ADDRESS_STRING . '$/', $ip );
78  }
79 
87  public static function isIPv6( $ip ) {
88  return (bool)preg_match( '/^' . RE_IPV6_ADD . '(?:\/' . RE_IPV6_PREFIX . ')?$/', $ip );
89  }
90 
98  public static function isIPv4( $ip ) {
99  return (bool)preg_match( '/^' . RE_IP_ADD . '(?:\/' . RE_IP_PREFIX . ')?$/', $ip );
100  }
101 
110  public static function isValid( $ip ) {
111  return ( preg_match( '/^' . RE_IP_ADD . '$/', $ip )
112  || preg_match( '/^' . RE_IPV6_ADD . '$/', $ip ) );
113  }
114 
123  public static function isValidBlock( $ipblock ) {
124  return ( preg_match( '/^' . RE_IPV6_BLOCK . '$/', $ipblock )
125  || preg_match( '/^' . RE_IP_BLOCK . '$/', $ipblock ) );
126  }
127 
136  public static function sanitizeIP( $ip ) {
137  $ip = trim( $ip );
138  if ( $ip === '' ) {
139  return null;
140  }
141  if ( self::isIPv4( $ip ) || !self::isIPv6( $ip ) ) {
142  return $ip; // nothing else to do for IPv4 addresses or invalid ones
143  }
144  // Remove any whitespaces, convert to upper case
145  $ip = strtoupper( $ip );
146  // Expand zero abbreviations
147  $abbrevPos = strpos( $ip, '::' );
148  if ( $abbrevPos !== false ) {
149  // We know this is valid IPv6. Find the last index of the
150  // address before any CIDR number (e.g. "a:b:c::/24").
151  $CIDRStart = strpos( $ip, "/" );
152  $addressEnd = ( $CIDRStart !== false )
153  ? $CIDRStart - 1
154  : strlen( $ip ) - 1;
155  // If the '::' is at the beginning...
156  if ( $abbrevPos == 0 ) {
157  $repeat = '0:';
158  $extra = ( $ip == '::' ) ? '0' : ''; // for the address '::'
159  $pad = 9; // 7+2 (due to '::')
160  // If the '::' is at the end...
161  } elseif ( $abbrevPos == ( $addressEnd - 1 ) ) {
162  $repeat = ':0';
163  $extra = '';
164  $pad = 9; // 7+2 (due to '::')
165  // If the '::' is in the middle...
166  } else {
167  $repeat = ':0';
168  $extra = ':';
169  $pad = 8; // 6+2 (due to '::')
170  }
171  $ip = str_replace( '::',
172  str_repeat( $repeat, $pad - substr_count( $ip, ':' ) ) . $extra,
173  $ip
174  );
175  }
176  // Remove leading zeros from each bloc as needed
177  $ip = preg_replace( '/(^|:)0+(' . RE_IPV6_WORD . ')/', '$1$2', $ip );
178 
179  return $ip;
180  }
181 
189  public static function prettifyIP( $ip ) {
190  $ip = self::sanitizeIP( $ip ); // normalize (removes '::')
191  if ( self::isIPv6( $ip ) ) {
192  // Split IP into an address and a CIDR
193  if ( strpos( $ip, '/' ) !== false ) {
194  list( $ip, $cidr ) = explode( '/', $ip, 2 );
195  } else {
196  list( $ip, $cidr ) = array( $ip, '' );
197  }
198  // Get the largest slice of words with multiple zeros
199  $offset = 0;
200  $longest = $longestPos = false;
201  while ( preg_match(
202  '!(?:^|:)0(?::0)+(?:$|:)!', $ip, $m, PREG_OFFSET_CAPTURE, $offset
203  ) ) {
204  list( $match, $pos ) = $m[0]; // full match
205  if ( strlen( $match ) > strlen( $longest ) ) {
206  $longest = $match;
207  $longestPos = $pos;
208  }
209  $offset = ( $pos + strlen( $match ) ); // advance
210  }
211  if ( $longest !== false ) {
212  // Replace this portion of the string with the '::' abbreviation
213  $ip = substr_replace( $ip, '::', $longestPos, strlen( $longest ) );
214  }
215  // Add any CIDR back on
216  if ( $cidr !== '' ) {
217  $ip = "{$ip}/{$cidr}";
218  }
219  // Convert to lower case to make it more readable
220  $ip = strtolower( $ip );
221  }
222 
223  return $ip;
224  }
225 
242  public static function splitHostAndPort( $both ) {
243  if ( substr( $both, 0, 1 ) === '[' ) {
244  if ( preg_match( '/^\[(' . RE_IPV6_ADD . ')\](?::(?P<port>\d+))?$/', $both, $m ) ) {
245  if ( isset( $m['port'] ) ) {
246  return array( $m[1], intval( $m['port'] ) );
247  } else {
248  return array( $m[1], false );
249  }
250  } else {
251  // Square bracket found but no IPv6
252  return false;
253  }
254  }
255  $numColons = substr_count( $both, ':' );
256  if ( $numColons >= 2 ) {
257  // Is it a bare IPv6 address?
258  if ( preg_match( '/^' . RE_IPV6_ADD . '$/', $both ) ) {
259  return array( $both, false );
260  } else {
261  // Not valid IPv6, but too many colons for anything else
262  return false;
263  }
264  }
265  if ( $numColons >= 1 ) {
266  // Host:port?
267  $bits = explode( ':', $both );
268  if ( preg_match( '/^\d+/', $bits[1] ) ) {
269  return array( $bits[0], intval( $bits[1] ) );
270  } else {
271  // Not a valid port
272  return false;
273  }
274  }
275 
276  // Plain hostname
277  return array( $both, false );
278  }
279 
291  public static function combineHostAndPort( $host, $port, $defaultPort = false ) {
292  if ( strpos( $host, ':' ) !== false ) {
293  $host = "[$host]";
294  }
295  if ( $defaultPort !== false && $port == $defaultPort ) {
296  return $host;
297  } else {
298  return "$host:$port";
299  }
300  }
301 
308  public static function toOctet( $ip_int ) {
309  return self::hexToOctet( wfBaseConvert( $ip_int, 10, 16, 32, false ) );
310  }
311 
318  public static function formatHex( $hex ) {
319  if ( substr( $hex, 0, 3 ) == 'v6-' ) { // IPv6
320  return self::hexToOctet( substr( $hex, 3 ) );
321  } else { // IPv4
322  return self::hexToQuad( $hex );
323  }
324  }
325 
332  public static function hexToOctet( $ip_hex ) {
333  // Pad hex to 32 chars (128 bits)
334  $ip_hex = str_pad( strtoupper( $ip_hex ), 32, '0', STR_PAD_LEFT );
335  // Separate into 8 words
336  $ip_oct = substr( $ip_hex, 0, 4 );
337  for ( $n = 1; $n < 8; $n++ ) {
338  $ip_oct .= ':' . substr( $ip_hex, 4 * $n, 4 );
339  }
340  // NO leading zeroes
341  $ip_oct = preg_replace( '/(^|:)0+(' . RE_IPV6_WORD . ')/', '$1$2', $ip_oct );
342 
343  return $ip_oct;
344  }
345 
352  public static function hexToQuad( $ip_hex ) {
353  // Pad hex to 8 chars (32 bits)
354  $ip_hex = str_pad( strtoupper( $ip_hex ), 8, '0', STR_PAD_LEFT );
355  // Separate into four quads
356  $s = '';
357  for ( $i = 0; $i < 4; $i++ ) {
358  if ( $s !== '' ) {
359  $s .= '.';
360  }
361  $s .= base_convert( substr( $ip_hex, $i * 2, 2 ), 16, 10 );
362  }
363 
364  return $s;
365  }
366 
374  public static function isPublic( $ip ) {
375  if ( self::isIPv6( $ip ) ) {
376  return self::isPublic6( $ip );
377  }
378  $n = self::toUnsigned( $ip );
379  if ( !$n ) {
380  return false;
381  }
382 
383  // ip2long accepts incomplete addresses, as well as some addresses
384  // followed by garbage characters. Check that it's really valid.
385  if ( $ip != long2ip( $n ) ) {
386  return false;
387  }
388 
389  static $privateRanges = false;
390  if ( !$privateRanges ) {
391  $privateRanges = array(
392  array( '10.0.0.0', '10.255.255.255' ), # RFC 1918 (private)
393  array( '172.16.0.0', '172.31.255.255' ), # RFC 1918 (private)
394  array( '192.168.0.0', '192.168.255.255' ), # RFC 1918 (private)
395  array( '0.0.0.0', '0.255.255.255' ), # this network
396  array( '127.0.0.0', '127.255.255.255' ), # loopback
397  );
398  }
399 
400  foreach ( $privateRanges as $r ) {
401  $start = self::toUnsigned( $r[0] );
402  $end = self::toUnsigned( $r[1] );
403  if ( $n >= $start && $n <= $end ) {
404  return false;
405  }
406  }
407 
408  return true;
409  }
410 
418  private static function isPublic6( $ip ) {
419  static $privateRanges = false;
420  if ( !$privateRanges ) {
421  $privateRanges = array(
422  array( 'fc00::', 'fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff' ), # RFC 4193 (local)
423  array( '0:0:0:0:0:0:0:1', '0:0:0:0:0:0:0:1' ), # loopback
424  );
425  }
426  $n = self::toHex( $ip );
427  foreach ( $privateRanges as $r ) {
428  $start = self::toHex( $r[0] );
429  $end = self::toHex( $r[1] );
430  if ( $n >= $start && $n <= $end ) {
431  return false;
432  }
433  }
434 
435  return true;
436  }
437 
449  public static function toHex( $ip ) {
450  if ( self::isIPv6( $ip ) ) {
451  $n = 'v6-' . self::IPv6ToRawHex( $ip );
452  } else {
453  $n = self::toUnsigned( $ip );
454  if ( $n !== false ) {
455  $n = wfBaseConvert( $n, 10, 16, 8, false );
456  }
457  }
458 
459  return $n;
460  }
461 
468  private static function IPv6ToRawHex( $ip ) {
469  $ip = self::sanitizeIP( $ip );
470  if ( !$ip ) {
471  return null;
472  }
473  $r_ip = '';
474  foreach ( explode( ':', $ip ) as $v ) {
475  $r_ip .= str_pad( $v, 4, 0, STR_PAD_LEFT );
476  }
477 
478  return $r_ip;
479  }
480 
488  public static function toUnsigned( $ip ) {
489  if ( self::isIPv6( $ip ) ) {
490  $n = self::toUnsigned6( $ip );
491  } else {
492  // Bug 60035: an IP with leading 0's fails in ip2long sometimes (e.g. *.08)
493  $ip = preg_replace( '/(?<=\.)0+(?=[1-9])/', '', $ip );
494  $n = ip2long( $ip );
495  if ( $n < 0 ) {
496  $n += pow( 2, 32 );
497  # On 32-bit platforms (and on Windows), 2^32 does not fit into an int,
498  # so $n becomes a float. We convert it to string instead.
499  if ( is_float( $n ) ) {
500  $n = (string)$n;
501  }
502  }
503  }
504 
505  return $n;
506  }
507 
512  private static function toUnsigned6( $ip ) {
513  return wfBaseConvert( self::IPv6ToRawHex( $ip ), 16, 10 );
514  }
515 
523  public static function parseCIDR( $range ) {
524  if ( self::isIPv6( $range ) ) {
525  return self::parseCIDR6( $range );
526  }
527  $parts = explode( '/', $range, 2 );
528  if ( count( $parts ) != 2 ) {
529  return array( false, false );
530  }
531  list( $network, $bits ) = $parts;
532  $network = ip2long( $network );
533  if ( $network !== false && is_numeric( $bits ) && $bits >= 0 && $bits <= 32 ) {
534  if ( $bits == 0 ) {
535  $network = 0;
536  } else {
537  $network &= ~( ( 1 << ( 32 - $bits ) ) - 1 );
538  }
539  # Convert to unsigned
540  if ( $network < 0 ) {
541  $network += pow( 2, 32 );
542  }
543  } else {
544  $network = false;
545  $bits = false;
546  }
547 
548  return array( $network, $bits );
549  }
550 
566  public static function parseRange( $range ) {
567  // CIDR notation
568  if ( strpos( $range, '/' ) !== false ) {
569  if ( self::isIPv6( $range ) ) {
570  return self::parseRange6( $range );
571  }
572  list( $network, $bits ) = self::parseCIDR( $range );
573  if ( $network === false ) {
574  $start = $end = false;
575  } else {
576  $start = sprintf( '%08X', $network );
577  $end = sprintf( '%08X', $network + pow( 2, ( 32 - $bits ) ) - 1 );
578  }
579  // Explicit range
580  } elseif ( strpos( $range, '-' ) !== false ) {
581  list( $start, $end ) = array_map( 'trim', explode( '-', $range, 2 ) );
582  if ( self::isIPv6( $start ) && self::isIPv6( $end ) ) {
583  return self::parseRange6( $range );
584  }
585  if ( self::isIPv4( $start ) && self::isIPv4( $end ) ) {
586  $start = self::toUnsigned( $start );
587  $end = self::toUnsigned( $end );
588  if ( $start > $end ) {
589  $start = $end = false;
590  } else {
591  $start = sprintf( '%08X', $start );
592  $end = sprintf( '%08X', $end );
593  }
594  } else {
595  $start = $end = false;
596  }
597  } else {
598  # Single IP
599  $start = $end = self::toHex( $range );
600  }
601  if ( $start === false || $end === false ) {
602  return array( false, false );
603  } else {
604  return array( $start, $end );
605  }
606  }
607 
616  private static function parseCIDR6( $range ) {
617  # Explode into <expanded IP,range>
618  $parts = explode( '/', IP::sanitizeIP( $range ), 2 );
619  if ( count( $parts ) != 2 ) {
620  return array( false, false );
621  }
622  list( $network, $bits ) = $parts;
623  $network = self::IPv6ToRawHex( $network );
624  if ( $network !== false && is_numeric( $bits ) && $bits >= 0 && $bits <= 128 ) {
625  if ( $bits == 0 ) {
626  $network = "0";
627  } else {
628  # Native 32 bit functions WONT work here!!!
629  # Convert to a padded binary number
630  $network = wfBaseConvert( $network, 16, 2, 128 );
631  # Truncate the last (128-$bits) bits and replace them with zeros
632  $network = str_pad( substr( $network, 0, $bits ), 128, 0, STR_PAD_RIGHT );
633  # Convert back to an integer
634  $network = wfBaseConvert( $network, 2, 10 );
635  }
636  } else {
637  $network = false;
638  $bits = false;
639  }
640 
641  return array( $network, (int)$bits );
642  }
643 
657  private static function parseRange6( $range ) {
658  # Expand any IPv6 IP
659  $range = IP::sanitizeIP( $range );
660  // CIDR notation...
661  if ( strpos( $range, '/' ) !== false ) {
662  list( $network, $bits ) = self::parseCIDR6( $range );
663  if ( $network === false ) {
664  $start = $end = false;
665  } else {
666  $start = wfBaseConvert( $network, 10, 16, 32, false );
667  # Turn network to binary (again)
668  $end = wfBaseConvert( $network, 10, 2, 128 );
669  # Truncate the last (128-$bits) bits and replace them with ones
670  $end = str_pad( substr( $end, 0, $bits ), 128, 1, STR_PAD_RIGHT );
671  # Convert to hex
672  $end = wfBaseConvert( $end, 2, 16, 32, false );
673  # see toHex() comment
674  $start = "v6-$start";
675  $end = "v6-$end";
676  }
677  // Explicit range notation...
678  } elseif ( strpos( $range, '-' ) !== false ) {
679  list( $start, $end ) = array_map( 'trim', explode( '-', $range, 2 ) );
680  $start = self::toUnsigned6( $start );
681  $end = self::toUnsigned6( $end );
682  if ( $start > $end ) {
683  $start = $end = false;
684  } else {
685  $start = wfBaseConvert( $start, 10, 16, 32, false );
686  $end = wfBaseConvert( $end, 10, 16, 32, false );
687  }
688  # see toHex() comment
689  $start = "v6-$start";
690  $end = "v6-$end";
691  } else {
692  # Single IP
693  $start = $end = self::toHex( $range );
694  }
695  if ( $start === false || $end === false ) {
696  return array( false, false );
697  } else {
698  return array( $start, $end );
699  }
700  }
701 
709  public static function isInRange( $addr, $range ) {
710  $hexIP = self::toHex( $addr );
711  list( $start, $end ) = self::parseRange( $range );
712 
713  return ( strcmp( $hexIP, $start ) >= 0 &&
714  strcmp( $hexIP, $end ) <= 0 );
715  }
716 
727  public static function canonicalize( $addr ) {
728  // remove zone info (bug 35738)
729  $addr = preg_replace( '/\%.*/', '', $addr );
730 
731  if ( self::isValid( $addr ) ) {
732  return $addr;
733  }
734  // Turn mapped addresses from ::ce:ffff:1.2.3.4 to 1.2.3.4
735  if ( strpos( $addr, ':' ) !== false && strpos( $addr, '.' ) !== false ) {
736  $addr = substr( $addr, strrpos( $addr, ':' ) + 1 );
737  if ( self::isIPv4( $addr ) ) {
738  return $addr;
739  }
740  }
741  // IPv6 loopback address
742  $m = array();
743  if ( preg_match( '/^0*' . RE_IPV6_GAP . '1$/', $addr, $m ) ) {
744  return '127.0.0.1';
745  }
746  // IPv4-mapped and IPv4-compatible IPv6 addresses
747  if ( preg_match( '/^' . RE_IPV6_V4_PREFIX . '(' . RE_IP_ADD . ')$/i', $addr, $m ) ) {
748  return $m[1];
749  }
750  if ( preg_match( '/^' . RE_IPV6_V4_PREFIX . RE_IPV6_WORD .
751  ':' . RE_IPV6_WORD . '$/i', $addr, $m )
752  ) {
753  return long2ip( ( hexdec( $m[1] ) << 16 ) + hexdec( $m[2] ) );
754  }
755 
756  return null; // give up
757  }
758 
765  public static function sanitizeRange( $range ) {
766  list( /*...*/, $bits ) = self::parseCIDR( $range );
767  list( $start, /*...*/ ) = self::parseRange( $range );
768  $start = self::formatHex( $start );
769  if ( $bits === false ) {
770  return $start; // wasn't actually a range
771  }
772 
773  return "$start/$bits";
774  }
775 }
RE_IPV6_V4_PREFIX
const RE_IPV6_V4_PREFIX
Definition: IP.php:51
RE_IP_BLOCK
const RE_IP_BLOCK
Definition: IP.php:31
IP\toHex
static toHex( $ip)
Return a zero-padded upper case hexadecimal representation of an IP address.
Definition: IP.php:447
IP\hexToOctet
static hexToOctet( $ip_hex)
Converts a hexadecimal number to an IPv6 address in octet notation.
Definition: IP.php:330
php
skin txt MediaWiki includes four core it has been set as the default in MediaWiki since the replacing Monobook it had been been the default skin since before being replaced by Vector largely rewritten in while keeping its appearance Several legacy skins were removed in the as the burden of supporting them became too heavy to bear Those in etc for skin dependent CSS etc for skin dependent JavaScript These can also be customised on a per user by etc This feature has led to a wide variety of user styles becoming that gallery is a good place to ending in php
Definition: skin.txt:62
RE_IPV6_PREFIX
const RE_IPV6_PREFIX
Definition: IP.php:36
IP\toOctet
static toOctet( $ip_int)
Given an unsigned integer, returns an IPv6 address in octet notation.
Definition: IP.php:306
IP\combineHostAndPort
static combineHostAndPort( $host, $port, $defaultPort=false)
Given a host name and a port, combine them into host/port string like you might find in a URL.
Definition: IP.php:289
RE_IPV6_ADD
const RE_IPV6_ADD
Definition: IP.php:37
IP_ADDRESS_STRING
const IP_ADDRESS_STRING
Definition: IP.php:54
IP\canonicalize
static canonicalize( $addr)
Convert some unusual representations of IPv4 addresses to their canonical dotted quad representation.
Definition: IP.php:725
$n
$n
Definition: RandomTest.php:76
RE_IPV6_GAP
const RE_IPV6_GAP
Definition: IP.php:50
IP\parseRange6
static parseRange6( $range)
Given a string range in a number of formats, return the start and end of the range in hexadecimal.
Definition: IP.php:655
RE_IPV6_BLOCK
const RE_IPV6_BLOCK
Definition: IP.php:48
IP
A collection of public static functions to play with IP address and IP blocks.
Definition: IP.php:65
IP\isIPv6
static isIPv6( $ip)
Given a string, determine if it as valid IP in IPv6 only.
Definition: IP.php:85
$s
$s
Definition: mergeMessageFileList.php:156
IP\toUnsigned6
static toUnsigned6( $ip)
Definition: IP.php:510
IP\parseCIDR6
static parseCIDR6( $range)
Convert a network specification in IPv6 CIDR notation to an integer network and a number of bits.
Definition: IP.php:614
RE_IP_PREFIX
const RE_IP_PREFIX
Definition: IP.php:30
RE_IPV6_WORD
const RE_IPV6_WORD
Definition: IP.php:35
IP\isPublic6
static isPublic6( $ip)
Determine if an IPv6 address really is an IP address, and if it is public, i.e.
Definition: IP.php:416
IP\hexToQuad
static hexToQuad( $ip_hex)
Converts a hexadecimal number to an IPv4 address in quad-dotted notation.
Definition: IP.php:350
IP\IPv6ToRawHex
static IPv6ToRawHex( $ip)
Given an IPv6 address in octet notation, returns a pure hex string.
Definition: IP.php:466
array
the array() calling protocol came about after MediaWiki 1.4rc1.
List of Api Query prop modules.
IP\isInRange
static isInRange( $addr, $range)
Determine if a given IPv4/IPv6 address is in a given CIDR network.
Definition: IP.php:707
IP\isPublic
static isPublic( $ip)
Determine if an IP address really is an IP address, and if it is public, i.e.
Definition: IP.php:372
list
deferred txt A few of the database updates required by various functions here can be deferred until after the result page is displayed to the user For updating the view updating the linked to tables after a etc PHP does not yet have any way to tell the server to actually return and disconnect while still running these but it might have such a feature in the future We handle these by creating a deferred update object and putting those objects on a global list
Definition: deferred.txt:11
false
processing should stop and the error should be shown to the user * false
Definition: hooks.txt:188
IP\prettifyIP
static prettifyIP( $ip)
Prettify an IP for display to end users.
Definition: IP.php:187
IP\toUnsigned
static toUnsigned( $ip)
Given an IP address in dotted-quad/octet notation, returns an unsigned integer.
Definition: IP.php:486
RE_IP_BYTE
const RE_IP_BYTE
Definition: IP.php:27
IP\splitHostAndPort
static splitHostAndPort( $both)
Given a host/port string, like one might find in the host part of a URL per RFC 2732,...
Definition: IP.php:240
IP\parseRange
static parseRange( $range)
Given a string range in a number of formats, return the start and end of the range in hexadecimal.
Definition: IP.php:564
IP\isValid
static isValid( $ip)
Validate an IP address.
Definition: IP.php:108
IP\isIPv4
static isIPv4( $ip)
Given a string, determine if it as valid IP in IPv4 only.
Definition: IP.php:96
IP\parseCIDR
static parseCIDR( $range)
Convert a network specification in CIDR notation to an integer network and a number of bits.
Definition: IP.php:521
network
MediaWiki has optional support for a high distributed memory object caching system For general information on but for a larger site with heavy like it should help lighten the load on the database servers by caching data and objects in Ubuntu and probably other Linux distributions If you there s no package available for your you can compile it from epoll rt patch for Linux is current Memcached and libevent are under BSD style licenses The server should run on Linux and other Unix like systems you can run multiple servers on one machine or on multiple machines on a network
Definition: memcached.txt:16
IP\sanitizeIP
static sanitizeIP( $ip)
Convert an IP into a verbose, uppercase, normalized form.
Definition: IP.php:134
wfBaseConvert
wfBaseConvert( $input, $sourceBase, $destBase, $pad=1, $lowercase=true, $engine='auto')
Convert an arbitrarily-long digit string from one numeric base to another, optionally zero-padding to...
Definition: GlobalFunctions.php:3368
as
This document is intended to provide useful advice for parties seeking to redistribute MediaWiki to end users It s targeted particularly at maintainers for Linux since it s been observed that distribution packages of MediaWiki often break We ve consistently had to recommend that users seeking support use official tarballs instead of their distribution s and this often solves whatever problem the user is having It would be nice if this could such as
Definition: distributors.txt:9
RE_IP_ADD
const RE_IP_ADD
Definition: IP.php:28
IP\isValidBlock
static isValidBlock( $ipblock)
Validate an IP Block (valid address WITH a valid prefix).
Definition: IP.php:121
IP\sanitizeRange
static sanitizeRange( $range)
Gets rid of unneeded numbers in quad-dotted/octet IP strings For example, 127.111....
Definition: IP.php:763
IP\isIPAddress
static isIPAddress( $ip)
Determine if a string is as valid IP address or network (CIDR prefix).
Definition: IP.php:74
IP\formatHex
static formatHex( $hex)
Convert an IPv4 or IPv6 hexadecimal representation back to readable format.
Definition: IP.php:316