Skip to main content

wechat_protocol/calls/
personal.rs

1//! Personal-call request codecs. Preparation performs no transport or account I/O.
2//!
3//! Host requests and Cloud requests use different envelopes. SDK task identifiers
4//! are not host BaseRequest identifiers. The caller supplies current authenticated
5//! context, advertised capabilities and device metadata; this module invents none.
6
7use 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/// Host operation identity. Inner Cloud command IDs are a different namespace.
16#[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
47/// Encoded inner host operation. It does not imply authorization to dispatch.
48/// Bodies may contain private identities and are deliberately not Debug.
49pub 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    /// Wrap with a separately prepared host BaseRequest. This never rewrites its
62    /// task field using `sdk_task`.
63    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
73/// Caller-supplied, selected direct-voice request settings. Nested protobufs are
74/// checked for their known wire types while unknown fields remain byte-identical.
75pub 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
194/// Prepare one direct voice invitation. `invite_id` identifies the original
195/// intent and is never allocated from a wall clock by this codec. An absent
196/// custom auth value stays absent, distinct from an invalid empty value.
197pub 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
233/// Cancel only the still-pending recipients of this original invitation.
234/// Preserve source traversal order and duplicates; membership/role/timer checks
235/// are the session owner's responsibility before constructing this request.
236pub 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    /// Direct InviteTimeout sends this lower-layer wire reason, bypassing the
285    /// ordinary SDK OnCancel mapping.
286    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
301/// Prepare one caller LiveSync. `timeout_seconds` is source-selected (3..50),
302/// distinct from the outer request deadline. Cookies remain uncommitted until
303/// the owner has handled the entire response batch.
304pub 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/// Owned room correlation supplied only after the matching Join/Invite reply.
329/// Member zero is valid. Room/key are private and deliberately not Debug.
330#[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
346/// Ringing ACK type1 for the selected incoming voice role. This is not Join.
347pub 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}
384/// Decline an already-ACKed callee with source Reject reason1. Pre-ACK busy uses
385/// a different operation and is not implied by this builder.
386pub 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
404/// Prepare callee Cloud Join3361. The caller obtains its context from Invite and
405/// must not manufacture a callee Join. Timestamp is an independently selected
406/// wire value; this codec does not assume its clock or unit.
407pub 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/// Remote-last-member cleanup uses a distinct source table from local Hangup.
444#[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
460/// Prepare joined Cloud Exit3380. Source reason numbers belong to the selected
461/// SDK, not local HTTP/CLI enums. The caller must establish native talk-success
462/// state separately; a joined roster or decoded frame is insufficient evidence.
463/// Required reliable peer notices, when selected, are a separate operation.
464pub 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}
480/// Clean up an admitted remote-terminal roster once. The owner must stop media
481/// first and retain uncertainty if the correlated reply is lost.
482pub 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
518/// Wrap an inner Cloud request using its separate app BaseRequest. This returns
519/// IlinkRequestInfo bytes, not host CommonRequest or a packed app-task frame.
520pub 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
545/// Raw caller response, distinct from the callee Join response. Decode after
546/// host CommonResponse authentication and success; it does not install a room.
547/// Secret room values and original fields deliberately have no Debug output.
548pub 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
613/// A complete caller-sync reply. A decoder preserves unfamiliar items; the
614/// account owner must handle all supported effects before committing `cookies`.
615/// An unknown item is not evidence that advancing the cursor is safe.
616pub 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
656/// Caller client context retains original Strategy separately from later current
657/// capability/AV snapshots. Retry seconds are not IM mode or a sync deadline.
658pub 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}