http_filter.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_HTTP_HTTP_FILTER_HPP__
#define NEFORCE_NETWORK_HTTP_HTTP_FILTER_HPP__

 
#include "NeForce/core/async/mutex.hpp"
#include "NeForce/core/functional/function.hpp"
#include "NeForce/core/memory/unique_ptr.hpp"
#include "NeForce/core/time/duration.hpp"
#include "NeForce/core/utility/byte_size.hpp"
#include "NeForce/core/utility/optional.hpp"
#include "NeForce/network/http/http_server_message.hpp"
NEFORCE_BEGIN_NAMESPACE__
NEFORCE_BEGIN_HTTP__


class NEFORCE_API http_filter {
public:
    virtual ~http_filter() = default;

    virtual void do_filter(http_request& request, http_response& response) = 0;

    virtual bool pre_filter(http_request& request, http_response& response) { return true; }

    virtual void post_filter(http_request& request, http_response& response) {}

    NEFORCE_NODISCARD virtual string name() const { return "http_filter"; }
};

class NEFORCE_API http_filter_chain {
private:
    struct filter_entry {
        unique_ptr<http_filter> filter;
        bool owned = true;
    };
    vector<filter_entry> filters_; 
 
public:
    http_filter_chain() = default;
    ~http_filter_chain() { clear(); }
 
    http_filter_chain(const http_filter_chain&) = delete;
    http_filter_chain& operator=(const http_filter_chain&) = delete;
 
    http_filter_chain(http_filter_chain&&) noexcept = default;
    http_filter_chain& operator=(http_filter_chain&&) noexcept = default;

    void add_filter(unique_ptr<http_filter> filter);

    void add_filter_ref(http_filter* filter);

    void clear() noexcept;

    NEFORCE_NODISCARD size_t size() const noexcept { return filters_.size(); }

    NEFORCE_NODISCARD bool empty() const noexcept { return filters_.empty(); }

    bool execute_pre_filters(http_request& request, http_response& response);

    void execute_post_filters(http_request& request, http_response& response);

    void execute_pre_filters_async(http_request& request, http_response& response, http_context& ctx,
                                   function<void(bool)> next);

    void execute_post_filters_async(http_request& request, http_response& response, http_context& ctx,
                                    function<void()> next);

    void execute_filters(http_request& request, http_response& response);
};

class NEFORCE_API cors_filter final : public http_filter {
public:
    string allowed_origins;                                                   
    http_method allowed_methods{http_method::DEFAULT()};                      
    string allowed_headers{"Content-Type, Cookie, Accept, X-Requested-With"}; 
    bool allow_credentials = true;                                            
    seconds max_age{86400};                                                   
 
    cors_filter() = default;

    explicit cors_filter(string origins) :
    allowed_origins(_NEFORCE move(origins)) {}
 
    bool pre_filter(http_request& request, http_response& response) override;
    void do_filter(http_request& request, http_response& response) override {}
    NEFORCE_NODISCARD string name() const override { return "cors_filter"; }
};

class NEFORCE_API logging_filter final : public http_filter {
public:
    bool log_headers = false;          
    bool log_body = false;             
    byte_size max_body_log_size{1_KB}; 
 
    bool pre_filter(http_request& request, http_response& response) override;
    void post_filter(http_request& request, http_response& response) override;
    void do_filter(http_request& request, http_response& response) override {}
    NEFORCE_NODISCARD string name() const override { return "logging_filter"; }
};

class NEFORCE_API static_file_filter final : public http_filter {
private:
    string root_path_;                               
    unordered_map<string, http_content> mime_types_; 
    bool enable_cache_ = true;                       
    bool enable_range_ = true;                       
    byte_size max_file_size_{10_MB};                 
    string spa_fallback_path_;                       
    bool spa_fallback_enabled_ = false;              
    vector<string> spa_exclude_paths_;               
 
public:
    explicit static_file_filter(string root_path);
 
    bool pre_filter(http_request& request, http_response& response) override;
    void do_filter(http_request& request, http_response& response) override {}
    NEFORCE_NODISCARD string name() const override { return "static_file_filter"; }

    NEFORCE_NODISCARD static bool is_safe_path(const string& path);

    NEFORCE_NODISCARD optional<http_content> get_mime_type(const string& path) const;

    void add_mime_type(const string& extension, http_content content_type);

    void set_spa_fallback(string index_file);

    NEFORCE_NODISCARD const string& spa_fallback() const noexcept { return spa_fallback_path_; }

    NEFORCE_NODISCARD bool is_spa_fallback_enabled() const noexcept { return spa_fallback_enabled_; }

    void add_spa_exclude_path(string path_prefix);
 
    void set_enable_range(const bool enable) { enable_range_ = enable; }
    void set_enable_cache(const bool enable) { enable_cache_ = enable; }
    void set_max_file_size(byte_size size) { max_file_size_ = size; }
 
    // TODO: Pre-compressed resource support — serve .gz/.br variants when client Accept-Encoding matches, avoiding on-the-fly compression
    // TODO: Directory listing — optional HTML directory listing for paths without an index file (Apache-style auto-index)
};

class NEFORCE_API authentication_filter final : public http_filter {
private:
    vector<string> excluded_paths_;                      
    vector<string> included_paths_;                      
    function<bool(const http_request&)> auth_validator_; 
 
    NEFORCE_NODISCARD bool is_path_excluded(const string& path) const;
    NEFORCE_NODISCARD bool is_path_protected(const string& path) const;
 
public:
    authentication_filter() = default;

    explicit authentication_filter(function<bool(const http_request&)> validator) :
    auth_validator_(_NEFORCE move(validator)) {}

    void set_auth_validator(function<bool(const http_request&)> validator) {
        auth_validator_ = _NEFORCE move(validator);
    }

    void add_excluded_path(string path) { excluded_paths_.push_back(_NEFORCE move(path)); }

    void add_included_path(string path) { included_paths_.push_back(_NEFORCE move(path)); }

    void clear_excluded_paths() { excluded_paths_.clear(); }

    void clear_included_paths() { included_paths_.clear(); }
 
    bool pre_filter(http_request& request, http_response& response) override;
    void do_filter(http_request& request, http_response& response) override {}
    NEFORCE_NODISCARD string name() const override { return "authentication_filter"; }
 
    // TODO: Multi-scheme auth support — support Basic (base64 user:pass), Bearer (token), Digest (RFC 7616) in addition to custom validator
    // TODO: Auth challenge response — set WWW-Authenticate header with realm and scopes on 401 responses
};
 
// TODO: Request validation filter — declarative field validation (required, min/max length, regex pattern, numeric range) with JSON error response
// TODO: Server-side templating filter — render dynamic HTML using template engines (Jinja2-like, Mustache) with data injection from request context
 // HTTP
 
NEFORCE_END_HTTP__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_HTTP_HTTP_FILTER_HPP__