ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
browser/transport.c
Go to the documentation of this file.
4#include <ascii-chat/buffer.h>
8#include <string.h>
9
10#define BROWSER_TRANSPORT_MAX_QUEUED_BYTES (4u * 1024u * 1024u)
11
19
33
34static bool browser_connected(acip_transport_t *transport) {
35 const browser_transport_t *browser = transport ? transport->impl_data : NULL;
36 return browser && (browser->state == BROWSER_TRANSPORT_HANDSHAKE || browser->state == BROWSER_TRANSPORT_CONNECTED);
37}
38
39static void browser_transport_output_pop_internal(browser_transport_t *browser);
40
41static asciichat_error_t browser_send(acip_transport_t *transport, const void *data, size_t length) {
42 browser_transport_t *browser = transport->impl_data;
43 socket_buffer_t input = {.data = data, .len = length};
45 crypto_context_t *send_crypto = transport->crypto_ctx && transport->crypto_ctx->handshake_complete ? transport->crypto_ctx : NULL;
46 asciichat_error_t result = acip_packet_plan(send_crypto, &input, 1, &plan);
47 if (result != ASCIICHAT_OK)
48 return result;
49 const size_t output_length = plan.encrypt ? sizeof(packet_header_t) + plan.ciphertext_capacity : length;
50 if (!browser_transport_writable(browser, output_length)) {
51 browser->dropped_packets++;
52 browser->dropped_bytes += length;
53 return SET_ERRNO(ERROR_NETWORK_SIZE, "Browser transport output queue is full");
54 }
55 browser_output_t *output = SAFE_CALLOC(1, sizeof(*output), browser_output_t *);
56 if (!output)
57 return SET_ERRNO(ERROR_MEMORY, "Cannot allocate browser transport output");
58 output->length = output_length;
59 output->traffic_class = plan.options.traffic_class;
60 output->delivery = plan.options.delivery;
61 output->data = buffer_alloc(plan.domain, output->length);
62 if (!output->data) {
63 SAFE_FREE(output);
64 return SET_ERRNO(ERROR_MEMORY, "Cannot allocate browser transport packet");
65 }
66 if (plan.encrypt) {
67 packet_header_t header;
68 size_t encrypted_length = 0;
69 result = acip_packet_encrypt(transport->crypto_ctx, &plan, plan.domain, (uint8_t *)output->data + sizeof(header), plan.ciphertext_capacity, &header, &encrypted_length);
70 if (result != ASCIICHAT_OK) {
71 buffer_release(output->data);
72 SAFE_FREE(output);
73 return result;
74 }
75 memcpy(output->data, &header, sizeof(header));
76 output->length = sizeof(header) + encrypted_length;
77 } else {
78 memcpy(output->data, data, length);
79 }
80 if (browser->tail)
81 browser->tail->next = output;
82 else
83 browser->output = output;
84 browser->tail = output;
85 browser->queued_bytes += output->length;
86 browser->accepted_packets++;
87 return ASCIICHAT_OK;
88}
89
90static asciichat_error_t browser_capabilities(acip_transport_t *transport, acip_transport_capabilities_t *out) {
91 browser_transport_t *browser = transport ? transport->impl_data : NULL;
92 if (!browser || !out)
93 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid browser transport capabilities query");
94 *out = (acip_transport_capabilities_t){.independent_streams = true, .datagrams = browser->datagrams, .max_datagram_payload = browser->max_datagram_payload};
95 return ASCIICHAT_OK;
96}
97
98static const acip_transport_methods_t browser_methods = {.send = browser_send, .is_connected = browser_connected, .get_capabilities = browser_capabilities};
99
101 browser_transport_t *browser = SAFE_CALLOC(1, sizeof(*browser), browser_transport_t *);
102 if (!browser)
103 return NULL;
104 browser->transport.methods = &browser_methods;
105 browser->transport.impl_data = browser;
106 return browser;
107}
108
112
114 if (browser)
115 browser->state = state;
116}
117
118void browser_transport_set_capabilities(browser_transport_t *browser, bool datagrams, size_t max_datagram_payload) {
119 if (!browser)
120 return;
121 browser->datagrams = datagrams && max_datagram_payload != 0;
122 browser->max_datagram_payload = browser->datagrams ? max_datagram_payload : 0;
123}
124
126 return browser ? browser->queued_bytes : 0;
127}
128
129bool browser_transport_writable(const browser_transport_t *browser, size_t additional_bytes) {
131}
132
136
138 return browser && (browser->state == BROWSER_TRANSPORT_HANDSHAKE || browser->state == BROWSER_TRANSPORT_CONNECTED);
139}
140
142 browser_transport_output_pop_internal(browser);
143}
144
146 if (!browser || !browser->transport.crypto_ctx)
147 return SET_ERRNO(ERROR_INVALID_STATE, "Browser transport security is unavailable");
148 crypto_session_t *session = NULL;
149 const asciichat_error_t result = crypto_session_lock(browser->transport.crypto_ctx, &session);
150 if (result == ASCIICHAT_OK)
151 crypto_session_unlock(session);
152 return result;
153}
154
155asciichat_error_t browser_transport_security_packet(browser_transport_t *browser, bool seal, uint32_t channel, uint32_t delivery, const uint8_t *packet, size_t length, uint8_t *output,
156 size_t capacity, size_t *out_length, uint64_t *sequence) {
157 if (!browser || !browser->transport.crypto_ctx)
158 return SET_ERRNO(ERROR_INVALID_STATE, "Browser transport security is unavailable");
159 const size_t overhead = sizeof(packet_header_t) + 32 + CRYPTO_NONCE_SIZE + CRYPTO_MAC_SIZE;
160 if (!packet || !output || !out_length || !sequence || length > SIZE_MAX - overhead || capacity < length + (seal ? overhead : 0))
161 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid browser security packet buffer");
162 *out_length = 0;
163 *sequence = 0;
164 uint8_t *result_packet = NULL;
165 size_t result_length = 0;
166 bool consumed = false;
167 const bool quiet = !seal && delivery == ACIP_DELIVERY_DATAGRAM;
169 if (quiet)
170 scope = errno_scope_begin();
171 const asciichat_error_t result = seal ? acip_security_seal(browser->transport.crypto_ctx, channel, delivery, packet, length, &result_packet, &result_length)
172 : acip_security_open(browser->transport.crypto_ctx, channel, delivery, packet, length, &result_packet, &result_length, sequence, &consumed);
173 if (quiet)
175 if (result == ASCIICHAT_OK && !consumed) {
176 memcpy(output, result_packet, result_length);
177 *out_length = result_length;
178 }
179 buffer_release(result_packet);
180 return result;
181}
182
184 if (!browser || !browser->transport.crypto_ctx)
185 return SET_ERRNO(ERROR_INVALID_STATE, "Browser transport security is unavailable");
186 crypto_session_t *session = NULL;
187 asciichat_error_t result = crypto_session_lock(browser->transport.crypto_ctx, &session);
188 if (result == ASCIICHAT_OK) {
189 result = crypto_session_tick(session, time_get_ns());
190 crypto_session_unlock(session);
191 }
192 return result;
193}
194
195asciichat_error_t browser_transport_security_output(browser_transport_t *browser, uint8_t *output, size_t capacity, size_t *length, uint32_t *channel) {
196 if (!browser || !browser->transport.crypto_ctx)
197 return SET_ERRNO(ERROR_INVALID_STATE, "Browser transport security is unavailable");
198 if (!output || !length || !channel || capacity < 256)
199 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid browser security control buffer");
200 uint8_t *packet = NULL;
202 *length = 0;
203 const asciichat_error_t result = acip_security_next_control(browser->transport.crypto_ctx, &flow, &packet, length);
204 if (result == ASCIICHAT_OK && *length) {
205 memcpy(output, packet, *length);
206 *channel = flow;
207 }
208 buffer_release(packet);
209 return result;
210}
211
213 if (!browser || !browser->transport.crypto_ctx)
214 return -1;
215 crypto_session_t *session = NULL;
216 if (crypto_session_lock(browser->transport.crypto_ctx, &session) != ASCIICHAT_OK)
217 return -1;
218 const double epoch = (double)session->records.key_epoch;
219 crypto_session_unlock(session);
220 return epoch;
221}
222
223static void browser_transport_output_pop_internal(browser_transport_t *browser) {
224 if (!browser || !browser->output)
225 return;
226 browser_output_t *output = browser->output;
227 browser->output = output->next;
228 if (!browser->output)
229 browser->tail = NULL;
230 browser->queued_bytes -= output->length;
231 buffer_release(output->data);
232 SAFE_FREE(output);
233}
234
236 if (!browser)
237 return;
238 while (browser->output)
240 SAFE_FREE(browser);
241}
242
244 if (!transport)
245 return;
246 if (transport->methods && transport->methods->close && transport->methods->is_connected && transport->methods->is_connected(transport))
247 transport->methods->close(transport);
248 if (transport->crypto_ctx) {
249 crypto_destroy(transport->crypto_ctx);
250 SAFE_FREE(transport->crypto_ctx);
251 }
253}
254
256 return browser ? &browser->transport : NULL;
257}
258
260 return browser ? browser->client_state : NULL;
261}
262
264 if (browser)
265 browser->client_state = state;
266}
267
269 return browser && browser->output ? browser->output->data : NULL;
270}
271
273 return browser && browser->output ? browser->output->length : 0;
274}
275
277 return browser ? browser->accepted_packets : 0;
278}
279
281 return browser ? browser->dropped_packets : 0;
282}
283
285 return browser ? browser->dropped_bytes : 0;
286}
287
291
293 return browser && browser->output ? browser->output->delivery : ACIP_DELIVERY_RELIABLE;
294}
void errno_scope_end(asciichat_errno_scope_t scope, asciichat_errno_outcome_t outcome)
asciichat_errno_scope_t errno_scope_begin(void)
Synchronized per-thread pending error stacks and value snapshots. SET_ERRNO pushes,...
#define SET_ERRNO(code,...)
@ ASCIICHAT_ERRNO_DISMISSED
browser_transport_t * browser_transport_create(void)
uint64_t browser_transport_dropped_packets(const browser_transport_t *browser)
acip_traffic_class_t browser_transport_output_traffic(const browser_transport_t *browser)
asciichat_error_t browser_transport_security_output(browser_transport_t *browser, uint8_t *output, size_t capacity, size_t *length, uint32_t *channel)
void browser_transport_set_client_state(browser_transport_t *browser, void *state)
uint64_t browser_transport_dropped_bytes(const browser_transport_t *browser)
size_t browser_transport_output_size(browser_transport_t *browser)
bool browser_transport_is_connected(browser_transport_t *browser)
asciichat_error_t browser_transport_security_init(browser_transport_t *browser)
acip_transport_t * browser_transport_base(browser_transport_t *browser)
bool browser_transport_writable(const browser_transport_t *browser, size_t additional_bytes)
struct browser_output browser_output_t
asciichat_error_t browser_transport_security_packet(browser_transport_t *browser, bool seal, uint32_t channel, uint32_t delivery, const uint8_t *packet, size_t length, uint8_t *output, size_t capacity, size_t *out_length, uint64_t *sequence)
double browser_transport_security_epoch(browser_transport_t *browser)
void * browser_transport_client_state(browser_transport_t *browser)
size_t browser_transport_queued_bytes(const browser_transport_t *browser)
asciichat_error_t browser_transport_security_tick(browser_transport_t *browser)
const void * browser_transport_output_data(browser_transport_t *browser)
void browser_transport_set_state(browser_transport_t *browser, browser_transport_state_t state)
void browser_transport_set_capabilities(browser_transport_t *browser, bool datagrams, size_t max_datagram_payload)
void browser_transport_set_connected(browser_transport_t *browser, bool connected)
uint64_t browser_transport_accepted_packets(const browser_transport_t *browser)
void browser_transport_output_pop(browser_transport_t *browser)
#define BROWSER_TRANSPORT_MAX_QUEUED_BYTES
void browser_transport_destroy(browser_transport_t *browser)
void acip_transport_destroy(acip_transport_t *transport)
Destroy transport and free all resources.
acip_delivery_t browser_transport_output_delivery(const browser_transport_t *browser)
void * buffer_alloc(buffer_domain_t *domain, size_t size)
Definition buffer.c:272
#define buffer_release(data)
Definition buffer.h:99
unsigned int uint32_t
#define SAFE_FREE(ptr)
#define SAFE_CALLOC(count, size, cast)
unsigned long long uint64_t
unsigned char uint8_t
void crypto_destroy(crypto_context_t *ctx)
Cleanup crypto context with secure memory wiping.
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48
@ ERROR_INVALID_STATE
@ ERROR_MEMORY
Definition error_codes.h:55
@ ASCIICHAT_OK
Definition error_codes.h:50
@ ERROR_NETWORK_SIZE
Definition error_codes.h:81
@ ERROR_INVALID_PARAM
struct acip_transport acip_transport_t
Forward declaration of ACIP transport.
Definition host.h:508
struct crypto_session crypto_session_t
For crypto session, this is the live record that ties owner, mutex, records, rotation together....
struct browser_transport browser_transport_t
enum browser_transport_state browser_transport_state_t
asciichat_error_t crypto_session_tick(crypto_session_t *session, uint64_t now)
void crypto_session_unlock(crypto_session_t *session)
asciichat_error_t crypto_session_lock(crypto_context_t *crypto, crypto_session_t **output)
asciichat_error_t acip_security_next_control(crypto_context_t *crypto, acip_traffic_class_t *flow, uint8_t **wire, size_t *length)
asciichat_error_t acip_security_seal(crypto_context_t *crypto, acip_traffic_class_t flow, acip_delivery_t delivery, const void *packet, size_t length, uint8_t **output, size_t *written)
asciichat_error_t acip_security_open(crypto_context_t *crypto, acip_traffic_class_t flow, acip_delivery_t delivery, const void *packet, size_t length, uint8_t **output, size_t *written, uint64_t *sequence, bool *consumed)
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
static bool size_t gotel_query_t * out
Definition queries.h:8
#define CRYPTO_NONCE_SIZE
Nonce size (XSalsa20).
Definition sizes.h:83
#define CRYPTO_MAC_SIZE
MAC size (Poly1305).
Definition sizes.h:89
🔤 String Manipulation and Shell Escaping Utilities
size_t ciphertext_capacity
Definition prepare.h:24
acip_send_options_t options
Definition prepare.h:28
buffer_domain_t * domain
Borrowed control reserve for handshake/error traffic; NULL otherwise.
Definition prepare.h:29
acip_delivery_t delivery
Definition traffic.h:22
acip_traffic_class_t traffic_class
Definition traffic.h:21
The useful part of acip transport capabilities is in independent_streams, datagrams,...
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 * impl_data
Transport-specific state.
const acip_transport_methods_t * methods
Method table (virtual functions).
crypto_context_t * crypto_ctx
Optional encryption context.
When code needs to work with asciichat errno snapshot, it keeps total, copied here instead of scatter...
acip_traffic_class_t traffic_class
struct browser_output * next
acip_delivery_t delivery
browser_output_t * tail
acip_transport_t transport
browser_transport_state_t state
browser_output_t * output
Endpoint cryptographic state for handshake, packet protection, authentication, and rekeying.
uint64_t key_epoch
Definition record.h:25
Fixed prefix shared by every ACIP packet on the wire.
Definition packet.h:641
⏱️ High-precision timing utilities using sokol_time.h and uthash
acip_traffic_class_t
Definition traffic.h:9
@ ACIP_TRAFFIC_CONTROL
Definition traffic.h:10
acip_delivery_t
Definition traffic.h:15
@ ACIP_DELIVERY_RELIABLE
Definition traffic.h:16
@ ACIP_DELIVERY_DATAGRAM
Definition traffic.h:17