host.c File Reference

🏠 Server-side session hosting implementation More...

Go to the source code of this file.

Data Structures
struct	session_host_client_t
	Internal client record structure. More...
struct	session_host
	Internal session host structure. More...

Macros
#define	SESSION_HOST_DEFAULT_MAX_CLIENTS   32
	Default maximum clients.

Typedefs
typedef struct session_host	session_host_t
	Internal session host structure.

Functions
session_host_t *	session_host_create (const session_host_config_t *config)
void	session_host_destroy (session_host_t *host)
asciichat_error_t	session_host_start (session_host_t *host)
void	session_host_stop (session_host_t *host)
bool	session_host_is_running (session_host_t *host)
uint32_t	session_host_add_client (session_host_t *host, socket_t socket, const char *ip, int port)
uint32_t	session_host_add_memory_participant (session_host_t *host)
asciichat_error_t	session_host_inject_frame (session_host_t *host, uint32_t participant_id, const image_t *frame)
asciichat_error_t	session_host_inject_audio (session_host_t *host, uint32_t participant_id, const float *samples, size_t count)
asciichat_error_t	session_host_remove_client (session_host_t *host, uint32_t client_id)
asciichat_error_t	session_host_find_client (session_host_t *host, uint32_t client_id, session_host_client_info_t *info)
int	session_host_get_client_count (session_host_t *host)
int	session_host_get_client_ids (session_host_t *host, uint32_t *ids, int max_ids)
asciichat_error_t	session_host_broadcast_frame (session_host_t *host, const char *frame)
asciichat_error_t	session_host_send_frame (session_host_t *host, uint32_t client_id, const char *frame)
asciichat_error_t	session_host_start_render (session_host_t *host)
void	session_host_stop_render (session_host_t *host)
asciichat_error_t	session_host_set_client_transport (session_host_t *host, uint32_t client_id, acip_transport_t *transport)
acip_transport_t *	session_host_get_client_transport (session_host_t *host, uint32_t client_id)
bool	session_host_client_has_transport (session_host_t *host, uint32_t client_id)

Detailed Description

🏠 Server-side session hosting implementation

Implements the session host abstraction for server-side client management and session coordination.

NOTE: This is a stub implementation that provides the API structure. Full implementation will integrate with existing server code in a future phase.

Author

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

Date

January 2026

Definition in file host.c.

Macro Definition Documentation

SESSION_HOST_DEFAULT_MAX_CLIENTS

#define SESSION_HOST_DEFAULT_MAX_CLIENTS   32

Default maximum clients.

Definition at line 43 of file host.c.

Typedef Documentation

session_host_t

typedef struct session_host session_host_t

Internal session host structure.

Contains server state, client list, and callback configuration.

Function Documentation

session_host_add_client()

uint32_t session_host_add_client	(	session_host_t *	host,
		socket_t	socket,
		const char *	ip,
		int	port
	)

Definition at line 928 of file host.c.

                                                                                                  {
  if (!host || !host->initialized) {
    return 0;
  }
 
  mutex_lock(&host->clients_mutex);
 
  // Check if we have room
  if (host->client_count >= host->max_clients) {
    mutex_unlock(&host->clients_mutex);
    SET_ERRNO(ERROR_SESSION_FULL, "Maximum clients reached");
    return 0;
  }
 
  // Find empty slot
  for (int i = 0; i < host->max_clients; i++) {
    if (!host->clients[i].active) {
      host->clients[i].participant_type = PARTICIPANT_TYPE_NETWORK;
      host->clients[i].client_id = host->next_client_id++;
      host->clients[i].socket = socket;
      if (ip) {
        SAFE_STRNCPY(host->clients[i].ip_address, ip, sizeof(host->clients[i].ip_address));
      }
      host->clients[i].port = port;
      host->clients[i].active = true;
      host->clients[i].video_active = false;
      host->clients[i].audio_active = false;
      host->clients[i].connected_at = (uint64_t)time(NULL);
      host->clients[i].transport = NULL; // No alternative transport initially
 
      // Allocate media buffers
      host->clients[i].incoming_video = image_new(480, 270);                        // Network-optimal size (HD preview)
      host->clients[i].incoming_audio = ringbuffer_create(sizeof(float), 960 * 10); // ~200ms buffer @ 48kHz
 
      if (!host->clients[i].incoming_video || !host->clients[i].incoming_audio) {
        // Cleanup on allocation failure
        if (host->clients[i].incoming_video) {
          image_destroy(host->clients[i].incoming_video);
          host->clients[i].incoming_video = NULL;
        }
        if (host->clients[i].incoming_audio) {
          ringbuffer_destroy(host->clients[i].incoming_audio);
          host->clients[i].incoming_audio = NULL;
        }
        host->clients[i].active = false;
        mutex_unlock(&host->clients_mutex);
        SET_ERRNO(ERROR_MEMORY, "Failed to allocate media buffers for client");
        return 0;
      }
 
      uint32_t client_id = host->clients[i].client_id;
      host->client_count++;
 
      mutex_unlock(&host->clients_mutex);
 
      // Invoke callback
      if (host->callbacks.on_client_join) {
        host->callbacks.on_client_join(host, client_id, host->user_data);
      }
 
      return client_id;
    }
  }
 
  mutex_unlock(&host->clients_mutex);
  return 0;
}

