proxygen::HTTPMessage Class Reference

#include <HTTPMessage.h>

Classes
struct	Request
struct	Response

Public Types
enum	WebSocketUpgrade { NONE, INGRESS, EGRESS }
using	HTTPPriority = std::tuple< uint32_t, bool, uint8_t >

Public Member Functions
	HTTPMessage ()
	~HTTPMessage ()
	HTTPMessage (HTTPMessage &&message) noexcept
	HTTPMessage (const HTTPMessage &message)
HTTPMessage &	operator= (const HTTPMessage &message)
HTTPMessage &	operator= (HTTPMessage &&message)
void	setIngressWebsocketUpgrade ()
void	setEgressWebsocketUpgrade ()
bool	isIngressWebsocketUpgrade () const
bool	isEgressWebsocketUpgrade () const
void	setIsChunked (bool chunked)
bool	getIsChunked () const
void	setIsUpgraded (bool upgraded)
bool	getIsUpgraded () const
void	setClientAddress (const folly::SocketAddress &addr, std::string ipStr=empty_string, std::string portStr=empty_string)
const folly::SocketAddress &	getClientAddress () const
const std::string &	getClientIP () const
const std::string &	getClientPort () const
void	setDstAddress (const folly::SocketAddress &addr, std::string addressStr=empty_string, std::string portStr=empty_string)
const folly::SocketAddress &	getDstAddress () const
const std::string &	getDstIP () const
const std::string &	getDstPort () const
template<typename T >
void	setLocalIp (T &&ip)
const std::string &	getLocalIp () const
void	setMethod (HTTPMethod method)
void	setMethod (folly::StringPiece method)
void	rawSetMethod (const std::string &method)
folly::Optional< HTTPMethod >	getMethod () const
const std::string &	getMethodString () const
template<typename T >
ParseURL	setURL (T &&url)
void	setURL (const char *url)
const std::string &	getURL () const
void	rawSetURL (const std::string &url)
const std::string &	getPath () const
const std::string &	getQueryString () const
void	setHTTPVersion (uint8_t major, uint8_t minor)
const std::pair< uint8_t, uint8_t > &	getHTTPVersion () const
template<typename T >
void	setStatusMessage (T &&msg)
const std::string &	getStatusMessage () const
void	rawSetStatusMessage (std::string msg)
const std::string &	getVersionString () const
void	setVersionString (const std::string &ver)
HTTPHeaders &	getHeaders ()
const HTTPHeaders &	getHeaders () const
HTTPHeaders &&	extractHeaders ()
HTTPHeaders *	getTrailers ()
const HTTPHeaders *	getTrailers () const
void	setTrailers (std::unique_ptr< HTTPHeaders > &&trailers)
int	processMaxForwards ()
bool	isHTTP1_0 () const
bool	isHTTP1_1 () const
bool	is1xxResponse () const
bool	is4xxResponse () const
bool	is5xxResponse () const
void	ensureHostHeader ()
void	setWantsKeepalive (bool wantsKeepaliveVal)
bool	wantsKeepalive () const
bool	trailersAllowed () const
void	setTrailersAllowed (bool trailersAllowedVal)
bool	hasTrailers () const
void	setStatusCode (uint16_t status)
uint16_t	getStatusCode () const
void	setUpgradeProtocol (std::string protocol)
const std::string *	getUpgradeProtocol () const
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
void	setSecure (bool secure)
bool	isSecure () const
int	getSecureVersion () const
const char *	getSecureCipher () const
void	setSecureInfo (int ver, const char *cipher)
void	setAdvancedProtocolString (const std::string &protocol)
bool	isAdvancedProto () const
const std::string *	getAdvancedProtocolString () const
const std::string &	getProtocolString () const
void	setPriority (int8_t pri)
uint8_t	getPriority () const
folly::Optional< HTTPPriority >	getHTTP2Priority () const
void	setHTTP2Priority (HTTPPriority h2Pri)
void	setSeqNo (int32_t seqNo)
int32_t	getSeqNo () const
void	setIngressHeaderSize (const HTTPHeaderSize &size)
const HTTPHeaderSize &	getIngressHeaderSize () const
TimePoint	getStartTime () const
void	setStartTime (const TimePoint &startTime)
bool	checkForHeaderToken (const HTTPHeaderCode headerCode, char const *token, bool caseSensitive) const
void	unparseCookies () const
bool	computeKeepalive () const
bool	isRequest () const
bool	isResponse () const

Static Public Member Functions
static std::string	formatDateHeader ()
static uint8_t	normalizePriority (int8_t pri)
static const char *	getDefaultReason (uint16_t status)
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)

Static Public Attributes
static const std::pair< uint8_t, uint8_t >	kHTTPVersion10
static const std::pair< uint8_t, uint8_t >	kHTTPVersion11
static const int8_t	kMaxPriority = 7

Protected Attributes
TimePoint	startTime_
int32_t	seqNo_

Private Member Functions
void	parseCookies () const
void	parseQueryParams () const
void	unparseQueryParams ()
bool	doHeaderTokenCheck (const HTTPHeaders &headers_, const HTTPHeaderCode headerCode, char const *token, bool caseSensitive) const
Request &	request ()
const Request &	request () const
Response &	response ()
const Response &	response () const

Static Private Member Functions
static folly::StringPiece	trim (folly::StringPiece sp)

Private Attributes
folly::SocketAddress	dstAddress_
std::string	dstIP_
std::string	dstPort_
std::string	localIP_
std::string	versionStr_
boost::variant< boost::blank, Request, Response >	fields_
std::map< folly::StringPiece, folly::StringPiece >	cookies_
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_
bool	parsedCookies_:1
bool	parsedQueryParams_:1
bool	chunked_:1
bool	upgraded_:1
bool	wantsKeepalive_:1
bool	trailersAllowed_:1
bool	secure_:1
WebSocketUpgrade	upgradeWebsocket_
std::unique_ptr< std::string >	upgradeProtocol_

Static Private Attributes
static std::mutex	mutexDump_

Detailed Description

An HTTP request or response minus the body.

Some of the methods on this class will assert if called from the wrong context since they only make sense for a request or response. Make sure you know what type of HTTPMessage this is before calling such methods.

All header names stored in this class are case-insensitive.

Definition at line 39 of file HTTPMessage.h.

Member Typedef Documentation

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

Definition at line 592 of file HTTPMessage.h.

Member Enumeration Documentation

enum proxygen::HTTPMessage::WebSocketUpgrade

Enumerator
NONE
INGRESS
EGRESS

Definition at line 42 of file HTTPMessage.h.

                        {
    NONE,
    INGRESS,
    EGRESS,
  };

Constructor & Destructor Documentation

proxygen::HTTPMessage::HTTPMessage

(

)

Definition at line 63 of file HTTPMessage.cpp.

                         :
    startTime_(getCurrentTime()),
    seqNo_(-1),
    localIP_(),
    versionStr_("1.0"),
    fields_(),
    version_(1,0),
    sslVersion_(0), sslCipher_(nullptr), protoStr_(nullptr), pri_(0),
    parsedCookies_(false), parsedQueryParams_(false),
    chunked_(false), upgraded_(false), wantsKeepalive_(true),
    trailersAllowed_(false), secure_(false),
    upgradeWebsocket_(HTTPMessage::WebSocketUpgrade::NONE) {
}

proxygen::HTTPMessage::~HTTPMessage

(

)

Definition at line 77 of file HTTPMessage.cpp.

                          {
}

proxygen::HTTPMessage::HTTPMessage ( HTTPMessage &&  message )

noexcept

Definition at line 112 of file HTTPMessage.cpp.

                                                       :
    startTime_(message.startTime_),
    seqNo_(message.seqNo_),
    dstAddress_(std::move(message.dstAddress_)),
    dstIP_(std::move(message.dstIP_)),
    dstPort_(message.dstPort_),
    localIP_(std::move(message.localIP_)),
    versionStr_(std::move(message.versionStr_)),
    fields_(std::move(message.fields_)),
    cookies_(std::move(message.cookies_)),
    queryParams_(std::move(message.queryParams_)),
    version_(message.version_),
    headers_(std::move(message.headers_)),
    strippedPerHopHeaders_(std::move(message.strippedPerHopHeaders_)),
    trailers_(std::move(message.trailers_)),
    sslVersion_(message.sslVersion_),
    sslCipher_(message.sslCipher_),
    protoStr_(message.protoStr_),
    pri_(message.pri_),
    h2Pri_(message.h2Pri_),
    parsedCookies_(message.parsedCookies_),
    parsedQueryParams_(message.parsedQueryParams_),
    chunked_(message.chunked_),
    upgraded_(message.upgraded_),
    wantsKeepalive_(message.wantsKeepalive_),
    trailersAllowed_(message.trailersAllowed_),
    secure_(message.secure_),
    upgradeWebsocket_(message.upgradeWebsocket_) {
}

proxygen::HTTPMessage::HTTPMessage

(

const HTTPMessage &

message

)

Definition at line 80 of file HTTPMessage.cpp.

References trailers_.

                                                   :
    startTime_(message.startTime_),
    seqNo_(message.seqNo_),
    dstAddress_(message.dstAddress_),
    dstIP_(message.dstIP_),
    dstPort_(message.dstPort_),
    localIP_(message.localIP_),
    versionStr_(message.versionStr_),
    fields_(message.fields_),
    cookies_(message.cookies_),
    queryParams_(message.queryParams_),
    version_(message.version_),
    headers_(message.headers_),
    strippedPerHopHeaders_(message.strippedPerHopHeaders_),
    sslVersion_(message.sslVersion_),
    sslCipher_(message.sslCipher_),
    protoStr_(message.protoStr_),
    pri_(message.pri_),
    h2Pri_(message.h2Pri_),
    parsedCookies_(message.parsedCookies_),
    parsedQueryParams_(message.parsedQueryParams_),
    chunked_(message.chunked_),
    upgraded_(message.upgraded_),
    wantsKeepalive_(message.wantsKeepalive_),
    trailersAllowed_(message.trailersAllowed_),
    secure_(message.secure_),
    upgradeWebsocket_(message.upgradeWebsocket_) {
  if (message.trailers_) {
    trailers_ = std::make_unique<HTTPHeaders>(*message.trailers_);
  }
}

Member Function Documentation

void proxygen::HTTPMessage::atomicDumpMessage

(

int

verbosity

)

const

Print the message out, serializes through mutex Used in shutdown path

Definition at line 731 of file HTTPMessage.cpp.

References dumpMessage(), g(), and mutexDump_.

Referenced by getUpgradeProtocol().

                                                  {
  std::lock_guard<std::mutex> g(mutexDump_);
  dumpMessage(vlogLevel);
}

bool proxygen::HTTPMessage::checkForHeaderToken	(	const HTTPHeaderCode	headerCode,
		char const *	token,
		bool	caseSensitive
	)		const

