server.c File Reference

ACIP server-side protocol implementation. More...

Go to the source code of this file.

Functions
asciichat_error_t	acip_server_receive_and_dispatch (acip_transport_t *transport, void *client_ctx, const acip_server_callbacks_t *callbacks)
	Receive packet from client and dispatch to callbacks.
asciichat_error_t	acip_send_ascii_frame (acip_transport_t *transport, const char *frame_data, uint32_t width, uint32_t height)
	Send ASCII frame to client (server → client)
asciichat_error_t	acip_send_clear_console (acip_transport_t *transport)
	Send clear console command to client (server → client)
asciichat_error_t	acip_send_server_state (acip_transport_t *transport, const server_state_packet_t *state)
	Send server state update to client (server → client)

Detailed Description

ACIP server-side protocol implementation.

Provides server-side ACIP protocol utilities for:

• Packet validation
• Error response generation
• Protocol compliance checking

ACIP (ASCII-Chat IP Protocol) is the wire protocol for session discovery and WebRTC signaling. This module provides reusable server-side utilities for any ACIP server implementation.

Server-side packet sending and receiving for ascii-chat protocol. Handles server→client communication (ASCII frames, state updates, console control).

Author

Zachary Fogg me@zf.nosp@m.o.gg

Date

January 2026

Definition in file lib/network/acip/server.c.

Function Documentation

acip_send_ascii_frame()

asciichat_error_t acip_send_ascii_frame	(	acip_transport_t *	transport,
		const char *	frame_data,
		uint32_t	width,
		uint32_t	height
	)

Send ASCII frame to client (server → client)

Sends rendered ASCII art frame to client for display.

Parameters

transport	Transport instance
frame_data	ASCII frame data (null-terminated string)
width	Frame width in characters
height	Frame height in characters

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 79 of file lib/network/acip/server.c.

                                                         {
  if (!transport || !frame_data) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid transport or frame_data");
  }
 
  size_t frame_size = strlen(frame_data);
  if (frame_size == 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Empty frame data");
  }
 
  // Calculate CRC32 checksum of frame data for integrity verification
  uint32_t checksum_value = asciichat_crc32(frame_data, frame_size);
 
  // Create ASCII frame packet header
  ascii_frame_packet_t header;
  header.width = HOST_TO_NET_U32(width);
  header.height = HOST_TO_NET_U32(height);
  header.original_size = HOST_TO_NET_U32((uint32_t)frame_size);
  header.compressed_size = 0;
  header.checksum = HOST_TO_NET_U32(checksum_value);
  header.flags = 0;
 
  // Calculate total packet size
  size_t total_size;
  if (checked_size_add(sizeof(header), frame_size, &total_size) != ASCIICHAT_OK) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Packet size overflow");
  }
 
  // Allocate buffer
  uint8_t *buffer = buffer_pool_alloc(NULL, total_size);
  if (!buffer) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate buffer: %zu bytes", total_size);
  }
 
  // Build packet: header + data
  memcpy(buffer, &header, sizeof(header));
  memcpy(buffer + sizeof(header), frame_data, frame_size);
 
  // Send via transport
  asciichat_error_t result = packet_send_via_transport(transport, PACKET_TYPE_ASCII_FRAME, buffer, total_size);
 
  buffer_pool_free(NULL, buffer, total_size);
  return result;
}

References asciichat_crc32, ASCIICHAT_OK, buffer_pool_alloc(), buffer_pool_free(), ascii_frame_packet_t::checksum, ascii_frame_packet_t::compressed_size, ERROR_INVALID_PARAM, ERROR_MEMORY, ascii_frame_packet_t::flags, ascii_frame_packet_t::height, HOST_TO_NET_U32, ascii_frame_packet_t::original_size, packet_send_via_transport(), PACKET_TYPE_ASCII_FRAME, SET_ERRNO, and ascii_frame_packet_t::width.

Referenced by client_send_thread_func().

acip_send_clear_console()

asciichat_error_t acip_send_clear_console

(

acip_transport_t *

transport

)

Send clear console command to client (server → client)

Instructs client to clear the terminal/console.

Parameters

transport

Transport instance

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 125 of file lib/network/acip/server.c.

                                                                       {
  if (!transport) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid transport");
  }
 
  return packet_send_via_transport(transport, PACKET_TYPE_CLEAR_CONSOLE, NULL, 0);
}

References ERROR_INVALID_PARAM, packet_send_via_transport(), PACKET_TYPE_CLEAR_CONSOLE, and SET_ERRNO.

Referenced by client_send_thread_func().

acip_send_server_state()

asciichat_error_t acip_send_server_state	(	acip_transport_t *	transport,
		const server_state_packet_t *	state
	)

Send server state update to client (server → client)

Notifies client of server state changes (client count, grid layout, etc.)

Parameters

transport	Transport instance
state	Server state structure

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 133 of file lib/network/acip/server.c.

                                                                                                          {
  if (!transport || !state) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid transport or state");
  }
 
  return packet_send_via_transport(transport, PACKET_TYPE_SERVER_STATE, state, sizeof(*state));
}

References ERROR_INVALID_PARAM, packet_send_via_transport(), PACKET_TYPE_SERVER_STATE, and SET_ERRNO.

Referenced by broadcast_server_state_to_all_clients(), and send_server_state_to_client().

acip_server_receive_and_dispatch()

asciichat_error_t acip_server_receive_and_dispatch	(	acip_transport_t *	transport,
		void *	client_ctx,
		const acip_server_callbacks_t *	callbacks
	)

Receive packet from client and dispatch to callbacks.

High-level receive function for server side. Receives a single packet from the transport, handles decryption, and dispatches to appropriate callback handler.

Parameters

transport	Transport instance
client_ctx	Client context pointer (passed to callbacks)
callbacks	Callback structure for handling received packets

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 29 of file lib/network/acip/server.c.

                                                                                             {
  if (!transport || !callbacks) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid transport or callbacks");
  }
 
  // Get socket from transport for low-level packet reception
  socket_t sock = transport->methods->get_socket(transport);
  if (sock == INVALID_SOCKET_VALUE) {
    return SET_ERRNO(ERROR_NETWORK, "Transport has no valid socket");
  }
 
  // Check if transport is connected
  if (!transport->methods->is_connected(transport)) {
    return SET_ERRNO(ERROR_NETWORK, "Transport not connected");
  }
 
  // Receive packet with automatic decryption
  packet_envelope_t envelope;
  bool enforce_encryption = (transport->crypto_ctx != NULL);
  packet_recv_result_t result = receive_packet_secure(sock, transport->crypto_ctx, enforce_encryption, &envelope);
 
  // Handle receive errors
  if (result != PACKET_RECV_SUCCESS) {
    if (result == PACKET_RECV_EOF) {
      return SET_ERRNO(ERROR_NETWORK, "Connection closed (EOF)");
    } else if (result == PACKET_RECV_SECURITY_VIOLATION) {
      return SET_ERRNO(ERROR_CRYPTO, "Security violation: unencrypted packet when encryption required");
    } else {
      return SET_ERRNO(ERROR_NETWORK, "Failed to receive packet");
    }
  }
 
  // Dispatch packet to appropriate ACIP handler
  asciichat_error_t dispatch_result =
      acip_handle_server_packet(transport, envelope.type, envelope.data, envelope.len, client_ctx, callbacks);
 
  // Always free the allocated buffer (even if handler failed)
  if (envelope.allocated_buffer) {
    buffer_pool_free(NULL, envelope.allocated_buffer, envelope.allocated_size);
  }
 
  // Return handler result
  return dispatch_result;
}

References acip_handle_server_packet(), packet_envelope_t::allocated_buffer, packet_envelope_t::allocated_size, buffer_pool_free(), acip_transport::crypto_ctx, packet_envelope_t::data, ERROR_CRYPTO, ERROR_INVALID_PARAM, ERROR_NETWORK, acip_transport_methods_t::get_socket, INVALID_SOCKET_VALUE, acip_transport_methods_t::is_connected, packet_envelope_t::len, acip_transport::methods, PACKET_RECV_EOF, PACKET_RECV_SECURITY_VIOLATION, PACKET_RECV_SUCCESS, receive_packet_secure(), SET_ERRNO, and packet_envelope_t::type.

Referenced by client_receive_thread().