References session_host_client_t::active, session_host_client_t::audio_active, session_host::callbacks, session_host::client_count, session_host_client_t::client_id, session_host::clients, session_host::clients_mutex, session_host_client_t::connected_at, image_destroy(), image_new(), session_host_client_t::incoming_audio, session_host_client_t::incoming_video, session_host::initialized, session_host_client_t::ip_address, session_host::max_clients, session_host::next_client_id, session_host_client_t::participant_type, session_host_client_t::port, ringbuffer_create(), ringbuffer_destroy(), session_host_client_t::socket, session_host_client_t::transport, session_host::user_data, and session_host_client_t::video_active.

Referenced by add_client(), and add_webrtc_client().

session_host_add_memory_participant()

uint32_t session_host_add_memory_participant

(

session_host_t *

host

)

Definition at line 996 of file host.c.

                                                                   {
  if (!host || !host->initialized) {
    return 0;
  }
 
  mutex_lock(&host->clients_mutex);
 
  // Check if we have room
  if (host->client_count >= host->max_clients) {
    mutex_unlock(&host->clients_mutex);
    SET_ERRNO(ERROR_SESSION_FULL, "Maximum clients reached");
    return 0;
  }
 
  // Check if memory participant already exists (only one allowed)
  for (int i = 0; i < host->max_clients; i++) {
    if (host->clients[i].active && host->clients[i].participant_type == PARTICIPANT_TYPE_MEMORY) {
      mutex_unlock(&host->clients_mutex);
      SET_ERRNO(ERROR_INVALID_PARAM, "Memory participant already exists");
      return 0;
    }
  }
 
  // Find empty slot
  for (int i = 0; i < host->max_clients; i++) {
    if (!host->clients[i].active) {
      host->clients[i].participant_type = PARTICIPANT_TYPE_MEMORY;
      host->clients[i].client_id = host->next_client_id++;
      host->clients[i].socket = INVALID_SOCKET_VALUE; // No socket for memory participant
      SAFE_STRNCPY(host->clients[i].ip_address, "memory", sizeof(host->clients[i].ip_address));
      host->clients[i].port = 0;
      host->clients[i].active = true;
      host->clients[i].video_active = false;
      host->clients[i].audio_active = false;
      host->clients[i].connected_at = (uint64_t)time(NULL);
      host->clients[i].transport = NULL;
 
      // Allocate media buffers (same as network clients)
      host->clients[i].incoming_video = image_new(480, 270);
      host->clients[i].incoming_audio = ringbuffer_create(sizeof(float), 960 * 10);
 
      if (!host->clients[i].incoming_video || !host->clients[i].incoming_audio) {
        if (host->clients[i].incoming_video) {
          image_destroy(host->clients[i].incoming_video);
          host->clients[i].incoming_video = NULL;
        }
        if (host->clients[i].incoming_audio) {
          ringbuffer_destroy(host->clients[i].incoming_audio);
          host->clients[i].incoming_audio = NULL;
        }
        host->clients[i].active = false;
        mutex_unlock(&host->clients_mutex);
        SET_ERRNO(ERROR_MEMORY, "Failed to allocate media buffers for memory participant");
        return 0;
      }
 
      uint32_t participant_id = host->clients[i].client_id;
      host->client_count++;
 
      mutex_unlock(&host->clients_mutex);
 
      log_info("Added memory participant with ID %u", participant_id);
 
      // Invoke callback
      if (host->callbacks.on_client_join) {
        host->callbacks.on_client_join(host, participant_id, host->user_data);
      }
 
      return participant_id;
    }
  }
 
  mutex_unlock(&host->clients_mutex);
  return 0;
}

References session_host_client_t::active, session_host_client_t::audio_active, session_host::callbacks, session_host::client_count, session_host_client_t::client_id, session_host::clients, session_host::clients_mutex, session_host_client_t::connected_at, image_destroy(), image_new(), session_host_client_t::incoming_audio, session_host_client_t::incoming_video, session_host::initialized, session_host_client_t::ip_address, session_host::max_clients, session_host::next_client_id, participant_id, session_host_client_t::participant_type, session_host_client_t::port, ringbuffer_create(), ringbuffer_destroy(), session_host_client_t::socket, session_host_client_t::transport, session_host::user_data, and session_host_client_t::video_active.

