http_request.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_REQUEST_HPP
#define STATICLIB_PION_HTTP_REQUEST_HPP

#include <functional>
#include <string>

#include "staticlib/config.hpp"

#include "staticlib/pion/http_message.hpp"
#include "staticlib/pion/http_parser.hpp"

namespace staticlib { 
namespace pion {

class http_request : public http_message {

    std::string m_method;

    std::string m_resource;

    std::string m_original_resource;

    std::string m_query_string;

    std::unordered_multimap<std::string, std::string, algorithm::ihash, algorithm::iequal_to> m_query_params;

    http_parser::payload_handler_type m_payload_handler;

    http_parser* m_request_reader;    

public:

    http_request() :
    m_method(REQUEST_METHOD_GET) { }

    http_request(const http_request&) = delete;

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

    virtual ~http_request() STATICLIB_NOEXCEPT { }

    virtual void clear() {
        http_message::clear();
        m_method.erase();
        m_resource.erase();
        m_original_resource.erase();
        m_query_string.erase();
        m_query_params.clear();
    }

    virtual bool is_content_length_implied() const {
        return false;
    }

    const std::string& get_method() const {
        return m_method;
    }

    const std::string& get_resource() const {
        return m_resource;
    }

    const std::string& get_original_resource() const {
        return m_original_resource;
    }

    const std::string& get_query_string() const {
        return m_query_string;
    }

    const std::string& get_query(const std::string& key) const {
        return get_value(m_query_params, key);
    }

    std::unordered_multimap<std::string, std::string, algorithm::ihash, algorithm::iequal_to>& get_queries() {
        return m_query_params;
    }

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

    void set_method(const std::string& str) {
        m_method = str;
        clear_first_line();
    }

    void set_resource(const std::string& str) {
        m_resource = m_original_resource = str;
        clear_first_line();
    }

    void change_resource(const std::string& str) {
        m_resource = str;
    }

    void set_query_string(const std::string& str) {
        m_query_string = str;
        clear_first_line();
    }

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

    void change_query(const std::string& key, const std::string& value) {
        change_value(m_query_params, key, value);
    }

    void delete_query(const std::string& key) {
        delete_value(m_query_params, key);
    }

    void use_query_params_for_query_string() {
        set_query_string(make_query_string(m_query_params));
    }

    void use_query_params_for_post_content() {
        std::string post_content(make_query_string(m_query_params));
        set_content_length(post_content.size());
        char *ptr = create_content_buffer(); // null-terminates buffer
        if (!post_content.empty()) {
            memcpy(ptr, post_content.c_str(), post_content.size());
        }
        set_method(REQUEST_METHOD_POST);
        set_content_type(CONTENT_TYPE_URLENCODED);
    }

    void set_content(const std::string &value) {
        set_content_length(value.size());
        char *ptr = create_content_buffer();
        if (!value.empty()) {
            memcpy(ptr, value.c_str(), value.size());
        }
    }

    void set_content(const char* value, size_t size){
        if (nullptr == value || 0 == size) return;
        set_content_length(size);
        char *ptr = create_content_buffer();
        std::memcpy(ptr, value, size);
    }

    void set_payload_handler(http_parser::payload_handler_type ph) {
        m_payload_handler = std::move(ph);
        // this should be done only once during request processing
        // and we won't restrict request_reader lifecycle after 
        // payload is processed, so we drop the pointer to it
        if (m_request_reader) {
            // request will always outlive reader
            m_request_reader->set_payload_handler(m_payload_handler);
            m_request_reader = nullptr;
        }
    }

    template<typename T>
    T* get_payload_handler() {
        return m_payload_handler.target<T>();
    }

    http_parser::payload_handler_type& get_payload_handler_wrapper() {
        return m_payload_handler;
    }
    
    void set_request_reader(http_parser* rr) {
        m_request_reader = rr;
    }

protected:

    virtual void update_first_line() const {
        // start out with the request method
        m_first_line = m_method;
        m_first_line += ' ';
        // append the resource requested
        m_first_line += m_resource;
        if (!m_query_string.empty()) {
            // append query string if not empty
            m_first_line += '?';
            m_first_line += m_query_string;
        }
        m_first_line += ' ';
        // append HTTP version
        m_first_line += get_version_string();
    }

    virtual void append_cookie_headers() {
        for (std::unordered_multimap<std::string, std::string, algorithm::ihash, algorithm::iequal_to>::const_iterator i = get_cookies().begin(); i != get_cookies().end(); ++i) {
            std::string cookie_header;
            cookie_header = i->first;
            cookie_header += COOKIE_NAME_VALUE_DELIMITER;
            cookie_header += i->second;
            add_header(HEADER_COOKIE, cookie_header);
        }
    }

};

using http_request_ptr = std::unique_ptr<http_request>;


} // namespace
}

#endif // STATICLIB_PION_HTTP_REQUEST_HPP