diff --git a/doc/local_transport_audit_findings.txt b/doc/local_transport_audit_findings.txt new file mode 100644 index 000000000..ab7b8ce61 --- /dev/null +++ b/doc/local_transport_audit_findings.txt @@ -0,0 +1,69 @@ +Аудит документации Local_transport — 26.10.2026 + +Объём и статус + +Полностью прочитаны src/local_transport/local_transport.c и platform.c, +сверены все объявления и комментарии трёх заголовков local_transport.h, +platform.h и protocol.h. Все три заголовка готовы к отметке [V] в чек-листе. +Для проверки интеграции прочитан chat_local.c; прочитаны три профильных теста +и local_transport_ipv6.sh. Полный аудит src/chat этой записью не заявляется. +LAN-раздел doc/node_snapshot.md уточнён; общая отметка документа остаётся [~]. + +Исправленные описания + +1. Доставка и дедупликация. Убрано безусловное обещание отсутствия дублей: + кеш хранит последние 128 успешно принятых (peer, epoch, request) до 30с, + без продления повтором. Отказы received не кешируются. Request уникален + среди pending, а повторное использование ID также ограничено кешем получателя. + FAILED и отсутствие ACK не доказывают, что приложение не получило данные. + Описаны 8 pending, немедленная отправка и до двух повторов по секундному tick. + +2. Активность и callbacks. Уточнены синхронные уведомления из API, порядок + activity_changed перед открытием/закрытием сокетов, завершение pending + через FAILED и сохранение эпохи/дедупликации при паузе того же handle. + Отказы открытия сокетов не означают отказ set_active: повтор при сверке; + невозможность создать tick-таймер выключает транспорт. peers() очищает TTL + и может вызвать routes_changed; route() callbacks не вызывает. + +3. Broadcast и TTL. Изменение ника рассылается только при active+broadcasts; + тот же ник не вызывает отправку. Отключение broadcasts сохраняет unicast, + приём, сверку интерфейсов и TTL. Только обычный ANNOUNCE продлевает endpoint. + Жизнь кандидата дополнительно ограничена его собственным TTL, интерфейсом + и discovery-endpoint. Offline-gate применяется к подписанному входящему + обмену, но не повторяется при route() и не нужен для ответа на CHALLENGE. + +4. Wire. Описаны все смещения 60-байтного заголовка, NUL в 16-байтном magic, + длина тела, BE, типы сообщений, неподписанные MESSAGE/ACK и ограничения + discovery-порта. Уточнены подпись/nonce, scope, допустимые protocol, + уникальные socket_id, ненулевые port/generation и пустой PROOF. + +5. Платформа. Зафиксированы различия отбора POSIX/Windows, дедупликация + адресов, усечение снимка, ответственность за ifindex/scope, допустимый + источник и результаты local_receive (включая пустой UDP/would-block/-2). + Добавлены предусловия встроенных BE/UTF-8 helpers и категория discovery. + +Проверки + +make -C src -j4 libutun.a и сборка трёх профильных тестов — PASS. +Логи /tmp/local-transport-audit-build.log и +/tmp/local-transport-audit-tests-build.log. Существующие предупреждения +db_sync/etcp_connections/dm_media не относятся к изменённым комментариям. + +Пять сценариев PASS, последовательно вне sandbox из-за запрета сокетов: +- test_local_transport: UDP discovery, ACK retry/dedup, TTL, настройки, + остановка/повторная активация; /tmp/local-transport-audit-discovery.log. +- test_local_transport_packets: миллион некорректных пакетов, ограничения + flood/памяти/events и восстановление; /tmp/local-transport-audit-packets.log. +- test_local_routes: подписи, nonce/replay, BGP gate, поколения сокетов, + TTL, NCD UDP/STCP и сохранность snapshot; /tmp/local-transport-audit-routes.log. +- sh tests/local_transport_ipv6.sh: изолированная IPv6-only LAN; + /tmp/local-transport-audit-ipv6-discovery.log. +- sh tests/local_transport_ipv6.sh test_local_routes: IPv6 scope и LAN/NCD; + /tmp/local-transport-audit-ipv6-routes.log. + +В заголовках изменены только комментарии; логика, ABI и wire не менялись. +Новых подтверждённых дефектов реализации в этом объёме не обнаружено. +Прежняя задача о нестабильном ACK в test_local_transport остаётся открытой: +успешный отдельный прогон не подтверждает устранение флака под общей нагрузкой. +Полный check.sh, санитайзеры, native Windows/FreeBSD и GUI/Android runtime +не запускались. [V] означает завершённую сверку документации по исходникам. diff --git a/doc/node_snapshot.md b/doc/node_snapshot.md index c8c55f3ba..b2683cb8e 100644 --- a/doc/node_snapshot.md +++ b/doc/node_snapshot.md @@ -108,6 +108,9 @@ LAN discovery предоставляет отдельные адреса под Открытое объявление рабочих сокетов и ответ на проверку имеют Ed25519-подпись; публичные ключи в этих пакетах отсутствуют. Получатель использует известный ключ из registry/SQLite, а неизвестное устройство остаётся только в списке discovery. +Обычные объявления имени, сообщения и ACK не подписаны и не подтверждают личность. +Общий UDP-порт 45731 принимает только объявления; unicast-обмен использует отдельные +ephemeral-порты. Формат и API описаны в `src/local_transport/protocol.h` и `local_transport.h`. Подписываются весь заголовок local_transport (magic/version/type, длина, IDs/эпохи, request=0) и тело: nonce(16), family(4/6), IP(16), количество сокетов, @@ -123,6 +126,15 @@ request=0) и тело: nonce(16), family(4/6), IP(16), количество с эпохи или случайные поколения сокетов сами по себе свежесть не доказывают. После проверки адрес действует 30 секунд по монотонным часам и только на интерфейсе приёма (включая IPv6 scope). Повтор объявления/ответа не продлевает срок без нового nonce. +Дополнительно должен оставаться живым discovery-endpoint: только обычный ANNOUNCE +продлевает его собственный TTL 30 секунд; MESSAGE/ACK и подписанный обмен этого не делают. +Смена discovery-эпохи очищает endpoints и кандидаты. Проверка offline выполняется +при обработке подписанного объявления/ответа; чтение кандидатов её не повторяет +и само по себе не удаляет ранее проверенные адреса при появлении рабочего пути. +Сверка интерфейсов и периодические объявления выполняются каждые 10 секунд, +очистка TTL — по секундному tick или при запросе списка устройств/отправке сообщения. +Отключение broadcasts сохраняет unicast-объявления и ответы, приём и сроки жизни; +полная остановка discovery закрывает сокеты, завершает pending-доставки и очищает кандидаты. NCD использует эти кандидаты при проверке совместимости, открытии/обновлении и появлении локального сокета. Если сохранены только ключи, идентичность загружается diff --git a/doc/stream.txt b/doc/stream.txt index 7358eea89..7165ecec4 100644 --- a/doc/stream.txt +++ b/doc/stream.txt @@ -1,5 +1,14 @@ Модуль стриминга. Техническое задание, этап 1. +Статус аудита 26.10.2026: сверка завершена только для stream_proto.h, +stream_block.h, stream_source.h и stream_media.h; остальные разделы проверены частично. +Расхождение допуска deleted устранено: stream_member_load читает принятый флаг +в том же SELECT, что и профиль, и возвращает STREAM_ERR_NOT_MEMBER до crypto. +Штатный test_stream_member проверяет подписи/версии, source/supplier/self, +закрытие handles/выдач, изоляцию каналов и повторное разрешение участия. +Полный аудит оставшихся разделов ещё не завершён. Подтверждения, архитектура +исправления и результаты проверок — doc/stream_audit_findings.txt. + 1. Цель и принятые решения Модуль размещается в src/stream. Узлы получают поток данных от источника через других подписчиков группы, diff --git a/doc/stream_audit_findings.txt b/doc/stream_audit_findings.txt new file mode 100644 index 000000000..92709080f --- /dev/null +++ b/doc/stream_audit_findings.txt @@ -0,0 +1,197 @@ +Аудит документации src/stream — 26.10.2026, частично завершён + +Текущий статус: подтверждённый дефект deleted исправлен в репозитории и покрыт +штатным test_stream_member; сборка, профиль7/7 и check.sh195/195 PASS (раздел 5). +Остальные частичные/непроверенные контракты каталога не закрыты. Разделы 1–4 +описывают первоначальную диагностику и проверку архитектуры до внедрения. + +1. Подтверждённый дефект: deleted не учитывается stream_member_load + +src/stream/stream_member.c:166–167 выбирает строку только по node_id. Условие +source=0 проверяется ниже, но столбец deleted не выбирается и не проверяется. +Проверка дерева приглашений и подписи профиля не заменяет проверку блока владельца: +после принятого deleted=yes эти подписи участника остаются корректными. +Поэтому loader возвращает STREAM_OK и публикует прежние stream-опции/ключ. + +Это расходится с допуском CHAT (source=0, deleted=0), закреплённым в topo_group.h, +и с результатом topo_node_sqlite_member_allowed. stream_member_supernode уже +отбирает deleted=0. Существующий тест deleted проверяет только supernode lookup. +Обработчик member_changed в stream.c:539–546 использует stream_member_load: +данный результат не запускает ветку инвалидирования STREAM_CLOSE_MEMBER. +Для исходной реализации полный сетевой сценарий продолжения выдачи после удаления не проверялся; +обход сетевой авторизации этим воспроизведением не заявляется. + +Изолированная проверка + +Настоящее ядро с SQLite :memory:, отдельные ключи канала и тестового участника. +Join/update/tree подписи создаются штатными функциями и принимаются member_sync_put. +В профиле корректные stream_source/subscriptions. Участник отличается от локального +узла; никаких удалённых узлов или пользовательской БД проверка не затрагивает. +Затем через member_sync_put применяется подписанный ключом владельца блок +{"ver":"1","deleted":"yes"}; прямой UPDATE deleted для воспроизведения не используется. + +Фактический лог: +before load=0 allowed=1; after load=0 allowed=0 published=1; expected load=-9 + +Тест завершился exit=1 на несовпадении с ожидаемым STREAM_ERR_NOT_MEMBER. +Стенд: /tmp/stream-audit-member-deleted.c. +Сборка через существующие Makefile/LIBUTUN/COMMON_LIBS и дополнительную цель: +make -C tests -f Makefile -f /tmp/stream-audit-member.mk /tmp/stream-audit-member-deleted +Логи: /tmp/stream-audit-member-build.log, /tmp/stream-audit-member-deleted.log. +Runtime выполнен вне sandbox из-за ограничений сокетов uasync. + +Предлагаемый вариант исправления + +Добавить deleted в список полей этого же SELECT и до проверки профиля вернуть +STREAM_ERR_NOT_MEMBER для удалённого участника, с отдельным логом причины и ID. +Вторая SQL-проверка и новый API не требуются. Вариант WHERE deleted=0 тоже +отсечёт запись, но существующий лог "member absent" не отличит удаление от отсутствия. +Сохранить различие отсутствующего/удалённого участника и неполного профиля (WAIT), +атомарность state/public_key при отказе. +Регрессия должна проверить подписанное удаление источника/локального участника/ +поставщика, закрытие соответствующих handles и отсутствие выдачи новых DATA. +После исправления продолжить сверку оставшихся заголовков и сетевых контрактов. +Реализация не исправлялась: аудит остановлен по правилу AGENTS.md:10. + +2. Выполненная сверка + +Все 18 заголовков src/stream прочитаны предварительно. Полностью прочитаны +10 реализаций: stream_block/source/buffer/media/media_buffer/wire/member/metrics/ +load/playback_clock. Другие реализации stream, включая playback_audio.cpp, +network/optimizer/publisher/viewer и stream.c целиком, ещё не проверены. +В stream.c просмотрена только затронутая ветка member_changed; полный аудит +жизненного цикла сервиса этим не заявляется. + +Завершены и готовы к [V]: stream_proto.h, stream_block.h, stream_source.h, +stream_media.h. Исправлены описание полного размера части и области подписи, +предусловия BE helpers, Ed25519 seed/ключ, владение и ошибки codec/source, +нулевой write/accepted, отсутствие END в source_finish, ограничения uAV2, +пересчёт first_frame_offset и атомарность views/выходов при ошибке. +В этих четырёх заголовках изменены комментарии/оформление, C-токены сохранены. + +Частично проверены [~]: stream_buffer.h, stream_load.h, stream_media_buffer.h, +stream_member.h, stream_metrics.h, stream_playback_clock.h, stream_wire.h. +Их реализации прочитаны, но оставшиеся уточнения контрактов не внесены после +остановки. В stream_member.h добавлено предупреждение о подтверждённом дефекте. + +Остальные семь заголовков остаются [ ]: stream.h, stream_network.h, +stream_optimizer.h, stream_playback_audio.h, stream_priv.h, stream_publisher.h, +stream_viewer.h. Прочтение одного заголовка без реализации не закрывает аудит. +doc/stream.txt остаётся [~]: просмотрены начальные разделы о FEC, подписи, +кольце и выдачах; последующие сетевые/media/desktop/Android разделы не сверены. +Добавлен статус аудита. +Полные .h/doc контракты всего модуля ещё не закрыты. + +3. Проверки и ограничения + +Сборка диагностического стенда PASS; отрицательная проверка deleted воспроизвела дефект. +Профильные наборы stream, полный check.sh, санитайзеры, Windows/FreeBSD и +GUI/Android runtime не запускались. Неизменность C-токенов заголовков и +git diff --check — PASS; успешные сетевые/медиа тесты не заявляются. +Предыдущие изменения Local_transport и чужие записи чек-листа сохранены. + +4. Архитектурная проверка предлагаемого исправления — 26.10.2026 + +Вывод: проверка deleted в stream_member_load архитектурно корректна. На этом +этапе проверка выполнялась на временной копии модуля без изменений .c проекта; +внедрение описано в разделе 5. Статусы полного аудита каталога этим не закрываются. + +Граница ответственности + +Блок A участника описывает личность/stream-опции. Блок B владельца определяет +в том числе исключение из канала. Корректный A не отменяет запрет из B. +member_apply_record проверяет подпись B и его версию; owner_put обновляет +adm_tags/adm_tags_sig/storage/deleted одним UPDATE. После успешного commit +member_committed посылает props-событие; Merkle-page уведомляет после commit +всей страницы. Поэтому достаточно прочитать принятую проекцию deleted в том же +SELECT, не вводя вторую криптопроверку блока B или отдельный SQL-запрос допуска. + +STREAM_ERR_NOT_MEMBER уже обработан в stream_open_check, каталоге источников, +member_changed/service_reconcile, authorized и network_membership_changed. +Событие источника/self немедленно ставит invalidated, затем reconcile закрывает +сессию. session_find/handle_active/session_deliver учитывают invalidated до +отложенного освобождения. Закрытие сохраняет владение handles у caller до close. +Для исключённого поставщика закрываются его flow, а локальная сессия источника +может продолжать получать от другого поставщика. Сфера запрета — конкретный +канал; общий ETCP/NCD и владельцы других каналов не должны закрываться. + +Результаты реального стенда + +В /tmp/stream-arch-member.c добавлены только поле deleted в существующий SELECT +и ветка NOT_MEMBER с причиной в логе до разбора профиля. Копия связана перед +штатной libutun.a, остальные модули взяты из существующей сборки. +Стенд использует fixture test_stream_service: четыре живых ядра, два канала, +подписанные owner/member записи, настоящий Merkle, UDP/TCP и NCD. + +Все четыре группы проверок PASS: +- Неполный профиль/placeholder остаётся WAIT; отсутствие и deleted дают + NOT_MEMBER; state/public_key не меняются на отказе. Неверная подпись владельца + отвергается, старая версия не снимает запрет, более свежая разрешает участие. +- Исключение источника сразу закрывает receive с MEMBER и инвалидирует reader; + новых DATA callback нет. Запрет через Merkle останавливает сам publisher. + Handle другого канала и транспорт с дополнительным NCD-владельцем сохраняются. +- Исключение поставщика закрывает только его локальную выдачу; reader источника, + другой канал и upstream другого ядра в этот момент остаются активными. +- Исключение self закрывает handles данного канала и запрещает новые publish/ + subscribe. Другой канал остаётся активен. После разрешения новый open работает, + прежние отсоединённые handles не оживают. Новая публикация получает новую эпоху. + +Итоговый exit=0, teardown flows=0 и ноль оставшихся tracked allocations. +Сборка: /tmp/stream-arch.mk, /tmp/stream-arch-build-final.log. +Кейсы: /tmp/stream-arch-cases.h; harness: /tmp/stream-arch-service.c. +Результат: /tmp/stream-arch-results-final.log. +Запуск: /tmp/stream-arch-service --architecture-only, вне sandbox. + +Первый прогон /tmp/stream-arch-results.log неверно пытался повторно использовать +publisher после распространённого через Merkle запрета: старый publisher уже +правильно закрыт. Ожидание стенда исправлено на новый запуск после разрешения, +сама временная проверка deleted при повторе не менялась. + +Гарантии и ограничения + +Уведомления/освобождение остаются отложенными; нужен обычный uasync loop. +Проверено отсутствие новых DATA callback у исключённого reader. Уже принятые +ETCP пакеты не отзываются, удалённые узлы узнают запрет при его доставке через +Merkle. Архитектурная проверка не обещает мгновенного глобального отзыва данных. +Полный check.sh, санитайзеры и платформенные/GUI runtime не запускались. +На этапе архитектурной проверки C-код репозитория не менялся; последующее +внедрение и постоянная регрессия описаны ниже. + +5. Внедрение согласованного исправления — 26.10.2026 + +В stream_member_load существующий SELECT дополнен deleted. Для удалённой записи +до crypto возвращается STREAM_ERR_NOT_MEMBER, с отдельным DEBUG_WARN о запрете +владельца, group_id/member_id. Другого SQL-запроса, нового API или формата нет. +Остальные результаты loader, включая WAIT, и атомарность выходов сохранены. +Предупреждение о неисправленном дефекте в stream_member.h заменено действующим +контрактом. Задача deleted в doc/tasks.md закрыта, текущий статус stream.txt уточнён. + +Постоянная регрессия — test_stream_member в check_PROGRAMS. Тест использует +test_stream_service.c с теми же четырьмя ядрами/подписанными записями/сетью, +а STREAM_MEMBER_TEST_ONLY выбирает изолированный сценарий в отдельном процессе. +Fixture не дублируется, её изменённые member-версии/активность не влияют на +обычный test_stream_service. Сценарий доступен также через --member-only. + +Проверены подписи/версии владельца, WAIT/NOT_MEMBER и сохранность выходов, +удаление источника/поставщика/self, причины закрытия, отсутствие новых DATA +callback после запрета, распространение через Merkle до остановки publisher, +сохранность чужого NCD-владения и работоспособность другого канала после +исключения self. Разрешение не оживляет старые handles; новая публикация +проверяется на новую эпоху. Ожидание удалённой остановки зависит от состояния, +а не фиксированного sleep; teardown подтверждает отсутствие tracked allocations. + +./build.sh --no-gui -j4 PASS: /tmp/stream-member-fix-build.log. +Профиль7/7 PASS: stream_member, stream_service, stream_core, stream_media, +stream_playback, stream_tx_stats, android_stream. +Сводка /tmp/stream-member-fix-profile-results.log, +подробности /tmp/stream-member-fix-test_*.log. +Последующий перенос длинной строки лога не меняет содержимое сообщения; +обе test-stream цели пересобраны, test_stream_member повторно PASS: +/tmp/stream-member-fix-test-rebuild.log, /tmp/stream-member-fix-test_stream_member-final.log. + +Полный Linux check.sh:195/195 PASS,0 failed/0 skipped; proxy9/9,burst PASS, +load8/8,134217728 байт,167 секунд. Лог /tmp/stream-member-fix-full-check.log. +git diff --check PASS. Sanitizers и нативные Windows/FreeBSD/GUI/Android runtime +в этом этапе не запускались; test_android_stream — тест общего C bridge на Linux. +Отметки полного аудита заголовков не расширены: устранение одного дефекта +не завершает оставшуюся сверку src/stream и всего doc/stream.txt. diff --git a/doc/tasks.md b/doc/tasks.md index a17fa1355..96b3f8c98 100644 --- a/doc/tasks.md +++ b/doc/tasks.md @@ -4,6 +4,21 @@ ## Текущие задачи +[+] **stream: учитывать подписанный deleted при загрузке мембера** — исправлено 26.10.2026. + stream_member_load читает deleted вместе с профилем и возвращает STREAM_ERR_NOT_MEMBER до crypto, + с отдельным логом причины/группы/узла. WAIT для неполного профиля и выходы при отказе сохраняются. + test_stream_member включён в общий check и использует fixture test_stream_service в отдельном процессе. + Проверены подписанные запрет/разрешение, неверная подпись/старая версия, source/supplier/self, + закрытие handles/выдач, отсутствие новых DATA callback, Merkle-остановка publisher, + другой канал с рабочей записью и чужое NCD-владение; после разрешения нужны новые handles/эпоха. + Воспроизведение: /tmp/stream-audit-member-deleted.c и /tmp/stream-audit-member.mk; + до исправления /tmp/stream-audit-member-deleted.log, exit=1; архитектурная копия PASS, + /tmp/stream-arch-results-final.log. Штатная сборка PASS, профиль7/7 PASS, tracked allocations=0. + check.sh:195/195 PASS,0 failed/0 skipped; proxy9/9,burst PASS,load8/8 (134217728 байт),167с. + Логи: /tmp/stream-member-fix-build.log, /tmp/stream-member-fix-profile-results.log, + /tmp/stream-member-fix-full-check.log. Полный аудит остальных контрактов stream этим не закрывается. + Подробности: [stream_audit_findings.txt](stream_audit_findings.txt). + [+] **transport_layer: завершить аудит заголовков и документов** — завершено 26.10.2026. С учётом прежних этапов сверены все32 собственных заголовка и17 документов каталога плюс doc/stun_nat.md. Закрыты auto_socket/socket_monitor/SOCKS/call_ring/REALITY/STUN; исправлены владение endpoints/posts, diff --git a/src/local_transport/local_transport.h b/src/local_transport/local_transport.h index 7f264758a..fb53efe99 100644 --- a/src/local_transport/local_transport.h +++ b/src/local_transport/local_transport.h @@ -1,9 +1,14 @@ -/* Открытый UDP-транспорт локальной сети. Не создаёт ETCP-сокетов и не подключает пиры. +/* UDP discovery и доставка небольших сообщений в LAN: create → set_active → peers/send → destroy. + * ANNOUNCE/MESSAGE/ACK открыты и не аутентифицированы; node_id/ник сами по себе не доказывают личность. + * Не создаёт ETCP-сокетов и не подключает пиры; необязательный подписанный обмен даёт LAN-кандидаты через route(). * Все вызовы и callbacks — в потоке ua. destroy/set_active — вне callbacks транспорта. - * Данные callback заимствованы до возврата; received возвращает 0 после принятия сообщения. - * delivery подтверждает приём сообщения приложением, а не выполнение его содержимого. - * Входящий поток ограничен 256 UDP/сек и 8 новыми сообщениями/сек на транспорт; при flood возможны потери. - * peers_changed объединяет изменения таблицы до одного уведомления за секунду. */ + * Callbacks могут выполняться синхронно из API; их аргументы-указатели заимствованы до возврата. + * Discovery-порт 45731 принимает объявления; ответы, сообщения и ACK идут через отдельные ephemeral UDP-порты. + * Объявления/сверка интерфейсов — каждые 10с, tick — 1с; только ANNOUNCE продлевает жизнь endpoint на 30с. + * До 128 устройств, 8 endpoints на устройство и 8 ожидающих доставок на транспорт; порядок peers/routes нестабилен. + * За tick: до 256 UDP, 8 вызовов received и общий бюджет 16 проверок подписей/ответов CHALLENGE. + * При исчерпании UDP-бюджета чтение приостанавливается до tick; возможны потери, таймеры не гарантируют точное время. + * Диагностика — категория discovery; причины отброса суммируются до следующего tick. */ #ifndef LOCAL_TRANSPORT_H #define LOCAL_TRANSPORT_H @@ -36,30 +41,40 @@ struct local_peer { uint64_t node_id; // идентификатор из объявления, не подтверждает подлинность char name[LOCAL_TRANSPORT_NAME_MAX]; // UTF-8 ник, завершается NUL }; -/* Рабочий endpoint, без ключей. generation отличает повторное использование socket_id. */ +/* Рабочий endpoint, без ключей. Ненулевой generation отличает повторное использование socket_id. + * В одном наборе для IP socket_id уникальны; protocol — UDP, TCP либо TCP|REALITY. */ struct local_route_socket { - uint64_t generation; + uint64_t generation; // ненулевое поколение рабочего сокета, не эпоха discovery uint16_t port; // host order, ненулевой - uint8_t socket_id, protocol; // LOCAL_ROUTE_*, REALITY только вместе с TCP + uint8_t socket_id, protocol; // ID 0..255 и LOCAL_ROUTE_*, REALITY только вместе с TCP }; /* Проверенный nonce-ответ; адрес принадлежит только интерфейсу, принявшему объявление. */ struct local_route { struct sockaddr_storage address; // IP отправителя и порт рабочего транспорта struct sockaddr_storage local_address; // IP нашего интерфейса, порт 0 uint32_t interface_index; // локальный ifindex, также IPv6 scope - struct local_route_socket socket; + struct local_route_socket socket; // подписанные ID/протокол/порт/поколение рабочего сокета }; struct local_transport_callbacks { - void (*peers_changed)(void* arg); // таблица изменилась; получить копию через peers() - int (*received)(void* arg, const struct local_peer* peer, const uint8_t* data, size_t len); // 0 = принято, FORBIDDEN = запрет, -1 = ошибка - void (*delivery)(void* arg, uint64_t request_id, uint64_t peer_id, int status); // один результат: enum local_delivery_status - void (*activity_changed)(void* arg, int active); // сокеты включаются/выключаются, в том числе при ошибке таймера + /* Эти четыре callbacks необязательны. Изменения списка объединяются до tick; выключение уведомляет сразу. */ + void (*peers_changed)(void* arg); // добавление/удаление устройства, смена ника/эпохи; копия через peers() + /* data: 1..DATA_MAX произвольных байтов, без гарантии NUL. 0 = принято, FORBIDDEN = запрет, прочее = ошибка. + * Без received отправляется FAILED. Только принятые сообщения попадают в кеш дедупликации. */ + int (*received)(void* arg, const struct local_peer* peer, const uint8_t* data, size_t len); + /* Один результат на принятый send; RECEIVED означает приём приложением, FAILED не доказывает отсутствие приёма. */ + void (*delivery)(void* arg, uint64_t request_id, uint64_t peer_id, int status); // enum local_delivery_status + void (*activity_changed)(void* arg, int active); // до открытия/закрытия сокетов; также при отказе tick-таймера /* Необязательный LAN transport: задать все пять callbacks либо ни одного. * sockets возвращает 0..capacity или -1; sign — 0/-1; verify — 0 (верна), 1 (ключ неизвестен), -1 (неверна/ошибка). + * route_sockets заполняет out endpoints для локального address/index; память заимствована до возврата. + * port/generation ненулевые, socket_id уникальны, protocol — UDP/TCP/TCP|REALITY; отправитель их не валидирует. + * Пустой набор не объявляется, но передаётся в PROOF и заменяет прежние кандидаты пустым набором. * Подпись Ed25519 ровно 64 байта. * Подписываются полный wire-заголовок и тело без подписи; verify использует только известный ключ peer. * offline возвращает 1 при отсутствии прямого UP и живого BGP-пути во всех группах. - * routes_changed вызывается после применения/удаления адресов; не останавливать транспорт из callback. */ + * Этот gate проверяется при ANNOUNCE/PROOF, а не при чтении route(); ответ на CHALLENGE от него не зависит. + * routes_changed сообщает применение PROOF, истечение/потерю endpoint, смену эпохи или выключение. + * Перечитать route(); при выключении он уже возвращает 0. Не останавливать транспорт из callback. */ int (*route_sockets)(void* arg, const struct sockaddr_storage* address, uint32_t index, struct local_route_socket* out, size_t capacity); int (*route_sign)(void* arg, const uint8_t* data, size_t len, uint8_t signature[64]); @@ -69,28 +84,42 @@ struct local_transport_callbacks { }; /* Создать выключенный транспорт: ua заимствован, name/callbacks копируются, arg передаётся callbacks. - * node_id != 0, name — 0..127 байтов UTF-8; пустой ник заменяется hex node_id. + * node_id != 0, callbacks != NULL, name != NULL — NUL-строка, 0..127 байтов UTF-8 без управляющих ASCII. + * Пустой ник заменяется 16 hex-цифрами node_id. Случайная ненулевая эпоха создаётся один раз на handle. * Возвращает владельческий handle либо NULL с ошибкой в логе. */ struct local_transport* local_transport_create(struct UASYNC* ua, uint64_t node_id, const char* name, const struct local_transport_callbacks* callbacks, void* arg); -/* Закрыть сокеты, отменить таймеры/доставки и освободить handle. NULL допустим. */ +/* Закрыть сокеты, отменить таймеры, завершить pending через delivery(FAILED) и освободить handle. + * Может синхронно вызывать callbacks выключения; NULL допустим. ua/arg не освобождаются. */ void local_transport_destroy(struct local_transport* transport); -/* ACTIVE включает сокеты и таймер; выключение отменяет доставки, очищает таблицу и не будит standby. - * Повтор допустим. Возвращает 0/-1; отсутствие локальной сети не является ошибкой активации. */ +/* Ненулевой active включает сокеты и tick; выключение завершает доставки FAILED, очищает peers/routes. + * Повтор допустим; эпоха и кеш принятых сообщений сохраняются до destroy, настройки имени/broadcasts тоже. + * Возвращает 0/-1. Отказы интерфейсов/сокетов логируются и повторяются при сверке, но не отменяют активацию; + * отказ tick-таймера выключает транспорт и даёт -1. NULL transport — -1. */ int local_transport_set_active(struct local_transport* transport, int active); /* Разрешить периодические broadcast/multicast-объявления (по умолчанию включены). - * Unicast, приём и таблица устройств сохраняются; включение сразу отправляет объявление. Возвращает 0/-1. */ + * Unicast-объявления, приём, сверка интерфейсов и TTL сохраняются; это не запрет видимости устройства. + * При смене на enabled != 0 активный транспорт сразу объявляется. Возвращает 0; NULL transport — -1. */ int local_transport_set_broadcasts(struct local_transport* transport, int enabled); -/* Обновить ник (те же ограничения, что у create), сразу отправить объявление. Возвращает 0/-1. */ +/* Обновить ник (ограничения create); при изменении объявить, если active и broadcasts включены. + * При том же имени ничего не отправляет. Возвращает 0/-1; ошибка оставляет прежний ник. */ int local_transport_set_name(struct local_transport* transport, const char* name); -/* Скопировать не более capacity живых устройств в out; возвращает количество, 0 для NULL transport/out. */ +/* Скопировать не более capacity живых устройств в out; возвращает количество скопированных, без общего размера. + * Перед копированием удаляет просроченные endpoints/routes: возможен синхронный routes_changed. + * peers_changed откладывается до tick. NULL transport/out — 0, без очистки; out обязан вмещать capacity элементов. */ size_t local_transport_peers(struct local_transport* transport, struct local_peer* out, size_t capacity); /* Скопировать 1..DATA_MAX байтов data для peer_id из текущей таблицы. request_id != 0, уникален среди pending. - * 0 = запрос принят, -1 = callback не будет. До 3 попыток на всех endpoints; дубли получатель не выдаёт приложению. */ + * До 8 pending всего. 0 = запрос принят, -1 = callback для него не будет; нужна активность и известный живой peer. + * Первая попытка сразу, до 2 повторов по tick на всех endpoints; первый ACK, потеря peer/эпохи, timeout или stop завершают запрос. + * Ошибка отправки UDP не меняет 0 на -1. FAILED/потерянный ACK не гарантируют, что приложение не приняло данные. + * Кеш получателя: последние 128 принятых (peer_id, epoch, request_id), каждый до 30с, без продления повтором. + * Только в этом окне дубли дают RECEIVED без received; отказ приложения не кешируется. Учитывать это при выборе request_id. + * Может вызвать routes_changed при очистке TTL. */ int local_transport_send(struct local_transport* transport, uint64_t peer_id, uint64_t request_id, const void* data, size_t len); /* Скопировать проверенный живой LAN-кандидат с порядковым номером index (с 0); 1/0. - * Без callbacks/продления TTL; NULL/неактивный транспорт/нет адреса дают 0. */ + * Кандидат требует nonce-PROOF за 3с и действует до 30с, пока живы endpoint и локальный интерфейс. + * Без callbacks/продления TTL и без повторного offline-gate; NULL/неактивный транспорт/нет адреса дают 0, out не меняется. */ int local_transport_route(struct local_transport* transport, uint64_t peer_id, size_t index, struct local_route* out); #ifdef __cplusplus diff --git a/src/local_transport/platform.h b/src/local_transport/platform.h index 28fc73e4b..b4ff3e0ce 100644 --- a/src/local_transport/platform.h +++ b/src/local_transport/platform.h @@ -1,11 +1,15 @@ -/* Внутренний API ОС: снимок локальных адресов и метаданные входящих UDP-пакетов. */ +/* Внутренний API ОС (Linux/FreeBSD/Windows): снимок LAN-адресов и метаданные входящего UDP. + * local_interfaces даёт привязки для сокетов отправки; local_receive_options включается до local_receive. + * Полученный ifindex используется для выбора интерфейса; local_on_interface проверяет только IP/порт, + * поэтому сопоставление ifindex и выставление IPv6 scope выполняет вызывающий код. + * Указатели обязательны, массивы/буферы принадлежат вызывающему коду; диагностика — discovery. */ #ifndef LOCAL_TRANSPORT_PLATFORM_H #define LOCAL_TRANSPORT_PLATFORM_H #include "../../lib/platform_compat.h" #include "../../lib/socket_compat.h" -#define LOCAL_INTERFACE_MAX 64 +#define LOCAL_INTERFACE_MAX 64 // вместимость снимка, используемая транспортом #define LOCAL_MULTICAST6 "ff12::7574:756e" struct local_interface { @@ -15,13 +19,26 @@ struct local_interface { uint32_t mask4; // IPv4 netmask в network byte order; 0 для IPv6 }; -/* Снимок UP-интерфейсов: IPv4 broadcast и IPv6 link-local, без loopback/P2P. count (<= capacity) либо -1. */ +/* Заполнить out[capacity] снимком UP LAN-адресов: IPv4 с маской != /0,/32 и IPv6 link-local. + * POSIX: без loopback/P2P, IPv4 требует IFF_BROADCAST, IPv6 — IFF_MULTICAST. + * Windows: без software-loopback/PPP/tunnel. IPv4-адреса одного ifindex различаются по IP; + * IPv6 — не более одного link-local на ifindex. Порядок определяется ОС. + * Возврат: число записанных (<= capacity), -1 при ошибке. Переполнение capacity логируется, лишнее пропускается. + * На ошибке out не является новым снимком; успешный результат 0 допустим. */ int local_interfaces(struct local_interface* out, size_t capacity); -/* Включить получение interface index через ancillary data для family. Возвращает 0/-1. */ +/* Включить ancillary ifindex для UDP fd семейства AF_INET/AF_INET6; иные family не поддерживаются. + * Возврат 0/-1 с диагностикой ошибки setsockopt; fd остаётся у вызывающего кода. */ int local_receive_options(socket_t fd, int family); -/* -2 = пакет усечён, -1 = ошибка ОС. index — входящий интерфейс (в том числе для IPv4 broadcast). */ +/* Прочитать одну датаграмму в data[capacity]; >=0 — размер, включая 0 для пустого UDP. + * -2 = усечены данные или ancillary metadata (пакет потреблён), -1 = ошибка ОС, включая would-block/EINTR. + * source/index обнуляются перед чтением; при успехе source содержит IP/порт, index — ingress (0 без metadata). + * При отрицательном результате выходы нельзя считать пакетом; ошибка ОС доступна через socket_get_error(). + * Сам не логирует ошибки чтения; caller различает ожидаемый would-block и реальные ошибки. + * IPv6 scope не нормализуется; проверку допустимости источника выполняет caller. */ ssize_t local_receive(socket_t fd, void* data, size_t capacity, struct sockaddr_storage* source, uint32_t* index); -/* Проверить адрес/порт источника: IPv4 той же подсети либо IPv6 link-local; 1 = подходит. */ +/* Проверить IP/порт источника для iface из local_interfaces: одинаковое семейство, ненулевой UDP-порт. + * IPv4: та же подсеть, без нулевого IP, limited/subnet broadcast и адреса сети; IPv6: только link-local. + * 1 = подходит, иначе 0. ifindex/scope и равенство порта discovery-порту здесь не проверяются. */ int local_on_interface(const struct local_interface* iface, const struct sockaddr_storage* source); #endif diff --git a/src/local_transport/protocol.h b/src/local_transport/protocol.h index 2d1f84b7f..bb02201d0 100644 --- a/src/local_transport/protocol.h +++ b/src/local_transport/protocol.h @@ -1,5 +1,16 @@ -/* Внутренний wire-формат: magic(16), version/type(1+1), length(2), пять uint64 BE. - * source/epoch, destination/epoch, request. Объявление не имеет destination/request. */ +/* Внутренний wire-формат local_transport; ручной codec, без выравнивания и native-структур. + * Общий заголовок 60 байт (смещения): + * 0: magic(16, строка LOCAL_MAGIC вместе с NUL), 16: version(1)=1, 17: type(1), + * 18: длина только тела(2 BE), 20: source(8 BE), 28: source_epoch(8 BE), + * 36: destination(8 BE), 44: destination_epoch(8 BE), 52: request(8 BE). + * Полная UDP-датаграмма ровно HEADER_SIZE + length, максимум PACKET_MAX=1160; фрагментации модулем нет. + * source/source_epoch всегда ненулевые, собственный source игнорируется. + * ANNOUNCE: ник 1..127 байтов UTF-8 без NUL, destination/destination_epoch/request=0. + * MESSAGE: произвольные 1..1100 байтов; ACK: ровно один байт enum local_delivery_status (0..2). + * MESSAGE/ACK адресованы node_id/эпохе получателя и имеют request != 0; отправитель и endpoint должны быть известны. + * Эти три типа не имеют подписи/шифрования; ACK подтверждает приём приложением, не выполнение содержимого. + * Общий discovery-порт принимает только ANNOUNCE/ROUTE_ANNOUNCE. Остальные типы — на unicast-портах. + * Проверка IP/входящего интерфейса выполняется до разбора заголовка. */ #ifndef LOCAL_TRANSPORT_PROTOCOL_H #define LOCAL_TRANSPORT_PROTOCOL_H @@ -16,11 +27,20 @@ #define LOCAL_ROUTE_CHALLENGE 5 #define LOCAL_ROUTE_PROOF 6 -/* ANNOUNCE/PROOF: nonce(16), family(1: 4/6), IP(16, v4 с нулевым хвостом), count(1), +/* ROUTE_ANNOUNCE/ROUTE_PROOF: nonce(16), family(1: 4/6), IP(16, v4 с нулевым хвостом), count(1), * count * {socket_id(1), protocol(1), port(2 BE), generation(8 BE)}, Ed25519(64). * Подпись покрывает весь 60-байтный заголовок (magic/version/type/length/IDs/epochs/request) - * и тело до подписи. ANNOUNCE имеет нулевые nonce/destination/request; PROOF адресован запросившему. - * CHALLENGE: ровно nonce(16), destination/epoch обязательны, request=0; ключей в протоколе нет. */ + * и тело до подписи. ROUTE_ANNOUNCE имеет нулевые nonce/destination/destination_epoch/request; + * ROUTE_PROOF адресован запросившему и повторяет его nonce. Для всех трёх ROUTE-типов request=0. + * ROUTE_CHALLENGE: ровно ненулевой nonce(16), destination/epoch обязательны, подписи нет. + * IP обязан совпасть с источником UDP, семейство — с его семейством; scope берётся из локального интерфейса. + * count=0..32; port/generation != 0; socket_id уникальны; protocol — 1(UDP), 2(TCP), 6(TCP|REALITY). + * Отправитель не рассылает пустой ROUTE_ANNOUNCE, но пустой PROOF допустим и очищает набор кандидатов. + * Ключей в протоколе нет: verify использует ранее известный Ed25519-ключ, ANNOUNCE не создаёт кандидаты. + * Только однократный PROOF с ожидаемыми nonce/эпохами за 3с даёт кандидаты на 30с; повтор TTL не продлевает. + * ROUTE_ANNOUNCE/ROUTE_PROOF обрабатываются только при route_offline != 0; ответ на CHALLENGE не зависит от gate. + * Дополнительно требуется живой discovery-endpoint того же IP/UDP-порта/интерфейса. + * Временные константы ниже — timebase (0.1мс), отсчитываются монотонно. */ #define LOCAL_ROUTE_NONCE_SIZE 16 #define LOCAL_ROUTE_HEADER_SIZE 34 #define LOCAL_ROUTE_SOCKET_SIZE 12 @@ -28,16 +48,19 @@ #define LOCAL_ROUTE_CHALLENGE_TB 30000 #define LOCAL_ROUTE_TTL_TB 300000 +/* Записать uint64 BE в доступные 8 байтов p; проверок указателя/длины нет. */ static inline void local_put64(uint8_t* p, uint64_t value) { for (int i = 7; i >= 0; i--) { p[i] = (uint8_t)value; value >>= 8; } } +/* Прочитать uint64 BE из доступных 8 байтов p, без требований выравнивания и проверок границ. */ static inline uint64_t local_get64(const uint8_t* p) { uint64_t value = 0; for (int i = 0; i < 8; i++) value = value << 8 | p[i]; return value; } -/* Непустой UTF-8 ник без NUL, управляющих ASCII, overlong, surrogate и кодов > U+10FFFF. */ +/* 1 = ник допустим: 1..127 байтов UTF-8 без NUL, управляющих ASCII, overlong, surrogate и кодов > U+10FFFF. + * Иначе 0. p должен содержать len доступных байтов; завершающий NUL в len не входит. */ static inline int local_name_valid(const uint8_t* p, size_t len) { if (!len || len >= LOCAL_TRANSPORT_NAME_MAX) return 0; for (size_t i = 0; i < len;) { diff --git a/src/stream/stream_block.h b/src/stream/stream_block.h index f7a8b3ef2..03c352a47 100644 --- a/src/stream/stream_block.h +++ b/src/stream/stream_block.h @@ -2,7 +2,7 @@ * Контексты одного uasync-потока; descriptor и ключ источника уже проверены членством группы. * encode возвращает заимствованные блоки до следующего encode/destroy; ошибочные результаты не публикуют. * parse проверяет только формат части; подпись источника проверяется после RS в batch_verify. - * Заимствованные части действуют до следующего encode/destroy; ошибочный результат не публикуют. */ + * Ключи здесь Ed25519 (32-байтный seed/public key); ID источника с ключом codec сам не связывает. */ #ifndef STREAM_BLOCK_H #define STREAM_BLOCK_H @@ -15,29 +15,34 @@ extern "C" { struct stream_encoder; struct stream_batch_info { - uint64_t seq; - uint32_t data_length; - uint16_t timestamp_ms; + uint64_t seq; /* Индекс пачки, UINT64_MAX запрещён. */ + uint32_t data_length; /* Длина содержимого без batch-header/подписи/padding. */ + uint16_t timestamp_ms; /* Монотонные часы источника по модулю 65536 мс. */ uint16_t block_size; /* Фактический размер RS-кодограммы одной пачки. */ - uint8_t flags; + uint8_t flags; /* Только STREAM_BLOCK_TIME_RESET. */ }; struct stream_block_view { - struct stream_batch_info batch; - uint8_t subblock; + struct stream_batch_info batch; /* Неподписанные подсказки, сверяемые после восстановления. */ + uint8_t subblock; /* Номер RS-части 0..n-1. */ const uint8_t *rs; /* Заимствованный диапазон batch.block_size байт. */ }; +/* Проверить ненулевой ключ, n/r, RS-size 10..4096 и место хотя бы для байта содержимого. + * STREAM_OK/STREAM_ERR_ARGUMENT; descriptor не меняется. */ int stream_descriptor_validate(const struct stream_descriptor *descriptor); +/* Максимальная полная часть: descriptor.block_size + 47; 0 при неверном descriptor. */ size_t stream_block_capacity(const struct stream_descriptor *descriptor); -/* Максимальная длина содержимого без подписанных метаданных/подписи. */ +/* Максимальная длина содержимого без подписанных метаданных/подписи; 0 при неверном descriptor. */ size_t stream_input_size(const struct stream_descriptor *descriptor); -/* out заранее NULL; ключ копируется и очищается при destroy. */ +/* out заранее NULL; descriptor/seed копируются, seed очищается при destroy. + * STREAM_OK либо отрицательная ошибка, при отказе *out остаётся NULL. */ int stream_encoder_create(struct stream_encoder **out, const struct stream_descriptor *descriptor, const uint8_t private_key[SC_PRIVKEY_SIZE]); +/* Освободить encoder и рабочие буферы; NULL допустим. */ void stream_encoder_destroy(struct stream_encoder *encoder); -/* Заимствованный публичный ключ, полученный из private_key этого encoder. */ +/* Заимствованный публичный ключ до destroy, полученный из seed этого encoder; NULL для NULL encoder. */ const uint8_t *stream_encoder_public_key(const struct stream_encoder *encoder); /* blocks — массив descriptor.n указателей; input не перекрывается с рабочими буферами encoder. @@ -50,7 +55,8 @@ int stream_encoder_encode(struct stream_encoder *encoder, uint64_t seq, uint16_t /* Формат, дескриптор и канонический размер; криптографической проверки части нет. view не меняется при отказе. */ int stream_block_parse(const struct stream_descriptor *descriptor, const uint8_t *wire, size_t length, struct stream_block_view *view); /* После RS сверить подписанные поля с ожидаемой пачкой, нулевой хвост и одну подпись источника. - * decoded_length — полный восстановленный размер с padding; содержимое начинается с STREAM_BATCH_HEADER. */ + * decoded_length — полный восстановленный размер с padding; содержимое начинается с STREAM_BATCH_HEADER. + * STREAM_OK либо ERR_ARGUMENT/FORMAT/SIGNATURE. Входы не меняются; decode RS выполняет caller. */ int stream_batch_verify(const struct stream_descriptor *descriptor, const uint8_t public_key[SC_PUBKEY_SIZE], const struct stream_batch_info *expected, const uint8_t *decoded, size_t decoded_length); diff --git a/src/stream/stream_media.h b/src/stream/stream_media.h index f423746ae..c6b64e6d7 100644 --- a/src/stream/stream_media.h +++ b/src/stream/stream_media.h @@ -33,26 +33,40 @@ extern "C" { #define STREAM_MEDIA_OPUS 1 #define STREAM_MEDIA_OPUS_STEREO 2 -struct stream_media_format { uint16_t width, height, rotation; uint8_t video_codec, audio_codec; uint32_t revision; }; +struct stream_media_format { + uint16_t width, height, rotation; /* Геометрия 1..4096, поворот 0/90/180/270. */ + uint8_t video_codec, audio_codec; /* H264..H266 и 0/OPUS/OPUS_STEREO; 0 означает отсутствие аудиотрека. */ + uint32_t revision; /* Ненулевая версия видео; связь версий между пачками проверяет store. */ +}; struct stream_media_video { - uint64_t frame_id, pts_us; - uint32_t frame_size, offset, length; - uint8_t flags; - const uint8_t *data; + uint64_t frame_id, pts_us; /* Ненулевой ID кадра и PTS <= INT64_MAX в микросекундах источника. */ + uint32_t frame_size, offset, length; /* Полный размер <=2MiB, смещение/длина непустого фрагмента. */ + uint8_t flags; /* Только KEY; одинаковы у всех фрагментов кадра. */ + const uint8_t *data; /* Заимствованные length байтов. */ +}; +struct stream_media_audio { + uint64_t pts_us; /* PTS <= INT64_MAX, микросекунды источника. */ + uint32_t length; /* 1..1275 байтов одного Opus-пакета. */ + uint16_t samples; /* Ровно 960 frames/channel (20мс при 48кГц). */ + const uint8_t *data; /* Заимствованные length байтов; codec здесь не декодируется. */ }; -struct stream_media_audio { uint64_t pts_us; uint32_t length; uint16_t samples; const uint8_t *data; }; struct stream_media_block { struct stream_media_format format; - uint32_t first_frame_offset; - unsigned video_count, audio_count; + uint32_t first_frame_offset; /* Parser вычисляет и сверяет; encode вычисляет заново, поле входа игнорируется. */ + unsigned video_count, audio_count; /* Каждый <=16, сумма >0; видео/аудио внутри блока упорядочены по PTS. */ struct stream_media_video video[STREAM_MEDIA_MAX_ENTRIES]; struct stream_media_audio audio[STREAM_MEDIA_MAX_ENTRIES]; }; -/* Encode не меняет output/length при отказе; данные не перекрывают output. */ +/* Encode: полный блок <=65536 байтов, данные не перекрывают output; output/length обязательны. + * STREAM_OK, ERR_ARGUMENT для недостаточного capacity/выходов или ERR_FORMAT для неверного блока. + * output/length не меняются при отказе; межблочную непрерывность/codec bitstream не проверяет. */ int stream_media_encode(const struct stream_media_block *block, uint8_t *output, size_t capacity, size_t *length); +/* Parse: проверить полный канонический блок и reserved, затем опубликовать заимствованные views в block. + * STREAM_OK/ERR_FORMAT; block не меняется при отказе, data должен жить всё время использования views. */ int stream_media_parse(const uint8_t *data, size_t length, struct stream_media_block *block); -/* Разобрать только полностью собранный KEY; указатели заимствованы из data. */ +/* Разобрать только полностью собранный KEY: config допускает длину 0..65536, access unit обязателен. + * Указатели заимствованы из data; все выходы обязательны и не меняются при ERR_FORMAT. Codec не проверяется. */ int stream_media_key_parse(const uint8_t *data, size_t length, const uint8_t **config, size_t *config_length, const uint8_t **frame, size_t *frame_length); diff --git a/src/stream/stream_member.c b/src/stream/stream_member.c index 5d042a183..654f10ddd 100644 --- a/src/stream/stream_member.c +++ b/src/stream/stream_member.c @@ -164,7 +164,7 @@ int stream_member_load(struct UTUN_INSTANCE *inst, uint64_t group_id, uint64_t m } char query[256]; snprintf(query, sizeof(query), "SELECT source,x25519_pubkey,ed25519_pubkey,join_sig,join_ts,update_sig,update_ts," - "userinfo,signed_by,signature FROM \"peers_%s\" WHERE node_id=?", group->channel_id); + "userinfo,signed_by,signature,deleted FROM \"peers_%s\" WHERE node_id=?", group->channel_id); sqlite3_stmt *statement = NULL; sqlite3 *db = inst->topo_sqlite_db; if (sqlite3_prepare_v2(db, query, -1, &statement, NULL) != SQLITE_OK) { @@ -173,7 +173,11 @@ int stream_member_load(struct UTUN_INSTANCE *inst, uint64_t group_id, uint64_t m } sqlite3_bind_int64(statement, 1, (sqlite3_int64)member_id); int result = STREAM_WAIT, step = sqlite3_step(statement); - if (step == SQLITE_ROW && sqlite3_column_int(statement, 0) == 0 + if (step == SQLITE_ROW && sqlite3_column_int(statement, 10) != 0) { + result = STREAM_ERR_NOT_MEMBER; + DEBUG_WARN(DEBUG_CATEGORY_STREAM, "member excluded by channel owner group=%llx member=%llx", + (unsigned long long)group_id, (unsigned long long)member_id); + } else if (step == SQLITE_ROW && sqlite3_column_int(statement, 0) == 0 && sqlite3_column_bytes(statement, 1) == 32 && sqlite3_column_bytes(statement, 2) == 32 && sqlite3_column_bytes(statement, 3) == 64 && sqlite3_column_bytes(statement, 5) == 64 && sqlite3_column_bytes(statement, 9) == 64 && sqlite3_column_int64(statement, 6) > 0) { diff --git a/src/stream/stream_member.h b/src/stream/stream_member.h index b13816ba5..5e5b1d673 100644 --- a/src/stream/stream_member.h +++ b/src/stream/stream_member.h @@ -40,8 +40,10 @@ int stream_member_format(const struct stream_member_state *state, char source[MS char subscriptions[MS_USERINFO_MAX + 1]); int stream_member_has_subscription(const struct stream_member_state *state, uint64_t source_id, uint64_t epoch); -/* WAIT — нет подписанного профиля/подтверждения родителя; ошибка подписи/формата <0. - * NOT_MEMBER отличает удалённого участника от временно неполного профиля. */ +/* WAIT — нет полного подписанного профиля/подтверждения родителя; ошибка подписи/формата <0. + * NOT_MEMBER — строка отсутствует либо принятый блок владельца задаёт deleted=1; запрет проверяется до crypto. + * Выходы меняются только при STREAM_OK; public_key необязателен, state обязателен. + * Online/BGP здесь не проверяются. deleted читается из той же строки, что и подписанный профиль. */ int stream_member_load(struct UTUN_INSTANCE *inst, uint64_t group_id, uint64_t member_id, struct stream_member_state *state, uint8_t public_key[SC_PUBKEY_SIZE]); int stream_member_online(struct UTUN_INSTANCE *inst, uint64_t group_id, uint64_t member_id); diff --git a/src/stream/stream_proto.h b/src/stream/stream_proto.h index 69399ce58..3382048e3 100644 --- a/src/stream/stream_proto.h +++ b/src/stream/stream_proto.h @@ -1,6 +1,10 @@ -/* Части RS имеют непроверенный внешний заголовок; подписанная пачка находится внутри RS. +/* Общие форматы и результаты stream; числовые wire-поля — big-endian, без native-структур. + * Части RS имеют непроверенный внешний заголовок; подписанная пачка находится внутри RS. * Данные ETCP-выдачи (handle/сессия/путь) добавляются снаружи и в подпись не входят. - * seq/subblock берутся из заголовка RS; seq повторяется в подписанной пачке и сверяется после decode. */ + * seq/subblock берутся из 9-байтного заголовка RS; seq повторяется в подписанной пачке и сверяется после decode. + * stream_part1 и stream_batch занимают по 12 байтов без NUL. Внешние поля до RS — 47 байтов, + * подписанный batch-header — 55, затем содержимое, Ed25519(64) и нулевое RS-дополнение. + * block_size в descriptor — максимум только RS; полный размер части дополнительно включает 47 байтов. */ #ifndef STREAM_PROTO_H #define STREAM_PROTO_H @@ -43,12 +47,12 @@ #define STREAM_TIMESTAMP_PERIOD_MS 65536u struct stream_descriptor { - uint64_t group_id; - uint64_t source_node_id; - uint64_t source_epoch; + uint64_t group_id; /* Ненулевой ID CHAT-группы. */ + uint64_t source_node_id; /* Ненулевой ID источника; ключ проверяется отдельно по членству. */ + uint64_t source_epoch; /* Ненулевой случайный ID запуска; параметры неизменны внутри эпохи. */ uint16_t block_size; /* Максимальный размер RS-кодограммы; фактический размер задан в каждой пачке. */ - uint8_t n; - uint8_t r; + uint8_t n; /* Всего частей 1..255; первые n-r систематические. */ + uint8_t r; /* Проверочных частей 0..n-1; нужны любые n-r различных частей. */ }; enum stream_result { @@ -70,13 +74,14 @@ enum stream_result { STREAM_ERR_NOT_MEMBER = -9 }; -/* Короткие примитивы без доступа за границы: размер проверяет вызывающий parser. */ +/* Читать bytes (1..8) доступных байтов BE; проверки указателя/длины нет, выравнивание не требуется. */ static inline uint64_t stream_read_be(const uint8_t *data, unsigned bytes) { uint64_t result = 0; for (unsigned i = 0; i < bytes; i++) result = (result << 8) | data[i]; return result; } +/* Записать младшие bytes (1..8) байтов value в доступный диапазон data; границы проверяет caller. */ static inline void stream_write_be(uint8_t *data, uint64_t value, unsigned bytes) { for (unsigned i = 0; i < bytes; i++) data[bytes - i - 1] = (uint8_t)(value >> (8 * i)); } diff --git a/src/stream/stream_source.h b/src/stream/stream_source.h index 22b6e1932..c796ca0c0 100644 --- a/src/stream/stream_source.h +++ b/src/stream/stream_source.h @@ -16,21 +16,27 @@ struct UASYNC; struct stream_source; typedef void (*stream_source_ready_fn)(struct stream_source *source, uint64_t seq, void *arg); +/* out заранее NULL; ua/arg заимствованы, descriptor/Ed25519 seed копируются; ready необязателен. + * STREAM_OK либо отрицательная ошибка; при отказе out не публикуется. */ int stream_source_create(struct stream_source **out, struct UASYNC *ua, const struct stream_descriptor *descriptor, const uint8_t private_key[SC_PRIVKEY_SIZE], stream_source_ready_fn ready, void *arg); +/* Отменить таймер и освободить источник; не выполняет finish и не публикует остаток. NULL допустим. */ void stream_source_destroy(struct stream_source *source); +/* Максимальная порция write/block, включая после finish; NULL даёт 0 с диагностикой. */ size_t stream_source_input_capacity(const struct stream_source *source); /* Только заимствованное чтение/decode; вставлять блоки/освобождать это кольцо должен сам источник. */ struct stream_buffer *stream_source_buffer(struct stream_source *source); /* length <= input_capacity: вызов кодирует не более одной пачки, не захватывая uasync большим внешним буфером. - * accepted получает принятую часть даже при ошибке; нулевой write допустим и не создаёт пустую пачку. + * accepted обязателен и обнуляется до проверок, затем получает принятую часть даже при ошибке. + * Нулевой write допускает data=NULL и не выбирает режим, но требует живого незавершённого источника. * Ошибка публикации/таймера делает источник failed; его уничтожают, не повторяют принятую часть как новую трансляцию. */ int stream_source_write(struct stream_source *source, const uint8_t *data, size_t length, size_t *accepted); /* Один непустой блок = одна немедленная FEC-пачка с минимальным размером частей, length <= input_capacity. * Режим выбирается первой непустой записью; побайтовый и блочный режимы не смешиваются. */ int stream_source_write_block(struct stream_source *source, const uint8_t *data, size_t length); -/* Сбросить остаток и остановить приём; повторный finish допустим, кольцо доступно до destroy. */ +/* Сбросить остаток и остановить приём; повторный finish допустим, кольцо доступно до destroy. + * Сам не создаёт подписанный сетевой END. STREAM_OK либо отрицательная ошибка; failed не восстанавливается. */ int stream_source_finish(struct stream_source *source); #ifdef __cplusplus diff --git a/tests/Makefile.am b/tests/Makefile.am index 1bfa175bd..c7e21590f 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -129,6 +129,7 @@ check_PROGRAMS += \ test_stream_tx_stats \ test_android_stream \ test_stream_service \ + test_stream_member \ test_u_async_comprehensive \ test_nat_detection \ test_audio_compressor \ @@ -638,6 +639,12 @@ test_stream_service_SOURCES = test_stream_service.c $(test_clock_sources) test_stream_service_LDADD = $(LIBUTUN) $(COMMON_LIBS) test_stream_service_LDFLAGS = $(test_clock_ldflags) -Wl,--wrap=uasync_get_load +# Та же реальная сетевая fixture, отдельный процесс для подписанного удаления/восстановления мемберов. +test_stream_member_SOURCES = $(test_stream_service_SOURCES) +test_stream_member_CFLAGS = $(AM_CFLAGS) -DSTREAM_MEMBER_TEST_ONLY +test_stream_member_LDADD = $(test_stream_service_LDADD) +test_stream_member_LDFLAGS = $(test_stream_service_LDFLAGS) + test_intensive_memory_pool_SOURCES = test_intensive_memory_pool.c test_intensive_memory_pool_CFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/lib test_intensive_memory_pool_LDADD = $(COMMON_LIBS) diff --git a/tests/test_stream_service.c b/tests/test_stream_service.c index 14002683d..0045aeffb 100644 --- a/tests/test_stream_service.c +++ b/tests/test_stream_service.c @@ -1791,6 +1791,167 @@ static void test_supernode_relay(void) { DEBUG_INFO(DEBUG_CATEGORY_STREAM, "[PASS] supernode assistance: direct success, fallback, shared viewers, idle release, replay, relay-only exclusion, empty END"); } +static unsigned member_data, member_closed; + +/* После запрета DATA не выдаются приложению; старый reader завершается ровно одним CLOSED. */ +static void member_event(struct UTUN_INSTANCE *inst, const struct stream_event *event, void *arg) { + (void)arg; CHECK(inst == nodes[1]); + if (event->descriptor.group_id != GROUP1) return; + if (event->type == STREAM_EVENT_DATA) { + CHECK(event->length == sizeof(expected) && !memcmp(event->data, expected, sizeof(expected))); + member_data++; + } + if (event->type == STREAM_EVENT_CLOSED) { CHECK(event->reason == STREAM_CLOSE_MEMBER); member_closed++; } +} + +/* Ошибка загрузки не публикует ни частичное состояние, ни ключ. */ +static void check_member_load(unsigned destination, unsigned member, int expected_result) { + struct stream_member_state state, saved; uint8_t key[32], previous[32]; + memset(&state, 0x5a, sizeof(state)); memcpy(&saved, &state, sizeof(state)); + memset(key, 0xa5, sizeof(key)); memcpy(previous, key, sizeof(key)); + int result = stream_member_load(nodes[destination], GROUP1, nodes[member]->node_id, &state, key); + CHECK(result == expected_result); + if (result != STREAM_OK) CHECK(!memcmp(&state, &saved, sizeof(state)) && !memcmp(key, previous, sizeof(key))); +} + +/* Запрет/разрешение поступает только через подписанный блок владельца и настоящий commit member_sync. */ +static int member_owner_update(unsigned destination, unsigned member, unsigned version, int deleted, int corrupt) { + char tags[128]; uint8_t signature[64], body[256]; + snprintf(tags, sizeof(tags), "{\"ver\":\"%u\",\"deleted\":\"%s\"}", version, deleted ? "yes" : "no"); + int length = member_sync_build_owner_msg(nodes[member]->node_id, tags, body, sizeof(body)); CHECK(length > 0); + CHECK(sc_ed25519_sign(group_private, body, (size_t)length, signature) == SC_OK); + if (corrupt) signature[0] ^= 1; + int result = member_sync_put(nodes[destination], "710001", nodes[member]->node_id, nodes[member]->my_keys.public_key, + nodes[member]->my_ed25519_pubkey, NULL, 0, NULL, 0, NULL, tags, signature, 0, 0, NULL); + DEBUG_INFO(DEBUG_CATEGORY_STREAM, "member owner destination=%u member=%u ver=%u deleted=%d corrupt=%d result=%d", + destination, member, version, deleted, corrupt, result); + return result; +} + +/* Ждём согласованную выдачу, не заменяя готовность фиксированной задержкой. */ +static void wait_member_flow(struct STREAM_RECEIVE *flow) { + struct stream_receive_info info; + uint64_t deadline = get_time_tb() + 100000; + do { + CHECK(stream_receive_get_info(flow, &info) == STREAM_OK); + if (info.state == STREAM_RECEIVE_ACTIVE) return; + CHECK(info.state != STREAM_RECEIVE_CLOSED); + test_clock_poll(ua, 100); + } while (get_time_tb() < deadline); + CHECK(info.state == STREAM_RECEIVE_ACTIVE); +} + +/* Внешний handle остаётся доступен для диагностики и close после отсоединения. */ +static void check_member_flow_closed(struct STREAM_RECEIVE *flow) { + struct stream_receive_info info; + CHECK(stream_receive_get_info(flow, &info) == STREAM_OK); + CHECK(info.state == STREAM_RECEIVE_CLOSED && info.reason == STREAM_REASON_MEMBER); +} + +/* Отдельный процесс test_stream_member разделяет fixture, но не состояния остальных stream-сценариев. */ +static void test_member_lifecycle(void) { + CHECK(!utun_set_client_activity(nodes[0], CLIENT_ACTIVITY_ACTIVE)); + CHECK(!utun_set_client_activity(nodes[2], CLIENT_ACTIVITY_ACTIVE)); + check_member_load(1, 0, STREAM_OK); + sqlite3 *db = nodes[1]->topo_sqlite_db; + CHECK(sqlite3_exec(db, "SAVEPOINT member_incomplete", NULL, NULL, NULL) == SQLITE_OK); + sqlite3_stmt *statement = NULL; + CHECK(sqlite3_prepare_v2(db, "UPDATE peers_710001 SET source=1 WHERE node_id=?", -1, &statement, NULL) == SQLITE_OK); + sqlite3_bind_int64(statement, 1, (sqlite3_int64)nodes[0]->node_id); + CHECK(sqlite3_step(statement) == SQLITE_DONE); sqlite3_finalize(statement); + check_member_load(1, 0, STREAM_WAIT); + CHECK(sqlite3_exec(db, "ROLLBACK TO member_incomplete; RELEASE member_incomplete", NULL, NULL, NULL) == SQLITE_OK); + CHECK(member_owner_update(1, 0, 1000, 1, 1) < 0); check_member_load(1, 0, STREAM_OK); + CHECK(member_owner_update(1, 0, 1000, 1, 0) >= 0); check_member_load(1, 0, STREAM_ERR_NOT_MEMBER); + CHECK(member_owner_update(1, 0, 999, 0, 0) >= 0); check_member_load(1, 0, STREAM_ERR_NOT_MEMBER); + CHECK(member_owner_update(1, 0, 1001, 0, 0) >= 0); check_member_load(1, 0, STREAM_OK); + struct stream_member_state missing, saved; + memset(&missing, 0x5a, sizeof(missing)); memcpy(&saved, &missing, sizeof(missing)); + CHECK(stream_member_load(nodes[1], GROUP1, UINT64_MAX, &missing, NULL) == STREAM_ERR_NOT_MEMBER); + CHECK(!memcmp(&missing, &saved, sizeof(missing))); + DEBUG_INFO(DEBUG_CATEGORY_STREAM, "[PASS] member load: WAIT/NOT_MEMBER, unchanged outputs, signed/stale/invalid owner updates"); + + struct STREAM_HANDLE *publisher = NULL, *other = NULL, *reader = NULL, *relay = NULL, *denied = NULL; + struct STREAM_RECEIVE *receive = NULL, *relay_receive = NULL; + struct stream_parameters parameters = {.n = 1, .r = 0, .block_size = STREAM_RS_DEFAULT_SIZE}; + CHECK(stream_publish_open(nodes[0], GROUP1, ¶meters, &publisher) == STREAM_OK); + CHECK(stream_publish_open(nodes[1], GROUP2, NULL, &other) == STREAM_OK); + struct stream_info origin; CHECK(stream_get_info(publisher, &origin) == STREAM_OK); + wait_state(1, 0, GROUP1, origin.descriptor.source_epoch, 0); + wait_state(2, 0, GROUP1, origin.descriptor.source_epoch, 0); + stream_set_event_callback(nodes[1], member_event, NULL); + CHECK(stream_subscribe_manual_open(nodes[1], GROUP1, nodes[0]->node_id, &reader) == STREAM_OK); + CHECK(stream_receive_open(reader, nodes[0]->node_id, 0, UINT64_MAX, &receive) == STREAM_OK); + wait_member_flow(receive); + memset(expected, 0x47, sizeof(expected)); + CHECK(stream_publish_block(publisher, expected, sizeof(expected)) == STREAM_OK); + run_until(&member_data, 1); + struct NODE_CONN_DIRECT *keep = NULL; + CHECK(node_conn_direct_open(nodes[1], nodes[0]->node_id, NULL, NULL, &keep, NULL) >= 0 && keep); + struct ETCP_CONN *transport = node_conn_direct_get_conn(keep); CHECK(transport && transport->links_up); + + CHECK(member_owner_update(1, 0, 1002, 1, 0) >= 0); + check_member_load(1, 0, STREAM_ERR_NOT_MEMBER); + CHECK(!stream_handle_active(reader) && stream_handle_reason(reader) == STREAM_CLOSE_MEMBER); + check_member_flow_closed(receive); + CHECK(stream_handle_active(other) && stream_handle_active(publisher) && transport->links_up); + CHECK(stream_subscribe_manual_open(nodes[1], GROUP1, nodes[0]->node_id, &denied) == STREAM_ERR_NOT_MEMBER && !denied); + CHECK(stream_publish_block(publisher, expected, sizeof(expected)) == STREAM_OK); + uint64_t deadline = get_time_tb() + 100000; + while ((stream_handle_active(publisher) || !member_closed) && get_time_tb() < deadline) test_clock_poll(ua, 100); + CHECK(member_data == 1 && member_closed == 1 && transport->links_up); + CHECK(!stream_handle_active(publisher) && stream_handle_reason(publisher) == STREAM_CLOSE_MEMBER); + for (unsigned i = 0; i < 4; i++) CHECK(member_owner_update(i, 0, 1003, 0, 0) >= 0); + CHECK(!stream_handle_active(reader)); + stream_receive_close(receive); receive = NULL; stream_close(reader); reader = NULL; + stream_close(publisher); publisher = NULL; + CHECK(stream_publish_open(nodes[0], GROUP1, ¶meters, &publisher) == STREAM_OK); + struct stream_info restarted; CHECK(stream_get_info(publisher, &restarted) == STREAM_OK); + CHECK(restarted.descriptor.source_epoch != origin.descriptor.source_epoch); origin = restarted; + wait_state(1, 0, GROUP1, origin.descriptor.source_epoch, 0); + wait_state(2, 0, GROUP1, origin.descriptor.source_epoch, 0); + CHECK(stream_publish_block(publisher, expected, sizeof(expected)) == STREAM_OK); + CHECK(stream_subscribe_manual_open(nodes[1], GROUP1, nodes[0]->node_id, &reader) == STREAM_OK); + CHECK(stream_subscribe_manual_open(nodes[2], GROUP1, nodes[0]->node_id, &relay) == STREAM_OK); + CHECK(stream_receive_open(relay, nodes[0]->node_id, 0, UINT64_MAX, &relay_receive) == STREAM_OK); + wait_member_flow(relay_receive); + wait_state(1, 2, GROUP1, origin.descriptor.source_epoch, 1); + struct stream_local local; deadline = get_time_tb() + 100000; + do { + test_clock_poll(ua, 100); + CHECK(stream_local_get(nodes[2], &origin.descriptor, &local) == STREAM_OK); + } while (!local.decoded && get_time_tb() < deadline); + CHECK(local.decoded); + CHECK(stream_receive_open(reader, nodes[2]->node_id, 0, UINT64_MAX, &receive) == STREAM_OK); + wait_member_flow(receive); + DEBUG_INFO(DEBUG_CATEGORY_STREAM, "[PASS] source removal: handles/flows/publisher stop, other channel/NCD survive, new epoch after restore"); + + CHECK(member_owner_update(1, 2, 1000, 1, 0) >= 0); + check_member_flow_closed(receive); + CHECK(stream_handle_active(reader) && stream_handle_active(relay) && stream_handle_active(other)); + struct stream_receive_info relay_info; + CHECK(stream_receive_get_info(relay_receive, &relay_info) == STREAM_OK && relay_info.state == STREAM_RECEIVE_ACTIVE); + DEBUG_INFO(DEBUG_CATEGORY_STREAM, "[PASS] supplier removal: only its issuance closes, source session/other upstream/channel survive"); + stream_receive_close(receive); receive = NULL; + + CHECK(member_owner_update(1, 1, 1000, 1, 0) >= 0); + CHECK(!stream_handle_active(reader) && stream_handle_reason(reader) == STREAM_CLOSE_MEMBER); + CHECK(stream_handle_active(other) && stream_handle_active(publisher) && stream_handle_active(relay)); + CHECK(stream_publish_open(nodes[1], GROUP1, NULL, &denied) == STREAM_ERR_NOT_MEMBER && !denied); + CHECK(stream_subscribe_manual_open(nodes[1], GROUP1, nodes[0]->node_id, &denied) == STREAM_ERR_NOT_MEMBER && !denied); + CHECK(stream_publish_block(other, expected, sizeof(expected)) == STREAM_OK); + CHECK(stream_get_info(other, &restarted) == STREAM_OK && restarted.buffer.blocks > 0); + CHECK(member_owner_update(1, 1, 1001, 0, 0) >= 0); + CHECK(!stream_handle_active(reader)); + stream_close(reader); reader = NULL; + CHECK(stream_subscribe_manual_open(nodes[1], GROUP1, nodes[0]->node_id, &reader) == STREAM_OK); + DEBUG_INFO(DEBUG_CATEGORY_STREAM, "[PASS] own removal: channel closes/new open denied, other channel writes, " + "higher owner version restores new open"); + stream_set_event_callback(nodes[1], NULL, NULL); + stream_receive_close(relay_receive); stream_close(reader); stream_close(relay); stream_close(other); stream_close(publisher); + node_conn_direct_close(keep); +} + /* Канонический список исключает неоднозначные IDs, дубли и обрезание значений. */ static void test_member_format(void) { struct stream_member_state state = {.source = {.group_id = GROUP1, .source_node_id = 1, .source_epoch = 2, @@ -2142,12 +2303,17 @@ int main(int argc, char **argv) { CHECK(member_sync_start(nodes[0], nodes[i]->node_id, "710001", NULL, NULL) == 0); CHECK(member_sync_start(nodes[i], nodes[0]->node_id, "710001", NULL, NULL) == 0); } - if (argc == 2 && (!strcmp(argv[1], "--relay-only") || !strcmp(argv[1], "--lifecycle-only") - || !strcmp(argv[1], "--wake-only") || !strcmp(argv[1], "--bootstrap-only") || !strcmp(argv[1], "--recovery-only"))) { - if (!strcmp(argv[1], "--relay-only")) test_supernode_relay(); - else if (!strcmp(argv[1], "--lifecycle-only")) test_partial_bootstrap_and_end(); - else if (!strcmp(argv[1], "--bootstrap-only")) test_bootstrap(); - else if (!strcmp(argv[1], "--recovery-only")) test_recovery_scenarios(); + const char *mode = argc == 2 ? argv[1] : NULL; +#ifdef STREAM_MEMBER_TEST_ONLY + mode = "--member-only"; +#endif + if (mode && (!strcmp(mode, "--relay-only") || !strcmp(mode, "--lifecycle-only") || !strcmp(mode, "--wake-only") + || !strcmp(mode, "--bootstrap-only") || !strcmp(mode, "--recovery-only") || !strcmp(mode, "--member-only"))) { + if (!strcmp(mode, "--member-only")) test_member_lifecycle(); + else if (!strcmp(mode, "--relay-only")) test_supernode_relay(); + else if (!strcmp(mode, "--lifecycle-only")) test_partial_bootstrap_and_end(); + else if (!strcmp(mode, "--bootstrap-only")) test_bootstrap(); + else if (!strcmp(mode, "--recovery-only")) test_recovery_scenarios(); else test_sources_after_wake(); for (unsigned i = 0; i < 3; i++) topo_group_peer_close(connections[i]); for (unsigned i = 0; i < 4; i++) { stream_set_event_callback(nodes[i], NULL, NULL); utun_instance_destroy(nodes[i]); }