session_host_broadcast_frame()

asciichat_error_t session_host_broadcast_frame	(	session_host_t *	host,
		const char *	frame
	)

Definition at line 1258 of file host.c.

                                                                                        {
  if (!host || !host->initialized || !frame) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "session_host_broadcast_frame: invalid parameter");
  }
 
  if (!host->running) {
    return SET_ERRNO(ERROR_INVALID_STATE, "session_host_broadcast_frame: not running");
  }
 
  // Broadcast ASCII frame to all connected clients
  size_t frame_len = strlen(frame) + 1; // Include null terminator
  asciichat_error_t result = ASCIICHAT_OK;
 
  mutex_lock(&host->clients_mutex);
  for (int i = 0; i < host->max_clients; i++) {
    if (host->clients[i].active && host->clients[i].socket != INVALID_SOCKET_VALUE) {
      asciichat_error_t send_result =
          packet_send(host->clients[i].socket, PACKET_TYPE_ASCII_FRAME, (const void *)frame, frame_len);
      if (send_result != ASCIICHAT_OK) {
        log_warn("Failed to send ASCII frame to client %u", host->clients[i].client_id);
        result = send_result; // Store error but continue broadcasting to other clients
      }
    }
  }
  mutex_unlock(&host->clients_mutex);
 
  return result;
}

References session_host_client_t::active, session_host_client_t::client_id, session_host::clients, session_host::clients_mutex, session_host::initialized, session_host::max_clients, packet_send(), session_host::running, and session_host_client_t::socket.

session_host_client_has_transport()

bool session_host_client_has_transport	(	session_host_t *	host,
		uint32_t	client_id
	)

Definition at line 1461 of file host.c.

                                                                                 {
  if (!host || !host->initialized) {
    return false;
  }
 
  mutex_lock(&host->clients_mutex);
 
  // Find client with matching ID
  for (int i = 0; i < host->max_clients; i++) {
    if (host->clients[i].active && host->clients[i].client_id == client_id) {
      bool has_transport = host->clients[i].transport != NULL;
      mutex_unlock(&host->clients_mutex);
      return has_transport;
    }
  }
 
  mutex_unlock(&host->clients_mutex);
  return false;
}

References session_host_client_t::active, session_host_client_t::client_id, session_host::clients, session_host::clients_mutex, session_host::initialized, session_host::max_clients, and session_host_client_t::transport.

session_host_create()

session_host_t * session_host_create

(

const session_host_config_t *

config

)

Definition at line 166 of file host.c.

                                                                         {
  if (!config) {
    SET_ERRNO(ERROR_INVALID_PARAM, "session_host_create: NULL config");
    return NULL;
  }
 
  // Allocate host
  session_host_t *host = SAFE_CALLOC(1, sizeof(session_host_t), session_host_t *);
 
  // Copy configuration
  host->port = config->port > 0 ? config->port : OPT_PORT_INT_DEFAULT;
  host->max_clients = config->max_clients > 0 ? config->max_clients : SESSION_HOST_DEFAULT_MAX_CLIENTS;
  host->encryption_enabled = config->encryption_enabled;
 
  if (config->ipv4_address) {
    SAFE_STRNCPY(host->ipv4_address, config->ipv4_address, sizeof(host->ipv4_address));
  }
 
  if (config->ipv6_address) {
    SAFE_STRNCPY(host->ipv6_address, config->ipv6_address, sizeof(host->ipv6_address));
  }
 
  if (config->key_path) {
    SAFE_STRNCPY(host->key_path, config->key_path, sizeof(host->key_path));
  }
 
  if (config->password) {
    SAFE_STRNCPY(host->password, config->password, sizeof(host->password));
  }
 
  host->callbacks = config->callbacks;
  host->user_data = config->user_data;
 
  // Initialize sockets to invalid
  host->socket_v4 = INVALID_SOCKET_VALUE;
  host->socket_v6 = INVALID_SOCKET_VALUE;
  host->running = false;
 
  // Allocate client array
  host->clients = SAFE_CALLOC((size_t)host->max_clients, sizeof(session_host_client_t), session_host_client_t *);
 
  host->client_count = 0;
  host->next_client_id = 1;
 
  // Initialize mutex
  if (mutex_init(&host->clients_mutex) != 0) {
    SET_ERRNO(ERROR_THREAD, "Failed to initialize clients mutex");
    SAFE_FREE(host->clients);
    SAFE_FREE(host);
    return NULL;
  }
 
  host->initialized = true;
  return host;
}

References session_host::callbacks, session_host::client_count, session_host::clients, session_host::clients_mutex, session_host::encryption_enabled, session_host::initialized, session_host::ipv4_address, session_host::ipv6_address, session_host::key_path, session_host::max_clients, mutex_init(), session_host::next_client_id, session_host::password, session_host::port, session_host::running, SESSION_HOST_DEFAULT_MAX_CLIENTS, session_host::socket_v4, session_host::socket_v6, and session_host::user_data.

Referenced by discovery_session_become_host(), discovery_session_process(), and server_main().

session_host_destroy()

void session_host_destroy

(

session_host_t *

host

)

Definition at line 222 of file host.c.

                                                {
  if (!host) {
    return;
  }
 
  // Stop if running
  if (host->running) {
    session_host_stop(host);
  }
 
  // Clean up audio resources
  if (host->audio_ctx) {
    session_audio_destroy(host->audio_ctx);
    host->audio_ctx = NULL;
  }
  if (host->opus_decoder) {
    opus_codec_destroy(host->opus_decoder);
    host->opus_decoder = NULL;
  }
 
  // Close sockets
  if (host->socket_v4 != INVALID_SOCKET_VALUE) {
    socket_close(host->socket_v4);
    host->socket_v4 = INVALID_SOCKET_VALUE;
  }
  if (host->socket_v6 != INVALID_SOCKET_VALUE) {
    socket_close(host->socket_v6);
    host->socket_v6 = INVALID_SOCKET_VALUE;
  }
 
  // Free client array and per-client resources
  if (host->clients) {
    for (int i = 0; i < host->max_clients; i++) {
      if (host->clients[i].incoming_video) {
        image_destroy(host->clients[i].incoming_video);
        host->clients[i].incoming_video = NULL;
      }
      if (host->clients[i].incoming_audio) {
        ringbuffer_destroy(host->clients[i].incoming_audio);
        host->clients[i].incoming_audio = NULL;
      }
    }
    SAFE_FREE(host->clients);
  }
 
  // Destroy mutex
  mutex_destroy(&host->clients_mutex);
 
  // Clear sensitive data
  memset(host->password, 0, sizeof(host->password));
 
  host->initialized = false;
  SAFE_FREE(host);
}

References session_host::audio_ctx, session_host::clients, session_host::clients_mutex, image_destroy(), session_host_client_t::incoming_audio, session_host_client_t::incoming_video, session_host::initialized, session_host::max_clients, mutex_destroy(), opus_codec_destroy(), session_host::opus_decoder, session_host::password, ringbuffer_destroy(), session_host::running, session_audio_destroy(), session_host_stop(), session_host::socket_v4, and session_host::socket_v6.

Referenced by discovery_session_destroy(), and server_main().

session_host_find_client()

asciichat_error_t session_host_find_client	(	session_host_t *	host,
		uint32_t	client_id,
		session_host_client_info_t *	info
	)

Definition at line 1204 of file host.c.

                                                                                                                       {
  if (!host || !host->initialized || !info) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "session_host_find_client: invalid parameter");
  }
 
  mutex_lock(&host->clients_mutex);
 
  for (int i = 0; i < host->max_clients; i++) {
    if (host->clients[i].active && host->clients[i].client_id == client_id) {
      info->client_id = host->clients[i].client_id;
      SAFE_STRNCPY(info->ip_address, host->clients[i].ip_address, sizeof(info->ip_address));
      info->port = host->clients[i].port;
      info->video_active = host->clients[i].video_active;
      info->audio_active = host->clients[i].audio_active;
      info->connected_at = host->clients[i].connected_at;
 
      mutex_unlock(&host->clients_mutex);
      return ASCIICHAT_OK;
    }
  }
 
  mutex_unlock(&host->clients_mutex);
  return SET_ERRNO(ERROR_NOT_FOUND, "Client not found: %u", client_id);
}

References session_host_client_t::active, session_host_client_t::audio_active, session_host_client_t::client_id, session_host::clients, session_host::clients_mutex, session_host_client_t::connected_at, session_host::initialized, session_host_client_t::ip_address, session_host::max_clients, session_host_client_t::port, and session_host_client_t::video_active.

session_host_get_client_count()

int session_host_get_client_count

(

session_host_t *

host

)

Definition at line 1229 of file host.c.

                                                        {
  if (!host || !host->initialized) {
    return 0;
  }
  return host->client_count;
}

References session_host::client_count, and session_host::initialized.

session_host_get_client_ids()

int session_host_get_client_ids	(	session_host_t *	host,
		uint32_t *	ids,
		int	max_ids
	)

Definition at line 1236 of file host.c.

                                                                                  {
  if (!host || !host->initialized || !ids || max_ids <= 0) {
    return 0;
  }
 
  mutex_lock(&host->clients_mutex);
 
  int count = 0;
  for (int i = 0; i < host->max_clients && count < max_ids; i++) {
    if (host->clients[i].active) {
      ids[count++] = host->clients[i].client_id;
    }
  }
 
  mutex_unlock(&host->clients_mutex);
  return count;
}

