shade/wadamesh
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 9 Wiki Activity
Files
2e2cccc5efec7089c0d88cc4cb37e3584c84e2cc
wadamesh/web/mesh/WebMesh.cpp
T

1155 lines
51 KiB
C++
Raw Blame History

// SPDX-License-Identifier: GPL-3.0-or-later
// The MyMesh stand-in (see WebMesh.h). The table semantics below mirror BaseChatMesh /
// src/MyMesh.h one for one (same return values, same UI callbacks in the same order),
// so the UI cannot tell this mirror from a device's. Network work goes to the backend.
#include "WebMesh.h"
#include <SPIFFS.h>
#include <Utils.h>
#include <helpers/TxtDataHelpers.h>
#include "helpers/esp32/TouchPrefsStore.h"
#include <ArduinoJson.h>
#include <math.h>
namespace {
const char* k_prefs_path = "/web_node_prefs"; // NodePrefs blob (versioned by size)
// The UI's own position (Profile / Settings > GPS, or this computer's last fix): two
// doubles. The device keeps it next to its prefs (DataStore::savePrefs); without this
// a typed position was gone after every reload.
const char* k_pos_path = "/web_node_pos";
int b64val(char c) {
if (c >= 'A' && c <= 'Z') return c - 'A';
if (c >= 'a' && c <= 'z') return c - 'a' + 26;
if (c >= '0' && c <= '9') return c - '0' + 52;
if (c == '+' || c == '-') return 62;
if (c == '/' || c == '_') return 63;
return -1;
}
int b64decode(const char* in, uint8_t* out, int cap) {
int n = 0, bits = 0; uint32_t acc = 0;
for (; *in; ++in) {
int v = b64val(*in);
if (v < 0) continue;
acc = (acc << 6) | (uint32_t)v; bits += 6;
if (bits >= 8) { bits -= 8; if (n < cap) out[n] = (uint8_t)(acc >> bits); n++; }
}
return n;
}
// The channel hash as BaseChatMesh::setChannel derives it (128- or 256-bit key).
void channelHash(ChannelDetails& cd) {
static const uint8_t zeroes[16] = {0};
const int klen = memcmp(&cd.channel.secret[16], zeroes, 16) == 0 ? 16 : 32;
mesh::Utils::sha256(cd.channel.hash, sizeof(cd.channel.hash), cd.channel.secret, klen);
}
void (*s_terminal_sink)(const char*) = nullptr;
// The device's "repeats heard" fingerprint (src/MyMesh.cpp fnv1a32): FNV-1a over a
// flood's payload, which repeaters leave unchanged.
uint32_t fnv1a32(const uint8_t* d, int n) {
uint32_t h = 2166136261u;
for (int i = 0; i < n; i++) { h ^= d[i]; h *= 16777619u; }
return h ? h : 1;
}
bool isMsgFloodType(uint8_t t) { return t == PAYLOAD_TYPE_TXT_MSG || t == PAYLOAD_TYPE_GRP_TXT; }
// Where a raw packet's path and payload start (header, optional transport codes, the
// packed path-length byte: low 6 bits hop count, top 2 bits hash size - 1).
struct RawView {
uint8_t ptype = 0, route = 0, hops = 0, hash_sz = 1;
int path_off = 0, payload_off = 0;
bool ok = false;
};
RawView rawView(const uint8_t* raw, size_t len) {
RawView v;
if (!raw || len < 2) return v;
v.route = raw[0] & 0x03;
v.ptype = (raw[0] >> 2) & 0x0F;
const bool xp = (v.route == ROUTE_TYPE_TRANSPORT_FLOOD || v.route == ROUTE_TYPE_TRANSPORT_DIRECT);
const int ps = 1 + (xp ? 4 : 0);
if ((size_t)ps >= len) return v;
const uint8_t plb = raw[ps];
v.hops = plb & 0x3F;
v.hash_sz = (uint8_t)(((plb >> 6) & 0x03) + 1);
v.path_off = ps + 1;
v.payload_off = v.path_off + (int)v.hops * (int)v.hash_sz;
v.ok = (size_t)v.payload_off <= len;
return v;
}
} // namespace
MyMesh::MyMesh(mesh::RTCClock& rtc, AbstractUITask* ui) : _rtc(&rtc), _ui(ui) {
memset(_contacts, 0, sizeof _contacts);
memset(_channels, 0, sizeof _channels);
memset(_heard, 0, sizeof _heard);
}
void MyMesh::loadPrefs() {
// Defaults: src/MyMesh.cpp's constructor values.
_prefs = NodePrefs{};
_prefs.airtime_factor = 1.0f;
StrHelper::strncpy(_prefs.node_name, "wadamesh web", sizeof(_prefs.node_name));
_prefs.freq = LORA_FREQ;
_prefs.sf = LORA_SF;
_prefs.bw = LORA_BW;
_prefs.cr = LORA_CR;
_prefs.tx_power_dbm = LORA_TX_POWER;
_prefs.rx_boosted_gain = 1;
_prefs.autoadd_max_hops = 64;
File f = SPIFFS.open(k_prefs_path, "r");
if (f) {
NodePrefs p{};
if (f.size() == sizeof p && f.read((uint8_t*)&p, sizeof p) == (int)sizeof p) _prefs = p;
f.close();
}
}
bool MyMesh::savePrefs() {
File f = SPIFFS.open(k_prefs_path, "w");
bool ok = false;
if (f) { ok = f.write((const uint8_t*)&_prefs, sizeof _prefs) == sizeof _prefs; f.close(); }
File pf = SPIFFS.open(k_pos_path, "w");
if (pf) {
const double pos[2] = {sensors.node_lat, sensors.node_lon};
if (pf.write((const uint8_t*)pos, sizeof pos) != sizeof pos) ok = false;
pf.close();
}
if (_backend) _backend->prefsChanged(_prefs);
return ok;
}
void MyMesh::begin(MeshBackend* backend) {
_backend = backend;
loadPrefs();
File pf = SPIFFS.open(k_pos_path, "r");
if (pf) {
double pos[2] = {0, 0};
if (pf.size() == sizeof pos && pf.read((uint8_t*)pos, sizeof pos) == (int)sizeof pos) {
sensors.node_lat = pos[0];
sensors.node_lon = pos[1];
_have_own_pos = pos[0] != 0.0 || pos[1] != 0.0;
}
pf.close();
}
_region_reg.begin(&SPIFFS);
// Identity: whatever the backend says this node is (a companion reports its key;
// the demo derives a fixed one), kept in a LocalIdentity like the device does.
uint8_t pub[PUB_KEY_SIZE] = {0};
NodePrefs from_backend = _prefs;
if (_backend) _backend->begin(*this, from_backend, pub);
// A node name the user set here wins over the backend's default.
File f = SPIFFS.open(k_prefs_path, "r");
const bool have_saved = (bool)f;
if (f) f.close();
if (!have_saved) _prefs = from_backend;
memcpy(self_id.pub_key, pub, PUB_KEY_SIZE);
Serial.printf("[web] mesh backend: %s, %d contacts\n", _backend ? _backend->name() : "none", _num_contacts);
// (A companion backend reports the node's identity and settings once its link is
// up: beSelfInfo, which overrides the placeholders above.)
}
void MyMesh::loop() {
const uint32_t now = millis();
if (_backend) _backend->loop(now);
if (now - _pos_sync_ms >= 5000) { _pos_sync_ms = now; syncAdvertPosition(now); }
}
// ---- this computer's position and the node (WEB_BUILD.md "Location") --------------------
// The device's advertPosition() (src/MyMesh.cpp, #399), unchanged: the Location privacy
// radius moves the ADVERTISED point by a fixed offset derived from the node key and the
// radius; the local map keeps the real one.
static void advertDisplace(const uint8_t pub_key[PUB_KEY_SIZE], double& lat, double& lon) {
const uint16_t r = touchPrefsGetGpsFuzzM();
if (r == 0 || (lat == 0 && lon == 0)) return;
uint32_t h = 2166136261u;
for (int i = 0; i < PUB_KEY_SIZE; ++i) { h ^= pub_key[i]; h *= 16777619u; }
h ^= (uint32_t)r; h *= 16777619u;
h ^= (uint32_t)(r >> 8); h *= 16777619u;
const double bearing = ((double)(h & 0xFFFFu) / 65536.0) * 2.0 * 3.14159265358979;
const double dist = (0.5 + ((double)((h >> 16) & 0xFFFFu) / 131072.0)) * (double)r;
const double dlat = (dist * cos(bearing)) / 111320.0;
double coslat = cos(lat * 3.14159265358979 / 180.0);
if (coslat < 0.01) coslat = 0.01;
const double dlon = (dist * sin(bearing)) / (111320.0 * coslat);
lat += dlat;
lon += dlon;
}
// A device advertises sensors.node_lat/lon (its GPS fix, or the Profile position) only
// while advert_loc_policy is ADVERT_LOC_SHARE. Here the advert is the node's, so the
// same rule decides whether the position the UI holds is handed to the node at all:
// * share off: it stays in this browser (map, distances, Lua); nothing is sent
// * share on, and the UI's position differs from the node's (this computer's GPS, a
// Profile edit): CMD_SET_ADVERT_LATLON with the Location privacy displacement,
// at most every 2 minutes (the device's own persist rate), the first one at once
// The demo has no node to tell (ownsPrefs() is false), and a read-only link refuses it.
void MyMesh::syncAdvertPosition(uint32_t now_ms) {
if (!_backend || !_backend->ownsPrefs()) return;
if (_prefs.advert_loc_policy != ADVERT_LOC_SHARE) return; // the privacy rule
const double la = sensors.node_lat, lo = sensors.node_lon;
if (la == 0.0 && lo == 0.0) return;
if (fabs(la - _node_pos_lat) < 1e-4 && fabs(lo - _node_pos_lon) < 1e-4) return; // ~11 m
if (_pos_pushed_ms && now_ms - _pos_pushed_ms < 120000) return;
double alat = la, alon = lo;
advertDisplace(self_id.pub_key, alat, alon);
_backend->advertPositionChanged((int32_t)llround(alat * 1.0e6), (int32_t)llround(alon * 1.0e6));
_node_pos_lat = la;
_node_pos_lon = lo;
_pos_pushed_ms = now_ms ? now_ms : 1;
}
void MyMesh::beSelfPosition(int32_t lat_e6, int32_t lon_e6) {
sensors.node_lat = (double)lat_e6 / 1.0e6;
sensors.node_lon = (double)lon_e6 / 1.0e6;
if (_ui) _ui->onThreadsChanged();
}
bool MyMesh::setBLEPin(uint32_t pin) {
if (!_backend || !_backend->setBlePin(pin)) return false;
_prefs.ble_pin = pin;
return true;
}
void MyMesh::applyRadioFromPrefs() {
if (_backend) _backend->prefsChanged(_prefs);
}
// ---- contacts -------------------------------------------------------------------------
bool MyMesh::getContactByIdx(uint32_t idx, ContactInfo& contact) {
if (idx >= (uint32_t)_num_contacts) return false;
contact = _contacts[idx];
return true;
}
ContactInfo* MyMesh::lookupContactByPubKey(const uint8_t* pub_key, int prefix_len) {
if (!pub_key || prefix_len <= 0) return nullptr;
for (int i = 0; i < _num_contacts; i++)
if (memcmp(_contacts[i].id.pub_key, pub_key, prefix_len) == 0) return &_contacts[i];
return nullptr;
}
bool MyMesh::addContact(const ContactInfo& contact) {
if (_num_contacts >= MAX_CONTACTS) return false;
_contacts[_num_contacts] = contact;
_contacts[_num_contacts].shared_secret_valid = false;
_num_contacts++;
return true;
}
void MyMesh::resetPathTo(ContactInfo& recipient) { recipient.out_path_len = OUT_PATH_UNKNOWN; }
int MyMesh::uiContactIdxByPubKey(const uint8_t pub_key[32]) {
for (int i = 0; i < _num_contacts; i++)
if (memcmp(_contacts[i].id.pub_key, pub_key, PUB_KEY_SIZE) == 0) return i;
return -1;
}
bool MyMesh::uiResetContactPath(const uint8_t pub_key[32]) {
ContactInfo* slot = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
if (!slot) return false;
slot->out_path_len = OUT_PATH_UNKNOWN;
memset(slot->out_path, 0, sizeof(slot->out_path));
if (_backend) _backend->contactPathReset(pub_key);
return true;
}
bool MyMesh::uiShareContact(const uint8_t pub_key[32]) {
if (!_backend || !lookupContactByPubKey(pub_key, PUB_KEY_SIZE)) return false;
return _backend->shareContact(pub_key);
}
bool MyMesh::uiSetContactGps(const uint8_t pub_key[32], int32_t lat_e6, int32_t lon_e6) {
ContactInfo* slot = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
if (!slot) return false;
slot->gps_lat = lat_e6;
slot->gps_lon = lon_e6;
slot->lastmod = getRTCClock()->getCurrentTime();
if (_backend) _backend->contactChanged(*slot);
return true;
}
bool MyMesh::uiAddManualContact(const uint8_t pub_key[32], const char* name) {
if (!name || !name[0]) return false;
if (lookupContactByPubKey(pub_key, PUB_KEY_SIZE) != nullptr) return false;
ContactInfo ci{};
memcpy(ci.id.pub_key, pub_key, PUB_KEY_SIZE);
ci.type = ADV_TYPE_CHAT;
ci.out_path_len = OUT_PATH_UNKNOWN;
ci.lastmod = getRTCClock()->getCurrentTime();
StrHelper::strncpy(ci.name, name, sizeof(ci.name));
if (!addContact(ci)) return false;
if (_backend) _backend->contactChanged(ci);
if (_ui) _ui->onThreadsChanged();
return true;
}
bool MyMesh::uiAddDiscoveredContact(const uint8_t pub_key[32], uint8_t type, const char* name) {
if (!name || !name[0]) return false;
if (lookupContactByPubKey(pub_key, PUB_KEY_SIZE) != nullptr) return false;
ContactInfo ci{};
memcpy(ci.id.pub_key, pub_key, PUB_KEY_SIZE);
ci.type = type;
ci.out_path_len = OUT_PATH_UNKNOWN;
ci.lastmod = getRTCClock()->getCurrentTime();
StrHelper::strncpy(ci.name, name, sizeof(ci.name));
if (!addContact(ci)) return false;
if (_backend) _backend->contactChanged(ci);
if (_ui) _ui->onThreadsChanged();
return true;
}
static uint8_t contactTelemBit(uint8_t telem_perm) { return (uint8_t)(telem_perm << 1); }
bool MyMesh::uiGetContactTelemetryPerm(const uint8_t pub_key[32], uint8_t telem_perm) {
ContactInfo* slot = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
return slot && (slot->flags & contactTelemBit(telem_perm)) != 0;
}
bool MyMesh::uiSetContactTelemetryPerm(const uint8_t pub_key[32], uint8_t telem_perm, bool on) {
ContactInfo* slot = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
if (!slot) return false;
const uint8_t bit = contactTelemBit(telem_perm);
const uint8_t before = slot->flags;
slot->flags = on ? (uint8_t)(slot->flags | bit) : (uint8_t)(slot->flags & ~bit);
if (_backend && slot->flags != before) _backend->contactChanged(*slot);
return true;
}
bool MyMesh::uiSetContactFavorite(const uint8_t pub_key[32], bool fav) {
ContactInfo* slot = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
if (!slot) return false;
const uint8_t before = slot->flags;
slot->flags = fav ? (uint8_t)(slot->flags | 0x01) : (uint8_t)(slot->flags & ~0x01);
if (_backend && slot->flags != before) _backend->contactChanged(*slot);
return true;
}
static bool removeAt(ContactInfo* table, int& n, const uint8_t* pub_key) {
int idx = 0;
while (idx < n && memcmp(table[idx].id.pub_key, pub_key, PUB_KEY_SIZE) != 0) idx++;
if (idx >= n) return false;
n--;
for (; idx < n; idx++) table[idx] = table[idx + 1];
return true;
}
bool MyMesh::uiRemoveContact(const ContactInfo& c) {
if (!removeAt(_contacts, _num_contacts, c.id.pub_key)) return false;
if (_backend) _backend->contactRemoved(c.id.pub_key);
if (_ui) _ui->onThreadsChanged();
return true;
}
bool MyMesh::uiRemoveContactNoSave(const uint8_t pub_key[PUB_KEY_SIZE]) {
if (!removeAt(_contacts, _num_contacts, pub_key)) return false;
if (_backend) _backend->contactRemoved(pub_key);
return true;
}
bool MyMesh::removeTransientContact(const uint8_t pub_key[PUB_KEY_SIZE]) {
ContactInfo* slot = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
if (!slot || slot->type != ADV_TYPE_NONE) return false;
return removeAt(_contacts, _num_contacts, pub_key);
}
bool MyMesh::uiHopName(const uint8_t* hash, int prefix_len, char* out, size_t out_sz) {
if (!out || out_sz == 0) return false;
out[0] = '\0';
if (!hash || prefix_len <= 0) return false;
ContactInfo* c = lookupContactByPubKey(hash, prefix_len);
if (!c || c->name[0] == '\0') return false;
strncpy(out, c->name, out_sz - 1);
out[out_sz - 1] = '\0';
return true;
}
bool MyMesh::uiHopPos(const uint8_t* hash, int prefix_len, double* out_lat, double* out_lon) {
if (!hash || prefix_len <= 0) return false;
ContactInfo* c = lookupContactByPubKey(hash, prefix_len);
if (!c || (c->gps_lat == 0 && c->gps_lon == 0)) return false;
if (out_lat) *out_lat = (double)c->gps_lat / 1.0e6;
if (out_lon) *out_lon = (double)c->gps_lon / 1.0e6;
return true;
}
void MyMesh::noteHeard(const ContactInfo& c) {
if (!c.name[0]) return;
int slot = -1;
for (int i = 0; i < _heard_n; i++)
if (memcmp(_heard[i].pubkey_prefix, c.id.pub_key, sizeof(_heard[i].pubkey_prefix)) == 0) { slot = i; break; }
if (slot < 0) {
if (_heard_n < HEARD_MAX) slot = _heard_n++;
else { // evict the oldest
slot = 0;
for (int i = 1; i < _heard_n; i++) if (_heard[i].recv_seq < _heard[slot].recv_seq) slot = i;
}
}
RecentlyHeardName& h = _heard[slot];
memcpy(h.pubkey_prefix, c.id.pub_key, sizeof(h.pubkey_prefix));
StrHelper::strncpy(h.name, c.name, sizeof(h.name));
h.recv_seq = ++_heard_seq;
h.type = c.type;
}
int MyMesh::getRecentlyHeard(RecentlyHeardName dest[], int max_num) {
if (!dest || max_num <= 0) return 0;
RecentlyHeardName snap[HEARD_MAX];
int n = _heard_n;
memcpy(snap, _heard, sizeof(snap[0]) * (size_t)n);
// newest first, like MyMesh::getRecentlyHeard's sort_by_recent
for (int i = 1; i < n; i++)
for (int j = i; j > 0 && snap[j].recv_seq > snap[j - 1].recv_seq; j--) { RecentlyHeardName t = snap[j]; snap[j] = snap[j - 1]; snap[j - 1] = t; }
if (max_num > n) max_num = n;
memcpy(dest, snap, (size_t)max_num * sizeof(dest[0]));
return max_num;
}
bool MyMesh::getAdvertPath(const uint8_t* pubkey_prefix, int prefix_len, uint8_t& path_len,
uint8_t* path, size_t path_cap) {
// The route of the last advert heard from this node, from the raw RX pushes (beRxRaw);
// the same table and answer as src/MyMesh.cpp's. The demo reports none: "unknown".
if (!pubkey_prefix || prefix_len <= 0) return false;
if (prefix_len > (int)sizeof(AdvertPath::pubkey_prefix)) prefix_len = sizeof(AdvertPath::pubkey_prefix);
for (int i = 0; i < ADVERT_PATHS; i++) {
const AdvertPath& p = _advert_paths[i];
if (!p.used || memcmp(p.pubkey_prefix, pubkey_prefix, (size_t)prefix_len) != 0) continue;
const size_t bytes = (size_t)(p.path_len & 63) * (size_t)((p.path_len >> 6) + 1);
if (bytes > path_cap || bytes > sizeof(p.path) || (bytes && !path)) return false;
path_len = p.path_len;
if (bytes) memcpy(path, p.path, bytes);
return true;
}
return false;
}
// ---- settings backup (Settings > Backups) ---------------------------------------------
// src/MyMesh.cpp's file, field for field (the MeshCore app's shape plus wadamesh's own
// blocks), so a backup moves between the browser, a device and the phone app. Two
// deliberate differences: no private key ("private_key" is empty, which every importer
// skips): the demo has none and a node keeps its own (MeshCore exports it only on the
// node, behind its own setting); and no Wi-Fi credentials (the browser has none).
void MyMesh::uiExportBackup(Print& out, double node_lat, double node_lon) {
static const char* HX = "0123456789abcdef";
auto hex = [&](const uint8_t* d, int n) {
for (int i = 0; i < n; ++i) { out.write(HX[d[i] >> 4]); out.write(HX[d[i] & 0xF]); }
};
auto esc = [&](const char* str) {
for (; str && *str; ++str) {
const char c = *str;
if (c == '"' || c == '\\') { out.write('\\'); out.write((uint8_t)c); }
else if (c == '\n') out.print("\\n");
else if (c == '\r') out.print("\\r");
else if (c == '\t') out.print("\\t");
else if ((uint8_t)c < 0x20) { char b[8]; snprintf(b, sizeof b, "\\u%04x", (unsigned)(uint8_t)c); out.print(b); }
else out.write((uint8_t)c);
}
};
const NodePrefs* p = &_prefs;
char l[256];
out.print("{\n \"name\": \""); esc(p->node_name); out.print("\",\n");
out.print(" \"public_key\": \""); hex(self_id.pub_key, 32); out.print("\",\n");
out.print(" \"private_key\": \"\",\n");
snprintf(l, sizeof l,
" \"radio_settings\": {\"frequency\": %.4f, \"bandwidth\": %.1f, \"spreading_factor\": %u, \"coding_rate\": %u, \"tx_power\": %d},\n",
(double)p->freq, (double)p->bw, (unsigned)p->sf, (unsigned)p->cr, (int)p->tx_power_dbm);
out.print(l);
snprintf(l, sizeof l, " \"position_settings\": {\"latitude\": %.6f, \"longitude\": %.6f},\n", node_lat, node_lon);
out.print(l);
out.print(" \"other_settings\": null,\n");
out.print(" \"auto_add_settings\": null,\n");
snprintf(l, sizeof l,
" \"wadamesh_settings\": {\"version\": 1, \"airtime_factor\": %.3f, \"rx_boosted_gain\": %u, "
"\"multi_acks\": %u, \"manual_add_contacts\": %u, \"autoadd_config\": %u, \"autoadd_max_hops\": %u, ",
(double)p->airtime_factor, (unsigned)p->rx_boosted_gain, (unsigned)p->multi_acks,
(unsigned)p->manual_add_contacts, (unsigned)p->autoadd_config, (unsigned)p->autoadd_max_hops);
out.print(l);
snprintf(l, sizeof l,
"\"advert_loc_policy\": %u, \"telemetry_mode_base\": %u, \"telemetry_mode_loc\": %u, "
"\"telemetry_mode_env\": %u, \"gps_enabled\": %u, \"gps_interval\": %lu, \"path_hash_mode\": %u, ",
(unsigned)p->advert_loc_policy, (unsigned)p->telemetry_mode_base, (unsigned)p->telemetry_mode_loc,
(unsigned)p->telemetry_mode_env, (unsigned)p->gps_enabled, (unsigned long)p->gps_interval,
(unsigned)p->path_hash_mode);
out.print(l);
snprintf(l, sizeof l, "\"rx_delay_base\": %.3f, \"buzzer_quiet\": %u, \"client_repeat\": %u, \"ble_pin\": %lu, ",
(double)p->rx_delay_base, (unsigned)p->buzzer_quiet, (unsigned)p->client_repeat, (unsigned long)p->ble_pin);
out.print(l);
snprintf(l, sizeof l, "\"gps_fuzz_m\": %u, ", (unsigned)touchPrefsGetGpsFuzzM());
out.print(l);
out.print("\"region_scope\": \"");
{
char region[TOUCH_REGION_SCOPE_MAXLEN] = {0};
touchPrefsGetRegionScope(region, sizeof(region));
esc(region);
}
out.print("\"},\n");
out.print(" \"app_settings\": {\"version\": 1,\n \"prefs\": ");
touchPrefsBackupExport(out);
out.print("\n },\n");
out.print(" \"channels\": [");
bool first = true;
for (int i = 0; i < MAX_GROUP_CHANNELS; ++i) {
const ChannelDetails& cd = _channels[i];
if (cd.name[0] == '\0') continue;
out.print(first ? "\n {\"name\": \"" : ",\n {\"name\": \"");
first = false;
esc(cd.name);
out.print("\", \"secret\": \""); hex(cd.channel.secret, 16); out.print("\"}");
}
out.print(first ? "],\n" : "\n ],\n");
out.print(" \"contacts\": [");
first = true;
for (int i = 0; i < _num_contacts; ++i) {
const ContactInfo& c = _contacts[i];
out.print(first ? "\n {\"type\": " : ",\n {\"type\": ");
first = false;
snprintf(l, sizeof l, "%u, \"name\": \"", (unsigned)c.type); out.print(l);
esc(c.name);
out.print("\", \"custom_name\": null, \"public_key\": \""); hex(c.id.pub_key, 32);
snprintf(l, sizeof l,
"\", \"flags\": %u, \"latitude\": \"%.6f\", \"longitude\": \"%.6f\", \"last_advert\": %lu, \"last_modified\": %lu, \"out_path\": null}",
(unsigned)c.flags, (double)c.gps_lat / 1e6, (double)c.gps_lon / 1e6,
(unsigned long)c.last_advert_timestamp, (unsigned long)c.lastmod);
out.print(l);
}
out.print(first ? "]\n}\n" : "\n ]\n}\n");
}
static uint8_t hexNib(char c) {
if (c >= '0' && c <= '9') return c - '0';
if (c >= 'a' && c <= 'f') return c - 'a' + 10;
if (c >= 'A' && c <= 'F') return c - 'A' + 10;
return 0;
}
static int hexToBytes(const char* hx, uint8_t* out, int max_bytes) {
int n = 0;
while (hx && hx[0] && hx[1] && n < max_bytes) { out[n++] = (uint8_t)((hexNib(hx[0]) << 4) | hexNib(hx[1])); hx += 2; }
return n;
}
// src/MyMesh.cpp's import, onto the stand-in: settings go through savePrefs (a node gets
// the ones it owns, as when they are changed by hand), channels and contacts through the
// backend (a node: SET_CHANNEL / ADD_UPDATE_CONTACT). Differences: no private key (see
// the export); contacts are added and updated, never deleted from a node over the link
// (replace_contacts only clears this browser's copy); 256-bit channel keys are not in
// the companion protocol. The demo replays its own cast and channels at every start, so
// there an import keeps the name, settings and app preferences.
bool MyMesh::uiImportBackup(Stream& in, uint8_t sections, bool replace_channels, bool replace_contacts,
int* out_channels, int* out_contacts) {
(void)replace_channels;
if (out_channels) *out_channels = 0;
if (out_contacts) *out_contacts = 0;
JsonDocument doc;
if (deserializeJson(doc, in)) return false;
JsonObjectConst root = doc.as<JsonObjectConst>();
if (root.isNull()) return false;
bool dirty = false;
if (sections & 0x01) {
const char* nm = root["name"].as<const char*>();
if (nm && nm[0]) { StrHelper::strncpy(_prefs.node_name, nm, sizeof(_prefs.node_name)); dirty = true; }
}
if (sections & 0x02) {
JsonObjectConst r = root["radio_settings"].as<JsonObjectConst>();
if (!r.isNull()) {
if (!r["frequency"].isNull()) { _prefs.freq = r["frequency"].as<float>(); dirty = true; }
if (!r["bandwidth"].isNull()) { _prefs.bw = r["bandwidth"].as<float>(); dirty = true; }
if (!r["spreading_factor"].isNull()) { _prefs.sf = (uint8_t)r["spreading_factor"].as<int>(); dirty = true; }
if (!r["coding_rate"].isNull()) { _prefs.cr = (uint8_t)r["coding_rate"].as<int>(); dirty = true; }
if (!r["tx_power"].isNull()) { _prefs.tx_power_dbm = (int8_t)r["tx_power"].as<int>(); dirty = true; }
}
JsonObjectConst w = root["wadamesh_settings"].as<JsonObjectConst>();
if (!w.isNull()) {
auto u8 = [&](const char* k, uint8_t& dst, int max_v) {
if (w[k].isNull()) return;
const int v = w[k].as<int>();
if (v >= 0 && v <= max_v) { dst = (uint8_t)v; dirty = true; }
};
if (!w["airtime_factor"].isNull()) {
const float af = w["airtime_factor"].as<float>();
if (af >= 0.0f && af <= 9.0f) { _prefs.airtime_factor = af; dirty = true; }
}
u8("rx_boosted_gain", _prefs.rx_boosted_gain, 1);
u8("multi_acks", _prefs.multi_acks, 255);
u8("manual_add_contacts", _prefs.manual_add_contacts, 255);
u8("autoadd_config", _prefs.autoadd_config, 255);
u8("autoadd_max_hops", _prefs.autoadd_max_hops, 64);
u8("advert_loc_policy", _prefs.advert_loc_policy, 255);
u8("telemetry_mode_base", _prefs.telemetry_mode_base, 255);
u8("telemetry_mode_loc", _prefs.telemetry_mode_loc, 255);
u8("telemetry_mode_env", _prefs.telemetry_mode_env, 255);
u8("gps_enabled", _prefs.gps_enabled, 1);
u8("path_hash_mode", _prefs.path_hash_mode, 255);
if (!w["gps_interval"].isNull()) { _prefs.gps_interval = w["gps_interval"].as<uint32_t>(); dirty = true; }
u8("buzzer_quiet", _prefs.buzzer_quiet, 1);
u8("client_repeat", _prefs.client_repeat, 255);
if (!w["rx_delay_base"].isNull()) {
const float rd = w["rx_delay_base"].as<float>();
if (rd >= 0.0f && rd <= 20.0f) { _prefs.rx_delay_base = rd; dirty = true; }
}
if (!w["gps_fuzz_m"].isNull()) {
const uint32_t fz = w["gps_fuzz_m"].as<uint32_t>();
if (fz == 0 || fz == 100 || fz == 250 || fz == 1000) touchPrefsSetGpsFuzzM((uint16_t)fz);
}
const char* region = w["region_scope"].as<const char*>();
if (region) {
StrHelper::strncpy(_prefs.default_scope_name, region, sizeof(_prefs.default_scope_name));
touchPrefsSetRegionScope(region);
if (region[0]) _region_reg.ensureRegion(region);
dirty = true;
}
}
}
if (sections & 0x04) {
JsonObjectConst ps = root["position_settings"].as<JsonObjectConst>();
if (!ps.isNull()) {
if (!ps["latitude"].isNull()) { sensors.node_lat = ps["latitude"].as<double>(); dirty = true; }
if (!ps["longitude"].isNull()) { sensors.node_lon = ps["longitude"].as<double>(); dirty = true; }
}
}
if (dirty) savePrefs();
int nch = 0;
if (sections & 0x08) {
JsonArrayConst ch = root["channels"].as<JsonArrayConst>();
int idx = 0;
for (JsonVariantConst ev : ch) {
JsonObjectConst e = ev.as<JsonObjectConst>();
const char* nm = e["name"].as<const char*>();
const char* sec = e["secret"].as<const char*>();
if (idx >= MAX_GROUP_CHANNELS) break;
if (nm && sec && strlen(sec) >= 32) {
uint8_t secret[16];
hexToBytes(sec, secret, 16);
if (uiAddOrUpdateChannel(idx, nm, secret)) nch++;
}
idx++;
}
}
int nco = 0;
if (sections & 0x10) {
JsonArrayConst co = root["contacts"].as<JsonArrayConst>();
if (replace_contacts && !co.isNull() && !(_backend && _backend->ownsPrefs())) _num_contacts = 0;
for (JsonVariantConst ev : co) {
JsonObjectConst e = ev.as<JsonObjectConst>();
const char* pk = e["public_key"].as<const char*>();
if (!pk || strlen(pk) < 64) continue;
ContactInfo c{};
hexToBytes(pk, c.id.pub_key, 32);
const char* cn = e["custom_name"].as<const char*>();
const char* nm = (cn && cn[0]) ? cn : e["name"].as<const char*>();
StrHelper::strncpy(c.name, nm ? nm : "", sizeof(c.name));
c.type = e["type"].as<uint8_t>();
c.flags = e["flags"].as<uint8_t>();
c.out_path_len = OUT_PATH_UNKNOWN;
const char* la = e["latitude"].as<const char*>();
const char* lo = e["longitude"].as<const char*>();
c.gps_lat = la ? (int32_t)(atof(la) * 1e6) : 0;
c.gps_lon = lo ? (int32_t)(atof(lo) * 1e6) : 0;
c.last_advert_timestamp = e["last_advert"].as<uint32_t>();
c.lastmod = e["last_modified"].as<uint32_t>();
ContactInfo* slot = lookupContactByPubKey(c.id.pub_key, PUB_KEY_SIZE);
if (slot) { c.out_path_len = slot->out_path_len; memcpy(c.out_path, slot->out_path, sizeof c.out_path); *slot = c; }
else if (!addContact(c)) continue;
if (_backend) _backend->contactChanged(c);
nco++;
}
}
if (sections & 0x20) {
JsonObjectConst app = root["app_settings"].as<JsonObjectConst>();
for (JsonVariantConst ev : app["prefs"].as<JsonArrayConst>()) {
JsonArrayConst e = ev.as<JsonArrayConst>();
const char* key = e[0].as<const char*>();
const char* type = e[1].as<const char*>();
const char* val = e[2].as<const char*>();
if (key && type && type[0] && !type[1] && val) touchPrefsBackupRestore(key, type[0], val);
}
}
if (_ui) _ui->onThreadsChanged();
if (out_channels) *out_channels = nch;
if (out_contacts) *out_contacts = nco;
return true;
}
bool MyMesh::uiFactoryReset() { return SPIFFS.format(); }
// ---- channels -------------------------------------------------------------------------
bool MyMesh::getChannel(int idx, ChannelDetails& dest) {
if (idx < 0 || idx >= MAX_GROUP_CHANNELS) return false;
dest = _channels[idx];
return true;
}
int MyMesh::findFirstEmptyChannelSlot() {
for (int i = 0; i < MAX_GROUP_CHANNELS; ++i) if (_channels[i].name[0] == '\0') return i;
return -1;
}
bool MyMesh::uiAddOrUpdateChannel(int idx, const char* name, const uint8_t secret16[16]) {
if (idx < 0 || idx >= MAX_GROUP_CHANNELS) return false;
ChannelDetails ch{};
StrHelper::strncpy(ch.name, name, sizeof(ch.name));
memcpy(ch.channel.secret, secret16, 16);
channelHash(ch);
_channels[idx] = ch;
if (_backend) _backend->channelChanged(idx, ch);
if (_ui) _ui->onThreadsChanged();
return true;
}
bool MyMesh::uiDeleteChannel(int idx) {
if (idx < 0 || idx >= MAX_GROUP_CHANNELS) return false;
ChannelDetails empty{};
channelHash(empty);
_channels[idx] = empty;
if (_backend) _backend->channelChanged(idx, empty);
if (_ui) _ui->onThreadsChanged();
return true;
}
bool MyMesh::uiJoinPublicChannel() {
for (int i = 0; i < MAX_GROUP_CHANNELS; ++i)
if (_channels[i].name[0] && strncasecmp(_channels[i].name, "Public", 6) == 0) return true;
const int idx = findFirstEmptyChannelSlot();
if (idx < 0) return false;
uint8_t secret[32] = {0};
if (b64decode("izOH6cXN6mrJ5e26oRXNcg==", secret, sizeof secret) != 16) return false; // MyMesh.cpp PUBLIC_GROUP_PSK
return uiAddOrUpdateChannel(idx, "Public", secret);
}
void MyMesh::setDefaultFloodScope(const char* region_name) {
StrHelper::strncpy(_prefs.default_scope_name, region_name ? region_name : "", sizeof(_prefs.default_scope_name));
savePrefs();
}
bool MyMesh::pushChannelScope(const char* region_name) { return region_name && region_name[0]; }
int MyMesh::channelIdxOf(const mesh::GroupChannel& ch) const {
for (int i = 0; i < MAX_GROUP_CHANNELS; i++)
if (_channels[i].name[0] && memcmp(ch.secret, _channels[i].channel.secret, sizeof(ch.secret)) == 0) return i;
return -1;
}
// ---- sending --------------------------------------------------------------------------
int MyMesh::sendMessage(const ContactInfo& recipient, uint32_t timestamp, uint8_t attempt,
const char* text, uint32_t& expected_ack, uint32_t& est_timeout,
uint32_t* out_packet_hash4, TxtTxDebugInfo* out_dbg) {
(void)attempt;
if (!_backend) return MSG_SEND_FAILED;
uint32_t fp = 0;
const int r = _backend->sendDirect(recipient, timestamp, text, expected_ack, est_timeout, fp);
if (r == MSG_SEND_SENT_FLOOD) _n_sent_flood++; else if (r == MSG_SEND_SENT_DIRECT) _n_sent_direct++;
if (r != MSG_SEND_FAILED) {
_last_txt_hash4 = expected_ack ^ 0x5741u; // stands in for the packet hash: unique per send
if (out_packet_hash4) *out_packet_hash4 = _last_txt_hash4;
if (out_dbg) { *out_dbg = TxtTxDebugInfo{}; out_dbg->uniq_ts = timestamp; out_dbg->packet_hash4 = _last_txt_hash4; }
if (fp && r == MSG_SEND_SENT_FLOOD) trackSentFp(fp);
}
return r;
}
bool MyMesh::sendGroupMessage(uint32_t timestamp, mesh::GroupChannel& channel, const char* sender_name,
const char* text, int text_len) {
if (!_backend) return false;
const int idx = channelIdxOf(channel);
if (idx < 0) return false;
char body[MAX_TEXT_LEN + 1];
int n = text_len < (int)sizeof(body) - 1 ? text_len : (int)sizeof(body) - 1;
memcpy(body, text, n); body[n] = 0;
uint32_t fp = 0;
const bool ok = _backend->sendChannel(idx, _channels[idx], timestamp, sender_name, body, fp);
if (ok) {
_n_sent_flood++;
if (fp) trackSentFp(fp);
}
return ok;
}
bool MyMesh::sendAdvert(bool flood) {
if (!_backend) return false;
const bool ok = _backend->sendAdvert(flood);
if (ok) { if (flood) _n_sent_flood++; else _n_sent_direct++; }
return ok;
}
void MyMesh::uiRegisterExpectedAck(uint32_t expected_ack, const uint8_t pub_key[32]) {
(void)expected_ack; (void)pub_key; // the backend matches its own ACKs (beAck)
}
uint8_t MyMesh::uiRepeatsForFp(uint32_t fp) const {
if (fp == 0) return 0;
for (int i = 0; i < UI_ECHO_SLOTS; i++) if (_echo_fp[i] == fp) return _echo_rep[i];
return 0;
}
uint8_t MyMesh::uiRepeatHopCount(uint32_t fp) const {
if (fp == 0) return 0;
for (int i = 0; i < UI_ECHO_SLOTS; i++) if (_echo_fp[i] == fp) return _echo_hop_n[i];
return 0;
}
uint8_t MyMesh::uiRepeatHop(uint32_t fp, uint8_t idx, uint8_t* out, uint8_t out_sz) const {
if (fp == 0 || !out) return 0;
for (int i = 0; i < UI_ECHO_SLOTS; i++) if (_echo_fp[i] == fp) {
if (idx >= _echo_hop_n[i]) return 0;
uint8_t sz = _echo_hop_sz[i]; if (sz > out_sz) sz = out_sz; if (sz > 4) sz = 4;
memcpy(out, _echo_hop[i][idx], sz);
return sz;
}
return 0;
}
// src/MyMesh.h uiTrackSentFp.
void MyMesh::trackSentFp(uint32_t fp) {
if (fp == 0) return;
_last_sent_fp = fp;
for (int i = 0; i < UI_ECHO_SLOTS; i++) if (_echo_fp[i] == fp) { _echo_rep[i] = 0; _echo_hop_n[i] = 0; return; }
_echo_fp[_echo_idx] = fp; _echo_rep[_echo_idx] = 0; _echo_hop_n[_echo_idx] = 0;
_echo_idx = (uint8_t)((_echo_idx + 1) % UI_ECHO_SLOTS);
}
// ---- UI requests ------------------------------------------------------------------------
int MyMesh::sendTelemetryRequestWithGuestLoginForUI(ContactInfo& recipient) {
return uiSendRequestAfterGuestLogin(recipient, UiReqKind::Telemetry);
}
int MyMesh::uiSendRequestAfterGuestLogin(ContactInfo& recipient, UiReqKind kind) {
if (!_backend || hasUIRequestPending()) return MSG_SEND_FAILED;
const int r = (kind == UiReqKind::Telemetry) ? _backend->requestTelemetry(recipient)
: _backend->requestStatus(recipient);
if (r == MSG_SEND_SENT_FLOOD || r == MSG_SEND_SENT_DIRECT) {
_ui_pending_kind = kind;
memcpy(_ui_pending_key, recipient.id.pub_key, PUB_KEY_SIZE);
}
return r;
}
// The admin app's requests (src/MyMesh.h): straight to the node, one at a time.
int MyMesh::uiStraightRequest(ContactInfo& recipient, UiReqKind kind) {
if (!_backend) return MSG_SEND_FAILED;
const int r = (kind == UiReqKind::Telemetry) ? _backend->requestTelemetry(recipient)
: _backend->requestStatus(recipient);
if (r == MSG_SEND_SENT_FLOOD || r == MSG_SEND_SENT_DIRECT) {
_ui_pending_kind = kind;
memcpy(_ui_pending_key, recipient.id.pub_key, PUB_KEY_SIZE);
}
return r;
}
int MyMesh::sendStatusPingForUI(ContactInfo& recipient) { return uiStraightRequest(recipient, UiReqKind::Status); }
int MyMesh::sendTelemetryRequestForUI(ContactInfo& recipient) { return uiStraightRequest(recipient, UiReqKind::Telemetry); }
int MyMesh::uiSendBinaryRequest(ContactInfo& recipient, const uint8_t* payload, uint8_t len) {
if (!_backend || !payload || !len) return MSG_SEND_FAILED;
const int r = _backend->binaryRequest(recipient, payload, len);
if (r == MSG_SEND_SENT_FLOOD || r == MSG_SEND_SENT_DIRECT) {
_ui_pending_kind = UiReqKind::Binary;
memcpy(_ui_pending_key, recipient.id.pub_key, PUB_KEY_SIZE);
}
return r;
}
int MyMesh::uiSendAdminLogin(ContactInfo& recipient, const char* password) {
if (!_backend) return MSG_SEND_FAILED;
return _backend->login(recipient, password ? password : "");
}
int MyMesh::uiSendAdminCommand(ContactInfo& recipient, const char* text) {
if (!_backend || !text || !text[0]) return MSG_SEND_FAILED;
return _backend->sendCli(recipient, text);
}
int MyMesh::uiRoomRelogin(const uint8_t pub_key[32]) {
ContactInfo* c = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
if (!c || c->type != ADV_TYPE_ROOM) return MSG_SEND_FAILED;
return uiSendAdminLogin(*c, "");
}
int MyMesh::sendRegionsRequestForUI(const uint8_t pub_key[PUB_KEY_SIZE], uint32_t& est_timeout) {
est_timeout = 0;
if (!_backend || !pub_key || hasUIRequestPending()) return MSG_SEND_FAILED;
const int r = _backend->requestRegions(pub_key, est_timeout);
if (r == MSG_SEND_SENT_FLOOD || r == MSG_SEND_SENT_DIRECT) {
_ui_pending_kind = UiReqKind::Regions;
memcpy(_ui_pending_key, pub_key, PUB_KEY_SIZE);
}
return r;
}
uint32_t MyMesh::uiSendTracePing(const uint8_t pub_key[32]) {
if (!_backend || !pub_key) return 0;
_ui_trace_tag = _backend->tracePing(pub_key);
return _ui_trace_tag;
}
uint32_t MyMesh::uiSendTraceRoute(const ContactInfo& c) {
if (!_backend) return 0;
_ui_trace_tag = _backend->traceRoute(c);
return _ui_trace_tag;
}
// ---- terminal -----------------------------------------------------------------------------
void MyMesh::setTerminalSink(void (*cb)(const char* line)) { s_terminal_sink = cb; }
void MyMesh::runLocalCli(const char* cmd) {
if (!s_terminal_sink || !cmd) return;
if (_backend && _backend->runNodeCli(cmd)) return; // a companion node runs it (beTerminalLine)
char line[160];
if (!strcmp(cmd, "ver") || !strcmp(cmd, "version")) {
snprintf(line, sizeof line, "%s (%s), web build, backend %s", FIRMWARE_VERSION, FIRMWARE_BUILD_DATE,
_backend ? _backend->name() : "none");
} else if (!strcmp(cmd, "name")) {
snprintf(line, sizeof line, "name: %s", _prefs.node_name);
} else if (!strcmp(cmd, "contacts")) {
snprintf(line, sizeof line, "contacts: %d", _num_contacts);
} else {
snprintf(line, sizeof line, "'%s' is not available in the web build", cmd);
}
s_terminal_sink(line);
}
// ---- events from the backend (same UI callback order as src/MyMesh.cpp) -------------------
void MyMesh::beContact(const ContactInfo& c, bool heard_advert, uint8_t path_len) {
ContactInfo* slot = lookupContactByPubKey(c.id.pub_key, PUB_KEY_SIZE);
const bool is_new = (slot == nullptr);
if (slot) *slot = c; else addContact(c);
if (heard_advert) {
noteHeard(c);
if (path_len == 0 || path_len == OUT_PATH_UNKNOWN) _n_recv_direct++; else _n_recv_flood++;
if (_ui) _ui->notify(UIEventType::newContactMessage);
if (_ui) _ui->discoveredContact(c, false /* it is in contacts[] now */, path_len);
} else if (is_new && _ui) {
_ui->onThreadsChanged();
}
}
void MyMesh::beDiscovered(const ContactInfo& c, uint8_t path_len) {
noteHeard(c);
_n_recv_flood++;
if (_ui) _ui->notify(UIEventType::newContactMessage);
if (_ui) _ui->discoveredContact(c, true /* not in contacts[] */, path_len);
}
void MyMesh::beOutgoingDirect(const uint8_t pub_key[32], const char* text, uint32_t expected_ack) {
ContactInfo* to = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
if (to && _ui) _ui->appSentMsgToContact(to->id.pub_key, to->name, text, expected_ack);
}
void MyMesh::beOutgoingChannel(int channel_idx, const char* text) {
if (channel_idx < 0 || channel_idx >= MAX_GROUP_CHANNELS || !_channels[channel_idx].name[0] || !_ui) return;
_ui->appSentMsgToChannel(_channels[channel_idx].name, text);
}
void MyMesh::beChannel(int idx, const ChannelDetails& ch) {
if (idx < 0 || idx >= MAX_GROUP_CHANNELS) return;
_channels[idx] = ch;
channelHash(_channels[idx]);
if (_ui) _ui->onThreadsChanged();
}
void MyMesh::beDirectMessage(const uint8_t pub_key[32], uint32_t sender_ts, const char* text,
uint8_t path_len, bool flood, int8_t snr_q4, int8_t rssi) {
ContactInfo* from = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
if (!from || !_ui) return;
if (flood) _n_recv_flood++; else _n_recv_direct++;
beSignal(snr_q4, rssi);
stashRxMeta(false, from->id.pub_key, flood ? path_len : 0xFF);
_ui->notify(UIEventType::contactMessage);
_last_sender_ts = sender_ts;
_ui->newMsgFromPubWithMeta(flood ? path_len : 0xFF, flood, from->id.pub_key, from->name, text,
++_msgcount, snr_q4, rssi);
}
void MyMesh::beChannelMessage(int channel_idx, uint32_t sender_ts, const char* text,
uint8_t path_len, int8_t snr_q4, int8_t rssi) {
if (!_ui) return;
const char* channel_name = "Unknown channel";
if (channel_idx >= 0 && channel_idx < MAX_GROUP_CHANNELS && _channels[channel_idx].name[0])
channel_name = _channels[channel_idx].name;
_n_recv_flood++;
beSignal(snr_q4, rssi);
stashRxMeta(true, (channel_idx >= 0 && channel_idx < MAX_GROUP_CHANNELS) ? _channels[channel_idx].channel.hash : nullptr,
path_len);
_ui->notify(UIEventType::channelMessage);
_last_sender_ts = sender_ts;
_ui->newMsgFromPubWithMeta(path_len, true, nullptr, channel_name, text, ++_msgcount, snr_q4, rssi);
}
void MyMesh::beRoomMessage(const uint8_t room_pub_key[32], const char* author, uint32_t sender_ts,
const char* text, uint8_t path_len, int8_t snr_q4, int8_t rssi) {
ContactInfo* room = lookupContactByPubKey(room_pub_key, PUB_KEY_SIZE);
if (!room || !_ui) return;
_n_recv_flood++;
beSignal(snr_q4, rssi);
stashRxMeta(false, room->id.pub_key, path_len);
_ui->notify(UIEventType::roomMessage);
_last_sender_ts = sender_ts;
_ui->newRoomMsgFromPubWithMeta(path_len, true, room->id.pub_key, room->name, author, text,
++_msgcount, snr_q4, rssi);
}
void MyMesh::beAck(uint32_t expected_ack) { if (_ui) _ui->onMessageAcked(expected_ack); }
// src/MyMesh.h uiCountEcho: count one echo, remember which repeater re-flooded it.
void MyMesh::beRepeatHeard(uint32_t sent_fp, const uint8_t* hop, uint8_t hop_sz) {
for (int i = 0; i < UI_ECHO_SLOTS; i++) {
if (_echo_fp[i] != sent_fp) continue;
if (_echo_rep[i] < 255) _echo_rep[i]++;
_echo_dirty = true;
if (hop && hop_sz > 0 && hop_sz <= 4 && _echo_hop_n[i] < ECHO_MAX_HOPS) {
bool seen = false;
for (uint8_t k = 0; k < _echo_hop_n[i]; k++)
if (_echo_hop_sz[i] == hop_sz && memcmp(_echo_hop[i][k], hop, hop_sz) == 0) { seen = true; break; }
if (!seen) {
memcpy(_echo_hop[i][_echo_hop_n[i]], hop, hop_sz);
_echo_hop_sz[i] = hop_sz;
_echo_hop_n[i]++;
}
}
return;
}
}
void MyMesh::beStatusReply(const uint8_t pub_key[32], const uint8_t* data, size_t len) {
ContactInfo* c = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
if (_ui_pending_kind == UiReqKind::None || memcmp(_ui_pending_key, pub_key, PUB_KEY_SIZE) != 0) return;
_ui_pending_kind = UiReqKind::None;
if (c && _ui) _ui->onPingReply(*c, data, len);
}
void MyMesh::beTelemetryReply(const uint8_t pub_key[32], const uint8_t* lpp, size_t len) {
ContactInfo* c = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
if (_ui_pending_kind == UiReqKind::None || memcmp(_ui_pending_key, pub_key, PUB_KEY_SIZE) != 0) return;
_ui_pending_kind = UiReqKind::None;
if (c && _ui) _ui->onTelemetryReply(*c, lpp, len);
}
void MyMesh::beTraceResult(uint32_t tag, int8_t their_snr, int8_t our_snr,
uint8_t extra_hops, const int8_t* extra_snrs) {
if (!_ui || tag == 0 || tag != _ui_trace_tag) return;
_ui_trace_tag = 0;
_ui->onTracePingResult(tag, their_snr, our_snr, extra_snrs ? extra_hops : 0, extra_snrs);
}
void MyMesh::beSignal(int8_t snr_q4, int8_t rssi) {
_ui_sig_snr_q4 = snr_q4;
_ui_sig_rssi = rssi;
_ui_sig_ms = millis();
if (_ui_sig_ms == 0) _ui_sig_ms = 1;
}
// ---- events only a link to a real node produces ----------------------------------------
void MyMesh::beSelfInfo(const NodePrefs& np, const uint8_t pub_key[32], int32_t lat_e6, int32_t lon_e6) {
// The node owns these; everything else in NodePrefs is this UI's own.
StrHelper::strncpy(_prefs.node_name, np.node_name, sizeof(_prefs.node_name));
_prefs.freq = np.freq;
_prefs.bw = np.bw;
_prefs.sf = np.sf;
_prefs.cr = np.cr;
_prefs.tx_power_dbm = np.tx_power_dbm;
_prefs.multi_acks = np.multi_acks;
_prefs.manual_add_contacts = np.manual_add_contacts;
_prefs.advert_loc_policy = np.advert_loc_policy;
_prefs.telemetry_mode_base = np.telemetry_mode_base;
_prefs.telemetry_mode_loc = np.telemetry_mode_loc;
_prefs.telemetry_mode_env = np.telemetry_mode_env;
_prefs.client_repeat = np.client_repeat;
_prefs.path_hash_mode = np.path_hash_mode;
_prefs.ble_pin = np.ble_pin;
memcpy(self_id.pub_key, pub_key, PUB_KEY_SIZE);
_node_pos_lat = (double)lat_e6 / 1.0e6;
_node_pos_lon = (double)lon_e6 / 1.0e6;
// The node's position is the UI's, unless this computer's GPS has one (it wins, as a
// device's fix wins over its stored position; syncAdvertPosition decides if it is sent)
// or this browser already keeps one (a position typed here stays; the node's is often
// the privacy-displaced copy it advertises, or none at all).
LocationProvider* lp = sensors.getLocationProvider();
const bool own_fix = _prefs.gps_enabled && lp && lp->isValid();
if ((lat_e6 != 0 || lon_e6 != 0) && !own_fix && !_have_own_pos) {
sensors.node_lat = _node_pos_lat;
sensors.node_lon = _node_pos_lon;
}
// Keep the local copy in step without echoing it back to the node.
File f = SPIFFS.open(k_prefs_path, "w");
if (f) { f.write((const uint8_t*)&_prefs, sizeof _prefs); f.close(); }
if (_ui) _ui->onThreadsChanged();
}
void MyMesh::beContactRemoved(const uint8_t pub_key[32]) {
if (removeAt(_contacts, _num_contacts, pub_key) && _ui) _ui->onThreadsChanged();
}
// src/MyMesh.cpp logRxRaw, on the node's copy of the frame: the RF monitor ring, the
// live signal (0-hop only), advert routes, and "repeats heard" for our own floods.
void MyMesh::beRxRaw(int8_t snr_q4, int8_t rssi, const uint8_t* raw, size_t len) {
const RawView v = rawView(raw, len);
if (!v.ok) return;
const uint32_t now_ms = millis();
_last_rx_snr_q4 = snr_q4;
_last_rx_rssi = rssi;
uint8_t org_kind = 0, org[4] = {0, 0, 0, 0};
const int pl = v.payload_off;
switch (v.ptype) {
case PAYLOAD_TYPE_ADVERT:
if ((size_t)pl + 32 <= len) { org_kind = 1; memcpy(org, &raw[pl], 4); }
break;
case PAYLOAD_TYPE_REQ: case PAYLOAD_TYPE_RESPONSE: case PAYLOAD_TYPE_TXT_MSG: case PAYLOAD_TYPE_PATH:
if ((size_t)pl + 2 <= len) { org_kind = 2; org[0] = raw[pl]; org[1] = raw[pl + 1]; }
break;
default: break;
}
if (v.hops == 0) beSignal(snr_q4, rssi);
UiRxRec& r = _rxlog[_rxlog_head];
r.ms = now_ms; r.rssi = rssi; r.snr_q4 = snr_q4; r.ptype = v.ptype; r.route = v.route; r.hops = v.hops;
r.len = (uint8_t)(len > 255 ? 255 : len);
r.org_kind = org_kind;
memcpy(r.org, org, 4);
_rxlog_head = (uint8_t)((_rxlog_head + 1) % UI_RXLOG_MAX);
if (_rxlog_cnt < UI_RXLOG_MAX) _rxlog_cnt++;
// Advert routes (getAdvertPath).
if (v.ptype == PAYLOAD_TYPE_ADVERT && org_kind == 1) {
int slot = -1, oldest = 0;
for (int i = 0; i < ADVERT_PATHS; i++) {
if (_advert_paths[i].used && memcmp(_advert_paths[i].pubkey_prefix, &raw[pl], sizeof(AdvertPath::pubkey_prefix)) == 0) { slot = i; break; }
if (!_advert_paths[i].used) { if (slot < 0) slot = i; continue; }
if (_advert_paths[i].recv_seq < _advert_paths[oldest].recv_seq) oldest = i;
}
if (slot < 0) slot = oldest;
AdvertPath& a = _advert_paths[slot];
memcpy(a.pubkey_prefix, &raw[pl], sizeof(a.pubkey_prefix));
const size_t bytes = (size_t)v.hops * v.hash_sz;
a.path_len = (uint8_t)(raw[v.path_off - 1]);
if (bytes <= sizeof(a.path)) memcpy(a.path, &raw[v.path_off], bytes);
else a.path_len = 0;
a.recv_timestamp = getRTCClock()->getCurrentTime();
a.recv_seq = ++_advert_seq;
a.used = true;
}
// A message packet: kept for the Info popup of the message event that follows it.
if ((v.ptype == PAYLOAD_TYPE_TXT_MSG || v.ptype == PAYLOAD_TYPE_GRP_TXT) && len <= sizeof(_last_msg_raw)) {
memcpy(_last_msg_raw, raw, len);
_last_msg_raw_len = (uint16_t)len;
_last_msg_raw_ms = now_ms ? now_ms : 1;
}
// Repeats heard: our own flood coming back (same payload, longer path).
if (isMsgFloodType(v.ptype) && (size_t)pl < len) {
const uint32_t fp = fnv1a32(raw + pl, (int)(len - pl));
const uint8_t* lasthop = v.hops >= 1 ? raw + pl - v.hash_sz : nullptr;
beRepeatHeard(fp, lasthop, lasthop ? v.hash_sz : 0);
}
}
// src/MyMesh.h uiStashRxMeta: route + scope of the packet that carried the message the
// UI is about to be told about. Over a companion link that is the raw RX push that came
// just before it, when it is plausibly the same packet (type, sender/channel hash, hops).
void MyMesh::stashRxMeta(bool for_channel, const uint8_t* key_or_hash, uint8_t path_len) {
_last_rx_path_n = 0;
_last_rx_has_scope = false;
_last_rx_scope = 0;
_last_rx_scope_slot = REGION_SLOT_NONE;
if (!_last_msg_raw_ms || !key_or_hash || (uint32_t)(millis() - _last_msg_raw_ms) > 3000) return;
const RawView v = rawView(_last_msg_raw, _last_msg_raw_len);
_last_msg_raw_ms = 0;
if (!v.ok || (size_t)v.payload_off + 2 > _last_msg_raw_len) return;
if (for_channel) {
if (v.ptype != PAYLOAD_TYPE_GRP_TXT || _last_msg_raw[v.payload_off] != key_or_hash[0]) return;
} else {
if (v.ptype != PAYLOAD_TYPE_TXT_MSG || _last_msg_raw[v.payload_off + 1] != key_or_hash[0]) return;
}
const bool flood = (v.route == ROUTE_TYPE_FLOOD || v.route == ROUTE_TYPE_TRANSPORT_FLOOD);
if (flood && path_len != 0xFF && (path_len & 0x3F) != v.hops) return;
if (flood) {
int nb = (int)v.hops * (int)v.hash_sz;
if (nb > (int)sizeof(_last_rx_path)) nb = (int)sizeof(_last_rx_path);
if (nb > 0) { memcpy(_last_rx_path, &_last_msg_raw[v.path_off], (size_t)nb); _last_rx_path_n = (uint8_t)nb; }
}
if (v.route == ROUTE_TYPE_TRANSPORT_FLOOD || v.route == ROUTE_TYPE_TRANSPORT_DIRECT) {
mesh::Packet pkt;
if (pkt.readFrom(_last_msg_raw, (uint8_t)_last_msg_raw_len)) {
_last_rx_has_scope = true;
_last_rx_scope = pkt.transport_codes[0] ? pkt.transport_codes[0] : pkt.transport_codes[1];
_last_rx_scope_slot = pkt.transport_codes[0] ? _region_reg.matchPacket(&pkt, pkt.transport_codes[0])
: REGION_SLOT_NONE;
}
}
}
void MyMesh::beLoginResult(const uint8_t pub_key[32], bool ok, uint8_t perms, uint32_t server_clock) {
ContactInfo* c = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
if (!c || !_ui) return;
if (ok) _ui->onServerClock(*c, server_clock);
_ui->onAdminLoginResult(*c, ok, perms);
}
void MyMesh::beLoginInfo(const uint8_t pub_key[32], uint8_t acl, uint8_t fw_level) {
memcpy(_ui_last_login.pub4, pub_key, 4);
_ui_last_login.acl = acl;
_ui_last_login.fw_level = fw_level;
_ui_last_login.valid = true;
}
void MyMesh::beBinaryReply(const uint8_t pub_key[32], const uint8_t* data, size_t len) {
if (_ui_pending_kind != UiReqKind::Binary || memcmp(_ui_pending_key, pub_key, PUB_KEY_SIZE) != 0) return;
_ui_pending_kind = UiReqKind::None;
ContactInfo* c = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
if (c && _ui) _ui->onBinaryReply(*c, data, len);
}
void MyMesh::beCliReply(const uint8_t pub_key[32], const char* text) {
ContactInfo* c = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
if (c && _ui) _ui->onAdminCommandReply(*c, text);
}
void MyMesh::beRegionsReply(const uint8_t pub_key[32], const uint8_t* data, size_t len) {
if (_ui_pending_kind != UiReqKind::Regions || memcmp(_ui_pending_key, pub_key, PUB_KEY_SIZE) != 0) return;
_ui_pending_kind = UiReqKind::None;
ContactInfo* c = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
if (c && _ui) _ui->onRegionListReply(*c, data, len);
}
void MyMesh::beLinkState(bool up, const char* detail) {
char line[160];
snprintf(line, sizeof line, "%s: %s", up ? "Connected" : "Disconnected", detail ? detail : "");
Serial.printf("[web] companion %s\n", line);
if (s_terminal_sink) s_terminal_sink(line);
if (_ui) _ui->onThreadsChanged();
}
void MyMesh::beTerminalLine(const char* text) {
if (s_terminal_sink && text) s_terminal_sink(text);
}
Reference in new issue View Git Blame Copy Permalink