Home | History | Annotate | Download | only in http 
      1 // Copyright (c) 2006-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 #include "net/http/http_stream_parser.h"
      6 
      7 #include "base/compiler_specific.h"
      8 #include "base/trace_event.h"
      9 #include "net/base/io_buffer.h"
     10 #include "net/http/http_request_info.h"
     11 #include "net/http/http_response_headers.h"
     12 #include "net/http/http_util.h"
     13 
     14 namespace net {
     15 
     16 HttpStreamParser::HttpStreamParser(ClientSocketHandle* connection,
     17                                    GrowableIOBuffer* read_buffer,
     18                                    LoadLog* load_log)
     19     : io_state_(STATE_NONE),
     20       request_(NULL),
     21       request_headers_(NULL),
     22       request_body_(NULL),
     23       read_buf_(read_buffer),
     24       read_buf_unused_offset_(0),
     25       response_header_start_offset_(-1),
     26       response_body_length_(-1),
     27       response_body_read_(0),
     28       chunked_decoder_(NULL),
     29       user_read_buf_(NULL),
     30       user_read_buf_len_(0),
     31       user_callback_(NULL),
     32       connection_(connection),
     33       load_log_(load_log),
     34       ALLOW_THIS_IN_INITIALIZER_LIST(
     35           io_callback_(this, &HttpStreamParser::OnIOComplete)) {
     36   DCHECK_EQ(0, read_buffer->offset());
     37 }
     38 
     39 int HttpStreamParser::SendRequest(const HttpRequestInfo* request,
     40                                   const std::string& headers,
     41                                   UploadDataStream* request_body,
     42                                   HttpResponseInfo* response,
     43                                   CompletionCallback* callback) {
     44   DCHECK_EQ(STATE_NONE, io_state_);
     45   DCHECK(!user_callback_);
     46   DCHECK(callback);
     47   DCHECK(response);
     48 
     49   request_ = request;
     50   response_ = response;
     51   scoped_refptr<StringIOBuffer> headers_io_buf = new StringIOBuffer(headers);
     52   request_headers_ = new DrainableIOBuffer(headers_io_buf,
     53                                            headers_io_buf->size());
     54   request_body_.reset(request_body);
     55 
     56   io_state_ = STATE_SENDING_HEADERS;
     57   int result = DoLoop(OK);
     58   if (result == ERR_IO_PENDING)
     59     user_callback_ = callback;
     60 
     61   return result > 0 ? OK : result;
     62 }
     63 
     64 int HttpStreamParser::ReadResponseHeaders(CompletionCallback* callback) {
     65   DCHECK(io_state_ == STATE_REQUEST_SENT || io_state_ == STATE_DONE);
     66   DCHECK(!user_callback_);
     67   DCHECK(callback);
     68 
     69   // This function can be called with io_state_ == STATE_DONE if the
     70   // connection is closed after seeing just a 1xx response code.
     71   if (io_state_ == STATE_DONE)
     72     return ERR_CONNECTION_CLOSED;
     73 
     74   int result = OK;
     75   io_state_ = STATE_READ_HEADERS;
     76 
     77   if (read_buf_->offset() > 0) {
     78     // Simulate the state where the data was just read from the socket.
     79     result = read_buf_->offset() - read_buf_unused_offset_;
     80     read_buf_->set_offset(read_buf_unused_offset_);
     81   }
     82   if (result > 0)
     83     io_state_ = STATE_READ_HEADERS_COMPLETE;
     84 
     85   result = DoLoop(result);
     86   if (result == ERR_IO_PENDING)
     87     user_callback_ = callback;
     88 
     89   return result > 0 ? OK : result;
     90 }
     91 
     92 int HttpStreamParser::ReadResponseBody(IOBuffer* buf, int buf_len,
     93                                       CompletionCallback* callback) {
     94   DCHECK(io_state_ == STATE_BODY_PENDING || io_state_ == STATE_DONE);
     95   DCHECK(!user_callback_);
     96   DCHECK(callback);
     97   DCHECK_LE(buf_len, kMaxBufSize);
     98 
     99   if (io_state_ == STATE_DONE)
    100     return OK;
    101 
    102   user_read_buf_ = buf;
    103   user_read_buf_len_ = buf_len;
    104   io_state_ = STATE_READ_BODY;
    105 
    106   int result = DoLoop(OK);
    107   if (result == ERR_IO_PENDING)
    108     user_callback_ = callback;
    109 
    110   return result;
    111 }
    112 
    113 void HttpStreamParser::OnIOComplete(int result) {
    114   result = DoLoop(result);
    115 
    116   // The client callback can do anything, including destroying this class,
    117   // so any pending callback must be issued after everything else is done.
    118   if (result != ERR_IO_PENDING && user_callback_) {
    119     CompletionCallback* c = user_callback_;
    120     user_callback_ = NULL;
    121     c->Run(result);
    122   }
    123 }
    124 
    125 int HttpStreamParser::DoLoop(int result) {
    126   bool can_do_more = true;
    127   do {
    128     switch (io_state_) {
    129       case STATE_SENDING_HEADERS:
    130         TRACE_EVENT_BEGIN("http.write_headers", request_, request_->url.spec());
    131         if (result < 0)
    132           can_do_more = false;
    133         else
    134           result = DoSendHeaders(result);
    135         TRACE_EVENT_END("http.write_headers", request_, request_->url.spec());
    136         break;
    137       case STATE_SENDING_BODY:
    138         TRACE_EVENT_BEGIN("http.write_body", request_, request_->url.spec());
    139         if (result < 0)
    140           can_do_more = false;
    141         else
    142           result = DoSendBody(result);
    143         TRACE_EVENT_END("http.write_body", request_, request_->url.spec());
    144         break;
    145       case STATE_REQUEST_SENT:
    146         DCHECK(result != ERR_IO_PENDING);
    147         can_do_more = false;
    148         break;
    149       case STATE_READ_HEADERS:
    150         TRACE_EVENT_BEGIN("http.read_headers", request_, request_->url.spec());
    151         LoadLog::BeginEvent(load_log_,
    152                             LoadLog::TYPE_HTTP_STREAM_PARSER_READ_HEADERS);
    153         result = DoReadHeaders();
    154         break;
    155       case STATE_READ_HEADERS_COMPLETE:
    156         result = DoReadHeadersComplete(result);
    157         LoadLog::EndEvent(load_log_,
    158                           LoadLog::TYPE_HTTP_STREAM_PARSER_READ_HEADERS);
    159         TRACE_EVENT_END("http.read_headers", request_, request_->url.spec());
    160         break;
    161       case STATE_BODY_PENDING:
    162         DCHECK(result != ERR_IO_PENDING);
    163         can_do_more = false;
    164         break;
    165       case STATE_READ_BODY:
    166         TRACE_EVENT_BEGIN("http.read_body", request_, request_->url.spec());
    167         result = DoReadBody();
    168         // DoReadBodyComplete handles error conditions.
    169         break;
    170       case STATE_READ_BODY_COMPLETE:
    171         result = DoReadBodyComplete(result);
    172         TRACE_EVENT_END("http.read_body", request_, request_->url.spec());
    173         break;
    174       case STATE_DONE:
    175         DCHECK(result != ERR_IO_PENDING);
    176         can_do_more = false;
    177         break;
    178       default:
    179         NOTREACHED();
    180         can_do_more = false;
    181         break;
    182     }
    183   } while (result != ERR_IO_PENDING && can_do_more);
    184 
    185   return result;
    186 }
    187 
    188 int HttpStreamParser::DoSendHeaders(int result) {
    189   request_headers_->DidConsume(result);
    190 
    191   if (request_headers_->BytesRemaining() > 0) {
    192     // Record our best estimate of the 'request time' as the time when we send
    193     // out the first bytes of the request headers.
    194     if (request_headers_->BytesRemaining() == request_headers_->size()) {
    195       response_->request_time = base::Time::Now();
    196     }
    197     result = connection_->socket()->Write(request_headers_,
    198                                           request_headers_->BytesRemaining(),
    199                                           &io_callback_);
    200   } else if (request_body_ != NULL && request_body_->size()) {
    201     io_state_ = STATE_SENDING_BODY;
    202     result = OK;
    203   } else {
    204     io_state_ = STATE_REQUEST_SENT;
    205   }
    206   return result;
    207 }
    208 
    209 int HttpStreamParser::DoSendBody(int result) {
    210   if (result > 0)
    211     request_body_->DidConsume(result);
    212 
    213   if (request_body_->position() < request_body_->size()) {
    214     int buf_len = static_cast<int>(request_body_->buf_len());
    215     result = connection_->socket()->Write(request_body_->buf(), buf_len,
    216                                           &io_callback_);
    217   } else {
    218     io_state_ = STATE_REQUEST_SENT;
    219   }
    220   return result;
    221 }
    222 
    223 int HttpStreamParser::DoReadHeaders() {
    224   io_state_ = STATE_READ_HEADERS_COMPLETE;
    225 
    226   // Grow the read buffer if necessary.
    227   if (read_buf_->RemainingCapacity() == 0)
    228     read_buf_->SetCapacity(read_buf_->capacity() + kHeaderBufInitialSize);
    229 
    230   // http://crbug.com/16371: We're seeing |user_buf_->data()| return NULL.
    231   // See if the user is passing in an IOBuffer with a NULL |data_|.
    232   CHECK(read_buf_->data());
    233 
    234   return connection_->socket()->Read(read_buf_,
    235                                      read_buf_->RemainingCapacity(),
    236                                      &io_callback_);
    237 }
    238 
    239 int HttpStreamParser::DoReadHeadersComplete(int result) {
    240   if (result == 0)
    241     result = ERR_CONNECTION_CLOSED;
    242 
    243   if (result < 0 && result != ERR_CONNECTION_CLOSED) {
    244     io_state_ = STATE_DONE;
    245     return result;
    246   }
    247   if (result == ERR_CONNECTION_CLOSED && read_buf_->offset() == 0 &&
    248       connection_->ShouldResendFailedRequest(result)) {
    249     io_state_ = STATE_DONE;
    250     return result;
    251   }
    252 
    253   // Record our best estimate of the 'response time' as the time when we read
    254   // the first bytes of the response headers.
    255   if (read_buf_->offset() == 0 && result != ERR_CONNECTION_CLOSED)
    256     response_->response_time = base::Time::Now();
    257 
    258   if (result == ERR_CONNECTION_CLOSED) {
    259     // The connection closed before we detected the end of the headers.
    260     // parse things as well as we can and let the caller decide what to do.
    261     if (read_buf_->offset() == 0) {
    262       // The connection was closed before any data was sent. Likely an error
    263       // rather than empty HTTP/0.9 response.
    264       io_state_ = STATE_DONE;
    265       return ERR_EMPTY_RESPONSE;
    266     } else {
    267       int end_offset;
    268       if (response_header_start_offset_ >= 0) {
    269         io_state_ = STATE_READ_BODY_COMPLETE;
    270         end_offset = read_buf_->offset();
    271       } else {
    272         io_state_ = STATE_BODY_PENDING;
    273         end_offset = 0;
    274       }
    275       DoParseResponseHeaders(end_offset);
    276       return result;
    277     }
    278   }
    279 
    280   read_buf_->set_offset(read_buf_->offset() + result);
    281   DCHECK_LE(read_buf_->offset(), read_buf_->capacity());
    282   DCHECK(result >= 0);
    283 
    284   int end_of_header_offset = ParseResponseHeaders();
    285   if (end_of_header_offset == -1) {
    286     io_state_ = STATE_READ_HEADERS;
    287     // Prevent growing the headers buffer indefinitely.
    288     if (read_buf_->offset() - read_buf_unused_offset_ >= kMaxHeaderBufSize) {
    289       io_state_ = STATE_DONE;
    290       return ERR_RESPONSE_HEADERS_TOO_BIG;
    291     }
    292   } else {
    293     // Note where the headers stop.
    294     read_buf_unused_offset_ = end_of_header_offset;
    295 
    296     if (response_->headers->response_code() / 100 == 1) {
    297       // After processing a 1xx response, the caller will ask for the next
    298       // header, so reset state to support that.  We don't just skip these
    299       // completely because 1xx codes aren't acceptable when establishing a
    300       // tunnel.
    301       io_state_ = STATE_REQUEST_SENT;
    302       response_header_start_offset_ = -1;
    303     } else {
    304       io_state_ = STATE_BODY_PENDING;
    305       CalculateResponseBodySize();
    306       // If the body is 0, the caller may not call ReadResponseBody, which
    307       // is where any extra data is copied to read_buf_, so we move the
    308       // data here and transition to DONE.
    309       if (response_body_length_ == 0) {
    310         io_state_ = STATE_DONE;
    311         int extra_bytes = read_buf_->offset() - read_buf_unused_offset_;
    312         if (extra_bytes) {
    313           CHECK(extra_bytes > 0);
    314           memmove(read_buf_->StartOfBuffer(),
    315                   read_buf_->StartOfBuffer() + read_buf_unused_offset_,
    316                   extra_bytes);
    317         }
    318         read_buf_->SetCapacity(extra_bytes);
    319         read_buf_unused_offset_ = 0;
    320         return OK;
    321       }
    322     }
    323   }
    324   return result;
    325 }
    326 
    327 int HttpStreamParser::DoReadBody() {
    328   io_state_ = STATE_READ_BODY_COMPLETE;
    329 
    330   // There may be some data left over from reading the response headers.
    331   if (read_buf_->offset()) {
    332     int available = read_buf_->offset() - read_buf_unused_offset_;
    333     if (available) {
    334       CHECK(available > 0);
    335       int bytes_from_buffer = std::min(available, user_read_buf_len_);
    336       memcpy(user_read_buf_->data(),
    337              read_buf_->StartOfBuffer() + read_buf_unused_offset_,
    338              bytes_from_buffer);
    339       read_buf_unused_offset_ += bytes_from_buffer;
    340       if (bytes_from_buffer == available) {
    341         read_buf_->SetCapacity(0);
    342         read_buf_unused_offset_ = 0;
    343       }
    344       return bytes_from_buffer;
    345     } else {
    346       read_buf_->SetCapacity(0);
    347       read_buf_unused_offset_ = 0;
    348     }
    349   }
    350 
    351   // Check to see if we're done reading.
    352   if (IsResponseBodyComplete())
    353     return 0;
    354 
    355   DCHECK_EQ(0, read_buf_->offset());
    356   return connection_->socket()->Read(user_read_buf_, user_read_buf_len_,
    357                                      &io_callback_);
    358 }
    359 
    360 int HttpStreamParser::DoReadBodyComplete(int result) {
    361   if (result == 0)
    362     result = ERR_CONNECTION_CLOSED;
    363 
    364   // Filter incoming data if appropriate.  FilterBuf may return an error.
    365   if (result > 0 && chunked_decoder_.get()) {
    366     result = chunked_decoder_->FilterBuf(user_read_buf_->data(), result);
    367     if (result == 0 && !chunked_decoder_->reached_eof()) {
    368       // Don't signal completion of the Read call yet or else it'll look like
    369       // we received end-of-file.  Wait for more data.
    370       io_state_ = STATE_READ_BODY;
    371       return OK;
    372     }
    373   }
    374 
    375   if (result > 0)
    376     response_body_read_ += result;
    377 
    378   if (result < 0 || IsResponseBodyComplete()) {
    379     io_state_ = STATE_DONE;
    380 
    381     // Save the overflow data, which can be in two places.  There may be
    382     // some left over in |user_read_buf_|, plus there may be more
    383     // in |read_buf_|.  But the part left over in |user_read_buf_| must have
    384     // come from the |read_buf_|, so there's room to put it back at the
    385     // start first.
    386     int additional_save_amount = read_buf_->offset() - read_buf_unused_offset_;
    387     int save_amount = 0;
    388     if (chunked_decoder_.get()) {
    389       save_amount = chunked_decoder_->bytes_after_eof();
    390     } else if (response_body_length_ >= 0) {
    391       int64 extra_data_read = response_body_read_ - response_body_length_;
    392       if (extra_data_read > 0) {
    393         save_amount = static_cast<int>(extra_data_read);
    394         if (result > 0)
    395           result -= save_amount;
    396       }
    397     }
    398 
    399     CHECK(save_amount + additional_save_amount <= kMaxBufSize);
    400     if (read_buf_->capacity() < save_amount + additional_save_amount) {
    401       read_buf_->SetCapacity(save_amount + additional_save_amount);
    402     }
    403 
    404     if (save_amount) {
    405       memcpy(read_buf_->StartOfBuffer(), user_read_buf_->data() + result,
    406              save_amount);
    407     }
    408     read_buf_->set_offset(save_amount);
    409     if (additional_save_amount) {
    410       memmove(read_buf_->data(),
    411               read_buf_->StartOfBuffer() + read_buf_unused_offset_,
    412               additional_save_amount);
    413       read_buf_->set_offset(save_amount + additional_save_amount);
    414     }
    415     read_buf_unused_offset_ = 0;
    416   } else {
    417     io_state_ = STATE_BODY_PENDING;
    418     user_read_buf_ = NULL;
    419     user_read_buf_len_ = 0;
    420   }
    421 
    422   return result;
    423 }
    424 
    425 int HttpStreamParser::ParseResponseHeaders() {
    426   int end_offset = -1;
    427 
    428   // Look for the start of the status line, if it hasn't been found yet.
    429   if (response_header_start_offset_ < 0) {
    430     response_header_start_offset_ = HttpUtil::LocateStartOfStatusLine(
    431         read_buf_->StartOfBuffer() + read_buf_unused_offset_,
    432         read_buf_->offset() - read_buf_unused_offset_);
    433   }
    434 
    435   if (response_header_start_offset_ >= 0) {
    436     end_offset = HttpUtil::LocateEndOfHeaders(
    437         read_buf_->StartOfBuffer() + read_buf_unused_offset_,
    438         read_buf_->offset() - read_buf_unused_offset_,
    439         response_header_start_offset_);
    440   } else if (read_buf_->offset() - read_buf_unused_offset_ >= 8) {
    441     // Enough data to decide that this is an HTTP/0.9 response.
    442     // 8 bytes = (4 bytes of junk) + "http".length()
    443     end_offset = 0;
    444   }
    445 
    446   if (end_offset == -1)
    447     return -1;
    448 
    449   DoParseResponseHeaders(end_offset);
    450   return end_offset + read_buf_unused_offset_;
    451 }
    452 
    453 void HttpStreamParser::DoParseResponseHeaders(int end_offset) {
    454   scoped_refptr<HttpResponseHeaders> headers;
    455   if (response_header_start_offset_ >= 0) {
    456     headers = new HttpResponseHeaders(HttpUtil::AssembleRawHeaders(
    457         read_buf_->StartOfBuffer() + read_buf_unused_offset_, end_offset));
    458   } else {
    459     // Enough data was read -- there is no status line.
    460     headers = new HttpResponseHeaders(std::string("HTTP/0.9 200 OK"));
    461   }
    462 
    463   response_->headers = headers;
    464   response_->vary_data.Init(*request_, *response_->headers);
    465 }
    466 
    467 void HttpStreamParser::CalculateResponseBodySize() {
    468   // Figure how to determine EOF:
    469 
    470   // For certain responses, we know the content length is always 0. From
    471   // RFC 2616 Section 4.3 Message Body:
    472   //
    473   // For response messages, whether or not a message-body is included with
    474   // a message is dependent on both the request method and the response
    475   // status code (section 6.1.1). All responses to the HEAD request method
    476   // MUST NOT include a message-body, even though the presence of entity-
    477   // header fields might lead one to believe they do. All 1xx
    478   // (informational), 204 (no content), and 304 (not modified) responses
    479   // MUST NOT include a message-body. All other responses do include a
    480   // message-body, although it MAY be of zero length.
    481   switch (response_->headers->response_code()) {
    482     // Note that 1xx was already handled earlier.
    483     case 204:  // No Content
    484     case 205:  // Reset Content
    485     case 304:  // Not Modified
    486       response_body_length_ = 0;
    487       break;
    488   }
    489   if (request_->method == "HEAD")
    490     response_body_length_ = 0;
    491 
    492   if (response_body_length_ == -1) {
    493     // Ignore spurious chunked responses from HTTP/1.0 servers and
    494     // proxies. Otherwise "Transfer-Encoding: chunked" trumps
    495     // "Content-Length: N"
    496     if (response_->headers->GetHttpVersion() >= HttpVersion(1, 1) &&
    497         response_->headers->HasHeaderValue("Transfer-Encoding", "chunked")) {
    498       chunked_decoder_.reset(new HttpChunkedDecoder());
    499     } else {
    500       response_body_length_ = response_->headers->GetContentLength();
    501       // If response_body_length_ is still -1, then we have to wait
    502       // for the server to close the connection.
    503     }
    504   }
    505 }
    506 
    507 uint64 HttpStreamParser::GetUploadProgress() const {
    508   if (!request_body_.get())
    509     return 0;
    510 
    511   return request_body_->position();
    512 }
    513 
    514 HttpResponseInfo* HttpStreamParser::GetResponseInfo() {
    515   return response_;
    516 }
    517 
    518 bool HttpStreamParser::IsResponseBodyComplete() const {
    519   if (chunked_decoder_.get())
    520     return chunked_decoder_->reached_eof();
    521   if (response_body_length_ != -1)
    522     return response_body_read_ >= response_body_length_;
    523 
    524   return false;  // Must read to EOF.
    525 }
    526 
    527 bool HttpStreamParser::CanFindEndOfResponse() const {
    528   return chunked_decoder_.get() || response_body_length_ >= 0;
    529 }
    530 
    531 bool HttpStreamParser::IsMoreDataBuffered() const {
    532   return read_buf_->offset() > read_buf_unused_offset_;
    533 }
    534 
    535 }  // namespace net
    536