proxygen::GzipHeaderCodec Class Reference

#include <GzipHeaderCodec.h>

Inheritance diagram for proxygen::GzipHeaderCodec:

Public Member Functions
	GzipHeaderCodec (int compressionLevel, const SPDYVersionSettings &versionSettings)
	GzipHeaderCodec (int compressionLevel, SPDYVersion version=SPDYVersion::SPDY3_1)
	~GzipHeaderCodec () override
std::unique_ptr< folly::IOBuf >	encode (std::vector< compress::Header > &headers) noexcept
folly::Expected< HeaderDecodeResult, GzipDecodeError >	decode (folly::io::Cursor &cursor, uint32_t length) noexcept
const HTTPHeaderSize &	getDecodedSize ()
Public Member Functions inherited from proxygen::HeaderCodec
	HeaderCodec ()
virtual	~HeaderCodec ()
const HTTPHeaderSize &	getEncodedSize ()
void	setEncodeHeadroom (uint32_t headroom)
virtual void	setMaxUncompressed (uint64_t maxUncompressed)
uint64_t	getMaxUncompressed () const
void	setStats (Stats *stats)

Private Member Functions
folly::IOBuf &	getHeaderBuf ()
folly::Expected< size_t, GzipDecodeError >	parseNameValues (const folly::IOBuf &uncompressed, uint32_t uncompressedLength) noexcept

Private Attributes
const SPDYVersionSettings &	versionSettings_
z_stream	deflater_
z_stream	inflater_
compress::HeaderPieceList	outHeaders_
HTTPHeaderSize	decodedSize_

Additional Inherited Members
Public Types inherited from proxygen::HeaderCodec
enum	Type : uint8_t { Type::GZIP = 0, Type::HPACK = 1, Type::QPACK = 2 }
Static Public Attributes inherited from proxygen::HeaderCodec
static const uint32_t	kMaxUncompressed = 128 * 1024
Protected Attributes inherited from proxygen::HeaderCodec
HTTPHeaderSize	encodedSize_
uint32_t	encodeHeadroom_ {0}
uint64_t	maxUncompressed_ {kMaxUncompressed}
Stats *	stats_ {nullptr}

Detailed Description

Definition at line 34 of file GzipHeaderCodec.h.

Constructor & Destructor Documentation

proxygen::GzipHeaderCodec::GzipHeaderCodec	(	int	compressionLevel,
		const SPDYVersionSettings &	versionSettings
	)

Definition at line 156 of file GzipHeaderCodec.cpp.

References context, deflater_, and inflater_.

    : versionSettings_(versionSettings) {
  // Create compression and decompression contexts by cloning thread-local
  // copies of the initial SPDY compression state
  auto context = getZlibContext(versionSettings, compressionLevel);
  deflateCopy(&deflater_, const_cast<z_stream*>(&(context->deflater)));
  inflateCopy(&inflater_, const_cast<z_stream*>(&(context->inflater)));
}

proxygen::GzipHeaderCodec::GzipHeaderCodec ( int  compressionLevel, SPDYVersion  version = SPDYVersion::SPDY3_1  )

explicit

Definition at line 166 of file GzipHeaderCodec.cpp.

    : GzipHeaderCodec(
        compressionLevel,
        SPDYCodec::getVersionSettings(version)) {}

proxygen::GzipHeaderCodec::~GzipHeaderCodec ( )

override

Definition at line 172 of file GzipHeaderCodec.cpp.

References deflater_, and inflater_.

                                  {
  deflateEnd(&deflater_);
  inflateEnd(&inflater_);
}

Member Function Documentation

folly::Expected< HeaderDecodeResult, GzipDecodeError > proxygen::GzipHeaderCodec::decode ( folly::io::Cursor &  cursor, uint32_t  length  )

noexcept

Definition at line 291 of file GzipHeaderCodec.cpp.

References proxygen::BAD_ENCODING, wangle::HTTPHeaderSize::compressed, decodedSize_, proxygen::SPDYVersionSettings::dict, proxygen::SPDYVersionSettings::dictSize, proxygen::ERROR, getHeaderBuf(), proxygen::HeaderCodec::GZIP, proxygen::HEADERS_TOO_LARGE, if(), proxygen::INFLATE_DICTIONARY, inflater_, folly::makeUnexpected(), proxygen::HeaderCodec::maxUncompressed_, min, cpp.ast::next(), outHeaders_, parseNameValues(), proxygen::HeaderCodec::Stats::recordDecode(), proxygen::HeaderCodec::stats_, uint32_t, uint8_t, wangle::HTTPHeaderSize::uncompressed, UNLIKELY, and versionSettings_.

Referenced by proxygen::SPDYCodec::decodeHeaders().

                                                                {
  outHeaders_.clear();

  // empty header block
  if (length == 0) {
    return HeaderDecodeResult{outHeaders_, 0};
  }

  // Get the thread local buffer space to use
  auto& uncompressed = getHeaderBuf();
  uint32_t consumed = 0;
  // Decompress the headers
  while (length > 0) {
    auto next = cursor.peek();
    uint32_t chunkLen = std::min((uint32_t)next.second, length);
    inflater_.avail_in = chunkLen;
    inflater_.next_in = (uint8_t *)next.first;
    do {
      if (uncompressed.tailroom() == 0) {
        // This code should not execute, since we throw an error if the
        // decompressed size of the headers is too large and we initialize
        // the buffer to that size.
        LOG(ERROR) << "Doubling capacity of SPDY headers buffer";
        uncompressed.reserve(0, uncompressed.capacity());
      }

      inflater_.next_out = uncompressed.writableTail();
      inflater_.avail_out = uncompressed.tailroom();
      int r = inflate(&inflater_, Z_NO_FLUSH);
      if (r == Z_NEED_DICT) {
        // we cannot initialize the inflater dictionary before calling inflate()
        // as it checks the adler-32 checksum of the supplied dictionary
        r = inflateSetDictionary(&inflater_, versionSettings_.dict,
                                 versionSettings_.dictSize);
        if (r != Z_OK) {
          LOG(ERROR) << "inflate set dictionary failed with error=" << r;
          return folly::makeUnexpected(GzipDecodeError::INFLATE_DICTIONARY);
        }
        inflater_.avail_out = 0;
        continue;
      }
      if (r != 0) {
        // probably bad encoding
        LOG(ERROR) << "inflate failed with error=" << r;
        return folly::makeUnexpected(GzipDecodeError::BAD_ENCODING);
      }
      uncompressed.append(uncompressed.tailroom() - inflater_.avail_out);
      if (uncompressed.length() > maxUncompressed_) {
        LOG(ERROR) << "Decompressed headers too large";
        return folly::makeUnexpected(GzipDecodeError::HEADERS_TOO_LARGE);
      }
    } while (inflater_.avail_in > 0 && inflater_.avail_out == 0);
    length -= chunkLen;
    consumed += chunkLen;
    cursor.skip(chunkLen);
  }

  decodedSize_.compressed = consumed;
  decodedSize_.uncompressed = uncompressed.computeChainDataLength();
  if (stats_) {
    stats_->recordDecode(Type::GZIP, decodedSize_);
  }

  size_t expandedHeaderLineBytes = 0;
  auto result = parseNameValues(uncompressed, decodedSize_.uncompressed);
  if (result.hasError()) {
    return folly::makeUnexpected(result.error());
  }
  expandedHeaderLineBytes = *result;

  if (UNLIKELY(expandedHeaderLineBytes > kMaxExpandedHeaderLineBytes)) {
    LOG(ERROR) << "expanded headers too large";
    return folly::makeUnexpected(GzipDecodeError::HEADERS_TOO_LARGE);
  }

  return HeaderDecodeResult{outHeaders_, consumed};
}

unique_ptr< IOBuf > proxygen::GzipHeaderCodec::encode ( std::vector< compress::Header > &  headers )

noexcept

Definition at line 181 of file GzipHeaderCodec.cpp.

