http_message.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_MESSAGE_HPP
#define STATICLIB_PION_HTTP_MESSAGE_HPP

#include <cstring>
#include <cstdint>
#include <iosfwd>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>

#include "asio.hpp"

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

#include "staticlib/pion/algorithm.hpp"

namespace staticlib {
namespace pion {

// forward declaration for class used by send() and receive()
class tcp_connection;
// forward declaration of parser class
class http_parser;

class http_message  {
public:

//    using chunk_cache_type = std::vector<char>; 

    enum data_status_type {
        STATUS_NONE,

        STATUS_TRUNCATED,

        STATUS_PARTIAL,

        STATUS_OK
    };

    struct receive_error_t : public asio::error_category {
        virtual ~receive_error_t() STATICLIB_NOEXCEPT { }

        virtual const char* name() const STATICLIB_NOEXCEPT {
            return "receive_error_t";
        }

        virtual std::string message(int ev) const {
            std::string result;
            switch (ev) {
            case 1:
                result = "HTTP message parsing error";
                break;
            default:
                result = "Unknown receive error";
                break;
            }
            return result;
        }
    };

    // generic strings used by HTTP
    static const std::string STRING_EMPTY;
    static const std::string STRING_CRLF;
    static const std::string STRING_HTTP_VERSION;
    static const std::string HEADER_NAME_VALUE_DELIMITER;
    static const std::string COOKIE_NAME_VALUE_DELIMITER;

    // common HTTP header names
    static const std::string HEADER_HOST;
    static const std::string HEADER_COOKIE;
    static const std::string HEADER_SET_COOKIE;
    static const std::string HEADER_CONNECTION;
    static const std::string HEADER_CONTENT_TYPE;
    static const std::string HEADER_CONTENT_LENGTH;
    static const std::string HEADER_CONTENT_LOCATION;
    static const std::string HEADER_CONTENT_ENCODING;
    static const std::string HEADER_CONTENT_DISPOSITION;
    static const std::string HEADER_LAST_MODIFIED;
    static const std::string HEADER_IF_MODIFIED_SINCE;
    static const std::string HEADER_TRANSFER_ENCODING;
    static const std::string HEADER_LOCATION;
    static const std::string HEADER_AUTHORIZATION;
    static const std::string HEADER_REFERER;
    static const std::string HEADER_USER_AGENT;
    static const std::string HEADER_X_FORWARDED_FOR;
    static const std::string HEADER_CLIENT_IP;

    // common HTTP content types
    static const std::string CONTENT_TYPE_HTML;
    static const std::string CONTENT_TYPE_TEXT;
    static const std::string CONTENT_TYPE_XML;
    static const std::string CONTENT_TYPE_URLENCODED;
    static const std::string CONTENT_TYPE_MULTIPART_FORM_DATA;

    // common HTTP request methods
    static const std::string REQUEST_METHOD_HEAD;
    static const std::string REQUEST_METHOD_GET;
    static const std::string REQUEST_METHOD_PUT;
    static const std::string REQUEST_METHOD_POST;
    static const std::string REQUEST_METHOD_DELETE;
    static const std::string REQUEST_METHOD_OPTIONS;

    // common HTTP response messages
    static const std::string RESPONSE_MESSAGE_OK;
    static const std::string RESPONSE_MESSAGE_CREATED;
    static const std::string RESPONSE_MESSAGE_ACCEPTED;
    static const std::string RESPONSE_MESSAGE_NO_CONTENT;
    static const std::string RESPONSE_MESSAGE_FOUND;
    static const std::string RESPONSE_MESSAGE_UNAUTHORIZED;
    static const std::string RESPONSE_MESSAGE_FORBIDDEN;
    static const std::string RESPONSE_MESSAGE_NOT_FOUND;
    static const std::string RESPONSE_MESSAGE_METHOD_NOT_ALLOWED;
    static const std::string RESPONSE_MESSAGE_NOT_MODIFIED;
    static const std::string RESPONSE_MESSAGE_BAD_REQUEST;
    static const std::string RESPONSE_MESSAGE_SERVER_ERROR;
    static const std::string RESPONSE_MESSAGE_NOT_IMPLEMENTED;
    static const std::string RESPONSE_MESSAGE_CONTINUE;

