HTTPMessage.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 <array>
#include <boost/variant.hpp>
#include <folly/Conv.h>
#include <folly/Optional.h>
#include <folly/SocketAddress.h>
#include <folly/io/IOBufQueue.h>
#include <glog/logging.h>
#include <map>
#include <mutex>
#include <proxygen/lib/http/HTTPHeaderSize.h>
#include <proxygen/lib/http/HTTPHeaders.h>
#include <proxygen/lib/http/HTTPMethod.h>
#include <proxygen/lib/utils/ParseURL.h>
#include <proxygen/lib/utils/Time.h>
#include <string>

namespace proxygen {

class HTTPMessage {
 public:

  enum WebSocketUpgrade {
    NONE,
    INGRESS,
    EGRESS,
  };

  HTTPMessage();
  ~HTTPMessage();
  HTTPMessage(HTTPMessage&& message) noexcept;
  HTTPMessage(const HTTPMessage& message);
  HTTPMessage& operator=(const HTTPMessage& message);
  HTTPMessage& operator=(HTTPMessage&& message);

  // upgradeWebsocket_ can have three states, WebSocketUpgrade::NONE by
  // default. WebSocketUpgrade::INGRESS is used by the codec to indicate a
  // websocket upgrade request was received from downstream or a successful
  // upgrade finished on an upstream stream.
  // WebSocketUpgrade::EGRESS is used by the application handler to indicate
  // websocket upgrade headers should be sent with the outgoing
  // request/response. Based on upstream/downstream, the codec serializes the
  // appropriate headers.
  void setIngressWebsocketUpgrade() {
    upgradeWebsocket_ = WebSocketUpgrade::INGRESS;
  }
  void setEgressWebsocketUpgrade() {
    upgradeWebsocket_ = WebSocketUpgrade::EGRESS;
  }
  bool isIngressWebsocketUpgrade() const {
    return upgradeWebsocket_ == WebSocketUpgrade::INGRESS;
  }
  bool isEgressWebsocketUpgrade() const {
    return upgradeWebsocket_ == WebSocketUpgrade::EGRESS;
  }

  void setIsChunked(bool chunked) { chunked_ = chunked; }
  bool getIsChunked() const { return chunked_; }

  void setIsUpgraded(bool upgraded) { upgraded_ = upgraded; }
  bool getIsUpgraded() const { return upgraded_; }

  void setClientAddress(const folly::SocketAddress& addr,
                        std::string ipStr = empty_string,
                        std::string portStr = empty_string) {
    request().clientAddress_ = addr;
    if (ipStr.empty() || portStr.empty()) {
      request().clientIP_ = addr.getAddressStr();
      request().clientPort_ = folly::to<std::string>(addr.getPort());
    } else {
      request().clientIP_ = std::move(ipStr);
      request().clientPort_ = std::move(portStr);
    }
  }

  const folly::SocketAddress& getClientAddress() const {
    return request().clientAddress_;
  }

  const std::string& getClientIP() const {
    return request().clientIP_;
  }

  const std::string& getClientPort() const {
    return request().clientPort_;
  }

  void setDstAddress(const folly::SocketAddress& addr,
                     std::string addressStr = empty_string,
                     std::string portStr = empty_string) {
    dstAddress_ = addr;
    if (addressStr.empty() || portStr.empty()) {
      dstIP_ = addr.getAddressStr();
      dstPort_ = folly::to<std::string>(addr.getPort());
    } else {
      dstIP_ = std::move(addressStr);
      dstPort_ = std::move(portStr);
    }
  }

  const folly::SocketAddress& getDstAddress() const {
    return dstAddress_;
  }

  const std::string& getDstIP() const {
    return dstIP_;
  }

  const std::string& getDstPort() const {
    return dstPort_;
  }

  template <typename T> // T = string
  void setLocalIp(T&& ip) {
    localIP_ = std::forward<T>(ip);
  }
  const std::string& getLocalIp() const {
    return localIP_;
  }

  void setMethod(HTTPMethod method);
  void setMethod(folly::StringPiece method);
  void rawSetMethod(const std::string& method) {
    setMethod(method);
  }

  folly::Optional<HTTPMethod> getMethod() const;

  const std::string& getMethodString() const;

  template <typename T> // T = string
  ParseURL setURL(T&& url) {
    VLOG(9) << "setURL: " << url;

    // Set the URL, path, and query string parameters
    ParseURL u(url);
    if (u.valid()) {
      VLOG(9) << "set path: " << u.path() << " query:" << u.query();
      request().path_ = u.path().str();
      request().query_ = u.query().str();
      unparseQueryParams();
    } else {
      VLOG(4) << "Error in parsing URL: " << url;
    }

    request().url_ = std::forward<T>(url);
    return u;
  }
  // The template function above doesn't work with char*,
  // so explicitly convert to a string first.
  void setURL(const char* url) {
    setURL(std::string(url));
  }
  const std::string& getURL() const {
    return request().url_;
  }
  void rawSetURL(const std::string& url) {
    setURL(url);
  }

  const std::string& getPath() const {
    return request().path_;
  }

  const std::string& getQueryString() const {
    return request().query_;
  }

  static const std::pair<uint8_t, uint8_t> kHTTPVersion10;
  static const std::pair<uint8_t, uint8_t> kHTTPVersion11;

  void setHTTPVersion(uint8_t major, uint8_t minor);
  const std::pair<uint8_t, uint8_t>& getHTTPVersion() const;

  template <typename T> // T = string
  void setStatusMessage(T&& msg) {
    response().statusMsg_ = std::forward<T>(msg);
  }
  const std::string& getStatusMessage() const {
    return response().statusMsg_;
  }
  void rawSetStatusMessage(std::string msg) {
    setStatusMessage(msg);
  }

  const std::string& getVersionString() const {
    return versionStr_;
  }
  void setVersionString(const std::string& ver) {
    if (ver.size() != 3 ||
        ver[1] != '.' ||
        !isdigit(ver[0]) ||
        !isdigit(ver[2])) {
      return;
    }

    setHTTPVersion(ver[0] - '0', ver[2] - '0');
  }

  HTTPHeaders& getHeaders() { return headers_; }
  const HTTPHeaders& getHeaders() const { return headers_; }

  HTTPHeaders&& extractHeaders() {
    return std::move(headers_);
  }

  HTTPHeaders* getTrailers() { return trailers_.get(); }
  const HTTPHeaders* getTrailers() const { return trailers_.get(); }

  void setTrailers(std::unique_ptr<HTTPHeaders>&& trailers) {
    trailers_ = std::move(trailers);
  }

  int processMaxForwards();

  bool isHTTP1_0() const;

  bool isHTTP1_1() const;

  bool is1xxResponse() const { return (getStatusCode() / 100) == 1; }

  bool is4xxResponse() const { return (getStatusCode() / 100) == 4; }

  bool is5xxResponse() const { return (getStatusCode() / 100) == 5; }

  static std::string formatDateHeader();

  void ensureHostHeader();

  void setWantsKeepalive(bool wantsKeepaliveVal) {
    wantsKeepalive_ = wantsKeepaliveVal;
  }
  bool wantsKeepalive() const {
    return wantsKeepalive_;
  }

  bool trailersAllowed() const { return trailersAllowed_; }
  void setTrailersAllowed(bool trailersAllowedVal) {
    trailersAllowed_ = trailersAllowedVal;
  }

  bool hasTrailers() const {
    return trailersAllowed_ && trailers_ && trailers_->size() > 0;
  }

  void setStatusCode(uint16_t status);
  uint16_t getStatusCode() const;

  void setUpgradeProtocol(std::string protocol) {
    upgradeProtocol_ = std::make_unique<std::string>(std::move(protocol));
  }
  const std::string* getUpgradeProtocol() const {
    return upgradeProtocol_.get();
  }

  void setPushStatusCode(const uint16_t status);
  const std::string& getPushStatusStr() const;
  uint16_t getPushStatusCode() const;

  void constructDirectResponse(const std::pair<uint8_t, uint8_t>& version,
                               const int statusCode,
                               const std::string& statusMsg,
                               int contentLength = 0);

  void constructDirectResponse(const std::pair<uint8_t, uint8_t>& version,
                               int contentLength = 0);

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

