X-Git-Url: https://git.heureux-cyclage.org/?a=blobdiff_plain;f=includes%2FIP.php;h=1b40f4bc1abd6257c7a74daea101d80a88d7b8e5;hb=d26f07888b8002fd1a7f5101fe5f6a70bbb85e2a;hp=9aeba39f2c0165e9cc7a76d88d4dff7167eb3576;hpb=9a301f1636a962ff8cd5d4447f06679fdc890b5a;p=lhc%2Fweb%2Fwiklou.git

diff --git a/includes/IP.php b/includes/IP.php
index 9aeba39f2c..1b40f4bc1a 100644
--- a/includes/IP.php
+++ b/includes/IP.php
@@ -18,7 +18,7 @@
  * http://www.gnu.org/copyleft/gpl.html
  *
  * @file
- * @author Ashar Voultoiz <hashar at free dot fr>, Aaron Schulz
+ * @author Antoine Musso "<hashar at free dot fr>", Aaron Schulz
  */
 
 // Some regex definition to "play" with IP address and IP address blocks
@@ -35,19 +35,22 @@ define( 'RE_IP_BLOCK', RE_IP_ADD . '\/' . RE_IP_PREFIX );
 define( 'RE_IPV6_WORD', '([0-9A-Fa-f]{1,4})' );
 define( 'RE_IPV6_PREFIX', '(12[0-8]|1[01][0-9]|[1-9]?\d)');
 define( 'RE_IPV6_ADD',
-	'(?:' . // starts with "::" (includes the address "::")
-		'::|:(?::' . RE_IPV6_WORD . '){1,7}' .
-	'|' . // ends with "::" (not including the address "::")
+	'(?:' . // starts with "::" (including "::")
+		':(?::|(?::' . RE_IPV6_WORD . '){1,7})' .
+	'|' . // ends with "::" (except "::")
 		RE_IPV6_WORD . '(?::' . RE_IPV6_WORD . '){0,6}::' .
-	'|' . // has no "::"
-		RE_IPV6_WORD . '(?::' . RE_IPV6_WORD . '){7}' .
-	'|' . // contains one "::" in the middle (awkward regex for PCRE 4.0+ compatibility)
-		RE_IPV6_WORD . '(?::(?!(?P=abn))(?P<abn>:(?P<iabn>))?' . RE_IPV6_WORD . '){1,6}(?P=iabn)' .
+	'|' . // contains one "::" in the middle, ending in "::WORD"
+		RE_IPV6_WORD . '(?::' . RE_IPV6_WORD . '){0,5}' . '::' . RE_IPV6_WORD .
+	'|' . // contains one "::" in the middle, not ending in "::WORD" (regex for PCRE 4.0+)
+		RE_IPV6_WORD . '(?::(?P<abn>:(?P<iabn>))?' . RE_IPV6_WORD . '(?!:(?P=abn))){1,5}' .
+			':' . RE_IPV6_WORD . '(?P=iabn)' .
 		// NOTE: (?!(?P=abn)) fails iff "::" used twice; (?P=iabn) passes iff a "::" was found.
-		
-		// Better regexp (PCRE 7.2+ only), allows intuitive regex concatenation
-		#RE_IPV6_WORD . '(?::((?(-1)|:))?' . RE_IPV6_WORD . '){1,6}(?(-2)|^)' .
+	'|' . // contains no "::"
+		RE_IPV6_WORD . '(?::' . RE_IPV6_WORD . '){7}' .
 	')'
+	// NOTE: With PCRE 7.2+, we can combine the two '"::" in the middle' cases into:
+	//		RE_IPV6_WORD . '(?::((?(-1)|:))?' . RE_IPV6_WORD . '){1,6}(?(-2)|^)'
+	// This also improves regex concatenation by using relative references.
 );
 // An IPv6 block is an IP address and a prefix (d1 to d128)
 define( 'RE_IPV6_BLOCK', RE_IPV6_ADD . '\/' . RE_IPV6_PREFIX );
@@ -130,7 +133,7 @@ class IP {
 	}
 
 	/**
-	 * Convert an IP into a nice standard form.
+	 * Convert an IP into a verbose, uppercase, normalized form.
 	 * IPv6 addresses in octet notation are expanded to 8 words.
 	 * IPv4 addresses are just trimmed.
 	 *
@@ -182,6 +185,124 @@ class IP {
 		return $ip;
 	}
 
+	/**
+	 * Prettify an IP for display to end users.
+	 * This will make it more compact and lower-case.
+	 *
+	 * @param $ip string
+	 * @return string
+	 */
+	public static function prettifyIP( $ip ) {
+		$ip = self::sanitizeIP( $ip ); // normalize (removes '::')
+		if ( self::isIPv6( $ip ) ) {
+			// Split IP into an address and a CIDR
+			if ( strpos( $ip, '/' ) !== false ) {
+				list( $ip, $cidr ) = explode( '/', $ip, 2 );
+			} else {
+				list( $ip, $cidr ) = array( $ip, '' );
+			}
+			// Get the largest slice of words with multiple zeros
+			$offset = 0;
+			$longest = $longestPos = false;
+			while ( preg_match(
+				'!(?:^|:)0(?::0)+(?:$|:)!', $ip, $m, PREG_OFFSET_CAPTURE, $offset
+			) ) {
+				list( $match, $pos ) = $m[0]; // full match
+				if ( strlen( $match ) > strlen( $longest ) ) {
+					$longest = $match;
+					$longestPos = $pos;
+				}
+				$offset += ( $pos + strlen( $match ) ); // advance
+			}
+			if ( $longest !== false ) {
+				// Replace this portion of the string with the '::' abbreviation
+				$ip = substr_replace( $ip, '::', $longestPos, strlen( $longest ) );
+			}
+			// Add any CIDR back on
+			if ( $cidr !== '' ) {
+				$ip = "{$ip}/{$cidr}";
+			}
+			// Convert to lower case to make it more readable
+			$ip = strtolower( $ip );
+		}
+		return $ip;
+	}
+
+	/**
+	 * Given a host/port string, like one might find in the host part of a URL
+	 * per RFC 2732, split the hostname part and the port part and return an
+	 * array with an element for each. If there is no port part, the array will
+	 * have false in place of the port. If the string was invalid in some way,
+	 * false is returned.
+	 *
+	 * This was easy with IPv4 and was generally done in an ad-hoc way, but
+	 * with IPv6 it's somewhat more complicated due to the need to parse the
+	 * square brackets and colons.
+	 *
+	 * A bare IPv6 address is accepted despite the lack of square brackets.
+	 *
+	 * @param $both string The string with the host and port
+	 * @return array
+	 */
+	public static function splitHostAndPort( $both ) {
+		if ( substr( $both, 0, 1 ) === '[' ) {
+			if ( preg_match( '/^\[(' . RE_IPV6_ADD . ')\](?::(?P<port>\d+))?$/', $both, $m ) ) {
+				if ( isset( $m['port'] ) ) {
+					return array( $m[1], intval( $m['port'] ) );
+				} else {
+					return array( $m[1], false );
+				}
+			} else {
+				// Square bracket found but no IPv6
+				return false;
+			}
+		}
+		$numColons = substr_count( $both, ':' );
+		if ( $numColons >= 2 ) {
+			// Is it a bare IPv6 address?
+			if ( preg_match( '/^' . RE_IPV6_ADD . '$/', $both ) ) {
+				return array( $both, false );
+			} else {
+				// Not valid IPv6, but too many colons for anything else
+				return false;
+			}
+		}
+		if ( $numColons >= 1 ) {
+			// Host:port?
+			$bits = explode( ':', $both );
+			if ( preg_match( '/^\d+/', $bits[1] ) ) {
+				return array( $bits[0], intval( $bits[1] ) );
+			} else {
+				// Not a valid port
+				return false;
+			}
+		}
+		// Plain hostname
+		return array( $both, false );
+	}
+
+	/**
+	 * Given a host name and a port, combine them into host/port string like
+	 * you might find in a URL. If the host contains a colon, wrap it in square
+	 * brackets like in RFC 2732. If the port matches the default port, omit
+	 * the port specification
+	 *
+	 * @param $host string
+	 * @param $port int
+	 * @param $defaultPort bool|int
+	 * @return string
+	 */
+	public static function combineHostAndPort( $host, $port, $defaultPort = false ) {
+		if ( strpos( $host, ':' ) !== false ) {
+			$host = "[$host]";
+		}
+		if ( $defaultPort !== false && $port == $defaultPort ) {
+			return $host;
+		} else {
+			return "$host:$port";
+		}
+	}
+
 	/**
 	 * Given an unsigned integer, returns an IPv6 address in octet notation
 	 *
@@ -300,7 +421,7 @@ class IP {
 		static $privateRanges = false;
 		if ( !$privateRanges ) {
 			$privateRanges = array(
-				array( 'fc::', 'fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff' ), # RFC 4193 (local)
+				array( 'fc00::', 'fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff' ), # RFC 4193 (local)
 				array( '0:0:0:0:0:0:0:1', '0:0:0:0:0:0:0:1' ), # loopback
 			);
 		}
@@ -376,6 +497,10 @@ class IP {
 		return $n;
 	}
 
+	/**
+	 * @param $ip
+	 * @return String
+	 */
 	private static function toUnsigned6( $ip ) {
 		return wfBaseConvert( self::IPv6ToRawHex( $ip ), 16, 10 );
 	}
@@ -475,6 +600,8 @@ class IP {
 	 * Convert a network specification in IPv6 CIDR notation to an
 	 * integer network and a number of bits
 	 *
+	 * @param $range
+	 *
 	 * @return array(string, int)
 	 */
 	private static function parseCIDR6( $range ) {
@@ -512,6 +639,9 @@ class IP {
 	 *     2001:0db8:85a3::7344/96          			 CIDR
 	 *     2001:0db8:85a3::7344 - 2001:0db8:85a3::7344   Explicit range
 	 *     2001:0db8:85a3::7344/96             			 Single IP
+	 *
+	 * @param $range
+	 *
 	 * @return array(string, string)
 	 */
 	private static function parseRange6( $range ) {
@@ -584,6 +714,7 @@ class IP {
 	 * @return String: valid dotted quad IPv4 address or null
 	 */
 	public static function canonicalize( $addr ) {
+		$addr = preg_replace( '/\%.*/','', $addr ); // remove zone info (bug 35738)
 		if ( self::isValid( $addr ) ) {
 			return $addr;
 		}
@@ -597,7 +728,7 @@ class IP {
 		// IPv6 loopback address
 		$m = array();
 		if ( preg_match( '/^0*' . RE_IPV6_GAP . '1$/', $addr, $m ) ) {
-	   		return '127.0.0.1';
+			return '127.0.0.1';
 		}
 		// IPv4-mapped and IPv4-compatible IPv6 addresses
 		if ( preg_match( '/^' . RE_IPV6_V4_PREFIX . '(' . RE_IP_ADD . ')$/i', $addr, $m ) ) {
@@ -611,4 +742,20 @@ class IP {
 
 		return null;  // give up
 	}
+
+	/**
+	 * Gets rid of uneeded numbers in quad-dotted/octet IP strings
+	 * For example, 127.111.113.151/24 -> 127.111.113.0/24
+	 * @param $range String: IP address to normalize
+	 * @return string
+	 */
+	public static function sanitizeRange( $range ) {
+		list( /*...*/, $bits ) = self::parseCIDR( $range );
+		list( $start, /*...*/ ) = self::parseRange( $range );
+		$start = self::formatHex( $start );
+		if ( $bits === false ) {
+			return $start; // wasn't actually a range
+		}
+		return "$start/$bits";
+	}
 }