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
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 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 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 unsafe {
333 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
334 (ptr as *mut u64).write_unaligned(0);
335 }
336 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 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 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 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 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 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 let mut _next_ordinal_to_read = 0;
468 let mut next_offset = offset;
469 let end_offset = offset + bytes_len;
470
471 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
547
548 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
550
551 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 let cur_offset: usize = (2 - 1) * envelope_size;
570
571 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
573
574 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 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
783
784 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
786
787 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 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 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 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 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}