server.h File Reference

Backend-neutral HTTP request/response contract. More...

Go to the source code of this file.

Data Structures
struct	http_header_t
struct	http_request_info
struct	http_server_config_t

Typedefs
typedef struct http_request	http_request_t
typedef struct http_response	http_response_t
typedef struct http_request_info	http_request_info_t
typedef void(*	http_request_fn) (http_request_t *request, http_response_t *response, void *user_data)
typedef void(*	http_connection_fn) (const char *peer_address, bool connected, void *user_data)
typedef void(*	http_error_fn) (asciichat_error_t error, const char *message, void *user_data)
typedef void(*	http_wakeup_fn) (void *user_data)

Enumerations
enum	http_protocol_t { HTTP_PROTOCOL_10 = 0 , HTTP_PROTOCOL_11 , HTTP_PROTOCOL_2 , HTTP_PROTOCOL_3 }

Functions
asciichat_error_t	http_server_init (http_server_t **server, const http_server_config_t *config)
asciichat_error_t	http_server_start (http_server_t *server)
asciichat_error_t	http_server_adopt_socket (http_server_t *server, intptr_t socket_handle)
asciichat_error_t	http_server_wakeup (http_server_t *server)
void	http_server_stop (http_server_t *server)
void	http_server_destroy (http_server_t **server)
asciichat_error_t	http_server_run (http_server_t *server)
const http_request_info_t *	http_request_info (const http_request_t *request)
const void *	http_request_body (const http_request_t *request, size_t *length)
bool	http_request_is_cancelled (const http_request_t *request)
asciichat_error_t	http_request_cancel (http_request_t *request)
bool	http_response_is_cancelled (const http_response_t *response)
asciichat_error_t	http_response_set_status (http_response_t *response, unsigned status)
asciichat_error_t	http_response_retain (http_response_t *response, http_response_t **retained)
void	http_response_release (http_response_t **response)
asciichat_error_t	http_response_set_header (http_response_t *response, const char *name, const char *value)
asciichat_error_t	http_response_write (http_response_t *response, const void *data, size_t length)
size_t	http_response_body_length (const http_response_t *response)
asciichat_error_t	http_response_finish (http_response_t *response)

Detailed Description

Backend-neutral HTTP request/response contract.

The public API deliberately contains no libuv, TLS, HTTP/2, HTTP/3, or libwebsockets types. Backends translate their protocol into this contract; handlers can therefore be shared by MCP, API, discovery, and WebTransport.

Definition in file include/ascii-chat/network/http/server/server.h.

Typedef Documentation

http_connection_fn

typedef void(* http_connection_fn) (const char *peer_address, bool connected, void *user_data)

Definition at line 47 of file include/ascii-chat/network/http/server/server.h.

http_error_fn

typedef void(* http_error_fn) (asciichat_error_t error, const char *message, void *user_data)

Definition at line 48 of file include/ascii-chat/network/http/server/server.h.

http_request_fn

typedef void(* http_request_fn) (http_request_t *request, http_response_t *response, void *user_data)

Definition at line 46 of file include/ascii-chat/network/http/server/server.h.

http_request_info_t

typedef struct http_request_info http_request_info_t

http_request_t

typedef struct http_request http_request_t

Definition at line 18 of file include/ascii-chat/network/http/server/server.h.

http_response_t

typedef struct http_response http_response_t

Definition at line 19 of file include/ascii-chat/network/http/server/server.h.

http_wakeup_fn

typedef void(* http_wakeup_fn) (void *user_data)

Invoked on the HTTP event-loop thread after http_server_wakeup().

Definition at line 50 of file include/ascii-chat/network/http/server/server.h.

Enumeration Type Documentation

http_protocol_t

enum http_protocol_t

Enumerator
HTTP_PROTOCOL_10
HTTP_PROTOCOL_11
HTTP_PROTOCOL_2
HTTP_PROTOCOL_3

Definition at line 21 of file include/ascii-chat/network/http/server/server.h.

             {
  HTTP_PROTOCOL_10 = 0,
  HTTP_PROTOCOL_11,
  HTTP_PROTOCOL_2,
  HTTP_PROTOCOL_3,
} http_protocol_t;

Function Documentation

http_request_body()

const void * http_request_body	(	const http_request_t *	request,
		size_t *	length )

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 *

request

)

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 *

request

)

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 *

request

)

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 *

response

)

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 *

response

)

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 *	response,
		const char *	name,
		const char *	value )

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 *	response,
		unsigned	status )

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 *	response,
		const void *	data,
		size_t	length )

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 **

server

)

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_init()

asciichat_error_t http_server_init	(	http_server_t **	server,
		const http_server_config_t *	config )

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_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 *

server

)

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 *

server

)

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().