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. 4 5 #ifndef NET_HTTP_HTTP_STREAM_PARSER_H_ 6 #define NET_HTTP_HTTP_STREAM_PARSER_H_ 7 8 #include <string> 9 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" 19 20 namespace net { 21 22 class ClientSocketHandle; 23 class DrainableIOBuffer; 24 class GrowableIOBuffer; 25 class HttpChunkedDecoder; 26 struct HttpRequestInfo; 27 class HttpRequestHeaders; 28 class HttpResponseInfo; 29 class IOBuffer; 30 class IOBufferWithSize; 31 class SSLCertRequestInfo; 32 class SSLInfo; 33 class UploadDataStream; 34 35 class NET_EXPORT_PRIVATE HttpStreamParser { 36 public: 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(); 47 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); 54 55 int ReadResponseHeaders(const CompletionCallback& callback); 56 57 int ReadResponseBody(IOBuffer* buf, int buf_len, 58 const CompletionCallback& callback); 59 60 void Close(bool not_reusable); 61 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; 65 66 HttpResponseInfo* GetResponseInfo(); 67 68 bool IsResponseBodyComplete() const; 69 70 bool CanFindEndOfResponse() const; 71 72 bool IsMoreDataBuffered() const; 73 74 bool IsConnectionReused() const; 75 76 void SetConnectionReused(); 77 78 bool IsConnectionReusable() const; 79 80 void GetSSLInfo(SSLInfo* ssl_info); 81 82 void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info); 83 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. 89 // 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, 93 char* output, 94 size_t output_size); 95 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); 101 102 // The number of extra bytes required to encode a chunk. 103 static const size_t kChunkHeaderFooterSize; 104 105 private: 106 class SeekableIOBuffer; 107 108 // FOO_COMPLETE states implement the second half of potentially asynchronous 109 // operations and don't necessarily mean that FOO is complete. 110 enum State { 111 STATE_NONE, 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 115 // or not. 116 STATE_SENDING_BODY, 117 STATE_SEND_REQUEST_READING_BODY, 118 STATE_REQUEST_SENT, 119 STATE_READ_HEADERS, 120 STATE_READ_HEADERS_COMPLETE, 121 STATE_BODY_PENDING, 122 STATE_READ_BODY, 123 STATE_READ_BODY_COMPLETE, 124 STATE_DONE 125 }; 126 127 // The number of bytes by which the header buffer is grown when it reaches 128 // capacity. 129 static const int kHeaderBufInitialSize = 4 * 1024; // 4K 130 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 136 137 // The maximum sane buffer size. 138 static const int kMaxBufSize = 2 * 1024 * 1024; // 2M 139 140 // Handle callbacks. 141 void OnIOComplete(int result); 142 143 // Try to make progress sending/receiving the request/response. 144 int DoLoop(int result); 145 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); 150 int DoReadHeaders(); 151 int DoReadHeadersComplete(int result); 152 int DoReadBody(); 153 int DoReadBodyComplete(int result); 154 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(); 160 161 // Parse the headers into response_. Returns OK on success or a net::Error on 162 // failure. 163 int DoParseResponseHeaders(int end_of_header_offset); 164 165 // Examine the parsed headers to try to determine the response body size. 166 void CalculateResponseBodySize(); 167 168 // Current state of the request. 169 State io_state_; 170 171 // The request to send. 172 const HttpRequestInfo* request_; 173 174 // The request header data. 175 scoped_refptr<DrainableIOBuffer> request_headers_; 176 177 // Temporary buffer for reading. 178 scoped_refptr<GrowableIOBuffer> read_buf_; 179 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 182 // headers. 183 int read_buf_unused_offset_; 184 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_; 188 189 // The parsed response headers. Owned by the caller. 190 HttpResponseInfo* response_; 191 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_; 196 197 // Keep track of the number of response body bytes read so far. 198 int64 response_body_read_; 199 200 // Helper if the data is chunked. 201 scoped_ptr<HttpChunkedDecoder> chunked_decoder_; 202 203 // Where the caller wants the body data. 204 scoped_refptr<IOBuffer> user_read_buf_; 205 int user_read_buf_len_; 206 207 // The callback to notify a user that their request or response is 208 // complete or there was an error 209 CompletionCallback callback_; 210 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_; 216 217 // The underlying socket. 218 ClientSocketHandle* const connection_; 219 220 BoundNetLog net_log_; 221 222 // Callback to be used when doing IO. 223 CompletionCallback io_callback_; 224 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_; 231 232 base::WeakPtrFactory<HttpStreamParser> weak_ptr_factory_; 233 234 DISALLOW_COPY_AND_ASSIGN(HttpStreamParser); 235 }; 236 237 } // namespace net 238 239 #endif // NET_HTTP_HTTP_STREAM_PARSER_H_ 240