mirror of
https://github.com/permissionlesstech/bitchat-android.git
synced 2026-07-26 20:45:20 +00:00
callebtc
75cc4615c7
- Use Kotlin coroutine actors for per-peer packet processing - Each peer gets dedicated actor that processes packets sequentially - Eliminates race conditions in session management without complex locking - Single surgical change in PacketProcessor - minimal, maintainable - Leverages Kotlin's native concurrency primitives
74 lines
3.2 KiB
Plaintext
74 lines
3.2 KiB
Plaintext
**COMPLETED: Noise Handshake Step Counting Logic - Complete Rewrite**
|
|
|
|
**Problem Solved**: Eliminated the complex and error-prone manual step counting logic that was causing handshake failures.
|
|
|
|
**Root Issues with Old Approach**:
|
|
1. Manual `handshakeMessageCount` tracking was out of sync with actual Noise library state
|
|
2. Complex conditionals for step validation based on role and count
|
|
3. Mismatch between what the app thought the step was vs. what the Noise library expected
|
|
4. Artificial size validation that didn't match Noise library expectations
|
|
|
|
**New Clean Approach - Let the Noise Library Handle It**:
|
|
|
|
**1. Removed Manual Step Counting**:
|
|
- Deleted `handshakeMessageCount` variable entirely
|
|
- Removed `validateHandshakeMessageSize()` helper function
|
|
- Removed `getExpectedResponseSize()` helper function
|
|
- Eliminated complex step-based conditionals
|
|
|
|
**2. State-Driven Flow**:
|
|
```kotlin
|
|
fun processHandshakeMessage(message: ByteArray): ByteArray? {
|
|
// Let the Noise library validate message sizes and handle the flow
|
|
val payloadLength = handshakeStateLocal.readMessage(message, 0, message.size, payloadBuffer, 0)
|
|
|
|
// Check what ACTION the handshake state wants us to take next
|
|
val action = handshakeStateLocal.getAction()
|
|
|
|
return when (action) {
|
|
HandshakeState.WRITE_MESSAGE -> {
|
|
// Noise library says we need to send a response
|
|
val responseLength = handshakeStateLocal.writeMessage(responseBuffer, 0, ByteArray(0), 0, 0)
|
|
responseBuffer.copyOf(responseLength)
|
|
}
|
|
HandshakeState.SPLIT -> {
|
|
// Handshake complete
|
|
completeHandshake()
|
|
null
|
|
}
|
|
HandshakeState.FAILED -> {
|
|
throw Exception("Handshake failed - Noise library reported FAILED state")
|
|
}
|
|
HandshakeState.READ_MESSAGE -> {
|
|
// Waiting for next message
|
|
null
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
**3. Key Benefits**:
|
|
- **No more step counting errors**: Noise library internally tracks the handshake state
|
|
- **Automatic validation**: Library validates message sizes and formats
|
|
- **Cleaner code**: Eliminated 50+ lines of error-prone logic
|
|
- **Library-driven flow**: Actions are determined by the actual Noise protocol state
|
|
- **Better error handling**: Library provides precise error states
|
|
|
|
**4. Simplified Message Flow**:
|
|
- **Initiator**: `startHandshake()` → `writeMessage()` → action = READ_MESSAGE
|
|
- **Responder**: Receives message → `readMessage()` → action = WRITE_MESSAGE → `writeMessage()` → action = READ_MESSAGE
|
|
- **Both**: Final message → action = SPLIT → handshake complete
|
|
|
|
**Files Modified**:
|
|
- `/app/src/main/java/com/bitchat/android/noise/NoiseSession.kt` - Complete rewrite of handshake logic
|
|
|
|
**Removed Functions**:
|
|
- `validateHandshakeMessageSize()` - No longer needed
|
|
- `getExpectedResponseSize()` - No longer needed
|
|
- Manual `handshakeMessageCount` tracking - Eliminated
|
|
|
|
**Build Status**: ✅ Successful compilation with `./gradlew assembleDebug`
|
|
|
|
**Result**: The handshake logic is now much simpler, more reliable, and follows the Noise protocol library's intended usage pattern. The library itself handles all the complexity of step validation, message sizing, and flow control.
|
|
|