http.h

Go to the documentation of this file.

 
#ifndef __CWIST_HTTP_H__
#define __CWIST_HTTP_H__
 
#include <cwist/core/sstring/sstring.h>
#include <cwist/sys/err/cwist_err.h>
#include <cwist/net/http/query.h>
#include <cwist/core/db/sql.h>
#include <cwist/sys/app/endpoint_opts.h>
#include <cwist/sys/app/big_dumb_reply.h>
#include <cwist/sys/io/reactor.h>
#include <stdint.h>
#include <cwist/sys/platform.h>
#ifndef CWIST_BAREMETAL
#include <netinet/in.h>
#include <sys/socket.h>
#else
struct sockaddr;
struct sockaddr_in;
#endif
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
 
long get_cpu_cores(void);
long get_optimal_thread_count(void);
 
struct cwist_app;
struct cwist_http_async_conn;
 
typedef enum cwist_http_method_t {
    CWIST_HTTP_GET,
    CWIST_HTTP_POST,
    CWIST_HTTP_PUT,
    CWIST_HTTP_DELETE,
    CWIST_HTTP_PATCH,
    CWIST_HTTP_HEAD,
    CWIST_HTTP_OPTIONS,
    CWIST_HTTP_CONNECT,
    CWIST_HTTP_UNKNOWN
} cwist_http_method_t;
 
typedef enum cwist_http_status_t {
    /* 1xx Informational */
    CWIST_HTTP_CONTINUE = 100,
    CWIST_HTTP_SWITCHING_PROTOCOLS = 101,
    CWIST_HTTP_PROCESSING = 102,
    CWIST_HTTP_EARLY_HINTS = 103,
    /* 2xx Success */
    CWIST_HTTP_OK = 200,
    CWIST_HTTP_CREATED = 201,
    CWIST_HTTP_ACCEPTED = 202,
    CWIST_HTTP_NON_AUTHORITATIVE_INFORMATION = 203,
    CWIST_HTTP_NO_CONTENT = 204,
    CWIST_HTTP_RESET_CONTENT = 205,
    CWIST_HTTP_PARTIAL_CONTENT = 206,
    CWIST_HTTP_MULTI_STATUS = 207,
    CWIST_HTTP_ALREADY_REPORTED = 208,
    CWIST_HTTP_IM_USED = 226,
    /* 3xx Redirection */
    CWIST_HTTP_MULTIPLE_CHOICES = 300,
    CWIST_HTTP_MOVED_PERMANENTLY = 301,
    CWIST_HTTP_FOUND = 302,
    CWIST_HTTP_SEE_OTHER = 303,
    CWIST_HTTP_NOT_MODIFIED = 304,
    CWIST_HTTP_USE_PROXY = 305,
    CWIST_HTTP_TEMPORARY_REDIRECT = 307,
    CWIST_HTTP_PERMANENT_REDIRECT = 308,
    /* 4xx Client Error */
    CWIST_HTTP_BAD_REQUEST = 400,
    CWIST_HTTP_UNAUTHORIZED = 401,
    CWIST_HTTP_PAYMENT_REQUIRED = 402,
    CWIST_HTTP_FORBIDDEN = 403,
    CWIST_HTTP_NOT_FOUND = 404,
    CWIST_HTTP_METHOD_NOT_ALLOWED = 405,
    CWIST_HTTP_NOT_ACCEPTABLE = 406,
    CWIST_HTTP_PROXY_AUTHENTICATION_REQUIRED = 407,
    CWIST_HTTP_REQUEST_TIMEOUT = 408,
    CWIST_HTTP_CONFLICT = 409,
    CWIST_HTTP_GONE = 410,
    CWIST_HTTP_LENGTH_REQUIRED = 411,
    CWIST_HTTP_PRECONDITION_FAILED = 412,
    CWIST_HTTP_CONTENT_TOO_LARGE = 413,
    CWIST_HTTP_PAYLOAD_TOO_LARGE = 413,
    CWIST_HTTP_URI_TOO_LONG = 414,
    CWIST_HTTP_UNSUPPORTED_MEDIA_TYPE = 415,
    CWIST_HTTP_RANGE_NOT_SATISFIABLE = 416,
    CWIST_HTTP_EXPECTATION_FAILED = 417,
    CWIST_HTTP_IM_A_TEAPOT = 418,
    CWIST_HTTP_MISDIRECTED_REQUEST = 421,
    CWIST_HTTP_UNPROCESSABLE_CONTENT = 422,
    CWIST_HTTP_LOCKED = 423,
    CWIST_HTTP_FAILED_DEPENDENCY = 424,
    CWIST_HTTP_TOO_EARLY = 425,
    CWIST_HTTP_UPGRADE_REQUIRED = 426,
    CWIST_HTTP_PRECONDITION_REQUIRED = 428,
    CWIST_HTTP_TOO_MANY_REQUESTS = 429,
    CWIST_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
    CWIST_HTTP_UNAVAILABLE_FOR_LEGAL_REASONS = 451,
    /* 5xx Server Error */
    CWIST_HTTP_INTERNAL_ERROR = 500,
    CWIST_HTTP_INTERNAL_SERVER_ERROR = 500,
    CWIST_HTTP_NOT_IMPLEMENTED = 501,
    CWIST_HTTP_BAD_GATEWAY = 502,
    CWIST_HTTP_SERVICE_UNAVAILABLE = 503,
    CWIST_HTTP_GATEWAY_TIMEOUT = 504,
    CWIST_HTTP_VERSION_NOT_SUPPORTED = 505,
    CWIST_HTTP_VARIANT_ALSO_NEGOTIATES = 506,
    CWIST_HTTP_INSUFFICIENT_STORAGE = 507,
    CWIST_HTTP_LOOP_DETECTED = 508,
    CWIST_HTTP_NOT_EXTENDED = 510,
    CWIST_HTTP_NETWORK_AUTHENTICATION_REQUIRED = 511
} cwist_http_status_t;
 
