Internal WebSocket implementation types shared between transport.c and server.c. More...

Data Structures
struct	websocket_msg_t
	Owned WebSocket frame queued for sending or reassembly. More...
struct	websocket_transport_data_t
	Private state for one libwebsockets-backed ACIP transport. More...

Typedefs
typedef websocket_msg_t	websocket_recv_msg_t

Functions
asciichat_error_t	websocket_transport_send (acip_transport_t transport, const void data, size_t len)
void	websocket_transport_write_pending (struct lws wsi, websocket_transport_data_t ws_data)
	Drain client messages from the send queue on the service thread.

Detailed Description

Internal WebSocket implementation types shared between transport.c and server.c.

Definition in file network/websocket/internal.h.

Typedef Documentation

◆ websocket_recv_msg_t

typedef websocket_msg_t websocket_recv_msg_t

Definition at line 37 of file network/websocket/internal.h.

Function Documentation

◆ websocket_transport_send()

asciichat_error_t websocket_transport_send	(	acip_transport_t *	transport,
		const void *	data,
		size_t	len )

Queue one packet, preserving its control budget through encryption and ownership transfer.

Definition at line 642 of file websocket/transport.c.

                                                                                                      {
  // NOTE: Disabled START_TIMER/STOP_TIMER due to thread safety issues with timer hashtable
  // causing heap-use-after-free crashes in ASAN. The timer system has race conditions
  // when accessed from the service thread context. See: line 325 (similar issue).
  websocket_transport_data_t *ws_data = (websocket_transport_data_t *)transport->impl_data;
 
  // For server-side transports (owns_context=false), the connection is already established.
  // For client-side transports, packets may be queued before the asynchronous WebSocket
  // handshake completes. The service thread drains that queue after CLIENT_ESTABLISHED.
  if (ws_data->owns_context) {
    // Check connection state without blocking the service thread.
    mutex_lock(&ws_data->state_mutex);
    bool connected = ws_data->is_connected;
    bool connection_failed = ws_data->connection_failed;
    mutex_unlock(&ws_data->state_mutex);
 
    if (connection_failed) {
      log_error("Connection failed - cannot send");
      return SET_ERRNO(ERROR_NETWORK, "WebSocket connection failed");
    }
 
    if (!connected) {
      log_debug("Connection is opening; queueing packet for delivery after handshake");
    }
 
    log_dev_every(1000000, "websocket_send (client): is_connected=%d, wsi=%p, send_len=%zu", connected,
                  (void *)ws_data->wsi, len);
  } else {
    log_dev_every(4500 * US_PER_MS_INT,
                  "[WEBSOCKET_SEND_SERVER] Server transport send: wsi=%p, len=%zu (bypassing is_connected check)",
                  (void *)ws_data->wsi, len);
  }
 
  // Classify the original packet before encryption hides its type. Keep this
  // domain through every allocation, including the asynchronous queue owner.
  buffer_domain_t *domain = NULL;
  if (data && len >= sizeof(packet_header_t)) {
    packet_header_t header;
    memcpy(&header, data, sizeof(header));
    packet_type_t type = NET_TO_HOST_U16(header.type);
    if (packet_is_handshake_type(type) || type == PACKET_TYPE_ERROR_MESSAGE)
      domain = buffer_control_domain();
  }
  const void *send_data = NULL;
  size_t send_len = 0;
  uint8_t *encrypted_packet = NULL;
  size_t encrypted_packet_size = 0;
  asciichat_error_t result = websocket_prepare_payload(transport, domain, data, len, &send_data, &send_len,
                                                       &encrypted_packet, &encrypted_packet_size);
  if (result != ASCIICHAT_OK) {
    return result;
  }
 
  result = websocket_queue_payload(ws_data, domain, send_data, send_len);
  if (encrypted_packet) {
    buffer_release(encrypted_packet);
  }
  return result;
}

References ASCIICHAT_OK, buffer_control_domain(), buffer_release, websocket_transport_data_t::connection_failed, ERROR_NETWORK, acip_transport::impl_data, websocket_transport_data_t::is_connected, log_debug, log_dev_every, log_error, NET_TO_HOST_U16, websocket_transport_data_t::owns_context, PACKET_TYPE_ERROR_MESSAGE, SET_ERRNO, websocket_transport_data_t::state_mutex, US_PER_MS_INT, and websocket_transport_data_t::wsi.

◆ websocket_transport_write_pending()

void websocket_transport_write_pending	(	struct lws *	wsi,
		websocket_transport_data_t *	ws_data )

Drain client messages from the send queue on the service thread.

Definition at line 459 of file websocket/transport.c.

                                                                                             {
  if (!ws_data || atomic_load_bool(&ws_data->is_destroying))
    return;
  /* lws suppresses writable callbacks until previously buffered output is
   * consumed. Keep one owner until this completion boundary, or connection
   * teardown; elapsed service-loop iterations are not a completion signal. */
  websocket_recv_msg_t msg = {0};
  mutex_lock(&ws_data->send_mutex);
  buffer_release(ws_data->inflight_buffer);
  ws_data->inflight_buffer = NULL;
  ws_data->pending_send_bytes -= ws_data->inflight_bytes;
  ws_data->inflight_bytes = 0;
  bool available = ringbuffer_read(ws_data->send_queue, &msg);
  if (available)
    ws_data->inflight_buffer = msg.data;
  ws_data->inflight_bytes = msg.len;
  mutex_unlock(&ws_data->send_mutex);
  if (!available)
    return;
  int written = lws_write(wsi, msg.data + LWS_PRE, msg.len, LWS_WRITE_BINARY);
  if (written < 0 || (size_t)written < msg.len) {
    mutex_lock(&ws_data->state_mutex);
    ws_data->is_connected = false;
    ws_data->connection_failed = true;
    cond_broadcast(&ws_data->state_cond);
    mutex_unlock(&ws_data->state_mutex);
    lws_set_timeout(wsi, PENDING_TIMEOUT_CLOSE_SEND, LWS_TO_KILL_ASYNC);
    return;
  }
  /* Exactly one write per callback. Request a completion callback even if
   * there is no next message, so the final owner is promptly released. */
  lws_callback_on_writable(wsi);
}

Data Structures