project updated

Author: paulocoutinhox

include/bitchat/helpers/protocol_helper.h

@@ -1,12 +1,79 @@
 #pragma once
 
+#include <chrono>
 #include <cstdint>
+#include <map>
 #include <string>
 #include <vector>
 
 namespace bitchat
 {
 
+// Version negotiation state enum
+enum class VersionNegotiationState
+{
+    NotStarted,
+    HelloSent,
+    AckReceived,
+    Failed
+};
+
+// Version hello structure
+struct VersionHello
+{
+    std::vector<uint8_t> supportedVersions;
+    uint8_t preferredVersion;
+    std::string clientVersion;
+    std::string platform;
+    std::vector<std::string> capabilities;
+
+    VersionHello() = default;
+    VersionHello(const std::vector<uint8_t> &versions, uint8_t preferred, const std::string &version, const std::string &plat)
+        : supportedVersions(versions)
+        , preferredVersion(preferred)
+        , clientVersion(version)
+        , platform(plat)
+    {
+        // Pass
+    }
+};
+
+// Version ack structure
+struct VersionAck
+{
+    uint8_t agreedVersion;
+    std::string serverVersion;
+    std::string platform;
+    bool rejected;
+    std::string reason;
+
+    VersionAck()
+        : agreedVersion(0)
+        , rejected(false)
+    {
+        // Pass
+    }
+
+    VersionAck(uint8_t version, const std::string &serverVer, const std::string &plat)
+        : agreedVersion(version)
+        , serverVersion(serverVer)
+        , platform(plat)
+        , rejected(false)
+    {
+        // Pass
+    }
+
+    VersionAck(uint8_t version, const std::string &serverVer, const std::string &plat, bool reject, const std::string &rejectReason)
+        : agreedVersion(version)
+        , serverVersion(serverVer)
+        , platform(plat)
+        , rejected(reject)
+        , reason(rejectReason)
+    {
+        // Pass
+    }
+};
+
 // Helper class for protocol-related helper functions
 class ProtocolHelper
 {
@@ -15,6 +82,10 @@ class ProtocolHelper
     static bool isValidChannelName(const std::string &channel);
     static bool isValidNickname(const std::string &nickname);
 
+    // Version negotiation helpers
+    static uint8_t negotiateVersion(const std::vector<uint8_t> &clientVersions, const std::vector<uint8_t> &serverVersions);
+    static std::vector<uint8_t> getSupportedVersions();
+
 private:
     ProtocolHelper() = delete;
 };

include/bitchat/platform/bluetooth_interface.h

@@ -40,6 +40,9 @@ class IBluetoothNetwork
     // Send packet to specific peer
     virtual bool sendPacketToPeer(const BitchatPacket &packet, const std::string &peerID) = 0;
 
+    // Send packet to specific peripheral by peripheralID
+    virtual bool sendPacketToPeripheral(const BitchatPacket &packet, const std::string &peripheralID) = 0;
+
     // Check if Bluetooth is ready
     virtual bool isReady() const = 0;
 

include/bitchat/protocol/packet_serializer.h

@@ -43,6 +43,12 @@ class PacketSerializer
     // 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 version ack payload
+    std::vector<uint8_t> makeVersionAckPayload(uint8_t agreedVersion, const std::string &serverVersion, const std::string &platform, bool rejected, const std::string &reason);
+
+    // Parse version ack payload
+    void parseVersionAckPayload(const std::vector<uint8_t> &payload, uint8_t &agreedVersion, std::string &serverVersion, std::string &platform, bool &rejected, std::string &reason);
+
     // Create packet with proper fields
     BitchatPacket makePacket(uint8_t type, const std::vector<uint8_t> &payload, bool hasRecipient, bool hasSignature, const std::string &senderID);
 

include/bitchat/services/message_service.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "bitchat/core/bitchat_data.h"
+#include "bitchat/helpers/protocol_helper.h"
 #include "bitchat/protocol/packet.h"
 #include "bitchat/ui/ui_interface.h"
 #include <functional>
@@ -65,6 +66,10 @@ class MessageService
     BitchatPacket createChannelAnnouncePacket(const std::string &channel, bool joining);
     BitchatPacket createVersionHelloPacket();
 
+    // Version negotiation
+    void sendVersionHello(const std::string &peripheralID);
+    void sendVersionAck(const VersionAck &ack, const std::string &peerID);
+
     // Set callbacks for message events
     using MessageReceivedCallback = std::function<void(const BitchatMessage &)>;
     using ChannelJoinedCallback = std::function<void(const std::string &)>;
@@ -97,7 +102,13 @@ class MessageService
     PeerConnectedCallback peerConnectedCallback;
     PeerDisconnectedCallback peerDisconnectedCallback;
 
-    // Message-related packet processing
+    // Version hello packet processing
+    void processVersionHelloPacket(const BitchatPacket &packet);
+    void processVersionAckPacket(const BitchatPacket &packet);
+    void handleVersionHello(const std::string &peerID, const std::vector<uint8_t> &data);
+    void handleVersionAck(const std::string &peerID, const std::vector<uint8_t> &data);
+
+    // Message packet processing
     void processMessagePacket(const BitchatPacket &packet);
     void processChannelAnnouncePacket(const BitchatPacket &packet);
 

include/bitchat/services/network_service.h

@@ -43,6 +43,9 @@ class NetworkService
     // Send a packet to a specific peer
     bool sendPacketToPeer(const BitchatPacket &packet, const std::string &peerID);
 
+    // Send a packet to a specific peripheral
+    bool sendPacketToPeripheral(const BitchatPacket &packet, const std::string &peripheralID);
+
     // Set callbacks
     using PacketReceivedCallback = std::function<void(const BitchatPacket &, const std::string &)>;
     using PeerConnectedCallback = std::function<void(const std::string &)>;

include/platforms/apple/bluetooth.h

@@ -36,6 +36,7 @@
 - (BOOL)sendPacket:(NSData *)packetData;
 - (BOOL)sendPacket:(NSData *)packetData toPeripheral:(CBPeripheral *)peripheral;
 - (BOOL)sendPacket:(NSData *)packetData toPeer:(NSString *)peerID;
+- (BOOL)sendPacket:(NSData *)packetData toPeripheralID:(NSString *)peripheralID;
 
 // State
 - (BOOL)isReady;

include/platforms/apple/bluetooth_bridge.h

@@ -82,6 +82,14 @@ class AppleBluetoothNetworkBridge : public bitchat::IBluetoothNetwork
      */
     bool sendPacketToPeer(const BitchatPacket &packet, const std::string &peerID) override;
 
+    /**
+     * @brief Send a packet to a specific peripheral by peripheralID
+     * @param packet The packet to send
+     * @param peripheralID The target peripheral's identifier
+     * @return true if sent successfully, false otherwise
+     */
+    bool sendPacketToPeripheral(const BitchatPacket &packet, const std::string &peripheralID) override;
+
     /**
      * @brief Check if Bluetooth system is ready for operations
      * @return true if ready, false otherwise

include/platforms/linux/bluetooth.h

@@ -23,6 +23,7 @@ class LinuxBluetoothNetwork : public IBluetoothNetwork
     void stop() override;
     bool sendPacket(const BitchatPacket &packet) override;
     bool sendPacketToPeer(const BitchatPacket &packet, const std::string &peerID) override;
+    bool sendPacketToPeripheral(const BitchatPacket &packet, const std::string &peripheralID) override;
     bool isReady() const override;
 
     void setPeerConnectedCallback(PeerConnectedCallback callback) override;

src/bitchat/helpers/protocol_helper.cpp

@@ -1,5 +1,7 @@
 #include "bitchat/helpers/protocol_helper.h"
+#include "bitchat/core/constants.h"
 #include <algorithm>
+#include <spdlog/spdlog.h>
 
 namespace bitchat
 {
@@ -34,19 +36,19 @@ bool ProtocolHelper::isValidChannelName(const std::string &channel)
         return false;
     }
 
-    // Check if the channel is too long
-    if (channel.length() > 50)
+    // Check if the channel starts with #
+    if (channel[0] != '#')
     {
         return false;
     }
 
-    // Check if the channel starts with a #
-    if (channel[0] != '#')
+    // Check if the channel is too long (more than 50 characters)
+    if (channel.length() > 50)
     {
         return false;
     }
 
-    // Check if it contains only alphanumeric characters and underscores
+    // Check if it contains only alphanumeric characters, underscores, and hyphens after the #
     // clang-format off
     return std::all_of(channel.begin() + 1, channel.end(), [](char c) {
         return std::isalnum(c) || c == '_' || c == '-';
@@ -56,14 +58,8 @@ bool ProtocolHelper::isValidChannelName(const std::string &channel)
 
 bool ProtocolHelper::isValidNickname(const std::string &nickname)
 {
-    // Check if the nickname is empty
-    if (nickname.empty())
-    {
-        return false;
-    }
-
-    // Check if the nickname is too long
-    if (nickname.length() > 32)
+    // Nickname should not be empty and should be reasonable length
+    if (nickname.empty() || nickname.length() > 32)
     {
         return false;
     }
@@ -76,4 +72,25 @@ bool ProtocolHelper::isValidNickname(const std::string &nickname)
     // clang-format on
 }
 
+uint8_t ProtocolHelper::negotiateVersion(const std::vector<uint8_t> &clientVersions, const std::vector<uint8_t> &serverVersions)
+{
+    // Find the highest common version between client and server
+    for (auto it = clientVersions.rbegin(); it != clientVersions.rend(); ++it)
+    {
+        if (std::find(serverVersions.begin(), serverVersions.end(), *it) != serverVersions.end())
+        {
+            return *it;
+        }
+    }
+
+    // No compatible version found
+    return 0;
+}
+
+std::vector<uint8_t> ProtocolHelper::getSupportedVersions()
+{
+    // Currently only support version 1
+    return {1};
+}
+
 } // namespace bitchat

src/bitchat/protocol/packet_serializer.cpp

@@ -758,4 +758,120 @@ void PacketSerializer::parseVersionHelloPayload(const std::vector<uint8_t> &payl
     }
 }
 
+std::vector<uint8_t> PacketSerializer::makeVersionAckPayload(uint8_t agreedVersion, const std::string &serverVersion, const std::string &platform, bool rejected, const std::string &reason)
+{
+    std::vector<uint8_t> data;
+
+    // Flags byte: bit 0 = rejected, bit 1 = hasReason
+    uint8_t flags = 0;
+    if (rejected)
+    {
+        flags |= 0x01;
+    }
+    if (!reason.empty())
+    {
+        flags |= 0x02;
+    }
+    writeUint8(data, flags);
+
+    // Agreed version
+    writeUint8(data, agreedVersion);
+
+    // Server version (string with length prefix)
+    writeUint8(data, static_cast<uint8_t>(std::min(static_cast<size_t>(255), serverVersion.length())));
+    data.insert(data.end(), serverVersion.begin(), serverVersion.begin() + std::min(static_cast<size_t>(255), serverVersion.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()));
+
+    // Reason (if present)
+    if (!reason.empty())
+    {
+        writeUint8(data, static_cast<uint8_t>(std::min(static_cast<size_t>(255), reason.length())));
+        data.insert(data.end(), reason.begin(), reason.begin() + std::min(static_cast<size_t>(255), reason.length()));
+    }
+
+    return data;
+}
+
+void PacketSerializer::parseVersionAckPayload(const std::vector<uint8_t> &payload, uint8_t &agreedVersion, std::string &serverVersion, std::string &platform, bool &rejected, std::string &reason)
+{
+    // Minimum size check: flags(1) + agreedVersion(1) + min strings
+    if (payload.size() < 3)
+    {
+        spdlog::error("Version ack payload too short");
+        return;
+    }
+
+    size_t offset = 0;
+
+    // Flags byte
+    uint8_t flags = readUint8(payload, offset);
+    rejected = (flags & 0x01) != 0;
+    bool hasReason = (flags & 0x02) != 0;
+
+    // Agreed version
+    if (offset >= payload.size())
+    {
+        spdlog::error("Version ack payload buffer overflow reading agreed version");
+        return;
+    }
+    agreedVersion = readUint8(payload, offset);
+
+    // Server version (string with length prefix)
+    if (offset >= payload.size())
+    {
+        spdlog::error("Version ack payload buffer overflow reading server version length");
+        return;
+    }
+    uint8_t serverVersionLen = readUint8(payload, offset);
+
+    if (offset + serverVersionLen > payload.size())
+    {
+        spdlog::error("Version ack payload buffer overflow reading server version");
+        return;
+    }
+
+    serverVersion = std::string(payload.begin() + offset, payload.begin() + offset + serverVersionLen);
+    offset += serverVersionLen;
+
+    // Platform (string with length prefix)
+    if (offset >= payload.size())
+    {
+        spdlog::error("Version ack payload buffer overflow reading platform length");
+        return;
+    }
+    uint8_t platformLen = readUint8(payload, offset);
+
+    if (offset + platformLen > payload.size())
+    {
+        spdlog::error("Version ack payload buffer overflow reading platform");
+        return;
+    }
+
+    platform = std::string(payload.begin() + offset, payload.begin() + offset + platformLen);
+    offset += platformLen;
+
+    // Reason (if present)
+    reason.clear();
+    if (hasReason)
+    {
+        if (offset >= payload.size())
+        {
+            spdlog::error("Version ack payload buffer overflow reading reason length");
+            return;
+        }
+        uint8_t reasonLen = readUint8(payload, offset);
+
+        if (offset + reasonLen > payload.size())
+        {
+            spdlog::error("Version ack payload buffer overflow reading reason");
+            return;
+        }
+
+        reason = std::string(payload.begin() + offset, payload.begin() + offset + reasonLen);
+    }
+}
+
 } // namespace bitchat