diff --git a/src/transport_layer/etcp.c b/src/transport_layer/etcp.c index 09376eb4..8eed7bf0 100644 --- a/src/transport_layer/etcp.c +++ b/src/transport_layer/etcp.c @@ -400,10 +400,11 @@ void etcp_connection_close(struct ETCP_CONN* etcp) { etcp->state = 2; // deleted — blocks ref_take and etcp_send immediately if (etcp->links_up != 0) etcp->links_up = 0; - if (etcp->peer_sleeping) { - etcp->peer_sleeping = 0; + if (etcp->peer_sleep_phase) { + etcp->peer_sleep_phase = 0; utun_fire_peer_sleep_cbk(etcp->instance, etcp->peer_node_id, 0); } + if (etcp->peer_phase_timer) { uasync_cancel_timeout(etcp->instance->ua, etcp->peer_phase_timer); etcp->peer_phase_timer = NULL; } etcp_fire_conn_status(etcp, ETCP_CONN_STATUS_DELETE); DEBUG_DEBUG(DEBUG_CATEGORY_CONNECTION, "[%s] close: state=2 conn=%p peer=%016llx (DELETE fired)", etcp->log_name, (void*)etcp, (unsigned long long)etcp->peer_node_id); diff --git a/src/transport_layer/etcp.h b/src/transport_layer/etcp.h index a8fab282..d8f4c517 100644 --- a/src/transport_layer/etcp.h +++ b/src/transport_layer/etcp.h @@ -125,7 +125,10 @@ struct ETCP_CONN { // Peer info uint64_t peer_node_id; // Peer node ID uint8_t peer_ed25519_pubkey[SC_PUBKEY_SIZE]; // Ed25519 pubkey пира (из INIT) - uint8_t peer_sleeping; // 1 = пир в спячке (keepalive sleep-анонс), серверная сторона + uint8_t peer_sleep_phase; // 1 = пир в SLEEP-фазе (троттлить), 0 = ACTIVE-окно (обмен) + uint16_t peer_active_remaining; // до SLEEP-фазы (x0.1с), из keepalive + uint16_t peer_sleep_duration; // длительность SLEEP-фазы (x0.1с), из keepalive + void* peer_phase_timer; // таймер смены фазы троттлинга // ============ Processing incoming data to be sent by ETCP struct ll_queue* input_queue; // Incoming packets to send (rx_pool -> ETCP_FRAGMENT) diff --git a/src/transport_layer/etcp_connections.c b/src/transport_layer/etcp_connections.c index 4b805cd9..159d4082 100644 --- a/src/transport_layer/etcp_connections.c +++ b/src/transport_layer/etcp_connections.c @@ -1008,8 +1008,8 @@ struct ETCP_LINK* etcp_link_new(struct ETCP_CONN* etcp, struct ETCP_SOCKET* conn link->ka_sleep_period_ms = 0; link->ka_sleeping = 0; link->ka_sleep_acked = 0; - link->ka_sleep_time = 0; - link->ka_sleep_deadline_tb = 0; + link->ka_active_remaining = 0; + link->ka_sleep_duration = 0; link->ka_sleep_announce_timer = NULL; link->ka_sleep_announce_end_tb = 0; /* inflight_lim_bytes set above */ diff --git a/src/transport_layer/etcp_connections.h b/src/transport_layer/etcp_connections.h index 1bf8563b..7123116a 100644 --- a/src/transport_layer/etcp_connections.h +++ b/src/transport_layer/etcp_connections.h @@ -285,8 +285,8 @@ struct ETCP_LINK { uint16_t ka_sleep_period_ms; // период keepalive в спячке (мс; настройка клиента / ka_period_ms пира) uint8_t ka_sleeping; // 1 = линк в режиме спячки uint8_t ka_sleep_acked; // клиент: получен ack спячки от сервера - uint16_t ka_sleep_time; // дедлайн пробуждения (x0.1с), текущий - uint64_t ka_sleep_deadline_tb; // абсолютный дедлайн пробуждения (timebase 0.1мс) + uint16_t ka_active_remaining; // сколько до SLEEP-фазы (x0.1с), 0 = уже спим + uint16_t ka_sleep_duration; // длительность SLEEP-фазы (x0.1с) void* ka_sleep_announce_timer; // таймер ретрая анонса спячки (клиент) uint64_t ka_sleep_announce_end_tb; // конец окна ретрая анонса (4с) uint8_t pkt_sent_since_keepalive; // Флаг: был ли отправлен пакет с последнего keepalive тика diff --git a/src/transport_layer/etcp_keepalive.c b/src/transport_layer/etcp_keepalive.c index 8155df1d..03ae0ef2 100644 --- a/src/transport_layer/etcp_keepalive.c +++ b/src/transport_layer/etcp_keepalive.c @@ -34,7 +34,7 @@ uint16_t negotiate_keepalive(uint8_t my_type, uint16_t my_ka, return result; } -// Send keepalive packet: code(0x08) + flags + ka_period_ms + [sleep_time] +// Send keepalive packet: code(0x08) + flags + ka_period_ms + [active_remaining + sleep_duration] void etcp_link_send_keepalive(struct ETCP_LINK* link) { DEBUG_TRACE(DEBUG_CATEGORY_KEEPALIVE, ""); if (!link || !link->etcp || !link->etcp->instance) return; @@ -51,9 +51,11 @@ void etcp_link_send_keepalive(struct ETCP_LINK* link) { dgram->data[2] = link->ka_period_ms & 0xFF; dgram->data[3] = link->ka_period_ms >> 8; if (link->ka_sleeping) { - dgram->data[4] = link->ka_sleep_time & 0xFF; - dgram->data[5] = link->ka_sleep_time >> 8; - dgram->data_len = 6; + dgram->data[4] = link->ka_active_remaining & 0xFF; + dgram->data[5] = link->ka_active_remaining >> 8; + dgram->data[6] = link->ka_sleep_duration & 0xFF; + dgram->data[7] = link->ka_sleep_duration >> 8; + dgram->data_len = 8; } else { dgram->data_len = 4; } @@ -173,20 +175,6 @@ static void keepalive_timer_cb(void* arg) { } } - // Сервер: дедлайн спячки пира вышел — пир должен был проснуться/переанонсировать, - // выходим из спячки в обычный режим (базовый период, probe штатным keepalive). - if (link->is_server && link->ka_sleeping && now >= link->ka_sleep_deadline_tb) { - link->ka_sleeping = 0; - link->ka_period_ms = link->keepalive_interval; - link->keepalive_timeout = (uint32_t)link->keepalive_interval * KA_TIMEOUT_MULT; - if (link->etcp && link->etcp->peer_sleeping) { - link->etcp->peer_sleeping = 0; - utun_fire_peer_sleep_cbk(link->etcp->instance, link->etcp->peer_node_id, 0); - } - DEBUG_INFO(DEBUG_CATEGORY_KEEPALIVE, "[%s] server: sleep deadline expired, back to normal (interval=%dms)", - link->etcp->log_name, link->keepalive_interval); - } - // Период: спячка — фиксированный sleep-период; normal — адаптивный от базового. if (link->ka_sleeping) link->ka_period_ms = link->ka_sleep_period_ms; @@ -223,22 +211,32 @@ static uint16_t ka_sleep_period_ms(struct UTUN_INSTANCE* inst) { #endif } -// Дедлайн пробуждения (x0.1с): остаток SLEEP либо остаток ACTIVE + полная SLEEP. -static uint16_t ka_wake_deadline_01s(void) { +// Сколько осталось до SLEEP-фазы (x0.1с): 0 = уже спим. +static uint16_t ka_active_remaining_01s(void) { #ifdef UTUN_HAVE_STANDBY - int deadline_tb = standby_get_wake_deadline_tb(); - uint32_t v = deadline_tb > 0 ? (uint32_t)(deadline_tb / 1000) : 0; + uint32_t v = (uint32_t)(standby_get_active_remaining_tb() / 1000); return v > 65535 ? 65535 : (uint16_t)v; #else return 0; #endif } -// Отправить keepalive спячки (обновить дедлайн) + при необходимости заармить ретрай. +// Длительность SLEEP-фазы (x0.1с): в SLEEP — оставшийся сон, в ACTIVE — полная длительность. +static uint16_t ka_sleep_duration_01s(void) { +#ifdef UTUN_HAVE_STANDBY + int s = standby_get_sleep_tb(); + uint32_t v = s > 0 ? (uint32_t)(s / 1000) + : (uint32_t)(standby_get_sleep_duration_tb() / 1000); + return v > 65535 ? 65535 : (uint16_t)v; +#else + return 0; +#endif +} + +// Отправить keepalive спячки (обновить поля тайминга) + при необходимости заармить ретрай. static void ka_send_sleep_keepalive(struct ETCP_LINK* link) { - uint16_t sleep_time = ka_wake_deadline_01s(); - if (sleep_time == 0) sleep_time = link->ka_sleep_period_ms / 100; - link->ka_sleep_time = sleep_time; + link->ka_active_remaining = ka_active_remaining_01s(); + link->ka_sleep_duration = ka_sleep_duration_01s(); etcp_link_send_keepalive(link); if (!link->ka_sleep_acked && link->ka_sleep_announce_timer == NULL) { link->ka_sleep_announce_timer = uasync_set_timeout(link->etcp->instance->ua, @@ -318,17 +316,58 @@ static void ka_for_each_link(struct UTUN_INSTANCE* inst, ka_link_fn fn) { } #ifdef UTUN_HAVE_STANDBY -// Фаза duty-cycle: вошли в SLEEP → переанонсировать спячку (каждый цикл). +// Клиент: вход в ACTIVE-окно — отправить keepalive с active_remaining>0 (флаг стоит). +static void ka_client_active_announce(struct ETCP_LINK* link) { + if (!link->ka_sleeping) return; + ka_send_sleep_keepalive(link); +} + +// Фаза duty-cycle: SLEEP → переанонс спячки; ACTIVE → анонс активности (флаг всегда стоит). static void ka_phase_cb(int sleeping, void* arg) { struct UTUN_INSTANCE* inst = (struct UTUN_INSTANCE*)arg; if (!inst || inst->client_type != CLIENT_TYPE_MOBILE) return; - if (!sleeping) return; - ka_for_each_link(inst, ka_client_reannounce); - DEBUG_INFO(DEBUG_CATEGORY_KEEPALIVE, "keepalive: duty-cycle SLEEP phase, re-announce (node=%016llx)", - (unsigned long long)inst->node_id); + if (sleeping) { + ka_for_each_link(inst, ka_client_reannounce); + DEBUG_INFO(DEBUG_CATEGORY_KEEPALIVE, "keepalive: duty-cycle SLEEP phase, re-announce (node=%016llx)", + (unsigned long long)inst->node_id); + } else { + ka_for_each_link(inst, ka_client_active_announce); + DEBUG_INFO(DEBUG_CATEGORY_KEEPALIVE, "keepalive: duty-cycle ACTIVE phase, announce (node=%016llx)", + (unsigned long long)inst->node_id); + } } #endif +/* ── Сервер: машина фаз троттлинга (по active_remaining/sleep_duration) ── */ + +static void ka_server_arm_phase(struct ETCP_CONN* etcp); + +static void ka_server_set_phase(struct ETCP_CONN* etcp, int sleeping) { + if (!etcp) return; + if (etcp->peer_sleep_phase == (uint8_t)(sleeping ? 1 : 0)) return; + etcp->peer_sleep_phase = sleeping ? 1 : 0; + utun_fire_peer_sleep_cbk(etcp->instance, etcp->peer_node_id, sleeping); +} + +static void ka_server_phase_timer_cb(void* arg) { + struct ETCP_CONN* etcp = (struct ETCP_CONN*)arg; + etcp->peer_phase_timer = NULL; + if (!etcp || etcp->state == 2) return; + ka_server_set_phase(etcp, etcp->peer_sleep_phase ? 0 : 1); + ka_server_arm_phase(etcp); +} + +static void ka_server_arm_phase(struct ETCP_CONN* etcp) { + if (!etcp || !etcp->instance) return; + uint16_t dur_01s = etcp->peer_sleep_phase ? etcp->peer_sleep_duration : etcp->peer_active_remaining; + if (etcp->peer_phase_timer) { + uasync_cancel_timeout(etcp->instance->ua, etcp->peer_phase_timer); + etcp->peer_phase_timer = NULL; + } + etcp->peer_phase_timer = uasync_set_timeout(etcp->instance->ua, (int)((uint32_t)dur_01s * 1000), + etcp, ka_server_phase_timer_cb, "peer_phase"); +} + int etcp_keepalive_on_recv(struct ETCP_SOCKET* e_sock, struct ETCP_DGRAM* pkt, struct ETCP_LINK* link, size_t pkt_len) { (void)pkt_len; @@ -346,21 +385,27 @@ int etcp_keepalive_on_recv(struct ETCP_SOCKET* e_sock, struct ETCP_DGRAM* pkt, uint8_t flags = (pkt->data_len >= 2) ? pkt->data[1] : 0; if (flags & KA_FLAG_SLEEP) { - uint16_t sleep_time = (pkt->data_len >= 6) + uint16_t active_remaining = (pkt->data_len >= 6) ? (pkt->data[4] | ((uint16_t)pkt->data[5] << 8)) : 0; + uint16_t sleep_duration = (pkt->data_len >= 8) + ? (pkt->data[6] | ((uint16_t)pkt->data[7] << 8)) : 0; if (link->is_server) { - /* Сервер: пир заснул — перейти в спячку и ответить ack-эхо. */ + /* Сервер: пир в спячке — зеркалим флаг/поля для эхо и ведём фазу троттлинга. */ link->ka_sleeping = 1; link->ka_sleep_period_ms = peer_period; - link->ka_sleep_time = sleep_time; - link->ka_sleep_deadline_tb = get_time_tb() + (uint64_t)sleep_time * 1000; + link->ka_active_remaining = active_remaining; + link->ka_sleep_duration = sleep_duration; link->ka_period_ms = peer_period; - if (link->etcp && !link->etcp->peer_sleeping) { - link->etcp->peer_sleeping = 1; - utun_fire_peer_sleep_cbk(link->etcp->instance, link->etcp->peer_node_id, 1); + if (link->etcp) { + link->etcp->peer_active_remaining = active_remaining; + link->etcp->peer_sleep_duration = sleep_duration; + ka_server_set_phase(link->etcp, active_remaining == 0); + ka_server_arm_phase(link->etcp); } - DEBUG_INFO(DEBUG_CATEGORY_KEEPALIVE, "[%s] server: peer sleeping (period=%dms deadline=%us), echo ack", - link->etcp->log_name, peer_period, (unsigned)(sleep_time / 10)); + DEBUG_INFO(DEBUG_CATEGORY_KEEPALIVE, "[%s] server: peer sleeping (period=%dms active_rem=%d.%ds sleep_dur=%d.%ds), echo ack", + link->etcp->log_name, peer_period, + (int)(active_remaining / 10), (int)(active_remaining % 10), + (int)(sleep_duration / 10), (int)(sleep_duration % 10)); etcp_link_send_keepalive(link); restart_keepalive_timer_ms(link, peer_period); } else { @@ -379,9 +424,12 @@ int etcp_keepalive_on_recv(struct ETCP_SOCKET* e_sock, struct ETCP_DGRAM* pkt, link->ka_sleeping = 0; link->ka_period_ms = (uint16_t)link->keepalive_interval; link->keepalive_timeout = (uint32_t)link->keepalive_interval * KA_TIMEOUT_MULT; - if (link->etcp && link->etcp->peer_sleeping) { - link->etcp->peer_sleeping = 0; - utun_fire_peer_sleep_cbk(link->etcp->instance, link->etcp->peer_node_id, 0); + if (link->etcp) { + if (link->etcp->peer_phase_timer) { + uasync_cancel_timeout(link->etcp->instance->ua, link->etcp->peer_phase_timer); + link->etcp->peer_phase_timer = NULL; + } + ka_server_set_phase(link->etcp, 0); } DEBUG_INFO(DEBUG_CATEGORY_KEEPALIVE, "[%s] server: peer woke up, back to normal (interval=%dms)", link->etcp->log_name, link->keepalive_interval); diff --git a/src/transport_layer/etcp_keepalive.h b/src/transport_layer/etcp_keepalive.h index afbfa5ff..e6e3349d 100644 --- a/src/transport_layer/etcp_keepalive.h +++ b/src/transport_layer/etcp_keepalive.h @@ -12,30 +12,27 @@ extern "C" { /* ─── Протокол спячки поверх keepalive-пакета (code ETCP_KEEPALIVE = 0x08) ─── * - * Режим спячки передаётся флагом в самом keepalive (отдельные кодограммы - * REQ/RESP не используются). Формат keepalive-пакета: + * Режим спячки (standby) передаётся флагом в самом keepalive (персистентный, + * стоит весь фон). Тайминг duty-cycle (SLEEP 120с / ACTIVE 2с) — двумя полями: * * data[0] = ETCP_KEEPALIVE (0x08) - * data[1] = flags (bit0 = KA_FLAG_SLEEP — спячка) + * data[1] = flags (bit0 = KA_FLAG_SLEEP — standby) * data[2..3] = ka_period_ms (LE 16-bit) — период keepalive в спячке, мс - * data[4..5] = sleep_time (LE 16-bit, x0.1с) — дедлайн пробуждения (при KA_FLAG_SLEEP) + * data[4..5] = active_remaining (LE 16-bit, x0.1с) — до SLEEP-фазы (0 = уже спим) + * data[6..7] = sleep_duration (LE 16-bit, x0.1с) — длительность SLEEP-фазы * - * Засыпание (клиент, перед входом в каждый цикл спячки duty-cycle): - * 1) шлёт keepalive с KA_FLAG_SLEEP + sleep_time. sleep_time = остаток ACTIVE + - * полная длительность SLEEP (дедлайн, после которого клиент ТОЧНО проснётся; - * может и раньше). В спячке при ретраях корректируется вниз до остатка SLEEP. - * 2) ретраит каждые KA_SLEEP_RETRY_MS, пока не получит keepalive с KA_FLAG_SLEEP - * (ack сервера); суммарно KA_SLEEP_ANNOUNCE_TIMEOUT_MS, после чего спит anyway. - * 3) сервер отвечает ответным keepalive с KA_FLAG_SLEEP (ack) и переводит период - * keepalive в спячку (ka_period_ms из пакета). + * Клиент в standby шлёт ВСЕ keepalive с KA_FLAG_SLEEP. На входе в SLEEP-фазу — + * active_remaining=0, sleep_duration=полная; на входе в ACTIVE-окно — + * active_remaining=остаток окна; периодические — active_remaining=0, + * sleep_duration=оставшийся сон. Сервер по этим полям ведёт фазу троттлинга + * (SLEEP-фаза → тормозим протоколы, ACTIVE-окно → обмен) и эхо-подтверждает + * флаг как есть. * - * В спячке (включая ACTIVE-фазу duty-cycle) клиент продолжает слать keepalive с - * KA_FLAG_SLEEP. Сервер отвечает echo на входящие keepalive, либо, если дедлайн - * sleep_time вышел — шлёт серию keepalive с обычным таймаутом, пока не получит - * keepalive со sleep_time (клиент переанонсировал) или обычный (клиент проснулся). + * Засыпание (клиент): анонс + ретраи KA_SLEEP_RETRY_MS до ack (эхо с флагом), + * окно KA_SLEEP_ANNOUNCE_TIMEOUT_MS, после чего спит anyway. * - * Пробуждение: только выход в форграунд — клиент шлёт обычный keepalive (без - * KA_FLAG_SLEEP), сервер возвращается в обычный адаптивный режим с базовым периодом. + * Пробуждение (форграунд): клиент шлёт обычный keepalive (без флага) — сервер + * снимает standby и фазу троттлинга, возвращается в обычный режим. */ // Флаги keepalive-пакета (data[1])