Files
utun2/src/routing_layer/nat_detection.c
T

1361 lines
84 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/* NAT-детектор владельца endpoint. Один раунд на рабочий сокет:
* S->B observation, B->C ingress(S), S->C/C-alt observations, S->B repeat.
* Команды к C проходят через B: контроль не открывает фильтр S->C. */
#include "nat_detection.h"
#include <stdio.h>
#include <string.h>
#include "utun_instance.h"
#include "config_parser.h"
#include "etcp_api.h"
#include "etcp.h"
#include "etcp_connections.h"
#include "route_ping.h"
#include "topo_node.h"
#include "topo_group.h"
#include "etcp_router.h"
#include "route_crypto.h"
#include "stcp_client.h"
#include "stun_nat.h"
#include "../lib/debug_config.h"
#include "../lib/mem.h"
#include "../lib/u_async.h"
#define NAT_WIRE_VERSION 3
#define NAT_MAX_BINDINGS 128
#define NAT_MAX_PROBES 64
#define NAT_MAX_CONTACTS 256
#define NAT_TICK_TB 1000
#define NAT_ROUND_TB 300000
#define NAT_REFRESH_TB 18000000
#define NAT_RETRY_TB 300000
#define NAT_PROBE_COUNT 3
#define NAT_QUERY_TAG_SIZE (ROUTE_OBSERVE_TAG_SIZE + 9)
enum nat_command { NAT_RUN = 1, NAT_RESULT };
enum nat_phase { NAT_IDLE, NAT_OBSERVE_B, NAT_PREPARE_C, NAT_PRE, NAT_OBSERVE_C, NAT_PREPARE_ALT,
NAT_OBSERVE_ALT, NAT_POST, NAT_REPEAT_B, NAT_TCP };
enum nat_step { NAT_STEP_PREPARE = 1, NAT_STEP_PRE, NAT_STEP_ALT, NAT_STEP_POST, NAT_STEP_TCP };
/* Только байты: формат независим от alignment/endian платформы. */
struct nat_wire {
uint8_t cmd, command, version, owner_socket, helper_socket, step, reason, sent, received, errors;
uint8_t owner[8], generation[8], round[8], token[8], observer[8], helper[8], timeout_ms[2];
uint8_t target[ROUTE_ADDR_WIRE_SIZE], primary[ROUTE_ADDR_WIRE_SIZE], secondary[ROUTE_ADDR_WIRE_SIZE];
uint8_t observer_address[ROUTE_ADDR_WIRE_SIZE];
};
struct nat_pair { uint64_t group, observer, helper; };
struct nat_socket {
struct nat_socket *next;
struct NAT_DETECTION *detector;
struct ETCP_SOCKET *socket, *helper_primary, *auxiliary;
struct sockaddr_storage local, observer_address, helper_address, alternate_address;
struct sockaddr_storage baseline, helper_seen, alternate_seen;
struct sockaddr_storage measured_address;
struct address_profile measured_profile;
uint64_t select_due, available_fingerprint, reservation_fingerprint, cold_until;
uint8_t fallback_allowed;
uint8_t observer_key[32], helper_key[32];
uint64_t group_id, round, observer, helper, token, deadline, due, completed_tb, preferred_observer;
struct nat_pair cursor, fallback;
uint8_t contacts[NAT_MAX_CONTACTS][17];
unsigned contact_count, phase, reason, retries;
uint8_t history_loaded, history_complete, history_incomplete, filter_clean, pre_received, post_received, pre_healthy;
uint8_t helper_socket, active_ping, forced, cycling, using_fallback, prefer_fresh;
uint32_t rounds, helper_reselections;
};
struct nat_binding {
struct nat_binding *next;
uint64_t group_id, owner, generation, round, expires, helper, token;
uint8_t owner_socket, owner_key[32];
struct sockaddr_storage target;
};
struct nat_probe {
struct nat_probe *next;
struct NAT_DETECTION *detector;
struct nat_wire message;
uint64_t group_id, reply, source_generation, io_generation, due, expires;
uint8_t owner_key[32], observer_key[32];
uint8_t source_socket, io_socket, active, cancelled, alternate_fallback;
struct stcp_client *tcp;
};
struct NAT_DETECTION {
struct UTUN_INSTANCE *instance;
struct nat_socket *sockets;
struct nat_binding *bindings;
struct nat_probe *probes;
void *timer;
void *topology_wake;
uint64_t publish_after;
uint8_t allow_local, stopping, history_table_ready, automatic, publish_pending, reservation_dirty;
};
static void owner_ping_cb(int, uint16_t, void *, uint64_t, const uint8_t *, size_t);
static void helper_ping_cb(int, uint16_t, void *, uint64_t, const uint8_t *, size_t);
static void detector_tick(void *);
static int owner_observe(struct nat_socket *);
static int owner_run(struct nat_socket *, uint8_t);
static void owner_finish(struct nat_socket *, uint8_t);
static void helper_remove(struct nat_probe *);
static int helper_send(struct nat_probe *);
static void owner_start(struct nat_socket *);
static int contacted(struct nat_socket *, const struct sockaddr_storage *);
static uint64_t read64(const uint8_t *data) {
uint64_t value = 0;
for (unsigned i = 0; i < 8; i++) value = (value << 8) | data[i];
return value;
}
static void write64(uint8_t *data, uint64_t value) {
for (unsigned i = 0; i < 8; i++) data[i] = (uint8_t)(value >> (56 - i * 8));
}
static int random_id(uint64_t *value) {
do {
if (random_bytes((uint8_t *)value, sizeof(*value))) {
DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT round/token RNG failed"); return -1;
}
} while (!*value);
return 0;
}
const char *nat_check_reason_name(uint8_t reason) {
static const char *const names[] = {"none", "no_observer", "no_helper", "control_lost", "send_error", "timeout",
"address_changed", "contact_history", "proxy", "no_listener", "cancelled", "invalid_observation", "dependent_mapping"};
return reason < sizeof(names) / sizeof(names[0]) ? names[reason] : "invalid_reason";
}
static struct ETCP_SOCKET *find_socket(struct NAT_DETECTION *detector, uint8_t id, uint64_t generation) {
for (struct ETCP_SOCKET *socket = detector->instance->etcp_sockets; socket; socket = socket->next)
if (socket->sock_id == id && (!generation || socket->generation == generation)) return socket;
return NULL;
}
static int public_address(struct NAT_DETECTION *detector, const struct sockaddr_storage *address) {
if (address->ss_family == AF_INET) {
uint32_t ip = ((const struct sockaddr_in *)address)->sin_addr.s_addr;
return ip && (ip_is_public(ip) || detector->allow_local);
}
if (address->ss_family == AF_INET6) {
const uint8_t *ip = ((const struct sockaddr_in6 *)address)->sin6_addr.s6_addr;
return (ip[0] & 0xe0) == 0x20 || (detector->allow_local && !memcmp(ip, &in6addr_loopback, 16));
}
return 0;
}
/* Подписанная идентичность участника выбранной группы; сохранённый bootstrap не разрешает управление. */
static const struct TOPO_NODE *group_node(struct NAT_DETECTION *detector, uint64_t group_id, uint64_t node_id) {
struct TOPO_GROUP *group = topo_groups_find(detector->instance->topo_groups, group_id);
if (!group || group->stopping || (node_id != detector->instance->node_id && !topo_node_find_by_id(group, node_id))) return NULL;
const struct TOPO_NODE *node = topo_node_registry_find(detector->instance->topo_groups, node_id);
return node && node->timestamp ? node : NULL;
}
/* Управление допускает транзит и TCP, но следующий хоп должен завершить согласование этой группы. */
static int control_route(struct NAT_DETECTION *detector, uint64_t group_id, uint64_t node_id) {
if (!group_node(detector, group_id, node_id)) return 0;
struct ETCP_ROUTER_PATH path = etcp_router_get_path(detector->instance, group_id, node_id, ETCP_RT_ID_NAT_DETECTION);
struct TOPO_GROUP *group = topo_groups_find(detector->instance->topo_groups, group_id);
return path.type != CONN_TYPE_NONE && topo_group_peer_ready(group, path.next_hop_node_id);
}
/* Выбирает сокет по NODEINFO. Помощнику разрешён приватный endpoint: его mapping измеряется перед ingress. */
static int node_udp_endpoint(struct NAT_DETECTION *detector, const struct TOPO_NODE *node, int family, int allow_private,
struct sockaddr_storage *address, uint8_t *socket_id) {
int best = 4;
for (const struct TOPO_ADDR4 *a = family == AF_INET ? node->v4_addrs : NULL; a; a = a->next) {
if (!(a->protocol & TOPO_PROTO_UDP) || !a->port) continue;
const struct TOPO_SOCKMETA4 *meta = node->v4_sock_meta;
while (meta && meta->id != a->socket_id) meta = meta->next;
if (meta && (meta->config_type == CFG_SERVER_TYPE_PRIVATE || meta->config_type == CFG_SERVER_TYPE_LOCAL)) continue;
struct sockaddr_storage candidate = {0}; struct sockaddr_in *v4 = (struct sockaddr_in *)&candidate;
v4->sin_family = AF_INET; memcpy(&v4->sin_addr, a->addr, 4); v4->sin_port = htons(a->port);
int rank = public_address(detector, &candidate) ? 0 : 2;
if ((!allow_private && rank) || rank > best || (rank == best && a->socket_id >= *socket_id)) continue;
best = rank; *address = candidate; *socket_id = a->socket_id;
}
for (const struct TOPO_ADDR6 *a = family == AF_INET6 ? node->v6_addrs : NULL; a; a = a->next) {
if (!(a->protocol & TOPO_PROTO_UDP) || !a->port) continue;
const struct TOPO_SOCKMETA6 *meta = node->v6_sock_meta;
while (meta && meta->id != a->socket_id) meta = meta->next;
if (meta && (meta->config_type == CFG_SERVER_TYPE_PRIVATE || meta->config_type == CFG_SERVER_TYPE_LOCAL)) continue;
struct sockaddr_storage candidate = {0}; struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)&candidate;
v6->sin6_family = AF_INET6; memcpy(&v6->sin6_addr, a->addr, 16); v6->sin6_port = htons(a->port);
int rank = public_address(detector, &candidate) ? 0 : 2;
if ((!allow_private && rank) || rank > best || (rank == best && a->socket_id >= *socket_id)) continue;
best = rank; *address = candidate; *socket_id = a->socket_id;
}
/* Наблюдаемый адрес уже работающего UDP помогает bootstrap за NAT; прямой линк не является условием отбора. */
struct ETCP_CONN *connection = instance_find_conn(detector->instance, node->node_id);
for (struct ETCP_LINK *link = connection ? connection->links : NULL; link; link = link->next) {
if (link->is_tcp || !link->initialized || !link->link_status || link->remote_only_local ||
link->remote_addr.ss_family != family || !public_address(detector, &link->remote_addr)) continue;
if (best == 0) break;
*address = link->remote_addr; *socket_id = link->remote_socket_id; best = 1; break;
}
return best < 4;
}
static int pair_after(struct nat_pair a, struct nat_pair b) {
if (a.group != b.group) return a.group > b.group;
if (a.observer != b.observer) return a.observer > b.observer;
return a.helper > b.helper;
}
/* Обходит пары всех групп без ограничения числа узлов и без хранения указателей на топологию. */
static int select_pair(struct nat_socket *state) {
struct NAT_DETECTION *detector = state->detector;
struct nat_pair best = {0};
struct sockaddr_storage observer_address = {0}, helper_address = {0};
uint8_t observer_key[32] = {0}, helper_key[32] = {0}, helper_socket = 0;
unsigned observers = 0, groups = 0;
for (struct ll_entry *e = detector->instance->topo_groups->group_list->head; e; e = e->next) {
struct TOPO_GROUP *group = (struct TOPO_GROUP *)e;
if (group->stopping || !group->local_node) continue;
groups++;
for (struct ll_entry *b = group->nodes->head; b; b = b->next) {
uint64_t observer = ((struct TOPO_GROUP_NODE *)b)->node_id;
if (observer == detector->instance->node_id || (state->preferred_observer && observer != state->preferred_observer) ||
!control_route(detector, group->group_id, observer)) continue;
const struct TOPO_NODE *bn = group_node(detector, group->group_id, observer);
struct sockaddr_storage ba = {0}; uint8_t bs = 0;
if (!state->socket->is_tcp && !node_udp_endpoint(detector, bn, state->local.ss_family, 0, &ba, &bs)) continue;
observers++;
for (struct ll_entry *c = state->socket->is_tcp ? b : group->nodes->head; c; c = state->socket->is_tcp ? NULL : c->next) {
uint64_t helper = ((struct TOPO_GROUP_NODE *)c)->node_id;
if (helper == detector->instance->node_id || (!state->socket->is_tcp && helper == observer) ||
!control_route(detector, group->group_id, helper)) continue;
const struct TOPO_NODE *cn = group_node(detector, group->group_id, helper);
struct sockaddr_storage ca = {0}; uint8_t cs = 0;
if (!state->socket->is_tcp && !node_udp_endpoint(detector, cn, state->local.ss_family, 1, &ca, &cs)) continue;
if (!state->socket->is_tcp && state->prefer_fresh && !state->using_fallback && contacted(state, &ca)) continue;
struct nat_pair candidate = {group->group_id, observer, helper};
if (state->using_fallback) {
if (memcmp(&candidate, &state->fallback, sizeof(candidate))) continue;
} else if (!pair_after(candidate, state->cursor)) continue;
if (best.group && !pair_after(best, candidate)) continue;
best = candidate; observer_address = ba; helper_address = ca; helper_socket = cs;
memcpy(observer_key, bn->public_key, 32); memcpy(helper_key, cn->public_key, 32);
}
}
}
if (!best.group) {
if (state->prefer_fresh && !state->using_fallback) {
state->prefer_fresh = 0; state->cursor = (struct nat_pair){0}; return select_pair(state);
}
if (!state->using_fallback && state->fallback.group) { state->using_fallback = 1; return select_pair(state); }
state->reason = observers ? NAT_REASON_NO_HELPER : NAT_REASON_NO_OBSERVER;
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT candidate cycle exhausted socket=%s groups=%u observers=%u reason=%s",
state->socket->name, groups, observers, nat_check_reason_name(state->reason));
return -1;
}
if (!state->using_fallback) state->cursor = best;
state->group_id = best.group; state->observer = best.observer; state->helper = best.helper;
state->observer_address = observer_address; state->helper_address = helper_address; state->helper_socket = helper_socket;
memcpy(state->observer_key, observer_key, 32); memcpy(state->helper_key, helper_key, 32);
DEBUG_INFO(DEBUG_CATEGORY_NAT, "NAT candidates socket=%s group=%016llx observer=%016llx endpoint=%s helper=%016llx candidate=%s fallback=%u",
state->socket->name, (unsigned long long)best.group, (unsigned long long)best.observer,
sockaddr_storage_to_str(&observer_address).str, (unsigned long long)best.helper,
sockaddr_storage_to_str(&helper_address).str, state->using_fallback);
return 0;
}
static void publish(struct NAT_DETECTION *detector) {
if (detector->stopping || !detector->instance->topo_groups) return;
detector->publish_pending = topo_node_update_my_addresses(detector->instance) < 0;
if (detector->publish_pending) detector->publish_after = get_time_tb() + 10000;
if (detector->publish_pending) DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT profile publication failed; retry scheduled");
}
static struct nat_socket *socket_state(struct NAT_DETECTION *detector, struct ETCP_SOCKET *socket, int create) {
if (!detector || !socket || socket->probe_only || detector->stopping) return NULL;
for (struct nat_socket *state = detector->sockets; state; state = state->next)
if (state->socket == socket) return state;
if (!create) return NULL;
struct nat_socket *state = u_calloc(1, sizeof(*state));
if (!state) { DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT endpoint state allocation failed socket=%s", socket->name); return NULL; }
state->detector = detector; state->socket = socket; state->local = socket->local_addr;
if (socket->is_tcp) state->local = socket->interface_addr;
state->due = get_time_tb() + 2500;
state->cold_until = state->due + NAT_ROUND_TB;
state->next = detector->sockets; detector->sockets = state;
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT endpoint created socket=%s id=%u generation=%016llx protocol=%s local=%s",
socket->name, socket->sock_id, (unsigned long long)socket->generation,
socket->is_tcp ? "TCP" : "UDP", sockaddr_storage_to_str(&state->local).str);
return state;
}
/* История сохраняется один раз на новый IP. Перезапуск на том же IP:port её не очищает. */
static int history_table(struct NAT_DETECTION *detector) {
if (detector->history_table_ready) return 0;
sqlite3 *db = detector->instance->topo_sqlite_db;
if (!db) return -1;
if (sqlite3_exec(db, "CREATE TABLE IF NOT EXISTS nat_contacts(local BLOB NOT NULL,remote BLOB NOT NULL,"
"PRIMARY KEY(local,remote)) WITHOUT ROWID", NULL, NULL, NULL) != SQLITE_OK) {
DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT contact history initialization failed: %s", sqlite3_errmsg(db)); return -1;
}
detector->history_table_ready = 1; return 0;
}
static int history_insert(struct nat_socket *state, const uint8_t remote[17]) {
uint8_t local[ROUTE_ADDR_WIRE_SIZE];
if (route_ping_addr_encode(local, &state->local) || history_table(state->detector)) return -1;
sqlite3_stmt *statement = NULL;
sqlite3 *db = state->detector->instance->topo_sqlite_db;
if (sqlite3_prepare_v2(db, "INSERT OR IGNORE INTO nat_contacts(local,remote) VALUES(?,?)",
-1, &statement, NULL) != SQLITE_OK) {
DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT contact write failed: %s", sqlite3_errmsg(db)); return -1;
}
sqlite3_bind_blob(statement, 1, local, sizeof(local), SQLITE_TRANSIENT);
sqlite3_bind_blob(statement, 2, remote, 17, SQLITE_TRANSIENT);
int result = sqlite3_step(statement); sqlite3_finalize(statement);
if (result != SQLITE_DONE) { DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT contact insert failed: %s", sqlite3_errmsg(db)); return -1; }
return 0;
}
static void history_mark_incomplete(struct nat_socket *state) {
static const uint8_t marker[17];
state->history_complete = 0; state->history_incomplete = 1;
/* family=0 — постоянный маркер неполной истории, не адрес помощника. */
if (history_insert(state, marker)) DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT incomplete history marker persistence failed");
}
static void history_load(struct nat_socket *state) {
if (state->history_loaded || state->socket->is_tcp) return;
struct NAT_DETECTION *detector = state->detector;
if (history_table(detector)) { state->history_complete = 0; return; }
uint8_t local[ROUTE_ADDR_WIRE_SIZE];
if (route_ping_addr_encode(local, &state->local)) return;
sqlite3_stmt *statement = NULL;
sqlite3 *db = detector->instance->topo_sqlite_db;
if (sqlite3_prepare_v2(db, "SELECT remote FROM nat_contacts WHERE local=?", -1, &statement, NULL) != SQLITE_OK) {
DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT history read failed: %s", sqlite3_errmsg(db)); return;
}
sqlite3_bind_blob(statement, 1, local, sizeof(local), SQLITE_TRANSIENT);
state->history_complete = !state->history_incomplete;
int result;
while ((result = sqlite3_step(statement)) == SQLITE_ROW) {
const uint8_t *remote = sqlite3_column_blob(statement, 0);
if (!remote || sqlite3_column_bytes(statement, 0) != 17 || (remote[0] != 4 && remote[0] != 6)) {
state->history_incomplete = 1; state->history_complete = 0; continue;
}
unsigned index;
for (index = 0; index < state->contact_count; index++) if (!memcmp(state->contacts[index], remote, 17)) break;
if (index < state->contact_count) continue;
if (state->contact_count == NAT_MAX_CONTACTS) { state->history_incomplete = 1; state->history_complete = 0; continue; }
memcpy(state->contacts[state->contact_count++], remote, 17);
}
if (result != SQLITE_DONE) {
state->history_complete = 0;
DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT history query failed: %s", sqlite3_errmsg(db));
}
sqlite3_finalize(statement); state->history_loaded = 1;
/* Сохраняем также отправки, которые случились до открытия общей SQLite. */
for (unsigned i = 0; i < state->contact_count; i++)
if (history_insert(state, state->contacts[i])) { history_mark_incomplete(state); break; }
if (state->history_incomplete) history_mark_incomplete(state);
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT history loaded socket=%s contacts=%u complete=%u",
state->socket->name, state->contact_count, state->history_complete);
}
static int contacted(struct nat_socket *state, const struct sockaddr_storage *address) {
uint8_t remote[ROUTE_ADDR_WIRE_SIZE];
if (!state->history_complete || route_ping_addr_encode(remote, address)) return 1;
for (unsigned i = 0; i < state->contact_count; i++) if (!memcmp(state->contacts[i], remote, 17)) return 1;
return 0;
}
void nat_detection_note_send(struct NAT_DETECTION *detector, struct ETCP_SOCKET *socket,
const struct sockaddr_storage *destination) {
if (!detector || !socket || socket->is_tcp || socket->probe_only || socket->socks_udp || detector->stopping) return;
struct nat_socket *state = socket_state(detector, socket, 1);
if (!state) return;
history_load(state);
if (state->phase == NAT_PRE && !state->pre_received &&
route_ping_addr_equal(destination, &state->helper_address, 0)) {
state->filter_clean = 0;
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT ingress contaminated by outgoing UDP socket=%s round=%016llx destination=%s",
socket->name, (unsigned long long)state->round, sockaddr_storage_to_str(destination).str);
}
uint8_t local[ROUTE_ADDR_WIRE_SIZE], remote[ROUTE_ADDR_WIRE_SIZE];
if (route_ping_addr_encode(local, &state->local) || route_ping_addr_encode(remote, destination)) return;
for (unsigned i = 0; i < state->contact_count; i++) if (!memcmp(state->contacts[i], remote, 17)) return;
if (state->contact_count == NAT_MAX_CONTACTS) {
if (state->history_complete) DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT contact history full socket=%s", socket->name);
if (!state->history_incomplete) history_mark_incomplete(state);
return;
}
memcpy(state->contacts[state->contact_count++], remote, 17);
if (!state->history_loaded || !detector->instance->topo_sqlite_db) { state->history_complete = 0; return; }
if (history_insert(state, remote)) history_mark_incomplete(state);
}
static int send_control(struct NAT_DETECTION *detector, uint64_t group_id, uint64_t destination, struct nat_wire *message) {
if (!control_route(detector, group_id, destination)) {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT control route unavailable group=%016llx peer=%016llx",
(unsigned long long)group_id, (unsigned long long)destination); return -1;
}
struct ll_entry *entry = queue_entry_new(0);
if (!entry) { DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT control queue allocation failed"); return -1; }
entry->dgram = u_malloc(1 + sizeof(*message));
if (!entry->dgram) { queue_entry_free(entry); DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT control allocation failed"); return -1; }
message->cmd = ETCP_RT_ID_NAT_DETECTION; message->version = NAT_WIRE_VERSION;
entry->dgram[0] = ETCP_RT_ID_NAT_DETECTION;
memcpy(entry->dgram + 1, message, sizeof(*message)); entry->len = 1 + sizeof(*message);
if (etcp_route_send(detector->instance, group_id, destination, entry, 0, ROUTE_CRYPTO_SIGN | ROUTE_CRYPTO_ENCRYPT)) {
DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT control send failed group=%016llx peer=%016llx command=%u",
(unsigned long long)group_id, (unsigned long long)destination, message->command); return -1;
}
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT control TX group=%016llx command=%u step=%u peer=%016llx owner=%016llx round=%016llx helper=%016llx",
(unsigned long long)group_id, message->command, message->step, (unsigned long long)destination,
(unsigned long long)read64(message->owner), (unsigned long long)read64(message->round),
(unsigned long long)read64(message->helper));
return 0;
}
static int make_message(struct nat_socket *state, struct nat_wire *message, uint8_t command) {
memset(message, 0, sizeof(*message)); message->command = command;
message->owner_socket = state->socket->sock_id; message->helper_socket = state->helper_socket;
write64(message->owner, state->detector->instance->node_id);
write64(message->generation, state->socket->generation); write64(message->round, state->round);
write64(message->helper, state->helper); write64(message->observer, state->observer); write64(message->token, state->token);
if (route_ping_addr_encode(message->target, state->socket->is_tcp ? &state->local : &state->baseline)) return -1;
if (state->helper_address.ss_family && route_ping_addr_encode(message->primary, &state->helper_address)) return -1;
if (state->observer_address.ss_family && route_ping_addr_encode(message->observer_address, &state->observer_address)) return -1;
int timeout = 1000;
struct ETCP_CONN *observer = topo_group_find_conn_for_node(
topo_groups_find(state->detector->instance->topo_groups, state->group_id), state->observer);
for (struct ETCP_LINK *link = observer ? observer->links : NULL; link; link = link->next)
if (link->rtt_last / 10 * 4 > timeout) timeout = link->rtt_last / 10 * 4;
if (timeout > 3000) timeout = 3000;
message->timeout_ms[0] = timeout >> 8; message->timeout_ms[1] = timeout;
return 0;
}
static struct nat_binding *binding_find(struct NAT_DETECTION *detector, uint64_t group_id, uint64_t owner,
uint64_t generation, uint64_t round) {
for (struct nat_binding *binding = detector->bindings; binding; binding = binding->next)
if (binding->group_id == group_id && binding->owner == owner && binding->generation == generation && binding->round == round &&
binding->expires > get_time_tb()) return binding;
return NULL;
}
void nat_detection_record_observation(struct NAT_DETECTION *detector, struct ETCP_SOCKET *socket,
const uint8_t peer_key[32], const struct sockaddr_storage *source,
const uint8_t *tag, size_t length) {
if (!detector || detector->stopping) return;
if (!socket || socket->socks_udp || length != ROUTE_OBSERVE_TAG_SIZE || !tag || memcmp(tag, "NAT3UDP!", 8)) {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT observation query has invalid tag length=%zu", length); return;
}
uint64_t owner = sc_derive_node_id_from_pubkey(peer_key), generation = read64(tag + 9), round = read64(tag + 17);
uint64_t group_id = read64(tag + 25);
const struct TOPO_NODE *node = group_node(detector, group_id, owner);
if (!generation || !round || !node || memcmp(node->public_key, peer_key, 32)) {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT observation has invalid group/identity group=%016llx owner=%016llx",
(unsigned long long)group_id, (unsigned long long)owner); return;
}
struct nat_binding *binding = binding_find(detector, group_id, owner, generation, round);
if (!binding) {
unsigned count = 0;
for (struct nat_binding *item = detector->bindings; item; item = item->next) count++;
if (count >= NAT_MAX_BINDINGS) { DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT observation cache full"); return; }
binding = u_calloc(1, sizeof(*binding));
if (!binding) { DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT observation cache allocation failed"); return; }
binding->next = detector->bindings; detector->bindings = binding;
}
binding->group_id = group_id; binding->owner = owner; binding->generation = generation;
binding->round = round; binding->owner_socket = tag[8];
memcpy(binding->owner_key, peer_key, 32); binding->target = *source; binding->expires = get_time_tb() + NAT_ROUND_TB;
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT observation group=%016llx owner=%016llx socket=%u generation=%016llx round=%016llx observed=%s via=%s",
(unsigned long long)group_id, (unsigned long long)owner, tag[8], (unsigned long long)generation, (unsigned long long)round,
sockaddr_storage_to_str(source).str, socket->name);
}
static void clear_profile(struct nat_socket *state, uint8_t reason) {
int changed = state->socket->address_profile.mapping || state->socket->address_profile.inbound ||
state->socket->nat_addr.ss_family;
memset(&state->socket->address_profile, 0, sizeof(state->socket->address_profile));
memset(&state->socket->nat_addr, 0, sizeof(state->socket->nat_addr));
state->completed_tb = 0;
state->cold_until = get_time_tb() + NAT_ROUND_TB + 2500;
memset(&state->measured_profile, 0, sizeof(state->measured_profile));
memset(&state->measured_address, 0, sizeof(state->measured_address));
if (changed) {
DEBUG_INFO(DEBUG_CATEGORY_NAT, "NAT profile invalidated socket=%s generation=%016llx reason=%s",
state->socket->name, (unsigned long long)state->socket->generation, nat_check_reason_name(reason));
publish(state->detector);
}
}
/* Единственный выбор публикуемого профиля. STUN переносит только тип IP/netif,
* никогда не mapped endpoint тестового порта. Успешный ETCP действует до явного сброса. */
static void select_profile(struct nat_socket *state) {
const struct address_profile *current = &state->socket->address_profile;
struct address_profile selected = *current;
struct sockaddr_storage selected_address = {0};
if (state->measured_profile.source == ADDRESS_SOURCE_ETCP) {
selected = state->measured_profile;
if (selected.mapping == ADDRESS_MAP_EIM) selected_address = state->measured_address;
}
else if (state->fallback_allowed && !state->socket->is_tcp) {
struct stun_nat_result result;
if (!stun_nat_get_socket_result(state->detector->instance, state->socket, &result) &&
result.generation &&
(result.status == STUN_NAT_COMPLETE || result.status == STUN_NAT_PARTIAL)) {
struct address_profile fallback = {0};
if (result.mapping == STUN_MAP_EIM) fallback.mapping = result.translated == 0 ? ADDRESS_MAP_UNCHANGED : ADDRESS_MAP_EIM;
else if (result.mapping == STUN_MAP_DEPENDENT || result.mapping == STUN_MAP_ADM || result.mapping == STUN_MAP_APDM)
fallback.mapping = ADDRESS_MAP_DEPENDENT;
if (result.filtering == STUN_FILTER_EIF) fallback.inbound = ADDRESS_IN_OPEN;
else if (result.filtering == STUN_FILTER_ADF || result.filtering == STUN_FILTER_APDF) fallback.inbound = ADDRESS_IN_CONTACT;
if (fallback.mapping || fallback.inbound) {
fallback.source = ADDRESS_SOURCE_STUN;
if (current->source == ADDRESS_SOURCE_STUN) {
if (!fallback.mapping) fallback.mapping = current->mapping;
if (fallback.mapping == current->mapping && !fallback.inbound) fallback.inbound = current->inbound;
}
selected = fallback;
}
}
}
int address_changed = selected_address.ss_family != state->socket->nat_addr.ss_family ||
(selected_address.ss_family && !route_ping_addr_equal(&selected_address, &state->socket->nat_addr, 1));
if (selected.mapping == current->mapping && selected.inbound == current->inbound &&
selected.source == current->source && !address_changed) return;
DEBUG_INFO(DEBUG_CATEGORY_NAT, "NAT selected socket=%s generation=%016llx source=%s previous=%s mapping=%s inbound=%s"
" address_changed=%d reason=%s",
state->socket->name, (unsigned long long)state->socket->generation, address_profile_source_name(selected.source),
address_profile_source_name(current->source), address_mapping_name(selected.mapping), address_inbound_name(selected.inbound),
address_changed, nat_check_reason_name(state->reason));
state->socket->address_profile = selected;
state->socket->nat_addr = selected_address;
publish(state->detector);
}
static void owner_finish(struct nat_socket *state, uint8_t reason) {
int next_pair = reason && state->phase && state->cycling && !state->using_fallback &&
reason != NAT_REASON_CANCELLED && reason != NAT_REASON_ADDRESS_CHANGED;
etcp_cancel_pings(state->detector->instance, owner_ping_cb, state);
state->active_ping = 0; state->phase = NAT_IDLE; state->reason = reason;
if (reason == NAT_REASON_NO_OBSERVER || reason == NAT_REASON_NO_HELPER) state->fallback_allowed = 1;
if (next_pair) {
state->forced = 1; state->due = get_time_tb() + 1000; state->helper_reselections++;
} else {
state->cycling = 0; state->using_fallback = 0; state->preferred_observer = 0;
state->cursor = (struct nat_pair){0}; state->fallback = (struct nat_pair){0};
state->due = get_time_tb() + (reason == NAT_REASON_ADDRESS_CHANGED ? 2500 :
state->socket->address_profile.source || !reason ? NAT_REFRESH_TB : NAT_RETRY_TB);
}
if (reason) {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT round incomplete socket=%s group=%016llx generation=%016llx round=%016llx reason=%s next_pair=%d",
state->socket->name, (unsigned long long)state->group_id, (unsigned long long)state->socket->generation,
(unsigned long long)state->round, nat_check_reason_name(reason), next_pair);
}
select_profile(state);
}
static void owner_apply(struct nat_socket *state, uint8_t mapping, uint8_t inbound) {
struct address_profile profile = {.mapping = mapping, .inbound = inbound, .source = ADDRESS_SOURCE_ETCP};
uint8_t partial_reason = inbound != ADDRESS_IN_UNKNOWN ? NAT_REASON_NONE : !state->filter_clean ? NAT_REASON_CONTACT_HISTORY :
mapping == ADDRESS_MAP_DEPENDENT ? NAT_REASON_DEPENDENT_MAPPING : NAT_REASON_TIMEOUT;
if (inbound == ADDRESS_IN_UNKNOWN && state->measured_profile.source == ADDRESS_SOURCE_ETCP &&
mapping == state->measured_profile.mapping && route_ping_addr_equal(&state->measured_address, &state->baseline, 1)) {
profile.inbound = state->measured_profile.inbound;
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT incomplete ingress preserves previous result socket=%s round=%016llx inbound=%s reason=%s",
state->socket->name, (unsigned long long)state->round, address_inbound_name(profile.inbound),
nat_check_reason_name(partial_reason));
}
state->measured_profile = profile; state->measured_address = state->baseline; state->fallback_allowed = 0;
state->completed_tb = get_time_tb();
DEBUG_INFO(DEBUG_CATEGORY_NAT, "NAT profile socket=%s id=%u generation=%016llx round=%016llx mapping=%s inbound=%s effective_inbound=%s"
" local=%s external=%s observer=%016llx helper=%016llx clean=%u partial_reason=%s",
state->socket->name, state->socket->sock_id, (unsigned long long)state->socket->generation,
(unsigned long long)state->round, address_mapping_name(mapping), address_inbound_name(inbound),
address_inbound_name(profile.inbound),
sockaddr_storage_to_str(&state->local).str, sockaddr_storage_to_str(&state->baseline).str,
(unsigned long long)state->observer, (unsigned long long)state->helper, state->filter_clean,
nat_check_reason_name(partial_reason));
owner_finish(state, NAT_REASON_NONE); state->reason = partial_reason;
}
static int owner_run(struct nat_socket *state, uint8_t step) {
if (random_id(&state->token)) return -1;
struct nat_wire message;
if (make_message(state, &message, NAT_RUN)) return -1;
message.step = step;
state->phase = step == NAT_STEP_TCP ? NAT_TCP : step == NAT_STEP_PREPARE ? NAT_PREPARE_C :
step == NAT_STEP_PRE ? NAT_PRE : step == NAT_STEP_ALT ? NAT_PREPARE_ALT : NAT_POST;
return send_control(state->detector, state->group_id, state->observer, &message);
}
static int owner_observe(struct nat_socket *state) {
const struct sockaddr_storage *target = &state->observer_address;
const uint8_t *key = state->observer_key;
if (state->phase == NAT_OBSERVE_C || state->phase == NAT_OBSERVE_ALT) {
target = state->phase == NAT_OBSERVE_C ? &state->helper_address : &state->alternate_address;
key = state->helper_key;
}
int timeout = 1000;
struct ETCP_CONN *connection = topo_group_find_conn_for_node(
topo_groups_find(state->detector->instance->topo_groups, state->group_id), state->observer);
for (struct ETCP_LINK *link = connection ? connection->links : NULL; link; link = link->next)
if (link->rtt_last / 10 * 4 > timeout) timeout = link->rtt_last / 10 * 4;
if (timeout > 3000) timeout = 3000;
if (route_ping_observe(state->socket, key, target, state->group_id, state->round, timeout, owner_ping_cb, state)) return -1;
state->active_ping = 1; return 0;
}
static void owner_ping_cb(int success, uint16_t rtt, void *arg, uint64_t nonce, const uint8_t *data, size_t length) {
(void)rtt; (void)nonce;
struct nat_socket *state = arg;
state->active_ping = 0;
if (state->phase == NAT_IDLE) return;
struct sockaddr_storage observed;
if (!success || route_ping_observation(data, length, state->socket, state->group_id, state->round, &observed)) {
if (++state->retries < NAT_PROBE_COUNT) { state->due = get_time_tb() + 1000; return; }
owner_finish(state, success ? NAT_REASON_INVALID_OBSERVATION : NAT_REASON_TIMEOUT); return;
}
state->retries = 0;
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT own observation socket=%s phase=%u round=%016llx observed=%s",
state->socket->name, state->phase, (unsigned long long)state->round, sockaddr_storage_to_str(&observed).str);
if (state->phase == NAT_OBSERVE_B) {
state->baseline = observed;
if ((state->measured_profile.mapping == ADDRESS_MAP_UNCHANGED && !route_ping_addr_equal(&state->local, &observed, 1)) ||
(state->socket->nat_addr.ss_family && !route_ping_addr_equal(&state->socket->nat_addr, &observed, 1)))
clear_profile(state, NAT_REASON_ADDRESS_CHANGED);
if (owner_run(state, NAT_STEP_PREPARE)) owner_finish(state, NAT_REASON_CONTROL_LOST);
return;
}
if (state->phase == NAT_OBSERVE_C) {
state->helper_seen = observed;
if (route_ping_addr_equal(&state->baseline, &observed, 1)) {
if (owner_run(state, NAT_STEP_ALT)) owner_finish(state, NAT_REASON_CONTROL_LOST);
return;
}
state->phase = NAT_REPEAT_B;
} else if (state->phase == NAT_OBSERVE_ALT) {
state->alternate_seen = observed;
if (state->filter_clean && state->pre_healthy && !state->pre_received &&
route_ping_addr_equal(&state->baseline, &state->helper_seen, 1) &&
route_ping_addr_equal(&state->baseline, &state->alternate_seen, 1)) {
if (owner_run(state, NAT_STEP_POST)) owner_finish(state, NAT_REASON_CONTROL_LOST);
return;
}
state->phase = NAT_REPEAT_B;
} else if (state->phase == NAT_REPEAT_B) {
if (!route_ping_addr_equal(&observed, &state->baseline, 1)) {
clear_profile(state, NAT_REASON_ADDRESS_CHANGED); owner_finish(state, NAT_REASON_ADDRESS_CHANGED); return;
}
int same = route_ping_addr_equal(&state->baseline, &state->helper_seen, 1) &&
route_ping_addr_equal(&state->baseline, &state->alternate_seen, 1);
uint8_t mapping = same ? (route_ping_addr_equal(&state->local, &state->baseline, 1) ?
ADDRESS_MAP_UNCHANGED : ADDRESS_MAP_EIM) : ADDRESS_MAP_DEPENDENT;
uint8_t inbound = state->filter_clean && state->pre_received ? ADDRESS_IN_OPEN :
state->filter_clean && state->pre_healthy && state->post_received && same ? ADDRESS_IN_CONTACT : ADDRESS_IN_UNKNOWN;
owner_apply(state, mapping, inbound); return;
} else {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT observation in unexpected phase=%u", state->phase);
owner_finish(state, NAT_REASON_INVALID_OBSERVATION); return;
}
if (owner_observe(state)) owner_finish(state, NAT_REASON_SEND_ERROR);
}
void nat_detection_receive_ingress(struct NAT_DETECTION *detector, struct ETCP_SOCKET *socket,
const uint8_t peer_key[32], const struct sockaddr_storage *source,
const uint8_t *tag, size_t length) {
struct nat_socket *state = socket_state(detector, socket, 0);
if (!state || !tag || length != NAT_QUERY_TAG_SIZE) {
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT ingress ignored without pending endpoint/valid tag length=%zu", length); return;
}
uint8_t expected[ROUTE_OBSERVE_TAG_SIZE]; route_ping_make_tag(expected, socket, state->group_id, state->round);
uint8_t step = state->phase == NAT_PRE ? NAT_STEP_PRE : state->phase == NAT_POST ? NAT_STEP_POST : 0;
if (!step || memcmp(tag, expected, sizeof(expected)) || tag[ROUTE_OBSERVE_TAG_SIZE] != step ||
read64(tag + ROUTE_OBSERVE_TAG_SIZE + 1) != state->token ||
sc_derive_node_id_from_pubkey(peer_key) != state->helper || memcmp(peer_key, state->helper_key, 32) ||
source->ss_family != state->local.ss_family || !public_address(detector, source) ||
((step == NAT_STEP_POST || state->pre_received) && !route_ping_addr_equal(source, &state->helper_address, 1)) ||
route_ping_addr_equal(source, &state->observer_address, 0)) {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT ingress correlation/source mismatch socket=%s phase=%u round=%016llx source=%s",
socket->name, state->phase, (unsigned long long)state->round, sockaddr_storage_to_str(source).str); return;
}
if (step == NAT_STEP_PRE) {
if (!state->pre_received) { state->filter_clean = !contacted(state, source); state->helper_address = *source; }
state->pre_received = 1;
}
else state->post_received = 1;
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT direct ingress socket=%s round=%016llx step=%u source=%s clean=%u",
socket->name, (unsigned long long)state->round, step, sockaddr_storage_to_str(source).str, state->filter_clean);
}
/* Дополнительный порт наблюдателя не публикуется и не участвует в NCD. */
static struct ETCP_SOCKET *helper_socket(struct NAT_DETECTION *detector, struct ETCP_SOCKET *source, int alternate) {
struct nat_socket *state = socket_state(detector, source, 1);
if (!state) return NULL;
struct ETCP_SOCKET **slot = alternate ? &state->auxiliary : &state->helper_primary;
if (*slot) return *slot;
struct CFG_SERVER server; memset(&server, 0, sizeof(server));
server.ip = source->local_addr; server.netif_index = source->netif_index;
server.type = CFG_SERVER_TYPE_PRIVATE; server.mtu = source->mtu; server.fib = -1;
for (const struct CFG_SERVER *cfg = detector->instance->config->servers; cfg; cfg = cfg->next)
if (!strcmp(cfg->name, source->name)) { server.so_mark = cfg->so_mark; server.fib = cfg->fib; break; }
snprintf(server.name, sizeof(server.name), "nat-helper-%u-%u", source->sock_id, alternate);
if (server.ip.ss_family == AF_INET) ((struct sockaddr_in *)&server.ip)->sin_port = 0;
else ((struct sockaddr_in6 *)&server.ip)->sin6_port = 0;
*slot = etcp_socket_add(detector->instance, &server);
if (!*slot) { DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT helper socket failed source=%s alternate=%d", source->name, alternate); return NULL; }
(*slot)->probe_only = 1;
DEBUG_INFO(DEBUG_CATEGORY_NAT, "NAT isolated helper socket source=%s alternate=%d local=%s helper=%s",
source->name, alternate, sockaddr_storage_to_str(&source->local_addr).str,
sockaddr_storage_to_str(&(*slot)->local_addr).str);
return *slot;
}
static void helper_remove(struct nat_probe *probe) {
struct NAT_DETECTION *detector = probe->detector;
struct nat_probe **cursor = &detector->probes;
while (*cursor && *cursor != probe) cursor = &(*cursor)->next;
if (*cursor) *cursor = probe->next;
probe->cancelled = 1;
etcp_cancel_pings(detector->instance, helper_ping_cb, probe);
if (probe->tcp) { struct stcp_client *tcp = probe->tcp; probe->tcp = NULL; stcp_client_destroy(tcp); }
u_free(probe);
}
static void helper_finish(struct nat_probe *probe, uint8_t reason) {
probe->message.command = NAT_RESULT; probe->message.reason = reason;
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT helper done owner=%016llx round=%016llx step=%u sent=%u received=%u errors=%u reason=%s",
(unsigned long long)read64(probe->message.owner), (unsigned long long)read64(probe->message.round),
probe->message.step, probe->message.sent, probe->message.received, probe->message.errors, nat_check_reason_name(reason));
if (send_control(probe->detector, probe->group_id, probe->reply, &probe->message))
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT helper result delivery failed");
helper_remove(probe);
}
/* Входящая проба несёт идентификаторы owner; OBSERVE с помощника — идентификаторы его собственного socket. */
static void ingress_tag(const struct nat_wire *message, uint64_t group_id, uint8_t tag[NAT_QUERY_TAG_SIZE]) {
memcpy(tag, "NAT3UDP!", 8); tag[8] = message->owner_socket;
memcpy(tag + 9, message->generation, 8); memcpy(tag + 17, message->round, 8); write64(tag + 25, group_id);
tag[ROUTE_OBSERVE_TAG_SIZE] = message->step;
memcpy(tag + ROUTE_OBSERVE_TAG_SIZE + 1, message->token, 8);
}
static void helper_ping_cb(int success, uint16_t rtt, void *arg, uint64_t nonce, const uint8_t *data, size_t length) {
(void)rtt; (void)nonce;
struct nat_probe *probe = arg;
if (probe->cancelled) return;
probe->active = 0; probe->tcp = NULL;
uint8_t step = probe->message.step;
if (step == NAT_STEP_PREPARE || step == NAT_STEP_ALT) {
struct ETCP_SOCKET *socket = find_socket(probe->detector, probe->io_socket, probe->io_generation);
struct sockaddr_storage mapped;
if (success && socket && !route_ping_observation(data, length, socket, probe->group_id,
read64(probe->message.round), &mapped)) {
uint8_t *endpoint = step == NAT_STEP_PREPARE ? probe->message.primary : probe->message.secondary;
if (route_ping_addr_encode(endpoint, &mapped)) { helper_finish(probe, NAT_REASON_INVALID_OBSERVATION); return; }
probe->message.received++;
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT helper endpoint measured group=%016llx owner=%016llx step=%u socket=%s mapped=%s fallback=%u",
(unsigned long long)probe->group_id, (unsigned long long)read64(probe->message.owner), step,
socket->name, sockaddr_storage_to_str(&mapped).str, probe->alternate_fallback);
helper_finish(probe, NAT_REASON_NONE); return;
}
if (success) { helper_finish(probe, NAT_REASON_INVALID_OBSERVATION); return; }
if (probe->message.sent >= NAT_PROBE_COUNT) {
if (step == NAT_STEP_ALT && !probe->alternate_fallback) {
probe->alternate_fallback = 1; probe->message.sent = 0;
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT alternate endpoint blocked by owner; observe through broker group=%016llx owner=%016llx",
(unsigned long long)probe->group_id, (unsigned long long)read64(probe->message.owner));
} else { helper_finish(probe, NAT_REASON_TIMEOUT); return; }
}
} else if (step == NAT_STEP_TCP) {
if (success) probe->message.received++;
helper_finish(probe, success ? NAT_REASON_NONE : NAT_REASON_TIMEOUT); return;
} else {
if (success) {
uint8_t expected[NAT_QUERY_TAG_SIZE]; ingress_tag(&probe->message, probe->group_id, expected);
struct sockaddr_storage mapped;
if (length != ROUTE_ADDR_WIRE_SIZE + sizeof(expected) || memcmp(data + ROUTE_ADDR_WIRE_SIZE, expected, sizeof(expected)) ||
route_ping_addr_decode(data, &mapped) || route_ping_addr_encode(probe->message.primary, &mapped)) {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT ingress PONG has invalid endpoint/tag group=%016llx length=%zu",
(unsigned long long)probe->group_id, length);
helper_finish(probe, NAT_REASON_INVALID_OBSERVATION); return;
}
probe->message.received++;
}
if (probe->message.sent >= NAT_PROBE_COUNT) { helper_finish(probe, NAT_REASON_NONE); return; }
}
probe->due = get_time_tb() + 1000;
}
static int helper_send(struct nat_probe *probe) {
struct NAT_DETECTION *detector = probe->detector;
struct sockaddr_storage target;
if (route_ping_addr_decode(probe->message.target, &target)) return -1;
int timeout = ((unsigned)probe->message.timeout_ms[0] << 8) | probe->message.timeout_ms[1];
if (timeout < 500 || timeout > 3000) return -1;
int result;
if (probe->message.step == NAT_STEP_TCP) {
struct reality_client_config reality, *camouflage = NULL;
const struct TOPO_NODE *owner = topo_node_registry_find(detector->instance->topo_groups, read64(probe->message.owner));
const struct TOPO_REALITY_SOCK *parameters = topo_node_find_reality_sock(owner, probe->message.owner_socket);
if (parameters) { topo_node_reality_config(&reality, parameters); camouflage = &reality; }
result = etcp_send_tcp_ping(detector->instance, probe->owner_key, &target, timeout,
helper_ping_cb, probe, &probe->tcp, camouflage);
} else if (probe->message.step == NAT_STEP_PREPARE || probe->message.step == NAT_STEP_ALT) {
struct ETCP_SOCKET *source = find_socket(detector, probe->source_socket, probe->source_generation);
if (!source) { DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT helper source generation disappeared"); return -1; }
struct ETCP_SOCKET *socket = helper_socket(detector, source, probe->message.step == NAT_STEP_ALT);
if (!socket) return -1;
const uint8_t *peer_key = probe->owner_key;
if (probe->message.step == NAT_STEP_PREPARE || probe->alternate_fallback) {
if (route_ping_addr_decode(probe->message.observer_address, &target)) return -1;
peer_key = probe->observer_key;
}
probe->io_socket = socket->sock_id; probe->io_generation = socket->generation;
result = route_ping_observe(socket, peer_key, &target, probe->group_id, read64(probe->message.round),
timeout, helper_ping_cb, probe);
} else {
struct ETCP_SOCKET *source = find_socket(detector, probe->source_socket, probe->source_generation);
if (!source || source->is_tcp || source->socks_udp) return -1;
struct ETCP_SOCKET *socket = helper_socket(detector, source, 0);
if (!socket) return -1;
probe->io_socket = socket->sock_id; probe->io_generation = socket->generation;
uint8_t tag[NAT_QUERY_TAG_SIZE];
ingress_tag(&probe->message, probe->group_id, tag);
result = etcp_send_ping_to_socket(detector->instance, socket, probe->owner_key, &target, timeout,
helper_ping_cb, probe, tag, sizeof(tag), ETCP_PING_FLAG_ADDRESS_CHECK);
}
if (result) { probe->message.errors++; return -1; }
probe->message.sent++; probe->active = 1; return 0;
}
static int tcp_target_advertised(struct NAT_DETECTION *detector, uint64_t group_id, const struct nat_wire *message,
const struct sockaddr_storage *target) {
const struct TOPO_NODE *owner = group_node(detector, group_id, read64(message->owner));
if (!owner) return 0;
uint8_t address[ROUTE_ADDR_WIRE_SIZE];
if (route_ping_addr_encode(address, target)) return 0;
if (target->ss_family == AF_INET) {
for (const struct TOPO_ADDR4 *item = owner->v4_addrs; item; item = item->next)
if (item->socket_id == message->owner_socket && (item->protocol & TOPO_PROTO_TCP) &&
!memcmp(item->addr, address + 1, 4) && item->port == (((unsigned)address[17] << 8) | address[18])) return 1;
} else {
for (const struct TOPO_ADDR6 *item = owner->v6_addrs; item; item = item->next)
if (item->socket_id == message->owner_socket && (item->protocol & TOPO_PROTO_TCP) &&
!memcmp(item->addr, address + 1, 16) && item->port == (((unsigned)address[17] << 8) | address[18])) return 1;
}
return 0;
}
/* Broker проверяет реальное наблюдение owner, затем делегирует выбранному владельцем помощнику через ту же группу. */
static void handle_run(struct NAT_DETECTION *detector, uint64_t group_id, uint64_t sender, struct nat_wire *message) {
uint64_t owner = read64(message->owner), observer = read64(message->observer), helper = read64(message->helper);
const struct TOPO_NODE *owner_node = group_node(detector, group_id, owner);
const struct TOPO_NODE *observer_node = group_node(detector, group_id, observer);
struct sockaddr_storage target;
uint8_t reason = NAT_REASON_INVALID_OBSERVATION;
if (!owner_node || !observer_node || owner == observer || owner == helper ||
route_ping_addr_decode(message->target, &target) || !public_address(detector, &target)) {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT run has invalid participants/target group=%016llx owner=%016llx observer=%016llx helper=%016llx",
(unsigned long long)group_id, (unsigned long long)owner, (unsigned long long)observer,
(unsigned long long)helper); goto reject;
}
if (sender == owner && observer == detector->instance->node_id) {
if (message->step != NAT_STEP_TCP) {
struct nat_binding *binding = binding_find(detector, group_id, owner, read64(message->generation), read64(message->round));
if (!binding || binding->owner_socket != message->owner_socket || !route_ping_addr_equal(&binding->target, &target, 1) ||
memcmp(binding->owner_key, owner_node->public_key, 32) || helper == observer) {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT delegation rejected: stale own observation group=%016llx owner=%016llx",
(unsigned long long)group_id, (unsigned long long)owner); goto reject;
}
binding->helper = helper; binding->token = read64(message->token); binding->expires = get_time_tb() + NAT_ROUND_TB;
}
if (helper != detector->instance->node_id) {
if (!control_route(detector, group_id, helper) || send_control(detector, group_id, helper, message)) {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT delegation route failed group=%016llx helper=%016llx",
(unsigned long long)group_id, (unsigned long long)helper);
reason = NAT_REASON_CONTROL_LOST; goto reject;
}
return;
}
} else if (sender != observer || helper != detector->instance->node_id) {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT run role mismatch group=%016llx sender=%016llx observer=%016llx helper=%016llx",
(unsigned long long)group_id, (unsigned long long)sender, (unsigned long long)observer,
(unsigned long long)helper); goto reject;
}
if (message->step == NAT_STEP_TCP && (helper != observer || !tcp_target_advertised(detector, group_id, message, &target))) {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT TCP target is not the signed owner listener group=%016llx", (unsigned long long)group_id);
goto reject;
}
unsigned count = 0;
for (struct nat_probe *probe = detector->probes; probe; probe = probe->next) {
count++;
if (probe->group_id == group_id && read64(probe->message.owner) == owner &&
read64(probe->message.generation) == read64(message->generation) && read64(probe->message.round) == read64(message->round) &&
read64(probe->message.token) == read64(message->token)) {
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT duplicate helper run ignored"); return;
}
}
if (count >= NAT_MAX_PROBES) { DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT helper probe limit reached"); reason = NAT_REASON_SEND_ERROR; goto reject; }
struct ETCP_SOCKET *source = NULL;
if (message->step != NAT_STEP_TCP) {
struct sockaddr_storage observer_address;
source = find_socket(detector, message->helper_socket, 0);
if (!source || source->is_tcp || source->probe_only || source->socks_udp ||
source->type == CFG_SERVER_TYPE_PRIVATE || source->type == CFG_SERVER_TYPE_LOCAL ||
source->local_addr.ss_family != target.ss_family ||
route_ping_addr_decode(message->observer_address, &observer_address) ||
observer_address.ss_family != target.ss_family || !public_address(detector, &observer_address)) {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT helper source is not a native socket group=%016llx socket=%u",
(unsigned long long)group_id, message->helper_socket);
reason = source && source->socks_udp ? NAT_REASON_PROXY : NAT_REASON_NO_HELPER; goto reject;
}
}
struct nat_probe *probe = u_calloc(1, sizeof(*probe));
if (!probe) { DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT helper probe allocation failed"); reason = NAT_REASON_SEND_ERROR; goto reject; }
probe->detector = detector; probe->message = *message; probe->group_id = group_id; probe->reply = sender;
memcpy(probe->owner_key, owner_node->public_key, 32); memcpy(probe->observer_key, observer_node->public_key, 32);
if (source) { probe->source_socket = source->sock_id; probe->source_generation = source->generation; }
probe->expires = get_time_tb() + NAT_ROUND_TB;
probe->next = detector->probes; detector->probes = probe;
if (helper_send(probe)) helper_finish(probe, NAT_REASON_SEND_ERROR);
return;
reject:
message->command = NAT_RESULT; message->reason = reason;
if (send_control(detector, group_id, sender, message)) DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT rejection delivery failed");
}
static void handle_result(struct nat_socket *state, const struct nat_wire *message) {
uint8_t step = state->phase == NAT_PRE ? NAT_STEP_PRE : state->phase == NAT_POST ? NAT_STEP_POST :
state->phase == NAT_TCP ? NAT_STEP_TCP : state->phase == NAT_PREPARE_C ? NAT_STEP_PREPARE :
state->phase == NAT_PREPARE_ALT ? NAT_STEP_ALT : 0;
if (!step || message->step != step || read64(message->token) != state->token || read64(message->helper) != state->helper) {
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT stale helper result ignored socket=%s phase=%u", state->socket->name, state->phase); return;
}
if (message->reason || message->errors || !message->sent || message->received > message->sent) {
owner_finish(state, message->reason ? message->reason : NAT_REASON_SEND_ERROR); return;
}
if (step == NAT_STEP_TCP) {
if (message->received) owner_apply(state, ADDRESS_MAP_UNCHANGED, ADDRESS_IN_OPEN);
else owner_finish(state, NAT_REASON_TIMEOUT);
return;
}
if (step == NAT_STEP_PREPARE) {
struct sockaddr_storage primary;
if (route_ping_addr_decode(message->primary, &primary) || primary.ss_family != state->local.ss_family ||
!public_address(state->detector, &primary)) { owner_finish(state, NAT_REASON_INVALID_OBSERVATION); return; }
int same_ip = route_ping_addr_equal(&state->observer_address, &primary, 0), old_contact = contacted(state, &primary);
if (same_ip || (old_contact && !state->using_fallback)) {
if (!same_ip && !state->fallback.group) state->fallback = (struct nat_pair){state->group_id, state->observer, state->helper};
DEBUG_INFO(DEBUG_CATEGORY_NAT, "NAT try another pair socket=%s group=%016llx helper=%016llx endpoint=%s reason=%s",
state->socket->name, (unsigned long long)state->group_id, (unsigned long long)state->helper,
sockaddr_storage_to_str(&primary).str, same_ip ? "same_external_ip" : "previous_udp_contact");
owner_finish(state, same_ip ? NAT_REASON_NO_HELPER : NAT_REASON_CONTACT_HISTORY); return;
}
state->helper_address = primary; state->filter_clean = !old_contact;
if (owner_run(state, NAT_STEP_PRE)) owner_finish(state, NAT_REASON_CONTROL_LOST);
return;
}
if (step == NAT_STEP_ALT) {
if (route_ping_addr_decode(message->secondary, &state->alternate_address) ||
!route_ping_addr_equal(&state->alternate_address, &state->helper_address, 0) ||
route_ping_addr_equal(&state->alternate_address, &state->helper_address, 1)) {
owner_finish(state, NAT_REASON_INVALID_OBSERVATION); return;
}
state->phase = NAT_OBSERVE_ALT;
} else if (step == NAT_STEP_PRE) {
if (!state->pre_received && route_ping_addr_decode(message->primary, &state->helper_address)) {
owner_finish(state, NAT_REASON_INVALID_OBSERVATION); return;
}
state->pre_healthy = message->sent == NAT_PROBE_COUNT;
state->phase = NAT_OBSERVE_C;
} else state->phase = NAT_REPEAT_B;
state->retries = 0;
if (owner_observe(state)) owner_finish(state, NAT_REASON_SEND_ERROR);
}
/* Потеря router-сессии отменяет только роли этого узла в данной группе, не общий транспорт. */
static void cancel_route(struct NAT_DETECTION *detector, uint64_t group_id, uint64_t peer) {
for (struct nat_socket *state = detector->sockets; state; state = state->next)
if (state->phase && state->group_id == group_id && (state->observer == peer || state->helper == peer))
owner_finish(state, NAT_REASON_CONTROL_LOST);
struct nat_probe *probe = detector->probes;
while (probe) {
struct nat_probe *next = probe->next;
if (probe->group_id == group_id && (probe->reply == peer || read64(probe->message.owner) == peer)) helper_remove(probe);
probe = next;
}
for (struct nat_binding *binding = detector->bindings; binding; binding = binding->next)
if (binding->group_id == group_id && (binding->owner == peer || binding->helper == peer)) binding->expires = 0;
}
/* SOURCE и group берём из проверенного router-заголовка, а не из ETCP next hop. */
static void receive_control(struct ETCP_CONN *from, struct ll_entry *entry) {
struct NAT_DETECTION *detector = from && from->instance ? from->instance->nat_det : NULL;
if (!detector || !entry || !entry->dgram || entry->len < ROUTER_SVC_HDR_SIZE) {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT routed control invalid size=%zu", entry ? entry->len : 0);
if (entry) { queue_dgram_free(entry); queue_entry_free(entry); } return;
}
uint64_t group_id, sender;
memcpy(&group_id, entry->dgram + ROUTER_SVC_GROUP_OFF, 8); memcpy(&sender, entry->dgram + ROUTER_SVC_SRC_OFF, 8);
if (entry->len == ROUTER_SVC_HDR_SIZE) {
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT routed control closed group=%016llx peer=%016llx",
(unsigned long long)group_id, (unsigned long long)sender);
queue_dgram_free(entry); queue_entry_free(entry); cancel_route(detector, group_id, sender); return;
}
if (entry->len != ROUTER_SVC_HDR_SIZE + sizeof(struct nat_wire) ||
entry->dgram[ROUTER_SVC_FLAGS_OFF] != (ROUTER_FLAG_SIGNED | ROUTER_FLAG_ENCRYPTED) ||
!group_node(detector, group_id, sender)) {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT routed control rejected group=%016llx sender=%016llx size=%zu flags=%u",
(unsigned long long)group_id, (unsigned long long)sender, entry->len, entry->dgram[ROUTER_SVC_FLAGS_OFF]);
queue_dgram_free(entry); queue_entry_free(entry); return;
}
struct nat_wire message; memcpy(&message, entry->dgram + ROUTER_SVC_PAYLOAD_OFF, sizeof(message));
queue_dgram_free(entry); queue_entry_free(entry);
if (message.cmd != ETCP_RT_ID_NAT_DETECTION || message.version != NAT_WIRE_VERSION ||
!read64(message.owner) || !read64(message.observer) || !read64(message.helper) ||
!read64(message.generation) || !read64(message.round) || !read64(message.token) ||
message.command < NAT_RUN || message.command > NAT_RESULT || message.reason > NAT_REASON_DEPENDENT_MAPPING ||
message.step < NAT_STEP_PREPARE || message.step > NAT_STEP_TCP) {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT control malformed command=%u version=%u step=%u", message.command, message.version, message.step);
return;
}
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT control RX group=%016llx command=%u step=%u sender=%016llx via=%016llx owner=%016llx round=%016llx",
(unsigned long long)group_id, message.command, message.step, (unsigned long long)sender,
(unsigned long long)from->peer_node_id, (unsigned long long)read64(message.owner), (unsigned long long)read64(message.round));
if (message.command == NAT_RUN) { handle_run(detector, group_id, sender, &message); return; }
uint64_t owner = read64(message.owner);
if (owner != detector->instance->node_id) {
struct nat_binding *binding = binding_find(detector, group_id, owner, read64(message.generation), read64(message.round));
if (!binding || binding->helper != sender || read64(message.helper) != sender || binding->token != read64(message.token) ||
read64(message.observer) != detector->instance->node_id) {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT result has no matching delegation group=%016llx owner=%016llx sender=%016llx",
(unsigned long long)group_id, (unsigned long long)owner, (unsigned long long)sender); return;
}
if (send_control(detector, group_id, owner, &message)) DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT result forwarding failed");
return;
}
struct ETCP_SOCKET *socket = find_socket(detector, message.owner_socket, read64(message.generation));
struct nat_socket *state = socket_state(detector, socket, 0);
if (!state || state->group_id != group_id || state->round != read64(message.round) ||
state->observer != sender || read64(message.observer) != sender || state->phase == NAT_IDLE) {
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT stale/foreign owner response ignored group=%016llx", (unsigned long long)group_id); return;
}
handle_result(state, &message);
}
static void owner_start(struct nat_socket *state) {
struct NAT_DETECTION *detector = state->detector;
if (state->socket->socks_udp) {
state->reason = NAT_REASON_PROXY; state->due = UINT64_MAX;
DEBUG_INFO(DEBUG_CATEGORY_NAT, "NAT native endpoint not measured through SOCKS5 socket=%s", state->socket->name); return;
}
if (state->socket->type == CFG_SERVER_TYPE_LOCAL || state->socket->type == CFG_SERVER_TYPE_PRIVATE) {
state->due = UINT64_MAX; return;
}
if (state->socket->is_tcp && !public_address(detector, &state->local)) {
state->reason = NAT_REASON_NO_LISTENER; state->due = UINT64_MAX;
DEBUG_INFO(DEBUG_CATEGORY_NAT, "TCP inbound profile remains UNKNOWN: no public listener candidate socket=%s local=%s",
state->socket->name, sockaddr_storage_to_str(&state->local).str); return;
}
if (!state->cycling) {
state->cycling = 1; state->cursor = (struct nat_pair){0}; state->fallback = (struct nat_pair){0};
state->using_fallback = 0; state->prefer_fresh = 1;
}
history_load(state);
if (random_id(&state->round)) { owner_finish(state, NAT_REASON_SEND_ERROR); return; }
state->rounds++;
if (select_pair(state)) { owner_finish(state, state->reason); return; }
memset(&state->helper_seen, 0, sizeof(state->helper_seen)); memset(&state->alternate_seen, 0, sizeof(state->alternate_seen));
state->retries = 0; state->pre_received = 0; state->post_received = 0; state->filter_clean = 0; state->pre_healthy = 0;
state->deadline = get_time_tb() + NAT_ROUND_TB; state->reason = NAT_REASON_NONE;
DEBUG_INFO(DEBUG_CATEGORY_NAT, "NAT round start socket=%s group=%016llx id=%u generation=%016llx round=%016llx observer=%016llx helper=%016llx protocol=%s",
state->socket->name, (unsigned long long)state->group_id, state->socket->sock_id,
(unsigned long long)state->socket->generation, (unsigned long long)state->round,
(unsigned long long)state->observer, (unsigned long long)state->helper, state->socket->is_tcp ? "TCP" : "UDP");
if (state->socket->is_tcp) {
state->baseline = state->local;
if (owner_run(state, NAT_STEP_TCP)) owner_finish(state, NAT_REASON_CONTROL_LOST);
} else {
state->phase = NAT_OBSERVE_B;
if (owner_observe(state)) owner_finish(state, NAT_REASON_SEND_ERROR);
}
}
static void detector_tick(void *arg) {
struct NAT_DETECTION *detector = arg; detector->timer = NULL;
if (detector->publish_pending && get_time_tb() >= detector->publish_after) publish(detector);
uint64_t now = get_time_tb();
for (struct ETCP_SOCKET *socket = detector->instance->etcp_sockets; socket; socket = socket->next)
if (!socket->probe_only) socket_state(detector, socket, 1);
for (struct nat_socket *state = detector->sockets; state; state = state->next) {
if (now >= state->select_due) { select_profile(state); state->select_due = now + 10000; }
if (state->phase && now >= state->deadline) { owner_finish(state, NAT_REASON_TIMEOUT); continue; }
if (!state->phase && now >= state->due && (detector->automatic || state->forced)) {
state->forced = 0; owner_start(state);
}
else if ((state->phase == NAT_OBSERVE_B || state->phase == NAT_OBSERVE_C ||
state->phase == NAT_OBSERVE_ALT || state->phase == NAT_REPEAT_B) && !state->active_ping && now >= state->due) {
if (owner_observe(state)) owner_finish(state, NAT_REASON_SEND_ERROR);
}
}
struct nat_probe *probe = detector->probes;
while (probe) {
struct nat_probe *next = probe->next;
if (now >= probe->expires) helper_finish(probe, NAT_REASON_TIMEOUT);
else if (!probe->active && now >= probe->due && helper_send(probe)) helper_finish(probe, NAT_REASON_SEND_ERROR);
probe = next;
}
struct nat_binding **cursor = &detector->bindings;
while (*cursor) {
struct nat_binding *binding = *cursor;
if (now < binding->expires) { cursor = &binding->next; continue; }
*cursor = binding->next; u_free(binding);
}
detector->timer = uasync_set_timeout(detector->instance->ua, NAT_TICK_TB, detector, detector_tick, "nat_detection");
if (!detector->timer) DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT detector timer scheduling failed");
}
/* Отпечаток доступных endpoint не содержит timestamp/имя/профиль: обычный повтор NODEINFO не запускает пробы. */
static uint64_t candidate_fingerprint(struct nat_socket *state, int ready) {
struct NAT_DETECTION *detector = state->detector;
uint64_t total = 0;
for (struct ll_entry *e = detector->instance->topo_groups->group_list->head; e; e = e->next) {
struct TOPO_GROUP *group = (struct TOPO_GROUP *)e;
if (group->stopping || !group->local_node) continue;
uint64_t group_total = 0; unsigned candidates = 0, observers = 0;
for (struct ll_entry *n = group->nodes->head; n; n = n->next) {
uint64_t id = ((struct TOPO_GROUP_NODE *)n)->node_id;
if (id == detector->instance->node_id || (ready ? !control_route(detector, group->group_id, id) :
!topo_node_best_path((struct TOPO_GROUP_NODE *)n))) continue;
const struct TOPO_NODE *node = group_node(detector, group->group_id, id);
if (!node) continue;
struct sockaddr_storage endpoint = {0}; uint8_t socket_id = 0;
uint8_t bytes[16 + ROUTE_ADDR_WIRE_SIZE + 1] = {0};
write64(bytes, group->group_id); write64(bytes + 8, id);
if (!state->socket->is_tcp) {
if (!node_udp_endpoint(detector, node, state->local.ss_family, 1, &endpoint, &socket_id)) continue;
if (route_ping_addr_encode(bytes + 16, &endpoint)) continue;
bytes[16 + ROUTE_ADDR_WIRE_SIZE] = socket_id;
struct sockaddr_storage observer_address = {0}; uint8_t observer_socket = 0;
observers += node_udp_endpoint(detector, node, state->local.ss_family, 0, &observer_address, &observer_socket);
}
candidates++;
uint64_t hash = UINT64_C(14695981039346656037);
for (unsigned i = 0; i < sizeof(bytes); i++) { hash ^= bytes[i]; hash *= UINT64_C(1099511628211); }
group_total += hash;
}
if (ready || (candidates >= 2 && observers)) total += group_total;
}
return total;
}
/* Изменения нескольких групп объединяются; известный полный ETCP-профиль не перепроверяется из-за нового соседа. */
static void topology_wake(void *arg) {
struct NAT_DETECTION *detector = arg; detector->topology_wake = NULL;
for (struct nat_socket *state = detector->sockets; state; state = state->next) {
uint64_t fingerprint = candidate_fingerprint(state, 1);
int changed = fingerprint != state->available_fingerprint; state->available_fingerprint = fingerprint;
if (state->phase) {
if (!control_route(detector, state->group_id, state->observer) || !control_route(detector, state->group_id, state->helper))
owner_finish(state, NAT_REASON_CONTROL_LOST);
continue;
}
if (!changed || !fingerprint || !detector->automatic || state->cycling) continue;
if (state->measured_profile.source == ADDRESS_SOURCE_ETCP && state->measured_profile.mapping && state->measured_profile.inbound)
continue;
state->cursor = (struct nat_pair){0}; state->fallback = (struct nat_pair){0}; state->using_fallback = 0;
state->due = get_time_tb() + 2500;
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT available candidates changed socket=%s; early measurement scheduled", state->socket->name);
}
}
void nat_detection_topology_changed(struct NAT_DETECTION *detector) {
if (!detector || detector->stopping) return;
detector->reservation_dirty = 1;
if (detector->topology_wake) return;
detector->topology_wake = uasync_call_soon(detector->instance->ua, detector, topology_wake);
if (!detector->topology_wake) DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT topology wake scheduling failed");
}
void nat_detection_cancel_group(struct NAT_DETECTION *detector, uint64_t group_id) {
if (!detector || detector->stopping) return;
for (struct nat_socket *state = detector->sockets; state; state = state->next) {
if (state->fallback.group == group_id) state->fallback = (struct nat_pair){0};
if (state->group_id != group_id || (!state->phase && !state->cycling)) continue;
owner_finish(state, NAT_REASON_CANCELLED); state->forced = 0; state->group_id = 0; state->due = get_time_tb() + 2500;
}
struct nat_probe *probe = detector->probes;
while (probe) {
struct nat_probe *next = probe->next;
if (probe->group_id == group_id) helper_remove(probe);
probe = next;
}
struct nat_binding **cursor = &detector->bindings;
while (*cursor) {
struct nat_binding *binding = *cursor;
if (binding->group_id != group_id) { cursor = &binding->next; continue; }
*cursor = binding->next; u_free(binding);
}
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT group tasks cancelled group=%016llx", (unsigned long long)group_id);
nat_detection_topology_changed(detector);
}
void nat_detection_cancel_for_conn(struct NAT_DETECTION *detector, struct ETCP_CONN *connection) {
if (!detector || !connection || detector->stopping) return;
nat_detection_topology_changed(detector);
}
static void connection_status(struct ETCP_CONN *connection, int status, void *arg) {
struct NAT_DETECTION *detector = arg;
if (status == ETCP_CONN_STATUS_DOWN || status == ETCP_CONN_STATUS_DELETE || status == ETCP_CONN_STATUS_REINIT)
nat_detection_cancel_for_conn(detector, connection);
else if (status == ETCP_CONN_STATUS_UP) nat_detection_topology_changed(detector);
}
void nat_detection_link_ready(struct NAT_DETECTION *detector, struct ETCP_LINK *link) {
if (!detector || !link || !link->conn || link->conn->probe_only || detector->stopping) return;
struct nat_socket *state = socket_state(detector, link->conn, 1);
if (state && !state->phase && !state->completed_tb) state->due = get_time_tb() + 2500;
}
void nat_detection_observed_by_peer(struct NAT_DETECTION *detector, struct ETCP_LINK *link,
const struct sockaddr_storage *observed) {
if (!detector || !link || !link->conn || link->is_tcp || link->conn->socks_udp || !observed->ss_family) return;
struct nat_socket *state = socket_state(detector, link->conn, 1);
if (!state) return;
if ((state->measured_profile.mapping == ADDRESS_MAP_UNCHANGED &&
!route_ping_addr_equal(&state->local, observed, 1)) ||
(link->conn->nat_addr.ss_family && !route_ping_addr_equal(&link->conn->nat_addr, observed, 1))) {
if (state->phase) owner_finish(state, NAT_REASON_ADDRESS_CHANGED);
clear_profile(state, NAT_REASON_ADDRESS_CHANGED);
state->due = get_time_tb() + 2500;
}
}
void nat_detection_socket_removed(struct NAT_DETECTION *detector, struct ETCP_SOCKET *socket) {
if (!detector || !socket || detector->stopping) return;
if (!socket->probe_only) { detector->publish_pending = 1; detector->publish_after = get_time_tb(); }
struct nat_probe *probe = detector->probes;
while (probe) {
struct nat_probe *next = probe->next;
if ((probe->source_socket == socket->sock_id && probe->source_generation == socket->generation) ||
(probe->io_socket == socket->sock_id && probe->io_generation == socket->generation)) helper_remove(probe);
probe = next;
}
struct nat_socket **cursor = &detector->sockets;
while (*cursor && (*cursor)->socket != socket) cursor = &(*cursor)->next;
if (!*cursor) return;
struct nat_socket *state = *cursor; *cursor = state->next;
etcp_cancel_pings(detector->instance, owner_ping_cb, state);
struct ETCP_SOCKET *primary = state->helper_primary, *auxiliary = state->auxiliary;
DEBUG_DEBUG(DEBUG_CATEGORY_NAT, "NAT endpoint removed socket=%s generation=%016llx", socket->name,
(unsigned long long)socket->generation);
u_free(state);
if (primary) etcp_socket_remove(primary);
if (auxiliary) etcp_socket_remove(auxiliary);
}
static void socket_changed(struct ETCP_SOCKET *socket, int event, void *arg) {
struct NAT_DETECTION *detector = arg;
struct nat_socket *state = socket_state(detector, socket, 0);
if (!state || !(event & ETCP_SOCKET_EVENT_ADDR_CHANGED)) return;
clear_profile(state, NAT_REASON_ADDRESS_CHANGED);
nat_detection_socket_removed(detector, socket);
if (random_id(&socket->generation)) return;
socket_state(detector, socket, 1);
}
struct NAT_DETECTION *nat_detection_create(struct UTUN_INSTANCE *instance) {
if (!instance || !instance->topo_groups || !instance->router_conns ||
instance->router_bindings.callbacks[ETCP_RT_ID_NAT_DETECTION]) {
DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT detector invalid instance/binding collision"); return NULL;
}
struct NAT_DETECTION *detector = u_calloc(1, sizeof(*detector));
if (!detector) { DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT detector allocation failed"); return NULL; }
detector->instance = instance; detector->automatic = 1;
if (etcp_router_bind(instance, ETCP_RT_ID_NAT_DETECTION, receive_control)) { u_free(detector); return NULL; }
etcp_add_conn_status_cbk(instance, connection_status, detector);
etcp_add_socket_cbk(instance, socket_changed, detector, ETCP_SOCKET_EVENT_ADDR_CHANGED);
detector->timer = uasync_set_timeout(instance->ua, NAT_TICK_TB, detector, detector_tick, "nat_detection");
if (!detector->timer) {
etcp_remove_conn_status_cbk(instance, connection_status, detector);
etcp_remove_socket_cbk(instance, socket_changed, detector);
etcp_router_unbind(instance, ETCP_RT_ID_NAT_DETECTION); u_free(detector);
DEBUG_ERROR(DEBUG_CATEGORY_NAT, "NAT detector initial timer failed"); return NULL;
}
DEBUG_INFO(DEBUG_CATEGORY_NAT, "NAT endpoint detector started: UDP mapping/inbound measured separately, TCP listener probes");
return detector;
}
void nat_detection_destroy(struct NAT_DETECTION *detector) {
if (!detector) return;
detector->stopping = 1;
if (detector->timer) uasync_cancel_timeout(detector->instance->ua, detector->timer);
if (detector->topology_wake) uasync_call_soon_cancel(detector->instance->ua, detector->topology_wake);
etcp_remove_conn_status_cbk(detector->instance, connection_status, detector);
etcp_remove_socket_cbk(detector->instance, socket_changed, detector);
etcp_router_unbind(detector->instance, ETCP_RT_ID_NAT_DETECTION);
while (detector->probes) helper_remove(detector->probes);
while (detector->sockets) {
struct nat_socket *state = detector->sockets; detector->sockets = state->next;
etcp_cancel_pings(detector->instance, owner_ping_cb, state);
struct ETCP_SOCKET *primary = state->helper_primary, *auxiliary = state->auxiliary; u_free(state);
if (primary) etcp_socket_remove(primary);
if (auxiliary) etcp_socket_remove(auxiliary);
}
while (detector->bindings) {
struct nat_binding *binding = detector->bindings; detector->bindings = binding->next; u_free(binding);
}
DEBUG_INFO(DEBUG_CATEGORY_NAT, "NAT detector stopped; all endpoint rounds and helper probes cancelled");
u_free(detector);
}
void nat_detection_request_check_all(struct NAT_DETECTION *detector) {
if (!detector || detector->stopping) return;
for (struct ETCP_SOCKET *socket = detector->instance->etcp_sockets; socket; socket = socket->next) {
struct nat_socket *state = socket_state(detector, socket, 1);
if (!state) continue;
if (state->phase) owner_finish(state, NAT_REASON_CANCELLED);
state->cycling = 0; state->cursor = (struct nat_pair){0}; state->fallback = (struct nat_pair){0}; state->using_fallback = 0;
state->due = get_time_tb(); state->forced = 1; state->preferred_observer = 0;
}
DEBUG_INFO(DEBUG_CATEGORY_NAT, "NAT endpoint recheck requested");
}
int nat_detection_request_check_socket(struct NAT_DETECTION *detector, struct ETCP_SOCKET *socket, uint64_t observer) {
struct nat_socket *state = socket_state(detector, socket, 1);
if (!state || !observer) {
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT endpoint recheck has invalid endpoint/observer"); return -1;
}
if (state->phase) owner_finish(state, NAT_REASON_CANCELLED);
state->cycling = 0; state->cursor = (struct nat_pair){0}; state->fallback = (struct nat_pair){0}; state->using_fallback = 0;
state->preferred_observer = observer; state->due = get_time_tb(); state->forced = 1;
DEBUG_INFO(DEBUG_CATEGORY_NAT, "NAT endpoint recheck socket=%s observer=%016llx", socket->name, (unsigned long long)observer);
return 0;
}
void nat_detection_set_allow_local(struct NAT_DETECTION *detector, int allow) {
if (detector) detector->allow_local = !!allow;
}
void nat_detection_set_automatic(struct NAT_DETECTION *detector, int automatic) {
if (!detector) return;
detector->automatic = !!automatic;
DEBUG_INFO(DEBUG_CATEGORY_NAT, "NAT automatic endpoint measurements %s", automatic ? "enabled" : "disabled");
}
int nat_detection_get_status(struct NAT_DETECTION *detector, struct ETCP_SOCKET *socket, struct nat_check_status *status) {
struct nat_socket *state = socket_state(detector, socket, 0);
if (!state || !status) return -1;
*status = (struct nat_check_status){.generation = socket->generation, .round = state->round, .group_id = state->group_id,
.observer = state->observer,
.helper = state->helper, .rounds = state->rounds, .helper_reselections = state->helper_reselections,
.phase = state->phase, .reason = state->reason, .history_complete = state->history_complete,
.measured_profile = state->measured_profile, .effective_profile = socket->address_profile, .fallback_allowed = state->fallback_allowed};
return 0;
}