| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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/spdy/spdy_headers_block_parser.h" | |
| 6 | |
| 7 #include "base/sys_byteorder.h" | |
| 8 | |
| 9 namespace net { | |
| 10 namespace { | |
| 11 | |
| 12 // 0 is invalid according to both the SPDY 3.1 and HTTP/2 specifications. | |
| 13 const SpdyStreamId kInvalidStreamId = 0; | |
| 14 | |
| 15 } // anonymous namespace | |
| 16 | |
| 17 const size_t SpdyHeadersBlockParser::kMaximumFieldLength = 16 * 1024; | |
| 18 | |
| 19 SpdyHeadersBlockParser::SpdyHeadersBlockParser( | |
| 20 SpdyMajorVersion spdy_version, | |
| 21 SpdyHeadersHandlerInterface* handler) | |
| 22 : state_(READING_HEADER_BLOCK_LEN), | |
| 23 length_field_size_(LengthFieldSizeForVersion(spdy_version)), | |
| 24 max_headers_in_block_(MaxNumberOfHeadersForVersion(spdy_version)), | |
| 25 total_bytes_received_(0), | |
| 26 remaining_key_value_pairs_for_frame_(0), | |
| 27 handler_(handler), | |
| 28 stream_id_(kInvalidStreamId), | |
| 29 error_(NO_PARSER_ERROR), | |
| 30 spdy_version_(spdy_version) { | |
| 31 // The handler that we set must not be NULL. | |
| 32 DCHECK(handler_ != NULL); | |
| 33 } | |
| 34 | |
| 35 SpdyHeadersBlockParser::~SpdyHeadersBlockParser() {} | |
| 36 | |
| 37 bool SpdyHeadersBlockParser::HandleControlFrameHeadersData( | |
| 38 SpdyStreamId stream_id, | |
| 39 const char* headers_data, | |
| 40 size_t headers_data_length) { | |
| 41 if (error_ == NEED_MORE_DATA) { | |
| 42 error_ = NO_PARSER_ERROR; | |
| 43 } | |
| 44 if (error_ != NO_PARSER_ERROR) { | |
| 45 LOG(DFATAL) << "Unexpected error: " << error_; | |
| 46 return false; | |
| 47 } | |
| 48 | |
| 49 // If this is the first call with the current header block, | |
| 50 // save its stream id. | |
| 51 if (state_ == READING_HEADER_BLOCK_LEN && stream_id_ == kInvalidStreamId) { | |
| 52 stream_id_ = stream_id; | |
| 53 } | |
| 54 if (stream_id != stream_id_) { | |
| 55 LOG(DFATAL) << "Unexpected stream id: " << stream_id << " (expected " | |
| 56 << stream_id_ << ")"; | |
| 57 error_ = UNEXPECTED_STREAM_ID; | |
| 58 return false; | |
| 59 } | |
| 60 if (stream_id_ == kInvalidStreamId) { | |
| 61 LOG(DFATAL) << "Expected nonzero stream id, saw: " << stream_id_; | |
| 62 error_ = UNEXPECTED_STREAM_ID; | |
| 63 return false; | |
| 64 } | |
| 65 total_bytes_received_ += headers_data_length; | |
| 66 | |
| 67 SpdyPinnableBufferPiece prefix, key, value; | |
| 68 // Simultaneously tie lifetimes to the stack, and clear member variables. | |
| 69 prefix.Swap(&headers_block_prefix_); | |
| 70 key.Swap(&key_); | |
| 71 | |
| 72 // Apply the parsing state machine to the remaining prefix | |
| 73 // from last invocation, plus newly-available headers data. | |
| 74 Reader reader(prefix.buffer(), prefix.length(), | |
| 75 headers_data, headers_data_length); | |
| 76 while (error_ == NO_PARSER_ERROR) { | |
| 77 ParserState next_state(FINISHED_HEADER); | |
| 78 | |
| 79 switch (state_) { | |
| 80 case READING_HEADER_BLOCK_LEN: | |
| 81 next_state = READING_KEY_LEN; | |
| 82 ParseBlockLength(&reader); | |
| 83 break; | |
| 84 case READING_KEY_LEN: | |
| 85 next_state = READING_KEY; | |
| 86 ParseFieldLength(&reader); | |
| 87 break; | |
| 88 case READING_KEY: | |
| 89 next_state = READING_VALUE_LEN; | |
| 90 if (!reader.ReadN(next_field_length_, &key)) { | |
| 91 error_ = NEED_MORE_DATA; | |
| 92 } | |
| 93 break; | |
| 94 case READING_VALUE_LEN: | |
| 95 next_state = READING_VALUE; | |
| 96 ParseFieldLength(&reader); | |
| 97 break; | |
| 98 case READING_VALUE: | |
| 99 next_state = FINISHED_HEADER; | |
| 100 if (!reader.ReadN(next_field_length_, &value)) { | |
| 101 error_ = NEED_MORE_DATA; | |
| 102 } else { | |
| 103 handler_->OnHeader(key, value); | |
| 104 } | |
| 105 break; | |
| 106 case FINISHED_HEADER: | |
| 107 // Prepare for next header or block. | |
| 108 if (--remaining_key_value_pairs_for_frame_ > 0) { | |
| 109 next_state = READING_KEY_LEN; | |
| 110 } else { | |
| 111 next_state = READING_HEADER_BLOCK_LEN; | |
| 112 handler_->OnHeaderBlockEnd(total_bytes_received_); | |
| 113 stream_id_ = kInvalidStreamId; | |
| 114 // Expect to have consumed all buffer. | |
| 115 if (reader.Available() != 0) { | |
| 116 error_ = TOO_MUCH_DATA; | |
| 117 } | |
| 118 } | |
| 119 break; | |
| 120 } | |
| 121 | |
| 122 if (error_ == NO_PARSER_ERROR) { | |
| 123 state_ = next_state; | |
| 124 | |
| 125 if (next_state == READING_HEADER_BLOCK_LEN) { | |
| 126 // We completed reading a full header block. Return to caller. | |
| 127 total_bytes_received_ = 0; | |
| 128 break; | |
| 129 } | |
| 130 } else if (error_ == NEED_MORE_DATA) { | |
| 131 // We can't continue parsing until more data is available. Make copies of | |
| 132 // the key and buffer remainder, in preperation for the next invocation. | |
| 133 if (state_ > READING_KEY) { | |
| 134 key_.Swap(&key); | |
| 135 key_.Pin(); | |
| 136 } | |
| 137 reader.ReadN(reader.Available(), &headers_block_prefix_); | |
| 138 headers_block_prefix_.Pin(); | |
| 139 } | |
| 140 } | |
| 141 return error_ == NO_PARSER_ERROR; | |
| 142 } | |
| 143 | |
| 144 void SpdyHeadersBlockParser::ParseBlockLength(Reader* reader) { | |
| 145 ParseLength(reader, &remaining_key_value_pairs_for_frame_); | |
| 146 if (error_ == NO_PARSER_ERROR && | |
| 147 remaining_key_value_pairs_for_frame_ > max_headers_in_block_) { | |
| 148 error_ = HEADER_BLOCK_TOO_LARGE; | |
| 149 } | |
| 150 if (error_ == NO_PARSER_ERROR) { | |
| 151 handler_->OnHeaderBlock(remaining_key_value_pairs_for_frame_); | |
| 152 } | |
| 153 } | |
| 154 | |
| 155 void SpdyHeadersBlockParser::ParseFieldLength(Reader* reader) { | |
| 156 ParseLength(reader, &next_field_length_); | |
| 157 if (error_ == NO_PARSER_ERROR && next_field_length_ > kMaximumFieldLength) { | |
| 158 error_ = HEADER_FIELD_TOO_LARGE; | |
| 159 } | |
| 160 } | |
| 161 | |
| 162 void SpdyHeadersBlockParser::ParseLength(Reader* reader, | |
| 163 uint32_t* parsed_length) { | |
| 164 char buffer[] = {0, 0, 0, 0}; | |
| 165 if (!reader->ReadN(length_field_size_, buffer)) { | |
| 166 error_ = NEED_MORE_DATA; | |
| 167 return; | |
| 168 } | |
| 169 // Convert from network to host order and return the parsed out integer. | |
| 170 if (length_field_size_ == sizeof(uint32_t)) { | |
| 171 *parsed_length = ntohl(*reinterpret_cast<const uint32_t *>(buffer)); | |
| 172 } else { | |
| 173 *parsed_length = ntohs(*reinterpret_cast<const uint16_t *>(buffer)); | |
| 174 } | |
| 175 } | |
| 176 | |
| 177 size_t SpdyHeadersBlockParser::LengthFieldSizeForVersion( | |
| 178 SpdyMajorVersion spdy_version) { | |
| 179 if (spdy_version < SPDY3) { | |
| 180 return sizeof(uint16_t); | |
| 181 } | |
| 182 return sizeof(uint32_t); | |
| 183 } | |
| 184 | |
| 185 size_t SpdyHeadersBlockParser::MaxNumberOfHeadersForVersion( | |
| 186 SpdyMajorVersion spdy_version) { | |
| 187 // Account for the length of the header block field. | |
| 188 size_t max_bytes_for_headers = | |
| 189 kMaximumFieldLength - LengthFieldSizeForVersion(spdy_version); | |
| 190 | |
| 191 // A minimal size header is twice the length field size (and has a | |
| 192 // zero-lengthed key and a zero-lengthed value). | |
| 193 return max_bytes_for_headers / (2 * LengthFieldSizeForVersion(spdy_version)); | |
| 194 } | |
| 195 | |
| 196 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master