193 lines
10 KiB
C
193 lines
10 KiB
C
#include "chat_local.h"
|
|
#include "chat_event.h"
|
|
#include "invite_link.h"
|
|
#include "chat_setting.h"
|
|
#include "../utun_instance.h"
|
|
#include "../local_transport/protocol.h"
|
|
#include "../routing_layer/topo_group.h"
|
|
#include "../routing_layer/topo_group_connect.h"
|
|
#include "../routing_layer/topo_node_sqlite.h"
|
|
#include "../routing_layer/sock_match.h"
|
|
#include "../transport_layer/etcp.h"
|
|
#include "../transport_layer/etcp_connections.h"
|
|
#include "../transport_layer/node_conn_direct.h"
|
|
#include "../../lib/debug_config.h"
|
|
#include "../../lib/mem.h"
|
|
#include <string.h>
|
|
|
|
void chat_local_peers_trampoline(void* arg) {
|
|
struct UTUN_INSTANCE* inst = arg;
|
|
if (!inst) { DEBUG_ERROR(DEBUG_CATEGORY_DISCOVERY, "device list request without instance"); return; }
|
|
struct local_peer peers[LOCAL_TRANSPORT_PEERS_MAX];
|
|
size_t count = local_transport_peers(inst->local_transport, peers, LOCAL_TRANSPORT_PEERS_MAX), offset = 2;
|
|
uint8_t data[2 + LOCAL_TRANSPORT_PEERS_MAX * (8 + 1 + LOCAL_TRANSPORT_NAME_MAX - 1)];
|
|
data[0] = (uint8_t)(count >> 8); data[1] = (uint8_t)count;
|
|
for (size_t i = 0; i < count; i++) {
|
|
size_t len = strlen(peers[i].name);
|
|
local_put64(data + offset, peers[i].node_id); data[offset + 8] = (uint8_t)len;
|
|
memcpy(data + offset + 9, peers[i].name, len); offset += 9 + len;
|
|
}
|
|
chat_event_post(inst, CHAT_EVT_LOCAL_DEVICES, data, (int)offset);
|
|
}
|
|
|
|
static void peers_changed(void* arg) { chat_local_peers_trampoline(arg); }
|
|
|
|
static int valid_link(const char* link, size_t len) {
|
|
struct InviteData invite = {0};
|
|
char error[128];
|
|
if (!len || len > LOCAL_TRANSPORT_DATA_MAX || memchr(link, 0, len) || len < 7 || memcmp(link, "utun://", 7)) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_DISCOVERY, "invalid local invitation length/prefix bytes=%zu", len); return 0;
|
|
}
|
|
if (invite_link_decode(link, len, &invite, error, sizeof(error)) < 0) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_DISCOVERY, "invalid local invitation: %s", error); return 0;
|
|
}
|
|
static const uint8_t empty_key[INVITE_PUBKEY_SIZE] = {0};
|
|
if (!invite.channelId || !invite.join_key || !invite.addrCount || !memcmp(invite.pubkey, empty_key, sizeof(empty_key))) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_DISCOVERY, "invalid local invitation: missing channel, join key or entry node"); return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int received(void* arg, const struct local_peer* peer, const uint8_t* link, size_t len) {
|
|
struct UTUN_INSTANCE* inst = arg;
|
|
if (!chat_setting_get_int(inst, "local_invites_enabled", 1)) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_DISCOVERY, "local invitation rejected peer=%016llx reason=receiving disabled",
|
|
(unsigned long long)peer->node_id); return LOCAL_DELIVERY_FORBIDDEN;
|
|
}
|
|
if (!inst->chat_event_handler || !valid_link((const char*)link, len)) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_DISCOVERY, "local invitation rejected peer=%016llx handler=%d",
|
|
(unsigned long long)peer->node_id, inst->chat_event_handler != NULL); return -1;
|
|
}
|
|
uint8_t data[9 + LOCAL_TRANSPORT_NAME_MAX + LOCAL_TRANSPORT_DATA_MAX];
|
|
size_t name_len = strlen(peer->name);
|
|
local_put64(data, peer->node_id); data[8] = (uint8_t)name_len;
|
|
memcpy(data + 9, peer->name, name_len); memcpy(data + 9 + name_len, link, len);
|
|
chat_event_post(inst, CHAT_EVT_LOCAL_INVITE, data, (int)(9 + name_len + len));
|
|
return 0;
|
|
}
|
|
|
|
static void delivered(void* arg, uint64_t request, uint64_t peer, int status) {
|
|
uint8_t data[17];
|
|
local_put64(data, request); local_put64(data + 8, peer); data[16] = (uint8_t)status;
|
|
chat_event_post(arg, CHAT_EVT_LOCAL_DELIVERY, data, sizeof(data));
|
|
}
|
|
|
|
static void activity_changed(void* arg, int active) {
|
|
uint8_t value = active != 0;
|
|
chat_event_post(arg, CHAT_EVT_LOCAL_DISCOVERY_ACTIVE, &value, 1);
|
|
}
|
|
|
|
static void activity(struct UTUN_INSTANCE* inst, int active, void* arg) {
|
|
(void)arg;
|
|
if (local_transport_set_active(inst->local_transport, inst->client_type != CLIENT_TYPE_MOBILE || active) < 0)
|
|
DEBUG_ERROR(DEBUG_CATEGORY_DISCOVERY, "failed to apply discovery activity node=%016llx", (unsigned long long)inst->node_id);
|
|
}
|
|
|
|
/* Только принимающие рабочие endpoints этого IP; скрытые и SOCKS/probe-сокеты не публикуются. */
|
|
static int route_sockets(void* arg, const struct sockaddr_storage* address, uint32_t index,
|
|
struct local_route_socket* out, size_t capacity) {
|
|
struct UTUN_INSTANCE* inst = arg;
|
|
size_t count = 0;
|
|
for (struct ETCP_SOCKET* sock = inst->etcp_sockets; sock; sock = sock->next) {
|
|
if (sock->type == CFG_SERVER_TYPE_PRIVATE || !sock_matches_lan(sock, address, index)) continue;
|
|
uint16_t port = ss_get_port(&sock->local_addr);
|
|
if (!port || !sock->generation) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_DISCOVERY, "LAN socket omitted name=%s id=%u port=%u generation=%016llx",
|
|
sock->name, sock->sock_id, port, (unsigned long long)sock->generation); continue;
|
|
}
|
|
if (count == capacity) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_DISCOVERY, "too many LAN sockets interface=%u capacity=%zu", index, capacity); return -1;
|
|
}
|
|
out[count++] = (struct local_route_socket){ .socket_id = sock->sock_id, .generation = sock->generation,
|
|
.port = port, .protocol = sock->is_tcp ? LOCAL_ROUTE_TCP | (sock->reality_enabled ? LOCAL_ROUTE_REALITY : 0) : LOCAL_ROUTE_UDP };
|
|
}
|
|
return (int)count;
|
|
}
|
|
|
|
/* Ключи не покидают ядро; wire magic/version/type отделяют эту подпись от других протоколов. */
|
|
static int route_sign(void* arg, const uint8_t* data, size_t len, uint8_t signature[64]) {
|
|
struct UTUN_INSTANCE* inst = arg;
|
|
if (inst->node_id != sc_derive_node_id_from_pubkey(inst->my_keys.public_key) ||
|
|
sc_ed25519_sign(inst->my_ed25519_privkey, data, len, signature) != SC_OK) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_DISCOVERY, "LAN endpoint signing failed node=%016llx", (unsigned long long)inst->node_id); return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Отсутствие ключа не мешает открытому discovery, но не даёт адрес для NCD. */
|
|
static int route_verify(void* arg, uint64_t peer, const uint8_t* data, size_t len, const uint8_t signature[64]) {
|
|
struct UTUN_INSTANCE* inst = arg;
|
|
uint8_t key[32];
|
|
struct TOPO_NODE* node = topo_node_registry_find(inst->topo_groups, peer);
|
|
if (node && node->timestamp) memcpy(key, node->ed25519_public_key, sizeof(key));
|
|
else if (!inst->topo_sqlite_db || topo_node_sqlite_get_ed25519_pubkey(inst->topo_sqlite_db, peer, key)) {
|
|
DEBUG_DEBUG(DEBUG_CATEGORY_DISCOVERY, "LAN route ignored peer=%016llx reason=unknown signing key", (unsigned long long)peer); return 1;
|
|
}
|
|
if (sc_ed25519_verify(key, data, len, signature) != SC_OK) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_DISCOVERY, "LAN route signature rejected peer=%016llx", (unsigned long long)peer); return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Общие адреса узла нельзя заменять, пока доступен прямой транспорт или любой BGP-путь. */
|
|
static int route_offline(void* arg, uint64_t peer) {
|
|
struct UTUN_INSTANCE* inst = arg;
|
|
struct ETCP_CONN* conn = inst->connections ? instance_find_conn(inst, peer) : NULL;
|
|
if (conn && conn->links_up && !conn->close_requested && conn->state != 2) return 0;
|
|
for (struct ll_entry* e = inst->topo_groups && inst->topo_groups->group_list ? inst->topo_groups->group_list->head : NULL;
|
|
e; e = e->next) {
|
|
if (topo_node_best_path(topo_node_find_by_id((struct TOPO_GROUP*)e, peer))) return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/* Обновление помогает уже удерживаемому NCD; право создавать соединение остаётся у сервисов. */
|
|
static void routes_changed(void* arg, uint64_t peer) {
|
|
struct UTUN_INSTANCE* inst = arg;
|
|
if (inst->connections && node_conn_direct_update_local(inst, peer) < 0)
|
|
DEBUG_ERROR(DEBUG_CATEGORY_DISCOVERY, "LAN address application failed peer=%016llx", (unsigned long long)peer);
|
|
for (struct ll_entry* e = inst->topo_groups && inst->topo_groups->group_list ? inst->topo_groups->group_list->head : NULL;
|
|
e; e = e->next) {
|
|
struct TOPO_GROUP* group = (struct TOPO_GROUP*)e;
|
|
if (group->group_type == TOPO_GROUP_TYPE_CHAT && !group->stopping) topo_group_connect_changed(group);
|
|
}
|
|
}
|
|
|
|
int chat_local_start(struct UTUN_INSTANCE* inst) {
|
|
if (inst->local_transport || inst->client_type == CLIENT_TYPE_SERVER) return 0;
|
|
struct local_transport_callbacks callbacks = { .peers_changed = peers_changed, .received = received, .delivery = delivered,
|
|
.activity_changed = activity_changed, .route_sockets = route_sockets, .route_sign = route_sign,
|
|
.route_verify = route_verify, .route_offline = route_offline, .routes_changed = routes_changed };
|
|
inst->local_transport = local_transport_create(inst->ua, inst->node_id, inst->name, &callbacks, inst);
|
|
if (!inst->local_transport) return -1;
|
|
if (chat_local_apply_settings(inst) < 0) { chat_local_stop(inst); return -1; }
|
|
utun_add_activity_cbk(inst, activity, inst);
|
|
activity(inst, inst->client_activity == CLIENT_ACTIVITY_ACTIVE, inst);
|
|
return 0;
|
|
}
|
|
|
|
int chat_local_apply_settings(struct UTUN_INSTANCE* inst) {
|
|
if (!inst || !inst->local_transport) return 0;
|
|
int receive = chat_setting_get_int(inst, "local_invites_enabled", 1);
|
|
int broadcasts = chat_setting_get_int(inst, "local_broadcasts_enabled", 1);
|
|
DEBUG_INFO(DEBUG_CATEGORY_DISCOVERY, "local permissions applied node=%016llx receive_invites=%d broadcast=%d",
|
|
(unsigned long long)inst->node_id, receive, broadcasts);
|
|
return local_transport_set_broadcasts(inst->local_transport, broadcasts);
|
|
}
|
|
|
|
void chat_local_stop(struct UTUN_INSTANCE* inst) {
|
|
if (!inst || !inst->local_transport) return;
|
|
utun_remove_activity_cbk(inst, activity, inst);
|
|
local_transport_destroy(inst->local_transport); inst->local_transport = NULL;
|
|
}
|
|
|
|
void chat_local_send_trampoline(void* arg) {
|
|
struct chat_local_send_request* req = arg;
|
|
if (!req) return;
|
|
size_t len = strnlen(req->link, sizeof(req->link));
|
|
if (!req->inst) { DEBUG_ERROR(DEBUG_CATEGORY_DISCOVERY, "invitation send without instance"); u_free(req); return; }
|
|
if (!valid_link(req->link, len) || local_transport_send(req->inst->local_transport, req->peer_id,
|
|
req->request_id, req->link, len) < 0) delivered(req->inst, req->request_id, req->peer_id, 0);
|
|
u_free(req);
|
|
}
|