proxygen: proxygen::RFC1867Codec Class Reference

#include <RFC1867.h>

Inheritance diagram for proxygen::RFC1867Codec:

Classes
class	Callback

Public Member Functions
	RFC1867Codec (const std::string &boundary)

void	setCallback (Callback *callback)

std::unique_ptr< folly::IOBuf >	onIngress (std::unique_ptr< folly::IOBuf > data)

void	onIngressEOM ()

uint64_t	getBytesProcessed () const

Private Types
enum	ParserState { ParserState::START, ParserState::HEADERS_START, ParserState::HEADERS, ParserState::FIELD_DATA, ParserState::DONE, ParserState::ERROR }

Private Member Functions
void	onMessageBegin (HTTPCodec::StreamID, HTTPMessage *) override

void	onHeadersComplete (HTTPCodec::StreamID stream, std::unique_ptr< HTTPMessage > msg) override

void	onBody (HTTPCodec::StreamID, std::unique_ptr< folly::IOBuf >, uint16_t) override

void	onTrailersComplete (HTTPCodec::StreamID, std::unique_ptr< HTTPHeaders >) override

void	onMessageComplete (HTTPCodec::StreamID, bool) override

void	onError (HTTPCodec::StreamID, const HTTPException &, bool) override

folly::IOBufQueue	readToBoundary (bool &foundBoundary)

Private Member Functions inherited from proxygen::HTTPCodec::Callback
virtual void	onPushMessageBegin (StreamID, StreamID, HTTPMessage *)

virtual void	onExMessageBegin (StreamID, StreamID, bool, HTTPMessage *)

virtual void	onChunkHeader (StreamID, size_t)

virtual void	onChunkComplete (StreamID)

virtual void	onAbort (StreamID, ErrorCode)

virtual void	onFrameHeader (StreamID, uint8_t, uint64_t, uint8_t, uint16_t=0)

virtual void	onGoaway (uint64_t, ErrorCode, std::unique_ptr< folly::IOBuf >=nullptr)

virtual void	onPingRequest (uint64_t)

virtual void	onPingReply (uint64_t)

virtual void	onWindowUpdate (StreamID, uint32_t)

virtual void	onSettings (const SettingsList &)

virtual void	onSettingsAck ()

virtual void	onPriority (StreamID, const HTTPMessage::HTTPPriority &)

virtual bool	onNativeProtocolUpgrade (StreamID, CodecProtocol, const std::string &, HTTPMessage &)

virtual void	onGenerateFrameHeader (StreamID, uint8_t, uint64_t, uint16_t=0)

virtual void	onCertificateRequest (uint16_t, std::unique_ptr< folly::IOBuf >)

virtual void	onCertificate (uint16_t, std::unique_ptr< folly::IOBuf >)

virtual uint32_t	numOutgoingStreams () const

virtual uint32_t	numIncomingStreams () const

virtual	~Callback ()

Private Attributes
std::string	boundary_

Callback *	callback_ {nullptr}

ParserState	state_ {ParserState::START}

HTTP1xCodec	headerParser_ {TransportDirection::DOWNSTREAM}

std::string	field_

folly::IOBufQueue	input_ {folly::IOBufQueue::cacheChainLength()}

folly::IOBufQueue	value_

std::unique_ptr< folly::IOBuf >	pendingCR_

uint64_t	bytesProcessed_ {0}

bool	parseError_ {false}

Detailed Description

Class for stream-parsing RFC 1867 style post data. At present it does not support nested multi-part content (multipart/mixed). Can parse multiple POST bodies unless one of them invokes the onError() callback. After that, the codec is no longer usable.

Definition at line 24 of file RFC1867.h.

Member Enumeration Documentation

enum proxygen::RFC1867Codec::ParserState

strongprivate

Enumerator
START
HEADERS_START
HEADERS
FIELD_DATA
DONE
ERROR

Definition at line 71 of file RFC1867.h.

                          {
     START,
     HEADERS_START,
     HEADERS,
     FIELD_DATA,  // part, or field, not only file
     DONE,
     ERROR
   };

