proxygen: proxygen::QPACKEncoder Class Reference

#include <QPACKEncoder.h>

Inheritance diagram for proxygen::QPACKEncoder:

Classes
struct	EncodeResult

struct	OutstandingBlock

Public Types
using	Buf = std::unique_ptr< folly::IOBuf >

Public Member Functions
	QPACKEncoder (bool huffman, uint32_t tableSize=HPACK::kTableSize)

EncodeResult	encode (const std::vector< HPACKHeader > &headers, uint32_t headroom, uint64_t streamId)

HPACK::DecodeError	decodeDecoderStream (std::unique_ptr< folly::IOBuf > buf)

HPACK::DecodeError	onTableStateSync (uint32_t inserts)

HPACK::DecodeError	onHeaderAck (uint64_t streamId, bool all)

void	setHeaderTableSize (uint32_t size)

void	setMaxVulnerable (uint32_t maxVulnerable)

Public Member Functions inherited from proxygen::HPACKEncoderBase
	HPACKEncoderBase (bool huffman)

void	setHeaderTableSize (HeaderTable &table, uint32_t size)

void	setHeaderIndexingStrategy (const HeaderIndexingStrategy *indexingStrat)

const HeaderIndexingStrategy *	getHeaderIndexingStrategy () const

Public Member Functions inherited from proxygen::QPACKContext
	QPACKContext (uint32_t tableSize, bool trackReferences)

	~QPACKContext ()

const HPACKHeader &	getHeader (bool isStatic, uint32_t index, uint32_t base, bool aboveBase)

const QPACKHeaderTable &	getTable () const

uint32_t	getTableSize () const

uint32_t	getBytesStored () const

uint32_t	getHeadersStored () const

void	seedHeaderTable (std::vector< HPACKHeader > &headers)

void	describe (std::ostream &os) const

Private Types
using	BlockReferences = std::set< uint32_t >

Private Member Functions
bool	allowVulnerable () const

bool	shouldIndex (const HPACKHeader &header) const

void	encodeControl (const HPACKHeader &header)

std::pair< bool, uint32_t >	maybeDuplicate (uint32_t relativeIndex)

QPACKEncoder::EncodeResult	encodeQ (const std::vector< HPACKHeader > &headers, uint64_t streamId)

std::tuple< bool, uint32_t, uint32_t >	getNameIndexQ (const HPACKHeaderName &headerName)

void	encodeStreamLiteralQ (const HPACKHeader &header, bool isStaticName, uint32_t nameIndex, uint32_t absoluteNameIndex, uint32_t baseIndex, uint32_t *largestReference)

void	encodeHeaderQ (const HPACKHeader &header, uint32_t baseIndex, uint32_t *largestReference)

void	encodeInsertQ (const HPACKHeader &header, bool isStaticName, uint32_t nameIndex)

void	encodeLiteralQ (const HPACKHeader &header, bool isStaticName, bool postBase, uint32_t nameIndex, const HPACK::Instruction &idxInstr)

void	encodeLiteralQHelper (HPACKEncodeBuffer &buffer, const HPACKHeader &header, bool isStaticName, uint32_t nameIndex, uint8_t staticFlag, const HPACK::Instruction &idxInstr, const HPACK::Instruction &litInstr)

void	trackReference (uint32_t index, uint32_t *largestReference)

void	encodeDuplicate (uint32_t index)

HPACK::DecodeError	decodeHeaderAck (HPACKDecodeBuffer &dbuf, uint8_t prefixLength, bool all)

Private Attributes
HPACKEncodeBuffer	controlBuffer_

std::unordered_map< uint64_t, std::list< OutstandingBlock > >	outstanding_

OutstandingBlock *	curOutstanding_ {nullptr}

uint32_t	maxDepends_ {0}

uint32_t	maxVulnerable_ {HPACK::kDefaultBlocking}

uint32_t	numVulnerable_ {0}

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

Additional Inherited Members
Static Public Attributes inherited from proxygen::HPACKEncoderBase
static const uint32_t	kBufferGrowth = 4000

Protected Member Functions inherited from proxygen::HPACKEncoderBase
void	handlePendingContextUpdate (HPACKEncodeBuffer &buf, uint32_t tableCapacity)

Protected Member Functions inherited from proxygen::QPACKContext
const StaticHeaderTable &	getStaticTable () const