Check if a particular token value is present in a header that consists of a list of comma separated tokens. (e.g., a header with a #rule body as specified in the RFC 2616 BNF notation.)

Definition at line 782 of file HTTPMessage.cpp.

References doHeaderTokenCheck(), and headers_.

Referenced by computeKeepalive(), ZlibServerFilterTest::exercise_compression(), proxygen::HTTP2Codec::requestUpgrade(), setStartTime(), stripPerHopHeaders(), TEST(), and TEST_F().

                                                                {
  return doHeaderTokenCheck(headers_, headerCode, token, caseSensitive);
}

bool proxygen::HTTPMessage::computeKeepalive

(

)

const

Computes whether the state of this message is compatible with keepalive. Changing the headers, version, etc can change the result.

Definition at line 740 of file HTTPMessage.cpp.

References checkForHeaderToken(), doHeaderTokenCheck(), proxygen::HTTP_HEADER_CONNECTION, kHTTPVersion10, string, strippedPerHopHeaders_, and version_.

Referenced by setStartTime(), and TEST().

                                         {
  if (version_.first < 1) {
    return false;
  }

  // RFC 2616 isn't explicitly clear about whether "close" is case-sensitive.
  // Section 2.1 states that literal tokens in the BNF are case-insensitive
  // unless stated otherwise.  The "close" token isn't explicitly mentioned
  // in the BNF, but other header fields such as the character set and
  // content coding are explicitly called out as being case insensitive.
  //
  // We'll treat the "close" token case-insensitively.  This is the most
  // conservative approach, since disabling keepalive when it was requested
  // is better than enabling keepalive for a client that didn't expect it.
  //
  // Note that we only perform ASCII lowering here.  This is good enough,
  // since the token we are looking for is ASCII.
  if (checkForHeaderToken(HTTP_HEADER_CONNECTION, "close", false)) {
    // The Connection header contained a "close" token, so keepalive
    // is disabled.
    return false;
  }

  const std::string kKeepAliveConnToken = "keep-alive";
  if (version_ == kHTTPVersion10) {
      // HTTP 1.0 persistent connections require a Connection: Keep-Alive
      // header to be present for the connection to be persistent.
      if (checkForHeaderToken(
              HTTP_HEADER_CONNECTION, kKeepAliveConnToken.c_str(), false) ||
          doHeaderTokenCheck(strippedPerHopHeaders_,
                             HTTP_HEADER_CONNECTION,
                             kKeepAliveConnToken.c_str(),
                             false)) {
        return true;
      }
      return false;
  }

  // It's a keepalive connection.
  return true;
}

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

Fill in the fields for a response message header that the server will send directly to the client.

Parameters

version	HTTP version (major, minor)
statusCode	HTTP status code to respond with
msg	textual message to embed in "message" status field
contentLength	the length of the data to be written out through this message

Definition at line 358 of file HTTPMessage.cpp.

References setStatusCode(), and setStatusMessage().

Referenced by getUpgradeProtocol().

                                                        {
  setStatusCode(statusCode);
  setStatusMessage(statusMsg);
  constructDirectResponse(version, contentLength);
}

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

Fill in the fields for a response message header that the server will send directly to the client. This function assumes the status code and status message have already been set on this HTTPMessage object

Parameters

version	HTTP version (major, minor)
contentLength	the length of the data to be written out through this message

Definition at line 368 of file HTTPMessage.cpp.

References proxygen::HTTPHeaders::add(), proxygen::HTTPHeaders::exists(), headers_, proxygen::HTTP_HEADER_CONTENT_LENGTH, proxygen::HTTP_HEADER_CONTENT_TYPE, proxygen::HTTPHeaders::set(), setHTTPVersion(), setIsChunked(), and setIsUpgraded().

                                                        {
  setHTTPVersion(version.first, version.second);

  headers_.set(HTTP_HEADER_CONTENT_LENGTH, folly::to<string>(contentLength));

  if (!headers_.exists(HTTP_HEADER_CONTENT_TYPE)) {
    headers_.add(HTTP_HEADER_CONTENT_TYPE, "text/plain");
  }
  setIsChunked(false);
  setIsUpgraded(false);
}

std::string proxygen::HTTPMessage::createQueryString ( const std::map< std::string, std::string > &  params, uint32_t  maxSize  )

static

Create a query string from the query parameters map containing the name-value pairs.

Definition at line 547 of file HTTPMessage.cpp.

References string.

Referenced by isResponse(), removeQueryParam(), and setQueryParam().

                                                                    {
  std::string query;
  query.reserve(maxLength);
  for (auto it = params.begin(); it != params.end(); it++) {
    if (it != params.begin()) {
      query.append("&");
    }
    query.append(it->first + "=" + it->second);
  }
  query.shrink_to_fit();
  return query;
}

std::string proxygen::HTTPMessage::createUrl ( const folly::StringPiece  scheme, const folly::StringPiece  authority, const folly::StringPiece  path, const folly::StringPiece  query, const folly::StringPiece  fragment  )

static

Form the URL from the individual components. url -> {scheme}://{authority}{path}?{query}#{fragment}

Definition at line 561 of file HTTPMessage.cpp.

References folly::Range< Iter >::empty(), folly::Range< Iter >::size(), folly::Range< Iter >::str(), string, and folly::toAppend().

Referenced by PushService::generateUrl(), isResponse(), and setQueryString().

                                                                    {
  std::string url;
  url.reserve(scheme.size() + authority.size() + path.size() + query.size() +
                 fragment.size() + 5); // 5 chars for ://,? and #
  if (!scheme.empty()) {
    folly::toAppend(scheme.str(), "://", &url);
  }
  folly::toAppend(authority, path, &url);
  if (!query.empty()) {
    folly::toAppend('?', query, &url);
  }
  if (!fragment.empty()) {
    folly::toAppend('#', fragment, &url);
  }
  url.shrink_to_fit();
  return url;
}

void proxygen::HTTPMessage::describe

(

std::ostream &

os

)

const

Definition at line 680 of file HTTPMessage.cpp.

References chunked_, proxygen::HTTPMessage::Request::clientIP_, proxygen::HTTPMessage::Request::clientPort_, dstIP_, dstPort_, folly::gen::field(), fields_, proxygen::HTTPHeaders::forEach(), getMethodString(), h, headers_, localIP_, proxygen::HTTPMessage::Request::path_, proxygen::HTTPMessage::Request::pushStatusStr_, proxygen::HTTPMessage::Request::query_, request(), response(), proxygen::HTTPHeaders::size(), proxygen::HTTPMessage::Response::statusMsg_, proxygen::HTTPMessage::Response::statusStr_, proxygen::stripCntrlChars(), strippedPerHopHeaders_, upgraded_, proxygen::HTTPMessage::Request::url_, and versionStr_.

Referenced by getUpgradeProtocol(), and proxygen::operator<<().

                                               {
  os << ", chunked: " << chunked_
     << ", upgraded: " << upgraded_
     << ", Fields for message:" << std::endl;

  // Common fields to both requests and responses.
  std::vector<std::pair<const char*, const std::string*>> fields {{
      {"local_ip", &localIP_},
      {"version", &versionStr_},
      {"dst_ip", &dstIP_},
      {"dst_port", &dstPort_},
  }};

  if (fields_.type() == typeid(Request)) {
    // Request fields.
    const Request& req = request();
    fields.push_back(make_pair("client_ip", &req.clientIP_));
    fields.push_back(make_pair("client_port", &req.clientPort_));
    fields.push_back(make_pair("method", &getMethodString()));
    fields.push_back(make_pair("path", &req.path_));
    fields.push_back(make_pair("query", &req.query_));
    fields.push_back(make_pair("url", &req.url_));
    fields.push_back(make_pair("push_status", &req.pushStatusStr_));
  } else if (fields_.type() == typeid(Response)) {
    // Response fields.
    const Response& resp = response();
    fields.push_back(make_pair("status", &resp.statusStr_));
    fields.push_back(make_pair("status_msg", &resp.statusMsg_));
  }

  for (auto field : fields) {
    if (!field.second->empty()) {
      os << " " << field.first
         << ":" << stripCntrlChars(*field.second) << std::endl;
    }
  }

  headers_.forEach([&] (const string& h, const string& v) {
      os << " " << stripCntrlChars(h) << ": "
         << stripCntrlChars(v) << std::endl;
    });
  if (strippedPerHopHeaders_.size() > 0) {
    os << "Per-Hop Headers" << std::endl;
    strippedPerHopHeaders_.forEach([&] (const string& h, const string& v) {
        os << " " << stripCntrlChars(h) << ": "
           << stripCntrlChars(v) << std::endl;
      });
  }
}

bool proxygen::HTTPMessage::doHeaderTokenCheck ( const HTTPHeaders &  headers_, const HTTPHeaderCode  headerCode, char const *  token, bool  caseSensitive  ) const

private

Definition at line 788 of file HTTPMessage.cpp.

References c, folly::test::end(), proxygen::HTTPHeaders::forEachValueOfHeader(), proxygen::isLWS(), cpp.ast::next(), folly::Range< Iter >::reset(), and value.

Referenced by checkForHeaderToken(), and computeKeepalive().

                                                               {
  StringPiece tokenPiece(token);
  string lowerToken;
  if (!caseSensitive) {
    lowerToken = token;
    boost::to_lower(lowerToken, defaultLocale);
    tokenPiece.reset(lowerToken);
  }

  // Search through all of the headers with this name.
  // forEachValueOfHeader will return true iff it was "broken" prematurely
  // with "return true" in the lambda-function
  return headers.forEachValueOfHeader(headerCode, [&] (const string& value) {
    string lower;
    // Use StringPiece, since it implements a faster find() than std::string
    StringPiece headerValue;
    if (caseSensitive) {
      headerValue.reset(value);
    } else {
      // TODO: We only perform ASCII lowering right now.  Technically the
      // headers could contain data in other encodings, if encoded according
      // to RFC 2047 (encoded strings will start with "=?").
      lower = value;
      boost::to_lower(lower, defaultLocale);
      headerValue.reset(lower);
    }

    // Look for the specified token
    size_t idx = 0;
    size_t end = headerValue.size();
    while (idx < end) {
      idx = headerValue.find(tokenPiece, idx);
      if (idx == string::npos) {
        break;
      }

      // Search backwards to make sure we found the value at the beginning
      // of a token.
      bool at_token_start = false;
      size_t prev = idx;
      while (true) {
        if (prev == 0) {
          at_token_start = true;
          break;
        }
        --prev;
        char c = headerValue[prev];
        if (c == ',') {
          at_token_start = true;
          break;
        }
        if (!isLWS(c)) {
          // not at a token start
          break;
        }
      }
      if (!at_token_start) {
        idx += 1;
        continue;
      }

      // Search forwards to see if we found the value at the end of a token
      bool at_token_end = false;
      size_t next = idx + tokenPiece.size();
      while (true) {
        if (next >= end) {
          at_token_end = true;
          break;
        }
        char c = headerValue[next];
        if (c == ',') {
          at_token_end = true;
          break;
        }
        if (!isLWS(c)) {
          // not at a token end
          break;
        }
        ++next;
      }
      if (at_token_end) {
        // We found the token we're looking for
        return true;
      }

      idx += 1;
    }
    return false; // keep processing
  });
}

void proxygen::HTTPMessage::dumpMessage

(

int

verbosity

)

const

Print the message out.

Definition at line 676 of file HTTPMessage.cpp.

Referenced by atomicDumpMessage(), getUpgradeProtocol(), and CurlService::CurlClient::sendRequest().

                                                 {
  VLOG(vlogLevel) << *this;
}

void proxygen::HTTPMessage::dumpMessageToSink

(

google::LogSink *

logSink

)

const

Print the message out to logSink.

Definition at line 736 of file HTTPMessage.cpp.

Referenced by getUpgradeProtocol().

                                                                {
  LOG_TO_SINK(logSink, INFO) << *this;
}

void proxygen::HTTPMessage::ensureHostHeader

(

)

Ensures this HTTPMessage contains a host header, adding a default one with the destination address if necessary.

Definition at line 327 of file HTTPMessage.cpp.

References proxygen::HTTPHeaders::add(), proxygen::HTTPHeaders::exists(), getDstAddress(), getDstIP(), headers_, and proxygen::HTTP_HEADER_HOST.

Referenced by is5xxResponse(), and TEST().

                                   {
  if (!headers_.exists(HTTP_HEADER_HOST)) {
    headers_.add(HTTP_HEADER_HOST,
                 getDstAddress().getFamily() == AF_INET6
                 ? '[' + getDstIP() + ']' : getDstIP());
  }
}

HTTPHeaders&& proxygen::HTTPMessage::extractHeaders ( )

inline

Move headers out of current message (returns rvalue ref)

Definition at line 279 of file HTTPMessage.h.

References headers_, and folly::gen::move.

                                 {
    return std::move(headers_);
  }

string proxygen::HTTPMessage::formatDateHeader ( )

static

Formats the current time appropriately for a Date header

Definition at line 321 of file HTTPMessage.cpp.

References folly::SingletonThreadLocal< T, Tag, Make, TLTag >::get().

Referenced by proxygen::HTTP1xCodec::addDateHeader(), is5xxResponse(), proxygen::CodecUtil::prepareMessageForCompression(), and proxygen::SPDYCodec::serializeResponseHeaders().

                                     {
  struct DateTag {};
  auto& obj = folly::SingletonThreadLocal<FormattedDate, DateTag>::get();
  return obj.formatDate();
}

const std::string* proxygen::HTTPMessage::getAdvancedProtocolString ( ) const

inline

Definition at line 548 of file HTTPMessage.h.

References protoStr_.

                                                     {
    return protoStr_;
  }

const folly::SocketAddress& proxygen::HTTPMessage::getClientAddress ( ) const

inline

Definition at line 104 of file HTTPMessage.h.

References proxygen::HTTPMessage::Request::clientAddress_, and request().

                                                     {
    return request().clientAddress_;
  }

const std::string& proxygen::HTTPMessage::getClientIP ( ) const

inline

Definition at line 108 of file HTTPMessage.h.

References proxygen::HTTPMessage::Request::clientIP_, and request().

                                       {
    return request().clientIP_;
  }

const std::string& proxygen::HTTPMessage::getClientPort ( ) const

inline

Definition at line 112 of file HTTPMessage.h.

References proxygen::HTTPMessage::Request::clientPort_, and request().

                                         {
    return request().clientPort_;
  }

const StringPiece proxygen::HTTPMessage::getCookie

(

const std::string &

name

)

const

Get the cookie with the specified name.

Returns a StringPiece to the cookie value, or an empty StringPiece if there is no cookie with the specified name. The returned cookie is only valid as long as the Cookie Header in HTTPMessage object exists. Applications should make sure they call unparseCookies() when editing the Cookie Header, so that the StringPiece references are cleared.

Definition at line 401 of file HTTPMessage.cpp.

References cookies_, parseCookies(), parsedCookies_, and unparseCookies().

Referenced by getUpgradeProtocol(), and TEST().

                                                                 {
 // clear previous parsed cookies.  They might store raw pointers to a vector
  // in headers_, which can resize on add()
  // Parse the cookies if we haven't done so yet
  unparseCookies();
  if (!parsedCookies_) {
    parseCookies();
  }

  auto it = cookies_.find(name);
  if (it == cookies_.end()) {
    return StringPiece();
  } else {
    return it->second;
  }
}

std::string proxygen::HTTPMessage::getDecodedQueryParam

(

const std::string &

name

)

const

Get the query parameter with the specified name after percent decoding.

Returns empty string if parameter is missing or folly::uriUnescape query param

Definition at line 482 of file HTTPMessage.cpp.

References folly::exceptionStr(), getQueryParam(), folly::QUERY, string, folly::uriUnescape(), and val.

Referenced by getUpgradeProtocol(), and TEST().

                                                                       {
  auto val = getQueryParam(name);

  std::string result;
  try {
    folly::uriUnescape(val, result, folly::UriEscapeMode::QUERY);
  } catch (const std::exception& ex) {
    LOG(WARNING) << "Invalid escaped query param: " << folly::exceptionStr(ex);
  }
  return result;
}

const char * proxygen::HTTPMessage::getDefaultReason ( uint16_t  status )

static

Get the default reason string for a status code.

This returns the reason string for the specified status code as specified in RFC 2616. For unknown status codes, the string "-" is returned.

Definition at line 882 of file HTTPMessage.cpp.

Referenced by proxygen::HTTP1xCodec::generateHeader(), proxygen::HeaderDecodeInfo::onHeader(), proxygen::HTTPDirectResponseHandler::onHeadersComplete(), and setStartTime().

                                                         {
  switch (status) {
    case 100: return "Continue";
    case 101: return "Switching Protocols";
    case 200: return "OK";
    case 201: return "Created";
    case 202: return "Accepted";
    case 203: return "Non-Authoritative Information";
    case 204: return "No Content";
    case 205: return "Reset Content";
    case 206: return "Partial Content";
    case 300: return "Multiple Choices";
    case 301: return "Moved Permanently";
    case 302: return "Found";
    case 303: return "See Other";
    case 304: return "Not Modified";
    case 305: return "Use Proxy";
    case 307: return "Temporary Redirect";
    case 400: return "Bad Request";
    case 401: return "Unauthorized";
    case 402: return "Payment Required";
    case 403: return "Forbidden";
    case 404: return "Not Found";
    case 405: return "Method Not Allowed";
    case 406: return "Not Acceptable";
    case 407: return "Proxy Authentication Required";
    case 408: return "Request Timeout";
    case 409: return "Conflict";
    case 410: return "Gone";
    case 411: return "Length Required";
    case 412: return "Precondition Failed";
    case 413: return "Request Entity Too Large";
    case 414: return "Request-URI Too Long";
    case 415: return "Unsupported Media Type";
    case 416: return "Requested Range Not Satisfiable";
    case 417: return "Expectation Failed";
    case 418: return "I'm a teapot";
    case 500: return "Internal Server Error";
    case 501: return "Not Implemented";
    case 502: return "Bad Gateway";
    case 503: return "Service Unavailable";
    case 504: return "Gateway Timeout";
    case 505: return "HTTP Version Not Supported";
  }

  // Note: Some Microsoft clients behave badly if the reason string
  // is left empty.  Therefore return a non-empty string here.
  return "-";
}

const folly::SocketAddress& proxygen::HTTPMessage::getDstAddress ( ) const

inline

Definition at line 132 of file HTTPMessage.h.

References dstAddress_.

Referenced by ensureHostHeader().

                                                  {
    return dstAddress_;
  }

const std::string& proxygen::HTTPMessage::getDstIP ( ) const

inline

Definition at line 136 of file HTTPMessage.h.

References dstIP_.

Referenced by ensureHostHeader().

                                    {
    return dstIP_;
  }

const std::string& proxygen::HTTPMessage::getDstPort ( ) const

inline

Definition at line 140 of file HTTPMessage.h.

References dstPort_.

                                      {
    return dstPort_;
  }

HTTPHeaders& proxygen::HTTPMessage::getHeaders ( )

inline

Access the headers (fpreq, fpres)

Definition at line 273 of file HTTPMessage.h.

References headers_.

Referenced by proxygen::HTTPArchive::convertToHPACK(), TestPriorityMapBuilder::createVirtualStreams(), CurlService::CurlClient::CurlClient(), doEmptyHeaderValueTest(), proxygen::SPDYCodec::encodeHeaders(), ZlibServerFilterTest::exercise_compression(), HTTPDownstreamTest< SPDY3_1CodecPair >::expect101(), proxygen::HTTPArchive::fromFile(), proxygen::HTTPArchive::fromPublicFile(), proxygen::HTTPChecks::generateHeader(), proxygen::HTTP1xCodec::generateHeader(), proxygen::HTTP2Codec::generateHeaderImpl(), PushService::generateUrl(), proxygen::getBigGetRequest(), proxygen::getChunkedPostRequest(), proxygen::getGetRequest(), proxygen::getPostRequest(), proxygen::getPubRequest(), proxygen::getResponse(), CurlService::CurlClient::getServerName(), proxygen::HTTPArchive::getSize(), getSynStream(), proxygen::getUpgradeRequest(), proxygen::compress::SimStreamingCallback::onHeader(), proxygen::HTTPDirectResponseHandler::onHeadersComplete(), proxygen::compress::SimStreamingCallback::onHeadersComplete(), proxygen::HTTP2Codec::onIngressUpgradeMessage(), proxygen::HTTPDownstreamSession::onNativeProtocolUpgrade(), proxygen::operator==(), proxygen::compress::prepareMessageForCompression(), proxygen::CodecUtil::prepareMessageForCompression(), proxygen::HTTP2Codec::requestUpgrade(), proxygen::HTTPHandlerBase::sendHeaders(), proxygen::HTTPTransaction::sendHeadersWithOptionalEOM(), proxygen::MockHTTPPushHandler::sendPushHeaders(), CurlService::CurlClient::sendRequest(), proxygen::SPDYCodec::serializeRequestHeaders(), proxygen::SPDYCodec::serializeResponseHeaders(), proxygen::HTTPRequestVerifier::setAuthority(), TEST(), TEST_F(), TEST_P(), HTTPUpstreamTest< C >::testBasicRequestHttp10(), and HTTP2CodecTest::testHeaderListSize().

{ return headers_; }

const HTTPHeaders& proxygen::HTTPMessage::getHeaders ( ) const

inline

Definition at line 274 of file HTTPMessage.h.

References headers_.

{ return headers_; }

folly::Optional<HTTPPriority> proxygen::HTTPMessage::getHTTP2Priority ( ) const

inline

Definition at line 594 of file HTTPMessage.h.

References h2Pri_.

Referenced by proxygen::HTTP2Codec::generateHeaderImpl(), and proxygen::HTTPSession::getMessagePriority().

          {
    return h2Pri_;
  }

const pair< uint8_t, uint8_t > & proxygen::HTTPMessage::getHTTPVersion

(

)

const

Definition at line 262 of file HTTPMessage.cpp.

References version_.

Referenced by proxygen::HTTP1xCodec::generateHeader().

                                                                {
  return version_;
}

const HTTPHeaderSize& proxygen::HTTPMessage::getIngressHeaderSize ( ) const

inline

Definition at line 615 of file HTTPMessage.h.

References size_.

Referenced by HTTP1xCodecCallback::onHeadersComplete().

                                                     {
    return size_;
  }

int proxygen::HTTPMessage::getIntQueryParam

(

const std::string &

name

)

const

Get the query parameter with the specified name as int.

If the conversion fails, throws exception.

Definition at line 469 of file HTTPMessage.cpp.

References getQueryParam().

Referenced by getIntQueryParam(), getUpgradeProtocol(), and TEST().

                                                             {
  return folly::to<int>(getQueryParam(name));
}

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

Get the query parameter with the specified name as int.

Returns the query parameter if it can be parsed as int otherwise the default value.

Definition at line 473 of file HTTPMessage.cpp.

References getIntQueryParam().

                                                                         {
  try {
    return getIntQueryParam(name);
  } catch (const std::exception& ex) {
  }

  return defval;
}

bool proxygen::HTTPMessage::getIsChunked ( ) const

inline

Definition at line 80 of file HTTPMessage.h.

References chunked_.

Referenced by ZlibServerFilterTest::exercise_compression(), proxygen::HTTP1xCodec::generateHeader(), and TEST_F().

{ return chunked_; }

bool proxygen::HTTPMessage::getIsUpgraded ( ) const

inline

Definition at line 86 of file HTTPMessage.h.

References upgraded_.

{ return upgraded_; }

const std::string& proxygen::HTTPMessage::getLocalIp ( ) const

inline

Definition at line 151 of file HTTPMessage.h.

References localIP_, and setMethod().

                                      {
    return localIP_;
  }

folly::Optional< HTTPMethod > proxygen::HTTPMessage::getMethod

(

)

const

an HTTPMethod enum value representing the method if it is a standard request method, or else "none" if it is an extension method (fpreq)

Definition at line 235 of file HTTPMessage.cpp.

References folly::none, and request().

Referenced by proxygen::HTTPChecks::generateHeader(), proxygen::HTTP1xCodec::generateHeader(), proxygen::HTTP2Codec::onHeadersComplete(), proxygen::compress::prepareMessageForCompression(), proxygen::CodecUtil::prepareMessageForCompression(), processMaxForwards(), rawSetMethod(), proxygen::HTTPTransaction::sendHeadersWithOptionalEOM(), TEST(), and proxygen::HTTPRequestVerifier::validate().

                                                       {
  const auto& req = request();
  if (req.method_.which() == 2) {
    return boost::get<HTTPMethod>(req.method_);
  }
  return folly::none;
}

const std::string & proxygen::HTTPMessage::getMethodString

(

)

const

a string representation of the request method (fpreq)

Definition at line 246 of file HTTPMessage.cpp.

References proxygen::empty_string, proxygen::methodToString(), and request().

Referenced by describe(), proxygen::HTTP1xCodec::generateHeader(), proxygen::operator==(), proxygen::compress::prepareMessageForCompression(), proxygen::CodecUtil::prepareMessageForCompression(), rawSetMethod(), proxygen::SPDYCodec::serializeRequestHeaders(), and TEST().

                                                    {
  const auto& req = request();
  if (req.method_.which() == 1) {
    return boost::get<std::string>(req.method_);
  } else if (req.method_.which() == 2) {
    return methodToString(boost::get<HTTPMethod>(req.method_));
  }
  return empty_string;
}

const std::string& proxygen::HTTPMessage::getPath ( ) const

inline

Access the path component (fpreq)

Definition at line 215 of file HTTPMessage.h.

References proxygen::HTTPMessage::Request::path_, and request().

Referenced by testPathAndQuery().

                                   {
    return request().path_;
  }

uint8_t proxygen::HTTPMessage::getPriority ( ) const

inline

Definition at line 590 of file HTTPMessage.h.

References pri_.

Referenced by proxygen::SPDYCodec::generateSynStream(), and proxygen::HTTPSession::getMessagePriority().

{ return pri_; }

const std::string& proxygen::HTTPMessage::getProtocolString ( ) const

inline

Return the protocol string used by this HTTPMessage.

If this HTTP message is using an advanced protocol, the protocol string will be the advanced protocol. If not, it will simply be the HTTP version.

Definition at line 558 of file HTTPMessage.h.

References isAdvancedProto(), protoStr_, and versionStr_.

Referenced by TEST().

                                             {
    if (isAdvancedProto()) {
      return *protoStr_;
    }

    return versionStr_;
  }

uint16_t proxygen::HTTPMessage::getPushStatusCode

(

)

const

Definition at line 353 of file HTTPMessage.cpp.

References proxygen::HTTPMessage::Request::pushStatus_, and request().

Referenced by getUpgradeProtocol().

                                             {
  return request().pushStatus_;
}

const std::string & proxygen::HTTPMessage::getPushStatusStr

(

)

const

Definition at line 349 of file HTTPMessage.cpp.

References proxygen::HTTPMessage::Request::pushStatusStr_, and request().

Referenced by getUpgradeProtocol(), and proxygen::SPDYCodec::serializeRequestHeaders().

                                                    {
  return request().pushStatusStr_;
}

const string & proxygen::HTTPMessage::getQueryParam

(

const std::string &

name

)

const

Get the query parameter with the specified name.

Returns a reference to the query parameter value, or proxygen::empty_string if there is no parameter with the specified name. The returned value is only valid as long as this HTTPMessage object.

Definition at line 464 of file HTTPMessage.cpp.

References proxygen::empty_string, and getQueryParamPtr().

Referenced by getDecodedQueryParam(), getIntQueryParam(), getUpgradeProtocol(), and TEST().

                                                                 {
  const string* ret = getQueryParamPtr(name);
  return ret ? *ret : empty_string;
}

const string * proxygen::HTTPMessage::getQueryParamPtr

(

const std::string &

name

)

const

Get the query parameter with the specified name.

Returns a pointer to the query parameter value, or nullptr if there is no parameter with the specified name. The returned value is only valid as long as this HTTPMessage object.

Definition at line 447 of file HTTPMessage.cpp.

References parsedQueryParams_, parseQueryParams(), and queryParams_.

Referenced by getQueryParam(), getUpgradeProtocol(), and hasQueryParam().

                                                                    {
  // Parse the query parameters if we haven't done so yet
  if (!parsedQueryParams_) {
    parseQueryParams();
  }

  auto it = queryParams_.find(name);
  if (it == queryParams_.end()) {
    return nullptr;
  }
  return &it->second;
}

const std::map< std::string, std::string > & proxygen::HTTPMessage::getQueryParams

(

)

const

Get all the query parameters.

Returns a reference to the query parameters map. The returned value is only valid as long as this HTTPMessage object.

Definition at line 494 of file HTTPMessage.cpp.

References parsedQueryParams_, parseQueryParams(), and queryParams_.

Referenced by getUpgradeProtocol().

                                                                      {
  // Parse the query parameters if we haven't done so yet
  if (!parsedQueryParams_) {
    parseQueryParams();
  }
  return queryParams_;
}

const std::string& proxygen::HTTPMessage::getQueryString ( ) const

inline

Access the query component (fpreq)

Definition at line 222 of file HTTPMessage.h.

References proxygen::HTTPMessage::Request::query_, and request().

Referenced by testPathAndQuery(), testRemoveQueryParam(), and testSetQueryParam().

                                          {
    return request().query_;
  }

const char* proxygen::HTTPMessage::getSecureCipher ( ) const

inline

Definition at line 537 of file HTTPMessage.h.

References sslCipher_.

{ return sslCipher_; }

int proxygen::HTTPMessage::getSecureVersion ( ) const

inline

Definition at line 536 of file HTTPMessage.h.

References sslVersion_.

{ return sslVersion_; }

int32_t proxygen::HTTPMessage::getSeqNo ( ) const

inline

Definition at line 607 of file HTTPMessage.h.

References seqNo_.

{ return seqNo_; }

TimePoint proxygen::HTTPMessage::getStartTime ( ) const

inline

Getter and setter for the time when the first byte of the message arrived

Definition at line 622 of file HTTPMessage.h.

References startTime_.

Referenced by proxygen::compress::CompressionSimulator::readInputFromFileAndSchedule().

{ return startTime_; }

uint16_t proxygen::HTTPMessage::getStatusCode

(

)

const

Definition at line 340 of file HTTPMessage.cpp.

References response(), and proxygen::HTTPMessage::Response::status_.

Referenced by HTTPDownstreamTest< SPDY3_1CodecPair >::expect101(), proxygen::HTTP1xCodec::generateHeader(), hasTrailers(), is1xxResponse(), is4xxResponse(), is5xxResponse(), proxygen::HTTP2Codec::onHeadersComplete(), proxygen::HTTPDownstreamSession::onHeadersSent(), proxygen::CodecUtil::prepareMessageForCompression(), proxygen::HTTPTransaction::sendHeadersWithOptionalEOM(), proxygen::SPDYCodec::serializeResponseHeaders(), DownstreamTransactionTest::setupRequestResponseFlow(), and TEST_F().

                                          {
  return response().status_;
}

const std::string& proxygen::HTTPMessage::getStatusMessage ( ) const

inline

Definition at line 245 of file HTTPMessage.h.

References response(), and proxygen::HTTPMessage::Response::statusMsg_.

Referenced by HTTPDownstreamTest< SPDY3_1CodecPair >::expect101(), proxygen::HTTP1xCodec::generateHeader(), and proxygen::SPDYCodec::serializeResponseHeaders().

                                            {
    return response().statusMsg_;
  }

const HTTPHeaders& proxygen::HTTPMessage::getStrippedPerHopHeaders ( ) const

inline

Definition at line 530 of file HTTPMessage.h.

References strippedPerHopHeaders_.

Referenced by TEST().

                                                      {
    return strippedPerHopHeaders_;
  }

HTTPHeaders* proxygen::HTTPMessage::getTrailers ( )

inline

Access the trailers

Definition at line 286 of file HTTPMessage.h.

References trailers_.

{ return trailers_.get(); }

const HTTPHeaders* proxygen::HTTPMessage::getTrailers ( ) const

inline

Definition at line 287 of file HTTPMessage.h.

References trailers_.

{ return trailers_.get(); }

const std::string* proxygen::HTTPMessage::getUpgradeProtocol ( ) const

inline

Definition at line 378 of file HTTPMessage.h.

References atomicDumpMessage(), constructDirectResponse(), describe(), dumpMessage(), dumpMessageToSink(), getCookie(), getDecodedQueryParam(), getIntQueryParam(), getPushStatusCode(), getPushStatusStr(), getQueryParam(), getQueryParamPtr(), getQueryParams(), hasQueryParam(), name, removeQueryParam(), setPushStatusCode(), setQueryParam(), setQueryString(), statusCode, string, stripPerHopHeaders(), uint16_t, upgradeProtocol_, value, upload::verbosity, and version.

Referenced by proxygen::HTTP2Codec::onHeadersComplete().

                                              {
    return upgradeProtocol_.get();
  }

const std::string& proxygen::HTTPMessage::getURL ( ) const

inline

Definition at line 205 of file HTTPMessage.h.

References request(), and proxygen::HTTPMessage::Request::url_.

Referenced by proxygen::HTTP1xCodec::generateHeader(), proxygen::operator==(), proxygen::compress::prepareMessageForCompression(), proxygen::CodecUtil::prepareMessageForCompression(), proxygen::SPDYCodec::serializeRequestHeaders(), testPathAndQuery(), testRemoveQueryParam(), and testSetQueryParam().

                                  {
    return request().url_;
  }

const std::string& proxygen::HTTPMessage::getVersionString ( ) const

inline

Get/Set the HTTP version string (like "1.1"). XXX: Note we only support X.Y format while setting version.

Definition at line 256 of file HTTPMessage.h.

References versionStr_.

                                            {
    return versionStr_;
  }

bool proxygen::HTTPMessage::hasQueryParam

(

const std::string &

name

)

const

Check if query parameter with the specified name exists.

Definition at line 460 of file HTTPMessage.cpp.

References getQueryParamPtr().

Referenced by getUpgradeProtocol(), and TEST().

                                                        {
  return getQueryParamPtr(name) != nullptr;
}

bool proxygen::HTTPMessage::hasTrailers ( ) const

inline

Returns true if this message has trailers that need to be serialized

Definition at line 365 of file HTTPMessage.h.

References getStatusCode(), setStatusCode(), trailers_, trailersAllowed_, and uint16_t.

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

bool proxygen::HTTPMessage::is1xxResponse ( ) const

inline

Returns true if this is a 1xx response.

Definition at line 316 of file HTTPMessage.h.

References getStatusCode().

Referenced by proxygen::HTTP1xCodec::generateHeader().

{ return (getStatusCode() / 100) == 1; }

bool proxygen::HTTPMessage::is4xxResponse ( ) const

inline

Returns true if this is a 4xx response.

Definition at line 321 of file HTTPMessage.h.

References getStatusCode().

{ return (getStatusCode() / 100) == 4; }

bool proxygen::HTTPMessage::is5xxResponse ( ) const

inline

Returns true if this is a 5xx response.

Definition at line 326 of file HTTPMessage.h.

References ensureHostHeader(), formatDateHeader(), getStatusCode(), and string.

{ return (getStatusCode() / 100) == 5; }

bool proxygen::HTTPMessage::isAdvancedProto ( ) const

inline

Definition at line 545 of file HTTPMessage.h.

References protoStr_.

Referenced by getProtocolString().

                               {
    return protoStr_ != nullptr;
  }

bool proxygen::HTTPMessage::isEgressWebsocketUpgrade ( ) const

inline

Definition at line 72 of file HTTPMessage.h.

References upgradeWebsocket_.

Referenced by proxygen::HTTP1xCodec::generateHeader(), proxygen::HTTP2Codec::generateHeaderImpl(), and proxygen::CodecUtil::prepareMessageForCompression().

                                        {
    return upgradeWebsocket_ == WebSocketUpgrade::EGRESS;
  }

bool proxygen::HTTPMessage::isHTTP1_0

(

)

const

Returns true if the version of this message is HTTP/1.0

Definition at line 290 of file HTTPMessage.cpp.

References kHTTPVersion10, and version_.

Referenced by setTrailers().

                                  {
  return version_ == kHTTPVersion10;
}

bool proxygen::HTTPMessage::isHTTP1_1

(

)

const

Returns true if the version of this message is HTTP/1.1

Definition at line 294 of file HTTPMessage.cpp.

References kHTTPVersion11, and version_.

Referenced by setTrailers().

                                  {
  return version_ == kHTTPVersion11;
}

bool proxygen::HTTPMessage::isIngressWebsocketUpgrade ( ) const

inline

Definition at line 69 of file HTTPMessage.h.

References upgradeWebsocket_.

                                         {
    return upgradeWebsocket_ == WebSocketUpgrade::INGRESS;
  }

bool proxygen::HTTPMessage::isRequest ( ) const

inline

Returns

true if this HTTPMessage represents an HTTP request

Definition at line 661 of file HTTPMessage.h.

References fields_.

Referenced by proxygen::HTTPChecks::generateHeader(), proxygen::HTTP2Codec::generateHeaderImpl(), proxygen::CodecUtil::prepareMessageForCompression(), and proxygen::HTTPTransaction::sendHeadersWithOptionalEOM().

                         {
    return fields_.which() == 1;
  }

bool proxygen::HTTPMessage::isResponse ( ) const

inline

Returns

true if this HTTPMessage represents an HTTP response

Definition at line 668 of file HTTPMessage.h.

References createQueryString(), createUrl(), fields_, params, splitNameValue(), splitNameValuePieces(), string, and uint32_t.

Referenced by proxygen::CodecUtil::prepareMessageForCompression(), and proxygen::HTTPTransaction::sendHeadersWithOptionalEOM().

                          {
    return fields_.which() == 2;
  }

bool proxygen::HTTPMessage::isSecure ( ) const

inline

Definition at line 535 of file HTTPMessage.h.

References secure_.

Referenced by PushService::generateUrl(), proxygen::operator==(), proxygen::compress::prepareMessageForCompression(), proxygen::CodecUtil::prepareMessageForCompression(), and proxygen::SPDYCodec::serializeRequestHeaders().

{ return secure_; }

static uint8_t proxygen::HTTPMessage::normalizePriority ( int8_t  pri )

inlinestatic

Definition at line 576 of file HTTPMessage.h.

References kMaxPriority.

Referenced by setPriority(), and proxygen::HTTPTransaction::updateAndSendPriority().

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

HTTPMessage & proxygen::HTTPMessage::operator=

(

const HTTPMessage &

message

)

Definition at line 142 of file HTTPMessage.cpp.

References chunked_, cookies_, dstAddress_, dstIP_, dstPort_, fields_, h2Pri_, headers_, localIP_, parsedCookies_, parsedQueryParams_, pri_, protoStr_, queryParams_, secure_, seqNo_, sslCipher_, sslVersion_, startTime_, strippedPerHopHeaders_, trailers_, trailersAllowed_, upgraded_, upgradeWebsocket_, version_, versionStr_, and wantsKeepalive_.

                                                              {
  if (&message == this) {
    return *this;
  }
  startTime_ = message.startTime_;
  seqNo_ = message.seqNo_;
  dstAddress_ = message.dstAddress_;
  dstIP_ = message.dstIP_;
  dstPort_ = message.dstPort_;
  localIP_ = message.localIP_;
  versionStr_ = message.versionStr_;
  fields_ = message.fields_;
  cookies_ = message.cookies_;
  queryParams_ = message.queryParams_;
  version_ = message.version_;
  headers_ = message.headers_;
  strippedPerHopHeaders_ = message.strippedPerHopHeaders_;
  sslVersion_ = message.sslVersion_;
  sslCipher_ = message.sslCipher_;
  protoStr_ = message.protoStr_;
  pri_ = message.pri_;
  h2Pri_ = message.h2Pri_;
  parsedCookies_ = message.parsedCookies_;
  parsedQueryParams_ = message.parsedQueryParams_;
  chunked_ = message.chunked_;
  upgraded_ = message.upgraded_;
  wantsKeepalive_ = message.wantsKeepalive_;
  trailersAllowed_ = message.trailersAllowed_;
  secure_ = message.secure_;
  upgradeWebsocket_ = message.upgradeWebsocket_;

  if (message.trailers_) {
    trailers_ = std::make_unique<HTTPHeaders>(*message.trailers_);
  } else {
    trailers_.reset();
  }
  return *this;
}

HTTPMessage & proxygen::HTTPMessage::operator=

(

HTTPMessage &&

message

)

Definition at line 181 of file HTTPMessage.cpp.

References chunked_, cookies_, dstAddress_, dstIP_, dstPort_, fields_, h2Pri_, headers_, localIP_, folly::gen::move, parsedCookies_, parsedQueryParams_, pri_, protoStr_, queryParams_, secure_, seqNo_, sslCipher_, sslVersion_, startTime_, strippedPerHopHeaders_, trailers_, trailersAllowed_, upgraded_, upgradeWebsocket_, version_, versionStr_, and wantsKeepalive_.

                                                         {
  if (&message == this) {
    return *this;
  }
  startTime_ = message.startTime_;
  seqNo_ = message.seqNo_;
  dstAddress_ = std::move(message.dstAddress_);
  dstIP_ = std::move(message.dstIP_);
  dstPort_ = message.dstPort_;
  localIP_ = std::move(message.localIP_);
  versionStr_ = std::move(message.versionStr_);
  fields_ = std::move(message.fields_);
  cookies_ = std::move(message.cookies_);
  queryParams_ = std::move(message.queryParams_);
  version_ = message.version_;
  headers_ = std::move(message.headers_);
  strippedPerHopHeaders_ = std::move(message.strippedPerHopHeaders_);
  sslVersion_ = message.sslVersion_;
  sslCipher_ = message.sslCipher_;
  protoStr_ = message.protoStr_;
  pri_ = message.pri_;
  h2Pri_ = message.h2Pri_;
  parsedCookies_ = message.parsedCookies_;
  parsedQueryParams_ = message.parsedQueryParams_;
  chunked_ = message.chunked_;
  upgraded_ = message.upgraded_;
  wantsKeepalive_ = message.wantsKeepalive_;
  trailersAllowed_ = message.trailersAllowed_;
  secure_ = message.secure_;
  upgradeWebsocket_ = message.upgradeWebsocket_;

  trailers_ = std::move(message.trailers_);
  return *this;
}

void proxygen::HTTPMessage::parseCookies ( ) const

private

Definition at line 381 of file HTTPMessage.cpp.

References cookies_, proxygen::HTTPHeaders::forEachValueOfHeader(), headers_, proxygen::HTTP_HEADER_COOKIE, parsedCookies_, and splitNameValuePieces().

Referenced by getCookie().

                                     {
  DCHECK(!parsedCookies_);
  parsedCookies_ = true;

  headers_.forEachValueOfHeader(HTTP_HEADER_COOKIE,
                                [&](const string& headerval) {
    splitNameValuePieces(headerval, ';', '=',
        [this](StringPiece cookieName, StringPiece cookieValue) {
          cookies_.emplace(cookieName, cookieValue);
        });

    return false; // continue processing "cookie" headers
  });
}

void proxygen::HTTPMessage::parseQueryParams ( ) const

private

Definition at line 418 of file HTTPMessage.cpp.

References parsedQueryParams_, proxygen::HTTPMessage::Request::query_, request(), and splitNameValue().

Referenced by getQueryParamPtr(), getQueryParams(), removeQueryParam(), and setQueryParam().

                                         {
  DCHECK(!parsedQueryParams_);
  const Request& req = request();

  parsedQueryParams_ = true;
  if (req.query_.empty()) {
    return;
  }

  splitNameValue(req.query_, '&', '=',
        [this] (string&& paramName, string&& paramValue) {

    auto it = queryParams_.find(paramName);
    if (it == queryParams_.end()) {
      queryParams_.emplace(std::move(paramName), std::move(paramValue));
    } else {
      // We have some unit tests that make sure we always return the last
      // value when there are duplicate parameters. I don't think this really
      // matters, but for now we might as well maintain the same behavior.
      it->second = std::move(paramValue);
    }
  });
}

int proxygen::HTTPMessage::processMaxForwards

(

)

Decrements Max-Forwards header, when present on OPTIONS or TRACE methods.

Returns HTTP status code.

Definition at line 266 of file HTTPMessage.cpp.

References getMethod(), proxygen::HTTPHeaders::getSingleOrEmpty(), headers_, proxygen::HTTP_HEADER_MAX_FORWARDS, int64_t, proxygen::OPTIONS, proxygen::HTTPHeaders::set(), proxygen::TRACE, and value.

Referenced by setTrailers().

                                    {
  if (getMethod() == HTTPMethod::TRACE || getMethod()  == HTTPMethod::OPTIONS) {
    const string& value = headers_.getSingleOrEmpty(HTTP_HEADER_MAX_FORWARDS);
    if (value.length() > 0) {
      int64_t max_forwards = 0;
      try {
        max_forwards = folly::to<int64_t>(value);
      } catch (const std::range_error& ex) {
        return 400;
      }

      if (max_forwards < 0) {
        return 400;
      } else if (max_forwards == 0) {
        return 501;
      } else {
        headers_.set(HTTP_HEADER_MAX_FORWARDS,
                     folly::to<string>(max_forwards - 1));
      }
    }
  }
  return 0;
}

void proxygen::HTTPMessage::rawSetMethod ( const std::string &  method )

inline

Definition at line 160 of file HTTPMessage.h.

References getMethod(), getMethodString(), setMethod(), and string.

                                             {
    setMethod(method);
  }

void proxygen::HTTPMessage::rawSetStatusMessage ( std::string  msg )

inline

Definition at line 248 of file HTTPMessage.h.

References setStatusMessage().

                                          {
    setStatusMessage(msg);
  }

void proxygen::HTTPMessage::rawSetURL ( const std::string &  url )

inline

Definition at line 208 of file HTTPMessage.h.

References setURL().

                                       {
    setURL(url);
  }

bool proxygen::HTTPMessage::removeQueryParam

(

const std::string &

name

)

Remove the query parameter with the specified name.

Returns true if the query parameter was present and deleted.

Definition at line 520 of file HTTPMessage.cpp.

References createQueryString(), parsedQueryParams_, parseQueryParams(), queryParams_, request(), and setQueryString().

Referenced by getUpgradeProtocol(), and testRemoveQueryParam().

                                                        {
  // Parse the query parameters if we haven't done so yet
  if (!parsedQueryParams_) {
    parseQueryParams();
  }

  if (!queryParams_.erase(name)) {
    // Query param was not found.
    return false;
  }

  auto query = createQueryString(queryParams_, request().query_.length());
  return setQueryString(query);
}

Request& proxygen::HTTPMessage::request ( )

inlineprivate

Definition at line 761 of file HTTPMessage.h.

References fields_.

Referenced by describe(), getClientAddress(), getClientIP(), getClientPort(), getMethod(), getMethodString(), getPath(), getPushStatusCode(), getPushStatusStr(), getQueryString(), getURL(), parseQueryParams(), removeQueryParam(), setClientAddress(), setMethod(), setPushStatusCode(), setQueryParam(), setQueryString(), and setURL().

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

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

const Request& proxygen::HTTPMessage::request ( ) const

inlineprivate

Definition at line 770 of file HTTPMessage.h.

References fields_.

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

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

Response& proxygen::HTTPMessage::response ( )

inlineprivate

Definition at line 779 of file HTTPMessage.h.

References fields_.

Referenced by describe(), getStatusCode(), getStatusMessage(), setStatusCode(), and setStatusMessage().

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

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

const Response& proxygen::HTTPMessage::response ( ) const

inlineprivate

Definition at line 788 of file HTTPMessage.h.

References fields_.

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

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

void proxygen::HTTPMessage::setAdvancedProtocolString ( const std::string &  protocol )

inline

Definition at line 542 of file HTTPMessage.h.

References protoStr_.

Referenced by TEST().

                                                            {
    protoStr_ = &protocol;
  }

void proxygen::HTTPMessage::setClientAddress ( const folly::SocketAddress &  addr, std::string  ipStr = empty_string, std::string  portStr = empty_string  )

inline

Set/Get client address

Definition at line 91 of file HTTPMessage.h.

References addr, proxygen::HTTPMessage::Request::clientAddress_, proxygen::HTTPMessage::Request::clientIP_, proxygen::HTTPMessage::Request::clientPort_, folly::SocketAddress::getAddressStr(), folly::SocketAddress::getPort(), folly::gen::move, and request().

                                                          {
    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);
    }
  }

