Home | History | Annotate | Download | only in http 
      1 // Copyright (c) 2009 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 "net/base/io_buffer.h"
     12 #include "net/base/load_log.h"
     13 #include "net/base/upload_data_stream.h"
     14 #include "net/http/http_chunked_decoder.h"
     15 #include "net/http/http_response_info.h"
     16 #include "net/socket/client_socket_handle.h"
     17 
     18 namespace net {
     19 
     20 class ClientSocketHandle;
     21 class HttpRequestInfo;
     22 
     23 class HttpStreamParser {
     24  public:
     25   // Any data in |read_buffer| will be used before reading from the socket
     26   // and any data left over after parsing the stream will be put into
     27   // |read_buffer|.  The left over data will start at offset 0 and the
     28   // buffer's offset will be set to the first free byte. |read_buffer| may
     29   // have its capacity changed.
     30   HttpStreamParser(ClientSocketHandle* connection,
     31                    GrowableIOBuffer* read_buffer,
     32                    LoadLog* load_log);
     33   ~HttpStreamParser() {}
     34 
     35   // These functions implement the interface described in HttpStream with
     36   // some additional functionality
     37   int SendRequest(const HttpRequestInfo* request, const std::string& headers,
     38                   UploadDataStream* request_body, HttpResponseInfo* response,
     39                   CompletionCallback* callback);
     40 
     41   int ReadResponseHeaders(CompletionCallback* callback);
     42 
     43   int ReadResponseBody(IOBuffer* buf, int buf_len,
     44                        CompletionCallback* callback);
     45 
     46   uint64 GetUploadProgress() const;
     47 
     48   HttpResponseInfo* GetResponseInfo();
     49 
     50   bool IsResponseBodyComplete() const;
     51 
     52   bool CanFindEndOfResponse() const;
     53 
     54   bool IsMoreDataBuffered() const;
     55 
     56  private:
     57   // FOO_COMPLETE states implement the second half of potentially asynchronous
     58   // operations and don't necessarily mean that FOO is complete.
     59   enum State {
     60     STATE_NONE,
     61     STATE_SENDING_HEADERS,
     62     STATE_SENDING_BODY,
     63     STATE_REQUEST_SENT,
     64     STATE_READ_HEADERS,
     65     STATE_READ_HEADERS_COMPLETE,
     66     STATE_BODY_PENDING,
     67     STATE_READ_BODY,
     68     STATE_READ_BODY_COMPLETE,
     69     STATE_DONE
     70   };
     71 
     72   // The number of bytes by which the header buffer is grown when it reaches
     73   // capacity.
     74   enum { kHeaderBufInitialSize = 4096 };
     75 
     76   // |kMaxHeaderBufSize| is the number of bytes that the response headers can
     77   // grow to. If the body start is not found within this range of the
     78   // response, the transaction will fail with ERR_RESPONSE_HEADERS_TOO_BIG.
     79   // Note: |kMaxHeaderBufSize| should be a multiple of |kHeaderBufInitialSize|.
     80   enum { kMaxHeaderBufSize = 256 * 1024 };  // 256 kilobytes.
     81 
     82   // The maximum sane buffer size.
     83   enum { kMaxBufSize = 2 * 1024 * 1024 };  // 2 megabytes.
     84 
     85   // Handle callbacks.
     86   void OnIOComplete(int result);
     87 
     88   // Try to make progress sending/receiving the request/response.
     89   int DoLoop(int result);
     90 
     91   // The implementations of each state of the state machine.
     92   int DoSendHeaders(int result);
     93   int DoSendBody(int result);
     94   int DoReadHeaders();
     95   int DoReadHeadersComplete(int result);
     96   int DoReadBody();
     97   int DoReadBodyComplete(int result);
     98 
     99   // Examines |read_buf_| to find the start and end of the headers. Return
    100   // the offset for the end of the headers, or -1 if the complete headers
    101   // were not found. If they are are found, parse them with
    102   // DoParseResponseHeaders().
    103   int ParseResponseHeaders();
    104 
    105   // Parse the headers into response_.
    106   void DoParseResponseHeaders(int end_of_header_offset);
    107 
    108   // Examine the parsed headers to try to determine the response body size.
    109   void CalculateResponseBodySize();
    110 
    111   // Current state of the request.
    112   State io_state_;
    113 
    114   // The request to send.
    115   const HttpRequestInfo* request_;
    116 
    117   // The request header data.
    118   scoped_refptr<DrainableIOBuffer> request_headers_;
    119 
    120   // The request body data.
    121   scoped_ptr<UploadDataStream> request_body_;
    122 
    123   // Temporary buffer for reading.
    124   scoped_refptr<GrowableIOBuffer> read_buf_;
    125 
    126   // Offset of the first unused byte in |read_buf_|.  May be nonzero due to
    127   // a 1xx header, or body data in the same packet as header data.
    128   int read_buf_unused_offset_;
    129 
    130   // The amount beyond |read_buf_unused_offset_| where the status line starts;
    131   // -1 if not found yet.
    132   int response_header_start_offset_;
    133 
    134   // The parsed response headers.  Owned by the caller.
    135   HttpResponseInfo* response_;
    136 
    137   // Indicates the content length.  If this value is less than zero
    138   // (and chunked_decoder_ is null), then we must read until the server
    139   // closes the connection.
    140   int64 response_body_length_;
    141 
    142   // Keep track of the number of response body bytes read so far.
    143   int64 response_body_read_;
    144 
    145   // Helper if the data is chunked.
    146   scoped_ptr<HttpChunkedDecoder> chunked_decoder_;
    147 
    148   // Where the caller wants the body data.
    149   scoped_refptr<IOBuffer> user_read_buf_;
    150   int user_read_buf_len_;
    151 
    152   // The callback to notify a user that their request or response is
    153   // complete or there was an error
    154   CompletionCallback* user_callback_;
    155 
    156   // In the client callback, the client can do anything, including
    157   // destroying this class, so any pending callback must be issued
    158   // after everything else is done.  When it is time to issue the client
    159   // callback, move it from |user_callback_| to |scheduled_callback_|.
    160   CompletionCallback* scheduled_callback_;
    161 
    162   // The underlying socket.
    163   ClientSocketHandle* const connection_;
    164 
    165   scoped_refptr<LoadLog> load_log_;
    166 
    167   // Callback to be used when doing IO.
    168   CompletionCallbackImpl<HttpStreamParser> io_callback_;
    169 
    170   DISALLOW_COPY_AND_ASSIGN(HttpStreamParser);
    171 };
    172 
    173 }  // namespace net
    174 
    175 #endif  // NET_HTTP_HTTP_STREAM_PARSER_H_
    176