HTTPHeaders.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 <folly/FBVector.h>
#include <folly/Range.h>
#include <proxygen/lib/http/HTTPCommonHeaders.h>
#include <proxygen/lib/utils/Export.h>
#include <proxygen/lib/utils/UtilInl.h>

#include <bitset>
#include <cstring>
#include <string>
#include <initializer_list>

namespace proxygen {

extern const std::string empty_string;

inline bool isLWS(char c) {
  // Technically \r and \n are only allowed in LWS if they appear together.
  if (c == ' ' || c == '\t' || c == '\r' || c == '\n') {
    return true;
  }
  return false;
}

class HTTPHeaders {
 public:
   struct HTTPHeaderName {
     enum Type { CODE, STRING };
     union {
       folly::StringPiece name_;
       HTTPHeaderCode code_;
     };
     Type type_;
     /* implicit */ HTTPHeaderName(HTTPHeaderCode code)
      : code_(code), type_(CODE) {}
     /* implicit */ HTTPHeaderName(const char* name)
      : name_(name), type_(STRING) {}
     /* implicit */ HTTPHeaderName(folly::StringPiece name)
      : name_(name), type_(STRING) {}
   };

   using headers_initializer_list = std::initializer_list<
                                std::pair<HTTPHeaderName,folly::StringPiece>>;

  /*
   * separator used to concatenate multiple values of the same header
   * check out sections 4.2 and 14.45 from rfc2616
   */
  static const std::string COMBINE_SEPARATOR;

  FB_EXPORT HTTPHeaders();
  FB_EXPORT ~HTTPHeaders();
  FB_EXPORT HTTPHeaders (const HTTPHeaders&);
  FB_EXPORT HTTPHeaders& operator= (const HTTPHeaders&);
  FB_EXPORT HTTPHeaders (HTTPHeaders&&) noexcept;
  FB_EXPORT HTTPHeaders& operator= (HTTPHeaders&&);

  void add(folly::StringPiece name, folly::StringPiece value);
  template <typename T> // T = string
  void add(folly::StringPiece name, T&& value);
  template <typename T> // T = string
  void add(HTTPHeaderCode code, T&& value);
  void add(headers_initializer_list l);
  void rawAdd(const std::string& name, const std::string& value);

  void addFromCodec(const char* str, size_t len, std::string&& value);

  void set(folly::StringPiece name, const std::string& value) {
    // this could be somewhat optimized but probably not an issue yet
    remove(name);
    add(name, value);
  }
  void set(HTTPHeaderCode code, const std::string& value) {
    remove(code);
    add(code, value);
  }
  void rawSet(const std::string& name, const std::string& value) {
    set(name, value);
  }

  bool exists(folly::StringPiece name) const;
  bool exists(HTTPHeaderCode code) const;
  bool rawExists(std::string& name) const {
    return exists(name);
  }

  template <typename T>
  std::string combine(const T& header,
                      const std::string& separator=COMBINE_SEPARATOR) const;

  template <typename LAMBDA> // (const string &, const string &) -> void
  inline void forEach(LAMBDA func) const;

  template <typename LAMBDA>
  inline void forEachWithCode(LAMBDA func) const;

  template <typename LAMBDA> // (const string &, const string &) -> bool
  inline bool removeByPredicate(LAMBDA func);

  template <typename T> // either uint8_t or string
  const std::string & getSingleOrEmpty(const T& nameOrCode) const;
  const std::string rawGet(const std::string& header) const {
    return getSingleOrEmpty(header);
  }

  size_t getNumberOfValues(HTTPHeaderCode code) const;
  size_t getNumberOfValues(folly::StringPiece name) const;

  template <typename LAMBDA> // const string & -> bool
  inline bool forEachValueOfHeader(folly::StringPiece name, LAMBDA func) const;
  template <typename LAMBDA> // const string & -> bool
  inline bool forEachValueOfHeader(HTTPHeaderCode code, LAMBDA func) const;

  bool remove(folly::StringPiece name);
  bool remove(HTTPHeaderCode code);
  void rawRemove(const std::string& name) {
    remove(name);
  }

  void removeAll();

  void stripPerHopHeaders(HTTPHeaders& strippedHeaders);

  size_t size() const;

  void copyTo(HTTPHeaders& hdrs) const;

  static std::bitset<256>& perHopHeaderCodes();

 private:
  // vector storing the 1-byte hashes of header names
  folly::fbvector<HTTPHeaderCode> codes_;

  folly::fbvector<const std::string *> headerNames_;

  folly::fbvector<std::string> headerValues_;

  size_t deletedCount_;

  static const size_t kInitialVectorReserve = 16;

  bool transferHeaderIfPresent(folly::StringPiece name, HTTPHeaders& dest);

  // deletes the strings in headerNames_ that we own
  void disposeOfHeaderNames();
};

// Implementation follows - it has to be in the .h because of the templates

template <typename T> // T = string
void HTTPHeaders::add(folly::StringPiece name, T&& value) {
  assert(name.size());
  const HTTPHeaderCode code = HTTPCommonHeaders::hash(name.data(), name.size());
  codes_.push_back(code);
  headerNames_.push_back((code == HTTP_HEADER_OTHER)
      ? new std::string(name.data(), name.size())
      : HTTPCommonHeaders::getPointerToHeaderName(code));
  headerValues_.emplace_back(std::forward<T>(value));
}

template <typename T> // T = string
void HTTPHeaders::add(HTTPHeaderCode code, T&& value) {
  codes_.push_back(code);
  headerNames_.push_back(HTTPCommonHeaders::getPointerToHeaderName(code));
  headerValues_.emplace_back(std::forward<T>(value));
}

// iterate over the positions (in vector) of all headers with given code
#define ITERATE_OVER_CODES(Code, Block)                               \
  {                                                                   \
    const HTTPHeaderCode* ptr = codes_.data();                        \
    while (ptr) {                                                     \
      ptr = (HTTPHeaderCode*)memchr(                                  \
          (void*)ptr, (Code), codes_.size() - (ptr - codes_.data())); \
      if (ptr == nullptr)                                             \
        break;                                                        \
      const size_t pos = ptr - codes_.data();                         \
      {Block} ptr++;                                                  \
    }                                                                 \
  }

// iterate over the positions of all headers with given name
#define ITERATE_OVER_STRINGS(String, Block) \
    ITERATE_OVER_CODES(HTTP_HEADER_OTHER, { \
  if (caseInsensitiveEqual((String), *headerNames_[pos])) { \
    {Block} \
  } \
})

template <typename LAMBDA> // (const string &, const string &) -> void
void HTTPHeaders::forEach(LAMBDA func) const {
  for (size_t i = 0; i < codes_.size(); ++i) {
    if (codes_[i] != HTTP_HEADER_NONE) {
      func(*headerNames_[i], headerValues_[i]);
    }
  }
}

template <typename LAMBDA>
void HTTPHeaders::forEachWithCode(LAMBDA func) const {
  for (size_t i = 0; i < codes_.size(); ++i) {
    if (codes_[i] != HTTP_HEADER_NONE) {
      func(codes_[i], *headerNames_[i], headerValues_[i]);
    }
  }
}

template <typename LAMBDA> // const string & -> bool
bool HTTPHeaders::forEachValueOfHeader(folly::StringPiece name,
                                       LAMBDA func) const {
  const HTTPHeaderCode code = HTTPCommonHeaders::hash(name.data(), name.size());
  if (code != HTTP_HEADER_OTHER) {
    return forEachValueOfHeader(code, func);
  } else {
    ITERATE_OVER_STRINGS(name, {
      if (func(headerValues_[pos])) {
        return true;
      }
    });
    return false;
  }
}

template <typename LAMBDA> // const string & -> bool
bool HTTPHeaders::forEachValueOfHeader(HTTPHeaderCode code,
                                       LAMBDA func) const {
  ITERATE_OVER_CODES(code, {
    if (func(headerValues_[pos])) {
      return true;
    }
  });
  return false;
}

template <typename T>
std::string HTTPHeaders::combine(const T& header,
                                 const std::string& separator) const {
  std::string combined = "";
  forEachValueOfHeader(header, [&] (const std::string& value) -> bool {
      if (combined.empty()) {
        combined.append(value);
      } else {
        combined.append(separator).append(value);
      }
      return false;
    });
  return combined;
}

// LAMBDA: (HTTPHeaderCode, const string&, const string&) -> bool
template <typename LAMBDA>
bool HTTPHeaders::removeByPredicate(LAMBDA func) {
  bool removed = false;
  for (size_t i = 0; i < codes_.size(); ++i) {
    if (codes_[i] == HTTP_HEADER_NONE ||
        !func(codes_[i], *headerNames_[i], headerValues_[i])) {
      continue;
    }

    if (codes_[i] == HTTP_HEADER_OTHER) {
      delete headerNames_[i];
      headerNames_[i] = nullptr;
    }

    codes_[i] = HTTP_HEADER_NONE;
    ++deletedCount_;
    removed = true;
  }

  return removed;
}

template <typename T> // either uint8_t or string
const std::string & HTTPHeaders::getSingleOrEmpty(const T& nameOrCode) const {
  const std::string* res = nullptr;
  forEachValueOfHeader(nameOrCode, [&] (const std::string& value) -> bool {
    if (res != nullptr) {
      // a second value is found
      res = nullptr;
      return true; // stop processing
    } else {
      // the first value is found
      res = &value;
      return false;
    }
  });
  if (res == nullptr) {
    return empty_string;
  } else {
    return *res;
  }
}

#ifndef PROXYGEN_HTTPHEADERS_IMPL
#undef ITERATE_OVER_CODES
#undef ITERATE_OVER_STRINGS
#endif // PROXYGEN_HTTPHEADERS_IMPL

}