Protected Attributes inherited from proxygen::HPACKEncoderBase
const HeaderIndexingStrategy *	indexingStrat_

HPACKEncodeBuffer	streamBuffer_

bool	pendingContextUpdate_ {false}

Protected Attributes inherited from proxygen::QPACKContext
QPACKHeaderTable	table_

Detailed Description

Definition at line 25 of file QPACKEncoder.h.

Member Typedef Documentation

using proxygen::QPACKEncoder::BlockReferences = std::set<uint32_t>

private

Definition at line 116 of file QPACKEncoder.h.

using proxygen::QPACKEncoder::Buf = std::unique_ptr<folly::IOBuf>

Encode the given headers.

Definition at line 35 of file QPACKEncoder.h.

Constructor & Destructor Documentation

proxygen::QPACKEncoder::QPACKEncoder	(	bool	huffman,
		uint32_t	tableSize = `HPACK::kTableSize`
	)

explicit

Definition at line 17 of file QPACKEncoder.cpp.

References proxygen::HeaderIndexingStrategy::getDefaultInstance(), and proxygen::HPACKEncoderBase::setHeaderIndexingStrategy().

                                                            :
     // We only need the 'QPACK' table if we are using base index
     HPACKEncoderBase(huffman),
     QPACKContext(tableSize, true),
     controlBuffer_(kBufferGrowth, huffman) {
   // Default the encoder indexing strategy; it can be updated later as well
   setHeaderIndexingStrategy(HeaderIndexingStrategy::getDefaultInstance());
 }

Member Function Documentation

bool proxygen::QPACKEncoder::allowVulnerable ( ) const

inlineprivate

Definition at line 66 of file QPACKEncoder.h.

References folly::gen::all(), buffer(), decodeHeaderAck(), encodeControl(), encodeDuplicate(), encodeHeaderQ(), encodeInsertQ(), encodeLiteralQ(), encodeLiteralQHelper(), encodeQ(), encodeStreamLiteralQ(), getNameIndexQ(), maxVulnerable_, maybeDuplicate(), numVulnerable_, shouldIndex(), trackReference(), uint32_t, uint64_t, and uint8_t.

Referenced by encodeHeaderQ(), encodeQ(), encodeStreamLiteralQ(), getNameIndexQ(), and maybeDuplicate().

                                {
     return numVulnerable_ < maxVulnerable_;
   }

HPACK::DecodeError proxygen::QPACKEncoder::decodeDecoderStream ( std::unique_ptr< folly::IOBuf > buf )

Definition at line 277 of file QPACKEncoder.cpp.

References folly::IOBufQueue::append(), proxygen::HPACK::BUFFER_UNDERFLOW, folly::IOBufQueue::chainLength(), decodeHeaderAck(), decoderIngress_, proxygen::ERROR, folly::IOBufQueue::front(), folly::gen::move, proxygen::HPACK::NONE, onTableStateSync(), proxygen::HPACK::Q_CANCEL_STREAM, proxygen::HPACK::Q_HEADER_ACK, proxygen::HPACK::Q_TABLE_STATE_SYNC, folly::IOBufQueue::trimStart(), uint32_t, and uint64_t.

Referenced by proxygen::hpack::encodeDecode(), and TEST().

                                    {
   decoderIngress_.append(std::move(buf));
   folly::io::Cursor cursor(decoderIngress_.front());
   HPACKDecodeBuffer dbuf(cursor, decoderIngress_.chainLength(), 0);
   HPACK::DecodeError err = HPACK::DecodeError::NONE;
   uint32_t consumed = 0;
   while (err == HPACK::DecodeError::NONE && !dbuf.empty()) {
     consumed = dbuf.consumedBytes();
     auto byte = dbuf.peek();
     if (byte & HPACK::Q_HEADER_ACK.code) {
       err = decodeHeaderAck(dbuf, HPACK::Q_HEADER_ACK.prefixLength, false);
     } else if (byte & HPACK::Q_CANCEL_STREAM.code) {
       err = decodeHeaderAck(dbuf, HPACK::Q_CANCEL_STREAM.prefixLength, true);
     } else { // TABLE_STATE_SYNC
       uint64_t inserts = 0;
       err = dbuf.decodeInteger(HPACK::Q_TABLE_STATE_SYNC.prefixLength, inserts);
       if (err == HPACK::DecodeError::NONE) {
         err = onTableStateSync(inserts);
       } else if (err != HPACK::DecodeError::BUFFER_UNDERFLOW) {
         LOG(ERROR) << "Failed to decode num inserts, err=" << err;
       }
     }
   } // while
   if (err == HPACK::DecodeError::BUFFER_UNDERFLOW) {
     err = HPACK::DecodeError::NONE;
     decoderIngress_.trimStart(consumed);
   } else {
     decoderIngress_.trimStart(dbuf.consumedBytes());
   }
   return err;
 }

