1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 // The rules for parsing content-types were borrowed from Firefox:
6 // http://lxr.mozilla.org/mozilla/source/netwerk/base/src/nsURLHelper.cpp#834
8 #include "net/http/http_util.h"
12 #include "base/basictypes.h"
13 #include "base/logging.h"
14 #include "base/strings/string_number_conversions.h"
15 #include "base/strings/string_piece.h"
16 #include "base/strings/string_tokenizer.h"
17 #include "base/strings/string_util.h"
18 #include "base/strings/stringprintf.h"
19 #include "base/time/time.h"
24 // Helpers --------------------------------------------------------------------
26 // Returns the index of the closing quote of the string, if any. |start| points
27 // at the opening quote.
28 static size_t FindStringEnd(const std::string
& line
, size_t start
, char delim
) {
29 DCHECK_LT(start
, line
.length());
30 DCHECK_EQ(line
[start
], delim
);
31 DCHECK((delim
== '"') || (delim
== '\''));
33 const char set
[] = { delim
, '\\', '\0' };
34 for (size_t end
= line
.find_first_of(set
, start
+ 1);
35 end
!= std::string::npos
; end
= line
.find_first_of(set
, end
+ 2)) {
36 if (line
[end
] != '\\')
43 // HttpUtil -------------------------------------------------------------------
46 size_t HttpUtil::FindDelimiter(const std::string
& line
,
50 // search_start points to the spot from which we should start looking
52 const char delim_str
[] = { delimiter
, '"', '\'', '\0' };
53 size_t cur_delim_pos
= line
.find_first_of(delim_str
, search_start
);
54 if (cur_delim_pos
== std::string::npos
)
57 char ch
= line
[cur_delim_pos
];
58 if (ch
== delimiter
) {
63 // We hit the start of a quoted string. Look for its end.
64 search_start
= FindStringEnd(line
, cur_delim_pos
, ch
);
65 if (search_start
== line
.length())
70 // search_start now points to the first char after the end of the
71 // string, so just go back to the top of the loop and look for
80 void HttpUtil::ParseContentType(const std::string
& content_type_str
,
81 std::string
* mime_type
,
84 std::string
* boundary
) {
85 const std::string::const_iterator begin
= content_type_str
.begin();
87 // Trim leading and trailing whitespace from type. We include '(' in
88 // the trailing trim set to catch media-type comments, which are not at all
89 // standard, but may occur in rare cases.
90 size_t type_val
= content_type_str
.find_first_not_of(HTTP_LWS
);
91 type_val
= std::min(type_val
, content_type_str
.length());
92 size_t type_end
= content_type_str
.find_first_of(HTTP_LWS
";(", type_val
);
93 if (type_end
== std::string::npos
)
94 type_end
= content_type_str
.length();
96 size_t charset_val
= 0;
97 size_t charset_end
= 0;
98 bool type_has_charset
= false;
100 // Iterate over parameters
101 size_t param_start
= content_type_str
.find_first_of(';', type_end
);
102 if (param_start
!= std::string::npos
) {
103 base::StringTokenizer
tokenizer(begin
+ param_start
, content_type_str
.end(),
105 tokenizer
.set_quote_chars("\"");
106 while (tokenizer
.GetNext()) {
107 std::string::const_iterator equals_sign
=
108 std::find(tokenizer
.token_begin(), tokenizer
.token_end(), '=');
109 if (equals_sign
== tokenizer
.token_end())
112 std::string::const_iterator param_name_begin
= tokenizer
.token_begin();
113 std::string::const_iterator param_name_end
= equals_sign
;
114 TrimLWS(¶m_name_begin
, ¶m_name_end
);
116 std::string::const_iterator param_value_begin
= equals_sign
+ 1;
117 std::string::const_iterator param_value_end
= tokenizer
.token_end();
118 DCHECK(param_value_begin
<= tokenizer
.token_end());
119 TrimLWS(¶m_value_begin
, ¶m_value_end
);
121 if (LowerCaseEqualsASCII(param_name_begin
, param_name_end
, "charset")) {
122 // TODO(abarth): Refactor this function to consistently use iterators.
123 charset_val
= param_value_begin
- begin
;
124 charset_end
= param_value_end
- begin
;
125 type_has_charset
= true;
126 } else if (LowerCaseEqualsASCII(param_name_begin
, param_name_end
,
129 boundary
->assign(param_value_begin
, param_value_end
);
134 if (type_has_charset
) {
135 // Trim leading and trailing whitespace from charset_val. We include
136 // '(' in the trailing trim set to catch media-type comments, which are
137 // not at all standard, but may occur in rare cases.
138 charset_val
= content_type_str
.find_first_not_of(HTTP_LWS
, charset_val
);
139 charset_val
= std::min(charset_val
, charset_end
);
140 char first_char
= content_type_str
[charset_val
];
141 if (first_char
== '"' || first_char
== '\'') {
142 charset_end
= FindStringEnd(content_type_str
, charset_val
, first_char
);
144 DCHECK(charset_end
>= charset_val
);
146 charset_end
= std::min(content_type_str
.find_first_of(HTTP_LWS
";(",
152 // if the server sent "*/*", it is meaningless, so do not store it.
153 // also, if type_val is the same as mime_type, then just update the
154 // charset. however, if charset is empty and mime_type hasn't
155 // changed, then don't wipe-out an existing charset. We
156 // also want to reject a mime-type if it does not include a slash.
157 // some servers give junk after the charset parameter, which may
158 // include a comma, so this check makes us a bit more tolerant.
159 if (content_type_str
.length() != 0 &&
160 content_type_str
!= "*/*" &&
161 content_type_str
.find_first_of('/') != std::string::npos
) {
162 // Common case here is that mime_type is empty
163 bool eq
= !mime_type
->empty() && LowerCaseEqualsASCII(begin
+ type_val
,
167 mime_type
->assign(begin
+ type_val
, begin
+ type_end
);
168 base::StringToLowerASCII(mime_type
);
170 if ((!eq
&& *had_charset
) || type_has_charset
) {
172 charset
->assign(begin
+ charset_val
, begin
+ charset_end
);
173 base::StringToLowerASCII(charset
);
179 // Parse the Range header according to RFC 2616 14.35.1
180 // ranges-specifier = byte-ranges-specifier
181 // byte-ranges-specifier = bytes-unit "=" byte-range-set
182 // byte-range-set = 1#( byte-range-spec | suffix-byte-range-spec )
183 // byte-range-spec = first-byte-pos "-" [last-byte-pos]
184 // first-byte-pos = 1*DIGIT
185 // last-byte-pos = 1*DIGIT
186 bool HttpUtil::ParseRanges(const std::string
& headers
,
187 std::vector
<HttpByteRange
>* ranges
) {
188 std::string ranges_specifier
;
189 HttpUtil::HeadersIterator
it(headers
.begin(), headers
.end(), "\r\n");
191 while (it
.GetNext()) {
192 // Look for "Range" header.
193 if (!LowerCaseEqualsASCII(it
.name(), "range"))
195 ranges_specifier
= it
.values();
196 // We just care about the first "Range" header, so break here.
200 if (ranges_specifier
.empty())
203 return ParseRangeHeader(ranges_specifier
, ranges
);
207 bool HttpUtil::ParseRangeHeader(const std::string
& ranges_specifier
,
208 std::vector
<HttpByteRange
>* ranges
) {
209 size_t equal_char_offset
= ranges_specifier
.find('=');
210 if (equal_char_offset
== std::string::npos
)
213 // Try to extract bytes-unit part.
214 std::string::const_iterator bytes_unit_begin
= ranges_specifier
.begin();
215 std::string::const_iterator bytes_unit_end
= bytes_unit_begin
+
217 std::string::const_iterator byte_range_set_begin
= bytes_unit_end
+ 1;
218 std::string::const_iterator byte_range_set_end
= ranges_specifier
.end();
220 TrimLWS(&bytes_unit_begin
, &bytes_unit_end
);
221 // "bytes" unit identifier is not found.
222 if (!LowerCaseEqualsASCII(bytes_unit_begin
, bytes_unit_end
, "bytes"))
225 ValuesIterator
byte_range_set_iterator(byte_range_set_begin
,
226 byte_range_set_end
, ',');
227 while (byte_range_set_iterator
.GetNext()) {
228 size_t minus_char_offset
= byte_range_set_iterator
.value().find('-');
229 // If '-' character is not found, reports failure.
230 if (minus_char_offset
== std::string::npos
)
233 std::string::const_iterator first_byte_pos_begin
=
234 byte_range_set_iterator
.value_begin();
235 std::string::const_iterator first_byte_pos_end
=
236 first_byte_pos_begin
+ minus_char_offset
;
237 TrimLWS(&first_byte_pos_begin
, &first_byte_pos_end
);
238 std::string
first_byte_pos(first_byte_pos_begin
, first_byte_pos_end
);
241 // Try to obtain first-byte-pos.
242 if (!first_byte_pos
.empty()) {
243 int64 first_byte_position
= -1;
244 if (!base::StringToInt64(first_byte_pos
, &first_byte_position
))
246 range
.set_first_byte_position(first_byte_position
);
249 std::string::const_iterator last_byte_pos_begin
=
250 byte_range_set_iterator
.value_begin() + minus_char_offset
+ 1;
251 std::string::const_iterator last_byte_pos_end
=
252 byte_range_set_iterator
.value_end();
253 TrimLWS(&last_byte_pos_begin
, &last_byte_pos_end
);
254 std::string
last_byte_pos(last_byte_pos_begin
, last_byte_pos_end
);
256 // We have last-byte-pos or suffix-byte-range-spec in this case.
257 if (!last_byte_pos
.empty()) {
258 int64 last_byte_position
;
259 if (!base::StringToInt64(last_byte_pos
, &last_byte_position
))
261 if (range
.HasFirstBytePosition())
262 range
.set_last_byte_position(last_byte_position
);
264 range
.set_suffix_length(last_byte_position
);
265 } else if (!range
.HasFirstBytePosition()) {
269 // Do a final check on the HttpByteRange object.
270 if (!range
.IsValid())
272 ranges
->push_back(range
);
274 return !ranges
->empty();
278 bool HttpUtil::HasHeader(const std::string
& headers
, const char* name
) {
279 size_t name_len
= strlen(name
);
280 std::string::const_iterator it
=
281 std::search(headers
.begin(),
285 base::CaseInsensitiveCompareASCII
<char>());
286 if (it
== headers
.end())
289 // ensure match is prefixed by newline
290 if (it
!= headers
.begin() && it
[-1] != '\n')
293 // ensure match is suffixed by colon
294 if (it
+ name_len
>= headers
.end() || it
[name_len
] != ':')
301 // A header string containing any of the following fields will cause
302 // an error. The list comes from the XMLHttpRequest standard.
303 // http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader-method
304 const char* const kForbiddenHeaderFields
[] = {
307 "access-control-request-headers",
308 "access-control-request-method",
313 "content-transfer-encoding",
327 } // anonymous namespace
330 bool HttpUtil::IsSafeHeader(const std::string
& name
) {
331 std::string
lower_name(base::StringToLowerASCII(name
));
332 if (StartsWithASCII(lower_name
, "proxy-", true) ||
333 StartsWithASCII(lower_name
, "sec-", true))
335 for (size_t i
= 0; i
< arraysize(kForbiddenHeaderFields
); ++i
) {
336 if (lower_name
== kForbiddenHeaderFields
[i
])
343 bool HttpUtil::IsValidHeaderName(const std::string
& name
) {
344 // Check whether the header name is RFC 2616-compliant.
345 return HttpUtil::IsToken(name
);
349 bool HttpUtil::IsValidHeaderValue(const std::string
& value
) {
350 // Just a sanity check: disallow NUL and CRLF.
351 return value
.find('\0') == std::string::npos
&&
352 value
.find("\r\n") == std::string::npos
;
356 std::string
HttpUtil::StripHeaders(const std::string
& headers
,
357 const char* const headers_to_remove
[],
358 size_t headers_to_remove_len
) {
359 std::string stripped_headers
;
360 net::HttpUtil::HeadersIterator
it(headers
.begin(), headers
.end(), "\r\n");
362 while (it
.GetNext()) {
363 bool should_remove
= false;
364 for (size_t i
= 0; i
< headers_to_remove_len
; ++i
) {
365 if (LowerCaseEqualsASCII(it
.name_begin(), it
.name_end(),
366 headers_to_remove
[i
])) {
367 should_remove
= true;
371 if (!should_remove
) {
372 // Assume that name and values are on the same line.
373 stripped_headers
.append(it
.name_begin(), it
.values_end());
374 stripped_headers
.append("\r\n");
377 return stripped_headers
;
381 bool HttpUtil::IsNonCoalescingHeader(std::string::const_iterator name_begin
,
382 std::string::const_iterator name_end
) {
383 // NOTE: "set-cookie2" headers do not support expires attributes, so we don't
384 // have to list them here.
385 const char* kNonCoalescingHeaders
[] = {
389 "location", // See bug 1050541 for details
392 // The format of auth-challenges mixes both space separated tokens and
393 // comma separated properties, so coalescing on comma won't work.
395 "proxy-authenticate",
396 // STS specifies that UAs must not process any STS headers after the first
398 "strict-transport-security"
400 for (size_t i
= 0; i
< arraysize(kNonCoalescingHeaders
); ++i
) {
401 if (LowerCaseEqualsASCII(name_begin
, name_end
, kNonCoalescingHeaders
[i
]))
407 bool HttpUtil::IsLWS(char c
) {
408 return strchr(HTTP_LWS
, c
) != NULL
;
411 void HttpUtil::TrimLWS(std::string::const_iterator
* begin
,
412 std::string::const_iterator
* end
) {
413 // leading whitespace
414 while (*begin
< *end
&& IsLWS((*begin
)[0]))
417 // trailing whitespace
418 while (*begin
< *end
&& IsLWS((*end
)[-1]))
422 bool HttpUtil::IsQuote(char c
) {
423 // Single quote mark isn't actually part of quoted-text production,
424 // but apparently some servers rely on this.
425 return c
== '"' || c
== '\'';
428 // See RFC 2616 Sec 2.2 for the definition of |token|.
429 bool HttpUtil::IsToken(std::string::const_iterator begin
,
430 std::string::const_iterator end
) {
433 for (std::string::const_iterator iter
= begin
; iter
!= end
; ++iter
) {
434 unsigned char c
= *iter
;
435 if (c
>= 0x80 || c
<= 0x1F || c
== 0x7F ||
436 c
== '(' || c
== ')' || c
== '<' || c
== '>' || c
== '@' ||
437 c
== ',' || c
== ';' || c
== ':' || c
== '\\' || c
== '"' ||
438 c
== '/' || c
== '[' || c
== ']' || c
== '?' || c
== '=' ||
439 c
== '{' || c
== '}' || c
== ' ' || c
== '\t')
445 std::string
HttpUtil::Unquote(std::string::const_iterator begin
,
446 std::string::const_iterator end
) {
449 return std::string();
451 // Nothing to unquote.
452 if (!IsQuote(*begin
))
453 return std::string(begin
, end
);
455 // No terminal quote mark.
456 if (end
- begin
< 2 || *begin
!= *(end
- 1))
457 return std::string(begin
, end
);
463 // Unescape quoted-pair (defined in RFC 2616 section 2.2)
464 std::string unescaped
;
465 bool prev_escape
= false;
466 for (; begin
!= end
; ++begin
) {
468 if (c
== '\\' && !prev_escape
) {
473 unescaped
.push_back(c
);
479 std::string
HttpUtil::Unquote(const std::string
& str
) {
480 return Unquote(str
.begin(), str
.end());
484 std::string
HttpUtil::Quote(const std::string
& str
) {
486 escaped
.reserve(2 + str
.size());
488 std::string::const_iterator begin
= str
.begin();
489 std::string::const_iterator end
= str
.end();
491 // Esape any backslashes or quotemarks within the string, and
492 // then surround with quotes.
493 escaped
.push_back('"');
494 for (; begin
!= end
; ++begin
) {
496 if (c
== '"' || c
== '\\')
497 escaped
.push_back('\\');
498 escaped
.push_back(c
);
500 escaped
.push_back('"');
504 // Find the "http" substring in a status line. This allows for
505 // some slop at the start. If the "http" string could not be found
508 int HttpUtil::LocateStartOfStatusLine(const char* buf
, int buf_len
) {
510 const int http_len
= 4;
512 if (buf_len
>= http_len
) {
513 int i_max
= std::min(buf_len
- http_len
, slop
);
514 for (int i
= 0; i
<= i_max
; ++i
) {
515 if (LowerCaseEqualsASCII(buf
+ i
, buf
+ i
+ http_len
, "http"))
519 return -1; // Not found
522 int HttpUtil::LocateEndOfHeaders(const char* buf
, int buf_len
, int i
) {
525 for (; i
< buf_len
; ++i
) {
531 } else if (c
!= '\r' || last_c
!= '\n') {
539 // In order for a line to be continuable, it must specify a
540 // non-blank header-name. Line continuations are specifically for
541 // header values -- do not allow headers names to span lines.
542 static bool IsLineSegmentContinuable(const char* begin
, const char* end
) {
546 const char* colon
= std::find(begin
, end
, ':');
550 const char* name_begin
= begin
;
551 const char* name_end
= colon
;
553 // Name can't be empty.
554 if (name_begin
== name_end
)
557 // Can't start with LWS (this would imply the segment is a continuation)
558 if (HttpUtil::IsLWS(*name_begin
))
564 // Helper used by AssembleRawHeaders, to find the end of the status line.
565 static const char* FindStatusLineEnd(const char* begin
, const char* end
) {
566 size_t i
= base::StringPiece(begin
, end
- begin
).find_first_of("\r\n");
567 if (i
== base::StringPiece::npos
)
572 // Helper used by AssembleRawHeaders, to skip past leading LWS.
573 static const char* FindFirstNonLWS(const char* begin
, const char* end
) {
574 for (const char* cur
= begin
; cur
!= end
; ++cur
) {
575 if (!HttpUtil::IsLWS(*cur
))
578 return end
; // Not found.
581 std::string
HttpUtil::AssembleRawHeaders(const char* input_begin
,
583 std::string raw_headers
;
584 raw_headers
.reserve(input_len
);
586 const char* input_end
= input_begin
+ input_len
;
588 // Skip any leading slop, since the consumers of this output
589 // (HttpResponseHeaders) don't deal with it.
590 int status_begin_offset
= LocateStartOfStatusLine(input_begin
, input_len
);
591 if (status_begin_offset
!= -1)
592 input_begin
+= status_begin_offset
;
594 // Copy the status line.
595 const char* status_line_end
= FindStatusLineEnd(input_begin
, input_end
);
596 raw_headers
.append(input_begin
, status_line_end
);
598 // After the status line, every subsequent line is a header line segment.
599 // Should a segment start with LWS, it is a continuation of the previous
600 // line's field-value.
602 // TODO(ericroman): is this too permissive? (delimits on [\r\n]+)
603 base::CStringTokenizer
lines(status_line_end
, input_end
, "\r\n");
605 // This variable is true when the previous line was continuable.
606 bool prev_line_continuable
= false;
608 while (lines
.GetNext()) {
609 const char* line_begin
= lines
.token_begin();
610 const char* line_end
= lines
.token_end();
612 if (prev_line_continuable
&& IsLWS(*line_begin
)) {
613 // Join continuation; reduce the leading LWS to a single SP.
614 raw_headers
.push_back(' ');
615 raw_headers
.append(FindFirstNonLWS(line_begin
, line_end
), line_end
);
617 // Terminate the previous line.
618 raw_headers
.push_back('\n');
620 // Copy the raw data to output.
621 raw_headers
.append(line_begin
, line_end
);
623 // Check if the current line can be continued.
624 prev_line_continuable
= IsLineSegmentContinuable(line_begin
, line_end
);
628 raw_headers
.append("\n\n", 2);
630 // Use '\0' as the canonical line terminator. If the input already contained
631 // any embeded '\0' characters we will strip them first to avoid interpreting
632 // them as line breaks.
633 raw_headers
.erase(std::remove(raw_headers
.begin(), raw_headers
.end(), '\0'),
635 std::replace(raw_headers
.begin(), raw_headers
.end(), '\n', '\0');
640 std::string
HttpUtil::ConvertHeadersBackToHTTPResponse(const std::string
& str
) {
641 std::string disassembled_headers
;
642 base::StringTokenizer
tokenizer(str
, std::string(1, '\0'));
643 while (tokenizer
.GetNext()) {
644 disassembled_headers
.append(tokenizer
.token_begin(), tokenizer
.token_end());
645 disassembled_headers
.append("\r\n");
647 disassembled_headers
.append("\r\n");
649 return disassembled_headers
;
652 // TODO(jungshik): 1. If the list is 'fr-CA,fr-FR,en,de', we have to add
653 // 'fr' after 'fr-CA' with the same q-value as 'fr-CA' because
654 // web servers, in general, do not fall back to 'fr' and may end up picking
655 // 'en' which has a lower preference than 'fr-CA' and 'fr-FR'.
656 // 2. This function assumes that the input is a comma separated list
657 // without any whitespace. As long as it comes from the preference and
658 // a user does not manually edit the preference file, it's the case. Still,
659 // we may have to make it more robust.
660 std::string
HttpUtil::GenerateAcceptLanguageHeader(
661 const std::string
& raw_language_list
) {
662 // We use integers for qvalue and qvalue decrement that are 10 times
663 // larger than actual values to avoid a problem with comparing
664 // two floating point numbers.
665 const unsigned int kQvalueDecrement10
= 2;
666 unsigned int qvalue10
= 10;
667 base::StringTokenizer
t(raw_language_list
, ",");
668 std::string lang_list_with_q
;
669 while (t
.GetNext()) {
670 std::string language
= t
.token();
671 if (qvalue10
== 10) {
672 // q=1.0 is implicit.
673 lang_list_with_q
= language
;
675 DCHECK_LT(qvalue10
, 10U);
676 base::StringAppendF(&lang_list_with_q
, ",%s;q=0.%d", language
.c_str(),
679 // It does not make sense to have 'q=0'.
680 if (qvalue10
> kQvalueDecrement10
)
681 qvalue10
-= kQvalueDecrement10
;
683 return lang_list_with_q
;
686 void HttpUtil::AppendHeaderIfMissing(const char* header_name
,
687 const std::string
& header_value
,
688 std::string
* headers
) {
689 if (header_value
.empty())
691 if (net::HttpUtil::HasHeader(*headers
, header_name
))
693 *headers
+= std::string(header_name
) + ": " + header_value
+ "\r\n";
696 bool HttpUtil::HasStrongValidators(HttpVersion version
,
697 const std::string
& etag_header
,
698 const std::string
& last_modified_header
,
699 const std::string
& date_header
) {
700 if (version
< HttpVersion(1, 1))
703 if (!etag_header
.empty()) {
704 size_t slash
= etag_header
.find('/');
705 if (slash
== std::string::npos
|| slash
== 0)
708 std::string::const_iterator i
= etag_header
.begin();
709 std::string::const_iterator j
= etag_header
.begin() + slash
;
711 if (!LowerCaseEqualsASCII(i
, j
, "w"))
715 base::Time last_modified
;
716 if (!base::Time::FromString(last_modified_header
.c_str(), &last_modified
))
720 if (!base::Time::FromString(date_header
.c_str(), &date
))
723 return ((date
- last_modified
).InSeconds() >= 60);
726 // Functions for histogram initialization. The code 0 is put in the map to
727 // track status codes that are invalid.
728 // TODO(gavinp): Greatly prune the collected codes once we learn which
729 // ones are not sent in practice, to reduce upload size & memory use.
732 HISTOGRAM_MIN_HTTP_STATUS_CODE
= 100,
733 HISTOGRAM_MAX_HTTP_STATUS_CODE
= 599,
737 std::vector
<int> HttpUtil::GetStatusCodesForHistogram() {
738 std::vector
<int> codes
;
740 HISTOGRAM_MAX_HTTP_STATUS_CODE
- HISTOGRAM_MIN_HTTP_STATUS_CODE
+ 2);
742 for (int i
= HISTOGRAM_MIN_HTTP_STATUS_CODE
;
743 i
<= HISTOGRAM_MAX_HTTP_STATUS_CODE
; ++i
)
749 int HttpUtil::MapStatusCodeForHistogram(int code
) {
750 if (HISTOGRAM_MIN_HTTP_STATUS_CODE
<= code
&&
751 code
<= HISTOGRAM_MAX_HTTP_STATUS_CODE
)
756 // BNF from section 4.2 of RFC 2616:
758 // message-header = field-name ":" [ field-value ]
759 // field-name = token
760 // field-value = *( field-content | LWS )
761 // field-content = <the OCTETs making up the field-value
762 // and consisting of either *TEXT or combinations
763 // of token, separators, and quoted-string>
766 HttpUtil::HeadersIterator::HeadersIterator(
767 std::string::const_iterator headers_begin
,
768 std::string::const_iterator headers_end
,
769 const std::string
& line_delimiter
)
770 : lines_(headers_begin
, headers_end
, line_delimiter
) {
773 HttpUtil::HeadersIterator::~HeadersIterator() {
776 bool HttpUtil::HeadersIterator::GetNext() {
777 while (lines_
.GetNext()) {
778 name_begin_
= lines_
.token_begin();
779 values_end_
= lines_
.token_end();
781 std::string::const_iterator
colon(std::find(name_begin_
, values_end_
, ':'));
782 if (colon
== values_end_
)
783 continue; // skip malformed header
787 // If the name starts with LWS, it is an invalid line.
788 // Leading LWS implies a line continuation, and these should have
789 // already been joined by AssembleRawHeaders().
790 if (name_begin_
== name_end_
|| IsLWS(*name_begin_
))
793 TrimLWS(&name_begin_
, &name_end_
);
794 if (name_begin_
== name_end_
)
795 continue; // skip malformed header
797 values_begin_
= colon
+ 1;
798 TrimLWS(&values_begin_
, &values_end_
);
800 // if we got a header name, then we are done.
806 bool HttpUtil::HeadersIterator::AdvanceTo(const char* name
) {
807 DCHECK(name
!= NULL
);
808 DCHECK_EQ(0, base::StringToLowerASCII
<std::string
>(name
).compare(name
))
809 << "the header name must be in all lower case";
812 if (LowerCaseEqualsASCII(name_begin_
, name_end_
, name
)) {
820 HttpUtil::ValuesIterator::ValuesIterator(
821 std::string::const_iterator values_begin
,
822 std::string::const_iterator values_end
,
824 : values_(values_begin
, values_end
, std::string(1, delimiter
)) {
825 values_
.set_quote_chars("\'\"");
828 HttpUtil::ValuesIterator::~ValuesIterator() {
831 bool HttpUtil::ValuesIterator::GetNext() {
832 while (values_
.GetNext()) {
833 value_begin_
= values_
.token_begin();
834 value_end_
= values_
.token_end();
835 TrimLWS(&value_begin_
, &value_end_
);
837 // bypass empty values.
838 if (value_begin_
!= value_end_
)
844 HttpUtil::NameValuePairsIterator::NameValuePairsIterator(
845 std::string::const_iterator begin
,
846 std::string::const_iterator end
,
848 : props_(begin
, end
, delimiter
),
854 value_is_quoted_(false) {
857 HttpUtil::NameValuePairsIterator::~NameValuePairsIterator() {}
859 // We expect properties to be formatted as one of:
866 // Due to buggy implementations found in some embedded devices, we also
867 // accept values with missing close quotemark (http://crbug.com/39836):
869 bool HttpUtil::NameValuePairsIterator::GetNext() {
870 if (!props_
.GetNext())
873 // Set the value as everything. Next we will split out the name.
874 value_begin_
= props_
.value_begin();
875 value_end_
= props_
.value_end();
876 name_begin_
= name_end_
= value_end_
;
878 // Scan for the equals sign.
879 std::string::const_iterator equals
= std::find(value_begin_
, value_end_
, '=');
880 if (equals
== value_end_
|| equals
== value_begin_
)
881 return valid_
= false; // Malformed, no equals sign
883 // Verify that the equals sign we found wasn't inside of quote marks.
884 for (std::string::const_iterator it
= value_begin_
; it
!= equals
; ++it
) {
885 if (HttpUtil::IsQuote(*it
))
886 return valid_
= false; // Malformed, quote appears before equals sign
889 name_begin_
= value_begin_
;
891 value_begin_
= equals
+ 1;
893 TrimLWS(&name_begin_
, &name_end_
);
894 TrimLWS(&value_begin_
, &value_end_
);
895 value_is_quoted_
= false;
896 unquoted_value_
.clear();
898 if (value_begin_
== value_end_
)
899 return valid_
= false; // Malformed, value is empty
901 if (HttpUtil::IsQuote(*value_begin_
)) {
902 // Trim surrounding quotemarks off the value
903 if (*value_begin_
!= *(value_end_
- 1) || value_begin_
+ 1 == value_end_
) {
904 // NOTE: This is not as graceful as it sounds:
905 // * quoted-pairs will no longer be unquoted
906 // (["\"hello] should give ["hello]).
907 // * Does not detect when the final quote is escaped
908 // (["value\"] should give [value"])
909 ++value_begin_
; // Gracefully recover from mismatching quotes.
911 value_is_quoted_
= true;
912 // Do not store iterators into this. See declaration of unquoted_value_.
913 unquoted_value_
= HttpUtil::Unquote(value_begin_
, value_end_
);