feat(mesh): add BLE advertisement mesh bearer scaffold

Komzpa · Komzpa · commit de63f2c0ab9d · 2026-04-25T04:48:36.000+04:00
diff --git a/src/mesh/Router.cpp b/src/mesh/Router.cpp
@@ -14,6 +14,9 @@
 #if !MESHTASTIC_EXCLUDE_MQTT
 #include "mqtt/MQTT.h"
 #endif
+#if HAS_BLE_MESH_ADVERTISING
+#include "mesh/ble/BleAdvertisementMesh.h"
+#endif
 #include "Default.h"
 #if ARCH_PORTDUINO
 #include "Throttle.h"
@@ -381,6 +384,13 @@ ErrorCode Router::send(meshtastic_MeshPacket *p)
     }
 #endif
 
+#if HAS_BLE_MESH_ADVERTISING
+    if (bleAdvertisementMesh &&
+        config.network.enabled_protocols & meshtastic_Config_NetworkConfig_ProtocolFlags_BLE_ADVERTISEMENT_BROADCAST) {
+        bleAdvertisementMesh->onSend(p);
+    }
+#endif
+
     assert(iface); // This should have been detected already in sendLocal (or we just received a packet from outside)
     return iface->send(p);
 }
diff --git a/src/mesh/ble/BleAdvertisementMesh.cpp b/src/mesh/ble/BleAdvertisementMesh.cpp
@@ -0,0 +1,207 @@
+#include "mesh/ble/BleAdvertisementMesh.h"
+#include "mesh/mesh-pb-constants.h"
+
+#if HAS_BLE_MESH_ADVERTISING
+#include "Router.h"
+#include "configuration.h"
+#include "main.h"
+#endif
+#include <pb_decode.h>
+#include <pb_encode.h>
+#include <string.h>
+
+namespace
+{
+uint16_t crc16ccitt(const uint8_t *data, size_t length)
+{
+    uint16_t crc = 0xffff;
+    for (size_t i = 0; i < length; i++) {
+        crc ^= static_cast<uint16_t>(data[i]) << 8;
+        for (uint8_t bit = 0; bit < 8; bit++) {
+            crc = (crc & 0x8000) ? static_cast<uint16_t>((crc << 1) ^ 0x1021) : static_cast<uint16_t>(crc << 1);
+        }
+    }
+    return crc;
+}
+
+void putLe16(uint8_t *p, uint16_t v)
+{
+    p[0] = static_cast<uint8_t>(v);
+    p[1] = static_cast<uint8_t>(v >> 8);
+}
+
+void putLe32(uint8_t *p, uint32_t v)
+{
+    p[0] = static_cast<uint8_t>(v);
+    p[1] = static_cast<uint8_t>(v >> 8);
+    p[2] = static_cast<uint8_t>(v >> 16);
+    p[3] = static_cast<uint8_t>(v >> 24);
+}
+
+uint16_t getLe16(const uint8_t *p)
+{
+    return static_cast<uint16_t>(p[0]) | (static_cast<uint16_t>(p[1]) << 8);
+}
+
+uint32_t getLe32(const uint8_t *p)
+{
+    return static_cast<uint32_t>(p[0]) | (static_cast<uint32_t>(p[1]) << 8) | (static_cast<uint32_t>(p[2]) << 16) |
+           (static_cast<uint32_t>(p[3]) << 24);
+}
+} // namespace
+
+BleAdvertisementMeshCodec::BleAdvertisementMeshCodec() {}
+
+bool BleAdvertisementMeshCodec::forEachFrame(const meshtastic_MeshPacket *mp, EmitFrame emit, void *context)
+{
+    if (!mp || !emit || mp->which_payload_variant != meshtastic_MeshPacket_encrypted_tag) {
+        return false;
+    }
+
+    uint8_t encoded[meshtastic_MeshPacket_size] = {0};
+    size_t encodedLength = pb_encode_to_bytes(encoded, sizeof(encoded), &meshtastic_MeshPacket_msg, mp);
+    if (encodedLength == 0) {
+        return false;
+    }
+
+    uint8_t fragmentCount = (encodedLength + MAX_FRAGMENT_PAYLOAD_SIZE - 1) / MAX_FRAGMENT_PAYLOAD_SIZE;
+    if (fragmentCount == 0 || fragmentCount > MAX_FRAGMENTS) {
+        return false;
+    }
+
+    uint16_t crc = crc16ccitt(encoded, encodedLength);
+    for (uint8_t fragment = 0; fragment < fragmentCount; fragment++) {
+        size_t offset = fragment * MAX_FRAGMENT_PAYLOAD_SIZE;
+        size_t remaining = encodedLength - offset;
+        uint8_t payloadLength =
+            static_cast<uint8_t>(remaining > MAX_FRAGMENT_PAYLOAD_SIZE ? MAX_FRAGMENT_PAYLOAD_SIZE : remaining);
+
+        uint8_t frame[MAX_FRAME_SIZE] = {0};
+        frame[0] = FRAME_MAGIC_0;
+        frame[1] = FRAME_MAGIC_1;
+        frame[2] = FRAME_VERSION;
+        frame[3] = fragment;
+        frame[4] = fragmentCount;
+        frame[5] = payloadLength;
+        putLe32(&frame[6], mp->from);
+        putLe32(&frame[10], mp->id);
+        putLe16(&frame[14], crc);
+        memcpy(&frame[FRAME_HEADER_SIZE], &encoded[offset], payloadLength);
+
+        if (!emit(frame, FRAME_HEADER_SIZE + payloadLength, context)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+void BleAdvertisementMeshCodec::reset(uint32_t from, uint32_t packetId, uint16_t crc, uint8_t fragmentCount)
+{
+    currentFrom = from;
+    currentPacketId = packetId;
+    currentCrc = crc;
+    expectedFragments = fragmentCount;
+    lastFragmentLength = 0;
+    receivedMask = 0;
+    memset(encodedPacket, 0, sizeof(encodedPacket));
+}
+
+bool BleAdvertisementMeshCodec::receiveFrame(const uint8_t *frame, size_t frameLength, meshtastic_MeshPacket *out)
+{
+    if (!frame || !out || frameLength < FRAME_HEADER_SIZE || frameLength > MAX_FRAME_SIZE || frame[0] != FRAME_MAGIC_0 ||
+        frame[1] != FRAME_MAGIC_1 || frame[2] != FRAME_VERSION) {
+        return false;
+    }
+
+    uint8_t fragment = frame[3];
+    uint8_t fragmentCount = frame[4];
+    uint8_t payloadLength = frame[5];
+    uint32_t from = getLe32(&frame[6]);
+    uint32_t packetId = getLe32(&frame[10]);
+    uint16_t crc = getLe16(&frame[14]);
+
+    if (fragmentCount == 0 || fragmentCount > MAX_FRAGMENTS || fragment >= fragmentCount ||
+        payloadLength > MAX_FRAGMENT_PAYLOAD_SIZE || frameLength != FRAME_HEADER_SIZE + payloadLength) {
+        return false;
+    }
+
+    size_t offset = fragment * MAX_FRAGMENT_PAYLOAD_SIZE;
+    if (offset + payloadLength > sizeof(encodedPacket)) {
+        return false;
+    }
+
+    if (from != currentFrom || packetId != currentPacketId || crc != currentCrc || fragmentCount != expectedFragments) {
+        reset(from, packetId, crc, fragmentCount);
+    }
+
+    memcpy(&encodedPacket[offset], &frame[FRAME_HEADER_SIZE], payloadLength);
+    receivedMask |= 1ULL << fragment;
+    if (fragment == fragmentCount - 1) {
+        lastFragmentLength = payloadLength;
+    }
+
+    uint64_t completeMask = fragmentCount == 64 ? UINT64_MAX : ((1ULL << fragmentCount) - 1);
+    if (receivedMask != completeMask || lastFragmentLength == 0) {
+        return false;
+    }
+
+    size_t encodedLength = (fragmentCount - 1) * MAX_FRAGMENT_PAYLOAD_SIZE + lastFragmentLength;
+    if (crc16ccitt(encodedPacket, encodedLength) != currentCrc) {
+        reset(0, 0, 0, 0);
+        return false;
+    }
+
+    memset(out, 0, sizeof(*out));
+    bool decoded = pb_decode_from_bytes(encodedPacket, encodedLength, &meshtastic_MeshPacket_msg, out);
+    reset(0, 0, 0, 0);
+    return decoded;
+}
+
+#if HAS_BLE_MESH_ADVERTISING
+
+BleAdvertisementMesh *bleAdvertisementMesh = nullptr;
+
+namespace
+{
+struct PlatformEmitContext
+{
+    BleAdvertisementMesh::PlatformAdvertiseFrame advertiseFrame;
+};
+
+bool emitPlatformFrame(const uint8_t *frame, size_t frameLength, void *context)
+{
+    auto *platformContext = static_cast<PlatformEmitContext *>(context);
+    return platformContext && platformContext->advertiseFrame && platformContext->advertiseFrame(frame, frameLength);
+}
+} // namespace
+
+bool BleAdvertisementMesh::onSend(const meshtastic_MeshPacket *mp)
+{
+    if (!mp || !advertiseFrame ||
+        mp->transport_mechanism == meshtastic_MeshPacket_TransportMechanism_TRANSPORT_BLE_ADVERTISEMENT) {
+        return false;
+    }
+
+    LOG_DEBUG("Broadcasting packet over BLE advertisements (id=%u)", mp->id);
+    PlatformEmitContext context = {advertiseFrame};
+    return BleAdvertisementMeshCodec::forEachFrame(mp, emitPlatformFrame, &context);
+}
+
+void BleAdvertisementMesh::onAdvertisement(const uint8_t *frame, size_t frameLength)
+{
+    meshtastic_MeshPacket mp = {};
+    if (!codec.receiveFrame(frame, frameLength, &mp)) {
+        return;
+    }
+
+    if (router && mp.which_payload_variant == meshtastic_MeshPacket_encrypted_tag) {
+        mp.transport_mechanism = meshtastic_MeshPacket_TransportMechanism_TRANSPORT_BLE_ADVERTISEMENT;
+        UniquePacketPoolPacket p = packetPool.allocUniqueCopy(mp);
+        p->rx_snr = 0;
+        p->rx_rssi = 0;
+        router->enqueueReceivedMessage(p.release());
+    }
+}
+
+#endif // HAS_BLE_MESH_ADVERTISING
diff --git a/src/mesh/ble/BleAdvertisementMesh.h b/src/mesh/ble/BleAdvertisementMesh.h
@@ -0,0 +1,76 @@
+#pragma once
+
+#include "mesh/generated/meshtastic/mesh.pb.h"
+#include <stddef.h>
+#include <stdint.h>
+
+/**
+ * BLE advertisement bearer for encrypted MeshPacket protobufs.
+ *
+ * The platform BLE layer is intentionally kept outside this codec.  ESP32 and
+ * nRF52 implementations can carry these frames in service data, manufacturer
+ * data, or an extended advertising set without changing router semantics.
+ */
+class BleAdvertisementMeshCodec
+{
+  public:
+    static constexpr uint8_t FRAME_MAGIC_0 = 'M';
+    static constexpr uint8_t FRAME_MAGIC_1 = 'T';
+    static constexpr uint8_t FRAME_VERSION = 1;
+    // Legacy BLE advertisements are 31 bytes including AD type overhead.  A
+    // manufacturer-data bearer leaves 27 bytes for our frame after the 16-bit
+    // company id.
+    static constexpr size_t MAX_FRAME_SIZE = 27;
+    static constexpr size_t FRAME_HEADER_SIZE = 16;
+    static constexpr size_t MAX_FRAGMENT_PAYLOAD_SIZE = MAX_FRAME_SIZE - FRAME_HEADER_SIZE;
+    static constexpr uint8_t MAX_FRAGMENTS = 64;
+
+    typedef bool (*EmitFrame)(const uint8_t *frame, size_t frameLength, void *context);
+
+    BleAdvertisementMeshCodec();
+
+    /**
+     * Encode an encrypted MeshPacket into one or more BLE ADV frames.
+     */
+    static bool forEachFrame(const meshtastic_MeshPacket *mp, EmitFrame emit, void *context);
+
+    /**
+     * Accept one BLE ADV frame. Returns true when a complete MeshPacket has
+     * been reassembled into out.
+     */
+    bool receiveFrame(const uint8_t *frame, size_t frameLength, meshtastic_MeshPacket *out);
+
+  private:
+    uint32_t currentFrom = 0;
+    uint32_t currentPacketId = 0;
+    uint16_t currentCrc = 0;
+    uint8_t expectedFragments = 0;
+    uint8_t lastFragmentLength = 0;
+    uint64_t receivedMask = 0;
+    uint8_t encodedPacket[meshtastic_MeshPacket_size] = {0};
+
+    void reset(uint32_t from, uint32_t packetId, uint16_t crc, uint8_t fragmentCount);
+};
+
+#if HAS_BLE_MESH_ADVERTISING
+
+#include "MeshTypes.h"
+
+class BleAdvertisementMesh
+{
+  public:
+    typedef bool (*PlatformAdvertiseFrame)(const uint8_t *frame, size_t frameLength);
+
+    explicit BleAdvertisementMesh(PlatformAdvertiseFrame advertiseFrame) : advertiseFrame(advertiseFrame) {}
+
+    bool onSend(const meshtastic_MeshPacket *mp);
+    void onAdvertisement(const uint8_t *frame, size_t frameLength);
+
+  private:
+    PlatformAdvertiseFrame advertiseFrame = nullptr;
+    BleAdvertisementMeshCodec codec;
+};
+
+extern BleAdvertisementMesh *bleAdvertisementMesh;
+
+#endif // HAS_BLE_MESH_ADVERTISING
diff --git a/src/mesh/generated/meshtastic/config.pb.h b/src/mesh/generated/meshtastic/config.pb.h
@@ -171,7 +171,9 @@ typedef enum _meshtastic_Config_NetworkConfig_ProtocolFlags {
     /* Do not broadcast packets over any network protocol */
     meshtastic_Config_NetworkConfig_ProtocolFlags_NO_BROADCAST = 0,
     /* Enable broadcasting packets via UDP over the local network */
-    meshtastic_Config_NetworkConfig_ProtocolFlags_UDP_BROADCAST = 1
+    meshtastic_Config_NetworkConfig_ProtocolFlags_UDP_BROADCAST = 1,
+    /* Enable broadcasting packets over Bluetooth LE advertisements. */
+    meshtastic_Config_NetworkConfig_ProtocolFlags_BLE_ADVERTISEMENT_BROADCAST = 2
 } meshtastic_Config_NetworkConfig_ProtocolFlags;
 
 /* Deprecated in 2.7.4: Unused */
@@ -678,8 +680,8 @@ extern "C" {
 #define _meshtastic_Config_NetworkConfig_AddressMode_ARRAYSIZE ((meshtastic_Config_NetworkConfig_AddressMode)(meshtastic_Config_NetworkConfig_AddressMode_STATIC+1))
 
 #define _meshtastic_Config_NetworkConfig_ProtocolFlags_MIN meshtastic_Config_NetworkConfig_ProtocolFlags_NO_BROADCAST
-#define _meshtastic_Config_NetworkConfig_ProtocolFlags_MAX meshtastic_Config_NetworkConfig_ProtocolFlags_UDP_BROADCAST
-#define _meshtastic_Config_NetworkConfig_ProtocolFlags_ARRAYSIZE ((meshtastic_Config_NetworkConfig_ProtocolFlags)(meshtastic_Config_NetworkConfig_ProtocolFlags_UDP_BROADCAST+1))
+#define _meshtastic_Config_NetworkConfig_ProtocolFlags_MAX meshtastic_Config_NetworkConfig_ProtocolFlags_BLE_ADVERTISEMENT_BROADCAST
+#define _meshtastic_Config_NetworkConfig_ProtocolFlags_ARRAYSIZE ((meshtastic_Config_NetworkConfig_ProtocolFlags)(meshtastic_Config_NetworkConfig_ProtocolFlags_BLE_ADVERTISEMENT_BROADCAST+1))
 
 #define _meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_MIN meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_UNUSED
 #define _meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_MAX meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_UNUSED
diff --git a/src/mesh/generated/meshtastic/mesh.pb.h b/src/mesh/generated/meshtastic/mesh.pb.h
@@ -611,7 +611,9 @@ typedef enum _meshtastic_MeshPacket_TransportMechanism {
     /* Arrived via Multicast UDP */
     meshtastic_MeshPacket_TransportMechanism_TRANSPORT_MULTICAST_UDP = 6,
     /* Arrived via API connection */
-    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_API = 7
+    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_API = 7,
+    /* Arrived via Bluetooth LE advertisements */
+    meshtastic_MeshPacket_TransportMechanism_TRANSPORT_BLE_ADVERTISEMENT = 8
 } meshtastic_MeshPacket_TransportMechanism;
 
 /* Log levels, chosen to match python logging conventions. */
@@ -1449,8 +1451,8 @@ extern "C" {
 #define _meshtastic_MeshPacket_Delayed_ARRAYSIZE ((meshtastic_MeshPacket_Delayed)(meshtastic_MeshPacket_Delayed_DELAYED_DIRECT+1))
 
 #define _meshtastic_MeshPacket_TransportMechanism_MIN meshtastic_MeshPacket_TransportMechanism_TRANSPORT_INTERNAL
-#define _meshtastic_MeshPacket_TransportMechanism_MAX meshtastic_MeshPacket_TransportMechanism_TRANSPORT_API
-#define _meshtastic_MeshPacket_TransportMechanism_ARRAYSIZE ((meshtastic_MeshPacket_TransportMechanism)(meshtastic_MeshPacket_TransportMechanism_TRANSPORT_API+1))
+#define _meshtastic_MeshPacket_TransportMechanism_MAX meshtastic_MeshPacket_TransportMechanism_TRANSPORT_BLE_ADVERTISEMENT
+#define _meshtastic_MeshPacket_TransportMechanism_ARRAYSIZE ((meshtastic_MeshPacket_TransportMechanism)(meshtastic_MeshPacket_TransportMechanism_TRANSPORT_BLE_ADVERTISEMENT+1))
 
 #define _meshtastic_LogRecord_Level_MIN meshtastic_LogRecord_Level_UNSET
 #define _meshtastic_LogRecord_Level_MAX meshtastic_LogRecord_Level_CRITICAL
diff --git a/test/test_ble_advertisement_mesh/test_main.cpp b/test/test_ble_advertisement_mesh/test_main.cpp
