acds_handlers.c

Go to the documentation of this file.

 
#include <ascii-chat/network/acip/acds_handlers.h>
#include <ascii-chat/network/acip/messages.h>
#include <ascii-chat/network/acip/send.h>
#include <ascii-chat/network/acip/transport.h>
#include <ascii-chat/network/packet/packet.h>
#include <ascii-chat/log/log.h>
#include <ascii-chat/asciichat_errno.h>
#include <ascii-chat/common.h>
#include <ascii-chat/util/endian.h>
#include <string.h>
 
// =============================================================================
// ACDS Handler Function Types and Hash Table
// =============================================================================
 
// ACDS handler function signature
typedef asciichat_error_t (*acip_acds_handler_func_t)(const void *payload, size_t payload_len,
                                                      acip_transport_t *transport, const char *client_ip,
                                                      const acip_acds_callbacks_t *callbacks);
 
// Hash table for O(1) packet dispatch
#define ACDS_HASH_SIZE 32
#define ACDS_HANDLER_COUNT 11
 
typedef struct {
  packet_type_t key;   
  uint8_t handler_idx; 
} acds_hash_entry_t;
 
#define ACDS_HASH(type) ((type) % ACDS_HASH_SIZE)
 
static inline int acds_handler_hash_lookup(const acds_hash_entry_t *table, packet_type_t type) {
  uint32_t h = ACDS_HASH(type);
  for (int i = 0; i < ACDS_HASH_SIZE; i++) {
    uint32_t slot = (h + i) % ACDS_HASH_SIZE;
    if (table[slot].key == 0)
      return -1;
    if (table[slot].key == type)
      return table[slot].handler_idx;
  }
  return -1;
}
 
// =============================================================================
// Forward Declarations
// =============================================================================
 
static asciichat_error_t handle_acds_session_create(const void *payload, size_t payload_len,
                                                    acip_transport_t *transport, const char *client_ip,
                                                    const acip_acds_callbacks_t *callbacks);
static asciichat_error_t handle_acds_session_lookup(const void *payload, size_t payload_len,
                                                    acip_transport_t *transport, const char *client_ip,
                                                    const acip_acds_callbacks_t *callbacks);
static asciichat_error_t handle_acds_session_join(const void *payload, size_t payload_len, acip_transport_t *transport,
                                                  const char *client_ip, const acip_acds_callbacks_t *callbacks);
static asciichat_error_t handle_acds_session_leave(const void *payload, size_t payload_len, acip_transport_t *transport,
                                                   const char *client_ip, const acip_acds_callbacks_t *callbacks);
static asciichat_error_t handle_acds_webrtc_sdp(const void *payload, size_t payload_len, acip_transport_t *transport,
                                                const char *client_ip, const acip_acds_callbacks_t *callbacks);
static asciichat_error_t handle_acds_webrtc_ice(const void *payload, size_t payload_len, acip_transport_t *transport,
                                                const char *client_ip, const acip_acds_callbacks_t *callbacks);
static asciichat_error_t handle_acds_ping(const void *payload, size_t payload_len, acip_transport_t *transport,
                                          const char *client_ip, const acip_acds_callbacks_t *callbacks);
static asciichat_error_t handle_acds_pong(const void *payload, size_t payload_len, acip_transport_t *transport,
                                          const char *client_ip, const acip_acds_callbacks_t *callbacks);
static asciichat_error_t handle_acds_host_announcement(const void *payload, size_t payload_len,
                                                       acip_transport_t *transport, const char *client_ip,
                                                       const acip_acds_callbacks_t *callbacks);
static asciichat_error_t handle_acds_host_lost(const void *payload, size_t payload_len, acip_transport_t *transport,
                                               const char *client_ip, const acip_acds_callbacks_t *callbacks);
static asciichat_error_t handle_acds_network_quality(const void *payload, size_t payload_len,
                                                     acip_transport_t *transport, const char *client_ip,
                                                     const acip_acds_callbacks_t *callbacks);
 
// ACDS handler dispatch table
static const acip_acds_handler_func_t g_acds_handlers[ACDS_HANDLER_COUNT] = {
    handle_acds_ping,              // 0
    handle_acds_pong,              // 1
    handle_acds_session_create,    // 2
    handle_acds_session_lookup,    // 3
    handle_acds_session_join,      // 4
    handle_acds_session_leave,     // 5
    handle_acds_webrtc_sdp,        // 6
    handle_acds_webrtc_ice,        // 7
    handle_acds_host_announcement, // 8
    handle_acds_host_lost,         // 9
    handle_acds_network_quality,   // 10
};
 
// ACDS packet type -> handler index hash table
// clang-format off
static const acds_hash_entry_t g_acds_handler_hash[ACDS_HASH_SIZE] = {
    [9]  = {PACKET_TYPE_PING,                   0},   // hash(5001)=9
    [10] = {PACKET_TYPE_PONG,                   1},   // hash(5002)=10
    [13] = {PACKET_TYPE_ACIP_HOST_ANNOUNCEMENT, 8},   // hash(6061)=13
    [16] = {PACKET_TYPE_ACIP_SESSION_CREATE,    2},   // hash(6000)=16
    [17] = {PACKET_TYPE_ACIP_HOST_LOST,         9},   // hash(6065)=17
    [18] = {PACKET_TYPE_ACIP_SESSION_LOOKUP,    3},   // hash(6002)=18
    [20] = {PACKET_TYPE_ACIP_SESSION_JOIN,      4},   // hash(6004)=20
    [22] = {PACKET_TYPE_ACIP_SESSION_LEAVE,     5},   // hash(6006)=22
    [25] = {PACKET_TYPE_ACIP_WEBRTC_SDP,        6},   // hash(6009)=25
    [26] = {PACKET_TYPE_ACIP_WEBRTC_ICE,        7},   // hash(6010)=26
    [28] = {PACKET_TYPE_ACIP_NETWORK_QUALITY,   10},  // hash(6060)=28
};
// clang-format on
 
// =============================================================================
// Public API
// =============================================================================
 
asciichat_error_t acip_handle_acds_packet(acip_transport_t *transport, packet_type_t type, const void *payload,
                                          size_t payload_len, const char *client_ip,
                                          const acip_acds_callbacks_t *callbacks) {
  if (!callbacks) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid callbacks");
  }
 
  if (type == PACKET_TYPE_ACIP_NETWORK_QUALITY) {
    log_info("★ ACIP_HANDLE_ACDS_PACKET: Dispatching type=%u (NETWORK_QUALITY) from %s, payload_len=%zu", type,
             client_ip, payload_len);
  }
 
  // O(1) dispatch via hash table lookup
  int idx = acds_handler_hash_lookup(g_acds_handler_hash, type);
  if (idx < 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Unhandled ACDS packet type: %d from %s", type, client_ip);
  }
 
  if (type == PACKET_TYPE_ACIP_NETWORK_QUALITY) {
    log_info("★ ACIP_HANDLE_ACDS_PACKET: Found handler at index=%d", idx);
  }
 
  return g_acds_handlers[idx](payload, payload_len, transport, client_ip, callbacks);
}
 
// =============================================================================
// ACDS Handler Implementations
// =============================================================================
 
static asciichat_error_t handle_acds_session_create(const void *payload, size_t payload_len,
                                                    acip_transport_t *transport, const char *client_ip,
                                                    const acip_acds_callbacks_t *callbacks) {
  if (!callbacks->on_session_create) {
    return ASCIICHAT_OK;
  }
 
  if (payload_len < sizeof(acip_session_create_t)) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "SESSION_CREATE payload too small from %s", client_ip);
  }
 
  const acip_session_create_t *req = (const acip_session_create_t *)payload;
 
  // Multi-key protocol: validate parameters only for first key (key_index == 0)
  // total_keys > 0 indicates multi-key mode; skip validation for subsequent keys
  if (req->key_index == 0 || req->total_keys == 0) {
    // Validate session parameters for first key or single-key mode
    if (req->max_participants == 0 || req->max_participants > 32) {
      return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid max_participants: %u from %s (expected: 1-32)",
                       req->max_participants, client_ip);
    }
 
    if (req->session_type > 1) {
      return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid session_type: %u from %s (expected: 0=DIRECT_TCP or 1=WEBRTC)",
                       req->session_type, client_ip);
    }
 
    // Validate server port (0 = system assigned, 1-65535 = valid)
    // Allow 0 for auto-assignment during WEBRTC mode
    if (req->session_type == 0 && req->server_port == 0) {
      return SET_ERRNO(ERROR_INVALID_PARAM, "DIRECT_TCP session requires valid server_port from %s", client_ip);
    }
  }
 
  callbacks->on_session_create(req, transport, client_ip, callbacks->app_ctx);
  return ASCIICHAT_OK;
}
 
static asciichat_error_t handle_acds_session_lookup(const void *payload, size_t payload_len,
                                                    acip_transport_t *transport, const char *client_ip,
                                                    const acip_acds_callbacks_t *callbacks) {
  if (!callbacks->on_session_lookup) {
    return ASCIICHAT_OK;
  }
 
  if (payload_len < sizeof(acip_session_lookup_t)) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "SESSION_LOOKUP payload too small from %s", client_ip);
  }
 
  const acip_session_lookup_t *req = (const acip_session_lookup_t *)payload;
  callbacks->on_session_lookup(req, transport, client_ip, callbacks->app_ctx);
  return ASCIICHAT_OK;
}
 
static asciichat_error_t handle_acds_session_join(const void *payload, size_t payload_len, acip_transport_t *transport,
                                                  const char *client_ip, const acip_acds_callbacks_t *callbacks) {
  if (!callbacks->on_session_join) {
    return ASCIICHAT_OK;
  }
 
  if (payload_len < sizeof(acip_session_join_t)) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "SESSION_JOIN payload too small from %s", client_ip);
  }
 
  const acip_session_join_t *req = (const acip_session_join_t *)payload;
  callbacks->on_session_join(req, transport, client_ip, callbacks->app_ctx);
  return ASCIICHAT_OK;
}
 
static asciichat_error_t handle_acds_session_leave(const void *payload, size_t payload_len, acip_transport_t *transport,
                                                   const char *client_ip, const acip_acds_callbacks_t *callbacks) {
  if (!callbacks->on_session_leave) {
    return ASCIICHAT_OK;
  }
 
  if (payload_len < sizeof(acip_session_leave_t)) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "SESSION_LEAVE payload too small from %s", client_ip);
  }
 
  const acip_session_leave_t *req = (const acip_session_leave_t *)payload;
  callbacks->on_session_leave(req, transport, client_ip, callbacks->app_ctx);
  return ASCIICHAT_OK;
}
 
static asciichat_error_t handle_acds_webrtc_sdp(const void *payload, size_t payload_len, acip_transport_t *transport,
                                                const char *client_ip, const acip_acds_callbacks_t *callbacks) {
  if (!callbacks->on_webrtc_sdp) {
    return ASCIICHAT_OK;
  }
 
  if (payload_len < sizeof(acip_webrtc_sdp_t)) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "WEBRTC_SDP payload too small from %s", client_ip);
  }
 
  const acip_webrtc_sdp_t *sdp = (const acip_webrtc_sdp_t *)payload;
 
  // Validate sdp_len against actual payload size (convert from network byte order)
  uint16_t sdp_len_host = NET_TO_HOST_U16(sdp->sdp_len);
  size_t expected_size = sizeof(acip_webrtc_sdp_t) + sdp_len_host;
  if (expected_size > payload_len) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "WEBRTC_SDP size mismatch from %s: claims %u bytes but payload is %zu",
                     client_ip, sdp_len_host, payload_len);
  }
 
  callbacks->on_webrtc_sdp(sdp, payload_len, transport, client_ip, callbacks->app_ctx);
  return ASCIICHAT_OK;
}
 
static asciichat_error_t handle_acds_webrtc_ice(const void *payload, size_t payload_len, acip_transport_t *transport,
                                                const char *client_ip, const acip_acds_callbacks_t *callbacks) {
  if (!callbacks->on_webrtc_ice) {
    return ASCIICHAT_OK;
  }
 
  if (payload_len < sizeof(acip_webrtc_ice_t)) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "WEBRTC_ICE payload too small from %s", client_ip);
  }
 
  const acip_webrtc_ice_t *ice = (const acip_webrtc_ice_t *)payload;
 
  // Validate candidate_len against actual payload size (convert from network byte order)
  uint16_t candidate_len_host = NET_TO_HOST_U16(ice->candidate_len);
  size_t expected_size = sizeof(acip_webrtc_ice_t) + candidate_len_host;
  if (expected_size > payload_len) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "WEBRTC_ICE size mismatch from %s: claims %u bytes but payload is %zu",
                     client_ip, candidate_len_host, payload_len);
  }
 
  callbacks->on_webrtc_ice(ice, payload_len, transport, client_ip, callbacks->app_ctx);
  return ASCIICHAT_OK;
}
 
// Keepalive handlers for PING/PONG packets
static asciichat_error_t handle_acds_ping(const void *payload, size_t payload_len, acip_transport_t *transport,
                                          const char *client_ip, const acip_acds_callbacks_t *callbacks) {
  (void)payload;
  (void)payload_len;
  (void)transport;
  (void)callbacks;
 
  log_debug("★ PING received from %s", client_ip);
  // Simply acknowledge (log only) - client expects us to respond naturally
  return ASCIICHAT_OK;
}
 
static asciichat_error_t handle_acds_pong(const void *payload, size_t payload_len, acip_transport_t *transport,
                                          const char *client_ip, const acip_acds_callbacks_t *callbacks) {
  (void)payload;
  (void)payload_len;
  (void)transport;
  (void)callbacks;
 
  log_debug("★ PONG received from %s (heartbeat OK)", client_ip);
  // Simply acknowledge (log only) - used for timeout/heartbeat detection
  return ASCIICHAT_OK;
}
 
static asciichat_error_t handle_acds_host_announcement(const void *payload, size_t payload_len,
                                                       acip_transport_t *transport, const char *client_ip,
                                                       const acip_acds_callbacks_t *callbacks) {
  if (!callbacks->on_host_announcement) {
    return ASCIICHAT_OK;
  }
 
  if (payload_len < sizeof(acip_host_announcement_t)) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "HOST_ANNOUNCEMENT payload too small from %s", client_ip);
  }
 
  const acip_host_announcement_t *announcement = (const acip_host_announcement_t *)payload;
  callbacks->on_host_announcement(announcement, transport, client_ip, callbacks->app_ctx);
  return ASCIICHAT_OK;
}
 
static asciichat_error_t handle_acds_host_lost(const void *payload, size_t payload_len, acip_transport_t *transport,
                                               const char *client_ip, const acip_acds_callbacks_t *callbacks) {
  if (!callbacks->on_host_lost) {
    return ASCIICHAT_OK;
  }
 
  if (payload_len < sizeof(acip_host_lost_t)) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "HOST_LOST payload too small from %s", client_ip);
  }
 
  const acip_host_lost_t *host_lost = (const acip_host_lost_t *)payload;
  callbacks->on_host_lost(host_lost, transport, client_ip, callbacks->app_ctx);
  return ASCIICHAT_OK;
}
 
static asciichat_error_t handle_acds_network_quality(const void *payload, size_t payload_len,
                                                     acip_transport_t *transport, const char *client_ip,
                                                     const acip_acds_callbacks_t *callbacks) {
  if (!callbacks->on_network_quality) {
    return ASCIICHAT_OK;
  }
 
  if (payload_len < sizeof(acip_nat_quality_t)) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "NETWORK_QUALITY payload too small from %s", client_ip);
  }
 
  callbacks->on_network_quality(payload, payload_len, transport, client_ip, callbacks->app_ctx);
  return ASCIICHAT_OK;
}