SPDYCodec.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 <bitset>
#include <folly/Optional.h>
#include <deque>
#include <proxygen/lib/http/HTTPHeaders.h>
#include <proxygen/lib/http/codec/HTTPCodec.h>
#include <proxygen/lib/http/codec/HTTPParallelCodec.h>
#include <proxygen/lib/http/codec/HTTPSettings.h>
#include <proxygen/lib/http/codec/SPDYConstants.h>
#include <proxygen/lib/http/codec/SPDYVersionSettings.h>
#include <proxygen/lib/http/codec/compress/HPACKCodec.h>
#include <proxygen/lib/http/codec/compress/GzipHeaderCodec.h>
#include <zlib.h>

namespace folly { namespace io {
class Cursor;
}}

namespace proxygen {

class SPDYCodec: public HTTPParallelCodec {
public:
  static const StreamID NoStream = 0;

  explicit SPDYCodec(TransportDirection direction,
                     SPDYVersion version,
                     int spdyCompressionLevel = Z_NO_COMPRESSION);
  ~SPDYCodec() override;

  static const SPDYVersionSettings& getVersionSettings(SPDYVersion version);

  // HTTPCodec API
  CodecProtocol getProtocol() const override;
  const std::string& getUserAgent() const override;
  bool supportsStreamFlowControl() const override;
  bool supportsSessionFlowControl() const override;
  size_t onIngress(const folly::IOBuf& buf) override;
  bool supportsPushTransactions() const override { return true; }
  void generateHeader(folly::IOBufQueue& writeBuf,
                      StreamID stream,
                      const HTTPMessage& msg,
                      bool eom = false,
                      HTTPHeaderSize* size = nullptr) override;
  void generatePushPromise(folly::IOBufQueue& writeBuf,
                           StreamID stream,
                           const HTTPMessage& msg,
                           StreamID assocstream,
                           bool eom = false,
                           HTTPHeaderSize* size = nullptr) override;
  size_t generateBody(folly::IOBufQueue& writeBuf,
                      StreamID stream,
                      std::unique_ptr<folly::IOBuf> chain,
                      folly::Optional<uint8_t> padding,
                      bool eom) override;
  size_t generateChunkHeader(folly::IOBufQueue& writeBuf,
                             StreamID stream,
                             size_t length) override;
  size_t generateChunkTerminator(folly::IOBufQueue& writeBuf,
                                 StreamID stream) override;
  size_t generateTrailers(folly::IOBufQueue& writeBuf,
                          StreamID stream,
                          const HTTPHeaders& trailers) override;
  size_t generateEOM(folly::IOBufQueue& writeBuf,
                     StreamID stream) override;
  size_t generateRstStream(folly::IOBufQueue& writeBuf,
                           StreamID txn,
                           ErrorCode statusCode) override;
  size_t generateGoaway(
    folly::IOBufQueue& writeBuf,
    StreamID lastStream,
    ErrorCode statusCode,
    std::unique_ptr<folly::IOBuf> debugData = nullptr) override;
  size_t generatePingRequest(folly::IOBufQueue& writeBuf) override;
  size_t generatePingReply(folly::IOBufQueue& writeBuf,
                           uint64_t uniqueID) override;
  size_t generateSettings(folly::IOBufQueue& writeBuf) override;
  size_t generateWindowUpdate(folly::IOBufQueue& writeBuf,
                              StreamID stream,
                              uint32_t delta) override;

  const HTTPSettings* getIngressSettings() const override {
    return &ingressSettings_;
  }
  HTTPSettings* getEgressSettings() override { return &egressSettings_; }
  uint32_t getDefaultWindowSize() const override {
    return spdy::kInitialWindow;
  }

  uint8_t getVersion() const;

  uint8_t getMinorVersion() const;

  void setMaxFrameLength(uint32_t maxFrameLength);

  void setMaxUncompressedHeaders(uint32_t maxUncompressed);

  void setHeaderCodecStats(HeaderCodec::Stats* stats) override {
    headerCodec_.setStats(stats);
  }

  size_t addPriorityNodes(
      PriorityQueue& queue,
      folly::IOBufQueue& writeBuf,
      uint8_t maxLevel) override;

  StreamID mapPriorityToDependency(uint8_t priority) const override {
    return MAX_STREAM_ID + priority;
  }

  int8_t mapDependencyToPriority(StreamID parent) const override {
    if (parent >= MAX_STREAM_ID) {
      return parent - MAX_STREAM_ID;
    }
    return -1;
  }

  struct SettingData {
    SettingData(uint8_t inFlags, uint32_t inId, uint32_t inValue)
        : flags(inFlags),
          id(inId),
          value(inValue) {}
    uint8_t flags;
    uint32_t id;
    uint32_t value;
  };

  using SettingList = std::vector<SettingData>;

  static folly::Optional<SPDYVersion> getVersion(const std::string& protocol);

 private:

  void generateSynStream(StreamID stream,
                         StreamID assocStream,
                         folly::IOBufQueue& writeBuf,
                         const HTTPMessage& msg,
                         bool eom,
                         HTTPHeaderSize* size);
  void generateSynReply(StreamID stream,
                        folly::IOBufQueue& writeBuf,
                        const HTTPMessage& msg,
                        bool eom,
                        HTTPHeaderSize* size);

  size_t generatePingCommon(folly::IOBufQueue& writeBuf,
                            uint64_t uniqueID);
  size_t parseIngress(const folly::IOBuf& buf);

  void onSynStream(uint32_t assocStream,
                   uint8_t pri, uint8_t slot,
                   const compress::HeaderPieceList& headers,
                   const HTTPHeaderSize& size);
  void onSynReply(const compress::HeaderPieceList& headers,
                  const HTTPHeaderSize& size);
  void onRstStream(uint32_t statusCode) noexcept;
  void onSettings(const SettingList& settings);

  void onPing(uint32_t uniqueID) noexcept;

  void onGoaway(uint32_t lastGoodStream,
                uint32_t statusCode) noexcept;
  void onHeaders(const compress::HeaderPieceList& headers) noexcept;

  void onWindowUpdate(uint32_t delta) noexcept;

  // Helpers

  std::unique_ptr<HTTPMessage> parseHeaders(
    TransportDirection direction, StreamID streamID,
    StreamID assocStreamID, const compress::HeaderPieceList& headers);

  void onControlFrame(folly::io::Cursor& cursor);

  void onSynCommon(StreamID streamID,
                   StreamID assocStreamID,
                   const compress::HeaderPieceList& headers,
                   int8_t pri,
                   const HTTPHeaderSize& size);

  void deliverOnMessageBegin(StreamID streamID, StreamID assocStreamID,
                             HTTPMessage* msg);

  size_t generateDataFrame(folly::IOBufQueue& writeBuf,
                           uint32_t streamID,
                           uint8_t flags,
                           uint32_t length,
                           std::unique_ptr<folly::IOBuf> payload);

  std::unique_ptr<folly::IOBuf> serializeRequestHeaders(
    const HTTPMessage& msg,
    bool isPushed,
    uint32_t headroom = 0,
    HTTPHeaderSize* size = nullptr);

  std::unique_ptr<folly::IOBuf> serializeResponseHeaders(
     const HTTPMessage& msg,
     uint32_t headroom = 0,
     HTTPHeaderSize* size = nullptr);

  std::unique_ptr<folly::IOBuf> encodeHeaders(
    const HTTPMessage& msg, std::vector<compress::Header>& headers,
    uint32_t headroom = 0,
    HTTPHeaderSize* size = nullptr);

  void failStream(bool newTxn, StreamID streamID, uint32_t code,
                  std::string excStr = empty_string);

  void failSession(uint32_t statusCode);

  HeaderDecodeResult decodeHeaders(folly::io::Cursor& cursor);

  void checkLength(uint32_t expectedLength, const std::string& msg);

  void checkMinLength(uint32_t minLength, const std::string& msg);

  bool isSPDYReserved(const std::string& name);

  bool rstStatusSupported(int statusCode) const;

  folly::fbvector<StreamID> closedStreams_;
  const SPDYVersionSettings& versionSettings_;

  HTTPSettings ingressSettings_{
    {SettingsId::MAX_CONCURRENT_STREAMS, spdy::kMaxConcurrentStreams},
    {SettingsId::INITIAL_WINDOW_SIZE, spdy::kInitialWindow}
  };
  HTTPSettings egressSettings_{
    {SettingsId::MAX_CONCURRENT_STREAMS, spdy::kMaxConcurrentStreams},
    {SettingsId::INITIAL_WINDOW_SIZE, spdy::kInitialWindow}
  };

  std::unique_ptr<HTTPMessage> partialMsg_;
  std::string userAgent_;
  const folly::IOBuf* currentIngressBuf_{nullptr};

  StreamID nextEgressPingID_;
  // StreamID's are 31 bit unsigned integers, so all received goaways will
  // be lower than this.

  uint32_t maxFrameLength_{spdy::kMaxFrameLength};
  uint32_t streamId_{0};
  uint32_t length_{0};
  uint16_t version_{0};
  uint16_t type_{0xffff};
  uint8_t flags_{0};

  // SPDY Frame parsing state
  enum FrameState {
    FRAME_HEADER = 0,
    CTRL_FRAME_DATA = 1,
    DATA_FRAME_DATA = 2,
  } frameState_:2;

  bool ctrl_:1;

  GzipHeaderCodec headerCodec_;
};

} // proxygen