diff --git a/src/devices.rs b/src/devices.rs index 6417329..0e97320 100644 --- a/src/devices.rs +++ b/src/devices.rs @@ -60,6 +60,8 @@ pub struct DeviceStatusRow { pub device_id: String, pub name: String, pub client_version: String, + /// Device-sync protocol version the device reported itself. + pub protocol_version: u16, pub endpoint_id: String, pub last_seen_ms: Option, pub revoked: bool, @@ -292,6 +294,55 @@ struct PairingStatus { use_requester_group: bool, } +/// How the protocol version in a device profile became known. +/// +/// Version gating (podcast operations, snapshot sections and playback +/// state need v4) depends on these values, so this device never stores its +/// own [`PROTOCOL_VERSION`] for another device. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum VersionReport { + /// The device reported its own version (`None`: an older client left it + /// out). Replaces the stored version, so a downgrade is noticed. + SelfReported(Option), + /// Another device relayed the profile. Only raises the stored version: + /// v1–v3 relays substitute their own constant. + Relayed(u16), +} + +impl VersionReport { + fn resolve(self, stored: Option) -> u16 { + match self { + VersionReport::SelfReported(reported) => { + music_dht::device_sync::profile_protocol_version(reported, stored) + } + VersionReport::Relayed(relayed) => { + music_dht::device_sync::relayed_protocol_version(relayed, stored) + } + } + } + + /// Report carried by an entry of a `devices` list sent by `sender`. + fn for_listed(profile: &DeviceProfileWire, sender: Option<&str>) -> Self { + if sender == Some(profile.device_id.as_str()) { + VersionReport::SelfReported(Some(profile.protocol_version)) + } else { + VersionReport::Relayed(profile.protocol_version) + } + } +} + +/// The stored protocol version of a device, if any row exists. +fn stored_protocol_version(conn: &Connection, device_id: &str) -> Result> { + Ok(conn + .query_row( + "SELECT protocol_version FROM sync_devices WHERE device_id = ?1", + [device_id], + |row| row.get::<_, i64>(0), + ) + .optional()? + .and_then(|version| u16::try_from(version).ok())) +} + fn lock(mutex: &std::sync::Mutex) -> std::sync::MutexGuard<'_, T> { mutex .lock() @@ -512,7 +563,7 @@ impl DeviceSync { client_version: CLIENT_VERSION.to_string(), endpoint_ticket: ticket.to_string(), endpoint_id, - protocol_version: None, + protocol_version: Some(PROTOCOL_VERSION), })?; } Ok(()) @@ -549,7 +600,7 @@ impl DeviceSync { invite_id, secret, expires_at_ms, - protocol_version: None, + protocol_version: Some(PROTOCOL_VERSION), }; Ok(encode_invite(&payload)?) } @@ -661,13 +712,17 @@ impl DeviceSync { .. } => { self.set_group_id(&group_id)?; - if let Some(profile) = profile { - self.apply_device_profile(&profile, true)?; + if let Some(profile) = &profile { + self.apply_device_profile( + profile, + true, + VersionReport::SelfReported(Some(profile.protocol_version)), + )?; if let Some(playback) = playback { self.apply_playback_snapshot(&profile.device_id, playback)?; } } - self.apply_device_profiles(&devices)?; + self.apply_device_profiles(&devices, Some(&invite.device_id))?; self.apply_snapshot(snapshot)?; self.apply_ops(ops)?; self.record_local_op(SyncOpPayload::DeviceTrusted { @@ -708,7 +763,8 @@ impl DeviceSync { conn.query_row( "SELECT device_id, name, client_version, endpoint_id, endpoint_ticket, created_at_ms, - requester_group_id, requester_group_devices_json + requester_group_id, requester_group_devices_json, + protocol_version FROM sync_pending_pairing WHERE request_id = ?1", [request_id], @@ -718,7 +774,7 @@ impl DeviceSync { device_id: row.get(0)?, name: row.get(1)?, client_version: row.get(2)?, - protocol_version: PROTOCOL_VERSION, + protocol_version: music_dht::device_sync::UNREPORTED_PROTOCOL_VERSION, endpoint_id: row.get(3)?, endpoint_ticket: row.get(4)?, revoked: false, @@ -727,6 +783,8 @@ impl DeviceSync { }, row.get::<_, Option>(6)?, row.get::<_, String>(7)?, + row.get::<_, Option>(8)? + .and_then(|version| u16::try_from(version).ok()), )) }, ) @@ -747,7 +805,13 @@ impl DeviceSync { )? }; if accept && changed > 0 { - if let Some((profile, requester_group_id, requester_group_devices_json)) = pending { + if let Some(( + profile, + requester_group_id, + requester_group_devices_json, + requester_version, + )) = pending + { if use_requester_group { if let Some(group_id) = requester_group_id .as_deref() @@ -757,9 +821,15 @@ impl DeviceSync { } let requester_devices: Vec = serde_json::from_str(&requester_group_devices_json)?; - self.apply_device_profiles(&requester_devices)?; + self.apply_device_profiles(&requester_devices, Some(&profile.device_id))?; } - self.apply_device_profile(&profile, true)?; + // The version the requester reported in its own pairing + // request (requests stored by older builds have none). + self.apply_device_profile( + &profile, + true, + VersionReport::SelfReported(requester_version), + )?; self.record_local_op(SyncOpPayload::DeviceTrusted { target_device_id: profile.device_id, })?; @@ -1151,7 +1221,8 @@ impl DeviceSync { playback, .. } => { - self.apply_device_profiles(&devices)?; + // The responder lists itself: that entry is its own report. + self.apply_device_profiles(&devices, Some(&device.device_id))?; if let Some(playback) = playback { self.apply_playback_snapshot(&device.device_id, playback)?; } @@ -1222,8 +1293,9 @@ impl DeviceSync { fn own_profile(&self, endpoint_ticket: &str) -> Result { let identity = self.ensure_identity()?; let endpoint_id = ticket_endpoint_id(endpoint_ticket).unwrap_or_default(); - { + let previous_version = { let conn = lock(&self.conn); + let previous_version = stored_protocol_version(&conn, &identity.device_id)?; conn.execute( "INSERT INTO sync_devices (device_id, name, client_version, protocol_version, endpoint_id, @@ -1246,6 +1318,19 @@ impl DeviceSync { now_ms(), ], )?; + previous_version + }; + if previous_version.is_some_and(|version| version < PROTOCOL_VERSION) { + // First start of a new protocol version: announce it in the log + // too, so devices that only hear of this one through relays + // learn its version (`profile_protocol_version`). + self.record_local_op(SyncOpPayload::DeviceProfileSet { + name: identity.name.clone(), + client_version: CLIENT_VERSION.to_string(), + endpoint_ticket: endpoint_ticket.to_string(), + endpoint_id: endpoint_id.clone(), + protocol_version: Some(PROTOCOL_VERSION), + })?; } Ok(DeviceProfileWire { device_id: identity.device_id, @@ -1454,20 +1539,27 @@ impl DeviceSync { client_version, endpoint_ticket, endpoint_id, - .. + protocol_version, } => { let profile = DeviceProfileWire { device_id: op.origin_device_id.clone(), name: name.clone(), client_version: client_version.clone(), - protocol_version: PROTOCOL_VERSION, + protocol_version: protocol_version + .unwrap_or(music_dht::device_sync::UNREPORTED_PROTOCOL_VERSION), endpoint_id: endpoint_id.clone(), endpoint_ticket: endpoint_ticket.clone(), revoked: false, revoke_cutoff_seq: None, updated_at_ms: op.hlc_ms, }; - self.apply_device_profile(&profile, false)?; + // The origin announces its own profile; profiles before v4 + // carry no version and keep the stored one. + self.apply_device_profile( + &profile, + false, + VersionReport::SelfReported(*protocol_version), + )?; false } SyncOpPayload::DeviceTrusted { target_device_id } => { @@ -1952,14 +2044,26 @@ impl DeviceSync { Ok(()) } - fn apply_device_profiles(&self, devices: &[DeviceProfileWire]) -> Result<()> { + /// Stores the profiles of a `devices` list sent by `sender`. The entry + /// of the sender itself is its own version report; the others are + /// relayed. + fn apply_device_profiles( + &self, + devices: &[DeviceProfileWire], + sender: Option<&str>, + ) -> Result<()> { for profile in devices { - self.apply_device_profile(profile, false)?; + self.apply_device_profile(profile, false, VersionReport::for_listed(profile, sender))?; } Ok(()) } - fn apply_device_profile(&self, profile: &DeviceProfileWire, trusted: bool) -> Result<()> { + fn apply_device_profile( + &self, + profile: &DeviceProfileWire, + trusted: bool, + version: VersionReport, + ) -> Result<()> { let own = self.ensure_identity()?.device_id; if profile.device_id == own { return Ok(()); @@ -1971,6 +2075,8 @@ impl DeviceSync { }; { let conn = lock(&self.conn); + let protocol_version = + version.resolve(stored_protocol_version(&conn, &profile.device_id)?); conn.execute( "INSERT INTO sync_devices (device_id, name, client_version, protocol_version, endpoint_id, @@ -2006,7 +2112,7 @@ impl DeviceSync { profile.device_id, profile.name, profile.client_version, - profile.protocol_version, + protocol_version, profile.endpoint_id, profile.endpoint_ticket, trusted_at_ms, @@ -2399,7 +2505,7 @@ impl DeviceSync { let last_error = get_meta(&conn, "last_error")?; let mut stmt = conn.prepare( "SELECT device_id, name, client_version, endpoint_id, last_seen_ms, - revoked_at_ms IS NOT NULL + revoked_at_ms IS NOT NULL, protocol_version FROM sync_devices WHERE trusted_at_ms IS NOT NULL ORDER BY revoked_at_ms IS NOT NULL, name COLLATE NOCASE, device_id", @@ -2415,6 +2521,8 @@ impl DeviceSync { endpoint_id: row.get(3)?, last_seen_ms: row.get(4)?, revoked: row.get::<_, i64>(5)? != 0, + protocol_version: u16::try_from(row.get::<_, i64>(6)?) + .unwrap_or(music_dht::device_sync::UNREPORTED_PROTOCOL_VERSION), }) })? .collect::>>()?; @@ -2870,9 +2978,10 @@ async fn handle_pair_request( (request_id, device_id, name, client_version, endpoint_id, endpoint_ticket, invite_id, created_at_ms, status, requester_group_id, requester_group_active_devices, - requester_group_devices_json, use_requester_group) + requester_group_devices_json, use_requester_group, + protocol_version) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, 'pending', - ?9, ?10, ?11, 0)", + ?9, ?10, ?11, 0, ?12)", params![ request_id, profile.device_id, @@ -2885,6 +2994,7 @@ async fn handle_pair_request( requester_group_id.as_deref(), requester_group_active_devices as i64, requester_group_devices_json, + profile.protocol_version, ], )? }; @@ -2962,9 +3072,13 @@ async fn handle_pair_request( { sync.set_group_id(group_id)?; response_group_id = group_id.to_string(); - sync.apply_device_profiles(&requester_group_devices)?; + sync.apply_device_profiles(&requester_group_devices, Some(&profile.device_id))?; } - sync.apply_device_profile(&profile, true)?; + sync.apply_device_profile( + &profile, + true, + VersionReport::SelfReported(Some(profile.protocol_version)), + )?; if let Some(playback) = playback { sync.apply_playback_snapshot(&profile.device_id, playback)?; } @@ -3053,8 +3167,12 @@ async fn handle_hello( return Ok(()); } profile.endpoint_id = stream.peer_id.to_string(); - sync.apply_device_profile(&profile, false)?; - sync.apply_device_profiles(&devices)?; + sync.apply_device_profile( + &profile, + false, + VersionReport::SelfReported(Some(profile.protocol_version)), + )?; + sync.apply_device_profiles(&devices, Some(&profile.device_id))?; if let Some(playback) = playback { sync.apply_playback_snapshot(&profile.device_id, playback)?; } @@ -3296,6 +3414,13 @@ CREATE TABLE IF NOT EXISTS sync_playback_applied ( "ALTER TABLE sync_pending_pairing ADD COLUMN use_requester_group INTEGER NOT NULL DEFAULT 0", )?; + // Protocol version the requester reported in its pairing request. + ensure_column( + conn, + "sync_pending_pairing", + "protocol_version", + "ALTER TABLE sync_pending_pairing ADD COLUMN protocol_version INTEGER", + )?; Ok(()) } diff --git a/src/devices/tests.rs b/src/devices/tests.rs index cc5d67f..a0ca162 100644 --- a/src/devices/tests.rs +++ b/src/devices/tests.rs @@ -54,8 +54,18 @@ async fn localhost_devices_exchange_state_and_handoff() { let profile_b = b .own_profile(&service_b.ticket().await.unwrap().to_string()) .unwrap(); - a.apply_device_profile(&profile_b, true).unwrap(); - b.apply_device_profile(&profile_a, true).unwrap(); + a.apply_device_profile( + &profile_b, + true, + VersionReport::SelfReported(Some(profile_b.protocol_version)), + ) + .unwrap(); + b.apply_device_profile( + &profile_a, + true, + VersionReport::SelfReported(Some(profile_a.protocol_version)), + ) + .unwrap(); a.claim_playback(&profile_a.device_id).unwrap(); a.playback_tick(true, true).unwrap(); let mut state = empty_playback_state(); @@ -163,7 +173,12 @@ async fn localhost_devices_exchange_state_and_handoff() { silent_profile.device_id = "silent-peer".into(); silent_profile.endpoint_id = silent.endpoint_id().to_string(); silent_profile.endpoint_ticket = silent.ticket().await.unwrap().to_string(); - a.apply_device_profile(&silent_profile, true).unwrap(); + a.apply_device_profile( + &silent_profile, + true, + VersionReport::SelfReported(Some(silent_profile.protocol_version)), + ) + .unwrap(); lock(&a.conn) .execute( "UPDATE sync_devices SET last_seen_ms = ?1 WHERE device_id = 'silent-peer'", @@ -709,6 +724,7 @@ fn newer_device_trust_reactivates_revoked_device() { updated_at_ms: 20, }, false, + VersionReport::Relayed(PROTOCOL_VERSION), ) .unwrap(); assert!(!device_revoked(&sync, device_id)); @@ -1102,3 +1118,138 @@ fn podcast_episodes_never_enter_music_listening_history() { .is_none() ); } + +fn stored_version(sync: &DeviceSync, device_id: &str) -> Option { + stored_protocol_version(&lock(&sync.conn), device_id).unwrap() +} + +fn profile_wire(device_id: &str, protocol_version: u16) -> DeviceProfileWire { + DeviceProfileWire { + device_id: device_id.to_string(), + name: device_id.to_string(), + client_version: "0.0.0".to_string(), + protocol_version, + endpoint_id: String::new(), + endpoint_ticket: String::new(), + revoked: false, + revoke_cutoff_seq: None, + updated_at_ms: 1, + } +} + +fn profile_set_op(origin: &str, seq: i64, protocol_version: Option) -> SyncOpWire { + SyncOpWire { + op_id: format!("{origin}:{seq}"), + origin_device_id: origin.to_string(), + seq, + hlc_ms: seq, + payload: SyncOpPayload::DeviceProfileSet { + name: origin.to_string(), + client_version: "0.0.0".to_string(), + endpoint_ticket: String::new(), + endpoint_id: String::new(), + protocol_version, + }, + } +} + +#[test] +fn peer_versions_come_from_the_peer_itself_never_from_this_build() { + let sync = test_sync(); + sync.apply_device_trusted("dev_new", 1).unwrap(); + sync.apply_device_trusted("dev_old", 1).unwrap(); + // A device known only from `device_trusted` has reported nothing. + assert_eq!( + stored_version(&sync, "dev_new"), + Some(music_dht::device_sync::UNREPORTED_PROTOCOL_VERSION) + ); + + // Its own profile announcement (v4) is a self-report. + sync.apply_op(&profile_set_op("dev_new", 1, Some(4))) + .unwrap(); + assert_eq!(stored_version(&sync, "dev_new"), Some(4)); + // An announcement of an older client carries no version: this device + // keeps what it knows and never substitutes its own constant. + sync.apply_op(&profile_set_op("dev_old", 1, None)).unwrap(); + assert_eq!( + stored_version(&sync, "dev_old"), + Some(music_dht::device_sync::UNREPORTED_PROTOCOL_VERSION) + ); + + // Relays of v1-v3 clients list every device with their own constant: + // a relayed value only raises the stored version. + sync.apply_device_profiles( + &[profile_wire("dev_new", 3), profile_wire("dev_old", 3)], + Some("dev_relay"), + ) + .unwrap(); + assert_eq!(stored_version(&sync, "dev_new"), Some(4)); + assert_eq!(stored_version(&sync, "dev_old"), Some(3)); + + // The sender's own entry of a `devices` list is a self-report, so a + // downgraded device is noticed. + sync.apply_device_profiles(&[profile_wire("dev_new", 3)], Some("dev_new")) + .unwrap(); + assert_eq!(stored_version(&sync, "dev_new"), Some(3)); +} + +#[test] +fn accepted_pairing_keeps_the_version_the_requester_reported() { + let sync = test_sync(); + let insert = |request_id: &str, device_id: &str, version: Option| { + lock(&sync.conn) + .execute( + "INSERT INTO sync_pending_pairing + (request_id, device_id, name, client_version, endpoint_id, + endpoint_ticket, invite_id, created_at_ms, status, protocol_version) + VALUES (?1, ?2, 'phone', '0.0.0', '', '', 'inv', 1, 'pending', ?3)", + params![request_id, device_id, version], + ) + .unwrap(); + }; + insert("req_v3", "dev_v3", Some(3)); + // A request stored by an older build of this client has no version. + insert("req_legacy", "dev_legacy", None); + sync.answer_pairing("req_v3", true, false).unwrap(); + sync.answer_pairing("req_legacy", true, false).unwrap(); + assert_eq!(stored_version(&sync, "dev_v3"), Some(3)); + assert_eq!( + stored_version(&sync, "dev_legacy"), + Some(music_dht::device_sync::UNREPORTED_PROTOCOL_VERSION) + ); +} + +#[test] +fn a_new_protocol_version_is_announced_once_in_the_log() { + let sync = test_sync(); + let device_id = sync.ensure_identity().unwrap().device_id; + let announcements = |sync: &DeviceSync| { + logged_ops(sync) + .into_iter() + .filter(|(_, _, kind, ..)| kind == "device_profile_set") + .map(|(_, _, _, payload, _)| serde_json::from_str::(&payload).unwrap()) + .collect::>() + }; + // A fresh identity already reports this version in every hello. + sync.own_profile("").unwrap(); + assert!(announcements(&sync).is_empty()); + // The row written by the previous release. + lock(&sync.conn) + .execute( + "UPDATE sync_devices SET protocol_version = ?2 WHERE device_id = ?1", + params![device_id, PROTOCOL_VERSION - 1], + ) + .unwrap(); + sync.own_profile("").unwrap(); + sync.own_profile("").unwrap(); + let announced = announcements(&sync); + assert_eq!(announced.len(), 1, "{announced:?}"); + assert!(matches!( + announced[0], + SyncOpPayload::DeviceProfileSet { + protocol_version: Some(PROTOCOL_VERSION), + .. + } + )); + assert_eq!(stored_version(&sync, &device_id), Some(PROTOCOL_VERSION)); +} diff --git a/src/devices/wire_compat_tests.rs b/src/devices/wire_compat_tests.rs index 4aad9ed..75f3491 100644 --- a/src/devices/wire_compat_tests.rs +++ b/src/devices/wire_compat_tests.rs @@ -531,3 +531,46 @@ fn v3_peers_would_drop_the_source_of_podcast_items() { assert_eq!(forwarded.source, None); assert_eq!(forwarded.id, 0); } + +#[test] +fn version_reports_stay_readable_by_older_clients() { + let link = encode_invite(&InviteWire { + v: 1, + ticket: "ticket".into(), + device_id: "tui_a".into(), + invite_id: "inv".into(), + secret: "s3cr3t".into(), + expires_at_ms: 10, + protocol_version: Some(PROTOCOL_VERSION), + }) + .unwrap(); + let invite = parse_invite(&link).unwrap(); + assert_eq!(invite.inviter_protocol_version(), PROTOCOL_VERSION); + let json = serde_json::to_string(&invite).unwrap(); + assert!( + json.ends_with(&format!(r#","p":{PROTOCOL_VERSION}}}"#)), + "{json}" + ); + // `p` is an unknown field for 0.3.x and is ignored there. + assert_eq!( + serde_json::from_str::(&json) + .unwrap() + .invite_id, + "inv" + ); + + let announcement = SyncOpPayload::DeviceProfileSet { + name: "TUI".into(), + client_version: CLIENT_VERSION.into(), + endpoint_ticket: "t".into(), + endpoint_id: "e".into(), + protocol_version: Some(PROTOCOL_VERSION), + }; + let json = serde_json::to_string(&announcement).unwrap(); + assert!(json.ends_with(&format!(r#","protocol_version":{PROTOCOL_VERSION}}}"#))); + let old: legacy::SyncOpPayload = serde_json::from_str(&json).unwrap(); + assert!(matches!( + old, + legacy::SyncOpPayload::DeviceProfileSet { .. } + )); +}