parser.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014, Peter Thorson. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the WebSocket++ Project nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
 
#ifndef HTTP_PARSER_HPP
#define HTTP_PARSER_HPP
 
#include <algorithm>
#include <map>
#include <string>
#include <utility>
 
#include <websocketpp/utilities.hpp>
#include <websocketpp/http/constants.hpp>
 
namespace websocketpp {
namespace http {
namespace parser {
 
namespace state {
    enum value {
        method,
        resource,
        version,
        headers
    };
}
 
namespace body_encoding {
    enum value {
        unknown,
        plain,
        chunked
    };
}
 
typedef std::map<std::string, std::string, utility::ci_less > header_list;
 
 
template <typename InputIterator>
std::pair<std::string,InputIterator> extract_token(InputIterator begin,
    InputIterator end)
{
    InputIterator it = std::find_if(begin,end,&is_not_token_char);
    return std::make_pair(std::string(begin,it),it);
}
 
 
template <typename InputIterator>
std::pair<std::string,InputIterator> extract_quoted_string(InputIterator begin,
    InputIterator end)
{
    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);
}
 
 
template <typename InputIterator>
InputIterator extract_lws(InputIterator begin, InputIterator end) {
    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;
}
 
 
template <typename InputIterator>
InputIterator extract_all_lws(InputIterator begin, InputIterator end) {
    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;
}
 
 
template <typename InputIterator>
InputIterator extract_attributes(InputIterator begin, InputIterator end,
    attribute_list & attributes)
{
    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;
}
 
 
template <typename InputIterator>
InputIterator extract_parameters(InputIterator begin, InputIterator end,
    parameter_list &parameters)
{
    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;
}
 
inline std::string strip_lws(std::string const & input) {
    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());
}
 
 
class parser {
public:
    parser()
      : m_header_bytes(0)
      , m_body_bytes_needed(0)
      , m_body_bytes_max(max_body_size)
      , m_body_encoding(body_encoding::unknown) {}
    
 
    std::string const & get_version() const {
        return m_version;
    }
 
 
    void set_version(std::string const & version);
 
 
    std::string const & get_header(std::string const & key) const;
 
 
    bool get_header_as_plist(std::string const & key, parameter_list & out)
        const;
 
 
    void append_header(std::string const & key, std::string const & val);
 
 
    void replace_header(std::string const & key, std::string const & val);
 
 
    void remove_header(std::string const & key);
 
 
    std::string const & get_body() const {
        return m_body;
    }
 
 
    void set_body(std::string const & value);
 
 
    size_t get_max_body_size() const {
        return m_body_bytes_max;
    }
 
 
    void set_max_body_size(size_t value) {
        m_body_bytes_max = value;
    }
 
 
    bool parse_parameter_list(std::string const & in, parameter_list & out)
        const;
protected:
 
    void process_header(std::string::iterator begin, std::string::iterator end);
 
 
    bool prepare_body();
 
 
    size_t process_body(char const * buf, size_t len);
 
 
    bool body_ready() const {
        return (m_body_bytes_needed == 0);
    }
 
 
    std::string raw_headers() const;
 
    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;
};
 
} // namespace parser
} // namespace http
} // namespace websocketpp
 
#include <websocketpp/http/impl/parser.hpp>
 
#endif // HTTP_PARSER_HPP