HPACK::DecodeError proxygen::QPACKEncoder::decodeHeaderAck	(	HPACKDecodeBuffer &	dbuf,
		uint8_t	prefixLength,
		bool	all
	)

private

Definition at line 310 of file QPACKEncoder.cpp.

References proxygen::HPACK::BUFFER_UNDERFLOW, proxygen::HPACKDecodeBuffer::decodeInteger(), proxygen::ERROR, proxygen::HPACK::NONE, onHeaderAck(), and uint64_t.

Referenced by allowVulnerable(), and decodeDecoderStream().

                                                            {
   uint64_t streamId = 0;
   auto err = dbuf.decodeInteger(prefixLength, streamId);
   if (err == HPACK::DecodeError::NONE) {
     err = onHeaderAck(streamId, all);
   } else if (err != HPACK::DecodeError::BUFFER_UNDERFLOW) {
     LOG(ERROR) << "Failed to decode streamId, err=" << err;
   }
   return err;
 }

QPACKEncoder::EncodeResult proxygen::QPACKEncoder::encode	(	const std::vector< HPACKHeader > &	headers,
		uint32_t	headroom,
		uint64_t	streamId
	)

Definition at line 27 of file QPACKEncoder.cpp.

References proxygen::HPACKEncodeBuffer::addHeadroom(), proxygen::HeaderTable::capacity(), controlBuffer_, encodeQ(), proxygen::HPACKEncoderBase::handlePendingContextUpdate(), proxygen::HPACKEncoderBase::streamBuffer_, and proxygen::QPACKContext::table_.

Referenced by proxygen::QPACKCodec::encode(), proxygen::hpack::encodeDecode(), and TEST().

                                         {
   if (headroom) {
     streamBuffer_.addHeadroom(headroom);
   }
   handlePendingContextUpdate(controlBuffer_, table_.capacity());
   return encodeQ(headers, streamId);
 }

void proxygen::QPACKEncoder::encodeControl ( const HPACKHeader & header )

private

Referenced by allowVulnerable().

void proxygen::QPACKEncoder::encodeDuplicate ( uint32_t index )

private

Definition at line 224 of file QPACKEncoder.cpp.

References controlBuffer_, proxygen::HPACKEncodeBuffer::encodeInteger(), and proxygen::HPACK::Q_DUPLICATE.

Referenced by allowVulnerable(), and maybeDuplicate().

                                                  {
   DCHECK_GT(index, 0);
   controlBuffer_.encodeInteger(index - 1, HPACK::Q_DUPLICATE);
 }

void proxygen::QPACKEncoder::encodeHeaderQ	(	const HPACKHeader &	header,
		uint32_t	baseIndex,
		uint32_t *	largestReference
	)

private

Definition at line 76 of file QPACKEncoder.cpp.

References proxygen::QPACKHeaderTable::absoluteToRelative(), proxygen::QPACKHeaderTable::add(), allowVulnerable(), proxygen::QPACKHeaderTable::canIndex(), proxygen::HPACKHeader::copy(), encodeInsertQ(), proxygen::HPACKEncodeBuffer::encodeInteger(), encodeStreamLiteralQ(), proxygen::QPACKHeaderTable::getBaseIndex(), proxygen::HeaderTable::getIndex(), proxygen::QPACKHeaderTable::getIndex(), getNameIndexQ(), proxygen::QPACKContext::getStaticTable(), proxygen::QPACKHeaderTable::isValid(), maybeDuplicate(), proxygen::HPACKHeader::name, proxygen::HPACK::Q_INDEXED, proxygen::HPACK::Q_INDEXED_POST, proxygen::HPACK::Q_INDEXED_STATIC, shouldIndex(), proxygen::HPACKEncoderBase::streamBuffer_, proxygen::QPACKContext::table_, trackReference(), uint32_t, and proxygen::QPACKHeaderTable::UNACKED.

