proxygen::SPDYCodec Class Reference

#include <SPDYCodec.h>

Inheritance diagram for proxygen::SPDYCodec:

Classes
struct	SettingData

Public Types
using	SettingList = std::vector< SettingData >
Public Types inherited from proxygen::HTTPCodec
using	StreamID = uint64_t

Public Member Functions
	SPDYCodec (TransportDirection direction, SPDYVersion version, int spdyCompressionLevel=Z_NO_COMPRESSION)
	~SPDYCodec () override
CodecProtocol	getProtocol () const override
const std::string &	getUserAgent () const override
bool	supportsStreamFlowControl () const override
bool	supportsSessionFlowControl () const override
size_t	onIngress (const folly::IOBuf &buf) override
bool	supportsPushTransactions () const override
void	generateHeader (folly::IOBufQueue &writeBuf, StreamID stream, const HTTPMessage &msg, bool eom=false, HTTPHeaderSize *size=nullptr) override
void	generatePushPromise (folly::IOBufQueue &writeBuf, StreamID stream, const HTTPMessage &msg, StreamID assocstream, 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 txn, 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	generateWindowUpdate (folly::IOBufQueue &writeBuf, StreamID stream, uint32_t delta) override
const HTTPSettings *	getIngressSettings () const override
HTTPSettings *	getEgressSettings () override
uint32_t	getDefaultWindowSize () const override
uint8_t	getVersion () const
uint8_t	getMinorVersion () const
void	setMaxFrameLength (uint32_t maxFrameLength)
void	setMaxUncompressedHeaders (uint32_t maxUncompressed)
void	setHeaderCodecStats (HeaderCodec::Stats *stats) override
size_t	addPriorityNodes (PriorityQueue &queue, folly::IOBufQueue &writeBuf, uint8_t maxLevel) override
StreamID	mapPriorityToDependency (uint8_t priority) const override
int8_t	mapDependencyToPriority (StreamID parent) const override
Public Member Functions inherited from proxygen::HTTPParallelCodec
	HTTPParallelCodec (TransportDirection direction)
TransportDirection	getTransportDirection () const override
StreamID	createStream () override
bool	isBusy () 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 HPACKTableInfo	getHPACKTableInfo () const
virtual bool	supportsExTransactions () const
virtual size_t	generateConnectionPreface (folly::IOBufQueue &)
virtual void	generateExHeader (folly::IOBufQueue &, StreamID, const HTTPMessage &, const HTTPCodec::ExAttributes &, bool, HTTPHeaderSize *)
virtual size_t	generateSettingsAck (folly::IOBufQueue &)
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 >)

Static Public Member Functions
static const SPDYVersionSettings &	getVersionSettings (SPDYVersion version)
static folly::Optional< SPDYVersion >	getVersion (const std::string &protocol)

Static Public Attributes
static const StreamID	NoStream = 0
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

Private Types
enum	FrameState { FRAME_HEADER = 0, CTRL_FRAME_DATA = 1, DATA_FRAME_DATA = 2 }

Private Member Functions
void	generateSynStream (StreamID stream, StreamID assocStream, folly::IOBufQueue &writeBuf, const HTTPMessage &msg, bool eom, HTTPHeaderSize *size)
void	generateSynReply (StreamID stream, folly::IOBufQueue &writeBuf, const HTTPMessage &msg, bool eom, HTTPHeaderSize *size)
size_t	generatePingCommon (folly::IOBufQueue &writeBuf, uint64_t uniqueID)
size_t	parseIngress (const folly::IOBuf &buf)
void	onSynStream (uint32_t assocStream, uint8_t pri, uint8_t slot, const compress::HeaderPieceList &headers, const HTTPHeaderSize &size)
void	onSynReply (const compress::HeaderPieceList &headers, const HTTPHeaderSize &size)
void	onRstStream (uint32_t statusCode) noexcept
void	onSettings (const SettingList &settings)
void	onPing (uint32_t uniqueID) noexcept
void	onGoaway (uint32_t lastGoodStream, uint32_t statusCode) noexcept
void	onHeaders (const compress::HeaderPieceList &headers) noexcept
void	onWindowUpdate (uint32_t delta) noexcept
std::unique_ptr< HTTPMessage >	parseHeaders (TransportDirection direction, StreamID streamID, StreamID assocStreamID, const compress::HeaderPieceList &headers)
void	onControlFrame (folly::io::Cursor &cursor)
void	onSynCommon (StreamID streamID, StreamID assocStreamID, const compress::HeaderPieceList &headers, int8_t pri, const HTTPHeaderSize &size)
void	deliverOnMessageBegin (StreamID streamID, StreamID assocStreamID, HTTPMessage *msg)
size_t	generateDataFrame (folly::IOBufQueue &writeBuf, uint32_t streamID, uint8_t flags, uint32_t length, std::unique_ptr< folly::IOBuf > payload)
std::unique_ptr< folly::IOBuf >	serializeRequestHeaders (const HTTPMessage &msg, bool isPushed, uint32_t headroom=0, HTTPHeaderSize *size=nullptr)
std::unique_ptr< folly::IOBuf >	serializeResponseHeaders (const HTTPMessage &msg, uint32_t headroom=0, HTTPHeaderSize *size=nullptr)
std::unique_ptr< folly::IOBuf >	encodeHeaders (const HTTPMessage &msg, std::vector< compress::Header > &headers, uint32_t headroom=0, HTTPHeaderSize *size=nullptr)
void	failStream (bool newTxn, StreamID streamID, uint32_t code, std::string excStr=empty_string)
void	failSession (uint32_t statusCode)
HeaderDecodeResult	decodeHeaders (folly::io::Cursor &cursor)
void	checkLength (uint32_t expectedLength, const std::string &msg)
void	checkMinLength (uint32_t minLength, const std::string &msg)
bool	isSPDYReserved (const std::string &name)
bool	rstStatusSupported (int statusCode) const

Private Attributes
folly::fbvector< StreamID >	closedStreams_
const SPDYVersionSettings &	versionSettings_
HTTPSettings	ingressSettings_
HTTPSettings	egressSettings_
std::unique_ptr< HTTPMessage >	partialMsg_
std::string	userAgent_
const folly::IOBuf *	currentIngressBuf_ {nullptr}
StreamID	nextEgressPingID_
uint32_t	maxFrameLength_ {spdy::kMaxFrameLength}
uint32_t	streamId_ {0}
uint32_t	length_ {0}
uint16_t	version_ {0}
uint16_t	type_ {0xffff}
uint8_t	flags_ {0}
enum proxygen::SPDYCodec::FrameState	frameState_
bool	ctrl_:1
GzipHeaderCodec	headerCodec_

Additional Inherited Members
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 all versions of SPDY. Instances of this class must not be used from multiple threads concurrently.

Definition at line 36 of file SPDYCodec.h.

Member Typedef Documentation

using proxygen::SPDYCodec::SettingList = std::vector<SettingData>

Definition at line 153 of file SPDYCodec.h.

Member Enumeration Documentation

enum proxygen::SPDYCodec::FrameState

private

Enumerator
FRAME_HEADER
CTRL_FRAME_DATA
DATA_FRAME_DATA

Definition at line 369 of file SPDYCodec.h.

                  {
    FRAME_HEADER = 0,
    CTRL_FRAME_DATA = 1,
    DATA_FRAME_DATA = 2,
  } frameState_:2;

Constructor & Destructor Documentation

proxygen::SPDYCodec::SPDYCodec ( TransportDirection  direction, SPDYVersion  version, int  spdyCompressionLevel = Z_NO_COMPRESSION  )

explicit

Definition at line 170 of file SPDYCodec.cpp.

References headerCodec_, proxygen::SPDYVersionSettings::majorVersion, proxygen::SPDYVersionSettings::minorVersion, nextEgressPingID_, proxygen::HTTPParallelCodec::nextEgressStreamID_, proxygen::HeaderCodec::setMaxUncompressed(), and versionSettings_.

  : HTTPParallelCodec(direction),
    versionSettings_(getVersionSettings(version)),
    frameState_(FrameState::FRAME_HEADER),
    ctrl_(false),
    headerCodec_(spdyCompressionLevel, versionSettings_) {
  VLOG(4) << "creating SPDY/" << static_cast<int>(versionSettings_.majorVersion)
          << "." << static_cast<int>(versionSettings_.minorVersion)
          << " codec";

  // Limit uncompressed headers to 128kb
  headerCodec_.setMaxUncompressed(kMaxUncompressed);
  nextEgressPingID_ = nextEgressStreamID_;
}

proxygen::SPDYCodec::~SPDYCodec ( )

override

Definition at line 186 of file SPDYCodec.cpp.

                      {
}

Member Function Documentation

size_t proxygen::SPDYCodec::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 1010 of file SPDYCodec.cpp.

References proxygen::HTTPCodec::PriorityQueue::addPriorityNode(), proxygen::HTTPCodec::MAX_STREAM_ID, parent, and uint8_t.

             {
  HTTPCodec::StreamID parent = 0;
  // For SPDY, we always create 8 virtual nodes regardless of maxLevel
  for (uint8_t pri = 0; pri < 8; pri++) {
    queue.addPriorityNode(HTTPCodec::MAX_STREAM_ID + pri, parent);
    parent = HTTPCodec::MAX_STREAM_ID + pri;
  }
  return 0;
}

void proxygen::SPDYCodec::checkLength ( uint32_t  expectedLength, const std::string &  msg  )

private

Definition at line 219 of file SPDYCodec.cpp.

References proxygen::ERROR, proxygen::spdy::GOAWAY_PROTOCOL_ERROR, and length_.

Referenced by onControlFrame().

                                                                         {
  if (length_ != expectedLength) {
    LOG_IF(ERROR, length_ == 4 && msg != "GOAWAY")
      << msg << ": invalid length " << length_ << " != " << expectedLength;
    throw SPDYSessionFailed(spdy::GOAWAY_PROTOCOL_ERROR);
  }
}

void proxygen::SPDYCodec::checkMinLength ( uint32_t  minLength, const std::string &  msg  )

private

Definition at line 227 of file SPDYCodec.cpp.

References proxygen::ERROR, proxygen::spdy::GOAWAY_PROTOCOL_ERROR, and length_.

Referenced by onControlFrame().

                                                                       {
  if (length_ < minLength) {
    LOG(ERROR) << msg << ": invalid length " << length_ << " < " << minLength;
    throw SPDYSessionFailed(spdy::GOAWAY_PROTOCOL_ERROR);
  }
}

HeaderDecodeResult proxygen::SPDYCodec::decodeHeaders ( folly::io::Cursor &  cursor )

private

Decodes the headers from the cursor and returns the result.

Definition at line 466 of file SPDYCodec.cpp.

References proxygen::BAD_ENCODING, proxygen::GzipHeaderCodec::decode(), failStream(), proxygen::spdy::GOAWAY_PROTOCOL_ERROR, headerCodec_, proxygen::spdy::HEADERS, proxygen::HEADERS_TOO_LARGE, proxygen::INFLATE_DICTIONARY, length_, proxygen::spdy::RST_FRAME_TOO_LARGE, proxygen::spdy::RST_PROTOCOL_ERROR, streamId_, and type_.

Referenced by onControlFrame().

                                                          {
  auto result = headerCodec_.decode(cursor, length_);
  if (result.hasError()) {
    auto err = result.error();
    if (err == GzipDecodeError::HEADERS_TOO_LARGE ||
        err == GzipDecodeError::INFLATE_DICTIONARY ||
        err == GzipDecodeError::BAD_ENCODING) {
      // Fail stream only for FRAME_TOO_LARGE error
      if (err == GzipDecodeError::HEADERS_TOO_LARGE) {
        failStream(true, streamId_, spdy::RST_FRAME_TOO_LARGE);
      }
      throw SPDYSessionFailed(spdy::GOAWAY_PROTOCOL_ERROR);
    }
    // For other types of errors we throw a stream error
    bool newStream = (type_ != spdy::HEADERS);
    throw SPDYStreamFailed(newStream, streamId_, spdy::RST_PROTOCOL_ERROR,
                           "Error parsing header: " + folly::to<string>(err));
  }

  length_ -= result->bytesConsumed;
  return *result;
}

void proxygen::SPDYCodec::deliverOnMessageBegin ( StreamID  streamID, StreamID  assocStreamID, HTTPMessage *  msg  )

private

