Revert "Mesh gossip (#381)" (#394)

This reverts commit 0969c0641e.
2026-07-25 10:25:19 +00:00 · 2025-09-08 15:15:54 +02:00
parent 0969c0641e
commit c1e56188d6
11 changed files with 38 additions and 621 deletions
@@ -247,16 +247,6 @@ class BluetoothConnectionManager(
            serverManager.getCharacteristic()
        )
    }
-
-    fun sendToPeer(peerID: String, routed: RoutedPacket): Boolean {
-        if (!isActive) return false
-        return packetBroadcaster.sendToPeer(
-            peerID,
-            routed,
-            serverManager.getGattServer(),
-            serverManager.getCharacteristic()
-        )
-    }
    

    // Expose role controls for debug UI
@@ -408,10 +408,6 @@ class BluetoothMeshService(private val context: Context) {
            override fun relayPacket(routed: RoutedPacket) {
                connectionManager.broadcastPacket(routed)
            }
-
-            override fun sendToPeer(peerID: String, routed: RoutedPacket): Boolean {
-                return connectionManager.sendToPeer(peerID, routed)
-            }
        }
        
        // BluetoothConnectionManager delegates
@@ -692,25 +688,11 @@ class BluetoothMeshService(private val context: Context) {
            
            // Create iOS-compatible IdentityAnnouncement with TLV encoding
            val announcement = IdentityAnnouncement(nickname, staticKey, signingKey)
-            var tlvPayload = announcement.encode()
+            val tlvPayload = announcement.encode()
            if (tlvPayload == null) {
                Log.e(TAG, "Failed to encode announcement as TLV")
                return@launch
            }
-
-            // Append gossip TLV containing up to 10 direct neighbors (compact IDs)
-            try {
-                val directPeers = getDirectPeerIDsForGossip()
-                if (directPeers.isNotEmpty()) {
-                    val gossip = com.bitchat.android.services.meshgraph.GossipTLV.encodeNeighbors(directPeers)
-                    tlvPayload = tlvPayload + gossip
-                }
-                // Always update our own node in the mesh graph with the neighbor list we used
-                try {
-                    com.bitchat.android.services.meshgraph.MeshGraphService.getInstance()
-                        .updateFromAnnouncement(myPeerID, nickname, directPeers, System.currentTimeMillis().toULong())
-                } catch (_: Exception) { }
-            } catch (_: Exception) { }
            
            val announcePacket = BitchatPacket(
                type = MessageType.ANNOUNCE.value,
@@ -753,25 +735,11 @@ class BluetoothMeshService(private val context: Context) {
        
        // Create iOS-compatible IdentityAnnouncement with TLV encoding
        val announcement = IdentityAnnouncement(nickname, staticKey, signingKey)
-        var tlvPayload = announcement.encode()
+        val tlvPayload = announcement.encode()
        if (tlvPayload == null) {
            Log.e(TAG, "Failed to encode peer announcement as TLV")
            return
        }
-
-        // Append gossip TLV containing up to 10 direct neighbors (compact IDs)
-        try {
-            val directPeers = getDirectPeerIDsForGossip()
-            if (directPeers.isNotEmpty()) {
-                val gossip = com.bitchat.android.services.meshgraph.GossipTLV.encodeNeighbors(directPeers)
-                tlvPayload = tlvPayload + gossip
-            }
-            // Always update our own node in the mesh graph with the neighbor list we used
-            try {
-                com.bitchat.android.services.meshgraph.MeshGraphService.getInstance()
-                    .updateFromAnnouncement(myPeerID, nickname, directPeers, System.currentTimeMillis().toULong())
-            } catch (_: Exception) { }
-        } catch (_: Exception) { }
        
        val packet = BitchatPacket(
            type = MessageType.ANNOUNCE.value,
@@ -790,20 +758,6 @@ class BluetoothMeshService(private val context: Context) {
        Log.d(TAG, "Sent iOS-compatible signed TLV peer announce to $peerID (${tlvPayload.size} bytes)")
    }

-    /**
-     * Collect up to 10 direct neighbors for gossip TLV.
-     */
-    private fun getDirectPeerIDsForGossip(): List<String> {
-        return try {
-            // Prefer verified peers that are currently marked as direct
-            val verified = peerManager.getVerifiedPeers()
-            val direct = verified.filter { it.value.isDirectConnection }.keys.toList()
-            direct.take(10)
-        } catch (_: Exception) {
-            emptyList()
-        }
-    }
-
    /**
     * Send leave announcement
     */
@@ -985,37 +939,21 @@ class BluetoothMeshService(private val context: Context) {
     */
    private fun signPacketBeforeBroadcast(packet: BitchatPacket): BitchatPacket {
        return try {
-            // Optionally compute and attach a source route for addressed packets
-            val withRoute = try {
-                val rec = packet.recipientID
-                if (rec != null && !rec.contentEquals(SpecialRecipients.BROADCAST)) {
-                    val dest = rec.joinToString("") { b -> "%02x".format(b) }
-                    val path = com.bitchat.android.services.meshgraph.RoutePlanner.shortestPath(myPeerID, dest)
-                    if (path != null && path.size >= 3) {
-                        // Exclude first (sender) and last (recipient); only intermediates
-                        val intermediates = path.subList(1, path.size - 1)
-                        val hopsBytes = intermediates.map { hexStringToByteArray(it) }
-                        Log.d(TAG, "✅ Signed packet type ${packet.type} (route ${hopsBytes.size} hops: $intermediates)")
-                        packet.copy(route = hopsBytes)
-                    } else packet.copy(route = null)
-                } else packet
-            } catch (_: Exception) { packet }
-
            // Get the canonical packet data for signing (without signature)
-            val packetDataForSigning = withRoute.toBinaryDataForSigning()
+            val packetDataForSigning = packet.toBinaryDataForSigning()
            if (packetDataForSigning == null) {
                Log.w(TAG, "Failed to encode packet type ${packet.type} for signing, sending unsigned")
-                return withRoute
+                return packet
            }
            
            // Sign the packet data using our signing key
            val signature = encryptionService.signData(packetDataForSigning)
            if (signature != null) {
                Log.d(TAG, "✅ Signed packet type ${packet.type} (signature ${signature.size} bytes)")
-                withRoute.copy(signature = signature)
+                packet.copy(signature = signature)
            } else {
                Log.w(TAG, "Failed to sign packet type ${packet.type}, sending unsigned")
-                withRoute
+                packet
            }
        } catch (e: Exception) {
            Log.w(TAG, "Error signing packet type ${packet.type}: ${e.message}, sending unsigned")
@@ -159,46 +159,6 @@ class BluetoothPacketBroadcaster(
            }
        }
    }
-
-    /**
-     * Targeted send to a specific peer (by peerID) if directly connected.
-     * Returns true if sent to at least one matching connection.
-     */
-    fun sendToPeer(
-        targetPeerID: String,
-        routed: RoutedPacket,
-        gattServer: BluetoothGattServer?,
-        characteristic: BluetoothGattCharacteristic?
-    ): Boolean {
-        val packet = routed.packet
-        val data = packet.toBinaryData() ?: return false
-        val typeName = MessageType.fromValue(packet.type)?.name ?: packet.type.toString()
-        val senderPeerID = routed.peerID ?: packet.senderID.toHexString()
-        val incomingAddr = routed.relayAddress
-        val incomingPeer = incomingAddr?.let { connectionTracker.addressPeerMap[it] }
-        val senderNick = senderPeerID.let { pid -> nicknameResolver?.invoke(pid) }
-
-        // Try server-side connections first
-        val targetDevice = connectionTracker.getSubscribedDevices()
-            .firstOrNull { connectionTracker.addressPeerMap[it.address] == targetPeerID }
-        if (targetDevice != null) {
-            if (notifyDevice(targetDevice, data, gattServer, characteristic)) {
-                logPacketRelay(typeName, senderPeerID, senderNick, incomingPeer, incomingAddr, targetPeerID, targetDevice.address, packet.ttl)
-                return true
-            }
-        }
-
-        // Try client-side connections next
-        val targetConn = connectionTracker.getConnectedDevices().values
-            .firstOrNull { connectionTracker.addressPeerMap[it.device.address] == targetPeerID }
-        if (targetConn != null) {
-            if (writeToDeviceConn(targetConn, data)) {
-                logPacketRelay(typeName, senderPeerID, senderNick, incomingPeer, incomingAddr, targetPeerID, targetConn.device.address, packet.ttl)
-                return true
-            }
-        }
-        return false
-    }
    
    /**
     * Internal broadcast implementation - runs in serialized actor context
@@ -240,13 +240,6 @@ class MessageHandler(private val myPeerID: String) {
            previousPeerID = null
        )
        
-        // Update mesh graph from gossip neighbors (only if TLV present)
-        try {
-            val neighborsOrNull = com.bitchat.android.services.meshgraph.GossipTLV.decodeNeighborsFromAnnouncementPayload(packet.payload)
-            com.bitchat.android.services.meshgraph.MeshGraphService.getInstance()
-                .updateFromAnnouncement(peerID, nickname, neighborsOrNull, packet.timestamp)
-        } catch (_: Exception) { }
-
        Log.d(TAG, "✅ Processed verified TLV announce: stored identity for $peerID")
        return isFirstAnnounce
    }
@@ -112,9 +112,6 @@ class PacketProcessor(private val myPeerID: String) {
            override fun broadcastPacket(routed: RoutedPacket) {
                delegate?.relayPacket(routed)
            }
-            override fun sendToPeer(peerID: String, routed: RoutedPacket): Boolean {
-                return delegate?.sendToPeer(peerID, routed) ?: false
-            }
        }
    }
    
@@ -313,5 +310,4 @@ interface PacketProcessorDelegate {
    fun sendAnnouncementToPeer(peerID: String)
    fun sendCachedMessages(peerID: String)
    fun relayPacket(routed: RoutedPacket)
-    fun sendToPeer(peerID: String, routed: RoutedPacket): Boolean
 }
@@ -65,35 +65,9 @@ class PacketRelayManager(private val myPeerID: String) {
        val relayPacket = packet.copy(ttl = (packet.ttl - 1u).toUByte())
        Log.d(TAG, "Decremented TTL from ${'$'}{packet.ttl} to ${'$'}{relayPacket.ttl}")
        
-        // Source-based routing: if route is set and includes us, try targeted next-hop forwarding
-        val route = relayPacket.route
-        if (!route.isNullOrEmpty()) {
-            val myIdBytes = hexStringToPeerBytes(myPeerID)
-            val index = route.indexOfFirst { it.contentEquals(myIdBytes) }
-            if (index >= 0) {
-                val nextHopIdHex: String? = run {
-                    val nextIndex = index + 1
-                    if (nextIndex < route.size) {
-                        route[nextIndex].toHexString()
-                    } else {
-                        // We are the last intermediate; try final recipient as next hop
-                        relayPacket.recipientID?.toHexString()
-                    }
-                }
-                if (nextHopIdHex != null) {
-                    val success = try { delegate?.sendToPeer(nextHopIdHex, RoutedPacket(relayPacket, peerID, routed.relayAddress)) } catch (_: Exception) { false } ?: false
-                    if (success) {
-                        Log.i(TAG, "📦 Source-route relay: ${myPeerID.take(8)} -> ${nextHopIdHex.take(8)} (type ${'$'}{packet.type}, TTL ${'$'}{relayPacket.ttl})")
-                        return
-                    } else {
-                        Log.w(TAG, "Source-route next hop ${nextHopIdHex.take(8)} not directly connected; falling back to broadcast")
-                    }
-                }
-            }
-        }
-
        // Apply relay logic based on packet type and debug switch
        val shouldRelay = isRelayEnabled() && shouldRelayPacket(relayPacket, peerID)
+        
        if (shouldRelay) {
            relayPacket(RoutedPacket(relayPacket, peerID, routed.relayAddress))
        } else {
@@ -232,17 +206,4 @@ interface PacketRelayManagerDelegate {
    
    // Packet operations
    fun broadcastPacket(routed: RoutedPacket)
-    fun sendToPeer(peerID: String, routed: RoutedPacket): Boolean
-}
-
-private fun hexStringToPeerBytes(hex: String): ByteArray {
-    val result = ByteArray(8)
-    var idx = 0
-    var out = 0
-    while (idx + 1 < hex.length && out < 8) {
-        val b = hex.substring(idx, idx + 2).toIntOrNull(16)?.toByte() ?: 0
-        result[out++] = b
-        idx += 2
-    }
-    return result
 }