Merge branch 'dev' into reciprocal-path-retry

src/Identity.cpp

@@ -92,7 +92,7 @@ void LocalIdentity::sign(uint8_t* sig, const uint8_t* message, int msg_len) cons
   ed25519_sign(sig, message, msg_len, pub_key, prv_key);
 }
 
-void LocalIdentity::calcSharedSecret(uint8_t* secret, const uint8_t* other_pub_key) {
+void LocalIdentity::calcSharedSecret(uint8_t* secret, const uint8_t* other_pub_key) const {
   ed25519_key_exchange(secret, other_pub_key, prv_key);
 }
 

src/Identity.h

@@ -71,7 +71,7 @@ public:
    * \param  secret OUT - the 'shared secret' (must be PUB_KEY_SIZE bytes)
    * \param  other_pub_key IN - the public key of second party in the exchange (must be PUB_KEY_SIZE bytes)
   */
-  void calcSharedSecret(uint8_t* secret, const uint8_t* other_pub_key);
+  void calcSharedSecret(uint8_t* secret, const uint8_t* other_pub_key) const;
 
   bool readFrom(Stream& s);
   bool writeTo(Stream& s) const;

src/helpers/ClientACL.cpp

@@ -0,0 +1,128 @@
+#include "ClientACL.h"
+
+static File openWrite(FILESYSTEM* _fs, const char* filename) {
+  #if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
+    _fs->remove(filename);
+    return _fs->open(filename, FILE_O_WRITE);
+  #elif defined(RP2040_PLATFORM)
+    return _fs->open(filename, "w");
+  #else
+    return _fs->open(filename, "w", true);
+  #endif
+}
+
+void ClientACL::load(FILESYSTEM* _fs) {
+  num_clients = 0;
+  if (_fs->exists("/s_contacts")) {
+  #if defined(RP2040_PLATFORM)
+    File file = _fs->open("/s_contacts", "r");
+  #else
+    File file = _fs->open("/s_contacts");
+  #endif
+    if (file) {
+      bool full = false;
+      while (!full) {
+        ClientInfo c;
+        uint8_t pub_key[32];
+        uint8_t unused[6];
+
+        bool success = (file.read(pub_key, 32) == 32);
+        success = success && (file.read((uint8_t *) &c.permissions, 1) == 1);
+        success = success && (file.read(unused, 6) == 6);
+        success = success && (file.read((uint8_t *)&c.out_path_len, 1) == 1);
+        success = success && (file.read(c.out_path, 64) == 64);
+        success = success && (file.read(c.shared_secret, PUB_KEY_SIZE) == PUB_KEY_SIZE);
+        c.last_timestamp = 0;  // transient
+        c.last_activity = 0;
+
+        if (!success) break; // EOF
+
+        c.id = mesh::Identity(pub_key);
+        if (num_clients < MAX_CLIENTS) {
+          clients[num_clients++] = c;
+        } else {
+          full = true;
+        }
+      }
+      file.close();
+    }
+  }
+}
+
+void ClientACL::save(FILESYSTEM* _fs) {
+  File file = openWrite(_fs, "/s_contacts");
+  if (file) {
+    uint8_t unused[6];
+    memset(unused, 0, sizeof(unused));
+
+    for (int i = 0; i < num_clients; i++) {
+      auto c = &clients[i];
+      if (c->permissions == 0) continue;    // skip deleted entries
+
+      bool success = (file.write(c->id.pub_key, 32) == 32);
+      success = success && (file.write((uint8_t *) &c->permissions, 1) == 1);
+      success = success && (file.write(unused, 6) == 6);
+      success = success && (file.write((uint8_t *)&c->out_path_len, 1) == 1);
+      success = success && (file.write(c->out_path, 64) == 64);
+      success = success && (file.write(c->shared_secret, PUB_KEY_SIZE) == PUB_KEY_SIZE);
+
+      if (!success) break; // write failed
+    }
+    file.close();
+  }
+}
+
+ClientInfo* ClientACL::getClient(const uint8_t* pubkey, int key_len) {
+  for (int i = 0; i < num_clients; i++) {
+    if (memcmp(pubkey, clients[i].id.pub_key, key_len) == 0) return &clients[i];  // already known
+  }
+  return NULL;  // not found
+}
+
+ClientInfo* ClientACL::putClient(const mesh::Identity& id, uint8_t init_perms) {
+  uint32_t min_time = 0xFFFFFFFF;
+  ClientInfo* oldest = &clients[MAX_CLIENTS - 1];
+  for (int i = 0; i < num_clients; i++) {
+    if (id.matches(clients[i].id)) return &clients[i];  // already known
+    if (!clients[i].isAdmin() && clients[i].last_activity < min_time) {
+      oldest = &clients[i];
+      min_time = oldest->last_activity;
+    }
+  }
+
+  ClientInfo* c;
+  if (num_clients < MAX_CLIENTS) {
+    c = &clients[num_clients++];
+  } else {
+    c = oldest;  // evict least active contact
+  }
+  memset(c, 0, sizeof(*c));
+  c->permissions = init_perms;
+  c->id = id;
+  c->out_path_len = -1;  // initially out_path is unknown
+  return c;
+}
+
+bool ClientACL::applyPermissions(const mesh::LocalIdentity& self_id, const uint8_t* pubkey, int key_len, uint8_t perms) {
+  ClientInfo* c;
+  if ((perms & PERM_ACL_ROLE_MASK) == PERM_ACL_GUEST) {  // guest role is not persisted in contacts
+    c = getClient(pubkey, key_len);
+    if (c == NULL) return false;   // partial pubkey not found
+
+    num_clients--;   // delete from contacts[]
+    int i = c - clients;
+    while (i < num_clients) {
+      clients[i] = clients[i + 1];
+      i++;
+    }
+  } else {
+    if (key_len < PUB_KEY_SIZE) return false;   // need complete pubkey when adding/modifying
+
+    mesh::Identity id(pubkey);
+    c = putClient(id, 0);
+
+    c->permissions = perms;  // update their permissions
+    self_id.calcSharedSecret(c->shared_secret, pubkey);
+  }
+  return true;
+}

src/helpers/ClientACL.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <Arduino.h>   // needed for PlatformIO
+#include <Mesh.h>
+#include <helpers/IdentityStore.h>
+
+#define PERM_ACL_ROLE_MASK     3   // lower 2 bits
+#define PERM_ACL_GUEST         0
+#define PERM_ACL_READ_ONLY     1
+#define PERM_ACL_READ_WRITE    2
+#define PERM_ACL_ADMIN         3
+
+struct ClientInfo {
+  mesh::Identity id;
+  uint8_t permissions;
+  int8_t out_path_len;
+  uint8_t out_path[MAX_PATH_SIZE];
+  uint8_t shared_secret[PUB_KEY_SIZE];
+  uint32_t last_timestamp;   // by THEIR clock  (transient)
+  uint32_t last_activity;    // by OUR clock    (transient)
+
+  bool isAdmin() const { return (permissions & PERM_ACL_ROLE_MASK) == PERM_ACL_ADMIN; }
+};
+
+#ifndef MAX_CLIENTS
+  #define MAX_CLIENTS           20
+#endif
+
+class ClientACL {
+  ClientInfo clients[MAX_CLIENTS];
+  int num_clients;
+
+public:
+  ClientACL() { 
+    memset(clients, 0, sizeof(clients));
+    num_clients = 0;
+  }
+  void load(FILESYSTEM* _fs);
+  void save(FILESYSTEM* _fs);
+
+  ClientInfo* getClient(const uint8_t* pubkey, int key_len);
+  ClientInfo* putClient(const mesh::Identity& id, uint8_t init_perms);
+  bool applyPermissions(const mesh::LocalIdentity& self_id, const uint8_t* pubkey, int key_len, uint8_t perms);
+
+  int getNumClients() const { return num_clients; }
+  ClientInfo* getClientByIdx(int idx) { return &clients[idx]; }
+};

src/helpers/sensors/EnvironmentSensorManager.cpp

@@ -252,7 +252,7 @@ bool EnvironmentSensorManager::querySensors(uint8_t requester_permissions, Cayen
   next_available_channel = TELEM_CHANNEL_SELF + 1;
 
   if (requester_permissions & TELEM_PERM_LOCATION && gps_active) {
-    telemetry.addGPS(TELEM_CHANNEL_SELF, node_lat, node_lon, 0.0f); // allow lat/lon via telemetry even if no GPS is detected
+    telemetry.addGPS(TELEM_CHANNEL_SELF, node_lat, node_lon, node_altitude); // allow lat/lon via telemetry even if no GPS is detected
   }
 
   if (requester_permissions & TELEM_PERM_ENVIRONMENT) {
@@ -577,17 +577,23 @@ void EnvironmentSensorManager::loop() {
       node_lat = ((double)ublox_GNSS.getLatitude())/10000000.;
       node_lon = ((double)ublox_GNSS.getLongitude())/10000000.;
       MESH_DEBUG_PRINTLN("lat %f lon %f", node_lat, node_lon);
+      node_altitude = ((double)ublox_GNSS.getAltitude()) / 1000.0;
+      MESH_DEBUG_PRINTLN("lat %f lon %f alt %f", node_lat, node_lon, node_altitude);
     }
     else if (serialGPSFlag && _location->isValid()) {
       node_lat = ((double)_location->getLatitude())/1000000.;
       node_lon = ((double)_location->getLongitude())/1000000.;
       MESH_DEBUG_PRINTLN("lat %f lon %f", node_lat, node_lon);
+      node_altitude = ((double)_location->getAltitude()) / 1000.0;
+      MESH_DEBUG_PRINTLN("lat %f lon %f alt %f", node_lat, node_lon, node_altitude);
     }
     #else
     if (_location->isValid()) {
       node_lat = ((double)_location->getLatitude())/1000000.;
       node_lon = ((double)_location->getLongitude())/1000000.;
       MESH_DEBUG_PRINTLN("lat %f lon %f", node_lat, node_lon);
+      node_altitude = ((double)_location->getAltitude()) / 1000.0;
+      MESH_DEBUG_PRINTLN("lat %f lon %f alt %f", node_lat, node_lon, node_altitude);
     }
     #endif
     }

src/helpers/sensors/LPPDataHelpers.h

@@ -0,0 +1,223 @@
+#pragma once
+
+#include <stdint.h>
+
+#define LPP_DIGITAL_INPUT 0         // 1 byte
+#define LPP_DIGITAL_OUTPUT 1        // 1 byte
+#define LPP_ANALOG_INPUT 2          // 2 bytes, 0.01 signed
+#define LPP_ANALOG_OUTPUT 3         // 2 bytes, 0.01 signed
+#define LPP_GENERIC_SENSOR 100      // 4 bytes, unsigned
+#define LPP_LUMINOSITY 101          // 2 bytes, 1 lux unsigned
+#define LPP_PRESENCE 102            // 1 byte, bool
+#define LPP_TEMPERATURE 103         // 2 bytes, 0.1°C signed
+#define LPP_RELATIVE_HUMIDITY 104   // 1 byte, 0.5% unsigned
+#define LPP_ACCELEROMETER 113       // 2 bytes per axis, 0.001G
+#define LPP_BAROMETRIC_PRESSURE 115 // 2 bytes 0.1hPa unsigned
+#define LPP_VOLTAGE 116             // 2 bytes 0.01V unsigned
+#define LPP_CURRENT 117             // 2 bytes 0.001A unsigned
+#define LPP_FREQUENCY 118           // 4 bytes 1Hz unsigned
+#define LPP_PERCENTAGE 120          // 1 byte 1-100% unsigned
+#define LPP_ALTITUDE 121            // 2 byte 1m signed
+#define LPP_CONCENTRATION 125       // 2 bytes, 1 ppm unsigned
+#define LPP_POWER 128               // 2 byte, 1W, unsigned
+#define LPP_DISTANCE 130            // 4 byte, 0.001m, unsigned
+#define LPP_ENERGY 131              // 4 byte, 0.001kWh, unsigned
+#define LPP_DIRECTION 132           // 2 bytes, 1deg, unsigned
+#define LPP_UNIXTIME 133            // 4 bytes, unsigned
+#define LPP_GYROMETER 134           // 2 bytes per axis, 0.01 °/s
+#define LPP_COLOUR 135              // 1 byte per RGB Color
+#define LPP_GPS 136                 // 3 byte lon/lat 0.0001 °, 3 bytes alt 0.01 meter
+#define LPP_SWITCH 142              // 1 byte, 0/1
+#define LPP_POLYLINE 240            // 1 byte size, 1 byte delta factor, 3 byte lon/lat 0.0001° * factor, n (size-8) bytes deltas
+
+// Multipliers
+#define LPP_DIGITAL_INPUT_MULT 1
+#define LPP_DIGITAL_OUTPUT_MULT 1
+#define LPP_ANALOG_INPUT_MULT 100
+#define LPP_ANALOG_OUTPUT_MULT 100
+#define LPP_GENERIC_SENSOR_MULT 1
+#define LPP_LUMINOSITY_MULT 1
+#define LPP_PRESENCE_MULT 1
+#define LPP_TEMPERATURE_MULT 10
+#define LPP_RELATIVE_HUMIDITY_MULT 2
+#define LPP_ACCELEROMETER_MULT 1000
+#define LPP_BAROMETRIC_PRESSURE_MULT 10
+#define LPP_VOLTAGE_MULT 100
+#define LPP_CURRENT_MULT 1000
+#define LPP_FREQUENCY_MULT 1
+#define LPP_PERCENTAGE_MULT 1
+#define LPP_ALTITUDE_MULT 1
+#define LPP_POWER_MULT 1
+#define LPP_DISTANCE_MULT 1000
+#define LPP_ENERGY_MULT 1000
+#define LPP_DIRECTION_MULT 1
+#define LPP_UNIXTIME_MULT 1
+#define LPP_GYROMETER_MULT 100
+#define LPP_GPS_LAT_LON_MULT 10000
+#define LPP_GPS_ALT_MULT 100
+#define LPP_SWITCH_MULT 1
+#define LPP_CONCENTRATION_MULT 1
+#define LPP_COLOUR_MULT 1
+
+#define LPP_ERROR_OK 0
+#define LPP_ERROR_OVERFLOW 1
+#define LPP_ERROR_UNKOWN_TYPE 2
+
+class LPPReader {
+  const uint8_t* _buf;
+  uint8_t _len;
+  uint8_t _pos;
+
+  float getFloat(const uint8_t * buffer, uint8_t size, uint32_t multiplier, bool is_signed) {
+    uint32_t value = 0;
+    for (uint8_t i = 0; i < size; i++) {
+      value = (value << 8) + buffer[i];
+    }
+
+    int sign = 1;
+    if (is_signed) {
+      uint32_t bit = 1ul << ((size * 8) - 1);
+      if ((value & bit) == bit) {
+        value = (bit << 1) - value;
+        sign = -1;
+      }
+    }
+    return sign * ((float) value / multiplier);
+  }
+
+public:
+  LPPReader(const uint8_t buf[], uint8_t len) : _buf(buf), _len(len), _pos(0) { }
+
+  void reset() {
+    _pos = 0;
+  }
+
+  bool readHeader(uint8_t& channel, uint8_t& type) {
+    if (_pos + 2 < _len) {
+      channel = _buf[_pos++];
+      type = _buf[_pos++];
+
+      return channel != 0;   // channel 0 is End-of-data
+    }
+    return false;  // end-of-buffer
+  }
+
+  bool readGPS(float& lat, float& lon, float& alt) {
+    lat = getFloat(&_buf[_pos], 3, 10000, true); _pos += 3;
+    lon = getFloat(&_buf[_pos], 3, 10000, true); _pos += 3;
+    alt = getFloat(&_buf[_pos], 3, 100, true); _pos += 3;
+    return _pos <= _len;
+  }
+  bool readVoltage(float& voltage) {
+    voltage = getFloat(&_buf[_pos], 2, 100, false); _pos += 2;
+    return _pos <= _len;
+  }
+  bool readCurrent(float& amps) {
+    amps = getFloat(&_buf[_pos], 2, 1000, false); _pos += 2;
+    return _pos <= _len;
+  }
+  bool readPower(float& watts) {
+    watts = getFloat(&_buf[_pos], 2, 1, false); _pos += 2;
+    return _pos <= _len;
+  }
+  bool readTemperature(float& degrees_c) {
+    degrees_c = getFloat(&_buf[_pos], 2, 10, true); _pos += 2;
+    return _pos <= _len;
+  }
+  bool readPressure(float& pa) {
+    pa = getFloat(&_buf[_pos], 2, 10, false); _pos += 2;
+    return _pos <= _len;
+  }
+  bool readRelativeHumidity(float& pct) {
+    pct = getFloat(&_buf[_pos], 1, 2, false); _pos += 1;
+    return _pos <= _len;
+  }
+  bool readAltitude(float& m) {
+    m = getFloat(&_buf[_pos], 2, 1, true); _pos += 2;
+    return _pos <= _len;
+  }
+
+  void skipData(uint8_t type) {
+    switch (type) {
+      case LPP_GPS:
+        _pos += 9; break;
+      case LPP_POLYLINE:
+        _pos += 8; break;  // TODO: this is MINIMIUM
+      case LPP_GYROMETER:
+      case LPP_ACCELEROMETER:
+        _pos += 6; break;
+      case LPP_GENERIC_SENSOR:
+      case LPP_FREQUENCY:
+      case LPP_DISTANCE:
+      case LPP_ENERGY:
+      case LPP_UNIXTIME:
+        _pos += 4; break;
+      case LPP_COLOUR:
+        _pos += 3; break;
+      case LPP_ANALOG_INPUT:
+      case LPP_ANALOG_OUTPUT:
+      case LPP_LUMINOSITY:
+      case LPP_TEMPERATURE:
+      case LPP_CONCENTRATION:
+      case LPP_BAROMETRIC_PRESSURE:
+      case LPP_ALTITUDE:
+      case LPP_VOLTAGE:
+      case LPP_CURRENT:
+      case LPP_DIRECTION:
+      case LPP_POWER:
+        _pos += 2; break;
+      default:
+        _pos++;
+    }
+  }
+};
+
+class LPPWriter {
+  uint8_t* _buf;
+  uint8_t _max_len;
+  uint8_t _len;
+
+  void write(uint16_t value) {
+    _buf[_len++] = (value >> 8) & 0xFF;  // MSB
+    _buf[_len++] = value & 0xFF;         // LSB
+  }
+
+public:
+  LPPWriter(uint8_t buf[], uint8_t max_len): _buf(buf), _max_len(max_len), _len(0) { }
+
+  bool writeVoltage(uint8_t channel, float voltage) {
+    if (_len + 4 <= _max_len) {
+      _buf[_len++] = channel;
+      _buf[_len++] = LPP_VOLTAGE;
+      uint16_t value = voltage * 100;
+      write(value);
+      return true;
+    }
+    return false;
+  }
+
+  bool writeGPS(uint8_t channel, float lat, float lon, float alt) {
+    if (_len + 11 <= _max_len) {
+      _buf[_len++] = channel;
+      _buf[_len++] = LPP_GPS;
+
+      int32_t lati = lat * 10000;  // we lose some precision :-(
+      int32_t loni = lon * 10000;
+      int32_t alti = alt * 100;
+
+      _buf[_len++] = lati >> 16;
+      _buf[_len++] = lati >> 8;
+      _buf[_len++] = lati;
+      _buf[_len++] = loni >> 16;
+      _buf[_len++] = loni >> 8;
+      _buf[_len++] = loni;
+      _buf[_len++] = alti >> 16;
+      _buf[_len++] = alti >> 8;
+      _buf[_len++] = alti;
+      return true;
+    }
+    return false;
+  }
+
+  uint8_t length() { return _len; }
+};