Referenced by allowVulnerable(), and encodeQ().

                                                                              {
   uint32_t index = getStaticTable().getIndex(header);
   if (index > 0) {
     // static reference
     streamBuffer_.encodeInteger(index,
                                 HPACK::Q_INDEXED.code | HPACK::Q_INDEXED_STATIC,
                                 HPACK::Q_INDEXED.prefixLength);
     return;
   }
 
   bool indexable = shouldIndex(header);
   if (indexable) {
     index = table_.getIndex(header, allowVulnerable());
     if (index == QPACKHeaderTable::UNACKED) {
       index = 0;
       indexable = false;
     }
   }
   if (index != 0) {
     // dynamic reference
     bool duplicated = false;
     std::tie(duplicated, index) = maybeDuplicate(index);
     // index is now 0 or absolute
     indexable &= (duplicated && index == 0);
   }
   if (index == 0) {
     // No valid entry matching header, see if there's a matching name
     uint32_t nameIndex = 0;
     uint32_t absoluteNameIndex = 0;
     bool isStaticName = false;
     std::tie(isStaticName, nameIndex, absoluteNameIndex) =
       getNameIndexQ(header.name);
 
     // Now check if we should emit an insertion on the control stream
     if (indexable && table_.canIndex(header)) {
       encodeInsertQ(header, isStaticName, nameIndex);
       CHECK(table_.add(header.copy()));
       if (allowVulnerable()) {
         index = table_.getBaseIndex();
       } else {
         index = 0;
         if (!table_.isValid(table_.absoluteToRelative(absoluteNameIndex))) {
           // The insert may have invalidated the name index.
           isStaticName = true;
           nameIndex = 0;
           absoluteNameIndex = 0;
         }
       }
     }
 
     if (index == 0) {
       // Couldn't insert it: table full, not indexable, or table contains
       // vulnerable reference.  Encode a literal on the request stream.
       encodeStreamLiteralQ(header, isStaticName, nameIndex, absoluteNameIndex,
                            baseIndex, largestReference);
       return;
     }
   }
 
   // Encoding a dynamic index reference
   DCHECK_NE(index, 0);
   trackReference(index, largestReference);
   if (index > baseIndex) {
     streamBuffer_.encodeInteger(index - baseIndex - 1, HPACK::Q_INDEXED_POST);
   } else {
     streamBuffer_.encodeInteger(baseIndex - index, HPACK::Q_INDEXED);
   }
 }

void proxygen::QPACKEncoder::encodeInsertQ	(	const HPACKHeader &	header,
		bool	isStaticName,
		uint32_t	nameIndex
	)

private

Definition at line 229 of file QPACKEncoder.cpp.

References controlBuffer_, encodeLiteralQHelper(), proxygen::HPACK::Q_INSERT_NAME_REF, proxygen::HPACK::Q_INSERT_NAME_REF_STATIC, and proxygen::HPACK::Q_INSERT_NO_NAME_REF.

Referenced by allowVulnerable(), and encodeHeaderQ().

                                                      {
   encodeLiteralQHelper(
     controlBuffer_, header, isStaticName, nameIndex,
     HPACK::Q_INSERT_NAME_REF_STATIC, HPACK::Q_INSERT_NAME_REF,
     HPACK::Q_INSERT_NO_NAME_REF);
 }

void proxygen::QPACKEncoder::encodeLiteralQ	(	const HPACKHeader &	header,
		bool	isStaticName,
		bool	postBase,
		uint32_t	nameIndex,
		const HPACK::Instruction &	idxInstr
	)

private

Definition at line 238 of file QPACKEncoder.cpp.

References encodeLiteralQHelper(), proxygen::HPACK::Q_LITERAL, proxygen::HPACK::Q_LITERAL_STATIC, and proxygen::HPACKEncoderBase::streamBuffer_.

Referenced by allowVulnerable(), and encodeStreamLiteralQ().

                                                                     {
   DCHECK(!isStaticName || !postBase);
   encodeLiteralQHelper(
       streamBuffer_, header, isStaticName, nameIndex,
       HPACK::Q_LITERAL_STATIC, idxInstr,
       HPACK::Q_LITERAL);
 }