    // common HTTP response codes
    static const unsigned int RESPONSE_CODE_OK;
    static const unsigned int RESPONSE_CODE_CREATED;
    static const unsigned int RESPONSE_CODE_ACCEPTED;
    static const unsigned int RESPONSE_CODE_NO_CONTENT;
    static const unsigned int RESPONSE_CODE_FOUND;
    static const unsigned int RESPONSE_CODE_UNAUTHORIZED;
    static const unsigned int RESPONSE_CODE_FORBIDDEN;
    static const unsigned int RESPONSE_CODE_NOT_FOUND;
    static const unsigned int RESPONSE_CODE_METHOD_NOT_ALLOWED;
    static const unsigned int RESPONSE_CODE_NOT_MODIFIED;
    static const unsigned int RESPONSE_CODE_BAD_REQUEST;
    static const unsigned int RESPONSE_CODE_SERVER_ERROR;
    static const unsigned int RESPONSE_CODE_NOT_IMPLEMENTED;
    static const unsigned int RESPONSE_CODE_CONTINUE;

    // response to "Expect: 100-Continue" header
    static const std::string RESPONSE_FULLMESSAGE_100_CONTINUE;

protected:
 
    mutable std::string m_first_line;

    class content_buffer_t {
        std::unique_ptr<char[]> m_buf;
        std::size_t m_len;
        char m_empty;
        char *m_ptr;
    public:
        ~content_buffer_t() { }

        content_buffer_t() :
        m_buf(), 
        m_len(0),
        m_empty(0),
        m_ptr(&m_empty) { }

        content_buffer_t(const content_buffer_t& buf) :
        m_buf(), 
        m_len(0),
        m_empty(0),
        m_ptr(&m_empty) {
            if (buf.size()) {
                resize(buf.size());
                memcpy(get(), buf.get(), buf.size());
            }
        }

        content_buffer_t& operator=(const content_buffer_t& buf) {
            if (buf.size()) {
                resize(buf.size());
                memcpy(get(), buf.get(), buf.size());
            } else {
                clear();
            }
            return *this;
        }

        bool is_empty() const {
            return m_len == 0;
        }

        std::size_t size() const {
            return m_len;
        }

        const char *get() const {
            return m_ptr;
        }

        char *get() {
            return m_ptr;
        }

        void resize(std::size_t len) {
            m_len = len;
            if (len == 0) {
                m_buf.reset();
                m_ptr = &m_empty;
            } else {
                m_buf.reset(new char[len + 1]); 
                memset(m_buf.get(), '\0', len + 1);
                m_ptr = m_buf.get();
            }
        }

        void clear() {
            resize(0);
        }
    };
    
private:
    
    using headers_type = std::unordered_multimap<std::string, std::string, algorithm::ihash, algorithm::iequal_to>;
    
    bool m_is_valid;

    bool m_is_chunked;

    bool m_chunks_supported;

    bool m_do_not_send_content_length;

    asio::ip::address m_remote_ip;

    uint16_t m_version_major;

    uint16_t m_version_minor;

    size_t m_content_length;

    content_buffer_t m_content_buf;

    std::vector<char> m_chunk_cache;

    headers_type m_headers;

    headers_type m_cookie_params;

    data_status_type m_status;

    bool m_has_missing_packets;

    bool m_has_data_after_missing;    

public:

    http_message() :
    m_is_valid(false), 
    m_is_chunked(false),
    m_chunks_supported(false),
    m_do_not_send_content_length(false),
    m_version_major(1),
    m_version_minor(1),
    m_content_length(0),
    m_content_buf(),
    m_status(STATUS_NONE),
    m_has_missing_packets(false),
    m_has_data_after_missing(false) { }

