proxygen::RFC2616 Namespace Reference

Typedefs
using	TokenQPair = std::pair< folly::StringPiece, double >

Enumerations
enum	BodyAllowed { BodyAllowed::DEFINED, BodyAllowed::NOT_DEFINED, BodyAllowed::NOT_ALLOWED }

Functions
BodyAllowed	isRequestBodyAllowed (folly::Optional< HTTPMethod > method)
bool	responseBodyMustBeEmpty (unsigned status)
bool	bodyImplied (const HTTPHeaders &headers)
bool	parseQvalues (folly::StringPiece value, std::vector< TokenQPair > &output)
bool	parseByteRangeSpec (folly::StringPiece value, unsigned long &outFirstByte, unsigned long &outLastByte, unsigned long &outInstanceLength)

Typedef Documentation

using proxygen::RFC2616::TokenQPair = typedef std::pair<folly::StringPiece, double>

Parse a string containing tokens and qvalues, such as the RFC strings for Accept-Charset, Accept-Encoding and Accept-Language. It won't work for complex Accept: headers because it doesn't return parameters or accept-extension.

See RFC sections 14.2, 14.3, 14.4 for definitions of these header values

TODO: optionally sort by qvalue descending

Return true if the string was well formed according to the RFC. Note it can return false but still populate output with best-effort parsing.

Definition at line 69 of file RFC2616.h.

Enumeration Type Documentation

enum proxygen::RFC2616::BodyAllowed

strong

This file contains functions for determining when certain tricky parts of RFC 2616 arise. The HTTP request as defined in RFC 2616 may or may not have a body. In some cases they MUST NOT have a body. In other cases, the body has no semantic meaning and so is not defined. Finally, for some methods, the body is well defined. Please see Section 9 and 4.3 for details on this.

Enumerator
DEFINED
NOT_DEFINED
NOT_ALLOWED

Definition at line 34 of file RFC2616.h.

                       {
  DEFINED,
  NOT_DEFINED,
  NOT_ALLOWED,
};

Function Documentation

bool proxygen::RFC2616::bodyImplied

(

const HTTPHeaders &

headers

)

