public:

// PRD-NAM-REQ-004: explicit to forbid implicit conversion from

// create_webserver. Callers must direct-init: webserver ws{cw};

explicit webserver(const create_webserver& params);

/**

~webserver();

// PIMPL-owned: copy/move would slice the backing impl object.

webserver(const webserver&) = delete;

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

webserver(webserver&&) = delete;

webserver& operator=(webserver&&) = delete;

/**

bool start(bool blocking = false);

/**

bool stop();

/**

bool is_running();

// Registration, on_* shortcuts, route(), and unregister_* live in

// a sibling header to keep this class under the project per-file

// LOC ceiling. The inner gate forces the header to be included

// only from within this class body.

#define SRC_HTTPSERVER_WEBSERVER_HPP_INSIDE_CLASS_

#include "httpserver/webserver_routes.hpp"

#undef SRC_HTTPSERVER_WEBSERVER_HPP_INSIDE_CLASS_

/**

void block_ip(std::string_view ip);

/**

void unblock_ip(std::string_view ip);

/// Returns the configured access-log callback; null if none was set.

/// The callback may be invoked concurrently from MHD worker threads.

log_access_ptr get_access_logger() const {

return log_access;

}

/// Returns the configured error-log callback; null if none was set.

/// The callback may be invoked concurrently from MHD worker threads.

log_error_ptr get_error_logger() const {

return log_error;

}

/// Returns the configured request-validator callback; null if none was set.

/// The callback may be invoked concurrently from MHD worker threads.

validator_ptr get_request_validator() const {

return validator;

}

/// Returns the configured URL-unescaper callback; null if none was set.

/// The callback may be invoked concurrently from MHD worker threads.

unescaper_ptr get_unescaper() const {

return unescaper;

}

/**

void stop_and_wait();

/**

bool run();

/**

bool run_wait(int32_t millisec);

/**

bool get_fdset(fd_set* read_fd_set, fd_set* write_fd_set,

fd_set* except_fd_set, int* max_fd);

/**

bool get_timeout(uint64_t* timeout);

/**

bool add_connection(int client_socket, const struct sockaddr* addr, unsigned int addrlen);

/**

int quiesce();

/**

int get_listen_fd() const;

/**

unsigned int get_active_connections() const;

/**

uint16_t get_bound_port() const;

/**

struct features {

bool basic_auth;

bool digest_auth;

bool tls;

bool websocket;

};

static features features() noexcept;

// Websocket registration surface and lifecycle hook bus (TASK-045)

// live in sibling headers to keep this class under the project

// per-file LOC ceiling.

#define SRC_HTTPSERVER_WEBSERVER_HPP_INSIDE_CLASS_

#include "httpserver/webserver_websocket.hpp"

#include "httpserver/webserver_hooks.hpp"

#undef SRC_HTTPSERVER_WEBSERVER_HPP_INSIDE_CLASS_

private:

const uint16_t port;

http::http_utils::start_method_T start_method;

const int max_threads;

const int max_connections;

const int memory_limit;

const size_t content_size_limit;

const int connection_timeout;

const int per_IP_connection_limit;

log_access_ptr log_access;

log_error_ptr log_error;

validator_ptr validator;

unescaper_ptr unescaper;

const struct sockaddr* bind_address;

std::shared_ptr<struct sockaddr_storage> bind_address_storage;

const int max_thread_stack_size;

// 0 sentinel -> compile-time defaults

// (arguments_accumulator::DEFAULT_MAX_ARGS_COUNT / _BYTES).

// webserver_impl::connection_notify copies these into the per-

// connection_state at MHD_CONNECTION_NOTIFY_STARTED; populate_args

// reads them from connection_state via the socket_context.

const std::size_t max_args_count;

const std::size_t max_args_bytes;

const bool use_ssl;

const bool use_ipv6;

const bool use_dual_stack;

const bool debug;

const bool pedantic;

// TASK-055 / DR-009 Revision 1: when true, the default

// internal_error_page surfaces the originating exception message in

// the 500 body (development-only behaviour; CWE-209). Default is

// false: the body is the fixed string "Internal Server Error".

const bool expose_exception_messages;

// TASK-057: when true, http_request::operator<< streams credential

// material verbatim (v1 verbose form; development-only behaviour;

// CWE-312 / CWE-532). Default is false: the four credential

// surfaces are replaced by the fixed token "<redacted>".

const bool expose_credentials_in_logs;

const std::string https_mem_key;

const std::string https_mem_cert;

const std::string https_mem_trust;

const std::string https_priorities;

const http::http_utils::cred_type_T cred_type;

const psk_cred_handler_callback psk_cred_handler;

const std::string digest_auth_random;

const int nonce_nc_size;

const http::http_utils::policy_T default_policy;

// TASK-034: stored unconditionally. webserver(create_webserver const&)

// throws feature_unavailable when this is true but HAVE_BAUTH is off.

const bool basic_auth_enabled;

const bool digest_auth_enabled;

const bool regex_checking;

const bool ban_system_enabled;

const bool post_process_enabled;

const bool put_processed_data_to_content;

const file_upload_target_T file_upload_target;

const std::string file_upload_dir;

const bool generate_random_filename_on_upload;

const bool deferred_enabled;

const bool single_resource;

const bool tcp_nodelay;

const error_handler not_found_handler;

const error_handler method_not_allowed_handler;

const internal_error_handler_t internal_error_handler;

const file_cleanup_callback_ptr file_cleanup_callback;

const auth_handler_ptr auth_handler;

const std::vector<std::string> auth_skip_paths;

// TASK-058 step 2: pre-normalized form of @ref auth_skip_paths,

// populated once at construction. webserver_impl::should_skip_auth

// compares request paths against this list (not @ref auth_skip_paths)

// so non-canonical entries like "/public/" or "/a/../b" match the

// canonical request path the dispatch surface produces. Built by

// detail::normalize_auth_skip_paths in webserver_request.cpp.

const std::vector<std::string> auth_skip_paths_normalized;

const sni_callback_t sni_callback;

const bool no_listen_socket;

const bool no_thread_safety;

const bool turbo;

const bool suppress_date_header;

const int listen_backlog;

const int address_reuse;

const size_t connection_memory_increment;

const int tcp_fastopen_queue_size;

const bool sigpipe_handled_by_app;

const std::string https_mem_dhparams;

const std::string https_key_password;

const std::string https_priorities_append;

const bool no_alpn;

const int client_discipline_level;

// Shared registration helper. Both register_path and register_prefix

// funnel through here so the validation/insertion logic lives in one

// place. `family=true` is prefix-matching; `family=false` is

// exact-matching.

void register_impl_(const std::string& path,

std::shared_ptr<http_resource> res,

bool family);

// register_impl_ helpers carved out so the parent stays under the

// project-wide CCN gate.

void validate_register_inputs_(const std::string& path,

const std::shared_ptr<http_resource>& res,

bool family) const;

// Shared unregistration helper. Erases a single registration of the

// requested kind.

void unregister_impl_(const std::string& path, bool family);

// TASK-025/TASK-026: shared lambda-registration helper. Builds-or-

// merges a hidden detail::lambda_resource shim at @p path, sets every

// bit in @p methods on it, and stores @p handler into each of those

// method slots. All seven public on_* overloads and both public

// route() overloads forward to this single entry point so the

// merge-and-conflict logic lives in one place. Validation is

// atomic: if any requested method already has a slot on the path,

// no slot is mutated and the call throws -- callers therefore see

// either a fully-installed registration or no change at all.

// Throws std::invalid_argument if @p methods is empty, if @p

// handler is empty, if the path conflicts with single_resource

// mode, if a class-based resource is already registered at the

// path, or if a lambda is already registered for any requested

// (method, path).

void on_methods_(method_set methods,

const std::string& path,

std::function<http_response(const http_request&)> handler);

// on_methods_ helpers carved out so the parent stays under the

// project-wide CCN gate.

void validate_on_methods_inputs_(method_set methods,

const std::string& path,

const std::function<http_response(const http_request&)>& handler) const;

// PIMPL: backend-coupled state (MHD daemon, pthread mutexes, route

// table, ban set, route cache, websocket registry, GnuTLS SNI cache,

// and the dispatch helpers / MHD trampolines that operate on those)

// lives behind this pointer in detail/webserver_impl.hpp. The public

// header carries no <microhttpd.h>/<pthread.h>/<gnutls/...> baggage.

std::unique_ptr<detail::webserver_impl> impl_;

// detail::webserver_impl reads the const config bag above (tcp_nodelay,

// unescaper, regex_checking, auth_handler, etc.) when servicing

// requests, and houses the MHD trampolines / dispatch helpers so

// <microhttpd.h> stays out of this public header. Granting friendship

// is preferable to introducing a long list of trivial public getters

// that cross the PIMPL boundary in both directions.

friend class detail::webserver_impl;

friend class http_response;

#if defined(HTTPSERVER_COMPILATION)

// TASK-027: test-only hook so unit tests in test/unit/ can poke

// at the v2 route-table impl (lookup_v2, the three tier maps)

// without widening the public API. The pattern matches the SBO

// test access friend used by http_response. Gated on

// HTTPSERVER_COMPILATION so it never appears in installed headers.

friend struct webserver_test_access;

#endif

static detail::webserver_impl* impl(webserver& w) noexcept {

return w.impl_.get();

}