    http_message(const http_message& http_msg) :
    m_first_line(http_msg.m_first_line),
    m_is_valid(http_msg.m_is_valid),
    m_is_chunked(http_msg.m_is_chunked),
    m_chunks_supported(http_msg.m_chunks_supported),
    m_do_not_send_content_length(http_msg.m_do_not_send_content_length),
    m_remote_ip(http_msg.m_remote_ip),
    m_version_major(http_msg.m_version_major),
    m_version_minor(http_msg.m_version_minor),
    m_content_length(http_msg.m_content_length),
    m_content_buf(http_msg.m_content_buf),
    m_chunk_cache(http_msg.m_chunk_cache),
    m_headers(http_msg.m_headers),
    m_status(http_msg.m_status),
    m_has_missing_packets(http_msg.m_has_missing_packets),
    m_has_data_after_missing(http_msg.m_has_data_after_missing) { }

    http_message& operator=(const http_message& http_msg) {
        m_first_line = http_msg.m_first_line;
        m_is_valid = http_msg.m_is_valid;
        m_is_chunked = http_msg.m_is_chunked;
        m_chunks_supported = http_msg.m_chunks_supported;
        m_do_not_send_content_length = http_msg.m_do_not_send_content_length;
        m_remote_ip = http_msg.m_remote_ip;
        m_version_major = http_msg.m_version_major;
        m_version_minor = http_msg.m_version_minor;
        m_content_length = http_msg.m_content_length;
        m_content_buf = http_msg.m_content_buf;
        m_chunk_cache = http_msg.m_chunk_cache;
        m_headers = http_msg.m_headers;
        m_status = http_msg.m_status;
        m_has_missing_packets = http_msg.m_has_missing_packets;
        m_has_data_after_missing = http_msg.m_has_data_after_missing;
        return *this;
    }

    virtual ~http_message() STATICLIB_NOEXCEPT { }

    virtual void clear() {
        clear_first_line();
        m_is_valid = m_is_chunked = m_chunks_supported
                = m_do_not_send_content_length = false;
        m_remote_ip = asio::ip::address_v4(0);
        m_version_major = m_version_minor = 1;
        m_content_length = 0;
        m_content_buf.clear();
        m_chunk_cache.clear();
        m_headers.clear();
        m_cookie_params.clear();
        m_status = STATUS_NONE;
        m_has_missing_packets = false;
        m_has_data_after_missing = false;
    }

    virtual bool is_content_length_implied(void) const = 0;

    bool is_valid() const {
        return m_is_valid;
    }

    bool get_chunks_supported() const {
        return m_chunks_supported;
    }

    const asio::ip::address& get_remote_ip() const {
        return m_remote_ip;
    }

    uint16_t get_version_major() const {
        return m_version_major;
    }

    uint16_t get_version_minor() const {
        return m_version_minor;
    }

    std::string get_version_string() const {
        std::string http_version(STRING_HTTP_VERSION);
        http_version += sl::support::to_string(get_version_major());
        http_version += '.';
        http_version += sl::support::to_string(get_version_minor());
        return http_version;
    }

    size_t get_content_length() const {
        return m_content_length;
    }

    bool is_chunked(void) const {
        return m_is_chunked;
    }

    bool is_content_buffer_allocated() const {
        return !m_content_buf.is_empty();
    }
    
    std::size_t get_content_buffer_size() const {
        return m_content_buf.size();
    }

    char *get_content() {
        return m_content_buf.get();
    }

    const char *get_content() const {
        return m_content_buf.get();
    }

    std::vector<char>& get_chunk_cache() {
        return m_chunk_cache;
    }

    const std::string& get_header(const std::string& key) const {
        return get_value(m_headers, key);
    }