Definition at line 1271 of file SPDYCodec.cpp.

References proxygen::HTTPParallelCodec::deliverCallbackIfAllowed(), proxygen::HTTPCodec::Callback::onMessageBegin(), and proxygen::HTTPCodec::Callback::onPushMessageBegin().

Referenced by onSynCommon(), and parseHeaders().

                                                        {
  if (assocStreamID) {
    deliverCallbackIfAllowed(&HTTPCodec::Callback::onPushMessageBegin,
                             "onPushMessageBegin", streamID, assocStreamID,
                             msg);
  } else {
    deliverCallbackIfAllowed(&HTTPCodec::Callback::onMessageBegin,
                             "onMessageBegin", streamID, msg);
  }
}

unique_ptr< IOBuf > proxygen::SPDYCodec::encodeHeaders ( const HTTPMessage &  msg, std::vector< compress::Header > &  headers, uint32_t  headroom = 0, HTTPHeaderSize *  size = nullptr  )

private

Helper function to create the compressed Name/Value representation of a message's headers.

Parameters

msg	The message containing headers to serialize.
headers	A vector containing any extra headers to serialize
size	Size of the serialized headers before and after compression
headroom	Optional amount of headroom to reserve at the front of the returned IOBuf, in case the caller wants to put some other data there.

Definition at line 503 of file SPDYCodec.cpp.

References proxygen::GzipHeaderCodec::encode(), proxygen::HTTPHeaders::forEachWithCode(), proxygen::HeaderCodec::getEncodedSize(), proxygen::HTTPMessage::getHeaders(), headerCodec_, proxygen::HTTP_HEADER_CONNECTION, proxygen::HTTP_HEADER_HOST, proxygen::HTTP_HEADER_KEEP_ALIVE, proxygen::HTTP_HEADER_OTHER, proxygen::HTTP_HEADER_PROXY_CONNECTION, proxygen::HTTP_HEADER_TRANSFER_ENCODING, proxygen::HTTP_HEADER_UPGRADE, proxygen::spdy::httpVersion, isSPDYReserved(), proxygen::SPDYVersionSettings::majorVersion, name, proxygen::HeaderCodec::setEncodeHeadroom(), value, versionSettings_, and proxygen::SPDYVersionSettings::versionStr.

Referenced by serializeRequestHeaders(), and serializeResponseHeaders().

                                           {

  // We explicitly provide both the code and header name here
  // as HTTP_HEADER_OTHER does not map to kNameVersionv3 and we don't want a
  // perf penalty hash kNameVersionv3 to HTTP_HEADER_OTHER
  allHeaders.emplace_back(
    HTTP_HEADER_OTHER, versionSettings_.versionStr, spdy::httpVersion);

  // Add the HTTP headers supplied by the caller, but skip
  // any per-hop headers that aren't supported in SPDY.
  msg.getHeaders().forEachWithCode([&] (HTTPHeaderCode code,
                                        const string& name,
                                        const string& value) {
    static const std::bitset<256> s_perHopHeaderCodes{
      [] {
        std::bitset<256> bs;
        // SPDY per-hop headers
        bs[HTTP_HEADER_CONNECTION] = true;
        bs[HTTP_HEADER_HOST] = true;
        bs[HTTP_HEADER_KEEP_ALIVE] = true;
        bs[HTTP_HEADER_PROXY_CONNECTION] = true;
        bs[HTTP_HEADER_TRANSFER_ENCODING] = true;
        bs[HTTP_HEADER_UPGRADE] = true;
        return bs;
      }()
    };

    if (s_perHopHeaderCodes[code] || isSPDYReserved(name)) {
      VLOG(3) << "Dropping SPDY reserved header " << name;
      return;
    }
    if (name.length() == 0) {
      VLOG(2) << "Dropping header with empty name";
      return;
    }
    if (versionSettings_.majorVersion == 2 && value.length() == 0) {
      VLOG(2) << "Dropping header \"" << name
              << "\" with empty value for spdy/2";
      return;
    }
    allHeaders.emplace_back(code, name, value);
  });

  headerCodec_.setEncodeHeadroom(headroom);
  auto out = headerCodec_.encode(allHeaders);
  if (size) {
    *size = headerCodec_.getEncodedSize();
  }

  return out;
}

void proxygen::SPDYCodec::failSession ( uint32_t  statusCode )

private

Definition at line 1474 of file SPDYCodec.cpp.

References proxygen::HTTPParallelCodec::callback_, folly::IOBuf::clone(), currentIngressBuf_, proxygen::spdy::goawayToErrorCode(), proxygen::HTTPException::INGRESS_AND_EGRESS, proxygen::kErrorParseHeader, proxygen::HTTPParallelCodec::lastStreamID_, proxygen::HTTPCodec::Callback::onError(), proxygen::HTTPException::setCodecStatusCode(), proxygen::HTTPException::setCurrentIngressBuf(), and proxygen::Exception::setProxygenError().

Referenced by onIngress().

                                         {
  HTTPException err(
    HTTPException::Direction::INGRESS_AND_EGRESS,
    folly::to<std::string>("SPDYCodec session error: "
      "lastGoodStream=", lastStreamID_, " status=", code));
  err.setCodecStatusCode(spdy::goawayToErrorCode(spdy::GoawayStatusCode(code)));
  err.setProxygenError(kErrorParseHeader);

  // store the ingress buffer
  if (currentIngressBuf_) {
    err.setCurrentIngressBuf(currentIngressBuf_->clone());
  }
  callback_->onError(0, err);
}

void proxygen::SPDYCodec::failStream ( bool  newTxn, StreamID  streamID, uint32_t  code, std::string  excStr = empty_string  )

private

Definition at line 1444 of file SPDYCodec.cpp.

References proxygen::HTTPParallelCodec::callback_, folly::IOBuf::clone(), proxygen::spdy::CTRL_FLAG_FIN, currentIngressBuf_, flags_, proxygen::HTTPException::INGRESS, proxygen::HTTPException::INGRESS_AND_EGRESS, proxygen::kErrorParseHeader, folly::gen::move, proxygen::HTTPCodec::Callback::onError(), partialMsg_, proxygen::spdy::rstToErrorCode(), proxygen::HTTPException::setCodecStatusCode(), proxygen::HTTPException::setCurrentIngressBuf(), proxygen::HTTPException::setHttpStatusCode(), proxygen::HTTPException::setPartialMsg(), proxygen::Exception::setProxygenError(), and streamId_.

Referenced by decodeHeaders(), and parseIngress().

                                                         {
  // Suppress any EOM callback for the current frame.
  if (streamID == streamId_) {
    flags_ &= ~spdy::CTRL_FLAG_FIN;
  }

  HTTPException err(
    code >= 100 ?
    HTTPException::Direction::INGRESS :
    HTTPException::Direction::INGRESS_AND_EGRESS,
    folly::to<std::string>("SPDYCodec stream error: stream=",
      streamID, " status=", code, " exception: ", excStr));
  if (code >= 100) {
    err.setHttpStatusCode(code);
  } else {
    err.setCodecStatusCode(spdy::rstToErrorCode(spdy::ResetStatusCode(code)));
  }
  err.setProxygenError(kErrorParseHeader);

  if (partialMsg_) {
    err.setPartialMsg(std::move(partialMsg_));
  }
  // store the ingress buffer
  if (currentIngressBuf_) {
    err.setCurrentIngressBuf(currentIngressBuf_->clone());
  }
  callback_->onError(streamID, err, newStream);
}

size_t proxygen::SPDYCodec::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 765 of file SPDYCodec.cpp.

References folly::IOBuf::computeChainDataLength(), generateDataFrame(), proxygen::HTTPParallelCodec::ingressGoawayAck_, proxygen::HTTPParallelCodec::isStreamIngressEgressAllowed(), folly::gen::move, uint32_t, and uint8_t.

Referenced by TEST_F().

                                         {
  if (!isStreamIngressEgressAllowed(stream)) {
    VLOG(2) << "Suppressing DATA for stream=" << stream <<
      " ingressGoawayAck_=" << ingressGoawayAck_;
    return 0;
  }
  size_t len = chain->computeChainDataLength();
  if (len == 0) {
    return len;
  }

  // TODO if the data length is 2^24 or greater, split it into
  // multiple data frames.  Proxygen should never be writing that
  // much data at once, but other apps that use this codec might.
  CHECK_LT(len, (1 << 24));

  uint8_t flags = (eom) ? kFlagFin : 0;
  generateDataFrame(writeBuf, uint32_t(stream), flags, len, std::move(chain));
  return len;
}

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

overridevirtual

Write a body chunk header, if relevant.

Implements proxygen::HTTPCodec.

Definition at line 790 of file SPDYCodec.cpp.

                                                {
  // SPDY chunk headers are built into the data frames
  return 0;
}

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

overridevirtual

Write a body chunk terminator, if relevant.

Implements proxygen::HTTPCodec.

Definition at line 797 of file SPDYCodec.cpp.

                                                      {
  // SPDY has no chunk terminator
  return 0;
}

size_t proxygen::SPDYCodec::generateDataFrame ( folly::IOBufQueue &  writeBuf, uint32_t  streamID, uint8_t  flags, uint32_t  length, std::unique_ptr< folly::IOBuf >  payload  )

private

Generate the header for a SPDY data frame

Parameters

writeBuf	Buffer queue to which the control frame is written.
streamID	Stream ID.
flags	Bitmap of flags, as defined in the SPDY spec.
length	Length of the data, in bytes.

Returns

length Length of the encoded bytes

payload data payload

Definition at line 1031 of file SPDYCodec.cpp.

References folly::IOBufQueue::append(), folly::IOBuf::headroom(), folly::IOBuf::isSharedOne(), folly::IOBuf::length(), folly::gen::move, folly::IOBuf::pop(), folly::IOBufQueue::postallocate(), folly::IOBuf::retreat(), folly::IOBufQueue::tailroom(), folly::IOBuf::trimEnd(), uint32_t, uint64_t, and folly::io::detail::Writable< Derived >::writeBE().

Referenced by generateBody(), and generateEOM().

                                                               {
  const size_t frameSize = kFrameSizeDataCommon;
  uint64_t payloadLength = 0;
  if (payload && !payload->isSharedOne() &&
      payload->headroom() >= frameSize &&
      writeBuf.tailroom() < frameSize) {
    // Use the headroom in payload for the frame header.
    // Make it appear that the payload IOBuf is empty and retreat so
    // appender can access the headroom
    payloadLength = payload->length();
    payload->trimEnd(payloadLength);
    payload->retreat(frameSize);
    auto tail = payload->pop();
    writeBuf.append(std::move(payload));
    payload = std::move(tail);
  }
  QueueAppender cursor(&writeBuf, frameSize);
  cursor.writeBE(uint32_t(streamID));
  cursor.writeBE(flagsAndLength(flags, length));
  writeBuf.postallocate(payloadLength);
  writeBuf.append(std::move(payload));
  return kFrameSizeDataCommon + length;
}

size_t proxygen::SPDYCodec::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 812 of file SPDYCodec.cpp.

References generateDataFrame(), proxygen::HTTPParallelCodec::ingressGoawayAck_, proxygen::HTTPParallelCodec::isStreamIngressEgressAllowed(), stream, and uint32_t.

Referenced by TEST().

                                               {
  VLOG(4) << "sending EOM for stream=" << stream;
  if (!isStreamIngressEgressAllowed(stream)) {
    VLOG(2) << "Suppressing EOM for stream=" << stream <<
      " ingressGoawayAck_=" << ingressGoawayAck_;
    return 0;
  }
  generateDataFrame(writeBuf, uint32_t(stream), kFlagFin, 0, nullptr);
  return 8; // size of data frame header
}

size_t proxygen::SPDYCodec::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 856 of file SPDYCodec.cpp.

References folly::IOBufQueue::chainLength(), proxygen::SPDYVersionSettings::controlVersion, folly::IOBuf::data(), proxygen::HTTPParallelCodec::egressGoawayAck_, proxygen::spdy::errorCodeToGoaway(), proxygen::getErrorCodeString(), proxygen::spdy::GOAWAY, proxygen::SPDYVersionSettings::goawaySize, proxygen::SPDYVersionSettings::majorVersion, max, proxygen::NO_ERROR, proxygen::HTTPParallelCodec::sessionClosing_, statusCode, uint16_t, uint32_t, versionSettings_, and folly::io::detail::Writable< Derived >::writeBE().

Referenced by TEST(), and TEST_F().

                                                                      {
  const uint32_t statusCode = (uint32_t) spdy::errorCodeToGoaway(code);
  const size_t frameSize = kFrameSizeControlCommon +
    (size_t)versionSettings_.goawaySize;

  DCHECK_LE(lastStream, egressGoawayAck_) << "Cannot increase last good stream";
  egressGoawayAck_ = lastStream;
  if (sessionClosing_ == ClosingState::CLOSING) {
    VLOG(4) << "Not sending GOAWAY for closed session";
    return 0;
  }
  const size_t expectedLength = writeBuf.chainLength() + frameSize;
  QueueAppender appender(&writeBuf, frameSize);
  appender.writeBE(versionSettings_.controlVersion);

  if (code != ErrorCode::NO_ERROR) {
    sessionClosing_ = ClosingState::CLOSING;
  }

  string debugInfo = (debugData) ?
    folly::to<string>(" with debug info=",
                      (char*)debugData->data()) : "";
  VLOG(4) << "Sending GOAWAY with last acknowledged stream="
          << lastStream << " with code=" << getErrorCodeString(code)
          << debugInfo;

  appender.writeBE(uint16_t(spdy::GOAWAY));
  appender.writeBE(flagsAndLength(0, versionSettings_.goawaySize));
  appender.writeBE(uint32_t(lastStream));
  if (versionSettings_.majorVersion == 3) {
    appender.writeBE(statusCode);
  }
  switch (sessionClosing_) {
    case ClosingState::OPEN:
      sessionClosing_ = ClosingState::CLOSING;
      break;
    case ClosingState::OPEN_WITH_GRACEFUL_DRAIN_ENABLED:
      if (lastStream == std::numeric_limits<int32_t>::max()) {
        sessionClosing_ = ClosingState::FIRST_GOAWAY_SENT;
      } else {
        // The user of this codec decided not to do the double goaway
        // drain
        sessionClosing_ = ClosingState::CLOSING;
      }
      break;
    case ClosingState::FIRST_GOAWAY_SENT:
      sessionClosing_ = ClosingState::CLOSING;
      break;
    case ClosingState::CLOSING:
      break;
    case ClosingState::CLOSED:
      LOG(FATAL) << "unreachable";
      break;
  }
  DCHECK_EQ(writeBuf.chainLength(), expectedLength);
  return frameSize;
}

void proxygen::SPDYCodec::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 625 of file SPDYCodec.cpp.

References wangle::HTTPHeaderSize::compressed, generateSynReply(), generateSynStream(), proxygen::HTTPParallelCodec::ingressGoawayAck_, proxygen::HTTPParallelCodec::isStreamIngressEgressAllowed(), proxygen::HTTPParallelCodec::transportDirection_, wangle::HTTPHeaderSize::uncompressed, and proxygen::UPSTREAM.

Referenced by TEST_F().

                                                     {
  if (!isStreamIngressEgressAllowed(stream)) {
    VLOG(2) << "Suppressing SYN_STREAM/REPLY for stream=" << stream <<
      " ingressGoawayAck_=" << ingressGoawayAck_;
    if (size) {
      size->compressed = 0;
      size->uncompressed = 0;
    }
    return;
  }
  if (transportDirection_ == TransportDirection::UPSTREAM) {
    generateSynStream(stream, 0, writeBuf, msg, eom, size);
  } else {
    generateSynReply(stream, writeBuf, msg, eom, size);
  }
}

size_t proxygen::SPDYCodec::generatePingCommon ( folly::IOBufQueue &  writeBuf, uint64_t  uniqueID  )

private

Generates the shared parts of a ping request and reply.

Definition at line 929 of file SPDYCodec.cpp.

References folly::IOBufQueue::chainLength(), proxygen::SPDYVersionSettings::controlVersion, proxygen::spdy::PING, uint16_t, uint32_t, versionSettings_, and folly::io::detail::Writable< Derived >::writeBE().

Referenced by generatePingReply(), and generatePingRequest().

                                                                            {
  const size_t frameSize = kFrameSizeControlCommon + kFrameSizePing;
  const size_t expectedLength = writeBuf.chainLength() + frameSize;
  QueueAppender appender(&writeBuf, frameSize);
  appender.writeBE(versionSettings_.controlVersion);
  appender.writeBE(uint16_t(spdy::PING));
  appender.writeBE(flagsAndLength(0, kFrameSizePing));
  appender.writeBE(uint32_t(uniqueID));
  DCHECK_EQ(writeBuf.chainLength(), expectedLength);
  return frameSize;
}

size_t proxygen::SPDYCodec::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 924 of file SPDYCodec.cpp.

References generatePingCommon().

Referenced by TEST().

                                                                           {
  VLOG(4) << "Generating ping reply with id=" << uniqueID;
  return generatePingCommon(writeBuf, uniqueID);
}

size_t proxygen::SPDYCodec::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 917 of file SPDYCodec.cpp.

References generatePingCommon(), and nextEgressPingID_.

Referenced by TEST().

                                                          {
  const auto id = nextEgressPingID_;
  nextEgressPingID_ += 2;
  VLOG(4) << "Generating ping request with id=" << id;
  return generatePingCommon(writeBuf, id);
}

void proxygen::SPDYCodec::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 646 of file SPDYCodec.cpp.

References wangle::HTTPHeaderSize::compressed, generateSynStream(), proxygen::HTTPParallelCodec::ingressGoawayAck_, proxygen::HTTPParallelCodec::isStreamIngressEgressAllowed(), NoStream, and wangle::HTTPHeaderSize::uncompressed.

Referenced by TEST_F().

                                                          {
  DCHECK(assocStream != NoStream);
  if (!isStreamIngressEgressAllowed(stream)) {
    VLOG(2) << "Suppressing SYN_STREAM/REPLY for stream=" << stream <<
      " ingressGoawayAck_=" << ingressGoawayAck_;
    if (size) {
      size->compressed = 0;
      size->uncompressed = 0;
    }
    return;
  }
  generateSynStream(stream, assocStream, writeBuf, msg, eom, size);
}

size_t proxygen::SPDYCodec::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 824 of file SPDYCodec.cpp.

References folly::IOBufQueue::chainLength(), proxygen::SPDYVersionSettings::controlVersion, proxygen::spdy::CTRL_FLAG_FIN, proxygen::spdy::errorCodeToReset(), flags_, proxygen::getErrorCodeString(), proxygen::HTTPParallelCodec::ingressGoawayAck_, proxygen::HTTPParallelCodec::isStreamIngressEgressAllowed(), proxygen::spdy::RST_PROTOCOL_ERROR, proxygen::spdy::RST_STREAM, rstStatusSupported(), statusCode, streamId_, uint16_t, uint32_t, versionSettings_, and folly::io::detail::Writable< Derived >::writeBE().

Referenced by TEST().

                                                    {
  DCHECK_GT(stream, 0);
  VLOG(4) << "sending RST_STREAM for stream=" << stream
          << " with code=" << getErrorCodeString(code);

  // Suppress any EOM callback for the current frame.
  if (stream == streamId_) {
    flags_ &= ~spdy::CTRL_FLAG_FIN;
  }

  if (!isStreamIngressEgressAllowed(stream)) {
    VLOG(2) << "Suppressing RST_STREAM for stream=" << stream <<
      " ingressGoawayAck_=" << ingressGoawayAck_;
    return 0;
  }

  const uint32_t statusCode = (uint32_t) spdy::errorCodeToReset(code);
  const size_t frameSize = kFrameSizeControlCommon + kFrameSizeRstStream;
  const size_t expectedLength = writeBuf.chainLength() + frameSize;
  QueueAppender appender(&writeBuf, frameSize);
  appender.writeBE(versionSettings_.controlVersion);
  appender.writeBE(uint16_t(spdy::RST_STREAM));
  appender.writeBE(flagsAndLength(0, kFrameSizeRstStream));
  appender.writeBE(uint32_t(stream));
  appender.writeBE(rstStatusSupported(statusCode) ?
                   statusCode : (uint32_t)spdy::RST_PROTOCOL_ERROR);
  DCHECK_EQ(writeBuf.chainLength(), expectedLength);
  return frameSize;
}

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

overridevirtual

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

Reimplemented from proxygen::HTTPCodec.

Definition at line 941 of file SPDYCodec.cpp.

References folly::IOBufQueue::chainLength(), proxygen::SPDYVersionSettings::controlVersion, egressSettings_, proxygen::spdy::FLAG_SETTINGS_CLEAR_SETTINGS, proxygen::HTTPSettings::getAllSettings(), proxygen::HTTPSettings::getNumSettings(), proxygen::spdy::httpToSpdySettingsId(), proxygen::SPDYVersionSettings::majorVersion, proxygen::spdy::SETTINGS, uint16_t, uint32_t, versionSettings_, folly::io::detail::Writable< Derived >::writeBE(), and folly::io::detail::Writable< Derived >::writeLE().

Referenced by TEST().

                                                            {
  auto numSettings = egressSettings_.getNumSettings();
  for (const auto& setting: egressSettings_.getAllSettings()) {
    if (!spdy::httpToSpdySettingsId(setting.id)) {
      numSettings--;
    }
  }
  VLOG(4) << "generating " << (unsigned)numSettings << " settings";
  const size_t frameSize = kFrameSizeControlCommon + kFrameSizeSettings +
    (kFrameSizeSettingsEntry * numSettings);
  const size_t expectedLength = writeBuf.chainLength() + frameSize;
  QueueAppender appender(&writeBuf, frameSize);
  appender.writeBE(versionSettings_.controlVersion);
  appender.writeBE(uint16_t(spdy::SETTINGS));
  appender.writeBE(flagsAndLength(spdy::FLAG_SETTINGS_CLEAR_SETTINGS,
                                  kFrameSizeSettings +
                                  kFrameSizeSettingsEntry * numSettings));
  appender.writeBE(uint32_t(numSettings));
  for (const auto& setting: egressSettings_.getAllSettings()) {
    auto settingId = spdy::httpToSpdySettingsId(setting.id);
    if (!settingId) {
      LOG(WARNING) << "Invalid SpdySetting " << (uint32_t)setting.id;
      continue;
    }
    VLOG(5) << " writing setting with id=" << *settingId
            << ", value=" << setting.value;
    if (versionSettings_.majorVersion == 2) {
      // ID: 24-bits in little-endian byte order.
      // This is inconsistent with other values in SPDY and
      // is the result of a bug in the initial v2 implementation.
      appender.writeLE(flagsAndLength(0, *settingId));
    } else {
      appender.writeBE(flagsAndLength(0, *settingId));
    }
    appender.writeBE<uint32_t>(setting.value);
  }
  DCHECK_EQ(writeBuf.chainLength(), expectedLength);
  return frameSize;
}

void proxygen::SPDYCodec::generateSynReply ( StreamID  stream, folly::IOBufQueue &  writeBuf, const HTTPMessage &  msg, bool  eom, HTTPHeaderSize *  size  )

private

Generates a frame of type SYN_REPLY

Definition at line 724 of file SPDYCodec.cpp.

References folly::IOBufQueue::append(), folly::IOBuf::computeChainDataLength(), proxygen::SPDYVersionSettings::controlVersion, proxygen::spdy::CTRL_FLAG_FIN, proxygen::spdy::CTRL_FLAG_NONE, proxygen::SPDYVersionSettings::majorVersion, folly::gen::move, folly::IOBuf::prepend(), serializeResponseHeaders(), proxygen::spdy::SYN_REPLY, proxygen::SPDYVersionSettings::synReplySize, uint16_t, uint32_t, uint8_t, and versionSettings_.

