transport.c File Reference

Go to the source code of this file.

Data Structures
struct	tcp_transport_data_t
	TCP transport implementation data. More...

Functions
acip_transport_t *	acip_tcp_transport_create (const char *name, socket_t sockfd, crypto_context_t *crypto_ctx)
	Create TCP transport from existing socket.
void	acip_transport_destroy (acip_transport_t *transport)
	Destroy transport and free all resources.

Function Documentation

acip_tcp_transport_create()

acip_transport_t * acip_tcp_transport_create	(	const char *	name,
		socket_t	sockfd,
		crypto_context_t *	crypto_ctx
	)

Create TCP transport from existing socket.

Parameters

name	Debug name for tracking this transport (required, e.g., "transport_client_5")
sockfd	Connected socket descriptor
crypto_ctx	Optional crypto context (may be NULL)

Returns

Transport instance or NULL on error

Note

Caller retains socket ownership (transport doesn't close on destroy)

Definition at line 398 of file tcp/transport.c.

                                                                                                             {
  if (!name) {
    SET_ERRNO(ERROR_INVALID_STATE, "Transport name is required");
    return NULL;
  }
 
  if (sockfd == INVALID_SOCKET_VALUE) {
    log_error("[TCP_CREATE_STATE] ❌ INVALID_SOCKET: sockfd=%d", sockfd);
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid socket descriptor");
    return NULL;
  }
 
  log_info("[TCP_CREATE_STATE] 🟢 CREATE_START: sockfd=%d, crypto=%s", sockfd, crypto_ctx ? "yes" : "no");
 
  // Allocate transport structure
  acip_transport_t *transport = SAFE_MALLOC(sizeof(acip_transport_t), acip_transport_t *);
  if (!transport) {
    log_error("[TCP_CREATE_STATE] ❌ ALLOC_TRANSPORT_FAILED: size=%zu", sizeof(acip_transport_t));
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate TCP transport");
    return NULL;
  }
 
  log_debug("[TCP_CREATE_STATE] 🟢 TRANSPORT_ALLOCATED: transport=%p", (void *)transport);
 
  // Allocate TCP-specific data
  tcp_transport_data_t *tcp_data = SAFE_MALLOC(sizeof(tcp_transport_data_t), tcp_transport_data_t *);
  if (!tcp_data) {
    log_error("[TCP_CREATE_STATE] ❌ ALLOC_TCP_DATA_FAILED: size=%zu", sizeof(tcp_transport_data_t));
    SAFE_FREE(transport);
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate TCP transport data");
    return NULL;
  }
 
  log_debug("[TCP_CREATE_STATE] 🟢 TCP_DATA_ALLOCATED: tcp_data=%p", (void *)tcp_data);
 
  // Initialize TCP data
  tcp_data->sockfd = sockfd;
  tcp_data->is_connected = true;
 
  // Initialize send mutex to protect concurrent sends from multiple threads
  int mutex_result = mutex_init(&tcp_data->send_mutex, "tcp_send");
  if (mutex_result != 0) {
    log_error("[TCP_CREATE_STATE] ❌ MUTEX_INIT_FAILED: result=%d", mutex_result);
    SAFE_FREE(tcp_data);
    SAFE_FREE(transport);
    SET_ERRNO(ERROR_MEMORY, "Failed to initialize send mutex");
    return NULL;
  }
 
  log_info("[TCP_CREATE_STATE] 🟢 TCP_DATA_INITIALIZED: sockfd=%d, is_connected=true, send_mutex=initialized", sockfd);
 
  // Enable TCP_NODELAY to disable Nagle's algorithm
  // This ensures small packets are sent immediately instead of being buffered
  int nodelay = 1;
  if (setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (const char *)&nodelay, sizeof(nodelay)) < 0) {
    log_warn("[TCP_CREATE_STATE] ⚠️  TCP_NODELAY_FAILED: sockfd=%d, %s", sockfd, SAFE_STRERROR(errno));
    // Continue anyway - this is not fatal
  } else {
    log_debug("[TCP_CREATE_STATE] 🟢 TCP_NODELAY_SET: sockfd=%d", sockfd);
  }
 
  // Initialize transport
  transport->methods = &tcp_methods;
  transport->crypto_ctx = crypto_ctx;
  transport->impl_data = tcp_data;
 
  // Register transport and impl_data before logging so named replacements work
  NAMED_REGISTER_TRANSPORT(transport, name, NULL);
  NAMED_REGISTER(tcp_data, "impl", "tcp_impl", "0x%tx", (uintptr_t)(const void *)(transport));
 
  log_info("[TCP_CREATE_STATE] ✅ CREATE_COMPLETE: transport=%p, sockfd=%d, is_connected=true, crypto=%s",
           (void *)transport, sockfd, crypto_ctx ? "enabled" : "disabled");
 
  return transport;
}

References errno, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, ERROR_MEMORY, INVALID_SOCKET_VALUE, tcp_transport_data_t::is_connected, log_debug, log_error, log_info, log_warn, mutex_init(), NAMED_REGISTER, NAMED_REGISTER_TRANSPORT, SAFE_FREE, SAFE_MALLOC, SAFE_STRERROR, tcp_transport_data_t::send_mutex, SET_ERRNO, and tcp_transport_data_t::sockfd.

Referenced by acds_client_connect(), acds_client_handler(), add_client(), connection_attempt_tcp(), and server_connection_establish().

acip_transport_destroy()

void acip_transport_destroy

(

acip_transport_t *

transport

)

Destroy transport and free all resources.

Parameters

transport

Transport to destroy (may be NULL)

Note

Calls close() first if still connected

Frees the transport structure itself

Safe to pass NULL

Definition at line 478 of file tcp/transport.c.

                                                         {
  if (!transport) {
    log_debug("[TRANSPORT_DESTROY] ⚠️  NULL_TRANSPORT: nothing to destroy");
    return;
  }
 
  log_warn("[TRANSPORT_DESTROY] 🔴 DESTROY_START: transport=%p, impl_data=%p", (void *)transport, transport->impl_data);
 
  // Get type before we destroy for logging
  acip_transport_type_t type = 0;
  if (transport->methods && transport->methods->get_type) {
    type = transport->methods->get_type(transport);
    log_info("[TRANSPORT_DESTROY] 📋 TRANSPORT_TYPE: type=%d (1=TCP, 2=WebSocket, 3=WebRTC, ...)", type);
  }
 
  // Close if still connected
  if (transport->methods && transport->methods->close && transport->methods->is_connected &&
      transport->methods->is_connected(transport)) {
    log_warn("[TRANSPORT_DESTROY] 🔴 STILL_CONNECTED: calling close() first (type=%d)", type);
    asciichat_error_t close_result = transport->methods->close(transport);
    log_info("[TRANSPORT_DESTROY] 🔴 CLOSE_CALLED: result=%d", close_result != ASCIICHAT_OK ? -1 : 0);
  } else {
    log_debug("[TRANSPORT_DESTROY] ✅ ALREADY_CLOSED: skipping close (type=%d)", type);
  }
 
  // Call custom destroy implementation if provided
  if (transport->methods && transport->methods->destroy_impl) {
    log_info("[TRANSPORT_DESTROY] 🔧 CALLING_DESTROY_IMPL: type=%d", type);
    transport->methods->destroy_impl(transport);
    log_info("[TRANSPORT_DESTROY] ✅ DESTROY_IMPL_COMPLETE: type=%d", type);
  } else {
    log_debug("[TRANSPORT_DESTROY] ⏭️  NO_CUSTOM_DESTROY: type=%d (using generic cleanup)", type);
  }
 
  // Free implementation data
  if (transport->impl_data) {
    log_debug("[TRANSPORT_DESTROY] 🗑️  FREEING_IMPL_DATA: %p", transport->impl_data);
    NAMED_UNREGISTER(transport->impl_data);
    SAFE_FREE(transport->impl_data);
    log_debug("[TRANSPORT_DESTROY] ✅ IMPL_DATA_FREED");
  }
 
  // Free transport structure
  log_debug("[TRANSPORT_DESTROY] 🗑️  FREEING_TRANSPORT: %p", (void *)transport);
  SAFE_FREE(transport);
 
  log_warn("[TRANSPORT_DESTROY] ✅ DESTROY_COMPLETE: type=%d", type);
}

References ASCIICHAT_OK, acip_transport_methods_t::close, acip_transport_methods_t::destroy_impl, acip_transport_methods_t::get_type, acip_transport::impl_data, acip_transport_methods_t::is_connected, log_debug, log_info, log_warn, acip_transport::methods, NAMED_UNREGISTER, and SAFE_FREE.

Referenced by acds_client_connect(), acds_client_disconnect(), acds_client_handler(), connection_attempt_tcp(), connection_handle_cleanup(), discovery_session_destroy(), discovery_session_process(), remove_client(), server_connection_close(), server_connection_establish(), server_connection_set_transport(), and session_participant_destroy().