Check the state of the HTTP request and response when handling headers

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.
 
 class _HttpHeaders implements HttpHeaders {
   _HttpHeaders() : _headers = new Map<String, List<String>>();
 
   List<String> operator[](String name) {
     name = name.toLowerCase();
     return _headers[name];
   }
 
   String value(String name) {
     name = name.toLowerCase();
     List<String> values = _headers[name];
     if (values == null) return null;
     if (values.length > 1) {
       throw new HttpException("More than one value for header $name");
     }
     return values[0];
   }
 
   void add(String name, Object value) {
+    _checkMutable();
     if (value is List) {
       for (int i = 0; i < value.length; i++) {
         _add(name, value[i]);
       }
     } else {
       _add(name, value);
     }
   }
 
   void set(String name, Object value) {
+    _checkMutable();
     removeAll(name);
     add(name, value);
   }
 
   void remove(String name, Object value) {
+    _checkMutable();
     name = name.toLowerCase();
     List<String> values = _headers[name];
     if (values != null) {
       int index = values.indexOf(value);
       if (index != -1) {
         values.removeRange(index, 1);
       }
     }
   }
 
   void removeAll(String name) {
+    _checkMutable();
     name = name.toLowerCase();
     _headers.remove(name);
   }
 
   String get host() => _host;
+
   void set host(String host) {
+    _checkMutable();
     _host = host;
     _updateHostHeader();
   }
 
   int get port() => _port;
+
   void set port(int port) {
+    _checkMutable();
     _port = port;
     _updateHostHeader();
   }
 
   Date get date() {
     List<String> values = _headers["date"];
     if (values != null) {
       try {
         return _HttpUtils.parseDate(values[0]);
       } catch (Exception e) {
         return null;
       }
     }
     return null;
   }
 
   void set date(Date date) {
+    _checkMutable();
     // Format "Date" header with date in Greenwich Mean Time (GMT).
     String formatted =
         _HttpUtils.formatDate(expires.changeTimeZone(new TimeZone.utc()));
     _set("date", formatted);
   }
 
   Date get expires() {
     List<String> values = _headers["expires"];
     if (values != null) {
       try {
         return _HttpUtils.parseDate(values[0]);
       } catch (Exception e) {
         return null;
       }
     }
     return null;
   }
 
   void set expires(Date expires) {
+    _checkMutable();
     // Format "Expires" header with date in Greenwich Mean Time (GMT).
     String formatted =
         _HttpUtils.formatDate(expires.changeTimeZone(new TimeZone.utc()));
     _set("expires", formatted);
   }
 
   void _add(String name, Object value) {
     // TODO(sgjesse): Add immutable state throw HttpException is immutable.
     if (name.toLowerCase() == "date") {
       if (value is Date) {
@@ skipping 44 matching lines @@
     }
   }
 
   void _set(String name, String value) {
     name = name.toLowerCase();
     List<String> values = new List<String>();
     _headers[name] = values;
     values.add(value);
   }
 
+  _checkMutable() {
+    if (!_mutable) throw new HttpException("HTTP headers are not mutable");
+  }
+
   _updateHostHeader() {
     bool defaultPort = _port == null || _port == HttpClient.DEFAULT_HTTP_PORT;
     String portPart = defaultPort ? "" : ":$_port";
     _set("host", "$host$portPart");
   }
 
   _write(_HttpConnectionBase connection) {
     final COLONSP = const [_CharCode.COLON, _CharCode.SP];
     final COMMASP = const [_CharCode.COMMA, _CharCode.SP];
     final CRLF = const [_CharCode.CR, _CharCode.LF];
@@ skipping 24 matching lines @@
         if (i > 0) {
           sb.add(": ");
         }
         sb.add(values[i]);
       }
       sb.add("\n");
     });
     return sb.toString();
   }
 
