http.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022 Geoff Simmons <geoff@simmons.de>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 * See LICENSE
 */
 
#ifndef _PICOW_HTTP_H
#define _PICOW_HTTP_H
 
#include <string.h>
 
#include "lwip/ip_addr.h"
#include "lwip/prot/iana.h"
#include "lwip/err.h"
 
#include "assertion.h"
#include "log.h"
#include "ntp.h"
#include "version.h"
 
/*
 * Declarations required *before* including http_priv.h.
 */
 
#ifndef HTTP_REQ_MAX_HDRS
#define HTTP_REQ_MAX_HDRS (16)
#endif
 
struct http;
 
typedef err_t (*hndlr_f)(struct http *http, void *priv);
 
enum http_method_t {
    HTTP_METHOD_GET = 0,    
    HTTP_METHOD_HEAD,   
    HTTP_METHOD_POST,   
    HTTP_METHOD_PUT,    
    HTTP_METHOD_DELETE, 
    HTTP_METHOD_CONNECT,    
    HTTP_METHOD_OPTIONS,    
    HTTP_METHOD_TRACE,  
    __HTTP_METHOD_MAX,  
};
 
#define HTTP_METHODS_GET_HEAD \
    ((1U << HTTP_METHOD_GET) | (1U << HTTP_METHOD_HEAD))
 
typedef void priv_fini_f(void *p);
 
#include "http_priv.h"
 
static inline void
http_cx_set_priv(struct http *http, void *priv, priv_fini_f *fini)
{
    CHECK_OBJ_NOTNULL(http, HTTP_MAGIC);
    http->cx_priv.priv = priv;
    http->cx_priv.fini = fini;
}
 
static inline void *
http_cx_priv(struct http *http)
{
    CHECK_OBJ_NOTNULL(http, HTTP_MAGIC);
    return http->cx_priv.priv;
}
 
enum http_status_t {
    HTTP_STATUS_CONTINUE            = 100,
    HTTP_STATUS_SWITCHING_PROTOCOLS     = 101,
    HTTP_STATUS_OK              = 200,
    HTTP_STATUS_CREATED         = 201,
    HTTP_STATUS_ACCEPTED            = 202,
    HTTP_STATUS_NON_AUTHORITATIVE_INFO  = 203,
    HTTP_STATUS_NO_CONTENT          = 204,
    HTTP_STATUS_RESET_CONTENT       = 205,
    HTTP_STATUS_PARTIAL_CONTENT     = 206,
    HTTP_STATUS_MULTIPLE_CHOICES        = 300,
    HTTP_STATUS_MOVED_PERMANENTLY       = 301,
    HTTP_STATUS_FOUND           = 302,
    HTTP_STATUS_SEE_OTHER           = 303,
    HTTP_STATUS_NOT_MODIFIED        = 304,
    HTTP_STATUS_USE_PROXY           = 305,
    HTTP_STATUS_TEMPORARY_REDIRECT      = 307,
    HTTP_STATUS_PERMANENT_REDIRECT      = 308,
    HTTP_STATUS_BAD_REQUEST         = 400,
    HTTP_STATUS_UNAUTHORIZED        = 401,
    HTTP_STATUS_PAYMENT_REQUIRED        = 402,
    HTTP_STATUS_FORBIDDEN           = 403,
    HTTP_STATUS_NOT_FOUND           = 404,
    HTTP_STATUS_METHOD_NOT_ALLOWED      = 405,
    HTTP_STATUS_NOT_ACCEPTABLE      = 406,
    HTTP_STATUS_PROXY_AUTH_REQUIRED     = 407,
    HTTP_STATUS_REQUEST_TIMEOUT     = 408,
    HTTP_STATUS_CONFLICT            = 409,
    HTTP_STATUS_GONE            = 410,
    HTTP_STATUS_LENGTH_REQUIRED     = 411,
    HTTP_STATUS_PRECONDITION_FAILED     = 412,
    HTTP_STATUS_CONTENT_TOO_LARGE       = 413,
    HTTP_STATUS_URI_TOO_LONG        = 414,
    HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE  = 415,
    HTTP_STATUS_RANGE_NOT_SATISFIABLE   = 416,
    HTTP_STATUS_EXPECTATION_FAILED      = 417,
    HTTP_STATUS_IM_A_TEAPOT         = 418,
    HTTP_STATUS_MISDIRECTED_REQUEST     = 421,
    HTTP_STATUS_UNPROCESSABLE_CONTENT   = 422,
    HTTP_STATUS_UPGRADE_REQUIRED        = 426,
    HTTP_STATUS_REQ_HDR_FIELDS_TOO_LARGE    = 431,
    HTTP_STATUS_INTERNAL_SERVER_ERROR   = 500,
    HTTP_STATUS_NOT_IMPLEMENTED     = 501,
    HTTP_STATUS_BAD_GATEWAY         = 502,
    HTTP_STATUS_SERVICE_UNAVAILABLE     = 503,
    HTTP_STATUS_GATEWAY_TIMEOUT     = 504,
    HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED  = 505,
};
 