References folly::IOBuf::advance(), folly::IOBuf::append(), proxygen::SPDYVersionSettings::appendSizeFun, wangle::HTTPHeaderSize::compressed, deflater_, proxygen::empty_string, proxygen::HeaderCodec::encodedSize_, proxygen::HeaderCodec::encodeHeadroom_, getHeaderBuf(), proxygen::HeaderCodec::GZIP, proxygen::HTTP_HEADER_OTHER, folly::IOBuf::length(), proxygen::SPDYVersionSettings::nameValueSize, proxygen::HeaderCodec::Stats::recordEncode(), proxygen::HeaderCodec::stats_, folly::toLowerAscii(), uint8_t, wangle::HTTPHeaderSize::uncompressed, versionSettings_, and folly::IOBuf::writableData().

Referenced by proxygen::SPDYCodec::encodeHeaders().

                                                                          {
  // Build a sequence of the header names and values, sorted by name.
  // The purpose of the sort is to make it easier to combine the
  // values of multiple headers with the same name.  The SPDY spec
  // prohibits any header name from appearing more than once in the
  // Name/Value list, so we must combine values when serializing.
  std::sort(headers.begin(), headers.end());

  auto& uncompressed = getHeaderBuf();
  // Compute the amount of space needed to hold the uncompressed
  // representation of the headers.  This is an upper bound on the
  // amount of space we'll actually need, because if we end up
  // combining any headers with the same name, the combined
  // representation will be smaller than the original.
  size_t maxUncompressedSize = versionSettings_.nameValueSize;
  for (const Header& header : headers) {
    maxUncompressedSize += versionSettings_.nameValueSize;
    maxUncompressedSize += header.name->length();
    maxUncompressedSize += versionSettings_.nameValueSize;
    maxUncompressedSize += header.value->length();
  }

  // TODO: give on 'onError()' callback if the space in uncompressed buf
  // cannot fit the headers and then skip the "reserve" code below. We
  // have already reserved the maximum legal amount of space for
  // uncompressed headers.

  VLOG(5) << "reserving " << maxUncompressedSize
          << " bytes for uncompressed headers";
  uncompressed.reserve(0, maxUncompressedSize);

  // Serialize the uncompressed representation of the headers.
  uint8_t* dst = uncompressed.writableData();
  dst += versionSettings_.nameValueSize; // Leave space for count of headers.
  HTTPHeaderCode lastCode = HTTP_HEADER_OTHER;
  const string* lastName = &empty_string;
  uint8_t* lastValueLenPtr = nullptr;
  size_t lastValueLen = 0;
  unsigned numHeaders = 0;
  for (const Header& header : headers) {
    if ((header.code != lastCode) || (*header.name != *lastName)) {
      // Simple case: this header name is different from the previous
      // one, so we don't need to combine values.
      numHeaders++;
      versionSettings_.appendSizeFun(dst, header.name->length());

      // lowercasing the header name inline
      char* nameBegin = (char *)dst;
      appendString(dst, *header.name);
      folly::toLowerAscii((char *)nameBegin, header.name->size());

      lastValueLenPtr = dst;
      lastValueLen = header.value->length();
      versionSettings_.appendSizeFun(dst, header.value->length());
      appendString(dst, *header.value);
      lastCode = header.code;
      lastName = header.name;
    } else if (header.value->length() > 0) {
      // More complicated case: we do need to combine values.
      if (lastValueLen > 0) {
        // Only nul terminate if previous value was non-empty
        *dst++ = 0;  // SPDY uses a null byte as a separator
        lastValueLen++;
      }
      appendString(dst, *header.value);
      // Go back and rewrite the length field in front of the value
      lastValueLen += header.value->length();
      uint8_t* tmp = lastValueLenPtr;
      versionSettings_.appendSizeFun(tmp, lastValueLen);
    }
  }

  // Compute the uncompressed length; if we combined any header values,
  // we will have used less space than originally estimated.
  size_t uncompressedLen = dst - uncompressed.writableData();

  // Go back and write the count of unique header names at the start.
  dst = uncompressed.writableData();
  versionSettings_.appendSizeFun(dst, numHeaders);

  // Allocate a contiguous space big enough to hold the compressed headers,
  // plus any headroom requested by the caller.
  size_t maxDeflatedSize = deflateBound(&deflater_, uncompressedLen);
  unique_ptr<IOBuf> out(IOBuf::create(maxDeflatedSize + encodeHeadroom_));
  out->advance(encodeHeadroom_);

  // Compress
  deflater_.next_in = uncompressed.writableData();
  deflater_.avail_in = uncompressedLen;
  deflater_.next_out = out->writableData();
  deflater_.avail_out = maxDeflatedSize;
  int r = deflate(&deflater_, Z_SYNC_FLUSH);
  CHECK_EQ(r, Z_OK);
  CHECK_EQ(deflater_.avail_in, 0);
  out->append(maxDeflatedSize - deflater_.avail_out);

  VLOG(4) << "header size orig=" << uncompressedLen
          << ", max deflated=" << maxDeflatedSize
          << ", actual deflated=" << out->length();

  encodedSize_.compressed = out->length();
  encodedSize_.uncompressed = uncompressedLen;
  if (stats_) {
    stats_->recordEncode(Type::GZIP, encodedSize_);
  }

  return out;
}

const HTTPHeaderSize& proxygen::GzipHeaderCodec::getDecodedSize ( )

inline

same as above, but for decode

Definition at line 52 of file GzipHeaderCodec.h.

References folly::pushmi::__adl::noexcept(), and uint32_t.

Referenced by proxygen::SPDYCodec::onControlFrame().

                                         {
    return decodedSize_;
  }

folly::IOBuf & proxygen::GzipHeaderCodec::getHeaderBuf ( )

private

Definition at line 177 of file GzipHeaderCodec.cpp.

References proxygen::HeaderCodec::maxUncompressed_.

Referenced by decode(), and encode().

                                          {
  return getStaticHeaderBufSpace(maxUncompressed_);
}

folly::Expected< size_t, GzipDecodeError > proxygen::GzipHeaderCodec::parseNameValues ( const folly::IOBuf &  uncompressed, uint32_t  uncompressedLength  )

privatenoexcept

Parse the decompressed name/value header block.

Definition at line 370 of file GzipHeaderCodec.cpp.

References proxygen::BAD_ENCODING, c, data, folly::Range< Iter >::data(), proxygen::EMPTY_HEADER_NAME, proxygen::EMPTY_HEADER_VALUE, proxygen::ERROR, folly::exceptionStr(), folly::gen::first, i, proxygen::INVALID_HEADER_VALUE, folly::makeUnexpected(), proxygen::SPDYVersionSettings::nameValueSize, cpp.ast::next(), outHeaders_, proxygen::SPDYVersionSettings::parseSizeFun, folly::io::detail::CursorBase< Derived, BufType >::peek(), proxygen::IOBufPrinter::printHexFolly(), folly::io::detail::CursorBase< Derived, BufType >::pull(), folly::Range< Iter >::reset(), folly::Range< Iter >::size(), folly::io::detail::CursorBase< Derived, BufType >::skip(), stop(), proxygen::compress::HeaderPiece::str, uint32_t, and versionSettings_.

Referenced by decode().

                                                                       {

  size_t expandedHeaderLineBytes = 0;
  Cursor headerCursor(&uncompressed);
  uint32_t numNV = 0;
  const HeaderPiece* headerName = nullptr;

  try {
    numNV = versionSettings_.parseSizeFun(&headerCursor);
  } catch (const std::out_of_range& ex) {
    return folly::makeUnexpected(GzipDecodeError::BAD_ENCODING);
  }

  for (uint32_t i = 0; i < numNV * 2; i++) {
    uint32_t len = 0;
    try {
      len = versionSettings_.parseSizeFun(&headerCursor);
      uncompressedLength -= versionSettings_.nameValueSize;
    } catch (const std::out_of_range& ex) {
      return folly::makeUnexpected(GzipDecodeError::BAD_ENCODING);
    }

    if (len == 0 && !headerName) {
      LOG(ERROR) << "empty header name";
      return folly::makeUnexpected(GzipDecodeError::EMPTY_HEADER_NAME);
    }
    auto next = headerCursor.peek();
    try {
      if (len > uncompressedLength) {
        throw std::out_of_range(
          folly::to<string>("bad length=", len, " uncompressedLength=",
                            uncompressedLength));
      } else if (next.second >= len) {
        // string is contiguous, just put a pointer into the headers structure
        outHeaders_.emplace_back((char *)next.first, len, false, false);
        headerCursor.skip(len);
      } else {
        // string is not contiguous, allocate a buffer and pull into it
        unique_ptr<char[]> data (new char[len]);
        headerCursor.pull(data.get(), len);
        outHeaders_.emplace_back(data.release(), len, true, false);
      }
      uncompressedLength -= len;
    } catch (const std::out_of_range& ex) {
      LOG(ERROR) << "bad encoding for nv=" << i << ": "
                 << folly::exceptionStr(ex);
      VLOG(3) << IOBufPrinter::printHexFolly(&uncompressed, true);
      return folly::makeUnexpected(GzipDecodeError::BAD_ENCODING);
    }
    if (i % 2 == 0) {
      headerName = &outHeaders_.back();
      for (const char c: headerName->str) {
        if (c < 0x20 || c > 0x7e || ('A' <= c && c <= 'Z')) {
          LOG(ERROR) << "invalid header value";
          return folly::makeUnexpected(GzipDecodeError::INVALID_HEADER_VALUE);
        }
      }
    } else {
      HeaderPiece& headerValue = outHeaders_.back();
      bool first = true;
      const char* valueStart = headerValue.str.data();
      const char* pos = valueStart;
      const char* stop = valueStart + headerValue.str.size();
      while(pos < stop) {
        if (*pos == '\0') {
          if (pos - valueStart == 0) {
            LOG(ERROR) << "empty header value for header=" << headerName;
            return folly::makeUnexpected(GzipDecodeError::EMPTY_HEADER_VALUE);
          }
          if (first) {
            headerValue.str.reset(valueStart, pos - valueStart);
            first = false;
          } else {
            outHeaders_.emplace_back(headerName->str.data(),
                                     headerName->str.size(),
                                     false, true);
            outHeaders_.emplace_back(valueStart, pos - valueStart, false, true);
            expandedHeaderLineBytes += ((pos - valueStart) +
                                        headerName->str.size());
          }
          valueStart = pos + 1;
        }
        pos++;
      }
      if (!first) {
        // value contained at least one \0, add the last value
        if (pos - valueStart == 0) {
          LOG(ERROR) << "empty header value for header=" << headerName;
          return folly::makeUnexpected(GzipDecodeError::EMPTY_HEADER_VALUE);
        }
        outHeaders_.emplace_back(headerName->str.data(),
                                 headerName->str.size(),
                                 false, true);
        outHeaders_.emplace_back(valueStart, pos - valueStart, false, true);
        expandedHeaderLineBytes += (pos - valueStart) + headerName->str.size();
      }
      headerName = nullptr;
    }
  }
  return expandedHeaderLineBytes;
}

Member Data Documentation

HTTPHeaderSize proxygen::GzipHeaderCodec::decodedSize_

private

Definition at line 70 of file GzipHeaderCodec.h.

Referenced by decode().

z_stream proxygen::GzipHeaderCodec::deflater_

private

Definition at line 67 of file GzipHeaderCodec.h.

Referenced by encode(), GzipHeaderCodec(), and ~GzipHeaderCodec().

z_stream proxygen::GzipHeaderCodec::inflater_

private

Definition at line 68 of file GzipHeaderCodec.h.

Referenced by decode(), GzipHeaderCodec(), and ~GzipHeaderCodec().

compress::HeaderPieceList proxygen::GzipHeaderCodec::outHeaders_

private

Definition at line 69 of file GzipHeaderCodec.h.

Referenced by decode(), and parseNameValues().

const SPDYVersionSettings& proxygen::GzipHeaderCodec::versionSettings_

private

Definition at line 66 of file GzipHeaderCodec.h.

Referenced by decode(), encode(), and parseNameValues().

---

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

• proxygen/lib/http/codec/compress/GzipHeaderCodec.h
• proxygen/lib/http/codec/compress/GzipHeaderCodec.cpp