proxygen: proxygen::HPACKDecoder Class Reference

#include <HPACKDecoder.h>

Inheritance diagram for proxygen::HPACKDecoder:

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

void	decodeStreaming (folly::io::Cursor &cursor, uint32_t totalBytes, HPACK::StreamingCallback *streamingCb)

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::HPACKContext
	HPACKContext (uint32_t tableSize)

	~HPACKContext ()

uint32_t	getIndex (const HPACKHeader &header) const

uint32_t	nameIndex (const HPACKHeaderName &headerName) const

bool	isStatic (uint32_t index) const

const HPACKHeader &	getHeader (uint32_t index)

const HeaderTable &	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 Member Functions
bool	isValid (uint32_t index)

uint32_t	decodeIndexedHeader (HPACKDecodeBuffer &dbuf, HPACK::StreamingCallback streamingCb, headers_t emitted)

uint32_t	decodeLiteralHeader (HPACKDecodeBuffer &dbuf, HPACK::StreamingCallback streamingCb, headers_t emitted)

uint32_t	decodeHeader (HPACKDecodeBuffer &dbuf, HPACK::StreamingCallback streamingCb, headers_t emitted)

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::HPACKContext
const StaticHeaderTable &	getStaticTable () const

uint32_t	globalToDynamicIndex (uint32_t index) const

uint32_t	globalToStaticIndex (uint32_t index) const

uint32_t	dynamicToGlobalIndex (uint32_t index) const

uint32_t	staticToGlobalIndex (uint32_t index) const

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

uint32_t	maxTableSize_

uint64_t	maxUncompressed_

Protected Attributes inherited from proxygen::HPACKContext
HeaderTable	table_

Detailed Description

Definition at line 22 of file HPACKDecoder.h.

Constructor & Destructor Documentation

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

inlineexplicit

Definition at line 25 of file HPACKDecoder.h.

References decodeHeader(), decodeIndexedHeader(), decodeLiteralHeader(), decodeStreaming(), isValid(), and uint32_t.

28 : HPACKDecoderBase(tableSize, maxUncompressed),

29 HPACKContext(tableSize) {}

proxygen::HPACKDecoderBase::HPACKDecoderBase

HPACKDecoderBase(uint32_t tableSize, uint32_t maxUncompressed)

Definition: HPACKDecoderBase.h:26

proxygen::HPACKContext::HPACKContext

HPACKContext(uint32_t tableSize)

Definition: HPACKContext.cpp:14

Member Function Documentation

uint32_t proxygen::HPACKDecoder::decodeHeader	(	HPACKDecodeBuffer &	dbuf,
		HPACK::StreamingCallback *	streamingCb,
		headers_t *	emitted
	)

private

Definition at line 130 of file HPACKDecoder.cpp.

References decodeIndexedHeader(), decodeLiteralHeader(), proxygen::HPACKDecoderBase::handleTableSizeUpdate(), proxygen::HPACK::INDEX_REF, proxygen::HPACK::LITERAL_INC_INDEX, proxygen::HPACKDecodeBuffer::peek(), proxygen::HPACKContext::table_, proxygen::HPACK::TABLE_SIZE_UPDATE, and uint8_t.

Referenced by decodeStreaming(), and HPACKDecoder().

                         {
   uint8_t byte = dbuf.peek();
   if (byte & HPACK::INDEX_REF.code) {
     return decodeIndexedHeader(dbuf, streamingCb, emitted);
   } else if (byte & HPACK::LITERAL_INC_INDEX.code) {
     // else it's fine, fall through to decodeLiteralHeader
   } else if (byte & HPACK::TABLE_SIZE_UPDATE.code) {
     handleTableSizeUpdate(dbuf, table_);
     return 0;
   } // else LITERAL
   // LITERAL_NO_INDEXING or LITERAL_INCR_INDEXING
   return decodeLiteralHeader(dbuf, streamingCb, emitted);
 }

uint32_t proxygen::HPACKDecoder::decodeIndexedHeader	(	HPACKDecodeBuffer &	dbuf,
		HPACK::StreamingCallback *	streamingCb,
		headers_t *	emitted
	)

private

Definition at line 101 of file HPACKDecoder.cpp.

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

Referenced by decodeHeader(), and HPACKDecoder().

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

uint32_t proxygen::HPACKDecoder::decodeLiteralHeader	(	HPACKDecodeBuffer &	dbuf,
		HPACK::StreamingCallback *	streamingCb,
		headers_t *	emitted
	)

private

Definition at line 44 of file HPACKDecoder.cpp.

