proxygen::CodecUtil Class Reference

#include <CodecUtil.h>

Public Types
enum	CtlEscapeMode { COMPLIANT, STRICT }

Static Public Member Functions
static bool	validateURL (folly::ByteRange url)
static bool	validateMethod (folly::ByteRange method)
static bool	validateHeaderName (folly::ByteRange name)
static bool	validateHeaderValue (folly::ByteRange value, CtlEscapeMode mode)
static bool	hasGzipAndDeflate (const std::string &value, bool &hasGzip, bool &hasDeflate)
static std::vector< compress::Header >	prepareMessageForCompression (const HTTPMessage &msg, std::vector< std::string > &temps)
static bool	appendHeaders (const HTTPHeaders &inputHeaders, std::vector< compress::Header > &headers, HTTPHeaderCode headerToCheck)

Static Public Attributes
static const char	http_tokens [256]

Detailed Description

Definition at line 23 of file CodecUtil.h.

Member Enumeration Documentation

enum proxygen::CodecUtil::CtlEscapeMode

RFC2616 allows certain control chars in header values if they are quoted and escaped. When mode is COMPLIANT, then this is allowed. When mode is STRICT, no escaped CTLs are allowed

Enumerator
COMPLIANT
STRICT

Definition at line 61 of file CodecUtil.h.

                     {
    COMPLIANT,
    STRICT
  };

Member Function Documentation

bool proxygen::CodecUtil::appendHeaders ( const HTTPHeaders &  inputHeaders, std::vector< compress::Header > &  headers, HTTPHeaderCode  headerToCheck  )

static

Definition at line 131 of file CodecUtil.cpp.

References proxygen::HTTPHeaders::forEachWithCode(), proxygen::HTTP_HEADER_CONNECTION, proxygen::HTTP_HEADER_HOST, proxygen::HTTP_HEADER_KEEP_ALIVE, proxygen::HTTP_HEADER_PROXY_CONNECTION, proxygen::HTTP_HEADER_SEC_WEBSOCKET_ACCEPT, proxygen::HTTP_HEADER_SEC_WEBSOCKET_KEY, proxygen::HTTP_HEADER_TRANSFER_ENCODING, proxygen::HTTP_HEADER_UPGRADE, name, string, and value.

Referenced by proxygen::HTTP2Codec::generateTrailers(), prepareMessageForCompression(), and validateHeaderValue().

                                                            {
  bool headerToCheckExists = false;
  // Add the HTTP headers supplied by the caller, but skip
  // any per-hop headers that aren't supported in HTTP/2.
  inputHeaders.forEachWithCode([&](HTTPHeaderCode code,
                                   const std::string& name,
                                   const std::string& value) {
    static const std::bitset<256> s_perHopHeaderCodes{[] {
      std::bitset<256> bs;
      // HTTP/1.x per-hop headers that have no meaning in HTTP/2
      bs[HTTP_HEADER_CONNECTION] = true;
      bs[HTTP_HEADER_HOST] = true;
      bs[HTTP_HEADER_KEEP_ALIVE] = true;
      bs[HTTP_HEADER_PROXY_CONNECTION] = true;
      bs[HTTP_HEADER_TRANSFER_ENCODING] = true;
      bs[HTTP_HEADER_UPGRADE] = true;
      bs[HTTP_HEADER_SEC_WEBSOCKET_KEY] = true;
      bs[HTTP_HEADER_SEC_WEBSOCKET_ACCEPT] = true;
      return bs;
    }()};

    if (s_perHopHeaderCodes[code] || name.size() == 0 || name[0] == ':') {
      DCHECK_GT(name.size(), 0) << "Empty header";
      DCHECK_NE(name[0], ':') << "Invalid header=" << name;
      return;
    }
    // Note this code will not drop headers named by Connection.  That's the
    // caller's job

    // see HTTP/2 spec, 8.1.2
    DCHECK(name != "TE" || value == "trailers");
    if ((name.size() > 0 && name[0] != ':') && code != HTTP_HEADER_HOST) {
      headers.emplace_back(code, name, value);
    }
    if (code == headerToCheck) {
      headerToCheckExists = true;
    }
  });

  return headerToCheckExists;
}

bool proxygen::CodecUtil::hasGzipAndDeflate ( const std::string &  value, bool &  hasGzip, bool &  hasDeflate  )

static

Definition at line 61 of file CodecUtil.cpp.

References gmock_output_test::output, proxygen::RFC2616::parseQvalues(), string, and folly::pushmi::operators::transform.

Referenced by proxygen::SPDYCodec::parseHeaders(), and validateHeaderValue().

                                                   {
  static folly::ThreadLocal<std::vector<RFC2616::TokenQPair>> output;
  output->clear();
  hasGzip = false;
  hasDeflate = false;
  RFC2616::parseQvalues(value, *output);
  for (const auto& encodingQ: *output) {
    std::string lower(encodingQ.first.str());
    std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
    // RFC says 3 sig figs
    if (lower == "gzip" && encodingQ.second >= 0.001) {
      hasGzip = true;
    } else if (lower == "deflate" && encodingQ.second >= 0.001) {
      hasDeflate = true;
    }
  }
  return hasGzip && hasDeflate;
}

std::vector< compress::Header > proxygen::CodecUtil::prepareMessageForCompression ( const HTTPMessage &  msg, std::vector< std::string > &  temps  )

static

Definition at line 82 of file CodecUtil.cpp.

References appendHeaders(), proxygen::CONNECT, proxygen::HTTPMessage::formatDateHeader(), proxygen::HTTPMessage::getHeaders(), proxygen::HTTPMessage::getMethod(), proxygen::HTTPMessage::getMethodString(), proxygen::HTTPHeaders::getSingleOrEmpty(), proxygen::HTTPMessage::getStatusCode(), proxygen::HTTPMessage::getURL(), proxygen::HTTP_HEADER_COLON_AUTHORITY, proxygen::HTTP_HEADER_COLON_METHOD, proxygen::HTTP_HEADER_COLON_PATH, proxygen::HTTP_HEADER_COLON_PROTOCOL, proxygen::HTTP_HEADER_COLON_SCHEME, proxygen::HTTP_HEADER_COLON_STATUS, proxygen::HTTP_HEADER_DATE, proxygen::HTTP_HEADER_HOST, proxygen::HTTPMessage::isEgressWebsocketUpgrade(), proxygen::HTTPMessage::isRequest(), proxygen::HTTPMessage::isResponse(), proxygen::HTTPMessage::isSecure(), proxygen::headers::kHttp, proxygen::headers::kHttps, proxygen::headers::kStatus200, proxygen::headers::kWebsocketString, proxygen::methodToString(), and string.

Referenced by proxygen::HTTP2Codec::generateHeaderImpl(), and validateHeaderValue().

                                 {
  std::vector<compress::Header> allHeaders;
  if (msg.isRequest()) {
    if (msg.isEgressWebsocketUpgrade()) {
      allHeaders.emplace_back(HTTP_HEADER_COLON_METHOD,
          methodToString(HTTPMethod::CONNECT));
      allHeaders.emplace_back(HTTP_HEADER_COLON_PROTOCOL,
                              headers::kWebsocketString);
    } else {
      const std::string& method = msg.getMethodString();
      allHeaders.emplace_back(HTTP_HEADER_COLON_METHOD, method);
    }

    if (msg.getMethod() != HTTPMethod::CONNECT ||
        msg.isEgressWebsocketUpgrade()) {
      const std::string& scheme =
        (msg.isSecure() ? headers::kHttps : headers::kHttp);
      const std::string& path = msg.getURL();
      allHeaders.emplace_back(HTTP_HEADER_COLON_SCHEME, scheme);
      allHeaders.emplace_back(HTTP_HEADER_COLON_PATH, path);
    }
    const HTTPHeaders& headers = msg.getHeaders();
    const std::string& host = headers.getSingleOrEmpty(HTTP_HEADER_HOST);
    if (!host.empty()) {
      allHeaders.emplace_back(HTTP_HEADER_COLON_AUTHORITY, host);
    }
  } else {
    temps.reserve(3); // must be large enough so that emplace does not resize
    if (msg.isEgressWebsocketUpgrade()) {
      temps.emplace_back(headers::kStatus200);
    } else {
      temps.emplace_back(folly::to<std::string>(msg.getStatusCode()));
    }
    allHeaders.emplace_back(HTTP_HEADER_COLON_STATUS, temps.back());
    // HEADERS frames do not include a version or reason string.
  }

  bool hasDateHeader =
      appendHeaders(msg.getHeaders(), allHeaders, HTTP_HEADER_DATE);

  if (msg.isResponse() && !hasDateHeader) {
    temps.emplace_back(HTTPMessage::formatDateHeader());
    allHeaders.emplace_back(HTTP_HEADER_DATE, temps.back());
  }
  return allHeaders;
}

static bool proxygen::CodecUtil::validateHeaderName ( folly::ByteRange  name )

inlinestatic

Definition at line 43 of file CodecUtil.h.

References folly::Range< Iter >::size(), and uint8_t.

Referenced by proxygen::HeaderDecodeInfo::onHeader(), and proxygen::SPDYCodec::parseHeaders().

                                                      {
    if (name.size() == 0) {
      return false;
    }
    for (auto p: name) {
      if (p < 0x80 && http_tokens[(uint8_t)p] != p) {
        return false;
      }
    }
    return true;
  }

static bool proxygen::CodecUtil::validateHeaderValue ( folly::ByteRange  value, CtlEscapeMode  mode  )

inlinestatic

Definition at line 66 of file CodecUtil.h.

References appendHeaders(), folly::test::begin(), COMPLIANT, folly::test::end(), hasGzipAndDeflate(), prepareMessageForCompression(), quote, string, and value.

Referenced by proxygen::HeaderDecodeInfo::onHeader(), proxygen::SPDYCodec::parseHeaders(), and proxygen::HTTPRequestVerifier::setAuthority().

                                                      {
    bool escape = false;
    bool quote = false;
    enum { lws_none,
           lws_expect_nl,
           lws_expect_ws1,
           lws_expect_ws2 } state = lws_none;

    for (auto p = std::begin(value); p != std::end(value); ++p) {
      if (escape) {
        escape = false;
        if (mode == COMPLIANT) {
          // prev char escaped.  Turn off escape and go to next char
          // COMPLIANT mode only
          assert(quote);
          continue;
        }
      }
      switch (state) {
        case lws_none:
          switch (*p) {
            case '\\':
              if (quote) {
                escape = true;
              }
              break;
            case '\"':
              quote = !quote;
              break;
            case '\r':
              state = lws_expect_nl;
              break;
            default:
              if ((*p < 0x20 || *p == 0x7f) && *p != '\t') {
                // unexpected ctl per rfc2616, HT OK
                return false;
              }
              break;
          }
          break;
        case lws_expect_nl:
          if (*p != '\n') {
            // unescaped \r must be LWS
            return false;
          }
          state = lws_expect_ws1;
          break;
        case lws_expect_ws1:
          if (*p != ' ' && *p != '\t') {
            // unescaped \r\n must be LWS
            return false;
          }
          state = lws_expect_ws2;
          break;
        case lws_expect_ws2:
          if (*p != ' ' && *p != '\t') {
            // terminated LWS
            state = lws_none;
            // check this char again
            p--;
          }
          break;
      }
    }
    // Unterminated quotes are OK, since the value can be* TEXT which treats
    // the " like any other char.
    // Unterminated escapes are bad because it will escape the next character
    // when converting to HTTP
    // Unterminated LWS (dangling \r or \r\n) is bad because it could
    // prematurely terminate the headers when converting to HTTP
    return !escape && (state == lws_none || state == lws_expect_ws2);
  }

static bool proxygen::CodecUtil::validateMethod ( folly::ByteRange  method )

inlinestatic

Definition at line 33 of file CodecUtil.h.

Referenced by proxygen::SPDYCodec::parseHeaders(), proxygen::HTTPRequestVerifier::setMethod(), and proxygen::HTTPRequestVerifier::setScheme().

                                                    {
    for (auto p: method) {
      if (!isalpha(p)) {
        // methods are all characters
        return false;
      }
    }
    return true;
  }

static bool proxygen::CodecUtil::validateURL ( folly::ByteRange  url )

inlinestatic

Definition at line 29 of file CodecUtil.h.

References proxygen::validateURL().

Referenced by proxygen::SPDYCodec::parseHeaders(), and proxygen::HTTPRequestVerifier::setPath().

                                              {
    return proxygen::validateURL(url);
  }

Member Data Documentation

const char proxygen::CodecUtil::http_tokens

static

Tokens as defined by rfc 2616. Also lowercases them. token = 1*<any char="" except="" ctls="" or="" separators>=""> separators = "(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\" | <"> | "/" | "[" | "]" | "?" | "=" | "{" | "}" | SP | HT

Definition at line 27 of file CodecUtil.h.

---

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

• proxygen/lib/http/codec/CodecUtil.h
• proxygen/lib/http/codec/CodecUtil.cpp