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 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 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
26 pub struct FileFlags: u64 {
27 const RIGHT_READABLE = 1;
29 const RIGHT_WRITABLE = 2;
31 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 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
56 pub struct ReadFlags: u64 {
57 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
117mod internal {
118 use super::*;
119 unsafe impl fidl::encoding::TypeMarker for FileFlags {
120 type Owned = Self;
121
122 #[inline(always)]
123 fn inline_align(_context: fidl::encoding::Context) -> usize {
124 8
125 }
126
127 #[inline(always)]
128 fn inline_size(_context: fidl::encoding::Context) -> usize {
129 8
130 }
131 }
132
133 impl fidl::encoding::ValueTypeMarker for FileFlags {
134 type Borrowed<'a> = Self;
135 #[inline(always)]
136 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
137 *value
138 }
139 }
140
141 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for FileFlags {
142 #[inline]
143 unsafe fn encode(
144 self,
145 encoder: &mut fidl::encoding::Encoder<'_, D>,
146 offset: usize,
147 _depth: fidl::encoding::Depth,
148 ) -> fidl::Result<()> {
149 encoder.debug_check_bounds::<Self>(offset);
150 encoder.write_num(self.bits(), offset);
151 Ok(())
152 }
153 }
154
155 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FileFlags {
156 #[inline(always)]
157 fn new_empty() -> Self {
158 Self::empty()
159 }
160
161 #[inline]
162 unsafe fn decode(
163 &mut self,
164 decoder: &mut fidl::encoding::Decoder<'_, D>,
165 offset: usize,
166 _depth: fidl::encoding::Depth,
167 ) -> fidl::Result<()> {
168 decoder.debug_check_bounds::<Self>(offset);
169 let prim = decoder.read_num::<u64>(offset);
170 *self = Self::from_bits_allow_unknown(prim);
171 Ok(())
172 }
173 }
174 unsafe impl fidl::encoding::TypeMarker for ReadFlags {
175 type Owned = Self;
176
177 #[inline(always)]
178 fn inline_align(_context: fidl::encoding::Context) -> usize {
179 8
180 }
181
182 #[inline(always)]
183 fn inline_size(_context: fidl::encoding::Context) -> usize {
184 8
185 }
186 }
187
188 impl fidl::encoding::ValueTypeMarker for ReadFlags {
189 type Borrowed<'a> = Self;
190 #[inline(always)]
191 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
192 *value
193 }
194 }
195
196 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ReadFlags {
197 #[inline]
198 unsafe fn encode(
199 self,
200 encoder: &mut fidl::encoding::Encoder<'_, D>,
201 offset: usize,
202 _depth: fidl::encoding::Depth,
203 ) -> fidl::Result<()> {
204 encoder.debug_check_bounds::<Self>(offset);
205 encoder.write_num(self.bits(), offset);
206 Ok(())
207 }
208 }
209
210 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ReadFlags {
211 #[inline(always)]
212 fn new_empty() -> Self {
213 Self::empty()
214 }
215
216 #[inline]
217 unsafe fn decode(
218 &mut self,
219 decoder: &mut fidl::encoding::Decoder<'_, D>,
220 offset: usize,
221 _depth: fidl::encoding::Depth,
222 ) -> fidl::Result<()> {
223 decoder.debug_check_bounds::<Self>(offset);
224 let prim = decoder.read_num::<u64>(offset);
225 *self = Self::from_bits_allow_unknown(prim);
226 Ok(())
227 }
228 }
229
230 impl fidl::encoding::ValueTypeMarker for BinderIoctlRequest {
231 type Borrowed<'a> = &'a Self;
232 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
233 value
234 }
235 }
236
237 unsafe impl fidl::encoding::TypeMarker for BinderIoctlRequest {
238 type Owned = Self;
239
240 #[inline(always)]
241 fn inline_align(_context: fidl::encoding::Context) -> usize {
242 8
243 }
244
245 #[inline(always)]
246 fn inline_size(_context: fidl::encoding::Context) -> usize {
247 24
248 }
249 }
250
251 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BinderIoctlRequest, D>
252 for &BinderIoctlRequest
253 {
254 #[inline]
255 unsafe fn encode(
256 self,
257 encoder: &mut fidl::encoding::Encoder<'_, D>,
258 offset: usize,
259 _depth: fidl::encoding::Depth,
260 ) -> fidl::Result<()> {
261 encoder.debug_check_bounds::<BinderIoctlRequest>(offset);
262 unsafe {
263 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
265 (buf_ptr as *mut BinderIoctlRequest)
266 .write_unaligned((self as *const BinderIoctlRequest).read());
267 let padding_ptr = buf_ptr.offset(8) as *mut u64;
270 let padding_mask = 0xffffffff00000000u64;
271 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
272 }
273 Ok(())
274 }
275 }
276 unsafe impl<
277 D: fidl::encoding::ResourceDialect,
278 T0: fidl::encoding::Encode<u64, D>,
279 T1: fidl::encoding::Encode<u32, D>,
280 T2: fidl::encoding::Encode<u64, D>,
281 > fidl::encoding::Encode<BinderIoctlRequest, D> for (T0, T1, T2)
282 {
283 #[inline]
284 unsafe fn encode(
285 self,
286 encoder: &mut fidl::encoding::Encoder<'_, D>,
287 offset: usize,
288 depth: fidl::encoding::Depth,
289 ) -> fidl::Result<()> {
290 encoder.debug_check_bounds::<BinderIoctlRequest>(offset);
291 unsafe {
294 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
295 (ptr as *mut u64).write_unaligned(0);
296 }
297 self.0.encode(encoder, offset + 0, depth)?;
299 self.1.encode(encoder, offset + 8, depth)?;
300 self.2.encode(encoder, offset + 16, depth)?;
301 Ok(())
302 }
303 }
304
305 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BinderIoctlRequest {
306 #[inline(always)]
307 fn new_empty() -> Self {
308 Self {
309 tid: fidl::new_empty!(u64, D),
310 request: fidl::new_empty!(u32, D),
311 parameter: fidl::new_empty!(u64, D),
312 }
313 }
314
315 #[inline]
316 unsafe fn decode(
317 &mut self,
318 decoder: &mut fidl::encoding::Decoder<'_, D>,
319 offset: usize,
320 _depth: fidl::encoding::Depth,
321 ) -> fidl::Result<()> {
322 decoder.debug_check_bounds::<Self>(offset);
323 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
324 let ptr = unsafe { buf_ptr.offset(8) };
326 let padval = unsafe { (ptr as *const u64).read_unaligned() };
327 let mask = 0xffffffff00000000u64;
328 let maskedval = padval & mask;
329 if maskedval != 0 {
330 return Err(fidl::Error::NonZeroPadding {
331 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
332 });
333 }
334 unsafe {
336 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 24);
337 }
338 Ok(())
339 }
340 }
341
342 impl UnixDomainSocketGetEventRequest {
343 #[inline(always)]
344 fn max_ordinal_present(&self) -> u64 {
345 0
346 }
347 }
348
349 impl fidl::encoding::ValueTypeMarker for UnixDomainSocketGetEventRequest {
350 type Borrowed<'a> = &'a Self;
351 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
352 value
353 }
354 }
355
356 unsafe impl fidl::encoding::TypeMarker for UnixDomainSocketGetEventRequest {
357 type Owned = Self;
358
359 #[inline(always)]
360 fn inline_align(_context: fidl::encoding::Context) -> usize {
361 8
362 }
363
364 #[inline(always)]
365 fn inline_size(_context: fidl::encoding::Context) -> usize {
366 16
367 }
368 }
369
370 unsafe impl<D: fidl::encoding::ResourceDialect>
371 fidl::encoding::Encode<UnixDomainSocketGetEventRequest, D>
372 for &UnixDomainSocketGetEventRequest
373 {
374 unsafe fn encode(
375 self,
376 encoder: &mut fidl::encoding::Encoder<'_, D>,
377 offset: usize,
378 mut depth: fidl::encoding::Depth,
379 ) -> fidl::Result<()> {
380 encoder.debug_check_bounds::<UnixDomainSocketGetEventRequest>(offset);
381 let max_ordinal: u64 = self.max_ordinal_present();
383 encoder.write_num(max_ordinal, offset);
384 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
385 if max_ordinal == 0 {
387 return Ok(());
388 }
389 depth.increment()?;
390 let envelope_size = 8;
391 let bytes_len = max_ordinal as usize * envelope_size;
392 #[allow(unused_variables)]
393 let offset = encoder.out_of_line_offset(bytes_len);
394 let mut _prev_end_offset: usize = 0;
395
396 Ok(())
397 }
398 }
399
400 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
401 for UnixDomainSocketGetEventRequest
402 {
403 #[inline(always)]
404 fn new_empty() -> Self {
405 Self::default()
406 }
407
408 unsafe fn decode(
409 &mut self,
410 decoder: &mut fidl::encoding::Decoder<'_, D>,
411 offset: usize,
412 mut depth: fidl::encoding::Depth,
413 ) -> fidl::Result<()> {
414 decoder.debug_check_bounds::<Self>(offset);
415 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
416 None => return Err(fidl::Error::NotNullable),
417 Some(len) => len,
418 };
419 if len == 0 {
421 return Ok(());
422 };
423 depth.increment()?;
424 let envelope_size = 8;
425 let bytes_len = len * envelope_size;
426 let offset = decoder.out_of_line_offset(bytes_len)?;
427 let mut _next_ordinal_to_read = 0;
429 let mut next_offset = offset;
430 let end_offset = offset + bytes_len;
431
432 while next_offset < end_offset {
434 _next_ordinal_to_read += 1;
435 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
436 next_offset += envelope_size;
437 }
438
439 Ok(())
440 }
441 }
442
443 impl UnixDomainSocketReadRequest {
444 #[inline(always)]
445 fn max_ordinal_present(&self) -> u64 {
446 if let Some(_) = self.flags {
447 return 2;
448 }
449 if let Some(_) = self.count {
450 return 1;
451 }
452 0
453 }
454 }
455
456 impl fidl::encoding::ValueTypeMarker for UnixDomainSocketReadRequest {
457 type Borrowed<'a> = &'a Self;
458 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
459 value
460 }
461 }
462
463 unsafe impl fidl::encoding::TypeMarker for UnixDomainSocketReadRequest {
464 type Owned = Self;
465
466 #[inline(always)]
467 fn inline_align(_context: fidl::encoding::Context) -> usize {
468 8
469 }
470
471 #[inline(always)]
472 fn inline_size(_context: fidl::encoding::Context) -> usize {
473 16
474 }
475 }
476
477 unsafe impl<D: fidl::encoding::ResourceDialect>
478 fidl::encoding::Encode<UnixDomainSocketReadRequest, D> for &UnixDomainSocketReadRequest
479 {
480 unsafe fn encode(
481 self,
482 encoder: &mut fidl::encoding::Encoder<'_, D>,
483 offset: usize,
484 mut depth: fidl::encoding::Depth,
485 ) -> fidl::Result<()> {
486 encoder.debug_check_bounds::<UnixDomainSocketReadRequest>(offset);
487 let max_ordinal: u64 = self.max_ordinal_present();
489 encoder.write_num(max_ordinal, offset);
490 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
491 if max_ordinal == 0 {
493 return Ok(());
494 }
495 depth.increment()?;
496 let envelope_size = 8;
497 let bytes_len = max_ordinal as usize * envelope_size;
498 #[allow(unused_variables)]
499 let offset = encoder.out_of_line_offset(bytes_len);
500 let mut _prev_end_offset: usize = 0;
501 if 1 > max_ordinal {
502 return Ok(());
503 }
504
505 let cur_offset: usize = (1 - 1) * envelope_size;
508
509 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
511
512 fidl::encoding::encode_in_envelope_optional::<u64, D>(
517 self.count.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
518 encoder,
519 offset + cur_offset,
520 depth,
521 )?;
522
523 _prev_end_offset = cur_offset + envelope_size;
524 if 2 > max_ordinal {
525 return Ok(());
526 }
527
528 let cur_offset: usize = (2 - 1) * envelope_size;
531
532 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
534
535 fidl::encoding::encode_in_envelope_optional::<ReadFlags, D>(
540 self.flags.as_ref().map(<ReadFlags as fidl::encoding::ValueTypeMarker>::borrow),
541 encoder,
542 offset + cur_offset,
543 depth,
544 )?;
545
546 _prev_end_offset = cur_offset + envelope_size;
547
548 Ok(())
549 }
550 }
551
552 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
553 for UnixDomainSocketReadRequest
554 {
555 #[inline(always)]
556 fn new_empty() -> Self {
557 Self::default()
558 }
559
560 unsafe fn decode(
561 &mut self,
562 decoder: &mut fidl::encoding::Decoder<'_, D>,
563 offset: usize,
564 mut depth: fidl::encoding::Depth,
565 ) -> fidl::Result<()> {
566 decoder.debug_check_bounds::<Self>(offset);
567 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
568 None => return Err(fidl::Error::NotNullable),
569 Some(len) => len,
570 };
571 if len == 0 {
573 return Ok(());
574 };
575 depth.increment()?;
576 let envelope_size = 8;
577 let bytes_len = len * envelope_size;
578 let offset = decoder.out_of_line_offset(bytes_len)?;
579 let mut _next_ordinal_to_read = 0;
581 let mut next_offset = offset;
582 let end_offset = offset + bytes_len;
583 _next_ordinal_to_read += 1;
584 if next_offset >= end_offset {
585 return Ok(());
586 }
587
588 while _next_ordinal_to_read < 1 {
590 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
591 _next_ordinal_to_read += 1;
592 next_offset += envelope_size;
593 }
594
595 let next_out_of_line = decoder.next_out_of_line();
596 let handles_before = decoder.remaining_handles();
597 if let Some((inlined, num_bytes, num_handles)) =
598 fidl::encoding::decode_envelope_header(decoder, next_offset)?
599 {
600 let member_inline_size =
601 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
602 if inlined != (member_inline_size <= 4) {
603 return Err(fidl::Error::InvalidInlineBitInEnvelope);
604 }
605 let inner_offset;
606 let mut inner_depth = depth.clone();
607 if inlined {
608 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
609 inner_offset = next_offset;
610 } else {
611 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
612 inner_depth.increment()?;
613 }
614 let val_ref = self.count.get_or_insert_with(|| fidl::new_empty!(u64, D));
615 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
616 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
617 {
618 return Err(fidl::Error::InvalidNumBytesInEnvelope);
619 }
620 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
621 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
622 }
623 }
624
625 next_offset += envelope_size;
626 _next_ordinal_to_read += 1;
627 if next_offset >= end_offset {
628 return Ok(());
629 }
630
631 while _next_ordinal_to_read < 2 {
633 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
634 _next_ordinal_to_read += 1;
635 next_offset += envelope_size;
636 }
637
638 let next_out_of_line = decoder.next_out_of_line();
639 let handles_before = decoder.remaining_handles();
640 if let Some((inlined, num_bytes, num_handles)) =
641 fidl::encoding::decode_envelope_header(decoder, next_offset)?
642 {
643 let member_inline_size =
644 <ReadFlags as fidl::encoding::TypeMarker>::inline_size(decoder.context);
645 if inlined != (member_inline_size <= 4) {
646 return Err(fidl::Error::InvalidInlineBitInEnvelope);
647 }
648 let inner_offset;
649 let mut inner_depth = depth.clone();
650 if inlined {
651 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
652 inner_offset = next_offset;
653 } else {
654 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
655 inner_depth.increment()?;
656 }
657 let val_ref = self.flags.get_or_insert_with(|| fidl::new_empty!(ReadFlags, D));
658 fidl::decode!(ReadFlags, D, val_ref, decoder, inner_offset, inner_depth)?;
659 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
660 {
661 return Err(fidl::Error::InvalidNumBytesInEnvelope);
662 }
663 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
664 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
665 }
666 }
667
668 next_offset += envelope_size;
669
670 while next_offset < end_offset {
672 _next_ordinal_to_read += 1;
673 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
674 next_offset += envelope_size;
675 }
676
677 Ok(())
678 }
679 }
680
681 impl UnixDomainSocketWriteResponse {
682 #[inline(always)]
683 fn max_ordinal_present(&self) -> u64 {
684 if let Some(_) = self.actual_count {
685 return 1;
686 }
687 0
688 }
689 }
690
691 impl fidl::encoding::ValueTypeMarker for UnixDomainSocketWriteResponse {
692 type Borrowed<'a> = &'a Self;
693 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
694 value
695 }
696 }
697
698 unsafe impl fidl::encoding::TypeMarker for UnixDomainSocketWriteResponse {
699 type Owned = Self;
700
701 #[inline(always)]
702 fn inline_align(_context: fidl::encoding::Context) -> usize {
703 8
704 }
705
706 #[inline(always)]
707 fn inline_size(_context: fidl::encoding::Context) -> usize {
708 16
709 }
710 }
711
712 unsafe impl<D: fidl::encoding::ResourceDialect>
713 fidl::encoding::Encode<UnixDomainSocketWriteResponse, D>
714 for &UnixDomainSocketWriteResponse
715 {
716 unsafe fn encode(
717 self,
718 encoder: &mut fidl::encoding::Encoder<'_, D>,
719 offset: usize,
720 mut depth: fidl::encoding::Depth,
721 ) -> fidl::Result<()> {
722 encoder.debug_check_bounds::<UnixDomainSocketWriteResponse>(offset);
723 let max_ordinal: u64 = self.max_ordinal_present();
725 encoder.write_num(max_ordinal, offset);
726 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
727 if max_ordinal == 0 {
729 return Ok(());
730 }
731 depth.increment()?;
732 let envelope_size = 8;
733 let bytes_len = max_ordinal as usize * envelope_size;
734 #[allow(unused_variables)]
735 let offset = encoder.out_of_line_offset(bytes_len);
736 let mut _prev_end_offset: usize = 0;
737 if 1 > max_ordinal {
738 return Ok(());
739 }
740
741 let cur_offset: usize = (1 - 1) * envelope_size;
744
745 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
747
748 fidl::encoding::encode_in_envelope_optional::<u64, D>(
753 self.actual_count.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
754 encoder,
755 offset + cur_offset,
756 depth,
757 )?;
758
759 _prev_end_offset = cur_offset + envelope_size;
760
761 Ok(())
762 }
763 }
764
765 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
766 for UnixDomainSocketWriteResponse
767 {
768 #[inline(always)]
769 fn new_empty() -> Self {
770 Self::default()
771 }
772
773 unsafe fn decode(
774 &mut self,
775 decoder: &mut fidl::encoding::Decoder<'_, D>,
776 offset: usize,
777 mut depth: fidl::encoding::Depth,
778 ) -> fidl::Result<()> {
779 decoder.debug_check_bounds::<Self>(offset);
780 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
781 None => return Err(fidl::Error::NotNullable),
782 Some(len) => len,
783 };
784 if len == 0 {
786 return Ok(());
787 };
788 depth.increment()?;
789 let envelope_size = 8;
790 let bytes_len = len * envelope_size;
791 let offset = decoder.out_of_line_offset(bytes_len)?;
792 let mut _next_ordinal_to_read = 0;
794 let mut next_offset = offset;
795 let end_offset = offset + bytes_len;
796 _next_ordinal_to_read += 1;
797 if next_offset >= end_offset {
798 return Ok(());
799 }
800
801 while _next_ordinal_to_read < 1 {
803 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
804 _next_ordinal_to_read += 1;
805 next_offset += envelope_size;
806 }
807
808 let next_out_of_line = decoder.next_out_of_line();
809 let handles_before = decoder.remaining_handles();
810 if let Some((inlined, num_bytes, num_handles)) =
811 fidl::encoding::decode_envelope_header(decoder, next_offset)?
812 {
813 let member_inline_size =
814 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
815 if inlined != (member_inline_size <= 4) {
816 return Err(fidl::Error::InvalidInlineBitInEnvelope);
817 }
818 let inner_offset;
819 let mut inner_depth = depth.clone();
820 if inlined {
821 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
822 inner_offset = next_offset;
823 } else {
824 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
825 inner_depth.increment()?;
826 }
827 let val_ref = self.actual_count.get_or_insert_with(|| fidl::new_empty!(u64, D));
828 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
829 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
830 {
831 return Err(fidl::Error::InvalidNumBytesInEnvelope);
832 }
833 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
834 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
835 }
836 }
837
838 next_offset += envelope_size;
839
840 while next_offset < end_offset {
842 _next_ordinal_to_read += 1;
843 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
844 next_offset += envelope_size;
845 }
846
847 Ok(())
848 }
849 }
850}