request.h

/*
Copyright (c) 2016 Alexei Novakov
https://github.com/novalexei

Distributed under the Boost Software License, Version 1.0.
http://boost.org/LICENSE_1_0.txt
*/
#ifndef SERVLET_REQUEST_H
#define SERVLET_REQUEST_H

#include <vector>
#include <memory>

#include <servlet/uri.h>
#include <servlet/cookie.h>
#include <servlet/session.h>
#include <servlet/ssl.h>
#include <servlet/lib/io.h>
#include <servlet/lib/io_filter.h>
#include <servlet/lib/logger.h>

namespace servlet
{

class multipart_input;

class http_request
{
public:
    virtual ~http_request() noexcept {}

    virtual tree_any_map& get_attributes() = 0;

    virtual const tree_any_map& get_attributes() const = 0;

    virtual const std::map<std::string, std::vector<std::string>, std::less<>>& get_parameters() = 0;

    virtual const std::map<string_view, string_view, std::less<>>& get_env() = 0;

    virtual bool is_secure() = 0;

    virtual std::shared_ptr<SSL_information> ssl_information() = 0;

    template<typename StringType>
    const optional_ref<const std::string> get_parameter(const StringType& name)
    {
        const std::map<std::string, std::vector<std::string>, std::less<>>& params = get_parameters();
        auto it = params.find(name);
        return it == params.end() || it->second.empty() ? optional_ref<const std::string>{} :
               optional_ref<const std::string>{it->second.front()};
    }

    template<typename StringType>
    const optional_ref<const std::vector<std::string>> get_parameters(const StringType& name)
    {
        const std::map<std::string, std::vector<std::string>, std::less<>>& params = get_parameters();
        auto it = params.find(name);
        return it == params.end() ? optional_ref<const std::vector<std::string>>{} :
               optional_ref<const std::vector<std::string>>{it->second};
    }


    virtual string_view get_auth_type() = 0;

    virtual const std::vector<cookie>& get_cookies() = 0;

    virtual string_view get_context_path() const = 0;

    virtual string_view get_servlet_path() const = 0;

    virtual const URI& get_request_uri() const = 0;

    virtual string_view get_path_info() const = 0;

    virtual string_view get_header(const std::string& name) const = 0;

    virtual long get_date_header(const std::string& name) const = 0;

    virtual string_view get_content_type() const = 0;

    virtual long get_content_length() const = 0;

    virtual void get_headers(const std::string& name, std::vector<std::string>& headers) const = 0;

    virtual void get_headers(std::vector<std::pair<std::string, std::string>>& headers) const = 0;

    virtual string_view get_method() const = 0;

    virtual string_view get_path_translated() const = 0;

    virtual string_view get_scheme() const = 0;

    virtual string_view get_protocol() const = 0;


    virtual string_view get_client_addr() const = 0;

    virtual string_view get_client_host() const = 0;

    virtual uint16_t    get_client_port() const = 0;

    virtual string_view get_remote_user() const = 0;

    virtual string_view get_local_addr() const = 0;

    virtual string_view get_local_host() const = 0;

    virtual uint16_t    get_local_port() const = 0;


    virtual string_view get_server_name() const = 0;

    virtual uint16_t    get_server_port() const = 0;

    virtual void forward(const std::string &redirectURI, bool from_context_path = true) = 0;

    virtual int include(const std::string &includeURI, bool from_context_path = true) = 0;

    virtual http_session &get_session() = 0;

    virtual bool has_session() = 0;

    virtual void invalidate_session() = 0;

    virtual std::istream& get_input_stream() = 0;

    virtual multipart_input& get_multipart_input() = 0;

    virtual bool is_multipart() const = 0;
};

class multipart_input
{
public:
    virtual ~multipart_input() noexcept = default;

    virtual const std::map<std::string, std::vector<std::string>, std::less<>>& get_headers() const = 0;

    template<typename StringType>
    optional_ref<const std::string> get_header(const StringType& name) const
    {
        const std::map<std::string, std::vector<std::string>, std::less<>>& headers = get_headers();
        auto it = headers.find(name);
        return it == headers.end() || it->second.empty() ? optional_ref<const std::string>{} :
               optional_ref<const std::string>{it->second.front()};
    }