Constructor & Destructor Documentation

proxygen::RFC1867Codec::RFC1867Codec ( const std::string & boundary )

inlineexplicit

Definition at line 48 of file RFC1867.h.

References boundary_, headerParser_, and proxygen::HTTP1xCodec::setCallback().

                                                    {
     CHECK(!boundary.empty());
     boundary_ = folly::to<std::string>("\n--", boundary);
     headerParser_.setCallback(this);
   }

Member Function Documentation

uint64_t proxygen::RFC1867Codec::getBytesProcessed ( ) const

inline

Definition at line 66 of file RFC1867.h.

References bytesProcessed_.

                                      {
     return bytesProcessed_;
   }

void proxygen::RFC1867Codec::onBody	(	HTTPCodec::StreamID	stream,
		std::unique_ptr< folly::IOBuf >	chain,
		uint16_t	padding
	)

inlineoverrideprivatevirtual

Called for each block of message body data

Parameters

stream	The stream ID
chain	One or more buffers of body data. The codec will remove any protocol framing, such as HTTP/1.1 chunk headers, from the buffers before calling this function.
padding	Number of pad bytes that came with the data segment

Implements proxygen::HTTPCodec::Callback.

Definition at line 85 of file RFC1867.h.

References headerParser_, parseError_, and proxygen::HTTP1xCodec::setParserPaused().

                                    {
     parseError_ = true;
     headerParser_.setParserPaused(true);
   }

void proxygen::RFC1867Codec::onError	(	HTTPCodec::StreamID	stream,
		const HTTPException &	error,
		bool	newTxn
	)

inlineoverrideprivatevirtual

Called when a parsing or protocol error has occurred

Parameters

stream	The stream ID
error	Description of the error
newTxn	true if onMessageBegin has not been called for txn

Implements proxygen::HTTPCodec::Callback.

Definition at line 101 of file RFC1867.h.

References headerParser_, parseError_, readToBoundary(), and proxygen::HTTP1xCodec::setParserPaused().

                                 {
     parseError_ = true;
     headerParser_.setParserPaused(true);
   }

void proxygen::RFC1867Codec::onHeadersComplete	(	HTTPCodec::StreamID	stream,
		std::unique_ptr< HTTPMessage >	msg
	)

overrideprivatevirtual

Called when all the headers of an ingress message have been parsed

Parameters

stream	The stream ID
msg	The message
size	Size of the ingress header

Implements proxygen::HTTPCodec::Callback.

Definition at line 178 of file RFC1867.cpp.

References callback_, folly::Range< Iter >::data(), proxygen::ERROR, proxygen::HTTP_HEADER_CONTENT_DISPOSITION, folly::gen::move, name, folly::Range< Iter >::reset(), folly::Range< Iter >::size(), folly::Range< Iter >::str(), and value.

Referenced by onMessageBegin().

                                                                      {
   static const StringPiece kName("name", 4);
   static const StringPiece kFilename("filename", 8);
   static const StringPiece kFormData("form-data", 9);
 
   const auto& contentDisp =
     msg->getHeaders().getSingleOrEmpty(HTTP_HEADER_CONTENT_DISPOSITION);
   string name;
   folly::Optional<string> filename; // filename is optional
   HTTPMessage::splitNameValuePieces(
     contentDisp, ';', '=',
     [&] (folly::StringPiece parameter, folly::StringPiece value) {
       // TODO: Trim whitespace first
       // Strip quotes if present
       if (value.size() >= 2 && value[0] == '\"' &&
           value[value.size() - 1] == '\"') {
         value.reset(value.data() + 1, value.size() - 2);
       }
       if (parameter == kName) {
         name = value.str();
       } else if (parameter == kFilename) {
         filename = value.str();
       } else if (parameter != kFormData) {
         LOG(WARNING) << "Ignoring parameter " << parameter << " value \""
                      << value << '"';
       }
     });
   if (name.empty()) {
     if (callback_) {
       LOG(ERROR) << "name empty";
       callback_->onError();
     }
     state_ = ParserState::ERROR;
     return;
   } else {
     state_ = ParserState::FIELD_DATA;
     if (callback_ && callback_->onFieldStart(name, filename,
                                             std::move(msg),
                                             bytesProcessed_) < 0) {
     field_ = name;
       LOG(WARNING) << "Callback returned error";
       state_ = ParserState::ERROR;
     }
   }
 }