void proxygen::QPACKEncoder::encodeLiteralQHelper	(	HPACKEncodeBuffer &	buffer,
		const HPACKHeader &	header,
		bool	isStaticName,
		uint32_t	nameIndex,
		uint8_t	staticFlag,
		const HPACK::Instruction &	idxInstr,
		const HPACK::Instruction &	litInstr
	)

private

Definition at line 250 of file QPACKEncoder.cpp.

References proxygen::HPACK::Instruction::code, proxygen::HPACKEncodeBuffer::encodeInteger(), proxygen::HPACKEncodeBuffer::encodeLiteral(), proxygen::HPACKHeaderName::get(), proxygen::HPACKHeader::name, proxygen::HPACK::Instruction::prefixLength, uint8_t, proxygen::QPACKHeaderTable::UNACKED, and proxygen::HPACKHeader::value.

Referenced by allowVulnerable(), encodeInsertQ(), and encodeLiteralQ().

                                                                           {
   // name
   if (nameIndex) {
     VLOG(10) << "encoding name index=" << nameIndex;
     DCHECK_NE(nameIndex, QPACKHeaderTable::UNACKED);
     uint8_t byte = idxInstr.code;
     if (isStaticName) {
       byte |= staticFlag;
     } else {
       DCHECK_GE(nameIndex, 1);
       nameIndex -= 1;
     }
     buffer.encodeInteger(nameIndex, byte, idxInstr.prefixLength);
   } else {
     buffer.encodeLiteral(litInstr.code, litInstr.prefixLength,
                          header.name.get());
   }
   // value
   buffer.encodeLiteral(header.value);
 }

QPACKEncoder::EncodeResult proxygen::QPACKEncoder::encodeQ	(	const std::vector< HPACKHeader > &	headers,
		uint64_t	streamId
	)

private

Definition at line 38 of file QPACKEncoder.cpp.

References allowVulnerable(), controlBuffer_, curOutstanding_, encodeHeaderQ(), proxygen::HPACKEncodeBuffer::encodeInteger(), proxygen::QPACKHeaderTable::getBaseIndex(), folly::gen::move, numVulnerable_, outstanding_, proxygen::HPACK::Q_DELTA_BASE, proxygen::HPACK::Q_DELTA_BASE_NEG, proxygen::HPACK::Q_DELTA_BASE_POS, proxygen::HPACKEncodeBuffer::release(), proxygen::HPACKEncoderBase::streamBuffer_, proxygen::QPACKContext::table_, uint32_t, and proxygen::QPACKEncoder::OutstandingBlock::vulnerable.

Referenced by allowVulnerable(), and encode().

                                                                            {
   auto& outstandingBlocks = outstanding_[streamId];
   outstandingBlocks.emplace_back();
   curOutstanding_ = &outstandingBlocks.back();
   auto baseIndex = table_.getBaseIndex();
 
   uint32_t largestReference = 0;
   for (const auto& header: headers) {
     encodeHeaderQ(header, baseIndex, &largestReference);
   }
 
   auto streamBlock = streamBuffer_.release();
 
   // encode the prefix
   streamBuffer_.encodeInteger(largestReference);
   if (largestReference > baseIndex) {
     streamBuffer_.encodeInteger(largestReference - baseIndex,
                                 HPACK::Q_DELTA_BASE_NEG,
                                 HPACK::Q_DELTA_BASE.prefixLength);
   } else {
     streamBuffer_.encodeInteger(baseIndex - largestReference,
                                 HPACK::Q_DELTA_BASE_POS,
                                 HPACK::Q_DELTA_BASE.prefixLength);
   }
   auto streamBuffer = streamBuffer_.release();
   streamBuffer->prependChain(std::move(streamBlock));
 
   auto controlBuf = controlBuffer_.release();
   // curOutstanding_.references could be empty, if the block encodes only static
   // headers and/or literals
   if (curOutstanding_->vulnerable) {
     DCHECK(allowVulnerable());
     numVulnerable_++;
   }
 
   return { std::move(controlBuf), std::move(streamBuffer) };
 }

void proxygen::QPACKEncoder::encodeStreamLiteralQ	(	const HPACKHeader &	header,
		bool	isStaticName,
		uint32_t	nameIndex,
		uint32_t	absoluteNameIndex,
		uint32_t	baseIndex,
		uint32_t *	largestReference
	)

private

Definition at line 184 of file QPACKEncoder.cpp.

References allowVulnerable(), encodeLiteralQ(), proxygen::HPACK::Q_LITERAL_NAME_REF, proxygen::HPACK::Q_LITERAL_NAME_REF_POST, and trackReference().

Referenced by allowVulnerable(), and encodeHeaderQ().

                                                                               {
   if (absoluteNameIndex > 0) {
     // Dynamic name reference, vulnerability checks already done
     CHECK(absoluteNameIndex <= baseIndex || allowVulnerable());
     trackReference(absoluteNameIndex, largestReference);
   }
   if (absoluteNameIndex > baseIndex) {
     encodeLiteralQ(header,
                    false, /* not static */
                    true, /* post base */
                    absoluteNameIndex - baseIndex,
                    HPACK::Q_LITERAL_NAME_REF_POST);
   } else {
     encodeLiteralQ(header,
                    isStaticName,
                    false, /* not post base */
                    isStaticName ? nameIndex : baseIndex - absoluteNameIndex + 1,
                    HPACK::Q_LITERAL_NAME_REF);
   }
 }

std::tuple< bool, uint32_t, uint32_t > proxygen::QPACKEncoder::getNameIndexQ ( const HPACKHeaderName & headerName )

private

Definition at line 161 of file QPACKEncoder.cpp.

References proxygen::QPACKHeaderTable::absoluteToRelative(), allowVulnerable(), proxygen::QPACKContext::getStaticTable(), maybeDuplicate(), proxygen::HeaderTable::nameIndex(), proxygen::QPACKHeaderTable::nameIndex(), proxygen::QPACKContext::table_, and uint32_t.

Referenced by allowVulnerable(), and encodeHeaderQ().

                                      {
   uint32_t absoluteNameIndex = 0;
   uint32_t nameIndex = getStaticTable().nameIndex(headerName);
   bool isStatic = true;
   if (nameIndex == 0) {
     // check dynamic table
     nameIndex = table_.nameIndex(headerName, allowVulnerable());
     if (nameIndex != 0) {
       absoluteNameIndex = maybeDuplicate(nameIndex).second;
       if (absoluteNameIndex) {
         isStatic = false;
         nameIndex = table_.absoluteToRelative(absoluteNameIndex);
       } else {
         nameIndex = 0;
         absoluteNameIndex = 0;
       }
     }
   }
   return std::tuple<bool, uint32_t, uint32_t>(
     isStatic, nameIndex, absoluteNameIndex);
 }

std::pair< bool, uint32_t > proxygen::QPACKEncoder::maybeDuplicate ( uint32_t relativeIndex )

private

Definition at line 151 of file QPACKEncoder.cpp.

References allowVulnerable(), encodeDuplicate(), proxygen::QPACKHeaderTable::maybeDuplicate(), and proxygen::QPACKContext::table_.

Referenced by allowVulnerable(), encodeHeaderQ(), and getNameIndexQ().

                               {
   auto res = table_.maybeDuplicate(relativeIndex, allowVulnerable());
   if (res.first) {
     VLOG(4) << "Encoded duplicate index=" << relativeIndex;
     encodeDuplicate(relativeIndex);
   }
   return res;
 }

HPACK::DecodeError proxygen::QPACKEncoder::onHeaderAck	(	uint64_t	streamId,
		bool	all
	)

Definition at line 330 of file QPACKEncoder.cpp.

References folly::gen::all(), proxygen::ERROR, i, proxygen::HPACK::INVALID_ACK, folly::gen::move, proxygen::HPACK::NONE, numVulnerable_, outstanding_, proxygen::QPACKHeaderTable::setMaxAcked(), proxygen::QPACKHeaderTable::subRef(), and proxygen::QPACKContext::table_.

