fix(bluetooth): actively reconnect paired HID receivers (2026.6.23.1-4240)

Author: RealWhyKnot

bridge/src/cdc/bt_status.rs

@@ -3,10 +3,12 @@ use anyhow::{bail, Result};
 use super::{
     BT_STATUS_FIXED_LEN, BT_STATUS_FLAG_CONNECTED, BT_STATUS_FLAG_SEND_REQUESTED,
     BT_STATUS_FLAG_STARTED, BT_STATUS_V1_FIXED_LEN, BT_STATUS_V1_VERSION, BT_STATUS_V2_FIXED_LEN,
-    BT_STATUS_V2_VERSION, BT_STATUS_VERSION,
+    BT_STATUS_V2_VERSION, BT_STATUS_V3_FIXED_LEN, BT_STATUS_V3_VERSION, BT_STATUS_VERSION,
 };
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct BtStatus {
+    pub status_version: u8,
+    pub decoded_status_version: u8,
     pub flags: u8,
     pub target: u8,
     pub last_status: u8,
@@ -57,6 +59,26 @@ pub struct BtStatus {
     pub last_encryption_enabled: u8,
     pub last_disconnection_reason: u8,
     pub last_hid_open_status: u8,
+    pub reconnect_state: u8,
+    pub reconnect_cycle_attempts: u8,
+    pub last_reconnect_status: u8,
+    pub last_reconnect_reason: u8,
+    pub reconnect_schedule_count: u32,
+    pub reconnect_attempt_count: u32,
+    pub reconnect_success_count: u32,
+    pub reconnect_failed_count: u32,
+    pub reconnect_blocked_count: u32,
+    pub last_reconnect_ms: u32,
+    pub connection_complete_count: u32,
+    pub last_connection_complete_status: u8,
+    pub last_connection_complete_link_type: u8,
+    pub last_connection_complete_ms: u32,
+    pub incoming_l2cap_connection_count: u32,
+    pub incoming_l2cap_hid_control_count: u32,
+    pub incoming_l2cap_hid_interrupt_count: u32,
+    pub last_incoming_l2cap_psm: u16,
+    pub last_incoming_l2cap_local_cid: u16,
+    pub last_incoming_l2cap_ms: u32,
     pub local_name: String,
 }
 
@@ -85,6 +107,42 @@ impl BtStatus {
             || self.disconnection_complete_count > 0
             || self.last_security_event_ms > 0
     }
+
+    pub fn newer_status_version(&self) -> bool {
+        self.status_version > BT_STATUS_VERSION
+    }
+
+    pub fn reconnect_peer_known(&self) -> bool {
+        self.reconnect_state & 0x01 != 0
+    }
+
+    pub fn reconnect_pending(&self) -> bool {
+        self.reconnect_state & 0x02 != 0
+    }
+
+    pub fn reconnect_in_progress(&self) -> bool {
+        self.reconnect_state & 0x04 != 0
+    }
+
+    pub fn reconnect_maxed(&self) -> bool {
+        self.reconnect_state & 0x08 != 0
+    }
+
+    pub fn reconnect_activity_seen(&self) -> bool {
+        self.reconnect_schedule_count > 0
+            || self.reconnect_attempt_count > 0
+            || self.reconnect_success_count > 0
+            || self.reconnect_failed_count > 0
+            || self.reconnect_blocked_count > 0
+            || self.last_reconnect_ms > 0
+    }
+
+    pub fn incoming_hid_l2cap_seen(&self) -> bool {
+        self.incoming_l2cap_connection_count > 0
+            || self.incoming_l2cap_hid_control_count > 0
+            || self.incoming_l2cap_hid_interrupt_count > 0
+            || self.last_incoming_l2cap_psm != 0
+    }
 }
 
 fn read_u16_le(payload: &[u8], offset: usize) -> u16 {
@@ -108,35 +166,58 @@ pub fn decode_bt_status_payload(payload: &[u8]) -> Result<BtStatus> {
     let fixed_len = match version {
         BT_STATUS_V1_VERSION => BT_STATUS_V1_FIXED_LEN,
         BT_STATUS_V2_VERSION => BT_STATUS_V2_FIXED_LEN,
+        BT_STATUS_V3_VERSION => BT_STATUS_V3_FIXED_LEN,
         BT_STATUS_VERSION => BT_STATUS_FIXED_LEN,
+        newer if newer > BT_STATUS_VERSION => BT_STATUS_V3_FIXED_LEN,
         _ => bail!(
-            "BT_STATUS version mismatch (got {}, want {}, {}, or {})",
+            "BT_STATUS version mismatch (got {}, want {}, {}, {}, or {})",
             payload[0],
             BT_STATUS_V1_VERSION,
             BT_STATUS_V2_VERSION,
+            BT_STATUS_V3_VERSION,
             BT_STATUS_VERSION
         ),
     };
     if payload.len() < fixed_len {
         bail!("BT_STATUS response truncated ({} bytes)", payload.len());
     }
+    let decode_name = version <= BT_STATUS_VERSION;
     let name_len_offset = match version {
         BT_STATUS_V1_VERSION => BT_STATUS_V1_FIXED_LEN - 1,
         BT_STATUS_V2_VERSION => BT_STATUS_V2_FIXED_LEN - 1,
-        _ => BT_STATUS_FIXED_LEN - 1,
+        BT_STATUS_V3_VERSION => BT_STATUS_V3_FIXED_LEN - 1,
+        BT_STATUS_VERSION => BT_STATUS_FIXED_LEN - 1,
+        _ => payload.len(),
     };
     let name_start = fixed_len;
-    let name_len = payload[name_len_offset] as usize;
-    let need = name_start + name_len;
+    let name_len = if decode_name {
+        payload[name_len_offset] as usize
+    } else {
+        0
+    };
+    let need = if decode_name {
+        name_start + name_len
+    } else {
+        name_start
+    };
     if payload.len() < need {
         bail!(
             "BT_STATUS local name truncated (need {need} bytes, have {})",
             payload.len()
         );
     }
-    let has_v2 = version == BT_STATUS_V2_VERSION || version == BT_STATUS_VERSION;
-    let has_v3 = version == BT_STATUS_VERSION;
+    let has_v2 = version == BT_STATUS_V2_VERSION
+        || version == BT_STATUS_V3_VERSION
+        || version >= BT_STATUS_VERSION;
+    let has_v3 = version == BT_STATUS_V3_VERSION || version >= BT_STATUS_VERSION;
+    let has_v4 = version == BT_STATUS_VERSION;
     Ok(BtStatus {
+        status_version: version,
+        decoded_status_version: if version > BT_STATUS_VERSION {
+            BT_STATUS_V3_VERSION
+        } else {
+            version
+        },
         flags: payload[1],
         target: payload[2],
         last_status: payload[3],
@@ -187,6 +268,26 @@ pub fn decode_bt_status_payload(payload: &[u8]) -> Result<BtStatus> {
         last_encryption_enabled: if has_v3 { payload[145] } else { 0 },
         last_disconnection_reason: if has_v3 { payload[146] } else { 0 },
         last_hid_open_status: if has_v3 { payload[147] } else { 0 },
+        reconnect_state: if has_v4 { payload[152] } else { 0 },
+        reconnect_cycle_attempts: if has_v4 { payload[153] } else { 0 },
+        last_reconnect_status: if has_v4 { payload[154] } else { 0 },
+        last_reconnect_reason: if has_v4 { payload[155] } else { 0 },
+        reconnect_schedule_count: if has_v4 { read_u32_le(payload, 156) } else { 0 },
+        reconnect_attempt_count: if has_v4 { read_u32_le(payload, 160) } else { 0 },
+        reconnect_success_count: if has_v4 { read_u32_le(payload, 164) } else { 0 },
+        reconnect_failed_count: if has_v4 { read_u32_le(payload, 168) } else { 0 },
+        reconnect_blocked_count: if has_v4 { read_u32_le(payload, 172) } else { 0 },
+        last_reconnect_ms: if has_v4 { read_u32_le(payload, 176) } else { 0 },
+        connection_complete_count: if has_v4 { read_u32_le(payload, 180) } else { 0 },
+        last_connection_complete_status: if has_v4 { payload[184] } else { 0 },
+        last_connection_complete_link_type: if has_v4 { payload[185] } else { 0 },
+        last_connection_complete_ms: if has_v4 { read_u32_le(payload, 188) } else { 0 },
+        incoming_l2cap_connection_count: if has_v4 { read_u32_le(payload, 192) } else { 0 },
+        incoming_l2cap_hid_control_count: if has_v4 { read_u32_le(payload, 196) } else { 0 },
+        incoming_l2cap_hid_interrupt_count: if has_v4 { read_u32_le(payload, 200) } else { 0 },
+        last_incoming_l2cap_psm: if has_v4 { read_u16_le(payload, 204) } else { 0 },
+        last_incoming_l2cap_local_cid: if has_v4 { read_u16_le(payload, 206) } else { 0 },
+        last_incoming_l2cap_ms: if has_v4 { read_u32_le(payload, 208) } else { 0 },
         local_name: String::from_utf8_lossy(&payload[name_start..need]).into_owned(),
     })
 }

bridge/src/cdc/frame.rs

@@ -77,12 +77,14 @@ pub const HELLO_FLAG_WIFI_JOINED: u8 = 0x02;
 pub const HELLO_FLAG_RUN_MODE_OK: u8 = 0x04;
 pub const HELLO_FLAG_RUN_MODE_ACTIVE: u8 = 0x08;
 
-pub const BT_STATUS_VERSION: u8 = 3;
+pub const BT_STATUS_VERSION: u8 = 4;
 pub const BT_STATUS_V1_VERSION: u8 = 1;
 pub const BT_STATUS_V1_FIXED_LEN: usize = 49;
 pub const BT_STATUS_V2_VERSION: u8 = 2;
 pub const BT_STATUS_V2_FIXED_LEN: usize = 99;
-pub const BT_STATUS_FIXED_LEN: usize = 153;
+pub const BT_STATUS_V3_VERSION: u8 = 3;
+pub const BT_STATUS_V3_FIXED_LEN: usize = 153;
+pub const BT_STATUS_FIXED_LEN: usize = 213;
 pub const BT_STATUS_FLAG_STARTED: u8 = 1 << 0;
 pub const BT_STATUS_FLAG_CONNECTED: u8 = 1 << 1;
 pub const BT_STATUS_FLAG_SEND_REQUESTED: u8 = 1 << 2;

bridge/src/cdc/tests.rs

@@ -87,8 +87,28 @@ fn bt_status_payload_decodes_wire_shape() {
     payload[145] = 1;
     payload[146] = 0x13;
     payload[147] = 0x44;
-    payload[152] = name.len() as u8;
-    payload[153..].copy_from_slice(name);
+    payload[152] = 0x07;
+    payload[153] = 2;
+    payload[154] = 0x21;
+    payload[155] = 4;
+    payload[156..160].copy_from_slice(&28u32.to_le_bytes());
+    payload[160..164].copy_from_slice(&29u32.to_le_bytes());
+    payload[164..168].copy_from_slice(&30u32.to_le_bytes());
+    payload[168..172].copy_from_slice(&31u32.to_le_bytes());
+    payload[172..176].copy_from_slice(&32u32.to_le_bytes());
+    payload[176..180].copy_from_slice(&0x1020_3040u32.to_le_bytes());
+    payload[180..184].copy_from_slice(&33u32.to_le_bytes());
+    payload[184] = 0x35;
+    payload[185] = 1;
+    payload[188..192].copy_from_slice(&0x4050_6070u32.to_le_bytes());
+    payload[192..196].copy_from_slice(&34u32.to_le_bytes());
+    payload[196..200].copy_from_slice(&35u32.to_le_bytes());
+    payload[200..204].copy_from_slice(&36u32.to_le_bytes());
+    payload[204..206].copy_from_slice(&0x0013u16.to_le_bytes());
+    payload[206..208].copy_from_slice(&0x0041u16.to_le_bytes());
+    payload[208..212].copy_from_slice(&0x5060_7080u32.to_le_bytes());
+    payload[212] = name.len() as u8;
+    payload[213..].copy_from_slice(name);
 
     let status = decode_bt_status_payload(&payload).unwrap();
 
@@ -144,10 +164,67 @@ fn bt_status_payload_decodes_wire_shape() {
     assert_eq!(status.last_encryption_enabled, 1);
     assert_eq!(status.last_disconnection_reason, 0x13);
     assert_eq!(status.last_hid_open_status, 0x44);
+    assert_eq!(status.reconnect_state, 0x07);
+    assert!(status.reconnect_peer_known());
+    assert!(status.reconnect_pending());
+    assert!(status.reconnect_in_progress());
+    assert!(!status.reconnect_maxed());
+    assert_eq!(status.reconnect_cycle_attempts, 2);
+    assert_eq!(status.last_reconnect_status, 0x21);
+    assert_eq!(status.last_reconnect_reason, 4);
+    assert_eq!(status.reconnect_schedule_count, 28);
+    assert_eq!(status.reconnect_attempt_count, 29);
+    assert_eq!(status.reconnect_success_count, 30);
+    assert_eq!(status.reconnect_failed_count, 31);
+    assert_eq!(status.reconnect_blocked_count, 32);
+    assert_eq!(status.last_reconnect_ms, 0x10203040);
+    assert!(status.reconnect_activity_seen());
+    assert_eq!(status.connection_complete_count, 33);
+    assert_eq!(status.last_connection_complete_status, 0x35);
+    assert_eq!(status.last_connection_complete_link_type, 1);
+    assert_eq!(status.last_connection_complete_ms, 0x40506070);
+    assert_eq!(status.incoming_l2cap_connection_count, 34);
+    assert_eq!(status.incoming_l2cap_hid_control_count, 35);
+    assert_eq!(status.incoming_l2cap_hid_interrupt_count, 36);
+    assert_eq!(status.last_incoming_l2cap_psm, 0x0013);
+    assert_eq!(status.last_incoming_l2cap_local_cid, 0x0041);
+    assert_eq!(status.last_incoming_l2cap_ms, 0x50607080);
+    assert!(status.incoming_hid_l2cap_seen());
     assert!(status.pairing_security_contact_seen());
     assert_eq!(status.local_name, "CouchLink BT HID");
 }
 
+#[test]
+fn bt_status_payload_decodes_v3_wire_shape() {
+    let name = b"Security BT";
+    let mut payload = vec![0u8; BT_STATUS_V3_FIXED_LEN + name.len()];
+    payload[0] = BT_STATUS_V3_VERSION;
+    payload[1] = BT_STATUS_FLAG_STARTED;
+    payload[2] = 1;
+    payload[106..110].copy_from_slice(&4u32.to_le_bytes());
+    payload[110..114].copy_from_slice(&4u32.to_le_bytes());
+    payload[122..126].copy_from_slice(&1u32.to_le_bytes());
+    payload[146] = 0x16;
+    payload[152] = name.len() as u8;
+    payload[153..].copy_from_slice(name);
+
+    let status = decode_bt_status_payload(&payload).unwrap();
+
+    assert_eq!(status.status_version, BT_STATUS_V3_VERSION);
+    assert_eq!(status.decoded_status_version, BT_STATUS_V3_VERSION);
+    assert!(status.started());
+    assert_eq!(status.target, 1);
+    assert_eq!(status.user_confirmation_request_count, 4);
+    assert_eq!(status.user_confirmation_response_count, 4);
+    assert_eq!(status.link_key_notification_count, 1);
+    assert_eq!(status.last_disconnection_reason, 0x16);
+    assert!(status.pairing_security_contact_seen());
+    assert_eq!(status.reconnect_attempt_count, 0);
+    assert_eq!(status.connection_complete_count, 0);
+    assert_eq!(status.incoming_l2cap_connection_count, 0);
+    assert_eq!(status.local_name, "Security BT");
+}
+
 #[test]
 fn bt_status_payload_decodes_v2_wire_shape() {
     let name = b"Previous BT";
@@ -168,6 +245,9 @@ fn bt_status_payload_decodes_v2_wire_shape() {
     assert_eq!(status.pin_code_request_count, 0);
     assert_eq!(status.user_confirmation_request_count, 0);
     assert_eq!(status.hid_open_failed_count, 0);
+    assert_eq!(status.reconnect_attempt_count, 0);
+    assert_eq!(status.connection_complete_count, 0);
+    assert_eq!(status.incoming_l2cap_connection_count, 0);
     assert!(!status.pairing_security_contact_seen());
     assert_eq!(status.local_name, "Previous BT");
 }
@@ -195,6 +275,9 @@ fn bt_status_payload_decodes_v1_wire_shape() {
     assert_eq!(status.pin_code_request_count, 0);
     assert_eq!(status.user_confirmation_request_count, 0);
     assert_eq!(status.hid_open_failed_count, 0);
+    assert_eq!(status.reconnect_attempt_count, 0);
+    assert_eq!(status.connection_complete_count, 0);
+    assert_eq!(status.incoming_l2cap_connection_count, 0);
     assert!(!status.pairing_security_contact_seen());
     assert_eq!(status.local_name, "Legacy BT");
 }
@@ -203,10 +286,31 @@ fn bt_status_payload_decodes_v1_wire_shape() {
 fn bt_status_payload_rejects_bad_shape() {
     assert!(decode_bt_status_payload(&[0; BT_STATUS_FIXED_LEN - 1]).is_err());
     let mut bad_version = vec![0u8; BT_STATUS_FIXED_LEN];
-    bad_version[0] = BT_STATUS_VERSION + 1;
+    bad_version[0] = 0;
     assert!(decode_bt_status_payload(&bad_version).is_err());
     let mut bad_name = vec![0u8; BT_STATUS_FIXED_LEN];
     bad_name[0] = BT_STATUS_VERSION;
-    bad_name[152] = 1;
+    bad_name[212] = 1;
     assert!(decode_bt_status_payload(&bad_name).is_err());
 }
+
+#[test]
+fn bt_status_payload_decodes_future_version_prefix() {
+    let mut payload = vec![0u8; BT_STATUS_V3_FIXED_LEN + 8];
+    payload[0] = BT_STATUS_VERSION + 1;
+    payload[1] = BT_STATUS_FLAG_STARTED;
+    payload[2] = 1;
+    payload[106..110].copy_from_slice(&2u32.to_le_bytes());
+    payload[146] = 0x16;
+
+    let status = decode_bt_status_payload(&payload).unwrap();
+
+    assert_eq!(status.status_version, BT_STATUS_VERSION + 1);
+    assert_eq!(status.decoded_status_version, BT_STATUS_V3_VERSION);
+    assert!(status.newer_status_version());
+    assert!(status.started());
+    assert_eq!(status.user_confirmation_request_count, 2);
+    assert_eq!(status.last_disconnection_reason, 0x16);
+    assert_eq!(status.reconnect_attempt_count, 0);
+    assert_eq!(status.local_name, "");
+}