1use super::*;
3use std::collections::HashSet;
4
5#[derive(Clone, Serialize, Deserialize)]
6pub struct MetadataReply<T> {
7 pub value: T,
8 pub raw: Vec<u8>,
9}
10#[derive(Clone, Serialize, Deserialize)]
11pub struct GroupMetadataPage {
12 pub contacts: Vec<ContactRecord>,
13 pub next_cursor: Option<Vec<u8>>,
14 pub more: bool,
15 pub wait_seconds: u32,
16 pub raw: Vec<u8>,
17}
18pub fn group_inventory_request(state: &AccountState, cursor: &[u8]) -> Result<Vec<u8>> {
19 ensure!(
20 !cursor.is_empty() && cursor.len() <= 65536,
21 "Invalid raw group cursor"
22 );
23 p::message(&[
24 p::bytes(1, &wire::base_request(&state.device, state.uin, 0)?),
25 p::bytes(2, cursor),
26 ])
27}
28pub fn decode_group_inventory(raw: &[u8]) -> Result<GroupMetadataPage> {
29 let fields = p::decode(raw)?;
30 let code = p::base_code(&fields)?;
31 ServiceRejected::check(Service::GroupMetadata, code)?;
32 let mut contacts = vec![];
33 let mut seen = HashSet::new();
34 for field in fields.iter().filter(|f| f.number == 2) {
35 let p::Value::Bytes(raw) = &field.value else {
36 bail!("Invalid group contact field")
37 };
38 let record = wire::decode_contact_record(raw)?;
39 ensure!(
40 seen.insert(record.username.clone()) && contacts.len() < 5000,
41 "Duplicate or excessive group metadata"
42 );
43 contacts.push(record);
44 }
45 let next_cursor = p::optional_data(&fields, 3)?.map(Vec::from);
46 ensure!(
47 next_cursor
48 .as_ref()
49 .is_none_or(|c| !c.is_empty() && c.len() <= 65536),
50 "Invalid next group cursor"
51 );
52 let control = p::optional_data(&fields, 4)?
53 .map(p::decode)
54 .transpose()?
55 .unwrap_or_default();
56 let scalar = |n| -> Result<u32> {
57 match p::optional(&control, n)? {
58 None => Ok(0),
59 Some(p::Value::Varint(n)) => Ok(u32::try_from(*n)?),
60 _ => bail!("Invalid group control"),
61 }
62 };
63 let more = scalar(1)? != 0;
64 let wait_seconds = scalar(2)?;
65 ensure!(
66 !more || next_cursor.is_some(),
67 "Continuing group page has no cursor"
68 );
69 Ok(GroupMetadataPage {
70 contacts,
71 next_cursor,
72 more,
73 wait_seconds,
74 raw: raw.to_vec(),
75 })
76}
77impl NativeClient {
78 #[doc(hidden)]
79 pub(crate) fn group_inventory_snapshot(
80 &self,
81 state: &mut AccountState,
82 cursor: &[u8],
83 ) -> Result<GroupMetadataPage> {
84 let request = group_inventory_request(state, cursor)?;
85 let raw = self.authenticated_rpc(
86 state,
87 15595,
88 "/cgi-bin/micromsg-bin/syncsimplechatroomdata",
89 &request,
90 )?;
91 let page = decode_group_inventory(&raw)?;
92 ensure!(
93 !page.more || page.next_cursor.as_deref() != Some(cursor),
94 "Group metadata made no cursor progress"
95 );
96 Ok(page)
97 }
98 #[doc(hidden)]
102 pub(crate) fn lookup_contacts_raw_snapshot(
103 &self,
104 state: &mut AccountState,
105 ids: &[String],
106 ) -> Result<Vec<u8>> {
107 let request = wire::contact_request(state, ids)?;
108 let raw =
109 self.authenticated_rpc(state, 182, "/cgi-bin/micromsg-bin/getcontact", &request)?;
110 ensure!(
111 raw.len() <= crate::MAX_MESSAGE_BYTES,
112 "Contact response exceeds bound"
113 );
114 Ok(raw)
115 }
116 #[doc(hidden)]
117 pub(crate) fn lookup_contacts_receipt_snapshot(
118 &self,
119 state: &mut AccountState,
120 ids: &[String],
121 ) -> Result<MetadataReply<ContactLookup>> {
122 let raw = self.lookup_contacts_raw_snapshot(state, ids)?;
123 Ok(MetadataReply {
124 value: wire::decode_contacts(&raw, ids)?,
125 raw,
126 })
127 }
128 #[doc(hidden)]
129 pub(crate) fn lookup_room_receipt_snapshot(
130 &self,
131 state: &mut AccountState,
132 id: &str,
133 version: u32,
134 ) -> Result<MetadataReply<RoomRoster>> {
135 let raw = self.lookup_room_raw_snapshot(state, id, version)?;
136 Ok(MetadataReply {
137 value: wire::decode_room(&raw, id)?,
138 raw,
139 })
140 }
141 #[doc(hidden)]
142 pub(crate) fn lookup_room_raw_snapshot(
143 &self,
144 state: &mut AccountState,
145 id: &str,
146 version: u32,
147 ) -> Result<Vec<u8>> {
148 let request = wire::room_request(state, id, version)?;
149 self.authenticated_rpc(
150 state,
151 551,
152 "/cgi-bin/micromsg-bin/getchatroommemberdetail",
153 &request,
154 )
155 }
156 #[doc(hidden)]
157 pub(crate) fn init_contacts_receipt_snapshot(
158 &self,
159 state: &mut AccountState,
160 a: u32,
161 b: u32,
162 ) -> Result<MetadataReply<InitContactPage>> {
163 let request = wire::init_contacts_request(&state.own_username, a, b)?;
164 let raw =
165 self.authenticated_rpc(state, 851, "/cgi-bin/micromsg-bin/initcontact", &request)?;
166 let value = wire::decode_init_contacts(&raw)?;
167 ensure!(
168 !value.more || value.contact_sequence != a || value.room_sequence != b,
169 "Contact bootstrap made no cursor progress"
170 );
171 Ok(MetadataReply { value, raw })
172 }
173}
174#[cfg(test)]
175mod tests {
176 use super::*;
177 #[test]
178 fn group_cursor_is_raw_and_control_presence_is_optional() {
179 let raw = p::message(&[p::bytes(1, &p::uint(1, 0)), p::bytes(3, &[0, 255, 1])]).unwrap();
180 let page = decode_group_inventory(&raw).unwrap();
181 assert_eq!(page.next_cursor, Some(vec![0, 255, 1]));
182 assert!(!page.more);
183 assert_eq!(page.wait_seconds, 0);
184 assert_eq!(page.raw, raw);
185 let bad = p::message(&[p::bytes(1, &p::uint(1, 0)), p::bytes(4, &p::uint(1, 1))]).unwrap();
186 assert!(decode_group_inventory(&bad).is_err());
187 }
188 #[test]
189 fn rejection_does_not_require_success_fields() {
190 assert!(decode_group_inventory(&p::bytes(1, &p::int32(1, -13)))
191 .err()
192 .unwrap()
193 .to_string()
194 .contains("-13"));
195 }
196}