include/ascii-chat/network/acip/transport.h

Go to the documentation of this file.

 
#pragma once
#include <ascii-chat/network/acip/backpressure.h>
#include <ascii-chat/network/acip/traffic.h>
 
#include <ascii-chat/stats/runtime.h>
#include <libplatform/atomic.h>
#include "../../common.h"
#include "../../asciichat_errno.h"
#include "../../crypto/crypto.h"
#include "../../os/socket.h"
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>

typedef enum {
  ACIP_TRANSPORT_TCP = 1,       
  ACIP_TRANSPORT_WEBSOCKET = 2, 
  ACIP_TRANSPORT_WEBRTC = 3,    
  ACIP_TRANSPORT_HTTP = 4,      
  ACIP_TRANSPORT_QUIC = 5       
} acip_transport_type_t;

typedef struct acip_transport acip_transport_t;

typedef struct {
  bool independent_streams;
  bool datagrams;
  size_t max_datagram_payload;
} acip_transport_capabilities_t;

typedef enum {
  ACIP_TRANSPORT_BORROWED,
  ACIP_TRANSPORT_OWNED,
} acip_transport_ownership_t;

typedef struct {
  asciichat_error_t (*send)(acip_transport_t *transport, const void *data, size_t len);

  asciichat_error_t (*recv)(acip_transport_t *transport, void **buffer, size_t *out_len, void **out_allocated_buffer);

  asciichat_error_t (*close)(acip_transport_t *transport);

  void (*interrupt)(acip_transport_t *transport);

  acip_transport_type_t (*get_type)(acip_transport_t *transport);

  socket_t (*get_socket)(acip_transport_t *transport);

  bool (*is_connected)(acip_transport_t *transport);

  bool (*has_pending_data)(acip_transport_t *transport);

  asciichat_error_t (*sendv)(acip_transport_t *transport, const socket_buffer_t *buffers, size_t count);

  size_t (*queued_bytes)(acip_transport_t *transport);
  asciichat_error_t (*wait_writable)(acip_transport_t *transport, uint64_t timeout_ns);
  size_t reserved_bytes; 
  void (*destroy_impl)(acip_transport_t *transport);
  asciichat_error_t (*sendv_ex)(acip_transport_t *transport, const socket_buffer_t *buffers, size_t count,
                                const acip_send_options_t *options);
  asciichat_error_t (*get_capabilities)(acip_transport_t *transport, acip_transport_capabilities_t *out);
  asciichat_error_t (*validate_send_options)(acip_transport_t *transport, const acip_send_options_t *options);
  bool (*consume_keyframe_request)(acip_transport_t *transport, uint16_t type, uint32_t stream_id);
} acip_transport_methods_t;

struct acip_transport {
  struct acip_outbound *outbound;          
  stats_peer_t *stats_peer;                
  const acip_transport_methods_t *methods; 
  crypto_context_t *crypto_ctx;            
  atomic_t packet_security_active;         
  uint64_t receive_timeout_ns;  
  bool prefer_visual_datagrams; 
  bool prefer_audio_datagrams;  
  void *impl_data;              
  void *user_data;              
};
 
// =============================================================================
// Transport Lifecycle
// =============================================================================

void acip_transport_destroy(acip_transport_t *transport);
 
// =============================================================================
// Transport Operations (convenience wrappers)
// =============================================================================

asciichat_error_t acip_transport_sendv(acip_transport_t *transport, const socket_buffer_t *buffers, size_t count);

asciichat_error_t acip_transport_sendv_ex(acip_transport_t *transport, const socket_buffer_t *buffers, size_t count,
                                          const acip_send_options_t *options);

asciichat_error_t acip_transport_get_capabilities(acip_transport_t *transport, acip_transport_capabilities_t *out);
 
asciichat_error_t acip_transport_send(acip_transport_t *transport, const void *data, size_t len);

static inline asciichat_error_t acip_transport_recv(acip_transport_t *transport, void **buffer, size_t *out_len,
                                                    void **out_allocated_buffer) {
  if (!transport || !transport->methods || !transport->methods->recv) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid transport");
  }
  return transport->methods->recv(transport, buffer, out_len, out_allocated_buffer);
}

static inline asciichat_error_t acip_transport_close(acip_transport_t *transport) {
  if (!transport || !transport->methods || !transport->methods->close) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid transport");
  }
#ifndef __EMSCRIPTEN__
  acip_outbound_stop(transport);
#endif
  return transport->methods->close(transport);
}

static inline acip_transport_type_t acip_transport_get_type(acip_transport_t *transport) {
  if (!transport || !transport->methods || !transport->methods->get_type) {
    return (acip_transport_type_t)0;
  }
  return transport->methods->get_type(transport);
}

static inline void acip_transport_interrupt(acip_transport_t *transport) {
#ifndef __EMSCRIPTEN__
  acip_outbound_stop(transport);
#endif
  if (transport && transport->methods && transport->methods->interrupt)
    transport->methods->interrupt(transport);
}

static inline socket_t acip_transport_get_socket(acip_transport_t *transport) {
  if (!transport || !transport->methods || !transport->methods->get_socket) {
    return INVALID_SOCKET_VALUE;
  }
  return transport->methods->get_socket(transport);
}

static inline bool acip_transport_is_connected(acip_transport_t *transport) {
  if (!transport || !transport->methods || !transport->methods->is_connected) {
    return false;
  }
  return transport->methods->is_connected(transport);
}
 
static inline bool acip_transport_has_pending_data(acip_transport_t *transport) {
  if (!transport || !transport->methods || !transport->methods->has_pending_data) {
    return false;
  }
  return transport->methods->has_pending_data(transport);
}
 
// =============================================================================
// Transport Implementations (defined in separate files)
// =============================================================================

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

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

asciichat_error_t acip_tcp_transport_set_zerocopy(acip_transport_t *transport, bool enabled);

asciichat_error_t acip_websocket_transport_flush(acip_transport_t *transport, uint64_t timeout_ns);

typedef struct acip_websocket_runtime acip_websocket_runtime_t;
asciichat_error_t acip_websocket_runtime_create(acip_websocket_runtime_t **out);
void acip_websocket_runtime_destroy(acip_websocket_runtime_t **runtime);
 
acip_transport_t *acip_websocket_client_transport_create(const char *name, const char *url,
                                                         crypto_context_t *crypto_ctx);

struct lws;
acip_transport_t *acip_websocket_server_transport_create(const char *name, struct lws *wsi,
                                                         crypto_context_t *crypto_ctx);

struct webrtc_peer_connection;
struct webrtc_data_channel;
acip_transport_t *acip_webrtc_transport_create(struct webrtc_peer_connection *peer_conn,
                                               struct webrtc_data_channel *data_channel, crypto_context_t *crypto_ctx);