Referenced by generateHeader().

                                                       {
  // Serialize the compressed representation of the headers
  // first because we need to write its length.  The
  // serializeResponseHeaders() method allocates an IOBuf to
  // hold the headers, but we can tell it to reserve
  // enough headroom at the start of the IOBuf to hold
  // the metadata we'll need to add once we know the
  // length.
  uint32_t headroom = kFrameSizeControlCommon + versionSettings_.synReplySize;
  unique_ptr<IOBuf> out(serializeResponseHeaders(msg, headroom, size));

  // The length field in the SYN_REPLY header holds the number
  // of bytes that follow it.  That's the length of the fields
  // specific to the SYN_REPLY message (all of which come after
  // the length field) plus the length of the serialized header
  // name/value block.
  uint32_t len = versionSettings_.synReplySize + out->computeChainDataLength();

  // Generate a control frame header of type SYN_REPLY within
  // the headroom that we serializeResponseHeaders() reserved for us
  // at the start of the IOBuf.1
  uint8_t flags = eom ? spdy::CTRL_FLAG_FIN : spdy::CTRL_FLAG_NONE;
  out->prepend(headroom);
  RWPrivateCursor cursor(out.get());
  cursor.writeBE(versionSettings_.controlVersion);
  cursor.writeBE(uint16_t(spdy::SYN_REPLY));
  cursor.writeBE(flagsAndLength(flags, len));
  cursor.writeBE(uint32_t(stream)); // TODO: stream should never be bigger than 2^31
  if (versionSettings_.majorVersion == 2) {
    cursor.writeBE(uint16_t(0));
  }

  // Now that we have a complete SYN_REPLY control frame, append
  // it to the writeBuf.
  writeBuf.append(std::move(out));
}

void proxygen::SPDYCodec::generateSynStream ( StreamID  stream, StreamID  assocStream, folly::IOBufQueue &  writeBuf, const HTTPMessage &  msg, bool  eom, HTTPHeaderSize *  size  )

private

Generates a frame of type SYN_STREAM

Definition at line 665 of file SPDYCodec.cpp.

References folly::IOBufQueue::append(), folly::IOBuf::computeChainDataLength(), proxygen::SPDYVersionSettings::controlVersion, proxygen::spdy::CTRL_FLAG_FIN, proxygen::spdy::CTRL_FLAG_NONE, proxygen::spdy::CTRL_FLAG_UNIDIRECTIONAL, proxygen::HTTPMessage::getPriority(), proxygen::SPDYVersionSettings::majorVersion, folly::gen::move, NoStream, folly::IOBuf::prepend(), proxygen::SPDYVersionSettings::priShift, serializeRequestHeaders(), proxygen::spdy::SYN_STREAM, uint16_t, uint32_t, uint8_t, and versionSettings_.

Referenced by generateHeader(), and generatePushPromise().

                                                        {
  // Pushed streams must have an even streamId and an odd assocStream
  CHECK((assocStream == NoStream && (stream % 2 == 1)) ||
        ((stream % 2 == 0) && (assocStream % 2 == 1))) <<
    "Invalid stream ids stream=" << stream << " assocStream=" << assocStream;

  // Serialize the compressed representation of the headers
  // first because we need to write its length.  The
  // serializeRequestHeaders() method allocates an IOBuf to
  // hold the headers, but we can tell it to reserve
  // enough headroom at the start of the IOBuf to hold
  // the metadata we'll need to add once we know the
  // length.
  uint32_t fieldsSize = kFrameSizeSynStream;
  uint32_t headroom = kFrameSizeControlCommon + fieldsSize;
  bool isPushed = (assocStream != NoStream);
  unique_ptr<IOBuf> out(serializeRequestHeaders(msg, isPushed,
                                                headroom, size));

  // The length field in the SYN_STREAM header holds the number
  // of bytes that follow it.  That's the length of the fields
  // specific to the SYN_STREAM message (all of which come after
  // the length field) plus the length of the serialized header
  // name/value block.
  uint32_t len = fieldsSize + out->computeChainDataLength();

  // Generate a control frame header of type SYN_STREAM within
  // the headroom that serializeRequestHeaders() reserved for us
  // at the start of the IOBuf.
  uint8_t flags = spdy::CTRL_FLAG_NONE;
  if (assocStream != NoStream) {
    flags |= spdy::CTRL_FLAG_UNIDIRECTIONAL;
  }
  if (eom) {
    flags |= spdy::CTRL_FLAG_FIN;
  }
  out->prepend(headroom);
  RWPrivateCursor cursor(out.get());
  cursor.writeBE(versionSettings_.controlVersion);
  cursor.writeBE(uint16_t(spdy::SYN_STREAM));
  cursor.writeBE(flagsAndLength(flags, len));
  cursor.writeBE(uint32_t(stream));
  cursor.writeBE(uint32_t(assocStream));
  // If the message set HTTP/2 priority instead of SPDY priority, we lose
  // priority information since we can't collapse it.
  // halve priority for SPDY/2
  uint8_t pri = msg.getPriority() >> (3 - versionSettings_.majorVersion);
  cursor.writeBE(uint16_t(pri << (versionSettings_.priShift + 8)));

  // Now that we have a complete SYN_STREAM control frame, append
  // it to the writeBuf.
  writeBuf.append(std::move(out));
}

size_t proxygen::SPDYCodec::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 803 of file SPDYCodec.cpp.

                                                         {
  // TODO generate a HEADERS frame?  An additional HEADERS frame
  // somewhere after the SYN_REPLY seems to be the SPDY equivalent
  // of HTTP/1.1's trailers.
  return 0;
}

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

overridevirtual

Reimplemented from proxygen::HTTPCodec.

Definition at line 981 of file SPDYCodec.cpp.

References folly::IOBufQueue::chainLength(), proxygen::SPDYVersionSettings::controlVersion, proxygen::HTTPParallelCodec::ingressGoawayAck_, proxygen::HTTPParallelCodec::isStreamIngressEgressAllowed(), proxygen::SPDYVersionSettings::majorVersion, proxygen::SPDYVersionSettings::minorVersion, NoStream, uint16_t, uint32_t, versionSettings_, proxygen::spdy::WINDOW_UPDATE, and folly::io::detail::Writable< Derived >::writeBE().

                                                       {
  if (versionSettings_.majorVersion < 3 ||
      (stream == NoStream && versionSettings_.majorVersion == 3 &&
       versionSettings_.minorVersion == 0)) {
    return 0;
  }

  if (!isStreamIngressEgressAllowed(stream)) {
    VLOG(2) << "Suppressing WINDOW_UPDATE for stream=" << stream <<
      " ingressGoawayAck_=" << ingressGoawayAck_;
    return 0;
  }

  VLOG(4) << "generating window update for stream=" << stream
          << ": Processed " << delta << " bytes";
  const size_t frameSize = kFrameSizeControlCommon + kFrameSizeWindowUpdate;
  const size_t expectedLength = writeBuf.chainLength() + frameSize;
  QueueAppender appender(&writeBuf, frameSize);
  appender.writeBE(versionSettings_.controlVersion);
  appender.writeBE(uint16_t(spdy::WINDOW_UPDATE));
  appender.writeBE(flagsAndLength(0, kFrameSizeWindowUpdate));
  appender.writeBE(uint32_t(stream)); // TODO: ensure stream < 2^31
  appender.writeBE(delta); // TODO: delta should never be bigger than 2^31
  DCHECK_EQ(writeBuf.chainLength(), expectedLength);
  return frameSize;
}

uint32_t proxygen::SPDYCodec::getDefaultWindowSize ( ) const

inlineoverridevirtual

Get the default size of flow control windows for this protocol

Reimplemented from proxygen::HTTPCodec.

Definition at line 108 of file SPDYCodec.h.

References proxygen::http2::kInitialWindow, uint32_t, and uint8_t.

                                                 {
    return spdy::kInitialWindow;
  }

HTTPSettings* proxygen::SPDYCodec::getEgressSettings ( )

inlineoverridevirtual

Returns a reference to the egress settings

Reimplemented from proxygen::HTTPCodec.

Definition at line 107 of file SPDYCodec.h.

Referenced by TEST().

{ return &egressSettings_; }

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

inlineoverridevirtual

Returns a const reference to the ingress settings. Since ingress settings are set by the remote end, it doesn't make sense for these to be mutable outside the codec.

Reimplemented from proxygen::HTTPCodec.

Definition at line 101 of file SPDYCodec.h.

                                                          {
    return &ingressSettings_;
  }

uint8_t proxygen::SPDYCodec::getMinorVersion

(

)

const

Definition at line 1027 of file SPDYCodec.cpp.

References proxygen::SPDYVersionSettings::minorVersion, and versionSettings_.

                                         {
  return versionSettings_.minorVersion;
}

CodecProtocol proxygen::SPDYCodec::getProtocol ( ) const

overridevirtual

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 197 of file SPDYCodec.cpp.

References proxygen::SPDY3, proxygen::SPDY3_1, proxygen::SPDY_3, proxygen::SPDY_3_1, proxygen::SPDYVersionSettings::version, and versionSettings_.

Referenced by TEST().

                                           {
  switch (versionSettings_.version) {
    case SPDYVersion::SPDY3: return CodecProtocol::SPDY_3;
    case SPDYVersion::SPDY3_1: return CodecProtocol::SPDY_3_1;
  };
  LOG(FATAL) << "unreachable";
  return CodecProtocol::SPDY_3_1;
}

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

overridevirtual

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 206 of file SPDYCodec.cpp.

References userAgent_.

                                               {
  return userAgent_;
}

uint8_t proxygen::SPDYCodec::getVersion

(

)

const

Definition at line 1023 of file SPDYCodec.cpp.

References proxygen::SPDYVersionSettings::majorVersion, and versionSettings_.

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

                                    {
  return versionSettings_.majorVersion;
}

folly::Optional< SPDYVersion > proxygen::SPDYCodec::getVersion ( const std::string &  protocol )

static

Returns the SPDYVersion for the given protocol string, or none otherwise.

Definition at line 1501 of file SPDYCodec.cpp.

References folly::none, proxygen::SPDY3, and proxygen::SPDY3_1.

                                               {
  // Fail fast if it's not possible for the protocol string to define a
  // SPDY protocol. strlen("spdy/1") == 6
  if (protocol.length() < 6) {
    return folly::none;
  }

  if (protocol == "spdy/3.1") {
    return SPDYVersion::SPDY3_1;
  }
  if (protocol == "spdy/3") {
    return SPDYVersion::SPDY3;
  }

  return folly::none;
}

const SPDYVersionSettings & proxygen::SPDYCodec::getVersionSettings ( SPDYVersion  version )

static

Definition at line 138 of file SPDYCodec.cpp.

References proxygen::spdy::kNameHostv3, proxygen::spdy::kNameMethodv3, proxygen::spdy::kNamePathv3, proxygen::spdy::kNameSchemev3, proxygen::spdy::kNameStatusv3, proxygen::spdy::kNameVersionv3, proxygen::spdy::kSessionProtoNameSPDY3, proxygen::kSPDYv3Dictionary, proxygen::spdy::kVersionStrv3, proxygen::spdy::kVersionStrv31, proxygen::SPDY3, proxygen::SPDY3_1, and version.

                                                                            {
  // XXX: We new and leak the static here intentionally so it doesn't get
  // destroyed during a call to exit() when threads are still processing
  // requests resulting in spurious shutdown crashes.

  // Indexed by SPDYVersion
  static const auto spdyVersions = new std::vector<SPDYVersionSettings> {
  // SPDY2 no longer supported; should it ever be added back the lines in which
  // this codec creates compress/Header objects need to be updated as SPDY2
  // constant header names are different from the set of common header names.
  // SPDY3
    {spdy::kNameVersionv3, spdy::kNameStatusv3, spdy::kNameMethodv3,
    spdy::kNamePathv3, spdy::kNameSchemev3, spdy::kNameHostv3,
    spdy::kSessionProtoNameSPDY3, parseUint32, appendUint32,
    (const unsigned char*)kSPDYv3Dictionary, sizeof(kSPDYv3Dictionary),
    0x8003, kFrameSizeSynReplyv3, kFrameSizeNameValuev3,
     kFrameSizeGoawayv3, kPriShiftv3, 3, 0, SPDYVersion::SPDY3,
     spdy::kVersionStrv3},
  // SPDY3.1
    {spdy::kNameVersionv3, spdy::kNameStatusv3, spdy::kNameMethodv3,
    spdy::kNamePathv3, spdy::kNameSchemev3, spdy::kNameHostv3,
    spdy::kSessionProtoNameSPDY3, parseUint32, appendUint32,
    (const unsigned char*)kSPDYv3Dictionary, sizeof(kSPDYv3Dictionary),
    0x8003, kFrameSizeSynReplyv3, kFrameSizeNameValuev3,
     kFrameSizeGoawayv3, kPriShiftv3, 3, 1, SPDYVersion::SPDY3_1,
     spdy::kVersionStrv31}
  };
  auto intVersion = static_cast<unsigned>(version);
  CHECK_LT(intVersion, spdyVersions->size());
  return (*spdyVersions)[intVersion];
}

