243 lines
8.7 KiB
C++
243 lines
8.7 KiB
C++
#include <helpers/bridges/ESPNowBridgeDiagnostics.h>
|
|
#include <Packet.h>
|
|
|
|
#include <cassert>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <initializer_list>
|
|
#include <type_traits>
|
|
|
|
namespace diag = mesh::bridge::diag;
|
|
|
|
static diag::Probe sentinel() {
|
|
return {0x76543210U, 0, 6};
|
|
}
|
|
|
|
static void unchanged(const diag::Probe& value) {
|
|
assert(value.nonce == 0x76543210U && value.format == 0 && value.channel == 6);
|
|
}
|
|
|
|
static void makeProbe(uint8_t* bytes) {
|
|
assert(diag::encodeProbe(bytes, diag::ProbeSize, {0x01234567U, 1, 13}));
|
|
}
|
|
|
|
static void checksum(uint8_t* bytes) {
|
|
mesh::espnow::writeEspNowRawUint32(
|
|
bytes + 12, mesh::espnow::espNowRawCrc32(bytes, 12));
|
|
}
|
|
|
|
static void roundtrip() {
|
|
const uint32_t nonces[] = {0, 1, 0x80000000U, UINT32_MAX, 0x01234567U};
|
|
for (uint8_t format = 0; format <= 1; ++format) {
|
|
for (uint8_t channel = 1; channel <= 13; ++channel) {
|
|
for (uint32_t nonce : nonces) {
|
|
uint8_t bytes[18];
|
|
memset(bytes, 0xA5, sizeof(bytes));
|
|
assert(diag::encodeProbe(bytes + 1, 16, {nonce, format, channel}));
|
|
assert(bytes[0] == 0xA5 && bytes[17] == 0xA5);
|
|
diag::Probe parsed = sentinel();
|
|
assert(diag::isProbeCandidate(bytes + 1, 16));
|
|
assert(diag::decodeProbe(bytes + 1, 16, parsed));
|
|
assert(parsed.nonce == nonce && parsed.format == format
|
|
&& parsed.channel == channel);
|
|
}
|
|
}
|
|
}
|
|
uint8_t bytes[diag::ProbeSize];
|
|
makeProbe(bytes);
|
|
for (uint8_t byte : bytes) printf("%02X", byte);
|
|
puts("");
|
|
}
|
|
|
|
static void bounds() {
|
|
uint8_t bytes[250];
|
|
memset(bytes, 0xA5, sizeof(bytes));
|
|
makeProbe(bytes);
|
|
for (size_t length = 0; length <= sizeof(bytes); ++length) {
|
|
if (length == diag::ProbeSize) continue;
|
|
diag::Probe parsed = sentinel();
|
|
assert(!diag::decodeProbe(bytes, length, parsed));
|
|
unchanged(parsed);
|
|
}
|
|
diag::Probe parsed = sentinel();
|
|
assert(!diag::decodeProbe(nullptr, diag::ProbeSize, parsed));
|
|
unchanged(parsed);
|
|
assert(!diag::isProbeCandidate(nullptr, diag::ProbeSize));
|
|
for (size_t length = 0; length < diag::ProbeSize; ++length) {
|
|
memset(bytes, 0xA5, sizeof(bytes));
|
|
assert(!diag::encodeProbe(bytes, length, {1, 1, 1}));
|
|
for (uint8_t byte : bytes) assert(byte == 0xA5);
|
|
}
|
|
assert(!diag::encodeProbe(nullptr, diag::ProbeSize, {1, 1, 1}));
|
|
}
|
|
|
|
static void metadata() {
|
|
const uint8_t invalid_formats[] = {2, 127, 255};
|
|
const uint8_t invalid_channels[] = {0, 14, 127, 255};
|
|
for (uint8_t format : invalid_formats) {
|
|
uint8_t bytes[16];
|
|
memset(bytes, 0xA5, sizeof(bytes));
|
|
assert(!diag::encodeProbe(bytes, sizeof(bytes), {0, format, 6}));
|
|
for (uint8_t byte : bytes) assert(byte == 0xA5);
|
|
makeProbe(bytes);
|
|
bytes[6] = format;
|
|
checksum(bytes);
|
|
diag::Probe parsed = sentinel();
|
|
assert(!diag::decodeProbe(bytes, sizeof(bytes), parsed));
|
|
unchanged(parsed);
|
|
}
|
|
for (uint8_t channel : invalid_channels) {
|
|
uint8_t bytes[16];
|
|
memset(bytes, 0xA5, sizeof(bytes));
|
|
assert(!diag::encodeProbe(bytes, sizeof(bytes), {0, 0, channel}));
|
|
for (uint8_t byte : bytes) assert(byte == 0xA5);
|
|
makeProbe(bytes);
|
|
bytes[7] = channel;
|
|
checksum(bytes);
|
|
diag::Probe parsed = sentinel();
|
|
assert(!diag::decodeProbe(bytes, sizeof(bytes), parsed));
|
|
unchanged(parsed);
|
|
}
|
|
for (size_t field : {size_t(4), size_t(5)}) {
|
|
for (uint8_t value : {uint8_t(0), uint8_t(2), uint8_t(255)}) {
|
|
uint8_t bytes[16];
|
|
makeProbe(bytes);
|
|
bytes[field] = value;
|
|
checksum(bytes);
|
|
diag::Probe parsed = sentinel();
|
|
assert(diag::isProbeCandidate(bytes, sizeof(bytes)));
|
|
assert(!diag::decodeProbe(bytes, sizeof(bytes), parsed));
|
|
unchanged(parsed);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void corruption() {
|
|
uint8_t original[16];
|
|
makeProbe(original);
|
|
for (size_t byte = 0; byte < sizeof(original); ++byte) {
|
|
for (uint8_t bit = 0; bit < 8; ++bit) {
|
|
uint8_t bytes[16];
|
|
memcpy(bytes, original, sizeof(bytes));
|
|
bytes[byte] ^= uint8_t(1U << bit);
|
|
diag::Probe parsed = sentinel();
|
|
assert(!diag::decodeProbe(bytes, sizeof(bytes), parsed));
|
|
unchanged(parsed);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void candidate() {
|
|
uint8_t bytes[250];
|
|
memset(bytes, 0, sizeof(bytes));
|
|
makeProbe(bytes);
|
|
for (size_t length = 0; length < 4; ++length) {
|
|
assert(!diag::isProbeCandidate(bytes, length));
|
|
}
|
|
for (size_t length = 4; length <= sizeof(bytes); ++length) {
|
|
assert(diag::isProbeCandidate(bytes, length));
|
|
}
|
|
bytes[3] = 'F';
|
|
assert(!diag::isProbeCandidate(bytes, 16));
|
|
assert(memcmp(bytes, mesh::espnow::ESPNOW_RAW_FRAGMENT_MAGIC, 4) == 0);
|
|
}
|
|
|
|
static void nonce() {
|
|
struct Valid { const char* text; uint32_t expected; };
|
|
for (const Valid& valid : {Valid{"00000000", 0}, Valid{"00000001", 1},
|
|
Valid{"ffffffff", UINT32_MAX}, Valid{"ABCDef01", 0xABCDEF01U},
|
|
Valid{"01234567", 0x01234567U}}) {
|
|
uint32_t value = 7;
|
|
assert(diag::parseNonce(valid.text, value) && value == valid.expected);
|
|
}
|
|
const char* invalid[] = {nullptr, "", "0", "1234567", "123456789",
|
|
"0x123456", " 1234567", "1234567 ", "+1234567", "-1234567",
|
|
"1234567g", "12345678x", "12345678\n", "1234 678", "\t1234567"};
|
|
for (const char* text : invalid) {
|
|
uint32_t value = 0x89ABCDEFU;
|
|
assert(!diag::parseNonce(text, value) && value == 0x89ABCDEFU);
|
|
}
|
|
}
|
|
|
|
static void legacy() {
|
|
// These are actual production Packet and raw reassembler implementations.
|
|
uint8_t probe[16];
|
|
makeProbe(probe);
|
|
mesh::Packet parsed;
|
|
assert(!parsed.readFrom(probe, sizeof(probe)));
|
|
assert((probe[0] >> PH_VER_SHIFT) > PAYLOAD_VER_1);
|
|
assert((uint16_t(probe[0]) << 8 | probe[1]) != WRAPPED_BRIDGE_MAGIC);
|
|
mesh::espnow::ESPNowRawReassemblerT<1> raw;
|
|
uint8_t output[255];
|
|
uint8_t source[] = {1, 2, 3, 4, 5, 6};
|
|
size_t output_len = 999;
|
|
assert(raw.acceptFrame(source, probe, sizeof(probe), 0, output,
|
|
sizeof(output), output_len)
|
|
== mesh::espnow::ESPNowRawReassemblyResult::REJECTED);
|
|
assert(output_len == 0);
|
|
|
|
// Rejecting a probe must not disturb a real in-progress raw packet.
|
|
mesh::Packet packet;
|
|
packet.header = (PAYLOAD_TYPE_RAW_CUSTOM << PH_TYPE_SHIFT)
|
|
| ROUTE_TYPE_TRANSPORT_DIRECT;
|
|
packet.setPathHashSizeAndCount(2, 32);
|
|
packet.payload_len = MAX_PACKET_PAYLOAD;
|
|
memset(packet.path, 0x23, sizeof(packet.path));
|
|
memset(packet.payload, 0x42, sizeof(packet.payload));
|
|
uint8_t wire[255];
|
|
const size_t wire_len = packet.writeTo(wire);
|
|
assert(wire_len == 254);
|
|
mesh::espnow::ESPNowRawFrames frames;
|
|
assert(mesh::espnow::encodeEspNowRawFrames(wire, wire_len, frames));
|
|
assert(frames.count == 2);
|
|
assert(raw.acceptFrame(source, frames.data[0], frames.lengths[0], 1,
|
|
output, sizeof(output), output_len)
|
|
== mesh::espnow::ESPNowRawReassemblyResult::FRAGMENT_STORED);
|
|
assert(raw.acceptFrame(source, probe, sizeof(probe), 2,
|
|
output, sizeof(output), output_len)
|
|
== mesh::espnow::ESPNowRawReassemblyResult::REJECTED);
|
|
assert(!diag::isProbeCandidate(frames.data[1], frames.lengths[1]));
|
|
assert(raw.acceptFrame(source, frames.data[1], frames.lengths[1], 3,
|
|
output, sizeof(output), output_len)
|
|
== mesh::espnow::ESPNowRawReassemblyResult::PACKET_COMPLETE);
|
|
assert(output_len == wire_len && memcmp(output, wire, wire_len) == 0);
|
|
assert(parsed.readFrom(output, static_cast<uint8_t>(output_len)));
|
|
}
|
|
|
|
static void counters() {
|
|
static_assert(std::is_trivially_copyable<diag::Stats>::value,
|
|
"Snapshots must copy without heap ownership");
|
|
static_assert(sizeof(diag::Stats) <= 160, "Counter storage is bounded");
|
|
diag::Stats stats;
|
|
assert(stats.rx.frames == 0 && stats.tx.requested == 0
|
|
&& stats.probe.rx_ok == 0 && stats.error.stage == diag::Stage::None);
|
|
uint32_t count = UINT32_MAX - 1;
|
|
diag::increment(count);
|
|
assert(count == UINT32_MAX);
|
|
diag::increment(count);
|
|
assert(count == UINT32_MAX);
|
|
count = 0;
|
|
diag::increment(count);
|
|
assert(count == 1);
|
|
for (uint8_t stage = 0; stage <= static_cast<uint8_t>(diag::Stage::TestQueue);
|
|
++stage) {
|
|
assert(strcmp(diag::stageName(static_cast<diag::Stage>(stage)), "unknown") != 0);
|
|
}
|
|
assert(strcmp(diag::stageName(static_cast<diag::Stage>(255)), "unknown") == 0);
|
|
printf("counter_bytes=%zu\n", sizeof(stats));
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
assert(argc == 2);
|
|
if (!strcmp(argv[1], "roundtrip")) roundtrip();
|
|
else if (!strcmp(argv[1], "bounds")) bounds();
|
|
else if (!strcmp(argv[1], "metadata")) metadata();
|
|
else if (!strcmp(argv[1], "corruption")) corruption();
|
|
else if (!strcmp(argv[1], "candidate")) candidate();
|
|
else if (!strcmp(argv[1], "nonce")) nonce();
|
|
else if (!strcmp(argv[1], "legacy")) legacy();
|
|
else if (!strcmp(argv[1], "counters")) counters();
|
|
else assert(false);
|
|
return 0;
|
|
}
|