proxygen: proxygen::QPACKDecoder Class Reference

#include <QPACKDecoder.h>

Inheritance diagram for proxygen::QPACKDecoder:

Classes
struct	Partial

struct	PendingBlock

Public Member Functions
	QPACKDecoder (uint32_t tableSize=HPACK::kTableSize, uint32_t maxUncompressed=HeaderCodec::kMaxUncompressed)

void	decodeStreaming (uint64_t streamId, std::unique_ptr< folly::IOBuf > block, uint32_t totalBytes, HPACK::StreamingCallback *streamingCb)

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

std::unique_ptr< folly::IOBuf >	encodeTableStateSync ()

std::unique_ptr< folly::IOBuf >	encodeHeaderAck (uint64_t streamId) const

std::unique_ptr< folly::IOBuf >	encodeCancelStream (uint64_t streamId)

uint64_t	getHolBlockCount () const

uint64_t	getQueuedBytes () const

void	setMaxBlocking (uint32_t maxBlocking)

Public Member Functions inherited from proxygen::HPACKDecoderBase
	HPACKDecoderBase (uint32_t tableSize, uint32_t maxUncompressed)

HPACK::DecodeError	getError () const

bool	hasError () const

void	setHeaderTableMaxSize (uint32_t maxSize)

void	setMaxUncompressed (uint64_t maxUncompressed)

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

Public Member Functions inherited from folly::DestructorCheck
virtual	~DestructorCheck ()

Private Member Functions
bool	isValid (bool isStatic, uint32_t index, bool aboveBase)

uint32_t	handleBaseIndex (HPACKDecodeBuffer &dbuf)

void	decodeStreamingImpl (uint32_t largestReference, uint32_t consumed, HPACKDecodeBuffer &dbuf, HPACK::StreamingCallback *streamingCb)

uint32_t	decodeHeaderQ (HPACKDecodeBuffer &dbuf, HPACK::StreamingCallback *streamingCb)

uint32_t	decodeIndexedHeaderQ (HPACKDecodeBuffer &dbuf, uint32_t prefixLength, bool aboveBase, HPACK::StreamingCallback streamingCb, headers_t emitted)

uint32_t	decodeLiteralHeaderQ (HPACKDecodeBuffer &dbuf, bool indexing, bool nameIndexed, uint8_t prefixLength, bool aboveBase, HPACK::StreamingCallback *streamingCb)

void	decodeEncoderStreamInstruction (HPACKDecodeBuffer &dbuf)

void	enqueueHeaderBlock (uint64_t streamId, uint32_t largestReference, uint32_t baseIndex, uint32_t consumed, std::unique_ptr< folly::IOBuf > block, size_t length, HPACK::StreamingCallback *streamingCb)

bool	decodeBlock (uint32_t largestReference, const PendingBlock &pending)

void	drainQueue ()

Private Attributes
uint32_t	maxBlocking_ {HPACK::kDefaultBlocking}

uint32_t	baseIndex_ {0}

uint32_t	lastAcked_ {0}

uint32_t	holBlockCount_ {0}

uint64_t	queuedBytes_ {0}

std::multimap< uint32_t, PendingBlock >	queue_

Partial	partial_

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

Additional Inherited Members
Public Types inherited from proxygen::HPACKDecoderBase
using	headers_t = std::vector< HPACKHeader >

Protected Member Functions inherited from proxygen::HPACKDecoderBase
uint32_t	emit (const HPACKHeader &header, HPACK::StreamingCallback streamingCb, headers_t emitted)

void	completeDecode (HeaderCodec::Type type, HPACK::StreamingCallback *streamingCb, uint32_t compressedSize, uint32_t emittedSize)

void	handleTableSizeUpdate (HPACKDecodeBuffer &dbuf, HeaderTable &table)

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

Protected Attributes inherited from proxygen::HPACKDecoderBase
HPACK::DecodeError	err_ {HPACK::DecodeError::NONE}

uint32_t	maxTableSize_

uint64_t	maxUncompressed_

Protected Attributes inherited from proxygen::QPACKContext
QPACKHeaderTable	table_

Detailed Description

Definition at line 22 of file QPACKDecoder.h.

Constructor & Destructor Documentation

proxygen::QPACKDecoder::QPACKDecoder	(	uint32_t	tableSize = `HPACK::kTableSize`,
		uint32_t	maxUncompressed = `HeaderCodec::kMaxUncompressed`
	)

inlineexplicit

Definition at line 26 of file QPACKDecoder.h.

References decodeEncoderStream(), decodeStreaming(), encodeCancelStream(), encodeHeaderAck(), encodeTableStateSync(), uint32_t, and uint64_t.

29 : HPACKDecoderBase(tableSize, maxUncompressed),

30 QPACKContext(tableSize, false /* don't track references */) {}

proxygen::HPACKDecoderBase::HPACKDecoderBase

HPACKDecoderBase(uint32_t tableSize, uint32_t maxUncompressed)

Definition: HPACKDecoderBase.h:26

proxygen::QPACKContext::QPACKContext

QPACKContext(uint32_t tableSize, bool trackReferences)

Definition: QPACKContext.cpp:14

Member Function Documentation

bool proxygen::QPACKDecoder::decodeBlock	(	uint32_t	largestReference,
		const PendingBlock &	pending
	)

private

Definition at line 359 of file QPACKDecoder.cpp.

References proxygen::QPACKDecoder::PendingBlock::baseIndex, baseIndex_, proxygen::QPACKDecoder::PendingBlock::block, proxygen::QPACKDecoder::PendingBlock::cb, proxygen::QPACKDecoder::PendingBlock::consumed, decodeStreamingImpl(), folly::DestructorCheck::Safety::destroyed(), proxygen::QPACKDecoder::PendingBlock::length, proxygen::HPACKDecoderBase::maxUncompressed_, and queuedBytes_.

Referenced by drainQueue().

                                                             {
   if (pending.length > 0) {
     VLOG(5) << "decodeBlock len=" << pending.length;
     folly::io::Cursor cursor(pending.block.get());
     HPACKDecodeBuffer dbuf(cursor, pending.length, maxUncompressed_);
     DCHECK_LE(pending.length, queuedBytes_);
     queuedBytes_ -= pending.length;
     baseIndex_ = pending.baseIndex;
     folly::DestructorCheck::Safety safety(*this);
     decodeStreamingImpl(largestReference, pending.consumed, dbuf, pending.cb);
     // The callback way destroy this, if so stop queue processing
     if (safety.destroyed()) {
       return true;
     }
   }
   return false;
 }

HPACK::DecodeError proxygen::QPACKDecoder::decodeEncoderStream ( std::unique_ptr< folly::IOBuf > buf )

Definition at line 141 of file QPACKDecoder.cpp.

References folly::IOBufQueue::append(), baseIndex_, proxygen::HPACK::BUFFER_UNDERFLOW, folly::IOBufQueue::chainLength(), proxygen::QPACKDecoder::Partial::consumed, decodeEncoderStreamInstruction(), drainQueue(), proxygen::HPACKDecoderBase::err_, folly::IOBufQueue::front(), proxygen::HPACKDecoderBase::hasError(), ingress_, proxygen::HPACKDecoderBase::maxUncompressed_, folly::gen::move, proxygen::HPACK::NONE, partial_, and folly::IOBufQueue::trimStart().

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

                                    {
   ingress_.append(std::move(buf));
   Cursor cursor(ingress_.front());
   HPACKDecodeBuffer dbuf(cursor, ingress_.chainLength(), maxUncompressed_);
   VLOG(6) << "Decoding control block";
   baseIndex_ = 0;
   err_ = HPACK::DecodeError::NONE;
   while (!hasError() && !dbuf.empty()) {
     decodeEncoderStreamInstruction(dbuf);
     if (err_ == HPACK::DecodeError::BUFFER_UNDERFLOW) {
       ingress_.trimStart(partial_.consumed);
       drainQueue();
       return HPACK::DecodeError::NONE;
     }
   }
   ingress_.trimStart(dbuf.consumedBytes());
   if (hasError()) {
     return err_;
   } else {
     drainQueue();
     return HPACK::DecodeError::NONE;
   }
 }

