Add HTTP proxy tunnel support

sdk/lib/io/http_impl.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.
 
 part of dart.io;
 
 class _HttpIncoming extends Stream<List<int>> {
   final int _transferLength;
   final Completer _dataCompleter = new Completer();
   Stream<List<int>> _stream;
@@ skipping 867 matching lines @@
           _responseCompleter.completeError(e);
         });
   }
 
   void _onError(error) {
     _responseCompleter.completeError(error);
   }
 
   void _writeHeader() {
     var buffer = new _BufferList();
+
     writeSP() => buffer.add(const [_CharCode.SP]);
+
     writeCRLF() => buffer.add(const [_CharCode.CR, _CharCode.LF]);
 
-    buffer.add(method.codeUnits);
-    writeSP();
-    // Send the path for direct connections and the whole URL for
-    // proxy connections.
-    if (_proxy.isDirect) {
+    void writePath() {
       String path = uri.path;
       if (path.length == 0) path = "/";
       if (uri.query != "") {
         if (uri.fragment != "") {
           path = "${path}?${uri.query}#${uri.fragment}";
         } else {
           path = "${path}?${uri.query}";
         }
       }
       buffer.add(path.codeUnits);
+    }
+
+    // Write the request method.
+    buffer.add(method.codeUnits);
+    writeSP();
+    // Write the request URI.
+    if (_proxy.isDirect) {
+      writePath();
     } else {
-      buffer.add(uri.toString().codeUnits);
+      if (method == "CONNECT") {
+        // For the connect method the request URI is the host:port of
+        // the requested destination of the tunnel (see RFC 2817
+        // section 5.2)
+        buffer.add(uri.domain.codeUnits);
+        buffer.add(const [_CharCode.COLON]);
+        buffer.add(uri.port.toString().codeUnits);
+      } else {
+        if (_httpClientConnection._proxyTunnel) {
+          writePath();
+        } else {
+          buffer.add(uri.toString().codeUnits);
+        }
+      }
     }
     writeSP();
     buffer.add(_Const.HTTP11);
     writeCRLF();
 
     // Add the cookies to the headers.
     if (!cookies.isEmpty) {
       StringBuffer sb = new StringBuffer();
       for (int i = 0; i < cookies.length; i++) {
         if (i > 0) sb.write("; ");
@@ skipping 99 matching lines @@
   }
 
   Future close() {
     _doneCompleter.complete(_consumer);
     return new Future.value();
   }
 
   Future get done => _doneCompleter.future;
 }
 
-
 class _HttpClientConnection {
   final String key;
   final Socket _socket;
+  final bool _proxyTunnel;
   final _HttpParser _httpParser;
   StreamSubscription _subscription;
   final _HttpClient _httpClient;
+  bool _dispose = false;
 
   Completer<_HttpIncoming> _nextResponseCompleter;
   Future _streamFuture;
 
   _HttpClientConnection(String this.key,
                         Socket this._socket,
-                        _HttpClient this._httpClient)
+                        _HttpClient this._httpClient,
+                        [this._proxyTunnel = false])
       : _httpParser = new _HttpParser.responseParser() {
     _socket.pipe(_httpParser);
 
     // Set up handlers on the parser here, so we are sure to get 'onDone' from
     // the parser.
     _subscription = _httpParser.listen(
         (incoming) {
           // Only handle one incoming response at the time. Keep the
           // stream paused until the response have been processed.
           _subscription.pause();
@@ skipping 58 matching lines @@
     _httpParser.responseToMethod = method;
     _streamFuture = outgoing.done
         .then((s) {
           // Request sent, set up response completer.
           _nextResponseCompleter = new Completer();
 
           // Listen for response.
           _nextResponseCompleter.future
               .then((incoming) {
                 incoming.dataDone.then((_) {
-                  if (incoming.headers.persistentConnection &&
+                  if (!_dispose &&
+                      incoming.headers.persistentConnection &&
                       request.persistentConnection) {
                     // Return connection, now we are done.
                     _httpClient._returnConnection(this);
                     _subscription.resume();
                   } else {
                     destroy();
                   }
                 });
                 request._onIncoming(incoming);
               })
@@ skipping 30 matching lines @@
     _socket.destroy();
   }
 
   void close() {
     _httpClient._connectionClosed(this);
     _streamFuture
           // TODO(ajohnsen): Add timeout.
         .then((_) => _socket.destroy());
   }
 
+  Future<_HttpClientConnection> createProxyTunnel(host, port, proxy) {
+    _HttpClientRequest request =
+        send(new Uri.fromComponents(domain: host, port: port),
+             port,
+             "CONNECT",
+             proxy);
+    if (proxy.isAuthenticated) {
+      // If the proxy configuration contains user information use that
+      // for proxy basic authorization.
+      String auth = CryptoUtils.bytesToBase64(
+          _encodeString("${proxy.username}:${proxy.password}"));
+      request.headers.set(HttpHeaders.PROXY_AUTHORIZATION, "Basic $auth");
+    }
+    return request.close()
+        .then((response) {
+          if (response.statusCode != HttpStatus.OK) {
+            throw "Proxy failed to establish tunnel "
+                  "(${response.statusCode} ${response.reasonPhrase})";
+          }
+          var socket = response._httpRequest._httpClientConnection._socket;
+          return SecureSocket.secure(socket, host: host);
+        })
+        .then((secureSocket) {
+          String key = _HttpClientConnection.makeKey(true, host, port);
+          return new _HttpClientConnection(
+              key, secureSocket, request._httpClient, true);
+        });
+  }
+
   HttpConnectionInfo get connectionInfo => _HttpConnectionInfo.create(_socket);
+
+  static makeKey(bool isSecure, String host, int port) {
+    return isSecure ? "ssh:$host:$port" : "$host:$port";
+  }
+
 }
 
 class _ConnnectionInfo {
   _ConnnectionInfo(_HttpClientConnection this.connection, _Proxy this.proxy);
   final _HttpClientConnection connection;
   final _Proxy proxy;
 }
 
 
 class _HttpClient implements HttpClient {
@@ skipping 87 matching lines @@
                            HttpClientCredentials cr) {
     _proxyCredentials.add(new _ProxyCredentials(host, port, realm, cr));
   }
 
   set findProxy(String f(Uri uri)) => _findProxy = f;
 
   Future<HttpClientRequest> _openUrl(String method, Uri uri) {
     if (method == null) {
       throw new ArgumentError(method);
     }
-    if (uri.domain.isEmpty || (uri.scheme != "http" && uri.scheme != "https")) {
-      throw new ArgumentError("Unsupported scheme '${uri.scheme}' in $uri");
+    if (method != "CONNECT") {
+      if (uri.domain.isEmpty || (uri.scheme != "http" && uri.scheme != "https")) {

[Mads Ager (google), 2013/04/29 10:05:01]

long line

+        throw new ArgumentError("Unsupported scheme '${uri.scheme}' in $uri");
+      }
     }
 
     bool isSecure = (uri.scheme == "https");
     int port = uri.port;
     if (port == 0) {
       port = isSecure ?
           HttpClient.DEFAULT_HTTPS_PORT :
           HttpClient.DEFAULT_HTTP_PORT;
     }
     // Check to see if a proxy server should be used for this connection.
@@ skipping 67 matching lines @@
                                           int uriPort,
                                           _ProxyConfiguration proxyConf,
                                           bool isSecure) {
     Iterator<_Proxy> proxies = proxyConf.proxies.iterator;
 
     Future<_ConnnectionInfo> connect(error) {
       if (!proxies.moveNext()) return new Future.error(error);
       _Proxy proxy = proxies.current;
       String host = proxy.isDirect ? uriHost: proxy.host;
       int port = proxy.isDirect ? uriPort: proxy.port;
-      String key = isSecure ? "ssh:$host:$port" : "$host:$port";
+      String key = _HttpClientConnection.makeKey(isSecure, host, port);
       if (_idleConnections.containsKey(key)) {
         var connection = _idleConnections[key].first;
         _idleConnections[key].remove(connection);
         if (_idleConnections[key].isEmpty) {
           _idleConnections.remove(key);
         }
         _activeConnections.add(connection);
         return new Future.value(new _ConnnectionInfo(connection, proxy));
       }
       return (isSecure && proxy.isDirect
                   ? SecureSocket.connect(host,
                                          port,
                                          sendClientCertificate: true)
                   : Socket.connect(host, port))
         .then((socket) {
           socket.setOption(SocketOption.TCP_NODELAY, true);
           var connection = new _HttpClientConnection(key, socket, this);
-          _activeConnections.add(connection);
-          return new _ConnnectionInfo(connection, proxy);
+          if (isSecure && !proxy.isDirect) {
+            connection._dispose = true;
+            return connection.createProxyTunnel(uriHost, uriPort, proxy)
+                .then((tunnel) {
+                  _activeConnections.add(tunnel);
+                  return new _ConnnectionInfo(tunnel, proxy);
+                });
+          } else {
+            _activeConnections.add(connection);
+            return new _ConnnectionInfo(connection, proxy);
+          }
         }, onError: (error) {
           // Continue with next proxy.
           return connect(error);
         });
     }
     return connect(new HttpException("No proxies given"));
   }
 
   _Credentials _findCredentials(Uri url, [_AuthenticationScheme scheme]) {
     // Look for credentials.
@@ skipping 593 matching lines @@
 
 
 class _RedirectInfo implements RedirectInfo {
   const _RedirectInfo(int this.statusCode,
                       String this.method,
                       Uri this.location);
   final int statusCode;
   final String method;
   final Uri location;
 }