1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_posix_socket_raw__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
15pub struct ProviderSocketWithOptionsResponse {
16 pub s: fidl::endpoints::ClientEnd<SocketMarker>,
17}
18
19impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
20 for ProviderSocketWithOptionsResponse
21{
22}
23
24#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
25pub struct ProviderSocketResponse {
26 pub s: fidl::endpoints::ClientEnd<SocketMarker>,
27}
28
29impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ProviderSocketResponse {}
30
31#[derive(Debug, Default, PartialEq)]
32pub struct SocketDescribeResponse {
33 pub event: Option<fidl::EventPair>,
36 #[doc(hidden)]
37 pub __source_breaking: fidl::marker::SourceBreaking,
38}
39
40impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for SocketDescribeResponse {}
41
42#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
43pub struct ProviderMarker;
44
45impl fidl::endpoints::ProtocolMarker for ProviderMarker {
46 type Proxy = ProviderProxy;
47 type RequestStream = ProviderRequestStream;
48 #[cfg(target_os = "fuchsia")]
49 type SynchronousProxy = ProviderSynchronousProxy;
50
51 const DEBUG_NAME: &'static str = "fuchsia.posix.socket.raw.Provider";
52}
53impl fidl::endpoints::DiscoverableProtocolMarker for ProviderMarker {}
54pub type ProviderSocketResult =
55 Result<fidl::endpoints::ClientEnd<SocketMarker>, fidl_fuchsia_posix::Errno>;
56pub type ProviderSocketWithOptionsResult =
57 Result<fidl::endpoints::ClientEnd<SocketMarker>, fidl_fuchsia_posix::Errno>;
58
59pub trait ProviderProxyInterface: Send + Sync {
60 type SocketResponseFut: std::future::Future<Output = Result<ProviderSocketResult, fidl::Error>>
61 + Send;
62 fn r#socket(
63 &self,
64 domain: fidl_fuchsia_posix_socket::Domain,
65 proto: &ProtocolAssociation,
66 ) -> Self::SocketResponseFut;
67 type SocketWithOptionsResponseFut: std::future::Future<Output = Result<ProviderSocketWithOptionsResult, fidl::Error>>
68 + Send;
69 fn r#socket_with_options(
70 &self,
71 domain: fidl_fuchsia_posix_socket::Domain,
72 proto: &ProtocolAssociation,
73 opts: &fidl_fuchsia_posix_socket::SocketCreationOptions,
74 ) -> Self::SocketWithOptionsResponseFut;
75}
76#[derive(Debug)]
77#[cfg(target_os = "fuchsia")]
78pub struct ProviderSynchronousProxy {
79 client: fidl::client::sync::Client,
80}
81
82#[cfg(target_os = "fuchsia")]
83impl fidl::endpoints::SynchronousProxy for ProviderSynchronousProxy {
84 type Proxy = ProviderProxy;
85 type Protocol = ProviderMarker;
86
87 fn from_channel(inner: fidl::Channel) -> Self {
88 Self::new(inner)
89 }
90
91 fn into_channel(self) -> fidl::Channel {
92 self.client.into_channel()
93 }
94
95 fn as_channel(&self) -> &fidl::Channel {
96 self.client.as_channel()
97 }
98}
99
100#[cfg(target_os = "fuchsia")]
101impl ProviderSynchronousProxy {
102 pub fn new(channel: fidl::Channel) -> Self {
103 let protocol_name = <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
104 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
105 }
106
107 pub fn into_channel(self) -> fidl::Channel {
108 self.client.into_channel()
109 }
110
111 pub fn wait_for_event(
114 &self,
115 deadline: zx::MonotonicInstant,
116 ) -> Result<ProviderEvent, fidl::Error> {
117 ProviderEvent::decode(self.client.wait_for_event(deadline)?)
118 }
119
120 pub fn r#socket(
122 &self,
123 mut domain: fidl_fuchsia_posix_socket::Domain,
124 mut proto: &ProtocolAssociation,
125 ___deadline: zx::MonotonicInstant,
126 ) -> Result<ProviderSocketResult, fidl::Error> {
127 let _response =
128 self.client.send_query::<ProviderSocketRequest, fidl::encoding::ResultType<
129 ProviderSocketResponse,
130 fidl_fuchsia_posix::Errno,
131 >>(
132 (domain, proto),
133 0xdfa6a591ab48fd1,
134 fidl::encoding::DynamicFlags::empty(),
135 ___deadline,
136 )?;
137 Ok(_response.map(|x| x.s))
138 }
139
140 pub fn r#socket_with_options(
142 &self,
143 mut domain: fidl_fuchsia_posix_socket::Domain,
144 mut proto: &ProtocolAssociation,
145 mut opts: &fidl_fuchsia_posix_socket::SocketCreationOptions,
146 ___deadline: zx::MonotonicInstant,
147 ) -> Result<ProviderSocketWithOptionsResult, fidl::Error> {
148 let _response =
149 self.client.send_query::<ProviderSocketWithOptionsRequest, fidl::encoding::ResultType<
150 ProviderSocketWithOptionsResponse,
151 fidl_fuchsia_posix::Errno,
152 >>(
153 (domain, proto, opts),
154 0x34cd6e7e82c46f85,
155 fidl::encoding::DynamicFlags::empty(),
156 ___deadline,
157 )?;
158 Ok(_response.map(|x| x.s))
159 }
160}
161
162#[cfg(target_os = "fuchsia")]
163impl From<ProviderSynchronousProxy> for zx::Handle {
164 fn from(value: ProviderSynchronousProxy) -> Self {
165 value.into_channel().into()
166 }
167}
168
169#[cfg(target_os = "fuchsia")]
170impl From<fidl::Channel> for ProviderSynchronousProxy {
171 fn from(value: fidl::Channel) -> Self {
172 Self::new(value)
173 }
174}
175
176#[cfg(target_os = "fuchsia")]
177impl fidl::endpoints::FromClient for ProviderSynchronousProxy {
178 type Protocol = ProviderMarker;
179
180 fn from_client(value: fidl::endpoints::ClientEnd<ProviderMarker>) -> Self {
181 Self::new(value.into_channel())
182 }
183}
184
185#[derive(Debug, Clone)]
186pub struct ProviderProxy {
187 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
188}
189
190impl fidl::endpoints::Proxy for ProviderProxy {
191 type Protocol = ProviderMarker;
192
193 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
194 Self::new(inner)
195 }
196
197 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
198 self.client.into_channel().map_err(|client| Self { client })
199 }
200
201 fn as_channel(&self) -> &::fidl::AsyncChannel {
202 self.client.as_channel()
203 }
204}
205
206impl ProviderProxy {
207 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
209 let protocol_name = <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
210 Self { client: fidl::client::Client::new(channel, protocol_name) }
211 }
212
213 pub fn take_event_stream(&self) -> ProviderEventStream {
219 ProviderEventStream { event_receiver: self.client.take_event_receiver() }
220 }
221
222 pub fn r#socket(
224 &self,
225 mut domain: fidl_fuchsia_posix_socket::Domain,
226 mut proto: &ProtocolAssociation,
227 ) -> fidl::client::QueryResponseFut<
228 ProviderSocketResult,
229 fidl::encoding::DefaultFuchsiaResourceDialect,
230 > {
231 ProviderProxyInterface::r#socket(self, domain, proto)
232 }
233
234 pub fn r#socket_with_options(
236 &self,
237 mut domain: fidl_fuchsia_posix_socket::Domain,
238 mut proto: &ProtocolAssociation,
239 mut opts: &fidl_fuchsia_posix_socket::SocketCreationOptions,
240 ) -> fidl::client::QueryResponseFut<
241 ProviderSocketWithOptionsResult,
242 fidl::encoding::DefaultFuchsiaResourceDialect,
243 > {
244 ProviderProxyInterface::r#socket_with_options(self, domain, proto, opts)
245 }
246}
247
248impl ProviderProxyInterface for ProviderProxy {
249 type SocketResponseFut = fidl::client::QueryResponseFut<
250 ProviderSocketResult,
251 fidl::encoding::DefaultFuchsiaResourceDialect,
252 >;
253 fn r#socket(
254 &self,
255 mut domain: fidl_fuchsia_posix_socket::Domain,
256 mut proto: &ProtocolAssociation,
257 ) -> Self::SocketResponseFut {
258 fn _decode(
259 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
260 ) -> Result<ProviderSocketResult, fidl::Error> {
261 let _response = fidl::client::decode_transaction_body::<
262 fidl::encoding::ResultType<ProviderSocketResponse, fidl_fuchsia_posix::Errno>,
263 fidl::encoding::DefaultFuchsiaResourceDialect,
264 0xdfa6a591ab48fd1,
265 >(_buf?)?;
266 Ok(_response.map(|x| x.s))
267 }
268 self.client.send_query_and_decode::<ProviderSocketRequest, ProviderSocketResult>(
269 (domain, proto),
270 0xdfa6a591ab48fd1,
271 fidl::encoding::DynamicFlags::empty(),
272 _decode,
273 )
274 }
275
276 type SocketWithOptionsResponseFut = fidl::client::QueryResponseFut<
277 ProviderSocketWithOptionsResult,
278 fidl::encoding::DefaultFuchsiaResourceDialect,
279 >;
280 fn r#socket_with_options(
281 &self,
282 mut domain: fidl_fuchsia_posix_socket::Domain,
283 mut proto: &ProtocolAssociation,
284 mut opts: &fidl_fuchsia_posix_socket::SocketCreationOptions,
285 ) -> Self::SocketWithOptionsResponseFut {
286 fn _decode(
287 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
288 ) -> Result<ProviderSocketWithOptionsResult, fidl::Error> {
289 let _response = fidl::client::decode_transaction_body::<
290 fidl::encoding::ResultType<
291 ProviderSocketWithOptionsResponse,
292 fidl_fuchsia_posix::Errno,
293 >,
294 fidl::encoding::DefaultFuchsiaResourceDialect,
295 0x34cd6e7e82c46f85,
296 >(_buf?)?;
297 Ok(_response.map(|x| x.s))
298 }
299 self.client.send_query_and_decode::<
300 ProviderSocketWithOptionsRequest,
301 ProviderSocketWithOptionsResult,
302 >(
303 (domain, proto, opts,),
304 0x34cd6e7e82c46f85,
305 fidl::encoding::DynamicFlags::empty(),
306 _decode,
307 )
308 }
309}
310
311pub struct ProviderEventStream {
312 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
313}
314
315impl std::marker::Unpin for ProviderEventStream {}
316
317impl futures::stream::FusedStream for ProviderEventStream {
318 fn is_terminated(&self) -> bool {
319 self.event_receiver.is_terminated()
320 }
321}
322
323impl futures::Stream for ProviderEventStream {
324 type Item = Result<ProviderEvent, fidl::Error>;
325
326 fn poll_next(
327 mut self: std::pin::Pin<&mut Self>,
328 cx: &mut std::task::Context<'_>,
329 ) -> std::task::Poll<Option<Self::Item>> {
330 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
331 &mut self.event_receiver,
332 cx
333 )?) {
334 Some(buf) => std::task::Poll::Ready(Some(ProviderEvent::decode(buf))),
335 None => std::task::Poll::Ready(None),
336 }
337 }
338}
339
340#[derive(Debug)]
341pub enum ProviderEvent {}
342
343impl ProviderEvent {
344 fn decode(
346 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
347 ) -> Result<ProviderEvent, fidl::Error> {
348 let (bytes, _handles) = buf.split_mut();
349 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
350 debug_assert_eq!(tx_header.tx_id, 0);
351 match tx_header.ordinal {
352 _ => Err(fidl::Error::UnknownOrdinal {
353 ordinal: tx_header.ordinal,
354 protocol_name: <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
355 }),
356 }
357 }
358}
359
360pub struct ProviderRequestStream {
362 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
363 is_terminated: bool,
364}
365
366impl std::marker::Unpin for ProviderRequestStream {}
367
368impl futures::stream::FusedStream for ProviderRequestStream {
369 fn is_terminated(&self) -> bool {
370 self.is_terminated
371 }
372}
373
374impl fidl::endpoints::RequestStream for ProviderRequestStream {
375 type Protocol = ProviderMarker;
376 type ControlHandle = ProviderControlHandle;
377
378 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
379 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
380 }
381
382 fn control_handle(&self) -> Self::ControlHandle {
383 ProviderControlHandle { inner: self.inner.clone() }
384 }
385
386 fn into_inner(
387 self,
388 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
389 {
390 (self.inner, self.is_terminated)
391 }
392
393 fn from_inner(
394 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
395 is_terminated: bool,
396 ) -> Self {
397 Self { inner, is_terminated }
398 }
399}
400
401impl futures::Stream for ProviderRequestStream {
402 type Item = Result<ProviderRequest, fidl::Error>;
403
404 fn poll_next(
405 mut self: std::pin::Pin<&mut Self>,
406 cx: &mut std::task::Context<'_>,
407 ) -> std::task::Poll<Option<Self::Item>> {
408 let this = &mut *self;
409 if this.inner.check_shutdown(cx) {
410 this.is_terminated = true;
411 return std::task::Poll::Ready(None);
412 }
413 if this.is_terminated {
414 panic!("polled ProviderRequestStream after completion");
415 }
416 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
417 |bytes, handles| {
418 match this.inner.channel().read_etc(cx, bytes, handles) {
419 std::task::Poll::Ready(Ok(())) => {}
420 std::task::Poll::Pending => return std::task::Poll::Pending,
421 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
422 this.is_terminated = true;
423 return std::task::Poll::Ready(None);
424 }
425 std::task::Poll::Ready(Err(e)) => {
426 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
427 e.into(),
428 ))))
429 }
430 }
431
432 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
434
435 std::task::Poll::Ready(Some(match header.ordinal {
436 0xdfa6a591ab48fd1 => {
437 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
438 let mut req = fidl::new_empty!(
439 ProviderSocketRequest,
440 fidl::encoding::DefaultFuchsiaResourceDialect
441 );
442 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderSocketRequest>(&header, _body_bytes, handles, &mut req)?;
443 let control_handle = ProviderControlHandle { inner: this.inner.clone() };
444 Ok(ProviderRequest::Socket {
445 domain: req.domain,
446 proto: req.proto,
447
448 responder: ProviderSocketResponder {
449 control_handle: std::mem::ManuallyDrop::new(control_handle),
450 tx_id: header.tx_id,
451 },
452 })
453 }
454 0x34cd6e7e82c46f85 => {
455 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
456 let mut req = fidl::new_empty!(
457 ProviderSocketWithOptionsRequest,
458 fidl::encoding::DefaultFuchsiaResourceDialect
459 );
460 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderSocketWithOptionsRequest>(&header, _body_bytes, handles, &mut req)?;
461 let control_handle = ProviderControlHandle { inner: this.inner.clone() };
462 Ok(ProviderRequest::SocketWithOptions {
463 domain: req.domain,
464 proto: req.proto,
465 opts: req.opts,
466
467 responder: ProviderSocketWithOptionsResponder {
468 control_handle: std::mem::ManuallyDrop::new(control_handle),
469 tx_id: header.tx_id,
470 },
471 })
472 }
473 _ => Err(fidl::Error::UnknownOrdinal {
474 ordinal: header.ordinal,
475 protocol_name:
476 <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
477 }),
478 }))
479 },
480 )
481 }
482}
483
484#[derive(Debug)]
486pub enum ProviderRequest {
487 Socket {
489 domain: fidl_fuchsia_posix_socket::Domain,
490 proto: ProtocolAssociation,
491 responder: ProviderSocketResponder,
492 },
493 SocketWithOptions {
495 domain: fidl_fuchsia_posix_socket::Domain,
496 proto: ProtocolAssociation,
497 opts: fidl_fuchsia_posix_socket::SocketCreationOptions,
498 responder: ProviderSocketWithOptionsResponder,
499 },
500}
501
502impl ProviderRequest {
503 #[allow(irrefutable_let_patterns)]
504 pub fn into_socket(
505 self,
506 ) -> Option<(fidl_fuchsia_posix_socket::Domain, ProtocolAssociation, ProviderSocketResponder)>
507 {
508 if let ProviderRequest::Socket { domain, proto, responder } = self {
509 Some((domain, proto, responder))
510 } else {
511 None
512 }
513 }
514
515 #[allow(irrefutable_let_patterns)]
516 pub fn into_socket_with_options(
517 self,
518 ) -> Option<(
519 fidl_fuchsia_posix_socket::Domain,
520 ProtocolAssociation,
521 fidl_fuchsia_posix_socket::SocketCreationOptions,
522 ProviderSocketWithOptionsResponder,
523 )> {
524 if let ProviderRequest::SocketWithOptions { domain, proto, opts, responder } = self {
525 Some((domain, proto, opts, responder))
526 } else {
527 None
528 }
529 }
530
531 pub fn method_name(&self) -> &'static str {
533 match *self {
534 ProviderRequest::Socket { .. } => "socket",
535 ProviderRequest::SocketWithOptions { .. } => "socket_with_options",
536 }
537 }
538}
539
540#[derive(Debug, Clone)]
541pub struct ProviderControlHandle {
542 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
543}
544
545impl fidl::endpoints::ControlHandle for ProviderControlHandle {
546 fn shutdown(&self) {
547 self.inner.shutdown()
548 }
549 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
550 self.inner.shutdown_with_epitaph(status)
551 }
552
553 fn is_closed(&self) -> bool {
554 self.inner.channel().is_closed()
555 }
556 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
557 self.inner.channel().on_closed()
558 }
559
560 #[cfg(target_os = "fuchsia")]
561 fn signal_peer(
562 &self,
563 clear_mask: zx::Signals,
564 set_mask: zx::Signals,
565 ) -> Result<(), zx_status::Status> {
566 use fidl::Peered;
567 self.inner.channel().signal_peer(clear_mask, set_mask)
568 }
569}
570
571impl ProviderControlHandle {}
572
573#[must_use = "FIDL methods require a response to be sent"]
574#[derive(Debug)]
575pub struct ProviderSocketResponder {
576 control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
577 tx_id: u32,
578}
579
580impl std::ops::Drop for ProviderSocketResponder {
584 fn drop(&mut self) {
585 self.control_handle.shutdown();
586 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
588 }
589}
590
591impl fidl::endpoints::Responder for ProviderSocketResponder {
592 type ControlHandle = ProviderControlHandle;
593
594 fn control_handle(&self) -> &ProviderControlHandle {
595 &self.control_handle
596 }
597
598 fn drop_without_shutdown(mut self) {
599 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
601 std::mem::forget(self);
603 }
604}
605
606impl ProviderSocketResponder {
607 pub fn send(
611 self,
612 mut result: Result<fidl::endpoints::ClientEnd<SocketMarker>, fidl_fuchsia_posix::Errno>,
613 ) -> Result<(), fidl::Error> {
614 let _result = self.send_raw(result);
615 if _result.is_err() {
616 self.control_handle.shutdown();
617 }
618 self.drop_without_shutdown();
619 _result
620 }
621
622 pub fn send_no_shutdown_on_err(
624 self,
625 mut result: Result<fidl::endpoints::ClientEnd<SocketMarker>, fidl_fuchsia_posix::Errno>,
626 ) -> Result<(), fidl::Error> {
627 let _result = self.send_raw(result);
628 self.drop_without_shutdown();
629 _result
630 }
631
632 fn send_raw(
633 &self,
634 mut result: Result<fidl::endpoints::ClientEnd<SocketMarker>, fidl_fuchsia_posix::Errno>,
635 ) -> Result<(), fidl::Error> {
636 self.control_handle.inner.send::<fidl::encoding::ResultType<
637 ProviderSocketResponse,
638 fidl_fuchsia_posix::Errno,
639 >>(
640 result.map(|s| (s,)),
641 self.tx_id,
642 0xdfa6a591ab48fd1,
643 fidl::encoding::DynamicFlags::empty(),
644 )
645 }
646}
647
648#[must_use = "FIDL methods require a response to be sent"]
649#[derive(Debug)]
650pub struct ProviderSocketWithOptionsResponder {
651 control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
652 tx_id: u32,
653}
654
655impl std::ops::Drop for ProviderSocketWithOptionsResponder {
659 fn drop(&mut self) {
660 self.control_handle.shutdown();
661 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
663 }
664}
665
666impl fidl::endpoints::Responder for ProviderSocketWithOptionsResponder {
667 type ControlHandle = ProviderControlHandle;
668
669 fn control_handle(&self) -> &ProviderControlHandle {
670 &self.control_handle
671 }
672
673 fn drop_without_shutdown(mut self) {
674 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
676 std::mem::forget(self);
678 }
679}
680
681impl ProviderSocketWithOptionsResponder {
682 pub fn send(
686 self,
687 mut result: Result<fidl::endpoints::ClientEnd<SocketMarker>, fidl_fuchsia_posix::Errno>,
688 ) -> Result<(), fidl::Error> {
689 let _result = self.send_raw(result);
690 if _result.is_err() {
691 self.control_handle.shutdown();
692 }
693 self.drop_without_shutdown();
694 _result
695 }
696
697 pub fn send_no_shutdown_on_err(
699 self,
700 mut result: Result<fidl::endpoints::ClientEnd<SocketMarker>, fidl_fuchsia_posix::Errno>,
701 ) -> Result<(), fidl::Error> {
702 let _result = self.send_raw(result);
703 self.drop_without_shutdown();
704 _result
705 }
706
707 fn send_raw(
708 &self,
709 mut result: Result<fidl::endpoints::ClientEnd<SocketMarker>, fidl_fuchsia_posix::Errno>,
710 ) -> Result<(), fidl::Error> {
711 self.control_handle.inner.send::<fidl::encoding::ResultType<
712 ProviderSocketWithOptionsResponse,
713 fidl_fuchsia_posix::Errno,
714 >>(
715 result.map(|s| (s,)),
716 self.tx_id,
717 0x34cd6e7e82c46f85,
718 fidl::encoding::DynamicFlags::empty(),
719 )
720 }
721}
722
723#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
724pub struct SocketMarker;
725
726impl fidl::endpoints::ProtocolMarker for SocketMarker {
727 type Proxy = SocketProxy;
728 type RequestStream = SocketRequestStream;
729 #[cfg(target_os = "fuchsia")]
730 type SynchronousProxy = SocketSynchronousProxy;
731
732 const DEBUG_NAME: &'static str = "fuchsia.posix.socket.raw.Socket";
733}
734impl fidl::endpoints::DiscoverableProtocolMarker for SocketMarker {}
735pub type SocketRecvMsgResult = Result<
736 (
737 Option<Box<fidl_fuchsia_net::SocketAddress>>,
738 Vec<u8>,
739 fidl_fuchsia_posix_socket::NetworkSocketRecvControlData,
740 u32,
741 ),
742 fidl_fuchsia_posix::Errno,
743>;
744pub type SocketSendMsgResult = Result<(), fidl_fuchsia_posix::Errno>;
745pub type SocketGetInfoResult =
746 Result<(fidl_fuchsia_posix_socket::Domain, ProtocolAssociation), fidl_fuchsia_posix::Errno>;
747pub type SocketSetIpHeaderIncludedResult = Result<(), fidl_fuchsia_posix::Errno>;
748pub type SocketGetIpHeaderIncludedResult = Result<bool, fidl_fuchsia_posix::Errno>;
749pub type SocketSetIcmpv6FilterResult = Result<(), fidl_fuchsia_posix::Errno>;
750pub type SocketGetIcmpv6FilterResult = Result<Icmpv6Filter, fidl_fuchsia_posix::Errno>;
751pub type SocketSetIpv6ChecksumResult = Result<(), fidl_fuchsia_posix::Errno>;
752pub type SocketGetIpv6ChecksumResult = Result<Ipv6ChecksumConfiguration, fidl_fuchsia_posix::Errno>;
753
754pub trait SocketProxyInterface: Send + Sync {
755 fn r#clone(
756 &self,
757 request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
758 ) -> Result<(), fidl::Error>;
759 type CloseResponseFut: std::future::Future<
760 Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
761 > + Send;
762 fn r#close(&self) -> Self::CloseResponseFut;
763 type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
764 fn r#query(&self) -> Self::QueryResponseFut;
765 type SetReuseAddressResponseFut: std::future::Future<
766 Output = Result<
767 fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressResult,
768 fidl::Error,
769 >,
770 > + Send;
771 fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
772 type GetReuseAddressResponseFut: std::future::Future<
773 Output = Result<
774 fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResult,
775 fidl::Error,
776 >,
777 > + Send;
778 fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
779 type GetErrorResponseFut: std::future::Future<
780 Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetErrorResult, fidl::Error>,
781 > + Send;
782 fn r#get_error(&self) -> Self::GetErrorResponseFut;
783 type SetBroadcastResponseFut: std::future::Future<
784 Output = Result<fidl_fuchsia_posix_socket::BaseSocketSetBroadcastResult, fidl::Error>,
785 > + Send;
786 fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
787 type GetBroadcastResponseFut: std::future::Future<
788 Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResult, fidl::Error>,
789 > + Send;
790 fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
791 type SetSendBufferResponseFut: std::future::Future<
792 Output = Result<fidl_fuchsia_posix_socket::BaseSocketSetSendBufferResult, fidl::Error>,
793 > + Send;
794 fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
795 type GetSendBufferResponseFut: std::future::Future<
796 Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResult, fidl::Error>,
797 > + Send;
798 fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
799 type SetReceiveBufferResponseFut: std::future::Future<
800 Output = Result<
801 fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferResult,
802 fidl::Error,
803 >,
804 > + Send;
805 fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
806 type GetReceiveBufferResponseFut: std::future::Future<
807 Output = Result<
808 fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResult,
809 fidl::Error,
810 >,
811 > + Send;
812 fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
813 type SetKeepAliveResponseFut: std::future::Future<
814 Output = Result<fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveResult, fidl::Error>,
815 > + Send;
816 fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
817 type GetKeepAliveResponseFut: std::future::Future<
818 Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResult, fidl::Error>,
819 > + Send;
820 fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
821 type SetOutOfBandInlineResponseFut: std::future::Future<
822 Output = Result<
823 fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineResult,
824 fidl::Error,
825 >,
826 > + Send;
827 fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
828 type GetOutOfBandInlineResponseFut: std::future::Future<
829 Output = Result<
830 fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResult,
831 fidl::Error,
832 >,
833 > + Send;
834 fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
835 type SetNoCheckResponseFut: std::future::Future<
836 Output = Result<fidl_fuchsia_posix_socket::BaseSocketSetNoCheckResult, fidl::Error>,
837 > + Send;
838 fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
839 type GetNoCheckResponseFut: std::future::Future<
840 Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResult, fidl::Error>,
841 > + Send;
842 fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
843 type SetLingerResponseFut: std::future::Future<
844 Output = Result<fidl_fuchsia_posix_socket::BaseSocketSetLingerResult, fidl::Error>,
845 > + Send;
846 fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
847 type GetLingerResponseFut: std::future::Future<
848 Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetLingerResult, fidl::Error>,
849 > + Send;
850 fn r#get_linger(&self) -> Self::GetLingerResponseFut;
851 type SetReusePortResponseFut: std::future::Future<
852 Output = Result<fidl_fuchsia_posix_socket::BaseSocketSetReusePortResult, fidl::Error>,
853 > + Send;
854 fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
855 type GetReusePortResponseFut: std::future::Future<
856 Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetReusePortResult, fidl::Error>,
857 > + Send;
858 fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
859 type GetAcceptConnResponseFut: std::future::Future<
860 Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResult, fidl::Error>,
861 > + Send;
862 fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
863 type SetBindToDeviceResponseFut: std::future::Future<
864 Output = Result<
865 fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceResult,
866 fidl::Error,
867 >,
868 > + Send;
869 fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
870 type GetBindToDeviceResponseFut: std::future::Future<
871 Output = Result<
872 fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResult,
873 fidl::Error,
874 >,
875 > + Send;
876 fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
877 type SetBindToInterfaceIndexResponseFut: std::future::Future<
878 Output = Result<
879 fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexResult,
880 fidl::Error,
881 >,
882 > + Send;
883 fn r#set_bind_to_interface_index(&self, value: u64)
884 -> Self::SetBindToInterfaceIndexResponseFut;
885 type GetBindToInterfaceIndexResponseFut: std::future::Future<
886 Output = Result<
887 fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResult,
888 fidl::Error,
889 >,
890 > + Send;
891 fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
892 type SetTimestampResponseFut: std::future::Future<
893 Output = Result<fidl_fuchsia_posix_socket::BaseSocketSetTimestampResult, fidl::Error>,
894 > + Send;
895 fn r#set_timestamp(
896 &self,
897 value: fidl_fuchsia_posix_socket::TimestampOption,
898 ) -> Self::SetTimestampResponseFut;
899 type GetTimestampResponseFut: std::future::Future<
900 Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetTimestampResult, fidl::Error>,
901 > + Send;
902 fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
903 type SetMarkResponseFut: std::future::Future<
904 Output = Result<fidl_fuchsia_posix_socket::BaseSocketSetMarkResult, fidl::Error>,
905 > + Send;
906 fn r#set_mark(
907 &self,
908 domain: fidl_fuchsia_net::MarkDomain,
909 mark: &fidl_fuchsia_posix_socket::OptionalUint32,
910 ) -> Self::SetMarkResponseFut;
911 type GetMarkResponseFut: std::future::Future<
912 Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetMarkResult, fidl::Error>,
913 > + Send;
914 fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
915 type GetCookieResponseFut: std::future::Future<
916 Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetCookieResult, fidl::Error>,
917 > + Send;
918 fn r#get_cookie(&self) -> Self::GetCookieResponseFut;
919 type BindResponseFut: std::future::Future<
920 Output = Result<fidl_fuchsia_posix_socket::BaseNetworkSocketBindResult, fidl::Error>,
921 > + Send;
922 fn r#bind(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut;
923 type ConnectResponseFut: std::future::Future<
924 Output = Result<fidl_fuchsia_posix_socket::BaseNetworkSocketConnectResult, fidl::Error>,
925 > + Send;
926 fn r#connect(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut;
927 type DisconnectResponseFut: std::future::Future<
928 Output = Result<
929 fidl_fuchsia_posix_socket::BaseNetworkSocketDisconnectResult,
930 fidl::Error,
931 >,
932 > + Send;
933 fn r#disconnect(&self) -> Self::DisconnectResponseFut;
934 type GetSockNameResponseFut: std::future::Future<
935 Output = Result<
936 fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResult,
937 fidl::Error,
938 >,
939 > + Send;
940 fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
941 type GetPeerNameResponseFut: std::future::Future<
942 Output = Result<
943 fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResult,
944 fidl::Error,
945 >,
946 > + Send;
947 fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
948 type ShutdownResponseFut: std::future::Future<
949 Output = Result<
950 fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownResult,
951 fidl::Error,
952 >,
953 > + Send;
954 fn r#shutdown(
955 &self,
956 mode: fidl_fuchsia_posix_socket::ShutdownMode,
957 ) -> Self::ShutdownResponseFut;
958 type SetIpTypeOfServiceResponseFut: std::future::Future<
959 Output = Result<
960 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceResult,
961 fidl::Error,
962 >,
963 > + Send;
964 fn r#set_ip_type_of_service(&self, value: u8) -> Self::SetIpTypeOfServiceResponseFut;
965 type GetIpTypeOfServiceResponseFut: std::future::Future<
966 Output = Result<
967 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResult,
968 fidl::Error,
969 >,
970 > + Send;
971 fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut;
972 type SetIpTtlResponseFut: std::future::Future<
973 Output = Result<
974 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlResult,
975 fidl::Error,
976 >,
977 > + Send;
978 fn r#set_ip_ttl(
979 &self,
980 value: &fidl_fuchsia_posix_socket::OptionalUint8,
981 ) -> Self::SetIpTtlResponseFut;
982 type GetIpTtlResponseFut: std::future::Future<
983 Output = Result<
984 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResult,
985 fidl::Error,
986 >,
987 > + Send;
988 fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut;
989 type SetIpPacketInfoResponseFut: std::future::Future<
990 Output = Result<
991 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoResult,
992 fidl::Error,
993 >,
994 > + Send;
995 fn r#set_ip_packet_info(&self, value: bool) -> Self::SetIpPacketInfoResponseFut;
996 type GetIpPacketInfoResponseFut: std::future::Future<
997 Output = Result<
998 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResult,
999 fidl::Error,
1000 >,
1001 > + Send;
1002 fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut;
1003 type SetIpReceiveTypeOfServiceResponseFut: std::future::Future<
1004 Output = Result<
1005 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
1006 fidl::Error,
1007 >,
1008 > + Send;
1009 fn r#set_ip_receive_type_of_service(
1010 &self,
1011 value: bool,
1012 ) -> Self::SetIpReceiveTypeOfServiceResponseFut;
1013 type GetIpReceiveTypeOfServiceResponseFut: std::future::Future<
1014 Output = Result<
1015 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
1016 fidl::Error,
1017 >,
1018 > + Send;
1019 fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut;
1020 type SetIpReceiveTtlResponseFut: std::future::Future<
1021 Output = Result<
1022 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlResult,
1023 fidl::Error,
1024 >,
1025 > + Send;
1026 fn r#set_ip_receive_ttl(&self, value: bool) -> Self::SetIpReceiveTtlResponseFut;
1027 type GetIpReceiveTtlResponseFut: std::future::Future<
1028 Output = Result<
1029 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResult,
1030 fidl::Error,
1031 >,
1032 > + Send;
1033 fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut;
1034 type SetIpMulticastInterfaceResponseFut: std::future::Future<
1035 Output = Result<
1036 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceResult,
1037 fidl::Error,
1038 >,
1039 > + Send;
1040 fn r#set_ip_multicast_interface(
1041 &self,
1042 iface: u64,
1043 address: &fidl_fuchsia_net::Ipv4Address,
1044 ) -> Self::SetIpMulticastInterfaceResponseFut;
1045 type GetIpMulticastInterfaceResponseFut: std::future::Future<
1046 Output = Result<
1047 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResult,
1048 fidl::Error,
1049 >,
1050 > + Send;
1051 fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut;
1052 type SetIpMulticastTtlResponseFut: std::future::Future<
1053 Output = Result<
1054 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlResult,
1055 fidl::Error,
1056 >,
1057 > + Send;
1058 fn r#set_ip_multicast_ttl(
1059 &self,
1060 value: &fidl_fuchsia_posix_socket::OptionalUint8,
1061 ) -> Self::SetIpMulticastTtlResponseFut;
1062 type GetIpMulticastTtlResponseFut: std::future::Future<
1063 Output = Result<
1064 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResult,
1065 fidl::Error,
1066 >,
1067 > + Send;
1068 fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut;
1069 type SetIpMulticastLoopbackResponseFut: std::future::Future<
1070 Output = Result<
1071 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackResult,
1072 fidl::Error,
1073 >,
1074 > + Send;
1075 fn r#set_ip_multicast_loopback(&self, value: bool) -> Self::SetIpMulticastLoopbackResponseFut;
1076 type GetIpMulticastLoopbackResponseFut: std::future::Future<
1077 Output = Result<
1078 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResult,
1079 fidl::Error,
1080 >,
1081 > + Send;
1082 fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut;
1083 type AddIpMembershipResponseFut: std::future::Future<
1084 Output = Result<
1085 fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipResult,
1086 fidl::Error,
1087 >,
1088 > + Send;
1089 fn r#add_ip_membership(
1090 &self,
1091 membership: &fidl_fuchsia_posix_socket::IpMulticastMembership,
1092 ) -> Self::AddIpMembershipResponseFut;
1093 type DropIpMembershipResponseFut: std::future::Future<
1094 Output = Result<
1095 fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipResult,
1096 fidl::Error,
1097 >,
1098 > + Send;
1099 fn r#drop_ip_membership(
1100 &self,
1101 membership: &fidl_fuchsia_posix_socket::IpMulticastMembership,
1102 ) -> Self::DropIpMembershipResponseFut;
1103 type SetIpTransparentResponseFut: std::future::Future<
1104 Output = Result<
1105 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentResult,
1106 fidl::Error,
1107 >,
1108 > + Send;
1109 fn r#set_ip_transparent(&self, value: bool) -> Self::SetIpTransparentResponseFut;
1110 type GetIpTransparentResponseFut: std::future::Future<
1111 Output = Result<
1112 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResult,
1113 fidl::Error,
1114 >,
1115 > + Send;
1116 fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut;
1117 type SetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<Output = Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>> + Send;
1118 fn r#set_ip_receive_original_destination_address(
1119 &self,
1120 value: bool,
1121 ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut;
1122 type GetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<Output = Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>> + Send;
1123 fn r#get_ip_receive_original_destination_address(
1124 &self,
1125 ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut;
1126 type AddIpv6MembershipResponseFut: std::future::Future<
1127 Output = Result<
1128 fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipResult,
1129 fidl::Error,
1130 >,
1131 > + Send;
1132 fn r#add_ipv6_membership(
1133 &self,
1134 membership: &fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
1135 ) -> Self::AddIpv6MembershipResponseFut;
1136 type DropIpv6MembershipResponseFut: std::future::Future<
1137 Output = Result<
1138 fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipResult,
1139 fidl::Error,
1140 >,
1141 > + Send;
1142 fn r#drop_ipv6_membership(
1143 &self,
1144 membership: &fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
1145 ) -> Self::DropIpv6MembershipResponseFut;
1146 type SetIpv6MulticastInterfaceResponseFut: std::future::Future<
1147 Output = Result<
1148 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceResult,
1149 fidl::Error,
1150 >,
1151 > + Send;
1152 fn r#set_ipv6_multicast_interface(
1153 &self,
1154 value: u64,
1155 ) -> Self::SetIpv6MulticastInterfaceResponseFut;
1156 type GetIpv6MulticastInterfaceResponseFut: std::future::Future<
1157 Output = Result<
1158 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResult,
1159 fidl::Error,
1160 >,
1161 > + Send;
1162 fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut;
1163 type SetIpv6UnicastHopsResponseFut: std::future::Future<
1164 Output = Result<
1165 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsResult,
1166 fidl::Error,
1167 >,
1168 > + Send;
1169 fn r#set_ipv6_unicast_hops(
1170 &self,
1171 value: &fidl_fuchsia_posix_socket::OptionalUint8,
1172 ) -> Self::SetIpv6UnicastHopsResponseFut;
1173 type GetIpv6UnicastHopsResponseFut: std::future::Future<
1174 Output = Result<
1175 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResult,
1176 fidl::Error,
1177 >,
1178 > + Send;
1179 fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut;
1180 type SetIpv6ReceiveHopLimitResponseFut: std::future::Future<
1181 Output = Result<
1182 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
1183 fidl::Error,
1184 >,
1185 > + Send;
1186 fn r#set_ipv6_receive_hop_limit(&self, value: bool) -> Self::SetIpv6ReceiveHopLimitResponseFut;
1187 type GetIpv6ReceiveHopLimitResponseFut: std::future::Future<
1188 Output = Result<
1189 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
1190 fidl::Error,
1191 >,
1192 > + Send;
1193 fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut;
1194 type SetIpv6MulticastHopsResponseFut: std::future::Future<
1195 Output = Result<
1196 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsResult,
1197 fidl::Error,
1198 >,
1199 > + Send;
1200 fn r#set_ipv6_multicast_hops(
1201 &self,
1202 value: &fidl_fuchsia_posix_socket::OptionalUint8,
1203 ) -> Self::SetIpv6MulticastHopsResponseFut;
1204 type GetIpv6MulticastHopsResponseFut: std::future::Future<
1205 Output = Result<
1206 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResult,
1207 fidl::Error,
1208 >,
1209 > + Send;
1210 fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut;
1211 type SetIpv6MulticastLoopbackResponseFut: std::future::Future<
1212 Output = Result<
1213 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackResult,
1214 fidl::Error,
1215 >,
1216 > + Send;
1217 fn r#set_ipv6_multicast_loopback(
1218 &self,
1219 value: bool,
1220 ) -> Self::SetIpv6MulticastLoopbackResponseFut;
1221 type GetIpv6MulticastLoopbackResponseFut: std::future::Future<
1222 Output = Result<
1223 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResult,
1224 fidl::Error,
1225 >,
1226 > + Send;
1227 fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut;
1228 type SetIpv6OnlyResponseFut: std::future::Future<
1229 Output = Result<
1230 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyResult,
1231 fidl::Error,
1232 >,
1233 > + Send;
1234 fn r#set_ipv6_only(&self, value: bool) -> Self::SetIpv6OnlyResponseFut;
1235 type GetIpv6OnlyResponseFut: std::future::Future<
1236 Output = Result<
1237 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResult,
1238 fidl::Error,
1239 >,
1240 > + Send;
1241 fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut;
1242 type SetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
1243 Output = Result<
1244 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
1245 fidl::Error,
1246 >,
1247 > + Send;
1248 fn r#set_ipv6_receive_traffic_class(
1249 &self,
1250 value: bool,
1251 ) -> Self::SetIpv6ReceiveTrafficClassResponseFut;
1252 type GetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
1253 Output = Result<
1254 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
1255 fidl::Error,
1256 >,
1257 > + Send;
1258 fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut;
1259 type SetIpv6TrafficClassResponseFut: std::future::Future<
1260 Output = Result<
1261 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassResult,
1262 fidl::Error,
1263 >,
1264 > + Send;
1265 fn r#set_ipv6_traffic_class(
1266 &self,
1267 value: &fidl_fuchsia_posix_socket::OptionalUint8,
1268 ) -> Self::SetIpv6TrafficClassResponseFut;
1269 type GetIpv6TrafficClassResponseFut: std::future::Future<
1270 Output = Result<
1271 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResult,
1272 fidl::Error,
1273 >,
1274 > + Send;
1275 fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut;
1276 type SetIpv6ReceivePacketInfoResponseFut: std::future::Future<
1277 Output = Result<
1278 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
1279 fidl::Error,
1280 >,
1281 > + Send;
1282 fn r#set_ipv6_receive_packet_info(
1283 &self,
1284 value: bool,
1285 ) -> Self::SetIpv6ReceivePacketInfoResponseFut;
1286 type GetIpv6ReceivePacketInfoResponseFut: std::future::Future<
1287 Output = Result<
1288 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
1289 fidl::Error,
1290 >,
1291 > + Send;
1292 fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut;
1293 type GetOriginalDestinationResponseFut: std::future::Future<
1294 Output = Result<
1295 fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResult,
1296 fidl::Error,
1297 >,
1298 > + Send;
1299 fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut;
1300 type DescribeResponseFut: std::future::Future<Output = Result<SocketDescribeResponse, fidl::Error>>
1301 + Send;
1302 fn r#describe(&self) -> Self::DescribeResponseFut;
1303 type RecvMsgResponseFut: std::future::Future<Output = Result<SocketRecvMsgResult, fidl::Error>>
1304 + Send;
1305 fn r#recv_msg(
1306 &self,
1307 want_addr: bool,
1308 data_len: u32,
1309 want_control: bool,
1310 flags: fidl_fuchsia_posix_socket::RecvMsgFlags,
1311 ) -> Self::RecvMsgResponseFut;
1312 type SendMsgResponseFut: std::future::Future<Output = Result<SocketSendMsgResult, fidl::Error>>
1313 + Send;
1314 fn r#send_msg(
1315 &self,
1316 addr: Option<&fidl_fuchsia_net::SocketAddress>,
1317 data: &[u8],
1318 control: &fidl_fuchsia_posix_socket::NetworkSocketSendControlData,
1319 flags: fidl_fuchsia_posix_socket::SendMsgFlags,
1320 ) -> Self::SendMsgResponseFut;
1321 type GetInfoResponseFut: std::future::Future<Output = Result<SocketGetInfoResult, fidl::Error>>
1322 + Send;
1323 fn r#get_info(&self) -> Self::GetInfoResponseFut;
1324 type SetIpHeaderIncludedResponseFut: std::future::Future<Output = Result<SocketSetIpHeaderIncludedResult, fidl::Error>>
1325 + Send;
1326 fn r#set_ip_header_included(&self, value: bool) -> Self::SetIpHeaderIncludedResponseFut;
1327 type GetIpHeaderIncludedResponseFut: std::future::Future<Output = Result<SocketGetIpHeaderIncludedResult, fidl::Error>>
1328 + Send;
1329 fn r#get_ip_header_included(&self) -> Self::GetIpHeaderIncludedResponseFut;
1330 type SetIcmpv6FilterResponseFut: std::future::Future<Output = Result<SocketSetIcmpv6FilterResult, fidl::Error>>
1331 + Send;
1332 fn r#set_icmpv6_filter(&self, filter: &Icmpv6Filter) -> Self::SetIcmpv6FilterResponseFut;
1333 type GetIcmpv6FilterResponseFut: std::future::Future<Output = Result<SocketGetIcmpv6FilterResult, fidl::Error>>
1334 + Send;
1335 fn r#get_icmpv6_filter(&self) -> Self::GetIcmpv6FilterResponseFut;
1336 type SetIpv6ChecksumResponseFut: std::future::Future<Output = Result<SocketSetIpv6ChecksumResult, fidl::Error>>
1337 + Send;
1338 fn r#set_ipv6_checksum(
1339 &self,
1340 config: &Ipv6ChecksumConfiguration,
1341 ) -> Self::SetIpv6ChecksumResponseFut;
1342 type GetIpv6ChecksumResponseFut: std::future::Future<Output = Result<SocketGetIpv6ChecksumResult, fidl::Error>>
1343 + Send;
1344 fn r#get_ipv6_checksum(&self) -> Self::GetIpv6ChecksumResponseFut;
1345}
1346#[derive(Debug)]
1347#[cfg(target_os = "fuchsia")]
1348pub struct SocketSynchronousProxy {
1349 client: fidl::client::sync::Client,
1350}
1351
1352#[cfg(target_os = "fuchsia")]
1353impl fidl::endpoints::SynchronousProxy for SocketSynchronousProxy {
1354 type Proxy = SocketProxy;
1355 type Protocol = SocketMarker;
1356
1357 fn from_channel(inner: fidl::Channel) -> Self {
1358 Self::new(inner)
1359 }
1360
1361 fn into_channel(self) -> fidl::Channel {
1362 self.client.into_channel()
1363 }
1364
1365 fn as_channel(&self) -> &fidl::Channel {
1366 self.client.as_channel()
1367 }
1368}
1369
1370#[cfg(target_os = "fuchsia")]
1371impl SocketSynchronousProxy {
1372 pub fn new(channel: fidl::Channel) -> Self {
1373 let protocol_name = <SocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1374 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
1375 }
1376
1377 pub fn into_channel(self) -> fidl::Channel {
1378 self.client.into_channel()
1379 }
1380
1381 pub fn wait_for_event(
1384 &self,
1385 deadline: zx::MonotonicInstant,
1386 ) -> Result<SocketEvent, fidl::Error> {
1387 SocketEvent::decode(self.client.wait_for_event(deadline)?)
1388 }
1389
1390 pub fn r#clone(
1391 &self,
1392 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
1393 ) -> Result<(), fidl::Error> {
1394 self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
1395 (request,),
1396 0x20d8a7aba2168a79,
1397 fidl::encoding::DynamicFlags::empty(),
1398 )
1399 }
1400
1401 pub fn r#close(
1412 &self,
1413 ___deadline: zx::MonotonicInstant,
1414 ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
1415 let _response = self.client.send_query::<
1416 fidl::encoding::EmptyPayload,
1417 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
1418 >(
1419 (),
1420 0x5ac5d459ad7f657e,
1421 fidl::encoding::DynamicFlags::empty(),
1422 ___deadline,
1423 )?;
1424 Ok(_response.map(|x| x))
1425 }
1426
1427 pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
1428 let _response = self.client.send_query::<
1429 fidl::encoding::EmptyPayload,
1430 fidl_fuchsia_unknown::QueryableQueryResponse,
1431 >(
1432 (),
1433 0x2658edee9decfc06,
1434 fidl::encoding::DynamicFlags::empty(),
1435 ___deadline,
1436 )?;
1437 Ok(_response.protocol)
1438 }
1439
1440 pub fn r#set_reuse_address(
1442 &self,
1443 mut value: bool,
1444 ___deadline: zx::MonotonicInstant,
1445 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressResult, fidl::Error> {
1446 let _response = self.client.send_query::<
1447 fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressRequest,
1448 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1449 >(
1450 (value,),
1451 0x1fd74ee8b9a4a876,
1452 fidl::encoding::DynamicFlags::empty(),
1453 ___deadline,
1454 )?;
1455 Ok(_response.map(|x| x))
1456 }
1457
1458 pub fn r#get_reuse_address(
1460 &self,
1461 ___deadline: zx::MonotonicInstant,
1462 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResult, fidl::Error> {
1463 let _response = self
1464 .client
1465 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1466 fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResponse,
1467 fidl_fuchsia_posix::Errno,
1468 >>(
1469 (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
1470 )?;
1471 Ok(_response.map(|x| x.value))
1472 }
1473
1474 pub fn r#get_error(
1477 &self,
1478 ___deadline: zx::MonotonicInstant,
1479 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetErrorResult, fidl::Error> {
1480 let _response =
1481 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1482 fidl::encoding::EmptyStruct,
1483 fidl_fuchsia_posix::Errno,
1484 >>(
1485 (),
1486 0x5aad39b33e5f6ebb,
1487 fidl::encoding::DynamicFlags::empty(),
1488 ___deadline,
1489 )?;
1490 Ok(_response.map(|x| x))
1491 }
1492
1493 pub fn r#set_broadcast(
1495 &self,
1496 mut value: bool,
1497 ___deadline: zx::MonotonicInstant,
1498 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetBroadcastResult, fidl::Error> {
1499 let _response = self.client.send_query::<
1500 fidl_fuchsia_posix_socket::BaseSocketSetBroadcastRequest,
1501 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1502 >(
1503 (value,),
1504 0x6023e081ce3cd947,
1505 fidl::encoding::DynamicFlags::empty(),
1506 ___deadline,
1507 )?;
1508 Ok(_response.map(|x| x))
1509 }
1510
1511 pub fn r#get_broadcast(
1513 &self,
1514 ___deadline: zx::MonotonicInstant,
1515 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResult, fidl::Error> {
1516 let _response = self
1517 .client
1518 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1519 fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResponse,
1520 fidl_fuchsia_posix::Errno,
1521 >>(
1522 (), 0x68796fc556f9780d, fidl::encoding::DynamicFlags::empty(), ___deadline
1523 )?;
1524 Ok(_response.map(|x| x.value))
1525 }
1526
1527 pub fn r#set_send_buffer(
1529 &self,
1530 mut value_bytes: u64,
1531 ___deadline: zx::MonotonicInstant,
1532 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetSendBufferResult, fidl::Error> {
1533 let _response = self.client.send_query::<
1534 fidl_fuchsia_posix_socket::BaseSocketSetSendBufferRequest,
1535 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1536 >(
1537 (value_bytes,),
1538 0x756eac32d73a7a70,
1539 fidl::encoding::DynamicFlags::empty(),
1540 ___deadline,
1541 )?;
1542 Ok(_response.map(|x| x))
1543 }
1544
1545 pub fn r#get_send_buffer(
1547 &self,
1548 ___deadline: zx::MonotonicInstant,
1549 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResult, fidl::Error> {
1550 let _response = self
1551 .client
1552 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1553 fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResponse,
1554 fidl_fuchsia_posix::Errno,
1555 >>(
1556 (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
1557 )?;
1558 Ok(_response.map(|x| x.value_bytes))
1559 }
1560
1561 pub fn r#set_receive_buffer(
1563 &self,
1564 mut value_bytes: u64,
1565 ___deadline: zx::MonotonicInstant,
1566 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferResult, fidl::Error> {
1567 let _response = self.client.send_query::<
1568 fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferRequest,
1569 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1570 >(
1571 (value_bytes,),
1572 0x6b0cf2f1919c7001,
1573 fidl::encoding::DynamicFlags::empty(),
1574 ___deadline,
1575 )?;
1576 Ok(_response.map(|x| x))
1577 }
1578
1579 pub fn r#get_receive_buffer(
1581 &self,
1582 ___deadline: zx::MonotonicInstant,
1583 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResult, fidl::Error> {
1584 let _response = self
1585 .client
1586 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1587 fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResponse,
1588 fidl_fuchsia_posix::Errno,
1589 >>(
1590 (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
1591 )?;
1592 Ok(_response.map(|x| x.value_bytes))
1593 }
1594
1595 pub fn r#set_keep_alive(
1597 &self,
1598 mut value: bool,
1599 ___deadline: zx::MonotonicInstant,
1600 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveResult, fidl::Error> {
1601 let _response = self.client.send_query::<
1602 fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveRequest,
1603 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1604 >(
1605 (value,),
1606 0x572df8f0b920d2c7,
1607 fidl::encoding::DynamicFlags::empty(),
1608 ___deadline,
1609 )?;
1610 Ok(_response.map(|x| x))
1611 }
1612
1613 pub fn r#get_keep_alive(
1615 &self,
1616 ___deadline: zx::MonotonicInstant,
1617 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResult, fidl::Error> {
1618 let _response = self
1619 .client
1620 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1621 fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResponse,
1622 fidl_fuchsia_posix::Errno,
1623 >>(
1624 (), 0x2dd29d3215f2c9d2, fidl::encoding::DynamicFlags::empty(), ___deadline
1625 )?;
1626 Ok(_response.map(|x| x.value))
1627 }
1628
1629 pub fn r#set_out_of_band_inline(
1631 &self,
1632 mut value: bool,
1633 ___deadline: zx::MonotonicInstant,
1634 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineResult, fidl::Error> {
1635 let _response = self.client.send_query::<
1636 fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineRequest,
1637 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1638 >(
1639 (value,),
1640 0x3ecb49968bee439,
1641 fidl::encoding::DynamicFlags::empty(),
1642 ___deadline,
1643 )?;
1644 Ok(_response.map(|x| x))
1645 }
1646
1647 pub fn r#get_out_of_band_inline(
1649 &self,
1650 ___deadline: zx::MonotonicInstant,
1651 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResult, fidl::Error> {
1652 let _response = self
1653 .client
1654 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1655 fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResponse,
1656 fidl_fuchsia_posix::Errno,
1657 >>(
1658 (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
1659 )?;
1660 Ok(_response.map(|x| x.value))
1661 }
1662
1663 pub fn r#set_no_check(
1665 &self,
1666 mut value: bool,
1667 ___deadline: zx::MonotonicInstant,
1668 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetNoCheckResult, fidl::Error> {
1669 let _response = self.client.send_query::<
1670 fidl_fuchsia_posix_socket::BaseSocketSetNoCheckRequest,
1671 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1672 >(
1673 (value,),
1674 0x6bbf00c53a4c78c2,
1675 fidl::encoding::DynamicFlags::empty(),
1676 ___deadline,
1677 )?;
1678 Ok(_response.map(|x| x))
1679 }
1680
1681 pub fn r#get_no_check(
1683 &self,
1684 ___deadline: zx::MonotonicInstant,
1685 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResult, fidl::Error> {
1686 let _response = self
1687 .client
1688 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1689 fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResponse,
1690 fidl_fuchsia_posix::Errno,
1691 >>(
1692 (), 0x2cd4249286417694, fidl::encoding::DynamicFlags::empty(), ___deadline
1693 )?;
1694 Ok(_response.map(|x| x.value))
1695 }
1696
1697 pub fn r#set_linger(
1699 &self,
1700 mut linger: bool,
1701 mut length_secs: u32,
1702 ___deadline: zx::MonotonicInstant,
1703 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetLingerResult, fidl::Error> {
1704 let _response = self.client.send_query::<
1705 fidl_fuchsia_posix_socket::BaseSocketSetLingerRequest,
1706 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1707 >(
1708 (linger, length_secs,),
1709 0x45386351246e998e,
1710 fidl::encoding::DynamicFlags::empty(),
1711 ___deadline,
1712 )?;
1713 Ok(_response.map(|x| x))
1714 }
1715
1716 pub fn r#get_linger(
1718 &self,
1719 ___deadline: zx::MonotonicInstant,
1720 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetLingerResult, fidl::Error> {
1721 let _response = self
1722 .client
1723 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1724 fidl_fuchsia_posix_socket::BaseSocketGetLingerResponse,
1725 fidl_fuchsia_posix::Errno,
1726 >>(
1727 (), 0x48eb20fc5ccb0e45, fidl::encoding::DynamicFlags::empty(), ___deadline
1728 )?;
1729 Ok(_response.map(|x| (x.linger, x.length_secs)))
1730 }
1731
1732 pub fn r#set_reuse_port(
1734 &self,
1735 mut value: bool,
1736 ___deadline: zx::MonotonicInstant,
1737 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetReusePortResult, fidl::Error> {
1738 let _response = self.client.send_query::<
1739 fidl_fuchsia_posix_socket::BaseSocketSetReusePortRequest,
1740 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1741 >(
1742 (value,),
1743 0x24dd3e5cb36d9ccb,
1744 fidl::encoding::DynamicFlags::empty(),
1745 ___deadline,
1746 )?;
1747 Ok(_response.map(|x| x))
1748 }
1749
1750 pub fn r#get_reuse_port(
1752 &self,
1753 ___deadline: zx::MonotonicInstant,
1754 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetReusePortResult, fidl::Error> {
1755 let _response = self
1756 .client
1757 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1758 fidl_fuchsia_posix_socket::BaseSocketGetReusePortResponse,
1759 fidl_fuchsia_posix::Errno,
1760 >>(
1761 (), 0x7a112c1ab54ff828, fidl::encoding::DynamicFlags::empty(), ___deadline
1762 )?;
1763 Ok(_response.map(|x| x.value))
1764 }
1765
1766 pub fn r#get_accept_conn(
1768 &self,
1769 ___deadline: zx::MonotonicInstant,
1770 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResult, fidl::Error> {
1771 let _response = self
1772 .client
1773 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1774 fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResponse,
1775 fidl_fuchsia_posix::Errno,
1776 >>(
1777 (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
1778 )?;
1779 Ok(_response.map(|x| x.value))
1780 }
1781
1782 pub fn r#set_bind_to_device(
1784 &self,
1785 mut value: &str,
1786 ___deadline: zx::MonotonicInstant,
1787 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceResult, fidl::Error> {
1788 let _response = self.client.send_query::<
1789 fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceRequest,
1790 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1791 >(
1792 (value,),
1793 0x2118b483f28aafc4,
1794 fidl::encoding::DynamicFlags::empty(),
1795 ___deadline,
1796 )?;
1797 Ok(_response.map(|x| x))
1798 }
1799
1800 pub fn r#get_bind_to_device(
1802 &self,
1803 ___deadline: zx::MonotonicInstant,
1804 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResult, fidl::Error> {
1805 let _response = self
1806 .client
1807 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1808 fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResponse,
1809 fidl_fuchsia_posix::Errno,
1810 >>(
1811 (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
1812 )?;
1813 Ok(_response.map(|x| x.value))
1814 }
1815
1816 pub fn r#set_bind_to_interface_index(
1819 &self,
1820 mut value: u64,
1821 ___deadline: zx::MonotonicInstant,
1822 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexResult, fidl::Error>
1823 {
1824 let _response = self.client.send_query::<
1825 fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexRequest,
1826 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1827 >(
1828 (value,),
1829 0x6e387a0def00821,
1830 fidl::encoding::DynamicFlags::empty(),
1831 ___deadline,
1832 )?;
1833 Ok(_response.map(|x| x))
1834 }
1835
1836 pub fn r#get_bind_to_interface_index(
1838 &self,
1839 ___deadline: zx::MonotonicInstant,
1840 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResult, fidl::Error>
1841 {
1842 let _response = self
1843 .client
1844 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1845 fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResponse,
1846 fidl_fuchsia_posix::Errno,
1847 >>(
1848 (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
1849 )?;
1850 Ok(_response.map(|x| x.value))
1851 }
1852
1853 pub fn r#set_timestamp(
1855 &self,
1856 mut value: fidl_fuchsia_posix_socket::TimestampOption,
1857 ___deadline: zx::MonotonicInstant,
1858 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetTimestampResult, fidl::Error> {
1859 let _response = self.client.send_query::<
1860 fidl_fuchsia_posix_socket::BaseSocketSetTimestampRequest,
1861 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1862 >(
1863 (value,),
1864 0x285d6516c263d839,
1865 fidl::encoding::DynamicFlags::empty(),
1866 ___deadline,
1867 )?;
1868 Ok(_response.map(|x| x))
1869 }
1870
1871 pub fn r#get_timestamp(
1873 &self,
1874 ___deadline: zx::MonotonicInstant,
1875 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetTimestampResult, fidl::Error> {
1876 let _response = self
1877 .client
1878 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1879 fidl_fuchsia_posix_socket::BaseSocketGetTimestampResponse,
1880 fidl_fuchsia_posix::Errno,
1881 >>(
1882 (), 0x49f2fffbbcc2bd27, fidl::encoding::DynamicFlags::empty(), ___deadline
1883 )?;
1884 Ok(_response.map(|x| x.value))
1885 }
1886
1887 pub fn r#set_mark(
1891 &self,
1892 mut domain: fidl_fuchsia_net::MarkDomain,
1893 mut mark: &fidl_fuchsia_posix_socket::OptionalUint32,
1894 ___deadline: zx::MonotonicInstant,
1895 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetMarkResult, fidl::Error> {
1896 let _response = self.client.send_query::<
1897 fidl_fuchsia_posix_socket::BaseSocketSetMarkRequest,
1898 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1899 >(
1900 (domain, mark,),
1901 0x6ead6de09f653236,
1902 fidl::encoding::DynamicFlags::empty(),
1903 ___deadline,
1904 )?;
1905 Ok(_response.map(|x| x))
1906 }
1907
1908 pub fn r#get_mark(
1912 &self,
1913 mut domain: fidl_fuchsia_net::MarkDomain,
1914 ___deadline: zx::MonotonicInstant,
1915 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetMarkResult, fidl::Error> {
1916 let _response = self.client.send_query::<
1917 fidl_fuchsia_posix_socket::BaseSocketGetMarkRequest,
1918 fidl::encoding::ResultType<fidl_fuchsia_posix_socket::BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
1919 >(
1920 (domain,),
1921 0x57a2752c61d93d47,
1922 fidl::encoding::DynamicFlags::empty(),
1923 ___deadline,
1924 )?;
1925 Ok(_response.map(|x| x.mark))
1926 }
1927
1928 pub fn r#get_cookie(
1930 &self,
1931 ___deadline: zx::MonotonicInstant,
1932 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetCookieResult, fidl::Error> {
1933 let _response = self
1934 .client
1935 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1936 fidl_fuchsia_posix_socket::BaseSocketGetCookieResponse,
1937 fidl_fuchsia_posix::Errno,
1938 >>(
1939 (), 0x2c2f47fd8f924e52, fidl::encoding::DynamicFlags::empty(), ___deadline
1940 )?;
1941 Ok(_response.map(|x| x.value))
1942 }
1943
1944 pub fn r#bind(
1946 &self,
1947 mut addr: &fidl_fuchsia_net::SocketAddress,
1948 ___deadline: zx::MonotonicInstant,
1949 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketBindResult, fidl::Error> {
1950 let _response = self.client.send_query::<
1951 fidl_fuchsia_posix_socket::BaseNetworkSocketBindRequest,
1952 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1953 >(
1954 (addr,),
1955 0x4bc6400ae92125d,
1956 fidl::encoding::DynamicFlags::empty(),
1957 ___deadline,
1958 )?;
1959 Ok(_response.map(|x| x))
1960 }
1961
1962 pub fn r#connect(
1964 &self,
1965 mut addr: &fidl_fuchsia_net::SocketAddress,
1966 ___deadline: zx::MonotonicInstant,
1967 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketConnectResult, fidl::Error> {
1968 let _response = self.client.send_query::<
1969 fidl_fuchsia_posix_socket::BaseNetworkSocketConnectRequest,
1970 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1971 >(
1972 (addr,),
1973 0x5f05f19bfdd38871,
1974 fidl::encoding::DynamicFlags::empty(),
1975 ___deadline,
1976 )?;
1977 Ok(_response.map(|x| x))
1978 }
1979
1980 pub fn r#disconnect(
1982 &self,
1983 ___deadline: zx::MonotonicInstant,
1984 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketDisconnectResult, fidl::Error> {
1985 let _response =
1986 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1987 fidl::encoding::EmptyStruct,
1988 fidl_fuchsia_posix::Errno,
1989 >>(
1990 (),
1991 0x74e63b91f7b29b2,
1992 fidl::encoding::DynamicFlags::empty(),
1993 ___deadline,
1994 )?;
1995 Ok(_response.map(|x| x))
1996 }
1997
1998 pub fn r#get_sock_name(
2000 &self,
2001 ___deadline: zx::MonotonicInstant,
2002 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResult, fidl::Error> {
2003 let _response = self
2004 .client
2005 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2006 fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResponse,
2007 fidl_fuchsia_posix::Errno,
2008 >>(
2009 (), 0x475f23f84a1a4f85, fidl::encoding::DynamicFlags::empty(), ___deadline
2010 )?;
2011 Ok(_response.map(|x| x.addr))
2012 }
2013
2014 pub fn r#get_peer_name(
2016 &self,
2017 ___deadline: zx::MonotonicInstant,
2018 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResult, fidl::Error> {
2019 let _response = self
2020 .client
2021 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2022 fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResponse,
2023 fidl_fuchsia_posix::Errno,
2024 >>(
2025 (), 0x1ffecf4bd5b6432e, fidl::encoding::DynamicFlags::empty(), ___deadline
2026 )?;
2027 Ok(_response.map(|x| x.addr))
2028 }
2029
2030 pub fn r#shutdown(
2032 &self,
2033 mut mode: fidl_fuchsia_posix_socket::ShutdownMode,
2034 ___deadline: zx::MonotonicInstant,
2035 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownResult, fidl::Error> {
2036 let _response = self.client.send_query::<
2037 fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownRequest,
2038 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2039 >(
2040 (mode,),
2041 0x247f38b6db68c336,
2042 fidl::encoding::DynamicFlags::empty(),
2043 ___deadline,
2044 )?;
2045 Ok(_response.map(|x| x))
2046 }
2047
2048 pub fn r#set_ip_type_of_service(
2050 &self,
2051 mut value: u8,
2052 ___deadline: zx::MonotonicInstant,
2053 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>
2054 {
2055 let _response = self.client.send_query::<
2056 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceRequest,
2057 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2058 >(
2059 (value,),
2060 0x995c600475b6d46,
2061 fidl::encoding::DynamicFlags::empty(),
2062 ___deadline,
2063 )?;
2064 Ok(_response.map(|x| x))
2065 }
2066
2067 pub fn r#get_ip_type_of_service(
2069 &self,
2070 ___deadline: zx::MonotonicInstant,
2071 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>
2072 {
2073 let _response = self
2074 .client
2075 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2076 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResponse,
2077 fidl_fuchsia_posix::Errno,
2078 >>(
2079 (), 0x3814a04259f75fcb, fidl::encoding::DynamicFlags::empty(), ___deadline
2080 )?;
2081 Ok(_response.map(|x| x.value))
2082 }
2083
2084 pub fn r#set_ip_ttl(
2086 &self,
2087 mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
2088 ___deadline: zx::MonotonicInstant,
2089 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlResult, fidl::Error> {
2090 let _response = self.client.send_query::<
2091 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlRequest,
2092 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2093 >(
2094 (value,),
2095 0x29e2424b433ae1ef,
2096 fidl::encoding::DynamicFlags::empty(),
2097 ___deadline,
2098 )?;
2099 Ok(_response.map(|x| x))
2100 }
2101
2102 pub fn r#get_ip_ttl(
2104 &self,
2105 ___deadline: zx::MonotonicInstant,
2106 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResult, fidl::Error> {
2107 let _response = self
2108 .client
2109 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2110 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResponse,
2111 fidl_fuchsia_posix::Errno,
2112 >>(
2113 (), 0x47e47fa1f24da471, fidl::encoding::DynamicFlags::empty(), ___deadline
2114 )?;
2115 Ok(_response.map(|x| x.value))
2116 }
2117
2118 pub fn r#set_ip_packet_info(
2120 &self,
2121 mut value: bool,
2122 ___deadline: zx::MonotonicInstant,
2123 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>
2124 {
2125 let _response = self.client.send_query::<
2126 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoRequest,
2127 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2128 >(
2129 (value,),
2130 0x392d16bee20c0e16,
2131 fidl::encoding::DynamicFlags::empty(),
2132 ___deadline,
2133 )?;
2134 Ok(_response.map(|x| x))
2135 }
2136
2137 pub fn r#get_ip_packet_info(
2139 &self,
2140 ___deadline: zx::MonotonicInstant,
2141 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>
2142 {
2143 let _response = self
2144 .client
2145 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2146 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResponse,
2147 fidl_fuchsia_posix::Errno,
2148 >>(
2149 (), 0x54b505f242280740, fidl::encoding::DynamicFlags::empty(), ___deadline
2150 )?;
2151 Ok(_response.map(|x| x.value))
2152 }
2153
2154 pub fn r#set_ip_receive_type_of_service(
2156 &self,
2157 mut value: bool,
2158 ___deadline: zx::MonotonicInstant,
2159 ) -> Result<
2160 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
2161 fidl::Error,
2162 > {
2163 let _response = self.client.send_query::<
2164 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
2165 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2166 >(
2167 (value,),
2168 0x6c4f6714995f84ef,
2169 fidl::encoding::DynamicFlags::empty(),
2170 ___deadline,
2171 )?;
2172 Ok(_response.map(|x| x))
2173 }
2174
2175 pub fn r#get_ip_receive_type_of_service(
2177 &self,
2178 ___deadline: zx::MonotonicInstant,
2179 ) -> Result<
2180 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
2181 fidl::Error,
2182 > {
2183 let _response = self
2184 .client
2185 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2186 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
2187 fidl_fuchsia_posix::Errno,
2188 >>(
2189 (), 0x4158ba7dc2795960, fidl::encoding::DynamicFlags::empty(), ___deadline
2190 )?;
2191 Ok(_response.map(|x| x.value))
2192 }
2193
2194 pub fn r#set_ip_receive_ttl(
2196 &self,
2197 mut value: bool,
2198 ___deadline: zx::MonotonicInstant,
2199 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>
2200 {
2201 let _response = self.client.send_query::<
2202 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlRequest,
2203 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2204 >(
2205 (value,),
2206 0x46f15be0ce0ab82b,
2207 fidl::encoding::DynamicFlags::empty(),
2208 ___deadline,
2209 )?;
2210 Ok(_response.map(|x| x))
2211 }
2212
2213 pub fn r#get_ip_receive_ttl(
2215 &self,
2216 ___deadline: zx::MonotonicInstant,
2217 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>
2218 {
2219 let _response = self
2220 .client
2221 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2222 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResponse,
2223 fidl_fuchsia_posix::Errno,
2224 >>(
2225 (), 0x678ddd5a5dfa2eb5, fidl::encoding::DynamicFlags::empty(), ___deadline
2226 )?;
2227 Ok(_response.map(|x| x.value))
2228 }
2229
2230 pub fn r#set_ip_multicast_interface(
2232 &self,
2233 mut iface: u64,
2234 mut address: &fidl_fuchsia_net::Ipv4Address,
2235 ___deadline: zx::MonotonicInstant,
2236 ) -> Result<
2237 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceResult,
2238 fidl::Error,
2239 > {
2240 let _response = self.client.send_query::<
2241 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceRequest,
2242 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2243 >(
2244 (iface, address,),
2245 0x752fbfa9b12befe,
2246 fidl::encoding::DynamicFlags::empty(),
2247 ___deadline,
2248 )?;
2249 Ok(_response.map(|x| x))
2250 }
2251
2252 pub fn r#get_ip_multicast_interface(
2254 &self,
2255 ___deadline: zx::MonotonicInstant,
2256 ) -> Result<
2257 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResult,
2258 fidl::Error,
2259 > {
2260 let _response = self
2261 .client
2262 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2263 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResponse,
2264 fidl_fuchsia_posix::Errno,
2265 >>(
2266 (), 0x320bd14c4df046c4, fidl::encoding::DynamicFlags::empty(), ___deadline
2267 )?;
2268 Ok(_response.map(|x| x.value))
2269 }
2270
2271 pub fn r#set_ip_multicast_ttl(
2273 &self,
2274 mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
2275 ___deadline: zx::MonotonicInstant,
2276 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>
2277 {
2278 let _response = self.client.send_query::<
2279 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlRequest,
2280 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2281 >(
2282 (value,),
2283 0x63134d53772916a1,
2284 fidl::encoding::DynamicFlags::empty(),
2285 ___deadline,
2286 )?;
2287 Ok(_response.map(|x| x))
2288 }
2289
2290 pub fn r#get_ip_multicast_ttl(
2292 &self,
2293 ___deadline: zx::MonotonicInstant,
2294 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>
2295 {
2296 let _response = self
2297 .client
2298 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2299 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResponse,
2300 fidl_fuchsia_posix::Errno,
2301 >>(
2302 (), 0x4665cd378f39e1a, fidl::encoding::DynamicFlags::empty(), ___deadline
2303 )?;
2304 Ok(_response.map(|x| x.value))
2305 }
2306
2307 pub fn r#set_ip_multicast_loopback(
2309 &self,
2310 mut value: bool,
2311 ___deadline: zx::MonotonicInstant,
2312 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error>
2313 {
2314 let _response = self.client.send_query::<
2315 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackRequest,
2316 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2317 >(
2318 (value,),
2319 0x20c55c11f00943ea,
2320 fidl::encoding::DynamicFlags::empty(),
2321 ___deadline,
2322 )?;
2323 Ok(_response.map(|x| x))
2324 }
2325
2326 pub fn r#get_ip_multicast_loopback(
2328 &self,
2329 ___deadline: zx::MonotonicInstant,
2330 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error>
2331 {
2332 let _response = self
2333 .client
2334 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2335 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResponse,
2336 fidl_fuchsia_posix::Errno,
2337 >>(
2338 (), 0x3b6b26ff558298f2, fidl::encoding::DynamicFlags::empty(), ___deadline
2339 )?;
2340 Ok(_response.map(|x| x.value))
2341 }
2342
2343 pub fn r#add_ip_membership(
2345 &self,
2346 mut membership: &fidl_fuchsia_posix_socket::IpMulticastMembership,
2347 ___deadline: zx::MonotonicInstant,
2348 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipResult, fidl::Error>
2349 {
2350 let _response = self.client.send_query::<
2351 fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipRequest,
2352 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2353 >(
2354 (membership,),
2355 0x76bc7df115a3b4d0,
2356 fidl::encoding::DynamicFlags::empty(),
2357 ___deadline,
2358 )?;
2359 Ok(_response.map(|x| x))
2360 }
2361
2362 pub fn r#drop_ip_membership(
2364 &self,
2365 mut membership: &fidl_fuchsia_posix_socket::IpMulticastMembership,
2366 ___deadline: zx::MonotonicInstant,
2367 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipResult, fidl::Error>
2368 {
2369 let _response = self.client.send_query::<
2370 fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipRequest,
2371 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2372 >(
2373 (membership,),
2374 0x2888f3099188d03,
2375 fidl::encoding::DynamicFlags::empty(),
2376 ___deadline,
2377 )?;
2378 Ok(_response.map(|x| x))
2379 }
2380
2381 pub fn r#set_ip_transparent(
2383 &self,
2384 mut value: bool,
2385 ___deadline: zx::MonotonicInstant,
2386 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentResult, fidl::Error>
2387 {
2388 let _response = self.client.send_query::<
2389 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentRequest,
2390 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2391 >(
2392 (value,),
2393 0x1ae532b0c066e3a0,
2394 fidl::encoding::DynamicFlags::empty(),
2395 ___deadline,
2396 )?;
2397 Ok(_response.map(|x| x))
2398 }
2399
2400 pub fn r#get_ip_transparent(
2402 &self,
2403 ___deadline: zx::MonotonicInstant,
2404 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResult, fidl::Error>
2405 {
2406 let _response = self
2407 .client
2408 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2409 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResponse,
2410 fidl_fuchsia_posix::Errno,
2411 >>(
2412 (), 0x51d43695962ebfb5, fidl::encoding::DynamicFlags::empty(), ___deadline
2413 )?;
2414 Ok(_response.map(|x| x.value))
2415 }
2416
2417 pub fn r#set_ip_receive_original_destination_address(
2419 &self,
2420 mut value: bool,
2421 ___deadline: zx::MonotonicInstant,
2422 ) -> Result<
2423 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
2424 fidl::Error,
2425 > {
2426 let _response = self.client.send_query::<
2427 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
2428 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2429 >(
2430 (value,),
2431 0x4722b4ce52f7840,
2432 fidl::encoding::DynamicFlags::empty(),
2433 ___deadline,
2434 )?;
2435 Ok(_response.map(|x| x))
2436 }
2437
2438 pub fn r#get_ip_receive_original_destination_address(
2440 &self,
2441 ___deadline: zx::MonotonicInstant,
2442 ) -> Result<
2443 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
2444 fidl::Error,
2445 > {
2446 let _response = self.client.send_query::<
2447 fidl::encoding::EmptyPayload,
2448 fidl::encoding::ResultType<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse, fidl_fuchsia_posix::Errno>,
2449 >(
2450 (),
2451 0x2a0e7dc5d6bfdfe9,
2452 fidl::encoding::DynamicFlags::empty(),
2453 ___deadline,
2454 )?;
2455 Ok(_response.map(|x| x.value))
2456 }
2457
2458 pub fn r#add_ipv6_membership(
2460 &self,
2461 mut membership: &fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
2462 ___deadline: zx::MonotonicInstant,
2463 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>
2464 {
2465 let _response = self.client.send_query::<
2466 fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipRequest,
2467 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2468 >(
2469 (membership,),
2470 0x7c94727acb4ea4b3,
2471 fidl::encoding::DynamicFlags::empty(),
2472 ___deadline,
2473 )?;
2474 Ok(_response.map(|x| x))
2475 }
2476
2477 pub fn r#drop_ipv6_membership(
2479 &self,
2480 mut membership: &fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
2481 ___deadline: zx::MonotonicInstant,
2482 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>
2483 {
2484 let _response = self.client.send_query::<
2485 fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipRequest,
2486 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2487 >(
2488 (membership,),
2489 0x42104c70ccaba304,
2490 fidl::encoding::DynamicFlags::empty(),
2491 ___deadline,
2492 )?;
2493 Ok(_response.map(|x| x))
2494 }
2495
2496 pub fn r#set_ipv6_multicast_interface(
2498 &self,
2499 mut value: u64,
2500 ___deadline: zx::MonotonicInstant,
2501 ) -> Result<
2502 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceResult,
2503 fidl::Error,
2504 > {
2505 let _response = self.client.send_query::<
2506 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
2507 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2508 >(
2509 (value,),
2510 0x135f76db3774ab3b,
2511 fidl::encoding::DynamicFlags::empty(),
2512 ___deadline,
2513 )?;
2514 Ok(_response.map(|x| x))
2515 }
2516
2517 pub fn r#get_ipv6_multicast_interface(
2519 &self,
2520 ___deadline: zx::MonotonicInstant,
2521 ) -> Result<
2522 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResult,
2523 fidl::Error,
2524 > {
2525 let _response = self
2526 .client
2527 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2528 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
2529 fidl_fuchsia_posix::Errno,
2530 >>(
2531 (), 0x1f26fcdd348f1882, fidl::encoding::DynamicFlags::empty(), ___deadline
2532 )?;
2533 Ok(_response.map(|x| x.value))
2534 }
2535
2536 pub fn r#set_ipv6_unicast_hops(
2538 &self,
2539 mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
2540 ___deadline: zx::MonotonicInstant,
2541 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>
2542 {
2543 let _response = self.client.send_query::<
2544 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsRequest,
2545 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2546 >(
2547 (value,),
2548 0x157d51e98f462859,
2549 fidl::encoding::DynamicFlags::empty(),
2550 ___deadline,
2551 )?;
2552 Ok(_response.map(|x| x))
2553 }
2554
2555 pub fn r#get_ipv6_unicast_hops(
2557 &self,
2558 ___deadline: zx::MonotonicInstant,
2559 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>
2560 {
2561 let _response = self
2562 .client
2563 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2564 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResponse,
2565 fidl_fuchsia_posix::Errno,
2566 >>(
2567 (), 0x21f4641cad8bd8d2, fidl::encoding::DynamicFlags::empty(), ___deadline
2568 )?;
2569 Ok(_response.map(|x| x.value))
2570 }
2571
2572 pub fn r#set_ipv6_receive_hop_limit(
2574 &self,
2575 mut value: bool,
2576 ___deadline: zx::MonotonicInstant,
2577 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error>
2578 {
2579 let _response = self.client.send_query::<
2580 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
2581 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2582 >(
2583 (value,),
2584 0x5c24808ed2e84a1e,
2585 fidl::encoding::DynamicFlags::empty(),
2586 ___deadline,
2587 )?;
2588 Ok(_response.map(|x| x))
2589 }
2590
2591 pub fn r#get_ipv6_receive_hop_limit(
2593 &self,
2594 ___deadline: zx::MonotonicInstant,
2595 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error>
2596 {
2597 let _response = self
2598 .client
2599 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2600 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
2601 fidl_fuchsia_posix::Errno,
2602 >>(
2603 (), 0x341e06689885b4c0, fidl::encoding::DynamicFlags::empty(), ___deadline
2604 )?;
2605 Ok(_response.map(|x| x.value))
2606 }
2607
2608 pub fn r#set_ipv6_multicast_hops(
2610 &self,
2611 mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
2612 ___deadline: zx::MonotonicInstant,
2613 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error>
2614 {
2615 let _response = self.client.send_query::<
2616 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsRequest,
2617 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2618 >(
2619 (value,),
2620 0x25b9cd4d181f82c1,
2621 fidl::encoding::DynamicFlags::empty(),
2622 ___deadline,
2623 )?;
2624 Ok(_response.map(|x| x))
2625 }
2626
2627 pub fn r#get_ipv6_multicast_hops(
2629 &self,
2630 ___deadline: zx::MonotonicInstant,
2631 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error>
2632 {
2633 let _response = self
2634 .client
2635 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2636 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResponse,
2637 fidl_fuchsia_posix::Errno,
2638 >>(
2639 (), 0x52916948a365012a, fidl::encoding::DynamicFlags::empty(), ___deadline
2640 )?;
2641 Ok(_response.map(|x| x.value))
2642 }
2643
2644 pub fn r#set_ipv6_multicast_loopback(
2646 &self,
2647 mut value: bool,
2648 ___deadline: zx::MonotonicInstant,
2649 ) -> Result<
2650 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackResult,
2651 fidl::Error,
2652 > {
2653 let _response = self.client.send_query::<
2654 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
2655 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2656 >(
2657 (value,),
2658 0x55701c409ff41b40,
2659 fidl::encoding::DynamicFlags::empty(),
2660 ___deadline,
2661 )?;
2662 Ok(_response.map(|x| x))
2663 }
2664
2665 pub fn r#get_ipv6_multicast_loopback(
2667 &self,
2668 ___deadline: zx::MonotonicInstant,
2669 ) -> Result<
2670 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResult,
2671 fidl::Error,
2672 > {
2673 let _response = self
2674 .client
2675 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2676 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
2677 fidl_fuchsia_posix::Errno,
2678 >>(
2679 (), 0x4415b701fde319c3, fidl::encoding::DynamicFlags::empty(), ___deadline
2680 )?;
2681 Ok(_response.map(|x| x.value))
2682 }
2683
2684 pub fn r#set_ipv6_only(
2686 &self,
2687 mut value: bool,
2688 ___deadline: zx::MonotonicInstant,
2689 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
2690 let _response = self.client.send_query::<
2691 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyRequest,
2692 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2693 >(
2694 (value,),
2695 0x4873f1364758cbba,
2696 fidl::encoding::DynamicFlags::empty(),
2697 ___deadline,
2698 )?;
2699 Ok(_response.map(|x| x))
2700 }
2701
2702 pub fn r#get_ipv6_only(
2704 &self,
2705 ___deadline: zx::MonotonicInstant,
2706 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
2707 let _response = self
2708 .client
2709 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2710 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResponse,
2711 fidl_fuchsia_posix::Errno,
2712 >>(
2713 (), 0x4aa3340a1a26b89c, fidl::encoding::DynamicFlags::empty(), ___deadline
2714 )?;
2715 Ok(_response.map(|x| x.value))
2716 }
2717
2718 pub fn r#set_ipv6_receive_traffic_class(
2720 &self,
2721 mut value: bool,
2722 ___deadline: zx::MonotonicInstant,
2723 ) -> Result<
2724 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
2725 fidl::Error,
2726 > {
2727 let _response = self.client.send_query::<
2728 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
2729 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2730 >(
2731 (value,),
2732 0x58f07c8788d099a0,
2733 fidl::encoding::DynamicFlags::empty(),
2734 ___deadline,
2735 )?;
2736 Ok(_response.map(|x| x))
2737 }
2738
2739 pub fn r#get_ipv6_receive_traffic_class(
2741 &self,
2742 ___deadline: zx::MonotonicInstant,
2743 ) -> Result<
2744 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
2745 fidl::Error,
2746 > {
2747 let _response = self
2748 .client
2749 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2750 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
2751 fidl_fuchsia_posix::Errno,
2752 >>(
2753 (), 0x2e334df1da553ffa, fidl::encoding::DynamicFlags::empty(), ___deadline
2754 )?;
2755 Ok(_response.map(|x| x.value))
2756 }
2757
2758 pub fn r#set_ipv6_traffic_class(
2760 &self,
2761 mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
2762 ___deadline: zx::MonotonicInstant,
2763 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error>
2764 {
2765 let _response = self.client.send_query::<
2766 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassRequest,
2767 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2768 >(
2769 (value,),
2770 0x6af077800c5a0b4f,
2771 fidl::encoding::DynamicFlags::empty(),
2772 ___deadline,
2773 )?;
2774 Ok(_response.map(|x| x))
2775 }
2776
2777 pub fn r#get_ipv6_traffic_class(
2779 &self,
2780 ___deadline: zx::MonotonicInstant,
2781 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error>
2782 {
2783 let _response = self
2784 .client
2785 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2786 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResponse,
2787 fidl_fuchsia_posix::Errno,
2788 >>(
2789 (), 0x6baf6eed8fc2f04, fidl::encoding::DynamicFlags::empty(), ___deadline
2790 )?;
2791 Ok(_response.map(|x| x.value))
2792 }
2793
2794 pub fn r#set_ipv6_receive_packet_info(
2796 &self,
2797 mut value: bool,
2798 ___deadline: zx::MonotonicInstant,
2799 ) -> Result<
2800 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
2801 fidl::Error,
2802 > {
2803 let _response = self.client.send_query::<
2804 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
2805 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2806 >(
2807 (value,),
2808 0x19259775b1a92768,
2809 fidl::encoding::DynamicFlags::empty(),
2810 ___deadline,
2811 )?;
2812 Ok(_response.map(|x| x))
2813 }
2814
2815 pub fn r#get_ipv6_receive_packet_info(
2817 &self,
2818 ___deadline: zx::MonotonicInstant,
2819 ) -> Result<
2820 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
2821 fidl::Error,
2822 > {
2823 let _response = self
2824 .client
2825 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2826 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
2827 fidl_fuchsia_posix::Errno,
2828 >>(
2829 (), 0x7acd4a2775baec75, fidl::encoding::DynamicFlags::empty(), ___deadline
2830 )?;
2831 Ok(_response.map(|x| x.value))
2832 }
2833
2834 pub fn r#get_original_destination(
2836 &self,
2837 ___deadline: zx::MonotonicInstant,
2838 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResult, fidl::Error>
2839 {
2840 let _response = self
2841 .client
2842 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2843 fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResponse,
2844 fidl_fuchsia_posix::Errno,
2845 >>(
2846 (), 0x38bf28f0dafdbac0, fidl::encoding::DynamicFlags::empty(), ___deadline
2847 )?;
2848 Ok(_response.map(|x| x.value))
2849 }
2850
2851 pub fn r#describe(
2852 &self,
2853 ___deadline: zx::MonotonicInstant,
2854 ) -> Result<SocketDescribeResponse, fidl::Error> {
2855 let _response =
2856 self.client.send_query::<fidl::encoding::EmptyPayload, SocketDescribeResponse>(
2857 (),
2858 0x335706eccf54a135,
2859 fidl::encoding::DynamicFlags::empty(),
2860 ___deadline,
2861 )?;
2862 Ok(_response)
2863 }
2864
2865 pub fn r#recv_msg(
2880 &self,
2881 mut want_addr: bool,
2882 mut data_len: u32,
2883 mut want_control: bool,
2884 mut flags: fidl_fuchsia_posix_socket::RecvMsgFlags,
2885 ___deadline: zx::MonotonicInstant,
2886 ) -> Result<SocketRecvMsgResult, fidl::Error> {
2887 let _response = self.client.send_query::<SocketRecvMsgRequest, fidl::encoding::ResultType<
2888 SocketRecvMsgResponse,
2889 fidl_fuchsia_posix::Errno,
2890 >>(
2891 (want_addr, data_len, want_control, flags),
2892 0x1dfb695351d3aa1d,
2893 fidl::encoding::DynamicFlags::empty(),
2894 ___deadline,
2895 )?;
2896 Ok(_response.map(|x| (x.addr, x.data, x.control, x.truncated)))
2897 }
2898
2899 pub fn r#send_msg(
2907 &self,
2908 mut addr: Option<&fidl_fuchsia_net::SocketAddress>,
2909 mut data: &[u8],
2910 mut control: &fidl_fuchsia_posix_socket::NetworkSocketSendControlData,
2911 mut flags: fidl_fuchsia_posix_socket::SendMsgFlags,
2912 ___deadline: zx::MonotonicInstant,
2913 ) -> Result<SocketSendMsgResult, fidl::Error> {
2914 let _response = self.client.send_query::<SocketSendMsgRequest, fidl::encoding::ResultType<
2915 fidl::encoding::EmptyStruct,
2916 fidl_fuchsia_posix::Errno,
2917 >>(
2918 (addr, data, control, flags),
2919 0x2cf1eac9a7fc8958,
2920 fidl::encoding::DynamicFlags::empty(),
2921 ___deadline,
2922 )?;
2923 Ok(_response.map(|x| x))
2924 }
2925
2926 pub fn r#get_info(
2931 &self,
2932 ___deadline: zx::MonotonicInstant,
2933 ) -> Result<SocketGetInfoResult, fidl::Error> {
2934 let _response =
2935 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2936 SocketGetInfoResponse,
2937 fidl_fuchsia_posix::Errno,
2938 >>(
2939 (),
2940 0x39676f75aec339ba,
2941 fidl::encoding::DynamicFlags::empty(),
2942 ___deadline,
2943 )?;
2944 Ok(_response.map(|x| (x.domain, x.proto)))
2945 }
2946
2947 pub fn r#set_ip_header_included(
2949 &self,
2950 mut value: bool,
2951 ___deadline: zx::MonotonicInstant,
2952 ) -> Result<SocketSetIpHeaderIncludedResult, fidl::Error> {
2953 let _response =
2954 self.client.send_query::<SocketSetIpHeaderIncludedRequest, fidl::encoding::ResultType<
2955 fidl::encoding::EmptyStruct,
2956 fidl_fuchsia_posix::Errno,
2957 >>(
2958 (value,),
2959 0x5d06a606d95e8f3,
2960 fidl::encoding::DynamicFlags::empty(),
2961 ___deadline,
2962 )?;
2963 Ok(_response.map(|x| x))
2964 }
2965
2966 pub fn r#get_ip_header_included(
2968 &self,
2969 ___deadline: zx::MonotonicInstant,
2970 ) -> Result<SocketGetIpHeaderIncludedResult, fidl::Error> {
2971 let _response = self
2972 .client
2973 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2974 SocketGetIpHeaderIncludedResponse,
2975 fidl_fuchsia_posix::Errno,
2976 >>(
2977 (), 0x76125ad1f4d175f6, fidl::encoding::DynamicFlags::empty(), ___deadline
2978 )?;
2979 Ok(_response.map(|x| x.value))
2980 }
2981
2982 pub fn r#set_icmpv6_filter(
2984 &self,
2985 mut filter: &Icmpv6Filter,
2986 ___deadline: zx::MonotonicInstant,
2987 ) -> Result<SocketSetIcmpv6FilterResult, fidl::Error> {
2988 let _response =
2989 self.client.send_query::<SocketSetIcmpv6FilterRequest, fidl::encoding::ResultType<
2990 fidl::encoding::EmptyStruct,
2991 fidl_fuchsia_posix::Errno,
2992 >>(
2993 (filter,),
2994 0x4ebea92a43ae68a9,
2995 fidl::encoding::DynamicFlags::empty(),
2996 ___deadline,
2997 )?;
2998 Ok(_response.map(|x| x))
2999 }
3000
3001 pub fn r#get_icmpv6_filter(
3003 &self,
3004 ___deadline: zx::MonotonicInstant,
3005 ) -> Result<SocketGetIcmpv6FilterResult, fidl::Error> {
3006 let _response =
3007 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
3008 SocketGetIcmpv6FilterResponse,
3009 fidl_fuchsia_posix::Errno,
3010 >>(
3011 (),
3012 0x43bd4f3bc0970ace,
3013 fidl::encoding::DynamicFlags::empty(),
3014 ___deadline,
3015 )?;
3016 Ok(_response.map(|x| x.filter))
3017 }
3018
3019 pub fn r#set_ipv6_checksum(
3021 &self,
3022 mut config: &Ipv6ChecksumConfiguration,
3023 ___deadline: zx::MonotonicInstant,
3024 ) -> Result<SocketSetIpv6ChecksumResult, fidl::Error> {
3025 let _response =
3026 self.client.send_query::<SocketSetIpv6ChecksumRequest, fidl::encoding::ResultType<
3027 fidl::encoding::EmptyStruct,
3028 fidl_fuchsia_posix::Errno,
3029 >>(
3030 (config,),
3031 0x18b7809577199cb4,
3032 fidl::encoding::DynamicFlags::empty(),
3033 ___deadline,
3034 )?;
3035 Ok(_response.map(|x| x))
3036 }
3037
3038 pub fn r#get_ipv6_checksum(
3040 &self,
3041 ___deadline: zx::MonotonicInstant,
3042 ) -> Result<SocketGetIpv6ChecksumResult, fidl::Error> {
3043 let _response =
3044 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
3045 SocketGetIpv6ChecksumResponse,
3046 fidl_fuchsia_posix::Errno,
3047 >>(
3048 (),
3049 0x1847bf5b2d263dd,
3050 fidl::encoding::DynamicFlags::empty(),
3051 ___deadline,
3052 )?;
3053 Ok(_response.map(|x| x.config))
3054 }
3055}
3056
3057#[cfg(target_os = "fuchsia")]
3058impl From<SocketSynchronousProxy> for zx::Handle {
3059 fn from(value: SocketSynchronousProxy) -> Self {
3060 value.into_channel().into()
3061 }
3062}
3063
3064#[cfg(target_os = "fuchsia")]
3065impl From<fidl::Channel> for SocketSynchronousProxy {
3066 fn from(value: fidl::Channel) -> Self {
3067 Self::new(value)
3068 }
3069}
3070
3071#[cfg(target_os = "fuchsia")]
3072impl fidl::endpoints::FromClient for SocketSynchronousProxy {
3073 type Protocol = SocketMarker;
3074
3075 fn from_client(value: fidl::endpoints::ClientEnd<SocketMarker>) -> Self {
3076 Self::new(value.into_channel())
3077 }
3078}
3079
3080#[derive(Debug, Clone)]
3081pub struct SocketProxy {
3082 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
3083}
3084
3085impl fidl::endpoints::Proxy for SocketProxy {
3086 type Protocol = SocketMarker;
3087
3088 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
3089 Self::new(inner)
3090 }
3091
3092 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
3093 self.client.into_channel().map_err(|client| Self { client })
3094 }
3095
3096 fn as_channel(&self) -> &::fidl::AsyncChannel {
3097 self.client.as_channel()
3098 }
3099}
3100
3101impl SocketProxy {
3102 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
3104 let protocol_name = <SocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
3105 Self { client: fidl::client::Client::new(channel, protocol_name) }
3106 }
3107
3108 pub fn take_event_stream(&self) -> SocketEventStream {
3114 SocketEventStream { event_receiver: self.client.take_event_receiver() }
3115 }
3116
3117 pub fn r#clone(
3118 &self,
3119 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
3120 ) -> Result<(), fidl::Error> {
3121 SocketProxyInterface::r#clone(self, request)
3122 }
3123
3124 pub fn r#close(
3135 &self,
3136 ) -> fidl::client::QueryResponseFut<
3137 fidl_fuchsia_unknown::CloseableCloseResult,
3138 fidl::encoding::DefaultFuchsiaResourceDialect,
3139 > {
3140 SocketProxyInterface::r#close(self)
3141 }
3142
3143 pub fn r#query(
3144 &self,
3145 ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
3146 {
3147 SocketProxyInterface::r#query(self)
3148 }
3149
3150 pub fn r#set_reuse_address(
3152 &self,
3153 mut value: bool,
3154 ) -> fidl::client::QueryResponseFut<
3155 fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressResult,
3156 fidl::encoding::DefaultFuchsiaResourceDialect,
3157 > {
3158 SocketProxyInterface::r#set_reuse_address(self, value)
3159 }
3160
3161 pub fn r#get_reuse_address(
3163 &self,
3164 ) -> fidl::client::QueryResponseFut<
3165 fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResult,
3166 fidl::encoding::DefaultFuchsiaResourceDialect,
3167 > {
3168 SocketProxyInterface::r#get_reuse_address(self)
3169 }
3170
3171 pub fn r#get_error(
3174 &self,
3175 ) -> fidl::client::QueryResponseFut<
3176 fidl_fuchsia_posix_socket::BaseSocketGetErrorResult,
3177 fidl::encoding::DefaultFuchsiaResourceDialect,
3178 > {
3179 SocketProxyInterface::r#get_error(self)
3180 }
3181
3182 pub fn r#set_broadcast(
3184 &self,
3185 mut value: bool,
3186 ) -> fidl::client::QueryResponseFut<
3187 fidl_fuchsia_posix_socket::BaseSocketSetBroadcastResult,
3188 fidl::encoding::DefaultFuchsiaResourceDialect,
3189 > {
3190 SocketProxyInterface::r#set_broadcast(self, value)
3191 }
3192
3193 pub fn r#get_broadcast(
3195 &self,
3196 ) -> fidl::client::QueryResponseFut<
3197 fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResult,
3198 fidl::encoding::DefaultFuchsiaResourceDialect,
3199 > {
3200 SocketProxyInterface::r#get_broadcast(self)
3201 }
3202
3203 pub fn r#set_send_buffer(
3205 &self,
3206 mut value_bytes: u64,
3207 ) -> fidl::client::QueryResponseFut<
3208 fidl_fuchsia_posix_socket::BaseSocketSetSendBufferResult,
3209 fidl::encoding::DefaultFuchsiaResourceDialect,
3210 > {
3211 SocketProxyInterface::r#set_send_buffer(self, value_bytes)
3212 }
3213
3214 pub fn r#get_send_buffer(
3216 &self,
3217 ) -> fidl::client::QueryResponseFut<
3218 fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResult,
3219 fidl::encoding::DefaultFuchsiaResourceDialect,
3220 > {
3221 SocketProxyInterface::r#get_send_buffer(self)
3222 }
3223
3224 pub fn r#set_receive_buffer(
3226 &self,
3227 mut value_bytes: u64,
3228 ) -> fidl::client::QueryResponseFut<
3229 fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferResult,
3230 fidl::encoding::DefaultFuchsiaResourceDialect,
3231 > {
3232 SocketProxyInterface::r#set_receive_buffer(self, value_bytes)
3233 }
3234
3235 pub fn r#get_receive_buffer(
3237 &self,
3238 ) -> fidl::client::QueryResponseFut<
3239 fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResult,
3240 fidl::encoding::DefaultFuchsiaResourceDialect,
3241 > {
3242 SocketProxyInterface::r#get_receive_buffer(self)
3243 }
3244
3245 pub fn r#set_keep_alive(
3247 &self,
3248 mut value: bool,
3249 ) -> fidl::client::QueryResponseFut<
3250 fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveResult,
3251 fidl::encoding::DefaultFuchsiaResourceDialect,
3252 > {
3253 SocketProxyInterface::r#set_keep_alive(self, value)
3254 }
3255
3256 pub fn r#get_keep_alive(
3258 &self,
3259 ) -> fidl::client::QueryResponseFut<
3260 fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResult,
3261 fidl::encoding::DefaultFuchsiaResourceDialect,
3262 > {
3263 SocketProxyInterface::r#get_keep_alive(self)
3264 }
3265
3266 pub fn r#set_out_of_band_inline(
3268 &self,
3269 mut value: bool,
3270 ) -> fidl::client::QueryResponseFut<
3271 fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineResult,
3272 fidl::encoding::DefaultFuchsiaResourceDialect,
3273 > {
3274 SocketProxyInterface::r#set_out_of_band_inline(self, value)
3275 }
3276
3277 pub fn r#get_out_of_band_inline(
3279 &self,
3280 ) -> fidl::client::QueryResponseFut<
3281 fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResult,
3282 fidl::encoding::DefaultFuchsiaResourceDialect,
3283 > {
3284 SocketProxyInterface::r#get_out_of_band_inline(self)
3285 }
3286
3287 pub fn r#set_no_check(
3289 &self,
3290 mut value: bool,
3291 ) -> fidl::client::QueryResponseFut<
3292 fidl_fuchsia_posix_socket::BaseSocketSetNoCheckResult,
3293 fidl::encoding::DefaultFuchsiaResourceDialect,
3294 > {
3295 SocketProxyInterface::r#set_no_check(self, value)
3296 }
3297
3298 pub fn r#get_no_check(
3300 &self,
3301 ) -> fidl::client::QueryResponseFut<
3302 fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResult,
3303 fidl::encoding::DefaultFuchsiaResourceDialect,
3304 > {
3305 SocketProxyInterface::r#get_no_check(self)
3306 }
3307
3308 pub fn r#set_linger(
3310 &self,
3311 mut linger: bool,
3312 mut length_secs: u32,
3313 ) -> fidl::client::QueryResponseFut<
3314 fidl_fuchsia_posix_socket::BaseSocketSetLingerResult,
3315 fidl::encoding::DefaultFuchsiaResourceDialect,
3316 > {
3317 SocketProxyInterface::r#set_linger(self, linger, length_secs)
3318 }
3319
3320 pub fn r#get_linger(
3322 &self,
3323 ) -> fidl::client::QueryResponseFut<
3324 fidl_fuchsia_posix_socket::BaseSocketGetLingerResult,
3325 fidl::encoding::DefaultFuchsiaResourceDialect,
3326 > {
3327 SocketProxyInterface::r#get_linger(self)
3328 }
3329
3330 pub fn r#set_reuse_port(
3332 &self,
3333 mut value: bool,
3334 ) -> fidl::client::QueryResponseFut<
3335 fidl_fuchsia_posix_socket::BaseSocketSetReusePortResult,
3336 fidl::encoding::DefaultFuchsiaResourceDialect,
3337 > {
3338 SocketProxyInterface::r#set_reuse_port(self, value)
3339 }
3340
3341 pub fn r#get_reuse_port(
3343 &self,
3344 ) -> fidl::client::QueryResponseFut<
3345 fidl_fuchsia_posix_socket::BaseSocketGetReusePortResult,
3346 fidl::encoding::DefaultFuchsiaResourceDialect,
3347 > {
3348 SocketProxyInterface::r#get_reuse_port(self)
3349 }
3350
3351 pub fn r#get_accept_conn(
3353 &self,
3354 ) -> fidl::client::QueryResponseFut<
3355 fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResult,
3356 fidl::encoding::DefaultFuchsiaResourceDialect,
3357 > {
3358 SocketProxyInterface::r#get_accept_conn(self)
3359 }
3360
3361 pub fn r#set_bind_to_device(
3363 &self,
3364 mut value: &str,
3365 ) -> fidl::client::QueryResponseFut<
3366 fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceResult,
3367 fidl::encoding::DefaultFuchsiaResourceDialect,
3368 > {
3369 SocketProxyInterface::r#set_bind_to_device(self, value)
3370 }
3371
3372 pub fn r#get_bind_to_device(
3374 &self,
3375 ) -> fidl::client::QueryResponseFut<
3376 fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResult,
3377 fidl::encoding::DefaultFuchsiaResourceDialect,
3378 > {
3379 SocketProxyInterface::r#get_bind_to_device(self)
3380 }
3381
3382 pub fn r#set_bind_to_interface_index(
3385 &self,
3386 mut value: u64,
3387 ) -> fidl::client::QueryResponseFut<
3388 fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexResult,
3389 fidl::encoding::DefaultFuchsiaResourceDialect,
3390 > {
3391 SocketProxyInterface::r#set_bind_to_interface_index(self, value)
3392 }
3393
3394 pub fn r#get_bind_to_interface_index(
3396 &self,
3397 ) -> fidl::client::QueryResponseFut<
3398 fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResult,
3399 fidl::encoding::DefaultFuchsiaResourceDialect,
3400 > {
3401 SocketProxyInterface::r#get_bind_to_interface_index(self)
3402 }
3403
3404 pub fn r#set_timestamp(
3406 &self,
3407 mut value: fidl_fuchsia_posix_socket::TimestampOption,
3408 ) -> fidl::client::QueryResponseFut<
3409 fidl_fuchsia_posix_socket::BaseSocketSetTimestampResult,
3410 fidl::encoding::DefaultFuchsiaResourceDialect,
3411 > {
3412 SocketProxyInterface::r#set_timestamp(self, value)
3413 }
3414
3415 pub fn r#get_timestamp(
3417 &self,
3418 ) -> fidl::client::QueryResponseFut<
3419 fidl_fuchsia_posix_socket::BaseSocketGetTimestampResult,
3420 fidl::encoding::DefaultFuchsiaResourceDialect,
3421 > {
3422 SocketProxyInterface::r#get_timestamp(self)
3423 }
3424
3425 pub fn r#set_mark(
3429 &self,
3430 mut domain: fidl_fuchsia_net::MarkDomain,
3431 mut mark: &fidl_fuchsia_posix_socket::OptionalUint32,
3432 ) -> fidl::client::QueryResponseFut<
3433 fidl_fuchsia_posix_socket::BaseSocketSetMarkResult,
3434 fidl::encoding::DefaultFuchsiaResourceDialect,
3435 > {
3436 SocketProxyInterface::r#set_mark(self, domain, mark)
3437 }
3438
3439 pub fn r#get_mark(
3443 &self,
3444 mut domain: fidl_fuchsia_net::MarkDomain,
3445 ) -> fidl::client::QueryResponseFut<
3446 fidl_fuchsia_posix_socket::BaseSocketGetMarkResult,
3447 fidl::encoding::DefaultFuchsiaResourceDialect,
3448 > {
3449 SocketProxyInterface::r#get_mark(self, domain)
3450 }
3451
3452 pub fn r#get_cookie(
3454 &self,
3455 ) -> fidl::client::QueryResponseFut<
3456 fidl_fuchsia_posix_socket::BaseSocketGetCookieResult,
3457 fidl::encoding::DefaultFuchsiaResourceDialect,
3458 > {
3459 SocketProxyInterface::r#get_cookie(self)
3460 }
3461
3462 pub fn r#bind(
3464 &self,
3465 mut addr: &fidl_fuchsia_net::SocketAddress,
3466 ) -> fidl::client::QueryResponseFut<
3467 fidl_fuchsia_posix_socket::BaseNetworkSocketBindResult,
3468 fidl::encoding::DefaultFuchsiaResourceDialect,
3469 > {
3470 SocketProxyInterface::r#bind(self, addr)
3471 }
3472
3473 pub fn r#connect(
3475 &self,
3476 mut addr: &fidl_fuchsia_net::SocketAddress,
3477 ) -> fidl::client::QueryResponseFut<
3478 fidl_fuchsia_posix_socket::BaseNetworkSocketConnectResult,
3479 fidl::encoding::DefaultFuchsiaResourceDialect,
3480 > {
3481 SocketProxyInterface::r#connect(self, addr)
3482 }
3483
3484 pub fn r#disconnect(
3486 &self,
3487 ) -> fidl::client::QueryResponseFut<
3488 fidl_fuchsia_posix_socket::BaseNetworkSocketDisconnectResult,
3489 fidl::encoding::DefaultFuchsiaResourceDialect,
3490 > {
3491 SocketProxyInterface::r#disconnect(self)
3492 }
3493
3494 pub fn r#get_sock_name(
3496 &self,
3497 ) -> fidl::client::QueryResponseFut<
3498 fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResult,
3499 fidl::encoding::DefaultFuchsiaResourceDialect,
3500 > {
3501 SocketProxyInterface::r#get_sock_name(self)
3502 }
3503
3504 pub fn r#get_peer_name(
3506 &self,
3507 ) -> fidl::client::QueryResponseFut<
3508 fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResult,
3509 fidl::encoding::DefaultFuchsiaResourceDialect,
3510 > {
3511 SocketProxyInterface::r#get_peer_name(self)
3512 }
3513
3514 pub fn r#shutdown(
3516 &self,
3517 mut mode: fidl_fuchsia_posix_socket::ShutdownMode,
3518 ) -> fidl::client::QueryResponseFut<
3519 fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownResult,
3520 fidl::encoding::DefaultFuchsiaResourceDialect,
3521 > {
3522 SocketProxyInterface::r#shutdown(self, mode)
3523 }
3524
3525 pub fn r#set_ip_type_of_service(
3527 &self,
3528 mut value: u8,
3529 ) -> fidl::client::QueryResponseFut<
3530 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceResult,
3531 fidl::encoding::DefaultFuchsiaResourceDialect,
3532 > {
3533 SocketProxyInterface::r#set_ip_type_of_service(self, value)
3534 }
3535
3536 pub fn r#get_ip_type_of_service(
3538 &self,
3539 ) -> fidl::client::QueryResponseFut<
3540 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResult,
3541 fidl::encoding::DefaultFuchsiaResourceDialect,
3542 > {
3543 SocketProxyInterface::r#get_ip_type_of_service(self)
3544 }
3545
3546 pub fn r#set_ip_ttl(
3548 &self,
3549 mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
3550 ) -> fidl::client::QueryResponseFut<
3551 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlResult,
3552 fidl::encoding::DefaultFuchsiaResourceDialect,
3553 > {
3554 SocketProxyInterface::r#set_ip_ttl(self, value)
3555 }
3556
3557 pub fn r#get_ip_ttl(
3559 &self,
3560 ) -> fidl::client::QueryResponseFut<
3561 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResult,
3562 fidl::encoding::DefaultFuchsiaResourceDialect,
3563 > {
3564 SocketProxyInterface::r#get_ip_ttl(self)
3565 }
3566
3567 pub fn r#set_ip_packet_info(
3569 &self,
3570 mut value: bool,
3571 ) -> fidl::client::QueryResponseFut<
3572 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoResult,
3573 fidl::encoding::DefaultFuchsiaResourceDialect,
3574 > {
3575 SocketProxyInterface::r#set_ip_packet_info(self, value)
3576 }
3577
3578 pub fn r#get_ip_packet_info(
3580 &self,
3581 ) -> fidl::client::QueryResponseFut<
3582 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResult,
3583 fidl::encoding::DefaultFuchsiaResourceDialect,
3584 > {
3585 SocketProxyInterface::r#get_ip_packet_info(self)
3586 }
3587
3588 pub fn r#set_ip_receive_type_of_service(
3590 &self,
3591 mut value: bool,
3592 ) -> fidl::client::QueryResponseFut<
3593 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
3594 fidl::encoding::DefaultFuchsiaResourceDialect,
3595 > {
3596 SocketProxyInterface::r#set_ip_receive_type_of_service(self, value)
3597 }
3598
3599 pub fn r#get_ip_receive_type_of_service(
3601 &self,
3602 ) -> fidl::client::QueryResponseFut<
3603 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
3604 fidl::encoding::DefaultFuchsiaResourceDialect,
3605 > {
3606 SocketProxyInterface::r#get_ip_receive_type_of_service(self)
3607 }
3608
3609 pub fn r#set_ip_receive_ttl(
3611 &self,
3612 mut value: bool,
3613 ) -> fidl::client::QueryResponseFut<
3614 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlResult,
3615 fidl::encoding::DefaultFuchsiaResourceDialect,
3616 > {
3617 SocketProxyInterface::r#set_ip_receive_ttl(self, value)
3618 }
3619
3620 pub fn r#get_ip_receive_ttl(
3622 &self,
3623 ) -> fidl::client::QueryResponseFut<
3624 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResult,
3625 fidl::encoding::DefaultFuchsiaResourceDialect,
3626 > {
3627 SocketProxyInterface::r#get_ip_receive_ttl(self)
3628 }
3629
3630 pub fn r#set_ip_multicast_interface(
3632 &self,
3633 mut iface: u64,
3634 mut address: &fidl_fuchsia_net::Ipv4Address,
3635 ) -> fidl::client::QueryResponseFut<
3636 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceResult,
3637 fidl::encoding::DefaultFuchsiaResourceDialect,
3638 > {
3639 SocketProxyInterface::r#set_ip_multicast_interface(self, iface, address)
3640 }
3641
3642 pub fn r#get_ip_multicast_interface(
3644 &self,
3645 ) -> fidl::client::QueryResponseFut<
3646 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResult,
3647 fidl::encoding::DefaultFuchsiaResourceDialect,
3648 > {
3649 SocketProxyInterface::r#get_ip_multicast_interface(self)
3650 }
3651
3652 pub fn r#set_ip_multicast_ttl(
3654 &self,
3655 mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
3656 ) -> fidl::client::QueryResponseFut<
3657 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlResult,
3658 fidl::encoding::DefaultFuchsiaResourceDialect,
3659 > {
3660 SocketProxyInterface::r#set_ip_multicast_ttl(self, value)
3661 }
3662
3663 pub fn r#get_ip_multicast_ttl(
3665 &self,
3666 ) -> fidl::client::QueryResponseFut<
3667 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResult,
3668 fidl::encoding::DefaultFuchsiaResourceDialect,
3669 > {
3670 SocketProxyInterface::r#get_ip_multicast_ttl(self)
3671 }
3672
3673 pub fn r#set_ip_multicast_loopback(
3675 &self,
3676 mut value: bool,
3677 ) -> fidl::client::QueryResponseFut<
3678 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackResult,
3679 fidl::encoding::DefaultFuchsiaResourceDialect,
3680 > {
3681 SocketProxyInterface::r#set_ip_multicast_loopback(self, value)
3682 }
3683
3684 pub fn r#get_ip_multicast_loopback(
3686 &self,
3687 ) -> fidl::client::QueryResponseFut<
3688 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResult,
3689 fidl::encoding::DefaultFuchsiaResourceDialect,
3690 > {
3691 SocketProxyInterface::r#get_ip_multicast_loopback(self)
3692 }
3693
3694 pub fn r#add_ip_membership(
3696 &self,
3697 mut membership: &fidl_fuchsia_posix_socket::IpMulticastMembership,
3698 ) -> fidl::client::QueryResponseFut<
3699 fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipResult,
3700 fidl::encoding::DefaultFuchsiaResourceDialect,
3701 > {
3702 SocketProxyInterface::r#add_ip_membership(self, membership)
3703 }
3704
3705 pub fn r#drop_ip_membership(
3707 &self,
3708 mut membership: &fidl_fuchsia_posix_socket::IpMulticastMembership,
3709 ) -> fidl::client::QueryResponseFut<
3710 fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipResult,
3711 fidl::encoding::DefaultFuchsiaResourceDialect,
3712 > {
3713 SocketProxyInterface::r#drop_ip_membership(self, membership)
3714 }
3715
3716 pub fn r#set_ip_transparent(
3718 &self,
3719 mut value: bool,
3720 ) -> fidl::client::QueryResponseFut<
3721 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentResult,
3722 fidl::encoding::DefaultFuchsiaResourceDialect,
3723 > {
3724 SocketProxyInterface::r#set_ip_transparent(self, value)
3725 }
3726
3727 pub fn r#get_ip_transparent(
3729 &self,
3730 ) -> fidl::client::QueryResponseFut<
3731 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResult,
3732 fidl::encoding::DefaultFuchsiaResourceDialect,
3733 > {
3734 SocketProxyInterface::r#get_ip_transparent(self)
3735 }
3736
3737 pub fn r#set_ip_receive_original_destination_address(
3739 &self,
3740 mut value: bool,
3741 ) -> fidl::client::QueryResponseFut<
3742 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
3743 fidl::encoding::DefaultFuchsiaResourceDialect,
3744 > {
3745 SocketProxyInterface::r#set_ip_receive_original_destination_address(self, value)
3746 }
3747
3748 pub fn r#get_ip_receive_original_destination_address(
3750 &self,
3751 ) -> fidl::client::QueryResponseFut<
3752 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
3753 fidl::encoding::DefaultFuchsiaResourceDialect,
3754 > {
3755 SocketProxyInterface::r#get_ip_receive_original_destination_address(self)
3756 }
3757
3758 pub fn r#add_ipv6_membership(
3760 &self,
3761 mut membership: &fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
3762 ) -> fidl::client::QueryResponseFut<
3763 fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipResult,
3764 fidl::encoding::DefaultFuchsiaResourceDialect,
3765 > {
3766 SocketProxyInterface::r#add_ipv6_membership(self, membership)
3767 }
3768
3769 pub fn r#drop_ipv6_membership(
3771 &self,
3772 mut membership: &fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
3773 ) -> fidl::client::QueryResponseFut<
3774 fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipResult,
3775 fidl::encoding::DefaultFuchsiaResourceDialect,
3776 > {
3777 SocketProxyInterface::r#drop_ipv6_membership(self, membership)
3778 }
3779
3780 pub fn r#set_ipv6_multicast_interface(
3782 &self,
3783 mut value: u64,
3784 ) -> fidl::client::QueryResponseFut<
3785 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceResult,
3786 fidl::encoding::DefaultFuchsiaResourceDialect,
3787 > {
3788 SocketProxyInterface::r#set_ipv6_multicast_interface(self, value)
3789 }
3790
3791 pub fn r#get_ipv6_multicast_interface(
3793 &self,
3794 ) -> fidl::client::QueryResponseFut<
3795 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResult,
3796 fidl::encoding::DefaultFuchsiaResourceDialect,
3797 > {
3798 SocketProxyInterface::r#get_ipv6_multicast_interface(self)
3799 }
3800
3801 pub fn r#set_ipv6_unicast_hops(
3803 &self,
3804 mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
3805 ) -> fidl::client::QueryResponseFut<
3806 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsResult,
3807 fidl::encoding::DefaultFuchsiaResourceDialect,
3808 > {
3809 SocketProxyInterface::r#set_ipv6_unicast_hops(self, value)
3810 }
3811
3812 pub fn r#get_ipv6_unicast_hops(
3814 &self,
3815 ) -> fidl::client::QueryResponseFut<
3816 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResult,
3817 fidl::encoding::DefaultFuchsiaResourceDialect,
3818 > {
3819 SocketProxyInterface::r#get_ipv6_unicast_hops(self)
3820 }
3821
3822 pub fn r#set_ipv6_receive_hop_limit(
3824 &self,
3825 mut value: bool,
3826 ) -> fidl::client::QueryResponseFut<
3827 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
3828 fidl::encoding::DefaultFuchsiaResourceDialect,
3829 > {
3830 SocketProxyInterface::r#set_ipv6_receive_hop_limit(self, value)
3831 }
3832
3833 pub fn r#get_ipv6_receive_hop_limit(
3835 &self,
3836 ) -> fidl::client::QueryResponseFut<
3837 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
3838 fidl::encoding::DefaultFuchsiaResourceDialect,
3839 > {
3840 SocketProxyInterface::r#get_ipv6_receive_hop_limit(self)
3841 }
3842
3843 pub fn r#set_ipv6_multicast_hops(
3845 &self,
3846 mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
3847 ) -> fidl::client::QueryResponseFut<
3848 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsResult,
3849 fidl::encoding::DefaultFuchsiaResourceDialect,
3850 > {
3851 SocketProxyInterface::r#set_ipv6_multicast_hops(self, value)
3852 }
3853
3854 pub fn r#get_ipv6_multicast_hops(
3856 &self,
3857 ) -> fidl::client::QueryResponseFut<
3858 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResult,
3859 fidl::encoding::DefaultFuchsiaResourceDialect,
3860 > {
3861 SocketProxyInterface::r#get_ipv6_multicast_hops(self)
3862 }
3863
3864 pub fn r#set_ipv6_multicast_loopback(
3866 &self,
3867 mut value: bool,
3868 ) -> fidl::client::QueryResponseFut<
3869 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackResult,
3870 fidl::encoding::DefaultFuchsiaResourceDialect,
3871 > {
3872 SocketProxyInterface::r#set_ipv6_multicast_loopback(self, value)
3873 }
3874
3875 pub fn r#get_ipv6_multicast_loopback(
3877 &self,
3878 ) -> fidl::client::QueryResponseFut<
3879 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResult,
3880 fidl::encoding::DefaultFuchsiaResourceDialect,
3881 > {
3882 SocketProxyInterface::r#get_ipv6_multicast_loopback(self)
3883 }
3884
3885 pub fn r#set_ipv6_only(
3887 &self,
3888 mut value: bool,
3889 ) -> fidl::client::QueryResponseFut<
3890 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyResult,
3891 fidl::encoding::DefaultFuchsiaResourceDialect,
3892 > {
3893 SocketProxyInterface::r#set_ipv6_only(self, value)
3894 }
3895
3896 pub fn r#get_ipv6_only(
3898 &self,
3899 ) -> fidl::client::QueryResponseFut<
3900 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResult,
3901 fidl::encoding::DefaultFuchsiaResourceDialect,
3902 > {
3903 SocketProxyInterface::r#get_ipv6_only(self)
3904 }
3905
3906 pub fn r#set_ipv6_receive_traffic_class(
3908 &self,
3909 mut value: bool,
3910 ) -> fidl::client::QueryResponseFut<
3911 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
3912 fidl::encoding::DefaultFuchsiaResourceDialect,
3913 > {
3914 SocketProxyInterface::r#set_ipv6_receive_traffic_class(self, value)
3915 }
3916
3917 pub fn r#get_ipv6_receive_traffic_class(
3919 &self,
3920 ) -> fidl::client::QueryResponseFut<
3921 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
3922 fidl::encoding::DefaultFuchsiaResourceDialect,
3923 > {
3924 SocketProxyInterface::r#get_ipv6_receive_traffic_class(self)
3925 }
3926
3927 pub fn r#set_ipv6_traffic_class(
3929 &self,
3930 mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
3931 ) -> fidl::client::QueryResponseFut<
3932 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassResult,
3933 fidl::encoding::DefaultFuchsiaResourceDialect,
3934 > {
3935 SocketProxyInterface::r#set_ipv6_traffic_class(self, value)
3936 }
3937
3938 pub fn r#get_ipv6_traffic_class(
3940 &self,
3941 ) -> fidl::client::QueryResponseFut<
3942 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResult,
3943 fidl::encoding::DefaultFuchsiaResourceDialect,
3944 > {
3945 SocketProxyInterface::r#get_ipv6_traffic_class(self)
3946 }
3947
3948 pub fn r#set_ipv6_receive_packet_info(
3950 &self,
3951 mut value: bool,
3952 ) -> fidl::client::QueryResponseFut<
3953 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
3954 fidl::encoding::DefaultFuchsiaResourceDialect,
3955 > {
3956 SocketProxyInterface::r#set_ipv6_receive_packet_info(self, value)
3957 }
3958
3959 pub fn r#get_ipv6_receive_packet_info(
3961 &self,
3962 ) -> fidl::client::QueryResponseFut<
3963 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
3964 fidl::encoding::DefaultFuchsiaResourceDialect,
3965 > {
3966 SocketProxyInterface::r#get_ipv6_receive_packet_info(self)
3967 }
3968
3969 pub fn r#get_original_destination(
3971 &self,
3972 ) -> fidl::client::QueryResponseFut<
3973 fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResult,
3974 fidl::encoding::DefaultFuchsiaResourceDialect,
3975 > {
3976 SocketProxyInterface::r#get_original_destination(self)
3977 }
3978
3979 pub fn r#describe(
3980 &self,
3981 ) -> fidl::client::QueryResponseFut<
3982 SocketDescribeResponse,
3983 fidl::encoding::DefaultFuchsiaResourceDialect,
3984 > {
3985 SocketProxyInterface::r#describe(self)
3986 }
3987
3988 pub fn r#recv_msg(
4003 &self,
4004 mut want_addr: bool,
4005 mut data_len: u32,
4006 mut want_control: bool,
4007 mut flags: fidl_fuchsia_posix_socket::RecvMsgFlags,
4008 ) -> fidl::client::QueryResponseFut<
4009 SocketRecvMsgResult,
4010 fidl::encoding::DefaultFuchsiaResourceDialect,
4011 > {
4012 SocketProxyInterface::r#recv_msg(self, want_addr, data_len, want_control, flags)
4013 }
4014
4015 pub fn r#send_msg(
4023 &self,
4024 mut addr: Option<&fidl_fuchsia_net::SocketAddress>,
4025 mut data: &[u8],
4026 mut control: &fidl_fuchsia_posix_socket::NetworkSocketSendControlData,
4027 mut flags: fidl_fuchsia_posix_socket::SendMsgFlags,
4028 ) -> fidl::client::QueryResponseFut<
4029 SocketSendMsgResult,
4030 fidl::encoding::DefaultFuchsiaResourceDialect,
4031 > {
4032 SocketProxyInterface::r#send_msg(self, addr, data, control, flags)
4033 }
4034
4035 pub fn r#get_info(
4040 &self,
4041 ) -> fidl::client::QueryResponseFut<
4042 SocketGetInfoResult,
4043 fidl::encoding::DefaultFuchsiaResourceDialect,
4044 > {
4045 SocketProxyInterface::r#get_info(self)
4046 }
4047
4048 pub fn r#set_ip_header_included(
4050 &self,
4051 mut value: bool,
4052 ) -> fidl::client::QueryResponseFut<
4053 SocketSetIpHeaderIncludedResult,
4054 fidl::encoding::DefaultFuchsiaResourceDialect,
4055 > {
4056 SocketProxyInterface::r#set_ip_header_included(self, value)
4057 }
4058
4059 pub fn r#get_ip_header_included(
4061 &self,
4062 ) -> fidl::client::QueryResponseFut<
4063 SocketGetIpHeaderIncludedResult,
4064 fidl::encoding::DefaultFuchsiaResourceDialect,
4065 > {
4066 SocketProxyInterface::r#get_ip_header_included(self)
4067 }
4068
4069 pub fn r#set_icmpv6_filter(
4071 &self,
4072 mut filter: &Icmpv6Filter,
4073 ) -> fidl::client::QueryResponseFut<
4074 SocketSetIcmpv6FilterResult,
4075 fidl::encoding::DefaultFuchsiaResourceDialect,
4076 > {
4077 SocketProxyInterface::r#set_icmpv6_filter(self, filter)
4078 }
4079
4080 pub fn r#get_icmpv6_filter(
4082 &self,
4083 ) -> fidl::client::QueryResponseFut<
4084 SocketGetIcmpv6FilterResult,
4085 fidl::encoding::DefaultFuchsiaResourceDialect,
4086 > {
4087 SocketProxyInterface::r#get_icmpv6_filter(self)
4088 }
4089
4090 pub fn r#set_ipv6_checksum(
4092 &self,
4093 mut config: &Ipv6ChecksumConfiguration,
4094 ) -> fidl::client::QueryResponseFut<
4095 SocketSetIpv6ChecksumResult,
4096 fidl::encoding::DefaultFuchsiaResourceDialect,
4097 > {
4098 SocketProxyInterface::r#set_ipv6_checksum(self, config)
4099 }
4100
4101 pub fn r#get_ipv6_checksum(
4103 &self,
4104 ) -> fidl::client::QueryResponseFut<
4105 SocketGetIpv6ChecksumResult,
4106 fidl::encoding::DefaultFuchsiaResourceDialect,
4107 > {
4108 SocketProxyInterface::r#get_ipv6_checksum(self)
4109 }
4110}
4111
4112impl SocketProxyInterface for SocketProxy {
4113 fn r#clone(
4114 &self,
4115 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
4116 ) -> Result<(), fidl::Error> {
4117 self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
4118 (request,),
4119 0x20d8a7aba2168a79,
4120 fidl::encoding::DynamicFlags::empty(),
4121 )
4122 }
4123
4124 type CloseResponseFut = fidl::client::QueryResponseFut<
4125 fidl_fuchsia_unknown::CloseableCloseResult,
4126 fidl::encoding::DefaultFuchsiaResourceDialect,
4127 >;
4128 fn r#close(&self) -> Self::CloseResponseFut {
4129 fn _decode(
4130 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4131 ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
4132 let _response = fidl::client::decode_transaction_body::<
4133 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
4134 fidl::encoding::DefaultFuchsiaResourceDialect,
4135 0x5ac5d459ad7f657e,
4136 >(_buf?)?;
4137 Ok(_response.map(|x| x))
4138 }
4139 self.client.send_query_and_decode::<
4140 fidl::encoding::EmptyPayload,
4141 fidl_fuchsia_unknown::CloseableCloseResult,
4142 >(
4143 (),
4144 0x5ac5d459ad7f657e,
4145 fidl::encoding::DynamicFlags::empty(),
4146 _decode,
4147 )
4148 }
4149
4150 type QueryResponseFut =
4151 fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
4152 fn r#query(&self) -> Self::QueryResponseFut {
4153 fn _decode(
4154 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4155 ) -> Result<Vec<u8>, fidl::Error> {
4156 let _response = fidl::client::decode_transaction_body::<
4157 fidl_fuchsia_unknown::QueryableQueryResponse,
4158 fidl::encoding::DefaultFuchsiaResourceDialect,
4159 0x2658edee9decfc06,
4160 >(_buf?)?;
4161 Ok(_response.protocol)
4162 }
4163 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
4164 (),
4165 0x2658edee9decfc06,
4166 fidl::encoding::DynamicFlags::empty(),
4167 _decode,
4168 )
4169 }
4170
4171 type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
4172 fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressResult,
4173 fidl::encoding::DefaultFuchsiaResourceDialect,
4174 >;
4175 fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
4176 fn _decode(
4177 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4178 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressResult, fidl::Error>
4179 {
4180 let _response = fidl::client::decode_transaction_body::<
4181 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4182 fidl::encoding::DefaultFuchsiaResourceDialect,
4183 0x1fd74ee8b9a4a876,
4184 >(_buf?)?;
4185 Ok(_response.map(|x| x))
4186 }
4187 self.client.send_query_and_decode::<
4188 fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressRequest,
4189 fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressResult,
4190 >(
4191 (value,),
4192 0x1fd74ee8b9a4a876,
4193 fidl::encoding::DynamicFlags::empty(),
4194 _decode,
4195 )
4196 }
4197
4198 type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
4199 fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResult,
4200 fidl::encoding::DefaultFuchsiaResourceDialect,
4201 >;
4202 fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
4203 fn _decode(
4204 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4205 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResult, fidl::Error>
4206 {
4207 let _response = fidl::client::decode_transaction_body::<
4208 fidl::encoding::ResultType<
4209 fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResponse,
4210 fidl_fuchsia_posix::Errno,
4211 >,
4212 fidl::encoding::DefaultFuchsiaResourceDialect,
4213 0x67b7206b8d1bc0a5,
4214 >(_buf?)?;
4215 Ok(_response.map(|x| x.value))
4216 }
4217 self.client.send_query_and_decode::<
4218 fidl::encoding::EmptyPayload,
4219 fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResult,
4220 >(
4221 (),
4222 0x67b7206b8d1bc0a5,
4223 fidl::encoding::DynamicFlags::empty(),
4224 _decode,
4225 )
4226 }
4227
4228 type GetErrorResponseFut = fidl::client::QueryResponseFut<
4229 fidl_fuchsia_posix_socket::BaseSocketGetErrorResult,
4230 fidl::encoding::DefaultFuchsiaResourceDialect,
4231 >;
4232 fn r#get_error(&self) -> Self::GetErrorResponseFut {
4233 fn _decode(
4234 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4235 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetErrorResult, fidl::Error> {
4236 let _response = fidl::client::decode_transaction_body::<
4237 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4238 fidl::encoding::DefaultFuchsiaResourceDialect,
4239 0x5aad39b33e5f6ebb,
4240 >(_buf?)?;
4241 Ok(_response.map(|x| x))
4242 }
4243 self.client.send_query_and_decode::<
4244 fidl::encoding::EmptyPayload,
4245 fidl_fuchsia_posix_socket::BaseSocketGetErrorResult,
4246 >(
4247 (),
4248 0x5aad39b33e5f6ebb,
4249 fidl::encoding::DynamicFlags::empty(),
4250 _decode,
4251 )
4252 }
4253
4254 type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
4255 fidl_fuchsia_posix_socket::BaseSocketSetBroadcastResult,
4256 fidl::encoding::DefaultFuchsiaResourceDialect,
4257 >;
4258 fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
4259 fn _decode(
4260 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4261 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetBroadcastResult, fidl::Error> {
4262 let _response = fidl::client::decode_transaction_body::<
4263 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4264 fidl::encoding::DefaultFuchsiaResourceDialect,
4265 0x6023e081ce3cd947,
4266 >(_buf?)?;
4267 Ok(_response.map(|x| x))
4268 }
4269 self.client.send_query_and_decode::<
4270 fidl_fuchsia_posix_socket::BaseSocketSetBroadcastRequest,
4271 fidl_fuchsia_posix_socket::BaseSocketSetBroadcastResult,
4272 >(
4273 (value,),
4274 0x6023e081ce3cd947,
4275 fidl::encoding::DynamicFlags::empty(),
4276 _decode,
4277 )
4278 }
4279
4280 type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
4281 fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResult,
4282 fidl::encoding::DefaultFuchsiaResourceDialect,
4283 >;
4284 fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
4285 fn _decode(
4286 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4287 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResult, fidl::Error> {
4288 let _response = fidl::client::decode_transaction_body::<
4289 fidl::encoding::ResultType<
4290 fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResponse,
4291 fidl_fuchsia_posix::Errno,
4292 >,
4293 fidl::encoding::DefaultFuchsiaResourceDialect,
4294 0x68796fc556f9780d,
4295 >(_buf?)?;
4296 Ok(_response.map(|x| x.value))
4297 }
4298 self.client.send_query_and_decode::<
4299 fidl::encoding::EmptyPayload,
4300 fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResult,
4301 >(
4302 (),
4303 0x68796fc556f9780d,
4304 fidl::encoding::DynamicFlags::empty(),
4305 _decode,
4306 )
4307 }
4308
4309 type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
4310 fidl_fuchsia_posix_socket::BaseSocketSetSendBufferResult,
4311 fidl::encoding::DefaultFuchsiaResourceDialect,
4312 >;
4313 fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
4314 fn _decode(
4315 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4316 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetSendBufferResult, fidl::Error> {
4317 let _response = fidl::client::decode_transaction_body::<
4318 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4319 fidl::encoding::DefaultFuchsiaResourceDialect,
4320 0x756eac32d73a7a70,
4321 >(_buf?)?;
4322 Ok(_response.map(|x| x))
4323 }
4324 self.client.send_query_and_decode::<
4325 fidl_fuchsia_posix_socket::BaseSocketSetSendBufferRequest,
4326 fidl_fuchsia_posix_socket::BaseSocketSetSendBufferResult,
4327 >(
4328 (value_bytes,),
4329 0x756eac32d73a7a70,
4330 fidl::encoding::DynamicFlags::empty(),
4331 _decode,
4332 )
4333 }
4334
4335 type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
4336 fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResult,
4337 fidl::encoding::DefaultFuchsiaResourceDialect,
4338 >;
4339 fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
4340 fn _decode(
4341 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4342 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResult, fidl::Error> {
4343 let _response = fidl::client::decode_transaction_body::<
4344 fidl::encoding::ResultType<
4345 fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResponse,
4346 fidl_fuchsia_posix::Errno,
4347 >,
4348 fidl::encoding::DefaultFuchsiaResourceDialect,
4349 0x78a52fd9c7b2410b,
4350 >(_buf?)?;
4351 Ok(_response.map(|x| x.value_bytes))
4352 }
4353 self.client.send_query_and_decode::<
4354 fidl::encoding::EmptyPayload,
4355 fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResult,
4356 >(
4357 (),
4358 0x78a52fd9c7b2410b,
4359 fidl::encoding::DynamicFlags::empty(),
4360 _decode,
4361 )
4362 }
4363
4364 type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
4365 fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferResult,
4366 fidl::encoding::DefaultFuchsiaResourceDialect,
4367 >;
4368 fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
4369 fn _decode(
4370 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4371 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferResult, fidl::Error>
4372 {
4373 let _response = fidl::client::decode_transaction_body::<
4374 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4375 fidl::encoding::DefaultFuchsiaResourceDialect,
4376 0x6b0cf2f1919c7001,
4377 >(_buf?)?;
4378 Ok(_response.map(|x| x))
4379 }
4380 self.client.send_query_and_decode::<
4381 fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferRequest,
4382 fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferResult,
4383 >(
4384 (value_bytes,),
4385 0x6b0cf2f1919c7001,
4386 fidl::encoding::DynamicFlags::empty(),
4387 _decode,
4388 )
4389 }
4390
4391 type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
4392 fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResult,
4393 fidl::encoding::DefaultFuchsiaResourceDialect,
4394 >;
4395 fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
4396 fn _decode(
4397 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4398 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResult, fidl::Error>
4399 {
4400 let _response = fidl::client::decode_transaction_body::<
4401 fidl::encoding::ResultType<
4402 fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResponse,
4403 fidl_fuchsia_posix::Errno,
4404 >,
4405 fidl::encoding::DefaultFuchsiaResourceDialect,
4406 0x14c1a4b64f709e5c,
4407 >(_buf?)?;
4408 Ok(_response.map(|x| x.value_bytes))
4409 }
4410 self.client.send_query_and_decode::<
4411 fidl::encoding::EmptyPayload,
4412 fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResult,
4413 >(
4414 (),
4415 0x14c1a4b64f709e5c,
4416 fidl::encoding::DynamicFlags::empty(),
4417 _decode,
4418 )
4419 }
4420
4421 type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
4422 fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveResult,
4423 fidl::encoding::DefaultFuchsiaResourceDialect,
4424 >;
4425 fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
4426 fn _decode(
4427 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4428 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveResult, fidl::Error> {
4429 let _response = fidl::client::decode_transaction_body::<
4430 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4431 fidl::encoding::DefaultFuchsiaResourceDialect,
4432 0x572df8f0b920d2c7,
4433 >(_buf?)?;
4434 Ok(_response.map(|x| x))
4435 }
4436 self.client.send_query_and_decode::<
4437 fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveRequest,
4438 fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveResult,
4439 >(
4440 (value,),
4441 0x572df8f0b920d2c7,
4442 fidl::encoding::DynamicFlags::empty(),
4443 _decode,
4444 )
4445 }
4446
4447 type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
4448 fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResult,
4449 fidl::encoding::DefaultFuchsiaResourceDialect,
4450 >;
4451 fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
4452 fn _decode(
4453 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4454 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResult, fidl::Error> {
4455 let _response = fidl::client::decode_transaction_body::<
4456 fidl::encoding::ResultType<
4457 fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResponse,
4458 fidl_fuchsia_posix::Errno,
4459 >,
4460 fidl::encoding::DefaultFuchsiaResourceDialect,
4461 0x2dd29d3215f2c9d2,
4462 >(_buf?)?;
4463 Ok(_response.map(|x| x.value))
4464 }
4465 self.client.send_query_and_decode::<
4466 fidl::encoding::EmptyPayload,
4467 fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResult,
4468 >(
4469 (),
4470 0x2dd29d3215f2c9d2,
4471 fidl::encoding::DynamicFlags::empty(),
4472 _decode,
4473 )
4474 }
4475
4476 type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
4477 fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineResult,
4478 fidl::encoding::DefaultFuchsiaResourceDialect,
4479 >;
4480 fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
4481 fn _decode(
4482 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4483 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineResult, fidl::Error>
4484 {
4485 let _response = fidl::client::decode_transaction_body::<
4486 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4487 fidl::encoding::DefaultFuchsiaResourceDialect,
4488 0x3ecb49968bee439,
4489 >(_buf?)?;
4490 Ok(_response.map(|x| x))
4491 }
4492 self.client.send_query_and_decode::<
4493 fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineRequest,
4494 fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineResult,
4495 >(
4496 (value,),
4497 0x3ecb49968bee439,
4498 fidl::encoding::DynamicFlags::empty(),
4499 _decode,
4500 )
4501 }
4502
4503 type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
4504 fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResult,
4505 fidl::encoding::DefaultFuchsiaResourceDialect,
4506 >;
4507 fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
4508 fn _decode(
4509 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4510 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResult, fidl::Error>
4511 {
4512 let _response = fidl::client::decode_transaction_body::<
4513 fidl::encoding::ResultType<
4514 fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResponse,
4515 fidl_fuchsia_posix::Errno,
4516 >,
4517 fidl::encoding::DefaultFuchsiaResourceDialect,
4518 0x348c1ab3aeca1745,
4519 >(_buf?)?;
4520 Ok(_response.map(|x| x.value))
4521 }
4522 self.client.send_query_and_decode::<
4523 fidl::encoding::EmptyPayload,
4524 fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResult,
4525 >(
4526 (),
4527 0x348c1ab3aeca1745,
4528 fidl::encoding::DynamicFlags::empty(),
4529 _decode,
4530 )
4531 }
4532
4533 type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
4534 fidl_fuchsia_posix_socket::BaseSocketSetNoCheckResult,
4535 fidl::encoding::DefaultFuchsiaResourceDialect,
4536 >;
4537 fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
4538 fn _decode(
4539 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4540 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetNoCheckResult, fidl::Error> {
4541 let _response = fidl::client::decode_transaction_body::<
4542 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4543 fidl::encoding::DefaultFuchsiaResourceDialect,
4544 0x6bbf00c53a4c78c2,
4545 >(_buf?)?;
4546 Ok(_response.map(|x| x))
4547 }
4548 self.client.send_query_and_decode::<
4549 fidl_fuchsia_posix_socket::BaseSocketSetNoCheckRequest,
4550 fidl_fuchsia_posix_socket::BaseSocketSetNoCheckResult,
4551 >(
4552 (value,),
4553 0x6bbf00c53a4c78c2,
4554 fidl::encoding::DynamicFlags::empty(),
4555 _decode,
4556 )
4557 }
4558
4559 type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
4560 fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResult,
4561 fidl::encoding::DefaultFuchsiaResourceDialect,
4562 >;
4563 fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
4564 fn _decode(
4565 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4566 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResult, fidl::Error> {
4567 let _response = fidl::client::decode_transaction_body::<
4568 fidl::encoding::ResultType<
4569 fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResponse,
4570 fidl_fuchsia_posix::Errno,
4571 >,
4572 fidl::encoding::DefaultFuchsiaResourceDialect,
4573 0x2cd4249286417694,
4574 >(_buf?)?;
4575 Ok(_response.map(|x| x.value))
4576 }
4577 self.client.send_query_and_decode::<
4578 fidl::encoding::EmptyPayload,
4579 fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResult,
4580 >(
4581 (),
4582 0x2cd4249286417694,
4583 fidl::encoding::DynamicFlags::empty(),
4584 _decode,
4585 )
4586 }
4587
4588 type SetLingerResponseFut = fidl::client::QueryResponseFut<
4589 fidl_fuchsia_posix_socket::BaseSocketSetLingerResult,
4590 fidl::encoding::DefaultFuchsiaResourceDialect,
4591 >;
4592 fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
4593 fn _decode(
4594 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4595 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetLingerResult, fidl::Error> {
4596 let _response = fidl::client::decode_transaction_body::<
4597 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4598 fidl::encoding::DefaultFuchsiaResourceDialect,
4599 0x45386351246e998e,
4600 >(_buf?)?;
4601 Ok(_response.map(|x| x))
4602 }
4603 self.client.send_query_and_decode::<
4604 fidl_fuchsia_posix_socket::BaseSocketSetLingerRequest,
4605 fidl_fuchsia_posix_socket::BaseSocketSetLingerResult,
4606 >(
4607 (linger, length_secs,),
4608 0x45386351246e998e,
4609 fidl::encoding::DynamicFlags::empty(),
4610 _decode,
4611 )
4612 }
4613
4614 type GetLingerResponseFut = fidl::client::QueryResponseFut<
4615 fidl_fuchsia_posix_socket::BaseSocketGetLingerResult,
4616 fidl::encoding::DefaultFuchsiaResourceDialect,
4617 >;
4618 fn r#get_linger(&self) -> Self::GetLingerResponseFut {
4619 fn _decode(
4620 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4621 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetLingerResult, fidl::Error> {
4622 let _response = fidl::client::decode_transaction_body::<
4623 fidl::encoding::ResultType<
4624 fidl_fuchsia_posix_socket::BaseSocketGetLingerResponse,
4625 fidl_fuchsia_posix::Errno,
4626 >,
4627 fidl::encoding::DefaultFuchsiaResourceDialect,
4628 0x48eb20fc5ccb0e45,
4629 >(_buf?)?;
4630 Ok(_response.map(|x| (x.linger, x.length_secs)))
4631 }
4632 self.client.send_query_and_decode::<
4633 fidl::encoding::EmptyPayload,
4634 fidl_fuchsia_posix_socket::BaseSocketGetLingerResult,
4635 >(
4636 (),
4637 0x48eb20fc5ccb0e45,
4638 fidl::encoding::DynamicFlags::empty(),
4639 _decode,
4640 )
4641 }
4642
4643 type SetReusePortResponseFut = fidl::client::QueryResponseFut<
4644 fidl_fuchsia_posix_socket::BaseSocketSetReusePortResult,
4645 fidl::encoding::DefaultFuchsiaResourceDialect,
4646 >;
4647 fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
4648 fn _decode(
4649 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4650 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetReusePortResult, fidl::Error> {
4651 let _response = fidl::client::decode_transaction_body::<
4652 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4653 fidl::encoding::DefaultFuchsiaResourceDialect,
4654 0x24dd3e5cb36d9ccb,
4655 >(_buf?)?;
4656 Ok(_response.map(|x| x))
4657 }
4658 self.client.send_query_and_decode::<
4659 fidl_fuchsia_posix_socket::BaseSocketSetReusePortRequest,
4660 fidl_fuchsia_posix_socket::BaseSocketSetReusePortResult,
4661 >(
4662 (value,),
4663 0x24dd3e5cb36d9ccb,
4664 fidl::encoding::DynamicFlags::empty(),
4665 _decode,
4666 )
4667 }
4668
4669 type GetReusePortResponseFut = fidl::client::QueryResponseFut<
4670 fidl_fuchsia_posix_socket::BaseSocketGetReusePortResult,
4671 fidl::encoding::DefaultFuchsiaResourceDialect,
4672 >;
4673 fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
4674 fn _decode(
4675 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4676 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetReusePortResult, fidl::Error> {
4677 let _response = fidl::client::decode_transaction_body::<
4678 fidl::encoding::ResultType<
4679 fidl_fuchsia_posix_socket::BaseSocketGetReusePortResponse,
4680 fidl_fuchsia_posix::Errno,
4681 >,
4682 fidl::encoding::DefaultFuchsiaResourceDialect,
4683 0x7a112c1ab54ff828,
4684 >(_buf?)?;
4685 Ok(_response.map(|x| x.value))
4686 }
4687 self.client.send_query_and_decode::<
4688 fidl::encoding::EmptyPayload,
4689 fidl_fuchsia_posix_socket::BaseSocketGetReusePortResult,
4690 >(
4691 (),
4692 0x7a112c1ab54ff828,
4693 fidl::encoding::DynamicFlags::empty(),
4694 _decode,
4695 )
4696 }
4697
4698 type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
4699 fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResult,
4700 fidl::encoding::DefaultFuchsiaResourceDialect,
4701 >;
4702 fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
4703 fn _decode(
4704 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4705 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResult, fidl::Error> {
4706 let _response = fidl::client::decode_transaction_body::<
4707 fidl::encoding::ResultType<
4708 fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResponse,
4709 fidl_fuchsia_posix::Errno,
4710 >,
4711 fidl::encoding::DefaultFuchsiaResourceDialect,
4712 0x67ce6db6c2ec8966,
4713 >(_buf?)?;
4714 Ok(_response.map(|x| x.value))
4715 }
4716 self.client.send_query_and_decode::<
4717 fidl::encoding::EmptyPayload,
4718 fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResult,
4719 >(
4720 (),
4721 0x67ce6db6c2ec8966,
4722 fidl::encoding::DynamicFlags::empty(),
4723 _decode,
4724 )
4725 }
4726
4727 type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
4728 fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceResult,
4729 fidl::encoding::DefaultFuchsiaResourceDialect,
4730 >;
4731 fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
4732 fn _decode(
4733 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4734 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceResult, fidl::Error>
4735 {
4736 let _response = fidl::client::decode_transaction_body::<
4737 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4738 fidl::encoding::DefaultFuchsiaResourceDialect,
4739 0x2118b483f28aafc4,
4740 >(_buf?)?;
4741 Ok(_response.map(|x| x))
4742 }
4743 self.client.send_query_and_decode::<
4744 fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceRequest,
4745 fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceResult,
4746 >(
4747 (value,),
4748 0x2118b483f28aafc4,
4749 fidl::encoding::DynamicFlags::empty(),
4750 _decode,
4751 )
4752 }
4753
4754 type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
4755 fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResult,
4756 fidl::encoding::DefaultFuchsiaResourceDialect,
4757 >;
4758 fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
4759 fn _decode(
4760 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4761 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResult, fidl::Error>
4762 {
4763 let _response = fidl::client::decode_transaction_body::<
4764 fidl::encoding::ResultType<
4765 fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResponse,
4766 fidl_fuchsia_posix::Errno,
4767 >,
4768 fidl::encoding::DefaultFuchsiaResourceDialect,
4769 0x1ab1fbf0ef7906c8,
4770 >(_buf?)?;
4771 Ok(_response.map(|x| x.value))
4772 }
4773 self.client.send_query_and_decode::<
4774 fidl::encoding::EmptyPayload,
4775 fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResult,
4776 >(
4777 (),
4778 0x1ab1fbf0ef7906c8,
4779 fidl::encoding::DynamicFlags::empty(),
4780 _decode,
4781 )
4782 }
4783
4784 type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
4785 fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexResult,
4786 fidl::encoding::DefaultFuchsiaResourceDialect,
4787 >;
4788 fn r#set_bind_to_interface_index(
4789 &self,
4790 mut value: u64,
4791 ) -> Self::SetBindToInterfaceIndexResponseFut {
4792 fn _decode(
4793 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4794 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexResult, fidl::Error>
4795 {
4796 let _response = fidl::client::decode_transaction_body::<
4797 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4798 fidl::encoding::DefaultFuchsiaResourceDialect,
4799 0x6e387a0def00821,
4800 >(_buf?)?;
4801 Ok(_response.map(|x| x))
4802 }
4803 self.client.send_query_and_decode::<
4804 fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexRequest,
4805 fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexResult,
4806 >(
4807 (value,),
4808 0x6e387a0def00821,
4809 fidl::encoding::DynamicFlags::empty(),
4810 _decode,
4811 )
4812 }
4813
4814 type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
4815 fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResult,
4816 fidl::encoding::DefaultFuchsiaResourceDialect,
4817 >;
4818 fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
4819 fn _decode(
4820 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4821 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResult, fidl::Error>
4822 {
4823 let _response = fidl::client::decode_transaction_body::<
4824 fidl::encoding::ResultType<
4825 fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResponse,
4826 fidl_fuchsia_posix::Errno,
4827 >,
4828 fidl::encoding::DefaultFuchsiaResourceDialect,
4829 0x59c31dd3e3078295,
4830 >(_buf?)?;
4831 Ok(_response.map(|x| x.value))
4832 }
4833 self.client.send_query_and_decode::<
4834 fidl::encoding::EmptyPayload,
4835 fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResult,
4836 >(
4837 (),
4838 0x59c31dd3e3078295,
4839 fidl::encoding::DynamicFlags::empty(),
4840 _decode,
4841 )
4842 }
4843
4844 type SetTimestampResponseFut = fidl::client::QueryResponseFut<
4845 fidl_fuchsia_posix_socket::BaseSocketSetTimestampResult,
4846 fidl::encoding::DefaultFuchsiaResourceDialect,
4847 >;
4848 fn r#set_timestamp(
4849 &self,
4850 mut value: fidl_fuchsia_posix_socket::TimestampOption,
4851 ) -> Self::SetTimestampResponseFut {
4852 fn _decode(
4853 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4854 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetTimestampResult, fidl::Error> {
4855 let _response = fidl::client::decode_transaction_body::<
4856 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4857 fidl::encoding::DefaultFuchsiaResourceDialect,
4858 0x285d6516c263d839,
4859 >(_buf?)?;
4860 Ok(_response.map(|x| x))
4861 }
4862 self.client.send_query_and_decode::<
4863 fidl_fuchsia_posix_socket::BaseSocketSetTimestampRequest,
4864 fidl_fuchsia_posix_socket::BaseSocketSetTimestampResult,
4865 >(
4866 (value,),
4867 0x285d6516c263d839,
4868 fidl::encoding::DynamicFlags::empty(),
4869 _decode,
4870 )
4871 }
4872
4873 type GetTimestampResponseFut = fidl::client::QueryResponseFut<
4874 fidl_fuchsia_posix_socket::BaseSocketGetTimestampResult,
4875 fidl::encoding::DefaultFuchsiaResourceDialect,
4876 >;
4877 fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
4878 fn _decode(
4879 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4880 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetTimestampResult, fidl::Error> {
4881 let _response = fidl::client::decode_transaction_body::<
4882 fidl::encoding::ResultType<
4883 fidl_fuchsia_posix_socket::BaseSocketGetTimestampResponse,
4884 fidl_fuchsia_posix::Errno,
4885 >,
4886 fidl::encoding::DefaultFuchsiaResourceDialect,
4887 0x49f2fffbbcc2bd27,
4888 >(_buf?)?;
4889 Ok(_response.map(|x| x.value))
4890 }
4891 self.client.send_query_and_decode::<
4892 fidl::encoding::EmptyPayload,
4893 fidl_fuchsia_posix_socket::BaseSocketGetTimestampResult,
4894 >(
4895 (),
4896 0x49f2fffbbcc2bd27,
4897 fidl::encoding::DynamicFlags::empty(),
4898 _decode,
4899 )
4900 }
4901
4902 type SetMarkResponseFut = fidl::client::QueryResponseFut<
4903 fidl_fuchsia_posix_socket::BaseSocketSetMarkResult,
4904 fidl::encoding::DefaultFuchsiaResourceDialect,
4905 >;
4906 fn r#set_mark(
4907 &self,
4908 mut domain: fidl_fuchsia_net::MarkDomain,
4909 mut mark: &fidl_fuchsia_posix_socket::OptionalUint32,
4910 ) -> Self::SetMarkResponseFut {
4911 fn _decode(
4912 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4913 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetMarkResult, fidl::Error> {
4914 let _response = fidl::client::decode_transaction_body::<
4915 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4916 fidl::encoding::DefaultFuchsiaResourceDialect,
4917 0x6ead6de09f653236,
4918 >(_buf?)?;
4919 Ok(_response.map(|x| x))
4920 }
4921 self.client.send_query_and_decode::<
4922 fidl_fuchsia_posix_socket::BaseSocketSetMarkRequest,
4923 fidl_fuchsia_posix_socket::BaseSocketSetMarkResult,
4924 >(
4925 (domain, mark,),
4926 0x6ead6de09f653236,
4927 fidl::encoding::DynamicFlags::empty(),
4928 _decode,
4929 )
4930 }
4931
4932 type GetMarkResponseFut = fidl::client::QueryResponseFut<
4933 fidl_fuchsia_posix_socket::BaseSocketGetMarkResult,
4934 fidl::encoding::DefaultFuchsiaResourceDialect,
4935 >;
4936 fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
4937 fn _decode(
4938 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4939 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetMarkResult, fidl::Error> {
4940 let _response = fidl::client::decode_transaction_body::<
4941 fidl::encoding::ResultType<
4942 fidl_fuchsia_posix_socket::BaseSocketGetMarkResponse,
4943 fidl_fuchsia_posix::Errno,
4944 >,
4945 fidl::encoding::DefaultFuchsiaResourceDialect,
4946 0x57a2752c61d93d47,
4947 >(_buf?)?;
4948 Ok(_response.map(|x| x.mark))
4949 }
4950 self.client.send_query_and_decode::<
4951 fidl_fuchsia_posix_socket::BaseSocketGetMarkRequest,
4952 fidl_fuchsia_posix_socket::BaseSocketGetMarkResult,
4953 >(
4954 (domain,),
4955 0x57a2752c61d93d47,
4956 fidl::encoding::DynamicFlags::empty(),
4957 _decode,
4958 )
4959 }
4960
4961 type GetCookieResponseFut = fidl::client::QueryResponseFut<
4962 fidl_fuchsia_posix_socket::BaseSocketGetCookieResult,
4963 fidl::encoding::DefaultFuchsiaResourceDialect,
4964 >;
4965 fn r#get_cookie(&self) -> Self::GetCookieResponseFut {
4966 fn _decode(
4967 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4968 ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetCookieResult, fidl::Error> {
4969 let _response = fidl::client::decode_transaction_body::<
4970 fidl::encoding::ResultType<
4971 fidl_fuchsia_posix_socket::BaseSocketGetCookieResponse,
4972 fidl_fuchsia_posix::Errno,
4973 >,
4974 fidl::encoding::DefaultFuchsiaResourceDialect,
4975 0x2c2f47fd8f924e52,
4976 >(_buf?)?;
4977 Ok(_response.map(|x| x.value))
4978 }
4979 self.client.send_query_and_decode::<
4980 fidl::encoding::EmptyPayload,
4981 fidl_fuchsia_posix_socket::BaseSocketGetCookieResult,
4982 >(
4983 (),
4984 0x2c2f47fd8f924e52,
4985 fidl::encoding::DynamicFlags::empty(),
4986 _decode,
4987 )
4988 }
4989
4990 type BindResponseFut = fidl::client::QueryResponseFut<
4991 fidl_fuchsia_posix_socket::BaseNetworkSocketBindResult,
4992 fidl::encoding::DefaultFuchsiaResourceDialect,
4993 >;
4994 fn r#bind(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut {
4995 fn _decode(
4996 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4997 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketBindResult, fidl::Error> {
4998 let _response = fidl::client::decode_transaction_body::<
4999 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5000 fidl::encoding::DefaultFuchsiaResourceDialect,
5001 0x4bc6400ae92125d,
5002 >(_buf?)?;
5003 Ok(_response.map(|x| x))
5004 }
5005 self.client.send_query_and_decode::<
5006 fidl_fuchsia_posix_socket::BaseNetworkSocketBindRequest,
5007 fidl_fuchsia_posix_socket::BaseNetworkSocketBindResult,
5008 >(
5009 (addr,),
5010 0x4bc6400ae92125d,
5011 fidl::encoding::DynamicFlags::empty(),
5012 _decode,
5013 )
5014 }
5015
5016 type ConnectResponseFut = fidl::client::QueryResponseFut<
5017 fidl_fuchsia_posix_socket::BaseNetworkSocketConnectResult,
5018 fidl::encoding::DefaultFuchsiaResourceDialect,
5019 >;
5020 fn r#connect(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut {
5021 fn _decode(
5022 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5023 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketConnectResult, fidl::Error>
5024 {
5025 let _response = fidl::client::decode_transaction_body::<
5026 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5027 fidl::encoding::DefaultFuchsiaResourceDialect,
5028 0x5f05f19bfdd38871,
5029 >(_buf?)?;
5030 Ok(_response.map(|x| x))
5031 }
5032 self.client.send_query_and_decode::<
5033 fidl_fuchsia_posix_socket::BaseNetworkSocketConnectRequest,
5034 fidl_fuchsia_posix_socket::BaseNetworkSocketConnectResult,
5035 >(
5036 (addr,),
5037 0x5f05f19bfdd38871,
5038 fidl::encoding::DynamicFlags::empty(),
5039 _decode,
5040 )
5041 }
5042
5043 type DisconnectResponseFut = fidl::client::QueryResponseFut<
5044 fidl_fuchsia_posix_socket::BaseNetworkSocketDisconnectResult,
5045 fidl::encoding::DefaultFuchsiaResourceDialect,
5046 >;
5047 fn r#disconnect(&self) -> Self::DisconnectResponseFut {
5048 fn _decode(
5049 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5050 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketDisconnectResult, fidl::Error>
5051 {
5052 let _response = fidl::client::decode_transaction_body::<
5053 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5054 fidl::encoding::DefaultFuchsiaResourceDialect,
5055 0x74e63b91f7b29b2,
5056 >(_buf?)?;
5057 Ok(_response.map(|x| x))
5058 }
5059 self.client.send_query_and_decode::<
5060 fidl::encoding::EmptyPayload,
5061 fidl_fuchsia_posix_socket::BaseNetworkSocketDisconnectResult,
5062 >(
5063 (),
5064 0x74e63b91f7b29b2,
5065 fidl::encoding::DynamicFlags::empty(),
5066 _decode,
5067 )
5068 }
5069
5070 type GetSockNameResponseFut = fidl::client::QueryResponseFut<
5071 fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResult,
5072 fidl::encoding::DefaultFuchsiaResourceDialect,
5073 >;
5074 fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
5075 fn _decode(
5076 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5077 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResult, fidl::Error>
5078 {
5079 let _response = fidl::client::decode_transaction_body::<
5080 fidl::encoding::ResultType<
5081 fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResponse,
5082 fidl_fuchsia_posix::Errno,
5083 >,
5084 fidl::encoding::DefaultFuchsiaResourceDialect,
5085 0x475f23f84a1a4f85,
5086 >(_buf?)?;
5087 Ok(_response.map(|x| x.addr))
5088 }
5089 self.client.send_query_and_decode::<
5090 fidl::encoding::EmptyPayload,
5091 fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResult,
5092 >(
5093 (),
5094 0x475f23f84a1a4f85,
5095 fidl::encoding::DynamicFlags::empty(),
5096 _decode,
5097 )
5098 }
5099
5100 type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
5101 fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResult,
5102 fidl::encoding::DefaultFuchsiaResourceDialect,
5103 >;
5104 fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
5105 fn _decode(
5106 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5107 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResult, fidl::Error>
5108 {
5109 let _response = fidl::client::decode_transaction_body::<
5110 fidl::encoding::ResultType<
5111 fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResponse,
5112 fidl_fuchsia_posix::Errno,
5113 >,
5114 fidl::encoding::DefaultFuchsiaResourceDialect,
5115 0x1ffecf4bd5b6432e,
5116 >(_buf?)?;
5117 Ok(_response.map(|x| x.addr))
5118 }
5119 self.client.send_query_and_decode::<
5120 fidl::encoding::EmptyPayload,
5121 fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResult,
5122 >(
5123 (),
5124 0x1ffecf4bd5b6432e,
5125 fidl::encoding::DynamicFlags::empty(),
5126 _decode,
5127 )
5128 }
5129
5130 type ShutdownResponseFut = fidl::client::QueryResponseFut<
5131 fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownResult,
5132 fidl::encoding::DefaultFuchsiaResourceDialect,
5133 >;
5134 fn r#shutdown(
5135 &self,
5136 mut mode: fidl_fuchsia_posix_socket::ShutdownMode,
5137 ) -> Self::ShutdownResponseFut {
5138 fn _decode(
5139 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5140 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownResult, fidl::Error>
5141 {
5142 let _response = fidl::client::decode_transaction_body::<
5143 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5144 fidl::encoding::DefaultFuchsiaResourceDialect,
5145 0x247f38b6db68c336,
5146 >(_buf?)?;
5147 Ok(_response.map(|x| x))
5148 }
5149 self.client.send_query_and_decode::<
5150 fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownRequest,
5151 fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownResult,
5152 >(
5153 (mode,),
5154 0x247f38b6db68c336,
5155 fidl::encoding::DynamicFlags::empty(),
5156 _decode,
5157 )
5158 }
5159
5160 type SetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
5161 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceResult,
5162 fidl::encoding::DefaultFuchsiaResourceDialect,
5163 >;
5164 fn r#set_ip_type_of_service(&self, mut value: u8) -> Self::SetIpTypeOfServiceResponseFut {
5165 fn _decode(
5166 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5167 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>
5168 {
5169 let _response = fidl::client::decode_transaction_body::<
5170 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5171 fidl::encoding::DefaultFuchsiaResourceDialect,
5172 0x995c600475b6d46,
5173 >(_buf?)?;
5174 Ok(_response.map(|x| x))
5175 }
5176 self.client.send_query_and_decode::<
5177 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceRequest,
5178 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceResult,
5179 >(
5180 (value,),
5181 0x995c600475b6d46,
5182 fidl::encoding::DynamicFlags::empty(),
5183 _decode,
5184 )
5185 }
5186
5187 type GetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
5188 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResult,
5189 fidl::encoding::DefaultFuchsiaResourceDialect,
5190 >;
5191 fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut {
5192 fn _decode(
5193 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5194 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>
5195 {
5196 let _response = fidl::client::decode_transaction_body::<
5197 fidl::encoding::ResultType<
5198 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResponse,
5199 fidl_fuchsia_posix::Errno,
5200 >,
5201 fidl::encoding::DefaultFuchsiaResourceDialect,
5202 0x3814a04259f75fcb,
5203 >(_buf?)?;
5204 Ok(_response.map(|x| x.value))
5205 }
5206 self.client.send_query_and_decode::<
5207 fidl::encoding::EmptyPayload,
5208 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResult,
5209 >(
5210 (),
5211 0x3814a04259f75fcb,
5212 fidl::encoding::DynamicFlags::empty(),
5213 _decode,
5214 )
5215 }
5216
5217 type SetIpTtlResponseFut = fidl::client::QueryResponseFut<
5218 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlResult,
5219 fidl::encoding::DefaultFuchsiaResourceDialect,
5220 >;
5221 fn r#set_ip_ttl(
5222 &self,
5223 mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
5224 ) -> Self::SetIpTtlResponseFut {
5225 fn _decode(
5226 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5227 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlResult, fidl::Error>
5228 {
5229 let _response = fidl::client::decode_transaction_body::<
5230 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5231 fidl::encoding::DefaultFuchsiaResourceDialect,
5232 0x29e2424b433ae1ef,
5233 >(_buf?)?;
5234 Ok(_response.map(|x| x))
5235 }
5236 self.client.send_query_and_decode::<
5237 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlRequest,
5238 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlResult,
5239 >(
5240 (value,),
5241 0x29e2424b433ae1ef,
5242 fidl::encoding::DynamicFlags::empty(),
5243 _decode,
5244 )
5245 }
5246
5247 type GetIpTtlResponseFut = fidl::client::QueryResponseFut<
5248 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResult,
5249 fidl::encoding::DefaultFuchsiaResourceDialect,
5250 >;
5251 fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut {
5252 fn _decode(
5253 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5254 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResult, fidl::Error>
5255 {
5256 let _response = fidl::client::decode_transaction_body::<
5257 fidl::encoding::ResultType<
5258 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResponse,
5259 fidl_fuchsia_posix::Errno,
5260 >,
5261 fidl::encoding::DefaultFuchsiaResourceDialect,
5262 0x47e47fa1f24da471,
5263 >(_buf?)?;
5264 Ok(_response.map(|x| x.value))
5265 }
5266 self.client.send_query_and_decode::<
5267 fidl::encoding::EmptyPayload,
5268 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResult,
5269 >(
5270 (),
5271 0x47e47fa1f24da471,
5272 fidl::encoding::DynamicFlags::empty(),
5273 _decode,
5274 )
5275 }
5276
5277 type SetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
5278 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoResult,
5279 fidl::encoding::DefaultFuchsiaResourceDialect,
5280 >;
5281 fn r#set_ip_packet_info(&self, mut value: bool) -> Self::SetIpPacketInfoResponseFut {
5282 fn _decode(
5283 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5284 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>
5285 {
5286 let _response = fidl::client::decode_transaction_body::<
5287 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5288 fidl::encoding::DefaultFuchsiaResourceDialect,
5289 0x392d16bee20c0e16,
5290 >(_buf?)?;
5291 Ok(_response.map(|x| x))
5292 }
5293 self.client.send_query_and_decode::<
5294 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoRequest,
5295 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoResult,
5296 >(
5297 (value,),
5298 0x392d16bee20c0e16,
5299 fidl::encoding::DynamicFlags::empty(),
5300 _decode,
5301 )
5302 }
5303
5304 type GetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
5305 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResult,
5306 fidl::encoding::DefaultFuchsiaResourceDialect,
5307 >;
5308 fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut {
5309 fn _decode(
5310 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5311 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>
5312 {
5313 let _response = fidl::client::decode_transaction_body::<
5314 fidl::encoding::ResultType<
5315 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResponse,
5316 fidl_fuchsia_posix::Errno,
5317 >,
5318 fidl::encoding::DefaultFuchsiaResourceDialect,
5319 0x54b505f242280740,
5320 >(_buf?)?;
5321 Ok(_response.map(|x| x.value))
5322 }
5323 self.client.send_query_and_decode::<
5324 fidl::encoding::EmptyPayload,
5325 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResult,
5326 >(
5327 (),
5328 0x54b505f242280740,
5329 fidl::encoding::DynamicFlags::empty(),
5330 _decode,
5331 )
5332 }
5333
5334 type SetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
5335 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
5336 fidl::encoding::DefaultFuchsiaResourceDialect,
5337 >;
5338 fn r#set_ip_receive_type_of_service(
5339 &self,
5340 mut value: bool,
5341 ) -> Self::SetIpReceiveTypeOfServiceResponseFut {
5342 fn _decode(
5343 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5344 ) -> Result<
5345 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
5346 fidl::Error,
5347 > {
5348 let _response = fidl::client::decode_transaction_body::<
5349 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5350 fidl::encoding::DefaultFuchsiaResourceDialect,
5351 0x6c4f6714995f84ef,
5352 >(_buf?)?;
5353 Ok(_response.map(|x| x))
5354 }
5355 self.client.send_query_and_decode::<
5356 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
5357 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
5358 >(
5359 (value,),
5360 0x6c4f6714995f84ef,
5361 fidl::encoding::DynamicFlags::empty(),
5362 _decode,
5363 )
5364 }
5365
5366 type GetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
5367 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
5368 fidl::encoding::DefaultFuchsiaResourceDialect,
5369 >;
5370 fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut {
5371 fn _decode(
5372 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5373 ) -> Result<
5374 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
5375 fidl::Error,
5376 > {
5377 let _response = fidl::client::decode_transaction_body::<
5378 fidl::encoding::ResultType<
5379 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
5380 fidl_fuchsia_posix::Errno,
5381 >,
5382 fidl::encoding::DefaultFuchsiaResourceDialect,
5383 0x4158ba7dc2795960,
5384 >(_buf?)?;
5385 Ok(_response.map(|x| x.value))
5386 }
5387 self.client.send_query_and_decode::<
5388 fidl::encoding::EmptyPayload,
5389 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
5390 >(
5391 (),
5392 0x4158ba7dc2795960,
5393 fidl::encoding::DynamicFlags::empty(),
5394 _decode,
5395 )
5396 }
5397
5398 type SetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
5399 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlResult,
5400 fidl::encoding::DefaultFuchsiaResourceDialect,
5401 >;
5402 fn r#set_ip_receive_ttl(&self, mut value: bool) -> Self::SetIpReceiveTtlResponseFut {
5403 fn _decode(
5404 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5405 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>
5406 {
5407 let _response = fidl::client::decode_transaction_body::<
5408 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5409 fidl::encoding::DefaultFuchsiaResourceDialect,
5410 0x46f15be0ce0ab82b,
5411 >(_buf?)?;
5412 Ok(_response.map(|x| x))
5413 }
5414 self.client.send_query_and_decode::<
5415 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlRequest,
5416 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlResult,
5417 >(
5418 (value,),
5419 0x46f15be0ce0ab82b,
5420 fidl::encoding::DynamicFlags::empty(),
5421 _decode,
5422 )
5423 }
5424
5425 type GetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
5426 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResult,
5427 fidl::encoding::DefaultFuchsiaResourceDialect,
5428 >;
5429 fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut {
5430 fn _decode(
5431 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5432 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>
5433 {
5434 let _response = fidl::client::decode_transaction_body::<
5435 fidl::encoding::ResultType<
5436 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResponse,
5437 fidl_fuchsia_posix::Errno,
5438 >,
5439 fidl::encoding::DefaultFuchsiaResourceDialect,
5440 0x678ddd5a5dfa2eb5,
5441 >(_buf?)?;
5442 Ok(_response.map(|x| x.value))
5443 }
5444 self.client.send_query_and_decode::<
5445 fidl::encoding::EmptyPayload,
5446 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResult,
5447 >(
5448 (),
5449 0x678ddd5a5dfa2eb5,
5450 fidl::encoding::DynamicFlags::empty(),
5451 _decode,
5452 )
5453 }
5454
5455 type SetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
5456 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceResult,
5457 fidl::encoding::DefaultFuchsiaResourceDialect,
5458 >;
5459 fn r#set_ip_multicast_interface(
5460 &self,
5461 mut iface: u64,
5462 mut address: &fidl_fuchsia_net::Ipv4Address,
5463 ) -> Self::SetIpMulticastInterfaceResponseFut {
5464 fn _decode(
5465 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5466 ) -> Result<
5467 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceResult,
5468 fidl::Error,
5469 > {
5470 let _response = fidl::client::decode_transaction_body::<
5471 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5472 fidl::encoding::DefaultFuchsiaResourceDialect,
5473 0x752fbfa9b12befe,
5474 >(_buf?)?;
5475 Ok(_response.map(|x| x))
5476 }
5477 self.client.send_query_and_decode::<
5478 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceRequest,
5479 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceResult,
5480 >(
5481 (iface, address,),
5482 0x752fbfa9b12befe,
5483 fidl::encoding::DynamicFlags::empty(),
5484 _decode,
5485 )
5486 }
5487
5488 type GetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
5489 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResult,
5490 fidl::encoding::DefaultFuchsiaResourceDialect,
5491 >;
5492 fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut {
5493 fn _decode(
5494 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5495 ) -> Result<
5496 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResult,
5497 fidl::Error,
5498 > {
5499 let _response = fidl::client::decode_transaction_body::<
5500 fidl::encoding::ResultType<
5501 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResponse,
5502 fidl_fuchsia_posix::Errno,
5503 >,
5504 fidl::encoding::DefaultFuchsiaResourceDialect,
5505 0x320bd14c4df046c4,
5506 >(_buf?)?;
5507 Ok(_response.map(|x| x.value))
5508 }
5509 self.client.send_query_and_decode::<
5510 fidl::encoding::EmptyPayload,
5511 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResult,
5512 >(
5513 (),
5514 0x320bd14c4df046c4,
5515 fidl::encoding::DynamicFlags::empty(),
5516 _decode,
5517 )
5518 }
5519
5520 type SetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
5521 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlResult,
5522 fidl::encoding::DefaultFuchsiaResourceDialect,
5523 >;
5524 fn r#set_ip_multicast_ttl(
5525 &self,
5526 mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
5527 ) -> Self::SetIpMulticastTtlResponseFut {
5528 fn _decode(
5529 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5530 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>
5531 {
5532 let _response = fidl::client::decode_transaction_body::<
5533 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5534 fidl::encoding::DefaultFuchsiaResourceDialect,
5535 0x63134d53772916a1,
5536 >(_buf?)?;
5537 Ok(_response.map(|x| x))
5538 }
5539 self.client.send_query_and_decode::<
5540 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlRequest,
5541 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlResult,
5542 >(
5543 (value,),
5544 0x63134d53772916a1,
5545 fidl::encoding::DynamicFlags::empty(),
5546 _decode,
5547 )
5548 }
5549
5550 type GetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
5551 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResult,
5552 fidl::encoding::DefaultFuchsiaResourceDialect,
5553 >;
5554 fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut {
5555 fn _decode(
5556 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5557 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>
5558 {
5559 let _response = fidl::client::decode_transaction_body::<
5560 fidl::encoding::ResultType<
5561 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResponse,
5562 fidl_fuchsia_posix::Errno,
5563 >,
5564 fidl::encoding::DefaultFuchsiaResourceDialect,
5565 0x4665cd378f39e1a,
5566 >(_buf?)?;
5567 Ok(_response.map(|x| x.value))
5568 }
5569 self.client.send_query_and_decode::<
5570 fidl::encoding::EmptyPayload,
5571 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResult,
5572 >(
5573 (),
5574 0x4665cd378f39e1a,
5575 fidl::encoding::DynamicFlags::empty(),
5576 _decode,
5577 )
5578 }
5579
5580 type SetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
5581 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackResult,
5582 fidl::encoding::DefaultFuchsiaResourceDialect,
5583 >;
5584 fn r#set_ip_multicast_loopback(
5585 &self,
5586 mut value: bool,
5587 ) -> Self::SetIpMulticastLoopbackResponseFut {
5588 fn _decode(
5589 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5590 ) -> Result<
5591 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackResult,
5592 fidl::Error,
5593 > {
5594 let _response = fidl::client::decode_transaction_body::<
5595 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5596 fidl::encoding::DefaultFuchsiaResourceDialect,
5597 0x20c55c11f00943ea,
5598 >(_buf?)?;
5599 Ok(_response.map(|x| x))
5600 }
5601 self.client.send_query_and_decode::<
5602 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackRequest,
5603 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackResult,
5604 >(
5605 (value,),
5606 0x20c55c11f00943ea,
5607 fidl::encoding::DynamicFlags::empty(),
5608 _decode,
5609 )
5610 }
5611
5612 type GetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
5613 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResult,
5614 fidl::encoding::DefaultFuchsiaResourceDialect,
5615 >;
5616 fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut {
5617 fn _decode(
5618 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5619 ) -> Result<
5620 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResult,
5621 fidl::Error,
5622 > {
5623 let _response = fidl::client::decode_transaction_body::<
5624 fidl::encoding::ResultType<
5625 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResponse,
5626 fidl_fuchsia_posix::Errno,
5627 >,
5628 fidl::encoding::DefaultFuchsiaResourceDialect,
5629 0x3b6b26ff558298f2,
5630 >(_buf?)?;
5631 Ok(_response.map(|x| x.value))
5632 }
5633 self.client.send_query_and_decode::<
5634 fidl::encoding::EmptyPayload,
5635 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResult,
5636 >(
5637 (),
5638 0x3b6b26ff558298f2,
5639 fidl::encoding::DynamicFlags::empty(),
5640 _decode,
5641 )
5642 }
5643
5644 type AddIpMembershipResponseFut = fidl::client::QueryResponseFut<
5645 fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipResult,
5646 fidl::encoding::DefaultFuchsiaResourceDialect,
5647 >;
5648 fn r#add_ip_membership(
5649 &self,
5650 mut membership: &fidl_fuchsia_posix_socket::IpMulticastMembership,
5651 ) -> Self::AddIpMembershipResponseFut {
5652 fn _decode(
5653 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5654 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipResult, fidl::Error>
5655 {
5656 let _response = fidl::client::decode_transaction_body::<
5657 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5658 fidl::encoding::DefaultFuchsiaResourceDialect,
5659 0x76bc7df115a3b4d0,
5660 >(_buf?)?;
5661 Ok(_response.map(|x| x))
5662 }
5663 self.client.send_query_and_decode::<
5664 fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipRequest,
5665 fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipResult,
5666 >(
5667 (membership,),
5668 0x76bc7df115a3b4d0,
5669 fidl::encoding::DynamicFlags::empty(),
5670 _decode,
5671 )
5672 }
5673
5674 type DropIpMembershipResponseFut = fidl::client::QueryResponseFut<
5675 fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipResult,
5676 fidl::encoding::DefaultFuchsiaResourceDialect,
5677 >;
5678 fn r#drop_ip_membership(
5679 &self,
5680 mut membership: &fidl_fuchsia_posix_socket::IpMulticastMembership,
5681 ) -> Self::DropIpMembershipResponseFut {
5682 fn _decode(
5683 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5684 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipResult, fidl::Error>
5685 {
5686 let _response = fidl::client::decode_transaction_body::<
5687 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5688 fidl::encoding::DefaultFuchsiaResourceDialect,
5689 0x2888f3099188d03,
5690 >(_buf?)?;
5691 Ok(_response.map(|x| x))
5692 }
5693 self.client.send_query_and_decode::<
5694 fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipRequest,
5695 fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipResult,
5696 >(
5697 (membership,),
5698 0x2888f3099188d03,
5699 fidl::encoding::DynamicFlags::empty(),
5700 _decode,
5701 )
5702 }
5703
5704 type SetIpTransparentResponseFut = fidl::client::QueryResponseFut<
5705 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentResult,
5706 fidl::encoding::DefaultFuchsiaResourceDialect,
5707 >;
5708 fn r#set_ip_transparent(&self, mut value: bool) -> Self::SetIpTransparentResponseFut {
5709 fn _decode(
5710 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5711 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentResult, fidl::Error>
5712 {
5713 let _response = fidl::client::decode_transaction_body::<
5714 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5715 fidl::encoding::DefaultFuchsiaResourceDialect,
5716 0x1ae532b0c066e3a0,
5717 >(_buf?)?;
5718 Ok(_response.map(|x| x))
5719 }
5720 self.client.send_query_and_decode::<
5721 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentRequest,
5722 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentResult,
5723 >(
5724 (value,),
5725 0x1ae532b0c066e3a0,
5726 fidl::encoding::DynamicFlags::empty(),
5727 _decode,
5728 )
5729 }
5730
5731 type GetIpTransparentResponseFut = fidl::client::QueryResponseFut<
5732 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResult,
5733 fidl::encoding::DefaultFuchsiaResourceDialect,
5734 >;
5735 fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut {
5736 fn _decode(
5737 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5738 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResult, fidl::Error>
5739 {
5740 let _response = fidl::client::decode_transaction_body::<
5741 fidl::encoding::ResultType<
5742 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResponse,
5743 fidl_fuchsia_posix::Errno,
5744 >,
5745 fidl::encoding::DefaultFuchsiaResourceDialect,
5746 0x51d43695962ebfb5,
5747 >(_buf?)?;
5748 Ok(_response.map(|x| x.value))
5749 }
5750 self.client.send_query_and_decode::<
5751 fidl::encoding::EmptyPayload,
5752 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResult,
5753 >(
5754 (),
5755 0x51d43695962ebfb5,
5756 fidl::encoding::DynamicFlags::empty(),
5757 _decode,
5758 )
5759 }
5760
5761 type SetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
5762 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
5763 fidl::encoding::DefaultFuchsiaResourceDialect,
5764 >;
5765 fn r#set_ip_receive_original_destination_address(
5766 &self,
5767 mut value: bool,
5768 ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut {
5769 fn _decode(mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>{
5770 let _response = fidl::client::decode_transaction_body::<
5771 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5772 fidl::encoding::DefaultFuchsiaResourceDialect,
5773 0x4722b4ce52f7840,
5774 >(_buf?)?;
5775 Ok(_response.map(|x| x))
5776 }
5777 self.client.send_query_and_decode::<
5778 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
5779 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
5780 >(
5781 (value,),
5782 0x4722b4ce52f7840,
5783 fidl::encoding::DynamicFlags::empty(),
5784 _decode,
5785 )
5786 }
5787
5788 type GetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
5789 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
5790 fidl::encoding::DefaultFuchsiaResourceDialect,
5791 >;
5792 fn r#get_ip_receive_original_destination_address(
5793 &self,
5794 ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut {
5795 fn _decode(mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>{
5796 let _response = fidl::client::decode_transaction_body::<fidl::encoding::ResultType<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse, fidl_fuchsia_posix::Errno>, fidl::encoding::DefaultFuchsiaResourceDialect, 0x2a0e7dc5d6bfdfe9>(_buf?)?;
5797 Ok(_response.map(|x| x.value))
5798 }
5799 self.client.send_query_and_decode::<
5800 fidl::encoding::EmptyPayload,
5801 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
5802 >(
5803 (),
5804 0x2a0e7dc5d6bfdfe9,
5805 fidl::encoding::DynamicFlags::empty(),
5806 _decode,
5807 )
5808 }
5809
5810 type AddIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
5811 fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipResult,
5812 fidl::encoding::DefaultFuchsiaResourceDialect,
5813 >;
5814 fn r#add_ipv6_membership(
5815 &self,
5816 mut membership: &fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
5817 ) -> Self::AddIpv6MembershipResponseFut {
5818 fn _decode(
5819 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5820 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>
5821 {
5822 let _response = fidl::client::decode_transaction_body::<
5823 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5824 fidl::encoding::DefaultFuchsiaResourceDialect,
5825 0x7c94727acb4ea4b3,
5826 >(_buf?)?;
5827 Ok(_response.map(|x| x))
5828 }
5829 self.client.send_query_and_decode::<
5830 fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipRequest,
5831 fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipResult,
5832 >(
5833 (membership,),
5834 0x7c94727acb4ea4b3,
5835 fidl::encoding::DynamicFlags::empty(),
5836 _decode,
5837 )
5838 }
5839
5840 type DropIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
5841 fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipResult,
5842 fidl::encoding::DefaultFuchsiaResourceDialect,
5843 >;
5844 fn r#drop_ipv6_membership(
5845 &self,
5846 mut membership: &fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
5847 ) -> Self::DropIpv6MembershipResponseFut {
5848 fn _decode(
5849 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5850 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>
5851 {
5852 let _response = fidl::client::decode_transaction_body::<
5853 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5854 fidl::encoding::DefaultFuchsiaResourceDialect,
5855 0x42104c70ccaba304,
5856 >(_buf?)?;
5857 Ok(_response.map(|x| x))
5858 }
5859 self.client.send_query_and_decode::<
5860 fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipRequest,
5861 fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipResult,
5862 >(
5863 (membership,),
5864 0x42104c70ccaba304,
5865 fidl::encoding::DynamicFlags::empty(),
5866 _decode,
5867 )
5868 }
5869
5870 type SetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
5871 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceResult,
5872 fidl::encoding::DefaultFuchsiaResourceDialect,
5873 >;
5874 fn r#set_ipv6_multicast_interface(
5875 &self,
5876 mut value: u64,
5877 ) -> Self::SetIpv6MulticastInterfaceResponseFut {
5878 fn _decode(
5879 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5880 ) -> Result<
5881 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceResult,
5882 fidl::Error,
5883 > {
5884 let _response = fidl::client::decode_transaction_body::<
5885 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5886 fidl::encoding::DefaultFuchsiaResourceDialect,
5887 0x135f76db3774ab3b,
5888 >(_buf?)?;
5889 Ok(_response.map(|x| x))
5890 }
5891 self.client.send_query_and_decode::<
5892 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
5893 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceResult,
5894 >(
5895 (value,),
5896 0x135f76db3774ab3b,
5897 fidl::encoding::DynamicFlags::empty(),
5898 _decode,
5899 )
5900 }
5901
5902 type GetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
5903 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResult,
5904 fidl::encoding::DefaultFuchsiaResourceDialect,
5905 >;
5906 fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut {
5907 fn _decode(
5908 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5909 ) -> Result<
5910 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResult,
5911 fidl::Error,
5912 > {
5913 let _response = fidl::client::decode_transaction_body::<
5914 fidl::encoding::ResultType<
5915 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
5916 fidl_fuchsia_posix::Errno,
5917 >,
5918 fidl::encoding::DefaultFuchsiaResourceDialect,
5919 0x1f26fcdd348f1882,
5920 >(_buf?)?;
5921 Ok(_response.map(|x| x.value))
5922 }
5923 self.client.send_query_and_decode::<
5924 fidl::encoding::EmptyPayload,
5925 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResult,
5926 >(
5927 (),
5928 0x1f26fcdd348f1882,
5929 fidl::encoding::DynamicFlags::empty(),
5930 _decode,
5931 )
5932 }
5933
5934 type SetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
5935 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsResult,
5936 fidl::encoding::DefaultFuchsiaResourceDialect,
5937 >;
5938 fn r#set_ipv6_unicast_hops(
5939 &self,
5940 mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
5941 ) -> Self::SetIpv6UnicastHopsResponseFut {
5942 fn _decode(
5943 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5944 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>
5945 {
5946 let _response = fidl::client::decode_transaction_body::<
5947 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5948 fidl::encoding::DefaultFuchsiaResourceDialect,
5949 0x157d51e98f462859,
5950 >(_buf?)?;
5951 Ok(_response.map(|x| x))
5952 }
5953 self.client.send_query_and_decode::<
5954 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsRequest,
5955 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsResult,
5956 >(
5957 (value,),
5958 0x157d51e98f462859,
5959 fidl::encoding::DynamicFlags::empty(),
5960 _decode,
5961 )
5962 }
5963
5964 type GetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
5965 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResult,
5966 fidl::encoding::DefaultFuchsiaResourceDialect,
5967 >;
5968 fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut {
5969 fn _decode(
5970 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5971 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>
5972 {
5973 let _response = fidl::client::decode_transaction_body::<
5974 fidl::encoding::ResultType<
5975 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResponse,
5976 fidl_fuchsia_posix::Errno,
5977 >,
5978 fidl::encoding::DefaultFuchsiaResourceDialect,
5979 0x21f4641cad8bd8d2,
5980 >(_buf?)?;
5981 Ok(_response.map(|x| x.value))
5982 }
5983 self.client.send_query_and_decode::<
5984 fidl::encoding::EmptyPayload,
5985 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResult,
5986 >(
5987 (),
5988 0x21f4641cad8bd8d2,
5989 fidl::encoding::DynamicFlags::empty(),
5990 _decode,
5991 )
5992 }
5993
5994 type SetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
5995 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
5996 fidl::encoding::DefaultFuchsiaResourceDialect,
5997 >;
5998 fn r#set_ipv6_receive_hop_limit(
5999 &self,
6000 mut value: bool,
6001 ) -> Self::SetIpv6ReceiveHopLimitResponseFut {
6002 fn _decode(
6003 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6004 ) -> Result<
6005 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
6006 fidl::Error,
6007 > {
6008 let _response = fidl::client::decode_transaction_body::<
6009 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6010 fidl::encoding::DefaultFuchsiaResourceDialect,
6011 0x5c24808ed2e84a1e,
6012 >(_buf?)?;
6013 Ok(_response.map(|x| x))
6014 }
6015 self.client.send_query_and_decode::<
6016 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
6017 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
6018 >(
6019 (value,),
6020 0x5c24808ed2e84a1e,
6021 fidl::encoding::DynamicFlags::empty(),
6022 _decode,
6023 )
6024 }
6025
6026 type GetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
6027 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
6028 fidl::encoding::DefaultFuchsiaResourceDialect,
6029 >;
6030 fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut {
6031 fn _decode(
6032 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6033 ) -> Result<
6034 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
6035 fidl::Error,
6036 > {
6037 let _response = fidl::client::decode_transaction_body::<
6038 fidl::encoding::ResultType<
6039 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
6040 fidl_fuchsia_posix::Errno,
6041 >,
6042 fidl::encoding::DefaultFuchsiaResourceDialect,
6043 0x341e06689885b4c0,
6044 >(_buf?)?;
6045 Ok(_response.map(|x| x.value))
6046 }
6047 self.client.send_query_and_decode::<
6048 fidl::encoding::EmptyPayload,
6049 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
6050 >(
6051 (),
6052 0x341e06689885b4c0,
6053 fidl::encoding::DynamicFlags::empty(),
6054 _decode,
6055 )
6056 }
6057
6058 type SetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
6059 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsResult,
6060 fidl::encoding::DefaultFuchsiaResourceDialect,
6061 >;
6062 fn r#set_ipv6_multicast_hops(
6063 &self,
6064 mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
6065 ) -> Self::SetIpv6MulticastHopsResponseFut {
6066 fn _decode(
6067 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6068 ) -> Result<
6069 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsResult,
6070 fidl::Error,
6071 > {
6072 let _response = fidl::client::decode_transaction_body::<
6073 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6074 fidl::encoding::DefaultFuchsiaResourceDialect,
6075 0x25b9cd4d181f82c1,
6076 >(_buf?)?;
6077 Ok(_response.map(|x| x))
6078 }
6079 self.client.send_query_and_decode::<
6080 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsRequest,
6081 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsResult,
6082 >(
6083 (value,),
6084 0x25b9cd4d181f82c1,
6085 fidl::encoding::DynamicFlags::empty(),
6086 _decode,
6087 )
6088 }
6089
6090 type GetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
6091 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResult,
6092 fidl::encoding::DefaultFuchsiaResourceDialect,
6093 >;
6094 fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut {
6095 fn _decode(
6096 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6097 ) -> Result<
6098 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResult,
6099 fidl::Error,
6100 > {
6101 let _response = fidl::client::decode_transaction_body::<
6102 fidl::encoding::ResultType<
6103 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResponse,
6104 fidl_fuchsia_posix::Errno,
6105 >,
6106 fidl::encoding::DefaultFuchsiaResourceDialect,
6107 0x52916948a365012a,
6108 >(_buf?)?;
6109 Ok(_response.map(|x| x.value))
6110 }
6111 self.client.send_query_and_decode::<
6112 fidl::encoding::EmptyPayload,
6113 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResult,
6114 >(
6115 (),
6116 0x52916948a365012a,
6117 fidl::encoding::DynamicFlags::empty(),
6118 _decode,
6119 )
6120 }
6121
6122 type SetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
6123 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackResult,
6124 fidl::encoding::DefaultFuchsiaResourceDialect,
6125 >;
6126 fn r#set_ipv6_multicast_loopback(
6127 &self,
6128 mut value: bool,
6129 ) -> Self::SetIpv6MulticastLoopbackResponseFut {
6130 fn _decode(
6131 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6132 ) -> Result<
6133 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackResult,
6134 fidl::Error,
6135 > {
6136 let _response = fidl::client::decode_transaction_body::<
6137 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6138 fidl::encoding::DefaultFuchsiaResourceDialect,
6139 0x55701c409ff41b40,
6140 >(_buf?)?;
6141 Ok(_response.map(|x| x))
6142 }
6143 self.client.send_query_and_decode::<
6144 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
6145 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackResult,
6146 >(
6147 (value,),
6148 0x55701c409ff41b40,
6149 fidl::encoding::DynamicFlags::empty(),
6150 _decode,
6151 )
6152 }
6153
6154 type GetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
6155 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResult,
6156 fidl::encoding::DefaultFuchsiaResourceDialect,
6157 >;
6158 fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut {
6159 fn _decode(
6160 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6161 ) -> Result<
6162 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResult,
6163 fidl::Error,
6164 > {
6165 let _response = fidl::client::decode_transaction_body::<
6166 fidl::encoding::ResultType<
6167 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
6168 fidl_fuchsia_posix::Errno,
6169 >,
6170 fidl::encoding::DefaultFuchsiaResourceDialect,
6171 0x4415b701fde319c3,
6172 >(_buf?)?;
6173 Ok(_response.map(|x| x.value))
6174 }
6175 self.client.send_query_and_decode::<
6176 fidl::encoding::EmptyPayload,
6177 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResult,
6178 >(
6179 (),
6180 0x4415b701fde319c3,
6181 fidl::encoding::DynamicFlags::empty(),
6182 _decode,
6183 )
6184 }
6185
6186 type SetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
6187 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyResult,
6188 fidl::encoding::DefaultFuchsiaResourceDialect,
6189 >;
6190 fn r#set_ipv6_only(&self, mut value: bool) -> Self::SetIpv6OnlyResponseFut {
6191 fn _decode(
6192 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6193 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyResult, fidl::Error>
6194 {
6195 let _response = fidl::client::decode_transaction_body::<
6196 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6197 fidl::encoding::DefaultFuchsiaResourceDialect,
6198 0x4873f1364758cbba,
6199 >(_buf?)?;
6200 Ok(_response.map(|x| x))
6201 }
6202 self.client.send_query_and_decode::<
6203 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyRequest,
6204 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyResult,
6205 >(
6206 (value,),
6207 0x4873f1364758cbba,
6208 fidl::encoding::DynamicFlags::empty(),
6209 _decode,
6210 )
6211 }
6212
6213 type GetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
6214 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResult,
6215 fidl::encoding::DefaultFuchsiaResourceDialect,
6216 >;
6217 fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut {
6218 fn _decode(
6219 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6220 ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResult, fidl::Error>
6221 {
6222 let _response = fidl::client::decode_transaction_body::<
6223 fidl::encoding::ResultType<
6224 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResponse,
6225 fidl_fuchsia_posix::Errno,
6226 >,
6227 fidl::encoding::DefaultFuchsiaResourceDialect,
6228 0x4aa3340a1a26b89c,
6229 >(_buf?)?;
6230 Ok(_response.map(|x| x.value))
6231 }
6232 self.client.send_query_and_decode::<
6233 fidl::encoding::EmptyPayload,
6234 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResult,
6235 >(
6236 (),
6237 0x4aa3340a1a26b89c,
6238 fidl::encoding::DynamicFlags::empty(),
6239 _decode,
6240 )
6241 }
6242
6243 type SetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
6244 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
6245 fidl::encoding::DefaultFuchsiaResourceDialect,
6246 >;
6247 fn r#set_ipv6_receive_traffic_class(
6248 &self,
6249 mut value: bool,
6250 ) -> Self::SetIpv6ReceiveTrafficClassResponseFut {
6251 fn _decode(
6252 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6253 ) -> Result<
6254 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
6255 fidl::Error,
6256 > {
6257 let _response = fidl::client::decode_transaction_body::<
6258 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6259 fidl::encoding::DefaultFuchsiaResourceDialect,
6260 0x58f07c8788d099a0,
6261 >(_buf?)?;
6262 Ok(_response.map(|x| x))
6263 }
6264 self.client.send_query_and_decode::<
6265 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
6266 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
6267 >(
6268 (value,),
6269 0x58f07c8788d099a0,
6270 fidl::encoding::DynamicFlags::empty(),
6271 _decode,
6272 )
6273 }
6274
6275 type GetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
6276 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
6277 fidl::encoding::DefaultFuchsiaResourceDialect,
6278 >;
6279 fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut {
6280 fn _decode(
6281 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6282 ) -> Result<
6283 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
6284 fidl::Error,
6285 > {
6286 let _response = fidl::client::decode_transaction_body::<
6287 fidl::encoding::ResultType<
6288 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
6289 fidl_fuchsia_posix::Errno,
6290 >,
6291 fidl::encoding::DefaultFuchsiaResourceDialect,
6292 0x2e334df1da553ffa,
6293 >(_buf?)?;
6294 Ok(_response.map(|x| x.value))
6295 }
6296 self.client.send_query_and_decode::<
6297 fidl::encoding::EmptyPayload,
6298 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
6299 >(
6300 (),
6301 0x2e334df1da553ffa,
6302 fidl::encoding::DynamicFlags::empty(),
6303 _decode,
6304 )
6305 }
6306
6307 type SetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
6308 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassResult,
6309 fidl::encoding::DefaultFuchsiaResourceDialect,
6310 >;
6311 fn r#set_ipv6_traffic_class(
6312 &self,
6313 mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
6314 ) -> Self::SetIpv6TrafficClassResponseFut {
6315 fn _decode(
6316 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6317 ) -> Result<
6318 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassResult,
6319 fidl::Error,
6320 > {
6321 let _response = fidl::client::decode_transaction_body::<
6322 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6323 fidl::encoding::DefaultFuchsiaResourceDialect,
6324 0x6af077800c5a0b4f,
6325 >(_buf?)?;
6326 Ok(_response.map(|x| x))
6327 }
6328 self.client.send_query_and_decode::<
6329 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassRequest,
6330 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassResult,
6331 >(
6332 (value,),
6333 0x6af077800c5a0b4f,
6334 fidl::encoding::DynamicFlags::empty(),
6335 _decode,
6336 )
6337 }
6338
6339 type GetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
6340 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResult,
6341 fidl::encoding::DefaultFuchsiaResourceDialect,
6342 >;
6343 fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut {
6344 fn _decode(
6345 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6346 ) -> Result<
6347 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResult,
6348 fidl::Error,
6349 > {
6350 let _response = fidl::client::decode_transaction_body::<
6351 fidl::encoding::ResultType<
6352 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResponse,
6353 fidl_fuchsia_posix::Errno,
6354 >,
6355 fidl::encoding::DefaultFuchsiaResourceDialect,
6356 0x6baf6eed8fc2f04,
6357 >(_buf?)?;
6358 Ok(_response.map(|x| x.value))
6359 }
6360 self.client.send_query_and_decode::<
6361 fidl::encoding::EmptyPayload,
6362 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResult,
6363 >(
6364 (),
6365 0x6baf6eed8fc2f04,
6366 fidl::encoding::DynamicFlags::empty(),
6367 _decode,
6368 )
6369 }
6370
6371 type SetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
6372 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
6373 fidl::encoding::DefaultFuchsiaResourceDialect,
6374 >;
6375 fn r#set_ipv6_receive_packet_info(
6376 &self,
6377 mut value: bool,
6378 ) -> Self::SetIpv6ReceivePacketInfoResponseFut {
6379 fn _decode(
6380 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6381 ) -> Result<
6382 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
6383 fidl::Error,
6384 > {
6385 let _response = fidl::client::decode_transaction_body::<
6386 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6387 fidl::encoding::DefaultFuchsiaResourceDialect,
6388 0x19259775b1a92768,
6389 >(_buf?)?;
6390 Ok(_response.map(|x| x))
6391 }
6392 self.client.send_query_and_decode::<
6393 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
6394 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
6395 >(
6396 (value,),
6397 0x19259775b1a92768,
6398 fidl::encoding::DynamicFlags::empty(),
6399 _decode,
6400 )
6401 }
6402
6403 type GetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
6404 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
6405 fidl::encoding::DefaultFuchsiaResourceDialect,
6406 >;
6407 fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut {
6408 fn _decode(
6409 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6410 ) -> Result<
6411 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
6412 fidl::Error,
6413 > {
6414 let _response = fidl::client::decode_transaction_body::<
6415 fidl::encoding::ResultType<
6416 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
6417 fidl_fuchsia_posix::Errno,
6418 >,
6419 fidl::encoding::DefaultFuchsiaResourceDialect,
6420 0x7acd4a2775baec75,
6421 >(_buf?)?;
6422 Ok(_response.map(|x| x.value))
6423 }
6424 self.client.send_query_and_decode::<
6425 fidl::encoding::EmptyPayload,
6426 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
6427 >(
6428 (),
6429 0x7acd4a2775baec75,
6430 fidl::encoding::DynamicFlags::empty(),
6431 _decode,
6432 )
6433 }
6434
6435 type GetOriginalDestinationResponseFut = fidl::client::QueryResponseFut<
6436 fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResult,
6437 fidl::encoding::DefaultFuchsiaResourceDialect,
6438 >;
6439 fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut {
6440 fn _decode(
6441 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6442 ) -> Result<
6443 fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResult,
6444 fidl::Error,
6445 > {
6446 let _response = fidl::client::decode_transaction_body::<
6447 fidl::encoding::ResultType<
6448 fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResponse,
6449 fidl_fuchsia_posix::Errno,
6450 >,
6451 fidl::encoding::DefaultFuchsiaResourceDialect,
6452 0x38bf28f0dafdbac0,
6453 >(_buf?)?;
6454 Ok(_response.map(|x| x.value))
6455 }
6456 self.client.send_query_and_decode::<
6457 fidl::encoding::EmptyPayload,
6458 fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResult,
6459 >(
6460 (),
6461 0x38bf28f0dafdbac0,
6462 fidl::encoding::DynamicFlags::empty(),
6463 _decode,
6464 )
6465 }
6466
6467 type DescribeResponseFut = fidl::client::QueryResponseFut<
6468 SocketDescribeResponse,
6469 fidl::encoding::DefaultFuchsiaResourceDialect,
6470 >;
6471 fn r#describe(&self) -> Self::DescribeResponseFut {
6472 fn _decode(
6473 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6474 ) -> Result<SocketDescribeResponse, fidl::Error> {
6475 let _response = fidl::client::decode_transaction_body::<
6476 SocketDescribeResponse,
6477 fidl::encoding::DefaultFuchsiaResourceDialect,
6478 0x335706eccf54a135,
6479 >(_buf?)?;
6480 Ok(_response)
6481 }
6482 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, SocketDescribeResponse>(
6483 (),
6484 0x335706eccf54a135,
6485 fidl::encoding::DynamicFlags::empty(),
6486 _decode,
6487 )
6488 }
6489
6490 type RecvMsgResponseFut = fidl::client::QueryResponseFut<
6491 SocketRecvMsgResult,
6492 fidl::encoding::DefaultFuchsiaResourceDialect,
6493 >;
6494 fn r#recv_msg(
6495 &self,
6496 mut want_addr: bool,
6497 mut data_len: u32,
6498 mut want_control: bool,
6499 mut flags: fidl_fuchsia_posix_socket::RecvMsgFlags,
6500 ) -> Self::RecvMsgResponseFut {
6501 fn _decode(
6502 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6503 ) -> Result<SocketRecvMsgResult, fidl::Error> {
6504 let _response = fidl::client::decode_transaction_body::<
6505 fidl::encoding::ResultType<SocketRecvMsgResponse, fidl_fuchsia_posix::Errno>,
6506 fidl::encoding::DefaultFuchsiaResourceDialect,
6507 0x1dfb695351d3aa1d,
6508 >(_buf?)?;
6509 Ok(_response.map(|x| (x.addr, x.data, x.control, x.truncated)))
6510 }
6511 self.client.send_query_and_decode::<SocketRecvMsgRequest, SocketRecvMsgResult>(
6512 (want_addr, data_len, want_control, flags),
6513 0x1dfb695351d3aa1d,
6514 fidl::encoding::DynamicFlags::empty(),
6515 _decode,
6516 )
6517 }
6518
6519 type SendMsgResponseFut = fidl::client::QueryResponseFut<
6520 SocketSendMsgResult,
6521 fidl::encoding::DefaultFuchsiaResourceDialect,
6522 >;
6523 fn r#send_msg(
6524 &self,
6525 mut addr: Option<&fidl_fuchsia_net::SocketAddress>,
6526 mut data: &[u8],
6527 mut control: &fidl_fuchsia_posix_socket::NetworkSocketSendControlData,
6528 mut flags: fidl_fuchsia_posix_socket::SendMsgFlags,
6529 ) -> Self::SendMsgResponseFut {
6530 fn _decode(
6531 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6532 ) -> Result<SocketSendMsgResult, fidl::Error> {
6533 let _response = fidl::client::decode_transaction_body::<
6534 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6535 fidl::encoding::DefaultFuchsiaResourceDialect,
6536 0x2cf1eac9a7fc8958,
6537 >(_buf?)?;
6538 Ok(_response.map(|x| x))
6539 }
6540 self.client.send_query_and_decode::<SocketSendMsgRequest, SocketSendMsgResult>(
6541 (addr, data, control, flags),
6542 0x2cf1eac9a7fc8958,
6543 fidl::encoding::DynamicFlags::empty(),
6544 _decode,
6545 )
6546 }
6547
6548 type GetInfoResponseFut = fidl::client::QueryResponseFut<
6549 SocketGetInfoResult,
6550 fidl::encoding::DefaultFuchsiaResourceDialect,
6551 >;
6552 fn r#get_info(&self) -> Self::GetInfoResponseFut {
6553 fn _decode(
6554 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6555 ) -> Result<SocketGetInfoResult, fidl::Error> {
6556 let _response = fidl::client::decode_transaction_body::<
6557 fidl::encoding::ResultType<SocketGetInfoResponse, fidl_fuchsia_posix::Errno>,
6558 fidl::encoding::DefaultFuchsiaResourceDialect,
6559 0x39676f75aec339ba,
6560 >(_buf?)?;
6561 Ok(_response.map(|x| (x.domain, x.proto)))
6562 }
6563 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, SocketGetInfoResult>(
6564 (),
6565 0x39676f75aec339ba,
6566 fidl::encoding::DynamicFlags::empty(),
6567 _decode,
6568 )
6569 }
6570
6571 type SetIpHeaderIncludedResponseFut = fidl::client::QueryResponseFut<
6572 SocketSetIpHeaderIncludedResult,
6573 fidl::encoding::DefaultFuchsiaResourceDialect,
6574 >;
6575 fn r#set_ip_header_included(&self, mut value: bool) -> Self::SetIpHeaderIncludedResponseFut {
6576 fn _decode(
6577 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6578 ) -> Result<SocketSetIpHeaderIncludedResult, fidl::Error> {
6579 let _response = fidl::client::decode_transaction_body::<
6580 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6581 fidl::encoding::DefaultFuchsiaResourceDialect,
6582 0x5d06a606d95e8f3,
6583 >(_buf?)?;
6584 Ok(_response.map(|x| x))
6585 }
6586 self.client.send_query_and_decode::<
6587 SocketSetIpHeaderIncludedRequest,
6588 SocketSetIpHeaderIncludedResult,
6589 >(
6590 (value,),
6591 0x5d06a606d95e8f3,
6592 fidl::encoding::DynamicFlags::empty(),
6593 _decode,
6594 )
6595 }
6596
6597 type GetIpHeaderIncludedResponseFut = fidl::client::QueryResponseFut<
6598 SocketGetIpHeaderIncludedResult,
6599 fidl::encoding::DefaultFuchsiaResourceDialect,
6600 >;
6601 fn r#get_ip_header_included(&self) -> Self::GetIpHeaderIncludedResponseFut {
6602 fn _decode(
6603 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6604 ) -> Result<SocketGetIpHeaderIncludedResult, fidl::Error> {
6605 let _response = fidl::client::decode_transaction_body::<
6606 fidl::encoding::ResultType<
6607 SocketGetIpHeaderIncludedResponse,
6608 fidl_fuchsia_posix::Errno,
6609 >,
6610 fidl::encoding::DefaultFuchsiaResourceDialect,
6611 0x76125ad1f4d175f6,
6612 >(_buf?)?;
6613 Ok(_response.map(|x| x.value))
6614 }
6615 self.client
6616 .send_query_and_decode::<fidl::encoding::EmptyPayload, SocketGetIpHeaderIncludedResult>(
6617 (),
6618 0x76125ad1f4d175f6,
6619 fidl::encoding::DynamicFlags::empty(),
6620 _decode,
6621 )
6622 }
6623
6624 type SetIcmpv6FilterResponseFut = fidl::client::QueryResponseFut<
6625 SocketSetIcmpv6FilterResult,
6626 fidl::encoding::DefaultFuchsiaResourceDialect,
6627 >;
6628 fn r#set_icmpv6_filter(&self, mut filter: &Icmpv6Filter) -> Self::SetIcmpv6FilterResponseFut {
6629 fn _decode(
6630 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6631 ) -> Result<SocketSetIcmpv6FilterResult, fidl::Error> {
6632 let _response = fidl::client::decode_transaction_body::<
6633 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6634 fidl::encoding::DefaultFuchsiaResourceDialect,
6635 0x4ebea92a43ae68a9,
6636 >(_buf?)?;
6637 Ok(_response.map(|x| x))
6638 }
6639 self.client
6640 .send_query_and_decode::<SocketSetIcmpv6FilterRequest, SocketSetIcmpv6FilterResult>(
6641 (filter,),
6642 0x4ebea92a43ae68a9,
6643 fidl::encoding::DynamicFlags::empty(),
6644 _decode,
6645 )
6646 }
6647
6648 type GetIcmpv6FilterResponseFut = fidl::client::QueryResponseFut<
6649 SocketGetIcmpv6FilterResult,
6650 fidl::encoding::DefaultFuchsiaResourceDialect,
6651 >;
6652 fn r#get_icmpv6_filter(&self) -> Self::GetIcmpv6FilterResponseFut {
6653 fn _decode(
6654 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6655 ) -> Result<SocketGetIcmpv6FilterResult, fidl::Error> {
6656 let _response = fidl::client::decode_transaction_body::<
6657 fidl::encoding::ResultType<
6658 SocketGetIcmpv6FilterResponse,
6659 fidl_fuchsia_posix::Errno,
6660 >,
6661 fidl::encoding::DefaultFuchsiaResourceDialect,
6662 0x43bd4f3bc0970ace,
6663 >(_buf?)?;
6664 Ok(_response.map(|x| x.filter))
6665 }
6666 self.client
6667 .send_query_and_decode::<fidl::encoding::EmptyPayload, SocketGetIcmpv6FilterResult>(
6668 (),
6669 0x43bd4f3bc0970ace,
6670 fidl::encoding::DynamicFlags::empty(),
6671 _decode,
6672 )
6673 }
6674
6675 type SetIpv6ChecksumResponseFut = fidl::client::QueryResponseFut<
6676 SocketSetIpv6ChecksumResult,
6677 fidl::encoding::DefaultFuchsiaResourceDialect,
6678 >;
6679 fn r#set_ipv6_checksum(
6680 &self,
6681 mut config: &Ipv6ChecksumConfiguration,
6682 ) -> Self::SetIpv6ChecksumResponseFut {
6683 fn _decode(
6684 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6685 ) -> Result<SocketSetIpv6ChecksumResult, fidl::Error> {
6686 let _response = fidl::client::decode_transaction_body::<
6687 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6688 fidl::encoding::DefaultFuchsiaResourceDialect,
6689 0x18b7809577199cb4,
6690 >(_buf?)?;
6691 Ok(_response.map(|x| x))
6692 }
6693 self.client
6694 .send_query_and_decode::<SocketSetIpv6ChecksumRequest, SocketSetIpv6ChecksumResult>(
6695 (config,),
6696 0x18b7809577199cb4,
6697 fidl::encoding::DynamicFlags::empty(),
6698 _decode,
6699 )
6700 }
6701
6702 type GetIpv6ChecksumResponseFut = fidl::client::QueryResponseFut<
6703 SocketGetIpv6ChecksumResult,
6704 fidl::encoding::DefaultFuchsiaResourceDialect,
6705 >;
6706 fn r#get_ipv6_checksum(&self) -> Self::GetIpv6ChecksumResponseFut {
6707 fn _decode(
6708 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6709 ) -> Result<SocketGetIpv6ChecksumResult, fidl::Error> {
6710 let _response = fidl::client::decode_transaction_body::<
6711 fidl::encoding::ResultType<
6712 SocketGetIpv6ChecksumResponse,
6713 fidl_fuchsia_posix::Errno,
6714 >,
6715 fidl::encoding::DefaultFuchsiaResourceDialect,
6716 0x1847bf5b2d263dd,
6717 >(_buf?)?;
6718 Ok(_response.map(|x| x.config))
6719 }
6720 self.client
6721 .send_query_and_decode::<fidl::encoding::EmptyPayload, SocketGetIpv6ChecksumResult>(
6722 (),
6723 0x1847bf5b2d263dd,
6724 fidl::encoding::DynamicFlags::empty(),
6725 _decode,
6726 )
6727 }
6728}
6729
6730pub struct SocketEventStream {
6731 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
6732}
6733
6734impl std::marker::Unpin for SocketEventStream {}
6735
6736impl futures::stream::FusedStream for SocketEventStream {
6737 fn is_terminated(&self) -> bool {
6738 self.event_receiver.is_terminated()
6739 }
6740}
6741
6742impl futures::Stream for SocketEventStream {
6743 type Item = Result<SocketEvent, fidl::Error>;
6744
6745 fn poll_next(
6746 mut self: std::pin::Pin<&mut Self>,
6747 cx: &mut std::task::Context<'_>,
6748 ) -> std::task::Poll<Option<Self::Item>> {
6749 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
6750 &mut self.event_receiver,
6751 cx
6752 )?) {
6753 Some(buf) => std::task::Poll::Ready(Some(SocketEvent::decode(buf))),
6754 None => std::task::Poll::Ready(None),
6755 }
6756 }
6757}
6758
6759#[derive(Debug)]
6760pub enum SocketEvent {}
6761
6762impl SocketEvent {
6763 fn decode(
6765 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
6766 ) -> Result<SocketEvent, fidl::Error> {
6767 let (bytes, _handles) = buf.split_mut();
6768 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
6769 debug_assert_eq!(tx_header.tx_id, 0);
6770 match tx_header.ordinal {
6771 _ => Err(fidl::Error::UnknownOrdinal {
6772 ordinal: tx_header.ordinal,
6773 protocol_name: <SocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
6774 }),
6775 }
6776 }
6777}
6778
6779pub struct SocketRequestStream {
6781 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
6782 is_terminated: bool,
6783}
6784
6785impl std::marker::Unpin for SocketRequestStream {}
6786
6787impl futures::stream::FusedStream for SocketRequestStream {
6788 fn is_terminated(&self) -> bool {
6789 self.is_terminated
6790 }
6791}
6792
6793impl fidl::endpoints::RequestStream for SocketRequestStream {
6794 type Protocol = SocketMarker;
6795 type ControlHandle = SocketControlHandle;
6796
6797 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
6798 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
6799 }
6800
6801 fn control_handle(&self) -> Self::ControlHandle {
6802 SocketControlHandle { inner: self.inner.clone() }
6803 }
6804
6805 fn into_inner(
6806 self,
6807 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
6808 {
6809 (self.inner, self.is_terminated)
6810 }
6811
6812 fn from_inner(
6813 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
6814 is_terminated: bool,
6815 ) -> Self {
6816 Self { inner, is_terminated }
6817 }
6818}
6819
6820impl futures::Stream for SocketRequestStream {
6821 type Item = Result<SocketRequest, fidl::Error>;
6822
6823 fn poll_next(
6824 mut self: std::pin::Pin<&mut Self>,
6825 cx: &mut std::task::Context<'_>,
6826 ) -> std::task::Poll<Option<Self::Item>> {
6827 let this = &mut *self;
6828 if this.inner.check_shutdown(cx) {
6829 this.is_terminated = true;
6830 return std::task::Poll::Ready(None);
6831 }
6832 if this.is_terminated {
6833 panic!("polled SocketRequestStream after completion");
6834 }
6835 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
6836 |bytes, handles| {
6837 match this.inner.channel().read_etc(cx, bytes, handles) {
6838 std::task::Poll::Ready(Ok(())) => {}
6839 std::task::Poll::Pending => return std::task::Poll::Pending,
6840 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
6841 this.is_terminated = true;
6842 return std::task::Poll::Ready(None);
6843 }
6844 std::task::Poll::Ready(Err(e)) => {
6845 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
6846 e.into(),
6847 ))))
6848 }
6849 }
6850
6851 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
6853
6854 std::task::Poll::Ready(Some(match header.ordinal {
6855 0x20d8a7aba2168a79 => {
6856 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
6857 let mut req = fidl::new_empty!(
6858 fidl_fuchsia_unknown::CloneableCloneRequest,
6859 fidl::encoding::DefaultFuchsiaResourceDialect
6860 );
6861 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
6862 let control_handle = SocketControlHandle { inner: this.inner.clone() };
6863 Ok(SocketRequest::Clone { request: req.request, control_handle })
6864 }
6865 0x5ac5d459ad7f657e => {
6866 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6867 let mut req = fidl::new_empty!(
6868 fidl::encoding::EmptyPayload,
6869 fidl::encoding::DefaultFuchsiaResourceDialect
6870 );
6871 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6872 let control_handle = SocketControlHandle { inner: this.inner.clone() };
6873 Ok(SocketRequest::Close {
6874 responder: SocketCloseResponder {
6875 control_handle: std::mem::ManuallyDrop::new(control_handle),
6876 tx_id: header.tx_id,
6877 },
6878 })
6879 }
6880 0x2658edee9decfc06 => {
6881 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6882 let mut req = fidl::new_empty!(
6883 fidl::encoding::EmptyPayload,
6884 fidl::encoding::DefaultFuchsiaResourceDialect
6885 );
6886 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6887 let control_handle = SocketControlHandle { inner: this.inner.clone() };
6888 Ok(SocketRequest::Query {
6889 responder: SocketQueryResponder {
6890 control_handle: std::mem::ManuallyDrop::new(control_handle),
6891 tx_id: header.tx_id,
6892 },
6893 })
6894 }
6895 0x1fd74ee8b9a4a876 => {
6896 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6897 let mut req = fidl::new_empty!(
6898 fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressRequest,
6899 fidl::encoding::DefaultFuchsiaResourceDialect
6900 );
6901 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
6902 let control_handle = SocketControlHandle { inner: this.inner.clone() };
6903 Ok(SocketRequest::SetReuseAddress {
6904 value: req.value,
6905
6906 responder: SocketSetReuseAddressResponder {
6907 control_handle: std::mem::ManuallyDrop::new(control_handle),
6908 tx_id: header.tx_id,
6909 },
6910 })
6911 }
6912 0x67b7206b8d1bc0a5 => {
6913 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6914 let mut req = fidl::new_empty!(
6915 fidl::encoding::EmptyPayload,
6916 fidl::encoding::DefaultFuchsiaResourceDialect
6917 );
6918 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6919 let control_handle = SocketControlHandle { inner: this.inner.clone() };
6920 Ok(SocketRequest::GetReuseAddress {
6921 responder: SocketGetReuseAddressResponder {
6922 control_handle: std::mem::ManuallyDrop::new(control_handle),
6923 tx_id: header.tx_id,
6924 },
6925 })
6926 }
6927 0x5aad39b33e5f6ebb => {
6928 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6929 let mut req = fidl::new_empty!(
6930 fidl::encoding::EmptyPayload,
6931 fidl::encoding::DefaultFuchsiaResourceDialect
6932 );
6933 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6934 let control_handle = SocketControlHandle { inner: this.inner.clone() };
6935 Ok(SocketRequest::GetError {
6936 responder: SocketGetErrorResponder {
6937 control_handle: std::mem::ManuallyDrop::new(control_handle),
6938 tx_id: header.tx_id,
6939 },
6940 })
6941 }
6942 0x6023e081ce3cd947 => {
6943 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6944 let mut req = fidl::new_empty!(
6945 fidl_fuchsia_posix_socket::BaseSocketSetBroadcastRequest,
6946 fidl::encoding::DefaultFuchsiaResourceDialect
6947 );
6948 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
6949 let control_handle = SocketControlHandle { inner: this.inner.clone() };
6950 Ok(SocketRequest::SetBroadcast {
6951 value: req.value,
6952
6953 responder: SocketSetBroadcastResponder {
6954 control_handle: std::mem::ManuallyDrop::new(control_handle),
6955 tx_id: header.tx_id,
6956 },
6957 })
6958 }
6959 0x68796fc556f9780d => {
6960 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6961 let mut req = fidl::new_empty!(
6962 fidl::encoding::EmptyPayload,
6963 fidl::encoding::DefaultFuchsiaResourceDialect
6964 );
6965 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6966 let control_handle = SocketControlHandle { inner: this.inner.clone() };
6967 Ok(SocketRequest::GetBroadcast {
6968 responder: SocketGetBroadcastResponder {
6969 control_handle: std::mem::ManuallyDrop::new(control_handle),
6970 tx_id: header.tx_id,
6971 },
6972 })
6973 }
6974 0x756eac32d73a7a70 => {
6975 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6976 let mut req = fidl::new_empty!(
6977 fidl_fuchsia_posix_socket::BaseSocketSetSendBufferRequest,
6978 fidl::encoding::DefaultFuchsiaResourceDialect
6979 );
6980 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
6981 let control_handle = SocketControlHandle { inner: this.inner.clone() };
6982 Ok(SocketRequest::SetSendBuffer {
6983 value_bytes: req.value_bytes,
6984
6985 responder: SocketSetSendBufferResponder {
6986 control_handle: std::mem::ManuallyDrop::new(control_handle),
6987 tx_id: header.tx_id,
6988 },
6989 })
6990 }
6991 0x78a52fd9c7b2410b => {
6992 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6993 let mut req = fidl::new_empty!(
6994 fidl::encoding::EmptyPayload,
6995 fidl::encoding::DefaultFuchsiaResourceDialect
6996 );
6997 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6998 let control_handle = SocketControlHandle { inner: this.inner.clone() };
6999 Ok(SocketRequest::GetSendBuffer {
7000 responder: SocketGetSendBufferResponder {
7001 control_handle: std::mem::ManuallyDrop::new(control_handle),
7002 tx_id: header.tx_id,
7003 },
7004 })
7005 }
7006 0x6b0cf2f1919c7001 => {
7007 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7008 let mut req = fidl::new_empty!(
7009 fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferRequest,
7010 fidl::encoding::DefaultFuchsiaResourceDialect
7011 );
7012 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
7013 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7014 Ok(SocketRequest::SetReceiveBuffer {
7015 value_bytes: req.value_bytes,
7016
7017 responder: SocketSetReceiveBufferResponder {
7018 control_handle: std::mem::ManuallyDrop::new(control_handle),
7019 tx_id: header.tx_id,
7020 },
7021 })
7022 }
7023 0x14c1a4b64f709e5c => {
7024 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7025 let mut req = fidl::new_empty!(
7026 fidl::encoding::EmptyPayload,
7027 fidl::encoding::DefaultFuchsiaResourceDialect
7028 );
7029 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7030 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7031 Ok(SocketRequest::GetReceiveBuffer {
7032 responder: SocketGetReceiveBufferResponder {
7033 control_handle: std::mem::ManuallyDrop::new(control_handle),
7034 tx_id: header.tx_id,
7035 },
7036 })
7037 }
7038 0x572df8f0b920d2c7 => {
7039 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7040 let mut req = fidl::new_empty!(
7041 fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveRequest,
7042 fidl::encoding::DefaultFuchsiaResourceDialect
7043 );
7044 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
7045 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7046 Ok(SocketRequest::SetKeepAlive {
7047 value: req.value,
7048
7049 responder: SocketSetKeepAliveResponder {
7050 control_handle: std::mem::ManuallyDrop::new(control_handle),
7051 tx_id: header.tx_id,
7052 },
7053 })
7054 }
7055 0x2dd29d3215f2c9d2 => {
7056 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7057 let mut req = fidl::new_empty!(
7058 fidl::encoding::EmptyPayload,
7059 fidl::encoding::DefaultFuchsiaResourceDialect
7060 );
7061 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7062 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7063 Ok(SocketRequest::GetKeepAlive {
7064 responder: SocketGetKeepAliveResponder {
7065 control_handle: std::mem::ManuallyDrop::new(control_handle),
7066 tx_id: header.tx_id,
7067 },
7068 })
7069 }
7070 0x3ecb49968bee439 => {
7071 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7072 let mut req = fidl::new_empty!(
7073 fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineRequest,
7074 fidl::encoding::DefaultFuchsiaResourceDialect
7075 );
7076 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
7077 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7078 Ok(SocketRequest::SetOutOfBandInline {
7079 value: req.value,
7080
7081 responder: SocketSetOutOfBandInlineResponder {
7082 control_handle: std::mem::ManuallyDrop::new(control_handle),
7083 tx_id: header.tx_id,
7084 },
7085 })
7086 }
7087 0x348c1ab3aeca1745 => {
7088 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7089 let mut req = fidl::new_empty!(
7090 fidl::encoding::EmptyPayload,
7091 fidl::encoding::DefaultFuchsiaResourceDialect
7092 );
7093 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7094 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7095 Ok(SocketRequest::GetOutOfBandInline {
7096 responder: SocketGetOutOfBandInlineResponder {
7097 control_handle: std::mem::ManuallyDrop::new(control_handle),
7098 tx_id: header.tx_id,
7099 },
7100 })
7101 }
7102 0x6bbf00c53a4c78c2 => {
7103 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7104 let mut req = fidl::new_empty!(
7105 fidl_fuchsia_posix_socket::BaseSocketSetNoCheckRequest,
7106 fidl::encoding::DefaultFuchsiaResourceDialect
7107 );
7108 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
7109 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7110 Ok(SocketRequest::SetNoCheck {
7111 value: req.value,
7112
7113 responder: SocketSetNoCheckResponder {
7114 control_handle: std::mem::ManuallyDrop::new(control_handle),
7115 tx_id: header.tx_id,
7116 },
7117 })
7118 }
7119 0x2cd4249286417694 => {
7120 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7121 let mut req = fidl::new_empty!(
7122 fidl::encoding::EmptyPayload,
7123 fidl::encoding::DefaultFuchsiaResourceDialect
7124 );
7125 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7126 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7127 Ok(SocketRequest::GetNoCheck {
7128 responder: SocketGetNoCheckResponder {
7129 control_handle: std::mem::ManuallyDrop::new(control_handle),
7130 tx_id: header.tx_id,
7131 },
7132 })
7133 }
7134 0x45386351246e998e => {
7135 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7136 let mut req = fidl::new_empty!(
7137 fidl_fuchsia_posix_socket::BaseSocketSetLingerRequest,
7138 fidl::encoding::DefaultFuchsiaResourceDialect
7139 );
7140 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
7141 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7142 Ok(SocketRequest::SetLinger {
7143 linger: req.linger,
7144 length_secs: req.length_secs,
7145
7146 responder: SocketSetLingerResponder {
7147 control_handle: std::mem::ManuallyDrop::new(control_handle),
7148 tx_id: header.tx_id,
7149 },
7150 })
7151 }
7152 0x48eb20fc5ccb0e45 => {
7153 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7154 let mut req = fidl::new_empty!(
7155 fidl::encoding::EmptyPayload,
7156 fidl::encoding::DefaultFuchsiaResourceDialect
7157 );
7158 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7159 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7160 Ok(SocketRequest::GetLinger {
7161 responder: SocketGetLingerResponder {
7162 control_handle: std::mem::ManuallyDrop::new(control_handle),
7163 tx_id: header.tx_id,
7164 },
7165 })
7166 }
7167 0x24dd3e5cb36d9ccb => {
7168 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7169 let mut req = fidl::new_empty!(
7170 fidl_fuchsia_posix_socket::BaseSocketSetReusePortRequest,
7171 fidl::encoding::DefaultFuchsiaResourceDialect
7172 );
7173 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
7174 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7175 Ok(SocketRequest::SetReusePort {
7176 value: req.value,
7177
7178 responder: SocketSetReusePortResponder {
7179 control_handle: std::mem::ManuallyDrop::new(control_handle),
7180 tx_id: header.tx_id,
7181 },
7182 })
7183 }
7184 0x7a112c1ab54ff828 => {
7185 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7186 let mut req = fidl::new_empty!(
7187 fidl::encoding::EmptyPayload,
7188 fidl::encoding::DefaultFuchsiaResourceDialect
7189 );
7190 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7191 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7192 Ok(SocketRequest::GetReusePort {
7193 responder: SocketGetReusePortResponder {
7194 control_handle: std::mem::ManuallyDrop::new(control_handle),
7195 tx_id: header.tx_id,
7196 },
7197 })
7198 }
7199 0x67ce6db6c2ec8966 => {
7200 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7201 let mut req = fidl::new_empty!(
7202 fidl::encoding::EmptyPayload,
7203 fidl::encoding::DefaultFuchsiaResourceDialect
7204 );
7205 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7206 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7207 Ok(SocketRequest::GetAcceptConn {
7208 responder: SocketGetAcceptConnResponder {
7209 control_handle: std::mem::ManuallyDrop::new(control_handle),
7210 tx_id: header.tx_id,
7211 },
7212 })
7213 }
7214 0x2118b483f28aafc4 => {
7215 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7216 let mut req = fidl::new_empty!(
7217 fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceRequest,
7218 fidl::encoding::DefaultFuchsiaResourceDialect
7219 );
7220 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
7221 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7222 Ok(SocketRequest::SetBindToDevice {
7223 value: req.value,
7224
7225 responder: SocketSetBindToDeviceResponder {
7226 control_handle: std::mem::ManuallyDrop::new(control_handle),
7227 tx_id: header.tx_id,
7228 },
7229 })
7230 }
7231 0x1ab1fbf0ef7906c8 => {
7232 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7233 let mut req = fidl::new_empty!(
7234 fidl::encoding::EmptyPayload,
7235 fidl::encoding::DefaultFuchsiaResourceDialect
7236 );
7237 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7238 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7239 Ok(SocketRequest::GetBindToDevice {
7240 responder: SocketGetBindToDeviceResponder {
7241 control_handle: std::mem::ManuallyDrop::new(control_handle),
7242 tx_id: header.tx_id,
7243 },
7244 })
7245 }
7246 0x6e387a0def00821 => {
7247 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7248 let mut req = fidl::new_empty!(
7249 fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexRequest,
7250 fidl::encoding::DefaultFuchsiaResourceDialect
7251 );
7252 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
7253 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7254 Ok(SocketRequest::SetBindToInterfaceIndex {
7255 value: req.value,
7256
7257 responder: SocketSetBindToInterfaceIndexResponder {
7258 control_handle: std::mem::ManuallyDrop::new(control_handle),
7259 tx_id: header.tx_id,
7260 },
7261 })
7262 }
7263 0x59c31dd3e3078295 => {
7264 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7265 let mut req = fidl::new_empty!(
7266 fidl::encoding::EmptyPayload,
7267 fidl::encoding::DefaultFuchsiaResourceDialect
7268 );
7269 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7270 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7271 Ok(SocketRequest::GetBindToInterfaceIndex {
7272 responder: SocketGetBindToInterfaceIndexResponder {
7273 control_handle: std::mem::ManuallyDrop::new(control_handle),
7274 tx_id: header.tx_id,
7275 },
7276 })
7277 }
7278 0x285d6516c263d839 => {
7279 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7280 let mut req = fidl::new_empty!(
7281 fidl_fuchsia_posix_socket::BaseSocketSetTimestampRequest,
7282 fidl::encoding::DefaultFuchsiaResourceDialect
7283 );
7284 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
7285 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7286 Ok(SocketRequest::SetTimestamp {
7287 value: req.value,
7288
7289 responder: SocketSetTimestampResponder {
7290 control_handle: std::mem::ManuallyDrop::new(control_handle),
7291 tx_id: header.tx_id,
7292 },
7293 })
7294 }
7295 0x49f2fffbbcc2bd27 => {
7296 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7297 let mut req = fidl::new_empty!(
7298 fidl::encoding::EmptyPayload,
7299 fidl::encoding::DefaultFuchsiaResourceDialect
7300 );
7301 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7302 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7303 Ok(SocketRequest::GetTimestamp {
7304 responder: SocketGetTimestampResponder {
7305 control_handle: std::mem::ManuallyDrop::new(control_handle),
7306 tx_id: header.tx_id,
7307 },
7308 })
7309 }
7310 0x6ead6de09f653236 => {
7311 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7312 let mut req = fidl::new_empty!(
7313 fidl_fuchsia_posix_socket::BaseSocketSetMarkRequest,
7314 fidl::encoding::DefaultFuchsiaResourceDialect
7315 );
7316 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
7317 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7318 Ok(SocketRequest::SetMark {
7319 domain: req.domain,
7320 mark: req.mark,
7321
7322 responder: SocketSetMarkResponder {
7323 control_handle: std::mem::ManuallyDrop::new(control_handle),
7324 tx_id: header.tx_id,
7325 },
7326 })
7327 }
7328 0x57a2752c61d93d47 => {
7329 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7330 let mut req = fidl::new_empty!(
7331 fidl_fuchsia_posix_socket::BaseSocketGetMarkRequest,
7332 fidl::encoding::DefaultFuchsiaResourceDialect
7333 );
7334 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
7335 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7336 Ok(SocketRequest::GetMark {
7337 domain: req.domain,
7338
7339 responder: SocketGetMarkResponder {
7340 control_handle: std::mem::ManuallyDrop::new(control_handle),
7341 tx_id: header.tx_id,
7342 },
7343 })
7344 }
7345 0x2c2f47fd8f924e52 => {
7346 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7347 let mut req = fidl::new_empty!(
7348 fidl::encoding::EmptyPayload,
7349 fidl::encoding::DefaultFuchsiaResourceDialect
7350 );
7351 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7352 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7353 Ok(SocketRequest::GetCookie {
7354 responder: SocketGetCookieResponder {
7355 control_handle: std::mem::ManuallyDrop::new(control_handle),
7356 tx_id: header.tx_id,
7357 },
7358 })
7359 }
7360 0x4bc6400ae92125d => {
7361 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7362 let mut req = fidl::new_empty!(
7363 fidl_fuchsia_posix_socket::BaseNetworkSocketBindRequest,
7364 fidl::encoding::DefaultFuchsiaResourceDialect
7365 );
7366 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
7367 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7368 Ok(SocketRequest::Bind {
7369 addr: req.addr,
7370
7371 responder: SocketBindResponder {
7372 control_handle: std::mem::ManuallyDrop::new(control_handle),
7373 tx_id: header.tx_id,
7374 },
7375 })
7376 }
7377 0x5f05f19bfdd38871 => {
7378 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7379 let mut req = fidl::new_empty!(
7380 fidl_fuchsia_posix_socket::BaseNetworkSocketConnectRequest,
7381 fidl::encoding::DefaultFuchsiaResourceDialect
7382 );
7383 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
7384 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7385 Ok(SocketRequest::Connect {
7386 addr: req.addr,
7387
7388 responder: SocketConnectResponder {
7389 control_handle: std::mem::ManuallyDrop::new(control_handle),
7390 tx_id: header.tx_id,
7391 },
7392 })
7393 }
7394 0x74e63b91f7b29b2 => {
7395 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7396 let mut req = fidl::new_empty!(
7397 fidl::encoding::EmptyPayload,
7398 fidl::encoding::DefaultFuchsiaResourceDialect
7399 );
7400 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7401 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7402 Ok(SocketRequest::Disconnect {
7403 responder: SocketDisconnectResponder {
7404 control_handle: std::mem::ManuallyDrop::new(control_handle),
7405 tx_id: header.tx_id,
7406 },
7407 })
7408 }
7409 0x475f23f84a1a4f85 => {
7410 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7411 let mut req = fidl::new_empty!(
7412 fidl::encoding::EmptyPayload,
7413 fidl::encoding::DefaultFuchsiaResourceDialect
7414 );
7415 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7416 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7417 Ok(SocketRequest::GetSockName {
7418 responder: SocketGetSockNameResponder {
7419 control_handle: std::mem::ManuallyDrop::new(control_handle),
7420 tx_id: header.tx_id,
7421 },
7422 })
7423 }
7424 0x1ffecf4bd5b6432e => {
7425 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7426 let mut req = fidl::new_empty!(
7427 fidl::encoding::EmptyPayload,
7428 fidl::encoding::DefaultFuchsiaResourceDialect
7429 );
7430 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7431 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7432 Ok(SocketRequest::GetPeerName {
7433 responder: SocketGetPeerNameResponder {
7434 control_handle: std::mem::ManuallyDrop::new(control_handle),
7435 tx_id: header.tx_id,
7436 },
7437 })
7438 }
7439 0x247f38b6db68c336 => {
7440 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7441 let mut req = fidl::new_empty!(
7442 fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownRequest,
7443 fidl::encoding::DefaultFuchsiaResourceDialect
7444 );
7445 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownRequest>(&header, _body_bytes, handles, &mut req)?;
7446 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7447 Ok(SocketRequest::Shutdown {
7448 mode: req.mode,
7449
7450 responder: SocketShutdownResponder {
7451 control_handle: std::mem::ManuallyDrop::new(control_handle),
7452 tx_id: header.tx_id,
7453 },
7454 })
7455 }
7456 0x995c600475b6d46 => {
7457 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7458 let mut req = fidl::new_empty!(
7459 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceRequest,
7460 fidl::encoding::DefaultFuchsiaResourceDialect
7461 );
7462 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
7463 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7464 Ok(SocketRequest::SetIpTypeOfService {
7465 value: req.value,
7466
7467 responder: SocketSetIpTypeOfServiceResponder {
7468 control_handle: std::mem::ManuallyDrop::new(control_handle),
7469 tx_id: header.tx_id,
7470 },
7471 })
7472 }
7473 0x3814a04259f75fcb => {
7474 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7475 let mut req = fidl::new_empty!(
7476 fidl::encoding::EmptyPayload,
7477 fidl::encoding::DefaultFuchsiaResourceDialect
7478 );
7479 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7480 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7481 Ok(SocketRequest::GetIpTypeOfService {
7482 responder: SocketGetIpTypeOfServiceResponder {
7483 control_handle: std::mem::ManuallyDrop::new(control_handle),
7484 tx_id: header.tx_id,
7485 },
7486 })
7487 }
7488 0x29e2424b433ae1ef => {
7489 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7490 let mut req = fidl::new_empty!(
7491 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlRequest,
7492 fidl::encoding::DefaultFuchsiaResourceDialect
7493 );
7494 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlRequest>(&header, _body_bytes, handles, &mut req)?;
7495 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7496 Ok(SocketRequest::SetIpTtl {
7497 value: req.value,
7498
7499 responder: SocketSetIpTtlResponder {
7500 control_handle: std::mem::ManuallyDrop::new(control_handle),
7501 tx_id: header.tx_id,
7502 },
7503 })
7504 }
7505 0x47e47fa1f24da471 => {
7506 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7507 let mut req = fidl::new_empty!(
7508 fidl::encoding::EmptyPayload,
7509 fidl::encoding::DefaultFuchsiaResourceDialect
7510 );
7511 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7512 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7513 Ok(SocketRequest::GetIpTtl {
7514 responder: SocketGetIpTtlResponder {
7515 control_handle: std::mem::ManuallyDrop::new(control_handle),
7516 tx_id: header.tx_id,
7517 },
7518 })
7519 }
7520 0x392d16bee20c0e16 => {
7521 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7522 let mut req = fidl::new_empty!(
7523 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoRequest,
7524 fidl::encoding::DefaultFuchsiaResourceDialect
7525 );
7526 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
7527 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7528 Ok(SocketRequest::SetIpPacketInfo {
7529 value: req.value,
7530
7531 responder: SocketSetIpPacketInfoResponder {
7532 control_handle: std::mem::ManuallyDrop::new(control_handle),
7533 tx_id: header.tx_id,
7534 },
7535 })
7536 }
7537 0x54b505f242280740 => {
7538 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7539 let mut req = fidl::new_empty!(
7540 fidl::encoding::EmptyPayload,
7541 fidl::encoding::DefaultFuchsiaResourceDialect
7542 );
7543 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7544 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7545 Ok(SocketRequest::GetIpPacketInfo {
7546 responder: SocketGetIpPacketInfoResponder {
7547 control_handle: std::mem::ManuallyDrop::new(control_handle),
7548 tx_id: header.tx_id,
7549 },
7550 })
7551 }
7552 0x6c4f6714995f84ef => {
7553 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7554 let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
7555 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
7556 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7557 Ok(SocketRequest::SetIpReceiveTypeOfService {
7558 value: req.value,
7559
7560 responder: SocketSetIpReceiveTypeOfServiceResponder {
7561 control_handle: std::mem::ManuallyDrop::new(control_handle),
7562 tx_id: header.tx_id,
7563 },
7564 })
7565 }
7566 0x4158ba7dc2795960 => {
7567 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7568 let mut req = fidl::new_empty!(
7569 fidl::encoding::EmptyPayload,
7570 fidl::encoding::DefaultFuchsiaResourceDialect
7571 );
7572 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7573 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7574 Ok(SocketRequest::GetIpReceiveTypeOfService {
7575 responder: SocketGetIpReceiveTypeOfServiceResponder {
7576 control_handle: std::mem::ManuallyDrop::new(control_handle),
7577 tx_id: header.tx_id,
7578 },
7579 })
7580 }
7581 0x46f15be0ce0ab82b => {
7582 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7583 let mut req = fidl::new_empty!(
7584 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlRequest,
7585 fidl::encoding::DefaultFuchsiaResourceDialect
7586 );
7587 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlRequest>(&header, _body_bytes, handles, &mut req)?;
7588 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7589 Ok(SocketRequest::SetIpReceiveTtl {
7590 value: req.value,
7591
7592 responder: SocketSetIpReceiveTtlResponder {
7593 control_handle: std::mem::ManuallyDrop::new(control_handle),
7594 tx_id: header.tx_id,
7595 },
7596 })
7597 }
7598 0x678ddd5a5dfa2eb5 => {
7599 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7600 let mut req = fidl::new_empty!(
7601 fidl::encoding::EmptyPayload,
7602 fidl::encoding::DefaultFuchsiaResourceDialect
7603 );
7604 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7605 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7606 Ok(SocketRequest::GetIpReceiveTtl {
7607 responder: SocketGetIpReceiveTtlResponder {
7608 control_handle: std::mem::ManuallyDrop::new(control_handle),
7609 tx_id: header.tx_id,
7610 },
7611 })
7612 }
7613 0x752fbfa9b12befe => {
7614 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7615 let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
7616 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
7617 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7618 Ok(SocketRequest::SetIpMulticastInterface {
7619 iface: req.iface,
7620 address: req.address,
7621
7622 responder: SocketSetIpMulticastInterfaceResponder {
7623 control_handle: std::mem::ManuallyDrop::new(control_handle),
7624 tx_id: header.tx_id,
7625 },
7626 })
7627 }
7628 0x320bd14c4df046c4 => {
7629 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7630 let mut req = fidl::new_empty!(
7631 fidl::encoding::EmptyPayload,
7632 fidl::encoding::DefaultFuchsiaResourceDialect
7633 );
7634 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7635 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7636 Ok(SocketRequest::GetIpMulticastInterface {
7637 responder: SocketGetIpMulticastInterfaceResponder {
7638 control_handle: std::mem::ManuallyDrop::new(control_handle),
7639 tx_id: header.tx_id,
7640 },
7641 })
7642 }
7643 0x63134d53772916a1 => {
7644 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7645 let mut req = fidl::new_empty!(
7646 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlRequest,
7647 fidl::encoding::DefaultFuchsiaResourceDialect
7648 );
7649 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlRequest>(&header, _body_bytes, handles, &mut req)?;
7650 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7651 Ok(SocketRequest::SetIpMulticastTtl {
7652 value: req.value,
7653
7654 responder: SocketSetIpMulticastTtlResponder {
7655 control_handle: std::mem::ManuallyDrop::new(control_handle),
7656 tx_id: header.tx_id,
7657 },
7658 })
7659 }
7660 0x4665cd378f39e1a => {
7661 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7662 let mut req = fidl::new_empty!(
7663 fidl::encoding::EmptyPayload,
7664 fidl::encoding::DefaultFuchsiaResourceDialect
7665 );
7666 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7667 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7668 Ok(SocketRequest::GetIpMulticastTtl {
7669 responder: SocketGetIpMulticastTtlResponder {
7670 control_handle: std::mem::ManuallyDrop::new(control_handle),
7671 tx_id: header.tx_id,
7672 },
7673 })
7674 }
7675 0x20c55c11f00943ea => {
7676 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7677 let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
7678 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
7679 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7680 Ok(SocketRequest::SetIpMulticastLoopback {
7681 value: req.value,
7682
7683 responder: SocketSetIpMulticastLoopbackResponder {
7684 control_handle: std::mem::ManuallyDrop::new(control_handle),
7685 tx_id: header.tx_id,
7686 },
7687 })
7688 }
7689 0x3b6b26ff558298f2 => {
7690 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7691 let mut req = fidl::new_empty!(
7692 fidl::encoding::EmptyPayload,
7693 fidl::encoding::DefaultFuchsiaResourceDialect
7694 );
7695 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7696 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7697 Ok(SocketRequest::GetIpMulticastLoopback {
7698 responder: SocketGetIpMulticastLoopbackResponder {
7699 control_handle: std::mem::ManuallyDrop::new(control_handle),
7700 tx_id: header.tx_id,
7701 },
7702 })
7703 }
7704 0x76bc7df115a3b4d0 => {
7705 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7706 let mut req = fidl::new_empty!(
7707 fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipRequest,
7708 fidl::encoding::DefaultFuchsiaResourceDialect
7709 );
7710 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
7711 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7712 Ok(SocketRequest::AddIpMembership {
7713 membership: req.membership,
7714
7715 responder: SocketAddIpMembershipResponder {
7716 control_handle: std::mem::ManuallyDrop::new(control_handle),
7717 tx_id: header.tx_id,
7718 },
7719 })
7720 }
7721 0x2888f3099188d03 => {
7722 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7723 let mut req = fidl::new_empty!(
7724 fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipRequest,
7725 fidl::encoding::DefaultFuchsiaResourceDialect
7726 );
7727 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
7728 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7729 Ok(SocketRequest::DropIpMembership {
7730 membership: req.membership,
7731
7732 responder: SocketDropIpMembershipResponder {
7733 control_handle: std::mem::ManuallyDrop::new(control_handle),
7734 tx_id: header.tx_id,
7735 },
7736 })
7737 }
7738 0x1ae532b0c066e3a0 => {
7739 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7740 let mut req = fidl::new_empty!(
7741 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentRequest,
7742 fidl::encoding::DefaultFuchsiaResourceDialect
7743 );
7744 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentRequest>(&header, _body_bytes, handles, &mut req)?;
7745 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7746 Ok(SocketRequest::SetIpTransparent {
7747 value: req.value,
7748
7749 responder: SocketSetIpTransparentResponder {
7750 control_handle: std::mem::ManuallyDrop::new(control_handle),
7751 tx_id: header.tx_id,
7752 },
7753 })
7754 }
7755 0x51d43695962ebfb5 => {
7756 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7757 let mut req = fidl::new_empty!(
7758 fidl::encoding::EmptyPayload,
7759 fidl::encoding::DefaultFuchsiaResourceDialect
7760 );
7761 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7762 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7763 Ok(SocketRequest::GetIpTransparent {
7764 responder: SocketGetIpTransparentResponder {
7765 control_handle: std::mem::ManuallyDrop::new(control_handle),
7766 tx_id: header.tx_id,
7767 },
7768 })
7769 }
7770 0x4722b4ce52f7840 => {
7771 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7772 let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
7773 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest>(&header, _body_bytes, handles, &mut req)?;
7774 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7775 Ok(SocketRequest::SetIpReceiveOriginalDestinationAddress {
7776 value: req.value,
7777
7778 responder: SocketSetIpReceiveOriginalDestinationAddressResponder {
7779 control_handle: std::mem::ManuallyDrop::new(control_handle),
7780 tx_id: header.tx_id,
7781 },
7782 })
7783 }
7784 0x2a0e7dc5d6bfdfe9 => {
7785 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7786 let mut req = fidl::new_empty!(
7787 fidl::encoding::EmptyPayload,
7788 fidl::encoding::DefaultFuchsiaResourceDialect
7789 );
7790 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7791 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7792 Ok(SocketRequest::GetIpReceiveOriginalDestinationAddress {
7793 responder: SocketGetIpReceiveOriginalDestinationAddressResponder {
7794 control_handle: std::mem::ManuallyDrop::new(control_handle),
7795 tx_id: header.tx_id,
7796 },
7797 })
7798 }
7799 0x7c94727acb4ea4b3 => {
7800 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7801 let mut req = fidl::new_empty!(
7802 fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipRequest,
7803 fidl::encoding::DefaultFuchsiaResourceDialect
7804 );
7805 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
7806 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7807 Ok(SocketRequest::AddIpv6Membership {
7808 membership: req.membership,
7809
7810 responder: SocketAddIpv6MembershipResponder {
7811 control_handle: std::mem::ManuallyDrop::new(control_handle),
7812 tx_id: header.tx_id,
7813 },
7814 })
7815 }
7816 0x42104c70ccaba304 => {
7817 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7818 let mut req = fidl::new_empty!(
7819 fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipRequest,
7820 fidl::encoding::DefaultFuchsiaResourceDialect
7821 );
7822 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
7823 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7824 Ok(SocketRequest::DropIpv6Membership {
7825 membership: req.membership,
7826
7827 responder: SocketDropIpv6MembershipResponder {
7828 control_handle: std::mem::ManuallyDrop::new(control_handle),
7829 tx_id: header.tx_id,
7830 },
7831 })
7832 }
7833 0x135f76db3774ab3b => {
7834 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7835 let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
7836 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
7837 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7838 Ok(SocketRequest::SetIpv6MulticastInterface {
7839 value: req.value,
7840
7841 responder: SocketSetIpv6MulticastInterfaceResponder {
7842 control_handle: std::mem::ManuallyDrop::new(control_handle),
7843 tx_id: header.tx_id,
7844 },
7845 })
7846 }
7847 0x1f26fcdd348f1882 => {
7848 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7849 let mut req = fidl::new_empty!(
7850 fidl::encoding::EmptyPayload,
7851 fidl::encoding::DefaultFuchsiaResourceDialect
7852 );
7853 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7854 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7855 Ok(SocketRequest::GetIpv6MulticastInterface {
7856 responder: SocketGetIpv6MulticastInterfaceResponder {
7857 control_handle: std::mem::ManuallyDrop::new(control_handle),
7858 tx_id: header.tx_id,
7859 },
7860 })
7861 }
7862 0x157d51e98f462859 => {
7863 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7864 let mut req = fidl::new_empty!(
7865 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsRequest,
7866 fidl::encoding::DefaultFuchsiaResourceDialect
7867 );
7868 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
7869 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7870 Ok(SocketRequest::SetIpv6UnicastHops {
7871 value: req.value,
7872
7873 responder: SocketSetIpv6UnicastHopsResponder {
7874 control_handle: std::mem::ManuallyDrop::new(control_handle),
7875 tx_id: header.tx_id,
7876 },
7877 })
7878 }
7879 0x21f4641cad8bd8d2 => {
7880 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7881 let mut req = fidl::new_empty!(
7882 fidl::encoding::EmptyPayload,
7883 fidl::encoding::DefaultFuchsiaResourceDialect
7884 );
7885 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7886 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7887 Ok(SocketRequest::GetIpv6UnicastHops {
7888 responder: SocketGetIpv6UnicastHopsResponder {
7889 control_handle: std::mem::ManuallyDrop::new(control_handle),
7890 tx_id: header.tx_id,
7891 },
7892 })
7893 }
7894 0x5c24808ed2e84a1e => {
7895 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7896 let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
7897 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitRequest>(&header, _body_bytes, handles, &mut req)?;
7898 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7899 Ok(SocketRequest::SetIpv6ReceiveHopLimit {
7900 value: req.value,
7901
7902 responder: SocketSetIpv6ReceiveHopLimitResponder {
7903 control_handle: std::mem::ManuallyDrop::new(control_handle),
7904 tx_id: header.tx_id,
7905 },
7906 })
7907 }
7908 0x341e06689885b4c0 => {
7909 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7910 let mut req = fidl::new_empty!(
7911 fidl::encoding::EmptyPayload,
7912 fidl::encoding::DefaultFuchsiaResourceDialect
7913 );
7914 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7915 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7916 Ok(SocketRequest::GetIpv6ReceiveHopLimit {
7917 responder: SocketGetIpv6ReceiveHopLimitResponder {
7918 control_handle: std::mem::ManuallyDrop::new(control_handle),
7919 tx_id: header.tx_id,
7920 },
7921 })
7922 }
7923 0x25b9cd4d181f82c1 => {
7924 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7925 let mut req = fidl::new_empty!(
7926 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsRequest,
7927 fidl::encoding::DefaultFuchsiaResourceDialect
7928 );
7929 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
7930 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7931 Ok(SocketRequest::SetIpv6MulticastHops {
7932 value: req.value,
7933
7934 responder: SocketSetIpv6MulticastHopsResponder {
7935 control_handle: std::mem::ManuallyDrop::new(control_handle),
7936 tx_id: header.tx_id,
7937 },
7938 })
7939 }
7940 0x52916948a365012a => {
7941 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7942 let mut req = fidl::new_empty!(
7943 fidl::encoding::EmptyPayload,
7944 fidl::encoding::DefaultFuchsiaResourceDialect
7945 );
7946 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7947 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7948 Ok(SocketRequest::GetIpv6MulticastHops {
7949 responder: SocketGetIpv6MulticastHopsResponder {
7950 control_handle: std::mem::ManuallyDrop::new(control_handle),
7951 tx_id: header.tx_id,
7952 },
7953 })
7954 }
7955 0x55701c409ff41b40 => {
7956 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7957 let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
7958 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
7959 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7960 Ok(SocketRequest::SetIpv6MulticastLoopback {
7961 value: req.value,
7962
7963 responder: SocketSetIpv6MulticastLoopbackResponder {
7964 control_handle: std::mem::ManuallyDrop::new(control_handle),
7965 tx_id: header.tx_id,
7966 },
7967 })
7968 }
7969 0x4415b701fde319c3 => {
7970 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7971 let mut req = fidl::new_empty!(
7972 fidl::encoding::EmptyPayload,
7973 fidl::encoding::DefaultFuchsiaResourceDialect
7974 );
7975 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7976 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7977 Ok(SocketRequest::GetIpv6MulticastLoopback {
7978 responder: SocketGetIpv6MulticastLoopbackResponder {
7979 control_handle: std::mem::ManuallyDrop::new(control_handle),
7980 tx_id: header.tx_id,
7981 },
7982 })
7983 }
7984 0x4873f1364758cbba => {
7985 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7986 let mut req = fidl::new_empty!(
7987 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyRequest,
7988 fidl::encoding::DefaultFuchsiaResourceDialect
7989 );
7990 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyRequest>(&header, _body_bytes, handles, &mut req)?;
7991 let control_handle = SocketControlHandle { inner: this.inner.clone() };
7992 Ok(SocketRequest::SetIpv6Only {
7993 value: req.value,
7994
7995 responder: SocketSetIpv6OnlyResponder {
7996 control_handle: std::mem::ManuallyDrop::new(control_handle),
7997 tx_id: header.tx_id,
7998 },
7999 })
8000 }
8001 0x4aa3340a1a26b89c => {
8002 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8003 let mut req = fidl::new_empty!(
8004 fidl::encoding::EmptyPayload,
8005 fidl::encoding::DefaultFuchsiaResourceDialect
8006 );
8007 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8008 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8009 Ok(SocketRequest::GetIpv6Only {
8010 responder: SocketGetIpv6OnlyResponder {
8011 control_handle: std::mem::ManuallyDrop::new(control_handle),
8012 tx_id: header.tx_id,
8013 },
8014 })
8015 }
8016 0x58f07c8788d099a0 => {
8017 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8018 let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
8019 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
8020 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8021 Ok(SocketRequest::SetIpv6ReceiveTrafficClass {
8022 value: req.value,
8023
8024 responder: SocketSetIpv6ReceiveTrafficClassResponder {
8025 control_handle: std::mem::ManuallyDrop::new(control_handle),
8026 tx_id: header.tx_id,
8027 },
8028 })
8029 }
8030 0x2e334df1da553ffa => {
8031 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8032 let mut req = fidl::new_empty!(
8033 fidl::encoding::EmptyPayload,
8034 fidl::encoding::DefaultFuchsiaResourceDialect
8035 );
8036 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8037 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8038 Ok(SocketRequest::GetIpv6ReceiveTrafficClass {
8039 responder: SocketGetIpv6ReceiveTrafficClassResponder {
8040 control_handle: std::mem::ManuallyDrop::new(control_handle),
8041 tx_id: header.tx_id,
8042 },
8043 })
8044 }
8045 0x6af077800c5a0b4f => {
8046 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8047 let mut req = fidl::new_empty!(
8048 fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassRequest,
8049 fidl::encoding::DefaultFuchsiaResourceDialect
8050 );
8051 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
8052 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8053 Ok(SocketRequest::SetIpv6TrafficClass {
8054 value: req.value,
8055
8056 responder: SocketSetIpv6TrafficClassResponder {
8057 control_handle: std::mem::ManuallyDrop::new(control_handle),
8058 tx_id: header.tx_id,
8059 },
8060 })
8061 }
8062 0x6baf6eed8fc2f04 => {
8063 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8064 let mut req = fidl::new_empty!(
8065 fidl::encoding::EmptyPayload,
8066 fidl::encoding::DefaultFuchsiaResourceDialect
8067 );
8068 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8069 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8070 Ok(SocketRequest::GetIpv6TrafficClass {
8071 responder: SocketGetIpv6TrafficClassResponder {
8072 control_handle: std::mem::ManuallyDrop::new(control_handle),
8073 tx_id: header.tx_id,
8074 },
8075 })
8076 }
8077 0x19259775b1a92768 => {
8078 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8079 let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
8080 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
8081 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8082 Ok(SocketRequest::SetIpv6ReceivePacketInfo {
8083 value: req.value,
8084
8085 responder: SocketSetIpv6ReceivePacketInfoResponder {
8086 control_handle: std::mem::ManuallyDrop::new(control_handle),
8087 tx_id: header.tx_id,
8088 },
8089 })
8090 }
8091 0x7acd4a2775baec75 => {
8092 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8093 let mut req = fidl::new_empty!(
8094 fidl::encoding::EmptyPayload,
8095 fidl::encoding::DefaultFuchsiaResourceDialect
8096 );
8097 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8098 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8099 Ok(SocketRequest::GetIpv6ReceivePacketInfo {
8100 responder: SocketGetIpv6ReceivePacketInfoResponder {
8101 control_handle: std::mem::ManuallyDrop::new(control_handle),
8102 tx_id: header.tx_id,
8103 },
8104 })
8105 }
8106 0x38bf28f0dafdbac0 => {
8107 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8108 let mut req = fidl::new_empty!(
8109 fidl::encoding::EmptyPayload,
8110 fidl::encoding::DefaultFuchsiaResourceDialect
8111 );
8112 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8113 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8114 Ok(SocketRequest::GetOriginalDestination {
8115 responder: SocketGetOriginalDestinationResponder {
8116 control_handle: std::mem::ManuallyDrop::new(control_handle),
8117 tx_id: header.tx_id,
8118 },
8119 })
8120 }
8121 0x335706eccf54a135 => {
8122 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8123 let mut req = fidl::new_empty!(
8124 fidl::encoding::EmptyPayload,
8125 fidl::encoding::DefaultFuchsiaResourceDialect
8126 );
8127 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8128 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8129 Ok(SocketRequest::Describe {
8130 responder: SocketDescribeResponder {
8131 control_handle: std::mem::ManuallyDrop::new(control_handle),
8132 tx_id: header.tx_id,
8133 },
8134 })
8135 }
8136 0x1dfb695351d3aa1d => {
8137 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8138 let mut req = fidl::new_empty!(
8139 SocketRecvMsgRequest,
8140 fidl::encoding::DefaultFuchsiaResourceDialect
8141 );
8142 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketRecvMsgRequest>(&header, _body_bytes, handles, &mut req)?;
8143 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8144 Ok(SocketRequest::RecvMsg {
8145 want_addr: req.want_addr,
8146 data_len: req.data_len,
8147 want_control: req.want_control,
8148 flags: req.flags,
8149
8150 responder: SocketRecvMsgResponder {
8151 control_handle: std::mem::ManuallyDrop::new(control_handle),
8152 tx_id: header.tx_id,
8153 },
8154 })
8155 }
8156 0x2cf1eac9a7fc8958 => {
8157 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8158 let mut req = fidl::new_empty!(
8159 SocketSendMsgRequest,
8160 fidl::encoding::DefaultFuchsiaResourceDialect
8161 );
8162 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketSendMsgRequest>(&header, _body_bytes, handles, &mut req)?;
8163 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8164 Ok(SocketRequest::SendMsg {
8165 addr: req.addr,
8166 data: req.data,
8167 control: req.control,
8168 flags: req.flags,
8169
8170 responder: SocketSendMsgResponder {
8171 control_handle: std::mem::ManuallyDrop::new(control_handle),
8172 tx_id: header.tx_id,
8173 },
8174 })
8175 }
8176 0x39676f75aec339ba => {
8177 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8178 let mut req = fidl::new_empty!(
8179 fidl::encoding::EmptyPayload,
8180 fidl::encoding::DefaultFuchsiaResourceDialect
8181 );
8182 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8183 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8184 Ok(SocketRequest::GetInfo {
8185 responder: SocketGetInfoResponder {
8186 control_handle: std::mem::ManuallyDrop::new(control_handle),
8187 tx_id: header.tx_id,
8188 },
8189 })
8190 }
8191 0x5d06a606d95e8f3 => {
8192 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8193 let mut req = fidl::new_empty!(
8194 SocketSetIpHeaderIncludedRequest,
8195 fidl::encoding::DefaultFuchsiaResourceDialect
8196 );
8197 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketSetIpHeaderIncludedRequest>(&header, _body_bytes, handles, &mut req)?;
8198 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8199 Ok(SocketRequest::SetIpHeaderIncluded {
8200 value: req.value,
8201
8202 responder: SocketSetIpHeaderIncludedResponder {
8203 control_handle: std::mem::ManuallyDrop::new(control_handle),
8204 tx_id: header.tx_id,
8205 },
8206 })
8207 }
8208 0x76125ad1f4d175f6 => {
8209 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8210 let mut req = fidl::new_empty!(
8211 fidl::encoding::EmptyPayload,
8212 fidl::encoding::DefaultFuchsiaResourceDialect
8213 );
8214 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8215 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8216 Ok(SocketRequest::GetIpHeaderIncluded {
8217 responder: SocketGetIpHeaderIncludedResponder {
8218 control_handle: std::mem::ManuallyDrop::new(control_handle),
8219 tx_id: header.tx_id,
8220 },
8221 })
8222 }
8223 0x4ebea92a43ae68a9 => {
8224 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8225 let mut req = fidl::new_empty!(
8226 SocketSetIcmpv6FilterRequest,
8227 fidl::encoding::DefaultFuchsiaResourceDialect
8228 );
8229 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketSetIcmpv6FilterRequest>(&header, _body_bytes, handles, &mut req)?;
8230 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8231 Ok(SocketRequest::SetIcmpv6Filter {
8232 filter: req.filter,
8233
8234 responder: SocketSetIcmpv6FilterResponder {
8235 control_handle: std::mem::ManuallyDrop::new(control_handle),
8236 tx_id: header.tx_id,
8237 },
8238 })
8239 }
8240 0x43bd4f3bc0970ace => {
8241 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8242 let mut req = fidl::new_empty!(
8243 fidl::encoding::EmptyPayload,
8244 fidl::encoding::DefaultFuchsiaResourceDialect
8245 );
8246 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8247 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8248 Ok(SocketRequest::GetIcmpv6Filter {
8249 responder: SocketGetIcmpv6FilterResponder {
8250 control_handle: std::mem::ManuallyDrop::new(control_handle),
8251 tx_id: header.tx_id,
8252 },
8253 })
8254 }
8255 0x18b7809577199cb4 => {
8256 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8257 let mut req = fidl::new_empty!(
8258 SocketSetIpv6ChecksumRequest,
8259 fidl::encoding::DefaultFuchsiaResourceDialect
8260 );
8261 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketSetIpv6ChecksumRequest>(&header, _body_bytes, handles, &mut req)?;
8262 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8263 Ok(SocketRequest::SetIpv6Checksum {
8264 config: req.config,
8265
8266 responder: SocketSetIpv6ChecksumResponder {
8267 control_handle: std::mem::ManuallyDrop::new(control_handle),
8268 tx_id: header.tx_id,
8269 },
8270 })
8271 }
8272 0x1847bf5b2d263dd => {
8273 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8274 let mut req = fidl::new_empty!(
8275 fidl::encoding::EmptyPayload,
8276 fidl::encoding::DefaultFuchsiaResourceDialect
8277 );
8278 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8279 let control_handle = SocketControlHandle { inner: this.inner.clone() };
8280 Ok(SocketRequest::GetIpv6Checksum {
8281 responder: SocketGetIpv6ChecksumResponder {
8282 control_handle: std::mem::ManuallyDrop::new(control_handle),
8283 tx_id: header.tx_id,
8284 },
8285 })
8286 }
8287 _ => Err(fidl::Error::UnknownOrdinal {
8288 ordinal: header.ordinal,
8289 protocol_name:
8290 <SocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
8291 }),
8292 }))
8293 },
8294 )
8295 }
8296}
8297
8298#[derive(Debug)]
8312pub enum SocketRequest {
8313 Clone {
8314 request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
8315 control_handle: SocketControlHandle,
8316 },
8317 Close {
8328 responder: SocketCloseResponder,
8329 },
8330 Query {
8331 responder: SocketQueryResponder,
8332 },
8333 SetReuseAddress {
8335 value: bool,
8336 responder: SocketSetReuseAddressResponder,
8337 },
8338 GetReuseAddress {
8340 responder: SocketGetReuseAddressResponder,
8341 },
8342 GetError {
8345 responder: SocketGetErrorResponder,
8346 },
8347 SetBroadcast {
8349 value: bool,
8350 responder: SocketSetBroadcastResponder,
8351 },
8352 GetBroadcast {
8354 responder: SocketGetBroadcastResponder,
8355 },
8356 SetSendBuffer {
8358 value_bytes: u64,
8359 responder: SocketSetSendBufferResponder,
8360 },
8361 GetSendBuffer {
8363 responder: SocketGetSendBufferResponder,
8364 },
8365 SetReceiveBuffer {
8367 value_bytes: u64,
8368 responder: SocketSetReceiveBufferResponder,
8369 },
8370 GetReceiveBuffer {
8372 responder: SocketGetReceiveBufferResponder,
8373 },
8374 SetKeepAlive {
8376 value: bool,
8377 responder: SocketSetKeepAliveResponder,
8378 },
8379 GetKeepAlive {
8381 responder: SocketGetKeepAliveResponder,
8382 },
8383 SetOutOfBandInline {
8385 value: bool,
8386 responder: SocketSetOutOfBandInlineResponder,
8387 },
8388 GetOutOfBandInline {
8390 responder: SocketGetOutOfBandInlineResponder,
8391 },
8392 SetNoCheck {
8394 value: bool,
8395 responder: SocketSetNoCheckResponder,
8396 },
8397 GetNoCheck {
8399 responder: SocketGetNoCheckResponder,
8400 },
8401 SetLinger {
8403 linger: bool,
8404 length_secs: u32,
8405 responder: SocketSetLingerResponder,
8406 },
8407 GetLinger {
8409 responder: SocketGetLingerResponder,
8410 },
8411 SetReusePort {
8413 value: bool,
8414 responder: SocketSetReusePortResponder,
8415 },
8416 GetReusePort {
8418 responder: SocketGetReusePortResponder,
8419 },
8420 GetAcceptConn {
8422 responder: SocketGetAcceptConnResponder,
8423 },
8424 SetBindToDevice {
8426 value: String,
8427 responder: SocketSetBindToDeviceResponder,
8428 },
8429 GetBindToDevice {
8431 responder: SocketGetBindToDeviceResponder,
8432 },
8433 SetBindToInterfaceIndex {
8436 value: u64,
8437 responder: SocketSetBindToInterfaceIndexResponder,
8438 },
8439 GetBindToInterfaceIndex {
8441 responder: SocketGetBindToInterfaceIndexResponder,
8442 },
8443 SetTimestamp {
8445 value: fidl_fuchsia_posix_socket::TimestampOption,
8446 responder: SocketSetTimestampResponder,
8447 },
8448 GetTimestamp {
8450 responder: SocketGetTimestampResponder,
8451 },
8452 SetMark {
8456 domain: fidl_fuchsia_net::MarkDomain,
8457 mark: fidl_fuchsia_posix_socket::OptionalUint32,
8458 responder: SocketSetMarkResponder,
8459 },
8460 GetMark {
8464 domain: fidl_fuchsia_net::MarkDomain,
8465 responder: SocketGetMarkResponder,
8466 },
8467 GetCookie {
8469 responder: SocketGetCookieResponder,
8470 },
8471 Bind {
8473 addr: fidl_fuchsia_net::SocketAddress,
8474 responder: SocketBindResponder,
8475 },
8476 Connect {
8478 addr: fidl_fuchsia_net::SocketAddress,
8479 responder: SocketConnectResponder,
8480 },
8481 Disconnect {
8483 responder: SocketDisconnectResponder,
8484 },
8485 GetSockName {
8487 responder: SocketGetSockNameResponder,
8488 },
8489 GetPeerName {
8491 responder: SocketGetPeerNameResponder,
8492 },
8493 Shutdown {
8495 mode: fidl_fuchsia_posix_socket::ShutdownMode,
8496 responder: SocketShutdownResponder,
8497 },
8498 SetIpTypeOfService {
8500 value: u8,
8501 responder: SocketSetIpTypeOfServiceResponder,
8502 },
8503 GetIpTypeOfService {
8505 responder: SocketGetIpTypeOfServiceResponder,
8506 },
8507 SetIpTtl {
8509 value: fidl_fuchsia_posix_socket::OptionalUint8,
8510 responder: SocketSetIpTtlResponder,
8511 },
8512 GetIpTtl {
8514 responder: SocketGetIpTtlResponder,
8515 },
8516 SetIpPacketInfo {
8518 value: bool,
8519 responder: SocketSetIpPacketInfoResponder,
8520 },
8521 GetIpPacketInfo {
8523 responder: SocketGetIpPacketInfoResponder,
8524 },
8525 SetIpReceiveTypeOfService {
8527 value: bool,
8528 responder: SocketSetIpReceiveTypeOfServiceResponder,
8529 },
8530 GetIpReceiveTypeOfService {
8532 responder: SocketGetIpReceiveTypeOfServiceResponder,
8533 },
8534 SetIpReceiveTtl {
8536 value: bool,
8537 responder: SocketSetIpReceiveTtlResponder,
8538 },
8539 GetIpReceiveTtl {
8541 responder: SocketGetIpReceiveTtlResponder,
8542 },
8543 SetIpMulticastInterface {
8545 iface: u64,
8546 address: fidl_fuchsia_net::Ipv4Address,
8547 responder: SocketSetIpMulticastInterfaceResponder,
8548 },
8549 GetIpMulticastInterface {
8551 responder: SocketGetIpMulticastInterfaceResponder,
8552 },
8553 SetIpMulticastTtl {
8555 value: fidl_fuchsia_posix_socket::OptionalUint8,
8556 responder: SocketSetIpMulticastTtlResponder,
8557 },
8558 GetIpMulticastTtl {
8560 responder: SocketGetIpMulticastTtlResponder,
8561 },
8562 SetIpMulticastLoopback {
8564 value: bool,
8565 responder: SocketSetIpMulticastLoopbackResponder,
8566 },
8567 GetIpMulticastLoopback {
8569 responder: SocketGetIpMulticastLoopbackResponder,
8570 },
8571 AddIpMembership {
8573 membership: fidl_fuchsia_posix_socket::IpMulticastMembership,
8574 responder: SocketAddIpMembershipResponder,
8575 },
8576 DropIpMembership {
8578 membership: fidl_fuchsia_posix_socket::IpMulticastMembership,
8579 responder: SocketDropIpMembershipResponder,
8580 },
8581 SetIpTransparent {
8583 value: bool,
8584 responder: SocketSetIpTransparentResponder,
8585 },
8586 GetIpTransparent {
8588 responder: SocketGetIpTransparentResponder,
8589 },
8590 SetIpReceiveOriginalDestinationAddress {
8592 value: bool,
8593 responder: SocketSetIpReceiveOriginalDestinationAddressResponder,
8594 },
8595 GetIpReceiveOriginalDestinationAddress {
8597 responder: SocketGetIpReceiveOriginalDestinationAddressResponder,
8598 },
8599 AddIpv6Membership {
8601 membership: fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
8602 responder: SocketAddIpv6MembershipResponder,
8603 },
8604 DropIpv6Membership {
8606 membership: fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
8607 responder: SocketDropIpv6MembershipResponder,
8608 },
8609 SetIpv6MulticastInterface {
8611 value: u64,
8612 responder: SocketSetIpv6MulticastInterfaceResponder,
8613 },
8614 GetIpv6MulticastInterface {
8616 responder: SocketGetIpv6MulticastInterfaceResponder,
8617 },
8618 SetIpv6UnicastHops {
8620 value: fidl_fuchsia_posix_socket::OptionalUint8,
8621 responder: SocketSetIpv6UnicastHopsResponder,
8622 },
8623 GetIpv6UnicastHops {
8625 responder: SocketGetIpv6UnicastHopsResponder,
8626 },
8627 SetIpv6ReceiveHopLimit {
8629 value: bool,
8630 responder: SocketSetIpv6ReceiveHopLimitResponder,
8631 },
8632 GetIpv6ReceiveHopLimit {
8634 responder: SocketGetIpv6ReceiveHopLimitResponder,
8635 },
8636 SetIpv6MulticastHops {
8638 value: fidl_fuchsia_posix_socket::OptionalUint8,
8639 responder: SocketSetIpv6MulticastHopsResponder,
8640 },
8641 GetIpv6MulticastHops {
8643 responder: SocketGetIpv6MulticastHopsResponder,
8644 },
8645 SetIpv6MulticastLoopback {
8647 value: bool,
8648 responder: SocketSetIpv6MulticastLoopbackResponder,
8649 },
8650 GetIpv6MulticastLoopback {
8652 responder: SocketGetIpv6MulticastLoopbackResponder,
8653 },
8654 SetIpv6Only {
8656 value: bool,
8657 responder: SocketSetIpv6OnlyResponder,
8658 },
8659 GetIpv6Only {
8661 responder: SocketGetIpv6OnlyResponder,
8662 },
8663 SetIpv6ReceiveTrafficClass {
8665 value: bool,
8666 responder: SocketSetIpv6ReceiveTrafficClassResponder,
8667 },
8668 GetIpv6ReceiveTrafficClass {
8670 responder: SocketGetIpv6ReceiveTrafficClassResponder,
8671 },
8672 SetIpv6TrafficClass {
8674 value: fidl_fuchsia_posix_socket::OptionalUint8,
8675 responder: SocketSetIpv6TrafficClassResponder,
8676 },
8677 GetIpv6TrafficClass {
8679 responder: SocketGetIpv6TrafficClassResponder,
8680 },
8681 SetIpv6ReceivePacketInfo {
8683 value: bool,
8684 responder: SocketSetIpv6ReceivePacketInfoResponder,
8685 },
8686 GetIpv6ReceivePacketInfo {
8688 responder: SocketGetIpv6ReceivePacketInfoResponder,
8689 },
8690 GetOriginalDestination {
8692 responder: SocketGetOriginalDestinationResponder,
8693 },
8694 Describe {
8695 responder: SocketDescribeResponder,
8696 },
8697 RecvMsg {
8712 want_addr: bool,
8713 data_len: u32,
8714 want_control: bool,
8715 flags: fidl_fuchsia_posix_socket::RecvMsgFlags,
8716 responder: SocketRecvMsgResponder,
8717 },
8718 SendMsg {
8726 addr: Option<Box<fidl_fuchsia_net::SocketAddress>>,
8727 data: Vec<u8>,
8728 control: fidl_fuchsia_posix_socket::NetworkSocketSendControlData,
8729 flags: fidl_fuchsia_posix_socket::SendMsgFlags,
8730 responder: SocketSendMsgResponder,
8731 },
8732 GetInfo {
8737 responder: SocketGetInfoResponder,
8738 },
8739 SetIpHeaderIncluded {
8741 value: bool,
8742 responder: SocketSetIpHeaderIncludedResponder,
8743 },
8744 GetIpHeaderIncluded {
8746 responder: SocketGetIpHeaderIncludedResponder,
8747 },
8748 SetIcmpv6Filter {
8750 filter: Icmpv6Filter,
8751 responder: SocketSetIcmpv6FilterResponder,
8752 },
8753 GetIcmpv6Filter {
8755 responder: SocketGetIcmpv6FilterResponder,
8756 },
8757 SetIpv6Checksum {
8759 config: Ipv6ChecksumConfiguration,
8760 responder: SocketSetIpv6ChecksumResponder,
8761 },
8762 GetIpv6Checksum {
8764 responder: SocketGetIpv6ChecksumResponder,
8765 },
8766}
8767
8768impl SocketRequest {
8769 #[allow(irrefutable_let_patterns)]
8770 pub fn into_clone(
8771 self,
8772 ) -> Option<(
8773 fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
8774 SocketControlHandle,
8775 )> {
8776 if let SocketRequest::Clone { request, control_handle } = self {
8777 Some((request, control_handle))
8778 } else {
8779 None
8780 }
8781 }
8782
8783 #[allow(irrefutable_let_patterns)]
8784 pub fn into_close(self) -> Option<(SocketCloseResponder)> {
8785 if let SocketRequest::Close { responder } = self {
8786 Some((responder))
8787 } else {
8788 None
8789 }
8790 }
8791
8792 #[allow(irrefutable_let_patterns)]
8793 pub fn into_query(self) -> Option<(SocketQueryResponder)> {
8794 if let SocketRequest::Query { responder } = self {
8795 Some((responder))
8796 } else {
8797 None
8798 }
8799 }
8800
8801 #[allow(irrefutable_let_patterns)]
8802 pub fn into_set_reuse_address(self) -> Option<(bool, SocketSetReuseAddressResponder)> {
8803 if let SocketRequest::SetReuseAddress { value, responder } = self {
8804 Some((value, responder))
8805 } else {
8806 None
8807 }
8808 }
8809
8810 #[allow(irrefutable_let_patterns)]
8811 pub fn into_get_reuse_address(self) -> Option<(SocketGetReuseAddressResponder)> {
8812 if let SocketRequest::GetReuseAddress { responder } = self {
8813 Some((responder))
8814 } else {
8815 None
8816 }
8817 }
8818
8819 #[allow(irrefutable_let_patterns)]
8820 pub fn into_get_error(self) -> Option<(SocketGetErrorResponder)> {
8821 if let SocketRequest::GetError { responder } = self {
8822 Some((responder))
8823 } else {
8824 None
8825 }
8826 }
8827
8828 #[allow(irrefutable_let_patterns)]
8829 pub fn into_set_broadcast(self) -> Option<(bool, SocketSetBroadcastResponder)> {
8830 if let SocketRequest::SetBroadcast { value, responder } = self {
8831 Some((value, responder))
8832 } else {
8833 None
8834 }
8835 }
8836
8837 #[allow(irrefutable_let_patterns)]
8838 pub fn into_get_broadcast(self) -> Option<(SocketGetBroadcastResponder)> {
8839 if let SocketRequest::GetBroadcast { responder } = self {
8840 Some((responder))
8841 } else {
8842 None
8843 }
8844 }
8845
8846 #[allow(irrefutable_let_patterns)]
8847 pub fn into_set_send_buffer(self) -> Option<(u64, SocketSetSendBufferResponder)> {
8848 if let SocketRequest::SetSendBuffer { value_bytes, responder } = self {
8849 Some((value_bytes, responder))
8850 } else {
8851 None
8852 }
8853 }
8854
8855 #[allow(irrefutable_let_patterns)]
8856 pub fn into_get_send_buffer(self) -> Option<(SocketGetSendBufferResponder)> {
8857 if let SocketRequest::GetSendBuffer { responder } = self {
8858 Some((responder))
8859 } else {
8860 None
8861 }
8862 }
8863
8864 #[allow(irrefutable_let_patterns)]
8865 pub fn into_set_receive_buffer(self) -> Option<(u64, SocketSetReceiveBufferResponder)> {
8866 if let SocketRequest::SetReceiveBuffer { value_bytes, responder } = self {
8867 Some((value_bytes, responder))
8868 } else {
8869 None
8870 }
8871 }
8872
8873 #[allow(irrefutable_let_patterns)]
8874 pub fn into_get_receive_buffer(self) -> Option<(SocketGetReceiveBufferResponder)> {
8875 if let SocketRequest::GetReceiveBuffer { responder } = self {
8876 Some((responder))
8877 } else {
8878 None
8879 }
8880 }
8881
8882 #[allow(irrefutable_let_patterns)]
8883 pub fn into_set_keep_alive(self) -> Option<(bool, SocketSetKeepAliveResponder)> {
8884 if let SocketRequest::SetKeepAlive { value, responder } = self {
8885 Some((value, responder))
8886 } else {
8887 None
8888 }
8889 }
8890
8891 #[allow(irrefutable_let_patterns)]
8892 pub fn into_get_keep_alive(self) -> Option<(SocketGetKeepAliveResponder)> {
8893 if let SocketRequest::GetKeepAlive { responder } = self {
8894 Some((responder))
8895 } else {
8896 None
8897 }
8898 }
8899
8900 #[allow(irrefutable_let_patterns)]
8901 pub fn into_set_out_of_band_inline(self) -> Option<(bool, SocketSetOutOfBandInlineResponder)> {
8902 if let SocketRequest::SetOutOfBandInline { value, responder } = self {
8903 Some((value, responder))
8904 } else {
8905 None
8906 }
8907 }
8908
8909 #[allow(irrefutable_let_patterns)]
8910 pub fn into_get_out_of_band_inline(self) -> Option<(SocketGetOutOfBandInlineResponder)> {
8911 if let SocketRequest::GetOutOfBandInline { responder } = self {
8912 Some((responder))
8913 } else {
8914 None
8915 }
8916 }
8917
8918 #[allow(irrefutable_let_patterns)]
8919 pub fn into_set_no_check(self) -> Option<(bool, SocketSetNoCheckResponder)> {
8920 if let SocketRequest::SetNoCheck { value, responder } = self {
8921 Some((value, responder))
8922 } else {
8923 None
8924 }
8925 }
8926
8927 #[allow(irrefutable_let_patterns)]
8928 pub fn into_get_no_check(self) -> Option<(SocketGetNoCheckResponder)> {
8929 if let SocketRequest::GetNoCheck { responder } = self {
8930 Some((responder))
8931 } else {
8932 None
8933 }
8934 }
8935
8936 #[allow(irrefutable_let_patterns)]
8937 pub fn into_set_linger(self) -> Option<(bool, u32, SocketSetLingerResponder)> {
8938 if let SocketRequest::SetLinger { linger, length_secs, responder } = self {
8939 Some((linger, length_secs, responder))
8940 } else {
8941 None
8942 }
8943 }
8944
8945 #[allow(irrefutable_let_patterns)]
8946 pub fn into_get_linger(self) -> Option<(SocketGetLingerResponder)> {
8947 if let SocketRequest::GetLinger { responder } = self {
8948 Some((responder))
8949 } else {
8950 None
8951 }
8952 }
8953
8954 #[allow(irrefutable_let_patterns)]
8955 pub fn into_set_reuse_port(self) -> Option<(bool, SocketSetReusePortResponder)> {
8956 if let SocketRequest::SetReusePort { value, responder } = self {
8957 Some((value, responder))
8958 } else {
8959 None
8960 }
8961 }
8962
8963 #[allow(irrefutable_let_patterns)]
8964 pub fn into_get_reuse_port(self) -> Option<(SocketGetReusePortResponder)> {
8965 if let SocketRequest::GetReusePort { responder } = self {
8966 Some((responder))
8967 } else {
8968 None
8969 }
8970 }
8971
8972 #[allow(irrefutable_let_patterns)]
8973 pub fn into_get_accept_conn(self) -> Option<(SocketGetAcceptConnResponder)> {
8974 if let SocketRequest::GetAcceptConn { responder } = self {
8975 Some((responder))
8976 } else {
8977 None
8978 }
8979 }
8980
8981 #[allow(irrefutable_let_patterns)]
8982 pub fn into_set_bind_to_device(self) -> Option<(String, SocketSetBindToDeviceResponder)> {
8983 if let SocketRequest::SetBindToDevice { value, responder } = self {
8984 Some((value, responder))
8985 } else {
8986 None
8987 }
8988 }
8989
8990 #[allow(irrefutable_let_patterns)]
8991 pub fn into_get_bind_to_device(self) -> Option<(SocketGetBindToDeviceResponder)> {
8992 if let SocketRequest::GetBindToDevice { responder } = self {
8993 Some((responder))
8994 } else {
8995 None
8996 }
8997 }
8998
8999 #[allow(irrefutable_let_patterns)]
9000 pub fn into_set_bind_to_interface_index(
9001 self,
9002 ) -> Option<(u64, SocketSetBindToInterfaceIndexResponder)> {
9003 if let SocketRequest::SetBindToInterfaceIndex { value, responder } = self {
9004 Some((value, responder))
9005 } else {
9006 None
9007 }
9008 }
9009
9010 #[allow(irrefutable_let_patterns)]
9011 pub fn into_get_bind_to_interface_index(
9012 self,
9013 ) -> Option<(SocketGetBindToInterfaceIndexResponder)> {
9014 if let SocketRequest::GetBindToInterfaceIndex { responder } = self {
9015 Some((responder))
9016 } else {
9017 None
9018 }
9019 }
9020
9021 #[allow(irrefutable_let_patterns)]
9022 pub fn into_set_timestamp(
9023 self,
9024 ) -> Option<(fidl_fuchsia_posix_socket::TimestampOption, SocketSetTimestampResponder)> {
9025 if let SocketRequest::SetTimestamp { value, responder } = self {
9026 Some((value, responder))
9027 } else {
9028 None
9029 }
9030 }
9031
9032 #[allow(irrefutable_let_patterns)]
9033 pub fn into_get_timestamp(self) -> Option<(SocketGetTimestampResponder)> {
9034 if let SocketRequest::GetTimestamp { responder } = self {
9035 Some((responder))
9036 } else {
9037 None
9038 }
9039 }
9040
9041 #[allow(irrefutable_let_patterns)]
9042 pub fn into_set_mark(
9043 self,
9044 ) -> Option<(
9045 fidl_fuchsia_net::MarkDomain,
9046 fidl_fuchsia_posix_socket::OptionalUint32,
9047 SocketSetMarkResponder,
9048 )> {
9049 if let SocketRequest::SetMark { domain, mark, responder } = self {
9050 Some((domain, mark, responder))
9051 } else {
9052 None
9053 }
9054 }
9055
9056 #[allow(irrefutable_let_patterns)]
9057 pub fn into_get_mark(self) -> Option<(fidl_fuchsia_net::MarkDomain, SocketGetMarkResponder)> {
9058 if let SocketRequest::GetMark { domain, responder } = self {
9059 Some((domain, responder))
9060 } else {
9061 None
9062 }
9063 }
9064
9065 #[allow(irrefutable_let_patterns)]
9066 pub fn into_get_cookie(self) -> Option<(SocketGetCookieResponder)> {
9067 if let SocketRequest::GetCookie { responder } = self {
9068 Some((responder))
9069 } else {
9070 None
9071 }
9072 }
9073
9074 #[allow(irrefutable_let_patterns)]
9075 pub fn into_bind(self) -> Option<(fidl_fuchsia_net::SocketAddress, SocketBindResponder)> {
9076 if let SocketRequest::Bind { addr, responder } = self {
9077 Some((addr, responder))
9078 } else {
9079 None
9080 }
9081 }
9082
9083 #[allow(irrefutable_let_patterns)]
9084 pub fn into_connect(self) -> Option<(fidl_fuchsia_net::SocketAddress, SocketConnectResponder)> {
9085 if let SocketRequest::Connect { addr, responder } = self {
9086 Some((addr, responder))
9087 } else {
9088 None
9089 }
9090 }
9091
9092 #[allow(irrefutable_let_patterns)]
9093 pub fn into_disconnect(self) -> Option<(SocketDisconnectResponder)> {
9094 if let SocketRequest::Disconnect { responder } = self {
9095 Some((responder))
9096 } else {
9097 None
9098 }
9099 }
9100
9101 #[allow(irrefutable_let_patterns)]
9102 pub fn into_get_sock_name(self) -> Option<(SocketGetSockNameResponder)> {
9103 if let SocketRequest::GetSockName { responder } = self {
9104 Some((responder))
9105 } else {
9106 None
9107 }
9108 }
9109
9110 #[allow(irrefutable_let_patterns)]
9111 pub fn into_get_peer_name(self) -> Option<(SocketGetPeerNameResponder)> {
9112 if let SocketRequest::GetPeerName { responder } = self {
9113 Some((responder))
9114 } else {
9115 None
9116 }
9117 }
9118
9119 #[allow(irrefutable_let_patterns)]
9120 pub fn into_shutdown(
9121 self,
9122 ) -> Option<(fidl_fuchsia_posix_socket::ShutdownMode, SocketShutdownResponder)> {
9123 if let SocketRequest::Shutdown { mode, responder } = self {
9124 Some((mode, responder))
9125 } else {
9126 None
9127 }
9128 }
9129
9130 #[allow(irrefutable_let_patterns)]
9131 pub fn into_set_ip_type_of_service(self) -> Option<(u8, SocketSetIpTypeOfServiceResponder)> {
9132 if let SocketRequest::SetIpTypeOfService { value, responder } = self {
9133 Some((value, responder))
9134 } else {
9135 None
9136 }
9137 }
9138
9139 #[allow(irrefutable_let_patterns)]
9140 pub fn into_get_ip_type_of_service(self) -> Option<(SocketGetIpTypeOfServiceResponder)> {
9141 if let SocketRequest::GetIpTypeOfService { responder } = self {
9142 Some((responder))
9143 } else {
9144 None
9145 }
9146 }
9147
9148 #[allow(irrefutable_let_patterns)]
9149 pub fn into_set_ip_ttl(
9150 self,
9151 ) -> Option<(fidl_fuchsia_posix_socket::OptionalUint8, SocketSetIpTtlResponder)> {
9152 if let SocketRequest::SetIpTtl { value, responder } = self {
9153 Some((value, responder))
9154 } else {
9155 None
9156 }
9157 }
9158
9159 #[allow(irrefutable_let_patterns)]
9160 pub fn into_get_ip_ttl(self) -> Option<(SocketGetIpTtlResponder)> {
9161 if let SocketRequest::GetIpTtl { responder } = self {
9162 Some((responder))
9163 } else {
9164 None
9165 }
9166 }
9167
9168 #[allow(irrefutable_let_patterns)]
9169 pub fn into_set_ip_packet_info(self) -> Option<(bool, SocketSetIpPacketInfoResponder)> {
9170 if let SocketRequest::SetIpPacketInfo { value, responder } = self {
9171 Some((value, responder))
9172 } else {
9173 None
9174 }
9175 }
9176
9177 #[allow(irrefutable_let_patterns)]
9178 pub fn into_get_ip_packet_info(self) -> Option<(SocketGetIpPacketInfoResponder)> {
9179 if let SocketRequest::GetIpPacketInfo { responder } = self {
9180 Some((responder))
9181 } else {
9182 None
9183 }
9184 }
9185
9186 #[allow(irrefutable_let_patterns)]
9187 pub fn into_set_ip_receive_type_of_service(
9188 self,
9189 ) -> Option<(bool, SocketSetIpReceiveTypeOfServiceResponder)> {
9190 if let SocketRequest::SetIpReceiveTypeOfService { value, responder } = self {
9191 Some((value, responder))
9192 } else {
9193 None
9194 }
9195 }
9196
9197 #[allow(irrefutable_let_patterns)]
9198 pub fn into_get_ip_receive_type_of_service(
9199 self,
9200 ) -> Option<(SocketGetIpReceiveTypeOfServiceResponder)> {
9201 if let SocketRequest::GetIpReceiveTypeOfService { responder } = self {
9202 Some((responder))
9203 } else {
9204 None
9205 }
9206 }
9207
9208 #[allow(irrefutable_let_patterns)]
9209 pub fn into_set_ip_receive_ttl(self) -> Option<(bool, SocketSetIpReceiveTtlResponder)> {
9210 if let SocketRequest::SetIpReceiveTtl { value, responder } = self {
9211 Some((value, responder))
9212 } else {
9213 None
9214 }
9215 }
9216
9217 #[allow(irrefutable_let_patterns)]
9218 pub fn into_get_ip_receive_ttl(self) -> Option<(SocketGetIpReceiveTtlResponder)> {
9219 if let SocketRequest::GetIpReceiveTtl { responder } = self {
9220 Some((responder))
9221 } else {
9222 None
9223 }
9224 }
9225
9226 #[allow(irrefutable_let_patterns)]
9227 pub fn into_set_ip_multicast_interface(
9228 self,
9229 ) -> Option<(u64, fidl_fuchsia_net::Ipv4Address, SocketSetIpMulticastInterfaceResponder)> {
9230 if let SocketRequest::SetIpMulticastInterface { iface, address, responder } = self {
9231 Some((iface, address, responder))
9232 } else {
9233 None
9234 }
9235 }
9236
9237 #[allow(irrefutable_let_patterns)]
9238 pub fn into_get_ip_multicast_interface(
9239 self,
9240 ) -> Option<(SocketGetIpMulticastInterfaceResponder)> {
9241 if let SocketRequest::GetIpMulticastInterface { responder } = self {
9242 Some((responder))
9243 } else {
9244 None
9245 }
9246 }
9247
9248 #[allow(irrefutable_let_patterns)]
9249 pub fn into_set_ip_multicast_ttl(
9250 self,
9251 ) -> Option<(fidl_fuchsia_posix_socket::OptionalUint8, SocketSetIpMulticastTtlResponder)> {
9252 if let SocketRequest::SetIpMulticastTtl { value, responder } = self {
9253 Some((value, responder))
9254 } else {
9255 None
9256 }
9257 }
9258
9259 #[allow(irrefutable_let_patterns)]
9260 pub fn into_get_ip_multicast_ttl(self) -> Option<(SocketGetIpMulticastTtlResponder)> {
9261 if let SocketRequest::GetIpMulticastTtl { responder } = self {
9262 Some((responder))
9263 } else {
9264 None
9265 }
9266 }
9267
9268 #[allow(irrefutable_let_patterns)]
9269 pub fn into_set_ip_multicast_loopback(
9270 self,
9271 ) -> Option<(bool, SocketSetIpMulticastLoopbackResponder)> {
9272 if let SocketRequest::SetIpMulticastLoopback { value, responder } = self {
9273 Some((value, responder))
9274 } else {
9275 None
9276 }
9277 }
9278
9279 #[allow(irrefutable_let_patterns)]
9280 pub fn into_get_ip_multicast_loopback(self) -> Option<(SocketGetIpMulticastLoopbackResponder)> {
9281 if let SocketRequest::GetIpMulticastLoopback { responder } = self {
9282 Some((responder))
9283 } else {
9284 None
9285 }
9286 }
9287
9288 #[allow(irrefutable_let_patterns)]
9289 pub fn into_add_ip_membership(
9290 self,
9291 ) -> Option<(fidl_fuchsia_posix_socket::IpMulticastMembership, SocketAddIpMembershipResponder)>
9292 {
9293 if let SocketRequest::AddIpMembership { membership, responder } = self {
9294 Some((membership, responder))
9295 } else {
9296 None
9297 }
9298 }
9299
9300 #[allow(irrefutable_let_patterns)]
9301 pub fn into_drop_ip_membership(
9302 self,
9303 ) -> Option<(fidl_fuchsia_posix_socket::IpMulticastMembership, SocketDropIpMembershipResponder)>
9304 {
9305 if let SocketRequest::DropIpMembership { membership, responder } = self {
9306 Some((membership, responder))
9307 } else {
9308 None
9309 }
9310 }
9311
9312 #[allow(irrefutable_let_patterns)]
9313 pub fn into_set_ip_transparent(self) -> Option<(bool, SocketSetIpTransparentResponder)> {
9314 if let SocketRequest::SetIpTransparent { value, responder } = self {
9315 Some((value, responder))
9316 } else {
9317 None
9318 }
9319 }
9320
9321 #[allow(irrefutable_let_patterns)]
9322 pub fn into_get_ip_transparent(self) -> Option<(SocketGetIpTransparentResponder)> {
9323 if let SocketRequest::GetIpTransparent { responder } = self {
9324 Some((responder))
9325 } else {
9326 None
9327 }
9328 }
9329
9330 #[allow(irrefutable_let_patterns)]
9331 pub fn into_set_ip_receive_original_destination_address(
9332 self,
9333 ) -> Option<(bool, SocketSetIpReceiveOriginalDestinationAddressResponder)> {
9334 if let SocketRequest::SetIpReceiveOriginalDestinationAddress { value, responder } = self {
9335 Some((value, responder))
9336 } else {
9337 None
9338 }
9339 }
9340
9341 #[allow(irrefutable_let_patterns)]
9342 pub fn into_get_ip_receive_original_destination_address(
9343 self,
9344 ) -> Option<(SocketGetIpReceiveOriginalDestinationAddressResponder)> {
9345 if let SocketRequest::GetIpReceiveOriginalDestinationAddress { responder } = self {
9346 Some((responder))
9347 } else {
9348 None
9349 }
9350 }
9351
9352 #[allow(irrefutable_let_patterns)]
9353 pub fn into_add_ipv6_membership(
9354 self,
9355 ) -> Option<(
9356 fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
9357 SocketAddIpv6MembershipResponder,
9358 )> {
9359 if let SocketRequest::AddIpv6Membership { membership, responder } = self {
9360 Some((membership, responder))
9361 } else {
9362 None
9363 }
9364 }
9365
9366 #[allow(irrefutable_let_patterns)]
9367 pub fn into_drop_ipv6_membership(
9368 self,
9369 ) -> Option<(
9370 fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
9371 SocketDropIpv6MembershipResponder,
9372 )> {
9373 if let SocketRequest::DropIpv6Membership { membership, responder } = self {
9374 Some((membership, responder))
9375 } else {
9376 None
9377 }
9378 }
9379
9380 #[allow(irrefutable_let_patterns)]
9381 pub fn into_set_ipv6_multicast_interface(
9382 self,
9383 ) -> Option<(u64, SocketSetIpv6MulticastInterfaceResponder)> {
9384 if let SocketRequest::SetIpv6MulticastInterface { value, responder } = self {
9385 Some((value, responder))
9386 } else {
9387 None
9388 }
9389 }
9390
9391 #[allow(irrefutable_let_patterns)]
9392 pub fn into_get_ipv6_multicast_interface(
9393 self,
9394 ) -> Option<(SocketGetIpv6MulticastInterfaceResponder)> {
9395 if let SocketRequest::GetIpv6MulticastInterface { responder } = self {
9396 Some((responder))
9397 } else {
9398 None
9399 }
9400 }
9401
9402 #[allow(irrefutable_let_patterns)]
9403 pub fn into_set_ipv6_unicast_hops(
9404 self,
9405 ) -> Option<(fidl_fuchsia_posix_socket::OptionalUint8, SocketSetIpv6UnicastHopsResponder)> {
9406 if let SocketRequest::SetIpv6UnicastHops { value, responder } = self {
9407 Some((value, responder))
9408 } else {
9409 None
9410 }
9411 }
9412
9413 #[allow(irrefutable_let_patterns)]
9414 pub fn into_get_ipv6_unicast_hops(self) -> Option<(SocketGetIpv6UnicastHopsResponder)> {
9415 if let SocketRequest::GetIpv6UnicastHops { responder } = self {
9416 Some((responder))
9417 } else {
9418 None
9419 }
9420 }
9421
9422 #[allow(irrefutable_let_patterns)]
9423 pub fn into_set_ipv6_receive_hop_limit(
9424 self,
9425 ) -> Option<(bool, SocketSetIpv6ReceiveHopLimitResponder)> {
9426 if let SocketRequest::SetIpv6ReceiveHopLimit { value, responder } = self {
9427 Some((value, responder))
9428 } else {
9429 None
9430 }
9431 }
9432
9433 #[allow(irrefutable_let_patterns)]
9434 pub fn into_get_ipv6_receive_hop_limit(
9435 self,
9436 ) -> Option<(SocketGetIpv6ReceiveHopLimitResponder)> {
9437 if let SocketRequest::GetIpv6ReceiveHopLimit { responder } = self {
9438 Some((responder))
9439 } else {
9440 None
9441 }
9442 }
9443
9444 #[allow(irrefutable_let_patterns)]
9445 pub fn into_set_ipv6_multicast_hops(
9446 self,
9447 ) -> Option<(fidl_fuchsia_posix_socket::OptionalUint8, SocketSetIpv6MulticastHopsResponder)>
9448 {
9449 if let SocketRequest::SetIpv6MulticastHops { value, responder } = self {
9450 Some((value, responder))
9451 } else {
9452 None
9453 }
9454 }
9455
9456 #[allow(irrefutable_let_patterns)]
9457 pub fn into_get_ipv6_multicast_hops(self) -> Option<(SocketGetIpv6MulticastHopsResponder)> {
9458 if let SocketRequest::GetIpv6MulticastHops { responder } = self {
9459 Some((responder))
9460 } else {
9461 None
9462 }
9463 }
9464
9465 #[allow(irrefutable_let_patterns)]
9466 pub fn into_set_ipv6_multicast_loopback(
9467 self,
9468 ) -> Option<(bool, SocketSetIpv6MulticastLoopbackResponder)> {
9469 if let SocketRequest::SetIpv6MulticastLoopback { value, responder } = self {
9470 Some((value, responder))
9471 } else {
9472 None
9473 }
9474 }
9475
9476 #[allow(irrefutable_let_patterns)]
9477 pub fn into_get_ipv6_multicast_loopback(
9478 self,
9479 ) -> Option<(SocketGetIpv6MulticastLoopbackResponder)> {
9480 if let SocketRequest::GetIpv6MulticastLoopback { responder } = self {
9481 Some((responder))
9482 } else {
9483 None
9484 }
9485 }
9486
9487 #[allow(irrefutable_let_patterns)]
9488 pub fn into_set_ipv6_only(self) -> Option<(bool, SocketSetIpv6OnlyResponder)> {
9489 if let SocketRequest::SetIpv6Only { value, responder } = self {
9490 Some((value, responder))
9491 } else {
9492 None
9493 }
9494 }
9495
9496 #[allow(irrefutable_let_patterns)]
9497 pub fn into_get_ipv6_only(self) -> Option<(SocketGetIpv6OnlyResponder)> {
9498 if let SocketRequest::GetIpv6Only { responder } = self {
9499 Some((responder))
9500 } else {
9501 None
9502 }
9503 }
9504
9505 #[allow(irrefutable_let_patterns)]
9506 pub fn into_set_ipv6_receive_traffic_class(
9507 self,
9508 ) -> Option<(bool, SocketSetIpv6ReceiveTrafficClassResponder)> {
9509 if let SocketRequest::SetIpv6ReceiveTrafficClass { value, responder } = self {
9510 Some((value, responder))
9511 } else {
9512 None
9513 }
9514 }
9515
9516 #[allow(irrefutable_let_patterns)]
9517 pub fn into_get_ipv6_receive_traffic_class(
9518 self,
9519 ) -> Option<(SocketGetIpv6ReceiveTrafficClassResponder)> {
9520 if let SocketRequest::GetIpv6ReceiveTrafficClass { responder } = self {
9521 Some((responder))
9522 } else {
9523 None
9524 }
9525 }
9526
9527 #[allow(irrefutable_let_patterns)]
9528 pub fn into_set_ipv6_traffic_class(
9529 self,
9530 ) -> Option<(fidl_fuchsia_posix_socket::OptionalUint8, SocketSetIpv6TrafficClassResponder)>
9531 {
9532 if let SocketRequest::SetIpv6TrafficClass { value, responder } = self {
9533 Some((value, responder))
9534 } else {
9535 None
9536 }
9537 }
9538
9539 #[allow(irrefutable_let_patterns)]
9540 pub fn into_get_ipv6_traffic_class(self) -> Option<(SocketGetIpv6TrafficClassResponder)> {
9541 if let SocketRequest::GetIpv6TrafficClass { responder } = self {
9542 Some((responder))
9543 } else {
9544 None
9545 }
9546 }
9547
9548 #[allow(irrefutable_let_patterns)]
9549 pub fn into_set_ipv6_receive_packet_info(
9550 self,
9551 ) -> Option<(bool, SocketSetIpv6ReceivePacketInfoResponder)> {
9552 if let SocketRequest::SetIpv6ReceivePacketInfo { value, responder } = self {
9553 Some((value, responder))
9554 } else {
9555 None
9556 }
9557 }
9558
9559 #[allow(irrefutable_let_patterns)]
9560 pub fn into_get_ipv6_receive_packet_info(
9561 self,
9562 ) -> Option<(SocketGetIpv6ReceivePacketInfoResponder)> {
9563 if let SocketRequest::GetIpv6ReceivePacketInfo { responder } = self {
9564 Some((responder))
9565 } else {
9566 None
9567 }
9568 }
9569
9570 #[allow(irrefutable_let_patterns)]
9571 pub fn into_get_original_destination(self) -> Option<(SocketGetOriginalDestinationResponder)> {
9572 if let SocketRequest::GetOriginalDestination { responder } = self {
9573 Some((responder))
9574 } else {
9575 None
9576 }
9577 }
9578
9579 #[allow(irrefutable_let_patterns)]
9580 pub fn into_describe(self) -> Option<(SocketDescribeResponder)> {
9581 if let SocketRequest::Describe { responder } = self {
9582 Some((responder))
9583 } else {
9584 None
9585 }
9586 }
9587
9588 #[allow(irrefutable_let_patterns)]
9589 pub fn into_recv_msg(
9590 self,
9591 ) -> Option<(bool, u32, bool, fidl_fuchsia_posix_socket::RecvMsgFlags, SocketRecvMsgResponder)>
9592 {
9593 if let SocketRequest::RecvMsg { want_addr, data_len, want_control, flags, responder } = self
9594 {
9595 Some((want_addr, data_len, want_control, flags, responder))
9596 } else {
9597 None
9598 }
9599 }
9600
9601 #[allow(irrefutable_let_patterns)]
9602 pub fn into_send_msg(
9603 self,
9604 ) -> Option<(
9605 Option<Box<fidl_fuchsia_net::SocketAddress>>,
9606 Vec<u8>,
9607 fidl_fuchsia_posix_socket::NetworkSocketSendControlData,
9608 fidl_fuchsia_posix_socket::SendMsgFlags,
9609 SocketSendMsgResponder,
9610 )> {
9611 if let SocketRequest::SendMsg { addr, data, control, flags, responder } = self {
9612 Some((addr, data, control, flags, responder))
9613 } else {
9614 None
9615 }
9616 }
9617
9618 #[allow(irrefutable_let_patterns)]
9619 pub fn into_get_info(self) -> Option<(SocketGetInfoResponder)> {
9620 if let SocketRequest::GetInfo { responder } = self {
9621 Some((responder))
9622 } else {
9623 None
9624 }
9625 }
9626
9627 #[allow(irrefutable_let_patterns)]
9628 pub fn into_set_ip_header_included(self) -> Option<(bool, SocketSetIpHeaderIncludedResponder)> {
9629 if let SocketRequest::SetIpHeaderIncluded { value, responder } = self {
9630 Some((value, responder))
9631 } else {
9632 None
9633 }
9634 }
9635
9636 #[allow(irrefutable_let_patterns)]
9637 pub fn into_get_ip_header_included(self) -> Option<(SocketGetIpHeaderIncludedResponder)> {
9638 if let SocketRequest::GetIpHeaderIncluded { responder } = self {
9639 Some((responder))
9640 } else {
9641 None
9642 }
9643 }
9644
9645 #[allow(irrefutable_let_patterns)]
9646 pub fn into_set_icmpv6_filter(self) -> Option<(Icmpv6Filter, SocketSetIcmpv6FilterResponder)> {
9647 if let SocketRequest::SetIcmpv6Filter { filter, responder } = self {
9648 Some((filter, responder))
9649 } else {
9650 None
9651 }
9652 }
9653
9654 #[allow(irrefutable_let_patterns)]
9655 pub fn into_get_icmpv6_filter(self) -> Option<(SocketGetIcmpv6FilterResponder)> {
9656 if let SocketRequest::GetIcmpv6Filter { responder } = self {
9657 Some((responder))
9658 } else {
9659 None
9660 }
9661 }
9662
9663 #[allow(irrefutable_let_patterns)]
9664 pub fn into_set_ipv6_checksum(
9665 self,
9666 ) -> Option<(Ipv6ChecksumConfiguration, SocketSetIpv6ChecksumResponder)> {
9667 if let SocketRequest::SetIpv6Checksum { config, responder } = self {
9668 Some((config, responder))
9669 } else {
9670 None
9671 }
9672 }
9673
9674 #[allow(irrefutable_let_patterns)]
9675 pub fn into_get_ipv6_checksum(self) -> Option<(SocketGetIpv6ChecksumResponder)> {
9676 if let SocketRequest::GetIpv6Checksum { responder } = self {
9677 Some((responder))
9678 } else {
9679 None
9680 }
9681 }
9682
9683 pub fn method_name(&self) -> &'static str {
9685 match *self {
9686 SocketRequest::Clone { .. } => "clone",
9687 SocketRequest::Close { .. } => "close",
9688 SocketRequest::Query { .. } => "query",
9689 SocketRequest::SetReuseAddress { .. } => "set_reuse_address",
9690 SocketRequest::GetReuseAddress { .. } => "get_reuse_address",
9691 SocketRequest::GetError { .. } => "get_error",
9692 SocketRequest::SetBroadcast { .. } => "set_broadcast",
9693 SocketRequest::GetBroadcast { .. } => "get_broadcast",
9694 SocketRequest::SetSendBuffer { .. } => "set_send_buffer",
9695 SocketRequest::GetSendBuffer { .. } => "get_send_buffer",
9696 SocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
9697 SocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
9698 SocketRequest::SetKeepAlive { .. } => "set_keep_alive",
9699 SocketRequest::GetKeepAlive { .. } => "get_keep_alive",
9700 SocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
9701 SocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
9702 SocketRequest::SetNoCheck { .. } => "set_no_check",
9703 SocketRequest::GetNoCheck { .. } => "get_no_check",
9704 SocketRequest::SetLinger { .. } => "set_linger",
9705 SocketRequest::GetLinger { .. } => "get_linger",
9706 SocketRequest::SetReusePort { .. } => "set_reuse_port",
9707 SocketRequest::GetReusePort { .. } => "get_reuse_port",
9708 SocketRequest::GetAcceptConn { .. } => "get_accept_conn",
9709 SocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
9710 SocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
9711 SocketRequest::SetBindToInterfaceIndex { .. } => "set_bind_to_interface_index",
9712 SocketRequest::GetBindToInterfaceIndex { .. } => "get_bind_to_interface_index",
9713 SocketRequest::SetTimestamp { .. } => "set_timestamp",
9714 SocketRequest::GetTimestamp { .. } => "get_timestamp",
9715 SocketRequest::SetMark { .. } => "set_mark",
9716 SocketRequest::GetMark { .. } => "get_mark",
9717 SocketRequest::GetCookie { .. } => "get_cookie",
9718 SocketRequest::Bind { .. } => "bind",
9719 SocketRequest::Connect { .. } => "connect",
9720 SocketRequest::Disconnect { .. } => "disconnect",
9721 SocketRequest::GetSockName { .. } => "get_sock_name",
9722 SocketRequest::GetPeerName { .. } => "get_peer_name",
9723 SocketRequest::Shutdown { .. } => "shutdown",
9724 SocketRequest::SetIpTypeOfService { .. } => "set_ip_type_of_service",
9725 SocketRequest::GetIpTypeOfService { .. } => "get_ip_type_of_service",
9726 SocketRequest::SetIpTtl { .. } => "set_ip_ttl",
9727 SocketRequest::GetIpTtl { .. } => "get_ip_ttl",
9728 SocketRequest::SetIpPacketInfo { .. } => "set_ip_packet_info",
9729 SocketRequest::GetIpPacketInfo { .. } => "get_ip_packet_info",
9730 SocketRequest::SetIpReceiveTypeOfService { .. } => "set_ip_receive_type_of_service",
9731 SocketRequest::GetIpReceiveTypeOfService { .. } => "get_ip_receive_type_of_service",
9732 SocketRequest::SetIpReceiveTtl { .. } => "set_ip_receive_ttl",
9733 SocketRequest::GetIpReceiveTtl { .. } => "get_ip_receive_ttl",
9734 SocketRequest::SetIpMulticastInterface { .. } => "set_ip_multicast_interface",
9735 SocketRequest::GetIpMulticastInterface { .. } => "get_ip_multicast_interface",
9736 SocketRequest::SetIpMulticastTtl { .. } => "set_ip_multicast_ttl",
9737 SocketRequest::GetIpMulticastTtl { .. } => "get_ip_multicast_ttl",
9738 SocketRequest::SetIpMulticastLoopback { .. } => "set_ip_multicast_loopback",
9739 SocketRequest::GetIpMulticastLoopback { .. } => "get_ip_multicast_loopback",
9740 SocketRequest::AddIpMembership { .. } => "add_ip_membership",
9741 SocketRequest::DropIpMembership { .. } => "drop_ip_membership",
9742 SocketRequest::SetIpTransparent { .. } => "set_ip_transparent",
9743 SocketRequest::GetIpTransparent { .. } => "get_ip_transparent",
9744 SocketRequest::SetIpReceiveOriginalDestinationAddress { .. } => {
9745 "set_ip_receive_original_destination_address"
9746 }
9747 SocketRequest::GetIpReceiveOriginalDestinationAddress { .. } => {
9748 "get_ip_receive_original_destination_address"
9749 }
9750 SocketRequest::AddIpv6Membership { .. } => "add_ipv6_membership",
9751 SocketRequest::DropIpv6Membership { .. } => "drop_ipv6_membership",
9752 SocketRequest::SetIpv6MulticastInterface { .. } => "set_ipv6_multicast_interface",
9753 SocketRequest::GetIpv6MulticastInterface { .. } => "get_ipv6_multicast_interface",
9754 SocketRequest::SetIpv6UnicastHops { .. } => "set_ipv6_unicast_hops",
9755 SocketRequest::GetIpv6UnicastHops { .. } => "get_ipv6_unicast_hops",
9756 SocketRequest::SetIpv6ReceiveHopLimit { .. } => "set_ipv6_receive_hop_limit",
9757 SocketRequest::GetIpv6ReceiveHopLimit { .. } => "get_ipv6_receive_hop_limit",
9758 SocketRequest::SetIpv6MulticastHops { .. } => "set_ipv6_multicast_hops",
9759 SocketRequest::GetIpv6MulticastHops { .. } => "get_ipv6_multicast_hops",
9760 SocketRequest::SetIpv6MulticastLoopback { .. } => "set_ipv6_multicast_loopback",
9761 SocketRequest::GetIpv6MulticastLoopback { .. } => "get_ipv6_multicast_loopback",
9762 SocketRequest::SetIpv6Only { .. } => "set_ipv6_only",
9763 SocketRequest::GetIpv6Only { .. } => "get_ipv6_only",
9764 SocketRequest::SetIpv6ReceiveTrafficClass { .. } => "set_ipv6_receive_traffic_class",
9765 SocketRequest::GetIpv6ReceiveTrafficClass { .. } => "get_ipv6_receive_traffic_class",
9766 SocketRequest::SetIpv6TrafficClass { .. } => "set_ipv6_traffic_class",
9767 SocketRequest::GetIpv6TrafficClass { .. } => "get_ipv6_traffic_class",
9768 SocketRequest::SetIpv6ReceivePacketInfo { .. } => "set_ipv6_receive_packet_info",
9769 SocketRequest::GetIpv6ReceivePacketInfo { .. } => "get_ipv6_receive_packet_info",
9770 SocketRequest::GetOriginalDestination { .. } => "get_original_destination",
9771 SocketRequest::Describe { .. } => "describe",
9772 SocketRequest::RecvMsg { .. } => "recv_msg",
9773 SocketRequest::SendMsg { .. } => "send_msg",
9774 SocketRequest::GetInfo { .. } => "get_info",
9775 SocketRequest::SetIpHeaderIncluded { .. } => "set_ip_header_included",
9776 SocketRequest::GetIpHeaderIncluded { .. } => "get_ip_header_included",
9777 SocketRequest::SetIcmpv6Filter { .. } => "set_icmpv6_filter",
9778 SocketRequest::GetIcmpv6Filter { .. } => "get_icmpv6_filter",
9779 SocketRequest::SetIpv6Checksum { .. } => "set_ipv6_checksum",
9780 SocketRequest::GetIpv6Checksum { .. } => "get_ipv6_checksum",
9781 }
9782 }
9783}
9784
9785#[derive(Debug, Clone)]
9786pub struct SocketControlHandle {
9787 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
9788}
9789
9790impl fidl::endpoints::ControlHandle for SocketControlHandle {
9791 fn shutdown(&self) {
9792 self.inner.shutdown()
9793 }
9794 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
9795 self.inner.shutdown_with_epitaph(status)
9796 }
9797
9798 fn is_closed(&self) -> bool {
9799 self.inner.channel().is_closed()
9800 }
9801 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
9802 self.inner.channel().on_closed()
9803 }
9804
9805 #[cfg(target_os = "fuchsia")]
9806 fn signal_peer(
9807 &self,
9808 clear_mask: zx::Signals,
9809 set_mask: zx::Signals,
9810 ) -> Result<(), zx_status::Status> {
9811 use fidl::Peered;
9812 self.inner.channel().signal_peer(clear_mask, set_mask)
9813 }
9814}
9815
9816impl SocketControlHandle {}
9817
9818#[must_use = "FIDL methods require a response to be sent"]
9819#[derive(Debug)]
9820pub struct SocketCloseResponder {
9821 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
9822 tx_id: u32,
9823}
9824
9825impl std::ops::Drop for SocketCloseResponder {
9829 fn drop(&mut self) {
9830 self.control_handle.shutdown();
9831 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9833 }
9834}
9835
9836impl fidl::endpoints::Responder for SocketCloseResponder {
9837 type ControlHandle = SocketControlHandle;
9838
9839 fn control_handle(&self) -> &SocketControlHandle {
9840 &self.control_handle
9841 }
9842
9843 fn drop_without_shutdown(mut self) {
9844 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9846 std::mem::forget(self);
9848 }
9849}
9850
9851impl SocketCloseResponder {
9852 pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
9856 let _result = self.send_raw(result);
9857 if _result.is_err() {
9858 self.control_handle.shutdown();
9859 }
9860 self.drop_without_shutdown();
9861 _result
9862 }
9863
9864 pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
9866 let _result = self.send_raw(result);
9867 self.drop_without_shutdown();
9868 _result
9869 }
9870
9871 fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
9872 self.control_handle
9873 .inner
9874 .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
9875 result,
9876 self.tx_id,
9877 0x5ac5d459ad7f657e,
9878 fidl::encoding::DynamicFlags::empty(),
9879 )
9880 }
9881}
9882
9883#[must_use = "FIDL methods require a response to be sent"]
9884#[derive(Debug)]
9885pub struct SocketQueryResponder {
9886 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
9887 tx_id: u32,
9888}
9889
9890impl std::ops::Drop for SocketQueryResponder {
9894 fn drop(&mut self) {
9895 self.control_handle.shutdown();
9896 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9898 }
9899}
9900
9901impl fidl::endpoints::Responder for SocketQueryResponder {
9902 type ControlHandle = SocketControlHandle;
9903
9904 fn control_handle(&self) -> &SocketControlHandle {
9905 &self.control_handle
9906 }
9907
9908 fn drop_without_shutdown(mut self) {
9909 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9911 std::mem::forget(self);
9913 }
9914}
9915
9916impl SocketQueryResponder {
9917 pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
9921 let _result = self.send_raw(protocol);
9922 if _result.is_err() {
9923 self.control_handle.shutdown();
9924 }
9925 self.drop_without_shutdown();
9926 _result
9927 }
9928
9929 pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
9931 let _result = self.send_raw(protocol);
9932 self.drop_without_shutdown();
9933 _result
9934 }
9935
9936 fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
9937 self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
9938 (protocol,),
9939 self.tx_id,
9940 0x2658edee9decfc06,
9941 fidl::encoding::DynamicFlags::empty(),
9942 )
9943 }
9944}
9945
9946#[must_use = "FIDL methods require a response to be sent"]
9947#[derive(Debug)]
9948pub struct SocketSetReuseAddressResponder {
9949 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
9950 tx_id: u32,
9951}
9952
9953impl std::ops::Drop for SocketSetReuseAddressResponder {
9957 fn drop(&mut self) {
9958 self.control_handle.shutdown();
9959 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9961 }
9962}
9963
9964impl fidl::endpoints::Responder for SocketSetReuseAddressResponder {
9965 type ControlHandle = SocketControlHandle;
9966
9967 fn control_handle(&self) -> &SocketControlHandle {
9968 &self.control_handle
9969 }
9970
9971 fn drop_without_shutdown(mut self) {
9972 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9974 std::mem::forget(self);
9976 }
9977}
9978
9979impl SocketSetReuseAddressResponder {
9980 pub fn send(
9984 self,
9985 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9986 ) -> Result<(), fidl::Error> {
9987 let _result = self.send_raw(result);
9988 if _result.is_err() {
9989 self.control_handle.shutdown();
9990 }
9991 self.drop_without_shutdown();
9992 _result
9993 }
9994
9995 pub fn send_no_shutdown_on_err(
9997 self,
9998 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9999 ) -> Result<(), fidl::Error> {
10000 let _result = self.send_raw(result);
10001 self.drop_without_shutdown();
10002 _result
10003 }
10004
10005 fn send_raw(
10006 &self,
10007 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10008 ) -> Result<(), fidl::Error> {
10009 self.control_handle.inner.send::<fidl::encoding::ResultType<
10010 fidl::encoding::EmptyStruct,
10011 fidl_fuchsia_posix::Errno,
10012 >>(
10013 result,
10014 self.tx_id,
10015 0x1fd74ee8b9a4a876,
10016 fidl::encoding::DynamicFlags::empty(),
10017 )
10018 }
10019}
10020
10021#[must_use = "FIDL methods require a response to be sent"]
10022#[derive(Debug)]
10023pub struct SocketGetReuseAddressResponder {
10024 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10025 tx_id: u32,
10026}
10027
10028impl std::ops::Drop for SocketGetReuseAddressResponder {
10032 fn drop(&mut self) {
10033 self.control_handle.shutdown();
10034 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10036 }
10037}
10038
10039impl fidl::endpoints::Responder for SocketGetReuseAddressResponder {
10040 type ControlHandle = SocketControlHandle;
10041
10042 fn control_handle(&self) -> &SocketControlHandle {
10043 &self.control_handle
10044 }
10045
10046 fn drop_without_shutdown(mut self) {
10047 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10049 std::mem::forget(self);
10051 }
10052}
10053
10054impl SocketGetReuseAddressResponder {
10055 pub fn send(
10059 self,
10060 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10061 ) -> Result<(), fidl::Error> {
10062 let _result = self.send_raw(result);
10063 if _result.is_err() {
10064 self.control_handle.shutdown();
10065 }
10066 self.drop_without_shutdown();
10067 _result
10068 }
10069
10070 pub fn send_no_shutdown_on_err(
10072 self,
10073 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10074 ) -> Result<(), fidl::Error> {
10075 let _result = self.send_raw(result);
10076 self.drop_without_shutdown();
10077 _result
10078 }
10079
10080 fn send_raw(
10081 &self,
10082 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10083 ) -> Result<(), fidl::Error> {
10084 self.control_handle.inner.send::<fidl::encoding::ResultType<
10085 fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResponse,
10086 fidl_fuchsia_posix::Errno,
10087 >>(
10088 result.map(|value| (value,)),
10089 self.tx_id,
10090 0x67b7206b8d1bc0a5,
10091 fidl::encoding::DynamicFlags::empty(),
10092 )
10093 }
10094}
10095
10096#[must_use = "FIDL methods require a response to be sent"]
10097#[derive(Debug)]
10098pub struct SocketGetErrorResponder {
10099 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10100 tx_id: u32,
10101}
10102
10103impl std::ops::Drop for SocketGetErrorResponder {
10107 fn drop(&mut self) {
10108 self.control_handle.shutdown();
10109 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10111 }
10112}
10113
10114impl fidl::endpoints::Responder for SocketGetErrorResponder {
10115 type ControlHandle = SocketControlHandle;
10116
10117 fn control_handle(&self) -> &SocketControlHandle {
10118 &self.control_handle
10119 }
10120
10121 fn drop_without_shutdown(mut self) {
10122 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10124 std::mem::forget(self);
10126 }
10127}
10128
10129impl SocketGetErrorResponder {
10130 pub fn send(
10134 self,
10135 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10136 ) -> Result<(), fidl::Error> {
10137 let _result = self.send_raw(result);
10138 if _result.is_err() {
10139 self.control_handle.shutdown();
10140 }
10141 self.drop_without_shutdown();
10142 _result
10143 }
10144
10145 pub fn send_no_shutdown_on_err(
10147 self,
10148 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10149 ) -> Result<(), fidl::Error> {
10150 let _result = self.send_raw(result);
10151 self.drop_without_shutdown();
10152 _result
10153 }
10154
10155 fn send_raw(
10156 &self,
10157 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10158 ) -> Result<(), fidl::Error> {
10159 self.control_handle.inner.send::<fidl::encoding::ResultType<
10160 fidl::encoding::EmptyStruct,
10161 fidl_fuchsia_posix::Errno,
10162 >>(
10163 result,
10164 self.tx_id,
10165 0x5aad39b33e5f6ebb,
10166 fidl::encoding::DynamicFlags::empty(),
10167 )
10168 }
10169}
10170
10171#[must_use = "FIDL methods require a response to be sent"]
10172#[derive(Debug)]
10173pub struct SocketSetBroadcastResponder {
10174 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10175 tx_id: u32,
10176}
10177
10178impl std::ops::Drop for SocketSetBroadcastResponder {
10182 fn drop(&mut self) {
10183 self.control_handle.shutdown();
10184 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10186 }
10187}
10188
10189impl fidl::endpoints::Responder for SocketSetBroadcastResponder {
10190 type ControlHandle = SocketControlHandle;
10191
10192 fn control_handle(&self) -> &SocketControlHandle {
10193 &self.control_handle
10194 }
10195
10196 fn drop_without_shutdown(mut self) {
10197 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10199 std::mem::forget(self);
10201 }
10202}
10203
10204impl SocketSetBroadcastResponder {
10205 pub fn send(
10209 self,
10210 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10211 ) -> Result<(), fidl::Error> {
10212 let _result = self.send_raw(result);
10213 if _result.is_err() {
10214 self.control_handle.shutdown();
10215 }
10216 self.drop_without_shutdown();
10217 _result
10218 }
10219
10220 pub fn send_no_shutdown_on_err(
10222 self,
10223 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10224 ) -> Result<(), fidl::Error> {
10225 let _result = self.send_raw(result);
10226 self.drop_without_shutdown();
10227 _result
10228 }
10229
10230 fn send_raw(
10231 &self,
10232 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10233 ) -> Result<(), fidl::Error> {
10234 self.control_handle.inner.send::<fidl::encoding::ResultType<
10235 fidl::encoding::EmptyStruct,
10236 fidl_fuchsia_posix::Errno,
10237 >>(
10238 result,
10239 self.tx_id,
10240 0x6023e081ce3cd947,
10241 fidl::encoding::DynamicFlags::empty(),
10242 )
10243 }
10244}
10245
10246#[must_use = "FIDL methods require a response to be sent"]
10247#[derive(Debug)]
10248pub struct SocketGetBroadcastResponder {
10249 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10250 tx_id: u32,
10251}
10252
10253impl std::ops::Drop for SocketGetBroadcastResponder {
10257 fn drop(&mut self) {
10258 self.control_handle.shutdown();
10259 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10261 }
10262}
10263
10264impl fidl::endpoints::Responder for SocketGetBroadcastResponder {
10265 type ControlHandle = SocketControlHandle;
10266
10267 fn control_handle(&self) -> &SocketControlHandle {
10268 &self.control_handle
10269 }
10270
10271 fn drop_without_shutdown(mut self) {
10272 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10274 std::mem::forget(self);
10276 }
10277}
10278
10279impl SocketGetBroadcastResponder {
10280 pub fn send(
10284 self,
10285 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10286 ) -> Result<(), fidl::Error> {
10287 let _result = self.send_raw(result);
10288 if _result.is_err() {
10289 self.control_handle.shutdown();
10290 }
10291 self.drop_without_shutdown();
10292 _result
10293 }
10294
10295 pub fn send_no_shutdown_on_err(
10297 self,
10298 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10299 ) -> Result<(), fidl::Error> {
10300 let _result = self.send_raw(result);
10301 self.drop_without_shutdown();
10302 _result
10303 }
10304
10305 fn send_raw(
10306 &self,
10307 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10308 ) -> Result<(), fidl::Error> {
10309 self.control_handle.inner.send::<fidl::encoding::ResultType<
10310 fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResponse,
10311 fidl_fuchsia_posix::Errno,
10312 >>(
10313 result.map(|value| (value,)),
10314 self.tx_id,
10315 0x68796fc556f9780d,
10316 fidl::encoding::DynamicFlags::empty(),
10317 )
10318 }
10319}
10320
10321#[must_use = "FIDL methods require a response to be sent"]
10322#[derive(Debug)]
10323pub struct SocketSetSendBufferResponder {
10324 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10325 tx_id: u32,
10326}
10327
10328impl std::ops::Drop for SocketSetSendBufferResponder {
10332 fn drop(&mut self) {
10333 self.control_handle.shutdown();
10334 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10336 }
10337}
10338
10339impl fidl::endpoints::Responder for SocketSetSendBufferResponder {
10340 type ControlHandle = SocketControlHandle;
10341
10342 fn control_handle(&self) -> &SocketControlHandle {
10343 &self.control_handle
10344 }
10345
10346 fn drop_without_shutdown(mut self) {
10347 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10349 std::mem::forget(self);
10351 }
10352}
10353
10354impl SocketSetSendBufferResponder {
10355 pub fn send(
10359 self,
10360 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10361 ) -> Result<(), fidl::Error> {
10362 let _result = self.send_raw(result);
10363 if _result.is_err() {
10364 self.control_handle.shutdown();
10365 }
10366 self.drop_without_shutdown();
10367 _result
10368 }
10369
10370 pub fn send_no_shutdown_on_err(
10372 self,
10373 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10374 ) -> Result<(), fidl::Error> {
10375 let _result = self.send_raw(result);
10376 self.drop_without_shutdown();
10377 _result
10378 }
10379
10380 fn send_raw(
10381 &self,
10382 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10383 ) -> Result<(), fidl::Error> {
10384 self.control_handle.inner.send::<fidl::encoding::ResultType<
10385 fidl::encoding::EmptyStruct,
10386 fidl_fuchsia_posix::Errno,
10387 >>(
10388 result,
10389 self.tx_id,
10390 0x756eac32d73a7a70,
10391 fidl::encoding::DynamicFlags::empty(),
10392 )
10393 }
10394}
10395
10396#[must_use = "FIDL methods require a response to be sent"]
10397#[derive(Debug)]
10398pub struct SocketGetSendBufferResponder {
10399 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10400 tx_id: u32,
10401}
10402
10403impl std::ops::Drop for SocketGetSendBufferResponder {
10407 fn drop(&mut self) {
10408 self.control_handle.shutdown();
10409 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10411 }
10412}
10413
10414impl fidl::endpoints::Responder for SocketGetSendBufferResponder {
10415 type ControlHandle = SocketControlHandle;
10416
10417 fn control_handle(&self) -> &SocketControlHandle {
10418 &self.control_handle
10419 }
10420
10421 fn drop_without_shutdown(mut self) {
10422 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10424 std::mem::forget(self);
10426 }
10427}
10428
10429impl SocketGetSendBufferResponder {
10430 pub fn send(
10434 self,
10435 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
10436 ) -> Result<(), fidl::Error> {
10437 let _result = self.send_raw(result);
10438 if _result.is_err() {
10439 self.control_handle.shutdown();
10440 }
10441 self.drop_without_shutdown();
10442 _result
10443 }
10444
10445 pub fn send_no_shutdown_on_err(
10447 self,
10448 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
10449 ) -> Result<(), fidl::Error> {
10450 let _result = self.send_raw(result);
10451 self.drop_without_shutdown();
10452 _result
10453 }
10454
10455 fn send_raw(
10456 &self,
10457 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
10458 ) -> Result<(), fidl::Error> {
10459 self.control_handle.inner.send::<fidl::encoding::ResultType<
10460 fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResponse,
10461 fidl_fuchsia_posix::Errno,
10462 >>(
10463 result.map(|value_bytes| (value_bytes,)),
10464 self.tx_id,
10465 0x78a52fd9c7b2410b,
10466 fidl::encoding::DynamicFlags::empty(),
10467 )
10468 }
10469}
10470
10471#[must_use = "FIDL methods require a response to be sent"]
10472#[derive(Debug)]
10473pub struct SocketSetReceiveBufferResponder {
10474 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10475 tx_id: u32,
10476}
10477
10478impl std::ops::Drop for SocketSetReceiveBufferResponder {
10482 fn drop(&mut self) {
10483 self.control_handle.shutdown();
10484 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10486 }
10487}
10488
10489impl fidl::endpoints::Responder for SocketSetReceiveBufferResponder {
10490 type ControlHandle = SocketControlHandle;
10491
10492 fn control_handle(&self) -> &SocketControlHandle {
10493 &self.control_handle
10494 }
10495
10496 fn drop_without_shutdown(mut self) {
10497 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10499 std::mem::forget(self);
10501 }
10502}
10503
10504impl SocketSetReceiveBufferResponder {
10505 pub fn send(
10509 self,
10510 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10511 ) -> Result<(), fidl::Error> {
10512 let _result = self.send_raw(result);
10513 if _result.is_err() {
10514 self.control_handle.shutdown();
10515 }
10516 self.drop_without_shutdown();
10517 _result
10518 }
10519
10520 pub fn send_no_shutdown_on_err(
10522 self,
10523 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10524 ) -> Result<(), fidl::Error> {
10525 let _result = self.send_raw(result);
10526 self.drop_without_shutdown();
10527 _result
10528 }
10529
10530 fn send_raw(
10531 &self,
10532 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10533 ) -> Result<(), fidl::Error> {
10534 self.control_handle.inner.send::<fidl::encoding::ResultType<
10535 fidl::encoding::EmptyStruct,
10536 fidl_fuchsia_posix::Errno,
10537 >>(
10538 result,
10539 self.tx_id,
10540 0x6b0cf2f1919c7001,
10541 fidl::encoding::DynamicFlags::empty(),
10542 )
10543 }
10544}
10545
10546#[must_use = "FIDL methods require a response to be sent"]
10547#[derive(Debug)]
10548pub struct SocketGetReceiveBufferResponder {
10549 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10550 tx_id: u32,
10551}
10552
10553impl std::ops::Drop for SocketGetReceiveBufferResponder {
10557 fn drop(&mut self) {
10558 self.control_handle.shutdown();
10559 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10561 }
10562}
10563
10564impl fidl::endpoints::Responder for SocketGetReceiveBufferResponder {
10565 type ControlHandle = SocketControlHandle;
10566
10567 fn control_handle(&self) -> &SocketControlHandle {
10568 &self.control_handle
10569 }
10570
10571 fn drop_without_shutdown(mut self) {
10572 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10574 std::mem::forget(self);
10576 }
10577}
10578
10579impl SocketGetReceiveBufferResponder {
10580 pub fn send(
10584 self,
10585 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
10586 ) -> Result<(), fidl::Error> {
10587 let _result = self.send_raw(result);
10588 if _result.is_err() {
10589 self.control_handle.shutdown();
10590 }
10591 self.drop_without_shutdown();
10592 _result
10593 }
10594
10595 pub fn send_no_shutdown_on_err(
10597 self,
10598 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
10599 ) -> Result<(), fidl::Error> {
10600 let _result = self.send_raw(result);
10601 self.drop_without_shutdown();
10602 _result
10603 }
10604
10605 fn send_raw(
10606 &self,
10607 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
10608 ) -> Result<(), fidl::Error> {
10609 self.control_handle.inner.send::<fidl::encoding::ResultType<
10610 fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResponse,
10611 fidl_fuchsia_posix::Errno,
10612 >>(
10613 result.map(|value_bytes| (value_bytes,)),
10614 self.tx_id,
10615 0x14c1a4b64f709e5c,
10616 fidl::encoding::DynamicFlags::empty(),
10617 )
10618 }
10619}
10620
10621#[must_use = "FIDL methods require a response to be sent"]
10622#[derive(Debug)]
10623pub struct SocketSetKeepAliveResponder {
10624 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10625 tx_id: u32,
10626}
10627
10628impl std::ops::Drop for SocketSetKeepAliveResponder {
10632 fn drop(&mut self) {
10633 self.control_handle.shutdown();
10634 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10636 }
10637}
10638
10639impl fidl::endpoints::Responder for SocketSetKeepAliveResponder {
10640 type ControlHandle = SocketControlHandle;
10641
10642 fn control_handle(&self) -> &SocketControlHandle {
10643 &self.control_handle
10644 }
10645
10646 fn drop_without_shutdown(mut self) {
10647 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10649 std::mem::forget(self);
10651 }
10652}
10653
10654impl SocketSetKeepAliveResponder {
10655 pub fn send(
10659 self,
10660 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10661 ) -> Result<(), fidl::Error> {
10662 let _result = self.send_raw(result);
10663 if _result.is_err() {
10664 self.control_handle.shutdown();
10665 }
10666 self.drop_without_shutdown();
10667 _result
10668 }
10669
10670 pub fn send_no_shutdown_on_err(
10672 self,
10673 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10674 ) -> Result<(), fidl::Error> {
10675 let _result = self.send_raw(result);
10676 self.drop_without_shutdown();
10677 _result
10678 }
10679
10680 fn send_raw(
10681 &self,
10682 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10683 ) -> Result<(), fidl::Error> {
10684 self.control_handle.inner.send::<fidl::encoding::ResultType<
10685 fidl::encoding::EmptyStruct,
10686 fidl_fuchsia_posix::Errno,
10687 >>(
10688 result,
10689 self.tx_id,
10690 0x572df8f0b920d2c7,
10691 fidl::encoding::DynamicFlags::empty(),
10692 )
10693 }
10694}
10695
10696#[must_use = "FIDL methods require a response to be sent"]
10697#[derive(Debug)]
10698pub struct SocketGetKeepAliveResponder {
10699 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10700 tx_id: u32,
10701}
10702
10703impl std::ops::Drop for SocketGetKeepAliveResponder {
10707 fn drop(&mut self) {
10708 self.control_handle.shutdown();
10709 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10711 }
10712}
10713
10714impl fidl::endpoints::Responder for SocketGetKeepAliveResponder {
10715 type ControlHandle = SocketControlHandle;
10716
10717 fn control_handle(&self) -> &SocketControlHandle {
10718 &self.control_handle
10719 }
10720
10721 fn drop_without_shutdown(mut self) {
10722 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10724 std::mem::forget(self);
10726 }
10727}
10728
10729impl SocketGetKeepAliveResponder {
10730 pub fn send(
10734 self,
10735 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10736 ) -> Result<(), fidl::Error> {
10737 let _result = self.send_raw(result);
10738 if _result.is_err() {
10739 self.control_handle.shutdown();
10740 }
10741 self.drop_without_shutdown();
10742 _result
10743 }
10744
10745 pub fn send_no_shutdown_on_err(
10747 self,
10748 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10749 ) -> Result<(), fidl::Error> {
10750 let _result = self.send_raw(result);
10751 self.drop_without_shutdown();
10752 _result
10753 }
10754
10755 fn send_raw(
10756 &self,
10757 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10758 ) -> Result<(), fidl::Error> {
10759 self.control_handle.inner.send::<fidl::encoding::ResultType<
10760 fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResponse,
10761 fidl_fuchsia_posix::Errno,
10762 >>(
10763 result.map(|value| (value,)),
10764 self.tx_id,
10765 0x2dd29d3215f2c9d2,
10766 fidl::encoding::DynamicFlags::empty(),
10767 )
10768 }
10769}
10770
10771#[must_use = "FIDL methods require a response to be sent"]
10772#[derive(Debug)]
10773pub struct SocketSetOutOfBandInlineResponder {
10774 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10775 tx_id: u32,
10776}
10777
10778impl std::ops::Drop for SocketSetOutOfBandInlineResponder {
10782 fn drop(&mut self) {
10783 self.control_handle.shutdown();
10784 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10786 }
10787}
10788
10789impl fidl::endpoints::Responder for SocketSetOutOfBandInlineResponder {
10790 type ControlHandle = SocketControlHandle;
10791
10792 fn control_handle(&self) -> &SocketControlHandle {
10793 &self.control_handle
10794 }
10795
10796 fn drop_without_shutdown(mut self) {
10797 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10799 std::mem::forget(self);
10801 }
10802}
10803
10804impl SocketSetOutOfBandInlineResponder {
10805 pub fn send(
10809 self,
10810 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10811 ) -> Result<(), fidl::Error> {
10812 let _result = self.send_raw(result);
10813 if _result.is_err() {
10814 self.control_handle.shutdown();
10815 }
10816 self.drop_without_shutdown();
10817 _result
10818 }
10819
10820 pub fn send_no_shutdown_on_err(
10822 self,
10823 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10824 ) -> Result<(), fidl::Error> {
10825 let _result = self.send_raw(result);
10826 self.drop_without_shutdown();
10827 _result
10828 }
10829
10830 fn send_raw(
10831 &self,
10832 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10833 ) -> Result<(), fidl::Error> {
10834 self.control_handle.inner.send::<fidl::encoding::ResultType<
10835 fidl::encoding::EmptyStruct,
10836 fidl_fuchsia_posix::Errno,
10837 >>(
10838 result,
10839 self.tx_id,
10840 0x3ecb49968bee439,
10841 fidl::encoding::DynamicFlags::empty(),
10842 )
10843 }
10844}
10845
10846#[must_use = "FIDL methods require a response to be sent"]
10847#[derive(Debug)]
10848pub struct SocketGetOutOfBandInlineResponder {
10849 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10850 tx_id: u32,
10851}
10852
10853impl std::ops::Drop for SocketGetOutOfBandInlineResponder {
10857 fn drop(&mut self) {
10858 self.control_handle.shutdown();
10859 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10861 }
10862}
10863
10864impl fidl::endpoints::Responder for SocketGetOutOfBandInlineResponder {
10865 type ControlHandle = SocketControlHandle;
10866
10867 fn control_handle(&self) -> &SocketControlHandle {
10868 &self.control_handle
10869 }
10870
10871 fn drop_without_shutdown(mut self) {
10872 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10874 std::mem::forget(self);
10876 }
10877}
10878
10879impl SocketGetOutOfBandInlineResponder {
10880 pub fn send(
10884 self,
10885 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10886 ) -> Result<(), fidl::Error> {
10887 let _result = self.send_raw(result);
10888 if _result.is_err() {
10889 self.control_handle.shutdown();
10890 }
10891 self.drop_without_shutdown();
10892 _result
10893 }
10894
10895 pub fn send_no_shutdown_on_err(
10897 self,
10898 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10899 ) -> Result<(), fidl::Error> {
10900 let _result = self.send_raw(result);
10901 self.drop_without_shutdown();
10902 _result
10903 }
10904
10905 fn send_raw(
10906 &self,
10907 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10908 ) -> Result<(), fidl::Error> {
10909 self.control_handle.inner.send::<fidl::encoding::ResultType<
10910 fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResponse,
10911 fidl_fuchsia_posix::Errno,
10912 >>(
10913 result.map(|value| (value,)),
10914 self.tx_id,
10915 0x348c1ab3aeca1745,
10916 fidl::encoding::DynamicFlags::empty(),
10917 )
10918 }
10919}
10920
10921#[must_use = "FIDL methods require a response to be sent"]
10922#[derive(Debug)]
10923pub struct SocketSetNoCheckResponder {
10924 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10925 tx_id: u32,
10926}
10927
10928impl std::ops::Drop for SocketSetNoCheckResponder {
10932 fn drop(&mut self) {
10933 self.control_handle.shutdown();
10934 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10936 }
10937}
10938
10939impl fidl::endpoints::Responder for SocketSetNoCheckResponder {
10940 type ControlHandle = SocketControlHandle;
10941
10942 fn control_handle(&self) -> &SocketControlHandle {
10943 &self.control_handle
10944 }
10945
10946 fn drop_without_shutdown(mut self) {
10947 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10949 std::mem::forget(self);
10951 }
10952}
10953
10954impl SocketSetNoCheckResponder {
10955 pub fn send(
10959 self,
10960 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10961 ) -> Result<(), fidl::Error> {
10962 let _result = self.send_raw(result);
10963 if _result.is_err() {
10964 self.control_handle.shutdown();
10965 }
10966 self.drop_without_shutdown();
10967 _result
10968 }
10969
10970 pub fn send_no_shutdown_on_err(
10972 self,
10973 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10974 ) -> Result<(), fidl::Error> {
10975 let _result = self.send_raw(result);
10976 self.drop_without_shutdown();
10977 _result
10978 }
10979
10980 fn send_raw(
10981 &self,
10982 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10983 ) -> Result<(), fidl::Error> {
10984 self.control_handle.inner.send::<fidl::encoding::ResultType<
10985 fidl::encoding::EmptyStruct,
10986 fidl_fuchsia_posix::Errno,
10987 >>(
10988 result,
10989 self.tx_id,
10990 0x6bbf00c53a4c78c2,
10991 fidl::encoding::DynamicFlags::empty(),
10992 )
10993 }
10994}
10995
10996#[must_use = "FIDL methods require a response to be sent"]
10997#[derive(Debug)]
10998pub struct SocketGetNoCheckResponder {
10999 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11000 tx_id: u32,
11001}
11002
11003impl std::ops::Drop for SocketGetNoCheckResponder {
11007 fn drop(&mut self) {
11008 self.control_handle.shutdown();
11009 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11011 }
11012}
11013
11014impl fidl::endpoints::Responder for SocketGetNoCheckResponder {
11015 type ControlHandle = SocketControlHandle;
11016
11017 fn control_handle(&self) -> &SocketControlHandle {
11018 &self.control_handle
11019 }
11020
11021 fn drop_without_shutdown(mut self) {
11022 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11024 std::mem::forget(self);
11026 }
11027}
11028
11029impl SocketGetNoCheckResponder {
11030 pub fn send(
11034 self,
11035 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11036 ) -> Result<(), fidl::Error> {
11037 let _result = self.send_raw(result);
11038 if _result.is_err() {
11039 self.control_handle.shutdown();
11040 }
11041 self.drop_without_shutdown();
11042 _result
11043 }
11044
11045 pub fn send_no_shutdown_on_err(
11047 self,
11048 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11049 ) -> Result<(), fidl::Error> {
11050 let _result = self.send_raw(result);
11051 self.drop_without_shutdown();
11052 _result
11053 }
11054
11055 fn send_raw(
11056 &self,
11057 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11058 ) -> Result<(), fidl::Error> {
11059 self.control_handle.inner.send::<fidl::encoding::ResultType<
11060 fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResponse,
11061 fidl_fuchsia_posix::Errno,
11062 >>(
11063 result.map(|value| (value,)),
11064 self.tx_id,
11065 0x2cd4249286417694,
11066 fidl::encoding::DynamicFlags::empty(),
11067 )
11068 }
11069}
11070
11071#[must_use = "FIDL methods require a response to be sent"]
11072#[derive(Debug)]
11073pub struct SocketSetLingerResponder {
11074 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11075 tx_id: u32,
11076}
11077
11078impl std::ops::Drop for SocketSetLingerResponder {
11082 fn drop(&mut self) {
11083 self.control_handle.shutdown();
11084 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11086 }
11087}
11088
11089impl fidl::endpoints::Responder for SocketSetLingerResponder {
11090 type ControlHandle = SocketControlHandle;
11091
11092 fn control_handle(&self) -> &SocketControlHandle {
11093 &self.control_handle
11094 }
11095
11096 fn drop_without_shutdown(mut self) {
11097 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11099 std::mem::forget(self);
11101 }
11102}
11103
11104impl SocketSetLingerResponder {
11105 pub fn send(
11109 self,
11110 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11111 ) -> Result<(), fidl::Error> {
11112 let _result = self.send_raw(result);
11113 if _result.is_err() {
11114 self.control_handle.shutdown();
11115 }
11116 self.drop_without_shutdown();
11117 _result
11118 }
11119
11120 pub fn send_no_shutdown_on_err(
11122 self,
11123 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11124 ) -> Result<(), fidl::Error> {
11125 let _result = self.send_raw(result);
11126 self.drop_without_shutdown();
11127 _result
11128 }
11129
11130 fn send_raw(
11131 &self,
11132 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11133 ) -> Result<(), fidl::Error> {
11134 self.control_handle.inner.send::<fidl::encoding::ResultType<
11135 fidl::encoding::EmptyStruct,
11136 fidl_fuchsia_posix::Errno,
11137 >>(
11138 result,
11139 self.tx_id,
11140 0x45386351246e998e,
11141 fidl::encoding::DynamicFlags::empty(),
11142 )
11143 }
11144}
11145
11146#[must_use = "FIDL methods require a response to be sent"]
11147#[derive(Debug)]
11148pub struct SocketGetLingerResponder {
11149 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11150 tx_id: u32,
11151}
11152
11153impl std::ops::Drop for SocketGetLingerResponder {
11157 fn drop(&mut self) {
11158 self.control_handle.shutdown();
11159 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11161 }
11162}
11163
11164impl fidl::endpoints::Responder for SocketGetLingerResponder {
11165 type ControlHandle = SocketControlHandle;
11166
11167 fn control_handle(&self) -> &SocketControlHandle {
11168 &self.control_handle
11169 }
11170
11171 fn drop_without_shutdown(mut self) {
11172 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11174 std::mem::forget(self);
11176 }
11177}
11178
11179impl SocketGetLingerResponder {
11180 pub fn send(
11184 self,
11185 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
11186 ) -> Result<(), fidl::Error> {
11187 let _result = self.send_raw(result);
11188 if _result.is_err() {
11189 self.control_handle.shutdown();
11190 }
11191 self.drop_without_shutdown();
11192 _result
11193 }
11194
11195 pub fn send_no_shutdown_on_err(
11197 self,
11198 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
11199 ) -> Result<(), fidl::Error> {
11200 let _result = self.send_raw(result);
11201 self.drop_without_shutdown();
11202 _result
11203 }
11204
11205 fn send_raw(
11206 &self,
11207 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
11208 ) -> Result<(), fidl::Error> {
11209 self.control_handle.inner.send::<fidl::encoding::ResultType<
11210 fidl_fuchsia_posix_socket::BaseSocketGetLingerResponse,
11211 fidl_fuchsia_posix::Errno,
11212 >>(
11213 result,
11214 self.tx_id,
11215 0x48eb20fc5ccb0e45,
11216 fidl::encoding::DynamicFlags::empty(),
11217 )
11218 }
11219}
11220
11221#[must_use = "FIDL methods require a response to be sent"]
11222#[derive(Debug)]
11223pub struct SocketSetReusePortResponder {
11224 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11225 tx_id: u32,
11226}
11227
11228impl std::ops::Drop for SocketSetReusePortResponder {
11232 fn drop(&mut self) {
11233 self.control_handle.shutdown();
11234 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11236 }
11237}
11238
11239impl fidl::endpoints::Responder for SocketSetReusePortResponder {
11240 type ControlHandle = SocketControlHandle;
11241
11242 fn control_handle(&self) -> &SocketControlHandle {
11243 &self.control_handle
11244 }
11245
11246 fn drop_without_shutdown(mut self) {
11247 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11249 std::mem::forget(self);
11251 }
11252}
11253
11254impl SocketSetReusePortResponder {
11255 pub fn send(
11259 self,
11260 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11261 ) -> Result<(), fidl::Error> {
11262 let _result = self.send_raw(result);
11263 if _result.is_err() {
11264 self.control_handle.shutdown();
11265 }
11266 self.drop_without_shutdown();
11267 _result
11268 }
11269
11270 pub fn send_no_shutdown_on_err(
11272 self,
11273 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11274 ) -> Result<(), fidl::Error> {
11275 let _result = self.send_raw(result);
11276 self.drop_without_shutdown();
11277 _result
11278 }
11279
11280 fn send_raw(
11281 &self,
11282 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11283 ) -> Result<(), fidl::Error> {
11284 self.control_handle.inner.send::<fidl::encoding::ResultType<
11285 fidl::encoding::EmptyStruct,
11286 fidl_fuchsia_posix::Errno,
11287 >>(
11288 result,
11289 self.tx_id,
11290 0x24dd3e5cb36d9ccb,
11291 fidl::encoding::DynamicFlags::empty(),
11292 )
11293 }
11294}
11295
11296#[must_use = "FIDL methods require a response to be sent"]
11297#[derive(Debug)]
11298pub struct SocketGetReusePortResponder {
11299 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11300 tx_id: u32,
11301}
11302
11303impl std::ops::Drop for SocketGetReusePortResponder {
11307 fn drop(&mut self) {
11308 self.control_handle.shutdown();
11309 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11311 }
11312}
11313
11314impl fidl::endpoints::Responder for SocketGetReusePortResponder {
11315 type ControlHandle = SocketControlHandle;
11316
11317 fn control_handle(&self) -> &SocketControlHandle {
11318 &self.control_handle
11319 }
11320
11321 fn drop_without_shutdown(mut self) {
11322 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11324 std::mem::forget(self);
11326 }
11327}
11328
11329impl SocketGetReusePortResponder {
11330 pub fn send(
11334 self,
11335 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11336 ) -> Result<(), fidl::Error> {
11337 let _result = self.send_raw(result);
11338 if _result.is_err() {
11339 self.control_handle.shutdown();
11340 }
11341 self.drop_without_shutdown();
11342 _result
11343 }
11344
11345 pub fn send_no_shutdown_on_err(
11347 self,
11348 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11349 ) -> Result<(), fidl::Error> {
11350 let _result = self.send_raw(result);
11351 self.drop_without_shutdown();
11352 _result
11353 }
11354
11355 fn send_raw(
11356 &self,
11357 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11358 ) -> Result<(), fidl::Error> {
11359 self.control_handle.inner.send::<fidl::encoding::ResultType<
11360 fidl_fuchsia_posix_socket::BaseSocketGetReusePortResponse,
11361 fidl_fuchsia_posix::Errno,
11362 >>(
11363 result.map(|value| (value,)),
11364 self.tx_id,
11365 0x7a112c1ab54ff828,
11366 fidl::encoding::DynamicFlags::empty(),
11367 )
11368 }
11369}
11370
11371#[must_use = "FIDL methods require a response to be sent"]
11372#[derive(Debug)]
11373pub struct SocketGetAcceptConnResponder {
11374 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11375 tx_id: u32,
11376}
11377
11378impl std::ops::Drop for SocketGetAcceptConnResponder {
11382 fn drop(&mut self) {
11383 self.control_handle.shutdown();
11384 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11386 }
11387}
11388
11389impl fidl::endpoints::Responder for SocketGetAcceptConnResponder {
11390 type ControlHandle = SocketControlHandle;
11391
11392 fn control_handle(&self) -> &SocketControlHandle {
11393 &self.control_handle
11394 }
11395
11396 fn drop_without_shutdown(mut self) {
11397 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11399 std::mem::forget(self);
11401 }
11402}
11403
11404impl SocketGetAcceptConnResponder {
11405 pub fn send(
11409 self,
11410 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11411 ) -> Result<(), fidl::Error> {
11412 let _result = self.send_raw(result);
11413 if _result.is_err() {
11414 self.control_handle.shutdown();
11415 }
11416 self.drop_without_shutdown();
11417 _result
11418 }
11419
11420 pub fn send_no_shutdown_on_err(
11422 self,
11423 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11424 ) -> Result<(), fidl::Error> {
11425 let _result = self.send_raw(result);
11426 self.drop_without_shutdown();
11427 _result
11428 }
11429
11430 fn send_raw(
11431 &self,
11432 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11433 ) -> Result<(), fidl::Error> {
11434 self.control_handle.inner.send::<fidl::encoding::ResultType<
11435 fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResponse,
11436 fidl_fuchsia_posix::Errno,
11437 >>(
11438 result.map(|value| (value,)),
11439 self.tx_id,
11440 0x67ce6db6c2ec8966,
11441 fidl::encoding::DynamicFlags::empty(),
11442 )
11443 }
11444}
11445
11446#[must_use = "FIDL methods require a response to be sent"]
11447#[derive(Debug)]
11448pub struct SocketSetBindToDeviceResponder {
11449 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11450 tx_id: u32,
11451}
11452
11453impl std::ops::Drop for SocketSetBindToDeviceResponder {
11457 fn drop(&mut self) {
11458 self.control_handle.shutdown();
11459 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11461 }
11462}
11463
11464impl fidl::endpoints::Responder for SocketSetBindToDeviceResponder {
11465 type ControlHandle = SocketControlHandle;
11466
11467 fn control_handle(&self) -> &SocketControlHandle {
11468 &self.control_handle
11469 }
11470
11471 fn drop_without_shutdown(mut self) {
11472 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11474 std::mem::forget(self);
11476 }
11477}
11478
11479impl SocketSetBindToDeviceResponder {
11480 pub fn send(
11484 self,
11485 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11486 ) -> Result<(), fidl::Error> {
11487 let _result = self.send_raw(result);
11488 if _result.is_err() {
11489 self.control_handle.shutdown();
11490 }
11491 self.drop_without_shutdown();
11492 _result
11493 }
11494
11495 pub fn send_no_shutdown_on_err(
11497 self,
11498 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11499 ) -> Result<(), fidl::Error> {
11500 let _result = self.send_raw(result);
11501 self.drop_without_shutdown();
11502 _result
11503 }
11504
11505 fn send_raw(
11506 &self,
11507 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11508 ) -> Result<(), fidl::Error> {
11509 self.control_handle.inner.send::<fidl::encoding::ResultType<
11510 fidl::encoding::EmptyStruct,
11511 fidl_fuchsia_posix::Errno,
11512 >>(
11513 result,
11514 self.tx_id,
11515 0x2118b483f28aafc4,
11516 fidl::encoding::DynamicFlags::empty(),
11517 )
11518 }
11519}
11520
11521#[must_use = "FIDL methods require a response to be sent"]
11522#[derive(Debug)]
11523pub struct SocketGetBindToDeviceResponder {
11524 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11525 tx_id: u32,
11526}
11527
11528impl std::ops::Drop for SocketGetBindToDeviceResponder {
11532 fn drop(&mut self) {
11533 self.control_handle.shutdown();
11534 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11536 }
11537}
11538
11539impl fidl::endpoints::Responder for SocketGetBindToDeviceResponder {
11540 type ControlHandle = SocketControlHandle;
11541
11542 fn control_handle(&self) -> &SocketControlHandle {
11543 &self.control_handle
11544 }
11545
11546 fn drop_without_shutdown(mut self) {
11547 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11549 std::mem::forget(self);
11551 }
11552}
11553
11554impl SocketGetBindToDeviceResponder {
11555 pub fn send(
11559 self,
11560 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
11561 ) -> Result<(), fidl::Error> {
11562 let _result = self.send_raw(result);
11563 if _result.is_err() {
11564 self.control_handle.shutdown();
11565 }
11566 self.drop_without_shutdown();
11567 _result
11568 }
11569
11570 pub fn send_no_shutdown_on_err(
11572 self,
11573 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
11574 ) -> Result<(), fidl::Error> {
11575 let _result = self.send_raw(result);
11576 self.drop_without_shutdown();
11577 _result
11578 }
11579
11580 fn send_raw(
11581 &self,
11582 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
11583 ) -> Result<(), fidl::Error> {
11584 self.control_handle.inner.send::<fidl::encoding::ResultType<
11585 fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResponse,
11586 fidl_fuchsia_posix::Errno,
11587 >>(
11588 result.map(|value| (value,)),
11589 self.tx_id,
11590 0x1ab1fbf0ef7906c8,
11591 fidl::encoding::DynamicFlags::empty(),
11592 )
11593 }
11594}
11595
11596#[must_use = "FIDL methods require a response to be sent"]
11597#[derive(Debug)]
11598pub struct SocketSetBindToInterfaceIndexResponder {
11599 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11600 tx_id: u32,
11601}
11602
11603impl std::ops::Drop for SocketSetBindToInterfaceIndexResponder {
11607 fn drop(&mut self) {
11608 self.control_handle.shutdown();
11609 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11611 }
11612}
11613
11614impl fidl::endpoints::Responder for SocketSetBindToInterfaceIndexResponder {
11615 type ControlHandle = SocketControlHandle;
11616
11617 fn control_handle(&self) -> &SocketControlHandle {
11618 &self.control_handle
11619 }
11620
11621 fn drop_without_shutdown(mut self) {
11622 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11624 std::mem::forget(self);
11626 }
11627}
11628
11629impl SocketSetBindToInterfaceIndexResponder {
11630 pub fn send(
11634 self,
11635 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11636 ) -> Result<(), fidl::Error> {
11637 let _result = self.send_raw(result);
11638 if _result.is_err() {
11639 self.control_handle.shutdown();
11640 }
11641 self.drop_without_shutdown();
11642 _result
11643 }
11644
11645 pub fn send_no_shutdown_on_err(
11647 self,
11648 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11649 ) -> Result<(), fidl::Error> {
11650 let _result = self.send_raw(result);
11651 self.drop_without_shutdown();
11652 _result
11653 }
11654
11655 fn send_raw(
11656 &self,
11657 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11658 ) -> Result<(), fidl::Error> {
11659 self.control_handle.inner.send::<fidl::encoding::ResultType<
11660 fidl::encoding::EmptyStruct,
11661 fidl_fuchsia_posix::Errno,
11662 >>(
11663 result,
11664 self.tx_id,
11665 0x6e387a0def00821,
11666 fidl::encoding::DynamicFlags::empty(),
11667 )
11668 }
11669}
11670
11671#[must_use = "FIDL methods require a response to be sent"]
11672#[derive(Debug)]
11673pub struct SocketGetBindToInterfaceIndexResponder {
11674 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11675 tx_id: u32,
11676}
11677
11678impl std::ops::Drop for SocketGetBindToInterfaceIndexResponder {
11682 fn drop(&mut self) {
11683 self.control_handle.shutdown();
11684 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11686 }
11687}
11688
11689impl fidl::endpoints::Responder for SocketGetBindToInterfaceIndexResponder {
11690 type ControlHandle = SocketControlHandle;
11691
11692 fn control_handle(&self) -> &SocketControlHandle {
11693 &self.control_handle
11694 }
11695
11696 fn drop_without_shutdown(mut self) {
11697 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11699 std::mem::forget(self);
11701 }
11702}
11703
11704impl SocketGetBindToInterfaceIndexResponder {
11705 pub fn send(
11709 self,
11710 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
11711 ) -> Result<(), fidl::Error> {
11712 let _result = self.send_raw(result);
11713 if _result.is_err() {
11714 self.control_handle.shutdown();
11715 }
11716 self.drop_without_shutdown();
11717 _result
11718 }
11719
11720 pub fn send_no_shutdown_on_err(
11722 self,
11723 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
11724 ) -> Result<(), fidl::Error> {
11725 let _result = self.send_raw(result);
11726 self.drop_without_shutdown();
11727 _result
11728 }
11729
11730 fn send_raw(
11731 &self,
11732 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
11733 ) -> Result<(), fidl::Error> {
11734 self.control_handle.inner.send::<fidl::encoding::ResultType<
11735 fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResponse,
11736 fidl_fuchsia_posix::Errno,
11737 >>(
11738 result.map(|value| (value,)),
11739 self.tx_id,
11740 0x59c31dd3e3078295,
11741 fidl::encoding::DynamicFlags::empty(),
11742 )
11743 }
11744}
11745
11746#[must_use = "FIDL methods require a response to be sent"]
11747#[derive(Debug)]
11748pub struct SocketSetTimestampResponder {
11749 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11750 tx_id: u32,
11751}
11752
11753impl std::ops::Drop for SocketSetTimestampResponder {
11757 fn drop(&mut self) {
11758 self.control_handle.shutdown();
11759 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11761 }
11762}
11763
11764impl fidl::endpoints::Responder for SocketSetTimestampResponder {
11765 type ControlHandle = SocketControlHandle;
11766
11767 fn control_handle(&self) -> &SocketControlHandle {
11768 &self.control_handle
11769 }
11770
11771 fn drop_without_shutdown(mut self) {
11772 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11774 std::mem::forget(self);
11776 }
11777}
11778
11779impl SocketSetTimestampResponder {
11780 pub fn send(
11784 self,
11785 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11786 ) -> Result<(), fidl::Error> {
11787 let _result = self.send_raw(result);
11788 if _result.is_err() {
11789 self.control_handle.shutdown();
11790 }
11791 self.drop_without_shutdown();
11792 _result
11793 }
11794
11795 pub fn send_no_shutdown_on_err(
11797 self,
11798 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11799 ) -> Result<(), fidl::Error> {
11800 let _result = self.send_raw(result);
11801 self.drop_without_shutdown();
11802 _result
11803 }
11804
11805 fn send_raw(
11806 &self,
11807 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11808 ) -> Result<(), fidl::Error> {
11809 self.control_handle.inner.send::<fidl::encoding::ResultType<
11810 fidl::encoding::EmptyStruct,
11811 fidl_fuchsia_posix::Errno,
11812 >>(
11813 result,
11814 self.tx_id,
11815 0x285d6516c263d839,
11816 fidl::encoding::DynamicFlags::empty(),
11817 )
11818 }
11819}
11820
11821#[must_use = "FIDL methods require a response to be sent"]
11822#[derive(Debug)]
11823pub struct SocketGetTimestampResponder {
11824 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11825 tx_id: u32,
11826}
11827
11828impl std::ops::Drop for SocketGetTimestampResponder {
11832 fn drop(&mut self) {
11833 self.control_handle.shutdown();
11834 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11836 }
11837}
11838
11839impl fidl::endpoints::Responder for SocketGetTimestampResponder {
11840 type ControlHandle = SocketControlHandle;
11841
11842 fn control_handle(&self) -> &SocketControlHandle {
11843 &self.control_handle
11844 }
11845
11846 fn drop_without_shutdown(mut self) {
11847 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11849 std::mem::forget(self);
11851 }
11852}
11853
11854impl SocketGetTimestampResponder {
11855 pub fn send(
11859 self,
11860 mut result: Result<fidl_fuchsia_posix_socket::TimestampOption, fidl_fuchsia_posix::Errno>,
11861 ) -> Result<(), fidl::Error> {
11862 let _result = self.send_raw(result);
11863 if _result.is_err() {
11864 self.control_handle.shutdown();
11865 }
11866 self.drop_without_shutdown();
11867 _result
11868 }
11869
11870 pub fn send_no_shutdown_on_err(
11872 self,
11873 mut result: Result<fidl_fuchsia_posix_socket::TimestampOption, fidl_fuchsia_posix::Errno>,
11874 ) -> Result<(), fidl::Error> {
11875 let _result = self.send_raw(result);
11876 self.drop_without_shutdown();
11877 _result
11878 }
11879
11880 fn send_raw(
11881 &self,
11882 mut result: Result<fidl_fuchsia_posix_socket::TimestampOption, fidl_fuchsia_posix::Errno>,
11883 ) -> Result<(), fidl::Error> {
11884 self.control_handle.inner.send::<fidl::encoding::ResultType<
11885 fidl_fuchsia_posix_socket::BaseSocketGetTimestampResponse,
11886 fidl_fuchsia_posix::Errno,
11887 >>(
11888 result.map(|value| (value,)),
11889 self.tx_id,
11890 0x49f2fffbbcc2bd27,
11891 fidl::encoding::DynamicFlags::empty(),
11892 )
11893 }
11894}
11895
11896#[must_use = "FIDL methods require a response to be sent"]
11897#[derive(Debug)]
11898pub struct SocketSetMarkResponder {
11899 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11900 tx_id: u32,
11901}
11902
11903impl std::ops::Drop for SocketSetMarkResponder {
11907 fn drop(&mut self) {
11908 self.control_handle.shutdown();
11909 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11911 }
11912}
11913
11914impl fidl::endpoints::Responder for SocketSetMarkResponder {
11915 type ControlHandle = SocketControlHandle;
11916
11917 fn control_handle(&self) -> &SocketControlHandle {
11918 &self.control_handle
11919 }
11920
11921 fn drop_without_shutdown(mut self) {
11922 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11924 std::mem::forget(self);
11926 }
11927}
11928
11929impl SocketSetMarkResponder {
11930 pub fn send(
11934 self,
11935 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11936 ) -> Result<(), fidl::Error> {
11937 let _result = self.send_raw(result);
11938 if _result.is_err() {
11939 self.control_handle.shutdown();
11940 }
11941 self.drop_without_shutdown();
11942 _result
11943 }
11944
11945 pub fn send_no_shutdown_on_err(
11947 self,
11948 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11949 ) -> Result<(), fidl::Error> {
11950 let _result = self.send_raw(result);
11951 self.drop_without_shutdown();
11952 _result
11953 }
11954
11955 fn send_raw(
11956 &self,
11957 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11958 ) -> Result<(), fidl::Error> {
11959 self.control_handle.inner.send::<fidl::encoding::ResultType<
11960 fidl::encoding::EmptyStruct,
11961 fidl_fuchsia_posix::Errno,
11962 >>(
11963 result,
11964 self.tx_id,
11965 0x6ead6de09f653236,
11966 fidl::encoding::DynamicFlags::empty(),
11967 )
11968 }
11969}
11970
11971#[must_use = "FIDL methods require a response to be sent"]
11972#[derive(Debug)]
11973pub struct SocketGetMarkResponder {
11974 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11975 tx_id: u32,
11976}
11977
11978impl std::ops::Drop for SocketGetMarkResponder {
11982 fn drop(&mut self) {
11983 self.control_handle.shutdown();
11984 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11986 }
11987}
11988
11989impl fidl::endpoints::Responder for SocketGetMarkResponder {
11990 type ControlHandle = SocketControlHandle;
11991
11992 fn control_handle(&self) -> &SocketControlHandle {
11993 &self.control_handle
11994 }
11995
11996 fn drop_without_shutdown(mut self) {
11997 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11999 std::mem::forget(self);
12001 }
12002}
12003
12004impl SocketGetMarkResponder {
12005 pub fn send(
12009 self,
12010 mut result: Result<&fidl_fuchsia_posix_socket::OptionalUint32, fidl_fuchsia_posix::Errno>,
12011 ) -> Result<(), fidl::Error> {
12012 let _result = self.send_raw(result);
12013 if _result.is_err() {
12014 self.control_handle.shutdown();
12015 }
12016 self.drop_without_shutdown();
12017 _result
12018 }
12019
12020 pub fn send_no_shutdown_on_err(
12022 self,
12023 mut result: Result<&fidl_fuchsia_posix_socket::OptionalUint32, fidl_fuchsia_posix::Errno>,
12024 ) -> Result<(), fidl::Error> {
12025 let _result = self.send_raw(result);
12026 self.drop_without_shutdown();
12027 _result
12028 }
12029
12030 fn send_raw(
12031 &self,
12032 mut result: Result<&fidl_fuchsia_posix_socket::OptionalUint32, fidl_fuchsia_posix::Errno>,
12033 ) -> Result<(), fidl::Error> {
12034 self.control_handle.inner.send::<fidl::encoding::ResultType<
12035 fidl_fuchsia_posix_socket::BaseSocketGetMarkResponse,
12036 fidl_fuchsia_posix::Errno,
12037 >>(
12038 result.map(|mark| (mark,)),
12039 self.tx_id,
12040 0x57a2752c61d93d47,
12041 fidl::encoding::DynamicFlags::empty(),
12042 )
12043 }
12044}
12045
12046#[must_use = "FIDL methods require a response to be sent"]
12047#[derive(Debug)]
12048pub struct SocketGetCookieResponder {
12049 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12050 tx_id: u32,
12051}
12052
12053impl std::ops::Drop for SocketGetCookieResponder {
12057 fn drop(&mut self) {
12058 self.control_handle.shutdown();
12059 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12061 }
12062}
12063
12064impl fidl::endpoints::Responder for SocketGetCookieResponder {
12065 type ControlHandle = SocketControlHandle;
12066
12067 fn control_handle(&self) -> &SocketControlHandle {
12068 &self.control_handle
12069 }
12070
12071 fn drop_without_shutdown(mut self) {
12072 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12074 std::mem::forget(self);
12076 }
12077}
12078
12079impl SocketGetCookieResponder {
12080 pub fn send(
12084 self,
12085 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
12086 ) -> Result<(), fidl::Error> {
12087 let _result = self.send_raw(result);
12088 if _result.is_err() {
12089 self.control_handle.shutdown();
12090 }
12091 self.drop_without_shutdown();
12092 _result
12093 }
12094
12095 pub fn send_no_shutdown_on_err(
12097 self,
12098 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
12099 ) -> Result<(), fidl::Error> {
12100 let _result = self.send_raw(result);
12101 self.drop_without_shutdown();
12102 _result
12103 }
12104
12105 fn send_raw(
12106 &self,
12107 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
12108 ) -> Result<(), fidl::Error> {
12109 self.control_handle.inner.send::<fidl::encoding::ResultType<
12110 fidl_fuchsia_posix_socket::BaseSocketGetCookieResponse,
12111 fidl_fuchsia_posix::Errno,
12112 >>(
12113 result.map(|value| (value,)),
12114 self.tx_id,
12115 0x2c2f47fd8f924e52,
12116 fidl::encoding::DynamicFlags::empty(),
12117 )
12118 }
12119}
12120
12121#[must_use = "FIDL methods require a response to be sent"]
12122#[derive(Debug)]
12123pub struct SocketBindResponder {
12124 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12125 tx_id: u32,
12126}
12127
12128impl std::ops::Drop for SocketBindResponder {
12132 fn drop(&mut self) {
12133 self.control_handle.shutdown();
12134 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12136 }
12137}
12138
12139impl fidl::endpoints::Responder for SocketBindResponder {
12140 type ControlHandle = SocketControlHandle;
12141
12142 fn control_handle(&self) -> &SocketControlHandle {
12143 &self.control_handle
12144 }
12145
12146 fn drop_without_shutdown(mut self) {
12147 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12149 std::mem::forget(self);
12151 }
12152}
12153
12154impl SocketBindResponder {
12155 pub fn send(
12159 self,
12160 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12161 ) -> Result<(), fidl::Error> {
12162 let _result = self.send_raw(result);
12163 if _result.is_err() {
12164 self.control_handle.shutdown();
12165 }
12166 self.drop_without_shutdown();
12167 _result
12168 }
12169
12170 pub fn send_no_shutdown_on_err(
12172 self,
12173 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12174 ) -> Result<(), fidl::Error> {
12175 let _result = self.send_raw(result);
12176 self.drop_without_shutdown();
12177 _result
12178 }
12179
12180 fn send_raw(
12181 &self,
12182 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12183 ) -> Result<(), fidl::Error> {
12184 self.control_handle.inner.send::<fidl::encoding::ResultType<
12185 fidl::encoding::EmptyStruct,
12186 fidl_fuchsia_posix::Errno,
12187 >>(
12188 result,
12189 self.tx_id,
12190 0x4bc6400ae92125d,
12191 fidl::encoding::DynamicFlags::empty(),
12192 )
12193 }
12194}
12195
12196#[must_use = "FIDL methods require a response to be sent"]
12197#[derive(Debug)]
12198pub struct SocketConnectResponder {
12199 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12200 tx_id: u32,
12201}
12202
12203impl std::ops::Drop for SocketConnectResponder {
12207 fn drop(&mut self) {
12208 self.control_handle.shutdown();
12209 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12211 }
12212}
12213
12214impl fidl::endpoints::Responder for SocketConnectResponder {
12215 type ControlHandle = SocketControlHandle;
12216
12217 fn control_handle(&self) -> &SocketControlHandle {
12218 &self.control_handle
12219 }
12220
12221 fn drop_without_shutdown(mut self) {
12222 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12224 std::mem::forget(self);
12226 }
12227}
12228
12229impl SocketConnectResponder {
12230 pub fn send(
12234 self,
12235 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12236 ) -> Result<(), fidl::Error> {
12237 let _result = self.send_raw(result);
12238 if _result.is_err() {
12239 self.control_handle.shutdown();
12240 }
12241 self.drop_without_shutdown();
12242 _result
12243 }
12244
12245 pub fn send_no_shutdown_on_err(
12247 self,
12248 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12249 ) -> Result<(), fidl::Error> {
12250 let _result = self.send_raw(result);
12251 self.drop_without_shutdown();
12252 _result
12253 }
12254
12255 fn send_raw(
12256 &self,
12257 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12258 ) -> Result<(), fidl::Error> {
12259 self.control_handle.inner.send::<fidl::encoding::ResultType<
12260 fidl::encoding::EmptyStruct,
12261 fidl_fuchsia_posix::Errno,
12262 >>(
12263 result,
12264 self.tx_id,
12265 0x5f05f19bfdd38871,
12266 fidl::encoding::DynamicFlags::empty(),
12267 )
12268 }
12269}
12270
12271#[must_use = "FIDL methods require a response to be sent"]
12272#[derive(Debug)]
12273pub struct SocketDisconnectResponder {
12274 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12275 tx_id: u32,
12276}
12277
12278impl std::ops::Drop for SocketDisconnectResponder {
12282 fn drop(&mut self) {
12283 self.control_handle.shutdown();
12284 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12286 }
12287}
12288
12289impl fidl::endpoints::Responder for SocketDisconnectResponder {
12290 type ControlHandle = SocketControlHandle;
12291
12292 fn control_handle(&self) -> &SocketControlHandle {
12293 &self.control_handle
12294 }
12295
12296 fn drop_without_shutdown(mut self) {
12297 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12299 std::mem::forget(self);
12301 }
12302}
12303
12304impl SocketDisconnectResponder {
12305 pub fn send(
12309 self,
12310 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12311 ) -> Result<(), fidl::Error> {
12312 let _result = self.send_raw(result);
12313 if _result.is_err() {
12314 self.control_handle.shutdown();
12315 }
12316 self.drop_without_shutdown();
12317 _result
12318 }
12319
12320 pub fn send_no_shutdown_on_err(
12322 self,
12323 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12324 ) -> Result<(), fidl::Error> {
12325 let _result = self.send_raw(result);
12326 self.drop_without_shutdown();
12327 _result
12328 }
12329
12330 fn send_raw(
12331 &self,
12332 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12333 ) -> Result<(), fidl::Error> {
12334 self.control_handle.inner.send::<fidl::encoding::ResultType<
12335 fidl::encoding::EmptyStruct,
12336 fidl_fuchsia_posix::Errno,
12337 >>(
12338 result,
12339 self.tx_id,
12340 0x74e63b91f7b29b2,
12341 fidl::encoding::DynamicFlags::empty(),
12342 )
12343 }
12344}
12345
12346#[must_use = "FIDL methods require a response to be sent"]
12347#[derive(Debug)]
12348pub struct SocketGetSockNameResponder {
12349 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12350 tx_id: u32,
12351}
12352
12353impl std::ops::Drop for SocketGetSockNameResponder {
12357 fn drop(&mut self) {
12358 self.control_handle.shutdown();
12359 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12361 }
12362}
12363
12364impl fidl::endpoints::Responder for SocketGetSockNameResponder {
12365 type ControlHandle = SocketControlHandle;
12366
12367 fn control_handle(&self) -> &SocketControlHandle {
12368 &self.control_handle
12369 }
12370
12371 fn drop_without_shutdown(mut self) {
12372 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12374 std::mem::forget(self);
12376 }
12377}
12378
12379impl SocketGetSockNameResponder {
12380 pub fn send(
12384 self,
12385 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
12386 ) -> Result<(), fidl::Error> {
12387 let _result = self.send_raw(result);
12388 if _result.is_err() {
12389 self.control_handle.shutdown();
12390 }
12391 self.drop_without_shutdown();
12392 _result
12393 }
12394
12395 pub fn send_no_shutdown_on_err(
12397 self,
12398 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
12399 ) -> Result<(), fidl::Error> {
12400 let _result = self.send_raw(result);
12401 self.drop_without_shutdown();
12402 _result
12403 }
12404
12405 fn send_raw(
12406 &self,
12407 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
12408 ) -> Result<(), fidl::Error> {
12409 self.control_handle.inner.send::<fidl::encoding::ResultType<
12410 fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResponse,
12411 fidl_fuchsia_posix::Errno,
12412 >>(
12413 result.map(|addr| (addr,)),
12414 self.tx_id,
12415 0x475f23f84a1a4f85,
12416 fidl::encoding::DynamicFlags::empty(),
12417 )
12418 }
12419}
12420
12421#[must_use = "FIDL methods require a response to be sent"]
12422#[derive(Debug)]
12423pub struct SocketGetPeerNameResponder {
12424 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12425 tx_id: u32,
12426}
12427
12428impl std::ops::Drop for SocketGetPeerNameResponder {
12432 fn drop(&mut self) {
12433 self.control_handle.shutdown();
12434 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12436 }
12437}
12438
12439impl fidl::endpoints::Responder for SocketGetPeerNameResponder {
12440 type ControlHandle = SocketControlHandle;
12441
12442 fn control_handle(&self) -> &SocketControlHandle {
12443 &self.control_handle
12444 }
12445
12446 fn drop_without_shutdown(mut self) {
12447 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12449 std::mem::forget(self);
12451 }
12452}
12453
12454impl SocketGetPeerNameResponder {
12455 pub fn send(
12459 self,
12460 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
12461 ) -> Result<(), fidl::Error> {
12462 let _result = self.send_raw(result);
12463 if _result.is_err() {
12464 self.control_handle.shutdown();
12465 }
12466 self.drop_without_shutdown();
12467 _result
12468 }
12469
12470 pub fn send_no_shutdown_on_err(
12472 self,
12473 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
12474 ) -> Result<(), fidl::Error> {
12475 let _result = self.send_raw(result);
12476 self.drop_without_shutdown();
12477 _result
12478 }
12479
12480 fn send_raw(
12481 &self,
12482 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
12483 ) -> Result<(), fidl::Error> {
12484 self.control_handle.inner.send::<fidl::encoding::ResultType<
12485 fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResponse,
12486 fidl_fuchsia_posix::Errno,
12487 >>(
12488 result.map(|addr| (addr,)),
12489 self.tx_id,
12490 0x1ffecf4bd5b6432e,
12491 fidl::encoding::DynamicFlags::empty(),
12492 )
12493 }
12494}
12495
12496#[must_use = "FIDL methods require a response to be sent"]
12497#[derive(Debug)]
12498pub struct SocketShutdownResponder {
12499 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12500 tx_id: u32,
12501}
12502
12503impl std::ops::Drop for SocketShutdownResponder {
12507 fn drop(&mut self) {
12508 self.control_handle.shutdown();
12509 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12511 }
12512}
12513
12514impl fidl::endpoints::Responder for SocketShutdownResponder {
12515 type ControlHandle = SocketControlHandle;
12516
12517 fn control_handle(&self) -> &SocketControlHandle {
12518 &self.control_handle
12519 }
12520
12521 fn drop_without_shutdown(mut self) {
12522 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12524 std::mem::forget(self);
12526 }
12527}
12528
12529impl SocketShutdownResponder {
12530 pub fn send(
12534 self,
12535 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12536 ) -> Result<(), fidl::Error> {
12537 let _result = self.send_raw(result);
12538 if _result.is_err() {
12539 self.control_handle.shutdown();
12540 }
12541 self.drop_without_shutdown();
12542 _result
12543 }
12544
12545 pub fn send_no_shutdown_on_err(
12547 self,
12548 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12549 ) -> Result<(), fidl::Error> {
12550 let _result = self.send_raw(result);
12551 self.drop_without_shutdown();
12552 _result
12553 }
12554
12555 fn send_raw(
12556 &self,
12557 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12558 ) -> Result<(), fidl::Error> {
12559 self.control_handle.inner.send::<fidl::encoding::ResultType<
12560 fidl::encoding::EmptyStruct,
12561 fidl_fuchsia_posix::Errno,
12562 >>(
12563 result,
12564 self.tx_id,
12565 0x247f38b6db68c336,
12566 fidl::encoding::DynamicFlags::empty(),
12567 )
12568 }
12569}
12570
12571#[must_use = "FIDL methods require a response to be sent"]
12572#[derive(Debug)]
12573pub struct SocketSetIpTypeOfServiceResponder {
12574 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12575 tx_id: u32,
12576}
12577
12578impl std::ops::Drop for SocketSetIpTypeOfServiceResponder {
12582 fn drop(&mut self) {
12583 self.control_handle.shutdown();
12584 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12586 }
12587}
12588
12589impl fidl::endpoints::Responder for SocketSetIpTypeOfServiceResponder {
12590 type ControlHandle = SocketControlHandle;
12591
12592 fn control_handle(&self) -> &SocketControlHandle {
12593 &self.control_handle
12594 }
12595
12596 fn drop_without_shutdown(mut self) {
12597 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12599 std::mem::forget(self);
12601 }
12602}
12603
12604impl SocketSetIpTypeOfServiceResponder {
12605 pub fn send(
12609 self,
12610 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12611 ) -> Result<(), fidl::Error> {
12612 let _result = self.send_raw(result);
12613 if _result.is_err() {
12614 self.control_handle.shutdown();
12615 }
12616 self.drop_without_shutdown();
12617 _result
12618 }
12619
12620 pub fn send_no_shutdown_on_err(
12622 self,
12623 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12624 ) -> Result<(), fidl::Error> {
12625 let _result = self.send_raw(result);
12626 self.drop_without_shutdown();
12627 _result
12628 }
12629
12630 fn send_raw(
12631 &self,
12632 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12633 ) -> Result<(), fidl::Error> {
12634 self.control_handle.inner.send::<fidl::encoding::ResultType<
12635 fidl::encoding::EmptyStruct,
12636 fidl_fuchsia_posix::Errno,
12637 >>(
12638 result,
12639 self.tx_id,
12640 0x995c600475b6d46,
12641 fidl::encoding::DynamicFlags::empty(),
12642 )
12643 }
12644}
12645
12646#[must_use = "FIDL methods require a response to be sent"]
12647#[derive(Debug)]
12648pub struct SocketGetIpTypeOfServiceResponder {
12649 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12650 tx_id: u32,
12651}
12652
12653impl std::ops::Drop for SocketGetIpTypeOfServiceResponder {
12657 fn drop(&mut self) {
12658 self.control_handle.shutdown();
12659 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12661 }
12662}
12663
12664impl fidl::endpoints::Responder for SocketGetIpTypeOfServiceResponder {
12665 type ControlHandle = SocketControlHandle;
12666
12667 fn control_handle(&self) -> &SocketControlHandle {
12668 &self.control_handle
12669 }
12670
12671 fn drop_without_shutdown(mut self) {
12672 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12674 std::mem::forget(self);
12676 }
12677}
12678
12679impl SocketGetIpTypeOfServiceResponder {
12680 pub fn send(
12684 self,
12685 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12686 ) -> Result<(), fidl::Error> {
12687 let _result = self.send_raw(result);
12688 if _result.is_err() {
12689 self.control_handle.shutdown();
12690 }
12691 self.drop_without_shutdown();
12692 _result
12693 }
12694
12695 pub fn send_no_shutdown_on_err(
12697 self,
12698 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12699 ) -> Result<(), fidl::Error> {
12700 let _result = self.send_raw(result);
12701 self.drop_without_shutdown();
12702 _result
12703 }
12704
12705 fn send_raw(
12706 &self,
12707 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12708 ) -> Result<(), fidl::Error> {
12709 self.control_handle.inner.send::<fidl::encoding::ResultType<
12710 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResponse,
12711 fidl_fuchsia_posix::Errno,
12712 >>(
12713 result.map(|value| (value,)),
12714 self.tx_id,
12715 0x3814a04259f75fcb,
12716 fidl::encoding::DynamicFlags::empty(),
12717 )
12718 }
12719}
12720
12721#[must_use = "FIDL methods require a response to be sent"]
12722#[derive(Debug)]
12723pub struct SocketSetIpTtlResponder {
12724 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12725 tx_id: u32,
12726}
12727
12728impl std::ops::Drop for SocketSetIpTtlResponder {
12732 fn drop(&mut self) {
12733 self.control_handle.shutdown();
12734 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12736 }
12737}
12738
12739impl fidl::endpoints::Responder for SocketSetIpTtlResponder {
12740 type ControlHandle = SocketControlHandle;
12741
12742 fn control_handle(&self) -> &SocketControlHandle {
12743 &self.control_handle
12744 }
12745
12746 fn drop_without_shutdown(mut self) {
12747 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12749 std::mem::forget(self);
12751 }
12752}
12753
12754impl SocketSetIpTtlResponder {
12755 pub fn send(
12759 self,
12760 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12761 ) -> Result<(), fidl::Error> {
12762 let _result = self.send_raw(result);
12763 if _result.is_err() {
12764 self.control_handle.shutdown();
12765 }
12766 self.drop_without_shutdown();
12767 _result
12768 }
12769
12770 pub fn send_no_shutdown_on_err(
12772 self,
12773 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12774 ) -> Result<(), fidl::Error> {
12775 let _result = self.send_raw(result);
12776 self.drop_without_shutdown();
12777 _result
12778 }
12779
12780 fn send_raw(
12781 &self,
12782 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12783 ) -> Result<(), fidl::Error> {
12784 self.control_handle.inner.send::<fidl::encoding::ResultType<
12785 fidl::encoding::EmptyStruct,
12786 fidl_fuchsia_posix::Errno,
12787 >>(
12788 result,
12789 self.tx_id,
12790 0x29e2424b433ae1ef,
12791 fidl::encoding::DynamicFlags::empty(),
12792 )
12793 }
12794}
12795
12796#[must_use = "FIDL methods require a response to be sent"]
12797#[derive(Debug)]
12798pub struct SocketGetIpTtlResponder {
12799 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12800 tx_id: u32,
12801}
12802
12803impl std::ops::Drop for SocketGetIpTtlResponder {
12807 fn drop(&mut self) {
12808 self.control_handle.shutdown();
12809 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12811 }
12812}
12813
12814impl fidl::endpoints::Responder for SocketGetIpTtlResponder {
12815 type ControlHandle = SocketControlHandle;
12816
12817 fn control_handle(&self) -> &SocketControlHandle {
12818 &self.control_handle
12819 }
12820
12821 fn drop_without_shutdown(mut self) {
12822 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12824 std::mem::forget(self);
12826 }
12827}
12828
12829impl SocketGetIpTtlResponder {
12830 pub fn send(
12834 self,
12835 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12836 ) -> Result<(), fidl::Error> {
12837 let _result = self.send_raw(result);
12838 if _result.is_err() {
12839 self.control_handle.shutdown();
12840 }
12841 self.drop_without_shutdown();
12842 _result
12843 }
12844
12845 pub fn send_no_shutdown_on_err(
12847 self,
12848 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12849 ) -> Result<(), fidl::Error> {
12850 let _result = self.send_raw(result);
12851 self.drop_without_shutdown();
12852 _result
12853 }
12854
12855 fn send_raw(
12856 &self,
12857 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12858 ) -> Result<(), fidl::Error> {
12859 self.control_handle.inner.send::<fidl::encoding::ResultType<
12860 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResponse,
12861 fidl_fuchsia_posix::Errno,
12862 >>(
12863 result.map(|value| (value,)),
12864 self.tx_id,
12865 0x47e47fa1f24da471,
12866 fidl::encoding::DynamicFlags::empty(),
12867 )
12868 }
12869}
12870
12871#[must_use = "FIDL methods require a response to be sent"]
12872#[derive(Debug)]
12873pub struct SocketSetIpPacketInfoResponder {
12874 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12875 tx_id: u32,
12876}
12877
12878impl std::ops::Drop for SocketSetIpPacketInfoResponder {
12882 fn drop(&mut self) {
12883 self.control_handle.shutdown();
12884 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12886 }
12887}
12888
12889impl fidl::endpoints::Responder for SocketSetIpPacketInfoResponder {
12890 type ControlHandle = SocketControlHandle;
12891
12892 fn control_handle(&self) -> &SocketControlHandle {
12893 &self.control_handle
12894 }
12895
12896 fn drop_without_shutdown(mut self) {
12897 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12899 std::mem::forget(self);
12901 }
12902}
12903
12904impl SocketSetIpPacketInfoResponder {
12905 pub fn send(
12909 self,
12910 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12911 ) -> Result<(), fidl::Error> {
12912 let _result = self.send_raw(result);
12913 if _result.is_err() {
12914 self.control_handle.shutdown();
12915 }
12916 self.drop_without_shutdown();
12917 _result
12918 }
12919
12920 pub fn send_no_shutdown_on_err(
12922 self,
12923 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12924 ) -> Result<(), fidl::Error> {
12925 let _result = self.send_raw(result);
12926 self.drop_without_shutdown();
12927 _result
12928 }
12929
12930 fn send_raw(
12931 &self,
12932 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12933 ) -> Result<(), fidl::Error> {
12934 self.control_handle.inner.send::<fidl::encoding::ResultType<
12935 fidl::encoding::EmptyStruct,
12936 fidl_fuchsia_posix::Errno,
12937 >>(
12938 result,
12939 self.tx_id,
12940 0x392d16bee20c0e16,
12941 fidl::encoding::DynamicFlags::empty(),
12942 )
12943 }
12944}
12945
12946#[must_use = "FIDL methods require a response to be sent"]
12947#[derive(Debug)]
12948pub struct SocketGetIpPacketInfoResponder {
12949 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12950 tx_id: u32,
12951}
12952
12953impl std::ops::Drop for SocketGetIpPacketInfoResponder {
12957 fn drop(&mut self) {
12958 self.control_handle.shutdown();
12959 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12961 }
12962}
12963
12964impl fidl::endpoints::Responder for SocketGetIpPacketInfoResponder {
12965 type ControlHandle = SocketControlHandle;
12966
12967 fn control_handle(&self) -> &SocketControlHandle {
12968 &self.control_handle
12969 }
12970
12971 fn drop_without_shutdown(mut self) {
12972 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12974 std::mem::forget(self);
12976 }
12977}
12978
12979impl SocketGetIpPacketInfoResponder {
12980 pub fn send(
12984 self,
12985 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12986 ) -> Result<(), fidl::Error> {
12987 let _result = self.send_raw(result);
12988 if _result.is_err() {
12989 self.control_handle.shutdown();
12990 }
12991 self.drop_without_shutdown();
12992 _result
12993 }
12994
12995 pub fn send_no_shutdown_on_err(
12997 self,
12998 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12999 ) -> Result<(), fidl::Error> {
13000 let _result = self.send_raw(result);
13001 self.drop_without_shutdown();
13002 _result
13003 }
13004
13005 fn send_raw(
13006 &self,
13007 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13008 ) -> Result<(), fidl::Error> {
13009 self.control_handle.inner.send::<fidl::encoding::ResultType<
13010 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResponse,
13011 fidl_fuchsia_posix::Errno,
13012 >>(
13013 result.map(|value| (value,)),
13014 self.tx_id,
13015 0x54b505f242280740,
13016 fidl::encoding::DynamicFlags::empty(),
13017 )
13018 }
13019}
13020
13021#[must_use = "FIDL methods require a response to be sent"]
13022#[derive(Debug)]
13023pub struct SocketSetIpReceiveTypeOfServiceResponder {
13024 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13025 tx_id: u32,
13026}
13027
13028impl std::ops::Drop for SocketSetIpReceiveTypeOfServiceResponder {
13032 fn drop(&mut self) {
13033 self.control_handle.shutdown();
13034 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13036 }
13037}
13038
13039impl fidl::endpoints::Responder for SocketSetIpReceiveTypeOfServiceResponder {
13040 type ControlHandle = SocketControlHandle;
13041
13042 fn control_handle(&self) -> &SocketControlHandle {
13043 &self.control_handle
13044 }
13045
13046 fn drop_without_shutdown(mut self) {
13047 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13049 std::mem::forget(self);
13051 }
13052}
13053
13054impl SocketSetIpReceiveTypeOfServiceResponder {
13055 pub fn send(
13059 self,
13060 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13061 ) -> Result<(), fidl::Error> {
13062 let _result = self.send_raw(result);
13063 if _result.is_err() {
13064 self.control_handle.shutdown();
13065 }
13066 self.drop_without_shutdown();
13067 _result
13068 }
13069
13070 pub fn send_no_shutdown_on_err(
13072 self,
13073 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13074 ) -> Result<(), fidl::Error> {
13075 let _result = self.send_raw(result);
13076 self.drop_without_shutdown();
13077 _result
13078 }
13079
13080 fn send_raw(
13081 &self,
13082 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13083 ) -> Result<(), fidl::Error> {
13084 self.control_handle.inner.send::<fidl::encoding::ResultType<
13085 fidl::encoding::EmptyStruct,
13086 fidl_fuchsia_posix::Errno,
13087 >>(
13088 result,
13089 self.tx_id,
13090 0x6c4f6714995f84ef,
13091 fidl::encoding::DynamicFlags::empty(),
13092 )
13093 }
13094}
13095
13096#[must_use = "FIDL methods require a response to be sent"]
13097#[derive(Debug)]
13098pub struct SocketGetIpReceiveTypeOfServiceResponder {
13099 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13100 tx_id: u32,
13101}
13102
13103impl std::ops::Drop for SocketGetIpReceiveTypeOfServiceResponder {
13107 fn drop(&mut self) {
13108 self.control_handle.shutdown();
13109 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13111 }
13112}
13113
13114impl fidl::endpoints::Responder for SocketGetIpReceiveTypeOfServiceResponder {
13115 type ControlHandle = SocketControlHandle;
13116
13117 fn control_handle(&self) -> &SocketControlHandle {
13118 &self.control_handle
13119 }
13120
13121 fn drop_without_shutdown(mut self) {
13122 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13124 std::mem::forget(self);
13126 }
13127}
13128
13129impl SocketGetIpReceiveTypeOfServiceResponder {
13130 pub fn send(
13134 self,
13135 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13136 ) -> Result<(), fidl::Error> {
13137 let _result = self.send_raw(result);
13138 if _result.is_err() {
13139 self.control_handle.shutdown();
13140 }
13141 self.drop_without_shutdown();
13142 _result
13143 }
13144
13145 pub fn send_no_shutdown_on_err(
13147 self,
13148 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13149 ) -> Result<(), fidl::Error> {
13150 let _result = self.send_raw(result);
13151 self.drop_without_shutdown();
13152 _result
13153 }
13154
13155 fn send_raw(
13156 &self,
13157 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13158 ) -> Result<(), fidl::Error> {
13159 self.control_handle.inner.send::<fidl::encoding::ResultType<
13160 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
13161 fidl_fuchsia_posix::Errno,
13162 >>(
13163 result.map(|value| (value,)),
13164 self.tx_id,
13165 0x4158ba7dc2795960,
13166 fidl::encoding::DynamicFlags::empty(),
13167 )
13168 }
13169}
13170
13171#[must_use = "FIDL methods require a response to be sent"]
13172#[derive(Debug)]
13173pub struct SocketSetIpReceiveTtlResponder {
13174 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13175 tx_id: u32,
13176}
13177
13178impl std::ops::Drop for SocketSetIpReceiveTtlResponder {
13182 fn drop(&mut self) {
13183 self.control_handle.shutdown();
13184 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13186 }
13187}
13188
13189impl fidl::endpoints::Responder for SocketSetIpReceiveTtlResponder {
13190 type ControlHandle = SocketControlHandle;
13191
13192 fn control_handle(&self) -> &SocketControlHandle {
13193 &self.control_handle
13194 }
13195
13196 fn drop_without_shutdown(mut self) {
13197 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13199 std::mem::forget(self);
13201 }
13202}
13203
13204impl SocketSetIpReceiveTtlResponder {
13205 pub fn send(
13209 self,
13210 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13211 ) -> Result<(), fidl::Error> {
13212 let _result = self.send_raw(result);
13213 if _result.is_err() {
13214 self.control_handle.shutdown();
13215 }
13216 self.drop_without_shutdown();
13217 _result
13218 }
13219
13220 pub fn send_no_shutdown_on_err(
13222 self,
13223 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13224 ) -> Result<(), fidl::Error> {
13225 let _result = self.send_raw(result);
13226 self.drop_without_shutdown();
13227 _result
13228 }
13229
13230 fn send_raw(
13231 &self,
13232 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13233 ) -> Result<(), fidl::Error> {
13234 self.control_handle.inner.send::<fidl::encoding::ResultType<
13235 fidl::encoding::EmptyStruct,
13236 fidl_fuchsia_posix::Errno,
13237 >>(
13238 result,
13239 self.tx_id,
13240 0x46f15be0ce0ab82b,
13241 fidl::encoding::DynamicFlags::empty(),
13242 )
13243 }
13244}
13245
13246#[must_use = "FIDL methods require a response to be sent"]
13247#[derive(Debug)]
13248pub struct SocketGetIpReceiveTtlResponder {
13249 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13250 tx_id: u32,
13251}
13252
13253impl std::ops::Drop for SocketGetIpReceiveTtlResponder {
13257 fn drop(&mut self) {
13258 self.control_handle.shutdown();
13259 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13261 }
13262}
13263
13264impl fidl::endpoints::Responder for SocketGetIpReceiveTtlResponder {
13265 type ControlHandle = SocketControlHandle;
13266
13267 fn control_handle(&self) -> &SocketControlHandle {
13268 &self.control_handle
13269 }
13270
13271 fn drop_without_shutdown(mut self) {
13272 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13274 std::mem::forget(self);
13276 }
13277}
13278
13279impl SocketGetIpReceiveTtlResponder {
13280 pub fn send(
13284 self,
13285 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13286 ) -> Result<(), fidl::Error> {
13287 let _result = self.send_raw(result);
13288 if _result.is_err() {
13289 self.control_handle.shutdown();
13290 }
13291 self.drop_without_shutdown();
13292 _result
13293 }
13294
13295 pub fn send_no_shutdown_on_err(
13297 self,
13298 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13299 ) -> Result<(), fidl::Error> {
13300 let _result = self.send_raw(result);
13301 self.drop_without_shutdown();
13302 _result
13303 }
13304
13305 fn send_raw(
13306 &self,
13307 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13308 ) -> Result<(), fidl::Error> {
13309 self.control_handle.inner.send::<fidl::encoding::ResultType<
13310 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResponse,
13311 fidl_fuchsia_posix::Errno,
13312 >>(
13313 result.map(|value| (value,)),
13314 self.tx_id,
13315 0x678ddd5a5dfa2eb5,
13316 fidl::encoding::DynamicFlags::empty(),
13317 )
13318 }
13319}
13320
13321#[must_use = "FIDL methods require a response to be sent"]
13322#[derive(Debug)]
13323pub struct SocketSetIpMulticastInterfaceResponder {
13324 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13325 tx_id: u32,
13326}
13327
13328impl std::ops::Drop for SocketSetIpMulticastInterfaceResponder {
13332 fn drop(&mut self) {
13333 self.control_handle.shutdown();
13334 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13336 }
13337}
13338
13339impl fidl::endpoints::Responder for SocketSetIpMulticastInterfaceResponder {
13340 type ControlHandle = SocketControlHandle;
13341
13342 fn control_handle(&self) -> &SocketControlHandle {
13343 &self.control_handle
13344 }
13345
13346 fn drop_without_shutdown(mut self) {
13347 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13349 std::mem::forget(self);
13351 }
13352}
13353
13354impl SocketSetIpMulticastInterfaceResponder {
13355 pub fn send(
13359 self,
13360 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13361 ) -> Result<(), fidl::Error> {
13362 let _result = self.send_raw(result);
13363 if _result.is_err() {
13364 self.control_handle.shutdown();
13365 }
13366 self.drop_without_shutdown();
13367 _result
13368 }
13369
13370 pub fn send_no_shutdown_on_err(
13372 self,
13373 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13374 ) -> Result<(), fidl::Error> {
13375 let _result = self.send_raw(result);
13376 self.drop_without_shutdown();
13377 _result
13378 }
13379
13380 fn send_raw(
13381 &self,
13382 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13383 ) -> Result<(), fidl::Error> {
13384 self.control_handle.inner.send::<fidl::encoding::ResultType<
13385 fidl::encoding::EmptyStruct,
13386 fidl_fuchsia_posix::Errno,
13387 >>(
13388 result,
13389 self.tx_id,
13390 0x752fbfa9b12befe,
13391 fidl::encoding::DynamicFlags::empty(),
13392 )
13393 }
13394}
13395
13396#[must_use = "FIDL methods require a response to be sent"]
13397#[derive(Debug)]
13398pub struct SocketGetIpMulticastInterfaceResponder {
13399 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13400 tx_id: u32,
13401}
13402
13403impl std::ops::Drop for SocketGetIpMulticastInterfaceResponder {
13407 fn drop(&mut self) {
13408 self.control_handle.shutdown();
13409 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13411 }
13412}
13413
13414impl fidl::endpoints::Responder for SocketGetIpMulticastInterfaceResponder {
13415 type ControlHandle = SocketControlHandle;
13416
13417 fn control_handle(&self) -> &SocketControlHandle {
13418 &self.control_handle
13419 }
13420
13421 fn drop_without_shutdown(mut self) {
13422 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13424 std::mem::forget(self);
13426 }
13427}
13428
13429impl SocketGetIpMulticastInterfaceResponder {
13430 pub fn send(
13434 self,
13435 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
13436 ) -> Result<(), fidl::Error> {
13437 let _result = self.send_raw(result);
13438 if _result.is_err() {
13439 self.control_handle.shutdown();
13440 }
13441 self.drop_without_shutdown();
13442 _result
13443 }
13444
13445 pub fn send_no_shutdown_on_err(
13447 self,
13448 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
13449 ) -> Result<(), fidl::Error> {
13450 let _result = self.send_raw(result);
13451 self.drop_without_shutdown();
13452 _result
13453 }
13454
13455 fn send_raw(
13456 &self,
13457 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
13458 ) -> Result<(), fidl::Error> {
13459 self.control_handle.inner.send::<fidl::encoding::ResultType<
13460 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResponse,
13461 fidl_fuchsia_posix::Errno,
13462 >>(
13463 result.map(|value| (value,)),
13464 self.tx_id,
13465 0x320bd14c4df046c4,
13466 fidl::encoding::DynamicFlags::empty(),
13467 )
13468 }
13469}
13470
13471#[must_use = "FIDL methods require a response to be sent"]
13472#[derive(Debug)]
13473pub struct SocketSetIpMulticastTtlResponder {
13474 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13475 tx_id: u32,
13476}
13477
13478impl std::ops::Drop for SocketSetIpMulticastTtlResponder {
13482 fn drop(&mut self) {
13483 self.control_handle.shutdown();
13484 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13486 }
13487}
13488
13489impl fidl::endpoints::Responder for SocketSetIpMulticastTtlResponder {
13490 type ControlHandle = SocketControlHandle;
13491
13492 fn control_handle(&self) -> &SocketControlHandle {
13493 &self.control_handle
13494 }
13495
13496 fn drop_without_shutdown(mut self) {
13497 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13499 std::mem::forget(self);
13501 }
13502}
13503
13504impl SocketSetIpMulticastTtlResponder {
13505 pub fn send(
13509 self,
13510 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13511 ) -> Result<(), fidl::Error> {
13512 let _result = self.send_raw(result);
13513 if _result.is_err() {
13514 self.control_handle.shutdown();
13515 }
13516 self.drop_without_shutdown();
13517 _result
13518 }
13519
13520 pub fn send_no_shutdown_on_err(
13522 self,
13523 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13524 ) -> Result<(), fidl::Error> {
13525 let _result = self.send_raw(result);
13526 self.drop_without_shutdown();
13527 _result
13528 }
13529
13530 fn send_raw(
13531 &self,
13532 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13533 ) -> Result<(), fidl::Error> {
13534 self.control_handle.inner.send::<fidl::encoding::ResultType<
13535 fidl::encoding::EmptyStruct,
13536 fidl_fuchsia_posix::Errno,
13537 >>(
13538 result,
13539 self.tx_id,
13540 0x63134d53772916a1,
13541 fidl::encoding::DynamicFlags::empty(),
13542 )
13543 }
13544}
13545
13546#[must_use = "FIDL methods require a response to be sent"]
13547#[derive(Debug)]
13548pub struct SocketGetIpMulticastTtlResponder {
13549 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13550 tx_id: u32,
13551}
13552
13553impl std::ops::Drop for SocketGetIpMulticastTtlResponder {
13557 fn drop(&mut self) {
13558 self.control_handle.shutdown();
13559 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13561 }
13562}
13563
13564impl fidl::endpoints::Responder for SocketGetIpMulticastTtlResponder {
13565 type ControlHandle = SocketControlHandle;
13566
13567 fn control_handle(&self) -> &SocketControlHandle {
13568 &self.control_handle
13569 }
13570
13571 fn drop_without_shutdown(mut self) {
13572 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13574 std::mem::forget(self);
13576 }
13577}
13578
13579impl SocketGetIpMulticastTtlResponder {
13580 pub fn send(
13584 self,
13585 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
13586 ) -> Result<(), fidl::Error> {
13587 let _result = self.send_raw(result);
13588 if _result.is_err() {
13589 self.control_handle.shutdown();
13590 }
13591 self.drop_without_shutdown();
13592 _result
13593 }
13594
13595 pub fn send_no_shutdown_on_err(
13597 self,
13598 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
13599 ) -> Result<(), fidl::Error> {
13600 let _result = self.send_raw(result);
13601 self.drop_without_shutdown();
13602 _result
13603 }
13604
13605 fn send_raw(
13606 &self,
13607 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
13608 ) -> Result<(), fidl::Error> {
13609 self.control_handle.inner.send::<fidl::encoding::ResultType<
13610 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResponse,
13611 fidl_fuchsia_posix::Errno,
13612 >>(
13613 result.map(|value| (value,)),
13614 self.tx_id,
13615 0x4665cd378f39e1a,
13616 fidl::encoding::DynamicFlags::empty(),
13617 )
13618 }
13619}
13620
13621#[must_use = "FIDL methods require a response to be sent"]
13622#[derive(Debug)]
13623pub struct SocketSetIpMulticastLoopbackResponder {
13624 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13625 tx_id: u32,
13626}
13627
13628impl std::ops::Drop for SocketSetIpMulticastLoopbackResponder {
13632 fn drop(&mut self) {
13633 self.control_handle.shutdown();
13634 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13636 }
13637}
13638
13639impl fidl::endpoints::Responder for SocketSetIpMulticastLoopbackResponder {
13640 type ControlHandle = SocketControlHandle;
13641
13642 fn control_handle(&self) -> &SocketControlHandle {
13643 &self.control_handle
13644 }
13645
13646 fn drop_without_shutdown(mut self) {
13647 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13649 std::mem::forget(self);
13651 }
13652}
13653
13654impl SocketSetIpMulticastLoopbackResponder {
13655 pub fn send(
13659 self,
13660 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13661 ) -> Result<(), fidl::Error> {
13662 let _result = self.send_raw(result);
13663 if _result.is_err() {
13664 self.control_handle.shutdown();
13665 }
13666 self.drop_without_shutdown();
13667 _result
13668 }
13669
13670 pub fn send_no_shutdown_on_err(
13672 self,
13673 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13674 ) -> Result<(), fidl::Error> {
13675 let _result = self.send_raw(result);
13676 self.drop_without_shutdown();
13677 _result
13678 }
13679
13680 fn send_raw(
13681 &self,
13682 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13683 ) -> Result<(), fidl::Error> {
13684 self.control_handle.inner.send::<fidl::encoding::ResultType<
13685 fidl::encoding::EmptyStruct,
13686 fidl_fuchsia_posix::Errno,
13687 >>(
13688 result,
13689 self.tx_id,
13690 0x20c55c11f00943ea,
13691 fidl::encoding::DynamicFlags::empty(),
13692 )
13693 }
13694}
13695
13696#[must_use = "FIDL methods require a response to be sent"]
13697#[derive(Debug)]
13698pub struct SocketGetIpMulticastLoopbackResponder {
13699 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13700 tx_id: u32,
13701}
13702
13703impl std::ops::Drop for SocketGetIpMulticastLoopbackResponder {
13707 fn drop(&mut self) {
13708 self.control_handle.shutdown();
13709 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13711 }
13712}
13713
13714impl fidl::endpoints::Responder for SocketGetIpMulticastLoopbackResponder {
13715 type ControlHandle = SocketControlHandle;
13716
13717 fn control_handle(&self) -> &SocketControlHandle {
13718 &self.control_handle
13719 }
13720
13721 fn drop_without_shutdown(mut self) {
13722 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13724 std::mem::forget(self);
13726 }
13727}
13728
13729impl SocketGetIpMulticastLoopbackResponder {
13730 pub fn send(
13734 self,
13735 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13736 ) -> Result<(), fidl::Error> {
13737 let _result = self.send_raw(result);
13738 if _result.is_err() {
13739 self.control_handle.shutdown();
13740 }
13741 self.drop_without_shutdown();
13742 _result
13743 }
13744
13745 pub fn send_no_shutdown_on_err(
13747 self,
13748 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13749 ) -> Result<(), fidl::Error> {
13750 let _result = self.send_raw(result);
13751 self.drop_without_shutdown();
13752 _result
13753 }
13754
13755 fn send_raw(
13756 &self,
13757 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13758 ) -> Result<(), fidl::Error> {
13759 self.control_handle.inner.send::<fidl::encoding::ResultType<
13760 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResponse,
13761 fidl_fuchsia_posix::Errno,
13762 >>(
13763 result.map(|value| (value,)),
13764 self.tx_id,
13765 0x3b6b26ff558298f2,
13766 fidl::encoding::DynamicFlags::empty(),
13767 )
13768 }
13769}
13770
13771#[must_use = "FIDL methods require a response to be sent"]
13772#[derive(Debug)]
13773pub struct SocketAddIpMembershipResponder {
13774 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13775 tx_id: u32,
13776}
13777
13778impl std::ops::Drop for SocketAddIpMembershipResponder {
13782 fn drop(&mut self) {
13783 self.control_handle.shutdown();
13784 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13786 }
13787}
13788
13789impl fidl::endpoints::Responder for SocketAddIpMembershipResponder {
13790 type ControlHandle = SocketControlHandle;
13791
13792 fn control_handle(&self) -> &SocketControlHandle {
13793 &self.control_handle
13794 }
13795
13796 fn drop_without_shutdown(mut self) {
13797 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13799 std::mem::forget(self);
13801 }
13802}
13803
13804impl SocketAddIpMembershipResponder {
13805 pub fn send(
13809 self,
13810 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13811 ) -> Result<(), fidl::Error> {
13812 let _result = self.send_raw(result);
13813 if _result.is_err() {
13814 self.control_handle.shutdown();
13815 }
13816 self.drop_without_shutdown();
13817 _result
13818 }
13819
13820 pub fn send_no_shutdown_on_err(
13822 self,
13823 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13824 ) -> Result<(), fidl::Error> {
13825 let _result = self.send_raw(result);
13826 self.drop_without_shutdown();
13827 _result
13828 }
13829
13830 fn send_raw(
13831 &self,
13832 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13833 ) -> Result<(), fidl::Error> {
13834 self.control_handle.inner.send::<fidl::encoding::ResultType<
13835 fidl::encoding::EmptyStruct,
13836 fidl_fuchsia_posix::Errno,
13837 >>(
13838 result,
13839 self.tx_id,
13840 0x76bc7df115a3b4d0,
13841 fidl::encoding::DynamicFlags::empty(),
13842 )
13843 }
13844}
13845
13846#[must_use = "FIDL methods require a response to be sent"]
13847#[derive(Debug)]
13848pub struct SocketDropIpMembershipResponder {
13849 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13850 tx_id: u32,
13851}
13852
13853impl std::ops::Drop for SocketDropIpMembershipResponder {
13857 fn drop(&mut self) {
13858 self.control_handle.shutdown();
13859 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13861 }
13862}
13863
13864impl fidl::endpoints::Responder for SocketDropIpMembershipResponder {
13865 type ControlHandle = SocketControlHandle;
13866
13867 fn control_handle(&self) -> &SocketControlHandle {
13868 &self.control_handle
13869 }
13870
13871 fn drop_without_shutdown(mut self) {
13872 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13874 std::mem::forget(self);
13876 }
13877}
13878
13879impl SocketDropIpMembershipResponder {
13880 pub fn send(
13884 self,
13885 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13886 ) -> Result<(), fidl::Error> {
13887 let _result = self.send_raw(result);
13888 if _result.is_err() {
13889 self.control_handle.shutdown();
13890 }
13891 self.drop_without_shutdown();
13892 _result
13893 }
13894
13895 pub fn send_no_shutdown_on_err(
13897 self,
13898 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13899 ) -> Result<(), fidl::Error> {
13900 let _result = self.send_raw(result);
13901 self.drop_without_shutdown();
13902 _result
13903 }
13904
13905 fn send_raw(
13906 &self,
13907 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13908 ) -> Result<(), fidl::Error> {
13909 self.control_handle.inner.send::<fidl::encoding::ResultType<
13910 fidl::encoding::EmptyStruct,
13911 fidl_fuchsia_posix::Errno,
13912 >>(
13913 result,
13914 self.tx_id,
13915 0x2888f3099188d03,
13916 fidl::encoding::DynamicFlags::empty(),
13917 )
13918 }
13919}
13920
13921#[must_use = "FIDL methods require a response to be sent"]
13922#[derive(Debug)]
13923pub struct SocketSetIpTransparentResponder {
13924 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13925 tx_id: u32,
13926}
13927
13928impl std::ops::Drop for SocketSetIpTransparentResponder {
13932 fn drop(&mut self) {
13933 self.control_handle.shutdown();
13934 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13936 }
13937}
13938
13939impl fidl::endpoints::Responder for SocketSetIpTransparentResponder {
13940 type ControlHandle = SocketControlHandle;
13941
13942 fn control_handle(&self) -> &SocketControlHandle {
13943 &self.control_handle
13944 }
13945
13946 fn drop_without_shutdown(mut self) {
13947 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13949 std::mem::forget(self);
13951 }
13952}
13953
13954impl SocketSetIpTransparentResponder {
13955 pub fn send(
13959 self,
13960 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13961 ) -> Result<(), fidl::Error> {
13962 let _result = self.send_raw(result);
13963 if _result.is_err() {
13964 self.control_handle.shutdown();
13965 }
13966 self.drop_without_shutdown();
13967 _result
13968 }
13969
13970 pub fn send_no_shutdown_on_err(
13972 self,
13973 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13974 ) -> Result<(), fidl::Error> {
13975 let _result = self.send_raw(result);
13976 self.drop_without_shutdown();
13977 _result
13978 }
13979
13980 fn send_raw(
13981 &self,
13982 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13983 ) -> Result<(), fidl::Error> {
13984 self.control_handle.inner.send::<fidl::encoding::ResultType<
13985 fidl::encoding::EmptyStruct,
13986 fidl_fuchsia_posix::Errno,
13987 >>(
13988 result,
13989 self.tx_id,
13990 0x1ae532b0c066e3a0,
13991 fidl::encoding::DynamicFlags::empty(),
13992 )
13993 }
13994}
13995
13996#[must_use = "FIDL methods require a response to be sent"]
13997#[derive(Debug)]
13998pub struct SocketGetIpTransparentResponder {
13999 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14000 tx_id: u32,
14001}
14002
14003impl std::ops::Drop for SocketGetIpTransparentResponder {
14007 fn drop(&mut self) {
14008 self.control_handle.shutdown();
14009 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14011 }
14012}
14013
14014impl fidl::endpoints::Responder for SocketGetIpTransparentResponder {
14015 type ControlHandle = SocketControlHandle;
14016
14017 fn control_handle(&self) -> &SocketControlHandle {
14018 &self.control_handle
14019 }
14020
14021 fn drop_without_shutdown(mut self) {
14022 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14024 std::mem::forget(self);
14026 }
14027}
14028
14029impl SocketGetIpTransparentResponder {
14030 pub fn send(
14034 self,
14035 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14036 ) -> Result<(), fidl::Error> {
14037 let _result = self.send_raw(result);
14038 if _result.is_err() {
14039 self.control_handle.shutdown();
14040 }
14041 self.drop_without_shutdown();
14042 _result
14043 }
14044
14045 pub fn send_no_shutdown_on_err(
14047 self,
14048 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14049 ) -> Result<(), fidl::Error> {
14050 let _result = self.send_raw(result);
14051 self.drop_without_shutdown();
14052 _result
14053 }
14054
14055 fn send_raw(
14056 &self,
14057 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14058 ) -> Result<(), fidl::Error> {
14059 self.control_handle.inner.send::<fidl::encoding::ResultType<
14060 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResponse,
14061 fidl_fuchsia_posix::Errno,
14062 >>(
14063 result.map(|value| (value,)),
14064 self.tx_id,
14065 0x51d43695962ebfb5,
14066 fidl::encoding::DynamicFlags::empty(),
14067 )
14068 }
14069}
14070
14071#[must_use = "FIDL methods require a response to be sent"]
14072#[derive(Debug)]
14073pub struct SocketSetIpReceiveOriginalDestinationAddressResponder {
14074 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14075 tx_id: u32,
14076}
14077
14078impl std::ops::Drop for SocketSetIpReceiveOriginalDestinationAddressResponder {
14082 fn drop(&mut self) {
14083 self.control_handle.shutdown();
14084 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14086 }
14087}
14088
14089impl fidl::endpoints::Responder for SocketSetIpReceiveOriginalDestinationAddressResponder {
14090 type ControlHandle = SocketControlHandle;
14091
14092 fn control_handle(&self) -> &SocketControlHandle {
14093 &self.control_handle
14094 }
14095
14096 fn drop_without_shutdown(mut self) {
14097 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14099 std::mem::forget(self);
14101 }
14102}
14103
14104impl SocketSetIpReceiveOriginalDestinationAddressResponder {
14105 pub fn send(
14109 self,
14110 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14111 ) -> Result<(), fidl::Error> {
14112 let _result = self.send_raw(result);
14113 if _result.is_err() {
14114 self.control_handle.shutdown();
14115 }
14116 self.drop_without_shutdown();
14117 _result
14118 }
14119
14120 pub fn send_no_shutdown_on_err(
14122 self,
14123 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14124 ) -> Result<(), fidl::Error> {
14125 let _result = self.send_raw(result);
14126 self.drop_without_shutdown();
14127 _result
14128 }
14129
14130 fn send_raw(
14131 &self,
14132 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14133 ) -> Result<(), fidl::Error> {
14134 self.control_handle.inner.send::<fidl::encoding::ResultType<
14135 fidl::encoding::EmptyStruct,
14136 fidl_fuchsia_posix::Errno,
14137 >>(
14138 result,
14139 self.tx_id,
14140 0x4722b4ce52f7840,
14141 fidl::encoding::DynamicFlags::empty(),
14142 )
14143 }
14144}
14145
14146#[must_use = "FIDL methods require a response to be sent"]
14147#[derive(Debug)]
14148pub struct SocketGetIpReceiveOriginalDestinationAddressResponder {
14149 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14150 tx_id: u32,
14151}
14152
14153impl std::ops::Drop for SocketGetIpReceiveOriginalDestinationAddressResponder {
14157 fn drop(&mut self) {
14158 self.control_handle.shutdown();
14159 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14161 }
14162}
14163
14164impl fidl::endpoints::Responder for SocketGetIpReceiveOriginalDestinationAddressResponder {
14165 type ControlHandle = SocketControlHandle;
14166
14167 fn control_handle(&self) -> &SocketControlHandle {
14168 &self.control_handle
14169 }
14170
14171 fn drop_without_shutdown(mut self) {
14172 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14174 std::mem::forget(self);
14176 }
14177}
14178
14179impl SocketGetIpReceiveOriginalDestinationAddressResponder {
14180 pub fn send(
14184 self,
14185 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14186 ) -> Result<(), fidl::Error> {
14187 let _result = self.send_raw(result);
14188 if _result.is_err() {
14189 self.control_handle.shutdown();
14190 }
14191 self.drop_without_shutdown();
14192 _result
14193 }
14194
14195 pub fn send_no_shutdown_on_err(
14197 self,
14198 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14199 ) -> Result<(), fidl::Error> {
14200 let _result = self.send_raw(result);
14201 self.drop_without_shutdown();
14202 _result
14203 }
14204
14205 fn send_raw(
14206 &self,
14207 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14208 ) -> Result<(), fidl::Error> {
14209 self.control_handle.inner.send::<fidl::encoding::ResultType<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse, fidl_fuchsia_posix::Errno>>(
14210 result.map(|value| (value,)),
14211 self.tx_id,
14212 0x2a0e7dc5d6bfdfe9,
14213 fidl::encoding::DynamicFlags::empty()
14214 )
14215 }
14216}
14217
14218#[must_use = "FIDL methods require a response to be sent"]
14219#[derive(Debug)]
14220pub struct SocketAddIpv6MembershipResponder {
14221 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14222 tx_id: u32,
14223}
14224
14225impl std::ops::Drop for SocketAddIpv6MembershipResponder {
14229 fn drop(&mut self) {
14230 self.control_handle.shutdown();
14231 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14233 }
14234}
14235
14236impl fidl::endpoints::Responder for SocketAddIpv6MembershipResponder {
14237 type ControlHandle = SocketControlHandle;
14238
14239 fn control_handle(&self) -> &SocketControlHandle {
14240 &self.control_handle
14241 }
14242
14243 fn drop_without_shutdown(mut self) {
14244 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14246 std::mem::forget(self);
14248 }
14249}
14250
14251impl SocketAddIpv6MembershipResponder {
14252 pub fn send(
14256 self,
14257 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14258 ) -> Result<(), fidl::Error> {
14259 let _result = self.send_raw(result);
14260 if _result.is_err() {
14261 self.control_handle.shutdown();
14262 }
14263 self.drop_without_shutdown();
14264 _result
14265 }
14266
14267 pub fn send_no_shutdown_on_err(
14269 self,
14270 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14271 ) -> Result<(), fidl::Error> {
14272 let _result = self.send_raw(result);
14273 self.drop_without_shutdown();
14274 _result
14275 }
14276
14277 fn send_raw(
14278 &self,
14279 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14280 ) -> Result<(), fidl::Error> {
14281 self.control_handle.inner.send::<fidl::encoding::ResultType<
14282 fidl::encoding::EmptyStruct,
14283 fidl_fuchsia_posix::Errno,
14284 >>(
14285 result,
14286 self.tx_id,
14287 0x7c94727acb4ea4b3,
14288 fidl::encoding::DynamicFlags::empty(),
14289 )
14290 }
14291}
14292
14293#[must_use = "FIDL methods require a response to be sent"]
14294#[derive(Debug)]
14295pub struct SocketDropIpv6MembershipResponder {
14296 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14297 tx_id: u32,
14298}
14299
14300impl std::ops::Drop for SocketDropIpv6MembershipResponder {
14304 fn drop(&mut self) {
14305 self.control_handle.shutdown();
14306 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14308 }
14309}
14310
14311impl fidl::endpoints::Responder for SocketDropIpv6MembershipResponder {
14312 type ControlHandle = SocketControlHandle;
14313
14314 fn control_handle(&self) -> &SocketControlHandle {
14315 &self.control_handle
14316 }
14317
14318 fn drop_without_shutdown(mut self) {
14319 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14321 std::mem::forget(self);
14323 }
14324}
14325
14326impl SocketDropIpv6MembershipResponder {
14327 pub fn send(
14331 self,
14332 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14333 ) -> Result<(), fidl::Error> {
14334 let _result = self.send_raw(result);
14335 if _result.is_err() {
14336 self.control_handle.shutdown();
14337 }
14338 self.drop_without_shutdown();
14339 _result
14340 }
14341
14342 pub fn send_no_shutdown_on_err(
14344 self,
14345 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14346 ) -> Result<(), fidl::Error> {
14347 let _result = self.send_raw(result);
14348 self.drop_without_shutdown();
14349 _result
14350 }
14351
14352 fn send_raw(
14353 &self,
14354 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14355 ) -> Result<(), fidl::Error> {
14356 self.control_handle.inner.send::<fidl::encoding::ResultType<
14357 fidl::encoding::EmptyStruct,
14358 fidl_fuchsia_posix::Errno,
14359 >>(
14360 result,
14361 self.tx_id,
14362 0x42104c70ccaba304,
14363 fidl::encoding::DynamicFlags::empty(),
14364 )
14365 }
14366}
14367
14368#[must_use = "FIDL methods require a response to be sent"]
14369#[derive(Debug)]
14370pub struct SocketSetIpv6MulticastInterfaceResponder {
14371 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14372 tx_id: u32,
14373}
14374
14375impl std::ops::Drop for SocketSetIpv6MulticastInterfaceResponder {
14379 fn drop(&mut self) {
14380 self.control_handle.shutdown();
14381 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14383 }
14384}
14385
14386impl fidl::endpoints::Responder for SocketSetIpv6MulticastInterfaceResponder {
14387 type ControlHandle = SocketControlHandle;
14388
14389 fn control_handle(&self) -> &SocketControlHandle {
14390 &self.control_handle
14391 }
14392
14393 fn drop_without_shutdown(mut self) {
14394 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14396 std::mem::forget(self);
14398 }
14399}
14400
14401impl SocketSetIpv6MulticastInterfaceResponder {
14402 pub fn send(
14406 self,
14407 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14408 ) -> Result<(), fidl::Error> {
14409 let _result = self.send_raw(result);
14410 if _result.is_err() {
14411 self.control_handle.shutdown();
14412 }
14413 self.drop_without_shutdown();
14414 _result
14415 }
14416
14417 pub fn send_no_shutdown_on_err(
14419 self,
14420 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14421 ) -> Result<(), fidl::Error> {
14422 let _result = self.send_raw(result);
14423 self.drop_without_shutdown();
14424 _result
14425 }
14426
14427 fn send_raw(
14428 &self,
14429 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14430 ) -> Result<(), fidl::Error> {
14431 self.control_handle.inner.send::<fidl::encoding::ResultType<
14432 fidl::encoding::EmptyStruct,
14433 fidl_fuchsia_posix::Errno,
14434 >>(
14435 result,
14436 self.tx_id,
14437 0x135f76db3774ab3b,
14438 fidl::encoding::DynamicFlags::empty(),
14439 )
14440 }
14441}
14442
14443#[must_use = "FIDL methods require a response to be sent"]
14444#[derive(Debug)]
14445pub struct SocketGetIpv6MulticastInterfaceResponder {
14446 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14447 tx_id: u32,
14448}
14449
14450impl std::ops::Drop for SocketGetIpv6MulticastInterfaceResponder {
14454 fn drop(&mut self) {
14455 self.control_handle.shutdown();
14456 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14458 }
14459}
14460
14461impl fidl::endpoints::Responder for SocketGetIpv6MulticastInterfaceResponder {
14462 type ControlHandle = SocketControlHandle;
14463
14464 fn control_handle(&self) -> &SocketControlHandle {
14465 &self.control_handle
14466 }
14467
14468 fn drop_without_shutdown(mut self) {
14469 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14471 std::mem::forget(self);
14473 }
14474}
14475
14476impl SocketGetIpv6MulticastInterfaceResponder {
14477 pub fn send(
14481 self,
14482 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
14483 ) -> Result<(), fidl::Error> {
14484 let _result = self.send_raw(result);
14485 if _result.is_err() {
14486 self.control_handle.shutdown();
14487 }
14488 self.drop_without_shutdown();
14489 _result
14490 }
14491
14492 pub fn send_no_shutdown_on_err(
14494 self,
14495 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
14496 ) -> Result<(), fidl::Error> {
14497 let _result = self.send_raw(result);
14498 self.drop_without_shutdown();
14499 _result
14500 }
14501
14502 fn send_raw(
14503 &self,
14504 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
14505 ) -> Result<(), fidl::Error> {
14506 self.control_handle.inner.send::<fidl::encoding::ResultType<
14507 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
14508 fidl_fuchsia_posix::Errno,
14509 >>(
14510 result.map(|value| (value,)),
14511 self.tx_id,
14512 0x1f26fcdd348f1882,
14513 fidl::encoding::DynamicFlags::empty(),
14514 )
14515 }
14516}
14517
14518#[must_use = "FIDL methods require a response to be sent"]
14519#[derive(Debug)]
14520pub struct SocketSetIpv6UnicastHopsResponder {
14521 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14522 tx_id: u32,
14523}
14524
14525impl std::ops::Drop for SocketSetIpv6UnicastHopsResponder {
14529 fn drop(&mut self) {
14530 self.control_handle.shutdown();
14531 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14533 }
14534}
14535
14536impl fidl::endpoints::Responder for SocketSetIpv6UnicastHopsResponder {
14537 type ControlHandle = SocketControlHandle;
14538
14539 fn control_handle(&self) -> &SocketControlHandle {
14540 &self.control_handle
14541 }
14542
14543 fn drop_without_shutdown(mut self) {
14544 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14546 std::mem::forget(self);
14548 }
14549}
14550
14551impl SocketSetIpv6UnicastHopsResponder {
14552 pub fn send(
14556 self,
14557 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14558 ) -> Result<(), fidl::Error> {
14559 let _result = self.send_raw(result);
14560 if _result.is_err() {
14561 self.control_handle.shutdown();
14562 }
14563 self.drop_without_shutdown();
14564 _result
14565 }
14566
14567 pub fn send_no_shutdown_on_err(
14569 self,
14570 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14571 ) -> Result<(), fidl::Error> {
14572 let _result = self.send_raw(result);
14573 self.drop_without_shutdown();
14574 _result
14575 }
14576
14577 fn send_raw(
14578 &self,
14579 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14580 ) -> Result<(), fidl::Error> {
14581 self.control_handle.inner.send::<fidl::encoding::ResultType<
14582 fidl::encoding::EmptyStruct,
14583 fidl_fuchsia_posix::Errno,
14584 >>(
14585 result,
14586 self.tx_id,
14587 0x157d51e98f462859,
14588 fidl::encoding::DynamicFlags::empty(),
14589 )
14590 }
14591}
14592
14593#[must_use = "FIDL methods require a response to be sent"]
14594#[derive(Debug)]
14595pub struct SocketGetIpv6UnicastHopsResponder {
14596 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14597 tx_id: u32,
14598}
14599
14600impl std::ops::Drop for SocketGetIpv6UnicastHopsResponder {
14604 fn drop(&mut self) {
14605 self.control_handle.shutdown();
14606 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14608 }
14609}
14610
14611impl fidl::endpoints::Responder for SocketGetIpv6UnicastHopsResponder {
14612 type ControlHandle = SocketControlHandle;
14613
14614 fn control_handle(&self) -> &SocketControlHandle {
14615 &self.control_handle
14616 }
14617
14618 fn drop_without_shutdown(mut self) {
14619 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14621 std::mem::forget(self);
14623 }
14624}
14625
14626impl SocketGetIpv6UnicastHopsResponder {
14627 pub fn send(
14631 self,
14632 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
14633 ) -> Result<(), fidl::Error> {
14634 let _result = self.send_raw(result);
14635 if _result.is_err() {
14636 self.control_handle.shutdown();
14637 }
14638 self.drop_without_shutdown();
14639 _result
14640 }
14641
14642 pub fn send_no_shutdown_on_err(
14644 self,
14645 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
14646 ) -> Result<(), fidl::Error> {
14647 let _result = self.send_raw(result);
14648 self.drop_without_shutdown();
14649 _result
14650 }
14651
14652 fn send_raw(
14653 &self,
14654 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
14655 ) -> Result<(), fidl::Error> {
14656 self.control_handle.inner.send::<fidl::encoding::ResultType<
14657 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResponse,
14658 fidl_fuchsia_posix::Errno,
14659 >>(
14660 result.map(|value| (value,)),
14661 self.tx_id,
14662 0x21f4641cad8bd8d2,
14663 fidl::encoding::DynamicFlags::empty(),
14664 )
14665 }
14666}
14667
14668#[must_use = "FIDL methods require a response to be sent"]
14669#[derive(Debug)]
14670pub struct SocketSetIpv6ReceiveHopLimitResponder {
14671 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14672 tx_id: u32,
14673}
14674
14675impl std::ops::Drop for SocketSetIpv6ReceiveHopLimitResponder {
14679 fn drop(&mut self) {
14680 self.control_handle.shutdown();
14681 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14683 }
14684}
14685
14686impl fidl::endpoints::Responder for SocketSetIpv6ReceiveHopLimitResponder {
14687 type ControlHandle = SocketControlHandle;
14688
14689 fn control_handle(&self) -> &SocketControlHandle {
14690 &self.control_handle
14691 }
14692
14693 fn drop_without_shutdown(mut self) {
14694 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14696 std::mem::forget(self);
14698 }
14699}
14700
14701impl SocketSetIpv6ReceiveHopLimitResponder {
14702 pub fn send(
14706 self,
14707 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14708 ) -> Result<(), fidl::Error> {
14709 let _result = self.send_raw(result);
14710 if _result.is_err() {
14711 self.control_handle.shutdown();
14712 }
14713 self.drop_without_shutdown();
14714 _result
14715 }
14716
14717 pub fn send_no_shutdown_on_err(
14719 self,
14720 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14721 ) -> Result<(), fidl::Error> {
14722 let _result = self.send_raw(result);
14723 self.drop_without_shutdown();
14724 _result
14725 }
14726
14727 fn send_raw(
14728 &self,
14729 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14730 ) -> Result<(), fidl::Error> {
14731 self.control_handle.inner.send::<fidl::encoding::ResultType<
14732 fidl::encoding::EmptyStruct,
14733 fidl_fuchsia_posix::Errno,
14734 >>(
14735 result,
14736 self.tx_id,
14737 0x5c24808ed2e84a1e,
14738 fidl::encoding::DynamicFlags::empty(),
14739 )
14740 }
14741}
14742
14743#[must_use = "FIDL methods require a response to be sent"]
14744#[derive(Debug)]
14745pub struct SocketGetIpv6ReceiveHopLimitResponder {
14746 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14747 tx_id: u32,
14748}
14749
14750impl std::ops::Drop for SocketGetIpv6ReceiveHopLimitResponder {
14754 fn drop(&mut self) {
14755 self.control_handle.shutdown();
14756 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14758 }
14759}
14760
14761impl fidl::endpoints::Responder for SocketGetIpv6ReceiveHopLimitResponder {
14762 type ControlHandle = SocketControlHandle;
14763
14764 fn control_handle(&self) -> &SocketControlHandle {
14765 &self.control_handle
14766 }
14767
14768 fn drop_without_shutdown(mut self) {
14769 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14771 std::mem::forget(self);
14773 }
14774}
14775
14776impl SocketGetIpv6ReceiveHopLimitResponder {
14777 pub fn send(
14781 self,
14782 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14783 ) -> Result<(), fidl::Error> {
14784 let _result = self.send_raw(result);
14785 if _result.is_err() {
14786 self.control_handle.shutdown();
14787 }
14788 self.drop_without_shutdown();
14789 _result
14790 }
14791
14792 pub fn send_no_shutdown_on_err(
14794 self,
14795 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14796 ) -> Result<(), fidl::Error> {
14797 let _result = self.send_raw(result);
14798 self.drop_without_shutdown();
14799 _result
14800 }
14801
14802 fn send_raw(
14803 &self,
14804 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14805 ) -> Result<(), fidl::Error> {
14806 self.control_handle.inner.send::<fidl::encoding::ResultType<
14807 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
14808 fidl_fuchsia_posix::Errno,
14809 >>(
14810 result.map(|value| (value,)),
14811 self.tx_id,
14812 0x341e06689885b4c0,
14813 fidl::encoding::DynamicFlags::empty(),
14814 )
14815 }
14816}
14817
14818#[must_use = "FIDL methods require a response to be sent"]
14819#[derive(Debug)]
14820pub struct SocketSetIpv6MulticastHopsResponder {
14821 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14822 tx_id: u32,
14823}
14824
14825impl std::ops::Drop for SocketSetIpv6MulticastHopsResponder {
14829 fn drop(&mut self) {
14830 self.control_handle.shutdown();
14831 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14833 }
14834}
14835
14836impl fidl::endpoints::Responder for SocketSetIpv6MulticastHopsResponder {
14837 type ControlHandle = SocketControlHandle;
14838
14839 fn control_handle(&self) -> &SocketControlHandle {
14840 &self.control_handle
14841 }
14842
14843 fn drop_without_shutdown(mut self) {
14844 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14846 std::mem::forget(self);
14848 }
14849}
14850
14851impl SocketSetIpv6MulticastHopsResponder {
14852 pub fn send(
14856 self,
14857 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14858 ) -> Result<(), fidl::Error> {
14859 let _result = self.send_raw(result);
14860 if _result.is_err() {
14861 self.control_handle.shutdown();
14862 }
14863 self.drop_without_shutdown();
14864 _result
14865 }
14866
14867 pub fn send_no_shutdown_on_err(
14869 self,
14870 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14871 ) -> Result<(), fidl::Error> {
14872 let _result = self.send_raw(result);
14873 self.drop_without_shutdown();
14874 _result
14875 }
14876
14877 fn send_raw(
14878 &self,
14879 mut result: Result<(), fidl_fuchsia_posix::Errno>,
14880 ) -> Result<(), fidl::Error> {
14881 self.control_handle.inner.send::<fidl::encoding::ResultType<
14882 fidl::encoding::EmptyStruct,
14883 fidl_fuchsia_posix::Errno,
14884 >>(
14885 result,
14886 self.tx_id,
14887 0x25b9cd4d181f82c1,
14888 fidl::encoding::DynamicFlags::empty(),
14889 )
14890 }
14891}
14892
14893#[must_use = "FIDL methods require a response to be sent"]
14894#[derive(Debug)]
14895pub struct SocketGetIpv6MulticastHopsResponder {
14896 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14897 tx_id: u32,
14898}
14899
14900impl std::ops::Drop for SocketGetIpv6MulticastHopsResponder {
14904 fn drop(&mut self) {
14905 self.control_handle.shutdown();
14906 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14908 }
14909}
14910
14911impl fidl::endpoints::Responder for SocketGetIpv6MulticastHopsResponder {
14912 type ControlHandle = SocketControlHandle;
14913
14914 fn control_handle(&self) -> &SocketControlHandle {
14915 &self.control_handle
14916 }
14917
14918 fn drop_without_shutdown(mut self) {
14919 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14921 std::mem::forget(self);
14923 }
14924}
14925
14926impl SocketGetIpv6MulticastHopsResponder {
14927 pub fn send(
14931 self,
14932 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
14933 ) -> Result<(), fidl::Error> {
14934 let _result = self.send_raw(result);
14935 if _result.is_err() {
14936 self.control_handle.shutdown();
14937 }
14938 self.drop_without_shutdown();
14939 _result
14940 }
14941
14942 pub fn send_no_shutdown_on_err(
14944 self,
14945 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
14946 ) -> Result<(), fidl::Error> {
14947 let _result = self.send_raw(result);
14948 self.drop_without_shutdown();
14949 _result
14950 }
14951
14952 fn send_raw(
14953 &self,
14954 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
14955 ) -> Result<(), fidl::Error> {
14956 self.control_handle.inner.send::<fidl::encoding::ResultType<
14957 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResponse,
14958 fidl_fuchsia_posix::Errno,
14959 >>(
14960 result.map(|value| (value,)),
14961 self.tx_id,
14962 0x52916948a365012a,
14963 fidl::encoding::DynamicFlags::empty(),
14964 )
14965 }
14966}
14967
14968#[must_use = "FIDL methods require a response to be sent"]
14969#[derive(Debug)]
14970pub struct SocketSetIpv6MulticastLoopbackResponder {
14971 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14972 tx_id: u32,
14973}
14974
14975impl std::ops::Drop for SocketSetIpv6MulticastLoopbackResponder {
14979 fn drop(&mut self) {
14980 self.control_handle.shutdown();
14981 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14983 }
14984}
14985
14986impl fidl::endpoints::Responder for SocketSetIpv6MulticastLoopbackResponder {
14987 type ControlHandle = SocketControlHandle;
14988
14989 fn control_handle(&self) -> &SocketControlHandle {
14990 &self.control_handle
14991 }
14992
14993 fn drop_without_shutdown(mut self) {
14994 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14996 std::mem::forget(self);
14998 }
14999}
15000
15001impl SocketSetIpv6MulticastLoopbackResponder {
15002 pub fn send(
15006 self,
15007 mut result: Result<(), fidl_fuchsia_posix::Errno>,
15008 ) -> Result<(), fidl::Error> {
15009 let _result = self.send_raw(result);
15010 if _result.is_err() {
15011 self.control_handle.shutdown();
15012 }
15013 self.drop_without_shutdown();
15014 _result
15015 }
15016
15017 pub fn send_no_shutdown_on_err(
15019 self,
15020 mut result: Result<(), fidl_fuchsia_posix::Errno>,
15021 ) -> Result<(), fidl::Error> {
15022 let _result = self.send_raw(result);
15023 self.drop_without_shutdown();
15024 _result
15025 }
15026
15027 fn send_raw(
15028 &self,
15029 mut result: Result<(), fidl_fuchsia_posix::Errno>,
15030 ) -> Result<(), fidl::Error> {
15031 self.control_handle.inner.send::<fidl::encoding::ResultType<
15032 fidl::encoding::EmptyStruct,
15033 fidl_fuchsia_posix::Errno,
15034 >>(
15035 result,
15036 self.tx_id,
15037 0x55701c409ff41b40,
15038 fidl::encoding::DynamicFlags::empty(),
15039 )
15040 }
15041}
15042
15043#[must_use = "FIDL methods require a response to be sent"]
15044#[derive(Debug)]
15045pub struct SocketGetIpv6MulticastLoopbackResponder {
15046 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15047 tx_id: u32,
15048}
15049
15050impl std::ops::Drop for SocketGetIpv6MulticastLoopbackResponder {
15054 fn drop(&mut self) {
15055 self.control_handle.shutdown();
15056 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15058 }
15059}
15060
15061impl fidl::endpoints::Responder for SocketGetIpv6MulticastLoopbackResponder {
15062 type ControlHandle = SocketControlHandle;
15063
15064 fn control_handle(&self) -> &SocketControlHandle {
15065 &self.control_handle
15066 }
15067
15068 fn drop_without_shutdown(mut self) {
15069 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15071 std::mem::forget(self);
15073 }
15074}
15075
15076impl SocketGetIpv6MulticastLoopbackResponder {
15077 pub fn send(
15081 self,
15082 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15083 ) -> Result<(), fidl::Error> {
15084 let _result = self.send_raw(result);
15085 if _result.is_err() {
15086 self.control_handle.shutdown();
15087 }
15088 self.drop_without_shutdown();
15089 _result
15090 }
15091
15092 pub fn send_no_shutdown_on_err(
15094 self,
15095 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15096 ) -> Result<(), fidl::Error> {
15097 let _result = self.send_raw(result);
15098 self.drop_without_shutdown();
15099 _result
15100 }
15101
15102 fn send_raw(
15103 &self,
15104 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15105 ) -> Result<(), fidl::Error> {
15106 self.control_handle.inner.send::<fidl::encoding::ResultType<
15107 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
15108 fidl_fuchsia_posix::Errno,
15109 >>(
15110 result.map(|value| (value,)),
15111 self.tx_id,
15112 0x4415b701fde319c3,
15113 fidl::encoding::DynamicFlags::empty(),
15114 )
15115 }
15116}
15117
15118#[must_use = "FIDL methods require a response to be sent"]
15119#[derive(Debug)]
15120pub struct SocketSetIpv6OnlyResponder {
15121 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15122 tx_id: u32,
15123}
15124
15125impl std::ops::Drop for SocketSetIpv6OnlyResponder {
15129 fn drop(&mut self) {
15130 self.control_handle.shutdown();
15131 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15133 }
15134}
15135
15136impl fidl::endpoints::Responder for SocketSetIpv6OnlyResponder {
15137 type ControlHandle = SocketControlHandle;
15138
15139 fn control_handle(&self) -> &SocketControlHandle {
15140 &self.control_handle
15141 }
15142
15143 fn drop_without_shutdown(mut self) {
15144 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15146 std::mem::forget(self);
15148 }
15149}
15150
15151impl SocketSetIpv6OnlyResponder {
15152 pub fn send(
15156 self,
15157 mut result: Result<(), fidl_fuchsia_posix::Errno>,
15158 ) -> Result<(), fidl::Error> {
15159 let _result = self.send_raw(result);
15160 if _result.is_err() {
15161 self.control_handle.shutdown();
15162 }
15163 self.drop_without_shutdown();
15164 _result
15165 }
15166
15167 pub fn send_no_shutdown_on_err(
15169 self,
15170 mut result: Result<(), fidl_fuchsia_posix::Errno>,
15171 ) -> Result<(), fidl::Error> {
15172 let _result = self.send_raw(result);
15173 self.drop_without_shutdown();
15174 _result
15175 }
15176
15177 fn send_raw(
15178 &self,
15179 mut result: Result<(), fidl_fuchsia_posix::Errno>,
15180 ) -> Result<(), fidl::Error> {
15181 self.control_handle.inner.send::<fidl::encoding::ResultType<
15182 fidl::encoding::EmptyStruct,
15183 fidl_fuchsia_posix::Errno,
15184 >>(
15185 result,
15186 self.tx_id,
15187 0x4873f1364758cbba,
15188 fidl::encoding::DynamicFlags::empty(),
15189 )
15190 }
15191}
15192
15193#[must_use = "FIDL methods require a response to be sent"]
15194#[derive(Debug)]
15195pub struct SocketGetIpv6OnlyResponder {
15196 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15197 tx_id: u32,
15198}
15199
15200impl std::ops::Drop for SocketGetIpv6OnlyResponder {
15204 fn drop(&mut self) {
15205 self.control_handle.shutdown();
15206 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15208 }
15209}
15210
15211impl fidl::endpoints::Responder for SocketGetIpv6OnlyResponder {
15212 type ControlHandle = SocketControlHandle;
15213
15214 fn control_handle(&self) -> &SocketControlHandle {
15215 &self.control_handle
15216 }
15217
15218 fn drop_without_shutdown(mut self) {
15219 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15221 std::mem::forget(self);
15223 }
15224}
15225
15226impl SocketGetIpv6OnlyResponder {
15227 pub fn send(
15231 self,
15232 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15233 ) -> Result<(), fidl::Error> {
15234 let _result = self.send_raw(result);
15235 if _result.is_err() {
15236 self.control_handle.shutdown();
15237 }
15238 self.drop_without_shutdown();
15239 _result
15240 }
15241
15242 pub fn send_no_shutdown_on_err(
15244 self,
15245 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15246 ) -> Result<(), fidl::Error> {
15247 let _result = self.send_raw(result);
15248 self.drop_without_shutdown();
15249 _result
15250 }
15251
15252 fn send_raw(
15253 &self,
15254 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15255 ) -> Result<(), fidl::Error> {
15256 self.control_handle.inner.send::<fidl::encoding::ResultType<
15257 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResponse,
15258 fidl_fuchsia_posix::Errno,
15259 >>(
15260 result.map(|value| (value,)),
15261 self.tx_id,
15262 0x4aa3340a1a26b89c,
15263 fidl::encoding::DynamicFlags::empty(),
15264 )
15265 }
15266}
15267
15268#[must_use = "FIDL methods require a response to be sent"]
15269#[derive(Debug)]
15270pub struct SocketSetIpv6ReceiveTrafficClassResponder {
15271 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15272 tx_id: u32,
15273}
15274
15275impl std::ops::Drop for SocketSetIpv6ReceiveTrafficClassResponder {
15279 fn drop(&mut self) {
15280 self.control_handle.shutdown();
15281 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15283 }
15284}
15285
15286impl fidl::endpoints::Responder for SocketSetIpv6ReceiveTrafficClassResponder {
15287 type ControlHandle = SocketControlHandle;
15288
15289 fn control_handle(&self) -> &SocketControlHandle {
15290 &self.control_handle
15291 }
15292
15293 fn drop_without_shutdown(mut self) {
15294 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15296 std::mem::forget(self);
15298 }
15299}
15300
15301impl SocketSetIpv6ReceiveTrafficClassResponder {
15302 pub fn send(
15306 self,
15307 mut result: Result<(), fidl_fuchsia_posix::Errno>,
15308 ) -> Result<(), fidl::Error> {
15309 let _result = self.send_raw(result);
15310 if _result.is_err() {
15311 self.control_handle.shutdown();
15312 }
15313 self.drop_without_shutdown();
15314 _result
15315 }
15316
15317 pub fn send_no_shutdown_on_err(
15319 self,
15320 mut result: Result<(), fidl_fuchsia_posix::Errno>,
15321 ) -> Result<(), fidl::Error> {
15322 let _result = self.send_raw(result);
15323 self.drop_without_shutdown();
15324 _result
15325 }
15326
15327 fn send_raw(
15328 &self,
15329 mut result: Result<(), fidl_fuchsia_posix::Errno>,
15330 ) -> Result<(), fidl::Error> {
15331 self.control_handle.inner.send::<fidl::encoding::ResultType<
15332 fidl::encoding::EmptyStruct,
15333 fidl_fuchsia_posix::Errno,
15334 >>(
15335 result,
15336 self.tx_id,
15337 0x58f07c8788d099a0,
15338 fidl::encoding::DynamicFlags::empty(),
15339 )
15340 }
15341}
15342
15343#[must_use = "FIDL methods require a response to be sent"]
15344#[derive(Debug)]
15345pub struct SocketGetIpv6ReceiveTrafficClassResponder {
15346 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15347 tx_id: u32,
15348}
15349
15350impl std::ops::Drop for SocketGetIpv6ReceiveTrafficClassResponder {
15354 fn drop(&mut self) {
15355 self.control_handle.shutdown();
15356 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15358 }
15359}
15360
15361impl fidl::endpoints::Responder for SocketGetIpv6ReceiveTrafficClassResponder {
15362 type ControlHandle = SocketControlHandle;
15363
15364 fn control_handle(&self) -> &SocketControlHandle {
15365 &self.control_handle
15366 }
15367
15368 fn drop_without_shutdown(mut self) {
15369 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15371 std::mem::forget(self);
15373 }
15374}
15375
15376impl SocketGetIpv6ReceiveTrafficClassResponder {
15377 pub fn send(
15381 self,
15382 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15383 ) -> Result<(), fidl::Error> {
15384 let _result = self.send_raw(result);
15385 if _result.is_err() {
15386 self.control_handle.shutdown();
15387 }
15388 self.drop_without_shutdown();
15389 _result
15390 }
15391
15392 pub fn send_no_shutdown_on_err(
15394 self,
15395 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15396 ) -> Result<(), fidl::Error> {
15397 let _result = self.send_raw(result);
15398 self.drop_without_shutdown();
15399 _result
15400 }
15401
15402 fn send_raw(
15403 &self,
15404 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15405 ) -> Result<(), fidl::Error> {
15406 self.control_handle.inner.send::<fidl::encoding::ResultType<
15407 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
15408 fidl_fuchsia_posix::Errno,
15409 >>(
15410 result.map(|value| (value,)),
15411 self.tx_id,
15412 0x2e334df1da553ffa,
15413 fidl::encoding::DynamicFlags::empty(),
15414 )
15415 }
15416}
15417
15418#[must_use = "FIDL methods require a response to be sent"]
15419#[derive(Debug)]
15420pub struct SocketSetIpv6TrafficClassResponder {
15421 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15422 tx_id: u32,
15423}
15424
15425impl std::ops::Drop for SocketSetIpv6TrafficClassResponder {
15429 fn drop(&mut self) {
15430 self.control_handle.shutdown();
15431 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15433 }
15434}
15435
15436impl fidl::endpoints::Responder for SocketSetIpv6TrafficClassResponder {
15437 type ControlHandle = SocketControlHandle;
15438
15439 fn control_handle(&self) -> &SocketControlHandle {
15440 &self.control_handle
15441 }
15442
15443 fn drop_without_shutdown(mut self) {
15444 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15446 std::mem::forget(self);
15448 }
15449}
15450
15451impl SocketSetIpv6TrafficClassResponder {
15452 pub fn send(
15456 self,
15457 mut result: Result<(), fidl_fuchsia_posix::Errno>,
15458 ) -> Result<(), fidl::Error> {
15459 let _result = self.send_raw(result);
15460 if _result.is_err() {
15461 self.control_handle.shutdown();
15462 }
15463 self.drop_without_shutdown();
15464 _result
15465 }
15466
15467 pub fn send_no_shutdown_on_err(
15469 self,
15470 mut result: Result<(), fidl_fuchsia_posix::Errno>,
15471 ) -> Result<(), fidl::Error> {
15472 let _result = self.send_raw(result);
15473 self.drop_without_shutdown();
15474 _result
15475 }
15476
15477 fn send_raw(
15478 &self,
15479 mut result: Result<(), fidl_fuchsia_posix::Errno>,
15480 ) -> Result<(), fidl::Error> {
15481 self.control_handle.inner.send::<fidl::encoding::ResultType<
15482 fidl::encoding::EmptyStruct,
15483 fidl_fuchsia_posix::Errno,
15484 >>(
15485 result,
15486 self.tx_id,
15487 0x6af077800c5a0b4f,
15488 fidl::encoding::DynamicFlags::empty(),
15489 )
15490 }
15491}
15492
15493#[must_use = "FIDL methods require a response to be sent"]
15494#[derive(Debug)]
15495pub struct SocketGetIpv6TrafficClassResponder {
15496 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15497 tx_id: u32,
15498}
15499
15500impl std::ops::Drop for SocketGetIpv6TrafficClassResponder {
15504 fn drop(&mut self) {
15505 self.control_handle.shutdown();
15506 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15508 }
15509}
15510
15511impl fidl::endpoints::Responder for SocketGetIpv6TrafficClassResponder {
15512 type ControlHandle = SocketControlHandle;
15513
15514 fn control_handle(&self) -> &SocketControlHandle {
15515 &self.control_handle
15516 }
15517
15518 fn drop_without_shutdown(mut self) {
15519 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15521 std::mem::forget(self);
15523 }
15524}
15525
15526impl SocketGetIpv6TrafficClassResponder {
15527 pub fn send(
15531 self,
15532 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
15533 ) -> Result<(), fidl::Error> {
15534 let _result = self.send_raw(result);
15535 if _result.is_err() {
15536 self.control_handle.shutdown();
15537 }
15538 self.drop_without_shutdown();
15539 _result
15540 }
15541
15542 pub fn send_no_shutdown_on_err(
15544 self,
15545 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
15546 ) -> Result<(), fidl::Error> {
15547 let _result = self.send_raw(result);
15548 self.drop_without_shutdown();
15549 _result
15550 }
15551
15552 fn send_raw(
15553 &self,
15554 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
15555 ) -> Result<(), fidl::Error> {
15556 self.control_handle.inner.send::<fidl::encoding::ResultType<
15557 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResponse,
15558 fidl_fuchsia_posix::Errno,
15559 >>(
15560 result.map(|value| (value,)),
15561 self.tx_id,
15562 0x6baf6eed8fc2f04,
15563 fidl::encoding::DynamicFlags::empty(),
15564 )
15565 }
15566}
15567
15568#[must_use = "FIDL methods require a response to be sent"]
15569#[derive(Debug)]
15570pub struct SocketSetIpv6ReceivePacketInfoResponder {
15571 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15572 tx_id: u32,
15573}
15574
15575impl std::ops::Drop for SocketSetIpv6ReceivePacketInfoResponder {
15579 fn drop(&mut self) {
15580 self.control_handle.shutdown();
15581 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15583 }
15584}
15585
15586impl fidl::endpoints::Responder for SocketSetIpv6ReceivePacketInfoResponder {
15587 type ControlHandle = SocketControlHandle;
15588
15589 fn control_handle(&self) -> &SocketControlHandle {
15590 &self.control_handle
15591 }
15592
15593 fn drop_without_shutdown(mut self) {
15594 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15596 std::mem::forget(self);
15598 }
15599}
15600
15601impl SocketSetIpv6ReceivePacketInfoResponder {
15602 pub fn send(
15606 self,
15607 mut result: Result<(), fidl_fuchsia_posix::Errno>,
15608 ) -> Result<(), fidl::Error> {
15609 let _result = self.send_raw(result);
15610 if _result.is_err() {
15611 self.control_handle.shutdown();
15612 }
15613 self.drop_without_shutdown();
15614 _result
15615 }
15616
15617 pub fn send_no_shutdown_on_err(
15619 self,
15620 mut result: Result<(), fidl_fuchsia_posix::Errno>,
15621 ) -> Result<(), fidl::Error> {
15622 let _result = self.send_raw(result);
15623 self.drop_without_shutdown();
15624 _result
15625 }
15626
15627 fn send_raw(
15628 &self,
15629 mut result: Result<(), fidl_fuchsia_posix::Errno>,
15630 ) -> Result<(), fidl::Error> {
15631 self.control_handle.inner.send::<fidl::encoding::ResultType<
15632 fidl::encoding::EmptyStruct,
15633 fidl_fuchsia_posix::Errno,
15634 >>(
15635 result,
15636 self.tx_id,
15637 0x19259775b1a92768,
15638 fidl::encoding::DynamicFlags::empty(),
15639 )
15640 }
15641}
15642
15643#[must_use = "FIDL methods require a response to be sent"]
15644#[derive(Debug)]
15645pub struct SocketGetIpv6ReceivePacketInfoResponder {
15646 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15647 tx_id: u32,
15648}
15649
15650impl std::ops::Drop for SocketGetIpv6ReceivePacketInfoResponder {
15654 fn drop(&mut self) {
15655 self.control_handle.shutdown();
15656 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15658 }
15659}
15660
15661impl fidl::endpoints::Responder for SocketGetIpv6ReceivePacketInfoResponder {
15662 type ControlHandle = SocketControlHandle;
15663
15664 fn control_handle(&self) -> &SocketControlHandle {
15665 &self.control_handle
15666 }
15667
15668 fn drop_without_shutdown(mut self) {
15669 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15671 std::mem::forget(self);
15673 }
15674}
15675
15676impl SocketGetIpv6ReceivePacketInfoResponder {
15677 pub fn send(
15681 self,
15682 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15683 ) -> Result<(), fidl::Error> {
15684 let _result = self.send_raw(result);
15685 if _result.is_err() {
15686 self.control_handle.shutdown();
15687 }
15688 self.drop_without_shutdown();
15689 _result
15690 }
15691
15692 pub fn send_no_shutdown_on_err(
15694 self,
15695 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15696 ) -> Result<(), fidl::Error> {
15697 let _result = self.send_raw(result);
15698 self.drop_without_shutdown();
15699 _result
15700 }
15701
15702 fn send_raw(
15703 &self,
15704 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15705 ) -> Result<(), fidl::Error> {
15706 self.control_handle.inner.send::<fidl::encoding::ResultType<
15707 fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
15708 fidl_fuchsia_posix::Errno,
15709 >>(
15710 result.map(|value| (value,)),
15711 self.tx_id,
15712 0x7acd4a2775baec75,
15713 fidl::encoding::DynamicFlags::empty(),
15714 )
15715 }
15716}
15717
15718#[must_use = "FIDL methods require a response to be sent"]
15719#[derive(Debug)]
15720pub struct SocketGetOriginalDestinationResponder {
15721 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15722 tx_id: u32,
15723}
15724
15725impl std::ops::Drop for SocketGetOriginalDestinationResponder {
15729 fn drop(&mut self) {
15730 self.control_handle.shutdown();
15731 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15733 }
15734}
15735
15736impl fidl::endpoints::Responder for SocketGetOriginalDestinationResponder {
15737 type ControlHandle = SocketControlHandle;
15738
15739 fn control_handle(&self) -> &SocketControlHandle {
15740 &self.control_handle
15741 }
15742
15743 fn drop_without_shutdown(mut self) {
15744 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15746 std::mem::forget(self);
15748 }
15749}
15750
15751impl SocketGetOriginalDestinationResponder {
15752 pub fn send(
15756 self,
15757 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
15758 ) -> Result<(), fidl::Error> {
15759 let _result = self.send_raw(result);
15760 if _result.is_err() {
15761 self.control_handle.shutdown();
15762 }
15763 self.drop_without_shutdown();
15764 _result
15765 }
15766
15767 pub fn send_no_shutdown_on_err(
15769 self,
15770 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
15771 ) -> Result<(), fidl::Error> {
15772 let _result = self.send_raw(result);
15773 self.drop_without_shutdown();
15774 _result
15775 }
15776
15777 fn send_raw(
15778 &self,
15779 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
15780 ) -> Result<(), fidl::Error> {
15781 self.control_handle.inner.send::<fidl::encoding::ResultType<
15782 fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResponse,
15783 fidl_fuchsia_posix::Errno,
15784 >>(
15785 result.map(|value| (value,)),
15786 self.tx_id,
15787 0x38bf28f0dafdbac0,
15788 fidl::encoding::DynamicFlags::empty(),
15789 )
15790 }
15791}
15792
15793#[must_use = "FIDL methods require a response to be sent"]
15794#[derive(Debug)]
15795pub struct SocketDescribeResponder {
15796 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15797 tx_id: u32,
15798}
15799
15800impl std::ops::Drop for SocketDescribeResponder {
15804 fn drop(&mut self) {
15805 self.control_handle.shutdown();
15806 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15808 }
15809}
15810
15811impl fidl::endpoints::Responder for SocketDescribeResponder {
15812 type ControlHandle = SocketControlHandle;
15813
15814 fn control_handle(&self) -> &SocketControlHandle {
15815 &self.control_handle
15816 }
15817
15818 fn drop_without_shutdown(mut self) {
15819 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15821 std::mem::forget(self);
15823 }
15824}
15825
15826impl SocketDescribeResponder {
15827 pub fn send(self, mut payload: SocketDescribeResponse) -> Result<(), fidl::Error> {
15831 let _result = self.send_raw(payload);
15832 if _result.is_err() {
15833 self.control_handle.shutdown();
15834 }
15835 self.drop_without_shutdown();
15836 _result
15837 }
15838
15839 pub fn send_no_shutdown_on_err(
15841 self,
15842 mut payload: SocketDescribeResponse,
15843 ) -> Result<(), fidl::Error> {
15844 let _result = self.send_raw(payload);
15845 self.drop_without_shutdown();
15846 _result
15847 }
15848
15849 fn send_raw(&self, mut payload: SocketDescribeResponse) -> Result<(), fidl::Error> {
15850 self.control_handle.inner.send::<SocketDescribeResponse>(
15851 &mut payload,
15852 self.tx_id,
15853 0x335706eccf54a135,
15854 fidl::encoding::DynamicFlags::empty(),
15855 )
15856 }
15857}
15858
15859#[must_use = "FIDL methods require a response to be sent"]
15860#[derive(Debug)]
15861pub struct SocketRecvMsgResponder {
15862 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15863 tx_id: u32,
15864}
15865
15866impl std::ops::Drop for SocketRecvMsgResponder {
15870 fn drop(&mut self) {
15871 self.control_handle.shutdown();
15872 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15874 }
15875}
15876
15877impl fidl::endpoints::Responder for SocketRecvMsgResponder {
15878 type ControlHandle = SocketControlHandle;
15879
15880 fn control_handle(&self) -> &SocketControlHandle {
15881 &self.control_handle
15882 }
15883
15884 fn drop_without_shutdown(mut self) {
15885 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15887 std::mem::forget(self);
15889 }
15890}
15891
15892impl SocketRecvMsgResponder {
15893 pub fn send(
15897 self,
15898 mut result: Result<
15899 (
15900 Option<&fidl_fuchsia_net::SocketAddress>,
15901 &[u8],
15902 &fidl_fuchsia_posix_socket::NetworkSocketRecvControlData,
15903 u32,
15904 ),
15905 fidl_fuchsia_posix::Errno,
15906 >,
15907 ) -> Result<(), fidl::Error> {
15908 let _result = self.send_raw(result);
15909 if _result.is_err() {
15910 self.control_handle.shutdown();
15911 }
15912 self.drop_without_shutdown();
15913 _result
15914 }
15915
15916 pub fn send_no_shutdown_on_err(
15918 self,
15919 mut result: Result<
15920 (
15921 Option<&fidl_fuchsia_net::SocketAddress>,
15922 &[u8],
15923 &fidl_fuchsia_posix_socket::NetworkSocketRecvControlData,
15924 u32,
15925 ),
15926 fidl_fuchsia_posix::Errno,
15927 >,
15928 ) -> Result<(), fidl::Error> {
15929 let _result = self.send_raw(result);
15930 self.drop_without_shutdown();
15931 _result
15932 }
15933
15934 fn send_raw(
15935 &self,
15936 mut result: Result<
15937 (
15938 Option<&fidl_fuchsia_net::SocketAddress>,
15939 &[u8],
15940 &fidl_fuchsia_posix_socket::NetworkSocketRecvControlData,
15941 u32,
15942 ),
15943 fidl_fuchsia_posix::Errno,
15944 >,
15945 ) -> Result<(), fidl::Error> {
15946 self.control_handle.inner.send::<fidl::encoding::ResultType<
15947 SocketRecvMsgResponse,
15948 fidl_fuchsia_posix::Errno,
15949 >>(
15950 result,
15951 self.tx_id,
15952 0x1dfb695351d3aa1d,
15953 fidl::encoding::DynamicFlags::empty(),
15954 )
15955 }
15956}
15957
15958#[must_use = "FIDL methods require a response to be sent"]
15959#[derive(Debug)]
15960pub struct SocketSendMsgResponder {
15961 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15962 tx_id: u32,
15963}
15964
15965impl std::ops::Drop for SocketSendMsgResponder {
15969 fn drop(&mut self) {
15970 self.control_handle.shutdown();
15971 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15973 }
15974}
15975
15976impl fidl::endpoints::Responder for SocketSendMsgResponder {
15977 type ControlHandle = SocketControlHandle;
15978
15979 fn control_handle(&self) -> &SocketControlHandle {
15980 &self.control_handle
15981 }
15982
15983 fn drop_without_shutdown(mut self) {
15984 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15986 std::mem::forget(self);
15988 }
15989}
15990
15991impl SocketSendMsgResponder {
15992 pub fn send(
15996 self,
15997 mut result: Result<(), fidl_fuchsia_posix::Errno>,
15998 ) -> Result<(), fidl::Error> {
15999 let _result = self.send_raw(result);
16000 if _result.is_err() {
16001 self.control_handle.shutdown();
16002 }
16003 self.drop_without_shutdown();
16004 _result
16005 }
16006
16007 pub fn send_no_shutdown_on_err(
16009 self,
16010 mut result: Result<(), fidl_fuchsia_posix::Errno>,
16011 ) -> Result<(), fidl::Error> {
16012 let _result = self.send_raw(result);
16013 self.drop_without_shutdown();
16014 _result
16015 }
16016
16017 fn send_raw(
16018 &self,
16019 mut result: Result<(), fidl_fuchsia_posix::Errno>,
16020 ) -> Result<(), fidl::Error> {
16021 self.control_handle.inner.send::<fidl::encoding::ResultType<
16022 fidl::encoding::EmptyStruct,
16023 fidl_fuchsia_posix::Errno,
16024 >>(
16025 result,
16026 self.tx_id,
16027 0x2cf1eac9a7fc8958,
16028 fidl::encoding::DynamicFlags::empty(),
16029 )
16030 }
16031}
16032
16033#[must_use = "FIDL methods require a response to be sent"]
16034#[derive(Debug)]
16035pub struct SocketGetInfoResponder {
16036 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
16037 tx_id: u32,
16038}
16039
16040impl std::ops::Drop for SocketGetInfoResponder {
16044 fn drop(&mut self) {
16045 self.control_handle.shutdown();
16046 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16048 }
16049}
16050
16051impl fidl::endpoints::Responder for SocketGetInfoResponder {
16052 type ControlHandle = SocketControlHandle;
16053
16054 fn control_handle(&self) -> &SocketControlHandle {
16055 &self.control_handle
16056 }
16057
16058 fn drop_without_shutdown(mut self) {
16059 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16061 std::mem::forget(self);
16063 }
16064}
16065
16066impl SocketGetInfoResponder {
16067 pub fn send(
16071 self,
16072 mut result: Result<
16073 (fidl_fuchsia_posix_socket::Domain, &ProtocolAssociation),
16074 fidl_fuchsia_posix::Errno,
16075 >,
16076 ) -> Result<(), fidl::Error> {
16077 let _result = self.send_raw(result);
16078 if _result.is_err() {
16079 self.control_handle.shutdown();
16080 }
16081 self.drop_without_shutdown();
16082 _result
16083 }
16084
16085 pub fn send_no_shutdown_on_err(
16087 self,
16088 mut result: Result<
16089 (fidl_fuchsia_posix_socket::Domain, &ProtocolAssociation),
16090 fidl_fuchsia_posix::Errno,
16091 >,
16092 ) -> Result<(), fidl::Error> {
16093 let _result = self.send_raw(result);
16094 self.drop_without_shutdown();
16095 _result
16096 }
16097
16098 fn send_raw(
16099 &self,
16100 mut result: Result<
16101 (fidl_fuchsia_posix_socket::Domain, &ProtocolAssociation),
16102 fidl_fuchsia_posix::Errno,
16103 >,
16104 ) -> Result<(), fidl::Error> {
16105 self.control_handle.inner.send::<fidl::encoding::ResultType<
16106 SocketGetInfoResponse,
16107 fidl_fuchsia_posix::Errno,
16108 >>(
16109 result,
16110 self.tx_id,
16111 0x39676f75aec339ba,
16112 fidl::encoding::DynamicFlags::empty(),
16113 )
16114 }
16115}
16116
16117#[must_use = "FIDL methods require a response to be sent"]
16118#[derive(Debug)]
16119pub struct SocketSetIpHeaderIncludedResponder {
16120 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
16121 tx_id: u32,
16122}
16123
16124impl std::ops::Drop for SocketSetIpHeaderIncludedResponder {
16128 fn drop(&mut self) {
16129 self.control_handle.shutdown();
16130 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16132 }
16133}
16134
16135impl fidl::endpoints::Responder for SocketSetIpHeaderIncludedResponder {
16136 type ControlHandle = SocketControlHandle;
16137
16138 fn control_handle(&self) -> &SocketControlHandle {
16139 &self.control_handle
16140 }
16141
16142 fn drop_without_shutdown(mut self) {
16143 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16145 std::mem::forget(self);
16147 }
16148}
16149
16150impl SocketSetIpHeaderIncludedResponder {
16151 pub fn send(
16155 self,
16156 mut result: Result<(), fidl_fuchsia_posix::Errno>,
16157 ) -> Result<(), fidl::Error> {
16158 let _result = self.send_raw(result);
16159 if _result.is_err() {
16160 self.control_handle.shutdown();
16161 }
16162 self.drop_without_shutdown();
16163 _result
16164 }
16165
16166 pub fn send_no_shutdown_on_err(
16168 self,
16169 mut result: Result<(), fidl_fuchsia_posix::Errno>,
16170 ) -> Result<(), fidl::Error> {
16171 let _result = self.send_raw(result);
16172 self.drop_without_shutdown();
16173 _result
16174 }
16175
16176 fn send_raw(
16177 &self,
16178 mut result: Result<(), fidl_fuchsia_posix::Errno>,
16179 ) -> Result<(), fidl::Error> {
16180 self.control_handle.inner.send::<fidl::encoding::ResultType<
16181 fidl::encoding::EmptyStruct,
16182 fidl_fuchsia_posix::Errno,
16183 >>(
16184 result,
16185 self.tx_id,
16186 0x5d06a606d95e8f3,
16187 fidl::encoding::DynamicFlags::empty(),
16188 )
16189 }
16190}
16191
16192#[must_use = "FIDL methods require a response to be sent"]
16193#[derive(Debug)]
16194pub struct SocketGetIpHeaderIncludedResponder {
16195 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
16196 tx_id: u32,
16197}
16198
16199impl std::ops::Drop for SocketGetIpHeaderIncludedResponder {
16203 fn drop(&mut self) {
16204 self.control_handle.shutdown();
16205 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16207 }
16208}
16209
16210impl fidl::endpoints::Responder for SocketGetIpHeaderIncludedResponder {
16211 type ControlHandle = SocketControlHandle;
16212
16213 fn control_handle(&self) -> &SocketControlHandle {
16214 &self.control_handle
16215 }
16216
16217 fn drop_without_shutdown(mut self) {
16218 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16220 std::mem::forget(self);
16222 }
16223}
16224
16225impl SocketGetIpHeaderIncludedResponder {
16226 pub fn send(
16230 self,
16231 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
16232 ) -> Result<(), fidl::Error> {
16233 let _result = self.send_raw(result);
16234 if _result.is_err() {
16235 self.control_handle.shutdown();
16236 }
16237 self.drop_without_shutdown();
16238 _result
16239 }
16240
16241 pub fn send_no_shutdown_on_err(
16243 self,
16244 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
16245 ) -> Result<(), fidl::Error> {
16246 let _result = self.send_raw(result);
16247 self.drop_without_shutdown();
16248 _result
16249 }
16250
16251 fn send_raw(
16252 &self,
16253 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
16254 ) -> Result<(), fidl::Error> {
16255 self.control_handle.inner.send::<fidl::encoding::ResultType<
16256 SocketGetIpHeaderIncludedResponse,
16257 fidl_fuchsia_posix::Errno,
16258 >>(
16259 result.map(|value| (value,)),
16260 self.tx_id,
16261 0x76125ad1f4d175f6,
16262 fidl::encoding::DynamicFlags::empty(),
16263 )
16264 }
16265}
16266
16267#[must_use = "FIDL methods require a response to be sent"]
16268#[derive(Debug)]
16269pub struct SocketSetIcmpv6FilterResponder {
16270 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
16271 tx_id: u32,
16272}
16273
16274impl std::ops::Drop for SocketSetIcmpv6FilterResponder {
16278 fn drop(&mut self) {
16279 self.control_handle.shutdown();
16280 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16282 }
16283}
16284
16285impl fidl::endpoints::Responder for SocketSetIcmpv6FilterResponder {
16286 type ControlHandle = SocketControlHandle;
16287
16288 fn control_handle(&self) -> &SocketControlHandle {
16289 &self.control_handle
16290 }
16291
16292 fn drop_without_shutdown(mut self) {
16293 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16295 std::mem::forget(self);
16297 }
16298}
16299
16300impl SocketSetIcmpv6FilterResponder {
16301 pub fn send(
16305 self,
16306 mut result: Result<(), fidl_fuchsia_posix::Errno>,
16307 ) -> Result<(), fidl::Error> {
16308 let _result = self.send_raw(result);
16309 if _result.is_err() {
16310 self.control_handle.shutdown();
16311 }
16312 self.drop_without_shutdown();
16313 _result
16314 }
16315
16316 pub fn send_no_shutdown_on_err(
16318 self,
16319 mut result: Result<(), fidl_fuchsia_posix::Errno>,
16320 ) -> Result<(), fidl::Error> {
16321 let _result = self.send_raw(result);
16322 self.drop_without_shutdown();
16323 _result
16324 }
16325
16326 fn send_raw(
16327 &self,
16328 mut result: Result<(), fidl_fuchsia_posix::Errno>,
16329 ) -> Result<(), fidl::Error> {
16330 self.control_handle.inner.send::<fidl::encoding::ResultType<
16331 fidl::encoding::EmptyStruct,
16332 fidl_fuchsia_posix::Errno,
16333 >>(
16334 result,
16335 self.tx_id,
16336 0x4ebea92a43ae68a9,
16337 fidl::encoding::DynamicFlags::empty(),
16338 )
16339 }
16340}
16341
16342#[must_use = "FIDL methods require a response to be sent"]
16343#[derive(Debug)]
16344pub struct SocketGetIcmpv6FilterResponder {
16345 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
16346 tx_id: u32,
16347}
16348
16349impl std::ops::Drop for SocketGetIcmpv6FilterResponder {
16353 fn drop(&mut self) {
16354 self.control_handle.shutdown();
16355 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16357 }
16358}
16359
16360impl fidl::endpoints::Responder for SocketGetIcmpv6FilterResponder {
16361 type ControlHandle = SocketControlHandle;
16362
16363 fn control_handle(&self) -> &SocketControlHandle {
16364 &self.control_handle
16365 }
16366
16367 fn drop_without_shutdown(mut self) {
16368 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16370 std::mem::forget(self);
16372 }
16373}
16374
16375impl SocketGetIcmpv6FilterResponder {
16376 pub fn send(
16380 self,
16381 mut result: Result<&Icmpv6Filter, fidl_fuchsia_posix::Errno>,
16382 ) -> Result<(), fidl::Error> {
16383 let _result = self.send_raw(result);
16384 if _result.is_err() {
16385 self.control_handle.shutdown();
16386 }
16387 self.drop_without_shutdown();
16388 _result
16389 }
16390
16391 pub fn send_no_shutdown_on_err(
16393 self,
16394 mut result: Result<&Icmpv6Filter, fidl_fuchsia_posix::Errno>,
16395 ) -> Result<(), fidl::Error> {
16396 let _result = self.send_raw(result);
16397 self.drop_without_shutdown();
16398 _result
16399 }
16400
16401 fn send_raw(
16402 &self,
16403 mut result: Result<&Icmpv6Filter, fidl_fuchsia_posix::Errno>,
16404 ) -> Result<(), fidl::Error> {
16405 self.control_handle.inner.send::<fidl::encoding::ResultType<
16406 SocketGetIcmpv6FilterResponse,
16407 fidl_fuchsia_posix::Errno,
16408 >>(
16409 result.map(|filter| (filter,)),
16410 self.tx_id,
16411 0x43bd4f3bc0970ace,
16412 fidl::encoding::DynamicFlags::empty(),
16413 )
16414 }
16415}
16416
16417#[must_use = "FIDL methods require a response to be sent"]
16418#[derive(Debug)]
16419pub struct SocketSetIpv6ChecksumResponder {
16420 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
16421 tx_id: u32,
16422}
16423
16424impl std::ops::Drop for SocketSetIpv6ChecksumResponder {
16428 fn drop(&mut self) {
16429 self.control_handle.shutdown();
16430 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16432 }
16433}
16434
16435impl fidl::endpoints::Responder for SocketSetIpv6ChecksumResponder {
16436 type ControlHandle = SocketControlHandle;
16437
16438 fn control_handle(&self) -> &SocketControlHandle {
16439 &self.control_handle
16440 }
16441
16442 fn drop_without_shutdown(mut self) {
16443 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16445 std::mem::forget(self);
16447 }
16448}
16449
16450impl SocketSetIpv6ChecksumResponder {
16451 pub fn send(
16455 self,
16456 mut result: Result<(), fidl_fuchsia_posix::Errno>,
16457 ) -> Result<(), fidl::Error> {
16458 let _result = self.send_raw(result);
16459 if _result.is_err() {
16460 self.control_handle.shutdown();
16461 }
16462 self.drop_without_shutdown();
16463 _result
16464 }
16465
16466 pub fn send_no_shutdown_on_err(
16468 self,
16469 mut result: Result<(), fidl_fuchsia_posix::Errno>,
16470 ) -> Result<(), fidl::Error> {
16471 let _result = self.send_raw(result);
16472 self.drop_without_shutdown();
16473 _result
16474 }
16475
16476 fn send_raw(
16477 &self,
16478 mut result: Result<(), fidl_fuchsia_posix::Errno>,
16479 ) -> Result<(), fidl::Error> {
16480 self.control_handle.inner.send::<fidl::encoding::ResultType<
16481 fidl::encoding::EmptyStruct,
16482 fidl_fuchsia_posix::Errno,
16483 >>(
16484 result,
16485 self.tx_id,
16486 0x18b7809577199cb4,
16487 fidl::encoding::DynamicFlags::empty(),
16488 )
16489 }
16490}
16491
16492#[must_use = "FIDL methods require a response to be sent"]
16493#[derive(Debug)]
16494pub struct SocketGetIpv6ChecksumResponder {
16495 control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
16496 tx_id: u32,
16497}
16498
16499impl std::ops::Drop for SocketGetIpv6ChecksumResponder {
16503 fn drop(&mut self) {
16504 self.control_handle.shutdown();
16505 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16507 }
16508}
16509
16510impl fidl::endpoints::Responder for SocketGetIpv6ChecksumResponder {
16511 type ControlHandle = SocketControlHandle;
16512
16513 fn control_handle(&self) -> &SocketControlHandle {
16514 &self.control_handle
16515 }
16516
16517 fn drop_without_shutdown(mut self) {
16518 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16520 std::mem::forget(self);
16522 }
16523}
16524
16525impl SocketGetIpv6ChecksumResponder {
16526 pub fn send(
16530 self,
16531 mut result: Result<&Ipv6ChecksumConfiguration, fidl_fuchsia_posix::Errno>,
16532 ) -> Result<(), fidl::Error> {
16533 let _result = self.send_raw(result);
16534 if _result.is_err() {
16535 self.control_handle.shutdown();
16536 }
16537 self.drop_without_shutdown();
16538 _result
16539 }
16540
16541 pub fn send_no_shutdown_on_err(
16543 self,
16544 mut result: Result<&Ipv6ChecksumConfiguration, fidl_fuchsia_posix::Errno>,
16545 ) -> Result<(), fidl::Error> {
16546 let _result = self.send_raw(result);
16547 self.drop_without_shutdown();
16548 _result
16549 }
16550
16551 fn send_raw(
16552 &self,
16553 mut result: Result<&Ipv6ChecksumConfiguration, fidl_fuchsia_posix::Errno>,
16554 ) -> Result<(), fidl::Error> {
16555 self.control_handle.inner.send::<fidl::encoding::ResultType<
16556 SocketGetIpv6ChecksumResponse,
16557 fidl_fuchsia_posix::Errno,
16558 >>(
16559 result.map(|config| (config,)),
16560 self.tx_id,
16561 0x1847bf5b2d263dd,
16562 fidl::encoding::DynamicFlags::empty(),
16563 )
16564 }
16565}
16566
16567mod internal {
16568 use super::*;
16569
16570 impl fidl::encoding::ResourceTypeMarker for ProviderSocketWithOptionsResponse {
16571 type Borrowed<'a> = &'a mut Self;
16572 fn take_or_borrow<'a>(
16573 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
16574 ) -> Self::Borrowed<'a> {
16575 value
16576 }
16577 }
16578
16579 unsafe impl fidl::encoding::TypeMarker for ProviderSocketWithOptionsResponse {
16580 type Owned = Self;
16581
16582 #[inline(always)]
16583 fn inline_align(_context: fidl::encoding::Context) -> usize {
16584 4
16585 }
16586
16587 #[inline(always)]
16588 fn inline_size(_context: fidl::encoding::Context) -> usize {
16589 4
16590 }
16591 }
16592
16593 unsafe impl
16594 fidl::encoding::Encode<
16595 ProviderSocketWithOptionsResponse,
16596 fidl::encoding::DefaultFuchsiaResourceDialect,
16597 > for &mut ProviderSocketWithOptionsResponse
16598 {
16599 #[inline]
16600 unsafe fn encode(
16601 self,
16602 encoder: &mut fidl::encoding::Encoder<
16603 '_,
16604 fidl::encoding::DefaultFuchsiaResourceDialect,
16605 >,
16606 offset: usize,
16607 _depth: fidl::encoding::Depth,
16608 ) -> fidl::Result<()> {
16609 encoder.debug_check_bounds::<ProviderSocketWithOptionsResponse>(offset);
16610 fidl::encoding::Encode::<ProviderSocketWithOptionsResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
16612 (
16613 <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.s),
16614 ),
16615 encoder, offset, _depth
16616 )
16617 }
16618 }
16619 unsafe impl<
16620 T0: fidl::encoding::Encode<
16621 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SocketMarker>>,
16622 fidl::encoding::DefaultFuchsiaResourceDialect,
16623 >,
16624 >
16625 fidl::encoding::Encode<
16626 ProviderSocketWithOptionsResponse,
16627 fidl::encoding::DefaultFuchsiaResourceDialect,
16628 > for (T0,)
16629 {
16630 #[inline]
16631 unsafe fn encode(
16632 self,
16633 encoder: &mut fidl::encoding::Encoder<
16634 '_,
16635 fidl::encoding::DefaultFuchsiaResourceDialect,
16636 >,
16637 offset: usize,
16638 depth: fidl::encoding::Depth,
16639 ) -> fidl::Result<()> {
16640 encoder.debug_check_bounds::<ProviderSocketWithOptionsResponse>(offset);
16641 self.0.encode(encoder, offset + 0, depth)?;
16645 Ok(())
16646 }
16647 }
16648
16649 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
16650 for ProviderSocketWithOptionsResponse
16651 {
16652 #[inline(always)]
16653 fn new_empty() -> Self {
16654 Self {
16655 s: fidl::new_empty!(
16656 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SocketMarker>>,
16657 fidl::encoding::DefaultFuchsiaResourceDialect
16658 ),
16659 }
16660 }
16661
16662 #[inline]
16663 unsafe fn decode(
16664 &mut self,
16665 decoder: &mut fidl::encoding::Decoder<
16666 '_,
16667 fidl::encoding::DefaultFuchsiaResourceDialect,
16668 >,
16669 offset: usize,
16670 _depth: fidl::encoding::Depth,
16671 ) -> fidl::Result<()> {
16672 decoder.debug_check_bounds::<Self>(offset);
16673 fidl::decode!(
16675 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SocketMarker>>,
16676 fidl::encoding::DefaultFuchsiaResourceDialect,
16677 &mut self.s,
16678 decoder,
16679 offset + 0,
16680 _depth
16681 )?;
16682 Ok(())
16683 }
16684 }
16685
16686 impl fidl::encoding::ResourceTypeMarker for ProviderSocketResponse {
16687 type Borrowed<'a> = &'a mut Self;
16688 fn take_or_borrow<'a>(
16689 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
16690 ) -> Self::Borrowed<'a> {
16691 value
16692 }
16693 }
16694
16695 unsafe impl fidl::encoding::TypeMarker for ProviderSocketResponse {
16696 type Owned = Self;
16697
16698 #[inline(always)]
16699 fn inline_align(_context: fidl::encoding::Context) -> usize {
16700 4
16701 }
16702
16703 #[inline(always)]
16704 fn inline_size(_context: fidl::encoding::Context) -> usize {
16705 4
16706 }
16707 }
16708
16709 unsafe impl
16710 fidl::encoding::Encode<
16711 ProviderSocketResponse,
16712 fidl::encoding::DefaultFuchsiaResourceDialect,
16713 > for &mut ProviderSocketResponse
16714 {
16715 #[inline]
16716 unsafe fn encode(
16717 self,
16718 encoder: &mut fidl::encoding::Encoder<
16719 '_,
16720 fidl::encoding::DefaultFuchsiaResourceDialect,
16721 >,
16722 offset: usize,
16723 _depth: fidl::encoding::Depth,
16724 ) -> fidl::Result<()> {
16725 encoder.debug_check_bounds::<ProviderSocketResponse>(offset);
16726 fidl::encoding::Encode::<ProviderSocketResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
16728 (
16729 <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.s),
16730 ),
16731 encoder, offset, _depth
16732 )
16733 }
16734 }
16735 unsafe impl<
16736 T0: fidl::encoding::Encode<
16737 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SocketMarker>>,
16738 fidl::encoding::DefaultFuchsiaResourceDialect,
16739 >,
16740 >
16741 fidl::encoding::Encode<
16742 ProviderSocketResponse,
16743 fidl::encoding::DefaultFuchsiaResourceDialect,
16744 > for (T0,)
16745 {
16746 #[inline]
16747 unsafe fn encode(
16748 self,
16749 encoder: &mut fidl::encoding::Encoder<
16750 '_,
16751 fidl::encoding::DefaultFuchsiaResourceDialect,
16752 >,
16753 offset: usize,
16754 depth: fidl::encoding::Depth,
16755 ) -> fidl::Result<()> {
16756 encoder.debug_check_bounds::<ProviderSocketResponse>(offset);
16757 self.0.encode(encoder, offset + 0, depth)?;
16761 Ok(())
16762 }
16763 }
16764
16765 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
16766 for ProviderSocketResponse
16767 {
16768 #[inline(always)]
16769 fn new_empty() -> Self {
16770 Self {
16771 s: fidl::new_empty!(
16772 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SocketMarker>>,
16773 fidl::encoding::DefaultFuchsiaResourceDialect
16774 ),
16775 }
16776 }
16777
16778 #[inline]
16779 unsafe fn decode(
16780 &mut self,
16781 decoder: &mut fidl::encoding::Decoder<
16782 '_,
16783 fidl::encoding::DefaultFuchsiaResourceDialect,
16784 >,
16785 offset: usize,
16786 _depth: fidl::encoding::Depth,
16787 ) -> fidl::Result<()> {
16788 decoder.debug_check_bounds::<Self>(offset);
16789 fidl::decode!(
16791 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SocketMarker>>,
16792 fidl::encoding::DefaultFuchsiaResourceDialect,
16793 &mut self.s,
16794 decoder,
16795 offset + 0,
16796 _depth
16797 )?;
16798 Ok(())
16799 }
16800 }
16801
16802 impl SocketDescribeResponse {
16803 #[inline(always)]
16804 fn max_ordinal_present(&self) -> u64 {
16805 if let Some(_) = self.event {
16806 return 1;
16807 }
16808 0
16809 }
16810 }
16811
16812 impl fidl::encoding::ResourceTypeMarker for SocketDescribeResponse {
16813 type Borrowed<'a> = &'a mut Self;
16814 fn take_or_borrow<'a>(
16815 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
16816 ) -> Self::Borrowed<'a> {
16817 value
16818 }
16819 }
16820
16821 unsafe impl fidl::encoding::TypeMarker for SocketDescribeResponse {
16822 type Owned = Self;
16823
16824 #[inline(always)]
16825 fn inline_align(_context: fidl::encoding::Context) -> usize {
16826 8
16827 }
16828
16829 #[inline(always)]
16830 fn inline_size(_context: fidl::encoding::Context) -> usize {
16831 16
16832 }
16833 }
16834
16835 unsafe impl
16836 fidl::encoding::Encode<
16837 SocketDescribeResponse,
16838 fidl::encoding::DefaultFuchsiaResourceDialect,
16839 > for &mut SocketDescribeResponse
16840 {
16841 unsafe fn encode(
16842 self,
16843 encoder: &mut fidl::encoding::Encoder<
16844 '_,
16845 fidl::encoding::DefaultFuchsiaResourceDialect,
16846 >,
16847 offset: usize,
16848 mut depth: fidl::encoding::Depth,
16849 ) -> fidl::Result<()> {
16850 encoder.debug_check_bounds::<SocketDescribeResponse>(offset);
16851 let max_ordinal: u64 = self.max_ordinal_present();
16853 encoder.write_num(max_ordinal, offset);
16854 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
16855 if max_ordinal == 0 {
16857 return Ok(());
16858 }
16859 depth.increment()?;
16860 let envelope_size = 8;
16861 let bytes_len = max_ordinal as usize * envelope_size;
16862 #[allow(unused_variables)]
16863 let offset = encoder.out_of_line_offset(bytes_len);
16864 let mut _prev_end_offset: usize = 0;
16865 if 1 > max_ordinal {
16866 return Ok(());
16867 }
16868
16869 let cur_offset: usize = (1 - 1) * envelope_size;
16872
16873 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16875
16876 fidl::encoding::encode_in_envelope_optional::<
16881 fidl::encoding::HandleType<
16882 fidl::EventPair,
16883 { fidl::ObjectType::EVENTPAIR.into_raw() },
16884 2147483648,
16885 >,
16886 fidl::encoding::DefaultFuchsiaResourceDialect,
16887 >(
16888 self.event.as_mut().map(
16889 <fidl::encoding::HandleType<
16890 fidl::EventPair,
16891 { fidl::ObjectType::EVENTPAIR.into_raw() },
16892 2147483648,
16893 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
16894 ),
16895 encoder,
16896 offset + cur_offset,
16897 depth,
16898 )?;
16899
16900 _prev_end_offset = cur_offset + envelope_size;
16901
16902 Ok(())
16903 }
16904 }
16905
16906 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
16907 for SocketDescribeResponse
16908 {
16909 #[inline(always)]
16910 fn new_empty() -> Self {
16911 Self::default()
16912 }
16913
16914 unsafe fn decode(
16915 &mut self,
16916 decoder: &mut fidl::encoding::Decoder<
16917 '_,
16918 fidl::encoding::DefaultFuchsiaResourceDialect,
16919 >,
16920 offset: usize,
16921 mut depth: fidl::encoding::Depth,
16922 ) -> fidl::Result<()> {
16923 decoder.debug_check_bounds::<Self>(offset);
16924 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
16925 None => return Err(fidl::Error::NotNullable),
16926 Some(len) => len,
16927 };
16928 if len == 0 {
16930 return Ok(());
16931 };
16932 depth.increment()?;
16933 let envelope_size = 8;
16934 let bytes_len = len * envelope_size;
16935 let offset = decoder.out_of_line_offset(bytes_len)?;
16936 let mut _next_ordinal_to_read = 0;
16938 let mut next_offset = offset;
16939 let end_offset = offset + bytes_len;
16940 _next_ordinal_to_read += 1;
16941 if next_offset >= end_offset {
16942 return Ok(());
16943 }
16944
16945 while _next_ordinal_to_read < 1 {
16947 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16948 _next_ordinal_to_read += 1;
16949 next_offset += envelope_size;
16950 }
16951
16952 let next_out_of_line = decoder.next_out_of_line();
16953 let handles_before = decoder.remaining_handles();
16954 if let Some((inlined, num_bytes, num_handles)) =
16955 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16956 {
16957 let member_inline_size = <fidl::encoding::HandleType<
16958 fidl::EventPair,
16959 { fidl::ObjectType::EVENTPAIR.into_raw() },
16960 2147483648,
16961 > as fidl::encoding::TypeMarker>::inline_size(
16962 decoder.context
16963 );
16964 if inlined != (member_inline_size <= 4) {
16965 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16966 }
16967 let inner_offset;
16968 let mut inner_depth = depth.clone();
16969 if inlined {
16970 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16971 inner_offset = next_offset;
16972 } else {
16973 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16974 inner_depth.increment()?;
16975 }
16976 let val_ref =
16977 self.event.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
16978 fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
16979 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16980 {
16981 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16982 }
16983 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16984 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16985 }
16986 }
16987
16988 next_offset += envelope_size;
16989
16990 while next_offset < end_offset {
16992 _next_ordinal_to_read += 1;
16993 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16994 next_offset += envelope_size;
16995 }
16996
16997 Ok(())
16998 }
16999 }
17000}