proxygen: proxygen::http2 Namespace Reference

Classes
struct	FrameHeader

struct	PriorityUpdate

Typedefs
using	Padding = folly::Optional< uint8_t >

Enumerations
enum	FrameType : uint8_t { FrameType::DATA = 0, FrameType::HEADERS = 1, PRIORITY = 2, FrameType::RST_STREAM = 3, FrameType::SETTINGS = 4, FrameType::PUSH_PROMISE = 5, FrameType::PING = 6, FrameType::GOAWAY = 7, FrameType::WINDOW_UPDATE = 8, FrameType::CONTINUATION = 9, FrameType::ALTSVC = 10, FrameType::EX_HEADERS = 0xfb, FrameType::CERTIFICATE_REQUEST = 0xf0, FrameType::CERTIFICATE = 0xf1, FrameType::CERTIFICATE_NEEDED = 0xf2, FrameType::USE_CERTIFICATE = 0xf3 }

enum	Flags { ACK = 0x1, END_STREAM = 0x1, END_HEADERS = 0x4, PADDED = 0x8, PRIORITY = 0x20, PRIORITY = 2, UNIDIRECTIONAL = 0x40, UNSOLICITED = 0x1, TO_BE_CONTINUED = 0x1 }

Functions
ErrorCode	filterInvalidStream (ErrorCode code)

ErrorCode	errorCodeToGoaway (ErrorCode code)

ErrorCode	errorCodeToReset (ErrorCode code)

const std::string	kConnectionPreface ("PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n")

const std::string	kProtocolString ("h2")

const std::string	kProtocolDraftString ("h2-14")

const std::string	kProtocolExperimentalString ("h2-fb")

const std::string	kProtocolCleartextString ("h2c")

const std::string	kProtocolSettingsHeader ("HTTP2-Settings")

bool	isValidFrameType (FrameType type)

bool	frameAffectsCompression (FrameType t)

bool	frameHasPadding (const FrameHeader &header)

ErrorCode	parseFrameHeader (Cursor &cursor, FrameHeader &header) noexcept

ErrorCode	parseData (Cursor &cursor, const FrameHeader &header, std::unique_ptr< IOBuf > &outBuf, uint16_t &outPadding) noexcept

ErrorCode	parseDataBegin (Cursor &cursor, const FrameHeader &header, size_t &, uint16_t &outPadding) noexcept

ErrorCode	parseDataEnd (Cursor &cursor, const size_t bufLen, const size_t pendingDataFramePaddingBytes, size_t &toSkip) noexcept

ErrorCode	parseHeaders (Cursor &cursor, const FrameHeader &header, folly::Optional< PriorityUpdate > &outPriority, std::unique_ptr< IOBuf > &outBuf) noexcept

ErrorCode	parseExHeaders (Cursor &cursor, const FrameHeader &header, HTTPCodec::ExAttributes &outExAttributes, folly::Optional< PriorityUpdate > &outPriority, std::unique_ptr< IOBuf > &outBuf) noexcept

ErrorCode	parsePriority (Cursor &cursor, const FrameHeader &header, PriorityUpdate &outPriority) noexcept

ErrorCode	parseRstStream (Cursor &cursor, const FrameHeader &header, ErrorCode &outCode) noexcept

ErrorCode	parseSettings (Cursor &cursor, const FrameHeader &header, std::deque< SettingPair > &settings) noexcept

ErrorCode	parsePushPromise (Cursor &cursor, const FrameHeader &header, uint32_t &outPromisedStream, std::unique_ptr< IOBuf > &outBuf) noexcept

ErrorCode	parsePing (Cursor &cursor, const FrameHeader &header, uint64_t &outOpaqueData) noexcept

ErrorCode	parseGoaway (Cursor &cursor, const FrameHeader &header, uint32_t &outLastStreamID, ErrorCode &outCode, std::unique_ptr< IOBuf > &outDebugData) noexcept

ErrorCode	parseWindowUpdate (Cursor &cursor, const FrameHeader &header, uint32_t &outAmount) noexcept

ErrorCode	parseContinuation (Cursor &cursor, const FrameHeader &header, std::unique_ptr< IOBuf > &outBuf) noexcept

ErrorCode	parseAltSvc (Cursor &cursor, const FrameHeader &header, uint32_t &outMaxAge, uint32_t &outPort, std::string &outProtocol, std::string &outHost, std::string &outOrigin) noexcept

ErrorCode	parseCertificateRequest (folly::io::Cursor &cursor, const FrameHeader &header, uint16_t &outRequestId, std::unique_ptr< folly::IOBuf > &outAuthRequest) noexcept

ErrorCode	parseCertificate (folly::io::Cursor &cursor, const FrameHeader &header, uint16_t &outCertId, std::unique_ptr< folly::IOBuf > &outAuthenticator) noexcept

size_t	writeData (IOBufQueue &queue, std::unique_ptr< IOBuf > data, uint32_t stream, folly::Optional< uint8_t > padding, bool endStream, bool reuseIOBufHeadroom) noexcept

size_t	writeHeaders (IOBufQueue &queue, std::unique_ptr< IOBuf > headers, uint32_t stream, folly::Optional< PriorityUpdate > priority, folly::Optional< uint8_t > padding, bool endStream, bool endHeaders) noexcept

size_t	writeExHeaders (IOBufQueue &queue, std::unique_ptr< IOBuf > headers, uint32_t stream, const HTTPCodec::ExAttributes &exAttributes, const folly::Optional< PriorityUpdate > &priority, const folly::Optional< uint8_t > &padding, bool endStream, bool endHeaders) noexcept

size_t	writePriority (IOBufQueue &queue, uint32_t stream, PriorityUpdate priority) noexcept

size_t	writeRstStream (IOBufQueue &queue, uint32_t stream, ErrorCode errorCode) noexcept

size_t	writeSettings (IOBufQueue &queue, const std::deque< SettingPair > &settings)

size_t	writeSettingsAck (IOBufQueue &queue)

size_t	writePushPromise (IOBufQueue &queue, uint32_t associatedStream, uint32_t promisedStream, std::unique_ptr< IOBuf > headers, folly::Optional< uint8_t > padding, bool endHeaders) noexcept

size_t	writePing (IOBufQueue &queue, uint64_t opaqueData, bool ack) noexcept

size_t	writeGoaway (IOBufQueue &queue, uint32_t lastStreamID, ErrorCode errorCode, std::unique_ptr< IOBuf > debugData) noexcept

size_t	writeWindowUpdate (IOBufQueue &queue, uint32_t stream, uint32_t amount) noexcept

size_t	writeContinuation (IOBufQueue &queue, uint32_t stream, bool endHeaders, std::unique_ptr< IOBuf > headers) noexcept

size_t	writeAltSvc (IOBufQueue &queue, uint32_t stream, uint32_t maxAge, uint16_t port, StringPiece protocol, StringPiece host, StringPiece origin) noexcept

size_t	writeCertificateRequest (folly::IOBufQueue &writeBuf, uint16_t requestId, std::unique_ptr< folly::IOBuf > authRequest)

size_t	writeCertificate (folly::IOBufQueue &writeBuf, uint16_t certId, std::unique_ptr< folly::IOBuf > authenticator, bool toBeContinued)

const char *	getFrameTypeString (FrameType type)

Variables
const uint32_t	kFrameHeaderSize = 9

const uint32_t	kFrameHeadersBaseMaxSize = kFramePrioritySize + 1

const uint32_t	kFramePrioritySize = 5

const uint32_t	kFrameStreamIDSize = 4

const uint32_t	kFrameRstStreamSize = 4

const uint32_t	kFramePushPromiseSize = 4

const uint32_t	kFramePingSize = 8

const uint32_t	kFrameGoawaySize = 8

const uint32_t	kFrameWindowUpdateSize = 4

const uint32_t	kFrameCertificateRequestSizeBase = 2

const uint32_t	kFrameCertificateSizeBase = 2