const char *cwist_http_status_reason(int status);
 
typedef enum cwist_http_parse_error_t {
    CWIST_HTTP_PARSE_OK = 0,          /* No error. */
    CWIST_HTTP_PARSE_EOF,             /* Orderly close / no data: close quietly. */
    CWIST_HTTP_PARSE_MALFORMED,       /* 400: bad request-line, Host rules, CL/TE rules. */
    CWIST_HTTP_PARSE_HEADER_OVERFLOW, /* 431: header block exceeds the read buffer. */
    CWIST_HTTP_PARSE_BODY_TOO_LARGE,  /* 413: Content-Length exceeds the body cap. */
    CWIST_HTTP_PARSE_TE_UNSUPPORTED,  /* 501: unsupported transfer coding. */
    CWIST_HTTP_PARSE_EXPECT_FAILED    /* 417: unsupported Expect value. */
} cwist_http_parse_error_t;
 
#define CWIST_HTTP_MAX_HEADER_SIZE (8 * 1024)
#define CWIST_HTTP_MAX_BODY_SIZE (10 * 1024 * 1024)
#define CWIST_HTTP_READ_BUFFER_SIZE (16 * 1024)
#define CWIST_HTTP_TIMEOUT_MS 30000
#define CWIST_HTTPS_HANDSHAKE_TIMEOUT_MS 45000  /* Total TLS handshake budget */
#define CWIST_HTTP_HEADERS_TIMEOUT_MS 120000 /* Total header read budget */
#define CWIST_HTTP_BODY_IDLE_TIMEOUT_MS 60000  /* Abort body read after this much silence */
#define CWIST_HTTP2_IDLE_TIMEOUT_MS 300000 /* Default h2 idle budget (env overridable) */
#define CWIST_HTTP_KEEP_ALIVE_TIMEOUT_SEC \
    15    /* Default keep-alive idle connection timeout in seconds */
 
