Build complete network JSON snapshots and verify SQL failure recovery

This commit is contained in:
evgeny committed 2026-10-29 13:35:41 +01:00
1 parent 853cad67e8
commit 2fa2050187
3 files changed
+121 -189

No files matched your search

+22
View File
@@ -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.