const uint32_t	kFrameAltSvcSizeBase = 8

const uint32_t	kMaxFramePayloadLengthMin = (1u << 14)

const uint32_t	kMaxFramePayloadLength = (1u << 24) - 1

const uint32_t	kMaxStreamID = (1u << 31) - 1

const uint32_t	kInitialWindow = (1u << 16) - 1

const uint32_t	kMaxWindowUpdateSize = (1u << 31) - 1

const uint32_t	kMaxHeaderTableSize = (1u << 16)

const uint32_t	kMaxAuthenticatorBufSize = 0x20000

const std::string	kConnectionPreface

const std::string	kProtocolString

const std::string	kProtocolDraftString

const std::string	kProtocolExperimentalString

const std::string	kProtocolCleartextString

const std::string	kProtocolSettingsHeader

const uint8_t	kMinExperimentalFrameType = 0xf0

const Padding	kNoPadding = folly::none

const PriorityUpdate	DefaultPriority {0, false, 15}

Typedef Documentation

using proxygen::http2::Padding = typedef folly::Optional<uint8_t>

Definition at line 30 of file HTTP2Framer.h.

Enumeration Type Documentation

enum proxygen::http2::Flags

Enumerator
ACK
END_STREAM
END_HEADERS
PADDED
PRIORITY
PRIORITY
UNIDIRECTIONAL
UNSOLICITED
TO_BE_CONTINUED

Definition at line 59 of file HTTP2Framer.h.

            {
   ACK = 0x1,
   END_STREAM = 0x1,
   END_HEADERS = 0x4,
   PADDED = 0x8,
   PRIORITY = 0x20,
   // experimental flag for EX stream only
   UNIDIRECTIONAL = 0x40,
 
   // for secondary certificate authentication frames
   UNSOLICITED = 0x1,
   TO_BE_CONTINUED = 0x1,
 };

enum proxygen::http2::FrameType : uint8_t

strong

Enumerator
DATA
HEADERS
PRIORITY
RST_STREAM
SETTINGS
PUSH_PROMISE
PING
GOAWAY
WINDOW_UPDATE
CONTINUATION
ALTSVC
EX_HEADERS
CERTIFICATE_REQUEST
CERTIFICATE
CERTIFICATE_NEEDED
USE_CERTIFICATE

Definition at line 35 of file HTTP2Framer.h.

                      : uint8_t {
   DATA = 0,
   HEADERS = 1,
   PRIORITY = 2,
   RST_STREAM = 3,
   SETTINGS = 4,
   PUSH_PROMISE = 5,
   PING = 6,
   GOAWAY = 7,
   WINDOW_UPDATE = 8,
   CONTINUATION = 9,
   ALTSVC = 10, // not in current draft so frame type has not been assigned
 
   // experimental use
   EX_HEADERS = 0xfb,
 
   // For secondary certificate authentication in HTTP/2 as specified in the
   // draft-ietf-httpbis-http2-secondary-certs-02.
   CERTIFICATE_REQUEST = 0xf0,
   CERTIFICATE = 0xf1,
   CERTIFICATE_NEEDED = 0xf2,
   USE_CERTIFICATE = 0xf3,
 };

Function Documentation

ErrorCode proxygen::http2::errorCodeToGoaway ( ErrorCode code )

Definition at line 22 of file HTTP2Constants.cpp.

References filterInvalidStream().

Referenced by proxygen::HTTP2Codec::generateGoaway().

                                             {
   return filterInvalidStream(code);
 }

ErrorCode proxygen::http2::errorCodeToReset ( ErrorCode code )

Definition at line 26 of file HTTP2Constants.cpp.

References filterInvalidStream().

Referenced by proxygen::HTTP2Codec::generateRstStream().

                                            {
   return filterInvalidStream(code);
 }

ErrorCode proxygen::http2::filterInvalidStream ( ErrorCode code )

Definition at line 14 of file HTTP2Constants.cpp.

References proxygen::_SPDY_INVALID_STREAM, and proxygen::STREAM_CLOSED.

Referenced by errorCodeToGoaway(), and errorCodeToReset().

                                               {
   // _SPDY_INVALID_STREAM is SPDY specific, filter it out
   if (code == ErrorCode::_SPDY_INVALID_STREAM) {
     return ErrorCode::STREAM_CLOSED;
   }
   return code;
 }

bool proxygen::http2::frameAffectsCompression ( FrameType t )

Definition at line 244 of file HTTP2Framer.cpp.

References proxygen::spdy::HEADERS.

Referenced by proxygen::HTTP2Codec::parseFrame().

                                           {
   return t == FrameType::HEADERS ||
     t == FrameType::PUSH_PROMISE ||
     t == FrameType::CONTINUATION;
 }

bool proxygen::http2::frameHasPadding ( const FrameHeader & header )

This function returns true if the padding bit is set in the header

Parameters

header The frame header.

Returns: true if the padding bit is set, false otherwise.

Definition at line 250 of file HTTP2Framer.cpp.

References proxygen::http2::FrameHeader::flags, and PADDED.

Referenced by parseData(), parseDataBegin(), and proxygen::HTTP2Codec::parseDataFrameData().

                                                   {
     return header.flags & PADDED;
   }

const char * proxygen::http2::getFrameTypeString ( FrameType type )

Get the string representation of the given FrameType

Parameters

type	frame type

Returns: string representation of the frame type

Definition at line 963 of file HTTP2Framer.cpp.

References folly::FATAL, proxygen::spdy::GOAWAY, proxygen::spdy::HEADERS, proxygen::spdy::PING, PRIORITY, proxygen::spdy::RST_STREAM, proxygen::spdy::SETTINGS, and proxygen::spdy::WINDOW_UPDATE.

Referenced by proxygen::HTTP2Codec::onIngress(), and proxygen::HTTP2Codec::parseFrame().

                                                {
   switch (type) {
     case FrameType::DATA: return "DATA";
     case FrameType::HEADERS: return "HEADERS";
     case FrameType::PRIORITY: return "PRIORITY";
     case FrameType::RST_STREAM: return "RST_STREAM";
     case FrameType::SETTINGS: return "SETTINGS";
     case FrameType::PUSH_PROMISE: return "PUSH_PROMISE";
     case FrameType::PING: return "PING";
     case FrameType::GOAWAY: return "GOAWAY";
     case FrameType::WINDOW_UPDATE: return "WINDOW_UPDATE";
     case FrameType::CONTINUATION: return "CONTINUATION";
     case FrameType::ALTSVC: return "ALTSVC";
     case FrameType::CERTIFICATE_REQUEST: return "CERTIFICATE_REQUEST";
     case FrameType::CERTIFICATE: return "CERTIFICATE";
     default:
       // can happen when type was cast from uint8_t
       return "Unknown";
   }
   LOG(FATAL) << "Unreachable";
   return "";
 }

bool proxygen::http2::isValidFrameType ( FrameType type )

Definition at line 226 of file HTTP2Framer.cpp.

References type, uint8_t, and val.

                                       {
   auto val = static_cast<uint8_t>(type);
   if (val < kMinExperimentalFrameType) {
     return val <= static_cast<uint8_t>(FrameType::ALTSVC);
   } else {
     switch (type) {
       case FrameType::EX_HEADERS:
         // Include the frame types added into FrameType enum for secondary
         // authentication.
       case FrameType::CERTIFICATE_REQUEST:
       case FrameType::CERTIFICATE:
         return true;
       default:
         return false;
     }
   }
 }

const std::string proxygen::http2::kConnectionPreface ( "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n" )

const std::string proxygen::http2::kProtocolCleartextString ( "h2c" )

const std::string proxygen::http2::kProtocolDraftString ( "h2-14" )

const std::string proxygen::http2::kProtocolExperimentalString ( "h2-fb" )

const std::string proxygen::http2::kProtocolSettingsHeader ( "HTTP2-Settings" )

const std::string proxygen::http2::kProtocolString ( "h2" )

