merge: upstream/dev into observer-firmware-dev (v1.17.1)

Picks up upstream MeshCore 1.17.1.

Notable upstream content:
- 1.17.1 version/build-date bump in the example MyMesh headers.
- nRF52: combine radio entropy with CC310 RNG.
- Companion FEM prefs: load/save of fem_ properties commented out until they
  can be set from the client.
- Scoped reply routing: replies no longer dropped when flood.max.unscoped is
  low (RoutingPolicy + unit tests).
- nRF52 unused-pin sweep (T1, T-Echo Lite, MeshPocket).

No conflicts.

src/helpers/RoutingPolicy.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <Packet.h>
+
+namespace mesh {
+
+/**
+ * \brief  Test a flood packet against the configured hop limits.
+ * \param  packet  inbound flood packet (caller has already checked isRouteFlood())
+ * \param  flood_max            max hops for any flood packet
+ * \param  flood_max_unscoped   max hops for ROUTE_TYPE_FLOOD (ie. un-scoped) packets
+ * \param  flood_max_advert     max hops for ADVERT packets
+ * \returns  true if the packet has exceeded a limit, and must not be forwarded
+ */
+inline bool isFloodHopLimitExceeded(const Packet* packet, uint8_t flood_max,
+                                    uint8_t flood_max_unscoped, uint8_t flood_max_advert) {
+  uint8_t hops = packet->getPathHashCount();
+  if (hops >= flood_max) return true;
+  if (packet->getRouteType() == ROUTE_TYPE_FLOOD && hops >= flood_max_unscoped) return true;
+  if (packet->getPayloadType() == PAYLOAD_TYPE_ADVERT && hops >= flood_max_advert) return true;
+  return false;
+}
+
+/**
+ * \brief  How a server routes a reply back to the requesting client.
+ */
+enum ReplyRoute : uint8_t {
+  REPLY_ROUTE_PATH_RETURN,       // request arrived by flood: reply with a PATH return, flooded back
+  REPLY_ROUTE_DIRECT_SUPPLIED,   // reply DIRECT, along the return path supplied in the request
+  REPLY_ROUTE_DIRECT_OUT_PATH,   // reply DIRECT, along the out_path already stored for this client
+  REPLY_ROUTE_FLOOD,             // no return path known: flood the reply
+};
+
+/**
+ * \param  inbound_is_flood    the request arrived as a flood packet
+ * \param  have_supplied_path  the request payload carried an explicit reply path
+ * \param  have_out_path       this server already has a stored out_path for the client
+ */
+inline ReplyRoute chooseReplyRoute(bool inbound_is_flood, bool have_supplied_path, bool have_out_path) {
+  if (inbound_is_flood) return REPLY_ROUTE_PATH_RETURN;
+  if (have_supplied_path) return REPLY_ROUTE_DIRECT_SUPPLIED;
+  if (have_out_path) return REPLY_ROUTE_DIRECT_OUT_PATH;
+  return REPLY_ROUTE_FLOOD;
+}
+
+/**
+ * \brief  Which transport scope a flooded reply should be sent with.
+ */
+enum ReplyScope : uint8_t {
+  REPLY_SCOPE_REQUEST,   // re-use the scope the request arrived on
+  REPLY_SCOPE_DEFAULT,   // fall back to this node's default region scope
+  REPLY_SCOPE_NONE,      // send un-scoped (ROUTE_TYPE_FLOOD)
+};
+
+/**
+ * \param  request_scope_known         request arrived scoped, and we resolved its Region's key
+ * \param  request_was_unscoped_flood  request arrived as an un-scoped flood
+ * \param  default_scope_known         this node has a default Region with a usable transport key
+ */
+inline ReplyScope chooseReplyScope(bool request_scope_known, bool request_was_unscoped_flood,
+                                   bool default_scope_known) {
+  if (request_scope_known) return REPLY_SCOPE_REQUEST;
+  if (request_was_unscoped_flood) return REPLY_SCOPE_NONE;  // requester chose un-scoped, so mirror it
+  if (default_scope_known) return REPLY_SCOPE_DEFAULT;      // scope unknowable: DIRECT, or unresolved Region
+  return REPLY_SCOPE_NONE;
+}
+
+}

src/helpers/radiolib/RadioLibWrappers.h

@@ -103,8 +103,10 @@ public:
 
   void random(uint8_t* dest, size_t sz) override {
 #ifdef USE_CC310_HW_CRYPTO
-    // CC310 TRNG is higher quality and environment-independent vs radio RSSI noise.
     nRFCrypto.Random.generate(dest, (uint16_t)sz);
+    for (int i = 0; i < sz; i++) {
+      dest[i] ^= _radio->randomByte() ^ (::random(0, 256) & 0xFF); // combine with Radio's entropy
+    }
 #else
     for (int i = 0; i < sz; i++) {
       dest[i] = _radio->randomByte() ^ (::random(0, 256) & 0xFF);