mirror of
https://github.com/permissionlesstech/bitchat.git
synced 2026-07-26 16:25:23 +00:00
[codex] Extract BLE service policy helpers (#1321)
* Extract BLE service policy helpers * Stabilize image media transfer test --------- Co-authored-by: jack <jackjackbits@users.noreply.github.com>
This commit is contained in:
jack
@@ -0,0 +1,76 @@
|
||||
import BitFoundation
|
||||
import Foundation
|
||||
|
||||
enum BLEIngressPacketGuard {
|
||||
enum Rejection: Error, Equatable {
|
||||
case selfLoopback(packetType: UInt8)
|
||||
case directSenderMismatch(boundPeerID: PeerID, claimedSenderID: PeerID)
|
||||
case invalidRSR(peerID: PeerID)
|
||||
case timestampSkew(peerID: PeerID, skewMs: UInt64, maxSkewMs: UInt64)
|
||||
}
|
||||
|
||||
static func evaluate(
|
||||
packet: BitchatPacket,
|
||||
claimedSenderID: PeerID,
|
||||
boundPeerID: PeerID?,
|
||||
localPeerID: PeerID,
|
||||
directAnnounceTTL: UInt8,
|
||||
nowMs: UInt64 = UInt64(Date().timeIntervalSince1970 * 1000),
|
||||
maxTimestampSkewMs: UInt64 = 120_000,
|
||||
isValidSyncResponse: (PeerID) -> Bool
|
||||
) -> Result<BLEIngressPacketContext, Rejection> {
|
||||
let contextResult = BLEIngressLinkRegistry.packetContext(
|
||||
for: packet,
|
||||
claimedSenderID: claimedSenderID,
|
||||
boundPeerID: boundPeerID,
|
||||
localPeerID: localPeerID,
|
||||
directAnnounceTTL: directAnnounceTTL
|
||||
)
|
||||
|
||||
let context: BLEIngressPacketContext
|
||||
switch contextResult {
|
||||
case .success(let acceptedContext):
|
||||
context = acceptedContext
|
||||
case .failure(.selfLoopback(let packetType)):
|
||||
return .failure(.selfLoopback(packetType: packetType))
|
||||
case .failure(.directSenderMismatch(let boundPeerID, let claimedSenderID)):
|
||||
return .failure(.directSenderMismatch(boundPeerID: boundPeerID, claimedSenderID: claimedSenderID))
|
||||
}
|
||||
|
||||
switch validatePayload(
|
||||
packet,
|
||||
from: context.validationPeerID,
|
||||
nowMs: nowMs,
|
||||
maxTimestampSkewMs: maxTimestampSkewMs,
|
||||
isValidSyncResponse: isValidSyncResponse
|
||||
) {
|
||||
case .success:
|
||||
return .success(context)
|
||||
case .failure(let rejection):
|
||||
return .failure(rejection)
|
||||
}
|
||||
}
|
||||
|
||||
static func validatePayload(
|
||||
_ packet: BitchatPacket,
|
||||
from peerID: PeerID,
|
||||
nowMs: UInt64 = UInt64(Date().timeIntervalSince1970 * 1000),
|
||||
maxTimestampSkewMs: UInt64 = 120_000,
|
||||
isValidSyncResponse: (PeerID) -> Bool
|
||||
) -> Result<Void, Rejection> {
|
||||
if packet.isRSR {
|
||||
guard isValidSyncResponse(peerID) else {
|
||||
return .failure(.invalidRSR(peerID: peerID))
|
||||
}
|
||||
return .success(())
|
||||
}
|
||||
|
||||
let packetTime = packet.timestamp
|
||||
let skew = packetTime > nowMs ? packetTime - nowMs : nowMs - packetTime
|
||||
guard skew <= maxTimestampSkewMs else {
|
||||
return .failure(.timestampSkew(peerID: peerID, skewMs: skew, maxSkewMs: maxTimestampSkewMs))
|
||||
}
|
||||
|
||||
return .success(())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
import Foundation
|
||||
|
||||
final class BLELogRateLimiter {
|
||||
private let defaultMinimumInterval: TimeInterval
|
||||
private let queue = DispatchQueue(label: "chat.bitchat.ble.log-rate-limiter")
|
||||
private var lastLogTimeByKey: [String: Date] = [:]
|
||||
|
||||
init(defaultMinimumInterval: TimeInterval) {
|
||||
self.defaultMinimumInterval = defaultMinimumInterval
|
||||
}
|
||||
|
||||
func shouldLog(
|
||||
key: String,
|
||||
now: Date = Date(),
|
||||
minimumInterval: TimeInterval? = nil
|
||||
) -> Bool {
|
||||
queue.sync {
|
||||
let interval = minimumInterval ?? defaultMinimumInterval
|
||||
if let lastLogTime = lastLogTimeByKey[key],
|
||||
now.timeIntervalSince(lastLogTime) < interval {
|
||||
return false
|
||||
}
|
||||
lastLogTimeByKey[key] = now
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
func removeAll() {
|
||||
queue.sync {
|
||||
lastLogTimeByKey.removeAll()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,137 @@
|
||||
import BitFoundation
|
||||
import Foundation
|
||||
|
||||
struct BLEOutboundFragmentPlan {
|
||||
let fragmentPackets: [BitchatPacket]
|
||||
let fragmentVersion: UInt8
|
||||
let chunkSize: Int
|
||||
let spacingMs: Int
|
||||
|
||||
var totalFragments: Int {
|
||||
fragmentPackets.count
|
||||
}
|
||||
|
||||
var shouldPauseScanning: Bool {
|
||||
totalFragments > 4
|
||||
}
|
||||
}
|
||||
|
||||
enum BLEOutboundFragmentPlanner {
|
||||
private static let minimumChunkSize = 64
|
||||
private static let fragmentIDLength = 8
|
||||
|
||||
static func makePlan(
|
||||
for request: BLEOutboundFragmentTransferRequest,
|
||||
defaultChunkSize: Int,
|
||||
bleMaxMTU: Int,
|
||||
fragmentID: Data = randomFragmentID()
|
||||
) -> BLEOutboundFragmentPlan? {
|
||||
guard fragmentID.count == fragmentIDLength,
|
||||
let fullData = request.packet.toBinaryData(padding: request.pad) else {
|
||||
return nil
|
||||
}
|
||||
|
||||
let sizing = sizingPolicy(
|
||||
for: request.packet,
|
||||
requestedMaxChunk: request.maxChunk,
|
||||
defaultChunkSize: defaultChunkSize,
|
||||
bleMaxMTU: bleMaxMTU
|
||||
)
|
||||
|
||||
let chunks = stride(from: 0, to: fullData.count, by: sizing.chunkSize).map { offset in
|
||||
Data(fullData[offset..<min(offset + sizing.chunkSize, fullData.count)])
|
||||
}
|
||||
|
||||
guard !chunks.isEmpty else { return nil }
|
||||
|
||||
let fragmentRecipient: Data? = {
|
||||
if let directedPeer = request.directedPeer {
|
||||
return Data(hexString: directedPeer.id)
|
||||
}
|
||||
return request.packet.recipientID
|
||||
}()
|
||||
|
||||
let fragmentPackets = chunks.enumerated().map { index, chunk in
|
||||
makeFragmentPacket(
|
||||
original: request.packet,
|
||||
fragmentID: fragmentID,
|
||||
index: index,
|
||||
total: chunks.count,
|
||||
fragmentData: chunk,
|
||||
fragmentRecipient: fragmentRecipient,
|
||||
fragmentVersion: sizing.fragmentVersion
|
||||
)
|
||||
}
|
||||
|
||||
return BLEOutboundFragmentPlan(
|
||||
fragmentPackets: fragmentPackets,
|
||||
fragmentVersion: sizing.fragmentVersion,
|
||||
chunkSize: sizing.chunkSize,
|
||||
spacingMs: spacingMs(for: request)
|
||||
)
|
||||
}
|
||||
|
||||
private static func sizingPolicy(
|
||||
for packet: BitchatPacket,
|
||||
requestedMaxChunk: Int?,
|
||||
defaultChunkSize: Int,
|
||||
bleMaxMTU: Int
|
||||
) -> (fragmentVersion: UInt8, chunkSize: Int) {
|
||||
var fragmentVersion: UInt8 = 1
|
||||
var calculatedChunk = defaultChunkSize
|
||||
|
||||
if let route = packet.route, !route.isEmpty {
|
||||
fragmentVersion = 2
|
||||
let routeSize = 1 + (route.count * 8)
|
||||
let overhead = 16 + 8 + 8 + routeSize + 13 + 16
|
||||
calculatedChunk = max(minimumChunkSize, bleMaxMTU - overhead)
|
||||
}
|
||||
|
||||
return (
|
||||
fragmentVersion: fragmentVersion,
|
||||
chunkSize: max(minimumChunkSize, requestedMaxChunk ?? calculatedChunk)
|
||||
)
|
||||
}
|
||||
|
||||
private static func makeFragmentPacket(
|
||||
original packet: BitchatPacket,
|
||||
fragmentID: Data,
|
||||
index: Int,
|
||||
total: Int,
|
||||
fragmentData: Data,
|
||||
fragmentRecipient: Data?,
|
||||
fragmentVersion: UInt8
|
||||
) -> BitchatPacket {
|
||||
var payload = Data()
|
||||
payload.append(fragmentID)
|
||||
payload.append(contentsOf: withUnsafeBytes(of: UInt16(index).bigEndian) { Data($0) })
|
||||
payload.append(contentsOf: withUnsafeBytes(of: UInt16(total).bigEndian) { Data($0) })
|
||||
payload.append(packet.type)
|
||||
payload.append(fragmentData)
|
||||
|
||||
return BitchatPacket(
|
||||
type: MessageType.fragment.rawValue,
|
||||
senderID: packet.senderID,
|
||||
recipientID: fragmentRecipient,
|
||||
timestamp: packet.timestamp,
|
||||
payload: payload,
|
||||
signature: nil,
|
||||
ttl: packet.ttl,
|
||||
version: fragmentVersion,
|
||||
route: packet.route,
|
||||
isRSR: packet.isRSR
|
||||
)
|
||||
}
|
||||
|
||||
private static func spacingMs(for request: BLEOutboundFragmentTransferRequest) -> Int {
|
||||
if request.directedPeer != nil || request.packet.recipientID != nil {
|
||||
return TransportConfig.bleFragmentSpacingDirectedMs
|
||||
}
|
||||
|
||||
return TransportConfig.bleFragmentSpacingMs
|
||||
}
|
||||
|
||||
private static func randomFragmentID() -> Data {
|
||||
Data((0..<fragmentIDLength).map { _ in UInt8.random(in: 0...255) })
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,211 @@
|
||||
import BitFoundation
|
||||
import Foundation
|
||||
|
||||
struct BLEPeerInfo: Equatable {
|
||||
let peerID: PeerID
|
||||
var nickname: String
|
||||
var isConnected: Bool
|
||||
var noisePublicKey: Data?
|
||||
var signingPublicKey: Data?
|
||||
var isVerifiedNickname: Bool
|
||||
var lastSeen: Date
|
||||
}
|
||||
|
||||
struct BLEPeerAnnounceUpdate: Equatable {
|
||||
let isNewPeer: Bool
|
||||
let wasDisconnected: Bool
|
||||
let previousNickname: String?
|
||||
}
|
||||
|
||||
struct BLEPeerLinkPresence: Equatable {
|
||||
var hasPeripheral: Bool
|
||||
var hasCentral: Bool
|
||||
}
|
||||
|
||||
struct BLERemovedPeer: Equatable {
|
||||
let peerID: PeerID
|
||||
let nickname: String
|
||||
}
|
||||
|
||||
struct BLEPeerConnectivityChanges: Equatable {
|
||||
var disconnectedPeerIDs: [PeerID] = []
|
||||
var removedPeers: [BLERemovedPeer] = []
|
||||
}
|
||||
|
||||
struct BLEPeerRegistry {
|
||||
private var peers: [PeerID: BLEPeerInfo] = [:]
|
||||
|
||||
var isEmpty: Bool {
|
||||
peers.isEmpty
|
||||
}
|
||||
|
||||
var count: Int {
|
||||
peers.count
|
||||
}
|
||||
|
||||
var peerIDs: [PeerID] {
|
||||
Array(peers.keys)
|
||||
}
|
||||
|
||||
var connectedCount: Int {
|
||||
peers.values.filter(\.isConnected).count
|
||||
}
|
||||
|
||||
var connectedPeerIDs: [PeerID] {
|
||||
peers.values.compactMap { $0.isConnected ? $0.peerID : nil }
|
||||
}
|
||||
|
||||
var connectedRoutingData: [Data] {
|
||||
peers.values.filter(\.isConnected).compactMap { $0.peerID.routingData }
|
||||
}
|
||||
|
||||
var snapshotByID: [PeerID: BLEPeerInfo] {
|
||||
peers
|
||||
}
|
||||
|
||||
mutating func removeAll() {
|
||||
peers.removeAll()
|
||||
}
|
||||
|
||||
func info(for peerID: PeerID) -> BLEPeerInfo? {
|
||||
peers[peerID]
|
||||
}
|
||||
|
||||
mutating func upsert(_ info: BLEPeerInfo) {
|
||||
peers[info.peerID] = info
|
||||
}
|
||||
|
||||
@discardableResult
|
||||
mutating func remove(_ peerID: PeerID) -> BLEPeerInfo? {
|
||||
peers.removeValue(forKey: peerID)
|
||||
}
|
||||
|
||||
func isConnected(_ peerID: PeerID) -> Bool {
|
||||
peers[peerID.toShort()]?.isConnected ?? false
|
||||
}
|
||||
|
||||
func isReachable(_ peerID: PeerID, now: Date) -> Bool {
|
||||
let shortID = peerID.toShort()
|
||||
let meshAttached = connectedCount > 0
|
||||
guard let info = peers[shortID] else { return false }
|
||||
if info.isConnected { return true }
|
||||
guard meshAttached else { return false }
|
||||
|
||||
let retention: TimeInterval = info.isVerifiedNickname
|
||||
? TransportConfig.bleReachabilityRetentionVerifiedSeconds
|
||||
: TransportConfig.bleReachabilityRetentionUnverifiedSeconds
|
||||
return now.timeIntervalSince(info.lastSeen) <= retention
|
||||
}
|
||||
|
||||
func nickname(for peerID: PeerID, connectedOnly: Bool) -> String? {
|
||||
guard let peer = peers[peerID] else { return nil }
|
||||
if connectedOnly && !peer.isConnected { return nil }
|
||||
return peer.nickname
|
||||
}
|
||||
|
||||
func fingerprint(for peerID: PeerID) -> String? {
|
||||
peers[peerID]?.noisePublicKey?.sha256Fingerprint()
|
||||
}
|
||||
|
||||
func displayNicknames(selfNickname: String) -> [PeerID: String] {
|
||||
let connected = peers.filter { $0.value.isConnected }
|
||||
let tuples = connected.map { ($0.key, $0.value.nickname, true) }
|
||||
return PeerDisplayNameResolver.resolve(tuples, selfNickname: selfNickname)
|
||||
}
|
||||
|
||||
func transportSnapshots(selfNickname: String) -> [TransportPeerSnapshot] {
|
||||
let snapshot = Array(peers.values)
|
||||
let resolvedNames = PeerDisplayNameResolver.resolve(
|
||||
snapshot.map { ($0.peerID, $0.nickname, $0.isConnected) },
|
||||
selfNickname: selfNickname
|
||||
)
|
||||
return snapshot.map { info in
|
||||
TransportPeerSnapshot(
|
||||
peerID: info.peerID,
|
||||
nickname: resolvedNames[info.peerID] ?? info.nickname,
|
||||
isConnected: info.isConnected,
|
||||
noisePublicKey: info.noisePublicKey,
|
||||
lastSeen: info.lastSeen
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
func collisionResolvedNickname(for peerID: PeerID, selfNickname: String) -> String? {
|
||||
guard let info = peers[peerID], info.isVerifiedNickname else { return nil }
|
||||
let hasCollision = peers.values.contains {
|
||||
$0.isConnected && $0.nickname == info.nickname && $0.peerID != peerID
|
||||
} || selfNickname == info.nickname
|
||||
return hasCollision ? info.nickname + "#" + String(peerID.id.prefix(4)) : info.nickname
|
||||
}
|
||||
|
||||
mutating func markDisconnected(_ peerID: PeerID) {
|
||||
guard var info = peers[peerID] else { return }
|
||||
info.isConnected = false
|
||||
peers[peerID] = info
|
||||
}
|
||||
|
||||
mutating func updateLastSeen(_ peerID: PeerID, at date: Date) {
|
||||
guard var peer = peers[peerID] else { return }
|
||||
peer.lastSeen = date
|
||||
peers[peerID] = peer
|
||||
}
|
||||
|
||||
mutating func upsertVerifiedAnnounce(
|
||||
peerID: PeerID,
|
||||
nickname: String,
|
||||
noisePublicKey: Data,
|
||||
signingPublicKey: Data?,
|
||||
isConnected: Bool,
|
||||
now: Date
|
||||
) -> BLEPeerAnnounceUpdate {
|
||||
let existing = peers[peerID]
|
||||
let update = BLEPeerAnnounceUpdate(
|
||||
isNewPeer: existing == nil,
|
||||
wasDisconnected: existing?.isConnected == false,
|
||||
previousNickname: existing?.nickname
|
||||
)
|
||||
|
||||
peers[peerID] = BLEPeerInfo(
|
||||
peerID: existing?.peerID ?? peerID,
|
||||
nickname: nickname,
|
||||
isConnected: isConnected,
|
||||
noisePublicKey: noisePublicKey,
|
||||
signingPublicKey: signingPublicKey,
|
||||
isVerifiedNickname: true,
|
||||
lastSeen: now
|
||||
)
|
||||
|
||||
return update
|
||||
}
|
||||
|
||||
mutating func reconcileConnectivity(
|
||||
now: Date,
|
||||
linkStates: [PeerID: BLEPeerLinkPresence]
|
||||
) -> BLEPeerConnectivityChanges {
|
||||
var changes = BLEPeerConnectivityChanges()
|
||||
|
||||
for (peerID, peer) in Array(peers) {
|
||||
let age = now.timeIntervalSince(peer.lastSeen)
|
||||
let retention: TimeInterval = peer.isVerifiedNickname
|
||||
? TransportConfig.bleReachabilityRetentionVerifiedSeconds
|
||||
: TransportConfig.bleReachabilityRetentionUnverifiedSeconds
|
||||
|
||||
if peer.isConnected && age > TransportConfig.blePeerInactivityTimeoutSeconds {
|
||||
let state = linkStates[peerID] ?? BLEPeerLinkPresence(hasPeripheral: false, hasCentral: false)
|
||||
if !state.hasPeripheral && !state.hasCentral {
|
||||
var updated = peer
|
||||
updated.isConnected = false
|
||||
peers[peerID] = updated
|
||||
changes.disconnectedPeerIDs.append(peerID)
|
||||
}
|
||||
}
|
||||
|
||||
if !peer.isConnected && age > retention {
|
||||
peers.removeValue(forKey: peerID)
|
||||
changes.removedPeers.append(BLERemovedPeer(peerID: peerID, nickname: peer.nickname))
|
||||
}
|
||||
}
|
||||
|
||||
return changes
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
import BitFoundation
|
||||
import Foundation
|
||||
|
||||
enum BLEPeerSenderDisplayName {
|
||||
static func resolveKnownPeer(
|
||||
peerID: PeerID,
|
||||
localPeerID: PeerID,
|
||||
localNickname: String,
|
||||
peers: [PeerID: BLEPeerInfo],
|
||||
allowConnectedUnverified: Bool
|
||||
) -> String? {
|
||||
if peerID == localPeerID {
|
||||
return localNickname
|
||||
}
|
||||
|
||||
guard let info = peers[peerID] else { return nil }
|
||||
|
||||
if info.isVerifiedNickname {
|
||||
return collisionResolvedName(
|
||||
displayName: info.nickname,
|
||||
collisionNickname: info.nickname,
|
||||
peerID: peerID,
|
||||
localNickname: localNickname,
|
||||
peers: peers
|
||||
)
|
||||
}
|
||||
|
||||
if allowConnectedUnverified, info.isConnected {
|
||||
let displayName = info.nickname.isEmpty ? anonymousNickname(for: peerID) : info.nickname
|
||||
return collisionResolvedName(
|
||||
displayName: displayName,
|
||||
collisionNickname: info.nickname,
|
||||
peerID: peerID,
|
||||
localNickname: localNickname,
|
||||
peers: peers
|
||||
)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
static func anonymousNickname(for peerID: PeerID) -> String {
|
||||
"anon" + String(peerID.id.prefix(4))
|
||||
}
|
||||
|
||||
private static func collisionResolvedName(
|
||||
displayName: String,
|
||||
collisionNickname: String,
|
||||
peerID: PeerID,
|
||||
localNickname: String,
|
||||
peers: [PeerID: BLEPeerInfo]
|
||||
) -> String {
|
||||
let hasCollision = peers.values.contains {
|
||||
$0.isConnected && $0.nickname == collisionNickname && $0.peerID != peerID
|
||||
} || localNickname == collisionNickname
|
||||
|
||||
guard hasCollision else { return displayName }
|
||||
return displayName + "#" + String(peerID.id.prefix(4))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
import BitFoundation
|
||||
import Foundation
|
||||
|
||||
struct BLEReceivedPacketContext: Equatable {
|
||||
let senderID: PeerID
|
||||
let messageID: String
|
||||
let messageType: MessageType?
|
||||
let shouldDeduplicate: Bool
|
||||
let logsHandlingDetails: Bool
|
||||
}
|
||||
|
||||
struct BLEReceivePipeline {
|
||||
static func context(for packet: BitchatPacket, localPeerID: PeerID) -> BLEReceivedPacketContext {
|
||||
let senderID = PeerID(hexData: packet.senderID)
|
||||
let messageID = "\(senderID)-\(packet.timestamp)-\(packet.type)"
|
||||
let messageType = MessageType(rawValue: packet.type)
|
||||
let allowSelfSyncReplay = packet.ttl == 0 && senderID == localPeerID
|
||||
let shouldDeduplicate = messageType != .fragment && !allowSelfSyncReplay
|
||||
|
||||
return BLEReceivedPacketContext(
|
||||
senderID: senderID,
|
||||
messageID: messageID,
|
||||
messageType: messageType,
|
||||
shouldDeduplicate: shouldDeduplicate,
|
||||
logsHandlingDetails: messageType != .announce
|
||||
)
|
||||
}
|
||||
|
||||
static func shouldCancelScheduledRelayForDuplicate(connectedPeerCount: Int) -> Bool {
|
||||
connectedPeerCount > 2
|
||||
}
|
||||
|
||||
static func relayDecision(
|
||||
for packet: BitchatPacket,
|
||||
senderID: PeerID,
|
||||
localPeerID: PeerID,
|
||||
degree: Int,
|
||||
highDegreeThreshold: Int
|
||||
) -> RelayDecision {
|
||||
RelayController.decide(
|
||||
ttl: packet.ttl,
|
||||
senderIsSelf: senderID == localPeerID,
|
||||
recipientIsSelf: PeerID(hexData: packet.recipientID) == localPeerID,
|
||||
isEncrypted: packet.type == MessageType.noiseEncrypted.rawValue,
|
||||
isDirectedEncrypted: packet.type == MessageType.noiseEncrypted.rawValue && packet.recipientID != nil,
|
||||
isFragment: packet.type == MessageType.fragment.rawValue,
|
||||
isDirectedFragment: packet.type == MessageType.fragment.rawValue && packet.recipientID != nil,
|
||||
isHandshake: packet.type == MessageType.noiseHandshake.rawValue,
|
||||
isAnnounce: packet.type == MessageType.announce.rawValue,
|
||||
degree: degree,
|
||||
highDegreeThreshold: highDegreeThreshold
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
struct BLERecentTrafficTracker: Equatable {
|
||||
private var packetTimestamps: [Date] = []
|
||||
|
||||
var count: Int {
|
||||
packetTimestamps.count
|
||||
}
|
||||
|
||||
mutating func removeAll() {
|
||||
packetTimestamps.removeAll()
|
||||
}
|
||||
|
||||
mutating func recordPacket(at now: Date) {
|
||||
packetTimestamps.append(now)
|
||||
prune(at: now)
|
||||
}
|
||||
|
||||
func hasTraffic(within seconds: TimeInterval, now: Date) -> Bool {
|
||||
let cutoff = now.addingTimeInterval(-seconds)
|
||||
return packetTimestamps.contains { $0 >= cutoff }
|
||||
}
|
||||
|
||||
private mutating func prune(at now: Date) {
|
||||
let cutoff = now.addingTimeInterval(-TransportConfig.bleRecentPacketWindowSeconds)
|
||||
if packetTimestamps.count > TransportConfig.bleRecentPacketWindowMaxCount {
|
||||
packetTimestamps.removeFirst(packetTimestamps.count - TransportConfig.bleRecentPacketWindowMaxCount)
|
||||
}
|
||||
packetTimestamps.removeAll { $0 < cutoff }
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,71 @@
|
||||
import Foundation
|
||||
|
||||
enum BLESubscriptionAnnounceDecision: Equatable {
|
||||
case allowed
|
||||
case rateLimited(backoffSeconds: TimeInterval, attemptCount: Int, suppressAnnounce: Bool)
|
||||
}
|
||||
|
||||
struct BLESubscriptionAnnounceLimiter {
|
||||
private struct State {
|
||||
var lastAnnounceTime: Date
|
||||
var attemptCount: Int
|
||||
var currentBackoffSeconds: TimeInterval
|
||||
}
|
||||
|
||||
private var states: [String: State] = [:]
|
||||
|
||||
var trackedCentralCount: Int {
|
||||
states.count
|
||||
}
|
||||
|
||||
mutating func removeAll() {
|
||||
states.removeAll()
|
||||
}
|
||||
|
||||
mutating func decision(for centralID: String, now: Date) -> BLESubscriptionAnnounceDecision {
|
||||
pruneStaleEntries(now: now)
|
||||
|
||||
guard let existing = states[centralID] else {
|
||||
recordAllowedAttempt(for: centralID, now: now)
|
||||
return .allowed
|
||||
}
|
||||
|
||||
let timeSinceLastAnnounce = now.timeIntervalSince(existing.lastAnnounceTime)
|
||||
guard timeSinceLastAnnounce < existing.currentBackoffSeconds else {
|
||||
recordAllowedAttempt(for: centralID, now: now)
|
||||
return .allowed
|
||||
}
|
||||
|
||||
let newAttemptCount = existing.attemptCount + 1
|
||||
let newBackoff = min(
|
||||
existing.currentBackoffSeconds * TransportConfig.bleSubscriptionRateLimitBackoffFactor,
|
||||
TransportConfig.bleSubscriptionRateLimitMaxBackoffSeconds
|
||||
)
|
||||
states[centralID] = State(
|
||||
lastAnnounceTime: now,
|
||||
attemptCount: newAttemptCount,
|
||||
currentBackoffSeconds: newBackoff
|
||||
)
|
||||
|
||||
return .rateLimited(
|
||||
backoffSeconds: existing.currentBackoffSeconds,
|
||||
attemptCount: existing.attemptCount,
|
||||
suppressAnnounce: newAttemptCount >= TransportConfig.bleSubscriptionRateLimitMaxAttempts
|
||||
)
|
||||
}
|
||||
|
||||
private mutating func recordAllowedAttempt(for centralID: String, now: Date) {
|
||||
states[centralID] = State(
|
||||
lastAnnounceTime: now,
|
||||
attemptCount: 1,
|
||||
currentBackoffSeconds: TransportConfig.bleSubscriptionRateLimitMinSeconds
|
||||
)
|
||||
}
|
||||
|
||||
private mutating func pruneStaleEntries(now: Date) {
|
||||
let windowSeconds = TransportConfig.bleSubscriptionRateLimitWindowSeconds
|
||||
states = states.filter { _, state in
|
||||
now.timeIntervalSince(state.lastAnnounceTime) < windowSeconds
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user