uasync: pass socket name to all add_socket call sites

lib/async_dns.c

@@ -251,7 +251,7 @@ static void adns_rearm(struct adns_query* q) {
         }
         q->cur_fd = -1;
         if (fd >= 0) {
-            q->socket_id = uasync_add_socket_t(q->ua, (socket_t)fd, adns_read_cb, adns_write_cb, NULL, q);
+            q->socket_id = uasync_add_socket_t(q->ua, (socket_t)fd, adns_read_cb, adns_write_cb, NULL, "dns_query", q);
             if (q->socket_id) q->cur_fd = fd;
             else DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: uasync_add_socket_t(%d) failed", fd);
         }

lib/tcp_io.c

@@ -79,7 +79,7 @@ struct tcp_conn* tcp_conn_create(
     queue_set_callback(tc->write_queue, write_queue_fetch_cb, tc);
     queue_set_waiter_defer(tc->write_queue, 1);
 
-    tc->socket_id = uasync_add_socket_t(ua, sock, read_cb, write_cb, error_cb, tc);
+    tc->socket_id = uasync_add_socket_t(ua, sock, read_cb, write_cb, error_cb, "tcp_io", tc);
     if (!tc->socket_id) {
         DEBUG_ERROR(DEBUG_CATEGORY_SOCKET, "tcp_conn_create: uasync_add_socket_t failed");
         queue_free(tc->read_queue);

net_emulator/net_emulator.c

@@ -425,7 +425,7 @@ int net_emulator_init(net_emulator_t *emulator) {
         ep->emulator = emulator;
         
         // Add socket to u_async
-        uasync_add_socket(emulator->ua, ep->sockfd, socket_callback, NULL, NULL, ep);
+        uasync_add_socket(emulator->ua, ep->sockfd, socket_callback, NULL, NULL, "emulator", ep);
         printf("[INIT] Listening on %s:%u\n",
                inet_ntoa(ep->listen_addr.sin_addr), ntohs(ep->listen_addr.sin_port));
     }

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;
         }
     }

tests/bench_uasync_timeouts.c

@@ -126,7 +126,7 @@ static void benchmark_with_sockets(void) {
         int flags = fcntl(sockets[i], F_GETFL, 0);
         fcntl(sockets[i], F_SETFL, flags | O_NONBLOCK);
         
-        socket_ids[i] = uasync_add_socket(ua, sockets[i], socket_callback, NULL, NULL, NULL);
+            socket_ids[i] = uasync_add_socket(ua, sockets[i], socket_callback, NULL, NULL, "bench", NULL);
         if (!socket_ids[i]) {
             fprintf(stderr, "Failed to add socket %d to uasync\n", i);
             for (int j = 0; j <= i; j++) {
@@ -259,7 +259,7 @@ int main(void) {
             sockets[i] = socket(AF_INET, SOCK_DGRAM, 0);
             int flags = fcntl(sockets[i], F_GETFL, 0);
             fcntl(sockets[i], F_SETFL, flags | O_NONBLOCK);
-            socket_ids[i] = uasync_add_socket(ua, sockets[i], socket_callback, NULL, NULL, NULL);
+        socket_ids[i] = uasync_add_socket(ua, sockets[i], socket_callback, NULL, NULL, "bench", NULL);
         }
         printf("Created %d sockets\n\n", NUM_SOCKETS);
 

tests/simple_test.c

@@ -24,7 +24,7 @@ int main() {
     int sock = socket(AF_INET, SOCK_DGRAM, 0);
     DEBUG_INFO(DEBUG_CATEGORY_SYS, "Created socket with fd=%d", sock);
     
-    void* id = uasync_add_socket(ua, sock, test_callback, NULL, NULL, NULL);
+    void* id = uasync_add_socket(ua, sock, test_callback, NULL, NULL, "test", NULL);
     DEBUG_INFO(DEBUG_CATEGORY_SYS, "Added socket: fd=%d, id=%p", sock, id);
     
     // Check if fd is still correct (internal struct socket_node not exposed)

tests/test_call_headless.c

@@ -259,7 +259,7 @@ static int hs_connect(struct hs_ctx* t, struct hs_conn* c, int port) {
         socket_close_wrapper(c->fd); c->fd = SOCKET_INVALID; return -1;
     }
     socket_set_nonblocking(c->fd);
-    c->socket_id = uasync_add_socket_t(t->ua, c->fd, hs_recv_cb, NULL, NULL, c);
+    c->socket_id = uasync_add_socket_t(t->ua, c->fd, hs_recv_cb, NULL, NULL, "test_call", c);
     if (!c->socket_id) { socket_close_wrapper(c->fd); c->fd = SOCKET_INVALID; return -1; }
     return 0;
 }

tests/test_dummynet.c

@@ -224,8 +224,8 @@ static int run_scenario(const char* name,
     }
     
     /* Добавляем сокеты в uasync */
-    uasync_add_socket_t(st.ua, st.sock_a, recv_callback_a, NULL, NULL, &st);
+    uasync_add_socket_t(st.ua, st.sock_a, recv_callback_a, NULL, NULL, "dummynet_a", &st);
-    uasync_add_socket_t(st.ua, st.sock_b, recv_callback_b, NULL, NULL, &st);
+    uasync_add_socket_t(st.ua, st.sock_b, recv_callback_b, NULL, NULL, "dummynet_b", &st);
     
     /* Создаем dummynet */
     st.dn = dummynet_create(st.ua, "127.0.0.1", LISTEN_PORT);

tests/test_radio_headless.c

@@ -251,7 +251,7 @@ static int hr_connect(struct hr_ctx* t, struct hr_conn* c, int port) {
         socket_close_wrapper(c->fd); c->fd = SOCKET_INVALID; return -1;
     }
     socket_set_nonblocking(c->fd);
-    c->socket_id = uasync_add_socket_t(t->ua, c->fd, hr_recv_cb, NULL, NULL, c);
+    c->socket_id = uasync_add_socket_t(t->ua, c->fd, hr_recv_cb, NULL, NULL, "test_radio", c);
     if (!c->socket_id) { socket_close_wrapper(c->fd); c->fd = SOCKET_INVALID; return -1; }
     return 0;
 }

tests/test_socks_client.c

@@ -98,7 +98,7 @@ static void mock_accept_cb(socket_t sock, void *arg) {
     m->conn_sock = accept(sock, (struct sockaddr *)&sa, &sl);
     if (m->conn_sock == SOCKET_INVALID) return;
     socket_set_nonblocking(m->conn_sock);
-    m->conn_id = uasync_add_socket_t(m->ua, m->conn_sock, mock_read_cb, NULL, NULL, m);
+    m->conn_id = uasync_add_socket_t(m->ua, m->conn_sock, mock_read_cb, NULL, NULL, "mock_conn", m);
 }
 
 static int mock_start(struct mock *m, struct UASYNC *ua, int port, uint8_t mode) {
@@ -112,7 +112,7 @@ static int mock_start(struct mock *m, struct UASYNC *ua, int port, uint8_t mode)
     a.sin_family = AF_INET; a.sin_addr.s_addr = htonl(INADDR_LOOPBACK); a.sin_port = htons((uint16_t)port);
     if (bind(m->listen_sock, (struct sockaddr *)&a, sizeof(a)) < 0) return -1;
     if (listen(m->listen_sock, 8) < 0) return -1;
-    m->listen_id = uasync_add_socket_t(ua, m->listen_sock, mock_accept_cb, NULL, NULL, m);
+    m->listen_id = uasync_add_socket_t(ua, m->listen_sock, mock_accept_cb, NULL, NULL, "mock_listen", m);
     return m->listen_id ? 0 : -1;
 }
 
@@ -200,7 +200,7 @@ static void umock_accept_cb(socket_t sock, void *arg) {
     m->ctrl_sock = cs;
     m->cstate = 0;
     m->cblen = 0;
-    m->ctrl_id = uasync_add_socket_t(m->ua, cs, umock_ctrl_read_cb, NULL, NULL, m);
+    m->ctrl_id = uasync_add_socket_t(m->ua, cs, umock_ctrl_read_cb, NULL, NULL, "umock_ctrl", m);
 }
 
 // Релей: принять обёрнутую датаграмму, сохранить dst (peer) + payload, отправить эхо с SRC=peer.
@@ -265,7 +265,7 @@ static int umock_start(struct udp_mock *m, struct UASYNC *ua, int listen_port) {
     a.sin_family = AF_INET; a.sin_addr.s_addr = htonl(INADDR_LOOPBACK); a.sin_port = htons((uint16_t)listen_port);
     if (bind(m->listen_sock, (struct sockaddr *)&a, sizeof(a)) < 0) return -1;
     if (listen(m->listen_sock, 8) < 0) return -1;
-    m->listen_id = uasync_add_socket_t(ua, m->listen_sock, umock_accept_cb, NULL, NULL, m);
+    m->listen_id = uasync_add_socket_t(ua, m->listen_sock, umock_accept_cb, NULL, NULL, "umock_listen", m);
 
     m->udp_sock = socket(AF_INET, SOCK_DGRAM, 0);
     if (m->udp_sock == SOCKET_INVALID) return -1;
@@ -276,7 +276,7 @@ static int umock_start(struct udp_mock *m, struct UASYNC *ua, int listen_port) {
     struct sockaddr_in got; socklen_t gl = sizeof(got);
     getsockname(m->udp_sock, (struct sockaddr *)&got, &gl);
     m->udp_port = ntohs(got.sin_port);
-    m->udp_id = uasync_add_socket_t(ua, m->udp_sock, umock_udp_read_cb, NULL, NULL, m);
+    m->udp_id = uasync_add_socket_t(ua, m->udp_sock, umock_udp_read_cb, NULL, NULL, "umock_udp", m);
     return (m->listen_id && m->udp_id) ? 0 : -1;
 }
 
@@ -332,7 +332,7 @@ static int test1_noauth_v4(void) {
     TASSERT(m.got_connect == 1);
 
     int got = 0;
-    void *sid = uasync_add_socket_t(ua, g_sock, read_echo_cb, NULL, NULL, &got);
+    void *sid = uasync_add_socket_t(ua, g_sock, read_echo_cb, NULL, NULL, "echo", &got);
     TASSERT(sid != NULL);
     uint8_t x = 'A';
     send(g_sock, &x, 1, 0);

tests/test_u_async_comprehensive.c

@@ -361,7 +361,7 @@ static void test_socket_management(void) {
         fcntl(sockets[i], F_SETFL, flags | O_NONBLOCK);
         
         /* Add to async */
-        socket_ids[i] = uasync_add_socket(ua, sockets[i], test_socket_callback, NULL, NULL, &ctx);
+        socket_ids[i] = uasync_add_socket(ua, sockets[i], test_socket_callback, NULL, NULL, "test", &ctx);
         ASSERT_NOT_NULL(socket_ids[i], "Failed to add socket to async");
     }
     
@@ -403,7 +403,7 @@ static void test_error_handling(void) {
     ASSERT_EQ(cancel_result, ERR_FAIL, "Should fail with NULL parameters");
     
     /* Test with invalid socket */
-    void* socket_result = uasync_add_socket(ua, -1, NULL, NULL, NULL, NULL);
+    void* socket_result = uasync_add_socket(ua, -1, NULL, NULL, NULL, "test_invalid", NULL);
     ASSERT_NULL(socket_result, "Should fail with invalid socket");
     
     /* Test callback that simulates errors */
@@ -465,7 +465,7 @@ static void test_concurrent_operations(void) {
     for (int i = 0; i < 2; i++) {
         int flags = fcntl(sockets[i], F_GETFL, 0);
         fcntl(sockets[i], F_SETFL, flags | O_NONBLOCK);
-        socket_ids[i] = uasync_add_socket(ua, sockets[i], test_socket_callback, NULL, NULL, &socket_ctx);
+        socket_ids[i] = uasync_add_socket(ua, sockets[i], test_socket_callback, NULL, NULL, "test", &socket_ctx);
         ASSERT_NOT_NULL(socket_ids[i], "Failed to add socket to async");
     }
     
@@ -569,7 +569,7 @@ static void test_socket_flags_toggle(void) {
     test_context_t read_ctx = {0};
     test_context_t write_ctx = {0};
 
-    void* s_id = uasync_add_socket(ua, sockets[0], test_socket_callback, NULL, NULL, &read_ctx);
+    void* s_id = uasync_add_socket(ua, sockets[0], test_socket_callback, NULL, NULL, "test", &read_ctx);
     ASSERT_NOT_NULL(s_id, "Failed to add socket");
 
     /* Write data — read callback should fire on sockets[0] */
@@ -597,7 +597,7 @@ static void test_socket_flags_toggle(void) {
     ASSERT_TRUE(read_ctx.callback_count > before_count, "Read callback should fire after re-enable");
 
     /* Test write flag toggle — socket is always writable (newly created), so write callback fires */
-    void* s_id2 = uasync_add_socket(ua, sockets[1], NULL, test_socket_callback, NULL, &write_ctx);
+    void* s_id2 = uasync_add_socket(ua, sockets[1], NULL, test_socket_callback, NULL, "test", &write_ctx);
     ASSERT_NOT_NULL(s_id2, "Failed to add socket for write test");
 
     uasync_poll(ua, 1);

tests/test_u_async_performance.c

@@ -89,7 +89,7 @@ static void test_socket_callback(int fd, void* arg) {
     uint64_t start_time = perf_get_time_us();
     int sockets_added = 0;
     for (int i = 0; i < num_sockets; i++) {
-        void* id = uasync_add_socket(ua, sockets[i], test_socket_callback, NULL, NULL, NULL);
+        void* id = uasync_add_socket(ua, sockets[i], test_socket_callback, NULL, NULL, "test", NULL);
         if (!id) {
             printf("Failed to add socket %d\n", i);
             printf("DEBUG: Only added %d sockets before failure\n", sockets_added);
@@ -184,7 +184,7 @@ static void benchmark_high_frequency(void) {
         int flags = fcntl(sockets[i], F_GETFL, 0);
         fcntl(sockets[i], F_SETFL, flags | O_NONBLOCK);
         
-        socket_ids[i] = uasync_add_socket(ua, sockets[i], test_socket_callback, NULL, NULL, NULL);
+        socket_ids[i] = uasync_add_socket(ua, sockets[i], test_socket_callback, NULL, NULL, "test", NULL);
     }
     
     /* Benchmark: Rapid add/remove cycles */
@@ -203,7 +203,7 @@ static void benchmark_high_frequency(void) {
         
         /* Add them back */
         for (int i = 0; i < num_sockets; i++) {
-            socket_ids[i] = uasync_add_socket(ua, sockets[i], test_socket_callback, NULL, NULL, NULL);
+            socket_ids[i] = uasync_add_socket(ua, sockets[i], test_socket_callback, NULL, NULL, "test", NULL);
         }
         
         /* Poll once per cycle */
@@ -246,7 +246,7 @@ static void benchmark_scalability(void) {
             int flags = fcntl(sockets[i], F_GETFL, 0);
             fcntl(sockets[i], F_SETFL, flags | O_NONBLOCK);
             
-            socket_ids[i] = uasync_add_socket(ua, sockets[i], test_socket_callback, NULL, NULL, NULL);
+            socket_ids[i] = uasync_add_socket(ua, sockets[i], test_socket_callback, NULL, NULL, "test", NULL);
         }
         
         /* Measure poll time */

tests/test_uasync_socket_race.c

@@ -138,7 +138,7 @@ int main(void) {
     la.sin_addr.s_addr = inet_addr("127.0.0.1");
     if (bind(lsock, (struct sockaddr*)&la, sizeof(la)) < 0) { printf("[FAIL] bind: %s\n", strerror(errno)); goto cleanup; }
     if (listen(lsock, 1024) < 0) { printf("[FAIL] listen: %s\n", strerror(errno)); goto cleanup; }
-    uasync_add_socket(g_ua, lsock, on_accept_cb, NULL, NULL, NULL);
+    uasync_add_socket(g_ua, lsock, on_accept_cb, NULL, NULL, "test_listen", NULL);
 
     for (int i = 0; i < CHILDREN; i++) {
         pid_t pid = fork();

tests/test_udp_proxy.c

@@ -172,7 +172,7 @@ int main(void) {
     struct sockaddr_in ea = {.sin_family = AF_INET, .sin_addr = {.s_addr = inet_addr("127.0.0.1")}, .sin_port = htons(UDP_ECHO_PORT)};
     if (bind(g_echo_sock, (struct sockaddr*)&ea, sizeof(ea)) < 0) { printf("[FAIL] echo bind: %s\n", strerror(errno)); goto done; }
     socket_set_nonblocking(g_echo_sock);
-    g_echo_id = uasync_add_socket_t(ua, g_echo_sock, udp_echo_cb, NULL, NULL, NULL);
+    g_echo_id = uasync_add_socket_t(ua, g_echo_sock, udp_echo_cb, NULL, NULL, "udp_echo", NULL);
 
     g_to_id = uasync_set_timeout(ua, 100, NULL, monitor, "mon");
     void* to_id = uasync_set_timeout(ua, TEST_TIMEOUT_MS * 10, NULL, test_timeout, "to");

tools/proxy/udp_proxy.c

@@ -76,7 +76,7 @@ static udp_flow_t* create_flow(proxy_context_t* ctx, struct sockaddr_in* client)
     baddr.sin_port = 0;
     bind((int)flow->backend_sock, (struct sockaddr*)&baddr, sizeof(baddr));
     
-    flow->socket_id = uasync_add_socket_t(ctx->ua, flow->backend_sock, backend_read_cb, NULL, NULL, ctx);
+    flow->socket_id = uasync_add_socket_t(ctx->ua, flow->backend_sock, backend_read_cb, NULL, NULL, "udp_backend", ctx);
     if (!flow->socket_id) {
         socket_close_wrapper(flow->backend_sock);
         u_free(flow);
@@ -202,7 +202,7 @@ int main(int argc, char* argv[]) {
                 DEBUG_ERROR(DEBUG_CATEGORY_SOCKET, "bind listen failed on %s:%d", ip, p);
                 return 1;
             }
-            ctx.listen_id = uasync_add_socket_t(ctx.ua, ctx.listen_sock, client_read_cb, NULL, NULL, &ctx);
+            ctx.listen_id = uasync_add_socket_t(ctx.ua, ctx.listen_sock, client_read_cb, NULL, NULL, "udp_listen", &ctx);
         } else if (strcmp(argv[i], "--target") == 0 && i+1 < argc) {
             char ip[64] = {0}; int port = 0;
             if (sscanf(argv[++i], "%63[^:]:%d", ip, &port) == 2) {