mirror of
https://github.com/mikecarper/MeshCore.git
synced 2026-09-17 01:44:25 +00:00
8387 lines
315 KiB
C++
8387 lines
315 KiB
C++
#include "MyMesh.h"
|
|
|
|
#include <Arduino.h> // needed for PlatformIO
|
|
#include <Mesh.h>
|
|
#include <helpers/CompanionHardwareCommandCompat.h>
|
|
#include <helpers/CompanionStatusResponse.h>
|
|
#include <helpers/CompanionJohn.h>
|
|
#include <helpers/IdentityGeneration.h>
|
|
#include <helpers/LazyPersistence.h>
|
|
#include <helpers/StorageLayout.h>
|
|
#include <helpers/UsbAsciiBinarySwitch.h>
|
|
#include <helpers/UsbLogging.h>
|
|
#include "helpers/radiolib/RXPowerSaving.h"
|
|
#include "helpers/radiolib/RxBoostedGainDefaults.h"
|
|
#include "helpers/radiolib/CadTiming.h"
|
|
|
|
#if defined(MESHCORE_EXTRAFS_HIL) \
|
|
&& (!defined(NRF52_PLATFORM) || !defined(EXTRAFS) || defined(QSPIFLASH))
|
|
#error "MESHCORE_EXTRAFS_HIL requires an nRF52 internal ExtraFS build"
|
|
#endif
|
|
|
|
#if COMPANION_FEATURE_MEMORY_DIAGNOSTICS
|
|
#include <helpers/CompanionTerminalDiagnostics.h>
|
|
#endif
|
|
|
|
#if defined(ESP32_PLATFORM) \
|
|
&& (defined(BOARD_HAS_PSRAM) || COMPANION_FEATURE_MEMORY_DIAGNOSTICS)
|
|
#include <esp_heap_caps.h>
|
|
#endif
|
|
|
|
#if defined(ESP32) && defined(WIFI_SSID)
|
|
#include "CompanionWiFi.h"
|
|
#include <helpers/WiFiPowerSave.h>
|
|
#endif
|
|
|
|
#if defined(ESP32_PLATFORM)
|
|
#include <helpers/ESP32TrueRandom.h>
|
|
#endif
|
|
|
|
#if defined(MESH_PRIMARY_ESPNOW) && MESH_PRIMARY_ESPNOW
|
|
#include <helpers/esp32/WiFiRadioPolicy.h>
|
|
#endif
|
|
|
|
#include <helpers/CLICommandUtils.h>
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
#include <helpers/TracePathHelpers.h>
|
|
#endif
|
|
|
|
#if COMPANION_FEATURE_OTA_CLI
|
|
#include <helpers/ota/OtaCli.h>
|
|
#endif
|
|
|
|
#if defined(WITH_MQTT_BRIDGE) && defined(ESP32_PLATFORM) && defined(WIFI_SSID)
|
|
#include <helpers/MQTTDefaults.h>
|
|
#endif
|
|
|
|
#ifdef WITH_WEBCONFIG
|
|
#include <helpers/WiFiSetupPortal.h>
|
|
#include <WiFi.h>
|
|
#include <esp_wifi.h>
|
|
#endif
|
|
|
|
static uint32_t nextRadioApplyRetryDelay(uint8_t& failure_count) {
|
|
uint8_t shift = failure_count < 5 ? failure_count : 5;
|
|
if (failure_count < 6) failure_count++;
|
|
uint32_t delay_ms = 1000UL << shift;
|
|
return delay_ms > 30000UL ? 30000UL : delay_ms;
|
|
}
|
|
|
|
static const uint32_t COMMAND_RADIO_APPLY_TIMEOUT_MS = 5000UL;
|
|
|
|
#if RXPS_FIXED_ENABLED
|
|
#if RXPS_FIXED_LEVEL < 1 || RXPS_FIXED_LEVEL > 10
|
|
#error "RXPS_FIXED_LEVEL must be between 1 and 10"
|
|
#endif
|
|
#if RXPS_FIXED_PREAMBLE != 16 && RXPS_FIXED_PREAMBLE != 32
|
|
#error "RXPS_FIXED_PREAMBLE must be 16 or 32"
|
|
#endif
|
|
#endif
|
|
|
|
#define CMD_APP_START 1
|
|
#define CMD_SEND_TXT_MSG 2
|
|
#define CMD_SEND_CHANNEL_TXT_MSG 3
|
|
#define CMD_GET_CONTACTS 4 // with optional 'since' (for efficient sync)
|
|
#define CMD_GET_DEVICE_TIME 5
|
|
#define CMD_SET_DEVICE_TIME 6
|
|
#define CMD_SEND_SELF_ADVERT 7
|
|
#define CMD_SET_ADVERT_NAME 8
|
|
#define CMD_ADD_UPDATE_CONTACT 9
|
|
#define CMD_SYNC_NEXT_MESSAGE 10
|
|
#define CMD_SET_RADIO_PARAMS 11
|
|
#define CMD_SET_RADIO_TX_POWER 12
|
|
#define CMD_RESET_PATH 13
|
|
#define CMD_SET_ADVERT_LATLON 14
|
|
#define CMD_REMOVE_CONTACT 15
|
|
#define CMD_SHARE_CONTACT 16
|
|
#define CMD_EXPORT_CONTACT 17
|
|
#define CMD_IMPORT_CONTACT 18
|
|
#define CMD_REBOOT 19
|
|
#define CMD_GET_BATT_AND_STORAGE 20 // was CMD_GET_BATTERY_VOLTAGE
|
|
#define CMD_SET_TUNING_PARAMS 21
|
|
#define CMD_DEVICE_QUERY 22
|
|
#define CMD_EXPORT_PRIVATE_KEY 23
|
|
#define CMD_IMPORT_PRIVATE_KEY 24
|
|
#define CMD_SEND_RAW_DATA 25
|
|
#define CMD_SEND_LOGIN 26
|
|
#define CMD_SEND_STATUS_REQ 27
|
|
#define CMD_HAS_CONNECTION 28
|
|
#define CMD_LOGOUT 29 // 'Disconnect'
|
|
#define CMD_GET_CONTACT_BY_KEY 30
|
|
#define CMD_GET_CHANNEL 31
|
|
#define CMD_SET_CHANNEL 32
|
|
#define CMD_SIGN_START 33
|
|
#define CMD_SIGN_DATA 34
|
|
#define CMD_SIGN_FINISH 35
|
|
#define CMD_SEND_TRACE_PATH 36
|
|
#define CMD_SET_DEVICE_PIN 37
|
|
#define CMD_SET_OTHER_PARAMS 38
|
|
#define CMD_SEND_TELEMETRY_REQ 39 // can deprecate this
|
|
#define CMD_GET_CUSTOM_VARS 40
|
|
#define CMD_SET_CUSTOM_VAR 41
|
|
#define CMD_GET_ADVERT_PATH 42
|
|
#define CMD_GET_TUNING_PARAMS 43
|
|
// NOTE: decimal command IDs 44..49 (0x2C..0x31) remain parked
|
|
#define CMD_SEND_BINARY_REQ 50
|
|
#define CMD_FACTORY_RESET 51
|
|
#define CMD_SEND_PATH_DISCOVERY_REQ 52
|
|
#define CMD_SET_FLOOD_SCOPE_KEY 54 // v8+
|
|
#define CMD_SEND_CONTROL_DATA 55 // v8+
|
|
#define CMD_GET_STATS 56 // v8+, second byte is stats type
|
|
#define CMD_SEND_ANON_REQ 57
|
|
#define CMD_SET_AUTOADD_CONFIG 58
|
|
#define CMD_GET_AUTOADD_CONFIG 59
|
|
#define CMD_GET_ALLOWED_REPEAT_FREQ 60
|
|
#define CMD_SET_PATH_HASH_MODE 61
|
|
#define CMD_SEND_CHANNEL_DATA 62
|
|
#define CMD_SET_DEFAULT_FLOOD_SCOPE 63
|
|
#define CMD_GET_DEFAULT_FLOOD_SCOPE 64
|
|
#define CMD_SEND_RAW_PACKET 65
|
|
|
|
#if defined(RADIO_FEM_RXGAIN) && (RADIO_FEM_RXGAIN == 0)
|
|
static constexpr uint8_t DEFAULT_FEM_RX_GAIN = 0;
|
|
#else
|
|
static constexpr uint8_t DEFAULT_FEM_RX_GAIN = 1;
|
|
#endif
|
|
|
|
// Stats sub-types for CMD_GET_STATS
|
|
#define STATS_TYPE_CORE 0
|
|
#define STATS_TYPE_RADIO 1
|
|
#define STATS_TYPE_PACKETS 2
|
|
|
|
#define RESP_CODE_OK 0
|
|
#define RESP_CODE_ERR 1
|
|
#define RESP_CODE_CONTACTS_START 2 // first reply to CMD_GET_CONTACTS
|
|
#define RESP_CODE_CONTACT 3 // multiple of these (after CMD_GET_CONTACTS)
|
|
#define RESP_CODE_END_OF_CONTACTS 4 // last reply to CMD_GET_CONTACTS
|
|
#define CONTACT_STREAM_FRAME_INTERVAL_MS 5 // let slow USB hosts drain accepted frames
|
|
#define RESP_CODE_SELF_INFO 5 // reply to CMD_APP_START
|
|
#define RESP_CODE_SENT 6 // reply to CMD_SEND_TXT_MSG
|
|
#define RESP_CODE_CONTACT_MSG_RECV 7 // a reply to CMD_SYNC_NEXT_MESSAGE (ver < 3)
|
|
#define RESP_CODE_CHANNEL_MSG_RECV 8 // a reply to CMD_SYNC_NEXT_MESSAGE (ver < 3)
|
|
#define RESP_CODE_CURR_TIME 9 // a reply to CMD_GET_DEVICE_TIME
|
|
#define RESP_CODE_NO_MORE_MESSAGES 10 // a reply to CMD_SYNC_NEXT_MESSAGE
|
|
#define RESP_CODE_EXPORT_CONTACT 11
|
|
#define RESP_CODE_BATT_AND_STORAGE 12 // a reply to a CMD_GET_BATT_AND_STORAGE
|
|
#define RESP_CODE_DEVICE_INFO 13 // a reply to CMD_DEVICE_QUERY
|
|
#define RESP_CODE_PRIVATE_KEY 14 // a reply to CMD_EXPORT_PRIVATE_KEY
|
|
#define RESP_CODE_DISABLED 15
|
|
#define RESP_CODE_CONTACT_MSG_RECV_V3 16 // a reply to CMD_SYNC_NEXT_MESSAGE (ver >= 3)
|
|
#define RESP_CODE_CHANNEL_MSG_RECV_V3 17 // a reply to CMD_SYNC_NEXT_MESSAGE (ver >= 3)
|
|
#define RESP_CODE_CHANNEL_INFO 18 // a reply to CMD_GET_CHANNEL
|
|
#define RESP_CODE_SIGN_START 19
|
|
#define RESP_CODE_SIGNATURE 20
|
|
#define RESP_CODE_CUSTOM_VARS 21
|
|
#define RESP_CODE_ADVERT_PATH 22
|
|
#define RESP_CODE_TUNING_PARAMS 23
|
|
#define RESP_CODE_STATS 24 // v8+, second byte is stats type
|
|
#define RESP_CODE_AUTOADD_CONFIG 25
|
|
#define RESP_ALLOWED_REPEAT_FREQ 26
|
|
#define RESP_CODE_CHANNEL_DATA_RECV 27
|
|
#define RESP_CODE_DEFAULT_FLOOD_SCOPE 28
|
|
#define RESP_CODE_CLI_REPLY 29 // v14+, a reply to CMD_RUN_CLI_COMMAND
|
|
|
|
#define MAX_CHANNEL_DATA_LENGTH (MAX_FRAME_SIZE - 9)
|
|
|
|
#define SEND_TIMEOUT_BASE_MILLIS 500
|
|
#define FLOOD_SEND_TIMEOUT_FACTOR 16.0f
|
|
#define DIRECT_SEND_PERHOP_FACTOR 6.0f
|
|
#define DIRECT_SEND_PERHOP_EXTRA_MILLIS 250
|
|
#define LAZY_CONTACTS_WRITE_DELAY 5000
|
|
#define CONTACT_PAGE_WRITE_GAP 100
|
|
#define EXPECTED_ACK_RETRY_RECHECK_MILLIS 1000
|
|
|
|
static bool save_filter(const ContactInfo& c);
|
|
|
|
#ifndef DEFAULT_MULTI_ACKS
|
|
#define DEFAULT_MULTI_ACKS 0
|
|
#endif
|
|
#ifndef DEFAULT_PATH_HASH_MODE
|
|
#define DEFAULT_PATH_HASH_MODE 0
|
|
#endif
|
|
#ifndef DEFAULT_MANUAL_ADD_CONTACTS
|
|
#define DEFAULT_MANUAL_ADD_CONTACTS 0
|
|
#endif
|
|
#ifndef DEFAULT_AUTOADD_CONFIG
|
|
#define DEFAULT_AUTOADD_CONFIG 0
|
|
#endif
|
|
#ifndef DEFAULT_BUZZER_QUIET
|
|
#define DEFAULT_BUZZER_QUIET 0
|
|
#endif
|
|
#ifndef DEFAULT_CAD_ENABLED
|
|
// Preserve the tuned Companion behavior that preceded the runtime setting.
|
|
#define DEFAULT_CAD_ENABLED 1
|
|
#endif
|
|
|
|
#ifndef EMERGENCY_CLIENT_REPEAT_HOLD_MS
|
|
#define EMERGENCY_CLIENT_REPEAT_HOLD_MS 120000UL
|
|
#endif
|
|
#ifndef EMERGENCY_CLIENT_REPEAT_JITTER_MS
|
|
#define EMERGENCY_CLIENT_REPEAT_JITTER_MS 15000UL
|
|
#endif
|
|
|
|
#define PUBLIC_GROUP_PSK "izOH6cXN6mrJ5e26oRXNcg=="
|
|
// First 16 bytes of SHA-256("#testing"), encoded as base64.
|
|
#define TESTING_GROUP_PSK "zeXoLPUVZH3LVHp5pPBl0Q=="
|
|
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
static const char* terminalContactTypeName(uint8_t type) {
|
|
if (type == ADV_TYPE_CHAT) return "Chat";
|
|
if (type == ADV_TYPE_REPEATER) return "Repeater";
|
|
if (type == ADV_TYPE_ROOM) return "Room";
|
|
if (type == ADV_TYPE_SENSOR) return "Sensor";
|
|
return "Unknown";
|
|
}
|
|
#endif
|
|
|
|
// these are _pushed_ to client app at any time
|
|
#define PUSH_CODE_ADVERT 0x80
|
|
#define PUSH_CODE_PATH_UPDATED 0x81
|
|
#define PUSH_CODE_SEND_CONFIRMED 0x82
|
|
#define PUSH_CODE_MSG_WAITING 0x83
|
|
#define PUSH_CODE_RAW_DATA 0x84
|
|
#define PUSH_CODE_LOGIN_SUCCESS 0x85
|
|
#define PUSH_CODE_LOGIN_FAIL 0x86
|
|
#define PUSH_CODE_STATUS_RESPONSE 0x87
|
|
#define PUSH_CODE_LOG_RX_DATA 0x88
|
|
#define PUSH_CODE_TRACE_DATA 0x89
|
|
#define PUSH_CODE_NEW_ADVERT 0x8A
|
|
#define PUSH_CODE_TELEMETRY_RESPONSE 0x8B
|
|
#define PUSH_CODE_BINARY_RESPONSE 0x8C
|
|
#define PUSH_CODE_PATH_DISCOVERY_RESPONSE 0x8D
|
|
|
|
static const uint8_t EMERGENCY_CHANNEL_SECRET[CIPHER_KEY_SIZE] = {
|
|
0xe1, 0xad, 0x57, 0x8d, 0x25, 0x10, 0x8e, 0x34,
|
|
0x48, 0x08, 0xf3, 0x0d, 0xfd, 0xaa, 0xf9, 0x26
|
|
};
|
|
|
|
#define EMERGENCY_CLIENT_REPEAT_TABLE_SIZE 63
|
|
static uint16_t emergency_client_repeats[EMERGENCY_CLIENT_REPEAT_TABLE_SIZE];
|
|
static uint8_t emergency_client_repeat_next;
|
|
static unsigned long emergency_client_repeat_send_at;
|
|
static uint16_t emergency_client_repeat_key;
|
|
static mesh::Packet* emergency_client_repeat_packet;
|
|
|
|
#define PUSH_CODE_CONTROL_DATA 0x8E // v8+
|
|
#define PUSH_CODE_CONTACT_DELETED 0x8F // used to notify client app of deleted contact when overwriting oldest
|
|
#define PUSH_CODE_CONTACTS_FULL 0x90 // used to notify client app that contacts storage is full
|
|
|
|
#define ERR_CODE_UNSUPPORTED_CMD 1
|
|
#define ERR_CODE_NOT_FOUND 2
|
|
#define ERR_CODE_TABLE_FULL 3
|
|
#define ERR_CODE_BAD_STATE 4
|
|
#define ERR_CODE_FILE_IO_ERROR 5
|
|
#define ERR_CODE_ILLEGAL_ARG 6
|
|
|
|
#define MAX_SIGN_DATA_LEN (8 * 1024) // 8K
|
|
static constexpr unsigned long SIGN_SESSION_TIMEOUT_MILLIS = 120000;
|
|
|
|
// Auto-add config bitmask
|
|
// Bit 0: If set, overwrite oldest non-favourite contact when contacts file is full
|
|
// Bits 1-4: these indicate which contact types to auto-add when manual_contact_mode = 0x01
|
|
#define AUTO_ADD_OVERWRITE_OLDEST (1 << 0) // 0x01 - overwrite oldest non-favourite when full
|
|
#define AUTO_ADD_CHAT (1 << 1) // 0x02 - auto-add Chat (Companion) (ADV_TYPE_CHAT)
|
|
#define AUTO_ADD_REPEATER (1 << 2) // 0x04 - auto-add Repeater (ADV_TYPE_REPEATER)
|
|
#define AUTO_ADD_ROOM_SERVER (1 << 3) // 0x08 - auto-add Room Server (ADV_TYPE_ROOM)
|
|
#define AUTO_ADD_SENSOR (1 << 4) // 0x10 - auto-add Sensor (ADV_TYPE_SENSOR)
|
|
|
|
void MyMesh::writeOKFrame(BaseSerialInterface* route) {
|
|
uint8_t buf[1];
|
|
buf[0] = RESP_CODE_OK;
|
|
if (route != NULL) {
|
|
_serial->writeFrameToRoute(route, buf, 1);
|
|
} else {
|
|
_serial->writeFrame(buf, 1);
|
|
}
|
|
}
|
|
void MyMesh::writeErrFrame(uint8_t err_code, BaseSerialInterface* route) {
|
|
uint8_t buf[2];
|
|
buf[0] = RESP_CODE_ERR;
|
|
buf[1] = err_code;
|
|
if (route != NULL) {
|
|
_serial->writeFrameToRoute(route, buf, 2);
|
|
} else {
|
|
_serial->writeFrame(buf, 2);
|
|
}
|
|
}
|
|
|
|
size_t MyMesh::writePendingSerialFrame(const uint8_t frame[], size_t len) {
|
|
if (_serial == NULL || pending_serial_reply_route == NULL) return 0;
|
|
return _serial->writeFrameToRoute(pending_serial_reply_route, frame, len);
|
|
}
|
|
|
|
void MyMesh::writeDisabledFrame() {
|
|
uint8_t buf[1];
|
|
buf[0] = RESP_CODE_DISABLED;
|
|
_serial->writeFrame(buf, 1);
|
|
}
|
|
|
|
bool MyMesh::writeContactRespFrame(uint8_t code, const ContactInfo &contact) {
|
|
int i = 0;
|
|
out_frame[i++] = code;
|
|
memcpy(&out_frame[i], contact.id.pub_key, PUB_KEY_SIZE);
|
|
i += PUB_KEY_SIZE;
|
|
out_frame[i++] = contact.type;
|
|
out_frame[i++] = contact.flags;
|
|
out_frame[i++] = contact.out_path_len;
|
|
if (!contact.copyPathTo(&out_frame[i])) return false;
|
|
i += MAX_PATH_SIZE;
|
|
StrHelper::strzcpy((char *)&out_frame[i], contact.name, 32);
|
|
i += 32;
|
|
memcpy(&out_frame[i], &contact.last_advert_timestamp, 4);
|
|
i += 4;
|
|
memcpy(&out_frame[i], &contact.gps_lat, 4);
|
|
i += 4;
|
|
memcpy(&out_frame[i], &contact.gps_lon, 4);
|
|
i += 4;
|
|
memcpy(&out_frame[i], &contact.lastmod, 4);
|
|
i += 4;
|
|
return _serial->writeFrame(out_frame, i) == (size_t)i;
|
|
}
|
|
|
|
void MyMesh::stopContactsIterator() {
|
|
_iter_pending_contact = ContactInfo();
|
|
if (!_iter_started) return;
|
|
_iter_started = false;
|
|
_iter_start_pending = false;
|
|
_iter_contact_pending = false;
|
|
_iter_next_frame_at = 0;
|
|
if (_serial != NULL) _serial->unlockReplyRoute();
|
|
}
|
|
|
|
static constexpr int CONTACT_UPDATE_FRAME_MIN_LEN =
|
|
1 + PUB_KEY_SIZE + 1 + 1 + 1 + MAX_PATH_SIZE + 32 + 4;
|
|
static constexpr int CONTACT_UPDATE_FRAME_GPS_LEN =
|
|
CONTACT_UPDATE_FRAME_MIN_LEN + 8;
|
|
static constexpr int CONTACT_UPDATE_FRAME_LASTMOD_LEN =
|
|
CONTACT_UPDATE_FRAME_GPS_LEN + 4;
|
|
|
|
static bool isPersistentContactType(uint8_t type) {
|
|
return type == ADV_TYPE_CHAT || type == ADV_TYPE_REPEATER
|
|
|| type == ADV_TYPE_ROOM || type == ADV_TYPE_SENSOR;
|
|
}
|
|
|
|
bool MyMesh::updateContactFromFrame(ContactInfo &contact, uint32_t& last_mod, const uint8_t *frame, int len) {
|
|
if (frame == NULL || len < CONTACT_UPDATE_FRAME_MIN_LEN
|
|
|| (len > CONTACT_UPDATE_FRAME_MIN_LEN
|
|
&& len < CONTACT_UPDATE_FRAME_GPS_LEN)
|
|
|| (len > CONTACT_UPDATE_FRAME_GPS_LEN
|
|
&& len < CONTACT_UPDATE_FRAME_LASTMOD_LEN)
|
|
|| frame[0] != CMD_ADD_UPDATE_CONTACT) {
|
|
return false;
|
|
}
|
|
|
|
const uint8_t type = frame[1 + PUB_KEY_SIZE];
|
|
const uint8_t out_path_len = frame[1 + PUB_KEY_SIZE + 1 + 1];
|
|
if (!isPersistentContactType(type)
|
|
|| (out_path_len != OUT_PATH_UNKNOWN
|
|
&& !mesh::Packet::isValidPathLen(out_path_len))) {
|
|
return false;
|
|
}
|
|
|
|
int i = 1; // command byte
|
|
memcpy(contact.id.pub_key, &frame[i], PUB_KEY_SIZE);
|
|
i += PUB_KEY_SIZE;
|
|
contact.type = frame[i++];
|
|
contact.flags = frame[i++];
|
|
contact.out_path_len = frame[i++];
|
|
if (!contact.setRawPath(&frame[i])) return false;
|
|
i += MAX_PATH_SIZE;
|
|
memcpy(contact.name, &frame[i], 32);
|
|
contact.name[sizeof(contact.name) - 1] = 0;
|
|
i += 32;
|
|
memcpy(&contact.last_advert_timestamp, &frame[i], 4);
|
|
i += 4;
|
|
if (len >= CONTACT_UPDATE_FRAME_GPS_LEN) { // optional fields
|
|
memcpy(&contact.gps_lat, &frame[i], 4);
|
|
i += 4;
|
|
memcpy(&contact.gps_lon, &frame[i], 4);
|
|
i += 4;
|
|
if (len >= CONTACT_UPDATE_FRAME_LASTMOD_LEN) {
|
|
memcpy(&last_mod, &frame[i], 4);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool MyMesh::Frame::isChannelMsg() const {
|
|
return len > 0 && (buf[0] == RESP_CODE_CHANNEL_MSG_RECV || buf[0] == RESP_CODE_CHANNEL_MSG_RECV_V3 ||
|
|
buf[0] == RESP_CODE_CHANNEL_DATA_RECV);
|
|
}
|
|
|
|
int MyMesh::getOfflineQueueCapacity() const {
|
|
#if defined(OTA_SHARED_COMPANION_QUEUE)
|
|
return offline_queue.capacity();
|
|
#elif defined(ESP32_PLATFORM) && defined(BOARD_HAS_PSRAM)
|
|
return offline_queue_capacity;
|
|
#else
|
|
return OFFLINE_QUEUE_SIZE;
|
|
#endif
|
|
}
|
|
|
|
MyMesh::Frame& MyMesh::offlineQueueFrameAt(int logical_index) {
|
|
#if defined(OTA_SHARED_COMPANION_QUEUE)
|
|
return offline_queue.at((offline_queue_head + logical_index) % getOfflineQueueCapacity());
|
|
#else
|
|
return offline_queue[(offline_queue_head + logical_index) % getOfflineQueueCapacity()];
|
|
#endif
|
|
}
|
|
|
|
#if defined(OTA_SHARED_COMPANION_QUEUE)
|
|
mesh::ota::OtaContext* MyMesh::acquireOfflineQueueForOta(void* owner) {
|
|
MyMesh* mesh = static_cast<MyMesh*>(owner);
|
|
return mesh->offline_queue.acquire(mesh->offline_queue_len, mesh->offline_queue_head);
|
|
}
|
|
|
|
void MyMesh::releaseOfflineQueueFromOta(void* owner) {
|
|
MyMesh* mesh = static_cast<MyMesh*>(owner);
|
|
mesh->offline_queue.release(mesh->offline_queue_head);
|
|
}
|
|
#endif
|
|
|
|
void MyMesh::initializeOfflineQueue() {
|
|
#if defined(OTA_SHARED_COMPANION_QUEUE)
|
|
mesh::ota::ota_set_context_storage(this, acquireOfflineQueueForOta, releaseOfflineQueueFromOta);
|
|
#elif defined(ESP32_PLATFORM) && defined(BOARD_HAS_PSRAM)
|
|
if (offline_queue != offline_queue_fallback || OFFLINE_QUEUE_SIZE <= offline_queue_capacity) return;
|
|
|
|
int requested_capacity = OFFLINE_QUEUE_SIZE;
|
|
while (requested_capacity > offline_queue_capacity) {
|
|
void* storage = heap_caps_malloc(sizeof(Frame) * requested_capacity,
|
|
MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
|
|
if (storage) {
|
|
offline_queue = static_cast<Frame*>(storage);
|
|
offline_queue_capacity = requested_capacity;
|
|
return;
|
|
}
|
|
|
|
if (requested_capacity > 256) {
|
|
requested_capacity = 256;
|
|
} else if (requested_capacity > 128) {
|
|
requested_capacity = 128;
|
|
} else {
|
|
requested_capacity = offline_queue_capacity;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void MyMesh::addToOfflineQueue(const uint8_t frame[], int len) {
|
|
const int capacity = getOfflineQueueCapacity();
|
|
if (!frame || len <= 0 || len > MAX_FRAME_SIZE || capacity <= 0) {
|
|
MESH_DEBUG_PRINTLN("WARN: invalid offline queue frame length: %d", len);
|
|
return;
|
|
}
|
|
|
|
if (offline_queue_len >= capacity) {
|
|
MESH_DEBUG_PRINTLN("WARN: offline_queue is full!");
|
|
int pos = 0;
|
|
while (pos < offline_queue_len) {
|
|
if (offlineQueueFrameAt(pos).isChannelMsg()) {
|
|
for (int i = pos; i < offline_queue_len - 1; i++) { // delete oldest channel msg from queue
|
|
offlineQueueFrameAt(i) = offlineQueueFrameAt(i + 1);
|
|
}
|
|
MESH_DEBUG_PRINTLN("INFO: removed oldest channel message from queue.");
|
|
Frame& tail = offlineQueueFrameAt(offline_queue_len - 1);
|
|
tail.len = len;
|
|
memcpy(tail.buf, frame, len);
|
|
return;
|
|
}
|
|
pos++;
|
|
}
|
|
MESH_DEBUG_PRINTLN("INFO: no channel messages to remove from queue.");
|
|
} else {
|
|
Frame& tail = offlineQueueFrameAt(offline_queue_len);
|
|
tail.len = len;
|
|
memcpy(tail.buf, frame, len);
|
|
offline_queue_len++;
|
|
}
|
|
}
|
|
|
|
int MyMesh::getFromOfflineQueue(uint8_t frame[]) {
|
|
if (offline_queue_len > 0) { // check offline queue
|
|
Frame& head = offlineQueueFrameAt(0);
|
|
size_t len = head.len; // take from top of queue
|
|
memcpy(frame, head.buf, len);
|
|
|
|
offline_queue_len--;
|
|
if (offline_queue_len == 0) {
|
|
offline_queue_head = 0;
|
|
} else {
|
|
offline_queue_head = (offline_queue_head + 1) % getOfflineQueueCapacity();
|
|
}
|
|
return len;
|
|
}
|
|
return 0; // queue is empty
|
|
}
|
|
|
|
float MyMesh::getAirtimeBudgetFactor() const {
|
|
// TempRadio is a short-lived, explicitly coordinated OTA channel. Let its
|
|
// primary transfer use the full dispatcher budget; the persisted public
|
|
// channel duty factor becomes authoritative again as soon as TempRadio ends.
|
|
#if COMPANION_FEATURE_TEMP_RADIO
|
|
if (isTempRadioActive()) return 0.0f;
|
|
#endif
|
|
return _prefs.airtime_factor;
|
|
}
|
|
|
|
bool MyMesh::getCADEnabled() const {
|
|
return _prefs.cad_enabled != 0;
|
|
}
|
|
|
|
uint32_t MyMesh::getCADFailRetryDelay() const {
|
|
return _prefs.cad_retry_delay_ms != 0
|
|
? _prefs.cad_retry_delay_ms
|
|
: BaseChatMesh::getCADFailRetryDelay();
|
|
}
|
|
|
|
uint32_t MyMesh::getCADFailMaxDuration() const {
|
|
return _prefs.cad_max_duration_ms != 0
|
|
? _prefs.cad_max_duration_ms
|
|
: mesh::Dispatcher::getCADFailMaxDuration();
|
|
}
|
|
|
|
int MyMesh::getInterferenceThreshold() const {
|
|
return 0; // disabled for now, until currentRSSI() problem is resolved
|
|
}
|
|
|
|
int MyMesh::calcRxDelay(float score, uint32_t air_time) const {
|
|
if (_prefs.rx_delay_base <= 0.0f) return 0;
|
|
return (int)((powf(_prefs.rx_delay_base, 0.85f - score) - 1.0f) * air_time);
|
|
}
|
|
|
|
uint32_t MyMesh::getRetransmitDelay(const mesh::Packet *packet) {
|
|
uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * 0.5f);
|
|
return getRNG()->nextInt(0, 5*t + 1);
|
|
}
|
|
uint32_t MyMesh::getDirectRetransmitDelay(const mesh::Packet *packet) {
|
|
uint32_t t = (_radio->getEstAirtimeFor(packet->getPathByteLen() + packet->payload_len + 2) * 0.2f);
|
|
return getRNG()->nextInt(0, 5*t + 1);
|
|
}
|
|
|
|
uint8_t MyMesh::getExtraAckTransmitCount() const {
|
|
return _prefs.multi_acks;
|
|
}
|
|
|
|
bool MyMesh::hasLocationTelemetryRecipient() {
|
|
if (_prefs.telemetry_mode_loc == TELEM_MODE_DENY) return false;
|
|
|
|
ContactsIterator iter = startContactsIterator();
|
|
ContactInfo contact;
|
|
while (iter.hasNext(this, contact)) {
|
|
if (contact.type == ADV_TYPE_NONE) continue;
|
|
if (_prefs.telemetry_mode_loc == TELEM_MODE_ALLOW_ALL) return true;
|
|
if (_prefs.telemetry_mode_loc == TELEM_MODE_ALLOW_FLAGS &&
|
|
((contact.flags >> 1) & TELEM_PERM_LOCATION)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void MyMesh::updateGpsTelemetryPolicy() {
|
|
sensors.setTelemetryLocationAccessAvailable(hasLocationTelemetryRecipient());
|
|
}
|
|
|
|
void MyMesh::logRxRaw(float snr, float rssi, const uint8_t raw[], int len) {
|
|
#if defined(WITH_MQTT_BRIDGE) && defined(ESP32_PLATFORM) && defined(WIFI_SSID)
|
|
if (_mqtt_bridge && _mqtt_bridge->isRunning()) {
|
|
_mqtt_bridge->storeRawRadioData(raw, len, snr, rssi);
|
|
}
|
|
#endif
|
|
|
|
if (_serial->isConnected() && len + 3 <= MAX_FRAME_SIZE) {
|
|
int i = 0;
|
|
out_frame[i++] = PUSH_CODE_LOG_RX_DATA;
|
|
out_frame[i++] = (int8_t)(snr * 4);
|
|
out_frame[i++] = (int8_t)(rssi);
|
|
memcpy(&out_frame[i], raw, len);
|
|
i += len;
|
|
|
|
_serial->writeFrame(out_frame, i);
|
|
}
|
|
}
|
|
|
|
#if defined(WITH_MQTT_BRIDGE) && defined(ESP32_PLATFORM) && defined(WIFI_SSID)
|
|
void MyMesh::logRx(mesh::Packet* packet, int, float) {
|
|
if (_mqtt_bridge && _mqtt_bridge->isRunning()) {
|
|
_mqtt_bridge->onPacketReceived(packet);
|
|
}
|
|
}
|
|
|
|
void MyMesh::logTx(mesh::Packet* packet, int) {
|
|
if (_mqtt_bridge && _mqtt_bridge->isRunning()) {
|
|
_mqtt_bridge->sendPacket(packet);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
bool MyMesh::isAutoAddEnabled() const {
|
|
return (_prefs.manual_add_contacts & 1) == 0;
|
|
}
|
|
|
|
bool MyMesh::shouldAutoAddContactType(uint8_t contact_type) const {
|
|
if ((_prefs.manual_add_contacts & 1) == 0) {
|
|
return true;
|
|
}
|
|
|
|
uint8_t type_bit = 0;
|
|
switch (contact_type) {
|
|
case ADV_TYPE_CHAT:
|
|
type_bit = AUTO_ADD_CHAT;
|
|
break;
|
|
case ADV_TYPE_REPEATER:
|
|
type_bit = AUTO_ADD_REPEATER;
|
|
break;
|
|
case ADV_TYPE_ROOM:
|
|
type_bit = AUTO_ADD_ROOM_SERVER;
|
|
break;
|
|
case ADV_TYPE_SENSOR:
|
|
type_bit = AUTO_ADD_SENSOR;
|
|
break;
|
|
default:
|
|
return false; // Unknown type, don't auto-add
|
|
}
|
|
|
|
return (_prefs.autoadd_config & type_bit) != 0;
|
|
}
|
|
|
|
bool MyMesh::shouldOverwriteWhenFull() const {
|
|
return (_prefs.autoadd_config & AUTO_ADD_OVERWRITE_OLDEST) != 0;
|
|
}
|
|
|
|
uint8_t MyMesh::getAutoAddMaxHops() const {
|
|
return _prefs.autoadd_max_hops;
|
|
}
|
|
|
|
bool MyMesh::canMutateContacts() const {
|
|
return !_store->hasIncompleteContactLoad();
|
|
}
|
|
|
|
bool MyMesh::onContactOverwrite(const ContactInfo& contact) {
|
|
uint16_t released_slot = mesh::storage::CONTACT_SLOT_NONE;
|
|
if (!scheduleContactWriteAfterRelease(contact, released_slot)) {
|
|
MESH_DEBUG_PRINTLN(
|
|
"Contact overwrite refused: persistent slot release failed");
|
|
return false;
|
|
}
|
|
if (!_store->deleteBlobByKey(contact.id.pub_key, PUB_KEY_SIZE)) {
|
|
// releaseContact() is failure-atomic and this single-threaded path still
|
|
// owns the just-freed slot. Put it back before refusing the overwrite so a
|
|
// full filesystem cannot silently retain stale advert state for a contact
|
|
// which the live table has already replaced.
|
|
if (!restoreContactWriteAfterRelease(contact, released_slot)) {
|
|
MESH_DEBUG_PRINTLN(
|
|
"Contact overwrite rollback failed after advert-cache error");
|
|
}
|
|
MESH_DEBUG_PRINTLN(
|
|
"Contact overwrite refused: advert-cache deletion failed");
|
|
return false;
|
|
}
|
|
if (_serial != NULL && _serial->isConnected()) {
|
|
out_frame[0] = PUSH_CODE_CONTACT_DELETED;
|
|
memcpy(&out_frame[1], contact.id.pub_key, PUB_KEY_SIZE);
|
|
_serial->writeFrame(out_frame, 1 + PUB_KEY_SIZE);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void MyMesh::onContactsFull() {
|
|
if (_serial != NULL && _serial->isConnected()) {
|
|
out_frame[0] = PUSH_CODE_CONTACTS_FULL;
|
|
_serial->writeFrame(out_frame, 1);
|
|
}
|
|
}
|
|
|
|
void MyMesh::onDiscoveredContact(ContactInfo &contact, bool is_new, uint8_t path_len, const uint8_t* path) {
|
|
if (_serial->isConnected()) {
|
|
if (is_new) {
|
|
writeContactRespFrame(PUSH_CODE_NEW_ADVERT, contact);
|
|
} else {
|
|
out_frame[0] = PUSH_CODE_ADVERT;
|
|
memcpy(&out_frame[1], contact.id.pub_key, PUB_KEY_SIZE);
|
|
_serial->writeFrame(out_frame, 1 + PUB_KEY_SIZE);
|
|
}
|
|
} else {
|
|
#ifdef DISPLAY_CLASS
|
|
if (_ui) _ui->notify(UIEventType::newContactMessage);
|
|
#endif
|
|
}
|
|
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
if (hasTerminalOutput() && _terminal_display.shouldShowAdvert()) {
|
|
Stream& output = terminalOutput();
|
|
output.printf("\r\nADVERT from -> %s\r\n", contact.name);
|
|
output.printf(" type: %s\r\n", terminalContactTypeName(contact.type));
|
|
output.print(" public key: ");
|
|
mesh::Utils::printHex(output, contact.id.pub_key, PUB_KEY_SIZE);
|
|
output.print("\r\n> ");
|
|
}
|
|
#endif
|
|
|
|
// add inbound-path to mem cache
|
|
if (path && mesh::Packet::isValidPathLen(path_len)) { // check path is valid
|
|
AdvertPath* p = advert_paths;
|
|
uint32_t oldest = 0xFFFFFFFF;
|
|
for (int i = 0; i < ADVERT_PATH_TABLE_SIZE; i++) { // check if already in table, otherwise evict oldest
|
|
if (memcmp(advert_paths[i].pubkey_prefix, contact.id.pub_key, sizeof(AdvertPath::pubkey_prefix)) == 0) {
|
|
p = &advert_paths[i]; // found
|
|
break;
|
|
}
|
|
if (advert_paths[i].recv_timestamp < oldest) {
|
|
oldest = advert_paths[i].recv_timestamp;
|
|
p = &advert_paths[i];
|
|
}
|
|
}
|
|
|
|
memcpy(p->pubkey_prefix, contact.id.pub_key, sizeof(p->pubkey_prefix));
|
|
strcpy(p->name, contact.name);
|
|
p->recv_timestamp = getRTCClock()->getCurrentTime();
|
|
p->path_len = mesh::Packet::copyPath(p->path, path, path_len);
|
|
}
|
|
|
|
ContactInfo* stored = lookupContactByPubKey(contact.id.pub_key, PUB_KEY_SIZE);
|
|
if (stored == &contact) scheduleContactWrite(contact);
|
|
updateGpsTelemetryPolicy();
|
|
}
|
|
|
|
static int sort_by_recent(const void *a, const void *b) {
|
|
return ((AdvertPath *) b)->recv_timestamp - ((AdvertPath *) a)->recv_timestamp;
|
|
}
|
|
|
|
int MyMesh::getRecentlyHeard(AdvertPath dest[], int max_num) {
|
|
if (max_num > ADVERT_PATH_TABLE_SIZE) max_num = ADVERT_PATH_TABLE_SIZE;
|
|
qsort(advert_paths, ADVERT_PATH_TABLE_SIZE, sizeof(advert_paths[0]), sort_by_recent);
|
|
|
|
for (int i = 0; i < max_num; i++) {
|
|
dest[i] = advert_paths[i];
|
|
}
|
|
return max_num;
|
|
}
|
|
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
void MyMesh::onContactVisit(const ContactInfo& contact) {
|
|
if (contact.type == ADV_TYPE_NONE) return;
|
|
|
|
Stream& output = terminalOutput();
|
|
output.printf(" %s (%s) - ", contact.name, terminalContactTypeName(contact.type));
|
|
char relative_time[40];
|
|
int32_t seconds_from_now = contact.last_advert_timestamp - getRTCClock()->getCurrentTime();
|
|
AdvertTimeHelper::formatRelativeTimeDiff(relative_time, seconds_from_now, false);
|
|
output.println(relative_time);
|
|
}
|
|
#endif
|
|
|
|
void MyMesh::onContactPathUpdated(const ContactInfo &contact) {
|
|
out_frame[0] = PUSH_CODE_PATH_UPDATED;
|
|
memcpy(&out_frame[1], contact.id.pub_key, PUB_KEY_SIZE);
|
|
_serial->writeFrame(out_frame, 1 + PUB_KEY_SIZE); // NOTE: app may not be connected
|
|
|
|
scheduleContactWrite(contact);
|
|
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
if (hasTerminalOutput()) {
|
|
terminalOutput().printf("\r\nPATH updated -> %s\r\n> ", contact.name);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void MyMesh::clearExpectedAck(AckTableEntry& entry, bool cancel_retries) {
|
|
if (cancel_retries && entry.ack != 0) {
|
|
cancelActiveRetries(entry.retry_key);
|
|
}
|
|
memset(&entry, 0, sizeof(entry));
|
|
}
|
|
|
|
void MyMesh::expireExpectedAcks() {
|
|
unsigned long now = _ms->getMillis();
|
|
unsigned long nearest_delay = 0;
|
|
has_next_ack_expiry = false;
|
|
|
|
for (int i = 0; i < EXPECTED_ACK_TABLE_SIZE; i++) {
|
|
AckTableEntry& entry = expected_ack_table[i];
|
|
if (entry.ack == 0) {
|
|
continue;
|
|
}
|
|
|
|
if (entry.reply_route != NULL
|
|
&& !_serial->isReplyRouteAvailable(entry.reply_route)) {
|
|
// The requesting transport owns only the eventual ACK notification,
|
|
// not the already-accepted radio transmission. Detach a vanished host
|
|
// without cancelling Mesh's retry sequence or forgetting the semantic
|
|
// ACK match; a late ACK can still stop those retries safely.
|
|
entry.reply_route = NULL;
|
|
}
|
|
|
|
if (entry.expires_at == now || millisHasNowPassed(entry.expires_at)) {
|
|
if (!hasActiveRetries(entry.retry_key)) {
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
if (entry.terminal_origin && hasTerminalOutput()) {
|
|
terminalOutput().print("\r\n ERROR: timed out, no ACK.\r\n> ");
|
|
}
|
|
#endif
|
|
clearExpectedAck(entry, false);
|
|
continue;
|
|
}
|
|
// Keep the semantic match alive while its lower-level retry sequence is
|
|
// active, so a newer app submission can replace that sequence cleanly.
|
|
entry.expires_at = futureMillis(EXPECTED_ACK_RETRY_RECHECK_MILLIS);
|
|
}
|
|
|
|
unsigned long delay = entry.expires_at - now;
|
|
if (!has_next_ack_expiry || delay < nearest_delay) {
|
|
nearest_delay = delay;
|
|
next_ack_expiry = entry.expires_at;
|
|
has_next_ack_expiry = true;
|
|
}
|
|
}
|
|
|
|
if (!has_next_ack_expiry) {
|
|
next_ack_expiry = 0;
|
|
}
|
|
}
|
|
|
|
MyMesh::AckTableEntry* MyMesh::findPendingTextMessage(
|
|
const uint8_t text_fingerprint[MAX_HASH_SIZE], uint32_t message_timestamp) {
|
|
expireExpectedAcks();
|
|
for (int i = 0; i < EXPECTED_ACK_TABLE_SIZE; i++) {
|
|
AckTableEntry& entry = expected_ack_table[i];
|
|
if (entry.ack != 0
|
|
&& entry.message_timestamp != message_timestamp
|
|
&& memcmp(entry.text_fingerprint, text_fingerprint, MAX_HASH_SIZE) == 0
|
|
&& hasActiveRetries(entry.retry_key)) {
|
|
return &entry;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
ContactInfo* MyMesh::processAck(const uint8_t *data) {
|
|
expireExpectedAcks();
|
|
|
|
// see if matches any in a table
|
|
for (int i = 0; i < EXPECTED_ACK_TABLE_SIZE; i++) {
|
|
if (expected_ack_table[i].ack != 0
|
|
&& memcmp(data, &expected_ack_table[i].ack, 4) == 0) { // got an ACK from recipient
|
|
out_frame[0] = PUSH_CODE_SEND_CONFIRMED;
|
|
memcpy(&out_frame[1], data, 4);
|
|
uint32_t trip_time = _ms->getMillis() - expected_ack_table[i].msg_sent;
|
|
memcpy(&out_frame[5], &trip_time, 4);
|
|
if (expected_ack_table[i].reply_route != NULL) {
|
|
_serial->writeFrameToRoute(expected_ack_table[i].reply_route,
|
|
out_frame, 9);
|
|
}
|
|
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
if (expected_ack_table[i].terminal_origin && hasTerminalOutput()) {
|
|
terminalOutput().printf("\r\n Got ACK! (round trip: %lu ms)\r\n> ",
|
|
(unsigned long)trip_time);
|
|
}
|
|
#endif
|
|
|
|
// NOTE: the same ACK can be received multiple times!
|
|
ContactInfo* contact = expected_ack_table[i].contact;
|
|
clearExpectedAck(expected_ack_table[i]);
|
|
expireExpectedAcks();
|
|
return contact;
|
|
}
|
|
}
|
|
return checkConnectionsAck(data);
|
|
}
|
|
|
|
void MyMesh::queueMessage(const ContactInfo &from, uint8_t txt_type, mesh::Packet *pkt,
|
|
uint32_t sender_timestamp, const uint8_t *extra,
|
|
int extra_len, const char *text,
|
|
bool terminal_command_reply,
|
|
uint32_t terminal_command_elapsed_millis) {
|
|
int i = 0;
|
|
if (app_target_ver >= 3) {
|
|
out_frame[i++] = RESP_CODE_CONTACT_MSG_RECV_V3;
|
|
out_frame[i++] = (int8_t)(pkt->getSNR() * 4);
|
|
out_frame[i++] = 0; // reserved1
|
|
out_frame[i++] = 0; // reserved2
|
|
} else {
|
|
out_frame[i++] = RESP_CODE_CONTACT_MSG_RECV;
|
|
}
|
|
memcpy(&out_frame[i], from.id.pub_key, 6);
|
|
i += 6; // just 6-byte prefix
|
|
uint8_t path_len = out_frame[i++] = pkt->isRouteFlood() ? pkt->path_len : 0xFF;
|
|
out_frame[i++] = txt_type;
|
|
memcpy(&out_frame[i], &sender_timestamp, 4);
|
|
i += 4;
|
|
if (extra_len > 0) {
|
|
memcpy(&out_frame[i], extra, extra_len);
|
|
i += extra_len;
|
|
}
|
|
int tlen = strlen(text); // TODO: UTF-8 ??
|
|
if (i + tlen > MAX_FRAME_SIZE) {
|
|
tlen = MAX_FRAME_SIZE - i;
|
|
}
|
|
memcpy(&out_frame[i], text, tlen);
|
|
i += tlen;
|
|
addToOfflineQueue(out_frame, i);
|
|
|
|
if (_serial->isConnected()) {
|
|
uint8_t frame[1];
|
|
frame[0] = PUSH_CODE_MSG_WAITING; // send push 'tickle'
|
|
_serial->writeFrame(frame, 1);
|
|
}
|
|
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
if (hasTerminalOutput()) {
|
|
Stream& output = terminalOutput();
|
|
const char* kind = txt_type == TXT_TYPE_CLI_DATA ? "CLI" : "MSG";
|
|
output.printf("\r\n(%s) %s -> from %s",
|
|
mesh::cli::terminalInboundRouteLabel(pkt->isRouteDirect()),
|
|
kind, from.name);
|
|
if (terminal_command_reply) {
|
|
output.printf(" (round trip %lu ms)",
|
|
(unsigned long)terminal_command_elapsed_millis);
|
|
}
|
|
output.printf("\r\n %s\r\n> ", text);
|
|
}
|
|
#endif
|
|
|
|
#ifdef DISPLAY_CLASS
|
|
// we only want to show text messages on display, not cli data
|
|
bool should_display = txt_type == TXT_TYPE_PLAIN || txt_type == TXT_TYPE_SIGNED_PLAIN;
|
|
if (should_display && _ui) {
|
|
_ui->newMsg(path_len, from.name, text, offline_queue_len);
|
|
if (!_serial->isConnected()) {
|
|
_ui->notify(UIEventType::contactMessage);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static uint16_t emergencyClientRepeatKey(const mesh::Packet* packet) {
|
|
const uint8_t* p = packet->payload;
|
|
return ((uint16_t)p[1]) | ((uint16_t)p[2] << 8);
|
|
}
|
|
|
|
static bool __attribute__((noinline)) hasEmergencyClientRepeat(uint16_t key) {
|
|
for (uint8_t i = 0; i < EMERGENCY_CLIENT_REPEAT_TABLE_SIZE; i++) {
|
|
if (emergency_client_repeats[i] == key) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool MyMesh::filterRecvFloodPacket(mesh::Packet* packet) {
|
|
if (emergency_client_repeat_packet != NULL && packet->getPathHashCount() > 0) {
|
|
if (emergencyClientRepeatKey(packet) == emergency_client_repeat_key) {
|
|
releasePacket(emergency_client_repeat_packet);
|
|
emergency_client_repeat_packet = NULL;
|
|
}
|
|
}
|
|
// REVISIT: try to determine which Region (from transport_codes[1]) that Sender is indicating for replies/responses
|
|
// if unknown, fallback to finding Region from transport_codes[0], the 'scope' used by Sender
|
|
return false;
|
|
}
|
|
|
|
bool MyMesh::allowPacketForward(const mesh::Packet* packet) {
|
|
if (!_prefs.isRepeatEn()) return false;
|
|
#ifdef COMPANION_MESH_CLOCK_SYNC
|
|
_clock_sync.observeAcceptedFlood(packet);
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
#ifdef COMPANION_MESH_CLOCK_SYNC
|
|
void MyMesh::onAdvertRecv(mesh::Packet* packet, const mesh::Identity& id,
|
|
uint32_t timestamp, const uint8_t* app_data,
|
|
size_t app_data_len) {
|
|
BaseChatMesh::onAdvertRecv(packet, id, timestamp, app_data, app_data_len);
|
|
_clock_sync.observeVerifiedAdvert(packet, id, timestamp);
|
|
}
|
|
|
|
void MyMesh::onGroupPacketRecv(mesh::Packet* packet) {
|
|
_clock_sync.observeGroupPacket(packet);
|
|
}
|
|
#endif
|
|
|
|
bool MyMesh::allowFloodRetry(const mesh::Packet* packet) const {
|
|
if (packet == NULL) return false;
|
|
// A companion may retry its own advert once, using the core's deliberately
|
|
// slow origin-advert delay. Do not add retries while relaying a neighbour's
|
|
// advert; the ordinary forwarding and recent-echo guard still apply.
|
|
return packet->getPayloadType() != PAYLOAD_TYPE_ADVERT
|
|
|| isSelfOriginAdvert(packet);
|
|
}
|
|
|
|
bool MyMesh::sendFloodScoped(const TransportKey& scope, mesh::Packet* pkt, uint32_t delay_millis) {
|
|
if (scope.isNull()) {
|
|
return sendFlood(pkt, delay_millis, _prefs.path_hash_mode + 1);
|
|
} else {
|
|
uint16_t codes[2];
|
|
codes[0] = scope.calcTransportCode(pkt);
|
|
codes[1] = 0; // REVISIT: set to 'home' Region, for sender/return region?
|
|
return sendFlood(pkt, codes, delay_millis, _prefs.path_hash_mode + 1);
|
|
}
|
|
}
|
|
|
|
bool MyMesh::sendFloodScoped(const ContactInfo& recipient, mesh::Packet* pkt, uint32_t delay_millis) {
|
|
// TODO: dynamic send_scope, depending on recipient and current 'home' Region
|
|
if (send_unscoped) {
|
|
return sendFlood(pkt, delay_millis, _prefs.path_hash_mode + 1); // app explicitly requested un-scoped
|
|
} else {
|
|
TransportKey default_scope;
|
|
memcpy(&default_scope.key, _prefs.default_scope_key, sizeof(default_scope.key));
|
|
|
|
auto scope = send_scope.isNull() ? &default_scope : &send_scope;
|
|
return sendFloodScoped(*scope, pkt, delay_millis);
|
|
}
|
|
}
|
|
bool MyMesh::sendFloodScoped(const mesh::GroupChannel& channel, mesh::Packet* pkt, uint32_t delay_millis) {
|
|
// TODO: have per-channel send_scope
|
|
if (send_unscoped) {
|
|
return sendFlood(pkt, delay_millis, _prefs.path_hash_mode + 1); // app explicitly requested un-scoped
|
|
} else {
|
|
TransportKey default_scope;
|
|
memcpy(&default_scope.key, _prefs.default_scope_key, sizeof(default_scope.key));
|
|
|
|
auto scope = send_scope.isNull() ? &default_scope : &send_scope;
|
|
return sendFloodScoped(*scope, pkt, delay_millis);
|
|
}
|
|
}
|
|
|
|
void MyMesh::onMessageRecv(const ContactInfo &from, mesh::Packet *pkt, uint32_t sender_timestamp,
|
|
const char *text) {
|
|
markConnectionActive(from); // in case this is from a server, and we have a connection
|
|
// BaseChatMesh updates lastmod immediately before this callback.
|
|
scheduleContactWrite(from);
|
|
queueMessage(from, TXT_TYPE_PLAIN, pkt, sender_timestamp, NULL, 0, text);
|
|
}
|
|
|
|
void MyMesh::onCommandDataRecv(const ContactInfo &from, mesh::Packet *pkt, uint32_t sender_timestamp, const char *text) {
|
|
markConnectionActive(from); // in case this is from a server, and we have a connection
|
|
bool terminal_command_reply = false;
|
|
uint32_t terminal_command_elapsed_millis = 0;
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
terminal_command_reply = _terminal_command.takeReply(
|
|
from.id.pub_key, _ms->getMillis(), terminal_command_elapsed_millis);
|
|
if (terminal_command_reply) _terminal_command_target[0] = 0;
|
|
#endif
|
|
queueMessage(from, TXT_TYPE_CLI_DATA, pkt, sender_timestamp, NULL, 0, text,
|
|
terminal_command_reply, terminal_command_elapsed_millis);
|
|
}
|
|
|
|
void MyMesh::onCLICommandRecv(const ContactInfo &from, mesh::Packet *pkt, uint32_t sender_timestamp,
|
|
const char *text, char* reply) {
|
|
markConnectionActive(from); // in case this is from a server, and we have a connection
|
|
if (from.isRemoteCLIAllowed()) {
|
|
if (!handleCommand(text, sender_timestamp, reply)) {
|
|
strcat(reply, "Unknown command"); // reply may have cmd prefix from 'text'
|
|
}
|
|
} else {
|
|
queueMessage(from, TXT_TYPE_CLI_COMMAND, pkt, sender_timestamp, NULL, 0, text);
|
|
}
|
|
}
|
|
|
|
void MyMesh::onSignedMessageRecv(const ContactInfo &from, mesh::Packet *pkt, uint32_t sender_timestamp,
|
|
const uint8_t *sender_prefix, const char *text) {
|
|
markConnectionActive(from);
|
|
// from.sync_since change needs to be persisted
|
|
scheduleContactWrite(from);
|
|
queueMessage(from, TXT_TYPE_SIGNED_PLAIN, pkt, sender_timestamp, sender_prefix, 4, text);
|
|
}
|
|
|
|
void MyMesh::onChannelMessageRecv(const mesh::GroupChannel &channel, mesh::Packet *pkt, uint32_t timestamp,
|
|
const char *text) {
|
|
const bool is_emergency_channel =
|
|
memcmp(channel.secret, EMERGENCY_CHANNEL_SECRET,
|
|
sizeof(EMERGENCY_CHANNEL_SECRET)) == 0;
|
|
int i = 0;
|
|
if (app_target_ver >= 3) {
|
|
out_frame[i++] = RESP_CODE_CHANNEL_MSG_RECV_V3;
|
|
out_frame[i++] = (int8_t)(pkt->getSNR() * 4);
|
|
out_frame[i++] = 0; // reserved1
|
|
out_frame[i++] = 0; // reserved2
|
|
} else {
|
|
out_frame[i++] = RESP_CODE_CHANNEL_MSG_RECV;
|
|
}
|
|
|
|
uint8_t channel_idx = findChannelIdx(channel);
|
|
out_frame[i++] = channel_idx;
|
|
uint8_t path_len = out_frame[i++] = pkt->isRouteFlood() ? pkt->path_len : 0xFF;
|
|
|
|
out_frame[i++] = TXT_TYPE_PLAIN;
|
|
memcpy(&out_frame[i], ×tamp, 4);
|
|
i += 4;
|
|
int tlen = strlen(text); // TODO: UTF-8 ??
|
|
if (i + tlen > MAX_FRAME_SIZE) {
|
|
tlen = MAX_FRAME_SIZE - i;
|
|
}
|
|
memcpy(&out_frame[i], text, tlen);
|
|
i += tlen;
|
|
addToOfflineQueue(out_frame, i);
|
|
|
|
if (_serial->isConnected()) {
|
|
uint8_t frame[1];
|
|
frame[0] = PUSH_CODE_MSG_WAITING; // send push 'tickle'
|
|
_serial->writeFrame(frame, 1);
|
|
} else {
|
|
#ifdef DISPLAY_CLASS
|
|
if (_ui) _ui->notify(UIEventType::channelMessage);
|
|
#endif
|
|
}
|
|
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
if (hasTerminalOutput()
|
|
&& _terminal_display.shouldShowChannel(is_emergency_channel)) {
|
|
ChannelDetails details;
|
|
const char* channel_name = getChannel(channel_idx, details) ? details.name : "Unknown";
|
|
terminalOutput().printf(
|
|
"\r\nCHANNEL MSG -> %s (%s)\r\n %s\r\n> ", channel_name,
|
|
pkt->isRouteDirect() ? "DIRECT" : "FLOOD", text);
|
|
}
|
|
#endif
|
|
#ifdef DISPLAY_CLASS
|
|
// Get the channel name from the channel index
|
|
const char *channel_name = "Unknown";
|
|
ChannelDetails channel_details;
|
|
if (getChannel(channel_idx, channel_details)) {
|
|
channel_name = channel_details.name;
|
|
}
|
|
char channel_label[64];
|
|
snprintf(channel_label, sizeof(channel_label), "Ch %u %s",
|
|
(unsigned int)channel_idx, channel_name);
|
|
if (_ui) {
|
|
_ui->newMsg(path_len, channel_label, text, offline_queue_len,
|
|
channel_idx, channel_name);
|
|
}
|
|
#endif
|
|
|
|
if (pkt->isRouteFlood() && is_emergency_channel) {
|
|
bool zero_path = pkt->getPathHashCount() == 0;
|
|
uint16_t key = emergencyClientRepeatKey(pkt);
|
|
if (hasEmergencyClientRepeat(key)) {
|
|
pkt->markDoNotRetransmit();
|
|
} else {
|
|
emergency_client_repeats[emergency_client_repeat_next] = key;
|
|
emergency_client_repeat_next++;
|
|
if (emergency_client_repeat_next >= EMERGENCY_CLIENT_REPEAT_TABLE_SIZE) emergency_client_repeat_next = 0;
|
|
|
|
if (zero_path && emergency_client_repeat_packet == NULL) {
|
|
emergency_client_repeat_packet = obtainNewPacket();
|
|
if (emergency_client_repeat_packet != NULL) {
|
|
*emergency_client_repeat_packet = *pkt;
|
|
emergency_client_repeat_key = key;
|
|
emergency_client_repeat_send_at = futureMillis(
|
|
(int)(EMERGENCY_CLIENT_REPEAT_HOLD_MS + getRNG()->nextInt(0, EMERGENCY_CLIENT_REPEAT_JITTER_MS + 1)));
|
|
pkt->markDoNotRetransmit();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void MyMesh::onChannelDataRecv(const mesh::GroupChannel &channel, mesh::Packet *pkt, uint16_t data_type,
|
|
const uint8_t *data, size_t data_len) {
|
|
if (data_len > MAX_CHANNEL_DATA_LENGTH) {
|
|
MESH_DEBUG_PRINTLN("onChannelDataRecv: dropping payload_len=%d exceeds frame limit=%d",
|
|
(uint32_t)data_len, (uint32_t)MAX_CHANNEL_DATA_LENGTH);
|
|
return;
|
|
}
|
|
|
|
int i = 0;
|
|
out_frame[i++] = RESP_CODE_CHANNEL_DATA_RECV;
|
|
out_frame[i++] = (int8_t)(pkt->getSNR() * 4);
|
|
out_frame[i++] = 0; // reserved1
|
|
out_frame[i++] = 0; // reserved2
|
|
|
|
uint8_t channel_idx = findChannelIdx(channel);
|
|
out_frame[i++] = channel_idx;
|
|
out_frame[i++] = pkt->isRouteFlood() ? pkt->path_len : 0xFF;
|
|
out_frame[i++] = (uint8_t)(data_type & 0xFF);
|
|
out_frame[i++] = (uint8_t)(data_type >> 8);
|
|
out_frame[i++] = (uint8_t)data_len;
|
|
|
|
int copy_len = (int)data_len;
|
|
if (copy_len > 0) {
|
|
memcpy(&out_frame[i], data, copy_len);
|
|
i += copy_len;
|
|
}
|
|
addToOfflineQueue(out_frame, i);
|
|
|
|
if (_serial->isConnected()) {
|
|
uint8_t frame[1];
|
|
frame[0] = PUSH_CODE_MSG_WAITING; // send push 'tickle'
|
|
_serial->writeFrame(frame, 1);
|
|
}
|
|
}
|
|
|
|
uint8_t MyMesh::onContactRequest(const ContactInfo &contact, uint32_t sender_timestamp, const uint8_t *data,
|
|
uint8_t len, uint8_t *reply) {
|
|
if (data[0] == REQ_TYPE_GET_TELEMETRY_DATA) {
|
|
uint8_t permissions = 0;
|
|
uint8_t cp = contact.flags >> 1; // LSB used as 'favourite' bit (so only use upper bits)
|
|
|
|
if (_prefs.telemetry_mode_base == TELEM_MODE_ALLOW_ALL) {
|
|
permissions = TELEM_PERM_BASE;
|
|
} else if (_prefs.telemetry_mode_base == TELEM_MODE_ALLOW_FLAGS) {
|
|
permissions = cp & TELEM_PERM_BASE;
|
|
}
|
|
|
|
if (_prefs.telemetry_mode_loc == TELEM_MODE_ALLOW_ALL) {
|
|
permissions |= TELEM_PERM_LOCATION;
|
|
} else if (_prefs.telemetry_mode_loc == TELEM_MODE_ALLOW_FLAGS) {
|
|
permissions |= cp & TELEM_PERM_LOCATION;
|
|
}
|
|
|
|
if (_prefs.telemetry_mode_env == TELEM_MODE_ALLOW_ALL) {
|
|
permissions |= TELEM_PERM_ENVIRONMENT;
|
|
} else if (_prefs.telemetry_mode_env == TELEM_MODE_ALLOW_FLAGS) {
|
|
permissions |= cp & TELEM_PERM_ENVIRONMENT;
|
|
}
|
|
|
|
uint8_t perm_mask = ~(data[1]); // NEW: first reserved byte (of 4), is now inverse mask to apply to permissions
|
|
permissions &= perm_mask;
|
|
|
|
if (permissions & TELEM_PERM_BASE) { // only respond if base permission bit is set
|
|
telemetry.reset();
|
|
telemetry.addVoltage(TELEM_CHANNEL_SELF, (float)board.getBattMilliVolts() / 1000.0f);
|
|
// query other sensors -- target specific
|
|
sensors.querySensors(permissions, telemetry);
|
|
|
|
float temperature = board.getMCUTemperature();
|
|
if(!isnan(temperature)) { // Supported boards with built-in temperature sensor. ESP32-C3 may return NAN
|
|
telemetry.addTemperature(TELEM_CHANNEL_SELF, temperature); // Built-in MCU Temperature
|
|
}
|
|
|
|
memcpy(reply, &sender_timestamp,
|
|
4); // reflect sender_timestamp back in response packet (kind of like a 'tag')
|
|
|
|
uint8_t tlen = telemetry.getSize();
|
|
memcpy(&reply[4], telemetry.getBuffer(), tlen);
|
|
return 4 + tlen;
|
|
}
|
|
}
|
|
return 0; // unknown
|
|
}
|
|
|
|
void MyMesh::onContactResponse(const ContactInfo &contact, const uint8_t *data, uint8_t len) {
|
|
if (data == NULL || len < 4) return;
|
|
|
|
uint32_t tag;
|
|
memcpy(&tag, data, 4);
|
|
|
|
if (pending_login && memcmp(&pending_login, contact.id.pub_key, 4) == 0) { // check for login response
|
|
// yes, is response to pending sendLogin()
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
const bool terminal_login_response = _terminal_login_pending
|
|
&& memcmp(_terminal_login_key, contact.id.pub_key,
|
|
sizeof(_terminal_login_key)) == 0;
|
|
#endif
|
|
int i = 0;
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
bool login_success = false;
|
|
bool modern_login = false;
|
|
#endif
|
|
if (len >= 6 && memcmp(&data[4], "OK", 2) == 0) { // legacy Repeater login OK response
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
login_success = true;
|
|
#endif
|
|
out_frame[i++] = PUSH_CODE_LOGIN_SUCCESS;
|
|
out_frame[i++] = 0; // legacy: is_admin = false
|
|
memcpy(&out_frame[i], contact.id.pub_key, 6);
|
|
i += 6; // pub_key_prefix
|
|
} else if (len >= 13 && data[4] == RESP_SERVER_LOGIN_OK) { // new login response
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
login_success = true;
|
|
modern_login = true;
|
|
#endif
|
|
uint16_t keep_alive_secs = ((uint16_t)data[5]) * 16;
|
|
if (keep_alive_secs > 0) {
|
|
startConnection(contact, keep_alive_secs);
|
|
}
|
|
out_frame[i++] = PUSH_CODE_LOGIN_SUCCESS;
|
|
out_frame[i++] = data[6]; // permissions (eg. is_admin)
|
|
memcpy(&out_frame[i], contact.id.pub_key, 6);
|
|
i += 6; // pub_key_prefix
|
|
memcpy(&out_frame[i], &tag, 4);
|
|
i += 4; // NEW: include server timestamp
|
|
out_frame[i++] = data[7]; // NEW (v7): ACL permissions
|
|
out_frame[i++] = data[12]; // FIRMWARE_VER_LEVEL
|
|
} else {
|
|
out_frame[i++] = PUSH_CODE_LOGIN_FAIL;
|
|
out_frame[i++] = 0; // reserved
|
|
memcpy(&out_frame[i], contact.id.pub_key, 6);
|
|
i += 6; // pub_key_prefix
|
|
}
|
|
// Terminal login has its own text destination and deliberately captures
|
|
// no Binary route. Binary logins retain their exact requester even if a
|
|
// different transport has issued a command in the meantime.
|
|
writePendingSerialFrame(out_frame, i);
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
if (terminal_login_response) {
|
|
if (hasTerminalOutput()) {
|
|
Stream& output = terminalOutput();
|
|
if (login_success && modern_login) {
|
|
output.printf(
|
|
"\r\nLOGIN -> %s accepted (ACL permissions 0x%02X, server v%u)\r\n> ",
|
|
_terminal_login_target, (unsigned)data[7], (unsigned)data[12]);
|
|
} else if (login_success) {
|
|
output.printf("\r\nLOGIN -> %s accepted (legacy server)\r\n> ",
|
|
_terminal_login_target);
|
|
} else {
|
|
output.printf("\r\nLOGIN -> %s rejected\r\n> ",
|
|
_terminal_login_target);
|
|
}
|
|
}
|
|
clearTerminalLogin();
|
|
}
|
|
#endif
|
|
clearPendingReqs();
|
|
} else if (mesh::companionStatusTagMatches(pending_status, tag)) {
|
|
// Do not expose a truncated or unrelated response as repeater statistics.
|
|
// The app parses at least 48 bytes and otherwise throws a RangeError.
|
|
if (!mesh::companionStatusResponseIsLongEnough(len)) {
|
|
MESH_DEBUG_PRINTLN(
|
|
"onContactResponse(), short status response: len=%u, expected>=%u",
|
|
(unsigned)len,
|
|
(unsigned)mesh::COMPANION_MIN_STATUS_RESPONSE_SIZE);
|
|
clearPendingReqs();
|
|
return;
|
|
}
|
|
|
|
int i = 0;
|
|
out_frame[i++] = PUSH_CODE_STATUS_RESPONSE;
|
|
out_frame[i++] = 0; // reserved
|
|
memcpy(&out_frame[i], contact.id.pub_key, 6);
|
|
i += 6; // pub_key_prefix
|
|
memcpy(&out_frame[i], &data[4], len - 4);
|
|
i += (len - 4);
|
|
writePendingSerialFrame(out_frame, i);
|
|
clearPendingReqs();
|
|
} else if (len > 4 && tag == pending_telemetry) { // check for matching response tag
|
|
int i = 0;
|
|
out_frame[i++] = PUSH_CODE_TELEMETRY_RESPONSE;
|
|
out_frame[i++] = 0; // reserved
|
|
memcpy(&out_frame[i], contact.id.pub_key, 6);
|
|
i += 6; // pub_key_prefix
|
|
memcpy(&out_frame[i], &data[4], len - 4);
|
|
i += (len - 4);
|
|
writePendingSerialFrame(out_frame, i);
|
|
clearPendingReqs();
|
|
} else if (len > 4 && tag == pending_req) { // check for matching response tag
|
|
int i = 0;
|
|
out_frame[i++] = PUSH_CODE_BINARY_RESPONSE;
|
|
out_frame[i++] = 0; // reserved
|
|
memcpy(&out_frame[i], &tag, 4); // app needs to match this to RESP_CODE_SENT.tag
|
|
i += 4;
|
|
memcpy(&out_frame[i], &data[4], len - 4);
|
|
i += (len - 4);
|
|
writePendingSerialFrame(out_frame, i);
|
|
clearPendingReqs();
|
|
}
|
|
}
|
|
|
|
bool MyMesh::onContactPathRecv(ContactInfo& contact, uint8_t* in_path, uint8_t in_path_len, uint8_t* out_path, uint8_t out_path_len, uint8_t extra_type, uint8_t* extra, uint8_t extra_len) {
|
|
if (extra_type == PAYLOAD_TYPE_RESPONSE && extra_len > 4) {
|
|
uint32_t tag;
|
|
memcpy(&tag, extra, 4);
|
|
|
|
if (tag == pending_discovery) { // check for matching response tag)
|
|
if (!mesh::Packet::isValidPathLen(in_path_len) || !mesh::Packet::isValidPathLen(out_path_len)) {
|
|
MESH_DEBUG_PRINTLN("onContactPathRecv, invalid path sizes: %d, %d", in_path_len, out_path_len);
|
|
} else {
|
|
int i = 0;
|
|
out_frame[i++] = PUSH_CODE_PATH_DISCOVERY_RESPONSE;
|
|
out_frame[i++] = 0; // reserved
|
|
memcpy(&out_frame[i], contact.id.pub_key, 6);
|
|
i += 6; // pub_key_prefix
|
|
out_frame[i++] = out_path_len;
|
|
i += mesh::Packet::writePath(&out_frame[i], out_path, out_path_len);
|
|
out_frame[i++] = in_path_len;
|
|
i += mesh::Packet::writePath(&out_frame[i], in_path, in_path_len);
|
|
// NOTE: telemetry data in 'extra' is discarded at present
|
|
|
|
writePendingSerialFrame(out_frame, i);
|
|
}
|
|
clearPendingReqs();
|
|
return false; // DON'T send reciprocal path!
|
|
}
|
|
}
|
|
// let base class handle received path and data
|
|
return BaseChatMesh::onContactPathRecv(contact, in_path, in_path_len, out_path, out_path_len, extra_type, extra, extra_len);
|
|
}
|
|
|
|
void MyMesh::onControlDataRecv(mesh::Packet *packet) {
|
|
if (packet->payload_len + 4 > sizeof(out_frame)) {
|
|
MESH_DEBUG_PRINTLN("onControlDataRecv(), payload_len too long: %d", packet->payload_len);
|
|
return;
|
|
}
|
|
int i = 0;
|
|
out_frame[i++] = PUSH_CODE_CONTROL_DATA;
|
|
out_frame[i++] = (int8_t)(packet->getSNR() * 4);
|
|
out_frame[i++] = (int8_t)packet->getRSSI();
|
|
out_frame[i++] = packet->path_len;
|
|
memcpy(&out_frame[i], packet->payload, packet->payload_len);
|
|
i += packet->payload_len;
|
|
|
|
if (_serial->isConnected()) {
|
|
_serial->writeFrame(out_frame, i);
|
|
} else {
|
|
MESH_DEBUG_PRINTLN("onControlDataRecv(), data received while app offline");
|
|
}
|
|
}
|
|
|
|
void MyMesh::onRawDataRecv(mesh::Packet *packet) {
|
|
if (packet->payload_len + 4 > sizeof(out_frame)) {
|
|
MESH_DEBUG_PRINTLN("onRawDataRecv(), payload_len too long: %d", packet->payload_len);
|
|
return;
|
|
}
|
|
int i = 0;
|
|
out_frame[i++] = PUSH_CODE_RAW_DATA;
|
|
out_frame[i++] = (int8_t)(packet->getSNR() * 4);
|
|
out_frame[i++] = (int8_t)packet->getRSSI();
|
|
out_frame[i++] = 0xFF; // reserved (possibly path_len in future)
|
|
memcpy(&out_frame[i], packet->payload, packet->payload_len);
|
|
i += packet->payload_len;
|
|
|
|
if (_serial->isConnected()) {
|
|
_serial->writeFrame(out_frame, i);
|
|
} else {
|
|
MESH_DEBUG_PRINTLN("onRawDataRecv(), data received while app offline");
|
|
}
|
|
}
|
|
|
|
void MyMesh::onTraceRecv(mesh::Packet *packet, uint32_t tag, uint32_t auth_code, uint8_t flags,
|
|
const uint8_t *path_snrs, const uint8_t *path_hashes, uint8_t path_len) {
|
|
const bool binary_trace_match = binary_trace_pending
|
|
&& tag == binary_trace_tag && auth_code == binary_trace_auth;
|
|
uint8_t path_sz = flags & 0x03; // NEW v1.11+
|
|
if (12 + path_len + (path_len >> path_sz) + 1 > sizeof(out_frame)) {
|
|
MESH_DEBUG_PRINTLN("onTraceRecv(), path_len is too long: %d", (uint32_t)path_len);
|
|
if (binary_trace_match) clearBinaryTraceReply();
|
|
return;
|
|
}
|
|
int i = 0;
|
|
out_frame[i++] = PUSH_CODE_TRACE_DATA;
|
|
out_frame[i++] = 0; // reserved
|
|
out_frame[i++] = path_len;
|
|
out_frame[i++] = flags;
|
|
memcpy(&out_frame[i], &tag, 4);
|
|
i += 4;
|
|
memcpy(&out_frame[i], &auth_code, 4);
|
|
i += 4;
|
|
memcpy(&out_frame[i], path_hashes, path_len);
|
|
i += path_len;
|
|
|
|
memcpy(&out_frame[i], path_snrs, path_len >> path_sz);
|
|
i += path_len >> path_sz;
|
|
out_frame[i++] = (int8_t)(packet->getSNR() * 4); // extra/final SNR (to this node)
|
|
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
if (hasTerminalOutput() && _terminal_trace_pending
|
|
&& tag == _terminal_trace_tag && auth_code == _terminal_trace_auth) {
|
|
Stream& output = terminalOutput();
|
|
const uint8_t hash_size = _terminal_trace_hash_size;
|
|
const uint8_t hop_count = hash_size == 0 ? 0 : path_len / hash_size;
|
|
const uint8_t response_hash_size = 1 << (flags & 0x03);
|
|
const unsigned long elapsed = _ms->getMillis() - _terminal_trace_sent_at;
|
|
output.printf("\r\nTRACE -> %s (%lu ms)\r\n",
|
|
_terminal_trace_target, elapsed);
|
|
if (hash_size == 0 || response_hash_size != hash_size
|
|
|| path_len % hash_size != 0
|
|
|| hop_count >= MAX_PATH_SIZE) {
|
|
output.print(" ERROR: malformed trace response\r\n> ");
|
|
} else {
|
|
output.print(" ");
|
|
for (uint8_t hop = 0; hop < hop_count; hop++) {
|
|
output.print(((float)(int8_t)path_snrs[hop]) / 4.0f, 2);
|
|
output.print(" dB -> [");
|
|
mesh::Utils::printHex(output, &path_hashes[hop * hash_size],
|
|
hash_size);
|
|
output.print("] -> ");
|
|
}
|
|
output.print(packet->getSNR(), 2);
|
|
output.print(" dB\r\n> ");
|
|
}
|
|
clearTerminalTrace();
|
|
}
|
|
#endif
|
|
|
|
if (binary_trace_match) {
|
|
_serial->writeFrameToRoute(binary_trace_reply_route, out_frame, i);
|
|
clearBinaryTraceReply();
|
|
}
|
|
}
|
|
|
|
uint32_t MyMesh::calcFloodTimeoutMillisFor(uint32_t pkt_airtime_millis) const {
|
|
return SEND_TIMEOUT_BASE_MILLIS + (FLOOD_SEND_TIMEOUT_FACTOR * pkt_airtime_millis);
|
|
}
|
|
uint32_t MyMesh::calcDirectTimeoutMillisFor(uint32_t pkt_airtime_millis, uint8_t path_len) const {
|
|
uint8_t path_hash_count = path_len & 63;
|
|
return SEND_TIMEOUT_BASE_MILLIS +
|
|
((pkt_airtime_millis * DIRECT_SEND_PERHOP_FACTOR + DIRECT_SEND_PERHOP_EXTRA_MILLIS) *
|
|
(path_hash_count + 1));
|
|
}
|
|
|
|
void MyMesh::onSendTimeout() {
|
|
expireExpectedAcks();
|
|
}
|
|
|
|
MyMesh::MyMesh(mesh::Radio &radio, mesh::RNG &rng, mesh::RTCClock &rtc, SimpleMeshTables &tables, DataStore& store, AbstractUITask* ui)
|
|
: BaseChatMesh(radio, *new ArduinoMillis(), rng, rtc, *new StaticPoolPacketManager(16), tables),
|
|
#ifdef COMPANION_MESH_CLOCK_SYNC
|
|
_clock_sync(radio, _clock_sync_millis, rtc, _clock_sync_acl, sensors,
|
|
_prefs.airtime_factor),
|
|
#endif
|
|
_serial(NULL), _mota_source_control(NULL),
|
|
telemetry(MAX_PACKET_PAYLOAD - 4), _store(&store), _ui(ui), _iter(0) {
|
|
_iter_started = false;
|
|
_iter_start_pending = false;
|
|
_iter_contact_pending = false;
|
|
_iter_next_frame_at = 0;
|
|
_iter_total_count = 0;
|
|
_iter_table_revision = 0;
|
|
_cli_rescue = false;
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
_terminal_mode = false;
|
|
_terminal_output = NULL;
|
|
_terminal_recipient_set = false;
|
|
memset(_terminal_recipient_key, 0, sizeof(_terminal_recipient_key));
|
|
_terminal_login_pending = false;
|
|
memset(_terminal_login_key, 0, sizeof(_terminal_login_key));
|
|
_terminal_login_expires_at = 0;
|
|
_terminal_login_target[0] = 0;
|
|
clearTerminalCommand();
|
|
clearTerminalTrace();
|
|
#endif
|
|
saved_radio_apply_pending = false;
|
|
_radio_available = true;
|
|
radio_apply_retry_at = 0;
|
|
radio_apply_failures = 0;
|
|
command_radio_apply_pending = false;
|
|
command_radio_freq = 0.0f;
|
|
command_radio_bw = 0.0f;
|
|
command_radio_sf = 0;
|
|
command_radio_cr = 0;
|
|
command_radio_repeat = 0;
|
|
command_radio_apply_deadline = 0;
|
|
command_radio_reply_route = NULL;
|
|
binary_trace_pending = false;
|
|
binary_trace_tag = 0;
|
|
binary_trace_auth = 0;
|
|
binary_trace_deadline = 0;
|
|
binary_trace_reply_route = NULL;
|
|
_scheduled_reboot_at = 0;
|
|
#if COMPANION_FEATURE_TEMP_RADIO
|
|
_temp_radio_set_at = 0;
|
|
_temp_radio_revert_at = 0;
|
|
_temp_radio_retry_at = 0;
|
|
_temp_radio_freq = 0.0f;
|
|
_temp_radio_bw = 0.0f;
|
|
_temp_radio_sf = 0;
|
|
_temp_radio_cr = 0;
|
|
_temp_radio_failures = 0;
|
|
_temp_radio_applied = false;
|
|
#endif
|
|
offline_queue_len = 0;
|
|
offline_queue_head = 0;
|
|
#if defined(ESP32_PLATFORM) && defined(BOARD_HAS_PSRAM)
|
|
offline_queue = offline_queue_fallback;
|
|
offline_queue_capacity = OFFLINE_QUEUE_PSRAM_FALLBACK_SIZE;
|
|
#endif
|
|
app_target_ver = 0;
|
|
clearPendingReqs();
|
|
memset(expected_ack_table, 0, sizeof(expected_ack_table));
|
|
next_ack_idx = 0;
|
|
next_ack_expiry = 0;
|
|
has_next_ack_expiry = false;
|
|
sign_data = NULL;
|
|
sign_data_reply_route = NULL;
|
|
sign_data_deadline = 0;
|
|
dirty_contacts_expiry = 0;
|
|
dirty_contacts_failures = 0;
|
|
memset(advert_paths, 0, sizeof(advert_paths));
|
|
memset(send_scope.key, 0, sizeof(send_scope.key));
|
|
send_unscoped = false;
|
|
|
|
// defaults
|
|
_prefs.airtime_factor = 1.0; // one half
|
|
strcpy(_prefs.node_name, "NONAME");
|
|
_prefs.freq = LORA_FREQ;
|
|
_prefs.sf = LORA_SF;
|
|
_prefs.bw = LORA_BW;
|
|
_prefs.cr = LORA_CR;
|
|
_prefs.multi_acks = DEFAULT_MULTI_ACKS;
|
|
_prefs.manual_add_contacts = DEFAULT_MANUAL_ADD_CONTACTS;
|
|
_prefs.tx_power_dbm = LORA_TX_POWER;
|
|
_prefs.buzzer_quiet = DEFAULT_BUZZER_QUIET ? 1 : 0;
|
|
_prefs.gps_enabled = 0; // GPS disabled by default
|
|
_prefs.gps_interval = 0; // Use the default 1-second fix-processing interval
|
|
_prefs.autoadd_config = DEFAULT_AUTOADD_CONFIG;
|
|
_prefs.path_hash_mode = DEFAULT_PATH_HASH_MODE;
|
|
_prefs.radio_fem_txgain = 0;
|
|
#ifdef DEFAULT_RX_DELAY_BASE
|
|
_prefs.rx_delay_base = DEFAULT_RX_DELAY_BASE;
|
|
#endif
|
|
_prefs.setRepeatEn(false);
|
|
#if defined(USE_SX1262) || defined(USE_SX1268) || defined(USE_LR1110) \
|
|
|| defined(USE_LR2021) || defined(SX126X_RX_BOOSTED_GAIN) \
|
|
|| defined(RX_BOOSTED_GAIN)
|
|
_prefs.rx_boosted_gain = mesh::radio::configuredRxBoostedGainDefault();
|
|
#endif
|
|
_prefs.radio_fem_rxgain = DEFAULT_FEM_RX_GAIN;
|
|
_prefs.rx_powersaving_enabled = RXPS_FIXED_ENABLED ? 1 : 0;
|
|
_prefs.rx_ps_level = RXPS_FIXED_LEVEL;
|
|
_prefs.rx_ps_preamble = RXPS_FIXED_PREAMBLE;
|
|
_prefs.rx_ps_rx_us = RX_POWERSAVING_DEFAULT_RX_US;
|
|
_prefs.rx_ps_sleep_us = RX_POWERSAVING_DEFAULT_SLEEP_US;
|
|
_prefs.powersaving_enabled = 1;
|
|
_prefs.powersaving_policy_version = 0;
|
|
_prefs.wifi_enabled = 1;
|
|
memset(_prefs.bluetooth_name, 0, sizeof(_prefs.bluetooth_name));
|
|
_prefs.display_rotation_degrees = 0;
|
|
_prefs.cad_enabled = DEFAULT_CAD_ENABLED ? 1 : 0;
|
|
_prefs.cad_scan_timeout_ms = 0;
|
|
_prefs.cad_retry_delay_ms = 0;
|
|
_prefs.cad_max_duration_ms = 0;
|
|
#if defined(ENABLE_USB_INTERFACE)
|
|
// Keep a USB Companion's primary stream exclusively framed on a fresh
|
|
// install. nRF52 Full can add a diagnostics port; ESP32 and other single-TTY
|
|
// builds switch the primary stream into the text terminal before logs.
|
|
_prefs.usb_logging_enabled = 0;
|
|
#else
|
|
_prefs.usb_logging_enabled = 1;
|
|
#endif
|
|
recalcRxPowerSavingFromLevel(_prefs.rx_ps_level, _prefs.sf, _prefs.bw,
|
|
_prefs.rx_ps_preamble, &_prefs.rx_ps_rx_us,
|
|
&_prefs.rx_ps_sleep_us);
|
|
|
|
#if defined(WITH_MQTT_BRIDGE) && defined(ESP32_PLATFORM) && defined(WIFI_SSID)
|
|
memset(&_mqtt_prefs, 0, sizeof(_mqtt_prefs));
|
|
_mqtt_bridge = nullptr;
|
|
_mqtt_configured = false;
|
|
_mqtt_started = false;
|
|
#endif
|
|
#ifdef WITH_WEBCONFIG
|
|
_webconfig = nullptr;
|
|
_wc_mqtt_dirty = false;
|
|
#endif
|
|
if (_ui != nullptr) _ui->setShutdownGuard(this);
|
|
}
|
|
|
|
void MyMesh::begin(bool has_display, bool radio_available) {
|
|
_radio_available = radio_available;
|
|
setRadioAvailable(radio_available);
|
|
initializeContactStorage();
|
|
initializeOfflineQueue();
|
|
BaseChatMesh::begin();
|
|
|
|
const bool identity_loaded = _store->loadMainIdentity(self_id);
|
|
const bool is_new_install = !identity_loaded
|
|
|| mesh::hasReservedIdentityPrefix(self_id);
|
|
if (is_new_install && !_store->canCreateMainIdentity()) {
|
|
MESH_DEBUG_PRINTLN(
|
|
"Identity unavailable from persistent storage; rebooting without replacement");
|
|
board.reboot();
|
|
return;
|
|
}
|
|
|
|
bool identity_ready = true;
|
|
if (is_new_install) {
|
|
identity_ready = mesh::generateUsableLocalIdentity(self_id, radio_new_identity);
|
|
if (identity_ready) identity_ready = _store->saveMainIdentity(self_id);
|
|
}
|
|
|
|
#if defined(ESP32_PLATFORM)
|
|
mesh::discardESP32TrueRandom();
|
|
#endif
|
|
if (!identity_ready) {
|
|
MESH_DEBUG_PRINTLN("Identity generation/save failed; rebooting");
|
|
board.reboot();
|
|
return;
|
|
}
|
|
|
|
// if name is provided as a build flag, use that as default node name instead
|
|
#ifdef ADVERT_NAME
|
|
strcpy(_prefs.node_name, ADVERT_NAME);
|
|
#else
|
|
// use hex of first 4 bytes of identity public key as default node name
|
|
char pub_key_hex[10];
|
|
mesh::Utils::toHex(pub_key_hex, self_id.pub_key, 4);
|
|
strcpy(_prefs.node_name, pub_key_hex);
|
|
#endif
|
|
|
|
// if build provides default-scope, init with that
|
|
#ifdef DEFAULT_FLOOD_SCOPE_NAME
|
|
strcpy(_prefs.default_scope_name, DEFAULT_FLOOD_SCOPE_NAME);
|
|
{
|
|
TransportKeyStore temp;
|
|
TransportKey key;
|
|
temp.getAutoKeyFor(0, "#" DEFAULT_FLOOD_SCOPE_NAME, key);
|
|
memcpy(_prefs.default_scope_key, key.key, sizeof(key.key));
|
|
}
|
|
#endif
|
|
|
|
// load persisted prefs
|
|
const bool prefs_ready =
|
|
_store->loadPrefs(_prefs, sensors.node_lat, sensors.node_lon);
|
|
|
|
// v1.17.1.2 repairs the Companion default-off regression for both fresh
|
|
// installs and devices that already persisted the regressed value. The
|
|
// appended policy marker makes this a one-time migration, so a later
|
|
// explicit `powersaving off` choice remains persistent.
|
|
const bool power_saving_default_migrated =
|
|
migrateCompanionPowerSavingDefault(_prefs);
|
|
|
|
_prefs.node_name[sizeof(_prefs.node_name) - 1] = 0;
|
|
const bool bluetooth_name_had_terminator =
|
|
memchr(_prefs.bluetooth_name, 0, sizeof(_prefs.bluetooth_name)) != NULL;
|
|
_prefs.bluetooth_name[sizeof(_prefs.bluetooth_name) - 1] = 0;
|
|
const bool bluetooth_name_repaired =
|
|
!bluetooth_name_had_terminator
|
|
|| (_prefs.bluetooth_name[0] != 0
|
|
&& !mesh::companion::isValidBluetoothName(_prefs.bluetooth_name));
|
|
if (bluetooth_name_repaired) {
|
|
memset(_prefs.bluetooth_name, 0, sizeof(_prefs.bluetooth_name));
|
|
}
|
|
const bool display_rotation_repaired =
|
|
_prefs.display_rotation_degrees != 0
|
|
&& _prefs.display_rotation_degrees != 90
|
|
&& _prefs.display_rotation_degrees != 180
|
|
&& _prefs.display_rotation_degrees != 270;
|
|
if (display_rotation_repaired) {
|
|
_prefs.display_rotation_degrees = 0;
|
|
}
|
|
|
|
bool bluetooth_mac_repaired = false;
|
|
if (!mesh::companion::isValidBluetoothStealthMode(
|
|
_prefs.bluetooth_stealth_mode)) {
|
|
_prefs.bluetooth_stealth_mode = mesh::companion::BLUETOOTH_STEALTH_OFF;
|
|
bluetooth_mac_repaired = true;
|
|
}
|
|
if (!mesh::companion::isValidBluetoothMacMode(
|
|
_prefs.bluetooth_mac_mode)) {
|
|
_prefs.bluetooth_mac_mode =
|
|
mesh::companion::BLUETOOTH_MAC_DEFAULT;
|
|
memset(_prefs.bluetooth_mac, 0, sizeof(_prefs.bluetooth_mac));
|
|
clearCompanionBluetoothStealthPeer(_prefs);
|
|
bluetooth_mac_repaired = true;
|
|
} else if (mesh::companion::bluetoothMacModeUsesSavedAddress(
|
|
_prefs.bluetooth_mac_mode)
|
|
&& !mesh::companion::isValidBluetoothMac(
|
|
_prefs.bluetooth_mac)
|
|
&& !mesh::companion::bluetoothMacModeIsRandomAfterConnect(
|
|
_prefs.bluetooth_mac_mode)) {
|
|
_prefs.bluetooth_mac_mode =
|
|
mesh::companion::BLUETOOTH_MAC_DEFAULT;
|
|
memset(_prefs.bluetooth_mac, 0, sizeof(_prefs.bluetooth_mac));
|
|
clearCompanionBluetoothStealthPeer(_prefs);
|
|
bluetooth_mac_repaired = true;
|
|
}
|
|
|
|
mesh::companion::BluetoothPeerIdentity saved_stealth_peer;
|
|
saved_stealth_peer.type = _prefs.bluetooth_stealth_peer_type;
|
|
memcpy(saved_stealth_peer.address, _prefs.bluetooth_stealth_peer,
|
|
sizeof(saved_stealth_peer.address));
|
|
bool stealth_peer_payload_empty = true;
|
|
for (size_t i = 0; i < sizeof(_prefs.bluetooth_stealth_peer); i++) {
|
|
stealth_peer_payload_empty = stealth_peer_payload_empty
|
|
&& _prefs.bluetooth_stealth_peer[i] == 0;
|
|
}
|
|
if (_prefs.bluetooth_stealth_mode
|
|
== mesh::companion::BLUETOOTH_STEALTH_PAIRED
|
|
&& !mesh::companion::isValidBluetoothPeerIdentity(
|
|
saved_stealth_peer)) {
|
|
_prefs.bluetooth_stealth_mode = mesh::companion::BLUETOOTH_STEALTH_PAIRING;
|
|
bluetooth_mac_repaired = true;
|
|
}
|
|
if (_prefs.bluetooth_stealth_mode
|
|
!= mesh::companion::BLUETOOTH_STEALTH_PAIRED
|
|
&& (_prefs.bluetooth_stealth_peer_type
|
|
!= mesh::companion::BLUETOOTH_PEER_ADDRESS_NONE
|
|
|| !stealth_peer_payload_empty)) {
|
|
_prefs.bluetooth_stealth_peer_type =
|
|
mesh::companion::BLUETOOTH_PEER_ADDRESS_NONE;
|
|
memset(_prefs.bluetooth_stealth_peer, 0,
|
|
sizeof(_prefs.bluetooth_stealth_peer));
|
|
bluetooth_mac_repaired = true;
|
|
}
|
|
|
|
// sanitise bad pref values
|
|
_prefs.rx_delay_base = constrain(_prefs.rx_delay_base, 0, 20.0f);
|
|
_prefs.airtime_factor = constrain(_prefs.airtime_factor, 0, 9.0f);
|
|
_prefs.freq = constrain(_prefs.freq, 150.0f, 2500.0f);
|
|
_prefs.bw = constrain(_prefs.bw, 7.8f, 500.0f);
|
|
_prefs.sf = constrain(_prefs.sf, 5, 12);
|
|
_prefs.cr = constrain(_prefs.cr, 5, 8);
|
|
_prefs.tx_power_dbm = constrain(_prefs.tx_power_dbm, -9, MAX_LORA_TX_POWER);
|
|
_prefs.multi_acks = constrain(_prefs.multi_acks, 0, 1);
|
|
_prefs.manual_add_contacts = constrain(_prefs.manual_add_contacts, 0, 1);
|
|
_prefs.vibe_quiet = constrain(_prefs.vibe_quiet, 0, 1);
|
|
_prefs.gps_enabled = constrain(_prefs.gps_enabled, 0, 1); // Ensure boolean 0 or 1
|
|
_prefs.gps_interval = constrain(_prefs.gps_interval, 0, 86400); // Max 24 hours
|
|
_prefs.autoadd_config &= AUTO_ADD_OVERWRITE_OLDEST | AUTO_ADD_CHAT | AUTO_ADD_REPEATER | AUTO_ADD_ROOM_SERVER | AUTO_ADD_SENSOR;
|
|
_prefs.path_hash_mode = constrain(_prefs.path_hash_mode, 0, 2);
|
|
_prefs.radio_fem_rxgain_override = constrain(_prefs.radio_fem_rxgain_override, 0, 1);
|
|
if (!_prefs.radio_fem_rxgain_override) {
|
|
_prefs.radio_fem_rxgain = DEFAULT_FEM_RX_GAIN;
|
|
}
|
|
_prefs.radio_fem_rxgain = constrain(_prefs.radio_fem_rxgain, 0, 1);
|
|
_prefs.radio_fem_txgain = constrain(_prefs.radio_fem_txgain, 0, 1);
|
|
_prefs.rx_powersaving_enabled = constrain(_prefs.rx_powersaving_enabled, 0, 1);
|
|
_prefs.powersaving_enabled = constrain(_prefs.powersaving_enabled, 0, 1);
|
|
_prefs.wifi_enabled = constrain(_prefs.wifi_enabled, 0, 1);
|
|
_prefs.usb_logging_enabled = constrain(_prefs.usb_logging_enabled, 0, 1);
|
|
_prefs.cad_enabled = constrain(_prefs.cad_enabled, 0, 1);
|
|
if (_prefs.cad_scan_timeout_ms != 0
|
|
&& (_prefs.cad_scan_timeout_ms < mesh::CAD_SCAN_MIN_TIMEOUT_MS
|
|
|| _prefs.cad_scan_timeout_ms > mesh::CAD_SCAN_MAX_TIMEOUT_MS)) {
|
|
_prefs.cad_scan_timeout_ms = 0;
|
|
}
|
|
_prefs.rx_ps_level = constrain(_prefs.rx_ps_level, 0, 10);
|
|
if (_prefs.rx_ps_preamble != 16 && _prefs.rx_ps_preamble != 32) {
|
|
_prefs.rx_ps_preamble = 0;
|
|
}
|
|
ensureRxPowerSavingDefaults(&_prefs.rx_ps_rx_us, &_prefs.rx_ps_sleep_us);
|
|
recalcRxPowerSavingFromLevel(_prefs.rx_ps_level, _prefs.sf, _prefs.bw,
|
|
_prefs.rx_ps_preamble, &_prefs.rx_ps_rx_us,
|
|
&_prefs.rx_ps_sleep_us);
|
|
if (prefs_ready
|
|
&& (power_saving_default_migrated || bluetooth_name_repaired
|
|
|| display_rotation_repaired || bluetooth_mac_repaired)) {
|
|
_store->savePrefs(_prefs, sensors.node_lat, sensors.node_lon);
|
|
}
|
|
#if MESH_USB_LOGGING_AVAILABLE
|
|
const bool usb_logging_enabled = _prefs.usb_logging_enabled != 0;
|
|
mesh::setUsbLoggingEnabled(usb_logging_enabled);
|
|
if (!mesh::saveUsbLoggingBootPreference(usb_logging_enabled)) {
|
|
MESH_DEBUG_PRINTLN("Unable to save next-boot USB logging interface state");
|
|
}
|
|
#endif
|
|
|
|
#ifdef BLE_PIN_CODE // 123456 by default
|
|
if (_prefs.ble_pin == 0) {
|
|
#ifdef DISPLAY_CLASS
|
|
if (has_display && BLE_PIN_CODE == 123456) {
|
|
StdRNG rng;
|
|
_active_ble_pin = rng.nextInt(100000, 999999); // random pin each session
|
|
} else {
|
|
_active_ble_pin = BLE_PIN_CODE; // otherwise static pin
|
|
}
|
|
#else
|
|
_active_ble_pin = BLE_PIN_CODE; // otherwise static pin
|
|
#endif
|
|
} else {
|
|
_active_ble_pin = _prefs.ble_pin;
|
|
}
|
|
#else
|
|
_active_ble_pin = 0;
|
|
#endif
|
|
|
|
resetContacts();
|
|
_store->loadContacts(this);
|
|
if (_store->hasPendingContactWrites()) {
|
|
dirty_contacts_expiry = mesh::nonzeroLazyPersistenceDeadline(
|
|
futureMillis(LAZY_CONTACTS_WRITE_DELAY));
|
|
}
|
|
updateGpsTelemetryPolicy();
|
|
bootstrapRTCfromContacts();
|
|
addChannel("Public", PUBLIC_GROUP_PSK); // pre-configure Andy's public channel
|
|
if (is_new_install) {
|
|
addChannel("#testing", TESTING_GROUP_PSK);
|
|
}
|
|
// A saved table takes precedence over compiled defaults on later boots.
|
|
_store->loadChannels(this);
|
|
if (is_new_install) {
|
|
// Make the first-boot defaults survive before a companion app changes them.
|
|
_store->saveChannels(this);
|
|
}
|
|
|
|
#ifdef COMPANION_MESH_CLOCK_SYNC
|
|
// Fixed fallback policy for this Companion build. A successful host time
|
|
// update below suppresses mesh correction for the remainder of the boot.
|
|
_clock_sync.begin(nullptr);
|
|
#endif
|
|
|
|
configureRadioFromPrefs();
|
|
|
|
#if defined(WITH_MQTT_BRIDGE) && defined(ESP32_PLATFORM) && defined(WIFI_SSID)
|
|
#if defined(COMPANION_EXCLUSIVE_WIFI_BLE)
|
|
if (_prefs.wifi_enabled != 0) {
|
|
#endif
|
|
applyMQTTDefaults(&_mqtt_prefs);
|
|
_mqtt_configured = CompanionMqttSetupPortal::loadStoredConfig(_mqtt_prefs);
|
|
if (!_mqtt_configured) applyMQTTDefaults(&_mqtt_prefs);
|
|
// Companion WiFi owns the connection and its mesh-wifi NVS setting is
|
|
// canonical. Keep MQTT reconnects from restoring a stale MQTT-pref value.
|
|
_mqtt_prefs.wifi_power_save = getCompanionWiFiPowerSave();
|
|
|
|
MQTTNodeInfo node_info;
|
|
node_info.node_name = _prefs.node_name;
|
|
node_info.freq = &_prefs.freq;
|
|
node_info.bw = &_prefs.bw;
|
|
node_info.sf = &_prefs.sf;
|
|
node_info.cr = &_prefs.cr;
|
|
node_info.repeat_flag = &_prefs.client_repeat;
|
|
node_info.repeat_when_nonzero = true;
|
|
_mqtt_bridge = new MQTTBridge(node_info, &_mqtt_prefs,
|
|
getRTCClock(), &self_id, false);
|
|
if (_mqtt_bridge) {
|
|
char device_id[65];
|
|
mesh::Utils::toHex(device_id, self_id.pub_key, PUB_KEY_SIZE);
|
|
_mqtt_bridge->setDeviceID(device_id);
|
|
_mqtt_bridge->setFirmwareVersion(FIRMWARE_VERSION);
|
|
_mqtt_bridge->setBoardModel(board.getManufacturerName());
|
|
_mqtt_bridge->setBuildDate(FIRMWARE_BUILD_DATE);
|
|
_mqtt_bridge->setStatsSources(this, _radio, &board, _ms);
|
|
}
|
|
#if defined(COMPANION_EXCLUSIVE_WIFI_BLE)
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef WITH_WEBCONFIG
|
|
#if defined(COMPANION_EXCLUSIVE_WIFI_BLE)
|
|
if (_prefs.wifi_enabled != 0) {
|
|
#endif
|
|
void* web_mqtt_prefs = nullptr;
|
|
#ifdef WITH_MQTT_BRIDGE
|
|
web_mqtt_prefs = &_mqtt_prefs;
|
|
#endif
|
|
_webconfig = new WebConfigServer(this, web_mqtt_prefs, false,
|
|
self_id.pub_key, FIRMWARE_VERSION,
|
|
FIRMWARE_BUILD_DATE,
|
|
"companion", board.getManufacturerName());
|
|
#if defined(COMPANION_EXCLUSIVE_WIFI_BLE)
|
|
}
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
void MyMesh::configureRadioFromPrefs() {
|
|
board.attachDynamicPrefs(_prefs.getCustom());
|
|
|
|
if (!_radio_available) {
|
|
saved_radio_apply_pending = false;
|
|
board.setLoRaFemLnaEnabled(_prefs.radio_fem_rxgain);
|
|
board.setLoRaFemPaGainEnabled(_prefs.radio_fem_txgain);
|
|
MESH_DEBUG_PRINTLN("Radio unavailable: companion services are running in recovery mode");
|
|
return;
|
|
}
|
|
|
|
saved_radio_apply_pending = !applySavedRadioParams();
|
|
radio_driver.setCADScanTimeoutMillis(_prefs.cad_scan_timeout_ms);
|
|
_radio->setCADEnabled(_prefs.cad_enabled != 0);
|
|
if (!saved_radio_apply_pending) {
|
|
radio_driver.setTxPower(_prefs.tx_power_dbm);
|
|
radio_driver.setRxBoostedGainMode(_prefs.rx_boosted_gain);
|
|
}
|
|
const bool fem_gain_changed = board.canControlLoRaFemLna()
|
|
&& board.isLoRaFemLnaEnabled() != (_prefs.radio_fem_rxgain != 0);
|
|
if (board.setLoRaFemLnaEnabled(_prefs.radio_fem_rxgain) && fem_gain_changed) {
|
|
_radio->recalibrateNoiseFloor();
|
|
}
|
|
board.setLoRaFemPaGainEnabled(_prefs.radio_fem_txgain);
|
|
MESH_DEBUG_PRINTLN("RX Boosted Gain Mode: %s",
|
|
radio_driver.getRxBoostedGainMode() ? "Enabled" : "Disabled");
|
|
}
|
|
|
|
void MyMesh::activateRadio() {
|
|
if (_radio_available) return;
|
|
|
|
_radio_available = true;
|
|
setRadioAvailable(true);
|
|
configureRadioFromPrefs();
|
|
MESH_DEBUG_PRINTLN("Radio recovery completed; mesh transport is active");
|
|
}
|
|
|
|
mesh::RadioParamApplyResult MyMesh::tryApplyRadioParams(float freq, float bw, uint8_t sf, uint8_t cr) {
|
|
if (!_radio_available) return mesh::RadioParamApplyResult::FAILED;
|
|
|
|
uint32_t rx_us = _prefs.rx_ps_rx_us;
|
|
uint32_t sleep_us = _prefs.rx_ps_sleep_us;
|
|
if (_prefs.rx_powersaving_enabled && _prefs.rx_ps_level != 0
|
|
&& !recalcRxPowerSavingFromLevel(_prefs.rx_ps_level, sf, bw,
|
|
_prefs.rx_ps_preamble, &rx_us, &sleep_us)) {
|
|
return mesh::RadioParamApplyResult::FAILED;
|
|
}
|
|
uint32_t timings[2] = {rx_us, sleep_us};
|
|
const uint32_t* applied_timings = _prefs.rx_powersaving_enabled
|
|
&& radio_driver.supportsRxPowerSaving() ? timings : NULL;
|
|
return radio_driver.trySetParams(freq, bw, sf, cr, applied_timings);
|
|
}
|
|
|
|
bool MyMesh::applySavedRadioParams() {
|
|
return tryApplyRadioParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr)
|
|
== mesh::RadioParamApplyResult::APPLIED;
|
|
}
|
|
|
|
void MyMesh::finishRadioParamApply(float freq, float bw, uint8_t sf,
|
|
uint8_t cr, uint8_t repeat,
|
|
BaseSerialInterface* route) {
|
|
_prefs.sf = sf;
|
|
_prefs.cr = cr;
|
|
_prefs.freq = freq;
|
|
_prefs.bw = bw;
|
|
_prefs.client_repeat = repeat;
|
|
recalcRxPowerSavingFromLevel(_prefs.rx_ps_level, _prefs.sf, _prefs.bw,
|
|
_prefs.rx_ps_preamble, &_prefs.rx_ps_rx_us,
|
|
&_prefs.rx_ps_sleep_us);
|
|
savePrefs();
|
|
|
|
saved_radio_apply_pending = false;
|
|
radio_apply_retry_at = 0;
|
|
radio_apply_failures = 0;
|
|
|
|
MESH_DEBUG_PRINTLN("OK: CMD_SET_RADIO_PARAMS: f=%d, bw=%d, sf=%d, cr=%d",
|
|
(uint32_t)(freq * 1000.0f), (uint32_t)(bw * 1000.0f),
|
|
(uint32_t)sf, (uint32_t)cr);
|
|
writeOKFrame(route);
|
|
}
|
|
|
|
void MyMesh::cancelPendingRadioParamApply() {
|
|
if (!command_radio_apply_pending) return;
|
|
|
|
command_radio_apply_pending = false;
|
|
command_radio_apply_deadline = 0;
|
|
command_radio_reply_route = NULL;
|
|
// The requested tuple was not committed. Reassert the persisted tuple in
|
|
// case a failed hardware apply only restored part of the old configuration.
|
|
saved_radio_apply_pending = true;
|
|
radio_apply_retry_at = 0;
|
|
radio_apply_failures = 0;
|
|
}
|
|
|
|
void MyMesh::servicePendingRadioParamApply() {
|
|
if (!command_radio_apply_pending) return;
|
|
if (!_serial || !_serial->isReplyRouteAvailable(command_radio_reply_route)) {
|
|
cancelPendingRadioParamApply();
|
|
return;
|
|
}
|
|
|
|
// Leave enough queue headroom for the eventual command response.
|
|
if (_serial->isReplyRouteWriteBusy(command_radio_reply_route)) return;
|
|
|
|
mesh::RadioParamApplyResult result = tryApplyRadioParams(
|
|
command_radio_freq, command_radio_bw, command_radio_sf, command_radio_cr);
|
|
if (result == mesh::RadioParamApplyResult::APPLIED) {
|
|
float freq = command_radio_freq;
|
|
float bw = command_radio_bw;
|
|
uint8_t sf = command_radio_sf;
|
|
uint8_t cr = command_radio_cr;
|
|
uint8_t repeat = command_radio_repeat;
|
|
BaseSerialInterface* route = command_radio_reply_route;
|
|
command_radio_apply_pending = false;
|
|
command_radio_apply_deadline = 0;
|
|
command_radio_reply_route = NULL;
|
|
finishRadioParamApply(freq, bw, sf, cr, repeat, route);
|
|
} else if (result == mesh::RadioParamApplyResult::FAILED) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG, command_radio_reply_route);
|
|
cancelPendingRadioParamApply();
|
|
} else if (command_radio_apply_deadline == _ms->getMillis()
|
|
|| millisHasNowPassed(command_radio_apply_deadline)) {
|
|
writeErrFrame(ERR_CODE_BAD_STATE, command_radio_reply_route);
|
|
cancelPendingRadioParamApply();
|
|
}
|
|
}
|
|
|
|
#if COMPANION_FEATURE_TEMP_RADIO
|
|
static bool isFullCompanionBandwidth(float bw) {
|
|
static const float supported[] = {
|
|
7.8f, 10.4f, 15.6f, 20.8f, 31.25f, 41.7f,
|
|
62.5f, 125.0f, 250.0f, 500.0f
|
|
};
|
|
for (float candidate : supported) {
|
|
if (fabsf(candidate - bw) <= 0.01f) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool MyMesh::scheduleTempRadio(float freq, float bw, uint8_t sf, uint8_t cr,
|
|
uint32_t timeout_mins, char* reply,
|
|
size_t reply_size) {
|
|
if (command_radio_apply_pending) {
|
|
snprintf(reply, reply_size, "ERR companion radio change is already pending");
|
|
return false;
|
|
}
|
|
|
|
#if defined(OTA_SHARED_COMPANION_QUEUE)
|
|
if (!mesh::ota::ota_acquire_context(reply, reply_size)) return false;
|
|
mesh::ota::ota_ctx().release_when_idle = false;
|
|
#endif
|
|
_temp_radio_freq = freq;
|
|
_temp_radio_bw = bw;
|
|
_temp_radio_sf = sf;
|
|
_temp_radio_cr = cr;
|
|
_temp_radio_set_at = futureMillis(1500); // let the local reply drain first
|
|
_temp_radio_revert_at = futureMillis(1500 + (int)(timeout_mins * 60000UL));
|
|
_temp_radio_retry_at = 0;
|
|
_temp_radio_failures = 0;
|
|
snprintf(reply, reply_size, "OK - temp params for %lu mins",
|
|
(unsigned long)timeout_mins);
|
|
appendRxPowerSavingAdjustmentNote(reply, reply_size, sf, bw);
|
|
return true;
|
|
}
|
|
|
|
void MyMesh::scheduleNormalRadio(char* reply, size_t reply_size) {
|
|
_temp_radio_set_at = 0;
|
|
_temp_radio_revert_at = futureMillis(1500); // keep the reply on the active tuple
|
|
_temp_radio_retry_at = 0;
|
|
_temp_radio_failures = 0;
|
|
snprintf(reply, reply_size, "OK - normal radio restore scheduled");
|
|
}
|
|
#endif
|
|
|
|
static bool parseCadTimingMillis(const char* text, uint32_t minimum,
|
|
uint32_t maximum, uint16_t& result) {
|
|
if (strcmp(text, "auto") == 0 || strcmp(text, "0") == 0) {
|
|
result = 0;
|
|
return true;
|
|
}
|
|
|
|
uint32_t parsed = 0;
|
|
if (!mesh::cli::parseUnsignedIntegerStrict(text, parsed)
|
|
|| parsed < minimum || parsed > maximum) {
|
|
return false;
|
|
}
|
|
result = (uint16_t)parsed;
|
|
return true;
|
|
}
|
|
|
|
bool MyMesh::handleCadCommand(const char* command, char* reply,
|
|
size_t reply_size) {
|
|
if (command == NULL || reply == NULL || reply_size == 0) return false;
|
|
|
|
if (strcmp(command, "get radio.cad") == 0
|
|
|| strcmp(command, "get cad") == 0) {
|
|
char scan[32];
|
|
char retry[24];
|
|
char maximum[24];
|
|
if (_prefs.cad_scan_timeout_ms == 0) {
|
|
uint32_t effective = _radio_available
|
|
? radio_driver.getCADScanTimeoutMillis() : 0;
|
|
if (effective == 0) {
|
|
effective = mesh::calculateCadScanTimeoutMillis(_prefs.sf, _prefs.bw);
|
|
}
|
|
snprintf(scan, sizeof(scan), "auto(%lu)", (unsigned long)effective);
|
|
} else {
|
|
snprintf(scan, sizeof(scan), "%u", (unsigned)_prefs.cad_scan_timeout_ms);
|
|
}
|
|
if (_prefs.cad_retry_delay_ms == 0) {
|
|
snprintf(retry, sizeof(retry), "auto");
|
|
} else {
|
|
snprintf(retry, sizeof(retry), "%u", (unsigned)_prefs.cad_retry_delay_ms);
|
|
}
|
|
if (_prefs.cad_max_duration_ms == 0) {
|
|
snprintf(maximum, sizeof(maximum), "auto");
|
|
} else {
|
|
snprintf(maximum, sizeof(maximum), "%u", (unsigned)_prefs.cad_max_duration_ms);
|
|
}
|
|
snprintf(reply, reply_size,
|
|
"radio.cad %s, scan=%s ms, retry=%s ms, max=%s ms",
|
|
_prefs.cad_enabled ? "on" : "off", scan, retry, maximum);
|
|
return true;
|
|
}
|
|
|
|
const char* value = NULL;
|
|
if (strncmp(command, "set radio.cad", 13) == 0
|
|
&& (command[13] == 0 || command[13] == ' '
|
|
|| command[13] == '\t')) {
|
|
value = command + 13;
|
|
} else if (strncmp(command, "set cad", 7) == 0
|
|
&& (command[7] == 0 || command[7] == ' '
|
|
|| command[7] == '\t')) {
|
|
value = command + 7;
|
|
} else {
|
|
return false;
|
|
}
|
|
while (*value == ' ' || *value == '\t') value++;
|
|
|
|
if (strcmp(value, "on") == 0 || strcmp(value, "off") == 0) {
|
|
const uint8_t previous = _prefs.cad_enabled;
|
|
_prefs.cad_enabled = strcmp(value, "on") == 0 ? 1 : 0;
|
|
if (_radio_available) _radio->setCADEnabled(_prefs.cad_enabled != 0);
|
|
if (!savePrefs()) {
|
|
_prefs.cad_enabled = previous;
|
|
if (_radio_available) _radio->setCADEnabled(previous != 0);
|
|
snprintf(reply, reply_size, "Error: CAD changed but save failed");
|
|
} else {
|
|
snprintf(reply, reply_size, "OK - radio.cad %s", value);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (strncmp(value, "timings", 7) == 0
|
|
&& (value[7] == 0 || value[7] == ' ' || value[7] == '\t')) {
|
|
value += 7;
|
|
while (*value == ' ' || *value == '\t') value++;
|
|
char token_storage[64] = {0};
|
|
const char* tokens[3] = {NULL};
|
|
size_t token_count = 0;
|
|
uint16_t scan_ms;
|
|
uint16_t retry_ms;
|
|
uint16_t max_ms;
|
|
if (!mesh::cli::splitWhitespaceFieldsStrict(
|
|
value, token_storage, sizeof(token_storage), tokens, 3,
|
|
token_count)
|
|
|| token_count != 3
|
|
|| !parseCadTimingMillis(tokens[0],
|
|
mesh::CAD_SCAN_MIN_TIMEOUT_MS,
|
|
mesh::CAD_SCAN_MAX_TIMEOUT_MS, scan_ms)
|
|
|| !parseCadTimingMillis(tokens[1], 1, 60000, retry_ms)
|
|
|| !parseCadTimingMillis(tokens[2], 1, 60000, max_ms)) {
|
|
snprintf(reply, reply_size,
|
|
"Error: use set radio.cad timings <auto|100-3500> <auto|1-60000> <auto|1-60000>");
|
|
return true;
|
|
}
|
|
|
|
const uint16_t previous_scan = _prefs.cad_scan_timeout_ms;
|
|
const uint16_t previous_retry = _prefs.cad_retry_delay_ms;
|
|
const uint16_t previous_max = _prefs.cad_max_duration_ms;
|
|
if (_radio_available && !radio_driver.setCADScanTimeoutMillis(scan_ms)) {
|
|
snprintf(reply, reply_size, "Error: CAD scan timing is unsupported");
|
|
return true;
|
|
}
|
|
_prefs.cad_scan_timeout_ms = scan_ms;
|
|
_prefs.cad_retry_delay_ms = retry_ms;
|
|
_prefs.cad_max_duration_ms = max_ms;
|
|
if (!savePrefs()) {
|
|
_prefs.cad_scan_timeout_ms = previous_scan;
|
|
_prefs.cad_retry_delay_ms = previous_retry;
|
|
_prefs.cad_max_duration_ms = previous_max;
|
|
if (_radio_available) radio_driver.setCADScanTimeoutMillis(previous_scan);
|
|
snprintf(reply, reply_size, "Error: CAD timings changed but save failed");
|
|
} else {
|
|
snprintf(reply, reply_size, "OK - radio.cad timings saved");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
snprintf(reply, reply_size,
|
|
"Error: use set radio.cad <on|off> or set radio.cad timings <scan_ms|auto> <retry_ms|auto> <max_ms|auto>");
|
|
return true;
|
|
}
|
|
|
|
bool MyMesh::handleLocalControlCommand(const char* command, char* reply,
|
|
size_t reply_size) {
|
|
if (!command || !reply || reply_size == 0) return false;
|
|
while (*command == ' ') command++;
|
|
|
|
#if defined(ESP32_PLATFORM) && defined(COMPANION_RADIO_FULL)
|
|
if (strcmp(command, "start ota") == 0
|
|
|| strcmp(command, "start ota ap") == 0) {
|
|
#if defined(COMPANION_EXCLUSIVE_WIFI_BLE)
|
|
if (!isCompanionWiFiEnabled()) {
|
|
snprintf(reply, reply_size,
|
|
"ERR: select WiFi transport and reboot before starting WiFi OTA");
|
|
return true;
|
|
}
|
|
#endif
|
|
// Board implementations use the common 160-byte CLI reply contract.
|
|
// Binary Companion callers may supply a shorter buffer.
|
|
char ota_reply[160] = {0};
|
|
if (!board.startOTAUpdate(_prefs.node_name, ota_reply,
|
|
strcmp(command, "start ota ap") == 0)) {
|
|
snprintf(reply, reply_size, "%s",
|
|
ota_reply[0] ? ota_reply : "ERR: WiFi OTA unavailable");
|
|
} else {
|
|
snprintf(reply, reply_size, "%s", ota_reply);
|
|
}
|
|
return true;
|
|
}
|
|
if (strcmp(command, "stop ota") == 0) {
|
|
char ota_reply[160] = {0};
|
|
if (!board.stopOTAUpdate(ota_reply) && !ota_reply[0]) {
|
|
snprintf(ota_reply, sizeof(ota_reply), "ERR: WiFi OTA unavailable");
|
|
}
|
|
snprintf(reply, reply_size, "%s", ota_reply);
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
if (strcmp(command, "board") == 0) {
|
|
const char* hardware_name = board.getManufacturerName();
|
|
snprintf(reply, reply_size, "%s",
|
|
hardware_name != NULL ? hardware_name : "Unknown hardware");
|
|
return true;
|
|
}
|
|
|
|
if (strcmp(command, "version") == 0) {
|
|
snprintf(reply, reply_size, "Companion %s (protocol %u, build %s)",
|
|
FIRMWARE_VERSION, (unsigned)FIRMWARE_VER_CODE,
|
|
FIRMWARE_BUILD_DATE);
|
|
return true;
|
|
}
|
|
|
|
if (strncmp(command, "get ", 4) == 0 &&
|
|
mesh::cli::handleStorageLayoutGet(command + 4, board, reply,
|
|
reply_size)) {
|
|
return true;
|
|
}
|
|
|
|
if (strcmp(command, "get pwrmgt.bootreason") == 0
|
|
|| strcmp(command, "powerlog") == 0) {
|
|
if (!board.isPowerManagementInitialized()) {
|
|
snprintf(reply, reply_size, "Error: power management unsupported");
|
|
} else {
|
|
snprintf(reply, reply_size, "> Reset: %s; Shutdown: %s",
|
|
board.getResetReasonString(board.getResetReason()),
|
|
board.getShutdownReasonString(board.getShutdownReason()));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (strcmp(command, "get contact.cache.timing") == 0) {
|
|
#if MESH_CONTACT_CACHE
|
|
const auto& cache = mesh::contactSecretCache();
|
|
snprintf(reply, reply_size, "last_flash_us=%lu last_calculation_us=%lu",
|
|
(unsigned long)cache.last_flash_read_us,
|
|
(unsigned long)cache.last_calculation_us);
|
|
#else
|
|
snprintf(reply, reply_size, "contact cache disabled");
|
|
#endif
|
|
return true;
|
|
}
|
|
if (strcmp(command, "get contact.cache") == 0) {
|
|
#if MESH_CONTACT_CACHE
|
|
const auto& cache = mesh::contactSecretCache();
|
|
snprintf(reply, reply_size, "paths=16 secrets=16 miss=%s ram_hits=%lu flash_hits=%lu calculations=%lu save_skips=%lu",
|
|
MESH_CONTACT_SECRET_FLASH_CACHE ? "flash" : "calculate",
|
|
(unsigned long)cache.ram_hits, (unsigned long)cache.flash_hits,
|
|
(unsigned long)cache.calculations, (unsigned long)cache.save_failures);
|
|
#else
|
|
snprintf(reply, reply_size, "paths=inline secrets=inline");
|
|
#endif
|
|
return true;
|
|
}
|
|
#if COMPANION_FEATURE_MEMORY_DIAGNOSTICS
|
|
if (strcmp(command, "memory") == 0) {
|
|
const mesh::CompanionMemoryDiagnostics diagnostics = {
|
|
(uint32_t)ESP.getFreeHeap(),
|
|
(uint32_t)ESP.getMinFreeHeap(),
|
|
(uint32_t)ESP.getMaxAllocHeap(),
|
|
(uint32_t)heap_caps_get_free_size(MALLOC_CAP_INTERNAL),
|
|
(uint32_t)heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL),
|
|
(uint32_t)ESP.getFreePsram(),
|
|
(uint32_t)ESP.getPsramSize(),
|
|
offline_queue_len,
|
|
getOfflineQueueCapacity()
|
|
};
|
|
mesh::formatCompanionMemoryDiagnostics(reply, reply_size, diagnostics);
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
if (handleCadCommand(command, reply, reply_size)) return true;
|
|
|
|
if (strcmp(command, "get radio.rxgain") == 0) {
|
|
if (!radio_driver.supportsRxBoostedGainMode()) {
|
|
snprintf(reply, reply_size, "Error: unsupported");
|
|
} else {
|
|
snprintf(reply, reply_size, "> %s",
|
|
_prefs.rx_boosted_gain ? "on" : "off");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (strncmp(command, "set radio.rxgain ", 17) == 0) {
|
|
const char* value = command + 17;
|
|
if (strcmp(value, "on") != 0 && strcmp(value, "off") != 0) {
|
|
snprintf(reply, reply_size,
|
|
"Error: use set radio.rxgain on|off");
|
|
} else if (!radio_driver.supportsRxBoostedGainMode()) {
|
|
snprintf(reply, reply_size, "Error: unsupported");
|
|
} else if (!applyAndSaveRxBoostedGain(strcmp(value, "on") == 0)) {
|
|
snprintf(reply, reply_size, "Error: radio busy or save failed");
|
|
} else {
|
|
snprintf(reply, reply_size, "OK - radio.rxgain %s", value);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (strcmp(command, "get radio.fem.rxgain") == 0) {
|
|
if (!board.canControlLoRaFemLna()) {
|
|
snprintf(reply, reply_size, "Error: unsupported");
|
|
} else {
|
|
snprintf(reply, reply_size, "> %s",
|
|
board.isLoRaFemLnaEnabled() ? "on" : "off");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (strncmp(command, "set radio.fem.rxgain ", 21) == 0) {
|
|
const char* value = command + 21;
|
|
if (strcmp(value, "on") != 0 && strcmp(value, "off") != 0) {
|
|
snprintf(reply, reply_size,
|
|
"Error: use set radio.fem.rxgain on|off");
|
|
} else if (!board.canControlLoRaFemLna()) {
|
|
snprintf(reply, reply_size, "Error: unsupported");
|
|
} else if (!applyAndSaveFemRxGain(strcmp(value, "on") == 0)) {
|
|
snprintf(reply, reply_size, "Error: failed to apply or save FEM RX gain");
|
|
} else {
|
|
snprintf(reply, reply_size, "OK - radio.fem.rxgain %s", value);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (strcmp(command, "get radio.fem.txgain") == 0) {
|
|
if (!board.canControlLoRaFemPaGain()) {
|
|
snprintf(reply, reply_size, "Error: unsupported");
|
|
} else {
|
|
snprintf(reply, reply_size, "> %s",
|
|
board.isLoRaFemPaGainEnabled() ? "on" : "off");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (strncmp(command, "set radio.fem.txgain ", 21) == 0) {
|
|
const char* value = command + 21;
|
|
if (strcmp(value, "on") != 0 && strcmp(value, "off") != 0) {
|
|
snprintf(reply, reply_size,
|
|
"Error: use set radio.fem.txgain on|off");
|
|
} else if (!board.canControlLoRaFemPaGain()) {
|
|
snprintf(reply, reply_size, "Error: unsupported");
|
|
} else if (!applyAndSaveFemTxGain(strcmp(value, "on") == 0)) {
|
|
snprintf(reply, reply_size, "Error: failed to apply or save FEM TX gain");
|
|
} else {
|
|
snprintf(reply, reply_size, "OK - radio.fem.txgain %s", value);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (strcmp(command, "get display.rotation") == 0) {
|
|
if (_ui == NULL || !_ui->supportsDisplayRotation()) {
|
|
snprintf(reply, reply_size, "Error: display rotation is unsupported");
|
|
} else if (_prefs.display_rotation_degrees == 0) {
|
|
snprintf(reply, reply_size, "display.rotation default");
|
|
} else {
|
|
snprintf(reply, reply_size, "display.rotation %u",
|
|
(unsigned)_prefs.display_rotation_degrees);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (strncmp(command, "set display.rotation", 20) == 0
|
|
&& (command[20] == 0 || command[20] == ' '
|
|
|| command[20] == '\t')) {
|
|
const char* value = command + 20;
|
|
while (*value == ' ' || *value == '\t') value++;
|
|
char* end = NULL;
|
|
const unsigned long degrees = strtoul(value, &end, 10);
|
|
while (end != NULL && (*end == ' ' || *end == '\t')) end++;
|
|
const bool valid = value[0] != 0 && end != NULL && *end == 0
|
|
&& (degrees == 0 || degrees == 90 || degrees == 180
|
|
|| degrees == 270);
|
|
if (!valid) {
|
|
snprintf(reply, reply_size,
|
|
"Error: use set display.rotation <0|90|180|270>");
|
|
} else if (_ui == NULL || !_ui->supportsDisplayRotation()) {
|
|
snprintf(reply, reply_size, "Error: display rotation is unsupported");
|
|
} else {
|
|
const uint16_t previous = _prefs.display_rotation_degrees;
|
|
if (!_ui->setDisplayRotationDegrees((uint16_t)degrees)) {
|
|
snprintf(reply, reply_size, "Error: display rotation failed");
|
|
} else {
|
|
_prefs.display_rotation_degrees = (uint16_t)degrees;
|
|
if (!savePrefs()) {
|
|
_prefs.display_rotation_degrees = previous;
|
|
_ui->setDisplayRotationDegrees(previous);
|
|
snprintf(reply, reply_size,
|
|
"Error: display rotation changed but save failed");
|
|
} else if (degrees == 0) {
|
|
snprintf(reply, reply_size,
|
|
"OK - display rotation reset to board default");
|
|
} else {
|
|
snprintf(reply, reply_size, "OK - display rotation %lu",
|
|
degrees);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (strcmp(command, "get bluetooth.name") == 0
|
|
|| strcmp(command, "get ble.name") == 0) {
|
|
formatBluetoothNameStatus(reply, reply_size);
|
|
return true;
|
|
}
|
|
|
|
const char* bluetooth_name_value = NULL;
|
|
if (strncmp(command, "set bluetooth.name", 18) == 0
|
|
&& (command[18] == 0 || command[18] == ' '
|
|
|| command[18] == '\t')) {
|
|
bluetooth_name_value = command + 18;
|
|
} else if (strncmp(command, "set ble.name", 12) == 0
|
|
&& (command[12] == 0 || command[12] == ' '
|
|
|| command[12] == '\t')) {
|
|
bluetooth_name_value = command + 12;
|
|
}
|
|
if (bluetooth_name_value != NULL) {
|
|
while (*bluetooth_name_value == ' ' || *bluetooth_name_value == '\t') {
|
|
bluetooth_name_value++;
|
|
}
|
|
if (bluetooth_name_value[0] == 0) {
|
|
snprintf(reply, reply_size,
|
|
"Error: use set bluetooth.name <name|default>");
|
|
} else {
|
|
const bool clear_override = strcmp(bluetooth_name_value, "default") == 0
|
|
|| strcmp(bluetooth_name_value, "clear") == 0;
|
|
applyAndSaveBluetoothName(clear_override ? "" : bluetooth_name_value,
|
|
reply, reply_size);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#if defined(BLE_PIN_CODE)
|
|
if (strcmp(command, "get bluetooth.stealth") == 0
|
|
|| strcmp(command, "get ble.stealth") == 0) {
|
|
formatBluetoothStealthStatus(reply, reply_size);
|
|
return true;
|
|
}
|
|
|
|
const char* bluetooth_stealth_value = NULL;
|
|
if (strncmp(command, "set bluetooth.stealth", 21) == 0
|
|
&& (command[21] == 0 || command[21] == ' '
|
|
|| command[21] == '\t')) {
|
|
bluetooth_stealth_value = command + 21;
|
|
} else if (strncmp(command, "set ble.stealth", 15) == 0
|
|
&& (command[15] == 0 || command[15] == ' '
|
|
|| command[15] == '\t')) {
|
|
bluetooth_stealth_value = command + 15;
|
|
}
|
|
if (bluetooth_stealth_value != NULL) {
|
|
while (*bluetooth_stealth_value == ' ' || *bluetooth_stealth_value == '\t') {
|
|
bluetooth_stealth_value++;
|
|
}
|
|
applyAndSaveBluetoothStealth(bluetooth_stealth_value, reply, reply_size);
|
|
return true;
|
|
}
|
|
|
|
if (strcmp(command, "get bluetooth.mac") == 0
|
|
|| strcmp(command, "get ble.mac") == 0) {
|
|
formatBluetoothMacStatus(reply, reply_size);
|
|
return true;
|
|
}
|
|
|
|
const char* bluetooth_mac_value = NULL;
|
|
if (strncmp(command, "set bluetooth.mac", 17) == 0
|
|
&& (command[17] == 0 || command[17] == ' '
|
|
|| command[17] == '\t')) {
|
|
bluetooth_mac_value = command + 17;
|
|
} else if (strncmp(command, "set ble.mac", 11) == 0
|
|
&& (command[11] == 0 || command[11] == ' '
|
|
|| command[11] == '\t')) {
|
|
bluetooth_mac_value = command + 11;
|
|
}
|
|
if (bluetooth_mac_value != NULL) {
|
|
while (*bluetooth_mac_value == ' ' || *bluetooth_mac_value == '\t') {
|
|
bluetooth_mac_value++;
|
|
}
|
|
if (bluetooth_mac_value[0] == 0) {
|
|
snprintf(reply, reply_size,
|
|
"Error: use set bluetooth.mac <address|random|random-every-boot|random-after-connect|default>");
|
|
} else {
|
|
applyAndSaveBluetoothMac(bluetooth_mac_value, reply, reply_size);
|
|
}
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
if (strncmp(command, "set pin", 7) == 0
|
|
&& (command[7] == 0 || command[7] == ' '
|
|
|| command[7] == '\t')) {
|
|
const char* value = command + 7;
|
|
while (*value == ' ' || *value == '\t') value++;
|
|
int32_t parsed = 0;
|
|
if (!mesh::cli::parseIntegerStrict(value, parsed)
|
|
|| parsed < 0 || parsed > 999999) {
|
|
snprintf(reply, reply_size, "Error: pin must be 0-999999");
|
|
} else {
|
|
const uint32_t previous = _prefs.ble_pin;
|
|
_prefs.ble_pin = static_cast<uint32_t>(parsed);
|
|
if (!savePrefs()) {
|
|
_prefs.ble_pin = previous;
|
|
snprintf(reply, reply_size, "Error: pin changed but save failed");
|
|
} else {
|
|
snprintf(reply, reply_size, "> pin is now %06lu",
|
|
(unsigned long)_prefs.ble_pin);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#if defined(MESH_PRIMARY_ESPNOW) && MESH_PRIMARY_ESPNOW
|
|
if (strcmp(command, "get espnow.channel") == 0) {
|
|
formatEspNowChannel(reply, reply_size);
|
|
return true;
|
|
}
|
|
|
|
if (strncmp(command, "set espnow.channel", 18) == 0
|
|
&& (command[18] == 0 || command[18] == ' '
|
|
|| command[18] == '\t')) {
|
|
const char* value = command + 18;
|
|
while (*value == ' ' || *value == '\t') value++;
|
|
applyAndSaveEspNowChannel(value, reply, reply_size);
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
#if defined(ESP32) && defined(WIFI_SSID)
|
|
if (strcmp(command, "get display.wifi") == 0) {
|
|
formatCompanionWiFiDisplayStatus(reply, reply_size);
|
|
return true;
|
|
}
|
|
|
|
#if defined(COMPANION_EXCLUSIVE_WIFI_BLE)
|
|
if (strcmp(command, "get companion.transport") == 0) {
|
|
snprintf(reply, reply_size, "%s",
|
|
getCompanionTransportMode() == CompanionTransportMode::WiFi
|
|
? "wifi" : "ble");
|
|
return true;
|
|
}
|
|
|
|
if (strncmp(command, "set companion.transport", 23) == 0
|
|
&& (command[23] == 0 || command[23] == ' '
|
|
|| command[23] == '\t')) {
|
|
const char* value = command + 23;
|
|
while (*value == ' ' || *value == '\t') value++;
|
|
CompanionTransportMode selected;
|
|
if (strcmp(value, "wifi") == 0) {
|
|
selected = CompanionTransportMode::WiFi;
|
|
} else if (strcmp(value, "ble") == 0) {
|
|
selected = CompanionTransportMode::Bluetooth;
|
|
} else {
|
|
snprintf(reply, reply_size,
|
|
"Error: use set companion.transport <wifi|ble>");
|
|
return true;
|
|
}
|
|
if (!selectCompanionTransportMode(selected)) {
|
|
snprintf(reply, reply_size,
|
|
"Error: failed to save companion transport");
|
|
} else {
|
|
snprintf(reply, reply_size,
|
|
"OK - companion transport %s saved; reboot required", value);
|
|
}
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
#ifdef WITH_WEBCONFIG
|
|
if (strncmp(command, "get ", 4) == 0) {
|
|
const mesh::cli::StandaloneWiFiKey wifi_key =
|
|
mesh::cli::classifyStandaloneWiFiGet(command + 4);
|
|
switch (wifi_key) {
|
|
case mesh::cli::StandaloneWiFiKey::SSID:
|
|
WebConfigServer::formatWiFiSSID(reply, reply_size);
|
|
return true;
|
|
case mesh::cli::StandaloneWiFiKey::Status:
|
|
formatCompanionWiFiStatus(reply, reply_size);
|
|
return true;
|
|
case mesh::cli::StandaloneWiFiKey::CLI:
|
|
// Companion WebConfig deliberately has no browser command terminal:
|
|
// the page is not an authenticated repeater/room-server admin
|
|
// surface. Do not report the saved global WebConfig preference as
|
|
// "waiting", because supportsCliTerminal() is false for this role and
|
|
// /api/cli can therefore never become active. The Full Companion text
|
|
// CLI remains available over USB and TCP port 5002.
|
|
snprintf(reply, reply_size,
|
|
"Error: browser CLI unavailable; use USB (or TCP 5002 on Full Companion)");
|
|
return true;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (strncmp(command, "set ", 4) == 0) {
|
|
const char* value = NULL;
|
|
const mesh::cli::StandaloneWiFiKey wifi_key =
|
|
mesh::cli::classifyStandaloneWiFiSet(command + 4, &value);
|
|
bool saved = false;
|
|
switch (wifi_key) {
|
|
case mesh::cli::StandaloneWiFiKey::SSID:
|
|
saved = WebConfigServer::setStandaloneWiFiSSID(
|
|
value, reply, reply_size);
|
|
break;
|
|
case mesh::cli::StandaloneWiFiKey::Password:
|
|
saved = WebConfigServer::setStandaloneWiFiPassword(
|
|
value, reply, reply_size);
|
|
break;
|
|
case mesh::cli::StandaloneWiFiKey::CLI:
|
|
// See the matching getter above. In particular, do not persist a
|
|
// preference and claim success for a terminal this role cannot serve.
|
|
snprintf(reply, reply_size,
|
|
"Error: browser CLI unavailable; use USB (or TCP 5002 on Full Companion)");
|
|
return true;
|
|
default:
|
|
break;
|
|
}
|
|
if (wifi_key == mesh::cli::StandaloneWiFiKey::SSID
|
|
|| wifi_key == mesh::cli::StandaloneWiFiKey::Password) {
|
|
if (saved) {
|
|
char saved_ssid[32] = {0};
|
|
char saved_password[65] = {0};
|
|
uint8_t saved_power_save = mesh::wifi::kDefaultPowerSave;
|
|
const bool has_ssid = WebConfigServer::loadStandaloneWiFi(
|
|
saved_ssid, sizeof(saved_ssid), saved_password,
|
|
sizeof(saved_password), &saved_power_save);
|
|
memset(saved_password, 0, sizeof(saved_password));
|
|
if (_webconfig) {
|
|
_webconfig->reloadStandaloneWiFi();
|
|
if (has_ssid && _webconfig->isRunning()) {
|
|
_webconfig->requestStop();
|
|
}
|
|
}
|
|
if (has_ssid) {
|
|
scheduleCompanionWiFiCredentialReload();
|
|
snprintf(reply, reply_size,
|
|
"OK - WiFi %s saved; reconnect scheduled",
|
|
wifi_key == mesh::cli::StandaloneWiFiKey::SSID
|
|
? "SSID" : "password");
|
|
} else {
|
|
snprintf(reply, reply_size,
|
|
"OK - WiFi password saved; set wifi.ssid to connect");
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (strcmp(command, "get webui") == 0) {
|
|
const bool enabled = WebConfigServer::loadEnabled(true);
|
|
if (!_webconfig
|
|
|| (!_webconfig->isRunning() && !_webconfig->isStopping())) {
|
|
snprintf(reply, reply_size, "> %s, inactive", enabled ? "on" : "off");
|
|
} else if (_webconfig->mode() == WebConfigServer::MODE_SETUP) {
|
|
char ssid[33] = {0};
|
|
char ip[16] = {0};
|
|
WebConfigServer::getSetupInfo(ssid, sizeof(ssid), ip, sizeof(ip));
|
|
snprintf(reply, reply_size, "> %s, setup AP %s http://%s/",
|
|
enabled ? "on" : "off", ssid, ip);
|
|
} else if (_webconfig->mode() == WebConfigServer::MODE_CONNECTING) {
|
|
snprintf(reply, reply_size, "> %s, connecting to WiFi",
|
|
enabled ? "on" : "off");
|
|
} else {
|
|
snprintf(reply, reply_size, "> %s, http://%s/",
|
|
enabled ? "on" : "off",
|
|
WiFi.localIP().toString().c_str());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (strcmp(command, "set webui on") == 0
|
|
|| strcmp(command, "set webui off") == 0) {
|
|
const bool enabled = command[10] == 'o' && command[11] == 'n';
|
|
if (!WebConfigServer::saveEnabled(enabled)) {
|
|
snprintf(reply, reply_size, "Error: failed to save webui setting");
|
|
} else if (!enabled) {
|
|
if (_webconfig && _webconfig->isRunning()) _webconfig->requestStop();
|
|
snprintf(reply, reply_size, "OK - webui off");
|
|
} else if (_webconfig
|
|
&& (_webconfig->isRunning() || _webconfig->isStopping())) {
|
|
snprintf(reply, reply_size, "OK - webui on (already active)");
|
|
} else {
|
|
char start_reply[160] = {0};
|
|
startWebConfig(false, start_reply);
|
|
if (strncmp(start_reply, "WebConfig", 9) == 0) {
|
|
snprintf(reply, reply_size, "OK - webui on; %s", start_reply);
|
|
} else {
|
|
snprintf(reply, reply_size, "%s", start_reply);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (strncmp(command, "set webui", 9) == 0
|
|
&& (command[9] == 0 || command[9] == ' ' || command[9] == '\t')) {
|
|
snprintf(reply, reply_size, "Error: usage set webui on|off");
|
|
return true;
|
|
}
|
|
|
|
if (strcmp(command, "start webconfig") == 0
|
|
|| strcmp(command, "start webconfig ap") == 0) {
|
|
startWebConfig(strcmp(command, "start webconfig ap") == 0, reply);
|
|
return true;
|
|
}
|
|
if (strncmp(command, "start webconfig", 15) == 0
|
|
&& (command[15] == 0 || command[15] == ' ' || command[15] == '\t')) {
|
|
snprintf(reply, reply_size, "ERR: usage start webconfig [ap]");
|
|
return true;
|
|
}
|
|
if (strcmp(command, "stop webconfig") == 0) {
|
|
if (!_webconfig || !_webconfig->isRunning()) {
|
|
snprintf(reply, reply_size, "Err: webconfig not running");
|
|
} else {
|
|
_webconfig->requestStop();
|
|
snprintf(reply, reply_size, "OK - webconfig stopping");
|
|
}
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
if (strcmp(command, "get wifi.powersave") == 0) {
|
|
formatWiFiPowerSaving(reply, reply_size);
|
|
return true;
|
|
}
|
|
|
|
if (strcmp(command, "set wifi.powersave") == 0
|
|
|| strncmp(command, "set wifi.powersave ", 19) == 0) {
|
|
const char* value = command + 18;
|
|
while (*value == ' ') value++;
|
|
applyAndSaveWiFiPowerSaving(value, reply, reply_size);
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
#if COMPANION_FEATURE_TEMP_RADIO || COMPANION_FEATURE_OTA_CLI
|
|
#if COMPANION_FEATURE_TEMP_RADIO
|
|
if (strcmp(command, "tempradio") == 0) {
|
|
if (_temp_radio_set_at) {
|
|
snprintf(reply, reply_size, "TempRadio pending: %.3f,%.2f,%u,%u",
|
|
_temp_radio_freq, _temp_radio_bw,
|
|
(unsigned)_temp_radio_sf, (unsigned)_temp_radio_cr);
|
|
} else if (isTempRadioActive()) {
|
|
uint32_t seconds = (_temp_radio_revert_at - _ms->getMillis()) / 1000UL;
|
|
snprintf(reply, reply_size, "TempRadio active: %.3f,%.2f,%u,%u %lus left",
|
|
_temp_radio_freq, _temp_radio_bw,
|
|
(unsigned)_temp_radio_sf, (unsigned)_temp_radio_cr,
|
|
(unsigned long)seconds);
|
|
} else {
|
|
snprintf(reply, reply_size, "TempRadio inactive");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (strncmp(command, "tempradio ", 10) == 0) {
|
|
float freq = 0.0f, bw = 0.0f;
|
|
uint8_t sf = 0, cr = 0;
|
|
uint32_t timeout_mins = 0;
|
|
if (!mesh::cli::parseTemporaryRadioTupleStrict(
|
|
command + 10, freq, bw, sf, cr, timeout_mins)
|
|
|| !isfinite(freq) || !isfinite(bw)
|
|
|| freq < 150.0f || freq > 2500.0f
|
|
|| !isFullCompanionBandwidth(bw)
|
|
|| sf < 5 || sf > 12 || cr < 5 || cr > 8
|
|
|| timeout_mins == 0 || timeout_mins > 10080UL) {
|
|
snprintf(reply, reply_size,
|
|
"ERR usage: tempradio freq,bw,sf,cr,minutes (minutes 1-10080)");
|
|
return true;
|
|
}
|
|
scheduleTempRadio(freq, bw, sf, cr, timeout_mins, reply, reply_size);
|
|
return true;
|
|
}
|
|
|
|
if (strcmp(command, "normalradio") == 0) {
|
|
scheduleNormalRadio(reply, reply_size);
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
#if COMPANION_FEATURE_OTA_CLI
|
|
if (strncmp(command, "ota", 3) == 0
|
|
&& (command[3] == 0 || command[3] == ' ')) {
|
|
char ota_reply[160] = {0};
|
|
if (!mesh::ota::handle_ota_command(command, ota_reply, board)) return false;
|
|
snprintf(reply, reply_size, "%s", ota_reply);
|
|
return true;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
return false;
|
|
}
|
|
|
|
#if COMPANION_FEATURE_TEMP_RADIO
|
|
void MyMesh::serviceTempRadio() {
|
|
const unsigned long now = _ms->getMillis();
|
|
const bool retry_ready = !_temp_radio_retry_at
|
|
|| _temp_radio_retry_at == now || millisHasNowPassed(_temp_radio_retry_at);
|
|
const bool revert_due = _temp_radio_revert_at
|
|
&& (_temp_radio_revert_at == now || millisHasNowPassed(_temp_radio_revert_at));
|
|
|
|
if (revert_due) {
|
|
if (hasOutbound() || !retry_ready) return;
|
|
mesh::RadioParamApplyResult result = tryApplyRadioParams(
|
|
_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);
|
|
if (result == mesh::RadioParamApplyResult::APPLIED) {
|
|
radio_driver.setTxPower(_prefs.tx_power_dbm);
|
|
radio_driver.setRxBoostedGainMode(_prefs.rx_boosted_gain);
|
|
_temp_radio_set_at = 0;
|
|
_temp_radio_revert_at = 0;
|
|
_temp_radio_retry_at = 0;
|
|
_temp_radio_failures = 0;
|
|
_temp_radio_applied = false;
|
|
saved_radio_apply_pending = false;
|
|
MESH_DEBUG_PRINTLN("Full companion restored normal radio");
|
|
} else {
|
|
_temp_radio_retry_at = futureMillis(
|
|
nextRadioApplyRetryDelay(_temp_radio_failures));
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (!_temp_radio_set_at
|
|
|| (_temp_radio_set_at != now && !millisHasNowPassed(_temp_radio_set_at))
|
|
|| hasOutbound() || !retry_ready) return;
|
|
|
|
mesh::RadioParamApplyResult result = tryApplyRadioParams(
|
|
_temp_radio_freq, _temp_radio_bw, _temp_radio_sf, _temp_radio_cr);
|
|
if (result == mesh::RadioParamApplyResult::APPLIED) {
|
|
_temp_radio_set_at = 0;
|
|
_temp_radio_retry_at = 0;
|
|
_temp_radio_failures = 0;
|
|
_temp_radio_applied = true;
|
|
MESH_DEBUG_PRINTLN("Full companion entered TempRadio");
|
|
} else if (result == mesh::RadioParamApplyResult::BUSY) {
|
|
_temp_radio_retry_at = futureMillis(250);
|
|
} else {
|
|
// A partially applied tuple must never become persistent. Restore the
|
|
// saved Companion settings through the same bounded retry path.
|
|
_temp_radio_set_at = 0;
|
|
_temp_radio_revert_at = futureMillis(1);
|
|
_temp_radio_retry_at = 0;
|
|
saved_radio_apply_pending = true;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
const char *MyMesh::getNodeName() {
|
|
return _prefs.node_name;
|
|
}
|
|
CompanionNodePrefs *MyMesh::getNodePrefs() {
|
|
return &_prefs;
|
|
}
|
|
uint32_t MyMesh::getBLEPin() {
|
|
return _active_ble_pin;
|
|
}
|
|
|
|
#if defined(WITH_MQTT_BRIDGE) && defined(ESP32_PLATFORM) && defined(WIFI_SSID)
|
|
static void copyMqttString(char* dest, size_t dest_size, const char* src) {
|
|
strncpy(dest, src ? src : "", dest_size - 1);
|
|
dest[dest_size - 1] = 0;
|
|
}
|
|
|
|
void MyMesh::serviceMQTT(const char* wifi_ssid, const char* wifi_password) {
|
|
if (!_mqtt_started) {
|
|
if (strcmp(_mqtt_prefs.wifi_ssid, wifi_ssid ? wifi_ssid : "") != 0) {
|
|
copyMqttString(_mqtt_prefs.wifi_ssid, sizeof(_mqtt_prefs.wifi_ssid), wifi_ssid);
|
|
}
|
|
if (strcmp(_mqtt_prefs.wifi_password, wifi_password ? wifi_password : "") != 0) {
|
|
copyMqttString(_mqtt_prefs.wifi_password, sizeof(_mqtt_prefs.wifi_password), wifi_password);
|
|
}
|
|
}
|
|
|
|
if (WiFi.status() == WL_CONNECTED && _mqtt_configured && !_mqtt_started && _mqtt_bridge
|
|
#ifdef WITH_WEBCONFIG
|
|
&& !isWebConfigSetupActive()
|
|
#endif
|
|
) {
|
|
_mqtt_started = true; // begin is one-shot; avoid retrying partial allocations
|
|
_mqtt_bridge->begin();
|
|
if (_mqtt_bridge->isRunning()) {
|
|
mesh::usbLoggingPort().println("MQTT companion: bridge started");
|
|
} else {
|
|
mesh::usbLoggingPort().println(
|
|
"MQTT companion: bridge could not start");
|
|
}
|
|
}
|
|
}
|
|
|
|
void MyMesh::stopMQTT() {
|
|
if (_mqtt_started && _mqtt_bridge) _mqtt_bridge->end();
|
|
_mqtt_started = false;
|
|
}
|
|
#endif
|
|
|
|
#ifdef WITH_WEBCONFIG
|
|
static bool wcParseBool(const char* value, bool& out) {
|
|
if (strcmp(value, "on") == 0) { out = true; return true; }
|
|
if (strcmp(value, "off") == 0) { out = false; return true; }
|
|
return false;
|
|
}
|
|
|
|
static bool wcParseLong(const char* value, long min_value, long max_value, long& out) {
|
|
if (!value || !value[0]) return false;
|
|
char* end = nullptr;
|
|
long parsed = strtol(value, &end, 10);
|
|
if (!end || *end != 0 || parsed < min_value || parsed > max_value) return false;
|
|
out = parsed;
|
|
return true;
|
|
}
|
|
|
|
static bool wcParseDouble(const char* value, double min_value, double max_value, double& out) {
|
|
float parsed = 0.0f;
|
|
if (!mesh::cli::parseDecimalStrict(value, parsed)
|
|
|| parsed < min_value || parsed > max_value) return false;
|
|
out = parsed;
|
|
return true;
|
|
}
|
|
|
|
static bool wcValidNtpHost(const char* value) {
|
|
if (!value || !value[0] || strlen(value) > 63 || value[0] == '.') return false;
|
|
size_t len = strlen(value);
|
|
if (value[len - 1] == '.') return false;
|
|
for (size_t i = 0; i < len; i++) {
|
|
char c = value[i];
|
|
if (!isalnum(static_cast<unsigned char>(c)) && c != '.' && c != '-') return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool wcValidHexKey(const char* value) {
|
|
if (!value || strlen(value) != 64) return false;
|
|
for (int i = 0; i < 64; i++) {
|
|
if (!isxdigit(static_cast<unsigned char>(value[i]))) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool wcCopyValue(char* dest, size_t dest_size, const char* value) {
|
|
if (!dest || dest_size == 0 || !value || strlen(value) >= dest_size) return false;
|
|
strncpy(dest, value, dest_size - 1);
|
|
dest[dest_size - 1] = 0;
|
|
return true;
|
|
}
|
|
|
|
void MyMesh::getNodeSnapshot(WebConfigServer::NodeSnapshot& s) {
|
|
memset(&s, 0, sizeof(s));
|
|
wcCopyValue(s.name, sizeof(s.name), _prefs.node_name);
|
|
wcCopyValue(s.bluetooth_name, sizeof(s.bluetooth_name),
|
|
_prefs.bluetooth_name);
|
|
s.lat = sensors.node_lat;
|
|
s.lon = sensors.node_lon;
|
|
s.freq = _prefs.freq;
|
|
s.bw = _prefs.bw;
|
|
s.sf = _prefs.sf;
|
|
s.cr = _prefs.cr;
|
|
s.tx_power = _prefs.tx_power_dbm;
|
|
s.airtime_factor = _prefs.airtime_factor;
|
|
s.rx_delay = _prefs.rx_delay_base;
|
|
s.rx_gain = _prefs.rx_boosted_gain;
|
|
s.fem_rx_gain = board.isLoRaFemLnaEnabled();
|
|
s.rx_ps_enabled = _prefs.rx_powersaving_enabled;
|
|
s.rx_ps_level = _prefs.rx_ps_level;
|
|
s.rx_ps_preamble = _prefs.rx_ps_preamble;
|
|
s.rx_ps_rx_us = _prefs.rx_ps_rx_us;
|
|
s.rx_ps_sleep_us = _prefs.rx_ps_sleep_us;
|
|
s.power_saving = _prefs.powersaving_enabled;
|
|
s.repeat = _prefs.client_repeat != 0;
|
|
s.capabilities = WebConfigServer::CAP_LOCATION | WebConfigServer::CAP_AIRTIME
|
|
| WebConfigServer::CAP_RX_DELAY | WebConfigServer::CAP_POWER_SAVING;
|
|
#ifdef BLE_PIN_CODE
|
|
s.capabilities |= WebConfigServer::CAP_BLUETOOTH_NAME
|
|
| WebConfigServer::CAP_BLUETOOTH_MAC
|
|
| WebConfigServer::CAP_BLUETOOTH_STEALTH;
|
|
s.bluetooth_stealth = mesh::companion::bluetoothStealthEnabled(
|
|
_prefs.bluetooth_stealth_mode);
|
|
if (_prefs.bluetooth_mac_mode
|
|
== mesh::companion::BLUETOOTH_MAC_RANDOM_EVERY_BOOT) {
|
|
wcCopyValue(s.bluetooth_mac, sizeof(s.bluetooth_mac),
|
|
"random-every-boot");
|
|
} else if (mesh::companion::bluetoothMacModeIsRandomAfterConnect(
|
|
_prefs.bluetooth_mac_mode)) {
|
|
wcCopyValue(s.bluetooth_mac, sizeof(s.bluetooth_mac),
|
|
"random-after-connect");
|
|
} else if (mesh::companion::bluetoothMacModeUsesSavedAddress(
|
|
_prefs.bluetooth_mac_mode)
|
|
&& mesh::companion::isValidBluetoothMac(
|
|
_prefs.bluetooth_mac)) {
|
|
mesh::companion::formatBluetoothMac(
|
|
_prefs.bluetooth_mac, s.bluetooth_mac, sizeof(s.bluetooth_mac));
|
|
}
|
|
#endif
|
|
#if defined(ESP32) && defined(WIFI_SSID)
|
|
s.capabilities |= WebConfigServer::CAP_WIFI_POWER_SAVE;
|
|
#endif
|
|
#if defined(MESH_PRIMARY_ESPNOW) && MESH_PRIMARY_ESPNOW
|
|
s.capabilities |= WebConfigServer::CAP_ESPNOW_CHANNEL;
|
|
#endif
|
|
if (radio_driver.supportsRxBoostedGainMode()) {
|
|
s.capabilities |= WebConfigServer::CAP_RX_GAIN;
|
|
}
|
|
if (board.canControlLoRaFemLna()) {
|
|
s.capabilities |= WebConfigServer::CAP_FEM_RX_GAIN;
|
|
}
|
|
if (radio_driver.supportsRxPowerSaving()) {
|
|
s.capabilities |= WebConfigServer::CAP_RX_POWER_SAVING;
|
|
}
|
|
}
|
|
|
|
bool MyMesh::startWebConfig(bool force_ap, char* reply) {
|
|
#if defined(COMPANION_EXCLUSIVE_WIFI_BLE)
|
|
if (!isCompanionWiFiEnabled()) {
|
|
strcpy(reply,
|
|
"Err: WebUI unavailable while Bluetooth transport is active; select WiFi and reboot");
|
|
return false;
|
|
}
|
|
#endif
|
|
if (!_webconfig) {
|
|
strcpy(reply, "Err: WebUI unavailable (not enough memory)");
|
|
return false;
|
|
}
|
|
if (_webconfig->isRunning() || _webconfig->isStopping()) {
|
|
if (force_ap && !_webconfig->isStopping()
|
|
&& _webconfig->mode() == WebConfigServer::MODE_LAN) {
|
|
#ifdef WITH_MQTT_BRIDGE
|
|
if (_mqtt_started && _mqtt_bridge) {
|
|
_mqtt_bridge->end();
|
|
_mqtt_started = false;
|
|
}
|
|
#endif
|
|
return _webconfig->startSetupMode(reply);
|
|
}
|
|
strcpy(reply, _webconfig->isStopping() ? "Err: WebUI still stopping"
|
|
: "Err: WebUI already running");
|
|
return false;
|
|
}
|
|
if (force_ap) {
|
|
#ifdef WITH_MQTT_BRIDGE
|
|
if (_mqtt_started && _mqtt_bridge) {
|
|
_mqtt_bridge->end();
|
|
_mqtt_started = false;
|
|
}
|
|
#endif
|
|
return _webconfig->startSetupMode(reply);
|
|
}
|
|
return _webconfig->startAutoMode(reply);
|
|
}
|
|
|
|
void MyMesh::stopWebConfig() {
|
|
if (_webconfig && _webconfig->isRunning()) _webconfig->requestStop();
|
|
}
|
|
|
|
void MyMesh::serviceWebConfig() {
|
|
if (_webconfig) _webconfig->tick(millis());
|
|
}
|
|
|
|
bool MyMesh::isWebConfigActiveOrStopping() const {
|
|
return _webconfig && (_webconfig->isRunning() || _webconfig->isStopping());
|
|
}
|
|
|
|
bool MyMesh::isWebConfigSetupActive() const {
|
|
return _webconfig && _webconfig->mode() == WebConfigServer::MODE_SETUP
|
|
&& !_webconfig->isStopping();
|
|
}
|
|
|
|
bool MyMesh::isWebConfigWiFiRecoveryActive() const {
|
|
return _webconfig && _webconfig->isSavedWiFiRecoveryActive();
|
|
}
|
|
|
|
void MyMesh::rebootNow() {
|
|
if (flushContactsBeforeReboot()) {
|
|
board.reboot();
|
|
} else {
|
|
MESH_DEBUG_PRINTLN("Reboot refused: pending contacts could not be saved");
|
|
}
|
|
}
|
|
|
|
void MyMesh::onConfigBatchStart() {
|
|
_wc_mqtt_dirty = false;
|
|
}
|
|
|
|
void MyMesh::onConfigBatchEnd() {
|
|
#if defined(ESP32) && defined(WIFI_SSID)
|
|
// The WebConfig WiFi form writes the canonical mesh-wifi namespace itself.
|
|
// Reload it here so the Companion runtime and MQTT reconnect policy cannot
|
|
// retain a stale modem-sleep mode.
|
|
reloadCompanionWiFiPowerSave();
|
|
syncWiFiPowerSaving();
|
|
#endif
|
|
#ifdef WITH_MQTT_BRIDGE
|
|
if (_wc_mqtt_dirty) {
|
|
CompanionMqttSetupPortal::saveStoredConfig(_mqtt_prefs);
|
|
if (_mqtt_started && _mqtt_bridge) _mqtt_bridge->end();
|
|
_mqtt_started = false;
|
|
// loadStoredConfig only replaces its destination after validation. Pass
|
|
// the live preferences directly: another 2.8 KB copy here nests with the
|
|
// loader's scratch copy and NVS calls, overflowing the ESP32 loop stack.
|
|
_mqtt_configured = CompanionMqttSetupPortal::loadStoredConfig(_mqtt_prefs);
|
|
// The standalone Companion setting remains canonical even if MQTT config
|
|
// verification reloaded an older copy of this field.
|
|
_mqtt_prefs.wifi_power_save = getCompanionWiFiPowerSave();
|
|
}
|
|
#endif
|
|
_wc_mqtt_dirty = false;
|
|
}
|
|
|
|
void MyMesh::execCommand(char* cmd, char* reply) {
|
|
reply[0] = 0;
|
|
if (handleCadCommand(cmd, reply, 160)) return;
|
|
if (cmd && (strcmp(cmd, "get bluetooth.name") == 0
|
|
|| strcmp(cmd, "get ble.name") == 0)) {
|
|
formatBluetoothNameStatus(reply, 160);
|
|
return;
|
|
}
|
|
#if defined(BLE_PIN_CODE)
|
|
if (cmd && (strcmp(cmd, "get bluetooth.stealth") == 0
|
|
|| strcmp(cmd, "get ble.stealth") == 0)) {
|
|
formatBluetoothStealthStatus(reply, 160);
|
|
return;
|
|
}
|
|
if (cmd && (strcmp(cmd, "get bluetooth.mac") == 0
|
|
|| strcmp(cmd, "get ble.mac") == 0)) {
|
|
formatBluetoothMacStatus(reply, 160);
|
|
return;
|
|
}
|
|
#endif
|
|
#if defined(MESH_PRIMARY_ESPNOW) && MESH_PRIMARY_ESPNOW
|
|
if (cmd && strcmp(cmd, "get espnow.channel") == 0) {
|
|
formatEspNowChannel(reply, 160);
|
|
return;
|
|
}
|
|
#endif
|
|
#if defined(ESP32) && defined(WIFI_SSID)
|
|
if (cmd && strcmp(cmd, "get wifi.powersave") == 0) {
|
|
formatWiFiPowerSaving(reply, 160);
|
|
return;
|
|
}
|
|
#endif
|
|
if (!cmd || strncmp(cmd, "set ", 4) != 0) {
|
|
strcpy(reply, "Error: unsupported command");
|
|
return;
|
|
}
|
|
char* key = cmd + 4;
|
|
char* split = strchr(key, ' ');
|
|
if (!split) {
|
|
strcpy(reply, "Error: missing value");
|
|
return;
|
|
}
|
|
*split = 0;
|
|
const char* value = split + 1;
|
|
|
|
if (strcmp(key, "name") == 0) {
|
|
if (!value[0] || !wcCopyValue(_prefs.node_name, sizeof(_prefs.node_name), value)) {
|
|
strcpy(reply, "Error: name must be 1-31 characters");
|
|
} else {
|
|
savePrefs();
|
|
strcpy(reply, "OK");
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(key, "bluetooth.name") == 0) {
|
|
applyAndSaveBluetoothName(value, reply, 160);
|
|
return;
|
|
}
|
|
#if defined(BLE_PIN_CODE)
|
|
if (strcmp(key, "bluetooth.stealth") == 0
|
|
|| strcmp(key, "ble.stealth") == 0) {
|
|
applyAndSaveBluetoothStealth(value, reply, 160);
|
|
return;
|
|
}
|
|
if (strcmp(key, "bluetooth.mac") == 0) {
|
|
applyAndSaveBluetoothMac(value, reply, 160);
|
|
return;
|
|
}
|
|
#endif
|
|
#if defined(MESH_PRIMARY_ESPNOW) && MESH_PRIMARY_ESPNOW
|
|
if (strcmp(key, "espnow.channel") == 0) {
|
|
applyAndSaveEspNowChannel(value, reply, 160);
|
|
return;
|
|
}
|
|
#endif
|
|
if (strcmp(key, "lat") == 0 || strcmp(key, "lon") == 0) {
|
|
double parsed;
|
|
const bool latitude = key[1] == 'a';
|
|
if (!wcParseDouble(value, latitude ? -90.0 : -180.0,
|
|
latitude ? 90.0 : 180.0, parsed)) {
|
|
strcpy(reply, latitude ? "Error: latitude must be -90 to 90"
|
|
: "Error: longitude must be -180 to 180");
|
|
} else {
|
|
if (latitude) sensors.node_lat = parsed; else sensors.node_lon = parsed;
|
|
savePrefs();
|
|
strcpy(reply, "OK");
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(key, "radio") == 0) {
|
|
float freq, bw;
|
|
uint8_t sf, cr;
|
|
if (!mesh::cli::parseRadioTupleStrict(value, freq, bw, sf, cr)
|
|
|| !isfinite(freq) || !isfinite(bw) || freq < 150.0f || freq > 2500.0f
|
|
|| bw < 7.0f || bw > 500.0f || sf < 5 || sf > 12 || cr < 5 || cr > 8) {
|
|
strcpy(reply, "Error: radio must be freq,bw,sf,cr");
|
|
} else {
|
|
_prefs.freq = freq;
|
|
_prefs.bw = bw;
|
|
_prefs.sf = sf;
|
|
_prefs.cr = cr;
|
|
recalcRxPowerSavingFromLevel(_prefs.rx_ps_level, _prefs.sf, _prefs.bw,
|
|
_prefs.rx_ps_preamble, &_prefs.rx_ps_rx_us,
|
|
&_prefs.rx_ps_sleep_us);
|
|
savePrefs();
|
|
strcpy(reply, "OK - reboot required");
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(key, "tx") == 0) {
|
|
long parsed;
|
|
if (!wcParseLong(value, -9, MAX_LORA_TX_POWER, parsed)) {
|
|
snprintf(reply, 160, "Error: TX power must be -9 to %d", MAX_LORA_TX_POWER);
|
|
} else {
|
|
_prefs.tx_power_dbm = static_cast<int8_t>(parsed);
|
|
if (_radio_available) radio_driver.setTxPower(_prefs.tx_power_dbm);
|
|
savePrefs();
|
|
strcpy(reply, "OK");
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(key, "af") == 0 || strcmp(key, "rxdelay") == 0) {
|
|
double parsed;
|
|
const bool is_af = strcmp(key, "af") == 0;
|
|
if (!wcParseDouble(value, 0.0, is_af ? 9.0 : 20.0, parsed)) {
|
|
strcpy(reply, is_af ? "Error: airtime factor must be 0-9"
|
|
: "Error: RX delay must be 0-20");
|
|
} else {
|
|
if (is_af) _prefs.airtime_factor = parsed; else _prefs.rx_delay_base = parsed;
|
|
savePrefs();
|
|
strcpy(reply, "OK");
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(key, "radio.rxgain") == 0 || strcmp(key, "repeat") == 0) {
|
|
bool enabled;
|
|
if (!wcParseBool(value, enabled)) {
|
|
strcpy(reply, "Error: must be on or off");
|
|
} else {
|
|
if (strcmp(key, "radio.rxgain") == 0) {
|
|
if (!radio_driver.supportsRxBoostedGainMode()) {
|
|
strcpy(reply, "Error: RX boosted gain unsupported");
|
|
return;
|
|
}
|
|
if (!applyAndSaveRxBoostedGain(enabled)) {
|
|
strcpy(reply, "Error: radio busy; retry");
|
|
return;
|
|
}
|
|
} else {
|
|
_prefs.client_repeat = enabled;
|
|
savePrefs();
|
|
}
|
|
strcpy(reply, "OK");
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(key, "radio.rxps") == 0) {
|
|
applyAndSaveRxPowerSaving(value, reply);
|
|
return;
|
|
}
|
|
if (strcmp(key, "powersaving") == 0) {
|
|
applyAndSavePowerSaving(value, reply);
|
|
return;
|
|
}
|
|
#if defined(ESP32) && defined(WIFI_SSID)
|
|
if (strcmp(key, "wifi.powersave") == 0) {
|
|
applyAndSaveWiFiPowerSaving(value, reply, 160);
|
|
return;
|
|
}
|
|
#endif
|
|
if (strcmp(key, "radio.fem.rxgain") == 0) {
|
|
bool enabled;
|
|
if (!wcParseBool(value, enabled)) {
|
|
strcpy(reply, "Error: must be on or off");
|
|
} else if (!board.canControlLoRaFemLna()) {
|
|
strcpy(reply, "Error: unsupported");
|
|
} else if (!applyAndSaveFemRxGain(enabled)) {
|
|
strcpy(reply, "Error: failed to apply FEM RX gain");
|
|
} else {
|
|
strcpy(reply, "OK");
|
|
}
|
|
return;
|
|
}
|
|
if (strcmp(key, "radio.fem.txgain") == 0) {
|
|
bool enabled;
|
|
if (!wcParseBool(value, enabled)) {
|
|
strcpy(reply, "Error: must be on or off");
|
|
} else if (!board.canControlLoRaFemPaGain()) {
|
|
strcpy(reply, "Error: unsupported");
|
|
} else if (!applyAndSaveFemTxGain(enabled)) {
|
|
strcpy(reply, "Error: failed to apply FEM TX gain");
|
|
} else {
|
|
strcpy(reply, "OK");
|
|
}
|
|
return;
|
|
}
|
|
|
|
#ifdef WITH_MQTT_BRIDGE
|
|
bool changed = false;
|
|
if (strcmp(key, "mqtt.origin") == 0) {
|
|
changed = wcCopyValue(_mqtt_prefs.mqtt_origin, sizeof(_mqtt_prefs.mqtt_origin), value);
|
|
} else if (strcmp(key, "mqtt.iata") == 0) {
|
|
changed = wcCopyValue(_mqtt_prefs.mqtt_iata, sizeof(_mqtt_prefs.mqtt_iata), value);
|
|
if (changed) {
|
|
for (char* p = _mqtt_prefs.mqtt_iata; *p; p++) *p = toupper(static_cast<unsigned char>(*p));
|
|
}
|
|
} else if (strcmp(key, "mqtt.status") == 0 || strcmp(key, "mqtt.packets") == 0
|
|
|| strcmp(key, "mqtt.raw") == 0 || strcmp(key, "mqtt.rx") == 0
|
|
|| strcmp(key, "snmp") == 0) {
|
|
bool enabled;
|
|
if (!wcParseBool(value, enabled)) {
|
|
strcpy(reply, "Error: must be on or off");
|
|
return;
|
|
}
|
|
if (strcmp(key, "mqtt.status") == 0) _mqtt_prefs.mqtt_status_enabled = enabled;
|
|
else if (strcmp(key, "mqtt.packets") == 0) _mqtt_prefs.mqtt_packets_enabled = enabled;
|
|
else if (strcmp(key, "mqtt.raw") == 0) _mqtt_prefs.mqtt_raw_enabled = enabled;
|
|
else if (strcmp(key, "mqtt.rx") == 0) _mqtt_prefs.mqtt_rx_enabled = enabled;
|
|
else _mqtt_prefs.snmp_enabled = enabled;
|
|
changed = true;
|
|
} else if (strcmp(key, "mqtt.tx") == 0) {
|
|
if (strcmp(value, "off") == 0) _mqtt_prefs.mqtt_tx_enabled = 0;
|
|
else if (strcmp(value, "on") == 0) _mqtt_prefs.mqtt_tx_enabled = 1;
|
|
else if (strcmp(value, "advert") == 0) _mqtt_prefs.mqtt_tx_enabled = 2;
|
|
else {
|
|
strcpy(reply, "Error: MQTT TX must be off, on, or advert");
|
|
return;
|
|
}
|
|
changed = true;
|
|
} else if (strcmp(key, "mqtt.interval") == 0) {
|
|
long minutes;
|
|
if (!wcParseLong(value, 1, 60, minutes)) {
|
|
strcpy(reply, "Error: interval must be 1-60 minutes");
|
|
return;
|
|
}
|
|
_mqtt_prefs.mqtt_status_interval = static_cast<uint32_t>(minutes) * 60000UL;
|
|
changed = true;
|
|
} else if (strcmp(key, "mqtt.ntp") == 0) {
|
|
if (strcmp(value, "none") == 0) {
|
|
_mqtt_prefs.mqtt_ntp_server[0] = 0;
|
|
changed = true;
|
|
} else if (wcValidNtpHost(value)) {
|
|
changed = wcCopyValue(_mqtt_prefs.mqtt_ntp_server,
|
|
sizeof(_mqtt_prefs.mqtt_ntp_server), value);
|
|
}
|
|
} else if (strcmp(key, "mqtt.owner") == 0) {
|
|
if (!value[0]) {
|
|
_mqtt_prefs.mqtt_owner_public_key[0] = 0;
|
|
changed = true;
|
|
} else if (wcValidHexKey(value)) {
|
|
changed = wcCopyValue(_mqtt_prefs.mqtt_owner_public_key,
|
|
sizeof(_mqtt_prefs.mqtt_owner_public_key), value);
|
|
}
|
|
} else if (strcmp(key, "mqtt.email") == 0) {
|
|
changed = wcCopyValue(_mqtt_prefs.mqtt_email, sizeof(_mqtt_prefs.mqtt_email), value);
|
|
} else if (strcmp(key, "timezone") == 0) {
|
|
changed = wcCopyValue(_mqtt_prefs.timezone_string, sizeof(_mqtt_prefs.timezone_string), value);
|
|
} else if (strcmp(key, "timezone.offset") == 0) {
|
|
long offset;
|
|
if (!wcParseLong(value, -12, 14, offset)) {
|
|
strcpy(reply, "Error: timezone offset must be -12 to 14");
|
|
return;
|
|
}
|
|
_mqtt_prefs.timezone_offset = static_cast<int8_t>(offset);
|
|
changed = true;
|
|
} else if (strcmp(key, "snmp.community") == 0) {
|
|
changed = wcCopyValue(_mqtt_prefs.snmp_community,
|
|
sizeof(_mqtt_prefs.snmp_community), value);
|
|
} else if (strncmp(key, "mqtt", 4) == 0 && key[4] >= '1'
|
|
&& key[4] <= ('0' + MAX_MQTT_SLOTS) && key[5] == '.') {
|
|
int slot = key[4] - '1';
|
|
const char* field = key + 6;
|
|
if (strcmp(field, "preset") == 0) {
|
|
const bool valid = findMQTTPreset(value) != nullptr
|
|
|| strcmp(value, MQTT_PRESET_CUSTOM) == 0
|
|
|| strcmp(value, MQTT_PRESET_NONE) == 0;
|
|
if (!valid) {
|
|
strcpy(reply, "Error: unknown MQTT preset");
|
|
return;
|
|
}
|
|
if (findMQTTPreset(value)) {
|
|
for (int i = 0; i < MAX_MQTT_SLOTS; i++) {
|
|
if (i != slot && strcmp(_mqtt_prefs.mqtt_slot_preset[i], value) == 0) {
|
|
snprintf(reply, 160, "Error: preset already assigned to slot %d", i + 1);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
changed = wcCopyValue(_mqtt_prefs.mqtt_slot_preset[slot],
|
|
sizeof(_mqtt_prefs.mqtt_slot_preset[slot]), value);
|
|
} else if (strcmp(field, "server") == 0) {
|
|
changed = wcCopyValue(_mqtt_prefs.mqtt_slot_host[slot],
|
|
sizeof(_mqtt_prefs.mqtt_slot_host[slot]), value);
|
|
} else if (strcmp(field, "port") == 0) {
|
|
long port;
|
|
if (!wcParseLong(value, 1, 65535, port)) {
|
|
strcpy(reply, "Error: port must be 1-65535");
|
|
return;
|
|
}
|
|
_mqtt_prefs.mqtt_slot_port[slot] = static_cast<uint16_t>(port);
|
|
changed = true;
|
|
} else if (strcmp(field, "username") == 0) {
|
|
changed = wcCopyValue(_mqtt_prefs.mqtt_slot_username[slot],
|
|
sizeof(_mqtt_prefs.mqtt_slot_username[slot]), value);
|
|
} else if (strcmp(field, "password") == 0) {
|
|
changed = wcCopyValue(_mqtt_prefs.mqtt_slot_password[slot],
|
|
sizeof(_mqtt_prefs.mqtt_slot_password[slot]), value);
|
|
} else if (strcmp(field, "token") == 0) {
|
|
changed = wcCopyValue(_mqtt_prefs.mqtt_slot_token[slot],
|
|
sizeof(_mqtt_prefs.mqtt_slot_token[slot]), value);
|
|
} else if (strcmp(field, "topic") == 0) {
|
|
if (strcmp(_mqtt_prefs.mqtt_slot_preset[slot], MQTT_PRESET_CUSTOM) != 0) {
|
|
strcpy(reply, "Error: topic only applies to custom slots");
|
|
return;
|
|
}
|
|
changed = wcCopyValue(_mqtt_prefs.mqtt_slot_topic[slot],
|
|
sizeof(_mqtt_prefs.mqtt_slot_topic[slot]), value);
|
|
} else if (strcmp(field, "audience") == 0) {
|
|
changed = wcCopyValue(_mqtt_prefs.mqtt_slot_audience[slot],
|
|
sizeof(_mqtt_prefs.mqtt_slot_audience[slot]), value);
|
|
}
|
|
}
|
|
|
|
if (changed) {
|
|
_wc_mqtt_dirty = true;
|
|
strcpy(reply, "OK");
|
|
} else if (reply[0] == 0) {
|
|
strcpy(reply, "Error: invalid or unsupported value");
|
|
}
|
|
#else
|
|
strcpy(reply, "Error: unsupported setting for this companion");
|
|
#endif
|
|
}
|
|
|
|
void MyMesh::buildStatsJson(char* buf, size_t buf_size) {
|
|
char ip[20] = "";
|
|
int wifi_rssi = 0;
|
|
if (WiFi.status() == WL_CONNECTED) {
|
|
strncpy(ip, WiFi.localIP().toString().c_str(), sizeof(ip) - 1);
|
|
wifi_rssi = WiFi.RSSI();
|
|
} else if (_webconfig && _webconfig->mode() == WebConfigServer::MODE_SETUP) {
|
|
strncpy(ip, WiFi.softAPIP().toString().c_str(), sizeof(ip) - 1);
|
|
}
|
|
int pos = snprintf(buf, buf_size,
|
|
"{\"uptime_s\":%lu,\"batt_mv\":%u,"
|
|
"\"heap_free\":%lu,\"heap_min\":%lu,\"heap_max_alloc\":%lu,"
|
|
"\"noise\":%d,\"rssi\":%d,\"snr\":%.1f,"
|
|
"\"airtime_s\":%lu,\"rx_airtime_s\":%lu,"
|
|
"\"recv\":%lu,\"sent\":%lu,\"rx_err\":%lu,"
|
|
"\"sent_flood\":%lu,\"sent_direct\":%lu,\"recv_flood\":%lu,\"recv_direct\":%lu,"
|
|
"\"tx_queue\":%d,\"wifi_rssi\":%d,\"ip\":\"%s\",\"mqtt_queue\":%d,\"slots\":[",
|
|
(unsigned long)(millis() / 1000), (unsigned)board.getBattMilliVolts(),
|
|
(unsigned long)ESP.getFreeHeap(), (unsigned long)ESP.getMinFreeHeap(),
|
|
(unsigned long)ESP.getMaxAllocHeap(),
|
|
(int)_radio->getNoiseFloor(), (int)radio_driver.getLastRSSI(),
|
|
radio_driver.getLastSNR(),
|
|
(unsigned long)(getTotalAirTime() / 1000), (unsigned long)(getReceiveAirTime() / 1000),
|
|
(unsigned long)radio_driver.getPacketsRecv(), (unsigned long)radio_driver.getPacketsSent(),
|
|
(unsigned long)radio_driver.getPacketsRecvErrors(),
|
|
(unsigned long)getNumSentFlood(), (unsigned long)getNumSentDirect(),
|
|
(unsigned long)getNumRecvFlood(), (unsigned long)getNumRecvDirect(),
|
|
(int)_mgr->getOutboundCount(0xFFFFFFFF), wifi_rssi, ip,
|
|
#ifdef WITH_MQTT_BRIDGE
|
|
_mqtt_bridge ? _mqtt_bridge->getQueueSize() : 0);
|
|
#else
|
|
0);
|
|
#endif
|
|
if (pos < 0 || pos >= static_cast<int>(buf_size) - 3) return;
|
|
|
|
#ifdef WITH_MQTT_BRIDGE
|
|
bool first = true;
|
|
for (int i = 0; i < RUNTIME_MQTT_SLOTS; i++) {
|
|
MQTTBridge::SlotStatusSnapshot status;
|
|
if (!MQTTBridge::getSlotStatusSnapshot(i, &status)) continue;
|
|
int written = snprintf(buf + pos, buf_size - pos,
|
|
"%s{\"n\":%d,\"name\":\"%s\",\"state\":\"%s\"}",
|
|
first ? "" : ",", i + 1, status.name, status.state);
|
|
if (written < 0 || written >= static_cast<int>(buf_size - pos)) break;
|
|
pos += written;
|
|
first = false;
|
|
}
|
|
#endif
|
|
snprintf(buf + pos, buf_size - pos, "]}");
|
|
}
|
|
#endif
|
|
|
|
struct FreqRange {
|
|
uint32_t lower_freq, upper_freq;
|
|
};
|
|
|
|
static FreqRange repeat_freq_ranges[] = {
|
|
#ifdef ALLOWED_REPEAT_FREQ_RANGE
|
|
ALLOWED_REPEAT_FREQ_RANGE
|
|
#else
|
|
{ 433000, 433000 },
|
|
{ 869495, 869495 },
|
|
{ 918000, 918000 }
|
|
#endif
|
|
};
|
|
|
|
bool MyMesh::isValidClientRepeatFreq(uint32_t f) const {
|
|
for (int i = 0; i < sizeof(repeat_freq_ranges)/sizeof(repeat_freq_ranges[0]); i++) {
|
|
auto r = &repeat_freq_ranges[i];
|
|
if (f >= r->lower_freq && f <= r->upper_freq) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void MyMesh::startInterface(BaseSerialInterface &serial) {
|
|
_serial = &serial;
|
|
serial.enable();
|
|
}
|
|
|
|
void MyMesh::clearPendingReqs() {
|
|
pending_login = pending_status = pending_telemetry = pending_discovery =
|
|
pending_req = 0;
|
|
pending_serial_reply_route = NULL;
|
|
pending_serial_reply_deadline = 0;
|
|
}
|
|
|
|
bool MyMesh::hasPendingReqs() const {
|
|
return pending_login != 0 || pending_status != 0 || pending_telemetry != 0
|
|
|| pending_discovery != 0 || pending_req != 0;
|
|
}
|
|
|
|
bool MyMesh::hasFiniteDelayedReplyForRoute(BaseSerialInterface* route) const {
|
|
if (route == NULL) return false;
|
|
if (pending_serial_reply_route == route
|
|
|| (command_radio_apply_pending && command_radio_reply_route == route)
|
|
|| (binary_trace_pending && binary_trace_reply_route == route)) {
|
|
return true;
|
|
}
|
|
for (int i = 0; i < EXPECTED_ACK_TABLE_SIZE; ++i) {
|
|
if (expected_ack_table[i].ack != 0
|
|
&& expected_ack_table[i].reply_route == route) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void MyMesh::servicePendingSerialReply() {
|
|
if (pending_serial_reply_route == NULL) return;
|
|
if (!_serial->isReplyRouteAvailable(pending_serial_reply_route)
|
|
|| pending_serial_reply_deadline == _ms->getMillis()
|
|
|| millisHasNowPassed(pending_serial_reply_deadline)) {
|
|
clearPendingReqs();
|
|
}
|
|
}
|
|
|
|
void MyMesh::clearBinaryTraceReply() {
|
|
binary_trace_pending = false;
|
|
binary_trace_tag = 0;
|
|
binary_trace_auth = 0;
|
|
binary_trace_deadline = 0;
|
|
binary_trace_reply_route = NULL;
|
|
}
|
|
|
|
void MyMesh::serviceBinaryTraceReply() {
|
|
if (!binary_trace_pending) return;
|
|
if (!_serial->isReplyRouteAvailable(binary_trace_reply_route)
|
|
|| binary_trace_deadline == _ms->getMillis()
|
|
|| millisHasNowPassed(binary_trace_deadline)) {
|
|
clearBinaryTraceReply();
|
|
}
|
|
}
|
|
|
|
void MyMesh::cancelSigningSession() {
|
|
if (sign_data != NULL) free(sign_data);
|
|
sign_data = NULL;
|
|
sign_data_len = 0;
|
|
sign_data_reply_route = NULL;
|
|
sign_data_deadline = 0;
|
|
}
|
|
|
|
void MyMesh::serviceSigningSession() {
|
|
if (sign_data == NULL) return;
|
|
if (!_serial->isReplyRouteAvailable(sign_data_reply_route)
|
|
|| sign_data_deadline == _ms->getMillis()
|
|
|| millisHasNowPassed(sign_data_deadline)) {
|
|
cancelSigningSession();
|
|
}
|
|
}
|
|
|
|
void MyMesh::cancelSerialResponseStream() {
|
|
stopContactsIterator();
|
|
}
|
|
|
|
void MyMesh::cancelSerialOperationsForRoute(BaseSerialInterface* route) {
|
|
if (route == NULL) return;
|
|
if (pending_serial_reply_route == route) clearPendingReqs();
|
|
if (command_radio_reply_route == route) cancelPendingRadioParamApply();
|
|
if (binary_trace_reply_route == route) clearBinaryTraceReply();
|
|
if (sign_data_reply_route == route) cancelSigningSession();
|
|
for (int i = 0; i < EXPECTED_ACK_TABLE_SIZE; ++i) {
|
|
if (expected_ack_table[i].reply_route == route) {
|
|
// A host-session change must prevent the late ACK from reaching a new
|
|
// session on the same transport, but it must not revoke radio delivery
|
|
// for a message for which RESP_CODE_SENT was already returned.
|
|
expected_ack_table[i].reply_route = NULL;
|
|
}
|
|
}
|
|
expireExpectedAcks();
|
|
}
|
|
|
|
void MyMesh::resetUsbHostSessionInput() {
|
|
// CLI rescue deliberately remains active across reconnects, but no bytes
|
|
// typed by the old host may complete a command for the new one. This is
|
|
// especially important for the rescue shell's erase/rm commands.
|
|
if (_cli_rescue) memset(cli_command, 0, sizeof(cli_command));
|
|
}
|
|
|
|
void MyMesh::handleCmdFrame(size_t len) {
|
|
if (len == 0) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
return;
|
|
}
|
|
|
|
const bool starts_long_lived_request =
|
|
(cmd_frame[0] == CMD_SEND_LOGIN && len >= 1 + PUB_KEY_SIZE)
|
|
|| (cmd_frame[0] == CMD_SEND_ANON_REQ && len > 1 + PUB_KEY_SIZE)
|
|
|| (cmd_frame[0] == CMD_SEND_STATUS_REQ && len >= 1 + PUB_KEY_SIZE)
|
|
|| (cmd_frame[0] == CMD_SEND_PATH_DISCOVERY_REQ
|
|
&& len >= 2 + PUB_KEY_SIZE)
|
|
|| (cmd_frame[0] == CMD_SEND_TELEMETRY_REQ
|
|
&& len >= 4 + PUB_KEY_SIZE)
|
|
|| (cmd_frame[0] == CMD_SEND_BINARY_REQ
|
|
&& len >= 2 + PUB_KEY_SIZE);
|
|
if (starts_long_lived_request && hasPendingReqs()) {
|
|
// There is one correlation slot for these request families. Reject before
|
|
// transmitting rather than orphaning an earlier USB/BLE client's SENT
|
|
// operation and reassigning its late response to the new requester.
|
|
writeErrFrame(ERR_CODE_BAD_STATE);
|
|
return;
|
|
}
|
|
|
|
if (cmd_frame[0] == CMD_DEVICE_QUERY && len >= 2) { // sent when app establishes connection
|
|
app_target_ver = cmd_frame[1]; // which version of protocol does app understand
|
|
|
|
int i = 0;
|
|
out_frame[i++] = RESP_CODE_DEVICE_INFO;
|
|
out_frame[i++] = FIRMWARE_VER_CODE;
|
|
out_frame[i++] = MAX_CONTACTS / 2; // v3+
|
|
out_frame[i++] = MAX_GROUP_CHANNELS; // v3+
|
|
memcpy(&out_frame[i], &_active_ble_pin, 4);
|
|
i += 4;
|
|
memset(&out_frame[i], 0, 12);
|
|
strcpy((char *)&out_frame[i], FIRMWARE_BUILD_DATE);
|
|
i += 12;
|
|
StrHelper::strzcpy((char *)&out_frame[i], board.getManufacturerName(), 40);
|
|
i += 40;
|
|
StrHelper::strzcpy((char *)&out_frame[i], FIRMWARE_VERSION, 20);
|
|
i += 20;
|
|
out_frame[i++] = _prefs.isRepeatEn() ? 1 : 0; // v9+
|
|
out_frame[i++] = _prefs.path_hash_mode; // v10+
|
|
_serial->writeFrame(out_frame, i);
|
|
} else if (cmd_frame[0] == CMD_APP_START &&
|
|
len >= 8) { // sent when app establishes connection, respond with node ID
|
|
// cmd_frame[1..7] reserved future
|
|
char *app_name = (char *)&cmd_frame[8];
|
|
cmd_frame[len] = 0; // make app_name null terminated
|
|
MESH_DEBUG_PRINTLN("App %s connected", app_name);
|
|
|
|
BaseSerialInterface* app_route = _serial->captureReplyRoute();
|
|
stopContactsIterator(); // stop any left-over ContactsIterator
|
|
cancelSerialOperationsForRoute(app_route);
|
|
int i = 0;
|
|
out_frame[i++] = RESP_CODE_SELF_INFO;
|
|
out_frame[i++] = ADV_TYPE_CHAT; // what this node Advert identifies as (maybe node's pronouns too?? :-)
|
|
out_frame[i++] = _prefs.tx_power_dbm;
|
|
out_frame[i++] = MAX_LORA_TX_POWER;
|
|
memcpy(&out_frame[i], self_id.pub_key, PUB_KEY_SIZE);
|
|
i += PUB_KEY_SIZE;
|
|
|
|
int32_t lat, lon;
|
|
lat = (sensors.node_lat * 1000000.0);
|
|
lon = (sensors.node_lon * 1000000.0);
|
|
memcpy(&out_frame[i], &lat, 4);
|
|
i += 4;
|
|
memcpy(&out_frame[i], &lon, 4);
|
|
i += 4;
|
|
out_frame[i++] = _prefs.multi_acks; // new v7+
|
|
out_frame[i++] = _prefs.advert_loc_policy;
|
|
out_frame[i++] = (_prefs.telemetry_mode_env << 4) | (_prefs.telemetry_mode_loc << 2) |
|
|
(_prefs.telemetry_mode_base); // v5+
|
|
out_frame[i++] = _prefs.manual_add_contacts;
|
|
|
|
uint32_t freq = _prefs.freq * 1000;
|
|
memcpy(&out_frame[i], &freq, 4);
|
|
i += 4;
|
|
uint32_t bw = _prefs.bw * 1000;
|
|
memcpy(&out_frame[i], &bw, 4);
|
|
i += 4;
|
|
out_frame[i++] = _prefs.sf;
|
|
out_frame[i++] = _prefs.cr;
|
|
|
|
int tlen = strlen(_prefs.node_name); // revisit: UTF_8 ??
|
|
memcpy(&out_frame[i], _prefs.node_name, tlen);
|
|
i += tlen;
|
|
_serial->writeFrame(out_frame, i);
|
|
} else if (mesh::companion::isRunCliFrame(cmd_frame[0], len)) { // V14+
|
|
int i = 1;
|
|
char *text = (char *)&cmd_frame[i];
|
|
int tlen = len - i;
|
|
if (memchr(text, 0, tlen) != NULL) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else {
|
|
text[tlen] = 0; // ensure null
|
|
|
|
reply_buf[0] = 0;
|
|
bool handled = false;
|
|
#if defined(MESHCORE_EXTRAFS_HIL)
|
|
// This hook is deliberately reachable only from a directly attached
|
|
// Companion frame. It is not part of handleCommand(), so an on-air
|
|
// administrator command can never fill, corrupt, or reset the device.
|
|
handled = handleExtraFsHilCommand(text, reply_buf, sizeof(reply_buf));
|
|
#endif
|
|
if (!handled) handled = handleCommand(text, 0, reply_buf);
|
|
if (!handled) {
|
|
strcat(reply_buf, "Unknown command"); // reply_buf may have cmd prefix from 'text'
|
|
}
|
|
out_frame[0] = RESP_CODE_CLI_REPLY;
|
|
int rlen = strlen(reply_buf);
|
|
memcpy(&out_frame[1], reply_buf, rlen);
|
|
_serial->writeFrame(out_frame, 1 + rlen);
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SEND_TXT_MSG && len >= 14) {
|
|
int i = 1;
|
|
uint8_t txt_type = cmd_frame[i++];
|
|
uint8_t attempt = cmd_frame[i++];
|
|
uint32_t msg_timestamp;
|
|
memcpy(&msg_timestamp, &cmd_frame[i], 4);
|
|
i += 4;
|
|
uint8_t *pub_key_prefix = &cmd_frame[i];
|
|
i += 6;
|
|
ContactInfo *recipient = lookupContactByPubKey(pub_key_prefix, 6);
|
|
if (recipient && (txt_type == TXT_TYPE_PLAIN || txt_type == TXT_TYPE_CLI_DATA || txt_type == TXT_TYPE_CLI_COMMAND)) {
|
|
char *text = (char *)&cmd_frame[i];
|
|
int tlen = len - i;
|
|
uint32_t est_timeout;
|
|
text[tlen] = 0; // ensure null
|
|
|
|
uint8_t text_fingerprint[MAX_HASH_SIZE] = { 0 };
|
|
uint8_t packet_retry_key[MAX_HASH_SIZE] = { 0 };
|
|
AckTableEntry* replacement_entry = NULL;
|
|
if (txt_type == TXT_TYPE_PLAIN) {
|
|
mesh::Utils::sha256(text_fingerprint, sizeof(text_fingerprint),
|
|
recipient->id.pub_key, PUB_KEY_SIZE,
|
|
(const uint8_t*)text, strlen(text));
|
|
}
|
|
|
|
int result;
|
|
uint32_t expected_ack;
|
|
if (txt_type == TXT_TYPE_CLI_DATA || txt_type == TXT_TYPE_CLI_COMMAND) {
|
|
const uint32_t logical_request_id = msg_timestamp;
|
|
msg_timestamp = getRTCClock()->getCurrentTimeUnique(); // Use node's RTC instead of app timestamp to avoid tripping replay protection
|
|
result = sendCommandData(*recipient, msg_timestamp, attempt, txt_type,
|
|
text, est_timeout, logical_request_id);
|
|
expected_ack = 0; // no Ack expected
|
|
} else {
|
|
const uint32_t app_timestamp = msg_timestamp;
|
|
const bool is_room_post = recipient->type == ADV_TYPE_ROOM;
|
|
if (is_room_post
|
|
&& !room_message_timestamps.find(text_fingerprint, app_timestamp,
|
|
&msg_timestamp)) {
|
|
// Room login/control packets already use the node's monotonic clock.
|
|
// Give a new post that same clock source, then preserve the mapping
|
|
// so application retries keep one logical server-side timestamp.
|
|
msg_timestamp = getRTCClock()->getCurrentTimeUnique();
|
|
}
|
|
replacement_entry = findPendingTextMessage(text_fingerprint, msg_timestamp);
|
|
result = sendMessage(*recipient, msg_timestamp, attempt, text, expected_ack, est_timeout,
|
|
packet_retry_key, NULL, text_fingerprint);
|
|
if (result != MSG_SEND_FAILED && is_room_post) {
|
|
room_message_timestamps.remember(text_fingerprint, app_timestamp,
|
|
msg_timestamp);
|
|
}
|
|
}
|
|
if (result == MSG_SEND_FAILED) {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL);
|
|
} else {
|
|
if (replacement_entry != NULL) {
|
|
// The newest successfully-queued submission wins. Keep the older
|
|
// entry intact if composition, validation, or queueing failed.
|
|
clearExpectedAck(*replacement_entry, false);
|
|
}
|
|
if (expected_ack) {
|
|
AckTableEntry& entry = replacement_entry != NULL
|
|
? *replacement_entry
|
|
: expected_ack_table[next_ack_idx];
|
|
// Reusing this circular slot changes only ACK bookkeeping. Retry
|
|
// ownership lives in Mesh and ends only on an ACK, retry completion,
|
|
// or a successfully queued semantic replacement.
|
|
clearExpectedAck(entry, false);
|
|
entry.msg_sent = _ms->getMillis(); // add to circular table
|
|
entry.expires_at = futureMillis(est_timeout);
|
|
entry.ack = expected_ack;
|
|
entry.message_timestamp = msg_timestamp;
|
|
entry.contact = recipient;
|
|
entry.reply_route = _serial->captureReplyRoute();
|
|
memcpy(entry.text_fingerprint, text_fingerprint, sizeof(entry.text_fingerprint));
|
|
memcpy(entry.retry_key, packet_retry_key, sizeof(entry.retry_key));
|
|
if (replacement_entry == NULL) {
|
|
next_ack_idx = (next_ack_idx + 1) % EXPECTED_ACK_TABLE_SIZE;
|
|
}
|
|
}
|
|
if (replacement_entry != NULL || expected_ack != 0) {
|
|
expireExpectedAcks();
|
|
}
|
|
|
|
out_frame[0] = RESP_CODE_SENT;
|
|
out_frame[1] = (result == MSG_SEND_SENT_FLOOD) ? 1 : 0;
|
|
memcpy(&out_frame[2], &expected_ack, 4);
|
|
memcpy(&out_frame[6], &est_timeout, 4);
|
|
_serial->writeFrame(out_frame, 10);
|
|
}
|
|
} else {
|
|
writeErrFrame(recipient == NULL
|
|
? ERR_CODE_NOT_FOUND
|
|
: ERR_CODE_UNSUPPORTED_CMD); // unknown recipient, or unsupported TXT_TYPE_*
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SEND_CHANNEL_TXT_MSG) { // send GroupChannel text msg
|
|
if (len < 7) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
return;
|
|
}
|
|
int i = 1;
|
|
uint8_t txt_type = cmd_frame[i++]; // should be TXT_TYPE_PLAIN
|
|
uint8_t channel_idx = cmd_frame[i++];
|
|
uint32_t msg_timestamp;
|
|
memcpy(&msg_timestamp, &cmd_frame[i], 4);
|
|
i += 4;
|
|
const char *text = (char *)&cmd_frame[i];
|
|
|
|
if (txt_type != TXT_TYPE_PLAIN) {
|
|
writeErrFrame(ERR_CODE_UNSUPPORTED_CMD);
|
|
} else {
|
|
ChannelDetails channel;
|
|
bool success = getChannel(channel_idx, channel);
|
|
if (success && sendGroupMessage(msg_timestamp, channel.channel, _prefs.node_name, text, len - i)) {
|
|
writeOKFrame();
|
|
} else {
|
|
writeErrFrame(ERR_CODE_NOT_FOUND); // bad channel_idx
|
|
}
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SEND_CHANNEL_DATA) { // send GroupChannel datagram
|
|
if (len < 3) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
return;
|
|
}
|
|
int i = 1;
|
|
uint8_t channel_idx = cmd_frame[i++];
|
|
uint8_t path_len = cmd_frame[i++];
|
|
|
|
// validate path len, allowing 0xFF for flood
|
|
if (!mesh::Packet::isValidPathLen(path_len) && path_len != OUT_PATH_UNKNOWN) {
|
|
MESH_DEBUG_PRINTLN("CMD_SEND_CHANNEL_DATA invalid path size: %d", path_len);
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
return;
|
|
}
|
|
|
|
// parse provided path if not flood
|
|
uint8_t path[MAX_PATH_SIZE];
|
|
size_t path_bytes = 0;
|
|
if (path_len != OUT_PATH_UNKNOWN) {
|
|
path_bytes = (size_t)(path_len & 63) * (size_t)((path_len >> 6) + 1);
|
|
}
|
|
if ((size_t)i + path_bytes + 2 > len) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
return;
|
|
}
|
|
if (path_len != OUT_PATH_UNKNOWN) {
|
|
i += mesh::Packet::writePath(path, &cmd_frame[i], path_len);
|
|
}
|
|
|
|
uint16_t data_type = ((uint16_t)cmd_frame[i]) | (((uint16_t)cmd_frame[i + 1]) << 8);
|
|
i += 2;
|
|
const uint8_t *payload = &cmd_frame[i];
|
|
int payload_len = (len > (size_t)i) ? (int)(len - i) : 0;
|
|
|
|
ChannelDetails channel;
|
|
if (!getChannel(channel_idx, channel)) {
|
|
writeErrFrame(ERR_CODE_NOT_FOUND); // bad channel_idx
|
|
} else if (data_type == DATA_TYPE_RESERVED) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else if (payload_len > MAX_CHANNEL_DATA_LENGTH) {
|
|
MESH_DEBUG_PRINTLN("CMD_SEND_CHANNEL_DATA payload too long: %d > %d", payload_len, MAX_CHANNEL_DATA_LENGTH);
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else if (sendGroupData(channel.channel, path, path_len, data_type, payload, payload_len)) {
|
|
writeOKFrame();
|
|
} else {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL);
|
|
}
|
|
} else if (cmd_frame[0] == CMD_GET_CONTACTS) { // get Contact list
|
|
if (_iter_started) {
|
|
writeErrFrame(ERR_CODE_BAD_STATE); // iterator is currently busy
|
|
} else if (_store->hasIncompleteContactLoad()) {
|
|
// Never present a transiently unread page as an authoritative partial
|
|
// contact list. A reboot can retry the untouched source page.
|
|
writeErrFrame(ERR_CODE_FILE_IO_ERROR);
|
|
} else {
|
|
if (len >= 5) { // has optional 'since' param
|
|
memcpy(&_iter_filter_since, &cmd_frame[1], 4);
|
|
} else {
|
|
_iter_filter_since = 0;
|
|
}
|
|
|
|
// CONTACTS_START, every CONTACT, and END_OF_CONTACTS are one response
|
|
// transaction. Keep them on the transport which requested the list.
|
|
_serial->lockReplyRoute();
|
|
_iter = startContactsIterator();
|
|
_iter_started = true;
|
|
_iter_start_pending = true;
|
|
_iter_contact_pending = false;
|
|
_iter_next_frame_at = 0;
|
|
_iter_total_count = getNumContacts();
|
|
_iter_table_revision = getContactTableRevision();
|
|
_most_recent_lastmod = 0;
|
|
|
|
uint8_t reply[5];
|
|
reply[0] = RESP_CODE_CONTACTS_START;
|
|
memcpy(&reply[1], &_iter_total_count, 4); // total, NOT filtered count
|
|
if (_serial->writeFrame(reply, 5) == 5) {
|
|
_iter_start_pending = false;
|
|
_iter_next_frame_at = futureMillis(CONTACT_STREAM_FRAME_INTERVAL_MS);
|
|
}
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SET_ADVERT_NAME && len >= 2) {
|
|
int nlen = len - 1;
|
|
if (nlen > sizeof(_prefs.node_name) - 1) nlen = sizeof(_prefs.node_name) - 1; // max len
|
|
memcpy(_prefs.node_name, &cmd_frame[1], nlen);
|
|
_prefs.node_name[nlen] = 0; // null terminator
|
|
savePrefs();
|
|
writeOKFrame();
|
|
} else if (cmd_frame[0] == CMD_SET_ADVERT_LATLON && len >= 9) {
|
|
int32_t lat, lon, alt = 0;
|
|
memcpy(&lat, &cmd_frame[1], 4);
|
|
memcpy(&lon, &cmd_frame[5], 4);
|
|
if (len >= 13) {
|
|
memcpy(&alt, &cmd_frame[9], 4); // for FUTURE support
|
|
}
|
|
if (lat <= 90 * 1E6 && lat >= -90 * 1E6 && lon <= 180 * 1E6 && lon >= -180 * 1E6) {
|
|
sensors.node_lat = ((double)lat) / 1000000.0;
|
|
sensors.node_lon = ((double)lon) / 1000000.0;
|
|
savePrefs();
|
|
writeOKFrame();
|
|
} else {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG); // invalid geo coordinate
|
|
}
|
|
} else if (cmd_frame[0] == CMD_GET_DEVICE_TIME) {
|
|
uint8_t reply[5];
|
|
reply[0] = RESP_CODE_CURR_TIME;
|
|
uint32_t now = getRTCClock()->getCurrentTime();
|
|
memcpy(&reply[1], &now, 4);
|
|
_serial->writeFrame(reply, 5);
|
|
} else if (cmd_frame[0] == CMD_SET_DEVICE_TIME && len >= 5) {
|
|
uint32_t secs;
|
|
memcpy(&secs, &cmd_frame[1], 4);
|
|
uint32_t curr = getRTCClock()->getCurrentTime();
|
|
if (secs >= curr) {
|
|
getRTCClock()->setCurrentTime(secs);
|
|
#ifdef COMPANION_MESH_CLOCK_SYNC
|
|
_clock_sync.onManualClockSet();
|
|
#endif
|
|
writeOKFrame();
|
|
} else {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SEND_SELF_ADVERT) {
|
|
mesh::Packet* pkt;
|
|
if (_prefs.advert_loc_policy == ADVERT_LOC_NONE) {
|
|
pkt = createSelfAdvert(_prefs.node_name);
|
|
} else {
|
|
pkt = createSelfAdvert(_prefs.node_name, sensors.node_lat, sensors.node_lon);
|
|
}
|
|
if (pkt) {
|
|
if (len >= 2 && cmd_frame[1] == 1) { // optional param (1 = flood, 0 = zero hop)
|
|
unsigned long delay_millis = 0;
|
|
TransportKey default_scope;
|
|
memcpy(&default_scope.key, _prefs.default_scope_key, sizeof(default_scope.key));
|
|
sendFloodScoped(default_scope, pkt, delay_millis);
|
|
} else {
|
|
sendZeroHop(pkt);
|
|
}
|
|
writeOKFrame();
|
|
} else {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL);
|
|
}
|
|
} else if (cmd_frame[0] == CMD_RESET_PATH && len >= 1 + 32) {
|
|
if (_store->hasIncompleteContactLoad()) {
|
|
writeErrFrame(ERR_CODE_FILE_IO_ERROR);
|
|
} else {
|
|
uint8_t *pub_key = &cmd_frame[1];
|
|
ContactInfo *recipient = lookupPersistentContactByPubKey(pub_key, PUB_KEY_SIZE);
|
|
if (recipient) {
|
|
const uint8_t previous_out_path_len = recipient->out_path_len;
|
|
recipient->out_path_len = OUT_PATH_UNKNOWN;
|
|
// recipient->lastmod = ?? shouldn't be needed, app already has this version of contact
|
|
if (scheduleContactWrite(*recipient)) {
|
|
ContactInfo* transient = lookupTransientContactByPubKey(
|
|
pub_key, PUB_KEY_SIZE);
|
|
if (transient != NULL) clearTransientContact(*transient);
|
|
writeOKFrame();
|
|
} else {
|
|
recipient->out_path_len = previous_out_path_len;
|
|
writeErrFrame(ERR_CODE_FILE_IO_ERROR);
|
|
}
|
|
} else {
|
|
writeErrFrame(ERR_CODE_NOT_FOUND); // unknown contact
|
|
}
|
|
}
|
|
} else if (cmd_frame[0] == CMD_ADD_UPDATE_CONTACT) {
|
|
if (len < CONTACT_UPDATE_FRAME_MIN_LEN) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else if (_store->hasIncompleteContactLoad()) {
|
|
writeErrFrame(ERR_CODE_FILE_IO_ERROR);
|
|
} else {
|
|
uint8_t *pub_key = &cmd_frame[1];
|
|
ContactInfo *recipient = lookupPersistentContactByPubKey(pub_key, PUB_KEY_SIZE);
|
|
ContactInfo candidate = {};
|
|
if (recipient != NULL) candidate = *recipient;
|
|
|
|
uint32_t last_mod = getRTCClock()->getCurrentTime(); // fallback value if not present in cmd_frame
|
|
if (!updateContactFromFrame(candidate, last_mod, cmd_frame, len)) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else {
|
|
candidate.lastmod = last_mod;
|
|
if (recipient == NULL) candidate.sync_since = 0;
|
|
|
|
ContactInfo* transient = lookupTransientContactByPubKey(
|
|
pub_key, PUB_KEY_SIZE);
|
|
ContactInfo previous_transient = {};
|
|
if (transient != NULL) previous_transient = *transient;
|
|
|
|
if (recipient != NULL) {
|
|
const ContactInfo previous = *recipient;
|
|
*recipient = candidate;
|
|
if (scheduleContactWrite(*recipient)) {
|
|
// A prior anonymous request can leave a same-key entry in the
|
|
// reserved prefix. Retire it in place; never compact that prefix.
|
|
if (transient != NULL) clearTransientContact(*transient);
|
|
updateGpsTelemetryPolicy();
|
|
writeOKFrame();
|
|
} else {
|
|
*recipient = previous;
|
|
writeErrFrame(ERR_CODE_FILE_IO_ERROR);
|
|
}
|
|
} else {
|
|
// Promotion must free the exact transient prefix slot before lookup
|
|
// of the newly-added persistent record. Restore it on every failure.
|
|
if (transient != NULL) clearTransientContact(*transient);
|
|
if (addContact(candidate)) {
|
|
ContactInfo* added = lookupPersistentContactByPubKey(
|
|
candidate.id.pub_key, PUB_KEY_SIZE);
|
|
if (added != NULL && scheduleContactWrite(*added)) {
|
|
updateGpsTelemetryPolicy();
|
|
writeOKFrame();
|
|
} else {
|
|
if (added != NULL) removeContact(*added);
|
|
if (transient != NULL) *transient = previous_transient;
|
|
writeErrFrame(ERR_CODE_FILE_IO_ERROR);
|
|
}
|
|
} else {
|
|
if (transient != NULL) *transient = previous_transient;
|
|
writeErrFrame(ERR_CODE_TABLE_FULL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (cmd_frame[0] == CMD_REMOVE_CONTACT && len >= 1 + PUB_KEY_SIZE) {
|
|
if (_store->hasIncompleteContactLoad()) {
|
|
writeErrFrame(ERR_CODE_FILE_IO_ERROR);
|
|
} else {
|
|
uint8_t *pub_key = &cmd_frame[1];
|
|
ContactInfo *recipient = lookupPersistentContactByPubKey(pub_key, PUB_KEY_SIZE);
|
|
if (recipient == NULL) {
|
|
writeErrFrame(ERR_CODE_NOT_FOUND);
|
|
} else {
|
|
ContactInfo removed = *recipient;
|
|
// releaseContact() is failure-atomic, so reserve the persistent deletion
|
|
// before changing the live table. A failed release must not be ACKed.
|
|
uint16_t released_slot = mesh::storage::CONTACT_SLOT_NONE;
|
|
if (!scheduleContactWriteAfterRelease(removed, released_slot)) {
|
|
writeErrFrame(ERR_CODE_FILE_IO_ERROR);
|
|
} else if (!_store->deleteBlobByKey(pub_key, PUB_KEY_SIZE)) {
|
|
// Keep the live contact and restore ownership of its persistent slot.
|
|
// A full filesystem must not turn a failed cache deletion into an
|
|
// acknowledged contact removal with stale share data left behind.
|
|
if (!restoreContactWriteAfterRelease(*recipient, released_slot)) {
|
|
MESH_DEBUG_PRINTLN(
|
|
"Contact removal rollback failed after advert-cache error");
|
|
}
|
|
writeErrFrame(ERR_CODE_FILE_IO_ERROR);
|
|
} else if (!removeContact(*recipient)) {
|
|
// The lookup above makes this unreachable in the single-threaded mesh
|
|
// loop, but restore persistence bookkeeping if that invariant changes.
|
|
restoreContactWriteAfterRelease(*recipient, released_slot);
|
|
writeErrFrame(ERR_CODE_BAD_STATE);
|
|
} else {
|
|
ContactInfo* transient = lookupTransientContactByPubKey(
|
|
pub_key, PUB_KEY_SIZE);
|
|
if (transient != NULL) clearTransientContact(*transient);
|
|
updateGpsTelemetryPolicy();
|
|
writeOKFrame();
|
|
}
|
|
}
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SHARE_CONTACT && len >= 1 + PUB_KEY_SIZE) {
|
|
uint8_t *pub_key = &cmd_frame[1];
|
|
ContactInfo *recipient = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
|
|
if (recipient) {
|
|
if (shareContactZeroHop(*recipient)) {
|
|
writeOKFrame();
|
|
} else {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL); // unable to send
|
|
}
|
|
} else {
|
|
writeErrFrame(ERR_CODE_NOT_FOUND);
|
|
}
|
|
} else if (cmd_frame[0] == CMD_GET_CONTACT_BY_KEY && len >= 1 + PUB_KEY_SIZE) {
|
|
uint8_t *pub_key = &cmd_frame[1];
|
|
ContactInfo *contact = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
|
|
if (contact) {
|
|
writeContactRespFrame(RESP_CODE_CONTACT, *contact);
|
|
} else {
|
|
writeErrFrame(ERR_CODE_NOT_FOUND); // not found
|
|
}
|
|
} else if (cmd_frame[0] == CMD_EXPORT_CONTACT) {
|
|
if (len < 1 + PUB_KEY_SIZE) {
|
|
// export SELF
|
|
mesh::Packet* pkt;
|
|
if (_prefs.advert_loc_policy == ADVERT_LOC_NONE) {
|
|
pkt = createSelfAdvert(_prefs.node_name);
|
|
} else {
|
|
pkt = createSelfAdvert(_prefs.node_name, sensors.node_lat, sensors.node_lon);
|
|
}
|
|
if (pkt) {
|
|
pkt->header |= ROUTE_TYPE_FLOOD; // would normally be sent in this mode
|
|
|
|
out_frame[0] = RESP_CODE_EXPORT_CONTACT;
|
|
uint8_t out_len = pkt->writeTo(&out_frame[1]);
|
|
releasePacket(pkt); // undo the obtainNewPacket()
|
|
_serial->writeFrame(out_frame, out_len + 1);
|
|
} else {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL); // Error
|
|
}
|
|
} else {
|
|
uint8_t *pub_key = &cmd_frame[1];
|
|
ContactInfo *recipient = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
|
|
uint8_t out_len;
|
|
if (recipient && (out_len = exportContact(*recipient, &out_frame[1])) > 0) {
|
|
out_frame[0] = RESP_CODE_EXPORT_CONTACT;
|
|
_serial->writeFrame(out_frame, out_len + 1);
|
|
} else {
|
|
writeErrFrame(ERR_CODE_NOT_FOUND); // not found
|
|
}
|
|
}
|
|
} else if (cmd_frame[0] == CMD_IMPORT_CONTACT && len > 2 + 32 + 64) {
|
|
if (_store->hasIncompleteContactLoad()) {
|
|
// importContact() is asynchronous: without this admission gate the
|
|
// queued advert would be ACKed here and then deliberately discarded by
|
|
// BaseChatMesh's incomplete-table mutation veto on the next loop.
|
|
writeErrFrame(ERR_CODE_FILE_IO_ERROR);
|
|
} else if (importContact(&cmd_frame[1], len - 1)) {
|
|
updateGpsTelemetryPolicy();
|
|
writeOKFrame();
|
|
} else {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SYNC_NEXT_MESSAGE) {
|
|
int out_len;
|
|
if ((out_len = getFromOfflineQueue(out_frame)) > 0) {
|
|
_serial->writeFrame(out_frame, out_len);
|
|
#ifdef DISPLAY_CLASS
|
|
if (_ui) _ui->msgRead(offline_queue_len);
|
|
#endif
|
|
} else {
|
|
out_frame[0] = RESP_CODE_NO_MORE_MESSAGES;
|
|
_serial->writeFrame(out_frame, 1);
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SET_RADIO_PARAMS) {
|
|
if (len < 11) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
return;
|
|
}
|
|
#if COMPANION_FEATURE_TEMP_RADIO
|
|
if (isTempRadioActive() || _temp_radio_set_at != 0
|
|
|| _temp_radio_revert_at != 0) {
|
|
writeErrFrame(ERR_CODE_BAD_STATE);
|
|
return;
|
|
}
|
|
#endif
|
|
int i = 1;
|
|
uint32_t freq;
|
|
memcpy(&freq, &cmd_frame[i], 4);
|
|
i += 4;
|
|
uint32_t bw;
|
|
memcpy(&bw, &cmd_frame[i], 4);
|
|
i += 4;
|
|
uint8_t sf = cmd_frame[i++];
|
|
uint8_t cr = cmd_frame[i++];
|
|
uint8_t repeat = 0; // default - false
|
|
if (len > i) {
|
|
repeat = cmd_frame[i++]; // FIRMWARE_VER_CODE 9+
|
|
}
|
|
|
|
if (repeat && !isValidClientRepeatFreq(freq)) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else if (freq >= 150000 && freq <= 2500000 && sf >= 5 && sf <= 12 && cr >= 5 && cr <= 8 && bw >= 7000 &&
|
|
bw <= 500000) {
|
|
float new_freq = (float)freq / 1000.0;
|
|
float new_bw = (float)bw / 1000.0;
|
|
if (command_radio_apply_pending) {
|
|
writeErrFrame(ERR_CODE_BAD_STATE);
|
|
return;
|
|
}
|
|
|
|
mesh::RadioParamApplyResult result = tryApplyRadioParams(new_freq, new_bw, sf, cr);
|
|
if (result == mesh::RadioParamApplyResult::BUSY) {
|
|
// Capture this requester instead of relying on the mutable last-RX
|
|
// route. This remains correct if a contact stream later unlocks or a
|
|
// different transport supplies another command before completion.
|
|
command_radio_reply_route = _serial->captureReplyRoute();
|
|
if (command_radio_reply_route == NULL) {
|
|
writeErrFrame(ERR_CODE_BAD_STATE);
|
|
return;
|
|
}
|
|
command_radio_apply_pending = true;
|
|
command_radio_freq = new_freq;
|
|
command_radio_bw = new_bw;
|
|
command_radio_sf = sf;
|
|
command_radio_cr = cr;
|
|
command_radio_repeat = repeat;
|
|
command_radio_apply_deadline = futureMillis(COMMAND_RADIO_APPLY_TIMEOUT_MS);
|
|
MESH_DEBUG_PRINTLN("Deferred CMD_SET_RADIO_PARAMS while radio is busy");
|
|
return;
|
|
}
|
|
if (result == mesh::RadioParamApplyResult::FAILED) {
|
|
// Persisted settings remain authoritative after a rejected change or
|
|
// a hardware apply that had to be rolled back.
|
|
saved_radio_apply_pending = true;
|
|
radio_apply_retry_at = 0;
|
|
radio_apply_failures = 0;
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
return;
|
|
}
|
|
|
|
finishRadioParamApply(new_freq, new_bw, sf, cr, repeat);
|
|
} else {
|
|
MESH_DEBUG_PRINTLN("Error: CMD_SET_RADIO_PARAMS: f=%d, bw=%d, sf=%d, cr=%d", freq, bw, (uint32_t)sf,
|
|
(uint32_t)cr);
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SET_RADIO_TX_POWER) {
|
|
if (len < 2) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
return;
|
|
}
|
|
int8_t power = (int8_t)cmd_frame[1];
|
|
if (power < -9 || power > MAX_LORA_TX_POWER) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else {
|
|
_prefs.tx_power_dbm = power;
|
|
savePrefs();
|
|
if (_radio_available) radio_driver.setTxPower(_prefs.tx_power_dbm);
|
|
writeOKFrame();
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SET_TUNING_PARAMS) {
|
|
if (len < 9) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
return;
|
|
}
|
|
int i = 1;
|
|
uint32_t rx, af;
|
|
memcpy(&rx, &cmd_frame[i], 4);
|
|
i += 4;
|
|
memcpy(&af, &cmd_frame[i], 4);
|
|
i += 4;
|
|
_prefs.rx_delay_base = ((float)rx) / 1000.0f;
|
|
_prefs.airtime_factor = ((float)af) / 1000.0f;
|
|
savePrefs();
|
|
writeOKFrame();
|
|
} else if (cmd_frame[0] == CMD_GET_TUNING_PARAMS) {
|
|
uint32_t rx = _prefs.rx_delay_base * 1000, af = _prefs.airtime_factor * 1000;
|
|
int i = 0;
|
|
out_frame[i++] = RESP_CODE_TUNING_PARAMS;
|
|
memcpy(&out_frame[i], &rx, 4); i += 4;
|
|
memcpy(&out_frame[i], &af, 4); i += 4;
|
|
_serial->writeFrame(out_frame, i);
|
|
} else if (cmd_frame[0] == CMD_SET_OTHER_PARAMS) {
|
|
if (len < 2) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
return;
|
|
}
|
|
_prefs.manual_add_contacts = cmd_frame[1];
|
|
if (len >= 3) {
|
|
_prefs.telemetry_mode_base = cmd_frame[2] & 0x03; // v5+
|
|
_prefs.telemetry_mode_loc = (cmd_frame[2] >> 2) & 0x03;
|
|
_prefs.telemetry_mode_env = (cmd_frame[2] >> 4) & 0x03;
|
|
|
|
if (len >= 4) {
|
|
_prefs.advert_loc_policy = cmd_frame[3];
|
|
if (len >= 5) {
|
|
_prefs.multi_acks = cmd_frame[4];
|
|
}
|
|
}
|
|
}
|
|
updateGpsTelemetryPolicy();
|
|
savePrefs();
|
|
writeOKFrame();
|
|
} else if (cmd_frame[0] == CMD_SET_PATH_HASH_MODE && len >= 3 && cmd_frame[1] == 0) {
|
|
if (cmd_frame[2] >= 3) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else {
|
|
_prefs.path_hash_mode = cmd_frame[2];
|
|
savePrefs();
|
|
writeOKFrame();
|
|
}
|
|
} else if (cmd_frame[0] == CMD_REBOOT && len >= 7 && memcmp(&cmd_frame[1], "reboot", 6) == 0) {
|
|
if (!flushContactsBeforeReboot()) {
|
|
writeErrFrame(ERR_CODE_FILE_IO_ERROR);
|
|
return;
|
|
}
|
|
board.reboot();
|
|
} else if (cmd_frame[0] == CMD_GET_BATT_AND_STORAGE) {
|
|
uint8_t reply[11];
|
|
int i = 0;
|
|
reply[i++] = RESP_CODE_BATT_AND_STORAGE;
|
|
uint16_t battery_millivolts = board.getBattMilliVolts();
|
|
uint32_t used = _store->getStorageUsedKb();
|
|
uint32_t total = _store->getStorageTotalKb();
|
|
memcpy(&reply[i], &battery_millivolts, 2); i += 2;
|
|
memcpy(&reply[i], &used, 4); i += 4;
|
|
memcpy(&reply[i], &total, 4); i += 4;
|
|
_serial->writeFrame(reply, i);
|
|
} else if (cmd_frame[0] == CMD_EXPORT_PRIVATE_KEY) {
|
|
#if ENABLE_PRIVATE_KEY_EXPORT
|
|
uint8_t reply[65];
|
|
reply[0] = RESP_CODE_PRIVATE_KEY;
|
|
self_id.writeTo(&reply[1], 64);
|
|
_serial->writeFrame(reply, 65);
|
|
#else
|
|
writeDisabledFrame();
|
|
#endif
|
|
} else if (cmd_frame[0] == CMD_IMPORT_PRIVATE_KEY && len >= 65) {
|
|
#if ENABLE_PRIVATE_KEY_IMPORT
|
|
if (!mesh::LocalIdentity::validatePrivateKey(&cmd_frame[1])) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG); // invalid key
|
|
} else if (!flushContactsBeforeReboot()) {
|
|
// loadContacts() resets the dirty-page map, so never replace the
|
|
// identity and reload while newer contact state exists only in RAM.
|
|
writeErrFrame(ERR_CODE_FILE_IO_ERROR);
|
|
} else {
|
|
mesh::LocalIdentity identity;
|
|
identity.readFrom(&cmd_frame[1], 64);
|
|
if (_store->saveMainIdentity(identity)) {
|
|
self_id = identity;
|
|
writeOKFrame();
|
|
// re-load contacts, to invalidate ecdh shared_secrets
|
|
stopContactsIterator();
|
|
resetContacts();
|
|
mesh::resetLazyPersistenceAfterSuccess(
|
|
dirty_contacts_expiry, dirty_contacts_failures);
|
|
_store->loadContacts(this);
|
|
if (_store->hasPendingContactWrites()) {
|
|
mesh::scheduleLazyPersistenceMutation(
|
|
dirty_contacts_expiry, dirty_contacts_failures,
|
|
futureMillis(LAZY_CONTACTS_WRITE_DELAY));
|
|
}
|
|
updateGpsTelemetryPolicy();
|
|
} else {
|
|
writeErrFrame(ERR_CODE_FILE_IO_ERROR);
|
|
}
|
|
}
|
|
#else
|
|
writeDisabledFrame();
|
|
#endif
|
|
} else if (cmd_frame[0] == CMD_SEND_RAW_DATA && len >= 6) {
|
|
int i = 1;
|
|
uint8_t path_len = cmd_frame[i++];
|
|
if (path_len >= 0 && mesh::Packet::isValidPathLen(path_len)) {
|
|
uint8_t path[MAX_PATH_SIZE];
|
|
i += mesh::Packet::writePath(path, &cmd_frame[i], path_len);
|
|
if (i + 4 > len) { // min payload 4 bytes
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else {
|
|
auto pkt = createRawData(&cmd_frame[i], len - i);
|
|
if (pkt) {
|
|
sendDirect(pkt, path, path_len);
|
|
writeOKFrame();
|
|
} else {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL);
|
|
}
|
|
}
|
|
} else {
|
|
writeErrFrame(ERR_CODE_UNSUPPORTED_CMD); // flood, not supported (yet)
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SEND_LOGIN && len >= 1 + PUB_KEY_SIZE) {
|
|
uint8_t *pub_key = &cmd_frame[1];
|
|
ContactInfo *recipient = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
|
|
char *password = (char *)&cmd_frame[1 + PUB_KEY_SIZE];
|
|
cmd_frame[len] = 0; // ensure null terminator in password
|
|
if (recipient) {
|
|
uint32_t est_timeout;
|
|
int result = sendLogin(*recipient, password, est_timeout);
|
|
if (result == MSG_SEND_FAILED) {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL);
|
|
} else {
|
|
clearPendingReqs();
|
|
pending_serial_reply_route = _serial->captureReplyRoute();
|
|
pending_serial_reply_deadline =
|
|
futureMillis(est_timeout + est_timeout / 5);
|
|
memcpy(&pending_login, recipient->id.pub_key, 4); // match this to onContactResponse()
|
|
out_frame[0] = RESP_CODE_SENT;
|
|
out_frame[1] = (result == MSG_SEND_SENT_FLOOD) ? 1 : 0;
|
|
memcpy(&out_frame[2], &pending_login, 4);
|
|
memcpy(&out_frame[6], &est_timeout, 4);
|
|
_serial->writeFrame(out_frame, 10);
|
|
}
|
|
} else {
|
|
writeErrFrame(ERR_CODE_NOT_FOUND); // contact not found
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SEND_ANON_REQ && len > 1 + PUB_KEY_SIZE) {
|
|
uint8_t *pub_key = &cmd_frame[1];
|
|
ContactInfo *recipient = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
|
|
ContactInfo anon;
|
|
if (recipient == NULL) { // FIRMWARE_VER_CODE 13+, allow non-contact requests
|
|
memset(&anon, 0, sizeof(anon));
|
|
#if defined(NRF52_PLATFORM)
|
|
anon.storage_slot = mesh::storage::CONTACT_SLOT_NONE;
|
|
#endif
|
|
memcpy(anon.id.pub_key, pub_key, PUB_KEY_SIZE);
|
|
anon.out_path_len = 0; // default to zero-hop direct
|
|
anon.type = ADV_TYPE_NONE; // unknown
|
|
anon.lastmod = getRTCClock()->getCurrentTime();
|
|
|
|
if (addContact(anon)) recipient = &anon;
|
|
}
|
|
uint8_t *data = &cmd_frame[1 + PUB_KEY_SIZE];
|
|
if (recipient) {
|
|
uint32_t tag, est_timeout;
|
|
int result = sendAnonReq(*recipient, data, len - (1 + PUB_KEY_SIZE), tag, est_timeout);
|
|
if (result == MSG_SEND_FAILED) {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL);
|
|
} else {
|
|
clearPendingReqs();
|
|
pending_serial_reply_route = _serial->captureReplyRoute();
|
|
pending_serial_reply_deadline =
|
|
futureMillis(est_timeout + est_timeout / 5);
|
|
pending_req = tag; // match this to onContactResponse()
|
|
out_frame[0] = RESP_CODE_SENT;
|
|
out_frame[1] = (result == MSG_SEND_SENT_FLOOD) ? 1 : 0;
|
|
memcpy(&out_frame[2], &tag, 4);
|
|
memcpy(&out_frame[6], &est_timeout, 4);
|
|
_serial->writeFrame(out_frame, 10);
|
|
}
|
|
} else {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL); // contacts full
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SEND_STATUS_REQ && len >= 1 + PUB_KEY_SIZE) {
|
|
uint8_t *pub_key = &cmd_frame[1];
|
|
ContactInfo *recipient = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
|
|
if (recipient) {
|
|
uint32_t tag, est_timeout;
|
|
int result = sendRequest(*recipient, REQ_TYPE_GET_STATUS, tag, est_timeout);
|
|
if (result == MSG_SEND_FAILED) {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL);
|
|
} else {
|
|
clearPendingReqs();
|
|
pending_serial_reply_route = _serial->captureReplyRoute();
|
|
pending_serial_reply_deadline =
|
|
futureMillis(est_timeout + est_timeout / 5);
|
|
pending_status = tag; // match the reflected tag in onContactResponse()
|
|
out_frame[0] = RESP_CODE_SENT;
|
|
out_frame[1] = (result == MSG_SEND_SENT_FLOOD) ? 1 : 0;
|
|
memcpy(&out_frame[2], &tag, 4);
|
|
memcpy(&out_frame[6], &est_timeout, 4);
|
|
_serial->writeFrame(out_frame, 10);
|
|
}
|
|
} else {
|
|
writeErrFrame(ERR_CODE_NOT_FOUND); // contact not found
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SEND_PATH_DISCOVERY_REQ && len >= 2 + PUB_KEY_SIZE && cmd_frame[1] == 0) {
|
|
uint8_t *pub_key = &cmd_frame[2];
|
|
ContactInfo *recipient = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
|
|
if (recipient) {
|
|
uint32_t tag, est_timeout;
|
|
// 'Path Discovery' is just a special case of flood + Telemetry req
|
|
uint8_t req_data[9];
|
|
req_data[0] = REQ_TYPE_GET_TELEMETRY_DATA;
|
|
req_data[1] = ~(TELEM_PERM_BASE); // NEW: inverse permissions mask (ie. we only want BASE telemetry)
|
|
memset(&req_data[2], 0, 3); // reserved
|
|
getRNG()->random(&req_data[5], 4); // random blob to help make packet-hash unique
|
|
auto save = recipient->out_path_len; // temporarily force sendRequest() to flood
|
|
recipient->out_path_len = OUT_PATH_UNKNOWN;
|
|
int result = sendRequest(*recipient, req_data, sizeof(req_data), tag, est_timeout);
|
|
recipient->out_path_len = save;
|
|
if (result == MSG_SEND_FAILED) {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL);
|
|
} else {
|
|
clearPendingReqs();
|
|
pending_serial_reply_route = _serial->captureReplyRoute();
|
|
pending_serial_reply_deadline =
|
|
futureMillis(est_timeout + est_timeout / 5);
|
|
pending_discovery = tag; // match this in onContactResponse()
|
|
out_frame[0] = RESP_CODE_SENT;
|
|
out_frame[1] = (result == MSG_SEND_SENT_FLOOD) ? 1 : 0;
|
|
memcpy(&out_frame[2], &tag, 4);
|
|
memcpy(&out_frame[6], &est_timeout, 4);
|
|
_serial->writeFrame(out_frame, 10);
|
|
}
|
|
} else {
|
|
writeErrFrame(ERR_CODE_NOT_FOUND); // contact not found
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SEND_TELEMETRY_REQ && len >= 4 + PUB_KEY_SIZE) { // can deprecate, in favour of CMD_SEND_BINARY_REQ
|
|
uint8_t *pub_key = &cmd_frame[4];
|
|
ContactInfo *recipient = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
|
|
if (recipient) {
|
|
uint32_t tag, est_timeout;
|
|
int result = sendRequest(*recipient, REQ_TYPE_GET_TELEMETRY_DATA, tag, est_timeout);
|
|
if (result == MSG_SEND_FAILED) {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL);
|
|
} else {
|
|
clearPendingReqs();
|
|
pending_serial_reply_route = _serial->captureReplyRoute();
|
|
pending_serial_reply_deadline =
|
|
futureMillis(est_timeout + est_timeout / 5);
|
|
pending_telemetry = tag; // match this in onContactResponse()
|
|
out_frame[0] = RESP_CODE_SENT;
|
|
out_frame[1] = (result == MSG_SEND_SENT_FLOOD) ? 1 : 0;
|
|
memcpy(&out_frame[2], &tag, 4);
|
|
memcpy(&out_frame[6], &est_timeout, 4);
|
|
_serial->writeFrame(out_frame, 10);
|
|
}
|
|
} else {
|
|
writeErrFrame(ERR_CODE_NOT_FOUND); // contact not found
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SEND_TELEMETRY_REQ && len == 4) { // 'self' telemetry request
|
|
telemetry.reset();
|
|
telemetry.addVoltage(TELEM_CHANNEL_SELF, (float)board.getBattMilliVolts() / 1000.0f);
|
|
float temperature = board.getMCUTemperature();
|
|
if(!isnan(temperature)) { // Supported boards with built-in temperature sensor. ESP32-C3 may return NAN
|
|
telemetry.addTemperature(TELEM_CHANNEL_SELF, temperature); // Built-in MCU Temperature
|
|
}
|
|
|
|
// query other sensors -- target specific
|
|
sensors.querySensors(0xFF, telemetry);
|
|
|
|
int i = 0;
|
|
out_frame[i++] = PUSH_CODE_TELEMETRY_RESPONSE;
|
|
out_frame[i++] = 0; // reserved
|
|
memcpy(&out_frame[i], self_id.pub_key, 6);
|
|
i += 6; // pub_key_prefix
|
|
uint8_t tlen = telemetry.getSize();
|
|
memcpy(&out_frame[i], telemetry.getBuffer(), tlen);
|
|
i += tlen;
|
|
_serial->writeFrame(out_frame, i);
|
|
} else if (cmd_frame[0] == CMD_SEND_BINARY_REQ && len >= 2 + PUB_KEY_SIZE) {
|
|
uint8_t *pub_key = &cmd_frame[1];
|
|
ContactInfo *recipient = lookupContactByPubKey(pub_key, PUB_KEY_SIZE);
|
|
if (recipient) {
|
|
uint8_t *req_data = &cmd_frame[1 + PUB_KEY_SIZE];
|
|
uint32_t tag, est_timeout;
|
|
int result = sendRequest(*recipient, req_data, len - (1 + PUB_KEY_SIZE), tag, est_timeout);
|
|
if (result == MSG_SEND_FAILED) {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL);
|
|
} else {
|
|
clearPendingReqs();
|
|
pending_serial_reply_route = _serial->captureReplyRoute();
|
|
pending_serial_reply_deadline =
|
|
futureMillis(est_timeout + est_timeout / 5);
|
|
pending_req = tag; // match this in onContactResponse()
|
|
out_frame[0] = RESP_CODE_SENT;
|
|
out_frame[1] = (result == MSG_SEND_SENT_FLOOD) ? 1 : 0;
|
|
memcpy(&out_frame[2], &tag, 4);
|
|
memcpy(&out_frame[6], &est_timeout, 4);
|
|
_serial->writeFrame(out_frame, 10);
|
|
}
|
|
} else {
|
|
writeErrFrame(ERR_CODE_NOT_FOUND); // contact not found
|
|
}
|
|
} else if (cmd_frame[0] == CMD_HAS_CONNECTION && len >= 1 + PUB_KEY_SIZE) {
|
|
uint8_t *pub_key = &cmd_frame[1];
|
|
if (hasConnectionTo(pub_key)) {
|
|
writeOKFrame();
|
|
} else {
|
|
writeErrFrame(ERR_CODE_NOT_FOUND);
|
|
}
|
|
} else if (cmd_frame[0] == CMD_LOGOUT && len >= 1 + PUB_KEY_SIZE) {
|
|
uint8_t *pub_key = &cmd_frame[1];
|
|
stopConnection(pub_key);
|
|
writeOKFrame();
|
|
} else if (cmd_frame[0] == CMD_GET_CHANNEL && len >= 2) {
|
|
uint8_t channel_idx = cmd_frame[1];
|
|
ChannelDetails channel;
|
|
if (getChannel(channel_idx, channel)) {
|
|
int i = 0;
|
|
out_frame[i++] = RESP_CODE_CHANNEL_INFO;
|
|
out_frame[i++] = channel_idx;
|
|
strcpy((char *)&out_frame[i], channel.name);
|
|
i += 32;
|
|
memcpy(&out_frame[i], channel.channel.secret, 16);
|
|
i += 16; // NOTE: only 128-bit supported
|
|
_serial->writeFrame(out_frame, i);
|
|
} else {
|
|
writeErrFrame(ERR_CODE_NOT_FOUND);
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SET_CHANNEL && len >= 2 + 32 + 32) {
|
|
writeErrFrame(ERR_CODE_UNSUPPORTED_CMD); // not supported (yet)
|
|
} else if (cmd_frame[0] == CMD_SET_CHANNEL && len >= 2 + 32 + 16) {
|
|
uint8_t channel_idx = cmd_frame[1];
|
|
ChannelDetails previous;
|
|
ChannelDetails channel;
|
|
StrHelper::strncpy(channel.name, (char *)&cmd_frame[2], 32);
|
|
memset(channel.channel.secret, 0, sizeof(channel.channel.secret));
|
|
memcpy(channel.channel.secret, &cmd_frame[2 + 32], 16); // NOTE: only 128-bit supported
|
|
if (!getChannel(channel_idx, previous)
|
|
|| !setChannel(channel_idx, channel)) {
|
|
writeErrFrame(ERR_CODE_NOT_FOUND); // bad channel_idx
|
|
} else if (saveChannels()) {
|
|
writeOKFrame();
|
|
} else {
|
|
// AtomicFileWriter preserves the last complete channels file. Keep the
|
|
// live table consistent with it when a full or failing filesystem cannot
|
|
// commit this update, and never acknowledge a change that will disappear
|
|
// after reboot.
|
|
setChannel(channel_idx, previous);
|
|
writeErrFrame(ERR_CODE_FILE_IO_ERROR);
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SIGN_START) {
|
|
BaseSerialInterface* signing_route = _serial->captureReplyRoute();
|
|
if (signing_route == NULL) {
|
|
writeErrFrame(ERR_CODE_BAD_STATE);
|
|
return;
|
|
}
|
|
if (sign_data != NULL && sign_data_reply_route != signing_route) {
|
|
writeErrFrame(ERR_CODE_BAD_STATE);
|
|
return;
|
|
}
|
|
cancelSigningSession();
|
|
sign_data = (uint8_t *)malloc(MAX_SIGN_DATA_LEN);
|
|
if (sign_data == NULL) {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL);
|
|
return;
|
|
}
|
|
sign_data_len = 0;
|
|
sign_data_reply_route = signing_route;
|
|
sign_data_deadline = futureMillis(SIGN_SESSION_TIMEOUT_MILLIS);
|
|
|
|
out_frame[0] = RESP_CODE_SIGN_START;
|
|
out_frame[1] = 0; // reserved
|
|
uint32_t len = MAX_SIGN_DATA_LEN;
|
|
memcpy(&out_frame[2], &len, 4);
|
|
_serial->writeFrame(out_frame, 6);
|
|
} else if (cmd_frame[0] == CMD_SIGN_DATA && len > 1) {
|
|
BaseSerialInterface* signing_route = _serial->captureReplyRoute();
|
|
if (sign_data == NULL || sign_data_reply_route != signing_route) {
|
|
writeErrFrame(ERR_CODE_BAD_STATE);
|
|
} else if (sign_data_len + (len - 1) > MAX_SIGN_DATA_LEN) {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL); // error: too long
|
|
} else {
|
|
memcpy(&sign_data[sign_data_len], &cmd_frame[1], len - 1);
|
|
sign_data_len += (len - 1);
|
|
sign_data_deadline = futureMillis(SIGN_SESSION_TIMEOUT_MILLIS);
|
|
writeOKFrame();
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SIGN_FINISH) {
|
|
if (sign_data != NULL
|
|
&& sign_data_reply_route == _serial->captureReplyRoute()) {
|
|
self_id.sign(&out_frame[1], sign_data, sign_data_len);
|
|
|
|
cancelSigningSession();
|
|
|
|
out_frame[0] = RESP_CODE_SIGNATURE;
|
|
_serial->writeFrame(out_frame, 1 + SIGNATURE_SIZE);
|
|
} else {
|
|
writeErrFrame(ERR_CODE_BAD_STATE);
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SEND_TRACE_PATH && len > 10 && len - 10 <= MAX_PACKET_PAYLOAD - 9) {
|
|
serviceBinaryTraceReply();
|
|
if (binary_trace_pending) {
|
|
writeErrFrame(ERR_CODE_BAD_STATE);
|
|
return;
|
|
}
|
|
uint8_t path_len = len - 10;
|
|
uint8_t flags = cmd_frame[9];
|
|
uint8_t path_sz = flags & 0x03; // NEW v1.11+
|
|
if ((path_len >> path_sz) > MAX_PATH_SIZE || (path_len % (1 << path_sz)) != 0) { // make sure is multiple of path_sz
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else {
|
|
uint32_t tag, auth;
|
|
memcpy(&tag, &cmd_frame[1], 4);
|
|
memcpy(&auth, &cmd_frame[5], 4);
|
|
auto pkt = createTrace(tag, auth, flags);
|
|
if (pkt) {
|
|
// Compute before handing ownership to sendDirect(), which releases the
|
|
// packet itself if validation or queueing fails.
|
|
uint32_t t = _radio->getEstAirtimeFor(9 + path_len + 2);
|
|
uint32_t est_timeout = calcDirectTimeoutMillisFor(t, path_len >> path_sz);
|
|
if (sendDirect(pkt, &cmd_frame[10], path_len)) {
|
|
binary_trace_pending = true;
|
|
binary_trace_tag = tag;
|
|
binary_trace_auth = auth;
|
|
binary_trace_deadline =
|
|
futureMillis(est_timeout + est_timeout / 5);
|
|
binary_trace_reply_route = _serial->captureReplyRoute();
|
|
out_frame[0] = RESP_CODE_SENT;
|
|
out_frame[1] = 0;
|
|
memcpy(&out_frame[2], &tag, 4);
|
|
memcpy(&out_frame[6], &est_timeout, 4);
|
|
_serial->writeFrame(out_frame, 10);
|
|
} else {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL);
|
|
}
|
|
} else {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL);
|
|
}
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SET_DEVICE_PIN && len >= 5) {
|
|
|
|
// get pin from command frame
|
|
uint32_t pin;
|
|
memcpy(&pin, &cmd_frame[1], 4);
|
|
|
|
// ensure pin is zero, or a valid 6 digit pin
|
|
if (pin == 0 || (pin >= 100000 && pin <= 999999)) {
|
|
_prefs.ble_pin = pin;
|
|
savePrefs();
|
|
writeOKFrame();
|
|
} else {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
}
|
|
} else if (cmd_frame[0] == CMD_GET_CUSTOM_VARS) {
|
|
out_frame[0] = RESP_CODE_CUSTOM_VARS;
|
|
char *dp = (char *)&out_frame[1];
|
|
for (int i = 0; i < sensors.getNumSettings() && dp - (char *)&out_frame[1] < 140; i++) {
|
|
if (i > 0) {
|
|
*dp++ = ',';
|
|
}
|
|
strcpy(dp, sensors.getSettingName(i));
|
|
dp = strchr(dp, 0);
|
|
*dp++ = ':';
|
|
strcpy(dp, sensors.getSettingValue(i));
|
|
dp = strchr(dp, 0);
|
|
}
|
|
_serial->writeFrame(out_frame, dp - (char *)out_frame);
|
|
} else if (cmd_frame[0] == CMD_SET_CUSTOM_VAR && len >= 4) {
|
|
cmd_frame[len] = 0;
|
|
char *sp = (char *)&cmd_frame[1];
|
|
char *np = strchr(sp, ':'); // look for separator char
|
|
if (np) {
|
|
*np++ = 0; // modify 'cmd_frame', replace ':' with null
|
|
bool success = sensors.setSettingValue(sp, np);
|
|
if (success) {
|
|
#if ENV_INCLUDE_GPS == 1
|
|
// Update node preferences for GPS settings
|
|
if (strcmp(sp, "gps") == 0) {
|
|
_prefs.gps_enabled = (np[0] == '1') ? 1 : 0;
|
|
savePrefs();
|
|
} else if (strcmp(sp, "gps_interval") == 0) {
|
|
uint32_t interval_seconds = atoi(np);
|
|
_prefs.gps_interval = constrain(interval_seconds, 0, 86400);
|
|
savePrefs();
|
|
}
|
|
#endif
|
|
writeOKFrame();
|
|
} else {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
}
|
|
} else {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
}
|
|
} else if (mesh::companion::isFemRxGainGet(cmd_frame[0])) {
|
|
if (len != 1) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else if (!board.canControlLoRaFemLna()) {
|
|
writeErrFrame(ERR_CODE_UNSUPPORTED_CMD);
|
|
} else {
|
|
out_frame[0] = RESP_CODE_OK;
|
|
uint8_t value = board.isLoRaFemLnaEnabled() ? 1 : 0;
|
|
memcpy(&out_frame[1], &value, 1);
|
|
_serial->writeFrame(out_frame, 2);
|
|
}
|
|
} else if (mesh::companion::isFemRxGainSet(cmd_frame[0])) {
|
|
uint8_t value = len >= 2 ? cmd_frame[1] : 0;
|
|
if (len != 2) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else if (!board.canControlLoRaFemLna()) {
|
|
writeErrFrame(ERR_CODE_UNSUPPORTED_CMD);
|
|
} else if (value <= 1) {
|
|
if (applyAndSaveFemRxGain(value != 0)) {
|
|
writeOKFrame();
|
|
} else {
|
|
writeErrFrame(ERR_CODE_BAD_STATE);
|
|
}
|
|
} else {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
}
|
|
} else if (mesh::companion::isRadioRxGainGet(cmd_frame[0])) {
|
|
if (len != 1) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else if (!radio_driver.supportsRxBoostedGainMode()) {
|
|
writeErrFrame(ERR_CODE_UNSUPPORTED_CMD);
|
|
} else {
|
|
out_frame[0] = RESP_CODE_OK;
|
|
out_frame[1] = _prefs.rx_boosted_gain ? 1 : 0;
|
|
_serial->writeFrame(out_frame, 2);
|
|
}
|
|
} else if (mesh::companion::isRadioRxGainSet(cmd_frame[0])) {
|
|
uint8_t value = len >= 2 ? cmd_frame[1] : 0;
|
|
if (len != 2 || value > 1) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else if (!radio_driver.supportsRxBoostedGainMode()) {
|
|
writeErrFrame(ERR_CODE_UNSUPPORTED_CMD);
|
|
} else if (!applyAndSaveRxBoostedGain(value != 0)) {
|
|
writeErrFrame(ERR_CODE_BAD_STATE);
|
|
} else {
|
|
writeOKFrame();
|
|
}
|
|
} else if (mesh::companion::isWiFiPowerSaveGet(cmd_frame[0])) {
|
|
if (len != 1) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else {
|
|
#if defined(ESP32) && defined(WIFI_SSID)
|
|
out_frame[0] = RESP_CODE_OK;
|
|
out_frame[1] = getCompanionWiFiPowerSave();
|
|
_serial->writeFrame(out_frame, 2);
|
|
#else
|
|
writeErrFrame(ERR_CODE_UNSUPPORTED_CMD);
|
|
#endif
|
|
}
|
|
} else if (mesh::companion::isWiFiPowerSaveSet(cmd_frame[0])) {
|
|
if (len != 2) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else {
|
|
#if defined(ESP32) && defined(WIFI_SSID)
|
|
const uint8_t value = cmd_frame[1];
|
|
if (value > mesh::wifi::kPowerSaveMax) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else {
|
|
char reply[160];
|
|
if (applyAndSaveWiFiPowerSaving(
|
|
companionWiFiPowerSaveName(value), reply, sizeof(reply))) {
|
|
writeOKFrame();
|
|
} else {
|
|
writeErrFrame(ERR_CODE_BAD_STATE);
|
|
}
|
|
}
|
|
#else
|
|
writeErrFrame(ERR_CODE_UNSUPPORTED_CMD);
|
|
#endif
|
|
}
|
|
} else if (mesh::companion::isBluetoothNameGet(cmd_frame[0])) {
|
|
if (len != 1) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else {
|
|
out_frame[0] = RESP_CODE_OK;
|
|
out_frame[1] = mesh::companion::hasCustomBluetoothName(
|
|
_prefs.bluetooth_name) ? 1 : 0;
|
|
char* effective_name = reinterpret_cast<char*>(&out_frame[2]);
|
|
mesh::companion::formatBluetoothName(
|
|
effective_name, MAX_FRAME_SIZE - 1, _prefs.bluetooth_name,
|
|
BLE_NAME_PREFIX, _prefs.node_name);
|
|
_serial->writeFrame(out_frame, 2 + strlen(effective_name));
|
|
}
|
|
} else if (mesh::companion::isBluetoothNameSet(cmd_frame[0])) {
|
|
const size_t name_len = len - 1;
|
|
if (name_len > mesh::companion::BLUETOOTH_NAME_MAX_BYTES
|
|
|| memchr(&cmd_frame[1], 0, name_len) != NULL) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else {
|
|
char name[mesh::companion::BLUETOOTH_NAME_SIZE] = {0};
|
|
if (name_len != 0) memcpy(name, &cmd_frame[1], name_len);
|
|
if (name_len != 0 && !mesh::companion::isValidBluetoothName(name)) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else if (!saveBluetoothNameOverride(name)) {
|
|
writeErrFrame(ERR_CODE_BAD_STATE);
|
|
} else {
|
|
writeOKFrame();
|
|
}
|
|
}
|
|
} else if (cmd_frame[0]
|
|
== mesh::companion::CMD_EXEC_LOCAL_OTA_CONTROL) {
|
|
#if COMPANION_FEATURE_OTA_CLI
|
|
const size_t command_len = len - 1;
|
|
if (!mesh::companion::isBleOtaControlCommandAllowed(
|
|
&cmd_frame[1], command_len)) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else {
|
|
char command[MAX_FRAME_SIZE] = {0};
|
|
memcpy(command, &cmd_frame[1], command_len);
|
|
char reply[MAX_FRAME_SIZE] = {0};
|
|
if (!handleLocalControlCommand(command, reply, sizeof(reply))) {
|
|
writeErrFrame(ERR_CODE_UNSUPPORTED_CMD);
|
|
} else {
|
|
out_frame[0] = RESP_CODE_OK;
|
|
const size_t reply_len = strnlen(reply, MAX_FRAME_SIZE - 2);
|
|
out_frame[1] = static_cast<uint8_t>(reply_len);
|
|
memcpy(&out_frame[2], reply, reply_len);
|
|
_serial->writeFrame(out_frame, 2 + reply_len);
|
|
}
|
|
}
|
|
#else
|
|
writeErrFrame(ERR_CODE_UNSUPPORTED_CMD);
|
|
#endif
|
|
} else if (cmd_frame[0] == mesh::companion::CMD_BLE_MOTA_SOURCE) {
|
|
#if defined(COMPANION_RADIO_FULL)
|
|
if (len != 2) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
} else if (_mota_source_control == NULL) {
|
|
writeErrFrame(ERR_CODE_UNSUPPORTED_CMD);
|
|
} else {
|
|
const mesh::companion::MotaSourceAction action =
|
|
static_cast<mesh::companion::MotaSourceAction>(cmd_frame[1]);
|
|
char control_reply[96] = {0};
|
|
bool action_ok = true;
|
|
if (action == mesh::companion::MotaSourceAction::Start) {
|
|
action_ok = _mota_source_control->start(control_reply,
|
|
sizeof(control_reply));
|
|
} else if (action == mesh::companion::MotaSourceAction::Stop) {
|
|
action_ok = _mota_source_control->stop(control_reply,
|
|
sizeof(control_reply));
|
|
} else if (action != mesh::companion::MotaSourceAction::Status) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
return;
|
|
}
|
|
|
|
if (!action_ok) {
|
|
writeErrFrame(ERR_CODE_BAD_STATE);
|
|
} else {
|
|
const mesh::companion::MotaSourceStatus status =
|
|
_mota_source_control->status();
|
|
uint8_t flags = 0;
|
|
if (status.channel_ready) {
|
|
flags |= mesh::companion::MOTA_SOURCE_FLAG_CHANNEL_READY;
|
|
}
|
|
if (status.attached) {
|
|
flags |= mesh::companion::MOTA_SOURCE_FLAG_ATTACHED;
|
|
}
|
|
if (status.another_link_active) {
|
|
flags |=
|
|
mesh::companion::MOTA_SOURCE_FLAG_ANOTHER_LINK_ACTIVE;
|
|
}
|
|
out_frame[0] = RESP_CODE_OK;
|
|
out_frame[1] = cmd_frame[1];
|
|
out_frame[2] = flags;
|
|
out_frame[3] = static_cast<uint8_t>(status.offered & 0xFF);
|
|
out_frame[4] = static_cast<uint8_t>(status.offered >> 8);
|
|
out_frame[5] = static_cast<uint8_t>(status.advertised & 0xFF);
|
|
out_frame[6] = static_cast<uint8_t>(status.advertised >> 8);
|
|
out_frame[7] = static_cast<uint8_t>(status.packets_sent & 0xFF);
|
|
out_frame[8] = static_cast<uint8_t>((status.packets_sent >> 8) & 0xFF);
|
|
out_frame[9] = static_cast<uint8_t>((status.packets_sent >> 16) & 0xFF);
|
|
out_frame[10] = static_cast<uint8_t>((status.packets_sent >> 24) & 0xFF);
|
|
_serial->writeFrame(out_frame, 11);
|
|
}
|
|
}
|
|
#else
|
|
writeErrFrame(ERR_CODE_UNSUPPORTED_CMD);
|
|
#endif
|
|
} else if (cmd_frame[0] == CMD_GET_ADVERT_PATH && len >= PUB_KEY_SIZE+2) {
|
|
// FUTURE use: uint8_t reserved = cmd_frame[1];
|
|
uint8_t *pub_key = &cmd_frame[2];
|
|
AdvertPath* found = NULL;
|
|
for (int i = 0; i < ADVERT_PATH_TABLE_SIZE; i++) {
|
|
auto p = &advert_paths[i];
|
|
if (memcmp(p->pubkey_prefix, pub_key, sizeof(p->pubkey_prefix)) == 0) {
|
|
found = p;
|
|
break;
|
|
}
|
|
}
|
|
if (found) {
|
|
int i = 0;
|
|
out_frame[i++] = RESP_CODE_ADVERT_PATH;
|
|
memcpy(&out_frame[i], &found->recv_timestamp, 4); i += 4;
|
|
out_frame[i++] = found->path_len;
|
|
i += mesh::Packet::writePath(&out_frame[i], found->path, found->path_len);
|
|
_serial->writeFrame(out_frame, i);
|
|
} else {
|
|
writeErrFrame(ERR_CODE_NOT_FOUND);
|
|
}
|
|
} else if (cmd_frame[0] == CMD_GET_STATS && len >= 2) {
|
|
uint8_t stats_type = cmd_frame[1];
|
|
if (stats_type == STATS_TYPE_CORE) {
|
|
int i = 0;
|
|
out_frame[i++] = RESP_CODE_STATS;
|
|
out_frame[i++] = STATS_TYPE_CORE;
|
|
uint16_t battery_mv = board.getBattMilliVolts();
|
|
uint32_t uptime_secs = _ms->getMillis() / 1000;
|
|
uint8_t queue_len = (uint8_t)_mgr->getOutboundCount(0xFFFFFFFF);
|
|
memcpy(&out_frame[i], &battery_mv, 2); i += 2;
|
|
memcpy(&out_frame[i], &uptime_secs, 4); i += 4;
|
|
memcpy(&out_frame[i], &_err_flags, 2); i += 2;
|
|
out_frame[i++] = queue_len;
|
|
_serial->writeFrame(out_frame, i);
|
|
} else if (stats_type == STATS_TYPE_RADIO) {
|
|
int i = 0;
|
|
out_frame[i++] = RESP_CODE_STATS;
|
|
out_frame[i++] = STATS_TYPE_RADIO;
|
|
int16_t noise_floor = (int16_t)_radio->getNoiseFloor();
|
|
int8_t last_rssi = (int8_t)radio_driver.getLastRSSI();
|
|
int8_t last_snr = (int8_t)(radio_driver.getLastSNR() * 4); // scaled by 4 for 0.25 dB precision
|
|
uint32_t tx_air_secs = getTotalAirTime() / 1000;
|
|
uint32_t rx_air_secs = getReceiveAirTime() / 1000;
|
|
memcpy(&out_frame[i], &noise_floor, 2); i += 2;
|
|
out_frame[i++] = last_rssi;
|
|
out_frame[i++] = last_snr;
|
|
memcpy(&out_frame[i], &tx_air_secs, 4); i += 4;
|
|
memcpy(&out_frame[i], &rx_air_secs, 4); i += 4;
|
|
_serial->writeFrame(out_frame, i);
|
|
} else if (stats_type == STATS_TYPE_PACKETS) {
|
|
int i = 0;
|
|
out_frame[i++] = RESP_CODE_STATS;
|
|
out_frame[i++] = STATS_TYPE_PACKETS;
|
|
uint32_t recv = radio_driver.getPacketsRecv();
|
|
uint32_t sent = radio_driver.getPacketsSent();
|
|
uint32_t n_sent_flood = getNumSentFlood();
|
|
uint32_t n_sent_direct = getNumSentDirect();
|
|
uint32_t n_recv_flood = getNumRecvFlood();
|
|
uint32_t n_recv_direct = getNumRecvDirect();
|
|
uint32_t n_recv_errors = radio_driver.getPacketsRecvErrors();
|
|
memcpy(&out_frame[i], &recv, 4); i += 4;
|
|
memcpy(&out_frame[i], &sent, 4); i += 4;
|
|
memcpy(&out_frame[i], &n_sent_flood, 4); i += 4;
|
|
memcpy(&out_frame[i], &n_sent_direct, 4); i += 4;
|
|
memcpy(&out_frame[i], &n_recv_flood, 4); i += 4;
|
|
memcpy(&out_frame[i], &n_recv_direct, 4); i += 4;
|
|
memcpy(&out_frame[i], &n_recv_errors, 4); i += 4;
|
|
_serial->writeFrame(out_frame, i);
|
|
} else {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG); // invalid stats sub-type
|
|
}
|
|
} else if (cmd_frame[0] == CMD_FACTORY_RESET && len >= 6 && memcmp(&cmd_frame[1], "reset", 5) == 0) {
|
|
if (_serial) {
|
|
MESH_DEBUG_PRINTLN("Factory reset: disabling serial interface to prevent reconnects (BLE/WiFi)");
|
|
_serial->disable(); // Phone app disconnects before we can send OK frame so it's safe here
|
|
}
|
|
bool success = _store->formatFileSystem();
|
|
if (success) {
|
|
writeOKFrame();
|
|
delay(1000);
|
|
board.reboot(); // doesn't return
|
|
} else {
|
|
writeErrFrame(ERR_CODE_FILE_IO_ERROR);
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SET_FLOOD_SCOPE_KEY && len >= 2 && cmd_frame[1] == 0) {
|
|
if (len >= 2 + 16) {
|
|
memcpy(send_scope.key, &cmd_frame[2], sizeof(send_scope.key)); // set scope override TransportKey
|
|
} else {
|
|
memset(send_scope.key, 0, sizeof(send_scope.key)); // reset scope override
|
|
}
|
|
send_unscoped = false;
|
|
writeOKFrame();
|
|
} else if (cmd_frame[0] == CMD_SET_FLOOD_SCOPE_KEY && len >= 2 && cmd_frame[1] == 1) { // ver 12+
|
|
send_unscoped = true;
|
|
writeOKFrame();
|
|
} else if (cmd_frame[0] == CMD_SET_DEFAULT_FLOOD_SCOPE && len >= 1) {
|
|
if (len >= 1+31+16) {
|
|
const void* terminator = memchr(&cmd_frame[1], 0, 31);
|
|
size_t n = terminator == NULL ? 31 : (const uint8_t*)terminator - &cmd_frame[1];
|
|
if (n > 0 && n < 31) {
|
|
memcpy(_prefs.default_scope_name, &cmd_frame[1], n);
|
|
_prefs.default_scope_name[n] = 0;
|
|
memcpy(_prefs.default_scope_key, &cmd_frame[1+31], 16);
|
|
savePrefs();
|
|
writeOKFrame();
|
|
} else {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
}
|
|
} else {
|
|
memset(_prefs.default_scope_name, 0, sizeof(_prefs.default_scope_name)); // set default scope to null
|
|
memset(_prefs.default_scope_key, 0, sizeof(_prefs.default_scope_key));
|
|
savePrefs();
|
|
writeOKFrame();
|
|
}
|
|
} else if (cmd_frame[0] == CMD_GET_DEFAULT_FLOOD_SCOPE) {
|
|
out_frame[0] = RESP_CODE_DEFAULT_FLOOD_SCOPE;
|
|
if (strlen(_prefs.default_scope_name) > 0) {
|
|
memcpy(&out_frame[1], _prefs.default_scope_name, 31);
|
|
memcpy(&out_frame[1+31], _prefs.default_scope_key, 16);
|
|
_serial->writeFrame(out_frame, 1+31+16);
|
|
} else {
|
|
_serial->writeFrame(out_frame, 1); // no name or key means null
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SEND_CONTROL_DATA && len >= 2 && (cmd_frame[1] & 0x80) != 0) {
|
|
auto resp = createControlData(&cmd_frame[1], len - 1);
|
|
if (resp) {
|
|
sendZeroHop(resp);
|
|
writeOKFrame();
|
|
} else {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL);
|
|
}
|
|
} else if (cmd_frame[0] == CMD_SET_AUTOADD_CONFIG) {
|
|
if (len < 2) {
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
return;
|
|
}
|
|
_prefs.autoadd_config = cmd_frame[1];
|
|
if (len >= 3) {
|
|
_prefs.autoadd_max_hops = min(cmd_frame[2], (uint8_t)64);
|
|
}
|
|
savePrefs();
|
|
writeOKFrame();
|
|
} else if (cmd_frame[0] == CMD_GET_AUTOADD_CONFIG) {
|
|
int i = 0;
|
|
out_frame[i++] = RESP_CODE_AUTOADD_CONFIG;
|
|
out_frame[i++] = _prefs.autoadd_config;
|
|
out_frame[i++] = _prefs.autoadd_max_hops;
|
|
_serial->writeFrame(out_frame, i);
|
|
} else if (cmd_frame[0] == CMD_GET_ALLOWED_REPEAT_FREQ) {
|
|
int i = 0;
|
|
out_frame[i++] = RESP_ALLOWED_REPEAT_FREQ;
|
|
for (int k = 0; k < sizeof(repeat_freq_ranges)/sizeof(repeat_freq_ranges[0]) && i + 8 < sizeof(out_frame); k++) {
|
|
auto r = &repeat_freq_ranges[k];
|
|
memcpy(&out_frame[i], &r->lower_freq, 4); i += 4;
|
|
memcpy(&out_frame[i], &r->upper_freq, 4); i += 4;
|
|
}
|
|
_serial->writeFrame(out_frame, i);
|
|
} else if (cmd_frame[0] == CMD_SEND_RAW_PACKET && len >= 4) {
|
|
auto pkt = obtainNewPacket();
|
|
if (pkt) {
|
|
uint8_t priority = cmd_frame[1];
|
|
if (tryParsePacket(pkt, &cmd_frame[2], len - 2)) {
|
|
sendPacket(pkt, priority, 0);
|
|
writeOKFrame();
|
|
} else {
|
|
releasePacket(pkt);
|
|
writeErrFrame(ERR_CODE_ILLEGAL_ARG);
|
|
}
|
|
} else {
|
|
writeErrFrame(ERR_CODE_TABLE_FULL);
|
|
}
|
|
} else {
|
|
writeErrFrame(ERR_CODE_UNSUPPORTED_CMD);
|
|
MESH_DEBUG_PRINTLN("ERROR: unknown command: %02X", cmd_frame[0]);
|
|
}
|
|
}
|
|
|
|
static bool save_filter(const ContactInfo& c) {
|
|
return c.type != ADV_TYPE_NONE; // don't save the transient/anon entries
|
|
}
|
|
|
|
void MyMesh::onContactCacheFlushed() {
|
|
// Eviction already saved the pending mutations. Avoid writing them again
|
|
// when the old five-second lazy-save deadline arrives.
|
|
mesh::resetLazyPersistenceAfterSuccess(dirty_contacts_expiry, dirty_contacts_failures);
|
|
}
|
|
|
|
void MyMesh::saveContacts() {
|
|
const bool success = _store->saveContacts(this, save_filter);
|
|
if (!success) {
|
|
scheduleContactWriteRetry();
|
|
} else if (_store->hasPendingContactWrites()) {
|
|
dirty_contacts_failures = 0;
|
|
dirty_contacts_expiry = mesh::nonzeroLazyPersistenceDeadline(
|
|
futureMillis(CONTACT_PAGE_WRITE_GAP));
|
|
} else {
|
|
mesh::resetLazyPersistenceAfterSuccess(
|
|
dirty_contacts_expiry, dirty_contacts_failures);
|
|
}
|
|
}
|
|
|
|
void MyMesh::scheduleContactWriteRetry() {
|
|
const uint32_t retry_delay = mesh::recordLazyPersistenceSaveFailure(
|
|
dirty_contacts_failures, LAZY_CONTACTS_WRITE_DELAY,
|
|
mesh::LAZY_PERSISTENCE_MAX_RETRY_DELAY_MILLIS);
|
|
mesh::completeLazyPersistenceSave(
|
|
dirty_contacts_expiry, false, futureMillis(retry_delay));
|
|
MESH_DEBUG_PRINTLN("Contact persistence failed; retry in %lu ms",
|
|
(unsigned long)retry_delay);
|
|
}
|
|
|
|
bool MyMesh::isContactWriteDue() const {
|
|
// Read the clock once. Two separate reads can straddle the exact deadline
|
|
// and make both equality and the library's strict-after test return false.
|
|
const uint32_t now = _ms->getMillis();
|
|
return dirty_contacts_expiry != 0
|
|
&& (int32_t)(now - dirty_contacts_expiry) >= 0;
|
|
}
|
|
|
|
bool MyMesh::flushContactsBeforeReboot() {
|
|
// Non-nRF stores use the legacy monolithic file and therefore do not report
|
|
// dirty pages. The lazy-write deadline still proves that RAM may be newer.
|
|
if (!dirty_contacts_expiry && !_store->hasPendingContactWrites()) return true;
|
|
if (!_store->flushContactWrites(this, save_filter)) {
|
|
scheduleContactWriteRetry();
|
|
return false;
|
|
}
|
|
mesh::resetLazyPersistenceAfterSuccess(
|
|
dirty_contacts_expiry, dirty_contacts_failures);
|
|
return true;
|
|
}
|
|
|
|
bool MyMesh::prepareForOtaReboot() {
|
|
// Once a write has failed, honor its bounded retry deadline instead of
|
|
// letting the armed OTA apply hammer the same filesystem every loop.
|
|
if (dirty_contacts_failures != 0 && dirty_contacts_expiry != 0
|
|
&& !isContactWriteDue()) {
|
|
return false;
|
|
}
|
|
return flushContactsBeforeReboot();
|
|
}
|
|
|
|
bool MyMesh::prepareForUiShutdown() {
|
|
return flushContactsBeforeReboot();
|
|
}
|
|
|
|
bool MyMesh::scheduleContactWrite(const ContactInfo& contact) {
|
|
// Anonymous contacts live only in the reserved transient prefix and are
|
|
// deliberately excluded from contact storage. Never allocate a persistent
|
|
// slot for one when a path/message callback updates its runtime state.
|
|
if (contact.type == ADV_TYPE_NONE || isTransientContact(contact)) return true;
|
|
if (!_store->markContactDirty(contact)) {
|
|
MESH_DEBUG_PRINTLN(
|
|
"Contact persistence scheduling failed: no persistent slot");
|
|
return false;
|
|
}
|
|
mesh::scheduleLazyPersistenceMutation(
|
|
dirty_contacts_expiry, dirty_contacts_failures,
|
|
futureMillis(LAZY_CONTACTS_WRITE_DELAY));
|
|
return true;
|
|
}
|
|
|
|
bool MyMesh::scheduleContactWriteAfterRelease(const ContactInfo& contact,
|
|
uint16_t& released_slot) {
|
|
#if defined(NRF52_PLATFORM)
|
|
released_slot = contact.storage_slot;
|
|
#else
|
|
released_slot = mesh::storage::CONTACT_SLOT_NONE;
|
|
#endif
|
|
if (!_store->releaseContact(contact)) {
|
|
MESH_DEBUG_PRINTLN(
|
|
"Contact removal scheduling failed: persistent slot was not reserved");
|
|
return false;
|
|
}
|
|
mesh::scheduleLazyPersistenceMutation(
|
|
dirty_contacts_expiry, dirty_contacts_failures,
|
|
futureMillis(LAZY_CONTACTS_WRITE_DELAY));
|
|
return true;
|
|
}
|
|
|
|
bool MyMesh::restoreContactWriteAfterRelease(const ContactInfo& contact,
|
|
uint16_t released_slot) {
|
|
if (!_store->restoreContactSlot(contact, released_slot)) {
|
|
MESH_DEBUG_PRINTLN(
|
|
"Contact removal rollback failed: released slot was not restored");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#if defined(NRF52_PLATFORM) && defined(EXTRAFS) && !defined(QSPIFLASH)
|
|
void MyMesh::repairInternalExtraFS(Stream& output) {
|
|
// Always run the store-level operation. When the 100 KiB ExtraFS is already
|
|
// active this is a non-destructive retry of any incomplete migration, not a
|
|
// format. Do not overwrite it from RAM until every authoritative source file
|
|
// has been copied, verified, and retired from primary storage.
|
|
const bool authoritative_reload_required =
|
|
_store->hasIncompleteContactLoad();
|
|
if (!_store->repairInternalExtraFS()) {
|
|
output.println(" Error: internal ExtraFS repair/migration failed; retry repair extrafs");
|
|
return;
|
|
}
|
|
|
|
if (authoritative_reload_required) {
|
|
// This boot intentionally loaded no/partial contacts while secondary
|
|
// authority was unknown. The repair has made the filesystem available,
|
|
// but rebuilding it from that RAM image would destroy the data just
|
|
// recovered. Reboot and reload the verified store before permitting any
|
|
// normal persistence.
|
|
output.println(
|
|
" > internal ExtraFS repaired; rebooting to reload authoritative data");
|
|
_scheduled_reboot_at = futureMillis(1000);
|
|
return;
|
|
}
|
|
|
|
const bool contacts_saved = _store->saveContacts(this, save_filter);
|
|
const bool channels_saved = saveChannels();
|
|
const bool capacity_ready = _store->getStorageTotalKb() == 100;
|
|
if (contacts_saved && channels_saved && capacity_ready
|
|
&& !_store->hasPendingContactWrites()) {
|
|
mesh::resetLazyPersistenceAfterSuccess(
|
|
dirty_contacts_expiry, dirty_contacts_failures);
|
|
output.printf(" > internal ExtraFS repaired (%lu KiB); contacts and channels rebuilt\n",
|
|
(unsigned long)_store->getStorageTotalKb());
|
|
} else {
|
|
if (!contacts_saved || _store->hasPendingContactWrites()) {
|
|
scheduleContactWriteRetry();
|
|
} else {
|
|
mesh::resetLazyPersistenceAfterSuccess(
|
|
dirty_contacts_expiry, dirty_contacts_failures);
|
|
}
|
|
output.println(" Error: ExtraFS is active, but data rebuild/verification failed; retry repair extrafs");
|
|
}
|
|
}
|
|
|
|
#if defined(MESHCORE_EXTRAFS_HIL)
|
|
bool MyMesh::handleExtraFsHilCommand(const char* command, char* reply,
|
|
size_t reply_size) {
|
|
static const char* const fill_path = "/__hil.fill";
|
|
static const char* const contact_failure_marker = "/__hil.readfail";
|
|
static const uint8_t contact_stat_failure_flag = 0x80;
|
|
static const char* const prefix = "hil extrafs ";
|
|
if (strncmp(command, prefix, strlen(prefix)) != 0) return false;
|
|
|
|
FILESYSTEM* fs = _store->getSecondaryFS();
|
|
const char* action = command + strlen(prefix);
|
|
auto armContactPageFailure = [fs](uint8_t encoded_failure) -> int8_t {
|
|
if (fs == nullptr) return 0;
|
|
// Do not replace an unread/read-failure request with a stat-failure request
|
|
// (or vice versa). One marker allocation represents exactly one fault.
|
|
if (fs->exists(contact_failure_marker)) return -1;
|
|
|
|
File marker = fs->open(contact_failure_marker, FILE_O_WRITE);
|
|
const bool written = marker
|
|
&& marker.write(&encoded_failure, 1) == 1;
|
|
if (marker) {
|
|
marker.flush();
|
|
marker.close();
|
|
}
|
|
File verify = fs->open(contact_failure_marker, FILE_O_READ);
|
|
const bool durable = written && verify && verify.size() == 1
|
|
&& verify.read() == encoded_failure;
|
|
if (verify) verify.close();
|
|
if (!durable && fs->exists(contact_failure_marker)) {
|
|
fs->remove(contact_failure_marker);
|
|
}
|
|
return durable ? 1 : 0;
|
|
};
|
|
auto findHilContact = [this](const char* encoded,
|
|
size_t encoded_len) -> ContactInfo* {
|
|
// Seven bytes match the advert-cache key width and keep the direct-only
|
|
// HIL command below the Companion CLI frame limit.
|
|
if (encoded_len != 14) return nullptr;
|
|
char text[15];
|
|
memcpy(text, encoded, encoded_len);
|
|
text[encoded_len] = 0;
|
|
uint8_t key_prefix[7];
|
|
if (!mesh::Utils::fromHex(key_prefix, sizeof(key_prefix), text)) {
|
|
return nullptr;
|
|
}
|
|
return lookupPersistentContactByPubKey(
|
|
key_prefix, sizeof(key_prefix));
|
|
};
|
|
if (strcmp(action, "status") == 0) {
|
|
uint32_t fill_size = 0;
|
|
if (fs != nullptr) {
|
|
File fill = fs->open(fill_path, FILE_O_READ);
|
|
if (fill) {
|
|
fill_size = fill.size();
|
|
fill.close();
|
|
}
|
|
}
|
|
snprintf(reply, reply_size,
|
|
"HIL ExtraFS active=%u used=%luKiB total=%luKiB fill=%lu",
|
|
fs != nullptr ? 1U : 0U,
|
|
(unsigned long)_store->getStorageUsedKb(),
|
|
(unsigned long)_store->getStorageTotalKb(),
|
|
(unsigned long)fill_size);
|
|
return true;
|
|
}
|
|
|
|
if (strcmp(action, "clear") == 0) {
|
|
if (fs == nullptr) {
|
|
snprintf(reply, reply_size, "HIL ExtraFS unavailable");
|
|
} else if ((!fs->exists(fill_path) || fs->remove(fill_path))
|
|
&& !fs->exists(fill_path)) {
|
|
snprintf(reply, reply_size, "HIL ExtraFS filler cleared");
|
|
} else {
|
|
snprintf(reply, reply_size, "HIL ExtraFS filler clear failed");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static const char* const contact_slot_prefix = "contact-slot ";
|
|
if (strncmp(action, contact_slot_prefix,
|
|
strlen(contact_slot_prefix)) == 0) {
|
|
const char* encoded = action + strlen(contact_slot_prefix);
|
|
ContactInfo* contact = findHilContact(encoded, strlen(encoded));
|
|
if (contact == nullptr) {
|
|
snprintf(reply, reply_size,
|
|
"HIL usage: hil extrafs contact-slot <14 hex chars>");
|
|
} else {
|
|
snprintf(reply, reply_size, "HIL contact slot=%u",
|
|
(unsigned)contact->storage_slot);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static const char* const seed_advert_prefix = "seed-advert ";
|
|
if (strncmp(action, seed_advert_prefix,
|
|
strlen(seed_advert_prefix)) == 0) {
|
|
const char* encoded = action + strlen(seed_advert_prefix);
|
|
static const char* const confirm = " CONFIRM";
|
|
const size_t value_len = strlen(encoded);
|
|
const size_t confirm_len = strlen(confirm);
|
|
ContactInfo* contact = value_len == 14 + confirm_len
|
|
&& strcmp(encoded + 14, confirm) == 0
|
|
? findHilContact(encoded, 14) : nullptr;
|
|
if (contact == nullptr || fs == nullptr) {
|
|
snprintf(reply, reply_size,
|
|
"HIL usage: hil extrafs seed-advert <14 hex chars> CONFIRM");
|
|
return true;
|
|
}
|
|
|
|
uint8_t advert[PUB_KEY_SIZE + 4 + SIGNATURE_SIZE];
|
|
memset(advert, 0xA5, sizeof(advert));
|
|
memcpy(advert, contact->id.pub_key, PUB_KEY_SIZE);
|
|
uint8_t verify[MAX_PACKET_PAYLOAD];
|
|
const bool saved = _store->putBlobByKey(
|
|
contact->id.pub_key, PUB_KEY_SIZE, advert, sizeof(advert));
|
|
const uint8_t stored = saved ? _store->getBlobByKey(
|
|
contact->id.pub_key, PUB_KEY_SIZE, verify) : 0;
|
|
if (!saved || stored != sizeof(advert)
|
|
|| memcmp(advert, verify, sizeof(advert)) != 0) {
|
|
snprintf(reply, reply_size, "HIL advert seed failed");
|
|
} else {
|
|
snprintf(reply, reply_size, "HIL advert seeded slot=%u",
|
|
(unsigned)contact->storage_slot);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static const char* const clear_advert_prefix = "clear-advert ";
|
|
if (strncmp(action, clear_advert_prefix,
|
|
strlen(clear_advert_prefix)) == 0) {
|
|
const char* encoded = action + strlen(clear_advert_prefix);
|
|
static const char* const confirm = " CONFIRM";
|
|
const size_t value_len = strlen(encoded);
|
|
const size_t confirm_len = strlen(confirm);
|
|
ContactInfo* contact = value_len == 14 + confirm_len
|
|
&& strcmp(encoded + 14, confirm) == 0
|
|
? findHilContact(encoded, 14) : nullptr;
|
|
if (contact == nullptr || fs == nullptr) {
|
|
snprintf(reply, reply_size,
|
|
"HIL usage: hil extrafs clear-advert <14 hex chars> CONFIRM");
|
|
} else if (!_store->deleteBlobByKey(
|
|
contact->id.pub_key, PUB_KEY_SIZE)) {
|
|
snprintf(reply, reply_size, "HIL advert clear failed");
|
|
} else {
|
|
uint8_t verify[MAX_PACKET_PAYLOAD];
|
|
const uint8_t stored = _store->getBlobByKey(
|
|
contact->id.pub_key, PUB_KEY_SIZE, verify);
|
|
snprintf(reply, reply_size, stored == 0
|
|
? "HIL advert cleared" : "HIL advert clear verify failed");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static const char* const fail_stat_prefix = "fail-stat-page ";
|
|
if (strncmp(action, fail_stat_prefix, strlen(fail_stat_prefix)) == 0) {
|
|
const char* value = action + strlen(fail_stat_prefix);
|
|
char* end = nullptr;
|
|
const unsigned long page = strtoul(value, &end, 10);
|
|
char page_path[24];
|
|
snprintf(page_path, sizeof(page_path), "/contacts4_%02lu", page);
|
|
if (value == end || strcmp(end, " CONFIRM") != 0
|
|
|| page >= mesh::storage::CONTACT_PAGE_COUNT || fs == nullptr
|
|
|| !fs->exists(page_path) || _store->hasPendingContactWrites()
|
|
|| _store->hasIncompleteContactLoad()) {
|
|
snprintf(reply, reply_size,
|
|
"HIL usage: hil extrafs fail-stat-page <0..%u> CONFIRM",
|
|
(unsigned)(mesh::storage::CONTACT_PAGE_COUNT - 1));
|
|
return true;
|
|
}
|
|
const int8_t armed = armContactPageFailure(
|
|
contact_stat_failure_flag | static_cast<uint8_t>(page));
|
|
if (armed < 0) {
|
|
snprintf(reply, reply_size, "HIL contact failure already armed");
|
|
} else if (armed == 0) {
|
|
snprintf(reply, reply_size, "HIL stat-failure marker write failed");
|
|
} else {
|
|
snprintf(reply, reply_size,
|
|
"HIL contact page %lu stat failure armed", page);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static const char* const fail_read_prefix = "fail-read-page ";
|
|
if (strncmp(action, fail_read_prefix, strlen(fail_read_prefix)) == 0) {
|
|
const char* value = action + strlen(fail_read_prefix);
|
|
char* end = nullptr;
|
|
const unsigned long page = strtoul(value, &end, 10);
|
|
char page_path[24];
|
|
snprintf(page_path, sizeof(page_path), "/contacts4_%02lu", page);
|
|
if (value == end || strcmp(end, " CONFIRM") != 0
|
|
|| page >= mesh::storage::CONTACT_PAGE_COUNT || fs == nullptr
|
|
|| !fs->exists(page_path) || _store->hasPendingContactWrites()
|
|
|| _store->hasIncompleteContactLoad()) {
|
|
snprintf(reply, reply_size,
|
|
"HIL usage: hil extrafs fail-read-page <0..%u> CONFIRM",
|
|
(unsigned)(mesh::storage::CONTACT_PAGE_COUNT - 1));
|
|
return true;
|
|
}
|
|
const int8_t armed = armContactPageFailure(static_cast<uint8_t>(page));
|
|
if (armed < 0) {
|
|
snprintf(reply, reply_size, "HIL contact failure already armed");
|
|
} else if (armed == 0) {
|
|
snprintf(reply, reply_size, "HIL read-failure marker write failed");
|
|
} else {
|
|
snprintf(reply, reply_size,
|
|
"HIL contact page %lu read failure armed", page);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static const char* const fill_prefix = "fill ";
|
|
if (strncmp(action, fill_prefix, strlen(fill_prefix)) == 0) {
|
|
const char* value = action + strlen(fill_prefix);
|
|
char* end = nullptr;
|
|
const unsigned long requested = strtoul(value, &end, 10);
|
|
if (value == end || *end != 0 || requested > 128UL * 1024UL) {
|
|
snprintf(reply, reply_size,
|
|
"HIL usage: hil extrafs fill <0..131072>");
|
|
return true;
|
|
}
|
|
if (fs == nullptr) {
|
|
snprintf(reply, reply_size, "HIL ExtraFS unavailable");
|
|
return true;
|
|
}
|
|
if (fs->exists(fill_path) && !fs->remove(fill_path)) {
|
|
snprintf(reply, reply_size, "HIL ExtraFS old filler remove failed");
|
|
return true;
|
|
}
|
|
|
|
uint8_t chunk[128];
|
|
memset(chunk, 0xA5, sizeof(chunk));
|
|
uint32_t committed = 0;
|
|
while (committed < requested) {
|
|
// LittleFS can accept buffered writes which are all rolled back when the
|
|
// final sync runs out of blocks. Commit and read-verify each small extent
|
|
// so the filler represents durable pressure, not an optimistic write()
|
|
// count for a file which disappears on close.
|
|
File fill = fs->open(fill_path, FILE_O_WRITE);
|
|
if (!fill || fill.size() != committed || !fill.seek(committed)) {
|
|
if (fill) fill.close();
|
|
break;
|
|
}
|
|
|
|
const uint32_t extent_end = committed + 1024UL < requested
|
|
? committed + 1024UL : requested;
|
|
bool extent_written = true;
|
|
while (committed < extent_end) {
|
|
const size_t remaining = extent_end - committed;
|
|
const size_t count = remaining < sizeof(chunk) ? remaining : sizeof(chunk);
|
|
if (fill.write(chunk, count) != count) {
|
|
extent_written = false;
|
|
break;
|
|
}
|
|
committed += count;
|
|
}
|
|
fill.flush();
|
|
fill.close();
|
|
|
|
File verify = fs->open(fill_path, FILE_O_READ);
|
|
const uint32_t durable_size = verify ? verify.size() : 0;
|
|
if (verify) verify.close();
|
|
if (!extent_written || durable_size != committed) {
|
|
committed = durable_size;
|
|
break;
|
|
}
|
|
}
|
|
snprintf(reply, reply_size,
|
|
"HIL ExtraFS fill requested=%lu written=%lu used=%luKiB total=%luKiB",
|
|
requested, (unsigned long)committed,
|
|
(unsigned long)_store->getStorageUsedKb(),
|
|
(unsigned long)_store->getStorageTotalKb());
|
|
return true;
|
|
}
|
|
|
|
static const char* const corrupt_prefix = "corrupt-page ";
|
|
static const char* const page_mask_prefix = "page-mask ";
|
|
if (strncmp(action, page_mask_prefix, strlen(page_mask_prefix)) == 0) {
|
|
const char* value = action + strlen(page_mask_prefix);
|
|
char* end = nullptr;
|
|
const unsigned long page = strtoul(value, &end, 10);
|
|
if (value == end || *end != 0
|
|
|| page >= mesh::storage::CONTACT_PAGE_COUNT || fs == nullptr) {
|
|
snprintf(reply, reply_size,
|
|
"HIL usage: hil extrafs page-mask <0..%u>",
|
|
(unsigned)(mesh::storage::CONTACT_PAGE_COUNT - 1));
|
|
return true;
|
|
}
|
|
|
|
char path[24];
|
|
snprintf(path, sizeof(path), "/contacts4_%02lu", page);
|
|
File page_file = fs->open(path, FILE_O_READ);
|
|
uint8_t raw_header[mesh::storage::CONTACT_PAGE_HEADER_SIZE];
|
|
mesh::storage::ContactPageHeader header = {};
|
|
const bool valid = page_file
|
|
&& page_file.read(raw_header, sizeof(raw_header)) == sizeof(raw_header)
|
|
&& mesh::storage::decodeContactPageHeader(
|
|
raw_header, static_cast<uint8_t>(page), header);
|
|
if (page_file) page_file.close();
|
|
if (!valid) {
|
|
snprintf(reply, reply_size, "HIL contact page unavailable");
|
|
} else {
|
|
snprintf(reply, reply_size,
|
|
"HIL contact page %lu occupied=%08lx", page,
|
|
(unsigned long)header.occupied);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static const char* const corrupt_occupied_prefix = "corrupt-occupied ";
|
|
if (strncmp(action, corrupt_occupied_prefix,
|
|
strlen(corrupt_occupied_prefix)) == 0) {
|
|
const char* value = action + strlen(corrupt_occupied_prefix);
|
|
char* page_end = nullptr;
|
|
const unsigned long page = strtoul(value, &page_end, 10);
|
|
const char* slot_value = page_end;
|
|
while (*slot_value == ' ') slot_value++;
|
|
char* slot_end = nullptr;
|
|
const unsigned long slot = strtoul(slot_value, &slot_end, 10);
|
|
if (value == page_end || slot_value == slot_end
|
|
|| strcmp(slot_end, " CONFIRM") != 0
|
|
|| page >= mesh::storage::CONTACT_PAGE_COUNT || slot >= 32
|
|
|| fs == nullptr || _store->hasPendingContactWrites()
|
|
|| _store->hasIncompleteContactLoad()) {
|
|
snprintf(reply, reply_size,
|
|
"HIL usage: hil extrafs corrupt-occupied <page> <bit 0..31> CONFIRM");
|
|
return true;
|
|
}
|
|
|
|
char path[24];
|
|
snprintf(path, sizeof(path), "/contacts4_%02lu", page);
|
|
const uint32_t byte_offset = 8 + slot / 8;
|
|
File original = fs->open(path, FILE_O_READ);
|
|
if (!original || !original.seek(byte_offset)) {
|
|
if (original) original.close();
|
|
snprintf(reply, reply_size, "HIL contact page unavailable");
|
|
return true;
|
|
}
|
|
const int prior = original.read();
|
|
original.close();
|
|
if (prior < 0) {
|
|
snprintf(reply, reply_size, "HIL contact page read failed");
|
|
return true;
|
|
}
|
|
|
|
const uint8_t changed = static_cast<uint8_t>(prior)
|
|
^ static_cast<uint8_t>(1U << (slot % 8));
|
|
File update = fs->open(path, FILE_O_WRITE);
|
|
if (!update || !update.seek(byte_offset)
|
|
|| update.write(&changed, 1) != 1) {
|
|
if (update) update.close();
|
|
snprintf(reply, reply_size, "HIL contact occupancy corrupt failed");
|
|
return true;
|
|
}
|
|
update.flush();
|
|
update.close();
|
|
|
|
File verify = fs->open(path, FILE_O_READ);
|
|
const bool changed_on_flash = verify && verify.seek(byte_offset)
|
|
&& verify.read() == changed;
|
|
if (verify) verify.close();
|
|
snprintf(reply, reply_size, changed_on_flash
|
|
? "HIL contact page %lu occupancy bit %lu corrupted"
|
|
: "HIL contact occupancy corrupt verify failed", page, slot);
|
|
return true;
|
|
}
|
|
|
|
if (strncmp(action, corrupt_prefix, strlen(corrupt_prefix)) == 0) {
|
|
const char* value = action + strlen(corrupt_prefix);
|
|
char* end = nullptr;
|
|
const unsigned long page = strtoul(value, &end, 10);
|
|
if (value == end || strcmp(end, " CONFIRM") != 0
|
|
|| page >= mesh::storage::CONTACT_PAGE_COUNT) {
|
|
snprintf(reply, reply_size,
|
|
"HIL usage: hil extrafs corrupt-page <0..%u> CONFIRM",
|
|
(unsigned)(mesh::storage::CONTACT_PAGE_COUNT - 1));
|
|
return true;
|
|
}
|
|
if (fs == nullptr || _store->hasPendingContactWrites()
|
|
|| _store->hasIncompleteContactLoad()) {
|
|
snprintf(reply, reply_size, "HIL ExtraFS unavailable or contacts pending");
|
|
return true;
|
|
}
|
|
|
|
char path[24];
|
|
snprintf(path, sizeof(path), "/contacts4_%02lu", page);
|
|
File original = fs->open(path, FILE_O_READ);
|
|
if (!original || original.size() != mesh::storage::CONTACT_PAGE_FILE_SIZE
|
|
|| !original.seek(mesh::storage::CONTACT_PAGE_HEADER_SIZE)) {
|
|
if (original) original.close();
|
|
snprintf(reply, reply_size, "HIL contact page unavailable");
|
|
return true;
|
|
}
|
|
const int prior = original.read();
|
|
original.close();
|
|
if (prior < 0) {
|
|
snprintf(reply, reply_size, "HIL contact page read failed");
|
|
return true;
|
|
}
|
|
|
|
const uint8_t changed = static_cast<uint8_t>(prior) ^ 0xA5U;
|
|
File update = fs->open(path, FILE_O_WRITE);
|
|
if (!update || !update.seek(mesh::storage::CONTACT_PAGE_HEADER_SIZE)
|
|
|| update.write(&changed, 1) != 1) {
|
|
if (update) update.close();
|
|
snprintf(reply, reply_size, "HIL contact page corrupt failed");
|
|
return true;
|
|
}
|
|
update.flush();
|
|
update.close();
|
|
|
|
File verify = fs->open(path, FILE_O_READ);
|
|
const bool changed_on_flash = verify
|
|
&& verify.seek(mesh::storage::CONTACT_PAGE_HEADER_SIZE)
|
|
&& verify.read() == changed;
|
|
if (verify) verify.close();
|
|
snprintf(reply, reply_size, changed_on_flash
|
|
? "HIL contact page %lu CRC corrupted"
|
|
: "HIL contact page corrupt verify failed", page);
|
|
return true;
|
|
}
|
|
|
|
if (strcmp(action, "unsafe-reset CONFIRM") == 0) {
|
|
// Intentionally bypass all persistence hooks so HIL can prove that a
|
|
// mutation was already committed before an event-driven sleep.
|
|
NVIC_SystemReset();
|
|
while (true) {}
|
|
}
|
|
|
|
snprintf(reply, reply_size,
|
|
"HIL usage: hil extrafs <status|fill N|clear|contact-slot K|seed-advert K CONFIRM|clear-advert K CONFIRM|fail-read-page N CONFIRM|page-mask N|corrupt-occupied N B CONFIRM|corrupt-page N CONFIRM|unsafe-reset CONFIRM>");
|
|
return true;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
bool MyMesh::applyAndSaveFemRxGain(bool enabled) {
|
|
if (!board.canControlLoRaFemLna()) return false;
|
|
|
|
const bool previous_hardware = board.isLoRaFemLnaEnabled();
|
|
const uint8_t previous_pref = _prefs.radio_fem_rxgain;
|
|
const uint8_t previous_override = _prefs.radio_fem_rxgain_override;
|
|
const bool changed = previous_hardware != enabled;
|
|
if (!board.setLoRaFemLnaEnabled(enabled)) return false;
|
|
|
|
if (changed && _radio_available) _radio->recalibrateNoiseFloor();
|
|
_prefs.radio_fem_rxgain = enabled ? 1 : 0;
|
|
_prefs.radio_fem_rxgain_override = 1;
|
|
if (!savePrefs()) {
|
|
_prefs.radio_fem_rxgain = previous_pref;
|
|
_prefs.radio_fem_rxgain_override = previous_override;
|
|
board.setLoRaFemLnaEnabled(previous_hardware);
|
|
if (changed && _radio_available) _radio->recalibrateNoiseFloor();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool MyMesh::applyAndSaveFemTxGain(bool enabled) {
|
|
if (!board.canControlLoRaFemPaGain()) return false;
|
|
const bool previous_hardware = board.isLoRaFemPaGainEnabled();
|
|
const uint8_t previous_pref = _prefs.radio_fem_txgain;
|
|
if (!board.setLoRaFemPaGainEnabled(enabled)) return false;
|
|
|
|
_prefs.radio_fem_txgain = enabled ? 1 : 0;
|
|
if (!savePrefs()) {
|
|
_prefs.radio_fem_txgain = previous_pref;
|
|
board.setLoRaFemPaGainEnabled(previous_hardware);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool MyMesh::applyAndSaveRxBoostedGain(bool enabled) {
|
|
if (!radio_driver.supportsRxBoostedGainMode()
|
|
|| (_radio_available && !radio_driver.setRxBoostedGainMode(enabled))) {
|
|
return false;
|
|
}
|
|
|
|
const uint8_t previous_pref = _prefs.rx_boosted_gain;
|
|
_prefs.rx_boosted_gain = enabled ? 1 : 0;
|
|
if (!savePrefs()) {
|
|
_prefs.rx_boosted_gain = previous_pref;
|
|
if (_radio_available) {
|
|
radio_driver.setRxBoostedGainMode(previous_pref != 0);
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool MyMesh::saveBluetoothNameOverride(const char* name) {
|
|
if (name == NULL) return false;
|
|
|
|
char previous[sizeof(_prefs.bluetooth_name)];
|
|
memcpy(previous, _prefs.bluetooth_name, sizeof(previous));
|
|
memset(_prefs.bluetooth_name, 0, sizeof(_prefs.bluetooth_name));
|
|
if (name[0] != 0) {
|
|
StrHelper::strncpy(_prefs.bluetooth_name, name,
|
|
sizeof(_prefs.bluetooth_name));
|
|
}
|
|
|
|
if (savePrefs()) return true;
|
|
memcpy(_prefs.bluetooth_name, previous, sizeof(_prefs.bluetooth_name));
|
|
return false;
|
|
}
|
|
|
|
bool MyMesh::applyAndSaveBluetoothName(const char* value, char* reply,
|
|
size_t reply_size) {
|
|
if (reply == NULL || reply_size == 0) return false;
|
|
|
|
const bool use_default = value == NULL || value[0] == 0;
|
|
if (!use_default && !mesh::companion::isValidBluetoothName(value)) {
|
|
snprintf(reply, reply_size,
|
|
"Error: Bluetooth name must be 1-%u valid UTF-8 bytes without control characters",
|
|
(unsigned)mesh::companion::BLUETOOTH_NAME_MAX_BYTES);
|
|
return false;
|
|
}
|
|
|
|
if (!saveBluetoothNameOverride(use_default ? "" : value)) {
|
|
snprintf(reply, reply_size, "Error: Bluetooth name save failed");
|
|
return false;
|
|
}
|
|
|
|
if (use_default) {
|
|
snprintf(reply, reply_size,
|
|
"OK - Bluetooth name follows %s<node name>; reboot required",
|
|
BLE_NAME_PREFIX);
|
|
} else {
|
|
snprintf(reply, reply_size,
|
|
"OK - Bluetooth name saved as '%s'; reboot required", value);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void MyMesh::formatBluetoothNameStatus(char* reply, size_t reply_size) const {
|
|
if (reply == NULL || reply_size == 0) return;
|
|
|
|
char effective_name[64];
|
|
mesh::companion::formatBluetoothName(
|
|
effective_name, sizeof(effective_name), _prefs.bluetooth_name,
|
|
BLE_NAME_PREFIX, _prefs.node_name);
|
|
snprintf(reply, reply_size, "> %s (%s)", effective_name,
|
|
mesh::companion::hasCustomBluetoothName(_prefs.bluetooth_name)
|
|
? "custom" : "default from node name");
|
|
}
|
|
|
|
#if defined(BLE_PIN_CODE)
|
|
bool MyMesh::prepareBluetoothMacForBoot(bool& address_rotated) {
|
|
address_rotated = false;
|
|
if (_prefs.bluetooth_mac_mode
|
|
== mesh::companion::BLUETOOTH_MAC_RANDOM_EVERY_BOOT) {
|
|
// This policy deliberately invalidates the previous local BLE identity.
|
|
// Reopen first pairing before advertising rather than hiding behind a
|
|
// bond created for that old address. Address generation remains once per
|
|
// boot in main.cpp, including initialization retries.
|
|
if (!resetBluetoothStealthPairing()) return false;
|
|
address_rotated = true;
|
|
return true;
|
|
}
|
|
const bool rotate_after_connection =
|
|
mesh::companion::bluetoothMacShouldRotateAtBoot(
|
|
_prefs.bluetooth_mac_mode, _prefs.bluetooth_mac);
|
|
if (!rotate_after_connection) return true;
|
|
|
|
uint8_t address[mesh::companion::BLUETOOTH_MAC_BYTES];
|
|
getRNG()->random(address, sizeof(address));
|
|
mesh::companion::makeRandomStaticBluetoothMacDifferentFrom(
|
|
address, _prefs.bluetooth_mac);
|
|
address_rotated = saveBluetoothMac(
|
|
mesh::companion::BLUETOOTH_MAC_RANDOM_AFTER_CONNECT, address);
|
|
return address_rotated;
|
|
}
|
|
|
|
bool MyMesh::armBluetoothMacRotationAfterConnection() {
|
|
if (_prefs.bluetooth_mac_mode
|
|
== mesh::companion::BLUETOOTH_MAC_RANDOM_AFTER_CONNECT_ARMED) {
|
|
return true;
|
|
}
|
|
if (_prefs.bluetooth_mac_mode
|
|
!= mesh::companion::BLUETOOTH_MAC_RANDOM_AFTER_CONNECT) {
|
|
return true;
|
|
}
|
|
|
|
_prefs.bluetooth_mac_mode =
|
|
mesh::companion::BLUETOOTH_MAC_RANDOM_AFTER_CONNECT_ARMED;
|
|
if (savePrefs()) return true;
|
|
|
|
_prefs.bluetooth_mac_mode =
|
|
mesh::companion::BLUETOOTH_MAC_RANDOM_AFTER_CONNECT;
|
|
return false;
|
|
}
|
|
|
|
bool MyMesh::saveBluetoothStealthPeer(
|
|
const mesh::companion::BluetoothPeerIdentity& peer) {
|
|
if (!mesh::companion::isValidBluetoothPeerIdentity(peer)) return false;
|
|
if (_prefs.bluetooth_stealth_mode
|
|
== mesh::companion::BLUETOOTH_STEALTH_PAIRED
|
|
&& _prefs.bluetooth_stealth_peer_type == peer.type
|
|
&& memcmp(_prefs.bluetooth_stealth_peer, peer.address,
|
|
sizeof(_prefs.bluetooth_stealth_peer)) == 0) {
|
|
return true;
|
|
}
|
|
if (_prefs.bluetooth_stealth_mode
|
|
!= mesh::companion::BLUETOOTH_STEALTH_PAIRING) {
|
|
return false;
|
|
}
|
|
|
|
const uint8_t previous_mode = _prefs.bluetooth_mac_mode;
|
|
const uint8_t previous_type = _prefs.bluetooth_stealth_peer_type;
|
|
uint8_t previous_peer[mesh::companion::BLUETOOTH_MAC_BYTES];
|
|
memcpy(previous_peer, _prefs.bluetooth_stealth_peer,
|
|
sizeof(previous_peer));
|
|
|
|
_prefs.bluetooth_stealth_mode = mesh::companion::BLUETOOTH_STEALTH_PAIRED;
|
|
// One durable write records both consequences of a successful pairing.
|
|
// Stealth must not prevent random-after-connect from arming for next boot.
|
|
if (mesh::companion::bluetoothMacModeIsRandomAfterConnect(
|
|
_prefs.bluetooth_mac_mode)) {
|
|
_prefs.bluetooth_mac_mode =
|
|
mesh::companion::BLUETOOTH_MAC_RANDOM_AFTER_CONNECT_ARMED;
|
|
}
|
|
_prefs.bluetooth_stealth_peer_type = peer.type;
|
|
memcpy(_prefs.bluetooth_stealth_peer, peer.address,
|
|
sizeof(_prefs.bluetooth_stealth_peer));
|
|
if (savePrefs()) return true;
|
|
|
|
_prefs.bluetooth_mac_mode = previous_mode;
|
|
_prefs.bluetooth_stealth_mode = mesh::companion::BLUETOOTH_STEALTH_PAIRING;
|
|
_prefs.bluetooth_stealth_peer_type = previous_type;
|
|
memcpy(_prefs.bluetooth_stealth_peer, previous_peer,
|
|
sizeof(_prefs.bluetooth_stealth_peer));
|
|
return false;
|
|
}
|
|
|
|
bool MyMesh::resetBluetoothStealthPairing() {
|
|
if (_prefs.bluetooth_stealth_mode !=
|
|
mesh::companion::BLUETOOTH_STEALTH_PAIRED) {
|
|
return true;
|
|
}
|
|
|
|
const uint8_t previous_type = _prefs.bluetooth_stealth_peer_type;
|
|
uint8_t previous_peer[mesh::companion::BLUETOOTH_MAC_BYTES];
|
|
memcpy(previous_peer, _prefs.bluetooth_stealth_peer,
|
|
sizeof(previous_peer));
|
|
|
|
clearCompanionBluetoothStealthPeer(_prefs);
|
|
if (savePrefs()) return true;
|
|
|
|
_prefs.bluetooth_stealth_mode = mesh::companion::BLUETOOTH_STEALTH_PAIRED;
|
|
_prefs.bluetooth_stealth_peer_type = previous_type;
|
|
memcpy(_prefs.bluetooth_stealth_peer, previous_peer,
|
|
sizeof(_prefs.bluetooth_stealth_peer));
|
|
return false;
|
|
}
|
|
|
|
bool MyMesh::saveBluetoothMac(uint8_t mode, const uint8_t* address) {
|
|
if (!mesh::companion::isValidBluetoothMacMode(mode)) return false;
|
|
if (mesh::companion::bluetoothMacModeUsesSavedAddress(mode)
|
|
&& !mesh::companion::isValidBluetoothMac(address)) {
|
|
return false;
|
|
}
|
|
|
|
if (_prefs.bluetooth_mac_mode == mode
|
|
&& (!mesh::companion::bluetoothMacModeUsesSavedAddress(mode)
|
|
|| memcmp(_prefs.bluetooth_mac, address,
|
|
sizeof(_prefs.bluetooth_mac)) == 0)) {
|
|
return true;
|
|
}
|
|
|
|
const uint8_t previous_mode = _prefs.bluetooth_mac_mode;
|
|
const uint8_t previous_stealth_mode = _prefs.bluetooth_stealth_mode;
|
|
uint8_t previous_address[mesh::companion::BLUETOOTH_MAC_BYTES];
|
|
const uint8_t previous_peer_type = _prefs.bluetooth_stealth_peer_type;
|
|
uint8_t previous_peer[mesh::companion::BLUETOOTH_MAC_BYTES];
|
|
memcpy(previous_address, _prefs.bluetooth_mac, sizeof(previous_address));
|
|
memcpy(previous_peer, _prefs.bluetooth_stealth_peer,
|
|
sizeof(previous_peer));
|
|
|
|
_prefs.bluetooth_mac_mode = mode;
|
|
memset(_prefs.bluetooth_mac, 0, sizeof(_prefs.bluetooth_mac));
|
|
if (mesh::companion::bluetoothMacModeUsesSavedAddress(mode)) {
|
|
memcpy(_prefs.bluetooth_mac, address, sizeof(_prefs.bluetooth_mac));
|
|
}
|
|
clearCompanionBluetoothStealthPeer(_prefs);
|
|
|
|
if (savePrefs()) return true;
|
|
_prefs.bluetooth_mac_mode = previous_mode;
|
|
_prefs.bluetooth_stealth_mode = previous_stealth_mode;
|
|
memcpy(_prefs.bluetooth_mac, previous_address, sizeof(_prefs.bluetooth_mac));
|
|
_prefs.bluetooth_stealth_peer_type = previous_peer_type;
|
|
memcpy(_prefs.bluetooth_stealth_peer, previous_peer,
|
|
sizeof(_prefs.bluetooth_stealth_peer));
|
|
return false;
|
|
}
|
|
|
|
bool MyMesh::applyAndSaveBluetoothMac(const char* value, char* reply,
|
|
size_t reply_size) {
|
|
if (reply == NULL || reply_size == 0) return false;
|
|
if (value == NULL) {
|
|
snprintf(reply, reply_size,
|
|
"Error: use set bluetooth.mac <address|random|random-every-boot|random-after-connect|default>");
|
|
return false;
|
|
}
|
|
|
|
uint8_t mode = mesh::companion::BLUETOOTH_MAC_DEFAULT;
|
|
uint8_t address[mesh::companion::BLUETOOTH_MAC_BYTES] = {};
|
|
if (value[0] == 0 || strcmp(value, "default") == 0
|
|
|| strcmp(value, "clear") == 0) {
|
|
mode = mesh::companion::BLUETOOTH_MAC_DEFAULT;
|
|
} else if (strcmp(value, "random") == 0) {
|
|
mode = mesh::companion::BLUETOOTH_MAC_RANDOM_SAVED;
|
|
getRNG()->random(address, sizeof(address));
|
|
mesh::companion::makeRandomStaticBluetoothMac(address);
|
|
} else if (strcmp(value, "random-every-boot") == 0
|
|
|| strcmp(value, "random-everyboot") == 0
|
|
|| strcmp(value, "random_every_boot") == 0
|
|
|| strcmp(value, "random everyboot") == 0
|
|
|| strcmp(value, "random every boot") == 0
|
|
|| strcmp(value, "everyboot") == 0) {
|
|
mode = mesh::companion::BLUETOOTH_MAC_RANDOM_EVERY_BOOT;
|
|
} else if (strcmp(value, "random-after-connect") == 0
|
|
|| strcmp(value, "random-after-connection") == 0
|
|
|| strcmp(value, "random after connect") == 0
|
|
|| strcmp(value, "random after connection") == 0
|
|
|| strcmp(value, "random-on-reboot-after-connect") == 0) {
|
|
mode = mesh::companion::BLUETOOTH_MAC_RANDOM_AFTER_CONNECT;
|
|
getRNG()->random(address, sizeof(address));
|
|
mesh::companion::makeRandomStaticBluetoothMac(address);
|
|
} else {
|
|
const char* custom_value = value;
|
|
if (strncmp(custom_value, "custom", 6) == 0
|
|
&& (custom_value[6] == ' ' || custom_value[6] == '\t')) {
|
|
custom_value += 7;
|
|
while (*custom_value == ' ' || *custom_value == '\t') custom_value++;
|
|
}
|
|
if (!mesh::companion::parseBluetoothMac(custom_value, address)) {
|
|
snprintf(reply, reply_size,
|
|
"Error: use a random-static address (first byte C0-FF), random, random-every-boot, random-after-connect, or default");
|
|
return false;
|
|
}
|
|
mode = mesh::companion::BLUETOOTH_MAC_CUSTOM;
|
|
}
|
|
|
|
if (!saveBluetoothMac(mode, address)) {
|
|
snprintf(reply, reply_size, "Error: Bluetooth MAC save failed");
|
|
return false;
|
|
}
|
|
|
|
char formatted[mesh::companion::BLUETOOTH_MAC_TEXT_SIZE];
|
|
if (mode == mesh::companion::BLUETOOTH_MAC_DEFAULT) {
|
|
snprintf(reply, reply_size,
|
|
"OK - factory Bluetooth address restored; reboot and re-pair");
|
|
} else if (mode == mesh::companion::BLUETOOTH_MAC_RANDOM_EVERY_BOOT) {
|
|
snprintf(reply, reply_size,
|
|
"OK - Bluetooth address will randomize every boot; reboot and pair each time");
|
|
} else if (mesh::companion::bluetoothMacModeIsRandomAfterConnect(mode)) {
|
|
mesh::companion::formatBluetoothMac(address, formatted,
|
|
sizeof(formatted));
|
|
snprintf(reply, reply_size,
|
|
"OK - Bluetooth address saved as %s; it will rotate on the first boot after a connection",
|
|
formatted);
|
|
} else {
|
|
mesh::companion::formatBluetoothMac(address, formatted,
|
|
sizeof(formatted));
|
|
snprintf(reply, reply_size,
|
|
"OK - Bluetooth address saved as %s; reboot and re-pair",
|
|
formatted);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void MyMesh::formatBluetoothMacStatus(char* reply, size_t reply_size) const {
|
|
if (reply == NULL || reply_size == 0) return;
|
|
|
|
const uint8_t mode = _prefs.bluetooth_mac_mode;
|
|
if (!mesh::companion::isValidBluetoothMacMode(mode)) {
|
|
snprintf(reply, reply_size,
|
|
"> factory address (invalid saved mode ignored)");
|
|
} else if (mode == mesh::companion::BLUETOOTH_MAC_DEFAULT) {
|
|
snprintf(reply, reply_size, "> factory address (default)");
|
|
} else if (mode == mesh::companion::BLUETOOTH_MAC_RANDOM_EVERY_BOOT) {
|
|
snprintf(reply, reply_size, "> random-every-boot (pair after each reboot)");
|
|
} else if (!mesh::companion::isValidBluetoothMac(
|
|
_prefs.bluetooth_mac)) {
|
|
snprintf(reply, reply_size,
|
|
"> factory address (invalid saved address ignored)");
|
|
} else if (mesh::companion::bluetoothMacModeIsRandomAfterConnect(mode)) {
|
|
char formatted[mesh::companion::BLUETOOTH_MAC_TEXT_SIZE];
|
|
mesh::companion::formatBluetoothMac(
|
|
_prefs.bluetooth_mac, formatted, sizeof(formatted));
|
|
snprintf(
|
|
reply, reply_size, "> %s (random-after-connect; %s)", formatted,
|
|
mode == mesh::companion::BLUETOOTH_MAC_RANDOM_AFTER_CONNECT_ARMED
|
|
? "rotation armed for next boot"
|
|
: "retained until a successful connection");
|
|
} else {
|
|
char formatted[mesh::companion::BLUETOOTH_MAC_TEXT_SIZE];
|
|
mesh::companion::formatBluetoothMac(
|
|
_prefs.bluetooth_mac, formatted, sizeof(formatted));
|
|
snprintf(reply, reply_size, "> %s (%s)", formatted,
|
|
mode == mesh::companion::BLUETOOTH_MAC_CUSTOM
|
|
? "custom" : "saved random");
|
|
}
|
|
}
|
|
|
|
bool MyMesh::applyAndSaveBluetoothStealth(const char* value, char* reply,
|
|
size_t reply_size) {
|
|
if (reply == NULL || reply_size == 0) return false;
|
|
if (value == NULL
|
|
|| (strcmp(value, "on") != 0 && strcmp(value, "off") != 0)) {
|
|
snprintf(reply, reply_size,
|
|
"Error: use set bluetooth.stealth on|off");
|
|
return false;
|
|
}
|
|
|
|
const uint8_t previous_mode = _prefs.bluetooth_stealth_mode;
|
|
const uint8_t previous_type = _prefs.bluetooth_stealth_peer_type;
|
|
uint8_t previous_peer[mesh::companion::BLUETOOTH_MAC_BYTES];
|
|
memcpy(previous_peer, _prefs.bluetooth_stealth_peer, sizeof(previous_peer));
|
|
if (setCompanionBluetoothStealth(_prefs, strcmp(value, "on") == 0)
|
|
&& !savePrefs()) {
|
|
_prefs.bluetooth_stealth_mode = previous_mode;
|
|
_prefs.bluetooth_stealth_peer_type = previous_type;
|
|
memcpy(_prefs.bluetooth_stealth_peer, previous_peer, sizeof(previous_peer));
|
|
snprintf(reply, reply_size, "Error: Bluetooth stealth save failed");
|
|
return false;
|
|
}
|
|
|
|
snprintf(reply, reply_size,
|
|
"OK - Bluetooth stealth %s saved; MAC policy unchanged; reboot to apply",
|
|
value);
|
|
return true;
|
|
}
|
|
|
|
void MyMesh::formatBluetoothStealthStatus(char* reply, size_t reply_size) const {
|
|
if (reply == NULL || reply_size == 0) return;
|
|
if (!mesh::companion::bluetoothStealthEnabled(_prefs.bluetooth_stealth_mode)) {
|
|
snprintf(reply, reply_size, "> off");
|
|
} else {
|
|
snprintf(reply, reply_size, "> on (%s)",
|
|
_prefs.bluetooth_stealth_mode == mesh::companion::BLUETOOTH_STEALTH_PAIRED
|
|
? "bonded-peer-only advertising"
|
|
: "discoverable until first authenticated pairing");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if defined(MESH_PRIMARY_ESPNOW) && MESH_PRIMARY_ESPNOW
|
|
void MyMesh::formatEspNowChannel(char* reply, size_t reply_size) const {
|
|
if (reply == NULL || reply_size == 0) return;
|
|
const uint8_t saved = mesh::wifi::loadConfiguredEspNowChannel();
|
|
const uint8_t active = mesh::wifi::activeEspNowChannel();
|
|
if (saved == active) {
|
|
snprintf(reply, reply_size, "> %u (saved and active)",
|
|
(unsigned)saved);
|
|
} else {
|
|
snprintf(reply, reply_size,
|
|
"> saved %u, active %u; reboot required",
|
|
(unsigned)saved, (unsigned)active);
|
|
}
|
|
}
|
|
|
|
bool MyMesh::applyAndSaveEspNowChannel(const char* value, char* reply,
|
|
size_t reply_size) {
|
|
if (reply == NULL || reply_size == 0) return false;
|
|
uint8_t channel = 0;
|
|
if (!mesh::wifi::parseEspNowChannel(value, channel)) {
|
|
snprintf(reply, reply_size, "Error: ESP-NOW channel must be 1-13");
|
|
return false;
|
|
}
|
|
// Snapshot the boot channel before writing NVS so even a CLI-only image
|
|
// cannot reinterpret the newly-saved setting as active in this boot.
|
|
const uint8_t active = mesh::wifi::activeEspNowChannel();
|
|
if (!mesh::wifi::saveConfiguredEspNowChannel(channel)) {
|
|
snprintf(reply, reply_size, "Error: failed to save ESP-NOW channel");
|
|
return false;
|
|
}
|
|
|
|
if (channel == active) {
|
|
snprintf(reply, reply_size,
|
|
"OK - ESP-NOW channel %u saved and active",
|
|
(unsigned)channel);
|
|
} else {
|
|
snprintf(reply, reply_size,
|
|
"OK - ESP-NOW channel %u saved; active %u; reboot required",
|
|
(unsigned)channel, (unsigned)active);
|
|
}
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
bool MyMesh::applyAndSavePowerSaving(const char* value, char* reply) {
|
|
bool enabled;
|
|
if (strcmp(value, "on") == 0) {
|
|
enabled = true;
|
|
} else if (strcmp(value, "off") == 0) {
|
|
enabled = false;
|
|
} else {
|
|
strcpy(reply, "Error: use powersaving on or powersaving off");
|
|
return false;
|
|
}
|
|
|
|
_prefs.powersaving_enabled = enabled ? 1 : 0;
|
|
sensors.setPowerSavingEnabled(enabled);
|
|
savePrefs();
|
|
snprintf(reply, 160, "OK - powersaving %s", enabled ? "on" : "off");
|
|
return true;
|
|
}
|
|
|
|
#if defined(ESP32) && defined(WIFI_SSID)
|
|
void MyMesh::syncWiFiPowerSaving() {
|
|
const uint8_t mode = getCompanionWiFiPowerSave();
|
|
#ifdef WITH_MQTT_BRIDGE
|
|
_mqtt_prefs.wifi_power_save = mode;
|
|
#endif
|
|
#ifdef WITH_WEBCONFIG
|
|
if (_webconfig) _webconfig->reloadStandaloneWiFi();
|
|
#endif
|
|
}
|
|
|
|
void MyMesh::formatWiFiPowerSaving(char* reply, size_t reply_size) const {
|
|
if (!reply || reply_size == 0) return;
|
|
snprintf(reply, reply_size, "> %s", getCompanionWiFiPowerSaveName());
|
|
}
|
|
|
|
bool MyMesh::applyAndSaveWiFiPowerSaving(const char* value, char* reply,
|
|
size_t reply_size) {
|
|
if (!reply || reply_size == 0) return false;
|
|
uint8_t mode = mesh::wifi::kDefaultPowerSave;
|
|
if (value && strcmp(value, "min") == 0) {
|
|
mode = mesh::wifi::kPowerSaveMin;
|
|
} else if (value && strcmp(value, "none") == 0) {
|
|
mode = mesh::wifi::kPowerSaveNone;
|
|
} else if (value && strcmp(value, "max") == 0) {
|
|
mode = mesh::wifi::kPowerSaveMax;
|
|
} else {
|
|
snprintf(reply, reply_size,
|
|
"Error: power save must be none, min, or max");
|
|
return false;
|
|
}
|
|
|
|
const CompanionWiFiPowerSaveResult result =
|
|
setCompanionWiFiPowerSave(mode);
|
|
if (result == CompanionWiFiPowerSaveResult::PrimaryEspNowConflict) {
|
|
snprintf(reply, reply_size,
|
|
"Error: power save max is unavailable while ESP-NOW is the primary radio");
|
|
return false;
|
|
}
|
|
if (result == CompanionWiFiPowerSaveResult::BluetoothConflict) {
|
|
snprintf(reply, reply_size,
|
|
"Error: power save none is unavailable while Bluetooth is active");
|
|
return false;
|
|
}
|
|
if (result == CompanionWiFiPowerSaveResult::InvalidMode) {
|
|
snprintf(reply, reply_size,
|
|
"Error: power save must be none, min, or max");
|
|
return false;
|
|
}
|
|
if (result == CompanionWiFiPowerSaveResult::StorageError) {
|
|
snprintf(reply, reply_size, "Error: failed to save WiFi power save");
|
|
return false;
|
|
}
|
|
|
|
syncWiFiPowerSaving();
|
|
if (result == CompanionWiFiPowerSaveResult::Applied) {
|
|
snprintf(reply, reply_size, "OK - WiFi power save set to %s", value);
|
|
} else {
|
|
snprintf(reply, reply_size,
|
|
"OK - saved; WiFi power save applies on next connection");
|
|
}
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
bool MyMesh::applyAndSaveRxPowerSaving(const char* value, char* reply) {
|
|
if (!radio_driver.supportsRxPowerSaving()) {
|
|
strcpy(reply, "Error: RX power saving unsupported");
|
|
return false;
|
|
}
|
|
|
|
uint8_t enabled = _prefs.rx_powersaving_enabled;
|
|
uint8_t level = _prefs.rx_ps_level;
|
|
uint8_t preamble = _prefs.rx_ps_preamble;
|
|
uint32_t rx_us = _prefs.rx_ps_rx_us;
|
|
uint32_t sleep_us = _prefs.rx_ps_sleep_us;
|
|
bool level_requested = false;
|
|
bool manual_requested = false;
|
|
|
|
mesh::cli::RxPowerSavingArguments parsed = {};
|
|
if (!mesh::cli::parseRxPowerSavingArgumentsStrict(value, parsed)) {
|
|
strcpy(reply, "Error: use off, level 1-10, or RX/SLEEP microseconds");
|
|
return false;
|
|
}
|
|
|
|
if (parsed.mode == mesh::cli::RxPowerSavingArgumentMode::Off) {
|
|
enabled = 0;
|
|
} else if (parsed.mode
|
|
== mesh::cli::RxPowerSavingArgumentMode::Conservative) {
|
|
enabled = 1;
|
|
level = RX_POWERSAVING_CONSERVATIVE_LEVEL;
|
|
preamble = RX_POWERSAVING_PROFILE_PREAMBLE;
|
|
level_requested = true;
|
|
} else if (parsed.mode == mesh::cli::RxPowerSavingArgumentMode::Balanced) {
|
|
enabled = 1;
|
|
level = RX_POWERSAVING_BALANCED_LEVEL;
|
|
preamble = RX_POWERSAVING_PROFILE_PREAMBLE;
|
|
level_requested = true;
|
|
} else if (parsed.mode == mesh::cli::RxPowerSavingArgumentMode::Level) {
|
|
if (parsed.level < 1 || parsed.level > 10) {
|
|
strcpy(reply, parsed.preamble == 0
|
|
? "Error: level must be 1-10"
|
|
: "Error: level must be 1-10; preamble must be 16 or 32");
|
|
return false;
|
|
}
|
|
if (parsed.preamble != 0
|
|
&& parsed.preamble != 16 && parsed.preamble != 32) {
|
|
strcpy(reply, "Error: level must be 1-10; preamble must be 16 or 32");
|
|
return false;
|
|
}
|
|
enabled = 1;
|
|
level = static_cast<uint8_t>(parsed.level);
|
|
preamble = static_cast<uint8_t>(parsed.preamble);
|
|
level_requested = true;
|
|
} else if (parsed.mode == mesh::cli::RxPowerSavingArgumentMode::Manual) {
|
|
if (parsed.rx_us < RX_POWERSAVING_MIN_MANUAL_PERIOD_US
|
|
|| parsed.rx_us > RX_POWERSAVING_MAX_PERIOD_US
|
|
|| parsed.sleep_us < RX_POWERSAVING_MIN_MANUAL_PERIOD_US
|
|
|| parsed.sleep_us > RX_POWERSAVING_MAX_PERIOD_US) {
|
|
snprintf(reply, 160, "Error: RX/SLEEP must be %lu-%lu us",
|
|
(unsigned long)RX_POWERSAVING_MIN_MANUAL_PERIOD_US,
|
|
(unsigned long)RX_POWERSAVING_MAX_PERIOD_US);
|
|
return false;
|
|
}
|
|
enabled = 1;
|
|
rx_us = parsed.rx_us;
|
|
sleep_us = parsed.sleep_us;
|
|
level = 0;
|
|
preamble = 0;
|
|
manual_requested = true;
|
|
}
|
|
|
|
if (level_requested) {
|
|
if (level < 1 || level > 10
|
|
|| (preamble != 0 && preamble != 16 && preamble != 32)
|
|
|| !recalcRxPowerSavingFromLevel(level, _prefs.sf, _prefs.bw, preamble,
|
|
&rx_us, &sleep_us)) {
|
|
strcpy(reply, "Error: level must be 1-10; preamble must be auto, 16, or 32");
|
|
return false;
|
|
}
|
|
}
|
|
if ((manual_requested || enabled)
|
|
&& (!isValidRxPowerSavingPeriod(rx_us)
|
|
|| !isValidRxPowerSavingPeriod(sleep_us))) {
|
|
snprintf(reply, 160, "Error: RX/SLEEP must be %lu-%lu us",
|
|
(unsigned long)RX_POWERSAVING_MIN_MANUAL_PERIOD_US,
|
|
(unsigned long)RX_POWERSAVING_MAX_PERIOD_US);
|
|
return false;
|
|
}
|
|
|
|
if (_radio_available
|
|
&& !radio_driver.setRxPowerSaving(enabled != 0, rx_us, sleep_us)) {
|
|
strcpy(reply, "Error: radio busy; retry");
|
|
return false;
|
|
}
|
|
|
|
_prefs.rx_powersaving_enabled = enabled;
|
|
_prefs.rx_ps_rx_us = rx_us;
|
|
_prefs.rx_ps_sleep_us = sleep_us;
|
|
_prefs.rx_ps_level = level;
|
|
_prefs.rx_ps_preamble = preamble;
|
|
savePrefs();
|
|
snprintf(reply, 160, "OK - %s,%lu,%lu",
|
|
enabled ? "on" : "off", (unsigned long)rx_us,
|
|
(unsigned long)sleep_us);
|
|
return true;
|
|
}
|
|
|
|
void MyMesh::appendRxPowerSavingAdjustmentNote(char* reply, size_t reply_size,
|
|
uint8_t sf, float bw) const {
|
|
if (!reply || reply_size == 0 || !_prefs.rx_powersaving_enabled
|
|
|| _prefs.rx_ps_level < 1 || _prefs.rx_ps_level > 10) {
|
|
return;
|
|
}
|
|
|
|
uint32_t rx_us = 0;
|
|
uint32_t sleep_us = 0;
|
|
uint8_t effective_level = 0;
|
|
uint8_t effective_preamble = 0;
|
|
if (!recalcRxPowerSavingFromLevel(
|
|
_prefs.rx_ps_level, sf, bw, _prefs.rx_ps_preamble,
|
|
&rx_us, &sleep_us, &effective_level, &effective_preamble)) {
|
|
return;
|
|
}
|
|
|
|
const size_t used = strlen(reply);
|
|
if (used >= reply_size - 1) return;
|
|
|
|
if (rxPowerSavingUsesContinuousFallback(rx_us, sleep_us)) {
|
|
snprintf(reply + used, reply_size - used,
|
|
"; RXPS continuous-fast (no safe level %u-10)",
|
|
(unsigned)_prefs.rx_ps_level);
|
|
return;
|
|
}
|
|
|
|
const uint8_t requested_preamble = _prefs.rx_ps_preamble == 0
|
|
? rxPowerSavingPreambleForParams(sf, bw) : _prefs.rx_ps_preamble;
|
|
if (effective_level == _prefs.rx_ps_level
|
|
&& effective_preamble == requested_preamble) {
|
|
return;
|
|
}
|
|
|
|
snprintf(reply + used, reply_size - used,
|
|
"; RXPS effective level %u, preamble %u (saved minimum %u)",
|
|
(unsigned)effective_level, (unsigned)effective_preamble,
|
|
(unsigned)_prefs.rx_ps_level);
|
|
}
|
|
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
Stream& MyMesh::terminalOutput() {
|
|
return _terminal_output != NULL ? *_terminal_output : Serial;
|
|
}
|
|
|
|
void MyMesh::resetTerminalSession() {
|
|
_terminal_recipient_set = false;
|
|
memset(_terminal_recipient_key, 0, sizeof(_terminal_recipient_key));
|
|
clearTerminalLogin();
|
|
clearTerminalCommand();
|
|
clearTerminalTrace();
|
|
|
|
// A reply from an abandoned TCP or USB terminal session must not be shown
|
|
// to whichever terminal connects next. Keep the radio retry alive for the
|
|
// Binary Companion interface, but remove its old text-terminal ownership.
|
|
for (int i = 0; i < EXPECTED_ACK_TABLE_SIZE; i++) {
|
|
expected_ack_table[i].terminal_origin = false;
|
|
}
|
|
}
|
|
|
|
void MyMesh::printTerminalBanner(bool show_binary_stop) {
|
|
Stream& output = terminalOutput();
|
|
#if COMPANION_FEATURE_TEMP_RADIO || COMPANION_FEATURE_NETWORK_TERMINAL
|
|
output.print("\r\n===== MeshCore Full Companion Terminal =====\r\n\r\n");
|
|
#else
|
|
output.print("\r\n===== MeshCore Companion Terminal =====\r\n\r\n");
|
|
#endif
|
|
output.printf("WELCOME %s\r\n", _prefs.node_name);
|
|
mesh::Utils::printHex(output, self_id.pub_key, PUB_KEY_SIZE);
|
|
output.printf("\r\nCompanion %s\r\n", FIRMWARE_VERSION);
|
|
output.print(" (enter 'help' for commands)\r\n");
|
|
if (show_binary_stop) {
|
|
output.print(" (+++MESHCORE-TERM-STOP returns to Binary mode)\r\n");
|
|
} else {
|
|
output.print(" (disconnect to close this TCP terminal)\r\n");
|
|
}
|
|
output.print("\r\n> ");
|
|
}
|
|
|
|
void MyMesh::enterTerminalMode() {
|
|
_terminal_mode = true;
|
|
_terminal_output = &mesh::usbTerminalPort();
|
|
resetTerminalSession();
|
|
printTerminalBanner(true);
|
|
}
|
|
|
|
void MyMesh::exitTerminalMode() {
|
|
_terminal_mode = false;
|
|
resetTerminalSession();
|
|
if (_terminal_output == &mesh::usbTerminalPort()) _terminal_output = NULL;
|
|
}
|
|
|
|
#if COMPANION_FEATURE_NETWORK_TERMINAL
|
|
bool MyMesh::enterNetworkTerminalMode(Stream& output) {
|
|
if (_terminal_mode) return false;
|
|
_terminal_output = &output;
|
|
resetTerminalSession();
|
|
printTerminalBanner(false);
|
|
return true;
|
|
}
|
|
|
|
void MyMesh::exitNetworkTerminalMode(Stream& output) {
|
|
if (_terminal_mode || _terminal_output != &output) return;
|
|
resetTerminalSession();
|
|
_terminal_output = NULL;
|
|
}
|
|
|
|
bool MyMesh::isNetworkTerminalMode(const Stream& output) const {
|
|
return !_terminal_mode && _terminal_output == &output;
|
|
}
|
|
#endif
|
|
|
|
ContactInfo* MyMesh::getTerminalRecipient() {
|
|
if (!_terminal_recipient_set) return NULL;
|
|
|
|
ContactInfo* recipient = lookupContactByPubKey(_terminal_recipient_key, PUB_KEY_SIZE);
|
|
if (recipient == NULL) {
|
|
_terminal_recipient_set = false;
|
|
memset(_terminal_recipient_key, 0, sizeof(_terminal_recipient_key));
|
|
}
|
|
return recipient;
|
|
}
|
|
|
|
void MyMesh::printTerminalPath(const ContactInfo& recipient) {
|
|
terminalOutput().printf(" Path to %s: ", recipient.name);
|
|
if (recipient.out_path_len == OUT_PATH_UNKNOWN) {
|
|
terminalOutput().print("unknown (next send uses FLOOD)\r\n");
|
|
return;
|
|
}
|
|
if (!mesh::Packet::isValidPathLen(recipient.out_path_len)) {
|
|
terminalOutput().print("invalid\r\n");
|
|
return;
|
|
}
|
|
|
|
const uint8_t hash_size = (recipient.out_path_len >> 6) + 1;
|
|
const uint8_t hop_count = recipient.out_path_len & 63;
|
|
if (hop_count == 0) {
|
|
terminalOutput().print("direct (zero hop)\r\n");
|
|
return;
|
|
}
|
|
|
|
uint8_t path_bytes[MAX_PATH_SIZE];
|
|
if (!recipient.copyPathTo(path_bytes)) {
|
|
terminalOutput().print("unavailable (storage read failed)\r\n");
|
|
return;
|
|
}
|
|
for (uint8_t hop = 0; hop < hop_count; hop++) {
|
|
if (hop != 0) terminalOutput().print(',');
|
|
mesh::Utils::printHex(terminalOutput(),
|
|
&path_bytes[(size_t)hop * hash_size],
|
|
hash_size);
|
|
}
|
|
terminalOutput().printf(" (%u %s, %u-byte hashes; used by DIRECT sends)\r\n",
|
|
(unsigned)hop_count, hop_count == 1 ? "hop" : "hops",
|
|
(unsigned)hash_size);
|
|
}
|
|
|
|
void MyMesh::handleTerminalPath(ContactInfo& recipient,
|
|
const char* path_spec) {
|
|
if (path_spec == NULL) {
|
|
printTerminalPath(recipient);
|
|
return;
|
|
}
|
|
|
|
mesh::cli::TerminalPath path;
|
|
const mesh::cli::TerminalPathParseResult parsed =
|
|
mesh::cli::parseTerminalPath(path_spec, _terminal_tmp_buf,
|
|
MAX_PATH_SIZE, 63, path);
|
|
switch (parsed) {
|
|
case mesh::cli::TerminalPathParseResult::Valid:
|
|
break;
|
|
case mesh::cli::TerminalPathParseResult::Missing:
|
|
terminalOutput().print(" ERROR: use path <direct|clear|hops separated by spaces or commas>\r\n");
|
|
return;
|
|
case mesh::cli::TerminalPathParseResult::InvalidPrefix:
|
|
terminalOutput().print(" ERROR: each path hop must be 2, 4, or 6 hex digits\r\n");
|
|
return;
|
|
case mesh::cli::TerminalPathParseResult::MixedPrefixSize:
|
|
terminalOutput().print(" ERROR: all path hops must use the same width\r\n");
|
|
return;
|
|
case mesh::cli::TerminalPathParseResult::InvalidSeparator:
|
|
terminalOutput().print(" ERROR: separate path hops with spaces or commas\r\n");
|
|
return;
|
|
case mesh::cli::TerminalPathParseResult::TooManyHops:
|
|
terminalOutput().print(" ERROR: path must contain at most 63 hops\r\n");
|
|
return;
|
|
case mesh::cli::TerminalPathParseResult::RouteTooLong:
|
|
terminalOutput().print(" ERROR: path is too long\r\n");
|
|
return;
|
|
}
|
|
|
|
const ContactInfo previous = recipient;
|
|
if (!recipient.setPath(_terminal_tmp_buf,
|
|
path.mode == mesh::cli::TerminalPathMode::Clear ? OUT_PATH_UNKNOWN : path.encoded_len)
|
|
|| !scheduleContactWrite(recipient)) {
|
|
recipient = previous;
|
|
terminalOutput().print(
|
|
" ERROR: contact storage is unavailable; reboot and retry\r\n");
|
|
return;
|
|
}
|
|
printTerminalPath(recipient);
|
|
}
|
|
|
|
void MyMesh::rememberTerminalAck(ContactInfo& recipient, const char* text,
|
|
uint32_t message_timestamp, uint32_t expected_ack,
|
|
uint32_t est_timeout,
|
|
const uint8_t packet_retry_key[MAX_HASH_SIZE],
|
|
AckTableEntry* replacement_entry) {
|
|
if (expected_ack == 0) {
|
|
if (replacement_entry != NULL) {
|
|
clearExpectedAck(*replacement_entry, false);
|
|
}
|
|
return;
|
|
}
|
|
|
|
AckTableEntry& entry = replacement_entry != NULL
|
|
? *replacement_entry
|
|
: expected_ack_table[next_ack_idx];
|
|
clearExpectedAck(entry, false);
|
|
entry.msg_sent = _ms->getMillis();
|
|
entry.expires_at = futureMillis(est_timeout);
|
|
entry.ack = expected_ack;
|
|
entry.message_timestamp = message_timestamp;
|
|
entry.contact = &recipient;
|
|
entry.reply_route = NULL;
|
|
mesh::Utils::sha256(entry.text_fingerprint, sizeof(entry.text_fingerprint),
|
|
recipient.id.pub_key, PUB_KEY_SIZE,
|
|
(const uint8_t*)text, strlen(text));
|
|
memcpy(entry.retry_key, packet_retry_key, sizeof(entry.retry_key));
|
|
entry.terminal_origin = true;
|
|
if (replacement_entry == NULL) {
|
|
next_ack_idx = (next_ack_idx + 1) % EXPECTED_ACK_TABLE_SIZE;
|
|
}
|
|
expireExpectedAcks();
|
|
}
|
|
|
|
void MyMesh::importTerminalCard(char* command) {
|
|
if (_store->hasIncompleteContactLoad()) {
|
|
terminalOutput().print(
|
|
" ERROR: contact storage is unavailable; reboot and retry\r\n");
|
|
return;
|
|
}
|
|
|
|
while (*command == ' ') command++;
|
|
if (strncmp(command, "meshcore://", 11) != 0) {
|
|
terminalOutput().print(" ERROR: invalid card format\r\n");
|
|
return;
|
|
}
|
|
|
|
char* encoded = command + 11;
|
|
char* end = encoded + strlen(encoded);
|
|
while (end > encoded && !mesh::Utils::isHexChar(end[-1])) {
|
|
*--end = 0;
|
|
}
|
|
|
|
size_t encoded_len = strlen(encoded);
|
|
if (encoded_len == 0 || (encoded_len & 1) != 0
|
|
|| encoded_len / 2 > sizeof(_terminal_tmp_buf)) {
|
|
terminalOutput().print(" ERROR: invalid card format\r\n");
|
|
return;
|
|
}
|
|
|
|
size_t raw_len = encoded_len / 2;
|
|
if (!mesh::Utils::fromHex(_terminal_tmp_buf, raw_len, encoded)
|
|
|| !importContact(_terminal_tmp_buf, raw_len)) {
|
|
terminalOutput().print(" ERROR: invalid card\r\n");
|
|
return;
|
|
}
|
|
|
|
terminalOutput().print(" OK - contact import queued\r\n");
|
|
}
|
|
|
|
void MyMesh::listTerminalChannels() {
|
|
bool found = false;
|
|
terminalOutput().print("Channels:\r\n");
|
|
for (int i = 0; i < MAX_GROUP_CHANNELS; i++) {
|
|
ChannelDetails channel;
|
|
if (getChannel(i, channel) && channel.name[0] != 0) {
|
|
terminalOutput().printf(" %d: %s\r\n", i, channel.name);
|
|
found = true;
|
|
}
|
|
}
|
|
if (!found) terminalOutput().print(" (none configured)\r\n");
|
|
}
|
|
|
|
void MyMesh::handleTerminalDisplayCommand(const char* arguments) {
|
|
mesh::TerminalDisplayCommand display_command;
|
|
const mesh::TerminalDisplayParseResult result =
|
|
mesh::parseTerminalDisplayCommand(arguments, display_command);
|
|
|
|
if (result == mesh::TerminalDisplayParseResult::InvalidCategory
|
|
|| result == mesh::TerminalDisplayParseResult::InvalidValue) {
|
|
terminalOutput().print(
|
|
" ERROR: use show [adverts|channels|emergency] [on|off]\r\n");
|
|
return;
|
|
}
|
|
|
|
if (result == mesh::TerminalDisplayParseResult::StatusAll) {
|
|
terminalOutput().printf(" Terminal display: adverts %s, channels %s, emergency %s\r\n",
|
|
_terminal_display.isEnabled(
|
|
mesh::TerminalDisplayCategory::Adverts) ? "on" : "off",
|
|
_terminal_display.isEnabled(
|
|
mesh::TerminalDisplayCategory::Channels) ? "on" : "off",
|
|
_terminal_display.isEnabled(
|
|
mesh::TerminalDisplayCategory::Emergency) ? "on" : "off");
|
|
return;
|
|
}
|
|
|
|
if (result == mesh::TerminalDisplayParseResult::Updated) {
|
|
_terminal_display.setEnabled(display_command.category,
|
|
display_command.enabled);
|
|
}
|
|
terminalOutput().printf(" Terminal display: %s %s\r\n",
|
|
mesh::terminalDisplayCategoryName(display_command.category),
|
|
_terminal_display.isEnabled(display_command.category)
|
|
? "on" : "off");
|
|
}
|
|
|
|
void MyMesh::sendTerminalChannelMessage(ChannelDetails& channel,
|
|
const char* text) {
|
|
const size_t prefix_len = strlen(_prefs.node_name) + 2; // "name: "
|
|
const size_t max_text_len = prefix_len < MAX_TEXT_LEN
|
|
? MAX_TEXT_LEN - prefix_len : 0;
|
|
const size_t text_len = text == NULL ? 0 : strlen(text);
|
|
if (text_len == 0) {
|
|
terminalOutput().print(" ERROR: message is empty\r\n");
|
|
} else if (text_len > max_text_len) {
|
|
terminalOutput().printf(" ERROR: message must be 1-%u UTF-8 bytes for this node name\r\n",
|
|
(unsigned)max_text_len);
|
|
} else if (sendGroupMessage(getRTCClock()->getCurrentTimeUnique(),
|
|
channel.channel, _prefs.node_name, text,
|
|
text_len)) {
|
|
terminalOutput().printf(" Sent to %s.\r\n", channel.name);
|
|
} else {
|
|
terminalOutput().print(" ERROR: unable to send\r\n");
|
|
}
|
|
}
|
|
|
|
void MyMesh::printTerminalSendStatus(const char* operation,
|
|
const ContactInfo& recipient, int result,
|
|
uint32_t timeout_millis) {
|
|
terminalOutput().printf(" %s sent to %s (", operation, recipient.name);
|
|
if (result == MSG_SEND_SENT_FLOOD) {
|
|
terminalOutput().print("FLOOD");
|
|
} else {
|
|
const uint8_t hop_count = recipient.out_path_len & 63;
|
|
if (hop_count == 0) {
|
|
terminalOutput().print("zero-hop DIRECT");
|
|
} else {
|
|
const uint8_t hash_size = (recipient.out_path_len >> 6) + 1;
|
|
terminalOutput().print("DIRECT via path ");
|
|
uint8_t path_bytes[MAX_PATH_SIZE];
|
|
const bool path_ready = recipient.copyPathTo(path_bytes);
|
|
if (!path_ready) terminalOutput().print("unavailable");
|
|
for (uint8_t hop = 0; path_ready && hop < hop_count; hop++) {
|
|
if (hop != 0) terminalOutput().print(',');
|
|
mesh::Utils::printHex(
|
|
terminalOutput(), &path_bytes[(size_t)hop * hash_size], hash_size);
|
|
}
|
|
terminalOutput().printf("; %u %s, %u-byte hashes", (unsigned)hop_count,
|
|
hop_count == 1 ? "hop" : "hops", (unsigned)hash_size);
|
|
}
|
|
}
|
|
terminalOutput().printf(", timeout %lu ms)\r\n", (unsigned long)timeout_millis);
|
|
}
|
|
|
|
void MyMesh::clearTerminalLogin() {
|
|
if (_terminal_login_pending && pending_login != 0
|
|
&& memcmp(&pending_login, _terminal_login_key,
|
|
sizeof(_terminal_login_key)) == 0) {
|
|
pending_login = 0;
|
|
}
|
|
_terminal_login_pending = false;
|
|
memset(_terminal_login_key, 0, sizeof(_terminal_login_key));
|
|
_terminal_login_expires_at = 0;
|
|
_terminal_login_target[0] = 0;
|
|
}
|
|
|
|
void MyMesh::serviceTerminalLogin() {
|
|
if (!_terminal_login_pending) return;
|
|
const unsigned long now = _ms->getMillis();
|
|
if (_terminal_login_expires_at != now
|
|
&& !millisHasNowPassed(_terminal_login_expires_at)) {
|
|
return;
|
|
}
|
|
|
|
if (hasTerminalOutput()) {
|
|
terminalOutput().printf("\r\n ERROR: login to %s timed out (wrong password or no response).\r\n> ",
|
|
_terminal_login_target);
|
|
}
|
|
clearTerminalLogin();
|
|
}
|
|
|
|
void MyMesh::sendTerminalLogin(ContactInfo& recipient,
|
|
const char* password) {
|
|
serviceTerminalLogin();
|
|
if (_terminal_login_pending) {
|
|
terminalOutput().printf(" ERROR: login to %s is still pending\r\n",
|
|
_terminal_login_target);
|
|
return;
|
|
}
|
|
if (hasPendingReqs()) {
|
|
terminalOutput().print(
|
|
" ERROR: another Companion request is still pending\r\n");
|
|
return;
|
|
}
|
|
|
|
const size_t password_len = password == NULL ? 0 : strlen(password);
|
|
if (password_len == 0 || password_len > 15) {
|
|
terminalOutput().print(" ERROR: password must be 1-15 UTF-8 bytes\r\n");
|
|
return;
|
|
}
|
|
|
|
uint32_t est_timeout = 0;
|
|
const int result = sendLogin(recipient, password, est_timeout);
|
|
if (result == MSG_SEND_FAILED) {
|
|
terminalOutput().print(" ERROR: unable to send login\r\n");
|
|
return;
|
|
}
|
|
|
|
clearPendingReqs();
|
|
memcpy(&pending_login, recipient.id.pub_key, sizeof(pending_login));
|
|
_terminal_login_pending = true;
|
|
memcpy(_terminal_login_key, recipient.id.pub_key,
|
|
sizeof(_terminal_login_key));
|
|
const uint32_t timeout = est_timeout + est_timeout / 5;
|
|
_terminal_login_expires_at = futureMillis(timeout);
|
|
StrHelper::strzcpy(_terminal_login_target, recipient.name,
|
|
sizeof(_terminal_login_target));
|
|
printTerminalSendStatus("Login", recipient, result, timeout);
|
|
}
|
|
|
|
void MyMesh::clearTerminalCommand() {
|
|
_terminal_command.clear();
|
|
_terminal_command_target[0] = 0;
|
|
}
|
|
|
|
void MyMesh::serviceTerminalCommand() {
|
|
uint32_t elapsed_millis = 0;
|
|
if (!_terminal_command.expire(_ms->getMillis(), elapsed_millis)) return;
|
|
|
|
if (hasTerminalOutput()) {
|
|
terminalOutput().printf("\r\n ERROR: command to %s timed out after %lu ms.\r\n> ",
|
|
_terminal_command_target, (unsigned long)elapsed_millis);
|
|
}
|
|
_terminal_command_target[0] = 0;
|
|
}
|
|
|
|
void MyMesh::sendTerminalCommand(ContactInfo& recipient,
|
|
const char* command) {
|
|
serviceTerminalLogin();
|
|
if (_terminal_login_pending) {
|
|
terminalOutput().printf(" ERROR: login to %s is still pending\r\n",
|
|
_terminal_login_target);
|
|
return;
|
|
}
|
|
|
|
serviceTerminalCommand();
|
|
if (_terminal_command.isPending()) {
|
|
terminalOutput().printf(" ERROR: command to %s is still pending\r\n",
|
|
_terminal_command_target);
|
|
return;
|
|
}
|
|
|
|
// Be defensive if a caller passes the complete terminal line instead of
|
|
// the already-parsed argument. Never transmit the local "cmd" wrapper.
|
|
const char* on_air_command = command;
|
|
const char* nested_command = NULL;
|
|
if (mesh::cli::parseTerminalArgumentCommand(
|
|
command, "cmd", nested_command)
|
|
== mesh::cli::TerminalArgumentCommandMatch::Valid) {
|
|
on_air_command = nested_command;
|
|
}
|
|
|
|
const size_t command_len =
|
|
on_air_command == NULL ? 0 : strlen(on_air_command);
|
|
if (command_len == 0 || command_len > MAX_CORRELATED_CLI_TEXT_LEN) {
|
|
terminalOutput().printf(" ERROR: remote command must be 1-%u UTF-8 bytes\r\n",
|
|
(unsigned)MAX_CORRELATED_CLI_TEXT_LEN);
|
|
return;
|
|
}
|
|
|
|
const uint32_t logical_request_id =
|
|
getRTCClock()->getCurrentTimeUnique();
|
|
const uint32_t timestamp = getRTCClock()->getCurrentTimeUnique();
|
|
const uint32_t command_started_at = _ms->getMillis();
|
|
uint32_t est_timeout = 0;
|
|
// Legacy server roles used CLI_DATA for requests as well as replies. Keep
|
|
// that interoperable request form for deployed Repeaters, Rooms, and
|
|
// Sensors; Chat/Companion nodes need the explicit CLI_COMMAND direction.
|
|
const bool is_server_role = recipient.type == ADV_TYPE_REPEATER
|
|
|| recipient.type == ADV_TYPE_ROOM
|
|
|| recipient.type == ADV_TYPE_SENSOR;
|
|
const uint8_t txt_type = is_server_role
|
|
? TXT_TYPE_CLI_DATA : TXT_TYPE_CLI_COMMAND;
|
|
const int result = sendCommandData(recipient, timestamp, 0,
|
|
txt_type, on_air_command,
|
|
est_timeout, logical_request_id);
|
|
if (result == MSG_SEND_FAILED) {
|
|
terminalOutput().print(" ERROR: unable to send remote command\r\n");
|
|
return;
|
|
}
|
|
|
|
_terminal_command.begin(recipient.id.pub_key, command_started_at,
|
|
est_timeout);
|
|
StrHelper::strzcpy(_terminal_command_target, recipient.name,
|
|
sizeof(_terminal_command_target));
|
|
|
|
printTerminalSendStatus("Remote command", recipient, result, est_timeout);
|
|
}
|
|
|
|
void MyMesh::clearTerminalTrace() {
|
|
_terminal_trace_pending = false;
|
|
_terminal_trace_hash_size = 0;
|
|
_terminal_trace_tag = 0;
|
|
_terminal_trace_auth = 0;
|
|
_terminal_trace_sent_at = 0;
|
|
_terminal_trace_expires_at = 0;
|
|
_terminal_trace_target[0] = 0;
|
|
}
|
|
|
|
void MyMesh::serviceTerminalTrace() {
|
|
if (!_terminal_trace_pending) return;
|
|
const unsigned long now = _ms->getMillis();
|
|
if (_terminal_trace_expires_at != now
|
|
&& !millisHasNowPassed(_terminal_trace_expires_at)) {
|
|
return;
|
|
}
|
|
|
|
if (hasTerminalOutput()) {
|
|
terminalOutput().printf("\r\n ERROR: trace to %s timed out.\r\n> ",
|
|
_terminal_trace_target);
|
|
}
|
|
clearTerminalTrace();
|
|
}
|
|
|
|
void MyMesh::sendTerminalTraceRoute(const uint8_t* route, uint8_t hash_size,
|
|
uint8_t hop_count, const char* target) {
|
|
serviceTerminalTrace();
|
|
if (_terminal_trace_pending) {
|
|
terminalOutput().printf(" ERROR: trace to %s is still pending\r\n",
|
|
_terminal_trace_target);
|
|
return;
|
|
}
|
|
if (route == NULL || hop_count == 0 || hop_count >= MAX_PATH_SIZE) {
|
|
terminalOutput().print(" ERROR: trace path must contain 1-63 prefixes\r\n");
|
|
return;
|
|
}
|
|
|
|
const size_t route_byte_len = static_cast<size_t>(hash_size) * hop_count;
|
|
if (route_byte_len > MAX_PACKET_PAYLOAD - 9) {
|
|
terminalOutput().print(" ERROR: trace path is too long\r\n");
|
|
return;
|
|
}
|
|
|
|
const uint8_t flags = mesh::traceFlagsForHashSize(hash_size);
|
|
if (flags == 0xFF) {
|
|
terminalOutput().print(" ERROR: trace hash size must be 1, 2, or 4 bytes\r\n");
|
|
return;
|
|
}
|
|
|
|
const uint32_t airtime = _radio->getEstAirtimeFor(9 + route_byte_len + 2);
|
|
if (airtime == 0) {
|
|
terminalOutput().print(" ERROR: unable to estimate trace timeout\r\n");
|
|
return;
|
|
}
|
|
const uint32_t base_timeout =
|
|
calcDirectTimeoutMillisFor(airtime, hop_count);
|
|
uint32_t trace_timeout = 0;
|
|
if (!mesh::calculateTerminalTraceTimeoutMillis(base_timeout,
|
|
trace_timeout)) {
|
|
terminalOutput().print(" ERROR: trace timeout is out of range\r\n");
|
|
return;
|
|
}
|
|
|
|
uint32_t tag = 0;
|
|
uint32_t auth = 0;
|
|
getRNG()->random((uint8_t*)&tag, sizeof(tag));
|
|
getRNG()->random((uint8_t*)&auth, sizeof(auth));
|
|
mesh::Packet* packet = createTrace(tag, auth, flags);
|
|
if (packet == NULL) {
|
|
terminalOutput().print(" ERROR: unable to allocate trace packet\r\n");
|
|
return;
|
|
}
|
|
|
|
if (!sendDirect(packet, route, static_cast<uint8_t>(route_byte_len))) {
|
|
terminalOutput().print(" ERROR: unable to send trace\r\n");
|
|
return;
|
|
}
|
|
|
|
_terminal_trace_pending = true;
|
|
_terminal_trace_hash_size = hash_size;
|
|
_terminal_trace_tag = tag;
|
|
_terminal_trace_auth = auth;
|
|
_terminal_trace_sent_at = _ms->getMillis();
|
|
_terminal_trace_expires_at = futureMillis(trace_timeout);
|
|
StrHelper::strzcpy(_terminal_trace_target, target,
|
|
sizeof(_terminal_trace_target));
|
|
terminalOutput().printf(" Trace sent to %s (%u route hops, timeout %lu ms)\r\n",
|
|
target, (unsigned)hop_count,
|
|
(unsigned long)trace_timeout);
|
|
}
|
|
|
|
void MyMesh::sendTerminalTrace(ContactInfo& recipient) {
|
|
if (recipient.out_path_len == OUT_PATH_UNKNOWN
|
|
|| !mesh::Packet::isValidPathLen(recipient.out_path_len)) {
|
|
terminalOutput().print(" ERROR: recipient has no valid direct path\r\n");
|
|
return;
|
|
}
|
|
|
|
const bool include_endpoint = recipient.type == ADV_TYPE_REPEATER
|
|
|| recipient.type == ADV_TYPE_ROOM;
|
|
mesh::RoundTripTracePath route;
|
|
uint8_t path_bytes[MAX_PATH_SIZE];
|
|
if (!recipient.copyPathTo(path_bytes) || !mesh::buildRoundTripTracePath(
|
|
path_bytes, recipient.out_path_len, recipient.id.pub_key,
|
|
include_endpoint, _terminal_tmp_buf, MAX_PACKET_PAYLOAD - 9,
|
|
route)) {
|
|
terminalOutput().print(" ERROR: recipient has no traceable round-trip path\r\n");
|
|
return;
|
|
}
|
|
if (route.hop_count >= MAX_PATH_SIZE) {
|
|
terminalOutput().print(" ERROR: round-trip trace path is too long\r\n");
|
|
return;
|
|
}
|
|
|
|
sendTerminalTraceRoute(_terminal_tmp_buf, route.hash_size, route.hop_count,
|
|
recipient.name);
|
|
}
|
|
|
|
void MyMesh::sendTerminalRawTrace(const char* arguments) {
|
|
mesh::RawTracePath route;
|
|
const mesh::RawTracePathParseResult parsed = mesh::parseRawTracePath(
|
|
arguments, _terminal_tmp_buf, MAX_PACKET_PAYLOAD - 9,
|
|
MAX_PATH_SIZE - 1, route);
|
|
switch (parsed) {
|
|
case mesh::RawTracePathParseResult::Valid:
|
|
break;
|
|
case mesh::RawTracePathParseResult::MissingHashSize:
|
|
case mesh::RawTracePathParseResult::MissingPrefixes:
|
|
terminalOutput().print(" ERROR: use trace path <1|2|4> <prefixes...>\r\n");
|
|
return;
|
|
case mesh::RawTracePathParseResult::InvalidHashSize:
|
|
terminalOutput().print(" ERROR: trace hash size must be 1, 2, or 4 bytes\r\n");
|
|
return;
|
|
case mesh::RawTracePathParseResult::InvalidPrefix:
|
|
terminalOutput().printf(" ERROR: every prefix must be exactly %u hex digits\r\n",
|
|
(unsigned)route.hash_size * 2);
|
|
return;
|
|
case mesh::RawTracePathParseResult::TooManyHops:
|
|
terminalOutput().print(" ERROR: trace path must contain at most 63 prefixes\r\n");
|
|
return;
|
|
case mesh::RawTracePathParseResult::RouteTooLong:
|
|
terminalOutput().print(" ERROR: trace path is too long\r\n");
|
|
return;
|
|
}
|
|
|
|
char target[32];
|
|
snprintf(target, sizeof(target), "raw %u-byte path",
|
|
(unsigned)route.hash_size);
|
|
sendTerminalTraceRoute(_terminal_tmp_buf, route.hash_size, route.hop_count,
|
|
target);
|
|
}
|
|
|
|
void MyMesh::handleTerminalCommand(char* command) {
|
|
while (*command == ' ' || *command == '\t') command++;
|
|
if (*command == 0) return;
|
|
mesh::cli::normalizeCommandVerb(command);
|
|
|
|
#if COMPANION_FEATURE_JOHN
|
|
if (mesh::handleJohnCommand(command, terminalOutput())) return;
|
|
#endif
|
|
|
|
char local_reply[160];
|
|
#if COMPANION_FEATURE_USB_MOTA_SOURCE
|
|
const bool usb_mota_owner_transition =
|
|
mesh::isUsbMotaOwnerTransitionCommand(command);
|
|
#else
|
|
const bool usb_mota_owner_transition = false;
|
|
#endif
|
|
if (!usb_mota_owner_transition
|
|
&& handleLocalControlCommand(command, local_reply, sizeof(local_reply))) {
|
|
terminalOutput().printf(" %s\r\n", local_reply);
|
|
return;
|
|
}
|
|
|
|
mesh::cli::TerminalChannelMessage channel_message;
|
|
const mesh::cli::TerminalChannelCommandMatch channel_match =
|
|
mesh::cli::parseTerminalChannelMessage(command, channel_message);
|
|
const char* login_password = NULL;
|
|
const mesh::cli::TerminalArgumentCommandMatch login_match =
|
|
mesh::cli::parseTerminalArgumentCommand(command, "login",
|
|
login_password);
|
|
const char* remote_command = NULL;
|
|
const mesh::cli::TerminalArgumentCommandMatch command_match =
|
|
mesh::cli::parseTerminalArgumentCommand(command, "cmd",
|
|
remote_command);
|
|
const char* path_spec = NULL;
|
|
const mesh::cli::TerminalArgumentCommandMatch path_match =
|
|
mesh::cli::parseTerminalArgumentCommand(command, "path", path_spec);
|
|
const char* recipient_prefix = NULL;
|
|
const mesh::cli::TerminalArgumentCommandMatch recipient_match =
|
|
mesh::cli::parseTerminalArgumentCommand(command, "to",
|
|
recipient_prefix);
|
|
const char* display_arguments = NULL;
|
|
const mesh::cli::TerminalArgumentCommandMatch display_match =
|
|
mesh::cli::parseTerminalArgumentCommand(command, "show",
|
|
display_arguments);
|
|
|
|
if (display_match != mesh::cli::TerminalArgumentCommandMatch::NoMatch) {
|
|
handleTerminalDisplayCommand(
|
|
display_match == mesh::cli::TerminalArgumentCommandMatch::Valid
|
|
? display_arguments : NULL);
|
|
} else if (strcmp(command, "channels") == 0) {
|
|
listTerminalChannels();
|
|
} else if (channel_match != mesh::cli::TerminalChannelCommandMatch::NoMatch) {
|
|
if (channel_match != mesh::cli::TerminalChannelCommandMatch::Valid) {
|
|
terminalOutput().print(" ERROR: use channel <name-or-slot> <message>\r\n");
|
|
return;
|
|
}
|
|
|
|
ChannelDetails channel;
|
|
bool found = false;
|
|
size_t requested_index = 0;
|
|
if (mesh::cli::parseTerminalChannelIndex(
|
|
channel_message, MAX_GROUP_CHANNELS, requested_index)) {
|
|
found = getChannel((int)requested_index, channel)
|
|
&& channel.name[0] != 0;
|
|
} else {
|
|
for (int i = 0; i < MAX_GROUP_CHANNELS; i++) {
|
|
if (getChannel(i, channel) && channel.name[0] != 0
|
|
&& mesh::cli::terminalChannelNameMatches(channel_message,
|
|
channel.name)) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
terminalOutput().print(" ERROR: channel not found (use 'channels')\r\n");
|
|
} else {
|
|
sendTerminalChannelMessage(channel, channel_message.text);
|
|
}
|
|
} else if (strncmp(command, "send ", 5) == 0) {
|
|
ContactInfo* recipient = getTerminalRecipient();
|
|
const char* text = command + 5;
|
|
if (recipient == NULL) {
|
|
terminalOutput().print(" ERROR: no recipient selected (use 'to' first)\r\n");
|
|
} else if (*text == 0 || strlen(text) > MAX_TEXT_LEN) {
|
|
terminalOutput().printf(" ERROR: message must be 1-%u characters\r\n", (unsigned)MAX_TEXT_LEN);
|
|
} else {
|
|
uint32_t expected_ack = 0;
|
|
uint32_t est_timeout = 0;
|
|
uint32_t message_timestamp = getRTCClock()->getCurrentTimeUnique();
|
|
uint8_t text_fingerprint[MAX_HASH_SIZE] = { 0 };
|
|
uint8_t packet_retry_key[MAX_HASH_SIZE] = { 0 };
|
|
mesh::Utils::sha256(text_fingerprint, sizeof(text_fingerprint),
|
|
recipient->id.pub_key, PUB_KEY_SIZE,
|
|
(const uint8_t*)text, strlen(text));
|
|
AckTableEntry* replacement_entry =
|
|
findPendingTextMessage(text_fingerprint, message_timestamp);
|
|
int result = sendMessage(*recipient, message_timestamp, 0, text,
|
|
expected_ack, est_timeout, packet_retry_key,
|
|
NULL, text_fingerprint);
|
|
if (result == MSG_SEND_FAILED) {
|
|
terminalOutput().print(" ERROR: unable to send\r\n");
|
|
} else {
|
|
rememberTerminalAck(*recipient, text, message_timestamp, expected_ack,
|
|
est_timeout, packet_retry_key, replacement_entry);
|
|
terminalOutput().printf(" message sent - %s\r\n",
|
|
result == MSG_SEND_SENT_FLOOD ? "FLOOD" : "DIRECT");
|
|
}
|
|
}
|
|
} else if (strncmp(command, "public ", 7) == 0) {
|
|
ChannelDetails channel;
|
|
const char* text = command + 7;
|
|
if (!getChannel(0, channel) || channel.name[0] == 0) {
|
|
terminalOutput().print(" ERROR: Public channel is unavailable\r\n");
|
|
} else {
|
|
sendTerminalChannelMessage(channel, text);
|
|
}
|
|
} else if (strcmp(command, "list") == 0 || strncmp(command, "list ", 5) == 0) {
|
|
int count = command[4] == ' ' ? atoi(command + 5) : 0;
|
|
scanRecentContacts(count, this);
|
|
} else if (strcmp(command, "clock") == 0) {
|
|
DateTime dt(getRTCClock()->getCurrentTime());
|
|
terminalOutput().printf("%02d:%02d - %d/%d/%d UTC\r\n",
|
|
dt.hour(), dt.minute(), dt.day(), dt.month(), dt.year());
|
|
} else if (strncmp(command, "time ", 5) == 0) {
|
|
uint32_t timestamp = strtoul(command + 5, NULL, 10);
|
|
uint32_t current = getRTCClock()->getCurrentTime();
|
|
if (timestamp >= current) {
|
|
getRTCClock()->setCurrentTime(timestamp);
|
|
#ifdef COMPANION_MESH_CLOCK_SYNC
|
|
_clock_sync.onManualClockSet();
|
|
#endif
|
|
terminalOutput().print(" OK - clock set\r\n");
|
|
} else {
|
|
terminalOutput().print(" ERROR: clock cannot go backwards\r\n");
|
|
}
|
|
} else if (recipient_match
|
|
== mesh::cli::TerminalArgumentCommandMatch::Valid) {
|
|
ContactInfo* recipient = NULL;
|
|
if (strlen(recipient_prefix) < sizeof(ContactInfo::name)) {
|
|
recipient = searchContactsByPrefix(recipient_prefix);
|
|
}
|
|
if (recipient == NULL || recipient->type == ADV_TYPE_NONE) {
|
|
terminalOutput().print(" ERROR: name prefix not found\r\n");
|
|
} else {
|
|
memcpy(_terminal_recipient_key, recipient->id.pub_key, PUB_KEY_SIZE);
|
|
_terminal_recipient_set = true;
|
|
terminalOutput().printf(" Recipient %s selected\r\n", recipient->name);
|
|
}
|
|
} else if (recipient_match
|
|
== mesh::cli::TerminalArgumentCommandMatch::MissingArgument) {
|
|
ContactInfo* recipient = getTerminalRecipient();
|
|
if (recipient != NULL) {
|
|
terminalOutput().printf(" Current recipient: %s\r\n", recipient->name);
|
|
} else {
|
|
terminalOutput().print(" No recipient selected\r\n");
|
|
}
|
|
} else if (path_match
|
|
!= mesh::cli::TerminalArgumentCommandMatch::NoMatch) {
|
|
ContactInfo* recipient = getTerminalRecipient();
|
|
if (recipient == NULL) {
|
|
terminalOutput().print(" ERROR: no recipient selected (use 'to' first)\r\n");
|
|
} else {
|
|
handleTerminalPath(
|
|
*recipient,
|
|
path_match == mesh::cli::TerminalArgumentCommandMatch::Valid
|
|
? path_spec : NULL);
|
|
}
|
|
} else if (login_match
|
|
!= mesh::cli::TerminalArgumentCommandMatch::NoMatch) {
|
|
ContactInfo* recipient = getTerminalRecipient();
|
|
if (login_match
|
|
!= mesh::cli::TerminalArgumentCommandMatch::Valid) {
|
|
terminalOutput().print(" ERROR: use login <admin-password>\r\n");
|
|
} else if (recipient == NULL) {
|
|
terminalOutput().print(" ERROR: no recipient selected (use 'to' first)\r\n");
|
|
} else {
|
|
sendTerminalLogin(*recipient, login_password);
|
|
}
|
|
} else if (command_match
|
|
!= mesh::cli::TerminalArgumentCommandMatch::NoMatch) {
|
|
ContactInfo* recipient = getTerminalRecipient();
|
|
if (command_match
|
|
!= mesh::cli::TerminalArgumentCommandMatch::Valid) {
|
|
terminalOutput().print(" ERROR: use cmd <remote-command>\r\n");
|
|
} else if (recipient == NULL) {
|
|
terminalOutput().print(" ERROR: no recipient selected (use 'to' first)\r\n");
|
|
} else {
|
|
sendTerminalCommand(*recipient, remote_command);
|
|
}
|
|
} else if (strcmp(command, "trace path") == 0
|
|
|| strncmp(command, "trace path ", 11) == 0
|
|
|| strncmp(command, "trace path\t", 11) == 0) {
|
|
sendTerminalRawTrace(command + 10);
|
|
} else if (strcmp(command, "trace") == 0
|
|
|| strncmp(command, "trace ", 6) == 0) {
|
|
ContactInfo* recipient = NULL;
|
|
if (command[5] == ' ') {
|
|
const char* prefix = command + 6;
|
|
while (*prefix == ' ') prefix++;
|
|
if (*prefix != 0 && strlen(prefix) < sizeof(ContactInfo::name)) {
|
|
recipient = searchContactsByPrefix(prefix);
|
|
}
|
|
if (recipient == NULL || recipient->type == ADV_TYPE_NONE) {
|
|
terminalOutput().print(" ERROR: recipient prefix not found\r\n");
|
|
return;
|
|
}
|
|
} else {
|
|
recipient = getTerminalRecipient();
|
|
if (recipient == NULL) {
|
|
terminalOutput().print(" ERROR: no recipient selected (use 'to' first)\r\n");
|
|
return;
|
|
}
|
|
}
|
|
sendTerminalTrace(*recipient);
|
|
} else if (strcmp(command, "advert") == 0) {
|
|
terminalOutput().print(advert() ? " advert sent (zero hop)\r\n"
|
|
: " ERROR: unable to send advert\r\n");
|
|
} else if (strcmp(command, "reset path") == 0) {
|
|
ContactInfo* recipient = getTerminalRecipient();
|
|
if (recipient == NULL) {
|
|
terminalOutput().print(" ERROR: no recipient selected\r\n");
|
|
} else {
|
|
const uint8_t previous_out_path_len = recipient->out_path_len;
|
|
resetPathTo(*recipient);
|
|
if (scheduleContactWrite(*recipient)) {
|
|
terminalOutput().print(" Done.\r\n");
|
|
} else {
|
|
recipient->out_path_len = previous_out_path_len;
|
|
terminalOutput().print(
|
|
" ERROR: contact storage is unavailable; reboot and retry\r\n");
|
|
}
|
|
}
|
|
} else if (strcmp(command, "card") == 0) {
|
|
mesh::Packet* packet = _prefs.advert_loc_policy == ADVERT_LOC_NONE
|
|
? createSelfAdvert(_prefs.node_name)
|
|
: createSelfAdvert(_prefs.node_name, sensors.node_lat, sensors.node_lon);
|
|
if (packet == NULL) {
|
|
terminalOutput().print(" ERROR: unable to create card\r\n");
|
|
} else {
|
|
packet->header |= ROUTE_TYPE_FLOOD;
|
|
uint8_t raw_len = packet->writeTo(_terminal_tmp_buf);
|
|
releasePacket(packet);
|
|
terminalOutput().print("meshcore://");
|
|
mesh::Utils::printHex(terminalOutput(), _terminal_tmp_buf, raw_len);
|
|
terminalOutput().print("\r\n");
|
|
}
|
|
} else if (strncmp(command, "import ", 7) == 0) {
|
|
importTerminalCard(command + 7);
|
|
} else if (strcmp(command, "powersaving") == 0
|
|
|| strcmp(command, "get powersaving") == 0) {
|
|
terminalOutput().printf(" powersaving %s\r\n",
|
|
_prefs.powersaving_enabled ? "on" : "off");
|
|
#if MESH_USB_LOGGING_AVAILABLE
|
|
} else if (strcmp(command, "get usb.logging") == 0) {
|
|
terminalOutput().printf(
|
|
" usb.logging %s; port: %s%s\r\n",
|
|
mesh::isUsbLoggingEnabled() ? "on" : "off",
|
|
mesh::usbLoggingPortDescription(),
|
|
mesh::usbLoggingInterfaceRestartRequired()
|
|
? " (reboot required to change USB interfaces)" : "");
|
|
#endif
|
|
} else if (strncmp(command, "powersaving ", 12) == 0) {
|
|
char reply[160];
|
|
applyAndSavePowerSaving(command + 12, reply);
|
|
terminalOutput().printf(" %s\r\n", reply);
|
|
} else if (strcmp(command, "get radio.rxps.config") == 0) {
|
|
if (!radio_driver.supportsRxPowerSaving()) {
|
|
terminalOutput().print(" ERROR: RX power saving is unsupported on this radio\r\n");
|
|
} else {
|
|
terminalOutput().printf(
|
|
" radio.rxps.config %s,level=%u,preamble=%u,rx=%lu,sleep=%lu\r\n",
|
|
_prefs.rx_powersaving_enabled ? "on" : "off",
|
|
(unsigned)_prefs.rx_ps_level,
|
|
(unsigned)_prefs.rx_ps_preamble,
|
|
(unsigned long)_prefs.rx_ps_rx_us,
|
|
(unsigned long)_prefs.rx_ps_sleep_us);
|
|
}
|
|
} else if (strcmp(command, "get radio.rxps") == 0) {
|
|
if (!radio_driver.supportsRxPowerSaving()) {
|
|
terminalOutput().print(" ERROR: RX power saving is unsupported on this radio\r\n");
|
|
} else {
|
|
uint8_t effective_level = 0;
|
|
uint8_t effective_preamble = 0;
|
|
uint32_t effective_rx_us = _prefs.rx_ps_rx_us;
|
|
uint32_t effective_sleep_us = _prefs.rx_ps_sleep_us;
|
|
uint8_t active_sf = _prefs.sf;
|
|
float active_bw = _prefs.bw;
|
|
#if COMPANION_FEATURE_TEMP_RADIO
|
|
if (isTempRadioActive()) {
|
|
active_sf = _temp_radio_sf;
|
|
active_bw = _temp_radio_bw;
|
|
}
|
|
#endif
|
|
if (_prefs.rx_ps_level != 0) {
|
|
recalcRxPowerSavingFromLevel(
|
|
_prefs.rx_ps_level, active_sf, active_bw,
|
|
_prefs.rx_ps_preamble, &effective_rx_us, &effective_sleep_us,
|
|
&effective_level, &effective_preamble);
|
|
}
|
|
char effective_suffix[48] = {};
|
|
const bool adjusted_level = effective_level != 0
|
|
&& effective_level != _prefs.rx_ps_level;
|
|
const bool adjusted_preamble = effective_preamble != 0
|
|
&& effective_preamble != _prefs.rx_ps_preamble;
|
|
if (adjusted_level && adjusted_preamble) {
|
|
snprintf(effective_suffix, sizeof(effective_suffix),
|
|
",effective-level=%u,effective-preamble=%u",
|
|
(unsigned)effective_level, (unsigned)effective_preamble);
|
|
} else if (adjusted_level) {
|
|
snprintf(effective_suffix, sizeof(effective_suffix),
|
|
",effective-level=%u", (unsigned)effective_level);
|
|
} else if (adjusted_preamble) {
|
|
snprintf(effective_suffix, sizeof(effective_suffix),
|
|
",effective-preamble=%u", (unsigned)effective_preamble);
|
|
}
|
|
terminalOutput().printf(" radio.rxps %s,level=%u,preamble=%u,rx=%lu,sleep=%lu%s%s\r\n",
|
|
_prefs.rx_powersaving_enabled ? "on" : "off",
|
|
(unsigned)_prefs.rx_ps_level,
|
|
(unsigned)_prefs.rx_ps_preamble,
|
|
(unsigned long)effective_rx_us,
|
|
(unsigned long)effective_sleep_us,
|
|
radio_driver.isRxPowerSavingContinuousFallback()
|
|
? ",mode=continuous-fast" : "",
|
|
effective_suffix);
|
|
}
|
|
#if defined(ESP32) && defined(WIFI_SSID)
|
|
} else if (strcmp(command, "get wifi.powersave") == 0) {
|
|
char reply[160];
|
|
formatWiFiPowerSaving(reply, sizeof(reply));
|
|
terminalOutput().printf(" %s\r\n", reply);
|
|
#endif
|
|
} else if (strcmp(command, "get radio.rxgain") == 0) {
|
|
if (!radio_driver.supportsRxBoostedGainMode()) {
|
|
terminalOutput().print(" ERROR: RX boosted gain is unsupported on this radio\r\n");
|
|
} else {
|
|
terminalOutput().printf(" radio.rxgain %s\r\n",
|
|
_prefs.rx_boosted_gain ? "on" : "off");
|
|
}
|
|
} else if (strcmp(command, "get radio.fem.rxgain") == 0) {
|
|
if (!board.canControlLoRaFemLna()) {
|
|
terminalOutput().print(" ERROR: FEM RX gain control is unsupported on this board\r\n");
|
|
} else {
|
|
terminalOutput().printf(" FEM RX gain: %s\r\n",
|
|
board.isLoRaFemLnaEnabled() ? "on" : "off");
|
|
}
|
|
} else if (strcmp(command, "get radio.fem.txgain") == 0) {
|
|
if (!board.canControlLoRaFemPaGain()) {
|
|
terminalOutput().print(" ERROR: FEM TX gain control is unsupported on this board\r\n");
|
|
} else {
|
|
terminalOutput().printf(" FEM TX gain: %s\r\n",
|
|
board.isLoRaFemPaGainEnabled() ? "on" : "off");
|
|
}
|
|
} else if (strncmp(command, "set ", 4) == 0) {
|
|
const char* config = command + 4;
|
|
#if MESH_USB_LOGGING_AVAILABLE
|
|
if (strncmp(config, "usb.logging", 11) == 0
|
|
&& (config[11] == 0 || config[11] == ' '
|
|
|| config[11] == '\t')) {
|
|
const char* value = config + 11;
|
|
while (*value == ' ' || *value == '\t') value++;
|
|
bool enabled = false;
|
|
bool reboot_if_needed = false;
|
|
bool valid = true;
|
|
if (strcmp(value, "on") == 0) {
|
|
enabled = true;
|
|
} else if (strcmp(value, "off") == 0) {
|
|
enabled = false;
|
|
} else if (strcmp(value, "on reboot") == 0) {
|
|
enabled = true;
|
|
reboot_if_needed = true;
|
|
} else if (strcmp(value, "off reboot") == 0) {
|
|
enabled = false;
|
|
reboot_if_needed = true;
|
|
} else {
|
|
valid = false;
|
|
}
|
|
|
|
if (!valid) {
|
|
terminalOutput().print(
|
|
" ERROR: use set usb.logging <on|off> [reboot]\r\n");
|
|
} else {
|
|
_prefs.usb_logging_enabled = enabled ? 1 : 0;
|
|
mesh::setUsbLoggingEnabled(enabled);
|
|
if (!savePrefs()) {
|
|
terminalOutput().print(
|
|
" ERROR: USB logging changed for this boot but save failed\r\n");
|
|
} else if (!mesh::saveUsbLoggingBootPreference(enabled)) {
|
|
terminalOutput().print(
|
|
" ERROR: setting saved, but next-boot USB interface state could not be saved\r\n");
|
|
} else if (mesh::usbLoggingInterfaceRestartRequired()) {
|
|
if (reboot_if_needed) {
|
|
terminalOutput().printf(
|
|
" OK - USB logging %s (saved); rebooting to change USB interfaces\r\n",
|
|
enabled ? "on" : "off");
|
|
_scheduled_reboot_at = futureMillis(1000);
|
|
} else {
|
|
terminalOutput().printf(
|
|
" OK - USB logging %s (saved); reboot required to change USB interfaces\r\n",
|
|
enabled ? "on" : "off");
|
|
}
|
|
} else {
|
|
terminalOutput().printf(" OK - USB logging %s (saved)\r\n",
|
|
enabled ? "on" : "off");
|
|
}
|
|
}
|
|
} else
|
|
#endif
|
|
if (strncmp(config, "powersaving ", 12) == 0) {
|
|
char reply[160];
|
|
applyAndSavePowerSaving(config + 12, reply);
|
|
terminalOutput().printf(" %s\r\n", reply);
|
|
} else if (strncmp(config, "radio.rxps ", 11) == 0) {
|
|
char reply[160];
|
|
applyAndSaveRxPowerSaving(config + 11, reply);
|
|
terminalOutput().printf(" %s\r\n", reply);
|
|
#if defined(ESP32) && defined(WIFI_SSID)
|
|
} else if (strncmp(config, "wifi.powersave", 14) == 0
|
|
&& (config[14] == 0 || config[14] == ' '
|
|
|| config[14] == '\t')) {
|
|
const char* value = config + 14;
|
|
while (*value == ' ' || *value == '\t') value++;
|
|
char reply[160];
|
|
applyAndSaveWiFiPowerSaving(value, reply, sizeof(reply));
|
|
terminalOutput().printf(" %s\r\n", reply);
|
|
#endif
|
|
} else if (strncmp(config, "radio.rxgain", 12) == 0
|
|
&& (config[12] == 0 || config[12] == ' '
|
|
|| config[12] == '\t')) {
|
|
const char* value = config + 12;
|
|
while (*value == ' ' || *value == '\t') value++;
|
|
if (strcmp(value, "on") != 0 && strcmp(value, "off") != 0) {
|
|
terminalOutput().print(" ERROR: use set radio.rxgain <on|off>\r\n");
|
|
} else if (!radio_driver.supportsRxBoostedGainMode()) {
|
|
terminalOutput().print(" ERROR: RX boosted gain is unsupported on this radio\r\n");
|
|
} else if (!applyAndSaveRxBoostedGain(strcmp(value, "on") == 0)) {
|
|
terminalOutput().print(" ERROR: radio busy; retry\r\n");
|
|
} else {
|
|
terminalOutput().printf(" OK - radio.rxgain %s\r\n", value);
|
|
}
|
|
} else if (strncmp(config, "af ", 3) == 0) {
|
|
float parsed = 0.0f;
|
|
if (!mesh::cli::parseDecimalStrict(config + 3, parsed)
|
|
|| parsed < 0.0f || parsed > 9.0f) {
|
|
terminalOutput().print(" ERROR: airtime factor must be 0-9\r\n");
|
|
} else {
|
|
_prefs.airtime_factor = parsed;
|
|
savePrefs();
|
|
terminalOutput().print(" OK\r\n");
|
|
}
|
|
} else if (strncmp(config, "name ", 5) == 0 && config[5] != 0) {
|
|
StrHelper::strncpy(_prefs.node_name, config + 5, sizeof(_prefs.node_name));
|
|
savePrefs();
|
|
terminalOutput().print(" OK\r\n");
|
|
} else if (strncmp(config, "lat ", 4) == 0) {
|
|
float parsed = 0.0f;
|
|
if (!mesh::cli::parseDecimalStrict(config + 4, parsed)
|
|
|| parsed < -90.0f || parsed > 90.0f) {
|
|
terminalOutput().print(" ERROR: latitude must be -90 to 90\r\n");
|
|
} else {
|
|
sensors.node_lat = parsed;
|
|
savePrefs();
|
|
terminalOutput().print(" OK\r\n");
|
|
}
|
|
} else if (strncmp(config, "lon ", 4) == 0) {
|
|
float parsed = 0.0f;
|
|
if (!mesh::cli::parseDecimalStrict(config + 4, parsed)
|
|
|| parsed < -180.0f || parsed > 180.0f) {
|
|
terminalOutput().print(" ERROR: longitude must be -180 to 180\r\n");
|
|
} else {
|
|
sensors.node_lon = parsed;
|
|
savePrefs();
|
|
terminalOutput().print(" OK\r\n");
|
|
}
|
|
} else if (strncmp(config, "tx ", 3) == 0) {
|
|
_prefs.tx_power_dbm = constrain(atoi(config + 3), -9, MAX_LORA_TX_POWER);
|
|
savePrefs();
|
|
terminalOutput().print(" OK - reboot to apply\r\n");
|
|
} else if (strncmp(config, "freq ", 5) == 0) {
|
|
float parsed = 0.0f;
|
|
if (!mesh::cli::parseDecimalStrict(config + 5, parsed)
|
|
|| parsed < 150.0f || parsed > 2500.0f) {
|
|
terminalOutput().print(" ERROR: frequency must be 150-2500 MHz\r\n");
|
|
} else {
|
|
_prefs.freq = parsed;
|
|
savePrefs();
|
|
terminalOutput().print(" OK - reboot to apply\r\n");
|
|
}
|
|
} else if (strncmp(config, "radio.fem.rxgain", 16) == 0
|
|
&& (config[16] == 0 || config[16] == ' '
|
|
|| config[16] == '\t')) {
|
|
const char* value = config + 16;
|
|
while (*value == ' ' || *value == '\t') value++;
|
|
if (strcmp(value, "on") != 0 && strcmp(value, "off") != 0) {
|
|
terminalOutput().print(" ERROR: use set radio.fem.rxgain <on|off>\r\n");
|
|
} else if (!board.canControlLoRaFemLna()) {
|
|
terminalOutput().print(" ERROR: FEM RX gain control is unsupported on this board\r\n");
|
|
} else if (!applyAndSaveFemRxGain(strcmp(value, "on") == 0)) {
|
|
terminalOutput().print(" ERROR: failed to apply FEM RX gain\r\n");
|
|
} else {
|
|
terminalOutput().printf(" OK - FEM RX gain %s\r\n", value);
|
|
}
|
|
} else if (strncmp(config, "radio.fem.txgain", 16) == 0
|
|
&& (config[16] == 0 || config[16] == ' '
|
|
|| config[16] == '\t')) {
|
|
const char* value = config + 16;
|
|
while (*value == ' ' || *value == '\t') value++;
|
|
if (strcmp(value, "on") != 0 && strcmp(value, "off") != 0) {
|
|
terminalOutput().print(" ERROR: use set radio.fem.txgain <on|off>\r\n");
|
|
} else if (!board.canControlLoRaFemPaGain()) {
|
|
terminalOutput().print(" ERROR: FEM TX gain control is unsupported on this board\r\n");
|
|
} else if (!applyAndSaveFemTxGain(strcmp(value, "on") == 0)) {
|
|
terminalOutput().print(" ERROR: failed to apply FEM TX gain\r\n");
|
|
} else {
|
|
terminalOutput().printf(" OK - FEM TX gain %s\r\n", value);
|
|
}
|
|
} else {
|
|
// The terminal has a few presentation-specific setters above, while
|
|
// handleCommand() owns the shared radio-pref and board-specific command
|
|
// surface used by framed/rescue clients. Use it only as the fallback so
|
|
// Full Companion does not develop holes such as `set radio ...` without
|
|
// changing the established terminal behavior of `set tx`, `set name`,
|
|
// or the WiFi commands.
|
|
if (handleCommand(command, 0, local_reply)) {
|
|
terminalOutput().printf(" %s\r\n", local_reply);
|
|
} else {
|
|
terminalOutput().printf(" ERROR: unknown setting: %s\r\n", config);
|
|
}
|
|
}
|
|
} else if (strcmp(command, "reboot") == 0) {
|
|
terminalOutput().print(" OK - rebooting in 1 second\r\n");
|
|
_scheduled_reboot_at = futureMillis(1000);
|
|
#if defined(NRF52_PLATFORM) && defined(EXTRAFS) && !defined(QSPIFLASH)
|
|
} else if (strcmp(command, "repair extrafs") == 0) {
|
|
repairInternalExtraFS(terminalOutput());
|
|
#endif
|
|
} else if (strcmp(command, "ver") == 0) {
|
|
terminalOutput().printf("Companion %s (protocol %u, build %s)\r\n",
|
|
FIRMWARE_VERSION, (unsigned)FIRMWARE_VER_CODE, FIRMWARE_BUILD_DATE);
|
|
} else if (strcmp(command, "help") == 0) {
|
|
terminalOutput().print("Commands:\r\n");
|
|
terminalOutput().print(" board\r\n");
|
|
terminalOutput().print(" version\r\n");
|
|
terminalOutput().print(" get storage.layout\r\n");
|
|
#if COMPANION_FEATURE_JOHN
|
|
terminalOutput().print(" get John <chapter>:<verse> (World English Bible, offline)\r\n");
|
|
#endif
|
|
terminalOutput().print(" get pwrmgt.bootreason\r\n");
|
|
#if COMPANION_FEATURE_MEMORY_DIAGNOSTICS
|
|
terminalOutput().print(" memory\r\n");
|
|
#endif
|
|
terminalOutput().print(" get display.rotation\r\n");
|
|
terminalOutput().print(" set display.rotation <0|90|180|270>\r\n");
|
|
terminalOutput().print(" set {name|lat|lon|freq|tx|af} {value}\r\n");
|
|
terminalOutput().print(" get bluetooth.name\r\n");
|
|
terminalOutput().print(" set bluetooth.name <name|default>\r\n");
|
|
#if defined(BLE_PIN_CODE)
|
|
terminalOutput().print(" get bluetooth.mac\r\n");
|
|
terminalOutput().print(
|
|
" set bluetooth.mac <address|random|random-every-boot|random-after-connect|default>\r\n");
|
|
terminalOutput().print(" get bluetooth.stealth\r\n");
|
|
terminalOutput().print(" set bluetooth.stealth on|off\r\n");
|
|
#endif
|
|
terminalOutput().print(" set pin <0-999999>\r\n");
|
|
terminalOutput().print(" powersaving [on|off]\r\n");
|
|
#if MESH_USB_LOGGING_AVAILABLE
|
|
terminalOutput().print(" get usb.logging\r\n");
|
|
terminalOutput().print(" set usb.logging <on|off> [reboot]\r\n");
|
|
#endif
|
|
#if defined(ESP32) && defined(WIFI_SSID)
|
|
#if defined(COMPANION_RADIO_FULL)
|
|
terminalOutput().print(" start ota [ap] (WiFi firmware update on port 8080)\r\n");
|
|
terminalOutput().print(" stop ota\r\n");
|
|
#endif
|
|
#if defined(COMPANION_EXCLUSIVE_WIFI_BLE)
|
|
terminalOutput().print(" get companion.transport\r\n");
|
|
terminalOutput().print(" set companion.transport <wifi|ble>\r\n");
|
|
#endif
|
|
terminalOutput().print(" get wifi.powersave\r\n");
|
|
terminalOutput().print(" set wifi.powersave <none|min|max>\r\n");
|
|
#ifdef WITH_WEBCONFIG
|
|
terminalOutput().print(" get wifi.{ssid|status}\r\n");
|
|
terminalOutput().print(" set wifi.ssid <network name>\r\n");
|
|
terminalOutput().print(" set wifi.pwd <password>\r\n");
|
|
terminalOutput().print(" get webui\r\n");
|
|
terminalOutput().print(" set webui <on|off>\r\n");
|
|
terminalOutput().print(" start webconfig [ap]\r\n");
|
|
terminalOutput().print(" stop webconfig\r\n");
|
|
#endif
|
|
#endif
|
|
#if defined(MESH_PRIMARY_ESPNOW) && MESH_PRIMARY_ESPNOW
|
|
terminalOutput().print(" get espnow.channel\r\n");
|
|
terminalOutput().print(" set espnow.channel <1-13>\r\n");
|
|
#endif
|
|
terminalOutput().print(" get radio.rxps\r\n");
|
|
terminalOutput().print(" get radio.rxps.config\r\n");
|
|
terminalOutput().print(" set radio.rxps <off|on|level 1-10 [preamble 16|32]|rx_us sleep_us>\r\n");
|
|
terminalOutput().print(" get radio.cad\r\n");
|
|
terminalOutput().print(" set radio.cad <on|off>\r\n");
|
|
terminalOutput().print(" set radio.cad timings <scan_ms|auto> <retry_ms|auto> <max_ms|auto>\r\n");
|
|
terminalOutput().print(" get radio.rxgain\r\n");
|
|
terminalOutput().print(" set radio.rxgain <on|off>\r\n");
|
|
terminalOutput().print(" get radio.fem.rxgain\r\n");
|
|
terminalOutput().print(" set radio.fem.rxgain <on|off>\r\n");
|
|
terminalOutput().print(" get radio.fem.txgain\r\n");
|
|
terminalOutput().print(" set radio.fem.txgain <on|off>\r\n");
|
|
terminalOutput().print(" card\r\n");
|
|
terminalOutput().print(" import <meshcore://card>\r\n");
|
|
terminalOutput().print(" clock\r\n");
|
|
terminalOutput().print(" time <epoch-seconds>\r\n");
|
|
terminalOutput().print(" list [n]\r\n");
|
|
terminalOutput().print(" show [adverts|channels|emergency] [on|off]\r\n");
|
|
terminalOutput().print(" to [recipient name or prefix]\r\n");
|
|
terminalOutput().print(" path [direct|clear|hops separated by spaces or commas]\r\n");
|
|
terminalOutput().print(" send <text>\r\n");
|
|
terminalOutput().print(" login <admin-password>\r\n");
|
|
terminalOutput().print(" cmd <remote-command>\r\n");
|
|
terminalOutput().print(" trace [recipient name or prefix]\r\n");
|
|
terminalOutput().print(" trace path <1|2|4> <prefixes...>\r\n");
|
|
terminalOutput().print(" advert\r\n");
|
|
terminalOutput().print(" reset path\r\n");
|
|
terminalOutput().print(" public <text>\r\n");
|
|
terminalOutput().print(" channels\r\n");
|
|
terminalOutput().print(" channel <name-or-slot> <text>\r\n");
|
|
#if defined(NRF52_PLATFORM) && defined(EXTRAFS) && !defined(QSPIFLASH)
|
|
terminalOutput().print(" repair extrafs (erases/rebuilds internal ExtraFS)\r\n");
|
|
#endif
|
|
#if COMPANION_FEATURE_TEMP_RADIO || COMPANION_FEATURE_OTA_CLI
|
|
#if COMPANION_FEATURE_TEMP_RADIO
|
|
terminalOutput().print(" tempradio [freq,bw,sf,cr,minutes]\r\n");
|
|
terminalOutput().print(" normalradio\r\n");
|
|
#endif
|
|
#if COMPANION_FEATURE_OTA_CLI
|
|
terminalOutput().print(" ota {status|ls|announce|folder|config|...}\r\n");
|
|
#endif
|
|
#endif
|
|
terminalOutput().print(" reboot\r\n");
|
|
terminalOutput().print(" ver\r\n");
|
|
#if defined(NRF52_PLATFORM)
|
|
terminalOutput().println(" uf2reset");
|
|
#endif
|
|
if (_terminal_mode) {
|
|
terminalOutput().print(" +++MESHCORE-TERM-STOP\r\n");
|
|
} else {
|
|
terminalOutput().print(" disconnect (closes the TCP terminal)\r\n");
|
|
}
|
|
} else if (handleCommand(command, 0, local_reply)) {
|
|
// Fill the same safe shared-command surface for getters (`get name`,
|
|
// `get radio`, `get tx`, and variant commands). Terminal-only commands
|
|
// above still win, including the richer `ver` response and reboot flow.
|
|
terminalOutput().printf(" %s\r\n", local_reply);
|
|
} else {
|
|
terminalOutput().printf(" ERROR: unknown command: %s\r\n", command);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void MyMesh::enterCLIRescue() {
|
|
_cli_rescue = true;
|
|
cli_command[0] = 0;
|
|
mesh::usbTerminalPort().println("========= CLI Rescue =========");
|
|
}
|
|
|
|
static bool isCompanionRadioPrefsCommand(const char* command) {
|
|
if (command == NULL) return false;
|
|
|
|
static const char* const exact_commands[] = {
|
|
"get radio", "get freq", "get af", "get dutycycle", "get tx",
|
|
"get rxdelay", "get path.hash.mode", "get multi.acks"
|
|
};
|
|
for (const char* candidate : exact_commands) {
|
|
if (strcmp(command, candidate) == 0) return true;
|
|
}
|
|
|
|
static const char* const set_prefixes[] = {
|
|
"set radio ", "set af ", "set dutycycle ", "set rxdelay ",
|
|
"set path.hash.mode ", "set multi.acks "
|
|
};
|
|
for (const char* prefix : set_prefixes) {
|
|
if (strncmp(command, prefix, strlen(prefix)) == 0) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool MyMesh::handleCommand(const char* command, uint32_t sender_timestamp,
|
|
char* reply) {
|
|
if (command == NULL || reply == NULL) return false;
|
|
size_t reply_capacity = 160;
|
|
while (*command == ' ' || *command == '\t') command++;
|
|
|
|
if (strlen(command) > 3 && command[2] == '|') {
|
|
// Optional two-character request prefix used by Companion CLI clients.
|
|
memcpy(reply, command, 3);
|
|
reply += 3;
|
|
reply_capacity -= 3;
|
|
*reply = 0;
|
|
command += 3;
|
|
while (*command == ' ' || *command == '\t') command++;
|
|
}
|
|
|
|
#if COMPANION_FEATURE_USB_MOTA_SOURCE
|
|
if (mesh::isUsbMotaOwnerTransitionCommand(command)) {
|
|
snprintf(reply, reply_capacity,
|
|
"ERR ota folder on/off requires the owning USB mOTA session");
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
if (sender_timestamp == 0 && mesh::cli::isUf2ResetCommand(command)) {
|
|
if (!board.rebootToUf2Bootloader()) {
|
|
snprintf(reply, reply_capacity, "ERR: unsupported");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (handleLocalControlCommand(command, reply, reply_capacity)) return true;
|
|
|
|
if (strncmp(command, "set tx ", 7) == 0) {
|
|
int32_t parsed = 0;
|
|
if (!mesh::cli::parseIntegerStrict(command + 7, parsed)) {
|
|
strcpy(reply, "Error: invalid TX power");
|
|
} else if (parsed < -9 || parsed > MAX_LORA_TX_POWER) {
|
|
snprintf(reply, reply_capacity, "Error: TX power must be -9 to %d",
|
|
MAX_LORA_TX_POWER);
|
|
} else {
|
|
const int8_t previous = _prefs.tx_power_dbm;
|
|
const int8_t requested = static_cast<int8_t>(parsed);
|
|
if (_radio_available && !radio_driver.setTxPower(requested)) {
|
|
strcpy(reply, "Error: radio busy or TX power rejected");
|
|
} else {
|
|
_prefs.tx_power_dbm = requested;
|
|
if (!savePrefs()) {
|
|
_prefs.tx_power_dbm = previous;
|
|
if (_radio_available) radio_driver.setTxPower(previous);
|
|
strcpy(reply, "Error: TX power changed but save failed");
|
|
} else {
|
|
strcpy(reply, "OK");
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (isCompanionRadioPrefsCommand(command)) {
|
|
const float previous_freq = _prefs.freq;
|
|
const float previous_bw = _prefs.bw;
|
|
const uint8_t previous_sf = _prefs.sf;
|
|
const uint8_t previous_cr = _prefs.cr;
|
|
const float previous_af = _prefs.airtime_factor;
|
|
const float previous_rxdelay = _prefs.rx_delay_base;
|
|
const uint8_t previous_hash_mode = _prefs.path_hash_mode;
|
|
const uint8_t previous_multi_acks = _prefs.multi_acks;
|
|
const uint32_t previous_rx_us = _prefs.rx_ps_rx_us;
|
|
const uint32_t previous_sleep_us = _prefs.rx_ps_sleep_us;
|
|
|
|
if (!_prefs.getRadioPrefs()->handleCommand(
|
|
command, sender_timestamp, reply)) {
|
|
return false;
|
|
}
|
|
if (_prefs.getRadioPrefs()->isDirty()) {
|
|
if (strncmp(command, "set radio ", 10) == 0) {
|
|
recalcRxPowerSavingFromLevel(
|
|
_prefs.rx_ps_level, _prefs.sf, _prefs.bw,
|
|
_prefs.rx_ps_preamble, &_prefs.rx_ps_rx_us,
|
|
&_prefs.rx_ps_sleep_us);
|
|
}
|
|
if (!savePrefs()) {
|
|
_prefs.freq = previous_freq;
|
|
_prefs.bw = previous_bw;
|
|
_prefs.sf = previous_sf;
|
|
_prefs.cr = previous_cr;
|
|
_prefs.airtime_factor = previous_af;
|
|
_prefs.rx_delay_base = previous_rxdelay;
|
|
_prefs.path_hash_mode = previous_hash_mode;
|
|
_prefs.multi_acks = previous_multi_acks;
|
|
_prefs.rx_ps_rx_us = previous_rx_us;
|
|
_prefs.rx_ps_sleep_us = previous_sleep_us;
|
|
_prefs.clearDirty();
|
|
strcpy(reply, "Error: setting changed but save failed");
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Hook for future variant-specific commands not covered by the shared,
|
|
// runtime-aware FEM handlers above.
|
|
if (board.handleCommand(command, sender_timestamp, reply)) {
|
|
if (_prefs.isDirty() && !savePrefs()) {
|
|
strcpy(reply, "Error: board setting changed but save failed");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (strncmp(command, "set name ", 9) == 0) {
|
|
const char* name = command + 9;
|
|
if (!AdvertDataParser::isValidName(name)) {
|
|
strcpy(reply, "Error, bad chars");
|
|
} else {
|
|
char previous[sizeof(_prefs.node_name)];
|
|
memcpy(previous, _prefs.node_name, sizeof(previous));
|
|
StrHelper::strncpy(_prefs.node_name, name, sizeof(_prefs.node_name));
|
|
if (!savePrefs()) {
|
|
memcpy(_prefs.node_name, previous, sizeof(_prefs.node_name));
|
|
strcpy(reply, "Error: name changed but save failed");
|
|
} else {
|
|
strcpy(reply, "OK");
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
if (strcmp(command, "get name") == 0) {
|
|
snprintf(reply, reply_capacity, "> %s", _prefs.node_name);
|
|
return true;
|
|
}
|
|
|
|
if (strcmp(command, "ver") == 0) {
|
|
snprintf(reply, reply_capacity, "%s (Build: %s)", FIRMWARE_VERSION,
|
|
FIRMWARE_BUILD_DATE);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void MyMesh::checkCLIRescueCmd() {
|
|
Stream& output = mesh::usbTerminalPort();
|
|
Stream& input = mesh::usbCompanionPort();
|
|
int len = strlen(cli_command);
|
|
while (input.available() && len < sizeof(cli_command)-1) {
|
|
char c = input.read();
|
|
if (c != '\n') {
|
|
cli_command[len++] = c;
|
|
cli_command[len] = 0;
|
|
}
|
|
output.print(c); // echo
|
|
}
|
|
if (len == sizeof(cli_command)-1) { // command buffer full
|
|
cli_command[sizeof(cli_command)-1] = '\r';
|
|
}
|
|
|
|
if (len > 0 && cli_command[len - 1] == '\r') { // received complete line
|
|
cli_command[len - 1] = 0; // replace newline with C string null terminator
|
|
|
|
reply_buf[0] = 0;
|
|
if (handleCommand(cli_command, 0, reply_buf)) {
|
|
// command was handled, print reply output
|
|
output.print(" "); output.print(reply_buf); output.println();
|
|
#if defined(NRF52_PLATFORM) && defined(EXTRAFS) && !defined(QSPIFLASH)
|
|
} else if (strcmp(cli_command, "repair extrafs") == 0) {
|
|
repairInternalExtraFS(output);
|
|
#endif
|
|
} else if (strcmp(cli_command, "rebuild") == 0) {
|
|
bool success = _store->formatFileSystem();
|
|
if (success) {
|
|
const bool identity_saved = _store->saveMainIdentity(self_id);
|
|
const bool prefs_saved = savePrefs();
|
|
const bool contacts_saved = _store->saveContacts(this, save_filter);
|
|
const bool channels_saved = saveChannels();
|
|
const bool contacts_complete =
|
|
contacts_saved && !_store->hasPendingContactWrites();
|
|
|
|
if (contacts_complete) {
|
|
mesh::resetLazyPersistenceAfterSuccess(
|
|
dirty_contacts_expiry, dirty_contacts_failures);
|
|
} else {
|
|
scheduleContactWriteRetry();
|
|
}
|
|
|
|
if (identity_saved && prefs_saved && contacts_complete
|
|
&& channels_saved) {
|
|
output.println(" > erase and rebuild done");
|
|
} else {
|
|
output.println(" Error: erase succeeded, but data rebuild failed; retry rebuild");
|
|
}
|
|
} else {
|
|
output.println(" Error: erase failed");
|
|
}
|
|
} else if (strcmp(cli_command, "erase") == 0) {
|
|
bool success = _store->formatFileSystem();
|
|
if (success) {
|
|
output.println(" > erase done");
|
|
} else {
|
|
output.println(" Error: erase failed");
|
|
}
|
|
} else if (memcmp(cli_command, "ls", 2) == 0) {
|
|
|
|
// get path from command e.g: "ls /adafruit"
|
|
const char *path = &cli_command[3];
|
|
|
|
bool is_fs2 = false;
|
|
if (memcmp(path, "UserData/", 9) == 0) {
|
|
path += 8; // skip "UserData"
|
|
} else if (memcmp(path, "ExtraFS/", 8) == 0) {
|
|
path += 7; // skip "ExtraFS"
|
|
is_fs2 = true;
|
|
}
|
|
output.printf("Listing files in %s\n", path);
|
|
|
|
// log each file and directory
|
|
File root = _store->openDirectory(path);
|
|
if (is_fs2 == false) {
|
|
if (root) {
|
|
File file = root.openNextFile();
|
|
while (file) {
|
|
if (file.isDirectory()) {
|
|
output.printf("[dir] UserData%s/%s\n", path, file.name());
|
|
} else {
|
|
output.printf("[file] UserData%s/%s (%d bytes)\n", path,
|
|
file.name(), file.size());
|
|
}
|
|
// move to next file
|
|
file = root.openNextFile();
|
|
}
|
|
root.close();
|
|
}
|
|
}
|
|
|
|
if (is_fs2 == true || strlen(path) == 0 || strcmp(path, "/") == 0) {
|
|
if (_store->getSecondaryFS() != nullptr) {
|
|
File root2 = _store->openDirectory(_store->getSecondaryFS(), path);
|
|
File file = root2.openNextFile();
|
|
while (file) {
|
|
if (file.isDirectory()) {
|
|
output.printf("[dir] ExtraFS%s/%s\n", path, file.name());
|
|
} else {
|
|
output.printf("[file] ExtraFS%s/%s (%d bytes)\n", path,
|
|
file.name(), file.size());
|
|
}
|
|
// move to next file
|
|
file = root2.openNextFile();
|
|
}
|
|
root2.close();
|
|
}
|
|
}
|
|
} else if (memcmp(cli_command, "cat", 3) == 0) {
|
|
|
|
// get path from command e.g: "cat /contacts3"
|
|
const char *path = &cli_command[4];
|
|
|
|
bool is_fs2 = false;
|
|
if (memcmp(path, "UserData/", 9) == 0) {
|
|
path += 8; // skip "UserData"
|
|
} else if (memcmp(path, "ExtraFS/", 8) == 0) {
|
|
path += 7; // skip "ExtraFS"
|
|
is_fs2 = true;
|
|
} else {
|
|
output.println(
|
|
"Invalid path provided, must start with UserData/ or ExtraFS/");
|
|
cli_command[0] = 0;
|
|
return;
|
|
}
|
|
|
|
// A corrupt internal ExtraFS is deliberately quarantined until the
|
|
// explicit repair command runs. Never pass that null secondary pointer
|
|
// into the raw filesystem helpers while it is unavailable.
|
|
FILESYSTEM* selected_fs = is_fs2
|
|
? _store->getSecondaryFS()
|
|
: _store->getPrimaryFS();
|
|
if (selected_fs == nullptr) {
|
|
output.println("ExtraFS is unavailable; run repair extrafs first");
|
|
} else {
|
|
// log file content as hex
|
|
File file = _store->openRead(selected_fs, path);
|
|
if(file){
|
|
|
|
// Stream the dump in bounded chunks. An ExtraFS file can be much
|
|
// larger than the nRF52 task stack, so never allocate file.size()
|
|
// bytes on the stack here.
|
|
uint8_t buffer[64];
|
|
while (file.available() > 0) {
|
|
const int count = file.read(buffer, sizeof(buffer));
|
|
if (count <= 0) break;
|
|
mesh::Utils::printHex(output, buffer, count);
|
|
}
|
|
output.print("\n");
|
|
|
|
file.close();
|
|
|
|
}
|
|
}
|
|
|
|
} else if (memcmp(cli_command, "rm ", 3) == 0) {
|
|
// get path from command e.g: "rm /adv_blobs"
|
|
const char *path = &cli_command[3];
|
|
MESH_DEBUG_PRINTLN("Removing file: %s", path);
|
|
// ensure path is not empty, or root dir
|
|
if(!path || strlen(path) == 0 || strcmp(path, "/") == 0){
|
|
output.println("Invalid path provided");
|
|
} else {
|
|
bool is_fs2 = false;
|
|
if (memcmp(path, "UserData/", 9) == 0) {
|
|
path += 8; // skip "UserData"
|
|
} else if (memcmp(path, "ExtraFS/", 8) == 0) {
|
|
path += 7; // skip "ExtraFS"
|
|
is_fs2 = true;
|
|
}
|
|
|
|
// remove file
|
|
FILESYSTEM* selected_fs = is_fs2
|
|
? _store->getSecondaryFS()
|
|
: _store->getPrimaryFS();
|
|
if (selected_fs == nullptr) {
|
|
output.println("ExtraFS is unavailable; run repair extrafs first");
|
|
} else {
|
|
if (is_fs2) {
|
|
MESH_DEBUG_PRINTLN("Removing file from ExtraFS: %s", path);
|
|
} else {
|
|
MESH_DEBUG_PRINTLN("Removing file from UserData: %s", path);
|
|
}
|
|
if (_store->removeFile(selected_fs, path)) {
|
|
output.println("File removed");
|
|
} else {
|
|
output.println("Failed to remove file");
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
} else if (strcmp(cli_command, "reboot") == 0) {
|
|
if (flushContactsBeforeReboot()) {
|
|
board.reboot(); // doesn't return
|
|
} else {
|
|
output.println(" Error: pending contacts could not be saved; reboot cancelled");
|
|
}
|
|
} else {
|
|
output.println(" Error: unknown command");
|
|
}
|
|
|
|
cli_command[0] = 0; // reset command buffer
|
|
}
|
|
}
|
|
|
|
void MyMesh::checkSerialInterface() {
|
|
size_t len = _serial->checkRecvFrame(cmd_frame);
|
|
if (!_serial->isConnected()) {
|
|
stopContactsIterator();
|
|
return;
|
|
}
|
|
|
|
if (len > 0) {
|
|
handleCmdFrame(len);
|
|
} else if (_iter_started // check if our ContactsIterator is 'running'
|
|
&& (_iter_next_frame_at == 0
|
|
|| _iter_next_frame_at == _ms->getMillis()
|
|
|| millisHasNowPassed(_iter_next_frame_at))
|
|
&& !_serial->isWriteBusy() // don't spam the Serial Interface too quickly!
|
|
) {
|
|
if (_iter_table_revision != getContactTableRevision()) {
|
|
// The paced stream walks the live compacting table. If an advert, app
|
|
// command, or overwrite changes its membership mid-stream, start a fresh
|
|
// snapshot marker before reading another entry. Clients already reset
|
|
// their accumulation on CONTACTS_START, so they can never accept a
|
|
// skipped, duplicated, or wrong-count list.
|
|
_iter = startContactsIterator();
|
|
_iter_start_pending = true;
|
|
_iter_contact_pending = false;
|
|
_iter_total_count = getNumContacts();
|
|
_iter_table_revision = getContactTableRevision();
|
|
_most_recent_lastmod = 0;
|
|
}
|
|
|
|
if (_iter_start_pending) {
|
|
uint8_t reply[5];
|
|
reply[0] = RESP_CODE_CONTACTS_START;
|
|
memcpy(&reply[1], &_iter_total_count, 4);
|
|
if (_serial->writeFrame(reply, sizeof(reply)) == sizeof(reply)) {
|
|
_iter_start_pending = false;
|
|
_iter_next_frame_at = futureMillis(CONTACT_STREAM_FRAME_INTERVAL_MS);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (!_iter_contact_pending) {
|
|
ContactInfo contact;
|
|
if (_iter.hasNext(this, contact)) {
|
|
if (contact.lastmod <= _iter_filter_since) return;
|
|
_iter_pending_contact = contact;
|
|
_iter_contact_pending = true;
|
|
} else { // EOF
|
|
out_frame[0] = RESP_CODE_END_OF_CONTACTS;
|
|
memcpy(&out_frame[1], &_most_recent_lastmod,
|
|
4); // include the most recent lastmod, so app can update their 'since'
|
|
if (_serial->writeFrame(out_frame, 5) == 5) {
|
|
stopContactsIterator();
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Do not advance past a contact until its complete frame has been accepted
|
|
// by the selected transport. A transiently full/lost route must not turn a
|
|
// successful CONTACTS_START/END transaction into a silently short list.
|
|
if (writeContactRespFrame(RESP_CODE_CONTACT, _iter_pending_contact)) {
|
|
if (_iter_pending_contact.lastmod > _most_recent_lastmod) {
|
|
_most_recent_lastmod = _iter_pending_contact.lastmod;
|
|
}
|
|
_iter_contact_pending = false;
|
|
_iter_next_frame_at = futureMillis(CONTACT_STREAM_FRAME_INTERVAL_MS);
|
|
}
|
|
//} else if (!_serial->isWriteBusy()) {
|
|
// checkConnections(); // TODO - deprecate the 'Connections' stuff
|
|
}
|
|
}
|
|
|
|
void MyMesh::loop() {
|
|
#if defined(WITH_MQTT_BRIDGE) && defined(ESP32_PLATFORM) && defined(WIFI_SSID)
|
|
if (_mqtt_bridge) _mqtt_bridge->servicePendingClockCorrection();
|
|
#endif
|
|
if (_scheduled_reboot_at != 0
|
|
&& (_scheduled_reboot_at == _ms->getMillis()
|
|
|| millisHasNowPassed(_scheduled_reboot_at))) {
|
|
_scheduled_reboot_at = 0;
|
|
if (flushContactsBeforeReboot()) {
|
|
board.reboot();
|
|
} else {
|
|
MESH_DEBUG_PRINTLN("Scheduled reboot cancelled: pending contacts could not be saved");
|
|
}
|
|
return;
|
|
}
|
|
#if COMPANION_FEATURE_TEMP_RADIO
|
|
serviceTempRadio();
|
|
#endif
|
|
#if defined(OTA_SHARED_COMPANION_QUEUE)
|
|
mesh::ota::ota_release_context_if_idle(isTempRadioActive() || _temp_radio_set_at != 0);
|
|
#endif
|
|
BaseChatMesh::loop();
|
|
#ifdef COMPANION_MESH_CLOCK_SYNC
|
|
_clock_sync.loop();
|
|
#endif
|
|
#ifdef ENABLE_USB_INTERFACE
|
|
serviceTerminalLogin();
|
|
serviceTerminalCommand();
|
|
serviceTerminalTrace();
|
|
#endif
|
|
servicePendingSerialReply();
|
|
serviceBinaryTraceReply();
|
|
serviceSigningSession();
|
|
if (!command_radio_apply_pending && saved_radio_apply_pending && !hasOutbound()
|
|
#if COMPANION_FEATURE_TEMP_RADIO
|
|
&& !_temp_radio_applied && _temp_radio_set_at == 0
|
|
&& _temp_radio_revert_at == 0
|
|
#endif
|
|
&& (!radio_apply_retry_at || millisHasNowPassed(radio_apply_retry_at))) {
|
|
// A power-saving wake can enter begin() with a complete packet already
|
|
// waiting. Preserve that packet, then apply the persisted radio settings
|
|
// once the receive/response path is idle.
|
|
radio_driver.setRxBoostedGainMode(_prefs.rx_boosted_gain);
|
|
if (applySavedRadioParams()) {
|
|
radio_driver.setTxPower(_prefs.tx_power_dbm);
|
|
saved_radio_apply_pending = false;
|
|
radio_apply_retry_at = 0;
|
|
radio_apply_failures = 0;
|
|
} else {
|
|
radio_apply_retry_at = futureMillis(nextRadioApplyRetryDelay(radio_apply_failures));
|
|
}
|
|
}
|
|
if (has_next_ack_expiry
|
|
&& (next_ack_expiry == _ms->getMillis() || millisHasNowPassed(next_ack_expiry))) {
|
|
expireExpectedAcks();
|
|
}
|
|
if (emergency_client_repeat_packet != NULL && millisHasNowPassed(emergency_client_repeat_send_at)) {
|
|
mesh::Packet* pkt = emergency_client_repeat_packet;
|
|
emergency_client_repeat_packet = NULL;
|
|
sendPacket(pkt, 1, 0);
|
|
}
|
|
|
|
if (_cli_rescue) {
|
|
checkCLIRescueCmd();
|
|
} else {
|
|
checkSerialInterface();
|
|
}
|
|
servicePendingRadioParamApply();
|
|
|
|
// is there are pending dirty contacts write needed?
|
|
if (isContactWriteDue()) {
|
|
const bool success = _store->serviceContactWrites(this, save_filter);
|
|
if (!success) {
|
|
scheduleContactWriteRetry();
|
|
} else if (_store->hasPendingContactWrites()) {
|
|
dirty_contacts_failures = 0;
|
|
dirty_contacts_expiry = mesh::nonzeroLazyPersistenceDeadline(
|
|
futureMillis(CONTACT_PAGE_WRITE_GAP));
|
|
} else {
|
|
mesh::resetLazyPersistenceAfterSuccess(
|
|
dirty_contacts_expiry, dirty_contacts_failures);
|
|
}
|
|
}
|
|
|
|
#ifdef DISPLAY_CLASS
|
|
if (_ui) _ui->setHasConnection(_serial->isConnected());
|
|
#endif
|
|
}
|
|
|
|
bool MyMesh::advert() {
|
|
mesh::Packet* pkt;
|
|
if (_prefs.advert_loc_policy == ADVERT_LOC_NONE) {
|
|
pkt = createSelfAdvert(_prefs.node_name);
|
|
} else {
|
|
pkt = createSelfAdvert(_prefs.node_name, sensors.node_lat, sensors.node_lon);
|
|
}
|
|
if (pkt) {
|
|
sendZeroHop(pkt);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// To check if there is pending work
|
|
bool MyMesh::hasPendingWork() const {
|
|
if (_radio_available
|
|
&& (radio_driver.isWatchdogObserving()
|
|
|| radio_driver.isCalibratingNoiseFloor())) return true;
|
|
#if defined(NRF52_PLATFORM)
|
|
// nRF52 sleep is event-driven, so a future lazy-write deadline has no
|
|
// guaranteed interrupt to wake the loop when it becomes due. Keep polling
|
|
// through the initial write. After an actual storage failure, allow sleep
|
|
// during the bounded backoff; the next BLE/radio/GPIO event services an
|
|
// overdue retry without losing the dirty-page state.
|
|
const bool contact_write_needs_polling = dirty_contacts_expiry != 0
|
|
&& (dirty_contacts_failures == 0
|
|
|| isContactWriteDue());
|
|
#else
|
|
const bool contact_write_needs_polling = isContactWriteDue();
|
|
#endif
|
|
return (_serial != NULL && _serial->hasPendingIO())
|
|
|| (_iter_started && _serial != NULL && _serial->isConnected())
|
|
|| hasPendingOtaApply()
|
|
|| command_radio_apply_pending
|
|
|| _scheduled_reboot_at != 0
|
|
|| pending_serial_reply_route != NULL
|
|
|| binary_trace_pending
|
|
|| sign_data != NULL
|
|
|| hasQueuedWorkDue() || hasRetryWorkDue()
|
|
|| (saved_radio_apply_pending
|
|
&& (!radio_apply_retry_at || millisHasNowPassed(radio_apply_retry_at)))
|
|
|| contact_write_needs_polling
|
|
|| (emergency_client_repeat_packet != NULL
|
|
&& millisHasNowPassed(emergency_client_repeat_send_at))
|
|
#if COMPANION_FEATURE_TEMP_RADIO
|
|
|| (_temp_radio_set_at != 0 && millisHasNowPassed(_temp_radio_set_at))
|
|
|| (_temp_radio_revert_at != 0 && millisHasNowPassed(_temp_radio_revert_at))
|
|
|| (_temp_radio_retry_at != 0 && millisHasNowPassed(_temp_radio_retry_at))
|
|
#endif
|
|
;
|
|
}
|