Recover Companion WiFi TCP listener failures and expose diagnostics

This commit is contained in:
mikecarper committed 2026-10-13 16:24:34 -07:00
1 parent a2f51253d8
commit 6693dba8cf
17 files changed
+1004 -46

No files matched your search

+12 -1
View File
@@ -59,6 +59,7 @@ Portal& wifiSetupPortal(){return portal;}
void saveCompanionWiFi(){}
char configured_wifi_ssid[8]="mesh",configured_wifi_password[8]="secret";
bool companion_wifi_has_credentials=true,companion_wifi_requested=true,companion_wifi_active=true;
bool companion_wifi_interface_registered=true;
bool companion_wifi_services_stopped=true;
bool companion_wifi_background_stopped=false,companion_wifi_espnow_restore_pending=true;
bool companion_wifi_webconfig_start_pending=false;
@@ -71,7 +72,11 @@ void loadCompanionWiFiCredentials(){++credential_loads;}
void resetCompanionWiFiRecoveryState(){wifi_reconnect_tracker=WiFiReconnectPolicy::Tracker();}
void applyCompanionWiFiPowerSave(){++power_writes;}
constexpr int TCP_PORT=1234;
struct Interface{void begin(int){++socket_starts;}void enable(){}}wifi_interface;
struct Interface{
bool begin(int){++socket_starts;return true;}
void enable(){}
bool isListening()const{return socket_starts>0;}
}wifi_interface;
void ota_console_start(){++console_starts;}
@POWER_GUARDS@
#ifdef WITH_WEBCONFIG
@@ -136,6 +141,12 @@ int main(int argc,char** argv){
assert(companion_wifi_active&&!companion_wifi_services_stopped&&board.inhibit_sleep);
assert(mode_writes==1&&joins==1&&socket_starts==1&&console_starts==1&&power_writes==1);
startCompanionWiFi();assert(mode_writes==1&&socket_starts==1);
}else if(scenario=="registration"){
companion_wifi_interface_registered=false;
companion_wifi_active=false;board.ota=false;sdk_mode=WIFI_STA;
startCompanionWiFi();
assert(companion_wifi_active&&board.inhibit_sleep&&!companion_wifi_services_stopped);
assert(socket_starts==0&&console_starts==1&&joins==1);
}else if(scenario=="suspended"){
auto& power=mesh::wifi::networkPower();
power.setManaged(true);power.setSuspended(true);
+97
View File
@@ -0,0 +1,97 @@
#include <helpers/wifi/SerialWifiInterface.h>
#include <cassert>
#include <cstdio>
#include <cstring>
#include <climits>
uint32_t mock_millis = 100;
std::deque<WiFiClient> WiFiServer::incoming;
constexpr int TCP_PORT = 5000;
constexpr int ESP_OK = 0;
struct wifi_ap_record_t {};
int esp_wifi_sta_get_ap_info(wifi_ap_record_t*) { return ESP_OK; }
struct DiagnosticInterface {
SerialWifiInterface::Status snapshot{};
int reads = 0;
SerialWifiInterface::Status getStatus() { ++reads; return snapshot; }
} wifi_interface;
bool companion_wifi_interface_registered = true;
uint8_t companion_wifi_display_state = 3;
uint32_t companion_wifi_display_frames = 99;
bool companion_display_available = true;
uint8_t companion_display_begin_status = 0x3c;
bool companion_wifi_requested = true;
bool companion_wifi_active = true;
@METHODS@
int main() {
using Transport = SerialWifiInterface;
auto& status = wifi_interface.snapshot;
status.state = Transport::State::Retrying;
status.addressReady = true;
status.port = 5000;
status.beginFailures = 1;
status.lastErrno = EADDRINUSE;
status.retryInMs = 1;
status.lastDisconnectReason = Transport::DisconnectReason::InvalidHeader;
char reply[160] = {};
formatCompanionWiFiTcpStatus(reply, sizeof(reply));
assert(strstr(reply, "tcp=5000 retrying reg=1 ip=1 client=0 fail=1"));
assert(strstr(reply, "retry=1s") && strstr(reply, "drop=invalid-header"));
formatCompanionWiFiDisplayStatus(reply, sizeof(reply));
assert(strstr(reply, "requested=1, services=1") && strstr(reply, "tcp=0"));
status.listening = true;
status.clientConnected = true;
status.state = Transport::State::Listening;
formatCompanionWiFiDisplayStatus(reply, sizeof(reply));
assert(strstr(reply, "tcp=1"));
formatCompanionWiFiTcpStatus(reply, sizeof(reply));
assert(strstr(reply, "listening") && strstr(reply, "client=1"));
// Full-width counters and errno must leave the final drop reason intact in
// the actual 160-byte Companion command reply, not silently truncate it.
status.state = Transport::State::WaitingIp;
status.port = 65535;
status.beginFailures = UINT32_MAX;
status.acceptedClients = UINT32_MAX;
status.validFrames = UINT32_MAX;
status.txFrames = UINT32_MAX;
status.lastOpcode = status.lastTxOpcode = 0xff;
status.lastErrno = INT32_MIN;
status.retryInMs = 30000;
struct Guarded { char text[160]; char guard[8]; } guarded;
memset(&guarded, 0x5a, sizeof(guarded));
formatCompanionWiFiTcpStatus(guarded.text, sizeof(guarded.text));
assert(strlen(guarded.text) < sizeof(guarded.text));
assert(strstr(guarded.text, "fail=4294967295 err=-2147483648 retry=30s"));
assert(strstr(guarded.text, "acc=4294967295 rx=4294967295/FF tx=4294967295/FF"));
assert(strstr(guarded.text, "drop=invalid-header"));
for (char byte : guarded.guard) assert(byte == 0x5a);
// Correlated binary CLI replies reserve three of the 160 bytes for a tag.
formatCompanionWiFiTcpStatus(guarded.text, 157);
assert(strlen(guarded.text) < 157);
assert(strstr(guarded.text, "drop=invalid-header"));
for (char byte : guarded.guard) assert(byte == 0x5a);
// Small/null buffers are normal API contracts, not a reason to touch the
// transport. Status polling must not consume a command or open a client.
const int reads = wifi_interface.reads;
formatCompanionWiFiTcpStatus(nullptr, 160);
formatCompanionWiFiTcpStatus(reply, 0);
formatCompanionWiFiDisplayStatus(nullptr, 160);
formatCompanionWiFiDisplayStatus(reply, 0);
assert(wifi_interface.reads == reads);
memset(&guarded, 0x5a, sizeof(guarded));
formatCompanionWiFiTcpStatus(guarded.text, 1);
assert(guarded.text[0] == 0 && guarded.text[1] == 0x5a);
formatCompanionWiFiTcpStatus(guarded.text, 8);
assert(guarded.text[7] == 0 && guarded.text[8] == 0x5a);
companion_wifi_interface_registered = false;
status.port = 0;
formatCompanionWiFiTcpStatus(reply, sizeof(reply));
assert(strstr(reply, "tcp=5000") && strstr(reply, "reg=0"));
assert(WiFiServer::begin_calls == 0 && WiFiServer::incoming.empty());
std::puts("PASS: production Wi-Fi diagnostic formatters");
}
+348
View File
@@ -0,0 +1,348 @@
#include <helpers/wifi/SerialWifiInterface.h>
#include <helpers/MultiSerialInterface.h>
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <limits>
#include <vector>
uint32_t mock_millis = 100;
std::deque<WiFiClient> WiFiServer::incoming;
using Socket = std::shared_ptr<MockSocket>;
using Bytes = std::vector<uint8_t>;
static const IPAddress A(192, 168, 1, 20);
static const IPAddress B(192, 168, 1, 30);
struct Fixture {
SerialWifiInterface transport;
uint8_t input[MAX_FRAME_SIZE] = {};
int cancellations = 0;
Fixture() {
transport.setSessionChangedCallback([](void* context) {
++static_cast<Fixture*>(context)->cancellations;
}, this);
}
~Fixture() { transport.end(); }
bool start() { const bool result = transport.begin(5000); transport.enable(); return result; }
size_t tick() { return transport.checkRecvFrame(input); }
Socket connect(IPAddress ip, const Bytes& data = {}) {
auto socket = std::make_shared<MockSocket>(ip);
socket->received.insert(socket->received.end(), data.begin(), data.end());
WiFiServer::incoming.push_back(WiFiClient(socket));
tick();
return socket;
}
};
int main(int argc, char** argv) {
assert(argc == 2);
const int scenario = std::atoi(argv[1]);
WiFiServer::resetDiagnostics();
mock_millis = 100;
Fixture f;
if (scenario == 0) {
WiFi.link_status = WL_DISCONNECTED;
WiFi.station_ip = IPAddress();
assert(!f.start());
for (int i = 0; i < 100; ++i) { mock_millis += 1000; f.tick(); }
auto status = f.transport.getStatus();
assert(status.enabled && status.requested && !status.addressReady);
assert(!status.listening && status.beginAttempts == 0 && status.beginFailures == 0);
assert(WiFiServer::begin_calls == 0);
WiFi.link_status = WL_CONNECTED;
WiFi.station_ip = IPAddress(192, 168, 1, 10);
f.tick();
assert(f.transport.getStatus().listening && WiFiServer::begin_calls == 1);
} else if (scenario == 1) {
assert(f.start());
const int ends = WiFiServer::end_calls;
for (int i = 0; i < 100; ++i) { mock_millis += 1000; f.tick(); }
assert(f.transport.begin(5000));
assert(WiFiServer::begin_calls == 1 && WiFiServer::end_calls == ends);
assert(WiFiServer::open_sockets == 1);
} else if (scenario >= 2 && scenario <= 4) {
WiFiServer::begin_fault = scenario == 2 ? WiFiServer::BeginFault::Socket
: scenario == 3 ? WiFiServer::BeginFault::Bind : WiFiServer::BeginFault::Listen;
assert(!f.start());
auto failed = f.transport.getStatus();
assert(!failed.listening && failed.beginAttempts == 1 && failed.beginFailures == 1);
assert(!f.transport.isEnabled());
assert(failed.retryInMs == 1000 && static_cast<int>(failed.lastStartError) != 0);
assert(failed.lastErrno == (scenario == 2 ? ENOMEM : scenario == 3 ? EADDRINUSE : EIO));
assert(WiFiServer::open_sockets == 0);
for (int i = 0; i < 50; ++i) f.tick();
assert(WiFiServer::begin_calls == 1 && WiFiServer::open_sockets == 0);
mock_millis += 999; f.tick();
assert(WiFiServer::begin_calls == 1);
WiFiServer::begin_fault = WiFiServer::BeginFault::None;
++mock_millis; f.tick();
auto healed = f.transport.getStatus();
assert(healed.listening && healed.beginAttempts == 2 && healed.beginFailures == 1);
assert(healed.retryInMs == 0 && WiFiServer::open_sockets == 1);
assert(healed.lastStartError == SerialWifiInterface::StartError::None && healed.lastErrno == 0);
assert(f.transport.isEnabled());
} else if (scenario == 5) {
WiFiServer::begin_fault = WiFiServer::BeginFault::Listen;
assert(!f.start());
for (uint32_t delay : {1000U, 2000U, 4000U, 8000U, 16000U, 30000U, 30000U}) {
auto before = f.transport.getStatus();
assert(before.retryInMs == delay && WiFiServer::open_sockets == 0);
mock_millis += delay - 1;
for (int i = 0; i < 20; ++i) f.tick();
assert(f.transport.getStatus().beginAttempts == before.beginAttempts);
++mock_millis; f.tick();
assert(f.transport.getStatus().beginAttempts == before.beginAttempts + 1);
assert(WiFiServer::open_sockets == 0);
}
WiFiServer::begin_fault = WiFiServer::BeginFault::None;
mock_millis += 30000; f.tick();
assert(f.transport.getStatus().listening);
} else if (scenario == 6) {
mock_millis = UINT32_MAX - 500;
WiFiServer::begin_fault = WiFiServer::BeginFault::Bind;
assert(!f.start());
mock_millis += 999; f.tick();
assert(WiFiServer::begin_calls == 1 && f.transport.getStatus().retryInMs == 1);
WiFiServer::begin_fault = WiFiServer::BeginFault::None;
++mock_millis; f.tick();
assert(f.transport.getStatus().listening && WiFiServer::begin_calls == 2);
} else if (scenario == 7 || scenario == 8) {
WiFiServer::begin_fault = WiFiServer::BeginFault::Bind;
assert(!f.start());
if (scenario == 7) f.transport.disable();
else f.transport.end(); // The main loop uses end() for network suspension.
assert(!f.transport.getStatus().requested && !f.transport.getStatus().listening);
WiFiServer::begin_fault = WiFiServer::BeginFault::None;
mock_millis += 30000;
f.transport.enable();
for (int i = 0; i < 20; ++i) f.tick();
assert(WiFiServer::begin_calls == 1 && WiFiServer::open_sockets == 0);
assert(!f.transport.getStatus().requested);
assert(f.transport.begin(5000));
assert(f.transport.getStatus().listening);
} else if (scenario == 9) {
assert(f.start());
auto socket = f.connect(A);
const Bytes reply{0x01, 0x23, 0x45};
assert(f.transport.writeFrame(reply.data(), reply.size()) == reply.size());
WiFiServer::listener_lost = true;
f.transport.loop();
assert(f.transport.getStatus().listening);
assert(f.transport.isConnected() && socket->connected && f.cancellations == 0);
socket->write_limit = std::numeric_limits<size_t>::max();
for (int i = 0; i < 5; ++i) f.tick();
assert((socket->sent == Bytes{'>', 3, 0, 0x01, 0x23, 0x45}));
} else if (scenario == 10) {
assert(f.start());
WiFi.link_status = WL_DISCONNECTED;
WiFi.station_ip = IPAddress();
f.tick();
const int begins = WiFiServer::begin_calls;
assert(f.transport.getStatus().requested && !f.transport.getStatus().addressReady);
for (int i = 0; i < 20; ++i) { mock_millis += 1000; f.tick(); }
assert(WiFiServer::begin_calls == begins);
WiFi.link_status = WL_CONNECTED;
WiFi.station_ip = IPAddress(192, 168, 1, 11);
f.tick();
assert(f.transport.getStatus().listening);
auto socket = f.connect(A, Bytes{'<', 1, 0, 0x16});
assert(socket->connected && f.input[0] == 0x16);
} else if (scenario == 11) {
WiFi.station_ip = IPAddress();
assert(!f.start());
f.tick();
assert(!f.transport.getStatus().addressReady && WiFiServer::begin_calls == 0);
WiFi.station_ip = IPAddress(192, 168, 1, 11);
f.tick();
assert(f.transport.getStatus().listening);
} else if (scenario == 12 || scenario == 13) {
WiFi.link_status = WL_DISCONNECTED;
WiFi.station_ip = IPAddress();
WiFi.mode_value = WIFI_AP;
if (scenario == 12) WiFi.access_point_ip = IPAddress(192, 168, 4, 1);
assert(f.start() == (scenario == 12));
f.tick();
assert(f.transport.getStatus().addressReady == (scenario == 12));
assert(f.transport.getStatus().listening == (scenario == 12));
assert(WiFiServer::begin_calls == (scenario == 12 ? 1 : 0));
} else if (scenario == 14) {
assert(f.start());
auto old = f.connect(A, Bytes{'<', 1, 0, 0x11});
auto next = f.connect(B, Bytes{'<', 1, 0, 0x12});
assert(!old->connected && next->connected && f.cancellations == 1);
auto status = f.transport.getStatus();
assert(status.acceptedClients == 2 && status.validFrames == 2);
assert(status.lastOpcode == 0x12 && status.clientConnected && status.listening);
assert(status.disconnects == 1);
assert(status.lastDisconnectReason == SerialWifiInterface::DisconnectReason::Replaced);
} else if (scenario == 15) {
assert(f.start());
auto socket = f.connect(A);
auto accepted = f.transport.getStatus();
assert(accepted.acceptedClients == 1 && accepted.validFrames == 0);
socket->received = {'<', 1, 0, 0x16};
assert(f.tick() == 1);
auto parsed = f.transport.getStatus();
assert(parsed.validFrames == 1 && parsed.lastOpcode == 0x16);
socket->received = {'<', 2, 0, 0x42, 0x17};
assert(f.tick() == 2);
assert(f.transport.getStatus().validFrames == 2);
assert(f.transport.getStatus().lastOpcode == 0x42);
socket->connected = false; f.tick(); f.tick();
assert(f.transport.getStatus().disconnects == 1);
assert(f.transport.getStatus().lastDisconnectReason == SerialWifiInterface::DisconnectReason::PeerClosed);
assert(f.cancellations == 1 && !f.transport.getStatus().clientConnected);
} else if (scenario == 16) {
assert(f.start());
auto socket = f.connect(A, Bytes{'?', 1, 0, '<', 1, 0, 0x16});
auto status = f.transport.getStatus();
assert(!socket->connected && !status.clientConnected);
assert(status.acceptedClients == 1 && status.validFrames == 0 && status.disconnects == 1);
assert(status.lastDisconnectReason == SerialWifiInterface::DisconnectReason::InvalidHeader);
assert(socket->read_count == 3 && status.listening);
for (int i = 0; i < 20; ++i) assert(f.tick() == 0);
assert(f.transport.getStatus().disconnects == 1);
f.connect(A, Bytes{'<', 1, 0, 0x16});
assert(f.transport.getStatus().validFrames == 1);
} else if (scenario == 17) {
assert(f.start());
auto socket = f.connect(A, Bytes{'<', 2, 0, 0x16});
mock_millis += 4999; f.tick();
assert(socket->connected && f.transport.getStatus().disconnects == 0);
++mock_millis; f.tick();
auto status = f.transport.getStatus();
assert(!socket->connected && status.disconnects == 1 && status.validFrames == 0);
assert(status.lastDisconnectReason == SerialWifiInterface::DisconnectReason::FrameTimeout);
} else if (scenario == 18) {
assert(f.start());
auto socket = f.connect(A);
socket->received = {'<', 1, 0, 0x16};
const int begins = WiFiServer::begin_calls, ends = WiFiServer::end_calls;
for (int i = 0; i < 100; ++i) {
auto status = f.transport.getStatus();
assert(status.listening && status.validFrames == 0);
}
assert(socket->read_count == 0 && WiFiServer::begin_calls == begins && WiFiServer::end_calls == ends);
assert(f.tick() == 1 && f.transport.getStatus().validFrames == 1);
} else if (scenario == 19) {
WiFiServer::begin_fault = WiFiServer::BeginFault::Listen;
assert(!f.transport.begin(5000));
assert(!f.transport.getStatus().enabled);
WiFiServer::begin_fault = WiFiServer::BeginFault::None;
mock_millis += 30000;
for (int i = 0; i < 20; ++i) f.tick();
assert(WiFiServer::begin_calls == 1 && WiFiServer::open_sockets == 0);
f.transport.enable(); f.tick();
assert(f.transport.getStatus().listening && WiFiServer::begin_calls == 2);
} else if (scenario == 20) {
assert(f.start());
auto socket = f.connect(A);
const Bytes reply{0x05, 0x23, 0x45};
assert(f.transport.writeFrame(reply.data(), reply.size()) == reply.size());
assert(f.transport.getStatus().txFrames == 0);
f.tick(); // A zero-byte write is neither a sent packet nor a failure.
assert(f.transport.getStatus().txFrames == 0 && socket->sent.empty());
socket->write_limit = 2;
f.tick(); f.tick();
assert(socket->sent.size() == 4 && f.transport.getStatus().txFrames == 0);
f.tick();
auto complete = f.transport.getStatus();
assert(complete.txFrames == 1 && complete.lastTxOpcode == 0x05);
for (int i = 0; i < 10; ++i) f.tick();
assert(f.transport.getStatus().txFrames == 1);
} else if (scenario == 21) {
assert(!f.transport.begin(0));
f.transport.enable();
for (int i = 0; i < 20; ++i) { mock_millis += 1000; f.tick(); }
auto status = f.transport.getStatus();
assert(!status.requested && !status.listening && WiFiServer::begin_calls == 0);
assert(status.beginAttempts == 0 && status.beginFailures == 0);
assert(status.lastStartError == SerialWifiInterface::StartError::InvalidPort);
assert(!f.transport.begin(65536));
assert(f.transport.begin(5000));
assert(f.transport.getStatus().listening);
} else if (scenario == 22 || scenario == 23) {
assert(f.start());
auto socket = f.connect(A, scenario == 23 ? Bytes{'<', 2, 0} : Bytes{});
socket->read_limit = 1;
const Bytes remaining = scenario == 23 ? Bytes{0x16, 0x17} : Bytes{'<', 2, 0, 0x16, 0x17};
socket->received.assign(remaining.begin(), remaining.end());
assert(f.tick() == 0);
auto status = f.transport.getStatus();
assert(!socket->connected && status.validFrames == 0 && status.disconnects == 1);
const auto expected = scenario == 22 ? SerialWifiInterface::DisconnectReason::ShortHeader
: SerialWifiInterface::DisconnectReason::ShortPayload;
assert(status.lastDisconnectReason == expected);
assert(status.listening);
} else if (scenario == 24) {
assert(f.start());
auto socket = f.connect(A, Bytes{'<', 1, 0, 0x16});
const int begins = WiFiServer::begin_calls, ends = WiFiServer::end_calls;
WiFi.station_ip = IPAddress(192, 168, 1, 99);
f.tick();
assert(f.transport.getStatus().listening && socket->connected && f.cancellations == 0);
assert(WiFiServer::begin_calls == begins && WiFiServer::end_calls == ends);
} else if (scenario == 25) {
WiFiServer::begin_fault = WiFiServer::BeginFault::Socket;
assert(!f.transport.begin(5000));
MultiSerialInterface manager;
assert(manager.addInterface(InterfaceType::WiFi, &f.transport));
manager.enable();
assert(!f.transport.isEnabled());
assert(manager.checkRecvFrame(f.input) == 0);
mock_millis += 1000;
WiFiServer::begin_fault = WiFiServer::BeginFault::None;
manager.loop(); // Must service failed transports despite unavailable dispatch.
assert(f.transport.isEnabled() && f.transport.getStatus().listening);
auto socket = std::make_shared<MockSocket>(A);
socket->received = {'<', 1, 0, 0x16};
WiFiServer::incoming.push_back(WiFiClient(socket));
assert(manager.checkRecvFrame(f.input) == 1 && f.input[0] == 0x16);
} else if (scenario == 26) {
assert(f.start());
auto socket = f.connect(A);
MultiSerialInterface manager;
assert(manager.addInterface(InterfaceType::WiFi, &f.transport));
manager.enable();
socket->received = {'<', 1, 0, 0x04};
assert(manager.checkRecvFrame(f.input) == 1 && f.input[0] == 0x04);
manager.lockReplyRoute();
assert(manager.isReplyRouteAvailable(&f.transport));
const Bytes reply{0x05, 0x23, 0x45};
assert(manager.writeFrame(reply.data(), reply.size()) == reply.size());
WiFiServer::listener_lost = true;
WiFiServer::begin_fault = WiFiServer::BeginFault::Bind;
manager.loop();
assert(!f.transport.getStatus().listening && socket->connected && f.cancellations == 0);
assert(f.transport.hasPendingIO() && WiFiServer::open_sockets == 0);
assert(f.transport.isEnabled() && manager.isConnected());
assert(manager.isReplyRouteAvailable(&f.transport));
// A separately accepted socket must continue this locked response stream
// before listener repair succeeds; a listener-only readiness test breaks it.
socket->write_limit = std::numeric_limits<size_t>::max();
assert(manager.checkRecvFrame(f.input) == 0);
assert((socket->sent == Bytes{'>', 3, 0, 0x05, 0x23, 0x45}));
assert(f.transport.getStatus().txFrames == 1);
socket->received = {'<', 1, 0, 0x16};
assert(manager.checkRecvFrame(f.input) == 1 && f.input[0] == 0x16);
assert(f.transport.getStatus().validFrames == 2);
assert(!f.transport.getStatus().listening && WiFiServer::begin_calls == 2);
mock_millis += 1000;
WiFiServer::begin_fault = WiFiServer::BeginFault::None;
manager.loop();
assert(f.transport.getStatus().listening && socket->connected && f.cancellations == 0);
assert(manager.isReplyRouteAvailable(&f.transport));
} else if (scenario == 27) {
WiFi.mode_value = WIFI_STA;
WiFi.link_status = WL_DISCONNECTED;
WiFi.station_ip = IPAddress();
WiFi.access_point_ip = IPAddress(192, 168, 4, 1);
assert(!f.start());
f.tick();
assert(!f.transport.getStatus().addressReady && WiFiServer::begin_calls == 0);
} else {
assert(false && "unknown scenario");
}
std::printf("PASS: Wi-Fi listener scenario %d\n", scenario);
}
+75 -6
View File
@@ -1,11 +1,13 @@
#pragma once
#include <algorithm>
#include <cerrno>
#include <cstddef>
#include <cstdint>
#include <deque>
#include <limits>
#include <memory>
#include <string>
#include <vector>
class IPAddress {
@@ -18,8 +20,34 @@ public:
operator uint32_t() const { return _address; }
bool operator==(const IPAddress& other) const { return _address == other._address; }
bool operator!=(const IPAddress& other) const { return !(*this == other); }
std::string toString() const {
return std::to_string((_address >> 24) & 255) + "."
+ std::to_string((_address >> 16) & 255) + "."
+ std::to_string((_address >> 8) & 255) + "."
+ std::to_string(_address & 255);
}
};
constexpr int WL_CONNECTED = 3;
constexpr int WL_DISCONNECTED = 6;
constexpr int WIFI_OFF = 0;
constexpr int WIFI_STA = 1;
constexpr int WIFI_AP = 2;
constexpr int WIFI_AP_STA = 3;
struct WiFiClass {
int link_status = WL_CONNECTED;
int mode_value = WIFI_STA;
IPAddress station_ip{192, 168, 1, 10};
IPAddress access_point_ip;
int status() const { return link_status; }
int getMode() const { return mode_value; }
IPAddress localIP() const { return station_ip; }
IPAddress softAPIP() const { return access_point_ip; }
};
inline WiFiClass WiFi;
struct MockSocket {
IPAddress address;
bool connected = true;
@@ -36,11 +64,13 @@ class WiFiClient {
public:
WiFiClient() = default;
explicit WiFiClient(std::shared_ptr<MockSocket> socket) : _socket(socket) {}
explicit operator bool() const { return _socket && _socket->connected; }
bool connected() const { return _socket && _socket->connected; }
explicit operator bool() { return _socket && _socket->connected; }
// Match the pinned ESP32 SDK's non-const connected() signature. This catches
// const transport accessors that accidentally rely on a const-only fake.
bool connected() { return _socket && _socket->connected; }
void stop() { if (_socket) _socket->connected = false; }
IPAddress remoteIP() const { return _socket ? _socket->address : IPAddress(); }
int available() const { return connected() ? int(_socket->received.size()) : 0; }
int available() { return connected() ? int(_socket->received.size()) : 0; }
size_t read(uint8_t* dest, size_t size) {
if (_socket) size = std::min(size, _socket->read_limit);
size_t read = 0;
@@ -61,12 +91,51 @@ public:
};
class WiFiServer {
bool _listening = false;
bool _owns_socket = false;
public:
enum class BeginFault { None, Socket, Bind, Listen };
static std::deque<WiFiClient> incoming;
void begin(int) {}
void end() { incoming.clear(); }
inline static BeginFault begin_fault = BeginFault::None;
inline static int begin_calls = 0;
inline static int end_calls = 0;
inline static int open_sockets = 0;
inline static int last_port = 0;
inline static bool listener_lost = false;
static void resetDiagnostics() {
begin_fault = BeginFault::None;
begin_calls = end_calls = open_sockets = last_port = 0;
listener_lost = false;
incoming.clear();
WiFi = WiFiClass{};
}
void begin(int port) {
++begin_calls;
last_port = port;
if (_listening) return;
if (begin_fault == BeginFault::Socket) { errno = ENOMEM; return; }
// The pinned Arduino ESP32 WiFiServer leaves its descriptor open when
// bind/listen fails. A wrapper must call end() before a bounded retry.
_owns_socket = true;
++open_sockets;
if (begin_fault == BeginFault::Bind) { errno = EADDRINUSE; return; }
if (begin_fault == BeginFault::Listen) { errno = EIO; return; }
_listening = true;
listener_lost = false;
errno = 0;
}
void end() {
++end_calls;
if (_owns_socket) --open_sockets;
_owns_socket = _listening = false;
listener_lost = false;
incoming.clear();
// Cleanup may overwrite errno; diagnostics must preserve the start error.
errno = 0;
}
operator bool() { return _listening && !listener_lost; }
WiFiClient available() {
if (incoming.empty()) return WiFiClient();
if (!static_cast<bool>(*this) || incoming.empty()) return WiFiClient();
WiFiClient client = incoming.front();
incoming.pop_front();
return client;
+1
View File
@@ -203,6 +203,7 @@ class CLISettingsContractTest(unittest.TestCase):
self.assertEqual(gets - sets, {
'contact.cache', 'contact.cache.timing', # Contact-storage diagnostics
'display.wifi', # Connection/display status
'wifi.tcp', # Read-only app listener/traffic diagnostic
'dm.held', # Read-only pending-DM count
'flash.health', # Read-only flash health diagnostics
'key.backup.transport', # Identity-backup transport capability
+4
View File
@@ -66,6 +66,10 @@ class CompanionAccessPointOwnershipTest(unittest.TestCase):
self.run_fixture("start_wifi")
self.run_fixture("start_wifi", webconfig=False)
def test_failed_transport_registration_does_not_start_unserviced_socket(self):
self.run_fixture("registration")
self.run_fixture("registration", webconfig=False)
def test_deliberate_recovery_setup_handoff_remains_available(self):
self.run_fixture("setup_handoff")
self.run_fixture("setup_handoff", webconfig=False)
+123
View File
@@ -0,0 +1,123 @@
#!/usr/bin/env python3
"""Fault-inject the production Companion TCP listener, without a radio or PC probe."""
from pathlib import Path
import os
import shutil
import subprocess
import sys
import tempfile
import unittest
from test_replay_reset_integration import extract_braced
ROOT = Path(__file__).resolve().parents[1]
FIXTURE = ROOT / "test/fixtures/companion_wifi_listener/test.cpp"
MOCKS = ROOT / "test/fixtures/serial_wifi_sessions/mocks"
SANITIZERS = (
["-fsanitize=address,undefined", "-fno-sanitize-recover=all", "-fno-pie", "-no-pie"]
if sys.platform.startswith("linux") else []
)
SCENARIOS = (
"no listener attempt before station association and a real IP",
"healthy listener is not restarted by loop or repeated begin",
"failed socket creation is counted and retried without leaking",
"failed bind closes the retained SDK descriptor before retry",
"failed listen closes the retained SDK descriptor before retry",
"retry delay grows and caps at 30 seconds without a tight loop",
"retry deadline is correct across millis rollover",
"disable cancels automatic repair even after enable",
"end and background suspension cannot resurrect the listener",
"lost listener recovers without dropping a healthy client or its replies",
"station reconnect preserves requested listener and restarts service",
"station association alone with zero address is not ready",
"a ready setup AP supports TCP without station association",
"AP mode without an AP IP is not ready",
"single-client takeover retains existing session ownership guarantees",
"accepted sockets and valid command frames have separate diagnostics",
"invalid protocol frame records a rejection and never dispatches its tail",
"incomplete frame records timeout only at its bounded deadline",
"diagnostic reads cannot start listeners or consume client commands",
"begin without enable is bounded and cannot auto-retry while disabled",
"transmit diagnostics count only completely written framed packets",
"invalid port requests never start or automatically retry",
"short header read is distinguished from invalid protocol and timeout",
"short payload read is distinguished from invalid protocol and timeout",
"healthy address changes never restart a listener or displace its client",
"MultiSerial services unavailable transport so it can recover before dispatch",
"failed listener repair retains an accepted client and queued data",
"stale AP address never starts a listener while AP mode is disabled",
)
class CompanionWiFiListenerTests(unittest.TestCase):
def test_production_listener_faults(self):
compiler = os.environ.get("CXX") or shutil.which("g++") or shutil.which("clang++")
if compiler is None:
self.skipTest("a host C++17 compiler is required")
with tempfile.TemporaryDirectory(prefix="meshcore-wifi-listener-") as directory:
binary = Path(directory) / "wifi-listener.exe"
compiled = subprocess.run(
[compiler, "-std=c++17", "-Wall", "-Wextra", "-Werror",
*SANITIZERS, "-DESP32=1", f"-I{MOCKS}", f"-I{ROOT / 'src'}",
str(FIXTURE), str(ROOT / "src/helpers/wifi/SerialWifiInterface.cpp"),
"-o", str(binary)],
capture_output=True, text=True, timeout=60,
)
self.assertEqual(compiled.returncode, 0, compiled.stdout + compiled.stderr)
for scenario, description in enumerate(SCENARIOS):
with self.subTest(scenario=description):
checked = subprocess.run(
[str(binary), str(scenario)], capture_output=True,
text=True, timeout=10,
)
self.assertEqual(checked.returncode, 0, checked.stdout + checked.stderr)
self.assertIn(f"PASS: Wi-Fi listener scenario {scenario}", checked.stdout)
def test_production_cli_and_display_formatter_are_bounded_and_observable(self):
compiler = os.environ.get("CXX") or shutil.which("g++") or shutil.which("clang++")
if compiler is None:
self.skipTest("a host C++17 compiler is required")
main = (ROOT / "examples/companion_radio/main.cpp").read_text(encoding="utf-8")
methods = extract_braced(main, "void formatCompanionWiFiTcpStatus(")
methods += "\n" + extract_braced(main, "void formatCompanionWiFiDisplayStatus(")
fixture = (ROOT / "test/fixtures/companion_wifi_listener/diagnostics.cpp").read_text()
with tempfile.TemporaryDirectory(prefix="meshcore-wifi-diagnostics-") as directory:
work = Path(directory)
source = work / "diagnostics.cpp"
source.write_text(fixture.replace("@METHODS@", methods), encoding="utf-8")
binary = work / "diagnostics.exe"
compiled = subprocess.run(
[compiler, "-std=c++17", "-Wall", "-Wextra", "-Werror",
*SANITIZERS, "-DESP32=1", f"-I{MOCKS}", f"-I{ROOT / 'src'}",
str(source), str(ROOT / "src/helpers/wifi/SerialWifiInterface.cpp"),
"-o", str(binary)], capture_output=True, text=True, timeout=60,
)
self.assertEqual(compiled.returncode, 0, compiled.stdout + compiled.stderr)
checked = subprocess.run([str(binary)], capture_output=True, text=True, timeout=10)
self.assertEqual(checked.returncode, 0, checked.stdout + checked.stderr)
self.assertIn("PASS: production Wi-Fi diagnostic formatters", checked.stdout)
def test_cli_routes_and_registration_gate_use_real_listener(self):
main = (ROOT / "examples/companion_radio/main.cpp").read_text(encoding="utf-8")
mesh = (ROOT / "examples/companion_radio/MyMesh.cpp").read_text(encoding="utf-8")
command = extract_braced(mesh, 'if (strcmp(command, "get wifi.tcp") == 0)')
self.assertIn("formatCompanionWiFiTcpStatus(reply, reply_size);", command)
self.assertIn("return true;", command)
self.assertRegex(main, r"companion_wifi_interface_registered\s*=\s*"
r"interface_manager\.addInterface\(InterfaceType::WiFi")
for signature in ("static void startCompanionWiFi(",
"static void serviceCompanionWiFiBackgroundPower("):
method = extract_braced(main, signature)
gate = extract_braced(method, "if (companion_wifi_interface_registered)")
self.assertIn("wifi_interface.begin(TCP_PORT)", gate)
self.assertIn("wifi_interface.enable()", gate)
diagnostic = extract_braced(main, "void formatCompanionWiFiTcpStatus(")
self.assertNotRegex(diagnostic, r"(?:\.connect\(|WiFiClient\s+|server\.available)")
display = extract_braced(main, "void formatCompanionWiFiDisplayStatus(")
self.assertIn("wifi_interface.getStatus().listening", display)
if __name__ == "__main__":
unittest.main()
+13 -1
View File
@@ -47,8 +47,9 @@ struct Interface {
int ends = 0, begins = 0;
bool isConnected() const { return connected; }
void end() { enabled = false; ++ends; }
void begin(int) { ++begins; }
bool begin(int) { ++begins; return true; }
void enable() { enabled = true; }
bool isListening() const { return enabled && begins > ends; }
} wifi_interface;
struct ConsoleClient {
bool active = false;
@@ -71,6 +72,7 @@ void mesh::wifi::setStationAutoReconnect(bool value) { WiFi.setAutoReconnect(val
struct Tracker { void noteDisconnected(uint32_t) {} } wifi_reconnect_tracker;
bool companion_wifi_active = true, companion_wifi_requested = true;
bool companion_wifi_interface_registered = true;
bool companion_wifi_background_stopped = false;
bool companion_wifi_espnow_restore_pending = false;
uint32_t companion_wifi_espnow_restore_at = 0;
@@ -116,6 +118,7 @@ void reset() {
test_now = 10000;
board = {}; wifi_interface = {}; ota_console_client = {}; WiFi = {};
companion_wifi_active = companion_wifi_requested = true;
companion_wifi_interface_registered = true;
companion_wifi_background_stopped = false;
companion_wifi_espnow_restore_pending = false;
companion_wifi_espnow_restore_at = 0;
@@ -345,6 +348,15 @@ int main() {
assert(!companion_wifi_webconfig_start_pending);
mesh::wifi::networkPower().setManaged(false);
assert(companionWiFiAutomaticRecoveryAllowed());
// Recovery cannot publish a listener that no dispatcher registered.
reset();
companion_wifi_interface_registered = false;
mesh::wifi::networkPower().setSuspended(true);
serviceCompanionWiFiBackgroundPower();
mesh::wifi::networkPower().setSuspended(false);
serviceCompanionWiFiBackgroundPower();
assert(!companion_wifi_background_stopped && wifi_interface.begins == 0);
}
'''