Merge pull request #73 from meshtastic/master

pulling 1.2 into my fork

src/esp32/ESP32CryptoEngine.cpp

@@ -18,9 +18,6 @@ class ESP32CryptoEngine : public CryptoEngine
 
     mbedtls_aes_context aes;
 
-    /// How many bytes in our key
-    uint8_t keySize = 0;
-
   public:
     ESP32CryptoEngine() { mbedtls_aes_init(&aes); }
 
@@ -35,12 +32,12 @@ class ESP32CryptoEngine : public CryptoEngine
      * @param bytes a _static_ buffer that will remain valid for the life of this crypto instance (i.e. this class will cache the
      * provided pointer)
      */
-    virtual void setKey(size_t numBytes, uint8_t *bytes)
+    virtual void setKey(const CryptoKey &k)
     {
-        keySize = numBytes;
-        DEBUG_MSG("Installing AES%d key!\n", numBytes * 8);
-        if (numBytes != 0) {
-            auto res = mbedtls_aes_setkey_enc(&aes, bytes, numBytes * 8);
+        CryptoEngine::setKey(k);
+
+        if (key.length != 0) {
+            auto res = mbedtls_aes_setkey_enc(&aes, key.bytes, key.length * 8);
             assert(!res);
         }
     }
@@ -52,7 +49,7 @@ class ESP32CryptoEngine : public CryptoEngine
      */
     virtual void encrypt(uint32_t fromNode, uint64_t packetNum, size_t numBytes, uint8_t *bytes)
     {
-        if (keySize != 0) {
+        if (key.length > 0) {
             uint8_t stream_block[16];
             static uint8_t scratch[MAX_BLOCKSIZE];
             size_t nc_off = 0;

src/graphics/Screen.cpp

@@ -32,6 +32,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "main.h"
 #include "mesh-pb-constants.h"
 #include "plugins/TextMessagePlugin.h"
+#include "mesh/Channels.h"
 #include "target_specific.h"
 #include "utils.h"
 
@@ -243,8 +244,7 @@ static void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state
 
     // the max length of this buffer is much longer than we can possibly print
     static char tempBuf[96];
-    assert(mp.decoded.which_payloadVariant == SubPacket_data_tag);
-    snprintf(tempBuf, sizeof(tempBuf), "         %s", mp.decoded.data.payload.bytes);
+    snprintf(tempBuf, sizeof(tempBuf), "         %s", mp.decoded.payload.bytes);
 
     display->drawStringMaxWidth(4 + x, 10 + y, SCREEN_WIDTH - (6 + x), tempBuf);
 }
@@ -818,9 +818,6 @@ int32_t Screen::runOnce()
         showingBootScreen = false;
     }
 
-    // Update the screen last, after we've figured out what to show.
-    debug_info()->setChannelNameStatus(getChannelName());
-
     // Process incoming commands.
     for (;;) {
         ScreenCmd cmd;
@@ -1069,7 +1066,8 @@ void DebugInfo::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
     char channelStr[20];
     {
         concurrency::LockGuard guard(&lock);
-        snprintf(channelStr, sizeof(channelStr), "%s", channelName.c_str());
+        auto chName = channels.getPrimaryName();
+        snprintf(channelStr, sizeof(channelStr), "%s", chName);
     }
 
     // Display power status
@@ -1276,8 +1274,8 @@ void DebugInfo::drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *stat
         display->drawString(x, y, String("USB"));
     }
 
-    display->drawString(x + SCREEN_WIDTH - display->getStringWidth("Mode " + String(channelSettings.modem_config)), y,
-                        "Mode " + String(channelSettings.modem_config));
+    auto mode = "Mode " + String(channels.getPrimary().modem_config);
+    display->drawString(x + SCREEN_WIDTH - display->getStringWidth(mode), y, mode);
 
     // Line 2
     uint32_t currentMillis = millis();

src/graphics/Screen.h

@@ -39,13 +39,6 @@ class DebugInfo
     DebugInfo(const DebugInfo &) = delete;
     DebugInfo &operator=(const DebugInfo &) = delete;
 
-    /// Sets the name of the channel.
-    void setChannelNameStatus(const char *name)
-    {
-        concurrency::LockGuard guard(&lock);
-        channelName = name;
-    }
-
   private:
     friend Screen;
 
@@ -56,8 +49,6 @@ class DebugInfo
     void drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
     void drawFrameWiFi(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
 
-    std::string channelName;
-
     /// Protects all of internal state.
     concurrency::Lock lock;
 };

src/main.cpp

@@ -359,7 +359,7 @@ void setup()
 #endif
 
     // Hello
-    DEBUG_MSG("Meshtastic swver=%s, hwver=%s\n", optstr(APP_VERSION), optstr(HW_VERSION));
+    DEBUG_MSG("Meshtastic hwvendor=%s, swver=%s, hwver=%s\n", HW_VENDOR, optstr(APP_VERSION), optstr(HW_VERSION));
 
 #ifndef NO_ESP32
     // Don't init display if we don't have one or we are waking headless due to a timer event

src/mesh/Channels.cpp

@@ -0,0 +1,296 @@
+#include "Channels.h"
+#include "CryptoEngine.h"
+#include "NodeDB.h"
+
+#include <assert.h>
+
+/// 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};
+
+Channels channels;
+
+uint8_t xorHash(const uint8_t *p, size_t len)
+{
+    uint8_t code = 0;
+    for (int i = 0; i < len; i++)
+        code ^= p[i];
+    return code;
+}
+
+/** Given a channel number, return the (0 to 255) hash for that channel.
+ * The hash is just an xor of the channel name followed by the channel PSK being used for encryption
+ * If no suitable channel could be found, return -1
+ */
+int16_t Channels::generateHash(ChannelIndex channelNum)
+{
+    auto k = getKey(channelNum);
+    if (k.length < 0)
+        return -1; // invalid
+    else {
+        const char *name = getName(channelNum);
+        uint8_t h = xorHash((const uint8_t *) name, strlen(name));
+
+        h ^= xorHash(k.bytes, k.length);
+
+        return h;
+    }
+}
+
+/**
+ * Validate a channel, fixing any errors as needed
+ */
+Channel &Channels::fixupChannel(ChannelIndex chIndex)
+{
+    Channel &ch = getByIndex(chIndex);
+
+    ch.index = chIndex; // Preinit the index so it be ready to share with the phone (we'll never change it later)
+
+    if (!ch.has_settings) {
+        // No settings! Must disable and skip
+        ch.role = Channel_Role_DISABLED;
+        memset(&ch.settings, 0, sizeof(ch.settings));
+        ch.has_settings = true;
+    } else {
+        ChannelSettings &channelSettings = ch.settings;
+
+        // Convert the old string "Default" to our new short representation
+        if (strcmp(channelSettings.name, "Default") == 0)
+            *channelSettings.name = '\0';
+
+        /* 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;
+        } */
+    }
+
+    hashes[chIndex] = generateHash(chIndex);
+
+    return ch;
+}
+
+/**
+ * Write a default channel to the specified channel index
+ */
+void Channels::initDefaultChannel(ChannelIndex chIndex)
+{
+    Channel &ch = getByIndex(chIndex);
+    ChannelSettings &channelSettings = ch.settings;
+
+    // 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, "");
+
+    ch.has_settings = true;
+    ch.role = Channel_Role_PRIMARY;
+}
+
+CryptoKey Channels::getKey(ChannelIndex chIndex)
+{
+    Channel &ch = getByIndex(chIndex);
+    ChannelSettings &channelSettings = ch.settings;
+    assert(ch.has_settings);
+
+    CryptoKey k;
+    memset(k.bytes, 0, sizeof(k.bytes)); // In case the user provided a short key, we want to pad the rest with zeros
+
+    if (ch.role == Channel_Role_DISABLED) {
+        k.length = -1; // invalid
+    } else {
+        memcpy(k.bytes, channelSettings.psk.bytes, channelSettings.psk.size);
+        k.length = channelSettings.psk.size;
+        if (k.length == 0) {
+            if (ch.role == Channel_Role_SECONDARY) {
+                DEBUG_MSG("Unset PSK for secondary channel %s. using primary key\n", ch.settings.name);
+                k = getKey(primaryIndex);
+            } else
+                DEBUG_MSG("Warning: User disabled encryption\n");
+        } else if (k.length == 1) {
+            // Convert the short single byte variants of psk into variant that can be used more generally
+
+            uint8_t pskIndex = k.bytes[0];
+            DEBUG_MSG("Expanding short PSK #%d\n", pskIndex);
+            if (pskIndex == 0)
+                k.length = 0; // Turn off encryption
+            else {
+                memcpy(k.bytes, defaultpsk, sizeof(defaultpsk));
+                k.length = sizeof(defaultpsk);
+                // Bump up the last byte of PSK as needed
+                uint8_t *last = k.bytes + sizeof(defaultpsk) - 1;
+                *last = *last + pskIndex - 1; // index of 1 means no change vs defaultPSK
+            }
+        } else if (k.length < 16) {
+            // Error! The user specified only the first few bits of an AES128 key.  So by convention we just pad the rest of the
+            // key with zeros
+            DEBUG_MSG("Warning: User provided a too short AES128 key - padding\n");
+            k.length = 16;
+        } else if (k.length < 32 && k.length != 16) {
+            // Error! The user specified only the first few bits of an AES256 key.  So by convention we just pad the rest of the
+            // key with zeros
+            DEBUG_MSG("Warning: User provided a too short AES256 key - padding\n");
+            k.length = 32;
+        }
+    }
+
+    return k;
+}
+
+/** Given a channel index, change to use the crypto key specified by that index
+ */
+int16_t Channels::setCrypto(ChannelIndex chIndex)
+{
+    CryptoKey k = getKey(chIndex);
+
+    if (k.length < 0)
+        return -1;
+    else {
+        // Tell our crypto engine about the psk
+        crypto->setKey(k);
+        return getHash(chIndex);
+    }
+}
+
+void Channels::initDefaults()
+{
+    devicestate.channels_count = MAX_NUM_CHANNELS;
+    for (int i = 0; i < devicestate.channels_count; i++)
+        fixupChannel(i);
+    initDefaultChannel(0);
+}
+
+void Channels::onConfigChanged()
+{
+    // Make sure the phone hasn't mucked anything up
+    for (int i = 0; i < devicestate.channels_count; i++) {
+        Channel &ch = fixupChannel(i);
+
+        if (ch.role == Channel_Role_PRIMARY)
+            primaryIndex = i;
+    }
+}
+
+Channel &Channels::getByIndex(ChannelIndex chIndex)
+{
+    assert(chIndex < devicestate.channels_count);
+    Channel *ch = devicestate.channels + chIndex;
+    return *ch;
+}
+
+void Channels::setChannel(const Channel &c)
+{
+    Channel &old = getByIndex(c.index);
+
+    // if this is the new primary, demote any existing roles
+    if (c.role == Channel_Role_PRIMARY)
+        for (int i = 0; i < getNumChannels(); i++)
+            if (devicestate.channels[i].role == Channel_Role_PRIMARY)
+                devicestate.channels[i].role = Channel_Role_SECONDARY;
+
+    old = c; // slam in the new settings/role
+}
+
+const char *Channels::getName(size_t chIndex)
+{
+    // Convert the short "" representation for Default into a usable string
+    ChannelSettings &channelSettings = getByIndex(chIndex).settings;
+    const char *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
+
+        if (channelSettings.bandwidth != 0)
+            channelName = "Unset";
+        else
+            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;
+            }
+    }
+
+    return channelName;
+}
+
+/**
+* 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,
+*
+* 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 *Channels::getPrimaryName()
+{
+    static char buf[32];
+
+    char suffix;
+    // auto channelSettings = getPrimary();
+    // if (channelSettings.psk.size != 1) {
+    // We have a standard PSK, so generate a letter based hash.
+    uint8_t code = getHash(primaryIndex);
+
+    suffix = 'A' + (code % 26);
+    /* } else {
+        suffix = '0' + channelSettings.psk.bytes[0];
+    } */
+
+    snprintf(buf, sizeof(buf), "#%s-%c", getName(primaryIndex), suffix);
+    return buf;
+}
+
+/** Given a channel hash setup crypto for decoding that channel (or the primary channel if that channel is unsecured)
+ *
+ * This method is called before decoding inbound packets
+ *
+ * @return false if the channel hash or channel is invalid
+ */
+bool Channels::decryptForHash(ChannelIndex chIndex, ChannelHash channelHash)
+{
+    if(chIndex > getNumChannels() || getHash(chIndex) != channelHash) {
+        DEBUG_MSG("Skipping channel %d due to invalid hash/index\n", chIndex);
+        return false;
+    }
+    else {
+        setCrypto(chIndex);
+        return true;
+    }
+}
+
+/** Given a channel index setup crypto for encoding that channel (or the primary channel if that channel is unsecured)
+ *
+ * This method is called before encoding outbound packets
+ *
+ * @eturn the (0 to 255) hash for that channel - if no suitable channel could be found, return -1
+ */
+int16_t Channels::setActiveByIndex(ChannelIndex channelIndex)
+{
+    return setCrypto(channelIndex);
+}

src/mesh/Channels.h

@@ -0,0 +1,127 @@
+#pragma once
+
+#include "CryptoEngine.h"
+#include "NodeDB.h"
+#include "mesh-pb-constants.h"
+#include <Arduino.h>
+
+/** A channel number (index into the channel table)
+ */
+typedef uint8_t ChannelIndex;
+
+/** A low quality hash of the channel PSK and the channel name.  created by generateHash(chIndex)
+ * Used as a hint to limit which PSKs are considered for packet decoding.
+ */
+typedef uint8_t ChannelHash;
+
+/** The container/on device API for working with channels */
+class Channels
+{
+    /// The index of the primary channel
+    ChannelIndex primaryIndex = 0;
+
+    /** The channel index that was requested for sending/receving.  Note: if this channel is a secondary
+    channel and does not have a PSK, we will use the PSK from the primary channel.  If this channel is disabled
+    no sending or receiving will be allowed */
+    ChannelIndex activeChannelIndex = 0;
+
+    /// the precomputed hashes for each of our channels, or -1 for invalid
+    int16_t hashes[MAX_NUM_CHANNELS];
+
+  public:
+    const ChannelSettings &getPrimary() { return getByIndex(getPrimaryIndex()).settings; }
+
+    /** Return the Channel for a specified index */
+    Channel &getByIndex(ChannelIndex chIndex);
+
+    /** Using the index inside the channel, update the specified channel's settings and role.  If this channel is being promoted
+     * to be primary, force all other channels to be secondary.
+     */
+    void setChannel(const Channel &c);
+
+    const char *getName(size_t chIndex);
+
+    /** The index of the primary channel */
+    ChannelIndex getPrimaryIndex() const { return primaryIndex; }
+
+    ChannelIndex getNumChannels() { return devicestate.channels_count; }
+
+    /**
+     * 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 *getPrimaryName();
+
+    /// Called by NodeDB on initial boot when the radio config settings are unset.  Set a default single channel config.
+    void initDefaults();
+
+    /// called when the user has just changed our radio config and we might need to change channel keys
+    void onConfigChanged();
+
+    /** Given a channel hash setup crypto for decoding that channel (or the primary channel if that channel is unsecured)
+     *
+     * This method is called before decoding inbound packets
+     *
+     * @return false if the channel hash or channel is invalid
+     */
+    bool decryptForHash(ChannelIndex chIndex, ChannelHash channelHash);
+
+    /** Given a channel index setup crypto for encoding that channel (or the primary channel if that channel is unsecured)
+     *
+     * This method is called before encoding outbound packets
+     *
+     * @eturn the (0 to 255) hash for that channel - if no suitable channel could be found, return -1
+     */
+    int16_t setActiveByIndex(ChannelIndex channelIndex);
+
+  private:
+    /** Given a channel index, change to use the crypto key specified by that index
+     *
+     * @eturn the (0 to 255) hash for that channel - if no suitable channel could be found, return -1
+     */
+    int16_t setCrypto(ChannelIndex chIndex);
+
+    /** Return the channel index for the specified channel hash, or -1 for not found */
+    int8_t getIndexByHash(ChannelHash channelHash);
+
+    /** Given a channel number, return the (0 to 255) hash for that channel
+     * If no suitable channel could be found, return -1
+     *
+     * called by fixupChannel when a new channel is set
+     */
+    int16_t generateHash(ChannelIndex channelNum);
+
+    int16_t getHash(ChannelIndex i) { return hashes[i]; }
+
+    /**
+     * Validate a channel, fixing any errors as needed
+     */
+    Channel &fixupChannel(ChannelIndex chIndex);
+
+    /**
+     * Write a default channel to the specified channel index
+     */
+    void initDefaultChannel(ChannelIndex chIndex);
+
+    /**
+     * Return the key used for encrypting this channel (if channel is secondary and no key provided, use the primary channel's
+     * PSK)
+     */
+    CryptoKey getKey(ChannelIndex chIndex);
+};
+
+/// Singleton channel table
+extern Channels channels;

src/mesh/CryptoEngine.cpp

@@ -1,9 +1,10 @@
 #include "CryptoEngine.h"
 #include "configuration.h"
 
-void CryptoEngine::setKey(size_t numBytes, uint8_t *bytes)
+void CryptoEngine::setKey(const CryptoKey &k)
 {
-    DEBUG_MSG("WARNING: Using stub crypto - all crypto is sent in plaintext!\n");
+    DEBUG_MSG("Installing AES%d key!\n", k.length * 8);
+    key = k;
 }
 
 /**

src/mesh/CryptoEngine.h

@@ -2,6 +2,13 @@
 
 #include <Arduino.h>
 
+struct CryptoKey {
+    uint8_t bytes[32];
+
+    /// # of bytes, or -1 to mean "invalid key - do not use"
+    int8_t length;
+};
+
 /**
  * see docs/software/crypto.md for details.
  *
@@ -15,6 +22,8 @@ class CryptoEngine
     /** Our per packet nonce */
     uint8_t nonce[16];
 
+    CryptoKey key;
+
   public:
     virtual ~CryptoEngine() {}
 
@@ -27,7 +36,7 @@ class CryptoEngine
      * @param bytes a _static_ buffer that will remain valid for the life of this crypto instance (i.e. this class will cache the
      * provided pointer)
      */
-    virtual void setKey(size_t numBytes, uint8_t *bytes);
+    virtual void setKey(const CryptoKey &k);
 
     /**
      * Encrypt a packet

src/mesh/DSRRouter.cpp

@@ -62,7 +62,7 @@ ErrorCode DSRRouter::send(MeshPacket *p)
         return ReliableRouter::send(p);
 }
 
-void DSRRouter::sniffReceived(const MeshPacket *p)
+void DSRRouter::sniffReceived(const MeshPacket *p, const Routing *c)
 {
     // Learn 0 hop routes by just hearing any adjacent nodes
     // But treat broadcasts carefully, because when flood broadcasts go out they keep the same original "from".  So we want to
@@ -72,47 +72,49 @@ void DSRRouter::sniffReceived(const MeshPacket *p)
         addRoute(p->from, p->from, 0); // We are adjacent with zero hops
     }
 
-    switch (p->decoded.which_payloadVariant) {
-    case SubPacket_route_request_tag:
-        // Handle route discovery packets (will be a broadcast message)
-        // FIXME - always start request with the senders nodenum
-        if (weAreInRoute(p->decoded.route_request)) {
-            DEBUG_MSG("Ignoring a route request that contains us\n");
-        } else {
-            updateRoutes(p->decoded.route_request,
-                         true); // Update our routing tables based on the route that came in so far on this request
-
-            if (p->decoded.dest == getNodeNum()) {
-                // They were looking for us, send back a route reply (the sender address will be first in the list)
-                sendRouteReply(p->decoded.route_request);
+    if (c)
+        switch (c->which_variant) {
+        case Routing_route_request_tag:
+            // Handle route discovery packets (will be a broadcast message)
+            // FIXME - always start request with the senders nodenum
+            if (weAreInRoute(c->route_request)) {
+                DEBUG_MSG("Ignoring a route request that contains us\n");
             } else {
-                // They were looking for someone else, forward it along (as a zero hop broadcast)
-                NodeNum nextHop = getNextHop(p->decoded.dest);
-                if (nextHop) {
-                    // in our route cache, reply to the requester (the sender address will be first in the list)
-                    sendRouteReply(p->decoded.route_request, nextHop);
+                updateRoutes(c->route_request,
+                             true); // Update our routing tables based on the route that came in so far on this request
+
+                if (p->decoded.dest == getNodeNum()) {
+                    // They were looking for us, send back a route reply (the sender address will be first in the list)
+                    sendRouteReply(c->route_request);
                 } else {
-                    // Not in our route cache, rebroadcast on their behalf (after adding ourselves to the request route)
-                    resendRouteRequest(p);
+                    // They were looking for someone else, forward it along (as a zero hop broadcast)
+                    NodeNum nextHop = getNextHop(p->decoded.dest);
+                    if (nextHop) {
+                        // in our route cache, reply to the requester (the sender address will be first in the list)
+                        sendRouteReply(c->route_request, nextHop);
+                    } else {
+                        // Not in our route cache, rebroadcast on their behalf (after adding ourselves to the request route)
+                        resendRouteRequest(p);
+                    }
                 }
             }
+            break;
+        case Routing_route_reply_tag:
+            updateRoutes(c->route_reply, false);
+
+            // FIXME, if any of our current pending packets were waiting for this route, send them (and leave them as regular
+            // pending packets until ack arrives)
+            // FIXME, if we don't get a route reply at all (or a route error), timeout and generate a routeerror TIMEOUT on our
+            // own...
+            break;
+        case Routing_error_reason_tag:
+            removeRoute(p->decoded.dest);
+
+            // FIXME: if any pending packets were waiting on this route, delete them
+            break;
+        default:
+            break;
         }
-        break;
-    case SubPacket_route_reply_tag:
-        updateRoutes(p->decoded.route_reply, false);
-
-        // FIXME, if any of our current pending packets were waiting for this route, send them (and leave them as regular pending
-        // packets until ack arrives)
-        // FIXME, if we don't get a route reply at all (or a route error), timeout and generate a routeerror TIMEOUT on our own...
-        break;
-    case SubPacket_error_reason_tag:
-        removeRoute(p->decoded.dest);
-
-        // FIXME: if any pending packets were waiting on this route, delete them
-        break;
-    default:
-        break;
-    }
 
     // We simply ignore ACKs - because ReliableRouter will delete the pending packet for us
 
@@ -131,26 +133,29 @@ void DSRRouter::sniffReceived(const MeshPacket *p)
                 assert(p->decoded.source); // I think this is guaranteed by now
 
                 // FIXME - what if the current packet _is_ a route error packet?
-                sendRouteError(p, ErrorReason_NO_ROUTE);
+                sendRouteError(p, Routing_Error_NO_ROUTE);
             }
 
             // FIXME, stop local processing of this packet
         }
 
-        // handle naks - convert them to route error packets
-        // All naks are generated locally, because we failed resending the packet too many times
-        PacketId nakId = p->decoded.which_ackVariant == SubPacket_fail_id_tag ? p->decoded.ackVariant.fail_id : 0;
-        if (nakId) {
-            auto pending = findPendingPacket(p->to, nakId);
-            if (pending && pending->packet->decoded.source) { // if source not set, this was not a multihop packet, just ignore
-                removeRoute(pending->packet->decoded.dest);   // We no longer have a route to the specified node
+        if (c) {
+            // handle naks - convert them to route error packets
+            // All naks are generated locally, because we failed resending the packet too many times
+            PacketId nakId = c->error_reason ? p->decoded.request_id : 0;
+            if (nakId) {
+                auto pending = findPendingPacket(p->to, nakId);
+                if (pending &&
+                    pending->packet->decoded.source) {          // if source not set, this was not a multihop packet, just ignore
+                    removeRoute(pending->packet->decoded.dest); // We no longer have a route to the specified node
 
-                sendRouteError(p, ErrorReason_GOT_NAK);
+                    sendRouteError(p, Routing_Error_GOT_NAK);
+                }
             }
         }
     }
 
-    return ReliableRouter::sniffReceived(p);
+    ReliableRouter::sniffReceived(p, c);
 }
 
 /**
@@ -230,7 +235,7 @@ void DSRRouter::sendNextHop(NodeNum n, const MeshPacket *p)
 /**
  * Send a route error packet towards whoever originally sent this message
  */
