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 #ifndef NET_HTTP_HTTP_STREAM_PARSER_H_
6 #define NET_HTTP_HTTP_STREAM_PARSER_H_
10 #include "base/basictypes.h"
11 #include "base/memory/ref_counted.h"
12 #include "base/memory/scoped_ptr.h"
13 #include "base/memory/weak_ptr.h"
14 #include "base/strings/string_piece.h"
15 #include "net/base/completion_callback.h"
16 #include "net/base/net_export.h"
17 #include "net/base/net_log.h"
18 #include "net/base/upload_progress.h"
22 class ClientSocketHandle;
23 class DrainableIOBuffer;
24 class GrowableIOBuffer;
25 class HttpChunkedDecoder;
26 struct HttpRequestInfo;
27 class HttpRequestHeaders;
28 class HttpResponseInfo;
30 class IOBufferWithSize;
31 class SSLCertRequestInfo;
33 class UploadDataStream;
35 class NET_EXPORT_PRIVATE HttpStreamParser {
37 // Any data in |read_buffer| will be used before reading from the socket
38 // and any data left over after parsing the stream will be put into
39 // |read_buffer|. The left over data will start at offset 0 and the
40 // buffer's offset will be set to the first free byte. |read_buffer| may
41 // have its capacity changed.
42 HttpStreamParser(ClientSocketHandle* connection,
43 const HttpRequestInfo* request,
44 GrowableIOBuffer* read_buffer,
45 const BoundNetLog& net_log);
46 virtual ~HttpStreamParser();
48 // These functions implement the interface described in HttpStream with
49 // some additional functionality
50 int SendRequest(const std::string& request_line,
51 const HttpRequestHeaders& headers,
52 HttpResponseInfo* response,
53 const CompletionCallback& callback);
55 int ReadResponseHeaders(const CompletionCallback& callback);
57 int ReadResponseBody(IOBuffer* buf, int buf_len,
58 const CompletionCallback& callback);
60 void Close(bool not_reusable);
62 // Returns the progress of uploading. When data is chunked, size is set to
63 // zero, but position will not be.
64 UploadProgress GetUploadProgress() const;
66 HttpResponseInfo* GetResponseInfo();
68 bool IsResponseBodyComplete() const;
70 bool CanFindEndOfResponse() const;
72 bool IsMoreDataBuffered() const;
74 bool IsConnectionReused() const;
76 void SetConnectionReused();
78 bool IsConnectionReusable() const;
80 void GetSSLInfo(SSLInfo* ssl_info);
82 void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info);
84 // Encodes the given |payload| in the chunked format to |output|.
85 // Returns the number of bytes written to |output|. |output_size| should
86 // be large enough to store the encoded chunk, which is payload.size() +
87 // kChunkHeaderFooterSize. Returns ERR_INVALID_ARGUMENT if |output_size|
88 // is not large enough.
90 // The output will look like: "HEX\r\n[payload]\r\n"
91 // where HEX is a length in hexdecimal (without the "0x" prefix).
92 static int EncodeChunk(const base::StringPiece& payload,
96 // Returns true if request headers and body should be merged (i.e. the
97 // sum is small enough and the body is in memory, and not chunked).
98 static bool ShouldMergeRequestHeadersAndBody(
99 const std::string& request_headers,
100 const UploadDataStream* request_body);
102 // The number of extra bytes required to encode a chunk.
103 static const size_t kChunkHeaderFooterSize;
106 class SeekableIOBuffer;
108 // FOO_COMPLETE states implement the second half of potentially asynchronous
109 // operations and don't necessarily mean that FOO is complete.
112 STATE_SENDING_HEADERS,
113 // If the request comes with a body, either of the following two
114 // states will be executed, depending on whether the body is chunked
117 STATE_SEND_REQUEST_READING_BODY,
120 STATE_READ_HEADERS_COMPLETE,
123 STATE_READ_BODY_COMPLETE,
127 // The number of bytes by which the header buffer is grown when it reaches
129 static const int kHeaderBufInitialSize = 4 * 1024; // 4K
131 // |kMaxHeaderBufSize| is the number of bytes that the response headers can
132 // grow to. If the body start is not found within this range of the
133 // response, the transaction will fail with ERR_RESPONSE_HEADERS_TOO_BIG.
134 // Note: |kMaxHeaderBufSize| should be a multiple of |kHeaderBufInitialSize|.
135 static const int kMaxHeaderBufSize = kHeaderBufInitialSize * 64; // 256K
137 // The maximum sane buffer size.
138 static const int kMaxBufSize = 2 * 1024 * 1024; // 2M
141 void OnIOComplete(int result);
143 // Try to make progress sending/receiving the request/response.
144 int DoLoop(int result);
146 // The implementations of each state of the state machine.
147 int DoSendHeaders(int result);
148 int DoSendBody(int result);
149 int DoSendRequestReadingBody(int result);
151 int DoReadHeadersComplete(int result);
153 int DoReadBodyComplete(int result);
155 // Examines |read_buf_| to find the start and end of the headers. If they are
156 // found, parse them with DoParseResponseHeaders(). Return the offset for
157 // the end of the headers, or -1 if the complete headers were not found, or
158 // with a net::Error if we encountered an error during parsing.
159 int ParseResponseHeaders();
161 // Parse the headers into response_. Returns OK on success or a net::Error on
163 int DoParseResponseHeaders(int end_of_header_offset);
165 // Examine the parsed headers to try to determine the response body size.
166 void CalculateResponseBodySize();
168 // Current state of the request.
171 // The request to send.
172 const HttpRequestInfo* request_;
174 // The request header data.
175 scoped_refptr<DrainableIOBuffer> request_headers_;
177 // Temporary buffer for reading.
178 scoped_refptr<GrowableIOBuffer> read_buf_;
180 // Offset of the first unused byte in |read_buf_|. May be nonzero due to
181 // body data in the same packet as header data but is zero when reading
183 int read_buf_unused_offset_;
185 // The amount beyond |read_buf_unused_offset_| where the status line starts;
186 // -1 if not found yet.
187 int response_header_start_offset_;
189 // The parsed response headers. Owned by the caller.
190 HttpResponseInfo* response_;
192 // Indicates the content length. If this value is less than zero
193 // (and chunked_decoder_ is null), then we must read until the server
194 // closes the connection.
195 int64 response_body_length_;
197 // Keep track of the number of response body bytes read so far.
198 int64 response_body_read_;
200 // Helper if the data is chunked.
201 scoped_ptr<HttpChunkedDecoder> chunked_decoder_;
203 // Where the caller wants the body data.
204 scoped_refptr<IOBuffer> user_read_buf_;
205 int user_read_buf_len_;
207 // The callback to notify a user that their request or response is
208 // complete or there was an error
209 CompletionCallback callback_;
211 // In the client callback, the client can do anything, including
212 // destroying this class, so any pending callback must be issued
213 // after everything else is done. When it is time to issue the client
214 // callback, move it from |callback_| to |scheduled_callback_|.
215 CompletionCallback scheduled_callback_;
217 // The underlying socket.
218 ClientSocketHandle* const connection_;
220 BoundNetLog net_log_;
222 // Callback to be used when doing IO.
223 CompletionCallback io_callback_;
225 // Buffer used to read the request body from UploadDataStream.
226 scoped_refptr<SeekableIOBuffer> request_body_read_buf_;
227 // Buffer used to send the request body. This points the same buffer as
228 // |request_body_read_buf_| unless the data is chunked.
229 scoped_refptr<SeekableIOBuffer> request_body_send_buf_;
230 bool sent_last_chunk_;
232 base::WeakPtrFactory<HttpStreamParser> weak_ptr_factory_;
234 DISALLOW_COPY_AND_ASSIGN(HttpStreamParser);
239 #endif // NET_HTTP_HTTP_STREAM_PARSER_H_