http_parser.hpp

Go to the documentation of this file.

/*
 * Copyright 2015, alex at staticlibs.net
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// ---------------------------------------------------------------------
// pion:  a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc.  (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//

#ifndef STATICLIB_PION_HTTP_PARSER_HPP
#define STATICLIB_PION_HTTP_PARSER_HPP

#include <cstdint>
#include <functional>
#include <mutex>
#include <string>

#include "staticlib/config.hpp"
#include "staticlib/support.hpp"

#include "staticlib/pion/algorithm.hpp"
#include "staticlib/pion/logger.hpp"
#include "staticlib/pion/http_message.hpp"

namespace staticlib { 
namespace pion {

// forward declarations used for finishing HTTP messages
class http_request;
class http_response;

class http_parser {
public:

    static const size_t DEFAULT_CONTENT_MAX;

    using payload_handler_type = std::function<void(const char *, size_t)>;

    enum error_value_t {
        ERROR_METHOD_CHAR = 1,
        ERROR_METHOD_SIZE,
        ERROR_URI_CHAR,
        ERROR_URI_SIZE,
        ERROR_QUERY_CHAR,
        ERROR_QUERY_SIZE,
        ERROR_VERSION_EMPTY,
        ERROR_VERSION_CHAR,
        ERROR_STATUS_EMPTY,
        ERROR_STATUS_CHAR,
        ERROR_HEADER_CHAR,
        ERROR_HEADER_NAME_SIZE,
        ERROR_HEADER_VALUE_SIZE,
        ERROR_INVALID_CONTENT_LENGTH,
        ERROR_CHUNK_CHAR,
        ERROR_MISSING_CHUNK_DATA,
        ERROR_MISSING_HEADER_DATA,
        ERROR_MISSING_TOO_MUCH_CONTENT,
    };

    class error_category_t : public asio::error_category {
    public:
        const char *name() const STATICLIB_NOEXCEPT {
            return "parser";
        }
        
        std::string message(int ev) const;
    };

protected:

    static const uint32_t STATUS_MESSAGE_MAX;

    static const uint32_t METHOD_MAX;

    static const uint32_t RESOURCE_MAX;

    static const uint32_t QUERY_STRING_MAX;

    static const uint32_t HEADER_NAME_MAX;

    static const uint32_t HEADER_VALUE_MAX;

    static const uint32_t QUERY_NAME_MAX;

    static const uint32_t QUERY_VALUE_MAX;

    static const uint32_t COOKIE_NAME_MAX;

    static const uint32_t COOKIE_VALUE_MAX;

    const char * m_read_ptr;

    const char * m_read_end_ptr;

private:
    enum message_parse_state_type {
        PARSE_START,
        PARSE_HEADERS,
        PARSE_FOOTERS,
        PARSE_CONTENT,
        PARSE_CONTENT_NO_LENGTH,
        PARSE_CHUNKS, PARSE_END
    };

    enum header_parse_state_type {
        PARSE_METHOD_START,
        PARSE_METHOD,
        PARSE_URI_STEM,
        PARSE_URI_QUERY,
        PARSE_HTTP_VERSION_H,
        PARSE_HTTP_VERSION_T_1,
        PARSE_HTTP_VERSION_T_2,
        PARSE_HTTP_VERSION_P,
        PARSE_HTTP_VERSION_SLASH,
        PARSE_HTTP_VERSION_MAJOR_START,
        PARSE_HTTP_VERSION_MAJOR,
        PARSE_HTTP_VERSION_MINOR_START,
        PARSE_HTTP_VERSION_MINOR,
        PARSE_STATUS_CODE_START,
        PARSE_STATUS_CODE,
        PARSE_STATUS_MESSAGE,
        PARSE_EXPECTING_NEWLINE,
        PARSE_EXPECTING_CR,
        PARSE_HEADER_WHITESPACE,
        PARSE_HEADER_START,
        PARSE_HEADER_NAME,
        PARSE_SPACE_BEFORE_HEADER_VALUE,
        PARSE_HEADER_VALUE,
        PARSE_EXPECTING_FINAL_NEWLINE,
        PARSE_EXPECTING_FINAL_CR
    };

    enum chunk_parse_state_type {
        PARSE_CHUNK_SIZE_START,
        PARSE_CHUNK_SIZE,
        PARSE_EXPECTING_IGNORED_TEXT_AFTER_CHUNK_SIZE,
        PARSE_EXPECTING_CR_AFTER_CHUNK_SIZE,
        PARSE_EXPECTING_LF_AFTER_CHUNK_SIZE,
        PARSE_CHUNK,
        PARSE_EXPECTING_CR_AFTER_CHUNK,
        PARSE_EXPECTING_LF_AFTER_CHUNK,
        PARSE_EXPECTING_FINAL_CR_OR_FOOTERS_AFTER_LAST_CHUNK,
        PARSE_EXPECTING_FINAL_LF_AFTER_LAST_CHUNK
    };

    message_parse_state_type m_message_parse_state;

    header_parse_state_type m_headers_parse_state;

    chunk_parse_state_type m_chunked_content_parse_state;

    payload_handler_type* m_payload_handler = nullptr;

    uint16_t m_status_code;

    std::string m_status_message;

    std::string m_method;

    std::string m_resource;

    std::string m_query_string;

    std::string m_raw_headers;

    std::string m_header_name;

    std::string m_header_value;

    std::string m_chunk_size_str;

    size_t m_size_of_current_chunk;

    size_t m_bytes_read_in_current_chunk;

    size_t m_bytes_content_remaining;

    size_t m_bytes_content_read;

    size_t m_bytes_last_read;

    size_t m_bytes_total_read;

    size_t m_max_content_length;

    bool m_parse_headers_only;

    bool m_save_raw_headers;

    static error_category_t * m_error_category_ptr;

    static std::once_flag m_instance_flag;

public:

    http_parser(size_t max_content_length = DEFAULT_CONTENT_MAX) :
    m_read_ptr(nullptr),
    m_read_end_ptr(nullptr),
    m_message_parse_state(PARSE_START),
    m_headers_parse_state(PARSE_METHOD_START),
    m_chunked_content_parse_state(PARSE_CHUNK_SIZE_START),
    m_status_code(0),
    m_bytes_content_remaining(0),
    m_bytes_content_read(0),
    m_bytes_last_read(0),
    m_bytes_total_read(0),
    m_max_content_length(max_content_length),
    m_parse_headers_only(false),
    m_save_raw_headers(false) { }

    http_parser(const http_parser&) = delete;

    http_parser& operator=(const http_parser&) = delete;

    virtual ~http_parser() STATICLIB_NOEXCEPT { }

    sl::support::tribool parse(http_message& http_msg, std::error_code& ec);

    void finish(http_message& http_msg) const;

    void set_read_buffer(const char *ptr, size_t len) {
        m_read_ptr = ptr;
        m_read_end_ptr = ptr + len;
    }

    void load_read_pos(const char *&read_ptr, const char *&read_end_ptr) const {
        read_ptr = m_read_ptr;
        read_end_ptr = m_read_end_ptr;
    }

    bool check_premature_eof(http_message& http_msg) {
        if (m_message_parse_state != PARSE_CONTENT_NO_LENGTH) {
            return true;
        }
        m_message_parse_state = PARSE_END;
        http_msg.concatenate_chunks();
        finish(http_msg);
        return false;
    }

    void parse_headers_only(bool b = true) {
        m_parse_headers_only = b;
    }

    void skip_header_parsing(http_message& http_msg) {
        std::error_code ec;
        finish_header_parsing(http_msg, ec);
    }
    
    void reset() {
        m_message_parse_state = PARSE_START;
        m_headers_parse_state = PARSE_METHOD_START;
        m_chunked_content_parse_state = PARSE_CHUNK_SIZE_START;
        m_status_code = 0;
        m_status_message.erase();
        m_method.erase();
        m_resource.erase();
        m_query_string.erase();
        m_raw_headers.erase();
        m_bytes_content_read = m_bytes_last_read = m_bytes_total_read = 0;
    }

    bool eof() const {
        return m_read_ptr == nullptr || m_read_ptr >= m_read_end_ptr;
    }

    size_t bytes_available() const {
        return (eof() ? 0 : (size_t)(m_read_end_ptr - m_read_ptr));
    }

    size_t gcount() const {
        return m_bytes_last_read;
    }

    size_t get_total_bytes_read() const {
        return m_bytes_total_read;
    }

    size_t get_content_bytes_read() const {
        return m_bytes_content_read;
    }

    size_t get_max_content_length() const {
        return m_max_content_length;
    }

    const std::string& get_raw_headers() const {
        return m_raw_headers;
    }

    bool get_save_raw_headers() const {
        return m_save_raw_headers;
    }

    bool get_parse_headers_only() {
        return m_parse_headers_only;
    }
    
    bool is_parsing_request() const;

    bool is_parsing_response() const;

    void set_payload_handler(payload_handler_type& h) {
        m_payload_handler = &h;
    }

    void set_max_content_length(size_t n) {
        m_max_content_length = n;
    }

    void reset_max_content_length() {
        m_max_content_length = DEFAULT_CONTENT_MAX;
    }

    void set_save_raw_headers(bool b) {
        m_save_raw_headers = b;
    }

    static bool parse_uri(const std::string& uri, std::string& proto, std::string& host,
            uint16_t& port, std::string& path, std::string& query);

    static bool parse_url_encoded(std::unordered_multimap<std::string, std::string, algorithm::ihash, algorithm::iequal_to>& dict,
            const char *ptr, const size_t len);

    static bool parse_multipart_form_data(std::unordered_multimap<std::string, std::string, algorithm::ihash, algorithm::iequal_to>& dict,
            const std::string& content_type, const char *ptr, const size_t len);

    static bool parse_cookie_header(std::unordered_multimap<std::string, std::string, algorithm::ihash, algorithm::iequal_to>& dict,
            const char *ptr, const size_t len, bool set_cookie_header);

    static bool parse_cookie_header(std::unordered_multimap<std::string, std::string, algorithm::ihash, algorithm::iequal_to>& dict,
            const std::string& cookie_header, bool set_cookie_header);

    static bool parse_url_encoded(std::unordered_multimap<std::string, std::string, algorithm::ihash, algorithm::iequal_to>& dict,
            const std::string& query);

    static bool parse_multipart_form_data(std::unordered_multimap<std::string, std::string, algorithm::ihash, algorithm::iequal_to>& dict,
            const std::string& content_type, const std::string& form_data);
 
    sl::support::tribool finish_header_parsing(http_message& http_msg, std::error_code& ec);

    static error_category_t& get_error_category() {
        std::call_once(m_instance_flag, http_parser::create_error_category);
        return *m_error_category_ptr;
    }

protected:

    virtual void finished_parsing_headers(const std::error_code& /* ec */, sl::support::tribool& /* rc */) {
        // no-op
    }
    
    sl::support::tribool parse_headers(http_message& http_msg, std::error_code& ec);

    void update_message_with_header_data(http_message& http_msg) const;

    sl::support::tribool parse_chunks(std::vector<char>& chunk_buffers, std::error_code& ec);

    sl::support::tribool consume_content(http_message& http_msg, std::error_code& ec);

    size_t consume_content_as_next_chunk(std::vector<char>& chunk_buffers);

    static void compute_msg_status(http_message& http_msg, bool msg_parsed_ok);

    static void set_error(std::error_code& ec, error_value_t ev) {
        ec = std::error_code(static_cast<int> (ev), get_error_category());
    }

    static void create_error_category() {
        static error_category_t UNIQUE_ERROR_CATEGORY;
        m_error_category_ptr = &UNIQUE_ERROR_CATEGORY;
    }

    // misc functions used by the parsing functions

    static bool is_digit(int c) {
        return (c >= '0' && c <= '9');
    }
    
    static bool is_hex_digit(int c) {
        return ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'));
    }
    
    static bool is_cookie_attribute(const std::string& name, bool set_cookie_header);

};

} // namespace
}

#endif // STATICLIB_PION_HTTP_PARSER_HPP