-void DSRRouter::sendRouteError(const MeshPacket *p, ErrorReason err)
+void DSRRouter::sendRouteError(const MeshPacket *p, Routing_Error err)
 {
     DEBUG_MSG("FIXME not implemented sendRouteError\n");
 }

src/mesh/DSRRouter.h

@@ -8,7 +8,7 @@ class DSRRouter : public ReliableRouter
      * Every (non duplicate) packet this node receives will be passed through this method.  This allows subclasses to
      * update routing tables etc... based on what we overhear (even for messages not destined to our node)
      */
-    virtual void sniffReceived(const MeshPacket *p);
+    virtual void sniffReceived(const MeshPacket *p, const Routing *c);
 
     /**
      * Send a packet on a suitable interface.  This routine will
@@ -70,7 +70,7 @@ class DSRRouter : public ReliableRouter
     /**
      * Send a route error packet towards whoever originally sent this message
      */
-    void sendRouteError(const MeshPacket *p, ErrorReason err);
+    void sendRouteError(const MeshPacket *p, Routing_Error err);
 
     /** make a copy of p, start discovery, but only if we don't
      *  already a discovery in progress for that node number.  Caller has already scheduled this message for retransmission

src/mesh/FloodingRouter.cpp

@@ -27,11 +27,11 @@ bool FloodingRouter::shouldFilterReceived(const MeshPacket *p)
     return Router::shouldFilterReceived(p);
 }
 
-void FloodingRouter::sniffReceived(const MeshPacket *p)
+void FloodingRouter::sniffReceived(const MeshPacket *p, const Routing *c)
 {
     // If a broadcast, possibly _also_ send copies out into the mesh.
     // (FIXME, do something smarter than naive flooding here)
-    if (p->to == NODENUM_BROADCAST && p->hop_limit > 0) {
+    if (p->to == NODENUM_BROADCAST && p->hop_limit > 0 && p->from != getNodeNum()) {
         if (p->id != 0) {
             MeshPacket *tosend = packetPool.allocCopy(*p); // keep a copy because we will be sending it
 
@@ -48,5 +48,5 @@ void FloodingRouter::sniffReceived(const MeshPacket *p)
     }
 
     // handle the packet as normal
-    Router::sniffReceived(p);
+    Router::sniffReceived(p, c);
 }

src/mesh/FloodingRouter.h

@@ -55,5 +55,5 @@ class FloodingRouter : public Router, protected PacketHistory
     /**
      * Look for broadcasts we need to rebroadcast
      */
-    virtual void sniffReceived(const MeshPacket *p);
+    virtual void sniffReceived(const MeshPacket *p, const Routing *c);
 };

src/mesh/MeshPacketQueue.cpp

@@ -33,7 +33,7 @@ void fixPriority(MeshPacket *p)
     if (p->priority == MeshPacket_Priority_UNSET) {
         // if acks give high priority
         // if a reliable message give a bit higher default priority
-        p->priority = p->decoded.which_ackVariant ? MeshPacket_Priority_ACK :                
+        p->priority = (p->decoded.portnum == PortNum_ROUTING_APP) ? MeshPacket_Priority_ACK :                
                           (p->want_ack ? MeshPacket_Priority_RELIABLE : MeshPacket_Priority_DEFAULT);
     }
 }

src/mesh/MeshPlugin.cpp

@@ -28,29 +28,48 @@ void MeshPlugin::callPlugins(const MeshPacket &mp)
 {
     // DEBUG_MSG("In call plugins\n");
     bool pluginFound = false;
+
+    assert(mp.which_payloadVariant == MeshPacket_decoded_tag); // I think we are guarnteed the packet is decoded by this point?
+
+    // Was this message directed to us specifically?  Will be false if we are sniffing someone elses packets
+    auto ourNodeNum = nodeDB.getNodeNum();
+    bool toUs = mp.to == NODENUM_BROADCAST || mp.to == ourNodeNum;
     for (auto i = plugins->begin(); i != plugins->end(); ++i) {
         auto &pi = **i;
 
         pi.currentRequest = ∓
-        if (pi.wantPortnum(mp.decoded.data.portnum)) {
+
+        // We only call plugins that are interested in the packet (and the message is destined to us or we are promiscious)
+        bool wantsPacket = (pi.isPromiscuous || toUs) && pi.wantPacket(&mp);
+        // DEBUG_MSG("Plugin %s wantsPacket=%d\n", pi.name, wantsPacket);
+        if (wantsPacket) {
             pluginFound = true;
 
             bool handled = pi.handleReceived(mp);
 
-            // Possibly send replies
-            if (mp.decoded.want_response)
-                pi.sendResponse(mp);
+            // Possibly send replies (but only if the message was directed to us specifically, i.e. not for promiscious sniffing)
 
-            DEBUG_MSG("Plugin %s handled=%d\n", pi.name, handled);
-            if (handled)
+            // NOTE: we send a reply *even if the (non broadcast) request was from us* which is unfortunate but necessary because currently when the phone 
+            // sends things, it sends things using the local node ID as the from address.  A better solution (FIXME) would be to let phones
+            // have their own distinct addresses and we 'route' to them like any other node.
+            if (mp.decoded.want_response && toUs && (mp.from != ourNodeNum || mp.to == ourNodeNum)) {
+                pi.sendResponse(mp);
+                DEBUG_MSG("Plugin %s sent a response\n", pi.name);
+            }
+            else {
+                DEBUG_MSG("Plugin %s considered\n", pi.name);
+            }
+            if (handled) {
+                DEBUG_MSG("Plugin %s handled and skipped other processing\n", pi.name);
                 break;
+            }
         }
        
         pi.currentRequest = NULL;
     }
 
     if(!pluginFound)
-        DEBUG_MSG("No plugins interested in portnum=%d\n", mp.decoded.data.portnum);
+        DEBUG_MSG("No plugins interested in portnum=%d\n", mp.decoded.portnum);
 }
 
 /** Messages can be received that have the want_response bit set.  If set, this callback will be invoked
@@ -65,7 +84,8 @@ void MeshPlugin::sendResponse(const MeshPacket &req) {
         service.sendToMesh(r);
     }
     else {
-        DEBUG_MSG("WARNING: Client requested response but this plugin did not provide\n");
+        // Ignore - this is now expected behavior for routing plugin (because it ignores some replies)
+        // DEBUG_MSG("WARNING: Client requested response but this plugin did not provide\n");
     }
 }
 
@@ -73,8 +93,10 @@ void MeshPlugin::sendResponse(const MeshPacket &req) {
  * This ensures that if the request packet was sent reliably, the reply is sent that way as well.
 */
 void setReplyTo(MeshPacket *p, const MeshPacket &to) {
+    assert(p->which_payloadVariant == MeshPacket_decoded_tag); // Should already be set by now
     p->to = to.from;
     p->want_ack = to.want_ack;
+    p->decoded.request_id = to.id;
 }
 
 std::vector<MeshPlugin *> MeshPlugin::GetMeshPluginsWithUIFrames() {

src/mesh/MeshPlugin.h

@@ -37,6 +37,12 @@ class MeshPlugin
   protected:
     const char *name;
 
+    /* Most plugins only care about packets that are destined for their node (i.e. broadcasts or has their node as the specific recipient)
+    But some plugs might want to 'sniff' packets that are merely being routed (passing through the current node).  Those plugins can set this to
+    true and their handleReceived() will be called for every packet.
+    */
+    bool isPromiscuous = false;
+
     /**
      * If this plugin is currently handling a request currentRequest will be preset
      * to the packet with the request.  This is mostly useful for reply handlers.
@@ -55,7 +61,7 @@ class MeshPlugin
     /**
      * @return true if you want to receive the specified portnum
      */
-    virtual bool wantPortnum(PortNum p) = 0;
+    virtual bool wantPacket(const MeshPacket *p) = 0;
 
     /** Called to handle a particular incoming message
 

src/mesh/MeshService.cpp

@@ -65,7 +65,6 @@ void MeshService::init()
 
     if (gps)
         gpsObserver.observe(&gps->newStatus);
-    packetReceivedObserver.observe(&router->notifyPacketReceived);
 }
 
 

src/mesh/MeshService.h

@@ -19,8 +19,6 @@ class MeshService
 {
     CallbackObserver<MeshService, const meshtastic::GPSStatus *> gpsObserver =
         CallbackObserver<MeshService, const meshtastic::GPSStatus *>(this, &MeshService::onGPSChanged);
-    CallbackObserver<MeshService, const MeshPacket *> packetReceivedObserver =
-        CallbackObserver<MeshService, const MeshPacket *>(this, &MeshService::handleFromRadio);
 
     /// received packets waiting for the phone to process them
     /// FIXME, change to a DropOldestQueue and keep a count of the number of dropped packets to ensure
@@ -91,9 +89,10 @@ class MeshService
     /// returns 0 to allow futher processing
     int onGPSChanged(const meshtastic::GPSStatus *arg);
 
-    /// Handle a packet that just arrived from the radio.  This method does _not_ free the provided packet.  If it needs
+    /// Handle a packet that just arrived from the radio.  This method does _ReliableRouternot_ free the provided packet.  If it needs
     /// to keep the packet around it makes a copy
     int handleFromRadio(const MeshPacket *p);
+    friend class RoutingPlugin;
 };
 
 extern MeshService service;

src/mesh/MeshTypes.h

@@ -14,6 +14,8 @@ typedef uint32_t PacketId; // A packet sequence number
 #define ERRNO_NO_INTERFACES 33
 #define ERRNO_UNKNOWN 32 // pick something that doesn't conflict with RH_ROUTER_ERROR_UNABLE_TO_DELIVER
 #define ERRNO_DISABLED 34 // the itnerface is disabled
+#define ERRNO_TOO_LARGE 35
+#define ERRNO_NO_CHANNEL 36
 
 /**
  * the max number of hops a message can pass through, used as the default max for hop_limit in MeshPacket.

src/mesh/NodeDB.cpp

@@ -4,6 +4,7 @@
 
 #include "FS.h"
 
+#include "Channels.h"
 #include "CryptoEngine.h"
 #include "FSCommon.h"
 #include "GPS.h"
@@ -30,7 +31,6 @@ NodeDB nodeDB;
 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.
@@ -64,49 +64,6 @@ static uint8_t ourMacAddr[6];
  */
 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()
@@ -115,104 +72,19 @@ bool NodeDB::resetRadioConfig()
 
     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");
+    } else if (devicestate.channels_count == 0) {
+        DEBUG_MSG("Setting default channel and radio preferences!\n");
+
+        channels.initDefaults();
 
-        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
-
-        if (channelSettings.bandwidth != 0)
-            channelName = "Unset";
-        else
-            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;
-    }
-
-    memset(activePSK, 0, sizeof(activePSK)); // In case the user provided a short key, we want to pad the rest with zeros
-    memcpy(activePSK, channelSettings.psk.bytes, channelSettings.psk.size);
-    activePSKSize = channelSettings.psk.size;
-    if (activePSKSize == 0)
-        DEBUG_MSG("Warning: User disabled encryption\n");
-    else if (activePSKSize == 1) {
-        // Convert the short single byte variants of psk into variant that can be used more generally
-
-        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
-        }
-    } else if (activePSKSize < 16) {
-        // Error! The user specified only the first few bits of an AES128 key.  So by convention we just pad the rest of the key
-        // with zeros
-        DEBUG_MSG("Warning: User provided a too short AES128 key - padding\n");
-        activePSKSize = 16;
-    } else if (activePSKSize < 32 && activePSKSize != 16) {
-        // Error! The user specified only the first few bits of an AES256 key.  So by convention we just pad the rest of the key
-        // with zeros
-        DEBUG_MSG("Warning: User provided a too short AES256 key - padding\n");
-        activePSKSize = 32;
-    }
-
-    // Tell our crypto engine about the psk
-    crypto->setKey(activePSKSize, activePSK);
+    channels.onConfigChanged();
 
     // temp hack for quicker testing
     // devicestate.no_save = true;
@@ -251,7 +123,6 @@ void NodeDB::installDefaultDeviceState()
     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
@@ -277,7 +148,7 @@ void NodeDB::installDefaultDeviceState()
     // Restore region if possible
     if (oldRegionCode != RegionCode_Unset)
         radioConfig.preferences.region = oldRegionCode;
-    if (oldRegion.length())
+    if (oldRegion.length()) // If the old style region was set, try to keep it up-to-date
         strcpy(myNodeInfo.region, oldRegion.c_str());
 }
 
@@ -289,17 +160,14 @@ void NodeDB::init()
     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.max_channels = MAX_NUM_CHANNELS; // tell others the max # of channels we can understand
 
     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
+    myNodeInfo.min_app_version = 20200; // 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)
@@ -490,7 +358,9 @@ void NodeDB::updatePosition(uint32_t nodeId, const Position &p)
     DEBUG_MSG("DB update position node=0x%x time=%u, latI=%d, lonI=%d\n", nodeId, p.time, p.latitude_i, p.longitude_i);
 
     // Be careful to only update fields that have been set by the sender
-    if (p.time)
+    // A lot of position reports don't have time populated.  In that case, be careful to not blow away the time we
+    // recorded based on the packet rxTime
+    if (!info->position.time && p.time)
         info->position.time = p.time;
     if(p.battery_level)
         info->position.battery_level = p.battery_level;
@@ -534,7 +404,6 @@ void NodeDB::updateUser(uint32_t nodeId, const User &p)
 void NodeDB::updateFrom(const MeshPacket &mp)
 {
     if (mp.which_payloadVariant == 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);
@@ -545,31 +414,6 @@ void NodeDB::updateFrom(const MeshPacket &mp)
         }
 
         info->snr = mp.rx_snr; // keep the most recent SNR we received for this node.
-
-        switch (p.which_payloadVariant) {
-        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
-        }
-        }
     }
 }
 

src/mesh/NodeDB.h

@@ -11,9 +11,7 @@
 extern DeviceState devicestate;
 extern MyNodeInfo &myNodeInfo;
 extern RadioConfig &radioConfig;
-extern ChannelSettings &channelSettings;
 extern User &owner;
-extern const char *channelName;
 
 /// Given a node, return how many seconds in the past (vs now) that we last heard from it
 uint32_t sinceLastSeen(const NodeInfo *n);
@@ -130,23 +128,6 @@ extern NodeNum displayedNodeNum;
 
 extern NodeDB nodeDB;
 
-/**
- * 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-XY".
- *
- * Where X is a letter from A to Z (base26), and formed by xoring all the bytes of the PSK together.
- * Y is not yet used but should eventually indicate 'speed/range' of the link
- *
- * 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();
-
 /*
   If is_router is set, we use a number of different default values
 

src/mesh/PhoneAPI.cpp

@@ -4,6 +4,7 @@
 #include "NodeDB.h"
 #include "PowerFSM.h"
 #include "RadioInterface.h"
+#include "Channels.h"
 #include <assert.h>
 
 #if FromRadio_size > MAX_TO_FROM_RADIO_SIZE
@@ -77,20 +78,6 @@ void PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength)
                                        // this will break once we have multiple instances of PhoneAPI running independently
             break;
 
-        case ToRadio_set_owner_tag:
-            DEBUG_MSG("Client is setting owner\n");
-            handleSetOwner(toRadioScratch.set_owner);
-            break;
-
-        case ToRadio_set_radio_tag:
-            DEBUG_MSG("Client is setting radio\n");
-            handleSetRadio(toRadioScratch.set_radio);
-            break;
-
-        case ToRadio_set_channel_tag:
-            DEBUG_MSG("Client is setting channel\n");
-            handleSetChannel(toRadioScratch.set_channel);
-            break;
         default:
             DEBUG_MSG("Error: unexpected ToRadio variant\n");
             break;
@@ -137,24 +124,11 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
                                  : (gps && gps->isConnected()); // Update with latest GPS connect info
         fromRadioScratch.which_payloadVariant = FromRadio_my_info_tag;
         fromRadioScratch.my_info = myNodeInfo;
-        state = STATE_SEND_RADIO;
+        state = STATE_SEND_NODEINFO;
 
         service.refreshMyNodeInfo();  // Update my NodeInfo because the client will be asking for it soon.
         break;
 
-    case STATE_SEND_RADIO:
-        fromRadioScratch.which_payloadVariant = FromRadio_radio_tag;
-
-        fromRadioScratch.radio = radioConfig;
-
-        // NOTE: The phone app needs to know the ls_secs value so it can properly expect sleep behavior.
-        // So even if we internally use 0 to represent 'use default' we still need to send the value we are
-        // using to the app (so that even old phone apps work with new device loads).
-        fromRadioScratch.radio.preferences.ls_secs = getPref_ls_secs();
-
-        state = STATE_SEND_NODEINFO;
-        break;
-
     case STATE_SEND_NODEINFO: {
         const NodeInfo *info = nodeInfoForPhone;
         nodeInfoForPhone = NULL; // We just consumed a nodeinfo, will need a new one next time
@@ -231,9 +205,6 @@ bool PhoneAPI::available()
             nodeInfoForPhone = nodeDB.readNextInfo();
         return true; // Always say we have something, because we might need to advance our state machine
 
-    case STATE_SEND_RADIO:
-        return true;
-
     case STATE_SEND_COMPLETE_ID:
         return true;
 
@@ -254,52 +225,6 @@ bool PhoneAPI::available()
     return false;
 }
 
-//
-// The following routines are only public for now - until the rev1 bluetooth API is removed
-//
-
-void PhoneAPI::handleSetOwner(const User &o)
-{
-    int changed = 0;
-
-    if (*o.long_name) {
-        changed |= strcmp(owner.long_name, o.long_name);
-        strcpy(owner.long_name, o.long_name);
-    }
-    if (*o.short_name) {
-        changed |= strcmp(owner.short_name, o.short_name);
-        strcpy(owner.short_name, o.short_name);
-    }
-    if (*o.id) {
-        changed |= strcmp(owner.id, o.id);
-        strcpy(owner.id, o.id);
-    }
-
-    if (changed) // If nothing really changed, don't broadcast on the network or write to flash
-        service.reloadOwner();
-}
-
-void PhoneAPI::handleSetChannel(const ChannelSettings &cc)
-{
-    radioConfig.channel_settings = cc;
-
-    bool didReset = service.reloadConfig();
-    if (didReset) {
-        state = STATE_SEND_MY_INFO; // Squirt a completely new set of configs to the client
-    }
-
-}
-
-void PhoneAPI::handleSetRadio(const RadioConfig &r)
-{
-    radioConfig = r;
-
-    bool didReset = service.reloadConfig();
-    if (didReset) {
-        state = STATE_SEND_MY_INFO; // Squirt a completely new set of configs to the client
-    }
-}
-
 /**
  * Handle a packet that the phone wants us to send.  It is our responsibility to free the packet to the pool
  */

src/mesh/PhoneAPI.h

@@ -23,7 +23,7 @@ class PhoneAPI
         STATE_LEGACY,       // (no longer used) old default state - until Android apps are all updated, uses the old BLE API
         STATE_SEND_NOTHING, // (Eventual) Initial state, don't send anything until the client starts asking for config
         STATE_SEND_MY_INFO, // send our my info record
-        STATE_SEND_RADIO,
+        // STATE_SEND_RADIO, // in 1.2 we now send this as a regular mesh packet
         // STATE_SEND_OWNER, no need to send Owner specially, it is just part of the nodedb
         STATE_SEND_NODEINFO, // states progress in this order as the device sends to to the client
         STATE_SEND_COMPLETE_ID,
@@ -83,14 +83,6 @@ class PhoneAPI
      */
     bool available();
 
-    //
-    // The following routines are only public for now - until the rev1 bluetooth API is removed
-    //
-
-    void handleSetOwner(const User &o);
-    void handleSetChannel(const ChannelSettings &cc);
-    void handleSetRadio(const RadioConfig &r);
-
   protected:
     /// Are we currently connected to a client?
     bool isConnected = false;

src/mesh/ProtobufPlugin.h

@@ -8,7 +8,7 @@
  * If you are using protobufs to encode your packets (recommended) you can use this as a baseclass for your plugin
  * and avoid a bunch of boilerplate code.
  */
