1#![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
11pub type Protocol = u16;
16
17pub const SOCKET_PROTOCOL_NAME: &str = "fuchsia.posix.socket.packet/Socket";
18
19#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
21#[repr(u32)]
22pub enum HardwareType {
23 NetworkOnly = 1,
27 Ethernet = 2,
29 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#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
52#[repr(u32)]
53pub enum Kind {
54 Network = 1,
56 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#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
81#[repr(u32)]
82pub enum PacketType {
83 Host = 1,
85 Broadcast = 2,
87 Multicast = 3,
89 OtherHost = 4,
91 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#[derive(Clone, Debug, PartialEq)]
122pub struct InterfaceProperties {
123 pub id: u64,
125 pub addr: HardwareAddress,
127 pub type_: HardwareType,
129}
130
131impl fidl::Persistable for InterfaceProperties {}
132
133#[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 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 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#[derive(Clone, Debug)]
264pub enum HardwareAddress {
265 None(Empty),
267 Eui48(fidl_fuchsia_net__common::MacAddress),
269 #[doc(hidden)]
270 __SourceBreaking { unknown_ordinal: u64 },
271}
272
273#[macro_export]
275macro_rules! HardwareAddressUnknown {
276 () => {
277 _
278 };
279}
280
281impl 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#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
320pub enum ProtocolAssociation {
321 All(Empty),
323 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 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 unsafe {
659 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
660 (ptr as *mut u64).write_unaligned(0);
661 }
662 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 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 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 unsafe {
768 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
769 (ptr as *mut u64).write_unaligned(0);
770 }
771 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 unsafe {
1288 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
1289 (ptr as *mut u64).write_unaligned(0);
1290 }
1291 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 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 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 unsafe {
1419 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1420 (ptr as *mut u64).write_unaligned(0);
1421 }
1422 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 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 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 unsafe {
1542 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
1543 (ptr as *mut u64).write_unaligned(0);
1544 }
1545 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
1667
1668 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1670
1671 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
1840
1841 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1843
1844 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 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 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 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 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 } else {
2048 *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 } else {
2063 *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 } else {
2180 *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 } else {
2195 *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 } else {
2312 *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 } else {
2327 *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 } else {
2462 *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 } else {
2477 *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}