Better handling of IPv6 with HTTP proxy

tests/standalone/io/http_proxy_test.dart

 // Copyright (c) 2013, 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.
 
 import "package:crypto/crypto.dart";
 import "package:expect/expect.dart";
 import "package:path/path.dart";
 import "dart:async";
 import "dart:io";
 import 'dart:convert';
@@ skipping 59 matching lines @@
 }
 
 Future<Server> setupServer(int proxyHops,
                    {List<String> directRequestPaths: const <String>[],
                     secure: false}) {
   Server server = new Server(proxyHops, directRequestPaths, secure);
   return server.start();
 }
 
 class ProxyServer {
+  final bool ipV6;
   HttpServer server;
   HttpClient client;
   int requestCount = 0;
   String authScheme;
   String realm = "test";
   String username;
   String password;
 
   var ha1;
   String serverAlgorithm = "MD5";
   String serverQop = "auth";
   Set ncs = new Set();
 
   var nonce = "12345678";  // No need for random nonce in test.
 
-  ProxyServer() : client = new HttpClient();
+  ProxyServer({this.ipV6: false}) : client = new HttpClient();
 
   void useBasicAuthentication(String username, String password) {
     this.username = username;
     this.password = password;
     authScheme = "Basic";
   }
 
   void useDigestAuthentication(String username, String password) {
     this.username = username;
     this.password = password;
@@ skipping 28 matching lines @@
         authHeader.write(', algorithm=$serverAlgorithm');
       }
       if (serverQop != null) authHeader.write(', qop="$serverQop"');
       response.headers.set(HttpHeaders.PROXY_AUTHENTICATE, authHeader);
       response.close();
     });
   }
 
   Future<ProxyServer> start() {
     var x = new Completer();
-    HttpServer.bind("localhost", 0).then((s) {
+    var host = ipV6 ? "::1" : "localhost";
+    HttpServer.bind(host, 0).then((s) {
       server = s;
       x.complete(this);
       server.listen((HttpRequest request) {
         requestCount++;
         if (username != null && password != null) {
           if (request.headers[HttpHeaders.PROXY_AUTHORIZATION] == null) {
             if (authScheme == "Digest") {
               digestAuthenticationRequired(request);
             } else {
               basicAuthenticationRequired(request);
@@ skipping 107 matching lines @@
   }
 
   void shutdown() {
     server.close();
     client.close();
   }
 
   int get port => server.port;
 }
 
-Future<ProxyServer> setupProxyServer() {
-  ProxyServer proxyServer = new ProxyServer();
+Future<ProxyServer> setupProxyServer({ipV6: false}) {
+  ProxyServer proxyServer = new ProxyServer(ipV6: ipV6);
   return proxyServer.start();
 }
 
 testInvalidProxy() {
   HttpClient client = new HttpClient();
 
   client.findProxy = (Uri uri) => "";
   client.getUrl(Uri.parse("http://www.google.com/test"))
     .catchError((error) {}, test: (e) => e is HttpException);
 
@@ skipping 106 matching lines @@
       }
 
       test(false);
       test(true);
     }
   });
   });
   });
 }
 
+int testProxyIPV6DoneCount = 0;
+void testProxyIPV6() {
+  setupProxyServer(ipV6: true).then((proxyServer) {
+  setupServer(1, directRequestPaths: ["/4"]).then((server) {
+  setupServer(1, directRequestPaths: ["/4"], secure: true).then((secureServer) {
+    HttpClient client = new HttpClient();
+
+    List<String> proxy = ["PROXY [::1]:${proxyServer.port}"];
+    client.findProxy = (Uri uri) {
+      // Pick the proxy configuration based on the request path.
+      int index = int.parse(uri.path.substring(1));
+      return proxy[index];
+    };
+
+    for (int i = 0; i < proxy.length; i++) {
+      test(bool secure) {
+        String url = secure
+            ? "https://localhost:${secureServer.port}/$i"
+            : "http://localhost:${server.port}/$i";
+
+        client.postUrl(Uri.parse(url))
+          .then((HttpClientRequest clientRequest) {
+            String content = "$i$i$i";
+            clientRequest.write(content);
+            return clientRequest.close();
+          })
+          .then((HttpClientResponse response) {
+            response.listen((_) {}, onDone: () {
+              testProxyIPV6DoneCount++;
+              if (testProxyIPV6DoneCount == proxy.length * 2) {
+                Expect.equals(proxy.length, server.requestCount);
+                Expect.equals(proxy.length, secureServer.requestCount);
+                proxyServer.shutdown();
+                server.shutdown();
+                secureServer.shutdown();
+                client.close();
+              }
+            });
+          });
+      }
+
+      test(false);
+      test(true);
+    }
+  });
+  });
+  });
+}
+
 int testProxyChainDoneCount = 0;
 void testProxyChain() {
   // Setup two proxy servers having the first using the second as its proxy.
   setupProxyServer().then((proxyServer1) {
   setupProxyServer().then((proxyServer2) {
   proxyServer1.client.findProxy = (_) => "PROXY localhost:${proxyServer2.port}";
 
   setupServer(2, directRequestPaths: ["/4"]).then((server) {
     HttpClient client = new HttpClient();
 
@@ skipping 339 matching lines @@
   var testPkcertDatabase = Platform.script.resolve('pkcert').toFilePath();
   SecureSocket.initialize(database: testPkcertDatabase,
                           password: 'dartdart');
 }
 
 main() {
   InitializeSSL();
   testInvalidProxy();
   testDirectProxy();
   testProxy();
+  testProxyIPV6();
   testProxyChain();
   testProxyFromEnviroment();
   // The two invocations of uses the same global variable for state -
   // run one after the other.
   testProxyAuthenticate(false)
       .then((_) => testProxyAuthenticate(true));
   // This test is not normally run. It can be used for locally testing
   // with a real proxy server (e.g. Apache).
   //testRealProxy();
   //testRealProxyAuth();
 }