rename ready_cbks → init_cbks (connection init, not fully ready)

ready_cbks/etcp_conn_set_ready_cbk/add_ready/remove_ready → init_cbks/..._init_cbk
ca_ready_cb → ca_init_cb
cm_direct_ready_cb → cm_direct_init_cb
cm_reverse_ready_cb → cm_reverse_init_cb
ntp_node_on_conn_ready → ntp_node_on_conn_init
connect_ready_cb → connect_init_cb

init accurately describes when conn->initialized=1, before keepalives establish UP.
Also fire etcp_fire_conn_status INIT at this point instead of create time.

src/conn_mgr.c

@@ -46,8 +46,8 @@ static void cm_handle_interm_exchange_req(struct ETCP_CONN* conn, struct CONN_MG
 static void cm_handle_interm_exchange_resp(struct CONN_MGR* mgr, const uint8_t* data, size_t len);
 static void cm_handle_interm_selected(struct CONN_MGR* mgr, const uint8_t* data, size_t len);
 static void cm_handle_disconnect(struct CONN_MGR* mgr, uint64_t node_id);
-static void cm_direct_ready_cb(struct ETCP_CONN* conn, void* arg);
-static void cm_reverse_ready_cb(struct ETCP_CONN* conn, void* arg);
+static void cm_direct_init_cb(struct ETCP_CONN* conn, void* arg);
+static void cm_reverse_init_cb(struct ETCP_CONN* conn, void* arg);
 static void cm_reverse_timeout_cb(void* arg);
 static void cm_exchange_timeout_cb(void* arg);
 static void cm_candidate_ping_timer_cb(void* arg);
@@ -471,7 +471,7 @@ static void cm_start_phase_direct(struct CONN_MGR_ENTRY* entry) {
                         struct sockaddr_storage sa; memset(&sa, 0, sizeof(sa)); memcpy(&sa, &sin, sizeof(sin));
                         struct ETCP_CONN* conn = etcp_connection_create(entry->mgr->instance, NULL);
                         if (conn) {
-                            etcp_conn_set_ready_cbk(conn, cm_direct_ready_cb, entry);
+                            etcp_conn_set_init_cbk(conn, cm_direct_init_cb, entry);
                             sc_init_ctx(&conn->crypto_ctx, &entry->mgr->instance->my_keys);
                             sc_set_peer_public_key(&conn->crypto_ctx, target->node->public_key, 0);
                             if (etcp_link_new(conn, s, &sa, 0)) {
@@ -507,7 +507,7 @@ static void cm_direct_timeout_cb(void* arg) {
         cm_deliver_result(entry, CONN_MGR_ERR_UNREACHABLE);
 }
 
-static void cm_direct_ready_cb(struct ETCP_CONN* conn, void* arg) {
+static void cm_direct_init_cb(struct ETCP_CONN* conn, void* arg) {
     struct CONN_MGR_ENTRY* entry = (struct CONN_MGR_ENTRY*)arg;
     if (!conn || conn->peer_node_id != entry->node_id) {
         DEBUG_WARN(DEBUG_CATEGORY_GENERAL, "conn_mgr: direct ready cb peer mismatch conn=%p peer=0x%llx entry=0x%llx",
@@ -611,7 +611,7 @@ static void cm_reverse_timeout_cb(void* arg) {
     cm_start_phase_indirect(entry);
 }
 
-static void cm_reverse_ready_cb(struct ETCP_CONN* conn, void* arg) {
+static void cm_reverse_init_cb(struct ETCP_CONN* conn, void* arg) {
     struct cm_reverse_pending* rp = (struct cm_reverse_pending*)arg;
     struct CONN_MGR_ENTRY* entry = rp->entry;
     if (!conn || conn->peer_node_id != entry->node_id) { u_free(rp); return; }
@@ -859,7 +859,7 @@ static void cm_handle_direct_req(struct ETCP_CONN* conn, const uint8_t* data, si
                         sc_set_peer_public_key(&new_conn->crypto_ctx, nq->node->public_key, 0); }
                     struct cm_reverse_pending* rp = u_calloc(1, sizeof(struct cm_reverse_pending));
                     if (rp) { rp->request_id = req->request_id; rp->entry = NULL; rp->next = mgr->reverse_pending;
-                        etcp_conn_set_ready_cbk(new_conn, cm_reverse_ready_cb, rp); mgr->reverse_pending = rp; }
+                        etcp_conn_set_init_cbk(new_conn, cm_reverse_init_cb, rp); mgr->reverse_pending = rp; }
                     etcp_link_new(new_conn, s, &sa, 0);
                 }
                 break;

src/etcp.c

@@ -332,7 +332,7 @@ static void etcp_connection_free_resources(struct ETCP_CONN* etcp) {
     drain_and_free_queue(&etcp->ack_q);
 
     // Free callback chains
-    { struct etcp_cbk_entry* cbe = etcp->ready_cbks; while (cbe) { struct etcp_cbk_entry* n = cbe->next; u_free(cbe); cbe = n; } etcp->ready_cbks = NULL; }
+    { struct etcp_cbk_entry* cbe = etcp->init_cbks; while (cbe) { struct etcp_cbk_entry* n = cbe->next; u_free(cbe); cbe = n; } etcp->init_cbks = NULL; }
     { struct etcp_cbk_entry* cbe = etcp->up_cbks;    while (cbe) { struct etcp_cbk_entry* n = cbe->next; u_free(cbe); cbe = n; } etcp->up_cbks = NULL; }
     { struct etcp_cbk_entry* cbe = etcp->down_cbks;  while (cbe) { struct etcp_cbk_entry* n = cbe->next; u_free(cbe); cbe = n; } etcp->down_cbks = NULL; }
 
@@ -621,7 +621,7 @@ void etcp_conn_queue_set_ready(struct ETCP_CONN* conn) {
     etcp_metrics_start_timer(conn);
 
     conn->callbacks_running = 1;
-    { struct etcp_cbk_entry* cbe = conn->ready_cbks; while (cbe) { struct etcp_cbk_entry* n = cbe->next; cbe->fn(conn, cbe->arg); cbe = n; } }
+    { struct etcp_cbk_entry* cbe = conn->init_cbks; while (cbe) { struct etcp_cbk_entry* n = cbe->next; cbe->fn(conn, cbe->arg); cbe = n; } }
     if (conn->links_up) etcp_on_up(conn);
     conn->callbacks_running = 0;
 }

src/etcp.h

@@ -237,7 +237,7 @@ struct ETCP_CONN {
     uint8_t callbacks_running;       // 1 - внутри итерации колбэк-цепочек, etcp_connection_close запрещён
 
     // Callback chains for ready/up/down notifications
-    struct etcp_cbk_entry* ready_cbks;   // цепочка callback'ов при готовности соединения
+    struct etcp_cbk_entry* init_cbks;    // цепочка callback'ов при инициализации соединения
     struct etcp_cbk_entry* up_cbks;      // цепочка callback'ов при поднятии канала
     struct etcp_cbk_entry* down_cbks;    // цепочка callback'ов при падении канала
     void (*bgp_ready_cbk)(struct ETCP_CONN* conn);  // вызывается когда BGP готов (завершён или пропущен)

src/etcp_api.c

@@ -12,12 +12,12 @@
 
 #define DEBUG_CATEGORY_ETCP_API DEBUG_CATEGORY_ETCP
 
-void etcp_conn_set_ready_cbk(struct ETCP_CONN* e, etcp_cbk_fn fn, void* arg) {
+void etcp_conn_set_init_cbk(struct ETCP_CONN* e, etcp_cbk_fn fn, void* arg) {
     if (!e) return;
-    struct etcp_cbk_entry* entry = e->ready_cbks;
+    struct etcp_cbk_entry* entry = e->init_cbks;
     while (entry) { struct etcp_cbk_entry* next = entry->next; u_free(entry); entry = next; }
-    e->ready_cbks = NULL;
-    if (fn) etcp_conn_add_ready_cbk(e, fn, arg);
+    e->init_cbks = NULL;
+    if (fn) etcp_conn_add_init_cbk(e, fn, arg);
 }
 void etcp_conn_set_up_cbk(struct ETCP_CONN* e, etcp_cbk_fn fn, void* arg) {
     if (!e) return;
@@ -60,8 +60,8 @@ static void etcp_cbk_remove_from_chain(struct etcp_cbk_entry** head, etcp_cbk_fn
     }
 }
 
-void etcp_conn_add_ready_cbk(struct ETCP_CONN* conn, etcp_cbk_fn fn, void* arg) { if (conn) etcp_cbk_add_to_chain(&conn->ready_cbks, fn, arg); }
-void etcp_conn_remove_ready_cbk(struct ETCP_CONN* conn, etcp_cbk_fn fn, void* arg) { if (conn) etcp_cbk_remove_from_chain(&conn->ready_cbks, fn, arg); }
+void etcp_conn_add_init_cbk(struct ETCP_CONN* conn, etcp_cbk_fn fn, void* arg) { if (conn) etcp_cbk_add_to_chain(&conn->init_cbks, fn, arg); }
+void etcp_conn_remove_init_cbk(struct ETCP_CONN* conn, etcp_cbk_fn fn, void* arg) { if (conn) etcp_cbk_remove_from_chain(&conn->init_cbks, fn, arg); }
 void etcp_conn_add_up_cbk(struct ETCP_CONN* conn, etcp_cbk_fn fn, void* arg) { if (conn) etcp_cbk_add_to_chain(&conn->up_cbks, fn, arg); }
 void etcp_conn_remove_up_cbk(struct ETCP_CONN* conn, etcp_cbk_fn fn, void* arg) { if (conn) etcp_cbk_remove_from_chain(&conn->up_cbks, fn, arg); }
 void etcp_conn_add_down_cbk(struct ETCP_CONN* conn, etcp_cbk_fn fn, void* arg) { if (conn) etcp_cbk_add_to_chain(&conn->down_cbks, fn, arg); }

src/etcp_api.h

@@ -162,12 +162,12 @@ int etcp_unbind(struct UTUN_INSTANCE* inst, uint8_t id);
  * @param callback_fn Коллбэк который будет вызван при готовности
  * @param arg Аргумент для коллбэка
  */
-void etcp_conn_set_ready_cbk(struct ETCP_CONN* conn, etcp_cbk_fn callback_fn, void* arg);
+void etcp_conn_set_init_cbk(struct ETCP_CONN* conn, etcp_cbk_fn callback_fn, void* arg);
 void etcp_conn_set_up_cbk   (struct ETCP_CONN* conn, etcp_cbk_fn callback_fn, void* arg);
 void etcp_conn_set_down_cbk (struct ETCP_CONN* conn, etcp_cbk_fn callback_fn, void* arg);
 
-void etcp_conn_add_ready_cbk(struct ETCP_CONN* conn, etcp_cbk_fn fn, void* arg);
-void etcp_conn_remove_ready_cbk(struct ETCP_CONN* conn, etcp_cbk_fn fn, void* arg);
+void etcp_conn_add_init_cbk(struct ETCP_CONN* conn, etcp_cbk_fn fn, void* arg);
+void etcp_conn_remove_init_cbk(struct ETCP_CONN* conn, etcp_cbk_fn fn, void* arg);
 void etcp_conn_add_up_cbk(struct ETCP_CONN* conn, etcp_cbk_fn fn, void* arg);
 void etcp_conn_remove_up_cbk(struct ETCP_CONN* conn, etcp_cbk_fn fn, void* arg);
 void etcp_conn_add_down_cbk(struct ETCP_CONN* conn, etcp_cbk_fn fn, void* arg);

src/etcp_connect.c

@@ -35,7 +35,7 @@ struct ETCP_CONNECT {
 };
 static void tcp_link_ready_cb(struct stcp_link* link, void* arg);
 static void tcp_link_close_cb(struct stcp_link* link, int err, void* arg);
-static void connect_ready_cb(struct ETCP_CONN* conn, void* arg);
+static void connect_init_cb(struct ETCP_CONN* conn, void* arg);
 
 static struct ETCP_CONNECT* connect_find(struct UTUN_INSTANCE* inst, uint64_t node_id) {
     struct ETCP_CONNECT* ctx = inst->pending_connects;
@@ -123,7 +123,7 @@ static void tcp_link_ready_cb(struct stcp_link* link, void* arg) {
     if (!ctx || ctx->done || ctx->tcp_ready) return;
     ctx->tcp_ready = 1;
     DEBUG_INFO(DEBUG_CATEGORY_ETCP_CONNECT, "[etcp_connect] TCP link ready for node 0x%016llx", (unsigned long long)ctx->node_id);
-    connect_ready_cb(ctx->conn, ctx);
+    connect_init_cb(ctx->conn, ctx);
 }
 
 static void tcp_link_close_cb(struct stcp_link* link, int err, void* arg) {
@@ -175,12 +175,12 @@ static void connect_settle_timeout_cb(void* arg) {
                    (unsigned long long)ctx->node_id);
         stcp_link_close(ctx->tcp_link); ctx->tcp_link = NULL;
     }
-    etcp_conn_remove_ready_cbk(ctx->conn, connect_ready_cb, ctx);
+    etcp_conn_remove_init_cbk(ctx->conn, connect_init_cb, ctx);
     connect_deliver(ctx, ETCP_CONNECT_LATE);
     connect_cancel(ctx);
 }
 
-static void connect_ready_cb(struct ETCP_CONN* conn, void* arg) {
+static void connect_init_cb(struct ETCP_CONN* conn, void* arg) {
     struct ETCP_CONNECT* ctx = (struct ETCP_CONNECT*)arg;
     if (!ctx || ctx->done) return;
     struct ETCP_LINK* link = conn->links;
@@ -266,7 +266,7 @@ int etcp_connect(struct UTUN_INSTANCE* inst, struct TOPO_NODEQ* node,
         cn->cb = cb; cn->arg = arg; cn->flags = flags; ctx->cb_list = cn;
     }
 
-    etcp_conn_add_ready_cbk(conn, connect_ready_cb, ctx);
+    etcp_conn_add_init_cbk(conn, connect_init_cb, ctx);
     conn->bgp_ready_cbk = connect_bgp_ready_cb;
 
     connect_create_links_v4(ctx, node);

src/etcp_connections.c

@@ -38,7 +38,7 @@ static void tcp_server_on_link(struct stcp_link *link, void *arg) {
     snprintf(conn->log_name, sizeof(conn->log_name), "tcp-[%p]", (void*)link);
     struct etcp_cbk_entry* cbe = inst->new_conn_cbks;
     while (cbe) { struct etcp_cbk_entry* n = cbe->next; cbe->fn(conn, cbe->arg); cbe = n; }
-    { struct etcp_cbk_entry* rcb = conn->ready_cbks; while (rcb) { struct etcp_cbk_entry* n = rcb->next; rcb->fn(conn, rcb->arg); rcb = n; } }
+    { struct etcp_cbk_entry* rcb = conn->init_cbks; while (rcb) { struct etcp_cbk_entry* n = rcb->next; rcb->fn(conn, rcb->arg); rcb = n; } }
     DEBUG_INFO(DEBUG_CATEGORY_ETCP, "TCP server new conn=%p total=%d pending=%d",
                (void*)conn,
                queue_entry_count(inst->connections),

src/ntp_node_time.c

@@ -21,7 +21,7 @@ struct time_sync_msg {
 
 _Static_assert(sizeof(struct time_sync_msg) == 9, "time_sync_msg size mismatch");
 
-static void ntp_node_on_conn_ready(struct ETCP_CONN* conn, void* arg);
+static void ntp_node_on_conn_init(struct ETCP_CONN* conn, void* arg);
 static void ntp_node_on_new_conn(struct ETCP_CONN* conn, void* arg);
 static void ntp_node_recv_cb(struct ETCP_CONN* conn, struct ll_entry* entry);
 
@@ -82,7 +82,7 @@ static void check_drift(uint64_t node_id, int64_t offset_us) {
     }
 }
 
-static void ntp_node_on_conn_ready(struct ETCP_CONN* conn, void* arg) {
+static void ntp_node_on_conn_init(struct ETCP_CONN* conn, void* arg) {
     struct UTUN_INSTANCE* inst = (struct UTUN_INSTANCE*)arg;
     if (!inst || !conn) return;
 
@@ -99,7 +99,7 @@ static void ntp_node_on_new_conn(struct ETCP_CONN* conn, void* arg) {
     if (!conn) return;
     struct UTUN_INSTANCE* inst = (struct UTUN_INSTANCE*)arg;
     if (!inst) return;
-    etcp_conn_add_ready_cbk(conn, ntp_node_on_conn_ready, inst);
+    etcp_conn_add_init_cbk(conn, ntp_node_on_conn_init, inst);
 }
 
 static void ntp_node_recv_cb(struct ETCP_CONN* conn, struct ll_entry* entry) {

tools/chatgui/transport/chat_core.c

@@ -674,7 +674,7 @@ static void ca_cleanup(struct ca_state* st) {
     u_free(st);
 }
 
-static void ca_ready_cb(struct ETCP_CONN* conn, void* arg) {
+static void ca_init_cb(struct ETCP_CONN* conn, void* arg) {
     struct ca_ctx* ctx = (struct ca_ctx*)arg;
     struct ca_state* st = ctx->state;
     if (st->delivered || st->cancelled) return;
@@ -685,7 +685,7 @@ static void ca_ready_cb(struct ETCP_CONN* conn, void* arg) {
         if (st->timers[i]) { uasync_cancel_timeout(st->inst->ua, st->timers[i]); st->timers[i] = NULL; }
         if (st->conns[i] && i != ctx->addr_index) { uasync_call_soon(st->inst->ua, st->conns[i], (timeout_callback_t)etcp_connection_close); st->conns[i] = NULL; }
     }
-    etcp_conn_remove_ready_cbk(conn, ca_ready_cb, ctx);
+    etcp_conn_remove_init_cbk(conn, ca_init_cb, ctx);
     st->result_cb(CC_OK, st->node_id, st->result_arg);
     ca_cleanup(st);
 }
@@ -860,7 +860,7 @@ void chat_core_connect_auto(uint64_t node_id,
         pctx->state = pst; pctx->addr_index = i;
         pst->ctxs[i] = pctx;
 
-        etcp_conn_set_ready_cbk(conn, ca_ready_cb, pctx);
+        etcp_conn_set_init_cbk(conn, ca_init_cb, pctx);
 
         if (!etcp_link_new(conn, best_socket, &sa, 0)) {
             DEBUG_ERROR(DEBUG_CATEGORY_CONNECTIVITY, "%s: auto_connect etcp_link_new failed idx=%d", CC_ID, i);

tools/chatgui/transport/chat_sync.c

@@ -198,7 +198,7 @@ static void ac_result_cb(int result, uint64_t node_id, void* arg) {
     if (!g_ac || !g_ac->active) return;
     const char* rs = result == CC_OK ? "OK" : "FAIL";
     DEBUG_INFO(DEBUG_CATEGORY_DB_SYNC, "%s: result node=0x%016llx %s", AC_ID, (unsigned long long)node_id, rs);
-    f->ca_state = NULL; /* already freed by ca_ready_cb or ca_timeout_cb */
+    f->ca_state = NULL; /* already freed by ca_init_cb or ca_timeout_cb */
 }
 
 /* ── retry timer callback (every AC_RETRY_MS) ── */