#ifndef HTTP_DEFAULT_IDLE_TMO_S
#define HTTP_DEFAULT_IDLE_TMO_S (5)
#endif
 
#ifndef HTTP_DEFAULT_SEND_TMO_S
#define HTTP_DEFAULT_SEND_TMO_S (5)
#endif
 
#ifndef HTTP_DEFAULT_LISTEN_BACKLOG
#define HTTP_DEFAULT_LISTEN_BACKLOG (10)
#endif
 
#define STRLEN_LTRL(s) (sizeof(s) - 1)
 
struct req;
 
struct resp;
 
struct server_cfg {
    struct ntp_cfg      ntp_cfg;
    const ip_addr_t     *ipaddr;
    struct srv_data     *srv_data;
    unsigned        idle_tmo_s;
    unsigned        send_tmo_s;
    uint16_t        port;
    uint8_t         listen_backlog;
    enum lwip_ip_addr_type  ip_type;
    bool            tls;
};
 
struct server;
 
err_t http_cfg(const char *name, struct server_cfg *cfg);
 
static inline struct server_cfg
http_default_cfg(void)
{
    err_t err;
    struct server_cfg cfg;
 
    err = http_cfg("default", &cfg);
    PICOW_HTTP_ASSERT(err == ERR_OK);
    return cfg;
}
 
err_t http_srv_init(struct server **server, struct server_cfg *cfg);
 
err_t http_srv_fini(struct server *server);
 
ip_addr_t * http_srv_ip(struct server *server);
 
uint16_t http_srv_port(struct server *server);
 
void http_srv_set_priv(struct server *server, void *priv, priv_fini_f *fini);
 
static inline ip_addr_t *
http_cx_local_ip(struct http *http)
{
    CHECK_OBJ_NOTNULL(http, HTTP_MAGIC);
    AN(http->pcb);
    return http_local_ip(http->pcb);
}
 
static inline uint16_t
http_cx_local_port(struct http *http)
{
    CHECK_OBJ_NOTNULL(http, HTTP_MAGIC);
    AN(http->pcb);
    return http_local_port(http->pcb);
}
 
static inline ip_addr_t *
http_cx_remote_ip(struct http *http)
{
    CHECK_OBJ_NOTNULL(http, HTTP_MAGIC);
    AN(http->pcb);
    return http_remote_ip(http->pcb);
}
 
static inline uint16_t
http_cx_remote_port(struct http *http)
{
    CHECK_OBJ_NOTNULL(http, HTTP_MAGIC);
    AN(http->pcb);
    return http_remote_port(http->pcb);
}
 
static inline void *
http_srv_priv(struct http *http)
{
    CHECK_OBJ_NOTNULL(http, HTTP_MAGIC);
    CHECK_OBJ_NOTNULL(http->srv_data, SRV_DATA_MAGIC);
    return http->srv_data->srv_priv;
}
 
static inline struct req *
http_req(struct http *http)
{
    CHECK_OBJ_NOTNULL(http, HTTP_MAGIC);
    CHECK_OBJ_NOTNULL(&http->req, REQ_MAGIC);
    return &http->req;
}
 
const char * http_req_hdr(struct req *req, const char *name, size_t name_len,
              size_t *val_len);
 
static inline const char *
http_req_hdr_str(struct req *req, const char *name, size_t *val_len)
{
    return http_req_hdr(req, name, strlen(name), val_len);
}
 
#define http_req_hdr_ltrl(req, name, val_len)           \
    http_req_hdr((req), (name), STRLEN_LTRL(name), (val_len))
 
