Merge pull request #73 from meshtastic/master

pulling 1.2 into my fork
2021-03-02 20:46:21 -08:00 · 2021-03-02 20:46:21 -08:00 · ee04d57a7f
commit ee04d57a7f
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@ -4,8 +4,7 @@ on:
  - pull_request

 jobs:
-  main:
-    name: Main
+  setup:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@master
@ -33,4 +32,3 @@ jobs:
        run: platformio run -e lora-relay-v1 
      - name: Build for linux
        run: platformio run -e linux
-        
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@ -68,5 +68,13 @@
        "protobufs",
        "wifi"
    ],
-    "C_Cpp.dimInactiveRegions": true
+    "C_Cpp.dimInactiveRegions": true,
+    "protoc": {
+        "compile_on_save": false,
+        "compile_all_path": "/home/kevinh/development/meshtastic/meshtastic-esp32/proto",
+        "options": [
+            "--java_out=/tmp",
+            "-I=/home/kevinh/development/meshtastic/meshtastic-esp32/proto"
+        ]
+    }    
 }
--- a/bin/build-all.sh
+++ b/bin/build-all.sh
@ -4,7 +4,9 @@ set -e

 VERSION=`bin/buildinfo.py`

-COUNTRIES="US EU433 EU865 CN JP ANZ KR"
+# We now only do regionless builds
+COUNTRIES=""
+#COUNTRIES="US EU433 EU865 CN JP ANZ KR"
 #COUNTRIES=US
 #COUNTRIES=CN

@ -92,7 +94,7 @@ pio run --environment tbeam -t buildfs
 cp .pio/build/tbeam/spiffs.bin $OUTDIR/bins/universal/spiffs-$VERSION.bin

 # keep the bins in archive also
-cp $OUTDIR/bins/firmware* $OUTDIR/bins/universal/spiffs* $OUTDIR/elfs/firmware* $OUTDIR/bins/universal/firmware* $OUTDIR/elfs/universal/firmware* $ARCHIVEDIR
+cp $OUTDIR/bins/universal/spiffs* $OUTDIR/bins/universal/firmware* $OUTDIR/elfs/universal/firmware* $ARCHIVEDIR

 echo Updating android bins $OUTDIR/forandroid
 rm -rf $OUTDIR/forandroid
@ -107,12 +109,12 @@ release.  It is used by the android app for forcing software updates.  Do not ed
 Generated by bin/buildall.sh -->

 <resources>
-    <string name="cur_firmware_version">$VERSION</string>
+    <string name="cur_firmware_version" translatable="false">$VERSION</string>
 </resources>
 XML

 echo Generating $ARCHIVEDIR/firmware-$VERSION.zip
 rm -f $ARCHIVEDIR/firmware-$VERSION.zip
-zip --junk-paths $ARCHIVEDIR/firmware-$VERSION.zip $ARCHIVEDIR/spiffs-$VERSION.bin $OUTDIR/bins/firmware-*-$VERSION.* images/system-info.bin bin/device-install.sh bin/device-update.sh
+zip --junk-paths $ARCHIVEDIR/firmware-$VERSION.zip $ARCHIVEDIR/spiffs-$VERSION.bin $OUTDIR/bins/universal/firmware-*-$VERSION.* images/system-info.bin bin/device-install.sh bin/device-update.sh

 echo BUILT ALL
--- a/bin/program-release-tbeam.sh
+++ b/bin/program-release-tbeam.sh
@ -2,5 +2,7 @@
 set -e

 VERSION=`bin/buildinfo.py`
+FILENAME=release/latest/bins/universal/firmware-tbeam-$VERSION.bin

-esptool.py --baud 921600 write_flash 0x10000 release/latest/bins/firmware-tbeam-US-$VERSION.bin
+echo Installing $FILENAME
+esptool.py --baud 921600 write_flash 0x10000 $FILENAME
--- a/docs/software/TODO.md
+++ b/docs/software/TODO.md
@ -2,6 +2,75 @@

 You probably don't care about this section - skip to the next one.

