websocketpp::http::parser::request Class Reference

Stores, parses, and manipulates HTTP requests. More...

#include <request.hpp>

Inheritance diagram for websocketpp::http::parser::request:

Collaboration diagram for websocketpp::http::parser::request:

Public Types
typedef request	type
typedef lib::shared_ptr< type >	ptr

Public Member Functions
	request ()
size_t	consume (char const *buf, size_t len)
	Process bytes in the input buffer.
bool	ready () const
	Returns whether or not the request is ready for reading.
std::string	raw () const
	Returns the full raw request (including the body)
std::string	raw_head () const
	Returns the raw request headers only (similar to an HTTP HEAD request)
void	set_method (std::string const &method)
	Set the HTTP method. Must be a valid HTTP token.
std::string const &	get_method () const
	Return the request method.
void	set_uri (std::string const &uri)
	Set the HTTP uri. Must be a valid HTTP uri.
std::string const &	get_uri () const
	Return the requested URI.
Public Member Functions inherited from websocketpp::http::parser::parser
	parser ()
std::string const &	get_version () const
	Get the HTTP version string.
void	set_version (std::string const &version)
	Set HTTP parser Version.
std::string const &	get_header (std::string const &key) const
	Get the value of an HTTP header.
bool	get_header_as_plist (std::string const &key, parameter_list &out) const
	Extract an HTTP parameter list from a parser header.
void	append_header (std::string const &key, std::string const &val)
	Append a value to an existing HTTP header.
void	replace_header (std::string const &key, std::string const &val)
	Set a value for an HTTP header, replacing an existing value.
void	remove_header (std::string const &key)
	Remove a header from the parser.
std::string const &	get_body () const
	Get HTTP body.
void	set_body (std::string const &value)
	Set body content.
size_t	get_max_body_size () const
	Get body size limit.
void	set_max_body_size (size_t value)
	Set body size limit.
bool	parse_parameter_list (std::string const &in, parameter_list &out) const
	Extract an HTTP parameter list from a string.

Additional Inherited Members
Protected Member Functions inherited from websocketpp::http::parser::parser
void	process_header (std::string::iterator begin, std::string::iterator end)
	Process a header line.
bool	prepare_body ()
	Prepare the parser to begin parsing body data.
size_t	process_body (char const *buf, size_t len)
	Process body data.
bool	body_ready () const
	Check if the parser is done parsing the body.
std::string	raw_headers () const
	Generate and return the HTTP headers as a string.
Protected Attributes inherited from websocketpp::http::parser::parser
std::string	m_version
header_list	m_headers
size_t	m_header_bytes
std::string	m_body
size_t	m_body_bytes_needed
size_t	m_body_bytes_max
body_encoding::value	m_body_encoding

Detailed Description

http::request provides the following functionality for working with HTTP requests.

• Initialize request via manually setting each element
• Initialize request via reading raw bytes and parsing
• Once initialized, access individual parsed elements
• Once initialized, read entire request as raw bytes

Definition at line 50 of file request.hpp.

Member Typedef Documentation

ptr

lib::shared_ptr<type> websocketpp::http::parser::request::ptr

Definition at line 53 of file request.hpp.

type

request websocketpp::http::parser::request::type

Definition at line 52 of file request.hpp.

Constructor & Destructor Documentation

request()

websocketpp::http::parser::request::request ( )

inline

Definition at line 55 of file request.hpp.

      : m_buf(lib::make_shared<std::string>())
      , m_ready(false) {}

Member Function Documentation

consume()

size_t websocketpp::http::parser::request::consume ( char const * buf, size_t len )

inline

Process up to len bytes from input buffer buf. Returns the number of bytes processed. Bytes left unprocessed means bytes left over after the final header delimiters.

Consume is a streaming processor. It may be called multiple times on one request and the full headers need not be available before processing can begin. If the end of the request was reached during this call to consume the ready flag will be set. Further calls to consume once ready will be ignored.

Consume will throw an http::exception in the case of an error. Typical error reasons include malformed requests, incomplete requests, and max header size being reached.

Parameters

buf	Pointer to byte buffer
len	Size of byte buffer

Returns

Number of bytes processed.

