Browse Source
- chat_headless_control.c: новая команда invite_to (inviter-side invite по адресам) - chat_client.py / chatcli: клиентский метод и CLI-команда invite_to - tools/chat_invite_test.py: headless-тест инвайтера-side (CHANNEL_INVITE → autojoin → member_sync) - topo: guard node_id=0 в cm_open/process_nodeinfo + детализация send_nodeinfo warn - cleanup: удалить устаревшие doc/*.txt, *.md заметкиtopo_upd
evgeny
2 months ago
22 changed files with 361 additions and 1633 deletions
@ -1,344 +0,0 @@ |
|||||||
Архитектура P2P Direct Connection (установка оптимального подключения между узлами) |
|
||||||
|
|
||||||
Цель: в большой сети узлов каждый узел умеет находить быстрые подключения |
|
||||||
к любому другому узлу — либо прямое (direct), либо через минимальное число |
|
||||||
промежуточных узлов с минимальным суммарным RTT. Оба узла пробуют доступные |
|
||||||
варианты пингом и выбирают лучший. |
|
||||||
|
|
||||||
|
|
||||||
=== Что уже есть в коде (используем, не дублируем) === |
|
||||||
|
|
||||||
1. NODEINFO уже содержит поле tranzit_nodes + структуру NODEINFO_TRANZIT_NODE |
|
||||||
(node_id, rtt, link_q) — "лучшие транзитные узлы, выбирается/обновляется узлом", |
|
||||||
но пока не заполняется и не используется. |
|
||||||
|
|
||||||
2. Пинг-инфраструктура: route_ping_send_req_addr (запрос удалённого пинга через |
|
||||||
третий узел), route_ping_handle_resp (приём результата). Также есть |
|
||||||
etcp_send_ping_to_socket — прямой пинг с конкретного сокета на конкретный адрес |
|
||||||
с pubkey для шифрования. |
|
||||||
|
|
||||||
3. NAT-детекция уже работает: проверка типа NAT через третий узел, обмен NAT_INFO. |
|
||||||
|
|
||||||
4. Path system: NODEINFO_PATH с hop_count, routes → ROUTE_ENTRY → NODEINFO_Q → paths — |
|
||||||
уже выбирается путь для маршрутизации пакетов. |
|
||||||
|
|
||||||
5. Константа ROUTE_SUBCMD_CONN_REQ (0x0B) зарезервирована в route_bgp.h, но не реализована. |
|
||||||
|
|
||||||
6. NODEINFO_Q уже имеет best_socket, last_ping_time, last_rtt. |
|
||||||
|
|
||||||
|
|
||||||
=== Общий алгоритм (на примере узлов A и B) === |
|
||||||
|
|
||||||
A ──(ETCP через релейные узлы)──> B [текущий путь, hop_count > 1] |
|
||||||
|
|
||||||
1. A замечает большой объём трафика к B → запускает CONN_REQ |
|
||||||
2. A шлёт B через существующий ETCP-путь: свои адреса-кандидаты + лучших транзитных соседей |
|
||||||
3. B получает CONN_REQ, сразу начинает пинговать адреса A, собирает свои данные |
|
||||||
4. B шлёт CONN_RESP: свои адреса + транзитных соседей + результаты пробных пингов |
|
||||||
5. A получает CONN_RESP, пингует все адреса B |
|
||||||
6. Оба вычисляют лучший вариант (прямой или релейный с минимальным RTT) |
|
||||||
7. Оба шлют друг другу CONN_RESULT с выбором |
|
||||||
8. Оба пытаются создать ETCP link к выбранному адресу (если прямой) |
|
||||||
9. Лишние/худшие линки закрываются позже — все линки в рамках одного ETCP_CONN |
|
||||||
|
|
||||||
|
|
||||||
=== Фаза 1: Обмен кандидатами (CONN_REQ → CONN_RESP) === |
|
||||||
|
|
||||||
Узел-инициатор A собирает и отправляет: |
|
||||||
- Свои адреса-кандидаты: из своих ETCP_SOCKET (interface_addr + nat_addr). |
|
||||||
Включаются только сокеты с NAT_VERIFIED_* / EIM / PUBLIC (type >= NAT_VERIFIED_UNKNOWN). |
|
||||||
Для каждого: ip, port, type, socket_id. |
|
||||||
- Лучших транзитных соседей: top-N directly-connected узлов (hop_count == 1) |
|
||||||
отсортированных по NODEINFO_Q.last_rtt (лучший RTT первым). |
|
||||||
|
|
||||||
Узел B при получении CONN_REQ: |
|
||||||
- Сохраняет кандидатов A |
|
||||||
- Сразу запускает пробные пинги ко всем адресам A (etcp_send_ping_to_socket с pubkey) |
|
||||||
- Собирает свои адреса-кандидаты |
|
||||||
- Собирает своих транзитных соседей |
|
||||||
- Шлёт CONN_RESP со своими данными + уже готовыми результатами проб |
|
||||||
|
|
||||||
|
|
||||||
=== Фаза 2: Пробы (CONN_RESP → Пинги) === |
|
||||||
|
|
||||||
Узел A при получении CONN_RESP: |
|
||||||
- Запускает пинги ко всем адресам B: |
|
||||||
каждый адрес B пингуется с каждого своего сокета (N×M проб) |
|
||||||
- Использует etcp_send_ping_to_socket с pubkey узла B (из NODEINFO) |
|
||||||
- Пинг идёт напрямую по UDP (не через ETCP) — проверяет реальную достижимость |
|
||||||
включая NAT traversal |
|
||||||
- Ждёт все результаты либо таймаут |
|
||||||
|
|
||||||
Параллельно B тоже завершает свои пробы (запущенные на шаге 3). |
|
||||||
|
|
||||||
|
|
||||||
=== Фаза 3: Выбор лучшего пути (→ CONN_RESULT) === |
|
||||||
|
|
||||||
Каждая сторона независимо вычисляет: |
|
||||||
|
|
||||||
best = {mode: none, rtt: 65535} |
|
||||||
|
|
||||||
Прямые варианты: |
|
||||||
for each (мой_сокет, peer_addr) где probe.ok: |
|
||||||
if probe.rtt < best.rtt: |
|
||||||
best = {direct, my_sock_idx, peer_addr_idx, probe.rtt} |
|
||||||
|
|
||||||
Релейные варианты: |
|
||||||
for each общий_транзитный_узел R (доступен и A и B): |
|
||||||
// RTT(A↔R) берём из своих замеров (A знает RTT до своих соседей) |
|
||||||
// RTT(R↔B) берём из транзитных соседей B (присланы в CONN_RESP) |
|
||||||
total_rtt = A→R_rtt + R→B_rtt |
|
||||||
if total_rtt < best.rtt: |
|
||||||
best = {relay, R, total_rtt} |
|
||||||
|
|
||||||
Обе стороны приходят к одинаковому выводу (информация симметрична). |
|
||||||
|
|
||||||
Шлют CONN_RESULT с выбором. |
|
||||||
Если прямой вариант — оба пытаются создать ETCP link к адресу пира. |
|
||||||
Если релейный — используют существующий путь (уже работает). |
|
||||||
|
|
||||||
|
|
||||||
=== Триггер запуска negotiation === |
|
||||||
|
|
||||||
В route_pkt (routing.c) при отправке пакета узлу с hop_count > 1: |
|
||||||
- Накапливаем счётчик байт к этому узлу (per-node counter в bgp) |
|
||||||
- При превышении порога (например 64KB) и если negotiation ещё не запущен — стартуем |
|
||||||
- Cooldown: не чаще чем раз в 30 секунд для одной пары узлов |
|
||||||
- Если negotiation уже в процессе для этой пары — не дублируем |
|
||||||
|
|
||||||
|
|
||||||
=== Tranzit nodes — автоматическое заполнение === |
|
||||||
|
|
||||||
В route_bgp_update_my_nodeinfo (route_node.c) при каждом обновлении NODEINFO: |
|
||||||
- Сканируем directly-connected соседей (из bgp->nodes, где hop_count == 1) |
|
||||||
- Сортируем по NODEINFO_Q.last_rtt (лучший RTT первым) |
|
||||||
- Берём top-N (до 4) и упаковываем в NODEINFO.tranzit_nodes как массив |
|
||||||
NODEINFO_TRANZIT_NODE (node_id, rtt, link_q) |
|
||||||
|
|
||||||
Плюс периодический refill (раз в ~10 сек) для свежести RTT замеров. |
|
||||||
|
|
||||||
|
|
||||||
=== Структуры данных (новые, route_p2pconn.h) === |
|
||||||
|
|
||||||
#define P2P_MAX_ADDRS 8 |
|
||||||
#define P2P_MAX_RELAYS 8 |
|
||||||
#define P2P_MAX_PROBES (P2P_MAX_ADDRS * P2P_MAX_ADDRS) // до 64 |
|
||||||
|
|
||||||
#define P2P_PHASE_WAIT_RESP 0 // ждём CONN_RESP от пира |
|
||||||
#define P2P_PHASE_PROBING 1 // пингуем адреса пира |
|
||||||
#define P2P_PHASE_SELECTING 2 // выбор лучшего, отправка CONN_RESULT |
|
||||||
#define P2P_PHASE_DONE 3 // завершено |
|
||||||
|
|
||||||
// Один адрес-кандидат |
|
||||||
struct P2P_ADDR { |
|
||||||
uint32_t ip; // network byte order |
|
||||||
uint16_t port; |
|
||||||
uint8_t type; // NAT_VERIFIED_* |
|
||||||
uint8_t socket_id; |
|
||||||
}; |
|
||||||
|
|
||||||
// Один транзитный узел |
|
||||||
struct P2P_RELAY { |
|
||||||
uint64_t node_id; |
|
||||||
uint16_t rtt; // x0.1ms |
|
||||||
uint16_t link_q; |
|
||||||
}; |
|
||||||
|
|
||||||
// Результат одного пробного пинга |
|
||||||
struct P2P_PROBE_RESULT { |
|
||||||
uint8_t my_sock_idx; // индекс в my_addrs[] |
|
||||||
uint8_t peer_addr_idx; // индекс в peer_addrs[] |
|
||||||
uint16_t rtt; // x0.1ms, 0 = fail |
|
||||||
}; |
|
||||||
|
|
||||||
// Состояние одних переговоров (хранится в хеш-таблице bgp->p2p_negotiations) |
|
||||||
struct P2P_NEGOTIATION { |
|
||||||
struct ll_entry ll; |
|
||||||
uint32_t request_id; |
|
||||||
uint64_t peer_node_id; |
|
||||||
uint8_t phase; |
|
||||||
|
|
||||||
// Мои данные |
|
||||||
struct P2P_ADDR my_addrs[P2P_MAX_ADDRS]; |
|
||||||
uint8_t my_addr_count; |
|
||||||
struct P2P_RELAY my_relays[P2P_MAX_RELAYS]; |
|
||||||
uint8_t my_relay_count; |
|
||||||
|
|
||||||
// Данные пира (заполняются из CONN_RESP) |
|
||||||
struct P2P_ADDR peer_addrs[P2P_MAX_ADDRS]; |
|
||||||
uint8_t peer_addr_count; |
|
||||||
struct P2P_RELAY peer_relays[P2P_MAX_RELAYS]; |
|
||||||
uint8_t peer_relay_count; |
|
||||||
|
|
||||||
// Результаты проб |
|
||||||
struct P2P_PROBE_RESULT probes[P2P_MAX_PROBES]; |
|
||||||
uint8_t probe_total; // сколько всего запланировано |
|
||||||
uint8_t probe_done; // сколько завершилось (ok + fail) |
|
||||||
|
|
||||||
// Лучший выбор |
|
||||||
uint8_t best_mode; // 1=direct, 2=relay |
|
||||||
uint64_t best_relay; // node_id релея (если mode=relay) |
|
||||||
uint16_t best_rtt; // x0.1ms |
|
||||||
uint8_t best_my_sock_idx; // индекс в my_addrs (если direct) |
|
||||||
uint8_t best_peer_addr_idx;// индекс в peer_addrs (если direct) |
|
||||||
|
|
||||||
void* timeout_timer; // общий таймаут на всю negotiation |
|
||||||
}; |
|
||||||
|
|
||||||
// Счётчик трафика per-node (для триггера, хранится в bgp) |
|
||||||
struct P2P_TRAFFIC_COUNTER { |
|
||||||
uint64_t node_id; |
|
||||||
uint64_t bytes_sent; // накоплено байт |
|
||||||
uint64_t last_negotiation_time; // время последней попытки (0 = не было) |
|
||||||
}; |
|
||||||
|
|
||||||
|
|
||||||
=== Протокольные пакеты (добавляются в route_bgp.h) === |
|
||||||
|
|
||||||
ROUTE_SUBCMD_CONN_REQ 0x0B // запрос прямого подключения (уже зарезервирован) |
|
||||||
ROUTE_SUBCMD_CONN_RESP 0x0C // ответ с адресами + результаты проб |
|
||||||
ROUTE_SUBCMD_CONN_RESULT 0x0E // финальный выбор |
|
||||||
|
|
||||||
// Пакет CONN_REQ (A → B) |
|
||||||
struct BGP_CONN_REQ { |
|
||||||
uint8_t cmd; // ETCP_ID_ROUTE_ENTRY |
|
||||||
uint8_t subcmd; // ROUTE_SUBCMD_CONN_REQ |
|
||||||
uint32_t request_id; // для корреляции |
|
||||||
uint8_t addr_count; // число адресов-кандидатов |
|
||||||
uint8_t relay_count; // число транзитных узлов |
|
||||||
uint8_t reserved[2]; |
|
||||||
// далее динамически (размер = addr_count*8 + relay_count*12): |
|
||||||
// [addr_count × {ip[4] port[2] type[1] socket_id[1]}] |
|
||||||
// [relay_count × {node_id[8] rtt[2] link_q[2]}] |
|
||||||
}; |
|
||||||
|
|
||||||
// Пакет CONN_RESP (B → A) |
|
||||||
struct BGP_CONN_RESP { |
|
||||||
uint8_t cmd; // ETCP_ID_ROUTE_ENTRY |
|
||||||
uint8_t subcmd; // ROUTE_SUBCMD_CONN_RESP |
|
||||||
uint32_t request_id; |
|
||||||
uint8_t addr_count; // адреса B |
|
||||||
uint8_t relay_count; // транзитные узлы B |
|
||||||
uint8_t probe_count; // готовые результаты проб B→A |
|
||||||
uint8_t reserved; |
|
||||||
// [addr_count × {ip[4] port[2] type[1] socket_id[1]}] |
|
||||||
// [relay_count × {node_id[8] rtt[2] link_q[2]}] |
|
||||||
// [probe_count × {peer_addr_idx[1] my_sock_idx[1] rtt[2] ok[1]}] |
|
||||||
}; |
|
||||||
|
|
||||||
// Пакет CONN_RESULT (A ↔ B, финальный) |
|
||||||
struct BGP_CONN_RESULT { |
|
||||||
uint8_t cmd; |
|
||||||
uint8_t subcmd; // ROUTE_SUBCMD_CONN_RESULT |
|
||||||
uint32_t request_id; |
|
||||||
uint8_t chosen_mode; // 1=direct, 2=relay |
|
||||||
uint8_t reserved; |
|
||||||
uint16_t chosen_rtt; // x0.1ms |
|
||||||
// Если direct: |
|
||||||
uint32_t peer_ip; // IP пира к которому подключаемся |
|
||||||
uint16_t peer_port; |
|
||||||
uint8_t my_socket_id; // свой сокет для подключения |
|
||||||
uint8_t peer_socket_id; // сокет пира |
|
||||||
// Если relay (оверлей тех же байт): |
|
||||||
// uint64_t relay_node_id; |
|
||||||
}; |
|
||||||
|
|
||||||
|
|
||||||
=== API модуля route_p2pconn === |
|
||||||
|
|
||||||
// Запуск negotiation к узлу peer_node_id. |
|
||||||
// Вызывается из route_pkt при превышении порога трафика. |
|
||||||
int p2p_start_negotiation(struct ROUTE_BGP* bgp, uint64_t peer_node_id); |
|
||||||
|
|
||||||
// Проверка: запущена ли уже negotiation для этой пары |
|
||||||
int p2p_is_negotiating(struct ROUTE_BGP* bgp, uint64_t peer_node_id); |
|
||||||
|
|
||||||
// Сбор своих адресов-кандидатов (из etcp_sockets) |
|
||||||
int p2p_collect_my_addrs(struct ROUTE_BGP* bgp, struct P2P_ADDR* out, uint8_t max); |
|
||||||
|
|
||||||
// Сбор лучших транзитных соседей (из directly-connected nodes) |
|
||||||
int p2p_collect_my_relays(struct ROUTE_BGP* bgp, struct P2P_RELAY* out, uint8_t max); |
|
||||||
|
|
||||||
// Обработчики входящих пакетов (вызываются из route_bgp_receive_cbk): |
|
||||||
void p2p_handle_conn_req(struct ROUTE_BGP* bgp, struct ETCP_CONN* from, |
|
||||||
const uint8_t* data, size_t len); |
|
||||||
void p2p_handle_conn_resp(struct ROUTE_BGP* bgp, struct ETCP_CONN* from, |
|
||||||
const uint8_t* data, size_t len); |
|
||||||
void p2p_handle_conn_result(struct ROUTE_BGP* bgp, struct ETCP_CONN* from, |
|
||||||
const uint8_t* data, size_t len); |
|
||||||
|
|
||||||
// Отмена negotiation при удалении conn |
|
||||||
void p2p_cancel_for_conn(struct ROUTE_BGP* bgp, struct ETCP_CONN* conn); |
|
||||||
|
|
||||||
// Очистка всех negotiation (при destroy bgp) |
|
||||||
void p2p_destroy_all(struct ROUTE_BGP* bgp); |
|
||||||
|
|
||||||
|
|
||||||
=== Схема состояний negotiation === |
|
||||||
|
|
||||||
IDLE ──(трафик > порог)──→ WAIT_RESP ──(CONN_RESP получен)──→ PROBING |
|
||||||
↑ ↑ │ |
|
||||||
│ (таймаут) (все пробы готовы) |
|
||||||
│ ↓ │ |
|
||||||
└──────────────────────────── DONE ←──(CONN_RESULT отправлен)── SELECTING |
|
||||||
|
|
||||||
|
|
||||||
=== Интеграция (какие файлы меняются) === |
|
||||||
|
|
||||||
Новые файлы: |
|
||||||
src/route_p2pconn.h — структуры, константы, прототипы |
|
||||||
src/route_p2pconn.c — вся логика negotiation |
|
||||||
|
|
||||||
Изменения в существующих: |
|
||||||
src/route_bgp.h — добавить ROUTE_SUBCMD_CONN_RESP 0x0C, |
|
||||||
ROUTE_SUBCMD_CONN_RESULT 0x0E, |
|
||||||
структуры пакетов BGP_CONN_REQ/RESP/RESULT |
|
||||||
src/route_bgp.c — в route_bgp_receive_cbk добавить обработку |
|
||||||
новых subcmd. В struct ROUTE_BGP добавить |
|
||||||
поле p2p_negotiations (очередь/хеш negotiation) |
|
||||||
и p2p_traffic_counters (per-node counters) |
|
||||||
src/route_node.c — в route_bgp_update_my_nodeinfo заполнять |
|
||||||
tranzit_nodes из RTT directly-connected соседей |
|
||||||
src/routing.c — в route_pkt добавить накопление счётчика трафика |
|
||||||
и вызов p2p_start_negotiation при превышении порога |
|
||||||
src/Makefile.am — добавить route_p2pconn.c в сборку |
|
||||||
|
|
||||||
|
|
||||||
=== Внутренняя логика route_p2pconn.c === |
|
||||||
|
|
||||||
p2p_start_negotiation(bgp, peer_node_id): |
|
||||||
1. Проверить что нет активной negotiation для этой пары |
|
||||||
2. Проверить cooldown (30 сек) |
|
||||||
3. Создать struct P2P_NEGOTIATION, заполнить my_addrs, my_relays |
|
||||||
4. Сформировать BGP_CONN_REQ и отправить через существующий путь к пиру |
|
||||||
5. Поставить таймаут на всю negotiation (например 5 сек) |
|
||||||
|
|
||||||
p2p_handle_conn_req(bgp, from_conn, data, len): |
|
||||||
1. Распарсить BGP_CONN_REQ |
|
||||||
2. Сохранить адреса и релеи инициатора в P2P_NEGOTIATION |
|
||||||
3. Собрать свои my_addrs, my_relays |
|
||||||
4. Запустить пробные пинги к адресам инициатора (p2p_start_probes) |
|
||||||
5. Когда пробы готовы — отправить CONN_RESP с результатами |
|
||||||
|
|
||||||
p2p_start_probes(neg): |
|
||||||
1. Для каждой пары (мой_сокет, peer_addr) запланировать пинг |
|
||||||
2. Вызвать etcp_send_ping_to_socket с pubkey пира |
|
||||||
3. В коллбэке сохранить результат в probes[], инкрементировать probe_done |
|
||||||
4. Когда probe_done == probe_total → вызвать p2p_select_best |
|
||||||
|
|
||||||
p2p_select_best(neg): |
|
||||||
1. Прямые: найти пару (my_sock, peer_addr) с минимальным rtt > 0 |
|
||||||
2. Релейные: для каждого общего транзитного узла посчитать суммарный rtt, |
|
||||||
найти минимум |
|
||||||
3. Сравнить прямой vs релейный лучший rtt |
|
||||||
4. Записать выбор в neg->best_* |
|
||||||
5. Отправить CONN_RESULT пиру |
|
||||||
6. Вызвать p2p_establish_link(neg) |
|
||||||
|
|
||||||
p2p_establish_link(neg): |
|
||||||
1. Если best_mode == direct: |
|
||||||
- Найти/создать ETCP_CONN к пиру (по node_id) |
|
||||||
- Вызвать etcp_link_new с chosen address |
|
||||||
2. Если best_mode == relay: |
|
||||||
- Ничего не делаем, существующий путь уже работает |
|
||||||
3. Пометить negotiation как DONE |
|
||||||
@ -1,22 +0,0 @@ |
|||||||
Архитектура таблицы c быстрой репликацией между несколькими узлами: |
|
||||||
|
|
||||||
1. В конец таблицы каждый узел может самостоятельно добавлять данные (со своим timestamp, желательно время правильное) |
|
||||||
2. узлы между собой синхронизируются, распространяя обновления по соседям |
|
||||||
|
|
||||||
3. TTL: изменение имеет время жизни. узел удаляет собственные записи которые не были отправлены никому в течении суток |
|
||||||
|
|
||||||
4. Формат записи: |
|
||||||
|
|
||||||
ID (64bit monotonic autoincrement) |
|
||||||
chain_hash (256bit) - цепочка хешей. считается так: chain_hash[index+1]=hash(chain_hash[index],ID[index],timestamp[index],datahash[index]). если хеш совпадает - это признак того что все строки выше синхронизированы. |
|
||||||
timestamp (64bit) - время создания записи. строки должны сортироваться по возрастанию concat(datahash(младшая часть числа,64 bit)+timestamp(старшая часть)) |
|
||||||
datahash (64bit) - хеш данных этой строки |
|
||||||
data (varchar) - данные в формате json |
|
||||||
|
|
||||||
алгоритм репликации (2 узла): |
|
||||||
узел A запрашивает синхронизацию и передает свой last id |
|
||||||
test_id= min(mast id, peer last id) |
|
||||||
узел B передает: test_id, chain_hash(test id), hash(test id-1), hash(test id-2), hash(test id-4), hash(test id-8) итд 16,32,..., до первого элемента включитально (лимитируем вылетевший индекс первым элементом) |
|
||||||
узел A - сравнивает, находит проверяемый диапазон id, отправляет другому узлу 16 (можно больше) хешей (линейно разбив проверяемый диапазон на более короткие поддиапазоны). таким образом узлы уточняют первый ид который не совпал. |
|
||||||
Когда первая различающияся запись найдена, узел отправляет хеш этой и n (например 32) последующих записей (если записей много). если записей мало (<4) то узел отправляет сразу содержимое записей. |
|
||||||
(надо додумать алгоритм, чтобы оптимизировать количество итераций - лучше передать больше данных за раз чем много итераций с ожиданием ответной стороны) |
|
||||||
@ -1,224 +0,0 @@ |
|||||||
# db_sync — Distributed append-only table with SQLite + P2P sync |
|
||||||
|
|
||||||
## 1. Назначение |
|
||||||
|
|
||||||
Реплицировать append-only таблицу JSON-записей между всеми пирами P2P-сети. Каждый пир в итоге должен иметь идентичный набор записей. Модуль поддерживает несколько независимых инстансов (таблиц), каждый идентифицируется хешем `SHA256(name || id_be)[0:8]`. |
|
||||||
|
|
||||||
## 2. Ключевые свойства |
|
||||||
|
|
||||||
- **Криптографическая цепь.** `chain_hash[N] = SHA256(chain_hash[N-1] || id || timestamp || author || author_signature)`. Записи упорядочены `ORDER BY timestamp, author_signature`. Первые 8 байт — `chain_hash8` — используется для быстрого сравнения в протоколе. |
|
||||||
- **Ed25519-подписи.** Каждая запись подписана автором. Записи без подписи или с неверной подписью отвергаются. |
|
||||||
- **Append-only.** Записи не редактируются и не удаляются явно, только TTL-очистка собственных неотправленных записей. |
|
||||||
- **PUSH — мгновенная доставка.** При локальном `insert_signed` запись немедленно шлётся всем пирам с `sync_state >= 1` (steady state). |
|
||||||
- **Sync — сравнение цепей.** При старте/реконнекте стороны обмениваются хешами цепей для поиска расхождений. |
|
||||||
- **Multi-instance.** Несколько независимых таблиц внутри одного процесса (разные hash). |
|
||||||
|
|
||||||
## 3. Архитектура протокола |
|
||||||
|
|
||||||
### 3.1. На что оптимизирован |
|
||||||
|
|
||||||
99% времени новые записи просто дописываются в конец. Самый частый сценарий — пир A добавил сообщение, пир B получил его и вставил в конец своей цепи. Протокол должен: |
|
||||||
- Доставлять новые записи немедленно (PUSH) |
|
||||||
- При реконнекте быстро понять "у нас всё совпадает до позиции N, добрось хвост" (hash_MATCH) |
|
||||||
- При реальном расхождении бинарным поиском найти точку и слить (divergence + REFINE) |
|
||||||
|
|
||||||
### 3.2. Общие идеи реализации |
|
||||||
|
|
||||||
**Криптографическая цепь** — гарантия целостности. Если `chain_hash8(N)` совпадает на двух пирах, цепь идентична до позиции N (вероятность коллизии 2^-64). При вставке не в конец — каскадный пересчёт `chain_hash` всех последующих записей через `db_cascade_from`. |
|
||||||
|
|
||||||
**PUSH** — рабочий механизм доставки в steady state. Запись, вставленная локально, немедленно уходит всем синхронизированным пирам. ACK_PUSH подтверждает получение и обновляет delivery_chain. |
|
||||||
|
|
||||||
**Sync** — полное сравнение цепей при старте/реконнекте. Три ветки: peer_empty (пир пуст — отдать всё), hash_MATCH (цепи совпали до позиции N — отдать хвост), divergence (цепи разошлись — найти точку расхождения). |
|
||||||
|
|
||||||
**Sparse checkpoints** — бинарный поиск расхождения. INIT_RESP возвращает хеши в степенях двойки от tp (tp-1, tp-2, tp-4, ..., до 16 шт). Это позволяет за O(log N) сравнений сузить диапазон, не передавая хеш каждой записи. |
|
||||||
|
|
||||||
**REFINE** — финальное сужение. Если sparse-хешей INIT_RESP недостаточно (диапазон >1), REFINE запрашивает до 16 дополнительных хешей. Когда диапазон ≤1 — сразу SEND_DATA. |
|
||||||
|
|
||||||
**Каскадное уведомление.** При вставке записи не в конец `synced_pos` всех остальных пиров сбрасывается до позиции вставки — им потребуется пересинхронизация. |
|
||||||
|
|
||||||
### 3.3. Фазы протокола |
|
||||||
|
|
||||||
**Фаза А — Инициализация.** `db_sync_instance_add` читает таблицу из SQLite, проверяет целостность цепи (`db_verify_chain` — автофикс при расхождении), и немедленно шлёт `INIT_SYNC(my_count)` всем подключённым пирам с `sync_state == 0`. Если связь появилась позже — `conn_up` делает то же самое. |
|
||||||
|
|
||||||
**Фаза Б — Сравнение цепей.** Получатель INIT_SYNC вычисляет `tp = min(my_count, peer_count)`, tp-- если >0 (последняя гарантированно общая позиция), и возвращает INIT_RESP: `peer_ch8` на позиции tp, `sc` (количество sparse-хешей), sparse-хеши на позициях tp-2^k. |
|
||||||
|
|
||||||
**Фаза В — Три ветки:** |
|
||||||
|
|
||||||
| Ветка | Условие | Сценарий | Действие | |
|
||||||
|-------|---------|----------|----------| |
|
||||||
| peer_empty | `peer_ch8==0 && sc==0` | Пир пуст (0 записей) | Отправить все свои записи через SEND_DATA | |
|
||||||
| hash_MATCH | `my_ch8 == peer_ch8` | Цепи идентичны до tp | Отправить хвост [tp+1..mc) через SEND_DATA | |
|
||||||
| divergence | `my_ch8 != peer_ch8` | Разные истории | Анализ sparse-хешей → REFINE → SEND_DATA | |
|
||||||
|
|
||||||
**Фаза Г — REFINE.** Инициатор анализирует sparse-хеши: `ds` — последняя совпавшая позиция, `de` — первая разошедшаяся. Если `de-ds ≤ 1` → сразу SEND_DATA (hc=0). Иначе → REFINE с до 16 своих хешей, равномерно распределённых в [ds..de]. Получатель сравнивает со своей цепью, находит точку совпадения, шлёт SEND_DATA от этой точки. |
|
||||||
|
|
||||||
**Фаза Д — SEND_DATA.** Получатель вставляет записи с проверкой Ed25519-подписи, делает `db_cascade_from(fix_from)`, уведомляет остальных пиров о сдвиге цепи (сброс их synced_pos). Если у получателя после вставки записей больше чем у отправителя — proactive push-back (шлёт свой хвост). Когда все записи получены → SYNC_DONE с итоговым count и chain_hash8. |
|
||||||
|
|
||||||
**Фаза Е — SYNC_DONE.** Сравнение итогового count и chain_hash8. Не совпало — ретрай всей процедуры с начала (до 3 раз, потом give up с partial sync). Совпало — `sync_state=2`, синхронизация завершена. |
|
||||||
|
|
||||||
### 3.4. PUSH — отдельный от sync механизм |
|
||||||
|
|
||||||
PUSH матчится по `hash` — если у пира нет si с таким же hash, PUSH не доставляется. Это позволяет изолировать тестирование sync-протокола от PUSH: вставлять данные через si с уникальным hash (PUSH не уходит — нет получателя), затем удалять tmp si (данные в SQLite сохраняются), создавать si с общим hash — instance_add запускает чистый sync. |
|
||||||
|
|
||||||
## 4. Peer management |
|
||||||
|
|
||||||
- При поднятии ETCP-соединения для каждого инстанса добавляется `SI_PEER` и запускается синхронизация. |
|
||||||
- При разрыве соединения `sync_state` пира сбрасывается в 0. |
|
||||||
- `peer_check` таймер (каждые 5с) перебирает активных пиров и запускает синхронизацию для тех, у кого `sync_state == 0`. Выбирается пир с минимальным `synced_pos` — двигаемся от самого старого несинхронизированного участка. |
|
||||||
- PUSH рассылается только пирам в состоянии `sync_state >= 1`. |
|
||||||
|
|
||||||
## 5. Сообщения протокола |
|
||||||
|
|
||||||
| Сообщение | Wire-формат | Описание | |
|
||||||
|-----------|-------------|----------| |
|
||||||
| `INIT_SYNC (0x01)` | `[type:1][count:4]` | Инициатор шлёт количество записей | |
|
||||||
| `INIT_RESP (0x02)` | `[type:1][tp:4][ch8:8][sc:1][(pos:4,ch8:8)*sc]` | tp, chain_hash8 на tp, sc sparse-хешей | |
|
||||||
| `REFINE (0x03)` | `[type:1][from:4][to:4][hc:1][(pos:4,ch8:8)*hc]` | hc=0 → сразу SEND_DATA; hc>0 → до 16 хешей в диапазоне | |
|
||||||
| `SEND_DATA (0x04)` | `[type:1][from:4][count:2][(id:8,ts:8,author:8,dlen:4,data,sig_len:1,sig)*count]` | Пакет до 32 записей | |
|
||||||
| `PUSH (0x05)` | `[type:1][id:8][ts:8][author:8][dlen:4][data][sig_len:1=64][sig:64]` | Рассылка одной записи synced-пирам | |
|
||||||
| `ACK_PUSH (0x06)` | `[type:1][ts:8][author:8]` | Подтверждение PUSH, обновление delivery_chain | |
|
||||||
| `SYNC_DONE (0x07)` | `[type:1][count:4][ch8:8]` | Финальный count + chain_hash8 | |
|
||||||
| `ERROR (0x08)` | `[type:1][code:1]` | Коды: 0x01=NOT_FOUND, 0x02=DISABLED | |
|
||||||
|
|
||||||
Все сообщения маршрутизируются через ETCP service `0x20` с префиксом `[svc:1][hash_be:8][payload]`. |
|
||||||
|
|
||||||
## 6. Wire-формат записи |
|
||||||
|
|
||||||
`[id:8][ts:8][author_node_id:8][dlen:4][data:json][sig_len:1=64][sig:ed25519:64]` |
|
||||||
|
|
||||||
Дубликаты определяются по `(timestamp, author_signature)`. |
|
||||||
|
|
||||||
## 7. Структуры данных |
|
||||||
|
|
||||||
```c |
|
||||||
struct DB_SYNC { |
|
||||||
struct UTUN_INSTANCE* inst; |
|
||||||
sqlite3* db; |
|
||||||
uint8_t shared_db; |
|
||||||
uint64_t last_connected_tb; |
|
||||||
struct DB_SYNC_INSTANCE* instances; |
|
||||||
int instance_count, instance_capacity; |
|
||||||
void* peer_check_timer; |
|
||||||
uint8_t enabled; |
|
||||||
}; |
|
||||||
|
|
||||||
struct DB_SYNC_INSTANCE { |
|
||||||
struct DB_SYNC* db_sync; |
|
||||||
uint64_t hash; |
|
||||||
char table_name[64]; |
|
||||||
uint64_t next_id; |
|
||||||
uint64_t last_timestamp_ms; |
|
||||||
uint8_t enabled; |
|
||||||
void* ttl_timer; |
|
||||||
struct SI_PEER* peers; |
|
||||||
int peer_count, peer_capacity; |
|
||||||
db_sync_insert_cb on_insert; |
|
||||||
void* on_insert_arg; |
|
||||||
}; |
|
||||||
|
|
||||||
struct SI_PEER { |
|
||||||
uint64_t node_id; |
|
||||||
uint32_t synced_pos; // последняя общая позиция (0-based) |
|
||||||
uint8_t sync_state; // 0=idle, 1=syncing, 2=synced |
|
||||||
uint8_t sync_retry_count; // счётчик retry SYNC_DONE mismatch |
|
||||||
uint64_t sync_start_tb; // время начала sync (для timeout) |
|
||||||
}; |
|
||||||
``` |
|
||||||
|
|
||||||
## 8. API |
|
||||||
|
|
||||||
### Глобальный жизненный цикл |
|
||||||
|
|
||||||
```c |
|
||||||
int db_sync_init(struct UTUN_INSTANCE* inst); |
|
||||||
void db_sync_destroy(struct UTUN_INSTANCE* inst); |
|
||||||
``` |
|
||||||
|
|
||||||
`db_sync_init` — открывает SQLite по пути `<db_path>/chats.db`, биндит ETCP service `0x20`, вешает коллбэки соединений, стартует `peer_check` таймер (5с). Если `db_sync_enabled = 0` — disabled-режим. |
|
||||||
|
|
||||||
`db_sync_destroy` — отменяет таймеры, анбиндит сервис, снимает коллбэки, закрывает SQLite. |
|
||||||
|
|
||||||
### Управление инстансами |
|
||||||
|
|
||||||
```c |
|
||||||
struct DB_SYNC_INSTANCE* db_sync_instance_add(struct UTUN_INSTANCE* inst, const char* table_name, uint64_t hash); |
|
||||||
void db_sync_instance_remove(struct DB_SYNC_INSTANCE* si); |
|
||||||
``` |
|
||||||
|
|
||||||
`db_sync_instance_add` — создаёт/регистрирует инстанс. Создаёт SQLite-таблицу (если нет), читает цепь, `db_verify_chain` (автофикс), стартует TTL-таймер. Если есть подключённые пиры с `sync_state == 0` — немедленно шлёт `INIT_SYNC`. |
|
||||||
|
|
||||||
`db_sync_instance_remove` — деактивирует: `enabled=0`, отменяет TTL-таймер, освобождает peers, удаляет из массива. Таблица БД не удаляется. |
|
||||||
|
|
||||||
### Операции с данными |
|
||||||
|
|
||||||
```c |
|
||||||
int db_sync_insert_signed(struct DB_SYNC_INSTANCE* si, const char* json_data, size_t len, |
|
||||||
const uint8_t* sig, size_t sig_len, uint64_t ts); |
|
||||||
uint32_t db_sync_count(struct DB_SYNC_INSTANCE* si); |
|
||||||
uint64_t db_sync_get_last_timestamp(struct DB_SYNC_INSTANCE* si); |
|
||||||
uint64_t db_sync_next_timestamp(struct DB_SYNC_INSTANCE* si); |
|
||||||
``` |
|
||||||
|
|
||||||
`db_sync_insert_signed` — вставляет подписанную запись. `sig` — 64 байта Ed25519. Проверяет подпись, проверяет дубликат, вычисляет chain_hash, вставляет с каскадным пересчётом, рассылает PUSH synced-пирам. Возвращает: 0=успех, 1=дубликат, -1=ошибка, -2=неверная подпись. |
|
||||||
|
|
||||||
### Чтение |
|
||||||
|
|
||||||
```c |
|
||||||
typedef void (*db_sync_select_cb)(void* arg, uint64_t id, uint64_t timestamp, |
|
||||||
const char* data, size_t data_len, uint64_t author, |
|
||||||
const uint8_t* author_sig, size_t sig_len, |
|
||||||
int delivered_peers, const char* delivery_chain); |
|
||||||
int db_sync_select(struct DB_SYNC_INSTANCE* si, uint32_t offset, uint32_t limit, |
|
||||||
db_sync_select_cb cb, void* arg); |
|
||||||
``` |
|
||||||
|
|
||||||
### Callback на вставку |
|
||||||
|
|
||||||
```c |
|
||||||
typedef void (*db_sync_insert_cb)(struct DB_SYNC_INSTANCE* si, |
|
||||||
uint64_t record_timestamp, |
|
||||||
const char* json_data, size_t len, |
|
||||||
uint64_t author_node_id, void* arg); |
|
||||||
void db_sync_set_insert_cb(struct DB_SYNC_INSTANCE* si, db_sync_insert_cb cb, void* arg); |
|
||||||
``` |
|
||||||
|
|
||||||
### Верификация цепи |
|
||||||
|
|
||||||
```c |
|
||||||
int db_sync_chain_verify(struct DB_SYNC_INSTANCE* si); |
|
||||||
``` |
|
||||||
|
|
||||||
Возвращает 0 если все chain_hash корректны, 1 если расхождение. |
|
||||||
|
|
||||||
## 9. Конфигурация |
|
||||||
|
|
||||||
| Параметр | По умолчанию | Описание | |
|
||||||
|----------|-------------|----------| |
|
||||||
| `db_sync_enabled` | `0` | Включить модуль синхронизации | |
|
||||||
| `db_sync_ttl` | `86400` | TTL неотправленных собственных записей (сек) | |
|
||||||
| `db_path` | — | Путь к БД; файл `<db_path>/chats.db` | |
|
||||||
|
|
||||||
## 10. Константы |
|
||||||
|
|
||||||
| Константа | Значение | Описание | |
|
||||||
|-----------|---------|----------| |
|
||||||
| `ETCP_RT_ID_DB_SYNC` | `0x20` | ETCP service ID | |
|
||||||
| `DB_REFINE_HASHES` | `16` | Макс. хешей в REFINE | |
|
||||||
| `DB_SEND_DATA_MAX` | `32` | Макс. записей в SEND_DATA | |
|
||||||
| `DB_SIG_SIZE` | `64` | Размер Ed25519 подписи | |
|
||||||
| `DB_SYNC_PEER_CHECK_INTERVAL` | `5` | Интервал проверки пиров (сек) | |
|
||||||
| `DB_SYNC_SYNC_TIMEOUT` | `15` | Таймаут ожидания ответа при sync (сек) | |
|
||||||
| `DB_SYNC_TTL_INTERVAL` | `3600` | Интервал TTL-очистки (сек) | |
|
||||||
|
|
||||||
## 11. Тестирование sync-протокола |
|
||||||
|
|
||||||
PUSH доставляет записи немедленно и независимо от sync. Чтобы тестировать чистый sync-протокол, нужно чтобы PUSH не вмешивался: |
|
||||||
|
|
||||||
1. Вставить данные через si с **уникальным hash** — PUSH уходит, но не доставляется (нет получателя с таким hash) |
|
||||||
2. `remove_si()` — данные сохраняются в SQLite, si деактивирован |
|
||||||
3. Создать si с **общим hash** на обеих сторонах — `instance_add` запускает чистый sync-протокол |
|
||||||
|
|
||||||
Этот паттерн используется для тестирования всех трёх веток INIT_RESP: |
|
||||||
- **peer_empty**: одна сторона с данными, другая пустая |
|
||||||
- **hash_MATCH**: обе имеют общий префикс, но у одной больше записей |
|
||||||
- **divergence**: независимые вставки на обеих сторонах до синхронизации |
|
||||||
@ -1,29 +0,0 @@ |
|||||||
Возможности utun: |
|
||||||
|
|
||||||
- роутинг между нодами - напрямую (предпочтительный вариант), или через наилучшего кандидата. |
|
||||||
Наилучший кандидат - узел с минимальным overall score. |
|
||||||
overall score = правило выбираемок пользователем |
|
||||||
% loss multiplier: |
|
||||||
<0.3% - x1 |
|
||||||
<1% - x0.5 |
|
||||||
<5% - x0.2 |
|
||||||
<10% - x0.1 |
|
||||||
> - x0.03 |
|
||||||
- либо minimum delay |
|
||||||
|
|
||||||
Формат данных: |
|
||||||
todo... |
|
||||||
|
|
||||||
tun -> (src/dst ip) -> routing table -> next hop -> transmit to -> etcp -> routing -> tun |
|
||||||
|
|
||||||
routing: выбирает по dst ip next hop. |
|
||||||
next hop = {type + conrol struct}. type= {1-tun, 2-etcp} |
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
control dgram = connect request - если нет прямого соединения |
|
||||||
при установке соединения сервер отправляет ip:port клиенту |
|
||||||
|
|
||||||
routing dgram: |
|
||||||
<routing c.s.> -> <type, dgram> |
|
||||||
@ -1,9 +0,0 @@ |
|||||||
Задача сделать механизм маршрутизации между узлами для групповых чатов. |
|
||||||
|
|
||||||
Узлы для всех чатов находятся в одной таблице - это nodeinfo (информация о подключении) |
|
||||||
В другой таблице есть список узлов конкретного чата. |
|
||||||
|
|
||||||
надо сделать возможность хранить одновременно несколько групп узлов. в группу узлов добавить тип - utun или чатовая. |
|
||||||
если utun - в группе используется роутинг (ipv4/ipv6). |
|
||||||
если чатовая - то только связность между узлами. |
|
||||||
|
|
||||||
@ -1,3 +0,0 @@ |
|||||||
При добавлении узла группы в БД дополнительно |
|
||||||
- проверяем текущие подключения |
|
||||||
- если узел найден в активных подключениях то добавляем его в группу topo_group |
|
||||||
@ -1,50 +0,0 @@ |
|||||||
# route6_lib — библиотека IPv6-маршрутизации на radix tree |
|
||||||
|
|
||||||
## 1. Назначение |
|
||||||
Локальная таблица маршрутизации IPv6 для поиска longest-prefix match по заданному адресу. |
|
||||||
Используется при пробросе трафика в TUN-интерфейс — по destination IP определяем узел-владелец |
|
||||||
подсети и отправляем пакет ему через ETCP. |
|
||||||
|
|
||||||
Индексируется по `node_id` через `ll_queue`-хеш — это позволяет эффективно удалять все маршруты |
|
||||||
узла при его withdraw из BGP-топологии. |
|
||||||
|
|
||||||
## 2. Как пользоваться |
|
||||||
```c |
|
||||||
struct ROUTE6_TABLE *rt = route6_table_create(ua); |
|
||||||
|
|
||||||
// При получении BGP-апдейта с новыми подсетями узла: |
|
||||||
route6_insert(rt, nodeq); |
|
||||||
|
|
||||||
// При withdraw узла: |
|
||||||
route6_delete(rt, nodeq); |
|
||||||
|
|
||||||
// При пробросе IPv6-пакета: |
|
||||||
const struct ROUTE6_DATA *rd = route6_lookup(rt, dst_addr); |
|
||||||
if (rd) forward_to_etcp(rd->v_node_info, pkt); |
|
||||||
``` |
|
||||||
|
|
||||||
Ключевой нюанс: `make_key6` формирует 17-байтовый ключ в формате sockaddr-like |
|
||||||
(первый байт = длина = 17, остальные 16 — адрес). Radix tree сравнивает ключи с отступом 1 байт |
|
||||||
(RADIX_OFF), пропуская заголовок длины. |
|
||||||
|
|
||||||
## 3. API |
|
||||||
|
|
||||||
### Структуры |
|
||||||
| Структура | Назначение | |
|
||||||
|-----------|------------| |
|
||||||
| `ROUTE6_DATA` | Запись маршрута: ключ+маска (17 байт sockaddr-like), `prefix_length`, `node_id` (для хеша), `v_node_info` (указатель на узел-владелец), `rn_nodes[2]` (scratch для radix) | |
|
||||||
| `ROUTE6_TABLE` | Таблица: `rnh` (radix tree head), `queue` (ll_queue с хеш-индексом по `node_id`) | |
|
||||||
|
|
||||||
### Функции |
|
||||||
| Функция | Назначение | |
|
||||||
|---------|------------| |
|
||||||
| `route6_table_create(ua)` | Создать таблицу: `rn_inithead` + `queue_new` с хеш-индексом по `node_id` | |
|
||||||
| `route6_table_destroy(table)` | Удалить все маршруты (radix+queue), освободить таблицу | |
|
||||||
| `route6_insert(table, node)` | Вставить все `v6_subnets` узла в radix tree и queue (с хеш-индексом) | |
|
||||||
| `route6_delete(table, node)` | Удалить из radix tree все маршруты с заданным `node_id` (поиск через хеш) | |
|
||||||
| `route6_lookup(table, addr)` | Longest-prefix match по 16-байтовому адресу, возвращает `ROUTE6_DATA*` или NULL | |
|
||||||
|
|
||||||
### Зависимости |
|
||||||
- `lib/radix.h` — radix tree (longest-match lookup) |
|
||||||
- `lib/ll_queue.h` — lock-free очередь с хеш-индексом для поиска по `node_id` |
|
||||||
- `src/topo_node.h` — `TOPO_GROUP_NODE`, `TOPO_SUBNET6` |
|
||||||
@ -1,42 +0,0 @@ |
|||||||
Ключевые изменения в понимании |
|
||||||
|
|
||||||
paths |
|
||||||
|
|
||||||
route_bgp_process_nodeinfo(bgp, from_conn, data, entry->len): |
|
||||||
проверяет текущую версию nodeinfo, если совпадает - только bgp_update local nodelist |
|
||||||
если версия новая или нет узла - spread: |
|
||||||
bgp_update local nodelist |
|
||||||
realloc: добавляет next hop: hoplist += prev_node_id, hop_count++ |
|
||||||
bgp_spread |
|
||||||
|
|
||||||
1. функция распространения маршрута |
|
||||||
bgp_spread(struct ROUTE_BGP bgp, struct NODEINFO* n) |
|
||||||
send to: |
|
||||||
- все подключения, если не найден uid подключения в hoplist |
|
||||||
|
|
||||||
|
|
||||||
bgp_update local nodelist: |
|
||||||
- обновляем саму node |
|
||||||
- удалеям conn где lash hop=prev_node_id |
|
||||||
- добавляем новый conn с новым hoplist |
|
||||||
|
|
||||||
2. withdraw: |
|
||||||
bgp_withdraw(struct ROUTE_BGP bgp, uint64_t node_to_del, uint64_t wd_source) - wd_source это узел который захотел withdraw. |
|
||||||
- находим у себя node to del. удаляем если в hoplist найден wd_node (или мы = wd_node) |
|
||||||
если удалили - распространяем по всем линкам с этими же аргументами |
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
=============================== |
|
||||||
определение nat |
|
||||||
|
|
||||||
определяем что оба узла в локальной сети: |
|
||||||
-если обе ноды имеют локальные адреса сокетов пробуем пинг по локальным адресам |
|
||||||
|
|
||||||
если узел подключился и его сокетовый ip:port отличается от connection ip:port - устанавливаем флаг nat. и инициируем проверку пингом третьим узлом: |
|
||||||
проверка считается успешной если по результату пинга ip источника пинга отличается от ip запросившего пинг узла. |
|
||||||
|
|
||||||
проверка типа nat узла который подключился: |
|
||||||
- пингуем узел с целью зафиксировать свой ip (в сокете может быть например 0.0.0.0) |
|
||||||
- даём команду третьему узлу пингануть этот узел. |
|
||||||
- по результатам двух пингов определяем тип nat |
|
||||||
@ -1,68 +0,0 @@ |
|||||||
# route_lib – библиотека таблицы IPv4-маршрутизации |
|
||||||
|
|
||||||
## 1. Назначение |
|
||||||
Ведёт таблицу IPv4-маршрутов в памяти: динамический массив `ROUTE_ENTRY`, отсортированный по network-адресу с поддержкой вставки/удаления и LPM-поиска (Longest Prefix Match). Используется модулем `routing` для принятия решения, куда слать пакет — какому узлу через ETCP или локально в TUN. |
|
||||||
|
|
||||||
Таблица не содержит логики синхронизации — наполнение маршрутами идёт через BGP (`topo_node`). |
|
||||||
|
|
||||||
## 2. Как пользоваться |
|
||||||
```c |
|
||||||
struct ROUTE_TABLE* rt = route_table_create(); |
|
||||||
|
|
||||||
// Вставка подсетей узла (из BGP): |
|
||||||
route_insert(rt, topo_nodeq); |
|
||||||
|
|
||||||
// Поиск маршрута (LPM): |
|
||||||
struct ROUTE_ENTRY* e = route_lookup(rt, dest_ip); |
|
||||||
if (e && e->v_node_info && e->v_node_info->hop_count > 0) { |
|
||||||
// Отправить через ETCP узлу e->v_node_info->node->node_id |
|
||||||
} else { |
|
||||||
// Локальный маршрут — отдать в TUN |
|
||||||
} |
|
||||||
|
|
||||||
// Удаление маршрутов узла: |
|
||||||
route_delete(rt, topo_nodeq); |
|
||||||
|
|
||||||
route_table_destroy(rt); |
|
||||||
``` |
|
||||||
|
|
||||||
**Ключевые нюансы:** |
|
||||||
- Адреса в `ROUTE_ENTRY.network` хранятся в **big-endian** (сетевой порядок) |
|
||||||
- Записи отсортированы по `network` ASC, при равенстве — по `prefix_length` DESC (более специфичные раньше) |
|
||||||
- Алгоритм LPM: бинарный поиск с fallback-проверкой соседней записи |
|
||||||
- `v_node_info == NULL` или `hop_count == 0` означает **локальный маршрут** |
|
||||||
- Пересечение маршрутов запрещено — `route_insert` проверяет `check_route_overlap_in_table` |
|
||||||
- Ёмкость массива динамически расширяется (×2) при переполнении |
|
||||||
|
|
||||||
## 3. API |
|
||||||
|
|
||||||
### Структуры |
|
||||||
|
|
||||||
| Структура | Поля | Описание | |
|
||||||
|-----------|------|----------| |
|
||||||
| `ROUTE_ENTRY` | `network` (uint32_t, BE), `prefix_length` (uint8_t), `v_node_info` (TOPO_GROUP_NODE*) | Запись маршрута. `v_node_info==NULL` → локальный | |
|
||||||
| `ROUTE_TABLE` | `entries`, `count`, `capacity`, `dynamic_subnets`, `local_subnets`, `stats` | Таблица маршрутизации. Динамический массив + статистика | |
|
||||||
|
|
||||||
### Функции |
|
||||||
|
|
||||||
| Функция | Описание | |
|
||||||
|---------|----------| |
|
||||||
| `route_table_create()` | Выделяет `ROUTE_TABLE`, `entries` на `INITIAL_CAPACITY=100`, счётчики в 0 | |
|
||||||
| `route_table_destroy(table)` | Освобождает `entries`, `dynamic_subnets`, `local_subnets`, саму таблицу | |
|
||||||
| `route_insert(table, node)` | Вставляет все v4-подсети узла (`TOPO_GROUP_NODE`) с сортировкой. Проверяет overlap. Расширяет capacity при необходимости | |
|
||||||
| `route_delete(table, node)` | Удаляет все записи, где `v_node_info == node`, со сдвигом массива | |
|
||||||
| `route_lookup(table, dest_ip)` | LPM-поиск. Возвращает `ROUTE_ENTRY*` или NULL. Инкрементит `stats` (hits/misses) | |
|
||||||
| `route_table_print(table)` | Печатает содержимое таблицы в лог | |
|
||||||
| `parse_subnet(str, network, prefix_length)` | Парсит `"a.b.c.d/n"` → network (BE) + prefix_length. Возвращает 0/-1 | |
|
||||||
| `is_local_subnet(ip)` | Проверяет, является ли IP локальным/мультикастовым/зарезервированным (0=true). RFC1918 + 0.0.0.0/8 + 127.0.0.0/8 + АPIPA + multicast + broadcast + CGNAT (100.64.0.0/10) | |
|
||||||
| `route_add_local_subnet(table, network, prefix_length)` | **Объявлена в .h, но не реализована** | |
|
||||||
|
|
||||||
### Внутренние функции |
|
||||||
|
|
||||||
| Функция | Описание | |
|
||||||
|---------|----------| |
|
||||||
| `prefix_to_mask(prefix)` | Преобразует длину префикса в маску: `/24` → `0xFFFFFF00` | |
|
||||||
| `routes_overlap(n1, p1, n2, p2)` | Проверяет, совпадают ли две подсети (одинаковые network+prefix) | |
|
||||||
| `check_route_overlap_in_table(net, pre, entries, count)` | Проверяет overlap со всеми существующими записями | |
|
||||||
| `binary_search_insert_pos(entries, count, net, pre)` | Находит позицию для вставки с сохранением сортировки | |
|
||||||
| `binary_search_lpm(table, dest_ip)` | Бинарный LPM-поиск с fallback на соседнюю запись | |
|
||||||
@ -1,11 +0,0 @@ |
|||||||
Установка прямого подключения между узлами |
|
||||||
|
|
||||||
1. узел собирает адреса - кандидаты для подключения: |
|
||||||
список пар адрес-порт: |
|
||||||
- адреса и порты из конфига сокетов (если не 0.0.0.0) |
|
||||||
- адреса и порты из сокетов (nat) где nat = EIM |
|
||||||
список ретрансляторов узлов-кандидатов: |
|
||||||
- rtt, nodeid, адрес-порт |
|
||||||
|
|
||||||
|
|
||||||
пары ip:port передаются на peer в команде "direct connection request" ROUTE_SUBCMD_CONN_REQ 0x0B |
|
||||||
@ -1,315 +0,0 @@ |
|||||||
# topo_group |
|
||||||
|
|
||||||
## 1. Назначение |
|
||||||
|
|
||||||
BGP-подобный обмен топологией узлов между пирами uTun через ETCP. Каждый узел хранит таблицу |
|
||||||
известных узлов и при подключении нового пира синхронизирует её с ним. Изменения информации об |
|
||||||
узле и обнаружение недоступности распространяются всем пирам (NODEINFO/WITHDRAW). |
|
||||||
|
|
||||||
Модуль поддерживает **изолированные группы** — разные «пространства имён» узлов с разной |
|
||||||
семантикой: |
|
||||||
- **TOPO_GROUP_TYPE_UTUN (1)** — VPN-сеть: обмен маршрутами (подсети) между узлами, NAT-детекция, |
|
||||||
проверка связности. |
|
||||||
- **TOPO_GROUP_TYPE_CHAT (2)** — чат-группа: только узлы, без подсетей, персистентность в SQLite. |
|
||||||
|
|
||||||
Группа по умолчанию (UTUN, `group_id = TOPO_GROUP_UTUN`) создаётся автоматически при |
|
||||||
`topo_groups_init()`. Дополнительные группы создаются через `topo_groups_create_group()` (для |
|
||||||
chatgui). Узлы разных групп изолированы, маршрутизация пакетов внутри группы ведётся по |
|
||||||
`group_id` из wire-заголовков. |
|
||||||
|
|
||||||
Помимо обмена топологией, модуль выполняет: |
|
||||||
- **Сборку local_node** (`topo_group_update_my_nodeinfo`) — при старте и при изменениях сокетов/active-mode. |
|
||||||
- **NAT-детекцию** — выделена в отдельный модуль `nat_detection.h` (свой ETCP_ID 0x02). |
|
||||||
- **Поиск оптимального маршрута** (`topo_group_find_conn_for_node`) — по min hop_count среди live-путей. |
|
||||||
- **Зондирование связности** — `route_connectivity_probe_node()` для новых узлов. |
|
||||||
- **Авто-подключение к узлам CHAT-группы** — `topo_group_connect` (бесконечный цикл до успеха). |
|
||||||
- **Восстановление каскадно отвалившихся узлов** — `topo_recovery` (после разрыва соединения). |
|
||||||
- **Invite/join** — `topo_group_invite` (прямое подключение + проверка членства). |
|
||||||
- **Персистентность в SQLite** — `topo_node_sqlite` (таблицы nodes, node_addresses, peers_*). |
|
||||||
- **Per-group broadcast** — `broadcast` (дёшевая рассылка данных с TTL внутри группы). |
|
||||||
|
|
||||||
## 2. Как пользоваться |
|
||||||
|
|
||||||
### 2.1. Инициализация (при старте utun) |
|
||||||
|
|
||||||
```c |
|
||||||
struct TOPO_GROUPS* g = topo_groups_init(instance); // контейнер + utun-группа по умолчанию |
|
||||||
``` |
|
||||||
Здесь же: |
|
||||||
- Открывается SQLite (`{db_path}/chats.db`), если задан `db_path`; БД — `instance->topo_sqlite_db`. |
|
||||||
- `etcp_bind(instance, ETCP_ID_TOPO_ENTRY, topo_group_receive_cbk)` — приёмник пакетов топологии. |
|
||||||
- `etcp_add_conn_status_cbk(instance, topo_group_conn_status, g)` — события UP/DOWN/DELETE всех соединений. |
|
||||||
- `etcp_add_socket_cbk(...)` — изменения адресов/статуса сокетов. |
|
||||||
- `utun_add_activity_cbk(...)` — смена active/standby режима. |
|
||||||
|
|
||||||
### 2.2. Новое ETCP-соединение |
|
||||||
|
|
||||||
При ETCP UP (`topo_group_conn_status` → `topo_group_new_conn` для каждой группы): |
|
||||||
1. Дедупликация (тот же conn стреляет UP дважды — UDP- и TCP-линк). |
|
||||||
2. `topo_recovery_cancel_for_node` — узел появился в сети, отменяем его recovery. |
|
||||||
3. Обновление peer-узла: `conn_presence/conn_up |= NCONN_DIRECT`. |
|
||||||
4. `topo_group_add_to_senders` + `topo_group_send_table_request` (запрос полной таблицы). |
|
||||||
5. `topo_group_connect_on_up` (авто-подключение CHAT). |
|
||||||
|
|
||||||
На `REQUEST_TABLE` пир отвечает: NODEINFO о себе (local_node) + full table sync (все узлы, кроме |
|
||||||
тех, чей путь уже включает этого пира — защита от петель) + `TABLE_COMPLETE`. При получении |
|
||||||
`TABLE_COMPLETE` вызывается `etcp_set_routing_exchange_state(from_conn, 3)`. |
|
||||||
|
|
||||||
### 2.3. NODEINFO (обновление/создание узла) |
|
||||||
|
|
||||||
`topo_group_process_nodeinfo(group, from, data, len)`: |
|
||||||
1. Проверка `group_id` пакета (`ni->group_id == group->group_id`). |
|
||||||
2. Проверка соответствия типа группы по флагу `TOPO_FLAG_SEND_SUBNETS` (CHAT → 0, UTUN → 1); |
|
||||||
при несовпадении — `TOPO_SUBCMD_ERR_GROUP_MISMATCH`. |
|
||||||
3. Проверка `hop_count < MAX_HOPS`; пропуск собственного `node_id`. |
|
||||||
4. Проверка версии: если `(int8_t)(last_ver - new_ver) >= 0` (stale) — только обновляется путь. |
|
||||||
5. Десериализация wire-формата → `TOPO_NODE` (глобальная идентичность) + подсети + hop_list. |
|
||||||
6. Верификация идентичности: `node_id == sc_derive_node_id_from_pubkey(public_key)` и |
|
||||||
Ed25519 self-signature (`x25519_self_sig`) над каноническим сообщением. |
|
||||||
7. Сохранение в глобальный реестр `node_registry` (дедупликация по node_id, ref_count). |
|
||||||
8. Обновление/создание `TOPO_GROUP_NODE` (per-group): paths, last_ver, subnets. |
|
||||||
9. `topo_group_remove_path_by_hop` + `topo_group_add_path` (через текущий conn). |
|
||||||
10. `conn_presence/conn_up |= NCONN_BGP` (+ `NCONN_DIRECT` если прямой). |
|
||||||
11. `route_insert` — только для UTUN-групп. |
|
||||||
12. SQLite: `topo_node_sqlite_member_exists` → `addrs_put`; для CHAT — `member_placeholder_put` |
|
||||||
(source=1, вне merkle-хеша); `nodeinfo_updated`. |
|
||||||
13. `control_server_notify_node_change`. |
|
||||||
14. Callback `node_updated_cb` (legacy, в текущем коде потребителей нет). |
|
||||||
15. Fire BGP node event callbacks (`TOPO_NODE_EVENT_NEW`/`UPDATE`) — используют member_sync, media_delivery. |
|
||||||
16. `topo_fire_nodeinfo_cbk` — глобальные nodeinfo-подписчики. |
|
||||||
17. Broadcast NODEINFO всем пирам, кроме самого узла и тех, чей node_id есть в hop_list (антипетля). |
|
||||||
18. `route_connectivity_probe_node` для новых/изменённых узлов с адресами. |
|
||||||
|
|
||||||
### 2.4. WITHDRAW (удаление узла) |
|
||||||
|
|
||||||
`topo_group_process_withdraw(group, sender, data, len)`: |
|
||||||
1. Поиск `TOPO_GROUP_NODE` по `node_id`. |
|
||||||
2. `topo_group_remove_path_by_hop(nq, wd_source)` — удаление путей, содержащих wd_source в hop_list. |
|
||||||
3. Если путей не осталось: сброс `conn_presence/conn_up`, `route_delete` (UTUN), уведомление |
|
||||||
control_server, отмена connectivity probe, освобождение paths и group-полей, удаление из |
|
||||||
`nodes`, `etcp_router_conn_close_all_for_node`, broadcast withdraw (кроме отправителя), |
|
||||||
fire `TOPO_NODE_EVENT_REMOVE`. |
|
||||||
4. **BGP не удаляет member-запись из SQLite** — удаление из `peers_*` только через битую подпись |
|
||||||
при верификации (member_sync). |
|
||||||
|
|
||||||
### 2.5. Отключение соединения |
|
||||||
|
|
||||||
При ETCP DOWN/DELETE (`topo_group_remove_conn`): |
|
||||||
1. Проверка наличия conn в senders_list (если нет — выход). |
|
||||||
2. Для каждого узла с путями через conn: вычисляется next_hop из hop_list, `remove_path`. Если |
|
||||||
узел стал недоступен — `topo_recovery_add_node` (для каскадных, кроме самого пира), полная |
|
||||||
очистка (как в WITHDRAW) + broadcast withdraw. |
|
||||||
3. Удаление conn из `senders_list`. |
|
||||||
4. Если были каскадные узлы — `topo_recovery_start`. |
|
||||||
5. `topo_group_connect_on_down`. |
|
||||||
|
|
||||||
### 2.6. Поиск пути до узла |
|
||||||
|
|
||||||
`topo_group_find_conn_for_node(group, node_id)` — перебирает paths узла, выбирает min `hop_count`, |
|
||||||
предпочитая live-пути (`conn->links_up > 0`); fallback на любой путь. Интенсивно используется |
|
||||||
`etcp_router` и `conn_mgr` (next-hop для маршрутов и multihop-соединений). |
|
||||||
|
|
||||||
## 3. API |
|
||||||
|
|
||||||
### 3.1. Структуры |
|
||||||
|
|
||||||
| Структура | Назначение | |
|
||||||
|---|---| |
|
||||||
| `TOPO_GROUPS` | Контейнер всех групп. `group_list` (hash), `node_registry` (глобальный реестр TOPO_NODE*, hash), memory_pool'ы (v4/v6 sock_meta, addr, subnet), `node_updated_cb` (legacy) | |
|
||||||
| `TOPO_GROUP` | Одна группа. `group_id`, `group_type`, `nodes` (queue TOPO_GROUP_NODE), `senders_list` (queue conn'ов), `local_node`, `ed25519_public_key`, `channel_id` (CHAT), `conn_mgr`, `recovery_list`, `connect`, `broadcast`, `node_cbks` | |
|
||||||
| `TOPO_NODE` | Глобальная идентичность узла (в `node_registry`): pubkeys, `x25519_self_sig`, name, v4/v6 sock_meta+addrs, `client_type`, `client_activity`, `ver`, `group_ref_count` | |
|
||||||
| `TOPO_GROUP_NODE` | Per-group запись узла: `node_id`, `subnets`, `paths`, `last_ver`, `conn_mgr_*`, `connectivity`, `conn_presence`, `conn_up`, `handle` (ncd) | |
|
||||||
| `TOPO_NODEPATH` | Путь до узла через ETCP_CONN: `{conn, hop_count, cumulative_rtt}` + inline `hop_list[hop_count]` | |
|
||||||
| `TOPO_NODESUBNETS` | Подсети узла: списки `TOPO_SUBNET4`/`TOPO_SUBNET6` | |
|
||||||
| `TOPO_CONNECTIVITY` | Связность: probe_status, rtt-метрики, статусы (interface/nat/real), `probe_deferred_wait` (standby) | |
|
||||||
| `TOPOMSG_NODEINFO_PKT` | Wire NODEINFO: cmd + subcmd + TOPOMSG_NODE + переменная часть | |
|
||||||
| `TOPOMSG_WITHDRAW_PKT` | Wire WITHDRAW: `group_id`, `node_id` (удаляемый), `wd_source` (инициатор) | |
|
||||||
| `TOPOMSG_TABLE_REQ` | Wire запроса/завершения таблицы: `group_id` | |
|
||||||
| `TOPOMSG_ERR_GROUP_MISMATCH` | Wire ошибки типа группы: `group_id`, `expected_type`, `received_flags` | |
|
||||||
| `NAT_DETECTION` | Контекст NAT-детекции (отдельный модуль) | |
|
||||||
|
|
||||||
### 3.2. Константы |
|
||||||
|
|
||||||
| Константа | Значение | Назначение | |
|
||||||
|---|---|---| |
|
||||||
| `ETCP_ID_TOPO_ENTRY` | 0x01 | ETCP ID пакетов топологии | |
|
||||||
| `TOPO_SUBCMD_NODEINFO` | 0x04 | Полная информация об узле | |
|
||||||
| `TOPO_SUBCMD_REQUEST_TABLE` | 0x05 | Запрос полной таблицы | |
|
||||||
| `TOPO_SUBCMD_WITHDRAW` | 0x06 | Узел стал недоступен | |
|
||||||
| `TOPO_SUBCMD_TABLE_COMPLETE` | 0x0B | Завершение начальной синхронизации | |
|
||||||
| `TOPO_SUBCMD_ERR_GROUP_MISMATCH` | 0x0C | Ошибка несоответствия типа группы | |
|
||||||
| `MAX_HOPS` | 16 | Максимальная длина hop-листа | |
|
||||||
| `BGP_NODES_HASH_SIZE` / `TOPO_NODE_REGISTRY_HASH_SIZE` | 256 | Хеш-таблицы nodes / node_registry | |
|
||||||
| `TOPO_GROUP_UTUN` | 0x8000000000000000ULL | group_id utun-группы по умолчанию | |
|
||||||
| `TOPO_GROUP_TYPE_UTUN` / `TOPO_GROUP_TYPE_CHAT` | 1 / 2 | Тип группы | |
|
||||||
| `TOPO_FLAG_SEND_SUBNETS` | 0x01 | Флаг NODEINFO: узел передаёт подсети | |
|
||||||
| `NCONN_DIRECT` / `NCONN_INDIRECT` / `NCONN_BGP` | 1/2/4 | Биты наличия соединений (presence/up) | |
|
||||||
| `CONN_TYPE_DIRECT` / `REVERSE` / `INDIRECT` / `NONE` | 1/2/3/0 | Стратегия conn_mgr | |
|
||||||
| `CLIENT_TYPE_SERVER` / `DESKTOP` / `MOBILE` | 0/1/2 | Тип клиента | |
|
||||||
| `CLIENT_ACTIVITY_STANDBY` / `ACTIVE` | 0/1 | Режим (standby/active) | |
|
||||||
| `PROBE_STATUS_NONE/IN_PROGRESS/DONE/DEFERRED` | 0/1/2/3 | Состояние пробы | |
|
||||||
| `PROBE_RESULT_UNKNOWN/REACHABLE/UNREACHABLE` | 0/1/2 | Результат пробы | |
|
||||||
| `TOPO_NODE_EVENT_NEW/UPDATE/REMOVE` | 0/1/2 | События BGP node callbacks | |
|
||||||
| `CONN_MGR_MAX_INTERMEDIARIES` | 3 | Максимум посредников для INDIRECT | |
|
||||||
|
|
||||||
### 3.3. Инициализация/завершение |
|
||||||
|
|
||||||
| Функция | Назначение | |
|
||||||
|---|---| |
|
||||||
| `topo_groups_init(instance)` | Контейнер + node_registry + пулы + SQLite + utun-группа + ETCP/activity коллбэки | |
|
||||||
| `topo_groups_destroy(instance)` | Отвязка коллбэков, destroy групп, node_registry, пулов, закрытие SQLite | |
|
||||||
| `topo_group_create(instance, group_id, group_type)` | Создать TOPO_GROUP: nodes/senders/local_node/conn_mgr/broadcast | |
|
||||||
| `topo_group_destroy(group)` | recovery_cancel_all, connect_destroy, broadcast_destroy, conn_mgr_destroy, очистка nodes/local_node | |
|
||||||
| `topo_groups_create_group(g, group_id, group_type, channel_id)` | Создать группу + добавить в group_list + new_conn для существующих соединений + connect_init (CHAT) | |
|
||||||
| `topo_groups_find(g, group_id)` / `topo_groups_get_default(g)` | Поиск группы / utun-группа | |
|
||||||
| `topo_group_on_activity_change(instance, active, arg)` | Обновить local_node и broadcast его по всем группам/пирам | |
|
||||||
|
|
||||||
### 3.4. Жизненный цикл соединения |
|
||||||
|
|
||||||
| Функция | Назначение | |
|
||||||
|---|---| |
|
||||||
| `topo_group_new_conn(group, conn)` | Дедуп, отмена recovery, обновить peer, add_to_senders, request_table, connect_on_up | |
|
||||||
| `topo_group_remove_conn(group, conn)` | Удалить пути, удалить недоступные узлы (recovery/broadcast), убрать conn, connect_on_down | |
|
||||||
| `topo_group_conn_status(conn, status, arg)` | Callback status: UP→new_conn, DOWN/DELETE→remove_conn для каждой группы | |
|
||||||
|
|
||||||
### 3.5. Обработка пакетов |
|
||||||
|
|
||||||
| Функция | Назначение | |
|
||||||
|---|---| |
|
||||||
| `topo_group_receive_cbk(from_conn, entry)` | Точка входа: извлекает `group_id`, находит группу, диспетчеризация по subcmd | |
|
||||||
| `topo_group_process_nodeinfo(group, from, data, len)` | Полный цикл NODEINFO (см. 2.3) | |
|
||||||
| `topo_group_process_withdraw(group, sender, data, len)` | Удаление путей/узла по WITHDRAW (см. 2.4) | |
|
||||||
| `topo_group_handle_request_table(group, conn)` | local_node + full table + add_to_senders + TABLE_COMPLETE | |
|
||||||
|
|
||||||
### 3.6. Поиск и пути |
|
||||||
|
|
||||||
| Функция | Назначение | |
|
||||||
|---|---| |
|
||||||
| `topo_group_find_conn_for_node(group, node_id)` | Оптимальный ETCP_CONN (min hop_count, предпочтение live) | |
|
||||||
| `topo_node_find_by_id(group, node_id)` | Поиск TOPO_GROUP_NODE по node_id (hash) | |
|
||||||
| `topo_group_add_path(nq, conn, hop_list, hop_count, cumulative_rtt)` | Создать TOPO_NODEPATH + inline hop_list | |
|
||||||
| `topo_group_remove_path(nq, conn)` | Удалить путь; возвращает 1 если путей не осталось | |
|
||||||
| `topo_group_remove_path_by_hop(nq, wd_source)` | Удалить пути, содержащие wd_source в hop_list | |
|
||||||
| `topo_group_should_send_to(nq, target_id)` | Проверка антипетли (target_id не во всех путях) | |
|
||||||
|
|
||||||
### 3.7. Broadcast |
|
||||||
|
|
||||||
| Функция | Назначение | |
|
||||||
|---|---| |
|
||||||
| `topo_group_send_nodeinfo(group, node, conn, cumulative_rtt)` | Сериализовать и отправить NODEINFO одному conn | |
|
||||||
| `topo_group_send_withdraw(group, node_id)` | Broadcast WITHDRAW (wd_source = self) | |
|
||||||
| `topo_group_broadcast_withdraw(group, node_id, wd_source, exclude)` | Broadcast WITHDRAW всем, кроме exclude | |
|
||||||
| `topo_group_send_full_table(group, conn)` | Все известные узлы (антипетля) указанному conn | |
|
||||||
| `topo_group_send_table_request/complete(group, conn)` | REQUEST_TABLE / TABLE_COMPLETE | |
|
||||||
| `topo_group_send_err_group_mismatch(group, conn, ...)` | ERR_GROUP_MISMATCH | |
|
||||||
|
|
||||||
### 3.8. Коллбэки (подписки) |
|
||||||
|
|
||||||
| Функция | Назначение | |
|
||||||
|---|---| |
|
||||||
| `topo_group_add_node_cbk/remove_node_cbk(group, fn, arg)` | BGP node events (NEW/UPDATE/REMOVE) — consumer: member_sync, media_delivery | |
|
||||||
| `utun_add_nodeinfo_cbk/remove_nodeinfo_cbk(instance, fn, arg)` | Глобальная подписка на изменения nodeinfo (per-instance) | |
|
||||||
| `topo_fire_nodeinfo_cbk(instance, group, node)` | Вызвать глобальные nodeinfo-подписчики | |
|
||||||
| `topo_groups_set_node_updated_cb(groups, fn)` | Legacy callback (в текущем коде потребителей нет) | |
|
||||||
|
|
||||||
### 3.9. NAT (делегаты в nat_detection) |
|
||||||
|
|
||||||
| Функция | Назначение | |
|
||||||
|---|---| |
|
||||||
| `topo_group_set_nat_check_local(group, allow)` | Делегат в `nat_detection_set_allow_local` | |
|
||||||
|
|
||||||
### 3.10. Связанные модули |
|
||||||
|
|
||||||
| Модуль | Назначение | |
|
||||||
|---|---| |
|
||||||
| `topo_group_connect` | Авто-подключение к узлам CHAT-группы (3 фазы, бесконечный цикл, standby-aware) | |
|
||||||
| `topo_group_invite` | Invite/join канала через прямое ncd-подключение (INVITE_INFO_REQ/RESP, ETCP_ID 0x13) | |
|
||||||
| `topo_recovery` | Восстановление каскадно отвалившихся узлов после разрыва соединения | |
|
||||||
| `broadcast` | Per-group рассылка данных с TTL (ETCP_ID_BROADCAST), `broadcast_init/сброс` | |
|
||||||
| `topo_node` | Модель данных: TOPO_NODE/TOPO_GROUP_NODE, ser/deserialize, node_registry, sig-msg | |
|
||||||
| `topo_node_sqlite` | Персистентность: nodes, node_addresses, peers_*, member block/owner/placeholder | |
|
||||||
|
|
||||||
## 4. Архитектурные связи |
|
||||||
|
|
||||||
### 4.1. Внешние зависимости |
|
||||||
|
|
||||||
| Модуль | Как используется | |
|
||||||
|---|---| |
|
||||||
| `topo_node.c/h` | Модель узла, ser/deserialize, node_registry, update_my_nodeinfo, sign_self | |
|
||||||
| `topo_node_sqlite.h` | Персистентность (node_put, member_placeholder_put, addrs_put, nodeinfo_updated) | |
|
||||||
| `nat_detection.h` | NAT-детекция (отдельный модуль, ETCP_ID 0x02) | |
|
||||||
| `route_lib.h` | route_insert / route_delete | |
|
||||||
| `route_connectivity.h` | probe_node / cancel_node / cancel_all | |
|
||||||
| `etcp_api.h` | etcp_bind, etcp_add_conn_status_cbk, etcp_add_socket_cbk, etcp_unbind | |
|
||||||
| `etcp_connections.h` | ETCP_CONN, conn->peer_node_id, links_up | |
|
||||||
| `etcp.h` | etcp_send, etcp_set_routing_exchange_state | |
|
||||||
| `etcp_router.h` | etcp_router_conn_close_all_for_node | |
|
||||||
| `control_server.h` | notify_node_change / notify_node_removed | |
|
||||||
| `conn_mgr.h` | conn_mgr_init/destroy (per-group), поиск путей | |
|
||||||
| `secure_channel.h` | sc_derive_ed25519_pubkey, sc_derive_node_id_from_pubkey, sc_ed25519_verify | |
|
||||||
| `broadcast.h` | broadcast_init/destroy (per-group) | |
|
||||||
| `memory_pool.h` | Пулы для сериализации | |
|
||||||
| `debug_config.h` | Логирование, категория BGP | |
|
||||||
| `mem.h` | u_malloc/u_free/u_calloc | |
|
||||||
|
|
||||||
### 4.2. Кто вызывает topo_group |
|
||||||
|
|
||||||
| Вызывающий | Что вызывает | Для чего | |
|
||||||
|---|---|---| |
|
||||||
| `utun_instance.c` | `topo_groups_init/destroy` | Инициализация/завершение | |
|
||||||
| `etcp_connections.c` | `topo_group_send_nodeinfo` | Переотправка local_node при смене сокетов | |
|
||||||
| `etcp_router.c` | `topo_group_find_conn_for_node` | next-hop для маршрутов | |
|
||||||
| `conn_mgr_*.c` | `topo_group_find_conn_for_node`, `topo_fire_nodeinfo_cbk` | Пути для соединений | |
|
||||||
| `nat_detection.c` | `topo_group_send_nodeinfo`, `topo_group_update_my_nodeinfo` | Обновление local_node после NAT-чека | |
|
||||||
| `member_sync.c` | `topo_group_add_node_cbk` | BGP → member_sync → node_props_changed | |
|
||||||
| `media_delivery.c` | `topo_group_add_node_cbk` | События узлов для медиа | |
|
||||||
| `route_connectivity.c` | `topo_fire_nodeinfo_cbk` | Уведомление об изменении узла | |
|
||||||
|
|
||||||
## 5. Форматы пакетов (wire) |
|
||||||
|
|
||||||
### 5.1. NODEINFO |
|
||||||
``` |
|
||||||
cmd(1) | subcmd(1) | TOPOMSG_NODE | [node_name] | [v4_sock_meta[]] | [v4_addrs[]] | [v6_sock_meta[]] | [v6_addrs[]] | [v4_subnets[]] | [v6_subnets[]] | [hop_list[]] |
|
||||||
``` |
|
||||||
`TOPOMSG_NODE` содержит `group_id`, `node_id`, `ver`, pubkeys, `x25519_self_sig(64)`, счётчики, |
|
||||||
`hop_count`, `client_type`, `client_activity`, `cumulative_rtt`. |
|
||||||
|
|
||||||
### 5.2. WITHDRAW |
|
||||||
``` |
|
||||||
cmd(1) | subcmd(1) | group_id(8) | node_id(8) | wd_source(8) = 26 байт |
|
||||||
``` |
|
||||||
|
|
||||||
### 5.3. REQUEST_TABLE / TABLE_COMPLETE |
|
||||||
``` |
|
||||||
cmd(1) | subcmd(1) | group_id(8) = 10 байт |
|
||||||
``` |
|
||||||
|
|
||||||
### 5.4. ERR_GROUP_MISMATCH |
|
||||||
``` |
|
||||||
cmd(1) | subcmd(1) | group_id(8) | expected_type(1) | received_flags(1) = 12 байт |
|
||||||
``` |
|
||||||
|
|
||||||
## 6. Примечания |
|
||||||
|
|
||||||
- **Глобальный реестр идентичности**: `TOPO_NODE` (pubkeys, адреса, имя) хранится один раз в |
|
||||||
`node_registry` и разделяется между группами через `group_ref_count`. Per-group данные — в |
|
||||||
`TOPO_GROUP_NODE` (paths, subnets, connectivity, conn_presence/up). |
|
||||||
- **Версионирование NODEINFO**: `ver` (uint8_t) сравнивается циклически `(int8_t)(cur - new) >= 0`; |
|
||||||
stale-версия только обновляет путь, не заменяя данные узла. |
|
||||||
- **Верификация идентичности**: `node_id == derive(x25519)` + Ed25519 self-signature над каноническим |
|
||||||
сообщением (`topo_node_build_sig_msg`). Несовпадение → пакет отвергается как forgery. |
|
||||||
- **Защита от петель**: NODEINFO рассылается пирам, чей node_id отсутствует в hop_list всех путей; |
|
||||||
WITHDRAW broadcast всем, кроме отправителя. |
|
||||||
- **Hop-лист хранится в пути**: `TOPO_NODEPATH` содержит inline `hop_list[hop_count]` сразу после |
|
||||||
структуры; `next_hop` для recovery вычисляется из него. |
|
||||||
- **Связность**: для новых узлов с адресами запускается `route_connectivity_probe_node`; при |
|
||||||
удалении — `route_connectivity_cancel_node`. В standby пробы откладываются (`PROBE_STATUS_DEFERRED`). |
|
||||||
- **Виртуальные каналы**: при удалении узла закрываются `etcp_router_conn_close_all_for_node`. |
|
||||||
- **CHAT-группа пишет плейсхолдер** `source=1` (pubkeys из BGP, без подписей) — вне merkle-хеша; |
|
||||||
полная запись приходит позже через merkle-путь (member_sync). |
|
||||||
- **BGP не удаляет member из SQLite**: работает только со своей RAM-таблицей; удаление из `peers_*` |
|
||||||
— только битая подпись (member_sync). |
|
||||||
- **NAT check для локальных сетей**: по умолчанию запрещён (`allow_nat_check_local=0`), включается |
|
||||||
для тестов через `topo_group_set_nat_check_local`. |
|
||||||
- **Обновление local_node при NAT/active-изменениях**: `nat_detection` и `topo_group_on_activity_change` |
|
||||||
вызывают `topo_group_update_my_nodeinfo` → новая версия → NODEINFO broadcast всем пирам. |
|
||||||
@ -1,89 +0,0 @@ |
|||||||
++ OOP: |
|
||||||
class Animal { |
|
||||||
public: // доступен всем |
|
||||||
//private: // только внутри класса |
|
||||||
//protected: // внутри класса и наследников |
|
||||||
virtual void sound() {play(...);}// virtual — разрешает переопределение. |
|
||||||
|
|
||||||
virtual void sound2() = 0;// если =0 - метод обязательно должен быть реализован в наследнике, а сам класс становится абстрактным и его экземпляры создавать нельзя. |
|
||||||
|
|
||||||
Animal() {// конструктор - совпадает с именем класса |
|
||||||
cout << "Created"; |
|
||||||
} |
|
||||||
~Animal() {// деструктор |
|
||||||
cout << "Deleted"; |
|
||||||
} |
|
||||||
|
|
||||||
}; |
|
||||||
|
|
||||||
class Dog : public Animal {// наследование |
|
||||||
public: |
|
||||||
void sound() override {}// override — говорит компилятору, что метод действительно переопределяет базовый. |
|
||||||
}; |
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Стратегия обмена |
|
||||||
|
|
||||||
узлы которые online живут только в пемяти. и синхронизируемся с ними используя topo_group. |
|
||||||
|
|
||||||
routing layer: |
|
||||||
- topo_group - обеспечивает корректное построение оптимальной таблицы роутинга (per group) между узлами в рамках установленных подключений. И корректировку этой таблицы при перестроении подключений. |
|
||||||
|
|
||||||
- topo_group_discovery - обеспечивает оптимизацию подключений, а именно: |
|
||||||
- периодически пингует узлы проверяя их доступность |
|
||||||
|
|
||||||
|
|
||||||
для каждой группы админ назначает суперузлы: a b c ... стать усуперузлом - получить разрешение с админской подписью. |
|
||||||
|
|
||||||
суперузел активирует bgp обмен с остаьлными суперузлами. |
|
||||||
как: |
|
||||||
|
|
||||||
суперузел - это по сути сервер для группы. который также синхронизируется с другими суперузлами |
|
||||||
|
|
||||||
клиенты приоритетно подключаются к суперузлам: |
|
||||||
- подключаются к кому-то |
|
||||||
- запрашивают таблицу маршрутизации |
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
1. Узлы за nat сами выбирают подходящие для себя точки подключения к сети. |
|
||||||
2 шт с минимальным rtt |
|
||||||
2 шт с минимальной загруженностью |
|
||||||
|
|
||||||
в чате (gui) можно выбрать предпочитаемые узлы для подключения |
|
||||||
|
|
||||||
|
|
||||||
2. узлы с eim nat |
|
||||||
??? если не хватает узлов прямым адресом |
|
||||||
|
|
||||||
3. узлы с прямыми ип |
|
||||||
суть - выстраивают линки между собой для надежного обмена конфигурацией сети |
|
||||||
как: |
|
||||||
- в таблице узлов для каждой группы |
|
||||||
|
|
||||||
У каждого узла проставляется доступность (можем ли мы каким-либо образом подключиться): acessible, reverse (при подключении с другой стороны), no |
|
||||||
|
|
||||||
|
|
||||||
Единое обновление инфы об узле (per-group): |
|
||||||
- обновляем тип узла в каждой группе где есть узел при обовлении типа нат узла. прямая доступность узла: yes/no. |
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
======================================= |
|
||||||
функционал группы. |
|
||||||
|
|
||||||
Есть суперадмины группы - владеют приватным ключом суперадмина (один на группу). |
|
||||||
Есть админы - владеют сгенерированным приватным ключом админа и подписанным суперадмином. |
|
||||||
суперадмины могут делать revoke админу. |
|
||||||
|
|
||||||
админские действия также распространяются по чату как и обычные сообщения. |
|
||||||
ид группы = пубкей группы |
|
||||||
|
|
||||||
|
|
||||||
юзер - join по ссылке (приватный ключ пира). получает ключи других пиров. Может только читать. |
|
||||||
админ подписывает разрешение на писать (как и другие разрешения). подпись храним в таблице юзеров |
|
||||||
@ -1,289 +0,0 @@ |
|||||||
# etcp |
|
||||||
|
|
||||||
## 1. Назначение |
|
||||||
|
|
||||||
Ядро протокола ETCP — TCP-подобный надёжный транспорт поверх UDP с шифрованием (AES-CCM + X25519), multi-link (несколько каналов между двумя узлами), фрагментацией/сборкой пакетов, ретрансмиссией с экспоненциальным backoff, BBR congestion control и burst-измерением пропускной способности. |
|
||||||
|
|
||||||
Модуль управляет **одним ETCP-соединением** (struct `ETCP_CONN`) между локальным и удалённым узлом. Соединение может иметь несколько линков (struct `ETCP_LINK`), работающих через разные сокеты / сетевые пути. |
|
||||||
|
|
||||||
Этапы жизни соединения: |
|
||||||
``` |
|
||||||
создание (pending, state=0) → первый линк проинициализирован → ready (state=1) → close (state=2, detach) → ref_count=0 → полное освобождение ресурсов |
|
||||||
``` |
|
||||||
|
|
||||||
## 2. Как пользоваться |
|
||||||
|
|
||||||
### 2.1. Типовой сценарий |
|
||||||
|
|
||||||
1. **Создание:** `etcp_connection_create(instance, name)` — создаёт `ETCP_CONN` в состоянии `pending` (state=0), размещает в очереди `instance->connections` с индексом peer_node_id=0. |
|
||||||
2. **Добавление линков:** `etcp_link_new(etcp, socket, remote_addr, is_server)` — создаёт `ETCP_LINK`, добавляет в список `etcp->links`. |
|
||||||
3. **Обмен ключами / INIT:** через `etcp_connections.c` происходит обмен INIT_REQUEST/INIT_RESPONSE, установка `peer_node_id`, инициализация `secure_channel` (X25519 + AES-CCM). |
|
||||||
4. **Готовность:** `etcp_conn_ready()` → `etcp_conn_queue_set_ready()` — переиндексирует соединение в очереди `instance->connections` с реальным `peer_node_id`, переводит `state=1`, запускает callback'и `ready_cbks`, таймер метрик. |
|
||||||
5. **Отправка данных:** `etcp_int_send(etcp, data, len)` — аллоцирует память из `data_pool`, создаёт `ETCP_FRAGMENT`, помещает в `input_queue`. |
|
||||||
6. **Приём данных:** потребитель читает из `etcp->output_queue` — там лежат собранные `ETCP_FRAGMENT` с полезной нагрузкой. |
|
||||||
7. **Закрытие:** `etcp_connection_close(etcp)` — 2-фазное: Phase 1 — detach от внешнего мира (линки, таймеры, роутинг), Phase 2 — отложенное освобождение ресурсов (очереди, пулы памяти, callback'и, struct) когда ref_count=0. |
|
||||||
|
|
||||||
### 2.2. Ключевые концепции |
|
||||||
|
|
||||||
#### Очереди данных (data flow) |
|
||||||
|
|
||||||
``` |
|
||||||
┌──────────────┐ |
|
||||||
et cp_int_send ──► │ input_queue │ входная очередь (ETCP_FRAGMENT из io_pool) |
|
||||||
└──────┬───────┘ |
|
||||||
│ input_queue_cb: перенос во inflight с присвоением seq |
|
||||||
┌──────▼───────┐ |
|
||||||
│ input_send_q │ очередь на отправку (INFLIGHT_PACKET из inflight_pool) |
|
||||||
└──────┬───────┘ |
|
||||||
│ etcp_request_pkt: формирует ETCP_DGRAM с секциями ACK+PAYLOAD |
|
||||||
┌──────▼───────┐ |
|
||||||
│input_wait_ack│ ожидание ACK (INFLIGHT_PACKET, index по seq) |
|
||||||
└──────┬───────┘ |
|
||||||
│ etcp_ack_recv: ACK получен → освобождение inflight |
|
||||||
[удалён] |
|
||||||
``` |
|
||||||
|
|
||||||
``` |
|
||||||
Приём: |
|
||||||
┌──────────┐ |
|
||||||
etcp_conn_input ──► │ recv_q │ очередь сборки (ETCP_FRAGMENT, index по seq) |
|
||||||
└────┬─────┘ |
|
||||||
│ etcp_output_try_assembly: поиск непрерывной последовательности |
|
||||||
┌────▼──────┐ |
|
||||||
│output_queue│ собранные пакеты для потребителя |
|
||||||
└───────────┘ |
|
||||||
``` |
|
||||||
|
|
||||||
- **`input_queue`** (ETCP_FRAGMENT) — пакеты от приложения к отправке. Callback `input_queue_cb` переносит их в `input_send_q`, создавая `INFLIGHT_PACKET` с seq. |
|
||||||
- **`input_send_q`** (INFLIGHT_PACKET, hash-индекс по seq) — ожидающие отправки (новые или ретрансмиссии). Callback `input_send_q_cb` вызывает `etcp_conn_process_send_queue`. |
|
||||||
- **`input_wait_ack`** (INFLIGHT_PACKET, hash-индекс по seq) — отправленные пакеты, ожидающие ACK. Callback `wait_ack_cb` запускает retrans-таймер. |
|
||||||
- **`recv_q`** (ETCP_FRAGMENT, hash-индекс по seq) — принятые фрагменты, ждущие сборки. |
|
||||||
- **`output_queue`** — собранные непрерывные пакеты для потребителя. |
|
||||||
- **`ack_q`** (ACK_PACKET, hash-индекс по seq) — неотправленные ACK подтверждения, ожидающие piggyback. |
|
||||||
- **`transit_queues`** — транзитные очереди для роутинга (хеш по `src_node_id:dst_node_id`). |
|
||||||
|
|
||||||
#### Ретрансмиссия с экспоненциальным backoff |
|
||||||
|
|
||||||
- Таймаут ретрансмиссии: `timeout = (rtt_avg_10 * K1 + jitter * K2) / 16`, где `K1=32`, `K2=32`. |
|
||||||
- Минимальный timeout: 50 tb (5ms), максимальный: 10000 tb (1000ms). |
|
||||||
- Пакеты в `input_wait_ack` упорядочены по времени отправки (FIFO). Проверка (`ack_timeout_check`) идёт с головы: как только найден пакет с неистекшим таймаутом — взводится таймер до его истечения, дальше не сканируем. |
|
||||||
- Ретрансмит: перенос из `input_wait_ack` в `input_send_q`, инкремент `send_count`, добавление в `send_hist`. |
|
||||||
- При ретрансмите старый линк (`last_link`) получает `total_retransmissions++` и вычитание из `inflight_bytes/packets`. |
|
||||||
|
|
||||||
#### RTT/Jitter/Bandwidth метрики |
|
||||||
|
|
||||||
- **RTT:** измеряется через секцию `ETCP_SECTION_TIMESTAMP` — результирующий `rtt_last` на соединение берётся как среднее по всем линкам (rtt_sum/cnt), `rtt_avg_10` — максимум RTT по линкам. |
|
||||||
- **Jitter:** per-link экспоненциальное сглаживание разности RTT: `jitter += (|new_rtt - prev_rtt| * 65536 - jitter) / 32`. На соединении — среднее по линкам. |
|
||||||
- **TT (transmission time):** время доставки отправленных пакетов, вычисляется из timestamp-секции. |
|
||||||
- **RT (recv time):** время доставки принятых пакетов. |
|
||||||
- **Bandwidth:** per-link, обновляется из BBR pacing rate и burst-измерений. |
|
||||||
|
|
||||||
#### Burst bandwidth measurement |
|
||||||
|
|
||||||
- Отправитель формирует пачку из `BURST_PACKET_COUNT` (12) пакетов, каждый содержит секцию `MEAS_TS` (type=0x07) с burst_id, flags, порядковым номером и µs-таймстемпом. |
|
||||||
- Флаги: `IS_FIRST`, `IS_LAST`, `IS_FILLER` (если нет данных — пакет заполняется FILLER-секцией). |
|
||||||
- Пропускаются первые `BURST_SKIP_COUNT` (3) пакета для исключения переходных процессов при замере inter-packet gap. |
|
||||||
- Приёмник собирает времена прихода, вычисляет min/avg gap между пакетами, отправляет ответ `MEAS_RESP` (type=0x08) с gap_avg, gap_min, pkt_count. |
|
||||||
- Bandwidth вычисляется как: `BW = pkt_size * 8000 / gap_min` (Kbps), BDP = `BW * 1000 / 8 * min_rtt_sec`. |
|
||||||
- Минимальный интервал между burst: 500ms. Таймаут ожидания ответа: 2s. |
|
||||||
- Ответ может быть piggyback'нут в обычный пакет (вне активного burst). |
|
||||||
|
|
||||||
#### Channel timestamp handling |
|
||||||
|
|
||||||
- Секция `ETCP_SECTION_TIMESTAMP` (type=0x06, 5 байт): добавляется когда есть новые данные о времени приёма от пира. |
|
||||||
- Содержит: ret_ts (текущее время пира на момент получения нашего пакета) и dt (разница local_time - timestamp пакета). |
|
||||||
- Позволяет вычислять RTT, jitter, tt, rt на всех линках, а также `recv_dt_avg_rx/tx` — экспоненциально сглаженные оценки односторонних задержек. |
|
||||||
|
|
||||||
#### 2-phase deferred cleanup |
|
||||||
|
|
||||||
- **Phase 1** (синхронно в `etcp_connection_close`): detach от внешнего мира — закрытие линков, отмена таймеров, остановка метрик, удаление из роутинга, удаление из очереди `instance->connections`, установка `state=2`. |
|
||||||
- **Phase 2** (отложено через `uasync_call_soon`): освобождение очередей, memory_pool'ов, callback-цепочек, struct. Выполняется когда `ref_count == 0`. Если есть внешние ссылки — ждёт `etcp_conn_ref_free()`. |
|
||||||
- `ref_count` нужен для безопасного доступа к conn из асинхронных контекстов (коллбэки, роутинг, BGP). |
|
||||||
|
|
||||||
#### Backpressure (пороговое ожидание) |
|
||||||
|
|
||||||
- `input_queue` имеет порог 0 (ждёт полного освобождения) — новые пакеты добавляются только когда очередь пуста. |
|
||||||
- `etcp_conn_process_send_queue` пробует протолкнуть данные из `input_queue` → `input_send_q` когда `wait_ack_bytes <= optimal_inflight`. |
|
||||||
- При ACK вызывается `input_queue_try_resume` — если `wait_ack_bytes <= optimal_inflight` и input_send_q пуста, возобновляет `input_queue_cb`. |
|
||||||
|
|
||||||
#### Normalizer (фрагментация/сборка) |
|
||||||
|
|
||||||
- `struct PKTNORM` — per-connection фрагментатор/дефрагментатор. Разбивает большие пакеты на части ≤ `frag_size` (MTU - overhead). |
|
||||||
- При reinit/reset несобранные фрагменты возвращаются в normalizer для повторной обработки (`etcp_return_inflight_to_normalizer`). |
|
||||||
|
|
||||||
### 2.3. State machine |
|
||||||
|
|
||||||
| Поле | Значения | Описание | |
|
||||||
|------|----------|----------| |
|
||||||
| `state` | 0=pending, 1=ready, 2=deleted | Внешнее состояние conn | |
|
||||||
| `initialized` | 0/1 | Хотя бы один линк прошёл обмен ключами | |
|
||||||
| `reset_done` | 0/1 | 0=reinit разрешён, 1=соединение стабильно | |
|
||||||
| `tx_state` | DATA_WAIT(1)/LINK_WAIT(2) | DATA_WAIT=можно отправлять, LINK_WAIT=все линки busy | |
|
||||||
| `links_up` | 0/1 | Хотя бы один линк в статусе up | |
|
||||||
| `got_initial_pkt` | 0/1 | Получен ли первый пакет (seq=1) после reset | |
|
||||||
| `routing_exchange_active` | 0-4 | Статус BGP-обмена | |
|
||||||
|
|
||||||
## 3. API |
|
||||||
|
|
||||||
### 3.1. Основные структуры |
|
||||||
|
|
||||||
#### `struct ETCP_CONN` (`etcp.h:140`) |
|
||||||
|
|
||||||
Главная управляющая структура соединения. Содержит: |
|
||||||
- **Состояние:** `state`, `ref_count`, `initialized`, `reset_done`, `links_up`, `tx_state`. |
|
||||||
- **Очереди:** `input_queue`, `input_send_q`, `input_wait_ack`, `recv_q`, `output_queue`, `ack_q`, `transit_queues`. |
|
||||||
- **Пулы памяти:** `inflight_pool` (для INFLIGHT_PACKET), `io_pool` (для ETCP_FRAGMENT). |
|
||||||
- **Линки:** связный список `links`, `last_rr_link` (round-robin для load balancer). |
|
||||||
- **Крипто:** `crypto_ctx` (secure_channel), `peer_ed25519_pubkey`. |
|
||||||
- **Нормалайзер:** `normalizer` (PKTNORM) — фрагментация/сборка. |
|
||||||
- **Метрики:** `rtt_last/avg_10/avg_100`, `jitter`, `tt_last`, окна (unacked_bytes, max_inflight, optimal_inflight). |
|
||||||
- **Таймеры:** `retrans_timer`, `ack_resp_timer`. |
|
||||||
- **Callback-цепочки:** `ready_cbks`, `up_cbks`, `down_cbks`, `bgp_ready_cbk`. |
|
||||||
- **Счётчики:** ACK hit/miss, дубликаты, ретрансмиссии, `debug[8]` для live watch. |
|
||||||
- **Метрики качества:** `metrics` (гистограммы RTT/потерь с 10-мин снимками, тотальные счётчики). |
|
||||||
- **Идентификация:** `log_name` (формат `XXXX→YYYY [name]`), `name` (из конфига), `session_id`. |
|
||||||
|
|
||||||
#### `struct INFLIGHT_PACKET` (`etcp.h:108`) |
|
||||||
|
|
||||||
Пакет в состоянии inflight (отправлен или ждёт отправки). Поля: |
|
||||||
- `seq` — sequence number (ID по протоколу). |
|
||||||
- `state` — `WAIT_SEND` (в input_send_q) или `WAIT_ACK` (в input_wait_ack). |
|
||||||
- `last_link` — последний линк, через который отправлен (для retrans/loss detection). |
|
||||||
- `last_timestamp` — время последней отправки (для retrans timeout). |
|
||||||
- `send_count` — количество попыток отправки. |
|
||||||
- `retrans_req_count` — количество запросов ретрансмиссии. |
|
||||||
- `send_hist[8]` — номера линков через которые передавался (кольцевой буфер, send_count — head). |
|
||||||
- `delivered_at_send`, `inflight_at_send`, `is_app_limited` — снэпшоты для BBR rate estimation. |
|
||||||
|
|
||||||
#### `struct ETCP_FRAGMENT` (`etcp.h:123`) |
|
||||||
|
|
||||||
Фрагмент данных в очередях ввода/вывода. Поля: |
|
||||||
- `seq` — sequence number. |
|
||||||
- `timestamp` — timestamp пакета (от удалённой стороны при приёме). |
|
||||||
- `ll` — `ll_entry` с dgram (указатель на data_pool) и len. |
|
||||||
|
|
||||||
#### `struct ACK_PACKET` (`etcp.h:129`) |
|
||||||
|
|
||||||
Неотправленное подтверждение приёма. Поля: |
|
||||||
- `seq` — sequence number подтверждаемого пакета. |
|
||||||
- `pkt_timestamp` — timestamp подтверждаемого пакета (часы удалённой стороны). |
|
||||||
- `recv_timestamp` — локальное время приёма (для вычисления задержки ACK). |
|
||||||
|
|
||||||
#### `struct etcp_metrics` (`etcp.h:70`) |
|
||||||
|
|
||||||
Гистограммы и счётчики качества соединения: |
|
||||||
- **Рабочие гистограммы:** `rtt_hist[12]`, `loss_hist[11]` — обновляются в реальном времени. |
|
||||||
- **Финальные снимки:** `rtt_hist_final[12]`, `loss_hist_final[11]` — копируются раз в 10 мин. |
|
||||||
- **Счётчики окна:** `work_samples/sent/rcvd/bytes_sent/bytes_rcvd/lost` — сбрасываются при снимке. |
|
||||||
- **Тотальные:** `total_sent/rcvd/bytes_sent/bytes_rcvd/lost` — кумулятивные счётчики. |
|
||||||
- **RTT-бакеты:** 0-1, 1-2, 2-3, 3-5, 5-8, 8-13, 13-21, 21-34, 34-55, 55-90, 90-150, 150+ ms (в 0.1ms). |
|
||||||
- **Loss-бакеты:** 0%, 1%, ..., 10%+. |
|
||||||
- Интервал снимка: 10 мин. Минимум пакетов для обновления: 200. |
|
||||||
|
|
||||||
### 3.2. Основные функции |
|
||||||
|
|
||||||
#### Жизненный цикл |
|
||||||
|
|
||||||
| Функция | Описание | |
|
||||||
|---------|----------| |
|
||||||
| `etcp_connection_create(instance, name)` | Создаёт ETCP_CONN, очереди, пулы, нормалайзер, помещает в `instance->connections` с key=0 (pending). | |
|
||||||
| `etcp_connection_close(etcp)` | Phase 1: detach (линки, таймеры, роутинг). Phase 2: deferred free когда ref_count=0. | |
|
||||||
| `etcp_conn_ref_take(conn)` | Увеличивает ref_count. Возвращает -1 если conn удалён. | |
|
||||||
| `etcp_conn_ref_free(conn)` | Уменьшает ref_count. Если 0 и state==2 — планирует Phase 2. | |
|
||||||
| `etcp_conn_reset(etcp)` | Сброс состояния после reinit: seq, метрики, очистка очередей, возврат данных в нормалайзер. | |
|
||||||
| `etcp_conn_reinit(etcp)` | Полный reinit: сброс флагов, сброс NAT, сброс роутера, вызов `etcp_conn_reset`. | |
|
||||||
| `etcp_links_reset(etcp)` | Сброс флага initialized у всех линков (после сбоя). | |
|
||||||
| `etcp_conn_ready(conn)` | Вызывается когда первый линк проинициализирован. Устанавливает `initialized=1`, `reset_done=1`, запускает `conn_queue_set_ready`. | |
|
||||||
| `etcp_conn_queue_set_ready(conn)` | Переиндексирует соединение в `instance->connections` с реальным `peer_node_id`, state=1, запускает ready/up callback'и, стартует таймер метрик. | |
|
||||||
| `etcp_conn_set_peer_node_id(conn, id)` | Устанавливает peer_node_id. Если state=1 — переиндексирует в очереди. | |
|
||||||
| `etcp_conn_on_inflight_lim_changed(etcp)` | Пересчитывает `optimal_inflight` как сумму `inflight_lim_bytes` всех линков. | |
|
||||||
| `etcp_update_mtu(etcp)` | Пересчитывает MTU соединения как минимум MTU всех линков. Обновляет `frag_size` нормалайзера. | |
|
||||||
|
|
||||||
#### Отправка |
|
||||||
|
|
||||||
| Функция | Описание | |
|
||||||
|---------|----------| |
|
||||||
| `etcp_int_send(etcp, data, len)` | Отправка данных через ETCP: аллокация из data_pool, создание ETCP_FRAGMENT, помещение в input_queue. | |
|
||||||
| `etcp_request_pkt(etcp)` | Формирует ETCP_DGRAM для отправки: выбирает линк через load balancer, берёт INFLIGHT_PACKET из input_send_q, добавляет ACK-секцию, опциональные секции (MEAS_TS, MEAS_RESP, TIMESTAMP, FILLER), payload. Перемещает inflight в wait_ack. | |
|
||||||
| `etcp_encrypt_send(dgram)` | (etcp_connections.c) Шифрует ETCP_DGRAM (AES-CCM), добавляет nonce/tag/crc32/pubkey, отправляет через udp_send. | |
|
||||||
|
|
||||||
#### Приём |
|
||||||
|
|
||||||
| Функция | Описание | |
|
||||||
|---------|----------| |
|
||||||
| `etcp_conn_input(pkt)` | Обработка расшифрованного пакета: разбор секций (ACK, TIMESTAMP, PAYLOAD, MEAS_TS, MEAS_RESP, FILLER, METRICS), вызов `etcp_ack_recv`, добавление данных в `recv_q`/`ack_q`. | |
|
||||||
| `etcp_ack_recv(etcp, seq, ts, dts)` | Обработка ACK: поиск пакета в `input_wait_ack`/`input_send_q`, вычитание inflight с линка, BBR rate estimation, освобождение памяти. | |
|
||||||
| `etcp_output_try_assembly(etcp)` | Сборка выходной очереди: ищет непрерывную последовательность от `last_delivered_id+1` в `recv_q`, переносит в `output_queue`. | |
|
||||||
| `etcp_stats(etcp)` | Вывод статистики в debug-лог: размеры очередей, RTT, счётчики, ID. | |
|
||||||
|
|
||||||
#### Callback'и / События |
|
||||||
|
|
||||||
| Функция | Описание | |
|
||||||
|---------|----------| |
|
||||||
| `etcp_on_link_down(etcp)` | Вызывается при падении линка. Проверяет все линки, если все down — вызывает `etcp_on_down`. | |
|
||||||
| `etcp_on_up(etcp)` | Запуск цепочки `up_cbks`. | |
|
||||||
| `etcp_on_down(etcp)` | Запуск цепочки `down_cbks`. | |
|
||||||
|
|
||||||
#### Метрики качества |
|
||||||
|
|
||||||
| Функция | Описание | |
|
||||||
|---------|----------| |
|
||||||
| `etcp_metrics_init(m)` | Обнуление структуры метрик. | |
|
||||||
| `etcp_metrics_add_rtt(etcp, rtt_tb)` | Добавление RTT-замера в гистограмму. | |
|
||||||
| `etcp_metrics_add_sent(etcp, len)` | Учёт отправленного пакета (working + total). | |
|
||||||
| `etcp_metrics_add_rcvd(etcp, len)` | Учёт принятого пакета. | |
|
||||||
| `etcp_metrics_add_loss(etcp, count)` | Учёт потерь. | |
|
||||||
| `etcp_metrics_start_timer(etcp)` | Запуск 10-минутного таймера снимков. | |
|
||||||
| `etcp_metrics_stop_timer(etcp)` | Остановка таймера метрик. | |
|
||||||
|
|
||||||
### 3.3. Константы |
|
||||||
|
|
||||||
| Константа | Значение | Описание | |
|
||||||
|-----------|----------|----------| |
|
||||||
| `MAX_INFLIGHT_BYTES` | 65536 | Начальное окно | |
|
||||||
| `RETRANS_K1` | 32 | Множитель RTT для retrans timeout | |
|
||||||
| `RETRANS_K2` | 32 | Множитель jitter для retrans timeout | |
|
||||||
| `ACK_DELAY_TB` | 20 | Задержка отправки ACK (2ms) | |
|
||||||
| `RTT_HISTORY_SIZE` | 10 | Размер истории RTT для jitter | |
|
||||||
| `INFLIGHT_INITIAL_HASH_SIZE` | 1024 | Начальный размер хеш-таблиц | |
|
||||||
| `MAX_INFLIGHT_SIZE` | 16384 | Максимум элементов в recv_q (защита от атак) | |
|
||||||
| `ASM_BUF_MAX_SIZE` | 65536 | Максимальный размер буфера сборки | |
|
||||||
| `BURST_PACKET_COUNT` | 12 | Пакетов в burst | |
|
||||||
| `BURST_SKIP_COUNT` | 3 | Пропускаемых пакетов при замере gap | |
|
||||||
| `MIN_BURST_INTERVAL_TB` | 5000 | Мин. интервал между burst (500ms) | |
|
||||||
| `BURST_RESP_TIMEOUT_TB` | 20000 | Таймаут ответа на burst (2s) | |
|
||||||
| `ETCP_METRICS_RTT_BUCKETS` | 12 | Число RTT-бакетов в гистограмме | |
|
||||||
| `ETCP_METRICS_LOSS_BUCKETS` | 11 | Число loss-бакетов | |
|
||||||
| `ETCP_METRICS_INTERVAL_TB` | 6000000 | Интервал снимков (10 мин) | |
|
||||||
| `ETCP_METRICS_MIN_PACKETS` | 200 | Мин. пакетов для снимка | |
|
||||||
|
|
||||||
### 3.4. Секции пакета |
|
||||||
|
|
||||||
| Секция | Type | Размер | Описание | |
|
||||||
|--------|------|--------|----------| |
|
||||||
| `PAYLOAD` | 0x00 | 5 + data | Данные: type(1) + seq(4) + payload | |
|
||||||
| `ACK` | 0x01 | 8 + N*8 | ACK: type(1) + count(1) + last_delivered_id(4) + rx_dup_count(2) + N×{seq(4) + recv_ts(2) + delay(2)} | |
|
||||||
| `TIMESTAMP` | 0x06 | 5 | Channel timestamp: type(1) + ret_ts(2) + dt(2) | |
|
||||||
| `MEAS_TS` | 0x07 | 9 | Burst measurement: type(1) + burst_id(2) + flags(1) + seq(1) + ts_us(2) + pkt_sz(2) | |
|
||||||
| `MEAS_RESP` | 0x08 | 13 | Burst response: type(1) + burst_id(2) + valid(1) + gap_avg(4) + gap_min(4) + pkt_count(1) | |
|
||||||
| `FILLER` | 0x09 | 3 + N | Filler padding: type(1) + len(2) + zeros(N) | |
|
||||||
| `METRICS` | 0x0A | 2 + 64 + N | Metrics CSV: type(1) + csv_len(2) + ed25519_sig(64) + csv_data(N) | |
|
||||||
|
|
||||||
### 3.5. Зависимости |
|
||||||
|
|
||||||
| Модуль | Как используется | |
|
||||||
|--------|-----------------| |
|
||||||
| `etcp_connections.h` | ETCP_LINK, ETCP_DGRAM, ETCP_SOCKET, etcp_link_new/close, etcp_encrypt_send | |
|
||||||
| `etcp_loadbalancer.h` | etcp_loadbalancer_select_link, etcp_loadbalancer_send | |
|
||||||
| `etcp_router.h` | etcp_router_transit_queues_destroy, etcp_router_pause_retrans_for_node | |
|
||||||
| `etcp_debug.h` | etcp_dump_pkt_sections | |
|
||||||
| `etcp_connect.h` | etcp_connect_cancel_for_conn | |
|
||||||
| `pkt_normalizer.h` | PKTNORM (pn_init, pn_deinit, pn_reset) | |
|
||||||
| `secure_channel.h` | sc_context_t для шифрования | |
|
||||||
| `routing.h` | routing_del_conn | |
|
||||||
| `topo_group.h` | route_ping_cancel_for_conn | |
|
||||||
| `../lib/ll_queue.h` | Все очереди | |
|
||||||
| `../lib/u_async.h` | uasync_set_timeout, uasync_call_soon | |
|
||||||
| `../lib/memory_pool.h` | memory_pool_alloc/free/init/destroy | |
|
||||||
| `../lib/mem.h` | u_malloc, u_calloc, u_realloc, u_free, u_strdup | |
|
||||||
| `../lib/debug_config.h` | DEBUG_ERROR/WARN/INFO/DEBUG/TRACE | |
|
||||||
@ -1,51 +0,0 @@ |
|||||||
# ETCP Load Balancer (etcp_loadbalancer) |
|
||||||
|
|
||||||
## 1. Назначение |
|
||||||
Балансировка исходящего трафика ETCP между несколькими линками (UDP-сокетами) внутри одного ETCP_CONN. Выбирает оптимальный линк по минимальному `inflight_bytes`, при равенстве — round-robin. Для каждого линка работает traffic shaper — ограничение полосы пропускания (bandwidth pacing) с таймерной задержкой и burst-режимом. |
|
||||||
|
|
||||||
## 2. Как пользоваться |
|
||||||
Типовой сценарий: перед отправкой пакета вызывается `etcp_loadbalancer_send(dgram)`. Функция сама выбирает линк (если он ещё не задан), отправляет и обновляет shaper-нагрузку линка. |
|
||||||
|
|
||||||
```c |
|
||||||
// Отправка пакета через loadbalancer |
|
||||||
struct ETCP_DGRAM* dgram = memory_pool_alloc(inst->pkt_pool); |
|
||||||
// ... заполнение dgram ... |
|
||||||
etcp_loadbalancer_send(dgram); // сам выберет линк, зашифрует, отправит, освободит dgram |
|
||||||
``` |
|
||||||
|
|
||||||
Если все линки заняты (shaper-таймер или inflight превышает лимит), пакет дропается. При освобождении линка shaper-таймер вызывает `loadbalancer_link_ready()`, который нотифицирует `ETCP_CONN->link_ready_for_send_fn`. |
|
||||||
|
|
||||||
```c |
|
||||||
// Проверка статуса связи |
|
||||||
if (etcp_loadbalancer_get_link_status(etcp)) { |
|
||||||
// есть хотя бы один живой линк |
|
||||||
} |
|
||||||
``` |
|
||||||
|
|
||||||
**Нюансы:** |
|
||||||
- Алгоритм выбора: min `inflight_bytes`, среди равных — round-robin (поле `last_rr_link` в ETCP_CONN) |
|
||||||
- Shaper работает через `shaper_load_time_tb` / `shaper_sub_nanotime` — виртуальное время передачи, сравнивается с `now_tb + SHAPER_BURST_DELAY_TB` (1ms) |
|
||||||
- Burst-пакеты (`link->burst_active`) обходят shaper |
|
||||||
- При безлимитном bandwidth (`link->bandwidth == 0`) shaper пропускается |
|
||||||
- `etcp_loadbalancer_send()` освобождает dgram через `memory_pool_free()` — после вызова dgram недействителен |
|
||||||
|
|
||||||
## 3. API |
|
||||||
|
|
||||||
### Структуры |
|
||||||
Поля ETCP_LINK, используемые балансировщиком: |
|
||||||
- `initialized` — линк готов к работе |
|
||||||
- `link_status` — 1 = линк жив |
|
||||||
- `inflight_bytes` — байт в полёте (минимизируемый критерий) |
|
||||||
- `burst_active` — 1 = burst bypass всех ограничений |
|
||||||
- `shaper_timer` — активный таймер задержки shaper'а |
|
||||||
- `bandwidth` — Kbps, 0 = безлимит |
|
||||||
- `shaper_load_time_tb`, `shaper_sub_nanotime` — аккумулированное время передачи (0.1ms timebase) |
|
||||||
|
|
||||||
### Функции |
|
||||||
| Функция | Описание | |
|
||||||
|---|---| |
|
||||||
| `etcp_loadbalancer_select_link(etcp)` | Выбрать линк по min inflight_bytes с round-robin. NULL если все заняты | |
|
||||||
| `etcp_loadbalancer_send(dgram)` | Выбрать линк → зашифровать/отправить → обновить shaper → освободить dgram | |
|
||||||
| `loadbalancer_link_can_send(link)` | 1 если линк не заблокирован shaper'ом и burst не активен | |
|
||||||
| `loadbalancer_link_ready(link)` | Уведомить ETCP_CONN о готовности линка (вызывает `link_ready_for_send_fn`) | |
|
||||||
| `etcp_loadbalancer_get_link_status(etcp)` | 1 = есть живой линк, 0 = все недоступны | |
|
||||||
@ -1,32 +0,0 @@ |
|||||||
сделай тест проверки отправкив в udp (etcp_loadbalancer) |
|
||||||
|
|
||||||
|
|
||||||
1. инициализируешь etcp без линков, и один сокет для работы |
|
||||||
2. вписываешь в link_ready_for_send_fn свою функцию |
|
||||||
3. в тесте открываешь ответный сокет |
|
||||||
4. добавляешь линк к etcp |
|
||||||
5. |
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
link initialization: |
|
||||||
|
|
||||||
client: |
|
||||||
|
|
||||||
1. init timer: |
|
||||||
- шлём init with reset |
|
||||||
|
|
||||||
Получили response: |
|
||||||
- отменяем init, переходим в обычный режим + keepalive |
|
||||||
|
|
||||||
link не отвечает: |
|
||||||
- шлём init without reset |
|
||||||
|
|
||||||
server: |
|
||||||
- просто ждёт init request. |
|
||||||
как получил init, делает линк инициализированным. |
|
||||||
|
|
||||||
общая логика keepalive (client+server): |
|
||||||
далее на init линках шлём keepalive со статусом remote keepalive. |
|
||||||
если remote keepalive =0 - значит на другой стороне всё плохо и не шлём данные (только keepalive) |
|
||||||
@ -1,52 +0,0 @@ |
|||||||
# STCP (Secure TCP) — общая часть соединения |
|
||||||
|
|
||||||
## 1. Назначение |
|
||||||
|
|
||||||
STCP — потоковый TCP-протокол с X25519-ключеобменом и потоковым AES-CTR шифрованием (stream cipher). Обеспечивает безопасное TCP-соединение: клиент подключается, сервер принимает, выполняется ECDH-рукопожатие с обфускацией публичных ключей, после чего трафик шифруется AES-CTR с контрольными суммами CRC32. |
|
||||||
|
|
||||||
Модуль `stcp.c/stcp.h` содержит общие структуры, константы и базовый жизненный цикл соединения `struct stcp_conn`, используемый как клиентской (`stcp_client`), так и серверной (`stcp_server`) сторонами. |
|
||||||
|
|
||||||
## 2. Как пользоваться |
|
||||||
|
|
||||||
Типовая схема: вышестоящий код создаёт `struct stcp_conn` (сервер через `stcp_server_create`, клиент — через `stcp_client_connect`), устанавливает очереди приёма/передачи (`stcp_conn_set_tx_queue`, `stcp_conn_set_rx_queue`), коллбэк закрытия (`stcp_conn_set_on_close`). После рукопожатия (`STCP_STATE_DATA`) сообщения передаются через `rx_queue`/`tx_queue`: отправка — через ll_queue с коллбэком `tx_cb`, приём — данные раскладываются в `rx_queue`. |
|
||||||
|
|
||||||
Потоковое шифрование (`sc_stream_state`) не требует буферизации целых сообщений — XOR применяется побайтово к потоку, поэтому порядок отправки/приёма критичен. Для каждого направления создаётся отдельный stream (`stream_send`, `stream_recv`). |
|
||||||
|
|
||||||
Ключевые нюансы: |
|
||||||
- Размер сообщения — `uint16_t` в префиксе, макс. 65535 байт. |
|
||||||
- Каждое сообщение шифруется: 2 байта длины + данные + 4 байта CRC32. |
|
||||||
- CRC32 проверяется после расшифровки для детектирования повреждений. |
|
||||||
- При разрыве соединения или ошибке вызывается `on_close`. |
|
||||||
|
|
||||||
## 3. API |
|
||||||
|
|
||||||
### Состояния |
|
||||||
- `STCP_STATE_INIT` — начальное (на клиенте) |
|
||||||
- `STCP_STATE_HS_SERVER_WAIT` — сервер ждёт рукопожатия от клиента |
|
||||||
- `STCP_STATE_DATA` — активный обмен данными (шифрованный) |
|
||||||
- `STCP_STATE_CLOSED` / `STCP_STATE_ERROR` — завершение |
|
||||||
|
|
||||||
### stcp_conn — структура соединения |
|
||||||
| Поле | Описание | |
|
||||||
|------|----------| |
|
||||||
| `sock` | TCP-сокет | |
|
||||||
| `ua` | UASYNC event loop | |
|
||||||
| `state` | Текущее состояние (enum stcp_state) | |
|
||||||
| `is_server` | 1 = серверная сторона | |
|
||||||
| `session_key[SC_SESSION_KEY_SIZE]` | Ключ X25519 ECDH (AES-128) | |
|
||||||
| `stream_send` / `stream_recv` | Состояния потокового AES-CTR для отправки и приёма | |
|
||||||
| `my_keys` | Локальные ключи X25519 | |
|
||||||
| `peer_pubkey` | Публичный ключ пира (после рукопожатия) | |
|
||||||
| `rx_queue` / `tx_queue` | ll_queue для приёма/отправки сообщений | |
|
||||||
| `tx_cb` | Коллбэк очереди tx_queue | |
|
||||||
| `recv_buf` | Буфер приёма TCP (динамический, до 128KB) | |
|
||||||
| `send_buf` | Буфер отправки (для досыла при EAGAIN) | |
|
||||||
| `hs_expected_len` / `hs_key_processed` | Состояние рукопожатия | |
|
||||||
| `on_ready` | Вызывается после завершения рукопожатия | |
|
||||||
| `on_close` | Вызывается при закрытии соединения | |
|
||||||
|
|
||||||
### Функции |
|
||||||
- `stcp_conn_set_tx_queue(c, q)` — установить очередь отправки, привязывает `tx_cb` как коллбэк |
|
||||||
- `stcp_conn_set_rx_queue(c, q)` — установить очередь приёма (в неё кладутся расшифрованные сообщения) |
|
||||||
- `stcp_conn_set_on_close(c, cb, arg)` — установить коллбэк закрытия (err=0 — норма, иначе код ошибки) |
|
||||||
- `stcp_conn_free(c)` — освободить сокет, буферы, очистить stream-ы. Если `allocated=1` — освободить и саму структуру |
|
||||||
@ -0,0 +1,271 @@ |
|||||||
|
#!/usr/bin/env python3 |
||||||
|
""" |
||||||
|
chat_invite_test.py — headless test of the inviter-side invite flow. |
||||||
|
|
||||||
|
Сценарий: A (owner) говорит B (серверу) «добавь себе мою группу» |
||||||
|
(CS_MSG_CHANNEL_INVITE), B авто-принимает (join_policy=0) и join+member_sync |
||||||
|
завершается. Проверяем, что канал и мемберы появились на обеих сторонах. |
||||||
|
|
||||||
|
Usage: |
||||||
|
python3 tools/chat_invite_test.py |
||||||
|
""" |
||||||
|
|
||||||
|
import asyncio |
||||||
|
import json |
||||||
|
import os |
||||||
|
import socket |
||||||
|
import sys |
||||||
|
import tempfile |
||||||
|
import time |
||||||
|
|
||||||
|
sys.path.insert(0, os.path.dirname(__file__)) |
||||||
|
from chat_client import ChatClient, ChatClientError |
||||||
|
|
||||||
|
UTUN_BIN = os.path.join(os.path.dirname(__file__), "..", "src", "utun") |
||||||
|
READY_TIMEOUT = 3.0 # max wait for utun ready |
||||||
|
SYNC_TIMEOUT = 10.0 # max wait for join + sync |
||||||
|
REQUEST_TIMEOUT = 5.0 # per-request timeout |
||||||
|
TOTAL_TIMEOUT = 30.0 # overall test timeout |
||||||
|
|
||||||
|
|
||||||
|
def find_free_port(): |
||||||
|
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
||||||
|
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) |
||||||
|
s.bind(("127.0.0.1", 0)) |
||||||
|
port = s.getsockname()[1] |
||||||
|
s.close() |
||||||
|
return port |
||||||
|
|
||||||
|
|
||||||
|
def write_config(path, etcp_port, ctrl_port, db_subdir, join_policy=None): |
||||||
|
chat_section = "" |
||||||
|
if join_policy is not None: |
||||||
|
chat_section = f"\n[chat]\njoin_policy={join_policy}\n" |
||||||
|
content = f"""[global] |
||||||
|
db_path={db_subdir} |
||||||
|
|
||||||
|
[server: srv] |
||||||
|
addr=127.0.0.1:{etcp_port} |
||||||
|
type=public |
||||||
|
|
||||||
|
[chatserver] |
||||||
|
db_path={db_subdir} |
||||||
|
headless_control_bind=127.0.0.1:{ctrl_port} |
||||||
|
{chat_section} |
||||||
|
[allowed_keys] |
||||||
|
allow_all=1 |
||||||
|
""" |
||||||
|
with open(path, "w") as f: |
||||||
|
f.write(content) |
||||||
|
|
||||||
|
|
||||||
|
def read_config_key(path, key): |
||||||
|
try: |
||||||
|
with open(path, "r") as f: |
||||||
|
for line in f: |
||||||
|
line = line.strip() |
||||||
|
if line.startswith(key + "="): |
||||||
|
return line[len(key) + 1:] |
||||||
|
except OSError: |
||||||
|
return None |
||||||
|
return None |
||||||
|
|
||||||
|
|
||||||
|
async def wait_config_key(path, key, timeout=READY_TIMEOUT): |
||||||
|
deadline = time.monotonic() + timeout |
||||||
|
while time.monotonic() < deadline: |
||||||
|
val = read_config_key(path, key) |
||||||
|
if val: |
||||||
|
return val |
||||||
|
await asyncio.sleep(0.1) |
||||||
|
return None |
||||||
|
|
||||||
|
|
||||||
|
async def kill_proc(proc, label): |
||||||
|
if proc is None or proc.returncode is not None: |
||||||
|
return |
||||||
|
try: |
||||||
|
proc.terminate() |
||||||
|
try: |
||||||
|
await asyncio.wait_for(proc.wait(), timeout=3.0) |
||||||
|
except asyncio.TimeoutError: |
||||||
|
proc.kill() |
||||||
|
await proc.wait() |
||||||
|
except ProcessLookupError: |
||||||
|
pass |
||||||
|
|
||||||
|
|
||||||
|
async def wait_ready(cli, timeout=READY_TIMEOUT): |
||||||
|
deadline = time.monotonic() + timeout |
||||||
|
while time.monotonic() < deadline: |
||||||
|
try: |
||||||
|
await cli.ping() |
||||||
|
return True |
||||||
|
except ChatClientError: |
||||||
|
await asyncio.sleep(0.1) |
||||||
|
return False |
||||||
|
|
||||||
|
|
||||||
|
def check(name, expr, detail=""): |
||||||
|
if not expr: |
||||||
|
detail = f" ({detail})" if detail else "" |
||||||
|
raise AssertionError(f"FAIL: {name}{detail}") |
||||||
|
print(f" OK: {name}") |
||||||
|
|
||||||
|
|
||||||
|
async def main(): |
||||||
|
etcp_a = find_free_port() |
||||||
|
etcp_b = find_free_port() |
||||||
|
ctrl_a = find_free_port() |
||||||
|
ctrl_b = find_free_port() |
||||||
|
|
||||||
|
print(f"ports: etcp={etcp_a},{etcp_b} ctrl={ctrl_a},{ctrl_b}") |
||||||
|
|
||||||
|
tmpdir = tempfile.mkdtemp(prefix="utun_invite_test_") |
||||||
|
db_a = os.path.join(tmpdir, "db_a") |
||||||
|
db_b = os.path.join(tmpdir, "db_b") |
||||||
|
os.makedirs(db_a, exist_ok=True) |
||||||
|
os.makedirs(db_b, exist_ok=True) |
||||||
|
|
||||||
|
config_a = os.path.join(tmpdir, "a.conf") |
||||||
|
config_b = os.path.join(tmpdir, "b.conf") |
||||||
|
write_config(config_a, etcp_a, ctrl_a, db_a) # A: owner |
||||||
|
write_config(config_b, etcp_b, ctrl_b, db_b, join_policy=0) # B: server, autojoin |
||||||
|
|
||||||
|
proc_a = None |
||||||
|
proc_b = None |
||||||
|
|
||||||
|
try: |
||||||
|
print("\n--- Starting utun ---") |
||||||
|
log_a = os.path.join(tmpdir, "utun_a.log") |
||||||
|
log_b = os.path.join(tmpdir, "utun_b.log") |
||||||
|
pid_a = os.path.join(tmpdir, "utun_a.pid") |
||||||
|
pid_b = os.path.join(tmpdir, "utun_b.pid") |
||||||
|
|
||||||
|
proc_a = await asyncio.create_subprocess_exec( |
||||||
|
UTUN_BIN, "-f", "-p", pid_a, "-l", log_a, "-c", config_a, |
||||||
|
stdout=asyncio.subprocess.DEVNULL, stderr=asyncio.subprocess.DEVNULL, |
||||||
|
) |
||||||
|
proc_b = await asyncio.create_subprocess_exec( |
||||||
|
UTUN_BIN, "-f", "-p", pid_b, "-l", log_b, "-c", config_b, |
||||||
|
stdout=asyncio.subprocess.DEVNULL, stderr=asyncio.subprocess.DEVNULL, |
||||||
|
) |
||||||
|
|
||||||
|
print(f" proc_a pid={proc_a.pid} proc_b pid={proc_b.pid}") |
||||||
|
await asyncio.sleep(0.5) |
||||||
|
|
||||||
|
print("\n--- Connecting to headless control ---") |
||||||
|
async with ChatClient(port=ctrl_a, timeout=REQUEST_TIMEOUT) as cli_a: |
||||||
|
if not await wait_ready(cli_a): |
||||||
|
raise RuntimeError(f"node A not ready after {READY_TIMEOUT}s") |
||||||
|
print(f" node A ready") |
||||||
|
|
||||||
|
async with ChatClient(port=ctrl_b, timeout=REQUEST_TIMEOUT) as cli_b: |
||||||
|
if not await wait_ready(cli_b): |
||||||
|
raise RuntimeError(f"node B not ready after {READY_TIMEOUT}s") |
||||||
|
print(f" node B ready") |
||||||
|
|
||||||
|
# ── Create channel on A ── |
||||||
|
print("\n--- Create channel ---") |
||||||
|
await cli_a.create_channel("TestGroup") |
||||||
|
channels = await cli_a.channels() |
||||||
|
check("channel created", isinstance(channels, list) and len(channels) == 1, |
||||||
|
f"channels={json.dumps(channels)}") |
||||||
|
ch_id = str(channels[0]["id"]) |
||||||
|
print(f" channel_id={ch_id} name={channels[0]['name']}") |
||||||
|
|
||||||
|
# ── Read B's node_id + pubkey from config (written back by utun) ── |
||||||
|
print("\n--- Read B identity ---") |
||||||
|
b_node_id = await wait_config_key(config_b, "my_node_id") |
||||||
|
b_pubkey = await wait_config_key(config_b, "my_public_key") |
||||||
|
if not b_node_id or not b_pubkey: |
||||||
|
raise RuntimeError("failed to read B's node_id/pubkey from config") |
||||||
|
b_node_id = "0x" + b_node_id |
||||||
|
print(f" B node_id={b_node_id} pubkey={b_pubkey[:16]}...") |
||||||
|
|
||||||
|
# ── A invites B to add the channel (inviter side) ── |
||||||
|
print("\n--- Invite B (inviter → CHANNEL_INVITE) ---") |
||||||
|
resp = await cli_a.invite_to(ch_id, b_node_id, b_pubkey, f"127.0.0.1:{etcp_b}", proto=1) |
||||||
|
check("invite_to accepted", isinstance(resp, dict) and resp.get("inviting"), |
||||||
|
f"resp={json.dumps(resp)}") |
||||||
|
|
||||||
|
# ── Wait for B to join + member_sync ── |
||||||
|
print(f"\n--- Wait join + sync (max {SYNC_TIMEOUT}s) ---") |
||||||
|
deadline = time.monotonic() + SYNC_TIMEOUT |
||||||
|
member_count_b = 0 |
||||||
|
members_b = [] |
||||||
|
while time.monotonic() < deadline: |
||||||
|
try: |
||||||
|
members_b = await cli_b.members(ch_id) |
||||||
|
member_count_b = len(members_b) if isinstance(members_b, list) else 0 |
||||||
|
if member_count_b >= 2: |
||||||
|
break |
||||||
|
except ChatClientError: |
||||||
|
pass |
||||||
|
await asyncio.sleep(0.15) |
||||||
|
|
||||||
|
print(f"\n--- Members on B ({member_count_b}) ---") |
||||||
|
for m in (members_b if isinstance(members_b, list) else []): |
||||||
|
print(f" {m['node_id']} name={m.get('name','?')} online={m.get('online')} connected={m.get('connected')}") |
||||||
|
check("2 members on B (B joined A)", member_count_b >= 2, |
||||||
|
f"got {member_count_b} after {SYNC_TIMEOUT}s") |
||||||
|
|
||||||
|
await asyncio.sleep(0.5) |
||||||
|
|
||||||
|
members_a = await cli_a.members(ch_id) |
||||||
|
print(f"\n--- Members on A ({len(members_a) if isinstance(members_a, list) else '?'}) ---") |
||||||
|
for m in members_a: |
||||||
|
print(f" {m['node_id']} name={m.get('name','?')} online={m.get('online')} connected={m.get('connected')}") |
||||||
|
check("2 members on A (B visible to A)", isinstance(members_a, list) and len(members_a) >= 2, |
||||||
|
f"got {len(members_a) if isinstance(members_a, list) else '?'}") |
||||||
|
|
||||||
|
channels_b = await cli_b.channels() |
||||||
|
check("channel present on B", isinstance(channels_b, list) and len(channels_b) >= 1, |
||||||
|
f"channels_b={json.dumps(channels_b)}") |
||||||
|
|
||||||
|
print("\n=== TEST PASSED ===") |
||||||
|
return 0 |
||||||
|
|
||||||
|
except Exception as e: |
||||||
|
print(f"\n=== TEST FAILED: {e} ===", file=sys.stderr) |
||||||
|
import traceback |
||||||
|
traceback.print_exc() |
||||||
|
print(f"\n--- logs ---", file=sys.stderr) |
||||||
|
for lp in ["utun_a.log", "utun_b.log"]: |
||||||
|
lp = os.path.join(tmpdir, lp) |
||||||
|
if os.path.exists(lp): |
||||||
|
print(f"\n===== {lp} (tail) =====", file=sys.stderr) |
||||||
|
try: |
||||||
|
with open(lp, "r") as f: |
||||||
|
lines = f.readlines() |
||||||
|
for ln in lines[-80:]: |
||||||
|
sys.stderr.write(ln) |
||||||
|
except OSError: |
||||||
|
pass |
||||||
|
return 1 |
||||||
|
|
||||||
|
finally: |
||||||
|
print("\n--- Cleanup ---") |
||||||
|
await kill_proc(proc_a, "proc_a") |
||||||
|
await kill_proc(proc_b, "proc_b") |
||||||
|
|
||||||
|
for f in [config_a, config_b]: |
||||||
|
try: os.unlink(f) |
||||||
|
except OSError: pass |
||||||
|
try: os.rmdir(db_a) |
||||||
|
except OSError: pass |
||||||
|
try: os.rmdir(db_b) |
||||||
|
except OSError: pass |
||||||
|
try: os.rmdir(tmpdir) |
||||||
|
except OSError: pass |
||||||
|
print(f" temp dir cleaned: {tmpdir}") |
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__": |
||||||
|
async def _run(): |
||||||
|
try: |
||||||
|
return await asyncio.wait_for(main(), timeout=TOTAL_TIMEOUT) |
||||||
|
except asyncio.TimeoutError: |
||||||
|
print(f"\n=== TEST FAILED: total timeout {TOTAL_TIMEOUT}s ===", file=sys.stderr) |
||||||
|
return 1 |
||||||
|
sys.exit(asyncio.run(_run())) |
||||||
Loading…
Reference in new issue