QPACKHeaderTable.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2015-present, Facebook, Inc.
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  LICENSE file in the root directory of this source tree. An additional grant
 *  of patent rights can be found in the PATENTS file in the same directory.
 *
 */
#pragma once

#include <proxygen/lib/http/codec/compress/HPACKHeader.h>
#include <proxygen/lib/http/codec/compress/HeaderTable.h>

namespace proxygen {

class QPACKHeaderTable : public HeaderTable {
 public:
  enum {
    UNACKED = std::numeric_limits<uint32_t>::max()
  };

  QPACKHeaderTable(uint32_t capacityVal, bool trackReferences);

  ~QPACKHeaderTable() {}
  QPACKHeaderTable(const QPACKHeaderTable&) = delete;
  QPACKHeaderTable& operator=(const QPACKHeaderTable&) = delete;

  uint32_t getBaseIndex() const {
    return baseIndex_;
  }

  bool isVulnerable(uint32_t absIndex) const {
    return (absIndex > maxAcked_);
  }

  bool canIndex(const HPACKHeader& header) {
    auto totalBytes = bytes_ + header.bytes();
    // Don't index headers that would immediately be drained
    return ((header.bytes() <= (capacity_ - minFree_)) &&
            (totalBytes <= capacity_ || canEvict(totalBytes - capacity_)));
  }

  bool isDraining(uint32_t relativeIndex) {
    return relativeToAbsolute(relativeIndex) < minUsable_;
  }

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

  bool add(HPACKHeader header) override;

  bool setCapacity(uint32_t capacity) override;

  uint32_t getIndex(const HPACKHeader& header,
                    bool allowVulnerable = true) const;

  const HPACKHeader& getHeader(uint32_t index, uint32_t base = 0) const;

  bool isValid(uint32_t index, uint32_t base = 0) const;

  uint32_t nameIndex(const HPACKHeaderName& headerName,
                     bool allowVulnerable = true) const;

  bool onTableStateSync(uint32_t inserts) {
    // compare this way to avoid overflow
    if (inserts > baseIndex_ ||
        maxAcked_ > baseIndex_ - inserts) {
      LOG(ERROR) << "Decoder ack'd too much maxAcked_="
                 << maxAcked_ << " baseIndex_=" << baseIndex_
                 << " inserts=" << inserts;
      return false;
    }
    maxAcked_ += inserts;
    CHECK_LE(maxAcked_, baseIndex_);
    return true;
  }

  void setMaxAcked(uint32_t maxAcked) {
    if (maxAcked < maxAcked_) {
      return;
    }
    CHECK_LE(maxAcked, baseIndex_);
    maxAcked_ = maxAcked;
  }

  uint32_t relativeToAbsolute(uint32_t relativeIndex) const {
    DCHECK(isValid(relativeIndex, 0));
    return baseIndex_ - relativeIndex + 1;
  }

  uint32_t absoluteToRelative(uint32_t absIndex) const {
    CHECK_LE(absIndex, baseIndex_);
    return baseIndex_ - absIndex + 1;
  }

  void addRef(uint32_t absIndex);

  void subRef(uint32_t absIndex);

 private:
  /*
   * Shared implementation for getIndex and nameIndex
   */
  uint32_t getIndexImpl(const HPACKHeaderName& header,
                        const folly::fbstring& value,
                        bool nameOnly,
                        bool allowVulnerable=true) const;

  /*
   * Increase table length to newLength
   */
  void increaseTableLengthTo(uint32_t newLength) override;

  void resizeTable(uint32_t newLength) override;

  void updateResizedTable(uint32_t oldTail, uint32_t oldLength,
                          uint32_t newLength) override;
  uint32_t removeLast() override;

  bool canEvict(uint32_t needed);

  uint32_t evict(uint32_t needed, uint32_t desiredCapacity) override;

  uint32_t toInternal(uint32_t externalIndex, uint32_t base) const;


  uint32_t internalToAbsolute(uint32_t internalIndex) const;
  uint32_t absoluteToInternal(uint32_t absoluteIndex) const;

  uint32_t baseIndex_{0};
  uint32_t drainedBytes_{0};
  uint32_t minUsable_{1};
  uint32_t maxAcked_{0};
  std::unique_ptr<std::vector<uint16_t>> refCount_;
  uint32_t minFree_{0};
};

}