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