typedef struct cwist_http_header_node {
    cwist_sstring *key;
    cwist_sstring *value;
    struct cwist_http_header_node *next;
    bool arena_owned;   
} cwist_http_header_node;
 
typedef struct cwist_http_request {
    cwist_http_method_t method;
    cwist_sstring *path;        
    cwist_sstring *query;       
    cwist_query_map *query_params; 
    cwist_query_map *path_params;  
    cwist_sstring *version;     
    cwist_http_header_node *headers;
    cwist_sstring *body;
    bool keep_alive;
    bool te_chunked_seen;  
    bool expect_100_seen;  
    int client_fd;
    struct cwist_app *app;  
    cwist_db *db;           
    bool upgraded;
    uint32_t stream_id;     
    void *private_data;     
    void *route_middleware_state; 
    size_t content_length;
    cwist_endpoint_opt_t endpoint_opts; 
    cwist_query_map *flash; 
    void *session;          
    char *csrf_token;       
    void *arena;            
    void *async_conn;       
    bool ws_async_handoff;  
    void *https_conn;       
    void *h2_queue;         
} cwist_http_request;
 
typedef void (*cwist_http_body_cleanup_fn)(const void *ptr, size_t len, void *ctx);
 
typedef struct cwist_http_response {
    cwist_sstring *version;     
    cwist_http_status_t status_code;
    cwist_sstring *status_text; 
    cwist_http_header_node *headers;
    cwist_sstring *body;
    cwist_endpoint_opt_t endpoint_opts; 
 
    bool is_ptr_body;        
    const void *ptr_body;    
    size_t ptr_body_len;     
    cwist_http_body_cleanup_fn ptr_body_cleanup; 
    void *ptr_body_cleanup_ctx; 
 
    bool use_file_stream;        
    int file_stream_fd;          
    size_t file_stream_len;      
    off_t file_stream_offset;    
    bool file_stream_auto_close; 
 
    bool stream_mode;          
    bool stream_ended;         
    bool stream_failed;        
    cwist_sstring *stream_buf; 
    size_t stream_flushed;     
    int (*stream_sink)(void *ctx, const char *data, size_t len); 
    void *stream_sink_ctx;
    bool stream_head_sent;     
 
    bool keep_alive;
 
    char *alt_svc;
 
    void *arena;            
    bool arena_borrowed;    
 
    bool deferred;          
    void *async;            
} cwist_http_response;
 
cwist_http_request *cwist_http_request_create(void);
void cwist_http_request_destroy(cwist_http_request *req);
cwist_http_request *cwist_http_parse_request(const char *raw_request);
cwist_http_request *cwist_http_parse_request_len(const char *buf, size_t len);
int cwist_http_response_serialize(cwist_http_response *res, char **out, size_t *out_len);
 
int cwist_http_response_stream_begin(cwist_http_response *res);
int cwist_http_response_stream_write(cwist_http_response *res, const char *data, size_t len);
int cwist_http_response_stream_end(cwist_http_response *res);
cwist_http_request *cwist_http_receive_request(int client_fd, char *read_buf, size_t buf_size,
                                               size_t *buf_len, cwist_http_parse_error_t *err_out);
void cwist_http_send_error_response(int fd, int status, const char *msg);
cwist_sstring *cwist_get_client_ip_from_fd(int fd);
 
void cwist_http_format_date(time_t t, char *buf, size_t len);
 
time_t cwist_http_parse_date(const char *str);
cwist_http_response *cwist_http_response_create(void);
cwist_http_response *cwist_http_response_create_in_arena(void *arena);
void cwist_http_response_destroy(cwist_http_response *res);
 
void cwist_http_response_set_body_ptr(cwist_http_response *res, const void *ptr, size_t len);
void cwist_http_response_set_body_ptr_managed(cwist_http_response *res, const void *ptr, size_t len,
                                              cwist_http_body_cleanup_fn cleanup, void *ctx);
