proxygen: proxygen::HTTP2Codec Class Reference

#include <HTTP2Codec.h>

Inheritance diagram for proxygen::HTTP2Codec:

Public Member Functions
void	onHeader (const folly::fbstring &name, const folly::fbstring &value) override

void	onHeadersComplete (HTTPHeaderSize decodedSize) override

void	onDecodeError (HPACK::DecodeError decodeError) override

	HTTP2Codec (TransportDirection direction)

	~HTTP2Codec () override

CodecProtocol	getProtocol () const override

const std::string &	getUserAgent () const override

size_t	onIngress (const folly::IOBuf &buf) override

bool	onIngressUpgradeMessage (const HTTPMessage &msg) override

size_t	generateConnectionPreface (folly::IOBufQueue &writeBuf) override

void	generateHeader (folly::IOBufQueue &writeBuf, StreamID stream, const HTTPMessage &msg, bool eom=false, HTTPHeaderSize *size=nullptr) override

void	generateContinuation (folly::IOBufQueue &writeBuf, folly::IOBufQueue &queue, StreamID stream, size_t maxFrameSize)

void	generatePushPromise (folly::IOBufQueue &writeBuf, StreamID stream, const HTTPMessage &msg, StreamID assocStream, bool eom=false, HTTPHeaderSize *size=nullptr) override

void	generateExHeader (folly::IOBufQueue &writeBuf, StreamID stream, const HTTPMessage &msg, const HTTPCodec::ExAttributes &exAttributes, bool eom=false, HTTPHeaderSize *size=nullptr) override

size_t	generateBody (folly::IOBufQueue &writeBuf, StreamID stream, std::unique_ptr< folly::IOBuf > chain, folly::Optional< uint8_t > padding, bool eom) override

size_t	generateChunkHeader (folly::IOBufQueue &writeBuf, StreamID stream, size_t length) override

size_t	generateChunkTerminator (folly::IOBufQueue &writeBuf, StreamID stream) override

size_t	generateTrailers (folly::IOBufQueue &writeBuf, StreamID stream, const HTTPHeaders &trailers) override

size_t	generateEOM (folly::IOBufQueue &writeBuf, StreamID stream) override

size_t	generateRstStream (folly::IOBufQueue &writeBuf, StreamID stream, ErrorCode statusCode) override

size_t	generateGoaway (folly::IOBufQueue &writeBuf, StreamID lastStream, ErrorCode statusCode, std::unique_ptr< folly::IOBuf > debugData=nullptr) override

size_t	generatePingRequest (folly::IOBufQueue &writeBuf) override

size_t	generatePingReply (folly::IOBufQueue &writeBuf, uint64_t uniqueID) override

size_t	generateSettings (folly::IOBufQueue &writeBuf) override

size_t	generateSettingsAck (folly::IOBufQueue &writeBuf) override

size_t	generateWindowUpdate (folly::IOBufQueue &writeBuf, StreamID stream, uint32_t delta) override

size_t	generatePriority (folly::IOBufQueue &writeBuf, StreamID stream, const HTTPMessage::HTTPPriority &pri) override

size_t	generateCertificateRequest (folly::IOBufQueue &writeBuf, uint16_t requestId, std::unique_ptr< folly::IOBuf > certificateRequestData) override

size_t	generateCertificate (folly::IOBufQueue &writeBuf, uint16_t certId, std::unique_ptr< folly::IOBuf > certData) override

const HTTPSettings *	getIngressSettings () const override

HTTPSettings *	getEgressSettings () override

uint32_t	getDefaultWindowSize () const override

bool	supportsPushTransactions () const override

bool	peerHasWebsockets () const

bool	supportsExTransactions () const override

void	setHeaderCodecStats (HeaderCodec::Stats *hcStats) override

bool	isRequest (StreamID id) const

size_t	addPriorityNodes (PriorityQueue &queue, folly::IOBufQueue &writeBuf, uint8_t maxLevel) override

HTTPCodec::StreamID	mapPriorityToDependency (uint8_t priority) const override

HPACKTableInfo	getHPACKTableInfo () const override

uint64_t	getReceivedFrameCount () const

void	setReuseIOBufHeadroomForData (bool enabled)

void	setHeaderIndexingStrategy (const HeaderIndexingStrategy *indexingStrat)

const HeaderIndexingStrategy *	getHeaderIndexingStrategy () const

Public Member Functions inherited from proxygen::HTTPParallelCodec
	HTTPParallelCodec (TransportDirection direction)

TransportDirection	getTransportDirection () const override

StreamID	createStream () override

bool	isBusy () const override

bool	supportsStreamFlowControl () const override

bool	supportsSessionFlowControl () const override

bool	supportsParallelRequests () const override

bool	closeOnEgressComplete () const override

void	setCallback (Callback *callback) override

void	setParserPaused (bool) override

void	onIngressEOF () override

bool	isReusable () const override

bool	isWaitingToDrain () const override

StreamID	getLastIncomingStreamID () const override

void	enableDoubleGoawayDrain () override

bool	onIngressUpgradeMessage (const HTTPMessage &msg) override

void	setNextEgressStreamId (StreamID nextEgressStreamID)

bool	isInitiatedStream (StreamID stream) const

bool	isStreamIngressEgressAllowed (StreamID stream) const

Public Member Functions inherited from proxygen::HTTPCodec
virtual	~HTTPCodec ()

virtual int8_t	mapDependencyToPriority (StreamID) const

Static Public Member Functions
static void	requestUpgrade (HTTPMessage &request)

Private Types
enum	FrameState { UPSTREAM_CONNECTION_PREFACE = 0, DOWNSTREAM_CONNECTION_PREFACE = 1, FRAME_HEADER = 2, FRAME_DATA = 3, DATA_FRAME_DATA = 4 }

Private Member Functions
void	generateHeaderImpl (folly::IOBufQueue &writeBuf, StreamID stream, const HTTPMessage &msg, const folly::Optional< StreamID > &assocStream, const folly::Optional< ExAttributes > &exAttributes, bool eom, HTTPHeaderSize *size)

std::unique_ptr< folly::IOBuf >	encodeHeaders (const HTTPHeaders &headers, std::vector< compress::Header > &allHeaders, HTTPHeaderSize *size)

size_t	generateHeaderCallbackWrapper (StreamID stream, http2::FrameType type, size_t length)

ErrorCode	parseFrame (folly::io::Cursor &cursor)

ErrorCode	parseAllData (folly::io::Cursor &cursor)

ErrorCode	parseDataFrameData (folly::io::Cursor &cursor, size_t bufLen, size_t &parsed)

ErrorCode	parseHeaders (folly::io::Cursor &cursor)

ErrorCode	parseExHeaders (folly::io::Cursor &cursor)

ErrorCode	parsePriority (folly::io::Cursor &cursor)

ErrorCode	parseRstStream (folly::io::Cursor &cursor)

ErrorCode	parseSettings (folly::io::Cursor &cursor)

ErrorCode	parsePushPromise (folly::io::Cursor &cursor)

ErrorCode	parsePing (folly::io::Cursor &cursor)

ErrorCode	parseGoaway (folly::io::Cursor &cursor)

ErrorCode	parseContinuation (folly::io::Cursor &cursor)

ErrorCode	parseWindowUpdate (folly::io::Cursor &cursor)

ErrorCode	parseCertificateRequest (folly::io::Cursor &cursor)

ErrorCode	parseCertificate (folly::io::Cursor &cursor)

ErrorCode	parseHeadersImpl (folly::io::Cursor &cursor, std::unique_ptr< folly::IOBuf > headerBuf, const folly::Optional< http2::PriorityUpdate > &priority, const folly::Optional< uint32_t > &promisedStream, const folly::Optional< ExAttributes > &exAttributes)

folly::Optional< ErrorCode >	parseHeadersDecodeFrames (const folly::Optional< http2::PriorityUpdate > &priority, const folly::Optional< uint32_t > &promisedStream, const folly::Optional< ExAttributes > &exAttributes, std::unique_ptr< HTTPMessage > &msg)

folly::Optional< ErrorCode >	parseHeadersCheckConcurrentStreams (const folly::Optional< http2::PriorityUpdate > &priority)

ErrorCode	handleEndStream ()

ErrorCode	checkNewStream (uint32_t stream, bool trailersAllowed)

bool	checkConnectionError (ErrorCode, const folly::IOBuf *buf)

ErrorCode	handleSettings (const std::deque< SettingPair > &settings)

size_t	maxSendFrameSize () const

uint32_t	maxRecvFrameSize () const

void	streamError (const std::string &msg, ErrorCode error, bool newTxn=false)

bool	parsingTrailers () const

Private Member Functions inherited from proxygen::HPACK::StreamingCallback
virtual	~StreamingCallback ()

Private Attributes
HPACKCodec	headerCodec_

http2::FrameHeader	curHeader_

StreamID	expectedContinuationStream_ {0}

bool	pendingEndStreamHandling_ {false}

bool	ingressWebsocketUpgrade_ {false}

std::unordered_set< StreamID >	upgradedStreams_

uint16_t	curCertId_ {0}

folly::IOBufQueue	curAuthenticatorBlock_

folly::IOBufQueue	curHeaderBlock_ {folly::IOBufQueue::cacheChainLength()}

HTTPSettings	ingressSettings_

HTTPSettings	egressSettings_

uint64_t	receivedFrameCount_ {0}

FrameState	frameState_:3

std::string	userAgent_

size_t	pendingDataFrameBytes_ {0}

size_t	pendingDataFramePaddingBytes_ {0}

HeaderDecodeInfo	decodeInfo_

std::vector< StreamID >	virtualPriorityNodes_

bool	reuseIOBufHeadroomForData_ {true}

bool	parsingDownstreamTrailers_ {false}

http2::FrameType	headerBlockFrameType_ {http2::FrameType::DATA}

Private Attributes inherited from proxygen::HPACK::StreamingCallback
HeaderCodec::Stats *	stats {nullptr}

Additional Inherited Members
Public Types inherited from proxygen::HTTPCodec
using	StreamID = uint64_t

Static Public Attributes inherited from proxygen::HTTPCodec
static const folly::Optional< StreamID >	NoStream

static const folly::Optional< uint8_t >	NoPadding = folly::none

static const StreamID	MAX_STREAM_ID = 1u << 31

static const folly::Optional< ExAttributes >	NoExAttributes

Protected Types inherited from proxygen::HTTPParallelCodec
enum	ClosingState { OPEN = 0, OPEN_WITH_GRACEFUL_DRAIN_ENABLED = 1, FIRST_GOAWAY_SENT = 2, CLOSING = 3, CLOSED = 4 }

Protected Member Functions inherited from proxygen::HTTPParallelCodec
template<typename T , typename... Args>
bool	deliverCallbackIfAllowed (T callbackFn, char const *cbName, StreamID stream, Args &&...args)

Protected Attributes inherited from proxygen::HTTPParallelCodec
TransportDirection	transportDirection_

StreamID	nextEgressStreamID_

StreamID	lastStreamID_ {0}

HTTPCodec::Callback *	callback_ {nullptr}

StreamID	ingressGoawayAck_ {std::numeric_limits<uint32_t>::max()}

StreamID	egressGoawayAck_ {std::numeric_limits<uint32_t>::max()}

std::string	goawayErrorMessage_

enum proxygen::HTTPParallelCodec::ClosingState	sessionClosing_

Detailed Description

An implementation of the framing layer for HTTP/2. Instances of this class must not be used from multiple threads concurrently.

Definition at line 29 of file HTTP2Codec.h.

Member Enumeration Documentation

enum proxygen::HTTP2Codec::FrameState

private

Enumerator
UPSTREAM_CONNECTION_PREFACE
DOWNSTREAM_CONNECTION_PREFACE
FRAME_HEADER
FRAME_DATA
DATA_FRAME_DATA

Definition at line 269 of file HTTP2Codec.h.

                   {
     UPSTREAM_CONNECTION_PREFACE = 0,
     DOWNSTREAM_CONNECTION_PREFACE = 1,
     FRAME_HEADER = 2,
     FRAME_DATA = 3,
     DATA_FRAME_DATA = 4,
   };

Constructor & Destructor Documentation

proxygen::HTTP2Codec::HTTP2Codec ( TransportDirection direction )

explicit

Definition at line 42 of file HTTP2Codec.cpp.

References egressSettings_, proxygen::HTTPSettings::getSetting(), proxygen::getTransportDirectionString(), proxygen::HEADER_TABLE_SIZE, headerCodec_, proxygen::MAX_HEADER_LIST_SIZE, proxygen::HPACKCodec::setDecoderHeaderTableMaxSize(), and proxygen::HPACKCodec::setMaxUncompressed().

     : HTTPParallelCodec(direction),
       headerCodec_(direction),
       frameState_(direction == TransportDirection::DOWNSTREAM
                   ? FrameState::UPSTREAM_CONNECTION_PREFACE
                   : FrameState::DOWNSTREAM_CONNECTION_PREFACE) {
 
   // Set headerCodec_ settings if specified, else let headerCodec_ utilize
   // its own defaults
   const auto decoderHeaderTableMaxSize = egressSettings_.getSetting(
     SettingsId::HEADER_TABLE_SIZE);
   if (decoderHeaderTableMaxSize) {
     headerCodec_.setDecoderHeaderTableMaxSize(decoderHeaderTableMaxSize->value);
   }
   const auto maxHeaderListSize = egressSettings_.getSetting(
     SettingsId::MAX_HEADER_LIST_SIZE);
   if (maxHeaderListSize) {
     headerCodec_.setMaxUncompressed(maxHeaderListSize->value);
   }
 
   VLOG(4) << "creating " << getTransportDirectionString(direction)
           << " HTTP/2 codec";
 }

proxygen::HTTP2Codec::~HTTP2Codec ( )

override

Definition at line 66 of file HTTP2Codec.cpp.

66 {}

Member Function Documentation

size_t proxygen::HTTP2Codec::addPriorityNodes	(	PriorityQueue &	,
		folly::IOBufQueue &	,
		uint8_t
	)

overridevirtual

Create virtual nodes in HTTP/2 priority tree. Some protocols (SPDY) have a linear priority structure which must be simulated in the HTTP/2 tree structure with "virtual" nodes representing different priority bands. There are other cases we simply want a "plain" linear priority structure even with HTTP/2. In that case a Priority frame will also be sent out for each virtual node created so that peer will have the same linear structure.

Parameters

queue	the priority queue to add nodes
writeBuf	IOBufQueue to append priority frames to send. For SPDY, the writeBuf will be ignored.
maxLavel	the max level of virtual priority nodes to create. For SPDY, this value will be ignored.

Reimplemented from proxygen::HTTPCodec.

Definition at line 670 of file HTTP2Codec.cpp.

References proxygen::HTTPCodec::PriorityQueue::addPriorityNode(), proxygen::HTTPParallelCodec::createStream(), generatePriority(), std::tr1::make_tuple(), parent, and virtualPriorityNodes_.

Referenced by isRequest().

                       {
   HTTPCodec::StreamID parent = 0;
   size_t bytes = 0;
   while (maxLevel--) {
     auto id = createStream();
     virtualPriorityNodes_.push_back(id);
     queue.addPriorityNode(id, parent);
     bytes += generatePriority(writeBuf, id, std::make_tuple(parent, false, 0));
     parent = id;
   }
   return bytes;
 }

bool proxygen::HTTP2Codec::checkConnectionError	(	ErrorCode	err,
		const folly::IOBuf *	buf
	)

private

Definition at line 1598 of file HTTP2Codec.cpp.

References proxygen::HTTPParallelCodec::callback_, proxygen::ERROR, proxygen::getErrorCodeString(), proxygen::HTTPParallelCodec::goawayErrorMessage_, proxygen::HTTPException::INGRESS_AND_EGRESS, proxygen::NO_ERROR, proxygen::HTTPCodec::Callback::onError(), proxygen::IOBufPrinter::printHexFolly(), proxygen::HTTPException::setCodecStatusCode(), and string.

Referenced by getHeaderIndexingStrategy(), and onIngress().

                                                                           {
   if (err != ErrorCode::NO_ERROR) {
     LOG(ERROR) << "Connection error " << getErrorCodeString(err)
                << " with ingress=";
     VLOG(3) << IOBufPrinter::printHexFolly(buf, true);
     if (callback_) {
       std::string errorDescription = goawayErrorMessage_.empty() ?
         "Connection error" : goawayErrorMessage_;
       HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS,
                        errorDescription);
       ex.setCodecStatusCode(err);
       callback_->onError(0, ex, false);
     }
     return true;
   }
   return false;
 }

ErrorCode proxygen::HTTP2Codec::checkNewStream	(	uint32_t	stream,
		bool	trailersAllowed
	)

private

Definition at line 973 of file HTTP2Codec.cpp.

References proxygen::HTTPParallelCodec::goawayErrorMessage_, proxygen::HTTPParallelCodec::isInitiatedStream(), proxygen::HTTPParallelCodec::lastStreamID_, proxygen::NO_ERROR, parsingDownstreamTrailers_, proxygen::PROTOCOL_ERROR, and proxygen::HTTPParallelCodec::sessionClosing_.

Referenced by getHeaderIndexingStrategy(), parseExHeaders(), parseHeaders(), and parsePushPromise().

                                                                             {
   if (streamId == 0) {
     goawayErrorMessage_ = folly::to<string>(
         "GOAWAY error: received streamID=", streamId,
         " as invalid new stream for lastStreamID_=", lastStreamID_);
     VLOG(4) << goawayErrorMessage_;
     return ErrorCode::PROTOCOL_ERROR;
   }
   parsingDownstreamTrailers_ = trailersAllowed && (streamId <= lastStreamID_);
   if (parsingDownstreamTrailers_) {
     VLOG(4) << "Parsing downstream trailers streamId=" << streamId;
   }
 
   if (sessionClosing_ != ClosingState::CLOSED) {
     lastStreamID_ = streamId;
   }
 
   if (isInitiatedStream(streamId)) {
     // this stream should be initiated by us, not by peer
     goawayErrorMessage_ = folly::to<string>(
         "GOAWAY error: invalid new stream received with streamID=", streamId);
     VLOG(4) << goawayErrorMessage_;
     return ErrorCode::PROTOCOL_ERROR;
   } else {
     return ErrorCode::NO_ERROR;
   }
 }

std::unique_ptr< folly::IOBuf > proxygen::HTTP2Codec::encodeHeaders	(	const HTTPHeaders &	headers,
		std::vector< compress::Header > &	allHeaders,
		HTTPHeaderSize *	size
	)

private

Definition at line 1217 of file HTTP2Codec.cpp.

References proxygen::HPACKCodec::encode(), proxygen::ERROR, proxygen::HTTPHeaders::forEach(), proxygen::HeaderCodec::getEncodedSize(), proxygen::HTTPSettings::getSetting(), headerCodec_, ingressSettings_, proxygen::http2::kFrameHeadersBaseMaxSize, proxygen::http2::kFrameHeaderSize, max, proxygen::MAX_HEADER_LIST_SIZE, name, proxygen::HeaderCodec::setEncodeHeadroom(), proxygen::HTTPHeaders::size(), wangle::HTTPHeaderSize::uncompressed, and value.

Referenced by generateHeaderImpl(), generateTrailers(), and getHeaderIndexingStrategy().

                           {
   headerCodec_.setEncodeHeadroom(http2::kFrameHeaderSize +
                                  http2::kFrameHeadersBaseMaxSize);
   auto out = headerCodec_.encode(allHeaders);
   if (size) {
     *size = headerCodec_.getEncodedSize();
   }
 
   if (headerCodec_.getEncodedSize().uncompressed >
       ingressSettings_.getSetting(SettingsId::MAX_HEADER_LIST_SIZE,
                                   std::numeric_limits<uint32_t>::max())) {
     // The remote side told us they don't want headers this large...
     // but this function has no mechanism to fail
     string serializedHeaders;
     headers.forEach(
       [&serializedHeaders] (const string& name, const string& value) {
         serializedHeaders = folly::to<string>(serializedHeaders, "\\n", name,
                                               ":", value);
       });
     LOG(ERROR) << "generating HEADERS frame larger than peer maximum nHeaders="
                << headers.size() << " all headers="
                << serializedHeaders;
   }
   return out;
 }

size_t proxygen::HTTP2Codec::generateBody	(	folly::IOBufQueue &	writeBuf,
		StreamID	stream,
		std::unique_ptr< folly::IOBuf >	chain,
		folly::Optional< uint8_t >	padding,
		bool	eom
	)

overridevirtual

Write part of an egress message body.

This will automatically generate a chunk header and footer around the data if necessary (e.g. you haven't manually sent a chunk header and the message should be chunked).

Parameters

padding	Optionally add padding bytes to the body if possible
eom	implicitly generate the EOM marker with this body frame

Returns: number of bytes written

Implements proxygen::HTTPCodec.

Definition at line 1257 of file HTTP2Codec.cpp.

References folly::IOBufQueue::append(), folly::IOBufQueue::chainLength(), proxygen::http2::DATA, generateHeaderCallbackWrapper(), proxygen::HTTPParallelCodec::ingressGoawayAck_, proxygen::HTTPParallelCodec::isStreamIngressEgressAllowed(), maxSendFrameSize(), folly::IOBufQueue::move(), folly::gen::move, reuseIOBufHeadroomForData_, folly::IOBufQueue::split(), stream, and proxygen::http2::writeData().

Referenced by getUserAgent().

                                           {
   // todo: generate random padding for everything?
   size_t written = 0;
   if (!isStreamIngressEgressAllowed(stream)) {
     VLOG(2) << "Suppressing DATA for stream=" << stream << " ingressGoawayAck_="
             << ingressGoawayAck_;
     return 0;
   }
   IOBufQueue queue(IOBufQueue::cacheChainLength());
   queue.append(std::move(chain));
   size_t maxFrameSize = maxSendFrameSize();
   while (queue.chainLength() > maxFrameSize) {
     auto chunk = queue.split(maxFrameSize);
     written += generateHeaderCallbackWrapper(
                   stream,
                   http2::FrameType::DATA,
                   http2::writeData(writeBuf,
                                    std::move(chunk),
                                    stream,
                                    padding,
                                    false,
                                    reuseIOBufHeadroomForData_));
   }
 
   return written + generateHeaderCallbackWrapper(
                       stream,
                       http2::FrameType::DATA,
                       http2::writeData(writeBuf,
                                        queue.move(),
                                        stream,
                                        padding,
                                        eom,
                                        reuseIOBufHeadroomForData_));
 }

size_t proxygen::HTTP2Codec::generateCertificate	(	folly::IOBufQueue &	writeBuf,
		uint16_t	certId,
		std::unique_ptr< folly::IOBuf >	certData
	)

overridevirtual

Reimplemented from proxygen::HTTPCodec.

Definition at line 1579 of file HTTP2Codec.cpp.

References folly::IOBufQueue::append(), folly::IOBufQueue::chainLength(), maxSendFrameSize(), folly::IOBufQueue::move(), folly::gen::move, folly::IOBufQueue::splitAtMost(), and proxygen::http2::writeCertificate().

Referenced by getUserAgent().

                                                                            {
   size_t written = 0;
   VLOG(4) << "sending CERTIFICATE with Cert-ID=" << certId << "for stream=0";
   IOBufQueue queue(IOBufQueue::cacheChainLength());
   queue.append(std::move(certData));
   // The maximum size of an autenticator fragment, combined with the Cert-ID can
   // not exceed the maximal allowable size of a sent frame.
   size_t maxChunkSize = maxSendFrameSize() - sizeof(certId);
   while (queue.chainLength() > maxChunkSize) {
     auto chunk = queue.splitAtMost(maxChunkSize);
     written +=
         http2::writeCertificate(writeBuf, certId, std::move(chunk), true);
   }
   return written +
          http2::writeCertificate(writeBuf, certId, queue.move(), false);
 }

size_t proxygen::HTTP2Codec::generateCertificateRequest	(	folly::IOBufQueue &	writeBuf,
		uint16_t	requestId,
		std::unique_ptr< folly::IOBuf >	certificateRequestData
	)

overridevirtual

Reimplemented from proxygen::HTTPCodec.

Definition at line 1570 of file HTTP2Codec.cpp.

References folly::gen::move, and proxygen::http2::writeCertificateRequest().

Referenced by getUserAgent().

                                                       {
   VLOG(4) << "generating CERTIFICATE_REQUEST with Request-ID=" << requestId;
   return http2::writeCertificateRequest(
       writeBuf, requestId, std::move(certificateRequestData));
 }

size_t proxygen::HTTP2Codec::generateChunkHeader	(	folly::IOBufQueue &	writeBuf,
		StreamID	stream,
		size_t	length
	)

overridevirtual

Write a body chunk header, if relevant.

Implements proxygen::HTTPCodec.

Definition at line 1296 of file HTTP2Codec.cpp.

Referenced by getUserAgent().

                                                  {
   // HTTP/2 has no chunk headers
   return 0;
 }

size_t proxygen::HTTP2Codec::generateChunkTerminator	(	folly::IOBufQueue &	writeBuf,
		StreamID	stream
	)

overridevirtual

Write a body chunk terminator, if relevant.

Implements proxygen::HTTPCodec.

Definition at line 1303 of file HTTP2Codec.cpp.

Referenced by getUserAgent().

                                                        {
   // HTTP/2 has no chunk terminators
   return 0;
 }

size_t proxygen::HTTP2Codec::generateConnectionPreface ( folly::IOBufQueue & )

overridevirtual

Generate a connection preface, if there is any for this protocol.

Returns: size of the generated message

Reimplemented from proxygen::HTTPCodec.

Definition at line 1001 of file HTTP2Codec.cpp.

References folly::IOBufQueue::append(), proxygen::http2::kConnectionPreface, proxygen::HTTPParallelCodec::transportDirection_, and proxygen::UPSTREAM.

Referenced by getUserAgent().

                                                                       {
   if (transportDirection_ == TransportDirection::UPSTREAM) {
     VLOG(4) << "generating connection preface";
     writeBuf.append(http2::kConnectionPreface);
     return http2::kConnectionPreface.length();
   }
   return 0;
 }

void proxygen::HTTP2Codec::generateContinuation	(	folly::IOBufQueue &	writeBuf,
		folly::IOBufQueue &	queue,
		StreamID	stream,
		size_t	maxFrameSize
	)

Definition at line 1200 of file HTTP2Codec.cpp.

References folly::IOBufQueue::chainLength(), proxygen::http2::CONTINUATION, generateHeaderCallbackWrapper(), min, folly::gen::move, folly::IOBufQueue::split(), stream, and proxygen::http2::writeContinuation().

Referenced by generateHeaderImpl(), generateTrailers(), and getUserAgent().

                                                            {
   bool endHeaders = false;
   while (!endHeaders) {
     auto chunk = queue.split(std::min(maxFrameSize, queue.chainLength()));
     endHeaders = (queue.chainLength() == 0);
     VLOG(4) << "generating CONTINUATION for stream=" << stream;
     generateHeaderCallbackWrapper(
         stream,
         http2::FrameType::CONTINUATION,
         http2::writeContinuation(
             writeBuf, stream, endHeaders, std::move(chunk)));
   }
 }

size_t proxygen::HTTP2Codec::generateEOM	(	folly::IOBufQueue &	writeBuf,
		StreamID	stream
	)

overridevirtual

Generate any protocol framing needed to finalize an egress message. This method must be called to complete a stream.

Returns: number of bytes written

Implements proxygen::HTTPCodec.

Definition at line 1344 of file HTTP2Codec.cpp.

References proxygen::http2::DATA, generateHeaderCallbackWrapper(), proxygen::HTTPParallelCodec::ingressGoawayAck_, proxygen::HTTPParallelCodec::isStreamIngressEgressAllowed(), proxygen::http2::kNoPadding, reuseIOBufHeadroomForData_, stream, upgradedStreams_, and proxygen::http2::writeData().

Referenced by getUserAgent().

                                                 {
   VLOG(4) << "sending EOM for stream=" << stream;
   upgradedStreams_.erase(stream);
   if (!isStreamIngressEgressAllowed(stream)) {
     VLOG(2) << "suppressed EOM for stream=" << stream << " ingressGoawayAck_="
             << ingressGoawayAck_;
     return 0;
   }
   return generateHeaderCallbackWrapper(
             stream,
             http2::FrameType::DATA,
             http2::writeData(writeBuf,
                              nullptr,
                              stream,
                              http2::kNoPadding,
                              true,
                              reuseIOBufHeadroomForData_));
 }

void proxygen::HTTP2Codec::generateExHeader	(	folly::IOBufQueue &	writeBuf,
		StreamID	stream,
		const HTTPMessage &	msg,
		const HTTPCodec::ExAttributes &	exAttributes,
		bool	eom = `false`,
		HTTPHeaderSize *	size = `nullptr`
	)

overridevirtual

Reimplemented from proxygen::HTTPCodec.

Definition at line 1084 of file HTTP2Codec.cpp.

References generateHeaderImpl(), and folly::none.

Referenced by getUserAgent().

                                                         {
   generateHeaderImpl(writeBuf,
                      stream,
                      msg,
                      folly::none, /* assocStream */
                      exAttributes,
                      eom,
                      size);
 }

size_t proxygen::HTTP2Codec::generateGoaway	(	folly::IOBufQueue &	writeBuf,
		StreamID	lastStream,
		ErrorCode	code,
		std::unique_ptr< folly::IOBuf >	debugData = `nullptr`
	)

overridevirtual

Generate any protocol framing needed to abort a connection.

Returns: number of bytes written

Implements proxygen::HTTPCodec.

Definition at line 1391 of file HTTP2Codec.cpp.

References proxygen::HTTPParallelCodec::egressGoawayAck_, proxygen::http2::errorCodeToGoaway(), folly::FATAL, generateHeaderCallbackWrapper(), proxygen::getErrorCodeString(), proxygen::http2::GOAWAY, max, folly::gen::move, proxygen::NO_ERROR, proxygen::PROTOCOL_ERROR, proxygen::HTTPParallelCodec::sessionClosing_, userAgent_, and proxygen::http2::writeGoaway().

Referenced by getUserAgent().

                                                                        {
   DCHECK_LE(lastStream, egressGoawayAck_) << "Cannot increase last good stream";
   egressGoawayAck_ = lastStream;
   if (sessionClosing_ == ClosingState::CLOSED) {
     VLOG(4) << "Not sending GOAWAY for closed session";
     return 0;
   }
   switch (sessionClosing_) {
     case ClosingState::OPEN:
     case ClosingState::OPEN_WITH_GRACEFUL_DRAIN_ENABLED:
       if (lastStream == std::numeric_limits<int32_t>::max() &&
           statusCode == ErrorCode::NO_ERROR) {
         sessionClosing_ = ClosingState::FIRST_GOAWAY_SENT;
       } else {
         // The user of this codec decided not to do the double goaway
         // drain, or this is not a graceful shutdown
         sessionClosing_ = ClosingState::CLOSED;
       }
       break;
     case ClosingState::FIRST_GOAWAY_SENT:
       sessionClosing_ = ClosingState::CLOSED;
       break;
     case ClosingState::CLOSING:
     case ClosingState::CLOSED:
       LOG(FATAL) << "unreachable";
   }
 
   VLOG(4) << "Sending GOAWAY with last acknowledged stream="
           << lastStream << " with code=" << getErrorCodeString(statusCode);
   if (statusCode == ErrorCode::PROTOCOL_ERROR) {
     VLOG(2) << "sending GOAWAY with last acknowledged stream=" << lastStream
             << " with code=" << getErrorCodeString(statusCode)
             << " user-agent=" << userAgent_;
   }
 
   auto code = http2::errorCodeToGoaway(statusCode);
   return generateHeaderCallbackWrapper(
             0,
             http2::FrameType::GOAWAY,
             http2::writeGoaway(writeBuf,
                               lastStream,
                               code,
                               std::move(debugData)));
 }

void proxygen::HTTP2Codec::generateHeader	(	folly::IOBufQueue &	writeBuf,
		StreamID	stream,
		const HTTPMessage &	msg,
		bool	eom = `false`,
		HTTPHeaderSize *	size = `nullptr`
	)

overridevirtual

Write an egress message header. For pushed streams, you must specify the assocStream.

Return values

size	the size of the generated message, both the actual size and the size of the uncompressed data.

Returns: None

Implements proxygen::HTTPCodec.

Definition at line 1055 of file HTTP2Codec.cpp.

References generateHeaderImpl(), and folly::none.

Referenced by getUserAgent().

                                                       {
   generateHeaderImpl(writeBuf,
                      stream,
                      msg,
                      folly::none, /* assocStream */
                      folly::none, /* controlStream */
                      eom,
                      size);
 }

size_t proxygen::HTTP2Codec::generateHeaderCallbackWrapper	(	StreamID	stream,
		http2::FrameType	type,
		size_t	length
	)

private

Definition at line 1246 of file HTTP2Codec.cpp.

References proxygen::HTTPParallelCodec::callback_, and proxygen::HTTPCodec::Callback::onGenerateFrameHeader().

Referenced by generateBody(), generateContinuation(), generateEOM(), generateGoaway(), generateHeaderImpl(), generatePingReply(), generatePingRequest(), generatePriority(), generateRstStream(), generateSettings(), generateSettingsAck(), generateTrailers(), generateWindowUpdate(), and getHeaderIndexingStrategy().

                                                                 {
   if (callback_) {
     callback_->onGenerateFrameHeader(stream,
                                      static_cast<uint8_t>(type),
                                      length);
   }
   return length;
 }

void proxygen::HTTP2Codec::generateHeaderImpl	(	folly::IOBufQueue &	writeBuf,
		StreamID	stream,
		const HTTPMessage &	msg,
		const folly::Optional< StreamID > &	assocStream,
		const folly::Optional< ExAttributes > &	exAttributes,
		bool	eom,
		HTTPHeaderSize *	size
	)

private

Definition at line 1099 of file HTTP2Codec.cpp.

References wangle::HTTPHeaderSize::compressed, proxygen::DOWNSTREAM, encodeHeaders(), proxygen::http2::EX_HEADERS, generateContinuation(), generateHeaderCallbackWrapper(), proxygen::HTTPMessage::getHeaders(), proxygen::HTTPMessage::getHTTP2Priority(), proxygen::http2::HEADERS, proxygen::HTTPParallelCodec::ingressGoawayAck_, proxygen::HTTPMessage::isEgressWebsocketUpgrade(), proxygen::HTTPMessage::isRequest(), proxygen::HTTPParallelCodec::isStreamIngressEgressAllowed(), proxygen::http2::kFramePrioritySize, proxygen::http2::kNoPadding, maxSendFrameSize(), min, folly::gen::move, proxygen::CodecUtil::prepareMessageForCompression(), proxygen::http2::PUSH_PROMISE, folly::size(), stream, proxygen::HTTPParallelCodec::transportDirection_, wangle::HTTPHeaderSize::uncompressed, upgradedStreams_, proxygen::UPSTREAM, proxygen::http2::writeExHeaders(), proxygen::http2::writeHeaders(), and proxygen::http2::writePushPromise().

Referenced by generateExHeader(), generateHeader(), generatePushPromise(), and getHeaderIndexingStrategy().

                           {
   if (assocStream) {
     CHECK(!exAttributes);
     VLOG(4) << "generating PUSH_PROMISE for stream=" << stream;
   } else if (exAttributes) {
     CHECK(!assocStream);
     VLOG(4) << "generating ExHEADERS for stream=" << stream
             << " with control stream=" << exAttributes->controlStream
             << " unidirectional=" << exAttributes->unidirectional;
   } else {
     VLOG(4) << "generating HEADERS for stream=" << stream;
   }
 
   if (!isStreamIngressEgressAllowed(stream)) {
     VLOG(2) << "Suppressing HEADERS/PROMISE for stream=" << stream <<
       " ingressGoawayAck_=" << ingressGoawayAck_;
     if (size) {
       size->uncompressed = 0;
       size->compressed = 0;
     }
     return;
   }
 
   if (msg.isRequest()) {
     DCHECK(transportDirection_ == TransportDirection::UPSTREAM ||
            assocStream || exAttributes);
     if (msg.isEgressWebsocketUpgrade()) {
       upgradedStreams_.insert(stream);
     }
   } else {
     DCHECK(transportDirection_ == TransportDirection::DOWNSTREAM ||
            exAttributes);
   }
 
   std::vector<std::string> temps;
   auto allHeaders = CodecUtil::prepareMessageForCompression(msg, temps);
   auto out = encodeHeaders(msg.getHeaders(), allHeaders, size);
   IOBufQueue queue(IOBufQueue::cacheChainLength());
   queue.append(std::move(out));
   auto maxFrameSize = maxSendFrameSize();
   if (queue.chainLength() > 0) {
     folly::Optional<http2::PriorityUpdate> pri;
     auto res = msg.getHTTP2Priority();
     auto remainingFrameSize = maxFrameSize;
     if (res) {
       pri = http2::PriorityUpdate{std::get<0>(*res), std::get<1>(*res),
                                   std::get<2>(*res)};
       DCHECK_GE(remainingFrameSize, http2::kFramePrioritySize)
         << "no enough space for priority? frameHeadroom=" << remainingFrameSize;
       remainingFrameSize -= http2::kFramePrioritySize;
     }
     auto chunk = queue.split(std::min(remainingFrameSize, queue.chainLength()));
 
     bool endHeaders = queue.chainLength() == 0;
 
     if (assocStream) {
       DCHECK_EQ(transportDirection_, TransportDirection::DOWNSTREAM);
       DCHECK(!eom);
       generateHeaderCallbackWrapper(stream, http2::FrameType::PUSH_PROMISE,
                                     http2::writePushPromise(writeBuf,
                                                             *assocStream,
                                                             stream,
                                                             std::move(chunk),
                                                             http2::kNoPadding,
                                                             endHeaders));
     } else if (exAttributes) {
       generateHeaderCallbackWrapper(
         stream,
         http2::FrameType::EX_HEADERS,
         http2::writeExHeaders(writeBuf,
                               std::move(chunk),
                               stream,
                               *exAttributes,
                               pri,
                               http2::kNoPadding,
                               eom,
                               endHeaders));
     } else {
       generateHeaderCallbackWrapper(stream, http2::FrameType::HEADERS,
                                     http2::writeHeaders(writeBuf,
                                                         std::move(chunk),
                                                         stream,
                                                         pri,
                                                         http2::kNoPadding,
                                                         eom,
                                                         endHeaders));
     }
 
     if (!endHeaders) {
       generateContinuation(writeBuf, queue, stream, maxFrameSize);
     }
   }
 }

size_t proxygen::HTTP2Codec::generatePingReply	(	folly::IOBufQueue &	,
		uint64_t
	)

overridevirtual

Generate a reply to a ping message, if supported in the protocol implemented by the codec.

Reimplemented from proxygen::HTTPCodec.

Definition at line 1448 of file HTTP2Codec.cpp.

References generateHeaderCallbackWrapper(), proxygen::http2::PING, and proxygen::http2::writePing().

Referenced by getUserAgent().

                                                         {
   VLOG(4) << "Generating ping reply with opaqueData=" << uniqueID;
   return generateHeaderCallbackWrapper(0, http2::FrameType::PING,
                                        http2::writePing(writeBuf, uniqueID, true /* ack */));
 }

size_t proxygen::HTTP2Codec::generatePingRequest ( folly::IOBufQueue & )

overridevirtual

If the protocol supports it, generate a ping message that the other side should respond to.

Reimplemented from proxygen::HTTPCodec.

Definition at line 1439 of file HTTP2Codec.cpp.

References generateHeaderCallbackWrapper(), proxygen::http2::PING, folly::Random::rand64(), uint64_t, and proxygen::http2::writePing().

Referenced by getUserAgent().

                                                                 {
   // should probably let the caller specify when integrating with session
   // we know HTTPSession sets up events to track ping latency
   uint64_t opaqueData = folly::Random::rand64();
   VLOG(4) << "Generating ping request with opaqueData=" << opaqueData;
   return generateHeaderCallbackWrapper(0, http2::FrameType::PING,
                                        http2::writePing(writeBuf, opaqueData, false /* no ack */));
 }

size_t proxygen::HTTP2Codec::generatePriority	(	folly::IOBufQueue &	writeBuf,
		StreamID	stream,
		const HTTPMessage::HTTPPriority &	pri
	)

overridevirtual

Reimplemented from proxygen::HTTPCodec.

Definition at line 1552 of file HTTP2Codec.cpp.

References generateHeaderCallbackWrapper(), proxygen::HTTPParallelCodec::ingressGoawayAck_, proxygen::HTTPParallelCodec::isStreamIngressEgressAllowed(), proxygen::http2::PRIORITY, stream, and proxygen::http2::writePriority().

Referenced by addPriorityNodes(), and getUserAgent().

                                                                         {
   VLOG(4) << "generating priority for stream=" << stream;
   if (!isStreamIngressEgressAllowed(stream)) {
     VLOG(2) << "suppressed PRIORITY for stream=" << stream
             << " ingressGoawayAck_=" << ingressGoawayAck_;
     return 0;
   }
   return generateHeaderCallbackWrapper(
             stream,
             http2::FrameType::PRIORITY,
             http2::writePriority(writeBuf, stream,
                                  {std::get<0>(pri),
                                    std::get<1>(pri),
                                    std::get<2>(pri)}));
 }

void proxygen::HTTP2Codec::generatePushPromise	(	folly::IOBufQueue &	writeBuf,
		StreamID	stream,
		const HTTPMessage &	msg,
		StreamID	assocStream,
		bool	eom = `false`,
		HTTPHeaderSize *	size = `nullptr`
	)

overridevirtual

Reimplemented from proxygen::HTTPCodec.

Definition at line 1069 of file HTTP2Codec.cpp.

References generateHeaderImpl(), and folly::none.

Referenced by getUserAgent().

                                                            {
   generateHeaderImpl(writeBuf,
                      stream,
                      msg,
                      assocStream,
                      folly::none, /* controlStream */
                      eom,
                      size);
 }

size_t proxygen::HTTP2Codec::generateRstStream	(	folly::IOBufQueue &	writeBuf,
		StreamID	stream,
		ErrorCode	code
	)

overridevirtual

Generate any protocol framing needed to abort a stream.

Returns: number of bytes written

Implements proxygen::HTTPCodec.

Definition at line 1364 of file HTTP2Codec.cpp.

References curHeader_, proxygen::http2::END_STREAM, proxygen::http2::errorCodeToReset(), proxygen::http2::FrameHeader::flags, generateHeaderCallbackWrapper(), proxygen::getErrorCodeString(), proxygen::HTTPParallelCodec::ingressGoawayAck_, ingressWebsocketUpgrade_, proxygen::HTTPParallelCodec::isStreamIngressEgressAllowed(), pendingEndStreamHandling_, proxygen::PROTOCOL_ERROR, proxygen::http2::RST_STREAM, proxygen::http2::FrameHeader::stream, upgradedStreams_, userAgent_, and proxygen::http2::writeRstStream().

Referenced by getUserAgent().

                                                            {
   VLOG(4) << "sending RST_STREAM for stream=" << stream
           << " with code=" << getErrorCodeString(statusCode);
   if (!isStreamIngressEgressAllowed(stream)) {
     VLOG(2) << "suppressed RST_STREAM for stream=" << stream
             << " ingressGoawayAck_=" << ingressGoawayAck_;
     return 0;
   }
   // Suppress any EOM callback for the current frame.
   if (stream == curHeader_.stream) {
     curHeader_.flags &= ~http2::END_STREAM;
     pendingEndStreamHandling_ = false;
     ingressWebsocketUpgrade_ = false;
   }
   upgradedStreams_.erase(stream);
 
   if (statusCode == ErrorCode::PROTOCOL_ERROR) {
     VLOG(2) << "sending RST_STREAM with code=" << getErrorCodeString(statusCode)
             << " for stream=" << stream << " user-agent=" << userAgent_;
   }
   auto code = http2::errorCodeToReset(statusCode);
   return generateHeaderCallbackWrapper(stream, http2::FrameType::RST_STREAM,
                                        http2::writeRstStream(writeBuf, stream, code));
 }

size_t proxygen::HTTP2Codec::generateSettings ( folly::IOBufQueue & )

overridevirtual

Generate a settings message, if supported in the protocol implemented by the codec.

Reimplemented from proxygen::HTTPCodec.

Definition at line 1455 of file HTTP2Codec.cpp.

References proxygen::DOWNSTREAM, egressSettings_, proxygen::ENABLE_CONNECT_PROTOCOL, proxygen::ENABLE_EX_HEADERS, proxygen::ENABLE_PUSH, proxygen::ERROR, generateHeaderCallbackWrapper(), proxygen::HTTPSettings::getAllSettings(), proxygen::HTTPParallelCodec::getTransportDirection(), proxygen::getTransportDirectionString(), proxygen::HEADER_TABLE_SIZE, headerCodec_, proxygen::INITIAL_WINDOW_SIZE, proxygen::MAX_CONCURRENT_STREAMS, proxygen::MAX_FRAME_SIZE, proxygen::MAX_HEADER_LIST_SIZE, proxygen::HPACKCodec::setDecoderHeaderTableMaxSize(), proxygen::HPACKCodec::setMaxUncompressed(), proxygen::http2::SETTINGS, settings, proxygen::THRIFT_CHANNEL_ID, proxygen::THRIFT_CHANNEL_ID_DEPRECATED, proxygen::HTTPParallelCodec::transportDirection_, type, and proxygen::http2::writeSettings().

Referenced by getUserAgent(), and requestUpgrade().

                                                              {
   std::deque<SettingPair> settings;
   for (auto& setting: egressSettings_.getAllSettings()) {
     switch (setting.id) {
       case SettingsId::HEADER_TABLE_SIZE:
         headerCodec_.setDecoderHeaderTableMaxSize(setting.value);
         break;
       case SettingsId::ENABLE_PUSH:
         if (transportDirection_ == TransportDirection::DOWNSTREAM) {
           // HTTP/2 spec says downstream must not send this flag
           // HTTP2Codec uses it to determine if push features are enabled
           continue;
         } else {
           CHECK(setting.value == 0 || setting.value == 1);
         }
         break;
       case SettingsId::MAX_CONCURRENT_STREAMS:
       case SettingsId::INITIAL_WINDOW_SIZE:
       case SettingsId::MAX_FRAME_SIZE:
         break;
       case SettingsId::MAX_HEADER_LIST_SIZE:
         headerCodec_.setMaxUncompressed(setting.value);
         break;
       case SettingsId::ENABLE_EX_HEADERS:
         CHECK(setting.value == 0 || setting.value == 1);
         if (setting.value == 0) {
           continue; // just skip the experimental setting if disabled
         } else {
           VLOG(4) << "generating ENABLE_EX_HEADERS=" << setting.value;
         }
         break;
       case SettingsId::ENABLE_CONNECT_PROTOCOL:
         if (setting.value == 0) {
           continue;
         }
         break;
       case SettingsId::THRIFT_CHANNEL_ID:
       case SettingsId::THRIFT_CHANNEL_ID_DEPRECATED:
         break;
       default:
         LOG(ERROR) << "ignore unknown settingsId="
                    << std::underlying_type<SettingsId>::type(setting.id)
                    << " value=" << setting.value;
         continue;
     }
 
     settings.push_back(SettingPair(setting.id, setting.value));
   }
   VLOG(4) << getTransportDirectionString(getTransportDirection())
           << " generating " << (unsigned)settings.size() << " settings";
   return generateHeaderCallbackWrapper(0, http2::FrameType::SETTINGS,
                                        http2::writeSettings(writeBuf, settings));
 }

size_t proxygen::HTTP2Codec::generateSettingsAck ( folly::IOBufQueue & )

overridevirtual

Generate a settings ack message, if supported in the protocol implemented by the codec.

Reimplemented from proxygen::HTTPCodec.

Definition at line 1531 of file HTTP2Codec.cpp.

References generateHeaderCallbackWrapper(), proxygen::HTTPParallelCodec::getTransportDirection(), proxygen::getTransportDirectionString(), proxygen::http2::SETTINGS, and proxygen::http2::writeSettingsAck().

Referenced by getUserAgent().

                                                                 {
   VLOG(4) << getTransportDirectionString(getTransportDirection())
           << " generating settings ack";
   return generateHeaderCallbackWrapper(0, http2::FrameType::SETTINGS,
                                        http2::writeSettingsAck(writeBuf));
 }

size_t proxygen::HTTP2Codec::generateTrailers	(	folly::IOBufQueue &	writeBuf,
		StreamID	stream,
		const HTTPHeaders &	trailers
	)

overridevirtual

Write the message trailers

Returns: number of bytes written

Implements proxygen::HTTPCodec.

Definition at line 1309 of file HTTP2Codec.cpp.

References folly::IOBufQueue::append(), proxygen::CodecUtil::appendHeaders(), folly::IOBufQueue::chainLength(), wangle::HTTPHeaderSize::compressed, encodeHeaders(), generateContinuation(), generateHeaderCallbackWrapper(), proxygen::http2::HEADERS, proxygen::HTTP_HEADER_NONE, proxygen::http2::kNoPadding, maxSendFrameSize(), min, folly::gen::move, folly::size(), folly::IOBufQueue::split(), and proxygen::http2::writeHeaders().

Referenced by getUserAgent().

                                                                  {
   std::vector<compress::Header> allHeaders;
   CodecUtil::appendHeaders(trailers, allHeaders, HTTP_HEADER_NONE);
 
   HTTPHeaderSize size;
   auto out = encodeHeaders(trailers, allHeaders, &size);
 
   IOBufQueue queue(IOBufQueue::cacheChainLength());
   queue.append(std::move(out));
   auto maxFrameSize = maxSendFrameSize();
   if (queue.chainLength() > 0) {
     folly::Optional<http2::PriorityUpdate> pri;
     auto remainingFrameSize = maxFrameSize;
     auto chunk = queue.split(std::min(remainingFrameSize, queue.chainLength()));
     bool endHeaders = queue.chainLength() == 0;
     generateHeaderCallbackWrapper(stream,
                                   http2::FrameType::HEADERS,
                                   http2::writeHeaders(writeBuf,
                                                       std::move(chunk),
                                                       stream,
                                                       pri,
                                                       http2::kNoPadding,
                                                       true /*eom*/,
                                                       endHeaders));
 
     if (!endHeaders) {
       generateContinuation(writeBuf, queue, stream, maxFrameSize);
     }
   }
 
   return size.compressed;
 }

size_t proxygen::HTTP2Codec::generateWindowUpdate	(	folly::IOBufQueue &	writeBuf,
		StreamID	stream,
		uint32_t	delta
	)

overridevirtual

Reimplemented from proxygen::HTTPCodec.

Definition at line 1538 of file HTTP2Codec.cpp.

References generateHeaderCallbackWrapper(), proxygen::HTTPParallelCodec::ingressGoawayAck_, proxygen::HTTPParallelCodec::isStreamIngressEgressAllowed(), proxygen::http2::WINDOW_UPDATE, and proxygen::http2::writeWindowUpdate().

Referenced by getUserAgent().

                                                         {
   VLOG(4) << "generating window update for stream=" << stream
           << ": Processed " << delta << " bytes";
   if (!isStreamIngressEgressAllowed(stream)) {
     VLOG(2) << "suppressed WINDOW_UPDATE for stream=" << stream
             << " ingressGoawayAck_=" << ingressGoawayAck_;
     return 0;
   }
   return generateHeaderCallbackWrapper(stream, http2::FrameType::WINDOW_UPDATE,
                                        http2::writeWindowUpdate(writeBuf, stream, delta));
 }

uint32_t proxygen::HTTP2Codec::getDefaultWindowSize ( ) const

inlineoverridevirtual

Get the default size of flow control windows for this protocol

Reimplemented from proxygen::HTTPCodec.

Definition at line 117 of file HTTP2Codec.h.

References proxygen::http2::kInitialWindow.

Referenced by TEST_F().

                                                  {
     return http2::kInitialWindow;
   }

HTTPSettings* proxygen::HTTP2Codec::getEgressSettings ( )

inlineoverridevirtual

Reimplemented from proxygen::HTTPCodec.

Definition at line 116 of file HTTP2Codec.h.

References egressSettings_.

116 { return &egressSettings_; }

proxygen::HTTP2Codec::egressSettings_

HTTPSettings egressSettings_

Definition: HTTP2Codec.h:260

const HeaderIndexingStrategy* proxygen::HTTP2Codec::getHeaderIndexingStrategy ( ) const

inline

Definition at line 174 of file HTTP2Codec.h.

References checkConnectionError(), checkNewStream(), encodeHeaders(), generateHeaderCallbackWrapper(), generateHeaderImpl(), proxygen::HPACKCodec::getHeaderIndexingStrategy(), handleEndStream(), handleSettings(), headerCodec_, parseAllData(), parseCertificate(), parseCertificateRequest(), parseContinuation(), parseDataFrameData(), parseExHeaders(), parseFrame(), parseGoaway(), parseHeaders(), parseHeadersCheckConcurrentStreams(), parseHeadersDecodeFrames(), parseHeadersImpl(), parsePing(), parsePriority(), parsePushPromise(), parseRstStream(), parseSettings(), parseWindowUpdate(), settings, folly::size(), type, and uint32_t.

Referenced by HTTPDownstreamTest< SPDY3_1CodecPair >::HTTPDownstreamTest(), TEST_F(), HTTPDownstreamTest< C >::testSimpleUpgrade(), and HTTPUpstreamTest< C >::testSimpleUpgrade().

                                                                   {
     return headerCodec_.getHeaderIndexingStrategy();
   }

HPACKTableInfo proxygen::HTTP2Codec::getHPACKTableInfo ( ) const

inlineoverridevirtual

Gets both the egress and ingress header table size, bytes stored in header table, and the number of headers stored in the header table

Reimplemented from proxygen::HTTPCodec.

Definition at line 151 of file HTTP2Codec.h.

References proxygen::HPACKCodec::getHPACKTableInfo(), headerCodec_, and requestUpgrade().

                                                     {
     return headerCodec_.getHPACKTableInfo();
   }

const HTTPSettings* proxygen::HTTP2Codec::getIngressSettings ( ) const

inlineoverridevirtual

Reimplemented from proxygen::HTTPCodec.

Definition at line 113 of file HTTP2Codec.h.

References ingressSettings_.

                                                           {
     return &ingressSettings_;
   }

CodecProtocol proxygen::HTTP2Codec::getProtocol ( ) const

inlineoverridevirtual

Gets the session protocol currently used by the codec. This can be mapped to a string for logging and diagnostic use.

Implements proxygen::HTTPCodec.

Definition at line 40 of file HTTP2Codec.h.

References proxygen::HTTP_2.

Referenced by TEST().

                                              {
     return CodecProtocol::HTTP_2;
   }

uint64_t proxygen::HTTP2Codec::getReceivedFrameCount ( ) const

inline

Definition at line 160 of file HTTP2Codec.h.

References receivedFrameCount_.

                                          {
     return receivedFrameCount_;
   }

const std::string& proxygen::HTTP2Codec::getUserAgent ( ) const

inlineoverridevirtual

Gets the user agent string of the client. Thus, it is only meaningful for a DOWNSTREAM session. Note that the value is available after onHeadersComplete(). It can help in diagnosing the interactions between different codec implementation.

Implements proxygen::HTTPCodec.

Definition at line 44 of file HTTP2Codec.h.

References generateBody(), generateCertificate(), generateCertificateRequest(), generateChunkHeader(), generateChunkTerminator(), generateConnectionPreface(), generateContinuation(), generateEOM(), generateExHeader(), generateGoaway(), generateHeader(), generatePingReply(), generatePingRequest(), generatePriority(), generatePushPromise(), generateRstStream(), generateSettings(), generateSettingsAck(), generateTrailers(), generateWindowUpdate(), onIngress(), onIngressUpgradeMessage(), folly::size(), statusCode, uint16_t, uint32_t, uint64_t, userAgent_, and fizz::detail::writeBuf().

                                                  {
     return userAgent_;
   }

ErrorCode proxygen::HTTP2Codec::handleEndStream ( )

private

Definition at line 252 of file HTTP2Codec.cpp.

References proxygen::http2::CONTINUATION, curHeader_, proxygen::http2::DATA, proxygen::HTTPParallelCodec::deliverCallbackIfAllowed(), proxygen::http2::END_STREAM, proxygen::http2::EX_HEADERS, expectedContinuationStream_, proxygen::http2::FrameHeader::flags, proxygen::http2::HEADERS, ingressWebsocketUpgrade_, proxygen::NO_ERROR, proxygen::HTTPCodec::Callback::onMessageComplete(), pendingEndStreamHandling_, proxygen::http2::FrameHeader::stream, and proxygen::http2::FrameHeader::type.

Referenced by getHeaderIndexingStrategy(), parseAllData(), parseDataFrameData(), and parseHeadersImpl().

                                       {
   if (curHeader_.type != http2::FrameType::HEADERS &&
       curHeader_.type != http2::FrameType::EX_HEADERS &&
       curHeader_.type != http2::FrameType::CONTINUATION &&
       curHeader_.type != http2::FrameType::DATA) {
     return ErrorCode::NO_ERROR;
   }
 
   // do we need to handle case where this stream has already aborted via
   // another callback (onHeadersComplete/onBody)?
   pendingEndStreamHandling_ |= (curHeader_.flags & http2::END_STREAM);
 
   // with a websocket upgrade, we need to send message complete cb to
   // mirror h1x codec's behavior. when the stream closes, we need to
   // send another callback to clean up the stream's resources.
   if (ingressWebsocketUpgrade_) {
     ingressWebsocketUpgrade_ = false;
     deliverCallbackIfAllowed(&HTTPCodec::Callback::onMessageComplete,
                              "onMessageComplete", curHeader_.stream, true);
   }
 
   if (pendingEndStreamHandling_ && expectedContinuationStream_ == 0) {
     pendingEndStreamHandling_ = false;
     deliverCallbackIfAllowed(&HTTPCodec::Callback::onMessageComplete,
                              "onMessageComplete", curHeader_.stream, false);
   }
   return ErrorCode::NO_ERROR;
 }

ErrorCode proxygen::HTTP2Codec::handleSettings ( const std::deque< SettingPair > & settings )

private

Definition at line 721 of file HTTP2Codec.cpp.

References proxygen::HTTPParallelCodec::callback_, curHeader_, egressSettings_, proxygen::ENABLE_CONNECT_PROTOCOL, proxygen::ENABLE_EX_HEADERS, proxygen::ENABLE_PUSH, proxygen::HTTPSettings::getSetting(), proxygen::HTTPParallelCodec::getTransportDirection(), proxygen::getTransportDirectionString(), proxygen::HTTPParallelCodec::goawayErrorMessage_, proxygen::HEADER_TABLE_SIZE, headerCodec_, ingressSettings_, proxygen::INITIAL_WINDOW_SIZE, proxygen::http2::kMaxFramePayloadLength, proxygen::http2::kMaxFramePayloadLengthMin, proxygen::http2::kMaxHeaderTableSize, proxygen::http2::kMaxWindowUpdateSize, proxygen::MAX_CONCURRENT_STREAMS, proxygen::MAX_FRAME_SIZE, proxygen::MAX_HEADER_LIST_SIZE, proxygen::NO_ERROR, proxygen::HTTPCodec::Callback::onSettings(), proxygen::PROTOCOL_ERROR, ptr, proxygen::HPACKCodec::setEncoderHeaderTableSize(), proxygen::HTTPSettings::setSetting(), proxygen::SETTINGS_HTTP_CERT_AUTH, proxygen::http2::FrameHeader::stream, proxygen::THRIFT_CHANNEL_ID, proxygen::THRIFT_CHANNEL_ID_DEPRECATED, proxygen::HTTPParallelCodec::transportDirection_, uint32_t, and proxygen::UPSTREAM.

Referenced by getHeaderIndexingStrategy(), onIngressUpgradeMessage(), and parseSettings().

                                                                           {
   SettingsList settingsList;
   for (auto& setting: settings) {
     switch (setting.first) {
       case SettingsId::HEADER_TABLE_SIZE:
       {
         uint32_t tableSize = setting.second;
         if (setting.second > http2::kMaxHeaderTableSize) {
           VLOG(2) << "Limiting table size from " << tableSize << " to " <<
             http2::kMaxHeaderTableSize;
           tableSize = http2::kMaxHeaderTableSize;
         }
         headerCodec_.setEncoderHeaderTableSize(tableSize);
       }
       break;
       case SettingsId::ENABLE_PUSH:
         if ((setting.second != 0 && setting.second != 1) ||
             (setting.second == 1 &&
              transportDirection_ == TransportDirection::UPSTREAM)) {
           goawayErrorMessage_ = folly::to<string>(
               "GOAWAY error: ENABLE_PUSH invalid setting=", setting.second,
               " for streamID=", curHeader_.stream);
           VLOG(4) << goawayErrorMessage_;
           return ErrorCode::PROTOCOL_ERROR;
         }
         break;
       case SettingsId::MAX_CONCURRENT_STREAMS:
         break;
       case SettingsId::INITIAL_WINDOW_SIZE:
         if (setting.second > http2::kMaxWindowUpdateSize) {
           goawayErrorMessage_ = folly::to<string>(
               "GOAWAY error: INITIAL_WINDOW_SIZE invalid size=", setting.second,
               " for streamID=", curHeader_.stream);
           VLOG(4) << goawayErrorMessage_;
           return ErrorCode::PROTOCOL_ERROR;
         }
         break;
       case SettingsId::MAX_FRAME_SIZE:
         if (setting.second < http2::kMaxFramePayloadLengthMin ||
             setting.second > http2::kMaxFramePayloadLength) {
           goawayErrorMessage_ = folly::to<string>(
               "GOAWAY error: MAX_FRAME_SIZE invalid size=", setting.second,
               " for streamID=", curHeader_.stream);
           VLOG(4) << goawayErrorMessage_;
           return ErrorCode::PROTOCOL_ERROR;
         }
         ingressSettings_.setSetting(SettingsId::MAX_FRAME_SIZE, setting.second);
         break;
       case SettingsId::MAX_HEADER_LIST_SIZE:
         break;
       case SettingsId::ENABLE_EX_HEADERS:
       {
         auto ptr = egressSettings_.getSetting(SettingsId::ENABLE_EX_HEADERS);
         if (ptr && ptr->value > 0) {
           VLOG(4) << getTransportDirectionString(getTransportDirection())
                   << " got ENABLE_EX_HEADERS=" << setting.second;
           if (setting.second != 0 && setting.second != 1) {
             goawayErrorMessage_ = folly::to<string>(
               "GOAWAY error: invalid ENABLE_EX_HEADERS=", setting.second,
               " for streamID=", curHeader_.stream);
             VLOG(4) << goawayErrorMessage_;
             return ErrorCode::PROTOCOL_ERROR;
           }
           break;
         } else {
           // egress ENABLE_EX_HEADERS is disabled, consider the ingress
           // ENABLE_EX_HEADERS as unknown setting, and ignore it.
           continue;
         }
       }
       case SettingsId::ENABLE_CONNECT_PROTOCOL:
         if (setting.second > 1) {
           goawayErrorMessage_ = folly::to<string>(
               "GOAWAY error: ENABLE_CONNECT_PROTOCOL invalid number=",
               setting.second, " for streamID=", curHeader_.stream);
           VLOG(4) << goawayErrorMessage_;
           return ErrorCode::PROTOCOL_ERROR;
         }
         break;
       case SettingsId::THRIFT_CHANNEL_ID:
       case SettingsId::THRIFT_CHANNEL_ID_DEPRECATED:
         break;
       case SettingsId::SETTINGS_HTTP_CERT_AUTH:
         break;
       default:
         continue; // ignore unknown setting
     }
     ingressSettings_.setSetting(setting.first, setting.second);
     settingsList.push_back(*ingressSettings_.getSetting(setting.first));
   }
   if (callback_) {
     callback_->onSettings(settingsList);
   }
   return ErrorCode::NO_ERROR;
 }

bool proxygen::HTTP2Codec::isRequest ( StreamID id ) const

inline

Definition at line 138 of file HTTP2Codec.h.

References addPriorityNodes(), proxygen::DOWNSTREAM, mapPriorityToDependency(), proxygen::HTTPParallelCodec::transportDirection_, uint8_t, and proxygen::UPSTREAM.

Referenced by parseExHeaders(), and parseHeadersDecodeFrames().

                                     {
     return ((transportDirection_ == TransportDirection::DOWNSTREAM &&
              (id & 0x1) == 1) ||
             (transportDirection_ == TransportDirection::UPSTREAM &&
              (id & 0x1) == 0));
   }

HTTPCodec::StreamID proxygen::HTTP2Codec::mapPriorityToDependency ( uint8_t ) const

overridevirtual

Map the given linear priority to the correct parent node dependency

Reimplemented from proxygen::HTTPCodec.

Definition at line 1627 of file HTTP2Codec.cpp.

References min, uint8_t, and virtualPriorityNodes_.

Referenced by isRequest().

                                                           {
   // If the priority is out of the maximum index of virtual nodes array, we
   // return the lowest level virtual node as a punishment of not setting
   // priority correctly.
   return virtualPriorityNodes_.empty()
     ? 0
     : virtualPriorityNodes_[
         std::min(priority, uint8_t(virtualPriorityNodes_.size() - 1))];
 }

uint32_t proxygen::HTTP2Codec::maxRecvFrameSize ( ) const

inlineprivate

Definition at line 233 of file HTTP2Codec.h.

References egressSettings_, folly::pushmi::operators::error(), proxygen::HTTPSettings::getSetting(), proxygen::http2::kMaxFramePayloadLengthMin, proxygen::MAX_FRAME_SIZE, parsingTrailers(), streamError(), string, and uint32_t.

Referenced by onIngress().

                                     {
     return (uint32_t)egressSettings_.getSetting(SettingsId::MAX_FRAME_SIZE,
                                       http2::kMaxFramePayloadLengthMin);
   }

size_t proxygen::HTTP2Codec::maxSendFrameSize ( ) const

inlineprivate

Definition at line 229 of file HTTP2Codec.h.

References proxygen::HTTPSettings::getSetting(), ingressSettings_, proxygen::http2::kMaxFramePayloadLengthMin, proxygen::MAX_FRAME_SIZE, and uint32_t.

Referenced by generateBody(), generateCertificate(), generateHeaderImpl(), and generateTrailers().

                                   {
     return (uint32_t)ingressSettings_.getSetting(SettingsId::MAX_FRAME_SIZE,
                                        http2::kMaxFramePayloadLengthMin);
   }

void proxygen::HTTP2Codec::onDecodeError ( HPACK::DecodeError decodeError )

overridevirtual

Implements proxygen::HPACK::StreamingCallback.

Definition at line 646 of file HTTP2Codec.cpp.

References proxygen::HeaderDecodeInfo::decodeError, and decodeInfo_.

                                                            {
   decodeInfo_.decodeError = decodeError;
 }

void proxygen::HTTP2Codec::onHeader	(	const folly::fbstring &	name,
		const folly::fbstring &	value
	)

overridevirtual

Implements proxygen::HPACK::StreamingCallback.

Definition at line 606 of file HTTP2Codec.cpp.

References decodeInfo_, headerCodec_, proxygen::HeaderDecodeInfo::onHeader(), proxygen::HeaderDecodeInfo::parsingError, folly::basic_fbstring< E, T, A, Storage >::toStdString(), proxygen::HTTPParallelCodec::transportDirection_, uint32_t, and userAgent_.

                                                       {
   if (decodeInfo_.onHeader(name, value)) {
     if (name == "user-agent" && userAgent_.empty()) {
       userAgent_ = value.toStdString();
     }
   } else {
     VLOG(4) << "dir=" << uint32_t(transportDirection_) <<
       decodeInfo_.parsingError << " codec=" << headerCodec_;
   }
 }

void proxygen::HTTP2Codec::onHeadersComplete ( HTTPHeaderSize decodedSize )

overridevirtual

Implements proxygen::HPACK::StreamingCallback.

Definition at line 618 of file HTTP2Codec.cpp.

References proxygen::CONNECT, curHeader_, decodeInfo_, proxygen::DOWNSTREAM, proxygen::HTTPMessage::getMethod(), proxygen::HTTPMessage::getStatusCode(), proxygen::HTTPMessage::getUpgradeProtocol(), proxygen::HTTPRequestVerifier::hasUpgradeProtocol(), ingressWebsocketUpgrade_, proxygen::http2::kProtocolString, proxygen::headers::kWebsocketString, proxygen::HeaderDecodeInfo::msg, proxygen::HeaderDecodeInfo::onHeadersComplete(), proxygen::HeaderDecodeInfo::parsingError, proxygen::HTTPMessage::setIngressWebsocketUpgrade(), proxygen::http2::FrameHeader::stream, proxygen::HTTPParallelCodec::transportDirection_, upgradedStreams_, and proxygen::HeaderDecodeInfo::verifier.

                                                              {
   decodeInfo_.onHeadersComplete(decodedSize);
   decodeInfo_.msg->setAdvancedProtocolString(http2::kProtocolString);
 
   HTTPMessage* msg = decodeInfo_.msg.get();
   HTTPRequestVerifier& verifier = decodeInfo_.verifier;
   if ((transportDirection_ == TransportDirection::DOWNSTREAM) &&
       verifier.hasUpgradeProtocol() &&
       (*msg->getUpgradeProtocol() == headers::kWebsocketString) &&
       msg->getMethod() == HTTPMethod::CONNECT) {
     msg->setIngressWebsocketUpgrade();
     ingressWebsocketUpgrade_ = true;
   } else {
     auto it = upgradedStreams_.find(curHeader_.stream);
     if (it != upgradedStreams_.end()) {
       upgradedStreams_.erase(curHeader_.stream);
       // a websocket upgrade was sent on this stream.
       if (msg->getStatusCode() != 200) {
         decodeInfo_.parsingError =
           folly::to<string>("Invalid response code to a websocket upgrade: ",
                             msg->getStatusCode());
         return;
       }
       msg->setIngressWebsocketUpgrade();
     }
   }
 }

size_t proxygen::HTTP2Codec::onIngress ( const folly::IOBuf & buf )

overridevirtual

Parse ingress data.

Parameters

buf	A single IOBuf of data to parse

Returns: Number of bytes consumed.

Implements proxygen::HTTPCodec.

Definition at line 70 of file HTTP2Codec.cpp.

References proxygen::HTTPParallelCodec::callback_, checkConnectionError(), curHeader_, proxygen::http2::DATA, proxygen::http2::FrameHeader::flags, FOLLY_SCOPED_TRACE_SECTION, proxygen::FRAME_SIZE_ERROR, frameState_, proxygen::http2::getFrameTypeString(), proxygen::HTTPParallelCodec::goawayErrorMessage_, proxygen::http2::kConnectionPreface, proxygen::http2::kFrameHeaderSize, proxygen::http2::FrameHeader::length, maxRecvFrameSize(), proxygen::NO_ERROR, proxygen::HTTPCodec::Callback::onFrameHeader(), parseDataFrameData(), parseFrame(), proxygen::http2::parseFrameHeader(), pendingDataFrameBytes_, pendingDataFramePaddingBytes_, proxygen::PROTOCOL_ERROR, folly::io::detail::CursorBase< Derived, BufType >::readFixedString(), receivedFrameCount_, proxygen::http2::SETTINGS, proxygen::http2::FrameHeader::stream, folly::io::detail::CursorBase< Derived, BufType >::totalLength(), and proxygen::http2::FrameHeader::type.

Referenced by getUserAgent().

                                                   {
   // TODO: ensure only 1 parse at a time on stack.
   FOLLY_SCOPED_TRACE_SECTION("HTTP2Codec - onIngress");
 
   Cursor cursor(&buf);
   size_t parsed = 0;
   ErrorCode connError = ErrorCode::NO_ERROR;
   for (auto bufLen = cursor.totalLength();
        connError == ErrorCode::NO_ERROR;
        bufLen = cursor.totalLength()) {
     if (frameState_ == FrameState::UPSTREAM_CONNECTION_PREFACE) {
       if (bufLen >= http2::kConnectionPreface.length()) {
         auto test = cursor.readFixedString(http2::kConnectionPreface.length());
         parsed += http2::kConnectionPreface.length();
         if (test != http2::kConnectionPreface) {
           goawayErrorMessage_ = "missing connection preface";
           VLOG(4) << goawayErrorMessage_;
           connError = ErrorCode::PROTOCOL_ERROR;
         }
         frameState_ = FrameState::FRAME_HEADER;
       } else {
         break;
       }
     } else if (frameState_ == FrameState::FRAME_HEADER ||
                frameState_ == FrameState::DOWNSTREAM_CONNECTION_PREFACE) {
       // Waiting to parse the common frame header
       if (bufLen >= http2::kFrameHeaderSize) {
         connError = parseFrameHeader(cursor, curHeader_);
         parsed += http2::kFrameHeaderSize;
         if (frameState_ == FrameState::DOWNSTREAM_CONNECTION_PREFACE &&
             curHeader_.type != http2::FrameType::SETTINGS) {
           goawayErrorMessage_ = folly::to<string>(
               "GOAWAY error: got invalid connection preface frame type=",
               getFrameTypeString(curHeader_.type), "(", curHeader_.type, ")",
               " for streamID=", curHeader_.stream);
           VLOG(4) << goawayErrorMessage_;
           connError = ErrorCode::PROTOCOL_ERROR;
         }
         if (curHeader_.length > maxRecvFrameSize()) {
           VLOG(4) << "Excessively large frame len=" << curHeader_.length;
           connError = ErrorCode::FRAME_SIZE_ERROR;
         }
 
         if (callback_) {
           callback_->onFrameHeader(
             curHeader_.stream,
             curHeader_.flags,
             curHeader_.length,
             static_cast<uint8_t>(curHeader_.type));
         }
 
         frameState_ = (curHeader_.type == http2::FrameType::DATA) ?
           FrameState::DATA_FRAME_DATA : FrameState::FRAME_DATA;
         pendingDataFrameBytes_ = curHeader_.length;
         pendingDataFramePaddingBytes_ = 0;
 #ifndef NDEBUG
         receivedFrameCount_++;
 #endif
       } else {
         break;
       }
     } else if (frameState_ == FrameState::DATA_FRAME_DATA && bufLen > 0 &&
                (bufLen < curHeader_.length ||
                 pendingDataFrameBytes_ < curHeader_.length)) {
       // FrameState::DATA_FRAME_DATA with partial data only
       size_t dataParsed = 0;
       connError = parseDataFrameData(cursor, bufLen, dataParsed);
       if (dataParsed == 0 && pendingDataFrameBytes_ > 0) {
         // We received only the padding byte, we will wait for more
         break;
       } else {
         parsed += dataParsed;
         if (pendingDataFrameBytes_ == 0) {
           frameState_ = FrameState::FRAME_HEADER;
         }
       }
     } else { // FrameState::FRAME_DATA
              // or FrameState::DATA_FRAME_DATA with all data available
       // Already parsed the common frame header
       const auto frameLen = curHeader_.length;
       if (bufLen >= frameLen) {
         connError = parseFrame(cursor);
         parsed += curHeader_.length;
         frameState_ = FrameState::FRAME_HEADER;
       } else {
         break;
       }
     }
   }
   checkConnectionError(connError, &buf);
   return parsed;
 }

bool proxygen::HTTP2Codec::onIngressUpgradeMessage ( const HTTPMessage & )

overridevirtual

Invoked on a codec that has been upgraded to via an HTTPMessage on a different codec. The codec may return false to halt the upgrade.

Reimplemented from proxygen::HTTPCodec.

Definition at line 1010 of file HTTP2Codec.cpp.

References folly::IOBufQueue::append(), c, proxygen::HTTPMessage::getHeaders(), proxygen::HTTPHeaders::getNumberOfValues(), proxygen::HTTPHeaders::getSingleOrEmpty(), handleSettings(), proxygen::http2::kMaxFramePayloadLength, proxygen::http2::kProtocolSettingsHeader, folly::gen::move, proxygen::NO_ERROR, proxygen::HTTPParallelCodec::onIngressUpgradeMessage(), proxygen::http2::parseSettings(), proxygen::http2::SETTINGS, settings, and uint32_t.

Referenced by getUserAgent().

                                                                {
   if (!HTTPParallelCodec::onIngressUpgradeMessage(msg)) {
     return false;
   }
   if (msg.getHeaders().getNumberOfValues(http2::kProtocolSettingsHeader) != 1) {
     VLOG(4) << __func__ << " with no HTTP2-Settings";
     return false;
   }
 
   const auto& settingsHeader = msg.getHeaders().getSingleOrEmpty(
     http2::kProtocolSettingsHeader);
   if (settingsHeader.empty()) {
     return true;
   }
 
   auto decoded = base64url_decode(settingsHeader);
 
   // Must be well formed Base64Url and not too large
   if (decoded.empty() || decoded.length() > http2::kMaxFramePayloadLength) {
     VLOG(4) << __func__ << " failed to decode HTTP2-Settings";
     return false;
   }
   std::unique_ptr<IOBuf> decodedBuf = IOBuf::wrapBuffer(decoded.data(),
                                                         decoded.length());
   IOBufQueue settingsQueue{IOBufQueue::cacheChainLength()};
   settingsQueue.append(std::move(decodedBuf));
   Cursor c(settingsQueue.front());
   std::deque<SettingPair> settings;
   // downcast is ok because of above length check
   http2::FrameHeader frameHeader{
     (uint32_t)settingsQueue.chainLength(), 0, http2::FrameType::SETTINGS, 0, 0};
   auto err = http2::parseSettings(c, frameHeader, settings);
   if (err != ErrorCode::NO_ERROR) {
     VLOG(4) << __func__ << " bad settings frame";
     return false;
   }
 
   if (handleSettings(settings) != ErrorCode::NO_ERROR) {
     VLOG(4) << __func__ << " handleSettings failed";
     return false;
   }
 
   return true;
 }

ErrorCode proxygen::HTTP2Codec::parseAllData ( folly::io::Cursor & cursor )

private

Definition at line 281 of file HTTP2Codec.cpp.

References proxygen::HTTPParallelCodec::callback_, curHeader_, proxygen::HTTPParallelCodec::deliverCallbackIfAllowed(), folly::IOBuf::empty(), handleEndStream(), proxygen::http2::FrameHeader::length, folly::gen::move, proxygen::HTTPCodec::Callback::onBody(), proxygen::http2::parseData(), RETURN_IF_ERROR, proxygen::http2::FrameHeader::stream, and uint16_t.

Referenced by getHeaderIndexingStrategy(), and parseFrame().

                                                  {
   std::unique_ptr<IOBuf> outData;
   uint16_t padding = 0;
   VLOG(10) << "parsing all frame DATA bytes for stream=" << curHeader_.stream <<
     " length=" << curHeader_.length;
   auto ret = http2::parseData(cursor, curHeader_, outData, padding);
   RETURN_IF_ERROR(ret);
 
   if (callback_ && (padding > 0 || (outData && !outData->empty()))) {
     if (!outData) {
       outData = std::make_unique<IOBuf>();
     }
     deliverCallbackIfAllowed(&HTTPCodec::Callback::onBody, "onBody",
                              curHeader_.stream, std::move(outData), padding);
   }
   return handleEndStream();
 }

ErrorCode proxygen::HTTP2Codec::parseCertificate ( folly::io::Cursor & cursor )

private

Definition at line 945 of file HTTP2Codec.cpp.

References folly::IOBufQueue::append(), proxygen::HTTPParallelCodec::callback_, folly::IOBufQueue::chainLength(), folly::IOBufQueue::clear(), curAuthenticatorBlock_, curCertId_, curHeader_, folly::IOBufQueue::empty(), proxygen::http2::FrameHeader::flags, proxygen::http2::kMaxAuthenticatorBufSize, proxygen::http2::FrameHeader::length, folly::IOBufQueue::move(), folly::gen::move, proxygen::NO_ERROR, proxygen::HTTPCodec::Callback::onCertificate(), proxygen::http2::parseCertificate(), proxygen::PROTOCOL_ERROR, RETURN_IF_ERROR, proxygen::http2::TO_BE_CONTINUED, and uint16_t.

Referenced by getHeaderIndexingStrategy(), and parseFrame().

                                                      {
   VLOG(4) << "parsing CERTIFICATE frame length=" << curHeader_.length;
   uint16_t certId = 0;
   std::unique_ptr<IOBuf> authData;
   auto err = http2::parseCertificate(cursor, curHeader_, certId, authData);
   RETURN_IF_ERROR(err);
   if (curAuthenticatorBlock_.empty()) {
     curCertId_ = certId;
   } else if (certId != curCertId_) {
     // Received CERTIFICATE frame with different Cert-ID.
     return ErrorCode::PROTOCOL_ERROR;
   }
   curAuthenticatorBlock_.append(std::move(authData));
   if (curAuthenticatorBlock_.chainLength() > http2::kMaxAuthenticatorBufSize) {
     // Received excessively long authenticator.
     return ErrorCode::PROTOCOL_ERROR;
   }
   if (!(curHeader_.flags & http2::TO_BE_CONTINUED)) {
     auto authenticator = curAuthenticatorBlock_.move();
     if (callback_) {
       callback_->onCertificate(certId, std::move(authenticator));
     } else {
       curAuthenticatorBlock_.clear();
     }
   }
   return ErrorCode::NO_ERROR;
 }

ErrorCode proxygen::HTTP2Codec::parseCertificateRequest ( folly::io::Cursor & cursor )

private

Definition at line 931 of file HTTP2Codec.cpp.

References proxygen::HTTPParallelCodec::callback_, curHeader_, proxygen::http2::FrameHeader::length, folly::gen::move, proxygen::NO_ERROR, proxygen::HTTPCodec::Callback::onCertificateRequest(), proxygen::http2::parseCertificateRequest(), RETURN_IF_ERROR, and uint16_t.

Referenced by getHeaderIndexingStrategy(), and parseFrame().

                                                             {
   VLOG(4) << "parsing CERTIFICATE_REQUEST frame length=" << curHeader_.length;
   uint16_t requestId = 0;
   std::unique_ptr<IOBuf> authRequest;
 
   auto err = http2::parseCertificateRequest(
       cursor, curHeader_, requestId, authRequest);
   RETURN_IF_ERROR(err);
   if (callback_) {
     callback_->onCertificateRequest(requestId, std::move(authRequest));
   }
   return ErrorCode::NO_ERROR;
 }

ErrorCode proxygen::HTTP2Codec::parseContinuation ( folly::io::Cursor & cursor )

private

Definition at line 413 of file HTTP2Codec.cpp.

References curHeader_, proxygen::http2::FrameHeader::length, folly::gen::move, folly::none, proxygen::http2::parseContinuation(), parseHeadersImpl(), RETURN_IF_ERROR, and proxygen::http2::FrameHeader::stream.

Referenced by getHeaderIndexingStrategy(), and parseFrame().

                                                       {
   std::unique_ptr<IOBuf> headerBuf;
   VLOG(4) << "parsing CONTINUATION frame for stream=" << curHeader_.stream <<
     " length=" << curHeader_.length;
   auto err = http2::parseContinuation(cursor, curHeader_, headerBuf);
   RETURN_IF_ERROR(err);
   err = parseHeadersImpl(cursor, std::move(headerBuf),
                          folly::none, folly::none, folly::none);
   return err;
 }

ErrorCode proxygen::HTTP2Codec::parseDataFrameData	(	folly::io::Cursor &	cursor,
		size_t	bufLen,
		size_t &	parsed
	)

private

Definition at line 299 of file HTTP2Codec.cpp.

References proxygen::HTTPParallelCodec::callback_, folly::io::detail::CursorBase< Derived, BufType >::clone(), curHeader_, proxygen::HTTPParallelCodec::deliverCallbackIfAllowed(), folly::IOBuf::empty(), FOLLY_SCOPED_TRACE_SECTION, proxygen::http2::frameHasPadding(), handleEndStream(), proxygen::http2::FrameHeader::length, min, folly::gen::move, proxygen::NO_ERROR, proxygen::HTTPCodec::Callback::onBody(), proxygen::http2::parseDataBegin(), proxygen::http2::parseDataEnd(), pendingDataFrameBytes_, pendingDataFramePaddingBytes_, RETURN_IF_ERROR, proxygen::http2::FrameHeader::stream, and uint16_t.

Referenced by getHeaderIndexingStrategy(), and onIngress().

                                                          {
   FOLLY_SCOPED_TRACE_SECTION("HTTP2Codec - parseDataFrameData");
   if (bufLen == 0) {
     VLOG(10) << "No data to parse";
     return ErrorCode::NO_ERROR;
   }
 
   std::unique_ptr<IOBuf> outData;
   uint16_t padding = 0;
   VLOG(10) << "parsing DATA frame data for stream=" << curHeader_.stream <<
     " frame data length=" << curHeader_.length << " pendingDataFrameBytes_=" <<
     pendingDataFrameBytes_ << " pendingDataFramePaddingBytes_=" <<
     pendingDataFramePaddingBytes_ << " bufLen=" << bufLen <<
     " parsed=" << parsed;
   // Parse the padding information only the first time
   if (pendingDataFrameBytes_ == curHeader_.length &&
     pendingDataFramePaddingBytes_ == 0) {
     if (frameHasPadding(curHeader_) && bufLen == 1) {
       // We need to wait for more bytes otherwise we won't be able to pass
       // the correct padding to the first onBody call
       return ErrorCode::NO_ERROR;
     }
     const auto ret = http2::parseDataBegin(cursor, curHeader_, parsed, padding);
     RETURN_IF_ERROR(ret);
     if (padding > 0) {
       pendingDataFramePaddingBytes_ = padding - 1;
       pendingDataFrameBytes_--;
       bufLen--;
       parsed++;
     }
     VLOG(10) << "out padding=" << padding << " pendingDataFrameBytes_=" <<
       pendingDataFrameBytes_ << " pendingDataFramePaddingBytes_=" <<
       pendingDataFramePaddingBytes_ << " bufLen=" << bufLen <<
       " parsed=" << parsed;
   }
   if (bufLen > 0) {
     // Check if we have application data to parse
     if (pendingDataFrameBytes_ > pendingDataFramePaddingBytes_) {
       const size_t pendingAppData =
         pendingDataFrameBytes_ - pendingDataFramePaddingBytes_;
       const size_t toClone = std::min(pendingAppData, bufLen);
       cursor.clone(outData, toClone);
       bufLen -= toClone;
       pendingDataFrameBytes_ -= toClone;
       parsed += toClone;
       VLOG(10) << "parsed some app data, pendingDataFrameBytes_=" <<
         pendingDataFrameBytes_ << " pendingDataFramePaddingBytes_=" <<
         pendingDataFramePaddingBytes_ << " bufLen=" << bufLen <<
         " parsed=" << parsed;
     }
     // Check if we have padding bytes to parse
     if (bufLen > 0 && pendingDataFramePaddingBytes_ > 0) {
       size_t toSkip = 0;
       auto ret = http2::parseDataEnd(cursor, bufLen,
                                      pendingDataFramePaddingBytes_, toSkip);
       RETURN_IF_ERROR(ret);
       pendingDataFrameBytes_ -= toSkip;
       pendingDataFramePaddingBytes_ -= toSkip;
       parsed += toSkip;
       VLOG(10) << "parsed some padding, pendingDataFrameBytes_=" <<
         pendingDataFrameBytes_ << " pendingDataFramePaddingBytes_=" <<
         pendingDataFramePaddingBytes_ << " bufLen=" << bufLen <<
         " parsed=" << parsed;
     }
   }
 
   if (callback_ && (padding > 0 || (outData && !outData->empty()))) {
     if (!outData) {
       outData = std::make_unique<IOBuf>();
     }
     deliverCallbackIfAllowed(&HTTPCodec::Callback::onBody, "onBody",
                              curHeader_.stream, std::move(outData), padding);
   }
   return (pendingDataFrameBytes_ > 0) ? ErrorCode::NO_ERROR : handleEndStream();
 }

ErrorCode proxygen::HTTP2Codec::parseExHeaders ( folly::io::Cursor & cursor )

private

Definition at line 395 of file HTTP2Codec.cpp.

References checkNewStream(), curHeader_, FOLLY_SCOPED_TRACE_SECTION, isRequest(), proxygen::http2::FrameHeader::length, folly::gen::move, folly::none, proxygen::http2::parseExHeaders(), parseHeadersImpl(), RETURN_IF_ERROR, and proxygen::http2::FrameHeader::stream.

Referenced by getHeaderIndexingStrategy(), and parseFrame().

                                                    {
   FOLLY_SCOPED_TRACE_SECTION("HTTP2Codec - parseExHeaders");
   HTTPCodec::ExAttributes exAttributes;
   folly::Optional<http2::PriorityUpdate> priority;
   std::unique_ptr<IOBuf> headerBuf;
   VLOG(4) << "parsing ExHEADERS frame for stream=" << curHeader_.stream
           << " length=" << curHeader_.length;
   auto err = http2::parseExHeaders(
       cursor, curHeader_, exAttributes, priority, headerBuf);
   RETURN_IF_ERROR(err);
   if (isRequest(curHeader_.stream)) {
     RETURN_IF_ERROR(
         checkNewStream(curHeader_.stream, false /* trailersAllowed */));
   }
   return parseHeadersImpl(cursor, std::move(headerBuf), priority, folly::none,
                           exAttributes);
 }

ErrorCode proxygen::HTTP2Codec::parseFrame ( folly::io::Cursor & cursor )

private

Definition at line 163 of file HTTP2Codec.cpp.

References proxygen::http2::ALTSVC, proxygen::http2::CERTIFICATE, proxygen::http2::CERTIFICATE_REQUEST, folly::IOBufQueue::chainLength(), proxygen::http2::CONTINUATION, curHeader_, curHeaderBlock_, proxygen::http2::DATA, egressSettings_, proxygen::ENABLE_EX_HEADERS, proxygen::http2::END_HEADERS, proxygen::ERROR, proxygen::http2::EX_HEADERS, expectedContinuationStream_, proxygen::http2::FrameHeader::flags, FOLLY_SCOPED_TRACE_SECTION, proxygen::http2::frameAffectsCompression(), proxygen::http2::getFrameTypeString(), proxygen::HTTPSettings::getSetting(), proxygen::http2::GOAWAY, proxygen::HTTPParallelCodec::goawayErrorMessage_, proxygen::http2::HEADERS, ingressSettings_, proxygen::http2::FrameHeader::length, proxygen::MAX_HEADER_LIST_SIZE, proxygen::NO_ERROR, parseAllData(), parseCertificate(), parseCertificateRequest(), parseContinuation(), parseExHeaders(), parseGoaway(), parseHeaders(), parsePing(), parsePriority(), parsePushPromise(), parseRstStream(), parseSettings(), parseWindowUpdate(), proxygen::http2::PING, proxygen::http2::PRIORITY, proxygen::PROTOCOL_ERROR, proxygen::http2::PUSH_PROMISE, proxygen::http2::RST_STREAM, proxygen::http2::SETTINGS, folly::io::detail::CursorBase< Derived, BufType >::skip(), proxygen::http2::FrameHeader::stream, proxygen::http2::FrameHeader::type, uint8_t, and proxygen::http2::WINDOW_UPDATE.

Referenced by getHeaderIndexingStrategy(), and onIngress().

                                                       {
   FOLLY_SCOPED_TRACE_SECTION("HTTP2Codec - parseFrame");
   if (expectedContinuationStream_ != 0 &&
        (curHeader_.type != http2::FrameType::CONTINUATION ||
         expectedContinuationStream_ != curHeader_.stream)) {
     goawayErrorMessage_ = folly::to<string>(
         "GOAWAY error: while expected CONTINUATION with stream=",
         expectedContinuationStream_, ", received streamID=", curHeader_.stream,
         " of type=", getFrameTypeString(curHeader_.type));
     VLOG(4) << goawayErrorMessage_;
     return ErrorCode::PROTOCOL_ERROR;
   }
   if (expectedContinuationStream_ == 0 &&
       curHeader_.type == http2::FrameType::CONTINUATION) {
     goawayErrorMessage_ = folly::to<string>(
         "GOAWAY error: unexpected CONTINUATION received with streamID=",
         curHeader_.stream);
     VLOG(4) << goawayErrorMessage_;
     return ErrorCode::PROTOCOL_ERROR;
   }
   if (frameAffectsCompression(curHeader_.type) &&
       curHeaderBlock_.chainLength() + curHeader_.length >
       egressSettings_.getSetting(SettingsId::MAX_HEADER_LIST_SIZE, 0)) {
     // this may be off by up to the padding length (max 255), but
     // these numbers are already so generous, and we're comparing the
     // max-uncompressed to the actual compressed size.  Let's fail
     // before buffering.
 
     // TODO(t6513634): it would be nicer to stream-process this header
     // block to keep the connection state consistent without consuming
     // memory, and fail just the request per the HTTP/2 spec (section
     // 10.3)
     goawayErrorMessage_ = folly::to<string>(
       "Failing connection due to excessively large headers");
     LOG(ERROR) << goawayErrorMessage_;
     return ErrorCode::PROTOCOL_ERROR;
   }
 
   expectedContinuationStream_ =
     (frameAffectsCompression(curHeader_.type) &&
      !(curHeader_.flags & http2::END_HEADERS)) ? curHeader_.stream : 0;
 
   switch (curHeader_.type) {
     case http2::FrameType::DATA:
       return parseAllData(cursor);
     case http2::FrameType::HEADERS:
       return parseHeaders(cursor);
     case http2::FrameType::PRIORITY:
       return parsePriority(cursor);
     case http2::FrameType::RST_STREAM:
       return parseRstStream(cursor);
     case http2::FrameType::SETTINGS:
       return parseSettings(cursor);
     case http2::FrameType::PUSH_PROMISE:
       return parsePushPromise(cursor);
     case http2::FrameType::EX_HEADERS:
       if (ingressSettings_.getSetting(SettingsId::ENABLE_EX_HEADERS, 0)) {
         return parseExHeaders(cursor);
       } else {
         VLOG(2) << "EX_HEADERS not enabled, ignoring the frame";
         break;
       }
     case http2::FrameType::PING:
       return parsePing(cursor);
     case http2::FrameType::GOAWAY:
       return parseGoaway(cursor);
     case http2::FrameType::WINDOW_UPDATE:
       return parseWindowUpdate(cursor);
     case http2::FrameType::CONTINUATION:
       return parseContinuation(cursor);
     case http2::FrameType::ALTSVC:
       // fall through, unimplemented
       break;
     case http2::FrameType::CERTIFICATE_REQUEST:
       return parseCertificateRequest(cursor);
     case http2::FrameType::CERTIFICATE:
       return parseCertificate(cursor);
     default:
       // Implementations MUST ignore and discard any frame that has a
       // type that is unknown
       break;
   }
 
   // Landing here means unknown, unimplemented or ignored frame.
   VLOG(2) << "Skipping frame (type=" << (uint8_t)curHeader_.type << ")";
   cursor.skip(curHeader_.length);
   return ErrorCode::NO_ERROR;
 }

ErrorCode proxygen::HTTP2Codec::parseGoaway ( folly::io::Cursor & cursor )

private

Definition at line 869 of file HTTP2Codec.cpp.

References proxygen::HTTPParallelCodec::callback_, curHeader_, folly::IOBuf::data(), proxygen::empty_string, proxygen::getErrorCodeString(), proxygen::HTTPParallelCodec::ingressGoawayAck_, proxygen::http2::FrameHeader::length, folly::IOBuf::length(), folly::gen::move, proxygen::NO_ERROR, proxygen::HTTPCodec::Callback::onGoaway(), proxygen::http2::parseGoaway(), RETURN_IF_ERROR, statusCode, uint32_t, userAgent_, and folly::WARNING.

Referenced by getHeaderIndexingStrategy(), and parseFrame().

                                                 {
   VLOG(4) << "parsing GOAWAY frame length=" << curHeader_.length;
   uint32_t lastGoodStream = 0;
   ErrorCode statusCode = ErrorCode::NO_ERROR;
   std::unique_ptr<IOBuf> debugData;
 
   auto err = http2::parseGoaway(cursor, curHeader_, lastGoodStream, statusCode,
                                 debugData);
   if (statusCode != ErrorCode::NO_ERROR) {
     VLOG(2) << "Goaway error statusCode=" << getErrorCodeString(statusCode)
             << " lastStream=" << lastGoodStream
             << " user-agent=" << userAgent_ <<  " debugData=" <<
       ((debugData) ? string((char*)debugData->data(), debugData->length()):
        empty_string);
   }
   RETURN_IF_ERROR(err);
   if (lastGoodStream < ingressGoawayAck_) {
     ingressGoawayAck_ = lastGoodStream;
     // Drain all streams <= lastGoodStream
     // and abort streams > lastGoodStream
     if (callback_) {
       callback_->onGoaway(lastGoodStream, statusCode, std::move(debugData));
     }
   } else {
     LOG(WARNING) << "Received multiple GOAWAY with increasing ack";
   }
   return ErrorCode::NO_ERROR;
 }

ErrorCode proxygen::HTTP2Codec::parseHeaders ( folly::io::Cursor & cursor )

private

Definition at line 378 of file HTTP2Codec.cpp.

References checkNewStream(), curHeader_, proxygen::DOWNSTREAM, FOLLY_SCOPED_TRACE_SECTION, proxygen::http2::FrameHeader::length, folly::gen::move, folly::none, proxygen::http2::parseHeaders(), parseHeadersImpl(), RETURN_IF_ERROR, proxygen::http2::FrameHeader::stream, and proxygen::HTTPParallelCodec::transportDirection_.

Referenced by getHeaderIndexingStrategy(), and parseFrame().

                                                  {
   FOLLY_SCOPED_TRACE_SECTION("HTTP2Codec - parseHeaders");
   folly::Optional<http2::PriorityUpdate> priority;
   std::unique_ptr<IOBuf> headerBuf;
   VLOG(4) << "parsing HEADERS frame for stream=" << curHeader_.stream <<
     " length=" << curHeader_.length;
   auto err = http2::parseHeaders(cursor, curHeader_, priority, headerBuf);
   RETURN_IF_ERROR(err);
   if (transportDirection_ == TransportDirection::DOWNSTREAM) {
     RETURN_IF_ERROR(
         checkNewStream(curHeader_.stream, true /* trailersAllowed */));
   }
   err = parseHeadersImpl(cursor, std::move(headerBuf), priority, folly::none,
                          folly::none);
   return err;
 }

folly::Optional< ErrorCode > proxygen::HTTP2Codec::parseHeadersCheckConcurrentStreams ( const folly::Optional< http2::PriorityUpdate > & priority )

private

Definition at line 585 of file HTTP2Codec.cpp.

References proxygen::HTTPParallelCodec::callback_, curHeader_, egressSettings_, proxygen::http2::EX_HEADERS, proxygen::http2::FrameHeader::flags, proxygen::HTTPSettings::getSetting(), proxygen::http2::HEADERS, max, proxygen::MAX_CONCURRENT_STREAMS, proxygen::NO_ERROR, proxygen::HTTPCodec::Callback::numIncomingStreams(), proxygen::http2::PRIORITY, proxygen::REFUSED_STREAM, streamError(), and proxygen::http2::FrameHeader::type.

Referenced by getHeaderIndexingStrategy(), and parseHeadersImpl().

                                                         {
   if (curHeader_.type == http2::FrameType::HEADERS ||
       curHeader_.type == http2::FrameType::EX_HEADERS) {
     if (curHeader_.flags & http2::PRIORITY) {
       DCHECK(priority);
       // callback_->onPriority(priority.get());
     }
 
     // callback checks total number of streams is smaller than settings max
     if (callback_->numIncomingStreams() >=
         egressSettings_.getSetting(SettingsId::MAX_CONCURRENT_STREAMS,
                                    std::numeric_limits<int32_t>::max())) {
       streamError(folly::to<string>("Exceeded max_concurrent_streams"),
                   ErrorCode::REFUSED_STREAM, true);
       return ErrorCode::NO_ERROR;
     }
   }
   return folly::Optional<ErrorCode>();
 }

folly::Optional< ErrorCode > proxygen::HTTP2Codec::parseHeadersDecodeFrames	(	const folly::Optional< http2::PriorityUpdate > &	priority,
		const folly::Optional< uint32_t > &	promisedStream,
		const folly::Optional< ExAttributes > &	exAttributes,
		std::unique_ptr< HTTPMessage > &	msg
	)

private

Definition at line 507 of file HTTP2Codec.cpp.

References proxygen::HTTPParallelCodec::callback_, folly::IOBufQueue::chainLength(), proxygen::COMPRESSION_ERROR, curHeader_, curHeaderBlock_, proxygen::HeaderDecodeInfo::decodeError, decodeInfo_, proxygen::HPACKCodec::decodeStreaming(), proxygen::DOWNSTREAM, proxygen::ERROR, folly::IOBufQueue::front(), g(), headerCodec_, proxygen::http2::HEADERS, proxygen::HPACK::HEADERS_TOO_LARGE, proxygen::HTTPException::INGRESS, proxygen::HeaderDecodeInfo::init(), isRequest(), std::tr1::make_tuple(), folly::makeGuard(), folly::IOBufQueue::move(), folly::gen::move, proxygen::HeaderDecodeInfo::msg, proxygen::NO_ERROR, proxygen::HPACK::NONE, proxygen::HTTPCodec::Callback::onError(), parsingDownstreamTrailers_, proxygen::HeaderDecodeInfo::parsingError, proxygen::IOBufPrinter::printHexFolly(), proxygen::PROTOCOL_ERROR, proxygen::http2::FrameHeader::stream, streamError(), string, proxygen::HTTPParallelCodec::transportDirection_, and proxygen::http2::FrameHeader::type.

Referenced by getHeaderIndexingStrategy(), and parseHeadersImpl().

                                      {
   // decompress headers
   Cursor headerCursor(curHeaderBlock_.front());
   bool isReq = false;
   if (promisedStream) {
     isReq = true;
   } else if (exAttributes) {
     isReq = isRequest(curHeader_.stream);
   } else {
     isReq = transportDirection_ == TransportDirection::DOWNSTREAM;
   }
 
   decodeInfo_.init(isReq, parsingDownstreamTrailers_);
   if (priority) {
     if (curHeader_.stream == priority->streamDependency) {
       streamError(folly::to<string>("Circular dependency for txn=",
                                     curHeader_.stream),
                   ErrorCode::PROTOCOL_ERROR,
                   curHeader_.type == http2::FrameType::HEADERS);
       return ErrorCode::NO_ERROR;
     }
 
     decodeInfo_.msg->setHTTP2Priority(
         std::make_tuple(priority->streamDependency,
                         priority->exclusive,
                         priority->weight));
   }
   headerCodec_.decodeStreaming(
       headerCursor, curHeaderBlock_.chainLength(), this);
   msg = std::move(decodeInfo_.msg);
   // Saving this in case we need to log it on error
   auto g = folly::makeGuard([this] { curHeaderBlock_.move(); });
   // Check decoding error
   if (decodeInfo_.decodeError != HPACK::DecodeError::NONE) {
     static const std::string decodeErrorMessage =
         "Failed decoding header block for stream=";
     // Avoid logging header blocks that have failed decoding due to being
     // excessively large.
     if (decodeInfo_.decodeError != HPACK::DecodeError::HEADERS_TOO_LARGE) {
       LOG(ERROR) << decodeErrorMessage << curHeader_.stream
                  << " header block=";
       VLOG(3) << IOBufPrinter::printHexFolly(curHeaderBlock_.front(), true);
     } else {
       LOG(ERROR) << decodeErrorMessage << curHeader_.stream;
     }
 
     if (msg) {
       // print the partial message
       msg->dumpMessage(3);
     }
     return ErrorCode::COMPRESSION_ERROR;
   }
 
   // Check parsing error
   if (decodeInfo_.parsingError != "") {
     LOG(ERROR) << "Failed parsing header list for stream=" << curHeader_.stream
                << ", error=" << decodeInfo_.parsingError << ", header block=";
     VLOG(3) << IOBufPrinter::printHexFolly(curHeaderBlock_.front(), true);
     HTTPException err(HTTPException::Direction::INGRESS,
                       folly::to<std::string>("HTTP2Codec stream error: ",
                                              "stream=",
                                              curHeader_.stream,
                                              " status=",
                                              400,
                                              " error: ",
                                              decodeInfo_.parsingError));
     err.setHttpStatusCode(400);
     callback_->onError(curHeader_.stream, err, true);
     return ErrorCode::NO_ERROR;
   }
 
   return folly::Optional<ErrorCode>();
 }

ErrorCode proxygen::HTTP2Codec::parseHeadersImpl	(	folly::io::Cursor &	cursor,
		std::unique_ptr< folly::IOBuf >	headerBuf,
		const folly::Optional< http2::PriorityUpdate > &	priority,
		const folly::Optional< uint32_t > &	promisedStream,
		const folly::Optional< ExAttributes > &	exAttributes
	)

private

Definition at line 424 of file HTTP2Codec.cpp.

References folly::IOBufQueue::append(), proxygen::HTTPParallelCodec::callback_, proxygen::http2::CONTINUATION, proxygen::HTTPCodec::ExAttributes::controlStream, curHeader_, curHeaderBlock_, proxygen::HTTPParallelCodec::deliverCallbackIfAllowed(), proxygen::http2::END_HEADERS, proxygen::http2::END_STREAM, proxygen::http2::EX_HEADERS, proxygen::http2::FrameHeader::flags, handleEndStream(), headerBlockFrameType_, proxygen::http2::HEADERS, folly::gen::move, proxygen::NO_ERROR, proxygen::HTTPCodec::Callback::onExMessageBegin(), proxygen::HTTPCodec::Callback::onHeadersComplete(), proxygen::HTTPCodec::Callback::onMessageBegin(), proxygen::HTTPCodec::Callback::onPushMessageBegin(), proxygen::HTTPCodec::Callback::onTrailersComplete(), parseHeadersCheckConcurrentStreams(), parseHeadersDecodeFrames(), parsingTrailers(), proxygen::http2::PUSH_PROMISE, proxygen::http2::FrameHeader::stream, proxygen::HTTPParallelCodec::transportDirection_, proxygen::http2::FrameHeader::type, uint32_t, and proxygen::HTTPCodec::ExAttributes::unidirectional.

Referenced by getHeaderIndexingStrategy(), parseContinuation(), parseExHeaders(), parseHeaders(), and parsePushPromise().

                                                      {
   curHeaderBlock_.append(std::move(headerBuf));
   std::unique_ptr<HTTPMessage> msg;
   if (curHeader_.flags & http2::END_HEADERS) {
     auto errorCode =
         parseHeadersDecodeFrames(priority, promisedStream, exAttributes, msg);
     if (errorCode.hasValue()) {
       return errorCode.value();
     }
   }
 
   // if we're not parsing CONTINUATION, then it's start of new header block
   if (curHeader_.type != http2::FrameType::CONTINUATION) {
     headerBlockFrameType_ = curHeader_.type;
   }
 
   // Report back what we've parsed
   if (callback_) {
     auto concurError = parseHeadersCheckConcurrentStreams(priority);
     if (concurError.hasValue()) {
       return concurError.value();
     }
     uint32_t headersCompleteStream = curHeader_.stream;
     bool trailers = parsingTrailers();
     bool allHeaderFramesReceived =
         (curHeader_.flags & http2::END_HEADERS) &&
         (headerBlockFrameType_ == http2::FrameType::HEADERS);
     if (allHeaderFramesReceived && !trailers) {
       // Only deliver onMessageBegin once per stream.
       // For responses with CONTINUATION, this will be delayed until
       // the frame with the END_HEADERS flag set.
       if (!deliverCallbackIfAllowed(&HTTPCodec::Callback::onMessageBegin,
                                     "onMessageBegin",
                                     curHeader_.stream,
                                     msg.get())) {
         return handleEndStream();
       }
    } else if (curHeader_.type == http2::FrameType::EX_HEADERS) {
       if (!deliverCallbackIfAllowed(&HTTPCodec::Callback::onExMessageBegin,
                                     "onExMessageBegin",
                                     curHeader_.stream,
                                     exAttributes->controlStream,
                                     exAttributes->unidirectional,
                                     msg.get())) {
         return handleEndStream();
       }
     } else if (curHeader_.type == http2::FrameType::PUSH_PROMISE) {
       DCHECK(promisedStream);
       if (!deliverCallbackIfAllowed(&HTTPCodec::Callback::onPushMessageBegin,
                                     "onPushMessageBegin", *promisedStream,
                                     curHeader_.stream, msg.get())) {
         return handleEndStream();
       }
       headersCompleteStream = *promisedStream;
     }
 
     if (curHeader_.flags & http2::END_HEADERS && msg) {
       if (!(curHeader_.flags & http2::END_STREAM)) {
         // If it there are DATA frames coming, consider it chunked
         msg->setIsChunked(true);
       }
       if (trailers) {
         VLOG(4) << "Trailers complete for streamId=" << headersCompleteStream
                 << " direction=" << transportDirection_;
         auto trailerHeaders =
             std::make_unique<HTTPHeaders>(msg->extractHeaders());
         msg.reset();
         callback_->onTrailersComplete(headersCompleteStream,
                                       std::move(trailerHeaders));
       } else {
         callback_->onHeadersComplete(headersCompleteStream, std::move(msg));
       }
     }
     return handleEndStream();
   }
   return ErrorCode::NO_ERROR;
 }

ErrorCode proxygen::HTTP2Codec::parsePing ( folly::io::Cursor & cursor )

private

Definition at line 854 of file HTTP2Codec.cpp.

References proxygen::http2::ACK, proxygen::HTTPParallelCodec::callback_, curHeader_, proxygen::http2::FrameHeader::flags, proxygen::http2::FrameHeader::length, proxygen::NO_ERROR, proxygen::HTTPCodec::Callback::onPingReply(), proxygen::HTTPCodec::Callback::onPingRequest(), proxygen::http2::parsePing(), RETURN_IF_ERROR, and uint64_t.

Referenced by getHeaderIndexingStrategy(), and parseFrame().

                                               {
   VLOG(4) << "parsing PING frame length=" << curHeader_.length;
   uint64_t opaqueData = 0;
   auto err = http2::parsePing(cursor, curHeader_, opaqueData);
   RETURN_IF_ERROR(err);
   if (callback_) {
     if (curHeader_.flags & http2::ACK) {
       callback_->onPingReply(opaqueData);
     } else {
       callback_->onPingRequest(opaqueData);
     }
   }
   return ErrorCode::NO_ERROR;
 }

ErrorCode proxygen::HTTP2Codec::parsePriority ( folly::io::Cursor & cursor )

private

Definition at line 650 of file HTTP2Codec.cpp.

References curHeader_, proxygen::HTTPParallelCodec::deliverCallbackIfAllowed(), proxygen::http2::PriorityUpdate::exclusive, proxygen::http2::FrameHeader::length, std::tr1::make_tuple(), proxygen::NO_ERROR, proxygen::HTTPCodec::Callback::onPriority(), proxygen::http2::parsePriority(), proxygen::PROTOCOL_ERROR, RETURN_IF_ERROR, proxygen::http2::FrameHeader::stream, proxygen::http2::PriorityUpdate::streamDependency, streamError(), and proxygen::http2::PriorityUpdate::weight.

Referenced by getHeaderIndexingStrategy(), and parseFrame().

                                                   {
   VLOG(4) << "parsing PRIORITY frame for stream=" << curHeader_.stream <<
     " length=" << curHeader_.length;
   http2::PriorityUpdate pri;
   auto err = http2::parsePriority(cursor, curHeader_, pri);
   RETURN_IF_ERROR(err);
   if (curHeader_.stream == pri.streamDependency) {
     streamError(folly::to<string>("Circular dependency for txn=",
                                   curHeader_.stream),
                 ErrorCode::PROTOCOL_ERROR, false);
     return ErrorCode::NO_ERROR;
   }
   deliverCallbackIfAllowed(&HTTPCodec::Callback::onPriority, "onPriority",
                            curHeader_.stream,
                            std::make_tuple(pri.streamDependency,
                                            pri.exclusive,
                                            pri.weight));
   return ErrorCode::NO_ERROR;
 }

ErrorCode proxygen::HTTP2Codec::parsePushPromise ( folly::io::Cursor & cursor )

private

Definition at line 817 of file HTTP2Codec.cpp.

References checkNewStream(), curHeader_, egressSettings_, proxygen::ENABLE_PUSH, proxygen::HTTPSettings::getSetting(), proxygen::HTTPParallelCodec::goawayErrorMessage_, proxygen::http2::FrameHeader::length, folly::gen::move, folly::none, parseHeadersImpl(), proxygen::http2::parsePushPromise(), proxygen::PROTOCOL_ERROR, RETURN_IF_ERROR, proxygen::http2::FrameHeader::stream, proxygen::HTTPParallelCodec::transportDirection_, uint32_t, and proxygen::UPSTREAM.

Referenced by getHeaderIndexingStrategy(), and parseFrame().

                                                      {
   // stream id must be idle - protocol error
   // assoc-stream-id=closed/unknown - protocol error, unless rst_stream sent
 
   /*
    * What does "must handle" mean in the following context?  I have to
    * accept this as a valid pushed resource?
 
     However, an endpoint that has sent RST_STREAM on the associated
     stream MUST handle PUSH_PROMISE frames that might have been
     created before the RST_STREAM frame is received and processed.
   */
   if (transportDirection_ != TransportDirection::UPSTREAM) {
     goawayErrorMessage_ = folly::to<string>(
       "Received PUSH_PROMISE on DOWNSTREAM codec");
     VLOG(2) << goawayErrorMessage_;
     return ErrorCode::PROTOCOL_ERROR;
   }
   if (egressSettings_.getSetting(SettingsId::ENABLE_PUSH, -1) != 1) {
     goawayErrorMessage_ = folly::to<string>(
       "Received PUSH_PROMISE on codec with push disabled");
     VLOG(2) << goawayErrorMessage_;
     return ErrorCode::PROTOCOL_ERROR;
   }
   VLOG(4) << "parsing PUSH_PROMISE frame for stream=" << curHeader_.stream <<
     " length=" << curHeader_.length;
   uint32_t promisedStream;
   std::unique_ptr<IOBuf> headerBlockFragment;
   auto err = http2::parsePushPromise(cursor, curHeader_, promisedStream,
                                      headerBlockFragment);
   RETURN_IF_ERROR(err);
   RETURN_IF_ERROR(checkNewStream(promisedStream, false /* trailersAllowed */));
   err = parseHeadersImpl(cursor, std::move(headerBlockFragment), folly::none,
                          promisedStream, folly::none);
   return err;
 }

ErrorCode proxygen::HTTP2Codec::parseRstStream ( folly::io::Cursor & cursor )

private

Definition at line 686 of file HTTP2Codec.cpp.

References curHeader_, proxygen::HTTPParallelCodec::deliverCallbackIfAllowed(), proxygen::getErrorCodeString(), proxygen::HTTPParallelCodec::goawayErrorMessage_, proxygen::http2::FrameHeader::length, proxygen::NO_ERROR, proxygen::HTTPCodec::Callback::onAbort(), proxygen::http2::parseRstStream(), proxygen::PROTOCOL_ERROR, RETURN_IF_ERROR, statusCode, proxygen::http2::FrameHeader::stream, upgradedStreams_, and userAgent_.

Referenced by getHeaderIndexingStrategy(), and parseFrame().

                                                    {
   // rst for stream in idle state - protocol error
   VLOG(4) << "parsing RST_STREAM frame for stream=" << curHeader_.stream <<
     " length=" << curHeader_.length;
   upgradedStreams_.erase(curHeader_.stream);
   ErrorCode statusCode = ErrorCode::NO_ERROR;
   auto err = http2::parseRstStream(cursor, curHeader_, statusCode);
   RETURN_IF_ERROR(err);
   if (statusCode == ErrorCode::PROTOCOL_ERROR) {
     goawayErrorMessage_ = folly::to<string>(
         "GOAWAY error: RST_STREAM with code=", getErrorCodeString(statusCode),
         " for streamID=", curHeader_.stream, " user-agent=", userAgent_);
     VLOG(2) << goawayErrorMessage_;
   }
   deliverCallbackIfAllowed(&HTTPCodec::Callback::onAbort, "onAbort",
                            curHeader_.stream, statusCode);
   return ErrorCode::NO_ERROR;
 }

ErrorCode proxygen::HTTP2Codec::parseSettings ( folly::io::Cursor & cursor )

private

Definition at line 705 of file HTTP2Codec.cpp.

References proxygen::http2::ACK, proxygen::HTTPParallelCodec::callback_, curHeader_, proxygen::http2::FrameHeader::flags, handleSettings(), proxygen::http2::FrameHeader::length, proxygen::NO_ERROR, proxygen::HTTPCodec::Callback::onSettingsAck(), proxygen::http2::parseSettings(), RETURN_IF_ERROR, settings, and proxygen::http2::FrameHeader::stream.

Referenced by getHeaderIndexingStrategy(), and parseFrame().

                                                   {
   VLOG(4) << "parsing SETTINGS frame for stream=" << curHeader_.stream <<
     " length=" << curHeader_.length;
   std::deque<SettingPair> settings;
   auto err = http2::parseSettings(cursor, curHeader_, settings);
   RETURN_IF_ERROR(err);
   if (curHeader_.flags & http2::ACK) {
     // for stats
     if (callback_) {
       callback_->onSettingsAck();
     }
     return ErrorCode::NO_ERROR;
   }
   return handleSettings(settings);
 }

ErrorCode proxygen::HTTP2Codec::parseWindowUpdate ( folly::io::Cursor & cursor )

private

Definition at line 898 of file HTTP2Codec.cpp.

References curHeader_, proxygen::HTTPParallelCodec::deliverCallbackIfAllowed(), proxygen::HTTPParallelCodec::goawayErrorMessage_, proxygen::http2::FrameHeader::length, proxygen::NO_ERROR, proxygen::HTTPCodec::Callback::onWindowUpdate(), proxygen::http2::parseWindowUpdate(), proxygen::PROTOCOL_ERROR, RETURN_IF_ERROR, proxygen::http2::FrameHeader::stream, streamError(), and uint32_t.

Referenced by getHeaderIndexingStrategy(), and parseFrame().

                                                       {
   VLOG(4) << "parsing WINDOW_UPDATE frame for stream=" << curHeader_.stream <<
     " length=" << curHeader_.length;
   uint32_t delta = 0;
   auto err = http2::parseWindowUpdate(cursor, curHeader_, delta);
   RETURN_IF_ERROR(err);
   if (delta == 0) {
     VLOG(4) << "Invalid 0 length delta for stream=" << curHeader_.stream;
     if (curHeader_.stream == 0) {
       goawayErrorMessage_ = folly::to<string>(
         "GOAWAY error: invalid/0 length delta for streamID=",
         curHeader_.stream);
       return ErrorCode::PROTOCOL_ERROR;
     } else {
       // Parsing a zero delta window update should cause a protocol error
       // and send a rst stream
       goawayErrorMessage_ = folly::to<string>(
         "parseWindowUpdate Invalid 0 length");
       VLOG(4) << goawayErrorMessage_;
       streamError(folly::to<std::string>("streamID=", curHeader_.stream,
                                          " with HTTP2Codec stream error: ",
                                          "window update delta=", delta),
                   ErrorCode::PROTOCOL_ERROR);
       return ErrorCode::PROTOCOL_ERROR;
     }
   }
   // if window exceeds 2^31-1, connection/stream error flow control error
   // must be checked in session/txn
   deliverCallbackIfAllowed(&HTTPCodec::Callback::onWindowUpdate,
                            "onWindowUpdate", curHeader_.stream, delta);
   return ErrorCode::NO_ERROR;
 }

bool proxygen::HTTP2Codec::parsingTrailers ( ) const

private

Definition at line 1637 of file HTTP2Codec.cpp.

References proxygen::http2::CONTINUATION, curHeader_, decodeInfo_, proxygen::DOWNSTREAM, proxygen::HeaderDecodeInfo::hasStatus(), proxygen::http2::HEADERS, parsingDownstreamTrailers_, proxygen::HTTPParallelCodec::transportDirection_, and proxygen::http2::FrameHeader::type.

Referenced by maxRecvFrameSize(), and parseHeadersImpl().

                                        {
   // HEADERS frame is used for request/response headers and trailers.
   // Per spec, specific role of HEADERS frame is determined by it's postion
   // within the stream. We don't keep full stream state in this codec,
   // thus using heuristics to distinguish between headers/trailers.
   // For DOWNSTREAM case, request headers HEADERS frame would be creating
   // new stream, thus HEADERS on existing stream ID are considered trailers
   // (see checkNewStream).
   // For UPSTREAM case, response headers are required to have status code,
   // thus if no status code we consider that trailers.
   if (curHeader_.type == http2::FrameType::HEADERS ||
       curHeader_.type == http2::FrameType::CONTINUATION) {
     if (transportDirection_ == TransportDirection::DOWNSTREAM) {
       return parsingDownstreamTrailers_;
     } else {
       return !decodeInfo_.hasStatus();
     }
   }
   return false;
 }

bool proxygen::HTTP2Codec::peerHasWebsockets ( ) const

inline

Definition at line 127 of file HTTP2Codec.h.

References proxygen::ENABLE_CONNECT_PROTOCOL, proxygen::HTTPSettings::getSetting(), and ingressSettings_.

                                  {
     return ingressSettings_.getSetting(SettingsId::ENABLE_CONNECT_PROTOCOL);
   }

void proxygen::HTTP2Codec::requestUpgrade ( HTTPMessage & request )

static

Definition at line 1509 of file HTTP2Codec.cpp.

References proxygen::HTTPMessage::checkForHeaderToken(), generateSettings(), proxygen::HTTPMessage::getHeaders(), proxygen::HTTP_HEADER_CONNECTION, proxygen::HTTP_HEADER_UPGRADE, proxygen::http2::kFrameHeaderSize, proxygen::http2::kProtocolCleartextString, proxygen::http2::kProtocolSettingsHeader, proxygen::HTTPHeaders::set(), proxygen::UPSTREAM, and fizz::detail::writeBuf().

Referenced by getHPACKTableInfo(), and TEST_F().

                                                     {
   static HTTP2Codec defaultCodec(TransportDirection::UPSTREAM);
 
   auto& headers = request.getHeaders();
   headers.set(HTTP_HEADER_UPGRADE, http2::kProtocolCleartextString);
   if (!request.checkForHeaderToken(HTTP_HEADER_CONNECTION, "Upgrade", false)) {
     headers.add(HTTP_HEADER_CONNECTION, "Upgrade");
   }
   IOBufQueue writeBuf{IOBufQueue::cacheChainLength()};
   defaultCodec.generateSettings(writeBuf);
   writeBuf.trimStart(http2::kFrameHeaderSize);
   auto buf = writeBuf.move();
   buf->coalesce();
   headers.set(http2::kProtocolSettingsHeader,
               base64url_encode(folly::ByteRange(buf->data(), buf->length())));
   if (!request.checkForHeaderToken(HTTP_HEADER_CONNECTION,
                                    http2::kProtocolSettingsHeader.c_str(),
                                    false)) {
     headers.add(HTTP_HEADER_CONNECTION, http2::kProtocolSettingsHeader);
   }
 }

void proxygen::HTTP2Codec::setHeaderCodecStats ( HeaderCodec::Stats * )

inlineoverridevirtual

set stats for the header codec, if the protocol supports header compression

Reimplemented from proxygen::HTTPCodec.

Definition at line 134 of file HTTP2Codec.h.

References headerCodec_, and proxygen::HeaderCodec::setStats().

                                                                {
     headerCodec_.setStats(hcStats);
   }

void proxygen::HTTP2Codec::setHeaderIndexingStrategy ( const HeaderIndexingStrategy * indexingStrat )

inline

Definition at line 171 of file HTTP2Codec.h.

References headerCodec_, and proxygen::HPACKCodec::setHeaderIndexingStrategy().

Referenced by proxygen::HTTPSessionBase::initCodecHeaderIndexingStrategy().

                                                                               {
     headerCodec_.setHeaderIndexingStrategy(indexingStrat);
   }

void proxygen::HTTP2Codec::setReuseIOBufHeadroomForData ( bool enabled )

inline

Definition at line 167 of file HTTP2Codec.h.

References reuseIOBufHeadroomForData_.

                                                   {
     reuseIOBufHeadroomForData_ = enabled;
   }

void proxygen::HTTP2Codec::streamError	(	const std::string &	msg,
		ErrorCode	error,
		bool	newTxn = `false`
	)

private

Definition at line 1616 of file HTTP2Codec.cpp.

References proxygen::HTTPParallelCodec::callback_, curHeader_, folly::pushmi::operators::error(), proxygen::HTTPException::INGRESS_AND_EGRESS, proxygen::HTTPCodec::Callback::onError(), proxygen::HTTPException::setCodecStatusCode(), and proxygen::http2::FrameHeader::stream.

Referenced by maxRecvFrameSize(), parseHeadersCheckConcurrentStreams(), parseHeadersDecodeFrames(), parsePriority(), and parseWindowUpdate().

                                           {
   HTTPException error(HTTPException::Direction::INGRESS_AND_EGRESS,
                       msg);
   error.setCodecStatusCode(code);
   if (callback_) {
     callback_->onError(curHeader_.stream, error, newTxn);
   }
 }

bool proxygen::HTTP2Codec::supportsExTransactions ( ) const

inlineoverridevirtual

Check whether the codec supports bidirectional communications between server and client.

Reimplemented from proxygen::HTTPCodec.

Definition at line 130 of file HTTP2Codec.h.

References egressSettings_, proxygen::ENABLE_EX_HEADERS, proxygen::HTTPSettings::getSetting(), and ingressSettings_.

                                                {
     return ingressSettings_.getSetting(SettingsId::ENABLE_EX_HEADERS, 0) &&
       egressSettings_.getSetting(SettingsId::ENABLE_EX_HEADERS, 0);
   }

bool proxygen::HTTP2Codec::supportsPushTransactions ( ) const

inlineoverridevirtual

Check whether the codec supports pushing resources from server to client.

Implements proxygen::HTTPCodec.

Definition at line 120 of file HTTP2Codec.h.

References proxygen::DOWNSTREAM, egressSettings_, proxygen::ENABLE_PUSH, proxygen::HTTPSettings::getSetting(), ingressSettings_, proxygen::HTTPParallelCodec::transportDirection_, and proxygen::UPSTREAM.

                                                  {
     return
       (transportDirection_ == TransportDirection::DOWNSTREAM &&
        ingressSettings_.getSetting(SettingsId::ENABLE_PUSH, 1)) ||
       (transportDirection_ == TransportDirection::UPSTREAM &&
        egressSettings_.getSetting(SettingsId::ENABLE_PUSH, 1));
   }

Member Data Documentation

folly::IOBufQueue proxygen::HTTP2Codec::curAuthenticatorBlock_

private

Initial value:

{

folly::IOBufQueue::cacheChainLength()}

Definition at line 251 of file HTTP2Codec.h.

Referenced by parseCertificate().

uint16_t proxygen::HTTP2Codec::curCertId_ {0}

private

Definition at line 250 of file HTTP2Codec.h.

Referenced by parseCertificate().

http2::FrameHeader proxygen::HTTP2Codec::curHeader_

private

folly::IOBufQueue proxygen::HTTP2Codec::curHeaderBlock_ {folly::IOBufQueue::cacheChainLength()}

private

Definition at line 254 of file HTTP2Codec.h.

Referenced by parseFrame(), parseHeadersDecodeFrames(), and parseHeadersImpl().

HeaderDecodeInfo proxygen::HTTP2Codec::decodeInfo_

private

Definition at line 282 of file HTTP2Codec.h.

Referenced by onDecodeError(), onHeader(), onHeadersComplete(), parseHeadersDecodeFrames(), and parsingTrailers().

HTTPSettings proxygen::HTTP2Codec::egressSettings_

private

Initial value:

{
    { SettingsId::HEADER_TABLE_SIZE, 4096 },
    { SettingsId::ENABLE_PUSH, 0 },
    { SettingsId::MAX_FRAME_SIZE, 16384 },
    { SettingsId::MAX_HEADER_LIST_SIZE, 1 << 17 }, 
  }

Definition at line 260 of file HTTP2Codec.h.

Referenced by generateSettings(), getEgressSettings(), handleSettings(), HTTP2Codec(), maxRecvFrameSize(), parseFrame(), parseHeadersCheckConcurrentStreams(), parsePushPromise(), supportsExTransactions(), and supportsPushTransactions().

StreamID proxygen::HTTP2Codec::expectedContinuationStream_ {0}

private

Definition at line 244 of file HTTP2Codec.h.

Referenced by handleEndStream(), and parseFrame().

FrameState proxygen::HTTP2Codec::frameState_

private

Definition at line 276 of file HTTP2Codec.h.

Referenced by onIngress().

http2::FrameType proxygen::HTTP2Codec::headerBlockFrameType_ {http2::FrameType::DATA}

private

Definition at line 296 of file HTTP2Codec.h.

Referenced by parseHeadersImpl().

HPACKCodec proxygen::HTTP2Codec::headerCodec_

private

Definition at line 240 of file HTTP2Codec.h.

Referenced by encodeHeaders(), generateSettings(), getHeaderIndexingStrategy(), getHPACKTableInfo(), handleSettings(), HTTP2Codec(), onHeader(), parseHeadersDecodeFrames(), setHeaderCodecStats(), and setHeaderIndexingStrategy().

HTTPSettings proxygen::HTTP2Codec::ingressSettings_

private

Initial value:

{
    { SettingsId::HEADER_TABLE_SIZE, 4096 },
    { SettingsId::ENABLE_PUSH, 1 },
    { SettingsId::MAX_FRAME_SIZE, 16384 },
  }

Definition at line 255 of file HTTP2Codec.h.

Referenced by encodeHeaders(), getIngressSettings(), handleSettings(), maxSendFrameSize(), parseFrame(), peerHasWebsockets(), supportsExTransactions(), and supportsPushTransactions().

bool proxygen::HTTP2Codec::ingressWebsocketUpgrade_ {false}

private

Definition at line 246 of file HTTP2Codec.h.

Referenced by generateRstStream(), handleEndStream(), and onHeadersComplete().

bool proxygen::HTTP2Codec::parsingDownstreamTrailers_ {false}

private

Definition at line 292 of file HTTP2Codec.h.

Referenced by checkNewStream(), parseHeadersDecodeFrames(), and parsingTrailers().

size_t proxygen::HTTP2Codec::pendingDataFrameBytes_ {0}

private

Definition at line 279 of file HTTP2Codec.h.

Referenced by onIngress(), and parseDataFrameData().

size_t proxygen::HTTP2Codec::pendingDataFramePaddingBytes_ {0}

private

Definition at line 280 of file HTTP2Codec.h.

Referenced by onIngress(), and parseDataFrameData().

bool proxygen::HTTP2Codec::pendingEndStreamHandling_ {false}

private

Definition at line 245 of file HTTP2Codec.h.

Referenced by generateRstStream(), and handleEndStream().

uint64_t proxygen::HTTP2Codec::receivedFrameCount_ {0}

private

Definition at line 267 of file HTTP2Codec.h.

Referenced by getReceivedFrameCount(), and onIngress().

bool proxygen::HTTP2Codec::reuseIOBufHeadroomForData_ {true}

private

Definition at line 284 of file HTTP2Codec.h.

Referenced by generateBody(), generateEOM(), and setReuseIOBufHeadroomForData().

std::unordered_set<StreamID> proxygen::HTTP2Codec::upgradedStreams_

private

Definition at line 248 of file HTTP2Codec.h.

Referenced by generateEOM(), generateHeaderImpl(), generateRstStream(), onHeadersComplete(), and parseRstStream().

std::string proxygen::HTTP2Codec::userAgent_

private

Definition at line 277 of file HTTP2Codec.h.

Referenced by generateGoaway(), generateRstStream(), getUserAgent(), onHeader(), parseGoaway(), and parseRstStream().

std::vector<StreamID> proxygen::HTTP2Codec::virtualPriorityNodes_

private

Definition at line 283 of file HTTP2Codec.h.

Referenced by addPriorityNodes(), and mapPriorityToDependency().

The documentation for this class was generated from the following files:

proxygen/lib/http/codec/HTTP2Codec.h
proxygen/lib/http/codec/HTTP2Codec.cpp

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation