Add handling of the HTTP header "Host"

runtime/bin/http_impl.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.
 
 // Utility class for encoding a string into UTF-8 byte stream.
 class _UTF8Encoder {
   static List<int> encodeString(String string) {
     int size = _encodingSize(string);
     ByteArray result = new ByteArray(size);
     _encodeString(string, result);
@@ skipping 40 matching lines @@
 
 
 class _HttpRequestResponseBase {
   _HttpRequestResponseBase(_HttpConnectionBase this._httpConnection)
       : _contentLength = -1,
         _keepAlive = false,
         _headers = new Map();
 
   int get contentLength() => _contentLength;
   bool get keepAlive() => _keepAlive;
+  Map get headers() => _headers;
 
   void _setHeader(String name, String value) {
     _headers[name] = value;
   }
 
   bool _write(List<int> data, bool copyBuffer) {
     bool allWritten = true;
     if (data.length > 0) {
       if (_contentLength < 0) {
         // Write chunk size if transfer encoding is chunked.
@@ skipping 95 matching lines @@
 }
 
 
 // Parsed HTTP request providing information on the HTTP headers.
 class _HttpRequest extends _HttpRequestResponseBase implements HttpRequest {
   _HttpRequest(_HttpConnection connection) : super(connection);
 
   String get method() => _method;
   String get uri() => _uri;
   String get path() => _path;
-  Map get headers() => _headers;
   String get queryString() => _queryString;
   Map get queryParameters() => _queryParameters;
 
   InputStream get inputStream() {
     if (_inputStream == null) {
       _inputStream = new _HttpInputStream(this);
     }
     return _inputStream;
   }
 
@@ skipping 65 matching lines @@
   static final int START = 0;
   static final int HEADERS_SENT = 1;
   static final int DONE = 2;
 
   _HttpResponse(_HttpConnection httpConnection)
       : super(httpConnection),
         _statusCode = HttpStatus.OK,
         _state = START;
 
   void set contentLength(int contentLength) {
-    if (_outputStream != null) return new HttpException("Header already sent");
+    if (_outputStream != null) throw new HttpException("Header already sent");
     _contentLength = contentLength;
   }
 
   void set keepAlive(bool keepAlive) {
-    if (_outputStream != null) return new HttpException("Header already sent");
+    if (_outputStream != null) throw new HttpException("Header already sent");
     _keepAlive = keepAlive;
   }
 
   int get statusCode() => _statusCode;
   void set statusCode(int statusCode) {
-    if (_outputStream != null) return new HttpException("Header already sent");
+    if (_outputStream != null) throw new HttpException("Header already sent");
     _statusCode = statusCode;
   }
 
   String get reasonPhrase() => _findReasonPhrase(_statusCode);
   void set reasonPhrase(String reasonPhrase) {
-    if (_outputStream != null) return new HttpException("Header already sent");
+    if (_outputStream != null) throw new HttpException("Header already sent");
     _reasonPhrase = reasonPhrase;
   }
 
   // Set a header on the response. NOTE: If the same header is set
   // more than once only the last one will be part of the response.
   void setHeader(String name, String value) {
     if (_outputStream != null) return new HttpException("Header already sent");
     _setHeader(name, value);
   }
 
@@ skipping 417 matching lines @@
     _connection = connection;
     // Default GET requests to have no content.
     if (_method == "GET") {
       _contentLength = 0;
     }
   }
 
   void set contentLength(int contentLength) => _contentLength = contentLength;
   void set keepAlive(bool keepAlive) => _keepAlive = keepAlive;
 
+  Date get host() => _host;

[Anders Johnsen, 2012/03/06 10:29:57]

String

[Søren Gjesse, 2012/03/06 10:59:05]

Oops, forgot to run tests with type check turned on.

+  void set host(String host) {
+    _host = host;
+    _updateHostHeader();
+  }
+
+  int get port() => _port;
+  void set port(int port) {
+    _port = port;
+    _updateHostHeader();
+  }
+
   void setHeader(String name, String value) {
+    if (_state != START) throw new HttpException("Header already sent");
+    if (name.toLowerCase() == "host") {
+      int pos = value.indexOf(":");
+      if (pos == -1) {
+        _host = value;
+        _port = HttpClient.DEFAULT_HTTP_PORT;
+      } else {
+        _host = value.substring(0, pos);
+        if (pos + 1 == value.length) {
+          _port = HttpClient.DEFAULT_HTTP_PORT;
+        } else {
+          _port = Math.parseInt(value.substring(pos + 1));
+        }
+      }
+      _updateHostHeader();
+      return;
+    }
     _setHeader(name, value);
   }
 
   bool writeString(String string) {
     outputStream;
     return _writeString(string);
   }
 
   OutputStream get outputStream() {
     if (_state == DONE) throw new HttpException("Request closed");
     if (_outputStream == null) {
       // Ensure that headers are written.
       if (_state == START) {
         _writeHeader();
       }
       _outputStream = new _HttpOutputStream(this);
     }
     return _outputStream;
   }
 
+  _updateHostHeader() {
+    String portPart = _port == HttpClient.DEFAULT_HTTP_PORT ? "" : ":$_port";
+    _setHeader("host", "$host$portPart");
+  }
+
   // Delegate functions for the HttpOutputStream implementation.
   bool _streamWrite(List<int> buffer, bool copyBuffer) {
     return _write(buffer, copyBuffer);
   }
 
   bool _streamWriteFrom(List<int> buffer, int offset, int len) {
     return _writeList(buffer, offset, len);
   }
 
   void _streamClose() {
@@ skipping 48 matching lines @@
       setHeader("Transfer-Encoding", "chunked");
     }
 
     // Write headers.
     _writeHeaders();
     _state = HEADERS_SENT;
   }
 
   String _method;
   String _uri;
+  String _host;
+  int _port;
   _HttpClientConnection _connection;
   _HttpOutputStream _outputStream;
   int _state;
 }
 
 
 class _HttpClientResponse
     extends _HttpRequestResponseBase implements HttpClientResponse {
   _HttpClientResponse(_HttpClientConnection connection)
       : super(connection) {
     _connection = connection;
   }
 
   int get statusCode() => _statusCode;
   String get reasonPhrase() => _reasonPhrase;
-  Map get headers() => _headers;
 
   InputStream get inputStream() {
     if (_inputStream == null) {
       _inputStream = new _HttpInputStream(this);
     }
     return _inputStream;
   }
 
   void _onRequestStart(String method, String uri) {
     // TODO(sgjesse): Error handling
@@ skipping 194 matching lines @@
     return "$host:$port";
   }
 
   HttpClientConnection _prepareHttpClientConnection(
       String host, int port, String method, String path) {
 
     void _connectionOpened(_SocketConnection socketConn,
                            _HttpClientConnection connection) {
       connection._connectionEstablished(socketConn);
       HttpClientRequest request = connection.open(method, path);
+      request.host = host;
+      request.port = port;
       if (connection._onRequest != null) {
         connection._onRequest(request);
       } else {
         request.outputStream.close();
       }
     }
 
     _HttpClientConnection connection = new _HttpClientConnection(this);
 
     // If there are active connections for this key get the first one
@@ skipping 76 matching lines @@
     _onError = callback;
   }
 
   Function _onOpen;
   Function _onError;
   Map<String, Queue<_SocketConnection>> _openSockets;
   Set<_SocketConnection> _activeSockets;
   Timer _evictionTimer;
   bool _shutdown;  // Has this HTTP client been shutdown?
 }