blob: d4a671b8933907290693b509c29d31f215c58bf4 [file] [log] [blame]
// Copyright (c) 2012 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.
// This file contains some protocol structures for use with SPDY 3 and HTTP 2
// The SPDY 3 spec can be found at:
// http://dev.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3
#ifndef QUICHE_SPDY_CORE_SPDY_PROTOCOL_H_
#define QUICHE_SPDY_CORE_SPDY_PROTOCOL_H_
#include <cstddef>
#include <cstdint>
#include <iosfwd>
#include <limits>
#include <map>
#include <memory>
#include <new>
#include <string>
#include <utility>
#include "absl/strings/string_view.h"
#include "common/platform/api/quiche_export.h"
#include "spdy/core/spdy_alt_svc_wire_format.h"
#include "spdy/core/spdy_bitmasks.h"
#include "spdy/core/spdy_header_block.h"
#include "spdy/platform/api/spdy_bug_tracker.h"
#include "spdy/platform/api/spdy_logging.h"
namespace spdy {
// A stream ID is a 31-bit entity.
using SpdyStreamId = uint32_t;
// A SETTINGS ID is a 16-bit entity.
using SpdySettingsId = uint16_t;
// Specifies the stream ID used to denote the current session (for
// flow control).
const SpdyStreamId kSessionFlowControlStreamId = 0;
// 0 is not a valid stream ID for any other purpose than flow control.
const SpdyStreamId kInvalidStreamId = 0;
// Max stream id.
const SpdyStreamId kMaxStreamId = 0x7fffffff;
// The maximum possible frame payload size allowed by the spec.
const uint32_t kSpdyMaxFrameSizeLimit = (1 << 24) - 1;
// The initial value for the maximum frame payload size as per the spec. This is
// the maximum control frame size we accept.
const uint32_t kHttp2DefaultFramePayloadLimit = 1 << 14;
// The maximum size of the control frames that we send, including the size of
// the header. This limit is arbitrary. We can enforce it here or at the
// application layer. We chose the framing layer, but this can be changed (or
// removed) if necessary later down the line.
const size_t kHttp2MaxControlFrameSendSize = kHttp2DefaultFramePayloadLimit - 1;
// Number of octets in the frame header.
const size_t kFrameHeaderSize = 9;
// The initial value for the maximum frame payload size as per the spec. This is
// the maximum control frame size we accept.
const uint32_t kHttp2DefaultFrameSizeLimit =
kHttp2DefaultFramePayloadLimit + kFrameHeaderSize;
// The initial value for the maximum size of the header list, "unlimited" (max
// unsigned 32-bit int) as per the spec.
const uint32_t kSpdyInitialHeaderListSizeLimit = 0xFFFFFFFF;
// Maximum window size for a Spdy stream or session.
const int32_t kSpdyMaximumWindowSize = 0x7FFFFFFF; // Max signed 32bit int
// Maximum padding size in octets for one DATA or HEADERS or PUSH_PROMISE frame.
const int32_t kPaddingSizePerFrame = 256;
// The HTTP/2 connection preface, which must be the first bytes sent by the
// client upon starting an HTTP/2 connection, and which must be followed by a
// SETTINGS frame. Note that even though |kHttp2ConnectionHeaderPrefix| is
// defined as a string literal with a null terminator, the actual connection
// preface is only the first |kHttp2ConnectionHeaderPrefixSize| bytes, which
// excludes the null terminator.
QUICHE_EXPORT_PRIVATE extern const char* const kHttp2ConnectionHeaderPrefix;
const int kHttp2ConnectionHeaderPrefixSize = 24;
// Wire values for HTTP2 frame types.
enum class SpdyFrameType : uint8_t {
DATA = 0x00,
HEADERS = 0x01,
PRIORITY = 0x02,
RST_STREAM = 0x03,
SETTINGS = 0x04,
PUSH_PROMISE = 0x05,
PING = 0x06,
GOAWAY = 0x07,
WINDOW_UPDATE = 0x08,
CONTINUATION = 0x09,
// ALTSVC is a public extension.
ALTSVC = 0x0a,
PRIORITY_UPDATE = 0x10,
ACCEPT_CH = 0x89,
};
// Flags on data packets.
enum SpdyDataFlags {
DATA_FLAG_NONE = 0x00,
DATA_FLAG_FIN = 0x01,
DATA_FLAG_PADDED = 0x08,
};
// Flags on control packets
enum SpdyControlFlags {
CONTROL_FLAG_NONE = 0x00,
CONTROL_FLAG_FIN = 0x01,
};
enum SpdyPingFlags {
PING_FLAG_ACK = 0x01,
};
// Used by HEADERS, PUSH_PROMISE, and CONTINUATION.
enum SpdyHeadersFlags {
HEADERS_FLAG_END_HEADERS = 0x04,
HEADERS_FLAG_PADDED = 0x08,
HEADERS_FLAG_PRIORITY = 0x20,
};
enum SpdyPushPromiseFlags {
PUSH_PROMISE_FLAG_END_PUSH_PROMISE = 0x04,
PUSH_PROMISE_FLAG_PADDED = 0x08,
};
enum Http2SettingsControlFlags {
SETTINGS_FLAG_ACK = 0x01,
};
// Wire values of HTTP/2 setting identifiers.
enum SpdyKnownSettingsId : SpdySettingsId {
// HPACK header table maximum size.
SETTINGS_HEADER_TABLE_SIZE = 0x1,
SETTINGS_MIN = SETTINGS_HEADER_TABLE_SIZE,
// Whether or not server push (PUSH_PROMISE) is enabled.
SETTINGS_ENABLE_PUSH = 0x2,
// The maximum number of simultaneous live streams in each direction.
SETTINGS_MAX_CONCURRENT_STREAMS = 0x3,
// Initial window size in bytes
SETTINGS_INITIAL_WINDOW_SIZE = 0x4,
// The size of the largest frame payload that a receiver is willing to accept.
SETTINGS_MAX_FRAME_SIZE = 0x5,
// The maximum size of header list that the sender is prepared to accept.
SETTINGS_MAX_HEADER_LIST_SIZE = 0x6,
// Enable Websockets over HTTP/2, see
// https://httpwg.org/specs/rfc8441.html
SETTINGS_ENABLE_CONNECT_PROTOCOL = 0x8,
// Disable HTTP/2 priorities, see
// https://tools.ietf.org/html/draft-ietf-httpbis-priority-02.
SETTINGS_DEPRECATE_HTTP2_PRIORITIES = 0x9,
SETTINGS_MAX = SETTINGS_DEPRECATE_HTTP2_PRIORITIES,
// Experimental setting used to configure an alternative write scheduler.
SETTINGS_EXPERIMENT_SCHEDULER = 0xFF45,
};
// This explicit operator is needed, otherwise compiler finds
// overloaded operator to be ambiguous.
QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
SpdyKnownSettingsId id);
// This operator is needed, because SpdyFrameType is an enum class,
// therefore implicit conversion to underlying integer type is not allowed.
QUICHE_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
SpdyFrameType frame_type);
using SettingsMap = std::map<SpdySettingsId, uint32_t>;
// HTTP/2 error codes, RFC 7540 Section 7.
enum SpdyErrorCode : uint32_t {
ERROR_CODE_NO_ERROR = 0x0,
ERROR_CODE_PROTOCOL_ERROR = 0x1,
ERROR_CODE_INTERNAL_ERROR = 0x2,
ERROR_CODE_FLOW_CONTROL_ERROR = 0x3,
ERROR_CODE_SETTINGS_TIMEOUT = 0x4,
ERROR_CODE_STREAM_CLOSED = 0x5,
ERROR_CODE_FRAME_SIZE_ERROR = 0x6,
ERROR_CODE_REFUSED_STREAM = 0x7,
ERROR_CODE_CANCEL = 0x8,
ERROR_CODE_COMPRESSION_ERROR = 0x9,
ERROR_CODE_CONNECT_ERROR = 0xa,
ERROR_CODE_ENHANCE_YOUR_CALM = 0xb,
ERROR_CODE_INADEQUATE_SECURITY = 0xc,
ERROR_CODE_HTTP_1_1_REQUIRED = 0xd,
ERROR_CODE_MAX = ERROR_CODE_HTTP_1_1_REQUIRED
};
// Type of priority write scheduler.
enum class WriteSchedulerType {
LIFO, // Last added stream has the highest priority.
SPDY, // Uses SPDY priorities described in
// https://www.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3-1#TOC-2.3.3-Stream-priority.
HTTP2, // Uses HTTP2 (tree-style) priority described in
// https://tools.ietf.org/html/rfc7540#section-5.3.
FIFO, // Stream with the smallest stream ID has the highest priority.
};
// A SPDY priority is a number between 0 and 7 (inclusive).
typedef uint8_t SpdyPriority;
// Lowest and Highest here refer to SPDY priorities as described in
// https://www.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3-1#TOC-2.3.3-Stream-priority
const SpdyPriority kV3HighestPriority = 0;
const SpdyPriority kV3LowestPriority = 7;
// Returns SPDY 3.x priority value clamped to the valid range of [0, 7].
QUICHE_EXPORT_PRIVATE SpdyPriority ClampSpdy3Priority(SpdyPriority priority);
// HTTP/2 stream weights are integers in range [1, 256], as specified in RFC
// 7540 section 5.3.2. Default stream weight is defined in section 5.3.5.
const int kHttp2MinStreamWeight = 1;
const int kHttp2MaxStreamWeight = 256;
const int kHttp2DefaultStreamWeight = 16;
// Returns HTTP/2 weight clamped to the valid range of [1, 256].
QUICHE_EXPORT_PRIVATE int ClampHttp2Weight(int weight);
// Maps SPDY 3.x priority value in range [0, 7] to HTTP/2 weight value in range
// [1, 256], where priority 0 (i.e. highest precedence) corresponds to maximum
// weight 256 and priority 7 (lowest precedence) corresponds to minimum weight
// 1.
QUICHE_EXPORT_PRIVATE int Spdy3PriorityToHttp2Weight(SpdyPriority priority);
// Maps HTTP/2 weight value in range [1, 256] to SPDY 3.x priority value in
// range [0, 7], where minimum weight 1 corresponds to priority 7 (lowest
// precedence) and maximum weight 256 corresponds to priority 0 (highest
// precedence).
QUICHE_EXPORT_PRIVATE SpdyPriority Http2WeightToSpdy3Priority(int weight);
// Reserved ID for root stream of HTTP/2 stream dependency tree, as specified
// in RFC 7540 section 5.3.1.
const unsigned int kHttp2RootStreamId = 0;
typedef uint64_t SpdyPingId;
// Returns true if a given on-the-wire enumeration of a frame type is defined
// in a standardized HTTP/2 specification, false otherwise.
QUICHE_EXPORT_PRIVATE bool IsDefinedFrameType(uint8_t frame_type_field);
// Parses a frame type from an on-the-wire enumeration.
// Behavior is undefined for invalid frame type fields; consumers should first
// use IsValidFrameType() to verify validity of frame type fields.
QUICHE_EXPORT_PRIVATE SpdyFrameType ParseFrameType(uint8_t frame_type_field);
// Serializes a frame type to the on-the-wire value.
QUICHE_EXPORT_PRIVATE uint8_t SerializeFrameType(SpdyFrameType frame_type);
// (HTTP/2) All standard frame types except WINDOW_UPDATE are
// (stream-specific xor connection-level). Returns false iff we know
// the given frame type does not align with the given streamID.
QUICHE_EXPORT_PRIVATE bool IsValidHTTP2FrameStreamId(
SpdyStreamId current_frame_stream_id,
SpdyFrameType frame_type_field);
// Serialize |frame_type| to string for logging/debugging.
const char* FrameTypeToString(SpdyFrameType frame_type);
// If |wire_setting_id| is the on-the-wire representation of a defined SETTINGS
// parameter, parse it to |*setting_id| and return true.
QUICHE_EXPORT_PRIVATE bool ParseSettingsId(SpdySettingsId wire_setting_id,
SpdyKnownSettingsId* setting_id);
// Returns a string representation of the |id| for logging/debugging. Returns
// the |id| prefixed with "SETTINGS_UNKNOWN_" for unknown SETTINGS IDs. To parse
// the |id| into a SpdyKnownSettingsId (if applicable), use ParseSettingsId().
QUICHE_EXPORT_PRIVATE std::string SettingsIdToString(SpdySettingsId id);
// Parse |wire_error_code| to a SpdyErrorCode.
// Treat unrecognized error codes as INTERNAL_ERROR
// as recommended by the HTTP/2 specification.
QUICHE_EXPORT_PRIVATE SpdyErrorCode ParseErrorCode(uint32_t wire_error_code);
// Serialize RST_STREAM or GOAWAY frame error code to string
// for logging/debugging.
const char* ErrorCodeToString(SpdyErrorCode error_code);
// Serialize |type| to string for logging/debugging.
QUICHE_EXPORT_PRIVATE const char* WriteSchedulerTypeToString(
WriteSchedulerType type);
// Minimum size of a frame, in octets.
const size_t kFrameMinimumSize = kFrameHeaderSize;
// Minimum frame size for variable size frame types (includes mandatory fields),
// frame size for fixed size frames, in octets.
const size_t kDataFrameMinimumSize = kFrameHeaderSize;
const size_t kHeadersFrameMinimumSize = kFrameHeaderSize;
// PRIORITY frame has stream_dependency (4 octets) and weight (1 octet) fields.
const size_t kPriorityFrameSize = kFrameHeaderSize + 5;
// RST_STREAM frame has error_code (4 octets) field.
const size_t kRstStreamFrameSize = kFrameHeaderSize + 4;
const size_t kSettingsFrameMinimumSize = kFrameHeaderSize;
const size_t kSettingsOneSettingSize =
sizeof(uint32_t) + sizeof(SpdySettingsId);
// PUSH_PROMISE frame has promised_stream_id (4 octet) field.
const size_t kPushPromiseFrameMinimumSize = kFrameHeaderSize + 4;
// PING frame has opaque_bytes (8 octet) field.
const size_t kPingFrameSize = kFrameHeaderSize + 8;
// GOAWAY frame has last_stream_id (4 octet) and error_code (4 octet) fields.
const size_t kGoawayFrameMinimumSize = kFrameHeaderSize + 8;
// WINDOW_UPDATE frame has window_size_increment (4 octet) field.
const size_t kWindowUpdateFrameSize = kFrameHeaderSize + 4;
const size_t kContinuationFrameMinimumSize = kFrameHeaderSize;
// ALTSVC frame has origin_len (2 octets) field.
const size_t kGetAltSvcFrameMinimumSize = kFrameHeaderSize + 2;
// PRIORITY_UPDATE frame has prioritized_stream_id (4 octets) field.
const size_t kPriorityUpdateFrameMinimumSize = kFrameHeaderSize + 4;
// ACCEPT_CH frame may have empty payload.
const size_t kAcceptChFrameMinimumSize = kFrameHeaderSize;
// Each ACCEPT_CH frame entry has a 16-bit origin length and a 16-bit value
// length.
const size_t kAcceptChFramePerEntryOverhead = 4;
// Maximum possible configurable size of a frame in octets.
const size_t kMaxFrameSizeLimit = kSpdyMaxFrameSizeLimit + kFrameHeaderSize;
// Size of a header block size field.
const size_t kSizeOfSizeField = sizeof(uint32_t);
// Initial window size for a stream in bytes.
const int32_t kInitialStreamWindowSize = 64 * 1024 - 1;
// Initial window size for a session in bytes.
const int32_t kInitialSessionWindowSize = 64 * 1024 - 1;
// The NPN string for HTTP2, "h2".
extern const char* const kHttp2Npn;
// An estimate size of the HPACK overhead for each header field. 1 bytes for
// indexed literal, 1 bytes for key literal and length encoding, and 2 bytes for
// value literal and length encoding.
const size_t kPerHeaderHpackOverhead = 4;
// Names of pseudo-headers defined for HTTP/2 requests.
QUICHE_EXPORT_PRIVATE extern const char* const kHttp2AuthorityHeader;
QUICHE_EXPORT_PRIVATE extern const char* const kHttp2MethodHeader;
QUICHE_EXPORT_PRIVATE extern const char* const kHttp2PathHeader;
QUICHE_EXPORT_PRIVATE extern const char* const kHttp2SchemeHeader;
QUICHE_EXPORT_PRIVATE extern const char* const kHttp2ProtocolHeader;
// Name of pseudo-header defined for HTTP/2 responses.
QUICHE_EXPORT_PRIVATE extern const char* const kHttp2StatusHeader;
QUICHE_EXPORT_PRIVATE size_t GetNumberRequiredContinuationFrames(size_t size);
// Variant type (i.e. tagged union) that is either a SPDY 3.x priority value,
// or else an HTTP/2 stream dependency tuple {parent stream ID, weight,
// exclusive bit}. Templated to allow for use by QUIC code; SPDY and HTTP/2
// code should use the concrete type instantiation SpdyStreamPrecedence.
template <typename StreamIdType>
class StreamPrecedence {
public:
// Constructs instance that is a SPDY 3.x priority. Clamps priority value to
// the valid range [0, 7].
explicit StreamPrecedence(SpdyPriority priority)
: is_spdy3_priority_(true),
spdy3_priority_(ClampSpdy3Priority(priority)) {}
// Constructs instance that is an HTTP/2 stream weight, parent stream ID, and
// exclusive bit. Clamps stream weight to the valid range [1, 256].
StreamPrecedence(StreamIdType parent_id, int weight, bool is_exclusive)
: is_spdy3_priority_(false),
http2_stream_dependency_{parent_id, ClampHttp2Weight(weight),
is_exclusive} {}
// Intentionally copyable, to support pass by value.
StreamPrecedence(const StreamPrecedence& other) = default;
StreamPrecedence& operator=(const StreamPrecedence& other) = default;
// Returns true if this instance is a SPDY 3.x priority, or false if this
// instance is an HTTP/2 stream dependency.
bool is_spdy3_priority() const { return is_spdy3_priority_; }
// Returns SPDY 3.x priority value. If |is_spdy3_priority()| is true, this is
// the value provided at construction, clamped to the legal priority
// range. Otherwise, it is the HTTP/2 stream weight mapped to a SPDY 3.x
// priority value, where minimum weight 1 corresponds to priority 7 (lowest
// precedence) and maximum weight 256 corresponds to priority 0 (highest
// precedence).
SpdyPriority spdy3_priority() const {
return is_spdy3_priority_
? spdy3_priority_
: Http2WeightToSpdy3Priority(http2_stream_dependency_.weight);
}
// Returns HTTP/2 parent stream ID. If |is_spdy3_priority()| is false, this is
// the value provided at construction, otherwise it is |kHttp2RootStreamId|.
StreamIdType parent_id() const {
return is_spdy3_priority_ ? kHttp2RootStreamId
: http2_stream_dependency_.parent_id;
}
// Returns HTTP/2 stream weight. If |is_spdy3_priority()| is false, this is
// the value provided at construction, clamped to the legal weight
// range. Otherwise, it is the SPDY 3.x priority value mapped to an HTTP/2
// stream weight, where priority 0 (i.e. highest precedence) corresponds to
// maximum weight 256 and priority 7 (lowest precedence) corresponds to
// minimum weight 1.
int weight() const {
return is_spdy3_priority_ ? Spdy3PriorityToHttp2Weight(spdy3_priority_)
: http2_stream_dependency_.weight;
}
// Returns HTTP/2 parent stream exclusivity. If |is_spdy3_priority()| is
// false, this is the value provided at construction, otherwise it is false.
bool is_exclusive() const {
return !is_spdy3_priority_ && http2_stream_dependency_.is_exclusive;
}
// Facilitates test assertions.
bool operator==(const StreamPrecedence& other) const {
if (is_spdy3_priority()) {
return other.is_spdy3_priority() &&
(spdy3_priority() == other.spdy3_priority());
} else {
return !other.is_spdy3_priority() && (parent_id() == other.parent_id()) &&
(weight() == other.weight()) &&
(is_exclusive() == other.is_exclusive());
}
}
bool operator!=(const StreamPrecedence& other) const {
return !(*this == other);
}
private:
struct Http2StreamDependency {
StreamIdType parent_id;
int weight;
bool is_exclusive;
};
bool is_spdy3_priority_;
union {
SpdyPriority spdy3_priority_;
Http2StreamDependency http2_stream_dependency_;
};
};
typedef StreamPrecedence<SpdyStreamId> SpdyStreamPrecedence;
class SpdyFrameVisitor;
// Intermediate representation for HTTP2 frames.
class QUICHE_EXPORT_PRIVATE SpdyFrameIR {
public:
virtual ~SpdyFrameIR() {}
virtual void Visit(SpdyFrameVisitor* visitor) const = 0;
virtual SpdyFrameType frame_type() const = 0;
SpdyStreamId stream_id() const { return stream_id_; }
virtual bool fin() const;
// Returns an estimate of the size of the serialized frame, without applying
// compression. May not be exact.
virtual size_t size() const = 0;
// Returns the number of bytes of flow control window that would be consumed
// by this frame if written to the wire.
virtual int flow_control_window_consumed() const;
protected:
SpdyFrameIR() : stream_id_(0) {}
explicit SpdyFrameIR(SpdyStreamId stream_id) : stream_id_(stream_id) {}
SpdyFrameIR(const SpdyFrameIR&) = delete;
SpdyFrameIR& operator=(const SpdyFrameIR&) = delete;
private:
SpdyStreamId stream_id_;
};
// Abstract class intended to be inherited by IRs that have the option of a FIN
// flag.
class QUICHE_EXPORT_PRIVATE SpdyFrameWithFinIR : public SpdyFrameIR {
public:
~SpdyFrameWithFinIR() override {}
bool fin() const override;
void set_fin(bool fin) { fin_ = fin; }
protected:
explicit SpdyFrameWithFinIR(SpdyStreamId stream_id)
: SpdyFrameIR(stream_id), fin_(false) {}
SpdyFrameWithFinIR(const SpdyFrameWithFinIR&) = delete;
SpdyFrameWithFinIR& operator=(const SpdyFrameWithFinIR&) = delete;
private:
bool fin_;
};
// Abstract class intended to be inherited by IRs that contain a header
// block. Implies SpdyFrameWithFinIR.
class QUICHE_EXPORT_PRIVATE SpdyFrameWithHeaderBlockIR
: public SpdyFrameWithFinIR {
public:
~SpdyFrameWithHeaderBlockIR() override;
const Http2HeaderBlock& header_block() const { return header_block_; }
void set_header_block(Http2HeaderBlock header_block) {
// Deep copy.
header_block_ = std::move(header_block);
}
void SetHeader(absl::string_view name, absl::string_view value) {
header_block_[name] = value;
}
protected:
SpdyFrameWithHeaderBlockIR(SpdyStreamId stream_id,
Http2HeaderBlock header_block);
SpdyFrameWithHeaderBlockIR(const SpdyFrameWithHeaderBlockIR&) = delete;
SpdyFrameWithHeaderBlockIR& operator=(const SpdyFrameWithHeaderBlockIR&) =
delete;
private:
Http2HeaderBlock header_block_;
};
class QUICHE_EXPORT_PRIVATE SpdyDataIR : public SpdyFrameWithFinIR {
public:
// Performs a deep copy on data.
SpdyDataIR(SpdyStreamId stream_id, absl::string_view data);
// Performs a deep copy on data.
SpdyDataIR(SpdyStreamId stream_id, const char* data);
// Moves data into data_store_. Makes a copy if passed a non-movable string.
SpdyDataIR(SpdyStreamId stream_id, std::string data);
// Use in conjunction with SetDataShallow() for shallow-copy on data.
explicit SpdyDataIR(SpdyStreamId stream_id);
SpdyDataIR(const SpdyDataIR&) = delete;
SpdyDataIR& operator=(const SpdyDataIR&) = delete;
~SpdyDataIR() override;
const char* data() const { return data_; }
size_t data_len() const { return data_len_; }
bool padded() const { return padded_; }
int padding_payload_len() const { return padding_payload_len_; }
void set_padding_len(int padding_len) {
QUICHE_DCHECK_GT(padding_len, 0);
QUICHE_DCHECK_LE(padding_len, kPaddingSizePerFrame);
padded_ = true;
// The pad field takes one octet on the wire.
padding_payload_len_ = padding_len - 1;
}
// Deep-copy of data (keep private copy).
void SetDataDeep(absl::string_view data) {
data_store_ = std::make_unique<std::string>(data.data(), data.size());
data_ = data_store_->data();
data_len_ = data.size();
}
// Shallow-copy of data (do not keep private copy).
void SetDataShallow(absl::string_view data) {
data_store_.reset();
data_ = data.data();
data_len_ = data.size();
}
// Use this method if we don't have a contiguous buffer and only
// need a length.
void SetDataShallow(size_t len) {
data_store_.reset();
data_ = nullptr;
data_len_ = len;
}
void Visit(SpdyFrameVisitor* visitor) const override;
SpdyFrameType frame_type() const override;
int flow_control_window_consumed() const override;
size_t size() const override;
private:
// Used to store data that this SpdyDataIR should own.
std::unique_ptr<std::string> data_store_;
const char* data_;
size_t data_len_;
bool padded_;
// padding_payload_len_ = desired padding length - len(padding length field).
int padding_payload_len_;
};
class QUICHE_EXPORT_PRIVATE SpdyRstStreamIR : public SpdyFrameIR {
public:
SpdyRstStreamIR(SpdyStreamId stream_id, SpdyErrorCode error_code);
SpdyRstStreamIR(const SpdyRstStreamIR&) = delete;
SpdyRstStreamIR& operator=(const SpdyRstStreamIR&) = delete;
~SpdyRstStreamIR() override;
SpdyErrorCode error_code() const { return error_code_; }
void set_error_code(SpdyErrorCode error_code) { error_code_ = error_code; }
void Visit(SpdyFrameVisitor* visitor) const override;
SpdyFrameType frame_type() const override;
size_t size() const override;
private:
SpdyErrorCode error_code_;
};
class QUICHE_EXPORT_PRIVATE SpdySettingsIR : public SpdyFrameIR {
public:
SpdySettingsIR();
SpdySettingsIR(const SpdySettingsIR&) = delete;
SpdySettingsIR& operator=(const SpdySettingsIR&) = delete;
~SpdySettingsIR() override;
// Overwrites as appropriate.
const SettingsMap& values() const { return values_; }
void AddSetting(SpdySettingsId id, int32_t value) { values_[id] = value; }
bool is_ack() const { return is_ack_; }
void set_is_ack(bool is_ack) { is_ack_ = is_ack; }
void Visit(SpdyFrameVisitor* visitor) const override;
SpdyFrameType frame_type() const override;
size_t size() const override;
private:
SettingsMap values_;
bool is_ack_;
};
class QUICHE_EXPORT_PRIVATE SpdyPingIR : public SpdyFrameIR {
public:
explicit SpdyPingIR(SpdyPingId id) : id_(id), is_ack_(false) {}
SpdyPingIR(const SpdyPingIR&) = delete;
SpdyPingIR& operator=(const SpdyPingIR&) = delete;
SpdyPingId id() const { return id_; }
bool is_ack() const { return is_ack_; }
void set_is_ack(bool is_ack) { is_ack_ = is_ack; }
void Visit(SpdyFrameVisitor* visitor) const override;
SpdyFrameType frame_type() const override;
size_t size() const override;
private:
SpdyPingId id_;
bool is_ack_;
};
class QUICHE_EXPORT_PRIVATE SpdyGoAwayIR : public SpdyFrameIR {
public:
// References description, doesn't copy it, so description must outlast
// this SpdyGoAwayIR.
SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
SpdyErrorCode error_code,
absl::string_view description);
// References description, doesn't copy it, so description must outlast
// this SpdyGoAwayIR.
SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
SpdyErrorCode error_code,
const char* description);
// Moves description into description_store_, so caller doesn't need to
// keep description live after constructing this SpdyGoAwayIR.
SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
SpdyErrorCode error_code,
std::string description);
SpdyGoAwayIR(const SpdyGoAwayIR&) = delete;
SpdyGoAwayIR& operator=(const SpdyGoAwayIR&) = delete;
~SpdyGoAwayIR() override;
SpdyStreamId last_good_stream_id() const { return last_good_stream_id_; }
void set_last_good_stream_id(SpdyStreamId last_good_stream_id) {
QUICHE_DCHECK_EQ(0u, last_good_stream_id & ~kStreamIdMask);
last_good_stream_id_ = last_good_stream_id;
}
SpdyErrorCode error_code() const { return error_code_; }
void set_error_code(SpdyErrorCode error_code) {
// TODO(hkhalil): Check valid ranges of error_code?
error_code_ = error_code;
}
const absl::string_view& description() const { return description_; }
void Visit(SpdyFrameVisitor* visitor) const override;
SpdyFrameType frame_type() const override;
size_t size() const override;
private:
SpdyStreamId last_good_stream_id_;
SpdyErrorCode error_code_;
const std::string description_store_;
const absl::string_view description_;
};
class QUICHE_EXPORT_PRIVATE SpdyHeadersIR : public SpdyFrameWithHeaderBlockIR {
public:
explicit SpdyHeadersIR(SpdyStreamId stream_id)
: SpdyHeadersIR(stream_id, Http2HeaderBlock()) {}
SpdyHeadersIR(SpdyStreamId stream_id, Http2HeaderBlock header_block)
: SpdyFrameWithHeaderBlockIR(stream_id, std::move(header_block)) {}
SpdyHeadersIR(const SpdyHeadersIR&) = delete;
SpdyHeadersIR& operator=(const SpdyHeadersIR&) = delete;
void Visit(SpdyFrameVisitor* visitor) const override;
SpdyFrameType frame_type() const override;
size_t size() const override;
bool has_priority() const { return has_priority_; }
void set_has_priority(bool has_priority) { has_priority_ = has_priority; }
int weight() const { return weight_; }
void set_weight(int weight) { weight_ = weight; }
SpdyStreamId parent_stream_id() const { return parent_stream_id_; }
void set_parent_stream_id(SpdyStreamId id) { parent_stream_id_ = id; }
bool exclusive() const { return exclusive_; }
void set_exclusive(bool exclusive) { exclusive_ = exclusive; }
bool padded() const { return padded_; }
int padding_payload_len() const { return padding_payload_len_; }
void set_padding_len(int padding_len) {
QUICHE_DCHECK_GT(padding_len, 0);
QUICHE_DCHECK_LE(padding_len, kPaddingSizePerFrame);
padded_ = true;
// The pad field takes one octet on the wire.
padding_payload_len_ = padding_len - 1;
}
private:
bool has_priority_ = false;
int weight_ = kHttp2DefaultStreamWeight;
SpdyStreamId parent_stream_id_ = 0;
bool exclusive_ = false;
bool padded_ = false;
int padding_payload_len_ = 0;
};
class QUICHE_EXPORT_PRIVATE SpdyWindowUpdateIR : public SpdyFrameIR {
public:
SpdyWindowUpdateIR(SpdyStreamId stream_id, int32_t delta)
: SpdyFrameIR(stream_id) {
set_delta(delta);
}
SpdyWindowUpdateIR(const SpdyWindowUpdateIR&) = delete;
SpdyWindowUpdateIR& operator=(const SpdyWindowUpdateIR&) = delete;
int32_t delta() const { return delta_; }
void set_delta(int32_t delta) {
QUICHE_DCHECK_LE(0, delta);
QUICHE_DCHECK_LE(delta, kSpdyMaximumWindowSize);
delta_ = delta;
}
void Visit(SpdyFrameVisitor* visitor) const override;
SpdyFrameType frame_type() const override;
size_t size() const override;
private:
int32_t delta_;
};
class QUICHE_EXPORT_PRIVATE SpdyPushPromiseIR
: public SpdyFrameWithHeaderBlockIR {
public:
SpdyPushPromiseIR(SpdyStreamId stream_id, SpdyStreamId promised_stream_id)
: SpdyPushPromiseIR(stream_id, promised_stream_id, Http2HeaderBlock()) {}
SpdyPushPromiseIR(SpdyStreamId stream_id,
SpdyStreamId promised_stream_id,
Http2HeaderBlock header_block)
: SpdyFrameWithHeaderBlockIR(stream_id, std::move(header_block)),
promised_stream_id_(promised_stream_id),
padded_(false),
padding_payload_len_(0) {}
SpdyPushPromiseIR(const SpdyPushPromiseIR&) = delete;
SpdyPushPromiseIR& operator=(const SpdyPushPromiseIR&) = delete;
SpdyStreamId promised_stream_id() const { return promised_stream_id_; }
void Visit(SpdyFrameVisitor* visitor) const override;
SpdyFrameType frame_type() const override;
size_t size() const override;
bool padded() const { return padded_; }
int padding_payload_len() const { return padding_payload_len_; }
void set_padding_len(int padding_len) {
QUICHE_DCHECK_GT(padding_len, 0);
QUICHE_DCHECK_LE(padding_len, kPaddingSizePerFrame);
padded_ = true;
// The pad field takes one octet on the wire.
padding_payload_len_ = padding_len - 1;
}
private:
SpdyStreamId promised_stream_id_;
bool padded_;
int padding_payload_len_;
};
class QUICHE_EXPORT_PRIVATE SpdyContinuationIR : public SpdyFrameIR {
public:
explicit SpdyContinuationIR(SpdyStreamId stream_id);
SpdyContinuationIR(const SpdyContinuationIR&) = delete;
SpdyContinuationIR& operator=(const SpdyContinuationIR&) = delete;
~SpdyContinuationIR() override;
void Visit(SpdyFrameVisitor* visitor) const override;
SpdyFrameType frame_type() const override;
bool end_headers() const { return end_headers_; }
void set_end_headers(bool end_headers) { end_headers_ = end_headers; }
const std::string& encoding() const { return *encoding_; }
void take_encoding(std::unique_ptr<std::string> encoding) {
encoding_ = std::move(encoding);
}
size_t size() const override;
private:
std::unique_ptr<std::string> encoding_;
bool end_headers_;
};
class QUICHE_EXPORT_PRIVATE SpdyAltSvcIR : public SpdyFrameIR {
public:
explicit SpdyAltSvcIR(SpdyStreamId stream_id);
SpdyAltSvcIR(const SpdyAltSvcIR&) = delete;
SpdyAltSvcIR& operator=(const SpdyAltSvcIR&) = delete;
~SpdyAltSvcIR() override;
std::string origin() const { return origin_; }
const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector() const {
return altsvc_vector_;
}
void set_origin(std::string origin) { origin_ = std::move(origin); }
void add_altsvc(const SpdyAltSvcWireFormat::AlternativeService& altsvc) {
altsvc_vector_.push_back(altsvc);
}
void Visit(SpdyFrameVisitor* visitor) const override;
SpdyFrameType frame_type() const override;
size_t size() const override;
private:
std::string origin_;
SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector_;
};
class QUICHE_EXPORT_PRIVATE SpdyPriorityIR : public SpdyFrameIR {
public:
SpdyPriorityIR(SpdyStreamId stream_id,
SpdyStreamId parent_stream_id,
int weight,
bool exclusive)
: SpdyFrameIR(stream_id),
parent_stream_id_(parent_stream_id),
weight_(weight),
exclusive_(exclusive) {}
SpdyPriorityIR(const SpdyPriorityIR&) = delete;
SpdyPriorityIR& operator=(const SpdyPriorityIR&) = delete;
SpdyStreamId parent_stream_id() const { return parent_stream_id_; }
int weight() const { return weight_; }
bool exclusive() const { return exclusive_; }
void Visit(SpdyFrameVisitor* visitor) const override;
SpdyFrameType frame_type() const override;
size_t size() const override;
private:
SpdyStreamId parent_stream_id_;
int weight_;
bool exclusive_;
};
class QUICHE_EXPORT_PRIVATE SpdyPriorityUpdateIR : public SpdyFrameIR {
public:
SpdyPriorityUpdateIR(SpdyStreamId stream_id,
SpdyStreamId prioritized_stream_id,
std::string priority_field_value)
: SpdyFrameIR(stream_id),
prioritized_stream_id_(prioritized_stream_id),
priority_field_value_(std::move(priority_field_value)) {}
SpdyPriorityUpdateIR(const SpdyPriorityUpdateIR&) = delete;
SpdyPriorityUpdateIR& operator=(const SpdyPriorityUpdateIR&) = delete;
SpdyStreamId prioritized_stream_id() const { return prioritized_stream_id_; }
const std::string& priority_field_value() const {
return priority_field_value_;
}
void Visit(SpdyFrameVisitor* visitor) const override;
SpdyFrameType frame_type() const override;
size_t size() const override;
private:
SpdyStreamId prioritized_stream_id_;
std::string priority_field_value_;
};
struct AcceptChOriginValuePair {
std::string origin;
std::string value;
bool operator==(const AcceptChOriginValuePair& rhs) const {
return origin == rhs.origin && value == rhs.value;
}
};
class QUICHE_EXPORT_PRIVATE SpdyAcceptChIR : public SpdyFrameIR {
public:
SpdyAcceptChIR(std::vector<AcceptChOriginValuePair> entries)
: entries_(std::move(entries)) {}
SpdyAcceptChIR(const SpdyAcceptChIR&) = delete;
SpdyAcceptChIR& operator=(const SpdyAcceptChIR&) = delete;
void Visit(SpdyFrameVisitor* visitor) const override;
SpdyFrameType frame_type() const override;
size_t size() const override;
const std::vector<AcceptChOriginValuePair>& entries() const {
return entries_;
}
private:
std::vector<AcceptChOriginValuePair> entries_;
};
// Represents a frame of unrecognized type.
class QUICHE_EXPORT_PRIVATE SpdyUnknownIR : public SpdyFrameIR {
public:
SpdyUnknownIR(SpdyStreamId stream_id,
uint8_t type,
uint8_t flags,
std::string payload)
: SpdyFrameIR(stream_id),
type_(type),
flags_(flags),
length_(payload.size()),
payload_(std::move(payload)) {}
SpdyUnknownIR(const SpdyUnknownIR&) = delete;
SpdyUnknownIR& operator=(const SpdyUnknownIR&) = delete;
uint8_t type() const { return type_; }
uint8_t flags() const { return flags_; }
size_t length() const { return length_; }
const std::string& payload() const { return payload_; }
void Visit(SpdyFrameVisitor* visitor) const override;
SpdyFrameType frame_type() const override;
int flow_control_window_consumed() const override;
size_t size() const override;
protected:
// Allows subclasses to overwrite the default payload length.
void set_length(size_t length) { length_ = length; }
private:
uint8_t type_;
uint8_t flags_;
size_t length_;
const std::string payload_;
};
class QUICHE_EXPORT_PRIVATE SpdySerializedFrame {
public:
SpdySerializedFrame()
: frame_(const_cast<char*>("")), size_(0), owns_buffer_(false) {}
// Create a valid SpdySerializedFrame using a pre-created buffer.
// If |owns_buffer| is true, this class takes ownership of the buffer and will
// delete it on cleanup. The buffer must have been created using new char[].
// If |owns_buffer| is false, the caller retains ownership of the buffer and
// is responsible for making sure the buffer outlives this frame. In other
// words, this class does NOT create a copy of the buffer.
SpdySerializedFrame(char* data, size_t size, bool owns_buffer)
: frame_(data), size_(size), owns_buffer_(owns_buffer) {}
SpdySerializedFrame(SpdySerializedFrame&& other)
: frame_(other.frame_),
size_(other.size_),
owns_buffer_(other.owns_buffer_) {
// |other| is no longer responsible for the buffer.
other.owns_buffer_ = false;
}
SpdySerializedFrame(const SpdySerializedFrame&) = delete;
SpdySerializedFrame& operator=(const SpdySerializedFrame&) = delete;
SpdySerializedFrame& operator=(SpdySerializedFrame&& other) {
// Free buffer if necessary.
if (owns_buffer_) {
delete[] frame_;
}
// Take over |other|.
frame_ = other.frame_;
size_ = other.size_;
owns_buffer_ = other.owns_buffer_;
// |other| is no longer responsible for the buffer.
other.owns_buffer_ = false;
return *this;
}
~SpdySerializedFrame() {
if (owns_buffer_) {
delete[] frame_;
}
}
// Provides access to the frame bytes, which is a buffer containing the frame
// packed as expected for sending over the wire.
char* data() const { return frame_; }
// Returns the actual size of the underlying buffer.
size_t size() const { return size_; }
operator absl::string_view() const {
return absl::string_view{frame_, size_};
}
operator std::string() const { return std::string{frame_, size_}; }
// Returns a buffer containing the contents of the frame, of which the caller
// takes ownership, and clears this SpdySerializedFrame.
char* ReleaseBuffer() {
char* buffer;
if (owns_buffer_) {
// If the buffer is owned, relinquish ownership to the caller.
buffer = frame_;
owns_buffer_ = false;
} else {
// Otherwise, we need to make a copy to give to the caller.
buffer = new char[size_];
memcpy(buffer, frame_, size_);
}
*this = SpdySerializedFrame();
return buffer;
}
// Returns the estimate of dynamically allocated memory in bytes.
size_t EstimateMemoryUsage() const { return owns_buffer_ ? size_ : 0; }
protected:
char* frame_;
private:
size_t size_;
bool owns_buffer_;
};
// This interface is for classes that want to process SpdyFrameIRs without
// having to know what type they are. An instance of this interface can be
// passed to a SpdyFrameIR's Visit method, and the appropriate type-specific
// method of this class will be called.
class QUICHE_EXPORT_PRIVATE SpdyFrameVisitor {
public:
SpdyFrameVisitor() {}
SpdyFrameVisitor(const SpdyFrameVisitor&) = delete;
SpdyFrameVisitor& operator=(const SpdyFrameVisitor&) = delete;
virtual ~SpdyFrameVisitor() {}
virtual void VisitRstStream(const SpdyRstStreamIR& rst_stream) = 0;
virtual void VisitSettings(const SpdySettingsIR& settings) = 0;
virtual void VisitPing(const SpdyPingIR& ping) = 0;
virtual void VisitGoAway(const SpdyGoAwayIR& goaway) = 0;
virtual void VisitHeaders(const SpdyHeadersIR& headers) = 0;
virtual void VisitWindowUpdate(const SpdyWindowUpdateIR& window_update) = 0;
virtual void VisitPushPromise(const SpdyPushPromiseIR& push_promise) = 0;
virtual void VisitContinuation(const SpdyContinuationIR& continuation) = 0;
virtual void VisitAltSvc(const SpdyAltSvcIR& altsvc) = 0;
virtual void VisitPriority(const SpdyPriorityIR& priority) = 0;
virtual void VisitData(const SpdyDataIR& data) = 0;
virtual void VisitPriorityUpdate(
const SpdyPriorityUpdateIR& priority_update) = 0;
virtual void VisitAcceptCh(const SpdyAcceptChIR& accept_ch) = 0;
virtual void VisitUnknown(const SpdyUnknownIR& /*unknown*/) {
// TODO(birenroy): make abstract.
}
};
// Optionally, and in addition to SpdyFramerVisitorInterface, a class supporting
// SpdyFramerDebugVisitorInterface may be used in conjunction with SpdyFramer in
// order to extract debug/internal information about the SpdyFramer as it
// operates.
//
// Most HTTP2 implementations need not bother with this interface at all.
class QUICHE_EXPORT_PRIVATE SpdyFramerDebugVisitorInterface {
public:
virtual ~SpdyFramerDebugVisitorInterface() {}
// Called after compressing a frame with a payload of
// a list of name-value pairs.
// |payload_len| is the uncompressed payload size.
// |frame_len| is the compressed frame size.
virtual void OnSendCompressedFrame(SpdyStreamId /*stream_id*/,
SpdyFrameType /*type*/,
size_t /*payload_len*/,
size_t /*frame_len*/) {}
// Called when a frame containing a compressed payload of
// name-value pairs is received.
// |frame_len| is the compressed frame size.
virtual void OnReceiveCompressedFrame(SpdyStreamId /*stream_id*/,
SpdyFrameType /*type*/,
size_t /*frame_len*/) {}
};
// Calculates the number of bytes required to serialize a SpdyHeadersIR, not
// including the bytes to be used for the encoded header set.
size_t GetHeaderFrameSizeSansBlock(const SpdyHeadersIR& header_ir);
// Calculates the number of bytes required to serialize a SpdyPushPromiseIR,
// not including the bytes to be used for the encoded header set.
size_t GetPushPromiseFrameSizeSansBlock(
const SpdyPushPromiseIR& push_promise_ir);
} // namespace spdy
#endif // QUICHE_SPDY_CORE_SPDY_PROTOCOL_H_