proxygen: proxygen::HPACKDecodeBuffer Class Reference

#include <HPACKDecodeBuffer.h>

Public Member Functions
	HPACKDecodeBuffer (folly::io::Cursor &cursorVal, uint32_t totalBytes, uint32_t maxLiteralSize)

	~HPACKDecodeBuffer ()

void	reset (folly::io::Cursor &cursorVal)

void	reset (folly::io::Cursor &cursorVal, uint32_t totalBytes)

uint32_t	consumedBytes () const

const folly::io::Cursor &	cursor () const

bool	empty ()

uint8_t	next ()

uint8_t	peek ()

HPACK::DecodeError	decodeInteger (uint8_t nbit, uint64_t &integer)

HPACK::DecodeError	decodeInteger (uint64_t &integer)

HPACK::DecodeError	decodeLiteral (folly::fbstring &literal)

HPACK::DecodeError	decodeLiteral (uint8_t nbit, folly::fbstring &literal)

Private Attributes
folly::io::Cursor &	cursor_

uint32_t	totalBytes_

uint32_t	remainingBytes_

uint32_t	maxLiteralSize_ {std::numeric_limits<uint32_t>::max()}

Detailed Description

Definition at line 21 of file HPACKDecodeBuffer.h.

Constructor & Destructor Documentation

proxygen::HPACKDecodeBuffer::HPACKDecodeBuffer	(	folly::io::Cursor &	cursorVal,
		uint32_t	totalBytes,
		uint32_t	maxLiteralSize
	)

inlineexplicit

Definition at line 24 of file HPACKDecodeBuffer.h.

       : cursor_(cursorVal),
         totalBytes_(totalBytes),
         remainingBytes_(totalBytes),
         maxLiteralSize_(maxLiteralSize) {}

proxygen::HPACKDecodeBuffer::~HPACKDecodeBuffer ( )

inline

Definition at line 32 of file HPACKDecodeBuffer.h.

32 {}

Member Function Documentation

uint32_t proxygen::HPACKDecodeBuffer::consumedBytes ( ) const

inline

Definition at line 45 of file HPACKDecodeBuffer.h.

References remainingBytes_, and totalBytes_.

Referenced by proxygen::QPACKDecoder::decodeEncoderStreamInstruction(), proxygen::QPACKDecoder::decodeLiteralHeaderQ(), proxygen::HPACKDecoder::decodeStreaming(), and proxygen::QPACKDecoder::decodeStreamingImpl().

                                  {
     return totalBytes_ - remainingBytes_;
   }

const folly::io::Cursor& proxygen::HPACKDecodeBuffer::cursor ( ) const

inline

Definition at line 49 of file HPACKDecodeBuffer.h.

References cursor_, decodeInteger(), decodeLiteral(), empty(), next(), peek(), uint64_t, and uint8_t.

                                       {
     return cursor_;
   }

DecodeError proxygen::HPACKDecodeBuffer::decodeInteger	(	uint8_t	nbit,
		uint64_t &	integer
	)

decode an integer from the current position, given a nbit prefix. Ignores 8 - nbit bits in the first byte of the buffer.

Definition at line 101 of file HPACKDecodeBuffer.cpp.

References add, proxygen::ERROR, f, max, proxygen::HPACK::NBIT_MASKS, next(), proxygen::NONE, remainingBytes_, uint32_t, uint64_t, and uint8_t.