Returns true if the headers imply that a body will follow. Note that in some situations a body may come even if this function returns false (e.g. a 1.0 response body's length can be given implicitly by closing the connection).

Definition at line 59 of file RFC2616.cpp.

References proxygen::HTTPHeaders::exists(), proxygen::HTTP_HEADER_CONTENT_LENGTH, and proxygen::HTTP_HEADER_TRANSFER_ENCODING.

Referenced by proxygen::HTTPChecks::generateHeader(), and proxygen::HTTPChecks::onHeadersComplete().

                                             {
  return headers.exists(HTTP_HEADER_TRANSFER_ENCODING) ||
    headers.exists(HTTP_HEADER_CONTENT_LENGTH);
}

BodyAllowed proxygen::RFC2616::isRequestBodyAllowed

(

folly::Optional< HTTPMethod >

method

)

Definition at line 43 of file RFC2616.cpp.

References DEFINED, NOT_ALLOWED, NOT_DEFINED, proxygen::OPTIONS, proxygen::POST, proxygen::PUT, and proxygen::TRACE.

Referenced by proxygen::HTTPChecks::generateHeader(), and proxygen::HTTPChecks::onHeadersComplete().

                                                                   {
  if (method == HTTPMethod::TRACE) {
    return BodyAllowed::NOT_ALLOWED;
  }
  if (method == HTTPMethod::OPTIONS || method == HTTPMethod::POST ||
      method == HTTPMethod::PUT) {
    return BodyAllowed::DEFINED;
  }
  return BodyAllowed::NOT_DEFINED;
}

bool proxygen::RFC2616::parseByteRangeSpec	(	folly::StringPiece	value,
		unsigned long &	firstByte,
		unsigned long &	lastByte,
		unsigned long &	instanceLength
	)

Parse an RFC 2616 section 14.16 "bytes A-B/C" string and returns them as the first and last bytes and instance length, respectively.

Wildcards are handled specially as follows: if the range is actually "*", the first byte is parsed as 0 and last byte as ULONG_MAX; if instance length is actually "*", it is parsed as ULONG_MAX.

Note that is ONLY suitable for use in parsing "Content-Range" response headers. The "Range" request header has different but similar syntax.

Definition at line 105 of file RFC2616.cpp.

References folly::Range< Iter >::begin(), folly::Range< Iter >::end(), and folly::Range< Iter >::startsWith().

Referenced by TEST().

                                      {
  // We should start with "bytes "
  if (!value.startsWith("bytes ")) {
    return false;
  }

  const char* curs = value.begin() + 6 /* strlen("bytes ") */;
  const char* end = value.end();

  unsigned long firstByte = ULONG_MAX;
  unsigned long lastByte = ULONG_MAX;
  unsigned long instanceLength = ULONG_MAX;

  if (!strtoulWrapper(curs, end, firstByte)) {
    if (*curs != '*') {
      return false;
    }

    firstByte = 0;
    lastByte = ULONG_MAX;
    ++curs;
  } else {
    if (*curs != '-') {
      return false;
    }

    ++curs;

    if (!strtoulWrapper(curs, end, lastByte)) {
      return false;
    }
  }

  if (*curs != '/') {
    return false;
  }

  ++curs;
  if (*curs != '*') {
    if (!strtoulWrapper(curs, end, instanceLength)) {
      return false;
    }
  } else {
    ++curs;
  }

  if (curs < end && *curs != '\0') {
    return false;
  }

  if (lastByte < firstByte) {
    return false;
  }

  if ((lastByte - firstByte + 1) > instanceLength) {
    return false;
  }

  outFirstByte = firstByte;
  outLastByte = lastByte;
  outInstanceLength = instanceLength;
  return true;
}

bool proxygen::RFC2616::parseQvalues	(	folly::StringPiece	value,
		std::vector< TokenQPair > &	output
	)

Definition at line 64 of file RFC2616.cpp.

References folly::split(), and tokens.

Referenced by proxygen::ZlibServerFilterFactory::acceptsSupportedCompressionType(), proxygen::CodecUtil::hasGzipAndDeflate(), and TEST().

                                                                         {
  bool result = true;
  static folly::ThreadLocal<std::vector<folly::StringPiece>> tokens;
  tokens->clear();
  folly::split(",", value, *tokens, true /*ignore empty*/);
  for (auto& token: *tokens) {
    auto pos = token.find(';');
    double qvalue = 1.0;
    if (pos != std::string::npos) {
      auto qpos = token.find("q=", pos);
      if (qpos != std::string::npos) {
        folly::StringPiece qvalueStr(token.data() + qpos + 2,
                                     token.size() - (qpos + 2));
        try {
          qvalue = folly::to<double>(&qvalueStr);
        } catch (const std::range_error&) {
          // q=<some garbage>
          result = false;
        }
        // we could validate that the remainder of qvalueStr was all whitespace,
        // for now we just discard it
      } else {
        // ; but no q=
        result = false;
      }
      token.reset(token.start(), pos);
    }
    // strip leading whitespace
    while (token.size() > 0 && isspace(token[0])) {
      token.reset(token.start() + 1, token.size() - 1);
    }
    if (token.size() == 0) {
      // empty token
      result = false;
    } else {
      output.emplace_back(token, qvalue);
    }
  }
  return result && output.size() > 0;
}

bool proxygen::RFC2616::responseBodyMustBeEmpty

(

unsigned

status

)

Some status codes imply that there MUST NOT be a response body. See section 4.3: "All 1xx (informational), 204 (no content), and 304 (not modified) responses MUST NOT include a message-body."

Parameters

status

The code to test (100 <= status <= 999)

Definition at line 54 of file RFC2616.cpp.

Referenced by proxygen::HTTP1xCodec::generateHeader(), proxygen::HTTP1xCodec::onHeadersComplete(), and proxygen::HTTPTransaction::onIngressHeadersComplete().

                                              {
  return (status == 304 || status == 204 ||
          (100 <= status && status < 200));
}