References session_host_client_t::active, session_host_client_t::client_id, session_host::clients, session_host::clients_mutex, session_host::initialized, and session_host::max_clients.

session_host_get_client_transport()

acip_transport_t * session_host_get_client_transport	(	session_host_t *	host,
		uint32_t	client_id
	)

Definition at line 1441 of file host.c.

                                                                                              {
  if (!host || !host->initialized) {
    return NULL;
  }
 
  mutex_lock(&host->clients_mutex);
 
  // Find client with matching ID
  for (int i = 0; i < host->max_clients; i++) {
    if (host->clients[i].active && host->clients[i].client_id == client_id) {
      acip_transport_t *transport = host->clients[i].transport;
      mutex_unlock(&host->clients_mutex);
      return transport;
    }
  }
 
  mutex_unlock(&host->clients_mutex);
  return NULL;
}

References session_host_client_t::active, session_host_client_t::client_id, session_host::clients, session_host::clients_mutex, session_host::initialized, session_host::max_clients, and session_host_client_t::transport.

session_host_inject_audio()

asciichat_error_t session_host_inject_audio	(	session_host_t *	host,
		uint32_t	participant_id,
		const float *	samples,
		size_t	count
	)

Definition at line 1117 of file host.c.

                                                          {
  if (!host || !host->initialized || !samples || count == 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "session_host_inject_audio: invalid parameters");
  }
 
  mutex_lock(&host->clients_mutex);
 
  // Find memory participant
  for (int i = 0; i < host->max_clients; i++) {
    if (host->clients[i].active && host->clients[i].client_id == participant_id &&
        host->clients[i].participant_type == PARTICIPANT_TYPE_MEMORY) {
 
      if (!host->clients[i].incoming_audio) {
        mutex_unlock(&host->clients_mutex);
        return SET_ERRNO(ERROR_INVALID_STATE, "Memory participant has no audio buffer");
      }
 
      // Write samples to ringbuffer (one at a time)
      size_t written = 0;
      for (size_t j = 0; j < count; j++) {
        if (ringbuffer_write(host->clients[i].incoming_audio, &samples[j])) {
          written++;
        } else {
          break; // Buffer full
        }
      }
 
      if (written < count) {
        log_warn_every(NS_PER_MS_INT, "Audio ringbuffer full, dropped %zu samples", count - written);
      }
 
      host->clients[i].audio_active = true;
 
      mutex_unlock(&host->clients_mutex);
      return ASCIICHAT_OK;
    }
  }
 
  mutex_unlock(&host->clients_mutex);
  return SET_ERRNO(ERROR_NOT_FOUND, "Memory participant not found");
}

References session_host_client_t::active, session_host_client_t::audio_active, session_host_client_t::client_id, session_host::clients, session_host::clients_mutex, session_host_client_t::incoming_audio, session_host::initialized, session_host::max_clients, participant_id, session_host_client_t::participant_type, and ringbuffer_write().

session_host_inject_frame()

asciichat_error_t session_host_inject_frame	(	session_host_t *	host,
		uint32_t	participant_id,
		const image_t *	frame
	)

Definition at line 1072 of file host.c.

                                                                                                                 {
  if (!host || !host->initialized || !frame) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "session_host_inject_frame: invalid parameters");
  }
 
  mutex_lock(&host->clients_mutex);
 
  // Find memory participant
  for (int i = 0; i < host->max_clients; i++) {
    if (host->clients[i].active && host->clients[i].client_id == participant_id &&
        host->clients[i].participant_type == PARTICIPANT_TYPE_MEMORY) {
 
      if (!host->clients[i].incoming_video) {
        mutex_unlock(&host->clients_mutex);
        return SET_ERRNO(ERROR_INVALID_STATE, "Memory participant has no video buffer");
      }
 
      // Copy frame data into buffer
      image_t *dest = host->clients[i].incoming_video;
      if (dest->w != frame->w || dest->h != frame->h) {
        // Reallocate if size changed
        image_destroy(dest);
        dest = image_new(frame->w, frame->h);
        if (!dest) {
          host->clients[i].incoming_video = NULL;
          mutex_unlock(&host->clients_mutex);
          return SET_ERRNO(ERROR_MEMORY, "Failed to reallocate video buffer");
        }
        host->clients[i].incoming_video = dest;
      }
 
      // Copy pixel data
      memcpy(dest->pixels, frame->pixels, frame->w * frame->h * sizeof(rgb_pixel_t));
 
      host->clients[i].video_active = true;
 
      mutex_unlock(&host->clients_mutex);
      return ASCIICHAT_OK;
    }
  }
 
  mutex_unlock(&host->clients_mutex);
  return SET_ERRNO(ERROR_NOT_FOUND, "Memory participant not found");
}