void cwist_http_response_set_alt_svc(cwist_http_response *res, const char *alt_svc);
 
cwist_sstring *cwist_http_stringify_response(cwist_http_response *res);
cwist_error_t cwist_http_send_response(int client_fd, cwist_http_response *res);
cwist_error_t cwist_http_send_response_head(int client_fd, cwist_http_response *res);
bool cwist_tcp_cork_enabled(void);
size_t cwist_http_serialize_headers(cwist_http_response *res, char *buf, size_t buf_size);
cwist_error_t cwist_http_response_send_file(cwist_http_response *res, const char *file_path,
                                            const char *content_type_hint, size_t *out_size);
cwist_error_t cwist_http_header_add(cwist_http_header_node **head, const char *key,
                                    const char *value);
char *cwist_http_header_get(cwist_http_header_node *head, const char *key);
size_t cwist_http_header_remove(cwist_http_header_node **head, const char *key);
void cwist_http_header_free_all(cwist_http_header_node *head);
 
void cwist_http_response_add_security_headers(cwist_http_response *res);
 
void cwist_http_response_add_hsts(cwist_http_response *res);
const char *cwist_http_method_to_string(cwist_http_method_t method);
cwist_http_method_t cwist_http_string_to_method(const char *method_str);
cwist_http_method_t cwist_http_string_to_method_len(const char *str, size_t len);
int cwist_make_socket_ipv4(struct sockaddr_in *sockv4, const char *address, uint16_t port,
                           uint16_t backlog);
cwist_error_t cwist_accept_socket(int server_fd, struct sockaddr *sockv4,
                                  void (*handler_func)(int client_fd, void *ctx), void *ctx);
typedef struct cwist_server_config {
    bool use_forking;     
    bool use_threading;   
    bool use_epoll;       
} cwist_server_config;
 
cwist_error_t cwist_http_server_loop(int server_fd, cwist_server_config *config,
                                     void (*handler)(int, void *), void *ctx);
int headers_have_content_length(cwist_http_header_node *headers);
 
int cwist_http_pool_init(void);
int cwist_http_pool_init_mode(bool use_c1m);
void cwist_http_pool_limit_core(unsigned int limit);
void cwist_http_pool_submit(int client_fd, void (*handler)(int, void *), void *ctx);
bool cwist_http_pool_rearm_current(int client_fd, void (*handler)(int, void *), void *ctx);
void cwist_http_pool_destroy(void);
 
/* --- Event-driven (one-shot) connection path for the C1M reactor ---------
 * The classic pool handler parks a worker thread on each keep-alive
 * connection, capping concurrent connections at the thread count.  The async
 * path below never blocks on a read: the callback drains whatever arrived,
 * serves every complete request, and rearms the fd, so one thread can hold
 * hundreds of thousands of mostly-idle connections.
 *
 * Writes on the deferred-completion path are resumable: when a slow client
 * saturates the socket, cwist_http_async_send_response deep-copies the unsent
 * remainder and parks it on a one-shot POLLOUT slot instead of blocking the
 * reactor thread in a poll() wait.  Synchronous (non-deferred) responses
 * still use the bounded poll wait inside cwist_http_send_response
 * (CWIST_HTTP_TIMEOUT_MS). */
typedef enum {
    CWIST_ASYNC_CLOSE = 0,  /* Close fd and release the connection. */
    CWIST_ASYNC_REARM,      /* Keep the connection; wait for more reads. */
    CWIST_ASYNC_DETACH,     /* Handler took ownership of fd (h2c, upgrades). */
    CWIST_ASYNC_DEFER       /* Completion/continuation owns fd and conn; leave untouched. */
} cwist_async_action_t;
 
typedef cwist_async_action_t (*cwist_async_handler_t)(int fd, struct cwist_http_async_conn *conn);
 
typedef struct cwist_http_async_conn {
    int fd;
    void *user_ctx;                       /* Owning app context. */
    char *rbuf;                           /* Lazy recv stash; freed while empty. */
    size_t cap;
    size_t len;
    char *obuf; /* Coalesced output stash (C1M async batch); reused across turns. */
    size_t ocap;
    size_t olen;
    bool virgin; /* No bytes seen yet (h2c preface sniff). */
    bool expect_continue_sent; /* 100 Continue already emitted for the pending request. */
    uint32_t last_active_sec; /* Monotonic timestamp of last activity (for idle reaping). */
    uint32_t worker_id; /* Assigned worker thread index for load tracking. */
    cwist_reactor_t *reactor; /* Owning reactor (deferred-response completion target). */
    cwist_async_handler_t handler; /* Connection handler, reused for re-arm after a defer. */
    bool peer_eof; /* Read side closed; drain complete buffered requests. */
    /* RX receive path (Linux reactors only: a RECV SQE on an io_uring ring,
     * or the reactor's own recv() on an epoll one; unused elsewhere).
     * Wait-state discipline, all transitions on the
     * reactor owner thread: at most one of {RECV SQE in flight, one-shot
     * POLL armed} at any time, or NONE while buffered work is served.
     * While rx_recv_inflight is true the stash buffer must not move or be
     * consumed: the in-flight SQE references rbuf + len. */
    bool rx_recv_inflight; /* RECV SQE armed on the reactor ring. */
    bool rx_data_ready;    /* RECV completion already staged bytes into the stash. */
    /* Learned mode: set when an armed RECV completed -EAGAIN (the client
     * sends one request per idle period, so arming RECV first just burns an
     * SQE before the POLL fallback).  Cleared whenever a RECV stages bytes,
     * so pipelining clients keep the SQE path.  While set, waits go straight
     * to the legacy POLL, making the steady-state op count identical to the
     * legacy path for non-pipelining clients. */
    bool rx_prefers_poll;
    uint64_t rx_armed_ns;  /* Latency-probe arm timestamp of the in-flight RECV. */
    /* Env-gated kernel-arrival probe (CWIST_KERN_TS=1, Linux only, experiment
     * instrumentation for issue #153): monotonic time of the recvmsg that
     * last delivered request bytes. Paired with SCM_TIMESTAMPNS at fill time. */
    uint64_t kern_last_mono_ns;
    bool kern_valid;
    /* Last BDR hit on this connection: repeated routes skip the SipHash and
     * bucket walk via a content-compare (validated under the EBR epoch on
     * every use). Zero-initialized at connection setup. */
    cwist_bdr_cursor_t bdr_cursor;
    /* Hysteresis anchor for the idle stash shrink (CWIST_ASYNC_STASH_IDLE_SEC):
     * monotonic time the rbuf/obuf capacity was last grown. While requests
     * keep needing capacity the stash is never shrunk at re-arm; one idle
     * window after the last growth it converges to the small floor. */
    uint32_t stash_grown_sec;
} cwist_http_async_conn_t;
 
/* Re-arm a connection after a deferred response completed on the reactor
 * thread (keep-alive), reusing the same one-shot event slot model as
 * http_async_event_cb. Buffered bytes resume through a posted continuation,
 * not recursively inline. On failure the fd is closed and conn released. */
bool cwist_http_async_rearm(int client_fd, cwist_reactor_t *reactor, cwist_http_async_conn_t *conn);
/* Pipelined continuations dropped (and their connections closed) because the
 * reactor post queue was full. Monotonic; useful for shed-rate alerting. */
long cwist_http_continuation_shed_count(void);
/* Live C1M connections (accepted, not yet released). Shutdown drain polls
 * this for an early exit; also useful for metrics. */
long cwist_http_inflight_count(void);
 