    bool has_header_value(const std::string& key, const std::string& value) const {
        auto range = m_headers.equal_range(key);
        for (auto it = range.first; it != range.second; ++it) {
            if (std::string::npos == it->second.find(',')) {
                if (sl::utils::iequals(value, it->second)) {
                    return true;
                }
            } else {
                auto vec = sl::utils::split(it->second, ',');
                for (auto& el : vec) {
                    auto trimmed = sl::utils::trim(el);
                    if (sl::utils::iequals(value, trimmed)) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    headers_type& get_headers() {
        return m_headers;
    }

    bool has_header(const std::string& key) const {
        return (m_headers.find(key) != m_headers.end());
    }

    const std::string& get_cookie(const std::string& key) const {
        return get_value(m_cookie_params, key);
    }
    
    headers_type& get_cookies() {
        return m_cookie_params;
    }

    bool has_cookie(const std::string& key) const {
        return (m_cookie_params.find(key) != m_cookie_params.end());
    }

    void add_cookie(const std::string& key, const std::string& value) {
        m_cookie_params.insert(std::make_pair(key, value));
    }

    void change_cookie(const std::string& key, const std::string& value) {
        change_value(m_cookie_params, key, value);
    }

    void delete_cookie(const std::string& key) {
        delete_value(m_cookie_params, key);
    }
    
    const std::string& get_first_line() const {
        if (m_first_line.empty()) {
            update_first_line();
        }
        return m_first_line;
    }

    bool has_missing_packets() const {
        return m_has_missing_packets;
    }

    void set_missing_packets(bool newVal) {
        m_has_missing_packets = newVal;
    }

    bool has_data_after_missing_packets() const {
        return m_has_data_after_missing;
    }

    void set_data_after_missing_packet(bool newVal) {
        m_has_data_after_missing = newVal;
    }

    void set_is_valid(bool b = true) {
        m_is_valid = b;
    }

    void set_chunks_supported(bool b) {
        m_chunks_supported = b;
    }

    void set_remote_ip(const asio::ip::address& ip) {
        m_remote_ip = ip;
    }

    void set_version_major(const uint16_t n) {
        m_version_major = n;
        clear_first_line();
    }

    void set_version_minor(const uint16_t n) {
        m_version_minor = n;
        clear_first_line();
    }

    void set_content_length(size_t n) {
        m_content_length = n;
    }

    void set_do_not_send_content_length() {
        m_do_not_send_content_length = true;
    }

    data_status_type get_status() const {
        return m_status;
    }

    void set_status(data_status_type newVal) {
        m_status = newVal;
    }

    void update_content_length_using_header() {
        auto i = m_headers.find(HEADER_CONTENT_LENGTH);
        if (i == m_headers.end()) {
            m_content_length = 0;
        } else {
            std::string trimmed_length(i->second);
            sl::utils::trim(trimmed_length);
            m_content_length = static_cast<size_t>(sl::utils::parse_uint64(trimmed_length));
        }
    }

    void update_transfer_encoding_using_header() {
        m_is_chunked = false;
        auto i = m_headers.find(HEADER_TRANSFER_ENCODING);
        if (i != m_headers.end()) {
            // From RFC 2616, sec 3.6: All transfer-coding values are case-insensitive.
            // comparing only lower and camel variants for simplicity
            if (std::string::npos != i->second.find("chunked") ||
                    std::string::npos != i->second.find("Chunked")) {
                m_is_chunked = true;
            } else {
                m_is_chunked = false;
            }
            // ignoring other possible values for now
        }
    }

    char *create_content_buffer() {
        m_content_buf.resize(m_content_length);
        return m_content_buf.get();
    }

    void set_content(const std::string& content) {
        set_content_length(content.size());
        create_content_buffer();
        memcpy(m_content_buf.get(), content.c_str(), content.size());
    }

    void clear_content() {
        set_content_length(0);
        create_content_buffer();
        delete_value(m_headers, HEADER_CONTENT_TYPE);
    }

    void set_content_type(const std::string& type) {
        change_value(m_headers, HEADER_CONTENT_TYPE, type);
    }

    void add_header(const std::string& key, const std::string& value) {
        m_headers.insert(std::make_pair(key, value));
    }

    void change_header(const std::string& key, const std::string& value) {
        change_value(m_headers, key, value);
    }

    void delete_header(const std::string& key) {
        delete_value(m_headers, key);
    }

    bool check_keep_alive() const {
        return (get_header(HEADER_CONNECTION) != "close"
                && (get_version_major() > 1
                || (get_version_major() >= 1 && get_version_minor() >= 1)));
    }

    void prepare_buffers_for_send(std::vector<asio::const_buffer>& write_buffers, const bool keep_alive,
            const bool using_chunks) {
        // update message headers
        prepare_headers_for_send(keep_alive, using_chunks);
        // add first message line
        write_buffers.push_back(asio::buffer(get_first_line()));
        write_buffers.push_back(asio::buffer(STRING_CRLF));
        // append cookie headers (if any)
        append_cookie_headers();
        // append HTTP headers
        append_headers(write_buffers);
    }

    void concatenate_chunks() {
        set_content_length(m_chunk_cache.size());
        char *post_buffer = create_content_buffer();
        if (m_chunk_cache.size() > 0) {
            std::memcpy(post_buffer, m_chunk_cache.data(), m_chunk_cache.size());
        }
    }

protected:

    std::string make_query_string(const std::unordered_multimap<std::string, std::string,
            algorithm::ihash, algorithm::iequal_to>& query_params) {
        std::string query_string;
        for (headers_type::const_iterator i = query_params.begin();
                i != query_params.end(); ++i) {
            if (i != query_params.begin()) {
                query_string += '&';
            }
            query_string += sl::utils::url_encode(i->first);
            query_string += '=';
            query_string += sl::utils::url_encode(i->second);
        }
        return query_string;
    }

    std::string make_set_cookie_header(const std::string& name, const std::string& value,
            const std::string& path, const bool has_max_age = false, const unsigned long max_age = 0) {
        // note: according to RFC6265, attributes should not be quoted
        std::string set_cookie_header(name);
        set_cookie_header += "=\"";
        set_cookie_header += value;
        set_cookie_header += "\"; Version=1";
        if (!path.empty()) {
            set_cookie_header += "; Path=";
            set_cookie_header += path;
        }
        if (has_max_age) {
            set_cookie_header += "; Max-Age=";
            set_cookie_header += sl::support::to_string(max_age);
        }
        return set_cookie_header;
    }

    void prepare_headers_for_send(const bool keep_alive, const bool using_chunks) {
        change_header(HEADER_CONNECTION, (keep_alive ? "Keep-Alive" : "close"));
        if (using_chunks) {
            if (get_chunks_supported()) {
                change_header(HEADER_TRANSFER_ENCODING, "chunked");
            }
        } else if (!m_do_not_send_content_length) {
            change_header(HEADER_CONTENT_LENGTH, sl::support::to_string(get_content_length()));
        }
    }

    void append_headers(std::vector<asio::const_buffer>& write_buffers) {
        // add HTTP headers
        for (headers_type::const_iterator i = m_headers.begin(); i != m_headers.end(); ++i) {
            write_buffers.push_back(asio::buffer(i->first));
            write_buffers.push_back(asio::buffer(HEADER_NAME_VALUE_DELIMITER));
            write_buffers.push_back(asio::buffer(i->second));
            write_buffers.push_back(asio::buffer(STRING_CRLF));
        }
        // add an extra CRLF to end HTTP headers
        write_buffers.push_back(asio::buffer(STRING_CRLF));
    }

    void append_cookie_headers() { }

    static const std::string& get_value(const headers_type& dict, const std::string& key) {
        auto i = dict.find(key);
        return ( (i==dict.end()) ? STRING_EMPTY : i->second );
    }

    inline static void change_value(headers_type& dict, const std::string& key, 
            const std::string& value) {
        // retrieve all current values for key
        auto result_pair = dict.equal_range(key);
        if (result_pair.first == dict.end()) {
            // no values exist -> add a new key
            dict.insert(std::make_pair(key, value));
        } else {
            // set the first value found for the key to the new one
            result_pair.first->second = value;
            // remove any remaining values
            headers_type::iterator i;
            ++(result_pair.first);
            while (result_pair.first != result_pair.second) {
                i = result_pair.first;
                ++(result_pair.first);
                dict.erase(i);
            }
        }
    }

    inline static void delete_value(headers_type& dict, const std::string& key) {
        auto result_pair = dict.equal_range(key);
        if (result_pair.first != dict.end()) {
            dict.erase(result_pair.first, result_pair.second);
        }
    }

    void clear_first_line() const {
        if (!m_first_line.empty()) {
            m_first_line.clear();
        }
    }

    virtual void update_first_line() const = 0;

};


} // namespace
}

#endif // STATICLIB_PION_HTTP_MESSAGE_HPP