mirror of
https://github.com/meshtastic/firmware.git
synced 2025-02-04 11:49:58 +00:00
581 lines
20 KiB
C++
581 lines
20 KiB
C++
|
|
#include <Arduino.h>
|
|
#include <assert.h>
|
|
|
|
#include "FS.h"
|
|
|
|
#include "CryptoEngine.h"
|
|
#include "GPS.h"
|
|
#include "MeshRadio.h"
|
|
#include "NodeDB.h"
|
|
#include "PacketHistory.h"
|
|
#include "PowerFSM.h"
|
|
#include "RTC.h"
|
|
#include "Router.h"
|
|
#include "configuration.h"
|
|
#include "error.h"
|
|
#include "mesh-pb-constants.h"
|
|
#include "meshwifi/meshwifi.h"
|
|
#include "FSCommon.h"
|
|
#include <pb_decode.h>
|
|
#include <pb_encode.h>
|
|
|
|
NodeDB nodeDB;
|
|
|
|
// we have plenty of ram so statically alloc this tempbuf (for now)
|
|
EXT_RAM_ATTR DeviceState devicestate;
|
|
MyNodeInfo &myNodeInfo = devicestate.my_node;
|
|
RadioConfig &radioConfig = devicestate.radio;
|
|
ChannelSettings &channelSettings = radioConfig.channel_settings;
|
|
|
|
/** The current change # for radio settings. Starts at 0 on boot and any time the radio settings
|
|
* might have changed is incremented. Allows others to detect they might now be on a new channel.
|
|
*/
|
|
uint32_t radioGeneration;
|
|
|
|
/*
|
|
DeviceState versions used to be defined in the .proto file but really only this function cares. So changed to a
|
|
#define here.
|
|
*/
|
|
|
|
#define DEVICESTATE_CUR_VER 11
|
|
#define DEVICESTATE_MIN_VER DEVICESTATE_CUR_VER
|
|
|
|
|
|
|
|
// FIXME - move this somewhere else
|
|
extern void getMacAddr(uint8_t *dmac);
|
|
|
|
/**
|
|
*
|
|
* Normally userids are unique and start with +country code to look like Signal phone numbers.
|
|
* But there are some special ids used when we haven't yet been configured by a user. In that case
|
|
* we use !macaddr (no colons).
|
|
*/
|
|
User &owner = devicestate.owner;
|
|
|
|
static uint8_t ourMacAddr[6];
|
|
|
|
/**
|
|
* The node number the user is currently looking at
|
|
* 0 if none
|
|
*/
|
|
NodeNum displayedNodeNum;
|
|
|
|
/// A usable (but bigger) version of the channel name in the channelSettings object
|
|
const char *channelName;
|
|
|
|
/// A usable psk - which has been constructed based on the (possibly short psk) in channelSettings
|
|
static uint8_t activePSK[32];
|
|
static uint8_t activePSKSize;
|
|
|
|
/**
|
|
* Generate a short suffix used to disambiguate channels that might have the same "name" entered by the human but different PSKs.
|
|
* The ideas is that the PSK changing should be visible to the user so that they see they probably messed up and that's why they
|
|
their nodes
|
|
* aren't talking to each other.
|
|
*
|
|
* This string is of the form "#name-X".
|
|
*
|
|
* Where X is either:
|
|
* (for custom PSKS) a letter from A to Z (base26), and formed by xoring all the bytes of the PSK together,
|
|
* OR (for the standard minimially secure PSKs) a number from 0 to 9.
|
|
*
|
|
* This function will also need to be implemented in GUI apps that talk to the radio.
|
|
*
|
|
* https://github.com/meshtastic/Meshtastic-device/issues/269
|
|
*/
|
|
const char *getChannelName()
|
|
{
|
|
static char buf[32];
|
|
|
|
char suffix;
|
|
if(channelSettings.psk.size != 1) {
|
|
// We have a standard PSK, so generate a letter based hash.
|
|
uint8_t code = 0;
|
|
for (int i = 0; i < activePSKSize; i++)
|
|
code ^= activePSK[i];
|
|
|
|
suffix = 'A' + (code % 26);
|
|
} else {
|
|
suffix = '0' + channelSettings.psk.bytes[0];
|
|
}
|
|
|
|
snprintf(buf, sizeof(buf), "#%s-%c", channelName, suffix);
|
|
return buf;
|
|
}
|
|
|
|
NodeDB::NodeDB() : nodes(devicestate.node_db), numNodes(&devicestate.node_db_count) {}
|
|
|
|
bool NodeDB::resetRadioConfig()
|
|
{
|
|
bool didFactoryReset = false;
|
|
|
|
radioGeneration++;
|
|
|
|
/// 16 bytes of random PSK for our _public_ default channel that all devices power up on (AES128)
|
|
static const uint8_t defaultpsk[] = {0xd4, 0xf1, 0xbb, 0x3a, 0x20, 0x29, 0x07, 0x59,
|
|
0xf0, 0xbc, 0xff, 0xab, 0xcf, 0x4e, 0x69, 0xbf};
|
|
|
|
if (radioConfig.preferences.factory_reset) {
|
|
DEBUG_MSG("Performing factory reset!\n");
|
|
installDefaultDeviceState();
|
|
didFactoryReset = true;
|
|
} else if (!channelSettings.psk.size) {
|
|
DEBUG_MSG("Setting default preferences!\n");
|
|
|
|
radioConfig.has_channel_settings = true;
|
|
radioConfig.has_preferences = true;
|
|
|
|
// radioConfig.modem_config = RadioConfig_ModemConfig_Bw125Cr45Sf128; // medium range and fast
|
|
// channelSettings.modem_config = ChannelSettings_ModemConfig_Bw500Cr45Sf128; // short range and fast, but wide
|
|
// bandwidth so incompatible radios can talk together
|
|
channelSettings.modem_config = ChannelSettings_ModemConfig_Bw125Cr48Sf4096; // slow and long range
|
|
|
|
channelSettings.tx_power = 0; // default
|
|
uint8_t defaultpskIndex = 1;
|
|
channelSettings.psk.bytes[0] = defaultpskIndex;
|
|
channelSettings.psk.size = 1;
|
|
strcpy(channelSettings.name, "");
|
|
}
|
|
|
|
// Convert the old string "Default" to our new short representation
|
|
if(strcmp(channelSettings.name, "Default") == 0)
|
|
*channelSettings.name = '\0';
|
|
|
|
// Convert the short "" representation for Default into a usable string
|
|
channelName = channelSettings.name;
|
|
if(!*channelName) { // emptystring
|
|
// Per mesh.proto spec, if bandwidth is specified we must ignore modemConfig enum, we assume that in that case
|
|
// the app fucked up and forgot to set channelSettings.name
|
|
channelName = "Unset";
|
|
if(channelSettings.bandwidth == 0) switch(channelSettings.modem_config) {
|
|
case ChannelSettings_ModemConfig_Bw125Cr45Sf128:
|
|
channelName = "Medium"; break;
|
|
case ChannelSettings_ModemConfig_Bw500Cr45Sf128:
|
|
channelName = "ShortFast"; break;
|
|
case ChannelSettings_ModemConfig_Bw31_25Cr48Sf512:
|
|
channelName = "LongAlt"; break;
|
|
case ChannelSettings_ModemConfig_Bw125Cr48Sf4096:
|
|
channelName = "LongSlow"; break;
|
|
default:
|
|
channelName = "Invalid"; break;
|
|
}
|
|
}
|
|
|
|
// Convert any old usage of the defaultpsk into our new short representation.
|
|
if(channelSettings.psk.size == sizeof(defaultpsk) &&
|
|
memcmp(channelSettings.psk.bytes, defaultpsk, sizeof(defaultpsk)) == 0) {
|
|
*channelSettings.psk.bytes = 1;
|
|
channelSettings.psk.size = 1;
|
|
}
|
|
|
|
// Convert the short single byte variants of psk into variant that can be used more generally
|
|
memcpy(activePSK, channelSettings.psk.bytes, channelSettings.psk.size);
|
|
activePSKSize = channelSettings.psk.size;
|
|
if(activePSKSize == 1) {
|
|
uint8_t pskIndex = activePSK[0];
|
|
DEBUG_MSG("Expanding short PSK #%d\n", pskIndex);
|
|
if(pskIndex == 0)
|
|
activePSKSize = 0; // Turn off encryption
|
|
else {
|
|
memcpy(activePSK, defaultpsk, sizeof(defaultpsk));
|
|
activePSKSize = sizeof(defaultpsk);
|
|
// Bump up the last byte of PSK as needed
|
|
uint8_t *last = activePSK + sizeof(defaultpsk) - 1;
|
|
*last = *last + pskIndex - 1; // index of 1 means no change vs defaultPSK
|
|
}
|
|
}
|
|
|
|
// Tell our crypto engine about the psk
|
|
crypto->setKey(activePSKSize, activePSK);
|
|
|
|
// temp hack for quicker testing
|
|
// devicestate.no_save = true;
|
|
if (devicestate.no_save) {
|
|
DEBUG_MSG("***** DEVELOPMENT MODE - DO NOT RELEASE *****\n");
|
|
|
|
// Sleep quite frequently to stress test the BLE comms, broadcast position every 6 mins
|
|
radioConfig.preferences.screen_on_secs = 10;
|
|
radioConfig.preferences.wait_bluetooth_secs = 10;
|
|
radioConfig.preferences.position_broadcast_secs = 6 * 60;
|
|
radioConfig.preferences.ls_secs = 60;
|
|
radioConfig.preferences.region = RegionCode_TW;
|
|
|
|
// Enter super deep sleep soon and stay there not very long
|
|
// radioConfig.preferences.mesh_sds_timeout_secs = 10;
|
|
// radioConfig.preferences.sds_secs = 60;
|
|
}
|
|
|
|
// Update the global myRegion
|
|
initRegion();
|
|
|
|
return didFactoryReset;
|
|
}
|
|
|
|
void NodeDB::installDefaultDeviceState()
|
|
{
|
|
// We try to preserve the region setting because it will really bum users out if we discard it
|
|
String oldRegion = myNodeInfo.region;
|
|
RegionCode oldRegionCode = radioConfig.preferences.region;
|
|
|
|
memset(&devicestate, 0, sizeof(devicestate));
|
|
|
|
*numNodes = 0; // Forget node DB
|
|
|
|
// init our devicestate with valid flags so protobuf writing/reading will work
|
|
devicestate.has_my_node = true;
|
|
devicestate.has_radio = true;
|
|
devicestate.has_owner = true;
|
|
devicestate.radio.has_channel_settings = true;
|
|
devicestate.radio.has_preferences = true;
|
|
devicestate.node_db_count = 0;
|
|
devicestate.receive_queue_count = 0; // Not yet implemented FIXME
|
|
|
|
resetRadioConfig();
|
|
|
|
// default to no GPS, until one has been found by probing
|
|
myNodeInfo.has_gps = false;
|
|
myNodeInfo.message_timeout_msec = FLOOD_EXPIRE_TIME;
|
|
generatePacketId(); // FIXME - ugly way to init current_packet_id;
|
|
|
|
// Init our blank owner info to reasonable defaults
|
|
getMacAddr(ourMacAddr);
|
|
sprintf(owner.id, "!%02x%02x%02x%02x%02x%02x", ourMacAddr[0], ourMacAddr[1], ourMacAddr[2], ourMacAddr[3], ourMacAddr[4],
|
|
ourMacAddr[5]);
|
|
memcpy(owner.macaddr, ourMacAddr, sizeof(owner.macaddr));
|
|
|
|
// Set default owner name
|
|
pickNewNodeNum(); // Note: we will repick later, just in case the settings are corrupted, but we need a valid
|
|
// owner.short_name now
|
|
sprintf(owner.long_name, "Unknown %02x%02x", ourMacAddr[4], ourMacAddr[5]);
|
|
sprintf(owner.short_name, "?%02X", (unsigned)(myNodeInfo.my_node_num & 0xff));
|
|
|
|
// Restore region if possible
|
|
if (oldRegionCode != RegionCode_Unset)
|
|
radioConfig.preferences.region = oldRegionCode;
|
|
if (oldRegion.length())
|
|
strcpy(myNodeInfo.region, oldRegion.c_str());
|
|
}
|
|
|
|
void NodeDB::init()
|
|
{
|
|
installDefaultDeviceState();
|
|
|
|
// saveToDisk();
|
|
loadFromDisk();
|
|
// saveToDisk();
|
|
|
|
// We set node_num and packet_id _after_ loading from disk, because we always want to use the values this
|
|
// rom was compiled for, not what happens to be in the save file.
|
|
myNodeInfo.node_num_bits = sizeof(NodeNum) * 8;
|
|
myNodeInfo.packet_id_bits = sizeof(PacketId) * 8;
|
|
|
|
myNodeInfo.error_code = CriticalErrorCode_None; // For the error code, only show values from this boot (discard value from flash)
|
|
myNodeInfo.error_address = 0;
|
|
|
|
// likewise - we always want the app requirements to come from the running appload
|
|
myNodeInfo.min_app_version = 20120; // format is Mmmss (where M is 1+the numeric major number. i.e. 20120 means 1.1.20
|
|
|
|
// Note! We do this after loading saved settings, so that if somehow an invalid nodenum was stored in preferences we won't
|
|
// keep using that nodenum forever. Crummy guess at our nodenum (but we will check against the nodedb to avoid conflicts)
|
|
pickNewNodeNum();
|
|
|
|
// Include our owner in the node db under our nodenum
|
|
NodeInfo *info = getOrCreateNode(getNodeNum());
|
|
info->user = owner;
|
|
info->has_user = true;
|
|
|
|
// We set these _after_ loading from disk - because they come from the build and are more trusted than
|
|
// what is stored in flash
|
|
if (xstr(HW_VERSION)[0])
|
|
strncpy(myNodeInfo.region, optstr(HW_VERSION), sizeof(myNodeInfo.region));
|
|
else
|
|
DEBUG_MSG("This build does not specify a HW_VERSION\n"); // Eventually new builds will no longer include this build flag
|
|
|
|
// Check for the old style of region code strings, if found, convert to the new enum.
|
|
// Those strings will look like "1.0-EU433"
|
|
if (radioConfig.preferences.region == RegionCode_Unset && strncmp(myNodeInfo.region, "1.0-", 4) == 0) {
|
|
const char *regionStr = myNodeInfo.region + 4; // EU433 or whatever
|
|
for (const RegionInfo *r = regions; r->code != RegionCode_Unset; r++)
|
|
if (strcmp(r->name, regionStr) == 0) {
|
|
radioConfig.preferences.region = r->code;
|
|
break;
|
|
}
|
|
}
|
|
|
|
strncpy(myNodeInfo.firmware_version, optstr(APP_VERSION), sizeof(myNodeInfo.firmware_version));
|
|
strncpy(myNodeInfo.hw_model, HW_VENDOR, sizeof(myNodeInfo.hw_model));
|
|
|
|
resetRadioConfig(); // If bogus settings got saved, then fix them
|
|
|
|
DEBUG_MSG("legacy_region=%s, region=%d, NODENUM=0x%x, dbsize=%d\n", myNodeInfo.region, radioConfig.preferences.region,
|
|
myNodeInfo.my_node_num, *numNodes);
|
|
}
|
|
|
|
// We reserve a few nodenums for future use
|
|
#define NUM_RESERVED 4
|
|
|
|
/**
|
|
* get our starting (provisional) nodenum from flash.
|
|
*/
|
|
void NodeDB::pickNewNodeNum()
|
|
{
|
|
NodeNum r = myNodeInfo.my_node_num;
|
|
|
|
// If we don't have a nodenum at app - pick an initial nodenum based on the macaddr
|
|
if (r == 0)
|
|
r = (ourMacAddr[2] << 24) | (ourMacAddr[3] << 16) | (ourMacAddr[4] << 8) | ourMacAddr[5];
|
|
|
|
if (r == NODENUM_BROADCAST || r < NUM_RESERVED)
|
|
r = NUM_RESERVED; // don't pick a reserved node number
|
|
|
|
NodeInfo *found;
|
|
while ((found = getNode(r)) && memcmp(found->user.macaddr, owner.macaddr, sizeof(owner.macaddr))) {
|
|
NodeNum n = random(NUM_RESERVED, NODENUM_BROADCAST); // try a new random choice
|
|
DEBUG_MSG("NOTE! Our desired nodenum 0x%x is in use, so trying for 0x%x\n", r, n);
|
|
r = n;
|
|
}
|
|
|
|
myNodeInfo.my_node_num = r;
|
|
}
|
|
|
|
const char *preffile = "/db.proto";
|
|
const char *preftmp = "/db.proto.tmp";
|
|
|
|
void NodeDB::loadFromDisk()
|
|
{
|
|
#ifdef FS
|
|
// static DeviceState scratch; We no longer read into a tempbuf because this structure is 15KB of valuable RAM
|
|
|
|
auto f = FS.open(preffile);
|
|
if (f) {
|
|
DEBUG_MSG("Loading saved preferences\n");
|
|
pb_istream_t stream = {&readcb, &f, DeviceState_size};
|
|
|
|
// DEBUG_MSG("Preload channel name=%s\n", channelSettings.name);
|
|
|
|
memset(&devicestate, 0, sizeof(devicestate));
|
|
if (!pb_decode(&stream, DeviceState_fields, &devicestate)) {
|
|
DEBUG_MSG("Error: can't decode protobuf %s\n", PB_GET_ERROR(&stream));
|
|
installDefaultDeviceState(); // Our in RAM copy might now be corrupt
|
|
// FIXME - report failure to phone
|
|
} else {
|
|
if (devicestate.version < DEVICESTATE_MIN_VER) {
|
|
DEBUG_MSG("Warn: devicestate is old, discarding\n");
|
|
installDefaultDeviceState();
|
|
} else {
|
|
DEBUG_MSG("Loaded saved preferences version %d\n", devicestate.version);
|
|
}
|
|
|
|
// DEBUG_MSG("Postload channel name=%s\n", channelSettings.name);
|
|
}
|
|
|
|
f.close();
|
|
} else {
|
|
DEBUG_MSG("No saved preferences found\n");
|
|
}
|
|
|
|
#else
|
|
DEBUG_MSG("ERROR: Filesystem not implemented\n");
|
|
#endif
|
|
}
|
|
|
|
void NodeDB::saveToDisk()
|
|
{
|
|
#ifdef FS
|
|
if (!devicestate.no_save) {
|
|
auto f = FS.open(preftmp, FILE_O_WRITE);
|
|
if (f) {
|
|
DEBUG_MSG("Writing preferences\n");
|
|
|
|
pb_ostream_t stream = {&writecb, &f, SIZE_MAX, 0};
|
|
|
|
// DEBUG_MSG("Presave channel name=%s\n", channelSettings.name);
|
|
|
|
devicestate.version = DEVICESTATE_CUR_VER;
|
|
if (!pb_encode(&stream, DeviceState_fields, &devicestate)) {
|
|
DEBUG_MSG("Error: can't write protobuf %s\n", PB_GET_ERROR(&stream));
|
|
// FIXME - report failure to phone
|
|
|
|
f.close();
|
|
} else {
|
|
// Success - replace the old file
|
|
f.close();
|
|
|
|
// brief window of risk here ;-)
|
|
if (!FS.remove(preffile))
|
|
DEBUG_MSG("Warning: Can't remove old pref file\n");
|
|
if (!FS.rename(preftmp, preffile))
|
|
DEBUG_MSG("Error: can't rename new pref file\n");
|
|
}
|
|
} else {
|
|
DEBUG_MSG("ERROR: can't write prefs\n"); // FIXME report to app
|
|
}
|
|
} else {
|
|
DEBUG_MSG("***** DEVELOPMENT MODE - DO NOT RELEASE - not saving to flash *****\n");
|
|
}
|
|
#else
|
|
DEBUG_MSG("ERROR filesystem not implemented\n");
|
|
#endif
|
|
}
|
|
|
|
const NodeInfo *NodeDB::readNextInfo()
|
|
{
|
|
if (readPointer < *numNodes)
|
|
return &nodes[readPointer++];
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
/// Given a node, return how many seconds in the past (vs now) that we last heard from it
|
|
uint32_t sinceLastSeen(const NodeInfo *n)
|
|
{
|
|
uint32_t now = getTime();
|
|
|
|
uint32_t last_seen = n->position.time;
|
|
int delta = (int)(now - last_seen);
|
|
if (delta < 0) // our clock must be slightly off still - not set from GPS yet
|
|
delta = 0;
|
|
|
|
return delta;
|
|
}
|
|
|
|
#define NUM_ONLINE_SECS (60 * 2) // 2 hrs to consider someone offline
|
|
|
|
size_t NodeDB::getNumOnlineNodes()
|
|
{
|
|
size_t numseen = 0;
|
|
|
|
// FIXME this implementation is kinda expensive
|
|
for (int i = 0; i < *numNodes; i++)
|
|
if (sinceLastSeen(&nodes[i]) < NUM_ONLINE_SECS)
|
|
numseen++;
|
|
|
|
return numseen;
|
|
}
|
|
|
|
#include "MeshPlugin.h"
|
|
|
|
/** Update position info for this node based on received position data
|
|
*/
|
|
void NodeDB::updatePosition(uint32_t nodeId, const Position &p)
|
|
{
|
|
NodeInfo *info = getOrCreateNode(nodeId);
|
|
|
|
DEBUG_MSG("DB update position node=0x%x time=%u, latI=%d, lonI=%d\n", nodeId, p.time, p.latitude_i, p.longitude_i);
|
|
|
|
info->position = p;
|
|
info->has_position = true;
|
|
updateGUIforNode = info;
|
|
notifyObservers(true); // Force an update whether or not our node counts have changed
|
|
}
|
|
|
|
/** Update user info for this node based on received user data
|
|
*/
|
|
void NodeDB::updateUser(uint32_t nodeId, const User &p)
|
|
{
|
|
NodeInfo *info = getOrCreateNode(nodeId);
|
|
|
|
DEBUG_MSG("old user %s/%s/%s\n", info->user.id, info->user.long_name, info->user.short_name);
|
|
|
|
bool changed = memcmp(&info->user, &p,
|
|
sizeof(info->user)); // Both of these blocks start as filled with zero so I think this is okay
|
|
|
|
info->user = p;
|
|
DEBUG_MSG("updating changed=%d user %s/%s/%s\n", changed, info->user.id, info->user.long_name, info->user.short_name);
|
|
info->has_user = true;
|
|
|
|
if (changed) {
|
|
updateGUIforNode = info;
|
|
powerFSM.trigger(EVENT_NODEDB_UPDATED);
|
|
notifyObservers(true); // Force an update whether or not our node counts have changed
|
|
|
|
// Not really needed - we will save anyways when we go to sleep
|
|
// We just changed something important about the user, store our DB
|
|
// saveToDisk();
|
|
}
|
|
}
|
|
|
|
/// given a subpacket sniffed from the network, update our DB state
|
|
/// we updateGUI and updateGUIforNode if we think our this change is big enough for a redraw
|
|
void NodeDB::updateFrom(const MeshPacket &mp)
|
|
{
|
|
if (mp.which_payload == MeshPacket_decoded_tag) {
|
|
const SubPacket &p = mp.decoded;
|
|
DEBUG_MSG("Update DB node 0x%x, rx_time=%u\n", mp.from, mp.rx_time);
|
|
|
|
NodeInfo *info = getOrCreateNode(mp.from);
|
|
|
|
if (mp.rx_time) { // if the packet has a valid timestamp use it to update our last_seen
|
|
info->has_position = true; // at least the time is valid
|
|
info->position.time = mp.rx_time;
|
|
}
|
|
|
|
info->snr = mp.rx_snr; // keep the most recent SNR we received for this node.
|
|
|
|
switch (p.which_payload) {
|
|
case SubPacket_position_tag: {
|
|
// handle a legacy position packet
|
|
DEBUG_MSG("WARNING: Processing a (deprecated) position packet from %d\n", mp.from);
|
|
updatePosition(mp.from, p.position);
|
|
break;
|
|
}
|
|
|
|
case SubPacket_data_tag: {
|
|
if (mp.to == NODENUM_BROADCAST || mp.to == nodeDB.getNodeNum())
|
|
MeshPlugin::callPlugins(mp);
|
|
break;
|
|
}
|
|
|
|
case SubPacket_user_tag: {
|
|
DEBUG_MSG("WARNING: Processing a (deprecated) user packet from %d\n", mp.from);
|
|
updateUser(mp.from, p.user);
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
notifyObservers(); // If the node counts have changed, notify observers
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Find a node in our DB, return null for missing
|
|
/// NOTE: This function might be called from an ISR
|
|
NodeInfo *NodeDB::getNode(NodeNum n)
|
|
{
|
|
for (int i = 0; i < *numNodes; i++)
|
|
if (nodes[i].num == n)
|
|
return &nodes[i];
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/// Find a node in our DB, create an empty NodeInfo if missing
|
|
NodeInfo *NodeDB::getOrCreateNode(NodeNum n)
|
|
{
|
|
NodeInfo *info = getNode(n);
|
|
|
|
if (!info) {
|
|
// add the node
|
|
assert(*numNodes < MAX_NUM_NODES);
|
|
info = &nodes[(*numNodes)++];
|
|
|
|
// everything is missing except the nodenum
|
|
memset(info, 0, sizeof(*info));
|
|
info->num = n;
|
|
}
|
|
|
|
return info;
|
|
}
|
|
|
|
/// Record an error that should be reported via analytics
|
|
void recordCriticalError(CriticalErrorCode code, uint32_t address)
|
|
{
|
|
DEBUG_MSG("NOTE! Recording critical error %d, address=%x\n", code, address);
|
|
myNodeInfo.error_code = code;
|
|
myNodeInfo.error_address = address;
|
|
myNodeInfo.error_count++;
|
|
}
|