You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
546 lines
18 KiB
546 lines
18 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2026 Tom Hensel <code@jitter.eu> // |
|
// // |
|
// This program is free software; you can redistribute it and/or modify // |
|
// it under the terms of the GNU General Public License as published by // |
|
// the Free Software Foundation as version 3 of the License, or // |
|
// (at your option) any later version. // |
|
// // |
|
// MESHCORE: command parser implementation. // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include "meshcore_command.h" |
|
|
|
#include "meshcore_builders.h" |
|
#include "meshcore_crypto.h" |
|
|
|
#include <QDateTime> |
|
#include <QStringList> |
|
|
|
namespace modemmeshcore |
|
{ |
|
namespace command |
|
{ |
|
|
|
namespace |
|
{ |
|
|
|
QString lower(const QString& s) { return s.toLower(); } |
|
|
|
// Parse a hex string into bytes; empty on parse error. |
|
QByteArray hex(const QString& v) |
|
{ |
|
QByteArray b = QByteArray::fromHex(v.toLatin1()); |
|
return b; |
|
} |
|
|
|
// Resolve a key (case-insensitive). Empty if missing. |
|
QString get(const QMap<QString, QString>& kv, const char* key) |
|
{ |
|
auto it = kv.find(QString::fromLatin1(key)); |
|
return (it != kv.end()) ? it.value() : QString(); |
|
} |
|
|
|
bool toUInt(const QString& s, uint32_t& out) |
|
{ |
|
bool ok = false; |
|
if (s.startsWith("0x", Qt::CaseInsensitive)) { |
|
out = s.mid(2).toUInt(&ok, 16); |
|
} else { |
|
out = s.toUInt(&ok, 10); |
|
} |
|
return ok; |
|
} |
|
|
|
bool toRouteType(const QString& s, uint8_t& out) |
|
{ |
|
const QString l = lower(s); |
|
if (l == "t_flood") { out = RouteTFlood; return true; } |
|
if (l == "flood") { out = RouteFlood; return true; } |
|
if (l == "direct") { out = RouteDirect; return true; } |
|
if (l == "t_direct") { out = RouteTDirect; return true; } |
|
return false; |
|
} |
|
|
|
uint32_t resolveTimestamp(const QMap<QString, QString>& kv) |
|
{ |
|
const QString ts = get(kv, "ts"); |
|
if (ts.isEmpty()) { |
|
return static_cast<uint32_t>(QDateTime::currentSecsSinceEpoch()); |
|
} |
|
uint32_t v = 0; |
|
return toUInt(ts, v) ? v : 0; |
|
} |
|
|
|
} // namespace |
|
|
|
bool tokenize(const QString& body, QMap<QString, QString>& kv, QString& error) |
|
{ |
|
kv.clear(); |
|
const QStringList tokens = body.split(';', Qt::SkipEmptyParts); |
|
for (const QString& raw : tokens) |
|
{ |
|
const QString tok = raw.trimmed(); |
|
if (tok.isEmpty()) { |
|
continue; |
|
} |
|
const int eq = tok.indexOf('='); |
|
if (eq <= 0) { |
|
error = QString("malformed token (expected key=value): '%1'").arg(tok); |
|
return false; |
|
} |
|
const QString k = tok.left(eq).trimmed().toLower(); |
|
const QString v = tok.mid(eq + 1).trimmed(); |
|
if (k.isEmpty()) { |
|
error = QString("empty key in token: '%1'").arg(tok); |
|
return false; |
|
} |
|
kv.insert(k, v); |
|
} |
|
return true; |
|
} |
|
|
|
namespace |
|
{ |
|
|
|
// MeshCore regional preset table. |
|
// |
|
// Entries below are the well-known regional defaults the MeshCore |
|
// community uses. They map directly to the firmware CLI's |
|
// `set radio freq_MHz,bw_kHz,sf,cr` form (cr is encoded as 5..8 for |
|
// 4/5..4/8 — `cr` here is therefore parityBits + 4). Default profile |
|
// is `EU_NARROW` (MeshCore EU/UK Narrow / Recommended channel). |
|
struct MeshcorePresetEntry |
|
{ |
|
const char* key; // canonical preset key (uppercase, snake_case) |
|
const char* displayName; // human-readable label (for logs/summary) |
|
qint64 freqHz; |
|
int bandwidthHz; |
|
int spreadFactor; |
|
int parityBits; // CR = parityBits + 4 |
|
}; |
|
|
|
constexpr MeshcorePresetEntry kMeshcorePresets[] = { |
|
{"EU_NARROW", "EU/UK Narrow (Recommended)", 869618000, 62500, 8, 4}, |
|
{"EU_LONG_RANGE", "EU/UK Long Range", 869525000, 250000, 11, 1}, |
|
{"EU_MEDIUM_RANGE", "EU/UK Medium Range", 869525000, 250000, 10, 1}, |
|
{"AU", "Australia", 915800000, 250000, 10, 1}, |
|
{"AU_VICTORIA", "Australia: Victoria", 916575000, 62500, 7, 4}, |
|
{"CZ_NARROW", "Czech Republic Narrow", 869525000, 62500, 7, 1}, |
|
{"EU_433_LONG_RANGE", "EU 433 MHz Long Range", 433650000, 250000, 11, 1}, |
|
{"NZ", "New Zealand", 917375000, 250000, 11, 1}, |
|
{"NZ_NARROW", "New Zealand Narrow", 917375000, 62500, 7, 1}, |
|
{"PT_433", "Portugal 433", 433375000, 62500, 9, 2}, |
|
{"PT_868", "Portugal 868", 869618000, 62500, 7, 2}, |
|
{"CH", "Switzerland", 869618000, 62500, 8, 4}, |
|
{"USA", "USA / Canada", 910525000, 62500, 7, 1}, |
|
{"VN", "Vietnam", 920250000, 250000, 11, 1}, |
|
}; |
|
|
|
bool applyMeshcorePreset(const QString& preset, TxRadioSettings& settings, QString& error) |
|
{ |
|
const QByteArray key = preset.toUpper().toLatin1(); |
|
if (key == "USER") { |
|
return true; // USER preset = no overrides; caller's individual keys win |
|
} |
|
for (const auto& entry : kMeshcorePresets) { |
|
if (key == entry.key) { |
|
settings.centerFrequencyHz = entry.freqHz; |
|
settings.hasCenterFrequency = true; |
|
settings.bandwidthHz = entry.bandwidthHz; |
|
settings.spreadFactor = entry.spreadFactor; |
|
settings.parityBits = entry.parityBits; |
|
settings.hasLoRaParams = true; |
|
settings.summary = QString("MeshCore preset %1").arg(entry.displayName); |
|
return true; |
|
} |
|
} |
|
error = QString("invalid MeshCore preset: '%1'").arg(preset); |
|
return false; |
|
} |
|
|
|
} // namespace |
|
|
|
bool applyRadioParams(const QMap<QString, QString>& kv, TxRadioSettings& settings, QString& error) |
|
{ |
|
bool changed = false; |
|
|
|
// Apply MeshCore regional preset first (if present), then let individual |
|
// sf/bw/cr/freq/sync/preamble keys override specific fields. |
|
const QString presetS = get(kv, "preset"); |
|
if (!presetS.isEmpty()) { |
|
if (!applyMeshcorePreset(presetS, settings, error)) { |
|
return false; |
|
} |
|
// SF-dependent preamble preamble: SF < 9 → 32, SF > 8 → 16. |
|
// Matches upstream meshcore-py commit 2026-06. |
|
if (settings.spreadFactor < 9) { settings.preambleChirps = 32; } |
|
else { settings.preambleChirps = 16; } |
|
changed = true; |
|
} |
|
|
|
const QString sfS = get(kv, "sf"); |
|
if (!sfS.isEmpty()) { |
|
uint32_t sf = 0; |
|
if (!toUInt(sfS, sf) || sf < 7 || sf > 12) { |
|
error = QString("invalid sf: '%1' (expected 7..12)").arg(sfS); |
|
return false; |
|
} |
|
settings.spreadFactor = static_cast<int>(sf); |
|
settings.hasLoRaParams = true; |
|
changed = true; |
|
} |
|
|
|
const QString bwS = get(kv, "bw"); |
|
if (!bwS.isEmpty()) { |
|
uint32_t bw = 0; |
|
if (!toUInt(bwS, bw) || bw == 0) { |
|
error = QString("invalid bw: '%1' (expected Hz)").arg(bwS); |
|
return false; |
|
} |
|
settings.bandwidthHz = static_cast<int>(bw); |
|
settings.hasLoRaParams = true; |
|
changed = true; |
|
} |
|
|
|
const QString crS = get(kv, "cr"); |
|
if (!crS.isEmpty()) { |
|
uint32_t cr = 0; |
|
if (!toUInt(crS, cr) || cr < 5 || cr > 8) { |
|
error = QString("invalid cr: '%1' (expected 5..8 for 4/5..4/8)").arg(crS); |
|
return false; |
|
} |
|
settings.parityBits = static_cast<int>(cr) - 4; // 5 -> 1, 8 -> 4 |
|
settings.hasLoRaParams = true; |
|
changed = true; |
|
} |
|
|
|
const QString syncS = get(kv, "sync"); |
|
if (!syncS.isEmpty()) { |
|
uint32_t sync = 0; |
|
if (!toUInt(syncS, sync) || sync > 0xFF) { |
|
error = QString("invalid sync: '%1'").arg(syncS); |
|
return false; |
|
} |
|
settings.syncWord = static_cast<uint8_t>(sync); |
|
settings.hasLoRaParams = true; |
|
changed = true; |
|
} |
|
|
|
const QString freqS = get(kv, "freq"); |
|
if (!freqS.isEmpty()) { |
|
// Accept "869618000" (Hz) or "869.618M" / "869.618MHz" |
|
QString s = freqS; |
|
s.replace("Hz", "", Qt::CaseInsensitive); |
|
const bool isMhz = s.contains('M', Qt::CaseInsensitive); |
|
s.replace("M", "", Qt::CaseInsensitive); |
|
bool ok = false; |
|
const double v = s.toDouble(&ok); |
|
if (!ok || v <= 0) { |
|
error = QString("invalid freq: '%1'").arg(freqS); |
|
return false; |
|
} |
|
settings.centerFrequencyHz = static_cast<qint64>(isMhz ? v * 1.0e6 : v); |
|
settings.hasCenterFrequency = true; |
|
changed = true; |
|
} |
|
|
|
const QString prS = get(kv, "preamble"); |
|
if (!prS.isEmpty()) { |
|
uint32_t pr = 0; |
|
if (!toUInt(prS, pr) || pr == 0 || pr > 1024) { |
|
error = QString("invalid preamble: '%1'").arg(prS); |
|
return false; |
|
} |
|
settings.preambleChirps = static_cast<int>(pr); |
|
settings.hasLoRaParams = true; |
|
changed = true; |
|
} |
|
|
|
if (changed) { |
|
settings.hasCommand = true; |
|
} |
|
return true; |
|
} |
|
|
|
namespace |
|
{ |
|
|
|
bool buildAdvertFromKv(const QMap<QString, QString>& kv, |
|
QByteArray& frame, QString& summary, QString& error) |
|
{ |
|
const QByteArray seed = hex(get(kv, "seed")); |
|
if (seed.size() != kPubKeySize) { |
|
error = "advert: seed (hex 32 bytes) is required"; |
|
return false; |
|
} |
|
const QByteArray pub = detail::derivePubKey(seed); |
|
if (pub.size() != kPubKeySize) { |
|
error = "advert: failed to derive public key"; |
|
return false; |
|
} |
|
|
|
builders::AdvertOptions opts; |
|
opts.timestamp = resolveTimestamp(kv); |
|
opts.name = get(kv, "name"); |
|
|
|
const QString latS = get(kv, "lat"); |
|
const QString lonS = get(kv, "lon"); |
|
if (!latS.isEmpty() && !lonS.isEmpty()) { |
|
bool okLat = false, okLon = false; |
|
const double lat = latS.toDouble(&okLat); |
|
const double lon = lonS.toDouble(&okLon); |
|
if (!okLat || !okLon) { |
|
error = "advert: invalid lat/lon"; |
|
return false; |
|
} |
|
opts.latLon = std::make_pair(lat, lon); |
|
} |
|
|
|
const QString routeS = get(kv, "route"); |
|
if (!routeS.isEmpty()) { |
|
if (!toRouteType(routeS, opts.routeType)) { |
|
error = QString("advert: invalid route '%1'").arg(routeS); |
|
return false; |
|
} |
|
} |
|
|
|
frame = builders::buildAdvert(seed, pub, opts); |
|
if (frame.isEmpty()) { |
|
error = "advert: build failed"; |
|
return false; |
|
} |
|
summary = QString("MESHCORE TX|advert pub=%1 ts=%2 name=\"%3\"") |
|
.arg(QString::fromLatin1(pub.toHex().left(16))) |
|
.arg(opts.timestamp) |
|
.arg(opts.name); |
|
return true; |
|
} |
|
|
|
bool buildTxtMsgFromKv(const QMap<QString, QString>& kv, |
|
QByteArray& frame, QString& summary, QString& error) |
|
{ |
|
const QByteArray seed = hex(get(kv, "seed")); |
|
const QByteArray dest = hex(get(kv, "dest")); |
|
const QString text = get(kv, "text"); |
|
if (seed.size() != kPubKeySize) { |
|
error = "txt_msg: seed (hex 32 bytes) required"; |
|
return false; |
|
} |
|
if (dest.size() != kPubKeySize) { |
|
error = "txt_msg: dest (hex 32 bytes) required"; |
|
return false; |
|
} |
|
if (text.isEmpty()) { |
|
error = "txt_msg: text required"; |
|
return false; |
|
} |
|
|
|
builders::TxtMsgOptions opts; |
|
opts.timestamp = resolveTimestamp(kv); |
|
|
|
uint32_t txtType = 0, attempt = 0; |
|
const QString tt = get(kv, "txt_type"); |
|
if (!tt.isEmpty() && (!toUInt(tt, txtType) || txtType > 0x3F)) { |
|
error = "txt_msg: invalid txt_type"; |
|
return false; |
|
} |
|
const QString at = get(kv, "attempt"); |
|
if (!at.isEmpty() && (!toUInt(at, attempt) || attempt > 3)) { |
|
error = "txt_msg: invalid attempt (0..3)"; |
|
return false; |
|
} |
|
opts.txtType = static_cast<uint8_t>(txtType); |
|
opts.attempt = static_cast<uint8_t>(attempt); |
|
|
|
const QString routeS = get(kv, "route"); |
|
if (!routeS.isEmpty() && !toRouteType(routeS, opts.routeType)) { |
|
error = QString("txt_msg: invalid route '%1'").arg(routeS); |
|
return false; |
|
} |
|
|
|
frame = builders::buildTxtMsg(seed, dest, text.toUtf8(), opts); |
|
if (frame.isEmpty()) { |
|
error = "txt_msg: build failed"; |
|
return false; |
|
} |
|
summary = QString("MESHCORE TX|txt_msg dest=%1 ts=%2 text=\"%3\"") |
|
.arg(QString::fromLatin1(dest.toHex().left(16))) |
|
.arg(opts.timestamp) |
|
.arg(text); |
|
return true; |
|
} |
|
|
|
bool buildAnonReqFromKv(const QMap<QString, QString>& kv, |
|
QByteArray& frame, QString& summary, QString& error) |
|
{ |
|
const QByteArray seed = hex(get(kv, "seed")); |
|
const QByteArray dest = hex(get(kv, "dest")); |
|
if (seed.size() != kPubKeySize) { |
|
error = "anon_req: seed required"; |
|
return false; |
|
} |
|
if (dest.size() != kPubKeySize) { |
|
error = "anon_req: dest required"; |
|
return false; |
|
} |
|
|
|
QByteArray data; |
|
const QString dataHex = get(kv, "data"); |
|
const QString dataTxt = get(kv, "text"); |
|
if (!dataHex.isEmpty()) { |
|
data = hex(dataHex); |
|
if (data.isEmpty()) { |
|
error = "anon_req: invalid data hex"; |
|
return false; |
|
} |
|
} else if (!dataTxt.isEmpty()) { |
|
data = dataTxt.toUtf8(); |
|
} else { |
|
error = "anon_req: data or text required"; |
|
return false; |
|
} |
|
|
|
builders::AnonReqOptions opts; |
|
opts.timestamp = resolveTimestamp(kv); |
|
const QString routeS = get(kv, "route"); |
|
if (!routeS.isEmpty() && !toRouteType(routeS, opts.routeType)) { |
|
error = QString("anon_req: invalid route '%1'").arg(routeS); |
|
return false; |
|
} |
|
|
|
frame = builders::buildAnonReq(seed, dest, data, opts); |
|
if (frame.isEmpty()) { |
|
error = "anon_req: build failed"; |
|
return false; |
|
} |
|
summary = QString("MESHCORE TX|anon_req dest=%1 ts=%2 len=%3") |
|
.arg(QString::fromLatin1(dest.toHex().left(16))) |
|
.arg(opts.timestamp) |
|
.arg(data.size()); |
|
return true; |
|
} |
|
|
|
bool buildGrpTxtFromKv(const QMap<QString, QString>& kv, |
|
QByteArray& frame, QString& summary, QString& error) |
|
{ |
|
const QString text = get(kv, "text"); |
|
if (text.isEmpty()) { |
|
error = "grp_txt: text required"; |
|
return false; |
|
} |
|
|
|
QByteArray psk; |
|
QString chanName = get(kv, "channel"); |
|
const QString pskS = get(kv, "channel_psk"); |
|
if (!pskS.isEmpty()) { |
|
psk = hex(pskS); |
|
if (psk.size() != 16 && psk.size() != 32) { |
|
error = "grp_txt: channel_psk must be 16 or 32 hex bytes"; |
|
return false; |
|
} |
|
if (chanName.isEmpty()) { |
|
chanName = "psk"; |
|
} |
|
} else if (chanName.compare("public", Qt::CaseInsensitive) == 0) { |
|
psk = builders::publicChannelPsk(); |
|
} else { |
|
error = "grp_txt: channel_psk or channel=public required"; |
|
return false; |
|
} |
|
|
|
const builders::GroupChannel ch = builders::GroupChannel::fromPsk(chanName, psk); |
|
if (!ch.isValid()) { |
|
error = "grp_txt: invalid channel"; |
|
return false; |
|
} |
|
|
|
builders::GrpTxtOptions opts; |
|
opts.timestamp = resolveTimestamp(kv); |
|
|
|
uint32_t txtType = 0, attempt = 0; |
|
const QString tt = get(kv, "txt_type"); |
|
if (!tt.isEmpty() && (!toUInt(tt, txtType) || txtType > 0x3F)) { |
|
error = "grp_txt: invalid txt_type"; |
|
return false; |
|
} |
|
const QString at = get(kv, "attempt"); |
|
if (!at.isEmpty() && (!toUInt(at, attempt) || attempt > 3)) { |
|
error = "grp_txt: invalid attempt"; |
|
return false; |
|
} |
|
opts.txtType = static_cast<uint8_t>(txtType); |
|
opts.attempt = static_cast<uint8_t>(attempt); |
|
|
|
const QString routeS = get(kv, "route"); |
|
if (!routeS.isEmpty() && !toRouteType(routeS, opts.routeType)) { |
|
error = QString("grp_txt: invalid route '%1'").arg(routeS); |
|
return false; |
|
} |
|
|
|
frame = builders::buildGrpTxt(ch, text.toUtf8(), opts); |
|
if (frame.isEmpty()) { |
|
error = "grp_txt: build failed"; |
|
return false; |
|
} |
|
summary = QString("MESHCORE TX|grp_txt channel=\"%1\" hash=%2 ts=%3 text=\"%4\"") |
|
.arg(chanName) |
|
.arg(QString::fromLatin1(ch.hash.toHex())) |
|
.arg(opts.timestamp) |
|
.arg(text); |
|
return true; |
|
} |
|
|
|
bool buildAckFromKv(const QMap<QString, QString>& kv, |
|
QByteArray& frame, QString& summary, QString& error) |
|
{ |
|
const QByteArray dest = hex(get(kv, "dest")); |
|
const QByteArray msgHash = hex(get(kv, "msg_hash")); |
|
if (dest.size() != kPubKeySize) { |
|
error = "ack: dest required"; |
|
return false; |
|
} |
|
if (msgHash.size() != 4) { |
|
error = "ack: msg_hash must be 4 hex bytes"; |
|
return false; |
|
} |
|
|
|
builders::AckOptions opts; |
|
const QString routeS = get(kv, "route"); |
|
if (!routeS.isEmpty() && !toRouteType(routeS, opts.routeType)) { |
|
error = QString("ack: invalid route '%1'").arg(routeS); |
|
return false; |
|
} |
|
|
|
frame = builders::buildAck(dest, msgHash, opts); |
|
if (frame.isEmpty()) { |
|
error = "ack: build failed"; |
|
return false; |
|
} |
|
summary = QString("MESHCORE TX|ack dest=%1 hash=%2") |
|
.arg(QString::fromLatin1(dest.toHex().left(16))) |
|
.arg(QString::fromLatin1(msgHash.toHex())); |
|
return true; |
|
} |
|
|
|
} // namespace |
|
|
|
bool buildFrameByType(const QString& typeName, |
|
const QMap<QString, QString>& kv, |
|
QByteArray& frame, |
|
QString& summary, |
|
QString& error) |
|
{ |
|
const QString t = typeName.toLower(); |
|
if (t == "advert") { return buildAdvertFromKv(kv, frame, summary, error); } |
|
if (t == "txt_msg") { return buildTxtMsgFromKv(kv, frame, summary, error); } |
|
if (t == "anon_req") { return buildAnonReqFromKv(kv, frame, summary, error); } |
|
if (t == "grp_txt") { return buildGrpTxtFromKv(kv, frame, summary, error); } |
|
if (t == "ack") { return buildAckFromKv(kv, frame, summary, error); } |
|
error = QString("unknown type: '%1' (expected advert|txt_msg|anon_req|grp_txt|ack)") |
|
.arg(typeName); |
|
return false; |
|
} |
|
|
|
} // namespace command |
|
} // namespace modemmeshcore
|
|
|