-template <class T> class ProtobufPlugin : private SinglePortPlugin
+template <class T> class ProtobufPlugin : protected SinglePortPlugin
 {
     const pb_msgdesc_t *fields;
 
@@ -25,8 +25,11 @@ template <class T> class ProtobufPlugin : private SinglePortPlugin
 
     /**
      * Handle a received message, the data field in the message is already decoded and is provided
+     * 
+     * In general decoded will always be !NULL.  But in some special applications (where you have handling packets
+     * for multiple port numbers, decoding will ONLY be attempted for packets where the portnum matches our expected ourPortNum.
      */
-    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const T &decoded) = 0;
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const T *decoded) = 0;
 
     /**
      * Return a mesh packet which has been preinited with a particular protobuf data payload and port number.
@@ -38,8 +41,8 @@ template <class T> class ProtobufPlugin : private SinglePortPlugin
         // Update our local node info with our position (even if we don't decide to update anyone else)
         MeshPacket *p = allocDataPacket();
 
-        p->decoded.data.payload.size =
-            pb_encode_to_bytes(p->decoded.data.payload.bytes, sizeof(p->decoded.data.payload.bytes), fields, &payload);
+        p->decoded.payload.size =
+            pb_encode_to_bytes(p->decoded.payload.bytes, sizeof(p->decoded.payload.bytes), fields, &payload);
         // DEBUG_MSG("did encode\n");
         return p;
     }
@@ -54,13 +57,18 @@ template <class T> class ProtobufPlugin : private SinglePortPlugin
         // FIXME - we currently update position data in the DB only if the message was a broadcast or destined to us
         // it would be better to update even if the message was destined to others.
 
-        auto &p = mp.decoded.data;
+        auto &p = mp.decoded;
         DEBUG_MSG("Received %s from=0x%0x, id=0x%x, payloadlen=%d\n", name, mp.from, mp.id, p.payload.size);
 
         T scratch;
-        if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, fields, &scratch))
-            return handleReceivedProtobuf(mp, scratch);
+        T *decoded = NULL; 
+        if(mp.decoded.portnum == ourPortNum) {
+            if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, fields, &scratch))
+                decoded = &scratch;
+            else
+                DEBUG_MSG("Error decoding protobuf plugin!\n");
+        }
 
-        return false; // Let others look at this message also if they want
+        return handleReceivedProtobuf(mp, decoded);
     }
 };

src/mesh/RadioInterface.cpp

@@ -1,5 +1,6 @@
 
 #include "RadioInterface.h"
+#include "Channels.h"
 #include "MeshRadio.h"
 #include "MeshService.h"
 #include "NodeDB.h"
@@ -9,6 +10,7 @@
 #include <assert.h>
 #include <pb_decode.h>
 #include <pb_encode.h>
+#include "Channels.h"
 
 #define RDEF(name, freq, spacing, num_ch, power_limit)                                                                           \
     {                                                                                                                            \
@@ -36,7 +38,7 @@ void initRegion()
     myRegion = r;
     DEBUG_MSG("Wanted region %d, using %s\n", radioConfig.preferences.region, r->name);
 
-    myNodeInfo.num_channels = myRegion->numChannels; // Tell our android app how many channels we have
+    myNodeInfo.num_bands = myRegion->numChannels; // Tell our android app how many channels we have
 }
 
 /**
@@ -117,27 +119,13 @@ uint32_t RadioInterface::getTxDelayMsec()
 
 void printPacket(const char *prefix, const MeshPacket *p)
 {
-    DEBUG_MSG("%s (id=0x%08x Fr0x%02x To0x%02x, WantAck%d, HopLim%d", prefix, p->id, p->from & 0xff, p->to & 0xff, p->want_ack,
-              p->hop_limit);
+    DEBUG_MSG("%s (id=0x%08x Fr0x%02x To0x%02x, WantAck%d, HopLim%d Ch0x%x", prefix, p->id, p->from & 0xff, p->to & 0xff, p->want_ack,
+              p->hop_limit, p->channel);
     if (p->which_payloadVariant == MeshPacket_decoded_tag) {
         auto &s = p->decoded;
-        switch (s.which_payloadVariant) {
-        case SubPacket_data_tag:
-            DEBUG_MSG(" Portnum=%d", s.data.portnum);
-            break;
-        case SubPacket_position_tag:
-            DEBUG_MSG(" Payload:Position");
-            break;
-        case SubPacket_user_tag:
-            DEBUG_MSG(" Payload:User");
-            break;
-        case 0:
-            DEBUG_MSG(" Payload:None");
-            break;
-        default:
-            DEBUG_MSG(" Payload:%d", s.which_payloadVariant);
-            break;
-        }
+        
+        DEBUG_MSG(" Portnum=%d", s.portnum);
+
         if (s.want_response)
             DEBUG_MSG(" WANTRESP");
 
@@ -147,10 +135,11 @@ void printPacket(const char *prefix, const MeshPacket *p)
         if (s.dest != 0)
             DEBUG_MSG(" dest=%08x", s.dest);
 
+        /* now inside Data and therefore kinda opaque
         if (s.which_ackVariant == SubPacket_success_id_tag)
             DEBUG_MSG(" successId=%08x", s.ackVariant.success_id);
         else if (s.which_ackVariant == SubPacket_fail_id_tag)
-            DEBUG_MSG(" failId=%08x", s.ackVariant.fail_id);
+            DEBUG_MSG(" failId=%08x", s.ackVariant.fail_id); */
     } else {
         DEBUG_MSG(" encrypted");
     }
@@ -161,15 +150,15 @@ void printPacket(const char *prefix, const MeshPacket *p)
     if (p->rx_snr != 0.0) {
         DEBUG_MSG(" rxSNR=%g", p->rx_snr);
     }
-    if(p->priority != 0)
+    if (p->priority != 0)
         DEBUG_MSG(" priority=%d", p->priority);
-        
+
     DEBUG_MSG(")\n");
 }
 
 RadioInterface::RadioInterface()
 {
-    assert(sizeof(PacketHeader) == 4 || sizeof(PacketHeader) == 16); // make sure the compiler did what we expected
+    assert(sizeof(PacketHeader) == 16); // make sure the compiler did what we expected
 
     // Can't print strings this early - serial not setup yet
     // DEBUG_MSG("Set meshradio defaults name=%s\n", channelSettings.name);
@@ -252,6 +241,7 @@ void RadioInterface::applyModemConfig()
     // Set up default configuration
     // No Sync Words in LORA mode
 
+    auto channelSettings = channels.getPrimary();
     if (channelSettings.spread_factor == 0) {
         switch (channelSettings.modem_config) {
         case ChannelSettings_ModemConfig_Bw125Cr45Sf128: ///< Bw = 125 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on. Default medium
@@ -296,7 +286,8 @@ void RadioInterface::applyModemConfig()
     assert(myRegion); // Should have been found in init
 
     // If user has manually specified a channel num, then use that, otherwise generate one by hashing the name
-    int channel_num = (channelSettings.channel_num ? channelSettings.channel_num - 1 : hash(channelName)) % myRegion->numChannels;
+    const char *channelName = channels.getName(channels.getPrimaryIndex());
+    int channel_num = channelSettings.channel_num ? channelSettings.channel_num - 1 : hash(channelName) % myRegion->numChannels;
     freq = myRegion->freq + myRegion->spacing * channel_num;
 
     DEBUG_MSG("Set radio: name=%s, config=%u, ch=%d, power=%d\n", channelName, channelSettings.modem_config, channel_num, power);
@@ -360,6 +351,7 @@ size_t RadioInterface::beginSending(MeshPacket *p)
     h->from = p->from;
     h->to = p->to;
     h->id = p->id;
+    h->channel = p->channel;
     assert(p->hop_limit <= HOP_MAX);
     h->flags = p->hop_limit | (p->want_ack ? PACKET_FLAGS_WANT_ACK_MASK : 0);
 

src/mesh/RadioInterface.h

@@ -29,6 +29,9 @@ typedef struct {
      * The bottom three bits of flags are use to store hop_limit when sent over the wire.
      **/
     uint8_t flags;
+
+    /** The channel hash - used as a hint for the decoder to limit which channels we consider */
+    uint8_t channel;
 } PacketHeader;
 
 /**

src/mesh/RadioLibInterface.cpp

@@ -275,6 +275,7 @@ void RadioLibInterface::handleReceiveInterrupt()
             mp->from = h->from;
             mp->to = h->to;
             mp->id = h->id;
+            mp->channel = h->channel;
             assert(HOP_MAX <= PACKET_FLAGS_HOP_MASK); // If hopmax changes, carefully check this code
             mp->hop_limit = h->flags & PACKET_FLAGS_HOP_MASK;
             mp->want_ack = !!(h->flags & PACKET_FLAGS_WANT_ACK_MASK);

src/mesh/RadioLibInterface.h

@@ -80,10 +80,13 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
   protected:
 
     /**
-     * FIXME, use a meshtastic sync word, but hashed with the Channel name.  Currently picking the same default
-     * the RF95 used (0x14). Note: do not use 0x34 - that is reserved for lorawan
+     * We use a meshtastic sync word, but hashed with the Channel name.  For releases before 1.2 we used 0x12 (or for very old loads 0x14)
+     * Note: do not use 0x34 - that is reserved for lorawan
+     * 
+     * We now use 0x2b (so that someday we can possibly use NOT 2b - because that would be funny pun).  We will be staying with this code
+     * for a long time.
      */
-    uint8_t syncWord = SX126X_SYNC_WORD_PRIVATE;
+    const uint8_t syncWord = 0x2b;
 
     float currentLimit = 100;     // FIXME
 

src/mesh/ReliableRouter.cpp

@@ -34,7 +34,7 @@ bool ReliableRouter::shouldFilterReceived(const MeshPacket *p)
         // the original sending process.
         if (stopRetransmission(p->from, p->id)) {
             DEBUG_MSG("Someone is retransmitting for us, generate implicit ack\n");
-            sendAckNak(ErrorReason_NONE, p->from, p->id);
+            sendAckNak(Routing_Error_NONE, p->from, p->id);
         }
     }
 
@@ -53,35 +53,36 @@ bool ReliableRouter::shouldFilterReceived(const MeshPacket *p)
  *
  * Otherwise, let superclass handle it.
  */
-void ReliableRouter::sniffReceived(const MeshPacket *p)
+void ReliableRouter::sniffReceived(const MeshPacket *p, const Routing *c)
 {
     NodeNum ourNode = getNodeNum();
 
     if (p->to == ourNode) { // ignore ack/nak/want_ack packets that are not address to us (we only handle 0 hop reliability
                             // - not DSR routing)
         if (p->want_ack) {
-            sendAckNak(ErrorReason_NONE, p->from, p->id);
+            sendAckNak(Routing_Error_NONE, p->from, p->id);
         }
 
         // If the payload is valid, look for ack/nak
+        if (c) {
+            PacketId ackId = c->error_reason == Routing_Error_NONE ? p->decoded.request_id : 0;
+            PacketId nakId = c->error_reason != Routing_Error_NONE ? p->decoded.request_id : 0;
 
-        PacketId ackId = p->decoded.which_ackVariant == SubPacket_success_id_tag ? p->decoded.ackVariant.success_id : 0;
-        PacketId nakId = p->decoded.which_ackVariant == SubPacket_fail_id_tag ? p->decoded.ackVariant.fail_id : 0;
-
-        // We intentionally don't check wasSeenRecently, because it is harmless to delete non existent retransmission records
-        if (ackId || nakId) {
-            if (ackId) {
-                DEBUG_MSG("Received a ack=%d, stopping retransmissions\n", ackId);
-                stopRetransmission(p->to, ackId);
-            } else {
-                DEBUG_MSG("Received a nak=%d, stopping retransmissions\n", nakId);
-                stopRetransmission(p->to, nakId);
+            // We intentionally don't check wasSeenRecently, because it is harmless to delete non existent retransmission records
+            if (ackId || nakId) {
+                if (ackId) {
+                    DEBUG_MSG("Received a ack=%d, stopping retransmissions\n", ackId);
+                    stopRetransmission(p->to, ackId);
+                } else {
+                    DEBUG_MSG("Received a nak=%d, stopping retransmissions\n", nakId);
+                    stopRetransmission(p->to, nakId);
+                }
             }
         }
     }
 
     // handle the packet as normal
-    FloodingRouter::sniffReceived(p);
+    FloodingRouter::sniffReceived(p, c);
 }
 
 #define NUM_RETRANSMISSIONS 3
@@ -155,7 +156,7 @@ int32_t ReliableRouter::doRetransmissions()
             if (p.numRetransmissions == 0) {
                 DEBUG_MSG("Reliable send failed, returning a nak fr=0x%x,to=0x%x,id=%d\n", p.packet->from, p.packet->to,
                           p.packet->id);
-                sendAckNak(ErrorReason_MAX_RETRANSMIT, p.packet->from, p.packet->id);
+                sendAckNak(Routing_Error_MAX_RETRANSMIT, p.packet->from, p.packet->id);
                 // Note: we don't stop retransmission here, instead the Nak packet gets processed in sniffReceived - which
                 // allows the DSR version to still be able to look at the PendingPacket
                 stopRetransmission(it->first);

src/mesh/ReliableRouter.h

@@ -90,7 +90,7 @@ class ReliableRouter : public FloodingRouter
     /**
      * Look for acks/naks or someone retransmitting us
      */
-    virtual void sniffReceived(const MeshPacket *p);
+    virtual void sniffReceived(const MeshPacket *p, const Routing *c);
 
     /**
      * Try to find the pending packet record for this ID (or NULL if not found)

src/mesh/Router.cpp

@@ -1,9 +1,11 @@
 #include "Router.h"
+#include "Channels.h"
 #include "CryptoEngine.h"
+#include "NodeDB.h"
 #include "RTC.h"
 #include "configuration.h"
 #include "mesh-pb-constants.h"
-#include <NodeDB.h>
+#include "plugins/RoutingPlugin.h"
 
 /**
  * Router todo
@@ -80,7 +82,6 @@ PacketId generatePacketId()
 
     i++;
     PacketId id = (i % numPacketId) + 1; // return number between 1 and numPacketId (ie - never zero)
-    myNodeInfo.current_packet_id = id;   // Kinda crufty - we keep updating this so the phone can see a current value
     return id;
 }
 
@@ -102,30 +103,17 @@ MeshPacket *Router::allocForSending()
 /**
  * Send an ack or a nak packet back towards whoever sent idFrom
  */
-void Router::sendAckNak(ErrorReason err, NodeNum to, PacketId idFrom)
+void Router::sendAckNak(Routing_Error err, NodeNum to, PacketId idFrom)
 {
-    auto p = allocForSending();
-    p->hop_limit = 0; // Assume just immediate neighbors for now
-    p->to = to;
-    DEBUG_MSG("Sending an err=%d,to=0x%x,idFrom=0x%x,id=0x%x\n", err, to, idFrom, p->id);
-
-    if (!err) {
-        p->decoded.ackVariant.success_id = idFrom;
-        p->decoded.which_ackVariant = SubPacket_success_id_tag;
-    } else {
-        p->decoded.ackVariant.fail_id = idFrom;
-        p->decoded.which_ackVariant = SubPacket_fail_id_tag;
-
-        // Also send back the error reason
-        p->decoded.which_payloadVariant = SubPacket_error_reason_tag;
-        p->decoded.error_reason = err;
-    }
-    p->priority = MeshPacket_Priority_ACK;
-
-    sendLocal(p); // we sometimes send directly to the local node
+    routingPlugin->sendAckNak(err, to, idFrom);
 }
 
-
+void Router::abortSendAndNak(Routing_Error err, MeshPacket *p)
+{
+    DEBUG_MSG("Error=%d, returning NAK and dropping packet.\n", err);
+    sendAckNak(Routing_Error_NO_INTERFACE, p->from, p->id);
+    packetPool.release(p);
+}
 
 ErrorCode Router::sendLocal(MeshPacket *p)
 {
@@ -136,11 +124,7 @@ ErrorCode Router::sendLocal(MeshPacket *p)
         return ERRNO_OK;
     } else if (!iface) {
         // We must be sending to remote nodes also, fail if no interface found
-
-        // ERROR! no radio found, report failure back to the client and drop the packet
-        DEBUG_MSG("Error: No interface, returning NAK and dropping packet.\n");
-        sendAckNak(ErrorReason_NO_INTERFACE, p->from, p->id);
-        packetPool.release(p);
+        abortSendAndNak(Routing_Error_NO_INTERFACE, p);
 
         return ERRNO_NO_INTERFACES;
     } else {
@@ -163,9 +147,9 @@ ErrorCode Router::send(MeshPacket *p)
 {
     assert(p->to != nodeDB.getNodeNum()); // should have already been handled by sendLocal
 
-    PacketId nakId = p->decoded.which_ackVariant == SubPacket_fail_id_tag ? p->decoded.ackVariant.fail_id : 0;
-    assert(
-        !nakId); // I don't think we ever send 0hop naks over the wire (other than to the phone), test that assumption with assert
+    // PacketId nakId = p->decoded.which_ackVariant == SubPacket_fail_id_tag ? p->decoded.ackVariant.fail_id : 0;
+    // assert(!nakId); // I don't think we ever send 0hop naks over the wire (other than to the phone), test that assumption with
+    // assert
 
     // Never set the want_ack flag on broadcast packets sent over the air.
     if (p->to == NODENUM_BROADCAST)
@@ -180,9 +164,22 @@ ErrorCode Router::send(MeshPacket *p)
     if (p->which_payloadVariant == MeshPacket_decoded_tag) {
         static uint8_t bytes[MAX_RHPACKETLEN]; // we have to use a scratch buffer because a union
 
-        size_t numbytes = pb_encode_to_bytes(bytes, sizeof(bytes), SubPacket_fields, &p->decoded);
+        size_t numbytes = pb_encode_to_bytes(bytes, sizeof(bytes), Data_fields, &p->decoded);
 
-        assert(numbytes <= MAX_RHPACKETLEN);
+        if (numbytes > MAX_RHPACKETLEN) {
+            abortSendAndNak(Routing_Error_TOO_LARGE, p);
+            return ERRNO_TOO_LARGE;
+        }
+
+        auto hash = channels.setActiveByIndex(p->channel);
+        if (hash < 0) {
+            // No suitable channel could be found for sending
+            abortSendAndNak(Routing_Error_NO_CHANNEL, p);
+            return ERRNO_NO_CHANNEL;
+        }
+
+        // Now that we are encrypting the packet channel should be the hash (no longer the index)
+        p->channel = hash;
         crypto->encrypt(p->from, p->id, numbytes, bytes);
 
         // Copy back into the packet and set the variant type
@@ -192,28 +189,20 @@ ErrorCode Router::send(MeshPacket *p)
     }
 
     assert(iface); // This should have been detected already in sendLocal (or we just received a packet from outside)
-    // if (iface) {
-    // DEBUG_MSG("Sending packet via interface fr=0x%x,to=0x%x,id=%d\n", p->from, p->to, p->id);
     return iface->send(p);
-    /* } else {
-        DEBUG_MSG("Dropping packet - no interfaces - fr=0x%x,to=0x%x,id=%d\n", p->from, p->to, p->id);
-        packetPool.release(p);
-        return ERRNO_NO_INTERFACES;
-    } */
 }
 
 /** Attempt to cancel a previously sent packet.  Returns true if a packet was found we could cancel */
-bool Router::cancelSending(NodeNum from, PacketId id) {
+bool Router::cancelSending(NodeNum from, PacketId id)
+{
     return iface ? iface->cancelSending(from, id) : false;
 }
 
-
-
 /**
  * Every (non duplicate) packet this node receives will be passed through this method.  This allows subclasses to
  * update routing tables etc... based on what we overhear (even for messages not destined to our node)
  */
-void Router::sniffReceived(const MeshPacket *p)
+void Router::sniffReceived(const MeshPacket *p, const Routing *c)
 {
     DEBUG_MSG("FIXME-update-db Sniffing packet\n");
     // FIXME, update nodedb here for any packet that passes through us
@@ -226,23 +215,32 @@ bool Router::perhapsDecode(MeshPacket *p)
 
     assert(p->which_payloadVariant == MeshPacket_encrypted_tag);
 
-    // FIXME - someday don't send routing packets encrypted.  That would allow us to route for other channels without
-    // being able to decrypt their data.
-    // Try to decrypt the packet if we can
-    static uint8_t bytes[MAX_RHPACKETLEN];
-    memcpy(bytes, p->encrypted.bytes,
-           p->encrypted.size); // we have to copy into a scratch buffer, because these bytes are a union with the decoded protobuf
-    crypto->decrypt(p->from, p->id, p->encrypted.size, bytes);
+    // Try to find a channel that works with this hash
+    for (ChannelIndex chIndex = 0; chIndex < channels.getNumChannels(); chIndex++) {
+        // Try to use this hash/channel pair
+        if (channels.decryptForHash(chIndex, p->channel)) {
+            // Try to decrypt the packet if we can
+            static uint8_t bytes[MAX_RHPACKETLEN];
+            memcpy(bytes, p->encrypted.bytes,
+                   p->encrypted
+                       .size); // we have to copy into a scratch buffer, because these bytes are a union with the decoded protobuf
+            crypto->decrypt(p->from, p->id, p->encrypted.size, bytes);
 
-    // Take those raw bytes and convert them back into a well structured protobuf we can understand
-    if (!pb_decode_from_bytes(bytes, p->encrypted.size, SubPacket_fields, &p->decoded)) {
-        DEBUG_MSG("Invalid protobufs in received mesh packet!\n");
-        return false;
-    } else {
-        // parsing was successful
-        p->which_payloadVariant = MeshPacket_decoded_tag;
-        return true;
+            // Take those raw bytes and convert them back into a well structured protobuf we can understand
+            if (!pb_decode_from_bytes(bytes, p->encrypted.size, Data_fields, &p->decoded)) {
+                DEBUG_MSG("Invalid protobufs in received mesh packet (bad psk?!\n");
+            } else {
+                // parsing was successful
+                p->channel = chIndex; // change to store the index instead of the hash
+                // printPacket("decoded message", p);
+                p->which_payloadVariant = MeshPacket_decoded_tag;
+                return true;
+            }
+        }
     }
+
+    DEBUG_MSG("No suitable channel found for decoding, hash was 0x%x!\n", p->channel);
+    return false;
 }
 
 NodeNum Router::getNodeNum()
@@ -260,15 +258,15 @@ void Router::handleReceived(MeshPacket *p)
     p->rx_time = getValidTime(RTCQualityFromNet); // store the arrival timestamp for the phone
 
     // Take those raw bytes and convert them back into a well structured protobuf we can understand
-    if (perhapsDecode(p)) {
+    bool decoded = perhapsDecode(p);
+    printPacket("handleReceived", p);
+    DEBUG_MSG("decoded=%d\n", decoded);    
+    if (decoded) {
         // parsing was successful, queue for our recipient
 
-        sniffReceived(p);
-
-        if (p->to == NODENUM_BROADCAST || p->to == getNodeNum()) {
-            printPacket("Delivering rx packet", p);
-            notifyPacketReceived.notifyObservers(p);
-        }
+        // call any promiscious plugins here, make a (non promisiocous) plugin for forwarding messages to phone api
+        // sniffReceived(p);
+        MeshPlugin::callPlugins(*p);
     }
 }
 

src/mesh/Router.h

@@ -21,10 +21,6 @@ class Router : protected concurrency::OSThread
     RadioInterface *iface = NULL;
 
   public:
-    /// Local services that want to see _every_ packet this node receives can observe this.
-    /// Observers should always return 0 and _copy_ any packets they want to keep for use later (this packet will be getting
-    /// freed)
-    Observable<const MeshPacket *> notifyPacketReceived;
 
     /**
      * Constructor
@@ -68,6 +64,8 @@ class Router : protected concurrency::OSThread
     NodeNum getNodeNum();
 
   protected:
+    friend class RoutingPlugin;
+
     /**
      * Send a packet on a suitable interface.  This routine will
      * later free() the packet to pool.  This routine is not allowed to stall.
@@ -79,6 +77,8 @@ class Router : protected concurrency::OSThread
 
     /**
      * Should this incoming filter be dropped?
+     * 
+     * FIXME, move this into the new RoutingPlugin and do the filtering there using the regular plugin logic
      *
      * Called immedately on receiption, before any further processing.
      * @return true to abandon the packet
@@ -89,7 +89,7 @@ class Router : protected concurrency::OSThread
      * Every (non duplicate) packet this node receives will be passed through this method.  This allows subclasses to
      * update routing tables etc... based on what we overhear (even for messages not destined to our node)
      */
-    virtual void sniffReceived(const MeshPacket *p);
+    virtual void sniffReceived(const MeshPacket *p, const Routing *c);
 
     /**
      * Remove any encryption and decode the protobufs inside this packet (if necessary).
@@ -101,7 +101,7 @@ class Router : protected concurrency::OSThread
     /**
      * Send an ack or a nak packet back towards whoever sent idFrom
      */
-    void sendAckNak(ErrorReason err, NodeNum to, PacketId idFrom);
+    void sendAckNak(Routing_Error err, NodeNum to, PacketId idFrom);
     
   private:
     /**
@@ -123,6 +123,9 @@ class Router : protected concurrency::OSThread
      * Note: this method will free the provided packet.
      */
     void handleReceived(MeshPacket *p);
+
+    /** Frees the provided packet, and generates a NAK indicating the speicifed error while sending */
+    void abortSendAndNak(Routing_Error err, MeshPacket *p);
 };
 
 extern Router *router;

src/mesh/SinglePortPlugin.h

@@ -21,7 +21,7 @@ class SinglePortPlugin : public MeshPlugin
     /**
      * @return true if you want to receive the specified portnum
      */
-    virtual bool wantPortnum(PortNum p) { return p == ourPortNum; }
+    virtual bool wantPacket(const MeshPacket *p) { return p->decoded.portnum == ourPortNum; }
 
     /**
      * Return a mesh packet which has been preinited as a data packet with a particular port number.
@@ -32,8 +32,7 @@ class SinglePortPlugin : public MeshPlugin
     {
         // Update our local node info with our position (even if we don't decide to update anyone else)
         MeshPacket *p = router->allocForSending();
-        p->decoded.which_payloadVariant = SubPacket_data_tag;
-        p->decoded.data.portnum = ourPortNum;
+        p->decoded.portnum = ourPortNum;
 
         return p;
     }

src/mesh/generated/admin.pb.c

@@ -0,0 +1,12 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.4 */
+
+#include "admin.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(AdminMessage, AdminMessage, 2)
+
+
+

src/mesh/generated/admin.pb.h

@@ -0,0 +1,76 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.4 */
+
+#ifndef PB_ADMIN_PB_H_INCLUDED
+#define PB_ADMIN_PB_H_INCLUDED
+#include <pb.h>
+#include "mesh.pb.h"
+#include "radioconfig.pb.h"
+#include "channel.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _AdminMessage {
+    pb_size_t which_variant;
+    union {
+        RadioConfig set_radio;
+        User set_owner;
+        Channel set_channel;
+        bool get_radio_request;
+        RadioConfig get_radio_response;
+        uint32_t get_channel_request;
+        Channel get_channel_response;
+    };
+} AdminMessage;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define AdminMessage_init_default                {0, {RadioConfig_init_default}}
+#define AdminMessage_init_zero                   {0, {RadioConfig_init_zero}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define AdminMessage_set_radio_tag               1
+#define AdminMessage_set_owner_tag               2
+#define AdminMessage_set_channel_tag             3
+#define AdminMessage_get_radio_request_tag       4
+#define AdminMessage_get_radio_response_tag      5
+#define AdminMessage_get_channel_request_tag     6
+#define AdminMessage_get_channel_response_tag    7
+
+/* Struct field encoding specification for nanopb */
+#define AdminMessage_FIELDLIST(X, a) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,set_radio,set_radio),   1) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,set_owner,set_owner),   2) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,set_channel,set_channel),   3) \
+X(a, STATIC,   ONEOF,    BOOL,     (variant,get_radio_request,get_radio_request),   4) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,get_radio_response,get_radio_response),   5) \
+X(a, STATIC,   ONEOF,    UINT32,   (variant,get_channel_request,get_channel_request),   6) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,get_channel_response,get_channel_response),   7)
+#define AdminMessage_CALLBACK NULL
+#define AdminMessage_DEFAULT NULL
+#define AdminMessage_variant_set_radio_MSGTYPE RadioConfig
+#define AdminMessage_variant_set_owner_MSGTYPE User
+#define AdminMessage_variant_set_channel_MSGTYPE Channel
+#define AdminMessage_variant_get_radio_response_MSGTYPE RadioConfig
+#define AdminMessage_variant_get_channel_response_MSGTYPE Channel
+
+extern const pb_msgdesc_t AdminMessage_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define AdminMessage_fields &AdminMessage_msg
+
+/* Maximum encoded size of messages (where known) */
+#define AdminMessage_size                        338
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/apponly.pb.c

@@ -9,4 +9,7 @@
 PB_BIND(ServiceEnvelope, ServiceEnvelope, 2)
 
 
+PB_BIND(ChannelSet, ChannelSet, AUTO)
+
+
 

src/mesh/generated/apponly.pb.h

@@ -5,12 +5,17 @@
 #define PB_APPONLY_PB_H_INCLUDED
 #include <pb.h>
 #include "mesh.pb.h"
+#include "channel.pb.h"
 
 #if PB_PROTO_HEADER_VERSION != 40
 #error Regenerate this file with the current version of nanopb generator.
 #endif
 
 /* Struct definitions */
+typedef struct _ChannelSet {
+    pb_callback_t settings;
+} ChannelSet;
+
 typedef struct _ServiceEnvelope {
     bool has_packet;
     MeshPacket packet;
@@ -25,9 +30,12 @@ extern "C" {
 
 /* Initializer values for message structs */
 #define ServiceEnvelope_init_default             {false, MeshPacket_init_default, {{NULL}, NULL}, {{NULL}, NULL}}
+#define ChannelSet_init_default                  {{{NULL}, NULL}}
 #define ServiceEnvelope_init_zero                {false, MeshPacket_init_zero, {{NULL}, NULL}, {{NULL}, NULL}}
+#define ChannelSet_init_zero                     {{{NULL}, NULL}}
 
 /* Field tags (for use in manual encoding/decoding) */
+#define ChannelSet_settings_tag                  1
 #define ServiceEnvelope_packet_tag               1
 #define ServiceEnvelope_channel_id_tag           2
 #define ServiceEnvelope_gateway_id_tag           3
@@ -41,13 +49,22 @@ X(a, CALLBACK, SINGULAR, STRING,   gateway_id,        3)
 #define ServiceEnvelope_DEFAULT NULL
 #define ServiceEnvelope_packet_MSGTYPE MeshPacket
 
+#define ChannelSet_FIELDLIST(X, a) \
+X(a, CALLBACK, REPEATED, MESSAGE,  settings,          1)
+#define ChannelSet_CALLBACK pb_default_field_callback
+#define ChannelSet_DEFAULT NULL
+#define ChannelSet_settings_MSGTYPE ChannelSettings
+
 extern const pb_msgdesc_t ServiceEnvelope_msg;
+extern const pb_msgdesc_t ChannelSet_msg;
 
 /* Defines for backwards compatibility with code written before nanopb-0.4.0 */
 #define ServiceEnvelope_fields &ServiceEnvelope_msg
+#define ChannelSet_fields &ChannelSet_msg
 
 /* Maximum encoded size of messages (where known) */
 /* ServiceEnvelope_size depends on runtime parameters */
+/* ChannelSet_size depends on runtime parameters */
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/channel.pb.c

@@ -0,0 +1,17 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.4 */
+
+#include "channel.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(ChannelSettings, ChannelSettings, AUTO)
+
+
+PB_BIND(Channel, Channel, AUTO)
+
+
+
+
+

src/mesh/generated/channel.pb.h

@@ -0,0 +1,125 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.4 */
+
+#ifndef PB_CHANNEL_PB_H_INCLUDED
+#define PB_CHANNEL_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+typedef enum _ChannelSettings_ModemConfig {
+    ChannelSettings_ModemConfig_Bw125Cr45Sf128 = 0,
+    ChannelSettings_ModemConfig_Bw500Cr45Sf128 = 1,
+    ChannelSettings_ModemConfig_Bw31_25Cr48Sf512 = 2,
+    ChannelSettings_ModemConfig_Bw125Cr48Sf4096 = 3
+} ChannelSettings_ModemConfig;
+
+typedef enum _Channel_Role {
+    Channel_Role_DISABLED = 0,
+    Channel_Role_PRIMARY = 1,
+    Channel_Role_SECONDARY = 2
+} Channel_Role;
+
+/* Struct definitions */
+typedef PB_BYTES_ARRAY_T(32) ChannelSettings_psk_t;
+typedef struct _ChannelSettings {
+    int8_t tx_power;
+    ChannelSettings_ModemConfig modem_config;
+    ChannelSettings_psk_t psk;
+    char name[12];
+    uint16_t bandwidth;
+    uint32_t spread_factor;
+    uint8_t coding_rate;
+    uint8_t channel_num;
+    uint32_t id;
+    bool uplink_enabled;
+    bool downlink_enabled;
+} ChannelSettings;
+
+typedef struct _Channel {
+    uint8_t index;
+    bool has_settings;
+    ChannelSettings settings;
+    Channel_Role role;
+} Channel;
+
+
+/* Helper constants for enums */
+#define _ChannelSettings_ModemConfig_MIN ChannelSettings_ModemConfig_Bw125Cr45Sf128
+#define _ChannelSettings_ModemConfig_MAX ChannelSettings_ModemConfig_Bw125Cr48Sf4096
+#define _ChannelSettings_ModemConfig_ARRAYSIZE ((ChannelSettings_ModemConfig)(ChannelSettings_ModemConfig_Bw125Cr48Sf4096+1))
+
+#define _Channel_Role_MIN Channel_Role_DISABLED
+#define _Channel_Role_MAX Channel_Role_SECONDARY
+#define _Channel_Role_ARRAYSIZE ((Channel_Role)(Channel_Role_SECONDARY+1))
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define ChannelSettings_init_default             {0, _ChannelSettings_ModemConfig_MIN, {0, {0}}, "", 0, 0, 0, 0, 0, 0, 0}
+#define Channel_init_default                     {0, false, ChannelSettings_init_default, _Channel_Role_MIN}
+#define ChannelSettings_init_zero                {0, _ChannelSettings_ModemConfig_MIN, {0, {0}}, "", 0, 0, 0, 0, 0, 0, 0}
+#define Channel_init_zero                        {0, false, ChannelSettings_init_zero, _Channel_Role_MIN}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define ChannelSettings_tx_power_tag             1
+#define ChannelSettings_modem_config_tag         3
+#define ChannelSettings_psk_tag                  4
+#define ChannelSettings_name_tag                 5
+#define ChannelSettings_bandwidth_tag            6
+#define ChannelSettings_spread_factor_tag        7
+#define ChannelSettings_coding_rate_tag          8
+#define ChannelSettings_channel_num_tag          9
+#define ChannelSettings_id_tag                   10
+#define ChannelSettings_uplink_enabled_tag       16
+#define ChannelSettings_downlink_enabled_tag     17
+#define Channel_index_tag                        1
+#define Channel_settings_tag                     2
+#define Channel_role_tag                         3
+
+/* Struct field encoding specification for nanopb */
+#define ChannelSettings_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, INT32,    tx_power,          1) \
+X(a, STATIC,   SINGULAR, UENUM,    modem_config,      3) \
+X(a, STATIC,   SINGULAR, BYTES,    psk,               4) \
+X(a, STATIC,   SINGULAR, STRING,   name,              5) \
+X(a, STATIC,   SINGULAR, UINT32,   bandwidth,         6) \
+X(a, STATIC,   SINGULAR, UINT32,   spread_factor,     7) \
+X(a, STATIC,   SINGULAR, UINT32,   coding_rate,       8) \
+X(a, STATIC,   SINGULAR, UINT32,   channel_num,       9) \
+X(a, STATIC,   SINGULAR, FIXED32,  id,               10) \
+X(a, STATIC,   SINGULAR, BOOL,     uplink_enabled,   16) \
+X(a, STATIC,   SINGULAR, BOOL,     downlink_enabled,  17)
+#define ChannelSettings_CALLBACK NULL
+#define ChannelSettings_DEFAULT NULL
+
+#define Channel_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   index,             1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  settings,          2) \
+X(a, STATIC,   SINGULAR, UENUM,    role,              3)
+#define Channel_CALLBACK NULL
+#define Channel_DEFAULT NULL
+#define Channel_settings_MSGTYPE ChannelSettings
+
+extern const pb_msgdesc_t ChannelSettings_msg;
+extern const pb_msgdesc_t Channel_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define ChannelSettings_fields &ChannelSettings_msg
+#define Channel_fields &Channel_msg
+
+/* Maximum encoded size of messages (where known) */
+#define ChannelSettings_size                     87
+#define Channel_size                             94
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/deviceonly.pb.h

@@ -5,6 +5,8 @@
 #define PB_DEVICEONLY_PB_H_INCLUDED
 #include <pb.h>
 #include "mesh.pb.h"
+#include "radioconfig.pb.h"
+#include "channel.pb.h"
 
 #if PB_PROTO_HEADER_VERSION != 40
 #error Regenerate this file with the current version of nanopb generator.
@@ -27,8 +29,8 @@ typedef struct _DeviceState {
     uint32_t version;
     bool no_save;
     bool did_gps_reset;
-    pb_size_t secondary_channels_count;
-    ChannelSettings secondary_channels[7];
+    pb_size_t channels_count;
+    Channel channels[8];
 } DeviceState;
 
 
@@ -37,8 +39,8 @@ extern "C" {
 #endif
 
 /* Initializer values for message structs */
-#define DeviceState_init_default                 {false, RadioConfig_init_default, false, MyNodeInfo_init_default, false, User_init_default, 0, {NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default}, 0, {MeshPacket_init_default}, false, MeshPacket_init_default, 0, 0, 0, 0, {ChannelSettings_init_default, ChannelSettings_init_default, ChannelSettings_init_default, ChannelSettings_init_default, ChannelSettings_init_default, ChannelSettings_init_default, ChannelSettings_init_default}}
-#define DeviceState_init_zero                    {false, RadioConfig_init_zero, false, MyNodeInfo_init_zero, false, User_init_zero, 0, {NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero}, 0, {MeshPacket_init_zero}, false, MeshPacket_init_zero, 0, 0, 0, 0, {ChannelSettings_init_zero, ChannelSettings_init_zero, ChannelSettings_init_zero, ChannelSettings_init_zero, ChannelSettings_init_zero, ChannelSettings_init_zero, ChannelSettings_init_zero}}
+#define DeviceState_init_default                 {false, RadioConfig_init_default, false, MyNodeInfo_init_default, false, User_init_default, 0, {NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default}, 0, {MeshPacket_init_default}, false, MeshPacket_init_default, 0, 0, 0, 0, {Channel_init_default, Channel_init_default, Channel_init_default, Channel_init_default, Channel_init_default, Channel_init_default, Channel_init_default, Channel_init_default}}
+#define DeviceState_init_zero                    {false, RadioConfig_init_zero, false, MyNodeInfo_init_zero, false, User_init_zero, 0, {NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero}, 0, {MeshPacket_init_zero}, false, MeshPacket_init_zero, 0, 0, 0, 0, {Channel_init_zero, Channel_init_zero, Channel_init_zero, Channel_init_zero, Channel_init_zero, Channel_init_zero, Channel_init_zero, Channel_init_zero}}
 
 /* Field tags (for use in manual encoding/decoding) */
 #define DeviceState_radio_tag                    1
@@ -50,7 +52,7 @@ extern "C" {
 #define DeviceState_version_tag                  8
 #define DeviceState_no_save_tag                  9
 #define DeviceState_did_gps_reset_tag            11
-#define DeviceState_secondary_channels_tag       12
+#define DeviceState_channels_tag                 13
 
 /* Struct field encoding specification for nanopb */
 #define DeviceState_FIELDLIST(X, a) \
@@ -63,7 +65,7 @@ X(a, STATIC,   OPTIONAL, MESSAGE,  rx_text_message,   7) \
 X(a, STATIC,   SINGULAR, UINT32,   version,           8) \
 X(a, STATIC,   SINGULAR, BOOL,     no_save,           9) \
 X(a, STATIC,   SINGULAR, BOOL,     did_gps_reset,    11) \
-X(a, STATIC,   REPEATED, MESSAGE,  secondary_channels,  12)
+X(a, STATIC,   REPEATED, MESSAGE,  channels,         13)
 #define DeviceState_CALLBACK NULL
 #define DeviceState_DEFAULT NULL
 #define DeviceState_radio_MSGTYPE RadioConfig
@@ -72,7 +74,7 @@ X(a, STATIC,   REPEATED, MESSAGE,  secondary_channels,  12)
 #define DeviceState_node_db_MSGTYPE NodeInfo
 #define DeviceState_receive_queue_MSGTYPE MeshPacket
 #define DeviceState_rx_text_message_MSGTYPE MeshPacket
-#define DeviceState_secondary_channels_MSGTYPE ChannelSettings
+#define DeviceState_channels_MSGTYPE Channel
 
 extern const pb_msgdesc_t DeviceState_msg;
 
@@ -80,7 +82,7 @@ extern const pb_msgdesc_t DeviceState_msg;
 #define DeviceState_fields &DeviceState_msg
 
 /* Maximum encoded size of messages (where known) */
-#define DeviceState_size                         6293
+#define DeviceState_size                         6156
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/mesh.pb.c

@@ -9,30 +9,21 @@
 PB_BIND(Position, Position, AUTO)
 
 
-PB_BIND(Data, Data, AUTO)
-
-
 PB_BIND(User, User, AUTO)
 
 
 PB_BIND(RouteDiscovery, RouteDiscovery, AUTO)
 
 
-PB_BIND(SubPacket, SubPacket, 2)
+PB_BIND(Routing, Routing, AUTO)
+
+
+PB_BIND(Data, Data, 2)
 
 
 PB_BIND(MeshPacket, MeshPacket, 2)
 
 
-PB_BIND(ChannelSettings, ChannelSettings, AUTO)
-
-
-PB_BIND(RadioConfig, RadioConfig, 2)
-
-
-PB_BIND(RadioConfig_UserPreferences, RadioConfig_UserPreferences, 2)
-
-
 PB_BIND(NodeInfo, NodeInfo, AUTO)
 
 
@@ -54,8 +45,3 @@ PB_BIND(ToRadio, ToRadio, 2)
 
 
 
-
-
-
-
-

src/mesh/generated/mesh.pb.h

@@ -11,66 +11,11 @@
 #endif
 
 /* Enum definitions */
-typedef enum _ErrorReason {
-    ErrorReason_NONE = 0,
-    ErrorReason_NO_ROUTE = 1,
-    ErrorReason_GOT_NAK = 2,
-    ErrorReason_TIMEOUT = 3,
-    ErrorReason_NO_INTERFACE = 4,
-    ErrorReason_MAX_RETRANSMIT = 5
-} ErrorReason;
-
 typedef enum _Constants {
     Constants_Unused = 0,
     Constants_DATA_PAYLOAD_LEN = 240
 } Constants;
 
-typedef enum _RegionCode {
-    RegionCode_Unset = 0,
-    RegionCode_US = 1,
-    RegionCode_EU433 = 2,
-    RegionCode_EU865 = 3,
-    RegionCode_CN = 4,
-    RegionCode_JP = 5,
-    RegionCode_ANZ = 6,
-    RegionCode_KR = 7,
-    RegionCode_TW = 8
-} RegionCode;
-
-typedef enum _ChargeCurrent {
-    ChargeCurrent_MAUnset = 0,
-    ChargeCurrent_MA100 = 1,
-    ChargeCurrent_MA190 = 2,
-    ChargeCurrent_MA280 = 3,
-    ChargeCurrent_MA360 = 4,
-    ChargeCurrent_MA450 = 5,
-    ChargeCurrent_MA550 = 6,
-    ChargeCurrent_MA630 = 7,
-    ChargeCurrent_MA700 = 8,
-    ChargeCurrent_MA780 = 9,
-    ChargeCurrent_MA880 = 10,
-    ChargeCurrent_MA960 = 11,
-    ChargeCurrent_MA1000 = 12,
-    ChargeCurrent_MA1080 = 13,
-    ChargeCurrent_MA1160 = 14,
-    ChargeCurrent_MA1240 = 15,
-    ChargeCurrent_MA1320 = 16
-} ChargeCurrent;
-
-typedef enum _GpsOperation {
-    GpsOperation_GpsOpUnset = 0,
-    GpsOperation_GpsOpStationary = 1,
-    GpsOperation_GpsOpMobile = 2,
-    GpsOperation_GpsOpTimeOnly = 3,
-    GpsOperation_GpsOpDisabled = 4
-} GpsOperation;
-
-typedef enum _LocationSharing {
-    LocationSharing_LocUnset = 0,
-    LocationSharing_LocEnabled = 1,
-    LocationSharing_LocDisabled = 2
-} LocationSharing;
-
 typedef enum _CriticalErrorCode {
     CriticalErrorCode_None = 0,
     CriticalErrorCode_TxWatchdog = 1,
@@ -83,6 +28,17 @@ typedef enum _CriticalErrorCode {
     CriticalErrorCode_TransmitFailed = 8
 } CriticalErrorCode;
 
+typedef enum _Routing_Error {
+    Routing_Error_NONE = 0,
+    Routing_Error_NO_ROUTE = 1,
+    Routing_Error_GOT_NAK = 2,
+    Routing_Error_TIMEOUT = 3,
+    Routing_Error_NO_INTERFACE = 4,
+    Routing_Error_MAX_RETRANSMIT = 5,
+    Routing_Error_NO_CHANNEL = 6,
+    Routing_Error_TOO_LARGE = 7
+} Routing_Error;
+
 typedef enum _MeshPacket_Priority {
     MeshPacket_Priority_UNSET = 0,
     MeshPacket_Priority_MIN = 1,
@@ -93,13 +49,6 @@ typedef enum _MeshPacket_Priority {
     MeshPacket_Priority_MAX = 127
 } MeshPacket_Priority;
 
-typedef enum _ChannelSettings_ModemConfig {
-    ChannelSettings_ModemConfig_Bw125Cr45Sf128 = 0,
-    ChannelSettings_ModemConfig_Bw500Cr45Sf128 = 1,
-    ChannelSettings_ModemConfig_Bw31_25Cr48Sf512 = 2,
-    ChannelSettings_ModemConfig_Bw125Cr48Sf4096 = 3
-} ChannelSettings_ModemConfig;
-
 typedef enum _LogRecord_Level {
     LogRecord_Level_UNSET = 0,
     LogRecord_Level_CRITICAL = 50,
@@ -111,25 +60,14 @@ typedef enum _LogRecord_Level {
 } LogRecord_Level;
 
 /* Struct definitions */
-typedef PB_BYTES_ARRAY_T(32) ChannelSettings_psk_t;
-typedef struct _ChannelSettings {
-    int32_t tx_power;
-    ChannelSettings_ModemConfig modem_config;
-    ChannelSettings_psk_t psk;
-    char name[12];
-    uint32_t bandwidth;
-    uint32_t spread_factor;
-    uint32_t coding_rate;
-    uint32_t channel_num;
-    uint32_t id;
-    bool uplink_enabled;
-    bool downlink_enabled;
-} ChannelSettings;
-
-typedef PB_BYTES_ARRAY_T(240) Data_payload_t;
+typedef PB_BYTES_ARRAY_T(237) Data_payload_t;
 typedef struct _Data {
     PortNum portnum;
     Data_payload_t payload;
+    bool want_response;
+    uint32_t dest;
+    uint32_t source;
+    uint32_t request_id;
 } Data;
 
 typedef struct _LogRecord {
@@ -142,82 +80,29 @@ typedef struct _LogRecord {
 typedef struct _MyNodeInfo {
     uint32_t my_node_num;
     bool has_gps;
-    int32_t num_channels;
+    uint32_t num_bands;
     char region[12];
     char hw_model[16];
     char firmware_version[12];
     CriticalErrorCode error_code;
     uint32_t error_address;
     uint32_t error_count;
-    uint32_t packet_id_bits;
-    uint32_t current_packet_id;
-    uint32_t node_num_bits;
     uint32_t message_timeout_msec;
     uint32_t min_app_version;
+    uint32_t max_channels;
 } MyNodeInfo;
 
 typedef struct _Position {
-    int32_t altitude;
-    int32_t battery_level;
     int32_t latitude_i;
     int32_t longitude_i;
+    int32_t altitude;
+    int32_t battery_level;
     uint32_t time;
 } Position;
 
-typedef struct _RadioConfig_UserPreferences {
-    uint32_t position_broadcast_secs;
-    uint32_t send_owner_interval;
-    uint32_t wait_bluetooth_secs;
-    uint32_t screen_on_secs;
-    uint32_t phone_timeout_secs;
-    uint32_t phone_sds_timeout_sec;
-    uint32_t mesh_sds_timeout_secs;
-    uint32_t sds_secs;
-    uint32_t ls_secs;
-    uint32_t min_wake_secs;
-    char wifi_ssid[33];
-    char wifi_password[64];
-    bool wifi_ap_mode;
-    RegionCode region;
-    ChargeCurrent charge_current;
-    LocationSharing location_share;
-    GpsOperation gps_operation;
-    uint32_t gps_update_interval;
-    uint32_t gps_attempt_time;
-    bool is_router;
-    bool is_low_power;
-    bool fixed_position;
-    bool factory_reset;
-    bool debug_log_enabled;
-    pb_size_t ignore_incoming_count;
-    uint32_t ignore_incoming[3];
-    bool serialplugin_enabled;
-    bool serialplugin_echo;
-    uint32_t serialplugin_rxd;
-    uint32_t serialplugin_txd;
-    uint32_t serialplugin_timeout;
-    uint32_t serialplugin_mode;
-    bool ext_notification_plugin_enabled;
-    uint32_t ext_notification_plugin_output_ms;
-    uint32_t ext_notification_plugin_output;
-    bool ext_notification_plugin_active;
-    bool ext_notification_plugin_alert_message;
-    bool ext_notification_plugin_alert_bell;
-    bool range_test_plugin_enabled;
-    uint32_t range_test_plugin_sender;
-    bool range_test_plugin_save;
-    bool store_forward_plugin_enabled;
-    uint32_t store_forward_plugin_records;
-    bool environmental_measurement_plugin_measurement_enabled;
-    bool environmental_measurement_plugin_screen_enabled;
-    uint32_t environmental_measurement_plugin_read_error_count_threshold;
-    uint32_t environmental_measurement_plugin_update_interval;
-    uint32_t environmental_measurement_plugin_recovery_interval;
-} RadioConfig_UserPreferences;
-
 typedef struct _RouteDiscovery {
     pb_size_t route_count;
-    int32_t route[8];
+    uint32_t route[8];
 } RouteDiscovery;
 
 typedef struct _User {
@@ -227,6 +112,24 @@ typedef struct _User {
     pb_byte_t macaddr[6];
 } User;
 
+typedef PB_BYTES_ARRAY_T(256) MeshPacket_encrypted_t;
+typedef struct _MeshPacket {
+    uint32_t from;
+    uint32_t to;
+    uint8_t channel;
+    pb_size_t which_payloadVariant;
+    union {
+        Data decoded;
+        MeshPacket_encrypted_t encrypted;
+    };
+    uint32_t id;
+    uint32_t rx_time;
+    float rx_snr;
+    uint8_t hop_limit;
+    bool want_ack;
+    MeshPacket_Priority priority;
+} MeshPacket;
+
 typedef struct _NodeInfo {
     uint32_t num;
     bool has_user;
@@ -237,64 +140,25 @@ typedef struct _NodeInfo {
     float snr;
 } NodeInfo;
 
-typedef struct _RadioConfig {
-    bool has_preferences;
-    RadioConfig_UserPreferences preferences;
-    bool has_channel_settings;
-    ChannelSettings channel_settings;
-} RadioConfig;
-
-typedef struct _SubPacket {
-    pb_size_t which_payloadVariant;
+typedef struct _Routing {
+    pb_size_t which_variant;
     union {
-        Position position;
-        Data data;
-        User user;
         RouteDiscovery route_request;
         RouteDiscovery route_reply;
-        ErrorReason error_reason;
+        Routing_Error error_reason;
     };
-    uint32_t original_id;
-    bool want_response;
-    uint32_t dest;
-    pb_size_t which_ackVariant;
-    union {
-        uint32_t success_id;
-        uint32_t fail_id;
-    } ackVariant;
-    uint32_t source;
-} SubPacket;
-
-typedef PB_BYTES_ARRAY_T(256) MeshPacket_encrypted_t;
-typedef struct _MeshPacket {
-    uint32_t from;
-    uint32_t to;
-    pb_size_t which_payloadVariant;
-    union {
-        SubPacket decoded;
-        MeshPacket_encrypted_t encrypted;
-    };
-    uint32_t channel_index;
-    uint32_t id;
-    float rx_snr;
-    uint32_t rx_time;
-    uint32_t hop_limit;
-    bool want_ack;
-    MeshPacket_Priority priority;
-} MeshPacket;
+} Routing;
 
 typedef struct _FromRadio {
     uint32_t num;
     pb_size_t which_payloadVariant;
     union {
-        MeshPacket packet;
         MyNodeInfo my_info;
         NodeInfo node_info;
-        RadioConfig radio;
         LogRecord log_record;
         uint32_t config_complete_id;
         bool rebooted;
-        ChannelSettings channel;
+        MeshPacket packet;
     };
 } FromRadio;
 
@@ -303,50 +167,27 @@ typedef struct _ToRadio {
     union {
         MeshPacket packet;
         uint32_t want_config_id;
-        RadioConfig set_radio;
-        User set_owner;
-        ChannelSettings set_channel;
     };
 } ToRadio;
 
 
 /* Helper constants for enums */
-#define _ErrorReason_MIN ErrorReason_NONE
-#define _ErrorReason_MAX ErrorReason_MAX_RETRANSMIT
-#define _ErrorReason_ARRAYSIZE ((ErrorReason)(ErrorReason_MAX_RETRANSMIT+1))
-
 #define _Constants_MIN Constants_Unused
 #define _Constants_MAX Constants_DATA_PAYLOAD_LEN
 #define _Constants_ARRAYSIZE ((Constants)(Constants_DATA_PAYLOAD_LEN+1))
 
-#define _RegionCode_MIN RegionCode_Unset
-#define _RegionCode_MAX RegionCode_TW
-#define _RegionCode_ARRAYSIZE ((RegionCode)(RegionCode_TW+1))
-
-#define _ChargeCurrent_MIN ChargeCurrent_MAUnset
-#define _ChargeCurrent_MAX ChargeCurrent_MA1320
-#define _ChargeCurrent_ARRAYSIZE ((ChargeCurrent)(ChargeCurrent_MA1320+1))
-
-#define _GpsOperation_MIN GpsOperation_GpsOpUnset
-#define _GpsOperation_MAX GpsOperation_GpsOpDisabled
-#define _GpsOperation_ARRAYSIZE ((GpsOperation)(GpsOperation_GpsOpDisabled+1))
-
-#define _LocationSharing_MIN LocationSharing_LocUnset
-#define _LocationSharing_MAX LocationSharing_LocDisabled
-#define _LocationSharing_ARRAYSIZE ((LocationSharing)(LocationSharing_LocDisabled+1))
-
 #define _CriticalErrorCode_MIN CriticalErrorCode_None
 #define _CriticalErrorCode_MAX CriticalErrorCode_TransmitFailed
 #define _CriticalErrorCode_ARRAYSIZE ((CriticalErrorCode)(CriticalErrorCode_TransmitFailed+1))
 
+#define _Routing_Error_MIN Routing_Error_NONE
+#define _Routing_Error_MAX Routing_Error_TOO_LARGE
+#define _Routing_Error_ARRAYSIZE ((Routing_Error)(Routing_Error_TOO_LARGE+1))
+
 #define _MeshPacket_Priority_MIN MeshPacket_Priority_UNSET
 #define _MeshPacket_Priority_MAX MeshPacket_Priority_MAX
 #define _MeshPacket_Priority_ARRAYSIZE ((MeshPacket_Priority)(MeshPacket_Priority_MAX+1))
 
-#define _ChannelSettings_ModemConfig_MIN ChannelSettings_ModemConfig_Bw125Cr45Sf128
-#define _ChannelSettings_ModemConfig_MAX ChannelSettings_ModemConfig_Bw125Cr48Sf4096
-#define _ChannelSettings_ModemConfig_ARRAYSIZE ((ChannelSettings_ModemConfig)(ChannelSettings_ModemConfig_Bw125Cr48Sf4096+1))
-
 #define _LogRecord_Level_MIN LogRecord_Level_UNSET
 #define _LogRecord_Level_MAX LogRecord_Level_CRITICAL
 #define _LogRecord_Level_ARRAYSIZE ((LogRecord_Level)(LogRecord_Level_CRITICAL+1))
@@ -358,184 +199,100 @@ extern "C" {
 
 /* Initializer values for message structs */
 #define Position_init_default                    {0, 0, 0, 0, 0}
-#define Data_init_default                        {_PortNum_MIN, {0, {0}}}
 #define User_init_default                        {"", "", "", {0}}
 #define RouteDiscovery_init_default              {0, {0, 0, 0, 0, 0, 0, 0, 0}}
-#define SubPacket_init_default                   {0, {Position_init_default}, 0, 0, 0, 0, {0}, 0}
-#define MeshPacket_init_default                  {0, 0, 0, {SubPacket_init_default}, 0, 0, 0, 0, 0, 0, _MeshPacket_Priority_MIN}
-#define ChannelSettings_init_default             {0, _ChannelSettings_ModemConfig_MIN, {0, {0}}, "", 0, 0, 0, 0, 0, 0, 0}
-#define RadioConfig_init_default                 {false, RadioConfig_UserPreferences_init_default, false, ChannelSettings_init_default}
-#define RadioConfig_UserPreferences_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#define Routing_init_default                     {0, {RouteDiscovery_init_default}}
+#define Data_init_default                        {_PortNum_MIN, {0, {0}}, 0, 0, 0, 0}
+#define MeshPacket_init_default                  {0, 0, 0, 0, {Data_init_default}, 0, 0, 0, 0, 0, _MeshPacket_Priority_MIN}
 #define NodeInfo_init_default                    {0, false, User_init_default, false, Position_init_default, 0, 0}
-#define MyNodeInfo_init_default                  {0, 0, 0, "", "", "", _CriticalErrorCode_MIN, 0, 0, 0, 0, 0, 0, 0}
+#define MyNodeInfo_init_default                  {0, 0, 0, "", "", "", _CriticalErrorCode_MIN, 0, 0, 0, 0, 0}
 #define LogRecord_init_default                   {"", 0, "", _LogRecord_Level_MIN}
-#define FromRadio_init_default                   {0, 0, {MeshPacket_init_default}}
+#define FromRadio_init_default                   {0, 0, {MyNodeInfo_init_default}}
 #define ToRadio_init_default                     {0, {MeshPacket_init_default}}
 #define Position_init_zero                       {0, 0, 0, 0, 0}
-#define Data_init_zero                           {_PortNum_MIN, {0, {0}}}
 #define User_init_zero                           {"", "", "", {0}}
 #define RouteDiscovery_init_zero                 {0, {0, 0, 0, 0, 0, 0, 0, 0}}
-#define SubPacket_init_zero                      {0, {Position_init_zero}, 0, 0, 0, 0, {0}, 0}
-#define MeshPacket_init_zero                     {0, 0, 0, {SubPacket_init_zero}, 0, 0, 0, 0, 0, 0, _MeshPacket_Priority_MIN}
-#define ChannelSettings_init_zero                {0, _ChannelSettings_ModemConfig_MIN, {0, {0}}, "", 0, 0, 0, 0, 0, 0, 0}
-#define RadioConfig_init_zero                    {false, RadioConfig_UserPreferences_init_zero, false, ChannelSettings_init_zero}
-#define RadioConfig_UserPreferences_init_zero    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#define Routing_init_zero                        {0, {RouteDiscovery_init_zero}}
+#define Data_init_zero                           {_PortNum_MIN, {0, {0}}, 0, 0, 0, 0}
+#define MeshPacket_init_zero                     {0, 0, 0, 0, {Data_init_zero}, 0, 0, 0, 0, 0, _MeshPacket_Priority_MIN}
 #define NodeInfo_init_zero                       {0, false, User_init_zero, false, Position_init_zero, 0, 0}
-#define MyNodeInfo_init_zero                     {0, 0, 0, "", "", "", _CriticalErrorCode_MIN, 0, 0, 0, 0, 0, 0, 0}
+#define MyNodeInfo_init_zero                     {0, 0, 0, "", "", "", _CriticalErrorCode_MIN, 0, 0, 0, 0, 0}
 #define LogRecord_init_zero                      {"", 0, "", _LogRecord_Level_MIN}
-#define FromRadio_init_zero                      {0, 0, {MeshPacket_init_zero}}
+#define FromRadio_init_zero                      {0, 0, {MyNodeInfo_init_zero}}
 #define ToRadio_init_zero                        {0, {MeshPacket_init_zero}}
 
 /* Field tags (for use in manual encoding/decoding) */
-#define ChannelSettings_tx_power_tag             1
-#define ChannelSettings_modem_config_tag         3
-#define ChannelSettings_psk_tag                  4
-#define ChannelSettings_name_tag                 5
-#define ChannelSettings_bandwidth_tag            6
-#define ChannelSettings_spread_factor_tag        7
-#define ChannelSettings_coding_rate_tag          8
-#define ChannelSettings_channel_num_tag          9
-#define ChannelSettings_id_tag                   10
-#define ChannelSettings_uplink_enabled_tag       16
-#define ChannelSettings_downlink_enabled_tag     17
 #define Data_portnum_tag                         1
 #define Data_payload_tag                         2
+#define Data_want_response_tag                   3
+#define Data_dest_tag                            4
+#define Data_source_tag                          5
+#define Data_request_id_tag                      6
 #define LogRecord_message_tag                    1
 #define LogRecord_time_tag                       2
 #define LogRecord_source_tag                     3
 #define LogRecord_level_tag                      4
 #define MyNodeInfo_my_node_num_tag               1
 #define MyNodeInfo_has_gps_tag                   2
-#define MyNodeInfo_num_channels_tag              3
+#define MyNodeInfo_num_bands_tag                 3
 #define MyNodeInfo_region_tag                    4
 #define MyNodeInfo_hw_model_tag                  5
 #define MyNodeInfo_firmware_version_tag          6
 #define MyNodeInfo_error_code_tag                7
 #define MyNodeInfo_error_address_tag             8
 #define MyNodeInfo_error_count_tag               9
-#define MyNodeInfo_packet_id_bits_tag            10
-#define MyNodeInfo_current_packet_id_tag         11
-#define MyNodeInfo_node_num_bits_tag             12
 #define MyNodeInfo_message_timeout_msec_tag      13
 #define MyNodeInfo_min_app_version_tag           14
+#define MyNodeInfo_max_channels_tag              15
+#define Position_latitude_i_tag                  1
+#define Position_longitude_i_tag                 2
 #define Position_altitude_tag                    3
 #define Position_battery_level_tag               4
-#define Position_latitude_i_tag                  7
-#define Position_longitude_i_tag                 8
 #define Position_time_tag                        9
-#define RadioConfig_UserPreferences_position_broadcast_secs_tag 1
-#define RadioConfig_UserPreferences_send_owner_interval_tag 2
-#define RadioConfig_UserPreferences_wait_bluetooth_secs_tag 4
-#define RadioConfig_UserPreferences_screen_on_secs_tag 5
-#define RadioConfig_UserPreferences_phone_timeout_secs_tag 6
-#define RadioConfig_UserPreferences_phone_sds_timeout_sec_tag 7
-#define RadioConfig_UserPreferences_mesh_sds_timeout_secs_tag 8
-#define RadioConfig_UserPreferences_sds_secs_tag 9
-#define RadioConfig_UserPreferences_ls_secs_tag  10
-#define RadioConfig_UserPreferences_min_wake_secs_tag 11
-#define RadioConfig_UserPreferences_wifi_ssid_tag 12
-#define RadioConfig_UserPreferences_wifi_password_tag 13
-#define RadioConfig_UserPreferences_wifi_ap_mode_tag 14
-#define RadioConfig_UserPreferences_region_tag   15
-#define RadioConfig_UserPreferences_charge_current_tag 16
-#define RadioConfig_UserPreferences_location_share_tag 32
-#define RadioConfig_UserPreferences_gps_operation_tag 33
-#define RadioConfig_UserPreferences_gps_update_interval_tag 34
-#define RadioConfig_UserPreferences_gps_attempt_time_tag 36
-#define RadioConfig_UserPreferences_is_router_tag 37
-#define RadioConfig_UserPreferences_is_low_power_tag 38
-#define RadioConfig_UserPreferences_fixed_position_tag 39
-#define RadioConfig_UserPreferences_factory_reset_tag 100
-#define RadioConfig_UserPreferences_debug_log_enabled_tag 101
-#define RadioConfig_UserPreferences_ignore_incoming_tag 103
-#define RadioConfig_UserPreferences_serialplugin_enabled_tag 120
-#define RadioConfig_UserPreferences_serialplugin_echo_tag 121
-#define RadioConfig_UserPreferences_serialplugin_rxd_tag 122
-#define RadioConfig_UserPreferences_serialplugin_txd_tag 123
-#define RadioConfig_UserPreferences_serialplugin_timeout_tag 124
-#define RadioConfig_UserPreferences_serialplugin_mode_tag 125
-#define RadioConfig_UserPreferences_ext_notification_plugin_enabled_tag 126
-#define RadioConfig_UserPreferences_ext_notification_plugin_output_ms_tag 127
-#define RadioConfig_UserPreferences_ext_notification_plugin_output_tag 128
-#define RadioConfig_UserPreferences_ext_notification_plugin_active_tag 129
-#define RadioConfig_UserPreferences_ext_notification_plugin_alert_message_tag 130
-#define RadioConfig_UserPreferences_ext_notification_plugin_alert_bell_tag 131
-#define RadioConfig_UserPreferences_range_test_plugin_enabled_tag 132
-#define RadioConfig_UserPreferences_range_test_plugin_sender_tag 133
-#define RadioConfig_UserPreferences_range_test_plugin_save_tag 134
-#define RadioConfig_UserPreferences_store_forward_plugin_enabled_tag 136
-#define RadioConfig_UserPreferences_store_forward_plugin_records_tag 137
-#define RadioConfig_UserPreferences_environmental_measurement_plugin_measurement_enabled_tag 140
-#define RadioConfig_UserPreferences_environmental_measurement_plugin_screen_enabled_tag 141
-#define RadioConfig_UserPreferences_environmental_measurement_plugin_read_error_count_threshold_tag 142
-#define RadioConfig_UserPreferences_environmental_measurement_plugin_update_interval_tag 143
-#define RadioConfig_UserPreferences_environmental_measurement_plugin_recovery_interval_tag 144
 #define RouteDiscovery_route_tag                 2
 #define User_id_tag                              1
 #define User_long_name_tag                       2
 #define User_short_name_tag                      3
 #define User_macaddr_tag                         4
+#define MeshPacket_from_tag                      1
+#define MeshPacket_to_tag                        2
+#define MeshPacket_channel_tag                   3
+#define MeshPacket_decoded_tag                   4
+#define MeshPacket_encrypted_tag                 5
+#define MeshPacket_id_tag                        6
+#define MeshPacket_rx_time_tag                   7
+#define MeshPacket_rx_snr_tag                    8
+#define MeshPacket_hop_limit_tag                 10
+#define MeshPacket_want_ack_tag                  11
+#define MeshPacket_priority_tag                  12
 #define NodeInfo_num_tag                         1
 #define NodeInfo_user_tag                        2
 #define NodeInfo_position_tag                    3
 #define NodeInfo_next_hop_tag                    5
 #define NodeInfo_snr_tag                         7
-#define RadioConfig_preferences_tag              1
-#define RadioConfig_channel_settings_tag         2
-#define SubPacket_position_tag                   1
-#define SubPacket_data_tag                       3
-#define SubPacket_user_tag                       4
-#define SubPacket_route_request_tag              6
-#define SubPacket_route_reply_tag                7
-#define SubPacket_error_reason_tag               13
-#define SubPacket_original_id_tag                2
-#define SubPacket_want_response_tag              5
-#define SubPacket_dest_tag                       9
-#define SubPacket_success_id_tag                 10
-#define SubPacket_fail_id_tag                    11
-#define SubPacket_source_tag                     12
-#define MeshPacket_from_tag                      1
-#define MeshPacket_to_tag                        2
-#define MeshPacket_decoded_tag                   3
-#define MeshPacket_encrypted_tag                 8
-#define MeshPacket_channel_index_tag             4
-#define MeshPacket_id_tag                        6
-#define MeshPacket_rx_snr_tag                    7
-#define MeshPacket_rx_time_tag                   9
-#define MeshPacket_hop_limit_tag                 10
-#define MeshPacket_want_ack_tag                  11
-#define MeshPacket_priority_tag                  12
+#define Routing_route_request_tag                1
+#define Routing_route_reply_tag                  2
+#define Routing_error_reason_tag                 3
 #define FromRadio_num_tag                        1
-#define FromRadio_packet_tag                     2
 #define FromRadio_my_info_tag                    3
 #define FromRadio_node_info_tag                  4
-#define FromRadio_radio_tag                      6
 #define FromRadio_log_record_tag                 7
 #define FromRadio_config_complete_id_tag         8
 #define FromRadio_rebooted_tag                   9
-#define FromRadio_channel_tag                    10
-#define ToRadio_packet_tag                       1
+#define FromRadio_packet_tag                     11
+#define ToRadio_packet_tag                       2
 #define ToRadio_want_config_id_tag               100
-#define ToRadio_set_radio_tag                    101
-#define ToRadio_set_owner_tag                    102
-#define ToRadio_set_channel_tag                  103
 
 /* Struct field encoding specification for nanopb */
 #define Position_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, SFIXED32, latitude_i,        1) \
+X(a, STATIC,   SINGULAR, SFIXED32, longitude_i,       2) \
 X(a, STATIC,   SINGULAR, INT32,    altitude,          3) \
 X(a, STATIC,   SINGULAR, INT32,    battery_level,     4) \
-X(a, STATIC,   SINGULAR, SINT32,   latitude_i,        7) \
-X(a, STATIC,   SINGULAR, SINT32,   longitude_i,       8) \
 X(a, STATIC,   SINGULAR, FIXED32,  time,              9)
 #define Position_CALLBACK NULL
 #define Position_DEFAULT NULL
 
-#define Data_FIELDLIST(X, a) \
-X(a, STATIC,   SINGULAR, UENUM,    portnum,           1) \
-X(a, STATIC,   SINGULAR, BYTES,    payload,           2)
-#define Data_CALLBACK NULL
-#define Data_DEFAULT NULL
-
 #define User_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, STRING,   id,                1) \
 X(a, STATIC,   SINGULAR, STRING,   long_name,         2) \
@@ -545,120 +302,44 @@ X(a, STATIC,   SINGULAR, FIXED_LENGTH_BYTES, macaddr,           4)
 #define User_DEFAULT NULL
 
 #define RouteDiscovery_FIELDLIST(X, a) \
-X(a, STATIC,   REPEATED, INT32,    route,             2)
+X(a, STATIC,   REPEATED, FIXED32,  route,             2)
 #define RouteDiscovery_CALLBACK NULL
 #define RouteDiscovery_DEFAULT NULL
 
-#define SubPacket_FIELDLIST(X, a) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,position,position),   1) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,data,data),   3) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,user,user),   4) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,route_request,route_request),   6) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,route_reply,route_reply),   7) \
-X(a, STATIC,   ONEOF,    UENUM,    (payloadVariant,error_reason,error_reason),  13) \
-X(a, STATIC,   SINGULAR, UINT32,   original_id,       2) \
-X(a, STATIC,   SINGULAR, BOOL,     want_response,     5) \
-X(a, STATIC,   SINGULAR, UINT32,   dest,              9) \
-X(a, STATIC,   ONEOF,    UINT32,   (ackVariant,success_id,ackVariant.success_id),  10) \
-X(a, STATIC,   ONEOF,    UINT32,   (ackVariant,fail_id,ackVariant.fail_id),  11) \
-X(a, STATIC,   SINGULAR, UINT32,   source,           12)
-#define SubPacket_CALLBACK NULL
-#define SubPacket_DEFAULT NULL
-#define SubPacket_payloadVariant_position_MSGTYPE Position
-#define SubPacket_payloadVariant_data_MSGTYPE Data
-#define SubPacket_payloadVariant_user_MSGTYPE User
-#define SubPacket_payloadVariant_route_request_MSGTYPE RouteDiscovery
-#define SubPacket_payloadVariant_route_reply_MSGTYPE RouteDiscovery
+#define Routing_FIELDLIST(X, a) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,route_request,route_request),   1) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,route_reply,route_reply),   2) \
+X(a, STATIC,   ONEOF,    UENUM,    (variant,error_reason,error_reason),   3)
+#define Routing_CALLBACK NULL
+#define Routing_DEFAULT NULL
+#define Routing_variant_route_request_MSGTYPE RouteDiscovery
+#define Routing_variant_route_reply_MSGTYPE RouteDiscovery
+
+#define Data_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UENUM,    portnum,           1) \
+X(a, STATIC,   SINGULAR, BYTES,    payload,           2) \
+X(a, STATIC,   SINGULAR, BOOL,     want_response,     3) \
+X(a, STATIC,   SINGULAR, FIXED32,  dest,              4) \
+X(a, STATIC,   SINGULAR, FIXED32,  source,            5) \
+X(a, STATIC,   SINGULAR, FIXED32,  request_id,        6)
+#define Data_CALLBACK NULL
+#define Data_DEFAULT NULL
 
 #define MeshPacket_FIELDLIST(X, a) \
-X(a, STATIC,   SINGULAR, UINT32,   from,              1) \
-X(a, STATIC,   SINGULAR, UINT32,   to,                2) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,decoded,decoded),   3) \
-X(a, STATIC,   ONEOF,    BYTES,    (payloadVariant,encrypted,encrypted),   8) \
-X(a, STATIC,   SINGULAR, UINT32,   channel_index,     4) \
-X(a, STATIC,   SINGULAR, UINT32,   id,                6) \
-X(a, STATIC,   SINGULAR, FLOAT,    rx_snr,            7) \
-X(a, STATIC,   SINGULAR, FIXED32,  rx_time,           9) \
+X(a, STATIC,   SINGULAR, FIXED32,  from,              1) \
+X(a, STATIC,   SINGULAR, FIXED32,  to,                2) \
+X(a, STATIC,   SINGULAR, UINT32,   channel,           3) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,decoded,decoded),   4) \
+X(a, STATIC,   ONEOF,    BYTES,    (payloadVariant,encrypted,encrypted),   5) \
+X(a, STATIC,   SINGULAR, FIXED32,  id,                6) \
+X(a, STATIC,   SINGULAR, FIXED32,  rx_time,           7) \
+X(a, STATIC,   SINGULAR, FLOAT,    rx_snr,            8) \
 X(a, STATIC,   SINGULAR, UINT32,   hop_limit,        10) \
 X(a, STATIC,   SINGULAR, BOOL,     want_ack,         11) \
 X(a, STATIC,   SINGULAR, UENUM,    priority,         12)
 #define MeshPacket_CALLBACK NULL
 #define MeshPacket_DEFAULT NULL
-#define MeshPacket_payloadVariant_decoded_MSGTYPE SubPacket
-
-#define ChannelSettings_FIELDLIST(X, a) \
-X(a, STATIC,   SINGULAR, INT32,    tx_power,          1) \
-X(a, STATIC,   SINGULAR, UENUM,    modem_config,      3) \
-X(a, STATIC,   SINGULAR, BYTES,    psk,               4) \
-X(a, STATIC,   SINGULAR, STRING,   name,              5) \
-X(a, STATIC,   SINGULAR, UINT32,   bandwidth,         6) \
-X(a, STATIC,   SINGULAR, UINT32,   spread_factor,     7) \
-X(a, STATIC,   SINGULAR, UINT32,   coding_rate,       8) \
-X(a, STATIC,   SINGULAR, UINT32,   channel_num,       9) \
-X(a, STATIC,   SINGULAR, FIXED32,  id,               10) \
-X(a, STATIC,   SINGULAR, BOOL,     uplink_enabled,   16) \
-X(a, STATIC,   SINGULAR, BOOL,     downlink_enabled,  17)
-#define ChannelSettings_CALLBACK NULL
-#define ChannelSettings_DEFAULT NULL
-
-#define RadioConfig_FIELDLIST(X, a) \
-X(a, STATIC,   OPTIONAL, MESSAGE,  preferences,       1) \
-X(a, STATIC,   OPTIONAL, MESSAGE,  channel_settings,   2)
-#define RadioConfig_CALLBACK NULL
-#define RadioConfig_DEFAULT NULL
-#define RadioConfig_preferences_MSGTYPE RadioConfig_UserPreferences
-#define RadioConfig_channel_settings_MSGTYPE ChannelSettings
-
-#define RadioConfig_UserPreferences_FIELDLIST(X, a) \
-X(a, STATIC,   SINGULAR, UINT32,   position_broadcast_secs,   1) \
-X(a, STATIC,   SINGULAR, UINT32,   send_owner_interval,   2) \
-X(a, STATIC,   SINGULAR, UINT32,   wait_bluetooth_secs,   4) \
-X(a, STATIC,   SINGULAR, UINT32,   screen_on_secs,    5) \
-X(a, STATIC,   SINGULAR, UINT32,   phone_timeout_secs,   6) \
-X(a, STATIC,   SINGULAR, UINT32,   phone_sds_timeout_sec,   7) \
-X(a, STATIC,   SINGULAR, UINT32,   mesh_sds_timeout_secs,   8) \
-X(a, STATIC,   SINGULAR, UINT32,   sds_secs,          9) \
-X(a, STATIC,   SINGULAR, UINT32,   ls_secs,          10) \
-X(a, STATIC,   SINGULAR, UINT32,   min_wake_secs,    11) \
-X(a, STATIC,   SINGULAR, STRING,   wifi_ssid,        12) \
-X(a, STATIC,   SINGULAR, STRING,   wifi_password,    13) \
-X(a, STATIC,   SINGULAR, BOOL,     wifi_ap_mode,     14) \
-X(a, STATIC,   SINGULAR, UENUM,    region,           15) \
-X(a, STATIC,   SINGULAR, UENUM,    charge_current,   16) \
-X(a, STATIC,   SINGULAR, UENUM,    location_share,   32) \
-X(a, STATIC,   SINGULAR, UENUM,    gps_operation,    33) \
-X(a, STATIC,   SINGULAR, UINT32,   gps_update_interval,  34) \
-X(a, STATIC,   SINGULAR, UINT32,   gps_attempt_time,  36) \
-X(a, STATIC,   SINGULAR, BOOL,     is_router,        37) \
-X(a, STATIC,   SINGULAR, BOOL,     is_low_power,     38) \
-X(a, STATIC,   SINGULAR, BOOL,     fixed_position,   39) \
-X(a, STATIC,   SINGULAR, BOOL,     factory_reset,   100) \
-X(a, STATIC,   SINGULAR, BOOL,     debug_log_enabled, 101) \
-X(a, STATIC,   REPEATED, UINT32,   ignore_incoming, 103) \
-X(a, STATIC,   SINGULAR, BOOL,     serialplugin_enabled, 120) \
-X(a, STATIC,   SINGULAR, BOOL,     serialplugin_echo, 121) \
-X(a, STATIC,   SINGULAR, UINT32,   serialplugin_rxd, 122) \
-X(a, STATIC,   SINGULAR, UINT32,   serialplugin_txd, 123) \
-X(a, STATIC,   SINGULAR, UINT32,   serialplugin_timeout, 124) \
-X(a, STATIC,   SINGULAR, UINT32,   serialplugin_mode, 125) \
-X(a, STATIC,   SINGULAR, BOOL,     ext_notification_plugin_enabled, 126) \
-X(a, STATIC,   SINGULAR, UINT32,   ext_notification_plugin_output_ms, 127) \
-X(a, STATIC,   SINGULAR, UINT32,   ext_notification_plugin_output, 128) \
-X(a, STATIC,   SINGULAR, BOOL,     ext_notification_plugin_active, 129) \
-X(a, STATIC,   SINGULAR, BOOL,     ext_notification_plugin_alert_message, 130) \
-X(a, STATIC,   SINGULAR, BOOL,     ext_notification_plugin_alert_bell, 131) \
-X(a, STATIC,   SINGULAR, BOOL,     range_test_plugin_enabled, 132) \
-X(a, STATIC,   SINGULAR, UINT32,   range_test_plugin_sender, 133) \
-X(a, STATIC,   SINGULAR, BOOL,     range_test_plugin_save, 134) \
-X(a, STATIC,   SINGULAR, BOOL,     store_forward_plugin_enabled, 136) \
-X(a, STATIC,   SINGULAR, UINT32,   store_forward_plugin_records, 137) \
-X(a, STATIC,   SINGULAR, BOOL,     environmental_measurement_plugin_measurement_enabled, 140) \
-X(a, STATIC,   SINGULAR, BOOL,     environmental_measurement_plugin_screen_enabled, 141) \
-X(a, STATIC,   SINGULAR, UINT32,   environmental_measurement_plugin_read_error_count_threshold, 142) \
-X(a, STATIC,   SINGULAR, UINT32,   environmental_measurement_plugin_update_interval, 143) \
-X(a, STATIC,   SINGULAR, UINT32,   environmental_measurement_plugin_recovery_interval, 144)
-#define RadioConfig_UserPreferences_CALLBACK NULL
-#define RadioConfig_UserPreferences_DEFAULT NULL
+#define MeshPacket_payloadVariant_decoded_MSGTYPE Data
 
 #define NodeInfo_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, UINT32,   num,               1) \
@@ -674,18 +355,16 @@ X(a, STATIC,   SINGULAR, FLOAT,    snr,               7)
 #define MyNodeInfo_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, UINT32,   my_node_num,       1) \
 X(a, STATIC,   SINGULAR, BOOL,     has_gps,           2) \
-X(a, STATIC,   SINGULAR, INT32,    num_channels,      3) \
+X(a, STATIC,   SINGULAR, UINT32,   num_bands,         3) \
 X(a, STATIC,   SINGULAR, STRING,   region,            4) \
 X(a, STATIC,   SINGULAR, STRING,   hw_model,          5) \
 X(a, STATIC,   SINGULAR, STRING,   firmware_version,   6) \
 X(a, STATIC,   SINGULAR, UENUM,    error_code,        7) \
 X(a, STATIC,   SINGULAR, UINT32,   error_address,     8) \
 X(a, STATIC,   SINGULAR, UINT32,   error_count,       9) \
-X(a, STATIC,   SINGULAR, UINT32,   packet_id_bits,   10) \
-X(a, STATIC,   SINGULAR, UINT32,   current_packet_id,  11) \
-X(a, STATIC,   SINGULAR, UINT32,   node_num_bits,    12) \
 X(a, STATIC,   SINGULAR, UINT32,   message_timeout_msec,  13) \
-X(a, STATIC,   SINGULAR, UINT32,   min_app_version,  14)
+X(a, STATIC,   SINGULAR, UINT32,   min_app_version,  14) \
+X(a, STATIC,   SINGULAR, UINT32,   max_channels,     15)
 #define MyNodeInfo_CALLBACK NULL
 #define MyNodeInfo_DEFAULT NULL
 
@@ -699,45 +378,32 @@ X(a, STATIC,   SINGULAR, UENUM,    level,             4)
 
 #define FromRadio_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, UINT32,   num,               1) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,packet,packet),   2) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,my_info,my_info),   3) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,node_info,node_info),   4) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,radio,radio),   6) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,log_record,log_record),   7) \
 X(a, STATIC,   ONEOF,    UINT32,   (payloadVariant,config_complete_id,config_complete_id),   8) \
 X(a, STATIC,   ONEOF,    BOOL,     (payloadVariant,rebooted,rebooted),   9) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,channel,channel),  10)
+X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,packet,packet),  11)
 #define FromRadio_CALLBACK NULL
 #define FromRadio_DEFAULT NULL
-#define FromRadio_payloadVariant_packet_MSGTYPE MeshPacket
 #define FromRadio_payloadVariant_my_info_MSGTYPE MyNodeInfo
 #define FromRadio_payloadVariant_node_info_MSGTYPE NodeInfo
-#define FromRadio_payloadVariant_radio_MSGTYPE RadioConfig
 #define FromRadio_payloadVariant_log_record_MSGTYPE LogRecord
-#define FromRadio_payloadVariant_channel_MSGTYPE ChannelSettings
+#define FromRadio_payloadVariant_packet_MSGTYPE MeshPacket
 
 #define ToRadio_FIELDLIST(X, a) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,packet,packet),   1) \
-X(a, STATIC,   ONEOF,    UINT32,   (payloadVariant,want_config_id,want_config_id), 100) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,set_radio,set_radio), 101) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,set_owner,set_owner), 102) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,set_channel,set_channel), 103)
+X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,packet,packet),   2) \
+X(a, STATIC,   ONEOF,    UINT32,   (payloadVariant,want_config_id,want_config_id), 100)
 #define ToRadio_CALLBACK NULL
 #define ToRadio_DEFAULT NULL
 #define ToRadio_payloadVariant_packet_MSGTYPE MeshPacket
-#define ToRadio_payloadVariant_set_radio_MSGTYPE RadioConfig
-#define ToRadio_payloadVariant_set_owner_MSGTYPE User
-#define ToRadio_payloadVariant_set_channel_MSGTYPE ChannelSettings
 
 extern const pb_msgdesc_t Position_msg;
-extern const pb_msgdesc_t Data_msg;
 extern const pb_msgdesc_t User_msg;
 extern const pb_msgdesc_t RouteDiscovery_msg;
-extern const pb_msgdesc_t SubPacket_msg;
+extern const pb_msgdesc_t Routing_msg;
+extern const pb_msgdesc_t Data_msg;
 extern const pb_msgdesc_t MeshPacket_msg;
-extern const pb_msgdesc_t ChannelSettings_msg;
-extern const pb_msgdesc_t RadioConfig_msg;
-extern const pb_msgdesc_t RadioConfig_UserPreferences_msg;
 extern const pb_msgdesc_t NodeInfo_msg;
 extern const pb_msgdesc_t MyNodeInfo_msg;
 extern const pb_msgdesc_t LogRecord_msg;
@@ -746,14 +412,11 @@ extern const pb_msgdesc_t ToRadio_msg;
 
 /* Defines for backwards compatibility with code written before nanopb-0.4.0 */
 #define Position_fields &Position_msg
-#define Data_fields &Data_msg
 #define User_fields &User_msg
 #define RouteDiscovery_fields &RouteDiscovery_msg
-#define SubPacket_fields &SubPacket_msg
+#define Routing_fields &Routing_msg
+#define Data_fields &Data_msg
 #define MeshPacket_fields &MeshPacket_msg
-#define ChannelSettings_fields &ChannelSettings_msg
-#define RadioConfig_fields &RadioConfig_msg
-#define RadioConfig_UserPreferences_fields &RadioConfig_UserPreferences_msg
 #define NodeInfo_fields &NodeInfo_msg
 #define MyNodeInfo_fields &MyNodeInfo_msg
 #define LogRecord_fields &LogRecord_msg
@@ -761,20 +424,17 @@ extern const pb_msgdesc_t ToRadio_msg;
 #define ToRadio_fields &ToRadio_msg
 
 /* Maximum encoded size of messages (where known) */
-#define Position_size                            39
-#define Data_size                                246
+#define Position_size                            37
 #define User_size                                72
-#define RouteDiscovery_size                      88
-#define SubPacket_size                           275
-#define MeshPacket_size                          322
-#define ChannelSettings_size                     95
-#define RadioConfig_size                         432
-#define RadioConfig_UserPreferences_size         332
-#define NodeInfo_size                            132
-#define MyNodeInfo_size                          106
+#define RouteDiscovery_size                      40
+#define Routing_size                             42
+#define Data_size                                260
+#define MeshPacket_size                          298
+#define NodeInfo_size                            130
+#define MyNodeInfo_size                          89
 #define LogRecord_size                           81
-#define FromRadio_size                           441
-#define ToRadio_size                             436
+#define FromRadio_size                           307
+#define ToRadio_size                             301
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/portnums.pb.h

@@ -16,20 +16,23 @@ typedef enum _PortNum {
     PortNum_REMOTE_HARDWARE_APP = 2,
     PortNum_POSITION_APP = 3,
     PortNum_NODEINFO_APP = 4,
+    PortNum_ROUTING_APP = 5,
+    PortNum_ADMIN_APP = 6,
     PortNum_REPLY_APP = 32,
     PortNum_IP_TUNNEL_APP = 33,
+    PortNum_ENVIRONMENTAL_MEASUREMENT_APP = 34,
     PortNum_SERIAL_APP = 64,
     PortNum_STORE_FORWARD_APP = 65,
     PortNum_RANGE_TEST_APP = 66,
-    PortNum_ENVIRONMENTAL_MEASUREMENT_APP = 67,
     PortNum_PRIVATE_APP = 256,
-    PortNum_ATAK_FORWARDER = 257
+    PortNum_ATAK_FORWARDER = 257,
+    PortNum_MAX = 511
 } PortNum;
 
 /* Helper constants for enums */
 #define _PortNum_MIN PortNum_UNKNOWN_APP
-#define _PortNum_MAX PortNum_ATAK_FORWARDER
-#define _PortNum_ARRAYSIZE ((PortNum)(PortNum_ATAK_FORWARDER+1))
+#define _PortNum_MAX PortNum_MAX
+#define _PortNum_ARRAYSIZE ((PortNum)(PortNum_MAX+1))
 
 
 #ifdef __cplusplus

src/mesh/generated/radioconfig.pb.c

@@ -0,0 +1,19 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.4 */
+
+#include "radioconfig.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(RadioConfig, RadioConfig, 2)
+
+
+PB_BIND(RadioConfig_UserPreferences, RadioConfig_UserPreferences, 2)
+
+
+
+
+
+
+

src/mesh/generated/radioconfig.pb.h

@@ -0,0 +1,268 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.4 */
+
+#ifndef PB_RADIOCONFIG_PB_H_INCLUDED
+#define PB_RADIOCONFIG_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+typedef enum _RegionCode {
+    RegionCode_Unset = 0,
+    RegionCode_US = 1,
+    RegionCode_EU433 = 2,
+    RegionCode_EU865 = 3,
+    RegionCode_CN = 4,
+    RegionCode_JP = 5,
+    RegionCode_ANZ = 6,
+    RegionCode_KR = 7,
+    RegionCode_TW = 8
+} RegionCode;
+
+typedef enum _ChargeCurrent {
+    ChargeCurrent_MAUnset = 0,
+    ChargeCurrent_MA100 = 1,
+    ChargeCurrent_MA190 = 2,
+    ChargeCurrent_MA280 = 3,
+    ChargeCurrent_MA360 = 4,
+    ChargeCurrent_MA450 = 5,
+    ChargeCurrent_MA550 = 6,
+    ChargeCurrent_MA630 = 7,
+    ChargeCurrent_MA700 = 8,
+    ChargeCurrent_MA780 = 9,
+    ChargeCurrent_MA880 = 10,
+    ChargeCurrent_MA960 = 11,
+    ChargeCurrent_MA1000 = 12,
+    ChargeCurrent_MA1080 = 13,
+    ChargeCurrent_MA1160 = 14,
+    ChargeCurrent_MA1240 = 15,
+    ChargeCurrent_MA1320 = 16
+} ChargeCurrent;
+
+typedef enum _GpsOperation {
+    GpsOperation_GpsOpUnset = 0,
+    GpsOperation_GpsOpStationary = 1,
+    GpsOperation_GpsOpMobile = 2,
+    GpsOperation_GpsOpTimeOnly = 3,
+    GpsOperation_GpsOpDisabled = 4
+} GpsOperation;
+
+typedef enum _LocationSharing {
+    LocationSharing_LocUnset = 0,
+    LocationSharing_LocEnabled = 1,
+    LocationSharing_LocDisabled = 2
+} LocationSharing;
+
+/* Struct definitions */
+typedef struct _RadioConfig_UserPreferences {
+    uint32_t position_broadcast_secs;
+    uint32_t send_owner_interval;
+    uint32_t wait_bluetooth_secs;
+    uint32_t screen_on_secs;
+    uint32_t phone_timeout_secs;
+    uint32_t phone_sds_timeout_sec;
+    uint32_t mesh_sds_timeout_secs;
+    uint32_t sds_secs;
+    uint32_t ls_secs;
+    uint32_t min_wake_secs;
+    char wifi_ssid[33];
+    char wifi_password[64];
+    bool wifi_ap_mode;
+    RegionCode region;
+    ChargeCurrent charge_current;
+    LocationSharing location_share;
+    GpsOperation gps_operation;
+    uint32_t gps_update_interval;
+    uint32_t gps_attempt_time;
+    bool is_router;
+    bool is_low_power;
+    bool fixed_position;
+    bool factory_reset;
+    bool debug_log_enabled;
+    pb_size_t ignore_incoming_count;
+    uint32_t ignore_incoming[3];
+    bool serialplugin_enabled;
+    bool serialplugin_echo;
+    uint32_t serialplugin_rxd;
+    uint32_t serialplugin_txd;
+    uint32_t serialplugin_timeout;
+    uint32_t serialplugin_mode;
+    bool ext_notification_plugin_enabled;
+    uint32_t ext_notification_plugin_output_ms;
+    uint32_t ext_notification_plugin_output;
+    bool ext_notification_plugin_active;
+    bool ext_notification_plugin_alert_message;
+    bool ext_notification_plugin_alert_bell;
+    bool range_test_plugin_enabled;
+    uint32_t range_test_plugin_sender;
+    bool range_test_plugin_save;
+    bool store_forward_plugin_enabled;
+    uint32_t store_forward_plugin_records;
+    bool environmental_measurement_plugin_measurement_enabled;
+    bool environmental_measurement_plugin_screen_enabled;
+    uint32_t environmental_measurement_plugin_read_error_count_threshold;
+    uint32_t environmental_measurement_plugin_update_interval;
+    uint32_t environmental_measurement_plugin_recovery_interval;
+} RadioConfig_UserPreferences;
+
+typedef struct _RadioConfig {
+    bool has_preferences;
+    RadioConfig_UserPreferences preferences;
+} RadioConfig;
+
+
+/* Helper constants for enums */
+#define _RegionCode_MIN RegionCode_Unset
+#define _RegionCode_MAX RegionCode_TW
+#define _RegionCode_ARRAYSIZE ((RegionCode)(RegionCode_TW+1))
+
+#define _ChargeCurrent_MIN ChargeCurrent_MAUnset
+#define _ChargeCurrent_MAX ChargeCurrent_MA1320
+#define _ChargeCurrent_ARRAYSIZE ((ChargeCurrent)(ChargeCurrent_MA1320+1))
+
+#define _GpsOperation_MIN GpsOperation_GpsOpUnset
+#define _GpsOperation_MAX GpsOperation_GpsOpDisabled
+#define _GpsOperation_ARRAYSIZE ((GpsOperation)(GpsOperation_GpsOpDisabled+1))
+
+#define _LocationSharing_MIN LocationSharing_LocUnset
+#define _LocationSharing_MAX LocationSharing_LocDisabled
+#define _LocationSharing_ARRAYSIZE ((LocationSharing)(LocationSharing_LocDisabled+1))
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define RadioConfig_init_default                 {false, RadioConfig_UserPreferences_init_default}
+#define RadioConfig_UserPreferences_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#define RadioConfig_init_zero                    {false, RadioConfig_UserPreferences_init_zero}
+#define RadioConfig_UserPreferences_init_zero    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define RadioConfig_UserPreferences_position_broadcast_secs_tag 1
+#define RadioConfig_UserPreferences_send_owner_interval_tag 2
+#define RadioConfig_UserPreferences_wait_bluetooth_secs_tag 4
+#define RadioConfig_UserPreferences_screen_on_secs_tag 5
+#define RadioConfig_UserPreferences_phone_timeout_secs_tag 6
+#define RadioConfig_UserPreferences_phone_sds_timeout_sec_tag 7
+#define RadioConfig_UserPreferences_mesh_sds_timeout_secs_tag 8
+#define RadioConfig_UserPreferences_sds_secs_tag 9
+#define RadioConfig_UserPreferences_ls_secs_tag  10
+#define RadioConfig_UserPreferences_min_wake_secs_tag 11
+#define RadioConfig_UserPreferences_wifi_ssid_tag 12
+#define RadioConfig_UserPreferences_wifi_password_tag 13
+#define RadioConfig_UserPreferences_wifi_ap_mode_tag 14
+#define RadioConfig_UserPreferences_region_tag   15
+#define RadioConfig_UserPreferences_charge_current_tag 16
+#define RadioConfig_UserPreferences_location_share_tag 32
+#define RadioConfig_UserPreferences_gps_operation_tag 33
+#define RadioConfig_UserPreferences_gps_update_interval_tag 34
+#define RadioConfig_UserPreferences_gps_attempt_time_tag 36
+#define RadioConfig_UserPreferences_is_router_tag 37
+#define RadioConfig_UserPreferences_is_low_power_tag 38
+#define RadioConfig_UserPreferences_fixed_position_tag 39
+#define RadioConfig_UserPreferences_factory_reset_tag 100
+#define RadioConfig_UserPreferences_debug_log_enabled_tag 101
+#define RadioConfig_UserPreferences_ignore_incoming_tag 103
+#define RadioConfig_UserPreferences_serialplugin_enabled_tag 120
+#define RadioConfig_UserPreferences_serialplugin_echo_tag 121
+#define RadioConfig_UserPreferences_serialplugin_rxd_tag 122
+#define RadioConfig_UserPreferences_serialplugin_txd_tag 123
+#define RadioConfig_UserPreferences_serialplugin_timeout_tag 124
+#define RadioConfig_UserPreferences_serialplugin_mode_tag 125
+#define RadioConfig_UserPreferences_ext_notification_plugin_enabled_tag 126
+#define RadioConfig_UserPreferences_ext_notification_plugin_output_ms_tag 127
+#define RadioConfig_UserPreferences_ext_notification_plugin_output_tag 128
+#define RadioConfig_UserPreferences_ext_notification_plugin_active_tag 129
+#define RadioConfig_UserPreferences_ext_notification_plugin_alert_message_tag 130
+#define RadioConfig_UserPreferences_ext_notification_plugin_alert_bell_tag 131
+#define RadioConfig_UserPreferences_range_test_plugin_enabled_tag 132
+#define RadioConfig_UserPreferences_range_test_plugin_sender_tag 133
+#define RadioConfig_UserPreferences_range_test_plugin_save_tag 134
+#define RadioConfig_UserPreferences_store_forward_plugin_enabled_tag 136
+#define RadioConfig_UserPreferences_store_forward_plugin_records_tag 137
+#define RadioConfig_UserPreferences_environmental_measurement_plugin_measurement_enabled_tag 140
+#define RadioConfig_UserPreferences_environmental_measurement_plugin_screen_enabled_tag 141
+#define RadioConfig_UserPreferences_environmental_measurement_plugin_read_error_count_threshold_tag 142
+#define RadioConfig_UserPreferences_environmental_measurement_plugin_update_interval_tag 143
+#define RadioConfig_UserPreferences_environmental_measurement_plugin_recovery_interval_tag 144
+#define RadioConfig_preferences_tag              1
+
+/* Struct field encoding specification for nanopb */
+#define RadioConfig_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  preferences,       1)
+#define RadioConfig_CALLBACK NULL
+#define RadioConfig_DEFAULT NULL
+#define RadioConfig_preferences_MSGTYPE RadioConfig_UserPreferences
+
+#define RadioConfig_UserPreferences_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   position_broadcast_secs,   1) \
+X(a, STATIC,   SINGULAR, UINT32,   send_owner_interval,   2) \
+X(a, STATIC,   SINGULAR, UINT32,   wait_bluetooth_secs,   4) \
+X(a, STATIC,   SINGULAR, UINT32,   screen_on_secs,    5) \
+X(a, STATIC,   SINGULAR, UINT32,   phone_timeout_secs,   6) \
+X(a, STATIC,   SINGULAR, UINT32,   phone_sds_timeout_sec,   7) \
+X(a, STATIC,   SINGULAR, UINT32,   mesh_sds_timeout_secs,   8) \
+X(a, STATIC,   SINGULAR, UINT32,   sds_secs,          9) \
+X(a, STATIC,   SINGULAR, UINT32,   ls_secs,          10) \
+X(a, STATIC,   SINGULAR, UINT32,   min_wake_secs,    11) \
+X(a, STATIC,   SINGULAR, STRING,   wifi_ssid,        12) \
+X(a, STATIC,   SINGULAR, STRING,   wifi_password,    13) \
+X(a, STATIC,   SINGULAR, BOOL,     wifi_ap_mode,     14) \
+X(a, STATIC,   SINGULAR, UENUM,    region,           15) \
+X(a, STATIC,   SINGULAR, UENUM,    charge_current,   16) \
+X(a, STATIC,   SINGULAR, UENUM,    location_share,   32) \
+X(a, STATIC,   SINGULAR, UENUM,    gps_operation,    33) \
+X(a, STATIC,   SINGULAR, UINT32,   gps_update_interval,  34) \
+X(a, STATIC,   SINGULAR, UINT32,   gps_attempt_time,  36) \
+X(a, STATIC,   SINGULAR, BOOL,     is_router,        37) \
+X(a, STATIC,   SINGULAR, BOOL,     is_low_power,     38) \
+X(a, STATIC,   SINGULAR, BOOL,     fixed_position,   39) \
+X(a, STATIC,   SINGULAR, BOOL,     factory_reset,   100) \
+X(a, STATIC,   SINGULAR, BOOL,     debug_log_enabled, 101) \
+X(a, STATIC,   REPEATED, UINT32,   ignore_incoming, 103) \
+X(a, STATIC,   SINGULAR, BOOL,     serialplugin_enabled, 120) \
+X(a, STATIC,   SINGULAR, BOOL,     serialplugin_echo, 121) \
+X(a, STATIC,   SINGULAR, UINT32,   serialplugin_rxd, 122) \
+X(a, STATIC,   SINGULAR, UINT32,   serialplugin_txd, 123) \
+X(a, STATIC,   SINGULAR, UINT32,   serialplugin_timeout, 124) \
+X(a, STATIC,   SINGULAR, UINT32,   serialplugin_mode, 125) \
+X(a, STATIC,   SINGULAR, BOOL,     ext_notification_plugin_enabled, 126) \
+X(a, STATIC,   SINGULAR, UINT32,   ext_notification_plugin_output_ms, 127) \
+X(a, STATIC,   SINGULAR, UINT32,   ext_notification_plugin_output, 128) \
+X(a, STATIC,   SINGULAR, BOOL,     ext_notification_plugin_active, 129) \
+X(a, STATIC,   SINGULAR, BOOL,     ext_notification_plugin_alert_message, 130) \
+X(a, STATIC,   SINGULAR, BOOL,     ext_notification_plugin_alert_bell, 131) \
+X(a, STATIC,   SINGULAR, BOOL,     range_test_plugin_enabled, 132) \
+X(a, STATIC,   SINGULAR, UINT32,   range_test_plugin_sender, 133) \
+X(a, STATIC,   SINGULAR, BOOL,     range_test_plugin_save, 134) \
+X(a, STATIC,   SINGULAR, BOOL,     store_forward_plugin_enabled, 136) \
+X(a, STATIC,   SINGULAR, UINT32,   store_forward_plugin_records, 137) \
+X(a, STATIC,   SINGULAR, BOOL,     environmental_measurement_plugin_measurement_enabled, 140) \
+X(a, STATIC,   SINGULAR, BOOL,     environmental_measurement_plugin_screen_enabled, 141) \
+X(a, STATIC,   SINGULAR, UINT32,   environmental_measurement_plugin_read_error_count_threshold, 142) \
+X(a, STATIC,   SINGULAR, UINT32,   environmental_measurement_plugin_update_interval, 143) \
+X(a, STATIC,   SINGULAR, UINT32,   environmental_measurement_plugin_recovery_interval, 144)
+#define RadioConfig_UserPreferences_CALLBACK NULL
+#define RadioConfig_UserPreferences_DEFAULT NULL
+
+extern const pb_msgdesc_t RadioConfig_msg;
+extern const pb_msgdesc_t RadioConfig_UserPreferences_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define RadioConfig_fields &RadioConfig_msg
+#define RadioConfig_UserPreferences_fields &RadioConfig_UserPreferences_msg
+
+/* Maximum encoded size of messages (where known) */
+#define RadioConfig_size                         335
+#define RadioConfig_UserPreferences_size         332
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/mesh-pb-constants.h

@@ -2,6 +2,7 @@
 
 #include "mesh/generated/mesh.pb.h"
 #include "mesh/generated/deviceonly.pb.h"
+#include "mesh/generated/admin.pb.h"
 
 // this file defines constants which come from mesh.options
 
@@ -16,6 +17,9 @@
 /// max number of nodes allowed in the mesh
 #define MAX_NUM_NODES (member_size(DeviceState, node_db) / member_size(DeviceState, node_db[0]))
 
+/// Max number of channels allowed
+#define MAX_NUM_CHANNELS (member_size(DeviceState, channels) / member_size(DeviceState, channels[0]))
+
 /// helper function for encoding a record as a protobuf, any failures to encode are fatal and we will panic
 /// returns the encoded packet size
 size_t pb_encode_to_bytes(uint8_t *destbuf, size_t destbufsize, const pb_msgdesc_t *fields, const void *src_struct);

src/nrf52/NRF52CryptoEngine.cpp

@@ -6,30 +6,13 @@
 class NRF52CryptoEngine : public CryptoEngine
 {
 
-    /// How many bytes in our key
-    uint8_t keySize = 0;
-    const uint8_t *keyBytes;
+
 
   public:
     NRF52CryptoEngine() {}
 
     ~NRF52CryptoEngine() {}
 
-    /**
-     * Set the key used for encrypt, decrypt.
-     *
-     * As a special case: If all bytes are zero, we assume _no encryption_ and send all data in cleartext.
-     *
-     * @param numBytes must be 16 (AES128), 32 (AES256) or 0 (no crypt)
-     * @param bytes a _static_ buffer that will remain valid for the life of this crypto instance (i.e. this class will cache the
-     * provided pointer)
-     */
-    virtual void setKey(size_t numBytes, uint8_t *bytes)
-    {
-        keySize = numBytes;
-        keyBytes = bytes;
-    }
-
     /**
      * Encrypt a packet
      *
@@ -39,11 +22,11 @@ class NRF52CryptoEngine : public CryptoEngine
     {
         // DEBUG_MSG("NRF52 encrypt!\n");
 
-        if (keySize != 0) {
+        if (key.length > 0) {
             ocrypto_aes_ctr_ctx ctx;
 
             initNonce(fromNode, packetNum);
-            ocrypto_aes_ctr_init(&ctx, keyBytes, keySize, nonce);
+            ocrypto_aes_ctr_init(&ctx, key.bytes, key.length, nonce);
 
             ocrypto_aes_ctr_encrypt(&ctx, bytes, bytes, numBytes);
         }
@@ -53,11 +36,11 @@ class NRF52CryptoEngine : public CryptoEngine
     {
         // DEBUG_MSG("NRF52 decrypt!\n");
 
-        if (keySize != 0) {
+        if (key.length > 0) {
             ocrypto_aes_ctr_ctx ctx;
 
             initNonce(fromNode, packetNum);
-            ocrypto_aes_ctr_init(&ctx, keyBytes, keySize, nonce);
+            ocrypto_aes_ctr_init(&ctx, key.bytes, key.length, nonce);
 
             ocrypto_aes_ctr_decrypt(&ctx, bytes, bytes, numBytes);
         }

src/plugins/AdminPlugin.cpp

@@ -0,0 +1,119 @@
+#include "AdminPlugin.h"
+#include "Channels.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "Router.h"
+#include "configuration.h"
+#include "main.h"
+
+AdminPlugin *adminPlugin;
+
+void AdminPlugin::handleGetChannel(const MeshPacket &req, uint32_t channelIndex) {
+        if (req.decoded.want_response) {
+        // We create the reply here
+        AdminMessage r = AdminMessage_init_default;
+        r.get_channel_response = channels.getByIndex(channelIndex);
+        r.which_variant = AdminMessage_get_channel_response_tag;
+        reply = allocDataProtobuf(r);
+    }
+}
+
+void AdminPlugin::handleGetRadio(const MeshPacket &req)
+{
+    if (req.decoded.want_response) {
+        // We create the reply here
+        AdminMessage r = AdminMessage_init_default;
+        r.get_radio_response = devicestate.radio;
+        r.which_variant = AdminMessage_get_radio_response_tag;
+        reply = allocDataProtobuf(r);
+    }
+}
+
+bool AdminPlugin::handleReceivedProtobuf(const MeshPacket &mp, const AdminMessage *r)
+{
+    assert(r);
+    switch (r->which_variant) {
+    case AdminMessage_set_owner_tag:
+        DEBUG_MSG("Client is setting owner\n");
+        handleSetOwner(r->set_owner);
+        break;
+
+    case AdminMessage_set_radio_tag:
+        DEBUG_MSG("Client is setting radio\n");
+        handleSetRadio(r->set_radio);
+        break;
+
+    case AdminMessage_set_channel_tag:
+        DEBUG_MSG("Client is setting channel\n");
+        handleSetChannel(r->set_channel);
+        break;
+
+    case AdminMessage_get_channel_request_tag:
+        DEBUG_MSG("Client is getting channel %d\n", r->get_channel_request - 1);
+        handleGetChannel(mp, r->get_channel_request - 1);
+        break;
+
+    case AdminMessage_get_radio_request_tag:
+        DEBUG_MSG("Client is getting radio\n");
+        handleGetRadio(mp);
+        break;
+
+    default:
+        break;
+    }
+    return false; // Let others look at this message also if they want
+}
+
+void AdminPlugin::handleSetOwner(const User &o)
+{
+    int changed = 0;
+
+    if (*o.long_name) {
+        changed |= strcmp(owner.long_name, o.long_name);
+        strcpy(owner.long_name, o.long_name);
+    }
+    if (*o.short_name) {
+        changed |= strcmp(owner.short_name, o.short_name);
+        strcpy(owner.short_name, o.short_name);
+    }
+    if (*o.id) {
+        changed |= strcmp(owner.id, o.id);
+        strcpy(owner.id, o.id);
+    }
+
+    if (changed) // If nothing really changed, don't broadcast on the network or write to flash
+        service.reloadOwner();
+}
+
+void AdminPlugin::handleSetChannel(const Channel &cc)
+{
+    channels.setChannel(cc);
+
+    bool didReset = service.reloadConfig();
+    /* FIXME - do we need this still?
+    if (didReset) {
+        state = STATE_SEND_MY_INFO; // Squirt a completely new set of configs to the client
+    } */
+}
+
+void AdminPlugin::handleSetRadio(const RadioConfig &r)
+{
+    radioConfig = r;
+
+    bool didReset = service.reloadConfig();
+    /* FIXME - do we need this still?  if (didReset) {
+        state = STATE_SEND_MY_INFO; // Squirt a completely new set of configs to the client
+    } */
+}
+
+MeshPacket *AdminPlugin::allocReply()
+{
+    auto r = reply;
+    reply = NULL; // Only use each reply once
+    return r;
+}
+
+AdminPlugin::AdminPlugin() : ProtobufPlugin("Admin", PortNum_ADMIN_APP, AdminMessage_fields)
+{
+    // FIXME, restrict to the admin channel for rx
+}

src/plugins/AdminPlugin.h

@@ -0,0 +1,37 @@
+#pragma once
+#include "ProtobufPlugin.h"
+
+/**
+ * Routing plugin for router control messages
+ */
+class AdminPlugin : public ProtobufPlugin<AdminMessage>
+{
+  MeshPacket *reply = NULL;
+  
+  public:
+    /** Constructor
+     * name is for debugging output
+     */
+    AdminPlugin();
+
+  protected:
+    /** Called to handle a particular incoming message
+
+    @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
+    */
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const AdminMessage *p);
+
+    /** Messages can be received that have the want_response bit set.  If set, this callback will be invoked
+     * so that subclasses can (optionally) send a response back to the original sender.  */
+    virtual MeshPacket *allocReply();
+
+  private:
+    void handleSetOwner(const User &o);
+    void handleSetChannel(const Channel &cc);
+    void handleSetRadio(const RadioConfig &r);
+
+    void handleGetChannel(const MeshPacket &req, uint32_t channelIndex);
+    void handleGetRadio(const MeshPacket &req);
+};
+
+extern AdminPlugin *adminPlugin;

src/plugins/ExternalNotificationPlugin.cpp

@@ -145,7 +145,7 @@ bool ExternalNotificationPluginRadio::handleReceived(const MeshPacket &mp)
 
     if (radioConfig.preferences.ext_notification_plugin_enabled) {
 
-        auto &p = mp.decoded.data;
+        auto &p = mp.decoded;
 
         if (mp.from != nodeDB.getNodeNum()) {
 

src/plugins/NodeInfoPlugin.cpp

@@ -8,10 +8,9 @@
 
 NodeInfoPlugin *nodeInfoPlugin;
 
-bool NodeInfoPlugin::handleReceivedProtobuf(const MeshPacket &mp, const User &p)
+bool NodeInfoPlugin::handleReceivedProtobuf(const MeshPacket &mp, const User *pptr)
 {
-    // FIXME - we currently update NodeInfo data in the DB only if the message was a broadcast or destined to us
-    // it would be better to update even if the message was destined to others.
+    auto p = *pptr;
 
     nodeDB.updateUser(mp.from, p);
 
@@ -52,6 +51,7 @@ MeshPacket *NodeInfoPlugin::allocReply()
 NodeInfoPlugin::NodeInfoPlugin()
     : ProtobufPlugin("nodeinfo", PortNum_NODEINFO_APP, User_fields), concurrency::OSThread("NodeInfoPlugin")
 {
+    isPromiscuous = true; // We always want to update our nodedb, even if we are sniffing on others
     setIntervalFromNow(30 *
                        1000); // Send our initial owner announcement 30 seconds after we start (to give network time to setup)
 }

src/plugins/NodeInfoPlugin.h

@@ -26,7 +26,7 @@ class NodeInfoPlugin : public ProtobufPlugin<User>, private concurrency::OSThrea
 
     @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const User &p);
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const User *p);
 
     /** Messages can be received that have the want_response bit set.  If set, this callback will be invoked
      * so that subclasses can (optionally) send a response back to the original sender.  */

src/plugins/Plugins.cpp

@@ -3,8 +3,11 @@
 #include "plugins/PositionPlugin.h"
 #include "plugins/RemoteHardwarePlugin.h"
 #include "plugins/ReplyPlugin.h"
+#include "plugins/TextMessagePlugin.h" 
+#include "plugins/SerialPlugin.h"
 #include "plugins/TextMessagePlugin.h"
-
+#include "plugins/RoutingPlugin.h"
+#include "plugins/AdminPlugin.h"
 #ifndef NO_ESP32
 #include "plugins/SerialPlugin.h"
 #include "plugins/esp32/EnvironmentalMeasurementPlugin.h"
@@ -17,6 +20,8 @@
  */
 void setupPlugins()
 {
+    routingPlugin = new RoutingPlugin();
+    adminPlugin = new AdminPlugin();
     nodeInfoPlugin = new NodeInfoPlugin();
     positionPlugin = new PositionPlugin();
     textMessagePlugin = new TextMessagePlugin();

src/plugins/PositionPlugin.cpp

@@ -10,15 +10,15 @@ PositionPlugin *positionPlugin;
 PositionPlugin::PositionPlugin()
     : ProtobufPlugin("position", PortNum_POSITION_APP, Position_fields), concurrency::OSThread("PositionPlugin")
 {
+    isPromiscuous = true; // We always want to update our nodedb, even if we are sniffing on others
     setIntervalFromNow(60 *
                        1000); // Send our initial position 60 seconds after we start (to give GPS time to setup)
 
 }
 
-bool PositionPlugin::handleReceivedProtobuf(const MeshPacket &mp, const Position &p)
+bool PositionPlugin::handleReceivedProtobuf(const MeshPacket &mp, const Position *pptr)
 {
-    // FIXME - we currently update position data in the DB only if the message was a broadcast or destined to us
-    // it would be better to update even if the message was destined to others.
+    auto p = *pptr;
 
     if (p.time) {
         struct timeval tv;

src/plugins/PositionPlugin.h

@@ -33,7 +33,7 @@ class PositionPlugin : public ProtobufPlugin<Position>, private concurrency::OST
 
     @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const Position &p);
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const Position *p);
 
     /** Messages can be received that have the want_response bit set.  If set, this callback will be invoked
      * so that subclasses can (optionally) send a response back to the original sender.  */

src/plugins/RemoteHardwarePlugin.cpp

@@ -47,8 +47,9 @@ RemoteHardwarePlugin::RemoteHardwarePlugin()
 {
 }
 
-bool RemoteHardwarePlugin::handleReceivedProtobuf(const MeshPacket &req, const HardwareMessage &p)
+bool RemoteHardwarePlugin::handleReceivedProtobuf(const MeshPacket &req, const HardwareMessage *pptr)
 {
+    auto p = *pptr;
     DEBUG_MSG("Received RemoteHardware typ=%d\n", p.typ);
 
     switch (p.typ) {

src/plugins/RemoteHardwarePlugin.h

@@ -27,7 +27,7 @@ class RemoteHardwarePlugin : public ProtobufPlugin<HardwareMessage>, private con
 
     @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const HardwareMessage &p);
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const HardwareMessage *p);
 
     /**
      * Periodically read the gpios we have been asked to WATCH, if they have changed,

src/plugins/ReplyPlugin.cpp

@@ -9,7 +9,7 @@ MeshPacket *ReplyPlugin::allocReply()
 {
     assert(currentRequest); // should always be !NULL
     auto req = *currentRequest;
-    auto &p = req.decoded.data;
+    auto &p = req.decoded;
     // The incoming message is in p.payload
     DEBUG_MSG("Received message from=0x%0x, id=%d, msg=%.*s\n", req.from, req.id, p.payload.size, p.payload.bytes);
 
@@ -17,8 +17,8 @@ MeshPacket *ReplyPlugin::allocReply()
 
     const char *replyStr = "Message Received";
     auto reply = allocDataPacket();                      // Allocate a packet for sending
-    reply->decoded.data.payload.size = strlen(replyStr); // You must specify how many bytes are in the reply
-    memcpy(reply->decoded.data.payload.bytes, replyStr, reply->decoded.data.payload.size);
+    reply->decoded.payload.size = strlen(replyStr); // You must specify how many bytes are in the reply
+    memcpy(reply->decoded.payload.bytes, replyStr, reply->decoded.payload.size);
 
     return reply;
 }

src/plugins/RoutingPlugin.cpp

@@ -0,0 +1,60 @@
+#include "RoutingPlugin.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "Router.h"
+#include "configuration.h"
+#include "main.h"
+
+RoutingPlugin *routingPlugin;
+
+bool RoutingPlugin::handleReceivedProtobuf(const MeshPacket &mp, const Routing *r)
+{
+    DEBUG_MSG("Routing sniffing", &mp);
+    router->sniffReceived(&mp, r);
+
+    // FIXME - move this to a non promsicious PhoneAPI plugin?
+    if (mp.to == NODENUM_BROADCAST || mp.to == nodeDB.getNodeNum()) {
+        printPacket("Delivering rx packet", &mp);
+        service.handleFromRadio(&mp);
+    }
+        
+    return false; // Let others look at this message also if they want
+}
+
+
+MeshPacket *RoutingPlugin::allocReply()
+{
+    assert(currentRequest);
+
+    // We only consider making replies if the request was a legit routing packet (not just something we were sniffing)
+    if(currentRequest->decoded.portnum == PortNum_ROUTING_APP) {
+        assert(0); // 1.2 refactoring fixme, Not sure if anything needs this yet?
+        // return allocDataProtobuf(u);
+    }
+    return NULL;
+}
+
+void RoutingPlugin::sendAckNak(Routing_Error err, NodeNum to, PacketId idFrom)
+{
+    Routing c = Routing_init_default;
+    
+    c.error_reason = err;
+
+    auto p = allocDataProtobuf(c);
+    p->priority = MeshPacket_Priority_ACK;
+
+    p->hop_limit = 0; // Assume just immediate neighbors for now
+    p->to = to;
+    p->decoded.request_id = idFrom;
+    DEBUG_MSG("Sending an err=%d,to=0x%x,idFrom=0x%x,id=0x%x\n", err, to, idFrom, p->id);
+
+    router->sendLocal(p); // we sometimes send directly to the local node
+}
+
+RoutingPlugin::RoutingPlugin()
+    : ProtobufPlugin("routing", PortNum_ROUTING_APP, Routing_fields)
+{
+    isPromiscuous = true;
+}
+
+

src/plugins/RoutingPlugin.h

@@ -0,0 +1,34 @@
+#pragma once
+#include "ProtobufPlugin.h"
+
+/**
+ * Routing plugin for router control messages
+ */
+class RoutingPlugin : public ProtobufPlugin<Routing>
+{
+  public:
+    /** Constructor
+     * name is for debugging output
+     */
+    RoutingPlugin();
+
+  protected:
+    friend class Router;
+
+    /** Called to handle a particular incoming message
+
+    @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
+    */
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const Routing *p);
+
+    /** Messages can be received that have the want_response bit set.  If set, this callback will be invoked
+     * so that subclasses can (optionally) send a response back to the original sender.  */
+    virtual MeshPacket *allocReply(); 
+
+    /// Override wantPacket to say we want to see all packets, not just those for our port number
+    virtual bool wantPacket(const MeshPacket *p) { return true; }
+
+    void sendAckNak(Routing_Error err, NodeNum to, PacketId idFrom);
+};
+
+extern RoutingPlugin *routingPlugin;

src/plugins/SerialPlugin.cpp

@@ -144,8 +144,8 @@ void SerialPluginRadio::sendPayload(NodeNum dest, bool wantReplies)
 
     p->want_ack = SERIALPLUGIN_ACK;
 
-    p->decoded.data.payload.size = strlen(serialStringChar); // You must specify how many bytes are in the reply
-    memcpy(p->decoded.data.payload.bytes, serialStringChar, p->decoded.data.payload.size);
+    p->decoded.payload.size = strlen(serialStringChar); // You must specify how many bytes are in the reply
+    memcpy(p->decoded.payload.bytes, serialStringChar, p->decoded.payload.size);
 
     service.sendToMesh(p);
 }
@@ -156,7 +156,7 @@ bool SerialPluginRadio::handleReceived(const MeshPacket &mp)
 
     if (radioConfig.preferences.serialplugin_enabled) {
 
-        auto &p = mp.decoded.data;
+        auto &p = mp.decoded;
         // DEBUG_MSG("Received text msg self=0x%0x, from=0x%0x, to=0x%0x, id=%d, msg=%.*s\n",
         //          nodeDB.getNodeNum(), mp.from, mp.to, mp.id, p.payload.size, p.payload.bytes);
 

src/plugins/TextMessagePlugin.cpp

@@ -7,7 +7,7 @@ TextMessagePlugin *textMessagePlugin;
 
 bool TextMessagePlugin::handleReceived(const MeshPacket &mp)
 {
-    auto &p = mp.decoded.data;
+    auto &p = mp.decoded;
     DEBUG_MSG("Received text msg from=0x%0x, id=%d, msg=%.*s\n", mp.from, mp.id, p.payload.size, p.payload.bytes);
 
     // We only store/display messages destined for us.

src/plugins/esp32/EnvironmentalMeasurementPlugin.cpp

@@ -149,8 +149,10 @@ String GetSenderName(const MeshPacket &mp) {
     return sender;
 }
 
-bool EnvironmentalMeasurementPluginRadio::handleReceivedProtobuf(const MeshPacket &mp, const EnvironmentalMeasurement &p)
+bool EnvironmentalMeasurementPluginRadio::handleReceivedProtobuf(const MeshPacket &mp, const EnvironmentalMeasurement *pptr)
 {
+    const EnvironmentalMeasurement &p = *pptr;
+    
     if (!(radioConfig.preferences.environmental_measurement_plugin_measurement_enabled || radioConfig.preferences.environmental_measurement_plugin_screen_enabled)){
         // If this plugin is not enabled in any capacity, don't handle the packet, and allow other plugins to consume 
          return false;

src/plugins/esp32/EnvironmentalMeasurementPlugin.h

@@ -47,7 +47,7 @@ class EnvironmentalMeasurementPluginRadio : public ProtobufPlugin<EnvironmentalM
 
     @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const EnvironmentalMeasurement &p);
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const EnvironmentalMeasurement *p);
 
     virtual bool wantUIFrame();
 

src/plugins/esp32/RangeTestPlugin.cpp

@@ -114,8 +114,8 @@ void RangeTestPluginRadio::sendPayload(NodeNum dest, bool wantReplies)
     static char heartbeatString[20];
     snprintf(heartbeatString, sizeof(heartbeatString), "seq %d", packetSequence);
 
-    p->decoded.data.payload.size = strlen(heartbeatString); // You must specify how many bytes are in the reply
-    memcpy(p->decoded.data.payload.bytes, heartbeatString, p->decoded.data.payload.size);
+    p->decoded.payload.size = strlen(heartbeatString); // You must specify how many bytes are in the reply
+    memcpy(p->decoded.payload.bytes, heartbeatString, p->decoded.payload.size);
 
     service.sendToMesh(p);
 
@@ -129,7 +129,7 @@ bool RangeTestPluginRadio::handleReceived(const MeshPacket &mp)
 
     if (radioConfig.preferences.range_test_plugin_enabled) {
 
-        auto &p = mp.decoded.data;
+        auto &p = mp.decoded;
         // DEBUG_MSG("Received text msg self=0x%0x, from=0x%0x, to=0x%0x, id=%d, msg=%.*s\n",
         //          nodeDB.getNodeNum(), mp.from, mp.to, mp.id, p.payload.size, p.payload.bytes);
 
@@ -207,7 +207,7 @@ float RangeTestPluginRadio::latLongToMeter(double lat_a, double lng_a, double la
 
 bool RangeTestPluginRadio::appendFile(const MeshPacket &mp)
 {
-    auto &p = mp.decoded.data;
+    auto &p = mp.decoded;
 
     NodeInfo *n = nodeDB.getNode(mp.from);
     /*

src/plugins/esp32/StoreForwardPlugin.cpp

@@ -190,7 +190,7 @@ void StoreForwardPlugin::historyAdd(const MeshPacket *mp)
     auto &p = mp;
 
     static uint8_t bytes[MAX_RHPACKETLEN];
-    size_t numbytes = pb_encode_to_bytes(bytes, sizeof(bytes), SubPacket_fields, &p->decoded);
+    size_t numbytes = pb_encode_to_bytes(bytes, sizeof(bytes), Data_fields, &p->decoded);
     assert(numbytes <= MAX_RHPACKETLEN);
 
     DEBUG_MSG("MP numbytes %u\n", numbytes);
@@ -271,37 +271,37 @@ bool StoreForwardPluginRadio::handleReceived(const MeshPacket &mp)
             uint32_t sawTime = storeForwardPlugin->sawNode(mp.from & 0xffffffff);
             DEBUG_MSG("We last saw this node (%u), %u sec ago\n", mp.from & 0xffffffff, (millis() - sawTime) / 1000);
 
-            if (mp.decoded.data.portnum == PortNum_UNKNOWN_APP) {
+            if (mp.decoded.portnum == PortNum_UNKNOWN_APP) {
                 DEBUG_MSG("Packet came from - PortNum_UNKNOWN_APP\n");
-            } else if (mp.decoded.data.portnum == PortNum_TEXT_MESSAGE_APP) {
+            } else if (mp.decoded.portnum == PortNum_TEXT_MESSAGE_APP) {
                 DEBUG_MSG("Packet came from - PortNum_TEXT_MESSAGE_APP\n");
 
                 storeForwardPlugin->historyAdd(&mp);
 
-            } else if (mp.decoded.data.portnum == PortNum_REMOTE_HARDWARE_APP) {
+            } else if (mp.decoded.portnum == PortNum_REMOTE_HARDWARE_APP) {
                 DEBUG_MSG("Packet came from - PortNum_REMOTE_HARDWARE_APP\n");
-            } else if (mp.decoded.data.portnum == PortNum_POSITION_APP) {
+            } else if (mp.decoded.portnum == PortNum_POSITION_APP) {
                 DEBUG_MSG("Packet came from - PortNum_POSITION_APP\n");
-            } else if (mp.decoded.data.portnum == PortNum_NODEINFO_APP) {
+            } else if (mp.decoded.portnum == PortNum_NODEINFO_APP) {
                 DEBUG_MSG("Packet came from - PortNum_NODEINFO_APP\n");
-            } else if (mp.decoded.data.portnum == PortNum_REPLY_APP) {
+            } else if (mp.decoded.portnum == PortNum_REPLY_APP) {
                 DEBUG_MSG("Packet came from - PortNum_REPLY_APP\n");
-            } else if (mp.decoded.data.portnum == PortNum_IP_TUNNEL_APP) {
+            } else if (mp.decoded.portnum == PortNum_IP_TUNNEL_APP) {
                 DEBUG_MSG("Packet came from - PortNum_IP_TUNNEL_APP\n");
-            } else if (mp.decoded.data.portnum == PortNum_SERIAL_APP) {
+            } else if (mp.decoded.portnum == PortNum_SERIAL_APP) {
                 DEBUG_MSG("Packet came from - PortNum_SERIAL_APP\n");
-            } else if (mp.decoded.data.portnum == PortNum_STORE_FORWARD_APP) {
+            } else if (mp.decoded.portnum == PortNum_STORE_FORWARD_APP) {
                 DEBUG_MSG("Packet came from - PortNum_STORE_FORWARD_APP\n");
-            } else if (mp.decoded.data.portnum == PortNum_RANGE_TEST_APP) {
+            } else if (mp.decoded.portnum == PortNum_RANGE_TEST_APP) {
                 DEBUG_MSG("Packet came from - PortNum_RANGE_TEST_APP\n");
-            } else if (mp.decoded.data.portnum == PortNum_PRIVATE_APP) {
+            } else if (mp.decoded.portnum == PortNum_PRIVATE_APP) {
                 DEBUG_MSG("Packet came from - PortNum_PRIVATE_APP\n");
-            } else if (mp.decoded.data.portnum == PortNum_RANGE_TEST_APP) {
+            } else if (mp.decoded.portnum == PortNum_RANGE_TEST_APP) {
                 DEBUG_MSG("Packet came from - PortNum_RANGE_TEST_APP\n");
-            } else if (mp.decoded.data.portnum == PortNum_ATAK_FORWARDER) {
+            } else if (mp.decoded.portnum == PortNum_ATAK_FORWARDER) {
                 DEBUG_MSG("Packet came from - PortNum_ATAK_FORWARDER\n");
             } else {
-                DEBUG_MSG("Packet came from an unknown port %u\n", mp.decoded.data.portnum);
+                DEBUG_MSG("Packet came from an unknown port %u\n", mp.decoded.portnum);
             }
 
             if ((millis() - sawTime) > STOREFORWARD_SEND_HISTORY_SHORT) {

src/portduino/CrossPlatformCryptoEngine.cpp

@@ -10,9 +10,6 @@ class CrossPlatformCryptoEngine : public CryptoEngine
 
     CTRCommon *ctr = NULL;
 
-    /// How many bytes in our key
-    uint8_t keySize = 0;
-
   public:
     CrossPlatformCryptoEngine() {}
 
@@ -27,21 +24,21 @@ class CrossPlatformCryptoEngine : public CryptoEngine
      * @param bytes a _static_ buffer that will remain valid for the life of this crypto instance (i.e. this class will cache the
      * provided pointer)
      */
-    virtual void setKey(size_t numBytes, uint8_t *bytes)
+    virtual void setKey(const CryptoKey &k)
     {
-        keySize = numBytes;
-        DEBUG_MSG("Installing AES%d key!\n", numBytes * 8);
+        CryptoEngine::setKey(k);
+        DEBUG_MSG("Installing AES%d key!\n", key.length * 8);
         if (ctr) {
             delete ctr;
             ctr = NULL;
         }
-        if (numBytes != 0) {
-            if (numBytes == 16)
+        if (key.length != 0) {
+            if (key.length == 16)
                 ctr = new CTR<AES128>();
             else
                 ctr = new CTR<AES256>();
 
-            ctr->setKey(bytes, numBytes);
+            ctr->setKey(key.bytes, key.length);
         }
     }
 
@@ -52,7 +49,7 @@ class CrossPlatformCryptoEngine : public CryptoEngine
      */
     virtual void encrypt(uint32_t fromNode, uint64_t packetNum, size_t numBytes, uint8_t *bytes)
     {
-        if (keySize != 0) {
+        if (key.length > 0) {
             uint8_t stream_block[16];
             static uint8_t scratch[MAX_BLOCKSIZE];
             size_t nc_off = 0;