Definition at line 41 of file request.hpp.

                                                           {
    size_t bytes_processed;
    
    if (m_ready) {return 0;}
    
    if (m_body_bytes_needed > 0) {
        bytes_processed = process_body(buf,len);
        if (body_ready()) {
            m_ready = true;
        }
        return bytes_processed;
    }
 
    // copy new header bytes into buffer
    m_buf->append(buf,len);
 
    // Search for delimiter in buf. If found read until then. If not read all
    std::string::iterator begin = m_buf->begin();
    std::string::iterator end;
 
    for (;;) {
        // search for line delimiter
        end = std::search(
            begin,
            m_buf->end(),
            header_delimiter,
            header_delimiter+sizeof(header_delimiter)-1
        );
        
        m_header_bytes += (end-begin+sizeof(header_delimiter));
        
        if (m_header_bytes > max_header_size) {
            // exceeded max header size
            throw exception("Maximum header size exceeded.",
                status_code::request_header_fields_too_large);
        }
 
        if (end == m_buf->end()) {
            // we are out of bytes. Discard the processed bytes and copy the
            // remaining unprecessed bytes to the beginning of the buffer
            std::copy(begin,end,m_buf->begin());
            m_buf->resize(static_cast<std::string::size_type>(end-begin));
            m_header_bytes -= m_buf->size();
 
            return len;
        }
 
        //the range [begin,end) now represents a line to be processed.
        if (end-begin == 0) {
            // we got a blank line
            if (m_method.empty() || get_header("Host").empty()) {
                throw exception("Incomplete Request",status_code::bad_request);
            }
 
            bytes_processed = (
                len - static_cast<std::string::size_type>(m_buf->end()-end)
                    + sizeof(header_delimiter) - 1
            );
 
            // frees memory used temporarily during request parsing
            m_buf.reset();
 
            // if this was not an upgrade request and has a content length
            // continue capturing content-length bytes and expose them as a 
            // request body.
            
            if (prepare_body()) {
                bytes_processed += process_body(buf+bytes_processed,len-bytes_processed);
                if (body_ready()) {
                    m_ready = true;
                }
                return bytes_processed;
            } else {
                m_ready = true;
 
                // return number of bytes processed (starting bytes - bytes left)
                return bytes_processed;
            }
        } else {
            if (m_method.empty()) {
                this->process(begin,end);
            } else {
                this->process_header(begin,end);
            }
        }
 
        begin = end+(sizeof(header_delimiter)-1);
    }
}

Here is the call graph for this function:

get_method()

std::string const & websocketpp::http::parser::request::get_method ( ) const

inline

Definition at line 96 of file request.hpp.

                                         {
        return m_method;
    }

get_uri()

std::string const & websocketpp::http::parser::request::get_uri ( ) const

inline

Definition at line 104 of file request.hpp.

                                      {
        return m_uri;
    }

raw()

std::string websocketpp::http::parser::request::raw ( ) const

inline

Definition at line 131 of file request.hpp.

                                    {
    // TODO: validation. Make sure all required fields have been set?
    std::stringstream ret;
 
    ret << m_method << " " << m_uri << " " << get_version() << "\r\n";
    ret << raw_headers() << "\r\n" << m_body;
 
    return ret.str();
}

Here is the call graph for this function:

raw_head()

std::string websocketpp::http::parser::request::raw_head ( ) const

inline

Definition at line 141 of file request.hpp.

                                         {
    // TODO: validation. Make sure all required fields have been set?
    std::stringstream ret;
 
    ret << m_method << " " << m_uri << " " << get_version() << "\r\n";
    ret << raw_headers() << "\r\n";
 
    return ret.str();
}

Here is the call graph for this function:

ready()

bool websocketpp::http::parser::request::ready ( ) const

inline

Definition at line 82 of file request.hpp.

                       {
        return m_ready;
    }

set_method()

void websocketpp::http::parser::request::set_method ( std::string const & method )

inline

Definition at line 151 of file request.hpp.

                                                        {
    if (std::find_if(method.begin(),method.end(),is_not_token_char) != method.end()) {
        throw exception("Invalid method token.",status_code::bad_request);
    }
 
    m_method = method;
}

Here is the call graph for this function:

set_uri()

void websocketpp::http::parser::request::set_uri ( std::string const & uri )

inline

Definition at line 159 of file request.hpp.

                                                  {
    // TODO: validation?
    m_uri = uri;
}

---

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

• libraries/fc/vendor/websocketpp/websocketpp/http/request.hpp
• libraries/fc/vendor/websocketpp/websocketpp/http/impl/request.hpp