std::unique_ptr< IOBuf > proxygen::RFC1867Codec::onIngress ( std::unique_ptr< folly::IOBuf > data )

Definition at line 61 of file RFC1867.cpp.

References folly::IOBufQueue::append(), c, callback_, ch, proxygen::ERROR, proxygen::spdy::HEADERS, folly::gen::move, and uint8_t.

Referenced by setCallback().

                                                                       {
   static auto dummyBuf = IOBuf::wrapBuffer(kDummyGet.data(),
                                            kDummyGet.length());
   IOBufQueue result{IOBufQueue::cacheChainLength()};
   bool foundBoundary = false;
   BoundaryResult br = BoundaryResult::NO;
 
   input_.append(std::move(data));
   while (!input_.empty()) {
     switch (state_) {
       case ParserState::START:
         // first time, must start with boundary without leading \n
         br = isBoundary(*input_.front(), 0, boundary_.data() + 1,
                         boundary_.length() - 1);
         if (br == BoundaryResult::NO) {
           if (callback_) {
             LOG(ERROR) << "Invalid starting sequence";
             callback_->onError();
           }
           state_ = ParserState::ERROR;
           return nullptr;
         } else if (br == BoundaryResult::PARTIAL) {
           return input_.move();
         }
         input_.trimStart(boundary_.length() - 1);
         bytesProcessed_ += boundary_.length() - 1;
         state_ = ParserState::HEADERS_START;
         // fall through
 
       case ParserState::HEADERS_START:
         {
           if (input_.chainLength() < 3) {
             return input_.move();
           }
           Cursor c(input_.front());
           char firstTwo[2];
           c.pull(firstTwo, 2);
           // We have at least 3 chars available to read
           uint8_t toTrim = 3;
           if (memcmp(firstTwo, "--", 2) == 0) {
             do {
               auto ch = c.read<char>();
               if (ch == '\n') {
                 input_.trimStart(toTrim);
                 state_ = ParserState::DONE;
               } else if (ch == '\r') {
                 // Every \r we encounter is a char we must trim but we must
                 // make sure we have sufficient data available in input_ to
                 // keep reading (toTrim is always one pos ahead to handle the
                 // expected \n)
                 ++toTrim;
                 if (input_.chainLength() < toTrim) {
                   return input_.move();
                 }
               } else {
                 state_ = ParserState::ERROR;
               }
             } while (state_ == ParserState::HEADERS_START);
             break;
           }
         }
         headerParser_.setParserPaused(false);
         headerParser_.onIngress(*dummyBuf);
         CHECK(!parseError_);
         state_ = ParserState::HEADERS;
         // fall through
 
       case ParserState::HEADERS:
         while (!parseError_ && input_.front() &&
                state_ == ParserState::HEADERS) {
           size_t bytesParsed = headerParser_.onIngress(*input_.front());
           input_.trimStart(bytesParsed);
           bytesProcessed_ += bytesParsed;
         }
         if (parseError_) {
           if (callback_) {
             LOG(ERROR) << "Error parsing header data: ";
             VLOG(3) << IOBufPrinter::printHexFolly(input_.front());
             callback_->onError();
           }
           state_ = ParserState::ERROR;
           return nullptr;
         }
         break;
 
       case ParserState::FIELD_DATA:
         result = readToBoundary(foundBoundary);
         value_.append(result.move());
         if (!value_.empty() && callback_) {
           if (callback_->onFieldData(value_.move(), bytesProcessed_) < 0) {
             LOG(ERROR) << "Callback returned error";
             state_ = ParserState::ERROR;
             return nullptr;
           }
         }
         if (foundBoundary) {
           if (callback_) {
             callback_->onFieldEnd(true, bytesProcessed_);
           }
           state_ = ParserState::HEADERS_START;
         } else {
           if (input_.chainLength() > 0) {
             VLOG(5) << "Trailing input="
                     << IOBufPrinter::printHexFolly(input_.front());
           }
           return input_.move();
         }
         break;
       case ParserState::DONE:
       case ParserState::ERROR:
         // abort, consume all input
         return nullptr;
     }
   }
   return nullptr;
 }

