fidl_fuchsia_starnix_binder__common/
fidl_fuchsia_starnix_binder__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
11pub type Fd = i32;
12
13pub const MAX_HANDLE_COUNT: u64 = 8;
14
15pub const MAX_PATH_LENGTH: u64 = 4095;
16
17pub const MAX_REQUEST_COUNT: u64 = 16;
18
19pub const MAX_WRITE_BYTES: u64 = 32768;
20
21pub const UNIX_DOMAIN_SOCKET_PROTOCOL_NAME: &str = "fuchsia.starnix.binder/UnixDomainSocket";
22
23bitflags! {
24    /// The flags associated with an opened file.
25    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
26    pub struct FileFlags: u64 {
27        /// The owner can read the file.
28        const RIGHT_READABLE = 1;
29        /// The owner can write to fhe file.
30        const RIGHT_WRITABLE = 2;
31        /// The file is a directory.
32        const DIRECTORY = 4096;
33    }
34}
35
36impl FileFlags {
37    #[inline(always)]
38    pub fn from_bits_allow_unknown(bits: u64) -> Self {
39        Self::from_bits_retain(bits)
40    }
41
42    #[inline(always)]
43    pub fn has_unknown_bits(&self) -> bool {
44        self.get_unknown_bits() != 0
45    }
46
47    #[inline(always)]
48    pub fn get_unknown_bits(&self) -> u64 {
49        self.bits() & !Self::all().bits()
50    }
51}
52
53bitflags! {
54    /// The flags when reading from an unix domain socket
55    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
56    pub struct ReadFlags: u64 {
57        /// When set, the data must not be removed from the queue and the next read
58        /// must resend the same data.
59        const PEEK = 1;
60    }
61}
62
63impl ReadFlags {
64    #[inline(always)]
65    pub fn from_bits_allow_unknown(bits: u64) -> Self {
66        Self::from_bits_retain(bits)
67    }
68
69    #[inline(always)]
70    pub fn has_unknown_bits(&self) -> bool {
71        self.get_unknown_bits() != 0
72    }
73
74    #[inline(always)]
75    pub fn get_unknown_bits(&self) -> u64 {
76        self.bits() & !Self::all().bits()
77    }
78}
79
80#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
81#[repr(C)]
82pub struct BinderIoctlRequest {
83    pub tid: u64,
84    pub request: u32,
85    pub parameter: u64,
86}
87
88impl fidl::Persistable for BinderIoctlRequest {}
89
90#[derive(Clone, Debug, Default, PartialEq)]
91pub struct UnixDomainSocketGetEventRequest {
92    #[doc(hidden)]
93    pub __source_breaking: fidl::marker::SourceBreaking,
94}
95
96impl fidl::Persistable for UnixDomainSocketGetEventRequest {}
97
98#[derive(Clone, Debug, Default, PartialEq)]
99pub struct UnixDomainSocketReadRequest {
100    pub count: Option<u64>,
101    pub flags: Option<ReadFlags>,
102    #[doc(hidden)]
103    pub __source_breaking: fidl::marker::SourceBreaking,
104}
105
106impl fidl::Persistable for UnixDomainSocketReadRequest {}
107
108#[derive(Clone, Debug, Default, PartialEq)]
109pub struct UnixDomainSocketWriteResponse {
110    pub actual_count: Option<u64>,
111    #[doc(hidden)]
112    pub __source_breaking: fidl::marker::SourceBreaking,
113}
114
115impl fidl::Persistable for UnixDomainSocketWriteResponse {}
116
117pub mod binder_ordinals {
118    pub const SET_VMO: u64 = 0x43ee5d8f7d3acbf6;
119    pub const IOCTL: u64 = 0x1032021e21310000;
120}
121
122pub mod container_power_controller_ordinals {
123    pub const WAKE: u64 = 0x31dc1b2d1e00a094;
124    pub const REGISTER_WAKE_WATCHER: u64 = 0x5a08c36d7c9c5703;
125}
126
127pub mod dev_binder_ordinals {
128    pub const OPEN: u64 = 0x250f5ee034977685;
129    pub const CLOSE: u64 = 0x50b39ce5c9bae3b1;
130}
131
132pub mod lutex_controller_ordinals {
133    pub const WAIT_BITSET: u64 = 0x489feee6787d11b1;
134    pub const WAKE_BITSET: u64 = 0x58309f6ebcb0d8eb;
135}
136
137pub mod process_accessor_ordinals {
138    pub const WRITE_MEMORY: u64 = 0x666cda7c6b6d4819;
139    pub const WRITE_BYTES: u64 = 0x6f94296329cb8d17;
140    pub const FILE_REQUEST: u64 = 0xd42103a37c3f0a;
141}
142
143pub mod remote_controller_ordinals {
144    pub const START: u64 = 0x72ecbe863c65f4cf;
145}
146
147pub mod unix_domain_socket_ordinals {
148    pub const CLONE: u64 = 0x20d8a7aba2168a79;
149    pub const CLOSE: u64 = 0x5ac5d459ad7f657e;
150    pub const QUERY: u64 = 0x2658edee9decfc06;
151    pub const GET_EVENT: u64 = 0x4d79eb8f83961b41;
152    pub const READ: u64 = 0x65ece02b0a73a069;
153    pub const WRITE: u64 = 0x2339b58d4b835aee;
154}
155
156mod internal {
157    use super::*;
158    unsafe impl fidl::encoding::TypeMarker for FileFlags {
159        type Owned = Self;
160
161        #[inline(always)]
162        fn inline_align(_context: fidl::encoding::Context) -> usize {
163            8
164        }
165
166        #[inline(always)]
167        fn inline_size(_context: fidl::encoding::Context) -> usize {
168            8
169        }
170    }
171
172    impl fidl::encoding::ValueTypeMarker for FileFlags {
173        type Borrowed<'a> = Self;
174        #[inline(always)]
175        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
176            *value
177        }
178    }
179
180    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for FileFlags {
181        #[inline]
182        unsafe fn encode(
183            self,
184            encoder: &mut fidl::encoding::Encoder<'_, D>,
185            offset: usize,
186            _depth: fidl::encoding::Depth,
187        ) -> fidl::Result<()> {
188            encoder.debug_check_bounds::<Self>(offset);
189            encoder.write_num(self.bits(), offset);
190            Ok(())
191        }
192    }
193
194    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FileFlags {
195        #[inline(always)]
196        fn new_empty() -> Self {
197            Self::empty()
198        }
199
200        #[inline]
201        unsafe fn decode(
202            &mut self,
203            decoder: &mut fidl::encoding::Decoder<'_, D>,
204            offset: usize,
205            _depth: fidl::encoding::Depth,
206        ) -> fidl::Result<()> {
207            decoder.debug_check_bounds::<Self>(offset);
208            let prim = decoder.read_num::<u64>(offset);
209            *self = Self::from_bits_allow_unknown(prim);
210            Ok(())
211        }
212    }
213    unsafe impl fidl::encoding::TypeMarker for ReadFlags {
214        type Owned = Self;
215
216        #[inline(always)]
217        fn inline_align(_context: fidl::encoding::Context) -> usize {
218            8
219        }
220
221        #[inline(always)]
222        fn inline_size(_context: fidl::encoding::Context) -> usize {
223            8
224        }
225    }
226
227    impl fidl::encoding::ValueTypeMarker for ReadFlags {
228        type Borrowed<'a> = Self;
229        #[inline(always)]
230        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
231            *value
232        }
233    }
234
235    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ReadFlags {
236        #[inline]
237        unsafe fn encode(
238            self,
239            encoder: &mut fidl::encoding::Encoder<'_, D>,
240            offset: usize,
241            _depth: fidl::encoding::Depth,
242        ) -> fidl::Result<()> {
243            encoder.debug_check_bounds::<Self>(offset);
244            encoder.write_num(self.bits(), offset);
245            Ok(())
246        }
247    }
248
249    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ReadFlags {
250        #[inline(always)]
251        fn new_empty() -> Self {
252            Self::empty()
253        }
254
255        #[inline]
256        unsafe fn decode(
257            &mut self,
258            decoder: &mut fidl::encoding::Decoder<'_, D>,
259            offset: usize,
260            _depth: fidl::encoding::Depth,
261        ) -> fidl::Result<()> {
262            decoder.debug_check_bounds::<Self>(offset);
263            let prim = decoder.read_num::<u64>(offset);
264            *self = Self::from_bits_allow_unknown(prim);
265            Ok(())
266        }
267    }
268
269    impl fidl::encoding::ValueTypeMarker for BinderIoctlRequest {
270        type Borrowed<'a> = &'a Self;
271        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
272            value
273        }
274    }
275
276    unsafe impl fidl::encoding::TypeMarker for BinderIoctlRequest {
277        type Owned = Self;
278
279        #[inline(always)]
280        fn inline_align(_context: fidl::encoding::Context) -> usize {
281            8
282        }
283
284        #[inline(always)]
285        fn inline_size(_context: fidl::encoding::Context) -> usize {
286            24
287        }
288    }
289
290    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BinderIoctlRequest, D>
291        for &BinderIoctlRequest
292    {
293        #[inline]
294        unsafe fn encode(
295            self,
296            encoder: &mut fidl::encoding::Encoder<'_, D>,
297            offset: usize,
298            _depth: fidl::encoding::Depth,
299        ) -> fidl::Result<()> {
300            encoder.debug_check_bounds::<BinderIoctlRequest>(offset);
301            unsafe {
302                // Copy the object into the buffer.
303                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
304                (buf_ptr as *mut BinderIoctlRequest)
305                    .write_unaligned((self as *const BinderIoctlRequest).read());
306                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
307                // done second because the memcpy will write garbage to these bytes.
308                let padding_ptr = buf_ptr.offset(8) as *mut u64;
309                let padding_mask = 0xffffffff00000000u64;
310                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
311            }
312            Ok(())
313        }
314    }
315    unsafe impl<
316            D: fidl::encoding::ResourceDialect,
317            T0: fidl::encoding::Encode<u64, D>,
318            T1: fidl::encoding::Encode<u32, D>,
319            T2: fidl::encoding::Encode<u64, D>,
320        > fidl::encoding::Encode<BinderIoctlRequest, D> for (T0, T1, T2)
321    {
322        #[inline]
323        unsafe fn encode(
324            self,
325            encoder: &mut fidl::encoding::Encoder<'_, D>,
326            offset: usize,
327            depth: fidl::encoding::Depth,
328        ) -> fidl::Result<()> {
329            encoder.debug_check_bounds::<BinderIoctlRequest>(offset);
330            // Zero out padding regions. There's no need to apply masks
331            // because the unmasked parts will be overwritten by fields.
332            unsafe {
333                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
334                (ptr as *mut u64).write_unaligned(0);
335            }
336            // Write the fields.
337            self.0.encode(encoder, offset + 0, depth)?;
338            self.1.encode(encoder, offset + 8, depth)?;
339            self.2.encode(encoder, offset + 16, depth)?;
340            Ok(())
341        }
342    }
343
344    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BinderIoctlRequest {
345        #[inline(always)]
346        fn new_empty() -> Self {
347            Self {
348                tid: fidl::new_empty!(u64, D),
349                request: fidl::new_empty!(u32, D),
350                parameter: fidl::new_empty!(u64, D),
351            }
352        }
353
354        #[inline]
355        unsafe fn decode(
356            &mut self,
357            decoder: &mut fidl::encoding::Decoder<'_, D>,
358            offset: usize,
359            _depth: fidl::encoding::Depth,
360        ) -> fidl::Result<()> {
361            decoder.debug_check_bounds::<Self>(offset);
362            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
363            // Verify that padding bytes are zero.
364            let ptr = unsafe { buf_ptr.offset(8) };
365            let padval = unsafe { (ptr as *const u64).read_unaligned() };
366            let mask = 0xffffffff00000000u64;
367            let maskedval = padval & mask;
368            if maskedval != 0 {
369                return Err(fidl::Error::NonZeroPadding {
370                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
371                });
372            }
373            // Copy from the buffer into the object.
374            unsafe {
375                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 24);
376            }
377            Ok(())
378        }
379    }
380
381    impl UnixDomainSocketGetEventRequest {
382        #[inline(always)]
383        fn max_ordinal_present(&self) -> u64 {
384            0
385        }
386    }
387
388    impl fidl::encoding::ValueTypeMarker for UnixDomainSocketGetEventRequest {
389        type Borrowed<'a> = &'a Self;
390        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
391            value
392        }
393    }
394
395    unsafe impl fidl::encoding::TypeMarker for UnixDomainSocketGetEventRequest {
396        type Owned = Self;
397
398        #[inline(always)]
399        fn inline_align(_context: fidl::encoding::Context) -> usize {
400            8
401        }
402
403        #[inline(always)]
404        fn inline_size(_context: fidl::encoding::Context) -> usize {
405            16
406        }
407    }
408
409    unsafe impl<D: fidl::encoding::ResourceDialect>
410        fidl::encoding::Encode<UnixDomainSocketGetEventRequest, D>
411        for &UnixDomainSocketGetEventRequest
412    {
413        unsafe fn encode(
414            self,
415            encoder: &mut fidl::encoding::Encoder<'_, D>,
416            offset: usize,
417            mut depth: fidl::encoding::Depth,
418        ) -> fidl::Result<()> {
419            encoder.debug_check_bounds::<UnixDomainSocketGetEventRequest>(offset);
420            // Vector header
421            let max_ordinal: u64 = self.max_ordinal_present();
422            encoder.write_num(max_ordinal, offset);
423            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
424            // Calling encoder.out_of_line_offset(0) is not allowed.
425            if max_ordinal == 0 {
426                return Ok(());
427            }
428            depth.increment()?;
429            let envelope_size = 8;
430            let bytes_len = max_ordinal as usize * envelope_size;
431            #[allow(unused_variables)]
432            let offset = encoder.out_of_line_offset(bytes_len);
433            let mut _prev_end_offset: usize = 0;
434
435            Ok(())
436        }
437    }
438
439    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
440        for UnixDomainSocketGetEventRequest
441    {
442        #[inline(always)]
443        fn new_empty() -> Self {
444            Self::default()
445        }
446
447        unsafe fn decode(
448            &mut self,
449            decoder: &mut fidl::encoding::Decoder<'_, D>,
450            offset: usize,
451            mut depth: fidl::encoding::Depth,
452        ) -> fidl::Result<()> {
453            decoder.debug_check_bounds::<Self>(offset);
454            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
455                None => return Err(fidl::Error::NotNullable),
456                Some(len) => len,
457            };
458            // Calling decoder.out_of_line_offset(0) is not allowed.
459            if len == 0 {
460                return Ok(());
461            };
462            depth.increment()?;
463            let envelope_size = 8;
464            let bytes_len = len * envelope_size;
465            let offset = decoder.out_of_line_offset(bytes_len)?;
466            // Decode the envelope for each type.
467            let mut _next_ordinal_to_read = 0;
468            let mut next_offset = offset;
469            let end_offset = offset + bytes_len;
470
471            // Decode the remaining unknown envelopes.
472            while next_offset < end_offset {
473                _next_ordinal_to_read += 1;
474                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
475                next_offset += envelope_size;
476            }
477
478            Ok(())
479        }
480    }
481
482    impl UnixDomainSocketReadRequest {
483        #[inline(always)]
484        fn max_ordinal_present(&self) -> u64 {
485            if let Some(_) = self.flags {
486                return 2;
487            }
488            if let Some(_) = self.count {
489                return 1;
490            }
491            0
492        }
493    }
494
495    impl fidl::encoding::ValueTypeMarker for UnixDomainSocketReadRequest {
496        type Borrowed<'a> = &'a Self;
497        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
498            value
499        }
500    }
501
502    unsafe impl fidl::encoding::TypeMarker for UnixDomainSocketReadRequest {
503        type Owned = Self;
504
505        #[inline(always)]
506        fn inline_align(_context: fidl::encoding::Context) -> usize {
507            8
508        }
509
510        #[inline(always)]
511        fn inline_size(_context: fidl::encoding::Context) -> usize {
512            16
513        }
514    }
515
516    unsafe impl<D: fidl::encoding::ResourceDialect>
517        fidl::encoding::Encode<UnixDomainSocketReadRequest, D> for &UnixDomainSocketReadRequest
518    {
519        unsafe fn encode(
520            self,
521            encoder: &mut fidl::encoding::Encoder<'_, D>,
522            offset: usize,
523            mut depth: fidl::encoding::Depth,
524        ) -> fidl::Result<()> {
525            encoder.debug_check_bounds::<UnixDomainSocketReadRequest>(offset);
526            // Vector header
527            let max_ordinal: u64 = self.max_ordinal_present();
528            encoder.write_num(max_ordinal, offset);
529            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
530            // Calling encoder.out_of_line_offset(0) is not allowed.
531            if max_ordinal == 0 {
532                return Ok(());
533            }
534            depth.increment()?;
535            let envelope_size = 8;
536            let bytes_len = max_ordinal as usize * envelope_size;
537            #[allow(unused_variables)]
538            let offset = encoder.out_of_line_offset(bytes_len);
539            let mut _prev_end_offset: usize = 0;
540            if 1 > max_ordinal {
541                return Ok(());
542            }
543
544            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
545            // are envelope_size bytes.
546            let cur_offset: usize = (1 - 1) * envelope_size;
547
548            // Zero reserved fields.
549            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
550
551            // Safety:
552            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
553            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
554            //   envelope_size bytes, there is always sufficient room.
555            fidl::encoding::encode_in_envelope_optional::<u64, D>(
556                self.count.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
557                encoder,
558                offset + cur_offset,
559                depth,
560            )?;
561
562            _prev_end_offset = cur_offset + envelope_size;
563            if 2 > max_ordinal {
564                return Ok(());
565            }
566
567            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
568            // are envelope_size bytes.
569            let cur_offset: usize = (2 - 1) * envelope_size;
570
571            // Zero reserved fields.
572            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
573
574            // Safety:
575            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
576            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
577            //   envelope_size bytes, there is always sufficient room.
578            fidl::encoding::encode_in_envelope_optional::<ReadFlags, D>(
579                self.flags.as_ref().map(<ReadFlags as fidl::encoding::ValueTypeMarker>::borrow),
580                encoder,
581                offset + cur_offset,
582                depth,
583            )?;
584
585            _prev_end_offset = cur_offset + envelope_size;
586
587            Ok(())
588        }
589    }
590
591    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
592        for UnixDomainSocketReadRequest
593    {
594        #[inline(always)]
595        fn new_empty() -> Self {
596            Self::default()
597        }
598
599        unsafe fn decode(
600            &mut self,
601            decoder: &mut fidl::encoding::Decoder<'_, D>,
602            offset: usize,
603            mut depth: fidl::encoding::Depth,
604        ) -> fidl::Result<()> {
605            decoder.debug_check_bounds::<Self>(offset);
606            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
607                None => return Err(fidl::Error::NotNullable),
608                Some(len) => len,
609            };
610            // Calling decoder.out_of_line_offset(0) is not allowed.
611            if len == 0 {
612                return Ok(());
613            };
614            depth.increment()?;
615            let envelope_size = 8;
616            let bytes_len = len * envelope_size;
617            let offset = decoder.out_of_line_offset(bytes_len)?;
618            // Decode the envelope for each type.
619            let mut _next_ordinal_to_read = 0;
620            let mut next_offset = offset;
621            let end_offset = offset + bytes_len;
622            _next_ordinal_to_read += 1;
623            if next_offset >= end_offset {
624                return Ok(());
625            }
626
627            // Decode unknown envelopes for gaps in ordinals.
628            while _next_ordinal_to_read < 1 {
629                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
630                _next_ordinal_to_read += 1;
631                next_offset += envelope_size;
632            }
633
634            let next_out_of_line = decoder.next_out_of_line();
635            let handles_before = decoder.remaining_handles();
636            if let Some((inlined, num_bytes, num_handles)) =
637                fidl::encoding::decode_envelope_header(decoder, next_offset)?
638            {
639                let member_inline_size =
640                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
641                if inlined != (member_inline_size <= 4) {
642                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
643                }
644                let inner_offset;
645                let mut inner_depth = depth.clone();
646                if inlined {
647                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
648                    inner_offset = next_offset;
649                } else {
650                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
651                    inner_depth.increment()?;
652                }
653                let val_ref = self.count.get_or_insert_with(|| fidl::new_empty!(u64, D));
654                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
655                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
656                {
657                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
658                }
659                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
660                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
661                }
662            }
663
664            next_offset += envelope_size;
665            _next_ordinal_to_read += 1;
666            if next_offset >= end_offset {
667                return Ok(());
668            }
669
670            // Decode unknown envelopes for gaps in ordinals.
671            while _next_ordinal_to_read < 2 {
672                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
673                _next_ordinal_to_read += 1;
674                next_offset += envelope_size;
675            }
676
677            let next_out_of_line = decoder.next_out_of_line();
678            let handles_before = decoder.remaining_handles();
679            if let Some((inlined, num_bytes, num_handles)) =
680                fidl::encoding::decode_envelope_header(decoder, next_offset)?
681            {
682                let member_inline_size =
683                    <ReadFlags as fidl::encoding::TypeMarker>::inline_size(decoder.context);
684                if inlined != (member_inline_size <= 4) {
685                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
686                }
687                let inner_offset;
688                let mut inner_depth = depth.clone();
689                if inlined {
690                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
691                    inner_offset = next_offset;
692                } else {
693                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
694                    inner_depth.increment()?;
695                }
696                let val_ref = self.flags.get_or_insert_with(|| fidl::new_empty!(ReadFlags, D));
697                fidl::decode!(ReadFlags, D, val_ref, decoder, inner_offset, inner_depth)?;
698                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
699                {
700                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
701                }
702                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
703                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
704                }
705            }
706
707            next_offset += envelope_size;
708
709            // Decode the remaining unknown envelopes.
710            while next_offset < end_offset {
711                _next_ordinal_to_read += 1;
712                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
713                next_offset += envelope_size;
714            }
715
716            Ok(())
717        }
718    }
719
720    impl UnixDomainSocketWriteResponse {
721        #[inline(always)]
722        fn max_ordinal_present(&self) -> u64 {
723            if let Some(_) = self.actual_count {
724                return 1;
725            }
726            0
727        }
728    }
729
730    impl fidl::encoding::ValueTypeMarker for UnixDomainSocketWriteResponse {
731        type Borrowed<'a> = &'a Self;
732        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
733            value
734        }
735    }
736
737    unsafe impl fidl::encoding::TypeMarker for UnixDomainSocketWriteResponse {
738        type Owned = Self;
739
740        #[inline(always)]
741        fn inline_align(_context: fidl::encoding::Context) -> usize {
742            8
743        }
744
745        #[inline(always)]
746        fn inline_size(_context: fidl::encoding::Context) -> usize {
747            16
748        }
749    }
750
751    unsafe impl<D: fidl::encoding::ResourceDialect>
752        fidl::encoding::Encode<UnixDomainSocketWriteResponse, D>
753        for &UnixDomainSocketWriteResponse
754    {
755        unsafe fn encode(
756            self,
757            encoder: &mut fidl::encoding::Encoder<'_, D>,
758            offset: usize,
759            mut depth: fidl::encoding::Depth,
760        ) -> fidl::Result<()> {
761            encoder.debug_check_bounds::<UnixDomainSocketWriteResponse>(offset);
762            // Vector header
763            let max_ordinal: u64 = self.max_ordinal_present();
764            encoder.write_num(max_ordinal, offset);
765            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
766            // Calling encoder.out_of_line_offset(0) is not allowed.
767            if max_ordinal == 0 {
768                return Ok(());
769            }
770            depth.increment()?;
771            let envelope_size = 8;
772            let bytes_len = max_ordinal as usize * envelope_size;
773            #[allow(unused_variables)]
774            let offset = encoder.out_of_line_offset(bytes_len);
775            let mut _prev_end_offset: usize = 0;
776            if 1 > max_ordinal {
777                return Ok(());
778            }
779
780            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
781            // are envelope_size bytes.
782            let cur_offset: usize = (1 - 1) * envelope_size;
783
784            // Zero reserved fields.
785            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
786
787            // Safety:
788            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
789            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
790            //   envelope_size bytes, there is always sufficient room.
791            fidl::encoding::encode_in_envelope_optional::<u64, D>(
792                self.actual_count.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
793                encoder,
794                offset + cur_offset,
795                depth,
796            )?;
797
798            _prev_end_offset = cur_offset + envelope_size;
799
800            Ok(())
801        }
802    }
803
804    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
805        for UnixDomainSocketWriteResponse
806    {
807        #[inline(always)]
808        fn new_empty() -> Self {
809            Self::default()
810        }
811
812        unsafe fn decode(
813            &mut self,
814            decoder: &mut fidl::encoding::Decoder<'_, D>,
815            offset: usize,
816            mut depth: fidl::encoding::Depth,
817        ) -> fidl::Result<()> {
818            decoder.debug_check_bounds::<Self>(offset);
819            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
820                None => return Err(fidl::Error::NotNullable),
821                Some(len) => len,
822            };
823            // Calling decoder.out_of_line_offset(0) is not allowed.
824            if len == 0 {
825                return Ok(());
826            };
827            depth.increment()?;
828            let envelope_size = 8;
829            let bytes_len = len * envelope_size;
830            let offset = decoder.out_of_line_offset(bytes_len)?;
831            // Decode the envelope for each type.
832            let mut _next_ordinal_to_read = 0;
833            let mut next_offset = offset;
834            let end_offset = offset + bytes_len;
835            _next_ordinal_to_read += 1;
836            if next_offset >= end_offset {
837                return Ok(());
838            }
839
840            // Decode unknown envelopes for gaps in ordinals.
841            while _next_ordinal_to_read < 1 {
842                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
843                _next_ordinal_to_read += 1;
844                next_offset += envelope_size;
845            }
846
847            let next_out_of_line = decoder.next_out_of_line();
848            let handles_before = decoder.remaining_handles();
849            if let Some((inlined, num_bytes, num_handles)) =
850                fidl::encoding::decode_envelope_header(decoder, next_offset)?
851            {
852                let member_inline_size =
853                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
854                if inlined != (member_inline_size <= 4) {
855                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
856                }
857                let inner_offset;
858                let mut inner_depth = depth.clone();
859                if inlined {
860                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
861                    inner_offset = next_offset;
862                } else {
863                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
864                    inner_depth.increment()?;
865                }
866                let val_ref = self.actual_count.get_or_insert_with(|| fidl::new_empty!(u64, D));
867                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
868                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
869                {
870                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
871                }
872                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
873                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
874                }
875            }
876
877            next_offset += envelope_size;
878
879            // Decode the remaining unknown envelopes.
880            while next_offset < end_offset {
881                _next_ordinal_to_read += 1;
882                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
883                next_offset += envelope_size;
884            }
885
886            Ok(())
887        }
888    }
889}