ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
tcp/transport.c
Go to the documentation of this file.
12
17#include <ascii-chat/log/log.h>
18#include <libplatform/socket.h>
20#include <ascii-chat/buffer.h>
24#include <string.h>
25#include <options/options.h>
26
40
41static asciichat_error_t tcp_sendv(acip_transport_t *transport, const socket_buffer_t *buffers, size_t count) {
42 tcp_transport_data_t *tcp = transport->impl_data;
43 mutex_lock(&tcp->send_mutex);
44 if (!tcp->is_connected) {
45 mutex_unlock(&tcp->send_mutex);
46 return SET_ERRNO(ERROR_NETWORK, "TCP transport disconnected");
47 }
49 asciichat_error_t result = acip_packet_plan(transport->crypto_ctx, buffers, count, &plan);
50 if (result != ASCIICHAT_OK) {
51 mutex_unlock(&tcp->send_mutex);
52 return result;
53 }
55 if (!plan.encrypt) {
56 result = socket_sendv_all(tcp->sockfd, buffers, count, timeout);
57 } else {
58 size_t capacity = sizeof(packet_header_t) + plan.ciphertext_capacity;
59 socket_send_buffer_t wire = {0};
60 if (tcp->zerocopy_disabled || plan.domain) {
61 wire.data = buffer_alloc(plan.domain, capacity);
62 wire.capacity = capacity;
63 result = wire.data ? ASCIICHAT_OK : SET_ERRNO(ERROR_MEMORY, "Cannot allocate ciphertext");
64 } else {
65 result = socket_send_buffer_alloc(capacity, &wire);
66 }
67 if (result != ASCIICHAT_OK) {
68 mutex_unlock(&tcp->send_mutex);
69 return result;
70 }
71 size_t ciphertext_len = 0;
72 packet_header_t outer;
73 result = acip_packet_encrypt(transport->crypto_ctx, &plan, plan.domain, (uint8_t *)wire.data + sizeof(outer), plan.ciphertext_capacity, &outer, &ciphertext_len);
74 if (result != ASCIICHAT_OK) {
75 socket_send_buffer_free(&wire);
76 mutex_unlock(&tcp->send_mutex);
77 return result;
78 }
79 memcpy(wire.data, &outer, sizeof(outer));
80 size_t wire_len = sizeof(outer) + ciphertext_len;
81 bool supported = false, copied = false;
82 uint64_t send_start = time_get_ns();
83 result = ASCIICHAT_OK;
84 if (!tcp->zerocopy_disabled && !plan.domain && wire_len >= SOCKET_ZEROCOPY_THRESHOLD) {
85 result = socket_send_zerocopy(tcp->sockfd, &wire, wire_len, timeout, &supported, &copied);
86 tcp->zerocopy_disabled = !supported || copied;
87 log_debug("TCP zerocopy: supported=%d copied=%d bytes=%zu", supported, copied, wire_len);
88 }
89 if (result == ASCIICHAT_OK && !supported) {
90 socket_buffer_t slice = {wire.data, wire_len};
91 uint64_t elapsed = time_get_ns() - send_start;
92 result = elapsed >= timeout ? SET_ERRNO(ERROR_NETWORK_TIMEOUT, "TCP send deadline expired") : socket_sendv_all(tcp->sockfd, &slice, 1, timeout - elapsed);
93 }
94 socket_send_buffer_free(&wire);
95 }
96 if (result != ASCIICHAT_OK) {
97 tcp->is_connected = false;
98 socket_shutdown(tcp->sockfd, SHUT_RDWR);
99 result = SET_ERRNO(ERROR_NETWORK, "TCP packet transmission failed");
100 }
101 mutex_unlock(&tcp->send_mutex);
102 return result;
103}
104
105static asciichat_error_t tcp_send(acip_transport_t *transport, const void *data, size_t len) {
106 socket_buffer_t slice = {data, len};
107 return tcp_sendv(transport, &slice, 1);
108}
109
111 if (!transport || acip_transport_get_type(transport) != ACIP_TRANSPORT_TCP)
112 return SET_ERRNO(ERROR_INVALID_PARAM, "Expected TCP transport");
113 tcp_transport_data_t *tcp = transport->impl_data;
114 mutex_lock(&tcp->send_mutex);
116 mutex_unlock(&tcp->send_mutex);
117 return ASCIICHAT_OK;
118}
119
120static asciichat_error_t tcp_recv(acip_transport_t *transport, void **buffer, size_t *out_len, void **out_allocated_buffer) {
122
123 log_debug("[TCP_RECV_STATE] Entry: transport=%p, sockfd=%d, is_connected=%s", (void *)transport, tcp->sockfd, tcp->is_connected ? "true" : "false");
124
125 if (!tcp->is_connected) {
126 log_error("[TCP_RECV_STATE] ❌ DISCONNECTED: Cannot recv - transport marked disconnected! sockfd=%d", tcp->sockfd);
127 return SET_ERRNO(ERROR_NETWORK, "TCP transport not connected");
128 }
129
130 // Use secure packet receive with envelope
131 packet_envelope_t envelope;
132 bool enforce_encryption = (transport->crypto_ctx != NULL && transport->crypto_ctx->encrypt_data);
133 log_debug("[TCP_RECV_STATE] 📥 RECV_WAITING: sockfd=%d, enforce_encryption=%s", tcp->sockfd, enforce_encryption ? "yes" : "no");
134
135 uint64_t receive_timeout_ns = transport->receive_timeout_ns != 0 ? transport->receive_timeout_ns : RECV_TIMEOUT * NS_PER_SEC_INT;
137 packet_recv_result_t result = receive_packet_secure_with_timeout(tcp->sockfd, transport->crypto_ctx, enforce_encryption, &envelope, receive_timeout_ns);
138 log_debug("[TCP_RECV_STATE] 📥 RECV_RESULT: code=%d (0=success, -1=eof, -2=error, -3=security), data_size=%zu", result, result == PACKET_RECV_SUCCESS ? envelope.len : 0);
139
140 if (result != PACKET_RECV_SUCCESS) {
141 if (result == PACKET_RECV_EOF) {
142 tcp->is_connected = false;
143 log_warn("[TCP_RECV_STATE] ⚠️ RECV_EOF: Connection closed by remote (sockfd=%d)", tcp->sockfd);
144 return SET_ERRNO(ERROR_NETWORK, "Connection closed");
145 } else if (result == PACKET_RECV_SECURITY_VIOLATION) {
146 log_error("[TCP_RECV_STATE] ❌ RECV_SECURITY_VIOLATION: Crypto error on sockfd=%d", tcp->sockfd);
147 return SET_ERRNO(ERROR_CRYPTO, "Security violation");
148 } else {
151 }
152 // A non-timeout receive error is terminal for this stream. Retaining a
153 // connected state after the peer has gone away causes callers to retry a
154 // socket that can no longer deliver packets.
155 tcp->is_connected = false;
156 log_error("[TCP_RECV_STATE] ❌ RECV_FAILED: result=%d on sockfd=%d", result, tcp->sockfd);
157 return SET_ERRNO(ERROR_NETWORK, "Failed to receive packet");
158 }
159 }
160
161 if (envelope.consumed) {
162 buffer_release(envelope.allocated_buffer);
164 }
165 *buffer = envelope.data;
166 *out_len = envelope.len;
167 *out_allocated_buffer = envelope.allocated_buffer;
168
169 // The decrypted header remains at the allocation base. Return that complete
170 // packet directly rather than copying and releasing the envelope's storage.
171 if (envelope.data != envelope.allocated_buffer) {
172 *buffer = envelope.allocated_buffer;
173 *out_len = sizeof(packet_header_t) + envelope.len;
174 }
175 if (*out_len >= sizeof(packet_header_t)) {
176 const packet_header_t *hdr = (const packet_header_t *)*buffer;
177 log_debug("TCP received packet type=%u, bytes=%zu", NET_TO_HOST_U16(hdr->type), *out_len);
178 }
179
180 return ASCIICHAT_OK;
181}
182
183static asciichat_error_t tcp_close(acip_transport_t *transport) {
185
186 if (tcp->owns_socket && tcp->sockfd != INVALID_SOCKET_VALUE) {
187 socket_close(tcp->sockfd);
188 tcp->sockfd = INVALID_SOCKET_VALUE;
189 }
190
191 log_warn("[TCP_CLOSE_STATE] 🔴 CLOSE_REQUESTED: transport=%p, sockfd=%d, was_connected=%s", (void *)transport, tcp->sockfd, tcp->is_connected ? "yes" : "no");
192
193 if (!tcp->is_connected) {
194 log_debug("[TCP_CLOSE_STATE] ✅ CLOSE_IDEMPOTENT: transport already disconnected (sockfd=%d)", tcp->sockfd);
195 return ASCIICHAT_OK; // Already closed
196 }
197
198 // Borrowed sockets remain open for their owner.
199 log_warn("[TCP_CLOSE_STATE] 🔴 MARKING_DISCONNECTED: transport=%p, sockfd=%d (owned socket closed; borrowed socket "
200 "retained)",
201 (void *)transport, tcp->sockfd);
202 tcp->is_connected = false;
203
204 log_warn("[TCP_CLOSE_STATE] ✅ CLOSE_COMPLETE: TCP transport marked as disconnected. transport=%p, sockfd=%d", (void *)transport, tcp->sockfd);
205 return ASCIICHAT_OK;
206}
207
208static acip_transport_type_t tcp_get_type(acip_transport_t *transport) {
209 (void)transport;
210 return ACIP_TRANSPORT_TCP;
211}
212
213static socket_t tcp_get_socket(acip_transport_t *transport) {
215 return tcp->sockfd;
216}
217
218static bool tcp_is_connected(acip_transport_t *transport) {
220 bool result = tcp->is_connected;
221 log_debug_every(LOG_RATE_FAST, "transport=%p, sockfd=%d, result=%s", (void *)transport, tcp->sockfd, result ? "true" : "false");
222 return result;
223}
224
225static bool tcp_has_pending_data(acip_transport_t *transport) {
227 if (!tcp || !socket_is_valid(tcp->sockfd)) {
228 return false;
229 }
230
231 fd_set readfds;
232 struct timeval tv = {0};
233 socket_fd_zero(&readfds);
234 socket_fd_set(tcp->sockfd, &readfds);
235
236 int select_result = socket_select(tcp->sockfd, &readfds, NULL, NULL, &tv);
237 return select_result > 0 && socket_fd_isset(tcp->sockfd, &readfds);
238}
239
240static void tcp_destroy_impl(acip_transport_t *transport) {
242 if (tcp) {
243 // Receive errors may have cleared is_connected before destruction.
244 if (tcp->owns_socket)
245 tcp_close(transport);
246 // Destroy the send mutex
247 int result = mutex_destroy(&tcp->send_mutex);
248 if (result != 0) {
249 log_warn("[TCP_DESTROY] ⚠️ MUTEX_DESTROY_FAILED: result=%d", result);
250 }
251 }
252}
253
254// =============================================================================
255// TCP Transport Method Table
256// =============================================================================
257
258static void tcp_interrupt(acip_transport_t *transport) {
259 tcp_transport_data_t *tcp = transport->impl_data;
260 if (tcp->sockfd != INVALID_SOCKET_VALUE)
261 socket_shutdown(tcp->sockfd, SHUT_RDWR);
262}
263
264static const acip_transport_methods_t tcp_methods = {
265 .send = tcp_send,
266 .reserved_bytes = SOCKET_STREAM_SEND_RESERVE,
267 .sendv = tcp_sendv,
268 .recv = tcp_recv,
269 .close = tcp_close,
270 .interrupt = tcp_interrupt,
271 .get_type = tcp_get_type,
272 .get_socket = tcp_get_socket,
273 .is_connected = tcp_is_connected,
274 .has_pending_data = tcp_has_pending_data,
275 .destroy_impl = tcp_destroy_impl, // Destroy send_mutex
276};
277
278// =============================================================================
279// TCP Transport Creation
280// =============================================================================
281
283 if (!name) {
284 SET_ERRNO(ERROR_INVALID_STATE, "Transport name is required");
285 return NULL;
286 }
287
288 if (sockfd == INVALID_SOCKET_VALUE) {
289 log_error("[TCP_CREATE_STATE] ❌ INVALID_SOCKET: sockfd=%d", sockfd);
290 SET_ERRNO(ERROR_INVALID_PARAM, "Invalid socket descriptor");
291 return NULL;
292 }
293
294 log_info("[TCP_CREATE_STATE] 🟢 CREATE_START: sockfd=%d, crypto=%s", sockfd, crypto_ctx ? "yes" : "no");
295
296 // Allocate transport structure
298 if (!transport) {
299 log_error("[TCP_CREATE_STATE] ❌ ALLOC_TRANSPORT_FAILED: size=%zu", sizeof(acip_transport_t));
300 SET_ERRNO(ERROR_MEMORY, "Failed to allocate TCP transport");
301 return NULL;
302 }
303
304 log_debug("[TCP_CREATE_STATE] 🟢 TRANSPORT_ALLOCATED: transport=%p", (void *)transport);
305
306 // Allocate TCP-specific data
308 if (!tcp_data) {
309 log_error("[TCP_CREATE_STATE] ❌ ALLOC_TCP_DATA_FAILED: size=%zu", sizeof(tcp_transport_data_t));
310 SAFE_FREE(transport);
311 SET_ERRNO(ERROR_MEMORY, "Failed to allocate TCP transport data");
312 return NULL;
313 }
314
315 log_debug("[TCP_CREATE_STATE] 🟢 TCP_DATA_ALLOCATED: tcp_data=%p", (void *)tcp_data);
316
317 // Initialize TCP data
318 tcp_data->sockfd = sockfd;
319 tcp_data->is_connected = true;
320 tcp_data->owns_socket = false;
321 tcp_data->zerocopy_disabled = false;
322
323 // Initialize send mutex to protect concurrent sends from multiple threads
324 int mutex_result = mutex_init(&tcp_data->send_mutex, "tcp_send");
325 if (mutex_result != 0) {
326 log_error("[TCP_CREATE_STATE] ❌ MUTEX_INIT_FAILED: result=%d", mutex_result);
327 SAFE_FREE(tcp_data);
328 SAFE_FREE(transport);
329 SET_ERRNO(ERROR_MEMORY, "Failed to initialize send mutex");
330 return NULL;
331 }
332
333 log_info("[TCP_CREATE_STATE] 🟢 TCP_DATA_INITIALIZED: sockfd=%d, is_connected=true, send_mutex=initialized", sockfd);
334
335 // Enable TCP_NODELAY to disable Nagle's algorithm
336 // This ensures small packets are sent immediately instead of being buffered
337 int nodelay = 1;
338 if (setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (const char *)&nodelay, sizeof(nodelay)) < 0) {
339 log_warn("[TCP_CREATE_STATE] ⚠️ TCP_NODELAY_FAILED: sockfd=%d, %s", sockfd, SAFE_STRERROR(errno));
340 // Continue anyway - this is not fatal
341 } else {
342 log_debug("[TCP_CREATE_STATE] 🟢 TCP_NODELAY_SET: sockfd=%d", sockfd);
343 }
344
345 // Initialize transport
346 transport->methods = &tcp_methods;
347 transport->stats_peer = stats_runtime_peer_open("TCP");
348 transport->crypto_ctx = crypto_ctx;
349 transport->impl_data = tcp_data;
350 int send_buffer = SOCKET_STREAM_SEND_BUFFER;
351 if (socket_setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &send_buffer, sizeof(send_buffer)) != 0) {
352 acip_transport_destroy(transport);
353 SET_ERRNO_SYS(ERROR_NETWORK, "Cannot bound TCP send buffer");
354 return NULL;
355 }
356
357 // Register transport and impl_data before logging so named replacements work
358 NAMED_REGISTER_TRANSPORT(transport, name, NULL);
359 NAMED_REGISTER(tcp_data, "impl", "tcp_impl", "0x%tx", (uintptr_t)(const void *)(transport));
360
361 log_info("[TCP_CREATE_STATE] ✅ CREATE_COMPLETE: transport=%p, sockfd=%d, is_connected=true, crypto=%s", (void *)transport, sockfd, crypto_ctx ? "enabled" : "disabled");
362
363#ifndef __EMSCRIPTEN__
364 if (transport && acip_outbound_create(transport) != ASCIICHAT_OK) {
365 acip_transport_destroy(transport);
366 return NULL;
367 }
368#endif
369 return transport;
370}
371
373 acip_transport_t *transport = acip_tcp_transport_create(name, sockfd, crypto_ctx);
374 if (transport)
375 ((tcp_transport_data_t *)transport->impl_data)->owns_socket = true;
376 return transport;
377}
378
379// =============================================================================
380// Transport Destroy (shared implementation)
381// =============================================================================
382
384 if (!transport) {
385 log_debug("[TRANSPORT_DESTROY] ⚠️ NULL_TRANSPORT: nothing to destroy");
386 return;
387 }
388
389 log_debug("[TRANSPORT_DESTROY] 🔴 DESTROY_START: transport=%p, impl_data=%p", (void *)transport, transport->impl_data);
390
391#ifndef __EMSCRIPTEN__
392 acip_outbound_destroy(transport);
393#endif
394
395 // Get type before we destroy for logging
396 acip_transport_type_t type = 0;
397 if (transport->methods && transport->methods->get_type) {
398 type = transport->methods->get_type(transport);
399 log_debug("[TRANSPORT_DESTROY] 📋 TRANSPORT_TYPE: type=%d (1=TCP, 2=WebSocket, 3=WebRTC, ...)", type);
400 }
401
402 // Close if still connected
403 if (transport->methods && transport->methods->close && transport->methods->is_connected && transport->methods->is_connected(transport)) {
404 log_debug("[TRANSPORT_DESTROY] 🔴 STILL_CONNECTED: calling close() first (type=%d)", type);
405 asciichat_error_t close_result = transport->methods->close(transport);
406 if (close_result != ASCIICHAT_OK)
407 log_warn("Transport close during cleanup failed: %d", close_result);
408 log_debug("[TRANSPORT_DESTROY] 🔴 CLOSE_CALLED: result=%d", close_result != ASCIICHAT_OK ? -1 : 0);
409 } else {
410 log_debug("[TRANSPORT_DESTROY] ✅ ALREADY_CLOSED: skipping close (type=%d)", type);
411 }
412
413 // Call custom destroy implementation if provided
414 if (transport->methods && transport->methods->destroy_impl) {
415 log_debug("[TRANSPORT_DESTROY] 🔧 CALLING_DESTROY_IMPL: type=%d", type);
416 transport->methods->destroy_impl(transport);
417 log_debug("[TRANSPORT_DESTROY] ✅ DESTROY_IMPL_COMPLETE: type=%d", type);
418 } else {
419 log_debug("[TRANSPORT_DESTROY] ⏭️ NO_CUSTOM_DESTROY: type=%d (using generic cleanup)", type);
420 }
421
422 // Free implementation data
423 if (transport->impl_data) {
424 log_debug("[TRANSPORT_DESTROY] 🗑️ FREEING_IMPL_DATA: %p", transport->impl_data);
425 NAMED_UNREGISTER(transport->impl_data);
426 SAFE_FREE(transport->impl_data);
427 log_debug("[TRANSPORT_DESTROY] ✅ IMPL_DATA_FREED");
428 }
429
431 transport->stats_peer = NULL;
432
433 // Free transport structure
434 log_debug("[TRANSPORT_DESTROY] 🗑️ FREEING_TRANSPORT: %p", (void *)transport);
435 SAFE_FREE(transport);
436
437 log_debug("[TRANSPORT_DESTROY] ✅ DESTROY_COMPLETE: type=%d", type);
438}
asciichat_errno_scope_t errno_checkpoint(void)
#define SET_ERRNO(code,...)
#define GET_ERRNO()
#define SET_ERRNO_SYS(code,...)
#define HAS_ERRNO_CODE_SINCE(scope, code)
void acip_outbound_destroy(acip_transport_t *transport)
asciichat_error_t acip_outbound_create(acip_transport_t *transport)
void * buffer_alloc(buffer_domain_t *domain, size_t size)
Definition buffer.c:272
#define buffer_release(data)
Definition buffer.h:99
int socket_shutdown(socket_t sock, int how)
bool socket_is_valid(socket_t sock)
int socket_close(socket_t sock)
Hardware-Accelerated CRC32 Checksum Computation.
Named object registry for debugging — log identifiable resource names.
🔄 Network byte order conversion helpers
#define NET_TO_HOST_U16(val)
Definition endian.h:115
bool enabled
Is filtering active?
Definition grep.c:62
#define SAFE_FREE(ptr)
#define SAFE_MALLOC(size, cast)
#define SAFE_STRERROR(errnum)
#define SAFE_CALLOC(count, size, cast)
unsigned long long uint64_t
unsigned char uint8_t
#define NAMED_REGISTER_TRANSPORT(transport, name, parent_ptr)
Register a transport with automatic format specifier.
#define NAMED_REGISTER(ptr, name, type, fmt, parent_ptr)
Register any pointer with base name, type, format spec, and location (auto-suffix).
#define NAMED_UNREGISTER(ptr)
Unregister a pointer.
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48
@ ERROR_INVALID_STATE
@ ERROR_NETWORK_INCOMPLETE
Definition error_codes.h:94
@ ERROR_NETWORK
Definition error_codes.h:76
@ ERROR_MEMORY
Definition error_codes.h:55
@ ASCIICHAT_OK
Definition error_codes.h:50
@ ERROR_CRYPTO
Definition error_codes.h:97
@ ERROR_INVALID_PARAM
@ ERROR_NETWORK_TIMEOUT
Definition error_codes.h:79
#define LOG_RATE_FAST
Log rate limit: 1 second (1,000,000 microseconds).
Definition log_rates.h:30
#define log_warn(...)
Log a WARN message.
Definition log/log.h:615
#define log_error(...)
Log an ERROR message.
Definition log/log.h:628
#define log_info(...)
Log an INFO message.
Definition log/log.h:602
#define log_debug(...)
Log a DEBUG message.
Definition log/log.h:589
#define NS_PER_SEC_INT
Definition time.h:173
#define RECV_TIMEOUT
Receive timeout in seconds (1 second).
Definition network.h:133
packet_recv_result_t
packet envelope is intentionally a small, concrete record. Fields such as type, data,...
Definition packet.h:1231
@ PACKET_RECV_EOF
Connection closed (EOF).
Definition packet.h:1235
@ PACKET_RECV_SECURITY_VIOLATION
Encryption policy violation (e.g., unencrypted packet when encryption required).
Definition packet.h:1239
@ PACKET_RECV_SUCCESS
Packet received successfully.
Definition packet.h:1233
struct acip_transport acip_transport_t
Forward declaration of ACIP transport.
Definition host.h:508
int socket_t
Transport abstraction layer for ACIP protocol.
acip_transport_type_t
Transport method table (virtual function table).
@ ACIP_TRANSPORT_TCP
Raw TCP socket.
📝 Logging API with multiple log levels and terminal output control
#define log_debug_every(interval_us, fmt,...)
Rate-limited DEBUG logging.
Definition log/log.h:743
🌐 Core network I/O operations with timeout support
⚙️ Unified options parsing system for ascii-chat with builder pattern and lock-free access
packet_recv_result_t receive_packet_secure_with_timeout(socket_t sockfd, void *crypto_ctx, bool enforce_encryption, packet_envelope_t *envelope, uint64_t timeout_ns)
Definition packet.c:1106
uint64_t packet_send_timeout_ns(size_t packet_size)
Definition packet.c:111
asciichat_error_t acip_packet_plan(crypto_context_t *crypto, const socket_buffer_t *buffers, size_t count, acip_packet_plan_t *plan)
Definition prepare.c:9
asciichat_error_t acip_packet_encrypt(crypto_context_t *crypto, const acip_packet_plan_t *plan, buffer_domain_t *domain, void *ciphertext, size_t capacity, packet_header_t *header, size_t *length)
The useful part of acip packet plan is in buffers, count, plaintext_size, ciphertext_capacity: togeth...
Definition prepare.c:53
void stats_runtime_peer_close(stats_peer_t *peer)
Definition runtime.c:177
stats_peer_t * stats_runtime_peer_open(const char *transport)
Definition runtime.c:149
🔤 String Manipulation and Shell Escaping Utilities
size_t ciphertext_capacity
Definition prepare.h:24
buffer_domain_t * domain
Borrowed control reserve for handshake/error traffic; NULL otherwise.
Definition prepare.h:29
size_t plaintext_size
Definition prepare.h:23
Transport method table (virtual function table).
bool(* is_connected)(acip_transport_t *transport)
Check if transport is connected.
asciichat_error_t(* close)(acip_transport_t *transport)
Close this transport.
void(* destroy_impl)(acip_transport_t *transport)
acip_transport_type_t(* get_type)(acip_transport_t *transport)
Get transport type.
void * impl_data
Transport-specific state.
stats_peer_t * stats_peer
Owned statistics handle, destroyed with transport.
const acip_transport_methods_t * methods
Method table (virtual functions).
crypto_context_t * crypto_ctx
Optional encryption context.
uint64_t receive_timeout_ns
Optional TCP receive timeout override; zero uses the normal polling timeout.
When code needs to work with asciichat errno snapshot, it keeps total, copied here instead of scatter...
Endpoint cryptographic state for handshake, packet protection, authentication, and rekeying.
Packet envelope containing received packet data.
Definition packet.h:1204
Fixed prefix shared by every ACIP packet on the wire.
Definition packet.h:641
uint16_t type
Packet type (packet_type_t enumeration).
Definition packet.h:645
tcp transport data is intentionally a small, concrete record. Fields such as sockfd,...
bool owns_socket
Close the socket when this transport is closed or destroyed.
socket_t sockfd
Connected socket descriptor.
bool is_connected
Connection state.
mutex_t send_mutex
Mutex to protect concurrent sends (multiple threads may send packets).
bool zerocopy_disabled
Disable copy avoidance after unsupported or copied completion.
asciichat_error_t acip_tcp_transport_set_zerocopy(acip_transport_t *transport, bool enabled)
acip_transport_t * acip_tcp_transport_create(const char *name, socket_t sockfd, crypto_context_t *crypto_ctx)
Create TCP transport from existing socket.
acip_transport_t * acip_tcp_transport_create_owned(const char *name, socket_t sockfd, crypto_context_t *crypto_ctx)
Create a TCP transport that owns its connected socket.
void acip_transport_destroy(acip_transport_t *transport)
Destroy transport and free all resources.