ErrorCode proxygen::http2::parseAltSvc	(	folly::io::Cursor &	cursor,
		const FrameHeader &	header,
		uint32_t &	outMaxAge,
		uint32_t &	outPort,
		std::string &	outProtocol,
		std::string &	outHost,
		std::string &	outOrigin
	)

noexcept

This function parses the section of the ALTSVC frame after the common frame header. The caller must ensure there is header.length bytes available in the cursor.

Parameters

cursor	The cursor to pull data from.
header	The frame header for the frame being parsed.
outMaxAge	The max age field.
outPort	The port the alternative service is on.
outProtocol	The alternative service protocol string.
outHost	The alternative service host name.
outOrigin	The origin the alternative service is applicable to.

Returns: NO_ERROR for successful parse. The connection error code to return in a GOAWAY frame if failure.

Definition at line 533 of file HTTP2Framer.cpp.

References kFrameAltSvcSizeBase, uint16_t, uint32_t, and uint8_t.

Referenced by TEST_F().

                                            {
   DCHECK_LE(header.length, cursor.totalLength());
   if (header.length < kFrameAltSvcSizeBase) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
   std::unique_ptr<IOBuf> tmpBuf;
 
   outMaxAge = cursor.readBE<uint32_t>();
   outPort = cursor.readBE<uint16_t>();
   const auto protoLen = cursor.readBE<uint8_t>();
   if (header.length < kFrameAltSvcSizeBase + protoLen) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
   outProtocol = cursor.readFixedString(protoLen);
   const auto hostLen = cursor.readBE<uint8_t>();
   if (header.length < kFrameAltSvcSizeBase + protoLen + hostLen) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
   outHost = cursor.readFixedString(hostLen);
   const auto originLen = (header.length - kFrameAltSvcSizeBase -
                           protoLen - hostLen);
   outOrigin = cursor.readFixedString(originLen);
 
   return ErrorCode::NO_ERROR;
 }

ErrorCode proxygen::http2::parseCertificate	(	folly::io::Cursor &	cursor,
		const FrameHeader &	header,
		uint16_t &	outCertId,
		std::unique_ptr< folly::IOBuf > &	outAuthenticator
	)

noexcept

This function parses the section of the CERTIFICATE frame after the common frame header. It pulls header.length bytes from the cursor, so it is the caller's responsibility to ensure there is enough data available.

Parameters

cursor	The cursor to pull data from.
header	The frame header for the frame being parsed.
outCertId	The Cert-ID identifying the frame.
outAuthenticator	Authenticator fragment in the frame, if any.

Returns: NO_ERROR for successful parse. The connection error code to return in a CERTIFICATE frame if failure.

Definition at line 586 of file HTTP2Framer.cpp.

References kFrameCertificateSizeBase, and uint16_t.

Referenced by proxygen::HTTP2Codec::parseCertificate(), and TEST_F().

                                                           {
   DCHECK_LE(header.length, cursor.totalLength());
   if (header.length < kFrameCertificateSizeBase) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
   if (header.stream != 0) {
     return ErrorCode::PROTOCOL_ERROR;
   }
   outCertId = cursor.readBE<uint16_t>();
   auto length = header.length;
   length -= kFrameCertificateSizeBase;
   if (length > 0) {
     cursor.clone(outAuthenticator, length);
   }
   return ErrorCode::NO_ERROR;
 }

ErrorCode proxygen::http2::parseCertificateRequest	(	folly::io::Cursor &	cursor,
		const FrameHeader &	header,
		uint16_t &	outRequestId,
		std::unique_ptr< folly::IOBuf > &	outAuthRequest
	)

noexcept

This function parses the section of the CERTIFICATE_REQUEST frame after the common frame header. It pulls header.length bytes from the cursor, so it is the caller's responsibility to ensure there is enough data available.

Parameters

cursor	The cursor to pull data from.
header	The frame header for the frame being parsed.
outRequestId	The Request-ID identifying this certificate request.
outAuthRequest	Authenticator request in the frame, if any.

Returns: NO_ERROR for successful parse. The connection error code to return in a CERTIFICATE_REQUEST frame if failure.

Definition at line 565 of file HTTP2Framer.cpp.

References kFrameCertificateRequestSizeBase, and uint16_t.

Referenced by proxygen::HTTP2Codec::parseCertificateRequest(), and TEST_F().

                                                         {
   DCHECK_LE(header.length, cursor.totalLength());
   if (header.length < kFrameCertificateRequestSizeBase) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
   if (header.stream != 0) {
     return ErrorCode::PROTOCOL_ERROR;
   }
   outRequestId = cursor.readBE<uint16_t>();
   auto length = header.length;
   length -= kFrameCertificateRequestSizeBase;
   if (length > 0) {
     cursor.clone(outAuthRequest, length);
   }
   return ErrorCode::NO_ERROR;
 }

ErrorCode proxygen::http2::parseContinuation	(	folly::io::Cursor &	cursor,
		const FrameHeader &	header,
		std::unique_ptr< folly::IOBuf > &	outBuf
	)

noexcept

This function parses the section of the CONTINUATION frame after the common frame header. The caller must ensure there is header.length bytes available in the cursor.

Parameters

cursor	The cursor to pull data from.
header	The frame header for the frame being parsed.
outBuf	The buffer to fill with header data.
outAmount	The amount to increment the stream's window by.

Returns: NO_ERROR for successful parse. The connection error code to return in a GOAWAY frame if failure.

Definition at line 520 of file HTTP2Framer.cpp.

Referenced by proxygen::HTTP2Codec::parseContinuation(), and TEST_F().

                                                          {
   DCHECK(header.type == FrameType::CONTINUATION);
   DCHECK_LE(header.length, cursor.totalLength());
   if (header.stream == 0) {
     return ErrorCode::PROTOCOL_ERROR;
   }
   cursor.clone(outBuf, header.length);
   return ErrorCode::NO_ERROR;
 }

ErrorCode proxygen::http2::parseData	(	folly::io::Cursor &	cursor,
		const FrameHeader &	header,
		std::unique_ptr< folly::IOBuf > &	outBuf,
		uint16_t &	padding
	)

noexcept

This function parses the section of the DATA frame after the common frame header. It discards any padding and returns the body data in outBuf. It pulls header.length bytes from the cursor, so it is the caller's responsibility to ensure there is enough data available.

Parameters

cursor	The cursor to pull data from.
header	The frame header for the frame being parsed.
outBuf	The buf to fill with body data.
padding	The number of padding bytes in this data frame

Returns: NO_ERROR for successful parse. The connection error code to return in a GOAWAY frame if failure.

Definition at line 270 of file HTTP2Framer.cpp.

References frameHasPadding(), RETURN_IF_ERROR, uint32_t, and uint8_t.

Referenced by HTTP2FramerTest::dataFrameTest(), proxygen::HTTP2Codec::parseAllData(), and TEST_F().

                                                      {
     DCHECK_LE(header.length, cursor.totalLength());
     if (header.stream == 0) {
       return ErrorCode::PROTOCOL_ERROR;
     }
 
     uint8_t padding;
     uint32_t lefttoparse;
     const auto err = parsePadding(cursor, header, padding, lefttoparse);
     RETURN_IF_ERROR(err);
     // outPadding is the total number of flow-controlled pad bytes, which
     // includes the length byte, if present.
     outPadding = padding + ((frameHasPadding(header)) ? 1 : 0);
     cursor.clone(outBuf, lefttoparse);
     return skipPadding(cursor, padding, kStrictPadding);
   }

ErrorCode proxygen::http2::parseDataBegin	(	Cursor &	cursor,
		const FrameHeader &	header,
		size_t &	,
		uint16_t &	outPadding
	)

noexcept

Definition at line 290 of file HTTP2Framer.cpp.

References frameHasPadding(), RETURN_IF_ERROR, uint32_t, and uint8_t.

Referenced by proxygen::HTTP2Codec::parseDataFrameData().

                                                           {
     uint8_t padding;
     uint32_t lefttoparse;
     const auto err = http2::parsePadding(cursor, header, padding, lefttoparse);
     RETURN_IF_ERROR(err);
     // outPadding is the total number of flow-controlled pad bytes, which
     // includes the length byte, if present.
     outPadding = padding + ((frameHasPadding(header)) ? 1 : 0);
     return ErrorCode::NO_ERROR;
   }

ErrorCode proxygen::http2::parseDataEnd	(	Cursor &	cursor,
		const size_t	bufLen,
		const size_t	pendingDataFramePaddingBytes,
		size_t &	toSkip
	)

noexcept

Definition at line 304 of file HTTP2Framer.cpp.

References min.

Referenced by proxygen::HTTP2Codec::parseDataFrameData().

                                                   {
     toSkip = std::min(pendingDataFramePaddingBytes, bufLen);
     return skipPadding(cursor, toSkip, kStrictPadding);
 }

ErrorCode proxygen::http2::parseExHeaders	(	Cursor &	cursor,
		const FrameHeader &	header,
		HTTPCodec::ExAttributes &	outExAttributes,
		folly::Optional< PriorityUpdate > &	outPriority,
		std::unique_ptr< IOBuf > &	outBuf
	)

noexcept

Definition at line 339 of file HTTP2Framer.cpp.

References kFramePrioritySize, kFrameStreamIDSize, folly::none, PRIORITY, RETURN_IF_ERROR, uint32_t, uint8_t, and UNIDIRECTIONAL.

Referenced by proxygen::HTTP2Codec::parseExHeaders(), and TEST_F().

                                                       {
   DCHECK_LE(header.length, cursor.totalLength());
   if (header.stream == 0) {
     return ErrorCode::PROTOCOL_ERROR;
   }
 
   uint8_t padding;
   uint32_t lefttoparse;
   auto err = parsePadding(cursor, header, padding, lefttoparse);
   RETURN_IF_ERROR(err);
 
   // the regular HEADERS frame starts from here
   if (header.flags & PRIORITY) {
     if (lefttoparse < kFramePrioritySize) {
       return ErrorCode::FRAME_SIZE_ERROR;
     }
     outPriority = parsePriorityCommon(cursor);
     lefttoparse -= kFramePrioritySize;
   } else {
     outPriority = folly::none;
   }
   outExAttributes.unidirectional = header.flags & UNIDIRECTIONAL;
 
   if (lefttoparse < kFrameStreamIDSize) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
   outExAttributes.controlStream = parseUint31(cursor);
   lefttoparse -= kFrameStreamIDSize;
   if (!(outExAttributes.controlStream & 0x1)) {
     // control stream ID should be odd because it is initiated by client
     return ErrorCode::PROTOCOL_ERROR;
   }
 
   cursor.clone(outBuf, lefttoparse);
   return skipPadding(cursor, padding, kStrictPadding);
 }

ErrorCode proxygen::http2::parseFrameHeader	(	folly::io::Cursor &	cursor,
		FrameHeader &	header
	)

noexcept

This function parses the common HTTP/2 frame header. This function pulls kFrameHeaderSize bytes from the cursor, so the caller must check that that amount is available.

Parameters

cursor	The cursor to pull data from.
header	The frame header struct to populate.

Returns: Nothing if success. The connection error code if failure.

Definition at line 256 of file HTTP2Framer.cpp.

References FOLLY_SCOPED_TRACE_SECTION, kFrameHeaderSize, type, uint32_t, and uint8_t.

Referenced by proxygen::HTTP2Codec::onIngress(), HTTP2FramerTest::parse(), and TEST_F().

                                                                              {
     FOLLY_SCOPED_TRACE_SECTION("HTTP2Framer - parseFrameHeader");
     DCHECK_LE(kFrameHeaderSize, cursor.totalLength());
 
     // MUST ignore the 2 bits before the length
     uint32_t lengthAndType = cursor.readBE<uint32_t>();
     header.length = kLengthMask & (lengthAndType >> 8);
     uint8_t type = lengthAndType & 0xff;
     header.type = FrameType(type);
     header.flags = cursor.readBE<uint8_t>();
     header.stream = parseUint31(cursor);
     return ErrorCode::NO_ERROR;
   }

ErrorCode proxygen::http2::parseGoaway	(	folly::io::Cursor &	cursor,
		const FrameHeader &	header,
		uint32_t &	outLastStreamID,
		ErrorCode &	outCode,
		std::unique_ptr< folly::IOBuf > &	outDebugData
	)

noexcept

This function parses the section of the GOAWAY frame after the common frame header. It pulls header.length bytes from the cursor, so it is the caller's responsibility to ensure there is enough data available.

Parameters

cursor	The cursor to pull data from.
header	The frame header for the frame being parsed.
outLastStreamID	The last stream id accepted by the remote.
outCode	The error code received in the frame.
outDebugData	Additional debug-data in the frame, if any

Returns: NO_ERROR for successful parse. The connection error code to return in a GOAWAY frame if failure.

Definition at line 484 of file HTTP2Framer.cpp.

References kFrameGoawaySize, and RETURN_IF_ERROR.

Referenced by proxygen::HTTP2Codec::parseGoaway(), and TEST_F().

                                                          {
   DCHECK_LE(header.length, cursor.totalLength());
   if (header.length < kFrameGoawaySize) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
   if (header.stream != 0) {
     return ErrorCode::PROTOCOL_ERROR;
   }
   outLastStreamID = parseUint31(cursor);
   auto err = parseErrorCode(cursor, outCode);
   RETURN_IF_ERROR(err);
   auto length = header.length;
   length -= kFrameGoawaySize;
   if (length > 0) {
     cursor.clone(outDebugData, length);
   }
   return ErrorCode::NO_ERROR;
 }

ErrorCode proxygen::http2::parseHeaders	(	folly::io::Cursor &	cursor,
		const FrameHeader &	header,
		folly::Optional< PriorityUpdate > &	outPriority,
		std::unique_ptr< folly::IOBuf > &	outBuf
	)

noexcept

This function parses the section of the HEADERS frame after the common frame header. It discards any padding and returns the header data in outBuf. It pulls header.length bytes from the cursor, so it is the caller's responsibility to ensure there is enough data available.

Parameters

cursor	The cursor to pull data from.
header	The frame header for the frame being parsed.
outPriority	If PRIORITY flag is set, this will be filled with the priority information from this frame.
outBuf	The buf to fill with header data.

Returns: NO_ERROR for successful parse. The connection error code to return in a GOAWAY frame if failure.

Definition at line 313 of file HTTP2Framer.cpp.

References kFramePrioritySize, folly::none, PRIORITY, RETURN_IF_ERROR, uint32_t, and uint8_t.

Referenced by proxygen::HTTP2Codec::parseHeaders(), and TEST_F().

                                                     {
   DCHECK_LE(header.length, cursor.totalLength());
   if (header.stream == 0) {
     return ErrorCode::PROTOCOL_ERROR;
   }
   uint8_t padding;
   uint32_t lefttoparse;
   auto err = parsePadding(cursor, header, padding, lefttoparse);
   RETURN_IF_ERROR(err);
   if (header.flags & PRIORITY) {
     if (lefttoparse < kFramePrioritySize) {
       return ErrorCode::FRAME_SIZE_ERROR;
     }
     outPriority = parsePriorityCommon(cursor);
     lefttoparse -= kFramePrioritySize;
   } else {
     outPriority = folly::none;
   }
   cursor.clone(outBuf, lefttoparse);
   return skipPadding(cursor, padding, kStrictPadding);
 }

ErrorCode proxygen::http2::parsePing	(	folly::io::Cursor &	cursor,
		const FrameHeader &	header,
		uint64_t &	outData
	)

noexcept

This function parses the section of the PING frame after the common frame header. It pulls header.length bytes from the cursor, so it is the caller's responsibility to ensure there is enough data available.

Parameters

cursor	The cursor to pull data from.
header	The frame header for the frame being parsed.
outData	The opaque data from the ping frame

Returns: NO_ERROR for successful parse. The connection error code to return in a GOAWAY frame if failure.

Definition at line 467 of file HTTP2Framer.cpp.

References kFramePingSize.

Referenced by proxygen::HTTP2Codec::parsePing(), and TEST_F().

                                             {
   DCHECK_LE(header.length, cursor.totalLength());
 
   if (header.length != kFramePingSize) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
   if (header.stream != 0) {
     return ErrorCode::PROTOCOL_ERROR;
   }
 
   cursor.pull(&outOpaqueData, sizeof(outOpaqueData));
   return ErrorCode::NO_ERROR;
 }

ErrorCode proxygen::http2::parsePriority	(	folly::io::Cursor &	cursor,
		const FrameHeader &	header,
		PriorityUpdate &	outPriority
	)

noexcept

This function parses the section of the PRIORITY frame after the common frame header. It pulls header.length bytes from the cursor, so it is the caller's responsibility to ensure there is enough data available.

Parameters

cursor	The cursor to pull data from.
header	The frame header for the frame being parsed.
outPriority	On success, filled with the priority information from this frame.

Returns: NO_ERROR for successful parse. The connection error code to return in a GOAWAY frame if failure.

Definition at line 381 of file HTTP2Framer.cpp.

References kFramePrioritySize.

Referenced by proxygen::HTTP2Codec::parsePriority(), and TEST_F().

                                                     {
   DCHECK_LE(header.length, cursor.totalLength());
   if (header.length != kFramePrioritySize) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
   if (header.stream == 0) {
     return ErrorCode::PROTOCOL_ERROR;
   }
   outPriority = parsePriorityCommon(cursor);
   return ErrorCode::NO_ERROR;
 }

ErrorCode proxygen::http2::parsePushPromise	(	folly::io::Cursor &	cursor,
		const FrameHeader &	header,
		uint32_t &	outPromisedStream,
		std::unique_ptr< folly::IOBuf > &	outBuf
	)

noexcept

This function parses the section of the PUSH_PROMISE frame after the common frame header. It pulls header.length bytes from the cursor, so it is the caller's responsibility to ensure there is enough data available.

Parameters

cursor	The cursor to pull data from.
header	The frame header for the frame being parsed.
outPromisedStream	The id of the stream promised by the remote.
outBuf	The buffer to fill with header data.

Returns: NO_ERROR for successful parse. The connection error code to return in a GOAWAY frame if failure.

Definition at line 436 of file HTTP2Framer.cpp.

References kFramePushPromiseSize, RETURN_IF_ERROR, uint32_t, and uint8_t.

Referenced by proxygen::HTTP2Codec::parsePushPromise(), and TEST_F().

                                                         {
   DCHECK_LE(header.length, cursor.totalLength());
   if (header.stream == 0) {
     return ErrorCode::PROTOCOL_ERROR;
   }
 
   uint8_t padding;
   uint32_t lefttoparse;
   auto err = parsePadding(cursor, header, padding, lefttoparse);
   RETURN_IF_ERROR(err);
   if (lefttoparse < kFramePushPromiseSize) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
   lefttoparse -= kFramePushPromiseSize;
   outPromisedStream = parseUint31(cursor);
   if (outPromisedStream == 0 ||
       outPromisedStream & 0x1) {
     // client MUST reserve an even stream id greater than 0
     return ErrorCode::PROTOCOL_ERROR;
   }
   if (lefttoparse < padding) {
     return ErrorCode::PROTOCOL_ERROR;
   }
   cursor.clone(outBuf, lefttoparse);
   return skipPadding(cursor, padding, kStrictPadding);
 }

ErrorCode proxygen::http2::parseRstStream	(	folly::io::Cursor &	cursor,
		const FrameHeader &	header,
		ErrorCode &	outCode
	)

noexcept

This function parses the section of the RST_STREAM frame after the common frame header. It pulls header.length bytes from the cursor, so it is the caller's responsibility to ensure there is enough data available.

Parameters

cursor	The cursor to pull data from.
header	The frame header for the frame being parsed.
outCode	The error code received in the frame.

Returns: NO_ERROR for successful parse. The connection error code to return in a GOAWAY frame if failure.

Definition at line 396 of file HTTP2Framer.cpp.

References kFrameRstStreamSize.

Referenced by proxygen::HTTP2Codec::parseRstStream(), and TEST_F().

                                             {
   DCHECK_LE(header.length, cursor.totalLength());
   if (header.length != kFrameRstStreamSize) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
   if (header.stream == 0) {
     return ErrorCode::PROTOCOL_ERROR;
   }
   return parseErrorCode(cursor, outCode);
 }

ErrorCode proxygen::http2::parseSettings	(	folly::io::Cursor &	cursor,
		const FrameHeader &	header,
		std::deque< SettingPair > &	settings
	)

noexcept

This function parses the section of the SETTINGS frame after the common frame header. It pulls header.length bytes from the cursor, so it is the caller's responsibility to ensure there is enough data available.

Parameters

cursor	The cursor to pull data from.
header	The frame header for the frame being parsed.
settings	The settings received in this frame.

Returns: NO_ERROR for successful parse. The connection error code to return in a GOAWAY frame if failure.

Definition at line 410 of file HTTP2Framer.cpp.

References ACK, settings, uint16_t, uint32_t, and val.

Referenced by proxygen::HTTP2Codec::onIngressUpgradeMessage(), proxygen::HTTP2Codec::parseSettings(), and TEST_F().

                                                         {
   DCHECK_LE(header.length, cursor.totalLength());
   if (header.stream != 0) {
     return ErrorCode::PROTOCOL_ERROR;
   }
   if (header.flags & ACK) {
     if (header.length != 0) {
       return ErrorCode::FRAME_SIZE_ERROR;
     }
     return ErrorCode::NO_ERROR;
   }
 
   if (header.length % 6 != 0) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
   for (auto length = header.length; length > 0; length -= 6) {
     uint16_t id = cursor.readBE<uint16_t>();
     uint32_t val = cursor.readBE<uint32_t>();
     settings.push_back(std::make_pair(SettingsId(id), val));
   }
   return ErrorCode::NO_ERROR;
 }

ErrorCode proxygen::http2::parseWindowUpdate	(	folly::io::Cursor &	cursor,
		const FrameHeader &	header,
		uint32_t &	outAmount
	)

noexcept

This function parses the section of the WINDOW_UPDATE frame after the common frame header. The caller must ensure there is header.length bytes available in the cursor.

Parameters

cursor	The cursor to pull data from.
header	The frame header for the frame being parsed.
outAmount	The amount to increment the stream's window by.

Returns: NO_ERROR for successful parse. The connection error code to return in a GOAWAY frame if failure.

Definition at line 508 of file HTTP2Framer.cpp.

References kFrameWindowUpdateSize.

Referenced by proxygen::HTTP2Codec::parseWindowUpdate(), and TEST_F().

                                                 {
   DCHECK_LE(header.length, cursor.totalLength());
   if (header.length != kFrameWindowUpdateSize) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
   outAmount = parseUint31(cursor);
   return ErrorCode::NO_ERROR;
 }

size_t proxygen::http2::writeAltSvc	(	folly::IOBufQueue &	writeBuf,
		uint32_t	stream,
		uint32_t	maxAge,
		uint16_t	port,
		folly::StringPiece	protocol,
		folly::StringPiece	host,
		folly::StringPiece	origin
	)

noexcept

Generate an entire ALTSVC frame, including the common frame header.

Parameters

writeBuf	The output queue to write to. It may grow or add underlying buffers inside this function.
stream	The stream to do Alt-Svc on. May be zero.
maxAge	The max age field.
port	The port the alternative service is on.
protocol	The alternative service protocol string.
host	The alternative service host name.
origin	The origin the alternative service is applicable to.

Returns: The number of bytes written to writeBuf.

Definition at line 890 of file HTTP2Framer.cpp.

References kFrameAltSvcSizeBase, kFrameHeaderSize, folly::none, folly::io::detail::Writable< Derived >::push(), uint16_t, uint32_t, uint8_t, and folly::io::detail::Writable< Derived >::writeBE().

Referenced by TEST_F().

                                          {
   const auto protoLen = protocol.size();
   const auto hostLen = host.size();
   const auto originLen = origin.size();
   const auto frameLen = protoLen + hostLen + originLen + kFrameAltSvcSizeBase;
 
   writeFrameHeader(queue, frameLen, FrameType::ALTSVC, 0, stream, kNoPadding,
                    folly::none, nullptr);
   QueueAppender appender(&queue, frameLen);
   appender.writeBE<uint32_t>(maxAge);
   appender.writeBE<uint16_t>(port);
   appender.writeBE<uint8_t>(protoLen);
   appender.push(reinterpret_cast<const uint8_t*>(protocol.data()), protoLen);
   appender.writeBE<uint8_t>(hostLen);
   appender.push(reinterpret_cast<const uint8_t*>(host.data()), hostLen);
   appender.push(reinterpret_cast<const uint8_t*>(origin.data()), originLen);
   return kFrameHeaderSize + frameLen;
 }

size_t proxygen::http2::writeCertificate	(	folly::IOBufQueue &	writeBuf,
		uint16_t	certId,
		std::unique_ptr< folly::IOBuf >	authenticator,
		bool	toBeContinued
	)

Generate an entire CERTIFICATE frame, including the common frame header.

Parameters

writeBuf	The output queue to write to. It may grow or add underlying buffers inside this function.
certId	The opaque Cert-ID of this frame which is used to correlate subsequent certificate-related frames with this certificate.
authenticator	The encoded authenticator fragment.
toBeContinued	Indicates whether there is additional authenticator fragment.

Returns: The number of bytes written to writeBuf.

Definition at line 936 of file HTTP2Framer.cpp.

References folly::IOBufQueue::append(), folly::IOBuf::computeChainDataLength(), kFrameCertificateSizeBase, kFrameHeaderSize, folly::gen::move, folly::none, TO_BE_CONTINUED, uint16_t, uint8_t, and folly::io::detail::Writable< Derived >::writeBE().

Referenced by proxygen::HTTP2Codec::generateCertificate(), and TEST_F().

                                             {
   uint8_t flags = 0;
   if (toBeContinued) {
     flags |= TO_BE_CONTINUED;
   }
   const auto dataLen =
       authenticator
           ? kFrameCertificateSizeBase + authenticator->computeChainDataLength()
           : kFrameCertificateSizeBase;
   // The CERTIFICATE_REQUEST frame must be sent on stream 0.
   const auto frameLen = writeFrameHeader(writeBuf,
                                          dataLen,
                                          FrameType::CERTIFICATE,
                                          flags,
                                          0,
                                          kNoPadding,
                                          folly::none,
                                          nullptr);
   QueueAppender appender(&writeBuf, frameLen);
   appender.writeBE<uint16_t>(certId);
   writeBuf.append(std::move(authenticator));
   return kFrameHeaderSize + frameLen;
 }

size_t proxygen::http2::writeCertificateRequest	(	folly::IOBufQueue &	writeBuf,
		uint16_t	requestId,
		std::unique_ptr< folly::IOBuf >	authRequest
	)

Generate an entire CERTIFICATE_REQUEST frame, including the common frame header.

Parameters

writeBuf	The output queue to write to. It may grow or add underlying buffers inside this function.
requestId	The opaque Request-ID of this used to correlate subsequent certificate-related frames with this request.
authRequest	The encoded authenticator request.

Returns: The number of bytes written to writeBuf.

Definition at line 915 of file HTTP2Framer.cpp.

References folly::IOBufQueue::append(), folly::IOBuf::computeChainDataLength(), kFrameCertificateRequestSizeBase, kFrameHeaderSize, folly::gen::move, folly::none, uint16_t, and folly::io::detail::Writable< Derived >::writeBE().

Referenced by proxygen::HTTP2Codec::generateCertificateRequest(), and TEST_F().

                                                                       {
   const auto dataLen = authRequest ? kFrameCertificateRequestSizeBase +
                                          authRequest->computeChainDataLength()
                                    : kFrameCertificateRequestSizeBase;
   // The CERTIFICATE_REQUEST frame must be sent on stream 0.
   const auto frameLen = writeFrameHeader(writeBuf,
                                          dataLen,
                                          FrameType::CERTIFICATE_REQUEST,
                                          0,
                                          0,
                                          kNoPadding,
                                          folly::none,
                                          nullptr);
   QueueAppender appender(&writeBuf, frameLen);
   appender.writeBE<uint16_t>(requestId);
   writeBuf.append(std::move(authRequest));
   return kFrameHeaderSize + frameLen;
 }

size_t proxygen::http2::writeContinuation	(	folly::IOBufQueue &	queue,
		uint32_t	stream,
		bool	endHeaders,
		std::unique_ptr< folly::IOBuf >	headers
	)

noexcept

Generate an entire CONTINUATION frame, including the common frame header. The combined length of the data buffer and the padding MUST NOT exceed 2^14 - 3, which is kMaxFramePayloadLength minus the two bytes to encode the length of the padding.

Parameters

writeBuf	The output queue to write to. It may grow or add underlying buffers inside this function.
stream	The stream identifier of the DATA frame.
endHeaders	True iff more CONTINUATION frames will follow.
headers	The encoded headers data to write out.

Returns: The number of bytes written to writeBuf.

Definition at line 872 of file HTTP2Framer.cpp.

References END_HEADERS, kFrameHeaderSize, folly::gen::move, and folly::none.

Referenced by proxygen::HTTP2Codec::generateContinuation(), and TEST_F().

                                                          {
   DCHECK_NE(0, stream);
   const auto dataLen = headers->computeChainDataLength();
   const auto frameLen = writeFrameHeader(queue,
                                          dataLen,
                                          FrameType::CONTINUATION,
                                          endHeaders ? END_HEADERS : 0,
                                          stream,
                                          kNoPadding,
                                          folly::none,
                                          std::move(headers));
   return kFrameHeaderSize + frameLen;
 }

size_t proxygen::http2::writeData	(	folly::IOBufQueue &	writeBuf,
		std::unique_ptr< folly::IOBuf >	data,
		uint32_t	stream,
		folly::Optional< uint8_t >	padding,
		bool	endStream,
		bool	reuseIOBufHeadroom
	)

noexcept

Generate an entire DATA frame, including the common frame header. The combined length of the data buffer, the padding, and the padding length MUST NOT exceed 2^14 - 1, which is kMaxFramePayloadLength.

Parameters

writeBuf	The output queue to write to. It may grow or add underlying buffers inside this function.
data	The body data to write out, can be nullptr for 0 length
stream	The stream identifier of the DATA frame.
padding	If not kNoPadding, adds 1 byte pad len and pad bytes
endStream	True iff this frame ends the stream.
reuseIOBufHeadroom	If HTTP2Framer should reuse headroom in data if headroom is enough for frame header

Returns: The number of bytes written to writeBuf.

Definition at line 610 of file HTTP2Framer.cpp.

References folly::data(), END_STREAM, kFrameHeaderSize, folly::gen::move, folly::none, uint64_t, and uint8_t.

Referenced by HTTP2FramerTest::dataFrameTest(), proxygen::HTTP2Codec::generateBody(), proxygen::HTTP2Codec::generateEOM(), and TEST_F().

                                             {
   DCHECK_NE(0, stream);
   uint8_t flags = 0;
   if (endStream) {
     flags |= END_STREAM;
   }
   const uint64_t dataLen = data ? data->computeChainDataLength() : 0;
   // Caller must not exceed peer setting for MAX_FRAME_SIZE
   // TODO: look into using headroom from data to hold the frame header
   const auto frameLen = writeFrameHeader(queue,
                                          dataLen,
                                          FrameType::DATA,
                                          flags,
                                          stream,
                                          padding,
                                          folly::none,
                                          std::move(data),
                                          reuseIOBufHeadroom);
   writePadding(queue, padding);
   return kFrameHeaderSize + frameLen;
 }

size_t proxygen::http2::writeExHeaders	(	folly::IOBufQueue &	writeBuf,
		std::unique_ptr< folly::IOBuf >	headers,
		uint32_t	stream,
		const HTTPCodec::ExAttributes &	exAttributes,
		const folly::Optional< PriorityUpdate > &	priority,
		const folly::Optional< uint8_t > &	padding,
		bool	endStream,
		bool	endHeaders
	)

noexcept

Generate an experimental ExHEADERS frame, including the common frame header. The combined length of the data buffer and the padding and priority fields MUST NOT exceed 2^14 - 1, which is kMaxFramePayloadLength.

Parameters

writeBuf	The output queue to write to. It may grow or add underlying buffers inside this function.
headers	The encoded headers data to write out.
stream	The stream identifier of the ExHEADERS frame.
exAttributes	Attributes specific to ExHEADERS frame.
priority	If present, the priority depedency information to update the stream with.
padding	If not kNoPadding, adds 1 byte pad len and pad bytes
endStream	True iff this frame ends the stream.
endHeaders	True iff no CONTINUATION frames will follow this frame.

Returns: The number of bytes written to writeBuf.

Definition at line 671 of file HTTP2Framer.cpp.

References END_HEADERS, END_STREAM, kFrameHeaderSize, kFrameStreamIDSize, folly::gen::move, PRIORITY, uint32_t, UNIDIRECTIONAL, and folly::io::detail::Writable< Derived >::writeBE().

Referenced by proxygen::HTTP2Codec::generateHeaderImpl(), and TEST_F().

                                          {
   DCHECK_NE(0, stream);
   DCHECK_NE(0, exAttributes.controlStream);
   DCHECK_EQ(0, ~kUint31Mask & stream);
   DCHECK_EQ(0, ~kUint31Mask & exAttributes.controlStream);
   DCHECK(0x1 & exAttributes.controlStream) <<
     "controlStream should be initiated by client";
 
   const auto dataLen = (headers) ? headers->computeChainDataLength() : 0;
   uint32_t flags = 0;
   if (priority) {
     flags |= PRIORITY;
   }
   if (endStream) {
     flags |= END_STREAM;
   }
   if (endHeaders) {
     flags |= END_HEADERS;
   }
   if (exAttributes.unidirectional) {
     flags |= UNIDIRECTIONAL;
   }
 
   const auto frameLen = writeFrameHeader(queue,
                                          dataLen + kFrameStreamIDSize,
                                          FrameType::EX_HEADERS,
                                          flags,
                                          stream,
                                          padding,
                                          priority,
                                          nullptr);
   QueueAppender appender(&queue, frameLen);
   appender.writeBE<uint32_t>(exAttributes.controlStream);
   queue.append(std::move(headers));
   writePadding(queue, padding);
   return kFrameHeaderSize + frameLen;
 }

size_t proxygen::http2::writeGoaway	(	folly::IOBufQueue &	writeBuf,
		uint32_t	lastStreamID,
		ErrorCode	errorCode,
		std::unique_ptr< folly::IOBuf >	debugData = `nullptr`
	)

noexcept

Generate an entire GOAWAY frame, including the common frame header. We do not implement the optional opaque data.

Parameters

writeBuf	The output queue to write to. It may grow or add underlying buffers inside this function.
lastStreamID	The identifier of the last stream accepted.
errorCode	The error code returned in the frame.
debugData	Optional debug information to add to the frame

Returns: The number of bytes written to writeBuf.

Definition at line 831 of file HTTP2Framer.cpp.

References proxygen::spdy::GOAWAY, kFrameGoawaySize, kFrameHeaderSize, folly::gen::move, folly::none, uint32_t, and folly::io::detail::Writable< Derived >::writeBE().

Referenced by proxygen::HTTP2Codec::generateGoaway(), and TEST_F().

                                                      {
   uint32_t debugLen = debugData ? debugData->computeChainDataLength() : 0;
   DCHECK_EQ(0, ~kLengthMask & debugLen);
   const auto frameLen = writeFrameHeader(queue,
                                          kFrameGoawaySize + debugLen,
                                          FrameType::GOAWAY,
                                          0,
                                          0,
                                          kNoPadding,
                                          folly::none,
                                          nullptr);
   QueueAppender appender(&queue, frameLen);
   appender.writeBE<uint32_t>(lastStreamID);
   appender.writeBE<uint32_t>(static_cast<uint32_t>(errorCode));
   queue.append(std::move(debugData));
   return kFrameHeaderSize + frameLen;
 }

size_t proxygen::http2::writeHeaders	(	folly::IOBufQueue &	writeBuf,
		std::unique_ptr< folly::IOBuf >	headers,
		uint32_t	stream,
		folly::Optional< PriorityUpdate >	priority,
		folly::Optional< uint8_t >	padding,
		bool	endStream,
		bool	endHeaders
	)

noexcept

Generate an entire HEADERS frame, including the common frame header. The combined length of the data buffer and the padding and priority fields MUST NOT exceed 2^14 - 1, which is kMaxFramePayloadLength.

Parameters

writeBuf	The output queue to write to. It may grow or add underlying buffers inside this function.
headers	The encoded headers data to write out.
stream	The stream identifier of the HEADERS frame.
priority	If present, the priority depedency information to update the stream with.
padding	If not kNoPadding, adds 1 byte pad len and pad bytes
endStream	True iff this frame ends the stream.
endHeaders	True iff no CONTINUATION frames will follow this frame.

Returns: The number of bytes written to writeBuf.

Definition at line 638 of file HTTP2Framer.cpp.

References END_HEADERS, END_STREAM, proxygen::spdy::HEADERS, kFrameHeaderSize, folly::gen::move, PRIORITY, and uint32_t.

Referenced by proxygen::HTTP2Codec::generateHeaderImpl(), proxygen::HTTP2Codec::generateTrailers(), and TEST_F().

                                        {
   DCHECK_NE(0, stream);
   const auto dataLen = (headers) ? headers->computeChainDataLength() : 0;
   uint32_t flags = 0;
   if (priority) {
     flags |= PRIORITY;
   }
   if (endStream) {
     flags |= END_STREAM;
   }
   if (endHeaders) {
     flags |= END_HEADERS;
   }
   // padding flags handled directly inside writeFrameHeader()
   const auto frameLen = writeFrameHeader(queue,
                                          dataLen,
                                          FrameType::HEADERS,
                                          flags,
                                          stream,
                                          padding,
                                          priority,
                                          std::move(headers));
   writePadding(queue, padding);
   return kFrameHeaderSize + frameLen;
 }

size_t proxygen::http2::writePing	(	folly::IOBufQueue &	writeBuf,
		uint64_t	data,
		bool	ack
	)

noexcept

Generate an entire PING frame, including the common frame header.

Parameters

writeBuf	The output queue to write to. It may grow or add underlying buffers inside this function.
data	The opaque data to include.
ack	True iff this is a ping response.

Returns: The number of bytes written to writeBuf.

Definition at line 815 of file HTTP2Framer.cpp.

References ACK, kFrameHeaderSize, kFramePingSize, folly::none, and proxygen::spdy::PING.

Referenced by proxygen::HTTP2Codec::generatePingReply(), proxygen::HTTP2Codec::generatePingRequest(), UDPClient::sendPing(), and TEST_F().

                              {
   const auto frameLen = writeFrameHeader(queue,
                                          kFramePingSize,
                                          FrameType::PING,
                                          ack ? ACK : 0,
                                          0,
                                          kNoPadding,
                                          folly::none,
                                          nullptr);
   queue.append(&opaqueData, sizeof(opaqueData));
   return kFrameHeaderSize + frameLen;
 }

size_t proxygen::http2::writePriority	(	folly::IOBufQueue &	writeBuf,
		uint32_t	stream,
		PriorityUpdate	priority
	)

noexcept

Generate an entire PRIORITY frame, including the common frame header.

Parameters

writeBuf	The output queue to write to. It may grow or add underlying buffers inside this function.
stream	The stream identifier of the DATA frame.
priority	The priority depedency information to update the stream with.

Returns: The number of bytes written to writeBuf.

Definition at line 717 of file HTTP2Framer.cpp.

References kFrameHeaderSize, kFramePrioritySize, and PRIORITY.

Referenced by proxygen::HTTP2Codec::generatePriority(), and TEST_F().

                                                 {
   DCHECK_NE(0, stream);
   const auto frameLen = writeFrameHeader(queue,
                                          kFramePrioritySize,
                                          FrameType::PRIORITY,
                                          0,
                                          stream,
                                          kNoPadding,
                                          priority,
                                          nullptr);
   return kFrameHeaderSize + frameLen;
 }

size_t proxygen::http2::writePushPromise	(	folly::IOBufQueue &	writeBuf,
		uint32_t	associatedStream,
		uint32_t	promisedStream,
		std::unique_ptr< folly::IOBuf >	headers,
		folly::Optional< uint8_t >	padding,
		bool	endHeaders
	)

noexcept

Writes an entire PUSH_PROMISE frame, including the common frame header.

Parameters

writeBuf	The output queue to write to. It may grow or add underlying buffers inside this function.
associatedStream	The identifier of the stream the promised stream is associated with.
promisedStream	The identifier of the promised stream.
headers	The encoded headers to include in the push promise frame.
padding	If not kNoPadding, adds 1 byte pad len and pad bytes
endHeaders	True iff no CONTINUATION frames will follow this frame.

Returns: The number of bytes written to writeBuf/

Definition at line 786 of file HTTP2Framer.cpp.

References END_HEADERS, kFrameHeaderSize, kFramePushPromiseSize, folly::gen::move, folly::none, uint32_t, and folly::io::detail::Writable< Derived >::writeBE().

Referenced by proxygen::HTTP2Codec::generateHeaderImpl(), and TEST_F().

                                            {
   DCHECK_NE(0, promisedStream);
   DCHECK_NE(0, associatedStream);
   DCHECK_EQ(0, 0x1 & promisedStream);
   DCHECK_EQ(1, 0x1 & associatedStream);
   DCHECK_EQ(0, ~kUint31Mask & promisedStream);
 
   const auto dataLen = headers->computeChainDataLength();
   const auto frameLen = writeFrameHeader(queue,
                                          dataLen + kFramePushPromiseSize,
                                          FrameType::PUSH_PROMISE,
                                          endHeaders ? END_HEADERS : 0,
                                          associatedStream,
                                          padding,
                                          folly::none,
                                          nullptr);
   QueueAppender appender(&queue, frameLen);
   appender.writeBE<uint32_t>(promisedStream);
   queue.append(std::move(headers));
   writePadding(queue, padding);
   return kFrameHeaderSize + frameLen;
 }

size_t proxygen::http2::writeRstStream	(	folly::IOBufQueue &	writeBuf,
		uint32_t	stream,
		ErrorCode	errorCode
	)

noexcept

Generate an entire RST_STREAM frame, including the common frame header.

Parameters

writeBuf	The output queue to write to. It may grow or add underlying buffers inside this function.
stream	The identifier of the stream to reset.
errorCode	The error code returned in the frame.

Returns: The number of bytes written to writeBuf.

Definition at line 733 of file HTTP2Framer.cpp.

References kFrameHeaderSize, kFrameRstStreamSize, folly::none, proxygen::spdy::RST_STREAM, uint32_t, and folly::io::detail::Writable< Derived >::writeBE().

Referenced by proxygen::HTTP2Codec::generateRstStream(), and TEST_F().

                                              {
   DCHECK_NE(0, stream);
   const auto frameLen = writeFrameHeader(queue,
                                          kFrameRstStreamSize,
                                          FrameType::RST_STREAM,
                                          0,
                                          stream,
                                          kNoPadding,
                                          folly::none,
                                          nullptr);
   QueueAppender appender(&queue, frameLen);
   appender.writeBE<uint32_t>(static_cast<uint32_t>(errorCode));
   return kFrameHeaderSize + frameLen;
 }

size_t proxygen::http2::writeSettings	(	folly::IOBufQueue &	writeBuf,
		const std::deque< SettingPair > &	settings
	)

Generate an entire SETTINGS frame, including the common frame header.

Parameters

writeBuf	The output queue to write to. It may grow or add underlying buffers inside this function.
settings	The settings to send

Returns: The number of bytes written to writeBuf.

Definition at line 751 of file HTTP2Framer.cpp.

References kFrameHeaderSize, max, folly::none, proxygen::spdy::SETTINGS, uint16_t, uint32_t, and folly::io::detail::Writable< Derived >::writeBE().

Referenced by proxygen::HTTP2Codec::generateSettings(), and TEST_F().

                                                      {
   const auto settingsSize = settings.size() * 6;
   const auto frameLen = writeFrameHeader(queue,
                                          settingsSize,
                                          FrameType::SETTINGS,
                                          0,
                                          0,
                                          kNoPadding,
                                          folly::none,
                                          nullptr);
   QueueAppender appender(&queue, settingsSize);
   for (const auto& setting: settings) {
     DCHECK_LE(static_cast<uint32_t>(setting.first),
               std::numeric_limits<uint16_t>::max());
     appender.writeBE<uint16_t>(static_cast<uint16_t>(setting.first));
     appender.writeBE<uint32_t>(setting.second);
   }
   return kFrameHeaderSize + frameLen;
 }

size_t proxygen::http2::writeSettingsAck ( folly::IOBufQueue & writeBuf )

Writes an entire empty SETTINGS frame, including the common frame header. No settings can be transmitted with this frame.

Definition at line 773 of file HTTP2Framer.cpp.

References ACK, kFrameHeaderSize, folly::none, and proxygen::spdy::SETTINGS.

Referenced by proxygen::HTTP2Codec::generateSettingsAck(), and TEST_F().

                                     {
   writeFrameHeader(queue,
                    0,
                    FrameType::SETTINGS,
                    ACK,
                    0,
                    kNoPadding,
                    folly::none,
                    nullptr);
   return kFrameHeaderSize;
 }

size_t proxygen::http2::writeWindowUpdate	(	folly::IOBufQueue &	writeBuf,
		uint32_t	stream,
		uint32_t	amount
	)

noexcept

Generate an entire WINDOW_UPDATE frame, including the common frame header. |amount| MUST be between 1 to 2^31 - 1 inclusive

Parameters

writeBuf	The output queue to write to. It may grow or add underlying buffers inside this function.
stream	The stream to send a WINDOW_UPDATE on
amount	The number of bytes to AK

Returns: The number of bytes written to writeBuf.

Definition at line 853 of file HTTP2Framer.cpp.

References kFrameHeaderSize, kFrameWindowUpdateSize, folly::none, uint32_t, proxygen::spdy::WINDOW_UPDATE, and folly::io::detail::Writable< Derived >::writeBE().

Referenced by proxygen::HTTP2Codec::generateWindowUpdate(), and TEST_F().

                                             {
   const auto frameLen = writeFrameHeader(queue,
                                          kFrameWindowUpdateSize,
                                          FrameType::WINDOW_UPDATE,
                                          0,
                                          stream,
                                          kNoPadding,
                                          folly::none,
                                          nullptr);
   DCHECK_EQ(0, ~kUint31Mask & amount);
   DCHECK_LT(0, amount);
   QueueAppender appender(&queue, kFrameWindowUpdateSize);
   appender.writeBE<uint32_t>(amount);
   return kFrameHeaderSize + frameLen;
 }