Referenced by cursor(), proxygen::QPACKEncoder::decodeHeaderAck(), proxygen::HPACKDecoder::decodeIndexedHeader(), proxygen::QPACKDecoder::decodeIndexedHeaderQ(), decodeInteger(), decodeLiteral(), proxygen::HPACKDecoder::decodeLiteralHeader(), proxygen::QPACKDecoder::decodeLiteralHeaderQ(), proxygen::QPACKDecoder::handleBaseIndex(), and proxygen::HPACKDecoderBase::handleTableSizeUpdate().

                                                                             {
   if (remainingBytes_ == 0) {
     LOG(ERROR) << "remainingBytes_ == 0";
     return DecodeError::BUFFER_UNDERFLOW;
   }
   uint8_t byte = next();
   uint8_t mask = HPACK::NBIT_MASKS[nbit];
   // remove the first (8 - nbit) bits
   byte = byte & mask;
   integer = byte;
   if (byte != mask) {
     // the value fit in one byte
     return DecodeError::NONE;
   }
   uint64_t f = 1;
   uint32_t fexp = 0;
   do {
     if (remainingBytes_ == 0) {
       LOG(ERROR) << "remainingBytes_ == 0";
       return DecodeError::BUFFER_UNDERFLOW;
     }
     byte = next();
     if (fexp > 64) {
       // overflow in factorizer, f > 2^64
       LOG(ERROR) << "overflow fexp=" << fexp;
       return DecodeError::INTEGER_OVERFLOW;
     }
     uint64_t add = (byte & 127) * f;
     if (std::numeric_limits<uint64_t>::max() - integer < add) {
       // overflow detected
       LOG(ERROR) << "overflow integer=" << integer << " add=" << add;
       return DecodeError::INTEGER_OVERFLOW;
     }
     integer += add;
     f = f << 7;
     fexp += 7;
   } while (byte & 128);
   return DecodeError::NONE;
 }

DecodeError proxygen::HPACKDecodeBuffer::decodeInteger ( uint64_t & integer )

As above but with no prefix

Definition at line 97 of file HPACKDecodeBuffer.cpp.

References decodeInteger().

                                                               {
   return decodeInteger(8, integer);
 }

DecodeError proxygen::HPACKDecodeBuffer::decodeLiteral ( folly::fbstring & literal )

decode a literal starting from the current position

Definition at line 44 of file HPACKDecodeBuffer.cpp.

Referenced by cursor(), proxygen::HPACKDecoder::decodeLiteralHeader(), and proxygen::QPACKDecoder::decodeLiteralHeaderQ().

                                                                    {
   return decodeLiteral(7, literal);
 }

DecodeError proxygen::HPACKDecodeBuffer::decodeLiteral	(	uint8_t	nbit,
		folly::fbstring &	literal
	)

Definition at line 48 of file HPACKDecodeBuffer.cpp.

References folly::basic_fbstring< E, T, A, Storage >::append(), folly::basic_fbstring< E, T, A, Storage >::clear(), cursor_, data, folly::io::detail::CursorBase< Derived, BufType >::data(), folly::IOBuf::data(), decodeInteger(), proxygen::ERROR, proxygen::huffman::huffTree(), folly::io::detail::CursorBase< Derived, BufType >::length(), maxLiteralSize_, proxygen::NONE, peek(), folly::io::detail::CursorBase< Derived, BufType >::pull(), remainingBytes_, folly::size(), folly::io::detail::CursorBase< Derived, BufType >::skip(), uint64_t, uint8_t, and folly::IOBuf::writableData().

                                                                      {
   literal.clear();
   if (remainingBytes_ == 0) {
     LOG(ERROR) << "remainingBytes_ == 0";
     return DecodeError::BUFFER_UNDERFLOW;
   }
   auto byte = peek();
   uint8_t huffmanCheck = uint8_t(1 << nbit);
   bool huffman = byte & huffmanCheck;
   // extract the size
   uint64_t size;
   DecodeError result = decodeInteger(nbit, size);
   if (result != DecodeError::NONE) {
     LOG(ERROR) << "Could not decode literal size";
     return result;
   }
   if (size > remainingBytes_) {
     LOG(ERROR) << "size > remainingBytes_ decoding literal size="
                << size << " remainingBytes_=" << remainingBytes_;
     return DecodeError::BUFFER_UNDERFLOW;
   }
   if (size > maxLiteralSize_) {
     LOG(ERROR) << "Literal too large, size=" << size;
     return DecodeError::LITERAL_TOO_LARGE;
   }
   const uint8_t* data;
   unique_ptr<IOBuf> tmpbuf;
   // handle the case where the buffer spans multiple buffers
   if (cursor_.length() >= size) {
     data = cursor_.data();
     cursor_.skip(size);
   } else {
     // temporary buffer to pull the chunks together
     tmpbuf = IOBuf::create(size);
     // pull() will move the cursor
     cursor_.pull(tmpbuf->writableData(), size);
     data = tmpbuf->data();
   }
   if (huffman) {
     static auto& huffmanTree = huffman::huffTree();
     huffmanTree.decode(data, size, literal);
   } else {
     literal.append((const char *)data, size);
   }
   remainingBytes_ -= size;
   return DecodeError::NONE;
 }