+1.2 cleanup & multichannel support:
+
+* DONE call RouterPlugin for *all* packets - not just Router packets
+* DONE generate channel hash from the name of the channel+the psk (not just one or the other)
+* DONE send a hint that can be used to select which channel to try and hash against with each message
+* DONE remove deprecated
+* DONE fix setchannel in phoneapi.cpp
+* DONE set mynodeinfo.max_channels
+* DONE set mynodeinfo.num_bands (formerly num_channels)
+* DONE fix sniffing of non Routing packets
+* DONE enable remote setttings access by moving settings operations into a regular plugin (move settings ops out of PhoneAPI)
+* DONE move portnum up?
+* DONE remove region specific builds from the firmware
+* DONE test single channel without python
+* DONE Use "default" for name if name is empty
+* DONE fix python data packet receiving (nothing showing in log?)
+* DONE implement 'get channels' Admin plugin operation
+* DONE use get-channels from python
+* DONE use get channels & get settings from android
+* use set-channel from python
+* DONE make settings changes from python work
+* DONE pthon should stop fetching channels once we've reached our first empty channel definition (hasSettings == true)
+* DONE add check for old devices with new API library
+* DONE release python api
+* DONE release protobufs
+* DONE release to developers
+* fix 1.1.50 android debug panel display
+* add gui in android app for setting region
+* stress test channel download from python, sometimes it seems like we don't get all replies
+* investigate @mc-hamster report of heap corruption
+* use set-channel from android
+* DONE use set-user from android
+* combine acks and responses in a single message if possible (do routing plugin LAST and drop ACK if someone else has already replied)
+* don't send packets we received from the phone BACK TOWARDS THE PHONE (possibly use fromnode 0 for packets the phone sends?)
+* use portuino TCP connection to debug with python API
+* make python tests more exhaustive
+* document the relationship between want_response (indicating remote node received it) and want_ack (indicating that this message should be sent reliably - and also get acks from the first rx node and naks if it is never delivered)
+* stress test multi channel
+* pick default random admin key
+* DONE android should stop fetching channels once we've reached our first empty channel definition (hasSettings == true)
+* add channel restrictions for plugins (and restrict routing plugin to the "control" channel)
+* restrict gpio & serial & settings operations to the admin channel (unless local to the current node)
+* warn in python api if we are too new to talk to the device code
+* make a post warning about 1.2, telling how to stay on old android & python clients.  link to this from the android dialog message and python version warning.
+* DONE "FIXME - move the radioconfig/user/channel READ operations into SettingsMessage as well"
+* DONE scrub protobufs to make sure they are absoloute minimum wiresize (in particular Data, ChannelSets and positions)
+* DONE change syncword (now ox2b)
+* allow chaning packets in single transmission - to increase airtime efficiency and amortize packet overhead
+* DONE move most parts of meshpacket into the Data packet, so that we can chain multiple Data for sending when they all have a common destination and key.
+* when selecting a MeshPacket for transmit, scan the TX queue for any Data packets we can merge together as a WirePayload.  In the low level send/rx code expand that into multiple MeshPackets as needed (thus 'hiding' from MeshPacket that over the wire we send multiple datapackets
+* confirm we are still calling the plugins for messages inbound from the phone (or generated locally)
+* confirm we are still multi hop routing flood broadcasts
+* confirm we are still doing resends on unicast reliable packets
+* add support for full DSR unicast delivery
+* DONE move acks into routing
+* DONE make all subpackets different versions of data
+* DONE move routing control into a data packet
+* have phoneapi done via plugin (will allow multiple simultaneous API clients - stop disabling BLE while using phone API)
+* DONE figure out how to add micro_delta to position, make it so that phone apps don't need to understand it?
+* only send battery updates a max of once a minute
+* add python channel selection for sending
+* DONE record recevied channel in meshpacket
+* test remote settings operations (confirm it works 3 hops away)
+* DONE make a primaryChannel global and properly maintain it when the phone sends setChannel
+* DONE move setCrypto call into packet send and packet decode code
+* implement 'small location diffs' change
+* move battery level out of position? 
+* DOUBLE CHECK android app can still upgrade 1.1 and 1.0 loads
+ 
 eink:

 * new battery level sensing
--- a/docs/software/android-too-old.md
+++ b/docs/software/android-too-old.md
@ -0,0 +1,13 @@
+# Your android application needs updating
+
+Hi.
+
+If you've landed here that means your android application is too old for the running device firmware.  Usually our updates are backwards compatible, but in this special circumstance it is not.  Sorry.
+
+Probably, what this means is that you installed the **alpha test** version of the firmware from github.  We really love people helping with development by running the alpha test binaries.  But if you aren't ready to sign up for that right now, please go back to [github](https://github.com/meshtastic/Meshtastic-device/releases) and install the latest **not alpha** 1.1.x firmware.
+
+If you **do** intend to run the alpha test please [opt-in](https://play.google.com/apps/testing/com.geeksville.mesh) to receive the alpha test version of the android application.
+
+If you are willing to be an alpha tester, please keep an eye on our forum where we post frequent release notes.  We also will actively help you with any bugs you might encounter (along our shared journey of new feature goodness).
+
+If you have problems/questions please post in our [forum](https://meshtastic.discourse.group) and some nice person will probably help.
--- a/images/Insufficient
+++ b/images/Insufficient
--- a/images/platformio-erase.png
+++ b/images/platformio-erase.png
--- a/platformio.ini
+++ b/platformio.ini
@ -15,6 +15,7 @@ default_envs = tbeam
 ;default_envs = tlora-v1
 ;default_envs = tlora-v2
 ;default_envs = lora-relay-v1 # nrf board
+;default_envs = eink
 ;default_envs = linux # lora-relay-v1 # nrf52840dk-geeksville # linux # or if you'd like to change the default to something like lora-relay-v1 put that here

 [common]
@ -33,7 +34,9 @@ extra_scripts = bin/platformio-custom.py

 ; note: we add src to our include search path so that lmic_project_config can override
 ; FIXME: fix lib/BluetoothOTA dependency back on src/ so we can remove -Isrc
-build_flags = -Wno-missing-field-initializers -Isrc -Isrc/mesh -Isrc/gps -Ilib/nanopb/include -Wl,-Map,.pio/build/output.map 
+build_flags = -Wno-missing-field-initializers
+  -Wno-format 
+  -Isrc -Isrc/mesh -Isrc/gps -Ilib/nanopb/include -Wl,-Map,.pio/build/output.map 
  -DHW_VERSION_${sysenv.COUNTRY}
  -DHW_VERSION=${sysenv.HW_VERSION}
  -DUSE_THREAD_NAMES
--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit d70f6f6f669df79c9423795caf34adbd28967e19
+Subproject commit 94bd0aae44e2c16c7776289225c804100c856cd4
--- a/src/esp32/ESP32CryptoEngine.cpp
+++ b/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;
--- a/src/graphics/Screen.cpp
+++ b/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();
--- a/src/graphics/Screen.h
+++ b/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;
 };
--- a/src/main.cpp
+++ b/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
--- a/src/mesh/Channels.cpp
+++ b/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);
+}
--- a/src/mesh/Channels.h
+++ b/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;
--- a/src/mesh/CryptoEngine.cpp
+++ b/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;
 }

 /**
--- a/src/mesh/CryptoEngine.h
+++ b/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
--- a/src/mesh/DSRRouter.cpp
+++ b/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");
 }
--- a/src/mesh/DSRRouter.h
+++ b/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
--- a/src/mesh/FloodingRouter.cpp
+++ b/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);
 }
--- a/src/mesh/FloodingRouter.h
+++ b/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);
 };
--- a/src/mesh/MeshPacketQueue.cpp
+++ b/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);
    }
 }
--- a/src/mesh/MeshPlugin.cpp
+++ b/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 = &mp;
-        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() {
--- a/src/mesh/MeshPlugin.h
+++ b/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

--- a/src/mesh/MeshService.cpp
+++ b/src/mesh/MeshService.cpp
@ -65,7 +65,6 @@ void MeshService::init()

    if (gps)
        gpsObserver.observe(&gps->newStatus);
-    packetReceivedObserver.observe(&router->notifyPacketReceived);
 }


--- a/src/mesh/MeshService.h
+++ b/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;
--- a/src/mesh/MeshTypes.h
+++ b/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.
--- a/src/mesh/NodeDB.cpp
+++ b/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
-        }
-        }
    }
 }

--- a/src/mesh/NodeDB.h
+++ b/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

--- a/src/mesh/PhoneAPI.cpp
+++ b/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
 */
--- a/src/mesh/PhoneAPI.h
+++ b/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;
--- a/src/mesh/ProtobufPlugin.h
+++ b/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);
    }
 };
--- a/src/mesh/RadioInterface.cpp
+++ b/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,7 +150,7 @@ 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");
@ -169,7 +158,7 @@ void printPacket(const char *prefix, const MeshPacket *p)

 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);

--- a/src/mesh/RadioInterface.h
+++ b/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;

 /**
--- a/src/mesh/RadioLibInterface.cpp
+++ b/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);
--- a/src/mesh/RadioLibInterface.h
+++ b/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

--- a/src/mesh/ReliableRouter.cpp
+++ b/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);
--- a/src/mesh/ReliableRouter.h
+++ b/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)
--- a/src/mesh/Router.cpp
+++ b/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);
    }
 }

--- a/src/mesh/Router.h
+++ b/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.
@ -80,6 +78,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;
--- a/src/mesh/SinglePortPlugin.h
+++ b/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;
    }
--- a/src/mesh/generated/admin.pb.c
+++ b/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)
+
+
+
--- a/src/mesh/generated/admin.pb.h
+++ b/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
--- a/src/mesh/generated/apponly.pb.c
+++ b/src/mesh/generated/apponly.pb.c
@ -9,4 +9,7 @@
 PB_BIND(ServiceEnvelope, ServiceEnvelope, 2)


+PB_BIND(ChannelSet, ChannelSet, AUTO)
+
+

--- a/src/mesh/generated/apponly.pb.h
+++ b/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" */
--- a/src/mesh/generated/channel.pb.c
+++ b/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)
+
+
+
+
+
--- a/src/mesh/generated/channel.pb.h
+++ b/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
--- a/src/mesh/generated/deviceonly.pb.h
+++ b/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" */
--- a/src/mesh/generated/mesh.pb.c
+++ b/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)



-
-
-
-
-
--- a/src/mesh/generated/mesh.pb.h
+++ b/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" */
--- a/src/mesh/generated/portnums.pb.h
+++ b/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
--- a/src/mesh/generated/radioconfig.pb.c
+++ b/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)
+
+
+
+
+
+
+
--- a/src/mesh/generated/radioconfig.pb.h
+++ b/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
--- a/src/mesh/mesh-pb-constants.h
+++ b/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);
--- a/src/nrf52/NRF52CryptoEngine.cpp
+++ b/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);
        }
--- a/src/plugins/AdminPlugin.cpp
+++ b/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
+}
--- a/src/plugins/AdminPlugin.h
+++ b/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;
--- a/src/plugins/ExternalNotificationPlugin.cpp
+++ b/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()) {

--- a/src/plugins/NodeInfoPlugin.cpp
+++ b/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)
 }
--- a/src/plugins/NodeInfoPlugin.h
+++ b/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.  */
--- a/src/plugins/Plugins.cpp
+++ b/src/plugins/Plugins.cpp
@ -4,7 +4,10 @@
 #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();
--- a/src/plugins/PositionPlugin.cpp
+++ b/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;
--- a/src/plugins/PositionPlugin.h
+++ b/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.  */
--- a/src/plugins/RemoteHardwarePlugin.cpp
+++ b/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) {
--- a/src/plugins/RemoteHardwarePlugin.h
+++ b/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,
--- a/src/plugins/ReplyPlugin.cpp
+++ b/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;
 }
--- a/src/plugins/RoutingPlugin.cpp
+++ b/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;
+}
+
+
--- a/src/plugins/RoutingPlugin.h
+++ b/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;
--- a/src/plugins/SerialPlugin.cpp
+++ b/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);

--- a/src/plugins/TextMessagePlugin.cpp
+++ b/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.
--- a/src/plugins/esp32/EnvironmentalMeasurementPlugin.cpp
+++ b/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;
--- a/src/plugins/esp32/EnvironmentalMeasurementPlugin.h
+++ b/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();

--- a/src/plugins/esp32/RangeTestPlugin.cpp
+++ b/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);
    /*
--- a/src/plugins/esp32/StoreForwardPlugin.cpp
+++ b/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) {
--- a/src/portduino/CrossPlatformCryptoEngine.cpp
+++ b/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;
--- a/version.properties
+++ b/version.properties
@ -1,4 +1,4 @@
 [VERSION]  
 major = 1  
-minor = 1
-build = 48
+minor = 2
+build = 0