Support for cookies in the HTTP library

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];
@@ skipping 42 matching lines @@
   void removeAll(String name) {
     _checkMutable();
     name = name.toLowerCase();
     _headers.remove(name);
   }
 
   void forEach(void f(String name, List<String> values)) {
     _headers.forEach(f);
   }
 
+  void noFolding(String name) {
+    if (_noFoldingHeaders == null) _noFoldingHeaders = new List<String>();
+    _noFoldingHeaders.add(name);
+  }
+
   String get host() => _host;
 
   void set host(String host) {
     _checkMutable();
     _host = host;
     _updateHostHeader();
   }
 
   int get port() => _port;
 
@@ skipping 120 matching lines @@
   _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");
   }
 
+  _foldHeader(String name) {
+    if (name == "set-cookie" ||
+        (_noFoldingHeaders != null &&
+         _noFoldingHeaders.indexOf(name) != -1)) {
+      return false;
+    }
+    return true;
+  }
+
   _write(_HttpConnectionBase connection) {
     final COLONSP = const [_CharCode.COLON, _CharCode.SP];
     final COMMASP = const [_CharCode.COMMA, _CharCode.SP];
     final CRLF = const [_CharCode.CR, _CharCode.LF];
 
     // Format headers.
     _headers.forEach((String name, List<String> values) {
+      bool fold = _foldHeader(name);
       List<int> data;
       data = name.charCodes();
       connection._write(data);
       connection._write(COLONSP);
       for (int i = 0; i < values.length; i++) {
         if (i > 0) {
-          connection._write(COMMASP);
+          if (fold) {
+            connection._write(COMMASP);
+          } else {
+            connection._write(CRLF);
+            data = name.charCodes();
+            connection._write(data);
+            connection._write(COLONSP);
+          }
         }
         data = values[i].charCodes();
         connection._write(data);
       }
       connection._write(CRLF);
     });
   }
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     _headers.forEach((String name, List<String> values) {
       sb.add(name);
       sb.add(": ");
+      bool fold = _foldHeader(name);
       for (int i = 0; i < values.length; i++) {
         if (i > 0) {
-          sb.add(", ");
+          if (fold) {
+            sb.add(", ");
+          } else {
+            sb.add("\n");
+            sb.add(name);
+            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;
+  List<String> _noFoldingHeaders;
 
   String _host;
   int _port;
 }
 
 
 class _HeaderValue implements HeaderValue {
   _HeaderValue([String this.value = ""]);
 
   _HeaderValue.fromString(String value) {
@@ skipping 148 matching lines @@
 
   void set charset(String s) {
     parameters["charset"] = s;
   }
 
   String _primaryType = "";
   String _subType = "";
 }
 
 
+class _Cookie implements Cookie {
+  _Cookie([String this.name, String this.value]);

[Mads Ager (google), 2012/05/23 13:31:05]

I would add a blank line after the first constructor.

[Søren Gjesse, 2012/05/24 11:34:21]

Done.

+  _Cookie.fromSetCookieValue(String value) {
+    // Parse the Set-Cookie header value.
+    _parseSetCookieValue(value);
+  }
+
+  // Parse a Set-Cookie header value according to the rules in RFC 6265.
+  void _parseSetCookieValue(String s) {
+    int index = 0;
+
+    bool done() => index == s.length;
+
+    String parseName() {
+      int start = index;
+      while (!done()) {
+        if (s[index] == "=") break;
+        index++;
+      }
+      return s.substring(start, index).trim().toLowerCase();
+    }
+
+    String parseValue() {
+      int start = index;
+      while (!done()) {
+        if (s[index] == ";") break;
+        index++;
+      }
+      return s.substring(start, index).trim().toLowerCase();
+    }
+
+    void expect(String expected) {
+      if (done()) throw new HttpException("Failed to parse header value [$s]");
+      if (s[index] != expected) {
+        throw new HttpException("Failed to parse header value [$s]");
+      }
+      index++;
+    }
+
+    void parseAttributes() {
+      String parseAttributeName() {
+        int start = index;
+        while (!done()) {
+          if (s[index] == "=" || s[index] == ";") break;
+          index++;
+        }
+        return s.substring(start, index).trim().toLowerCase();
+      }
+
+      String parseAttributeValue() {
+        int start = index;
+        while (!done()) {
+          if (s[index] == ";") break;
+          index++;
+        }
+        return s.substring(start, index).trim().toLowerCase();
+      }
+
+      while (!done()) {
+        String name = parseAttributeName();
+        String value = "";
+        if (!done() && s[index] == "=") {
+          index++;  // Skip the = character.
+          value = parseAttributeValue();
+        }
+        if (name == "expires") {
+          expires = _HttpUtils.parseDate(value, strict: false);
+        } else if (name == "max-age") {
+          maxAge = Math.parseInt(value);
+        } else if (name == "domain") {
+          domain = value;
+        } else if (name == "path") {
+          path = value;
+        } else if (name == "httponly") {
+          httpOnly = true;
+        } else if (name == "secure") {
+          secure = true;
+        }
+        if (!done()) index++;  // Skip the ; character
+      }
+    }
+
+    name = parseName();
+    if (done() || name.length == 0) {
+      _valid = false;
+      return;
+    }
+    index++;  // Skip the = character.
+    value = parseValue();
+    if (done()) return;
+    index++;  // Skip the ; character.
+    parseAttributes();
+  }
+
+  String toString() {
+    StringBuffer sb = new StringBuffer();
+    sb.add(name);
+    sb.add("=");
+    sb.add(value);
+    if (expires != null) {
+      sb.add("; Expires=");
+      sb.add(_HttpUtils.formatDate(expires));
+    }
+    if (maxAge != null) {
+      sb.add("; Max-Age=");
+      sb.add(maxAge);
+    }
+    if (domain != null) {
+      sb.add("; Domain=");
+      sb.add(domain);
+    }
+    if (path != null) {
+      sb.add("; Path=");
+      sb.add(path);
+    }
+    if (secure) sb.add("; Secure");
+    if (httpOnly) sb.add("; HttpOnly");
+    return sb.toString();
+  }
+
+  bool isValid() => _valid;

[Mads Ager (google), 2012/05/23 13:31:05]

I did not notice this in the interface. Add it? Should this be a getter? bool
get valid;

Also, since these are mutable shouldn't this be doing more? What if the name is
set to "" or to 42 after this Cookie was created? It will still say that it is
valid. It seems that could be an issue?

Do we need to verify here on each call?

[Søren Gjesse, 2012/05/24 11:34:21]

This was intended for handling validity when constructing from a string
(constructor fromSetCookitValue) but I ended up throwing exceptions instead.
When building a cookie there are no real validation needed.

I removed this for now as it was not used after all.

+
+  String name;
+  String value;
+  Date expires;
+  int maxAge;
+  String domain;
+  String path;
+  bool httpOnly = false;
+  bool secure = false;
+  bool _valid = true;
+}
+
+
 class _HttpRequestResponseBase {
   final int START = 0;
   final int HEADER_SENT = 1;
   final int DONE = 2;
   final int UPGRADED = 3;
 
   _HttpRequestResponseBase(_HttpConnectionBase this._httpConnection)
       : _headers = new _HttpHeaders() {
     _state = START;
   }
@@ skipping 121 matching lines @@
     if (_bodyBytesWritten + bytes > _contentLength) {
       throw new HttpException("Writing more than specified content length");
     }
     _bodyBytesWritten += bytes;
   }
 
   int _state;
 
   _HttpConnectionBase _httpConnection;
   _HttpHeaders _headers;
+  List<Cookie> _cookies;
   String _protocolVersion = "1.1";
 
   // 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 = -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;
   String get queryString() => _queryString;
   Map get queryParameters() => _queryParameters;
 
+  List<Cookie> get cookies() {
+    if (_cookies != null) return _cookies;
+
+    // Parse a Cookie header value according to the rules in RFC 6265.
+   void _parseCookieString(String s) {
+      int index = 0;
+
+      bool done() => index == s.length;
+
+      void skipWS() {
+        while (!done()) {
+          if (s[index] != " " && s[index] != "\t") return;

[Mads Ager (google), 2012/05/23 13:31:05]

indentation

[Søren Gjesse, 2012/05/24 11:34:21]

Done.

+         index++;
+        }
+      }
+
+      String parseName() {
+        int start = index;
+        while (!done()) {
+          if (s[index] == " " || s[index] == "\t" || s[index] == "=") break;
+          index++;
+        }
+        return s.substring(start, index).toLowerCase();
+      }
+
+      String parseValue() {
+        int start = index;

[Mads Ager (google), 2012/05/23 13:31:05]

indentation

[Søren Gjesse, 2012/05/24 11:34:21]

Done.

+       while (!done()) {
+          if (s[index] == " " || s[index] == "\t" || s[index] == ";") break;
+          index++;
+        }
+        return s.substring(start, index).toLowerCase();
+      }
+
+      void expect(String expected) {
+        if (done()) throw new HttpException("Failed to parse header value [$s]");

[Mads Ager (google), 2012/05/23 13:31:05]

Long line.

[Søren Gjesse, 2012/05/24 11:34:21]

Done.

+        if (s[index] != expected) {
+          throw new HttpException("Failed to parse header value [$s]");
+        }
+        index++;
+      }
+
+      while (!done()) {
+        skipWS();
+        if (done()) return;
+        String name = parseName();
+        skipWS();
+        expect("=");
+        skipWS();
+        String value = parseValue();
+        _cookies.add(new _Cookie(name, value));
+        skipWS();
+        if (done()) return;
+        expect(";");
+      }
+    }
+
+    _cookies = new List<Cookie>();
+    List<String> headerValues = headers["cookie"];
+    if (headerValues != null) {
+      headerValues.forEach((headerValue) => _parseCookieString(headerValue));
+    }
+    return _cookies;
+  }
+
   InputStream get inputStream() {
     if (_inputStream == null) {
       _inputStream = new _HttpInputStream(this);
     }
     return _inputStream;
   }
 
   String get protocolVersion() => _protocolVersion;
 
   void _onRequestStart(String method, String uri, String version) {
@@ skipping 81 matching lines @@
     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;
   }
 
+  List<Cookie> get cookies() {
+    if (_cookies == null) _cookies = new List<Cookie>();
+    return _cookies;
+  }
+
   OutputStream get outputStream() {
     if (_state >= DONE) throw new HttpException("Response closed");
     if (_outputStream == null) {
       _outputStream = new _HttpOutputStream(this);
     }
     return _outputStream;
   }
 
   DetachedSocket detachSocket() {
     if (_state >= DONE) throw new HttpException("Response closed");
@@ skipping 126 matching lines @@
     _writeCRLF();
 
     // Determine the value of the "Transfer-Encoding" header based on
     // whether the content length is known.
     if (_contentLength > 0) {
       _headers.set(HttpHeaders.CONTENT_LENGTH, _contentLength.toString());
     } else if (_contentLength < 0) {
       _headers.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
     }
 
+    // Add all the cookies set to the headers.
+    if (_cookies != null) {
+      _cookies.forEach((cookie) {
+        _headers.add("set-cookie", cookie);
+      });
+    }
+
     // Write headers.
     bool allWritten = _writeHeaders();
     _state = HEADER_SENT;
     return allWritten;
   }
 
   // Response status code.
   int _statusCode;
   String _reasonPhrase;
   _HttpOutputStream _outputStream;
@@ skipping 416 matching lines @@
     if (_method == "GET") {
       _contentLength = 0;
     }
   }
 
   void set contentLength(int contentLength) {
     if (_state >= HEADER_SENT) throw new HttpException("Header already sent");
     _contentLength = contentLength;
   }
 
+  List<Cookie> get cookies() {
+    if (_cookies == null) _cookies = new List<Cookie>();
+    return _cookies;
+  }
+
   OutputStream get outputStream() {
     if (_state == DONE) throw new HttpException("Request closed");
     if (_outputStream == null) {
       _outputStream = new _HttpOutputStream(this);
     }
     return _outputStream;
   }
 
   // Delegate functions for the HttpOutputStream implementation.
   bool _streamWrite(List<int> buffer, bool copyBuffer) {
@@ skipping 44 matching lines @@
 
     // Determine the value of the "Transfer-Encoding" header based on
     // whether the content length is known. If there is no content
     // neither "Content-Length" nor "Transfer-Encoding" is set
     if (_contentLength > 0) {
       _headers.set(HttpHeaders.CONTENT_LENGTH, _contentLength.toString());
     } else if (_contentLength < 0) {
       _headers.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
     }
 
+    // Add the cookies to the headers.
+    if (_cookies != null) {
+      StringBuffer sb = new StringBuffer();
+      for (int i = 0; i < _cookies.length; i++) {
+        if (i > 0) sb.add("; ");
+        sb.add(_cookies[i].name);
+        sb.add("=");
+        sb.add(_cookies[i].value);
+      }
+      _headers.add("cookie", sb.toString());
+    }
+
     // Write headers.
     _writeHeaders();
     _state = HEADER_SENT;
   }
 
   String _method;
   String _uri;
   _HttpClientConnection _connection;
   _HttpOutputStream _outputStream;
   Function _streamErrorHandler;
@@ skipping 10 matching lines @@
   int get statusCode() => _statusCode;
   String get reasonPhrase() => _reasonPhrase;
 
   bool get isRedirect() {
     return statusCode == HttpStatus.MOVED_PERMANENTLY ||
            statusCode == HttpStatus.FOUND ||
            statusCode == HttpStatus.SEE_OTHER ||
            statusCode == HttpStatus.TEMPORARY_REDIRECT;
   }
 
+  List<Cookie> get cookies() {
+    if (_cookies != null) return _cookies;
+    _cookies = new List<Cookie>();
+    List<String> values = _headers["set-cookie"];
+    if (values != null) {
+      values.forEach((value) {
+        _cookies.add(new Cookie.fromSetCookieValue(value));
+      });
+    }
+    return _cookies;
+  }
+
   InputStream get inputStream() {
     if (_inputStream == null) {
       _inputStream = new _HttpInputStream(this);
     }
     return _inputStream;
   }
 
   void _onRequestStart(String method, String uri, String version) {
     // TODO(sgjesse): Error handling
   }
@@ skipping 464 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;
 }