1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef NET_SPDY_SPDY_HEADERS_BLOCK_PARSER_H_
#define NET_SPDY_SPDY_HEADERS_BLOCK_PARSER_H_
#include <stddef.h>
#include <stdint.h>
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "base/strings/string_piece.h"
#include "net/base/net_export.h"
#include "net/spdy/spdy_headers_handler_interface.h"
#include "net/spdy/spdy_prefixed_buffer_reader.h"
#include "net/spdy/spdy_protocol.h"
namespace net {
namespace test {
class SpdyHeadersBlockParserPeer;
} // namespace test
// This class handles SPDY headers block bytes and parses out key-value pairs
// as they arrive. This class is not thread-safe, and assumes that all headers
// block bytes are processed in a single thread.
class NET_EXPORT_PRIVATE SpdyHeadersBlockParser {
public:
// Bound on acceptable header name or value length.
static const size_t kMaximumFieldLength; // = 16 * 1024
// Constructor. The handler's OnHeader will be called for every key
// value pair that we parsed from the headers block.
SpdyHeadersBlockParser(SpdyMajorVersion spdy_version,
SpdyHeadersHandlerInterface* handler);
virtual ~SpdyHeadersBlockParser();
// Handles headers block data as it arrives. Returns false if an error has
// been set, which can include the recoverable error NEED_MORE_DATA. Returns
// true if the invocation completes the parse of the entire headers block,
// in which case the parser is ready for a new headers block.
bool HandleControlFrameHeadersData(SpdyStreamId stream_id,
const char* headers_data,
size_t len);
enum ParserError {
NO_PARSER_ERROR,
// Set when parsing failed due to insufficient data.
// This error is recoverable, by passing in new data.
NEED_MORE_DATA,
// Set when a complete block has been read, but unprocessed data remains.
TOO_MUCH_DATA,
// Set when a block exceeds |MaxNumberOfHeadersForVersion| headers.
HEADER_BLOCK_TOO_LARGE,
// Set when a header key or value exceeds |kMaximumFieldLength|.
HEADER_FIELD_TOO_LARGE,
// Set when the parser is given an unexpected stream ID.
UNEXPECTED_STREAM_ID,
};
ParserError get_error() const { return error_; }
SpdyMajorVersion spdy_version() const { return spdy_version_; }
// Returns the maximal number of headers in a SPDY headers block.
static size_t MaxNumberOfHeaders();
private:
typedef SpdyPrefixedBufferReader Reader;
// Parses and sanity-checks header block length.
void ParseBlockLength(Reader* reader);
// Parses and sanity-checks header field length.
void ParseFieldLength(Reader* reader);
// Parses and decodes network-order lengths into |parsed_length|.
void ParseLength(Reader* reader, uint32_t* parsed_length);
// The state of the parser.
enum ParserState {
READING_HEADER_BLOCK_LEN,
READING_KEY_LEN,
READING_KEY,
READING_VALUE_LEN,
READING_VALUE,
FINISHED_HEADER
};
ParserState state_;
// The maximal number of headers in a SPDY headers block.
const size_t max_headers_in_block_;
// A running total of the bytes parsed since the last call to Reset().
size_t total_bytes_received_;
// Number of key-value pairs until we complete handling the current
// headers block.
uint32_t remaining_key_value_pairs_for_frame_;
// The length of the next header field to be read (either key or value).
uint32_t next_field_length_;
// Handles key-value pairs as we parse them.
SpdyHeadersHandlerInterface* handler_;
// Holds unprocessed buffer remainders between calls to
// |HandleControlFrameHeadersData|.
SpdyPinnableBufferPiece headers_block_prefix_;
// Holds the key of a partially processed header between calls to
// |HandleControlFrameHeadersData|.
SpdyPinnableBufferPiece key_;
// The current header block stream identifier.
SpdyStreamId stream_id_;
ParserError error_;
const SpdyMajorVersion spdy_version_;
};
} // namespace net
#endif // NET_SPDY_SPDY_HEADERS_BLOCK_PARSER_H_
|