References session_host_client_t::active, session_host_client_t::client_id, session_host::clients, session_host::clients_mutex, image_destroy(), image_new(), session_host_client_t::incoming_video, session_host::initialized, session_host::max_clients, participant_id, session_host_client_t::participant_type, and session_host_client_t::video_active.

session_host_is_running()

bool session_host_is_running

(

session_host_t *

host

)

Definition at line 917 of file host.c.

                                                   {
  if (!host || !host->initialized) {
    return false;
  }
  return host->running;
}

References session_host::initialized, and session_host::running.

session_host_remove_client()

asciichat_error_t session_host_remove_client	(	session_host_t *	host,
		uint32_t	client_id
	)

Definition at line 1160 of file host.c.

                                                                                       {
  if (!host || !host->initialized) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "session_host_remove_client: invalid host");
  }
 
  mutex_lock(&host->clients_mutex);
 
  for (int i = 0; i < host->max_clients; i++) {
    if (host->clients[i].active && host->clients[i].client_id == client_id) {
      // Invoke callback before removing
      mutex_unlock(&host->clients_mutex);
      if (host->callbacks.on_client_leave) {
        host->callbacks.on_client_leave(host, client_id, host->user_data);
      }
      mutex_lock(&host->clients_mutex);
 
      // Close socket
      if (host->clients[i].socket != INVALID_SOCKET_VALUE) {
        socket_close(host->clients[i].socket);
        host->clients[i].socket = INVALID_SOCKET_VALUE;
      }
 
      // Clean up media buffers
      if (host->clients[i].incoming_video) {
        image_destroy(host->clients[i].incoming_video);
        host->clients[i].incoming_video = NULL;
      }
      if (host->clients[i].incoming_audio) {
        ringbuffer_destroy(host->clients[i].incoming_audio);
        host->clients[i].incoming_audio = NULL;
      }
 
      host->clients[i].active = false;
      host->client_count--;
 
      mutex_unlock(&host->clients_mutex);
      return ASCIICHAT_OK;
    }
  }
 
  mutex_unlock(&host->clients_mutex);
  return SET_ERRNO(ERROR_NOT_FOUND, "Client not found: %u", client_id);
}

References session_host_client_t::active, session_host::callbacks, session_host::client_count, session_host_client_t::client_id, session_host::clients, session_host::clients_mutex, image_destroy(), session_host_client_t::incoming_audio, session_host_client_t::incoming_video, session_host::initialized, session_host::max_clients, ringbuffer_destroy(), session_host_client_t::socket, and session_host::user_data.

Referenced by remove_client().

session_host_send_frame()

asciichat_error_t session_host_send_frame	(	session_host_t *	host,
		uint32_t	client_id,
		const char *	frame
	)

Definition at line 1287 of file host.c.

                                                                                                       {
  if (!host || !host->initialized || !frame) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "session_host_send_frame: invalid parameter");
  }
 
  if (!host->running) {
    return SET_ERRNO(ERROR_INVALID_STATE, "session_host_send_frame: not running");
  }
 
  // Send ASCII frame to specific client
  size_t frame_len = strlen(frame) + 1; // Include null terminator
 
  mutex_lock(&host->clients_mutex);
  for (int i = 0; i < host->max_clients; i++) {
    if (host->clients[i].client_id == client_id && host->clients[i].active &&
        host->clients[i].socket != INVALID_SOCKET_VALUE) {
      asciichat_error_t result =
          packet_send(host->clients[i].socket, PACKET_TYPE_ASCII_FRAME, (const void *)frame, frame_len);
      mutex_unlock(&host->clients_mutex);
      return result;
    }
  }
  mutex_unlock(&host->clients_mutex);
 
  return SET_ERRNO(ERROR_NOT_FOUND, "session_host_send_frame: client %u not found", client_id);
}

References session_host_client_t::active, session_host_client_t::client_id, session_host::clients, session_host::clients_mutex, session_host::initialized, session_host::max_clients, packet_send(), session_host::running, and session_host_client_t::socket.

session_host_set_client_transport()

asciichat_error_t session_host_set_client_transport	(	session_host_t *	host,
		uint32_t	client_id,
		acip_transport_t *	transport
	)

Definition at line 1409 of file host.c.

                                                                                 {
  if (!host || !host->initialized) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Host is NULL or not initialized");
  }
 
  mutex_lock(&host->clients_mutex);
 
  // Find client with matching ID
  for (int i = 0; i < host->max_clients; i++) {
    if (host->clients[i].active && host->clients[i].client_id == client_id) {
      log_info("session_host_set_client_transport: Setting transport=%p for client %u (was=%p)", transport, client_id,
               host->clients[i].transport);
 
      host->clients[i].transport = transport;
 
      if (transport) {
        log_info("WebRTC transport now active for client %u", client_id);
      } else {
        log_info("WebRTC transport cleared for client %u, reverting to socket", client_id);
      }
 
      mutex_unlock(&host->clients_mutex);
      return ASCIICHAT_OK;
    }
  }
 
  mutex_unlock(&host->clients_mutex);
  log_warn("Client %u not found", client_id);
  return SET_ERRNO(ERROR_NOT_FOUND, "Client not found");
}

References session_host_client_t::active, session_host_client_t::client_id, session_host::clients, session_host::clients_mutex, session_host::initialized, session_host::max_clients, and session_host_client_t::transport.

session_host_start()

asciichat_error_t session_host_start

(

session_host_t *

host

)

Definition at line 797 of file host.c.

                                                           {
  if (!host || !host->initialized) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "session_host_start: invalid host");
  }
 
  if (host->running) {
    return ASCIICHAT_OK; // Already running
  }
 
  // Create listen socket(s)
  // For simplicity, we bind to IPv4 if specified, otherwise default to 0.0.0.0
  const char *bind_address = host->ipv4_address[0] ? host->ipv4_address : "0.0.0.0";
 
  host->socket_v4 = create_listen_socket(bind_address, host->port);
  if (host->socket_v4 == INVALID_SOCKET_VALUE) {
    log_error("Failed to create IPv4 listen socket");
    if (host->callbacks.on_error) {
      host->callbacks.on_error(host, ERROR_NETWORK_BIND, "Failed to create listen socket", host->user_data);
    }
    return GET_ERRNO();
  }
 
  host->running = true;
  log_info("Session host listening on %s:%d", bind_address, host->port);
 
  // Spawn accept loop thread
  host->accept_thread_running = true;
  if (asciichat_thread_create(&host->accept_thread, accept_loop_thread, host) != 0) {
    log_error("Failed to spawn accept loop thread");
    host->accept_thread_running = false;
    if (host->callbacks.on_error) {
      host->callbacks.on_error(host, ERROR_THREAD, "Failed to spawn accept loop thread", host->user_data);
    }
    socket_close(host->socket_v4);
    host->socket_v4 = INVALID_SOCKET_VALUE;
    host->running = false;
    return SET_ERRNO(ERROR_THREAD, "Failed to spawn accept loop thread");
  }
 
  // Spawn receive loop thread
  host->receive_thread_running = true;
  if (asciichat_thread_create(&host->receive_thread, receive_loop_thread, host) != 0) {
    log_error("Failed to spawn receive loop thread");
    host->receive_thread_running = false;
    host->accept_thread_running = false;
    asciichat_thread_join(&host->accept_thread, NULL);
    if (host->callbacks.on_error) {
      host->callbacks.on_error(host, ERROR_THREAD, "Failed to spawn receive loop thread", host->user_data);
    }
    socket_close(host->socket_v4);
    host->socket_v4 = INVALID_SOCKET_VALUE;
    host->running = false;
    return SET_ERRNO(ERROR_THREAD, "Failed to spawn receive loop thread");
  }
 
  // Spawn render thread (optional - can be started later)
  // This thread handles video mixing and audio distribution
  return ASCIICHAT_OK;
}

References session_host::accept_thread, session_host::accept_thread_running, asciichat_thread_create(), asciichat_thread_join(), session_host::callbacks, session_host::initialized, session_host::ipv4_address, session_host::port, session_host::receive_thread, session_host::receive_thread_running, session_host::running, session_host::socket_v4, and session_host::user_data.

Referenced by discovery_session_become_host(), and discovery_session_process().

session_host_start_render()

asciichat_error_t session_host_start_render

(

session_host_t *

host

)

Definition at line 1318 of file host.c.

                                                                  {
  if (!host || !host->initialized) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "session_host_start_render: invalid host");
  }
 
  if (!host->running) {
    return SET_ERRNO(ERROR_INVALID_STATE, "session_host_start_render: not running");
  }
 
  if (host->render_thread_running) {
    return ASCIICHAT_OK; // Already running
  }
 
  // Create audio context for mixing (host mode = true)
  if (!host->audio_ctx) {
    host->audio_ctx = session_audio_create(true);
    if (!host->audio_ctx) {
      return SET_ERRNO(ERROR_INVALID_STATE, "Failed to create audio context");
    }
  }
 
  // Create Opus decoder for decoding incoming Opus audio (48kHz)
  if (!host->opus_decoder) {
    host->opus_decoder = opus_codec_create_decoder(48000);
    if (!host->opus_decoder) {
      session_audio_destroy(host->audio_ctx);
      host->audio_ctx = NULL;
      return SET_ERRNO(ERROR_INVALID_STATE, "Failed to create Opus decoder");
    }
  }
 
  // Create Opus encoder for encoding mixed audio for broadcast (48kHz, VOIP mode, 24kbps)
  if (!host->opus_encoder) {
    host->opus_encoder = opus_codec_create_encoder(OPUS_APPLICATION_VOIP, 48000, 24000);
    if (!host->opus_encoder) {
      opus_codec_destroy(host->opus_decoder);
      host->opus_decoder = NULL;
      session_audio_destroy(host->audio_ctx);
      host->audio_ctx = NULL;
      return SET_ERRNO(ERROR_INVALID_STATE, "Failed to create Opus encoder");
    }
  }
 
  // Spawn render thread
  host->render_thread_running = true;
  if (asciichat_thread_create(&host->render_thread, host_render_thread, host) != 0) {
    log_error("Failed to spawn render thread");
    host->render_thread_running = false;
    return SET_ERRNO(ERROR_THREAD, "Failed to spawn render thread");
  }
 
  log_info("Host render thread started");
  return ASCIICHAT_OK;
}

References asciichat_thread_create(), session_host::audio_ctx, session_host::initialized, opus_codec_create_decoder(), opus_codec_create_encoder(), opus_codec_destroy(), session_host::opus_decoder, session_host::opus_encoder, session_host::render_thread, session_host::render_thread_running, session_host::running, session_audio_create(), and session_audio_destroy().

session_host_stop()

void session_host_stop

(

session_host_t *

host

)

Definition at line 857 of file host.c.

                                             {
  if (!host || !host->initialized || !host->running) {
    return;
  }
 
  // Stop render thread if running
  if (host->render_thread_running) {
    host->render_thread_running = false;
    asciichat_thread_join(&host->render_thread, NULL);
    log_info("Render thread joined");
  }
 
  // Stop receive loop thread (reads from client sockets)
  if (host->receive_thread_running) {
    host->receive_thread_running = false;
    asciichat_thread_join(&host->receive_thread, NULL);
    log_info("Receive loop thread joined");
  }
 
  // Stop accept loop thread (before closing listen socket)
  if (host->accept_thread_running) {
    host->accept_thread_running = false;
    asciichat_thread_join(&host->accept_thread, NULL);
    log_info("Accept loop thread joined");
  }
 
  // Disconnect all clients
  mutex_lock(&host->clients_mutex);
  for (int i = 0; i < host->max_clients; i++) {
    if (host->clients[i].active) {
      // Invoke callback
      if (host->callbacks.on_client_leave) {
        host->callbacks.on_client_leave(host, host->clients[i].client_id, host->user_data);
      }
 
      // Close socket
      if (host->clients[i].socket != INVALID_SOCKET_VALUE) {
        socket_close(host->clients[i].socket);
        host->clients[i].socket = INVALID_SOCKET_VALUE;
      }
 
      host->clients[i].active = false;
    }
  }
  host->client_count = 0;
  mutex_unlock(&host->clients_mutex);
 
  // Close listen sockets
  if (host->socket_v4 != INVALID_SOCKET_VALUE) {
    socket_close(host->socket_v4);
    host->socket_v4 = INVALID_SOCKET_VALUE;
  }
  if (host->socket_v6 != INVALID_SOCKET_VALUE) {
    socket_close(host->socket_v6);
    host->socket_v6 = INVALID_SOCKET_VALUE;
  }
 
  host->running = false;
}

References session_host::accept_thread, session_host::accept_thread_running, session_host_client_t::active, asciichat_thread_join(), session_host::callbacks, session_host::client_count, session_host_client_t::client_id, session_host::clients, session_host::clients_mutex, session_host::initialized, session_host::max_clients, session_host::receive_thread, session_host::receive_thread_running, session_host::render_thread, session_host::render_thread_running, session_host::running, session_host_client_t::socket, session_host::socket_v4, session_host::socket_v6, and session_host::user_data.

Referenced by session_host_destroy().

session_host_stop_render()

void session_host_stop_render

(

session_host_t *

host

)

Definition at line 1373 of file host.c.

                                                    {
  if (!host || !host->initialized) {
    return;
  }
 
  if (!host->render_thread_running) {
    return;
  }
 
  // Signal thread to stop
  host->render_thread_running = false;
 
  // Wait for thread to complete
  asciichat_thread_join(&host->render_thread, NULL);
 
  // Clean up audio resources
  if (host->audio_ctx) {
    session_audio_destroy(host->audio_ctx);
    host->audio_ctx = NULL;
  }
  if (host->opus_decoder) {
    opus_codec_destroy(host->opus_decoder);
    host->opus_decoder = NULL;
  }
  if (host->opus_encoder) {
    opus_codec_destroy(host->opus_encoder);
    host->opus_encoder = NULL;
  }
 
  log_info("Host render thread stopped");
}

References asciichat_thread_join(), session_host::audio_ctx, session_host::initialized, opus_codec_destroy(), session_host::opus_decoder, session_host::opus_encoder, session_host::render_thread, session_host::render_thread_running, and session_audio_destroy().