bool http_req_hdr_eq(struct req *req, const char *name, size_t name_len,
             const char *val, size_t val_len);
 
bool http_req_hdr_contains(struct req *req, const char *name, size_t name_len,
               const char *substring, size_t substring_len);
 
static inline bool
http_req_hdr_eq_str(struct req *req, const char *name, const char *val)
{
    return http_req_hdr_eq(req, name, strlen(name), val, strlen(val));
}
 
static inline bool
http_req_hdr_contains_str(struct req *req, const char *name,
              const char *substring)
{
    return http_req_hdr_contains(req, name, strlen(name), substring,
                     strlen(substring));
}
 
#define http_req_hdr_eq_ltrl(req, name, val)                \
    http_req_hdr_eq((req), (name), STRLEN_LTRL(name), (val),    \
            STRLEN_LTRL(val))
 
#define http_req_hdr_contains_ltrl(req, name, substring)        \
    http_req_hdr_contains((req), (name), STRLEN_LTRL(name), (substring), \
                  STRLEN_LTRL(substring))
 
typedef err_t (*name_val_iter_f)(const char *name, size_t name_len,
                 const char *val, size_t val_len, void *priv);
 
err_t http_req_hdr_iter(struct req *req, name_val_iter_f iter_cb, void *priv);
 
const uint8_t * http_req_cookie(struct req *req, const char *name,
                size_t name_len, size_t *val_len);
 
static inline const uint8_t *
http_req_cookie_str(struct req *req, const char *name, size_t *val_len)
{
    return http_req_cookie(req, name, strlen(name), val_len);
}
 
#define http_req_cookie_ltrl(req, name, val_len) \
    http_req_cookie((req), (name), STRLEN_LTRL(name), (val_len))
 
err_t http_req_cookie_iter(struct req *req, name_val_iter_f iter_cb,
               void *priv);
 
static inline enum http_method_t
http_req_method(struct req *req)
{
    CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
    return req->method;
}
 
static inline const uint8_t *
http_req_path(struct req *req, size_t *len)
{
    CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
    AN(len);
 
    *len = req->path.len;
    return req->p->payload + req->path.off;
}
 
static inline const uint8_t *
http_req_query(struct req *req, size_t *len)
{
    CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
    AN(len);
 
    *len = req->query.len;
    if (req->query.len == 0)
        return NULL;
    return req->p->payload + req->query.off;
}
 
const uint8_t * http_req_query_val(const uint8_t *query, size_t query_len,
                   const uint8_t *name, size_t name_len,
                   size_t *val_len);
 
err_t http_req_query_iter(const uint8_t *query, size_t len,
              name_val_iter_f iter_cb, void *priv);
 
static inline size_t
http_req_body_len(struct req *req)
{
    CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
    return req->clen;
}
 
err_t http_req_body(struct http *http, uint8_t buf[], size_t *len, size_t off);
 
err_t http_req_body_ptr(struct http *http, const uint8_t **buf, size_t *len,
            size_t off);
 
err_t http_req_chunk(struct http *http, uint8_t *buf, size_t *len);
 
static inline struct resp *
http_resp(struct http *http)
{
    CHECK_OBJ_NOTNULL(http, HTTP_MAGIC);
    CHECK_OBJ_NOTNULL(&http->resp, RESP_MAGIC);
    return &http->resp;
}
 
static inline err_t
http_resp_set_status(struct resp *resp, uint16_t status)
{
    CHECK_OBJ_NOTNULL(resp, RESP_MAGIC);
    if (status < 100 || status >= 1000)
        return ERR_VAL;
    resp->status = status;
    return ERR_OK;
}
 
static inline uint16_t
http_resp_status(struct resp *resp)
{
    CHECK_OBJ_NOTNULL(resp, RESP_MAGIC);
    return resp->status;
}
 
#ifndef RESP_HDR_SMALL_BUF_SZ
#define RESP_HDR_SMALL_BUF_SZ (512)
#endif
 
#ifndef RESP_HDR_LARGE_BUF_SZ
#define RESP_HDR_LARGE_BUF_SZ (TCP_MSS)
#endif
 
#ifdef __DOXYGEN__
#define RESP_HDR_SMALL_POOL_SZ (MAX_CONCURRENT_CX_HINT)
#endif
 
#ifndef RESP_HDR_SMALL_POOL_SZ
#define RESP_HDR_SMALL_POOL_SZ (HTTP_N * SRV_N)
#endif
 
#ifndef RESP_HDR_LARGE_POOL_SZ
#define RESP_HDR_LARGE_POOL_SZ (RESP_HDR_SMALL_POOL_SZ / 2)
#endif
 
err_t http_resp_set_hdr(struct resp *resp, const char *name, size_t name_len,
            const char *val, size_t val_len);
 
static inline err_t
http_resp_set_hdr_str(struct resp *resp, const char *name, const char *val)
{
    return http_resp_set_hdr(resp, name, strlen(name), val, strlen(val));
}
 
#define http_resp_set_hdr_ltrl(resp, name, val)             \
    http_resp_set_hdr((resp), (name), STRLEN_LTRL(name), (val), \
              STRLEN_LTRL(val))
 
static inline err_t
http_resp_set_type(struct resp *resp, const char *type, size_t type_len)
{
    return http_resp_set_hdr(resp, "Content-Type",
                 STRLEN_LTRL("Content-Type"), type, type_len);
}
 
static inline err_t
http_resp_set_type_str(struct resp *resp, const char *type)
{
    return http_resp_set_type(resp, type, strlen(type));
}
 
#define http_resp_set_type_ltrl(resp, type) \
    http_resp_set_type((resp), (type), STRLEN_LTRL(type))
 
err_t http_resp_set_len(struct resp *resp, size_t len);
 
static inline err_t
http_resp_set_xfer_chunked(struct resp *resp)
{
    CHECK_OBJ_NOTNULL(resp, RESP_MAGIC);
    return http_resp_set_hdr_ltrl(resp, "Transfer-Encoding", "chunked");
}
 
err_t http_resp_send_hdr(struct http *http);
 
err_t http_resp_send_buf(struct http *http, const uint8_t *buf, size_t len,
             bool durable);
 
err_t http_resp_send_chunk(struct http *http, const uint8_t *buf, size_t len,
               bool durable);
 
static inline err_t
http_resp_err(struct http *http, uint16_t status)
{
    CHECK_OBJ_NOTNULL(http, HTTP_MAGIC);
    CHECK_OBJ_NOTNULL(&http->resp, RESP_MAGIC);
 
    http->resp.status = status;
    return http_hndlr_err(http, NULL);
}
 
err_t register_hndlr_methods(struct server_cfg *cfg, const char *path,
                 hndlr_f hndlr, uint8_t methods, void *priv);
 
static inline err_t
register_hndlr(struct server_cfg *cfg, const char *path, hndlr_f hndlr,
           enum http_method_t method, void *priv)
{
    if (method < 0 || method >= __HTTP_METHOD_MAX)
        return ERR_VAL;
    return register_hndlr_methods(cfg, path, hndlr, (1U << method), priv);
}
 
err_t register_default_hndlr(struct server_cfg *cfg, hndlr_f hndlr, void *priv,
                 priv_fini_f fini);
 
err_t register_error_hndlr(struct server_cfg *cfg, hndlr_f hndlr, void *priv,
               priv_fini_f fini);
 
err_t format_decimal(char *s, size_t *len, int32_t n);
 
err_t format_hex(char *s, size_t *len, uint32_t n, bool upper);
 
err_t url_decode(char * restrict const out, size_t *outlen,
         const char * restrict const in, ssize_t inlen, bool plus);
 
err_t hex_decode(const char * const buf, ssize_t len, uint64_t *n);
 
static inline uint32_t
ilog2(uint32_t n)
{
    AN(n);
    return 31 - __builtin_clz(n);
}
 
static inline uint32_t
ilog10(uint32_t n)
{
    /*
     * Algorithm from Hacker's Delight ch. 11-4, figures 11-12 and 11-13.
     * See also Daniel Lemire's blog at:
     * https://lemire.me/blog/2021/05/28/computing-the-number-of-digits-of-an-integer-quickly/
     */
    static const uint32_t nines[] = {
        9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999,
    };
    /* Multiplication by 9/32 roughly approximates division by log2(10). */
    uint32_t x = __fast_mul(ilog2(n), 9) >> 5;
    /* Fix any off-by-one error. */
    return x + bool_to_bit(n > nines[x]);
}
 
#endif /* _PICOW_HTTP_H */