websocketpp::http::parser::response Class Reference

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

#include <response.hpp>

Inheritance diagram for websocketpp::http::parser::response:

Collaboration diagram for websocketpp::http::parser::response:

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

Public Member Functions
	response ()
size_t	consume (char const *buf, size_t len)
	Process bytes in the input buffer.
size_t	consume (std::istream &s)
	Process bytes in the input buffer (istream version)
bool	ready () const
	Returns true if the response is ready.
bool	headers_ready () const
	Returns true if the response headers are fully parsed.
std::string	raw () const
	Returns the full raw response.
void	set_status (status_code::value code)
	Set response status code and message.
void	set_status (status_code::value code, std::string const &msg)
	Set response status code and message.
status_code::value	get_status_code () const
	Return the response status code.
const std::string &	get_status_msg () const
	Return the response status message.
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::response provides the following functionality for working with HTTP responses.

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

http::response checks for header completeness separately from the full response. Once the header is complete, the Content-Length header is read to determine when to stop reading body bytes. If no Content-Length is present ready() will never return true. It is the responsibility of the caller to consume to determine when the response is complete (ie when the connection terminates, or some other metric).

Definition at line 57 of file response.hpp.

Member Typedef Documentation

ptr

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

Definition at line 60 of file response.hpp.

type

response websocketpp::http::parser::response::type

Definition at line 59 of file response.hpp.

Constructor & Destructor Documentation

response()

websocketpp::http::parser::response::response ( )

inline

Definition at line 62 of file response.hpp.

      : m_read(0)
      , m_buf(lib::make_shared<std::string>())
      , m_status_code(status_code::uninitialized)
      , m_state(RESPONSE_LINE) {}

Member Function Documentation

consume() [1/2]

size_t websocketpp::http::parser::response::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 response and the full headers need not be available before processing can begin. If the end of the response 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 responses, incomplete responses, 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 42 of file response.hpp.

                                                            {
    if (m_state == DONE) {return 0;}
 
    if (m_state == BODY) {
        return this->process_body(buf,len);
    }
 
    // 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 = begin;
 
 
    for (;;) {
        // search for 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_read += len;
            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_state == RESPONSE_LINE) {
                throw exception("Incomplete Request",status_code::bad_request);
            }
 
            // TODO: grab content-length
            std::string length = get_header("Content-Length");
 
            if (length.empty()) {
                // no content length found, read indefinitely
                m_read = 0;
            } else {
                std::istringstream ss(length);
 
                if ((ss >> m_read).fail()) {
                    throw exception("Unable to parse Content-Length header",
                                    status_code::bad_request);
                }
            }
 
            m_state = BODY;
 
            // calc header bytes processed (starting bytes - bytes left)
            size_t read = (
                len - static_cast<std::string::size_type>(m_buf->end() - end)
                + sizeof(header_delimiter) - 1
            );
 
            // if there were bytes left process them as body bytes
            if (read < len) {
                read += this->process_body(buf+read,(len-read));
            }
 
            // frees memory used temporarily during header parsing
            m_buf.reset();
 
            return read;
        } else {
            if (m_state == RESPONSE_LINE) {
                this->process(begin,end);
                m_state = HEADERS;
            } else {
                this->process_header(begin,end);
            }
        }
 
        begin = end+(sizeof(header_delimiter) - 1);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

consume() [2/2]

size_t websocketpp::http::parser::response::consume ( std::istream & s )

inline

Process bytes from istream s. 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 response and the full headers need not be available before processing can begin. If the end of the response 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 responses, incomplete responses, 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 139 of file response.hpp.

                                              {
    char buf[istream_buffer];
    size_t bytes_read;
    size_t bytes_processed;
    size_t total = 0;
 
    while (s.good()) {
        s.getline(buf,istream_buffer);
        bytes_read = static_cast<size_t>(s.gcount());
 
        if (s.fail() || s.eof()) {
            bytes_processed = this->consume(buf,bytes_read);
            total += bytes_processed;
 
            if (bytes_processed != bytes_read) {
                // problem
                break;
            }
        } else if (s.bad()) {
            // problem
            break;
        } else {
            // the delimiting newline was found. Replace the trailing null with
            // the newline that was discarded, since our raw consume function
            // expects the newline to be be there.
            buf[bytes_read-1] = '\n';
            bytes_processed = this->consume(buf,bytes_read);
            total += bytes_processed;
 
            if (bytes_processed != bytes_read) {
                // problem
                break;
            }
        }
    }
 
    return total;
}

Here is the call graph for this function:

get_status_code()

status_code::value websocketpp::http::parser::response::get_status_code ( ) const

inline

Definition at line 152 of file response.hpp.

                                             {
        return m_status_code;
    }

get_status_msg()

const std::string & websocketpp::http::parser::response::get_status_msg ( ) const

inline

Definition at line 157 of file response.hpp.

                                            {
        return m_status_msg;
    }

headers_ready()

bool websocketpp::http::parser::response::headers_ready ( ) const

inline

Definition at line 121 of file response.hpp.

                               {
        return (m_state == BODY || m_state == DONE);
    }

raw()

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

inline

Definition at line 178 of file response.hpp.

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

Here is the call graph for this function:

ready()

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

inline

Note

will never return true if the content length header is not present

Definition at line 116 of file response.hpp.

                       {
        return m_state == DONE;
    }

set_status() [1/2]

void websocketpp::http::parser::response::set_status ( status_code::value code )

inline

Sets the response status code to code and looks up the corresponding message for standard codes. Non-standard codes will be entered as Unknown use set_status(status_code::value,std::string) overload to set both values explicitly.

Parameters

code	Code to set
msg	Message to set

Definition at line 191 of file response.hpp.

                                                      {
    // TODO: validation?
    m_status_code = code;
    m_status_msg = get_string(code);
}

set_status() [2/2]

void websocketpp::http::parser::response::set_status ( status_code::value code, std::string const & msg )

inline

Sets the response status code and message to independent custom values. use set_status(status_code::value) to set the code and have the standard message be automatically set.

Parameters

code	Code to set
msg	Message to set

Definition at line 197 of file response.hpp.

{
    // TODO: validation?
    m_status_code = code;
    m_status_msg = msg;
}

---

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

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