    template<typename StringType>
    optional_ref<const std::vector<std::string>> get_headers(const StringType& name) const
    {
        const std::map<std::string, std::vector<std::string>, std::less<>>& headers = get_headers();
        auto it = headers.find(name);
        return it == headers.end() ? optional_ref<const std::vector<std::string>>{} :
               optional_ref<const std::vector<std::string>>{it->second};
    }

    optional_ref<const std::string> get_content_type() const { return get_header("Content-Type"); }

    optional_ref<const std::string> get_name() const { return get_header("name"); }

    optional_ref<const std::string> get_submitted_filename() const;

    virtual std::istream& get_input_stream() = 0;

    virtual bool to_next_part() = 0;
};

class http_request_wrapper : public http_request
{
public:
    http_request_wrapper(http_request& req) : _req{req} {}

    ~http_request_wrapper() noexcept override {}

    http_request& get_wrapped_request() { return _req; }
    const http_request& get_wrapped_request() const { return _req; }

    tree_any_map& get_attributes() override { return _req.get_attributes(); }
    const tree_any_map& get_attributes() const override { return _req.get_attributes(); }

    const std::map<std::string, std::vector<std::string>, std::less<>>& get_parameters() override
    { return _req.get_parameters(); }
    const std::map<string_view, string_view, std::less<>>& get_env() override { return _req.get_env(); };
    bool is_secure() override { return _req.is_secure(); }
    std::shared_ptr<SSL_information> ssl_information() override { return _req.ssl_information(); }

    string_view get_auth_type() override { return _req.get_auth_type(); }
    const std::vector<cookie>& get_cookies() override { return _req.get_cookies(); }
    string_view get_context_path() const override { return _req.get_context_path(); }
    string_view get_servlet_path() const override { return _req.get_servlet_path(); }
    const URI& get_request_uri() const override { return _req.get_request_uri(); }
    string_view get_path_info() const override { return _req.get_path_info(); }
    string_view get_header(const std::string& name) const override { return _req.get_header(name); }
    long get_date_header(const std::string& name) const override { return _req.get_date_header(name); }

    string_view get_content_type() const override { return _req.get_content_type(); }
    long get_content_length() const override { return _req.get_content_length(); }

    void get_headers(const std::string& name, std::vector<std::string>& headers) const override
    { return _req.get_headers(name, headers); }
    void get_headers(std::vector<std::pair<std::string, std::string>>& headers) const override
    { return _req.get_headers(headers); }

    string_view get_method() const override { return _req.get_method(); }

    string_view get_path_translated() const override { return _req.get_method(); }
    string_view get_scheme() const override { return _req.get_method(); }
    string_view get_protocol() const override { return _req.get_method(); }

    string_view get_client_addr() const override { return _req.get_client_addr(); }
    string_view get_client_host() const override { return _req.get_client_host(); }
    uint16_t    get_client_port() const override { return _req.get_client_port(); }
    string_view get_remote_user() const override { return _req.get_remote_user(); }

    string_view get_local_addr() const override { return _req.get_local_addr(); }
    string_view get_local_host() const override { return _req.get_local_host(); }
    uint16_t    get_local_port() const override { return _req.get_local_port(); }

    uint16_t    get_server_port() const override { return _req.get_server_port(); }
    string_view get_server_name() const override { return _req.get_server_name(); }

    void forward(const std::string &redirectURL, bool from_context_path = true) override
    { _req.forward(redirectURL, from_context_path); }
    int include(const std::string &includeURL, bool from_context_path = true) override
    { return _req.include(includeURL, from_context_path); }

    http_session &get_session() override { return _req.get_session(); }
    bool has_session() override { return _req.has_session(); }
    void invalidate_session() override { _req.invalidate_session(); }

    bool is_multipart() const override { return _req.is_multipart(); }

    std::istream& get_input_stream() override;
    multipart_input& get_multipart_input() override;

protected:

    virtual in_filter* filter() { return nullptr; }

private:
    http_request& _req;
    optional_ptr<std::istream> _in;
    optional_ptr<multipart_input> _multipart_in;
};

} // end of servlet namespace

#endif // SERVLET_REQUEST_H