+  bool _mutable = true;  // Are the headers currently mutable?
   Map<String, List<String>> _headers;
 
   String _host;
   int _port;
 }
 
 
 class _HttpRequestResponseBase {
+  final int START = 0;
+  final int HEADER_SENT = 1;
+  final int DONE = 2;
+
   _HttpRequestResponseBase(_HttpConnectionBase this._httpConnection)
-      : _contentLength = -1,
-        _headers = new _HttpHeaders();
+      : _headers = new _HttpHeaders() {
+    _state = START;
+  }
 
   int get contentLength() => _contentLength;
   HttpHeaders get headers() => _headers;
 
   bool _write(List<int> data, bool copyBuffer) {
+    _ensureHeadersSent();
     bool allWritten = true;
     if (data.length > 0) {
       if (_contentLength < 0) {
         // Write chunk size if transfer encoding is chunked.
         _writeHexString(data.length);
         _writeCRLF();
         _httpConnection._write(data, copyBuffer);
         allWritten = _writeCRLF();
       } else {
+        _checkContentLength(data.length);
         allWritten = _httpConnection._write(data, copyBuffer);
       }
     }
     return allWritten;
   }
 
   bool _writeList(List<int> data, int offset, int count) {
+    _ensureHeadersSent();
     bool allWritten = true;
     if (count > 0) {
       if (_contentLength < 0) {
         // Write chunk size if transfer encoding is chunked.
         _writeHexString(count);
         _writeCRLF();
         _httpConnection._writeFrom(data, offset, count);
         allWritten = _writeCRLF();
       } else {
+        _checkContentLength(count);
         allWritten = _httpConnection._writeFrom(data, offset, count);
       }
     }
     return allWritten;
   }
 
   bool _writeDone() {
     bool allWritten = true;
     if (_contentLength < 0) {
       // Terminate the content if transfer encoding is chunked.
       allWritten = _httpConnection._write(_Const.END_CHUNKED);
+    } else {
+      if (_bodyBytesWritten < _contentLength) {
+        throw new HttpException("Sending less than specified content length");
+      }
+      assert(_bodyBytesWritten == _contentLength);
     }
     return allWritten;
   }
 
   bool _writeHeaders() {
+    _headers._mutable = false;
     _headers._write(_httpConnection);
     // Terminate header.
     return _writeCRLF();
   }
 
   bool _writeHexString(int x) {
     final List<int> hexDigits = [0x30, 0x31, 0x32, 0x33, 0x34,
                                  0x35, 0x36, 0x37, 0x38, 0x39,
                                  0x41, 0x42, 0x43, 0x44, 0x45, 0x46];
     ByteArray hex = new ByteArray(10);
     int index = hex.length;
     while (x > 0) {
       index--;
       hex[index] = hexDigits[x % 16];
       x = x >> 4;
     }
     return _httpConnection._writeFrom(hex, index, hex.length - index);
   }
 
   bool _writeCRLF() {
     final CRLF = const [_CharCode.CR, _CharCode.LF];
     return _httpConnection._write(CRLF);
   }
 
   bool _writeSP() {
     final SP = const [_CharCode.SP];
     return _httpConnection._write(SP);
   }
 
+  void _ensureHeadersSent() {
+    // Ensure that headers are written.
+    if (_state == START) {
+      _writeHeader();
+    }
+  }
+
+  void _checkContentLength(int bytes) {
+    if (_bodyBytesWritten + bytes > _contentLength) {
+      throw new HttpException("Writing more than specified content length");
+    }
+    _bodyBytesWritten += bytes;

[Anders Johnsen, 2012/04/26 10:12:50]

The "check" method here is mutable. Should we rename it?

[Søren Gjesse, 2012/04/26 11:26:40]

Good point. Renamed to _updateContentLength.

+  }
+
+  int _state;
+
   _HttpConnectionBase _httpConnection;
   _HttpHeaders _headers;
 
   // Length of the content body. If this is set to -1 (default value)
   // when starting to send data chunked transfer encoding will be
   // used.
-  int _contentLength;
+  int _contentLength = -1;
+  // Number of body bytes written. This is only actual body data not
+  // including headers or chunk information of using chinked transfer
+  // encoding.
+  int _bodyBytesWritten = 0;
 }
 
 
 // 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;
@@ skipping 11 matching lines @@
     _method = method;
     _uri = uri;
     _parseRequestUri(uri);
   }
 
   void _onHeaderReceived(String name, String value) {
     _headers.add(name, value);
   }
 
   void _onHeadersComplete() {
+    _headers._mutable = false;
     // Prepare for receiving data.
     _buffer = new _BufferList();
   }
 
   void _onDataReceived(List<int> data) {
     _buffer.add(data);
     if (_inputStream != null) _inputStream._dataReceived();
   }
 
   void _onDataEnd() {
@@ skipping 39 matching lines @@
   String _queryString;
   Map<String, String> _queryParameters;
   _HttpInputStream _inputStream;
   _BufferList _buffer;
   Function _streamErrorHandler;
 }
 
 
 // HTTP response object for sending a HTTP response.
 class _HttpResponse extends _HttpRequestResponseBase implements HttpResponse {
-  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;
+        _statusCode = HttpStatus.OK;
 
   void set contentLength(int contentLength) {
-    if (_outputStream != null) throw new HttpException("Header already sent");
+    if (_state >= HEADER_SENT) throw new HttpException("Header already sent");
     _contentLength = contentLength;
   }
 
   int get statusCode() => _statusCode;
   void set statusCode(int statusCode) {
     if (_outputStream != null) throw new HttpException("Header already sent");
     _statusCode = statusCode;
   }
 
   String get reasonPhrase() => _findReasonPhrase(_statusCode);
   void set reasonPhrase(String reasonPhrase) {
     if (_outputStream != null) throw new HttpException("Header already sent");
     _reasonPhrase = reasonPhrase;
   }
 
   OutputStream get outputStream() {
     if (_state == DONE) throw new HttpException("Response closed");
     if (_outputStream == null) {
-      // Ensure that headers are written.
-      if (_state == START) {
-        _writeHeader();
-      }
       _outputStream = new _HttpOutputStream(this);
     }
     return _outputStream;
   }
 
   void _responseEnd() {
+    _ensureHeadersSent();
     _state = DONE;
     // Stop tracking no pending write events.
     _httpConnection._onNoPendingWrites = null;
     // Ensure that any trailing data is written.
     _writeDone();
     // Indicate to the connection that the response handling is done.
     _httpConnection._responseDone();
   }
 
   // Delegate functions for the HttpOutputStream implementation.
   bool _streamWrite(List<int> buffer, bool copyBuffer) {
+    if (_state == DONE) throw new HttpException("Response closed");
     return _write(buffer, copyBuffer);
   }
 
   bool _streamWriteFrom(List<int> buffer, int offset, int len) {
+    if (_state == DONE) throw new HttpException("Response closed");
     return _writeList(buffer, offset, len);
   }
 
   void _streamClose() {
     _responseEnd();
   }
 
   void _streamSetNoPendingWriteHandler(callback()) {
     if (_state != DONE) {
       _httpConnection._onNoPendingWrites = callback;
@@ skipping 89 matching lines @@
     // Determine the value of the "Transfer-Encoding" header based on
     // whether the content length is known.
     if (_contentLength >= 0) {
       _headers.set("Content-Length", _contentLength.toString());
     } else {
       _headers.set("Transfer-Encoding", "chunked");
     }
 
     // Write headers.
     bool allWritten = _writeHeaders();
-    _state = HEADERS_SENT;
+    _state = HEADER_SENT;
     return allWritten;
   }
 
   // Response status code.
   int _statusCode;
   String _reasonPhrase;
   String _protocolVersion;
   bool _persistentConnection;
   _HttpOutputStream _outputStream;
-  int _state;
   Function _streamErrorHandler;
 }
 
 
 class _HttpInputStream extends _BaseDataInputStream implements InputStream {
   _HttpInputStream(_HttpRequestResponseBase this._requestOrResponse) {
     _checkScheduleCallbacks();
   }
 
   int available() {
@@ skipping 357 matching lines @@
   bool _closeServer = false;
   Set<_HttpConnection> _connections;  // Set of currently connected clients.
   List<_RequestHandlerRegistration> _handlers;
   Object _defaultHandler;
   Function _onError;
 }
 
 
 class _HttpClientRequest
     extends _HttpRequestResponseBase implements HttpClientRequest {
-  static final int START = 0;
-  static final int HEADERS_SENT = 1;
-  static final int DONE = 2;
-
   _HttpClientRequest(String this._method,
                      String this._uri,
                      _HttpClientConnection connection)
-      : super(connection),
-        _state = START {
+      : super(connection) {
     _connection = connection;
     // Default GET requests to have no content.
     if (_method == "GET") {
       _contentLength = 0;
     }
   }
 
-  void set contentLength(int contentLength) => _contentLength = contentLength;
+  void set contentLength(int contentLength) {
+    if (_state >= HEADER_SENT) throw new HttpException("Header already sent");
+    _contentLength = contentLength;
+  }
 
   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;
   }
 
   // Delegate functions for the HttpOutputStream implementation.
   bool _streamWrite(List<int> buffer, bool copyBuffer) {
+    if (_state == DONE) throw new HttpException("Request closed");
     return _write(buffer, copyBuffer);
   }
 
   bool _streamWriteFrom(List<int> buffer, int offset, int len) {
+    if (_state == DONE) throw new HttpException("Request closed");
     return _writeList(buffer, offset, len);
   }
 
   void _streamClose() {
+    _ensureHeadersSent();
     _state = DONE;
     // Stop tracking no pending write events.
     _httpConnection._onNoPendingWrites = null;
     // Ensure that any trailing data is written.
     _writeDone();
   }
 
   void _streamSetNoPendingWriteHandler(callback()) {
     if (_state != DONE) {
       _httpConnection._onNoPendingWrites = callback;
@@ skipping 24 matching lines @@
     // Determine the value of the "Transfer-Encoding" header based on
     // whether the content length is known.
     if (_contentLength >= 0) {
       _headers.set("Content-Length", _contentLength.toString());
     } else {
       _headers.set("Transfer-Encoding", "chunked");
     }
 
     // Write headers.
     _writeHeaders();
-    _state = HEADERS_SENT;
+    _state = HEADER_SENT;
   }
 
   String _method;
   String _uri;
   _HttpClientConnection _connection;
   _HttpOutputStream _outputStream;
-  int _state;
   Function _streamErrorHandler;
 }
 
 
 class _HttpClientResponse
     extends _HttpRequestResponseBase implements HttpClientResponse {
   _HttpClientResponse(_HttpClientConnection connection)
       : super(connection) {
     _connection = connection;
   }
@@ skipping 15 matching lines @@
   void _onResponseStart(int statusCode, String reasonPhrase, String version) {
     _statusCode = statusCode;
     _reasonPhrase = reasonPhrase;
   }
 
   void _onHeaderReceived(String name, String value) {
     _headers.add(name, value);
   }
 
   void _onHeadersComplete() {
+    _headers._mutable = false;
     _buffer = new _BufferList();
     if (_connection._onResponse != null) {
       _connection._onResponse(this);
     }
   }
 
   void _onDataReceived(List<int> data) {
     _buffer.add(data);
     if (_inputStream != null) _inputStream._dataReceived();
   }
@@ skipping 342 matching lines @@
     _activeSockets.remove(socketConn);
     sockets.addFirst(socketConn);
   }
 
   Function _onOpen;
   Map<String, Queue<_SocketConnection>> _openSockets;
   Set<_SocketConnection> _activeSockets;
   Timer _evictionTimer;
   bool _shutdown;  // Has this HTTP client been shutdown?
 }