1use super::signaling::{self, CallOperation, CloudRequest, CommonRequest};
8use crate::protobuf::{self as p, Field, Value};
9use anyhow::{bail, ensure, Result};
10
11const MAX_BODY: usize = 64 * 1024;
12const MAX_NESTED: usize = 16 * 1024;
13const MAX_MEMBERS: usize = 16;
14
15#[derive(Clone, Copy, Debug, PartialEq, Eq)]
17pub enum HostOperation {
18 RingingAck,
19 Invite,
20 ConferenceAddMembers,
21 Cancel,
22 LiveSync,
23}
24
25impl HostOperation {
26 pub const fn command(self) -> u16 {
27 match self {
28 Self::RingingAck => 8069,
29 Self::Invite => 10342,
30 Self::ConferenceAddMembers => 10857,
31 Self::Cancel => 9332,
32 Self::LiveSync => 9262,
33 }
34 }
35
36 pub const fn path(self) -> &'static str {
37 match self {
38 Self::RingingAck => "/cgi-bin/micromsg-bin/voipilinkack",
39 Self::Invite => "/cgi-bin/micromsg-bin/voipilinkinvite",
40 Self::ConferenceAddMembers => "/cgi-bin/micromsg-bin/voipilinkaddmember",
41 Self::Cancel => "/cgi-bin/micromsg-bin/voipilinkcancel",
42 Self::LiveSync => "/cgi-bin/micromsg-bin/voipilinklivesync",
43 }
44 }
45}
46
47pub struct HostRequest {
50 pub operation: HostOperation,
51 pub sdk_task: u32,
52 pub(super) body: Vec<u8>,
53 pub longpoll_seconds: Option<u32>,
54}
55
56impl HostRequest {
57 pub fn body(&self) -> &[u8] {
58 &self.body
59 }
60
61 pub fn common(&self, host_base: Vec<u8>) -> Result<Vec<u8>> {
64 CommonRequest {
65 base_request: Some(host_base),
66 body: Some(self.body.clone()),
67 unknown_fields: vec![],
68 }
69 .encode()
70 }
71}
72
73pub struct VoiceInputs<'a> {
76 pub sdk: &'a [u8],
77 pub group: &'a [u8],
78 pub device: &'a [u8],
79 pub engine_capability: &'a [u8],
80 pub channel_capability: &'a [u8],
81 pub network_type: u32,
82 pub sim_type: u32,
83 pub video_length: u32,
84 pub video_ratio: u32,
85 pub nics: &'a [Vec<u8>],
86}
87
88impl VoiceInputs<'_> {
89 pub fn validate(&self) -> Result<()> {
90 self.checked().map(|_| ())
91 }
92
93 fn checked(&self) -> Result<(u32, Vec<u8>, Vec<u8>)> {
94 self.checked_context(b"voip-2p")
95 }
96
97 fn checked_context(&self, sub_app: &[u8]) -> Result<(u32, Vec<u8>, Vec<u8>)> {
98 ensure!(
99 self.network_type < 8 && self.nics.len() <= 8,
100 "Unsupported voice input configuration"
101 );
102 let sdk = fields(self.sdk)?;
103 let version = required_u32(&sdk, 1)?;
104 let owner_version = required_bytes(&sdk, 2)?;
105 text(owner_version, 128, true)?;
106 let group = fields(self.group)?;
107 ensure!(
108 required_bytes(&group, 1)? == b"wechat",
109 "Unsupported call application"
110 );
111 required_u64(&group, 2)?;
112 ensure!(
113 required_bytes(&group, 3)? == sub_app,
114 "Unsupported call target kind"
115 );
116 text(required_bytes(&group, 4)?, 1024, false)?;
117 ensure!(
118 required_u32(&group, 5)? <= 1,
119 "Unsupported personal call mode"
120 );
121 let owner_group = required_bytes(&group, 6)?;
122 text(owner_group, 1024, false)?;
123 required_u32(&group, 7)?;
124 let device = fields(self.device)?;
125 for n in [1, 2, 3, 4, 5, 9] {
126 if let Some(v) = p::optional_data(&device, n)? {
127 text(v, 1024, false)?;
128 }
129 }
130 for n in [7, 8] {
131 signaling::optional_u32(&device, n)?;
132 }
133 p::optional_data(&device, 6)?;
134 for value in [self.engine_capability, self.channel_capability] {
135 ensure!(
136 !value.is_empty() && value.len() <= MAX_NESTED,
137 "Invalid call capability size"
138 );
139 }
140 for nic in self.nics {
141 ensure!(nic.len() <= 2048, "Call NIC description too large");
142 fields(nic)?;
143 }
144 Ok((version, owner_version.to_vec(), owner_group.to_vec()))
145 }
146
147 fn client_info(&self) -> Result<Vec<u8>> {
148 let (version, owner_version, _) = self.checked()?;
149 self.encode_client_info(version, &owner_version)
150 }
151
152 pub(super) fn conference_client_info(&self, group_id: &str) -> Result<Vec<u8>> {
153 let (version, owner_version, owner_group) = self.checked_context(b"voip-mt")?;
154 let group = fields(self.group)?;
155 ensure!(
156 required_u32(&group, 5)? == 1
157 && required_bytes(&group, 4)?.is_empty()
158 && owner_group == group_id.as_bytes(),
159 "Conference creation context mismatch"
160 );
161 self.encode_client_info(version, &owner_version)
162 }
163
164 pub(super) fn validate_conference_context(&self) -> Result<()> {
165 self.checked_context(b"voip-mt")?;
166 ensure!(
167 required_u32(&fields(self.group)?, 5)? == 1,
168 "Unsupported conference mode"
169 );
170 Ok(())
171 }
172
173 fn encode_client_info(&self, version: u32, owner_version: &[u8]) -> Result<Vec<u8>> {
174 let capabilities = message(&[
175 p::bytes(1, self.engine_capability),
176 p::bytes(2, self.channel_capability),
177 ])?;
178 let mut values = vec![
179 p::uint(1, u64::from(version)),
180 p::bytes(2, owner_version),
181 p::uint(3, u64::from(self.network_type)),
182 p::uint(4, 1),
183 p::bytes(5, &capabilities),
184 p::bytes(6, self.device),
185 p::uint(7, u64::from(self.video_length)),
186 p::uint(8, u64::from(self.video_ratio)),
187 ];
188 values.extend(self.nics.iter().map(|nic| p::bytes(9, nic)));
189 values.push(p::uint(10, u64::from(self.sim_type)));
190 message(&values)
191 }
192}
193
194pub fn invite(
198 inputs: &VoiceInputs<'_>,
199 peer: &str,
200 invite_id: u64,
201 sdk_task: u32,
202 custom_auth: Option<&[u8]>,
203) -> Result<HostRequest> {
204 text(peer.as_bytes(), 128, true)?;
205 ensure!(
206 invite_id != 0 && sdk_task != 0,
207 "Missing call intent or task"
208 );
209 let (_, _, owner_group) = inputs.checked()?;
210 let mut values = vec![
211 p::bytes(1, peer.as_bytes()),
212 p::uint(2, 2),
213 p::bytes(3, &owner_group),
214 p::bytes(4, &inputs.client_info()?),
215 p::uint(5, invite_id),
216 ];
217 if let Some(auth) = custom_auth {
218 ensure!(
219 !auth.is_empty() && auth.len() <= 8192,
220 "Invalid custom call authorization"
221 );
222 values.push(p::bytes(6, auth));
223 }
224 values.push(p::bytes(7, b"voip-2p"));
225 Ok(HostRequest {
226 operation: HostOperation::Invite,
227 sdk_task,
228 body: message(&values)?,
229 longpoll_seconds: None,
230 })
231}
232
233pub fn cancel(
237 inputs: &VoiceInputs<'_>,
238 room: u64,
239 room_key: u64,
240 invite_id: u64,
241 pending_recipients: &[String],
242 reason: CancelReason,
243 sdk_task: u32,
244) -> Result<HostRequest> {
245 inputs.checked()?;
246 ensure!(
247 invite_id != 0 && sdk_task != 0 && (room == 0) == (room_key == 0),
248 "Invalid cancellation context"
249 );
250 ensure!(
251 !pending_recipients.is_empty() && pending_recipients.len() <= 8,
252 "Invalid pending recipient count"
253 );
254 for peer in pending_recipients {
255 text(peer.as_bytes(), 128, true)?;
256 }
257 let inner = message(&[
258 p::bytes(1, inputs.sdk),
259 p::bytes(2, inputs.group),
260 p::uint(3, room),
261 p::uint(4, room_key),
262 p::uint(5, invite_id),
263 p::uint(6, reason.wire()),
264 ])?;
265 let mut outer = vec![p::bytes(1, &inner), p::uint(2, invite_id), p::uint(3, room)];
266 outer.extend(
267 pending_recipients
268 .iter()
269 .map(|name| p::bytes(4, name.as_bytes())),
270 );
271 outer.push(p::bytes(5, b"voip-2p"));
272 Ok(HostRequest {
273 operation: HostOperation::Cancel,
274 sdk_task,
275 body: message(&outer)?,
276 longpoll_seconds: None,
277 })
278}
279
280#[derive(Clone, Copy, Debug, PartialEq, Eq)]
281pub enum CancelReason {
282 Local,
283 Timeout,
284 NoResponse,
287 Other,
288}
289
290impl CancelReason {
291 const fn wire(self) -> u64 {
292 match self {
293 Self::Local => 1,
294 Self::Timeout => 4,
295 Self::NoResponse => 2,
296 Self::Other => 0,
297 }
298 }
299}
300
301pub fn live_sync(
305 live_id: u64,
306 cookies: &[u8],
307 timeout_seconds: u32,
308 sdk_task: u32,
309) -> Result<HostRequest> {
310 ensure!(
311 live_id != 0 && sdk_task != 0 && (3..=50).contains(&timeout_seconds),
312 "Invalid call sync context"
313 );
314 ensure!(cookies.len() <= MAX_NESTED, "Call sync cookie too large");
315 Ok(HostRequest {
316 operation: HostOperation::LiveSync,
317 sdk_task,
318 body: message(&[
319 p::uint(1, live_id),
320 p::bytes(2, cookies),
321 p::bytes(4, b"voip-2p"),
322 p::uint(5, u64::from(timeout_seconds)),
323 ])?,
324 longpoll_seconds: Some(timeout_seconds + 5),
325 })
326}
327
328#[derive(Clone, Copy, PartialEq, Eq)]
331pub struct VoiceRoom {
332 pub room: u64,
333 pub room_key: u64,
334 pub own_member: u32,
335}
336impl VoiceRoom {
337 fn validate(self) -> Result<()> {
338 ensure!(
339 self.room != 0 && self.room_key != 0,
340 "Unallocated call room"
341 );
342 Ok(())
343 }
344}
345
346pub fn acknowledge_voice(
348 inputs: &VoiceInputs<'_>,
349 room: VoiceRoom,
350 sdk_task: u32,
351) -> Result<HostRequest> {
352 inputs.checked()?;
353 room.validate()?;
354 ensure!(sdk_task != 0, "Missing incoming ACK task");
355 let caps = message(&[
356 p::bytes(1, inputs.engine_capability),
357 p::bytes(2, inputs.channel_capability),
358 ])?;
359 let mut values = vec![
360 p::bytes(1, inputs.sdk),
361 p::bytes(2, inputs.group),
362 p::uint(3, u64::from(inputs.network_type)),
363 p::uint(4, 1),
364 p::uint(5, room.room),
365 p::uint(6, room.room_key),
366 p::uint(7, u64::from(room.own_member)),
367 ];
368 values.extend(inputs.nics.iter().map(|nic| p::bytes(8, nic)));
369 values.extend([
370 p::uint(9, u64::from(inputs.sim_type)),
371 p::bytes(11, inputs.device),
372 p::bytes(12, &caps),
373 p::uint(13, 1),
374 p::uint(14, u64::from(inputs.video_length)),
375 p::uint(15, u64::from(inputs.video_ratio)),
376 ]);
377 Ok(HostRequest {
378 operation: HostOperation::RingingAck,
379 sdk_task,
380 body: message(&[p::bytes(1, &message(&values)?), p::bytes(3, b"voip-2p")])?,
381 longpoll_seconds: None,
382 })
383}
384pub fn reject(inputs: &VoiceInputs<'_>, room: VoiceRoom, sdk_task: u32) -> Result<CloudRequest> {
387 inputs.checked()?;
388 room.validate()?;
389 ensure!(sdk_task != 0, "Missing Reject task");
390 Ok(CloudRequest::for_operation(
391 sdk_task,
392 CallOperation::Reject,
393 message(&[
394 p::bytes(1, inputs.sdk),
395 p::bytes(2, inputs.group),
396 p::uint(3, room.room),
397 p::uint(4, room.room_key),
398 p::uint(5, u64::from(room.own_member)),
399 p::uint(6, 1),
400 ])?,
401 ))
402}
403
404pub fn join(
408 inputs: &VoiceInputs<'_>,
409 room: VoiceRoom,
410 timestamp: u64,
411 sdk_task: u32,
412) -> Result<CloudRequest> {
413 inputs.checked()?;
414 room.validate()?;
415 ensure!(sdk_task != 0, "Missing call task");
416 let capabilities = message(&[
417 p::bytes(1, inputs.engine_capability),
418 p::bytes(2, inputs.channel_capability),
419 ])?;
420 let mut values = vec![
421 p::bytes(1, inputs.sdk),
422 p::bytes(2, inputs.group),
423 p::uint(3, u64::from(inputs.network_type)),
424 p::bytes(4, &capabilities),
425 p::uint(5, 2),
426 p::uint(6, 1),
427 p::bytes(7, inputs.device),
428 p::uint(8, timestamp),
429 p::uint(9, u64::from(inputs.video_length)),
430 p::uint(10, u64::from(inputs.video_ratio)),
431 p::uint(11, room.room),
432 p::uint(12, room.room_key),
433 ];
434 values.extend(inputs.nics.iter().map(|nic| p::bytes(13, nic)));
435 values.push(p::uint(14, u64::from(inputs.sim_type)));
436 Ok(CloudRequest::for_operation(
437 sdk_task,
438 CallOperation::Join,
439 message(&values)?,
440 ))
441}
442
443#[derive(Clone, Copy, Debug, PartialEq, Eq)]
445pub enum RemoteExitReason {
446 LastPeerLeft,
447 PeerBusy,
448 PeerRejected,
449}
450impl RemoteExitReason {
451 pub const fn wire(self) -> u64 {
452 match self {
453 Self::LastPeerLeft => 5,
454 Self::PeerBusy => 7,
455 Self::PeerRejected => 6,
456 }
457 }
458}
459
460pub fn exit(
465 inputs: &VoiceInputs<'_>,
466 room: VoiceRoom,
467 source_reason: u32,
468 talk_success: bool,
469 sdk_task: u32,
470) -> Result<CloudRequest> {
471 inputs.checked()?;
472 room.validate()?;
473 ensure!(sdk_task != 0, "Missing call task");
474 let mapped = [1, 0, 0, 0, 0, 8, 9, 10, 0, 5]
475 .get(source_reason.wrapping_sub(1) as usize)
476 .copied()
477 .unwrap_or(0);
478 exit_with_wire(inputs, room, mapped, talk_success, sdk_task)
479}
480pub fn exit_remote(
483 inputs: &VoiceInputs<'_>,
484 room: VoiceRoom,
485 reason: RemoteExitReason,
486 talk_success: bool,
487 sdk_task: u32,
488) -> Result<CloudRequest> {
489 inputs.checked()?;
490 room.validate()?;
491 ensure!(sdk_task != 0, "Missing call task");
492 exit_with_wire(inputs, room, reason.wire(), talk_success, sdk_task)
493}
494fn exit_with_wire(
495 inputs: &VoiceInputs<'_>,
496 room: VoiceRoom,
497 mapped: u64,
498 talk_success: bool,
499 sdk_task: u32,
500) -> Result<CloudRequest> {
501 let body = message(&[
502 p::bytes(1, inputs.sdk),
503 p::bytes(2, inputs.group),
504 p::uint(3, room.room),
505 p::uint(4, room.room_key),
506 p::uint(5, u64::from(room.own_member)),
507 p::uint(6, mapped),
508 p::uint(7, u64::from(inputs.network_type)),
509 p::uint(8, u64::from(!talk_success)),
510 ])?;
511 Ok(CloudRequest::for_operation(
512 sdk_task,
513 CallOperation::Exit,
514 body,
515 ))
516}
517
518pub fn cloud_request_info(request: &CloudRequest, cloud_base: &[u8]) -> Result<Vec<u8>> {
521 let operation = request.operation()?;
522 let base = fields(cloud_base)?;
523 required_u64(&base, 1)?;
524 ensure!(
525 required_bytes(&base, 2)?.len() <= 128,
526 "Cloud device identity too large"
527 );
528 let signed = required_u64(&base, 3)? as i64;
529 i32::try_from(signed)?;
530 let body = request
531 .body
532 .as_deref()
533 .ok_or_else(|| anyhow::anyhow!("Missing Cloud call body"))?;
534 let cloud = message(&[p::bytes(1, cloud_base), p::bytes(2, body)])?;
535 message(&[
536 p::uint(1, u64::from(operation.command_id())),
537 p::bytes(2, operation.path().as_bytes()),
538 p::bytes(3, &cloud),
539 p::uint(5, 1),
540 p::uint(6, 1),
541 p::uint(7, 1),
542 ])
543}
544
545pub struct InviteResponse {
549 pub room: u64,
550 pub room_key: u64,
551 pub own_member: u32,
552 pub group_id: String,
553 pub client_response: Vec<u8>,
554 pub custom_auth: Option<Vec<u8>>,
555 pub invite_results: Vec<(String, u32)>,
556 pub original: Vec<u8>,
557 pub unknown_fields: Vec<Field>,
558}
559
560impl InviteResponse {
561 pub fn decode(input: &[u8]) -> Result<Self> {
562 let values = fields(input)?;
563 let room = required_u64(&values, 1)?;
564 let room_key = required_u64(&values, 2)?;
565 ensure!(room != 0 && room_key != 0, "Unallocated caller room");
566 let group = required_bytes(&values, 4)?;
567 text(group, 1024, true)?;
568 let client_response = required_bytes(&values, 5)?;
569 ensure!(
570 !client_response.is_empty(),
571 "Missing caller client response"
572 );
573 let mut results = Vec::new();
574 for value in values.iter().filter(|value| value.number == 8) {
575 ensure!(
576 results.len() < MAX_MEMBERS,
577 "Too many call invitation results"
578 );
579 let nested = fields(field_bytes(value)?)?;
580 let name = required_bytes(&nested, 1)?;
581 text(name, 128, true)?;
582 results.push((
583 String::from_utf8(name.to_vec())?,
584 signaling::optional_u32(&nested, 2)?.unwrap_or(0),
585 ));
586 }
587 let users = values
588 .iter()
589 .filter(|value| value.number == 6)
590 .collect::<Vec<_>>();
591 ensure!(users.len() <= MAX_MEMBERS, "Too many call user mappings");
592 for user in users {
593 fields(field_bytes(user)?)?;
594 }
595 if let Some(url) = p::optional_data(&values, 9)? {
596 text(url, 8192, false)?;
597 }
598 signaling::optional_u32(&values, 10)?;
599 Ok(Self {
600 room,
601 room_key,
602 own_member: required_u32(&values, 3)?,
603 group_id: String::from_utf8(group.to_vec())?,
604 client_response: client_response.to_vec(),
605 custom_auth: p::optional_data(&values, 7)?.map(Vec::from),
606 invite_results: results,
607 original: input.to_vec(),
608 unknown_fields: signaling::unknown_fields(values, 10),
609 })
610 }
611}
612
613pub struct LiveSyncResponse {
617 pub items: Vec<LiveSyncItem>,
618 pub cookies: Option<Vec<u8>>,
619 pub original: Vec<u8>,
620 pub unknown_fields: Vec<Field>,
621}
622
623pub struct LiveSyncItem {
624 pub kind: i32,
625 pub body: Vec<u8>,
626 pub original: Vec<u8>,
627 pub unknown_fields: Vec<Field>,
628}
629
630impl LiveSyncResponse {
631 pub fn decode(input: &[u8]) -> Result<Self> {
632 let values = fields(input)?;
633 let mut items = Vec::new();
634 for value in values.iter().filter(|v| v.number == 1) {
635 ensure!(items.len() < 256, "Too many call sync items");
636 let raw = field_bytes(value)?;
637 let nested = fields(raw)?;
638 let kind = i32::try_from(required_u64(&nested, 1)? as i64)?;
639 let body = required_bytes(&nested, 2)?.to_vec();
640 items.push(LiveSyncItem {
641 kind,
642 body,
643 original: raw.to_vec(),
644 unknown_fields: signaling::unknown_fields(nested, 2),
645 });
646 }
647 Ok(Self {
648 items,
649 cookies: p::optional_data(&values, 2)?.map(Vec::from),
650 original: input.to_vec(),
651 unknown_fields: signaling::unknown_fields(values, 2),
652 })
653 }
654}
655
656pub struct JoinClientResponse {
659 pub strategy: Vec<u8>,
660 pub members: Vec<u8>,
661 pub av_status: Option<Vec<u8>>,
662 pub live_id: u64,
663 pub cookies: Vec<u8>,
664 pub retry_seconds: Option<u32>,
665 pub original: Vec<u8>,
666}
667
668impl JoinClientResponse {
669 pub fn decode(input: &[u8]) -> Result<Self> {
670 let values = fields(input)?;
671 let strategy = required_bytes(&values, 1)?;
672 let members = required_bytes(&values, 2)?;
673 ensure!(
674 !strategy.is_empty() && !members.is_empty(),
675 "Missing caller room negotiation"
676 );
677 fields(strategy)?;
678 fields(members)?;
679 for n in [3, 4] {
680 if let Some(raw) = p::optional_data(&values, n)? {
681 fields(raw)?;
682 }
683 }
684 for n in [7, 8, 10] {
685 signaling::optional_u32(&values, n)?;
686 }
687 for value in values.iter().filter(|value| value.number == 9) {
688 fields(field_bytes(value)?)?;
689 }
690 let live_id = required_u64(&values, 5)?;
691 ensure!(live_id != 0, "Missing caller live identity");
692 Ok(Self {
693 strategy: strategy.to_vec(),
694 members: members.to_vec(),
695 av_status: p::optional_data(&values, 3)?.map(Vec::from),
696 live_id,
697 cookies: required_bytes(&values, 6)?.to_vec(),
698 retry_seconds: signaling::optional_u32(&values, 7)?,
699 original: input.to_vec(),
700 })
701 }
702}
703
704fn message(parts: &[Vec<u8>]) -> Result<Vec<u8>> {
705 let value = p::message(parts)?;
706 ensure!(value.len() <= MAX_BODY, "Personal call body too large");
707 Ok(value)
708}
709fn fields(input: &[u8]) -> Result<Vec<Field>> {
710 ensure!(input.len() <= MAX_BODY, "Personal call body too large");
711 signaling::decode_fields(input)
712}
713fn required_bytes(values: &[Field], number: u32) -> Result<&[u8]> {
714 p::optional_data(values, number)?
715 .ok_or_else(|| anyhow::anyhow!("Missing call bytes field {number}"))
716}
717fn required_u64(values: &[Field], number: u32) -> Result<u64> {
718 match p::optional(values, number)? {
719 Some(Value::Varint(v)) => Ok(*v),
720 _ => bail!("Missing or invalid call integer field {number}"),
721 }
722}
723fn required_u32(values: &[Field], number: u32) -> Result<u32> {
724 Ok(u32::try_from(required_u64(values, number)?)?)
725}
726fn field_bytes(field: &Field) -> Result<&[u8]> {
727 match &field.value {
728 Value::Bytes(value) => Ok(value),
729 _ => bail!("Invalid call bytes field {}", field.number),
730 }
731}
732fn text(value: &[u8], maximum: usize, nonempty: bool) -> Result<()> {
733 ensure!(
734 value.len() <= maximum && (!nonempty || !value.is_empty()) && !value.contains(&0),
735 "Invalid call text"
736 );
737 std::str::from_utf8(value)?;
738 Ok(())
739}
740
741#[cfg(test)]
742mod tests {
743 use super::*;
744
745 #[test]
746 fn full_sync_preserves_later_unknown_item_and_cookie_presence() {
747 let first = message(&[p::uint(1, 1), p::bytes(2, b"a")]).unwrap();
748 let later = message(&[p::int32(1, -1), p::bytes(2, b"b"), p::uint(99, 7)]).unwrap();
749 let wire = message(&[p::bytes(1, &first), p::bytes(1, &later), p::bytes(2, &[])]).unwrap();
750 let result = LiveSyncResponse::decode(&wire).unwrap();
751 assert_eq!(result.items.len(), 2);
752 assert_eq!(result.items[1].kind, -1);
753 assert_eq!(result.items[1].unknown_fields.len(), 1);
754 assert_eq!(result.cookies, Some(vec![]));
755 assert!(LiveSyncResponse::decode(&[]).unwrap().cookies.is_none());
756 let bad = message(&[p::bytes(1, &[8, 1, 8, 2, 18, 0])]).unwrap();
757 assert!(LiveSyncResponse::decode(&bad).is_err());
758 }
759
760 #[test]
761 fn caller_response_keeps_retry_separate_and_requires_full_widths() {
762 let client = message(&[
763 p::bytes(1, &[8, 1]),
764 p::bytes(2, &[8, 0]),
765 p::uint(5, 9),
766 p::bytes(6, &[]),
767 p::uint(7, 3),
768 ])
769 .unwrap();
770 let result = JoinClientResponse::decode(&client).unwrap();
771 assert_eq!(result.live_id, 9);
772 assert_eq!(result.retry_seconds, Some(3));
773 let mut bad = client.clone();
774 bad.extend(p::uint(7, 4));
775 assert!(JoinClientResponse::decode(&bad).is_err());
776 let mut response = message(&[
777 p::uint(1, 10),
778 p::uint(2, u64::MAX),
779 p::uint(3, 0),
780 p::bytes(4, b"g"),
781 p::bytes(5, &client),
782 p::bytes(7, b"auth"),
783 p::uint(100, 1),
784 ])
785 .unwrap();
786 let result = InviteResponse::decode(&response).unwrap();
787 assert_eq!(result.own_member, 0);
788 assert_eq!(result.room_key, u64::MAX);
789 assert_eq!(result.unknown_fields.len(), 1);
790 assert_eq!(result.original, response);
791 response.extend(p::uint(3, u64::MAX));
792 assert!(InviteResponse::decode(&response).is_err());
793 for (nested, expected) in [
794 (p::bytes(1, b"peer"), 0),
795 (message(&[p::bytes(1, b"peer"), p::uint(2, 7)]).unwrap(), 7),
796 ] {
797 let wire = message(&[
798 p::uint(1, 7),
799 p::uint(2, 9),
800 p::uint(3, 0),
801 p::bytes(4, b"group"),
802 p::bytes(5, &[8, 1]),
803 p::bytes(8, &nested),
804 ])
805 .unwrap();
806 assert_eq!(
807 InviteResponse::decode(&wire).unwrap().invite_results[0].1,
808 expected
809 );
810 }
811 let bad = message(&[
812 p::uint(1, 7),
813 p::uint(2, 9),
814 p::uint(3, 0),
815 p::bytes(4, b"group"),
816 p::bytes(5, &[8, 1]),
817 p::bytes(
818 8,
819 &message(&[p::bytes(1, b"peer"), p::bytes(2, &[])]).unwrap(),
820 ),
821 ])
822 .unwrap();
823 assert!(InviteResponse::decode(&bad).is_err());
824 }
825}