void proxygen::QPACKDecoder::decodeEncoderStreamInstruction ( HPACKDecodeBuffer & dbuf )

private

Definition at line 166 of file QPACKDecoder.cpp.

References proxygen::QPACKHeaderTable::add(), proxygen::HPACK::Instruction::code, proxygen::QPACKDecoder::Partial::consumed, proxygen::HPACKDecodeBuffer::consumedBytes(), decodeIndexedHeaderQ(), decodeLiteralHeaderQ(), proxygen::HPACKDecoderBase::handleTableSizeUpdate(), proxygen::HPACKDecoderBase::hasError(), folly::gen::move, partial_, proxygen::HPACKDecodeBuffer::peek(), proxygen::HPACK::Q_DUPLICATE, proxygen::HPACK::Q_INSERT_NAME_REF, proxygen::HPACK::Q_INSERT_NO_NAME_REF, proxygen::HPACK::Q_TABLE_SIZE_UPDATE, proxygen::QPACKContext::table_, uint8_t, and proxygen::QPACKDecoder::Partial::VALUE.

Referenced by decodeEncoderStream(), and setMaxBlocking().

                                                                          {
   uint8_t byte = dbuf.peek();
   partial_.consumed = dbuf.consumedBytes();
   if (partial_.state == Partial::VALUE ||
       byte & HPACK::Q_INSERT_NAME_REF.code) {
     // If partial state is VALUE, it might have been a NO_NAME_REF instruction,
     // but we've already parsed the name, so it doesn't matter
     decodeLiteralHeaderQ(
         dbuf, true, true, HPACK::Q_INSERT_NAME_REF.prefixLength, false,
         nullptr);
   } else if (byte & HPACK::Q_INSERT_NO_NAME_REF.code) {
     decodeLiteralHeaderQ(
         dbuf, true, false, HPACK::Q_INSERT_NO_NAME_REF.prefixLength, false,
         nullptr);
   } else if (byte & HPACK::Q_TABLE_SIZE_UPDATE.code) {
     handleTableSizeUpdate(dbuf, table_);
   } else { // must be Q_DUPLICATE=000
     headers_t emitted;
     decodeIndexedHeaderQ(
         dbuf, HPACK::Q_DUPLICATE.prefixLength, false, nullptr, &emitted);
     if (!hasError()) {
       CHECK(!emitted.empty());
       table_.add(std::move(emitted[0]));
     }
   }
 }

uint32_t proxygen::QPACKDecoder::decodeHeaderQ	(	HPACKDecodeBuffer &	dbuf,
		HPACK::StreamingCallback *	streamingCb
	)

private

Definition at line 117 of file QPACKDecoder.cpp.

References decodeIndexedHeaderQ(), decodeLiteralHeaderQ(), proxygen::HPACKDecodeBuffer::peek(), proxygen::HPACK::Q_INDEXED, proxygen::HPACK::Q_INDEXED_POST, proxygen::HPACK::Q_LITERAL, proxygen::HPACK::Q_LITERAL_NAME_REF, proxygen::HPACK::Q_LITERAL_NAME_REF_POST, and uint8_t.

Referenced by decodeStreamingImpl(), and setMaxBlocking().

                                          {
   uint8_t byte = dbuf.peek();
   if (byte & HPACK::Q_INDEXED.code) {
     return decodeIndexedHeaderQ(
         dbuf, HPACK::Q_INDEXED.prefixLength, false, streamingCb, nullptr);
   } else if (byte & HPACK::Q_LITERAL_NAME_REF.code) {
     return decodeLiteralHeaderQ(
         dbuf, false, true, HPACK::Q_LITERAL_NAME_REF.prefixLength, false,
         streamingCb);
   } else if (byte & HPACK::Q_LITERAL.code) {
     return decodeLiteralHeaderQ(
         dbuf, false, false, HPACK::Q_LITERAL.prefixLength, false, streamingCb);
   } else if (byte & HPACK::Q_INDEXED_POST.code) {
     return decodeIndexedHeaderQ(
         dbuf, HPACK::Q_INDEXED_POST.prefixLength, true, streamingCb, nullptr);
   } else { // Q_LITERAL_NAME_REF_POST
     return decodeLiteralHeaderQ(
         dbuf, false, true, HPACK::Q_LITERAL_NAME_REF_POST.prefixLength, true,
         streamingCb);
   }
 }

uint32_t proxygen::QPACKDecoder::decodeIndexedHeaderQ	(	HPACKDecodeBuffer &	dbuf,
		uint32_t	prefixLength,
		bool	aboveBase,
		HPACK::StreamingCallback *	streamingCb,
		headers_t *	emitted
	)

private

Definition at line 262 of file QPACKDecoder.cpp.

References baseIndex_, proxygen::HPACKDecodeBuffer::decodeInteger(), proxygen::HPACKDecoderBase::emit(), proxygen::HPACKDecoderBase::err_, proxygen::ERROR, proxygen::QPACKContext::getHeader(), proxygen::HPACK::INVALID_INDEX, isValid(), proxygen::HPACK::NONE, proxygen::HPACKDecodeBuffer::peek(), and uint64_t.

Referenced by decodeEncoderStreamInstruction(), decodeHeaderQ(), and setMaxBlocking().

                         {
   uint64_t index;
   bool isStatic = !aboveBase && (dbuf.peek() & (1 << prefixLength));
   err_ = dbuf.decodeInteger(prefixLength, index);
   if (err_ != HPACK::DecodeError::NONE) {
     LOG(ERROR) << "Decode error decoding index err_=" << err_;
     return 0;
   }
   if (!isStatic) {
     index++;
   }
   // validate the index
   if (index == 0 || !isValid(isStatic, index, aboveBase)) {
     LOG(ERROR) << "received invalid index: " << index;
     err_ = HPACK::DecodeError::INVALID_INDEX;
     return 0;
   }
 
   auto& header = getHeader(isStatic, index, baseIndex_, aboveBase);
   return emit(header, streamingCb, emitted);
 }

uint32_t proxygen::QPACKDecoder::decodeLiteralHeaderQ	(	HPACKDecodeBuffer &	dbuf,
		bool	indexing,
		bool	nameIndexed,
		uint8_t	prefixLength,
		bool	aboveBase,
		HPACK::StreamingCallback *	streamingCb
	)

private

Definition at line 193 of file QPACKDecoder.cpp.

References proxygen::QPACKHeaderTable::add(), baseIndex_, proxygen::HPACK::BUFFER_UNDERFLOW, proxygen::QPACKDecoder::Partial::consumed, proxygen::HPACKDecodeBuffer::consumedBytes(), proxygen::HPACKDecodeBuffer::decodeInteger(), proxygen::HPACKDecodeBuffer::decodeLiteral(), proxygen::HPACKDecoderBase::emit(), proxygen::HPACKDecoderBase::err_, proxygen::ERROR, proxygen::QPACKContext::getHeader(), proxygen::QPACKDecoder::Partial::header, proxygen::HPACK::INVALID_INDEX, isValid(), folly::gen::move, proxygen::HPACKHeader::name, proxygen::QPACKDecoder::Partial::NAME, proxygen::HPACK::NONE, folly::partial(), partial_, proxygen::HPACKDecodeBuffer::peek(), proxygen::QPACKContext::table_, uint32_t, uint64_t, proxygen::HPACKHeader::value, and proxygen::QPACKDecoder::Partial::VALUE.

Referenced by decodeEncoderStreamInstruction(), decodeHeaderQ(), and setMaxBlocking().

                                          {
   bool allowPartial = (streamingCb == nullptr);
   Partial localPartial;
   Partial* partial = (allowPartial) ? &partial_ : &localPartial;
   if (partial->state == Partial::NAME) {
     if (nameIndexed) {
       uint64_t nameIndex = 0;
       bool isStaticName = !aboveBase && (dbuf.peek() & (1 << prefixLength));
       err_ = dbuf.decodeInteger(prefixLength, nameIndex);
       if (allowPartial && err_ == HPACK::DecodeError::BUFFER_UNDERFLOW) {
         return 0;
       }
       if (err_ != HPACK::DecodeError::NONE) {
         LOG(ERROR) << "Decode error decoding index err_=" << err_;
         return 0;
       }
       if (!isStaticName) {
         nameIndex++;
       }
       // validate the index
       if (!isValid(isStaticName, nameIndex, aboveBase)) {
         LOG(ERROR) << "received invalid index: " << nameIndex;
         err_ = HPACK::DecodeError::INVALID_INDEX;
         return 0;
       }
       partial->header.name = getHeader(
           isStaticName, nameIndex, baseIndex_, aboveBase).name;
     } else {
       folly::fbstring headerName;
       err_ = dbuf.decodeLiteral(prefixLength, headerName);
       if (allowPartial && err_ == HPACK::DecodeError::BUFFER_UNDERFLOW) {
         return 0;
       }
       if (err_ != HPACK::DecodeError::NONE) {
         LOG(ERROR) << "Error decoding header name err_=" << err_;
         return 0;
       }
       partial->header.name = headerName;
     }
     partial->state = Partial::VALUE;
     partial->consumed = dbuf.consumedBytes();
   }
   // value
   err_ = dbuf.decodeLiteral(partial->header.value);
   if (allowPartial && err_ == HPACK::DecodeError::BUFFER_UNDERFLOW) {
     return 0;
   }
   if (err_ != HPACK::DecodeError::NONE) {
     LOG(ERROR) << "Error decoding header value name=" << partial->header.name
                << " err_=" << err_;
     return 0;
   }
   partial->state = Partial::NAME;
 
   uint32_t emittedSize = emit(partial->header, streamingCb, nullptr);
 
   if (indexing) {
     table_.add(std::move(partial->header));
   }
 
   return emittedSize;
 }

void proxygen::QPACKDecoder::decodeStreaming	(	uint64_t	streamId,
		std::unique_ptr< folly::IOBuf >	block,
		uint32_t	totalBytes,
		HPACK::StreamingCallback *	streamingCb
	)

Definition at line 25 of file QPACKDecoder.cpp.

References folly::IOBufQueue::append(), baseIndex_, proxygen::HPACKDecoderBase::completeDecode(), decodeStreamingImpl(), enqueueHeaderBlock(), proxygen::HPACKDecoderBase::err_, proxygen::QPACKHeaderTable::getBaseIndex(), handleBaseIndex(), maxBlocking_, proxygen::HPACKDecoderBase::maxUncompressed_, folly::IOBufQueue::move(), folly::gen::move, proxygen::HPACK::NONE, proxygen::HeaderCodec::QPACK, queue_, proxygen::QPACKContext::table_, proxygen::HPACK::TOO_MANY_BLOCKING, folly::IOBufQueue::trimStart(), and uint32_t.

Referenced by checkQError(), proxygen::QPACKCodec::decodeStreaming(), proxygen::hpack::encodeDecode(), QPACKDecoder(), and TEST().

                                          {
   Cursor cursor(block.get());
   HPACKDecodeBuffer dbuf(cursor, totalBytes, maxUncompressed_);
   err_ = HPACK::DecodeError::NONE;
   uint32_t largestReference = handleBaseIndex(dbuf);
   if (largestReference > table_.getBaseIndex()) {
     VLOG(5) << "largestReference=" << largestReference << " > baseIndex=" <<
       table_.getBaseIndex() << ", queuing";
     if (queue_.size() >= maxBlocking_) {
       VLOG(2) << "QPACK queue is full size=" << queue_.size()
               << " maxBlocking_=" << maxBlocking_;
       err_ = HPACK::DecodeError::TOO_MANY_BLOCKING;
       completeDecode(HeaderCodec::Type::QPACK, streamingCb, 0, 0);
     } else {
       folly::IOBufQueue q;
       q.append(std::move(block));
       q.trimStart(dbuf.consumedBytes());
       enqueueHeaderBlock(streamID, largestReference, baseIndex_,
                          dbuf.consumedBytes(), q.move(),
                          totalBytes - dbuf.consumedBytes(), streamingCb);
     }
   } else {
     decodeStreamingImpl(largestReference, 0, dbuf, streamingCb);
   }
 }

void proxygen::QPACKDecoder::decodeStreamingImpl	(	uint32_t	largestReference,
		uint32_t	consumed,
		HPACKDecodeBuffer &	dbuf,
		HPACK::StreamingCallback *	streamingCb
	)

private

Definition at line 90 of file QPACKDecoder.cpp.

References proxygen::HPACKDecoderBase::completeDecode(), proxygen::HPACKDecodeBuffer::consumedBytes(), decodeHeaderQ(), proxygen::HPACKDecodeBuffer::empty(), proxygen::HPACKDecoderBase::err_, proxygen::ERROR, proxygen::HPACKDecoderBase::hasError(), proxygen::HPACK::HEADERS_TOO_LARGE, lastAcked_, max, proxygen::HPACKDecoderBase::maxUncompressed_, proxygen::HeaderCodec::QPACK, and uint32_t.

Referenced by decodeBlock(), decodeStreaming(), and setMaxBlocking().

                                          {
   uint32_t emittedSize = 0;
 
   while (!hasError() && !dbuf.empty()) {
     emittedSize += decodeHeaderQ(dbuf, streamingCb);
     if (emittedSize > maxUncompressed_) {
       LOG(ERROR) << "exceeded uncompressed size limit of "
                  << maxUncompressed_ << " bytes";
       err_ = HPACK::DecodeError::HEADERS_TOO_LARGE;
       break;
     }
     emittedSize += 2;
   }
 
   if (!hasError()) {
     // This is a little premature, since the ack doesn't get generated here.
     // lastAcked_ is only read in encodeTableStateSync, so all completed header
     // blocks must be call encodeHeaderAck BEFORE calling encodeTableStateSync.
     lastAcked_ = std::max(lastAcked_, largestReference);
   }
   completeDecode(HeaderCodec::Type::QPACK, streamingCb,
                  consumed + dbuf.consumedBytes(), emittedSize);
 }

void proxygen::QPACKDecoder::drainQueue ( )

private

Definition at line 378 of file QPACKDecoder.cpp.

References decodeBlock(), proxygen::QPACKHeaderTable::getBaseIndex(), proxygen::HPACKDecoderBase::hasError(), queue_, and proxygen::QPACKContext::table_.

Referenced by decodeEncoderStream().

                               {
   auto it = queue_.begin();
   while (!queue_.empty() && it->first <= table_.getBaseIndex() &&
          !hasError()) {
     if (decodeBlock(it->first, it->second)) {
       return;
     }
     queue_.erase(it);
     it = queue_.begin();
   }
 }

std::unique_ptr< folly::IOBuf > proxygen::QPACKDecoder::encodeCancelStream ( uint64_t streamId )

Definition at line 323 of file QPACKDecoder.cpp.

References proxygen::HPACKEncodeBuffer::encodeInteger(), proxygen::HPACK::Q_CANCEL_STREAM, queue_, and proxygen::HPACKEncodeBuffer::release().

Referenced by QPACKDecoder().

                        {
   // Remove this stream from the queue
   auto it = queue_.begin();
   while (it != queue_.end()) {
     if (it->second.streamID == streamId) {
       it = queue_.erase(it);
     } else {
       it++;
     }
   }
   HPACKEncodeBuffer ackEncoder(kGrowth, false);
   ackEncoder.encodeInteger(streamId, HPACK::Q_CANCEL_STREAM);
   return ackEncoder.release();
 }

std::unique_ptr< folly::IOBuf > proxygen::QPACKDecoder::encodeHeaderAck ( uint64_t streamId ) const

Definition at line 315 of file QPACKDecoder.cpp.

References proxygen::HPACKEncodeBuffer::encodeInteger(), proxygen::HPACK::Q_HEADER_ACK, and proxygen::HPACKEncodeBuffer::release().

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

                              {
   HPACKEncodeBuffer ackEncoder(kGrowth, false);
   VLOG(6) << "encodeHeaderAck id=" << streamId;
   ackEncoder.encodeInteger(streamId, HPACK::Q_HEADER_ACK);
   return ackEncoder.release();
 }

std::unique_ptr< folly::IOBuf > proxygen::QPACKDecoder::encodeTableStateSync ( )

