fidl_fuchsia_posix_socket_packet__common/
fidl_fuchsia_posix_socket_packet__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11/// A network-layer protocol (above link-layer).
12///
13/// Values are defined by
14/// https://www.iana.org/assignments/ieee-802-numbers/ieee-802-numbers.xhtml.
15pub type Protocol = u16;
16
17pub const SOCKET_PROTOCOL_NAME: &str = "fuchsia.posix.socket.packet/Socket";
18
19/// The type of a hardware.
20#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
21#[repr(u32)]
22pub enum HardwareType {
23    /// Hardware that operates only at the network layer; a pure L3 interface.
24    ///
25    /// Hardware of this type have no L2 headers/addressing.
26    NetworkOnly = 1,
27    /// Hardware that operates on ethernet-based links.
28    Ethernet = 2,
29    /// Hardware that loops back packets.
30    Loopback = 3,
31}
32
33impl HardwareType {
34    #[inline]
35    pub fn from_primitive(prim: u32) -> Option<Self> {
36        match prim {
37            1 => Some(Self::NetworkOnly),
38            2 => Some(Self::Ethernet),
39            3 => Some(Self::Loopback),
40            _ => None,
41        }
42    }
43
44    #[inline]
45    pub const fn into_primitive(self) -> u32 {
46        self as u32
47    }
48}
49
50/// A kind of packet socket.
51#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
52#[repr(u32)]
53pub enum Kind {
54    /// A packet socket that operates with network-layer packets.
55    Network = 1,
56    /// A packet socket that operates with link-layer packets.
57    ///
58    /// Packets are passed unmodified between the wire and client when the
59    /// packet socket is of this kind.
60    Link = 2,
61}
62
63impl Kind {
64    #[inline]
65    pub fn from_primitive(prim: u32) -> Option<Self> {
66        match prim {
67            1 => Some(Self::Network),
68            2 => Some(Self::Link),
69            _ => None,
70        }
71    }
72
73    #[inline]
74    pub const fn into_primitive(self) -> u32 {
75        self as u32
76    }
77}
78
79/// The type of a packet.
80#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
81#[repr(u32)]
82pub enum PacketType {
83    /// A packet that arrived at its destination.
84    Host = 1,
85    /// A packet that was broadcasted.
86    Broadcast = 2,
87    /// A packet that was multicasted.
88    Multicast = 3,
89    /// A packet that arrived at a host that isn't its destination.
90    OtherHost = 4,
91    /// A packet that is being sent on a local interface, regardless of how it
92    /// is being sent (unicasted, multicasted, broadcasted).
93    Outgoing = 5,
94}
95
96impl PacketType {
97    #[inline]
98    pub fn from_primitive(prim: u32) -> Option<Self> {
99        match prim {
100            1 => Some(Self::Host),
101            2 => Some(Self::Broadcast),
102            3 => Some(Self::Multicast),
103            4 => Some(Self::OtherHost),
104            5 => Some(Self::Outgoing),
105            _ => None,
106        }
107    }
108
109    #[inline]
110    pub const fn into_primitive(self) -> u32 {
111        self as u32
112    }
113}
114
115#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
116pub struct Empty;
117
118impl fidl::Persistable for Empty {}
119
120/// An interface's properties.
121#[derive(Clone, Debug, PartialEq)]
122pub struct InterfaceProperties {
123    /// The interface's ID.
124    pub id: u64,
125    /// The interface's hardware address.
126    pub addr: HardwareAddress,
127    /// The interface's hardware type.
128    pub type_: HardwareType,
129}
130
131impl fidl::Persistable for InterfaceProperties {}
132
133/// Information about a packet.
134#[derive(Clone, Debug, PartialEq)]
135pub struct PacketInfo {
136    pub protocol: u16,
137    pub interface_id: u64,
138    pub addr: HardwareAddress,
139}
140
141impl fidl::Persistable for PacketInfo {}
142
143#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
144pub struct ProviderSocketRequest {
145    pub kind: Kind,
146}
147
148impl fidl::Persistable for ProviderSocketRequest {}
149
150#[derive(Clone, Debug, PartialEq)]
151pub struct RecvPacketInfo {
152    pub packet_info: PacketInfo,
153    pub packet_type: PacketType,
154    pub interface_type: HardwareType,
155}
156
157impl fidl::Persistable for RecvPacketInfo {}
158
159#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
160pub struct SocketBindRequest {
161    pub protocol: Option<Box<ProtocolAssociation>>,
162    pub bound_interface_id: BoundInterfaceId,
163}
164
165impl fidl::Persistable for SocketBindRequest {}
166
167#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
168pub struct SocketRecvMsgRequest {
169    pub want_packet_info: bool,
170    pub data_len: u32,
171    pub want_control: bool,
172    pub flags: fidl_fuchsia_posix_socket__common::RecvMsgFlags,
173}
174
175impl fidl::Persistable for SocketRecvMsgRequest {}
176
177#[derive(Clone, Debug, PartialEq)]
178pub struct SocketSendMsgRequest {
179    pub packet_info: Option<Box<PacketInfo>>,
180    pub data: Vec<u8>,
181    pub control: SendControlData,
182    pub flags: fidl_fuchsia_posix_socket__common::SendMsgFlags,
183}
184
185impl fidl::Persistable for SocketSendMsgRequest {}
186
187#[derive(Clone, Debug, PartialEq)]
188pub struct SocketGetInfoResponse {
189    pub kind: Kind,
190    pub protocol: Option<Box<ProtocolAssociation>>,
191    pub bound_interface: BoundInterface,
192}
193
194impl fidl::Persistable for SocketGetInfoResponse {}
195
196#[derive(Clone, Debug, PartialEq)]
197pub struct SocketRecvMsgResponse {
198    pub packet_info: Option<Box<RecvPacketInfo>>,
199    pub data: Vec<u8>,
200    pub control: RecvControlData,
201    pub truncated: u32,
202}
203
204impl fidl::Persistable for SocketRecvMsgResponse {}
205
206#[derive(Clone, Debug, Default, PartialEq)]
207pub struct RecvControlData {
208    /// Socket level ancillary data.
209    pub socket: Option<fidl_fuchsia_posix_socket__common::SocketRecvControlData>,
210    #[doc(hidden)]
211    pub __source_breaking: fidl::marker::SourceBreaking,
212}
213
214impl fidl::Persistable for RecvControlData {}
215
216#[derive(Clone, Debug, Default, PartialEq)]
217pub struct SendControlData {
218    /// Socket level ancillary data.
219    pub socket: Option<fidl_fuchsia_posix_socket__common::SocketSendControlData>,
220    #[doc(hidden)]
221    pub __source_breaking: fidl::marker::SourceBreaking,
222}
223
224impl fidl::Persistable for SendControlData {}
225
226#[derive(Clone, Debug, PartialEq)]
227pub enum BoundInterface {
228    All(Empty),
229    Specified(InterfaceProperties),
230}
231
232impl BoundInterface {
233    #[inline]
234    pub fn ordinal(&self) -> u64 {
235        match *self {
236            Self::All(_) => 1,
237            Self::Specified(_) => 2,
238        }
239    }
240}
241
242impl fidl::Persistable for BoundInterface {}
243
244#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
245pub enum BoundInterfaceId {
246    All(Empty),
247    Specified(u64),
248}
249
250impl BoundInterfaceId {
251    #[inline]
252    pub fn ordinal(&self) -> u64 {
253        match *self {
254            Self::All(_) => 1,
255            Self::Specified(_) => 2,
256        }
257    }
258}
259
260impl fidl::Persistable for BoundInterfaceId {}
261
262/// A hardware address.
263#[derive(Clone, Debug)]
264pub enum HardwareAddress {
265    /// Indicates that the hardware does not support link-layer addressing.
266    None(Empty),
267    /// An EUI-48 based address.
268    Eui48(fidl_fuchsia_net__common::MacAddress),
269    #[doc(hidden)]
270    __SourceBreaking { unknown_ordinal: u64 },
271}
272
273/// Pattern that matches an unknown `HardwareAddress` member.
274#[macro_export]
275macro_rules! HardwareAddressUnknown {
276    () => {
277        _
278    };
279}
280
281// Custom PartialEq so that unknown variants are not equal to themselves.
282impl PartialEq for HardwareAddress {
283    fn eq(&self, other: &Self) -> bool {
284        match (self, other) {
285            (Self::None(x), Self::None(y)) => *x == *y,
286            (Self::Eui48(x), Self::Eui48(y)) => *x == *y,
287            _ => false,
288        }
289    }
290}
291
292impl HardwareAddress {
293    #[inline]
294    pub fn ordinal(&self) -> u64 {
295        match *self {
296            Self::None(_) => 1,
297            Self::Eui48(_) => 2,
298            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
299        }
300    }
301
302    #[inline]
303    pub fn unknown_variant_for_testing() -> Self {
304        Self::__SourceBreaking { unknown_ordinal: 0 }
305    }
306
307    #[inline]
308    pub fn is_unknown(&self) -> bool {
309        match self {
310            Self::__SourceBreaking { .. } => true,
311            _ => false,
312        }
313    }
314}
315
316impl fidl::Persistable for HardwareAddress {}
317
318/// The protocol association for a packet socket.
319#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
320pub enum ProtocolAssociation {
321    /// An association with all protocols.
322    All(Empty),
323    /// An association with a protocol.
324    Specified(u16),
325}
326
327impl ProtocolAssociation {
328    #[inline]
329    pub fn ordinal(&self) -> u64 {
330        match *self {
331            Self::All(_) => 1,
332            Self::Specified(_) => 2,
333        }
334    }
335}
336
337impl fidl::Persistable for ProtocolAssociation {}
338
339mod internal {
340    use super::*;
341    unsafe impl fidl::encoding::TypeMarker for HardwareType {
342        type Owned = Self;
343
344        #[inline(always)]
345        fn inline_align(_context: fidl::encoding::Context) -> usize {
346            std::mem::align_of::<u32>()
347        }
348
349        #[inline(always)]
350        fn inline_size(_context: fidl::encoding::Context) -> usize {
351            std::mem::size_of::<u32>()
352        }
353
354        #[inline(always)]
355        fn encode_is_copy() -> bool {
356            true
357        }
358
359        #[inline(always)]
360        fn decode_is_copy() -> bool {
361            false
362        }
363    }
364
365    impl fidl::encoding::ValueTypeMarker for HardwareType {
366        type Borrowed<'a> = Self;
367        #[inline(always)]
368        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
369            *value
370        }
371    }
372
373    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for HardwareType {
374        #[inline]
375        unsafe fn encode(
376            self,
377            encoder: &mut fidl::encoding::Encoder<'_, D>,
378            offset: usize,
379            _depth: fidl::encoding::Depth,
380        ) -> fidl::Result<()> {
381            encoder.debug_check_bounds::<Self>(offset);
382            encoder.write_num(self.into_primitive(), offset);
383            Ok(())
384        }
385    }
386
387    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HardwareType {
388        #[inline(always)]
389        fn new_empty() -> Self {
390            Self::NetworkOnly
391        }
392
393        #[inline]
394        unsafe fn decode(
395            &mut self,
396            decoder: &mut fidl::encoding::Decoder<'_, D>,
397            offset: usize,
398            _depth: fidl::encoding::Depth,
399        ) -> fidl::Result<()> {
400            decoder.debug_check_bounds::<Self>(offset);
401            let prim = decoder.read_num::<u32>(offset);
402
403            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
404            Ok(())
405        }
406    }
407    unsafe impl fidl::encoding::TypeMarker for Kind {
408        type Owned = Self;
409
410        #[inline(always)]
411        fn inline_align(_context: fidl::encoding::Context) -> usize {
412            std::mem::align_of::<u32>()
413        }
414
415        #[inline(always)]
416        fn inline_size(_context: fidl::encoding::Context) -> usize {
417            std::mem::size_of::<u32>()
418        }
419
420        #[inline(always)]
421        fn encode_is_copy() -> bool {
422            true
423        }
424
425        #[inline(always)]
426        fn decode_is_copy() -> bool {
427            false
428        }
429    }
430
431    impl fidl::encoding::ValueTypeMarker for Kind {
432        type Borrowed<'a> = Self;
433        #[inline(always)]
434        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
435            *value
436        }
437    }
438
439    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Kind {
440        #[inline]
441        unsafe fn encode(
442            self,
443            encoder: &mut fidl::encoding::Encoder<'_, D>,
444            offset: usize,
445            _depth: fidl::encoding::Depth,
446        ) -> fidl::Result<()> {
447            encoder.debug_check_bounds::<Self>(offset);
448            encoder.write_num(self.into_primitive(), offset);
449            Ok(())
450        }
451    }
452
453    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Kind {
454        #[inline(always)]
455        fn new_empty() -> Self {
456            Self::Network
457        }
458
459        #[inline]
460        unsafe fn decode(
461            &mut self,
462            decoder: &mut fidl::encoding::Decoder<'_, D>,
463            offset: usize,
464            _depth: fidl::encoding::Depth,
465        ) -> fidl::Result<()> {
466            decoder.debug_check_bounds::<Self>(offset);
467            let prim = decoder.read_num::<u32>(offset);
468
469            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
470            Ok(())
471        }
472    }
473    unsafe impl fidl::encoding::TypeMarker for PacketType {
474        type Owned = Self;
475
476        #[inline(always)]
477        fn inline_align(_context: fidl::encoding::Context) -> usize {
478            std::mem::align_of::<u32>()
479        }
480
481        #[inline(always)]
482        fn inline_size(_context: fidl::encoding::Context) -> usize {
483            std::mem::size_of::<u32>()
484        }
485
486        #[inline(always)]
487        fn encode_is_copy() -> bool {
488            true
489        }
490
491        #[inline(always)]
492        fn decode_is_copy() -> bool {
493            false
494        }
495    }
496
497    impl fidl::encoding::ValueTypeMarker for PacketType {
498        type Borrowed<'a> = Self;
499        #[inline(always)]
500        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
501            *value
502        }
503    }
504
505    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for PacketType {
506        #[inline]
507        unsafe fn encode(
508            self,
509            encoder: &mut fidl::encoding::Encoder<'_, D>,
510            offset: usize,
511            _depth: fidl::encoding::Depth,
512        ) -> fidl::Result<()> {
513            encoder.debug_check_bounds::<Self>(offset);
514            encoder.write_num(self.into_primitive(), offset);
515            Ok(())
516        }
517    }
518
519    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PacketType {
520        #[inline(always)]
521        fn new_empty() -> Self {
522            Self::Host
523        }
524
525        #[inline]
526        unsafe fn decode(
527            &mut self,
528            decoder: &mut fidl::encoding::Decoder<'_, D>,
529            offset: usize,
530            _depth: fidl::encoding::Depth,
531        ) -> fidl::Result<()> {
532            decoder.debug_check_bounds::<Self>(offset);
533            let prim = decoder.read_num::<u32>(offset);
534
535            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
536            Ok(())
537        }
538    }
539
540    impl fidl::encoding::ValueTypeMarker for Empty {
541        type Borrowed<'a> = &'a Self;
542        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
543            value
544        }
545    }
546
547    unsafe impl fidl::encoding::TypeMarker for Empty {
548        type Owned = Self;
549
550        #[inline(always)]
551        fn inline_align(_context: fidl::encoding::Context) -> usize {
552            1
553        }
554
555        #[inline(always)]
556        fn inline_size(_context: fidl::encoding::Context) -> usize {
557            1
558        }
559    }
560
561    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Empty, D> for &Empty {
562        #[inline]
563        unsafe fn encode(
564            self,
565            encoder: &mut fidl::encoding::Encoder<'_, D>,
566            offset: usize,
567            _depth: fidl::encoding::Depth,
568        ) -> fidl::Result<()> {
569            encoder.debug_check_bounds::<Empty>(offset);
570            encoder.write_num(0u8, offset);
571            Ok(())
572        }
573    }
574
575    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Empty {
576        #[inline(always)]
577        fn new_empty() -> Self {
578            Self
579        }
580
581        #[inline]
582        unsafe fn decode(
583            &mut self,
584            decoder: &mut fidl::encoding::Decoder<'_, D>,
585            offset: usize,
586            _depth: fidl::encoding::Depth,
587        ) -> fidl::Result<()> {
588            decoder.debug_check_bounds::<Self>(offset);
589            match decoder.read_num::<u8>(offset) {
590                0 => Ok(()),
591                _ => Err(fidl::Error::Invalid),
592            }
593        }
594    }
595
596    impl fidl::encoding::ValueTypeMarker for InterfaceProperties {
597        type Borrowed<'a> = &'a Self;
598        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
599            value
600        }
601    }
602
603    unsafe impl fidl::encoding::TypeMarker for InterfaceProperties {
604        type Owned = Self;
605
606        #[inline(always)]
607        fn inline_align(_context: fidl::encoding::Context) -> usize {
608            8
609        }
610
611        #[inline(always)]
612        fn inline_size(_context: fidl::encoding::Context) -> usize {
613            32
614        }
615    }
616
617    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InterfaceProperties, D>
618        for &InterfaceProperties
619    {
620        #[inline]
621        unsafe fn encode(
622            self,
623            encoder: &mut fidl::encoding::Encoder<'_, D>,
624            offset: usize,
625            _depth: fidl::encoding::Depth,
626        ) -> fidl::Result<()> {
627            encoder.debug_check_bounds::<InterfaceProperties>(offset);
628            // Delegate to tuple encoding.
629            fidl::encoding::Encode::<InterfaceProperties, D>::encode(
630                (
631                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
632                    <HardwareAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.addr),
633                    <HardwareType as fidl::encoding::ValueTypeMarker>::borrow(&self.type_),
634                ),
635                encoder,
636                offset,
637                _depth,
638            )
639        }
640    }
641    unsafe impl<
642            D: fidl::encoding::ResourceDialect,
643            T0: fidl::encoding::Encode<u64, D>,
644            T1: fidl::encoding::Encode<HardwareAddress, D>,
645            T2: fidl::encoding::Encode<HardwareType, D>,
646        > fidl::encoding::Encode<InterfaceProperties, D> for (T0, T1, T2)
647    {
648        #[inline]
649        unsafe fn encode(
650            self,
651            encoder: &mut fidl::encoding::Encoder<'_, D>,
652            offset: usize,
653            depth: fidl::encoding::Depth,
654        ) -> fidl::Result<()> {
655            encoder.debug_check_bounds::<InterfaceProperties>(offset);
656            // Zero out padding regions. There's no need to apply masks
657            // because the unmasked parts will be overwritten by fields.
658            unsafe {
659                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
660                (ptr as *mut u64).write_unaligned(0);
661            }
662            // Write the fields.
663            self.0.encode(encoder, offset + 0, depth)?;
664            self.1.encode(encoder, offset + 8, depth)?;
665            self.2.encode(encoder, offset + 24, depth)?;
666            Ok(())
667        }
668    }
669
670    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InterfaceProperties {
671        #[inline(always)]
672        fn new_empty() -> Self {
673            Self {
674                id: fidl::new_empty!(u64, D),
675                addr: fidl::new_empty!(HardwareAddress, D),
676                type_: fidl::new_empty!(HardwareType, D),
677            }
678        }
679
680        #[inline]
681        unsafe fn decode(
682            &mut self,
683            decoder: &mut fidl::encoding::Decoder<'_, D>,
684            offset: usize,
685            _depth: fidl::encoding::Depth,
686        ) -> fidl::Result<()> {
687            decoder.debug_check_bounds::<Self>(offset);
688            // Verify that padding bytes are zero.
689            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
690            let padval = unsafe { (ptr as *const u64).read_unaligned() };
691            let mask = 0xffffffff00000000u64;
692            let maskedval = padval & mask;
693            if maskedval != 0 {
694                return Err(fidl::Error::NonZeroPadding {
695                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
696                });
697            }
698            fidl::decode!(u64, D, &mut self.id, decoder, offset + 0, _depth)?;
699            fidl::decode!(HardwareAddress, D, &mut self.addr, decoder, offset + 8, _depth)?;
700            fidl::decode!(HardwareType, D, &mut self.type_, decoder, offset + 24, _depth)?;
701            Ok(())
702        }
703    }
704
705    impl fidl::encoding::ValueTypeMarker for PacketInfo {
706        type Borrowed<'a> = &'a Self;
707        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
708            value
709        }
710    }
711
712    unsafe impl fidl::encoding::TypeMarker for PacketInfo {
713        type Owned = Self;
714
715        #[inline(always)]
716        fn inline_align(_context: fidl::encoding::Context) -> usize {
717            8
718        }
719
720        #[inline(always)]
721        fn inline_size(_context: fidl::encoding::Context) -> usize {
722            32
723        }
724    }
725
726    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PacketInfo, D>
727        for &PacketInfo
728    {
729        #[inline]
730        unsafe fn encode(
731            self,
732            encoder: &mut fidl::encoding::Encoder<'_, D>,
733            offset: usize,
734            _depth: fidl::encoding::Depth,
735        ) -> fidl::Result<()> {
736            encoder.debug_check_bounds::<PacketInfo>(offset);
737            // Delegate to tuple encoding.
738            fidl::encoding::Encode::<PacketInfo, D>::encode(
739                (
740                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.protocol),
741                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.interface_id),
742                    <HardwareAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.addr),
743                ),
744                encoder,
745                offset,
746                _depth,
747            )
748        }
749    }
750    unsafe impl<
751            D: fidl::encoding::ResourceDialect,
752            T0: fidl::encoding::Encode<u16, D>,
753            T1: fidl::encoding::Encode<u64, D>,
754            T2: fidl::encoding::Encode<HardwareAddress, D>,
755        > fidl::encoding::Encode<PacketInfo, D> for (T0, T1, T2)
756    {
757        #[inline]
758        unsafe fn encode(
759            self,
760            encoder: &mut fidl::encoding::Encoder<'_, D>,
761            offset: usize,
762            depth: fidl::encoding::Depth,
763        ) -> fidl::Result<()> {
764            encoder.debug_check_bounds::<PacketInfo>(offset);
765            // Zero out padding regions. There's no need to apply masks
766            // because the unmasked parts will be overwritten by fields.
767            unsafe {
768                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
769                (ptr as *mut u64).write_unaligned(0);
770            }
771            // Write the fields.
772            self.0.encode(encoder, offset + 0, depth)?;
773            self.1.encode(encoder, offset + 8, depth)?;
774            self.2.encode(encoder, offset + 16, depth)?;
775            Ok(())
776        }
777    }
778
779    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PacketInfo {
780        #[inline(always)]
781        fn new_empty() -> Self {
782            Self {
783                protocol: fidl::new_empty!(u16, D),
784                interface_id: fidl::new_empty!(u64, D),
785                addr: fidl::new_empty!(HardwareAddress, D),
786            }
787        }
788
789        #[inline]
790        unsafe fn decode(
791            &mut self,
792            decoder: &mut fidl::encoding::Decoder<'_, D>,
793            offset: usize,
794            _depth: fidl::encoding::Depth,
795        ) -> fidl::Result<()> {
796            decoder.debug_check_bounds::<Self>(offset);
797            // Verify that padding bytes are zero.
798            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
799            let padval = unsafe { (ptr as *const u64).read_unaligned() };
800            let mask = 0xffffffffffff0000u64;
801            let maskedval = padval & mask;
802            if maskedval != 0 {
803                return Err(fidl::Error::NonZeroPadding {
804                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
805                });
806            }
807            fidl::decode!(u16, D, &mut self.protocol, decoder, offset + 0, _depth)?;
808            fidl::decode!(u64, D, &mut self.interface_id, decoder, offset + 8, _depth)?;
809            fidl::decode!(HardwareAddress, D, &mut self.addr, decoder, offset + 16, _depth)?;
810            Ok(())
811        }
812    }
813
814    impl fidl::encoding::ValueTypeMarker for ProviderSocketRequest {
815        type Borrowed<'a> = &'a Self;
816        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
817            value
818        }
819    }
820
821    unsafe impl fidl::encoding::TypeMarker for ProviderSocketRequest {
822        type Owned = Self;
823
824        #[inline(always)]
825        fn inline_align(_context: fidl::encoding::Context) -> usize {
826            4
827        }
828
829        #[inline(always)]
830        fn inline_size(_context: fidl::encoding::Context) -> usize {
831            4
832        }
833    }
834
835    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProviderSocketRequest, D>
836        for &ProviderSocketRequest
837    {
838        #[inline]
839        unsafe fn encode(
840            self,
841            encoder: &mut fidl::encoding::Encoder<'_, D>,
842            offset: usize,
843            _depth: fidl::encoding::Depth,
844        ) -> fidl::Result<()> {
845            encoder.debug_check_bounds::<ProviderSocketRequest>(offset);
846            // Delegate to tuple encoding.
847            fidl::encoding::Encode::<ProviderSocketRequest, D>::encode(
848                (<Kind as fidl::encoding::ValueTypeMarker>::borrow(&self.kind),),
849                encoder,
850                offset,
851                _depth,
852            )
853        }
854    }
855    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Kind, D>>
856        fidl::encoding::Encode<ProviderSocketRequest, D> for (T0,)
857    {
858        #[inline]
859        unsafe fn encode(
860            self,
861            encoder: &mut fidl::encoding::Encoder<'_, D>,
862            offset: usize,
863            depth: fidl::encoding::Depth,
864        ) -> fidl::Result<()> {
865            encoder.debug_check_bounds::<ProviderSocketRequest>(offset);
866            // Zero out padding regions. There's no need to apply masks
867            // because the unmasked parts will be overwritten by fields.
868            // Write the fields.
869            self.0.encode(encoder, offset + 0, depth)?;
870            Ok(())
871        }
872    }
873
874    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProviderSocketRequest {
875        #[inline(always)]
876        fn new_empty() -> Self {
877            Self { kind: fidl::new_empty!(Kind, D) }
878        }
879
880        #[inline]
881        unsafe fn decode(
882            &mut self,
883            decoder: &mut fidl::encoding::Decoder<'_, D>,
884            offset: usize,
885            _depth: fidl::encoding::Depth,
886        ) -> fidl::Result<()> {
887            decoder.debug_check_bounds::<Self>(offset);
888            // Verify that padding bytes are zero.
889            fidl::decode!(Kind, D, &mut self.kind, decoder, offset + 0, _depth)?;
890            Ok(())
891        }
892    }
893
894    impl fidl::encoding::ValueTypeMarker for RecvPacketInfo {
895        type Borrowed<'a> = &'a Self;
896        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
897            value
898        }
899    }
900
901    unsafe impl fidl::encoding::TypeMarker for RecvPacketInfo {
902        type Owned = Self;
903
904        #[inline(always)]
905        fn inline_align(_context: fidl::encoding::Context) -> usize {
906            8
907        }
908
909        #[inline(always)]
910        fn inline_size(_context: fidl::encoding::Context) -> usize {
911            40
912        }
913    }
914
915    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RecvPacketInfo, D>
916        for &RecvPacketInfo
917    {
918        #[inline]
919        unsafe fn encode(
920            self,
921            encoder: &mut fidl::encoding::Encoder<'_, D>,
922            offset: usize,
923            _depth: fidl::encoding::Depth,
924        ) -> fidl::Result<()> {
925            encoder.debug_check_bounds::<RecvPacketInfo>(offset);
926            // Delegate to tuple encoding.
927            fidl::encoding::Encode::<RecvPacketInfo, D>::encode(
928                (
929                    <PacketInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.packet_info),
930                    <PacketType as fidl::encoding::ValueTypeMarker>::borrow(&self.packet_type),
931                    <HardwareType as fidl::encoding::ValueTypeMarker>::borrow(&self.interface_type),
932                ),
933                encoder,
934                offset,
935                _depth,
936            )
937        }
938    }
939    unsafe impl<
940            D: fidl::encoding::ResourceDialect,
941            T0: fidl::encoding::Encode<PacketInfo, D>,
942            T1: fidl::encoding::Encode<PacketType, D>,
943            T2: fidl::encoding::Encode<HardwareType, D>,
944        > fidl::encoding::Encode<RecvPacketInfo, D> for (T0, T1, T2)
945    {
946        #[inline]
947        unsafe fn encode(
948            self,
949            encoder: &mut fidl::encoding::Encoder<'_, D>,
950            offset: usize,
951            depth: fidl::encoding::Depth,
952        ) -> fidl::Result<()> {
953            encoder.debug_check_bounds::<RecvPacketInfo>(offset);
954            // Zero out padding regions. There's no need to apply masks
955            // because the unmasked parts will be overwritten by fields.
956            // Write the fields.
957            self.0.encode(encoder, offset + 0, depth)?;
958            self.1.encode(encoder, offset + 32, depth)?;
959            self.2.encode(encoder, offset + 36, depth)?;
960            Ok(())
961        }
962    }
963
964    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RecvPacketInfo {
965        #[inline(always)]
966        fn new_empty() -> Self {
967            Self {
968                packet_info: fidl::new_empty!(PacketInfo, D),
969                packet_type: fidl::new_empty!(PacketType, D),
970                interface_type: fidl::new_empty!(HardwareType, D),
971            }
972        }
973
974        #[inline]
975        unsafe fn decode(
976            &mut self,
977            decoder: &mut fidl::encoding::Decoder<'_, D>,
978            offset: usize,
979            _depth: fidl::encoding::Depth,
980        ) -> fidl::Result<()> {
981            decoder.debug_check_bounds::<Self>(offset);
982            // Verify that padding bytes are zero.
983            fidl::decode!(PacketInfo, D, &mut self.packet_info, decoder, offset + 0, _depth)?;
984            fidl::decode!(PacketType, D, &mut self.packet_type, decoder, offset + 32, _depth)?;
985            fidl::decode!(HardwareType, D, &mut self.interface_type, decoder, offset + 36, _depth)?;
986            Ok(())
987        }
988    }
989
990    impl fidl::encoding::ValueTypeMarker for SocketBindRequest {
991        type Borrowed<'a> = &'a Self;
992        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
993            value
994        }
995    }
996
997    unsafe impl fidl::encoding::TypeMarker for SocketBindRequest {
998        type Owned = Self;
999
1000        #[inline(always)]
1001        fn inline_align(_context: fidl::encoding::Context) -> usize {
1002            8
1003        }
1004
1005        #[inline(always)]
1006        fn inline_size(_context: fidl::encoding::Context) -> usize {
1007            32
1008        }
1009    }
1010
1011    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SocketBindRequest, D>
1012        for &SocketBindRequest
1013    {
1014        #[inline]
1015        unsafe fn encode(
1016            self,
1017            encoder: &mut fidl::encoding::Encoder<'_, D>,
1018            offset: usize,
1019            _depth: fidl::encoding::Depth,
1020        ) -> fidl::Result<()> {
1021            encoder.debug_check_bounds::<SocketBindRequest>(offset);
1022            // Delegate to tuple encoding.
1023            fidl::encoding::Encode::<SocketBindRequest, D>::encode(
1024                (
1025                    <fidl::encoding::OptionalUnion<ProtocolAssociation> as fidl::encoding::ValueTypeMarker>::borrow(&self.protocol),
1026                    <BoundInterfaceId as fidl::encoding::ValueTypeMarker>::borrow(&self.bound_interface_id),
1027                ),
1028                encoder, offset, _depth
1029            )
1030        }
1031    }
1032    unsafe impl<
1033            D: fidl::encoding::ResourceDialect,
1034            T0: fidl::encoding::Encode<fidl::encoding::OptionalUnion<ProtocolAssociation>, D>,
1035            T1: fidl::encoding::Encode<BoundInterfaceId, D>,
1036        > fidl::encoding::Encode<SocketBindRequest, D> for (T0, T1)
1037    {
1038        #[inline]
1039        unsafe fn encode(
1040            self,
1041            encoder: &mut fidl::encoding::Encoder<'_, D>,
1042            offset: usize,
1043            depth: fidl::encoding::Depth,
1044        ) -> fidl::Result<()> {
1045            encoder.debug_check_bounds::<SocketBindRequest>(offset);
1046            // Zero out padding regions. There's no need to apply masks
1047            // because the unmasked parts will be overwritten by fields.
1048            // Write the fields.
1049            self.0.encode(encoder, offset + 0, depth)?;
1050            self.1.encode(encoder, offset + 16, depth)?;
1051            Ok(())
1052        }
1053    }
1054
1055    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SocketBindRequest {
1056        #[inline(always)]
1057        fn new_empty() -> Self {
1058            Self {
1059                protocol: fidl::new_empty!(fidl::encoding::OptionalUnion<ProtocolAssociation>, D),
1060                bound_interface_id: fidl::new_empty!(BoundInterfaceId, D),
1061            }
1062        }
1063
1064        #[inline]
1065        unsafe fn decode(
1066            &mut self,
1067            decoder: &mut fidl::encoding::Decoder<'_, D>,
1068            offset: usize,
1069            _depth: fidl::encoding::Depth,
1070        ) -> fidl::Result<()> {
1071            decoder.debug_check_bounds::<Self>(offset);
1072            // Verify that padding bytes are zero.
1073            fidl::decode!(
1074                fidl::encoding::OptionalUnion<ProtocolAssociation>,
1075                D,
1076                &mut self.protocol,
1077                decoder,
1078                offset + 0,
1079                _depth
1080            )?;
1081            fidl::decode!(
1082                BoundInterfaceId,
1083                D,
1084                &mut self.bound_interface_id,
1085                decoder,
1086                offset + 16,
1087                _depth
1088            )?;
1089            Ok(())
1090        }
1091    }
1092
1093    impl fidl::encoding::ValueTypeMarker for SocketRecvMsgRequest {
1094        type Borrowed<'a> = &'a Self;
1095        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1096            value
1097        }
1098    }
1099
1100    unsafe impl fidl::encoding::TypeMarker for SocketRecvMsgRequest {
1101        type Owned = Self;
1102
1103        #[inline(always)]
1104        fn inline_align(_context: fidl::encoding::Context) -> usize {
1105            4
1106        }
1107
1108        #[inline(always)]
1109        fn inline_size(_context: fidl::encoding::Context) -> usize {
1110            12
1111        }
1112    }
1113
1114    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SocketRecvMsgRequest, D>
1115        for &SocketRecvMsgRequest
1116    {
1117        #[inline]
1118        unsafe fn encode(
1119            self,
1120            encoder: &mut fidl::encoding::Encoder<'_, D>,
1121            offset: usize,
1122            _depth: fidl::encoding::Depth,
1123        ) -> fidl::Result<()> {
1124            encoder.debug_check_bounds::<SocketRecvMsgRequest>(offset);
1125            // Delegate to tuple encoding.
1126            fidl::encoding::Encode::<SocketRecvMsgRequest, D>::encode(
1127                (
1128                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.want_packet_info),
1129                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.data_len),
1130                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.want_control),
1131                    <fidl_fuchsia_posix_socket__common::RecvMsgFlags as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),
1132                ),
1133                encoder, offset, _depth
1134            )
1135        }
1136    }
1137    unsafe impl<
1138            D: fidl::encoding::ResourceDialect,
1139            T0: fidl::encoding::Encode<bool, D>,
1140            T1: fidl::encoding::Encode<u32, D>,
1141            T2: fidl::encoding::Encode<bool, D>,
1142            T3: fidl::encoding::Encode<fidl_fuchsia_posix_socket__common::RecvMsgFlags, D>,
1143        > fidl::encoding::Encode<SocketRecvMsgRequest, D> for (T0, T1, T2, T3)
1144    {
1145        #[inline]
1146        unsafe fn encode(
1147            self,
1148            encoder: &mut fidl::encoding::Encoder<'_, D>,
1149            offset: usize,
1150            depth: fidl::encoding::Depth,
1151        ) -> fidl::Result<()> {
1152            encoder.debug_check_bounds::<SocketRecvMsgRequest>(offset);
1153            // Zero out padding regions. There's no need to apply masks
1154            // because the unmasked parts will be overwritten by fields.
1155            unsafe {
1156                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1157                (ptr as *mut u32).write_unaligned(0);
1158            }
1159            unsafe {
1160                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
1161                (ptr as *mut u32).write_unaligned(0);
1162            }
1163            // Write the fields.
1164            self.0.encode(encoder, offset + 0, depth)?;
1165            self.1.encode(encoder, offset + 4, depth)?;
1166            self.2.encode(encoder, offset + 8, depth)?;
1167            self.3.encode(encoder, offset + 10, depth)?;
1168            Ok(())
1169        }
1170    }
1171
1172    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SocketRecvMsgRequest {
1173        #[inline(always)]
1174        fn new_empty() -> Self {
1175            Self {
1176                want_packet_info: fidl::new_empty!(bool, D),
1177                data_len: fidl::new_empty!(u32, D),
1178                want_control: fidl::new_empty!(bool, D),
1179                flags: fidl::new_empty!(fidl_fuchsia_posix_socket__common::RecvMsgFlags, D),
1180            }
1181        }
1182
1183        #[inline]
1184        unsafe fn decode(
1185            &mut self,
1186            decoder: &mut fidl::encoding::Decoder<'_, D>,
1187            offset: usize,
1188            _depth: fidl::encoding::Depth,
1189        ) -> fidl::Result<()> {
1190            decoder.debug_check_bounds::<Self>(offset);
1191            // Verify that padding bytes are zero.
1192            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1193            let padval = unsafe { (ptr as *const u32).read_unaligned() };
1194            let mask = 0xffffff00u32;
1195            let maskedval = padval & mask;
1196            if maskedval != 0 {
1197                return Err(fidl::Error::NonZeroPadding {
1198                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1199                });
1200            }
1201            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
1202            let padval = unsafe { (ptr as *const u32).read_unaligned() };
1203            let mask = 0xff00u32;
1204            let maskedval = padval & mask;
1205            if maskedval != 0 {
1206                return Err(fidl::Error::NonZeroPadding {
1207                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
1208                });
1209            }
1210            fidl::decode!(bool, D, &mut self.want_packet_info, decoder, offset + 0, _depth)?;
1211            fidl::decode!(u32, D, &mut self.data_len, decoder, offset + 4, _depth)?;
1212            fidl::decode!(bool, D, &mut self.want_control, decoder, offset + 8, _depth)?;
1213            fidl::decode!(
1214                fidl_fuchsia_posix_socket__common::RecvMsgFlags,
1215                D,
1216                &mut self.flags,
1217                decoder,
1218                offset + 10,
1219                _depth
1220            )?;
1221            Ok(())
1222        }
1223    }
1224
1225    impl fidl::encoding::ValueTypeMarker for SocketSendMsgRequest {
1226        type Borrowed<'a> = &'a Self;
1227        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1228            value
1229        }
1230    }
1231
1232    unsafe impl fidl::encoding::TypeMarker for SocketSendMsgRequest {
1233        type Owned = Self;
1234
1235        #[inline(always)]
1236        fn inline_align(_context: fidl::encoding::Context) -> usize {
1237            8
1238        }
1239
1240        #[inline(always)]
1241        fn inline_size(_context: fidl::encoding::Context) -> usize {
1242            48
1243        }
1244    }
1245
1246    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SocketSendMsgRequest, D>
1247        for &SocketSendMsgRequest
1248    {
1249        #[inline]
1250        unsafe fn encode(
1251            self,
1252            encoder: &mut fidl::encoding::Encoder<'_, D>,
1253            offset: usize,
1254            _depth: fidl::encoding::Depth,
1255        ) -> fidl::Result<()> {
1256            encoder.debug_check_bounds::<SocketSendMsgRequest>(offset);
1257            // Delegate to tuple encoding.
1258            fidl::encoding::Encode::<SocketSendMsgRequest, D>::encode(
1259                (
1260                    <fidl::encoding::Boxed<PacketInfo> as fidl::encoding::ValueTypeMarker>::borrow(&self.packet_info),
1261                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
1262                    <SendControlData as fidl::encoding::ValueTypeMarker>::borrow(&self.control),
1263                    <fidl_fuchsia_posix_socket__common::SendMsgFlags as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),
1264                ),
1265                encoder, offset, _depth
1266            )
1267        }
1268    }
1269    unsafe impl<
1270            D: fidl::encoding::ResourceDialect,
1271            T0: fidl::encoding::Encode<fidl::encoding::Boxed<PacketInfo>, D>,
1272            T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
1273            T2: fidl::encoding::Encode<SendControlData, D>,
1274            T3: fidl::encoding::Encode<fidl_fuchsia_posix_socket__common::SendMsgFlags, D>,
1275        > fidl::encoding::Encode<SocketSendMsgRequest, D> for (T0, T1, T2, T3)
1276    {
1277        #[inline]
1278        unsafe fn encode(
1279            self,
1280            encoder: &mut fidl::encoding::Encoder<'_, D>,
1281            offset: usize,
1282            depth: fidl::encoding::Depth,
1283        ) -> fidl::Result<()> {
1284            encoder.debug_check_bounds::<SocketSendMsgRequest>(offset);
1285            // Zero out padding regions. There's no need to apply masks
1286            // because the unmasked parts will be overwritten by fields.
1287            unsafe {
1288                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
1289                (ptr as *mut u64).write_unaligned(0);
1290            }
1291            // Write the fields.
1292            self.0.encode(encoder, offset + 0, depth)?;
1293            self.1.encode(encoder, offset + 8, depth)?;
1294            self.2.encode(encoder, offset + 24, depth)?;
1295            self.3.encode(encoder, offset + 40, depth)?;
1296            Ok(())
1297        }
1298    }
1299
1300    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SocketSendMsgRequest {
1301        #[inline(always)]
1302        fn new_empty() -> Self {
1303            Self {
1304                packet_info: fidl::new_empty!(fidl::encoding::Boxed<PacketInfo>, D),
1305                data: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
1306                control: fidl::new_empty!(SendControlData, D),
1307                flags: fidl::new_empty!(fidl_fuchsia_posix_socket__common::SendMsgFlags, D),
1308            }
1309        }
1310
1311        #[inline]
1312        unsafe fn decode(
1313            &mut self,
1314            decoder: &mut fidl::encoding::Decoder<'_, D>,
1315            offset: usize,
1316            _depth: fidl::encoding::Depth,
1317        ) -> fidl::Result<()> {
1318            decoder.debug_check_bounds::<Self>(offset);
1319            // Verify that padding bytes are zero.
1320            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
1321            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1322            let mask = 0xffffffffffff0000u64;
1323            let maskedval = padval & mask;
1324            if maskedval != 0 {
1325                return Err(fidl::Error::NonZeroPadding {
1326                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
1327                });
1328            }
1329            fidl::decode!(
1330                fidl::encoding::Boxed<PacketInfo>,
1331                D,
1332                &mut self.packet_info,
1333                decoder,
1334                offset + 0,
1335                _depth
1336            )?;
1337            fidl::decode!(
1338                fidl::encoding::UnboundedVector<u8>,
1339                D,
1340                &mut self.data,
1341                decoder,
1342                offset + 8,
1343                _depth
1344            )?;
1345            fidl::decode!(SendControlData, D, &mut self.control, decoder, offset + 24, _depth)?;
1346            fidl::decode!(
1347                fidl_fuchsia_posix_socket__common::SendMsgFlags,
1348                D,
1349                &mut self.flags,
1350                decoder,
1351                offset + 40,
1352                _depth
1353            )?;
1354            Ok(())
1355        }
1356    }
1357
1358    impl fidl::encoding::ValueTypeMarker for SocketGetInfoResponse {
1359        type Borrowed<'a> = &'a Self;
1360        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1361            value
1362        }
1363    }
1364
1365    unsafe impl fidl::encoding::TypeMarker for SocketGetInfoResponse {
1366        type Owned = Self;
1367
1368        #[inline(always)]
1369        fn inline_align(_context: fidl::encoding::Context) -> usize {
1370            8
1371        }
1372
1373        #[inline(always)]
1374        fn inline_size(_context: fidl::encoding::Context) -> usize {
1375            40
1376        }
1377    }
1378
1379    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SocketGetInfoResponse, D>
1380        for &SocketGetInfoResponse
1381    {
1382        #[inline]
1383        unsafe fn encode(
1384            self,
1385            encoder: &mut fidl::encoding::Encoder<'_, D>,
1386            offset: usize,
1387            _depth: fidl::encoding::Depth,
1388        ) -> fidl::Result<()> {
1389            encoder.debug_check_bounds::<SocketGetInfoResponse>(offset);
1390            // Delegate to tuple encoding.
1391            fidl::encoding::Encode::<SocketGetInfoResponse, D>::encode(
1392                (
1393                    <Kind as fidl::encoding::ValueTypeMarker>::borrow(&self.kind),
1394                    <fidl::encoding::OptionalUnion<ProtocolAssociation> as fidl::encoding::ValueTypeMarker>::borrow(&self.protocol),
1395                    <BoundInterface as fidl::encoding::ValueTypeMarker>::borrow(&self.bound_interface),
1396                ),
1397                encoder, offset, _depth
1398            )
1399        }
1400    }
1401    unsafe impl<
1402            D: fidl::encoding::ResourceDialect,
1403            T0: fidl::encoding::Encode<Kind, D>,
1404            T1: fidl::encoding::Encode<fidl::encoding::OptionalUnion<ProtocolAssociation>, D>,
1405            T2: fidl::encoding::Encode<BoundInterface, D>,
1406        > fidl::encoding::Encode<SocketGetInfoResponse, D> for (T0, T1, T2)
1407    {
1408        #[inline]
1409        unsafe fn encode(
1410            self,
1411            encoder: &mut fidl::encoding::Encoder<'_, D>,
1412            offset: usize,
1413            depth: fidl::encoding::Depth,
1414        ) -> fidl::Result<()> {
1415            encoder.debug_check_bounds::<SocketGetInfoResponse>(offset);
1416            // Zero out padding regions. There's no need to apply masks
1417            // because the unmasked parts will be overwritten by fields.
1418            unsafe {
1419                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1420                (ptr as *mut u64).write_unaligned(0);
1421            }
1422            // Write the fields.
1423            self.0.encode(encoder, offset + 0, depth)?;
1424            self.1.encode(encoder, offset + 8, depth)?;
1425            self.2.encode(encoder, offset + 24, depth)?;
1426            Ok(())
1427        }
1428    }
1429
1430    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SocketGetInfoResponse {
1431        #[inline(always)]
1432        fn new_empty() -> Self {
1433            Self {
1434                kind: fidl::new_empty!(Kind, D),
1435                protocol: fidl::new_empty!(fidl::encoding::OptionalUnion<ProtocolAssociation>, D),
1436                bound_interface: fidl::new_empty!(BoundInterface, D),
1437            }
1438        }
1439
1440        #[inline]
1441        unsafe fn decode(
1442            &mut self,
1443            decoder: &mut fidl::encoding::Decoder<'_, D>,
1444            offset: usize,
1445            _depth: fidl::encoding::Depth,
1446        ) -> fidl::Result<()> {
1447            decoder.debug_check_bounds::<Self>(offset);
1448            // Verify that padding bytes are zero.
1449            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1450            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1451            let mask = 0xffffffff00000000u64;
1452            let maskedval = padval & mask;
1453            if maskedval != 0 {
1454                return Err(fidl::Error::NonZeroPadding {
1455                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1456                });
1457            }
1458            fidl::decode!(Kind, D, &mut self.kind, decoder, offset + 0, _depth)?;
1459            fidl::decode!(
1460                fidl::encoding::OptionalUnion<ProtocolAssociation>,
1461                D,
1462                &mut self.protocol,
1463                decoder,
1464                offset + 8,
1465                _depth
1466            )?;
1467            fidl::decode!(
1468                BoundInterface,
1469                D,
1470                &mut self.bound_interface,
1471                decoder,
1472                offset + 24,
1473                _depth
1474            )?;
1475            Ok(())
1476        }
1477    }
1478
1479    impl fidl::encoding::ValueTypeMarker for SocketRecvMsgResponse {
1480        type Borrowed<'a> = &'a Self;
1481        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1482            value
1483        }
1484    }
1485
1486    unsafe impl fidl::encoding::TypeMarker for SocketRecvMsgResponse {
1487        type Owned = Self;
1488
1489        #[inline(always)]
1490        fn inline_align(_context: fidl::encoding::Context) -> usize {
1491            8
1492        }
1493
1494        #[inline(always)]
1495        fn inline_size(_context: fidl::encoding::Context) -> usize {
1496            48
1497        }
1498    }
1499
1500    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SocketRecvMsgResponse, D>
1501        for &SocketRecvMsgResponse
1502    {
1503        #[inline]
1504        unsafe fn encode(
1505            self,
1506            encoder: &mut fidl::encoding::Encoder<'_, D>,
1507            offset: usize,
1508            _depth: fidl::encoding::Depth,
1509        ) -> fidl::Result<()> {
1510            encoder.debug_check_bounds::<SocketRecvMsgResponse>(offset);
1511            // Delegate to tuple encoding.
1512            fidl::encoding::Encode::<SocketRecvMsgResponse, D>::encode(
1513                (
1514                    <fidl::encoding::Boxed<RecvPacketInfo> as fidl::encoding::ValueTypeMarker>::borrow(&self.packet_info),
1515                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
1516                    <RecvControlData as fidl::encoding::ValueTypeMarker>::borrow(&self.control),
1517                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.truncated),
1518                ),
1519                encoder, offset, _depth
1520            )
1521        }
1522    }
1523    unsafe impl<
1524            D: fidl::encoding::ResourceDialect,
1525            T0: fidl::encoding::Encode<fidl::encoding::Boxed<RecvPacketInfo>, D>,
1526            T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
1527            T2: fidl::encoding::Encode<RecvControlData, D>,
1528            T3: fidl::encoding::Encode<u32, D>,
1529        > fidl::encoding::Encode<SocketRecvMsgResponse, D> for (T0, T1, T2, T3)
1530    {
1531        #[inline]
1532        unsafe fn encode(
1533            self,
1534            encoder: &mut fidl::encoding::Encoder<'_, D>,
1535            offset: usize,
1536            depth: fidl::encoding::Depth,
1537        ) -> fidl::Result<()> {
1538            encoder.debug_check_bounds::<SocketRecvMsgResponse>(offset);
1539            // Zero out padding regions. There's no need to apply masks
1540            // because the unmasked parts will be overwritten by fields.
1541            unsafe {
1542                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
1543                (ptr as *mut u64).write_unaligned(0);
1544            }
1545            // Write the fields.
1546            self.0.encode(encoder, offset + 0, depth)?;
1547            self.1.encode(encoder, offset + 8, depth)?;
1548            self.2.encode(encoder, offset + 24, depth)?;
1549            self.3.encode(encoder, offset + 40, depth)?;
1550            Ok(())
1551        }
1552    }
1553
1554    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SocketRecvMsgResponse {
1555        #[inline(always)]
1556        fn new_empty() -> Self {
1557            Self {
1558                packet_info: fidl::new_empty!(fidl::encoding::Boxed<RecvPacketInfo>, D),
1559                data: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
1560                control: fidl::new_empty!(RecvControlData, D),
1561                truncated: fidl::new_empty!(u32, D),
1562            }
1563        }
1564
1565        #[inline]
1566        unsafe fn decode(
1567            &mut self,
1568            decoder: &mut fidl::encoding::Decoder<'_, D>,
1569            offset: usize,
1570            _depth: fidl::encoding::Depth,
1571        ) -> fidl::Result<()> {
1572            decoder.debug_check_bounds::<Self>(offset);
1573            // Verify that padding bytes are zero.
1574            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
1575            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1576            let mask = 0xffffffff00000000u64;
1577            let maskedval = padval & mask;
1578            if maskedval != 0 {
1579                return Err(fidl::Error::NonZeroPadding {
1580                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
1581                });
1582            }
1583            fidl::decode!(
1584                fidl::encoding::Boxed<RecvPacketInfo>,
1585                D,
1586                &mut self.packet_info,
1587                decoder,
1588                offset + 0,
1589                _depth
1590            )?;
1591            fidl::decode!(
1592                fidl::encoding::UnboundedVector<u8>,
1593                D,
1594                &mut self.data,
1595                decoder,
1596                offset + 8,
1597                _depth
1598            )?;
1599            fidl::decode!(RecvControlData, D, &mut self.control, decoder, offset + 24, _depth)?;
1600            fidl::decode!(u32, D, &mut self.truncated, decoder, offset + 40, _depth)?;
1601            Ok(())
1602        }
1603    }
1604
1605    impl RecvControlData {
1606        #[inline(always)]
1607        fn max_ordinal_present(&self) -> u64 {
1608            if let Some(_) = self.socket {
1609                return 1;
1610            }
1611            0
1612        }
1613    }
1614
1615    impl fidl::encoding::ValueTypeMarker for RecvControlData {
1616        type Borrowed<'a> = &'a Self;
1617        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1618            value
1619        }
1620    }
1621
1622    unsafe impl fidl::encoding::TypeMarker for RecvControlData {
1623        type Owned = Self;
1624
1625        #[inline(always)]
1626        fn inline_align(_context: fidl::encoding::Context) -> usize {
1627            8
1628        }
1629
1630        #[inline(always)]
1631        fn inline_size(_context: fidl::encoding::Context) -> usize {
1632            16
1633        }
1634    }
1635
1636    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RecvControlData, D>
1637        for &RecvControlData
1638    {
1639        unsafe fn encode(
1640            self,
1641            encoder: &mut fidl::encoding::Encoder<'_, D>,
1642            offset: usize,
1643            mut depth: fidl::encoding::Depth,
1644        ) -> fidl::Result<()> {
1645            encoder.debug_check_bounds::<RecvControlData>(offset);
1646            // Vector header
1647            let max_ordinal: u64 = self.max_ordinal_present();
1648            encoder.write_num(max_ordinal, offset);
1649            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1650            // Calling encoder.out_of_line_offset(0) is not allowed.
1651            if max_ordinal == 0 {
1652                return Ok(());
1653            }
1654            depth.increment()?;
1655            let envelope_size = 8;
1656            let bytes_len = max_ordinal as usize * envelope_size;
1657            #[allow(unused_variables)]
1658            let offset = encoder.out_of_line_offset(bytes_len);
1659            let mut _prev_end_offset: usize = 0;
1660            if 1 > max_ordinal {
1661                return Ok(());
1662            }
1663
1664            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1665            // are envelope_size bytes.
1666            let cur_offset: usize = (1 - 1) * envelope_size;
1667
1668            // Zero reserved fields.
1669            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1670
1671            // Safety:
1672            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1673            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1674            //   envelope_size bytes, there is always sufficient room.
1675            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_posix_socket__common::SocketRecvControlData, D>(
1676            self.socket.as_ref().map(<fidl_fuchsia_posix_socket__common::SocketRecvControlData as fidl::encoding::ValueTypeMarker>::borrow),
1677            encoder, offset + cur_offset, depth
1678        )?;
1679
1680            _prev_end_offset = cur_offset + envelope_size;
1681
1682            Ok(())
1683        }
1684    }
1685
1686    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RecvControlData {
1687        #[inline(always)]
1688        fn new_empty() -> Self {
1689            Self::default()
1690        }
1691
1692        unsafe fn decode(
1693            &mut self,
1694            decoder: &mut fidl::encoding::Decoder<'_, D>,
1695            offset: usize,
1696            mut depth: fidl::encoding::Depth,
1697        ) -> fidl::Result<()> {
1698            decoder.debug_check_bounds::<Self>(offset);
1699            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1700                None => return Err(fidl::Error::NotNullable),
1701                Some(len) => len,
1702            };
1703            // Calling decoder.out_of_line_offset(0) is not allowed.
1704            if len == 0 {
1705                return Ok(());
1706            };
1707            depth.increment()?;
1708            let envelope_size = 8;
1709            let bytes_len = len * envelope_size;
1710            let offset = decoder.out_of_line_offset(bytes_len)?;
1711            // Decode the envelope for each type.
1712            let mut _next_ordinal_to_read = 0;
1713            let mut next_offset = offset;
1714            let end_offset = offset + bytes_len;
1715            _next_ordinal_to_read += 1;
1716            if next_offset >= end_offset {
1717                return Ok(());
1718            }
1719
1720            // Decode unknown envelopes for gaps in ordinals.
1721            while _next_ordinal_to_read < 1 {
1722                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1723                _next_ordinal_to_read += 1;
1724                next_offset += envelope_size;
1725            }
1726
1727            let next_out_of_line = decoder.next_out_of_line();
1728            let handles_before = decoder.remaining_handles();
1729            if let Some((inlined, num_bytes, num_handles)) =
1730                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1731            {
1732                let member_inline_size = <fidl_fuchsia_posix_socket__common::SocketRecvControlData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1733                if inlined != (member_inline_size <= 4) {
1734                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1735                }
1736                let inner_offset;
1737                let mut inner_depth = depth.clone();
1738                if inlined {
1739                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1740                    inner_offset = next_offset;
1741                } else {
1742                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1743                    inner_depth.increment()?;
1744                }
1745                let val_ref = self.socket.get_or_insert_with(|| {
1746                    fidl::new_empty!(fidl_fuchsia_posix_socket__common::SocketRecvControlData, D)
1747                });
1748                fidl::decode!(
1749                    fidl_fuchsia_posix_socket__common::SocketRecvControlData,
1750                    D,
1751                    val_ref,
1752                    decoder,
1753                    inner_offset,
1754                    inner_depth
1755                )?;
1756                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1757                {
1758                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1759                }
1760                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1761                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1762                }
1763            }
1764
1765            next_offset += envelope_size;
1766
1767            // Decode the remaining unknown envelopes.
1768            while next_offset < end_offset {
1769                _next_ordinal_to_read += 1;
1770                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1771                next_offset += envelope_size;
1772            }
1773
1774            Ok(())
1775        }
1776    }
1777
1778    impl SendControlData {
1779        #[inline(always)]
1780        fn max_ordinal_present(&self) -> u64 {
1781            if let Some(_) = self.socket {
1782                return 1;
1783            }
1784            0
1785        }
1786    }
1787
1788    impl fidl::encoding::ValueTypeMarker for SendControlData {
1789        type Borrowed<'a> = &'a Self;
1790        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1791            value
1792        }
1793    }
1794
1795    unsafe impl fidl::encoding::TypeMarker for SendControlData {
1796        type Owned = Self;
1797
1798        #[inline(always)]
1799        fn inline_align(_context: fidl::encoding::Context) -> usize {
1800            8
1801        }
1802
1803        #[inline(always)]
1804        fn inline_size(_context: fidl::encoding::Context) -> usize {
1805            16
1806        }
1807    }
1808
1809    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SendControlData, D>
1810        for &SendControlData
1811    {
1812        unsafe fn encode(
1813            self,
1814            encoder: &mut fidl::encoding::Encoder<'_, D>,
1815            offset: usize,
1816            mut depth: fidl::encoding::Depth,
1817        ) -> fidl::Result<()> {
1818            encoder.debug_check_bounds::<SendControlData>(offset);
1819            // Vector header
1820            let max_ordinal: u64 = self.max_ordinal_present();
1821            encoder.write_num(max_ordinal, offset);
1822            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1823            // Calling encoder.out_of_line_offset(0) is not allowed.
1824            if max_ordinal == 0 {
1825                return Ok(());
1826            }
1827            depth.increment()?;
1828            let envelope_size = 8;
1829            let bytes_len = max_ordinal as usize * envelope_size;
1830            #[allow(unused_variables)]
1831            let offset = encoder.out_of_line_offset(bytes_len);
1832            let mut _prev_end_offset: usize = 0;
1833            if 1 > max_ordinal {
1834                return Ok(());
1835            }
1836
1837            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1838            // are envelope_size bytes.
1839            let cur_offset: usize = (1 - 1) * envelope_size;
1840
1841            // Zero reserved fields.
1842            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1843
1844            // Safety:
1845            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1846            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1847            //   envelope_size bytes, there is always sufficient room.
1848            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_posix_socket__common::SocketSendControlData, D>(
1849            self.socket.as_ref().map(<fidl_fuchsia_posix_socket__common::SocketSendControlData as fidl::encoding::ValueTypeMarker>::borrow),
1850            encoder, offset + cur_offset, depth
1851        )?;
1852
1853            _prev_end_offset = cur_offset + envelope_size;
1854
1855            Ok(())
1856        }
1857    }
1858
1859    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SendControlData {
1860        #[inline(always)]
1861        fn new_empty() -> Self {
1862            Self::default()
1863        }
1864
1865        unsafe fn decode(
1866            &mut self,
1867            decoder: &mut fidl::encoding::Decoder<'_, D>,
1868            offset: usize,
1869            mut depth: fidl::encoding::Depth,
1870        ) -> fidl::Result<()> {
1871            decoder.debug_check_bounds::<Self>(offset);
1872            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1873                None => return Err(fidl::Error::NotNullable),
1874                Some(len) => len,
1875            };
1876            // Calling decoder.out_of_line_offset(0) is not allowed.
1877            if len == 0 {
1878                return Ok(());
1879            };
1880            depth.increment()?;
1881            let envelope_size = 8;
1882            let bytes_len = len * envelope_size;
1883            let offset = decoder.out_of_line_offset(bytes_len)?;
1884            // Decode the envelope for each type.
1885            let mut _next_ordinal_to_read = 0;
1886            let mut next_offset = offset;
1887            let end_offset = offset + bytes_len;
1888            _next_ordinal_to_read += 1;
1889            if next_offset >= end_offset {
1890                return Ok(());
1891            }
1892
1893            // Decode unknown envelopes for gaps in ordinals.
1894            while _next_ordinal_to_read < 1 {
1895                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1896                _next_ordinal_to_read += 1;
1897                next_offset += envelope_size;
1898            }
1899
1900            let next_out_of_line = decoder.next_out_of_line();
1901            let handles_before = decoder.remaining_handles();
1902            if let Some((inlined, num_bytes, num_handles)) =
1903                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1904            {
1905                let member_inline_size = <fidl_fuchsia_posix_socket__common::SocketSendControlData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1906                if inlined != (member_inline_size <= 4) {
1907                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1908                }
1909                let inner_offset;
1910                let mut inner_depth = depth.clone();
1911                if inlined {
1912                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1913                    inner_offset = next_offset;
1914                } else {
1915                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1916                    inner_depth.increment()?;
1917                }
1918                let val_ref = self.socket.get_or_insert_with(|| {
1919                    fidl::new_empty!(fidl_fuchsia_posix_socket__common::SocketSendControlData, D)
1920                });
1921                fidl::decode!(
1922                    fidl_fuchsia_posix_socket__common::SocketSendControlData,
1923                    D,
1924                    val_ref,
1925                    decoder,
1926                    inner_offset,
1927                    inner_depth
1928                )?;
1929                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1930                {
1931                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1932                }
1933                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1934                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1935                }
1936            }
1937
1938            next_offset += envelope_size;
1939
1940            // Decode the remaining unknown envelopes.
1941            while next_offset < end_offset {
1942                _next_ordinal_to_read += 1;
1943                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1944                next_offset += envelope_size;
1945            }
1946
1947            Ok(())
1948        }
1949    }
1950
1951    impl fidl::encoding::ValueTypeMarker for BoundInterface {
1952        type Borrowed<'a> = &'a Self;
1953        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1954            value
1955        }
1956    }
1957
1958    unsafe impl fidl::encoding::TypeMarker for BoundInterface {
1959        type Owned = Self;
1960
1961        #[inline(always)]
1962        fn inline_align(_context: fidl::encoding::Context) -> usize {
1963            8
1964        }
1965
1966        #[inline(always)]
1967        fn inline_size(_context: fidl::encoding::Context) -> usize {
1968            16
1969        }
1970    }
1971
1972    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BoundInterface, D>
1973        for &BoundInterface
1974    {
1975        #[inline]
1976        unsafe fn encode(
1977            self,
1978            encoder: &mut fidl::encoding::Encoder<'_, D>,
1979            offset: usize,
1980            _depth: fidl::encoding::Depth,
1981        ) -> fidl::Result<()> {
1982            encoder.debug_check_bounds::<BoundInterface>(offset);
1983            encoder.write_num::<u64>(self.ordinal(), offset);
1984            match self {
1985                BoundInterface::All(ref val) => fidl::encoding::encode_in_envelope::<Empty, D>(
1986                    <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
1987                    encoder,
1988                    offset + 8,
1989                    _depth,
1990                ),
1991                BoundInterface::Specified(ref val) => {
1992                    fidl::encoding::encode_in_envelope::<InterfaceProperties, D>(
1993                        <InterfaceProperties as fidl::encoding::ValueTypeMarker>::borrow(val),
1994                        encoder,
1995                        offset + 8,
1996                        _depth,
1997                    )
1998                }
1999            }
2000        }
2001    }
2002
2003    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BoundInterface {
2004        #[inline(always)]
2005        fn new_empty() -> Self {
2006            Self::All(fidl::new_empty!(Empty, D))
2007        }
2008
2009        #[inline]
2010        unsafe fn decode(
2011            &mut self,
2012            decoder: &mut fidl::encoding::Decoder<'_, D>,
2013            offset: usize,
2014            mut depth: fidl::encoding::Depth,
2015        ) -> fidl::Result<()> {
2016            decoder.debug_check_bounds::<Self>(offset);
2017            #[allow(unused_variables)]
2018            let next_out_of_line = decoder.next_out_of_line();
2019            let handles_before = decoder.remaining_handles();
2020            let (ordinal, inlined, num_bytes, num_handles) =
2021                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
2022
2023            let member_inline_size = match ordinal {
2024                1 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2025                2 => <InterfaceProperties as fidl::encoding::TypeMarker>::inline_size(
2026                    decoder.context,
2027                ),
2028                _ => return Err(fidl::Error::UnknownUnionTag),
2029            };
2030
2031            if inlined != (member_inline_size <= 4) {
2032                return Err(fidl::Error::InvalidInlineBitInEnvelope);
2033            }
2034            let _inner_offset;
2035            if inlined {
2036                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
2037                _inner_offset = offset + 8;
2038            } else {
2039                depth.increment()?;
2040                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2041            }
2042            match ordinal {
2043                1 => {
2044                    #[allow(irrefutable_let_patterns)]
2045                    if let BoundInterface::All(_) = self {
2046                        // Do nothing, read the value into the object
2047                    } else {
2048                        // Initialize `self` to the right variant
2049                        *self = BoundInterface::All(fidl::new_empty!(Empty, D));
2050                    }
2051                    #[allow(irrefutable_let_patterns)]
2052                    if let BoundInterface::All(ref mut val) = self {
2053                        fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
2054                    } else {
2055                        unreachable!()
2056                    }
2057                }
2058                2 => {
2059                    #[allow(irrefutable_let_patterns)]
2060                    if let BoundInterface::Specified(_) = self {
2061                        // Do nothing, read the value into the object
2062                    } else {
2063                        // Initialize `self` to the right variant
2064                        *self = BoundInterface::Specified(fidl::new_empty!(InterfaceProperties, D));
2065                    }
2066                    #[allow(irrefutable_let_patterns)]
2067                    if let BoundInterface::Specified(ref mut val) = self {
2068                        fidl::decode!(InterfaceProperties, D, val, decoder, _inner_offset, depth)?;
2069                    } else {
2070                        unreachable!()
2071                    }
2072                }
2073                ordinal => panic!("unexpected ordinal {:?}", ordinal),
2074            }
2075            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
2076                return Err(fidl::Error::InvalidNumBytesInEnvelope);
2077            }
2078            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2079                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2080            }
2081            Ok(())
2082        }
2083    }
2084
2085    impl fidl::encoding::ValueTypeMarker for BoundInterfaceId {
2086        type Borrowed<'a> = &'a Self;
2087        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2088            value
2089        }
2090    }
2091
2092    unsafe impl fidl::encoding::TypeMarker for BoundInterfaceId {
2093        type Owned = Self;
2094
2095        #[inline(always)]
2096        fn inline_align(_context: fidl::encoding::Context) -> usize {
2097            8
2098        }
2099
2100        #[inline(always)]
2101        fn inline_size(_context: fidl::encoding::Context) -> usize {
2102            16
2103        }
2104    }
2105
2106    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BoundInterfaceId, D>
2107        for &BoundInterfaceId
2108    {
2109        #[inline]
2110        unsafe fn encode(
2111            self,
2112            encoder: &mut fidl::encoding::Encoder<'_, D>,
2113            offset: usize,
2114            _depth: fidl::encoding::Depth,
2115        ) -> fidl::Result<()> {
2116            encoder.debug_check_bounds::<BoundInterfaceId>(offset);
2117            encoder.write_num::<u64>(self.ordinal(), offset);
2118            match self {
2119                BoundInterfaceId::All(ref val) => fidl::encoding::encode_in_envelope::<Empty, D>(
2120                    <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
2121                    encoder,
2122                    offset + 8,
2123                    _depth,
2124                ),
2125                BoundInterfaceId::Specified(ref val) => {
2126                    fidl::encoding::encode_in_envelope::<u64, D>(
2127                        <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
2128                        encoder,
2129                        offset + 8,
2130                        _depth,
2131                    )
2132                }
2133            }
2134        }
2135    }
2136
2137    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BoundInterfaceId {
2138        #[inline(always)]
2139        fn new_empty() -> Self {
2140            Self::All(fidl::new_empty!(Empty, D))
2141        }
2142
2143        #[inline]
2144        unsafe fn decode(
2145            &mut self,
2146            decoder: &mut fidl::encoding::Decoder<'_, D>,
2147            offset: usize,
2148            mut depth: fidl::encoding::Depth,
2149        ) -> fidl::Result<()> {
2150            decoder.debug_check_bounds::<Self>(offset);
2151            #[allow(unused_variables)]
2152            let next_out_of_line = decoder.next_out_of_line();
2153            let handles_before = decoder.remaining_handles();
2154            let (ordinal, inlined, num_bytes, num_handles) =
2155                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
2156
2157            let member_inline_size = match ordinal {
2158                1 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2159                2 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2160                _ => return Err(fidl::Error::UnknownUnionTag),
2161            };
2162
2163            if inlined != (member_inline_size <= 4) {
2164                return Err(fidl::Error::InvalidInlineBitInEnvelope);
2165            }
2166            let _inner_offset;
2167            if inlined {
2168                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
2169                _inner_offset = offset + 8;
2170            } else {
2171                depth.increment()?;
2172                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2173            }
2174            match ordinal {
2175                1 => {
2176                    #[allow(irrefutable_let_patterns)]
2177                    if let BoundInterfaceId::All(_) = self {
2178                        // Do nothing, read the value into the object
2179                    } else {
2180                        // Initialize `self` to the right variant
2181                        *self = BoundInterfaceId::All(fidl::new_empty!(Empty, D));
2182                    }
2183                    #[allow(irrefutable_let_patterns)]
2184                    if let BoundInterfaceId::All(ref mut val) = self {
2185                        fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
2186                    } else {
2187                        unreachable!()
2188                    }
2189                }
2190                2 => {
2191                    #[allow(irrefutable_let_patterns)]
2192                    if let BoundInterfaceId::Specified(_) = self {
2193                        // Do nothing, read the value into the object
2194                    } else {
2195                        // Initialize `self` to the right variant
2196                        *self = BoundInterfaceId::Specified(fidl::new_empty!(u64, D));
2197                    }
2198                    #[allow(irrefutable_let_patterns)]
2199                    if let BoundInterfaceId::Specified(ref mut val) = self {
2200                        fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
2201                    } else {
2202                        unreachable!()
2203                    }
2204                }
2205                ordinal => panic!("unexpected ordinal {:?}", ordinal),
2206            }
2207            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
2208                return Err(fidl::Error::InvalidNumBytesInEnvelope);
2209            }
2210            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2211                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2212            }
2213            Ok(())
2214        }
2215    }
2216
2217    impl fidl::encoding::ValueTypeMarker for HardwareAddress {
2218        type Borrowed<'a> = &'a Self;
2219        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2220            value
2221        }
2222    }
2223
2224    unsafe impl fidl::encoding::TypeMarker for HardwareAddress {
2225        type Owned = Self;
2226
2227        #[inline(always)]
2228        fn inline_align(_context: fidl::encoding::Context) -> usize {
2229            8
2230        }
2231
2232        #[inline(always)]
2233        fn inline_size(_context: fidl::encoding::Context) -> usize {
2234            16
2235        }
2236    }
2237
2238    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HardwareAddress, D>
2239        for &HardwareAddress
2240    {
2241        #[inline]
2242        unsafe fn encode(
2243            self,
2244            encoder: &mut fidl::encoding::Encoder<'_, D>,
2245            offset: usize,
2246            _depth: fidl::encoding::Depth,
2247        ) -> fidl::Result<()> {
2248            encoder.debug_check_bounds::<HardwareAddress>(offset);
2249            encoder.write_num::<u64>(self.ordinal(), offset);
2250            match self {
2251            HardwareAddress::None(ref val) => {
2252                fidl::encoding::encode_in_envelope::<Empty, D>(
2253                    <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
2254                    encoder, offset + 8, _depth
2255                )
2256            }
2257            HardwareAddress::Eui48(ref val) => {
2258                fidl::encoding::encode_in_envelope::<fidl_fuchsia_net__common::MacAddress, D>(
2259                    <fidl_fuchsia_net__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow(val),
2260                    encoder, offset + 8, _depth
2261                )
2262            }
2263            HardwareAddress::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
2264        }
2265        }
2266    }
2267
2268    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HardwareAddress {
2269        #[inline(always)]
2270        fn new_empty() -> Self {
2271            Self::__SourceBreaking { unknown_ordinal: 0 }
2272        }
2273
2274        #[inline]
2275        unsafe fn decode(
2276            &mut self,
2277            decoder: &mut fidl::encoding::Decoder<'_, D>,
2278            offset: usize,
2279            mut depth: fidl::encoding::Depth,
2280        ) -> fidl::Result<()> {
2281            decoder.debug_check_bounds::<Self>(offset);
2282            #[allow(unused_variables)]
2283            let next_out_of_line = decoder.next_out_of_line();
2284            let handles_before = decoder.remaining_handles();
2285            let (ordinal, inlined, num_bytes, num_handles) =
2286                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
2287
2288            let member_inline_size = match ordinal {
2289            1 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2290            2 => <fidl_fuchsia_net__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2291            0 => return Err(fidl::Error::UnknownUnionTag),
2292            _ => num_bytes as usize,
2293        };
2294
2295            if inlined != (member_inline_size <= 4) {
2296                return Err(fidl::Error::InvalidInlineBitInEnvelope);
2297            }
2298            let _inner_offset;
2299            if inlined {
2300                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
2301                _inner_offset = offset + 8;
2302            } else {
2303                depth.increment()?;
2304                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2305            }
2306            match ordinal {
2307                1 => {
2308                    #[allow(irrefutable_let_patterns)]
2309                    if let HardwareAddress::None(_) = self {
2310                        // Do nothing, read the value into the object
2311                    } else {
2312                        // Initialize `self` to the right variant
2313                        *self = HardwareAddress::None(fidl::new_empty!(Empty, D));
2314                    }
2315                    #[allow(irrefutable_let_patterns)]
2316                    if let HardwareAddress::None(ref mut val) = self {
2317                        fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
2318                    } else {
2319                        unreachable!()
2320                    }
2321                }
2322                2 => {
2323                    #[allow(irrefutable_let_patterns)]
2324                    if let HardwareAddress::Eui48(_) = self {
2325                        // Do nothing, read the value into the object
2326                    } else {
2327                        // Initialize `self` to the right variant
2328                        *self = HardwareAddress::Eui48(fidl::new_empty!(
2329                            fidl_fuchsia_net__common::MacAddress,
2330                            D
2331                        ));
2332                    }
2333                    #[allow(irrefutable_let_patterns)]
2334                    if let HardwareAddress::Eui48(ref mut val) = self {
2335                        fidl::decode!(
2336                            fidl_fuchsia_net__common::MacAddress,
2337                            D,
2338                            val,
2339                            decoder,
2340                            _inner_offset,
2341                            depth
2342                        )?;
2343                    } else {
2344                        unreachable!()
2345                    }
2346                }
2347                #[allow(deprecated)]
2348                ordinal => {
2349                    for _ in 0..num_handles {
2350                        decoder.drop_next_handle()?;
2351                    }
2352                    *self = HardwareAddress::__SourceBreaking { unknown_ordinal: ordinal };
2353                }
2354            }
2355            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
2356                return Err(fidl::Error::InvalidNumBytesInEnvelope);
2357            }
2358            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2359                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2360            }
2361            Ok(())
2362        }
2363    }
2364
2365    impl fidl::encoding::ValueTypeMarker for ProtocolAssociation {
2366        type Borrowed<'a> = &'a Self;
2367        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2368            value
2369        }
2370    }
2371
2372    unsafe impl fidl::encoding::TypeMarker for ProtocolAssociation {
2373        type Owned = Self;
2374
2375        #[inline(always)]
2376        fn inline_align(_context: fidl::encoding::Context) -> usize {
2377            8
2378        }
2379
2380        #[inline(always)]
2381        fn inline_size(_context: fidl::encoding::Context) -> usize {
2382            16
2383        }
2384    }
2385
2386    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProtocolAssociation, D>
2387        for &ProtocolAssociation
2388    {
2389        #[inline]
2390        unsafe fn encode(
2391            self,
2392            encoder: &mut fidl::encoding::Encoder<'_, D>,
2393            offset: usize,
2394            _depth: fidl::encoding::Depth,
2395        ) -> fidl::Result<()> {
2396            encoder.debug_check_bounds::<ProtocolAssociation>(offset);
2397            encoder.write_num::<u64>(self.ordinal(), offset);
2398            match self {
2399                ProtocolAssociation::All(ref val) => {
2400                    fidl::encoding::encode_in_envelope::<Empty, D>(
2401                        <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
2402                        encoder,
2403                        offset + 8,
2404                        _depth,
2405                    )
2406                }
2407                ProtocolAssociation::Specified(ref val) => {
2408                    fidl::encoding::encode_in_envelope::<u16, D>(
2409                        <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
2410                        encoder,
2411                        offset + 8,
2412                        _depth,
2413                    )
2414                }
2415            }
2416        }
2417    }
2418
2419    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProtocolAssociation {
2420        #[inline(always)]
2421        fn new_empty() -> Self {
2422            Self::All(fidl::new_empty!(Empty, D))
2423        }
2424
2425        #[inline]
2426        unsafe fn decode(
2427            &mut self,
2428            decoder: &mut fidl::encoding::Decoder<'_, D>,
2429            offset: usize,
2430            mut depth: fidl::encoding::Depth,
2431        ) -> fidl::Result<()> {
2432            decoder.debug_check_bounds::<Self>(offset);
2433            #[allow(unused_variables)]
2434            let next_out_of_line = decoder.next_out_of_line();
2435            let handles_before = decoder.remaining_handles();
2436            let (ordinal, inlined, num_bytes, num_handles) =
2437                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
2438
2439            let member_inline_size = match ordinal {
2440                1 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2441                2 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2442                _ => return Err(fidl::Error::UnknownUnionTag),
2443            };
2444
2445            if inlined != (member_inline_size <= 4) {
2446                return Err(fidl::Error::InvalidInlineBitInEnvelope);
2447            }
2448            let _inner_offset;
2449            if inlined {
2450                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
2451                _inner_offset = offset + 8;
2452            } else {
2453                depth.increment()?;
2454                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2455            }
2456            match ordinal {
2457                1 => {
2458                    #[allow(irrefutable_let_patterns)]
2459                    if let ProtocolAssociation::All(_) = self {
2460                        // Do nothing, read the value into the object
2461                    } else {
2462                        // Initialize `self` to the right variant
2463                        *self = ProtocolAssociation::All(fidl::new_empty!(Empty, D));
2464                    }
2465                    #[allow(irrefutable_let_patterns)]
2466                    if let ProtocolAssociation::All(ref mut val) = self {
2467                        fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
2468                    } else {
2469                        unreachable!()
2470                    }
2471                }
2472                2 => {
2473                    #[allow(irrefutable_let_patterns)]
2474                    if let ProtocolAssociation::Specified(_) = self {
2475                        // Do nothing, read the value into the object
2476                    } else {
2477                        // Initialize `self` to the right variant
2478                        *self = ProtocolAssociation::Specified(fidl::new_empty!(u16, D));
2479                    }
2480                    #[allow(irrefutable_let_patterns)]
2481                    if let ProtocolAssociation::Specified(ref mut val) = self {
2482                        fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
2483                    } else {
2484                        unreachable!()
2485                    }
2486                }
2487                ordinal => panic!("unexpected ordinal {:?}", ordinal),
2488            }
2489            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
2490                return Err(fidl::Error::InvalidNumBytesInEnvelope);
2491            }
2492            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2493                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2494            }
2495            Ok(())
2496        }
2497    }
2498}