blob: 8e011f8d9304bc45e2f7aefe0ea6751887623fab [file] [log] [blame]
[email protected]d807bf92009-04-22 20:38:071// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
license.botbf09a502008-08-24 00:55:552// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commit586acc5fe2008-07-26 22:42:524
[email protected]e2a23092009-03-17 15:35:185#ifndef NET_HTTP_HTTP_RESPONSE_HEADERS_H_
6#define NET_HTTP_HTTP_RESPONSE_HEADERS_H_
[email protected]32b76ef2010-07-26 23:08:247#pragma once
initial.commit586acc5fe2008-07-26 22:42:528
initial.commit586acc5fe2008-07-26 22:42:529#include <string>
10#include <vector>
11
12#include "base/basictypes.h"
[email protected]8a2a25f2008-08-19 23:06:0513#include "base/hash_tables.h"
initial.commit586acc5fe2008-07-26 22:42:5214#include "base/ref_counted.h"
[email protected]231d5a32008-09-13 00:45:2715#include "net/http/http_version.h"
initial.commit586acc5fe2008-07-26 22:42:5216
17class Pickle;
[email protected]e1acf6f2008-10-27 20:43:3318
19namespace base {
initial.commit586acc5fe2008-07-26 22:42:5220class Time;
21class TimeDelta;
[email protected]e1acf6f2008-10-27 20:43:3322}
initial.commit586acc5fe2008-07-26 22:42:5223
24namespace net {
25
26// HttpResponseHeaders: parses and holds HTTP response headers.
[email protected]7eab0d2262009-10-14 22:05:5427class HttpResponseHeaders
28 : public base::RefCountedThreadSafe<HttpResponseHeaders> {
initial.commit586acc5fe2008-07-26 22:42:5229 public:
30 // Parses the given raw_headers. raw_headers should be formatted thus:
31 // includes the http status response line, each line is \0-terminated, and
32 // it's terminated by an empty line (ie, 2 \0s in a row).
[email protected]036d8772008-09-06 01:00:5333 // (Note that line continuations should have already been joined;
34 // see HttpUtil::AssembleRawHeaders)
initial.commit586acc5fe2008-07-26 22:42:5235 //
36 // NOTE: For now, raw_headers is not really 'raw' in that this constructor is
37 // called with a 'NativeMB' string on Windows because WinHTTP does not allow
38 // us to access the raw byte sequence as sent by a web server. In any case,
39 // HttpResponseHeaders does not perform any encoding changes on the input.
40 //
41 explicit HttpResponseHeaders(const std::string& raw_headers);
42
43 // Initializes from the representation stored in the given pickle. The data
44 // for this object is found relative to the given pickle_iter, which should
45 // be passed to the pickle's various Read* methods.
46 HttpResponseHeaders(const Pickle& pickle, void** pickle_iter);
47
[email protected]cd5b9a732008-11-20 08:14:3948 // Persist options.
49 typedef int PersistOptions;
50 static const PersistOptions PERSIST_RAW = -1; // Raw, unparsed headers.
51 static const PersistOptions PERSIST_ALL = 0; // Parsed headers.
52 static const PersistOptions PERSIST_SANS_COOKIES = 1 << 0;
53 static const PersistOptions PERSIST_SANS_CHALLENGES = 1 << 1;
54 static const PersistOptions PERSIST_SANS_HOP_BY_HOP = 1 << 2;
55 static const PersistOptions PERSIST_SANS_NON_CACHEABLE = 1 << 3;
[email protected]8bf26f49a2009-06-12 17:35:5056 static const PersistOptions PERSIST_SANS_RANGES = 1 << 4;
[email protected]cd5b9a732008-11-20 08:14:3957
58 // Appends a representation of this object to the given pickle.
59 // The options argument can be a combination of PersistOptions.
60 void Persist(Pickle* pickle, PersistOptions options);
initial.commit586acc5fe2008-07-26 22:42:5261
62 // Performs header merging as described in 13.5.3 of RFC 2616.
63 void Update(const HttpResponseHeaders& new_headers);
64
[email protected]95792eb12009-06-22 21:30:4065 // Removes all instances of a particular header.
66 void RemoveHeader(const std::string& name);
67
68 // Adds a particular header. |header| has to be a single header without any
69 // EOL termination, just [<header-name>: <header-values>]
70 // If a header with the same name is already stored, the two headers are not
71 // merged together by this method; the one provided is simply put at the
72 // end of the list.
73 void AddHeader(const std::string& header);
74
[email protected]44f873a62009-08-12 00:14:4875 // Replaces the current status line with the provided one (|new_status| should
76 // not have any EOL).
77 void ReplaceStatusLine(const std::string& new_status);
78
initial.commit586acc5fe2008-07-26 22:42:5279 // Creates a normalized header string. The output will be formatted exactly
80 // like so:
81 // HTTP/<version> <status_code> <status_text>\n
82 // [<header-name>: <header-values>\n]*
83 // meaning, each line is \n-terminated, and there is no extra whitespace
84 // beyond the single space separators shown (of course, values can contain
85 // whitespace within them). If a given header-name appears more than once
86 // in the set of headers, they are combined into a single line like so:
87 // <header-name>: <header-value1>, <header-value2>, ...<header-valueN>\n
88 //
89 // DANGER: For some headers (e.g., "Set-Cookie"), the normalized form can be
90 // a lossy format. This is due to the fact that some servers generate
91 // Set-Cookie headers that contain unquoted commas (usually as part of the
92 // value of an "expires" attribute). So, use this function with caution. Do
93 // not expect to be able to re-parse Set-Cookie headers from this output.
94 //
95 // NOTE: Do not make any assumptions about the encoding of this output
96 // string. It may be non-ASCII, and the encoding used by the server is not
97 // necessarily known to us. Do not assume that this output is UTF-8!
98 //
99 // TODO(darin): remove this method
100 //
101 void GetNormalizedHeaders(std::string* output) const;
102
[email protected]aef04272010-06-28 18:03:04103 // Gets the raw stored headers, in human-readable form.
104 void GetRawHeaders(std::string* output) const;
105
initial.commit586acc5fe2008-07-26 22:42:52106 // Fetch the "normalized" value of a single header, where all values for the
107 // header name are separated by commas. See the GetNormalizedHeaders for
108 // format details. Returns false if this header wasn't found.
109 //
110 // NOTE: Do not make any assumptions about the encoding of this output
111 // string. It may be non-ASCII, and the encoding used by the server is not
112 // necessarily known to us. Do not assume that this output is UTF-8!
113 //
114 // TODO(darin): remove this method
115 //
116 bool GetNormalizedHeader(const std::string& name, std::string* value) const;
117
118 // Returns the normalized status line. For HTTP/0.9 responses (i.e.,
119 // responses that lack a status line), this is the manufactured string
120 // "HTTP/0.9 200 OK".
121 std::string GetStatusLine() const;
122
[email protected]231d5a32008-09-13 00:45:27123 // Get the HTTP version of the normalized status line.
124 HttpVersion GetHttpVersion() const {
125 return http_version_;
126 }
127
128 // Get the HTTP version determined while parsing; or (0,0) if parsing failed
129 HttpVersion GetParsedHttpVersion() const {
130 return parsed_http_version_;
131 }
132
133 // Get the HTTP status text of the normalized status line.
134 std::string GetStatusText() const;
135
initial.commit586acc5fe2008-07-26 22:42:52136 // Enumerate the "lines" of the response headers. This skips over the status
137 // line. Use GetStatusLine if you are interested in that. Note that this
138 // method returns the un-coalesced response header lines, so if a response
139 // header appears on multiple lines, then it will appear multiple times in
140 // this enumeration (in the order the header lines were received from the
141 // server). Initialize a 'void*' variable to NULL and pass it by address to
142 // EnumerateHeaderLines. Call EnumerateHeaderLines repeatedly until it
143 // returns false. The out-params 'name' and 'value' are set upon success.
144 bool EnumerateHeaderLines(void** iter,
145 std::string* name,
146 std::string* value) const;
147
148 // Enumerate the values of the specified header. If you are only interested
149 // in the first header, then you can pass NULL for the 'iter' parameter.
150 // Otherwise, to iterate across all values for the specified header,
151 // initialize a 'void*' variable to NULL and pass it by address to
152 // EnumerateHeader. Call EnumerateHeader repeatedly until it returns false.
153 bool EnumerateHeader(void** iter,
154 const std::string& name,
155 std::string* value) const;
156
157 // Returns true if the response contains the specified header-value pair.
158 // Both name and value are compared case insensitively.
159 bool HasHeaderValue(const std::string& name, const std::string& value) const;
160
[email protected]3f662f12010-03-25 19:56:12161 // Returns true if the response contains the specified header.
162 // The name is compared case insensitively.
163 bool HasHeader(const std::string& name) const;
164
initial.commit586acc5fe2008-07-26 22:42:52165 // Get the mime type and charset values in lower case form from the headers.
166 // Empty strings are returned if the values are not present.
167 void GetMimeTypeAndCharset(std::string* mime_type,
168 std::string* charset) const;
169
170 // Get the mime type in lower case from the headers. If there's no mime
171 // type, returns false.
172 bool GetMimeType(std::string* mime_type) const;
173
174 // Get the charset in lower case from the headers. If there's no charset,
175 // returns false.
176 bool GetCharset(std::string* charset) const;
177
178 // Returns true if this response corresponds to a redirect. The target
179 // location of the redirect is optionally returned if location is non-null.
180 bool IsRedirect(std::string* location) const;
181
[email protected]86de13d2009-11-24 01:21:35182 // Returns true if the HTTP response code passed in corresponds to a
183 // redirect.
184 static bool IsRedirectResponseCode(int response_code);
185
initial.commit586acc5fe2008-07-26 22:42:52186 // Returns true if the response cannot be reused without validation. The
187 // result is relative to the current_time parameter, which is a parameter to
188 // support unit testing. The request_time parameter indicates the time at
189 // which the request was made that resulted in this response, which was
190 // received at response_time.
[email protected]e1acf6f2008-10-27 20:43:33191 bool RequiresValidation(const base::Time& request_time,
192 const base::Time& response_time,
193 const base::Time& current_time) const;
initial.commit586acc5fe2008-07-26 22:42:52194
195 // Returns the amount of time the server claims the response is fresh from
196 // the time the response was generated. See section 13.2.4 of RFC 2616. See
197 // RequiresValidation for a description of the response_time parameter.
[email protected]e1acf6f2008-10-27 20:43:33198 base::TimeDelta GetFreshnessLifetime(const base::Time& response_time) const;
initial.commit586acc5fe2008-07-26 22:42:52199
200 // Returns the age of the response. See section 13.2.3 of RFC 2616.
201 // See RequiresValidation for a description of this method's parameters.
[email protected]e1acf6f2008-10-27 20:43:33202 base::TimeDelta GetCurrentAge(const base::Time& request_time,
203 const base::Time& response_time,
204 const base::Time& current_time) const;
initial.commit586acc5fe2008-07-26 22:42:52205
206 // The following methods extract values from the response headers. If a
207 // value is not present, then false is returned. Otherwise, true is returned
208 // and the out param is assigned to the corresponding value.
[email protected]e1acf6f2008-10-27 20:43:33209 bool GetMaxAgeValue(base::TimeDelta* value) const;
210 bool GetAgeValue(base::TimeDelta* value) const;
211 bool GetDateValue(base::Time* value) const;
212 bool GetLastModifiedValue(base::Time* value) const;
213 bool GetExpiresValue(base::Time* value) const;
initial.commit586acc5fe2008-07-26 22:42:52214
215 // Extracts the time value of a particular header. This method looks for the
216 // first matching header value and parses its value as a HTTP-date.
[email protected]e1acf6f2008-10-27 20:43:33217 bool GetTimeValuedHeader(const std::string& name, base::Time* result) const;
initial.commit586acc5fe2008-07-26 22:42:52218
219 // Determines if this response indicates a keep-alive connection.
220 bool IsKeepAlive() const;
221
[email protected]dbd39fb2010-01-08 01:13:36222 // Returns true if this response has a strong etag or last-modified header.
223 // See section 13.3.3 of RFC 2616.
224 bool HasStrongValidators() const;
225
initial.commit586acc5fe2008-07-26 22:42:52226 // Extracts the value of the Content-Length header or returns -1 if there is
227 // no such header in the response.
228 int64 GetContentLength() const;
229
[email protected]7eab0d2262009-10-14 22:05:54230 // Extracts the values in a Content-Range header and returns true if they are
231 // valid for a 206 response; otherwise returns false.
[email protected]d807bf92009-04-22 20:38:07232 // The following values will be outputted:
233 // |*first_byte_position| = inclusive position of the first byte of the range
234 // |*last_byte_position| = inclusive position of the last byte of the range
235 // |*instance_length| = size in bytes of the object requested
236 // If any of the above values is unknown, its value will be -1.
237 bool GetContentRange(int64* first_byte_position,
238 int64* last_byte_position,
239 int64* instance_length) const;
240
initial.commit586acc5fe2008-07-26 22:42:52241 // Returns the HTTP response code. This is 0 if the response code text seems
242 // to exist but could not be parsed. Otherwise, it defaults to 200 if the
243 // response code is not found in the raw headers.
244 int response_code() const { return response_code_; }
245
246 // Returns the raw header string.
247 const std::string& raw_headers() const { return raw_headers_; }
248
249 private:
[email protected]8a2a25f2008-08-19 23:06:05250 friend class base::RefCountedThreadSafe<HttpResponseHeaders>;
initial.commit586acc5fe2008-07-26 22:42:52251
[email protected]95792eb12009-06-22 21:30:40252 typedef base::hash_set<std::string> HeaderSet;
253
[email protected]9349cfb2010-08-31 18:00:53254 HttpResponseHeaders();
255 ~HttpResponseHeaders();
initial.commit586acc5fe2008-07-26 22:42:52256
257 // Initializes from the given raw headers.
258 void Parse(const std::string& raw_input);
259
260 // Helper function for ParseStatusLine.
261 // Tries to extract the "HTTP/X.Y" from a status line formatted like:
262 // HTTP/1.1 200 OK
263 // with line_begin and end pointing at the begin and end of this line. If the
[email protected]231d5a32008-09-13 00:45:27264 // status line is malformed, returns HttpVersion(0,0).
265 static HttpVersion ParseVersion(std::string::const_iterator line_begin,
266 std::string::const_iterator line_end);
initial.commit586acc5fe2008-07-26 22:42:52267
268 // Tries to extract the status line from a header block, given the first
[email protected]72d1e592009-03-10 17:39:46269 // line of said header block. If the status line is malformed, we'll
270 // construct a valid one. Example input:
initial.commit586acc5fe2008-07-26 22:42:52271 // HTTP/1.1 200 OK
272 // with line_begin and end pointing at the begin and end of this line.
273 // Output will be a normalized version of this, with a trailing \n.
274 void ParseStatusLine(std::string::const_iterator line_begin,
[email protected]231d5a32008-09-13 00:45:27275 std::string::const_iterator line_end,
276 bool has_headers);
initial.commit586acc5fe2008-07-26 22:42:52277
initial.commit586acc5fe2008-07-26 22:42:52278 // Find the header in our list (case-insensitive) starting with parsed_ at
279 // index |from|. Returns string::npos if not found.
280 size_t FindHeader(size_t from, const std::string& name) const;
281
[email protected]79867b592008-08-21 21:23:52282 // Add a header->value pair to our list. If we already have header in our
283 // list, append the value to it.
initial.commit586acc5fe2008-07-26 22:42:52284 void AddHeader(std::string::const_iterator name_begin,
285 std::string::const_iterator name_end,
286 std::string::const_iterator value_begin,
287 std::string::const_iterator value_end);
288
289 // Add to parsed_ given the fields of a ParsedHeader object.
290 void AddToParsed(std::string::const_iterator name_begin,
291 std::string::const_iterator name_end,
292 std::string::const_iterator value_begin,
293 std::string::const_iterator value_end);
294
[email protected]95792eb12009-06-22 21:30:40295 // Replaces the current headers with the merged version of |raw_headers| and
296 // the current headers without the headers in |headers_to_remove|. Note that
297 // |headers_to_remove| are removed from the current headers (before the
298 // merge), not after the merge.
299 void MergeWithHeaders(const std::string& raw_headers,
300 const HeaderSet& headers_to_remove);
initial.commit586acc5fe2008-07-26 22:42:52301
[email protected]cd5b9a732008-11-20 08:14:39302 // Adds the values from any 'cache-control: no-cache="foo,bar"' headers.
303 void AddNonCacheableHeaders(HeaderSet* header_names) const;
304
305 // Adds the set of header names that contain cookie values.
306 static void AddSensitiveHeaders(HeaderSet* header_names);
307
308 // Adds the set of rfc2616 hop-by-hop response headers.
309 static void AddHopByHopHeaders(HeaderSet* header_names);
310
311 // Adds the set of challenge response headers.
312 static void AddChallengeHeaders(HeaderSet* header_names);
313
314 // Adds the set of cookie response headers.
315 static void AddCookieHeaders(HeaderSet* header_names);
initial.commit586acc5fe2008-07-26 22:42:52316
[email protected]8bf26f49a2009-06-12 17:35:50317 // Adds the set of content range response headers.
318 static void AddHopContentRangeHeaders(HeaderSet* header_names);
319
initial.commit586acc5fe2008-07-26 22:42:52320 // The members of this structure point into raw_headers_.
321 struct ParsedHeader {
322 std::string::const_iterator name_begin;
323 std::string::const_iterator name_end;
324 std::string::const_iterator value_begin;
325 std::string::const_iterator value_end;
326
327 // A header "continuation" contains only a subsequent value for the
328 // preceding header. (Header values are comma separated.)
329 bool is_continuation() const { return name_begin == name_end; }
330 };
331 typedef std::vector<ParsedHeader> HeaderList;
332
333 // We keep a list of ParsedHeader objects. These tell us where to locate the
334 // header-value pairs within raw_headers_.
335 HeaderList parsed_;
336
337 // The raw_headers_ consists of the normalized status line (terminated with a
338 // null byte) and then followed by the raw null-terminated headers from the
[email protected]036d8772008-09-06 01:00:53339 // input that was passed to our constructor. We preserve the input [*] to
initial.commit586acc5fe2008-07-26 22:42:52340 // maintain as much ancillary fidelity as possible (since it is sometimes
341 // hard to tell what may matter down-stream to a consumer of XMLHttpRequest).
[email protected]036d8772008-09-06 01:00:53342 // [*] The status line may be modified.
initial.commit586acc5fe2008-07-26 22:42:52343 std::string raw_headers_;
344
345 // This is the parsed HTTP response code.
346 int response_code_;
347
[email protected]231d5a32008-09-13 00:45:27348 // The normalized http version (consistent with what GetStatusLine() returns).
349 HttpVersion http_version_;
350
351 // The parsed http version number (not normalized).
352 HttpVersion parsed_http_version_;
353
[email protected]8a2a25f2008-08-19 23:06:05354 DISALLOW_COPY_AND_ASSIGN(HttpResponseHeaders);
initial.commit586acc5fe2008-07-26 22:42:52355};
356
357} // namespace net
358
[email protected]e2a23092009-03-17 15:35:18359#endif // NET_HTTP_HTTP_RESPONSE_HEADERS_H_