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 {
@@ skipping 135 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 = null;

[floitsch, 2013/09/09 13:32:21]

That's how I would write it.

var hostEnd = hostStart;
if (authority.codeUnitAt(hostStart) == _LEFT_BRACKET) {
  // IPv6 host.
  for (; hostEnd < authority.length; hostEnd++) {
    if (authority.codeUnitAt(hostEnd) == _RIGHT_BRACKET) break;
  }
  if (hostEnd == authority.length) throw...;
  hostEnd++;  // Skip the closing bracket.
  if (hostEnd != authority.length && authority.codeUnitAt(hostEnd) != _COLON) {
    throw "bad authority".
  }
}
// Split host and port.
bool hasPort = false;
for (int i = hostEnd; i < authority.length; i++) {
  if (authority.codeUnitAt(i) == _COLON) {
    hostEnd = i;
    var portString = authority.substring(i + 1);
    if (portString.isNotEmpty) port = int.parse(portString);
  }
}
host = authority.substring(hostStart, hostEnd);
}

[Anders Johnsen, 2013/09/10 11:13:23]

Done.

+    var portStart = hostStart;
+    if (authority.codeUnitAt(hostStart) == _LEFT_BRACKET) {
+      // IPv6 host.
+      for (int i = hostStart; i < authority.length; i++) {
+        if (authority.codeUnitAt(i) == _RIGHT_BRACKET) {
+          hostEnd = i;
+          break;
+        }
+      }
+      if (hostEnd == null) {
+        throw new FormatException("Invalid IPv6 host entry.");
+      }
+      hostEnd++;
+      portStart = hostEnd;
+    }
     // Split host and port.
     bool hasPort = false;
-    for (int i = hostStart; i < authority.length; i++) {
+    for (int i = portStart; i < authority.length; i++) {
       if (authority.codeUnitAt(i) == _COLON) {
         hasPort = true;

[floitsch, 2013/09/09 13:32:21]

you set hasPort to true, but if the host is empty you don't actually provide a
port.

[Anders Johnsen, 2013/09/10 11:13:23]

Done.

-        host = authority.substring(hostStart, i);
+        if (hostEnd == null) hostEnd = i;
+        host = authority.substring(hostStart, hostEnd);
         if (!host.isEmpty) {

[floitsch, 2013/09/09 13:32:21]

if you just check hostStart != hostEnd you don't need to take the host string
and can take it unconditionally below.

[Anders Johnsen, 2013/09/10 11:13:23]

Done.

           var portString = authority.substring(i + 1);
           if (portString.isNotEmpty) port = int.parse(portString);

[floitsch, 2013/09/09 13:32:21]

is this intended behavior? (an authority with ":" but without the port?

[Anders Johnsen, 2013/09/10 11:13:23]

Done.

         }
         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 202 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.isEmpty) return host;
+    if (host.codeUnitAt(0) == _LEFT_BRACKET) return host;

[floitsch, 2013/09/09 13:32:21]

I would prefer a more sophisticated host-parser:
detect bad hosts with ports ("foo:8080") and don't treat them like ipv6.
Detect obviously bad ipv6 addresses (like :::znth:aaaaaa:)

[Anders Johnsen, 2013/09/10 11:13:23]

Done.

+    for (int i = 0; i < host.length; i++) {
+      if (host.codeUnitAt(i) == _COLON) {
+        var buffer = new StringBuffer();
+        buffer.writeCharCode(_LEFT_BRACKET);
+        buffer.write(host);
+        if (host.codeUnitAt(host.length - 1) != _RIGHT_BRACKET) {
+          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 670 matching lines @@
   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;
 }