References proxygen::HeaderTable::add(), proxygen::HPACK::Instruction::code, proxygen::HPACKDecodeBuffer::decodeInteger(), proxygen::HPACKDecodeBuffer::decodeLiteral(), proxygen::HPACKDecoderBase::emit(), proxygen::HPACKDecoderBase::err_, proxygen::ERROR, proxygen::HPACKContext::getHeader(), proxygen::HPACK::INVALID_INDEX, isValid(), proxygen::HPACK::LITERAL, proxygen::HPACK::LITERAL_INC_INDEX, folly::gen::move, proxygen::HPACKHeader::name, proxygen::HPACKDecodeBuffer::next(), proxygen::HPACK::NONE, proxygen::HPACKDecodeBuffer::peek(), proxygen::HPACK::Instruction::prefixLength, proxygen::HPACKContext::table_, uint32_t, uint64_t, uint8_t, and proxygen::HPACKHeader::value.

Referenced by decodeHeader(), and HPACKDecoder().

                         {
   uint8_t byte = dbuf.peek();
   bool indexing = byte & HPACK::LITERAL_INC_INDEX.code;
   HPACKHeader header;
   uint8_t indexMask = 0x3F;  // 0011 1111
   uint8_t length = HPACK::LITERAL_INC_INDEX.prefixLength;
   if (!indexing) {
     // bool neverIndex = byte & HPACK::LITERAL_NEV_INDEX.code;
     // TODO: we need to emit this flag with the headers
     indexMask = 0x0F; // 0000 1111
     length = HPACK::LITERAL.prefixLength;
   }
   if (byte & indexMask) {
     uint64_t index;
     err_ = dbuf.decodeInteger(length, index);
     if (err_ != HPACK::DecodeError::NONE) {
       LOG(ERROR) << "Decode error decoding index err_=" << err_;
       return 0;
     }
     // validate the index
     if (!isValid(index)) {
       LOG(ERROR) << "received invalid index: " << index;
       err_ = HPACK::DecodeError::INVALID_INDEX;
       return 0;
     }
     header.name = getHeader(index).name;
   } else {
     // skip current byte
     dbuf.next();
     folly::fbstring headerName;
     err_ = dbuf.decodeLiteral(headerName);
     header.name = headerName;
     if (err_ != HPACK::DecodeError::NONE) {
       LOG(ERROR) << "Error decoding header name err_=" << err_;
       return 0;
     }
   }
   // value
   err_ = dbuf.decodeLiteral(header.value);
   if (err_ != HPACK::DecodeError::NONE) {
     LOG(ERROR) << "Error decoding header value name=" << header.name
                << " err_=" << err_;
     return 0;
   }
 
   uint32_t emittedSize = emit(header, streamingCb, emitted);
 
   if (indexing) {
     table_.add(std::move(header));
   }
 
   return emittedSize;
 }

void proxygen::HPACKDecoder::decodeStreaming	(	folly::io::Cursor &	cursor,
		uint32_t	totalBytes,
		HPACK::StreamingCallback *	streamingCb
	)

given a Cursor and a total amount of bytes we can consume from it, decode headers and invoke a callback.

Definition at line 21 of file HPACKDecoder.cpp.

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

Referenced by proxygen::hpack::decode(), proxygen::HPACKCodec::decodeStreaming(), encodeDecode(), and HPACKDecoder().

                                          {
   HPACKDecodeBuffer dbuf(cursor, totalBytes, maxUncompressed_);
   uint32_t emittedSize = 0;
 
   while (!hasError() && !dbuf.empty()) {
     emittedSize += decodeHeader(dbuf, streamingCb, nullptr);
 
     if (emittedSize > maxUncompressed_) {
       LOG(ERROR) << "exceeded uncompressed size limit of "
                  << maxUncompressed_ << " bytes";
       err_ = HPACK::DecodeError::HEADERS_TOO_LARGE;
       break;
     }
     emittedSize += 2;
   }
 
   completeDecode(HeaderCodec::Type::HPACK, streamingCb, dbuf.consumedBytes(),
                  emittedSize);
 }

bool proxygen::HPACKDecoder::isValid ( uint32_t index )

private

Definition at line 122 of file HPACKDecoder.cpp.

References proxygen::HPACKContext::getStaticTable(), proxygen::HPACKContext::globalToDynamicIndex(), proxygen::HPACKContext::globalToStaticIndex(), proxygen::HPACKContext::isStatic(), proxygen::HeaderTable::isValid(), and proxygen::HPACKContext::table_.

Referenced by decodeIndexedHeader(), decodeLiteralHeader(), and HPACKDecoder().

                                          {
   if (isStatic(index)) {
     return getStaticTable().isValid(globalToStaticIndex(index));
   } else {
     return table_.isValid(globalToDynamicIndex(index));
   }
 }

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

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

Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation