websocketpp::http::parser Namespace Reference

Namespaces
namespace	body_encoding
namespace	state

Classes
class	parser
	Base HTTP parser. More...
class	request
	Stores, parses, and manipulates HTTP requests. More...
class	response
	Stores, parses, and manipulates HTTP responses. More...

Typedefs
typedef std::map< std::string, std::string, utility::ci_less >	header_list

Functions
template<typename InputIterator >
std::pair< std::string, InputIterator >	extract_token (InputIterator begin, InputIterator end)
	Read and return the next token in the stream.
template<typename InputIterator >
std::pair< std::string, InputIterator >	extract_quoted_string (InputIterator begin, InputIterator end)
	Read and return the next quoted string in the stream.
template<typename InputIterator >
InputIterator	extract_lws (InputIterator begin, InputIterator end)
	Read and discard one unit of linear whitespace.
template<typename InputIterator >
InputIterator	extract_all_lws (InputIterator begin, InputIterator end)
	Read and discard linear whitespace.
template<typename InputIterator >
InputIterator	extract_attributes (InputIterator begin, InputIterator end, attribute_list &attributes)
	Extract HTTP attributes.
template<typename InputIterator >
InputIterator	extract_parameters (InputIterator begin, InputIterator end, parameter_list &parameters)
	Extract HTTP parameters.
std::string	strip_lws (std::string const &input)

Typedef Documentation

header_list

typedef std::map<std::string, std::string, utility::ci_less > websocketpp::http::parser::header_list

Definition at line 60 of file parser.hpp.

Function Documentation

extract_all_lws()

template<typename InputIterator >

InputIterator websocketpp::http::parser::extract_all_lws	(	InputIterator	begin,
		InputIterator	end )

Read linear white space until a non-lws character is read and return an iterator to that character. If begin is returned, no whitespace was extracted.

Parameters

begin	An iterator to the beginning of the sequence
end	An iterator to the end of the sequence

Returns

An iterator to the character after the linear whitespace read

Definition at line 164 of file parser.hpp.

                                                                      {
    InputIterator old_it;
    InputIterator new_it = begin;
 
    do {
        // Pull value from previous iteration
        old_it = new_it;
 
        // look ahead another pass
        new_it = extract_lws(old_it,end);
    } while (new_it != end && old_it != new_it);
 
    return new_it;
}

Here is the call graph for this function:

Here is the caller graph for this function:

extract_attributes()

template<typename InputIterator >

InputIterator websocketpp::http::parser::extract_attributes	(	InputIterator	begin,
		InputIterator	end,
		attribute_list &	attributes )

An http attributes list is a semicolon delimited list of key value pairs in the format: *( ";" attribute "=" value ) where attribute is a token and value is a token or quoted string.

Attributes extracted are appended to the supplied attributes list attributes.

Parameters

[in]	begin	An iterator to the beginning of the sequence
[in]	end	An iterator to the end of the sequence
[out]	attributes	A reference to the attributes list to append attribute/value pairs extracted to

Returns

An iterator to the character after the last atribute read

Definition at line 195 of file parser.hpp.

{
    InputIterator cursor;
    bool first = true;
 
    if (begin == end) {
        return begin;
    }
 
    cursor = begin;
    std::pair<std::string,InputIterator> ret;
 
    while (cursor != end) {
        std::string name;
 
        cursor = http::parser::extract_all_lws(cursor,end);
        if (cursor == end) {
            break;
        }
 
        if (first) {
            // ignore this check for the very first pass
            first = false;
        } else {
            if (*cursor == ';') {
                // advance past the ';'
                ++cursor;
            } else {
                // non-semicolon in this position indicates end end of the
                // attribute list, break and return.
                break;
            }
        }
 
        cursor = http::parser::extract_all_lws(cursor,end);
        ret = http::parser::extract_token(cursor,end);
 
        if (ret.first.empty()) {
            // error: expected a token
            return begin;
        } else {
            name = ret.first;
            cursor = ret.second;
        }
 
        cursor = http::parser::extract_all_lws(cursor,end);
        if (cursor == end || *cursor != '=') {
            // if there is an equals sign, read the attribute value. Otherwise
            // record a blank value and continue
            attributes[name].clear();
            continue;
        }
 
        // advance past the '='
        ++cursor;
 
        cursor = http::parser::extract_all_lws(cursor,end);
        if (cursor == end) {
            // error: expected a token or quoted string
            return begin;
        }
 
        ret = http::parser::extract_quoted_string(cursor,end);
        if (ret.second != cursor) {
            attributes[name] = ret.first;
            cursor = ret.second;
            continue;
        }
 
        ret = http::parser::extract_token(cursor,end);
        if (ret.first.empty()) {
            // error : expected token or quoted string
            return begin;
        } else {
            attributes[name] = ret.first;
            cursor = ret.second;
        }
    }
 
    return cursor;
}

Here is the call graph for this function:

Here is the caller graph for this function:

extract_lws()

template<typename InputIterator >

InputIterator websocketpp::http::parser::extract_lws	(	InputIterator	begin,
		InputIterator	end )

Read one unit of linear white space and return the iterator to the character afterwards. If begin is returned, no whitespace was extracted.

Parameters

begin	An iterator to the beginning of the sequence
end	An iterator to the end of the sequence

Returns

An iterator to the character after the linear whitespace read

Definition at line 139 of file parser.hpp.

                                                                  {
    InputIterator it = begin;
 
    // strip leading CRLF
    if (end-begin > 2 && *begin == '\r' && *(begin+1) == '\n' &&
        is_whitespace_char(static_cast<unsigned char>(*(begin+2))))
    {
        it+=3;
    }
 
    it = std::find_if(it,end,&is_not_whitespace_char);
    return it;
}

Here is the call graph for this function:

Here is the caller graph for this function:

extract_parameters()

template<typename InputIterator >

InputIterator websocketpp::http::parser::extract_parameters	(	InputIterator	begin,
		InputIterator	end,
		parameter_list &	parameters )

An http parameters list is a comma delimited list of tokens followed by optional semicolon delimited attributes lists.

Parameters extracted are appended to the supplied parameters list parameters.

Parameters

[in]	begin	An iterator to the beginning of the sequence
[in]	end	An iterator to the end of the sequence
[out]	parameters	A reference to the parameters list to append paramter values extracted to

Returns

An iterator to the character after the last parameter read

LWS token LWS *(";" method-param) LWS ,=loop again

Definition at line 293 of file parser.hpp.

{
    InputIterator cursor;
 
    if (begin == end) {
        // error: expected non-zero length range
        return begin;
    }
 
    cursor = begin;
    std::pair<std::string,InputIterator> ret;
 
    while (cursor != end) {
        std::string parameter_name;
        attribute_list attributes;
 
        // extract any stray whitespace
        cursor = http::parser::extract_all_lws(cursor,end);
        if (cursor == end) {break;}
 
        ret = http::parser::extract_token(cursor,end);
 
        if (ret.first.empty()) {
            // error: expected a token
            return begin;
        } else {
            parameter_name = ret.first;
            cursor = ret.second;
        }
 
        // Safe break point, insert parameter with blank attributes and exit
        cursor = http::parser::extract_all_lws(cursor,end);
        if (cursor == end) {
            //parameters[parameter_name] = attributes;
            parameters.push_back(std::make_pair(parameter_name,attributes));
            break;
        }
 
        // If there is an attribute list, read it in
        if (*cursor == ';') {
            InputIterator acursor;
 
            ++cursor;
            acursor = http::parser::extract_attributes(cursor,end,attributes);
 
            if (acursor == cursor) {
                // attribute extraction ended in syntax error
                return begin;
            }
 
            cursor = acursor;
        }
 
        // insert parameter into output list
        //parameters[parameter_name] = attributes;
        parameters.push_back(std::make_pair(parameter_name,attributes));
 
        cursor = http::parser::extract_all_lws(cursor,end);
        if (cursor == end) {break;}
 
        // if next char is ',' then read another parameter, else stop
        if (*cursor != ',') {
            break;
        }
 
        // advance past comma
        ++cursor;
 
        if (cursor == end) {
            // expected more bytes after a comma
            return begin;
        }
    }
 
    return cursor;
}

Here is the call graph for this function:

Here is the caller graph for this function:

extract_quoted_string()

template<typename InputIterator >

std::pair< std::string, InputIterator > websocketpp::http::parser::extract_quoted_string	(	InputIterator	begin,
		InputIterator	end )

Read a double quoted string starting at begin. The quotes themselves are stripped. The quoted value is returned along with an iterator to the next character to read

Parameters

begin	An iterator to the beginning of the sequence
end	An iterator to the end of the sequence

Returns

A pair containing the string read and an iterator to the next character in the stream

Definition at line 92 of file parser.hpp.

{
    std::string s;
 
    if (end == begin) {
        return std::make_pair(s,begin);
    }
 
    if (*begin != '"') {
        return std::make_pair(s,begin);
    }
 
    InputIterator cursor = begin+1;
    InputIterator marker = cursor;
 
    cursor = std::find(cursor,end,'"');
 
    while (cursor != end) {
        // either this is the end or a quoted string
        if (*(cursor-1) == '\\') {
            s.append(marker,cursor-1);
            s.append(1,'"');
            ++cursor;
            marker = cursor;
        } else {
            s.append(marker,cursor);
            ++cursor;
            return std::make_pair(s,cursor);
        }
 
        cursor = std::find(cursor,end,'"');
    }
 
    return std::make_pair("",begin);
}

Here is the caller graph for this function:

extract_token()

template<typename InputIterator >

std::pair< std::string, InputIterator > websocketpp::http::parser::extract_token	(	InputIterator	begin,
		InputIterator	end )

Read until a non-token character is found and then return the token and iterator to the next character to read

Parameters

begin	An iterator to the beginning of the sequence
end	An iterator to the end of the sequence

Returns

A pair containing the token and an iterator to the next character in the stream

Definition at line 73 of file parser.hpp.

{
    InputIterator it = std::find_if(begin,end,&is_not_token_char);
    return std::make_pair(std::string(begin,it),it);
}

Here is the call graph for this function:

Here is the caller graph for this function:

strip_lws()

std::string websocketpp::http::parser::strip_lws ( std::string const & input )

inline

Definition at line 379 of file parser.hpp.

                                                    {
    std::string::const_iterator begin = extract_all_lws(input.begin(),input.end());
    if (begin == input.end()) {
        return std::string();
    }
 
    std::string::const_reverse_iterator rbegin = extract_all_lws(input.rbegin(),input.rend());
    if (rbegin == input.rend()) {
        return std::string();
    }
 
    return std::string(begin,rbegin.base());
}

Here is the call graph for this function:

Here is the caller graph for this function: