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   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   // a 1xx header, or body data in the same packet as header data.
 182   int read_buf_unused_offset_;
 183
 184   // The amount beyond |read_buf_unused_offset_| where the status line starts;
 185   // -1 if not found yet.
 186   int response_header_start_offset_;
 187
 188   // The parsed response headers.  Owned by the caller.
 189   HttpResponseInfo* response_;
 190
 191   // Indicates the content length.  If this value is less than zero
 192   // (and chunked_decoder_ is null), then we must read until the server
 193   // closes the connection.
 194   int64 response_body_length_;
 195
 196   // Keep track of the number of response body bytes read so far.
 197   int64 response_body_read_;
 198
 199   // Helper if the data is chunked.
 200   scoped_ptr<HttpChunkedDecoder> chunked_decoder_;
 201
 202   // Where the caller wants the body data.
 203   scoped_refptr<IOBuffer> user_read_buf_;
 204   int user_read_buf_len_;
 205
 206   // The callback to notify a user that their request or response is
 207   // complete or there was an error
 208   CompletionCallback callback_;
 209
 210   // In the client callback, the client can do anything, including
 211   // destroying this class, so any pending callback must be issued
 212   // after everything else is done.  When it is time to issue the client
 213   // callback, move it from |callback_| to |scheduled_callback_|.
 214   CompletionCallback scheduled_callback_;
 215
 216   // The underlying socket.
 217   ClientSocketHandle* const connection_;
 218
 219   BoundNetLog net_log_;
 220
 221   // Callback to be used when doing IO.
 222   CompletionCallback io_callback_;
 223
 224   // Buffer used to read the request body from UploadDataStream.
 225   scoped_refptr<SeekableIOBuffer> request_body_read_buf_;
 226   // Buffer used to send the request body. This points the same buffer as
 227   // |request_body_read_buf_| unless the data is chunked.
 228   scoped_refptr<SeekableIOBuffer> request_body_send_buf_;
 229   bool sent_last_chunk_;
 230
 231   base::WeakPtrFactory<HttpStreamParser> weak_ptr_factory_;
 232
 233   DISALLOW_COPY_AND_ASSIGN(HttpStreamParser);
 234 };
 235
 236 }  // namespace net
 237
 238 #endif  // NET_HTTP_HTTP_STREAM_PARSER_H_