Function cbm_daemon_runtime_client_connect

src/daemon/runtime.c:2886–2939

}

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 || !cbm_daemon_ipc_send_frame(connection, CBM_DAEMON_FRAME_REQUEST,
                                                  CBM_DAEMON_RUNTIME_OP_HELLO, request,
                                                  (uint32_t)sizeof(request))) {
        cbm_daemon_ipc_connection_close(connection);
        return NULL;
    }
    cbm_daemon_frame_t frame = {0};
    uint8_t *payload = NULL;
    int received = cbm_daemon_ipc_receive_frame_bounded(
        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 (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;