void proxygen::RFC1867Codec::onIngressEOM ( )

Definition at line 299 of file RFC1867.cpp.

References callback_, proxygen::ERROR, and uint8_t.

Referenced by setCallback().

                                 {
   if (state_ == ParserState::FIELD_DATA) {
     LOG(WARNING) << "Field not terminated by boundary";
     if (callback_) {
       callback_->onFieldEnd(false, bytesProcessed_);
     }
   }
   if (state_ != ParserState::HEADERS_START && state_ != ParserState::ERROR &&
       state_ != ParserState::DONE) {
     if (callback_) {
       LOG(ERROR) << "onIngressEOM with state_=" << (uint8_t)state_;
       callback_->onError();
     }
   }
   state_ = ParserState::START;
 }

void proxygen::RFC1867Codec::onMessageBegin	(	HTTPCodec::StreamID	stream,
		HTTPMessage *	msg
	)

inlineoverrideprivatevirtual

Called when a new message is seen while parsing the ingress

Parameters

stream	The stream ID
msg	A newly allocated HTTPMessage

Implements proxygen::HTTPCodec::Callback.

Definition at line 81 of file RFC1867.h.

References onHeadersComplete().

82 {}

void proxygen::RFC1867Codec::onMessageComplete	(	HTTPCodec::StreamID	stream,
		bool	upgrade
	)

inlineoverrideprivatevirtual

Called at end of a message (including body and trailers, if applicable)

Parameters

stream	The stream ID
upgrade	Whether the connection has been upgraded to another protocol.

Implements proxygen::HTTPCodec::Callback.

Definition at line 96 of file RFC1867.h.

References headerParser_, and proxygen::HTTP1xCodec::setParserPaused().

                                           {
     headerParser_.setParserPaused(true);
   }

void proxygen::RFC1867Codec::onTrailersComplete	(	HTTPCodec::StreamID	stream,
		std::unique_ptr< HTTPHeaders >	trailers
	)

inlineoverrideprivatevirtual

Called when all the trailers of an ingress message have been parsed, but only if the number of trailers is nonzero.

Parameters

stream	The stream ID
trailers	The message trailers

Implements proxygen::HTTPCodec::Callback.

Definition at line 91 of file RFC1867.h.

References headerParser_, parseError_, and proxygen::HTTP1xCodec::setParserPaused().

                                                                  {
     parseError_ = true;
     headerParser_.setParserPaused(true);
   }

IOBufQueue proxygen::RFC1867Codec::readToBoundary ( bool & foundBoundary )

private

Definition at line 225 of file RFC1867.cpp.

References c, ch, folly::IOBuf::data(), folly::IOBuf::length(), folly::gen::move, ptr, folly::io::detail::CursorBase< Derived, BufType >::read(), folly::io::detail::CursorBase< Derived, BufType >::skip(), uint32_t, uint64_t, and uint8_t.

Referenced by onError().

                                                            {
   IOBufQueue result{IOBufQueue::cacheChainLength()};
   BoundaryResult boundaryResult = BoundaryResult::NO;
 
   while (!input_.empty() && boundaryResult != BoundaryResult::PARTIAL) {
     const IOBuf* head = input_.front();
     uint64_t len = head->length();
     const uint8_t *ptr = head->data();
 
     /* iterate through first character matches */
     while (len > 0 && (ptr = (const uint8_t*)memchr(ptr, boundary_[0], len))) {
       /* calculate length after match */
       uint64_t readlen = (ptr - head->data());
       len = head->length() - readlen;
       boundaryResult =
         isBoundary(*head, readlen, boundary_.data(), boundary_.length());
       if (boundaryResult == BoundaryResult::YES) {
         CHECK(readlen < head->length());
         bool hasCr = false;
         if (readlen == 0 && pendingCR_) {
           pendingCR_.reset();
         }
         if (readlen > 0) {
           // If the last read char is a CR omit from result
           Cursor c(head);
           c.skip(readlen - 1);
           uint8_t ch = c.read<uint8_t>();
           if (ch == '\r') {
             --readlen;
             hasCr = true;
           }
         }
         result.append(std::move(pendingCR_));
         result.append(input_.split(readlen));
         uint32_t trimLen = boundary_.length() + (hasCr ? 1 : 0);
         input_.trimStart(trimLen);
         bytesProcessed_ += readlen + trimLen;
         foundBoundary = true;
         return result;
       } else if (boundaryResult == BoundaryResult::PARTIAL) {
         break;
       } else if (pendingCR_) {
         // not a match, append pending CR to result
         result.append(std::move(pendingCR_));
       }
 
       /* next character */
       ptr++; len--;
     }
     uint64_t resultLen = ptr ? ptr - head->data() : head->length();
     // Put pendingCR_ in result if there was no partial match in head, or a
     // partial match starting after the first character
     if ((boundaryResult == BoundaryResult::NO || resultLen > 0) &&
         pendingCR_) {
       result.append(std::move(pendingCR_));
     }
     // the boundary does not start through resultLen, append it
     // to result, except maybe the last char if it's a CR.
     if (resultLen > 0 && head->data()[resultLen - 1] == '\r') {
       result.append(input_.split(resultLen - 1));
       CHECK(!pendingCR_);
       pendingCR_ = input_.split(1);
     } else {
       result.append(input_.split(resultLen));
     }
     bytesProcessed_ += resultLen;
   }
 
   // reached the end but no boundary found
   foundBoundary = false;
 
   return result;
 }

void proxygen::RFC1867Codec::setCallback ( Callback * callback )

inline

Definition at line 54 of file RFC1867.h.

References callback_, data, onIngress(), and onIngressEOM().

                                        {
     callback_ = callback;
   }

Member Data Documentation

std::string proxygen::RFC1867Codec::boundary_

private

Definition at line 110 of file RFC1867.h.

Referenced by RFC1867Codec().

uint64_t proxygen::RFC1867Codec::bytesProcessed_ {0}

private

Definition at line 118 of file RFC1867.h.

Referenced by getBytesProcessed().

Callback* proxygen::RFC1867Codec::callback_ {nullptr}

private

Definition at line 111 of file RFC1867.h.

Referenced by setCallback().

std::string proxygen::RFC1867Codec::field_

private

Definition at line 114 of file RFC1867.h.

HTTP1xCodec proxygen::RFC1867Codec::headerParser_ {TransportDirection::DOWNSTREAM}

private

Definition at line 113 of file RFC1867.h.

Referenced by onBody(), onError(), onMessageComplete(), onTrailersComplete(), and RFC1867Codec().

folly::IOBufQueue proxygen::RFC1867Codec::input_ {folly::IOBufQueue::cacheChainLength()}

private

Definition at line 115 of file RFC1867.h.

bool proxygen::RFC1867Codec::parseError_ {false}

private

Definition at line 119 of file RFC1867.h.

Referenced by onBody(), onError(), and onTrailersComplete().

std::unique_ptr<folly::IOBuf> proxygen::RFC1867Codec::pendingCR_

private

Definition at line 117 of file RFC1867.h.

ParserState proxygen::RFC1867Codec::state_ {ParserState::START}

private

Definition at line 112 of file RFC1867.h.

folly::IOBufQueue proxygen::RFC1867Codec::value_

private

Definition at line 116 of file RFC1867.h.

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

proxygen/lib/http/experimental/RFC1867.h
proxygen/lib/http/experimental/RFC1867.cpp

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation