Files
MeshCore/test/test_bridge_recovery.py
T
mikecarper 617aacba42 Fix packet, delivery, clock and radio stability regressions
Reject truncated anonymous reply paths and advert metadata before copying,
while preserving timestamp-only empty-password logins. Limit room posting to
read-write/admin ACL roles, retain inbox frames until the requesting transport
accepts them, and lock raw LittleFS traversal against concurrent writes.

Separate ISR event generations from main-loop radio state. Confirm RX/TX IRQs,
detach concrete wrapper callbacks safely, and discard inconsistent LR2021 FIFO
snapshots before rearming. Preserve bridge RX frames through packet-pool
exhaustion and bound ESP-NOW retries and missing-callback recovery. Screen RTC
register layouts without losing DS1307 startup, and ignore poisoned future
contact timestamps during clock bootstrap.

Keep the nRF52 loop stack at 8 KiB while reducing the OTA listing call chain
from 7,832 to 6,056 static bytes. Retain all target names through lossless Full
Companion compression and the canonical size optimizer. Preserve constrained
STM32 filesystems and bind corrected ESP32 UART/OLED budgets to source size
assertions. Document the separately measured preexisting W12 package limits.

Adapted for this branch from meshcore-dev/MeshCore PRs #3521, #3340, #3362,
#2062, #3503, #3038, #3534, #3544 and #3512.

Validation: 1,829 native tests; sanitized parser, inbox, LittleFS, ACL, clock,
RTC, IRQ/FIFO and bridge fault tests; 332 additional Companion cases; real
RAK4631 Full and both repeater profiles, G2 Full/standard, V3 Full and both
constrained STM32 release recipes. Radio-family compile coverage continues
separately; W12 full/portable package guards remain enforced.
2026-10-09 19:56:08 -07:00

272 lines
14 KiB
Python

"""Fault-inject real bridge sources: pool pressure, TX backoff and lost callbacks."""
from pathlib import Path
import os
import re
import subprocess
import tempfile
import unittest
from test_radio_receive_contract import method
ROOT = Path(__file__).resolve().parents[1]
MOCKS = r'''
#include <vector>
#include <algorithm>
#include <array>
#define MAX_TRANS_UNIT 255
using portMUX_TYPE=int;
#define portMUX_INITIALIZER_UNLOCKED 0
struct esp_now_recv_info_t {const uint8_t* src_addr;};
struct esp_now_send_info_t {const uint8_t* des_addr;};
constexpr int ESP_ERR_ESPNOW_NO_MEM=-77;
uint32_t now_ms=100;
uint32_t millis(){return now_ms;}
int send_result=0,send_calls=0;
std::vector<std::vector<uint8_t>> sent;
int esp_now_send(const uint8_t*,const uint8_t* bytes,size_t len){
assert(espnow_active);++send_calls;
if(send_result!=ESP_OK)return send_result;
sent.emplace_back(bytes,bytes+len);return ESP_OK;
}
namespace mesh {
struct RTCClock {};
struct Packet {
uint8_t data[MAX_TRANS_UNIT]={};uint16_t length=4;
bool readFrom(const uint8_t* bytes,size_t len){
if(len==0||len>sizeof(data)||bytes[0]==0xee)return false;
memcpy(data,bytes,len);length=len;return true;
}
int getRawLength()const{return length;}
uint16_t writeTo(uint8_t* out)const{memcpy(out,data,length);return length;}
bool violatesRoutePolicy()const{return false;}
};
struct PacketManager {
std::array<Packet,8> pool;std::array<bool,8> used{};
bool exhausted=false;unsigned frees=0,allocs=0;
std::vector<uint8_t> received;
Packet* allocNew(){
if(exhausted)return nullptr;
for(size_t i=0;i<used.size();++i)if(!used[i]){used[i]=true;++allocs;return &pool[i];}
return nullptr;
}
void free(Packet* p){size_t i=p-pool.data();assert(i<used.size()&&used[i]);used[i]=false;++frees;}
void queueInbound(Packet* p,uint32_t){received.push_back(p->data[0]);free(p);}
};
}
struct NodePrefs {
int bridge_format=mesh::bridge::ESPNOW_FORMAT_RAW;
uint8_t bridge_channel=6;uint32_t bridge_baud=115200,bridge_delay=1;
char bridge_secret[32]="fleet-test";
};
struct Seen {
std::vector<uint8_t> ids;
bool wasSeen(const mesh::Packet* p){return std::find(ids.begin(),ids.end(),p->data[0])!=ids.end();}
void markSeen(const mesh::Packet* p){if(!wasSeen(p))ids.push_back(p->data[0]);}
void clear(const mesh::Packet* p){ids.erase(std::remove(ids.begin(),ids.end(),p->data[0]),ids.end());}
};
class BridgeBase {
public:
static constexpr uint16_t BRIDGE_PACKET_MAGIC=0xc03e;
static constexpr uint16_t BRIDGE_MAGIC_SIZE=2,BRIDGE_LENGTH_SIZE=2,BRIDGE_CHECKSUM_SIZE=2;
NodePrefs* _prefs;mesh::PacketManager* _mgr;mesh::RTCClock* _rtc;
bool _initialized=false,allowed=true;Seen _seen_packets;
BridgeBase(NodePrefs* prefs,mesh::PacketManager* mgr,mesh::RTCClock* rtc):_prefs(prefs),_mgr(mgr),_rtc(rtc){}
virtual ~BridgeBase()=default;
virtual void begin()=0;virtual void end()=0;virtual void loop()=0;
virtual void sendPacket(mesh::Packet*)=0;virtual void onPacketReceived(mesh::Packet*)=0;
bool allowsPacket(const mesh::Packet*)const{return allowed;}
static uint16_t fletcher16(const uint8_t*,size_t);
bool validateChecksum(const uint8_t*,size_t,uint16_t);
void handleReceivedPacket(mesh::Packet*);
};
class Stream {
public:
std::vector<uint8_t> input,output;size_t position=0,write_limit=1000;unsigned reads=0;
int available(){return input.size()-position;}
int read(){++reads;return position<input.size()?input[position++]:-1;}
size_t write(const uint8_t* bytes,size_t length){
length=std::min(length,write_limit);output.insert(output.end(),bytes,bytes+length);return length;
}
};
class HardwareSerial:public Stream {
public:
bool setPins(int16_t,int16_t){return true;}
void begin(uint32_t){}void end(){}explicit operator bool()const{return true;}
};
'''
def code():
# Reuse the existing SDK/facade model, with its separate caches and shared
# infrastructure owner. Only hardware APIs and Packet allocation are mocked.
sdk = (ROOT / "test/fixtures/espnow_wifi_handoff.cpp").read_text().split("class Bridge {")[0]
sdk = sdk.replace("int esp_now_deinit() { assert(espnow_active); espnow_active=false; return ESP_OK; }",
"int esp_now_deinit() { assert(espnow_active); if(failure==18)return -1; espnow_active=false; return ESP_OK; }")
base = (ROOT / "src/helpers/bridges/BridgeBase.cpp").read_text()
base_methods = "\n".join(method(base, signature) for signature in (
"uint16_t BridgeBase::fletcher16(", "bool BridgeBase::validateChecksum(",
"void BridgeBase::handleReceivedPacket("))
headers, sources = [], []
for name in ("RS232Bridge", "ESPNowBridge"):
header = (ROOT / f"src/helpers/bridges/{name}.h").read_text()
source = (ROOT / f"src/helpers/bridges/{name}.cpp").read_text()
headers.append(re.sub(r"^\s*#(?:include|pragma).*?$", "", header, flags=re.MULTILINE).replace("private:", "public:"))
sources.append(re.sub(r"^\s*#include.*?$", "", source, flags=re.MULTILINE))
return sdk + MOCKS + "\n".join(headers) + base_methods + "\n".join(sources)
COMMON = r'''
static std::vector<uint8_t> uart_frame(uint8_t id){
uint8_t payload[4]={id,1,2,3};uint16_t sum=BridgeBase::fletcher16(payload,4);
return {0xc0,0x3e,0,4,id,1,2,3,uint8_t(sum>>8),uint8_t(sum)};
}
static void append(HardwareSerial& serial,const std::vector<uint8_t>& frame){
serial.input.insert(serial.input.end(),frame.begin(),frame.end());
}
static mesh::Packet packet(uint8_t id,size_t length=4){
mesh::Packet p;p.length=length;memset(p.data,id,sizeof(p.data));return p;
}
static void complete(ESPNowBridge& bridge,int status=ESP_NOW_SEND_SUCCESS){
const uint8_t mac[6]={255,255,255,255,255,255};
bridge.onDataSent(mac,static_cast<esp_now_send_status_t>(status));bridge.loop();
}
'''
class BridgeRecoveryTests(unittest.TestCase):
def run_fixture(self, checks, versions=(50200,)):
with tempfile.TemporaryDirectory(prefix="meshcore-bridge-recovery-") as tmp:
cpp, exe = Path(tmp) / "test.cpp", Path(tmp) / "test"
cpp.write_text(code() + COMMON + checks)
for version in versions:
with self.subTest(idf=version):
result = subprocess.run([
os.environ.get("CXX", "g++"), "-std=c++17", "-O1", "-Wall", "-Wextra",
"-fsanitize=address,undefined", "-fno-omit-frame-pointer", "-fno-pie", "-no-pie",
"-DESP32=1", "-DWITH_ESPNOW_BRIDGE=1", "-DWITH_RS232_BRIDGE=1",
f"-DESP_IDF_VERSION={version}", f"-DESP_IDF_VERSION_MAJOR={version//10000}",
"-I", str(ROOT / "src"), str(cpp), "-o", str(exe),
], capture_output=True, text=True)
self.assertEqual(result.returncode, 0, result.stderr)
result = subprocess.run([str(exe)], capture_output=True, text=True)
self.assertEqual(result.returncode, 0, result.stderr)
def test_uart_pool_pressure_order_parser_bounds_and_restart(self):
self.run_fixture(r'''
int main(){
NodePrefs prefs;mesh::PacketManager mgr;mesh::RTCClock rtc;HardwareSerial serial;
RS232Bridge bridge(&prefs,serial,1,2,&mgr,&rtc);bridge.begin();
append(serial,uart_frame(1));append(serial,uart_frame(2));mgr.exhausted=true;
bridge.loop();assert(bridge._rx_packet_ready&&serial.available()==10&&mgr.received.empty());
const auto read=serial.reads;bridge.loop();assert(serial.reads==read&&mgr.received.empty());
mgr.exhausted=false;bridge.loop();assert((mgr.received==std::vector<uint8_t>{1,2}));
append(serial,{0xc0,0x3e,0,0}); // empty length must resynchronize
append(serial,{0xc0,0x3e,1,1}); // oversized length must resynchronize
auto corrupt=uart_frame(3);corrupt.back()^=1;append(serial,corrupt);
auto invalid=uart_frame(0xee);append(serial,invalid);append(serial,uart_frame(4));
for(unsigned i=0;i<4;++i)bridge.loop();
assert((mgr.received==std::vector<uint8_t>{1,2,4}));
serial.input.insert(serial.input.end(),2000,0x00);const auto before=serial.reads;
bridge.loop();assert(serial.reads-before==512); // noisy UART has bounded loop work
serial.position=serial.input.size();append(serial,uart_frame(5));mgr.exhausted=true;
bridge.loop();assert(bridge._rx_packet_ready);bridge.end();mgr.exhausted=false;bridge.begin();
bridge.loop();assert((mgr.received==std::vector<uint8_t>{1,2,4})); // held frame cannot cross restart
auto outgoing=packet(6);serial.write_limit=2;bridge.sendPacket(&outgoing);
assert(!bridge._seen_packets.wasSeen(&outgoing)); // failed admission can retry
serial.write_limit=1000;bridge.sendPacket(&outgoing);assert(bridge._seen_packets.wasSeen(&outgoing));
bridge.allowed=false;auto blocked=packet(7);auto total=serial.output.size();
bridge.sendPacket(&blocked);assert(serial.output.size()==total);
bridge.allowed=true;serial.input.clear();serial.position=0;
for(uint8_t id=10;id<40;++id)append(serial,uart_frame(id));
bridge.loop();assert(serial.available()==0&&mgr.received.size()==33); // one bounded batch preserves throughput
}
''')
def test_espnow_rx_pool_pressure_reassembly_and_filter_ownership(self):
self.run_fixture(r'''
int main(){
Backend backend;backend.wifi=true;mesh::wireless::control().begin(backend);
sdk_initialized=sdk_started=true;sdk_mode=WIFI_STA;
NodePrefs prefs;mesh::PacketManager mgr;mesh::RTCClock rtc;ESPNowBridge bridge(&prefs,&mgr,&rtc);bridge.begin();
const uint8_t mac[6]={1,2,3,4,5,6};auto p=packet(1);
bridge.queueReceivedFrame(mac,p.data,p.length);mgr.exhausted=true;bridge.loop();
assert(bridge._rx_count==1&&mgr.received.empty());
mgr.exhausted=false;bridge.loop();assert((mgr.received==std::vector<uint8_t>{1}));
mesh::espnow::ESPNowRawFrames fragments;auto full=packet(2,255);
assert(mesh::espnow::encodeEspNowRawFrames(full.data,full.length,fragments));
bridge.queueReceivedFrame(mac,fragments.data[0],fragments.lengths[0]);bridge.loop();
bridge.queueReceivedFrame(mac,fragments.data[1],fragments.lengths[1]);mgr.exhausted=true;
bridge.loop();assert(bridge._rx_count==1&&mgr.received.size()==1);
mgr.exhausted=false;bridge.loop();assert((mgr.received==std::vector<uint8_t>{1,2}));
auto blocked=packet(3);bridge.allowed=false;bridge.queueReceivedFrame(mac,blocked.data,blocked.length);
bridge.loop();assert(mgr.received.size()==2);bridge.allowed=true;
auto bad=packet(0xee);bridge.queueReceivedFrame(mac,bad.data,bad.length);bridge.loop();
assert(mgr.received.size()==2&&mgr.allocs==mgr.frees);
bridge.end();prefs.bridge_format=mesh::bridge::ESPNOW_FORMAT_WRAPPED;bridge.begin();
auto wrapped=packet(4);uint8_t bytes[8]={0xc0,0x3e};uint16_t sum=BridgeBase::fletcher16(wrapped.data,4);
bytes[2]=sum>>8;bytes[3]=sum;memcpy(bytes+4,wrapped.data,4);assert(bridge.xorCrypt(bytes+2,6));
bridge.queueReceivedFrame(mac,bytes,sizeof(bytes));mgr.exhausted=true;bridge.loop();
assert(bridge._rx_count==1);mgr.exhausted=false;bridge.loop();
assert((mgr.received==std::vector<uint8_t>{1,2,4}));
bridge.end();assert(mgr.allocs==mgr.frees&&sdk_started); // shared WiFi survives
}
''')
def test_espnow_start_retry_budget_wrap_and_fragment_order(self):
self.run_fixture(r'''
int main(){
Backend backend;backend.wifi=true;mesh::wireless::control().begin(backend);
sdk_initialized=sdk_started=true;sdk_mode=WIFI_STA;
NodePrefs prefs;mesh::PacketManager mgr;mesh::RTCClock rtc;ESPNowBridge bridge(&prefs,&mgr,&rtc);bridge.begin();
auto p=packet(1,255);bridge.sendPacket(&p);send_result=ESP_ERR_ESPNOW_NO_MEM;
now_ms=UINT32_MAX-19;bridge.loop();assert(send_calls==1&&bridge._tx_count==1);
for(unsigned i=0;i<3;++i){now_ms+=19;bridge.loop();assert(send_calls==int(i+1));++now_ms;bridge.loop();}
assert(send_calls==4&&bridge._tx_count==0&&!bridge._seen_packets.wasSeen(&p));
send_result=ESP_OK;bridge.sendPacket(&p);bridge.loop();assert(sent.size()==1);
complete(bridge);assert(sent.size()==2&&bridge._tx_count==1);complete(bridge);assert(bridge._tx_count==0);
mesh::espnow::ESPNowRawReassembler assembler;uint8_t out[255],mac[6]={};size_t size=0;
assembler.acceptFrame(mac,sent[0].data(),sent[0].size(),now_ms,out,sizeof(out),size);
assert(assembler.acceptFrame(mac,sent[1].data(),sent[1].size(),now_ms,out,sizeof(out),size)==mesh::espnow::ESPNowRawReassemblyResult::PACKET_COMPLETE);
assert(size==255&&!memcmp(out,p.data,size));
auto fail=packet(2,255);bridge.sendPacket(&fail);bridge.loop();const size_t prior=sent.size();
for(unsigned i=0;i<3;++i){
complete(bridge,ESP_NOW_SEND_FAIL);assert(sent.size()==prior+i&&bridge._tx_count==1);
now_ms+=19;bridge.loop();assert(sent.size()==prior+i);
++now_ms;bridge.loop();assert(sent.size()==prior+i+1);
}
complete(bridge,ESP_NOW_SEND_FAIL);assert(bridge._tx_count==0); // bounded budget, no orphan sibling
for(size_t i=prior-1;i<sent.size();++i)assert(sent[i]==sent[prior-1]); // retries are part0 only
auto two=packet(3,255);bridge.sendPacket(&two);bridge.loop();send_result=ESP_ERR_ESPNOW_NO_MEM;
complete(bridge);assert(bridge._tx_count==1&&bridge._tx_queue[bridge._tx_tail].next_frame==1);
send_result=ESP_OK;now_ms+=20;bridge.loop();complete(bridge);assert(bridge._tx_count==0);
bridge.end();
}
''', (40400, 50200, 50500))
def test_missing_callback_restarts_session_and_failed_teardown_blocks_admission(self):
self.run_fixture(r'''
int main(){
Backend backend;backend.wifi=true;mesh::wireless::control().begin(backend);
sdk_initialized=sdk_started=true;sdk_mode=WIFI_STA;
NodePrefs prefs;mesh::PacketManager mgr;mesh::RTCClock rtc;ESPNowBridge bridge(&prefs,&mgr,&rtc);bridge.begin();
auto p=packet(1,255),waiting=packet(2);bridge.sendPacket(&p);bridge.sendPacket(&waiting);bridge.loop();
now_ms+=999;bridge.loop();assert(send_calls==1&&bridge._tx_count==2);
++now_ms;bridge.loop();assert(bridge._initialized&&bridge._tx_count==0&&send_calls==1);
assert(!bridge._seen_packets.wasSeen(&waiting)&&sdk_started); // untouched WiFi, unsent can retry
complete(bridge);assert(send_calls==1); // callback arriving before a new send cannot fake progress
bridge.sendPacket(&waiting);bridge.loop();complete(bridge);assert(bridge._tx_count==0);
auto bad=packet(3,255);bridge.sendPacket(&bad);bridge.loop();failure=18;now_ms+=1000;bridge.loop();
assert(!bridge._initialized&&bridge._sdk_teardown_failed&&espnow_active);
const int started=send_calls;bridge.sendPacket(&p);bridge.loop();complete(bridge);
bridge.begin();assert(!bridge._initialized&&send_calls==started); // old driver still owns accepted TX
failure=0;bridge.begin();assert(bridge._initialized&&!bridge._sdk_teardown_failed);
auto good=packet(4);bridge.sendPacket(&good);bridge.loop();complete(bridge);
assert(bridge._tx_count==0&&send_calls==started+1);bridge.end();
}
''')
if __name__ == "__main__":
unittest.main()