blob: 7d87b886b98f33559d6bff345f27d60305b7eafe [file] [log] [blame]
// 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._http;
class _HttpHeaders implements HttpHeaders {
final Map<String, List<String>> _headers;
// The original header names keyed by the lowercase header names.
Map<String, String>? _originalHeaderNames;
final String protocolVersion;
bool _mutable = true; // Are the headers currently mutable?
List<String>? _noFoldingHeaders;
int _contentLength = -1;
bool _persistentConnection = true;
bool _chunkedTransferEncoding = false;
String? _host;
int? _port;
final int _defaultPortForScheme;
_HttpHeaders(this.protocolVersion,
{int defaultPortForScheme = HttpClient.defaultHttpPort,
_HttpHeaders? initialHeaders})
: _headers = new HashMap<String, List<String>>(),
_defaultPortForScheme = defaultPortForScheme {
if (initialHeaders != null) {
initialHeaders._headers.forEach((name, value) => _headers[name] = value);
_contentLength = initialHeaders._contentLength;
_persistentConnection = initialHeaders._persistentConnection;
_chunkedTransferEncoding = initialHeaders._chunkedTransferEncoding;
_host = initialHeaders._host;
_port = initialHeaders._port;
}
if (protocolVersion == "1.0") {
_persistentConnection = false;
_chunkedTransferEncoding = false;
}
}
List<String>? operator [](String name) => _headers[_validateField(name)];
String? value(String name) {
name = _validateField(name);
List<String>? values = _headers[name];
if (values == null) return null;
assert(values.isNotEmpty);
if (values.length > 1) {
throw new HttpException("More than one value for header $name");
}
return values[0];
}
void add(String name, value, {bool preserveHeaderCase = false}) {
_checkMutable();
String lowercaseName = _validateField(name);
if (preserveHeaderCase && name != lowercaseName) {
(_originalHeaderNames ??= {})[lowercaseName] = name;
} else {
_originalHeaderNames?.remove(lowercaseName);
}
_addAll(lowercaseName, value);
}
void _addAll(String name, value) {
if (value is Iterable) {
for (var v in value) {
_add(name, _validateValue(v));
}
} else {
_add(name, _validateValue(value));
}
}
void set(String name, Object value, {bool preserveHeaderCase = false}) {
_checkMutable();
String lowercaseName = _validateField(name);
_headers.remove(lowercaseName);
_originalHeaderNames?.remove(lowercaseName);
if (lowercaseName == HttpHeaders.contentLengthHeader) {
_contentLength = -1;
}
if (lowercaseName == HttpHeaders.transferEncodingHeader) {
_chunkedTransferEncoding = false;
}
if (preserveHeaderCase && name != lowercaseName) {
(_originalHeaderNames ??= {})[lowercaseName] = name;
}
_addAll(lowercaseName, value);
}
void remove(String name, Object value) {
_checkMutable();
name = _validateField(name);
value = _validateValue(value);
List<String>? values = _headers[name];
if (values != null) {
values.remove(_valueToString(value));
if (values.length == 0) {
_headers.remove(name);
_originalHeaderNames?.remove(name);
}
}
if (name == HttpHeaders.transferEncodingHeader && value == "chunked") {
_chunkedTransferEncoding = false;
}
}
void removeAll(String name) {
_checkMutable();
name = _validateField(name);
_headers.remove(name);
_originalHeaderNames?.remove(name);
}
void forEach(void action(String name, List<String> values)) {
_headers.forEach((String name, List<String> values) {
String originalName = _originalHeaderName(name);
action(originalName, values);
});
}
void noFolding(String name) {
name = _validateField(name);
(_noFoldingHeaders ??= <String>[]).add(name);
}
bool get persistentConnection => _persistentConnection;
void set persistentConnection(bool persistentConnection) {
_checkMutable();
if (persistentConnection == _persistentConnection) return;
final originalName = _originalHeaderName(HttpHeaders.connectionHeader);
if (persistentConnection) {
if (protocolVersion == "1.1") {
remove(HttpHeaders.connectionHeader, "close");
} else {
if (_contentLength < 0) {
throw new HttpException(
"Trying to set 'Connection: Keep-Alive' on HTTP 1.0 headers with "
"no ContentLength");
}
add(originalName, "keep-alive", preserveHeaderCase: true);
}
} else {
if (protocolVersion == "1.1") {
add(originalName, "close", preserveHeaderCase: true);
} else {
remove(HttpHeaders.connectionHeader, "keep-alive");
}
}
_persistentConnection = persistentConnection;
}
int get contentLength => _contentLength;
void set contentLength(int contentLength) {
_checkMutable();
if (protocolVersion == "1.0" &&
persistentConnection &&
contentLength == -1) {
throw new HttpException(
"Trying to clear ContentLength on HTTP 1.0 headers with "
"'Connection: Keep-Alive' set");
}
if (_contentLength == contentLength) return;
_contentLength = contentLength;
if (_contentLength >= 0) {
if (chunkedTransferEncoding) chunkedTransferEncoding = false;
_set(HttpHeaders.contentLengthHeader, contentLength.toString());
} else {
_headers.remove(HttpHeaders.contentLengthHeader);
if (protocolVersion == "1.1") {
chunkedTransferEncoding = true;
}
}
}
bool get chunkedTransferEncoding => _chunkedTransferEncoding;
void set chunkedTransferEncoding(bool chunkedTransferEncoding) {
_checkMutable();
if (chunkedTransferEncoding && protocolVersion == "1.0") {
throw new HttpException(
"Trying to set 'Transfer-Encoding: Chunked' on HTTP 1.0 headers");
}
if (chunkedTransferEncoding == _chunkedTransferEncoding) return;
if (chunkedTransferEncoding) {
List<String>? values = _headers[HttpHeaders.transferEncodingHeader];
if (values == null || !values.contains("chunked")) {
// Headers does not specify chunked encoding - add it if set.
_addValue(HttpHeaders.transferEncodingHeader, "chunked");
}
contentLength = -1;
} else {
// Headers does specify chunked encoding - remove it if not set.
remove(HttpHeaders.transferEncodingHeader, "chunked");
}
_chunkedTransferEncoding = chunkedTransferEncoding;
}
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();
}
DateTime? get ifModifiedSince {
List<String>? values = _headers[HttpHeaders.ifModifiedSinceHeader];
if (values != null) {
assert(values.isNotEmpty);
try {
return HttpDate.parse(values[0]);
} on Exception {
return null;
}
}
return null;
}
void set ifModifiedSince(DateTime? ifModifiedSince) {
_checkMutable();
if (ifModifiedSince == null) {
_headers.remove(HttpHeaders.ifModifiedSinceHeader);
} else {
// Format "ifModifiedSince" header with date in Greenwich Mean Time (GMT).
String formatted = HttpDate.format(ifModifiedSince.toUtc());
_set(HttpHeaders.ifModifiedSinceHeader, formatted);
}
}
DateTime? get date {
List<String>? values = _headers[HttpHeaders.dateHeader];
if (values != null) {
assert(values.isNotEmpty);
try {
return HttpDate.parse(values[0]);
} on Exception {
return null;
}
}
return null;
}
void set date(DateTime? date) {
_checkMutable();
if (date == null) {
_headers.remove(HttpHeaders.dateHeader);
} else {
// Format "DateTime" header with date in Greenwich Mean Time (GMT).
String formatted = HttpDate.format(date.toUtc());
_set(HttpHeaders.dateHeader, formatted);
}
}
DateTime? get expires {
List<String>? values = _headers[HttpHeaders.expiresHeader];
if (values != null) {
assert(values.isNotEmpty);
try {
return HttpDate.parse(values[0]);
} on Exception {
return null;
}
}
return null;
}
void set expires(DateTime? expires) {
_checkMutable();
if (expires == null) {
_headers.remove(HttpHeaders.expiresHeader);
} else {
// Format "Expires" header with date in Greenwich Mean Time (GMT).
String formatted = HttpDate.format(expires.toUtc());
_set(HttpHeaders.expiresHeader, formatted);
}
}
ContentType? get contentType {
var values = _headers[HttpHeaders.contentTypeHeader];
if (values != null) {
return ContentType.parse(values[0]);
} else {
return null;
}
}
void set contentType(ContentType? contentType) {
_checkMutable();
if (contentType == null) {
_headers.remove(HttpHeaders.contentTypeHeader);
} else {
_set(HttpHeaders.contentTypeHeader, contentType.toString());
}
}
void clear() {
_checkMutable();
_headers.clear();
_contentLength = -1;
_persistentConnection = true;
_chunkedTransferEncoding = false;
_host = null;
_port = null;
}
// [name] must be a lower-case version of the name.
void _add(String name, value) {
assert(name == _validateField(name));
// Use the length as index on what method to call. This is notable
// faster than computing hash and looking up in a hash-map.
switch (name.length) {
case 4:
if (HttpHeaders.dateHeader == name) {
_addDate(name, value);
return;
}
if (HttpHeaders.hostHeader == name) {
_addHost(name, value);
return;
}
break;
case 7:
if (HttpHeaders.expiresHeader == name) {
_addExpires(name, value);
return;
}
break;
case 10:
if (HttpHeaders.connectionHeader == name) {
_addConnection(name, value);
return;
}
break;
case 12:
if (HttpHeaders.contentTypeHeader == name) {
_addContentType(name, value);
return;
}
break;
case 14:
if (HttpHeaders.contentLengthHeader == name) {
_addContentLength(name, value);
return;
}
break;
case 17:
if (HttpHeaders.transferEncodingHeader == name) {
_addTransferEncoding(name, value);
return;
}
if (HttpHeaders.ifModifiedSinceHeader == name) {
_addIfModifiedSince(name, value);
return;
}
}
_addValue(name, value);
}
void _addContentLength(String name, value) {
if (value is int) {
contentLength = value;
} else if (value is String) {
contentLength = int.parse(value);
} else {
throw new HttpException("Unexpected type for header named $name");
}
}
void _addTransferEncoding(String name, value) {
if (value == "chunked") {
chunkedTransferEncoding = true;
} else {
_addValue(HttpHeaders.transferEncodingHeader, value);
}
}
void _addDate(String name, value) {
if (value is DateTime) {
date = value;
} else if (value is String) {
_set(HttpHeaders.dateHeader, value);
} else {
throw new HttpException("Unexpected type for header named $name");
}
}
void _addExpires(String name, value) {
if (value is DateTime) {
expires = value;
} else if (value is String) {
_set(HttpHeaders.expiresHeader, value);
} else {
throw new HttpException("Unexpected type for header named $name");
}
}
void _addIfModifiedSince(String name, value) {
if (value is DateTime) {
ifModifiedSince = value;
} else if (value is String) {
_set(HttpHeaders.ifModifiedSinceHeader, value);
} else {
throw new HttpException("Unexpected type for header named $name");
}
}
void _addHost(String name, value) {
if (value is String) {
int pos = value.indexOf(":");
if (pos == -1) {
_host = value;
_port = HttpClient.defaultHttpPort;
} else {
if (pos > 0) {
_host = value.substring(0, pos);
} else {
_host = null;
}
if (pos + 1 == value.length) {
_port = HttpClient.defaultHttpPort;
} else {
try {
_port = int.parse(value.substring(pos + 1));
} on FormatException {
_port = null;
}
}
}
_set(HttpHeaders.hostHeader, value);
} else {
throw new HttpException("Unexpected type for header named $name");
}
}
void _addConnection(String name, value) {
var lowerCaseValue = value.toLowerCase();
if (lowerCaseValue == 'close') {
_persistentConnection = false;
} else if (lowerCaseValue == 'keep-alive') {
_persistentConnection = true;
}
_addValue(name, value);
}
void _addContentType(String name, value) {
_set(HttpHeaders.contentTypeHeader, value);
}
void _addValue(String name, Object value) {
List<String> values = (_headers[name] ??= <String>[]);
values.add(_valueToString(value));
}
String _valueToString(Object value) {
if (value is DateTime) {
return HttpDate.format(value);
} else if (value is String) {
return value; // TODO(39784): no _validateValue?
} else {
return _validateValue(value.toString()) as String;
}
}
void _set(String name, String value) {
assert(name == _validateField(name));
_headers[name] = <String>[value];
}
void _checkMutable() {
if (!_mutable) throw new HttpException("HTTP headers are not mutable");
}
void _updateHostHeader() {
var host = _host;
if (host != null) {
bool defaultPort = _port == null || _port == _defaultPortForScheme;
_set("host", defaultPort ? host : "$host:$_port");
}
}
bool _foldHeader(String name) {
if (name == HttpHeaders.setCookieHeader) return false;
var noFoldingHeaders = _noFoldingHeaders;
return noFoldingHeaders == null || !noFoldingHeaders.contains(name);
}
void _finalize() {
_mutable = false;
}
void _build(BytesBuilder builder) {
_headers.forEach((String name, List<String> values) {
String originalName = _originalHeaderName(name);
bool fold = _foldHeader(name);
var nameData = originalName.codeUnits;
builder.add(nameData);
builder.addByte(_CharCode.COLON);
builder.addByte(_CharCode.SP);
for (int i = 0; i < values.length; i++) {
if (i > 0) {
if (fold) {
builder.addByte(_CharCode.COMMA);
builder.addByte(_CharCode.SP);
} else {
builder.addByte(_CharCode.CR);
builder.addByte(_CharCode.LF);
builder.add(nameData);
builder.addByte(_CharCode.COLON);
builder.addByte(_CharCode.SP);
}
}
builder.add(values[i].codeUnits);
}
builder.addByte(_CharCode.CR);
builder.addByte(_CharCode.LF);
});
}
String toString() {
StringBuffer sb = new StringBuffer();
_headers.forEach((String name, List<String> values) {
String originalName = _originalHeaderName(name);
sb..write(originalName)..write(": ");
bool fold = _foldHeader(name);
for (int i = 0; i < values.length; i++) {
if (i > 0) {
if (fold) {
sb.write(", ");
} else {
sb..write("\n")..write(originalName)..write(": ");
}
}
sb.write(values[i]);
}
sb.write("\n");
});
return sb.toString();
}
List<Cookie> _parseCookies() {
// Parse a Cookie header value according to the rules in RFC 6265.
var cookies = <Cookie>[];
void parseCookieString(String s) {
int index = 0;
bool done() => index == -1 || index == s.length;
void skipWS() {
while (!done()) {
if (s[index] != " " && s[index] != "\t") return;
index++;
}
}
String parseName() {
int start = index;
while (!done()) {
if (s[index] == " " || s[index] == "\t" || s[index] == "=") break;
index++;
}
return s.substring(start, index);
}
String parseValue() {
int start = index;
while (!done()) {
if (s[index] == " " || s[index] == "\t" || s[index] == ";") break;
index++;
}
return s.substring(start, index);
}
bool expect(String expected) {
if (done()) return false;
if (s[index] != expected) return false;
index++;
return true;
}
while (!done()) {
skipWS();
if (done()) return;
String name = parseName();
skipWS();
if (!expect("=")) {
index = s.indexOf(';', index);
continue;
}
skipWS();
String value = parseValue();
try {
cookies.add(new _Cookie(name, value));
} catch (_) {
// Skip it, invalid cookie data.
}
skipWS();
if (done()) return;
if (!expect(";")) {
index = s.indexOf(';', index);
continue;
}
}
}
List<String>? values = _headers[HttpHeaders.cookieHeader];
if (values != null) {
values.forEach((headerValue) => parseCookieString(headerValue));
}
return cookies;
}
static String _validateField(String field) {
for (var i = 0; i < field.length; i++) {
if (!_HttpParser._isTokenChar(field.codeUnitAt(i))) {
throw new FormatException(
"Invalid HTTP header field name: ${json.encode(field)}", field, i);
}
}
return field.toLowerCase();
}
static Object _validateValue(Object value) {
if (value is! String) return value;
for (var i = 0; i < (value as String).length; i++) {
if (!_HttpParser._isValueChar((value as String).codeUnitAt(i))) {
throw new FormatException(
"Invalid HTTP header field value: ${json.encode(value)}", value, i);
}
}
return value;
}
String _originalHeaderName(String name) {
return _originalHeaderNames?[name] ?? name;
}
}
class _HeaderValue implements HeaderValue {
String _value;
Map<String, String?>? _parameters;
Map<String, String?>? _unmodifiableParameters;
_HeaderValue([this._value = "", Map<String, String?> parameters = const {}]) {
// TODO(40614): Remove once non-nullability is sound.
Map<String, String?>? nullableParameters = parameters;
if (nullableParameters != null && nullableParameters.isNotEmpty) {
_parameters = new HashMap<String, String?>.from(nullableParameters);
}
}
static _HeaderValue parse(String value,
{String parameterSeparator = ";",
String? valueSeparator,
bool preserveBackslash = false}) {
// Parse the string.
var result = new _HeaderValue();
result._parse(value, parameterSeparator, valueSeparator, preserveBackslash);
return result;
}
String get value => _value;
Map<String, String?> _ensureParameters() =>
_parameters ??= <String, String?>{};
Map<String, String?> get parameters =>
_unmodifiableParameters ??= UnmodifiableMapView(_ensureParameters());
static bool _isToken(String token) {
if (token.isEmpty) {
return false;
}
final delimiters = "\"(),/:;<=>?@[\]{}";
for (int i = 0; i < token.length; i++) {
int codeUnit = token.codeUnitAt(i);
if (codeUnit <= 32 ||
codeUnit >= 127 ||
delimiters.indexOf(token[i]) >= 0) {
return false;
}
}
return true;
}
String toString() {
StringBuffer sb = new StringBuffer();
sb.write(_value);
var parameters = this._parameters;
if (parameters != null && parameters.length > 0) {
parameters.forEach((String name, String? value) {
sb..write("; ")..write(name);
if (value != null) {
sb.write("=");
if (_isToken(value)) {
sb.write(value);
} else {
sb.write('"');
int start = 0;
for (int i = 0; i < value.length; i++) {
// Can use codeUnitAt here instead.
int codeUnit = value.codeUnitAt(i);
if (codeUnit == 92 /* backslash */ ||
codeUnit == 34 /* double quote */) {
sb.write(value.substring(start, i));
sb.write(r'\');
start = i;
}
}
sb..write(value.substring(start))..write('"');
}
}
});
}
return sb.toString();
}
void _parse(String s, String parameterSeparator, String? valueSeparator,
bool preserveBackslash) {
int index = 0;
bool done() => index == s.length;
void skipWS() {
while (!done()) {
if (s[index] != " " && s[index] != "\t") return;
index++;
}
}
String parseValue() {
int start = index;
while (!done()) {
var char = s[index];
if (char == " " ||
char == "\t" ||
char == valueSeparator ||
char == parameterSeparator) break;
index++;
}
return s.substring(start, index);
}
void expect(String expected) {
if (done() || s[index] != expected) {
throw new HttpException("Failed to parse header value");
}
index++;
}
bool maybeExpect(String expected) {
if (done() || !s.startsWith(expected, index)) {
return false;
}
index++;
return true;
}
void parseParameters() {
var parameters = _ensureParameters();
String parseParameterName() {
int start = index;
while (!done()) {
var char = s[index];
if (char == " " ||
char == "\t" ||
char == "=" ||
char == parameterSeparator ||
char == valueSeparator) break;
index++;
}
return s.substring(start, index).toLowerCase();
}
String parseParameterValue() {
if (!done() && s[index] == "\"") {
// Parse quoted value.
StringBuffer sb = new StringBuffer();
index++;
while (!done()) {
var char = s[index];
if (char == "\\") {
if (index + 1 == s.length) {
throw new HttpException("Failed to parse header value");
}
if (preserveBackslash && s[index + 1] != "\"") {
sb.write(char);
}
index++;
} else if (char == "\"") {
index++;
return sb.toString();
}
char = s[index];
sb.write(char);
index++;
}
throw new HttpException("Failed to parse header value");
} else {
// Parse non-quoted value.
return parseValue();
}
}
while (!done()) {
skipWS();
if (done()) return;
String name = parseParameterName();
skipWS();
if (maybeExpect("=")) {
skipWS();
String value = parseParameterValue();
if (name == 'charset' && this is _ContentType) {
// Charset parameter of ContentTypes are always lower-case.
value = value.toLowerCase();
}
parameters[name] = value;
skipWS();
} else if (name.isNotEmpty) {
parameters[name] = null;
}
if (done()) return;
// TODO: Implement support for multi-valued parameters.
if (s[index] == valueSeparator) return;
expect(parameterSeparator);
}
}
skipWS();
_value = parseValue();
skipWS();
if (done()) return;
if (s[index] == valueSeparator) return;
maybeExpect(parameterSeparator);
parseParameters();
}
}
class _ContentType extends _HeaderValue implements ContentType {
String _primaryType = "";
String _subType = "";
_ContentType(String primaryType, String subType, String? charset,
Map<String, String?> parameters)
: _primaryType = primaryType,
_subType = subType,
super("") {
// TODO(40614): Remove once non-nullability is sound.
String emptyIfNull(String? string) => string ?? "";
_primaryType = emptyIfNull(_primaryType);
_subType = emptyIfNull(_subType);
_value = "$_primaryType/$_subType";
// TODO(40614): Remove once non-nullability is sound.
Map<String, String?>? nullableParameters = parameters;
if (nullableParameters != null) {
var parameterMap = _ensureParameters();
nullableParameters.forEach((String key, String? value) {
String lowerCaseKey = key.toLowerCase();
if (lowerCaseKey == "charset") {
value = value?.toLowerCase();
}
parameterMap[lowerCaseKey] = value;
});
}
if (charset != null) {
_ensureParameters()["charset"] = charset.toLowerCase();
}
}
_ContentType._();
static _ContentType parse(String value) {
var result = new _ContentType._();
result._parse(value, ";", null, false);
int index = result._value.indexOf("/");
if (index == -1 || index == (result._value.length - 1)) {
result._primaryType = result._value.trim().toLowerCase();
} else {
result._primaryType =
result._value.substring(0, index).trim().toLowerCase();
result._subType = result._value.substring(index + 1).trim().toLowerCase();
}
return result;
}
String get mimeType => '$primaryType/$subType';
String get primaryType => _primaryType;
String get subType => _subType;
String? get charset => parameters["charset"];
}
class _Cookie implements Cookie {
String _name;
String _value;
DateTime? expires;
int? maxAge;
String? domain;
String? _path;
bool httpOnly = false;
bool secure = false;
_Cookie(String name, String value)
: _name = _validateName(name),
_value = _validateValue(value),
httpOnly = true;
String get name => _name;
String get value => _value;
String? get path => _path;
set path(String? newPath) {
_validatePath(newPath);
_path = newPath;
}
set name(String newName) {
_validateName(newName);
_name = newName;
}
set value(String newValue) {
_validateValue(newValue);
_value = newValue;
}
_Cookie.fromSetCookieValue(String value)
: _name = "",
_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();
}
String parseValue() {
int start = index;
while (!done()) {
if (s[index] == ";") break;
index++;
}
return s.substring(start, index).trim();
}
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 = HttpDate._parseCookieDate(value);
} else if (name == "max-age") {
maxAge = int.parse(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 = _validateName(parseName());
if (done() || _name.length == 0) {
throw new HttpException("Failed to parse header value [$s]");
}
index++; // Skip the = character.
_value = _validateValue(parseValue());
if (done()) return;
index++; // Skip the ; character.
parseAttributes();
}
String toString() {
StringBuffer sb = new StringBuffer();
sb..write(_name)..write("=")..write(_value);
var expires = this.expires;
if (expires != null) {
sb..write("; Expires=")..write(HttpDate.format(expires));
}
if (maxAge != null) {
sb..write("; Max-Age=")..write(maxAge);
}
if (domain != null) {
sb..write("; Domain=")..write(domain);
}
if (path != null) {
sb..write("; Path=")..write(path);
}
if (secure) sb.write("; Secure");
if (httpOnly) sb.write("; HttpOnly");
return sb.toString();
}
static String _validateName(String newName) {
const separators = const [
"(",
")",
"<",
">",
"@",
",",
";",
":",
"\\",
'"',
"/",
"[",
"]",
"?",
"=",
"{",
"}"
];
if (newName == null) throw new ArgumentError.notNull("name");
for (int i = 0; i < newName.length; i++) {
int codeUnit = newName.codeUnitAt(i);
if (codeUnit <= 32 ||
codeUnit >= 127 ||
separators.indexOf(newName[i]) >= 0) {
throw new FormatException(
"Invalid character in cookie name, code unit: '$codeUnit'",
newName,
i);
}
}
return newName;
}
static String _validateValue(String newValue) {
if (newValue == null) throw new ArgumentError.notNull("value");
// Per RFC 6265, consider surrounding "" as part of the value, but otherwise
// double quotes are not allowed.
int start = 0;
int end = newValue.length;
if (2 <= newValue.length &&
newValue.codeUnits[start] == 0x22 &&
newValue.codeUnits[end - 1] == 0x22) {
start++;
end--;
}
for (int i = start; i < end; i++) {
int codeUnit = newValue.codeUnits[i];
if (!(codeUnit == 0x21 ||
(codeUnit >= 0x23 && codeUnit <= 0x2B) ||
(codeUnit >= 0x2D && codeUnit <= 0x3A) ||
(codeUnit >= 0x3C && codeUnit <= 0x5B) ||
(codeUnit >= 0x5D && codeUnit <= 0x7E))) {
throw new FormatException(
"Invalid character in cookie value, code unit: '$codeUnit'",
newValue,
i);
}
}
return newValue;
}
static void _validatePath(String? path) {
if (path == null) return;
for (int i = 0; i < path.length; i++) {
int codeUnit = path.codeUnitAt(i);
// According to RFC 6265, semicolon and controls should not occur in the
// path.
// path-value = <any CHAR except CTLs or ";">
// CTLs = %x00-1F / %x7F
if (codeUnit < 0x20 || codeUnit >= 0x7f || codeUnit == 0x3b /*;*/) {
throw FormatException(
"Invalid character in cookie path, code unit: '$codeUnit'");
}
}
}
}