void proxygen::HTTPMessage::setDstAddress ( const folly::SocketAddress &  addr, std::string  addressStr = empty_string, std::string  portStr = empty_string  )

inline

Set/Get destination (vip) address

Definition at line 119 of file HTTPMessage.h.

References addr, dstAddress_, dstIP_, dstPort_, folly::SocketAddress::getAddressStr(), folly::SocketAddress::getPort(), and folly::gen::move.

Referenced by TEST().

                                                       {
    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);
    }
  }

void proxygen::HTTPMessage::setEgressWebsocketUpgrade ( )

inline

Definition at line 66 of file HTTPMessage.h.

References upgradeWebsocket_.

Referenced by TEST(), and TEST_F().

                                   {
    upgradeWebsocket_ = WebSocketUpgrade::EGRESS;
  }

void proxygen::HTTPMessage::setHTTP2Priority ( HTTPPriority  h2Pri )

inline

Definition at line 599 of file HTTPMessage.h.

References h2Pri_.

Referenced by proxygen::MockHTTPPushHandler::sendPushHeaders(), and TEST_F().

                                            {
    h2Pri_ = h2Pri;
  }

void proxygen::HTTPMessage::setHTTPVersion	(	uint8_t	major,
		uint8_t	minor
	)

Access the HTTP version number (fpreq, fpres)

Definition at line 256 of file HTTPMessage.cpp.

References min, version_, and versionStr_.

Referenced by constructDirectResponse(), proxygen::getBigGetRequest(), proxygen::getChunkedPostRequest(), proxygen::getGetRequest(), proxygen::getPostRequest(), proxygen::getPubRequest(), proxygen::HTTPDirectResponseHandler::onHeadersComplete(), proxygen::HTTPDownstreamSession::onNativeProtocolUpgrade(), proxygen::HTTPHandlerBase::sendChunkedReplyWithBody(), proxygen::HTTPHandlerBase::sendHeaders(), CurlService::CurlClient::sendRequest(), setVersionString(), TEST(), TEST_F(), and HTTPUpstreamTest< C >::testBasicRequestHttp10().

                                                         {
  version_.first = maj;
  version_.second = min;
  versionStr_ = folly::to<string>(maj, ".", min);
}

void proxygen::HTTPMessage::setIngressHeaderSize ( const HTTPHeaderSize &  size )

inline

getter and setter for size in serialized form

Definition at line 612 of file HTTPMessage.h.

References folly::size(), and size_.

                                                        {
    size_ = size;
  }

void proxygen::HTTPMessage::setIngressWebsocketUpgrade ( )

inline

Definition at line 63 of file HTTPMessage.h.

References upgradeWebsocket_.

Referenced by proxygen::HTTP2Codec::onHeadersComplete().

                                    {
    upgradeWebsocket_ = WebSocketUpgrade::INGRESS;
  }

void proxygen::HTTPMessage::setIsChunked ( bool  chunked )

inline

Is this a chunked message? (fpreq, fpresp)

Definition at line 79 of file HTTPMessage.h.

References folly::gen::chunked(), and chunked_.

Referenced by constructDirectResponse(), proxygen::getChunkedPostRequest(), proxygen::HTTPHandlerBase::sendChunkedReplyWithBody(), and TEST().

{ chunked_ = chunked; }

void proxygen::HTTPMessage::setIsUpgraded ( bool  upgraded )

inline

Is this an upgraded message? (fpreq, fpresp)

Definition at line 85 of file HTTPMessage.h.

References upgraded_.

Referenced by constructDirectResponse().

{ upgraded_ = upgraded; }

template<typename T >

void proxygen::HTTPMessage::setLocalIp ( T &&  ip )

inline

Set/Get the local IP address

Definition at line 148 of file HTTPMessage.h.

References localIP_.

Referenced by TEST().

                          {
    localIP_ = std::forward<T>(ip);
  }

void proxygen::HTTPMessage::setMethod

(

HTTPMethod

method

)

Access the method (fpreq)

Definition at line 216 of file HTTPMessage.cpp.

References proxygen::HTTPMessage::Request::method_, and request().

Referenced by doEmptyHeaderValueTest(), proxygen::getBigGetRequest(), proxygen::getChunkedPostRequest(), proxygen::getGetRequest(), getLocalIp(), proxygen::getPostRequest(), proxygen::getPubRequest(), getSynStream(), proxygen::getUpgradeRequest(), proxygen::compress::SimStreamingCallback::onHeader(), rawSetMethod(), CurlService::CurlClient::sendRequest(), proxygen::HTTPRequestVerifier::setMethod(), TEST(), TEST_F(), and TEST_P().

                                             {
  Request& req = request();
  req.method_ = method;
}

void proxygen::HTTPMessage::setMethod

(

folly::StringPiece

method

)

Definition at line 221 of file HTTPMessage.cpp.

References proxygen::HTTPMessage::Request::method_, request(), folly::Range< Iter >::str(), proxygen::stringToMethod(), and folly::pushmi::operators::transform.

                                                   {
  VLOG(9) << "setMethod: " << method;
  Request& req = request();
  folly::Optional<HTTPMethod> result = stringToMethod(method);
  if (result) {
    req.method_ = *result;
  } else {
    req.method_ = method.str();
    auto& storedMethod = boost::get<std::string>(req.method_);
    std::transform(storedMethod.begin(), storedMethod.end(),
                   storedMethod.begin(), ::toupper);
  }
}

void proxygen::HTTPMessage::setPriority ( int8_t  pri )

inline

Definition at line 586 of file HTTPMessage.h.

References h2Pri_, folly::none, normalizePriority(), and pri_.

                               {
    pri_ = normalizePriority(pri);
    h2Pri_ = folly::none;
  }

void proxygen::HTTPMessage::setPushStatusCode

(

const uint16_t

status

)

Access the push status code

Definition at line 344 of file HTTPMessage.cpp.

References proxygen::HTTPMessage::Request::pushStatus_, proxygen::HTTPMessage::Request::pushStatusStr_, and request().

Referenced by getUpgradeProtocol(), TEST(), and TEST_F().

                                                   {
  request().pushStatus_ = status;
  request().pushStatusStr_ = folly::to<string>(status);
}

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

Sets the query parameter with the specified name to the specified value.

Returns true if the query parameter was successfully set.

Definition at line 535 of file HTTPMessage.cpp.

References createQueryString(), name, parsedQueryParams_, parseQueryParams(), queryParams_, request(), setQueryString(), and value.

Referenced by getUpgradeProtocol(), and testSetQueryParam().

                            {
  // Parse the query parameters if we haven't done so yet
  if (!parsedQueryParams_) {
    parseQueryParams();
  }

  queryParams_[name] = value;
  auto query = createQueryString(queryParams_, request().query_.length());
  return setQueryString(query);
}

bool proxygen::HTTPMessage::setQueryString

(

const std::string &

query

)

Set the query string to the specified value, and recreate the url_.

Returns true if the query string was changed successfully.

Definition at line 502 of file HTTPMessage.cpp.

References proxygen::ParseURL::authority(), createUrl(), proxygen::ParseURL::fragment(), proxygen::ParseURL::path(), proxygen::HTTPMessage::Request::query_, request(), proxygen::ParseURL::scheme(), proxygen::HTTPMessage::Request::url_, and proxygen::ParseURL::valid().

Referenced by getUpgradeProtocol(), removeQueryParam(), and setQueryParam().

                                                       {
  ParseURL u(request().url_);

  if (u.valid()) {
    // Recreate the URL by just changing the query string
    request().url_ = createUrl(u.scheme(),
                               u.authority(),
                               u.path(),
                               query, // new query string
                               u.fragment());
    request().query_ = query;
    return true;
  }

  VLOG(4) << "Error parsing URL during setQueryString: " << request().url_;
  return false;
}

void proxygen::HTTPMessage::setSecure ( bool  secure )

inline

Definition at line 534 of file HTTPMessage.h.

References secure_.

Referenced by proxygen::compress::SimStreamingCallback::onHeader(), CurlService::CurlClient::sendRequest(), proxygen::HTTPRequestVerifier::setScheme(), and TEST_F().

{ secure_ = secure; }

void proxygen::HTTPMessage::setSecureInfo ( int  ver, const char *  cipher  )

inline

Definition at line 538 of file HTTPMessage.h.

References cipher, sslCipher_, and sslVersion_.

                                                  {
    // cipher is a static const char* provided and managed by openssl lib
    sslVersion_ = ver; sslCipher_ = cipher;
  }

void proxygen::HTTPMessage::setSeqNo ( int32_t  seqNo )

inline

get and setter for transaction sequence number

Definition at line 606 of file HTTPMessage.h.

References seqNo_.

{ seqNo_ = seqNo; }

void proxygen::HTTPMessage::setStartTime ( const TimePoint &  startTime )

inline

Definition at line 623 of file HTTPMessage.h.

References checkForHeaderToken(), computeKeepalive(), getDefaultReason(), startTime_, uint16_t, and unparseCookies().

{ startTime_ = startTime; }

void proxygen::HTTPMessage::setStatusCode

(

uint16_t

status

)

Access the status code (fpres)

Definition at line 335 of file HTTPMessage.cpp.

References response(), proxygen::HTTPMessage::Response::status_, and proxygen::HTTPMessage::Response::statusStr_.

Referenced by constructDirectResponse(), TestPriorityMapBuilder::createVirtualStreams(), proxygen::getResponse(), hasTrailers(), proxygen::HTTPDirectResponseHandler::onHeadersComplete(), proxygen::HTTPDownstreamSession::onNativeProtocolUpgrade(), proxygen::HTTPHandlerBase::sendChunkedReplyWithBody(), proxygen::HTTPHandlerBase::sendHeaders(), TEST(), and TEST_F().

                                               {
  response().status_ = status;
  response().statusStr_ = folly::to<string>(status);
}

template<typename T >

void proxygen::HTTPMessage::setStatusMessage ( T &&  msg )

inline

Access the HTTP status message string (res)

Definition at line 242 of file HTTPMessage.h.

References response(), and proxygen::HTTPMessage::Response::statusMsg_.

Referenced by constructDirectResponse(), TestPriorityMapBuilder::createVirtualStreams(), proxygen::HTTPDirectResponseHandler::onHeadersComplete(), proxygen::HTTPDownstreamSession::onNativeProtocolUpgrade(), rawSetStatusMessage(), TEST(), and TEST_F().

                                 {
    response().statusMsg_ = std::forward<T>(msg);
  }

void proxygen::HTTPMessage::setTrailers ( std::unique_ptr< HTTPHeaders > &&  trailers )

inline

Set the trailers, replacing any that might already be present

Definition at line 292 of file HTTPMessage.h.

References isHTTP1_0(), isHTTP1_1(), folly::gen::move, processMaxForwards(), and trailers_.

                                                          {
    trailers_ = std::move(trailers);
  }

void proxygen::HTTPMessage::setTrailersAllowed ( bool  trailersAllowedVal )

inline

Accessor to set whether trailers are allowed in the response

Definition at line 358 of file HTTPMessage.h.

References trailersAllowed_.

                                                   {
    trailersAllowed_ = trailersAllowedVal;
  }

void proxygen::HTTPMessage::setUpgradeProtocol ( std::string  protocol )

inline

Definition at line 375 of file HTTPMessage.h.

References folly::gen::move, and upgradeProtocol_.

Referenced by proxygen::HTTPRequestVerifier::setUpgradeProtocol().

                                              {
    upgradeProtocol_ = std::make_unique<std::string>(std::move(protocol));
  }

template<typename T >

ParseURL proxygen::HTTPMessage::setURL ( T &&  url )

inline

Access the URL component (fpreq)

The <url> component from the initial "METHOD <url> HTTP/..." line. When valid, this is a full URL, not just a path.

Definition at line 183 of file HTTPMessage.h.

References proxygen::ParseURL::path(), proxygen::HTTPMessage::Request::path_, proxygen::ParseURL::query(), proxygen::HTTPMessage::Request::query_, request(), folly::Range< Iter >::str(), unparseQueryParams(), proxygen::HTTPMessage::Request::url_, and proxygen::ParseURL::valid().

Referenced by doEmptyHeaderValueTest(), ZlibServerFilterTest::exercise_compression(), proxygen::getBigGetRequest(), proxygen::getChunkedPostRequest(), proxygen::getGetRequest(), proxygen::getPostRequest(), proxygen::getPubRequest(), getSynStream(), proxygen::compress::SimStreamingCallback::onHeader(), rawSetURL(), proxygen::MockHTTPPushHandler::sendPushHeaders(), CurlService::CurlClient::sendRequest(), proxygen::HTTPRequestVerifier::setPath(), setURL(), TEST(), TEST_F(), TEST_P(), testPathAndQuery(), testRemoveQueryParam(), and testSetQueryParam().

                           {
    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;
  }

void proxygen::HTTPMessage::setURL ( const char *  url )

inline

Definition at line 202 of file HTTPMessage.h.

References setURL(), and string.

                               {
    setURL(std::string(url));
  }

void proxygen::HTTPMessage::setVersionString ( const std::string &  ver )

inline

Definition at line 259 of file HTTPMessage.h.