Definition at line 302 of file QPACKDecoder.cpp.

References proxygen::HPACKEncodeBuffer::encodeInteger(), proxygen::QPACKHeaderTable::getBaseIndex(), lastAcked_, proxygen::HPACK::Q_TABLE_STATE_SYNC, proxygen::HPACKEncodeBuffer::release(), proxygen::QPACKContext::table_, and uint32_t.

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

                                                              {
   uint32_t toAck = table_.getBaseIndex() - lastAcked_;
   if (toAck > 0) {
     VLOG(6) << "encodeTableStateSync toAck=" << toAck;
     HPACKEncodeBuffer ackEncoder(kGrowth, false);
     ackEncoder.encodeInteger(toAck, HPACK::Q_TABLE_STATE_SYNC);
     lastAcked_ = table_.getBaseIndex();
     return ackEncoder.release();
   } else {
     return nullptr;
   }
 }

void proxygen::QPACKDecoder::enqueueHeaderBlock	(	uint64_t	streamId,
		uint32_t	largestReference,
		uint32_t	baseIndex,
		uint32_t	consumed,
		std::unique_ptr< folly::IOBuf >	block,
		size_t	length,
		HPACK::StreamingCallback *	streamingCb
	)

private

Definition at line 339 of file QPACKDecoder.cpp.

References proxygen::QPACKHeaderTable::getBaseIndex(), holBlockCount_, folly::gen::move, queue_, queuedBytes_, and proxygen::QPACKContext::table_.

Referenced by decodeStreaming(), and setMaxBlocking().

                                        {
   // TDOO: this queue is currently unbounded and has no timeouts
   CHECK_GT(largestReference, table_.getBaseIndex());
   queue_.emplace(
     std::piecewise_construct,
     std::forward_as_tuple(largestReference),
     std::forward_as_tuple(streamID, baseIndex, length, consumed,
                           std::move(block), streamingCb));
   holBlockCount_++;
   VLOG(5) << "queued block=" << largestReference << " len=" << length;
   queuedBytes_ += length;
 }

uint64_t proxygen::QPACKDecoder::getHolBlockCount ( ) const

inline

Definition at line 46 of file QPACKDecoder.h.

References holBlockCount_.

                                     {
     return holBlockCount_;
   }

uint64_t proxygen::QPACKDecoder::getQueuedBytes ( ) const

inline

Definition at line 50 of file QPACKDecoder.h.

References queuedBytes_.

                                   {
     return queuedBytes_;
   }

uint32_t proxygen::QPACKDecoder::handleBaseIndex ( HPACKDecodeBuffer & dbuf )

private

Definition at line 55 of file QPACKDecoder.cpp.

References baseIndex_, proxygen::HPACK::BUFFER_UNDERFLOW, proxygen::HPACKDecodeBuffer::decodeInteger(), proxygen::HPACKDecodeBuffer::empty(), proxygen::HPACKDecoderBase::err_, proxygen::ERROR, proxygen::HPACK::INVALID_INDEX, proxygen::HPACK::NONE, proxygen::HPACKDecodeBuffer::peek(), proxygen::HPACK::Q_DELTA_BASE, proxygen::HPACK::Q_DELTA_BASE_NEG, and uint64_t.

Referenced by decodeStreaming(), and setMaxBlocking().

                                                               {
   uint64_t largestReference;
   err_ = dbuf.decodeInteger(largestReference);
   if (err_ != HPACK::DecodeError::NONE) {
     LOG(ERROR) << "Decode error decoding largest reference err_=" << err_;
     return 0;
   }
   VLOG(5) << "Decoded largestReference=" << largestReference;
   uint64_t delta = 0;
   if (dbuf.empty()) {
     LOG(ERROR) << "Invalid prefix, no delta-base";
     err_ = HPACK::DecodeError::BUFFER_UNDERFLOW;
     return 0;
   }
   bool neg = dbuf.peek() & HPACK::Q_DELTA_BASE_NEG;
   err_ = dbuf.decodeInteger(HPACK::Q_DELTA_BASE.prefixLength, delta);
   if (err_ != HPACK::DecodeError::NONE) {
     LOG(ERROR) << "Decode error decoding delta base=" << err_;
     return 0;
   }
   if (neg) {
     if (delta > largestReference) {
       LOG(ERROR) << "Invalid delta=" << delta << " largestReference="
                  << largestReference;
       err_ = HPACK::DecodeError::INVALID_INDEX;
       return 0;
     }
     baseIndex_ = largestReference - delta;
   } else {
     baseIndex_ = largestReference + delta;
   }
   VLOG(5) << "Decoded baseIndex_=" << baseIndex_;
   return largestReference;
 }

