proxygen: proxygen::HTTP1xCodec Class Reference

#include <HTTP1xCodec.h>

Inheritance diagram for proxygen::HTTP1xCodec:

Public Member Functions
	HTTP1xCodec (TransportDirection direction, bool forceUpstream1_1=false)

	~HTTP1xCodec () override

CodecProtocol	getProtocol () const override

const std::string &	getUserAgent () const override

TransportDirection	getTransportDirection () const override

StreamID	createStream () override

void	setCallback (Callback *callback) override

bool	isBusy () const override

void	setParserPaused (bool paused) override

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

void	onIngressEOF () override

bool	isReusable () const override

bool	isWaitingToDrain () const override

bool	closeOnEgressComplete () const override

bool	supportsParallelRequests () const override

bool	supportsPushTransactions () const override

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

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

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

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

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

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

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

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

void	setAllowedUpgradeProtocols (std::list< std::string > protocols)

const std::string &	getAllowedUpgradeProtocols ()

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

virtual HPACKTableInfo	getHPACKTableInfo () const

virtual bool	supportsStreamFlowControl () const

virtual bool	supportsSessionFlowControl () const

virtual bool	onIngressUpgradeMessage (const HTTPMessage &)

virtual bool	supportsExTransactions () const

virtual size_t	generateConnectionPreface (folly::IOBufQueue &)

virtual void	generatePushPromise (folly::IOBufQueue &, StreamID, const HTTPMessage &, StreamID, bool, HTTPHeaderSize *)

virtual void	generateExHeader (folly::IOBufQueue &, StreamID, const HTTPMessage &, const HTTPCodec::ExAttributes &, bool, HTTPHeaderSize *)

virtual size_t	generatePingRequest (folly::IOBufQueue &)

virtual size_t	generatePingReply (folly::IOBufQueue &, uint64_t)

virtual size_t	generateSettings (folly::IOBufQueue &)

virtual size_t	generateSettingsAck (folly::IOBufQueue &)

virtual size_t	generateWindowUpdate (folly::IOBufQueue &, StreamID, uint32_t)

virtual size_t	generatePriority (folly::IOBufQueue &, StreamID, const HTTPMessage::HTTPPriority &)

virtual size_t	generateCertificateRequest (folly::IOBufQueue &, uint16_t, std::unique_ptr< folly::IOBuf >)

virtual size_t	generateCertificate (folly::IOBufQueue &, uint16_t, std::unique_ptr< folly::IOBuf >)

virtual HTTPSettings *	getEgressSettings ()

virtual const HTTPSettings *	getIngressSettings () const

virtual void	enableDoubleGoawayDrain ()

virtual void	setHeaderCodecStats (HeaderCodec::Stats *)

virtual StreamID	getLastIncomingStreamID () const

virtual uint32_t	getDefaultWindowSize () const

virtual size_t	addPriorityNodes (PriorityQueue &, folly::IOBufQueue &, uint8_t)

virtual StreamID	mapPriorityToDependency (uint8_t) const

virtual int8_t	mapDependencyToPriority (StreamID) const

Static Public Member Functions
static bool	supportsNextProtocol (const std::string &npn)

Private Types
enum	HeaderParseState : uint8_t { HeaderParseState::kParsingHeaderIdle, HeaderParseState::kParsingHeaderStart, HeaderParseState::kParsingHeaderName, HeaderParseState::kParsingHeaderValue, HeaderParseState::kParsingHeadersComplete, HeaderParseState::kParsingTrailerName, HeaderParseState::kParsingTrailerValue }

enum	KeepaliveRequested : uint8_t { KeepaliveRequested::UNSET, KeepaliveRequested::ENABLED, KeepaliveRequested::DISABLED }

Private Member Functions
std::string	generateWebsocketKey () const

std::string	generateWebsocketAccept (const std::string &acceptKey) const

void	addDateHeader (folly::IOBufQueue &writeBuf, size_t &len)

bool	isParsingHeaders () const

bool	isParsingHeaderOrTrailerName () const

void	onParserError (const char *what=nullptr)

void	pushHeaderNameAndValue (HTTPHeaders &hdrs)

void	serializeWebsocketHeader (folly::IOBufQueue &writeBuf, size_t &len, bool upstream)

int	onMessageBegin ()

int	onURL (const char *buf, size_t len)

int	onReason (const char *buf, size_t len)

int	onHeaderField (const char *buf, size_t len)

int	onHeaderValue (const char *buf, size_t len)

int	onHeadersComplete (size_t len)

int	onBody (const char *buf, size_t len)

int	onChunkHeader (size_t len)

int	onChunkComplete ()

int	onMessageComplete ()

Static Private Member Functions
static int	onMessageBeginCB (http_parser *parser)

static int	onPathCB (http_parser parser, const char buf, size_t len)

static int	onQueryStringCB (http_parser parser, const char buf, size_t len)

static int	onUrlCB (http_parser parser, const char buf, size_t len)

static int	onReasonCB (http_parser parser, const char buf, size_t len)

static int	onHeaderFieldCB (http_parser parser, const char buf, size_t len)

static int	onHeaderValueCB (http_parser parser, const char buf, size_t len)

static int	onHeadersCompleteCB (http_parser parser, const char buf, size_t len)

static int	onBodyCB (http_parser parser, const char buf, size_t len)

static int	onChunkHeaderCB (http_parser *parser)

static int	onChunkCompleteCB (http_parser *parser)

static int	onMessageCompleteCB (http_parser *parser)

static const http_parser_settings *	getParserSettings ()

Private Attributes
std::string	websockAcceptKey_

HTTPCodec::Callback *	callback_

StreamID	ingressTxnID_

StreamID	egressTxnID_

http_parser	parser_

const folly::IOBuf *	currentIngressBuf_

std::unique_ptr< HTTPMessage >	msg_

std::unique_ptr< HTTPMessage >	upgradeRequest_

std::unique_ptr< HTTPHeaders >	trailers_

std::string	currentHeaderName_

folly::StringPiece	currentHeaderNameStringPiece_

std::string	currentHeaderValue_

std::string	url_

std::string	userAgent_

std::string	reason_

std::string	upgradeHeader_

std::string	allowedNativeUpgrades_

HTTPHeaderSize	headerSize_

HeaderParseState	headerParseState_

TransportDirection	transportDirection_

KeepaliveRequested	keepaliveRequested_

std::pair< CodecProtocol, std::string >	upgradeResult_

bool	forceUpstream1_1_:1

bool	parserActive_:1

bool	pendingEOF_:1

bool	parserPaused_:1

bool	parserError_:1

bool	requestPending_:1

bool	responsePending_:1

bool	egressChunked_:1

bool	inChunk_:1

bool	lastChunkWritten_:1

bool	keepalive_:1

bool	disableKeepalivePending_:1

bool	connectRequest_:1

bool	headRequest_:1

bool	expectNoResponseBody_:1

bool	mayChunkEgress_:1

bool	is1xxResponse_:1

bool	inRecvLastChunk_:1

bool	ingressUpgrade_:1

bool	ingressUpgradeComplete_:1

bool	egressUpgrade_:1

bool	nativeUpgrade_:1

bool	headersComplete_:1

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

Detailed Description

Definition at line 21 of file HTTP1xCodec.h.

Member Enumeration Documentation

enum proxygen::HTTP1xCodec::HeaderParseState : uint8_t

strongprivate

Simple state model used to track the parsing of HTTP headers

Enumerator
kParsingHeaderIdle
kParsingHeaderStart
kParsingHeaderName
kParsingHeaderValue
kParsingHeadersComplete
kParsingTrailerName
kParsingTrailerValue

Definition at line 91 of file HTTP1xCodec.h.

                               : uint8_t {
     kParsingHeaderIdle,
     kParsingHeaderStart,
     kParsingHeaderName,
     kParsingHeaderValue,
     kParsingHeadersComplete,
     kParsingTrailerName,
     kParsingTrailerValue
   };

enum proxygen::HTTP1xCodec::KeepaliveRequested : uint8_t

strongprivate

Used to keep track of whether a client requested keep-alive. This is only useful to support HTTP 1.0 keep-alive for a downstream connection where keep-alive is disabled unless the client requested it.

Enumerator
UNSET
ENABLED
DISABLED

Definition at line 108 of file HTTP1xCodec.h.

                                 : uint8_t {
     UNSET,
     ENABLED,  // incoming message requested keepalive
     DISABLED,   // incoming message disabled keepalive
   };

Constructor & Destructor Documentation

proxygen::HTTP1xCodec::HTTP1xCodec	(	TransportDirection	direction,
		bool	forceUpstream1_1 = `false`
	)

explicit

Definition at line 81 of file HTTP1xCodec.cpp.

References http_parser::data, proxygen::DOWNSTREAM, http_parser_init(), HTTP_REQUEST, HTTP_RESPONSE, parser_, and proxygen::UPSTREAM.

   : callback_(nullptr),
     ingressTxnID_(0),
     egressTxnID_(0),
     currentIngressBuf_(nullptr),
     headerParseState_(HeaderParseState::kParsingHeaderIdle),
     transportDirection_(direction),
     keepaliveRequested_(KeepaliveRequested::UNSET),
     forceUpstream1_1_(forceUpstream1_1),
     parserActive_(false),
     pendingEOF_(false),
     parserPaused_(false),
     parserError_(false),
     requestPending_(false),
     responsePending_(false),
     egressChunked_(false),
     inChunk_(false),
     lastChunkWritten_(false),
     keepalive_(true),
     disableKeepalivePending_(false),
     connectRequest_(false),
     headRequest_(false),
     expectNoResponseBody_(false),
     mayChunkEgress_(false),
     is1xxResponse_(false),
     inRecvLastChunk_(false),
     ingressUpgrade_(false),
     ingressUpgradeComplete_(false),
     egressUpgrade_(false),
     nativeUpgrade_(false),
     headersComplete_(false) {
   switch (direction) {
   case TransportDirection::DOWNSTREAM:
     http_parser_init(&parser_, HTTP_REQUEST);
     break;
   case TransportDirection::UPSTREAM:
     http_parser_init(&parser_, HTTP_RESPONSE);
     break;
   default:
     LOG(FATAL) << "Unknown transport direction.";
   }
   parser_.data = this;
 }

proxygen::HTTP1xCodec::~HTTP1xCodec ( )

override

Definition at line 125 of file HTTP1xCodec.cpp.

                           {
   // This code used to throw a parse error there were unterminated headers
   // being parsed.  None of the cases where this can happen relied on the parse
   // error.
 }

Member Function Documentation

void proxygen::HTTP1xCodec::addDateHeader	(	folly::IOBufQueue &	writeBuf,
		size_t &	len
	)

private

Definition at line 306 of file HTTP1xCodec.cpp.

References appendLiteral, and proxygen::HTTPMessage::formatDateHeader().

Referenced by generateHeader().

                                                             {
   appendLiteral(writeBuf, len, "Date: ");
   appendString(writeBuf, len, HTTPMessage::formatDateHeader());
   appendLiteral(writeBuf, len, CRLF);
 }

bool proxygen::HTTP1xCodec::closeOnEgressComplete ( ) const

inlineoverridevirtual

Checks whether the socket needs to be closed when EOM is sent. This is used during CONNECT when EOF needs to be sent after upgrade to notify the server

Implements proxygen::HTTPCodec.

Definition at line 49 of file HTTP1xCodec.h.

References egressUpgrade_.

49 { return egressUpgrade_; }

proxygen::HTTP1xCodec::egressUpgrade_

bool egressUpgrade_

Definition: HTTP1xCodec.h:195

HTTPCodec::StreamID proxygen::HTTP1xCodec::createStream ( )

overridevirtual

Reserve a stream ID.

Returns: A stream ID on success, or zero on error.

Implements proxygen::HTTPCodec.

Definition at line 132 of file HTTP1xCodec.cpp.

References proxygen::DOWNSTREAM, egressTxnID_, ingressTxnID_, and transportDirection_.

Referenced by getTransportDirection(), TEST(), and TEST_P().

                           {
   if (transportDirection_ == TransportDirection::DOWNSTREAM) {
     return ++ingressTxnID_;
   } else {
     return ++egressTxnID_;
   }
 }

size_t proxygen::HTTP1xCodec::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 657 of file HTTP1xCodec.cpp.

References folly::IOBufQueue::append(), folly::IOBuf::computeChainDataLength(), egressChunked_, egressTxnID_, generateEOM(), inChunk_, and folly::gen::move.

Referenced by supportsPushTransactions(), and TEST().

                                            {
   DCHECK_EQ(txn, egressTxnID_);
   if (!chain) {
     return 0;
   }
   size_t buflen = chain->computeChainDataLength();
   size_t totLen = buflen;
   if (totLen == 0) {
     if (eom) {
       totLen += generateEOM(writeBuf, txn);
     }
     return totLen;
   }
 
   if (egressChunked_ && !inChunk_) {
     char chunkLenBuf[32];
     int rc = snprintf(chunkLenBuf, sizeof(chunkLenBuf), "%zx\r\n", buflen);
     CHECK_GT(rc, 0);
     CHECK_LT(size_t(rc), sizeof(chunkLenBuf));
 
     writeBuf.append(chunkLenBuf, rc);
     totLen += rc;
 
     writeBuf.append(std::move(chain));
     writeBuf.append("\r\n", 2);
     totLen += 2;
   } else {
     writeBuf.append(std::move(chain));
   }
   if (eom) {
     totLen += generateEOM(writeBuf, txn);
   }
 
   return totLen;
 }

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

overridevirtual

Write a body chunk header, if relevant.

Implements proxygen::HTTPCodec.

Definition at line 697 of file HTTP1xCodec.cpp.

References folly::IOBufQueue::append(), egressChunked_, and inChunk_.

Referenced by supportsPushTransactions().

                                                        {
   // TODO: Format directly into the IOBuf, rather than copying after the fact.
   // IOBufQueue::append() currently forces us to copy.
 
   CHECK(length) << "use sendEOM to terminate the message using the "
                 << "standard zero-length chunk. Don't "
                 << "send zero-length chunks using this API.";
   if (egressChunked_) {
     CHECK(!inChunk_);
     inChunk_ = true;
     char chunkLenBuf[32];
     int rc = snprintf(chunkLenBuf, sizeof(chunkLenBuf), "%zx\r\n", length);
     CHECK_GT(rc, 0);
     CHECK_LT(size_t(rc), sizeof(chunkLenBuf));
 
     writeBuf.append(chunkLenBuf, rc);
     return rc;
   }
 
   return 0;
 }

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

overridevirtual

Write a body chunk terminator, if relevant.

Implements proxygen::HTTPCodec.

Definition at line 721 of file HTTP1xCodec.cpp.

References folly::IOBufQueue::append(), egressChunked_, and inChunk_.

Referenced by supportsPushTransactions().

                                                         {
   if (egressChunked_ && inChunk_) {
     inChunk_ = false;
     writeBuf.append("\r\n", 2);
     return 2;
   }
 
   return 0;
 }

size_t proxygen::HTTP1xCodec::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 752 of file HTTP1xCodec.cpp.

References appendLiteral, proxygen::DOWNSTREAM, egressChunked_, egressTxnID_, headRequest_, inChunk_, lastChunkWritten_, requestPending_, responsePending_, transportDirection_, and proxygen::UPSTREAM.

Referenced by generateBody(), generateHeader(), supportsPushTransactions(), and TEST().

                                                                   {
   DCHECK_EQ(txn, egressTxnID_);
   size_t len = 0;
   if (egressChunked_) {
     CHECK(!inChunk_);
     if (headRequest_ && transportDirection_ == TransportDirection::DOWNSTREAM) {
       lastChunkWritten_ = true;
     } else {
       // appending a 0\r\n only if it's not a HEAD and downstream request
       if (!lastChunkWritten_) {
         lastChunkWritten_ = true;
         if (!(headRequest_ &&
               transportDirection_ == TransportDirection::DOWNSTREAM)) {
           appendLiteral(writeBuf, len, "0\r\n");
         }
       }
       appendLiteral(writeBuf, len, CRLF);
     }
   }
   switch (transportDirection_) {
   case TransportDirection::DOWNSTREAM:
     responsePending_ = false;
     break;
   case TransportDirection::UPSTREAM:
     requestPending_ = false;
     break;
   }
   return len;
 }

size_t proxygen::HTTP1xCodec::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 791 of file HTTP1xCodec.cpp.

References disableKeepalivePending_.

Referenced by supportsPushTransactions().

                              {
   // statusCode ignored for HTTP/1.1
   // We won't be able to send anything else on the transport after this.
   disableKeepalivePending_ = true;
   return 0;
 }

void proxygen::HTTP1xCodec::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 364 of file HTTP1xCodec.cpp.

Referenced by supportsPushTransactions(), TEST(), and TEST_P().

                                                   {
   if (keepalive_ && disableKeepalivePending_) {
     keepalive_ = false;
   }
   const bool upstream = (transportDirection_ == TransportDirection::UPSTREAM);
   const bool downstream = !upstream;
   if (upstream) {
     DCHECK_EQ(txn, egressTxnID_);
     requestPending_ = true;
     responsePending_ = true;
     connectRequest_ = (msg.getMethod() == HTTPMethod::CONNECT);
     headRequest_ = (msg.getMethod() == HTTPMethod::HEAD);
     expectNoResponseBody_ = connectRequest_ || headRequest_;
   } else {
     // In HTTP, transactions must be egressed sequentially -- no out of order
     // responses.  So txn must be egressTxnID_ + 1.  Furthermore, we shouldn't
     // ever egress a response before we see a request, so txn can't
     // be > ingressTxnID_
     if ((txn != egressTxnID_ + 1 &&
          !(txn == egressTxnID_ && is1xxResponse_)) ||
         (txn > ingressTxnID_)) {
       LOG(DFATAL) << "Out of order, duplicate or premature HTTP response";
     }
     if (!is1xxResponse_) {
       ++egressTxnID_;
     }
     is1xxResponse_ = msg.is1xxResponse() || msg.isEgressWebsocketUpgrade();
 
     expectNoResponseBody_ =
       connectRequest_ || headRequest_ ||
       RFC2616::responseBodyMustBeEmpty(msg.getStatusCode());
   }
 
   int statusCode = 0;
   StringPiece statusMessage;
   if (downstream) {
     statusCode = msg.getStatusCode();
     statusMessage = msg.getStatusMessage();
     // If a response to a websocket upgrade is being sent out, it must be 101.
     // This is required since the application may not have changed the status,
     // particularly when proxying between a H2 hop and a H1 hop.
     if (msg.isEgressWebsocketUpgrade()) {
       statusCode = 101;
       statusMessage = HTTPMessage::getDefaultReason(101);
     }
     if (connectRequest_ && (statusCode >= 200 && statusCode < 300)) {
       // Set egress upgrade flag if we are sending a 200 response
       // to a CONNECT request we received earlier.
       egressUpgrade_ = true;
     } else if (statusCode == 101) {
       // Set the upgrade flags if we upgraded after the request from client.
       ingressUpgrade_ = true;
       egressUpgrade_ = true;
     }
     else if (connectRequest_ && ingressUpgrade_) {
       // Disable upgrade when rejecting CONNECT request
       ingressUpgrade_ = false;
 
       // This codec/session is no longer useful as we might have
       // forwarded some data before receiving the 200.
       keepalive_ = false;
     }
   } else {
     if (connectRequest_ || msg.isEgressWebsocketUpgrade()) {
       // Sending a CONNECT request or a websocket upgrade request to an upstream
       // server. This is used to determine the chunked setting below.
       egressUpgrade_ = true;
     }
   }
 
   egressChunked_ = msg.getIsChunked() && !egressUpgrade_;
   lastChunkWritten_ = false;
   std::pair<uint8_t, uint8_t> version = msg.getHTTPVersion();
   if (version > HTTPMessage::kHTTPVersion11) {
     version = HTTPMessage::kHTTPVersion11;
   }
 
   size_t len = 0;
   switch (transportDirection_) {
   case TransportDirection::DOWNSTREAM:
     DCHECK_NE(statusCode, 0);
     if (version.first == 0 && version.second == 9) {
       return;
     }
     appendLiteral(writeBuf, len, "HTTP/");
     appendUint(writeBuf, len, version.first);
     appendLiteral(writeBuf, len, ".");
     appendUint(writeBuf, len, version.second);
     appendLiteral(writeBuf, len, " ");
     appendUint(writeBuf, len, statusCode);
     appendLiteral(writeBuf, len, " ");
     appendString(writeBuf, len, statusMessage);
     break;
   case TransportDirection::UPSTREAM:
     if (forceUpstream1_1_ && version < HTTPMessage::kHTTPVersion11) {
       version = HTTPMessage::kHTTPVersion11;
     }
     if (msg.isEgressWebsocketUpgrade()) {
       appendString(writeBuf, len, methodToString(HTTPMethod::GET));
     } else {
       appendString(writeBuf, len, msg.getMethodString());
     }
     appendLiteral(writeBuf, len, " ");
     appendString(writeBuf, len, msg.getURL());
     appendLiteral(writeBuf, len, " HTTP/");
     appendUint(writeBuf, len, version.first);
     appendLiteral(writeBuf, len, ".");
     appendUint(writeBuf, len, version.second);
     mayChunkEgress_ = (version.first == 1) && (version.second >= 1);
     if (!upgradeHeader_.empty()) {
       LOG(DFATAL) << "Attempted to pipeline HTTP request with pending upgrade";
       upgradeHeader_.clear();
     }
     break;
   }
 
   if (keepalive_ &&
       (!msg.wantsKeepalive() ||
        version.first < 1 ||
        (downstream && version == HTTPMessage::kHTTPVersion10 &&
         keepaliveRequested_ != KeepaliveRequested::ENABLED))) {
     // Disable keepalive if
     //  - the message asked to turn it off
     //  - it's HTTP/0.9
     //  - this is a response to a 1.0 request that didn't say keep-alive
     keepalive_ = false;
   }
   egressChunked_ &= mayChunkEgress_;
   appendLiteral(writeBuf, len, CRLF);
   if (version.first == 0 && version.second == 9) {
     parser_.http_major = 0;
     parser_.http_minor = 9;
     return;
   }
   const string* deferredContentLength = nullptr;
   bool hasTransferEncodingChunked = false;
   bool hasDateHeader = false;
   bool hasUpgradeHeader = false;
   std::vector<StringPiece> connectionTokens;
   size_t lastConnectionToken = 0;
   bool egressWebsocketUpgrade = msg.isEgressWebsocketUpgrade();
   bool hasUpgradeTokeninConnection = false;
   msg.getHeaders().forEachWithCode([&] (HTTPHeaderCode code,
                                         const string& header,
                                         const string& value) {
     if (code == HTTP_HEADER_CONTENT_LENGTH) {
       // Write the Content-Length last (t1071703)
       deferredContentLength = &value;
       return; // continue
     } else if (code == HTTP_HEADER_CONNECTION && (!is1xxResponse_ ||
         egressWebsocketUpgrade)) {
       static const string kClose = "close";
       static const string kKeepAlive = "keep-alive";
       folly::split(',', value, connectionTokens);
       for (auto curConnectionToken = lastConnectionToken;
            curConnectionToken < connectionTokens.size();
            curConnectionToken++) {
         auto token = trimWhitespace(connectionTokens[curConnectionToken]);
         if (caseInsensitiveEqual(token, "upgrade")) {
           hasUpgradeTokeninConnection = true;
         }
         if (caseInsensitiveEqual(token, kClose)) {
           keepalive_ = false;
         } else if (!caseInsensitiveEqual(token, kKeepAlive)) {
           connectionTokens[lastConnectionToken++] = token;
         } // else eat the keep-alive token
       }
       connectionTokens.resize(lastConnectionToken);
       // We'll generate a new Connection header based on the keepalive_ state
       return;
     } else if (code == HTTP_HEADER_UPGRADE && txn == 1) {
       hasUpgradeHeader = true;
       if (upstream) {
         // save in case we get a 101 Switching Protocols
         upgradeHeader_ = value;
       }
     } else if (!hasTransferEncodingChunked &&
                code == HTTP_HEADER_TRANSFER_ENCODING) {
       if (!caseInsensitiveEqual(value, kChunked)) {
         return;
       }
       hasTransferEncodingChunked = true;
       if (!mayChunkEgress_) {
         return;
       }
     } else if (!hasDateHeader && code == HTTP_HEADER_DATE) {
       hasDateHeader = true;
     } else if (egressWebsocketUpgrade &&
         code == HTTP_HEADER_SEC_WEBSOCKET_KEY) {
       // will generate our own key per hop, not client's.
       return;
     } else if (egressWebsocketUpgrade &&
         code == HTTP_HEADER_SEC_WEBSOCKET_ACCEPT) {
       // will generate our own accept per hop, not client's.
       return;
     }
     size_t lineLen = header.length() + value.length() + 4; // 4 for ": " + CRLF
     auto writable = writeBuf.preallocate(lineLen,
         std::max(lineLen, size_t(2000)));
     char* dst = (char*)writable.first;
     memcpy(dst, header.data(), header.length());
     dst += header.length();
     *dst++ = ':';
     *dst++ = ' ';
     memcpy(dst, value.data(), value.length());
     dst += value.length();
     *dst++ = '\r';
     *dst = '\n';
     DCHECK_EQ(size_t(++dst - (char*)writable.first), lineLen);
     writeBuf.postallocate(lineLen);
     len += lineLen;
   });
   bool bodyCheck =
     (downstream && keepalive_ && !expectNoResponseBody_ && !egressUpgrade_) ||
     // auto chunk POSTs and any request that came to us chunked
     (upstream && ((msg.getMethod() == HTTPMethod::POST) || egressChunked_));
   // TODO: 400 a 1.0 POST with no content-length
   // clear egressChunked_ if the header wasn't actually set
   egressChunked_ &= hasTransferEncodingChunked;
   if (bodyCheck && !egressChunked_ && !deferredContentLength) {
     // On a connection that would otherwise be eligible for keep-alive,
     // we're being asked to send a response message with no Content-Length,
     // no chunked encoding, and no special circumstances that would eliminate
     // the need for a response body. If the client supports chunking, turn
     // on chunked encoding now.  Otherwise, turn off keepalives on this
     // connection.
     if (!hasTransferEncodingChunked && mayChunkEgress_) {
       appendLiteral(writeBuf, len, "Transfer-Encoding: chunked\r\n");
       egressChunked_ = true;
     } else {
       keepalive_ = false;
     }
   }
   if (downstream && !hasDateHeader) {
     addDateHeader(writeBuf, len);
   }
 
   // websocket headers
   if (msg.isEgressWebsocketUpgrade()) {
     if (!hasUpgradeHeader && txn == 1) {
       // upgradeHeader_ is set in serializeWwebsocketHeader for requests.
       serializeWebsocketHeader(writeBuf, len, upstream);
       if (!hasUpgradeTokeninConnection) {
         connectionTokens.push_back(kUpgradeConnectionToken);
         lastConnectionToken++;
       }
     } else {
       LOG(ERROR) << folly::to<string>("Not serializing headers. "
           "Upgrade headers present/txn: ",
           hasUpgradeHeader, txn);
     }
   }
 
   if (!is1xxResponse_ || upstream || !connectionTokens.empty()) {
     // We don't seem to add keep-alive/close and let the application add any
     // for 1xx responses.
     appendLiteral(writeBuf, len, "Connection: ");
     if (connectionTokens.size() > 0) {
       appendString(writeBuf, len, folly::join(", ", connectionTokens));
     }
     if (!is1xxResponse_) {
       if (connectionTokens.size() > 0) {
         appendString(writeBuf, len, ", ");
       }
       if (keepalive_) {
         appendLiteral(writeBuf, len, "keep-alive");
       } else {
         appendLiteral(writeBuf, len, "close");
       }
     }
     appendLiteral(writeBuf, len, "\r\n");
   }
 
   if (deferredContentLength) {
     appendLiteral(writeBuf, len, "Content-Length: ");
     appendString(writeBuf, len, *deferredContentLength);
     appendLiteral(writeBuf, len, CRLF);
   }
   appendLiteral(writeBuf, len, CRLF);
   if (eom) {
     len += generateEOM(writeBuf, txn);
   }
 
   if (size) {
     size->compressed = 0;
     size->uncompressed = len;
   }
 }

size_t proxygen::HTTP1xCodec::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 782 of file HTTP1xCodec.cpp.

References disableKeepalivePending_.

Referenced by supportsPushTransactions().

                                                    {
   // statusCode ignored for HTTP/1.1
   // We won't be able to send anything else on the transport after this.
   disableKeepalivePending_ = true;
   return 0;
 }

size_t proxygen::HTTP1xCodec::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 733 of file HTTP1xCodec.cpp.

References appendLiteral, egressChunked_, egressTxnID_, proxygen::HTTPHeaders::forEach(), inChunk_, and lastChunkWritten_.

Referenced by supportsPushTransactions(), and TEST().

                                                            {
   DCHECK_EQ(txn, egressTxnID_);
   size_t len = 0;
   if (egressChunked_) {
     CHECK(!inChunk_);
     appendLiteral(writeBuf, len, "0\r\n");
     lastChunkWritten_ = true;
     trailers.forEach([&] (const string& trailer, const string& value) {
       appendString(writeBuf, len, trailer);
       appendLiteral(writeBuf, len, ": ");
       appendString(writeBuf, len, value);
       appendLiteral(writeBuf, len, CRLF);
     });
   }
   return len;
 }

std::string proxygen::HTTP1xCodec::generateWebsocketAccept ( const std::string & acceptKey ) const

private

Definition at line 326 of file HTTP1xCodec.cpp.

References folly::netops::accept(), proxygen::Base64::encode(), folly::ssl::OpenSSLHash::Digest::hash_final(), folly::ssl::OpenSSLHash::Digest::hash_init(), folly::ssl::OpenSSLHash::Digest::hash_update(), and proxygen::kWSMagicString.

Referenced by onHeadersComplete(), and serializeWebsocketHeader().

                                                                {
   folly::ssl::OpenSSLHash::Digest digest;
   digest.hash_init(EVP_sha1());
   digest.hash_update(folly::StringPiece(key));
   digest.hash_update(kWSMagicString);
   std::array<unsigned char, 20> arr;
   folly::MutableByteRange accept(arr.data(), arr.size());
   digest.hash_final(accept);
   return Base64::encode(accept);
 }

std::string proxygen::HTTP1xCodec::generateWebsocketKey ( ) const

private

Definition at line 319 of file HTTP1xCodec.cpp.

References proxygen::Base64::encode(), folly::Random::secureRandom(), and string.

Referenced by serializeWebsocketHeader().

                                         {
   std::array<unsigned char, 16> arr;
   folly::Random::secureRandom(arr.data(), arr.size());
   return Base64::encode(folly::ByteRange(arr.data(), arr.size()));
 }

const std::string & proxygen::HTTP1xCodec::getAllowedUpgradeProtocols ( )

Definition at line 812 of file HTTP1xCodec.cpp.

References allowedNativeUpgrades_.

Referenced by supportsPushTransactions(), and TEST().

                                                          {
   return allowedNativeUpgrades_;
 }

const http_parser_settings * proxygen::HTTP1xCodec::getParserSettings ( )

staticprivate

Definition at line 158 of file HTTP1xCodec.cpp.

Referenced by onIngress(), and onIngressEOF().

                                                            {
   static http_parser_settings parserSettings = [] {
     http_parser_settings st;
     st.on_message_begin = HTTP1xCodec::onMessageBeginCB;
     st.on_url = HTTP1xCodec::onUrlCB;
     st.on_header_field = HTTP1xCodec::onHeaderFieldCB;
     st.on_header_value = HTTP1xCodec::onHeaderValueCB;
     st.on_headers_complete = HTTP1xCodec::onHeadersCompleteCB;
     st.on_body = HTTP1xCodec::onBodyCB;
     st.on_message_complete = HTTP1xCodec::onMessageCompleteCB;
     st.on_reason = HTTP1xCodec::onReasonCB;
     st.on_chunk_header = HTTP1xCodec::onChunkHeaderCB;
     st.on_chunk_complete = HTTP1xCodec::onChunkCompleteCB;
     return st;
   }();
   return &parserSettings;
 }

CodecProtocol proxygen::HTTP1xCodec::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 28 of file HTTP1xCodec.h.

References proxygen::HTTP_1_1.

Referenced by TEST().

                                              {
     return CodecProtocol::HTTP_1_1;
   }

TransportDirection proxygen::HTTP1xCodec::getTransportDirection ( ) const

inlineoverridevirtual

Get the transport direction of this codec: DOWNSTREAM if the codec receives requests from clients or UPSTREAM if the codec sends requests to servers.

Implements proxygen::HTTPCodec.

Definition at line 36 of file HTTP1xCodec.h.

References createStream(), and transportDirection_.

                                                             {
     return transportDirection_;
   }

const std::string& proxygen::HTTP1xCodec::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 32 of file HTTP1xCodec.h.

References userAgent_.

                                                  {
     return userAgent_;
   }

bool proxygen::HTTP1xCodec::isBusy ( ) const

overridevirtual

Check whether the codec still has at least one HTTP stream to parse.

Implements proxygen::HTTPCodec.

Definition at line 301 of file HTTP1xCodec.cpp.

References requestPending_, and responsePending_.

Referenced by setCallback().

                           {
   return requestPending_ || responsePending_;
 }

bool proxygen::HTTP1xCodec::isParsingHeaderOrTrailerName ( ) const

inlineprivate

Check whether we're currently parsing ingress header-or-trailer name

Definition at line 123 of file HTTP1xCodec.h.

References headerParseState_, kParsingHeaderName, kParsingTrailerName, onBody(), onChunkComplete(), onChunkHeader(), onHeaderField(), onHeadersComplete(), onHeaderValue(), onMessageBegin(), onMessageComplete(), onParserError(), onReason(), onURL(), pushHeaderNameAndValue(), and serializeWebsocketHeader().

Referenced by onHeaderField().

                                             {
     return (headerParseState_ == HeaderParseState::kParsingHeaderName) ||
         (headerParseState_ == HeaderParseState::kParsingTrailerName);
   }

bool proxygen::HTTP1xCodec::isParsingHeaders ( ) const

inlineprivate

Check whether we're currently parsing ingress message headers

Definition at line 117 of file HTTP1xCodec.h.

References headerParseState_, kParsingHeaderIdle, and kParsingHeadersComplete.

Referenced by onBody(), onHeaderValue(), and onMessageComplete().

                                 {
     return (headerParseState_ > HeaderParseState::kParsingHeaderIdle) &&
        (headerParseState_ < HeaderParseState::kParsingHeadersComplete);
   }

bool proxygen::HTTP1xCodec::isReusable ( ) const

overridevirtual

Check whether the codec can process new streams. Typically, an implementing subclass will return true when a new codec is created and false once it encounters a situation that would prevent reuse of the underlying transport (e.g., a "Connection: close" in HTTP/1.x).

Note: A return value of true means that the codec can process new connections at some reasonable point in the future; that may mean "immediately," for codecs that support pipelined or interleaved requests, or "upon completion of the current stream" for codecs that do not.

Implements proxygen::HTTPCodec.

Definition at line 295 of file HTTP1xCodec.cpp.

References egressUpgrade_, ingressUpgrade_, keepalive_, parserError_, and websockAcceptKey_.

Referenced by setCallback().

                               {
   return keepalive_ && !egressUpgrade_ && !ingressUpgrade_ && !parserError_ &&
     websockAcceptKey_.empty();
 }

bool proxygen::HTTP1xCodec::isWaitingToDrain ( ) const

inlineoverridevirtual

Returns true if this codec is in a state where it accepting new requests but will soon begin to reject new requests. For SPDY and HTTP/2, this is true when the first GOAWAY NO_ERROR is sent during graceful shutdown.

Implements proxygen::HTTPCodec.

Definition at line 46 of file HTTP1xCodec.h.

46 { return false; }

int proxygen::HTTP1xCodec::onBody	(	const char *	buf,
		size_t	len
	)

private

Definition at line 1144 of file HTTP1xCodec.cpp.

References callback_, folly::IOBuf::cloneOne(), currentIngressBuf_, folly::IOBuf::data(), ingressTxnID_, inRecvLastChunk_, isParsingHeaders(), folly::IOBuf::length(), folly::gen::move, and proxygen::HTTPCodec::Callback::onBody().

Referenced by isParsingHeaderOrTrailerName(), and onBodyCB().

                                                {
   DCHECK(!isParsingHeaders());
   DCHECK(!inRecvLastChunk_);
   CHECK_NOTNULL(currentIngressBuf_);
   const char* dataStart = (const char*)currentIngressBuf_->data();
   const char* dataEnd = dataStart + currentIngressBuf_->length();
   DCHECK_GE(buf, dataStart);
   DCHECK_LE(buf + len, dataEnd);
   unique_ptr<IOBuf> clone(currentIngressBuf_->cloneOne());
   clone->trimStart(buf - dataStart);
   clone->trimEnd(dataEnd - (buf + len));
   DCHECK_EQ(len, clone->computeChainDataLength());
   callback_->onBody(ingressTxnID_, std::move(clone), 0);
   return 0;
 }

int proxygen::HTTP1xCodec::onBodyCB	(	http_parser *	parser,
		const char *	buf,
		size_t	len
	)

staticprivate

Definition at line 1321 of file HTTP1xCodec.cpp.

References codec, http_parser::data, onBody(), onParserError(), and parser_.

Referenced by getParserSettings().

                                                                       {
   HTTP1xCodec* codec = static_cast<HTTP1xCodec*>(parser->data);
   DCHECK(codec != nullptr);
   DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onBody(buf, len);
   } catch (const std::exception& ex) {
     // Note: http_parser appears to completely ignore the return value from the
     // on_body() callback.  There seems to be no way to abort parsing after an
     // error in on_body().
     //
     // We handle this by checking if error_ is set after each call to
     // http_parser_execute().
     codec->onParserError(ex.what());
     return 1;
   }
 }

int proxygen::HTTP1xCodec::onChunkComplete ( )

private

Definition at line 1171 of file HTTP1xCodec.cpp.

References callback_, ingressTxnID_, inRecvLastChunk_, and proxygen::HTTPCodec::Callback::onChunkComplete().

Referenced by isParsingHeaderOrTrailerName(), and onChunkCompleteCB().

                                  {
   if (inRecvLastChunk_) {
     inRecvLastChunk_ = false;
   } else {
     callback_->onChunkComplete(ingressTxnID_);
   }
   return 0;
 }

int proxygen::HTTP1xCodec::onChunkCompleteCB ( http_parser * parser )

staticprivate

Definition at line 1353 of file HTTP1xCodec.cpp.

References codec, http_parser::data, onChunkComplete(), onParserError(), and parser_.

Referenced by getParserSettings().

                                                       {
   HTTP1xCodec* codec = static_cast<HTTP1xCodec*>(parser->data);
   DCHECK(codec != nullptr);
   DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onChunkComplete();
   } catch (const std::exception& ex) {
     codec->onParserError(ex.what());
     return 1;
   }
 }

int proxygen::HTTP1xCodec::onChunkHeader ( size_t len )

private

Definition at line 1160 of file HTTP1xCodec.cpp.

References callback_, ingressTxnID_, inRecvLastChunk_, and proxygen::HTTPCodec::Callback::onChunkHeader().

Referenced by isParsingHeaderOrTrailerName(), and onChunkHeaderCB().

                                          {
   if (len > 0) {
     callback_->onChunkHeader(ingressTxnID_, len);
   } else {
     VLOG(5) << "Suppressed onChunkHeader callback for final zero length "
             << "chunk";
     inRecvLastChunk_ = true;
   }
   return 0;
 }

int proxygen::HTTP1xCodec::onChunkHeaderCB ( http_parser * parser )

staticprivate

Definition at line 1340 of file HTTP1xCodec.cpp.

References codec, http_parser::content_length, http_parser::data, onChunkHeader(), onParserError(), and parser_.

Referenced by getParserSettings().

                                                     {
   HTTP1xCodec* codec = static_cast<HTTP1xCodec*>(parser->data);
   DCHECK(codec != nullptr);
   DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onChunkHeader(parser->content_length);
   } catch (const std::exception& ex) {
     codec->onParserError(ex.what());
     return 1;
   }
 }

int proxygen::HTTP1xCodec::onHeaderField	(	const char *	buf,
		size_t	len
	)

private

Definition at line 866 of file HTTP1xCodec.cpp.

References folly::Range< Iter >::advance(), folly::Range< Iter >::begin(), currentHeaderName_, currentHeaderNameStringPiece_, folly::Range< Iter >::end(), headerParseState_, isParsingHeaderOrTrailerName(), kParsingHeaderName, kParsingHeadersComplete, kParsingHeaderValue, kParsingTrailerName, kParsingTrailerValue, msg_, pushHeaderNameAndValue(), folly::Range< Iter >::reset(), folly::Range< Iter >::size(), and trailers_.

Referenced by isParsingHeaderOrTrailerName(), and onHeaderFieldCB().

                                                       {
   if (headerParseState_ == HeaderParseState::kParsingHeaderValue) {
     pushHeaderNameAndValue(msg_->getHeaders());
   } else if (headerParseState_ == HeaderParseState::kParsingTrailerValue) {
     if (!trailers_) {
       trailers_.reset(new HTTPHeaders());
     }
     pushHeaderNameAndValue(*trailers_);
   }
 
   if (isParsingHeaderOrTrailerName()) {
 
     // we're already parsing a header name
     if (currentHeaderName_.empty()) {
       // but we've been keeping it in currentHeaderNameStringPiece_ until now
       if (currentHeaderNameStringPiece_.end() == buf) {
         // the header name we are currently reading is contiguous in memory,
         // and so we just adjust the right end of our StringPiece;
         // this is likely because onIngress() hasn't been called since we got
         // the previous chunk (otherwise currentHeaderName_ would be nonempty)
         currentHeaderNameStringPiece_.advance(len);
       } else {
         // this is just for safety - if for any reason there is a discontinuity
         // even though we are during the same onIngress() call,
         // we fall back to currentHeaderName_
         currentHeaderName_.assign(currentHeaderNameStringPiece_.begin(),
                                   currentHeaderNameStringPiece_.size());
         currentHeaderName_.append(buf, len);
       }
     } else {
       // we had already fallen back to currentHeaderName_ before
       currentHeaderName_.append(buf, len);
     }
 
   } else {
     // we're not yet parsing a header name - this is the first chunk
     // (typically, there is only one)
     currentHeaderNameStringPiece_.reset(buf, len);
 
     if (headerParseState_ >= HeaderParseState::kParsingHeadersComplete) {
       headerParseState_ = HeaderParseState::kParsingTrailerName;
     } else {
       headerParseState_ = HeaderParseState::kParsingHeaderName;
     }
   }
   return 0;
 }

int proxygen::HTTP1xCodec::onHeaderFieldCB	(	http_parser *	parser,
		const char *	buf,
		size_t	len
	)

staticprivate

Definition at line 1278 of file HTTP1xCodec.cpp.

References codec, http_parser::data, onHeaderField(), onParserError(), and parser_.

Referenced by getParserSettings().

                                                                              {
   HTTP1xCodec* codec = static_cast<HTTP1xCodec*>(parser->data);
   DCHECK(codec != nullptr);
   DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onHeaderField(buf, len);
   } catch (const std::exception& ex) {
     codec->onParserError(ex.what());
     return 1;
   }
 }

int proxygen::HTTP1xCodec::onHeadersComplete ( size_t len )

private

Definition at line 926 of file HTTP1xCodec.cpp.

References folly::netops::accept(), allowedNativeUpgrades_, callback_, proxygen::caseInsensitiveEqual(), proxygen::checkForProtocolUpgrade(), proxygen::CONNECT, connectRequest_, DISABLED, proxygen::DOWNSTREAM, egressUpgrade_, ENABLED, proxygen::ERROR, folly::pushmi::operators::error(), expectNoResponseBody_, F_CHUNKED, F_UPGRADE, http_parser::flags, g(), generateWebsocketAccept(), proxygen::getCodecProtocolString(), proxygen::ParseURL::hasHost(), folly::Optional< Value >::hasValue(), proxygen::HEAD, headerParseState_, headersComplete_, headerSize_, headRequest_, proxygen::ParseURL::hostAndPort(), proxygen::HTTP_1_1, proxygen::HTTP_HEADER_CONTENT_LENGTH, proxygen::HTTP_HEADER_HOST, proxygen::HTTP_HEADER_SEC_WEBSOCKET_ACCEPT, proxygen::HTTP_HEADER_SEC_WEBSOCKET_KEY, proxygen::HTTP_HEADER_TRANSFER_ENCODING, proxygen::HTTP_HEADER_UPGRADE, proxygen::HTTP_HEADER_USER_AGENT, http_parser::http_major, http_method_str(), http_parser::http_minor, ingressTxnID_, ingressUpgrade_, is1xxResponse_, keepalive_, keepaliveRequested_, kParsingHeadersComplete, kParsingHeaderValue, folly::makeGuard(), mayChunkEgress_, http_parser::method, folly::gen::move, msg_, nativeUpgrade_, proxygen::HTTPCodec::Callback::onHeadersComplete(), proxygen::HTTPCodec::Callback::onNativeProtocolUpgrade(), parser_, pushHeaderNameAndValue(), reason_, proxygen::RFC2616::responseBodyMustBeEmpty(), http_parser::status_code, string, transportDirection_, wangle::HTTPHeaderSize::uncompressed, UNSET, http_parser::upgrade, upgradeHeader_, upgradeRequest_, upgradeResult_, proxygen::UPSTREAM, url_, userAgent_, value, folly::Optional< Value >::value(), and websockAcceptKey_.

Referenced by isParsingHeaderOrTrailerName(), onHeadersCompleteCB(), and onIngress().

                                          {
   if (headerParseState_ == HeaderParseState::kParsingHeaderValue) {
     pushHeaderNameAndValue(msg_->getHeaders());
   }
 
   // discard messages with folded or multiple valued Transfer-Encoding headers
   // ex : "chunked , zorg\r\n" or "\r\n chunked \r\n" (t12767790)
   HTTPHeaders& hdrs = msg_->getHeaders();
   const std::string& headerVal =
     hdrs.getSingleOrEmpty(HTTP_HEADER_TRANSFER_ENCODING);
   if (!headerVal.empty() && !caseInsensitiveEqual(headerVal, kChunked)) {
       LOG(ERROR) << "Invalid Transfer-Encoding header. Value =" << headerVal;
       return -1;
   }
 
   // discard messages with multiple content-length headers (t12767790)
   if (hdrs.getNumberOfValues(HTTP_HEADER_CONTENT_LENGTH) > 1) {
     // Only reject the message if the Content-Length headers have different
     // values
     folly::Optional<folly::StringPiece> contentLen;
     bool error = hdrs.forEachValueOfHeader(
         HTTP_HEADER_CONTENT_LENGTH, [&] (folly::StringPiece value) -> bool {
       if (!contentLen.hasValue()) {
         contentLen = value;
         return false;
       }
       return (contentLen.value() != value);
     });
 
     if (error) {
       LOG(ERROR) << "Invalid message, multiple Content-Length headers";
       return -1;
     }
   }
 
   // Update the HTTPMessage with the values parsed from the header
   msg_->setHTTPVersion(parser_.http_major, parser_.http_minor);
   msg_->setIsChunked((parser_.flags & F_CHUNKED));
 
   if (transportDirection_ == TransportDirection::DOWNSTREAM) {
     // Set the method type
     msg_->setMethod(http_method_str(static_cast<http_method>(parser_.method)));
 
     connectRequest_ = (msg_->getMethod() == HTTPMethod::CONNECT);
 
     // If this is a headers-only request, we shouldn't send
     // an entity-body in the response.
     headRequest_ = (msg_->getMethod() == HTTPMethod::HEAD);
 
     ParseURL parseUrl = msg_->setURL(std::move(url_));
     url_.clear();
 
     if (parseUrl.hasHost()) {
       // RFC 2616 5.2.1 states "If Request-URI is an absoluteURI, the host
       // is part of the Request-URI. Any Host header field value in the
       // request MUST be ignored."
       auto hostAndPort = parseUrl.hostAndPort();
       VLOG(4) << "Adding inferred host header: " << hostAndPort;
       msg_->getHeaders().set(HTTP_HEADER_HOST, hostAndPort);
     }
 
     // If the client sent us an HTTP/1.x with x >= 1, we may send
     // chunked responses.
     mayChunkEgress_ = ((parser_.http_major == 1) && (parser_.http_minor >= 1));
   } else {
     msg_->setStatusCode(parser_.status_code);
     msg_->setStatusMessage(std::move(reason_));
     reason_.clear();
   }
 
   auto g = folly::makeGuard([this] {
       // Always clear the outbound upgrade header after we receive a response
       if (transportDirection_ == TransportDirection::UPSTREAM &&
           parser_.status_code != 100) {
         upgradeHeader_.clear();
       }
     });
   headerParseState_ = HeaderParseState::kParsingHeadersComplete;
   if (transportDirection_ == TransportDirection::UPSTREAM) {
     if (connectRequest_ &&
         (parser_.status_code >= 200 && parser_.status_code < 300)) {
       // Enable upgrade if this is a 200 response to a CONNECT
       // request we sent earlier
       ingressUpgrade_ = true;
     } else if (parser_.status_code == 101) {
       // Set the upgrade flags if the server has upgraded.
       const std::string& serverUpgrade =
         msg_->getHeaders().getSingleOrEmpty(HTTP_HEADER_UPGRADE);
       if (serverUpgrade.empty() ||
           upgradeHeader_.empty()) {
         LOG(ERROR) << "Invalid 101 response, empty upgrade headers";
         return -1;
       }
       auto result = checkForProtocolUpgrade(upgradeHeader_,
                                             serverUpgrade,
                                             false /* client mode */);
       if (result) {
         ingressUpgrade_ = true;
         egressUpgrade_ = true;
         if (result->first != CodecProtocol::HTTP_1_1) {
           bool success = callback_->onNativeProtocolUpgrade(
             ingressTxnID_, result->first, result->second, *msg_);
           if (success) {
             nativeUpgrade_ = true;
             msg_->setIsUpgraded(ingressUpgrade_);
             return 1;  // no message body if successful
           }
         } else if (result->second == getCodecProtocolString(result->first)) {
           // someone upgraded to http/1.1?  Reset upgrade flags
           ingressUpgrade_ = false;
           egressUpgrade_ = false;
         }
         // else, there's some non-native upgrade
       } else {
         LOG(ERROR) << "Invalid 101 response, client/server upgrade mismatch "
           "client=" << upgradeHeader_ << " server=" << serverUpgrade;
         return -1;
       }
     } else if (parser_.upgrade || parser_.flags & F_UPGRADE) {
       // Ignore upgrade header for upstream response messages with status code
       // different from 101 in case if it was not a response to CONNECT.
       parser_.upgrade = false;
       parser_.flags &= ~F_UPGRADE;
     }
   }
   else {
     if (connectRequest_) {
       // Enable upgrade by default for the CONNECT requests.
       // If we locally reject CONNECT, we will disable this flag while
       // sending the reject response. If we forward the req to upstream proxy,
       // we will start forwarding data to the proxy without waiting for
       // the response from the proxy server.
       ingressUpgrade_ = true;
     } else if (!allowedNativeUpgrades_.empty() && ingressTxnID_ == 1) {
       upgradeHeader_ = msg_->getHeaders().getSingleOrEmpty(HTTP_HEADER_UPGRADE);
       if (!upgradeHeader_.empty() && !allowedNativeUpgrades_.empty()) {
         auto result = checkForProtocolUpgrade(upgradeHeader_,
                                               allowedNativeUpgrades_,
                                               true /* server mode */);
         if (result && result->first != CodecProtocol::HTTP_1_1) {
           nativeUpgrade_ = true;
           upgradeResult_ = *result;
           // unfortunately have to copy because msg_ is passed to
           // onHeadersComplete
           upgradeRequest_ = std::make_unique<HTTPMessage>(*msg_);
         }
       }
     }
   }
   msg_->setIsUpgraded(ingressUpgrade_);
 
   const std::string& upgrade = hdrs.getSingleOrEmpty(HTTP_HEADER_UPGRADE);
   if (kUpgradeToken.equals(upgrade, folly::AsciiCaseInsensitive())) {
     msg_->setIngressWebsocketUpgrade();
     if (transportDirection_ == TransportDirection::UPSTREAM) {
       // response.
       const std::string& accept = hdrs.getSingleOrEmpty(
           HTTP_HEADER_SEC_WEBSOCKET_ACCEPT);
       if (accept != websockAcceptKey_) {
         LOG(ERROR) << "Mismatch in expected ws accept key: " <<
           "upstream: " << accept << " expected: " << websockAcceptKey_;
         return -1;
       }
     } else {
       // request.
       auto key = hdrs.getSingleOrEmpty(HTTP_HEADER_SEC_WEBSOCKET_KEY);
       DCHECK(websockAcceptKey_.empty());
       websockAcceptKey_ = generateWebsocketAccept(key);
     }
   }
 
   bool msgKeepalive = msg_->computeKeepalive();
   if (!msgKeepalive) {
      keepalive_ = false;
   }
   if (transportDirection_ == TransportDirection::DOWNSTREAM) {
     // Remember whether this was an HTTP 1.0 request with keepalive enabled
     if (msgKeepalive && msg_->isHTTP1_0() &&
           (keepaliveRequested_ == KeepaliveRequested::UNSET ||
            keepaliveRequested_ == KeepaliveRequested::ENABLED)) {
       keepaliveRequested_ = KeepaliveRequested::ENABLED;
     } else {
       keepaliveRequested_ = KeepaliveRequested::DISABLED;
     }
   }
 
   // Determine whether the HTTP parser should ignore any headers
   // that indicate the presence of a message body.  This is needed,
   // for example, if the message is a response to a request with
   // method==HEAD.
   bool ignoreBody;
   if (transportDirection_ == TransportDirection::DOWNSTREAM) {
     ignoreBody = false;
   } else {
     is1xxResponse_ = msg_->is1xxResponse();
     if (expectNoResponseBody_) {
       ignoreBody = true;
     } else {
       ignoreBody = RFC2616::responseBodyMustBeEmpty(msg_->getStatusCode());
     }
   }
 
   headersComplete_ = true;
   headerSize_.uncompressed += len;
   msg_->setIngressHeaderSize(headerSize_);
 
   if (userAgent_.empty()) {
     userAgent_ = msg_->getHeaders().getSingleOrEmpty(HTTP_HEADER_USER_AGENT);
   }
   callback_->onHeadersComplete(ingressTxnID_, std::move(msg_));
 
   // 1 is a magic value that tells the http_parser not to expect a
   // message body even if the message header implied the presence
   // of one (e.g., via a Content-Length)
   return (ignoreBody) ? 1 : 0;
 }

int proxygen::HTTP1xCodec::onHeadersCompleteCB	(	http_parser *	parser,
		const char *	buf,
		size_t	len
	)

staticprivate

Definition at line 1305 of file HTTP1xCodec.cpp.

References codec, http_parser::data, onHeadersComplete(), onParserError(), and parser_.

Referenced by getParserSettings().

                                                  {
   HTTP1xCodec* codec = static_cast<HTTP1xCodec*>(parser->data);
   DCHECK(codec != nullptr);
   DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onHeadersComplete(len);
   } catch (const std::exception& ex) {
     codec->onParserError(ex.what());
     return 3;
   }
 }

int proxygen::HTTP1xCodec::onHeaderValue	(	const char *	buf,
		size_t	len
	)

private

Definition at line 915 of file HTTP1xCodec.cpp.

References currentHeaderValue_, headerParseState_, isParsingHeaders(), kParsingHeaderValue, and kParsingTrailerValue.

Referenced by isParsingHeaderOrTrailerName(), and onHeaderValueCB().

                                                       {
   if (isParsingHeaders()) {
     headerParseState_ = HeaderParseState::kParsingHeaderValue;
   } else {
     headerParseState_ = HeaderParseState::kParsingTrailerValue;
   }
   currentHeaderValue_.append(buf, len);
   return 0;
 }

int proxygen::HTTP1xCodec::onHeaderValueCB	(	http_parser *	parser,
		const char *	buf,
		size_t	len
	)

staticprivate

Definition at line 1292 of file HTTP1xCodec.cpp.

References codec, http_parser::data, onHeaderValue(), onParserError(), and parser_.

Referenced by getParserSettings().

                                                                              {
   HTTP1xCodec* codec = static_cast<HTTP1xCodec*>(parser->data);
   DCHECK(codec != nullptr);
   DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onHeaderValue(buf, len);
   } catch (const std::exception& ex) {
     codec->onParserError(ex.what());
     return 1;
   }
 }

size_t proxygen::HTTP1xCodec::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 177 of file HTTP1xCodec.cpp.

References folly::Range< Iter >::begin(), callback_, folly::IOBuf::clone(), folly::IOBuf::computeChainDataLength(), currentHeaderName_, currentHeaderNameStringPiece_, currentIngressBuf_, folly::IOBuf::data(), folly::Range< Iter >::empty(), getParserSettings(), headersComplete_, headerSize_, HPE_OK, HPE_PAUSED, http_parser::http_major, http_parser::http_minor, HTTP_PARSER_ERRNO, http_parser_execute(), ingressTxnID_, ingressUpgradeComplete_, folly::IOBuf::length(), msg_, proxygen::HTTPCodec::Callback::onBody(), onHeadersComplete(), onIngressEOF(), onMessageBegin(), onParserError(), parser_, parserActive_, parserError_, pendingEOF_, folly::Range< Iter >::size(), transportDirection_, wangle::HTTPHeaderSize::uncompressed, and proxygen::UPSTREAM.

Referenced by setCallback(), TEST(), and TEST_P().

                                        {
   if (parserError_) {
     return 0;
   } else if (ingressUpgradeComplete_) {
     callback_->onBody(ingressTxnID_, buf.clone(), 0);
     return buf.computeChainDataLength();
   } else {
     // Callers responsibility to prevent calling onIngress from a callback
     CHECK(!parserActive_);
     parserActive_ = true;
     currentIngressBuf_ = &buf;
     if (transportDirection_ == TransportDirection::UPSTREAM &&
         parser_.http_major == 0 && parser_.http_minor == 9) {
       // HTTP/0.9 responses have no header block, so create a fake 200 response
       // and put the codec in upgrade mode
       onMessageBegin();
       msg_->setStatusCode(200);
       onHeadersComplete(0);
       parserActive_ = false;
       ingressUpgradeComplete_ = true;
       return onIngress(buf);
     }
     size_t bytesParsed = http_parser_execute(&parser_,
                                              getParserSettings(),
                                              (const char*)buf.data(),
                                              buf.length());
     // in case we parsed a section of the headers but we're not done parsing
     // the headers we need to keep accounting of it for total header size
     if (!headersComplete_) {
       headerSize_.uncompressed += bytesParsed;
     }
     parserActive_ = false;
     parserError_ = (HTTP_PARSER_ERRNO(&parser_) != HPE_OK) &&
         (HTTP_PARSER_ERRNO(&parser_) != HPE_PAUSED);
     if (parserError_) {
       onParserError();
     }
     if (currentHeaderName_.empty() && !currentHeaderNameStringPiece_.empty()) {
       // we currently are storing a chunk of header name via pointers in
       // currentHeaderNameStringPiece_, but the currentIngressBuf_ is about to
       // vanish and so we need to copy over that data to currentHeaderName_
       currentHeaderName_.assign(currentHeaderNameStringPiece_.begin(),
                                 currentHeaderNameStringPiece_.size());
     }
     currentIngressBuf_ = nullptr;
     if (pendingEOF_) {
       onIngressEOF();
       pendingEOF_ = false;
     }
     return bytesParsed;
   }
 }

void proxygen::HTTP1xCodec::onIngressEOF ( )

overridevirtual

Finish parsing when the ingress stream has ended.

Implements proxygen::HTTPCodec.

Definition at line 231 of file HTTP1xCodec.cpp.

References callback_, getParserSettings(), HPE_OK, HPE_PAUSED, HTTP_PARSER_ERRNO, http_parser_execute(), ingressTxnID_, ingressUpgradeComplete_, proxygen::HTTPCodec::Callback::onMessageComplete(), onParserError(), parser_, parserActive_, parserError_, and pendingEOF_.

Referenced by onIngress(), setCallback(), and TEST().

                           {
   if (parserError_) {
     return;
   }
   if (parserActive_) {
     pendingEOF_ = true;
     return;
   }
   if (ingressUpgradeComplete_) {
     callback_->onMessageComplete(ingressTxnID_, false);
     return;
   }
   parserActive_ = true;
   if (http_parser_execute(&parser_, getParserSettings(), nullptr, 0) != 0) {
     parserError_ = true;
   } else {
     parserError_ = (HTTP_PARSER_ERRNO(&parser_) != HPE_OK) &&
         (HTTP_PARSER_ERRNO(&parser_) != HPE_PAUSED);
   }
   parserActive_ = false;
   if (parserError_) {
     onParserError();
   }
 }

int proxygen::HTTP1xCodec::onMessageBegin ( )

private

Definition at line 817 of file HTTP1xCodec.cpp.

References callback_, proxygen::DOWNSTREAM, headerParseState_, headersComplete_, headerSize_, ingressTxnID_, is1xxResponse_, kParsingHeaderStart, msg_, proxygen::HTTPCodec::Callback::onMessageBegin(), requestPending_, responsePending_, trailers_, transportDirection_, wangle::HTTPHeaderSize::uncompressed, and proxygen::UPSTREAM.

Referenced by isParsingHeaderOrTrailerName(), onIngress(), and onMessageBeginCB().

                             {
   headersComplete_ = false;
   headerSize_.uncompressed = 0;
   headerParseState_ = HeaderParseState::kParsingHeaderStart;
   msg_.reset(new HTTPMessage());
   trailers_.reset();
   if (transportDirection_ == TransportDirection::DOWNSTREAM) {
     requestPending_ = true;
     responsePending_ = true;
   }
   // If there was a 1xx on this connection, don't increment the ingress txn id
   if (transportDirection_ == TransportDirection::DOWNSTREAM ||
       !is1xxResponse_) {
     ++ingressTxnID_;
   }
   if (transportDirection_ == TransportDirection::UPSTREAM) {
     is1xxResponse_ = false;
   }
   callback_->onMessageBegin(ingressTxnID_, msg_.get());
   return 0;
 }

int proxygen::HTTP1xCodec::onMessageBeginCB ( http_parser * parser )

staticprivate

Definition at line 1236 of file HTTP1xCodec.cpp.

References codec, http_parser::data, onMessageBegin(), onParserError(), and parser_.

Referenced by getParserSettings().

                                                  {
   HTTP1xCodec* codec = static_cast<HTTP1xCodec*>(parser->data);
   DCHECK(codec != nullptr);
   DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onMessageBegin();
   } catch (const std::exception& ex) {
     codec->onParserError(ex.what());
     return 1;
   }
 }

int proxygen::HTTP1xCodec::onMessageComplete ( )

private

Definition at line 1180 of file HTTP1xCodec.cpp.

References callback_, proxygen::DOWNSTREAM, headerParseState_, ingressTxnID_, ingressUpgrade_, ingressUpgradeComplete_, inRecvLastChunk_, is1xxResponse_, isParsingHeaders(), kParsingHeaderIdle, kParsingTrailerValue, folly::gen::move, nativeUpgrade_, proxygen::HTTPCodec::Callback::onMessageComplete(), proxygen::HTTPCodec::Callback::onNativeProtocolUpgrade(), proxygen::HTTPCodec::Callback::onTrailersComplete(), pushHeaderNameAndValue(), requestPending_, responsePending_, setParserPaused(), trailers_, transportDirection_, upgradeRequest_, upgradeResult_, and proxygen::UPSTREAM.

Referenced by isParsingHeaderOrTrailerName(), and onMessageCompleteCB().

                                    {
   DCHECK(!isParsingHeaders());
   DCHECK(!inRecvLastChunk_);
   if (headerParseState_ == HeaderParseState::kParsingTrailerValue) {
     if (!trailers_) {
       trailers_.reset(new HTTPHeaders());
     }
     pushHeaderNameAndValue(*trailers_);
   }
 
   headerParseState_ = HeaderParseState::kParsingHeaderIdle;
   if (trailers_) {
     callback_->onTrailersComplete(ingressTxnID_, std::move(trailers_));
   }
 
   switch (transportDirection_) {
   case TransportDirection::DOWNSTREAM:
   {
     requestPending_ = false;
     if (upgradeRequest_) {
       ingressUpgrade_ = callback_->onNativeProtocolUpgrade(
         ingressTxnID_, upgradeResult_.first, upgradeResult_.second,
         *upgradeRequest_);
       upgradeRequest_.reset();
     }
     // else there was no match, OR we upgraded to http/1.1 OR someone specified
     // a non-native protocol in the setAllowedUpgradeProtocols.  No-ops
     break;
   }
   case TransportDirection::UPSTREAM:
     responsePending_ = is1xxResponse_;
   }
 
   // For downstream, always call onMessageComplete. If native upgrade,
   // pass upgrade=false. Else pass ingressUpgrade_.
   // For upstream, call onMessagComplete if not native upgrade.
   if (!nativeUpgrade_) {
     callback_->onMessageComplete(ingressTxnID_, ingressUpgrade_);
   } else if (transportDirection_ == TransportDirection::DOWNSTREAM) {
     // native upgrade and downstream.
     callback_->onMessageComplete(ingressTxnID_, false);
   }
   // else we suppressed onHeadersComplete, suppress onMessageComplete also.
   // The new codec will handle these callbacks with the real message
 
   if (ingressUpgrade_) {
     ingressUpgradeComplete_ = true;
     // If upgrade is complete, any pending data should not be parsed.
     // It must be forwarded directly to the handler.
     setParserPaused(true);
   }
 
   return 0;
 }

int proxygen::HTTP1xCodec::onMessageCompleteCB ( http_parser * parser )

staticprivate

Definition at line 1367 of file HTTP1xCodec.cpp.

References codec, http_parser::data, onMessageComplete(), onParserError(), and parser_.

Referenced by getParserSettings().

                                                     {
   HTTP1xCodec* codec = static_cast<HTTP1xCodec*>(parser->data);
   DCHECK(codec != nullptr);
   DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onMessageComplete();
   } catch (const std::exception& ex) {
     codec->onParserError(ex.what());
     return 1;
   }
 }

void proxygen::HTTP1xCodec::onParserError ( const char * what = nullptr )

private

Invoked when a parsing error occurs. It will send an exception to the callback object to report the error and do any other cleanup needed. It optionally takes a message to pass to the generated HTTPException passed to callback_.

Definition at line 257 of file HTTP1xCodec.cpp.

References callback_, folly::IOBuf::cloneOne(), currentIngressBuf_, proxygen::DOWNSTREAM, egressTxnID_, folly::pushmi::operators::error(), HPE_HEADER_OVERFLOW, HPE_HUGE_CHUNK_SIZE, HPE_HUGE_CONTENT_LENGTH, HPE_INVALID_CHUNK_SIZE, HPE_INVALID_CONSTANT, HPE_INVALID_EOF_STATE, HPE_INVALID_VERSION, http_errno_description(), HTTP_PARSER_ERRNO, proxygen::HTTPException::INGRESS, ingressTxnID_, inRecvLastChunk_, proxygen::kErrorEOF, proxygen::kErrorParseBody, proxygen::kErrorParseHeader, proxygen::kErrorUnknown, folly::gen::move, msg_, proxygen::HTTPCodec::Callback::onError(), parser_, proxygen::HTTPException::setCurrentIngressBuf(), proxygen::HTTPException::setHttpStatusCode(), proxygen::HTTPException::setPartialMsg(), proxygen::Exception::setProxygenError(), and transportDirection_.

Referenced by isParsingHeaderOrTrailerName(), onBodyCB(), onChunkCompleteCB(), onChunkHeaderCB(), onHeaderFieldCB(), onHeadersCompleteCB(), onHeaderValueCB(), onIngress(), onIngressEOF(), onMessageBeginCB(), onMessageCompleteCB(), onReasonCB(), and onUrlCB().

                                            {
   inRecvLastChunk_ = false;
   http_errno parser_errno = HTTP_PARSER_ERRNO(&parser_);
   HTTPException error(HTTPException::Direction::INGRESS,
                       what ? what : folly::to<std::string>(
                         "Error parsing message: ",
                         http_errno_description(parser_errno)
                       ));
   // generate a string of parsed headers so that we can pass it to callback
   if (msg_) {
     error.setPartialMsg(std::move(msg_));
   }
   // store the ingress buffer
   if (currentIngressBuf_) {
     error.setCurrentIngressBuf(currentIngressBuf_->cloneOne());
   }
   if (transportDirection_ == TransportDirection::DOWNSTREAM &&
       egressTxnID_ < ingressTxnID_) {
     error.setHttpStatusCode(400);
   } // else we've already egressed a response for this txn, don't attempt a 400
   // See http_parser.h for what these error codes mean
   if (parser_errno == HPE_INVALID_EOF_STATE) {
     error.setProxygenError(kErrorEOF);
   } else if (parser_errno == HPE_HEADER_OVERFLOW ||
              parser_errno == HPE_INVALID_CONSTANT ||
              (parser_errno >= HPE_INVALID_VERSION &&
               parser_errno <= HPE_HUGE_CONTENT_LENGTH)) {
     error.setProxygenError(kErrorParseHeader);
   } else if (parser_errno == HPE_INVALID_CHUNK_SIZE ||
              parser_errno == HPE_HUGE_CHUNK_SIZE) {
     error.setProxygenError(kErrorParseBody);
   } else {
     error.setProxygenError(kErrorUnknown);
   }
   callback_->onError(ingressTxnID_, error);
 }

static int proxygen::HTTP1xCodec::onPathCB	(	http_parser *	parser,
		const char *	buf,
		size_t	len
	)

staticprivate

static int proxygen::HTTP1xCodec::onQueryStringCB	(	http_parser *	parser,
		const char *	buf,
		size_t	len
	)

staticprivate

int proxygen::HTTP1xCodec::onReason	(	const char *	buf,
		size_t	len
	)

private

Definition at line 846 of file HTTP1xCodec.cpp.

References reason_.

Referenced by isParsingHeaderOrTrailerName(), and onReasonCB().

                                                  {
   reason_.append(buf, len);
   return 0;
 }

int proxygen::HTTP1xCodec::onReasonCB	(	http_parser *	parser,
		const char *	buf,
		size_t	len
	)

staticprivate

Definition at line 1264 of file HTTP1xCodec.cpp.

References codec, http_parser::data, onParserError(), onReason(), and parser_.

Referenced by getParserSettings().

                                                                         {
   HTTP1xCodec* codec = static_cast<HTTP1xCodec*>(parser->data);
   DCHECK(codec != nullptr);
   DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onReason(buf, len);
   } catch (const std::exception& ex) {
     codec->onParserError(ex.what());
     return 1;
   }
 }

int proxygen::HTTP1xCodec::onURL	(	const char *	buf,
		size_t	len
	)

private

Definition at line 840 of file HTTP1xCodec.cpp.

References url_.

Referenced by isParsingHeaderOrTrailerName(), and onUrlCB().

                                               {
   url_.append(buf, len);
   return 0;
 }

int proxygen::HTTP1xCodec::onUrlCB	(	http_parser *	parser,
		const char *	buf,
		size_t	len
	)

staticprivate

Definition at line 1250 of file HTTP1xCodec.cpp.

References codec, http_parser::data, onParserError(), onURL(), and parser_.

Referenced by getParserSettings().

                                                                      {
   HTTP1xCodec* codec = static_cast<HTTP1xCodec*>(parser->data);
   DCHECK(codec != nullptr);
   DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onURL(buf, len);
   } catch (const std::exception& ex) {
     codec->onParserError(ex.what());
     return 1;
   }
 }

void proxygen::HTTP1xCodec::pushHeaderNameAndValue ( HTTPHeaders & hdrs )

private

Push out header name-value pair to hdrs and clear currentHeader*_

Definition at line 851 of file HTTP1xCodec.cpp.

References proxygen::HTTPHeaders::add(), proxygen::HTTPHeaders::addFromCodec(), folly::Range< Iter >::begin(), folly::Range< Iter >::clear(), currentHeaderName_, currentHeaderNameStringPiece_, currentHeaderValue_, LIKELY, folly::gen::move, and folly::Range< Iter >::size().

Referenced by isParsingHeaderOrTrailerName(), onHeaderField(), onHeadersComplete(), and onMessageComplete().

                                                           {
   if (LIKELY(currentHeaderName_.empty())) {
     hdrs.addFromCodec(currentHeaderNameStringPiece_.begin(),
                       currentHeaderNameStringPiece_.size(),
                       std::move(currentHeaderValue_));
   } else {
     hdrs.add(currentHeaderName_,
              std::move(currentHeaderValue_));
     currentHeaderName_.clear();
   }
   currentHeaderNameStringPiece_.clear();
   currentHeaderValue_.clear();
 }

void proxygen::HTTP1xCodec::serializeWebsocketHeader	(	folly::IOBufQueue &	writeBuf,
		size_t &	len,
		bool	upstream
	)

private

Serialize websocket headers into a buffer

Definition at line 337 of file HTTP1xCodec.cpp.

References appendLiteral, generateWebsocketAccept(), generateWebsocketKey(), upgradeHeader_, and websockAcceptKey_.

Referenced by generateHeader(), and isParsingHeaderOrTrailerName().

                                                           {
     if (upstream) {
       appendLiteral(writeBuf, len, "Upgrade: ");
       appendString(writeBuf, len, kUpgradeToken.str());
       appendLiteral(writeBuf, len, CRLF);
       upgradeHeader_ = kUpgradeToken.str();
 
       auto key = generateWebsocketKey();
       appendLiteral(writeBuf, len, "Sec-WebSocket-Key: ");
       appendString(writeBuf, len, key);
       appendLiteral(writeBuf, len, CRLF);
       DCHECK(websockAcceptKey_.empty());
       websockAcceptKey_ = generateWebsocketAccept(key);
     } else {
       appendLiteral(writeBuf, len, "Upgrade: ");
       appendString(writeBuf, len, kUpgradeToken.str());
       appendLiteral(writeBuf, len, CRLF);
 
       appendLiteral(writeBuf, len, "Sec-WebSocket-Accept: ");
       appendString(writeBuf, len, websockAcceptKey_);
       appendLiteral(writeBuf, len, CRLF);
     }
 }

void proxygen::HTTP1xCodec::setAllowedUpgradeProtocols ( std::list< std::string > protocols )

Definition at line 802 of file HTTP1xCodec.cpp.

References allowedNativeUpgrades_, proxygen::DOWNSTREAM, and transportDirection_.

Referenced by supportsPushTransactions().

                                                                          {
   CHECK(transportDirection_ == TransportDirection::DOWNSTREAM);
   for (const auto& proto: protocols) {
     allowedNativeUpgrades_ += folly::to<string>(proto, ",");
   }
   if (!allowedNativeUpgrades_.empty()) {
     allowedNativeUpgrades_.erase(allowedNativeUpgrades_.size() - 1);
   }
 }

void proxygen::HTTP1xCodec::setCallback ( Callback * callback )

inlineoverridevirtual

Set the callback to notify on ingress events

Parameters

callback The callback object

Implements proxygen::HTTPCodec.

Definition at line 40 of file HTTP1xCodec.h.

References callback_, isBusy(), isReusable(), onIngress(), onIngressEOF(), and setParserPaused().

Referenced by proxygen::RFC1867Codec::RFC1867Codec(), TEST(), and TEST_P().

40 { callback_ = callback; }

proxygen::HTTP1xCodec::callback_

HTTPCodec::Callback * callback_

Definition: HTTP1xCodec.h:153

void proxygen::HTTP1xCodec::setParserPaused ( bool paused )

overridevirtual

Pause or resume the ingress parser

Parameters

paused Whether the caller wants the parser to be paused

Implements proxygen::HTTPCodec.

Definition at line 141 of file HTTP1xCodec.cpp.

References HPE_OK, HPE_PAUSED, HTTP_PARSER_ERRNO, http_parser_pause(), parser_, parserError_, and parserPaused_.

Referenced by proxygen::RFC1867Codec::onBody(), proxygen::RFC1867Codec::onError(), proxygen::RFC1867Codec::onMessageComplete(), onMessageComplete(), proxygen::RFC1867Codec::onTrailersComplete(), setCallback(), and TEST().

                                         {
   if ((paused == parserPaused_) || parserError_) {
     // If we're bailing early, we better be paused already
     DCHECK(parserError_ ||
            (HTTP_PARSER_ERRNO(&parser_) == HPE_PAUSED) == paused);
     return;
   }
   if (paused) {
     if (HTTP_PARSER_ERRNO(&parser_) == HPE_OK) {
       http_parser_pause(&parser_, 1);
     }
   } else {
     http_parser_pause(&parser_, 0);
   }
   parserPaused_ = paused;
 }

bool proxygen::HTTP1xCodec::supportsNextProtocol ( const std::string & npn )

static

Returns: true if the codec supports the given NPN protocol.

Definition at line 1380 of file HTTP1xCodec.cpp.

Referenced by proxygen::DefaultHTTPCodecFactory::getCodec(), proxygen::HTTPDefaultSessionCodecFactory::getCodec(), and supportsPushTransactions().

                                                            {
   return npn.length() == 8 && (npn == "http/1.0" || npn == "http/1.1");
 }

bool proxygen::HTTP1xCodec::supportsParallelRequests ( ) const

inlineoverridevirtual

Check whether the codec supports the processing of multiple requests in parallel.

Implements proxygen::HTTPCodec.

Definition at line 50 of file HTTP1xCodec.h.

50 { return false; }

bool proxygen::HTTP1xCodec::supportsPushTransactions ( ) const

inlineoverridevirtual

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

Implements proxygen::HTTPCodec.

Definition at line 51 of file HTTP1xCodec.h.

References generateBody(), generateChunkHeader(), generateChunkTerminator(), generateEOM(), generateGoaway(), generateHeader(), generateRstStream(), generateTrailers(), getAllowedUpgradeProtocols(), setAllowedUpgradeProtocols(), folly::size(), statusCode, string, supportsNextProtocol(), and fizz::detail::writeBuf().

51 { return false; }

Member Data Documentation

std::string proxygen::HTTP1xCodec::allowedNativeUpgrades_

private

Definition at line 168 of file HTTP1xCodec.h.

Referenced by getAllowedUpgradeProtocols(), onHeadersComplete(), and setAllowedUpgradeProtocols().

HTTPCodec::Callback* proxygen::HTTP1xCodec::callback_

private

Definition at line 153 of file HTTP1xCodec.h.

Referenced by onBody(), onChunkComplete(), onChunkHeader(), onHeadersComplete(), onIngress(), onIngressEOF(), onMessageBegin(), onMessageComplete(), onParserError(), and setCallback().

bool proxygen::HTTP1xCodec::connectRequest_

private

Definition at line 187 of file HTTP1xCodec.h.

Referenced by generateHeader(), and onHeadersComplete().

std::string proxygen::HTTP1xCodec::currentHeaderName_

private

Definition at line 161 of file HTTP1xCodec.h.

Referenced by onHeaderField(), onIngress(), and pushHeaderNameAndValue().

folly::StringPiece proxygen::HTTP1xCodec::currentHeaderNameStringPiece_

private

Definition at line 162 of file HTTP1xCodec.h.

Referenced by onHeaderField(), onIngress(), and pushHeaderNameAndValue().

std::string proxygen::HTTP1xCodec::currentHeaderValue_

private

Definition at line 163 of file HTTP1xCodec.h.

Referenced by onHeaderValue(), and pushHeaderNameAndValue().

const folly::IOBuf* proxygen::HTTP1xCodec::currentIngressBuf_

private

Definition at line 157 of file HTTP1xCodec.h.

Referenced by onBody(), onIngress(), and onParserError().

bool proxygen::HTTP1xCodec::disableKeepalivePending_

private

Definition at line 185 of file HTTP1xCodec.h.

Referenced by generateGoaway(), generateHeader(), and generateRstStream().

bool proxygen::HTTP1xCodec::egressChunked_

private

Definition at line 181 of file HTTP1xCodec.h.

Referenced by generateBody(), generateChunkHeader(), generateChunkTerminator(), generateEOM(), generateHeader(), and generateTrailers().

StreamID proxygen::HTTP1xCodec::egressTxnID_

private

Definition at line 155 of file HTTP1xCodec.h.

Referenced by createStream(), generateBody(), generateEOM(), generateHeader(), generateTrailers(), and onParserError().

bool proxygen::HTTP1xCodec::egressUpgrade_

private

Definition at line 195 of file HTTP1xCodec.h.

Referenced by closeOnEgressComplete(), generateHeader(), isReusable(), and onHeadersComplete().

bool proxygen::HTTP1xCodec::expectNoResponseBody_

private

Definition at line 189 of file HTTP1xCodec.h.

Referenced by generateHeader(), and onHeadersComplete().

bool proxygen::HTTP1xCodec::forceUpstream1_1_

private

Definition at line 174 of file HTTP1xCodec.h.

Referenced by generateHeader().

HeaderParseState proxygen::HTTP1xCodec::headerParseState_

private

Definition at line 170 of file HTTP1xCodec.h.

Referenced by isParsingHeaderOrTrailerName(), isParsingHeaders(), onHeaderField(), onHeadersComplete(), onHeaderValue(), onMessageBegin(), and onMessageComplete().

bool proxygen::HTTP1xCodec::headersComplete_

private

Definition at line 197 of file HTTP1xCodec.h.

Referenced by onHeadersComplete(), onIngress(), and onMessageBegin().

HTTPHeaderSize proxygen::HTTP1xCodec::headerSize_

private

Definition at line 169 of file HTTP1xCodec.h.

Referenced by onHeadersComplete(), onIngress(), and onMessageBegin().

bool proxygen::HTTP1xCodec::headRequest_

private

Definition at line 188 of file HTTP1xCodec.h.

Referenced by generateEOM(), generateHeader(), and onHeadersComplete().

bool proxygen::HTTP1xCodec::inChunk_

private

Definition at line 182 of file HTTP1xCodec.h.

Referenced by generateBody(), generateChunkHeader(), generateChunkTerminator(), generateEOM(), and generateTrailers().

StreamID proxygen::HTTP1xCodec::ingressTxnID_

private

Definition at line 154 of file HTTP1xCodec.h.

Referenced by createStream(), generateHeader(), onBody(), onChunkComplete(), onChunkHeader(), onHeadersComplete(), onIngress(), onIngressEOF(), onMessageBegin(), onMessageComplete(), and onParserError().

bool proxygen::HTTP1xCodec::ingressUpgrade_

private

Definition at line 193 of file HTTP1xCodec.h.

Referenced by generateHeader(), isReusable(), onHeadersComplete(), and onMessageComplete().

bool proxygen::HTTP1xCodec::ingressUpgradeComplete_

private

Definition at line 194 of file HTTP1xCodec.h.

Referenced by onIngress(), onIngressEOF(), and onMessageComplete().

bool proxygen::HTTP1xCodec::inRecvLastChunk_

private

Definition at line 192 of file HTTP1xCodec.h.

Referenced by onBody(), onChunkComplete(), onChunkHeader(), onMessageComplete(), and onParserError().

bool proxygen::HTTP1xCodec::is1xxResponse_

private

Definition at line 191 of file HTTP1xCodec.h.

Referenced by generateHeader(), onHeadersComplete(), onMessageBegin(), and onMessageComplete().

bool proxygen::HTTP1xCodec::keepalive_

private

Definition at line 184 of file HTTP1xCodec.h.

Referenced by generateHeader(), isReusable(), and onHeadersComplete().

KeepaliveRequested proxygen::HTTP1xCodec::keepaliveRequested_

private

Definition at line 172 of file HTTP1xCodec.h.

Referenced by generateHeader(), and onHeadersComplete().

bool proxygen::HTTP1xCodec::lastChunkWritten_

private

Definition at line 183 of file HTTP1xCodec.h.

Referenced by generateEOM(), generateHeader(), and generateTrailers().

bool proxygen::HTTP1xCodec::mayChunkEgress_

private

Definition at line 190 of file HTTP1xCodec.h.

Referenced by generateHeader(), and onHeadersComplete().

std::unique_ptr<HTTPMessage> proxygen::HTTP1xCodec::msg_

private

Definition at line 158 of file HTTP1xCodec.h.

Referenced by onHeaderField(), onHeadersComplete(), onIngress(), onMessageBegin(), and onParserError().

bool proxygen::HTTP1xCodec::nativeUpgrade_

private

Definition at line 196 of file HTTP1xCodec.h.

Referenced by onHeadersComplete(), and onMessageComplete().

http_parser proxygen::HTTP1xCodec::parser_

private

Definition at line 156 of file HTTP1xCodec.h.

Referenced by generateHeader(), HTTP1xCodec(), onBodyCB(), onChunkCompleteCB(), onChunkHeaderCB(), onHeaderFieldCB(), onHeadersComplete(), onHeadersCompleteCB(), onHeaderValueCB(), onIngress(), onIngressEOF(), onMessageBeginCB(), onMessageCompleteCB(), onParserError(), onReasonCB(), onUrlCB(), and setParserPaused().

bool proxygen::HTTP1xCodec::parserActive_

private

Definition at line 175 of file HTTP1xCodec.h.

Referenced by onIngress(), and onIngressEOF().

bool proxygen::HTTP1xCodec::parserError_

private

Definition at line 178 of file HTTP1xCodec.h.

Referenced by isReusable(), onIngress(), onIngressEOF(), and setParserPaused().

bool proxygen::HTTP1xCodec::parserPaused_

private

Definition at line 177 of file HTTP1xCodec.h.

Referenced by setParserPaused().

bool proxygen::HTTP1xCodec::pendingEOF_

private

Definition at line 176 of file HTTP1xCodec.h.

Referenced by onIngress(), and onIngressEOF().

std::string proxygen::HTTP1xCodec::reason_

private

Definition at line 166 of file HTTP1xCodec.h.

Referenced by onHeadersComplete(), and onReason().

bool proxygen::HTTP1xCodec::requestPending_

private

Definition at line 179 of file HTTP1xCodec.h.

Referenced by generateEOM(), generateHeader(), isBusy(), onMessageBegin(), and onMessageComplete().

bool proxygen::HTTP1xCodec::responsePending_

private

Definition at line 180 of file HTTP1xCodec.h.

Referenced by generateEOM(), generateHeader(), isBusy(), onMessageBegin(), and onMessageComplete().

std::unique_ptr<HTTPHeaders> proxygen::HTTP1xCodec::trailers_

private

Definition at line 160 of file HTTP1xCodec.h.

Referenced by onHeaderField(), onMessageBegin(), and onMessageComplete().

TransportDirection proxygen::HTTP1xCodec::transportDirection_

private

Definition at line 171 of file HTTP1xCodec.h.

Referenced by createStream(), generateEOM(), generateHeader(), getTransportDirection(), onHeadersComplete(), onIngress(), onMessageBegin(), onMessageComplete(), onParserError(), and setAllowedUpgradeProtocols().

std::string proxygen::HTTP1xCodec::upgradeHeader_

private

Definition at line 167 of file HTTP1xCodec.h.

Referenced by generateHeader(), onHeadersComplete(), and serializeWebsocketHeader().

std::unique_ptr<HTTPMessage> proxygen::HTTP1xCodec::upgradeRequest_

private

Definition at line 159 of file HTTP1xCodec.h.

Referenced by onHeadersComplete(), and onMessageComplete().

std::pair<CodecProtocol, std::string> proxygen::HTTP1xCodec::upgradeResult_

private

Definition at line 173 of file HTTP1xCodec.h.

Referenced by onHeadersComplete(), and onMessageComplete().

std::string proxygen::HTTP1xCodec::url_

private

Definition at line 164 of file HTTP1xCodec.h.

Referenced by onHeadersComplete(), and onURL().

std::string proxygen::HTTP1xCodec::userAgent_

private

Definition at line 165 of file HTTP1xCodec.h.

Referenced by getUserAgent(), and onHeadersComplete().

std::string proxygen::HTTP1xCodec::websockAcceptKey_

mutableprivate

Definition at line 103 of file HTTP1xCodec.h.

Referenced by isReusable(), onHeadersComplete(), and serializeWebsocketHeader().

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

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

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation