proxygen: proxygen::HeaderDecodeInfo Class Reference

#include <HeaderDecodeInfo.h>

Public Member Functions
void	init (bool isRequestIn, bool isRequestTrailers)

bool	onHeader (const folly::fbstring &name, const folly::fbstring &value)

void	onHeadersComplete (HTTPHeaderSize decodedSize)

bool	hasStatus () const

Public Attributes
std::unique_ptr< HTTPMessage >	msg

HTTPRequestVerifier	verifier

std::string	parsingError

HPACK::DecodeError	decodeError {HPACK::DecodeError::NONE}

Private Attributes
bool	isRequest_ {false}

bool	isRequestTrailers_ {false}

bool	hasStatus_ {false}

bool	regularHeaderSeen_ {false}

bool	pseudoHeaderSeen_ {false}

folly::Optional< uint32_t >	contentLength_

Detailed Description

Definition at line 19 of file HeaderDecodeInfo.h.

Member Function Documentation

bool proxygen::HeaderDecodeInfo::hasStatus ( ) const

Definition at line 135 of file HeaderDecodeInfo.cpp.

References hasStatus_.

Referenced by init(), and proxygen::HTTP2Codec::parsingTrailers().

                                        {
   return hasStatus_;
 }

void proxygen::HeaderDecodeInfo::init	(	bool	isRequestIn,
		bool	isRequestTrailers
	)

inline

Definition at line 21 of file HeaderDecodeInfo.h.

References contentLength_, decodeError, hasStatus(), hasStatus_, isRequest_, isRequestTrailers_, msg, name, proxygen::HPACK::NONE, folly::none, onHeader(), onHeadersComplete(), parsingError, pseudoHeaderSeen_, regularHeaderSeen_, proxygen::HTTPRequestVerifier::reset(), value, and verifier.

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

                                                       {
     CHECK(!msg);
     msg.reset(new HTTPMessage());
     isRequest_ = isRequestIn;
     isRequestTrailers_ = isRequestTrailers;
     hasStatus_ = false;
     contentLength_ = folly::none;
     regularHeaderSeen_ = false;
     pseudoHeaderSeen_ = false;
     parsingError = "";
     decodeError = HPACK::DecodeError::NONE;
     verifier.reset(msg.get());
   }

bool proxygen::HeaderDecodeInfo::onHeader	(	const folly::fbstring &	name,
		const folly::fbstring &	value
	)

Definition at line 16 of file HeaderDecodeInfo.cpp.

References contentLength_, decodeError, proxygen::HTTPMessage::getDefaultReason(), hasStatus_, int32_t, isRequest_, proxygen::headers::kAuthority, proxygen::headers::kMethod, proxygen::headers::kPath, proxygen::headers::kProtocol, proxygen::headers::kScheme, proxygen::headers::kStatus, msg, proxygen::HPACK::NONE, parsingError, pseudoHeaderSeen_, regularHeaderSeen_, proxygen::HTTPRequestVerifier::setAuthority(), proxygen::HTTPRequestVerifier::setMethod(), proxygen::HTTPRequestVerifier::setPath(), proxygen::HTTPRequestVerifier::setScheme(), proxygen::HTTPRequestVerifier::setUpgradeProtocol(), folly::Range< Iter >::startsWith(), proxygen::CodecUtil::STRICT, string, uint32_t, proxygen::CodecUtil::validateHeaderName(), proxygen::CodecUtil::validateHeaderValue(), value, and verifier.

