server.c File Reference

Go to the source code of this file.

Data Structures
struct	http_write
struct	http_server
struct	http_request
struct	http_response
struct	http_server_client

Macros
#define	HTTP_READ_CAPACITY   (1024u * 1024u)
#define	HTTP_HEADER_MAX_BYTES   (64u * 1024u)
#define	HTTP_HEADER_CAPACITY   64u

Typedefs
typedef struct http_server_client	http_server_client_t
typedef struct http_write	http_write_t

Functions
size_t	http_server_max_response_body (const http_server_t *server)
void	http_server_invalidate_http3_context (http_server_t *server, void *context)
asciichat_error_t	http_response_set_status (http_response_t *r, unsigned s)
asciichat_error_t	http_response_retain (http_response_t *r, http_response_t **retained)
void	http_response_release (http_response_t **response)
asciichat_error_t	http_response_set_header (http_response_t *r, const char *n, const char *v)
asciichat_error_t	http_response_write (http_response_t *r, const void *d, size_t n)
size_t	http_response_body_length (const http_response_t *r)
asciichat_error_t	http_response_finish (http_response_t *r)
asciichat_error_t	http_server_dispatch_http3 (http_server_t *server, const char *method, const char *path, const http_header_t *headers, size_t header_count, const void *body, size_t body_length, const char *peer_address, http3_submit_response_fn submit, void *submit_context)
const http_request_info_t *	http_request_info (const http_request_t *r)
const void *	http_request_body (const http_request_t *r, size_t *n)
size_t	http_server_max_request_body (const http_server_t *server)
bool	http_request_is_cancelled (const http_request_t *r)
bool	http_response_is_cancelled (const http_response_t *r)
asciichat_error_t	http_request_cancel (http_request_t *r)
asciichat_error_t	http_server_init (http_server_t **out, const http_server_config_t *cfg)
asciichat_error_t	http_server_wakeup (http_server_t *s)
asciichat_error_t	http_server_start (http_server_t *s)
asciichat_error_t	http_server_adopt_socket (http_server_t *s, intptr_t socket_handle)
asciichat_error_t	http_server_run (http_server_t *s)
void	http_server_stop (http_server_t *s)
void	http_server_destroy (http_server_t **p)

Macro Definition Documentation

HTTP_HEADER_CAPACITY

#define HTTP_HEADER_CAPACITY   64u

Definition at line 20 of file lib/network/http/server/server.c.

Referenced by http_response_set_header().

HTTP_HEADER_MAX_BYTES

#define HTTP_HEADER_MAX_BYTES   (64u * 1024u)

Definition at line 19 of file lib/network/http/server/server.c.

HTTP_READ_CAPACITY

#define HTTP_READ_CAPACITY   (1024u * 1024u)

Definition at line 18 of file lib/network/http/server/server.c.

Typedef Documentation

http_server_client_t

typedef struct http_server_client http_server_client_t

Definition at line 37 of file lib/network/http/server/server.c.

http_write_t

typedef struct http_write http_write_t

Function Documentation

http_request_body()

const void * http_request_body	(	const http_request_t *	r,
		size_t *	n )

Definition at line 879 of file lib/network/http/server/server.c.

                                                                  {
  if (n)
    *n = r ? r->body_length : 0;
  return r && r->body_length ? r->storage + r->body_offset : NULL;
}

References http_request::body_length, http_request::body_offset, and http_request::storage.

http_request_cancel()

asciichat_error_t http_request_cancel

(

http_request_t *

r

)

Definition at line 894 of file lib/network/http/server/server.c.

                                                         {
  if (!r)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing HTTP request");
  if (!r->cancelled)
    stats_counter_add(stats_runtime_scope(), STATS_COUNTER_HTTP_CANCELLED, 1);
  r->cancelled = true;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, http_request::cancelled, ERROR_INVALID_PARAM, SET_ERRNO, stats_counter_add(), STATS_COUNTER_HTTP_CANCELLED, and stats_runtime_scope().

http_request_info()

const http_request_info_t * http_request_info

(

const http_request_t *

r

)

Definition at line 876 of file lib/network/http/server/server.c.

                                                                      {
  return r ? &r->info : NULL;
}

References http_request::info.

http_request_is_cancelled()

bool http_request_is_cancelled

(

const http_request_t *

r

)

Definition at line 888 of file lib/network/http/server/server.c.

                                                        {
  return !r || r->cancelled;
}

References http_request::cancelled.

http_response_body_length()

size_t http_response_body_length

(

const http_response_t *

response

)

Return the number of bytes buffered for the response body.

Definition at line 738 of file lib/network/http/server/server.c.

                                                           {
  return r ? r->body_length : 0;
}

References http_response::body_length.

http_response_finish()

asciichat_error_t http_response_finish

(

http_response_t *

r

)

Definition at line 741 of file lib/network/http/server/server.c.

                                                           {
  if (!r || r->finished)
    return SET_ERRNO(ERROR_INVALID_STATE, "HTTP response already finished");
  r->finished = true;
  if (r->status >= 400)
    stats_counter_add(stats_runtime_scope(), STATS_COUNTER_HTTP_ERRORS, 1);
  if (r->cancelled) {
    if (r->inflight_accounted && !r->deferred) {
      http_request_release(r->server);
      r->inflight_accounted = false;
    }
    return SET_ERRNO(ERROR_INVALID_STATE, "HTTP response was cancelled");
  }
  asciichat_error_t result;
  if (r->http3_submit)
    result = r->http3_submit(r->http3_context, r->status, r->headers, r->header_count, r->body, r->body_length);
  else if (r->client && r->client->http2_mode) {
    result = http2_connection_submit_response(r->client->http2, r->http2_stream_id, r->status, r->headers,
                                              r->header_count, r->body, r->body_length);
    if (result == ASCIICHAT_OK)
      result = http2_flush(r->client);
  } else {
    size_t cap = 256 + r->body_length;
    for (size_t i = 0; i < r->header_count; i++)
      cap += strlen(r->headers[i].name) + strlen(r->headers[i].value) + 4;
    char *out = SAFE_MALLOC(cap, char *);
    if (!out) {
      if (r->inflight_accounted && !r->deferred) {
        http_request_release(r->server);
        r->inflight_accounted = false;
      }
      return SET_ERRNO(ERROR_MEMORY, "Cannot allocate HTTP response");
    }
    const char *version = r->protocol == HTTP_PROTOCOL_10 ? "HTTP/1.0" : "HTTP/1.1";
    int n = safe_snprintf(out, cap, "%s %u %s\r\nContent-Length: %zu\r\nConnection: close\r\n", version, r->status,
                          reason(r->status), r->body_length);
    for (size_t i = 0; i < r->header_count; i++)
      n += safe_snprintf(out + n, cap - (size_t)n, "%s: %s\r\n", r->headers[i].name, r->headers[i].value);
    n += safe_snprintf(out + n, cap - (size_t)n, "\r\n");
    if (r->body_length)
      memcpy(out + n, r->body, r->body_length);
    n += (int)r->body_length;
    result = client_write_plain(r->client, out, (size_t)n, true);
    SAFE_FREE(out);
  }
  if (r->inflight_accounted && !r->deferred) {
    http_request_release(r->server);
    r->inflight_accounted = false;
  }
  return result;
}

References ASCIICHAT_OK, http_response::body, http_response::body_length, http_response::cancelled, http_response::client, http_response::deferred, ERROR_INVALID_STATE, ERROR_MEMORY, http_response::finished, http_response::header_count, http_response::headers, http_server_client::http2, http2_connection_submit_response(), http_server_client::http2_mode, http_response::http2_stream_id, http_response::http3_context, http_response::http3_submit, HTTP_PROTOCOL_10, http_response::inflight_accounted, http_header_t::name, out, http_response::protocol, SAFE_FREE, SAFE_MALLOC, safe_snprintf(), http_response::server, SET_ERRNO, stats_counter_add(), STATS_COUNTER_HTTP_ERRORS, stats_runtime_scope(), http_response::status, and http_header_t::value.

Referenced by http_server_authorize(), and http_server_dispatch_http3().

http_response_is_cancelled()

bool http_response_is_cancelled

(

const http_response_t *

r

)

Definition at line 891 of file lib/network/http/server/server.c.

                                                          {
  return !r || r->cancelled;
}

References http_response::cancelled.

http_response_release()

void http_response_release

(

http_response_t **

response

)

Release a response retained with http_response_retain().

Definition at line 687 of file lib/network/http/server/server.c.

                                                       {
  if (!response || !*response)
    return;
  if ((*response)->retained) {
    http_server_t *server = (*response)->server;
    if ((*response)->inflight_accounted) {
      http_request_release(server);
      (*response)->inflight_accounted = false;
    }
    if (server) {
      mutex_lock(&server->response_mutex);
      http_response_t **cursor = &server->retained_responses;
      while (*cursor && *cursor != *response)
        cursor = &(*cursor)->next_retained;
      if (*cursor == *response)
        *cursor = (*response)->next_retained;
      mutex_unlock(&server->response_mutex);
    }
    SAFE_FREE((*response)->body);
    SAFE_FREE(*response);
  }
  *response = NULL;
}

References http_response::next_retained, http_server::response_mutex, http_server::retained_responses, and SAFE_FREE.

http_response_retain()

asciichat_error_t http_response_retain	(	http_response_t *	response,
		http_response_t **	retained )

Retain a response for completion after the request callback returns.

Definition at line 649 of file lib/network/http/server/server.c.

                                                                                       {
  if (!r || !retained || !r->server || r->finished || r->retained)
    return SET_ERRNO(ERROR_INVALID_STATE, "HTTP response cannot be retained");
  http_response_t *copy = SAFE_CALLOC(1, sizeof(*copy), http_response_t *);
  if (!copy)
    return SET_ERRNO(ERROR_MEMORY, "Cannot retain HTTP response");
  copy->stream = r->stream;
  copy->client = r->client;
  copy->http2_stream_id = r->http2_stream_id;
  copy->protocol = r->protocol;
  copy->max_body_length = r->max_body_length;
  copy->http3_submit = r->http3_submit;
  copy->http3_context = r->http3_context;
  copy->server = r->server;
  copy->inflight_accounted = r->inflight_accounted;
  copy->status = r->status;
  copy->header_count = r->header_count;
  memcpy(copy->headers, r->headers, r->header_count * sizeof(r->headers[0]));
  if (r->body_length) {
    copy->body = SAFE_MALLOC(r->body_length, char *);
    if (!copy->body) {
      SAFE_FREE(copy);
      return SET_ERRNO(ERROR_MEMORY, "Cannot retain HTTP response body");
    }
    memcpy(copy->body, r->body, r->body_length);
    copy->body_length = r->body_length;
  }
  copy->retained = true;
  mutex_lock(&r->server->response_mutex);
  copy->next_retained = r->server->retained_responses;
  r->server->retained_responses = copy;
  mutex_unlock(&r->server->response_mutex);
  r->deferred = true;
  r->retained = true;
  r->inflight_accounted = false;
  *retained = copy;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, http_response::body, http_response::body_length, http_response::client, http_response::deferred, ERROR_INVALID_STATE, ERROR_MEMORY, http_response::finished, http_response::header_count, http_response::headers, http_response::http2_stream_id, http_response::http3_context, http_response::http3_submit, http_response::inflight_accounted, http_response::max_body_length, http_response::next_retained, http_response::protocol, http_server::response_mutex, http_response::retained, http_server::retained_responses, SAFE_CALLOC, SAFE_FREE, SAFE_MALLOC, http_response::server, SET_ERRNO, http_response::status, and http_response::stream.

http_response_set_header()

asciichat_error_t http_response_set_header	(	http_response_t *	r,
		const char *	n,
		const char *	v )

Definition at line 710 of file lib/network/http/server/server.c.

                                                                                             {
  if (!r || !n || !v)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP response header");
  for (size_t i = 0; i < r->header_count; ++i) {
    if (platform_strcasecmp(r->headers[i].name, n) == 0) {
      r->headers[i] = (http_header_t){n, v};
      return ASCIICHAT_OK;
    }
  }
  if (r->header_count >= HTTP_HEADER_CAPACITY)
    return SET_ERRNO(ERROR_INVALID_PARAM, "HTTP response header limit exceeded");
  r->headers[r->header_count++] = (http_header_t){n, v};
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, http_response::header_count, http_response::headers, HTTP_HEADER_CAPACITY, http_header_t::name, and SET_ERRNO.

Referenced by http_server_authorize().

http_response_set_status()

asciichat_error_t http_response_set_status	(	http_response_t *	r,
		unsigned	s )

Definition at line 643 of file lib/network/http/server/server.c.

                                                                           {
  if (!r || s < 100 || s > 599)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP status");
  r->status = s;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, SET_ERRNO, and http_response::status.

Referenced by http_server_authorize().

http_response_write()

asciichat_error_t http_response_write	(	http_response_t *	r,
		const void *	d,
		size_t	n )

Definition at line 724 of file lib/network/http/server/server.c.

                                                                                   {
  if (!r || (!d && n) || r->finished)
    return SET_ERRNO(ERROR_INVALID_STATE, "HTTP response is not writable");
  if (n > r->max_body_length || r->body_length > r->max_body_length - n)
    return SET_ERRNO(ERROR_NETWORK_SIZE, "HTTP response body exceeds configured limit");
  char *p = SAFE_REALLOC(r->body, r->body_length + n + 1, char *);
  if (!p)
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate HTTP response body");
  r->body = p;
  memcpy(p + r->body_length, d, n);
  r->body_length += n;
  p[r->body_length] = 0;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, http_response::body, http_response::body_length, ERROR_INVALID_STATE, ERROR_MEMORY, ERROR_NETWORK_SIZE, http_response::finished, http_response::max_body_length, SAFE_REALLOC, and SET_ERRNO.

http_server_adopt_socket()

asciichat_error_t http_server_adopt_socket	(	http_server_t *	server,
		intptr_t	socket_handle )

Adopt an already-listening native socket before starting the server.

Definition at line 1352 of file lib/network/http/server/server.c.

                                                                                     {
  if (!s || s->running || s->adopted_socket || socket_handle < 0)
    return SET_ERRNO(ERROR_INVALID_STATE, "HTTP listener cannot adopt this socket");
  if (uv_tcp_open(&s->listener, (uv_os_sock_t)socket_handle) != 0)
    return SET_ERRNO(ERROR_NETWORK, "Cannot adopt HTTP listener socket");
  s->adopted_socket = true;
  return ASCIICHAT_OK;
}

References http_server::adopted_socket, ASCIICHAT_OK, ERROR_INVALID_STATE, ERROR_NETWORK, http_server::listener, http_server::running, and SET_ERRNO.

http_server_destroy()

void http_server_destroy

(

http_server_t **

p

)

Definition at line 1392 of file lib/network/http/server/server.c.

                                            {
  if (!p || !*p)
    return;
  http_server_t *s = *p;
  http_server_stop(s);
  while (uv_run(&s->loop, UV_RUN_NOWAIT) != 0)
    ;
  uv_loop_close(&s->loop);
  http_server_detach_http3(s);
  rate_limiter_destroy(s->rate_limiter);
  mutex_destroy(&s->response_mutex);
  SSL_CTX_free(s->tls_context);
  SAFE_FREE(s);
  *p = NULL;
}

References http_server_stop(), http_server::loop, http_server::rate_limiter, rate_limiter_destroy(), http_server::response_mutex, SAFE_FREE, and http_server::tls_context.

Referenced by api_server_main(), and mcp_http_run().

http_server_dispatch_http3()

asciichat_error_t http_server_dispatch_http3	(	http_server_t *	server,
		const char *	method,
		const char *	path,
		const http_header_t *	headers,
		size_t	header_count,
		const void *	body,
		size_t	body_length,
		const char *	peer_address,
		http3_submit_response_fn	submit,
		void *	submit_context )

Definition at line 793 of file lib/network/http/server/server.c.

                                                                                                    {
  if (!server || !method || !path || (header_count && !headers) || (!body && body_length) || !submit ||
      body_length > server->config.max_request_body_bytes)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP/3 request");
  char path_copy[2048];
  if (strlen(path) >= sizeof(path_copy))
    return SET_ERRNO(ERROR_NETWORK_SIZE, "HTTP/3 request path is too long");
  platform_strncpy(path_copy, sizeof(path_copy), path, sizeof(path_copy) - 1);
  char *query = strchr(path_copy, '?');
  if (query)
    *query++ = 0;
  http_request_t request = {0};
  request.info = (http_request_info_t){.method = method,
                                       .path = path_copy,
                                       .query = query,
                                       .protocol = HTTP_PROTOCOL_3,
                                       .headers = headers,
                                       .header_count = header_count,
                                       .peer_address = peer_address,
                                       .user_data = server->config.user_data};
  request.storage = (char *)body;
  request.body_length = body_length;
  stats_counter_add(stats_runtime_scope(), STATS_COUNTER_HTTP_BYTES_RECEIVED, body_length);
  const char *peer = peer_address ? peer_address : "unknown";
  bool allowed = false;
  if (rate_limiter_check(server->rate_limiter, peer, RATE_EVENT_HTTP_REQUEST, &server->request_rate_limit, &allowed) !=
          ASCIICHAT_OK ||
      !allowed) {
    stats_counter_add(stats_runtime_scope(), STATS_COUNTER_HTTP_REJECTED, 1);
    http_response_t limited = {.server = server,
                               .protocol = HTTP_PROTOCOL_3,
                               .status = 429,
                               .max_body_length = http_max_response_body(server),
                               .http3_submit = submit,
                               .http3_context = submit_context};
    return http_response_finish(&limited);
  }
  rate_limiter_record(server->rate_limiter, peer, RATE_EVENT_HTTP_REQUEST);
  stats_counter_add(stats_runtime_scope(), STATS_COUNTER_HTTP_REQUESTS, 1);
  stats_gauge_set(stats_runtime_scope(), STATS_GAUGE_HTTP_STREAMS_ACTIVE, 1);
  uint64_t request_start = time_get_ns();
  if (!http_request_admit(server)) {
    http_response_t limited = {.server = server,
                               .protocol = HTTP_PROTOCOL_3,
                               .status = 429,
                               .max_body_length = http_max_response_body(server),
                               .http3_submit = submit,
                               .http3_context = submit_context};
    return http_response_finish(&limited);
  }
  http_response_t response = {.server = server,
                              .protocol = HTTP_PROTOCOL_3,
                              .status = 200,
                              .max_body_length = http_max_response_body(server),
                              .inflight_accounted = true,
                              .http3_submit = submit,
                              .http3_context = submit_context};
  ASCII_OTEL_SCOPE(HTTP);
  ASCII_OTEL_ATTR_STRING("http.method", method);
  ASCII_OTEL_ATTR_STRING("http.route", request.info.path);
  ASCII_OTEL_ATTR_STRING("http.protocol", "3");
  ASCII_OTEL_ATTR_STRING("http.backend", "quic-ngtcp2-nghttp3");
  if (http_server_authorize(&server->config.basic_auth, &request.info, &response))
    server->config.on_request(&request, &response, server->config.user_data);
  if (!response.finished && !response.deferred) {
    asciichat_error_t result = http_response_finish(&response);
    ASCII_OTEL_ATTR_INT("http.status", response.status);
    ASCII_OTEL_ATTR_INT("http.response_bytes", (int64_t)response.body_length);
    stats_duration_record(stats_runtime_scope(), STATS_DURATION_HTTP_REQUEST, time_get_ns() - request_start);
    stats_gauge_set(stats_runtime_scope(), STATS_GAUGE_HTTP_STREAMS_ACTIVE, 0);
    if (result == ASCIICHAT_OK && response.protocol == HTTP_PROTOCOL_3)
      stats_counter_add(stats_runtime_scope(), STATS_COUNTER_HTTP_BYTES_SENT, response.body_length);
    SAFE_FREE(response.body);
    return result;
  }
  stats_duration_record(stats_runtime_scope(), STATS_DURATION_HTTP_REQUEST, time_get_ns() - request_start);
  stats_gauge_set(stats_runtime_scope(), STATS_GAUGE_HTTP_STREAMS_ACTIVE, 0);
  SAFE_FREE(response.body);
  return ASCIICHAT_OK;
}

References ASCII_OTEL_ATTR_INT, ASCII_OTEL_ATTR_STRING, ASCII_OTEL_SCOPE, ASCIICHAT_OK, http_server_config_t::basic_auth, http_response::body, http_request::body_length, http_response::body_length, http_server::config, http_response::deferred, ERROR_INVALID_PARAM, ERROR_NETWORK_SIZE, http_response::finished, HTTP_PROTOCOL_3, http_response_finish(), http_server_authorize(), http_request::info, http_server_config_t::max_request_body_bytes, http_server_config_t::on_request, http_request_info::path, http_response::protocol, RATE_EVENT_HTTP_REQUEST, http_server::rate_limiter, rate_limiter_check(), rate_limiter_record(), http_server::request_rate_limit, SAFE_FREE, SET_ERRNO, stats_counter_add(), STATS_COUNTER_HTTP_BYTES_RECEIVED, STATS_COUNTER_HTTP_BYTES_SENT, STATS_COUNTER_HTTP_REJECTED, STATS_COUNTER_HTTP_REQUESTS, STATS_DURATION_HTTP_REQUEST, stats_duration_record(), STATS_GAUGE_HTTP_STREAMS_ACTIVE, stats_gauge_set(), stats_runtime_scope(), http_response::status, http_request::storage, and http_server_config_t::user_data.

http_server_init()

asciichat_error_t http_server_init	(	http_server_t **	out,
		const http_server_config_t *	cfg )

Definition at line 1227 of file lib/network/http/server/server.c.

                                                                                         {
  if (!out || !cfg || !cfg->on_request || (!cfg->enable_http1 && !cfg->enable_http2 && !cfg->enable_http3))
    return SET_ERRNO(ERROR_INVALID_PARAM, "At least one HTTP protocol and a request handler are required");
  if (cfg->max_connections == 0 || cfg->max_request_body_bytes == 0)
    return SET_ERRNO(ERROR_INVALID_PARAM, "HTTP limits must be non-zero");
  if (cfg->basic_auth.enabled && (!cfg->basic_auth.username || !cfg->basic_auth.password ||
                                  !cfg->basic_auth.username[0] || !cfg->basic_auth.password[0]))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Basic authentication requires non-empty credentials");
  if ((cfg->enable_http3 && !cfg->http3_endpoint) || ((cfg->tls_cert_path == NULL) != (cfg->tls_key_path == NULL)))
    return SET_ERRNO(ERROR_INVALID_PARAM, "HTTP/3 requires a pre-opened endpoint and TLS requires certificate and key");
  http_server_t *s = SAFE_CALLOC(1, sizeof(*s), http_server_t *);
  if (mutex_init(&s->response_mutex, "http_responses") != 0) {
    SAFE_FREE(s);
    return SET_ERRNO(ERROR_NETWORK, "Cannot initialize HTTP response synchronization");
  }
  s->rate_limiter = rate_limiter_create_memory();
  if (!s->rate_limiter) {
    mutex_destroy(&s->response_mutex);
    SAFE_FREE(s);
    return SET_ERRNO(ERROR_MEMORY, "Cannot initialize HTTP rate limiter");
  }
  s->config = *cfg;
  if (cfg->tls_cert_path) {
    s->tls_context = SSL_CTX_new(TLS_server_method());
    if (!s->tls_context) {
      rate_limiter_destroy(s->rate_limiter);
      mutex_destroy(&s->response_mutex);
      SAFE_FREE(s);
      return SET_ERRNO(ERROR_NETWORK, "Cannot initialize TLS context");
    }
    SSL_CTX_set_app_data(s->tls_context, s);
    SSL_CTX_set_alpn_select_cb(s->tls_context, http_select_alpn, s);
    if (cfg->tls_key_password) {
      SSL_CTX_set_default_passwd_cb_userdata(s->tls_context, (void *)cfg->tls_key_password);
    }
    if (cfg->tls_key_password)
      SSL_CTX_set_default_passwd_cb(s->tls_context, tls_password_cb);
    if (SSL_CTX_use_certificate_chain_file(s->tls_context, cfg->tls_cert_path) != 1 ||
        SSL_CTX_use_PrivateKey_file(s->tls_context, cfg->tls_key_path, SSL_FILETYPE_PEM) != 1 ||
        SSL_CTX_check_private_key(s->tls_context) != 1) {
      SSL_CTX_free(s->tls_context);
      s->tls_context = NULL;
      rate_limiter_destroy(s->rate_limiter);
      mutex_destroy(&s->response_mutex);
      SAFE_FREE(s);
      return SET_ERRNO(ERROR_NETWORK, "Cannot load HTTP TLS certificate or key");
    }
  }
  s->request_rate_limit.max_events =
      cfg->max_requests_per_peer
          ? (uint32_t)(cfg->max_requests_per_peer > UINT32_MAX ? UINT32_MAX : cfg->max_requests_per_peer)
          : DEFAULT_RATE_LIMITS[RATE_EVENT_HTTP_REQUEST].max_events;
  s->request_rate_limit.window_secs = cfg->request_rate_window_seconds
                                          ? cfg->request_rate_window_seconds
                                          : DEFAULT_RATE_LIMITS[RATE_EVENT_HTTP_REQUEST].window_secs;
  if (uv_loop_init(&s->loop) != 0) {
    rate_limiter_destroy(s->rate_limiter);
    mutex_destroy(&s->response_mutex);
    SSL_CTX_free(s->tls_context);
    SAFE_FREE(s);
    return SET_ERRNO(ERROR_NETWORK, "Cannot initialize HTTP event loop");
  }
  if (uv_tcp_init(&s->loop, &s->listener) != 0) {
    uv_loop_close(&s->loop);
    rate_limiter_destroy(s->rate_limiter);
    mutex_destroy(&s->response_mutex);
    SSL_CTX_free(s->tls_context);
    SAFE_FREE(s);
    return SET_ERRNO(ERROR_NETWORK, "Cannot initialize HTTP listener");
  }
  s->listener_initialized = true;
  s->listener.data = s;
  if (uv_tcp_init(&s->loop, &s->listener6) != 0) {
    uv_close((uv_handle_t *)&s->listener, NULL);
    return SET_ERRNO(ERROR_NETWORK, "Cannot initialize IPv6 HTTP listener");
  }
  s->listener6_initialized = true;
  s->listener6.data = s;
  if (uv_async_init(&s->loop, &s->stop_async, stop_async_cb) != 0) {
    uv_close((uv_handle_t *)&s->listener, NULL);
    uv_run(&s->loop, UV_RUN_DEFAULT);
    uv_loop_close(&s->loop);
    rate_limiter_destroy(s->rate_limiter);
    mutex_destroy(&s->response_mutex);
    SSL_CTX_free(s->tls_context);
    SAFE_FREE(s);
    return SET_ERRNO(ERROR_NETWORK, "Cannot initialize HTTP stop handle");
  }
  s->stop_async_initialized = true;
  s->stop_async.data = s;
  if (uv_async_init(&s->loop, &s->wake_async, wake_async_cb) != 0) {
    uv_close((uv_handle_t *)&s->stop_async, NULL);
    uv_close((uv_handle_t *)&s->listener, NULL);
    uv_run(&s->loop, UV_RUN_DEFAULT);
    uv_loop_close(&s->loop);
    mutex_destroy(&s->response_mutex);
    rate_limiter_destroy(s->rate_limiter);
    SSL_CTX_free(s->tls_context);
    SAFE_FREE(s);
    return SET_ERRNO(ERROR_NETWORK, "Cannot initialize HTTP wakeup handle");
  }
  s->wake_async_initialized = true;
  s->wake_async.data = s;
  *out = s;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, http_server_config_t::basic_auth, http_server::config, DEFAULT_RATE_LIMITS, http_server_config_t::enable_http1, http_server_config_t::enable_http2, http_server_config_t::enable_http3, http_basic_auth_config::enabled, ERROR_INVALID_PARAM, ERROR_MEMORY, ERROR_NETWORK, http_server_config_t::http3_endpoint, http_server::listener, http_server::listener6, http_server::listener6_initialized, http_server::listener_initialized, http_server::loop, http_server_config_t::max_connections, rate_limit_config_t::max_events, http_server_config_t::max_request_body_bytes, http_server_config_t::max_requests_per_peer, http_server_config_t::on_request, out, http_basic_auth_config::password, RATE_EVENT_HTTP_REQUEST, http_server::rate_limiter, rate_limiter_create_memory(), rate_limiter_destroy(), http_server::request_rate_limit, http_server_config_t::request_rate_window_seconds, http_server::response_mutex, SAFE_CALLOC, SAFE_FREE, SET_ERRNO, http_server::stop_async, http_server::stop_async_initialized, http_server_config_t::tls_cert_path, http_server::tls_context, http_server_config_t::tls_key_password, http_server_config_t::tls_key_path, http_basic_auth_config::username, http_server::wake_async, http_server::wake_async_initialized, and rate_limit_config_t::window_secs.

Referenced by api_server_main(), and mcp_http_run().

http_server_invalidate_http3_context()

void http_server_invalidate_http3_context	(	http_server_t *	server,
		void *	context )

Definition at line 138 of file lib/network/http/server/server.c.

                                                                                {
  if (!server || !context)
    return;
  mutex_lock(&server->response_mutex);
  for (http_response_t *response = server->retained_responses; response; response = response->next_retained) {
    if (response->http3_context == context) {
      response->http3_submit = NULL;
      response->http3_context = NULL;
      response->cancelled = true;
    }
  }
  mutex_unlock(&server->response_mutex);
}

References http_response::next_retained, http_server::response_mutex, and http_server::retained_responses.

Referenced by http_server_http3_destroy().

http_server_max_request_body()

size_t http_server_max_request_body

(

const http_server_t *

server

)

Definition at line 885 of file lib/network/http/server/server.c.

                                                                 {
  return server ? server->config.max_request_body_bytes : 0;
}

References http_server::config, and http_server_config_t::max_request_body_bytes.

http_server_max_response_body()

size_t http_server_max_response_body

(

const http_server_t *

server

)

Definition at line 135 of file lib/network/http/server/server.c.

                                                                  {
  return server ? http_max_response_body(server) : 0;
}

http_server_run()

asciichat_error_t http_server_run

(

http_server_t *

server

)

Run the server loop when embedding the server without a background thread.

Definition at line 1360 of file lib/network/http/server/server.c.

                                                    {
  if (!s || s->running || s->thread_started)
    return SET_ERRNO(ERROR_INVALID_STATE, "HTTP server loop is already running in its worker thread");
  asciichat_error_t result = http_server_start_listener(s);
  if (result != ASCIICHAT_OK)
    return result;
  s->running = true;
  s->foreground_running = true;
  uv_run(&s->loop, UV_RUN_DEFAULT);
  s->foreground_running = false;
  s->running = false;
  http_server_detach_http3(s);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_STATE, http_server::foreground_running, http_server::loop, http_server::running, SET_ERRNO, and http_server::thread_started.

http_server_start()

asciichat_error_t http_server_start

(

http_server_t *

s

)

Definition at line 1338 of file lib/network/http/server/server.c.

                                                      {
  if (!s || s->running)
    return SET_ERRNO(ERROR_INVALID_STATE, "HTTP server is already running");
  asciichat_error_t result = http_server_start_listener(s);
  if (result != ASCIICHAT_OK)
    return result;
  s->running = true;
  if (platform_thread_create(&s->thread, "http_io", http_loop_thread, s) != 0) {
    http_server_rollback_start(s);
    return SET_ERRNO(ERROR_THREAD, "Cannot create HTTP event-loop thread");
  }
  s->thread_started = true;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_STATE, ERROR_THREAD, http_server::running, SET_ERRNO, http_server::thread, and http_server::thread_started.

Referenced by api_server_main(), and mcp_http_run().

http_server_stop()

void http_server_stop

(

http_server_t *

s

)

Definition at line 1374 of file lib/network/http/server/server.c.

                                        {
  if (!s || !s->running)
    return;
  s->running = false;
  if (s->thread_started) {
    uv_async_send(&s->stop_async);
    thread_join(&s->thread, NULL);
    s->thread_started = false;
    http_server_detach_http3(s);
  } else if (s->foreground_running) {
    (void)uv_async_send(&s->stop_async);
  } else {
    stop_async_cb(&s->stop_async);
    while (uv_run(&s->loop, UV_RUN_NOWAIT) != 0)
      ;
    http_server_detach_http3(s);
  }
}

References http_server::foreground_running, http_server::loop, http_server::running, http_server::stop_async, http_server::thread, and http_server::thread_started.

Referenced by api_server_main(), http_server_destroy(), and mcp_http_run().

http_server_wakeup()

asciichat_error_t http_server_wakeup

(

http_server_t *

server

)

Wake the private event loop from a worker thread.

Definition at line 1333 of file lib/network/http/server/server.c.

                                                       {
  if (!s || !s->running || uv_is_closing((uv_handle_t *)&s->wake_async))
    return SET_ERRNO(ERROR_INVALID_STATE, "HTTP server is not running");
  return uv_async_send(&s->wake_async) == 0 ? ASCIICHAT_OK : SET_ERRNO(ERROR_NETWORK, "Cannot wake HTTP event loop");
}

References ASCIICHAT_OK, ERROR_INVALID_STATE, ERROR_NETWORK, http_server::running, SET_ERRNO, and http_server::wake_async.

Referenced by mcp_http_wake().