Accept IPv6 addresses in Uri.http and Uri.https, and correctly nest IPv6 addresses in '[' and ']'.

sdk/lib/core/uri.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.core;
 
 /**
  * A parsed URI, as specified by RFC-3986, http://tools.ietf.org/html/rfc3986.
  */
 class Uri {
+  final String _host;
   int _port;
   String _path;
 
   /**
    * Returns the scheme component.
    *
    * Returns the empty string if there is no scheme component.
    */
   final String scheme;
 
@@ skipping 19 matching lines @@
    * authority component.
    */
   final String userInfo;
 
   /**
    * Returns the host part of the authority component.
    *
    * Returns the empty string if there is no authority component and
    * hence no host.
    */
-  final String host;
+  String get host {
+    if (_host != null && _host.startsWith('[')) {
+      return _host.substring(1, _host.length - 1);
+    }
+    return _host;
+  }
 
   /**
    * Returns the port part of the authority component.
    *
    * Returns 0 if there is no port in the authority component.
    */
   int get port => _port;
 
   /**
    * Returns the path component.
@@ skipping 85 matching lines @@
    * [queryParameters]. When [query] is used the provided string is
    * expected to be fully percent-encoded and is used in its literal
    * form. When [queryParameters] is used the query is built from the
    * provided map. Each key and value in the map is percent-encoded
    * and joined using equal and ampersand characters. The
    * percent-encoding of the keys and values encodes all characters
    * except for the unreserved characters.
    *
    * The fragment component is set through [fragment].
    */
-  Uri({scheme,
+  Uri({String scheme,
        this.userInfo: "",
-       this.host: "",
+       String host: "",
        port: 0,
        String path,
        Iterable<String> pathSegments,
        String query,
        Map<String, String> queryParameters,
        fragment: ""}) :
       scheme = _makeScheme(scheme),
+      _host = _makeHost(host),
       query = _makeQuery(query, queryParameters),
       fragment = _makeFragment(fragment) {
     // Perform scheme specific normalization.
     if (scheme == "http" && port == 80) {
       _port = 0;
     } else if (scheme == "https" && port == 443) {
       _port = 0;
     } else {
       _port = port;
     }
@@ skipping 54 matching lines @@
     // Split off the user info.
     bool hasUserInfo = false;
     for (int i = 0; i < authority.length; i++) {
       if (authority.codeUnitAt(i) == _AT_SIGN) {
         hasUserInfo = true;
         userInfo = authority.substring(0, i);
         hostStart = i + 1;
         break;
       }
     }
+    var hostEnd = hostStart;
+    if (hostStart < authority.length &&
+        authority.codeUnitAt(hostStart) == _LEFT_BRACKET) {
+      // IPv6 host.
+      for (; hostEnd < authority.length; hostEnd++) {
+        if (authority.codeUnitAt(hostEnd) == _RIGHT_BRACKET) break;
+      }
+      if (hostEnd == authority.length) {
+        throw new FormatException("Invalid IPv6 host entry.");
+      }
+      parseIPv6Address(authority.substring(hostStart + 1, hostEnd));
+      hostEnd++;  // Skip the closing bracket.
+      if (hostEnd != authority.length &&
+          authority.codeUnitAt(hostEnd) != _COLON) {
+        throw new FormatException("Invalid end of authority");
+      }
+    }
     // Split host and port.
     bool hasPort = false;
-    for (int i = hostStart; i < authority.length; i++) {
-      if (authority.codeUnitAt(i) == _COLON) {
-        hasPort = true;
-        host = authority.substring(hostStart, i);
-        if (!host.isEmpty) {
-          var portString = authority.substring(i + 1);
-          if (portString.isNotEmpty) port = int.parse(portString);
-        }
+    for (;hostEnd < authority.length; hostEnd++) {

[floitsch, 2013/09/10 12:11:46]

nit: space after ";" ?

[Søren Gjesse, 2013/09/10 12:18:03]

Please add space after ;

[Anders Johnsen, 2013/09/11 12:58:31]

Done.

[Anders Johnsen, 2013/09/11 12:58:31]

Done.

+      if (authority.codeUnitAt(hostEnd) == _COLON) {
+        var portString = authority.substring(hostEnd + 1);
+        if (portString.isNotEmpty) port = int.parse(portString);

[floitsch, 2013/09/10 12:11:46]

do we allow: "foo.bar:" as host?
is this valid?
maybe write small comment explaining that this is ok.

[Anders Johnsen, 2013/09/11 12:58:31]

Yes, we even test for that: 
  
      check(new Uri.http("@host:", ""), "http://host");

Adding comment.

         break;
       }
     }
-    if (!hasPort) {
-      host = hasUserInfo ? authority.substring(hostStart) : authority;
-    }
+    host = authority.substring(hostStart, hostEnd);
 
     return new Uri(scheme: scheme,
                    userInfo: userInfo,
                    host: host,
                    port: port,
                    pathSegments: unencodedPath.split("/"),
                    queryParameters: queryParameters);
   }
 
   /**
@@ skipping 201 matching lines @@
    * The returned map is unmodifiable and will throw [UnsupportedError] on any
    * calls that would mutate it.
    */
   Map<String, String> get queryParameters {
     if (_queryParameters == null) {
       _queryParameters = new _UnmodifiableMap(splitQueryString(query));
     }
     return _queryParameters;
   }
 
+  static String _makeHost(String host) {
+    if (host == null || host.isEmpty) return host;
+    if (host.codeUnitAt(0) == _LEFT_BRACKET) {
+      if (host.codeUnitAt(host.length - 1) != _RIGHT_BRACKET) {
+        throw new FormatException('Missing end `]` to match `[` in host');
+      }
+      parseIPv6Address(host.substring(1, host.length - 1));
+      return host;
+    }
+    for (int i = 0; i < host.length; i++) {
+      if (host.codeUnitAt(i) == _COLON) {
+        parseIPv6Address(host);
+        var buffer = new StringBuffer();
+        buffer.writeCharCode(_LEFT_BRACKET);

[floitsch, 2013/09/10 12:11:46]

just write "[$host]".
This will use a string-buffer on the VM and the more efficient + in dart2js.

[Anders Johnsen, 2013/09/11 12:58:31]

Done.

+        buffer.write(host);
+        buffer.writeCharCode(_RIGHT_BRACKET);
+        return buffer.toString();
+      }
+    }
+    return host;
+  }
+
   static String _makeScheme(String scheme) {
     bool isSchemeLowerCharacter(int ch) {
       return ch < 128 &&
              ((_schemeLowerTable[ch >> 4] & (1 << (ch & 0x0f))) != 0);
     }
 
     bool isSchemeCharacter(int ch) {
       return ch < 128 && ((_schemeTable[ch >> 4] & (1 << (ch & 0x0f))) != 0);
     }
 
@@ skipping 334 matching lines @@
 
   /**
    * Returns the origin of the URI in the form scheme://host:port for the
    * schemes http and https.
    *
    * It is an error if the scheme is not "http" or "https".
    *
    * See: http://www.w3.org/TR/2011/WD-html5-20110405/origin-0.html#origin
    */
   String get origin {
-    if (scheme == "" || host == null || host == "") {
+    if (scheme == "" || _host == null || _host == "") {
       throw new StateError("Cannot use origin without a scheme: $this");
     }
     if (scheme != "http" && scheme != "https") {
       throw new StateError(
         "Origin is only applicable schemes http and https: $this");
     }
-    if (port == 0) return "$scheme://$host";
-    return "$scheme://$host:$port";
+    if (port == 0) return "$scheme://$_host";
+    return "$scheme://$_host:$port";
   }
 
   /**
    * Returns the file path from a file URI.
    *
    * The returned path has either Windows or non-Windows
    * semantics.
    *
    * For non-Windows semantics the slash ("/") is used to separate
    * path segments.
@@ skipping 105 matching lines @@
       result.write(host);
       result.write("\\");
     }
     result.writeAll(segments, "\\");
     if (hasDriveLetter && segments.length == 1) result.write("\\");
     return result.toString();
   }
 
   void _writeAuthority(StringSink ss) {
     _addIfNonEmpty(ss, userInfo, userInfo, "@");
-    ss.write(host == null ? "null" :
-             host.contains(':') ? '[$host]' : host);
+    ss.write(_host == null ? "null" : _host);
     if (port != 0) {
       ss.write(":");
       ss.write(port.toString());
     }
   }
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     _addIfNonEmpty(sb, scheme, scheme, ':');
     if (hasAuthority || (scheme == "file")) {
@@ skipping 164 matching lines @@
       } else if (index != 0) {
         var key = element.substring(0, index);
         var value = element.substring(index + 1);
         map[Uri.decodeQueryComponent(key, decode: decode)] =
             decodeQueryComponent(value, decode: decode);
       }
       return map;
     });
   }
 
+  /**
+   * Parse the [host] as a IPv4 address, returning the address as a list of

[floitsch, 2013/09/10 12:11:46]

as an IPv4

[Søren Gjesse, 2013/09/10 12:18:03]

In socket we always write "IP version 4 (IPv4)".

[Anders Johnsen, 2013/09/11 12:58:31]

Done.

+   * 4 bytes in network byte order (big endian).
+   *
+   * If it's unable to parse the address as IPv4, a `FormatException` will be

[floitsch, 2013/09/10 12:11:46]

If [host] is not a valid IPv4 address representation throws a [FormatException].

(don't use "it", use [class] and don't use future).

[Anders Johnsen, 2013/09/11 12:58:31]

Done.

+   * thrown.
+   */
+  static List<int> parseIPv4Address(String host) {
+    var bytes = host.split('.');
+    if (bytes.length != 4) {
+      throw new FormatException(

[Søren Gjesse, 2013/09/10 12:18:03]

How about making all these FormatExceptions start with either

Illegal IP version 4 address
Illegal IP version 6 address

And then add the reason after?

Illegal IP version 4 address, an IP version 4 address...

[Anders Johnsen, 2013/09/11 12:58:31]

Done.

+          'A IPv4 address should contain exactly 4 parts');
+    }
+    return bytes
+        .map((byteString) {
+          int byte = int.parse(byteString);
+          if (byte < 0 || byte > 255) {
+            throw new FormatException(
+              'Each part must be in the range of `0...255`');

[Søren Gjesse, 2013/09/10 12:18:03]

Only two dots in range.

[Anders Johnsen, 2013/09/11 12:58:31]

Done.

+          }
+          return byte;
+        })

[Søren Gjesse, 2013/09/10 12:18:03]

Maybe this should be a Uint8List.

[floitsch, 2013/09/10 12:23:32]

Currently not possible. Afaik IE still doesn't have a shim.
But add a TODO.

+        .toList();
+  }
+
+  /**
+   * Parse the [host] as a IPv6 address, returning the address as a list of

[floitsch, 2013/09/10 12:11:46]

an IPv6

[Anders Johnsen, 2013/09/11 12:58:31]

Done.

+   * 16 bytes in network byte order (big endian).
+   *
+   * If it's unable to parse the address as IPv6, a `FormatException` will be

[floitsch, 2013/09/10 12:11:46]

ditto.

[Anders Johnsen, 2013/09/11 12:58:31]

Done.

+   * thrown.
+   */

[floitsch, 2013/09/10 12:11:46]

Provide examples.
This would make it also easier to follow the code.

[Anders Johnsen, 2013/09/11 12:58:31]

Done.

+  static List<int> parseIPv6Address(String host) {
+    int parseHex(int start, int end) {
+      if (end - start > 4) {
+        throw new FormatException(
+            'An IPv6 part can only contain a maximum of 4 hex digits');
+      }
+      int value = int.parse(host.substring(start, end), radix: 16);
+      if (value < 0 || value > (1 << 16) - 1) {
+        throw new FormatException(
+            'Each part must be in the range of `0x0...0xFFFF`');

[Søren Gjesse, 2013/09/10 12:18:03]

Only two dots in range.

[Anders Johnsen, 2013/09/11 12:58:31]

Done.

+      }
+      return value;
+    }
+    if (host.length < 2) throw new FormatException('IPv6 addres is too short');
+    List<int> segments = [];
+    bool wildcardSeen = false;
+    int partStart = 0;
+    for (int i = 0; i < host.length; i++) {

[floitsch, 2013/09/10 12:11:46]

Add comment that this will parse all segments except potentially the last one
which is handled after the loop.

[Anders Johnsen, 2013/09/11 12:58:31]

Done.

+      if (host.codeUnitAt(i) == _COLON) {
+        if (i == 0) {
+          // If we see a `:` in the beginning, expect wildcard.
+          i++;
+          if (host.codeUnitAt(i) != _COLON) {
+            throw new FormatException('Invalid start colon.');
+          }
+          partStart = i;
+        }
+        if (i == partStart) {
+          // Wildcard. We only allow one.
+          if (wildcardSeen) {
+            throw new FormatException('Only one IPv6 wildcart `::` is allowed');

[floitsch, 2013/09/10 12:11:46]

wildcard

[Anders Johnsen, 2013/09/11 12:58:31]

Done.

+          }
+          wildcardSeen = true;
+          segments.add(-1);
+        } else {
+          // Found a single colon. Parse [partStart..i] as a hex entry.
+          segments.add(parseHex(partStart, i));
+        }
+        partStart = i + 1;
+      }
+    }
+    if (segments.length == 0) throw new FormatException('Too few IPv6 parts');
+    if (!(segments.last == -1 && partStart == host.length)) {

[floitsch, 2013/09/10 12:11:46]

Do the check explicitly:
if (partStart == host.length && segments.lest != -1) {
  // We allow a trailing ":" only if it part of a wildcard.
  throw new FormatException('...');
}
if (partStart == host.length) {
  ...
}

[Anders Johnsen, 2013/09/11 12:58:31]

Done.

+      try {
+        segments.add(parseHex(partStart, host.length));
+      } catch (e) {
+        // Failed to parse the last chunk as hex. Try IPv4.
+        try {
+          List<int> last = parseIPv4Address(host.substring(partStart));
+          segments.add(last[0] << 8 | last[1]);
+          segments.add(last[2] << 8 | last[3]);
+        } catch (e) {
+          throw new FormatException('Invalid end of IPv6 address.');
+        }
+      }
+      if (segments.length > 8 ||
+          (wildcardSeen && segments.length > 7)) {
+
+        throw new FormatException(
+            'An IPv6 address can only contain maximum 8 parts');
+      }
+    }
+    return segments

[Søren Gjesse, 2013/09/10 12:18:03]

Wouldn't it be simpler to allocate a list of length 16 and then fill in the
values? Could be a Uint8List.

[Anders Johnsen, 2013/09/11 12:58:31]

IMO this is easier, than using indexes into a list. Adding Uint8List todo.

+        .expand((value) {
+          if (value == -1) {
+            var list = [];
+            for (int i = 0; i < 9 - segments.length; i++) {
+              list.addAll(const [0, 0]);
+            }
+            return list;
+          } else {
+            return [(value >> 8) & 0xFF, value & 0xFF];
+          }
+        })
+        .toList();
+  }
+
   // Frequently used character codes.
   static const int _DOUBLE_QUOTE = 0x22;
   static const int _PERCENT = 0x25;
   static const int _ASTERISK = 0x2A;
   static const int _PLUS = 0x2B;
   static const int _SLASH = 0x2F;
   static const int _ZERO = 0x30;
   static const int _NINE = 0x39;
   static const int _COLON = 0x3A;
   static const int _LESS = 0x3C;
   static const int _GREATER = 0x3E;
   static const int _QUESTION = 0x3F;
   static const int _AT_SIGN = 0x40;
   static const int _UPPER_CASE_A = 0x41;
   static const int _UPPER_CASE_F = 0x46;
   static const int _UPPER_CASE_Z = 0x5A;
+  static const int _LEFT_BRACKET = 0x5B;
   static const int _BACKSLASH = 0x5C;
+  static const int _RIGHT_BRACKET = 0x5D;
   static const int _LOWER_CASE_A = 0x61;
   static const int _LOWER_CASE_F = 0x66;
   static const int _LOWER_CASE_Z = 0x7A;
   static const int _BAR = 0x7C;
 
   /**
    * This is the internal implementation of JavaScript's encodeURI function.
    * It encodes all characters in the string [text] except for those
    * that appear in [canonicalTable], and returns the escaped string.
    */
@@ skipping 287 matching lines @@
   void clear() {
     throw new UnsupportedError("Cannot modify an unmodifiable map");
   }
   void forEach(void f(K key, V value)) => _map.forEach(f);
   Iterable<K> get keys => _map.keys;
   Iterable<V> get values => _map.values;
   int get length => _map.length;
   bool get isEmpty => _map.isEmpty;
   bool get isNotEmpty => _map.isNotEmpty;
 }