bool proxygen::HPACKDecodeBuffer::empty ( )

Returns: true if there are no more bytes to decode. Calling this method might move the cursor from the current IOBuf to the next one

Definition at line 22 of file HPACKDecodeBuffer.cpp.

References remainingBytes_.

Referenced by cursor(), proxygen::HPACKDecoder::decodeStreaming(), proxygen::QPACKDecoder::decodeStreamingImpl(), and proxygen::QPACKDecoder::handleBaseIndex().

                               {
   return remainingBytes_ == 0;
 }

uint8_t proxygen::HPACKDecodeBuffer::next ( )

extracts one byte from the buffer and advances the cursor

Definition at line 26 of file HPACKDecodeBuffer.cpp.

References cursor_, peek(), remainingBytes_, folly::io::detail::CursorBase< Derived, BufType >::skip(), and uint8_t.

Referenced by cursor(), decodeInteger(), and proxygen::HPACKDecoder::decodeLiteralHeader().

                                 {
   CHECK_GT(remainingBytes_, 0);
   // in case we are the end of an IOBuf, peek() will move to the next one
   uint8_t byte = peek();
   cursor_.skip(1);
   remainingBytes_--;
 
   return byte;
 }

uint8_t proxygen::HPACKDecodeBuffer::peek ( )

just peeks at the next available byte without moving the cursor

Definition at line 36 of file HPACKDecodeBuffer.cpp.

References cursor_, folly::io::detail::CursorBase< Derived, BufType >::data(), folly::io::detail::CursorBase< Derived, BufType >::length(), folly::io::detail::CursorBase< Derived, BufType >::peek(), and remainingBytes_.

Referenced by cursor(), proxygen::QPACKDecoder::decodeEncoderStreamInstruction(), proxygen::HPACKDecoder::decodeHeader(), proxygen::QPACKDecoder::decodeHeaderQ(), proxygen::QPACKDecoder::decodeIndexedHeaderQ(), decodeLiteral(), proxygen::HPACKDecoder::decodeLiteralHeader(), proxygen::QPACKDecoder::decodeLiteralHeaderQ(), proxygen::QPACKDecoder::handleBaseIndex(), and next().

                                 {
   CHECK_GT(remainingBytes_, 0);
   if (cursor_.length() == 0) {
     cursor_.peek();
   }
   return *cursor_.data();
 }

void proxygen::HPACKDecodeBuffer::reset ( folly::io::Cursor & cursorVal )

inline

Definition at line 34 of file HPACKDecodeBuffer.h.

References folly::io::detail::CursorBase< Derived, BufType >::totalLength().

                                        {
     reset(cursorVal, folly::to<uint32_t>(cursorVal.totalLength()));
   }

void proxygen::HPACKDecodeBuffer::reset	(	folly::io::Cursor &	cursorVal,
		uint32_t	totalBytes
	)

inline

Definition at line 38 of file HPACKDecodeBuffer.h.

References cursor_, remainingBytes_, and totalBytes_.

                                   {
     cursor_ = cursorVal;
     totalBytes_ = totalBytes;
     remainingBytes_ = totalBytes;
   }

Member Data Documentation

folly::io::Cursor& proxygen::HPACKDecodeBuffer::cursor_

private

Definition at line 88 of file HPACKDecodeBuffer.h.

Referenced by cursor(), decodeLiteral(), next(), peek(), and reset().

uint32_t proxygen::HPACKDecodeBuffer::maxLiteralSize_ {std::numeric_limits<uint32_t>::max()}

private

Definition at line 91 of file HPACKDecodeBuffer.h.

Referenced by decodeLiteral().

uint32_t proxygen::HPACKDecodeBuffer::remainingBytes_

private

Definition at line 90 of file HPACKDecodeBuffer.h.

Referenced by consumedBytes(), decodeInteger(), decodeLiteral(), empty(), next(), peek(), and reset().

uint32_t proxygen::HPACKDecodeBuffer::totalBytes_

private

Definition at line 89 of file HPACKDecodeBuffer.h.

Referenced by consumedBytes(), and reset().

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

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

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation