uasync: pass socket name to all add_socket call sites

src/call/call_headless.c

@@ -282,7 +282,7 @@ static void ca_accept_callback(socket_t fd, void* arg) {
     if (!cli) { socket_close_wrapper(cfd); return; }
     cli->fd = cfd;
     cli->ca = ca;
-    cli->socket_id = uasync_add_socket_t(ca->ua, cfd, ca_read_callback, ca_write_callback, NULL, cli);
+    cli->socket_id = uasync_add_socket_t(ca->ua, cfd, ca_read_callback, ca_write_callback, NULL, "call_client", cli);
     if (!cli->socket_id) { u_free(cli); socket_close_wrapper(cfd); DEBUG_ERROR(DEBUG_CATEGORY_CALL, "%s: failed to register client fd", CH_ID); return; }
 
     cli->next = ca->clients; ca->clients = cli; ca->client_count++;
@@ -333,7 +333,7 @@ int call_headless_init(struct UASYNC* ua, struct UTUN_INSTANCE* inst,
     }
     if (listen(ca->listen_fd, 5) < 0) { socket_close_wrapper(ca->listen_fd); ca->listen_fd = SOCKET_INVALID; return -1; }
 
-    ca->listen_sock_id = uasync_add_socket_t(ua, ca->listen_fd, ca_accept_callback, NULL, NULL, ca);
+    ca->listen_sock_id = uasync_add_socket_t(ua, ca->listen_fd, ca_accept_callback, NULL, NULL, "call_listen", ca);
     if (!ca->listen_sock_id) { socket_close_wrapper(ca->listen_fd); ca->listen_fd = SOCKET_INVALID; return -1; }
 
     call_set_media_recv_cb(inst, ca_media_recv, ca);

src/chat/chat_headless_control.c

@@ -799,7 +799,7 @@ static void accept_callback(socket_t fd, void* arg) {
     cli->fd = cfd;
     cli->hc = hc;
 
-    cli->socket_id = uasync_add_socket_t(hc->ua, cfd, client_read_callback, client_write_callback, NULL, cli);
+    cli->socket_id = uasync_add_socket_t(hc->ua, cfd, client_read_callback, client_write_callback, NULL, "chatctl_client", cli);
     if (!cli->socket_id) { u_free(cli); socket_close_wrapper(cfd); DEBUG_ERROR((int)DEBUG_CATEGORY_HEADLESS, "headless: failed to register client fd"); return; }
 
     cli->next = hc->clients; hc->clients = cli; hc->client_count++;
@@ -853,7 +853,7 @@ int chat_headless_control_init(struct UASYNC* ua, struct UTUN_INSTANCE* inst,
     }
     if (listen(hc->listen_fd, 5) < 0) { socket_close_wrapper(hc->listen_fd); hc->listen_fd = SOCKET_INVALID; return -1; }
 
-    hc->listen_sock_id = uasync_add_socket_t(ua, hc->listen_fd, accept_callback, NULL, NULL, hc);
+    hc->listen_sock_id = uasync_add_socket_t(ua, hc->listen_fd, accept_callback, NULL, NULL, "chatctl_listen", hc);
     if (!hc->listen_sock_id) { socket_close_wrapper(hc->listen_fd); hc->listen_fd = SOCKET_INVALID; return -1; }
 
     chat_event_set_handler(inst, hc_on_chat_event);

src/control_server.c

@@ -217,6 +217,7 @@ int control_server_init(struct control_server* server,
                                                       accept_callback,
                                                       NULL,  /* write callback */
                                                       NULL,  /* except callback */
+                                                      "control_listen",
                                                       server);
     
     if (!server->listen_socket_id) {
@@ -434,6 +435,7 @@ static void accept_callback(socket_t fd, void* arg) {
                                             client_read_callback,
                                             client_write_callback,
                                             client_except_callback,
+                                            "control_client",
                                             client);
     
     if (!client->socket_id) {

src/ntp_time.c

@@ -211,7 +211,7 @@ static void ntp_send_request(struct ntp_sync* ctx) {
     }
 
     if (!ctx->socket_id) {
-        ctx->socket_id = uasync_add_socket_t(inst->ua, ctx->sock, ntp_query_read_cb, NULL, NULL, ctx);
+        ctx->socket_id = uasync_add_socket_t(inst->ua, ctx->sock, ntp_query_read_cb, NULL, NULL, "ntp_query", ctx);
         if (!ctx->socket_id) {
             DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "NTP: uasync_add_socket_t failed");
             ntp_query_fail(ctx);

src/proxy/icmp_proxy.c

@@ -338,7 +338,7 @@ int icmp_proxy_init(struct UTUN_INSTANCE* inst, struct UASYNC* ua) {
             DEBUG_ERROR(DEBUG_CATEGORY_PROXY, "icmp_proxy: raw socket(SOCK_RAW) failed: %s", strerror(errno));
         else {
             DEBUG_INFO(DEBUG_CATEGORY_PROXY, "icmp_proxy: raw socket created fd=%d", ctx->raw_sock);
-            ctx->raw_read_id = uasync_add_socket_t(ua, ctx->raw_sock, raw_read_cb, NULL, NULL, NULL);
+            ctx->raw_read_id = uasync_add_socket_t(ua, ctx->raw_sock, raw_read_cb, NULL, NULL, "icmp_raw", NULL);
             if (!ctx->raw_read_id) { socket_close_wrapper(ctx->raw_sock); ctx->raw_sock = SOCKET_INVALID; }
         }
     }

src/proxy/socks_proxy.c

@@ -736,7 +736,7 @@ struct listen_ctx* socks_proxy_init_listen(struct UASYNC* ua, const char* addr_s
     if (listen(sock, 32) < 0) { DEBUG_ERROR(DEBUG_CATEGORY_PROXY, "socks_proxy: listen() failed errno=%d", errno); socket_close_wrapper(sock); u_free(ctx); return NULL; }
 
     ctx->listen_sock = sock;
-    ctx->socket_id = uasync_add_socket_t(ua, sock, on_accept_cb, NULL, NULL, ctx);
+    ctx->socket_id = uasync_add_socket_t(ua, sock, on_accept_cb, NULL, NULL, "socks_proxy_listen", ctx);
     if (!ctx->socket_id) { DEBUG_ERROR(DEBUG_CATEGORY_PROXY, "socks_proxy: uasync_add_socket_t failed"); socket_close_wrapper(sock); u_free(ctx); return NULL; }
 
     DEBUG_INFO(DEBUG_CATEGORY_PROXY, "socks_proxy: %s listening on %s:%d sock=%d",

src/proxy/udp_proxy.c

@@ -95,7 +95,7 @@ static void exit_handle_data(struct ETCP_CONN* conn, struct ll_entry* entry) {
         socket_set_nonblocking(f->sock);
         struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr = {.s_addr = INADDR_ANY}, .sin_port = 0};
         bind(f->sock, (struct sockaddr*)&bind_addr, sizeof(bind_addr));
-        f->read_id = uasync_add_socket_t(g_udp_ctx->ua, f->sock, flow_read_cb, NULL, NULL, f);
+        f->read_id = uasync_add_socket_t(g_udp_ctx->ua, f->sock, flow_read_cb, NULL, NULL, "udp_flow", f);
         if (!f->read_id) { socket_close_wrapper(f->sock); u_free(f); goto drop; }
         f->next = g_udp_ctx->flows; g_udp_ctx->flows = f; g_udp_ctx->flow_count++;
         if (!g_udp_ctx->expire_timer)

src/radio/radio_headless.c

@@ -405,7 +405,7 @@ static void rh_accept_callback(socket_t fd, void* arg) {
     if (!cli) { socket_close_wrapper(cfd); return; }
     cli->fd = cfd;
     cli->rh = rh;
-    cli->socket_id = uasync_add_socket_t(rh->ua, cfd, rh_read_callback, rh_write_callback, NULL, cli);
+    cli->socket_id = uasync_add_socket_t(rh->ua, cfd, rh_read_callback, rh_write_callback, NULL, "radio_client", cli);
     if (!cli->socket_id) { u_free(cli); socket_close_wrapper(cfd); DEBUG_ERROR(DEBUG_CATEGORY_RADIO, "%s: failed to register client fd", RH_ID); return; }
 
     cli->next = rh->clients; rh->clients = cli; rh->client_count++;
@@ -456,7 +456,7 @@ int radio_headless_init(struct UASYNC* ua, struct UTUN_INSTANCE* inst,
     }
     if (listen(rh->listen_fd, 5) < 0) { socket_close_wrapper(rh->listen_fd); rh->listen_fd = SOCKET_INVALID; return -1; }
 
-    rh->listen_sock_id = uasync_add_socket_t(ua, rh->listen_fd, rh_accept_callback, NULL, NULL, rh);
+    rh->listen_sock_id = uasync_add_socket_t(ua, rh->listen_fd, rh_accept_callback, NULL, NULL, "radio_listen", rh);
     if (!rh->listen_sock_id) { socket_close_wrapper(rh->listen_fd); rh->listen_fd = SOCKET_INVALID; return -1; }
 
     radio_set_frame_cb(inst, rh_frame_cb, rh);

src/transport_layer/auto_socket.c

@@ -1205,7 +1205,7 @@ static int auto_socket_init_monitor(struct AUTO_SOCKET* as) {
         close(as->nl_sock); as->nl_sock = -1; return 0;
     }
     socket_set_nonblocking(as->nl_sock);
-    as->uasync_handle = uasync_add_socket(as->instance->ua, as->nl_sock, auto_socket_netlink_cb, NULL, NULL, as);
+    as->uasync_handle = uasync_add_socket(as->instance->ua, as->nl_sock, auto_socket_netlink_cb, NULL, NULL, "netlink_autosock", as);
     if (!as->uasync_handle) { DEBUG_ERROR(DEBUG_CATEGORY_AS, "[as] uasync_add_socket failed"); close(as->nl_sock); as->nl_sock = -1; return 0; }
     DEBUG_INFO(DEBUG_CATEGORY_AS, "[as] netlink monitor started: fd=%d", (int)as->nl_sock);
     return 0;
@@ -1240,7 +1240,7 @@ static int auto_socket_init_monitor(struct AUTO_SOCKET* as) {
     as->route_sock = socket(PF_ROUTE, SOCK_RAW, AF_UNSPEC);
     if (as->route_sock < 0) { DEBUG_ERROR(DEBUG_CATEGORY_AS, "[as] route socket: %s", strerror(errno)); return -1; }
     fcntl(as->route_sock, F_SETFL, O_NONBLOCK);
-    as->uasync_handle = uasync_add_socket(as->instance->ua, as->route_sock, auto_socket_bsd_cb, NULL, NULL, as);
+    as->uasync_handle = uasync_add_socket(as->instance->ua, as->route_sock, auto_socket_bsd_cb, NULL, NULL, "route_autosock", as);
     if (!as->uasync_handle) { DEBUG_ERROR(DEBUG_CATEGORY_AS, "[as] uasync_add_socket failed"); close(as->route_sock); return -1; }
     DEBUG_INFO(DEBUG_CATEGORY_AS, "[as] route socket monitor started: fd=%d", (int)as->route_sock);
     return 0;

src/transport_layer/dummynet.c

@@ -410,7 +410,7 @@ struct dummynet* dummynet_create(struct UASYNC* ua, const char* bind_ip, uint16_
     }
 
     /* Добавляем сокет в uasync */
-    void* sock_id = uasync_add_socket_t(ua, dn->sock, dummynet_read_callback, NULL, NULL, dn);
+    void* sock_id = uasync_add_socket_t(ua, dn->sock, dummynet_read_callback, NULL, NULL, "dummynet", dn);
     if (!sock_id) {
         DEBUG_ERROR(DEBUG_CATEGORY_DUMMYNET, "Failed to add socket to uasync");
         dummynet_destroy(dn);

src/transport_layer/etcp_connections.c

@@ -796,10 +796,10 @@ struct ETCP_SOCKET* etcp_socket_add(struct UTUN_INSTANCE* instance, struct CFG_S
             u_free(e_sock);
             return NULL;
         }
-        e_sock->socket_id = uasync_add_socket_t(instance->ua, e_sock->fd, socks_etcp_read_callback, NULL, NULL, e_sock);
+        e_sock->socket_id = uasync_add_socket_t(instance->ua, e_sock->fd, socks_etcp_read_callback, NULL, NULL, "etcp_sock_socks", e_sock);
         DEBUG_INFO(DEBUG_CATEGORY_SOCKET, "socket %s tunneled via SOCKS5 UDP (proxy=%s:%u)", e_sock->name, gc->socks_host, gc->socks_port);
     } else {
-        e_sock->socket_id = uasync_add_socket_t(instance->ua, e_sock->fd, etcp_connections_read_callback_socket, NULL, NULL, e_sock);
+        e_sock->socket_id = uasync_add_socket_t(instance->ua, e_sock->fd, etcp_connections_read_callback_socket, NULL, NULL, "etcp_sock", e_sock);
     }
     if (!e_sock->socket_id) {
         DEBUG_ERROR(DEBUG_CATEGORY_SOCKET, "Failed to register socket with uasync");

src/transport_layer/reality_relay.c

@@ -226,7 +226,7 @@ int reality_relay_start(struct UASYNC *ua, socket_t client_sock,
 
     // берём владение client_sock: снимаем прежнюю регистрацию и ставим свою
     uasync_remove_socket_t(ua, client_sock);
-    r->client_sid = uasync_add_socket_t(ua, client_sock, relay_client_read_cb, relay_client_write_cb, NULL, r);
+    r->client_sid = uasync_add_socket_t(ua, client_sock, relay_client_read_cb, relay_client_write_cb, NULL, "reality_client", r);
     if (!r->client_sid) { relay_free(r); freeaddrinfo(res); return -1; }
 
     if (initial_len && initial_data) {
@@ -249,7 +249,7 @@ int reality_relay_start(struct UASYNC *ua, socket_t client_sock,
         r->connecting = 0;
         int opt = 1; setsockopt(dest_sock, IPPROTO_TCP, TCP_NODELAY, (const char *)&opt, sizeof(opt));
     }
-    r->dest_sid = uasync_add_socket_t(ua, dest_sock, relay_dest_read_cb, relay_dest_write_cb, NULL, r);
+    r->dest_sid = uasync_add_socket_t(ua, dest_sock, relay_dest_read_cb, relay_dest_write_cb, NULL, "reality_dest", r);
     if (!r->dest_sid) { relay_free(r); return -1; }
 
     if (!r->connecting && r->c2d) relay_flush_c2d(r);

src/transport_layer/socket_monitor.c

@@ -439,7 +439,7 @@ int socket_monitor_init(struct UTUN_INSTANCE* instance) {
     if (socket_set_nonblocking(sm->nl_sock) != 0) {
         DEBUG_WARN(DEBUG_CATEGORY_SOCKET, "failed to set netlink socket non-blocking: %s", strerror(errno));
     }
-    sm->uasync_handle = uasync_add_socket(instance->ua, sm->nl_sock, socket_monitor_read_cb, NULL, NULL, sm);
+    sm->uasync_handle = uasync_add_socket(instance->ua, sm->nl_sock, socket_monitor_read_cb, NULL, NULL, "netlink_monitor", sm);
     if (!sm->uasync_handle) {
         DEBUG_ERROR(DEBUG_CATEGORY_SOCKET, "failed to register netlink socket fd=%d with uasync", sm->nl_sock);
         close(sm->nl_sock);
@@ -463,7 +463,7 @@ int socket_monitor_init(struct UTUN_INSTANCE* instance) {
     if (fcntl(sm->route_sock, F_SETFL, O_NONBLOCK) < 0) {
         DEBUG_WARN(DEBUG_CATEGORY_SOCKET, "failed to set route socket non-blocking: %s", strerror(errno));
     }
-    sm->uasync_handle = uasync_add_socket(instance->ua, sm->route_sock, socket_monitor_bsd_read_cb, NULL, NULL, sm);
+    sm->uasync_handle = uasync_add_socket(instance->ua, sm->route_sock, socket_monitor_bsd_read_cb, NULL, NULL, "route_monitor", sm);
     if (!sm->uasync_handle) {
         DEBUG_ERROR(DEBUG_CATEGORY_SOCKET, "failed to register route socket fd=%d with uasync", sm->route_sock);
         close(sm->route_sock);

src/transport_layer/socks_client.c

@@ -146,7 +146,7 @@ static void socks_ctrl_connect_wait_cb(socket_t sock, void *arg) {
         return;
     }
     uasync_remove_socket_t(c->ua, sock);
-    c->socket_id = uasync_add_socket_t(c->ua, sock, socks_ctrl_read_cb, socks_ctrl_write_cb, NULL, c);
+    c->socket_id = uasync_add_socket_t(c->ua, sock, socks_ctrl_read_cb, socks_ctrl_write_cb, NULL, "socks_ctrl", c);
     if (!c->socket_id) { DEBUG_ERROR(DEBUG_CATEGORY_PROXY, "socks: re-add socket failed"); c->on_error(c, ENOMEM); return; }
     socks_ctrl_after_connect(c);
 }
@@ -189,9 +189,9 @@ static int socks_ctrl_start(struct socks_ctrl *c, int timeout_tb) {
             socket_close_wrapper(c->sock); c->sock = SOCKET_INVALID;
             return -1;
         }
-        c->socket_id = uasync_add_socket_t(c->ua, c->sock, NULL, socks_ctrl_connect_wait_cb, NULL, c);
+        c->socket_id = uasync_add_socket_t(c->ua, c->sock, NULL, socks_ctrl_connect_wait_cb, NULL, "socks_ctrl_connect", c);
     } else {
-        c->socket_id = uasync_add_socket_t(c->ua, c->sock, socks_ctrl_read_cb, socks_ctrl_write_cb, NULL, c);
+        c->socket_id = uasync_add_socket_t(c->ua, c->sock, socks_ctrl_read_cb, socks_ctrl_write_cb, NULL, "socks_ctrl", c);
         if (c->socket_id) socks_ctrl_after_connect(c);
     }
     if (!c->socket_id) { DEBUG_ERROR(DEBUG_CATEGORY_PROXY, "socks: add_socket failed"); socket_close_wrapper(c->sock); c->sock = SOCKET_INVALID; return -1; }

src/transport_layer/stcp_client.c

@@ -218,7 +218,7 @@ static void client_connect_write_cb(socket_t sock, void *arg) {
     }
     DEBUG_INFO(DEBUG_CATEGORY_ETCP, "stcp_client: TCP connected, starting handshake");
     uasync_remove_socket_t(cli->ua, sock);
-    c->socket_id = uasync_add_socket_t(cli->ua, sock, client_conn_read_cb, stcp_write_cb, NULL, c);
+    c->socket_id = uasync_add_socket_t(cli->ua, sock, client_conn_read_cb, stcp_write_cb, NULL, "stcp_client_conn", c);
     if (!c->socket_id) { stcp_conn_do_close(c, ENOMEM); return; }
     client_after_connect(c);
 }
@@ -234,7 +234,7 @@ static void client_socks_ready_cb(socket_t sock, int err, void *arg) {
         return;
     }
     c->sock = sock;
-    c->socket_id = uasync_add_socket_t(cli->ua, sock, client_conn_read_cb, stcp_write_cb, NULL, c);
+    c->socket_id = uasync_add_socket_t(cli->ua, sock, client_conn_read_cb, stcp_write_cb, NULL, "stcp_client_conn", c);
     if (!c->socket_id) { DEBUG_ERROR(DEBUG_CATEGORY_ETCP, "stcp_client: add_socket after socks failed"); stcp_conn_do_close(c, ENOMEM); return; }
     c->hs_timer = uasync_set_timeout(cli->ua, cli->hs_timeout_tb, c, hs_timeout_cb, "stcp_hs");
     client_after_connect(c);
@@ -309,11 +309,11 @@ struct stcp_client *stcp_client_connect(struct UASYNC *ua, const char *addr, uin
             DEBUG_ERROR(DEBUG_CATEGORY_ETCP, "stcp_client connect to %s:%u failed err=%d(%s)", addr, port, sock_err, socket_strerror(sock_err));
             socket_close_wrapper(c->sock); u_free(cli); return NULL;
         }
-        c->socket_id = uasync_add_socket_t(ua, c->sock, NULL, client_connect_write_cb, NULL, cli);
+        c->socket_id = uasync_add_socket_t(ua, c->sock, NULL, client_connect_write_cb, NULL, "stcp_client_connect", cli);
         if (!c->socket_id) { socket_close_wrapper(c->sock); u_free(cli); return NULL; }
         c->hs_timer = uasync_set_timeout(ua, cli->hs_timeout_tb, c, hs_timeout_cb, "stcp_hs");
     } else {
-        c->socket_id = uasync_add_socket_t(ua, c->sock, client_conn_read_cb, stcp_write_cb, NULL, c);
+        c->socket_id = uasync_add_socket_t(ua, c->sock, client_conn_read_cb, stcp_write_cb, NULL, "stcp_client_conn", c);
         if (!c->socket_id) { socket_close_wrapper(c->sock); u_free(cli); return NULL; }
         c->hs_timer = uasync_set_timeout(ua, cli->hs_timeout_tb, c, hs_timeout_cb, "stcp_hs");
         client_after_connect(c);

src/transport_layer/stcp_server.c

@@ -288,7 +288,7 @@ static void server_accept_cb(socket_t listen_sock, void *arg) {
     c->ready_arg = srv->cb_arg;
     c->on_close = srv->close_cb;
     c->close_arg = srv->close_arg;
-    c->socket_id = uasync_add_socket_t(srv->ua, cli_sock, server_conn_read_cb, stcp_write_cb, NULL, c);
+    c->socket_id = uasync_add_socket_t(srv->ua, cli_sock, server_conn_read_cb, stcp_write_cb, NULL, "stcp_conn", c);
     c->inst = srv->inst;
     c->device_type = srv->inst ? srv->inst->client_type : 0;
     c->keepalive_interval = srv->inst ? srv->inst->keepalive_interval : 200;
@@ -363,7 +363,7 @@ struct stcp_server *stcp_server_create(struct UASYNC *ua, uint16_t port,
         DEBUG_ERROR(DEBUG_CATEGORY_ETCP, "listen failed err=%d", socket_get_error());
         socket_close_wrapper(srv->listen_sock); u_free(srv); return NULL;
     }
-    srv->listen_id = uasync_add_socket_t(ua, srv->listen_sock, server_accept_cb, NULL, NULL, srv);
+    srv->listen_id = uasync_add_socket_t(ua, srv->listen_sock, server_accept_cb, NULL, NULL, "stcp_listen", srv);
     DEBUG_INFO(DEBUG_CATEGORY_ETCP, "stcp_server: listening on port %u family=%s", port, use_family == AF_INET ? "v4" : "v6");
     return srv;
 }

src/tun_if.c

@@ -181,7 +181,7 @@ struct tun_if* tun_init(struct UASYNC* ua, struct utun_config* config)
     {
         int poll_fd = test_mode ? tun->fd : tun_platform_get_poll_fd(tun);
         if (poll_fd >= 0) {
-            tun->socket_id = uasync_add_socket(ua, poll_fd, tun_read_callback, NULL, NULL, tun);
+            tun->socket_id = uasync_add_socket(ua, poll_fd, tun_read_callback, NULL, NULL, "tun", tun);
             if (!tun->socket_id) goto fail;
         }
     }
@@ -280,7 +280,7 @@ struct tun_if* tun_init_nat(struct UASYNC* ua, const char* ifname, const char* i
     {
         int poll_fd = test_mode ? tun->fd : tun_platform_get_poll_fd(tun);
         if (poll_fd >= 0) {
-            tun->socket_id = uasync_add_socket(ua, poll_fd, tun_read_callback, NULL, NULL, tun);
+            tun->socket_id = uasync_add_socket(ua, poll_fd, tun_read_callback, NULL, NULL, "tun", tun);
             if (!tun->socket_id) goto fail2;
         }
     }