net/http/http_stream_parser.h

   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   int64 received_bytes() const { return received_bytes_; }
  81
  82   void GetSSLInfo(SSLInfo* ssl_info);
  83
  84   void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info);
  85
  86   // Encodes the given |payload| in the chunked format to |output|.
  87   // Returns the number of bytes written to |output|. |output_size| should
  88   // be large enough to store the encoded chunk, which is payload.size() +
  89   // kChunkHeaderFooterSize. Returns ERR_INVALID_ARGUMENT if |output_size|
  90   // is not large enough.
  91   //
  92   // The output will look like: "HEX\r\n[payload]\r\n"
  93   // where HEX is a length in hexdecimal (without the "0x" prefix).
  94   static int EncodeChunk(const base::StringPiece& payload,
  95                          char* output,
  96                          size_t output_size);
  97
  98   // Returns true if request headers and body should be merged (i.e. the
  99   // sum is small enough and the body is in memory, and not chunked).
 100   static bool ShouldMergeRequestHeadersAndBody(
 101       const std::string& request_headers,
 102       const UploadDataStream* request_body);
 103
 104   // The number of extra bytes required to encode a chunk.
 105   static const size_t kChunkHeaderFooterSize;
 106
 107  private:
 108   class SeekableIOBuffer;
 109
 110   // FOO_COMPLETE states implement the second half of potentially asynchronous
 111   // operations and don't necessarily mean that FOO is complete.
 112   enum State {
 113     // STATE_NONE indicates that this is waiting on an external call before
 114     // continuing.
 115     STATE_NONE,
 116     STATE_SEND_HEADERS,
 117     STATE_SEND_HEADERS_COMPLETE,
 118     STATE_SEND_BODY,
 119     STATE_SEND_BODY_COMPLETE,
 120     STATE_SEND_REQUEST_READ_BODY_COMPLETE,
 121     STATE_READ_HEADERS,
 122     STATE_READ_HEADERS_COMPLETE,
 123     STATE_READ_BODY,
 124     STATE_READ_BODY_COMPLETE,
 125     STATE_DONE
 126   };
 127
 128   // The number of bytes by which the header buffer is grown when it reaches
 129   // capacity.
 130   static const int kHeaderBufInitialSize = 4 * 1024;  // 4K
 131
 132   // |kMaxHeaderBufSize| is the number of bytes that the response headers can
 133   // grow to. If the body start is not found within this range of the
 134   // response, the transaction will fail with ERR_RESPONSE_HEADERS_TOO_BIG.
 135   // Note: |kMaxHeaderBufSize| should be a multiple of |kHeaderBufInitialSize|.
 136   static const int kMaxHeaderBufSize = kHeaderBufInitialSize * 64;  // 256K
 137
 138   // The maximum sane buffer size.
 139   static const int kMaxBufSize = 2 * 1024 * 1024;  // 2M
 140
 141   // Handle callbacks.
 142   void OnIOComplete(int result);
 143
 144   // Try to make progress sending/receiving the request/response.
 145   int DoLoop(int result);
 146
 147   // The implementations of each state of the state machine.
 148   int DoSendHeaders();
 149   int DoSendHeadersComplete(int result);
 150   int DoSendBody();
 151   int DoSendBodyComplete(int result);
 152   int DoSendRequestReadBodyComplete(int result);
 153   int DoReadHeaders();
 154   int DoReadHeadersComplete(int result);
 155   int DoReadBody();
 156   int DoReadBodyComplete(int result);
 157
 158   // This handles most of the logic for DoReadHeadersComplete.
 159   int HandleReadHeaderResult(int result);
 160
 161   // Examines |read_buf_| to find the start and end of the headers. If they are
 162   // found, parse them with DoParseResponseHeaders().  Return the offset for
 163   // the end of the headers, or -1 if the complete headers were not found, or
 164   // with a net::Error if we encountered an error during parsing.
 165   int ParseResponseHeaders();
 166
 167   // Parse the headers into response_.  Returns OK on success or a net::Error on
 168   // failure.
 169   int DoParseResponseHeaders(int end_of_header_offset);
 170
 171   // Examine the parsed headers to try to determine the response body size.
 172   void CalculateResponseBodySize();
 173
 174   // Next state of the request, when the current one completes.
 175   State io_state_;
 176
 177   // The request to send.
 178   const HttpRequestInfo* request_;
 179
 180   // The request header data.  May include a merged request body.
 181   scoped_refptr<DrainableIOBuffer> request_headers_;
 182
 183   // Size of just the request headers.  May be less than the length of
 184   // |request_headers_| if the body was merged with the headers.
 185   int request_headers_length_;
 186
 187   // Temporary buffer for reading.
 188   scoped_refptr<GrowableIOBuffer> read_buf_;
 189
 190   // Offset of the first unused byte in |read_buf_|.  May be nonzero due to
 191   // body data in the same packet as header data but is zero when reading
 192   // headers.
 193   int read_buf_unused_offset_;
 194
 195   // The amount beyond |read_buf_unused_offset_| where the status line starts;
 196   // -1 if not found yet.
 197   int response_header_start_offset_;
 198
 199   // The amount of received data.  If connection is reused then intermediate
 200   // value may be bigger than final.
 201   int64 received_bytes_;
 202
 203   // The parsed response headers.  Owned by the caller.
 204   HttpResponseInfo* response_;
 205
 206   // Indicates the content length.  If this value is less than zero
 207   // (and chunked_decoder_ is null), then we must read until the server
 208   // closes the connection.
 209   int64 response_body_length_;
 210
 211   // Keep track of the number of response body bytes read so far.
 212   int64 response_body_read_;
 213
 214   // Helper if the data is chunked.
 215   scoped_ptr<HttpChunkedDecoder> chunked_decoder_;
 216
 217   // Where the caller wants the body data.
 218   scoped_refptr<IOBuffer> user_read_buf_;
 219   int user_read_buf_len_;
 220
 221   // The callback to notify a user that their request or response is
 222   // complete or there was an error
 223   CompletionCallback callback_;
 224
 225   // In the client callback, the client can do anything, including
 226   // destroying this class, so any pending callback must be issued
 227   // after everything else is done.  When it is time to issue the client
 228   // callback, move it from |callback_| to |scheduled_callback_|.
 229   CompletionCallback scheduled_callback_;
 230
 231   // The underlying socket.
 232   ClientSocketHandle* const connection_;
 233
 234   BoundNetLog net_log_;
 235
 236   // Callback to be used when doing IO.
 237   CompletionCallback io_callback_;
 238
 239   // Buffer used to read the request body from UploadDataStream.
 240   scoped_refptr<SeekableIOBuffer> request_body_read_buf_;
 241   // Buffer used to send the request body. This points the same buffer as
 242   // |request_body_read_buf_| unless the data is chunked.
 243   scoped_refptr<SeekableIOBuffer> request_body_send_buf_;
 244   bool sent_last_chunk_;
 245
 246   // Error received when uploading the body, if any.
 247   int upload_error_;
 248
 249   base::WeakPtrFactory<HttpStreamParser> weak_ptr_factory_;
 250
 251   DISALLOW_COPY_AND_ASSIGN(HttpStreamParser);
 252 };
 253
 254 }  // namespace net
 255
 256 #endif  // NET_HTTP_HTTP_STREAM_PARSER_H_