bool proxygen::SPDYCodec::isSPDYReserved ( const std::string &  name )

private

Definition at line 489 of file SPDYCodec.cpp.

References proxygen::caseInsensitiveEqual(), proxygen::DOWNSTREAM, proxygen::spdy::kNameMethodv2, proxygen::spdy::kNamePathv2, proxygen::spdy::kNameSchemev2, proxygen::spdy::kNameStatusv2, proxygen::spdy::kNameVersionv2, proxygen::SPDYVersionSettings::majorVersion, proxygen::HTTPParallelCodec::transportDirection_, proxygen::UPSTREAM, and versionSettings_.

Referenced by encodeHeaders().

                                                    {
  return (versionSettings_.majorVersion == 2 &&
          ((transportDirection_ == TransportDirection::DOWNSTREAM &&
            (caseInsensitiveEqual(name, spdy::kNameStatusv2) ||
             caseInsensitiveEqual(name, spdy::kNameVersionv2))) ||
           (transportDirection_ == TransportDirection::UPSTREAM &&
            (caseInsensitiveEqual(name, spdy::kNameMethodv2) ||
             caseInsensitiveEqual(name, spdy::kNameSchemev2) ||
             caseInsensitiveEqual(name, spdy::kNamePathv2) ||
             caseInsensitiveEqual(name, spdy::kNameVersionv2)))));
}

int8_t proxygen::SPDYCodec::mapDependencyToPriority ( StreamID  ) const

inlineoverridevirtual

Map the parent back to the priority, -1 if this doesn't make sense.

Reimplemented from proxygen::HTTPCodec.

Definition at line 136 of file SPDYCodec.h.

                                                                 {
    if (parent >= MAX_STREAM_ID) {
      return parent - MAX_STREAM_ID;
    }
    return -1;
  }

StreamID proxygen::SPDYCodec::mapPriorityToDependency ( uint8_t  ) const

inlineoverridevirtual

Map the given linear priority to the correct parent node dependency

Reimplemented from proxygen::HTTPCodec.

Definition at line 132 of file SPDYCodec.h.

                                                                    {
    return MAX_STREAM_ID + priority;
  }

void proxygen::SPDYCodec::onControlFrame ( folly::io::Cursor &  cursor )

private

Helper function to parse out a control frame and execute its handler. All errors are thrown as exceptions.

Definition at line 335 of file SPDYCodec.cpp.

References checkLength(), checkMinLength(), proxygen::spdy::CREDENTIAL, decodeHeaders(), DELTA_WINDOW_SIZE_MASK, proxygen::ERROR, FLAGS_MASK, proxygen::GzipHeaderCodec::getDecodedSize(), proxygen::spdy::GOAWAY, proxygen::spdy::GOAWAY_PROTOCOL_ERROR, proxygen::SPDYVersionSettings::goawaySize, headerCodec_, proxygen::spdy::HEADERS, i, length_, proxygen::spdy::NOOP, onGoaway(), onHeaders(), onPing(), onRstStream(), onSettings(), onSynReply(), onSynStream(), onWindowUpdate(), proxygen::spdy::PING, proxygen::SPDYVersionSettings::priShift, folly::io::detail::CursorBase< Derived, BufType >::read(), folly::io::detail::CursorBase< Derived, BufType >::readBE(), folly::io::detail::CursorBase< Derived, BufType >::readLE(), proxygen::spdy::RST_STREAM, proxygen::spdy::SETTINGS, settings, folly::io::detail::CursorBase< Derived, BufType >::skip(), statusCode, STREAM_ID_MASK, streamId_, proxygen::spdy::SYN_REPLY, proxygen::spdy::SYN_STREAM, proxygen::SPDYVersionSettings::synReplySize, type_, uint32_t, uint8_t, value, version_, versionSettings_, and proxygen::spdy::WINDOW_UPDATE.

Referenced by parseIngress().

                                             {
  switch (type_) {
    case spdy::SYN_STREAM:
    {
      checkMinLength(kFrameSizeSynStream, "SYN_STREAM");
      streamId_ = cursor.readBE<uint32_t>() & STREAM_ID_MASK;
      uint32_t assocStream = cursor.readBE<uint32_t>();
      uint8_t pri = cursor.read<uint8_t>() >> versionSettings_.priShift;
      uint8_t slot = cursor.read<uint8_t>();
      length_ -= kFrameSizeSynStream;
      auto result = decodeHeaders(cursor);
      checkLength(0, "SYN_STREAM");
      onSynStream(assocStream, pri, slot,
                  result.headers, headerCodec_.getDecodedSize());
      break;
    }
    case spdy::SYN_REPLY:
    {
      checkMinLength(versionSettings_.synReplySize, "SYN_REPLY");
      streamId_ = cursor.readBE<uint32_t>() & STREAM_ID_MASK;
      length_ -= versionSettings_.synReplySize;
      if (version_ == 2) {
        // 2 byte unused
        cursor.skip(2);
      }
      auto result = decodeHeaders(cursor);
      checkLength(0, "SYN_REPLY");
      onSynReply(result.headers,
                 headerCodec_.getDecodedSize());
      break;
    }
    case spdy::RST_STREAM:
    {
      checkLength(kFrameSizeRstStream, "RST");
      streamId_ = cursor.readBE<uint32_t>() & STREAM_ID_MASK;
      uint32_t statusCode = cursor.readBE<uint32_t>();
      onRstStream(statusCode);
      break;
    }
    case spdy::SETTINGS:
    {
      checkMinLength(kFrameSizeSettings, "SETTINGS");
      uint32_t numSettings = cursor.readBE<uint32_t>();
      length_ -= sizeof(uint32_t);
      if (length_ / 8 < numSettings) {
        LOG(ERROR) << "SETTINGS: number of settings to high. "
                   << length_ << " < 8 * " << numSettings;
        throw SPDYSessionFailed(spdy::GOAWAY_PROTOCOL_ERROR);
      }
      SettingList settings;
      for (uint32_t i = 0; i < numSettings; i++) {
        uint32_t id = 0;
        if (version_ == 2) {
          id = cursor.readLE<uint32_t>();
        } else {
          id = cursor.readBE<uint32_t>();
        }
        uint32_t value = cursor.readBE<uint32_t>();
        uint8_t flags = (id & FLAGS_MASK) >> 24;
        id &= ~FLAGS_MASK;
        settings.emplace_back(flags, id, value);
      }
      onSettings(settings);
      break;
    }
    case spdy::NOOP:
      VLOG(4) << "Noop received. Doing nothing.";
      checkLength(0, "NOOP");
      break;
    case spdy::PING:
    {
      checkLength(kFrameSizePing, "PING");
      uint32_t unique_id = cursor.readBE<uint32_t>();
      onPing(unique_id);
      break;
    }
    case spdy::GOAWAY:
    {
      checkLength(versionSettings_.goawaySize, "GOAWAY");
      uint32_t lastStream = cursor.readBE<uint32_t>();
      uint32_t statusCode = 0;
      if (version_ == 3) {
        statusCode = cursor.readBE<uint32_t>();
      }
      onGoaway(lastStream, statusCode);
      break;
    }
    case spdy::HEADERS:
    {
      // Note: this is for the HEADERS frame type, not the initial headers
      checkMinLength(kFrameSizeHeaders, "HEADERS");
      streamId_ = cursor.readBE<uint32_t>() & STREAM_ID_MASK;
      length_ -= kFrameSizeHeaders;
      if (version_ == 2) {
        // 2 byte unused
        cursor.skip(2);
        length_ -= 2;
      }
      auto result = decodeHeaders(cursor);
      checkLength(0, "HEADERS");
      onHeaders(result.headers);
      break;
    }
    case spdy::WINDOW_UPDATE:
    {
      checkLength(kFrameSizeWindowUpdate, "WINDOW_UPDATE");
      streamId_ = cursor.readBE<uint32_t>() & STREAM_ID_MASK;
      uint32_t delta = cursor.readBE<uint32_t>() & DELTA_WINDOW_SIZE_MASK;
      onWindowUpdate(delta);
      break;
    }
    case spdy::CREDENTIAL:
    {
      VLOG(4) << "Skipping unsupported/deprecated CREDENTIAL frame";
      // Fall through to default case
    }
    default:
      VLOG(3) << "unimplemented control frame type " << type_
              << ", frame length: " << length_;
      // From spdy spec:
      // Control frame processing requirements:
      // If an endpoint receives a control frame for a type it does not
      // recognize, it must ignore the frame.

      // Consume rest of the frame to skip processing it further
      cursor.skip(length_);
      length_ = 0;
      return;
  }
}

void proxygen::SPDYCodec::onGoaway ( uint32_t  lastGoodStream, uint32_t  statusCode  )

privatenoexcept

Definition at line 1416 of file SPDYCodec.cpp.

References proxygen::HTTPParallelCodec::callback_, proxygen::spdy::GOAWAY_FLOW_CONTROL_ERROR, proxygen::spdy::goawayToErrorCode(), proxygen::HTTPParallelCodec::ingressGoawayAck_, proxygen::HTTPCodec::Callback::onGoaway(), proxygen::PROTOCOL_ERROR, and statusCode.

Referenced by onControlFrame().

                                                       {
  VLOG(4) << "Got GOAWAY, lastGoodStream=" << lastGoodStream
          << ", statusCode=" << statusCode;

  if (lastGoodStream < ingressGoawayAck_) {
    ingressGoawayAck_ = lastGoodStream;
    // Drain all streams <= lastGoodStream
    // and abort streams > lastGoodStream
    auto errorCode = ErrorCode::PROTOCOL_ERROR;
    if (statusCode <= spdy::GoawayStatusCode::GOAWAY_FLOW_CONTROL_ERROR) {
      errorCode = spdy::goawayToErrorCode(spdy::GoawayStatusCode(statusCode));
    }
    callback_->onGoaway(lastGoodStream, errorCode);
  } else {
    LOG(WARNING) << "Received multiple GOAWAY with increasing ack";
  }
}

void proxygen::SPDYCodec::onHeaders ( const compress::HeaderPieceList &  headers )

privatenoexcept

Handle a HEADERS frame. This is not invoked when the first headers on a stream are received. This is called when the remote endpoint sends us any additional headers.

Definition at line 1435 of file SPDYCodec.cpp.

Referenced by onControlFrame().

                                                           {
  VLOG(3) << "onHeaders is unimplemented.";
}

size_t proxygen::SPDYCodec::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 234 of file SPDYCodec.cpp.

References folly::IOBuf::computeChainDataLength(), currentIngressBuf_, failSession(), and parseIngress().

Referenced by TEST().

                                                 {
  size_t bytesParsed = 0;
  currentIngressBuf_ = &buf;
  try {
    bytesParsed = parseIngress(buf);
  } catch (const SPDYSessionFailed& ex) {
    failSession(ex.statusCode);
    bytesParsed = buf.computeChainDataLength();
  }
  return bytesParsed;
}

void proxygen::SPDYCodec::onPing ( uint32_t  uniqueID )

privatenoexcept

Definition at line 1393 of file SPDYCodec.cpp.

References proxygen::HTTPParallelCodec::callback_, proxygen::DOWNSTREAM, nextEgressPingID_, odd, proxygen::HTTPCodec::Callback::onPingReply(), proxygen::HTTPCodec::Callback::onPingRequest(), and proxygen::HTTPParallelCodec::transportDirection_.

Referenced by onControlFrame().

                                                 {
  bool odd = uniqueID & 0x1;
  bool isReply = true;
  if (transportDirection_ == TransportDirection::DOWNSTREAM) {
    if (odd) {
      isReply = false;
    }
  } else if (!odd) {
    isReply = false;
  }

  if (isReply) {
    if (uniqueID >= nextEgressPingID_) {
      LOG(INFO) << "Received reply for pingID=" << uniqueID
                << " that was never sent";
      return;
    }
    callback_->onPingReply(uniqueID);
  } else {
    callback_->onPingRequest(uniqueID);
  }
}

void proxygen::SPDYCodec::onRstStream ( uint32_t  statusCode )

privatenoexcept

Handle an ingress RST_STREAM control frame.

Definition at line 1337 of file SPDYCodec.cpp.

References proxygen::HTTPParallelCodec::deliverCallbackIfAllowed(), proxygen::HTTPCodec::Callback::onAbort(), proxygen::spdy::rstToErrorCode(), statusCode, streamID, and streamId_.

