Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.
C aiderastclaude-codecode-analysiscode-intelligencecodexcursorcypherdeveloper-toolsgemini-cligraph-visualizationkilocodeknowledge-graphmcpmcp-servermodel-context-protocolopencodesqlitetree-sitterwindsurf
/*
* runtime.c — Mandatory per-account daemon service over authenticated IPC.
*/
#include "daemon/runtime.h"
#include "daemon/ipc_internal.h"
#include "daemon/service_internal.h"
#include "foundation/compat.h"
#include "foundation/compat_thread.h"
#include "foundation/log.h"
#include "foundation/mem.h"
#include "foundation/platform.h"
#include "foundation/win_utf8.h"
#include <limits.h>
#include <stdatomic.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef CBM_ENABLE_TEST_SEAMS
/* #1383 test seam: force peer-image verification to fail so the rejection
* -response path is reachable from the in-process harness — the peer pid is
* OS-authenticated socket credentials, so a same-process peer always verifies
* against the service's own active image. */
static atomic_bool runtime_force_peer_image_unverified_seam;
void cbm_daemon_runtime_force_peer_image_unverified_for_testing(bool force) {
atomic_store(&runtime_force_peer_image_unverified_seam, force);
}
/* The two failure modes are NOT interchangeable and must be testable apart:
* an image that cannot be examined at all is admitted (the peer already proved
* build compatibility in the HELLO), while one that CAN be examined and differs
* is rejected. One seam per mode keeps each contract honest. */
static atomic_bool runtime_force_peer_image_mismatch_seam;
void cbm_daemon_runtime_force_peer_image_mismatch_for_testing(bool force) {
atomic_store(&runtime_force_peer_image_mismatch_seam, force);
}
/* #1955 test seam: make the active-image comparison miss, exactly as when the
* peer runs a DIFFERENT file with identical bytes (a second install path, a
* package-manager cache copy). Everything after that comparison - the full
* fingerprint fallback and the verified-image cache - still runs for real. The
* counter records every full-image fingerprint the HELLO path computes, so a
* test asserts how often the O(image size) hash runs instead of timing it. */
static atomic_bool runtime_force_peer_image_distinct_copy_seam;
static atomic_uint_fast64_t runtime_peer_image_hash_count_seam;
void cbm_daemon_runtime_force_peer_image_distinct_copy_for_testing(bool force) {
atomic_store(&runtime_force_peer_image_distinct_copy_seam, force);
}
uint64_t cbm_daemon_runtime_peer_image_hashes_for_testing(void) {
return (uint64_t)atomic_load(&runtime_peer_image_hash_count_seam);
}
static void runtime_note_peer_image_hash(void) {
(void)atomic_fetch_add(&runtime_peer_image_hash_count_seam, 1);
}
/* The abandoned-request containment path ends in process termination, which an
* in-process harness cannot observe. The timeout override makes the ceiling
* reachable in test time; the hook replaces termination with a recordable
* callback. Both stay inert (zero/NULL) outside tests. */
static _Atomic uint32_t runtime_abandoned_request_join_timeout_seam;
void cbm_daemon_runtime_set_abandoned_request_join_timeout_for_testing(uint32_t timeout_ms) {
atomic_store(&runtime_abandoned_request_join_timeout_seam, timeout_ms);
}
static _Atomic(cbm_daemon_runtime_containment_hook_t) runtime_containment_hook_seam;
void cbm_daemon_runtime_set_containment_hook_for_testing(
cbm_daemon_runtime_containment_hook_t hook) {
atomic_store(&runtime_containment_hook_seam, hook);
}
/* Cold-storm ephemeral-linger seam (2026-09). Overrides the bounded linger
* window that ephemeral last-committed-client retirement grants while cohort
* participants are still mid-bootstrap, so a test can drive both the linger and
* its expiry backstop in test time. UINT32_MAX leaves the production constant;
* any other value (0 = expire immediately) overrides. */
static _Atomic uint32_t runtime_ephemeral_linger_timeout_seam = UINT32_MAX;
void cbm_daemon_runtime_service_set_ephemeral_linger_timeout_for_testing(uint32_t timeout_ms) {
atomic_store(&runtime_ephemeral_linger_timeout_seam, timeout_ms);
}
/* Connection-cap seams (flaky-ledger item 12): see runtime.h. */
static atomic_bool runtime_hold_peer_waits_seam;
void cbm_daemon_runtime_hold_peer_waits_for_testing(bool hold) {
atomic_store(&runtime_hold_peer_waits_seam, hold);
}
static _Atomic(cbm_daemon_runtime_hello_hook_t) runtime_hello_hook_seam;
void cbm_daemon_runtime_set_hello_hook_for_testing(cbm_daemon_runtime_hello_hook_t hook) {
atomic_store(&runtime_hello_hook_seam, hook);
}
static void runtime_hello_point(cbm_daemon_runtime_hello_point_t point) {
cbm_daemon_runtime_hello_hook_t hook = atomic_load(&runtime_hello_hook_seam);
if (hook) {
hook(point);
}
}
#define RUNTIME_HELLO_POINT(point) runtime_hello_point(CBM_DAEMON_RUNTIME_HELLO_POINT_##point)
#else
static void runtime_note_peer_image_hash(void) {}
#define RUNTIME_HELLO_POINT(point) ((void)0)
#endif
#ifdef _WIN32
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#elif defined(__APPLE__)
#include <fcntl.h>
#include <libproc.h>
#include <mach/vm_prot.h>
#include <sys/proc_info.h>
#include <sys/stat.h>
#include <unistd.h>
#elif defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__)
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#if defined(__FreeBSD__) || defined(__NetBSD__)
#include <sys/types.h>
#include <sys/sysctl.h>
#endif
#endif
enum {
RUNTIME_MAX_CLIENTS_HARD = 64,
RUNTIME_ACCEPT_POLL_MS = 20,
RUNTIME_WAIT_POLL_NS = 1000000,
RUNTIME_WORKER_STACK_SIZE = 256 * 1024,
/* Distinct peer image files (install paths / identical copies) whose full
* fingerprint already matched this daemon. Each held entry pins one image
* inode, so the bound is small; a full table only means later copies are
* hashed per admission, exactly as before the table existed. */
RUNTIME_VERIFIED_PEER_IMAGE_CAPACITY = 8,
/* Bounds the drain-before-close wait for a peer consuming its final
* response; interrupted or already-poisoned connections skip it. */
RUNTIME_WORKER_DRAIN_TIMEOUT_MS = 2000,
/* Inline rejections run on the accept thread, so their drain stays short:
* a local cooperative peer is already blocked in read and consumes the
* rejection within milliseconds. */
RUNTIME_REJECT_DRAIN_TIMEOUT_MS = 250,
/* Ceiling on how long a disconnecting worker waits for its in-flight
* application request to observe cancellation. session_cancel has already
* run by the time this wait starts, so a compliant handler returns within
* milliseconds; the wait is sized for a handler that only polls its cancel
* flag between long pipeline stages. A handler that ignores cancellation
* past this ceiling turned the daemon into a permanent zombie once
* (2026-08-29): the unbounded join blocked the disconnect path, admission
* wedged behind it, and the dead generation held the endpoint pipes and
* the UI port for nine hours with nothing logged. */
RUNTIME_ABANDONED_REQUEST_JOIN_TIMEOUT_MS = 30000,
/* Cold-storm race (2026-09): when the final committed client of an
* ephemeral generation disconnects while cohort participants are still
* admitted but mid-bootstrap (racing connect()), the generation lingers
* this long for them to connect instead of retiring out from under them.
* Mirrors the host initial-client window; the linger is always bounded so
* a participant that never connects cannot wedge the generation (the
* 900s host_serving hang). */
RUNTIME_EPHEMERAL_LINGER_MS = 10000,
RUNTIME_PATH_CAP = 4096,
RENDEZVOUS_REQUEST_ABI_OFFSET = 0,
RENDEZVOUS_REQUEST_VERSION_OFFSET = 4,
RENDEZVOUS_REQUEST_BUILD_OFFSET =
RENDEZVOUS_REQUEST_VERSION_OFFSET + CBM_DAEMON_RENDEZVOUS_VERSION_TEXT_CAP,
RENDEZVOUS_RESPONSE_CONNECT_STATUS_OFFSET = 0,
RENDEZVOUS_RESPONSE_HELLO_STATUS_OFFSET = 4,
RENDEZVOUS_RESPONSE_CLIENT_ID_OFFSET = 8,
RENDEZVOUS_RESPONSE_PROCESS_ID_OFFSET = 16,
RENDEZVOUS_RESPONSE_CONFLICT_STATUS_OFFSET = 24,
RENDEZVOUS_RESPONSE_ACTIVE_VERSION_OFFSET = 28,
RENDEZVOUS_RESPONSE_ACTIVE_BUILD_OFFSET =
RENDEZVOUS_RESPONSE_ACTIVE_VERSION_OFFSET + CBM_DAEMON_RENDEZVOUS_VERSION_TEXT_CAP,
RENDEZVOUS_RESPONSE_REQUESTED_VERSION_OFFSET =
RENDEZVOUS_RESPONSE_ACTIVE_BUILD_OFFSET + CBM_DAEMON_RENDEZVOUS_BUILD_FINGERPRINT_CAP,
RENDEZVOUS_RESPONSE_REQUESTED_BUILD_OFFSET =
RENDEZVOUS_RESPONSE_REQUESTED_VERSION_OFFSET + CBM_DAEMON_RENDEZVOUS_VERSION_TEXT_CAP,
RENDEZVOUS_RESPONSE_MESSAGE_OFFSET =
RENDEZVOUS_RESPONSE_REQUESTED_BUILD_OFFSET + CBM_DAEMON_RENDEZVOUS_BUILD_FINGERPRINT_CAP,
ACTIVATION_REQUEST_ACTION_OFFSET = 0,
ACTIVATION_REQUEST_IDENTITY_OFFSET = 4,
ACTIVATION_RESPONSE_ABI_OFFSET = 0,
ACTIVATION_RESPONSE_ACCEPTED_OFFSET = 4,
ACTIVATION_RESPONSE_CLIENTS_OFFSET = 8,
ACTIVATION_RESPONSE_CONNECTIONS_OFFSET = 16,
STATUS_RESPONSE_SIZE = 4,
SUBSCRIBE_REQUEST_PREFIX_SIZE = 4,
SUBSCRIBE_RESPONSE_SIZE = 12,
UNSUBSCRIBE_REQUEST_SIZE = 8,
APPLICATION_CANCEL_REQUEST_SIZE = 8,
APPLICATION_REQUEST_PREFIX_SIZE = 12,
APPLICATION_RESPONSE_PREFIX_SIZE = 16,
};
_Static_assert(RENDEZVOUS_REQUEST_BUILD_OFFSET + CBM_DAEMON_RENDEZVOUS_BUILD_FINGERPRINT_CAP ==
CBM_DAEMON_RENDEZVOUS_REQUEST_SIZE,
"rendezvous request layout changed");
_Static_assert(RENDEZVOUS_RESPONSE_MESSAGE_OFFSET + CBM_DAEMON_RENDEZVOUS_MESSAGE_CAP ==
CBM_DAEMON_RENDEZVOUS_RESPONSE_SIZE,
"rendezvous response layout changed");
_Static_assert(ACTIVATION_REQUEST_IDENTITY_OFFSET + CBM_DAEMON_RENDEZVOUS_REQUEST_SIZE ==
CBM_DAEMON_ACTIVATION_SHUTDOWN_REQUEST_SIZE &&
ACTIVATION_RESPONSE_CONNECTIONS_OFFSET + 8 ==
CBM_DAEMON_ACTIVATION_SHUTDOWN_RESPONSE_SIZE,
"activation shutdown layout changed");
_Static_assert(CBM_DAEMON_RENDEZVOUS_VERSION_TEXT_CAP == CBM_DAEMON_VERSION_TEXT_SIZE,
"service version capacity requires a new rendezvous strategy");
_Static_assert(CBM_DAEMON_RENDEZVOUS_BUILD_FINGERPRINT_CAP == CBM_DAEMON_BUILD_FINGERPRINT_SIZE,
"service fingerprint capacity requires a new rendezvous strategy");
_Static_assert(CBM_DAEMON_RENDEZVOUS_MESSAGE_CAP == CBM_DAEMON_CONFLICT_MESSAGE_SIZE,
"service message capacity requires a new rendezvous strategy");
_Static_assert(CBM_DAEMON_RUNTIME_CONNECT_ERROR == 0 && CBM_DAEMON_RUNTIME_CONNECT_ACCEPTED == 1 &&
CBM_DAEMON_RUNTIME_CONNECT_CONFLICT == 2 &&
CBM_DAEMON_RUNTIME_CONNECT_REJECTED == 3,
"rendezvous connect status values changed");
_Static_assert(CBM_DAEMON_HELLO_INVALID == 0 && CBM_DAEMON_HELLO_COMPATIBLE == 1 &&
CBM_DAEMON_HELLO_VERSION_CONFLICT == 2 && CBM_DAEMON_HELLO_BUILD_CONFLICT == 3 &&
CBM_DAEMON_HELLO_PROTOCOL_ABI_CONFLICT == 4 &&
CBM_DAEMON_HELLO_STORE_ABI_CONFLICT == 5 &&
CBM_DAEMON_HELLO_FEATURE_ABI_CONFLICT == 6,
"rendezvous hello status values changed");
_Static_assert(CBM_DAEMON_RENDEZVOUS_FRAME_VERSION == 1 && CBM_DAEMON_RENDEZVOUS_ABI == 1 &&
CBM_DAEMON_FRAME_REQUEST == 1 && CBM_DAEMON_FRAME_RESPONSE == 2 &&
CBM_DAEMON_RUNTIME_OP_HELLO == 1 &&
CBM_DAEMON_RUNTIME_OP_ACTIVATION_SHUTDOWN == 8 &&
CBM_DAEMON_RUNTIME_ACTIVATION_INSTALL == 1 &&
CBM_DAEMON_RUNTIME_ACTIVATION_UPDATE == 2 &&
CBM_DAEMON_RUNTIME_ACTIVATION_UNINSTALL == 3,
"rendezvous framing values changed");
typedef struct cbm_daemon_runtime_worker cbm_daemon_runtime_worker_t;
/* The service keeps the exact native image object whose bytes were hashed at
* startup. HELLO can then prove that a peer maps this same, still-stable file
* object without reading the executable again. A different file identity is
* not a rejection by itself: identical copies remain supported through the
* full fingerprint fallback. */
typedef struct {
bool held;
#ifdef _WIN32
HANDLE file;
BY_HANDLE_FILE_INFORMATION information;
LARGE_INTEGER size;
#elif defined(__APPLE__) || defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__)
int fd;
struct stat status;
#endif
} runtime_process_image_reference_t;
struct cbm_daemon_runtime_service {
cbm_mutex_t mutex;
cbm_daemon_ipc_listener_t *listener;
cbm_daemon_coordinator_t *coordinator;
cbm_daemon_runtime_worker_t *workers;
size_t worker_capacity;
size_t worker_mutexes_initialized;
size_t active_connections;
size_t committed_clients;
/* Monotonic count of every admission since service start. The host's
* nobody-ever-connected window latches on this instead of sampling the
* live client count: a short-lived first session can begin and end
* entirely between two host polls, and a sampled count then reads zero
* forever, stopping a daemon whose client is mid-conversation. */
uint64_t admitted_total;
/* Born via `daemon start`: last-client-disconnect does not begin stopping.
* The stop/drain ops and process kill remain the only exits. */
bool permanent;
cbm_thread_t accept_thread;
bool accept_thread_started;
bool accept_thread_joined;
atomic_bool accept_thread_done;
cbm_daemon_runtime_service_state_t state;
uint64_t stop_deadline_ms;
bool emergency_stop;
bool activation_shutdown_requested;
bool activation_response_inflight;
char semantic_version[CBM_DAEMON_VERSION_TEXT_SIZE];
char build_fingerprint[CBM_DAEMON_BUILD_FINGERPRINT_SIZE];
cbm_daemon_build_identity_t identity;
runtime_process_image_reference_t active_image;
/* Guarded by mutex. Retained references keep each verified inode alive,
* so its stat identity cannot be reused by a different file. */
runtime_process_image_reference_t verified_peer_images[RUNTIME_VERIFIED_PEER_IMAGE_CAPACITY];
size_t verified_peer_image_count;
char *conflict_log_path;
size_t conflict_log_cap_bytes;
uint64_t lease_timeout_ms;
uint32_t request_timeout_ms;
uint32_t shutdown_timeout_ms;
cbm_daemon_runtime_application_callbacks_t application;
/* Owned only by the convenience start() path. start_reserved() callers
* retain their externally managed participant guard. */
cbm_daemon_ipc_participant_guard_t *owned_participant_guard;
/* Cold-storm ephemeral-retirement gate (2026-09). When the final committed
* client disconnects while cohort participants are still admitted but not
* yet committed, the generation lingers until this bounded deadline instead
* of retiring; reconcile_lifetime retires it once that window elapses with
* no new client committing. Zero means no linger is armed. */
uint64_t ephemeral_linger_deadline_ms;
};
struct cbm_daemon_runtime_worker {
cbm_daemon_runtime_service_t *service;
cbm_mutex_t send_mutex;
cbm_thread_t thread;
bool thread_started;
bool in_use;
bool joining;
atomic_bool done;
cbm_daemon_ipc_connection_t *connection;
cbm_daemon_client_id_t client_id;
uint64_t peer_process_id;
bool admitted;
bool admission_committed;
bool final_response_inflight;
cbm_daemon_runtime_application_session_t *application_session;
bool application_session_opened;
bool application_cancelled;
atomic_bool disconnecting;
cbm_thread_t application_thread;
bool application_thread_started;
atomic_bool application_thread_done;
cbm_daemon_runtime_application_token_t application_request_token;
cbm_daemon_runtime_application_token_t last_application_request_token;
uint8_t *application_request;
uint32_t application_request_length;
};
struct cbm_daemon_runtime_client {
cbm_mutex_t exchange_mutex;
cbm_mutex_t send_mutex;
cbm_mutex_t state_mutex;
cbm_daemon_ipc_connection_t *connection;
cbm_daemon_client_id_t client_id;
uint64_t authenticated_process_id;
bool usable;
bool exchange_active;
bool closing;
bool close_interrupted_exchange;
cbm_daemon_runtime_application_token_t next_application_token;
cbm_daemon_runtime_application_token_t last_started_application_token;
cbm_daemon_runtime_application_token_t active_application_token;
cbm_daemon_runtime_application_token_t pending_cancel_token;
bool application_request_sent;
bool application_cancel_sent;
};
static uint64_t runtime_deadline_after(uint32_t timeout_ms) {
uint64_t now_ms = cbm_now_ms();
if (UINT64_MAX - now_ms < (uint64_t)timeout_ms) {
return UINT64_MAX;
}
return now_ms + (uint64_t)timeout_ms;
}
static uint32_t runtime_ephemeral_linger_timeout_ms(void) {
#ifdef CBM_ENABLE_TEST_SEAMS
uint32_t seam = atomic_load(&runtime_ephemeral_linger_timeout_seam);
if (seam != UINT32_MAX) {
return seam;
}
#endif
return RUNTIME_EPHEMERAL_LINGER_MS;
}
static void runtime_wait_tick(uint64_t deadline_ms) {
uint64_t now_ms = cbm_now_ms();
if (now_ms >= deadline_ms) {
return;
}
uint64_t remaining_ms = deadline_ms - now_ms;
struct timespec pause = {
.tv_sec = 0,
.tv_nsec = remaining_ms > 1 ? RUNTIME_WAIT_POLL_NS : (long)(remaining_ms * 1000000ULL),
};
(void)cbm_nanosleep(&pause, NULL);
}
static void runtime_put_u32(uint8_t *out, uint32_t value) {
out[0] = (uint8_t)(value >> 24);
out[1] = (uint8_t)(value >> 16);
out[2] = (uint8_t)(value >> 8);
out[3] = (uint8_t)value;
}
static uint32_t runtime_get_u32(const uint8_t *in) {
return ((uint32_t)in[0] << 24) | ((uint32_t)in[1] << 16) | ((uint32_t)in[2] << 8) |
(uint32_t)in[3];
}
static void runtime_put_u64(uint8_t *out, uint64_t value) {
for (size_t i = 0; i < 8; i++) {
out[i] = (uint8_t)(value >> (56 - i * 8));
}
}
static uint64_t runtime_get_u64(const uint8_t *in) {
uint64_t value = 0;
for (size_t i = 0; i < 8; i++) {
value = (value << 8) | in[i];
}
return value;
}
static bool runtime_bounded_length(const char *value, size_t capacity, size_t *length_out) {
if (!value || capacity == 0) {
return false;
}
for (size_t i = 0; i < capacity; i++) {
if (value[i] == '\0') {
if (length_out) {
*length_out = i;
}
return true;
}
}
return false;
}
static bool runtime_wire_string_encode(uint8_t *out, size_t capacity, const char *value,
bool allow_empty) {
size_t length = 0;
if (!out || !runtime_bounded_length(value, capacity, &length) ||
(!allow_empty && length == 0)) {
return false;
}
memset(out, 0, capacity);
memcpy(out, value, length);
return true;
}
static bool runtime_wire_string_decode(const uint8_t *in, size_t capacity, char *out,
bool allow_empty) {
if (!in || !out || capacity == 0) {
return false;
}
size_t length = capacity;
for (size_t i = 0; i < capacity; i++) {
if (in[i] == 0) {
length = i;
break;
}
}
if (length == capacity || (!allow_empty && length == 0)) {
return false;
}
for (size_t i = length + 1; i < capacity; i++) {
if (in[i] != 0) {
return false;
}
}
memcpy(out, in, length);
out[length] = '\0';
return true;
}
/* Reuse the service layer's canonical printable-version and lowercase-SHA256
* validation without importing detailed ABI values into rendezvous. Fixed
* nonzero sentinels on both sides make only version/build ordering observable. */
static cbm_daemon_hello_status_t runtime_rendezvous_compare(const char *active_version,
const char *active_build,
const char *requested_version,
const char *requested_build,
cbm_daemon_conflict_t *conflict_out) {
cbm_daemon_build_identity_t active = {
.semantic_version = active_version,
.build_fingerprint = active_build,
.protocol_abi = 1,
.store_abi = 1,
.feature_abi = 1,
};
cbm_daemon_build_identity_t requested = {
.semantic_version = requested_version,
.build_fingerprint = requested_build,
.protocol_abi = 1,
.store_abi = 1,
.feature_abi = 1,
};
cbm_daemon_hello_status_t status = cbm_daemon_hello_compare(&active, &requested, conflict_out);
if (status != CBM_DAEMON_HELLO_INVALID && status != CBM_DAEMON_HELLO_COMPATIBLE &&
status != CBM_DAEMON_HELLO_VERSION_CONFLICT && status != CBM_DAEMON_HELLO_BUILD_CONFLICT) {
if (conflict_out) {
memset(conflict_out, 0, sizeof(*conflict_out));
conflict_out->status = CBM_DAEMON_HELLO_INVALID;
}
return CBM_DAEMON_HELLO_INVALID;
}
return status;
}
bool cbm_daemon_runtime_hello_request_encode(uint8_t out[CBM_DAEMON_RENDEZVOUS_REQUEST_SIZE],
const cbm_daemon_build_identity_t *identity) {
if (!out || !identity) {
return false;
}
cbm_daemon_conflict_t validation;
if (runtime_rendezvous_compare(identity->semantic_version, identity->build_fingerprint,
identity->semantic_version, identity->build_fingerprint,
&validation) != CBM_DAEMON_HELLO_COMPATIBLE) {
return false;
}
memset(out, 0, CBM_DAEMON_RENDEZVOUS_REQUEST_SIZE);
runtime_put_u32(out + RENDEZVOUS_REQUEST_ABI_OFFSET, CBM_DAEMON_RENDEZVOUS_ABI);
return runtime_wire_string_encode(out + RENDEZVOUS_REQUEST_VERSION_OFFSET,
CBM_DAEMON_RENDEZVOUS_VERSION_TEXT_CAP,
identity->semantic_version, false) &&
runtime_wire_string_encode(out + RENDEZVOUS_REQUEST_BUILD_OFFSET,
CBM_DAEMON_RENDEZVOUS_BUILD_FINGERPRINT_CAP,
identity->build_fingerprint, false);
}
static bool runtime_rendezvous_request_decode(
const uint8_t payload[CBM_DAEMON_RENDEZVOUS_REQUEST_SIZE],
char version[CBM_DAEMON_VERSION_TEXT_SIZE], char build[CBM_DAEMON_BUILD_FINGERPRINT_SIZE]) {
if (!payload || !version || !build ||
runtime_get_u32(payload + RENDEZVOUS_REQUEST_ABI_OFFSET) != CBM_DAEMON_RENDEZVOUS_ABI ||
!runtime_wire_string_decode(payload + RENDEZVOUS_REQUEST_VERSION_OFFSET,
CBM_DAEMON_RENDEZVOUS_VERSION_TEXT_CAP, version, false) ||
!runtime_wire_string_decode(payload + RENDEZVOUS_REQUEST_BUILD_OFFSET,
CBM_DAEMON_RENDEZVOUS_BUILD_FINGERPRINT_CAP, build, false)) {
return false;
}
cbm_daemon_conflict_t validation;
return runtime_rendezvous_compare(version, build, version, build, &validation) ==
CBM_DAEMON_HELLO_COMPATIBLE;
}
static bool runtime_activation_action_valid(cbm_daemon_runtime_activation_action_t action) {
return action == CBM_DAEMON_RUNTIME_ACTIVATION_INSTALL ||
action == CBM_DAEMON_RUNTIME_ACTIVATION_UPDATE ||
action == CBM_DAEMON_RUNTIME_ACTIVATION_UNINSTALL;
}
static const char *runtime_activation_action_text(cbm_daemon_runtime_activation_action_t action) {
switch (action) {
case CBM_DAEMON_RUNTIME_ACTIVATION_INSTALL:
return "install";
case CBM_DAEMON_RUNTIME_ACTIVATION_UPDATE:
return "update";
case CBM_DAEMON_RUNTIME_ACTIVATION_UNINSTALL:
return "uninstall";
default:
return "invalid";
}
}
static bool runtime_activation_request_encode(
uint8_t out[CBM_DAEMON_ACTIVATION_SHUTDOWN_REQUEST_SIZE],
cbm_daemon_runtime_activation_action_t action, const cbm_daemon_build_identity_t *identity) {
if (!out || !identity || !runtime_activation_action_valid(action)) {
return false;
}
memset(out, 0, CBM_DAEMON_ACTIVATION_SHUTDOWN_REQUEST_SIZE);
runtime_put_u32(out + ACTIVATION_REQUEST_ACTION_OFFSET, (uint32_t)action);
return cbm_daemon_runtime_hello_request_encode(out + ACTIVATION_REQUEST_IDENTITY_OFFSET,
identity);
}
static bool runtime_activation_request_decode(
const uint8_t payload[CBM_DAEMON_ACTIVATION_SHUTDOWN_REQUEST_SIZE],
cbm_daemon_runtime_activation_action_t *action_out, char version[CBM_DAEMON_VERSION_TEXT_SIZE],
char build[CBM_DAEMON_BUILD_FINGERPRINT_SIZE]) {
if (!payload || !action_out || !version || !build) {
return false;
}
uint32_t raw_action = runtime_get_u32(payload + ACTIVATION_REQUEST_ACTION_OFFSET);
if (raw_action < (uint32_t)CBM_DAEMON_RUNTIME_ACTIVATION_INSTALL ||
raw_action > (uint32_t)CBM_DAEMON_RUNTIME_ACTIVATION_UNINSTALL ||
!runtime_rendezvous_request_decode(payload + ACTIVATION_REQUEST_IDENTITY_OFFSET, version,
build)) {
return false;
}
cbm_daemon_runtime_activation_action_t action =
(cbm_daemon_runtime_activation_action_t)raw_action;
*action_out = action;
return true;
}
static bool runtime_activation_response_encode(
uint8_t out[CBM_DAEMON_ACTIVATION_SHUTDOWN_RESPONSE_SIZE],
const cbm_daemon_runtime_activation_result_t *result) {
if (!out || !result) {
return false;
}
memset(out, 0, CBM_DAEMON_ACTIVATION_SHUTDOWN_RESPONSE_SIZE);
runtime_put_u32(out + ACTIVATION_RESPONSE_ABI_OFFSET, CBM_DAEMON_RENDEZVOUS_ABI);
runtime_put_u32(out + ACTIVATION_RESPONSE_ACCEPTED_OFFSET, result->accepted ? 1U : 0U);
runtime_put_u64(out + ACTIVATION_RESPONSE_CLIENTS_OFFSET, result->active_clients);
runtime_put_u64(out + ACTIVATION_RESPONSE_CONNECTIONS_OFFSET, result->active_connections);
return true;
}
static bool runtime_activation_response_decode(
const uint8_t payload[CBM_DAEMON_ACTIVATION_SHUTDOWN_RESPONSE_SIZE],
cbm_daemon_runtime_activation_result_t *result_out) {
if (!payload || !result_out ||
runtime_get_u32(payload + ACTIVATION_RESPONSE_ABI_OFFSET) != CBM_DAEMON_RENDEZVOUS_ABI) {
return false;
}
uint32_t accepted = runtime_get_u32(payload + ACTIVATION_RESPONSE_ACCEPTED_OFFSET);
if (accepted > 1U) {
return false;
}
result_out->accepted = accepted == 1U;
result_out->active_clients = runtime_get_u64(payload + ACTIVATION_RESPONSE_CLIENTS_OFFSET);
result_out->active_connections =
runtime_get_u64(payload + ACTIVATION_RESPONSE_CONNECTIONS_OFFSET);
return true;
}
static uint64_t runtime_current_process_id(void) {
#ifdef _WIN32
return (uint64_t)GetCurrentProcessId();
#elif defined(__APPLE__) || defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__)
return (uint64_t)getpid();
#else
return 0;
#endif
}
static void runtime_process_image_reference_init(runtime_process_image_reference_t *reference) {
if (!reference) {
return;
}
memset(reference, 0, sizeof(*reference));
#ifdef _WIN32
reference->file = INVALID_HANDLE_VALUE;
#elif defined(__APPLE__) || defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__)
reference->fd = -1;
#endif
}
static bool runtime_process_image_reference_release(runtime_process_image_reference_t *reference) {
if (!reference) {
return false;
}
bool ok = true;
#ifdef _WIN32
if (reference->file != INVALID_HANDLE_VALUE && !CloseHandle(reference->file)) {
ok = false;
}
#elif defined(__APPLE__) || defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__)
if (reference->fd >= 0 && close(reference->fd) != 0) {
ok = false;
}
#endif
runtime_process_image_reference_init(reference);
return ok;
}
#ifdef _WIN32
typedef struct {
FILETIME creation_time;
wchar_t path[32768];
} runtime_windows_process_image_snapshot_t;
static bool runtime_windows_process_image_snapshot(
HANDLE process, runtime_windows_process_image_snapshot_t *snapshot) {
if (!process || !snapshot) {
return false;
}
memset(snapshot, 0, sizeof(*snapshot));
FILETIME exit_time;
FILETIME kernel_time;
FILETIME user_time;
DWORD exit_code = 0;
DWORD path_length = (DWORD)(sizeof(snapshot->path) / sizeof(snapshot->path[0]));
bool ok = GetProcessTimes(process, &snapshot->creation_time, &exit_time, &kernel_time,
&user_time) != 0 &&
GetExitCodeProcess(process, &exit_code) != 0 && exit_code == STILL_ACTIVE &&
QueryFullProcessImageNameW(process, 0, snapshot->path, &path_length) != 0 &&
path_length > 0 &&
path_length < (DWORD)(sizeof(snapshot->path) / sizeof(snapshot->path[0]));
if (ok) {
snapshot->path[path_length] = L'\0';
}
return ok;
}
static bool runtime_windows_process_image_snapshot_same(
const runtime_windows_process_image_snapshot_t *first,
const runtime_windows_process_image_snapshot_t *second) {
return first && second && CompareFileTime(&first->creation_time, &second->creation_time) == 0 &&
CompareStringOrdinal(first->path, -1, second->path, -1, TRUE) == CSTR_EQUAL;
}
static bool runtime_windows_file_snapshot(HANDLE file, BY_HANDLE_FILE_INFORMATION *information,
LARGE_INTEGER *size) {
if (!information || !size) {
return false;
}
memset(information, 0, sizeof(*information));
size->QuadPart = -1;
return file != INVALID_HANDLE_VALUE && GetFileType(file) == FILE_TYPE_DISK &&
GetFileInformationByHandle(file, information) != 0 &&
(information->dwFileAttributes &
(FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT)) == 0 &&
GetFileSizeEx(file, size) != 0 && size->QuadPart >= 0;
}
static bool runtime_windows_file_snapshot_same(const BY_HANDLE_FILE_INFORMATION *first_information,
const LARGE_INTEGER *first_size,
const BY_HANDLE_FILE_INFORMATION *second_information,
const LARGE_INTEGER *second_size) {
return first_information && first_size && second_information && second_size &&
first_information->dwVolumeSerialNumber == second_information->dwVolumeSerialNumber &&
first_information->nFileIndexHigh == second_information->nFileIndexHigh &&
first_information->nFileIndexLow == second_information->nFileIndexLow &&
first_size->QuadPart == second_size->QuadPart &&
CompareFileTime(&first_information->ftLastWriteTime,
&second_information->ftLastWriteTime) == 0;
}
#elif defined(__APPLE__)
static bool runtime_mac_process_instance(int process_id, struct proc_bsdinfo *info) {
if (!info) {
return false;
}
memset(info, 0, sizeof(*info));
return proc_pidinfo(process_id, PROC_PIDTBSDINFO, 0, info, (int)sizeof(*info)) ==
(int)sizeof(*info) &&
info->pbi_pid == (uint32_t)process_id;
}
static bool runtime_mac_process_instance_same(const struct proc_bsdinfo *first,
const struct proc_bsdinfo *second) {
return first && second && first->pbi_pid == second->pbi_pid &&
first->pbi_start_tvsec == second->pbi_start_tvsec &&
first->pbi_start_tvusec == second->pbi_start_tvusec;
}
static bool runtime_mac_stat_matches_vnode(const struct stat *status,
const struct vinfo_stat *vnode) {
return status && vnode && S_ISREG(vnode->vst_mode) &&
vnode->vst_dev == (uint32_t)status->st_dev &&
vnode->vst_ino == (uint64_t)status->st_ino && vnode->vst_size == status->st_size &&
vnode->vst_mtime == status->st_mtimespec.tv_sec &&
vnode->vst_mtimensec == status->st_mtimespec.tv_nsec &&
vnode->vst_ctime == status->st_ctimespec.tv_sec &&
vnode->vst_ctimensec == status->st_ctimespec.tv_nsec;
}
static bool runtime_mac_stat_same(const struct stat *first, const struct stat *second) {
return first && second && first->st_dev == second->st_dev && first->st_ino == second->st_ino &&
first->st_size == second->st_size &&
first->st_mtimespec.tv_sec == second->st_mtimespec.tv_sec &&
first->st_mtimespec.tv_nsec == second->st_mtimespec.tv_nsec &&
first->st_ctimespec.tv_sec == second->st_ctimespec.tv_sec &&
first->st_ctimespec.tv_nsec == second->st_ctimespec.tv_nsec;
}
static bool runtime_mac_process_maps_file_executable(int process_id, const struct stat *status) {
uint64_t address = 0;
for (size_t region_count = 0; region_count < 65536; region_count++) {
struct proc_regionwithpathinfo region;
memset(®ion, 0, sizeof(region));
int received =
proc_pidinfo(process_id, PROC_PIDREGIONPATHINFO, address, ®ion, (int)sizeof(region));
if (received != (int)sizeof(region)) {
return false;
}
if ((region.prp_prinfo.pri_protection & VM_PROT_EXECUTE) != 0 &&
runtime_mac_stat_matches_vnode(status, ®ion.prp_vip.vip_vi.vi_stat)) {
return true;
}
uint64_t region_address = region.prp_prinfo.pri_address;
uint64_t region_size = region.prp_prinfo.pri_size;
if (region_size == 0 || region_address > UINT64_MAX - region_size) {
return false;
}
uint64_t next = region_address + region_size;
if (next <= address) {
return false;
}
address = next;
}
return false;
}
#elif defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__)
static bool runtime_posix_stat_same_image(const struct stat *first, const struct stat *second) {
return first && second && S_ISREG(first->st_mode) && S_ISREG(second->st_mode) &&
first->st_dev == second->st_dev && first->st_ino == second->st_ino &&
first->st_size == second->st_size && first->st_mtim.tv_sec == second->st_mtim.tv_sec &&
first->st_mtim.tv_nsec == second->st_mtim.tv_nsec &&
first->st_ctim.tv_sec == second->st_ctim.tv_sec &&
first->st_ctim.tv_nsec == second->st_ctim.tv_nsec;
}
#endif
/* Acquire one process instance's mapped image as a native object. Supplying a
* fingerprint hashes that same held object; NULL performs metadata-only
* acquisition for the HELLO fast path. Every platform brackets the process
* identity/image lookup before returning the retained reference. */
static bool runtime_process_image_reference_acquire(
uint64_t process_id, runtime_process_image_reference_t *reference,
char fingerprint[CBM_DAEMON_BUILD_FINGERPRINT_SIZE]) {
if (!reference || process_id == 0) {
return false;
}
runtime_process_image_reference_init(reference);
if (fingerprint) {
fingerprint[0] = '\0';
}
#ifdef _WIN32
if (process_id > MAXDWORD) {
return false;
}
HANDLE process = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, (DWORD)process_id);
if (!process) {
return false;
}
runtime_windows_process_image_snapshot_t process_before;
runtime_windows_process_image_snapshot_t process_after;
BY_HANDLE_FILE_INFORMATION file_before;
BY_HANDLE_FILE_INFORMATION file_after;
LARGE_INTEGER size_before;
LARGE_INTEGER size_after;
bool ok = runtime_windows_process_image_snapshot(process, &process_before);
/* QueryFullProcessImageNameW returns a stable identity spelling for the
* before/after comparison, but its Win32/DOS form may exceed MAX_PATH.
* Keep that snapshot byte-for-byte and use an owned extended spelling only
* at the file-API boundary. */
wchar_t *open_path = ok ? cbm_wide_path_to_extended(process_before.path) : NULL;
HANDLE file = open_path
? CreateFileW(open_path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE,
NULL, OPEN_EXISTING,
FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_SEQUENTIAL_SCAN, NULL)
: INVALID_HANDLE_VALUE;
free(open_path);
ok = ok && runtime_windows_file_snapshot(file, &file_before, &size_before) &&
(!fingerprint || cbm_daemon_build_fingerprint_native_file((uintptr_t)file, fingerprint)) &&
runtime_windows_file_snapshot(file, &file_after, &size_after) &&
runtime_windows_file_snapshot_same(&file_before, &size_before, &file_after, &size_after) &&
runtime_windows_process_image_snapshot(process, &process_after) &&
runtime_windows_process_image_snapshot_same(&process_before, &process_after);
if (!CloseHandle(process)) {
ok = false;
}
if (ok) {
reference->held = true;
reference->file = file;
reference->information = file_after;
reference->size = size_after;
} else if (file != INVALID_HANDLE_VALUE) {
(void)CloseHandle(file);
}
#elif defined(__APPLE__)
if (process_id > INT_MAX) {
return false;
}
int pid = (int)process_id;
struct proc_bsdinfo process_before;
struct proc_bsdinfo process_after;
char path[PROC_PIDPATHINFO_MAXSIZE];
int path_length = 0;
bool ok = runtime_mac_process_instance(pid, &process_before) &&
(path_length = proc_pidpath(pid, path, sizeof(path))) > 0 &&
path_length < (int)sizeof(path);
if (ok) {
path[path_length] = '\0';
}
int fd = ok ? open(path, O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK) : -1;
struct stat file_before;
struct stat file_after;
ok = ok && fd >= 0 && fstat(fd, &file_before) == 0 && S_ISREG(file_before.st_mode) &&
runtime_mac_process_maps_file_executable(pid, &file_before) &&
(!fingerprint || cbm_daemon_build_fingerprint_native_file((uintptr_t)fd, fingerprint)) &&
fstat(fd, &file_after) == 0 && runtime_mac_stat_same(&file_before, &file_after) &&
runtime_mac_process_maps_file_executable(pid, &file_after) &&
runtime_mac_process_instance(pid, &process_after) &&
runtime_mac_process_instance_same(&process_before, &process_after);
if (ok) {
reference->held = true;
reference->fd = fd;
reference->status = file_after;
} else if (fd >= 0) {
(void)close(fd);
}
#elif defined(__linux__)
char proc_path[64];
int written =
snprintf(proc_path, sizeof(proc_path), "/proc/%llu", (unsigned long long)process_id);
if (written <= 0 || written >= (int)sizeof(proc_path)) {
return false;
}
int process_fd = open(proc_path, O_RDONLY | O_DIRECTORY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK);
int image_fd = process_fd >= 0 ? openat(process_fd, "exe", O_RDONLY | O_CLOEXEC) : -1;
struct stat image_before;
struct stat image_after;
bool ok = image_fd >= 0 && fstat(image_fd, &image_before) == 0 &&
S_ISREG(image_before.st_mode) &&
(!fingerprint ||
cbm_daemon_build_fingerprint_native_file((uintptr_t)image_fd, fingerprint)) &&
fstat(image_fd, &image_after) == 0 &&
runtime_posix_stat_same_image(&image_before, &image_after);
int verify_fd = ok ? openat(process_fd, "exe", O_RDONLY | O_CLOEXEC) : -1;
struct stat verify_status;
ok = ok && verify_fd >= 0 && fstat(verify_fd, &verify_status) == 0 &&
runtime_posix_stat_same_image(&image_after, &verify_status);
if (verify_fd >= 0 && close(verify_fd) != 0) {
ok = false;
}
if (process_fd >= 0 && close(process_fd) != 0) {
ok = false;
}
if (ok) {
reference->held = true;
reference->fd = image_fd;
reference->status = image_after;
} else if (image_fd >= 0) {
(void)close(image_fd);
}
#elif defined(__FreeBSD__) || defined(__NetBSD__)
if (process_id > INT_MAX) {
return false;
}
int pid = (int)process_id;
#if defined(__NetBSD__)
int mib[4] = {CTL_KERN, KERN_PROC_ARGS, pid, KERN_PROC_PATHNAME};
#else
int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, pid};
#endif
char path[PATH_MAX];
size_t path_length = sizeof(path);
bool ok = sysctl(mib, 4, path, &path_length, NULL, 0) == 0 && path_length > 0;
if (ok) {
path[path_length < sizeof(path) ? path_length : sizeof(path) - 1] = '\0';
}
int image_fd = ok ? open(path, O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK) : -1;
struct stat image_before;
struct stat image_after;
ok = image_fd >= 0 && fstat(image_fd, &image_before) == 0 && S_ISREG(image_before.st_mode) &&
(!fingerprint ||
cbm_daemon_build_fingerprint_native_file((uintptr_t)image_fd, fingerprint)) &&
fstat(image_fd, &image_after) == 0 &&
runtime_posix_stat_same_image(&image_before, &image_after);
if (ok) {
reference->held = true;
reference->fd = image_fd;
reference->status = image_after;
} else if (image_fd >= 0) {
(void)close(image_fd);
}
#else
(void)process_id;
bool ok = false;
#endif
if (!ok && fingerprint) {
fingerprint[0] = '\0';
}
return ok;
}
/* True when a retained reference is still the unchanged image it captured AND
* the freshly acquired peer maps that same image. Metadata only: no hashing. */
static bool runtime_process_image_reference_same(const runtime_process_image_reference_t *held,
const runtime_process_image_reference_t *peer) {
if (!held || !held->held || !peer || !peer->held) {
return false;
}
#ifdef _WIN32
BY_HANDLE_FILE_INFORMATION held_now;
LARGE_INTEGER held_size_now;
return runtime_windows_file_snapshot(held->file, &held_now, &held_size_now) &&
runtime_windows_file_snapshot_same(&held->information, &held->size, &held_now,
&held_size_now) &&
runtime_windows_file_snapshot_same(&held->information, &held->size, &peer->information,
&peer->size);
#elif defined(__APPLE__)
struct stat held_now;
return fstat(held->fd, &held_now) == 0 && runtime_mac_stat_same(&held->status, &held_now) &&
runtime_mac_stat_same(&held->status, &peer->status);
#elif defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__)
struct stat held_now;
return fstat(held->fd, &held_now) == 0 &&
runtime_posix_stat_same_image(&held->status, &held_now) &&
runtime_posix_stat_same_image(&held->status, &peer->status);
#else
return false;
#endif
}
/* A false result means only "not proven identical". The caller must use the
* full fingerprint fallback before rejecting the peer. */
static bool runtime_process_image_reference_matches_process(
const runtime_process_image_reference_t *active, uint64_t process_id) {
if (!active || !active->held || process_id == 0) {
return false;
}
runtime_process_image_reference_t peer;
runtime_process_image_reference_init(&peer);
bool same = runtime_process_image_reference_acquire(process_id, &peer, NULL) &&
runtime_process_image_reference_same(active, &peer);
bool released = runtime_process_image_reference_release(&peer);
return same && released;
}
bool cbm_daemon_runtime_process_build_fingerprint(uint64_t process_id,
char out[CBM_DAEMON_BUILD_FINGERPRINT_SIZE]) {
if (!out) {
return false;
}
out[0] = '\0';
runtime_process_image_reference_t reference;
runtime_process_image_reference_init(&reference);
bool ok = runtime_process_image_reference_acquire(process_id, &reference, out);
if (!runtime_process_image_reference_release(&reference)) {
ok = false;
}
if (!ok) {
out[0] = '\0';
}
return ok;
}
typedef enum {
RUNTIME_PEER_IMAGE_VERIFIED,
RUNTIME_PEER_IMAGE_UNVERIFIABLE,
RUNTIME_PEER_IMAGE_MISMATCH,
} runtime_peer_image_verdict_t;
static bool runtime_verified_peer_image_known_locked(
const cbm_daemon_runtime_service_t *service, const runtime_process_image_reference_t *peer) {
for (size_t i = 0; i < service->verified_peer_image_count; i++) {
if (runtime_process_image_reference_same(&service->verified_peer_images[i], peer)) {
return true;
}
}
return false;
}
/* #1955: the HELLO must prove the peer runs this daemon's build. The cheap
* proof is "same image file as the daemon"; a peer running a DIFFERENT file
* with identical bytes (a second install path, a package-manager copy) needs
* the full fingerprint, i.e. hashing the whole (~300 MB) image. That hash is
* slower than the client's HELLO budget, so the client abandoned it and every
* re-probe started it again - admission never completed against a healthy
* daemon. A copy is now hashed once: its verified reference is retained and
* later admissions of the same unchanged file match it by metadata, exactly
* like the active image. The accepted set of images is unchanged. */
static runtime_peer_image_verdict_t runtime_peer_image_verify(cbm_daemon_runtime_service_t *service,
uint64_t process_id,
const char *requested_build) {
runtime_process_image_reference_t peer;
runtime_process_image_reference_init(&peer);
bool peer_held = runtime_process_image_reference_acquire(process_id, &peer, NULL);
bool known = false;
if (peer_held) {
known = runtime_process_image_reference_same(&service->active_image, &peer);
#ifdef CBM_ENABLE_TEST_SEAMS
if (atomic_load(&runtime_force_peer_image_distinct_copy_seam)) {
known = false;
}
#endif
if (!known) {
cbm_mutex_lock(&service->mutex);
known = runtime_verified_peer_image_known_locked(service, &peer);
cbm_mutex_unlock(&service->mutex);
}
}
bool released = runtime_process_image_reference_release(&peer);
if (known && released) {
return RUNTIME_PEER_IMAGE_VERIFIED;
}
char fingerprint[CBM_DAEMON_BUILD_FINGERPRINT_SIZE];
runtime_process_image_reference_t hashed;
runtime_process_image_reference_init(&hashed);
runtime_note_peer_image_hash();
bool fingerprinted = runtime_process_image_reference_acquire(process_id, &hashed, fingerprint);
bool verified = fingerprinted && strcmp(fingerprint, requested_build) == 0 &&
strcmp(fingerprint, service->identity.build_fingerprint) == 0;
if (verified) {
cbm_mutex_lock(&service->mutex);
if (service->verified_peer_image_count < RUNTIME_VERIFIED_PEER_IMAGE_CAPACITY &&
!runtime_verified_peer_image_known_locked(service, &hashed)) {
service->verified_peer_images[service->verified_peer_image_count++] = hashed;
runtime_process_image_reference_init(&hashed);
}
cbm_mutex_unlock(&service->mutex);
}
(void)runtime_process_image_reference_release(&hashed);
if (verified) {
return RUNTIME_PEER_IMAGE_VERIFIED;
}
return fingerprinted ? RUNTIME_PEER_IMAGE_MISMATCH : RUNTIME_PEER_IMAGE_UNVERIFIABLE;
}
static void runtime_verified_peer_images_release(cbm_daemon_runtime_service_t *service) {
for (size_t i = 0; i < service->verified_peer_image_count; i++) {
(void)runtime_process_image_reference_release(&service->verified_peer_images[i]);
}
service->verified_peer_image_count = 0;
}
static bool runtime_hello_response_encode(uint8_t out[CBM_DAEMON_RENDEZVOUS_RESPONSE_SIZE],
const cbm_daemon_runtime_connect_result_t *result) {
if (!out || !result) {
return false;
}
memset(out, 0, CBM_DAEMON_RENDEZVOUS_RESPONSE_SIZE);
runtime_put_u32(out + RENDEZVOUS_RESPONSE_CONNECT_STATUS_OFFSET, (uint32_t)result->status);
runtime_put_u32(out + RENDEZVOUS_RESPONSE_HELLO_STATUS_OFFSET, (uint32_t)result->hello_status);
runtime_put_u64(out + RENDEZVOUS_RESPONSE_CLIENT_ID_OFFSET, result->client_id);
runtime_put_u64(out + RENDEZVOUS_RESPONSE_PROCESS_ID_OFFSET, result->authenticated_process_id);
runtime_put_u32(out + RENDEZVOUS_RESPONSE_CONFLICT_STATUS_OFFSET,
(uint32_t)result->conflict.status);
if (!runtime_wire_string_encode(out + RENDEZVOUS_RESPONSE_ACTIVE_VERSION_OFFSET,
CBM_DAEMON_RENDEZVOUS_VERSION_TEXT_CAP,
result->conflict.active_version, true) ||
!runtime_wire_string_encode(out + RENDEZVOUS_RESPONSE_ACTIVE_BUILD_OFFSET,
CBM_DAEMON_RENDEZVOUS_BUILD_FINGERPRINT_CAP,
result->conflict.active_build_fingerprint, true) ||
!runtime_wire_string_encode(out + RENDEZVOUS_RESPONSE_REQUESTED_VERSION_OFFSET,
CBM_DAEMON_RENDEZVOUS_VERSION_TEXT_CAP,
result->conflict.requested_version, true) ||
!runtime_wire_string_encode(out + RENDEZVOUS_RESPONSE_REQUESTED_BUILD_OFFSET,
CBM_DAEMON_RENDEZVOUS_BUILD_FINGERPRINT_CAP,
result->conflict.requested_build_fingerprint, true) ||
!runtime_wire_string_encode(out + RENDEZVOUS_RESPONSE_MESSAGE_OFFSET,
CBM_DAEMON_RENDEZVOUS_MESSAGE_CAP, result->message, true)) {
return false;
}
return true;
}
static bool runtime_hello_response_decode(
const uint8_t payload[CBM_DAEMON_RENDEZVOUS_RESPONSE_SIZE],
cbm_daemon_runtime_connect_result_t *result) {
if (!payload || !result) {
return false;
}
memset(result, 0, sizeof(*result));
result->status = (cbm_daemon_runtime_connect_status_t)runtime_get_u32(
payload + RENDEZVOUS_RESPONSE_CONNECT_STATUS_OFFSET);
result->hello_status = (cbm_daemon_hello_status_t)runtime_get_u32(
payload + RENDEZVOUS_RESPONSE_HELLO_STATUS_OFFSET);
result->client_id = runtime_get_u64(payload + RENDEZVOUS_RESPONSE_CLIENT_ID_OFFSET);
result->authenticated_process_id =
runtime_get_u64(payload + RENDEZVOUS_RESPONSE_PROCESS_ID_OFFSET);
result->conflict.status = (cbm_daemon_hello_status_t)runtime_get_u32(
payload + RENDEZVOUS_RESPONSE_CONFLICT_STATUS_OFFSET);
if (!runtime_wire_string_decode(payload + RENDEZVOUS_RESPONSE_ACTIVE_VERSION_OFFSET,
CBM_DAEMON_RENDEZVOUS_VERSION_TEXT_CAP,
result->conflict.active_version, true) ||
!runtime_wire_string_decode(payload + RENDEZVOUS_RESPONSE_ACTIVE_BUILD_OFFSET,
CBM_DAEMON_RENDEZVOUS_BUILD_FINGERPRINT_CAP,
result->conflict.active_build_fingerprint, true) ||
!runtime_wire_string_decode(payload + RENDEZVOUS_RESPONSE_REQUESTED_VERSION_OFFSET,
CBM_DAEMON_RENDEZVOUS_VERSION_TEXT_CAP,
result->conflict.requested_version, true) ||
!runtime_wire_string_decode(payload + RENDEZVOUS_RESPONSE_REQUESTED_BUILD_OFFSET,
CBM_DAEMON_RENDEZVOUS_BUILD_FINGERPRINT_CAP,
result->conflict.requested_build_fingerprint, true) ||
!runtime_wire_string_decode(payload + RENDEZVOUS_RESPONSE_MESSAGE_OFFSET,
CBM_DAEMON_RENDEZVOUS_MESSAGE_CAP, result->message, true)) {
return false;
}
if (result->status == CBM_DAEMON_RUNTIME_CONNECT_ACCEPTED) {
return result->hello_status == CBM_DAEMON_HELLO_COMPATIBLE &&
result->conflict.status == CBM_DAEMON_HELLO_COMPATIBLE &&
result->client_id != CBM_DAEMON_CLIENT_ID_INVALID &&
result->authenticated_process_id != 0;
}
if (result->status == CBM_DAEMON_RUNTIME_CONNECT_CONFLICT) {
char expected[CBM_DAEMON_RENDEZVOUS_MESSAGE_CAP];
return result->hello_status >= CBM_DAEMON_HELLO_VERSION_CONFLICT &&
result->hello_status <= CBM_DAEMON_HELLO_FEATURE_ABI_CONFLICT &&
result->conflict.status == result->hello_status &&
result->client_id == CBM_DAEMON_CLIENT_ID_INVALID &&
result->authenticated_process_id == 0 &&
cbm_daemon_conflict_format(&result->conflict, expected, sizeof(expected)) &&
strcmp(result->message, expected) == 0;
}
return result->status == CBM_DAEMON_RUNTIME_CONNECT_REJECTED &&
result->hello_status == CBM_DAEMON_HELLO_INVALID &&
result->conflict.status == CBM_DAEMON_HELLO_INVALID &&
result->client_id == CBM_DAEMON_CLIENT_ID_INVALID &&
result->authenticated_process_id == 0;
}
static bool runtime_send_hello_response(cbm_daemon_ipc_connection_t *connection,
const cbm_daemon_runtime_connect_result_t *result) {
uint8_t payload[CBM_DAEMON_RENDEZVOUS_RESPONSE_SIZE];
return runtime_hello_response_encode(payload, result) &&
cbm_daemon_ipc_send_frame(connection, CBM_DAEMON_FRAME_RESPONSE,
CBM_DAEMON_RUNTIME_OP_HELLO, payload,
(uint32_t)sizeof(payload));
}
static bool runtime_worker_send_frame(cbm_daemon_runtime_worker_t *worker,
cbm_daemon_frame_type_t type,
cbm_daemon_runtime_operation_t operation, const void *payload,
uint32_t length) {
if (!worker) {
return false;
}
cbm_mutex_lock(&worker->send_mutex);
bool sent =
worker->connection &&
cbm_daemon_ipc_send_frame(worker->connection, type, (uint16_t)operation, payload, length);
cbm_mutex_unlock(&worker->send_mutex);
return sent;
}
static bool runtime_worker_send_status(cbm_daemon_runtime_worker_t *worker,
cbm_daemon_runtime_operation_t operation, bool success) {
uint8_t payload[STATUS_RESPONSE_SIZE];
runtime_put_u32(payload, success ? 1U : 0U);
return runtime_worker_send_frame(worker, CBM_DAEMON_FRAME_RESPONSE, operation, payload,
(uint32_t)sizeof(payload));
}
static bool runtime_application_status_is_callback_result(
cbm_daemon_runtime_application_status_t status) {
return status == CBM_DAEMON_RUNTIME_APPLICATION_OK ||
status == CBM_DAEMON_RUNTIME_APPLICATION_REJECTED ||
status == CBM_DAEMON_RUNTIME_APPLICATION_HANDLER_ERROR ||
status == CBM_DAEMON_RUNTIME_APPLICATION_CANCELLED;
}
static bool runtime_worker_send_application_response(
cbm_daemon_runtime_worker_t *worker, cbm_daemon_runtime_application_token_t request_token,
cbm_daemon_runtime_application_status_t status, const uint8_t *response,
uint32_t response_length, bool suppress_when_disconnecting) {
if (!worker || request_token == CBM_DAEMON_RUNTIME_APPLICATION_TOKEN_INVALID ||
status <= CBM_DAEMON_RUNTIME_APPLICATION_TRANSPORT_ERROR ||
status > CBM_DAEMON_RUNTIME_APPLICATION_CANCELLED ||
response_length > CBM_DAEMON_RUNTIME_APPLICATION_PAYLOAD_MAX ||
(response_length > 0 && !response)) {
return false;
}
uint64_t wire_length = APPLICATION_RESPONSE_PREFIX_SIZE + (uint64_t)response_length;
if (wire_length > CBM_DAEMON_MAX_FRAME_SIZE || wire_length > UINT32_MAX) {
return false;
}
uint8_t *wire = malloc((size_t)wire_length);
if (!wire) {
return false;
}
runtime_put_u64(wire, request_token);
runtime_put_u32(wire + 8, (uint32_t)status);
runtime_put_u32(wire + 12, response_length);
if (response_length > 0) {
memcpy(wire + APPLICATION_RESPONSE_PREFIX_SIZE, response, response_length);
}
cbm_mutex_lock(&worker->send_mutex);
bool disconnected = suppress_when_disconnecting &&
atomic_load_explicit(&worker->disconnecting, memory_order_acquire);
bool sent = !disconnected && worker->connection &&
cbm_daemon_ipc_send_frame(worker->connection, CBM_DAEMON_FRAME_RESPONSE,
CBM_DAEMON_RUNTIME_OP_APPLICATION_REQUEST, wire,
(uint32_t)wire_length);
cbm_mutex_unlock(&worker->send_mutex);
free(wire);
return sent;
}
static void runtime_result_rejected(cbm_daemon_runtime_connect_result_t *result,
const char *message) {
memset(result, 0, sizeof(*result));
result->status = CBM_DAEMON_RUNTIME_CONNECT_REJECTED;
result->hello_status = CBM_DAEMON_HELLO_INVALID;
result->conflict.status = CBM_DAEMON_HELLO_INVALID;
(void)snprintf(result->message, sizeof(result->message), "%s", message);
}
static void runtime_service_begin_stopping_locked(cbm_daemon_runtime_service_t *service,
uint64_t deadline, bool emergency,
const char *reason) {
if (service->state == CBM_DAEMON_RUNTIME_SERVICE_RUNNING) {
service->state = CBM_DAEMON_RUNTIME_SERVICE_STOPPING;
service->stop_deadline_ms = deadline;
/* The generation's fate is decided here by one of several owners
* (last-client exit, coordinator stop, activation drain, external
* stop). Sessions dropped by the losing side of a race are
* undiagnosable without naming which owner pulled the trigger. */
cbm_log_info("daemon.runtime_stopping", "reason", reason ? reason : "unspecified");
} else if (service->state == CBM_DAEMON_RUNTIME_SERVICE_STOPPING &&
(service->stop_deadline_ms == 0 || deadline < service->stop_deadline_ms)) {
service->stop_deadline_ms = deadline;
}
if (emergency) {
service->emergency_stop = true;
}
}
static void runtime_service_begin_stopping(cbm_daemon_runtime_service_t *service,
uint32_t timeout_ms, bool emergency,
const char *reason) {
uint64_t deadline = runtime_deadline_after(timeout_ms);
cbm_mutex_lock(&service->mutex);
runtime_service_begin_stopping_locked(service, deadline, emergency, reason);
cbm_mutex_unlock(&service->mutex);
}
static void runtime_service_interrupt_connections_except(cbm_daemon_runtime_service_t *service,
cbm_daemon_runtime_worker_t *except_worker,
bool activation_owner) {
uint64_t now_ms = cbm_now_ms();
cbm_mutex_lock(&service->mutex);
if (service->activation_response_inflight && !activation_owner) {
cbm_mutex_unlock(&service->mutex);
return;
}
bool force = service->emergency_stop ||
(service->stop_deadline_ms != 0 && now_ms >= service->stop_deadline_ms);
for (size_t i = 0; i < service->worker_capacity; i++) {
cbm_daemon_runtime_worker_t *worker = &service->workers[i];
if (worker != except_worker && worker->in_use && worker->connection &&
(activation_owner || force || !worker->final_response_inflight)) {
cbm_daemon_ipc_connection_interrupt(worker->connection);
}
}
cbm_mutex_unlock(&service->mutex);
}
static void runtime_service_interrupt_connections(cbm_daemon_runtime_service_t *service) {
runtime_service_interrupt_connections_except(service, NULL, false);
}
/* A cold-storm racer is a connection that has been ACCEPTED but has not yet
* passed HELLO admission (in_use with a live connection, not yet admitted, not
* tearing down) -- a one-shot client still mid-bootstrap. This deliberately
* does NOT count an already-admitted provisional session (HELLO done, app
* session opening): a provisional coordinator client must not keep a retiring
* generation alive (see runtime_worker_disconnect below and the
* daemon_runtime_final_disconnect_rejects_blocked_provisional_session guard).
* Caller holds service->mutex. `except` excludes the departing worker. */
static bool runtime_has_pending_hello_peer_locked(const cbm_daemon_runtime_service_t *service,
const cbm_daemon_runtime_worker_t *except) {
for (size_t i = 0; i < service->worker_capacity; i++) {
const cbm_daemon_runtime_worker_t *worker = &service->workers[i];
if (worker != except && worker->in_use && worker->connection && !worker->admitted &&
!atomic_load_explicit(&worker->disconnecting, memory_order_acquire)) {
return true;
}
}
return false;
}
static void runtime_worker_disconnect(cbm_daemon_runtime_worker_t *worker) {
cbm_daemon_runtime_service_t *service = worker->service;
cbm_daemon_client_id_t client_id = CBM_DAEMON_CLIENT_ID_INVALID;
uint64_t shutdown_deadline = runtime_deadline_after(service->shutdown_timeout_ms);
bool last_committed_left = false;
bool linger_armed = false;
atomic_store_explicit(&worker->disconnecting, true, memory_order_release);
cbm_mutex_lock(&service->mutex);
if (worker->admitted) {
client_id = worker->client_id;
worker->admitted = false;
}
if (worker->admission_committed) {
worker->admission_committed = false;
if (service->committed_clients > 0) {
service->committed_clients--;
}
if (service->committed_clients == 0 && !service->permanent) {
/* A HELLO whose application session is still opening is only a
* provisional coordinator client. It cannot keep the generation
* alive after the final fully committed frontend disconnects.
* A permanent generation (`daemon start`) deliberately survives
* this: only the stop/drain ops or a process kill end it. */
last_committed_left = true;
/* Cold-storm race (2026-09): if another connection is already
* accepted and still mid-HELLO (not yet admitted) when the last
* committed client leaves, it is a one-shot peer racing to commit —
* retiring now strands it on a STOPPING daemon and forces a full
* cold respawn ("cold-storm client failed (racing daemon spawn)").
* Linger a bounded window for it; the accept loop retires the
* generation once that racer drains without committing or the window
* elapses, and a racer that does commit clears the linger
* (runtime_worker_commit_admission). This deliberately lingers ONLY
* for a pre-HELLO racer, never for an already-admitted provisional
* session (HELLO done, app session opening): the contract that a
* provisional coordinator client cannot keep a retiring generation
* alive is preserved (the reject-blocked-provisional-session guard).
* With no such racer — the common single-client case — retire
* immediately, unchanged. (A cross-process cohort peer count is
* unavailable: advisory locks expose presence, not a holder count,
* and Windows LockFileEx has no non-owning probe.) */
if (runtime_has_pending_hello_peer_locked(service, worker)) {
service->ephemeral_linger_deadline_ms =
runtime_deadline_after(runtime_ephemeral_linger_timeout_ms());
linger_armed = true;
} else {
service->ephemeral_linger_deadline_ms = 0;
runtime_service_begin_stopping_locked(service, shutdown_deadline, false,
"last_committed_client_disconnected");
}
}
}
cbm_mutex_unlock(&service->mutex);
if (client_id == CBM_DAEMON_CLIENT_ID_INVALID) {
return;
}
/* Set the coordinator hold BEFORE releasing this client so its last-client
* self-transition to STOPPING is suppressed while a racing peer is still
* mid-HELLO; when no peer is present the hold stays clear so the release
* retires the coordinator normally. last_committed_left implies a committed (hence
* admitted) client, so client_id is always valid here. */
if (last_committed_left) {
cbm_daemon_coordinator_set_linger(service->coordinator, linger_armed);
}
(void)cbm_daemon_client_disconnected(service->coordinator, client_id, cbm_now_ms());
if (worker->application_session_opened && !worker->application_cancelled) {
worker->application_cancelled = true;
service->application.session_cancel(service->application.context,
worker->application_session);
}
if (cbm_daemon_coordinator_state(service->coordinator) == CBM_DAEMON_COORDINATOR_STOPPING) {
runtime_service_begin_stopping(service, service->shutdown_timeout_ms, false,
"coordinator_stopping");
}
}
static bool runtime_worker_service_running(cbm_daemon_runtime_worker_t *worker) {
cbm_daemon_runtime_service_t *service = worker->service;
cbm_mutex_lock(&service->mutex);
bool running = service->state == CBM_DAEMON_RUNTIME_SERVICE_RUNNING;
cbm_mutex_unlock(&service->mutex);
return running;
}
static bool runtime_worker_admit(cbm_daemon_runtime_worker_t *worker,
cbm_daemon_client_id_t *client_id_out) {
cbm_daemon_runtime_service_t *service = worker->service;
cbm_daemon_client_id_t client_id = CBM_DAEMON_CLIENT_ID_INVALID;
cbm_mutex_lock(&service->mutex);
if (service->state == CBM_DAEMON_RUNTIME_SERVICE_RUNNING) {
client_id = cbm_daemon_client_connected(service->coordinator, cbm_now_ms());
if (client_id != CBM_DAEMON_CLIENT_ID_INVALID) {
worker->client_id = client_id;
worker->admitted = true;
worker->admission_committed = false;
service->admitted_total++;
}
}
cbm_mutex_unlock(&service->mutex);
*client_id_out = client_id;
return client_id != CBM_DAEMON_CLIENT_ID_INVALID;
}
static bool runtime_worker_commit_admission(cbm_daemon_runtime_worker_t *worker) {
cbm_daemon_runtime_service_t *service = worker->service;
cbm_mutex_lock(&service->mutex);
bool committed = service->state == CBM_DAEMON_RUNTIME_SERVICE_RUNNING && worker->admitted &&
!worker->admission_committed;
if (committed) {
worker->admission_committed = true;
service->committed_clients++;
/* A freshly committed client ends any last-client linger window; the
* next drop to zero re-arms it against the participants outstanding
* then. */
service->ephemeral_linger_deadline_ms = 0;
}
cbm_mutex_unlock(&service->mutex);
if (committed) {
/* Mirror the cleared linger onto the coordinator. client_count is
* already nonzero (admission incremented it), so this only resets the
* hold for the next idle window — it never retires a live coordinator. */
cbm_daemon_coordinator_set_linger(service->coordinator, false);
}
return committed;
}
static bool runtime_worker_handle_subscribe(cbm_daemon_runtime_worker_t *worker,
const uint8_t *payload, uint32_t length) {
if (!runtime_worker_service_running(worker) || !payload ||
length < SUBSCRIBE_REQUEST_PREFIX_SIZE) {
return false;
}
uint32_t key_length = runtime_get_u32(payload);
if (key_length == 0 || key_length > CBM_DAEMON_RUNTIME_PROJECT_KEY_MAX ||
length != SUBSCRIBE_REQUEST_PREFIX_SIZE + key_length) {
return false;
}
char project_key[CBM_DAEMON_RUNTIME_PROJECT_KEY_MAX + 1];
memcpy(project_key, payload + SUBSCRIBE_REQUEST_PREFIX_SIZE, key_length);
project_key[key_length] = '\0';
if (memchr(project_key, '\0', key_length) != NULL) {
return false;
}
cbm_daemon_subscription_id_t subscription_id = CBM_DAEMON_SUBSCRIPTION_ID_INVALID;
cbm_daemon_subscription_result_t result = cbm_daemon_job_subscribe(
worker->service->coordinator, worker->client_id, project_key, &subscription_id);
uint8_t response[SUBSCRIBE_RESPONSE_SIZE];
runtime_put_u32(response, (uint32_t)result);
runtime_put_u64(response + 4, subscription_id);
return runtime_worker_send_frame(worker, CBM_DAEMON_FRAME_RESPONSE,
CBM_DAEMON_RUNTIME_OP_JOB_SUBSCRIBE, response,
(uint32_t)sizeof(response));
}
static bool runtime_worker_handle_unsubscribe(cbm_daemon_runtime_worker_t *worker,
const uint8_t *payload, uint32_t length) {
if (!runtime_worker_service_running(worker) || !payload || length != UNSUBSCRIBE_REQUEST_SIZE) {
return false;
}
cbm_daemon_subscription_id_t subscription_id = runtime_get_u64(payload);
bool removed = cbm_daemon_job_unsubscribe(worker->service->coordinator, worker->client_id,
subscription_id);
return runtime_worker_send_status(worker, CBM_DAEMON_RUNTIME_OP_JOB_UNSUBSCRIBE, removed);
}
static void *runtime_application_worker(void *opaque) {
cbm_daemon_runtime_worker_t *worker = opaque;
cbm_daemon_runtime_service_t *service = worker->service;
uint8_t *response = NULL;
uint32_t response_length = 0;
cbm_daemon_runtime_application_status_t status = service->application.request(
service->application.context, worker->application_session,
worker->application_request_token, worker->application_request,
worker->application_request_length, &response, &response_length);
bool valid_status = runtime_application_status_is_callback_result(status);
bool valid_response =
response_length <= CBM_DAEMON_RUNTIME_APPLICATION_PAYLOAD_MAX &&
(response_length == 0 || response != NULL) &&
(status == CBM_DAEMON_RUNTIME_APPLICATION_OK || (response == NULL && response_length == 0));
if (!valid_status || !valid_response) {
free(response);
response = NULL;
response_length = 0;
status = CBM_DAEMON_RUNTIME_APPLICATION_HANDLER_ERROR;
}
/* Completion must be one atomic transition from the client's point of
* view: publish the done flag BEFORE the response bytes leave, so by the
* time any client can react to the response, admission already observes
* this slot as reusable. With the store after the send, a client that
* pipelines its next request the moment it sees a response raced this
* thread's final instructions and was rejected BUSY — on loaded Windows
* hosts roughly half of all back-to-back requests on one connection,
* surfacing as the wandering Phase 5 session drops. The admission side
* joins this thread after observing the flag, which safely absorbs the
* tail of the send. */
atomic_store_explicit(&worker->application_thread_done, true, memory_order_release);
bool sent = runtime_worker_send_application_response(worker, worker->application_request_token,
status, response, response_length, true);
free(response);
if (!sent && !atomic_load_explicit(&worker->disconnecting, memory_order_acquire)) {
cbm_daemon_ipc_connection_interrupt(worker->connection);
}
return NULL;
}
static _Noreturn void runtime_cleanup_fail_stop(const char *component);
static void runtime_contain_unresponsive_application(cbm_daemon_runtime_worker_t *worker) {
char peer_pid[32];
char token[32];
(void)snprintf(peer_pid, sizeof(peer_pid), "%llu", (unsigned long long)worker->peer_process_id);
(void)snprintf(token, sizeof(token), "%llu",
(unsigned long long)worker->application_request_token);
cbm_log_error("daemon.application_request_unresponsive", "peer_pid", peer_pid, "request_token",
token);
#ifdef CBM_ENABLE_TEST_SEAMS
cbm_daemon_runtime_containment_hook_t hook = atomic_load(&runtime_containment_hook_seam);
if (hook) {
hook("application_request_join");
return;
}
#endif
runtime_cleanup_fail_stop("application_request_join");
}
static bool runtime_worker_reap_application(cbm_daemon_runtime_worker_t *worker, bool wait) {
if (!worker->application_thread_started) {
return true;
}
if (!wait && !atomic_load_explicit(&worker->application_thread_done, memory_order_acquire)) {
return false;
}
if (!atomic_load_explicit(&worker->application_thread_done, memory_order_acquire)) {
/* The peer is gone and session_cancel already ran, so the handler owes
* a prompt return; only a handler that ignores cancellation reaches
* the ceiling. An unbounded join here once turned one wedged request
* into a whole-daemon zombie (2026-08-29): the disconnect path
* blocked, the worker slot never released, and the dead generation
* held the endpoint pipes and UI port for nine hours with nothing
* logged while every new client timed out bare. Containment
* terminates the process instead — the kernel releases every native
* claim and the next client starts a fresh generation. */
uint32_t timeout_ms = RUNTIME_ABANDONED_REQUEST_JOIN_TIMEOUT_MS;
#ifdef CBM_ENABLE_TEST_SEAMS
uint32_t seam_timeout = atomic_load(&runtime_abandoned_request_join_timeout_seam);
if (seam_timeout != 0) {
timeout_ms = seam_timeout;
}
#endif
uint64_t deadline = runtime_deadline_after(timeout_ms);
while (!atomic_load_explicit(&worker->application_thread_done, memory_order_acquire)) {
if (cbm_now_ms() >= deadline) {
/* Terminal in production. A test containment hook returns, and
* the join then waits for the harness to release the handler
* so teardown stays leak-free under the sanitizers. */
runtime_contain_unresponsive_application(worker);
deadline = UINT64_MAX;
}
runtime_wait_tick(deadline);
}
}
if (cbm_thread_join(&worker->application_thread) != 0) {
return false;
}
worker->application_thread_started = false;
free(worker->application_request);
worker->application_request = NULL;
worker->application_request_length = 0;
worker->application_request_token = CBM_DAEMON_RUNTIME_APPLICATION_TOKEN_INVALID;
atomic_store_explicit(&worker->application_thread_done, false, memory_order_release);
return true;
}
static bool runtime_worker_handle_application(cbm_daemon_runtime_worker_t *worker,
const uint8_t *payload, uint32_t length) {
if (!payload || length < APPLICATION_REQUEST_PREFIX_SIZE) {
return false;
}
cbm_daemon_runtime_application_token_t request_token = runtime_get_u64(payload);
uint32_t request_length = runtime_get_u32(payload + 8);
if (request_length > CBM_DAEMON_RUNTIME_APPLICATION_PAYLOAD_MAX ||
length != APPLICATION_REQUEST_PREFIX_SIZE + request_length ||
request_token == CBM_DAEMON_RUNTIME_APPLICATION_TOKEN_INVALID ||
request_token <= worker->last_application_request_token) {
return false;
}
/* A structurally valid token is consumed at admission, including BUSY,
* UNAVAILABLE, and local allocation/thread failures. Reusing a token after
* any terminal response would make late cancellation controls ambiguous. */
worker->last_application_request_token = request_token;
cbm_daemon_runtime_service_t *service = worker->service;
if (!service->application.request) {
return runtime_worker_send_application_response(
worker, request_token, CBM_DAEMON_RUNTIME_APPLICATION_UNAVAILABLE, NULL, 0, false);
}
(void)runtime_worker_reap_application(worker, false);
if (worker->application_thread_started) {
return runtime_worker_send_application_response(
worker, request_token, CBM_DAEMON_RUNTIME_APPLICATION_BUSY, NULL, 0, false);
}
uint8_t *request_copy = NULL;
if (request_length > 0) {
request_copy = malloc(request_length);
if (!request_copy) {
return runtime_worker_send_application_response(
worker, request_token, CBM_DAEMON_RUNTIME_APPLICATION_HANDLER_ERROR, NULL, 0,
false);
}
memcpy(request_copy, payload + APPLICATION_REQUEST_PREFIX_SIZE, request_length);
}
worker->application_request_token = request_token;
worker->application_request = request_copy;
worker->application_request_length = request_length;
atomic_store_explicit(&worker->application_thread_done, false, memory_order_release);
if (cbm_thread_create(&worker->application_thread, RUNTIME_WORKER_STACK_SIZE,
runtime_application_worker, worker) != 0) {
free(worker->application_request);
worker->application_request = NULL;
worker->application_request_length = 0;
return runtime_worker_send_application_response(
worker, request_token, CBM_DAEMON_RUNTIME_APPLICATION_HANDLER_ERROR, NULL, 0, false);
}
worker->application_thread_started = true;
return true;
}
static bool runtime_worker_handle_application_cancel(cbm_daemon_runtime_worker_t *worker,
const uint8_t *payload, uint32_t length) {
if (!worker || !payload || length != APPLICATION_CANCEL_REQUEST_SIZE) {
return false;
}
cbm_daemon_runtime_application_token_t request_token = runtime_get_u64(payload);
if (request_token == CBM_DAEMON_RUNTIME_APPLICATION_TOKEN_INVALID) {
return false;
}
if (worker->application_thread_started && worker->application_request_token == request_token &&
!atomic_load_explicit(&worker->application_thread_done, memory_order_acquire)) {
worker->service->application.request_cancel(worker->service->application.context,
worker->application_session, request_token);
}
/* Cancellation is deliberately one-way. A stale exact-sized token is a
* harmless no-op and never changes stream response ordering. */
return true;
}
static bool runtime_worker_handle_close_intent(cbm_daemon_runtime_worker_t *worker,
uint32_t length) {
if (length != 0) {
return false;
}
/* Terminal for the session (admission, coordinator registration, session
* cancel), but not for the connection: the worker keeps reading so the
* in-flight response tail and the eventual EOF unwind normally. */
runtime_worker_disconnect(worker);
return true;
}
static bool runtime_worker_handle_disconnect(cbm_daemon_runtime_worker_t *worker, uint32_t length) {
if (length != 0) {
return false;
}
cbm_daemon_runtime_service_t *service = worker->service;
cbm_mutex_lock(&service->mutex);
worker->final_response_inflight = true;
cbm_mutex_unlock(&service->mutex);
runtime_worker_disconnect(worker);
bool sent = runtime_worker_send_status(worker, CBM_DAEMON_RUNTIME_OP_DISCONNECT, true);
cbm_mutex_lock(&service->mutex);
worker->final_response_inflight = false;
cbm_mutex_unlock(&service->mutex);
return sent;
}
static void runtime_worker_finish(cbm_daemon_runtime_worker_t *worker) {
cbm_daemon_runtime_service_t *service = worker->service;
runtime_worker_disconnect(worker);
if (!runtime_worker_reap_application(worker, true)) {
/* Fail closed on an impossible/invalid join rather than closing the
* session or freeing storage a callback could still reference. The
* service intentionally remains non-terminal for diagnosis. */
return;
}
if (worker->application_session_opened) {
service->application.session_close(service->application.context,
worker->application_session);
worker->application_session = NULL;
worker->application_session_opened = false;
}
if (worker->connection) {
/* Off the service mutex: a peer that just received its final response
* (hello rejection, disconnect acknowledgement) must be able to read
* it before the handle closes; see cbm_daemon_ipc_connection_drain. */
cbm_daemon_ipc_connection_drain(worker->connection, RUNTIME_WORKER_DRAIN_TIMEOUT_MS);
}
cbm_mutex_lock(&service->mutex);
if (worker->connection) {
cbm_daemon_ipc_connection_close(worker->connection);
worker->connection = NULL;
}
if (service->active_connections > 0) {
service->active_connections--;
}
atomic_store_explicit(&worker->done, true, memory_order_release);
cbm_mutex_unlock(&service->mutex);
}
static bool runtime_activation_peer_matches_claim(cbm_daemon_runtime_service_t *service,
uint64_t process_id, const char *claimed_build) {
if (!service || process_id == 0 || !claimed_build) {
return false;
}
bool active_image =
runtime_process_image_reference_matches_process(&service->active_image, process_id);
if (active_image) {
return strcmp(claimed_build, service->identity.build_fingerprint) == 0;
}
char peer_fingerprint[CBM_DAEMON_BUILD_FINGERPRINT_SIZE];
return cbm_daemon_runtime_process_build_fingerprint(process_id, peer_fingerprint) &&
strcmp(peer_fingerprint, claimed_build) == 0;
}
static bool runtime_control_request_decode(const uint8_t *payload, uint32_t length,
char build_out[CBM_DAEMON_BUILD_FINGERPRINT_SIZE]) {
if (!payload || length != CBM_DAEMON_CONTROL_REQUEST_SIZE ||
payload[CBM_DAEMON_CONTROL_REQUEST_SIZE - 1U] != 0U) {
return false;
}
memcpy(build_out, payload, CBM_DAEMON_BUILD_FINGERPRINT_SIZE);
return strlen(build_out) == CBM_DAEMON_BUILD_FINGERPRINT_SIZE - 1U;
}
static void runtime_control_collect_clients_locked(cbm_daemon_runtime_service_t *service,
cbm_daemon_runtime_worker_t *except,
uint8_t *count_out,
uint32_t pids[CBM_DAEMON_CONTROL_CLIENT_CAP]) {
uint8_t count = 0U;
for (size_t index = 0; index < service->worker_capacity; index++) {
cbm_daemon_runtime_worker_t *candidate = &service->workers[index];
if (!candidate->in_use || !candidate->admission_committed || candidate == except) {
continue;
}
if (count < CBM_DAEMON_CONTROL_CLIENT_CAP) {
pids[count] = (uint32_t)candidate->peer_process_id;
}
count++;
}
*count_out =
count > CBM_DAEMON_CONTROL_CLIENT_CAP ? (uint8_t)CBM_DAEMON_CONTROL_CLIENT_CAP : count;
}
static void runtime_worker_handle_status(cbm_daemon_runtime_worker_t *worker,
const uint8_t *payload, uint32_t length) {
cbm_daemon_runtime_service_t *service = worker->service;
char requested_build[CBM_DAEMON_BUILD_FINGERPRINT_SIZE] = {0};
bool peer_verified =
runtime_control_request_decode(payload, length, requested_build) &&
runtime_activation_peer_matches_claim(service, worker->peer_process_id, requested_build);
uint8_t response[CBM_DAEMON_STATUS_RESPONSE_SIZE];
memset(response, 0, sizeof(response));
if (peer_verified) {
uint8_t count = 0U;
uint32_t pids[CBM_DAEMON_CONTROL_CLIENT_CAP] = {0};
cbm_mutex_lock(&service->mutex);
response[0] = 1U;
response[1] =
(uint8_t)((service->permanent ? 0x01U : 0U) |
(service->state != CBM_DAEMON_RUNTIME_SERVICE_RUNNING ? 0x02U : 0U));
uint16_t committed = service->committed_clients > UINT16_MAX
? UINT16_MAX
: (uint16_t)service->committed_clients;
response[2] = (uint8_t)(committed >> 8);
response[3] = (uint8_t)(committed & 0xFFU);
uint32_t daemon_pid = (uint32_t)runtime_current_process_id();
response[4] = (uint8_t)(daemon_pid >> 24);
response[5] = (uint8_t)(daemon_pid >> 16);
response[6] = (uint8_t)(daemon_pid >> 8);
response[7] = (uint8_t)(daemon_pid & 0xFFU);
runtime_control_collect_clients_locked(service, worker, &count, pids);
response[8] = count;
for (size_t index = 0; index < CBM_DAEMON_CONTROL_CLIENT_CAP; index++) {
size_t offset = 12U + index * 4U;
response[offset] = (uint8_t)(pids[index] >> 24);
response[offset + 1U] = (uint8_t)(pids[index] >> 16);
response[offset + 2U] = (uint8_t)(pids[index] >> 8);
response[offset + 3U] = (uint8_t)(pids[index] & 0xFFU);
}
(void)snprintf((char *)response + 44U, CBM_DAEMON_BUILD_FINGERPRINT_SIZE, "%s",
service->identity.build_fingerprint);
(void)snprintf((char *)response + 109U, 12U, "%s",
service->identity.semantic_version ? service->identity.semantic_version
: "");
cbm_mutex_unlock(&service->mutex);
}
(void)runtime_worker_send_frame(worker, CBM_DAEMON_FRAME_RESPONSE, CBM_DAEMON_RUNTIME_OP_STATUS,
response, (uint32_t)sizeof(response));
runtime_worker_finish(worker);
}
static void runtime_worker_handle_stop(cbm_daemon_runtime_worker_t *worker, const uint8_t *payload,
uint32_t length) {
cbm_daemon_runtime_service_t *service = worker->service;
char requested_build[CBM_DAEMON_BUILD_FINGERPRINT_SIZE] = {0};
bool peer_verified =
runtime_control_request_decode(payload, length, requested_build) &&
runtime_activation_peer_matches_claim(service, worker->peer_process_id, requested_build);
uint8_t response[CBM_DAEMON_STOP_RESPONSE_SIZE];
memset(response, 0, sizeof(response));
bool accepted = false;
if (peer_verified) {
uint8_t count = 0U;
uint32_t pids[CBM_DAEMON_CONTROL_CLIENT_CAP] = {0};
uint64_t deadline = runtime_deadline_after(service->shutdown_timeout_ms);
cbm_mutex_lock(&service->mutex);
response[0] = 1U;
uint16_t committed = service->committed_clients > UINT16_MAX
? UINT16_MAX
: (uint16_t)service->committed_clients;
runtime_control_collect_clients_locked(service, worker, &count, pids);
if (service->committed_clients > 0) {
/* Refuse-if-busy: the caller reports these pids to the user as
* the processes that must exit before a graceful stop. */
response[1] = 0x02U;
} else if (service->state == CBM_DAEMON_RUNTIME_SERVICE_RUNNING) {
/* Explicit stop is the sanctioned exit for PERMANENT generations
* as well — begin_stopping here overrides the permanence gate.
* Mirror the activation-shutdown ACK protocol: the stopping
* teardown must not consume this requester's response slot before
* the acceptance byte leaves. */
runtime_service_begin_stopping_locked(service, deadline, false,
"daemon_stop_requested");
/* Same exit criterion as an activation drain: a permanent
* coordinator never reports client-terminal, so resource
* emptiness must be allowed to complete this stop promptly. */
service->activation_shutdown_requested = true;
service->activation_response_inflight = true;
worker->final_response_inflight = true;
response[1] = 0x01U;
accepted = true;
}
response[2] = (uint8_t)(committed >> 8);
response[3] = (uint8_t)(committed & 0xFFU);
response[4] = count;
for (size_t index = 0; index < CBM_DAEMON_CONTROL_CLIENT_CAP; index++) {
size_t offset = 8U + index * 4U;
response[offset] = (uint8_t)(pids[index] >> 24);
response[offset + 1U] = (uint8_t)(pids[index] >> 16);
response[offset + 2U] = (uint8_t)(pids[index] >> 8);
response[offset + 3U] = (uint8_t)(pids[index] & 0xFFU);
}
cbm_mutex_unlock(&service->mutex);
}
if (accepted) {
char requester_pid[32];
(void)snprintf(requester_pid, sizeof(requester_pid), "%llu",
(unsigned long long)worker->peer_process_id);
cbm_log_info("daemon.stop_requested", "requester_pid", requester_pid, "requester_build",
requested_build);
runtime_service_interrupt_connections_except(worker->service, worker, true);
}
(void)runtime_worker_send_frame(worker, CBM_DAEMON_FRAME_RESPONSE, CBM_DAEMON_RUNTIME_OP_STOP,
response, (uint32_t)sizeof(response));
if (accepted) {
cbm_daemon_runtime_service_t *stop_service = worker->service;
runtime_worker_finish(worker);
cbm_mutex_lock(&stop_service->mutex);
worker->final_response_inflight = false;
stop_service->activation_response_inflight = false;
cbm_mutex_unlock(&stop_service->mutex);
runtime_service_interrupt_connections(stop_service);
return;
}
runtime_worker_finish(worker);
}
static void runtime_worker_handle_activation_shutdown(cbm_daemon_runtime_worker_t *worker,
const uint8_t *payload, uint32_t length) {
cbm_daemon_runtime_service_t *service = worker->service;
cbm_daemon_runtime_activation_result_t result = {0};
cbm_daemon_runtime_activation_action_t action = 0;
char requested_version[CBM_DAEMON_VERSION_TEXT_SIZE] = {0};
char requested_build[CBM_DAEMON_BUILD_FINGERPRINT_SIZE] = {0};
bool request_valid =
length == CBM_DAEMON_ACTIVATION_SHUTDOWN_REQUEST_SIZE && payload &&
runtime_activation_request_decode(payload, &action, requested_version, requested_build);
bool peer_verified = request_valid && runtime_activation_peer_matches_claim(
service, worker->peer_process_id, requested_build);
if (peer_verified) {
uint64_t deadline = runtime_deadline_after(service->shutdown_timeout_ms);
cbm_mutex_lock(&service->mutex);
result.active_clients = (uint64_t)service->committed_clients;
/* Report only connections this request will drain. The authenticated
* one-shot requester is never a session and excludes itself. */
result.active_connections =
service->active_connections > 0 ? (uint64_t)(service->active_connections - 1U) : 0;
if (service->state == CBM_DAEMON_RUNTIME_SERVICE_RUNNING) {
runtime_service_begin_stopping_locked(service, deadline, false, "activation_shutdown");
service->activation_shutdown_requested = true;
service->activation_response_inflight = true;
worker->final_response_inflight = true;
result.accepted = true;
}
cbm_mutex_unlock(&service->mutex);
}
uint8_t response[CBM_DAEMON_ACTIVATION_SHUTDOWN_RESPONSE_SIZE];
bool encoded = runtime_activation_response_encode(response, &result);
if (result.accepted) {
char requester_pid[32];
char active_clients[32];
char active_connections[32];
(void)snprintf(requester_pid, sizeof(requester_pid), "%llu",
(unsigned long long)worker->peer_process_id);
(void)snprintf(active_clients, sizeof(active_clients), "%llu",
(unsigned long long)result.active_clients);
(void)snprintf(active_connections, sizeof(active_connections), "%llu",
(unsigned long long)result.active_connections);
cbm_log_info("daemon.activation_shutdown", "requester_pid", requester_pid,
"requester_build", requested_build, "action",
runtime_activation_action_text(action), "active_clients", active_clients,
"active_connections", active_connections);
/* Interrupt every other connection BEFORE the ACK leaves: the ACK is
* the requester's license to act on "snapshotted and draining", so
* every drain must already be initiated when it arrives. Acking first
* left a window where a session could still get one request serviced
* after the requester observed the ACK. The requester itself is
* excepted and its response path stays protected. */
runtime_service_interrupt_connections_except(service, worker, true);
}
bool response_sent =
encoded && runtime_worker_send_frame(worker, CBM_DAEMON_FRAME_RESPONSE,
CBM_DAEMON_RUNTIME_OP_ACTIVATION_SHUTDOWN, response,
(uint32_t)sizeof(response));
if (result.accepted && !response_sent) {
cbm_log_error("daemon.activation_shutdown_ack_failed", "shutdown", "accepted",
"requester_build", requested_build, "action",
runtime_activation_action_text(action));
}
if (result.accepted) {
/* Close this requester normally, then release the global ACK gate so
* the accept loop can finish any stragglers. */
runtime_worker_finish(worker);
cbm_mutex_lock(&service->mutex);
worker->final_response_inflight = false;
service->activation_response_inflight = false;
cbm_mutex_unlock(&service->mutex);
runtime_service_interrupt_connections(service);
return;
}
runtime_worker_finish(worker);
}
/* The first frame is due within the request deadline. Under the item-12 seam a
* connection that never sends one holds its slot until it closes; stop still
* interrupts the wait like any other worker receive. */
static uint32_t runtime_first_frame_timeout_ms(const cbm_daemon_runtime_service_t *service) {
#ifdef CBM_ENABLE_TEST_SEAMS
if (atomic_load(&runtime_hold_peer_waits_seam)) {
return CBM_DAEMON_IPC_WAIT_FOREVER;
}
#endif
return service->request_timeout_ms;
}
/* Under the same seam an inline rejection's drain ends only on the peer's
* close, never on the 250 ms bound (the drain only waits on Windows). */
static uint32_t runtime_reject_drain_timeout_ms(void) {
#ifdef CBM_ENABLE_TEST_SEAMS
if (atomic_load(&runtime_hold_peer_waits_seam)) {
return CBM_DAEMON_IPC_WAIT_FOREVER;
}
#endif
return RUNTIME_REJECT_DRAIN_TIMEOUT_MS;
}
static void *runtime_connection_worker(void *opaque) {
cbm_daemon_runtime_worker_t *worker = opaque;
cbm_daemon_runtime_service_t *service = worker->service;
cbm_daemon_frame_t frame = {0};
uint8_t *payload = NULL;
char requested_version[CBM_DAEMON_VERSION_TEXT_SIZE];
char requested_build[CBM_DAEMON_BUILD_FINGERPRINT_SIZE];
int received = cbm_daemon_ipc_receive_frame_bounded(
worker->connection, runtime_first_frame_timeout_ms(service),
CBM_DAEMON_ACTIVATION_SHUTDOWN_REQUEST_SIZE, &frame, &payload);
if (received != 1 || frame.type != CBM_DAEMON_FRAME_REQUEST) {
free(payload);
runtime_worker_finish(worker);
return NULL;
}
if (frame.flags == CBM_DAEMON_RUNTIME_OP_ACTIVATION_SHUTDOWN) {
runtime_worker_handle_activation_shutdown(worker, payload, frame.length);
free(payload);
return NULL;
}
if (frame.flags == CBM_DAEMON_RUNTIME_OP_STATUS) {
runtime_worker_handle_status(worker, payload, frame.length);
free(payload);
return NULL;
}
if (frame.flags == CBM_DAEMON_RUNTIME_OP_STOP) {
runtime_worker_handle_stop(worker, payload, frame.length);
free(payload);
return NULL;
}
if (frame.flags != CBM_DAEMON_RUNTIME_OP_HELLO ||
frame.length != CBM_DAEMON_RENDEZVOUS_REQUEST_SIZE ||
!runtime_rendezvous_request_decode(payload, requested_version, requested_build)) {
free(payload);
runtime_worker_finish(worker);
return NULL;
}
free(payload);
payload = NULL;
cbm_daemon_runtime_connect_result_t hello_result;
memset(&hello_result, 0, sizeof(hello_result));
cbm_daemon_hello_status_t hello_status = runtime_rendezvous_compare(
service->identity.semantic_version, service->identity.build_fingerprint, requested_version,
requested_build, &hello_result.conflict);
if (hello_status != CBM_DAEMON_HELLO_COMPATIBLE) {
if (hello_status == CBM_DAEMON_HELLO_INVALID) {
runtime_worker_finish(worker);
return NULL;
}
hello_result.status = CBM_DAEMON_RUNTIME_CONNECT_CONFLICT;
hello_result.hello_status = hello_status;
(void)cbm_daemon_conflict_format(&hello_result.conflict, hello_result.message,
sizeof(hello_result.message));
if (!cbm_daemon_conflict_log_append(service->conflict_log_path, &hello_result.conflict,
service->conflict_log_cap_bytes)) {
/* This goes through the daemon operation-log sink, never back
* through the failed conflict-log path. Do not silently lose the
* durable startup-conflict diagnostic. */
cbm_log_error("daemon.conflict_log_append_failed", "path", service->conflict_log_path);
}
(void)runtime_send_hello_response(worker->connection, &hello_result);
runtime_worker_finish(worker);
return NULL;
}
runtime_peer_image_verdict_t peer_image =
runtime_peer_image_verify(service, worker->peer_process_id, requested_build);
bool peer_image_verified = peer_image == RUNTIME_PEER_IMAGE_VERIFIED;
bool peer_image_fingerprinted = peer_image != RUNTIME_PEER_IMAGE_UNVERIFIABLE;
#ifdef CBM_ENABLE_TEST_SEAMS
if (atomic_load(&runtime_force_peer_image_unverified_seam)) {
peer_image_verified = false;
peer_image_fingerprinted = false;
}
if (atomic_load(&runtime_force_peer_image_mismatch_seam)) {
peer_image_verified = false;
peer_image_fingerprinted = true;
}
#endif
/* Two different failures wear the same "unverified" flag, and treating them
* alike broke every ephemeral-path client (#1539/#1383):
*
* fingerprint_mismatch — the peer's image WAS read and hashes differently
* than the running daemon. That is the tamper/skew case the gate exists
* for. Still rejected, hard.
* image_unverifiable — the peer's image could not be examined at all
* (ephemeral npx cache paths, ptrace_scope restrictions, sandboxed
* hosts). Nothing was contradicted; we simply could not look. The peer
* ALREADY proved semantic version, build fingerprint, protocol/store/
* feature ABI and cache root in the HELLO exchange above — rejecting on
* top of that traded a real compatibility proof for an unavailable one,
* and made `npx codebase-memory-mcp` unusable with the daemon. Admit,
* and say so out loud so the weaker check is never invisible. */
if (!peer_image_verified && !peer_image_fingerprinted) {
cbm_log_warn("daemon.client_image_unverifiable_admitted", "reason", "image_unverifiable",
"basis", "rendezvous_hello_verified");
peer_image_verified = true;
}
if (!peer_image_verified) {
cbm_log_error("daemon.client_image_rejected", "reason", "fingerprint_mismatch");
/* #1383: answer the peer before closing. An unanswered rejection is
* indistinguishable from a slow cold start on the client side — the
* caller sat on "pending" indefinitely with the reason visible only in
* the daemon log. The version-conflict path above already responds to
* unverified peers, so this discloses nothing new to a same-uid local
* peer; admission stays rejected either way. */
runtime_result_rejected(&hello_result, "CBM daemon rejected this client's binary image");
(void)snprintf(hello_result.message, sizeof(hello_result.message),
"CBM daemon rejected this client: fingerprint_mismatch. The client binary "
"must match the running daemon's build; close CBM sessions (or run "
"'daemon stop') and retry with one consistent install.");
(void)runtime_send_hello_response(worker->connection, &hello_result);
runtime_worker_finish(worker);
return NULL;
}
cbm_daemon_client_id_t client_id = CBM_DAEMON_CLIENT_ID_INVALID;
if (!runtime_worker_admit(worker, &client_id)) {
runtime_result_rejected(&hello_result, "CBM daemon is stopping");
(void)runtime_send_hello_response(worker->connection, &hello_result);
runtime_worker_finish(worker);
return NULL;
}
if (service->application.request) {
worker->application_session = service->application.session_open(
service->application.context, client_id, worker->peer_process_id);
if (!worker->application_session) {
runtime_result_rejected(&hello_result, "CBM daemon session initialization failed");
cbm_mutex_lock(&service->mutex);
worker->final_response_inflight = true;
cbm_mutex_unlock(&service->mutex);
runtime_worker_disconnect(worker);
(void)runtime_send_hello_response(worker->connection, &hello_result);
cbm_mutex_lock(&service->mutex);
worker->final_response_inflight = false;
cbm_mutex_unlock(&service->mutex);
runtime_worker_finish(worker);
return NULL;
}
worker->application_session_opened = true;
}
if (!runtime_worker_commit_admission(worker)) {
/* session_open() returns a provisional allocation. STOPPING and this
* commit linearize on service->mutex; a losing provisional session is
* cancelled and closed exactly like any other connection-owned state,
* but is never exposed to the frontend as admitted. */
runtime_result_rejected(&hello_result, "CBM daemon is stopping");
cbm_mutex_lock(&service->mutex);
worker->final_response_inflight = true;
cbm_mutex_unlock(&service->mutex);
runtime_worker_disconnect(worker);
(void)runtime_send_hello_response(worker->connection, &hello_result);
cbm_mutex_lock(&service->mutex);
worker->final_response_inflight = false;
cbm_mutex_unlock(&service->mutex);
runtime_worker_finish(worker);
return NULL;
}
hello_result.status = CBM_DAEMON_RUNTIME_CONNECT_ACCEPTED;
hello_result.hello_status = CBM_DAEMON_HELLO_COMPATIBLE;
hello_result.conflict.status = CBM_DAEMON_HELLO_COMPATIBLE;
hello_result.client_id = client_id;
hello_result.authenticated_process_id = worker->peer_process_id;
if (!runtime_send_hello_response(worker->connection, &hello_result)) {
runtime_worker_finish(worker);
return NULL;
}
bool keep_running = true;
while (keep_running && runtime_worker_service_running(worker)) {
memset(&frame, 0, sizeof(frame));
payload = NULL;
received = cbm_daemon_ipc_receive_frame(worker->connection, CBM_DAEMON_IPC_WAIT_FOREVER,
&frame, &payload);
if (received != 1 || frame.type != CBM_DAEMON_FRAME_REQUEST) {
/* An admitted frontend disconnecting decides the daemon's fate
* (last committed client ends the generation), so the transport
* cause must be visible: 0 = orderly EOF, negative = transport
* error. A silent break here previously made session-drop races
* undiagnosable across three platforms. */
char received_text[16];
(void)snprintf(received_text, sizeof(received_text), "%d", received);
cbm_log_info("daemon.connection_end", "received", received_text, "frame_type",
received == 1 ? "non_request" : "none");
break;
}
switch (frame.flags) {
case CBM_DAEMON_RUNTIME_OP_HEARTBEAT: {
bool valid = frame.length == 0 &&
cbm_daemon_client_heartbeat(service->coordinator, client_id, cbm_now_ms());
keep_running =
valid && runtime_worker_send_status(worker, CBM_DAEMON_RUNTIME_OP_HEARTBEAT, true);
break;
}
case CBM_DAEMON_RUNTIME_OP_JOB_SUBSCRIBE:
keep_running = runtime_worker_handle_subscribe(worker, payload, frame.length);
break;
case CBM_DAEMON_RUNTIME_OP_JOB_UNSUBSCRIBE:
keep_running = runtime_worker_handle_unsubscribe(worker, payload, frame.length);
break;
case CBM_DAEMON_RUNTIME_OP_APPLICATION_REQUEST:
keep_running = runtime_worker_handle_application(worker, payload, frame.length);
break;
case CBM_DAEMON_RUNTIME_OP_APPLICATION_CANCEL:
keep_running = runtime_worker_handle_application_cancel(worker, payload, frame.length);
break;
case CBM_DAEMON_RUNTIME_OP_CLOSE_INTENT:
keep_running = runtime_worker_handle_close_intent(worker, frame.length);
break;
case CBM_DAEMON_RUNTIME_OP_DISCONNECT:
keep_running = false;
(void)runtime_worker_handle_disconnect(worker, frame.length);
break;
default:
keep_running = false;
break;
}
free(payload);
payload = NULL;
}
free(payload);
runtime_worker_finish(worker);
return NULL;
}
static void runtime_worker_reset_after_join(cbm_daemon_runtime_worker_t *worker) {
free(worker->application_request);
worker->thread_started = false;
worker->in_use = false;
worker->joining = false;
worker->connection = NULL;
worker->client_id = CBM_DAEMON_CLIENT_ID_INVALID;
worker->peer_process_id = 0;
worker->admitted = false;
worker->admission_committed = false;
worker->final_response_inflight = false;
worker->application_session = NULL;
worker->application_session_opened = false;
worker->application_cancelled = false;
worker->application_thread_started = false;
worker->application_request_token = CBM_DAEMON_RUNTIME_APPLICATION_TOKEN_INVALID;
worker->last_application_request_token = CBM_DAEMON_RUNTIME_APPLICATION_TOKEN_INVALID;
worker->application_request = NULL;
worker->application_request_length = 0;
atomic_store_explicit(&worker->done, false, memory_order_release);
atomic_store_explicit(&worker->disconnecting, false, memory_order_release);
atomic_store_explicit(&worker->application_thread_done, false, memory_order_release);
}
static void runtime_reap_completed_workers(cbm_daemon_runtime_service_t *service) {
for (size_t i = 0; i < service->worker_capacity; i++) {
cbm_daemon_runtime_worker_t *worker = &service->workers[i];
cbm_mutex_lock(&service->mutex);
bool reap = worker->in_use && worker->thread_started && !worker->joining &&
atomic_load_explicit(&worker->done, memory_order_acquire);
if (reap) {
worker->joining = true;
}
cbm_mutex_unlock(&service->mutex);
if (!reap) {
continue;
}
int joined = cbm_thread_join(&worker->thread);
cbm_mutex_lock(&service->mutex);
if (joined == 0) {
runtime_worker_reset_after_join(worker);
} else {
worker->joining = false;
}
cbm_mutex_unlock(&service->mutex);
}
}
static cbm_daemon_runtime_worker_t *runtime_find_free_worker_locked(
cbm_daemon_runtime_service_t *service) {
for (size_t i = 0; i < service->worker_capacity; i++) {
if (!service->workers[i].in_use) {
return &service->workers[i];
}
}
return NULL;
}
/* Answers WITHOUT reading the peer's HELLO, so on POSIX (where the drain is a
* no-op) the close can land before the peer has even sent it; the client reads
* this answer after its failed send (cbm_daemon_runtime_client_connect). */
static void runtime_reject_inline(cbm_daemon_ipc_connection_t *connection, const char *message) {
cbm_daemon_runtime_connect_result_t result;
runtime_result_rejected(&result, message);
RUNTIME_HELLO_POINT(DAEMON_REJECTING);
(void)runtime_send_hello_response(connection, &result);
/* Same Windows named-pipe discard hazard as runtime_worker_finish: the
* peer must get to read the rejection before the handle closes. */
cbm_daemon_ipc_connection_drain(connection, runtime_reject_drain_timeout_ms());
cbm_daemon_ipc_connection_close(connection);
RUNTIME_HELLO_POINT(DAEMON_REJECTED);
}
static void runtime_accept_connection(cbm_daemon_runtime_service_t *service,
cbm_daemon_ipc_connection_t *connection) {
uint64_t peer_pid = cbm_daemon_ipc_connection_peer_pid(connection);
if (peer_pid == 0) {
cbm_daemon_ipc_connection_close(connection);
return;
}
cbm_mutex_lock(&service->mutex);
bool running = service->state == CBM_DAEMON_RUNTIME_SERVICE_RUNNING;
bool capacity = service->active_connections >= service->worker_capacity;
cbm_daemon_runtime_worker_t *worker =
running && !capacity ? runtime_find_free_worker_locked(service) : NULL;
if (worker) {
worker->connection = connection;
worker->peer_process_id = peer_pid;
worker->client_id = CBM_DAEMON_CLIENT_ID_INVALID;
worker->admitted = false;
worker->admission_committed = false;
worker->final_response_inflight = false;
worker->application_session = NULL;
worker->application_session_opened = false;
worker->application_cancelled = false;
worker->application_thread_started = false;
free(worker->application_request);
worker->application_request = NULL;
worker->application_request_length = 0;
worker->joining = false;
worker->in_use = true;
atomic_store_explicit(&worker->done, false, memory_order_release);
atomic_store_explicit(&worker->disconnecting, false, memory_order_release);
atomic_store_explicit(&worker->application_thread_done, false, memory_order_release);
service->active_connections++;
int created = cbm_thread_create(&worker->thread, RUNTIME_WORKER_STACK_SIZE,
runtime_connection_worker, worker);
if (created == 0) {
worker->thread_started = true;
cbm_mutex_unlock(&service->mutex);
return;
}
service->active_connections--;
runtime_worker_reset_after_join(worker);
}
cbm_mutex_unlock(&service->mutex);
if (!running) {
runtime_reject_inline(connection, "CBM daemon is stopping");
} else {
runtime_reject_inline(connection, "CBM daemon connection capacity reached");
}
}
static bool runtime_service_can_exit(cbm_daemon_runtime_service_t *service, uint64_t now_ms) {
bool can_exit = false;
cbm_mutex_lock(&service->mutex);
if (service->state == CBM_DAEMON_RUNTIME_SERVICE_STOPPING && service->active_connections == 0) {
bool drained = cbm_daemon_should_exit(service->coordinator, now_ms);
if (!drained && service->activation_shutdown_requested) {
/* Activation can arrive while the daemon has no committed
* coordinator client, so no final disconnect exists to flip the
* coordinator's terminal bit. Resource emptiness is equivalent
* once the runtime has atomically stopped all new admission. */
drained = cbm_daemon_active_clients(service->coordinator) == 0 &&
cbm_daemon_active_jobs(service->coordinator) == 0 &&
cbm_daemon_active_watches(service->coordinator) == 0;
}
bool deadline_reached =
service->stop_deadline_ms != 0 && now_ms >= service->stop_deadline_ms;
can_exit = drained || deadline_reached || service->emergency_stop;
if (can_exit) {
service->state = CBM_DAEMON_RUNTIME_SERVICE_EXITED;
}
}
cbm_mutex_unlock(&service->mutex);
return can_exit;
}
static void *runtime_accept_loop(void *opaque) {
cbm_daemon_runtime_service_t *service = opaque;
for (;;) {
runtime_reap_completed_workers(service);
cbm_mutex_lock(&service->mutex);
cbm_daemon_runtime_service_state_t state = service->state;
cbm_mutex_unlock(&service->mutex);
if (state == CBM_DAEMON_RUNTIME_SERVICE_EXITED) {
break;
}
if (state == CBM_DAEMON_RUNTIME_SERVICE_STOPPING) {
runtime_service_interrupt_connections(service);
if (runtime_service_can_exit(service, cbm_now_ms())) {
break;
}
uint64_t tick_deadline = runtime_deadline_after(1);
runtime_wait_tick(tick_deadline);
continue;
}
/* Self-retire a generation lingering for a cold-storm peer once the peer
* drains or the bounded window elapses, without an external driver. A
* no-op unless a last-committed-client linger is armed. */
cbm_daemon_runtime_service_reconcile_lifetime(service);
cbm_daemon_ipc_connection_t *connection = NULL;
int accepted =
cbm_daemon_ipc_accept(service->listener, RUNTIME_ACCEPT_POLL_MS, &connection);
if (accepted == 1 && connection) {
runtime_accept_connection(service, connection);
} else if (accepted < 0) {
/* IPC intentionally combines invalid-peer and listener errors.
* Retry while RUNNING so one hostile peer cannot stop the daemon. */
uint64_t tick_deadline = runtime_deadline_after(1);
runtime_wait_tick(tick_deadline);
}
}
runtime_reap_completed_workers(service);
atomic_store_explicit(&service->accept_thread_done, true, memory_order_release);
return NULL;
}
static char *runtime_string_copy_bounded(const char *value, size_t capacity) {
size_t length = 0;
if (!runtime_bounded_length(value, capacity, &length)) {
return NULL;
}
char *copy = malloc(length + 1);
if (copy) {
memcpy(copy, value, length + 1);
}
return copy;
}
static bool runtime_application_callbacks_valid(
const cbm_daemon_runtime_application_callbacks_t *application) {
bool any = application->session_open || application->request || application->request_cancel ||
application->session_cancel || application->session_close;
bool all = application->session_open && application->request && application->request_cancel &&
application->session_cancel && application->session_close;
return !any || all;
}
static bool runtime_participant_guard_release_complete(
cbm_daemon_ipc_participant_guard_t **guard_io, uint32_t timeout_ms) {
uint64_t deadline = runtime_deadline_after(timeout_ms);
while (guard_io && *guard_io) {
(void)cbm_daemon_ipc_participant_guard_release(guard_io);
if (!*guard_io) {
return true;
}
if (cbm_now_ms() >= deadline) {
return false;
}
cbm_usleep(1000);
}
return guard_io != NULL;
}
static _Noreturn void runtime_cleanup_fail_stop(const char *component) {
/* Convenience start() has no outward cleanup handle on failure. Losing a
* live participant guard would permit later code to misreport teardown,
* so terminate the process and let the kernel release native ownership. */
cbm_log_error("daemon.forced_shutdown", "component", component);
(void)fflush(stdout);
(void)fflush(stderr);
#ifdef _WIN32
(void)TerminateProcess(GetCurrentProcess(), EXIT_FAILURE);
abort();
#else
_Exit(EXIT_FAILURE);
#endif
}
static void runtime_startup_lock_release_complete(cbm_daemon_ipc_startup_lock_t **lock_io,
uint32_t timeout_ms) {
uint64_t deadline = runtime_deadline_after(timeout_ms);
while (lock_io && *lock_io) {
(void)cbm_daemon_ipc_startup_lock_release(lock_io);
if (!*lock_io) {
return;
}
if (cbm_now_ms() >= deadline) {
runtime_cleanup_fail_stop("startup_lock_cleanup");
}
cbm_usleep(1000);
}
}
static void runtime_service_destroy_unstarted(cbm_daemon_runtime_service_t *service) {
if (!service) {
return;
}
cbm_daemon_ipc_listener_close(service->listener);
cbm_daemon_coordinator_free(service->coordinator);
(void)runtime_process_image_reference_release(&service->active_image);
runtime_verified_peer_images_release(service);
free(service->conflict_log_path);
for (size_t i = 0; i < service->worker_mutexes_initialized; i++) {
cbm_mutex_destroy(&service->workers[i].send_mutex);
}
free(service->workers);
cbm_mutex_destroy(&service->mutex);
free(service);
}
cbm_daemon_runtime_service_t *cbm_daemon_runtime_service_start_reserved(
const cbm_daemon_runtime_service_config_t *config,
cbm_daemon_ipc_lifetime_reservation_t **reservation_io) {
uint8_t validation[CBM_DAEMON_RENDEZVOUS_REQUEST_SIZE];
char active_process_fingerprint[CBM_DAEMON_BUILD_FINGERPRINT_SIZE];
runtime_process_image_reference_t active_image;
runtime_process_image_reference_init(&active_image);
if (!reservation_io || !*reservation_io || !config || !config->endpoint ||
!config->conflict_log_path || config->conflict_log_cap_bytes == 0 ||
config->max_clients == 0 || config->max_clients > RUNTIME_MAX_CLIENTS_HARD ||
config->lease_timeout_ms == 0 || config->request_timeout_ms == 0 ||
config->request_timeout_ms == CBM_DAEMON_IPC_WAIT_FOREVER ||
config->shutdown_timeout_ms == 0 ||
config->shutdown_timeout_ms == CBM_DAEMON_IPC_WAIT_FOREVER ||
!runtime_application_callbacks_valid(&config->application) ||
!cbm_daemon_runtime_hello_request_encode(validation, &config->identity)) {
cbm_log_error("daemon.runtime.start_failed", "stage", "config_validation");
return NULL;
}
/* WHY: cppcheck evaluates the unsupported-platform fail-closed branch
* because its invocation defines no host OS macro. Production compilers
* select one of the Windows/macOS/Linux native-image implementations. */
// cppcheck-suppress knownConditionTrueFalse
if (!runtime_process_image_reference_acquire(runtime_current_process_id(), &active_image,
active_process_fingerprint) ||
strcmp(active_process_fingerprint, config->identity.build_fingerprint) != 0) {
cbm_log_error("daemon.runtime.start_failed", "stage", "active_image_identity");
(void)runtime_process_image_reference_release(&active_image);
return NULL;
}
cbm_daemon_runtime_service_t *service = calloc(1, sizeof(*service));
if (!service) {
cbm_log_error("daemon.runtime.start_failed", "stage", "service_allocation");
(void)runtime_process_image_reference_release(&active_image);
return NULL;
}
service->active_image = active_image;
runtime_process_image_reference_init(&active_image);
cbm_mutex_init(&service->mutex);
atomic_init(&service->accept_thread_done, false);
service->worker_capacity = config->max_clients;
service->workers = calloc(service->worker_capacity, sizeof(*service->workers));
service->coordinator = cbm_daemon_coordinator_new(config->lease_timeout_ms);
if (service->coordinator && config->permanent) {
cbm_daemon_coordinator_set_permanent(service->coordinator, true);
}
service->conflict_log_path =
runtime_string_copy_bounded(config->conflict_log_path, RUNTIME_PATH_CAP);
size_t version_length = 0;
size_t build_length = 0;
bool copied_identity =
runtime_bounded_length(config->identity.semantic_version, sizeof(service->semantic_version),
&version_length) &&
runtime_bounded_length(config->identity.build_fingerprint,
sizeof(service->build_fingerprint), &build_length);
if (copied_identity) {
memcpy(service->semantic_version, config->identity.semantic_version, version_length + 1);
memcpy(service->build_fingerprint, config->identity.build_fingerprint, build_length + 1);
}
service->identity.semantic_version = service->semantic_version;
service->identity.build_fingerprint = service->build_fingerprint;
service->identity.protocol_abi = config->identity.protocol_abi;
service->identity.store_abi = config->identity.store_abi;
service->identity.feature_abi = config->identity.feature_abi;
service->conflict_log_cap_bytes = config->conflict_log_cap_bytes;
service->lease_timeout_ms = config->lease_timeout_ms;
service->request_timeout_ms = config->request_timeout_ms;
service->shutdown_timeout_ms = config->shutdown_timeout_ms;
service->application = config->application;
service->permanent = config->permanent;
service->state = CBM_DAEMON_RUNTIME_SERVICE_STARTING;
if (!service->workers || !service->coordinator || !service->conflict_log_path ||
!copied_identity) {
cbm_log_error("daemon.runtime.start_failed", "stage", "service_initialization");
runtime_service_destroy_unstarted(service);
return NULL;
}
for (size_t i = 0; i < service->worker_capacity; i++) {
service->workers[i].service = service;
cbm_mutex_init(&service->workers[i].send_mutex);
service->worker_mutexes_initialized++;
atomic_init(&service->workers[i].done, false);
atomic_init(&service->workers[i].disconnecting, false);
atomic_init(&service->workers[i].application_thread_done, false);
}
service->listener = cbm_daemon_ipc_listen_reserved(config->endpoint, reservation_io);
if (!service->listener) {
cbm_log_error("daemon.runtime.start_failed", "stage", "listener_handoff");
runtime_service_destroy_unstarted(service);
return NULL;
}
service->state = CBM_DAEMON_RUNTIME_SERVICE_RUNNING;
if (cbm_thread_create(&service->accept_thread, RUNTIME_WORKER_STACK_SIZE, runtime_accept_loop,
service) != 0) {
cbm_log_error("daemon.runtime.start_failed", "stage", "accept_thread");
service->state = CBM_DAEMON_RUNTIME_SERVICE_EXITED;
runtime_service_destroy_unstarted(service);
return NULL;
}
service->accept_thread_started = true;
return service;
}
cbm_daemon_runtime_service_t *cbm_daemon_runtime_service_start(
const cbm_daemon_runtime_service_config_t *config) {
if (!config || !config->endpoint) {
return NULL;
}
cbm_daemon_ipc_startup_lock_t *startup_lock = NULL;
if (cbm_daemon_ipc_startup_lock_try_acquire(config->endpoint, &startup_lock) != 1) {
return NULL;
}
int generation =
cbm_daemon_ipc_generation_probe_under_startup_lock(config->endpoint, startup_lock);
if (generation != 0 || !cbm_daemon_ipc_startup_lock_prepare_handoff(startup_lock)) {
runtime_startup_lock_release_complete(&startup_lock, config->shutdown_timeout_ms);
return NULL;
}
cbm_daemon_ipc_participant_guard_t *participant_guard = NULL;
if (cbm_daemon_ipc_participant_guard_try_join(config->endpoint, &participant_guard) != 1) {
runtime_startup_lock_release_complete(&startup_lock, config->shutdown_timeout_ms);
return NULL;
}
cbm_daemon_ipc_lifetime_reservation_t *reservation = NULL;
if (cbm_daemon_ipc_lifetime_reservation_try_acquire(config->endpoint, &reservation) != 1) {
if (!runtime_participant_guard_release_complete(&participant_guard,
config->shutdown_timeout_ms)) {
runtime_cleanup_fail_stop("participant_guard_cleanup");
}
runtime_startup_lock_release_complete(&startup_lock, config->shutdown_timeout_ms);
return NULL;
}
cbm_daemon_runtime_service_t *service =
cbm_daemon_runtime_service_start_reserved(config, &reservation);
cbm_daemon_ipc_lifetime_reservation_release(reservation);
if (!service) {
if (!runtime_participant_guard_release_complete(&participant_guard,
config->shutdown_timeout_ms)) {
runtime_cleanup_fail_stop("participant_guard_cleanup");
}
runtime_startup_lock_release_complete(&startup_lock, config->shutdown_timeout_ms);
return NULL;
}
service->owned_participant_guard = participant_guard;
runtime_startup_lock_release_complete(&startup_lock, config->shutdown_timeout_ms);
return service;
}
cbm_daemon_runtime_service_state_t cbm_daemon_runtime_service_state(
cbm_daemon_runtime_service_t *service) {
if (!service) {
return CBM_DAEMON_RUNTIME_SERVICE_EXITED;
}
cbm_mutex_lock(&service->mutex);
cbm_daemon_runtime_service_state_t state = service->state;
cbm_mutex_unlock(&service->mutex);
return state;
}
uint64_t cbm_daemon_runtime_service_clients_admitted_total(cbm_daemon_runtime_service_t *service) {
if (!service) {
return 0;
}
cbm_mutex_lock(&service->mutex);
uint64_t total = service->admitted_total;
cbm_mutex_unlock(&service->mutex);
return total;
}
size_t cbm_daemon_runtime_service_active_clients(cbm_daemon_runtime_service_t *service) {
if (!service) {
return 0;
}
cbm_mutex_lock(&service->mutex);
size_t count = service->committed_clients;
cbm_mutex_unlock(&service->mutex);
return count;
}
size_t cbm_daemon_runtime_service_active_connections(cbm_daemon_runtime_service_t *service) {
if (!service) {
return 0;
}
cbm_mutex_lock(&service->mutex);
size_t count = service->active_connections;
cbm_mutex_unlock(&service->mutex);
return count;
}
int cbm_daemon_runtime_service_touch_listener(cbm_daemon_runtime_service_t *service) {
return service && service->listener
? cbm_daemon_ipc_listener_touch(service->listener, service->owned_participant_guard)
: 0;
}
void cbm_daemon_runtime_service_reconcile_lifetime(cbm_daemon_runtime_service_t *service) {
if (!service) {
return;
}
bool retired = false;
cbm_mutex_lock(&service->mutex);
if (service->state == CBM_DAEMON_RUNTIME_SERVICE_RUNNING && !service->permanent &&
service->committed_clients == 0 && service->ephemeral_linger_deadline_ms != 0) {
bool peers_drained = !runtime_has_pending_hello_peer_locked(service, NULL);
bool window_elapsed = cbm_now_ms() >= service->ephemeral_linger_deadline_ms;
if (peers_drained || window_elapsed) {
/* The racing peer drained without committing (retire now), or never
* committed within the bounded window (the backstop that rules out
* an unbounded idle hang — the host_serving 900s mode). */
service->ephemeral_linger_deadline_ms = 0;
runtime_service_begin_stopping_locked(
service, runtime_deadline_after(service->shutdown_timeout_ms), false,
peers_drained ? "ephemeral_peer_drained" : "ephemeral_linger_expired");
retired = true;
}
}
cbm_mutex_unlock(&service->mutex);
if (retired) {
/* Release the coordinator hold now that the linger has resolved. With
* no client left this transitions the coordinator to STOPPING, so the
* service drains and exits cleanly rather than only on the deadline. */
cbm_daemon_coordinator_set_linger(service->coordinator, false);
}
}
size_t cbm_daemon_runtime_service_job_subscribers(cbm_daemon_runtime_service_t *service,
const char *project_key) {
return service ? cbm_daemon_job_subscribers(service->coordinator, project_key) : 0;
}
uint64_t cbm_daemon_runtime_service_client_process_id(cbm_daemon_runtime_service_t *service,
cbm_daemon_client_id_t client_id) {
if (!service || client_id == CBM_DAEMON_CLIENT_ID_INVALID) {
return 0;
}
uint64_t process_id = 0;
cbm_mutex_lock(&service->mutex);
for (size_t i = 0; i < service->worker_capacity; i++) {
cbm_daemon_runtime_worker_t *worker = &service->workers[i];
if (worker->in_use && worker->admitted && worker->admission_committed &&
worker->client_id == client_id) {
process_id = worker->peer_process_id;
break;
}
}
cbm_mutex_unlock(&service->mutex);
return process_id;
}
static bool runtime_wait_for_count(cbm_daemon_runtime_service_t *service, size_t expected,
uint32_t timeout_ms, bool connections) {
if (!service) {
return false;
}
uint64_t deadline = runtime_deadline_after(timeout_ms);
for (;;) {
size_t actual = connections ? cbm_daemon_runtime_service_active_connections(service)
: cbm_daemon_runtime_service_active_clients(service);
if (actual == expected) {
return true;
}
if (cbm_now_ms() >= deadline) {
return false;
}
runtime_wait_tick(deadline);
}
}
bool cbm_daemon_runtime_service_wait_for_clients(cbm_daemon_runtime_service_t *service,
size_t expected, uint32_t timeout_ms) {
return runtime_wait_for_count(service, expected, timeout_ms, false);
}
bool cbm_daemon_runtime_service_wait_for_connections(cbm_daemon_runtime_service_t *service,
size_t expected, uint32_t timeout_ms) {
return runtime_wait_for_count(service, expected, timeout_ms, true);
}
bool cbm_daemon_runtime_service_wait_exited(cbm_daemon_runtime_service_t *service,
uint32_t timeout_ms) {
if (!service) {
return false;
}
uint64_t deadline = runtime_deadline_after(timeout_ms);
for (;;) {
if (cbm_daemon_runtime_service_state(service) == CBM_DAEMON_RUNTIME_SERVICE_EXITED &&
atomic_load_explicit(&service->accept_thread_done, memory_order_acquire)) {
return true;
}
if (cbm_now_ms() >= deadline) {
return false;
}
runtime_wait_tick(deadline);
}
}
bool cbm_daemon_runtime_service_job_reaped(cbm_daemon_runtime_service_t *service,
const char *project_key) {
return service && cbm_daemon_job_reaped(service->coordinator, project_key, cbm_now_ms());
}
bool cbm_daemon_runtime_service_stop(cbm_daemon_runtime_service_t *service, uint32_t timeout_ms) {
if (!service) {
return false;
}
if (cbm_daemon_runtime_service_state(service) == CBM_DAEMON_RUNTIME_SERVICE_EXITED) {
return cbm_daemon_runtime_service_wait_exited(service, timeout_ms);
}
runtime_service_begin_stopping(service, timeout_ms, true, "service_stop");
runtime_service_interrupt_connections(service);
return cbm_daemon_runtime_service_wait_exited(service, timeout_ms);
}
bool cbm_daemon_runtime_service_free(cbm_daemon_runtime_service_t *service) {
if (!service ||
cbm_daemon_runtime_service_state(service) != CBM_DAEMON_RUNTIME_SERVICE_EXITED) {
return false;
}
if (service->accept_thread_started && !service->accept_thread_joined) {
if (cbm_thread_join(&service->accept_thread) != 0) {
return false;
}
service->accept_thread_joined = true;
}
for (size_t i = 0; i < service->worker_capacity; i++) {
cbm_daemon_runtime_worker_t *worker = &service->workers[i];
if (worker->thread_started) {
if (!atomic_load_explicit(&worker->done, memory_order_acquire) ||
cbm_thread_join(&worker->thread) != 0) {
return false;
}
runtime_worker_reset_after_join(worker);
}
}
cbm_daemon_ipc_listener_close(service->listener);
service->listener = NULL;
if (!runtime_participant_guard_release_complete(&service->owned_participant_guard,
service->shutdown_timeout_ms)) {
/* Preserve the service allocation so the caller can retry or force
* process exit without dropping the only live cleanup handle. */
return false;
}
cbm_daemon_coordinator_free(service->coordinator);
(void)runtime_process_image_reference_release(&service->active_image);
runtime_verified_peer_images_release(service);
free(service->conflict_log_path);
for (size_t i = 0; i < service->worker_mutexes_initialized; i++) {
cbm_mutex_destroy(&service->workers[i].send_mutex);
}
free(service->workers);
cbm_mutex_destroy(&service->mutex);
free(service);
return true;
}
bool cbm_daemon_runtime_request_activation_shutdown(
const cbm_daemon_ipc_endpoint_t *endpoint, const cbm_daemon_build_identity_t *identity,
cbm_daemon_runtime_activation_action_t action, uint32_t timeout_ms,
cbm_daemon_runtime_activation_result_t *result_out) {
if (result_out) {
memset(result_out, 0, sizeof(*result_out));
}
uint8_t request[CBM_DAEMON_ACTIVATION_SHUTDOWN_REQUEST_SIZE];
if (!endpoint || !identity || !result_out || timeout_ms == CBM_DAEMON_IPC_WAIT_FOREVER ||
!runtime_activation_request_encode(request, action, identity)) {
return false;
}
cbm_daemon_ipc_connection_t *connection = cbm_daemon_ipc_connect(endpoint, timeout_ms);
bool sent = connection && cbm_daemon_ipc_send_frame(connection, CBM_DAEMON_FRAME_REQUEST,
CBM_DAEMON_RUNTIME_OP_ACTIVATION_SHUTDOWN,
request, (uint32_t)sizeof(request));
cbm_daemon_frame_t frame = {0};
uint8_t *payload = NULL;
int received = sent ? cbm_daemon_ipc_receive_frame_bounded(
connection, timeout_ms, CBM_DAEMON_ACTIVATION_SHUTDOWN_RESPONSE_SIZE,
&frame, &payload)
: 0;
bool valid = received == 1 && frame.type == CBM_DAEMON_FRAME_RESPONSE &&
frame.flags == CBM_DAEMON_RUNTIME_OP_ACTIVATION_SHUTDOWN &&
frame.length == CBM_DAEMON_ACTIVATION_SHUTDOWN_RESPONSE_SIZE &&
runtime_activation_response_decode(payload, result_out);
free(payload);
cbm_daemon_ipc_connection_close(connection);
if (!valid) {
memset(result_out, 0, sizeof(*result_out));
}
return valid;
}
static bool runtime_control_request_send(const cbm_daemon_ipc_endpoint_t *endpoint,
const cbm_daemon_build_identity_t *identity,
cbm_daemon_runtime_operation_t operation,
uint32_t timeout_ms, uint32_t response_size,
uint8_t **payload_out, uint64_t *muted_holder_pid_out) {
*payload_out = NULL;
if (muted_holder_pid_out) {
*muted_holder_pid_out = 0;
}
if (!endpoint || !identity || !identity->build_fingerprint ||
timeout_ms == CBM_DAEMON_IPC_WAIT_FOREVER) {
return false;
}
uint8_t request[CBM_DAEMON_CONTROL_REQUEST_SIZE];
memset(request, 0, sizeof(request));
int written = snprintf((char *)request, sizeof(request), "%s", identity->build_fingerprint);
if (written <= 0 || (size_t)written != CBM_DAEMON_BUILD_FINGERPRINT_SIZE - 1U) {
return false;
}
cbm_daemon_ipc_connection_t *connection = cbm_daemon_ipc_connect(endpoint, timeout_ms);
bool sent =
connection && cbm_daemon_ipc_send_frame(connection, CBM_DAEMON_FRAME_REQUEST, operation,
request, (uint32_t)sizeof(request));
cbm_daemon_frame_t frame = {0};
uint8_t *payload = NULL;
int received = sent ? cbm_daemon_ipc_receive_frame_bounded(connection, timeout_ms,
response_size, &frame, &payload)
: 0;
if (muted_holder_pid_out && sent &&
(received != 1 || (frame.type == CBM_DAEMON_FRAME_RESPONSE && frame.flags != operation))) {
/* Connected but not served: either total silence (dead runtime), or a
* wrong-operation reject frame (a wedged generation whose accept path
* still answers inline while every worker slot is stuck). Both are
* the zombie class — surface the holder's kernel-reported pid so
* `daemon status` can name it instead of reporting "not running". */
*muted_holder_pid_out = cbm_daemon_ipc_connection_peer_pid(connection);
}
bool valid = received == 1 && frame.type == CBM_DAEMON_FRAME_RESPONSE &&
frame.flags == operation && frame.length == response_size && payload &&
payload[0] == 1U;
cbm_daemon_ipc_connection_close(connection);
if (!valid) {
free(payload);
return false;
}
*payload_out = payload;
return true;
}
static uint32_t runtime_control_read_u32(const uint8_t *bytes) {
return ((uint32_t)bytes[0] << 24) | ((uint32_t)bytes[1] << 16) | ((uint32_t)bytes[2] << 8) |
(uint32_t)bytes[3];
}
bool cbm_daemon_runtime_request_status(const cbm_daemon_ipc_endpoint_t *endpoint,
const cbm_daemon_build_identity_t *identity,
uint32_t timeout_ms,
cbm_daemon_runtime_status_t *status_out) {
if (!status_out) {
return false;
}
memset(status_out, 0, sizeof(*status_out));
uint8_t *payload = NULL;
if (!runtime_control_request_send(endpoint, identity, CBM_DAEMON_RUNTIME_OP_STATUS, timeout_ms,
CBM_DAEMON_STATUS_RESPONSE_SIZE, &payload,
&status_out->muted_endpoint_holder_pid)) {
return false;
}
status_out->permanent = (payload[1] & 0x01U) != 0U;
status_out->stopping = (payload[1] & 0x02U) != 0U;
status_out->committed_clients = (uint16_t)(((uint16_t)payload[2] << 8) | payload[3]);
status_out->daemon_pid = runtime_control_read_u32(payload + 4);
status_out->client_count = payload[8] > CBM_DAEMON_CONTROL_CLIENT_CAP
? (uint8_t)CBM_DAEMON_CONTROL_CLIENT_CAP
: payload[8];
for (size_t index = 0; index < CBM_DAEMON_CONTROL_CLIENT_CAP; index++) {
status_out->client_pids[index] = runtime_control_read_u32(payload + 12U + index * 4U);
}
memcpy(status_out->build_fingerprint, payload + 44U, CBM_DAEMON_BUILD_FINGERPRINT_SIZE);
status_out->build_fingerprint[CBM_DAEMON_BUILD_FINGERPRINT_SIZE - 1U] = '\0';
memcpy(status_out->semantic_version, payload + 109U, sizeof(status_out->semantic_version));
status_out->semantic_version[sizeof(status_out->semantic_version) - 1U] = '\0';
free(payload);
return true;
}
/* "; CBM sessions using it: pids 1, 2 and 3 more" — empty when none are known. */
static bool remedy_sessions_format(const cbm_daemon_runtime_status_t *active, char *out,
size_t out_size) {
out[0] = '\0';
size_t listed = active->client_count;
if (listed > CBM_DAEMON_CONTROL_CLIENT_CAP) {
listed = CBM_DAEMON_CONTROL_CLIENT_CAP;
}
size_t used = 0;
for (size_t i = 0; i < listed; i++) {
int written = snprintf(out + used, out_size - used, "%s%lu",
i == 0 ? "; CBM sessions using it: pids " : ", ",
(unsigned long)active->client_pids[i]);
if (written < 0 || (size_t)written >= out_size - used) {
return false;
}
used += (size_t)written;
}
if (listed > 0 && active->committed_clients > listed) {
int written = snprintf(out + used, out_size - used, " and %lu more",
(unsigned long)(active->committed_clients - listed));
if (written < 0 || (size_t)written >= out_size - used) {
return false;
}
}
return true;
}
bool cbm_daemon_conflict_remedy_format(const cbm_daemon_runtime_status_t *active, char *out,
size_t out_size) {
if (!out || out_size == 0) {
return false;
}
out[0] = '\0';
static const char install_hint[] =
"Usually another editor or agent session (for example Codex or Claude Code) "
"launched a different codebase-memory-mcp install: close it, or point every client "
"at one binary (compare `which -a codebase-memory-mcp` with each client's MCP "
"config).";
int written;
if (!active) {
written = snprintf(out, out_size,
"Run `codebase-memory-mcp daemon status` to see the active daemon and "
"the sessions using it. %s `codebase-memory-mcp daemon stop` retires "
"the daemon once no session uses it.",
install_hint);
} else {
char sessions[160];
if (!remedy_sessions_format(active, sessions, sizeof(sessions))) {
return false;
}
const char *lifetime =
active->permanent ? "permanent" : "session-managed, exits when its last session closes";
written = snprintf(out, out_size,
"Active daemon: pid %lu, version %s, %s%s%s. %s "
"`codebase-memory-mcp daemon stop` retires the daemon once no session "
"uses it.",
(unsigned long)active->daemon_pid, active->semantic_version, lifetime,
active->stopping ? ", already stopping" : "", sessions, install_hint);
}
if (written < 0 || (size_t)written >= out_size) {
out[0] = '\0';
return false;
}
return true;
}
bool cbm_daemon_runtime_request_stop(const cbm_daemon_ipc_endpoint_t *endpoint,
const cbm_daemon_build_identity_t *identity,
uint32_t timeout_ms,
cbm_daemon_runtime_stop_result_t *result_out) {
if (!result_out) {
return false;
}
memset(result_out, 0, sizeof(*result_out));
uint8_t *payload = NULL;
if (!runtime_control_request_send(endpoint, identity, CBM_DAEMON_RUNTIME_OP_STOP, timeout_ms,
CBM_DAEMON_STOP_RESPONSE_SIZE, &payload, NULL)) {
return false;
}
result_out->accepted = (payload[1] & 0x01U) != 0U;
result_out->busy = (payload[1] & 0x02U) != 0U;
result_out->committed_clients = (uint16_t)(((uint16_t)payload[2] << 8) | payload[3]);
result_out->client_count = payload[4] > CBM_DAEMON_CONTROL_CLIENT_CAP
? (uint8_t)CBM_DAEMON_CONTROL_CLIENT_CAP
: payload[4];
for (size_t index = 0; index < CBM_DAEMON_CONTROL_CLIENT_CAP; index++) {
result_out->client_pids[index] = runtime_control_read_u32(payload + 8U + index * 4U);
}
free(payload);
return true;
}
cbm_daemon_runtime_client_t *cbm_daemon_runtime_client_connect(
const cbm_daemon_ipc_endpoint_t *endpoint, const cbm_daemon_build_identity_t *identity,
uint32_t timeout_ms, cbm_daemon_runtime_connect_result_t *result_out) {
if (result_out) {
memset(result_out, 0, sizeof(*result_out));
}
uint8_t request[CBM_DAEMON_RENDEZVOUS_REQUEST_SIZE];
if (!endpoint || !identity || !result_out || timeout_ms == CBM_DAEMON_IPC_WAIT_FOREVER ||
!cbm_daemon_runtime_hello_request_encode(request, identity)) {
return NULL;
}
cbm_daemon_ipc_connection_t *connection = cbm_daemon_ipc_connect(endpoint, timeout_ms);
if (!connection) {
return NULL;
}
RUNTIME_HELLO_POINT(CLIENT_CONNECTED);
bool hello_sent =
cbm_daemon_ipc_send_frame(connection, CBM_DAEMON_FRAME_REQUEST, CBM_DAEMON_RUNTIME_OP_HELLO,
request, (uint32_t)sizeof(request));
RUNTIME_HELLO_POINT(CLIENT_SENT);
cbm_daemon_frame_t frame = {0};
uint8_t *payload = NULL;
/* A daemon at capacity or stopping answers from its accept loop without
* reading this HELLO and closes at once. When that close lands first, the
* send fails (EPIPE) with the whole answer already queued here: read it,
* or the caller gets a bare transport error and bootstrap classifies by
* lock state instead of by the daemon's own "capacity" / "stopping". */
int received =
hello_sent
? cbm_daemon_ipc_receive_frame_bounded(
connection, timeout_ms, CBM_DAEMON_RENDEZVOUS_RESPONSE_SIZE, &frame, &payload)
: cbm_daemon_ipc_receive_frame_after_failed_send(
connection, timeout_ms, CBM_DAEMON_RENDEZVOUS_RESPONSE_SIZE, &frame, &payload);
bool valid = received == 1 && frame.type == CBM_DAEMON_FRAME_RESPONSE &&
frame.flags == CBM_DAEMON_RUNTIME_OP_HELLO &&
frame.length == CBM_DAEMON_RENDEZVOUS_RESPONSE_SIZE &&
runtime_hello_response_decode(payload, result_out);
free(payload);
if (!hello_sent && (!valid || result_out->status != CBM_DAEMON_RUNTIME_CONNECT_REJECTED)) {
/* Only a rejection can answer a HELLO the daemon never received;
* anything else stays the plain send failure it always was. */
memset(result_out, 0, sizeof(*result_out));
cbm_daemon_ipc_connection_close(connection);
return NULL;
}
if (received != 1) {
/* The kernel completed the pipe/socket connect, so a server process
* exists, yet the HELLO went unanswered. Name that holder: a dead
* runtime behind a live endpoint is otherwise indistinguishable from
* absence, and the 2026-08-29 zombie hid behind exactly that gap. */
result_out->muted_endpoint_holder_pid = cbm_daemon_ipc_connection_peer_pid(connection);
}
if (!valid || result_out->status != CBM_DAEMON_RUNTIME_CONNECT_ACCEPTED) {
cbm_daemon_ipc_connection_close(connection);
return NULL;
}
cbm_daemon_runtime_client_t *client = calloc(1, sizeof(*client));
if (!client) {
cbm_daemon_ipc_connection_close(connection);
memset(result_out, 0, sizeof(*result_out));
return NULL;
}
cbm_mutex_init(&client->exchange_mutex);
cbm_mutex_init(&client->send_mutex);
cbm_mutex_init(&client->state_mutex);
client->connection = connection;
client->client_id = result_out->client_id;
client->authenticated_process_id = result_out->authenticated_process_id;
client->usable = true;
return client;
}
cbm_daemon_client_id_t cbm_daemon_runtime_client_id(const cbm_daemon_runtime_client_t *client) {
return client ? client->client_id : CBM_DAEMON_CLIENT_ID_INVALID;
}
uint64_t cbm_daemon_runtime_client_process_id(const cbm_daemon_runtime_client_t *client) {
return client ? client->authenticated_process_id : 0;
}
static bool runtime_client_exchange(cbm_daemon_runtime_client_t *client,
cbm_daemon_runtime_operation_t operation, const void *request,
uint32_t request_length, uint32_t timeout_ms,
uint8_t **response_out, uint32_t expected_response_length) {
*response_out = NULL;
if (timeout_ms == CBM_DAEMON_IPC_WAIT_FOREVER) {
return false;
}
cbm_mutex_lock(&client->exchange_mutex);
cbm_mutex_lock(&client->state_mutex);
if (!client->usable || client->closing || !client->connection) {
cbm_mutex_unlock(&client->state_mutex);
cbm_mutex_unlock(&client->exchange_mutex);
return false;
}
cbm_daemon_ipc_connection_t *connection = client->connection;
client->exchange_active = true;
cbm_mutex_unlock(&client->state_mutex);
cbm_mutex_lock(&client->send_mutex);
bool sent = cbm_daemon_ipc_send_frame(connection, CBM_DAEMON_FRAME_REQUEST, (uint16_t)operation,
request, request_length);
cbm_mutex_unlock(&client->send_mutex);
cbm_daemon_frame_t frame = {0};
uint8_t *payload = NULL;
int received =
sent ? cbm_daemon_ipc_receive_frame(connection, timeout_ms, &frame, &payload) : -1;
bool valid = sent && received == 1 && frame.type == CBM_DAEMON_FRAME_RESPONSE &&
frame.flags == (uint16_t)operation && frame.length == expected_response_length;
cbm_mutex_lock(&client->state_mutex);
client->exchange_active = false;
if (!valid) {
client->usable = false;
}
cbm_mutex_unlock(&client->state_mutex);
if (!valid) {
free(payload);
} else {
*response_out = payload;
}
cbm_mutex_unlock(&client->exchange_mutex);
return valid;
}
cbm_daemon_subscription_result_t cbm_daemon_runtime_client_job_subscribe(
cbm_daemon_runtime_client_t *client, const char *project_key,
cbm_daemon_subscription_id_t *subscription_id_out, uint32_t timeout_ms) {
if (subscription_id_out) {
*subscription_id_out = CBM_DAEMON_SUBSCRIPTION_ID_INVALID;
}
size_t key_length = 0;
if (!client || !subscription_id_out ||
!runtime_bounded_length(project_key, CBM_DAEMON_RUNTIME_PROJECT_KEY_MAX + 1, &key_length) ||
key_length == 0 || key_length > CBM_DAEMON_RUNTIME_PROJECT_KEY_MAX) {
return CBM_DAEMON_SUBSCRIPTION_REJECTED;
}
uint8_t request[SUBSCRIBE_REQUEST_PREFIX_SIZE + CBM_DAEMON_RUNTIME_PROJECT_KEY_MAX];
runtime_put_u32(request, (uint32_t)key_length);
memcpy(request + SUBSCRIBE_REQUEST_PREFIX_SIZE, project_key, key_length);
uint8_t *response = NULL;
if (!runtime_client_exchange(client, CBM_DAEMON_RUNTIME_OP_JOB_SUBSCRIBE, request,
(uint32_t)(SUBSCRIBE_REQUEST_PREFIX_SIZE + key_length), timeout_ms,
&response, SUBSCRIBE_RESPONSE_SIZE)) {
return CBM_DAEMON_SUBSCRIPTION_REJECTED;
}
cbm_daemon_subscription_result_t result =
(cbm_daemon_subscription_result_t)runtime_get_u32(response);
cbm_daemon_subscription_id_t subscription_id = runtime_get_u64(response + 4);
free(response);
if ((result != CBM_DAEMON_SUBSCRIPTION_STARTED && result != CBM_DAEMON_SUBSCRIPTION_JOINED) ||
subscription_id == CBM_DAEMON_SUBSCRIPTION_ID_INVALID) {
return CBM_DAEMON_SUBSCRIPTION_REJECTED;
}
*subscription_id_out = subscription_id;
return result;
}
bool cbm_daemon_runtime_client_job_unsubscribe(cbm_daemon_runtime_client_t *client,
cbm_daemon_subscription_id_t subscription_id,
uint32_t timeout_ms) {
if (!client || subscription_id == CBM_DAEMON_SUBSCRIPTION_ID_INVALID) {
return false;
}
uint8_t request[UNSUBSCRIBE_REQUEST_SIZE];
runtime_put_u64(request, subscription_id);
uint8_t *response = NULL;
if (!runtime_client_exchange(client, CBM_DAEMON_RUNTIME_OP_JOB_UNSUBSCRIBE, request,
(uint32_t)sizeof(request), timeout_ms, &response,
STATUS_RESPONSE_SIZE)) {
return false;
}
bool removed = runtime_get_u32(response) == 1;
free(response);
return removed;
}
bool cbm_daemon_runtime_client_heartbeat(cbm_daemon_runtime_client_t *client, uint32_t timeout_ms) {
if (!client) {
return false;
}
uint8_t *response = NULL;
if (!runtime_client_exchange(client, CBM_DAEMON_RUNTIME_OP_HEARTBEAT, NULL, 0, timeout_ms,
&response, STATUS_RESPONSE_SIZE)) {
return false;
}
bool valid = runtime_get_u32(response) == 1;
free(response);
return valid;
}
bool cbm_daemon_runtime_client_application_token_reserve(
cbm_daemon_runtime_client_t *client, cbm_daemon_runtime_application_token_t *token_out) {
if (token_out) {
*token_out = CBM_DAEMON_RUNTIME_APPLICATION_TOKEN_INVALID;
}
if (!client || !token_out) {
return false;
}
cbm_mutex_lock(&client->state_mutex);
bool valid = client->usable && !client->closing && client->connection &&
client->active_application_token == CBM_DAEMON_RUNTIME_APPLICATION_TOKEN_INVALID &&
client->next_application_token == client->last_started_application_token &&
client->next_application_token != UINT64_MAX;
if (valid) {
client->next_application_token++;
*token_out = client->next_application_token;
}
cbm_mutex_unlock(&client->state_mutex);
return valid;
}
cbm_daemon_runtime_cancel_result_t cbm_daemon_runtime_client_application_cancel(
cbm_daemon_runtime_client_t *client, cbm_daemon_runtime_application_token_t request_token) {
if (!client || request_token == CBM_DAEMON_RUNTIME_APPLICATION_TOKEN_INVALID) {
return CBM_DAEMON_RUNTIME_CANCEL_ERROR;
}
bool dispatch = false;
cbm_mutex_lock(&client->state_mutex);
if (!client->usable || client->closing || !client->connection) {
cbm_mutex_unlock(&client->state_mutex);
return CBM_DAEMON_RUNTIME_CANCEL_ERROR;
}
if (client->active_application_token == request_token) {
client->pending_cancel_token = request_token;
dispatch = client->application_request_sent && !client->application_cancel_sent;
} else if (client->active_application_token == CBM_DAEMON_RUNTIME_APPLICATION_TOKEN_INVALID &&
request_token == client->next_application_token &&
request_token > client->last_started_application_token) {
/* The frontend publishes its active identity immediately after token
* reservation. Preserve this one pre-send cancellation until the
* tagged exchange emits REQUEST then CANCEL under send_mutex. */
client->pending_cancel_token = request_token;
} else {
cbm_mutex_unlock(&client->state_mutex);
return CBM_DAEMON_RUNTIME_CANCEL_STALE;
}
cbm_mutex_unlock(&client->state_mutex);
if (!dispatch) {
return CBM_DAEMON_RUNTIME_CANCEL_ACCEPTED;
}
uint8_t wire[APPLICATION_CANCEL_REQUEST_SIZE];
runtime_put_u64(wire, request_token);
cbm_daemon_ipc_connection_t *connection = NULL;
bool already_sent = false;
bool unavailable = false;
cbm_mutex_lock(&client->send_mutex);
cbm_mutex_lock(&client->state_mutex);
dispatch = client->usable && !client->closing && client->connection &&
client->active_application_token == request_token &&
client->application_request_sent && !client->application_cancel_sent;
if (dispatch) {
client->application_cancel_sent = true;
connection = client->connection;
} else {
unavailable = !client->usable || client->closing || !client->connection;
already_sent = client->usable && !client->closing && client->connection &&
client->active_application_token == request_token &&
client->application_cancel_sent;
}
cbm_mutex_unlock(&client->state_mutex);
bool sent = !dispatch || cbm_daemon_ipc_send_frame(connection, CBM_DAEMON_FRAME_REQUEST,
CBM_DAEMON_RUNTIME_OP_APPLICATION_CANCEL,
wire, (uint32_t)sizeof(wire));
cbm_mutex_unlock(&client->send_mutex);
if (!dispatch) {
/* The request path may have observed pending_cancel_token and emitted
* the control while this caller waited for send_mutex. That is still
* an accepted cancellation, not a stale target. */
return already_sent ? CBM_DAEMON_RUNTIME_CANCEL_ACCEPTED
: (unavailable ? CBM_DAEMON_RUNTIME_CANCEL_ERROR
: CBM_DAEMON_RUNTIME_CANCEL_STALE);
}
if (!sent) {
cbm_mutex_lock(&client->state_mutex);
client->usable = false;
cbm_mutex_unlock(&client->state_mutex);
cbm_daemon_ipc_connection_interrupt(connection);
return CBM_DAEMON_RUNTIME_CANCEL_ERROR;
}
return CBM_DAEMON_RUNTIME_CANCEL_ACCEPTED;
}
cbm_daemon_runtime_application_status_t cbm_daemon_runtime_client_application_request_tagged(
cbm_daemon_runtime_client_t *client, cbm_daemon_runtime_application_token_t request_token,
const void *request, uint32_t request_length, uint8_t **response_out,
uint32_t *response_length_out, bool *request_sent_out, uint32_t timeout_ms) {
if (response_out) {
*response_out = NULL;
}
if (response_length_out) {
*response_length_out = 0;
}
if (request_sent_out) {
*request_sent_out = false;
}
if (!client || !response_out || !response_length_out ||
request_token == CBM_DAEMON_RUNTIME_APPLICATION_TOKEN_INVALID ||
timeout_ms == CBM_DAEMON_IPC_WAIT_FOREVER ||
request_length > CBM_DAEMON_RUNTIME_APPLICATION_PAYLOAD_MAX ||
(request_length > 0 && !request)) {
return CBM_DAEMON_RUNTIME_APPLICATION_TRANSPORT_ERROR;
}
uint64_t wire_length = APPLICATION_REQUEST_PREFIX_SIZE + (uint64_t)request_length;
if (wire_length > CBM_DAEMON_MAX_FRAME_SIZE || wire_length > UINT32_MAX) {
return CBM_DAEMON_RUNTIME_APPLICATION_TRANSPORT_ERROR;
}
uint8_t *wire = malloc((size_t)wire_length);
if (!wire) {
return CBM_DAEMON_RUNTIME_APPLICATION_TRANSPORT_ERROR;
}
runtime_put_u64(wire, request_token);
runtime_put_u32(wire + 8, request_length);
if (request_length > 0) {
memcpy(wire + APPLICATION_REQUEST_PREFIX_SIZE, request, request_length);
}
cbm_mutex_lock(&client->exchange_mutex);
cbm_mutex_lock(&client->state_mutex);
if (!client->usable || client->closing || !client->connection ||
request_token != client->next_application_token ||
request_token <= client->last_started_application_token ||
client->active_application_token != CBM_DAEMON_RUNTIME_APPLICATION_TOKEN_INVALID) {
cbm_mutex_unlock(&client->state_mutex);
cbm_mutex_unlock(&client->exchange_mutex);
free(wire);
return CBM_DAEMON_RUNTIME_APPLICATION_TRANSPORT_ERROR;
}
cbm_daemon_ipc_connection_t *connection = client->connection;
client->exchange_active = true;
client->last_started_application_token = request_token;
client->active_application_token = request_token;
client->application_request_sent = false;
client->application_cancel_sent = false;
if (client->pending_cancel_token != request_token) {
client->pending_cancel_token = CBM_DAEMON_RUNTIME_APPLICATION_TOKEN_INVALID;
}
cbm_mutex_unlock(&client->state_mutex);
uint8_t cancel_wire[APPLICATION_CANCEL_REQUEST_SIZE];
runtime_put_u64(cancel_wire, request_token);
cbm_mutex_lock(&client->send_mutex);
cbm_mutex_lock(&client->state_mutex);
bool request_can_send = client->usable && !client->closing &&
client->connection == connection &&
client->active_application_token == request_token;
cbm_mutex_unlock(&client->state_mutex);
bool sent =
request_can_send && cbm_daemon_ipc_send_frame(connection, CBM_DAEMON_FRAME_REQUEST,
CBM_DAEMON_RUNTIME_OP_APPLICATION_REQUEST,
wire, (uint32_t)wire_length);
if (request_sent_out) {
*request_sent_out = sent;
}
bool send_cancel = false;
cbm_mutex_lock(&client->state_mutex);
client->application_request_sent = sent;
send_cancel = sent && !client->closing && client->pending_cancel_token == request_token &&
!client->application_cancel_sent;
if (send_cancel) {
client->application_cancel_sent = true;
}
cbm_mutex_unlock(&client->state_mutex);
if (send_cancel) {
sent = cbm_daemon_ipc_send_frame(connection, CBM_DAEMON_FRAME_REQUEST,
CBM_DAEMON_RUNTIME_OP_APPLICATION_CANCEL, cancel_wire,
(uint32_t)sizeof(cancel_wire));
if (!sent) {
cbm_mutex_lock(&client->state_mutex);
client->usable = false;
cbm_mutex_unlock(&client->state_mutex);
}
}
cbm_mutex_unlock(&client->send_mutex);
free(wire);
cbm_daemon_frame_t frame = {0};
uint8_t *payload = NULL;
int received =
sent ? cbm_daemon_ipc_receive_frame(connection, timeout_ms, &frame, &payload) : -1;
bool protocol_valid = sent && received == 1 && frame.type == CBM_DAEMON_FRAME_RESPONSE &&
frame.flags == CBM_DAEMON_RUNTIME_OP_APPLICATION_REQUEST &&
frame.length >= APPLICATION_RESPONSE_PREFIX_SIZE && payload;
cbm_daemon_runtime_application_status_t status = CBM_DAEMON_RUNTIME_APPLICATION_TRANSPORT_ERROR;
uint32_t response_length = 0;
if (protocol_valid) {
cbm_daemon_runtime_application_token_t response_token = runtime_get_u64(payload);
status = (cbm_daemon_runtime_application_status_t)runtime_get_u32(payload + 8);
response_length = runtime_get_u32(payload + 12);
protocol_valid = response_token == request_token &&
status >= CBM_DAEMON_RUNTIME_APPLICATION_OK &&
status <= CBM_DAEMON_RUNTIME_APPLICATION_CANCELLED &&
response_length <= CBM_DAEMON_RUNTIME_APPLICATION_PAYLOAD_MAX &&
frame.length == APPLICATION_RESPONSE_PREFIX_SIZE + response_length &&
(status == CBM_DAEMON_RUNTIME_APPLICATION_OK || response_length == 0);
}
uint8_t *response_copy = NULL;
bool copied = true;
if (protocol_valid && response_length > 0) {
response_copy = malloc(response_length);
copied = response_copy != NULL;
if (copied) {
memcpy(response_copy, payload + APPLICATION_RESPONSE_PREFIX_SIZE, response_length);
}
}
free(payload);
cbm_mutex_lock(&client->state_mutex);
client->exchange_active = false;
if (client->active_application_token == request_token) {
client->active_application_token = CBM_DAEMON_RUNTIME_APPLICATION_TOKEN_INVALID;
client->application_request_sent = false;
client->application_cancel_sent = false;
}
if (client->pending_cancel_token == request_token) {
client->pending_cancel_token = CBM_DAEMON_RUNTIME_APPLICATION_TOKEN_INVALID;
}
if (!protocol_valid) {
client->usable = false;
}
cbm_mutex_unlock(&client->state_mutex);
cbm_mutex_unlock(&client->exchange_mutex);
if (!protocol_valid || !copied) {
free(response_copy);
return CBM_DAEMON_RUNTIME_APPLICATION_TRANSPORT_ERROR;
}
*response_out = response_copy;
*response_length_out = response_length;
return status;
}
cbm_daemon_runtime_application_status_t cbm_daemon_runtime_client_application_request(
cbm_daemon_runtime_client_t *client, const void *request, uint32_t request_length,
uint8_t **response_out, uint32_t *response_length_out, uint32_t timeout_ms) {
if (response_out) {
*response_out = NULL;
}
if (response_length_out) {
*response_length_out = 0;
}
if (!client || !response_out || !response_length_out ||
timeout_ms == CBM_DAEMON_IPC_WAIT_FOREVER ||
request_length > CBM_DAEMON_RUNTIME_APPLICATION_PAYLOAD_MAX ||
(request_length > 0 && !request)) {
return CBM_DAEMON_RUNTIME_APPLICATION_TRANSPORT_ERROR;
}
cbm_daemon_runtime_application_token_t request_token =
CBM_DAEMON_RUNTIME_APPLICATION_TOKEN_INVALID;
if (!cbm_daemon_runtime_client_application_token_reserve(client, &request_token)) {
return CBM_DAEMON_RUNTIME_APPLICATION_TRANSPORT_ERROR;
}
return cbm_daemon_runtime_client_application_request_tagged(
client, request_token, request, request_length, response_out, response_length_out, NULL,
timeout_ms);
}
bool cbm_daemon_runtime_client_close_begin(cbm_daemon_runtime_client_t *client) {
if (!client) {
return false;
}
/* Serialize with request publication. If the request won send_mutex, its
* exact token is visible here and cancellation is ordered after REQUEST;
* if close won, the request path's closing recheck refuses the late send. */
cbm_mutex_lock(&client->send_mutex);
cbm_mutex_lock(&client->state_mutex);
if (client->closing) {
cbm_mutex_unlock(&client->state_mutex);
cbm_mutex_unlock(&client->send_mutex);
return false;
}
client->closing = true;
client->close_interrupted_exchange = client->exchange_active;
cbm_daemon_ipc_connection_t *connection = client->connection;
cbm_daemon_runtime_application_token_t cancel_token = client->active_application_token;
bool send_cancel = client->close_interrupted_exchange && connection &&
client->application_request_sent && !client->application_cancel_sent &&
cancel_token != CBM_DAEMON_RUNTIME_APPLICATION_TOKEN_INVALID;
if (send_cancel) {
client->application_cancel_sent = true;
}
cbm_mutex_unlock(&client->state_mutex);
if (send_cancel) {
uint8_t wire[APPLICATION_CANCEL_REQUEST_SIZE];
runtime_put_u64(wire, cancel_token);
(void)cbm_daemon_ipc_send_frame(connection, CBM_DAEMON_FRAME_REQUEST,
CBM_DAEMON_RUNTIME_OP_APPLICATION_CANCEL, wire,
(uint32_t)sizeof(wire));
}
if (client->close_interrupted_exchange && connection) {
/* The interrupted-exchange close cannot run the DISCONNECT handshake,
* so announce the departure explicitly (ordered after the cancel);
* the server releases this client's admission on receipt instead of
* waiting for the handle to close. Mirrors POSIX shutdown() timing. */
(void)cbm_daemon_ipc_send_frame(connection, CBM_DAEMON_FRAME_REQUEST,
CBM_DAEMON_RUNTIME_OP_CLOSE_INTENT, NULL, 0);
cbm_daemon_ipc_connection_interrupt(connection);
}
cbm_mutex_unlock(&client->send_mutex);
return true;
}
bool cbm_daemon_runtime_client_close_finish(cbm_daemon_runtime_client_t *client,
uint32_t timeout_ms) {
if (!client) {
return false;
}
cbm_mutex_lock(&client->state_mutex);
bool closing = client->closing;
cbm_mutex_unlock(&client->state_mutex);
if (!closing) {
return false;
}
cbm_mutex_lock(&client->exchange_mutex);
bool acknowledged = false;
cbm_mutex_lock(&client->state_mutex);
bool can_disconnect = timeout_ms != CBM_DAEMON_IPC_WAIT_FOREVER &&
!client->close_interrupted_exchange && client->usable &&
client->connection != NULL;
cbm_daemon_ipc_connection_t *connection = client->connection;
cbm_mutex_unlock(&client->state_mutex);
bool disconnect_sent = false;
if (can_disconnect) {
cbm_mutex_lock(&client->send_mutex);
disconnect_sent = cbm_daemon_ipc_send_frame(connection, CBM_DAEMON_FRAME_REQUEST,
CBM_DAEMON_RUNTIME_OP_DISCONNECT, NULL, 0);
cbm_mutex_unlock(&client->send_mutex);
}
if (disconnect_sent) {
cbm_daemon_frame_t frame = {0};
uint8_t *response = NULL;
int received = cbm_daemon_ipc_receive_frame(connection, timeout_ms, &frame, &response);
acknowledged = received == 1 && frame.type == CBM_DAEMON_FRAME_RESPONSE &&
frame.flags == CBM_DAEMON_RUNTIME_OP_DISCONNECT &&
frame.length == STATUS_RESPONSE_SIZE && response &&
runtime_get_u32(response) == 1;
free(response);
}
cbm_mutex_lock(&client->state_mutex);
connection = client->connection;
client->connection = NULL;
client->usable = false;
client->exchange_active = false;
cbm_mutex_unlock(&client->state_mutex);
cbm_daemon_ipc_connection_close(connection);
cbm_mutex_unlock(&client->exchange_mutex);
cbm_mutex_destroy(&client->state_mutex);
cbm_mutex_destroy(&client->send_mutex);
cbm_mutex_destroy(&client->exchange_mutex);
free(client);
return acknowledged;
}
bool cbm_daemon_runtime_client_close(cbm_daemon_runtime_client_t *client, uint32_t timeout_ms) {
if (!cbm_daemon_runtime_client_close_begin(client)) {
return false;
}
return cbm_daemon_runtime_client_close_finish(client, timeout_ms);
}