1use crate::errors::{Service, ServiceRejected};
4use crate::{protobuf as p, wire, AccountState, NativeClient};
5use anyhow::{bail, ensure, Result};
6use serde::{Deserialize, Serialize};
7use std::collections::HashSet;
8
9pub const CONTACT_SELECTOR: u64 = 0x20004;
10
11#[derive(Clone, Serialize, Deserialize)]
12pub struct ContactSyncBatch {
13 pub cursor: Vec<u8>,
14 pub continuation: Vec<u64>,
15 pub commands: Vec<wire::SyncCommand>,
16 pub raw: Vec<u8>,
17}
18
19pub fn validate_cursor(input: &[u8]) -> Result<()> {
22 ensure!(input.len() <= 65536, "Contact cursor exceeds limit");
23 let fields = p::decode(input)?;
24 let mut keys = HashSet::new();
25 for field in fields.iter().filter(|field| field.number == 1) {
26 let p::Value::Bytes(raw) = &field.value else {
27 bail!("Invalid contact cursor pair");
28 };
29 let pair = p::decode(raw)?;
30 let key = u32::try_from(p::scalar(&pair, 1)?)?;
31 p::scalar(&pair, 2)?;
32 ensure!(
33 keys.insert(key) && keys.len() <= 256,
34 "Invalid contact cursor keys"
35 );
36 }
37 Ok(())
38}
39
40pub fn request(
41 state: &AccountState,
42 cursor: &[u8],
43 message_cursor: &[u8],
44 continuation: bool,
45) -> Result<Vec<u8>> {
46 validate_cursor(cursor)?;
47 ensure!(
48 message_cursor.len() <= 65536,
49 "Message cursor exceeds limit"
50 );
51 ensure!(
52 !cursor.is_empty() || !message_cursor.is_empty(),
53 "Contact sync has no cursor context"
54 );
55 let mut fields = vec![
58 p::bytes(1, &wire::base_request(&state.device, state.uin, 0)?),
59 p::uint(2, if continuation { 4 } else { 3 }),
60 p::uint(3, CONTACT_SELECTOR),
61 p::bytes(4, cursor),
62 ];
63 fields.push(p::bytes(5, message_cursor));
64 p::message(&fields)
65}
66
67pub fn decode(input: &[u8]) -> Result<ContactSyncBatch> {
68 ensure!(
69 input.len() <= 16 * 1024 * 1024,
70 "Contact response exceeds limit"
71 );
72 let fields = p::decode(input)?;
73 let code = p::base_code(&fields)?;
74 ServiceRejected::check(Service::ContactSync, code)?;
75 let cursor = p::data(&fields, 3)?.to_vec();
76 validate_cursor(&cursor)?;
77 let mut continuation = Vec::new();
78 let mut commands = Vec::new();
79 for field in fields {
80 match (field.number, field.value) {
81 (2, p::Value::Varint(value)) => {
82 continuation.push(value);
83 ensure!(
84 continuation.len() <= 64,
85 "Contact continuation exceeds limit"
86 );
87 }
88 (4, p::Value::Bytes(raw)) => {
89 let item = p::decode(&raw)?;
90 commands.push(wire::SyncCommand {
92 id: i32::try_from(p::scalar(&item, 1)?)?,
93 payload: p::data(&item, 2)?.to_vec(),
94 });
95 ensure!(commands.len() <= 10000, "Contact command limit");
96 }
97 (2 | 4, _) => bail!("Invalid contact response field type"),
98 _ => {}
99 }
100 }
101 Ok(ContactSyncBatch {
102 cursor,
103 continuation,
104 commands,
105 raw: input.to_vec(),
106 })
107}
108
109impl NativeClient {
110 #[doc(hidden)]
111 pub(crate) fn contact_sync_snapshot(
112 &self,
113 state: &mut AccountState,
114 cursor: &[u8],
115 message_cursor: &[u8],
116 continuation: bool,
117 ) -> Result<ContactSyncBatch> {
118 let request = request(state, cursor, message_cursor, continuation)?;
119 decode(&self.authenticated_rpc(
120 state,
121 8674,
122 "/cgi-bin/micromsg-bin/contactsync",
123 &request,
124 )?)
125 }
126}
127
128#[cfg(test)]
129mod tests {
130 use super::*;
131 fn pair(key: u64, value: u64) -> Vec<u8> {
132 p::bytes(
133 1,
134 &p::message(&[p::uint(1, key), p::uint(2, value)]).unwrap(),
135 )
136 }
137 #[test]
138 fn cursor_values_keep_u64_and_reject_duplicate_or_malformed_keys() {
139 validate_cursor(&pair(11, u64::MAX)).unwrap();
140 assert!(validate_cursor(&[pair(11, 1), pair(11, 2)].concat()).is_err());
141 assert!(validate_cursor(&p::uint(1, 11)).is_err());
142 assert!(validate_cursor(&pair(u32::MAX as u64 + 1, 0)).is_err());
143 }
144 #[test]
145 fn final_and_continuing_pages_retain_unknown_commands_and_raw_bytes() {
146 for flags in [vec![0], vec![0, CONTACT_SELECTOR]] {
147 let mut fields = vec![
148 p::bytes(1, &p::message(&[p::int32(1, 0)]).unwrap()),
149 p::bytes(3, &pair(11, 7)),
150 p::bytes(
151 4,
152 &p::message(&[p::uint(1, 912), p::bytes(2, b"unknown")]).unwrap(),
153 ),
154 ];
155 fields.extend(flags.iter().map(|value| p::uint(2, *value)));
156 let raw = p::message(&fields).unwrap();
157 let batch = decode(&raw).unwrap();
158 assert_eq!(batch.continuation, flags);
159 assert_eq!(batch.commands[0].id, 912);
160 assert_eq!(batch.commands[0].payload, b"unknown");
161 assert_eq!(batch.raw, raw);
162 }
163 }
164}