Referenced by decodeHeaderAck(), and TEST().

                                                                       {
   auto it = outstanding_.find(streamId);
   if (it == outstanding_.end()) {
     if (!all) {
       LOG(ERROR) << "Received an ack with no outstanding header blocks stream="
                  << streamId;
       return HPACK::DecodeError::INVALID_ACK;
     } else {
       // all implies a reset, meaning it's not an error if there are no
       // outstanding blocks
       return HPACK::DecodeError::NONE;
     }
   }
   VLOG(5) << ((all) ? "onCancelStream" : "onHeaderAck") << " streamId="
           << streamId;
   if (all) {
     // Happens when a stream is reset
     for (auto& block: it->second) {
       for (auto i: block.references) {
         table_.subRef(i);
       }
       if (block.vulnerable) {
         numVulnerable_--;
       }
     }
     it->second.clear();
   } else {
     auto block = std::move(it->second.front());
     it->second.pop_front();
     // a different stream, sub all the references
     for (auto i: block.references) {
       VLOG(5) << "Decrementing refcount for absoluteIndex=" << i;
       table_.subRef(i);
     }
     if (block.vulnerable) {
       numVulnerable_--;
     }
     // largest reference is implicitly acknowledged
     if (!block.references.empty()) {
       auto largestReference = *block.references.rbegin();
       VLOG(5) << "Implicitly acknowledging absoluteIndex=" << largestReference;
       table_.setMaxAcked(largestReference);
     }
   }
   if (it->second.empty()) {
     outstanding_.erase(it);
   }
   return HPACK::DecodeError::NONE;
 }

HPACK::DecodeError proxygen::QPACKEncoder::onTableStateSync ( uint32_t inserts )

Definition at line 323 of file QPACKEncoder.cpp.

References proxygen::HPACK::INVALID_ACK, proxygen::HPACK::NONE, proxygen::QPACKHeaderTable::onTableStateSync(), and proxygen::QPACKContext::table_.

Referenced by decodeDecoderStream(), and TEST().

                                                                 {
   if (!table_.onTableStateSync(inserts)) {
     return HPACK::DecodeError::INVALID_ACK;
   }
   return HPACK::DecodeError::NONE;
 }

void proxygen::QPACKEncoder::setHeaderTableSize ( uint32_t size )

inline

Definition at line 57 of file QPACKEncoder.h.

References proxygen::HPACKEncoderBase::setHeaderTableSize(), and proxygen::QPACKContext::table_.

Referenced by TEST().

                                          {
     HPACKEncoderBase::setHeaderTableSize(table_, size);
   }

void proxygen::QPACKEncoder::setMaxVulnerable ( uint32_t maxVulnerable )

inline

Definition at line 61 of file QPACKEncoder.h.

References maxVulnerable_.

Referenced by TEST().

                                                 {
     maxVulnerable_ = maxVulnerable;
   }

bool proxygen::QPACKEncoder::shouldIndex ( const HPACKHeader & header ) const

private

Definition at line 146 of file QPACKEncoder.cpp.

References proxygen::HPACKHeader::bytes(), proxygen::HeaderTable::capacity(), proxygen::HeaderIndexingStrategy::indexHeader(), proxygen::HPACKEncoderBase::indexingStrat_, and proxygen::QPACKContext::table_.

Referenced by allowVulnerable(), and encodeHeaderQ().

                                                               {
   return (header.bytes() <= table_.capacity()) &&
     (!indexingStrat_ || indexingStrat_->indexHeader(header));
 }

void proxygen::QPACKEncoder::trackReference	(	uint32_t	index,
		uint32_t *	largestReference
	)

private

Definition at line 207 of file QPACKEncoder.cpp.

References proxygen::QPACKHeaderTable::addRef(), curOutstanding_, proxygen::QPACKHeaderTable::isVulnerable(), proxygen::QPACKEncoder::OutstandingBlock::references, proxygen::QPACKContext::table_, and proxygen::QPACKEncoder::OutstandingBlock::vulnerable.

Referenced by allowVulnerable(), encodeHeaderQ(), and encodeStreamLiteralQ().

                                                               {
   CHECK_NE(absoluteIndex, 0);
   CHECK(curOutstanding_);
   if (absoluteIndex > *largestReference) {
     *largestReference = absoluteIndex;
     if (table_.isVulnerable(absoluteIndex)) {
       curOutstanding_->vulnerable = true;
     }
   }
   auto res = curOutstanding_->references.insert(absoluteIndex);
   if (res.second) {
     VLOG(5) << "Bumping refcount for absoluteIndex=" << absoluteIndex;
     table_.addRef(absoluteIndex);
   }
 }