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
|
// Copyright 2016 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 QUICHE_HTTP2_HPACK_DECODER_HPACK_WHOLE_ENTRY_BUFFER_H_
#define QUICHE_HTTP2_HPACK_DECODER_HPACK_WHOLE_ENTRY_BUFFER_H_
// HpackWholeEntryBuffer isolates a listener from the fact that an entry may
// be split across multiple input buffers, providing one callback per entry.
// HpackWholeEntryBuffer requires that the HpackEntryDecoderListener be made in
// the correct order, which is tested by hpack_entry_decoder_test.cc.
#include <stddef.h>
#include "absl/strings/string_view.h"
#include "http2/hpack/decoder/hpack_decoder_string_buffer.h"
#include "http2/hpack/decoder/hpack_decoding_error.h"
#include "http2/hpack/decoder/hpack_entry_decoder_listener.h"
#include "http2/hpack/decoder/hpack_whole_entry_listener.h"
#include "http2/hpack/http2_hpack_constants.h"
#include "common/platform/api/quiche_export.h"
namespace http2 {
// TODO(jamessynge): Consider renaming HpackEntryDecoderListener to
// HpackEntryPartsListener or HpackEntryFragmentsListener.
class QUICHE_EXPORT_PRIVATE HpackWholeEntryBuffer
: public HpackEntryDecoderListener {
public:
// max_string_size specifies the maximum size of an on-the-wire string (name
// or value, plain or Huffman encoded) that will be accepted. See sections
// 5.1 and 5.2 of RFC 7541. This is a defense against OOM attacks; HTTP/2
// allows a decoder to enforce any limit of the size of the header lists
// that it is willing decode, including less than the MAX_HEADER_LIST_SIZE
// setting, a setting that is initially unlimited. For example, we might
// choose to send a MAX_HEADER_LIST_SIZE of 64KB, and to use that same value
// as the upper bound for individual strings.
HpackWholeEntryBuffer(HpackWholeEntryListener* listener,
size_t max_string_size);
~HpackWholeEntryBuffer() override;
HpackWholeEntryBuffer(const HpackWholeEntryBuffer&) = delete;
HpackWholeEntryBuffer& operator=(const HpackWholeEntryBuffer&) = delete;
// Set the listener to be notified when a whole entry has been decoded.
// The listener may be changed at any time.
void set_listener(HpackWholeEntryListener* listener);
// Set how much encoded data this decoder is willing to buffer.
// TODO(jamessynge): Come up with consistent semantics for this protection
// across the various decoders; e.g. should it be for a single string or
// a single header entry?
void set_max_string_size_bytes(size_t max_string_size_bytes);
// Ensure that decoded strings pointed to by the HpackDecoderStringBuffer
// instances name_ and value_ are buffered, which allows any underlying
// transport buffer to be freed or reused without overwriting the decoded
// strings. This is needed only when an HPACK entry is split across transport
// buffers. See HpackDecoder::DecodeFragment.
void BufferStringsIfUnbuffered();
// Was an error detected? After an error has been detected and reported,
// no further callbacks will be made to the listener.
bool error_detected() const { return error_detected_; }
// Implement the HpackEntryDecoderListener methods.
void OnIndexedHeader(size_t index) override;
void OnStartLiteralHeader(HpackEntryType entry_type,
size_t maybe_name_index) override;
void OnNameStart(bool huffman_encoded, size_t len) override;
void OnNameData(const char* data, size_t len) override;
void OnNameEnd() override;
void OnValueStart(bool huffman_encoded, size_t len) override;
void OnValueData(const char* data, size_t len) override;
void OnValueEnd() override;
void OnDynamicTableSizeUpdate(size_t size) override;
private:
void ReportError(HpackDecodingError error, std::string detailed_error);
HpackWholeEntryListener* listener_;
HpackDecoderStringBuffer name_, value_;
// max_string_size_bytes_ specifies the maximum allowed size of an on-the-wire
// string. Larger strings will be reported as errors to the listener; the
// endpoint should treat these as COMPRESSION errors, which are CONNECTION
// level errors.
size_t max_string_size_bytes_;
// The name index (or zero) of the current header entry with a literal value.
size_t maybe_name_index_;
// The type of the current header entry (with literals) that is being decoded.
HpackEntryType entry_type_;
bool error_detected_ = false;
};
} // namespace http2
#endif // QUICHE_HTTP2_HPACK_DECODER_HPACK_WHOLE_ENTRY_BUFFER_H_
|