/* Send a deferred completion's response on the reactor path without ever
 * blocking the reactor thread: speculative non-blocking write first; on a
 * partial write the unsent remainder is deep-copied into an owned buffer and
 * parked on a one-shot POLLOUT slot, which resumes the send and then re-arms
 * (keep_alive) or closes exactly like the synchronous completion.  File-stream
 * bodies keep the existing bounded-blocking send path.  Takes over rearm/close
 * of (client_fd, conn) in all outcomes. */
void cwist_http_async_send_response(int client_fd, cwist_http_response *res,
                                    cwist_reactor_t *reactor, cwist_http_async_conn_t *conn,
                                    bool keep_alive, bool head_only);
 
typedef enum {
    CWIST_ASYNC_SEND_KEEPALIVE = 0,
    CWIST_ASYNC_SEND_CLOSE,
    CWIST_ASYNC_SEND_DEFERRED
} cwist_async_send_status_t;
 
cwist_async_send_status_t cwist_http_send_response_async(int client_fd, cwist_http_response *res,
                                                         cwist_http_async_conn_t *conn,
                                                         bool keep_alive, bool head_only);
 
/* Response write coalescing on the cleartext C1M async batch path: responses
 * served within one reactor turn accumulate in conn->obuf (capped at
 * CWIST_HTTP_COALESCE_MAX bytes) and flush with a single speculative write
 * at the yield/rearm point; a partial flush hands the remainder to the
 * parked-write mechanism.  cwist_http_coalesce_flush_blocking drains the
 * stash through the bounded poll wait and is reserved for ordering-critical
 * points (deferred completions, file streams, 100 Continue, cap overflow).
 * cwist_http_send_response_coalesced mirrors cwist_http_send_response_async
 * but appends to the stash instead of writing to the fd. */
#define CWIST_HTTP_COALESCE_MAX (256 * 1024)
 
typedef enum {
    CWIST_COALESCE_FLUSH_DONE = 0, /* Stash fully written (or empty). */
    CWIST_COALESCE_FLUSH_PARKED, /* Remainder parked on POLLOUT; slot owns fd/conn. */
    CWIST_COALESCE_FLUSH_ERROR /* Fatal; caller closes. */
} cwist_coalesce_flush_status_t;
 
int cwist_http_coalesce_append(cwist_http_async_conn_t *conn, const void *data, size_t len);
cwist_coalesce_flush_status_t
cwist_http_coalesce_flush(int client_fd, cwist_http_async_conn_t *conn, bool keep_alive);
int cwist_http_coalesce_flush_blocking(int client_fd, cwist_http_async_conn_t *conn);
int cwist_http_coalesce_error_response(cwist_http_async_conn_t *conn, int status);
cwist_async_send_status_t cwist_http_send_response_coalesced(int client_fd,
                                                             cwist_http_response *res,
                                                             cwist_http_async_conn_t *conn,
                                                             bool keep_alive, bool head_only);
 
typedef enum {
    CWIST_RECV_OK = 0,
    CWIST_RECV_NEED_MORE, /* Partial request; rearm and wait. */
    CWIST_RECV_FATAL /* Protocol error / overflow; close. */
} cwist_recv_status_t;
 
bool cwist_http_pool_submit_async(int client_fd, cwist_async_handler_t handler, void *ctx);
/* Returns 0 on data/EAGAIN/EOF, -1 on fatal error. EOF sets peer_eof;
 * drain complete buffered requests, then close instead of waiting for input. */
int cwist_http_async_conn_fill(cwist_http_async_conn_t *conn);
cwist_recv_status_t cwist_http_receive_request_nb(cwist_http_async_conn_t *conn,
                                                  cwist_http_request **out,
                                                  cwist_http_parse_error_t *err_out);
 
extern const int CWIST_CREATE_SOCKET_FAILED;
extern const int CWIST_HTTP_UNAVAILABLE_ADDRESS;
extern const int CWIST_HTTP_BIND_FAILED;
extern const int CWIST_HTTP_SETSOCKOPT_FAILED;
extern const int CWIST_HTTP_LISTEN_FAILED;
 
#endif