References setHTTPVersion().

                                              {
    if (ver.size() != 3 ||
        ver[1] != '.' ||
        !isdigit(ver[0]) ||
        !isdigit(ver[2])) {
      return;
    }

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

void proxygen::HTTPMessage::setWantsKeepalive ( bool  wantsKeepaliveVal )

inline

Indicates if this request wants the connection to be kept-alive (default true). Not all codecs respect this option.

Definition at line 343 of file HTTPMessage.h.

References wantsKeepalive_.

Referenced by proxygen::HTTPHandlerBase::sendHeaders(), TEST(), and TEST_F().

                                                 {
    wantsKeepalive_ = wantsKeepaliveVal;
  }

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

static

Definition at line 628 of file HTTPMessage.cpp.

References folly::Range< Iter >::advance(), folly::Range< Iter >::empty(), folly::Range< Iter >::find(), folly::gen::move, name, folly::Range< Iter >::size(), folly::Range< Iter >::str(), folly::Range< Iter >::subpiece(), and value.

Referenced by isResponse(), and parseQueryParams().

                                                        {

  folly::StringPiece sp(input);
  while (!sp.empty()) {
    size_t pairDelimPos = sp.find(pairDelim);
    folly::StringPiece keyValue;

    if (pairDelimPos == string::npos) {
      keyValue = sp;
      sp.advance(sp.size());
    } else {
      keyValue = sp.subpiece(0, pairDelimPos);
      // Skip '&' char
      sp.advance(pairDelimPos + 1);
    }

    if (keyValue.empty()) {
      continue;
    }

    size_t valueDelimPos = keyValue.find(valueDelim);
    if (valueDelimPos == string::npos) {
      // Key only query param
      string name = keyValue.str();
      string value;

      boost::trim(name, defaultLocale);
      callback(std::move(name), std::move(value));
    } else {
      string name = keyValue.subpiece(0, valueDelimPos).str();
      string value = keyValue.subpiece(valueDelimPos + 1).str();

      boost::trim(name, defaultLocale);
      boost::trim(value, defaultLocale);
      callback(std::move(name), std::move(value));
    }
  }
}

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

static

Assuming input contains <name><valueDelim>

(<pairDelim><name><valueDelim>

), invoke callback once with each name,value pair.

Definition at line 583 of file HTTPMessage.cpp.

References folly::Range< Iter >::advance(), name, trim(), and value.

Referenced by isResponse(), and parseCookies().

                                                              {

  StringPiece sp(input);
  while (!sp.empty()) {
    size_t pairDelimPos = sp.find(pairDelim);
    StringPiece keyValue;

    if (pairDelimPos == string::npos) {
      keyValue = sp;
      sp.advance(sp.size());
    } else {
      keyValue = sp.subpiece(0, pairDelimPos);
      // Skip '&' char
      sp.advance(pairDelimPos + 1);
    }

    if (keyValue.empty()) {
      continue;
    }

    size_t valueDelimPos = keyValue.find(valueDelim);
    if (valueDelimPos == string::npos) {
      // Key only query param
      callback(trim(keyValue), StringPiece());
    } else {
      auto name = keyValue.subpiece(0, valueDelimPos);
      auto value = keyValue.subpiece(valueDelimPos + 1);
      callback(trim(name), trim(value));
    }
  }
}

void proxygen::HTTPMessage::stripPerHopHeaders

(

)

Interact with headers that are defined to be per-hop.

It is expected that during request processing, stripPerHopHeaders() will be called before the message is proxied to the other connection.

Definition at line 48 of file HTTPMessage.cpp.

References checkForHeaderToken(), headers_, proxygen::HTTP_HEADER_TE, proxygen::HTTPHeaders::removeAll(), strippedPerHopHeaders_, proxygen::HTTPHeaders::stripPerHopHeaders(), and trailersAllowed_.

Referenced by getUpgradeProtocol(), and TEST().

                                     {
  // Some code paths end up recyling a single HTTPMessage instance for multiple
  // requests, and adding their own per-hop headers each time. In that case, we
  // don't want to accumulate these headers.
  strippedPerHopHeaders_.removeAll();

  if (!trailersAllowed_) {
    // Because stripPerHopHeaders can be called multiple times, don't
    // let subsequent instances clear this flag
    trailersAllowed_ = checkForHeaderToken(HTTP_HEADER_TE, "trailers", false);
  }

  headers_.stripPerHopHeaders(strippedPerHopHeaders_);
}

bool proxygen::HTTPMessage::trailersAllowed ( ) const

inline

Returns true if trailers are allowed on this message. Trailers are not allowed on responses unless the client is expecting them.

Definition at line 354 of file HTTPMessage.h.

References trailersAllowed_.

{ return trailersAllowed_; }

StringPiece proxygen::HTTPMessage::trim ( folly::StringPiece  sp )

staticprivate

Trims whitespace from the beggining and end of the StringPiece.

Definition at line 619 of file HTTPMessage.cpp.

Referenced by splitNameValuePieces().

                                            {
  // TODO: use a library function from boost?
  for (; !sp.empty() && sp.front() == ' '; sp.pop_front()) {
  }
  for (; !sp.empty() && sp.back() == ' '; sp.pop_back()) {
  }
  return sp;
}

void proxygen::HTTPMessage::unparseCookies

(

)

const

Forget about the parsed cookies.

Ideally HTTPMessage should automatically forget about the current parsed cookie state whenever a Cookie header is changed. However, at the moment callers have to explicitly call unparseCookies() after modifying the cookie headers.

Definition at line 396 of file HTTPMessage.cpp.

References cookies_, and parsedCookies_.

Referenced by getCookie(), and setStartTime().

                                       {
  cookies_.clear();
  parsedCookies_ = false;
}

void proxygen::HTTPMessage::unparseQueryParams ( )

private

Definition at line 442 of file HTTPMessage.cpp.

References parsedQueryParams_, and queryParams_.

Referenced by setURL().

                                     {
  queryParams_.clear();
  parsedQueryParams_ = false;
}

bool proxygen::HTTPMessage::wantsKeepalive ( ) const

inline

Definition at line 346 of file HTTPMessage.h.

References wantsKeepalive_.

Referenced by proxygen::HTTP1xCodec::generateHeader(), and TEST().

                              {
    return wantsKeepalive_;
  }

Member Data Documentation

bool proxygen::HTTPMessage::chunked_

private

Definition at line 820 of file HTTPMessage.h.

Referenced by describe(), getIsChunked(), operator=(), and setIsChunked().

std::map<folly::StringPiece, folly::StringPiece> proxygen::HTTPMessage::cookies_

mutableprivate

Definition at line 802 of file HTTPMessage.h.

Referenced by getCookie(), operator=(), parseCookies(), and unparseCookies().

folly::SocketAddress proxygen::HTTPMessage::dstAddress_

private

Definition at line 752 of file HTTPMessage.h.

Referenced by getDstAddress(), operator=(), and setDstAddress().

std::string proxygen::HTTPMessage::dstIP_

private

Definition at line 753 of file HTTPMessage.h.

Referenced by describe(), getDstIP(), operator=(), and setDstAddress().

std::string proxygen::HTTPMessage::dstPort_

private

Definition at line 754 of file HTTPMessage.h.

Referenced by describe(), getDstPort(), operator=(), and setDstAddress().

boost::variant<boost::blank, Request, Response> proxygen::HTTPMessage::fields_

mutableprivate

Definition at line 759 of file HTTPMessage.h.

Referenced by describe(), isRequest(), isResponse(), operator=(), request(), and response().

folly::Optional<HTTPPriority> proxygen::HTTPMessage::h2Pri_

private

Definition at line 816 of file HTTPMessage.h.

Referenced by getHTTP2Priority(), operator=(), setHTTP2Priority(), and setPriority().

HTTPHeaders proxygen::HTTPMessage::headers_

private

Definition at line 807 of file HTTPMessage.h.

Referenced by checkForHeaderToken(), constructDirectResponse(), describe(), ensureHostHeader(), extractHeaders(), getHeaders(), operator=(), parseCookies(), processMaxForwards(), and stripPerHopHeaders().

const pair< uint8_t, uint8_t > proxygen::HTTPMessage::kHTTPVersion10

static

Version constants

Definition at line 229 of file HTTPMessage.h.

Referenced by computeKeepalive(), proxygen::HTTP1xCodec::generateHeader(), and isHTTP1_0().

const pair< uint8_t, uint8_t > proxygen::HTTPMessage::kHTTPVersion11

static

Definition at line 230 of file HTTPMessage.h.

Referenced by proxygen::HTTP1xCodec::generateHeader(), and isHTTP1_1().

const int8_t proxygen::HTTPMessage::kMaxPriority = 7

static

Definition at line 574 of file HTTPMessage.h.

Referenced by normalizePriority().

std::string proxygen::HTTPMessage::localIP_

private

Definition at line 756 of file HTTPMessage.h.

Referenced by describe(), getLocalIp(), operator=(), and setLocalIp().

std::mutex proxygen::HTTPMessage::mutexDump_

staticprivate

Definition at line 829 of file HTTPMessage.h.

Referenced by atomicDumpMessage().

bool proxygen::HTTPMessage::parsedCookies_

mutableprivate

Definition at line 818 of file HTTPMessage.h.

Referenced by getCookie(), operator=(), parseCookies(), and unparseCookies().

bool proxygen::HTTPMessage::parsedQueryParams_

mutableprivate

Definition at line 819 of file HTTPMessage.h.

Referenced by getQueryParamPtr(), getQueryParams(), operator=(), parseQueryParams(), removeQueryParam(), setQueryParam(), and unparseQueryParams().

uint8_t proxygen::HTTPMessage::pri_

private

Definition at line 815 of file HTTPMessage.h.

Referenced by getPriority(), operator=(), and setPriority().

const std::string* proxygen::HTTPMessage::protoStr_

private

Definition at line 814 of file HTTPMessage.h.

Referenced by getAdvancedProtocolString(), getProtocolString(), isAdvancedProto(), operator=(), and setAdvancedProtocolString().

std::map<std::string, std::string> proxygen::HTTPMessage::queryParams_

mutableprivate

Definition at line 804 of file HTTPMessage.h.

Referenced by getQueryParamPtr(), getQueryParams(), operator=(), removeQueryParam(), setQueryParam(), and unparseQueryParams().

bool proxygen::HTTPMessage::secure_

private

Definition at line 826 of file HTTPMessage.h.

Referenced by isSecure(), operator=(), and setSecure().

int32_t proxygen::HTTPMessage::seqNo_

protected

Definition at line 709 of file HTTPMessage.h.

Referenced by getSeqNo(), operator=(), and setSeqNo().

HTTPHeaderSize proxygen::HTTPMessage::size_

private

Definition at line 809 of file HTTPMessage.h.

Referenced by getIngressHeaderSize(), and setIngressHeaderSize().

const char* proxygen::HTTPMessage::sslCipher_

private

Definition at line 813 of file HTTPMessage.h.

Referenced by getSecureCipher(), operator=(), and setSecureInfo().

int proxygen::HTTPMessage::sslVersion_

private

Definition at line 812 of file HTTPMessage.h.

Referenced by getSecureVersion(), operator=(), and setSecureInfo().

TimePoint proxygen::HTTPMessage::startTime_

protected

Definition at line 708 of file HTTPMessage.h.

Referenced by getStartTime(), operator=(), and setStartTime().

HTTPHeaders proxygen::HTTPMessage::strippedPerHopHeaders_

private

Definition at line 808 of file HTTPMessage.h.

Referenced by computeKeepalive(), describe(), getStrippedPerHopHeaders(), operator=(), and stripPerHopHeaders().

std::unique_ptr<HTTPHeaders> proxygen::HTTPMessage::trailers_

private

Definition at line 810 of file HTTPMessage.h.

Referenced by getTrailers(), hasTrailers(), HTTPMessage(), operator=(), and setTrailers().

bool proxygen::HTTPMessage::trailersAllowed_

private

Definition at line 823 of file HTTPMessage.h.

Referenced by hasTrailers(), operator=(), setTrailersAllowed(), stripPerHopHeaders(), and trailersAllowed().

bool proxygen::HTTPMessage::upgraded_

private

Definition at line 821 of file HTTPMessage.h.

Referenced by describe(), getIsUpgraded(), operator=(), and setIsUpgraded().

std::unique_ptr<std::string> proxygen::HTTPMessage::upgradeProtocol_

private

Definition at line 832 of file HTTPMessage.h.

Referenced by getUpgradeProtocol(), and setUpgradeProtocol().

WebSocketUpgrade proxygen::HTTPMessage::upgradeWebsocket_

private

Definition at line 831 of file HTTPMessage.h.

Referenced by isEgressWebsocketUpgrade(), isIngressWebsocketUpgrade(), operator=(), setEgressWebsocketUpgrade(), and setIngressWebsocketUpgrade().

std::pair<uint8_t, uint8_t> proxygen::HTTPMessage::version_

private

Definition at line 806 of file HTTPMessage.h.

Referenced by computeKeepalive(), getHTTPVersion(), isHTTP1_0(), isHTTP1_1(), operator=(), and setHTTPVersion().

std::string proxygen::HTTPMessage::versionStr_

private

Definition at line 757 of file HTTPMessage.h.

Referenced by describe(), getProtocolString(), getVersionString(), operator=(), and setHTTPVersion().

bool proxygen::HTTPMessage::wantsKeepalive_

private

Definition at line 822 of file HTTPMessage.h.

Referenced by operator=(), setWantsKeepalive(), and wantsKeepalive().

---

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

• proxygen/lib/http/HTTPMessage.h
• proxygen/lib/http/HTTPMessage.cpp