project updated

Author: paulocoutinhox

include/bitchat/core/constants.h

@@ -13,6 +13,12 @@ namespace constants
 const std::string BLE_SERVICE_UUID = "F47B5E2D-4A9E-4C5A-9B3F-8E1D2C3A4B5C";
 const std::string BLE_CHARACTERISTIC_UUID = "A1B2C3D4-E5F6-4A5B-8C9D-0E1F2A3B4C5D";
 
+// Client Version
+const std::string CLIENT_VERSION = "1.0";
+
+// Platform
+const std::string PLATFORM = "cpp";
+
 // BLE Configuration Constants
 const double BLE_SCAN_INTERVAL_SECONDS = 0.1;
 const double BLE_CONNECTION_TIMEOUT_SECONDS = 10.0;

include/bitchat/platform/bluetooth_interface.h

@@ -16,6 +16,7 @@ class BitchatMessage;
 using PeerConnectedCallback = std::function<void(const std::string &peripheralID)>;
 using PeerDisconnectedCallback = std::function<void(const std::string &peripheralID)>;
 using PacketReceivedCallback = std::function<void(const BitchatPacket &packet, const std::string &peripheralID)>;
+using PeripheralDiscoveredCallback = std::function<void(const std::string &peripheralID)>;
 
 // Abstract Bluetooth network interface that platforms must implement
 // This interface handles only BLE transport, all business logic is in BitchatManager
@@ -46,6 +47,7 @@ class IBluetoothNetwork
     virtual void setPeerConnectedCallback(PeerConnectedCallback callback) = 0;
     virtual void setPeerDisconnectedCallback(PeerDisconnectedCallback callback) = 0;
     virtual void setPacketReceivedCallback(PacketReceivedCallback callback) = 0;
+    virtual void setPeripheralDiscoveredCallback(PeripheralDiscoveredCallback callback) = 0;
 
     // Get connected peers count
     virtual size_t getConnectedPeersCount() const = 0;

include/bitchat/protocol/packet_serializer.h

@@ -37,10 +37,14 @@ class PacketSerializer
     // Parse channel announce payload
     void parseChannelAnnouncePayload(const std::vector<uint8_t> &payload, std::string &channel, bool &joining);
 
+    // Create version hello payload
+    std::vector<uint8_t> makeVersionHelloPayload(const std::vector<uint8_t> &supportedVersions, uint8_t preferredVersion, const std::string &clientVersion, const std::string &platform, const std::vector<std::string> &capabilities = {});
+
+    // Parse version hello payload
+    void parseVersionHelloPayload(const std::vector<uint8_t> &payload, std::vector<uint8_t> &supportedVersions, uint8_t &preferredVersion, std::string &clientVersion, std::string &platform, std::vector<std::string> &capabilities);
+
     // Create packet with proper fields
-    BitchatPacket makePacket(uint8_t type, const std::vector<uint8_t> &payload,
-                             bool hasRecipient = false, bool hasSignature = false,
-                             const std::string &senderID = "");
+    BitchatPacket makePacket(uint8_t type, const std::vector<uint8_t> &payload, bool hasRecipient, bool hasSignature, const std::string &senderID);
 
 private:
     // Helper functions for serialization

include/bitchat/services/message_service.h

@@ -59,6 +59,12 @@ class MessageService
     // Centralized packet processing - main entry point for all packets
     void processPacket(const BitchatPacket &packet, const std::string &peripheralID);
 
+    // Utility methods
+    BitchatPacket createMessagePacket(const BitchatMessage &message);
+    BitchatPacket createAnnouncePacket();
+    BitchatPacket createChannelAnnouncePacket(const std::string &channel, bool joining);
+    BitchatPacket createVersionHelloPacket();
+
     // Set callbacks for message events
     using MessageReceivedCallback = std::function<void(const BitchatMessage &)>;
     using ChannelJoinedCallback = std::function<void(const std::string &)>;
@@ -106,9 +112,6 @@ class MessageService
     void processNoiseIdentityAnnouncePacket(const BitchatPacket &packet);
 
     // Utility methods
-    BitchatPacket createMessagePacket(const BitchatMessage &message);
-    BitchatPacket createAnnouncePacket();
-    BitchatPacket createChannelAnnouncePacket(const std::string &channel, bool joining);
     std::string generateMessageID() const;
 
     // Helper methods

include/bitchat/services/network_service.h

@@ -19,6 +19,7 @@ namespace bitchat
 class BluetoothAnnounceRunner;
 class CleanupRunner;
 class IBluetoothNetwork;
+class MessageService;
 
 // NetworkService: Manages network operations, peer discovery, and message routing
 class NetworkService
@@ -28,7 +29,7 @@ class NetworkService
     ~NetworkService();
 
     // Initialize the network service
-    bool initialize(std::shared_ptr<IBluetoothNetwork> bluetoothNetworkInterface, std::shared_ptr<BluetoothAnnounceRunner> announceRunner, std::shared_ptr<CleanupRunner> cleanupRunner);
+    bool initialize(std::shared_ptr<IBluetoothNetwork> bluetoothNetworkInterface, std::shared_ptr<MessageService> messageService, std::shared_ptr<BluetoothAnnounceRunner> announceRunner, std::shared_ptr<CleanupRunner> cleanupRunner);
 
     // Start network operations
     bool start();
@@ -42,9 +43,6 @@ class NetworkService
     // Send a packet to a specific peer
     bool sendPacketToPeer(const BitchatPacket &packet, const std::string &peerID);
 
-    // Set the Bluetooth network interface
-    void setBluetoothNetworkInterface(std::shared_ptr<IBluetoothNetwork> bluetoothNetworkInterface);
-
     // Set callbacks
     using PacketReceivedCallback = std::function<void(const BitchatPacket &, const std::string &)>;
     using PeerConnectedCallback = std::function<void(const std::string &)>;
@@ -58,6 +56,9 @@ class NetworkService
     // Bluetooth interface
     std::shared_ptr<IBluetoothNetwork> bluetoothNetworkInterface;
 
+    // Message service for packet creation
+    std::shared_ptr<MessageService> messageService;
+
     // Runners
     std::shared_ptr<BluetoothAnnounceRunner> announceRunner;
     std::shared_ptr<CleanupRunner> cleanupRunner;
@@ -71,6 +72,7 @@ class NetworkService
     void onPeerConnected(const std::string &peripheralID);
     void onPeerDisconnected(const std::string &peripheralID);
     void onPacketReceived(const BitchatPacket &packet, const std::string &peripheralID);
+    void onPeripheralDiscovered(const std::string &peripheralID);
     void relayPacket(const BitchatPacket &packet);
 };
 

include/platforms/apple/bluetooth.h

@@ -24,6 +24,7 @@
 @property(nonatomic, copy) void (^peerConnectedCallback)(NSString *);
 @property(nonatomic, copy) void (^peerDisconnectedCallback)(NSString *);
 @property(nonatomic, copy) void (^packetReceivedCallback)(NSData *, NSString *);
+@property(nonatomic, copy) void (^peripheralDiscoveredCallback)(NSString *);
 
 // Initialization
 - (instancetype)init;
@@ -43,6 +44,7 @@
 // Callback setters
 - (void)setPeerDisconnectedCallback:(void (^)(NSString *peerID))callback;
 - (void)setPacketReceivedCallback:(void (^)(NSData *packetData, NSString *peripheralID))callback;
+- (void)setPeripheralDiscoveredCallback:(void (^)(NSString *peripheralID))callback;
 
 // Constants
 + (NSString *)serviceUUID;

include/platforms/apple/bluetooth_bridge.h

@@ -34,9 +34,10 @@ class AppleBluetoothNetworkBridge : public bitchat::IBluetoothNetwork
     std::shared_ptr<bitchat::PacketSerializer> serializer; // Handles packet serialization/deserialization
 
     // Callback function pointers for C++ interface
-    PeerConnectedCallback peerConnectedCallback;       // Called when a peer connects
-    PeerDisconnectedCallback peerDisconnectedCallback; // Called when a peer disconnects
-    PacketReceivedCallback packetReceivedCallback;     // Called when a packet is received
+    PeerConnectedCallback peerConnectedCallback;               // Called when a peer connects
+    PeerDisconnectedCallback peerDisconnectedCallback;         // Called when a peer disconnects
+    PacketReceivedCallback packetReceivedCallback;             // Called when a packet is received
+    PeripheralDiscoveredCallback peripheralDiscoveredCallback; // Called when peripheral is discovered
 
 public:
     /**
@@ -105,6 +106,12 @@ class AppleBluetoothNetworkBridge : public bitchat::IBluetoothNetwork
      */
     void setPacketReceivedCallback(PacketReceivedCallback callback) override;
 
+    /**
+     * @brief Set callback for peripheral discovery events
+     * @param callback Function to call when peripheral is discovered
+     */
+    void setPeripheralDiscoveredCallback(PeripheralDiscoveredCallback callback) override;
+
     /**
      * @brief Get the number of currently connected peers
      * @return Number of connected peers

include/platforms/linux/bluetooth.h

@@ -28,6 +28,7 @@ class LinuxBluetoothNetwork : public IBluetoothNetwork
     void setPeerConnectedCallback(PeerConnectedCallback callback) override;
     void setPeerDisconnectedCallback(PeerDisconnectedCallback callback) override;
     void setPacketReceivedCallback(PacketReceivedCallback callback) override;
+    void setPeripheralDiscoveredCallback(PeripheralDiscoveredCallback callback) override;
     size_t getConnectedPeersCount() const override;
 
 private:
@@ -46,6 +47,7 @@ class LinuxBluetoothNetwork : public IBluetoothNetwork
     PacketReceivedCallback packetReceivedCallback;
     PeerConnectedCallback peerConnectedCallback;
     PeerDisconnectedCallback peerDisconnectedCallback;
+    PeripheralDiscoveredCallback peripheralDiscoveredCallback;
 
     std::map<std::string, int> connectedSockets;
     std::mutex socketsMutex;

src/bitchat/core/bitchat_manager.cpp

@@ -56,7 +56,7 @@ bool BitchatManager::initialize(
     BitchatData::shared()->setPeerID(localPeerID);
 
     // Initialize services
-    if (!networkService->initialize(bluetoothNetworkInterface, announceRunner, cleanupRunner))
+    if (!networkService->initialize(bluetoothNetworkInterface, messageService, announceRunner, cleanupRunner))
     {
         spdlog::error("Failed to initialize NetworkService");
         return false;

src/bitchat/protocol/packet_serializer.cpp

@@ -603,4 +603,159 @@ void PacketSerializer::parseChannelAnnouncePayload(const std::vector<uint8_t> &p
     }
 }
 
+std::vector<uint8_t> PacketSerializer::makeVersionHelloPayload(const std::vector<uint8_t> &supportedVersions, uint8_t preferredVersion, const std::string &clientVersion, const std::string &platform, const std::vector<std::string> &capabilities)
+{
+    std::vector<uint8_t> data;
+
+    // Flags byte: bit 0 = hasCapabilities
+    uint8_t flags = 0;
+    if (!capabilities.empty())
+    {
+        flags |= 0x01;
+    }
+    writeUint8(data, flags);
+
+    // Supported versions array
+    writeUint8(data, static_cast<uint8_t>(supportedVersions.size()));
+    for (uint8_t version : supportedVersions)
+    {
+        writeUint8(data, version);
+    }
+
+    // Preferred version
+    writeUint8(data, preferredVersion);
+
+    // Client version (string with length prefix)
+    writeUint8(data, static_cast<uint8_t>(std::min(static_cast<size_t>(255), clientVersion.length())));
+    data.insert(data.end(), clientVersion.begin(), clientVersion.begin() + std::min(static_cast<size_t>(255), clientVersion.length()));
+
+    // Platform (string with length prefix)
+    writeUint8(data, static_cast<uint8_t>(std::min(static_cast<size_t>(255), platform.length())));
+    data.insert(data.end(), platform.begin(), platform.begin() + std::min(static_cast<size_t>(255), platform.length()));
+
+    // Capabilities (if present)
+    if (!capabilities.empty())
+    {
+        writeUint8(data, static_cast<uint8_t>(capabilities.size()));
+        for (const std::string &capability : capabilities)
+        {
+            writeUint8(data, static_cast<uint8_t>(std::min(static_cast<size_t>(255), capability.length())));
+            data.insert(data.end(), capability.begin(), capability.begin() + std::min(static_cast<size_t>(255), capability.length()));
+        }
+    }
+
+    return data;
+}
+
+void PacketSerializer::parseVersionHelloPayload(const std::vector<uint8_t> &payload, std::vector<uint8_t> &supportedVersions, uint8_t &preferredVersion, std::string &clientVersion, std::string &platform, std::vector<std::string> &capabilities)
+{
+    // Minimum size check: flags(1) + versionCount(1) + at least one version(1) + preferredVersion(1) + min strings
+    if (payload.size() < 4)
+    {
+        spdlog::error("Version hello payload too short");
+        return;
+    }
+
+    size_t offset = 0;
+
+    // Flags byte
+    uint8_t flags = readUint8(payload, offset);
+    bool hasCapabilities = (flags & 0x01) != 0;
+
+    // Supported versions count
+    uint8_t versionCount = readUint8(payload, offset);
+    supportedVersions.clear();
+
+    for (uint8_t i = 0; i < versionCount; i++)
+    {
+        if (offset >= payload.size())
+        {
+            spdlog::error("Version hello payload buffer overflow reading supported versions");
+            return;
+        }
+
+        supportedVersions.push_back(readUint8(payload, offset));
+    }
+
+    // Preferred version
+    if (offset >= payload.size())
+    {
+        spdlog::error("Version hello payload buffer overflow reading preferred version");
+        return;
+    }
+
+    preferredVersion = readUint8(payload, offset);
+
+    // Client version (string with length prefix)
+    if (offset >= payload.size())
+    {
+        spdlog::error("Version hello payload buffer overflow reading client version length");
+        return;
+    }
+
+    uint8_t clientVersionLen = readUint8(payload, offset);
+
+    if (offset + clientVersionLen > payload.size())
+    {
+        spdlog::error("Version hello payload buffer overflow reading client version");
+        return;
+    }
+
+    clientVersion = std::string(payload.begin() + offset, payload.begin() + offset + clientVersionLen);
+    offset += clientVersionLen;
+
+    // Platform (string with length prefix)
+    if (offset >= payload.size())
+    {
+        spdlog::error("Version hello payload buffer overflow reading platform length");
+        return;
+    }
+
+    uint8_t platformLen = readUint8(payload, offset);
+
+    if (offset + platformLen > payload.size())
+    {
+        spdlog::error("Version hello payload buffer overflow reading platform");
+        return;
+    }
+
+    platform = std::string(payload.begin() + offset, payload.begin() + offset + platformLen);
+    offset += platformLen;
+
+    // Capabilities (if present)
+    capabilities.clear();
+
+    if (hasCapabilities)
+    {
+        if (offset >= payload.size())
+        {
+            spdlog::error("Version hello payload buffer overflow reading capabilities count");
+            return;
+        }
+
+        uint8_t capCount = readUint8(payload, offset);
+
+        for (uint8_t i = 0; i < capCount; i++)
+        {
+            if (offset >= payload.size())
+            {
+                spdlog::error("Version hello payload buffer overflow reading capability length");
+                return;
+            }
+
+            uint8_t capLen = readUint8(payload, offset);
+
+            if (offset + capLen > payload.size())
+            {
+                spdlog::error("Version hello payload buffer overflow reading capability");
+                return;
+            }
+
+            capabilities.push_back(std::string(payload.begin() + offset, payload.begin() + offset + capLen));
+
+            offset += capLen;
+        }
+    }
+}
+
 } // namespace bitchat