Referenced by init(), and proxygen::HTTP2Codec::onHeader().

                                                             {
   // Refuse decoding other headers if an error is already found
   if (decodeError != HPACK::DecodeError::NONE
       || parsingError != "") {
     VLOG(4) << "Ignoring header=" << name << " value=" << value <<
       " due to parser error=" << parsingError;
     return true;
   }
   VLOG(5) << "Processing header=" << name << " value=" << value;
   folly::StringPiece nameSp(name);
   folly::StringPiece valueSp(value);
 
   if (nameSp.startsWith(':')) {
     pseudoHeaderSeen_ = true;
     if (regularHeaderSeen_) {
       parsingError = folly::to<string>("Illegal pseudo header name=", nameSp);
       return false;
     }
     if (isRequest_) {
       if (nameSp == headers::kMethod) {
         if (!verifier.setMethod(valueSp)) {
           return false;
         }
       } else if (nameSp == headers::kScheme) {
         if (!verifier.setScheme(valueSp)) {
           return false;
         }
       } else if (nameSp == headers::kAuthority) {
         if (!verifier.setAuthority(valueSp)) {
           return false;
         }
       } else if (nameSp == headers::kPath) {
         if (!verifier.setPath(valueSp)) {
           return false;
         }
       } else if (nameSp == headers::kProtocol) {
         if (!verifier.setUpgradeProtocol(valueSp)) {
           return false;
         }
       } else {
         parsingError = folly::to<string>("Invalid req header name=", nameSp);
         return false;
       }
     } else {
       if (nameSp == headers::kStatus) {
         if (hasStatus_) {
           parsingError = string("Duplicate status");
           return false;
         }
         hasStatus_ = true;
         int32_t code = -1;
         folly::tryTo<int32_t>(valueSp).then(
             [&code](int32_t num) { code = num; });
         if (code >= 100 && code <= 999) {
           msg->setStatusCode(code);
           msg->setStatusMessage(HTTPMessage::getDefaultReason(code));
         } else {
           parsingError = folly::to<string>("Malformed status code=", valueSp);
           return false;
         }
       } else {
         parsingError = folly::to<string>("Invalid resp header name=", nameSp);
         return false;
       }
     }
   } else {
     regularHeaderSeen_ = true;
     if (nameSp == "connection") {
       parsingError = string("HTTP/2 Message with Connection header");
       return false;
     }
     if (nameSp == "content-length") {
       uint32_t cl = 0;
       folly::tryTo<uint32_t>(valueSp).then(
           [&cl](uint32_t num) { cl = num; });
       if (contentLength_ && *contentLength_ != cl) {
         parsingError = string("Multiple content-length headers");
         return false;
       }
       contentLength_ = cl;
     }
     bool nameOk = CodecUtil::validateHeaderName(nameSp);
     bool valueOk = CodecUtil::validateHeaderValue(valueSp, CodecUtil::STRICT);
     if (!nameOk || !valueOk) {
       parsingError = folly::to<string>("Bad header value: name=",
                                        nameSp, " value=", valueSp);
       return false;
     }
     // Add the (name, value) pair to headers
     msg->getHeaders().add(nameSp, valueSp);
   }
   return true;
 }

void proxygen::HeaderDecodeInfo::onHeadersComplete ( HTTPHeaderSize decodedSize )

Definition at line 111 of file HeaderDecodeInfo.cpp.

References proxygen::HTTPHeaders::combine(), proxygen::HTTPRequestVerifier::error, hasStatus_, proxygen::HTTP_HEADER_COOKIE, isRequest_, isRequestTrailers_, msg, parsingError, pseudoHeaderSeen_, proxygen::HTTPHeaders::set(), proxygen::HTTPRequestVerifier::validate(), and verifier.

Referenced by init(), and proxygen::HTTP2Codec::onHeadersComplete().

                                                                    {
   HTTPHeaders& headers = msg->getHeaders();
 
   if (isRequest_ && !isRequestTrailers_) {
     auto combinedCookie = headers.combine(HTTP_HEADER_COOKIE, "; ");
     if (!combinedCookie.empty()) {
       headers.set(HTTP_HEADER_COOKIE, combinedCookie);
     }
     if (!verifier.validate()) {
       parsingError = verifier.error;
       return;
     }
   }
 
   bool isResponseTrailers = (!isRequest_ && !hasStatus_);
   if ((isRequestTrailers_ || isResponseTrailers) && pseudoHeaderSeen_) {
     parsingError = "Pseudo headers forbidden in trailers.";
     return;
   }
 
   msg->setHTTPVersion(1, 1);
   msg->setIngressHeaderSize(decodedSize);
 }