Referenced by onControlFrame().

                                                        {
  VLOG(4) << "Got RST_STREAM, stream=" << streamId_
          << ", status=" << statusCode;
  StreamID streamID(streamId_);
  deliverCallbackIfAllowed(&HTTPCodec::Callback::onAbort, "onAbort", streamID,
                       spdy::rstToErrorCode(spdy::ResetStatusCode(statusCode)));
}

void proxygen::SPDYCodec::onSettings ( const SettingList &  settings )

private

Handle a SETTINGS message that changes/updates settings for the entire SPDY connection (across all transactions)

Definition at line 1345 of file SPDYCodec.cpp.

References proxygen::HTTPParallelCodec::callback_, proxygen::ERROR, flags_, proxygen::HTTPSettings::getSetting(), proxygen::spdy::GOAWAY_PROTOCOL_ERROR, proxygen::spdy::ID_FLAG_SETTINGS_PERSISTED, ingressSettings_, max, proxygen::HTTPCodec::Callback::onSettings(), s, proxygen::HTTPSettings::setSetting(), proxygen::spdy::SETTINGS_CLIENT_CERTIFICATE_VECTOR_SIZE, proxygen::spdy::SETTINGS_CURRENT_CWND, proxygen::spdy::SETTINGS_DOWNLOAD_BANDWIDTH, proxygen::spdy::SETTINGS_DOWNLOAD_RETRANS_RATE, proxygen::spdy::SETTINGS_INITIAL_WINDOW_SIZE, proxygen::spdy::SETTINGS_MAX_CONCURRENT_STREAMS, proxygen::spdy::SETTINGS_ROUND_TRIP_TIME, proxygen::spdy::SETTINGS_UPLOAD_BANDWIDTH, proxygen::spdy::spdyToHttpSettingsId(), and version_.

Referenced by onControlFrame().

                                                      {
  VLOG(4) << "Got " << settings.size() << " settings with "
          << "version=" << version_ << " and flags="
          << std::hex << folly::to<unsigned int>(flags_) << std::dec;
  SettingsList settingsList;
  for (const SettingData& cur: settings) {
    // For now, we never ask for anything to be persisted, so ignore anything
    // coming back
    if (cur.flags & spdy::ID_FLAG_SETTINGS_PERSISTED) {
      VLOG(2) << "Ignoring bogus persisted setting: " << cur.id;
      continue;
    }

    switch (cur.id) {
      case spdy::SETTINGS_UPLOAD_BANDWIDTH:
      case spdy::SETTINGS_DOWNLOAD_BANDWIDTH:
      case spdy::SETTINGS_ROUND_TRIP_TIME:
      case spdy::SETTINGS_CURRENT_CWND:
      case spdy::SETTINGS_DOWNLOAD_RETRANS_RATE:
      case spdy::SETTINGS_CLIENT_CERTIFICATE_VECTOR_SIZE:
        // These will be stored in ingressSettings_ and passed to the callback
        // but we currently ignore the PERSIST flag
        break;
      case spdy::SETTINGS_MAX_CONCURRENT_STREAMS:
        break;
      case spdy::SETTINGS_INITIAL_WINDOW_SIZE:
        if (cur.value > std::numeric_limits<int32_t>::max()) {
          throw SPDYSessionFailed(spdy::GOAWAY_PROTOCOL_ERROR);
        }
        break;
      default:
        LOG(ERROR) << "Received unknown setting with ID=" << cur.id
                   << ", value=" << cur.value
                   << ", and flags=" << std::hex << cur.flags << std::dec;
    }
    if (cur.id >= spdy::SettingsId::SETTINGS_UPLOAD_BANDWIDTH &&
        cur.id <= spdy::SettingsId::SETTINGS_CLIENT_CERTIFICATE_VECTOR_SIZE) {
      auto id = spdy::spdyToHttpSettingsId((spdy::SettingsId)cur.id);
      if (id) {
        ingressSettings_.setSetting(*id, cur.value);
        auto s = ingressSettings_.getSetting(*id);
        settingsList.push_back(*s);
      }
    }
  }
  callback_->onSettings(settingsList);
}

void proxygen::SPDYCodec::onSynCommon ( StreamID  streamID, StreamID  assocStreamID, const compress::HeaderPieceList &  headers, int8_t  pri, const HTTPHeaderSize &  size  )

private

Helper function that contains the common implementation details of calling the same callbacks for onSynStream() and onSynReply()

Negative values of pri are interpreted much like negative array indexes in python, so -1 will be the largest numerical priority value for this SPDY version (i.e., 3 for SPDY/2 or 7 for SPDY/3), -2 the second largest (i.e., 2 for SPDY/2 or 6 for SPDY/3).

Definition at line 1238 of file SPDYCodec.cpp.

References proxygen::spdy::CTRL_FLAG_FIN, proxygen::HTTPParallelCodec::deliverCallbackIfAllowed(), deliverOnMessageBegin(), proxygen::ERROR, flags_, proxygen::spdy::GOAWAY_PROTOCOL_ERROR, proxygen::HTTP_HEADER_USER_AGENT, proxygen::SPDYVersionSettings::majorVersion, std::tr1::make_tuple(), proxygen::HTTPCodec::MAX_STREAM_ID, folly::gen::move, proxygen::HTTPCodec::Callback::onHeadersComplete(), parseHeaders(), proxygen::SPDYVersionSettings::protocolVersionString, proxygen::HTTPParallelCodec::transportDirection_, userAgent_, version_, and versionSettings_.

Referenced by onSynReply(), and onSynStream().

                                                        {
  if (version_ != versionSettings_.majorVersion) {
    LOG(ERROR) << "Invalid version=" << version_;
    throw SPDYSessionFailed(spdy::GOAWAY_PROTOCOL_ERROR);
  }

  unique_ptr<HTTPMessage> msg = parseHeaders(transportDirection_,
                                             streamID, assocStreamID, headers);
  msg->setIngressHeaderSize(size);

  msg->setAdvancedProtocolString(versionSettings_.protocolVersionString);
  // Normalize priority to 3 bits in HTTPMessage.
  pri <<= (3 - versionSettings_.majorVersion);
  msg->setPriority(pri);
  msg->setHTTP2Priority(std::make_tuple(HTTPCodec::MAX_STREAM_ID + pri,
                                        false, 255));
  deliverOnMessageBegin(streamID, assocStreamID, msg.get());

  if ((flags_ & spdy::CTRL_FLAG_FIN) == 0) {
    // If it there are DATA frames coming, consider it chunked
    msg->setIsChunked(true);
  }
  if (userAgent_.empty()) {
    userAgent_ = msg->getHeaders().getSingleOrEmpty(HTTP_HEADER_USER_AGENT);
  }
  deliverCallbackIfAllowed(&HTTPCodec::Callback::onHeadersComplete,
                           "onHeadersComplete", streamID, std::move(msg));
}

void proxygen::SPDYCodec::onSynReply ( const compress::HeaderPieceList &  headers, const HTTPHeaderSize &  size  )

private

Handle an ingress SYN_REPLY control frame. For an upstream-facing SPDY session, this frame is the equivalent of an HTTP response header.

Definition at line 1323 of file SPDYCodec.cpp.

References proxygen::DOWNSTREAM, NoStream, onSynCommon(), proxygen::spdy::RST_PROTOCOL_ERROR, streamId_, and proxygen::HTTPParallelCodec::transportDirection_.

Referenced by onControlFrame().

                                                       {
  VLOG(4) << "Got SYN_REPLY, stream=" << streamId_;
  if (transportDirection_ == TransportDirection::DOWNSTREAM ||
      (streamId_ & 0x1) == 0) {
    throw SPDYStreamFailed(true, streamId_, spdy::RST_PROTOCOL_ERROR);
  }
  // Server push transactions, short of any better heuristics,
  // should have a background priority. Thus, we pick the largest
  // numerical value for the SPDY priority, which no matter what
  // protocol version this is can be conveyed to onSynCommon by -1.
  onSynCommon(StreamID(streamId_), NoStream, headers, -1, size);
}

void proxygen::SPDYCodec::onSynStream ( uint32_t  assocStream, uint8_t  pri, uint8_t  slot, const compress::HeaderPieceList &  headers, const HTTPHeaderSize &  size  )

private

Handle an ingress SYN_STREAM control frame. For a downstream-facing SPDY session, this frame is the equivalent of an HTTP request header.

Definition at line 1283 of file SPDYCodec.cpp.

References proxygen::HTTPParallelCodec::callback_, proxygen::spdy::CTRL_FLAG_UNIDIRECTIONAL, proxygen::DOWNSTREAM, egressSettings_, proxygen::ERROR, flags_, proxygen::HTTPSettings::getSetting(), proxygen::spdy::GOAWAY_PROTOCOL_ERROR, proxygen::spdy::kMaxConcurrentStreams, proxygen::HTTPParallelCodec::lastStreamID_, proxygen::MAX_CONCURRENT_STREAMS, NoStream, proxygen::HTTPCodec::Callback::numIncomingStreams(), onSynCommon(), proxygen::spdy::RST_PROTOCOL_ERROR, proxygen::spdy::RST_REFUSED_STREAM, proxygen::HTTPParallelCodec::sessionClosing_, streamId_, proxygen::HTTPParallelCodec::transportDirection_, and proxygen::UPSTREAM.

Referenced by onControlFrame().

                                                        {
  VLOG(4) << "Got SYN_STREAM, stream=" << streamId_
          << " pri=" << folly::to<int>(pri);
  if (streamId_ == NoStream ||
      streamId_ < lastStreamID_ ||
      (transportDirection_ == TransportDirection::UPSTREAM &&
       (streamId_ & 0x01) == 1) ||
      (transportDirection_ == TransportDirection::DOWNSTREAM &&
       ((streamId_ & 0x1) == 0)) ||
      (transportDirection_ == TransportDirection::UPSTREAM &&
       assocStream == NoStream)) {
    LOG(ERROR) << " invalid syn stream stream_id=" << streamId_
               << " lastStreamID_=" << lastStreamID_
               << " assocStreamID=" << assocStream
               << " direction=" << transportDirection_;
    throw SPDYSessionFailed(spdy::GOAWAY_PROTOCOL_ERROR);
  }

  if (streamId_ == lastStreamID_) {
    throw SPDYStreamFailed(true, streamId_, spdy::RST_PROTOCOL_ERROR);
  }
  if (callback_->numIncomingStreams() >=
      egressSettings_.getSetting(SettingsId::MAX_CONCURRENT_STREAMS,
                                 spdy::kMaxConcurrentStreams)) {
    throw SPDYStreamFailed(true, streamId_, spdy::RST_REFUSED_STREAM);
  }
  if (assocStream != NoStream && !(flags_ & spdy::CTRL_FLAG_UNIDIRECTIONAL)) {
    throw SPDYStreamFailed(true, streamId_, spdy::RST_PROTOCOL_ERROR);
  }
  if (sessionClosing_ != ClosingState::CLOSING) {
    lastStreamID_ = streamId_;
  }
  onSynCommon(StreamID(streamId_),
              StreamID(assocStream), headers, pri, size);
}

void proxygen::SPDYCodec::onWindowUpdate ( uint32_t  delta )

privatenoexcept

Definition at line 1439 of file SPDYCodec.cpp.

References proxygen::HTTPParallelCodec::deliverCallbackIfAllowed(), proxygen::HTTPCodec::Callback::onWindowUpdate(), and streamId_.

Referenced by onControlFrame().

                                                      {
  deliverCallbackIfAllowed(&HTTPCodec::Callback::onWindowUpdate,
                           "onWindowUpdate", streamId_, delta);
}

unique_ptr< HTTPMessage > proxygen::SPDYCodec::parseHeaders ( TransportDirection  direction, StreamID  streamID, StreamID  assocStreamID, const compress::HeaderPieceList &  headers  )

private

Parses the headers in the nameValues array and creates an HTTPMessage object initialized for this transaction.

Definition at line 1059 of file SPDYCodec.cpp.