bool proxygen::QPACKDecoder::isValid	(	bool	isStatic,
		uint32_t	index,
		bool	aboveBase
	)

private

Definition at line 289 of file QPACKDecoder.cpp.

References baseIndex_, proxygen::QPACKContext::getStaticTable(), proxygen::HeaderTable::isValid(), proxygen::QPACKHeaderTable::isValid(), proxygen::QPACKContext::table_, and uint32_t.

Referenced by decodeIndexedHeaderQ(), decodeLiteralHeaderQ(), and setMaxBlocking().

                                                                         {
   if (isStatic) {
     return getStaticTable().isValid(index);
   } else {
     uint32_t baseIndex = baseIndex_;
     if (aboveBase) {
       baseIndex = baseIndex + index;
       index = 1;
     }
     return table_.isValid(index, baseIndex);
   }
 }

void proxygen::QPACKDecoder::setMaxBlocking ( uint32_t maxBlocking )

inline

Definition at line 54 of file QPACKDecoder.h.

References decodeEncoderStreamInstruction(), decodeHeaderQ(), decodeIndexedHeaderQ(), decodeLiteralHeaderQ(), decodeStreamingImpl(), enqueueHeaderBlock(), handleBaseIndex(), isValid(), maxBlocking_, uint32_t, uint64_t, and uint8_t.

Referenced by TEST().

                                             {
     maxBlocking_ = maxBlocking;
   }

Member Data Documentation

uint32_t proxygen::QPACKDecoder::baseIndex_ {0}

private

Definition at line 122 of file QPACKDecoder.h.

Referenced by decodeBlock(), decodeEncoderStream(), decodeIndexedHeaderQ(), decodeLiteralHeaderQ(), decodeStreaming(), handleBaseIndex(), and isValid().

uint32_t proxygen::QPACKDecoder::holBlockCount_ {0}

private

Definition at line 124 of file QPACKDecoder.h.

Referenced by enqueueHeaderBlock(), and getHolBlockCount().

folly::IOBufQueue proxygen::QPACKDecoder::ingress_ {folly::IOBufQueue::cacheChainLength()}

private

Definition at line 136 of file QPACKDecoder.h.

Referenced by decodeEncoderStream().

uint32_t proxygen::QPACKDecoder::lastAcked_ {0}

private

Definition at line 123 of file QPACKDecoder.h.

Referenced by decodeStreamingImpl(), and encodeTableStateSync().

uint32_t proxygen::QPACKDecoder::maxBlocking_ {HPACK::kDefaultBlocking}

private

Definition at line 121 of file QPACKDecoder.h.

Referenced by decodeStreaming(), and setMaxBlocking().

Partial proxygen::QPACKDecoder::partial_

private

Definition at line 135 of file QPACKDecoder.h.

Referenced by decodeEncoderStream(), decodeEncoderStreamInstruction(), and decodeLiteralHeaderQ().

std::multimap<uint32_t, PendingBlock> proxygen::QPACKDecoder::queue_

private

Definition at line 126 of file QPACKDecoder.h.

Referenced by decodeStreaming(), drainQueue(), encodeCancelStream(), and enqueueHeaderBlock().

uint64_t proxygen::QPACKDecoder::queuedBytes_ {0}

private

Definition at line 125 of file QPACKDecoder.h.

Referenced by decodeBlock(), enqueueHeaderBlock(), and getQueuedBytes().

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

proxygen/lib/http/codec/compress/QPACKDecoder.h
proxygen/lib/http/codec/compress/QPACKDecoder.cpp

Classes

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation