Build complete network JSON snapshots and verify SQL failure recovery
This commit is contained in:
1 parent
853cad67e8
commit
2fa2050187
3 files changed
+121
-189
No files matched your search
@@ -288,6 +288,27 @@ static int check_dm_submissions(const char* directory) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int deny_snapshot(void* target, int action, const char* table, const char* column, const char* db, const char* trigger) {
|
||||
(void)column; (void)db; (void)trigger;
|
||||
return action == SQLITE_READ && table && !strcmp(table, target) ? SQLITE_DENY : SQLITE_OK;
|
||||
}
|
||||
static int check_snapshot_errors(const char* channel) {
|
||||
sqlite3* db = instance->topo_sqlite_db;
|
||||
REQUIRE(sqlite3_set_authorizer(db, deny_snapshot, "channels") == SQLITE_OK);
|
||||
char* channels = utun_bridge_get_channels_json();
|
||||
REQUIRE(sqlite3_set_authorizer(db, NULL, NULL) == SQLITE_OK && !channels);
|
||||
char table[80]; msg_table_name(channel, table, sizeof(table));
|
||||
REQUIRE(sqlite3_set_authorizer(db, deny_snapshot, table) == SQLITE_OK);
|
||||
char* messages = utun_bridge_get_messages_json(channel, 10, NULL, 0);
|
||||
REQUIRE(sqlite3_set_authorizer(db, NULL, NULL) == SQLITE_OK && !messages);
|
||||
messages = utun_bridge_get_messages_json(channel, 10, NULL, 0);
|
||||
channels = utun_bridge_get_channels_json();
|
||||
REQUIRE(messages && !strcmp(messages, "[]") && channels && strcmp(channels, "[]"));
|
||||
u_free(messages); u_free(channels);
|
||||
printf("[PASS] Android snapshots: SQL denial returns failure, empty history stays valid, retry restores full snapshot\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
debug_config_init(); debug_set_level(DEBUG_LEVEL_WARN);
|
||||
char directory[512] = "/tmp/utun_android_replies_XXXXXX", config[1024], channel[64], hex[65];
|
||||
@@ -301,6 +322,7 @@ int main(void) {
|
||||
chat_core_create_channel_auto(instance, "Android replies");
|
||||
char* json = utun_bridge_get_channels_json();
|
||||
REQUIRE(!extract(json, "$[0].id", channel, sizeof(channel))); u_free(json);
|
||||
REQUIRE(!check_snapshot_errors(channel));
|
||||
REQUIRE(!check_addresses(channel));
|
||||
REQUIRE(!check_local_sockets());
|
||||
REQUIRE(!check_dm_submissions(directory));
|
||||
|
||||
@@ -335,22 +335,14 @@ void utun_bridge_connect_member_node(const char* channel_id, uint64_t node_id) {
|
||||
}
|
||||
|
||||
static char* json_escape_alloc(const char* str) {
|
||||
if (!str) return u_strdup("");
|
||||
size_t len = strlen(str), cap = len * 2 + 8;
|
||||
char* out = u_malloc(cap);
|
||||
if (!out) return u_strdup("");
|
||||
size_t pos = 0;
|
||||
for (size_t i = 0; i < len && pos < cap - 2; i++) {
|
||||
char c = str[i];
|
||||
if (c == '"' || c == '\\') { out[pos++] = '\\'; out[pos++] = c; }
|
||||
else if (c == '\n') { out[pos++] = '\\'; out[pos++] = 'n'; }
|
||||
else if (c == '\r') { out[pos++] = '\\'; out[pos++] = 'r'; }
|
||||
else if (c == '\t') { out[pos++] = '\\'; out[pos++] = 't'; }
|
||||
else if ((unsigned char)c < 32) { pos += snprintf(out + pos, cap - pos, "\\u%04x", (unsigned char)c); }
|
||||
else out[pos++] = c;
|
||||
struct strbuf out = strbuf_new();
|
||||
if (strbuf_add_json_string(&out, str ? str : "") < 0) {
|
||||
bridge_log(BLEV_ERROR, "JSON escaping allocation failed"); strbuf_free(&out); return NULL;
|
||||
}
|
||||
out[pos] = '\0';
|
||||
return out;
|
||||
char* result = strbuf_detach(&out);
|
||||
size_t size = strlen(result);
|
||||
memmove(result, result + 1, size - 2); result[size - 2] = 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
static void bridge_get_node_name(sqlite3* db, uint64_t node_id, const char* channel_id, char* out, size_t sz) {
|
||||
@@ -1071,60 +1063,56 @@ void utun_bridge_set_member_flags(const char* channel_id, uint64_t node_id,
|
||||
channel_id, (unsigned long long)node_id, admin, supernode, moder, storage_flag, verified, deleted);
|
||||
}
|
||||
|
||||
/* Рабочий снимок sockaddr; пустой AF_UNSPEC допустим до появления адреса/результата NAT. */
|
||||
static int bridge_address_parts(const struct sockaddr_storage* address, char* text, size_t size, int* family, int* port) {
|
||||
text[0] = 0; *family = 0; *port = 0;
|
||||
if (!address || !address->ss_family) return 0;
|
||||
const void* bytes;
|
||||
if (address->ss_family == AF_INET) {
|
||||
const struct sockaddr_in* value = (const struct sockaddr_in*)address;
|
||||
*family = 4; *port = ntohs(value->sin_port); bytes = &value->sin_addr;
|
||||
} else if (address->ss_family == AF_INET6) {
|
||||
const struct sockaddr_in6* value = (const struct sockaddr_in6*)address;
|
||||
*family = 6; *port = ntohs(value->sin6_port); bytes = &value->sin6_addr;
|
||||
} else {
|
||||
bridge_log(BLEV_ERROR, "Network snapshot: unsupported address family=%d", address->ss_family); return -1;
|
||||
}
|
||||
if (inet_ntop(address->ss_family, bytes, text, size)) return 0;
|
||||
bridge_log(BLEV_ERROR, "Network snapshot: inet_ntop failed family=%d errno=%d: %s", address->ss_family, errno, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
|
||||
char* utun_bridge_get_member_links_json(uint64_t node_id) {
|
||||
struct UTUN_INSTANCE* inst = instance_lite_get_instance();
|
||||
if (!inst || node_id == 0) return u_strdup("{}");
|
||||
|
||||
struct ETCP_CONN* conn = instance_find_conn(inst, node_id);
|
||||
if (!conn) return u_strdup("{}");
|
||||
|
||||
char buf[4096];
|
||||
int pos = snprintf(buf, sizeof(buf),
|
||||
"{\"cn\":true,\"in\":%s,\"lu\":%d,\"lk\":[",
|
||||
conn->initialized ? "true" : "false", conn->links_up);
|
||||
|
||||
int first = 1;
|
||||
for (struct ETCP_LINK* lk = conn->links; lk; lk = lk->next) {
|
||||
if (pos >= (int)sizeof(buf) - 100) break;
|
||||
|
||||
char la[INET6_ADDRSTRLEN] = ""; int lf = 0; uint16_t lp = 0;
|
||||
if (lk->conn) {
|
||||
const struct sockaddr_storage* lsa = lk->conn->interface_addr.ss_family ? &lk->conn->interface_addr : &lk->conn->local_addr;
|
||||
if (lsa->ss_family == AF_INET) {
|
||||
inet_ntop(AF_INET, &((struct sockaddr_in*)lsa)->sin_addr, la, sizeof(la)); lf = 4; lp = ntohs(((struct sockaddr_in*)lsa)->sin_port);
|
||||
} else if (lsa->ss_family == AF_INET6) {
|
||||
inet_ntop(AF_INET6, &((struct sockaddr_in6*)lsa)->sin6_addr, la, sizeof(la)); lf = 6; lp = ntohs(((struct sockaddr_in6*)lsa)->sin6_port);
|
||||
}
|
||||
} else if (lk->is_tcp && lk->tcp_link) {
|
||||
const struct sockaddr_storage* lsa = stcp_link_get_local_addr(lk->tcp_link);
|
||||
if (lsa && lsa->ss_family == AF_INET) {
|
||||
inet_ntop(AF_INET, &((struct sockaddr_in*)lsa)->sin_addr, la, sizeof(la)); lf = 4; lp = ntohs(((struct sockaddr_in*)lsa)->sin_port);
|
||||
} else if (lsa && lsa->ss_family == AF_INET6) {
|
||||
inet_ntop(AF_INET6, &((struct sockaddr_in6*)lsa)->sin6_addr, la, sizeof(la)); lf = 6; lp = ntohs(((struct sockaddr_in6*)lsa)->sin6_port);
|
||||
}
|
||||
}
|
||||
|
||||
char ra[INET6_ADDRSTRLEN] = ""; int rf = 0; uint16_t rp = 0;
|
||||
int st = lk->link_state, ls = lk->link_status;
|
||||
if (lk->is_tcp && lk->tcp_link && stcp_link_is_ready(lk->tcp_link)) { st = 3; ls = 1; }
|
||||
const struct sockaddr_storage* rsa = &lk->remote_addr;
|
||||
|
||||
if (rsa->ss_family == AF_INET) {
|
||||
inet_ntop(AF_INET, &((struct sockaddr_in*)rsa)->sin_addr, ra, sizeof(ra)); rf = 4; rp = ntohs(((struct sockaddr_in*)rsa)->sin_port);
|
||||
} else if (rsa->ss_family == AF_INET6) {
|
||||
inet_ntop(AF_INET6, &((struct sockaddr_in6*)rsa)->sin6_addr, ra, sizeof(ra)); rf = 6; rp = ntohs(((struct sockaddr_in6*)rsa)->sin6_port);
|
||||
}
|
||||
|
||||
const char* sep = first ? "" : ","; first = 0;
|
||||
const char* sn = lk->conn ? lk->conn->name : "";
|
||||
pos += snprintf(buf + pos, sizeof(buf) - (size_t)pos,
|
||||
"%s{\"id\":%d,\"pt\":\"%s\",\"lf\":%d,\"la\":\"%s\",\"lp\":%d,\"rf\":%d,\"ra\":\"%s\",\"rp\":%d,\"st\":%d,\"ls\":%d,\"is\":%d,\"sn\":\"%s\"}",
|
||||
sep, lk->local_link_id, lk->reality_set ? "TCP+REALITY" : (lk->is_tcp ? "TCP" : "UDP"), lf, la, (int)lp, rf, ra, (int)rp, st, ls, lk->is_server, sn);
|
||||
if (!inst || !node_id) { bridge_log(BLEV_WARN, "Member links snapshot: no core/node"); return NULL; }
|
||||
struct ETCP_CONN* connection = instance_find_conn(inst, node_id);
|
||||
if (!connection) return u_strdup("{}");
|
||||
struct strbuf out = strbuf_new();
|
||||
if (strbuf_addf(&out, "{\"cn\":true,\"in\":%s,\"lu\":%d,\"lk\":[",
|
||||
connection->initialized ? "true" : "false", connection->links_up) < 0) goto failed;
|
||||
unsigned count = 0;
|
||||
for (struct ETCP_LINK* link = connection->links; link; link = link->next) {
|
||||
const struct sockaddr_storage* local = NULL;
|
||||
if (link->conn) local = link->conn->interface_addr.ss_family ? &link->conn->interface_addr : &link->conn->local_addr;
|
||||
else if (link->is_tcp && link->tcp_link) local = stcp_link_get_local_addr(link->tcp_link);
|
||||
char local_text[INET6_ADDRSTRLEN], remote_text[INET6_ADDRSTRLEN];
|
||||
int local_family, local_port, remote_family, remote_port;
|
||||
if (bridge_address_parts(local, local_text, sizeof(local_text), &local_family, &local_port) ||
|
||||
bridge_address_parts(&link->remote_addr, remote_text, sizeof(remote_text), &remote_family, &remote_port)) goto failed;
|
||||
int state = link->link_state, status = link->link_status;
|
||||
if (link->is_tcp && link->tcp_link && stcp_link_is_ready(link->tcp_link)) { state = 3; status = 1; }
|
||||
if (strbuf_addf(&out, "%s{\"id\":%d,\"pt\":\"%s\",\"lf\":%d,\"la\":\"%s\",\"lp\":%d,"
|
||||
"\"rf\":%d,\"ra\":\"%s\",\"rp\":%d,\"st\":%d,\"ls\":%d,\"is\":%d,\"sn\":",
|
||||
count++ ? "," : "", link->local_link_id, link->reality_set ? "TCP+REALITY" : link->is_tcp ? "TCP" : "UDP",
|
||||
local_family, local_text, local_port, remote_family, remote_text, remote_port, state, status, link->is_server) < 0 ||
|
||||
strbuf_add_json_string(&out, link->conn ? link->conn->name : "") < 0 || strbuf_addf(&out, "}") < 0) goto failed;
|
||||
}
|
||||
if (pos < (int)sizeof(buf))
|
||||
pos += snprintf(buf + pos, sizeof(buf) - (size_t)pos, "]}");
|
||||
bridge_log(BLEV_INFO, "getMemberLinks node=0x%016llx → %s", (unsigned long long)node_id, buf);
|
||||
return u_strdup(buf);
|
||||
if (strbuf_addf(&out, "]}") < 0) goto failed;
|
||||
bridge_log(BLEV_DEBUG, "Member links snapshot node=%016llx count=%u", (unsigned long long)node_id, count);
|
||||
return strbuf_detach(&out);
|
||||
failed:
|
||||
bridge_log(BLEV_ERROR, "Member links snapshot failed node=%016llx", (unsigned long long)node_id);
|
||||
strbuf_free(&out); return NULL;
|
||||
}
|
||||
|
||||
/* ──────────────────────────────────────────────────────────────────
|
||||
@@ -1195,133 +1183,52 @@ void utun_bridge_set_sound_on_message(const char* channel_id, int on) {
|
||||
|
||||
#include "../../../lib/socket_compat.h"
|
||||
|
||||
static void bridge_count_socket_links(const struct ETCP_CONN* connection, const struct ETCP_SOCKET* socket, int* up, int* down) {
|
||||
if (!connection) return;
|
||||
for (const struct ETCP_LINK* link = connection->links; link; link = link->next) {
|
||||
if (link->conn != socket) continue;
|
||||
if (link->link_state == 3) (*up)++; else (*down)++;
|
||||
}
|
||||
}
|
||||
|
||||
char* utun_bridge_get_local_sockets_json(void) {
|
||||
struct UTUN_INSTANCE* inst = instance_lite_get_instance();
|
||||
if (!inst || !chat_core_is_initialized(inst)) return u_strdup("[]");
|
||||
|
||||
size_t cap = 4096, pos = 1;
|
||||
char* json = u_malloc(cap);
|
||||
if (!json) return u_strdup("[]");
|
||||
json[0] = '[';
|
||||
int first = 1;
|
||||
|
||||
bridge_log(BLEV_DEBUG, "local sockets snapshot: etcp_sockets=%p", (void*)inst->etcp_sockets);
|
||||
|
||||
/* Helper: count per-socket links_up / links_down */
|
||||
#define SOCK_COUNT_LINKS(_s, _lu, _ld) do { \
|
||||
int *_p_lu = &(_lu), *_p_ld = &(_ld); \
|
||||
*_p_lu = 0; *_p_ld = 0; \
|
||||
if (inst->connections) { \
|
||||
for (struct ll_entry* _e = inst->connections->head; _e; _e = _e->next) { \
|
||||
struct conn_queue_entry* _ce = (struct conn_queue_entry*)_e->data; \
|
||||
if (!_ce || !_ce->conn) continue; \
|
||||
for (struct ETCP_LINK* _lk = _ce->conn->links; _lk; _lk = _lk->next) { \
|
||||
if (_lk->conn != (_s)) continue; \
|
||||
if (_lk->link_state == 3) (*_p_lu)++; else (*_p_ld)++; \
|
||||
} \
|
||||
} \
|
||||
} \
|
||||
if (inst->tcp_connections) { \
|
||||
for (struct ll_entry* _e = inst->tcp_connections->head; _e; _e = _e->next) { \
|
||||
struct tcp_conn_entry* _te = (struct tcp_conn_entry*)_e->data; \
|
||||
if (!_te || !_te->etcp_conn) continue; \
|
||||
for (struct ETCP_LINK* _lk = _te->etcp_conn->links; _lk; _lk = _lk->next) { \
|
||||
if (_lk->conn != (_s)) continue; \
|
||||
if (_lk->link_state == 3) (*_p_lu)++; else (*_p_ld)++; \
|
||||
} \
|
||||
} \
|
||||
} \
|
||||
} while(0)
|
||||
|
||||
/* TCP sockets */
|
||||
{ struct ETCP_SOCKET* s = inst->etcp_sockets;
|
||||
while (s) {
|
||||
if (!s->is_tcp || s->probe_only) { s = s->next; continue; }
|
||||
char ip_str[INET6_ADDRSTRLEN] = ""; int port = 0;
|
||||
const struct sockaddr_storage* addr = s->interface_addr.ss_family ? &s->interface_addr : &s->local_addr;
|
||||
if (addr->ss_family == AF_INET) {
|
||||
struct sockaddr_in* sin = (struct sockaddr_in*)addr;
|
||||
port = ntohs(sin->sin_port);
|
||||
inet_ntop(AF_INET, &sin->sin_addr, ip_str, sizeof(ip_str));
|
||||
} else if (addr->ss_family == AF_INET6) {
|
||||
struct sockaddr_in6* sin6 = (struct sockaddr_in6*)addr;
|
||||
port = ntohs(sin6->sin6_port);
|
||||
inet_ntop(AF_INET6, &sin6->sin6_addr, ip_str, sizeof(ip_str));
|
||||
}
|
||||
int lu, ld; SOCK_COUNT_LINKS(s, lu, ld);
|
||||
int state = 2; /* bound and listening */
|
||||
const char* sep = first ? "" : ","; first = 0;
|
||||
const char* pn = s->reality_enabled ? "TCP+REALITY" : "TCP";
|
||||
char external[INET6_ADDRSTRLEN] = ""; int external_port = 0;
|
||||
if (s->nat_addr.ss_family == AF_INET) {
|
||||
const struct sockaddr_in* nat = (const struct sockaddr_in*)&s->nat_addr;
|
||||
inet_ntop(AF_INET, &nat->sin_addr, external, sizeof(external)); external_port = ntohs(nat->sin_port);
|
||||
} else if (s->nat_addr.ss_family == AF_INET6) {
|
||||
const struct sockaddr_in6* nat = (const struct sockaddr_in6*)&s->nat_addr;
|
||||
inet_ntop(AF_INET6, &nat->sin6_addr, external, sizeof(external)); external_port = ntohs(nat->sin6_port);
|
||||
}
|
||||
size_t needed = snprintf(NULL, 0,
|
||||
"%s{\"si\":%u,\"nm\":\"%s\",\"ad\":\"%s\",\"po\":%d,\"pt\":\"%s\",\"st\":%d,\"lu\":%d,\"ld\":%d,"
|
||||
"\"nmapping\":%u,\"ninbound\":%u,\"nsource\":%u,\"external\":\"%s\",\"externalPort\":%d}",
|
||||
sep, s->sock_id, s->name, ip_str, port, pn, state, lu, ld,
|
||||
s->address_profile.mapping, s->address_profile.inbound, s->address_profile.source, external, external_port);
|
||||
while (pos + needed + 2 > cap) { char* tmp = u_realloc(json, cap * 2); if (!tmp) break; json = tmp; cap *= 2; }
|
||||
if (pos + needed + 2 <= cap)
|
||||
pos += (size_t)snprintf(json + pos, cap - pos,
|
||||
"%s{\"si\":%u,\"nm\":\"%s\",\"ad\":\"%s\",\"po\":%d,\"pt\":\"%s\",\"st\":%d,\"lu\":%d,\"ld\":%d,"
|
||||
"\"nmapping\":%u,\"ninbound\":%u,\"nsource\":%u,\"external\":\"%s\",\"externalPort\":%d}",
|
||||
sep, s->sock_id, s->name, ip_str, port, pn, state, lu, ld,
|
||||
s->address_profile.mapping, s->address_profile.inbound, s->address_profile.source, external, external_port);
|
||||
s = s->next;
|
||||
}
|
||||
if (!inst || !chat_core_is_initialized(inst)) {
|
||||
bridge_log(BLEV_WARN, "Local sockets snapshot: core unavailable"); return NULL;
|
||||
}
|
||||
|
||||
/* UDP sockets */
|
||||
{ struct ETCP_SOCKET* es = inst->etcp_sockets;
|
||||
while (es) {
|
||||
if (es->is_tcp || es->probe_only) { es = es->next; continue; }
|
||||
char ip_str[INET6_ADDRSTRLEN] = ""; int port = 0;
|
||||
const struct sockaddr_storage* addr = es->interface_addr.ss_family ? &es->interface_addr : &es->local_addr;
|
||||
if (addr->ss_family == AF_INET) {
|
||||
struct sockaddr_in* sin = (struct sockaddr_in*)addr;
|
||||
port = ntohs(sin->sin_port);
|
||||
inet_ntop(AF_INET, &sin->sin_addr, ip_str, sizeof(ip_str));
|
||||
} else if (addr->ss_family == AF_INET6) {
|
||||
struct sockaddr_in6* sin6 = (struct sockaddr_in6*)addr;
|
||||
port = ntohs(sin6->sin6_port);
|
||||
inet_ntop(AF_INET6, &sin6->sin6_addr, ip_str, sizeof(ip_str));
|
||||
}
|
||||
int lu, ld; SOCK_COUNT_LINKS(es, lu, ld);
|
||||
int state = 2; /* bound and listening */
|
||||
const char* sep = first ? "" : ","; first = 0;
|
||||
char external[INET6_ADDRSTRLEN] = ""; int external_port = 0;
|
||||
if (es->nat_addr.ss_family == AF_INET) {
|
||||
const struct sockaddr_in* nat = (const struct sockaddr_in*)&es->nat_addr;
|
||||
inet_ntop(AF_INET, &nat->sin_addr, external, sizeof(external)); external_port = ntohs(nat->sin_port);
|
||||
} else if (es->nat_addr.ss_family == AF_INET6) {
|
||||
const struct sockaddr_in6* nat = (const struct sockaddr_in6*)&es->nat_addr;
|
||||
inet_ntop(AF_INET6, &nat->sin6_addr, external, sizeof(external)); external_port = ntohs(nat->sin6_port);
|
||||
}
|
||||
size_t needed = snprintf(NULL, 0,
|
||||
"%s{\"si\":%u,\"nm\":\"%s\",\"ad\":\"%s\",\"po\":%d,\"pt\":\"UDP\",\"st\":%d,\"lu\":%d,\"ld\":%d,"
|
||||
"\"nmapping\":%u,\"ninbound\":%u,\"nsource\":%u,\"external\":\"%s\",\"externalPort\":%d}",
|
||||
sep, es->sock_id, es->name, ip_str, port, state, lu, ld,
|
||||
es->address_profile.mapping, es->address_profile.inbound, es->address_profile.source, external, external_port);
|
||||
while (pos + needed + 2 > cap) { char* tmp = u_realloc(json, cap * 2); if (!tmp) break; json = tmp; cap *= 2; }
|
||||
if (pos + needed + 2 <= cap)
|
||||
pos += (size_t)snprintf(json + pos, cap - pos,
|
||||
"%s{\"si\":%u,\"nm\":\"%s\",\"ad\":\"%s\",\"po\":%d,\"pt\":\"UDP\",\"st\":%d,\"lu\":%d,\"ld\":%d,"
|
||||
"\"nmapping\":%u,\"ninbound\":%u,\"nsource\":%u,\"external\":\"%s\",\"externalPort\":%d}",
|
||||
sep, es->sock_id, es->name, ip_str, port, state, lu, ld,
|
||||
es->address_profile.mapping, es->address_profile.inbound, es->address_profile.source, external, external_port);
|
||||
es = es->next;
|
||||
}
|
||||
struct strbuf out = strbuf_new();
|
||||
if (strbuf_addf(&out, "[") < 0) goto failed;
|
||||
unsigned count = 0;
|
||||
for (struct ETCP_SOCKET* socket = inst->etcp_sockets; socket; socket = socket->next) {
|
||||
if (socket->probe_only) continue;
|
||||
const struct sockaddr_storage* local = socket->interface_addr.ss_family ? &socket->interface_addr : &socket->local_addr;
|
||||
char address[INET6_ADDRSTRLEN], external[INET6_ADDRSTRLEN];
|
||||
int family, port, external_family, external_port;
|
||||
if (bridge_address_parts(local, address, sizeof(address), &family, &port) ||
|
||||
bridge_address_parts(&socket->nat_addr, external, sizeof(external), &external_family, &external_port)) goto failed;
|
||||
int up = 0, down = 0;
|
||||
if (inst->connections) for (struct ll_entry* entry = inst->connections->head; entry; entry = entry->next) {
|
||||
struct conn_queue_entry* value = entry->data;
|
||||
if (value) bridge_count_socket_links(value->conn, socket, &up, &down);
|
||||
}
|
||||
if (inst->tcp_connections) for (struct ll_entry* entry = inst->tcp_connections->head; entry; entry = entry->next) {
|
||||
struct tcp_conn_entry* value = entry->data;
|
||||
if (value) bridge_count_socket_links(value->etcp_conn, socket, &up, &down);
|
||||
}
|
||||
const char* protocol = socket->is_tcp ? socket->reality_enabled ? "TCP+REALITY" : "TCP" : "UDP";
|
||||
if (strbuf_addf(&out, "%s{\"si\":%u,\"nm\":", count++ ? "," : "", socket->sock_id) < 0 ||
|
||||
strbuf_add_json_string(&out, socket->name) < 0 ||
|
||||
strbuf_addf(&out, ",\"ad\":\"%s\",\"po\":%d,\"pt\":\"%s\",\"st\":2,\"lu\":%d,\"ld\":%d,"
|
||||
"\"nmapping\":%u,\"ninbound\":%u,\"nsource\":%u,\"external\":\"%s\",\"externalPort\":%d}",
|
||||
address, port, protocol, up, down, socket->address_profile.mapping, socket->address_profile.inbound,
|
||||
socket->address_profile.source, external, external_port) < 0) goto failed;
|
||||
}
|
||||
|
||||
#undef SOCK_COUNT_LINKS
|
||||
|
||||
json[pos++] = ']'; json[pos] = '\0';
|
||||
return json;
|
||||
if (strbuf_addf(&out, "]") < 0) goto failed;
|
||||
bridge_log(BLEV_DEBUG, "Local sockets snapshot count=%u", count);
|
||||
return strbuf_detach(&out);
|
||||
failed:
|
||||
bridge_log(BLEV_ERROR, "Local sockets snapshot failed; previous snapshot retained");
|
||||
strbuf_free(&out); return NULL;
|
||||
}
|
||||
|
||||
static void bridge_network_change_run(void* unused) {
|
||||
|
||||
@@ -8,3 +8,6 @@ C99-компилятор, OpenSSL headers и JDK с javac/libjvm. Телефон
|
||||
кавычки и перевод строки. Проверяются отказ выделения C-буфера с повтором, отклонение
|
||||
внутреннего NUL, пустая строка, NULL и сохранение уже ожидающего Java exception.
|
||||
JVM проверяет корректность вызовов JNI; ART и Android SDK этим тестом не запускаются.
|
||||
Тот же запуск проверяет регистрацию/замену настоящего Java event callback, доставку payload,
|
||||
исключение обработчика с последующей успешной доставкой и сохранение чужого pending exception.
|
||||
Gradle запускает проверку как `:app:testJniUtf8` перед `:app:testDebugUnitTest` на Linux.
|
||||
Reference in new issue
Block a user