  const std::string* getQueryParamPtr(const std::string& name) const;

  const std::string& getQueryParam(const std::string& name) const;

  int getIntQueryParam(const std::string& name) const;

  int getIntQueryParam(const std::string& name, int defval) const;

  std::string getDecodedQueryParam(const std::string& name) const;

  const std::map<std::string, std::string>& getQueryParams() const;

  bool setQueryString(const std::string& query);

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

  bool setQueryParam(const std::string& name, const std::string& value);

  const folly::StringPiece getCookie(const std::string& name) const;

  void dumpMessage(int verbosity) const;

  void describe(std::ostream& os) const;

  void atomicDumpMessage(int verbosity) const;

  void dumpMessageToSink(google::LogSink* logSink) const;

  void stripPerHopHeaders();

  const HTTPHeaders& getStrippedPerHopHeaders() const {
    return strippedPerHopHeaders_;
  }

  void setSecure(bool secure) { secure_ = secure; }
  bool isSecure() const { return secure_; }
  int getSecureVersion() const { return sslVersion_; }
  const char* getSecureCipher() const { return sslCipher_; }
  void setSecureInfo(int ver, const char* cipher) {
    // cipher is a static const char* provided and managed by openssl lib
    sslVersion_ = ver; sslCipher_ = cipher;
  }
  void setAdvancedProtocolString(const std::string& protocol) {
    protoStr_ = &protocol;
  }
  bool isAdvancedProto() const {
    return protoStr_ != nullptr;
  }
  const std::string* getAdvancedProtocolString() const {
    return protoStr_;
  }

  const std::string& getProtocolString() const {
    if (isAdvancedProto()) {
      return *protoStr_;
    }

    return versionStr_;
  }

  /* Setter and getter for the SPDY priority value (0 - 7).  When serialized
   * to SPDY/2, Codecs will collpase 0,1 -> 0, 2,3 -> 1, etc.
   *
   * Negative values of pri are interpreted much like negative array
   * indexes in python, so -1 will be the largest numerical priority
   * value for this SPDY version (i.e. 3 for SPDY/2 or 7 for SPDY/3),
   * -2 the second largest (i.e. 2 for SPDY/2 or 6 for SPDY/3).
   */
  const static int8_t kMaxPriority;

  static uint8_t normalizePriority(int8_t pri) {
    if (pri > kMaxPriority || pri < -kMaxPriority) {
      // outside [-7, 7] => highest priority
      return kMaxPriority;
    } else if (pri < 0) {
      return pri + kMaxPriority + 1;
    }
    return pri;
  }

  void setPriority(int8_t pri) {
    pri_ = normalizePriority(pri);
    h2Pri_ = folly::none;
  }
  uint8_t getPriority() const { return pri_; }

  using HTTPPriority = std::tuple<uint32_t, bool, uint8_t>;

  folly::Optional<HTTPPriority> getHTTP2Priority()
    const {
    return h2Pri_;
  }

  void setHTTP2Priority(HTTPPriority h2Pri) {
    h2Pri_ = h2Pri;
  }

  void setSeqNo(int32_t seqNo) { seqNo_ = seqNo; }
  int32_t getSeqNo() const { return seqNo_; }

  void setIngressHeaderSize(const HTTPHeaderSize& size) {
    size_ = size;
  }
  const HTTPHeaderSize& getIngressHeaderSize() const {
    return size_;
  }

  TimePoint getStartTime() const { return startTime_; }
  void setStartTime(const TimePoint& startTime) { startTime_ = startTime; }

  bool checkForHeaderToken(const HTTPHeaderCode headerCode,
                           char const* token,
                           bool caseSensitive) const;

  void unparseCookies() const;

  static const char* getDefaultReason(uint16_t status);

  bool computeKeepalive() const;

  bool isRequest() const {
    return fields_.which() == 1;
  }

  bool isResponse() const {
    return fields_.which() == 2;
  }

  static void splitNameValuePieces(
      const std::string& input,
      char pairDelim,
      char valueDelim,
      std::function<void(folly::StringPiece, folly::StringPiece)> callback);

  static void splitNameValue(
      const std::string& input,
      char pairDelim,
      char valueDelim,
      std::function<void(std::string&&, std::string&&)> callback);

  static std::string createUrl(const folly::StringPiece scheme,
                               const folly::StringPiece authority,
                               const folly::StringPiece path,
                               const folly::StringPiece query,
                               const folly::StringPiece fragment);

  static std::string createQueryString(
      const std::map<std::string, std::string>& params, uint32_t maxSize);

 protected:
  // Message start time, in msec since the epoch.
  TimePoint startTime_;
  int32_t seqNo_;

 private:

  void parseCookies() const;

  void parseQueryParams() const;
  void unparseQueryParams();

  bool doHeaderTokenCheck(const HTTPHeaders& headers_,
                          const HTTPHeaderCode headerCode,
                          char const* token,
                          bool caseSensitive) const;

  static folly::StringPiece trim(folly::StringPiece sp);

  struct Request {
    folly::SocketAddress clientAddress_;
    std::string clientIP_;
    std::string clientPort_;
    mutable boost::variant<boost::blank, std::string, HTTPMethod> method_;
    std::string path_;
    std::string query_;
    std::string url_;

    uint16_t pushStatus_;
    std::string pushStatusStr_;
  };

  struct Response {
    uint16_t status_;
    std::string statusStr_;
    std::string statusMsg_;
  };

  folly::SocketAddress dstAddress_;
  std::string dstIP_;
  std::string dstPort_;

  std::string localIP_;
  std::string versionStr_;

  mutable boost::variant<boost::blank, Request, Response> fields_;

  Request& request() {
    DCHECK(fields_.which() == 0 || fields_.which() == 1) << fields_.which();
    if (fields_.which() == 0) {
      fields_ = Request();
    }

    return boost::get<Request>(fields_);
  }

  const Request& request() const {
    DCHECK(fields_.which() == 0 || fields_.which() == 1) << fields_.which();
    if (fields_.which() == 0) {
      fields_ = Request();
    }

    return boost::get<const Request>(fields_);
  }

  Response& response() {
    DCHECK(fields_.which() == 0 || fields_.which() == 2) << fields_.which();
    if (fields_.which() == 0) {
      fields_ = Response();
    }

    return boost::get<Response>(fields_);
  }

  const Response& response() const {
    DCHECK(fields_.which() == 0 || fields_.which() == 2) << fields_.which();
    if (fields_.which() == 0) {
      fields_ = Response();
    }

    return boost::get<const Response>(fields_);
  }

  /*
   * Cookies and query parameters
   * These are mutable since we parse them lazily in getCookie() and
   * getQueryParam()
   */
  mutable std::map<folly::StringPiece, folly::StringPiece> cookies_;
  // TODO: use StringPiece for queryParams_ and delete splitNameValue()
  mutable std::map<std::string, std::string> queryParams_;

  std::pair<uint8_t, uint8_t> version_;
  HTTPHeaders headers_;
  HTTPHeaders strippedPerHopHeaders_;
  HTTPHeaderSize size_;
  std::unique_ptr<HTTPHeaders> trailers_;

  int sslVersion_;
  const char* sslCipher_;
  const std::string* protoStr_;
  uint8_t pri_;
  folly::Optional<HTTPPriority> h2Pri_;

  mutable bool parsedCookies_:1;
  mutable bool parsedQueryParams_:1;
  bool chunked_:1;
  bool upgraded_:1;
  bool wantsKeepalive_:1;
  bool trailersAllowed_:1;

  // Whether the message is received in HTTPS.
  bool secure_:1;

  // used by atomicDumpMessage
  static std::mutex mutexDump_;

  WebSocketUpgrade upgradeWebsocket_;
  std::unique_ptr<std::string> upgradeProtocol_;
};

std::ostream& operator<<(std::ostream& os, const HTTPMessage& msg);

template<typename Str>
std::string stripCntrlChars(const Str& str) {
  std::string res;
  res.reserve(str.length());
  for (size_t i = 0; i < str.size(); ++i) {
    if (!(str[i] <= 0x1F || str[i] == 0x7F)) {
      res += str[i];
    }
  }
  return res;
}

} // proxygen