References add, proxygen::HTTPHeaders::add(), proxygen::caseInsensitiveEqual(), deliverOnMessageBegin(), proxygen::DOWNSTREAM, proxygen::HTTPHeaders::exists(), proxygen::HTTPHeaders::getSingleOrEmpty(), proxygen::CodecUtil::hasGzipAndDeflate(), proxygen::spdy::HEADERS, proxygen::HTTP_HEADER_ACCEPT_ENCODING, proxygen::HTTP_HEADER_HOST, i, int16_t, int32_t, folly::gen::move, name, partialMsg_, proxygen::spdy::RST_PROTOCOL_ERROR, proxygen::HTTPHeaders::set(), folly::Range< Iter >::str(), proxygen::CodecUtil::STRICT, type_, uint32_t, uint8_t, proxygen::UPSTREAM, proxygen::CodecUtil::validateHeaderName(), proxygen::CodecUtil::validateHeaderValue(), proxygen::CodecUtil::validateMethod(), proxygen::CodecUtil::validateURL(), value, and version_.

Referenced by onSynCommon().

                                                          {
  unique_ptr<HTTPMessage> msg(new HTTPMessage());
  HTTPHeaders& headers = msg->getHeaders();
  bool newStream = (type_ != spdy::HEADERS);

  bool hasScheme = false;
  bool hasPath = false;
  bool hasContentLength = false;

  // Number of fields must be even
  CHECK_EQ((inHeaders.size() & 1), 0);
  for (unsigned i = 0; i < inHeaders.size(); i += 2) {
    uint8_t off = 0;
    uint32_t len = inHeaders[i].str.size();
    if (len > 1 && inHeaders[i].str[0] == ':') {
      off = 1;  // also signals control header
      len--;
    }
    folly::StringPiece name(inHeaders[i].str, off, len);
    folly::StringPiece value = inHeaders[i + 1].str;
    VLOG(5) << "Header " << name << ": " << value;
    bool nameOk = CodecUtil::validateHeaderName(name);
    bool valueOk = false;
    bool isPath = false;
    bool isMethod = false;
    if (nameOk) {
      if (name == "content-length") {
        if (hasContentLength) {
          throw SPDYStreamFailed(false, streamID, 400,
             "Multiple content-length headers");
        }
        hasContentLength = true;
      }
      if ((version_ == 2 && name == "url") ||
          (version_ == 3 && off && name == "path")) {
        valueOk = CodecUtil::validateURL(value);
        isPath = true;
        if (hasPath) {
          throw SPDYStreamFailed(false, streamID, 400,
             "Multiple paths in header");
        }
        hasPath = true;
      } else if ((version_ == 2 || off) && name == "method") {
        valueOk = CodecUtil::validateMethod(value);
        isMethod = true;
        if (value == "CONNECT") {
          // We don't support CONNECT request for SPDY
          valueOk = false;
        }
      } else {
        valueOk = CodecUtil::validateHeaderValue(value, CodecUtil::STRICT);
      }
    }
    if (!nameOk || !valueOk) {
      if (newStream) {
        deliverOnMessageBegin(streamID, assocStreamID, nullptr);
      }
      partialMsg_ = std::move(msg);
      throw SPDYStreamFailed(false, streamID, 400, "Bad header value");
    }
    bool add = false;
    if (off || version_ == 2) {
      if (isMethod) {
        msg->setMethod(value);
      } else if (isPath) {
        msg->setURL(value.str());
      } else if (name == "version") {
        if (caseInsensitiveEqual(value, "http/1.0")) {
          msg->setHTTPVersion(1, 0);
        } else {
          msg->setHTTPVersion(1, 1);
        }
      } else if (version_ == 3 && name == "host") {
        headers.add(HTTP_HEADER_HOST, value.str());
      } else if (name == "scheme") {
        hasScheme = true;
        if (value == "https") {
          msg->setSecure(true);
        }
      } else if (name == "status") {
        if (direction == TransportDirection::UPSTREAM && !assocStreamID) {
          folly::StringPiece codePiece;
          folly::StringPiece reasonPiece;
          if (value.contains(' ')) {
            folly::split<false>(' ', value, codePiece, reasonPiece);
          } else {
            codePiece = value;
          }
          int32_t code = -1;
          try {
            code = folly::to<unsigned int>(codePiece);
          } catch (const std::range_error& ex) {
            // Toss out the range error cause the exception will get it
          }
          if (code >= 100 && code <= 999) {
            msg->setStatusCode(code);
            msg->setStatusMessage(reasonPiece.str());
          } else {
            msg->setStatusCode(0);
            headers.add(name, value);
            partialMsg_ = std::move(msg);
            throw SPDYStreamFailed(newStream, streamID,
                                   spdy::RST_PROTOCOL_ERROR,
                                  "Invalid status code");
          }
        } else if (!assocStreamID) {
          if (version_ == 2) {
            headers.add("Status", value);
          }
        } else { // is a push status since there is an assocStreamID?
          // If there exists a push status, save it.
          // If there does not, for now, we *eat* the push status.
          if (value.size() > 0) {
            int16_t code = -1;
            try {
              code = folly::to<uint16_t>(value);
            } catch (const std::range_error& ex) {
              // eat the push status
            }
            if (code >= 100 && code <= 999) {
              msg->setPushStatusCode(code);
            } else {
              // eat the push status.
            }
          }
        }
      } else if (version_ == 2) {
        add = true;
      }
    } else {
      add = true;
    }
    if (add) {
      if (!inHeaders[i].isMultiValued() && headers.exists(name)) {
        headers.add(name, value);
        partialMsg_ = std::move(msg);
        throw SPDYStreamFailed(newStream, streamID, spdy::RST_PROTOCOL_ERROR,
                               "Duplicate header value");
      }
      headers.add(name, value);
    }
  }
  if (assocStreamID &&
      (!headers.exists(HTTP_HEADER_HOST) || !hasScheme || !hasPath)) {
    // Fail a server push without host, scheme or path headers
    throw SPDYStreamFailed(newStream, streamID, 400, "Bad Request");
  }
  if (direction == TransportDirection::DOWNSTREAM) {
    if (version_ == 2 && !headers.exists(HTTP_HEADER_HOST)) {
      ParseURL url(msg->getURL());
      if (url.valid()) {
        headers.add(HTTP_HEADER_HOST, url.hostAndPort());
      }
    }

    const string& accept_encoding =
      headers.getSingleOrEmpty(HTTP_HEADER_ACCEPT_ENCODING);
    if (accept_encoding.empty()) {
      headers.add(HTTP_HEADER_ACCEPT_ENCODING, "gzip, deflate");
    } else {
      bool hasGzip = false;
      bool hasDeflate = false;
      if (!CodecUtil::hasGzipAndDeflate(accept_encoding, hasGzip, hasDeflate)) {
        string new_encoding = accept_encoding;
        if (!hasGzip) {
          new_encoding.append(", gzip");
        }
        if (!hasDeflate) {
          new_encoding.append(", deflate");
        }
        headers.set(HTTP_HEADER_ACCEPT_ENCODING, new_encoding);
      }
    }
  }
  return msg;
}

size_t proxygen::SPDYCodec::parseIngress ( const folly::IOBuf &  buf )

private

Ingress parser, can throw exceptions

Definition at line 246 of file SPDYCodec.cpp.

References proxygen::HTTPParallelCodec::callback_, folly::io::detail::CursorBase< Derived, BufType >::clone(), folly::IOBuf::computeChainDataLength(), ctrl_, proxygen::spdy::CTRL_FLAG_FIN, CTRL_MASK, data, proxygen::HTTPParallelCodec::deliverCallbackIfAllowed(), proxygen::ERROR, failStream(), flags_, FLAGS_MASK, FRAME_HEADER_LEN, frameState_, proxygen::spdy::GOAWAY_PROTOCOL_ERROR, proxygen::spdy::HEADERS, length_, proxygen::SPDYVersionSettings::majorVersion, max, maxFrameLength_, min, folly::gen::move, proxygen::HTTPCodec::Callback::onBody(), onControlFrame(), proxygen::HTTPCodec::Callback::onFrameHeader(), proxygen::HTTPCodec::Callback::onMessageComplete(), folly::io::detail::CursorBase< Derived, BufType >::peek(), folly::io::detail::CursorBase< Derived, BufType >::readBE(), proxygen::spdy::RST_FRAME_TOO_LARGE, STREAM_ID_MASK, streamId_, proxygen::spdy::SYN_REPLY, proxygen::spdy::SYN_STREAM, folly::io::detail::CursorBase< Derived, BufType >::totalLength(), type_, uint16_t, uint32_t, version_, VERSION_MASK, and versionSettings_.

Referenced by onIngress().

                                                    {
  const size_t chainLength = buf.computeChainDataLength();
  Cursor cursor(&buf);
  size_t avail = cursor.totalLength();

  // This can parse beyond the current IOBuf
  for (; avail > 0; avail = cursor.totalLength()) {
    if (frameState_ == FrameState::FRAME_HEADER) {
      if (avail < FRAME_HEADER_LEN) {
        // Make the caller buffer until we get a full frame header
        break;
      }
      auto data = cursor.peek();
      ctrl_ = (data.first[0] & CTRL_MASK);
      if (ctrl_) {
        version_ = cursor.readBE<uint16_t>() & VERSION_MASK;
        type_  = cursor.readBE<uint16_t>();
        if (version_ != versionSettings_.majorVersion) {
          LOG(ERROR) << "Invalid version=" << version_;
          throw SPDYSessionFailed(spdy::GOAWAY_PROTOCOL_ERROR);
        }
      } else {
        streamId_ = cursor.readBE<uint32_t>() & STREAM_ID_MASK;
      }
      length_ = cursor.readBE<uint32_t>();
      flags_ = (length_ & FLAGS_MASK) >> 24;
      length_ &= ~FLAGS_MASK;
      if (ctrl_) {
        if (length_ > maxFrameLength_) {
          if (type_ == spdy::SYN_STREAM || type_ == spdy::SYN_REPLY ||
              type_ == spdy::HEADERS) {
            uint32_t stream_id = cursor.readBE<uint32_t>() & STREAM_ID_MASK;
            failStream(true, stream_id, spdy::RST_FRAME_TOO_LARGE);
            // Compression/stream state is out of sync now
          }
          // Since maxFrameLength_ must be at least 8kb and most control frames
          // have fixed size, only an invalid settings or credential frame can
          // land here. For invalid credential frames we must send a goaway,
          // and a settings frame would have > 1023 pairs, of which none are
          // allowed to be duplicates. Just fail everything.
          LOG(ERROR) << "excessive frame size length_=" << length_;
          throw SPDYSessionFailed(spdy::GOAWAY_PROTOCOL_ERROR);
        }
        frameState_ = FrameState::CTRL_FRAME_DATA;
        callback_->onFrameHeader(0, flags_, length_, type_, version_);
      } else {
        frameState_ = FrameState::DATA_FRAME_DATA;
        callback_->onFrameHeader(streamId_, flags_, length_, type_);
      }
    } else if (frameState_ == FrameState::CTRL_FRAME_DATA) {
      if (avail < length_) {
        // Make the caller buffer the rest of the control frame.
        // We could attempt to decompress incomplete name/value blocks,
        // but for now we're favoring simplicity.
        VLOG(6) << "Need more data: length_=" << length_ << " avail=" << avail;
        break;
      }
      try {
        onControlFrame(cursor);
      } catch (const SPDYStreamFailed& ex) {
        failStream(ex.isNew, ex.streamID, ex.statusCode, ex.what());
      }
      frameState_ = FrameState::FRAME_HEADER;
    } else if (avail > 0 || length_ == 0) {
      // Data frame data.  Pass everything we have up to the frame boundary
      DCHECK(FrameState::DATA_FRAME_DATA == frameState_);

      uint32_t toClone = (avail > std::numeric_limits<uint32_t>::max()) ?
        std::numeric_limits<uint32_t>::max() : static_cast<uint32_t>(avail);
      toClone = std::min(toClone, length_);
      std::unique_ptr<IOBuf> chunk;
      cursor.clone(chunk, toClone);
      deliverCallbackIfAllowed(&HTTPCodec::Callback::onBody, "onBody",
                               streamId_, std::move(chunk), 0);
      length_ -= toClone;
    }

    // Fin handling
    if (length_ == 0) {
      if (flags_ & spdy::CTRL_FLAG_FIN) {
        deliverCallbackIfAllowed(&HTTPCodec::Callback::onMessageComplete,
                                 "onMessageComplete", streamId_, false);
      }
      frameState_ = FrameState::FRAME_HEADER;
    }
  }
  return chainLength - avail;
}

bool proxygen::SPDYCodec::rstStatusSupported ( int  statusCode ) const

private

Helper function to check if the status code is supported by the SPDY version being used

Definition at line 1489 of file SPDYCodec.cpp.

References proxygen::SPDYVersionSettings::majorVersion, proxygen::spdy::RST_FLOW_CONTROL_ERROR, and versionSettings_.

Referenced by generateRstStream().

                                                       {
  if (statusCode == 0) {
    // 0 is not a valid status code for RST_STREAM
    return false;
  }
  // SPDY/3 supports more status codes for RST_STREAM. For SPDY/2,
  // we just use PROTOCOL_ERROR for these new higher numbered error codes.
  return (versionSettings_.majorVersion != 2 ||
          statusCode <= spdy::RST_FLOW_CONTROL_ERROR);
}

unique_ptr< IOBuf > proxygen::SPDYCodec::serializeRequestHeaders ( const HTTPMessage &  msg, bool  isPushed, uint32_t  headroom = 0, HTTPHeaderSize *  size = nullptr  )

private

Serializes headers for requests (aka SYN_STREAM)

Parameters

msg	The message to serialize.
isPushed	true if this is a push message
size	Size of the serialized headers before and after compression
headroom	Optional amount of headroom to reserve at the front of the returned IOBuf, in case the caller wants to put some other data there.

Definition at line 587 of file SPDYCodec.cpp.

References encodeHeaders(), proxygen::HTTPHeaders::exists(), proxygen::HTTPMessage::getHeaders(), proxygen::HTTPMessage::getMethodString(), proxygen::HTTPMessage::getPushStatusStr(), proxygen::HTTPHeaders::getSingleOrEmpty(), proxygen::HTTPMessage::getURL(), proxygen::SPDYVersionSettings::hostStr, proxygen::HTTP_HEADER_COLON_METHOD, proxygen::HTTP_HEADER_COLON_PATH, proxygen::HTTP_HEADER_COLON_SCHEME, proxygen::HTTP_HEADER_COLON_STATUS, proxygen::HTTP_HEADER_HOST, proxygen::HTTP_HEADER_OTHER, proxygen::HTTPMessage::isSecure(), proxygen::SPDYVersionSettings::majorVersion, proxygen::HTTPHeaders::size(), and versionSettings_.

Referenced by generateSynStream().

                        {

  const HTTPHeaders& headers = msg.getHeaders();
  vector<Header> allHeaders;
  allHeaders.reserve(headers.size() + 6);

  const string& method = msg.getMethodString();
  static const string https("https");
  static const string http("http");
  const string& scheme = msg.isSecure() ? https : http;
  string path = msg.getURL();

  CHECK_GT(versionSettings_.majorVersion, 2) << "SPDY/2 no longer supported";

  if (isPushed) {
    const string& pushString = msg.getPushStatusStr();
    allHeaders.emplace_back(HTTP_HEADER_COLON_STATUS, pushString);
  } else {
    allHeaders.emplace_back(HTTP_HEADER_COLON_METHOD, method);
  }
  allHeaders.emplace_back(HTTP_HEADER_COLON_SCHEME, scheme);
  allHeaders.emplace_back(HTTP_HEADER_COLON_PATH, path);
  if (versionSettings_.majorVersion == 3) {
    DCHECK(headers.exists(HTTP_HEADER_HOST));
    const string& host = headers.getSingleOrEmpty(HTTP_HEADER_HOST);
    // We explicitly provide both the code and header name here
    // as HTTP_HEADER_OTHER does not map to kNameHostv3 and we don't want a
    // perf penalty hash kNameHostv3 to HTTP_HEADER_OTHER
    allHeaders.emplace_back(HTTP_HEADER_OTHER, versionSettings_.hostStr, host);
}

  return encodeHeaders(msg, allHeaders, headroom, size);
}

unique_ptr< IOBuf > proxygen::SPDYCodec::serializeResponseHeaders ( const HTTPMessage &  msg, uint32_t  headroom = 0, HTTPHeaderSize *  size = nullptr  )

private

Serializes headers for responses (aka SYN_REPLY)

Parameters

msg	The message to serialize.
size	Size of the serialized headers before and after compression
headroom	Optional amount of headroom to reserve at the front of the returned IOBuf, in case the caller wants to put some other data there.

Definition at line 557 of file SPDYCodec.cpp.

References date, encodeHeaders(), proxygen::HTTPHeaders::exists(), proxygen::HTTPMessage::formatDateHeader(), proxygen::HTTPMessage::getHeaders(), proxygen::HTTPMessage::getStatusCode(), proxygen::HTTPMessage::getStatusMessage(), proxygen::HTTP_HEADER_COLON_STATUS, proxygen::HTTP_HEADER_DATE, and proxygen::HTTPHeaders::size().

Referenced by generateSynReply().

                                                                   {

  // Note: the header-sorting code works with pointers to strings.
  // The role of this local status string is to hold the generated
  // status code long enough for the sort (done later within the
  // same scope) to be able to access it.
  string status;

  const HTTPHeaders& headers = msg.getHeaders();
  vector<Header> allHeaders;
  allHeaders.reserve(headers.size() + 4);

  if (msg.getStatusMessage().empty()) {
    status = folly::to<string>(msg.getStatusCode());
  } else {
    status = folly::to<string>(msg.getStatusCode(), " ",
                               msg.getStatusMessage());
  }
  allHeaders.emplace_back(HTTP_HEADER_COLON_STATUS, status);
  // See comment above regarding status
  string date;
  if (!headers.exists(HTTP_HEADER_DATE)) {
    date = HTTPMessage::formatDateHeader();
    allHeaders.emplace_back(HTTP_HEADER_DATE, date);
  }

  return encodeHeaders(msg, allHeaders, headroom, size);
}

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

inlineoverridevirtual

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

Reimplemented from proxygen::HTTPCodec.

Definition at line 123 of file SPDYCodec.h.

References uint8_t.

                                                             {
    headerCodec_.setStats(stats);
  }

void proxygen::SPDYCodec::setMaxFrameLength

(

uint32_t

maxFrameLength

)

Definition at line 189 of file SPDYCodec.cpp.

References maxFrameLength_.

Referenced by TEST().

                                                         {
  maxFrameLength_ = maxFrameLength;
}

void proxygen::SPDYCodec::setMaxUncompressedHeaders

(

uint32_t

maxUncompressed

)

Set the maximum size of the uncompressed headers

Definition at line 193 of file SPDYCodec.cpp.

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

Referenced by TEST().

                                                                  {
  headerCodec_.setMaxUncompressed(maxUncompressed);
}

bool proxygen::SPDYCodec::supportsPushTransactions ( ) const

inlineoverridevirtual

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

Implements proxygen::HTTPCodec.

Definition at line 53 of file SPDYCodec.h.

References folly::size(), statusCode, uint32_t, uint64_t, and fizz::detail::writeBuf().

{ return true; }

bool proxygen::SPDYCodec::supportsSessionFlowControl ( ) const

overridevirtual

Returns true iff this codec supports session level flow control

Reimplemented from proxygen::HTTPParallelCodec.

Definition at line 214 of file SPDYCodec.cpp.

References proxygen::SPDYVersionSettings::majorVersion, proxygen::SPDYVersionSettings::minorVersion, and versionSettings_.

Referenced by TEST().

                                                 {
  return versionSettings_.majorVersion > 3 ||
    (versionSettings_.majorVersion == 3 && versionSettings_.minorVersion > 0);
}

bool proxygen::SPDYCodec::supportsStreamFlowControl ( ) const

overridevirtual

Returns true iff this codec supports per stream flow control

Reimplemented from proxygen::HTTPParallelCodec.

Definition at line 210 of file SPDYCodec.cpp.

References proxygen::SPDYVersionSettings::majorVersion, and versionSettings_.

                                                {
  return versionSettings_.majorVersion > 2;
}

Member Data Documentation

folly::fbvector<StreamID> proxygen::SPDYCodec::closedStreams_

private

Definition at line 341 of file SPDYCodec.h.

bool proxygen::SPDYCodec::ctrl_

private

Definition at line 375 of file SPDYCodec.h.

Referenced by parseIngress().

const folly::IOBuf* proxygen::SPDYCodec::currentIngressBuf_ {nullptr}

private

Definition at line 355 of file SPDYCodec.h.

Referenced by failSession(), failStream(), and onIngress().

HTTPSettings proxygen::SPDYCodec::egressSettings_

private

Initial value:

{
    {SettingsId::MAX_CONCURRENT_STREAMS, spdy::kMaxConcurrentStreams},
    {SettingsId::INITIAL_WINDOW_SIZE, spdy::kInitialWindow}
  }

Definition at line 348 of file SPDYCodec.h.

Referenced by generateSettings(), and onSynStream().

uint8_t proxygen::SPDYCodec::flags_ {0}

private

Definition at line 366 of file SPDYCodec.h.

Referenced by failStream(), generateRstStream(), onSettings(), onSynCommon(), onSynStream(), and parseIngress().

enum proxygen::SPDYCodec::FrameState proxygen::SPDYCodec::frameState_

private

Referenced by parseIngress().

GzipHeaderCodec proxygen::SPDYCodec::headerCodec_

private

Definition at line 377 of file SPDYCodec.h.

Referenced by decodeHeaders(), encodeHeaders(), onControlFrame(), setMaxUncompressedHeaders(), and SPDYCodec().

HTTPSettings proxygen::SPDYCodec::ingressSettings_

private

Initial value:

{
    {SettingsId::MAX_CONCURRENT_STREAMS, spdy::kMaxConcurrentStreams},
    {SettingsId::INITIAL_WINDOW_SIZE, spdy::kInitialWindow}
  }

Definition at line 344 of file SPDYCodec.h.

Referenced by onSettings().

uint32_t proxygen::SPDYCodec::length_ {0}

private

Definition at line 363 of file SPDYCodec.h.

Referenced by checkLength(), checkMinLength(), decodeHeaders(), onControlFrame(), and parseIngress().

uint32_t proxygen::SPDYCodec::maxFrameLength_ {spdy::kMaxFrameLength}

private

Definition at line 361 of file SPDYCodec.h.

Referenced by parseIngress(), and setMaxFrameLength().

StreamID proxygen::SPDYCodec::nextEgressPingID_

private

Definition at line 357 of file SPDYCodec.h.

Referenced by generatePingRequest(), onPing(), and SPDYCodec().

const StreamID proxygen::SPDYCodec::NoStream = 0

static

Definition at line 38 of file SPDYCodec.h.

Referenced by generatePushPromise(), generateSynStream(), generateWindowUpdate(), onSynReply(), and onSynStream().

std::unique_ptr<HTTPMessage> proxygen::SPDYCodec::partialMsg_

private

Definition at line 353 of file SPDYCodec.h.

Referenced by failStream(), and parseHeaders().

uint32_t proxygen::SPDYCodec::streamId_ {0}

private

Definition at line 362 of file SPDYCodec.h.

Referenced by decodeHeaders(), failStream(), generateRstStream(), onControlFrame(), onRstStream(), onSynReply(), onSynStream(), onWindowUpdate(), and parseIngress().

uint16_t proxygen::SPDYCodec::type_ {0xffff}

private

Definition at line 365 of file SPDYCodec.h.

Referenced by decodeHeaders(), onControlFrame(), parseHeaders(), and parseIngress().

std::string proxygen::SPDYCodec::userAgent_

private

Definition at line 354 of file SPDYCodec.h.

Referenced by getUserAgent(), and onSynCommon().

uint16_t proxygen::SPDYCodec::version_ {0}

private

Definition at line 364 of file SPDYCodec.h.

Referenced by onControlFrame(), onSettings(), onSynCommon(), parseHeaders(), and parseIngress().

const SPDYVersionSettings& proxygen::SPDYCodec::versionSettings_

private

Definition at line 342 of file SPDYCodec.h.

Referenced by encodeHeaders(), generateGoaway(), generatePingCommon(), generateRstStream(), generateSettings(), generateSynReply(), generateSynStream(), generateWindowUpdate(), getMinorVersion(), getProtocol(), getVersion(), isSPDYReserved(), onControlFrame(), onSynCommon(), parseIngress(), rstStatusSupported(), serializeRequestHeaders(), SPDYCodec(), supportsSessionFlowControl(), and supportsStreamFlowControl().

---

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

• proxygen/lib/http/codec/SPDYCodec.h
• proxygen/lib/http/codec/SPDYCodec.cpp