ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
discovery-service/main.c
Go to the documentation of this file.
1
2/* Storage capacities in elements; text buffers include the terminating NUL. */
3#define DISCOVERY_SERVICE_MAIN_MSG_BUFFER_SIZE 256
4
5/* Existing buffer budgets in bytes, including NUL for text storage. */
6#define DISCOVERY_STATS_ROW_CAPACITY 64
7
19
21#include <stdio.h>
22#include <stdlib.h>
23#include <string.h>
24#include <stdbool.h>
25#include <signal.h>
26#include <errno.h>
27
28#include "../main.h"
34#include <ascii-chat/common.h>
35#include <ascii-chat/version.h>
36#include <util/string.h>
37#include <ascii-chat/log/log.h>
38#include <options/options.h>
39#include <options/rcu.h>
40#include <libplatform/compiler.h>
41#include <libplatform/system.h>
42#include <libplatform/filesystem.h>
43#include <libplatform/terminal.h>
46
47/* ============================================================================
48 * Static State
49 * ============================================================================ */
50
51static acds_server_t g_server;
52
53/* ============================================================================
54 * server_like Callbacks
55 * ============================================================================ */
56
57static void acds_interrupt_fn(int sig) {
58 (void)sig;
59
61}
62
63static void acds_stats_provider(stats_view_t *view, void *data) {
64 acds_server_t *server = data;
66 size_t count = 0;
67 uint64_t sessions = 0, participants = 0;
68 if (database_stats_snapshot(server->db, rows, 64, &count, &sessions, &participants) != ASCIICHAT_OK) {
69 stats_view_add(view, "Sessions: unavailable (database query failed)");
70 return;
71 }
72 if (view->page) {
73 stats_view_add(view, "");
74 stats_view_add(view, "SESSION PARTICIPANTS HOST / MIGRATION");
75 for (size_t i = 0; i < count; ++i)
76 stats_view_add(view, "%-32.32s %12u %s / %s", rows[i].session_string, rows[i].participants, rows[i].host_ready ? "ready" : "negotiating", rows[i].migrating ? "active" : "none");
77 if (sessions > count)
78 stats_view_add(view, "Showing first %zu of %llu sessions", count, (unsigned long long)sessions);
79 }
82 stats_view_add(view, "Active sessions: %llu Participants: %llu", (unsigned long long)sessions, (unsigned long long)participants);
83}
84
85static asciichat_error_t acds_init_fn(void *user_data) {
86 (void)user_data;
87 asciichat_error_t result;
88
89 const options_t *opts = options_get();
90
91 log_info("ascii-chat Discovery Service (acds) starting...");
92 log_info("Version: %s (%s, %s)", ASCII_CHAT_VERSION_FULL, ASCII_CHAT_BUILD_TYPE, ASCII_CHAT_BUILD_DATE);
93
94 // Initialize session string generator (libsodium)
95 result = acds_string_init();
96 if (result != ASCIICHAT_OK) {
97 log_error("Failed to initialize session string generator");
98 return result;
99 }
100
101 // Load or generate identity keys
104
105 const char *acds_key_path = GET_OPTION(encrypt_key);
106 char default_key_path[PLATFORM_MAX_PATH_LENGTH] = {0};
107 if (!acds_key_path || acds_key_path[0] == '\0') {
108 const char *config_dir = get_config_dir();
109 if (config_dir) {
110 safe_snprintf(default_key_path, sizeof(default_key_path), "%sdiscovery_identity", config_dir);
111 acds_key_path = default_key_path;
112 }
113 }
114 log_info("Loading identity key from %s", acds_key_path);
115 result = acds_identity_load(acds_key_path, public_key, secret_key);
116
117 if (result != ASCIICHAT_OK) {
118 if (platform_access(acds_key_path, PLATFORM_ACCESS_EXISTS) == 0) {
119 log_error("Failed to load discovery identity key from %s", acds_key_path);
120 return result;
121 }
122 log_info("Identity key not found, generating new key...");
123
124 result = acds_identity_generate(public_key, secret_key);
125 if (result != ASCIICHAT_OK) {
126 log_error("Failed to generate identity key");
127 return result;
128 }
129
130 result = acds_identity_save(acds_key_path, public_key, secret_key);
131 if (result != ASCIICHAT_OK) {
132 log_error("Failed to save identity key to %s", acds_key_path);
133 return result;
134 }
135
136 log_info("Saved new identity key to %s", acds_key_path);
137 }
138
139 public_key_t identity = {.type = KEY_TYPE_ED25519};
140 memcpy(identity.key, public_key, sizeof(identity.key));
141 key_identity_announce("DISCOVERY SERVER PUBLIC IDENTITY", &identity);
142
143 // Display server fingerprint
144 char fingerprint[HEX_STRING_SIZE_32];
145 acds_identity_fingerprint(public_key, fingerprint);
146 log_info("Discovery server identity: SHA256:%s", fingerprint);
148 safe_snprintf(msg, sizeof(msg), "Server fingerprint: SHA256:%s", fingerprint);
149 log_console(LOG_INFO, msg);
150
151 // Create config from options for server initialization
152 acds_config_t config = {0};
153 int port_num = GET_OPTION(port);
154 if (port_num < 1 || port_num > 65535) {
155 log_error("Invalid port: %d (must be 1-65535)", port_num);
156 return ERROR_INVALID_PARAM;
157 }
158 config.port = port_num;
159
160 const char *address = opts && opts->address[0] != '\0' ? opts->address : "127.0.0.1";
161 const char *address6 = opts && opts->address6[0] != '\0' ? opts->address6 : "::1";
162 const char *log_file = opts && opts->log_file[0] != '\0' ? opts->log_file : "acds.log";
163 SAFE_STRNCPY(config.address, address, sizeof(config.address));
164 SAFE_STRNCPY(config.address6, address6, sizeof(config.address6));
165 SAFE_STRNCPY(config.database_path, GET_OPTION(discovery_database_path), sizeof(config.database_path));
166 SAFE_STRNCPY(config.key_path, acds_key_path, sizeof(config.key_path));
167 SAFE_STRNCPY(config.log_file, log_file, sizeof(config.log_file));
168 config.log_level = GET_OPTION(log_level);
169 config.require_server_identity = GET_OPTION(require_server_identity) != 0;
170 config.require_client_identity = GET_OPTION(require_client_identity) != 0;
171
172 if (config.require_server_identity) {
173 log_info("Security: Requiring signed identity from servers creating sessions");
174 }
175 if (config.require_client_identity) {
176 log_info("Security: Requiring signed identity from clients joining sessions");
177 }
178
179 // Parse STUN servers from comma-separated list
180 config.stun_count = 0;
181 memset(config.stun_servers, 0, sizeof(config.stun_servers));
182 const char *stun_servers_str = GET_OPTION(stun_servers);
183 if (stun_servers_str && stun_servers_str[0] != '\0') {
184 char stun_copy[OPTIONS_BUFF_SIZE];
185 SAFE_STRNCPY(stun_copy, stun_servers_str, sizeof(stun_copy));
186
187 char *saveptr = NULL;
188 char *token = platform_strtok_r(stun_copy, ",", &saveptr);
189 while (token && config.stun_count < 4) {
190 while (*token == ' ' || *token == '\t')
191 token++;
192 size_t len = strlen(token);
193 while (len > 0 && (token[len - 1] == ' ' || token[len - 1] == '\t')) {
194 token[--len] = '\0';
195 }
196
197 if (len > 0 && len < sizeof(config.stun_servers[0].host)) {
198 config.stun_servers[config.stun_count].host_len = (uint8_t)len;
199 SAFE_STRNCPY(config.stun_servers[config.stun_count].host, token, sizeof(config.stun_servers[config.stun_count].host));
200 log_info("Added STUN server: %s", token);
201 config.stun_count++;
202 } else if (len > 0) {
203 log_warn("STUN server URL too long (max 63 chars): %s", token);
204 }
205
206 token = platform_strtok_r(NULL, ",", &saveptr);
207 }
208 }
209
210 // Parse TURN servers from comma-separated list
211 config.turn_count = 0;
212 memset(config.turn_servers, 0, sizeof(config.turn_servers));
213 const char *turn_servers_str = GET_OPTION(turn_servers);
214 const char *turn_username_str = GET_OPTION(turn_username);
215 const char *turn_credential_str = GET_OPTION(turn_credential);
216
217 if (turn_servers_str && turn_servers_str[0] != '\0') {
218 char turn_copy[OPTIONS_BUFF_SIZE];
219 SAFE_STRNCPY(turn_copy, turn_servers_str, sizeof(turn_copy));
220
221 char *saveptr = NULL;
222 char *token = platform_strtok_r(turn_copy, ",", &saveptr);
223 while (token && config.turn_count < 4) {
224 while (*token == ' ' || *token == '\t')
225 token++;
226 size_t len = strlen(token);
227 while (len > 0 && (token[len - 1] == ' ' || token[len - 1] == '\t')) {
228 token[--len] = '\0';
229 }
230
231 if (len > 0 && len < sizeof(config.turn_servers[0].url)) {
232 config.turn_servers[config.turn_count].url_len = (uint8_t)len;
233 SAFE_STRNCPY(config.turn_servers[config.turn_count].url, token, sizeof(config.turn_servers[config.turn_count].url));
234
235 if (turn_username_str && turn_username_str[0] != '\0') {
236 size_t username_len = strlen(turn_username_str);
237 if (username_len < sizeof(config.turn_servers[0].username)) {
238 config.turn_servers[config.turn_count].username_len = (uint8_t)username_len;
239 SAFE_STRNCPY(config.turn_servers[config.turn_count].username, turn_username_str, sizeof(config.turn_servers[config.turn_count].username));
240 }
241 }
242
243 if (turn_credential_str && turn_credential_str[0] != '\0') {
244 size_t credential_len = strlen(turn_credential_str);
245 if (credential_len < sizeof(config.turn_servers[0].credential)) {
246 config.turn_servers[config.turn_count].credential_len = (uint8_t)credential_len;
247 SAFE_STRNCPY(config.turn_servers[config.turn_count].credential, turn_credential_str, sizeof(config.turn_servers[config.turn_count].credential));
248 }
249 }
250
251 log_info("Added TURN server: %s (username: %s)", token, turn_username_str && turn_username_str[0] ? turn_username_str : "<none>");
252 config.turn_count++;
253 } else if (len > 0) {
254 log_warn("TURN server URL too long (max 63 chars): %s", token);
255 }
256
257 token = platform_strtok_r(NULL, ",", &saveptr);
258 }
259 }
260
261 // Copy TURN secret for dynamic credential generation
262 const char *turn_secret_str = GET_OPTION(turn_secret);
263 if (turn_secret_str && turn_secret_str[0] != '\0') {
264 SAFE_STRNCPY(config.turn_secret, turn_secret_str, sizeof(config.turn_secret));
265 log_info("TURN dynamic credential generation enabled");
266 } else {
267 config.turn_secret[0] = '\0';
268 }
269
270 // Check for shutdown request during startup
272 log_info("Shutdown signal received during initialization, aborting startup");
273 return ASCIICHAT_OK;
274 }
275
276 // Initialize server (DB, rate limiter, worker pool — TCP server comes from server_like)
277 result = acds_server_init(&g_server, &config);
278 if (result != ASCIICHAT_OK) {
279 log_error("Server initialization failed");
280 return result;
281 }
282
283 // acds_server_init clears the server struct, so install the identity only
284 // after initialization. WebSocket crypto handshakes sign with these keys.
285 memcpy(g_server.identity_public, public_key, sizeof(g_server.identity_public));
286 memcpy(g_server.identity_secret, secret_key, sizeof(g_server.identity_secret));
287
288 // Check again after server init in case SIGTERM arrived during init
290 log_info("Shutdown signal received after server initialization");
291 return ASCIICHAT_OK;
292 }
293
294 stats_runtime_set_provider(acds_stats_provider, &g_server);
295 log_info("Discovery service initialized");
296 return ASCIICHAT_OK;
297}
298
299static void acds_cleanup_fn(void *user_data) {
300 stats_runtime_set_provider(NULL, NULL);
301 (void)user_data;
302 log_info("Shutting down discovery server...");
303 acds_server_shutdown(&g_server);
304 log_info("Discovery server stopped");
305}
306
307/* ============================================================================
308 * Entry Point
309 * ============================================================================ */
310
311static void acds_status_fn(void *user_data, ui_status_t *status) {
312 (void)user_data;
314 if (tcp)
315 ui_status_gather(tcp, NULL, network_server_config(tcp)->ipv4_address, network_server_config(tcp)->ipv6_address, GET_OPTION(port), g_server.stats.start_time, "Discovery Service", false, status);
316}
317
318int acds_main(void) {
320 // Required callbacks
321 .init_fn = acds_init_fn,
322 .init_user_data = NULL,
323 .interrupt_fn = acds_interrupt_fn,
324
325 // Cleanup
326 .cleanup_fn = acds_cleanup_fn,
327 .cleanup_user_data = NULL,
328
329 .status_fn = acds_status_fn,
330 .status_user_data = NULL,
331
332 .connections = acds_network_callbacks,
333 .connection_user_data = &g_server,
334 .websocket_enabled = true,
336 .partial_timeout_ms = 5000,
337 .idle_timeout_ms = 60000,
338
339 // mDNS
340 .mdns =
341 {
342 .enabled = true,
343 .service_name = "ascii-chat-Discovery-Service",
344 .service_type = "_ascii-chat-discovery-service._tcp",
345 },
346
347 // UPnP
348 .upnp =
349 {
350 .enabled = true,
351 .description = "ascii-chat ACDS",
352 },
353
354 // System
355 .raise_fd_limit = true,
356 .fd_limit_target = 65536,
357 };
358
359 // Native Windows console events reach signal_exit(), not the CRT signal handler.
360 // Route them through the owner so the listener stops and its mapping is removed.
364 return result;
365}
Platform initialization and static synchronization helpers.
#define DISCOVERY_STATS_ROW_CAPACITY
int acds_main(void)
This is the handoff point for acds config. Callers fill port, log_level, require_server_identity,...
#define DISCOVERY_SERVICE_MAIN_MSG_BUFFER_SIZE
asciichat_error_t database_stats_snapshot(sqlite3 *db, database_session_stats_t *rows, size_t capacity, size_t *row_count, uint64_t *sessions, uint64_t *participants)
asciichat_error_t acds_string_init(void)
Initialize session string system with cached word validation.
Dedicated worker for all pending errno stacks and handled history. Signal handlers may only request a...
int platform_access(const char *pathname, int mode)
Definition filesystem.c:95
#define SAFE_STRNCPY(dst, src, size)
#define PLATFORM_MAX_PATH_LENGTH
unsigned long long uint64_t
unsigned char uint8_t
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48
@ ASCIICHAT_OK
Definition error_codes.h:50
@ ERROR_INVALID_PARAM
uint8_t key[CRYPTO_PUBLIC_KEY_SIZE]
Definition key_types.h:78
@ KEY_TYPE_ED25519
Definition key_types.h:58
#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_file(...)
File-only logging - writes to log file only, no stderr output.
Definition log/log.h:687
#define GET_OPTION(field)
Definition options.h:1333
struct options_state options_t
Immutable, RCU-published snapshot of the application's runtime configuration.
const options_t * options_get(void)
Get pointer to current options struct (lock-free, thread-safe).
Definition rcu.c:495
#define OPTIONS_BUFF_SIZE
Buffer size for option string values.
Definition options.h:305
char * get_config_dir(void)
Get configuration directory path with XDG_CONFIG_HOME support.
Definition path.c:279
#define CONSENSUS_HANDOFF_HEADER
Definition handoff.h:15
#define CONSENSUS_HANDOFF_PROBE_BYTES
Definition handoff.h:16
asciichat_error_t acds_identity_load(const char *path, uint8_t public_key[32], uint8_t secret_key[64])
Load identity from file.
Definition identity.c:36
void acds_identity_fingerprint(const uint8_t public_key[32], char fingerprint[(32 *2+1)])
Compute SHA256 fingerprint of public key.
Definition identity.c:131
asciichat_error_t acds_identity_save(const char *path, const uint8_t public_key[32], const uint8_t secret_key[64])
Save identity to file.
Definition identity.c:88
asciichat_error_t acds_identity_generate(uint8_t public_key[32], uint8_t secret_key[64])
Generate new Ed25519 keypair.
Definition identity.c:22
⚙️ Common definitions, error codes, macros, and types shared throughout the application
struct network_server network_server_t
@ STATS_GAUGE_PARTICIPANTS_ACTIVE
void key_identity_announce(const char *label, const public_key_t *key)
const network_server_config_t * network_server_config(network_server_t *s)
void network_server_request_stop(network_server_t *s)
void stats_gauge_set(stats_scope_t *scope, stats_gauge_id_t id, uint64_t value)
📝 Logging API with multiple log levels and terminal output control
#define log_console(level, message)
Definition log/log.h:1046
void set_interrupt_callback(void(*cb)(void))
Definition main.c:272
Global application exit and signal handling API.
⚙️ Unified options parsing system for ascii-chat with builder pattern and lock-free access
📂 Path Manipulation Utilities
void stats_runtime_set_provider(stats_provider_fn provider, void *data)
Definition runtime.c:123
void stats_view_add(stats_view_t *view, const char *format,...)
Definition runtime.c:109
stats_scope_t * stats_runtime_scope(void)
Definition runtime.c:78
void session_server_like_request_shutdown(void)
bool session_server_like_shutdown_requested(void)
asciichat_error_t session_server_like_run(const session_server_like_config_t *config)
network_server_t * session_server_like_get_network_server(void)
struct session_server_like_config session_server_like_config_t
The useful part of session server like config is in [struct].mdns, [struct].upnp, init_fn,...
#define ED25519_PUBLIC_KEY_SIZE
Ed25519 public key size in bytes.
Definition sizes.h:37
#define HEX_STRING_SIZE_32
Hex string size for 32-byte values (64 hex chars + null terminator).
Definition sizes.h:158
#define ED25519_PRIVATE_KEY_SIZE
Ed25519 private key size (seed + public) in bytes.
Definition sizes.h:39
const network_connection_callbacks_t acds_network_callbacks
void acds_server_shutdown(acds_server_t *server)
Shutdown discovery server.
asciichat_error_t acds_server_init(acds_server_t *server, const acds_config_t *config)
acds server is intentionally a small, concrete record. Fields such as network_server,...
asciichat_error_t ui_status_gather(network_server_t *server, const char *session_string, const char *ipv4_address, const char *ipv6_address, uint16_t port, time_t start_time, const char *mode_name, bool session_is_mdns_only, ui_status_t *out_status)
Gather current status information.
Definition status.c:70
🔤 String Manipulation and Shell Escaping Utilities
Discovery server configuration.
char address[256]
IPv4 bind address (empty = all interfaces).
char database_path[512]
SQLite database path.
bool require_server_identity
Require servers to provide signed identity when creating sessions.
uint8_t turn_count
Number of configured TURN servers (0-4).
int port
TCP listen port (default 27225).
char turn_secret[256]
(HMAC-SHA1)
uint8_t stun_count
Number of configured STUN servers (0-4).
char key_path[512]
Ed25519 identity key file path.
stun_server_t stun_servers[MAX_CONFIGURED_STUN_SERVERS]
STUN server configurations.
char log_file[512]
Log file path (empty = stderr).
char address6[256]
IPv6 bind address (empty = all interfaces).
bool require_client_identity
Require clients to provide signed identity when joining sessions.
turn_server_t turn_servers[MAX_CONFIGURED_TURN_SERVERS]
TURN server configurations.
log_level_t log_level
Logging verbosity level.
Discovery server state.
sqlite3 * db
SQLite database handle.
The useful part of database session stats is in participants, host_ready, migrating: together they de...
Definition database.h:275
char address6[256]
IPv6 bind address (server only).
Definition options.h:1003
char log_file[256]
Log file path.
Definition options.h:1159
char address[256]
Server address (client) or bind address (server).
Definition options.h:1002
The normalized public identity used by ascii-chat's crypto and key-management code.
Definition key_types.h:76
unsigned page
Status information for server/discovery service modes.
Definition status.h:42
#define LOG_INFO
Definition types.h:44