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__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
15pub struct ProviderDatagramSocketDeprecatedResponse {
16 pub s: fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
17}
18
19impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
20 for ProviderDatagramSocketDeprecatedResponse
21{
22}
23
24#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
25pub struct ProviderStreamSocketWithOptionsResponse {
26 pub s: fidl::endpoints::ClientEnd<StreamSocketMarker>,
27}
28
29impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
30 for ProviderStreamSocketWithOptionsResponse
31{
32}
33
34#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
35pub struct ProviderStreamSocketResponse {
36 pub s: fidl::endpoints::ClientEnd<StreamSocketMarker>,
37}
38
39impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
40 for ProviderStreamSocketResponse
41{
42}
43
44#[derive(Debug, PartialEq)]
45pub struct StreamSocketAcceptResponse {
46 pub addr: Option<Box<fidl_fuchsia_net::SocketAddress>>,
47 pub s: fidl::endpoints::ClientEnd<StreamSocketMarker>,
48}
49
50impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
51 for StreamSocketAcceptResponse
52{
53}
54
55#[derive(Debug, Default, PartialEq)]
56pub struct DatagramSocketDescribeResponse {
57 pub socket: Option<fidl::Socket>,
59 pub tx_meta_buf_size: Option<u64>,
61 pub rx_meta_buf_size: Option<u64>,
63 pub metadata_encoding_protocol_version: Option<UdpMetadataEncodingProtocolVersion>,
66 #[doc(hidden)]
67 pub __source_breaking: fidl::marker::SourceBreaking,
68}
69
70impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
71 for DatagramSocketDescribeResponse
72{
73}
74
75#[derive(Debug, Default, PartialEq)]
76pub struct DatagramSocketRecvMsgPostflightResponse {
77 pub validity: Option<fidl::EventPair>,
81 pub timestamp: Option<TimestampOption>,
84 pub requests: Option<CmsgRequests>,
89 #[doc(hidden)]
90 pub __source_breaking: fidl::marker::SourceBreaking,
91}
92
93impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
94 for DatagramSocketRecvMsgPostflightResponse
95{
96}
97
98#[derive(Debug, Default, PartialEq)]
99pub struct DatagramSocketSendMsgPreflightResponse {
100 pub to: Option<fidl_fuchsia_net::SocketAddress>,
104 pub validity: Option<Vec<fidl::EventPair>>,
110 pub maximum_size: Option<u32>,
114 #[doc(hidden)]
115 pub __source_breaking: fidl::marker::SourceBreaking,
116}
117
118impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
119 for DatagramSocketSendMsgPreflightResponse
120{
121}
122
123#[derive(Debug, Default, PartialEq)]
124pub struct StreamSocketDescribeResponse {
125 pub socket: Option<fidl::Socket>,
127 #[doc(hidden)]
128 pub __source_breaking: fidl::marker::SourceBreaking,
129}
130
131impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
132 for StreamSocketDescribeResponse
133{
134}
135
136#[derive(Debug, Default, PartialEq)]
137pub struct SynchronousDatagramSocketDescribeResponse {
138 pub event: Option<fidl::EventPair>,
141 #[doc(hidden)]
142 pub __source_breaking: fidl::marker::SourceBreaking,
143}
144
145impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
146 for SynchronousDatagramSocketDescribeResponse
147{
148}
149
150#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
151pub enum ProviderDatagramSocketWithOptionsResponse {
152 DatagramSocket(fidl::endpoints::ClientEnd<DatagramSocketMarker>),
153 SynchronousDatagramSocket(fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>),
154}
155
156impl ProviderDatagramSocketWithOptionsResponse {
157 #[inline]
158 pub fn ordinal(&self) -> u64 {
159 match *self {
160 Self::DatagramSocket(_) => 1,
161 Self::SynchronousDatagramSocket(_) => 2,
162 }
163 }
164}
165
166impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
167 for ProviderDatagramSocketWithOptionsResponse
168{
169}
170
171#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
172pub enum ProviderDatagramSocketResponse {
173 DatagramSocket(fidl::endpoints::ClientEnd<DatagramSocketMarker>),
174 SynchronousDatagramSocket(fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>),
175}
176
177impl ProviderDatagramSocketResponse {
178 #[inline]
179 pub fn ordinal(&self) -> u64 {
180 match *self {
181 Self::DatagramSocket(_) => 1,
182 Self::SynchronousDatagramSocket(_) => 2,
183 }
184 }
185}
186
187impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
188 for ProviderDatagramSocketResponse
189{
190}
191
192#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
193pub struct BaseDatagramSocketMarker;
194
195impl fidl::endpoints::ProtocolMarker for BaseDatagramSocketMarker {
196 type Proxy = BaseDatagramSocketProxy;
197 type RequestStream = BaseDatagramSocketRequestStream;
198 #[cfg(target_os = "fuchsia")]
199 type SynchronousProxy = BaseDatagramSocketSynchronousProxy;
200
201 const DEBUG_NAME: &'static str = "(anonymous) BaseDatagramSocket";
202}
203pub type BaseDatagramSocketGetInfoResult =
204 Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>;
205
206pub trait BaseDatagramSocketProxyInterface: Send + Sync {
207 fn r#clone(
208 &self,
209 request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
210 ) -> Result<(), fidl::Error>;
211 type CloseResponseFut: std::future::Future<
212 Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
213 > + Send;
214 fn r#close(&self) -> Self::CloseResponseFut;
215 type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
216 fn r#query(&self) -> Self::QueryResponseFut;
217 type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
218 + Send;
219 fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
220 type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
221 + Send;
222 fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
223 type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
224 + Send;
225 fn r#get_error(&self) -> Self::GetErrorResponseFut;
226 type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
227 + Send;
228 fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
229 type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
230 + Send;
231 fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
232 type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
233 + Send;
234 fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
235 type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
236 + Send;
237 fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
238 type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
239 + Send;
240 fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
241 type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
242 + Send;
243 fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
244 type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
245 + Send;
246 fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
247 type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
248 + Send;
249 fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
250 type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
251 + Send;
252 fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
253 type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
254 + Send;
255 fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
256 type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
257 + Send;
258 fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
259 type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
260 + Send;
261 fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
262 type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
263 + Send;
264 fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
265 type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
266 + Send;
267 fn r#get_linger(&self) -> Self::GetLingerResponseFut;
268 type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
269 + Send;
270 fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
271 type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
272 + Send;
273 fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
274 type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
275 + Send;
276 fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
277 type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
278 + Send;
279 fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
280 type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
281 + Send;
282 fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
283 type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
284 + Send;
285 fn r#set_bind_to_interface_index(&self, value: u64)
286 -> Self::SetBindToInterfaceIndexResponseFut;
287 type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
288 + Send;
289 fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
290 type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
291 + Send;
292 fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
293 type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
294 + Send;
295 fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
296 type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
297 + Send;
298 fn r#set_mark(
299 &self,
300 domain: fidl_fuchsia_net::MarkDomain,
301 mark: &OptionalUint32,
302 ) -> Self::SetMarkResponseFut;
303 type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
304 + Send;
305 fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
306 type BindResponseFut: std::future::Future<Output = Result<BaseNetworkSocketBindResult, fidl::Error>>
307 + Send;
308 fn r#bind(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut;
309 type ConnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketConnectResult, fidl::Error>>
310 + Send;
311 fn r#connect(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut;
312 type DisconnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDisconnectResult, fidl::Error>>
313 + Send;
314 fn r#disconnect(&self) -> Self::DisconnectResponseFut;
315 type GetSockNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetSockNameResult, fidl::Error>>
316 + Send;
317 fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
318 type GetPeerNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetPeerNameResult, fidl::Error>>
319 + Send;
320 fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
321 type ShutdownResponseFut: std::future::Future<Output = Result<BaseNetworkSocketShutdownResult, fidl::Error>>
322 + Send;
323 fn r#shutdown(&self, mode: ShutdownMode) -> Self::ShutdownResponseFut;
324 type SetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>>
325 + Send;
326 fn r#set_ip_type_of_service(&self, value: u8) -> Self::SetIpTypeOfServiceResponseFut;
327 type GetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>>
328 + Send;
329 fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut;
330 type SetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTtlResult, fidl::Error>>
331 + Send;
332 fn r#set_ip_ttl(&self, value: &OptionalUint8) -> Self::SetIpTtlResponseFut;
333 type GetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTtlResult, fidl::Error>>
334 + Send;
335 fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut;
336 type SetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>>
337 + Send;
338 fn r#set_ip_packet_info(&self, value: bool) -> Self::SetIpPacketInfoResponseFut;
339 type GetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>>
340 + Send;
341 fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut;
342 type SetIpReceiveTypeOfServiceResponseFut: std::future::Future<
343 Output = Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error>,
344 > + Send;
345 fn r#set_ip_receive_type_of_service(
346 &self,
347 value: bool,
348 ) -> Self::SetIpReceiveTypeOfServiceResponseFut;
349 type GetIpReceiveTypeOfServiceResponseFut: std::future::Future<
350 Output = Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error>,
351 > + Send;
352 fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut;
353 type SetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>>
354 + Send;
355 fn r#set_ip_receive_ttl(&self, value: bool) -> Self::SetIpReceiveTtlResponseFut;
356 type GetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>>
357 + Send;
358 fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut;
359 type SetIpMulticastInterfaceResponseFut: std::future::Future<
360 Output = Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error>,
361 > + Send;
362 fn r#set_ip_multicast_interface(
363 &self,
364 iface: u64,
365 address: &fidl_fuchsia_net::Ipv4Address,
366 ) -> Self::SetIpMulticastInterfaceResponseFut;
367 type GetIpMulticastInterfaceResponseFut: std::future::Future<
368 Output = Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error>,
369 > + Send;
370 fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut;
371 type SetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>>
372 + Send;
373 fn r#set_ip_multicast_ttl(&self, value: &OptionalUint8) -> Self::SetIpMulticastTtlResponseFut;
374 type GetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>>
375 + Send;
376 fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut;
377 type SetIpMulticastLoopbackResponseFut: std::future::Future<
378 Output = Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error>,
379 > + Send;
380 fn r#set_ip_multicast_loopback(&self, value: bool) -> Self::SetIpMulticastLoopbackResponseFut;
381 type GetIpMulticastLoopbackResponseFut: std::future::Future<
382 Output = Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error>,
383 > + Send;
384 fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut;
385 type AddIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error>>
386 + Send;
387 fn r#add_ip_membership(
388 &self,
389 membership: &IpMulticastMembership,
390 ) -> Self::AddIpMembershipResponseFut;
391 type DropIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error>>
392 + Send;
393 fn r#drop_ip_membership(
394 &self,
395 membership: &IpMulticastMembership,
396 ) -> Self::DropIpMembershipResponseFut;
397 type SetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error>>
398 + Send;
399 fn r#set_ip_transparent(&self, value: bool) -> Self::SetIpTransparentResponseFut;
400 type GetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error>>
401 + Send;
402 fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut;
403 type SetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
404 Output = Result<
405 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
406 fidl::Error,
407 >,
408 > + Send;
409 fn r#set_ip_receive_original_destination_address(
410 &self,
411 value: bool,
412 ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut;
413 type GetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
414 Output = Result<
415 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
416 fidl::Error,
417 >,
418 > + Send;
419 fn r#get_ip_receive_original_destination_address(
420 &self,
421 ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut;
422 type AddIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>>
423 + Send;
424 fn r#add_ipv6_membership(
425 &self,
426 membership: &Ipv6MulticastMembership,
427 ) -> Self::AddIpv6MembershipResponseFut;
428 type DropIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>>
429 + Send;
430 fn r#drop_ipv6_membership(
431 &self,
432 membership: &Ipv6MulticastMembership,
433 ) -> Self::DropIpv6MembershipResponseFut;
434 type SetIpv6MulticastInterfaceResponseFut: std::future::Future<
435 Output = Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error>,
436 > + Send;
437 fn r#set_ipv6_multicast_interface(
438 &self,
439 value: u64,
440 ) -> Self::SetIpv6MulticastInterfaceResponseFut;
441 type GetIpv6MulticastInterfaceResponseFut: std::future::Future<
442 Output = Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error>,
443 > + Send;
444 fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut;
445 type SetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>>
446 + Send;
447 fn r#set_ipv6_unicast_hops(&self, value: &OptionalUint8)
448 -> Self::SetIpv6UnicastHopsResponseFut;
449 type GetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>>
450 + Send;
451 fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut;
452 type SetIpv6ReceiveHopLimitResponseFut: std::future::Future<
453 Output = Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error>,
454 > + Send;
455 fn r#set_ipv6_receive_hop_limit(&self, value: bool) -> Self::SetIpv6ReceiveHopLimitResponseFut;
456 type GetIpv6ReceiveHopLimitResponseFut: std::future::Future<
457 Output = Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error>,
458 > + Send;
459 fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut;
460 type SetIpv6MulticastHopsResponseFut: std::future::Future<
461 Output = Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error>,
462 > + Send;
463 fn r#set_ipv6_multicast_hops(
464 &self,
465 value: &OptionalUint8,
466 ) -> Self::SetIpv6MulticastHopsResponseFut;
467 type GetIpv6MulticastHopsResponseFut: std::future::Future<
468 Output = Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error>,
469 > + Send;
470 fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut;
471 type SetIpv6MulticastLoopbackResponseFut: std::future::Future<
472 Output = Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error>,
473 > + Send;
474 fn r#set_ipv6_multicast_loopback(
475 &self,
476 value: bool,
477 ) -> Self::SetIpv6MulticastLoopbackResponseFut;
478 type GetIpv6MulticastLoopbackResponseFut: std::future::Future<
479 Output = Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error>,
480 > + Send;
481 fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut;
482 type SetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error>>
483 + Send;
484 fn r#set_ipv6_only(&self, value: bool) -> Self::SetIpv6OnlyResponseFut;
485 type GetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error>>
486 + Send;
487 fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut;
488 type SetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
489 Output = Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error>,
490 > + Send;
491 fn r#set_ipv6_receive_traffic_class(
492 &self,
493 value: bool,
494 ) -> Self::SetIpv6ReceiveTrafficClassResponseFut;
495 type GetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
496 Output = Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error>,
497 > + Send;
498 fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut;
499 type SetIpv6TrafficClassResponseFut: std::future::Future<
500 Output = Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error>,
501 > + Send;
502 fn r#set_ipv6_traffic_class(
503 &self,
504 value: &OptionalUint8,
505 ) -> Self::SetIpv6TrafficClassResponseFut;
506 type GetIpv6TrafficClassResponseFut: std::future::Future<
507 Output = Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error>,
508 > + Send;
509 fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut;
510 type SetIpv6ReceivePacketInfoResponseFut: std::future::Future<
511 Output = Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error>,
512 > + Send;
513 fn r#set_ipv6_receive_packet_info(
514 &self,
515 value: bool,
516 ) -> Self::SetIpv6ReceivePacketInfoResponseFut;
517 type GetIpv6ReceivePacketInfoResponseFut: std::future::Future<
518 Output = Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error>,
519 > + Send;
520 fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut;
521 type GetOriginalDestinationResponseFut: std::future::Future<
522 Output = Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error>,
523 > + Send;
524 fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut;
525 type GetInfoResponseFut: std::future::Future<Output = Result<BaseDatagramSocketGetInfoResult, fidl::Error>>
526 + Send;
527 fn r#get_info(&self) -> Self::GetInfoResponseFut;
528}
529#[derive(Debug)]
530#[cfg(target_os = "fuchsia")]
531pub struct BaseDatagramSocketSynchronousProxy {
532 client: fidl::client::sync::Client,
533}
534
535#[cfg(target_os = "fuchsia")]
536impl fidl::endpoints::SynchronousProxy for BaseDatagramSocketSynchronousProxy {
537 type Proxy = BaseDatagramSocketProxy;
538 type Protocol = BaseDatagramSocketMarker;
539
540 fn from_channel(inner: fidl::Channel) -> Self {
541 Self::new(inner)
542 }
543
544 fn into_channel(self) -> fidl::Channel {
545 self.client.into_channel()
546 }
547
548 fn as_channel(&self) -> &fidl::Channel {
549 self.client.as_channel()
550 }
551}
552
553#[cfg(target_os = "fuchsia")]
554impl BaseDatagramSocketSynchronousProxy {
555 pub fn new(channel: fidl::Channel) -> Self {
556 let protocol_name =
557 <BaseDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
558 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
559 }
560
561 pub fn into_channel(self) -> fidl::Channel {
562 self.client.into_channel()
563 }
564
565 pub fn wait_for_event(
568 &self,
569 deadline: zx::MonotonicInstant,
570 ) -> Result<BaseDatagramSocketEvent, fidl::Error> {
571 BaseDatagramSocketEvent::decode(self.client.wait_for_event(deadline)?)
572 }
573
574 pub fn r#clone(
575 &self,
576 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
577 ) -> Result<(), fidl::Error> {
578 self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
579 (request,),
580 0x20d8a7aba2168a79,
581 fidl::encoding::DynamicFlags::empty(),
582 )
583 }
584
585 pub fn r#close(
596 &self,
597 ___deadline: zx::MonotonicInstant,
598 ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
599 let _response = self.client.send_query::<
600 fidl::encoding::EmptyPayload,
601 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
602 >(
603 (),
604 0x5ac5d459ad7f657e,
605 fidl::encoding::DynamicFlags::empty(),
606 ___deadline,
607 )?;
608 Ok(_response.map(|x| x))
609 }
610
611 pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
612 let _response = self.client.send_query::<
613 fidl::encoding::EmptyPayload,
614 fidl_fuchsia_unknown::QueryableQueryResponse,
615 >(
616 (),
617 0x2658edee9decfc06,
618 fidl::encoding::DynamicFlags::empty(),
619 ___deadline,
620 )?;
621 Ok(_response.protocol)
622 }
623
624 pub fn r#set_reuse_address(
626 &self,
627 mut value: bool,
628 ___deadline: zx::MonotonicInstant,
629 ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
630 let _response =
631 self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
632 fidl::encoding::EmptyStruct,
633 fidl_fuchsia_posix::Errno,
634 >>(
635 (value,),
636 0x1fd74ee8b9a4a876,
637 fidl::encoding::DynamicFlags::empty(),
638 ___deadline,
639 )?;
640 Ok(_response.map(|x| x))
641 }
642
643 pub fn r#get_reuse_address(
645 &self,
646 ___deadline: zx::MonotonicInstant,
647 ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
648 let _response = self
649 .client
650 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
651 BaseSocketGetReuseAddressResponse,
652 fidl_fuchsia_posix::Errno,
653 >>(
654 (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
655 )?;
656 Ok(_response.map(|x| x.value))
657 }
658
659 pub fn r#get_error(
662 &self,
663 ___deadline: zx::MonotonicInstant,
664 ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
665 let _response =
666 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
667 fidl::encoding::EmptyStruct,
668 fidl_fuchsia_posix::Errno,
669 >>(
670 (),
671 0x5aad39b33e5f6ebb,
672 fidl::encoding::DynamicFlags::empty(),
673 ___deadline,
674 )?;
675 Ok(_response.map(|x| x))
676 }
677
678 pub fn r#set_broadcast(
680 &self,
681 mut value: bool,
682 ___deadline: zx::MonotonicInstant,
683 ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
684 let _response =
685 self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
686 fidl::encoding::EmptyStruct,
687 fidl_fuchsia_posix::Errno,
688 >>(
689 (value,),
690 0x6023e081ce3cd947,
691 fidl::encoding::DynamicFlags::empty(),
692 ___deadline,
693 )?;
694 Ok(_response.map(|x| x))
695 }
696
697 pub fn r#get_broadcast(
699 &self,
700 ___deadline: zx::MonotonicInstant,
701 ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
702 let _response =
703 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
704 BaseSocketGetBroadcastResponse,
705 fidl_fuchsia_posix::Errno,
706 >>(
707 (),
708 0x68796fc556f9780d,
709 fidl::encoding::DynamicFlags::empty(),
710 ___deadline,
711 )?;
712 Ok(_response.map(|x| x.value))
713 }
714
715 pub fn r#set_send_buffer(
717 &self,
718 mut value_bytes: u64,
719 ___deadline: zx::MonotonicInstant,
720 ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
721 let _response =
722 self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
723 fidl::encoding::EmptyStruct,
724 fidl_fuchsia_posix::Errno,
725 >>(
726 (value_bytes,),
727 0x756eac32d73a7a70,
728 fidl::encoding::DynamicFlags::empty(),
729 ___deadline,
730 )?;
731 Ok(_response.map(|x| x))
732 }
733
734 pub fn r#get_send_buffer(
736 &self,
737 ___deadline: zx::MonotonicInstant,
738 ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
739 let _response = self
740 .client
741 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
742 BaseSocketGetSendBufferResponse,
743 fidl_fuchsia_posix::Errno,
744 >>(
745 (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
746 )?;
747 Ok(_response.map(|x| x.value_bytes))
748 }
749
750 pub fn r#set_receive_buffer(
752 &self,
753 mut value_bytes: u64,
754 ___deadline: zx::MonotonicInstant,
755 ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
756 let _response =
757 self.client
758 .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
759 fidl::encoding::EmptyStruct,
760 fidl_fuchsia_posix::Errno,
761 >>(
762 (value_bytes,),
763 0x6b0cf2f1919c7001,
764 fidl::encoding::DynamicFlags::empty(),
765 ___deadline,
766 )?;
767 Ok(_response.map(|x| x))
768 }
769
770 pub fn r#get_receive_buffer(
772 &self,
773 ___deadline: zx::MonotonicInstant,
774 ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
775 let _response = self
776 .client
777 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
778 BaseSocketGetReceiveBufferResponse,
779 fidl_fuchsia_posix::Errno,
780 >>(
781 (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
782 )?;
783 Ok(_response.map(|x| x.value_bytes))
784 }
785
786 pub fn r#set_keep_alive(
788 &self,
789 mut value: bool,
790 ___deadline: zx::MonotonicInstant,
791 ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
792 let _response =
793 self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
794 fidl::encoding::EmptyStruct,
795 fidl_fuchsia_posix::Errno,
796 >>(
797 (value,),
798 0x572df8f0b920d2c7,
799 fidl::encoding::DynamicFlags::empty(),
800 ___deadline,
801 )?;
802 Ok(_response.map(|x| x))
803 }
804
805 pub fn r#get_keep_alive(
807 &self,
808 ___deadline: zx::MonotonicInstant,
809 ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
810 let _response =
811 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
812 BaseSocketGetKeepAliveResponse,
813 fidl_fuchsia_posix::Errno,
814 >>(
815 (),
816 0x2dd29d3215f2c9d2,
817 fidl::encoding::DynamicFlags::empty(),
818 ___deadline,
819 )?;
820 Ok(_response.map(|x| x.value))
821 }
822
823 pub fn r#set_out_of_band_inline(
825 &self,
826 mut value: bool,
827 ___deadline: zx::MonotonicInstant,
828 ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
829 let _response =
830 self.client
831 .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
832 fidl::encoding::EmptyStruct,
833 fidl_fuchsia_posix::Errno,
834 >>(
835 (value,),
836 0x3ecb49968bee439,
837 fidl::encoding::DynamicFlags::empty(),
838 ___deadline,
839 )?;
840 Ok(_response.map(|x| x))
841 }
842
843 pub fn r#get_out_of_band_inline(
845 &self,
846 ___deadline: zx::MonotonicInstant,
847 ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
848 let _response = self
849 .client
850 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
851 BaseSocketGetOutOfBandInlineResponse,
852 fidl_fuchsia_posix::Errno,
853 >>(
854 (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
855 )?;
856 Ok(_response.map(|x| x.value))
857 }
858
859 pub fn r#set_no_check(
861 &self,
862 mut value: bool,
863 ___deadline: zx::MonotonicInstant,
864 ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
865 let _response =
866 self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
867 fidl::encoding::EmptyStruct,
868 fidl_fuchsia_posix::Errno,
869 >>(
870 (value,),
871 0x6bbf00c53a4c78c2,
872 fidl::encoding::DynamicFlags::empty(),
873 ___deadline,
874 )?;
875 Ok(_response.map(|x| x))
876 }
877
878 pub fn r#get_no_check(
880 &self,
881 ___deadline: zx::MonotonicInstant,
882 ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
883 let _response =
884 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
885 BaseSocketGetNoCheckResponse,
886 fidl_fuchsia_posix::Errno,
887 >>(
888 (),
889 0x2cd4249286417694,
890 fidl::encoding::DynamicFlags::empty(),
891 ___deadline,
892 )?;
893 Ok(_response.map(|x| x.value))
894 }
895
896 pub fn r#set_linger(
898 &self,
899 mut linger: bool,
900 mut length_secs: u32,
901 ___deadline: zx::MonotonicInstant,
902 ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
903 let _response =
904 self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
905 fidl::encoding::EmptyStruct,
906 fidl_fuchsia_posix::Errno,
907 >>(
908 (linger, length_secs),
909 0x45386351246e998e,
910 fidl::encoding::DynamicFlags::empty(),
911 ___deadline,
912 )?;
913 Ok(_response.map(|x| x))
914 }
915
916 pub fn r#get_linger(
918 &self,
919 ___deadline: zx::MonotonicInstant,
920 ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
921 let _response =
922 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
923 BaseSocketGetLingerResponse,
924 fidl_fuchsia_posix::Errno,
925 >>(
926 (),
927 0x48eb20fc5ccb0e45,
928 fidl::encoding::DynamicFlags::empty(),
929 ___deadline,
930 )?;
931 Ok(_response.map(|x| (x.linger, x.length_secs)))
932 }
933
934 pub fn r#set_reuse_port(
936 &self,
937 mut value: bool,
938 ___deadline: zx::MonotonicInstant,
939 ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
940 let _response =
941 self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
942 fidl::encoding::EmptyStruct,
943 fidl_fuchsia_posix::Errno,
944 >>(
945 (value,),
946 0x24dd3e5cb36d9ccb,
947 fidl::encoding::DynamicFlags::empty(),
948 ___deadline,
949 )?;
950 Ok(_response.map(|x| x))
951 }
952
953 pub fn r#get_reuse_port(
955 &self,
956 ___deadline: zx::MonotonicInstant,
957 ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
958 let _response =
959 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
960 BaseSocketGetReusePortResponse,
961 fidl_fuchsia_posix::Errno,
962 >>(
963 (),
964 0x7a112c1ab54ff828,
965 fidl::encoding::DynamicFlags::empty(),
966 ___deadline,
967 )?;
968 Ok(_response.map(|x| x.value))
969 }
970
971 pub fn r#get_accept_conn(
973 &self,
974 ___deadline: zx::MonotonicInstant,
975 ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
976 let _response = self
977 .client
978 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
979 BaseSocketGetAcceptConnResponse,
980 fidl_fuchsia_posix::Errno,
981 >>(
982 (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
983 )?;
984 Ok(_response.map(|x| x.value))
985 }
986
987 pub fn r#set_bind_to_device(
989 &self,
990 mut value: &str,
991 ___deadline: zx::MonotonicInstant,
992 ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
993 let _response =
994 self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
995 fidl::encoding::EmptyStruct,
996 fidl_fuchsia_posix::Errno,
997 >>(
998 (value,),
999 0x2118b483f28aafc4,
1000 fidl::encoding::DynamicFlags::empty(),
1001 ___deadline,
1002 )?;
1003 Ok(_response.map(|x| x))
1004 }
1005
1006 pub fn r#get_bind_to_device(
1008 &self,
1009 ___deadline: zx::MonotonicInstant,
1010 ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
1011 let _response = self
1012 .client
1013 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1014 BaseSocketGetBindToDeviceResponse,
1015 fidl_fuchsia_posix::Errno,
1016 >>(
1017 (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
1018 )?;
1019 Ok(_response.map(|x| x.value))
1020 }
1021
1022 pub fn r#set_bind_to_interface_index(
1025 &self,
1026 mut value: u64,
1027 ___deadline: zx::MonotonicInstant,
1028 ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
1029 let _response =
1030 self.client
1031 .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
1032 fidl::encoding::EmptyStruct,
1033 fidl_fuchsia_posix::Errno,
1034 >>(
1035 (value,),
1036 0x6e387a0def00821,
1037 fidl::encoding::DynamicFlags::empty(),
1038 ___deadline,
1039 )?;
1040 Ok(_response.map(|x| x))
1041 }
1042
1043 pub fn r#get_bind_to_interface_index(
1045 &self,
1046 ___deadline: zx::MonotonicInstant,
1047 ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
1048 let _response = self
1049 .client
1050 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1051 BaseSocketGetBindToInterfaceIndexResponse,
1052 fidl_fuchsia_posix::Errno,
1053 >>(
1054 (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
1055 )?;
1056 Ok(_response.map(|x| x.value))
1057 }
1058
1059 pub fn r#set_timestamp(
1061 &self,
1062 mut value: TimestampOption,
1063 ___deadline: zx::MonotonicInstant,
1064 ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
1065 let _response =
1066 self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
1067 fidl::encoding::EmptyStruct,
1068 fidl_fuchsia_posix::Errno,
1069 >>(
1070 (value,),
1071 0x285d6516c263d839,
1072 fidl::encoding::DynamicFlags::empty(),
1073 ___deadline,
1074 )?;
1075 Ok(_response.map(|x| x))
1076 }
1077
1078 pub fn r#get_timestamp(
1080 &self,
1081 ___deadline: zx::MonotonicInstant,
1082 ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
1083 let _response =
1084 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1085 BaseSocketGetTimestampResponse,
1086 fidl_fuchsia_posix::Errno,
1087 >>(
1088 (),
1089 0x49f2fffbbcc2bd27,
1090 fidl::encoding::DynamicFlags::empty(),
1091 ___deadline,
1092 )?;
1093 Ok(_response.map(|x| x.value))
1094 }
1095
1096 pub fn r#set_mark(
1100 &self,
1101 mut domain: fidl_fuchsia_net::MarkDomain,
1102 mut mark: &OptionalUint32,
1103 ___deadline: zx::MonotonicInstant,
1104 ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
1105 let _response =
1106 self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
1107 fidl::encoding::EmptyStruct,
1108 fidl_fuchsia_posix::Errno,
1109 >>(
1110 (domain, mark),
1111 0x6ead6de09f653236,
1112 fidl::encoding::DynamicFlags::empty(),
1113 ___deadline,
1114 )?;
1115 Ok(_response.map(|x| x))
1116 }
1117
1118 pub fn r#get_mark(
1122 &self,
1123 mut domain: fidl_fuchsia_net::MarkDomain,
1124 ___deadline: zx::MonotonicInstant,
1125 ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
1126 let _response =
1127 self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
1128 BaseSocketGetMarkResponse,
1129 fidl_fuchsia_posix::Errno,
1130 >>(
1131 (domain,),
1132 0x57a2752c61d93d47,
1133 fidl::encoding::DynamicFlags::empty(),
1134 ___deadline,
1135 )?;
1136 Ok(_response.map(|x| x.mark))
1137 }
1138
1139 pub fn r#bind(
1141 &self,
1142 mut addr: &fidl_fuchsia_net::SocketAddress,
1143 ___deadline: zx::MonotonicInstant,
1144 ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
1145 let _response =
1146 self.client.send_query::<BaseNetworkSocketBindRequest, fidl::encoding::ResultType<
1147 fidl::encoding::EmptyStruct,
1148 fidl_fuchsia_posix::Errno,
1149 >>(
1150 (addr,),
1151 0x4bc6400ae92125d,
1152 fidl::encoding::DynamicFlags::empty(),
1153 ___deadline,
1154 )?;
1155 Ok(_response.map(|x| x))
1156 }
1157
1158 pub fn r#connect(
1160 &self,
1161 mut addr: &fidl_fuchsia_net::SocketAddress,
1162 ___deadline: zx::MonotonicInstant,
1163 ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
1164 let _response =
1165 self.client.send_query::<BaseNetworkSocketConnectRequest, fidl::encoding::ResultType<
1166 fidl::encoding::EmptyStruct,
1167 fidl_fuchsia_posix::Errno,
1168 >>(
1169 (addr,),
1170 0x5f05f19bfdd38871,
1171 fidl::encoding::DynamicFlags::empty(),
1172 ___deadline,
1173 )?;
1174 Ok(_response.map(|x| x))
1175 }
1176
1177 pub fn r#disconnect(
1179 &self,
1180 ___deadline: zx::MonotonicInstant,
1181 ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
1182 let _response =
1183 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1184 fidl::encoding::EmptyStruct,
1185 fidl_fuchsia_posix::Errno,
1186 >>(
1187 (),
1188 0x74e63b91f7b29b2,
1189 fidl::encoding::DynamicFlags::empty(),
1190 ___deadline,
1191 )?;
1192 Ok(_response.map(|x| x))
1193 }
1194
1195 pub fn r#get_sock_name(
1197 &self,
1198 ___deadline: zx::MonotonicInstant,
1199 ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
1200 let _response = self
1201 .client
1202 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1203 BaseNetworkSocketGetSockNameResponse,
1204 fidl_fuchsia_posix::Errno,
1205 >>(
1206 (), 0x475f23f84a1a4f85, fidl::encoding::DynamicFlags::empty(), ___deadline
1207 )?;
1208 Ok(_response.map(|x| x.addr))
1209 }
1210
1211 pub fn r#get_peer_name(
1213 &self,
1214 ___deadline: zx::MonotonicInstant,
1215 ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
1216 let _response = self
1217 .client
1218 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1219 BaseNetworkSocketGetPeerNameResponse,
1220 fidl_fuchsia_posix::Errno,
1221 >>(
1222 (), 0x1ffecf4bd5b6432e, fidl::encoding::DynamicFlags::empty(), ___deadline
1223 )?;
1224 Ok(_response.map(|x| x.addr))
1225 }
1226
1227 pub fn r#shutdown(
1229 &self,
1230 mut mode: ShutdownMode,
1231 ___deadline: zx::MonotonicInstant,
1232 ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
1233 let _response =
1234 self.client.send_query::<BaseNetworkSocketShutdownRequest, fidl::encoding::ResultType<
1235 fidl::encoding::EmptyStruct,
1236 fidl_fuchsia_posix::Errno,
1237 >>(
1238 (mode,),
1239 0x247f38b6db68c336,
1240 fidl::encoding::DynamicFlags::empty(),
1241 ___deadline,
1242 )?;
1243 Ok(_response.map(|x| x))
1244 }
1245
1246 pub fn r#set_ip_type_of_service(
1248 &self,
1249 mut value: u8,
1250 ___deadline: zx::MonotonicInstant,
1251 ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
1252 let _response = self.client.send_query::<
1253 BaseNetworkSocketSetIpTypeOfServiceRequest,
1254 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1255 >(
1256 (value,),
1257 0x995c600475b6d46,
1258 fidl::encoding::DynamicFlags::empty(),
1259 ___deadline,
1260 )?;
1261 Ok(_response.map(|x| x))
1262 }
1263
1264 pub fn r#get_ip_type_of_service(
1266 &self,
1267 ___deadline: zx::MonotonicInstant,
1268 ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
1269 let _response = self
1270 .client
1271 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1272 BaseNetworkSocketGetIpTypeOfServiceResponse,
1273 fidl_fuchsia_posix::Errno,
1274 >>(
1275 (), 0x3814a04259f75fcb, fidl::encoding::DynamicFlags::empty(), ___deadline
1276 )?;
1277 Ok(_response.map(|x| x.value))
1278 }
1279
1280 pub fn r#set_ip_ttl(
1282 &self,
1283 mut value: &OptionalUint8,
1284 ___deadline: zx::MonotonicInstant,
1285 ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
1286 let _response =
1287 self.client.send_query::<BaseNetworkSocketSetIpTtlRequest, fidl::encoding::ResultType<
1288 fidl::encoding::EmptyStruct,
1289 fidl_fuchsia_posix::Errno,
1290 >>(
1291 (value,),
1292 0x29e2424b433ae1ef,
1293 fidl::encoding::DynamicFlags::empty(),
1294 ___deadline,
1295 )?;
1296 Ok(_response.map(|x| x))
1297 }
1298
1299 pub fn r#get_ip_ttl(
1301 &self,
1302 ___deadline: zx::MonotonicInstant,
1303 ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
1304 let _response = self
1305 .client
1306 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1307 BaseNetworkSocketGetIpTtlResponse,
1308 fidl_fuchsia_posix::Errno,
1309 >>(
1310 (), 0x47e47fa1f24da471, fidl::encoding::DynamicFlags::empty(), ___deadline
1311 )?;
1312 Ok(_response.map(|x| x.value))
1313 }
1314
1315 pub fn r#set_ip_packet_info(
1317 &self,
1318 mut value: bool,
1319 ___deadline: zx::MonotonicInstant,
1320 ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
1321 let _response =
1322 self.client
1323 .send_query::<BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::ResultType<
1324 fidl::encoding::EmptyStruct,
1325 fidl_fuchsia_posix::Errno,
1326 >>(
1327 (value,),
1328 0x392d16bee20c0e16,
1329 fidl::encoding::DynamicFlags::empty(),
1330 ___deadline,
1331 )?;
1332 Ok(_response.map(|x| x))
1333 }
1334
1335 pub fn r#get_ip_packet_info(
1337 &self,
1338 ___deadline: zx::MonotonicInstant,
1339 ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
1340 let _response = self
1341 .client
1342 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1343 BaseNetworkSocketGetIpPacketInfoResponse,
1344 fidl_fuchsia_posix::Errno,
1345 >>(
1346 (), 0x54b505f242280740, fidl::encoding::DynamicFlags::empty(), ___deadline
1347 )?;
1348 Ok(_response.map(|x| x.value))
1349 }
1350
1351 pub fn r#set_ip_receive_type_of_service(
1353 &self,
1354 mut value: bool,
1355 ___deadline: zx::MonotonicInstant,
1356 ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
1357 let _response = self.client.send_query::<
1358 BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
1359 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1360 >(
1361 (value,),
1362 0x6c4f6714995f84ef,
1363 fidl::encoding::DynamicFlags::empty(),
1364 ___deadline,
1365 )?;
1366 Ok(_response.map(|x| x))
1367 }
1368
1369 pub fn r#get_ip_receive_type_of_service(
1371 &self,
1372 ___deadline: zx::MonotonicInstant,
1373 ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
1374 let _response = self
1375 .client
1376 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1377 BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
1378 fidl_fuchsia_posix::Errno,
1379 >>(
1380 (), 0x4158ba7dc2795960, fidl::encoding::DynamicFlags::empty(), ___deadline
1381 )?;
1382 Ok(_response.map(|x| x.value))
1383 }
1384
1385 pub fn r#set_ip_receive_ttl(
1387 &self,
1388 mut value: bool,
1389 ___deadline: zx::MonotonicInstant,
1390 ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
1391 let _response =
1392 self.client
1393 .send_query::<BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::ResultType<
1394 fidl::encoding::EmptyStruct,
1395 fidl_fuchsia_posix::Errno,
1396 >>(
1397 (value,),
1398 0x46f15be0ce0ab82b,
1399 fidl::encoding::DynamicFlags::empty(),
1400 ___deadline,
1401 )?;
1402 Ok(_response.map(|x| x))
1403 }
1404
1405 pub fn r#get_ip_receive_ttl(
1407 &self,
1408 ___deadline: zx::MonotonicInstant,
1409 ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
1410 let _response = self
1411 .client
1412 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1413 BaseNetworkSocketGetIpReceiveTtlResponse,
1414 fidl_fuchsia_posix::Errno,
1415 >>(
1416 (), 0x678ddd5a5dfa2eb5, fidl::encoding::DynamicFlags::empty(), ___deadline
1417 )?;
1418 Ok(_response.map(|x| x.value))
1419 }
1420
1421 pub fn r#set_ip_multicast_interface(
1423 &self,
1424 mut iface: u64,
1425 mut address: &fidl_fuchsia_net::Ipv4Address,
1426 ___deadline: zx::MonotonicInstant,
1427 ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
1428 let _response = self.client.send_query::<
1429 BaseNetworkSocketSetIpMulticastInterfaceRequest,
1430 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1431 >(
1432 (iface, address,),
1433 0x752fbfa9b12befe,
1434 fidl::encoding::DynamicFlags::empty(),
1435 ___deadline,
1436 )?;
1437 Ok(_response.map(|x| x))
1438 }
1439
1440 pub fn r#get_ip_multicast_interface(
1442 &self,
1443 ___deadline: zx::MonotonicInstant,
1444 ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
1445 let _response = self
1446 .client
1447 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1448 BaseNetworkSocketGetIpMulticastInterfaceResponse,
1449 fidl_fuchsia_posix::Errno,
1450 >>(
1451 (), 0x320bd14c4df046c4, fidl::encoding::DynamicFlags::empty(), ___deadline
1452 )?;
1453 Ok(_response.map(|x| x.value))
1454 }
1455
1456 pub fn r#set_ip_multicast_ttl(
1458 &self,
1459 mut value: &OptionalUint8,
1460 ___deadline: zx::MonotonicInstant,
1461 ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
1462 let _response =
1463 self.client
1464 .send_query::<BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::ResultType<
1465 fidl::encoding::EmptyStruct,
1466 fidl_fuchsia_posix::Errno,
1467 >>(
1468 (value,),
1469 0x63134d53772916a1,
1470 fidl::encoding::DynamicFlags::empty(),
1471 ___deadline,
1472 )?;
1473 Ok(_response.map(|x| x))
1474 }
1475
1476 pub fn r#get_ip_multicast_ttl(
1478 &self,
1479 ___deadline: zx::MonotonicInstant,
1480 ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
1481 let _response = self
1482 .client
1483 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1484 BaseNetworkSocketGetIpMulticastTtlResponse,
1485 fidl_fuchsia_posix::Errno,
1486 >>(
1487 (), 0x4665cd378f39e1a, fidl::encoding::DynamicFlags::empty(), ___deadline
1488 )?;
1489 Ok(_response.map(|x| x.value))
1490 }
1491
1492 pub fn r#set_ip_multicast_loopback(
1494 &self,
1495 mut value: bool,
1496 ___deadline: zx::MonotonicInstant,
1497 ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
1498 let _response = self.client.send_query::<
1499 BaseNetworkSocketSetIpMulticastLoopbackRequest,
1500 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1501 >(
1502 (value,),
1503 0x20c55c11f00943ea,
1504 fidl::encoding::DynamicFlags::empty(),
1505 ___deadline,
1506 )?;
1507 Ok(_response.map(|x| x))
1508 }
1509
1510 pub fn r#get_ip_multicast_loopback(
1512 &self,
1513 ___deadline: zx::MonotonicInstant,
1514 ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
1515 let _response = self
1516 .client
1517 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1518 BaseNetworkSocketGetIpMulticastLoopbackResponse,
1519 fidl_fuchsia_posix::Errno,
1520 >>(
1521 (), 0x3b6b26ff558298f2, fidl::encoding::DynamicFlags::empty(), ___deadline
1522 )?;
1523 Ok(_response.map(|x| x.value))
1524 }
1525
1526 pub fn r#add_ip_membership(
1528 &self,
1529 mut membership: &IpMulticastMembership,
1530 ___deadline: zx::MonotonicInstant,
1531 ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
1532 let _response =
1533 self.client
1534 .send_query::<BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::ResultType<
1535 fidl::encoding::EmptyStruct,
1536 fidl_fuchsia_posix::Errno,
1537 >>(
1538 (membership,),
1539 0x76bc7df115a3b4d0,
1540 fidl::encoding::DynamicFlags::empty(),
1541 ___deadline,
1542 )?;
1543 Ok(_response.map(|x| x))
1544 }
1545
1546 pub fn r#drop_ip_membership(
1548 &self,
1549 mut membership: &IpMulticastMembership,
1550 ___deadline: zx::MonotonicInstant,
1551 ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
1552 let _response =
1553 self.client
1554 .send_query::<BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::ResultType<
1555 fidl::encoding::EmptyStruct,
1556 fidl_fuchsia_posix::Errno,
1557 >>(
1558 (membership,),
1559 0x2888f3099188d03,
1560 fidl::encoding::DynamicFlags::empty(),
1561 ___deadline,
1562 )?;
1563 Ok(_response.map(|x| x))
1564 }
1565
1566 pub fn r#set_ip_transparent(
1568 &self,
1569 mut value: bool,
1570 ___deadline: zx::MonotonicInstant,
1571 ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
1572 let _response =
1573 self.client
1574 .send_query::<BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::ResultType<
1575 fidl::encoding::EmptyStruct,
1576 fidl_fuchsia_posix::Errno,
1577 >>(
1578 (value,),
1579 0x1ae532b0c066e3a0,
1580 fidl::encoding::DynamicFlags::empty(),
1581 ___deadline,
1582 )?;
1583 Ok(_response.map(|x| x))
1584 }
1585
1586 pub fn r#get_ip_transparent(
1588 &self,
1589 ___deadline: zx::MonotonicInstant,
1590 ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
1591 let _response = self
1592 .client
1593 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1594 BaseNetworkSocketGetIpTransparentResponse,
1595 fidl_fuchsia_posix::Errno,
1596 >>(
1597 (), 0x51d43695962ebfb5, fidl::encoding::DynamicFlags::empty(), ___deadline
1598 )?;
1599 Ok(_response.map(|x| x.value))
1600 }
1601
1602 pub fn r#set_ip_receive_original_destination_address(
1604 &self,
1605 mut value: bool,
1606 ___deadline: zx::MonotonicInstant,
1607 ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
1608 let _response = self.client.send_query::<
1609 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
1610 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1611 >(
1612 (value,),
1613 0x4722b4ce52f7840,
1614 fidl::encoding::DynamicFlags::empty(),
1615 ___deadline,
1616 )?;
1617 Ok(_response.map(|x| x))
1618 }
1619
1620 pub fn r#get_ip_receive_original_destination_address(
1622 &self,
1623 ___deadline: zx::MonotonicInstant,
1624 ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
1625 let _response = self
1626 .client
1627 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1628 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
1629 fidl_fuchsia_posix::Errno,
1630 >>(
1631 (), 0x2a0e7dc5d6bfdfe9, fidl::encoding::DynamicFlags::empty(), ___deadline
1632 )?;
1633 Ok(_response.map(|x| x.value))
1634 }
1635
1636 pub fn r#add_ipv6_membership(
1638 &self,
1639 mut membership: &Ipv6MulticastMembership,
1640 ___deadline: zx::MonotonicInstant,
1641 ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
1642 let _response =
1643 self.client
1644 .send_query::<BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::ResultType<
1645 fidl::encoding::EmptyStruct,
1646 fidl_fuchsia_posix::Errno,
1647 >>(
1648 (membership,),
1649 0x7c94727acb4ea4b3,
1650 fidl::encoding::DynamicFlags::empty(),
1651 ___deadline,
1652 )?;
1653 Ok(_response.map(|x| x))
1654 }
1655
1656 pub fn r#drop_ipv6_membership(
1658 &self,
1659 mut membership: &Ipv6MulticastMembership,
1660 ___deadline: zx::MonotonicInstant,
1661 ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
1662 let _response = self.client.send_query::<
1663 BaseNetworkSocketDropIpv6MembershipRequest,
1664 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1665 >(
1666 (membership,),
1667 0x42104c70ccaba304,
1668 fidl::encoding::DynamicFlags::empty(),
1669 ___deadline,
1670 )?;
1671 Ok(_response.map(|x| x))
1672 }
1673
1674 pub fn r#set_ipv6_multicast_interface(
1676 &self,
1677 mut value: u64,
1678 ___deadline: zx::MonotonicInstant,
1679 ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
1680 let _response = self.client.send_query::<
1681 BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
1682 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1683 >(
1684 (value,),
1685 0x135f76db3774ab3b,
1686 fidl::encoding::DynamicFlags::empty(),
1687 ___deadline,
1688 )?;
1689 Ok(_response.map(|x| x))
1690 }
1691
1692 pub fn r#get_ipv6_multicast_interface(
1694 &self,
1695 ___deadline: zx::MonotonicInstant,
1696 ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
1697 let _response = self
1698 .client
1699 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1700 BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
1701 fidl_fuchsia_posix::Errno,
1702 >>(
1703 (), 0x1f26fcdd348f1882, fidl::encoding::DynamicFlags::empty(), ___deadline
1704 )?;
1705 Ok(_response.map(|x| x.value))
1706 }
1707
1708 pub fn r#set_ipv6_unicast_hops(
1710 &self,
1711 mut value: &OptionalUint8,
1712 ___deadline: zx::MonotonicInstant,
1713 ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
1714 let _response = self.client.send_query::<
1715 BaseNetworkSocketSetIpv6UnicastHopsRequest,
1716 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1717 >(
1718 (value,),
1719 0x157d51e98f462859,
1720 fidl::encoding::DynamicFlags::empty(),
1721 ___deadline,
1722 )?;
1723 Ok(_response.map(|x| x))
1724 }
1725
1726 pub fn r#get_ipv6_unicast_hops(
1728 &self,
1729 ___deadline: zx::MonotonicInstant,
1730 ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
1731 let _response = self
1732 .client
1733 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1734 BaseNetworkSocketGetIpv6UnicastHopsResponse,
1735 fidl_fuchsia_posix::Errno,
1736 >>(
1737 (), 0x21f4641cad8bd8d2, fidl::encoding::DynamicFlags::empty(), ___deadline
1738 )?;
1739 Ok(_response.map(|x| x.value))
1740 }
1741
1742 pub fn r#set_ipv6_receive_hop_limit(
1744 &self,
1745 mut value: bool,
1746 ___deadline: zx::MonotonicInstant,
1747 ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
1748 let _response = self.client.send_query::<
1749 BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
1750 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1751 >(
1752 (value,),
1753 0x5c24808ed2e84a1e,
1754 fidl::encoding::DynamicFlags::empty(),
1755 ___deadline,
1756 )?;
1757 Ok(_response.map(|x| x))
1758 }
1759
1760 pub fn r#get_ipv6_receive_hop_limit(
1762 &self,
1763 ___deadline: zx::MonotonicInstant,
1764 ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
1765 let _response = self
1766 .client
1767 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1768 BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
1769 fidl_fuchsia_posix::Errno,
1770 >>(
1771 (), 0x341e06689885b4c0, fidl::encoding::DynamicFlags::empty(), ___deadline
1772 )?;
1773 Ok(_response.map(|x| x.value))
1774 }
1775
1776 pub fn r#set_ipv6_multicast_hops(
1778 &self,
1779 mut value: &OptionalUint8,
1780 ___deadline: zx::MonotonicInstant,
1781 ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
1782 let _response = self.client.send_query::<
1783 BaseNetworkSocketSetIpv6MulticastHopsRequest,
1784 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1785 >(
1786 (value,),
1787 0x25b9cd4d181f82c1,
1788 fidl::encoding::DynamicFlags::empty(),
1789 ___deadline,
1790 )?;
1791 Ok(_response.map(|x| x))
1792 }
1793
1794 pub fn r#get_ipv6_multicast_hops(
1796 &self,
1797 ___deadline: zx::MonotonicInstant,
1798 ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
1799 let _response = self
1800 .client
1801 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1802 BaseNetworkSocketGetIpv6MulticastHopsResponse,
1803 fidl_fuchsia_posix::Errno,
1804 >>(
1805 (), 0x52916948a365012a, fidl::encoding::DynamicFlags::empty(), ___deadline
1806 )?;
1807 Ok(_response.map(|x| x.value))
1808 }
1809
1810 pub fn r#set_ipv6_multicast_loopback(
1812 &self,
1813 mut value: bool,
1814 ___deadline: zx::MonotonicInstant,
1815 ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
1816 let _response = self.client.send_query::<
1817 BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
1818 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1819 >(
1820 (value,),
1821 0x55701c409ff41b40,
1822 fidl::encoding::DynamicFlags::empty(),
1823 ___deadline,
1824 )?;
1825 Ok(_response.map(|x| x))
1826 }
1827
1828 pub fn r#get_ipv6_multicast_loopback(
1830 &self,
1831 ___deadline: zx::MonotonicInstant,
1832 ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
1833 let _response = self
1834 .client
1835 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1836 BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
1837 fidl_fuchsia_posix::Errno,
1838 >>(
1839 (), 0x4415b701fde319c3, fidl::encoding::DynamicFlags::empty(), ___deadline
1840 )?;
1841 Ok(_response.map(|x| x.value))
1842 }
1843
1844 pub fn r#set_ipv6_only(
1846 &self,
1847 mut value: bool,
1848 ___deadline: zx::MonotonicInstant,
1849 ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
1850 let _response =
1851 self.client
1852 .send_query::<BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::ResultType<
1853 fidl::encoding::EmptyStruct,
1854 fidl_fuchsia_posix::Errno,
1855 >>(
1856 (value,),
1857 0x4873f1364758cbba,
1858 fidl::encoding::DynamicFlags::empty(),
1859 ___deadline,
1860 )?;
1861 Ok(_response.map(|x| x))
1862 }
1863
1864 pub fn r#get_ipv6_only(
1866 &self,
1867 ___deadline: zx::MonotonicInstant,
1868 ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
1869 let _response = self
1870 .client
1871 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1872 BaseNetworkSocketGetIpv6OnlyResponse,
1873 fidl_fuchsia_posix::Errno,
1874 >>(
1875 (), 0x4aa3340a1a26b89c, fidl::encoding::DynamicFlags::empty(), ___deadline
1876 )?;
1877 Ok(_response.map(|x| x.value))
1878 }
1879
1880 pub fn r#set_ipv6_receive_traffic_class(
1882 &self,
1883 mut value: bool,
1884 ___deadline: zx::MonotonicInstant,
1885 ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
1886 let _response = self.client.send_query::<
1887 BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
1888 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1889 >(
1890 (value,),
1891 0x58f07c8788d099a0,
1892 fidl::encoding::DynamicFlags::empty(),
1893 ___deadline,
1894 )?;
1895 Ok(_response.map(|x| x))
1896 }
1897
1898 pub fn r#get_ipv6_receive_traffic_class(
1900 &self,
1901 ___deadline: zx::MonotonicInstant,
1902 ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
1903 let _response = self
1904 .client
1905 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1906 BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
1907 fidl_fuchsia_posix::Errno,
1908 >>(
1909 (), 0x2e334df1da553ffa, fidl::encoding::DynamicFlags::empty(), ___deadline
1910 )?;
1911 Ok(_response.map(|x| x.value))
1912 }
1913
1914 pub fn r#set_ipv6_traffic_class(
1916 &self,
1917 mut value: &OptionalUint8,
1918 ___deadline: zx::MonotonicInstant,
1919 ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
1920 let _response = self.client.send_query::<
1921 BaseNetworkSocketSetIpv6TrafficClassRequest,
1922 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1923 >(
1924 (value,),
1925 0x6af077800c5a0b4f,
1926 fidl::encoding::DynamicFlags::empty(),
1927 ___deadline,
1928 )?;
1929 Ok(_response.map(|x| x))
1930 }
1931
1932 pub fn r#get_ipv6_traffic_class(
1934 &self,
1935 ___deadline: zx::MonotonicInstant,
1936 ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
1937 let _response = self
1938 .client
1939 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1940 BaseNetworkSocketGetIpv6TrafficClassResponse,
1941 fidl_fuchsia_posix::Errno,
1942 >>(
1943 (), 0x6baf6eed8fc2f04, fidl::encoding::DynamicFlags::empty(), ___deadline
1944 )?;
1945 Ok(_response.map(|x| x.value))
1946 }
1947
1948 pub fn r#set_ipv6_receive_packet_info(
1950 &self,
1951 mut value: bool,
1952 ___deadline: zx::MonotonicInstant,
1953 ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
1954 let _response = self.client.send_query::<
1955 BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
1956 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1957 >(
1958 (value,),
1959 0x19259775b1a92768,
1960 fidl::encoding::DynamicFlags::empty(),
1961 ___deadline,
1962 )?;
1963 Ok(_response.map(|x| x))
1964 }
1965
1966 pub fn r#get_ipv6_receive_packet_info(
1968 &self,
1969 ___deadline: zx::MonotonicInstant,
1970 ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
1971 let _response = self
1972 .client
1973 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1974 BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
1975 fidl_fuchsia_posix::Errno,
1976 >>(
1977 (), 0x7acd4a2775baec75, fidl::encoding::DynamicFlags::empty(), ___deadline
1978 )?;
1979 Ok(_response.map(|x| x.value))
1980 }
1981
1982 pub fn r#get_original_destination(
1984 &self,
1985 ___deadline: zx::MonotonicInstant,
1986 ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
1987 let _response = self
1988 .client
1989 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1990 BaseNetworkSocketGetOriginalDestinationResponse,
1991 fidl_fuchsia_posix::Errno,
1992 >>(
1993 (), 0x38bf28f0dafdbac0, fidl::encoding::DynamicFlags::empty(), ___deadline
1994 )?;
1995 Ok(_response.map(|x| x.value))
1996 }
1997
1998 pub fn r#get_info(
2003 &self,
2004 ___deadline: zx::MonotonicInstant,
2005 ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
2006 let _response = self
2007 .client
2008 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2009 BaseDatagramSocketGetInfoResponse,
2010 fidl_fuchsia_posix::Errno,
2011 >>(
2012 (), 0x48aa0a1f6a32d2ed, fidl::encoding::DynamicFlags::empty(), ___deadline
2013 )?;
2014 Ok(_response.map(|x| (x.domain, x.proto)))
2015 }
2016}
2017
2018#[cfg(target_os = "fuchsia")]
2019impl From<BaseDatagramSocketSynchronousProxy> for zx::Handle {
2020 fn from(value: BaseDatagramSocketSynchronousProxy) -> Self {
2021 value.into_channel().into()
2022 }
2023}
2024
2025#[cfg(target_os = "fuchsia")]
2026impl From<fidl::Channel> for BaseDatagramSocketSynchronousProxy {
2027 fn from(value: fidl::Channel) -> Self {
2028 Self::new(value)
2029 }
2030}
2031
2032#[derive(Debug, Clone)]
2033pub struct BaseDatagramSocketProxy {
2034 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
2035}
2036
2037impl fidl::endpoints::Proxy for BaseDatagramSocketProxy {
2038 type Protocol = BaseDatagramSocketMarker;
2039
2040 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
2041 Self::new(inner)
2042 }
2043
2044 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
2045 self.client.into_channel().map_err(|client| Self { client })
2046 }
2047
2048 fn as_channel(&self) -> &::fidl::AsyncChannel {
2049 self.client.as_channel()
2050 }
2051}
2052
2053impl BaseDatagramSocketProxy {
2054 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
2056 let protocol_name =
2057 <BaseDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
2058 Self { client: fidl::client::Client::new(channel, protocol_name) }
2059 }
2060
2061 pub fn take_event_stream(&self) -> BaseDatagramSocketEventStream {
2067 BaseDatagramSocketEventStream { event_receiver: self.client.take_event_receiver() }
2068 }
2069
2070 pub fn r#clone(
2071 &self,
2072 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
2073 ) -> Result<(), fidl::Error> {
2074 BaseDatagramSocketProxyInterface::r#clone(self, request)
2075 }
2076
2077 pub fn r#close(
2088 &self,
2089 ) -> fidl::client::QueryResponseFut<
2090 fidl_fuchsia_unknown::CloseableCloseResult,
2091 fidl::encoding::DefaultFuchsiaResourceDialect,
2092 > {
2093 BaseDatagramSocketProxyInterface::r#close(self)
2094 }
2095
2096 pub fn r#query(
2097 &self,
2098 ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
2099 {
2100 BaseDatagramSocketProxyInterface::r#query(self)
2101 }
2102
2103 pub fn r#set_reuse_address(
2105 &self,
2106 mut value: bool,
2107 ) -> fidl::client::QueryResponseFut<
2108 BaseSocketSetReuseAddressResult,
2109 fidl::encoding::DefaultFuchsiaResourceDialect,
2110 > {
2111 BaseDatagramSocketProxyInterface::r#set_reuse_address(self, value)
2112 }
2113
2114 pub fn r#get_reuse_address(
2116 &self,
2117 ) -> fidl::client::QueryResponseFut<
2118 BaseSocketGetReuseAddressResult,
2119 fidl::encoding::DefaultFuchsiaResourceDialect,
2120 > {
2121 BaseDatagramSocketProxyInterface::r#get_reuse_address(self)
2122 }
2123
2124 pub fn r#get_error(
2127 &self,
2128 ) -> fidl::client::QueryResponseFut<
2129 BaseSocketGetErrorResult,
2130 fidl::encoding::DefaultFuchsiaResourceDialect,
2131 > {
2132 BaseDatagramSocketProxyInterface::r#get_error(self)
2133 }
2134
2135 pub fn r#set_broadcast(
2137 &self,
2138 mut value: bool,
2139 ) -> fidl::client::QueryResponseFut<
2140 BaseSocketSetBroadcastResult,
2141 fidl::encoding::DefaultFuchsiaResourceDialect,
2142 > {
2143 BaseDatagramSocketProxyInterface::r#set_broadcast(self, value)
2144 }
2145
2146 pub fn r#get_broadcast(
2148 &self,
2149 ) -> fidl::client::QueryResponseFut<
2150 BaseSocketGetBroadcastResult,
2151 fidl::encoding::DefaultFuchsiaResourceDialect,
2152 > {
2153 BaseDatagramSocketProxyInterface::r#get_broadcast(self)
2154 }
2155
2156 pub fn r#set_send_buffer(
2158 &self,
2159 mut value_bytes: u64,
2160 ) -> fidl::client::QueryResponseFut<
2161 BaseSocketSetSendBufferResult,
2162 fidl::encoding::DefaultFuchsiaResourceDialect,
2163 > {
2164 BaseDatagramSocketProxyInterface::r#set_send_buffer(self, value_bytes)
2165 }
2166
2167 pub fn r#get_send_buffer(
2169 &self,
2170 ) -> fidl::client::QueryResponseFut<
2171 BaseSocketGetSendBufferResult,
2172 fidl::encoding::DefaultFuchsiaResourceDialect,
2173 > {
2174 BaseDatagramSocketProxyInterface::r#get_send_buffer(self)
2175 }
2176
2177 pub fn r#set_receive_buffer(
2179 &self,
2180 mut value_bytes: u64,
2181 ) -> fidl::client::QueryResponseFut<
2182 BaseSocketSetReceiveBufferResult,
2183 fidl::encoding::DefaultFuchsiaResourceDialect,
2184 > {
2185 BaseDatagramSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
2186 }
2187
2188 pub fn r#get_receive_buffer(
2190 &self,
2191 ) -> fidl::client::QueryResponseFut<
2192 BaseSocketGetReceiveBufferResult,
2193 fidl::encoding::DefaultFuchsiaResourceDialect,
2194 > {
2195 BaseDatagramSocketProxyInterface::r#get_receive_buffer(self)
2196 }
2197
2198 pub fn r#set_keep_alive(
2200 &self,
2201 mut value: bool,
2202 ) -> fidl::client::QueryResponseFut<
2203 BaseSocketSetKeepAliveResult,
2204 fidl::encoding::DefaultFuchsiaResourceDialect,
2205 > {
2206 BaseDatagramSocketProxyInterface::r#set_keep_alive(self, value)
2207 }
2208
2209 pub fn r#get_keep_alive(
2211 &self,
2212 ) -> fidl::client::QueryResponseFut<
2213 BaseSocketGetKeepAliveResult,
2214 fidl::encoding::DefaultFuchsiaResourceDialect,
2215 > {
2216 BaseDatagramSocketProxyInterface::r#get_keep_alive(self)
2217 }
2218
2219 pub fn r#set_out_of_band_inline(
2221 &self,
2222 mut value: bool,
2223 ) -> fidl::client::QueryResponseFut<
2224 BaseSocketSetOutOfBandInlineResult,
2225 fidl::encoding::DefaultFuchsiaResourceDialect,
2226 > {
2227 BaseDatagramSocketProxyInterface::r#set_out_of_band_inline(self, value)
2228 }
2229
2230 pub fn r#get_out_of_band_inline(
2232 &self,
2233 ) -> fidl::client::QueryResponseFut<
2234 BaseSocketGetOutOfBandInlineResult,
2235 fidl::encoding::DefaultFuchsiaResourceDialect,
2236 > {
2237 BaseDatagramSocketProxyInterface::r#get_out_of_band_inline(self)
2238 }
2239
2240 pub fn r#set_no_check(
2242 &self,
2243 mut value: bool,
2244 ) -> fidl::client::QueryResponseFut<
2245 BaseSocketSetNoCheckResult,
2246 fidl::encoding::DefaultFuchsiaResourceDialect,
2247 > {
2248 BaseDatagramSocketProxyInterface::r#set_no_check(self, value)
2249 }
2250
2251 pub fn r#get_no_check(
2253 &self,
2254 ) -> fidl::client::QueryResponseFut<
2255 BaseSocketGetNoCheckResult,
2256 fidl::encoding::DefaultFuchsiaResourceDialect,
2257 > {
2258 BaseDatagramSocketProxyInterface::r#get_no_check(self)
2259 }
2260
2261 pub fn r#set_linger(
2263 &self,
2264 mut linger: bool,
2265 mut length_secs: u32,
2266 ) -> fidl::client::QueryResponseFut<
2267 BaseSocketSetLingerResult,
2268 fidl::encoding::DefaultFuchsiaResourceDialect,
2269 > {
2270 BaseDatagramSocketProxyInterface::r#set_linger(self, linger, length_secs)
2271 }
2272
2273 pub fn r#get_linger(
2275 &self,
2276 ) -> fidl::client::QueryResponseFut<
2277 BaseSocketGetLingerResult,
2278 fidl::encoding::DefaultFuchsiaResourceDialect,
2279 > {
2280 BaseDatagramSocketProxyInterface::r#get_linger(self)
2281 }
2282
2283 pub fn r#set_reuse_port(
2285 &self,
2286 mut value: bool,
2287 ) -> fidl::client::QueryResponseFut<
2288 BaseSocketSetReusePortResult,
2289 fidl::encoding::DefaultFuchsiaResourceDialect,
2290 > {
2291 BaseDatagramSocketProxyInterface::r#set_reuse_port(self, value)
2292 }
2293
2294 pub fn r#get_reuse_port(
2296 &self,
2297 ) -> fidl::client::QueryResponseFut<
2298 BaseSocketGetReusePortResult,
2299 fidl::encoding::DefaultFuchsiaResourceDialect,
2300 > {
2301 BaseDatagramSocketProxyInterface::r#get_reuse_port(self)
2302 }
2303
2304 pub fn r#get_accept_conn(
2306 &self,
2307 ) -> fidl::client::QueryResponseFut<
2308 BaseSocketGetAcceptConnResult,
2309 fidl::encoding::DefaultFuchsiaResourceDialect,
2310 > {
2311 BaseDatagramSocketProxyInterface::r#get_accept_conn(self)
2312 }
2313
2314 pub fn r#set_bind_to_device(
2316 &self,
2317 mut value: &str,
2318 ) -> fidl::client::QueryResponseFut<
2319 BaseSocketSetBindToDeviceResult,
2320 fidl::encoding::DefaultFuchsiaResourceDialect,
2321 > {
2322 BaseDatagramSocketProxyInterface::r#set_bind_to_device(self, value)
2323 }
2324
2325 pub fn r#get_bind_to_device(
2327 &self,
2328 ) -> fidl::client::QueryResponseFut<
2329 BaseSocketGetBindToDeviceResult,
2330 fidl::encoding::DefaultFuchsiaResourceDialect,
2331 > {
2332 BaseDatagramSocketProxyInterface::r#get_bind_to_device(self)
2333 }
2334
2335 pub fn r#set_bind_to_interface_index(
2338 &self,
2339 mut value: u64,
2340 ) -> fidl::client::QueryResponseFut<
2341 BaseSocketSetBindToInterfaceIndexResult,
2342 fidl::encoding::DefaultFuchsiaResourceDialect,
2343 > {
2344 BaseDatagramSocketProxyInterface::r#set_bind_to_interface_index(self, value)
2345 }
2346
2347 pub fn r#get_bind_to_interface_index(
2349 &self,
2350 ) -> fidl::client::QueryResponseFut<
2351 BaseSocketGetBindToInterfaceIndexResult,
2352 fidl::encoding::DefaultFuchsiaResourceDialect,
2353 > {
2354 BaseDatagramSocketProxyInterface::r#get_bind_to_interface_index(self)
2355 }
2356
2357 pub fn r#set_timestamp(
2359 &self,
2360 mut value: TimestampOption,
2361 ) -> fidl::client::QueryResponseFut<
2362 BaseSocketSetTimestampResult,
2363 fidl::encoding::DefaultFuchsiaResourceDialect,
2364 > {
2365 BaseDatagramSocketProxyInterface::r#set_timestamp(self, value)
2366 }
2367
2368 pub fn r#get_timestamp(
2370 &self,
2371 ) -> fidl::client::QueryResponseFut<
2372 BaseSocketGetTimestampResult,
2373 fidl::encoding::DefaultFuchsiaResourceDialect,
2374 > {
2375 BaseDatagramSocketProxyInterface::r#get_timestamp(self)
2376 }
2377
2378 pub fn r#set_mark(
2382 &self,
2383 mut domain: fidl_fuchsia_net::MarkDomain,
2384 mut mark: &OptionalUint32,
2385 ) -> fidl::client::QueryResponseFut<
2386 BaseSocketSetMarkResult,
2387 fidl::encoding::DefaultFuchsiaResourceDialect,
2388 > {
2389 BaseDatagramSocketProxyInterface::r#set_mark(self, domain, mark)
2390 }
2391
2392 pub fn r#get_mark(
2396 &self,
2397 mut domain: fidl_fuchsia_net::MarkDomain,
2398 ) -> fidl::client::QueryResponseFut<
2399 BaseSocketGetMarkResult,
2400 fidl::encoding::DefaultFuchsiaResourceDialect,
2401 > {
2402 BaseDatagramSocketProxyInterface::r#get_mark(self, domain)
2403 }
2404
2405 pub fn r#bind(
2407 &self,
2408 mut addr: &fidl_fuchsia_net::SocketAddress,
2409 ) -> fidl::client::QueryResponseFut<
2410 BaseNetworkSocketBindResult,
2411 fidl::encoding::DefaultFuchsiaResourceDialect,
2412 > {
2413 BaseDatagramSocketProxyInterface::r#bind(self, addr)
2414 }
2415
2416 pub fn r#connect(
2418 &self,
2419 mut addr: &fidl_fuchsia_net::SocketAddress,
2420 ) -> fidl::client::QueryResponseFut<
2421 BaseNetworkSocketConnectResult,
2422 fidl::encoding::DefaultFuchsiaResourceDialect,
2423 > {
2424 BaseDatagramSocketProxyInterface::r#connect(self, addr)
2425 }
2426
2427 pub fn r#disconnect(
2429 &self,
2430 ) -> fidl::client::QueryResponseFut<
2431 BaseNetworkSocketDisconnectResult,
2432 fidl::encoding::DefaultFuchsiaResourceDialect,
2433 > {
2434 BaseDatagramSocketProxyInterface::r#disconnect(self)
2435 }
2436
2437 pub fn r#get_sock_name(
2439 &self,
2440 ) -> fidl::client::QueryResponseFut<
2441 BaseNetworkSocketGetSockNameResult,
2442 fidl::encoding::DefaultFuchsiaResourceDialect,
2443 > {
2444 BaseDatagramSocketProxyInterface::r#get_sock_name(self)
2445 }
2446
2447 pub fn r#get_peer_name(
2449 &self,
2450 ) -> fidl::client::QueryResponseFut<
2451 BaseNetworkSocketGetPeerNameResult,
2452 fidl::encoding::DefaultFuchsiaResourceDialect,
2453 > {
2454 BaseDatagramSocketProxyInterface::r#get_peer_name(self)
2455 }
2456
2457 pub fn r#shutdown(
2459 &self,
2460 mut mode: ShutdownMode,
2461 ) -> fidl::client::QueryResponseFut<
2462 BaseNetworkSocketShutdownResult,
2463 fidl::encoding::DefaultFuchsiaResourceDialect,
2464 > {
2465 BaseDatagramSocketProxyInterface::r#shutdown(self, mode)
2466 }
2467
2468 pub fn r#set_ip_type_of_service(
2470 &self,
2471 mut value: u8,
2472 ) -> fidl::client::QueryResponseFut<
2473 BaseNetworkSocketSetIpTypeOfServiceResult,
2474 fidl::encoding::DefaultFuchsiaResourceDialect,
2475 > {
2476 BaseDatagramSocketProxyInterface::r#set_ip_type_of_service(self, value)
2477 }
2478
2479 pub fn r#get_ip_type_of_service(
2481 &self,
2482 ) -> fidl::client::QueryResponseFut<
2483 BaseNetworkSocketGetIpTypeOfServiceResult,
2484 fidl::encoding::DefaultFuchsiaResourceDialect,
2485 > {
2486 BaseDatagramSocketProxyInterface::r#get_ip_type_of_service(self)
2487 }
2488
2489 pub fn r#set_ip_ttl(
2491 &self,
2492 mut value: &OptionalUint8,
2493 ) -> fidl::client::QueryResponseFut<
2494 BaseNetworkSocketSetIpTtlResult,
2495 fidl::encoding::DefaultFuchsiaResourceDialect,
2496 > {
2497 BaseDatagramSocketProxyInterface::r#set_ip_ttl(self, value)
2498 }
2499
2500 pub fn r#get_ip_ttl(
2502 &self,
2503 ) -> fidl::client::QueryResponseFut<
2504 BaseNetworkSocketGetIpTtlResult,
2505 fidl::encoding::DefaultFuchsiaResourceDialect,
2506 > {
2507 BaseDatagramSocketProxyInterface::r#get_ip_ttl(self)
2508 }
2509
2510 pub fn r#set_ip_packet_info(
2512 &self,
2513 mut value: bool,
2514 ) -> fidl::client::QueryResponseFut<
2515 BaseNetworkSocketSetIpPacketInfoResult,
2516 fidl::encoding::DefaultFuchsiaResourceDialect,
2517 > {
2518 BaseDatagramSocketProxyInterface::r#set_ip_packet_info(self, value)
2519 }
2520
2521 pub fn r#get_ip_packet_info(
2523 &self,
2524 ) -> fidl::client::QueryResponseFut<
2525 BaseNetworkSocketGetIpPacketInfoResult,
2526 fidl::encoding::DefaultFuchsiaResourceDialect,
2527 > {
2528 BaseDatagramSocketProxyInterface::r#get_ip_packet_info(self)
2529 }
2530
2531 pub fn r#set_ip_receive_type_of_service(
2533 &self,
2534 mut value: bool,
2535 ) -> fidl::client::QueryResponseFut<
2536 BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
2537 fidl::encoding::DefaultFuchsiaResourceDialect,
2538 > {
2539 BaseDatagramSocketProxyInterface::r#set_ip_receive_type_of_service(self, value)
2540 }
2541
2542 pub fn r#get_ip_receive_type_of_service(
2544 &self,
2545 ) -> fidl::client::QueryResponseFut<
2546 BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
2547 fidl::encoding::DefaultFuchsiaResourceDialect,
2548 > {
2549 BaseDatagramSocketProxyInterface::r#get_ip_receive_type_of_service(self)
2550 }
2551
2552 pub fn r#set_ip_receive_ttl(
2554 &self,
2555 mut value: bool,
2556 ) -> fidl::client::QueryResponseFut<
2557 BaseNetworkSocketSetIpReceiveTtlResult,
2558 fidl::encoding::DefaultFuchsiaResourceDialect,
2559 > {
2560 BaseDatagramSocketProxyInterface::r#set_ip_receive_ttl(self, value)
2561 }
2562
2563 pub fn r#get_ip_receive_ttl(
2565 &self,
2566 ) -> fidl::client::QueryResponseFut<
2567 BaseNetworkSocketGetIpReceiveTtlResult,
2568 fidl::encoding::DefaultFuchsiaResourceDialect,
2569 > {
2570 BaseDatagramSocketProxyInterface::r#get_ip_receive_ttl(self)
2571 }
2572
2573 pub fn r#set_ip_multicast_interface(
2575 &self,
2576 mut iface: u64,
2577 mut address: &fidl_fuchsia_net::Ipv4Address,
2578 ) -> fidl::client::QueryResponseFut<
2579 BaseNetworkSocketSetIpMulticastInterfaceResult,
2580 fidl::encoding::DefaultFuchsiaResourceDialect,
2581 > {
2582 BaseDatagramSocketProxyInterface::r#set_ip_multicast_interface(self, iface, address)
2583 }
2584
2585 pub fn r#get_ip_multicast_interface(
2587 &self,
2588 ) -> fidl::client::QueryResponseFut<
2589 BaseNetworkSocketGetIpMulticastInterfaceResult,
2590 fidl::encoding::DefaultFuchsiaResourceDialect,
2591 > {
2592 BaseDatagramSocketProxyInterface::r#get_ip_multicast_interface(self)
2593 }
2594
2595 pub fn r#set_ip_multicast_ttl(
2597 &self,
2598 mut value: &OptionalUint8,
2599 ) -> fidl::client::QueryResponseFut<
2600 BaseNetworkSocketSetIpMulticastTtlResult,
2601 fidl::encoding::DefaultFuchsiaResourceDialect,
2602 > {
2603 BaseDatagramSocketProxyInterface::r#set_ip_multicast_ttl(self, value)
2604 }
2605
2606 pub fn r#get_ip_multicast_ttl(
2608 &self,
2609 ) -> fidl::client::QueryResponseFut<
2610 BaseNetworkSocketGetIpMulticastTtlResult,
2611 fidl::encoding::DefaultFuchsiaResourceDialect,
2612 > {
2613 BaseDatagramSocketProxyInterface::r#get_ip_multicast_ttl(self)
2614 }
2615
2616 pub fn r#set_ip_multicast_loopback(
2618 &self,
2619 mut value: bool,
2620 ) -> fidl::client::QueryResponseFut<
2621 BaseNetworkSocketSetIpMulticastLoopbackResult,
2622 fidl::encoding::DefaultFuchsiaResourceDialect,
2623 > {
2624 BaseDatagramSocketProxyInterface::r#set_ip_multicast_loopback(self, value)
2625 }
2626
2627 pub fn r#get_ip_multicast_loopback(
2629 &self,
2630 ) -> fidl::client::QueryResponseFut<
2631 BaseNetworkSocketGetIpMulticastLoopbackResult,
2632 fidl::encoding::DefaultFuchsiaResourceDialect,
2633 > {
2634 BaseDatagramSocketProxyInterface::r#get_ip_multicast_loopback(self)
2635 }
2636
2637 pub fn r#add_ip_membership(
2639 &self,
2640 mut membership: &IpMulticastMembership,
2641 ) -> fidl::client::QueryResponseFut<
2642 BaseNetworkSocketAddIpMembershipResult,
2643 fidl::encoding::DefaultFuchsiaResourceDialect,
2644 > {
2645 BaseDatagramSocketProxyInterface::r#add_ip_membership(self, membership)
2646 }
2647
2648 pub fn r#drop_ip_membership(
2650 &self,
2651 mut membership: &IpMulticastMembership,
2652 ) -> fidl::client::QueryResponseFut<
2653 BaseNetworkSocketDropIpMembershipResult,
2654 fidl::encoding::DefaultFuchsiaResourceDialect,
2655 > {
2656 BaseDatagramSocketProxyInterface::r#drop_ip_membership(self, membership)
2657 }
2658
2659 pub fn r#set_ip_transparent(
2661 &self,
2662 mut value: bool,
2663 ) -> fidl::client::QueryResponseFut<
2664 BaseNetworkSocketSetIpTransparentResult,
2665 fidl::encoding::DefaultFuchsiaResourceDialect,
2666 > {
2667 BaseDatagramSocketProxyInterface::r#set_ip_transparent(self, value)
2668 }
2669
2670 pub fn r#get_ip_transparent(
2672 &self,
2673 ) -> fidl::client::QueryResponseFut<
2674 BaseNetworkSocketGetIpTransparentResult,
2675 fidl::encoding::DefaultFuchsiaResourceDialect,
2676 > {
2677 BaseDatagramSocketProxyInterface::r#get_ip_transparent(self)
2678 }
2679
2680 pub fn r#set_ip_receive_original_destination_address(
2682 &self,
2683 mut value: bool,
2684 ) -> fidl::client::QueryResponseFut<
2685 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
2686 fidl::encoding::DefaultFuchsiaResourceDialect,
2687 > {
2688 BaseDatagramSocketProxyInterface::r#set_ip_receive_original_destination_address(self, value)
2689 }
2690
2691 pub fn r#get_ip_receive_original_destination_address(
2693 &self,
2694 ) -> fidl::client::QueryResponseFut<
2695 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
2696 fidl::encoding::DefaultFuchsiaResourceDialect,
2697 > {
2698 BaseDatagramSocketProxyInterface::r#get_ip_receive_original_destination_address(self)
2699 }
2700
2701 pub fn r#add_ipv6_membership(
2703 &self,
2704 mut membership: &Ipv6MulticastMembership,
2705 ) -> fidl::client::QueryResponseFut<
2706 BaseNetworkSocketAddIpv6MembershipResult,
2707 fidl::encoding::DefaultFuchsiaResourceDialect,
2708 > {
2709 BaseDatagramSocketProxyInterface::r#add_ipv6_membership(self, membership)
2710 }
2711
2712 pub fn r#drop_ipv6_membership(
2714 &self,
2715 mut membership: &Ipv6MulticastMembership,
2716 ) -> fidl::client::QueryResponseFut<
2717 BaseNetworkSocketDropIpv6MembershipResult,
2718 fidl::encoding::DefaultFuchsiaResourceDialect,
2719 > {
2720 BaseDatagramSocketProxyInterface::r#drop_ipv6_membership(self, membership)
2721 }
2722
2723 pub fn r#set_ipv6_multicast_interface(
2725 &self,
2726 mut value: u64,
2727 ) -> fidl::client::QueryResponseFut<
2728 BaseNetworkSocketSetIpv6MulticastInterfaceResult,
2729 fidl::encoding::DefaultFuchsiaResourceDialect,
2730 > {
2731 BaseDatagramSocketProxyInterface::r#set_ipv6_multicast_interface(self, value)
2732 }
2733
2734 pub fn r#get_ipv6_multicast_interface(
2736 &self,
2737 ) -> fidl::client::QueryResponseFut<
2738 BaseNetworkSocketGetIpv6MulticastInterfaceResult,
2739 fidl::encoding::DefaultFuchsiaResourceDialect,
2740 > {
2741 BaseDatagramSocketProxyInterface::r#get_ipv6_multicast_interface(self)
2742 }
2743
2744 pub fn r#set_ipv6_unicast_hops(
2746 &self,
2747 mut value: &OptionalUint8,
2748 ) -> fidl::client::QueryResponseFut<
2749 BaseNetworkSocketSetIpv6UnicastHopsResult,
2750 fidl::encoding::DefaultFuchsiaResourceDialect,
2751 > {
2752 BaseDatagramSocketProxyInterface::r#set_ipv6_unicast_hops(self, value)
2753 }
2754
2755 pub fn r#get_ipv6_unicast_hops(
2757 &self,
2758 ) -> fidl::client::QueryResponseFut<
2759 BaseNetworkSocketGetIpv6UnicastHopsResult,
2760 fidl::encoding::DefaultFuchsiaResourceDialect,
2761 > {
2762 BaseDatagramSocketProxyInterface::r#get_ipv6_unicast_hops(self)
2763 }
2764
2765 pub fn r#set_ipv6_receive_hop_limit(
2767 &self,
2768 mut value: bool,
2769 ) -> fidl::client::QueryResponseFut<
2770 BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
2771 fidl::encoding::DefaultFuchsiaResourceDialect,
2772 > {
2773 BaseDatagramSocketProxyInterface::r#set_ipv6_receive_hop_limit(self, value)
2774 }
2775
2776 pub fn r#get_ipv6_receive_hop_limit(
2778 &self,
2779 ) -> fidl::client::QueryResponseFut<
2780 BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
2781 fidl::encoding::DefaultFuchsiaResourceDialect,
2782 > {
2783 BaseDatagramSocketProxyInterface::r#get_ipv6_receive_hop_limit(self)
2784 }
2785
2786 pub fn r#set_ipv6_multicast_hops(
2788 &self,
2789 mut value: &OptionalUint8,
2790 ) -> fidl::client::QueryResponseFut<
2791 BaseNetworkSocketSetIpv6MulticastHopsResult,
2792 fidl::encoding::DefaultFuchsiaResourceDialect,
2793 > {
2794 BaseDatagramSocketProxyInterface::r#set_ipv6_multicast_hops(self, value)
2795 }
2796
2797 pub fn r#get_ipv6_multicast_hops(
2799 &self,
2800 ) -> fidl::client::QueryResponseFut<
2801 BaseNetworkSocketGetIpv6MulticastHopsResult,
2802 fidl::encoding::DefaultFuchsiaResourceDialect,
2803 > {
2804 BaseDatagramSocketProxyInterface::r#get_ipv6_multicast_hops(self)
2805 }
2806
2807 pub fn r#set_ipv6_multicast_loopback(
2809 &self,
2810 mut value: bool,
2811 ) -> fidl::client::QueryResponseFut<
2812 BaseNetworkSocketSetIpv6MulticastLoopbackResult,
2813 fidl::encoding::DefaultFuchsiaResourceDialect,
2814 > {
2815 BaseDatagramSocketProxyInterface::r#set_ipv6_multicast_loopback(self, value)
2816 }
2817
2818 pub fn r#get_ipv6_multicast_loopback(
2820 &self,
2821 ) -> fidl::client::QueryResponseFut<
2822 BaseNetworkSocketGetIpv6MulticastLoopbackResult,
2823 fidl::encoding::DefaultFuchsiaResourceDialect,
2824 > {
2825 BaseDatagramSocketProxyInterface::r#get_ipv6_multicast_loopback(self)
2826 }
2827
2828 pub fn r#set_ipv6_only(
2830 &self,
2831 mut value: bool,
2832 ) -> fidl::client::QueryResponseFut<
2833 BaseNetworkSocketSetIpv6OnlyResult,
2834 fidl::encoding::DefaultFuchsiaResourceDialect,
2835 > {
2836 BaseDatagramSocketProxyInterface::r#set_ipv6_only(self, value)
2837 }
2838
2839 pub fn r#get_ipv6_only(
2841 &self,
2842 ) -> fidl::client::QueryResponseFut<
2843 BaseNetworkSocketGetIpv6OnlyResult,
2844 fidl::encoding::DefaultFuchsiaResourceDialect,
2845 > {
2846 BaseDatagramSocketProxyInterface::r#get_ipv6_only(self)
2847 }
2848
2849 pub fn r#set_ipv6_receive_traffic_class(
2851 &self,
2852 mut value: bool,
2853 ) -> fidl::client::QueryResponseFut<
2854 BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
2855 fidl::encoding::DefaultFuchsiaResourceDialect,
2856 > {
2857 BaseDatagramSocketProxyInterface::r#set_ipv6_receive_traffic_class(self, value)
2858 }
2859
2860 pub fn r#get_ipv6_receive_traffic_class(
2862 &self,
2863 ) -> fidl::client::QueryResponseFut<
2864 BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
2865 fidl::encoding::DefaultFuchsiaResourceDialect,
2866 > {
2867 BaseDatagramSocketProxyInterface::r#get_ipv6_receive_traffic_class(self)
2868 }
2869
2870 pub fn r#set_ipv6_traffic_class(
2872 &self,
2873 mut value: &OptionalUint8,
2874 ) -> fidl::client::QueryResponseFut<
2875 BaseNetworkSocketSetIpv6TrafficClassResult,
2876 fidl::encoding::DefaultFuchsiaResourceDialect,
2877 > {
2878 BaseDatagramSocketProxyInterface::r#set_ipv6_traffic_class(self, value)
2879 }
2880
2881 pub fn r#get_ipv6_traffic_class(
2883 &self,
2884 ) -> fidl::client::QueryResponseFut<
2885 BaseNetworkSocketGetIpv6TrafficClassResult,
2886 fidl::encoding::DefaultFuchsiaResourceDialect,
2887 > {
2888 BaseDatagramSocketProxyInterface::r#get_ipv6_traffic_class(self)
2889 }
2890
2891 pub fn r#set_ipv6_receive_packet_info(
2893 &self,
2894 mut value: bool,
2895 ) -> fidl::client::QueryResponseFut<
2896 BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
2897 fidl::encoding::DefaultFuchsiaResourceDialect,
2898 > {
2899 BaseDatagramSocketProxyInterface::r#set_ipv6_receive_packet_info(self, value)
2900 }
2901
2902 pub fn r#get_ipv6_receive_packet_info(
2904 &self,
2905 ) -> fidl::client::QueryResponseFut<
2906 BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
2907 fidl::encoding::DefaultFuchsiaResourceDialect,
2908 > {
2909 BaseDatagramSocketProxyInterface::r#get_ipv6_receive_packet_info(self)
2910 }
2911
2912 pub fn r#get_original_destination(
2914 &self,
2915 ) -> fidl::client::QueryResponseFut<
2916 BaseNetworkSocketGetOriginalDestinationResult,
2917 fidl::encoding::DefaultFuchsiaResourceDialect,
2918 > {
2919 BaseDatagramSocketProxyInterface::r#get_original_destination(self)
2920 }
2921
2922 pub fn r#get_info(
2927 &self,
2928 ) -> fidl::client::QueryResponseFut<
2929 BaseDatagramSocketGetInfoResult,
2930 fidl::encoding::DefaultFuchsiaResourceDialect,
2931 > {
2932 BaseDatagramSocketProxyInterface::r#get_info(self)
2933 }
2934}
2935
2936impl BaseDatagramSocketProxyInterface for BaseDatagramSocketProxy {
2937 fn r#clone(
2938 &self,
2939 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
2940 ) -> Result<(), fidl::Error> {
2941 self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
2942 (request,),
2943 0x20d8a7aba2168a79,
2944 fidl::encoding::DynamicFlags::empty(),
2945 )
2946 }
2947
2948 type CloseResponseFut = fidl::client::QueryResponseFut<
2949 fidl_fuchsia_unknown::CloseableCloseResult,
2950 fidl::encoding::DefaultFuchsiaResourceDialect,
2951 >;
2952 fn r#close(&self) -> Self::CloseResponseFut {
2953 fn _decode(
2954 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2955 ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
2956 let _response = fidl::client::decode_transaction_body::<
2957 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
2958 fidl::encoding::DefaultFuchsiaResourceDialect,
2959 0x5ac5d459ad7f657e,
2960 >(_buf?)?;
2961 Ok(_response.map(|x| x))
2962 }
2963 self.client.send_query_and_decode::<
2964 fidl::encoding::EmptyPayload,
2965 fidl_fuchsia_unknown::CloseableCloseResult,
2966 >(
2967 (),
2968 0x5ac5d459ad7f657e,
2969 fidl::encoding::DynamicFlags::empty(),
2970 _decode,
2971 )
2972 }
2973
2974 type QueryResponseFut =
2975 fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
2976 fn r#query(&self) -> Self::QueryResponseFut {
2977 fn _decode(
2978 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2979 ) -> Result<Vec<u8>, fidl::Error> {
2980 let _response = fidl::client::decode_transaction_body::<
2981 fidl_fuchsia_unknown::QueryableQueryResponse,
2982 fidl::encoding::DefaultFuchsiaResourceDialect,
2983 0x2658edee9decfc06,
2984 >(_buf?)?;
2985 Ok(_response.protocol)
2986 }
2987 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
2988 (),
2989 0x2658edee9decfc06,
2990 fidl::encoding::DynamicFlags::empty(),
2991 _decode,
2992 )
2993 }
2994
2995 type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
2996 BaseSocketSetReuseAddressResult,
2997 fidl::encoding::DefaultFuchsiaResourceDialect,
2998 >;
2999 fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
3000 fn _decode(
3001 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3002 ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
3003 let _response = fidl::client::decode_transaction_body::<
3004 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3005 fidl::encoding::DefaultFuchsiaResourceDialect,
3006 0x1fd74ee8b9a4a876,
3007 >(_buf?)?;
3008 Ok(_response.map(|x| x))
3009 }
3010 self.client.send_query_and_decode::<
3011 BaseSocketSetReuseAddressRequest,
3012 BaseSocketSetReuseAddressResult,
3013 >(
3014 (value,),
3015 0x1fd74ee8b9a4a876,
3016 fidl::encoding::DynamicFlags::empty(),
3017 _decode,
3018 )
3019 }
3020
3021 type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
3022 BaseSocketGetReuseAddressResult,
3023 fidl::encoding::DefaultFuchsiaResourceDialect,
3024 >;
3025 fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
3026 fn _decode(
3027 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3028 ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
3029 let _response = fidl::client::decode_transaction_body::<
3030 fidl::encoding::ResultType<
3031 BaseSocketGetReuseAddressResponse,
3032 fidl_fuchsia_posix::Errno,
3033 >,
3034 fidl::encoding::DefaultFuchsiaResourceDialect,
3035 0x67b7206b8d1bc0a5,
3036 >(_buf?)?;
3037 Ok(_response.map(|x| x.value))
3038 }
3039 self.client
3040 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
3041 (),
3042 0x67b7206b8d1bc0a5,
3043 fidl::encoding::DynamicFlags::empty(),
3044 _decode,
3045 )
3046 }
3047
3048 type GetErrorResponseFut = fidl::client::QueryResponseFut<
3049 BaseSocketGetErrorResult,
3050 fidl::encoding::DefaultFuchsiaResourceDialect,
3051 >;
3052 fn r#get_error(&self) -> Self::GetErrorResponseFut {
3053 fn _decode(
3054 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3055 ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
3056 let _response = fidl::client::decode_transaction_body::<
3057 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3058 fidl::encoding::DefaultFuchsiaResourceDialect,
3059 0x5aad39b33e5f6ebb,
3060 >(_buf?)?;
3061 Ok(_response.map(|x| x))
3062 }
3063 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
3064 (),
3065 0x5aad39b33e5f6ebb,
3066 fidl::encoding::DynamicFlags::empty(),
3067 _decode,
3068 )
3069 }
3070
3071 type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
3072 BaseSocketSetBroadcastResult,
3073 fidl::encoding::DefaultFuchsiaResourceDialect,
3074 >;
3075 fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
3076 fn _decode(
3077 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3078 ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
3079 let _response = fidl::client::decode_transaction_body::<
3080 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3081 fidl::encoding::DefaultFuchsiaResourceDialect,
3082 0x6023e081ce3cd947,
3083 >(_buf?)?;
3084 Ok(_response.map(|x| x))
3085 }
3086 self.client
3087 .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
3088 (value,),
3089 0x6023e081ce3cd947,
3090 fidl::encoding::DynamicFlags::empty(),
3091 _decode,
3092 )
3093 }
3094
3095 type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
3096 BaseSocketGetBroadcastResult,
3097 fidl::encoding::DefaultFuchsiaResourceDialect,
3098 >;
3099 fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
3100 fn _decode(
3101 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3102 ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
3103 let _response = fidl::client::decode_transaction_body::<
3104 fidl::encoding::ResultType<
3105 BaseSocketGetBroadcastResponse,
3106 fidl_fuchsia_posix::Errno,
3107 >,
3108 fidl::encoding::DefaultFuchsiaResourceDialect,
3109 0x68796fc556f9780d,
3110 >(_buf?)?;
3111 Ok(_response.map(|x| x.value))
3112 }
3113 self.client
3114 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
3115 (),
3116 0x68796fc556f9780d,
3117 fidl::encoding::DynamicFlags::empty(),
3118 _decode,
3119 )
3120 }
3121
3122 type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
3123 BaseSocketSetSendBufferResult,
3124 fidl::encoding::DefaultFuchsiaResourceDialect,
3125 >;
3126 fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
3127 fn _decode(
3128 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3129 ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
3130 let _response = fidl::client::decode_transaction_body::<
3131 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3132 fidl::encoding::DefaultFuchsiaResourceDialect,
3133 0x756eac32d73a7a70,
3134 >(_buf?)?;
3135 Ok(_response.map(|x| x))
3136 }
3137 self.client
3138 .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
3139 (value_bytes,),
3140 0x756eac32d73a7a70,
3141 fidl::encoding::DynamicFlags::empty(),
3142 _decode,
3143 )
3144 }
3145
3146 type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
3147 BaseSocketGetSendBufferResult,
3148 fidl::encoding::DefaultFuchsiaResourceDialect,
3149 >;
3150 fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
3151 fn _decode(
3152 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3153 ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
3154 let _response = fidl::client::decode_transaction_body::<
3155 fidl::encoding::ResultType<
3156 BaseSocketGetSendBufferResponse,
3157 fidl_fuchsia_posix::Errno,
3158 >,
3159 fidl::encoding::DefaultFuchsiaResourceDialect,
3160 0x78a52fd9c7b2410b,
3161 >(_buf?)?;
3162 Ok(_response.map(|x| x.value_bytes))
3163 }
3164 self.client
3165 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
3166 (),
3167 0x78a52fd9c7b2410b,
3168 fidl::encoding::DynamicFlags::empty(),
3169 _decode,
3170 )
3171 }
3172
3173 type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
3174 BaseSocketSetReceiveBufferResult,
3175 fidl::encoding::DefaultFuchsiaResourceDialect,
3176 >;
3177 fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
3178 fn _decode(
3179 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3180 ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
3181 let _response = fidl::client::decode_transaction_body::<
3182 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3183 fidl::encoding::DefaultFuchsiaResourceDialect,
3184 0x6b0cf2f1919c7001,
3185 >(_buf?)?;
3186 Ok(_response.map(|x| x))
3187 }
3188 self.client.send_query_and_decode::<
3189 BaseSocketSetReceiveBufferRequest,
3190 BaseSocketSetReceiveBufferResult,
3191 >(
3192 (value_bytes,),
3193 0x6b0cf2f1919c7001,
3194 fidl::encoding::DynamicFlags::empty(),
3195 _decode,
3196 )
3197 }
3198
3199 type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
3200 BaseSocketGetReceiveBufferResult,
3201 fidl::encoding::DefaultFuchsiaResourceDialect,
3202 >;
3203 fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
3204 fn _decode(
3205 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3206 ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
3207 let _response = fidl::client::decode_transaction_body::<
3208 fidl::encoding::ResultType<
3209 BaseSocketGetReceiveBufferResponse,
3210 fidl_fuchsia_posix::Errno,
3211 >,
3212 fidl::encoding::DefaultFuchsiaResourceDialect,
3213 0x14c1a4b64f709e5c,
3214 >(_buf?)?;
3215 Ok(_response.map(|x| x.value_bytes))
3216 }
3217 self.client.send_query_and_decode::<
3218 fidl::encoding::EmptyPayload,
3219 BaseSocketGetReceiveBufferResult,
3220 >(
3221 (),
3222 0x14c1a4b64f709e5c,
3223 fidl::encoding::DynamicFlags::empty(),
3224 _decode,
3225 )
3226 }
3227
3228 type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
3229 BaseSocketSetKeepAliveResult,
3230 fidl::encoding::DefaultFuchsiaResourceDialect,
3231 >;
3232 fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
3233 fn _decode(
3234 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3235 ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
3236 let _response = fidl::client::decode_transaction_body::<
3237 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3238 fidl::encoding::DefaultFuchsiaResourceDialect,
3239 0x572df8f0b920d2c7,
3240 >(_buf?)?;
3241 Ok(_response.map(|x| x))
3242 }
3243 self.client
3244 .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
3245 (value,),
3246 0x572df8f0b920d2c7,
3247 fidl::encoding::DynamicFlags::empty(),
3248 _decode,
3249 )
3250 }
3251
3252 type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
3253 BaseSocketGetKeepAliveResult,
3254 fidl::encoding::DefaultFuchsiaResourceDialect,
3255 >;
3256 fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
3257 fn _decode(
3258 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3259 ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
3260 let _response = fidl::client::decode_transaction_body::<
3261 fidl::encoding::ResultType<
3262 BaseSocketGetKeepAliveResponse,
3263 fidl_fuchsia_posix::Errno,
3264 >,
3265 fidl::encoding::DefaultFuchsiaResourceDialect,
3266 0x2dd29d3215f2c9d2,
3267 >(_buf?)?;
3268 Ok(_response.map(|x| x.value))
3269 }
3270 self.client
3271 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
3272 (),
3273 0x2dd29d3215f2c9d2,
3274 fidl::encoding::DynamicFlags::empty(),
3275 _decode,
3276 )
3277 }
3278
3279 type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
3280 BaseSocketSetOutOfBandInlineResult,
3281 fidl::encoding::DefaultFuchsiaResourceDialect,
3282 >;
3283 fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
3284 fn _decode(
3285 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3286 ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
3287 let _response = fidl::client::decode_transaction_body::<
3288 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3289 fidl::encoding::DefaultFuchsiaResourceDialect,
3290 0x3ecb49968bee439,
3291 >(_buf?)?;
3292 Ok(_response.map(|x| x))
3293 }
3294 self.client.send_query_and_decode::<
3295 BaseSocketSetOutOfBandInlineRequest,
3296 BaseSocketSetOutOfBandInlineResult,
3297 >(
3298 (value,),
3299 0x3ecb49968bee439,
3300 fidl::encoding::DynamicFlags::empty(),
3301 _decode,
3302 )
3303 }
3304
3305 type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
3306 BaseSocketGetOutOfBandInlineResult,
3307 fidl::encoding::DefaultFuchsiaResourceDialect,
3308 >;
3309 fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
3310 fn _decode(
3311 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3312 ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
3313 let _response = fidl::client::decode_transaction_body::<
3314 fidl::encoding::ResultType<
3315 BaseSocketGetOutOfBandInlineResponse,
3316 fidl_fuchsia_posix::Errno,
3317 >,
3318 fidl::encoding::DefaultFuchsiaResourceDialect,
3319 0x348c1ab3aeca1745,
3320 >(_buf?)?;
3321 Ok(_response.map(|x| x.value))
3322 }
3323 self.client.send_query_and_decode::<
3324 fidl::encoding::EmptyPayload,
3325 BaseSocketGetOutOfBandInlineResult,
3326 >(
3327 (),
3328 0x348c1ab3aeca1745,
3329 fidl::encoding::DynamicFlags::empty(),
3330 _decode,
3331 )
3332 }
3333
3334 type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
3335 BaseSocketSetNoCheckResult,
3336 fidl::encoding::DefaultFuchsiaResourceDialect,
3337 >;
3338 fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
3339 fn _decode(
3340 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3341 ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
3342 let _response = fidl::client::decode_transaction_body::<
3343 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3344 fidl::encoding::DefaultFuchsiaResourceDialect,
3345 0x6bbf00c53a4c78c2,
3346 >(_buf?)?;
3347 Ok(_response.map(|x| x))
3348 }
3349 self.client
3350 .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
3351 (value,),
3352 0x6bbf00c53a4c78c2,
3353 fidl::encoding::DynamicFlags::empty(),
3354 _decode,
3355 )
3356 }
3357
3358 type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
3359 BaseSocketGetNoCheckResult,
3360 fidl::encoding::DefaultFuchsiaResourceDialect,
3361 >;
3362 fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
3363 fn _decode(
3364 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3365 ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
3366 let _response = fidl::client::decode_transaction_body::<
3367 fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
3368 fidl::encoding::DefaultFuchsiaResourceDialect,
3369 0x2cd4249286417694,
3370 >(_buf?)?;
3371 Ok(_response.map(|x| x.value))
3372 }
3373 self.client
3374 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
3375 (),
3376 0x2cd4249286417694,
3377 fidl::encoding::DynamicFlags::empty(),
3378 _decode,
3379 )
3380 }
3381
3382 type SetLingerResponseFut = fidl::client::QueryResponseFut<
3383 BaseSocketSetLingerResult,
3384 fidl::encoding::DefaultFuchsiaResourceDialect,
3385 >;
3386 fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
3387 fn _decode(
3388 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3389 ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
3390 let _response = fidl::client::decode_transaction_body::<
3391 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3392 fidl::encoding::DefaultFuchsiaResourceDialect,
3393 0x45386351246e998e,
3394 >(_buf?)?;
3395 Ok(_response.map(|x| x))
3396 }
3397 self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
3398 (linger, length_secs),
3399 0x45386351246e998e,
3400 fidl::encoding::DynamicFlags::empty(),
3401 _decode,
3402 )
3403 }
3404
3405 type GetLingerResponseFut = fidl::client::QueryResponseFut<
3406 BaseSocketGetLingerResult,
3407 fidl::encoding::DefaultFuchsiaResourceDialect,
3408 >;
3409 fn r#get_linger(&self) -> Self::GetLingerResponseFut {
3410 fn _decode(
3411 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3412 ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
3413 let _response = fidl::client::decode_transaction_body::<
3414 fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
3415 fidl::encoding::DefaultFuchsiaResourceDialect,
3416 0x48eb20fc5ccb0e45,
3417 >(_buf?)?;
3418 Ok(_response.map(|x| (x.linger, x.length_secs)))
3419 }
3420 self.client
3421 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
3422 (),
3423 0x48eb20fc5ccb0e45,
3424 fidl::encoding::DynamicFlags::empty(),
3425 _decode,
3426 )
3427 }
3428
3429 type SetReusePortResponseFut = fidl::client::QueryResponseFut<
3430 BaseSocketSetReusePortResult,
3431 fidl::encoding::DefaultFuchsiaResourceDialect,
3432 >;
3433 fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
3434 fn _decode(
3435 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3436 ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
3437 let _response = fidl::client::decode_transaction_body::<
3438 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3439 fidl::encoding::DefaultFuchsiaResourceDialect,
3440 0x24dd3e5cb36d9ccb,
3441 >(_buf?)?;
3442 Ok(_response.map(|x| x))
3443 }
3444 self.client
3445 .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
3446 (value,),
3447 0x24dd3e5cb36d9ccb,
3448 fidl::encoding::DynamicFlags::empty(),
3449 _decode,
3450 )
3451 }
3452
3453 type GetReusePortResponseFut = fidl::client::QueryResponseFut<
3454 BaseSocketGetReusePortResult,
3455 fidl::encoding::DefaultFuchsiaResourceDialect,
3456 >;
3457 fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
3458 fn _decode(
3459 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3460 ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
3461 let _response = fidl::client::decode_transaction_body::<
3462 fidl::encoding::ResultType<
3463 BaseSocketGetReusePortResponse,
3464 fidl_fuchsia_posix::Errno,
3465 >,
3466 fidl::encoding::DefaultFuchsiaResourceDialect,
3467 0x7a112c1ab54ff828,
3468 >(_buf?)?;
3469 Ok(_response.map(|x| x.value))
3470 }
3471 self.client
3472 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
3473 (),
3474 0x7a112c1ab54ff828,
3475 fidl::encoding::DynamicFlags::empty(),
3476 _decode,
3477 )
3478 }
3479
3480 type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
3481 BaseSocketGetAcceptConnResult,
3482 fidl::encoding::DefaultFuchsiaResourceDialect,
3483 >;
3484 fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
3485 fn _decode(
3486 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3487 ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
3488 let _response = fidl::client::decode_transaction_body::<
3489 fidl::encoding::ResultType<
3490 BaseSocketGetAcceptConnResponse,
3491 fidl_fuchsia_posix::Errno,
3492 >,
3493 fidl::encoding::DefaultFuchsiaResourceDialect,
3494 0x67ce6db6c2ec8966,
3495 >(_buf?)?;
3496 Ok(_response.map(|x| x.value))
3497 }
3498 self.client
3499 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
3500 (),
3501 0x67ce6db6c2ec8966,
3502 fidl::encoding::DynamicFlags::empty(),
3503 _decode,
3504 )
3505 }
3506
3507 type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
3508 BaseSocketSetBindToDeviceResult,
3509 fidl::encoding::DefaultFuchsiaResourceDialect,
3510 >;
3511 fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
3512 fn _decode(
3513 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3514 ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
3515 let _response = fidl::client::decode_transaction_body::<
3516 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3517 fidl::encoding::DefaultFuchsiaResourceDialect,
3518 0x2118b483f28aafc4,
3519 >(_buf?)?;
3520 Ok(_response.map(|x| x))
3521 }
3522 self.client.send_query_and_decode::<
3523 BaseSocketSetBindToDeviceRequest,
3524 BaseSocketSetBindToDeviceResult,
3525 >(
3526 (value,),
3527 0x2118b483f28aafc4,
3528 fidl::encoding::DynamicFlags::empty(),
3529 _decode,
3530 )
3531 }
3532
3533 type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
3534 BaseSocketGetBindToDeviceResult,
3535 fidl::encoding::DefaultFuchsiaResourceDialect,
3536 >;
3537 fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
3538 fn _decode(
3539 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3540 ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
3541 let _response = fidl::client::decode_transaction_body::<
3542 fidl::encoding::ResultType<
3543 BaseSocketGetBindToDeviceResponse,
3544 fidl_fuchsia_posix::Errno,
3545 >,
3546 fidl::encoding::DefaultFuchsiaResourceDialect,
3547 0x1ab1fbf0ef7906c8,
3548 >(_buf?)?;
3549 Ok(_response.map(|x| x.value))
3550 }
3551 self.client
3552 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
3553 (),
3554 0x1ab1fbf0ef7906c8,
3555 fidl::encoding::DynamicFlags::empty(),
3556 _decode,
3557 )
3558 }
3559
3560 type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
3561 BaseSocketSetBindToInterfaceIndexResult,
3562 fidl::encoding::DefaultFuchsiaResourceDialect,
3563 >;
3564 fn r#set_bind_to_interface_index(
3565 &self,
3566 mut value: u64,
3567 ) -> Self::SetBindToInterfaceIndexResponseFut {
3568 fn _decode(
3569 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3570 ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
3571 let _response = fidl::client::decode_transaction_body::<
3572 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3573 fidl::encoding::DefaultFuchsiaResourceDialect,
3574 0x6e387a0def00821,
3575 >(_buf?)?;
3576 Ok(_response.map(|x| x))
3577 }
3578 self.client.send_query_and_decode::<
3579 BaseSocketSetBindToInterfaceIndexRequest,
3580 BaseSocketSetBindToInterfaceIndexResult,
3581 >(
3582 (value,),
3583 0x6e387a0def00821,
3584 fidl::encoding::DynamicFlags::empty(),
3585 _decode,
3586 )
3587 }
3588
3589 type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
3590 BaseSocketGetBindToInterfaceIndexResult,
3591 fidl::encoding::DefaultFuchsiaResourceDialect,
3592 >;
3593 fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
3594 fn _decode(
3595 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3596 ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
3597 let _response = fidl::client::decode_transaction_body::<
3598 fidl::encoding::ResultType<
3599 BaseSocketGetBindToInterfaceIndexResponse,
3600 fidl_fuchsia_posix::Errno,
3601 >,
3602 fidl::encoding::DefaultFuchsiaResourceDialect,
3603 0x59c31dd3e3078295,
3604 >(_buf?)?;
3605 Ok(_response.map(|x| x.value))
3606 }
3607 self.client.send_query_and_decode::<
3608 fidl::encoding::EmptyPayload,
3609 BaseSocketGetBindToInterfaceIndexResult,
3610 >(
3611 (),
3612 0x59c31dd3e3078295,
3613 fidl::encoding::DynamicFlags::empty(),
3614 _decode,
3615 )
3616 }
3617
3618 type SetTimestampResponseFut = fidl::client::QueryResponseFut<
3619 BaseSocketSetTimestampResult,
3620 fidl::encoding::DefaultFuchsiaResourceDialect,
3621 >;
3622 fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
3623 fn _decode(
3624 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3625 ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
3626 let _response = fidl::client::decode_transaction_body::<
3627 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3628 fidl::encoding::DefaultFuchsiaResourceDialect,
3629 0x285d6516c263d839,
3630 >(_buf?)?;
3631 Ok(_response.map(|x| x))
3632 }
3633 self.client
3634 .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
3635 (value,),
3636 0x285d6516c263d839,
3637 fidl::encoding::DynamicFlags::empty(),
3638 _decode,
3639 )
3640 }
3641
3642 type GetTimestampResponseFut = fidl::client::QueryResponseFut<
3643 BaseSocketGetTimestampResult,
3644 fidl::encoding::DefaultFuchsiaResourceDialect,
3645 >;
3646 fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
3647 fn _decode(
3648 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3649 ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
3650 let _response = fidl::client::decode_transaction_body::<
3651 fidl::encoding::ResultType<
3652 BaseSocketGetTimestampResponse,
3653 fidl_fuchsia_posix::Errno,
3654 >,
3655 fidl::encoding::DefaultFuchsiaResourceDialect,
3656 0x49f2fffbbcc2bd27,
3657 >(_buf?)?;
3658 Ok(_response.map(|x| x.value))
3659 }
3660 self.client
3661 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
3662 (),
3663 0x49f2fffbbcc2bd27,
3664 fidl::encoding::DynamicFlags::empty(),
3665 _decode,
3666 )
3667 }
3668
3669 type SetMarkResponseFut = fidl::client::QueryResponseFut<
3670 BaseSocketSetMarkResult,
3671 fidl::encoding::DefaultFuchsiaResourceDialect,
3672 >;
3673 fn r#set_mark(
3674 &self,
3675 mut domain: fidl_fuchsia_net::MarkDomain,
3676 mut mark: &OptionalUint32,
3677 ) -> Self::SetMarkResponseFut {
3678 fn _decode(
3679 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3680 ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
3681 let _response = fidl::client::decode_transaction_body::<
3682 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3683 fidl::encoding::DefaultFuchsiaResourceDialect,
3684 0x6ead6de09f653236,
3685 >(_buf?)?;
3686 Ok(_response.map(|x| x))
3687 }
3688 self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
3689 (domain, mark),
3690 0x6ead6de09f653236,
3691 fidl::encoding::DynamicFlags::empty(),
3692 _decode,
3693 )
3694 }
3695
3696 type GetMarkResponseFut = fidl::client::QueryResponseFut<
3697 BaseSocketGetMarkResult,
3698 fidl::encoding::DefaultFuchsiaResourceDialect,
3699 >;
3700 fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
3701 fn _decode(
3702 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3703 ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
3704 let _response = fidl::client::decode_transaction_body::<
3705 fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
3706 fidl::encoding::DefaultFuchsiaResourceDialect,
3707 0x57a2752c61d93d47,
3708 >(_buf?)?;
3709 Ok(_response.map(|x| x.mark))
3710 }
3711 self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
3712 (domain,),
3713 0x57a2752c61d93d47,
3714 fidl::encoding::DynamicFlags::empty(),
3715 _decode,
3716 )
3717 }
3718
3719 type BindResponseFut = fidl::client::QueryResponseFut<
3720 BaseNetworkSocketBindResult,
3721 fidl::encoding::DefaultFuchsiaResourceDialect,
3722 >;
3723 fn r#bind(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut {
3724 fn _decode(
3725 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3726 ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
3727 let _response = fidl::client::decode_transaction_body::<
3728 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3729 fidl::encoding::DefaultFuchsiaResourceDialect,
3730 0x4bc6400ae92125d,
3731 >(_buf?)?;
3732 Ok(_response.map(|x| x))
3733 }
3734 self.client
3735 .send_query_and_decode::<BaseNetworkSocketBindRequest, BaseNetworkSocketBindResult>(
3736 (addr,),
3737 0x4bc6400ae92125d,
3738 fidl::encoding::DynamicFlags::empty(),
3739 _decode,
3740 )
3741 }
3742
3743 type ConnectResponseFut = fidl::client::QueryResponseFut<
3744 BaseNetworkSocketConnectResult,
3745 fidl::encoding::DefaultFuchsiaResourceDialect,
3746 >;
3747 fn r#connect(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut {
3748 fn _decode(
3749 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3750 ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
3751 let _response = fidl::client::decode_transaction_body::<
3752 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3753 fidl::encoding::DefaultFuchsiaResourceDialect,
3754 0x5f05f19bfdd38871,
3755 >(_buf?)?;
3756 Ok(_response.map(|x| x))
3757 }
3758 self.client.send_query_and_decode::<
3759 BaseNetworkSocketConnectRequest,
3760 BaseNetworkSocketConnectResult,
3761 >(
3762 (addr,),
3763 0x5f05f19bfdd38871,
3764 fidl::encoding::DynamicFlags::empty(),
3765 _decode,
3766 )
3767 }
3768
3769 type DisconnectResponseFut = fidl::client::QueryResponseFut<
3770 BaseNetworkSocketDisconnectResult,
3771 fidl::encoding::DefaultFuchsiaResourceDialect,
3772 >;
3773 fn r#disconnect(&self) -> Self::DisconnectResponseFut {
3774 fn _decode(
3775 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3776 ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
3777 let _response = fidl::client::decode_transaction_body::<
3778 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3779 fidl::encoding::DefaultFuchsiaResourceDialect,
3780 0x74e63b91f7b29b2,
3781 >(_buf?)?;
3782 Ok(_response.map(|x| x))
3783 }
3784 self.client.send_query_and_decode::<
3785 fidl::encoding::EmptyPayload,
3786 BaseNetworkSocketDisconnectResult,
3787 >(
3788 (),
3789 0x74e63b91f7b29b2,
3790 fidl::encoding::DynamicFlags::empty(),
3791 _decode,
3792 )
3793 }
3794
3795 type GetSockNameResponseFut = fidl::client::QueryResponseFut<
3796 BaseNetworkSocketGetSockNameResult,
3797 fidl::encoding::DefaultFuchsiaResourceDialect,
3798 >;
3799 fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
3800 fn _decode(
3801 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3802 ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
3803 let _response = fidl::client::decode_transaction_body::<
3804 fidl::encoding::ResultType<
3805 BaseNetworkSocketGetSockNameResponse,
3806 fidl_fuchsia_posix::Errno,
3807 >,
3808 fidl::encoding::DefaultFuchsiaResourceDialect,
3809 0x475f23f84a1a4f85,
3810 >(_buf?)?;
3811 Ok(_response.map(|x| x.addr))
3812 }
3813 self.client.send_query_and_decode::<
3814 fidl::encoding::EmptyPayload,
3815 BaseNetworkSocketGetSockNameResult,
3816 >(
3817 (),
3818 0x475f23f84a1a4f85,
3819 fidl::encoding::DynamicFlags::empty(),
3820 _decode,
3821 )
3822 }
3823
3824 type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
3825 BaseNetworkSocketGetPeerNameResult,
3826 fidl::encoding::DefaultFuchsiaResourceDialect,
3827 >;
3828 fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
3829 fn _decode(
3830 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3831 ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
3832 let _response = fidl::client::decode_transaction_body::<
3833 fidl::encoding::ResultType<
3834 BaseNetworkSocketGetPeerNameResponse,
3835 fidl_fuchsia_posix::Errno,
3836 >,
3837 fidl::encoding::DefaultFuchsiaResourceDialect,
3838 0x1ffecf4bd5b6432e,
3839 >(_buf?)?;
3840 Ok(_response.map(|x| x.addr))
3841 }
3842 self.client.send_query_and_decode::<
3843 fidl::encoding::EmptyPayload,
3844 BaseNetworkSocketGetPeerNameResult,
3845 >(
3846 (),
3847 0x1ffecf4bd5b6432e,
3848 fidl::encoding::DynamicFlags::empty(),
3849 _decode,
3850 )
3851 }
3852
3853 type ShutdownResponseFut = fidl::client::QueryResponseFut<
3854 BaseNetworkSocketShutdownResult,
3855 fidl::encoding::DefaultFuchsiaResourceDialect,
3856 >;
3857 fn r#shutdown(&self, mut mode: ShutdownMode) -> Self::ShutdownResponseFut {
3858 fn _decode(
3859 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3860 ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
3861 let _response = fidl::client::decode_transaction_body::<
3862 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3863 fidl::encoding::DefaultFuchsiaResourceDialect,
3864 0x247f38b6db68c336,
3865 >(_buf?)?;
3866 Ok(_response.map(|x| x))
3867 }
3868 self.client.send_query_and_decode::<
3869 BaseNetworkSocketShutdownRequest,
3870 BaseNetworkSocketShutdownResult,
3871 >(
3872 (mode,),
3873 0x247f38b6db68c336,
3874 fidl::encoding::DynamicFlags::empty(),
3875 _decode,
3876 )
3877 }
3878
3879 type SetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
3880 BaseNetworkSocketSetIpTypeOfServiceResult,
3881 fidl::encoding::DefaultFuchsiaResourceDialect,
3882 >;
3883 fn r#set_ip_type_of_service(&self, mut value: u8) -> Self::SetIpTypeOfServiceResponseFut {
3884 fn _decode(
3885 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3886 ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
3887 let _response = fidl::client::decode_transaction_body::<
3888 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3889 fidl::encoding::DefaultFuchsiaResourceDialect,
3890 0x995c600475b6d46,
3891 >(_buf?)?;
3892 Ok(_response.map(|x| x))
3893 }
3894 self.client.send_query_and_decode::<
3895 BaseNetworkSocketSetIpTypeOfServiceRequest,
3896 BaseNetworkSocketSetIpTypeOfServiceResult,
3897 >(
3898 (value,),
3899 0x995c600475b6d46,
3900 fidl::encoding::DynamicFlags::empty(),
3901 _decode,
3902 )
3903 }
3904
3905 type GetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
3906 BaseNetworkSocketGetIpTypeOfServiceResult,
3907 fidl::encoding::DefaultFuchsiaResourceDialect,
3908 >;
3909 fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut {
3910 fn _decode(
3911 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3912 ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
3913 let _response = fidl::client::decode_transaction_body::<
3914 fidl::encoding::ResultType<
3915 BaseNetworkSocketGetIpTypeOfServiceResponse,
3916 fidl_fuchsia_posix::Errno,
3917 >,
3918 fidl::encoding::DefaultFuchsiaResourceDialect,
3919 0x3814a04259f75fcb,
3920 >(_buf?)?;
3921 Ok(_response.map(|x| x.value))
3922 }
3923 self.client.send_query_and_decode::<
3924 fidl::encoding::EmptyPayload,
3925 BaseNetworkSocketGetIpTypeOfServiceResult,
3926 >(
3927 (),
3928 0x3814a04259f75fcb,
3929 fidl::encoding::DynamicFlags::empty(),
3930 _decode,
3931 )
3932 }
3933
3934 type SetIpTtlResponseFut = fidl::client::QueryResponseFut<
3935 BaseNetworkSocketSetIpTtlResult,
3936 fidl::encoding::DefaultFuchsiaResourceDialect,
3937 >;
3938 fn r#set_ip_ttl(&self, mut value: &OptionalUint8) -> Self::SetIpTtlResponseFut {
3939 fn _decode(
3940 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3941 ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
3942 let _response = fidl::client::decode_transaction_body::<
3943 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3944 fidl::encoding::DefaultFuchsiaResourceDialect,
3945 0x29e2424b433ae1ef,
3946 >(_buf?)?;
3947 Ok(_response.map(|x| x))
3948 }
3949 self.client.send_query_and_decode::<
3950 BaseNetworkSocketSetIpTtlRequest,
3951 BaseNetworkSocketSetIpTtlResult,
3952 >(
3953 (value,),
3954 0x29e2424b433ae1ef,
3955 fidl::encoding::DynamicFlags::empty(),
3956 _decode,
3957 )
3958 }
3959
3960 type GetIpTtlResponseFut = fidl::client::QueryResponseFut<
3961 BaseNetworkSocketGetIpTtlResult,
3962 fidl::encoding::DefaultFuchsiaResourceDialect,
3963 >;
3964 fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut {
3965 fn _decode(
3966 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3967 ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
3968 let _response = fidl::client::decode_transaction_body::<
3969 fidl::encoding::ResultType<
3970 BaseNetworkSocketGetIpTtlResponse,
3971 fidl_fuchsia_posix::Errno,
3972 >,
3973 fidl::encoding::DefaultFuchsiaResourceDialect,
3974 0x47e47fa1f24da471,
3975 >(_buf?)?;
3976 Ok(_response.map(|x| x.value))
3977 }
3978 self.client
3979 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseNetworkSocketGetIpTtlResult>(
3980 (),
3981 0x47e47fa1f24da471,
3982 fidl::encoding::DynamicFlags::empty(),
3983 _decode,
3984 )
3985 }
3986
3987 type SetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
3988 BaseNetworkSocketSetIpPacketInfoResult,
3989 fidl::encoding::DefaultFuchsiaResourceDialect,
3990 >;
3991 fn r#set_ip_packet_info(&self, mut value: bool) -> Self::SetIpPacketInfoResponseFut {
3992 fn _decode(
3993 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3994 ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
3995 let _response = fidl::client::decode_transaction_body::<
3996 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3997 fidl::encoding::DefaultFuchsiaResourceDialect,
3998 0x392d16bee20c0e16,
3999 >(_buf?)?;
4000 Ok(_response.map(|x| x))
4001 }
4002 self.client.send_query_and_decode::<
4003 BaseNetworkSocketSetIpPacketInfoRequest,
4004 BaseNetworkSocketSetIpPacketInfoResult,
4005 >(
4006 (value,),
4007 0x392d16bee20c0e16,
4008 fidl::encoding::DynamicFlags::empty(),
4009 _decode,
4010 )
4011 }
4012
4013 type GetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
4014 BaseNetworkSocketGetIpPacketInfoResult,
4015 fidl::encoding::DefaultFuchsiaResourceDialect,
4016 >;
4017 fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut {
4018 fn _decode(
4019 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4020 ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
4021 let _response = fidl::client::decode_transaction_body::<
4022 fidl::encoding::ResultType<
4023 BaseNetworkSocketGetIpPacketInfoResponse,
4024 fidl_fuchsia_posix::Errno,
4025 >,
4026 fidl::encoding::DefaultFuchsiaResourceDialect,
4027 0x54b505f242280740,
4028 >(_buf?)?;
4029 Ok(_response.map(|x| x.value))
4030 }
4031 self.client.send_query_and_decode::<
4032 fidl::encoding::EmptyPayload,
4033 BaseNetworkSocketGetIpPacketInfoResult,
4034 >(
4035 (),
4036 0x54b505f242280740,
4037 fidl::encoding::DynamicFlags::empty(),
4038 _decode,
4039 )
4040 }
4041
4042 type SetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
4043 BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
4044 fidl::encoding::DefaultFuchsiaResourceDialect,
4045 >;
4046 fn r#set_ip_receive_type_of_service(
4047 &self,
4048 mut value: bool,
4049 ) -> Self::SetIpReceiveTypeOfServiceResponseFut {
4050 fn _decode(
4051 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4052 ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
4053 let _response = fidl::client::decode_transaction_body::<
4054 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4055 fidl::encoding::DefaultFuchsiaResourceDialect,
4056 0x6c4f6714995f84ef,
4057 >(_buf?)?;
4058 Ok(_response.map(|x| x))
4059 }
4060 self.client.send_query_and_decode::<
4061 BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
4062 BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
4063 >(
4064 (value,),
4065 0x6c4f6714995f84ef,
4066 fidl::encoding::DynamicFlags::empty(),
4067 _decode,
4068 )
4069 }
4070
4071 type GetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
4072 BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
4073 fidl::encoding::DefaultFuchsiaResourceDialect,
4074 >;
4075 fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut {
4076 fn _decode(
4077 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4078 ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
4079 let _response = fidl::client::decode_transaction_body::<
4080 fidl::encoding::ResultType<
4081 BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
4082 fidl_fuchsia_posix::Errno,
4083 >,
4084 fidl::encoding::DefaultFuchsiaResourceDialect,
4085 0x4158ba7dc2795960,
4086 >(_buf?)?;
4087 Ok(_response.map(|x| x.value))
4088 }
4089 self.client.send_query_and_decode::<
4090 fidl::encoding::EmptyPayload,
4091 BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
4092 >(
4093 (),
4094 0x4158ba7dc2795960,
4095 fidl::encoding::DynamicFlags::empty(),
4096 _decode,
4097 )
4098 }
4099
4100 type SetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
4101 BaseNetworkSocketSetIpReceiveTtlResult,
4102 fidl::encoding::DefaultFuchsiaResourceDialect,
4103 >;
4104 fn r#set_ip_receive_ttl(&self, mut value: bool) -> Self::SetIpReceiveTtlResponseFut {
4105 fn _decode(
4106 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4107 ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
4108 let _response = fidl::client::decode_transaction_body::<
4109 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4110 fidl::encoding::DefaultFuchsiaResourceDialect,
4111 0x46f15be0ce0ab82b,
4112 >(_buf?)?;
4113 Ok(_response.map(|x| x))
4114 }
4115 self.client.send_query_and_decode::<
4116 BaseNetworkSocketSetIpReceiveTtlRequest,
4117 BaseNetworkSocketSetIpReceiveTtlResult,
4118 >(
4119 (value,),
4120 0x46f15be0ce0ab82b,
4121 fidl::encoding::DynamicFlags::empty(),
4122 _decode,
4123 )
4124 }
4125
4126 type GetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
4127 BaseNetworkSocketGetIpReceiveTtlResult,
4128 fidl::encoding::DefaultFuchsiaResourceDialect,
4129 >;
4130 fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut {
4131 fn _decode(
4132 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4133 ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
4134 let _response = fidl::client::decode_transaction_body::<
4135 fidl::encoding::ResultType<
4136 BaseNetworkSocketGetIpReceiveTtlResponse,
4137 fidl_fuchsia_posix::Errno,
4138 >,
4139 fidl::encoding::DefaultFuchsiaResourceDialect,
4140 0x678ddd5a5dfa2eb5,
4141 >(_buf?)?;
4142 Ok(_response.map(|x| x.value))
4143 }
4144 self.client.send_query_and_decode::<
4145 fidl::encoding::EmptyPayload,
4146 BaseNetworkSocketGetIpReceiveTtlResult,
4147 >(
4148 (),
4149 0x678ddd5a5dfa2eb5,
4150 fidl::encoding::DynamicFlags::empty(),
4151 _decode,
4152 )
4153 }
4154
4155 type SetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
4156 BaseNetworkSocketSetIpMulticastInterfaceResult,
4157 fidl::encoding::DefaultFuchsiaResourceDialect,
4158 >;
4159 fn r#set_ip_multicast_interface(
4160 &self,
4161 mut iface: u64,
4162 mut address: &fidl_fuchsia_net::Ipv4Address,
4163 ) -> Self::SetIpMulticastInterfaceResponseFut {
4164 fn _decode(
4165 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4166 ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
4167 let _response = fidl::client::decode_transaction_body::<
4168 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4169 fidl::encoding::DefaultFuchsiaResourceDialect,
4170 0x752fbfa9b12befe,
4171 >(_buf?)?;
4172 Ok(_response.map(|x| x))
4173 }
4174 self.client.send_query_and_decode::<
4175 BaseNetworkSocketSetIpMulticastInterfaceRequest,
4176 BaseNetworkSocketSetIpMulticastInterfaceResult,
4177 >(
4178 (iface, address,),
4179 0x752fbfa9b12befe,
4180 fidl::encoding::DynamicFlags::empty(),
4181 _decode,
4182 )
4183 }
4184
4185 type GetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
4186 BaseNetworkSocketGetIpMulticastInterfaceResult,
4187 fidl::encoding::DefaultFuchsiaResourceDialect,
4188 >;
4189 fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut {
4190 fn _decode(
4191 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4192 ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
4193 let _response = fidl::client::decode_transaction_body::<
4194 fidl::encoding::ResultType<
4195 BaseNetworkSocketGetIpMulticastInterfaceResponse,
4196 fidl_fuchsia_posix::Errno,
4197 >,
4198 fidl::encoding::DefaultFuchsiaResourceDialect,
4199 0x320bd14c4df046c4,
4200 >(_buf?)?;
4201 Ok(_response.map(|x| x.value))
4202 }
4203 self.client.send_query_and_decode::<
4204 fidl::encoding::EmptyPayload,
4205 BaseNetworkSocketGetIpMulticastInterfaceResult,
4206 >(
4207 (),
4208 0x320bd14c4df046c4,
4209 fidl::encoding::DynamicFlags::empty(),
4210 _decode,
4211 )
4212 }
4213
4214 type SetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
4215 BaseNetworkSocketSetIpMulticastTtlResult,
4216 fidl::encoding::DefaultFuchsiaResourceDialect,
4217 >;
4218 fn r#set_ip_multicast_ttl(
4219 &self,
4220 mut value: &OptionalUint8,
4221 ) -> Self::SetIpMulticastTtlResponseFut {
4222 fn _decode(
4223 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4224 ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
4225 let _response = fidl::client::decode_transaction_body::<
4226 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4227 fidl::encoding::DefaultFuchsiaResourceDialect,
4228 0x63134d53772916a1,
4229 >(_buf?)?;
4230 Ok(_response.map(|x| x))
4231 }
4232 self.client.send_query_and_decode::<
4233 BaseNetworkSocketSetIpMulticastTtlRequest,
4234 BaseNetworkSocketSetIpMulticastTtlResult,
4235 >(
4236 (value,),
4237 0x63134d53772916a1,
4238 fidl::encoding::DynamicFlags::empty(),
4239 _decode,
4240 )
4241 }
4242
4243 type GetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
4244 BaseNetworkSocketGetIpMulticastTtlResult,
4245 fidl::encoding::DefaultFuchsiaResourceDialect,
4246 >;
4247 fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut {
4248 fn _decode(
4249 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4250 ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
4251 let _response = fidl::client::decode_transaction_body::<
4252 fidl::encoding::ResultType<
4253 BaseNetworkSocketGetIpMulticastTtlResponse,
4254 fidl_fuchsia_posix::Errno,
4255 >,
4256 fidl::encoding::DefaultFuchsiaResourceDialect,
4257 0x4665cd378f39e1a,
4258 >(_buf?)?;
4259 Ok(_response.map(|x| x.value))
4260 }
4261 self.client.send_query_and_decode::<
4262 fidl::encoding::EmptyPayload,
4263 BaseNetworkSocketGetIpMulticastTtlResult,
4264 >(
4265 (),
4266 0x4665cd378f39e1a,
4267 fidl::encoding::DynamicFlags::empty(),
4268 _decode,
4269 )
4270 }
4271
4272 type SetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
4273 BaseNetworkSocketSetIpMulticastLoopbackResult,
4274 fidl::encoding::DefaultFuchsiaResourceDialect,
4275 >;
4276 fn r#set_ip_multicast_loopback(
4277 &self,
4278 mut value: bool,
4279 ) -> Self::SetIpMulticastLoopbackResponseFut {
4280 fn _decode(
4281 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4282 ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
4283 let _response = fidl::client::decode_transaction_body::<
4284 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4285 fidl::encoding::DefaultFuchsiaResourceDialect,
4286 0x20c55c11f00943ea,
4287 >(_buf?)?;
4288 Ok(_response.map(|x| x))
4289 }
4290 self.client.send_query_and_decode::<
4291 BaseNetworkSocketSetIpMulticastLoopbackRequest,
4292 BaseNetworkSocketSetIpMulticastLoopbackResult,
4293 >(
4294 (value,),
4295 0x20c55c11f00943ea,
4296 fidl::encoding::DynamicFlags::empty(),
4297 _decode,
4298 )
4299 }
4300
4301 type GetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
4302 BaseNetworkSocketGetIpMulticastLoopbackResult,
4303 fidl::encoding::DefaultFuchsiaResourceDialect,
4304 >;
4305 fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut {
4306 fn _decode(
4307 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4308 ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
4309 let _response = fidl::client::decode_transaction_body::<
4310 fidl::encoding::ResultType<
4311 BaseNetworkSocketGetIpMulticastLoopbackResponse,
4312 fidl_fuchsia_posix::Errno,
4313 >,
4314 fidl::encoding::DefaultFuchsiaResourceDialect,
4315 0x3b6b26ff558298f2,
4316 >(_buf?)?;
4317 Ok(_response.map(|x| x.value))
4318 }
4319 self.client.send_query_and_decode::<
4320 fidl::encoding::EmptyPayload,
4321 BaseNetworkSocketGetIpMulticastLoopbackResult,
4322 >(
4323 (),
4324 0x3b6b26ff558298f2,
4325 fidl::encoding::DynamicFlags::empty(),
4326 _decode,
4327 )
4328 }
4329
4330 type AddIpMembershipResponseFut = fidl::client::QueryResponseFut<
4331 BaseNetworkSocketAddIpMembershipResult,
4332 fidl::encoding::DefaultFuchsiaResourceDialect,
4333 >;
4334 fn r#add_ip_membership(
4335 &self,
4336 mut membership: &IpMulticastMembership,
4337 ) -> Self::AddIpMembershipResponseFut {
4338 fn _decode(
4339 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4340 ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
4341 let _response = fidl::client::decode_transaction_body::<
4342 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4343 fidl::encoding::DefaultFuchsiaResourceDialect,
4344 0x76bc7df115a3b4d0,
4345 >(_buf?)?;
4346 Ok(_response.map(|x| x))
4347 }
4348 self.client.send_query_and_decode::<
4349 BaseNetworkSocketAddIpMembershipRequest,
4350 BaseNetworkSocketAddIpMembershipResult,
4351 >(
4352 (membership,),
4353 0x76bc7df115a3b4d0,
4354 fidl::encoding::DynamicFlags::empty(),
4355 _decode,
4356 )
4357 }
4358
4359 type DropIpMembershipResponseFut = fidl::client::QueryResponseFut<
4360 BaseNetworkSocketDropIpMembershipResult,
4361 fidl::encoding::DefaultFuchsiaResourceDialect,
4362 >;
4363 fn r#drop_ip_membership(
4364 &self,
4365 mut membership: &IpMulticastMembership,
4366 ) -> Self::DropIpMembershipResponseFut {
4367 fn _decode(
4368 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4369 ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
4370 let _response = fidl::client::decode_transaction_body::<
4371 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4372 fidl::encoding::DefaultFuchsiaResourceDialect,
4373 0x2888f3099188d03,
4374 >(_buf?)?;
4375 Ok(_response.map(|x| x))
4376 }
4377 self.client.send_query_and_decode::<
4378 BaseNetworkSocketDropIpMembershipRequest,
4379 BaseNetworkSocketDropIpMembershipResult,
4380 >(
4381 (membership,),
4382 0x2888f3099188d03,
4383 fidl::encoding::DynamicFlags::empty(),
4384 _decode,
4385 )
4386 }
4387
4388 type SetIpTransparentResponseFut = fidl::client::QueryResponseFut<
4389 BaseNetworkSocketSetIpTransparentResult,
4390 fidl::encoding::DefaultFuchsiaResourceDialect,
4391 >;
4392 fn r#set_ip_transparent(&self, mut value: bool) -> Self::SetIpTransparentResponseFut {
4393 fn _decode(
4394 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4395 ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
4396 let _response = fidl::client::decode_transaction_body::<
4397 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4398 fidl::encoding::DefaultFuchsiaResourceDialect,
4399 0x1ae532b0c066e3a0,
4400 >(_buf?)?;
4401 Ok(_response.map(|x| x))
4402 }
4403 self.client.send_query_and_decode::<
4404 BaseNetworkSocketSetIpTransparentRequest,
4405 BaseNetworkSocketSetIpTransparentResult,
4406 >(
4407 (value,),
4408 0x1ae532b0c066e3a0,
4409 fidl::encoding::DynamicFlags::empty(),
4410 _decode,
4411 )
4412 }
4413
4414 type GetIpTransparentResponseFut = fidl::client::QueryResponseFut<
4415 BaseNetworkSocketGetIpTransparentResult,
4416 fidl::encoding::DefaultFuchsiaResourceDialect,
4417 >;
4418 fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut {
4419 fn _decode(
4420 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4421 ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
4422 let _response = fidl::client::decode_transaction_body::<
4423 fidl::encoding::ResultType<
4424 BaseNetworkSocketGetIpTransparentResponse,
4425 fidl_fuchsia_posix::Errno,
4426 >,
4427 fidl::encoding::DefaultFuchsiaResourceDialect,
4428 0x51d43695962ebfb5,
4429 >(_buf?)?;
4430 Ok(_response.map(|x| x.value))
4431 }
4432 self.client.send_query_and_decode::<
4433 fidl::encoding::EmptyPayload,
4434 BaseNetworkSocketGetIpTransparentResult,
4435 >(
4436 (),
4437 0x51d43695962ebfb5,
4438 fidl::encoding::DynamicFlags::empty(),
4439 _decode,
4440 )
4441 }
4442
4443 type SetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
4444 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
4445 fidl::encoding::DefaultFuchsiaResourceDialect,
4446 >;
4447 fn r#set_ip_receive_original_destination_address(
4448 &self,
4449 mut value: bool,
4450 ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut {
4451 fn _decode(
4452 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4453 ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>
4454 {
4455 let _response = fidl::client::decode_transaction_body::<
4456 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4457 fidl::encoding::DefaultFuchsiaResourceDialect,
4458 0x4722b4ce52f7840,
4459 >(_buf?)?;
4460 Ok(_response.map(|x| x))
4461 }
4462 self.client.send_query_and_decode::<
4463 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
4464 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
4465 >(
4466 (value,),
4467 0x4722b4ce52f7840,
4468 fidl::encoding::DynamicFlags::empty(),
4469 _decode,
4470 )
4471 }
4472
4473 type GetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
4474 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
4475 fidl::encoding::DefaultFuchsiaResourceDialect,
4476 >;
4477 fn r#get_ip_receive_original_destination_address(
4478 &self,
4479 ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut {
4480 fn _decode(
4481 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4482 ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>
4483 {
4484 let _response = fidl::client::decode_transaction_body::<
4485 fidl::encoding::ResultType<
4486 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
4487 fidl_fuchsia_posix::Errno,
4488 >,
4489 fidl::encoding::DefaultFuchsiaResourceDialect,
4490 0x2a0e7dc5d6bfdfe9,
4491 >(_buf?)?;
4492 Ok(_response.map(|x| x.value))
4493 }
4494 self.client.send_query_and_decode::<
4495 fidl::encoding::EmptyPayload,
4496 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
4497 >(
4498 (),
4499 0x2a0e7dc5d6bfdfe9,
4500 fidl::encoding::DynamicFlags::empty(),
4501 _decode,
4502 )
4503 }
4504
4505 type AddIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
4506 BaseNetworkSocketAddIpv6MembershipResult,
4507 fidl::encoding::DefaultFuchsiaResourceDialect,
4508 >;
4509 fn r#add_ipv6_membership(
4510 &self,
4511 mut membership: &Ipv6MulticastMembership,
4512 ) -> Self::AddIpv6MembershipResponseFut {
4513 fn _decode(
4514 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4515 ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
4516 let _response = fidl::client::decode_transaction_body::<
4517 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4518 fidl::encoding::DefaultFuchsiaResourceDialect,
4519 0x7c94727acb4ea4b3,
4520 >(_buf?)?;
4521 Ok(_response.map(|x| x))
4522 }
4523 self.client.send_query_and_decode::<
4524 BaseNetworkSocketAddIpv6MembershipRequest,
4525 BaseNetworkSocketAddIpv6MembershipResult,
4526 >(
4527 (membership,),
4528 0x7c94727acb4ea4b3,
4529 fidl::encoding::DynamicFlags::empty(),
4530 _decode,
4531 )
4532 }
4533
4534 type DropIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
4535 BaseNetworkSocketDropIpv6MembershipResult,
4536 fidl::encoding::DefaultFuchsiaResourceDialect,
4537 >;
4538 fn r#drop_ipv6_membership(
4539 &self,
4540 mut membership: &Ipv6MulticastMembership,
4541 ) -> Self::DropIpv6MembershipResponseFut {
4542 fn _decode(
4543 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4544 ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
4545 let _response = fidl::client::decode_transaction_body::<
4546 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4547 fidl::encoding::DefaultFuchsiaResourceDialect,
4548 0x42104c70ccaba304,
4549 >(_buf?)?;
4550 Ok(_response.map(|x| x))
4551 }
4552 self.client.send_query_and_decode::<
4553 BaseNetworkSocketDropIpv6MembershipRequest,
4554 BaseNetworkSocketDropIpv6MembershipResult,
4555 >(
4556 (membership,),
4557 0x42104c70ccaba304,
4558 fidl::encoding::DynamicFlags::empty(),
4559 _decode,
4560 )
4561 }
4562
4563 type SetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
4564 BaseNetworkSocketSetIpv6MulticastInterfaceResult,
4565 fidl::encoding::DefaultFuchsiaResourceDialect,
4566 >;
4567 fn r#set_ipv6_multicast_interface(
4568 &self,
4569 mut value: u64,
4570 ) -> Self::SetIpv6MulticastInterfaceResponseFut {
4571 fn _decode(
4572 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4573 ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
4574 let _response = fidl::client::decode_transaction_body::<
4575 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4576 fidl::encoding::DefaultFuchsiaResourceDialect,
4577 0x135f76db3774ab3b,
4578 >(_buf?)?;
4579 Ok(_response.map(|x| x))
4580 }
4581 self.client.send_query_and_decode::<
4582 BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
4583 BaseNetworkSocketSetIpv6MulticastInterfaceResult,
4584 >(
4585 (value,),
4586 0x135f76db3774ab3b,
4587 fidl::encoding::DynamicFlags::empty(),
4588 _decode,
4589 )
4590 }
4591
4592 type GetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
4593 BaseNetworkSocketGetIpv6MulticastInterfaceResult,
4594 fidl::encoding::DefaultFuchsiaResourceDialect,
4595 >;
4596 fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut {
4597 fn _decode(
4598 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4599 ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
4600 let _response = fidl::client::decode_transaction_body::<
4601 fidl::encoding::ResultType<
4602 BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
4603 fidl_fuchsia_posix::Errno,
4604 >,
4605 fidl::encoding::DefaultFuchsiaResourceDialect,
4606 0x1f26fcdd348f1882,
4607 >(_buf?)?;
4608 Ok(_response.map(|x| x.value))
4609 }
4610 self.client.send_query_and_decode::<
4611 fidl::encoding::EmptyPayload,
4612 BaseNetworkSocketGetIpv6MulticastInterfaceResult,
4613 >(
4614 (),
4615 0x1f26fcdd348f1882,
4616 fidl::encoding::DynamicFlags::empty(),
4617 _decode,
4618 )
4619 }
4620
4621 type SetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
4622 BaseNetworkSocketSetIpv6UnicastHopsResult,
4623 fidl::encoding::DefaultFuchsiaResourceDialect,
4624 >;
4625 fn r#set_ipv6_unicast_hops(
4626 &self,
4627 mut value: &OptionalUint8,
4628 ) -> Self::SetIpv6UnicastHopsResponseFut {
4629 fn _decode(
4630 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4631 ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
4632 let _response = fidl::client::decode_transaction_body::<
4633 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4634 fidl::encoding::DefaultFuchsiaResourceDialect,
4635 0x157d51e98f462859,
4636 >(_buf?)?;
4637 Ok(_response.map(|x| x))
4638 }
4639 self.client.send_query_and_decode::<
4640 BaseNetworkSocketSetIpv6UnicastHopsRequest,
4641 BaseNetworkSocketSetIpv6UnicastHopsResult,
4642 >(
4643 (value,),
4644 0x157d51e98f462859,
4645 fidl::encoding::DynamicFlags::empty(),
4646 _decode,
4647 )
4648 }
4649
4650 type GetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
4651 BaseNetworkSocketGetIpv6UnicastHopsResult,
4652 fidl::encoding::DefaultFuchsiaResourceDialect,
4653 >;
4654 fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut {
4655 fn _decode(
4656 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4657 ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
4658 let _response = fidl::client::decode_transaction_body::<
4659 fidl::encoding::ResultType<
4660 BaseNetworkSocketGetIpv6UnicastHopsResponse,
4661 fidl_fuchsia_posix::Errno,
4662 >,
4663 fidl::encoding::DefaultFuchsiaResourceDialect,
4664 0x21f4641cad8bd8d2,
4665 >(_buf?)?;
4666 Ok(_response.map(|x| x.value))
4667 }
4668 self.client.send_query_and_decode::<
4669 fidl::encoding::EmptyPayload,
4670 BaseNetworkSocketGetIpv6UnicastHopsResult,
4671 >(
4672 (),
4673 0x21f4641cad8bd8d2,
4674 fidl::encoding::DynamicFlags::empty(),
4675 _decode,
4676 )
4677 }
4678
4679 type SetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
4680 BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
4681 fidl::encoding::DefaultFuchsiaResourceDialect,
4682 >;
4683 fn r#set_ipv6_receive_hop_limit(
4684 &self,
4685 mut value: bool,
4686 ) -> Self::SetIpv6ReceiveHopLimitResponseFut {
4687 fn _decode(
4688 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4689 ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
4690 let _response = fidl::client::decode_transaction_body::<
4691 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4692 fidl::encoding::DefaultFuchsiaResourceDialect,
4693 0x5c24808ed2e84a1e,
4694 >(_buf?)?;
4695 Ok(_response.map(|x| x))
4696 }
4697 self.client.send_query_and_decode::<
4698 BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
4699 BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
4700 >(
4701 (value,),
4702 0x5c24808ed2e84a1e,
4703 fidl::encoding::DynamicFlags::empty(),
4704 _decode,
4705 )
4706 }
4707
4708 type GetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
4709 BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
4710 fidl::encoding::DefaultFuchsiaResourceDialect,
4711 >;
4712 fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut {
4713 fn _decode(
4714 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4715 ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
4716 let _response = fidl::client::decode_transaction_body::<
4717 fidl::encoding::ResultType<
4718 BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
4719 fidl_fuchsia_posix::Errno,
4720 >,
4721 fidl::encoding::DefaultFuchsiaResourceDialect,
4722 0x341e06689885b4c0,
4723 >(_buf?)?;
4724 Ok(_response.map(|x| x.value))
4725 }
4726 self.client.send_query_and_decode::<
4727 fidl::encoding::EmptyPayload,
4728 BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
4729 >(
4730 (),
4731 0x341e06689885b4c0,
4732 fidl::encoding::DynamicFlags::empty(),
4733 _decode,
4734 )
4735 }
4736
4737 type SetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
4738 BaseNetworkSocketSetIpv6MulticastHopsResult,
4739 fidl::encoding::DefaultFuchsiaResourceDialect,
4740 >;
4741 fn r#set_ipv6_multicast_hops(
4742 &self,
4743 mut value: &OptionalUint8,
4744 ) -> Self::SetIpv6MulticastHopsResponseFut {
4745 fn _decode(
4746 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4747 ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
4748 let _response = fidl::client::decode_transaction_body::<
4749 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4750 fidl::encoding::DefaultFuchsiaResourceDialect,
4751 0x25b9cd4d181f82c1,
4752 >(_buf?)?;
4753 Ok(_response.map(|x| x))
4754 }
4755 self.client.send_query_and_decode::<
4756 BaseNetworkSocketSetIpv6MulticastHopsRequest,
4757 BaseNetworkSocketSetIpv6MulticastHopsResult,
4758 >(
4759 (value,),
4760 0x25b9cd4d181f82c1,
4761 fidl::encoding::DynamicFlags::empty(),
4762 _decode,
4763 )
4764 }
4765
4766 type GetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
4767 BaseNetworkSocketGetIpv6MulticastHopsResult,
4768 fidl::encoding::DefaultFuchsiaResourceDialect,
4769 >;
4770 fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut {
4771 fn _decode(
4772 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4773 ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
4774 let _response = fidl::client::decode_transaction_body::<
4775 fidl::encoding::ResultType<
4776 BaseNetworkSocketGetIpv6MulticastHopsResponse,
4777 fidl_fuchsia_posix::Errno,
4778 >,
4779 fidl::encoding::DefaultFuchsiaResourceDialect,
4780 0x52916948a365012a,
4781 >(_buf?)?;
4782 Ok(_response.map(|x| x.value))
4783 }
4784 self.client.send_query_and_decode::<
4785 fidl::encoding::EmptyPayload,
4786 BaseNetworkSocketGetIpv6MulticastHopsResult,
4787 >(
4788 (),
4789 0x52916948a365012a,
4790 fidl::encoding::DynamicFlags::empty(),
4791 _decode,
4792 )
4793 }
4794
4795 type SetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
4796 BaseNetworkSocketSetIpv6MulticastLoopbackResult,
4797 fidl::encoding::DefaultFuchsiaResourceDialect,
4798 >;
4799 fn r#set_ipv6_multicast_loopback(
4800 &self,
4801 mut value: bool,
4802 ) -> Self::SetIpv6MulticastLoopbackResponseFut {
4803 fn _decode(
4804 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4805 ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
4806 let _response = fidl::client::decode_transaction_body::<
4807 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4808 fidl::encoding::DefaultFuchsiaResourceDialect,
4809 0x55701c409ff41b40,
4810 >(_buf?)?;
4811 Ok(_response.map(|x| x))
4812 }
4813 self.client.send_query_and_decode::<
4814 BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
4815 BaseNetworkSocketSetIpv6MulticastLoopbackResult,
4816 >(
4817 (value,),
4818 0x55701c409ff41b40,
4819 fidl::encoding::DynamicFlags::empty(),
4820 _decode,
4821 )
4822 }
4823
4824 type GetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
4825 BaseNetworkSocketGetIpv6MulticastLoopbackResult,
4826 fidl::encoding::DefaultFuchsiaResourceDialect,
4827 >;
4828 fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut {
4829 fn _decode(
4830 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4831 ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
4832 let _response = fidl::client::decode_transaction_body::<
4833 fidl::encoding::ResultType<
4834 BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
4835 fidl_fuchsia_posix::Errno,
4836 >,
4837 fidl::encoding::DefaultFuchsiaResourceDialect,
4838 0x4415b701fde319c3,
4839 >(_buf?)?;
4840 Ok(_response.map(|x| x.value))
4841 }
4842 self.client.send_query_and_decode::<
4843 fidl::encoding::EmptyPayload,
4844 BaseNetworkSocketGetIpv6MulticastLoopbackResult,
4845 >(
4846 (),
4847 0x4415b701fde319c3,
4848 fidl::encoding::DynamicFlags::empty(),
4849 _decode,
4850 )
4851 }
4852
4853 type SetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
4854 BaseNetworkSocketSetIpv6OnlyResult,
4855 fidl::encoding::DefaultFuchsiaResourceDialect,
4856 >;
4857 fn r#set_ipv6_only(&self, mut value: bool) -> Self::SetIpv6OnlyResponseFut {
4858 fn _decode(
4859 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4860 ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
4861 let _response = fidl::client::decode_transaction_body::<
4862 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4863 fidl::encoding::DefaultFuchsiaResourceDialect,
4864 0x4873f1364758cbba,
4865 >(_buf?)?;
4866 Ok(_response.map(|x| x))
4867 }
4868 self.client.send_query_and_decode::<
4869 BaseNetworkSocketSetIpv6OnlyRequest,
4870 BaseNetworkSocketSetIpv6OnlyResult,
4871 >(
4872 (value,),
4873 0x4873f1364758cbba,
4874 fidl::encoding::DynamicFlags::empty(),
4875 _decode,
4876 )
4877 }
4878
4879 type GetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
4880 BaseNetworkSocketGetIpv6OnlyResult,
4881 fidl::encoding::DefaultFuchsiaResourceDialect,
4882 >;
4883 fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut {
4884 fn _decode(
4885 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4886 ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
4887 let _response = fidl::client::decode_transaction_body::<
4888 fidl::encoding::ResultType<
4889 BaseNetworkSocketGetIpv6OnlyResponse,
4890 fidl_fuchsia_posix::Errno,
4891 >,
4892 fidl::encoding::DefaultFuchsiaResourceDialect,
4893 0x4aa3340a1a26b89c,
4894 >(_buf?)?;
4895 Ok(_response.map(|x| x.value))
4896 }
4897 self.client.send_query_and_decode::<
4898 fidl::encoding::EmptyPayload,
4899 BaseNetworkSocketGetIpv6OnlyResult,
4900 >(
4901 (),
4902 0x4aa3340a1a26b89c,
4903 fidl::encoding::DynamicFlags::empty(),
4904 _decode,
4905 )
4906 }
4907
4908 type SetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
4909 BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
4910 fidl::encoding::DefaultFuchsiaResourceDialect,
4911 >;
4912 fn r#set_ipv6_receive_traffic_class(
4913 &self,
4914 mut value: bool,
4915 ) -> Self::SetIpv6ReceiveTrafficClassResponseFut {
4916 fn _decode(
4917 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4918 ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
4919 let _response = fidl::client::decode_transaction_body::<
4920 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4921 fidl::encoding::DefaultFuchsiaResourceDialect,
4922 0x58f07c8788d099a0,
4923 >(_buf?)?;
4924 Ok(_response.map(|x| x))
4925 }
4926 self.client.send_query_and_decode::<
4927 BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
4928 BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
4929 >(
4930 (value,),
4931 0x58f07c8788d099a0,
4932 fidl::encoding::DynamicFlags::empty(),
4933 _decode,
4934 )
4935 }
4936
4937 type GetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
4938 BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
4939 fidl::encoding::DefaultFuchsiaResourceDialect,
4940 >;
4941 fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut {
4942 fn _decode(
4943 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4944 ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
4945 let _response = fidl::client::decode_transaction_body::<
4946 fidl::encoding::ResultType<
4947 BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
4948 fidl_fuchsia_posix::Errno,
4949 >,
4950 fidl::encoding::DefaultFuchsiaResourceDialect,
4951 0x2e334df1da553ffa,
4952 >(_buf?)?;
4953 Ok(_response.map(|x| x.value))
4954 }
4955 self.client.send_query_and_decode::<
4956 fidl::encoding::EmptyPayload,
4957 BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
4958 >(
4959 (),
4960 0x2e334df1da553ffa,
4961 fidl::encoding::DynamicFlags::empty(),
4962 _decode,
4963 )
4964 }
4965
4966 type SetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
4967 BaseNetworkSocketSetIpv6TrafficClassResult,
4968 fidl::encoding::DefaultFuchsiaResourceDialect,
4969 >;
4970 fn r#set_ipv6_traffic_class(
4971 &self,
4972 mut value: &OptionalUint8,
4973 ) -> Self::SetIpv6TrafficClassResponseFut {
4974 fn _decode(
4975 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4976 ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
4977 let _response = fidl::client::decode_transaction_body::<
4978 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4979 fidl::encoding::DefaultFuchsiaResourceDialect,
4980 0x6af077800c5a0b4f,
4981 >(_buf?)?;
4982 Ok(_response.map(|x| x))
4983 }
4984 self.client.send_query_and_decode::<
4985 BaseNetworkSocketSetIpv6TrafficClassRequest,
4986 BaseNetworkSocketSetIpv6TrafficClassResult,
4987 >(
4988 (value,),
4989 0x6af077800c5a0b4f,
4990 fidl::encoding::DynamicFlags::empty(),
4991 _decode,
4992 )
4993 }
4994
4995 type GetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
4996 BaseNetworkSocketGetIpv6TrafficClassResult,
4997 fidl::encoding::DefaultFuchsiaResourceDialect,
4998 >;
4999 fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut {
5000 fn _decode(
5001 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5002 ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
5003 let _response = fidl::client::decode_transaction_body::<
5004 fidl::encoding::ResultType<
5005 BaseNetworkSocketGetIpv6TrafficClassResponse,
5006 fidl_fuchsia_posix::Errno,
5007 >,
5008 fidl::encoding::DefaultFuchsiaResourceDialect,
5009 0x6baf6eed8fc2f04,
5010 >(_buf?)?;
5011 Ok(_response.map(|x| x.value))
5012 }
5013 self.client.send_query_and_decode::<
5014 fidl::encoding::EmptyPayload,
5015 BaseNetworkSocketGetIpv6TrafficClassResult,
5016 >(
5017 (),
5018 0x6baf6eed8fc2f04,
5019 fidl::encoding::DynamicFlags::empty(),
5020 _decode,
5021 )
5022 }
5023
5024 type SetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
5025 BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
5026 fidl::encoding::DefaultFuchsiaResourceDialect,
5027 >;
5028 fn r#set_ipv6_receive_packet_info(
5029 &self,
5030 mut value: bool,
5031 ) -> Self::SetIpv6ReceivePacketInfoResponseFut {
5032 fn _decode(
5033 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5034 ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
5035 let _response = fidl::client::decode_transaction_body::<
5036 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5037 fidl::encoding::DefaultFuchsiaResourceDialect,
5038 0x19259775b1a92768,
5039 >(_buf?)?;
5040 Ok(_response.map(|x| x))
5041 }
5042 self.client.send_query_and_decode::<
5043 BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
5044 BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
5045 >(
5046 (value,),
5047 0x19259775b1a92768,
5048 fidl::encoding::DynamicFlags::empty(),
5049 _decode,
5050 )
5051 }
5052
5053 type GetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
5054 BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
5055 fidl::encoding::DefaultFuchsiaResourceDialect,
5056 >;
5057 fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut {
5058 fn _decode(
5059 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5060 ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
5061 let _response = fidl::client::decode_transaction_body::<
5062 fidl::encoding::ResultType<
5063 BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
5064 fidl_fuchsia_posix::Errno,
5065 >,
5066 fidl::encoding::DefaultFuchsiaResourceDialect,
5067 0x7acd4a2775baec75,
5068 >(_buf?)?;
5069 Ok(_response.map(|x| x.value))
5070 }
5071 self.client.send_query_and_decode::<
5072 fidl::encoding::EmptyPayload,
5073 BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
5074 >(
5075 (),
5076 0x7acd4a2775baec75,
5077 fidl::encoding::DynamicFlags::empty(),
5078 _decode,
5079 )
5080 }
5081
5082 type GetOriginalDestinationResponseFut = fidl::client::QueryResponseFut<
5083 BaseNetworkSocketGetOriginalDestinationResult,
5084 fidl::encoding::DefaultFuchsiaResourceDialect,
5085 >;
5086 fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut {
5087 fn _decode(
5088 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5089 ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
5090 let _response = fidl::client::decode_transaction_body::<
5091 fidl::encoding::ResultType<
5092 BaseNetworkSocketGetOriginalDestinationResponse,
5093 fidl_fuchsia_posix::Errno,
5094 >,
5095 fidl::encoding::DefaultFuchsiaResourceDialect,
5096 0x38bf28f0dafdbac0,
5097 >(_buf?)?;
5098 Ok(_response.map(|x| x.value))
5099 }
5100 self.client.send_query_and_decode::<
5101 fidl::encoding::EmptyPayload,
5102 BaseNetworkSocketGetOriginalDestinationResult,
5103 >(
5104 (),
5105 0x38bf28f0dafdbac0,
5106 fidl::encoding::DynamicFlags::empty(),
5107 _decode,
5108 )
5109 }
5110
5111 type GetInfoResponseFut = fidl::client::QueryResponseFut<
5112 BaseDatagramSocketGetInfoResult,
5113 fidl::encoding::DefaultFuchsiaResourceDialect,
5114 >;
5115 fn r#get_info(&self) -> Self::GetInfoResponseFut {
5116 fn _decode(
5117 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5118 ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
5119 let _response = fidl::client::decode_transaction_body::<
5120 fidl::encoding::ResultType<
5121 BaseDatagramSocketGetInfoResponse,
5122 fidl_fuchsia_posix::Errno,
5123 >,
5124 fidl::encoding::DefaultFuchsiaResourceDialect,
5125 0x48aa0a1f6a32d2ed,
5126 >(_buf?)?;
5127 Ok(_response.map(|x| (x.domain, x.proto)))
5128 }
5129 self.client
5130 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseDatagramSocketGetInfoResult>(
5131 (),
5132 0x48aa0a1f6a32d2ed,
5133 fidl::encoding::DynamicFlags::empty(),
5134 _decode,
5135 )
5136 }
5137}
5138
5139pub struct BaseDatagramSocketEventStream {
5140 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
5141}
5142
5143impl std::marker::Unpin for BaseDatagramSocketEventStream {}
5144
5145impl futures::stream::FusedStream for BaseDatagramSocketEventStream {
5146 fn is_terminated(&self) -> bool {
5147 self.event_receiver.is_terminated()
5148 }
5149}
5150
5151impl futures::Stream for BaseDatagramSocketEventStream {
5152 type Item = Result<BaseDatagramSocketEvent, fidl::Error>;
5153
5154 fn poll_next(
5155 mut self: std::pin::Pin<&mut Self>,
5156 cx: &mut std::task::Context<'_>,
5157 ) -> std::task::Poll<Option<Self::Item>> {
5158 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
5159 &mut self.event_receiver,
5160 cx
5161 )?) {
5162 Some(buf) => std::task::Poll::Ready(Some(BaseDatagramSocketEvent::decode(buf))),
5163 None => std::task::Poll::Ready(None),
5164 }
5165 }
5166}
5167
5168#[derive(Debug)]
5169pub enum BaseDatagramSocketEvent {}
5170
5171impl BaseDatagramSocketEvent {
5172 fn decode(
5174 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
5175 ) -> Result<BaseDatagramSocketEvent, fidl::Error> {
5176 let (bytes, _handles) = buf.split_mut();
5177 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
5178 debug_assert_eq!(tx_header.tx_id, 0);
5179 match tx_header.ordinal {
5180 _ => Err(fidl::Error::UnknownOrdinal {
5181 ordinal: tx_header.ordinal,
5182 protocol_name:
5183 <BaseDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
5184 }),
5185 }
5186 }
5187}
5188
5189pub struct BaseDatagramSocketRequestStream {
5191 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
5192 is_terminated: bool,
5193}
5194
5195impl std::marker::Unpin for BaseDatagramSocketRequestStream {}
5196
5197impl futures::stream::FusedStream for BaseDatagramSocketRequestStream {
5198 fn is_terminated(&self) -> bool {
5199 self.is_terminated
5200 }
5201}
5202
5203impl fidl::endpoints::RequestStream for BaseDatagramSocketRequestStream {
5204 type Protocol = BaseDatagramSocketMarker;
5205 type ControlHandle = BaseDatagramSocketControlHandle;
5206
5207 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
5208 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
5209 }
5210
5211 fn control_handle(&self) -> Self::ControlHandle {
5212 BaseDatagramSocketControlHandle { inner: self.inner.clone() }
5213 }
5214
5215 fn into_inner(
5216 self,
5217 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
5218 {
5219 (self.inner, self.is_terminated)
5220 }
5221
5222 fn from_inner(
5223 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
5224 is_terminated: bool,
5225 ) -> Self {
5226 Self { inner, is_terminated }
5227 }
5228}
5229
5230impl futures::Stream for BaseDatagramSocketRequestStream {
5231 type Item = Result<BaseDatagramSocketRequest, fidl::Error>;
5232
5233 fn poll_next(
5234 mut self: std::pin::Pin<&mut Self>,
5235 cx: &mut std::task::Context<'_>,
5236 ) -> std::task::Poll<Option<Self::Item>> {
5237 let this = &mut *self;
5238 if this.inner.check_shutdown(cx) {
5239 this.is_terminated = true;
5240 return std::task::Poll::Ready(None);
5241 }
5242 if this.is_terminated {
5243 panic!("polled BaseDatagramSocketRequestStream after completion");
5244 }
5245 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
5246 |bytes, handles| {
5247 match this.inner.channel().read_etc(cx, bytes, handles) {
5248 std::task::Poll::Ready(Ok(())) => {}
5249 std::task::Poll::Pending => return std::task::Poll::Pending,
5250 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
5251 this.is_terminated = true;
5252 return std::task::Poll::Ready(None);
5253 }
5254 std::task::Poll::Ready(Err(e)) => {
5255 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
5256 e.into(),
5257 ))))
5258 }
5259 }
5260
5261 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
5263
5264 std::task::Poll::Ready(Some(match header.ordinal {
5265 0x20d8a7aba2168a79 => {
5266 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
5267 let mut req = fidl::new_empty!(fidl_fuchsia_unknown::CloneableCloneRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5268 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
5269 let control_handle = BaseDatagramSocketControlHandle {
5270 inner: this.inner.clone(),
5271 };
5272 Ok(BaseDatagramSocketRequest::Clone {request: req.request,
5273
5274 control_handle,
5275 })
5276 }
5277 0x5ac5d459ad7f657e => {
5278 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5279 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5280 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5281 let control_handle = BaseDatagramSocketControlHandle {
5282 inner: this.inner.clone(),
5283 };
5284 Ok(BaseDatagramSocketRequest::Close {
5285 responder: BaseDatagramSocketCloseResponder {
5286 control_handle: std::mem::ManuallyDrop::new(control_handle),
5287 tx_id: header.tx_id,
5288 },
5289 })
5290 }
5291 0x2658edee9decfc06 => {
5292 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5293 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5294 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5295 let control_handle = BaseDatagramSocketControlHandle {
5296 inner: this.inner.clone(),
5297 };
5298 Ok(BaseDatagramSocketRequest::Query {
5299 responder: BaseDatagramSocketQueryResponder {
5300 control_handle: std::mem::ManuallyDrop::new(control_handle),
5301 tx_id: header.tx_id,
5302 },
5303 })
5304 }
5305 0x1fd74ee8b9a4a876 => {
5306 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5307 let mut req = fidl::new_empty!(BaseSocketSetReuseAddressRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5308 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
5309 let control_handle = BaseDatagramSocketControlHandle {
5310 inner: this.inner.clone(),
5311 };
5312 Ok(BaseDatagramSocketRequest::SetReuseAddress {value: req.value,
5313
5314 responder: BaseDatagramSocketSetReuseAddressResponder {
5315 control_handle: std::mem::ManuallyDrop::new(control_handle),
5316 tx_id: header.tx_id,
5317 },
5318 })
5319 }
5320 0x67b7206b8d1bc0a5 => {
5321 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5322 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5323 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5324 let control_handle = BaseDatagramSocketControlHandle {
5325 inner: this.inner.clone(),
5326 };
5327 Ok(BaseDatagramSocketRequest::GetReuseAddress {
5328 responder: BaseDatagramSocketGetReuseAddressResponder {
5329 control_handle: std::mem::ManuallyDrop::new(control_handle),
5330 tx_id: header.tx_id,
5331 },
5332 })
5333 }
5334 0x5aad39b33e5f6ebb => {
5335 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5336 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5337 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5338 let control_handle = BaseDatagramSocketControlHandle {
5339 inner: this.inner.clone(),
5340 };
5341 Ok(BaseDatagramSocketRequest::GetError {
5342 responder: BaseDatagramSocketGetErrorResponder {
5343 control_handle: std::mem::ManuallyDrop::new(control_handle),
5344 tx_id: header.tx_id,
5345 },
5346 })
5347 }
5348 0x6023e081ce3cd947 => {
5349 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5350 let mut req = fidl::new_empty!(BaseSocketSetBroadcastRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5351 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
5352 let control_handle = BaseDatagramSocketControlHandle {
5353 inner: this.inner.clone(),
5354 };
5355 Ok(BaseDatagramSocketRequest::SetBroadcast {value: req.value,
5356
5357 responder: BaseDatagramSocketSetBroadcastResponder {
5358 control_handle: std::mem::ManuallyDrop::new(control_handle),
5359 tx_id: header.tx_id,
5360 },
5361 })
5362 }
5363 0x68796fc556f9780d => {
5364 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5365 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5366 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5367 let control_handle = BaseDatagramSocketControlHandle {
5368 inner: this.inner.clone(),
5369 };
5370 Ok(BaseDatagramSocketRequest::GetBroadcast {
5371 responder: BaseDatagramSocketGetBroadcastResponder {
5372 control_handle: std::mem::ManuallyDrop::new(control_handle),
5373 tx_id: header.tx_id,
5374 },
5375 })
5376 }
5377 0x756eac32d73a7a70 => {
5378 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5379 let mut req = fidl::new_empty!(BaseSocketSetSendBufferRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5380 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
5381 let control_handle = BaseDatagramSocketControlHandle {
5382 inner: this.inner.clone(),
5383 };
5384 Ok(BaseDatagramSocketRequest::SetSendBuffer {value_bytes: req.value_bytes,
5385
5386 responder: BaseDatagramSocketSetSendBufferResponder {
5387 control_handle: std::mem::ManuallyDrop::new(control_handle),
5388 tx_id: header.tx_id,
5389 },
5390 })
5391 }
5392 0x78a52fd9c7b2410b => {
5393 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5394 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5395 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5396 let control_handle = BaseDatagramSocketControlHandle {
5397 inner: this.inner.clone(),
5398 };
5399 Ok(BaseDatagramSocketRequest::GetSendBuffer {
5400 responder: BaseDatagramSocketGetSendBufferResponder {
5401 control_handle: std::mem::ManuallyDrop::new(control_handle),
5402 tx_id: header.tx_id,
5403 },
5404 })
5405 }
5406 0x6b0cf2f1919c7001 => {
5407 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5408 let mut req = fidl::new_empty!(BaseSocketSetReceiveBufferRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5409 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
5410 let control_handle = BaseDatagramSocketControlHandle {
5411 inner: this.inner.clone(),
5412 };
5413 Ok(BaseDatagramSocketRequest::SetReceiveBuffer {value_bytes: req.value_bytes,
5414
5415 responder: BaseDatagramSocketSetReceiveBufferResponder {
5416 control_handle: std::mem::ManuallyDrop::new(control_handle),
5417 tx_id: header.tx_id,
5418 },
5419 })
5420 }
5421 0x14c1a4b64f709e5c => {
5422 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5423 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5424 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5425 let control_handle = BaseDatagramSocketControlHandle {
5426 inner: this.inner.clone(),
5427 };
5428 Ok(BaseDatagramSocketRequest::GetReceiveBuffer {
5429 responder: BaseDatagramSocketGetReceiveBufferResponder {
5430 control_handle: std::mem::ManuallyDrop::new(control_handle),
5431 tx_id: header.tx_id,
5432 },
5433 })
5434 }
5435 0x572df8f0b920d2c7 => {
5436 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5437 let mut req = fidl::new_empty!(BaseSocketSetKeepAliveRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5438 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
5439 let control_handle = BaseDatagramSocketControlHandle {
5440 inner: this.inner.clone(),
5441 };
5442 Ok(BaseDatagramSocketRequest::SetKeepAlive {value: req.value,
5443
5444 responder: BaseDatagramSocketSetKeepAliveResponder {
5445 control_handle: std::mem::ManuallyDrop::new(control_handle),
5446 tx_id: header.tx_id,
5447 },
5448 })
5449 }
5450 0x2dd29d3215f2c9d2 => {
5451 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5452 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5453 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5454 let control_handle = BaseDatagramSocketControlHandle {
5455 inner: this.inner.clone(),
5456 };
5457 Ok(BaseDatagramSocketRequest::GetKeepAlive {
5458 responder: BaseDatagramSocketGetKeepAliveResponder {
5459 control_handle: std::mem::ManuallyDrop::new(control_handle),
5460 tx_id: header.tx_id,
5461 },
5462 })
5463 }
5464 0x3ecb49968bee439 => {
5465 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5466 let mut req = fidl::new_empty!(BaseSocketSetOutOfBandInlineRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5467 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
5468 let control_handle = BaseDatagramSocketControlHandle {
5469 inner: this.inner.clone(),
5470 };
5471 Ok(BaseDatagramSocketRequest::SetOutOfBandInline {value: req.value,
5472
5473 responder: BaseDatagramSocketSetOutOfBandInlineResponder {
5474 control_handle: std::mem::ManuallyDrop::new(control_handle),
5475 tx_id: header.tx_id,
5476 },
5477 })
5478 }
5479 0x348c1ab3aeca1745 => {
5480 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5481 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5482 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5483 let control_handle = BaseDatagramSocketControlHandle {
5484 inner: this.inner.clone(),
5485 };
5486 Ok(BaseDatagramSocketRequest::GetOutOfBandInline {
5487 responder: BaseDatagramSocketGetOutOfBandInlineResponder {
5488 control_handle: std::mem::ManuallyDrop::new(control_handle),
5489 tx_id: header.tx_id,
5490 },
5491 })
5492 }
5493 0x6bbf00c53a4c78c2 => {
5494 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5495 let mut req = fidl::new_empty!(BaseSocketSetNoCheckRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5496 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
5497 let control_handle = BaseDatagramSocketControlHandle {
5498 inner: this.inner.clone(),
5499 };
5500 Ok(BaseDatagramSocketRequest::SetNoCheck {value: req.value,
5501
5502 responder: BaseDatagramSocketSetNoCheckResponder {
5503 control_handle: std::mem::ManuallyDrop::new(control_handle),
5504 tx_id: header.tx_id,
5505 },
5506 })
5507 }
5508 0x2cd4249286417694 => {
5509 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5510 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5511 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5512 let control_handle = BaseDatagramSocketControlHandle {
5513 inner: this.inner.clone(),
5514 };
5515 Ok(BaseDatagramSocketRequest::GetNoCheck {
5516 responder: BaseDatagramSocketGetNoCheckResponder {
5517 control_handle: std::mem::ManuallyDrop::new(control_handle),
5518 tx_id: header.tx_id,
5519 },
5520 })
5521 }
5522 0x45386351246e998e => {
5523 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5524 let mut req = fidl::new_empty!(BaseSocketSetLingerRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5525 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
5526 let control_handle = BaseDatagramSocketControlHandle {
5527 inner: this.inner.clone(),
5528 };
5529 Ok(BaseDatagramSocketRequest::SetLinger {linger: req.linger,
5530length_secs: req.length_secs,
5531
5532 responder: BaseDatagramSocketSetLingerResponder {
5533 control_handle: std::mem::ManuallyDrop::new(control_handle),
5534 tx_id: header.tx_id,
5535 },
5536 })
5537 }
5538 0x48eb20fc5ccb0e45 => {
5539 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5540 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5541 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5542 let control_handle = BaseDatagramSocketControlHandle {
5543 inner: this.inner.clone(),
5544 };
5545 Ok(BaseDatagramSocketRequest::GetLinger {
5546 responder: BaseDatagramSocketGetLingerResponder {
5547 control_handle: std::mem::ManuallyDrop::new(control_handle),
5548 tx_id: header.tx_id,
5549 },
5550 })
5551 }
5552 0x24dd3e5cb36d9ccb => {
5553 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5554 let mut req = fidl::new_empty!(BaseSocketSetReusePortRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5555 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
5556 let control_handle = BaseDatagramSocketControlHandle {
5557 inner: this.inner.clone(),
5558 };
5559 Ok(BaseDatagramSocketRequest::SetReusePort {value: req.value,
5560
5561 responder: BaseDatagramSocketSetReusePortResponder {
5562 control_handle: std::mem::ManuallyDrop::new(control_handle),
5563 tx_id: header.tx_id,
5564 },
5565 })
5566 }
5567 0x7a112c1ab54ff828 => {
5568 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5569 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5570 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5571 let control_handle = BaseDatagramSocketControlHandle {
5572 inner: this.inner.clone(),
5573 };
5574 Ok(BaseDatagramSocketRequest::GetReusePort {
5575 responder: BaseDatagramSocketGetReusePortResponder {
5576 control_handle: std::mem::ManuallyDrop::new(control_handle),
5577 tx_id: header.tx_id,
5578 },
5579 })
5580 }
5581 0x67ce6db6c2ec8966 => {
5582 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5583 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5584 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5585 let control_handle = BaseDatagramSocketControlHandle {
5586 inner: this.inner.clone(),
5587 };
5588 Ok(BaseDatagramSocketRequest::GetAcceptConn {
5589 responder: BaseDatagramSocketGetAcceptConnResponder {
5590 control_handle: std::mem::ManuallyDrop::new(control_handle),
5591 tx_id: header.tx_id,
5592 },
5593 })
5594 }
5595 0x2118b483f28aafc4 => {
5596 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5597 let mut req = fidl::new_empty!(BaseSocketSetBindToDeviceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5598 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
5599 let control_handle = BaseDatagramSocketControlHandle {
5600 inner: this.inner.clone(),
5601 };
5602 Ok(BaseDatagramSocketRequest::SetBindToDevice {value: req.value,
5603
5604 responder: BaseDatagramSocketSetBindToDeviceResponder {
5605 control_handle: std::mem::ManuallyDrop::new(control_handle),
5606 tx_id: header.tx_id,
5607 },
5608 })
5609 }
5610 0x1ab1fbf0ef7906c8 => {
5611 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5612 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5613 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5614 let control_handle = BaseDatagramSocketControlHandle {
5615 inner: this.inner.clone(),
5616 };
5617 Ok(BaseDatagramSocketRequest::GetBindToDevice {
5618 responder: BaseDatagramSocketGetBindToDeviceResponder {
5619 control_handle: std::mem::ManuallyDrop::new(control_handle),
5620 tx_id: header.tx_id,
5621 },
5622 })
5623 }
5624 0x6e387a0def00821 => {
5625 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5626 let mut req = fidl::new_empty!(BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5627 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
5628 let control_handle = BaseDatagramSocketControlHandle {
5629 inner: this.inner.clone(),
5630 };
5631 Ok(BaseDatagramSocketRequest::SetBindToInterfaceIndex {value: req.value,
5632
5633 responder: BaseDatagramSocketSetBindToInterfaceIndexResponder {
5634 control_handle: std::mem::ManuallyDrop::new(control_handle),
5635 tx_id: header.tx_id,
5636 },
5637 })
5638 }
5639 0x59c31dd3e3078295 => {
5640 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5641 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5642 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5643 let control_handle = BaseDatagramSocketControlHandle {
5644 inner: this.inner.clone(),
5645 };
5646 Ok(BaseDatagramSocketRequest::GetBindToInterfaceIndex {
5647 responder: BaseDatagramSocketGetBindToInterfaceIndexResponder {
5648 control_handle: std::mem::ManuallyDrop::new(control_handle),
5649 tx_id: header.tx_id,
5650 },
5651 })
5652 }
5653 0x285d6516c263d839 => {
5654 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5655 let mut req = fidl::new_empty!(BaseSocketSetTimestampRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5656 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
5657 let control_handle = BaseDatagramSocketControlHandle {
5658 inner: this.inner.clone(),
5659 };
5660 Ok(BaseDatagramSocketRequest::SetTimestamp {value: req.value,
5661
5662 responder: BaseDatagramSocketSetTimestampResponder {
5663 control_handle: std::mem::ManuallyDrop::new(control_handle),
5664 tx_id: header.tx_id,
5665 },
5666 })
5667 }
5668 0x49f2fffbbcc2bd27 => {
5669 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5670 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5671 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5672 let control_handle = BaseDatagramSocketControlHandle {
5673 inner: this.inner.clone(),
5674 };
5675 Ok(BaseDatagramSocketRequest::GetTimestamp {
5676 responder: BaseDatagramSocketGetTimestampResponder {
5677 control_handle: std::mem::ManuallyDrop::new(control_handle),
5678 tx_id: header.tx_id,
5679 },
5680 })
5681 }
5682 0x6ead6de09f653236 => {
5683 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5684 let mut req = fidl::new_empty!(BaseSocketSetMarkRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5685 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
5686 let control_handle = BaseDatagramSocketControlHandle {
5687 inner: this.inner.clone(),
5688 };
5689 Ok(BaseDatagramSocketRequest::SetMark {domain: req.domain,
5690mark: req.mark,
5691
5692 responder: BaseDatagramSocketSetMarkResponder {
5693 control_handle: std::mem::ManuallyDrop::new(control_handle),
5694 tx_id: header.tx_id,
5695 },
5696 })
5697 }
5698 0x57a2752c61d93d47 => {
5699 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5700 let mut req = fidl::new_empty!(BaseSocketGetMarkRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5701 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
5702 let control_handle = BaseDatagramSocketControlHandle {
5703 inner: this.inner.clone(),
5704 };
5705 Ok(BaseDatagramSocketRequest::GetMark {domain: req.domain,
5706
5707 responder: BaseDatagramSocketGetMarkResponder {
5708 control_handle: std::mem::ManuallyDrop::new(control_handle),
5709 tx_id: header.tx_id,
5710 },
5711 })
5712 }
5713 0x4bc6400ae92125d => {
5714 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5715 let mut req = fidl::new_empty!(BaseNetworkSocketBindRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5716 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
5717 let control_handle = BaseDatagramSocketControlHandle {
5718 inner: this.inner.clone(),
5719 };
5720 Ok(BaseDatagramSocketRequest::Bind {addr: req.addr,
5721
5722 responder: BaseDatagramSocketBindResponder {
5723 control_handle: std::mem::ManuallyDrop::new(control_handle),
5724 tx_id: header.tx_id,
5725 },
5726 })
5727 }
5728 0x5f05f19bfdd38871 => {
5729 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5730 let mut req = fidl::new_empty!(BaseNetworkSocketConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5731 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
5732 let control_handle = BaseDatagramSocketControlHandle {
5733 inner: this.inner.clone(),
5734 };
5735 Ok(BaseDatagramSocketRequest::Connect {addr: req.addr,
5736
5737 responder: BaseDatagramSocketConnectResponder {
5738 control_handle: std::mem::ManuallyDrop::new(control_handle),
5739 tx_id: header.tx_id,
5740 },
5741 })
5742 }
5743 0x74e63b91f7b29b2 => {
5744 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5745 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5746 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5747 let control_handle = BaseDatagramSocketControlHandle {
5748 inner: this.inner.clone(),
5749 };
5750 Ok(BaseDatagramSocketRequest::Disconnect {
5751 responder: BaseDatagramSocketDisconnectResponder {
5752 control_handle: std::mem::ManuallyDrop::new(control_handle),
5753 tx_id: header.tx_id,
5754 },
5755 })
5756 }
5757 0x475f23f84a1a4f85 => {
5758 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5759 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5760 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5761 let control_handle = BaseDatagramSocketControlHandle {
5762 inner: this.inner.clone(),
5763 };
5764 Ok(BaseDatagramSocketRequest::GetSockName {
5765 responder: BaseDatagramSocketGetSockNameResponder {
5766 control_handle: std::mem::ManuallyDrop::new(control_handle),
5767 tx_id: header.tx_id,
5768 },
5769 })
5770 }
5771 0x1ffecf4bd5b6432e => {
5772 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5773 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5774 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5775 let control_handle = BaseDatagramSocketControlHandle {
5776 inner: this.inner.clone(),
5777 };
5778 Ok(BaseDatagramSocketRequest::GetPeerName {
5779 responder: BaseDatagramSocketGetPeerNameResponder {
5780 control_handle: std::mem::ManuallyDrop::new(control_handle),
5781 tx_id: header.tx_id,
5782 },
5783 })
5784 }
5785 0x247f38b6db68c336 => {
5786 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5787 let mut req = fidl::new_empty!(BaseNetworkSocketShutdownRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5788 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketShutdownRequest>(&header, _body_bytes, handles, &mut req)?;
5789 let control_handle = BaseDatagramSocketControlHandle {
5790 inner: this.inner.clone(),
5791 };
5792 Ok(BaseDatagramSocketRequest::Shutdown {mode: req.mode,
5793
5794 responder: BaseDatagramSocketShutdownResponder {
5795 control_handle: std::mem::ManuallyDrop::new(control_handle),
5796 tx_id: header.tx_id,
5797 },
5798 })
5799 }
5800 0x995c600475b6d46 => {
5801 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5802 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTypeOfServiceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5803 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
5804 let control_handle = BaseDatagramSocketControlHandle {
5805 inner: this.inner.clone(),
5806 };
5807 Ok(BaseDatagramSocketRequest::SetIpTypeOfService {value: req.value,
5808
5809 responder: BaseDatagramSocketSetIpTypeOfServiceResponder {
5810 control_handle: std::mem::ManuallyDrop::new(control_handle),
5811 tx_id: header.tx_id,
5812 },
5813 })
5814 }
5815 0x3814a04259f75fcb => {
5816 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5817 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5818 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5819 let control_handle = BaseDatagramSocketControlHandle {
5820 inner: this.inner.clone(),
5821 };
5822 Ok(BaseDatagramSocketRequest::GetIpTypeOfService {
5823 responder: BaseDatagramSocketGetIpTypeOfServiceResponder {
5824 control_handle: std::mem::ManuallyDrop::new(control_handle),
5825 tx_id: header.tx_id,
5826 },
5827 })
5828 }
5829 0x29e2424b433ae1ef => {
5830 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5831 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5832 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTtlRequest>(&header, _body_bytes, handles, &mut req)?;
5833 let control_handle = BaseDatagramSocketControlHandle {
5834 inner: this.inner.clone(),
5835 };
5836 Ok(BaseDatagramSocketRequest::SetIpTtl {value: req.value,
5837
5838 responder: BaseDatagramSocketSetIpTtlResponder {
5839 control_handle: std::mem::ManuallyDrop::new(control_handle),
5840 tx_id: header.tx_id,
5841 },
5842 })
5843 }
5844 0x47e47fa1f24da471 => {
5845 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5846 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5847 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5848 let control_handle = BaseDatagramSocketControlHandle {
5849 inner: this.inner.clone(),
5850 };
5851 Ok(BaseDatagramSocketRequest::GetIpTtl {
5852 responder: BaseDatagramSocketGetIpTtlResponder {
5853 control_handle: std::mem::ManuallyDrop::new(control_handle),
5854 tx_id: header.tx_id,
5855 },
5856 })
5857 }
5858 0x392d16bee20c0e16 => {
5859 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5860 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5861 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpPacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
5862 let control_handle = BaseDatagramSocketControlHandle {
5863 inner: this.inner.clone(),
5864 };
5865 Ok(BaseDatagramSocketRequest::SetIpPacketInfo {value: req.value,
5866
5867 responder: BaseDatagramSocketSetIpPacketInfoResponder {
5868 control_handle: std::mem::ManuallyDrop::new(control_handle),
5869 tx_id: header.tx_id,
5870 },
5871 })
5872 }
5873 0x54b505f242280740 => {
5874 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5875 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5876 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5877 let control_handle = BaseDatagramSocketControlHandle {
5878 inner: this.inner.clone(),
5879 };
5880 Ok(BaseDatagramSocketRequest::GetIpPacketInfo {
5881 responder: BaseDatagramSocketGetIpPacketInfoResponder {
5882 control_handle: std::mem::ManuallyDrop::new(control_handle),
5883 tx_id: header.tx_id,
5884 },
5885 })
5886 }
5887 0x6c4f6714995f84ef => {
5888 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5889 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveTypeOfServiceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5890 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
5891 let control_handle = BaseDatagramSocketControlHandle {
5892 inner: this.inner.clone(),
5893 };
5894 Ok(BaseDatagramSocketRequest::SetIpReceiveTypeOfService {value: req.value,
5895
5896 responder: BaseDatagramSocketSetIpReceiveTypeOfServiceResponder {
5897 control_handle: std::mem::ManuallyDrop::new(control_handle),
5898 tx_id: header.tx_id,
5899 },
5900 })
5901 }
5902 0x4158ba7dc2795960 => {
5903 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5904 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5905 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5906 let control_handle = BaseDatagramSocketControlHandle {
5907 inner: this.inner.clone(),
5908 };
5909 Ok(BaseDatagramSocketRequest::GetIpReceiveTypeOfService {
5910 responder: BaseDatagramSocketGetIpReceiveTypeOfServiceResponder {
5911 control_handle: std::mem::ManuallyDrop::new(control_handle),
5912 tx_id: header.tx_id,
5913 },
5914 })
5915 }
5916 0x46f15be0ce0ab82b => {
5917 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5918 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5919 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTtlRequest>(&header, _body_bytes, handles, &mut req)?;
5920 let control_handle = BaseDatagramSocketControlHandle {
5921 inner: this.inner.clone(),
5922 };
5923 Ok(BaseDatagramSocketRequest::SetIpReceiveTtl {value: req.value,
5924
5925 responder: BaseDatagramSocketSetIpReceiveTtlResponder {
5926 control_handle: std::mem::ManuallyDrop::new(control_handle),
5927 tx_id: header.tx_id,
5928 },
5929 })
5930 }
5931 0x678ddd5a5dfa2eb5 => {
5932 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5933 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5934 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5935 let control_handle = BaseDatagramSocketControlHandle {
5936 inner: this.inner.clone(),
5937 };
5938 Ok(BaseDatagramSocketRequest::GetIpReceiveTtl {
5939 responder: BaseDatagramSocketGetIpReceiveTtlResponder {
5940 control_handle: std::mem::ManuallyDrop::new(control_handle),
5941 tx_id: header.tx_id,
5942 },
5943 })
5944 }
5945 0x752fbfa9b12befe => {
5946 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5947 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastInterfaceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5948 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
5949 let control_handle = BaseDatagramSocketControlHandle {
5950 inner: this.inner.clone(),
5951 };
5952 Ok(BaseDatagramSocketRequest::SetIpMulticastInterface {iface: req.iface,
5953address: req.address,
5954
5955 responder: BaseDatagramSocketSetIpMulticastInterfaceResponder {
5956 control_handle: std::mem::ManuallyDrop::new(control_handle),
5957 tx_id: header.tx_id,
5958 },
5959 })
5960 }
5961 0x320bd14c4df046c4 => {
5962 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5963 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5964 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5965 let control_handle = BaseDatagramSocketControlHandle {
5966 inner: this.inner.clone(),
5967 };
5968 Ok(BaseDatagramSocketRequest::GetIpMulticastInterface {
5969 responder: BaseDatagramSocketGetIpMulticastInterfaceResponder {
5970 control_handle: std::mem::ManuallyDrop::new(control_handle),
5971 tx_id: header.tx_id,
5972 },
5973 })
5974 }
5975 0x63134d53772916a1 => {
5976 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5977 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5978 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastTtlRequest>(&header, _body_bytes, handles, &mut req)?;
5979 let control_handle = BaseDatagramSocketControlHandle {
5980 inner: this.inner.clone(),
5981 };
5982 Ok(BaseDatagramSocketRequest::SetIpMulticastTtl {value: req.value,
5983
5984 responder: BaseDatagramSocketSetIpMulticastTtlResponder {
5985 control_handle: std::mem::ManuallyDrop::new(control_handle),
5986 tx_id: header.tx_id,
5987 },
5988 })
5989 }
5990 0x4665cd378f39e1a => {
5991 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5992 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5993 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5994 let control_handle = BaseDatagramSocketControlHandle {
5995 inner: this.inner.clone(),
5996 };
5997 Ok(BaseDatagramSocketRequest::GetIpMulticastTtl {
5998 responder: BaseDatagramSocketGetIpMulticastTtlResponder {
5999 control_handle: std::mem::ManuallyDrop::new(control_handle),
6000 tx_id: header.tx_id,
6001 },
6002 })
6003 }
6004 0x20c55c11f00943ea => {
6005 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6006 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastLoopbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6007 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
6008 let control_handle = BaseDatagramSocketControlHandle {
6009 inner: this.inner.clone(),
6010 };
6011 Ok(BaseDatagramSocketRequest::SetIpMulticastLoopback {value: req.value,
6012
6013 responder: BaseDatagramSocketSetIpMulticastLoopbackResponder {
6014 control_handle: std::mem::ManuallyDrop::new(control_handle),
6015 tx_id: header.tx_id,
6016 },
6017 })
6018 }
6019 0x3b6b26ff558298f2 => {
6020 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6021 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6022 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6023 let control_handle = BaseDatagramSocketControlHandle {
6024 inner: this.inner.clone(),
6025 };
6026 Ok(BaseDatagramSocketRequest::GetIpMulticastLoopback {
6027 responder: BaseDatagramSocketGetIpMulticastLoopbackResponder {
6028 control_handle: std::mem::ManuallyDrop::new(control_handle),
6029 tx_id: header.tx_id,
6030 },
6031 })
6032 }
6033 0x76bc7df115a3b4d0 => {
6034 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6035 let mut req = fidl::new_empty!(BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6036 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
6037 let control_handle = BaseDatagramSocketControlHandle {
6038 inner: this.inner.clone(),
6039 };
6040 Ok(BaseDatagramSocketRequest::AddIpMembership {membership: req.membership,
6041
6042 responder: BaseDatagramSocketAddIpMembershipResponder {
6043 control_handle: std::mem::ManuallyDrop::new(control_handle),
6044 tx_id: header.tx_id,
6045 },
6046 })
6047 }
6048 0x2888f3099188d03 => {
6049 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6050 let mut req = fidl::new_empty!(BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6051 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
6052 let control_handle = BaseDatagramSocketControlHandle {
6053 inner: this.inner.clone(),
6054 };
6055 Ok(BaseDatagramSocketRequest::DropIpMembership {membership: req.membership,
6056
6057 responder: BaseDatagramSocketDropIpMembershipResponder {
6058 control_handle: std::mem::ManuallyDrop::new(control_handle),
6059 tx_id: header.tx_id,
6060 },
6061 })
6062 }
6063 0x1ae532b0c066e3a0 => {
6064 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6065 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6066 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTransparentRequest>(&header, _body_bytes, handles, &mut req)?;
6067 let control_handle = BaseDatagramSocketControlHandle {
6068 inner: this.inner.clone(),
6069 };
6070 Ok(BaseDatagramSocketRequest::SetIpTransparent {value: req.value,
6071
6072 responder: BaseDatagramSocketSetIpTransparentResponder {
6073 control_handle: std::mem::ManuallyDrop::new(control_handle),
6074 tx_id: header.tx_id,
6075 },
6076 })
6077 }
6078 0x51d43695962ebfb5 => {
6079 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6080 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6081 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6082 let control_handle = BaseDatagramSocketControlHandle {
6083 inner: this.inner.clone(),
6084 };
6085 Ok(BaseDatagramSocketRequest::GetIpTransparent {
6086 responder: BaseDatagramSocketGetIpTransparentResponder {
6087 control_handle: std::mem::ManuallyDrop::new(control_handle),
6088 tx_id: header.tx_id,
6089 },
6090 })
6091 }
6092 0x4722b4ce52f7840 => {
6093 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6094 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6095 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest>(&header, _body_bytes, handles, &mut req)?;
6096 let control_handle = BaseDatagramSocketControlHandle {
6097 inner: this.inner.clone(),
6098 };
6099 Ok(BaseDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress {value: req.value,
6100
6101 responder: BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
6102 control_handle: std::mem::ManuallyDrop::new(control_handle),
6103 tx_id: header.tx_id,
6104 },
6105 })
6106 }
6107 0x2a0e7dc5d6bfdfe9 => {
6108 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6109 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6110 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6111 let control_handle = BaseDatagramSocketControlHandle {
6112 inner: this.inner.clone(),
6113 };
6114 Ok(BaseDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress {
6115 responder: BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
6116 control_handle: std::mem::ManuallyDrop::new(control_handle),
6117 tx_id: header.tx_id,
6118 },
6119 })
6120 }
6121 0x7c94727acb4ea4b3 => {
6122 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6123 let mut req = fidl::new_empty!(BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6124 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
6125 let control_handle = BaseDatagramSocketControlHandle {
6126 inner: this.inner.clone(),
6127 };
6128 Ok(BaseDatagramSocketRequest::AddIpv6Membership {membership: req.membership,
6129
6130 responder: BaseDatagramSocketAddIpv6MembershipResponder {
6131 control_handle: std::mem::ManuallyDrop::new(control_handle),
6132 tx_id: header.tx_id,
6133 },
6134 })
6135 }
6136 0x42104c70ccaba304 => {
6137 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6138 let mut req = fidl::new_empty!(BaseNetworkSocketDropIpv6MembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6139 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
6140 let control_handle = BaseDatagramSocketControlHandle {
6141 inner: this.inner.clone(),
6142 };
6143 Ok(BaseDatagramSocketRequest::DropIpv6Membership {membership: req.membership,
6144
6145 responder: BaseDatagramSocketDropIpv6MembershipResponder {
6146 control_handle: std::mem::ManuallyDrop::new(control_handle),
6147 tx_id: header.tx_id,
6148 },
6149 })
6150 }
6151 0x135f76db3774ab3b => {
6152 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6153 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastInterfaceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6154 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
6155 let control_handle = BaseDatagramSocketControlHandle {
6156 inner: this.inner.clone(),
6157 };
6158 Ok(BaseDatagramSocketRequest::SetIpv6MulticastInterface {value: req.value,
6159
6160 responder: BaseDatagramSocketSetIpv6MulticastInterfaceResponder {
6161 control_handle: std::mem::ManuallyDrop::new(control_handle),
6162 tx_id: header.tx_id,
6163 },
6164 })
6165 }
6166 0x1f26fcdd348f1882 => {
6167 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6168 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6169 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6170 let control_handle = BaseDatagramSocketControlHandle {
6171 inner: this.inner.clone(),
6172 };
6173 Ok(BaseDatagramSocketRequest::GetIpv6MulticastInterface {
6174 responder: BaseDatagramSocketGetIpv6MulticastInterfaceResponder {
6175 control_handle: std::mem::ManuallyDrop::new(control_handle),
6176 tx_id: header.tx_id,
6177 },
6178 })
6179 }
6180 0x157d51e98f462859 => {
6181 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6182 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6UnicastHopsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6183 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6UnicastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
6184 let control_handle = BaseDatagramSocketControlHandle {
6185 inner: this.inner.clone(),
6186 };
6187 Ok(BaseDatagramSocketRequest::SetIpv6UnicastHops {value: req.value,
6188
6189 responder: BaseDatagramSocketSetIpv6UnicastHopsResponder {
6190 control_handle: std::mem::ManuallyDrop::new(control_handle),
6191 tx_id: header.tx_id,
6192 },
6193 })
6194 }
6195 0x21f4641cad8bd8d2 => {
6196 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6197 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6198 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6199 let control_handle = BaseDatagramSocketControlHandle {
6200 inner: this.inner.clone(),
6201 };
6202 Ok(BaseDatagramSocketRequest::GetIpv6UnicastHops {
6203 responder: BaseDatagramSocketGetIpv6UnicastHopsResponder {
6204 control_handle: std::mem::ManuallyDrop::new(control_handle),
6205 tx_id: header.tx_id,
6206 },
6207 })
6208 }
6209 0x5c24808ed2e84a1e => {
6210 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6211 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceiveHopLimitRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6212 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveHopLimitRequest>(&header, _body_bytes, handles, &mut req)?;
6213 let control_handle = BaseDatagramSocketControlHandle {
6214 inner: this.inner.clone(),
6215 };
6216 Ok(BaseDatagramSocketRequest::SetIpv6ReceiveHopLimit {value: req.value,
6217
6218 responder: BaseDatagramSocketSetIpv6ReceiveHopLimitResponder {
6219 control_handle: std::mem::ManuallyDrop::new(control_handle),
6220 tx_id: header.tx_id,
6221 },
6222 })
6223 }
6224 0x341e06689885b4c0 => {
6225 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6226 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6227 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6228 let control_handle = BaseDatagramSocketControlHandle {
6229 inner: this.inner.clone(),
6230 };
6231 Ok(BaseDatagramSocketRequest::GetIpv6ReceiveHopLimit {
6232 responder: BaseDatagramSocketGetIpv6ReceiveHopLimitResponder {
6233 control_handle: std::mem::ManuallyDrop::new(control_handle),
6234 tx_id: header.tx_id,
6235 },
6236 })
6237 }
6238 0x25b9cd4d181f82c1 => {
6239 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6240 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastHopsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6241 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
6242 let control_handle = BaseDatagramSocketControlHandle {
6243 inner: this.inner.clone(),
6244 };
6245 Ok(BaseDatagramSocketRequest::SetIpv6MulticastHops {value: req.value,
6246
6247 responder: BaseDatagramSocketSetIpv6MulticastHopsResponder {
6248 control_handle: std::mem::ManuallyDrop::new(control_handle),
6249 tx_id: header.tx_id,
6250 },
6251 })
6252 }
6253 0x52916948a365012a => {
6254 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6255 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6256 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6257 let control_handle = BaseDatagramSocketControlHandle {
6258 inner: this.inner.clone(),
6259 };
6260 Ok(BaseDatagramSocketRequest::GetIpv6MulticastHops {
6261 responder: BaseDatagramSocketGetIpv6MulticastHopsResponder {
6262 control_handle: std::mem::ManuallyDrop::new(control_handle),
6263 tx_id: header.tx_id,
6264 },
6265 })
6266 }
6267 0x55701c409ff41b40 => {
6268 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6269 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastLoopbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6270 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
6271 let control_handle = BaseDatagramSocketControlHandle {
6272 inner: this.inner.clone(),
6273 };
6274 Ok(BaseDatagramSocketRequest::SetIpv6MulticastLoopback {value: req.value,
6275
6276 responder: BaseDatagramSocketSetIpv6MulticastLoopbackResponder {
6277 control_handle: std::mem::ManuallyDrop::new(control_handle),
6278 tx_id: header.tx_id,
6279 },
6280 })
6281 }
6282 0x4415b701fde319c3 => {
6283 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6284 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6285 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6286 let control_handle = BaseDatagramSocketControlHandle {
6287 inner: this.inner.clone(),
6288 };
6289 Ok(BaseDatagramSocketRequest::GetIpv6MulticastLoopback {
6290 responder: BaseDatagramSocketGetIpv6MulticastLoopbackResponder {
6291 control_handle: std::mem::ManuallyDrop::new(control_handle),
6292 tx_id: header.tx_id,
6293 },
6294 })
6295 }
6296 0x4873f1364758cbba => {
6297 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6298 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6299 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6OnlyRequest>(&header, _body_bytes, handles, &mut req)?;
6300 let control_handle = BaseDatagramSocketControlHandle {
6301 inner: this.inner.clone(),
6302 };
6303 Ok(BaseDatagramSocketRequest::SetIpv6Only {value: req.value,
6304
6305 responder: BaseDatagramSocketSetIpv6OnlyResponder {
6306 control_handle: std::mem::ManuallyDrop::new(control_handle),
6307 tx_id: header.tx_id,
6308 },
6309 })
6310 }
6311 0x4aa3340a1a26b89c => {
6312 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6313 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6314 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6315 let control_handle = BaseDatagramSocketControlHandle {
6316 inner: this.inner.clone(),
6317 };
6318 Ok(BaseDatagramSocketRequest::GetIpv6Only {
6319 responder: BaseDatagramSocketGetIpv6OnlyResponder {
6320 control_handle: std::mem::ManuallyDrop::new(control_handle),
6321 tx_id: header.tx_id,
6322 },
6323 })
6324 }
6325 0x58f07c8788d099a0 => {
6326 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6327 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6328 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
6329 let control_handle = BaseDatagramSocketControlHandle {
6330 inner: this.inner.clone(),
6331 };
6332 Ok(BaseDatagramSocketRequest::SetIpv6ReceiveTrafficClass {value: req.value,
6333
6334 responder: BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder {
6335 control_handle: std::mem::ManuallyDrop::new(control_handle),
6336 tx_id: header.tx_id,
6337 },
6338 })
6339 }
6340 0x2e334df1da553ffa => {
6341 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6342 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6343 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6344 let control_handle = BaseDatagramSocketControlHandle {
6345 inner: this.inner.clone(),
6346 };
6347 Ok(BaseDatagramSocketRequest::GetIpv6ReceiveTrafficClass {
6348 responder: BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder {
6349 control_handle: std::mem::ManuallyDrop::new(control_handle),
6350 tx_id: header.tx_id,
6351 },
6352 })
6353 }
6354 0x6af077800c5a0b4f => {
6355 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6356 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6TrafficClassRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6357 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6TrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
6358 let control_handle = BaseDatagramSocketControlHandle {
6359 inner: this.inner.clone(),
6360 };
6361 Ok(BaseDatagramSocketRequest::SetIpv6TrafficClass {value: req.value,
6362
6363 responder: BaseDatagramSocketSetIpv6TrafficClassResponder {
6364 control_handle: std::mem::ManuallyDrop::new(control_handle),
6365 tx_id: header.tx_id,
6366 },
6367 })
6368 }
6369 0x6baf6eed8fc2f04 => {
6370 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6371 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6372 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6373 let control_handle = BaseDatagramSocketControlHandle {
6374 inner: this.inner.clone(),
6375 };
6376 Ok(BaseDatagramSocketRequest::GetIpv6TrafficClass {
6377 responder: BaseDatagramSocketGetIpv6TrafficClassResponder {
6378 control_handle: std::mem::ManuallyDrop::new(control_handle),
6379 tx_id: header.tx_id,
6380 },
6381 })
6382 }
6383 0x19259775b1a92768 => {
6384 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6385 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceivePacketInfoRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6386 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceivePacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
6387 let control_handle = BaseDatagramSocketControlHandle {
6388 inner: this.inner.clone(),
6389 };
6390 Ok(BaseDatagramSocketRequest::SetIpv6ReceivePacketInfo {value: req.value,
6391
6392 responder: BaseDatagramSocketSetIpv6ReceivePacketInfoResponder {
6393 control_handle: std::mem::ManuallyDrop::new(control_handle),
6394 tx_id: header.tx_id,
6395 },
6396 })
6397 }
6398 0x7acd4a2775baec75 => {
6399 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6400 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6401 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6402 let control_handle = BaseDatagramSocketControlHandle {
6403 inner: this.inner.clone(),
6404 };
6405 Ok(BaseDatagramSocketRequest::GetIpv6ReceivePacketInfo {
6406 responder: BaseDatagramSocketGetIpv6ReceivePacketInfoResponder {
6407 control_handle: std::mem::ManuallyDrop::new(control_handle),
6408 tx_id: header.tx_id,
6409 },
6410 })
6411 }
6412 0x38bf28f0dafdbac0 => {
6413 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6414 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6415 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6416 let control_handle = BaseDatagramSocketControlHandle {
6417 inner: this.inner.clone(),
6418 };
6419 Ok(BaseDatagramSocketRequest::GetOriginalDestination {
6420 responder: BaseDatagramSocketGetOriginalDestinationResponder {
6421 control_handle: std::mem::ManuallyDrop::new(control_handle),
6422 tx_id: header.tx_id,
6423 },
6424 })
6425 }
6426 0x48aa0a1f6a32d2ed => {
6427 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6428 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6429 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6430 let control_handle = BaseDatagramSocketControlHandle {
6431 inner: this.inner.clone(),
6432 };
6433 Ok(BaseDatagramSocketRequest::GetInfo {
6434 responder: BaseDatagramSocketGetInfoResponder {
6435 control_handle: std::mem::ManuallyDrop::new(control_handle),
6436 tx_id: header.tx_id,
6437 },
6438 })
6439 }
6440 _ => Err(fidl::Error::UnknownOrdinal {
6441 ordinal: header.ordinal,
6442 protocol_name: <BaseDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
6443 }),
6444 }))
6445 },
6446 )
6447 }
6448}
6449
6450#[derive(Debug)]
6454pub enum BaseDatagramSocketRequest {
6455 Clone {
6456 request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
6457 control_handle: BaseDatagramSocketControlHandle,
6458 },
6459 Close {
6470 responder: BaseDatagramSocketCloseResponder,
6471 },
6472 Query {
6473 responder: BaseDatagramSocketQueryResponder,
6474 },
6475 SetReuseAddress {
6477 value: bool,
6478 responder: BaseDatagramSocketSetReuseAddressResponder,
6479 },
6480 GetReuseAddress {
6482 responder: BaseDatagramSocketGetReuseAddressResponder,
6483 },
6484 GetError {
6487 responder: BaseDatagramSocketGetErrorResponder,
6488 },
6489 SetBroadcast {
6491 value: bool,
6492 responder: BaseDatagramSocketSetBroadcastResponder,
6493 },
6494 GetBroadcast {
6496 responder: BaseDatagramSocketGetBroadcastResponder,
6497 },
6498 SetSendBuffer {
6500 value_bytes: u64,
6501 responder: BaseDatagramSocketSetSendBufferResponder,
6502 },
6503 GetSendBuffer {
6505 responder: BaseDatagramSocketGetSendBufferResponder,
6506 },
6507 SetReceiveBuffer {
6509 value_bytes: u64,
6510 responder: BaseDatagramSocketSetReceiveBufferResponder,
6511 },
6512 GetReceiveBuffer {
6514 responder: BaseDatagramSocketGetReceiveBufferResponder,
6515 },
6516 SetKeepAlive {
6518 value: bool,
6519 responder: BaseDatagramSocketSetKeepAliveResponder,
6520 },
6521 GetKeepAlive {
6523 responder: BaseDatagramSocketGetKeepAliveResponder,
6524 },
6525 SetOutOfBandInline {
6527 value: bool,
6528 responder: BaseDatagramSocketSetOutOfBandInlineResponder,
6529 },
6530 GetOutOfBandInline {
6532 responder: BaseDatagramSocketGetOutOfBandInlineResponder,
6533 },
6534 SetNoCheck {
6536 value: bool,
6537 responder: BaseDatagramSocketSetNoCheckResponder,
6538 },
6539 GetNoCheck {
6541 responder: BaseDatagramSocketGetNoCheckResponder,
6542 },
6543 SetLinger {
6545 linger: bool,
6546 length_secs: u32,
6547 responder: BaseDatagramSocketSetLingerResponder,
6548 },
6549 GetLinger {
6551 responder: BaseDatagramSocketGetLingerResponder,
6552 },
6553 SetReusePort {
6555 value: bool,
6556 responder: BaseDatagramSocketSetReusePortResponder,
6557 },
6558 GetReusePort {
6560 responder: BaseDatagramSocketGetReusePortResponder,
6561 },
6562 GetAcceptConn {
6564 responder: BaseDatagramSocketGetAcceptConnResponder,
6565 },
6566 SetBindToDevice {
6568 value: String,
6569 responder: BaseDatagramSocketSetBindToDeviceResponder,
6570 },
6571 GetBindToDevice {
6573 responder: BaseDatagramSocketGetBindToDeviceResponder,
6574 },
6575 SetBindToInterfaceIndex {
6578 value: u64,
6579 responder: BaseDatagramSocketSetBindToInterfaceIndexResponder,
6580 },
6581 GetBindToInterfaceIndex {
6583 responder: BaseDatagramSocketGetBindToInterfaceIndexResponder,
6584 },
6585 SetTimestamp {
6587 value: TimestampOption,
6588 responder: BaseDatagramSocketSetTimestampResponder,
6589 },
6590 GetTimestamp {
6592 responder: BaseDatagramSocketGetTimestampResponder,
6593 },
6594 SetMark {
6598 domain: fidl_fuchsia_net::MarkDomain,
6599 mark: OptionalUint32,
6600 responder: BaseDatagramSocketSetMarkResponder,
6601 },
6602 GetMark {
6606 domain: fidl_fuchsia_net::MarkDomain,
6607 responder: BaseDatagramSocketGetMarkResponder,
6608 },
6609 Bind {
6611 addr: fidl_fuchsia_net::SocketAddress,
6612 responder: BaseDatagramSocketBindResponder,
6613 },
6614 Connect {
6616 addr: fidl_fuchsia_net::SocketAddress,
6617 responder: BaseDatagramSocketConnectResponder,
6618 },
6619 Disconnect {
6621 responder: BaseDatagramSocketDisconnectResponder,
6622 },
6623 GetSockName {
6625 responder: BaseDatagramSocketGetSockNameResponder,
6626 },
6627 GetPeerName {
6629 responder: BaseDatagramSocketGetPeerNameResponder,
6630 },
6631 Shutdown {
6633 mode: ShutdownMode,
6634 responder: BaseDatagramSocketShutdownResponder,
6635 },
6636 SetIpTypeOfService {
6638 value: u8,
6639 responder: BaseDatagramSocketSetIpTypeOfServiceResponder,
6640 },
6641 GetIpTypeOfService {
6643 responder: BaseDatagramSocketGetIpTypeOfServiceResponder,
6644 },
6645 SetIpTtl {
6647 value: OptionalUint8,
6648 responder: BaseDatagramSocketSetIpTtlResponder,
6649 },
6650 GetIpTtl {
6652 responder: BaseDatagramSocketGetIpTtlResponder,
6653 },
6654 SetIpPacketInfo {
6656 value: bool,
6657 responder: BaseDatagramSocketSetIpPacketInfoResponder,
6658 },
6659 GetIpPacketInfo {
6661 responder: BaseDatagramSocketGetIpPacketInfoResponder,
6662 },
6663 SetIpReceiveTypeOfService {
6665 value: bool,
6666 responder: BaseDatagramSocketSetIpReceiveTypeOfServiceResponder,
6667 },
6668 GetIpReceiveTypeOfService {
6670 responder: BaseDatagramSocketGetIpReceiveTypeOfServiceResponder,
6671 },
6672 SetIpReceiveTtl {
6674 value: bool,
6675 responder: BaseDatagramSocketSetIpReceiveTtlResponder,
6676 },
6677 GetIpReceiveTtl {
6679 responder: BaseDatagramSocketGetIpReceiveTtlResponder,
6680 },
6681 SetIpMulticastInterface {
6683 iface: u64,
6684 address: fidl_fuchsia_net::Ipv4Address,
6685 responder: BaseDatagramSocketSetIpMulticastInterfaceResponder,
6686 },
6687 GetIpMulticastInterface {
6689 responder: BaseDatagramSocketGetIpMulticastInterfaceResponder,
6690 },
6691 SetIpMulticastTtl {
6693 value: OptionalUint8,
6694 responder: BaseDatagramSocketSetIpMulticastTtlResponder,
6695 },
6696 GetIpMulticastTtl {
6698 responder: BaseDatagramSocketGetIpMulticastTtlResponder,
6699 },
6700 SetIpMulticastLoopback {
6702 value: bool,
6703 responder: BaseDatagramSocketSetIpMulticastLoopbackResponder,
6704 },
6705 GetIpMulticastLoopback {
6707 responder: BaseDatagramSocketGetIpMulticastLoopbackResponder,
6708 },
6709 AddIpMembership {
6711 membership: IpMulticastMembership,
6712 responder: BaseDatagramSocketAddIpMembershipResponder,
6713 },
6714 DropIpMembership {
6716 membership: IpMulticastMembership,
6717 responder: BaseDatagramSocketDropIpMembershipResponder,
6718 },
6719 SetIpTransparent {
6721 value: bool,
6722 responder: BaseDatagramSocketSetIpTransparentResponder,
6723 },
6724 GetIpTransparent {
6726 responder: BaseDatagramSocketGetIpTransparentResponder,
6727 },
6728 SetIpReceiveOriginalDestinationAddress {
6730 value: bool,
6731 responder: BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder,
6732 },
6733 GetIpReceiveOriginalDestinationAddress {
6735 responder: BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder,
6736 },
6737 AddIpv6Membership {
6739 membership: Ipv6MulticastMembership,
6740 responder: BaseDatagramSocketAddIpv6MembershipResponder,
6741 },
6742 DropIpv6Membership {
6744 membership: Ipv6MulticastMembership,
6745 responder: BaseDatagramSocketDropIpv6MembershipResponder,
6746 },
6747 SetIpv6MulticastInterface {
6749 value: u64,
6750 responder: BaseDatagramSocketSetIpv6MulticastInterfaceResponder,
6751 },
6752 GetIpv6MulticastInterface {
6754 responder: BaseDatagramSocketGetIpv6MulticastInterfaceResponder,
6755 },
6756 SetIpv6UnicastHops {
6758 value: OptionalUint8,
6759 responder: BaseDatagramSocketSetIpv6UnicastHopsResponder,
6760 },
6761 GetIpv6UnicastHops {
6763 responder: BaseDatagramSocketGetIpv6UnicastHopsResponder,
6764 },
6765 SetIpv6ReceiveHopLimit {
6767 value: bool,
6768 responder: BaseDatagramSocketSetIpv6ReceiveHopLimitResponder,
6769 },
6770 GetIpv6ReceiveHopLimit {
6772 responder: BaseDatagramSocketGetIpv6ReceiveHopLimitResponder,
6773 },
6774 SetIpv6MulticastHops {
6776 value: OptionalUint8,
6777 responder: BaseDatagramSocketSetIpv6MulticastHopsResponder,
6778 },
6779 GetIpv6MulticastHops {
6781 responder: BaseDatagramSocketGetIpv6MulticastHopsResponder,
6782 },
6783 SetIpv6MulticastLoopback {
6785 value: bool,
6786 responder: BaseDatagramSocketSetIpv6MulticastLoopbackResponder,
6787 },
6788 GetIpv6MulticastLoopback {
6790 responder: BaseDatagramSocketGetIpv6MulticastLoopbackResponder,
6791 },
6792 SetIpv6Only {
6794 value: bool,
6795 responder: BaseDatagramSocketSetIpv6OnlyResponder,
6796 },
6797 GetIpv6Only {
6799 responder: BaseDatagramSocketGetIpv6OnlyResponder,
6800 },
6801 SetIpv6ReceiveTrafficClass {
6803 value: bool,
6804 responder: BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder,
6805 },
6806 GetIpv6ReceiveTrafficClass {
6808 responder: BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder,
6809 },
6810 SetIpv6TrafficClass {
6812 value: OptionalUint8,
6813 responder: BaseDatagramSocketSetIpv6TrafficClassResponder,
6814 },
6815 GetIpv6TrafficClass {
6817 responder: BaseDatagramSocketGetIpv6TrafficClassResponder,
6818 },
6819 SetIpv6ReceivePacketInfo {
6821 value: bool,
6822 responder: BaseDatagramSocketSetIpv6ReceivePacketInfoResponder,
6823 },
6824 GetIpv6ReceivePacketInfo {
6826 responder: BaseDatagramSocketGetIpv6ReceivePacketInfoResponder,
6827 },
6828 GetOriginalDestination {
6830 responder: BaseDatagramSocketGetOriginalDestinationResponder,
6831 },
6832 GetInfo {
6837 responder: BaseDatagramSocketGetInfoResponder,
6838 },
6839}
6840
6841impl BaseDatagramSocketRequest {
6842 #[allow(irrefutable_let_patterns)]
6843 pub fn into_clone(
6844 self,
6845 ) -> Option<(
6846 fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
6847 BaseDatagramSocketControlHandle,
6848 )> {
6849 if let BaseDatagramSocketRequest::Clone { request, control_handle } = self {
6850 Some((request, control_handle))
6851 } else {
6852 None
6853 }
6854 }
6855
6856 #[allow(irrefutable_let_patterns)]
6857 pub fn into_close(self) -> Option<(BaseDatagramSocketCloseResponder)> {
6858 if let BaseDatagramSocketRequest::Close { responder } = self {
6859 Some((responder))
6860 } else {
6861 None
6862 }
6863 }
6864
6865 #[allow(irrefutable_let_patterns)]
6866 pub fn into_query(self) -> Option<(BaseDatagramSocketQueryResponder)> {
6867 if let BaseDatagramSocketRequest::Query { responder } = self {
6868 Some((responder))
6869 } else {
6870 None
6871 }
6872 }
6873
6874 #[allow(irrefutable_let_patterns)]
6875 pub fn into_set_reuse_address(
6876 self,
6877 ) -> Option<(bool, BaseDatagramSocketSetReuseAddressResponder)> {
6878 if let BaseDatagramSocketRequest::SetReuseAddress { value, responder } = self {
6879 Some((value, responder))
6880 } else {
6881 None
6882 }
6883 }
6884
6885 #[allow(irrefutable_let_patterns)]
6886 pub fn into_get_reuse_address(self) -> Option<(BaseDatagramSocketGetReuseAddressResponder)> {
6887 if let BaseDatagramSocketRequest::GetReuseAddress { responder } = self {
6888 Some((responder))
6889 } else {
6890 None
6891 }
6892 }
6893
6894 #[allow(irrefutable_let_patterns)]
6895 pub fn into_get_error(self) -> Option<(BaseDatagramSocketGetErrorResponder)> {
6896 if let BaseDatagramSocketRequest::GetError { responder } = self {
6897 Some((responder))
6898 } else {
6899 None
6900 }
6901 }
6902
6903 #[allow(irrefutable_let_patterns)]
6904 pub fn into_set_broadcast(self) -> Option<(bool, BaseDatagramSocketSetBroadcastResponder)> {
6905 if let BaseDatagramSocketRequest::SetBroadcast { value, responder } = self {
6906 Some((value, responder))
6907 } else {
6908 None
6909 }
6910 }
6911
6912 #[allow(irrefutable_let_patterns)]
6913 pub fn into_get_broadcast(self) -> Option<(BaseDatagramSocketGetBroadcastResponder)> {
6914 if let BaseDatagramSocketRequest::GetBroadcast { responder } = self {
6915 Some((responder))
6916 } else {
6917 None
6918 }
6919 }
6920
6921 #[allow(irrefutable_let_patterns)]
6922 pub fn into_set_send_buffer(self) -> Option<(u64, BaseDatagramSocketSetSendBufferResponder)> {
6923 if let BaseDatagramSocketRequest::SetSendBuffer { value_bytes, responder } = self {
6924 Some((value_bytes, responder))
6925 } else {
6926 None
6927 }
6928 }
6929
6930 #[allow(irrefutable_let_patterns)]
6931 pub fn into_get_send_buffer(self) -> Option<(BaseDatagramSocketGetSendBufferResponder)> {
6932 if let BaseDatagramSocketRequest::GetSendBuffer { responder } = self {
6933 Some((responder))
6934 } else {
6935 None
6936 }
6937 }
6938
6939 #[allow(irrefutable_let_patterns)]
6940 pub fn into_set_receive_buffer(
6941 self,
6942 ) -> Option<(u64, BaseDatagramSocketSetReceiveBufferResponder)> {
6943 if let BaseDatagramSocketRequest::SetReceiveBuffer { value_bytes, responder } = self {
6944 Some((value_bytes, responder))
6945 } else {
6946 None
6947 }
6948 }
6949
6950 #[allow(irrefutable_let_patterns)]
6951 pub fn into_get_receive_buffer(self) -> Option<(BaseDatagramSocketGetReceiveBufferResponder)> {
6952 if let BaseDatagramSocketRequest::GetReceiveBuffer { responder } = self {
6953 Some((responder))
6954 } else {
6955 None
6956 }
6957 }
6958
6959 #[allow(irrefutable_let_patterns)]
6960 pub fn into_set_keep_alive(self) -> Option<(bool, BaseDatagramSocketSetKeepAliveResponder)> {
6961 if let BaseDatagramSocketRequest::SetKeepAlive { value, responder } = self {
6962 Some((value, responder))
6963 } else {
6964 None
6965 }
6966 }
6967
6968 #[allow(irrefutable_let_patterns)]
6969 pub fn into_get_keep_alive(self) -> Option<(BaseDatagramSocketGetKeepAliveResponder)> {
6970 if let BaseDatagramSocketRequest::GetKeepAlive { responder } = self {
6971 Some((responder))
6972 } else {
6973 None
6974 }
6975 }
6976
6977 #[allow(irrefutable_let_patterns)]
6978 pub fn into_set_out_of_band_inline(
6979 self,
6980 ) -> Option<(bool, BaseDatagramSocketSetOutOfBandInlineResponder)> {
6981 if let BaseDatagramSocketRequest::SetOutOfBandInline { value, responder } = self {
6982 Some((value, responder))
6983 } else {
6984 None
6985 }
6986 }
6987
6988 #[allow(irrefutable_let_patterns)]
6989 pub fn into_get_out_of_band_inline(
6990 self,
6991 ) -> Option<(BaseDatagramSocketGetOutOfBandInlineResponder)> {
6992 if let BaseDatagramSocketRequest::GetOutOfBandInline { responder } = self {
6993 Some((responder))
6994 } else {
6995 None
6996 }
6997 }
6998
6999 #[allow(irrefutable_let_patterns)]
7000 pub fn into_set_no_check(self) -> Option<(bool, BaseDatagramSocketSetNoCheckResponder)> {
7001 if let BaseDatagramSocketRequest::SetNoCheck { value, responder } = self {
7002 Some((value, responder))
7003 } else {
7004 None
7005 }
7006 }
7007
7008 #[allow(irrefutable_let_patterns)]
7009 pub fn into_get_no_check(self) -> Option<(BaseDatagramSocketGetNoCheckResponder)> {
7010 if let BaseDatagramSocketRequest::GetNoCheck { responder } = self {
7011 Some((responder))
7012 } else {
7013 None
7014 }
7015 }
7016
7017 #[allow(irrefutable_let_patterns)]
7018 pub fn into_set_linger(self) -> Option<(bool, u32, BaseDatagramSocketSetLingerResponder)> {
7019 if let BaseDatagramSocketRequest::SetLinger { linger, length_secs, responder } = self {
7020 Some((linger, length_secs, responder))
7021 } else {
7022 None
7023 }
7024 }
7025
7026 #[allow(irrefutable_let_patterns)]
7027 pub fn into_get_linger(self) -> Option<(BaseDatagramSocketGetLingerResponder)> {
7028 if let BaseDatagramSocketRequest::GetLinger { responder } = self {
7029 Some((responder))
7030 } else {
7031 None
7032 }
7033 }
7034
7035 #[allow(irrefutable_let_patterns)]
7036 pub fn into_set_reuse_port(self) -> Option<(bool, BaseDatagramSocketSetReusePortResponder)> {
7037 if let BaseDatagramSocketRequest::SetReusePort { value, responder } = self {
7038 Some((value, responder))
7039 } else {
7040 None
7041 }
7042 }
7043
7044 #[allow(irrefutable_let_patterns)]
7045 pub fn into_get_reuse_port(self) -> Option<(BaseDatagramSocketGetReusePortResponder)> {
7046 if let BaseDatagramSocketRequest::GetReusePort { responder } = self {
7047 Some((responder))
7048 } else {
7049 None
7050 }
7051 }
7052
7053 #[allow(irrefutable_let_patterns)]
7054 pub fn into_get_accept_conn(self) -> Option<(BaseDatagramSocketGetAcceptConnResponder)> {
7055 if let BaseDatagramSocketRequest::GetAcceptConn { responder } = self {
7056 Some((responder))
7057 } else {
7058 None
7059 }
7060 }
7061
7062 #[allow(irrefutable_let_patterns)]
7063 pub fn into_set_bind_to_device(
7064 self,
7065 ) -> Option<(String, BaseDatagramSocketSetBindToDeviceResponder)> {
7066 if let BaseDatagramSocketRequest::SetBindToDevice { value, responder } = self {
7067 Some((value, responder))
7068 } else {
7069 None
7070 }
7071 }
7072
7073 #[allow(irrefutable_let_patterns)]
7074 pub fn into_get_bind_to_device(self) -> Option<(BaseDatagramSocketGetBindToDeviceResponder)> {
7075 if let BaseDatagramSocketRequest::GetBindToDevice { responder } = self {
7076 Some((responder))
7077 } else {
7078 None
7079 }
7080 }
7081
7082 #[allow(irrefutable_let_patterns)]
7083 pub fn into_set_bind_to_interface_index(
7084 self,
7085 ) -> Option<(u64, BaseDatagramSocketSetBindToInterfaceIndexResponder)> {
7086 if let BaseDatagramSocketRequest::SetBindToInterfaceIndex { value, responder } = self {
7087 Some((value, responder))
7088 } else {
7089 None
7090 }
7091 }
7092
7093 #[allow(irrefutable_let_patterns)]
7094 pub fn into_get_bind_to_interface_index(
7095 self,
7096 ) -> Option<(BaseDatagramSocketGetBindToInterfaceIndexResponder)> {
7097 if let BaseDatagramSocketRequest::GetBindToInterfaceIndex { responder } = self {
7098 Some((responder))
7099 } else {
7100 None
7101 }
7102 }
7103
7104 #[allow(irrefutable_let_patterns)]
7105 pub fn into_set_timestamp(
7106 self,
7107 ) -> Option<(TimestampOption, BaseDatagramSocketSetTimestampResponder)> {
7108 if let BaseDatagramSocketRequest::SetTimestamp { value, responder } = self {
7109 Some((value, responder))
7110 } else {
7111 None
7112 }
7113 }
7114
7115 #[allow(irrefutable_let_patterns)]
7116 pub fn into_get_timestamp(self) -> Option<(BaseDatagramSocketGetTimestampResponder)> {
7117 if let BaseDatagramSocketRequest::GetTimestamp { responder } = self {
7118 Some((responder))
7119 } else {
7120 None
7121 }
7122 }
7123
7124 #[allow(irrefutable_let_patterns)]
7125 pub fn into_set_mark(
7126 self,
7127 ) -> Option<(fidl_fuchsia_net::MarkDomain, OptionalUint32, BaseDatagramSocketSetMarkResponder)>
7128 {
7129 if let BaseDatagramSocketRequest::SetMark { domain, mark, responder } = self {
7130 Some((domain, mark, responder))
7131 } else {
7132 None
7133 }
7134 }
7135
7136 #[allow(irrefutable_let_patterns)]
7137 pub fn into_get_mark(
7138 self,
7139 ) -> Option<(fidl_fuchsia_net::MarkDomain, BaseDatagramSocketGetMarkResponder)> {
7140 if let BaseDatagramSocketRequest::GetMark { domain, responder } = self {
7141 Some((domain, responder))
7142 } else {
7143 None
7144 }
7145 }
7146
7147 #[allow(irrefutable_let_patterns)]
7148 pub fn into_bind(
7149 self,
7150 ) -> Option<(fidl_fuchsia_net::SocketAddress, BaseDatagramSocketBindResponder)> {
7151 if let BaseDatagramSocketRequest::Bind { addr, responder } = self {
7152 Some((addr, responder))
7153 } else {
7154 None
7155 }
7156 }
7157
7158 #[allow(irrefutable_let_patterns)]
7159 pub fn into_connect(
7160 self,
7161 ) -> Option<(fidl_fuchsia_net::SocketAddress, BaseDatagramSocketConnectResponder)> {
7162 if let BaseDatagramSocketRequest::Connect { addr, responder } = self {
7163 Some((addr, responder))
7164 } else {
7165 None
7166 }
7167 }
7168
7169 #[allow(irrefutable_let_patterns)]
7170 pub fn into_disconnect(self) -> Option<(BaseDatagramSocketDisconnectResponder)> {
7171 if let BaseDatagramSocketRequest::Disconnect { responder } = self {
7172 Some((responder))
7173 } else {
7174 None
7175 }
7176 }
7177
7178 #[allow(irrefutable_let_patterns)]
7179 pub fn into_get_sock_name(self) -> Option<(BaseDatagramSocketGetSockNameResponder)> {
7180 if let BaseDatagramSocketRequest::GetSockName { responder } = self {
7181 Some((responder))
7182 } else {
7183 None
7184 }
7185 }
7186
7187 #[allow(irrefutable_let_patterns)]
7188 pub fn into_get_peer_name(self) -> Option<(BaseDatagramSocketGetPeerNameResponder)> {
7189 if let BaseDatagramSocketRequest::GetPeerName { responder } = self {
7190 Some((responder))
7191 } else {
7192 None
7193 }
7194 }
7195
7196 #[allow(irrefutable_let_patterns)]
7197 pub fn into_shutdown(self) -> Option<(ShutdownMode, BaseDatagramSocketShutdownResponder)> {
7198 if let BaseDatagramSocketRequest::Shutdown { mode, responder } = self {
7199 Some((mode, responder))
7200 } else {
7201 None
7202 }
7203 }
7204
7205 #[allow(irrefutable_let_patterns)]
7206 pub fn into_set_ip_type_of_service(
7207 self,
7208 ) -> Option<(u8, BaseDatagramSocketSetIpTypeOfServiceResponder)> {
7209 if let BaseDatagramSocketRequest::SetIpTypeOfService { value, responder } = self {
7210 Some((value, responder))
7211 } else {
7212 None
7213 }
7214 }
7215
7216 #[allow(irrefutable_let_patterns)]
7217 pub fn into_get_ip_type_of_service(
7218 self,
7219 ) -> Option<(BaseDatagramSocketGetIpTypeOfServiceResponder)> {
7220 if let BaseDatagramSocketRequest::GetIpTypeOfService { responder } = self {
7221 Some((responder))
7222 } else {
7223 None
7224 }
7225 }
7226
7227 #[allow(irrefutable_let_patterns)]
7228 pub fn into_set_ip_ttl(self) -> Option<(OptionalUint8, BaseDatagramSocketSetIpTtlResponder)> {
7229 if let BaseDatagramSocketRequest::SetIpTtl { value, responder } = self {
7230 Some((value, responder))
7231 } else {
7232 None
7233 }
7234 }
7235
7236 #[allow(irrefutable_let_patterns)]
7237 pub fn into_get_ip_ttl(self) -> Option<(BaseDatagramSocketGetIpTtlResponder)> {
7238 if let BaseDatagramSocketRequest::GetIpTtl { responder } = self {
7239 Some((responder))
7240 } else {
7241 None
7242 }
7243 }
7244
7245 #[allow(irrefutable_let_patterns)]
7246 pub fn into_set_ip_packet_info(
7247 self,
7248 ) -> Option<(bool, BaseDatagramSocketSetIpPacketInfoResponder)> {
7249 if let BaseDatagramSocketRequest::SetIpPacketInfo { value, responder } = self {
7250 Some((value, responder))
7251 } else {
7252 None
7253 }
7254 }
7255
7256 #[allow(irrefutable_let_patterns)]
7257 pub fn into_get_ip_packet_info(self) -> Option<(BaseDatagramSocketGetIpPacketInfoResponder)> {
7258 if let BaseDatagramSocketRequest::GetIpPacketInfo { responder } = self {
7259 Some((responder))
7260 } else {
7261 None
7262 }
7263 }
7264
7265 #[allow(irrefutable_let_patterns)]
7266 pub fn into_set_ip_receive_type_of_service(
7267 self,
7268 ) -> Option<(bool, BaseDatagramSocketSetIpReceiveTypeOfServiceResponder)> {
7269 if let BaseDatagramSocketRequest::SetIpReceiveTypeOfService { value, responder } = self {
7270 Some((value, responder))
7271 } else {
7272 None
7273 }
7274 }
7275
7276 #[allow(irrefutable_let_patterns)]
7277 pub fn into_get_ip_receive_type_of_service(
7278 self,
7279 ) -> Option<(BaseDatagramSocketGetIpReceiveTypeOfServiceResponder)> {
7280 if let BaseDatagramSocketRequest::GetIpReceiveTypeOfService { responder } = self {
7281 Some((responder))
7282 } else {
7283 None
7284 }
7285 }
7286
7287 #[allow(irrefutable_let_patterns)]
7288 pub fn into_set_ip_receive_ttl(
7289 self,
7290 ) -> Option<(bool, BaseDatagramSocketSetIpReceiveTtlResponder)> {
7291 if let BaseDatagramSocketRequest::SetIpReceiveTtl { value, responder } = self {
7292 Some((value, responder))
7293 } else {
7294 None
7295 }
7296 }
7297
7298 #[allow(irrefutable_let_patterns)]
7299 pub fn into_get_ip_receive_ttl(self) -> Option<(BaseDatagramSocketGetIpReceiveTtlResponder)> {
7300 if let BaseDatagramSocketRequest::GetIpReceiveTtl { responder } = self {
7301 Some((responder))
7302 } else {
7303 None
7304 }
7305 }
7306
7307 #[allow(irrefutable_let_patterns)]
7308 pub fn into_set_ip_multicast_interface(
7309 self,
7310 ) -> Option<(
7311 u64,
7312 fidl_fuchsia_net::Ipv4Address,
7313 BaseDatagramSocketSetIpMulticastInterfaceResponder,
7314 )> {
7315 if let BaseDatagramSocketRequest::SetIpMulticastInterface { iface, address, responder } =
7316 self
7317 {
7318 Some((iface, address, responder))
7319 } else {
7320 None
7321 }
7322 }
7323
7324 #[allow(irrefutable_let_patterns)]
7325 pub fn into_get_ip_multicast_interface(
7326 self,
7327 ) -> Option<(BaseDatagramSocketGetIpMulticastInterfaceResponder)> {
7328 if let BaseDatagramSocketRequest::GetIpMulticastInterface { responder } = self {
7329 Some((responder))
7330 } else {
7331 None
7332 }
7333 }
7334
7335 #[allow(irrefutable_let_patterns)]
7336 pub fn into_set_ip_multicast_ttl(
7337 self,
7338 ) -> Option<(OptionalUint8, BaseDatagramSocketSetIpMulticastTtlResponder)> {
7339 if let BaseDatagramSocketRequest::SetIpMulticastTtl { value, responder } = self {
7340 Some((value, responder))
7341 } else {
7342 None
7343 }
7344 }
7345
7346 #[allow(irrefutable_let_patterns)]
7347 pub fn into_get_ip_multicast_ttl(
7348 self,
7349 ) -> Option<(BaseDatagramSocketGetIpMulticastTtlResponder)> {
7350 if let BaseDatagramSocketRequest::GetIpMulticastTtl { responder } = self {
7351 Some((responder))
7352 } else {
7353 None
7354 }
7355 }
7356
7357 #[allow(irrefutable_let_patterns)]
7358 pub fn into_set_ip_multicast_loopback(
7359 self,
7360 ) -> Option<(bool, BaseDatagramSocketSetIpMulticastLoopbackResponder)> {
7361 if let BaseDatagramSocketRequest::SetIpMulticastLoopback { value, responder } = self {
7362 Some((value, responder))
7363 } else {
7364 None
7365 }
7366 }
7367
7368 #[allow(irrefutable_let_patterns)]
7369 pub fn into_get_ip_multicast_loopback(
7370 self,
7371 ) -> Option<(BaseDatagramSocketGetIpMulticastLoopbackResponder)> {
7372 if let BaseDatagramSocketRequest::GetIpMulticastLoopback { responder } = self {
7373 Some((responder))
7374 } else {
7375 None
7376 }
7377 }
7378
7379 #[allow(irrefutable_let_patterns)]
7380 pub fn into_add_ip_membership(
7381 self,
7382 ) -> Option<(IpMulticastMembership, BaseDatagramSocketAddIpMembershipResponder)> {
7383 if let BaseDatagramSocketRequest::AddIpMembership { membership, responder } = self {
7384 Some((membership, responder))
7385 } else {
7386 None
7387 }
7388 }
7389
7390 #[allow(irrefutable_let_patterns)]
7391 pub fn into_drop_ip_membership(
7392 self,
7393 ) -> Option<(IpMulticastMembership, BaseDatagramSocketDropIpMembershipResponder)> {
7394 if let BaseDatagramSocketRequest::DropIpMembership { membership, responder } = self {
7395 Some((membership, responder))
7396 } else {
7397 None
7398 }
7399 }
7400
7401 #[allow(irrefutable_let_patterns)]
7402 pub fn into_set_ip_transparent(
7403 self,
7404 ) -> Option<(bool, BaseDatagramSocketSetIpTransparentResponder)> {
7405 if let BaseDatagramSocketRequest::SetIpTransparent { value, responder } = self {
7406 Some((value, responder))
7407 } else {
7408 None
7409 }
7410 }
7411
7412 #[allow(irrefutable_let_patterns)]
7413 pub fn into_get_ip_transparent(self) -> Option<(BaseDatagramSocketGetIpTransparentResponder)> {
7414 if let BaseDatagramSocketRequest::GetIpTransparent { responder } = self {
7415 Some((responder))
7416 } else {
7417 None
7418 }
7419 }
7420
7421 #[allow(irrefutable_let_patterns)]
7422 pub fn into_set_ip_receive_original_destination_address(
7423 self,
7424 ) -> Option<(bool, BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder)> {
7425 if let BaseDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress {
7426 value,
7427 responder,
7428 } = self
7429 {
7430 Some((value, responder))
7431 } else {
7432 None
7433 }
7434 }
7435
7436 #[allow(irrefutable_let_patterns)]
7437 pub fn into_get_ip_receive_original_destination_address(
7438 self,
7439 ) -> Option<(BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder)> {
7440 if let BaseDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress { responder } =
7441 self
7442 {
7443 Some((responder))
7444 } else {
7445 None
7446 }
7447 }
7448
7449 #[allow(irrefutable_let_patterns)]
7450 pub fn into_add_ipv6_membership(
7451 self,
7452 ) -> Option<(Ipv6MulticastMembership, BaseDatagramSocketAddIpv6MembershipResponder)> {
7453 if let BaseDatagramSocketRequest::AddIpv6Membership { membership, responder } = self {
7454 Some((membership, responder))
7455 } else {
7456 None
7457 }
7458 }
7459
7460 #[allow(irrefutable_let_patterns)]
7461 pub fn into_drop_ipv6_membership(
7462 self,
7463 ) -> Option<(Ipv6MulticastMembership, BaseDatagramSocketDropIpv6MembershipResponder)> {
7464 if let BaseDatagramSocketRequest::DropIpv6Membership { membership, responder } = self {
7465 Some((membership, responder))
7466 } else {
7467 None
7468 }
7469 }
7470
7471 #[allow(irrefutable_let_patterns)]
7472 pub fn into_set_ipv6_multicast_interface(
7473 self,
7474 ) -> Option<(u64, BaseDatagramSocketSetIpv6MulticastInterfaceResponder)> {
7475 if let BaseDatagramSocketRequest::SetIpv6MulticastInterface { value, responder } = self {
7476 Some((value, responder))
7477 } else {
7478 None
7479 }
7480 }
7481
7482 #[allow(irrefutable_let_patterns)]
7483 pub fn into_get_ipv6_multicast_interface(
7484 self,
7485 ) -> Option<(BaseDatagramSocketGetIpv6MulticastInterfaceResponder)> {
7486 if let BaseDatagramSocketRequest::GetIpv6MulticastInterface { responder } = self {
7487 Some((responder))
7488 } else {
7489 None
7490 }
7491 }
7492
7493 #[allow(irrefutable_let_patterns)]
7494 pub fn into_set_ipv6_unicast_hops(
7495 self,
7496 ) -> Option<(OptionalUint8, BaseDatagramSocketSetIpv6UnicastHopsResponder)> {
7497 if let BaseDatagramSocketRequest::SetIpv6UnicastHops { value, responder } = self {
7498 Some((value, responder))
7499 } else {
7500 None
7501 }
7502 }
7503
7504 #[allow(irrefutable_let_patterns)]
7505 pub fn into_get_ipv6_unicast_hops(
7506 self,
7507 ) -> Option<(BaseDatagramSocketGetIpv6UnicastHopsResponder)> {
7508 if let BaseDatagramSocketRequest::GetIpv6UnicastHops { responder } = self {
7509 Some((responder))
7510 } else {
7511 None
7512 }
7513 }
7514
7515 #[allow(irrefutable_let_patterns)]
7516 pub fn into_set_ipv6_receive_hop_limit(
7517 self,
7518 ) -> Option<(bool, BaseDatagramSocketSetIpv6ReceiveHopLimitResponder)> {
7519 if let BaseDatagramSocketRequest::SetIpv6ReceiveHopLimit { value, responder } = self {
7520 Some((value, responder))
7521 } else {
7522 None
7523 }
7524 }
7525
7526 #[allow(irrefutable_let_patterns)]
7527 pub fn into_get_ipv6_receive_hop_limit(
7528 self,
7529 ) -> Option<(BaseDatagramSocketGetIpv6ReceiveHopLimitResponder)> {
7530 if let BaseDatagramSocketRequest::GetIpv6ReceiveHopLimit { responder } = self {
7531 Some((responder))
7532 } else {
7533 None
7534 }
7535 }
7536
7537 #[allow(irrefutable_let_patterns)]
7538 pub fn into_set_ipv6_multicast_hops(
7539 self,
7540 ) -> Option<(OptionalUint8, BaseDatagramSocketSetIpv6MulticastHopsResponder)> {
7541 if let BaseDatagramSocketRequest::SetIpv6MulticastHops { value, responder } = self {
7542 Some((value, responder))
7543 } else {
7544 None
7545 }
7546 }
7547
7548 #[allow(irrefutable_let_patterns)]
7549 pub fn into_get_ipv6_multicast_hops(
7550 self,
7551 ) -> Option<(BaseDatagramSocketGetIpv6MulticastHopsResponder)> {
7552 if let BaseDatagramSocketRequest::GetIpv6MulticastHops { responder } = self {
7553 Some((responder))
7554 } else {
7555 None
7556 }
7557 }
7558
7559 #[allow(irrefutable_let_patterns)]
7560 pub fn into_set_ipv6_multicast_loopback(
7561 self,
7562 ) -> Option<(bool, BaseDatagramSocketSetIpv6MulticastLoopbackResponder)> {
7563 if let BaseDatagramSocketRequest::SetIpv6MulticastLoopback { value, responder } = self {
7564 Some((value, responder))
7565 } else {
7566 None
7567 }
7568 }
7569
7570 #[allow(irrefutable_let_patterns)]
7571 pub fn into_get_ipv6_multicast_loopback(
7572 self,
7573 ) -> Option<(BaseDatagramSocketGetIpv6MulticastLoopbackResponder)> {
7574 if let BaseDatagramSocketRequest::GetIpv6MulticastLoopback { responder } = self {
7575 Some((responder))
7576 } else {
7577 None
7578 }
7579 }
7580
7581 #[allow(irrefutable_let_patterns)]
7582 pub fn into_set_ipv6_only(self) -> Option<(bool, BaseDatagramSocketSetIpv6OnlyResponder)> {
7583 if let BaseDatagramSocketRequest::SetIpv6Only { value, responder } = self {
7584 Some((value, responder))
7585 } else {
7586 None
7587 }
7588 }
7589
7590 #[allow(irrefutable_let_patterns)]
7591 pub fn into_get_ipv6_only(self) -> Option<(BaseDatagramSocketGetIpv6OnlyResponder)> {
7592 if let BaseDatagramSocketRequest::GetIpv6Only { responder } = self {
7593 Some((responder))
7594 } else {
7595 None
7596 }
7597 }
7598
7599 #[allow(irrefutable_let_patterns)]
7600 pub fn into_set_ipv6_receive_traffic_class(
7601 self,
7602 ) -> Option<(bool, BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder)> {
7603 if let BaseDatagramSocketRequest::SetIpv6ReceiveTrafficClass { value, responder } = self {
7604 Some((value, responder))
7605 } else {
7606 None
7607 }
7608 }
7609
7610 #[allow(irrefutable_let_patterns)]
7611 pub fn into_get_ipv6_receive_traffic_class(
7612 self,
7613 ) -> Option<(BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder)> {
7614 if let BaseDatagramSocketRequest::GetIpv6ReceiveTrafficClass { responder } = self {
7615 Some((responder))
7616 } else {
7617 None
7618 }
7619 }
7620
7621 #[allow(irrefutable_let_patterns)]
7622 pub fn into_set_ipv6_traffic_class(
7623 self,
7624 ) -> Option<(OptionalUint8, BaseDatagramSocketSetIpv6TrafficClassResponder)> {
7625 if let BaseDatagramSocketRequest::SetIpv6TrafficClass { value, responder } = self {
7626 Some((value, responder))
7627 } else {
7628 None
7629 }
7630 }
7631
7632 #[allow(irrefutable_let_patterns)]
7633 pub fn into_get_ipv6_traffic_class(
7634 self,
7635 ) -> Option<(BaseDatagramSocketGetIpv6TrafficClassResponder)> {
7636 if let BaseDatagramSocketRequest::GetIpv6TrafficClass { responder } = self {
7637 Some((responder))
7638 } else {
7639 None
7640 }
7641 }
7642
7643 #[allow(irrefutable_let_patterns)]
7644 pub fn into_set_ipv6_receive_packet_info(
7645 self,
7646 ) -> Option<(bool, BaseDatagramSocketSetIpv6ReceivePacketInfoResponder)> {
7647 if let BaseDatagramSocketRequest::SetIpv6ReceivePacketInfo { value, responder } = self {
7648 Some((value, responder))
7649 } else {
7650 None
7651 }
7652 }
7653
7654 #[allow(irrefutable_let_patterns)]
7655 pub fn into_get_ipv6_receive_packet_info(
7656 self,
7657 ) -> Option<(BaseDatagramSocketGetIpv6ReceivePacketInfoResponder)> {
7658 if let BaseDatagramSocketRequest::GetIpv6ReceivePacketInfo { responder } = self {
7659 Some((responder))
7660 } else {
7661 None
7662 }
7663 }
7664
7665 #[allow(irrefutable_let_patterns)]
7666 pub fn into_get_original_destination(
7667 self,
7668 ) -> Option<(BaseDatagramSocketGetOriginalDestinationResponder)> {
7669 if let BaseDatagramSocketRequest::GetOriginalDestination { responder } = self {
7670 Some((responder))
7671 } else {
7672 None
7673 }
7674 }
7675
7676 #[allow(irrefutable_let_patterns)]
7677 pub fn into_get_info(self) -> Option<(BaseDatagramSocketGetInfoResponder)> {
7678 if let BaseDatagramSocketRequest::GetInfo { responder } = self {
7679 Some((responder))
7680 } else {
7681 None
7682 }
7683 }
7684
7685 pub fn method_name(&self) -> &'static str {
7687 match *self {
7688 BaseDatagramSocketRequest::Clone { .. } => "clone",
7689 BaseDatagramSocketRequest::Close { .. } => "close",
7690 BaseDatagramSocketRequest::Query { .. } => "query",
7691 BaseDatagramSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
7692 BaseDatagramSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
7693 BaseDatagramSocketRequest::GetError { .. } => "get_error",
7694 BaseDatagramSocketRequest::SetBroadcast { .. } => "set_broadcast",
7695 BaseDatagramSocketRequest::GetBroadcast { .. } => "get_broadcast",
7696 BaseDatagramSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
7697 BaseDatagramSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
7698 BaseDatagramSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
7699 BaseDatagramSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
7700 BaseDatagramSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
7701 BaseDatagramSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
7702 BaseDatagramSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
7703 BaseDatagramSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
7704 BaseDatagramSocketRequest::SetNoCheck { .. } => "set_no_check",
7705 BaseDatagramSocketRequest::GetNoCheck { .. } => "get_no_check",
7706 BaseDatagramSocketRequest::SetLinger { .. } => "set_linger",
7707 BaseDatagramSocketRequest::GetLinger { .. } => "get_linger",
7708 BaseDatagramSocketRequest::SetReusePort { .. } => "set_reuse_port",
7709 BaseDatagramSocketRequest::GetReusePort { .. } => "get_reuse_port",
7710 BaseDatagramSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
7711 BaseDatagramSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
7712 BaseDatagramSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
7713 BaseDatagramSocketRequest::SetBindToInterfaceIndex { .. } => {
7714 "set_bind_to_interface_index"
7715 }
7716 BaseDatagramSocketRequest::GetBindToInterfaceIndex { .. } => {
7717 "get_bind_to_interface_index"
7718 }
7719 BaseDatagramSocketRequest::SetTimestamp { .. } => "set_timestamp",
7720 BaseDatagramSocketRequest::GetTimestamp { .. } => "get_timestamp",
7721 BaseDatagramSocketRequest::SetMark { .. } => "set_mark",
7722 BaseDatagramSocketRequest::GetMark { .. } => "get_mark",
7723 BaseDatagramSocketRequest::Bind { .. } => "bind",
7724 BaseDatagramSocketRequest::Connect { .. } => "connect",
7725 BaseDatagramSocketRequest::Disconnect { .. } => "disconnect",
7726 BaseDatagramSocketRequest::GetSockName { .. } => "get_sock_name",
7727 BaseDatagramSocketRequest::GetPeerName { .. } => "get_peer_name",
7728 BaseDatagramSocketRequest::Shutdown { .. } => "shutdown",
7729 BaseDatagramSocketRequest::SetIpTypeOfService { .. } => "set_ip_type_of_service",
7730 BaseDatagramSocketRequest::GetIpTypeOfService { .. } => "get_ip_type_of_service",
7731 BaseDatagramSocketRequest::SetIpTtl { .. } => "set_ip_ttl",
7732 BaseDatagramSocketRequest::GetIpTtl { .. } => "get_ip_ttl",
7733 BaseDatagramSocketRequest::SetIpPacketInfo { .. } => "set_ip_packet_info",
7734 BaseDatagramSocketRequest::GetIpPacketInfo { .. } => "get_ip_packet_info",
7735 BaseDatagramSocketRequest::SetIpReceiveTypeOfService { .. } => {
7736 "set_ip_receive_type_of_service"
7737 }
7738 BaseDatagramSocketRequest::GetIpReceiveTypeOfService { .. } => {
7739 "get_ip_receive_type_of_service"
7740 }
7741 BaseDatagramSocketRequest::SetIpReceiveTtl { .. } => "set_ip_receive_ttl",
7742 BaseDatagramSocketRequest::GetIpReceiveTtl { .. } => "get_ip_receive_ttl",
7743 BaseDatagramSocketRequest::SetIpMulticastInterface { .. } => {
7744 "set_ip_multicast_interface"
7745 }
7746 BaseDatagramSocketRequest::GetIpMulticastInterface { .. } => {
7747 "get_ip_multicast_interface"
7748 }
7749 BaseDatagramSocketRequest::SetIpMulticastTtl { .. } => "set_ip_multicast_ttl",
7750 BaseDatagramSocketRequest::GetIpMulticastTtl { .. } => "get_ip_multicast_ttl",
7751 BaseDatagramSocketRequest::SetIpMulticastLoopback { .. } => "set_ip_multicast_loopback",
7752 BaseDatagramSocketRequest::GetIpMulticastLoopback { .. } => "get_ip_multicast_loopback",
7753 BaseDatagramSocketRequest::AddIpMembership { .. } => "add_ip_membership",
7754 BaseDatagramSocketRequest::DropIpMembership { .. } => "drop_ip_membership",
7755 BaseDatagramSocketRequest::SetIpTransparent { .. } => "set_ip_transparent",
7756 BaseDatagramSocketRequest::GetIpTransparent { .. } => "get_ip_transparent",
7757 BaseDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress { .. } => {
7758 "set_ip_receive_original_destination_address"
7759 }
7760 BaseDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress { .. } => {
7761 "get_ip_receive_original_destination_address"
7762 }
7763 BaseDatagramSocketRequest::AddIpv6Membership { .. } => "add_ipv6_membership",
7764 BaseDatagramSocketRequest::DropIpv6Membership { .. } => "drop_ipv6_membership",
7765 BaseDatagramSocketRequest::SetIpv6MulticastInterface { .. } => {
7766 "set_ipv6_multicast_interface"
7767 }
7768 BaseDatagramSocketRequest::GetIpv6MulticastInterface { .. } => {
7769 "get_ipv6_multicast_interface"
7770 }
7771 BaseDatagramSocketRequest::SetIpv6UnicastHops { .. } => "set_ipv6_unicast_hops",
7772 BaseDatagramSocketRequest::GetIpv6UnicastHops { .. } => "get_ipv6_unicast_hops",
7773 BaseDatagramSocketRequest::SetIpv6ReceiveHopLimit { .. } => {
7774 "set_ipv6_receive_hop_limit"
7775 }
7776 BaseDatagramSocketRequest::GetIpv6ReceiveHopLimit { .. } => {
7777 "get_ipv6_receive_hop_limit"
7778 }
7779 BaseDatagramSocketRequest::SetIpv6MulticastHops { .. } => "set_ipv6_multicast_hops",
7780 BaseDatagramSocketRequest::GetIpv6MulticastHops { .. } => "get_ipv6_multicast_hops",
7781 BaseDatagramSocketRequest::SetIpv6MulticastLoopback { .. } => {
7782 "set_ipv6_multicast_loopback"
7783 }
7784 BaseDatagramSocketRequest::GetIpv6MulticastLoopback { .. } => {
7785 "get_ipv6_multicast_loopback"
7786 }
7787 BaseDatagramSocketRequest::SetIpv6Only { .. } => "set_ipv6_only",
7788 BaseDatagramSocketRequest::GetIpv6Only { .. } => "get_ipv6_only",
7789 BaseDatagramSocketRequest::SetIpv6ReceiveTrafficClass { .. } => {
7790 "set_ipv6_receive_traffic_class"
7791 }
7792 BaseDatagramSocketRequest::GetIpv6ReceiveTrafficClass { .. } => {
7793 "get_ipv6_receive_traffic_class"
7794 }
7795 BaseDatagramSocketRequest::SetIpv6TrafficClass { .. } => "set_ipv6_traffic_class",
7796 BaseDatagramSocketRequest::GetIpv6TrafficClass { .. } => "get_ipv6_traffic_class",
7797 BaseDatagramSocketRequest::SetIpv6ReceivePacketInfo { .. } => {
7798 "set_ipv6_receive_packet_info"
7799 }
7800 BaseDatagramSocketRequest::GetIpv6ReceivePacketInfo { .. } => {
7801 "get_ipv6_receive_packet_info"
7802 }
7803 BaseDatagramSocketRequest::GetOriginalDestination { .. } => "get_original_destination",
7804 BaseDatagramSocketRequest::GetInfo { .. } => "get_info",
7805 }
7806 }
7807}
7808
7809#[derive(Debug, Clone)]
7810pub struct BaseDatagramSocketControlHandle {
7811 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
7812}
7813
7814impl fidl::endpoints::ControlHandle for BaseDatagramSocketControlHandle {
7815 fn shutdown(&self) {
7816 self.inner.shutdown()
7817 }
7818 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
7819 self.inner.shutdown_with_epitaph(status)
7820 }
7821
7822 fn is_closed(&self) -> bool {
7823 self.inner.channel().is_closed()
7824 }
7825 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
7826 self.inner.channel().on_closed()
7827 }
7828
7829 #[cfg(target_os = "fuchsia")]
7830 fn signal_peer(
7831 &self,
7832 clear_mask: zx::Signals,
7833 set_mask: zx::Signals,
7834 ) -> Result<(), zx_status::Status> {
7835 use fidl::Peered;
7836 self.inner.channel().signal_peer(clear_mask, set_mask)
7837 }
7838}
7839
7840impl BaseDatagramSocketControlHandle {}
7841
7842#[must_use = "FIDL methods require a response to be sent"]
7843#[derive(Debug)]
7844pub struct BaseDatagramSocketCloseResponder {
7845 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
7846 tx_id: u32,
7847}
7848
7849impl std::ops::Drop for BaseDatagramSocketCloseResponder {
7853 fn drop(&mut self) {
7854 self.control_handle.shutdown();
7855 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7857 }
7858}
7859
7860impl fidl::endpoints::Responder for BaseDatagramSocketCloseResponder {
7861 type ControlHandle = BaseDatagramSocketControlHandle;
7862
7863 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
7864 &self.control_handle
7865 }
7866
7867 fn drop_without_shutdown(mut self) {
7868 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7870 std::mem::forget(self);
7872 }
7873}
7874
7875impl BaseDatagramSocketCloseResponder {
7876 pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
7880 let _result = self.send_raw(result);
7881 if _result.is_err() {
7882 self.control_handle.shutdown();
7883 }
7884 self.drop_without_shutdown();
7885 _result
7886 }
7887
7888 pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
7890 let _result = self.send_raw(result);
7891 self.drop_without_shutdown();
7892 _result
7893 }
7894
7895 fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
7896 self.control_handle
7897 .inner
7898 .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
7899 result,
7900 self.tx_id,
7901 0x5ac5d459ad7f657e,
7902 fidl::encoding::DynamicFlags::empty(),
7903 )
7904 }
7905}
7906
7907#[must_use = "FIDL methods require a response to be sent"]
7908#[derive(Debug)]
7909pub struct BaseDatagramSocketQueryResponder {
7910 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
7911 tx_id: u32,
7912}
7913
7914impl std::ops::Drop for BaseDatagramSocketQueryResponder {
7918 fn drop(&mut self) {
7919 self.control_handle.shutdown();
7920 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7922 }
7923}
7924
7925impl fidl::endpoints::Responder for BaseDatagramSocketQueryResponder {
7926 type ControlHandle = BaseDatagramSocketControlHandle;
7927
7928 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
7929 &self.control_handle
7930 }
7931
7932 fn drop_without_shutdown(mut self) {
7933 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7935 std::mem::forget(self);
7937 }
7938}
7939
7940impl BaseDatagramSocketQueryResponder {
7941 pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
7945 let _result = self.send_raw(protocol);
7946 if _result.is_err() {
7947 self.control_handle.shutdown();
7948 }
7949 self.drop_without_shutdown();
7950 _result
7951 }
7952
7953 pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
7955 let _result = self.send_raw(protocol);
7956 self.drop_without_shutdown();
7957 _result
7958 }
7959
7960 fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
7961 self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
7962 (protocol,),
7963 self.tx_id,
7964 0x2658edee9decfc06,
7965 fidl::encoding::DynamicFlags::empty(),
7966 )
7967 }
7968}
7969
7970#[must_use = "FIDL methods require a response to be sent"]
7971#[derive(Debug)]
7972pub struct BaseDatagramSocketSetReuseAddressResponder {
7973 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
7974 tx_id: u32,
7975}
7976
7977impl std::ops::Drop for BaseDatagramSocketSetReuseAddressResponder {
7981 fn drop(&mut self) {
7982 self.control_handle.shutdown();
7983 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7985 }
7986}
7987
7988impl fidl::endpoints::Responder for BaseDatagramSocketSetReuseAddressResponder {
7989 type ControlHandle = BaseDatagramSocketControlHandle;
7990
7991 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
7992 &self.control_handle
7993 }
7994
7995 fn drop_without_shutdown(mut self) {
7996 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7998 std::mem::forget(self);
8000 }
8001}
8002
8003impl BaseDatagramSocketSetReuseAddressResponder {
8004 pub fn send(
8008 self,
8009 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8010 ) -> Result<(), fidl::Error> {
8011 let _result = self.send_raw(result);
8012 if _result.is_err() {
8013 self.control_handle.shutdown();
8014 }
8015 self.drop_without_shutdown();
8016 _result
8017 }
8018
8019 pub fn send_no_shutdown_on_err(
8021 self,
8022 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8023 ) -> Result<(), fidl::Error> {
8024 let _result = self.send_raw(result);
8025 self.drop_without_shutdown();
8026 _result
8027 }
8028
8029 fn send_raw(
8030 &self,
8031 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8032 ) -> Result<(), fidl::Error> {
8033 self.control_handle.inner.send::<fidl::encoding::ResultType<
8034 fidl::encoding::EmptyStruct,
8035 fidl_fuchsia_posix::Errno,
8036 >>(
8037 result,
8038 self.tx_id,
8039 0x1fd74ee8b9a4a876,
8040 fidl::encoding::DynamicFlags::empty(),
8041 )
8042 }
8043}
8044
8045#[must_use = "FIDL methods require a response to be sent"]
8046#[derive(Debug)]
8047pub struct BaseDatagramSocketGetReuseAddressResponder {
8048 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8049 tx_id: u32,
8050}
8051
8052impl std::ops::Drop for BaseDatagramSocketGetReuseAddressResponder {
8056 fn drop(&mut self) {
8057 self.control_handle.shutdown();
8058 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8060 }
8061}
8062
8063impl fidl::endpoints::Responder for BaseDatagramSocketGetReuseAddressResponder {
8064 type ControlHandle = BaseDatagramSocketControlHandle;
8065
8066 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8067 &self.control_handle
8068 }
8069
8070 fn drop_without_shutdown(mut self) {
8071 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8073 std::mem::forget(self);
8075 }
8076}
8077
8078impl BaseDatagramSocketGetReuseAddressResponder {
8079 pub fn send(
8083 self,
8084 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8085 ) -> Result<(), fidl::Error> {
8086 let _result = self.send_raw(result);
8087 if _result.is_err() {
8088 self.control_handle.shutdown();
8089 }
8090 self.drop_without_shutdown();
8091 _result
8092 }
8093
8094 pub fn send_no_shutdown_on_err(
8096 self,
8097 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8098 ) -> Result<(), fidl::Error> {
8099 let _result = self.send_raw(result);
8100 self.drop_without_shutdown();
8101 _result
8102 }
8103
8104 fn send_raw(
8105 &self,
8106 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8107 ) -> Result<(), fidl::Error> {
8108 self.control_handle.inner.send::<fidl::encoding::ResultType<
8109 BaseSocketGetReuseAddressResponse,
8110 fidl_fuchsia_posix::Errno,
8111 >>(
8112 result.map(|value| (value,)),
8113 self.tx_id,
8114 0x67b7206b8d1bc0a5,
8115 fidl::encoding::DynamicFlags::empty(),
8116 )
8117 }
8118}
8119
8120#[must_use = "FIDL methods require a response to be sent"]
8121#[derive(Debug)]
8122pub struct BaseDatagramSocketGetErrorResponder {
8123 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8124 tx_id: u32,
8125}
8126
8127impl std::ops::Drop for BaseDatagramSocketGetErrorResponder {
8131 fn drop(&mut self) {
8132 self.control_handle.shutdown();
8133 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8135 }
8136}
8137
8138impl fidl::endpoints::Responder for BaseDatagramSocketGetErrorResponder {
8139 type ControlHandle = BaseDatagramSocketControlHandle;
8140
8141 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8142 &self.control_handle
8143 }
8144
8145 fn drop_without_shutdown(mut self) {
8146 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8148 std::mem::forget(self);
8150 }
8151}
8152
8153impl BaseDatagramSocketGetErrorResponder {
8154 pub fn send(
8158 self,
8159 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8160 ) -> Result<(), fidl::Error> {
8161 let _result = self.send_raw(result);
8162 if _result.is_err() {
8163 self.control_handle.shutdown();
8164 }
8165 self.drop_without_shutdown();
8166 _result
8167 }
8168
8169 pub fn send_no_shutdown_on_err(
8171 self,
8172 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8173 ) -> Result<(), fidl::Error> {
8174 let _result = self.send_raw(result);
8175 self.drop_without_shutdown();
8176 _result
8177 }
8178
8179 fn send_raw(
8180 &self,
8181 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8182 ) -> Result<(), fidl::Error> {
8183 self.control_handle.inner.send::<fidl::encoding::ResultType<
8184 fidl::encoding::EmptyStruct,
8185 fidl_fuchsia_posix::Errno,
8186 >>(
8187 result,
8188 self.tx_id,
8189 0x5aad39b33e5f6ebb,
8190 fidl::encoding::DynamicFlags::empty(),
8191 )
8192 }
8193}
8194
8195#[must_use = "FIDL methods require a response to be sent"]
8196#[derive(Debug)]
8197pub struct BaseDatagramSocketSetBroadcastResponder {
8198 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8199 tx_id: u32,
8200}
8201
8202impl std::ops::Drop for BaseDatagramSocketSetBroadcastResponder {
8206 fn drop(&mut self) {
8207 self.control_handle.shutdown();
8208 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8210 }
8211}
8212
8213impl fidl::endpoints::Responder for BaseDatagramSocketSetBroadcastResponder {
8214 type ControlHandle = BaseDatagramSocketControlHandle;
8215
8216 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8217 &self.control_handle
8218 }
8219
8220 fn drop_without_shutdown(mut self) {
8221 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8223 std::mem::forget(self);
8225 }
8226}
8227
8228impl BaseDatagramSocketSetBroadcastResponder {
8229 pub fn send(
8233 self,
8234 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8235 ) -> Result<(), fidl::Error> {
8236 let _result = self.send_raw(result);
8237 if _result.is_err() {
8238 self.control_handle.shutdown();
8239 }
8240 self.drop_without_shutdown();
8241 _result
8242 }
8243
8244 pub fn send_no_shutdown_on_err(
8246 self,
8247 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8248 ) -> Result<(), fidl::Error> {
8249 let _result = self.send_raw(result);
8250 self.drop_without_shutdown();
8251 _result
8252 }
8253
8254 fn send_raw(
8255 &self,
8256 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8257 ) -> Result<(), fidl::Error> {
8258 self.control_handle.inner.send::<fidl::encoding::ResultType<
8259 fidl::encoding::EmptyStruct,
8260 fidl_fuchsia_posix::Errno,
8261 >>(
8262 result,
8263 self.tx_id,
8264 0x6023e081ce3cd947,
8265 fidl::encoding::DynamicFlags::empty(),
8266 )
8267 }
8268}
8269
8270#[must_use = "FIDL methods require a response to be sent"]
8271#[derive(Debug)]
8272pub struct BaseDatagramSocketGetBroadcastResponder {
8273 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8274 tx_id: u32,
8275}
8276
8277impl std::ops::Drop for BaseDatagramSocketGetBroadcastResponder {
8281 fn drop(&mut self) {
8282 self.control_handle.shutdown();
8283 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8285 }
8286}
8287
8288impl fidl::endpoints::Responder for BaseDatagramSocketGetBroadcastResponder {
8289 type ControlHandle = BaseDatagramSocketControlHandle;
8290
8291 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8292 &self.control_handle
8293 }
8294
8295 fn drop_without_shutdown(mut self) {
8296 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8298 std::mem::forget(self);
8300 }
8301}
8302
8303impl BaseDatagramSocketGetBroadcastResponder {
8304 pub fn send(
8308 self,
8309 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8310 ) -> Result<(), fidl::Error> {
8311 let _result = self.send_raw(result);
8312 if _result.is_err() {
8313 self.control_handle.shutdown();
8314 }
8315 self.drop_without_shutdown();
8316 _result
8317 }
8318
8319 pub fn send_no_shutdown_on_err(
8321 self,
8322 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8323 ) -> Result<(), fidl::Error> {
8324 let _result = self.send_raw(result);
8325 self.drop_without_shutdown();
8326 _result
8327 }
8328
8329 fn send_raw(
8330 &self,
8331 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8332 ) -> Result<(), fidl::Error> {
8333 self.control_handle.inner.send::<fidl::encoding::ResultType<
8334 BaseSocketGetBroadcastResponse,
8335 fidl_fuchsia_posix::Errno,
8336 >>(
8337 result.map(|value| (value,)),
8338 self.tx_id,
8339 0x68796fc556f9780d,
8340 fidl::encoding::DynamicFlags::empty(),
8341 )
8342 }
8343}
8344
8345#[must_use = "FIDL methods require a response to be sent"]
8346#[derive(Debug)]
8347pub struct BaseDatagramSocketSetSendBufferResponder {
8348 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8349 tx_id: u32,
8350}
8351
8352impl std::ops::Drop for BaseDatagramSocketSetSendBufferResponder {
8356 fn drop(&mut self) {
8357 self.control_handle.shutdown();
8358 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8360 }
8361}
8362
8363impl fidl::endpoints::Responder for BaseDatagramSocketSetSendBufferResponder {
8364 type ControlHandle = BaseDatagramSocketControlHandle;
8365
8366 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8367 &self.control_handle
8368 }
8369
8370 fn drop_without_shutdown(mut self) {
8371 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8373 std::mem::forget(self);
8375 }
8376}
8377
8378impl BaseDatagramSocketSetSendBufferResponder {
8379 pub fn send(
8383 self,
8384 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8385 ) -> Result<(), fidl::Error> {
8386 let _result = self.send_raw(result);
8387 if _result.is_err() {
8388 self.control_handle.shutdown();
8389 }
8390 self.drop_without_shutdown();
8391 _result
8392 }
8393
8394 pub fn send_no_shutdown_on_err(
8396 self,
8397 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8398 ) -> Result<(), fidl::Error> {
8399 let _result = self.send_raw(result);
8400 self.drop_without_shutdown();
8401 _result
8402 }
8403
8404 fn send_raw(
8405 &self,
8406 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8407 ) -> Result<(), fidl::Error> {
8408 self.control_handle.inner.send::<fidl::encoding::ResultType<
8409 fidl::encoding::EmptyStruct,
8410 fidl_fuchsia_posix::Errno,
8411 >>(
8412 result,
8413 self.tx_id,
8414 0x756eac32d73a7a70,
8415 fidl::encoding::DynamicFlags::empty(),
8416 )
8417 }
8418}
8419
8420#[must_use = "FIDL methods require a response to be sent"]
8421#[derive(Debug)]
8422pub struct BaseDatagramSocketGetSendBufferResponder {
8423 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8424 tx_id: u32,
8425}
8426
8427impl std::ops::Drop for BaseDatagramSocketGetSendBufferResponder {
8431 fn drop(&mut self) {
8432 self.control_handle.shutdown();
8433 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8435 }
8436}
8437
8438impl fidl::endpoints::Responder for BaseDatagramSocketGetSendBufferResponder {
8439 type ControlHandle = BaseDatagramSocketControlHandle;
8440
8441 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8442 &self.control_handle
8443 }
8444
8445 fn drop_without_shutdown(mut self) {
8446 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8448 std::mem::forget(self);
8450 }
8451}
8452
8453impl BaseDatagramSocketGetSendBufferResponder {
8454 pub fn send(
8458 self,
8459 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
8460 ) -> Result<(), fidl::Error> {
8461 let _result = self.send_raw(result);
8462 if _result.is_err() {
8463 self.control_handle.shutdown();
8464 }
8465 self.drop_without_shutdown();
8466 _result
8467 }
8468
8469 pub fn send_no_shutdown_on_err(
8471 self,
8472 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
8473 ) -> Result<(), fidl::Error> {
8474 let _result = self.send_raw(result);
8475 self.drop_without_shutdown();
8476 _result
8477 }
8478
8479 fn send_raw(
8480 &self,
8481 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
8482 ) -> Result<(), fidl::Error> {
8483 self.control_handle.inner.send::<fidl::encoding::ResultType<
8484 BaseSocketGetSendBufferResponse,
8485 fidl_fuchsia_posix::Errno,
8486 >>(
8487 result.map(|value_bytes| (value_bytes,)),
8488 self.tx_id,
8489 0x78a52fd9c7b2410b,
8490 fidl::encoding::DynamicFlags::empty(),
8491 )
8492 }
8493}
8494
8495#[must_use = "FIDL methods require a response to be sent"]
8496#[derive(Debug)]
8497pub struct BaseDatagramSocketSetReceiveBufferResponder {
8498 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8499 tx_id: u32,
8500}
8501
8502impl std::ops::Drop for BaseDatagramSocketSetReceiveBufferResponder {
8506 fn drop(&mut self) {
8507 self.control_handle.shutdown();
8508 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8510 }
8511}
8512
8513impl fidl::endpoints::Responder for BaseDatagramSocketSetReceiveBufferResponder {
8514 type ControlHandle = BaseDatagramSocketControlHandle;
8515
8516 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8517 &self.control_handle
8518 }
8519
8520 fn drop_without_shutdown(mut self) {
8521 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8523 std::mem::forget(self);
8525 }
8526}
8527
8528impl BaseDatagramSocketSetReceiveBufferResponder {
8529 pub fn send(
8533 self,
8534 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8535 ) -> Result<(), fidl::Error> {
8536 let _result = self.send_raw(result);
8537 if _result.is_err() {
8538 self.control_handle.shutdown();
8539 }
8540 self.drop_without_shutdown();
8541 _result
8542 }
8543
8544 pub fn send_no_shutdown_on_err(
8546 self,
8547 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8548 ) -> Result<(), fidl::Error> {
8549 let _result = self.send_raw(result);
8550 self.drop_without_shutdown();
8551 _result
8552 }
8553
8554 fn send_raw(
8555 &self,
8556 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8557 ) -> Result<(), fidl::Error> {
8558 self.control_handle.inner.send::<fidl::encoding::ResultType<
8559 fidl::encoding::EmptyStruct,
8560 fidl_fuchsia_posix::Errno,
8561 >>(
8562 result,
8563 self.tx_id,
8564 0x6b0cf2f1919c7001,
8565 fidl::encoding::DynamicFlags::empty(),
8566 )
8567 }
8568}
8569
8570#[must_use = "FIDL methods require a response to be sent"]
8571#[derive(Debug)]
8572pub struct BaseDatagramSocketGetReceiveBufferResponder {
8573 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8574 tx_id: u32,
8575}
8576
8577impl std::ops::Drop for BaseDatagramSocketGetReceiveBufferResponder {
8581 fn drop(&mut self) {
8582 self.control_handle.shutdown();
8583 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8585 }
8586}
8587
8588impl fidl::endpoints::Responder for BaseDatagramSocketGetReceiveBufferResponder {
8589 type ControlHandle = BaseDatagramSocketControlHandle;
8590
8591 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8592 &self.control_handle
8593 }
8594
8595 fn drop_without_shutdown(mut self) {
8596 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8598 std::mem::forget(self);
8600 }
8601}
8602
8603impl BaseDatagramSocketGetReceiveBufferResponder {
8604 pub fn send(
8608 self,
8609 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
8610 ) -> Result<(), fidl::Error> {
8611 let _result = self.send_raw(result);
8612 if _result.is_err() {
8613 self.control_handle.shutdown();
8614 }
8615 self.drop_without_shutdown();
8616 _result
8617 }
8618
8619 pub fn send_no_shutdown_on_err(
8621 self,
8622 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
8623 ) -> Result<(), fidl::Error> {
8624 let _result = self.send_raw(result);
8625 self.drop_without_shutdown();
8626 _result
8627 }
8628
8629 fn send_raw(
8630 &self,
8631 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
8632 ) -> Result<(), fidl::Error> {
8633 self.control_handle.inner.send::<fidl::encoding::ResultType<
8634 BaseSocketGetReceiveBufferResponse,
8635 fidl_fuchsia_posix::Errno,
8636 >>(
8637 result.map(|value_bytes| (value_bytes,)),
8638 self.tx_id,
8639 0x14c1a4b64f709e5c,
8640 fidl::encoding::DynamicFlags::empty(),
8641 )
8642 }
8643}
8644
8645#[must_use = "FIDL methods require a response to be sent"]
8646#[derive(Debug)]
8647pub struct BaseDatagramSocketSetKeepAliveResponder {
8648 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8649 tx_id: u32,
8650}
8651
8652impl std::ops::Drop for BaseDatagramSocketSetKeepAliveResponder {
8656 fn drop(&mut self) {
8657 self.control_handle.shutdown();
8658 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8660 }
8661}
8662
8663impl fidl::endpoints::Responder for BaseDatagramSocketSetKeepAliveResponder {
8664 type ControlHandle = BaseDatagramSocketControlHandle;
8665
8666 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8667 &self.control_handle
8668 }
8669
8670 fn drop_without_shutdown(mut self) {
8671 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8673 std::mem::forget(self);
8675 }
8676}
8677
8678impl BaseDatagramSocketSetKeepAliveResponder {
8679 pub fn send(
8683 self,
8684 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8685 ) -> Result<(), fidl::Error> {
8686 let _result = self.send_raw(result);
8687 if _result.is_err() {
8688 self.control_handle.shutdown();
8689 }
8690 self.drop_without_shutdown();
8691 _result
8692 }
8693
8694 pub fn send_no_shutdown_on_err(
8696 self,
8697 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8698 ) -> Result<(), fidl::Error> {
8699 let _result = self.send_raw(result);
8700 self.drop_without_shutdown();
8701 _result
8702 }
8703
8704 fn send_raw(
8705 &self,
8706 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8707 ) -> Result<(), fidl::Error> {
8708 self.control_handle.inner.send::<fidl::encoding::ResultType<
8709 fidl::encoding::EmptyStruct,
8710 fidl_fuchsia_posix::Errno,
8711 >>(
8712 result,
8713 self.tx_id,
8714 0x572df8f0b920d2c7,
8715 fidl::encoding::DynamicFlags::empty(),
8716 )
8717 }
8718}
8719
8720#[must_use = "FIDL methods require a response to be sent"]
8721#[derive(Debug)]
8722pub struct BaseDatagramSocketGetKeepAliveResponder {
8723 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8724 tx_id: u32,
8725}
8726
8727impl std::ops::Drop for BaseDatagramSocketGetKeepAliveResponder {
8731 fn drop(&mut self) {
8732 self.control_handle.shutdown();
8733 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8735 }
8736}
8737
8738impl fidl::endpoints::Responder for BaseDatagramSocketGetKeepAliveResponder {
8739 type ControlHandle = BaseDatagramSocketControlHandle;
8740
8741 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8742 &self.control_handle
8743 }
8744
8745 fn drop_without_shutdown(mut self) {
8746 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8748 std::mem::forget(self);
8750 }
8751}
8752
8753impl BaseDatagramSocketGetKeepAliveResponder {
8754 pub fn send(
8758 self,
8759 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8760 ) -> Result<(), fidl::Error> {
8761 let _result = self.send_raw(result);
8762 if _result.is_err() {
8763 self.control_handle.shutdown();
8764 }
8765 self.drop_without_shutdown();
8766 _result
8767 }
8768
8769 pub fn send_no_shutdown_on_err(
8771 self,
8772 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8773 ) -> Result<(), fidl::Error> {
8774 let _result = self.send_raw(result);
8775 self.drop_without_shutdown();
8776 _result
8777 }
8778
8779 fn send_raw(
8780 &self,
8781 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8782 ) -> Result<(), fidl::Error> {
8783 self.control_handle.inner.send::<fidl::encoding::ResultType<
8784 BaseSocketGetKeepAliveResponse,
8785 fidl_fuchsia_posix::Errno,
8786 >>(
8787 result.map(|value| (value,)),
8788 self.tx_id,
8789 0x2dd29d3215f2c9d2,
8790 fidl::encoding::DynamicFlags::empty(),
8791 )
8792 }
8793}
8794
8795#[must_use = "FIDL methods require a response to be sent"]
8796#[derive(Debug)]
8797pub struct BaseDatagramSocketSetOutOfBandInlineResponder {
8798 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8799 tx_id: u32,
8800}
8801
8802impl std::ops::Drop for BaseDatagramSocketSetOutOfBandInlineResponder {
8806 fn drop(&mut self) {
8807 self.control_handle.shutdown();
8808 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8810 }
8811}
8812
8813impl fidl::endpoints::Responder for BaseDatagramSocketSetOutOfBandInlineResponder {
8814 type ControlHandle = BaseDatagramSocketControlHandle;
8815
8816 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8817 &self.control_handle
8818 }
8819
8820 fn drop_without_shutdown(mut self) {
8821 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8823 std::mem::forget(self);
8825 }
8826}
8827
8828impl BaseDatagramSocketSetOutOfBandInlineResponder {
8829 pub fn send(
8833 self,
8834 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8835 ) -> Result<(), fidl::Error> {
8836 let _result = self.send_raw(result);
8837 if _result.is_err() {
8838 self.control_handle.shutdown();
8839 }
8840 self.drop_without_shutdown();
8841 _result
8842 }
8843
8844 pub fn send_no_shutdown_on_err(
8846 self,
8847 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8848 ) -> Result<(), fidl::Error> {
8849 let _result = self.send_raw(result);
8850 self.drop_without_shutdown();
8851 _result
8852 }
8853
8854 fn send_raw(
8855 &self,
8856 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8857 ) -> Result<(), fidl::Error> {
8858 self.control_handle.inner.send::<fidl::encoding::ResultType<
8859 fidl::encoding::EmptyStruct,
8860 fidl_fuchsia_posix::Errno,
8861 >>(
8862 result,
8863 self.tx_id,
8864 0x3ecb49968bee439,
8865 fidl::encoding::DynamicFlags::empty(),
8866 )
8867 }
8868}
8869
8870#[must_use = "FIDL methods require a response to be sent"]
8871#[derive(Debug)]
8872pub struct BaseDatagramSocketGetOutOfBandInlineResponder {
8873 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8874 tx_id: u32,
8875}
8876
8877impl std::ops::Drop for BaseDatagramSocketGetOutOfBandInlineResponder {
8881 fn drop(&mut self) {
8882 self.control_handle.shutdown();
8883 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8885 }
8886}
8887
8888impl fidl::endpoints::Responder for BaseDatagramSocketGetOutOfBandInlineResponder {
8889 type ControlHandle = BaseDatagramSocketControlHandle;
8890
8891 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8892 &self.control_handle
8893 }
8894
8895 fn drop_without_shutdown(mut self) {
8896 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8898 std::mem::forget(self);
8900 }
8901}
8902
8903impl BaseDatagramSocketGetOutOfBandInlineResponder {
8904 pub fn send(
8908 self,
8909 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8910 ) -> Result<(), fidl::Error> {
8911 let _result = self.send_raw(result);
8912 if _result.is_err() {
8913 self.control_handle.shutdown();
8914 }
8915 self.drop_without_shutdown();
8916 _result
8917 }
8918
8919 pub fn send_no_shutdown_on_err(
8921 self,
8922 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8923 ) -> Result<(), fidl::Error> {
8924 let _result = self.send_raw(result);
8925 self.drop_without_shutdown();
8926 _result
8927 }
8928
8929 fn send_raw(
8930 &self,
8931 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8932 ) -> Result<(), fidl::Error> {
8933 self.control_handle.inner.send::<fidl::encoding::ResultType<
8934 BaseSocketGetOutOfBandInlineResponse,
8935 fidl_fuchsia_posix::Errno,
8936 >>(
8937 result.map(|value| (value,)),
8938 self.tx_id,
8939 0x348c1ab3aeca1745,
8940 fidl::encoding::DynamicFlags::empty(),
8941 )
8942 }
8943}
8944
8945#[must_use = "FIDL methods require a response to be sent"]
8946#[derive(Debug)]
8947pub struct BaseDatagramSocketSetNoCheckResponder {
8948 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8949 tx_id: u32,
8950}
8951
8952impl std::ops::Drop for BaseDatagramSocketSetNoCheckResponder {
8956 fn drop(&mut self) {
8957 self.control_handle.shutdown();
8958 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8960 }
8961}
8962
8963impl fidl::endpoints::Responder for BaseDatagramSocketSetNoCheckResponder {
8964 type ControlHandle = BaseDatagramSocketControlHandle;
8965
8966 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8967 &self.control_handle
8968 }
8969
8970 fn drop_without_shutdown(mut self) {
8971 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8973 std::mem::forget(self);
8975 }
8976}
8977
8978impl BaseDatagramSocketSetNoCheckResponder {
8979 pub fn send(
8983 self,
8984 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8985 ) -> Result<(), fidl::Error> {
8986 let _result = self.send_raw(result);
8987 if _result.is_err() {
8988 self.control_handle.shutdown();
8989 }
8990 self.drop_without_shutdown();
8991 _result
8992 }
8993
8994 pub fn send_no_shutdown_on_err(
8996 self,
8997 mut result: Result<(), fidl_fuchsia_posix::Errno>,
8998 ) -> Result<(), fidl::Error> {
8999 let _result = self.send_raw(result);
9000 self.drop_without_shutdown();
9001 _result
9002 }
9003
9004 fn send_raw(
9005 &self,
9006 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9007 ) -> Result<(), fidl::Error> {
9008 self.control_handle.inner.send::<fidl::encoding::ResultType<
9009 fidl::encoding::EmptyStruct,
9010 fidl_fuchsia_posix::Errno,
9011 >>(
9012 result,
9013 self.tx_id,
9014 0x6bbf00c53a4c78c2,
9015 fidl::encoding::DynamicFlags::empty(),
9016 )
9017 }
9018}
9019
9020#[must_use = "FIDL methods require a response to be sent"]
9021#[derive(Debug)]
9022pub struct BaseDatagramSocketGetNoCheckResponder {
9023 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9024 tx_id: u32,
9025}
9026
9027impl std::ops::Drop for BaseDatagramSocketGetNoCheckResponder {
9031 fn drop(&mut self) {
9032 self.control_handle.shutdown();
9033 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9035 }
9036}
9037
9038impl fidl::endpoints::Responder for BaseDatagramSocketGetNoCheckResponder {
9039 type ControlHandle = BaseDatagramSocketControlHandle;
9040
9041 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9042 &self.control_handle
9043 }
9044
9045 fn drop_without_shutdown(mut self) {
9046 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9048 std::mem::forget(self);
9050 }
9051}
9052
9053impl BaseDatagramSocketGetNoCheckResponder {
9054 pub fn send(
9058 self,
9059 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9060 ) -> Result<(), fidl::Error> {
9061 let _result = self.send_raw(result);
9062 if _result.is_err() {
9063 self.control_handle.shutdown();
9064 }
9065 self.drop_without_shutdown();
9066 _result
9067 }
9068
9069 pub fn send_no_shutdown_on_err(
9071 self,
9072 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9073 ) -> Result<(), fidl::Error> {
9074 let _result = self.send_raw(result);
9075 self.drop_without_shutdown();
9076 _result
9077 }
9078
9079 fn send_raw(
9080 &self,
9081 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9082 ) -> Result<(), fidl::Error> {
9083 self.control_handle.inner.send::<fidl::encoding::ResultType<
9084 BaseSocketGetNoCheckResponse,
9085 fidl_fuchsia_posix::Errno,
9086 >>(
9087 result.map(|value| (value,)),
9088 self.tx_id,
9089 0x2cd4249286417694,
9090 fidl::encoding::DynamicFlags::empty(),
9091 )
9092 }
9093}
9094
9095#[must_use = "FIDL methods require a response to be sent"]
9096#[derive(Debug)]
9097pub struct BaseDatagramSocketSetLingerResponder {
9098 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9099 tx_id: u32,
9100}
9101
9102impl std::ops::Drop for BaseDatagramSocketSetLingerResponder {
9106 fn drop(&mut self) {
9107 self.control_handle.shutdown();
9108 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9110 }
9111}
9112
9113impl fidl::endpoints::Responder for BaseDatagramSocketSetLingerResponder {
9114 type ControlHandle = BaseDatagramSocketControlHandle;
9115
9116 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9117 &self.control_handle
9118 }
9119
9120 fn drop_without_shutdown(mut self) {
9121 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9123 std::mem::forget(self);
9125 }
9126}
9127
9128impl BaseDatagramSocketSetLingerResponder {
9129 pub fn send(
9133 self,
9134 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9135 ) -> Result<(), fidl::Error> {
9136 let _result = self.send_raw(result);
9137 if _result.is_err() {
9138 self.control_handle.shutdown();
9139 }
9140 self.drop_without_shutdown();
9141 _result
9142 }
9143
9144 pub fn send_no_shutdown_on_err(
9146 self,
9147 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9148 ) -> Result<(), fidl::Error> {
9149 let _result = self.send_raw(result);
9150 self.drop_without_shutdown();
9151 _result
9152 }
9153
9154 fn send_raw(
9155 &self,
9156 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9157 ) -> Result<(), fidl::Error> {
9158 self.control_handle.inner.send::<fidl::encoding::ResultType<
9159 fidl::encoding::EmptyStruct,
9160 fidl_fuchsia_posix::Errno,
9161 >>(
9162 result,
9163 self.tx_id,
9164 0x45386351246e998e,
9165 fidl::encoding::DynamicFlags::empty(),
9166 )
9167 }
9168}
9169
9170#[must_use = "FIDL methods require a response to be sent"]
9171#[derive(Debug)]
9172pub struct BaseDatagramSocketGetLingerResponder {
9173 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9174 tx_id: u32,
9175}
9176
9177impl std::ops::Drop for BaseDatagramSocketGetLingerResponder {
9181 fn drop(&mut self) {
9182 self.control_handle.shutdown();
9183 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9185 }
9186}
9187
9188impl fidl::endpoints::Responder for BaseDatagramSocketGetLingerResponder {
9189 type ControlHandle = BaseDatagramSocketControlHandle;
9190
9191 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9192 &self.control_handle
9193 }
9194
9195 fn drop_without_shutdown(mut self) {
9196 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9198 std::mem::forget(self);
9200 }
9201}
9202
9203impl BaseDatagramSocketGetLingerResponder {
9204 pub fn send(
9208 self,
9209 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
9210 ) -> Result<(), fidl::Error> {
9211 let _result = self.send_raw(result);
9212 if _result.is_err() {
9213 self.control_handle.shutdown();
9214 }
9215 self.drop_without_shutdown();
9216 _result
9217 }
9218
9219 pub fn send_no_shutdown_on_err(
9221 self,
9222 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
9223 ) -> Result<(), fidl::Error> {
9224 let _result = self.send_raw(result);
9225 self.drop_without_shutdown();
9226 _result
9227 }
9228
9229 fn send_raw(
9230 &self,
9231 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
9232 ) -> Result<(), fidl::Error> {
9233 self.control_handle.inner.send::<fidl::encoding::ResultType<
9234 BaseSocketGetLingerResponse,
9235 fidl_fuchsia_posix::Errno,
9236 >>(
9237 result,
9238 self.tx_id,
9239 0x48eb20fc5ccb0e45,
9240 fidl::encoding::DynamicFlags::empty(),
9241 )
9242 }
9243}
9244
9245#[must_use = "FIDL methods require a response to be sent"]
9246#[derive(Debug)]
9247pub struct BaseDatagramSocketSetReusePortResponder {
9248 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9249 tx_id: u32,
9250}
9251
9252impl std::ops::Drop for BaseDatagramSocketSetReusePortResponder {
9256 fn drop(&mut self) {
9257 self.control_handle.shutdown();
9258 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9260 }
9261}
9262
9263impl fidl::endpoints::Responder for BaseDatagramSocketSetReusePortResponder {
9264 type ControlHandle = BaseDatagramSocketControlHandle;
9265
9266 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9267 &self.control_handle
9268 }
9269
9270 fn drop_without_shutdown(mut self) {
9271 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9273 std::mem::forget(self);
9275 }
9276}
9277
9278impl BaseDatagramSocketSetReusePortResponder {
9279 pub fn send(
9283 self,
9284 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9285 ) -> Result<(), fidl::Error> {
9286 let _result = self.send_raw(result);
9287 if _result.is_err() {
9288 self.control_handle.shutdown();
9289 }
9290 self.drop_without_shutdown();
9291 _result
9292 }
9293
9294 pub fn send_no_shutdown_on_err(
9296 self,
9297 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9298 ) -> Result<(), fidl::Error> {
9299 let _result = self.send_raw(result);
9300 self.drop_without_shutdown();
9301 _result
9302 }
9303
9304 fn send_raw(
9305 &self,
9306 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9307 ) -> Result<(), fidl::Error> {
9308 self.control_handle.inner.send::<fidl::encoding::ResultType<
9309 fidl::encoding::EmptyStruct,
9310 fidl_fuchsia_posix::Errno,
9311 >>(
9312 result,
9313 self.tx_id,
9314 0x24dd3e5cb36d9ccb,
9315 fidl::encoding::DynamicFlags::empty(),
9316 )
9317 }
9318}
9319
9320#[must_use = "FIDL methods require a response to be sent"]
9321#[derive(Debug)]
9322pub struct BaseDatagramSocketGetReusePortResponder {
9323 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9324 tx_id: u32,
9325}
9326
9327impl std::ops::Drop for BaseDatagramSocketGetReusePortResponder {
9331 fn drop(&mut self) {
9332 self.control_handle.shutdown();
9333 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9335 }
9336}
9337
9338impl fidl::endpoints::Responder for BaseDatagramSocketGetReusePortResponder {
9339 type ControlHandle = BaseDatagramSocketControlHandle;
9340
9341 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9342 &self.control_handle
9343 }
9344
9345 fn drop_without_shutdown(mut self) {
9346 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9348 std::mem::forget(self);
9350 }
9351}
9352
9353impl BaseDatagramSocketGetReusePortResponder {
9354 pub fn send(
9358 self,
9359 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9360 ) -> Result<(), fidl::Error> {
9361 let _result = self.send_raw(result);
9362 if _result.is_err() {
9363 self.control_handle.shutdown();
9364 }
9365 self.drop_without_shutdown();
9366 _result
9367 }
9368
9369 pub fn send_no_shutdown_on_err(
9371 self,
9372 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9373 ) -> Result<(), fidl::Error> {
9374 let _result = self.send_raw(result);
9375 self.drop_without_shutdown();
9376 _result
9377 }
9378
9379 fn send_raw(
9380 &self,
9381 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9382 ) -> Result<(), fidl::Error> {
9383 self.control_handle.inner.send::<fidl::encoding::ResultType<
9384 BaseSocketGetReusePortResponse,
9385 fidl_fuchsia_posix::Errno,
9386 >>(
9387 result.map(|value| (value,)),
9388 self.tx_id,
9389 0x7a112c1ab54ff828,
9390 fidl::encoding::DynamicFlags::empty(),
9391 )
9392 }
9393}
9394
9395#[must_use = "FIDL methods require a response to be sent"]
9396#[derive(Debug)]
9397pub struct BaseDatagramSocketGetAcceptConnResponder {
9398 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9399 tx_id: u32,
9400}
9401
9402impl std::ops::Drop for BaseDatagramSocketGetAcceptConnResponder {
9406 fn drop(&mut self) {
9407 self.control_handle.shutdown();
9408 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9410 }
9411}
9412
9413impl fidl::endpoints::Responder for BaseDatagramSocketGetAcceptConnResponder {
9414 type ControlHandle = BaseDatagramSocketControlHandle;
9415
9416 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9417 &self.control_handle
9418 }
9419
9420 fn drop_without_shutdown(mut self) {
9421 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9423 std::mem::forget(self);
9425 }
9426}
9427
9428impl BaseDatagramSocketGetAcceptConnResponder {
9429 pub fn send(
9433 self,
9434 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9435 ) -> Result<(), fidl::Error> {
9436 let _result = self.send_raw(result);
9437 if _result.is_err() {
9438 self.control_handle.shutdown();
9439 }
9440 self.drop_without_shutdown();
9441 _result
9442 }
9443
9444 pub fn send_no_shutdown_on_err(
9446 self,
9447 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9448 ) -> Result<(), fidl::Error> {
9449 let _result = self.send_raw(result);
9450 self.drop_without_shutdown();
9451 _result
9452 }
9453
9454 fn send_raw(
9455 &self,
9456 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9457 ) -> Result<(), fidl::Error> {
9458 self.control_handle.inner.send::<fidl::encoding::ResultType<
9459 BaseSocketGetAcceptConnResponse,
9460 fidl_fuchsia_posix::Errno,
9461 >>(
9462 result.map(|value| (value,)),
9463 self.tx_id,
9464 0x67ce6db6c2ec8966,
9465 fidl::encoding::DynamicFlags::empty(),
9466 )
9467 }
9468}
9469
9470#[must_use = "FIDL methods require a response to be sent"]
9471#[derive(Debug)]
9472pub struct BaseDatagramSocketSetBindToDeviceResponder {
9473 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9474 tx_id: u32,
9475}
9476
9477impl std::ops::Drop for BaseDatagramSocketSetBindToDeviceResponder {
9481 fn drop(&mut self) {
9482 self.control_handle.shutdown();
9483 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9485 }
9486}
9487
9488impl fidl::endpoints::Responder for BaseDatagramSocketSetBindToDeviceResponder {
9489 type ControlHandle = BaseDatagramSocketControlHandle;
9490
9491 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9492 &self.control_handle
9493 }
9494
9495 fn drop_without_shutdown(mut self) {
9496 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9498 std::mem::forget(self);
9500 }
9501}
9502
9503impl BaseDatagramSocketSetBindToDeviceResponder {
9504 pub fn send(
9508 self,
9509 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9510 ) -> Result<(), fidl::Error> {
9511 let _result = self.send_raw(result);
9512 if _result.is_err() {
9513 self.control_handle.shutdown();
9514 }
9515 self.drop_without_shutdown();
9516 _result
9517 }
9518
9519 pub fn send_no_shutdown_on_err(
9521 self,
9522 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9523 ) -> Result<(), fidl::Error> {
9524 let _result = self.send_raw(result);
9525 self.drop_without_shutdown();
9526 _result
9527 }
9528
9529 fn send_raw(
9530 &self,
9531 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9532 ) -> Result<(), fidl::Error> {
9533 self.control_handle.inner.send::<fidl::encoding::ResultType<
9534 fidl::encoding::EmptyStruct,
9535 fidl_fuchsia_posix::Errno,
9536 >>(
9537 result,
9538 self.tx_id,
9539 0x2118b483f28aafc4,
9540 fidl::encoding::DynamicFlags::empty(),
9541 )
9542 }
9543}
9544
9545#[must_use = "FIDL methods require a response to be sent"]
9546#[derive(Debug)]
9547pub struct BaseDatagramSocketGetBindToDeviceResponder {
9548 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9549 tx_id: u32,
9550}
9551
9552impl std::ops::Drop for BaseDatagramSocketGetBindToDeviceResponder {
9556 fn drop(&mut self) {
9557 self.control_handle.shutdown();
9558 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9560 }
9561}
9562
9563impl fidl::endpoints::Responder for BaseDatagramSocketGetBindToDeviceResponder {
9564 type ControlHandle = BaseDatagramSocketControlHandle;
9565
9566 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9567 &self.control_handle
9568 }
9569
9570 fn drop_without_shutdown(mut self) {
9571 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9573 std::mem::forget(self);
9575 }
9576}
9577
9578impl BaseDatagramSocketGetBindToDeviceResponder {
9579 pub fn send(
9583 self,
9584 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
9585 ) -> Result<(), fidl::Error> {
9586 let _result = self.send_raw(result);
9587 if _result.is_err() {
9588 self.control_handle.shutdown();
9589 }
9590 self.drop_without_shutdown();
9591 _result
9592 }
9593
9594 pub fn send_no_shutdown_on_err(
9596 self,
9597 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
9598 ) -> Result<(), fidl::Error> {
9599 let _result = self.send_raw(result);
9600 self.drop_without_shutdown();
9601 _result
9602 }
9603
9604 fn send_raw(
9605 &self,
9606 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
9607 ) -> Result<(), fidl::Error> {
9608 self.control_handle.inner.send::<fidl::encoding::ResultType<
9609 BaseSocketGetBindToDeviceResponse,
9610 fidl_fuchsia_posix::Errno,
9611 >>(
9612 result.map(|value| (value,)),
9613 self.tx_id,
9614 0x1ab1fbf0ef7906c8,
9615 fidl::encoding::DynamicFlags::empty(),
9616 )
9617 }
9618}
9619
9620#[must_use = "FIDL methods require a response to be sent"]
9621#[derive(Debug)]
9622pub struct BaseDatagramSocketSetBindToInterfaceIndexResponder {
9623 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9624 tx_id: u32,
9625}
9626
9627impl std::ops::Drop for BaseDatagramSocketSetBindToInterfaceIndexResponder {
9631 fn drop(&mut self) {
9632 self.control_handle.shutdown();
9633 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9635 }
9636}
9637
9638impl fidl::endpoints::Responder for BaseDatagramSocketSetBindToInterfaceIndexResponder {
9639 type ControlHandle = BaseDatagramSocketControlHandle;
9640
9641 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9642 &self.control_handle
9643 }
9644
9645 fn drop_without_shutdown(mut self) {
9646 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9648 std::mem::forget(self);
9650 }
9651}
9652
9653impl BaseDatagramSocketSetBindToInterfaceIndexResponder {
9654 pub fn send(
9658 self,
9659 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9660 ) -> Result<(), fidl::Error> {
9661 let _result = self.send_raw(result);
9662 if _result.is_err() {
9663 self.control_handle.shutdown();
9664 }
9665 self.drop_without_shutdown();
9666 _result
9667 }
9668
9669 pub fn send_no_shutdown_on_err(
9671 self,
9672 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9673 ) -> Result<(), fidl::Error> {
9674 let _result = self.send_raw(result);
9675 self.drop_without_shutdown();
9676 _result
9677 }
9678
9679 fn send_raw(
9680 &self,
9681 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9682 ) -> Result<(), fidl::Error> {
9683 self.control_handle.inner.send::<fidl::encoding::ResultType<
9684 fidl::encoding::EmptyStruct,
9685 fidl_fuchsia_posix::Errno,
9686 >>(
9687 result,
9688 self.tx_id,
9689 0x6e387a0def00821,
9690 fidl::encoding::DynamicFlags::empty(),
9691 )
9692 }
9693}
9694
9695#[must_use = "FIDL methods require a response to be sent"]
9696#[derive(Debug)]
9697pub struct BaseDatagramSocketGetBindToInterfaceIndexResponder {
9698 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9699 tx_id: u32,
9700}
9701
9702impl std::ops::Drop for BaseDatagramSocketGetBindToInterfaceIndexResponder {
9706 fn drop(&mut self) {
9707 self.control_handle.shutdown();
9708 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9710 }
9711}
9712
9713impl fidl::endpoints::Responder for BaseDatagramSocketGetBindToInterfaceIndexResponder {
9714 type ControlHandle = BaseDatagramSocketControlHandle;
9715
9716 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9717 &self.control_handle
9718 }
9719
9720 fn drop_without_shutdown(mut self) {
9721 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9723 std::mem::forget(self);
9725 }
9726}
9727
9728impl BaseDatagramSocketGetBindToInterfaceIndexResponder {
9729 pub fn send(
9733 self,
9734 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
9735 ) -> Result<(), fidl::Error> {
9736 let _result = self.send_raw(result);
9737 if _result.is_err() {
9738 self.control_handle.shutdown();
9739 }
9740 self.drop_without_shutdown();
9741 _result
9742 }
9743
9744 pub fn send_no_shutdown_on_err(
9746 self,
9747 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
9748 ) -> Result<(), fidl::Error> {
9749 let _result = self.send_raw(result);
9750 self.drop_without_shutdown();
9751 _result
9752 }
9753
9754 fn send_raw(
9755 &self,
9756 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
9757 ) -> Result<(), fidl::Error> {
9758 self.control_handle.inner.send::<fidl::encoding::ResultType<
9759 BaseSocketGetBindToInterfaceIndexResponse,
9760 fidl_fuchsia_posix::Errno,
9761 >>(
9762 result.map(|value| (value,)),
9763 self.tx_id,
9764 0x59c31dd3e3078295,
9765 fidl::encoding::DynamicFlags::empty(),
9766 )
9767 }
9768}
9769
9770#[must_use = "FIDL methods require a response to be sent"]
9771#[derive(Debug)]
9772pub struct BaseDatagramSocketSetTimestampResponder {
9773 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9774 tx_id: u32,
9775}
9776
9777impl std::ops::Drop for BaseDatagramSocketSetTimestampResponder {
9781 fn drop(&mut self) {
9782 self.control_handle.shutdown();
9783 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9785 }
9786}
9787
9788impl fidl::endpoints::Responder for BaseDatagramSocketSetTimestampResponder {
9789 type ControlHandle = BaseDatagramSocketControlHandle;
9790
9791 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9792 &self.control_handle
9793 }
9794
9795 fn drop_without_shutdown(mut self) {
9796 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9798 std::mem::forget(self);
9800 }
9801}
9802
9803impl BaseDatagramSocketSetTimestampResponder {
9804 pub fn send(
9808 self,
9809 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9810 ) -> Result<(), fidl::Error> {
9811 let _result = self.send_raw(result);
9812 if _result.is_err() {
9813 self.control_handle.shutdown();
9814 }
9815 self.drop_without_shutdown();
9816 _result
9817 }
9818
9819 pub fn send_no_shutdown_on_err(
9821 self,
9822 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9823 ) -> Result<(), fidl::Error> {
9824 let _result = self.send_raw(result);
9825 self.drop_without_shutdown();
9826 _result
9827 }
9828
9829 fn send_raw(
9830 &self,
9831 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9832 ) -> Result<(), fidl::Error> {
9833 self.control_handle.inner.send::<fidl::encoding::ResultType<
9834 fidl::encoding::EmptyStruct,
9835 fidl_fuchsia_posix::Errno,
9836 >>(
9837 result,
9838 self.tx_id,
9839 0x285d6516c263d839,
9840 fidl::encoding::DynamicFlags::empty(),
9841 )
9842 }
9843}
9844
9845#[must_use = "FIDL methods require a response to be sent"]
9846#[derive(Debug)]
9847pub struct BaseDatagramSocketGetTimestampResponder {
9848 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9849 tx_id: u32,
9850}
9851
9852impl std::ops::Drop for BaseDatagramSocketGetTimestampResponder {
9856 fn drop(&mut self) {
9857 self.control_handle.shutdown();
9858 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9860 }
9861}
9862
9863impl fidl::endpoints::Responder for BaseDatagramSocketGetTimestampResponder {
9864 type ControlHandle = BaseDatagramSocketControlHandle;
9865
9866 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9867 &self.control_handle
9868 }
9869
9870 fn drop_without_shutdown(mut self) {
9871 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9873 std::mem::forget(self);
9875 }
9876}
9877
9878impl BaseDatagramSocketGetTimestampResponder {
9879 pub fn send(
9883 self,
9884 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
9885 ) -> Result<(), fidl::Error> {
9886 let _result = self.send_raw(result);
9887 if _result.is_err() {
9888 self.control_handle.shutdown();
9889 }
9890 self.drop_without_shutdown();
9891 _result
9892 }
9893
9894 pub fn send_no_shutdown_on_err(
9896 self,
9897 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
9898 ) -> Result<(), fidl::Error> {
9899 let _result = self.send_raw(result);
9900 self.drop_without_shutdown();
9901 _result
9902 }
9903
9904 fn send_raw(
9905 &self,
9906 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
9907 ) -> Result<(), fidl::Error> {
9908 self.control_handle.inner.send::<fidl::encoding::ResultType<
9909 BaseSocketGetTimestampResponse,
9910 fidl_fuchsia_posix::Errno,
9911 >>(
9912 result.map(|value| (value,)),
9913 self.tx_id,
9914 0x49f2fffbbcc2bd27,
9915 fidl::encoding::DynamicFlags::empty(),
9916 )
9917 }
9918}
9919
9920#[must_use = "FIDL methods require a response to be sent"]
9921#[derive(Debug)]
9922pub struct BaseDatagramSocketSetMarkResponder {
9923 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9924 tx_id: u32,
9925}
9926
9927impl std::ops::Drop for BaseDatagramSocketSetMarkResponder {
9931 fn drop(&mut self) {
9932 self.control_handle.shutdown();
9933 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9935 }
9936}
9937
9938impl fidl::endpoints::Responder for BaseDatagramSocketSetMarkResponder {
9939 type ControlHandle = BaseDatagramSocketControlHandle;
9940
9941 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9942 &self.control_handle
9943 }
9944
9945 fn drop_without_shutdown(mut self) {
9946 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9948 std::mem::forget(self);
9950 }
9951}
9952
9953impl BaseDatagramSocketSetMarkResponder {
9954 pub fn send(
9958 self,
9959 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9960 ) -> Result<(), fidl::Error> {
9961 let _result = self.send_raw(result);
9962 if _result.is_err() {
9963 self.control_handle.shutdown();
9964 }
9965 self.drop_without_shutdown();
9966 _result
9967 }
9968
9969 pub fn send_no_shutdown_on_err(
9971 self,
9972 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9973 ) -> Result<(), fidl::Error> {
9974 let _result = self.send_raw(result);
9975 self.drop_without_shutdown();
9976 _result
9977 }
9978
9979 fn send_raw(
9980 &self,
9981 mut result: Result<(), fidl_fuchsia_posix::Errno>,
9982 ) -> Result<(), fidl::Error> {
9983 self.control_handle.inner.send::<fidl::encoding::ResultType<
9984 fidl::encoding::EmptyStruct,
9985 fidl_fuchsia_posix::Errno,
9986 >>(
9987 result,
9988 self.tx_id,
9989 0x6ead6de09f653236,
9990 fidl::encoding::DynamicFlags::empty(),
9991 )
9992 }
9993}
9994
9995#[must_use = "FIDL methods require a response to be sent"]
9996#[derive(Debug)]
9997pub struct BaseDatagramSocketGetMarkResponder {
9998 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9999 tx_id: u32,
10000}
10001
10002impl std::ops::Drop for BaseDatagramSocketGetMarkResponder {
10006 fn drop(&mut self) {
10007 self.control_handle.shutdown();
10008 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10010 }
10011}
10012
10013impl fidl::endpoints::Responder for BaseDatagramSocketGetMarkResponder {
10014 type ControlHandle = BaseDatagramSocketControlHandle;
10015
10016 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10017 &self.control_handle
10018 }
10019
10020 fn drop_without_shutdown(mut self) {
10021 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10023 std::mem::forget(self);
10025 }
10026}
10027
10028impl BaseDatagramSocketGetMarkResponder {
10029 pub fn send(
10033 self,
10034 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
10035 ) -> Result<(), fidl::Error> {
10036 let _result = self.send_raw(result);
10037 if _result.is_err() {
10038 self.control_handle.shutdown();
10039 }
10040 self.drop_without_shutdown();
10041 _result
10042 }
10043
10044 pub fn send_no_shutdown_on_err(
10046 self,
10047 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
10048 ) -> Result<(), fidl::Error> {
10049 let _result = self.send_raw(result);
10050 self.drop_without_shutdown();
10051 _result
10052 }
10053
10054 fn send_raw(
10055 &self,
10056 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
10057 ) -> Result<(), fidl::Error> {
10058 self.control_handle.inner.send::<fidl::encoding::ResultType<
10059 BaseSocketGetMarkResponse,
10060 fidl_fuchsia_posix::Errno,
10061 >>(
10062 result.map(|mark| (mark,)),
10063 self.tx_id,
10064 0x57a2752c61d93d47,
10065 fidl::encoding::DynamicFlags::empty(),
10066 )
10067 }
10068}
10069
10070#[must_use = "FIDL methods require a response to be sent"]
10071#[derive(Debug)]
10072pub struct BaseDatagramSocketBindResponder {
10073 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10074 tx_id: u32,
10075}
10076
10077impl std::ops::Drop for BaseDatagramSocketBindResponder {
10081 fn drop(&mut self) {
10082 self.control_handle.shutdown();
10083 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10085 }
10086}
10087
10088impl fidl::endpoints::Responder for BaseDatagramSocketBindResponder {
10089 type ControlHandle = BaseDatagramSocketControlHandle;
10090
10091 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10092 &self.control_handle
10093 }
10094
10095 fn drop_without_shutdown(mut self) {
10096 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10098 std::mem::forget(self);
10100 }
10101}
10102
10103impl BaseDatagramSocketBindResponder {
10104 pub fn send(
10108 self,
10109 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10110 ) -> Result<(), fidl::Error> {
10111 let _result = self.send_raw(result);
10112 if _result.is_err() {
10113 self.control_handle.shutdown();
10114 }
10115 self.drop_without_shutdown();
10116 _result
10117 }
10118
10119 pub fn send_no_shutdown_on_err(
10121 self,
10122 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10123 ) -> Result<(), fidl::Error> {
10124 let _result = self.send_raw(result);
10125 self.drop_without_shutdown();
10126 _result
10127 }
10128
10129 fn send_raw(
10130 &self,
10131 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10132 ) -> Result<(), fidl::Error> {
10133 self.control_handle.inner.send::<fidl::encoding::ResultType<
10134 fidl::encoding::EmptyStruct,
10135 fidl_fuchsia_posix::Errno,
10136 >>(
10137 result,
10138 self.tx_id,
10139 0x4bc6400ae92125d,
10140 fidl::encoding::DynamicFlags::empty(),
10141 )
10142 }
10143}
10144
10145#[must_use = "FIDL methods require a response to be sent"]
10146#[derive(Debug)]
10147pub struct BaseDatagramSocketConnectResponder {
10148 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10149 tx_id: u32,
10150}
10151
10152impl std::ops::Drop for BaseDatagramSocketConnectResponder {
10156 fn drop(&mut self) {
10157 self.control_handle.shutdown();
10158 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10160 }
10161}
10162
10163impl fidl::endpoints::Responder for BaseDatagramSocketConnectResponder {
10164 type ControlHandle = BaseDatagramSocketControlHandle;
10165
10166 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10167 &self.control_handle
10168 }
10169
10170 fn drop_without_shutdown(mut self) {
10171 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10173 std::mem::forget(self);
10175 }
10176}
10177
10178impl BaseDatagramSocketConnectResponder {
10179 pub fn send(
10183 self,
10184 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10185 ) -> Result<(), fidl::Error> {
10186 let _result = self.send_raw(result);
10187 if _result.is_err() {
10188 self.control_handle.shutdown();
10189 }
10190 self.drop_without_shutdown();
10191 _result
10192 }
10193
10194 pub fn send_no_shutdown_on_err(
10196 self,
10197 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10198 ) -> Result<(), fidl::Error> {
10199 let _result = self.send_raw(result);
10200 self.drop_without_shutdown();
10201 _result
10202 }
10203
10204 fn send_raw(
10205 &self,
10206 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10207 ) -> Result<(), fidl::Error> {
10208 self.control_handle.inner.send::<fidl::encoding::ResultType<
10209 fidl::encoding::EmptyStruct,
10210 fidl_fuchsia_posix::Errno,
10211 >>(
10212 result,
10213 self.tx_id,
10214 0x5f05f19bfdd38871,
10215 fidl::encoding::DynamicFlags::empty(),
10216 )
10217 }
10218}
10219
10220#[must_use = "FIDL methods require a response to be sent"]
10221#[derive(Debug)]
10222pub struct BaseDatagramSocketDisconnectResponder {
10223 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10224 tx_id: u32,
10225}
10226
10227impl std::ops::Drop for BaseDatagramSocketDisconnectResponder {
10231 fn drop(&mut self) {
10232 self.control_handle.shutdown();
10233 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10235 }
10236}
10237
10238impl fidl::endpoints::Responder for BaseDatagramSocketDisconnectResponder {
10239 type ControlHandle = BaseDatagramSocketControlHandle;
10240
10241 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10242 &self.control_handle
10243 }
10244
10245 fn drop_without_shutdown(mut self) {
10246 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10248 std::mem::forget(self);
10250 }
10251}
10252
10253impl BaseDatagramSocketDisconnectResponder {
10254 pub fn send(
10258 self,
10259 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10260 ) -> Result<(), fidl::Error> {
10261 let _result = self.send_raw(result);
10262 if _result.is_err() {
10263 self.control_handle.shutdown();
10264 }
10265 self.drop_without_shutdown();
10266 _result
10267 }
10268
10269 pub fn send_no_shutdown_on_err(
10271 self,
10272 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10273 ) -> Result<(), fidl::Error> {
10274 let _result = self.send_raw(result);
10275 self.drop_without_shutdown();
10276 _result
10277 }
10278
10279 fn send_raw(
10280 &self,
10281 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10282 ) -> Result<(), fidl::Error> {
10283 self.control_handle.inner.send::<fidl::encoding::ResultType<
10284 fidl::encoding::EmptyStruct,
10285 fidl_fuchsia_posix::Errno,
10286 >>(
10287 result,
10288 self.tx_id,
10289 0x74e63b91f7b29b2,
10290 fidl::encoding::DynamicFlags::empty(),
10291 )
10292 }
10293}
10294
10295#[must_use = "FIDL methods require a response to be sent"]
10296#[derive(Debug)]
10297pub struct BaseDatagramSocketGetSockNameResponder {
10298 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10299 tx_id: u32,
10300}
10301
10302impl std::ops::Drop for BaseDatagramSocketGetSockNameResponder {
10306 fn drop(&mut self) {
10307 self.control_handle.shutdown();
10308 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10310 }
10311}
10312
10313impl fidl::endpoints::Responder for BaseDatagramSocketGetSockNameResponder {
10314 type ControlHandle = BaseDatagramSocketControlHandle;
10315
10316 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10317 &self.control_handle
10318 }
10319
10320 fn drop_without_shutdown(mut self) {
10321 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10323 std::mem::forget(self);
10325 }
10326}
10327
10328impl BaseDatagramSocketGetSockNameResponder {
10329 pub fn send(
10333 self,
10334 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
10335 ) -> Result<(), fidl::Error> {
10336 let _result = self.send_raw(result);
10337 if _result.is_err() {
10338 self.control_handle.shutdown();
10339 }
10340 self.drop_without_shutdown();
10341 _result
10342 }
10343
10344 pub fn send_no_shutdown_on_err(
10346 self,
10347 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
10348 ) -> Result<(), fidl::Error> {
10349 let _result = self.send_raw(result);
10350 self.drop_without_shutdown();
10351 _result
10352 }
10353
10354 fn send_raw(
10355 &self,
10356 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
10357 ) -> Result<(), fidl::Error> {
10358 self.control_handle.inner.send::<fidl::encoding::ResultType<
10359 BaseNetworkSocketGetSockNameResponse,
10360 fidl_fuchsia_posix::Errno,
10361 >>(
10362 result.map(|addr| (addr,)),
10363 self.tx_id,
10364 0x475f23f84a1a4f85,
10365 fidl::encoding::DynamicFlags::empty(),
10366 )
10367 }
10368}
10369
10370#[must_use = "FIDL methods require a response to be sent"]
10371#[derive(Debug)]
10372pub struct BaseDatagramSocketGetPeerNameResponder {
10373 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10374 tx_id: u32,
10375}
10376
10377impl std::ops::Drop for BaseDatagramSocketGetPeerNameResponder {
10381 fn drop(&mut self) {
10382 self.control_handle.shutdown();
10383 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10385 }
10386}
10387
10388impl fidl::endpoints::Responder for BaseDatagramSocketGetPeerNameResponder {
10389 type ControlHandle = BaseDatagramSocketControlHandle;
10390
10391 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10392 &self.control_handle
10393 }
10394
10395 fn drop_without_shutdown(mut self) {
10396 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10398 std::mem::forget(self);
10400 }
10401}
10402
10403impl BaseDatagramSocketGetPeerNameResponder {
10404 pub fn send(
10408 self,
10409 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
10410 ) -> Result<(), fidl::Error> {
10411 let _result = self.send_raw(result);
10412 if _result.is_err() {
10413 self.control_handle.shutdown();
10414 }
10415 self.drop_without_shutdown();
10416 _result
10417 }
10418
10419 pub fn send_no_shutdown_on_err(
10421 self,
10422 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
10423 ) -> Result<(), fidl::Error> {
10424 let _result = self.send_raw(result);
10425 self.drop_without_shutdown();
10426 _result
10427 }
10428
10429 fn send_raw(
10430 &self,
10431 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
10432 ) -> Result<(), fidl::Error> {
10433 self.control_handle.inner.send::<fidl::encoding::ResultType<
10434 BaseNetworkSocketGetPeerNameResponse,
10435 fidl_fuchsia_posix::Errno,
10436 >>(
10437 result.map(|addr| (addr,)),
10438 self.tx_id,
10439 0x1ffecf4bd5b6432e,
10440 fidl::encoding::DynamicFlags::empty(),
10441 )
10442 }
10443}
10444
10445#[must_use = "FIDL methods require a response to be sent"]
10446#[derive(Debug)]
10447pub struct BaseDatagramSocketShutdownResponder {
10448 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10449 tx_id: u32,
10450}
10451
10452impl std::ops::Drop for BaseDatagramSocketShutdownResponder {
10456 fn drop(&mut self) {
10457 self.control_handle.shutdown();
10458 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10460 }
10461}
10462
10463impl fidl::endpoints::Responder for BaseDatagramSocketShutdownResponder {
10464 type ControlHandle = BaseDatagramSocketControlHandle;
10465
10466 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10467 &self.control_handle
10468 }
10469
10470 fn drop_without_shutdown(mut self) {
10471 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10473 std::mem::forget(self);
10475 }
10476}
10477
10478impl BaseDatagramSocketShutdownResponder {
10479 pub fn send(
10483 self,
10484 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10485 ) -> Result<(), fidl::Error> {
10486 let _result = self.send_raw(result);
10487 if _result.is_err() {
10488 self.control_handle.shutdown();
10489 }
10490 self.drop_without_shutdown();
10491 _result
10492 }
10493
10494 pub fn send_no_shutdown_on_err(
10496 self,
10497 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10498 ) -> Result<(), fidl::Error> {
10499 let _result = self.send_raw(result);
10500 self.drop_without_shutdown();
10501 _result
10502 }
10503
10504 fn send_raw(
10505 &self,
10506 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10507 ) -> Result<(), fidl::Error> {
10508 self.control_handle.inner.send::<fidl::encoding::ResultType<
10509 fidl::encoding::EmptyStruct,
10510 fidl_fuchsia_posix::Errno,
10511 >>(
10512 result,
10513 self.tx_id,
10514 0x247f38b6db68c336,
10515 fidl::encoding::DynamicFlags::empty(),
10516 )
10517 }
10518}
10519
10520#[must_use = "FIDL methods require a response to be sent"]
10521#[derive(Debug)]
10522pub struct BaseDatagramSocketSetIpTypeOfServiceResponder {
10523 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10524 tx_id: u32,
10525}
10526
10527impl std::ops::Drop for BaseDatagramSocketSetIpTypeOfServiceResponder {
10531 fn drop(&mut self) {
10532 self.control_handle.shutdown();
10533 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10535 }
10536}
10537
10538impl fidl::endpoints::Responder for BaseDatagramSocketSetIpTypeOfServiceResponder {
10539 type ControlHandle = BaseDatagramSocketControlHandle;
10540
10541 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10542 &self.control_handle
10543 }
10544
10545 fn drop_without_shutdown(mut self) {
10546 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10548 std::mem::forget(self);
10550 }
10551}
10552
10553impl BaseDatagramSocketSetIpTypeOfServiceResponder {
10554 pub fn send(
10558 self,
10559 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10560 ) -> Result<(), fidl::Error> {
10561 let _result = self.send_raw(result);
10562 if _result.is_err() {
10563 self.control_handle.shutdown();
10564 }
10565 self.drop_without_shutdown();
10566 _result
10567 }
10568
10569 pub fn send_no_shutdown_on_err(
10571 self,
10572 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10573 ) -> Result<(), fidl::Error> {
10574 let _result = self.send_raw(result);
10575 self.drop_without_shutdown();
10576 _result
10577 }
10578
10579 fn send_raw(
10580 &self,
10581 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10582 ) -> Result<(), fidl::Error> {
10583 self.control_handle.inner.send::<fidl::encoding::ResultType<
10584 fidl::encoding::EmptyStruct,
10585 fidl_fuchsia_posix::Errno,
10586 >>(
10587 result,
10588 self.tx_id,
10589 0x995c600475b6d46,
10590 fidl::encoding::DynamicFlags::empty(),
10591 )
10592 }
10593}
10594
10595#[must_use = "FIDL methods require a response to be sent"]
10596#[derive(Debug)]
10597pub struct BaseDatagramSocketGetIpTypeOfServiceResponder {
10598 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10599 tx_id: u32,
10600}
10601
10602impl std::ops::Drop for BaseDatagramSocketGetIpTypeOfServiceResponder {
10606 fn drop(&mut self) {
10607 self.control_handle.shutdown();
10608 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10610 }
10611}
10612
10613impl fidl::endpoints::Responder for BaseDatagramSocketGetIpTypeOfServiceResponder {
10614 type ControlHandle = BaseDatagramSocketControlHandle;
10615
10616 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10617 &self.control_handle
10618 }
10619
10620 fn drop_without_shutdown(mut self) {
10621 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10623 std::mem::forget(self);
10625 }
10626}
10627
10628impl BaseDatagramSocketGetIpTypeOfServiceResponder {
10629 pub fn send(
10633 self,
10634 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
10635 ) -> Result<(), fidl::Error> {
10636 let _result = self.send_raw(result);
10637 if _result.is_err() {
10638 self.control_handle.shutdown();
10639 }
10640 self.drop_without_shutdown();
10641 _result
10642 }
10643
10644 pub fn send_no_shutdown_on_err(
10646 self,
10647 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
10648 ) -> Result<(), fidl::Error> {
10649 let _result = self.send_raw(result);
10650 self.drop_without_shutdown();
10651 _result
10652 }
10653
10654 fn send_raw(
10655 &self,
10656 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
10657 ) -> Result<(), fidl::Error> {
10658 self.control_handle.inner.send::<fidl::encoding::ResultType<
10659 BaseNetworkSocketGetIpTypeOfServiceResponse,
10660 fidl_fuchsia_posix::Errno,
10661 >>(
10662 result.map(|value| (value,)),
10663 self.tx_id,
10664 0x3814a04259f75fcb,
10665 fidl::encoding::DynamicFlags::empty(),
10666 )
10667 }
10668}
10669
10670#[must_use = "FIDL methods require a response to be sent"]
10671#[derive(Debug)]
10672pub struct BaseDatagramSocketSetIpTtlResponder {
10673 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10674 tx_id: u32,
10675}
10676
10677impl std::ops::Drop for BaseDatagramSocketSetIpTtlResponder {
10681 fn drop(&mut self) {
10682 self.control_handle.shutdown();
10683 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10685 }
10686}
10687
10688impl fidl::endpoints::Responder for BaseDatagramSocketSetIpTtlResponder {
10689 type ControlHandle = BaseDatagramSocketControlHandle;
10690
10691 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10692 &self.control_handle
10693 }
10694
10695 fn drop_without_shutdown(mut self) {
10696 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10698 std::mem::forget(self);
10700 }
10701}
10702
10703impl BaseDatagramSocketSetIpTtlResponder {
10704 pub fn send(
10708 self,
10709 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10710 ) -> Result<(), fidl::Error> {
10711 let _result = self.send_raw(result);
10712 if _result.is_err() {
10713 self.control_handle.shutdown();
10714 }
10715 self.drop_without_shutdown();
10716 _result
10717 }
10718
10719 pub fn send_no_shutdown_on_err(
10721 self,
10722 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10723 ) -> Result<(), fidl::Error> {
10724 let _result = self.send_raw(result);
10725 self.drop_without_shutdown();
10726 _result
10727 }
10728
10729 fn send_raw(
10730 &self,
10731 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10732 ) -> Result<(), fidl::Error> {
10733 self.control_handle.inner.send::<fidl::encoding::ResultType<
10734 fidl::encoding::EmptyStruct,
10735 fidl_fuchsia_posix::Errno,
10736 >>(
10737 result,
10738 self.tx_id,
10739 0x29e2424b433ae1ef,
10740 fidl::encoding::DynamicFlags::empty(),
10741 )
10742 }
10743}
10744
10745#[must_use = "FIDL methods require a response to be sent"]
10746#[derive(Debug)]
10747pub struct BaseDatagramSocketGetIpTtlResponder {
10748 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10749 tx_id: u32,
10750}
10751
10752impl std::ops::Drop for BaseDatagramSocketGetIpTtlResponder {
10756 fn drop(&mut self) {
10757 self.control_handle.shutdown();
10758 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10760 }
10761}
10762
10763impl fidl::endpoints::Responder for BaseDatagramSocketGetIpTtlResponder {
10764 type ControlHandle = BaseDatagramSocketControlHandle;
10765
10766 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10767 &self.control_handle
10768 }
10769
10770 fn drop_without_shutdown(mut self) {
10771 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10773 std::mem::forget(self);
10775 }
10776}
10777
10778impl BaseDatagramSocketGetIpTtlResponder {
10779 pub fn send(
10783 self,
10784 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
10785 ) -> Result<(), fidl::Error> {
10786 let _result = self.send_raw(result);
10787 if _result.is_err() {
10788 self.control_handle.shutdown();
10789 }
10790 self.drop_without_shutdown();
10791 _result
10792 }
10793
10794 pub fn send_no_shutdown_on_err(
10796 self,
10797 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
10798 ) -> Result<(), fidl::Error> {
10799 let _result = self.send_raw(result);
10800 self.drop_without_shutdown();
10801 _result
10802 }
10803
10804 fn send_raw(
10805 &self,
10806 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
10807 ) -> Result<(), fidl::Error> {
10808 self.control_handle.inner.send::<fidl::encoding::ResultType<
10809 BaseNetworkSocketGetIpTtlResponse,
10810 fidl_fuchsia_posix::Errno,
10811 >>(
10812 result.map(|value| (value,)),
10813 self.tx_id,
10814 0x47e47fa1f24da471,
10815 fidl::encoding::DynamicFlags::empty(),
10816 )
10817 }
10818}
10819
10820#[must_use = "FIDL methods require a response to be sent"]
10821#[derive(Debug)]
10822pub struct BaseDatagramSocketSetIpPacketInfoResponder {
10823 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10824 tx_id: u32,
10825}
10826
10827impl std::ops::Drop for BaseDatagramSocketSetIpPacketInfoResponder {
10831 fn drop(&mut self) {
10832 self.control_handle.shutdown();
10833 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10835 }
10836}
10837
10838impl fidl::endpoints::Responder for BaseDatagramSocketSetIpPacketInfoResponder {
10839 type ControlHandle = BaseDatagramSocketControlHandle;
10840
10841 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10842 &self.control_handle
10843 }
10844
10845 fn drop_without_shutdown(mut self) {
10846 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10848 std::mem::forget(self);
10850 }
10851}
10852
10853impl BaseDatagramSocketSetIpPacketInfoResponder {
10854 pub fn send(
10858 self,
10859 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10860 ) -> Result<(), fidl::Error> {
10861 let _result = self.send_raw(result);
10862 if _result.is_err() {
10863 self.control_handle.shutdown();
10864 }
10865 self.drop_without_shutdown();
10866 _result
10867 }
10868
10869 pub fn send_no_shutdown_on_err(
10871 self,
10872 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10873 ) -> Result<(), fidl::Error> {
10874 let _result = self.send_raw(result);
10875 self.drop_without_shutdown();
10876 _result
10877 }
10878
10879 fn send_raw(
10880 &self,
10881 mut result: Result<(), fidl_fuchsia_posix::Errno>,
10882 ) -> Result<(), fidl::Error> {
10883 self.control_handle.inner.send::<fidl::encoding::ResultType<
10884 fidl::encoding::EmptyStruct,
10885 fidl_fuchsia_posix::Errno,
10886 >>(
10887 result,
10888 self.tx_id,
10889 0x392d16bee20c0e16,
10890 fidl::encoding::DynamicFlags::empty(),
10891 )
10892 }
10893}
10894
10895#[must_use = "FIDL methods require a response to be sent"]
10896#[derive(Debug)]
10897pub struct BaseDatagramSocketGetIpPacketInfoResponder {
10898 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10899 tx_id: u32,
10900}
10901
10902impl std::ops::Drop for BaseDatagramSocketGetIpPacketInfoResponder {
10906 fn drop(&mut self) {
10907 self.control_handle.shutdown();
10908 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10910 }
10911}
10912
10913impl fidl::endpoints::Responder for BaseDatagramSocketGetIpPacketInfoResponder {
10914 type ControlHandle = BaseDatagramSocketControlHandle;
10915
10916 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10917 &self.control_handle
10918 }
10919
10920 fn drop_without_shutdown(mut self) {
10921 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10923 std::mem::forget(self);
10925 }
10926}
10927
10928impl BaseDatagramSocketGetIpPacketInfoResponder {
10929 pub fn send(
10933 self,
10934 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10935 ) -> Result<(), fidl::Error> {
10936 let _result = self.send_raw(result);
10937 if _result.is_err() {
10938 self.control_handle.shutdown();
10939 }
10940 self.drop_without_shutdown();
10941 _result
10942 }
10943
10944 pub fn send_no_shutdown_on_err(
10946 self,
10947 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10948 ) -> Result<(), fidl::Error> {
10949 let _result = self.send_raw(result);
10950 self.drop_without_shutdown();
10951 _result
10952 }
10953
10954 fn send_raw(
10955 &self,
10956 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10957 ) -> Result<(), fidl::Error> {
10958 self.control_handle.inner.send::<fidl::encoding::ResultType<
10959 BaseNetworkSocketGetIpPacketInfoResponse,
10960 fidl_fuchsia_posix::Errno,
10961 >>(
10962 result.map(|value| (value,)),
10963 self.tx_id,
10964 0x54b505f242280740,
10965 fidl::encoding::DynamicFlags::empty(),
10966 )
10967 }
10968}
10969
10970#[must_use = "FIDL methods require a response to be sent"]
10971#[derive(Debug)]
10972pub struct BaseDatagramSocketSetIpReceiveTypeOfServiceResponder {
10973 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10974 tx_id: u32,
10975}
10976
10977impl std::ops::Drop for BaseDatagramSocketSetIpReceiveTypeOfServiceResponder {
10981 fn drop(&mut self) {
10982 self.control_handle.shutdown();
10983 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10985 }
10986}
10987
10988impl fidl::endpoints::Responder for BaseDatagramSocketSetIpReceiveTypeOfServiceResponder {
10989 type ControlHandle = BaseDatagramSocketControlHandle;
10990
10991 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10992 &self.control_handle
10993 }
10994
10995 fn drop_without_shutdown(mut self) {
10996 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10998 std::mem::forget(self);
11000 }
11001}
11002
11003impl BaseDatagramSocketSetIpReceiveTypeOfServiceResponder {
11004 pub fn send(
11008 self,
11009 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11010 ) -> Result<(), fidl::Error> {
11011 let _result = self.send_raw(result);
11012 if _result.is_err() {
11013 self.control_handle.shutdown();
11014 }
11015 self.drop_without_shutdown();
11016 _result
11017 }
11018
11019 pub fn send_no_shutdown_on_err(
11021 self,
11022 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11023 ) -> Result<(), fidl::Error> {
11024 let _result = self.send_raw(result);
11025 self.drop_without_shutdown();
11026 _result
11027 }
11028
11029 fn send_raw(
11030 &self,
11031 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11032 ) -> Result<(), fidl::Error> {
11033 self.control_handle.inner.send::<fidl::encoding::ResultType<
11034 fidl::encoding::EmptyStruct,
11035 fidl_fuchsia_posix::Errno,
11036 >>(
11037 result,
11038 self.tx_id,
11039 0x6c4f6714995f84ef,
11040 fidl::encoding::DynamicFlags::empty(),
11041 )
11042 }
11043}
11044
11045#[must_use = "FIDL methods require a response to be sent"]
11046#[derive(Debug)]
11047pub struct BaseDatagramSocketGetIpReceiveTypeOfServiceResponder {
11048 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11049 tx_id: u32,
11050}
11051
11052impl std::ops::Drop for BaseDatagramSocketGetIpReceiveTypeOfServiceResponder {
11056 fn drop(&mut self) {
11057 self.control_handle.shutdown();
11058 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11060 }
11061}
11062
11063impl fidl::endpoints::Responder for BaseDatagramSocketGetIpReceiveTypeOfServiceResponder {
11064 type ControlHandle = BaseDatagramSocketControlHandle;
11065
11066 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11067 &self.control_handle
11068 }
11069
11070 fn drop_without_shutdown(mut self) {
11071 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11073 std::mem::forget(self);
11075 }
11076}
11077
11078impl BaseDatagramSocketGetIpReceiveTypeOfServiceResponder {
11079 pub fn send(
11083 self,
11084 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11085 ) -> Result<(), fidl::Error> {
11086 let _result = self.send_raw(result);
11087 if _result.is_err() {
11088 self.control_handle.shutdown();
11089 }
11090 self.drop_without_shutdown();
11091 _result
11092 }
11093
11094 pub fn send_no_shutdown_on_err(
11096 self,
11097 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11098 ) -> Result<(), fidl::Error> {
11099 let _result = self.send_raw(result);
11100 self.drop_without_shutdown();
11101 _result
11102 }
11103
11104 fn send_raw(
11105 &self,
11106 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11107 ) -> Result<(), fidl::Error> {
11108 self.control_handle.inner.send::<fidl::encoding::ResultType<
11109 BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
11110 fidl_fuchsia_posix::Errno,
11111 >>(
11112 result.map(|value| (value,)),
11113 self.tx_id,
11114 0x4158ba7dc2795960,
11115 fidl::encoding::DynamicFlags::empty(),
11116 )
11117 }
11118}
11119
11120#[must_use = "FIDL methods require a response to be sent"]
11121#[derive(Debug)]
11122pub struct BaseDatagramSocketSetIpReceiveTtlResponder {
11123 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11124 tx_id: u32,
11125}
11126
11127impl std::ops::Drop for BaseDatagramSocketSetIpReceiveTtlResponder {
11131 fn drop(&mut self) {
11132 self.control_handle.shutdown();
11133 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11135 }
11136}
11137
11138impl fidl::endpoints::Responder for BaseDatagramSocketSetIpReceiveTtlResponder {
11139 type ControlHandle = BaseDatagramSocketControlHandle;
11140
11141 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11142 &self.control_handle
11143 }
11144
11145 fn drop_without_shutdown(mut self) {
11146 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11148 std::mem::forget(self);
11150 }
11151}
11152
11153impl BaseDatagramSocketSetIpReceiveTtlResponder {
11154 pub fn send(
11158 self,
11159 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11160 ) -> Result<(), fidl::Error> {
11161 let _result = self.send_raw(result);
11162 if _result.is_err() {
11163 self.control_handle.shutdown();
11164 }
11165 self.drop_without_shutdown();
11166 _result
11167 }
11168
11169 pub fn send_no_shutdown_on_err(
11171 self,
11172 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11173 ) -> Result<(), fidl::Error> {
11174 let _result = self.send_raw(result);
11175 self.drop_without_shutdown();
11176 _result
11177 }
11178
11179 fn send_raw(
11180 &self,
11181 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11182 ) -> Result<(), fidl::Error> {
11183 self.control_handle.inner.send::<fidl::encoding::ResultType<
11184 fidl::encoding::EmptyStruct,
11185 fidl_fuchsia_posix::Errno,
11186 >>(
11187 result,
11188 self.tx_id,
11189 0x46f15be0ce0ab82b,
11190 fidl::encoding::DynamicFlags::empty(),
11191 )
11192 }
11193}
11194
11195#[must_use = "FIDL methods require a response to be sent"]
11196#[derive(Debug)]
11197pub struct BaseDatagramSocketGetIpReceiveTtlResponder {
11198 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11199 tx_id: u32,
11200}
11201
11202impl std::ops::Drop for BaseDatagramSocketGetIpReceiveTtlResponder {
11206 fn drop(&mut self) {
11207 self.control_handle.shutdown();
11208 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11210 }
11211}
11212
11213impl fidl::endpoints::Responder for BaseDatagramSocketGetIpReceiveTtlResponder {
11214 type ControlHandle = BaseDatagramSocketControlHandle;
11215
11216 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11217 &self.control_handle
11218 }
11219
11220 fn drop_without_shutdown(mut self) {
11221 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11223 std::mem::forget(self);
11225 }
11226}
11227
11228impl BaseDatagramSocketGetIpReceiveTtlResponder {
11229 pub fn send(
11233 self,
11234 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11235 ) -> Result<(), fidl::Error> {
11236 let _result = self.send_raw(result);
11237 if _result.is_err() {
11238 self.control_handle.shutdown();
11239 }
11240 self.drop_without_shutdown();
11241 _result
11242 }
11243
11244 pub fn send_no_shutdown_on_err(
11246 self,
11247 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11248 ) -> Result<(), fidl::Error> {
11249 let _result = self.send_raw(result);
11250 self.drop_without_shutdown();
11251 _result
11252 }
11253
11254 fn send_raw(
11255 &self,
11256 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11257 ) -> Result<(), fidl::Error> {
11258 self.control_handle.inner.send::<fidl::encoding::ResultType<
11259 BaseNetworkSocketGetIpReceiveTtlResponse,
11260 fidl_fuchsia_posix::Errno,
11261 >>(
11262 result.map(|value| (value,)),
11263 self.tx_id,
11264 0x678ddd5a5dfa2eb5,
11265 fidl::encoding::DynamicFlags::empty(),
11266 )
11267 }
11268}
11269
11270#[must_use = "FIDL methods require a response to be sent"]
11271#[derive(Debug)]
11272pub struct BaseDatagramSocketSetIpMulticastInterfaceResponder {
11273 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11274 tx_id: u32,
11275}
11276
11277impl std::ops::Drop for BaseDatagramSocketSetIpMulticastInterfaceResponder {
11281 fn drop(&mut self) {
11282 self.control_handle.shutdown();
11283 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11285 }
11286}
11287
11288impl fidl::endpoints::Responder for BaseDatagramSocketSetIpMulticastInterfaceResponder {
11289 type ControlHandle = BaseDatagramSocketControlHandle;
11290
11291 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11292 &self.control_handle
11293 }
11294
11295 fn drop_without_shutdown(mut self) {
11296 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11298 std::mem::forget(self);
11300 }
11301}
11302
11303impl BaseDatagramSocketSetIpMulticastInterfaceResponder {
11304 pub fn send(
11308 self,
11309 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11310 ) -> Result<(), fidl::Error> {
11311 let _result = self.send_raw(result);
11312 if _result.is_err() {
11313 self.control_handle.shutdown();
11314 }
11315 self.drop_without_shutdown();
11316 _result
11317 }
11318
11319 pub fn send_no_shutdown_on_err(
11321 self,
11322 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11323 ) -> Result<(), fidl::Error> {
11324 let _result = self.send_raw(result);
11325 self.drop_without_shutdown();
11326 _result
11327 }
11328
11329 fn send_raw(
11330 &self,
11331 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11332 ) -> Result<(), fidl::Error> {
11333 self.control_handle.inner.send::<fidl::encoding::ResultType<
11334 fidl::encoding::EmptyStruct,
11335 fidl_fuchsia_posix::Errno,
11336 >>(
11337 result,
11338 self.tx_id,
11339 0x752fbfa9b12befe,
11340 fidl::encoding::DynamicFlags::empty(),
11341 )
11342 }
11343}
11344
11345#[must_use = "FIDL methods require a response to be sent"]
11346#[derive(Debug)]
11347pub struct BaseDatagramSocketGetIpMulticastInterfaceResponder {
11348 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11349 tx_id: u32,
11350}
11351
11352impl std::ops::Drop for BaseDatagramSocketGetIpMulticastInterfaceResponder {
11356 fn drop(&mut self) {
11357 self.control_handle.shutdown();
11358 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11360 }
11361}
11362
11363impl fidl::endpoints::Responder for BaseDatagramSocketGetIpMulticastInterfaceResponder {
11364 type ControlHandle = BaseDatagramSocketControlHandle;
11365
11366 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11367 &self.control_handle
11368 }
11369
11370 fn drop_without_shutdown(mut self) {
11371 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11373 std::mem::forget(self);
11375 }
11376}
11377
11378impl BaseDatagramSocketGetIpMulticastInterfaceResponder {
11379 pub fn send(
11383 self,
11384 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
11385 ) -> Result<(), fidl::Error> {
11386 let _result = self.send_raw(result);
11387 if _result.is_err() {
11388 self.control_handle.shutdown();
11389 }
11390 self.drop_without_shutdown();
11391 _result
11392 }
11393
11394 pub fn send_no_shutdown_on_err(
11396 self,
11397 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
11398 ) -> Result<(), fidl::Error> {
11399 let _result = self.send_raw(result);
11400 self.drop_without_shutdown();
11401 _result
11402 }
11403
11404 fn send_raw(
11405 &self,
11406 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
11407 ) -> Result<(), fidl::Error> {
11408 self.control_handle.inner.send::<fidl::encoding::ResultType<
11409 BaseNetworkSocketGetIpMulticastInterfaceResponse,
11410 fidl_fuchsia_posix::Errno,
11411 >>(
11412 result.map(|value| (value,)),
11413 self.tx_id,
11414 0x320bd14c4df046c4,
11415 fidl::encoding::DynamicFlags::empty(),
11416 )
11417 }
11418}
11419
11420#[must_use = "FIDL methods require a response to be sent"]
11421#[derive(Debug)]
11422pub struct BaseDatagramSocketSetIpMulticastTtlResponder {
11423 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11424 tx_id: u32,
11425}
11426
11427impl std::ops::Drop for BaseDatagramSocketSetIpMulticastTtlResponder {
11431 fn drop(&mut self) {
11432 self.control_handle.shutdown();
11433 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11435 }
11436}
11437
11438impl fidl::endpoints::Responder for BaseDatagramSocketSetIpMulticastTtlResponder {
11439 type ControlHandle = BaseDatagramSocketControlHandle;
11440
11441 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11442 &self.control_handle
11443 }
11444
11445 fn drop_without_shutdown(mut self) {
11446 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11448 std::mem::forget(self);
11450 }
11451}
11452
11453impl BaseDatagramSocketSetIpMulticastTtlResponder {
11454 pub fn send(
11458 self,
11459 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11460 ) -> Result<(), fidl::Error> {
11461 let _result = self.send_raw(result);
11462 if _result.is_err() {
11463 self.control_handle.shutdown();
11464 }
11465 self.drop_without_shutdown();
11466 _result
11467 }
11468
11469 pub fn send_no_shutdown_on_err(
11471 self,
11472 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11473 ) -> Result<(), fidl::Error> {
11474 let _result = self.send_raw(result);
11475 self.drop_without_shutdown();
11476 _result
11477 }
11478
11479 fn send_raw(
11480 &self,
11481 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11482 ) -> Result<(), fidl::Error> {
11483 self.control_handle.inner.send::<fidl::encoding::ResultType<
11484 fidl::encoding::EmptyStruct,
11485 fidl_fuchsia_posix::Errno,
11486 >>(
11487 result,
11488 self.tx_id,
11489 0x63134d53772916a1,
11490 fidl::encoding::DynamicFlags::empty(),
11491 )
11492 }
11493}
11494
11495#[must_use = "FIDL methods require a response to be sent"]
11496#[derive(Debug)]
11497pub struct BaseDatagramSocketGetIpMulticastTtlResponder {
11498 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11499 tx_id: u32,
11500}
11501
11502impl std::ops::Drop for BaseDatagramSocketGetIpMulticastTtlResponder {
11506 fn drop(&mut self) {
11507 self.control_handle.shutdown();
11508 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11510 }
11511}
11512
11513impl fidl::endpoints::Responder for BaseDatagramSocketGetIpMulticastTtlResponder {
11514 type ControlHandle = BaseDatagramSocketControlHandle;
11515
11516 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11517 &self.control_handle
11518 }
11519
11520 fn drop_without_shutdown(mut self) {
11521 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11523 std::mem::forget(self);
11525 }
11526}
11527
11528impl BaseDatagramSocketGetIpMulticastTtlResponder {
11529 pub fn send(
11533 self,
11534 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
11535 ) -> Result<(), fidl::Error> {
11536 let _result = self.send_raw(result);
11537 if _result.is_err() {
11538 self.control_handle.shutdown();
11539 }
11540 self.drop_without_shutdown();
11541 _result
11542 }
11543
11544 pub fn send_no_shutdown_on_err(
11546 self,
11547 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
11548 ) -> Result<(), fidl::Error> {
11549 let _result = self.send_raw(result);
11550 self.drop_without_shutdown();
11551 _result
11552 }
11553
11554 fn send_raw(
11555 &self,
11556 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
11557 ) -> Result<(), fidl::Error> {
11558 self.control_handle.inner.send::<fidl::encoding::ResultType<
11559 BaseNetworkSocketGetIpMulticastTtlResponse,
11560 fidl_fuchsia_posix::Errno,
11561 >>(
11562 result.map(|value| (value,)),
11563 self.tx_id,
11564 0x4665cd378f39e1a,
11565 fidl::encoding::DynamicFlags::empty(),
11566 )
11567 }
11568}
11569
11570#[must_use = "FIDL methods require a response to be sent"]
11571#[derive(Debug)]
11572pub struct BaseDatagramSocketSetIpMulticastLoopbackResponder {
11573 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11574 tx_id: u32,
11575}
11576
11577impl std::ops::Drop for BaseDatagramSocketSetIpMulticastLoopbackResponder {
11581 fn drop(&mut self) {
11582 self.control_handle.shutdown();
11583 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11585 }
11586}
11587
11588impl fidl::endpoints::Responder for BaseDatagramSocketSetIpMulticastLoopbackResponder {
11589 type ControlHandle = BaseDatagramSocketControlHandle;
11590
11591 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11592 &self.control_handle
11593 }
11594
11595 fn drop_without_shutdown(mut self) {
11596 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11598 std::mem::forget(self);
11600 }
11601}
11602
11603impl BaseDatagramSocketSetIpMulticastLoopbackResponder {
11604 pub fn send(
11608 self,
11609 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11610 ) -> Result<(), fidl::Error> {
11611 let _result = self.send_raw(result);
11612 if _result.is_err() {
11613 self.control_handle.shutdown();
11614 }
11615 self.drop_without_shutdown();
11616 _result
11617 }
11618
11619 pub fn send_no_shutdown_on_err(
11621 self,
11622 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11623 ) -> Result<(), fidl::Error> {
11624 let _result = self.send_raw(result);
11625 self.drop_without_shutdown();
11626 _result
11627 }
11628
11629 fn send_raw(
11630 &self,
11631 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11632 ) -> Result<(), fidl::Error> {
11633 self.control_handle.inner.send::<fidl::encoding::ResultType<
11634 fidl::encoding::EmptyStruct,
11635 fidl_fuchsia_posix::Errno,
11636 >>(
11637 result,
11638 self.tx_id,
11639 0x20c55c11f00943ea,
11640 fidl::encoding::DynamicFlags::empty(),
11641 )
11642 }
11643}
11644
11645#[must_use = "FIDL methods require a response to be sent"]
11646#[derive(Debug)]
11647pub struct BaseDatagramSocketGetIpMulticastLoopbackResponder {
11648 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11649 tx_id: u32,
11650}
11651
11652impl std::ops::Drop for BaseDatagramSocketGetIpMulticastLoopbackResponder {
11656 fn drop(&mut self) {
11657 self.control_handle.shutdown();
11658 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11660 }
11661}
11662
11663impl fidl::endpoints::Responder for BaseDatagramSocketGetIpMulticastLoopbackResponder {
11664 type ControlHandle = BaseDatagramSocketControlHandle;
11665
11666 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11667 &self.control_handle
11668 }
11669
11670 fn drop_without_shutdown(mut self) {
11671 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11673 std::mem::forget(self);
11675 }
11676}
11677
11678impl BaseDatagramSocketGetIpMulticastLoopbackResponder {
11679 pub fn send(
11683 self,
11684 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11685 ) -> Result<(), fidl::Error> {
11686 let _result = self.send_raw(result);
11687 if _result.is_err() {
11688 self.control_handle.shutdown();
11689 }
11690 self.drop_without_shutdown();
11691 _result
11692 }
11693
11694 pub fn send_no_shutdown_on_err(
11696 self,
11697 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11698 ) -> Result<(), fidl::Error> {
11699 let _result = self.send_raw(result);
11700 self.drop_without_shutdown();
11701 _result
11702 }
11703
11704 fn send_raw(
11705 &self,
11706 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11707 ) -> Result<(), fidl::Error> {
11708 self.control_handle.inner.send::<fidl::encoding::ResultType<
11709 BaseNetworkSocketGetIpMulticastLoopbackResponse,
11710 fidl_fuchsia_posix::Errno,
11711 >>(
11712 result.map(|value| (value,)),
11713 self.tx_id,
11714 0x3b6b26ff558298f2,
11715 fidl::encoding::DynamicFlags::empty(),
11716 )
11717 }
11718}
11719
11720#[must_use = "FIDL methods require a response to be sent"]
11721#[derive(Debug)]
11722pub struct BaseDatagramSocketAddIpMembershipResponder {
11723 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11724 tx_id: u32,
11725}
11726
11727impl std::ops::Drop for BaseDatagramSocketAddIpMembershipResponder {
11731 fn drop(&mut self) {
11732 self.control_handle.shutdown();
11733 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11735 }
11736}
11737
11738impl fidl::endpoints::Responder for BaseDatagramSocketAddIpMembershipResponder {
11739 type ControlHandle = BaseDatagramSocketControlHandle;
11740
11741 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11742 &self.control_handle
11743 }
11744
11745 fn drop_without_shutdown(mut self) {
11746 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11748 std::mem::forget(self);
11750 }
11751}
11752
11753impl BaseDatagramSocketAddIpMembershipResponder {
11754 pub fn send(
11758 self,
11759 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11760 ) -> Result<(), fidl::Error> {
11761 let _result = self.send_raw(result);
11762 if _result.is_err() {
11763 self.control_handle.shutdown();
11764 }
11765 self.drop_without_shutdown();
11766 _result
11767 }
11768
11769 pub fn send_no_shutdown_on_err(
11771 self,
11772 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11773 ) -> Result<(), fidl::Error> {
11774 let _result = self.send_raw(result);
11775 self.drop_without_shutdown();
11776 _result
11777 }
11778
11779 fn send_raw(
11780 &self,
11781 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11782 ) -> Result<(), fidl::Error> {
11783 self.control_handle.inner.send::<fidl::encoding::ResultType<
11784 fidl::encoding::EmptyStruct,
11785 fidl_fuchsia_posix::Errno,
11786 >>(
11787 result,
11788 self.tx_id,
11789 0x76bc7df115a3b4d0,
11790 fidl::encoding::DynamicFlags::empty(),
11791 )
11792 }
11793}
11794
11795#[must_use = "FIDL methods require a response to be sent"]
11796#[derive(Debug)]
11797pub struct BaseDatagramSocketDropIpMembershipResponder {
11798 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11799 tx_id: u32,
11800}
11801
11802impl std::ops::Drop for BaseDatagramSocketDropIpMembershipResponder {
11806 fn drop(&mut self) {
11807 self.control_handle.shutdown();
11808 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11810 }
11811}
11812
11813impl fidl::endpoints::Responder for BaseDatagramSocketDropIpMembershipResponder {
11814 type ControlHandle = BaseDatagramSocketControlHandle;
11815
11816 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11817 &self.control_handle
11818 }
11819
11820 fn drop_without_shutdown(mut self) {
11821 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11823 std::mem::forget(self);
11825 }
11826}
11827
11828impl BaseDatagramSocketDropIpMembershipResponder {
11829 pub fn send(
11833 self,
11834 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11835 ) -> Result<(), fidl::Error> {
11836 let _result = self.send_raw(result);
11837 if _result.is_err() {
11838 self.control_handle.shutdown();
11839 }
11840 self.drop_without_shutdown();
11841 _result
11842 }
11843
11844 pub fn send_no_shutdown_on_err(
11846 self,
11847 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11848 ) -> Result<(), fidl::Error> {
11849 let _result = self.send_raw(result);
11850 self.drop_without_shutdown();
11851 _result
11852 }
11853
11854 fn send_raw(
11855 &self,
11856 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11857 ) -> Result<(), fidl::Error> {
11858 self.control_handle.inner.send::<fidl::encoding::ResultType<
11859 fidl::encoding::EmptyStruct,
11860 fidl_fuchsia_posix::Errno,
11861 >>(
11862 result,
11863 self.tx_id,
11864 0x2888f3099188d03,
11865 fidl::encoding::DynamicFlags::empty(),
11866 )
11867 }
11868}
11869
11870#[must_use = "FIDL methods require a response to be sent"]
11871#[derive(Debug)]
11872pub struct BaseDatagramSocketSetIpTransparentResponder {
11873 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11874 tx_id: u32,
11875}
11876
11877impl std::ops::Drop for BaseDatagramSocketSetIpTransparentResponder {
11881 fn drop(&mut self) {
11882 self.control_handle.shutdown();
11883 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11885 }
11886}
11887
11888impl fidl::endpoints::Responder for BaseDatagramSocketSetIpTransparentResponder {
11889 type ControlHandle = BaseDatagramSocketControlHandle;
11890
11891 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11892 &self.control_handle
11893 }
11894
11895 fn drop_without_shutdown(mut self) {
11896 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11898 std::mem::forget(self);
11900 }
11901}
11902
11903impl BaseDatagramSocketSetIpTransparentResponder {
11904 pub fn send(
11908 self,
11909 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11910 ) -> Result<(), fidl::Error> {
11911 let _result = self.send_raw(result);
11912 if _result.is_err() {
11913 self.control_handle.shutdown();
11914 }
11915 self.drop_without_shutdown();
11916 _result
11917 }
11918
11919 pub fn send_no_shutdown_on_err(
11921 self,
11922 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11923 ) -> Result<(), fidl::Error> {
11924 let _result = self.send_raw(result);
11925 self.drop_without_shutdown();
11926 _result
11927 }
11928
11929 fn send_raw(
11930 &self,
11931 mut result: Result<(), fidl_fuchsia_posix::Errno>,
11932 ) -> Result<(), fidl::Error> {
11933 self.control_handle.inner.send::<fidl::encoding::ResultType<
11934 fidl::encoding::EmptyStruct,
11935 fidl_fuchsia_posix::Errno,
11936 >>(
11937 result,
11938 self.tx_id,
11939 0x1ae532b0c066e3a0,
11940 fidl::encoding::DynamicFlags::empty(),
11941 )
11942 }
11943}
11944
11945#[must_use = "FIDL methods require a response to be sent"]
11946#[derive(Debug)]
11947pub struct BaseDatagramSocketGetIpTransparentResponder {
11948 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11949 tx_id: u32,
11950}
11951
11952impl std::ops::Drop for BaseDatagramSocketGetIpTransparentResponder {
11956 fn drop(&mut self) {
11957 self.control_handle.shutdown();
11958 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11960 }
11961}
11962
11963impl fidl::endpoints::Responder for BaseDatagramSocketGetIpTransparentResponder {
11964 type ControlHandle = BaseDatagramSocketControlHandle;
11965
11966 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11967 &self.control_handle
11968 }
11969
11970 fn drop_without_shutdown(mut self) {
11971 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11973 std::mem::forget(self);
11975 }
11976}
11977
11978impl BaseDatagramSocketGetIpTransparentResponder {
11979 pub fn send(
11983 self,
11984 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11985 ) -> Result<(), fidl::Error> {
11986 let _result = self.send_raw(result);
11987 if _result.is_err() {
11988 self.control_handle.shutdown();
11989 }
11990 self.drop_without_shutdown();
11991 _result
11992 }
11993
11994 pub fn send_no_shutdown_on_err(
11996 self,
11997 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11998 ) -> Result<(), fidl::Error> {
11999 let _result = self.send_raw(result);
12000 self.drop_without_shutdown();
12001 _result
12002 }
12003
12004 fn send_raw(
12005 &self,
12006 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12007 ) -> Result<(), fidl::Error> {
12008 self.control_handle.inner.send::<fidl::encoding::ResultType<
12009 BaseNetworkSocketGetIpTransparentResponse,
12010 fidl_fuchsia_posix::Errno,
12011 >>(
12012 result.map(|value| (value,)),
12013 self.tx_id,
12014 0x51d43695962ebfb5,
12015 fidl::encoding::DynamicFlags::empty(),
12016 )
12017 }
12018}
12019
12020#[must_use = "FIDL methods require a response to be sent"]
12021#[derive(Debug)]
12022pub struct BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
12023 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12024 tx_id: u32,
12025}
12026
12027impl std::ops::Drop for BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
12031 fn drop(&mut self) {
12032 self.control_handle.shutdown();
12033 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12035 }
12036}
12037
12038impl fidl::endpoints::Responder
12039 for BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder
12040{
12041 type ControlHandle = BaseDatagramSocketControlHandle;
12042
12043 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12044 &self.control_handle
12045 }
12046
12047 fn drop_without_shutdown(mut self) {
12048 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12050 std::mem::forget(self);
12052 }
12053}
12054
12055impl BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
12056 pub fn send(
12060 self,
12061 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12062 ) -> Result<(), fidl::Error> {
12063 let _result = self.send_raw(result);
12064 if _result.is_err() {
12065 self.control_handle.shutdown();
12066 }
12067 self.drop_without_shutdown();
12068 _result
12069 }
12070
12071 pub fn send_no_shutdown_on_err(
12073 self,
12074 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12075 ) -> Result<(), fidl::Error> {
12076 let _result = self.send_raw(result);
12077 self.drop_without_shutdown();
12078 _result
12079 }
12080
12081 fn send_raw(
12082 &self,
12083 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12084 ) -> Result<(), fidl::Error> {
12085 self.control_handle.inner.send::<fidl::encoding::ResultType<
12086 fidl::encoding::EmptyStruct,
12087 fidl_fuchsia_posix::Errno,
12088 >>(
12089 result,
12090 self.tx_id,
12091 0x4722b4ce52f7840,
12092 fidl::encoding::DynamicFlags::empty(),
12093 )
12094 }
12095}
12096
12097#[must_use = "FIDL methods require a response to be sent"]
12098#[derive(Debug)]
12099pub struct BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
12100 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12101 tx_id: u32,
12102}
12103
12104impl std::ops::Drop for BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
12108 fn drop(&mut self) {
12109 self.control_handle.shutdown();
12110 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12112 }
12113}
12114
12115impl fidl::endpoints::Responder
12116 for BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder
12117{
12118 type ControlHandle = BaseDatagramSocketControlHandle;
12119
12120 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12121 &self.control_handle
12122 }
12123
12124 fn drop_without_shutdown(mut self) {
12125 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12127 std::mem::forget(self);
12129 }
12130}
12131
12132impl BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
12133 pub fn send(
12137 self,
12138 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12139 ) -> Result<(), fidl::Error> {
12140 let _result = self.send_raw(result);
12141 if _result.is_err() {
12142 self.control_handle.shutdown();
12143 }
12144 self.drop_without_shutdown();
12145 _result
12146 }
12147
12148 pub fn send_no_shutdown_on_err(
12150 self,
12151 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12152 ) -> Result<(), fidl::Error> {
12153 let _result = self.send_raw(result);
12154 self.drop_without_shutdown();
12155 _result
12156 }
12157
12158 fn send_raw(
12159 &self,
12160 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12161 ) -> Result<(), fidl::Error> {
12162 self.control_handle.inner.send::<fidl::encoding::ResultType<
12163 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
12164 fidl_fuchsia_posix::Errno,
12165 >>(
12166 result.map(|value| (value,)),
12167 self.tx_id,
12168 0x2a0e7dc5d6bfdfe9,
12169 fidl::encoding::DynamicFlags::empty(),
12170 )
12171 }
12172}
12173
12174#[must_use = "FIDL methods require a response to be sent"]
12175#[derive(Debug)]
12176pub struct BaseDatagramSocketAddIpv6MembershipResponder {
12177 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12178 tx_id: u32,
12179}
12180
12181impl std::ops::Drop for BaseDatagramSocketAddIpv6MembershipResponder {
12185 fn drop(&mut self) {
12186 self.control_handle.shutdown();
12187 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12189 }
12190}
12191
12192impl fidl::endpoints::Responder for BaseDatagramSocketAddIpv6MembershipResponder {
12193 type ControlHandle = BaseDatagramSocketControlHandle;
12194
12195 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12196 &self.control_handle
12197 }
12198
12199 fn drop_without_shutdown(mut self) {
12200 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12202 std::mem::forget(self);
12204 }
12205}
12206
12207impl BaseDatagramSocketAddIpv6MembershipResponder {
12208 pub fn send(
12212 self,
12213 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12214 ) -> Result<(), fidl::Error> {
12215 let _result = self.send_raw(result);
12216 if _result.is_err() {
12217 self.control_handle.shutdown();
12218 }
12219 self.drop_without_shutdown();
12220 _result
12221 }
12222
12223 pub fn send_no_shutdown_on_err(
12225 self,
12226 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12227 ) -> Result<(), fidl::Error> {
12228 let _result = self.send_raw(result);
12229 self.drop_without_shutdown();
12230 _result
12231 }
12232
12233 fn send_raw(
12234 &self,
12235 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12236 ) -> Result<(), fidl::Error> {
12237 self.control_handle.inner.send::<fidl::encoding::ResultType<
12238 fidl::encoding::EmptyStruct,
12239 fidl_fuchsia_posix::Errno,
12240 >>(
12241 result,
12242 self.tx_id,
12243 0x7c94727acb4ea4b3,
12244 fidl::encoding::DynamicFlags::empty(),
12245 )
12246 }
12247}
12248
12249#[must_use = "FIDL methods require a response to be sent"]
12250#[derive(Debug)]
12251pub struct BaseDatagramSocketDropIpv6MembershipResponder {
12252 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12253 tx_id: u32,
12254}
12255
12256impl std::ops::Drop for BaseDatagramSocketDropIpv6MembershipResponder {
12260 fn drop(&mut self) {
12261 self.control_handle.shutdown();
12262 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12264 }
12265}
12266
12267impl fidl::endpoints::Responder for BaseDatagramSocketDropIpv6MembershipResponder {
12268 type ControlHandle = BaseDatagramSocketControlHandle;
12269
12270 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12271 &self.control_handle
12272 }
12273
12274 fn drop_without_shutdown(mut self) {
12275 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12277 std::mem::forget(self);
12279 }
12280}
12281
12282impl BaseDatagramSocketDropIpv6MembershipResponder {
12283 pub fn send(
12287 self,
12288 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12289 ) -> Result<(), fidl::Error> {
12290 let _result = self.send_raw(result);
12291 if _result.is_err() {
12292 self.control_handle.shutdown();
12293 }
12294 self.drop_without_shutdown();
12295 _result
12296 }
12297
12298 pub fn send_no_shutdown_on_err(
12300 self,
12301 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12302 ) -> Result<(), fidl::Error> {
12303 let _result = self.send_raw(result);
12304 self.drop_without_shutdown();
12305 _result
12306 }
12307
12308 fn send_raw(
12309 &self,
12310 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12311 ) -> Result<(), fidl::Error> {
12312 self.control_handle.inner.send::<fidl::encoding::ResultType<
12313 fidl::encoding::EmptyStruct,
12314 fidl_fuchsia_posix::Errno,
12315 >>(
12316 result,
12317 self.tx_id,
12318 0x42104c70ccaba304,
12319 fidl::encoding::DynamicFlags::empty(),
12320 )
12321 }
12322}
12323
12324#[must_use = "FIDL methods require a response to be sent"]
12325#[derive(Debug)]
12326pub struct BaseDatagramSocketSetIpv6MulticastInterfaceResponder {
12327 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12328 tx_id: u32,
12329}
12330
12331impl std::ops::Drop for BaseDatagramSocketSetIpv6MulticastInterfaceResponder {
12335 fn drop(&mut self) {
12336 self.control_handle.shutdown();
12337 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12339 }
12340}
12341
12342impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6MulticastInterfaceResponder {
12343 type ControlHandle = BaseDatagramSocketControlHandle;
12344
12345 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12346 &self.control_handle
12347 }
12348
12349 fn drop_without_shutdown(mut self) {
12350 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12352 std::mem::forget(self);
12354 }
12355}
12356
12357impl BaseDatagramSocketSetIpv6MulticastInterfaceResponder {
12358 pub fn send(
12362 self,
12363 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12364 ) -> Result<(), fidl::Error> {
12365 let _result = self.send_raw(result);
12366 if _result.is_err() {
12367 self.control_handle.shutdown();
12368 }
12369 self.drop_without_shutdown();
12370 _result
12371 }
12372
12373 pub fn send_no_shutdown_on_err(
12375 self,
12376 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12377 ) -> Result<(), fidl::Error> {
12378 let _result = self.send_raw(result);
12379 self.drop_without_shutdown();
12380 _result
12381 }
12382
12383 fn send_raw(
12384 &self,
12385 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12386 ) -> Result<(), fidl::Error> {
12387 self.control_handle.inner.send::<fidl::encoding::ResultType<
12388 fidl::encoding::EmptyStruct,
12389 fidl_fuchsia_posix::Errno,
12390 >>(
12391 result,
12392 self.tx_id,
12393 0x135f76db3774ab3b,
12394 fidl::encoding::DynamicFlags::empty(),
12395 )
12396 }
12397}
12398
12399#[must_use = "FIDL methods require a response to be sent"]
12400#[derive(Debug)]
12401pub struct BaseDatagramSocketGetIpv6MulticastInterfaceResponder {
12402 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12403 tx_id: u32,
12404}
12405
12406impl std::ops::Drop for BaseDatagramSocketGetIpv6MulticastInterfaceResponder {
12410 fn drop(&mut self) {
12411 self.control_handle.shutdown();
12412 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12414 }
12415}
12416
12417impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6MulticastInterfaceResponder {
12418 type ControlHandle = BaseDatagramSocketControlHandle;
12419
12420 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12421 &self.control_handle
12422 }
12423
12424 fn drop_without_shutdown(mut self) {
12425 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12427 std::mem::forget(self);
12429 }
12430}
12431
12432impl BaseDatagramSocketGetIpv6MulticastInterfaceResponder {
12433 pub fn send(
12437 self,
12438 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
12439 ) -> Result<(), fidl::Error> {
12440 let _result = self.send_raw(result);
12441 if _result.is_err() {
12442 self.control_handle.shutdown();
12443 }
12444 self.drop_without_shutdown();
12445 _result
12446 }
12447
12448 pub fn send_no_shutdown_on_err(
12450 self,
12451 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
12452 ) -> Result<(), fidl::Error> {
12453 let _result = self.send_raw(result);
12454 self.drop_without_shutdown();
12455 _result
12456 }
12457
12458 fn send_raw(
12459 &self,
12460 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
12461 ) -> Result<(), fidl::Error> {
12462 self.control_handle.inner.send::<fidl::encoding::ResultType<
12463 BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
12464 fidl_fuchsia_posix::Errno,
12465 >>(
12466 result.map(|value| (value,)),
12467 self.tx_id,
12468 0x1f26fcdd348f1882,
12469 fidl::encoding::DynamicFlags::empty(),
12470 )
12471 }
12472}
12473
12474#[must_use = "FIDL methods require a response to be sent"]
12475#[derive(Debug)]
12476pub struct BaseDatagramSocketSetIpv6UnicastHopsResponder {
12477 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12478 tx_id: u32,
12479}
12480
12481impl std::ops::Drop for BaseDatagramSocketSetIpv6UnicastHopsResponder {
12485 fn drop(&mut self) {
12486 self.control_handle.shutdown();
12487 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12489 }
12490}
12491
12492impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6UnicastHopsResponder {
12493 type ControlHandle = BaseDatagramSocketControlHandle;
12494
12495 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12496 &self.control_handle
12497 }
12498
12499 fn drop_without_shutdown(mut self) {
12500 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12502 std::mem::forget(self);
12504 }
12505}
12506
12507impl BaseDatagramSocketSetIpv6UnicastHopsResponder {
12508 pub fn send(
12512 self,
12513 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12514 ) -> Result<(), fidl::Error> {
12515 let _result = self.send_raw(result);
12516 if _result.is_err() {
12517 self.control_handle.shutdown();
12518 }
12519 self.drop_without_shutdown();
12520 _result
12521 }
12522
12523 pub fn send_no_shutdown_on_err(
12525 self,
12526 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12527 ) -> Result<(), fidl::Error> {
12528 let _result = self.send_raw(result);
12529 self.drop_without_shutdown();
12530 _result
12531 }
12532
12533 fn send_raw(
12534 &self,
12535 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12536 ) -> Result<(), fidl::Error> {
12537 self.control_handle.inner.send::<fidl::encoding::ResultType<
12538 fidl::encoding::EmptyStruct,
12539 fidl_fuchsia_posix::Errno,
12540 >>(
12541 result,
12542 self.tx_id,
12543 0x157d51e98f462859,
12544 fidl::encoding::DynamicFlags::empty(),
12545 )
12546 }
12547}
12548
12549#[must_use = "FIDL methods require a response to be sent"]
12550#[derive(Debug)]
12551pub struct BaseDatagramSocketGetIpv6UnicastHopsResponder {
12552 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12553 tx_id: u32,
12554}
12555
12556impl std::ops::Drop for BaseDatagramSocketGetIpv6UnicastHopsResponder {
12560 fn drop(&mut self) {
12561 self.control_handle.shutdown();
12562 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12564 }
12565}
12566
12567impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6UnicastHopsResponder {
12568 type ControlHandle = BaseDatagramSocketControlHandle;
12569
12570 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12571 &self.control_handle
12572 }
12573
12574 fn drop_without_shutdown(mut self) {
12575 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12577 std::mem::forget(self);
12579 }
12580}
12581
12582impl BaseDatagramSocketGetIpv6UnicastHopsResponder {
12583 pub fn send(
12587 self,
12588 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12589 ) -> Result<(), fidl::Error> {
12590 let _result = self.send_raw(result);
12591 if _result.is_err() {
12592 self.control_handle.shutdown();
12593 }
12594 self.drop_without_shutdown();
12595 _result
12596 }
12597
12598 pub fn send_no_shutdown_on_err(
12600 self,
12601 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12602 ) -> Result<(), fidl::Error> {
12603 let _result = self.send_raw(result);
12604 self.drop_without_shutdown();
12605 _result
12606 }
12607
12608 fn send_raw(
12609 &self,
12610 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12611 ) -> Result<(), fidl::Error> {
12612 self.control_handle.inner.send::<fidl::encoding::ResultType<
12613 BaseNetworkSocketGetIpv6UnicastHopsResponse,
12614 fidl_fuchsia_posix::Errno,
12615 >>(
12616 result.map(|value| (value,)),
12617 self.tx_id,
12618 0x21f4641cad8bd8d2,
12619 fidl::encoding::DynamicFlags::empty(),
12620 )
12621 }
12622}
12623
12624#[must_use = "FIDL methods require a response to be sent"]
12625#[derive(Debug)]
12626pub struct BaseDatagramSocketSetIpv6ReceiveHopLimitResponder {
12627 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12628 tx_id: u32,
12629}
12630
12631impl std::ops::Drop for BaseDatagramSocketSetIpv6ReceiveHopLimitResponder {
12635 fn drop(&mut self) {
12636 self.control_handle.shutdown();
12637 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12639 }
12640}
12641
12642impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6ReceiveHopLimitResponder {
12643 type ControlHandle = BaseDatagramSocketControlHandle;
12644
12645 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12646 &self.control_handle
12647 }
12648
12649 fn drop_without_shutdown(mut self) {
12650 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12652 std::mem::forget(self);
12654 }
12655}
12656
12657impl BaseDatagramSocketSetIpv6ReceiveHopLimitResponder {
12658 pub fn send(
12662 self,
12663 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12664 ) -> Result<(), fidl::Error> {
12665 let _result = self.send_raw(result);
12666 if _result.is_err() {
12667 self.control_handle.shutdown();
12668 }
12669 self.drop_without_shutdown();
12670 _result
12671 }
12672
12673 pub fn send_no_shutdown_on_err(
12675 self,
12676 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12677 ) -> Result<(), fidl::Error> {
12678 let _result = self.send_raw(result);
12679 self.drop_without_shutdown();
12680 _result
12681 }
12682
12683 fn send_raw(
12684 &self,
12685 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12686 ) -> Result<(), fidl::Error> {
12687 self.control_handle.inner.send::<fidl::encoding::ResultType<
12688 fidl::encoding::EmptyStruct,
12689 fidl_fuchsia_posix::Errno,
12690 >>(
12691 result,
12692 self.tx_id,
12693 0x5c24808ed2e84a1e,
12694 fidl::encoding::DynamicFlags::empty(),
12695 )
12696 }
12697}
12698
12699#[must_use = "FIDL methods require a response to be sent"]
12700#[derive(Debug)]
12701pub struct BaseDatagramSocketGetIpv6ReceiveHopLimitResponder {
12702 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12703 tx_id: u32,
12704}
12705
12706impl std::ops::Drop for BaseDatagramSocketGetIpv6ReceiveHopLimitResponder {
12710 fn drop(&mut self) {
12711 self.control_handle.shutdown();
12712 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12714 }
12715}
12716
12717impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6ReceiveHopLimitResponder {
12718 type ControlHandle = BaseDatagramSocketControlHandle;
12719
12720 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12721 &self.control_handle
12722 }
12723
12724 fn drop_without_shutdown(mut self) {
12725 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12727 std::mem::forget(self);
12729 }
12730}
12731
12732impl BaseDatagramSocketGetIpv6ReceiveHopLimitResponder {
12733 pub fn send(
12737 self,
12738 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12739 ) -> Result<(), fidl::Error> {
12740 let _result = self.send_raw(result);
12741 if _result.is_err() {
12742 self.control_handle.shutdown();
12743 }
12744 self.drop_without_shutdown();
12745 _result
12746 }
12747
12748 pub fn send_no_shutdown_on_err(
12750 self,
12751 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12752 ) -> Result<(), fidl::Error> {
12753 let _result = self.send_raw(result);
12754 self.drop_without_shutdown();
12755 _result
12756 }
12757
12758 fn send_raw(
12759 &self,
12760 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12761 ) -> Result<(), fidl::Error> {
12762 self.control_handle.inner.send::<fidl::encoding::ResultType<
12763 BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
12764 fidl_fuchsia_posix::Errno,
12765 >>(
12766 result.map(|value| (value,)),
12767 self.tx_id,
12768 0x341e06689885b4c0,
12769 fidl::encoding::DynamicFlags::empty(),
12770 )
12771 }
12772}
12773
12774#[must_use = "FIDL methods require a response to be sent"]
12775#[derive(Debug)]
12776pub struct BaseDatagramSocketSetIpv6MulticastHopsResponder {
12777 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12778 tx_id: u32,
12779}
12780
12781impl std::ops::Drop for BaseDatagramSocketSetIpv6MulticastHopsResponder {
12785 fn drop(&mut self) {
12786 self.control_handle.shutdown();
12787 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12789 }
12790}
12791
12792impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6MulticastHopsResponder {
12793 type ControlHandle = BaseDatagramSocketControlHandle;
12794
12795 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12796 &self.control_handle
12797 }
12798
12799 fn drop_without_shutdown(mut self) {
12800 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12802 std::mem::forget(self);
12804 }
12805}
12806
12807impl BaseDatagramSocketSetIpv6MulticastHopsResponder {
12808 pub fn send(
12812 self,
12813 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12814 ) -> Result<(), fidl::Error> {
12815 let _result = self.send_raw(result);
12816 if _result.is_err() {
12817 self.control_handle.shutdown();
12818 }
12819 self.drop_without_shutdown();
12820 _result
12821 }
12822
12823 pub fn send_no_shutdown_on_err(
12825 self,
12826 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12827 ) -> Result<(), fidl::Error> {
12828 let _result = self.send_raw(result);
12829 self.drop_without_shutdown();
12830 _result
12831 }
12832
12833 fn send_raw(
12834 &self,
12835 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12836 ) -> Result<(), fidl::Error> {
12837 self.control_handle.inner.send::<fidl::encoding::ResultType<
12838 fidl::encoding::EmptyStruct,
12839 fidl_fuchsia_posix::Errno,
12840 >>(
12841 result,
12842 self.tx_id,
12843 0x25b9cd4d181f82c1,
12844 fidl::encoding::DynamicFlags::empty(),
12845 )
12846 }
12847}
12848
12849#[must_use = "FIDL methods require a response to be sent"]
12850#[derive(Debug)]
12851pub struct BaseDatagramSocketGetIpv6MulticastHopsResponder {
12852 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12853 tx_id: u32,
12854}
12855
12856impl std::ops::Drop for BaseDatagramSocketGetIpv6MulticastHopsResponder {
12860 fn drop(&mut self) {
12861 self.control_handle.shutdown();
12862 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12864 }
12865}
12866
12867impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6MulticastHopsResponder {
12868 type ControlHandle = BaseDatagramSocketControlHandle;
12869
12870 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12871 &self.control_handle
12872 }
12873
12874 fn drop_without_shutdown(mut self) {
12875 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12877 std::mem::forget(self);
12879 }
12880}
12881
12882impl BaseDatagramSocketGetIpv6MulticastHopsResponder {
12883 pub fn send(
12887 self,
12888 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12889 ) -> Result<(), fidl::Error> {
12890 let _result = self.send_raw(result);
12891 if _result.is_err() {
12892 self.control_handle.shutdown();
12893 }
12894 self.drop_without_shutdown();
12895 _result
12896 }
12897
12898 pub fn send_no_shutdown_on_err(
12900 self,
12901 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12902 ) -> Result<(), fidl::Error> {
12903 let _result = self.send_raw(result);
12904 self.drop_without_shutdown();
12905 _result
12906 }
12907
12908 fn send_raw(
12909 &self,
12910 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12911 ) -> Result<(), fidl::Error> {
12912 self.control_handle.inner.send::<fidl::encoding::ResultType<
12913 BaseNetworkSocketGetIpv6MulticastHopsResponse,
12914 fidl_fuchsia_posix::Errno,
12915 >>(
12916 result.map(|value| (value,)),
12917 self.tx_id,
12918 0x52916948a365012a,
12919 fidl::encoding::DynamicFlags::empty(),
12920 )
12921 }
12922}
12923
12924#[must_use = "FIDL methods require a response to be sent"]
12925#[derive(Debug)]
12926pub struct BaseDatagramSocketSetIpv6MulticastLoopbackResponder {
12927 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12928 tx_id: u32,
12929}
12930
12931impl std::ops::Drop for BaseDatagramSocketSetIpv6MulticastLoopbackResponder {
12935 fn drop(&mut self) {
12936 self.control_handle.shutdown();
12937 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12939 }
12940}
12941
12942impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6MulticastLoopbackResponder {
12943 type ControlHandle = BaseDatagramSocketControlHandle;
12944
12945 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12946 &self.control_handle
12947 }
12948
12949 fn drop_without_shutdown(mut self) {
12950 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12952 std::mem::forget(self);
12954 }
12955}
12956
12957impl BaseDatagramSocketSetIpv6MulticastLoopbackResponder {
12958 pub fn send(
12962 self,
12963 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12964 ) -> Result<(), fidl::Error> {
12965 let _result = self.send_raw(result);
12966 if _result.is_err() {
12967 self.control_handle.shutdown();
12968 }
12969 self.drop_without_shutdown();
12970 _result
12971 }
12972
12973 pub fn send_no_shutdown_on_err(
12975 self,
12976 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12977 ) -> Result<(), fidl::Error> {
12978 let _result = self.send_raw(result);
12979 self.drop_without_shutdown();
12980 _result
12981 }
12982
12983 fn send_raw(
12984 &self,
12985 mut result: Result<(), fidl_fuchsia_posix::Errno>,
12986 ) -> Result<(), fidl::Error> {
12987 self.control_handle.inner.send::<fidl::encoding::ResultType<
12988 fidl::encoding::EmptyStruct,
12989 fidl_fuchsia_posix::Errno,
12990 >>(
12991 result,
12992 self.tx_id,
12993 0x55701c409ff41b40,
12994 fidl::encoding::DynamicFlags::empty(),
12995 )
12996 }
12997}
12998
12999#[must_use = "FIDL methods require a response to be sent"]
13000#[derive(Debug)]
13001pub struct BaseDatagramSocketGetIpv6MulticastLoopbackResponder {
13002 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13003 tx_id: u32,
13004}
13005
13006impl std::ops::Drop for BaseDatagramSocketGetIpv6MulticastLoopbackResponder {
13010 fn drop(&mut self) {
13011 self.control_handle.shutdown();
13012 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13014 }
13015}
13016
13017impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6MulticastLoopbackResponder {
13018 type ControlHandle = BaseDatagramSocketControlHandle;
13019
13020 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13021 &self.control_handle
13022 }
13023
13024 fn drop_without_shutdown(mut self) {
13025 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13027 std::mem::forget(self);
13029 }
13030}
13031
13032impl BaseDatagramSocketGetIpv6MulticastLoopbackResponder {
13033 pub fn send(
13037 self,
13038 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13039 ) -> Result<(), fidl::Error> {
13040 let _result = self.send_raw(result);
13041 if _result.is_err() {
13042 self.control_handle.shutdown();
13043 }
13044 self.drop_without_shutdown();
13045 _result
13046 }
13047
13048 pub fn send_no_shutdown_on_err(
13050 self,
13051 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13052 ) -> Result<(), fidl::Error> {
13053 let _result = self.send_raw(result);
13054 self.drop_without_shutdown();
13055 _result
13056 }
13057
13058 fn send_raw(
13059 &self,
13060 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13061 ) -> Result<(), fidl::Error> {
13062 self.control_handle.inner.send::<fidl::encoding::ResultType<
13063 BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
13064 fidl_fuchsia_posix::Errno,
13065 >>(
13066 result.map(|value| (value,)),
13067 self.tx_id,
13068 0x4415b701fde319c3,
13069 fidl::encoding::DynamicFlags::empty(),
13070 )
13071 }
13072}
13073
13074#[must_use = "FIDL methods require a response to be sent"]
13075#[derive(Debug)]
13076pub struct BaseDatagramSocketSetIpv6OnlyResponder {
13077 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13078 tx_id: u32,
13079}
13080
13081impl std::ops::Drop for BaseDatagramSocketSetIpv6OnlyResponder {
13085 fn drop(&mut self) {
13086 self.control_handle.shutdown();
13087 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13089 }
13090}
13091
13092impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6OnlyResponder {
13093 type ControlHandle = BaseDatagramSocketControlHandle;
13094
13095 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13096 &self.control_handle
13097 }
13098
13099 fn drop_without_shutdown(mut self) {
13100 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13102 std::mem::forget(self);
13104 }
13105}
13106
13107impl BaseDatagramSocketSetIpv6OnlyResponder {
13108 pub fn send(
13112 self,
13113 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13114 ) -> Result<(), fidl::Error> {
13115 let _result = self.send_raw(result);
13116 if _result.is_err() {
13117 self.control_handle.shutdown();
13118 }
13119 self.drop_without_shutdown();
13120 _result
13121 }
13122
13123 pub fn send_no_shutdown_on_err(
13125 self,
13126 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13127 ) -> Result<(), fidl::Error> {
13128 let _result = self.send_raw(result);
13129 self.drop_without_shutdown();
13130 _result
13131 }
13132
13133 fn send_raw(
13134 &self,
13135 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13136 ) -> Result<(), fidl::Error> {
13137 self.control_handle.inner.send::<fidl::encoding::ResultType<
13138 fidl::encoding::EmptyStruct,
13139 fidl_fuchsia_posix::Errno,
13140 >>(
13141 result,
13142 self.tx_id,
13143 0x4873f1364758cbba,
13144 fidl::encoding::DynamicFlags::empty(),
13145 )
13146 }
13147}
13148
13149#[must_use = "FIDL methods require a response to be sent"]
13150#[derive(Debug)]
13151pub struct BaseDatagramSocketGetIpv6OnlyResponder {
13152 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13153 tx_id: u32,
13154}
13155
13156impl std::ops::Drop for BaseDatagramSocketGetIpv6OnlyResponder {
13160 fn drop(&mut self) {
13161 self.control_handle.shutdown();
13162 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13164 }
13165}
13166
13167impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6OnlyResponder {
13168 type ControlHandle = BaseDatagramSocketControlHandle;
13169
13170 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13171 &self.control_handle
13172 }
13173
13174 fn drop_without_shutdown(mut self) {
13175 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13177 std::mem::forget(self);
13179 }
13180}
13181
13182impl BaseDatagramSocketGetIpv6OnlyResponder {
13183 pub fn send(
13187 self,
13188 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13189 ) -> Result<(), fidl::Error> {
13190 let _result = self.send_raw(result);
13191 if _result.is_err() {
13192 self.control_handle.shutdown();
13193 }
13194 self.drop_without_shutdown();
13195 _result
13196 }
13197
13198 pub fn send_no_shutdown_on_err(
13200 self,
13201 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13202 ) -> Result<(), fidl::Error> {
13203 let _result = self.send_raw(result);
13204 self.drop_without_shutdown();
13205 _result
13206 }
13207
13208 fn send_raw(
13209 &self,
13210 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13211 ) -> Result<(), fidl::Error> {
13212 self.control_handle.inner.send::<fidl::encoding::ResultType<
13213 BaseNetworkSocketGetIpv6OnlyResponse,
13214 fidl_fuchsia_posix::Errno,
13215 >>(
13216 result.map(|value| (value,)),
13217 self.tx_id,
13218 0x4aa3340a1a26b89c,
13219 fidl::encoding::DynamicFlags::empty(),
13220 )
13221 }
13222}
13223
13224#[must_use = "FIDL methods require a response to be sent"]
13225#[derive(Debug)]
13226pub struct BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder {
13227 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13228 tx_id: u32,
13229}
13230
13231impl std::ops::Drop for BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder {
13235 fn drop(&mut self) {
13236 self.control_handle.shutdown();
13237 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13239 }
13240}
13241
13242impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder {
13243 type ControlHandle = BaseDatagramSocketControlHandle;
13244
13245 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13246 &self.control_handle
13247 }
13248
13249 fn drop_without_shutdown(mut self) {
13250 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13252 std::mem::forget(self);
13254 }
13255}
13256
13257impl BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder {
13258 pub fn send(
13262 self,
13263 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13264 ) -> Result<(), fidl::Error> {
13265 let _result = self.send_raw(result);
13266 if _result.is_err() {
13267 self.control_handle.shutdown();
13268 }
13269 self.drop_without_shutdown();
13270 _result
13271 }
13272
13273 pub fn send_no_shutdown_on_err(
13275 self,
13276 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13277 ) -> Result<(), fidl::Error> {
13278 let _result = self.send_raw(result);
13279 self.drop_without_shutdown();
13280 _result
13281 }
13282
13283 fn send_raw(
13284 &self,
13285 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13286 ) -> Result<(), fidl::Error> {
13287 self.control_handle.inner.send::<fidl::encoding::ResultType<
13288 fidl::encoding::EmptyStruct,
13289 fidl_fuchsia_posix::Errno,
13290 >>(
13291 result,
13292 self.tx_id,
13293 0x58f07c8788d099a0,
13294 fidl::encoding::DynamicFlags::empty(),
13295 )
13296 }
13297}
13298
13299#[must_use = "FIDL methods require a response to be sent"]
13300#[derive(Debug)]
13301pub struct BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder {
13302 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13303 tx_id: u32,
13304}
13305
13306impl std::ops::Drop for BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder {
13310 fn drop(&mut self) {
13311 self.control_handle.shutdown();
13312 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13314 }
13315}
13316
13317impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder {
13318 type ControlHandle = BaseDatagramSocketControlHandle;
13319
13320 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13321 &self.control_handle
13322 }
13323
13324 fn drop_without_shutdown(mut self) {
13325 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13327 std::mem::forget(self);
13329 }
13330}
13331
13332impl BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder {
13333 pub fn send(
13337 self,
13338 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13339 ) -> Result<(), fidl::Error> {
13340 let _result = self.send_raw(result);
13341 if _result.is_err() {
13342 self.control_handle.shutdown();
13343 }
13344 self.drop_without_shutdown();
13345 _result
13346 }
13347
13348 pub fn send_no_shutdown_on_err(
13350 self,
13351 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13352 ) -> Result<(), fidl::Error> {
13353 let _result = self.send_raw(result);
13354 self.drop_without_shutdown();
13355 _result
13356 }
13357
13358 fn send_raw(
13359 &self,
13360 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13361 ) -> Result<(), fidl::Error> {
13362 self.control_handle.inner.send::<fidl::encoding::ResultType<
13363 BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
13364 fidl_fuchsia_posix::Errno,
13365 >>(
13366 result.map(|value| (value,)),
13367 self.tx_id,
13368 0x2e334df1da553ffa,
13369 fidl::encoding::DynamicFlags::empty(),
13370 )
13371 }
13372}
13373
13374#[must_use = "FIDL methods require a response to be sent"]
13375#[derive(Debug)]
13376pub struct BaseDatagramSocketSetIpv6TrafficClassResponder {
13377 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13378 tx_id: u32,
13379}
13380
13381impl std::ops::Drop for BaseDatagramSocketSetIpv6TrafficClassResponder {
13385 fn drop(&mut self) {
13386 self.control_handle.shutdown();
13387 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13389 }
13390}
13391
13392impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6TrafficClassResponder {
13393 type ControlHandle = BaseDatagramSocketControlHandle;
13394
13395 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13396 &self.control_handle
13397 }
13398
13399 fn drop_without_shutdown(mut self) {
13400 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13402 std::mem::forget(self);
13404 }
13405}
13406
13407impl BaseDatagramSocketSetIpv6TrafficClassResponder {
13408 pub fn send(
13412 self,
13413 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13414 ) -> Result<(), fidl::Error> {
13415 let _result = self.send_raw(result);
13416 if _result.is_err() {
13417 self.control_handle.shutdown();
13418 }
13419 self.drop_without_shutdown();
13420 _result
13421 }
13422
13423 pub fn send_no_shutdown_on_err(
13425 self,
13426 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13427 ) -> Result<(), fidl::Error> {
13428 let _result = self.send_raw(result);
13429 self.drop_without_shutdown();
13430 _result
13431 }
13432
13433 fn send_raw(
13434 &self,
13435 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13436 ) -> Result<(), fidl::Error> {
13437 self.control_handle.inner.send::<fidl::encoding::ResultType<
13438 fidl::encoding::EmptyStruct,
13439 fidl_fuchsia_posix::Errno,
13440 >>(
13441 result,
13442 self.tx_id,
13443 0x6af077800c5a0b4f,
13444 fidl::encoding::DynamicFlags::empty(),
13445 )
13446 }
13447}
13448
13449#[must_use = "FIDL methods require a response to be sent"]
13450#[derive(Debug)]
13451pub struct BaseDatagramSocketGetIpv6TrafficClassResponder {
13452 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13453 tx_id: u32,
13454}
13455
13456impl std::ops::Drop for BaseDatagramSocketGetIpv6TrafficClassResponder {
13460 fn drop(&mut self) {
13461 self.control_handle.shutdown();
13462 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13464 }
13465}
13466
13467impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6TrafficClassResponder {
13468 type ControlHandle = BaseDatagramSocketControlHandle;
13469
13470 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13471 &self.control_handle
13472 }
13473
13474 fn drop_without_shutdown(mut self) {
13475 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13477 std::mem::forget(self);
13479 }
13480}
13481
13482impl BaseDatagramSocketGetIpv6TrafficClassResponder {
13483 pub fn send(
13487 self,
13488 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
13489 ) -> Result<(), fidl::Error> {
13490 let _result = self.send_raw(result);
13491 if _result.is_err() {
13492 self.control_handle.shutdown();
13493 }
13494 self.drop_without_shutdown();
13495 _result
13496 }
13497
13498 pub fn send_no_shutdown_on_err(
13500 self,
13501 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
13502 ) -> Result<(), fidl::Error> {
13503 let _result = self.send_raw(result);
13504 self.drop_without_shutdown();
13505 _result
13506 }
13507
13508 fn send_raw(
13509 &self,
13510 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
13511 ) -> Result<(), fidl::Error> {
13512 self.control_handle.inner.send::<fidl::encoding::ResultType<
13513 BaseNetworkSocketGetIpv6TrafficClassResponse,
13514 fidl_fuchsia_posix::Errno,
13515 >>(
13516 result.map(|value| (value,)),
13517 self.tx_id,
13518 0x6baf6eed8fc2f04,
13519 fidl::encoding::DynamicFlags::empty(),
13520 )
13521 }
13522}
13523
13524#[must_use = "FIDL methods require a response to be sent"]
13525#[derive(Debug)]
13526pub struct BaseDatagramSocketSetIpv6ReceivePacketInfoResponder {
13527 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13528 tx_id: u32,
13529}
13530
13531impl std::ops::Drop for BaseDatagramSocketSetIpv6ReceivePacketInfoResponder {
13535 fn drop(&mut self) {
13536 self.control_handle.shutdown();
13537 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13539 }
13540}
13541
13542impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6ReceivePacketInfoResponder {
13543 type ControlHandle = BaseDatagramSocketControlHandle;
13544
13545 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13546 &self.control_handle
13547 }
13548
13549 fn drop_without_shutdown(mut self) {
13550 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13552 std::mem::forget(self);
13554 }
13555}
13556
13557impl BaseDatagramSocketSetIpv6ReceivePacketInfoResponder {
13558 pub fn send(
13562 self,
13563 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13564 ) -> Result<(), fidl::Error> {
13565 let _result = self.send_raw(result);
13566 if _result.is_err() {
13567 self.control_handle.shutdown();
13568 }
13569 self.drop_without_shutdown();
13570 _result
13571 }
13572
13573 pub fn send_no_shutdown_on_err(
13575 self,
13576 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13577 ) -> Result<(), fidl::Error> {
13578 let _result = self.send_raw(result);
13579 self.drop_without_shutdown();
13580 _result
13581 }
13582
13583 fn send_raw(
13584 &self,
13585 mut result: Result<(), fidl_fuchsia_posix::Errno>,
13586 ) -> Result<(), fidl::Error> {
13587 self.control_handle.inner.send::<fidl::encoding::ResultType<
13588 fidl::encoding::EmptyStruct,
13589 fidl_fuchsia_posix::Errno,
13590 >>(
13591 result,
13592 self.tx_id,
13593 0x19259775b1a92768,
13594 fidl::encoding::DynamicFlags::empty(),
13595 )
13596 }
13597}
13598
13599#[must_use = "FIDL methods require a response to be sent"]
13600#[derive(Debug)]
13601pub struct BaseDatagramSocketGetIpv6ReceivePacketInfoResponder {
13602 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13603 tx_id: u32,
13604}
13605
13606impl std::ops::Drop for BaseDatagramSocketGetIpv6ReceivePacketInfoResponder {
13610 fn drop(&mut self) {
13611 self.control_handle.shutdown();
13612 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13614 }
13615}
13616
13617impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6ReceivePacketInfoResponder {
13618 type ControlHandle = BaseDatagramSocketControlHandle;
13619
13620 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13621 &self.control_handle
13622 }
13623
13624 fn drop_without_shutdown(mut self) {
13625 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13627 std::mem::forget(self);
13629 }
13630}
13631
13632impl BaseDatagramSocketGetIpv6ReceivePacketInfoResponder {
13633 pub fn send(
13637 self,
13638 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13639 ) -> Result<(), fidl::Error> {
13640 let _result = self.send_raw(result);
13641 if _result.is_err() {
13642 self.control_handle.shutdown();
13643 }
13644 self.drop_without_shutdown();
13645 _result
13646 }
13647
13648 pub fn send_no_shutdown_on_err(
13650 self,
13651 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13652 ) -> Result<(), fidl::Error> {
13653 let _result = self.send_raw(result);
13654 self.drop_without_shutdown();
13655 _result
13656 }
13657
13658 fn send_raw(
13659 &self,
13660 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13661 ) -> Result<(), fidl::Error> {
13662 self.control_handle.inner.send::<fidl::encoding::ResultType<
13663 BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
13664 fidl_fuchsia_posix::Errno,
13665 >>(
13666 result.map(|value| (value,)),
13667 self.tx_id,
13668 0x7acd4a2775baec75,
13669 fidl::encoding::DynamicFlags::empty(),
13670 )
13671 }
13672}
13673
13674#[must_use = "FIDL methods require a response to be sent"]
13675#[derive(Debug)]
13676pub struct BaseDatagramSocketGetOriginalDestinationResponder {
13677 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13678 tx_id: u32,
13679}
13680
13681impl std::ops::Drop for BaseDatagramSocketGetOriginalDestinationResponder {
13685 fn drop(&mut self) {
13686 self.control_handle.shutdown();
13687 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13689 }
13690}
13691
13692impl fidl::endpoints::Responder for BaseDatagramSocketGetOriginalDestinationResponder {
13693 type ControlHandle = BaseDatagramSocketControlHandle;
13694
13695 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13696 &self.control_handle
13697 }
13698
13699 fn drop_without_shutdown(mut self) {
13700 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13702 std::mem::forget(self);
13704 }
13705}
13706
13707impl BaseDatagramSocketGetOriginalDestinationResponder {
13708 pub fn send(
13712 self,
13713 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
13714 ) -> Result<(), fidl::Error> {
13715 let _result = self.send_raw(result);
13716 if _result.is_err() {
13717 self.control_handle.shutdown();
13718 }
13719 self.drop_without_shutdown();
13720 _result
13721 }
13722
13723 pub fn send_no_shutdown_on_err(
13725 self,
13726 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
13727 ) -> Result<(), fidl::Error> {
13728 let _result = self.send_raw(result);
13729 self.drop_without_shutdown();
13730 _result
13731 }
13732
13733 fn send_raw(
13734 &self,
13735 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
13736 ) -> Result<(), fidl::Error> {
13737 self.control_handle.inner.send::<fidl::encoding::ResultType<
13738 BaseNetworkSocketGetOriginalDestinationResponse,
13739 fidl_fuchsia_posix::Errno,
13740 >>(
13741 result.map(|value| (value,)),
13742 self.tx_id,
13743 0x38bf28f0dafdbac0,
13744 fidl::encoding::DynamicFlags::empty(),
13745 )
13746 }
13747}
13748
13749#[must_use = "FIDL methods require a response to be sent"]
13750#[derive(Debug)]
13751pub struct BaseDatagramSocketGetInfoResponder {
13752 control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13753 tx_id: u32,
13754}
13755
13756impl std::ops::Drop for BaseDatagramSocketGetInfoResponder {
13760 fn drop(&mut self) {
13761 self.control_handle.shutdown();
13762 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13764 }
13765}
13766
13767impl fidl::endpoints::Responder for BaseDatagramSocketGetInfoResponder {
13768 type ControlHandle = BaseDatagramSocketControlHandle;
13769
13770 fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13771 &self.control_handle
13772 }
13773
13774 fn drop_without_shutdown(mut self) {
13775 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13777 std::mem::forget(self);
13779 }
13780}
13781
13782impl BaseDatagramSocketGetInfoResponder {
13783 pub fn send(
13787 self,
13788 mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
13789 ) -> Result<(), fidl::Error> {
13790 let _result = self.send_raw(result);
13791 if _result.is_err() {
13792 self.control_handle.shutdown();
13793 }
13794 self.drop_without_shutdown();
13795 _result
13796 }
13797
13798 pub fn send_no_shutdown_on_err(
13800 self,
13801 mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
13802 ) -> Result<(), fidl::Error> {
13803 let _result = self.send_raw(result);
13804 self.drop_without_shutdown();
13805 _result
13806 }
13807
13808 fn send_raw(
13809 &self,
13810 mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
13811 ) -> Result<(), fidl::Error> {
13812 self.control_handle.inner.send::<fidl::encoding::ResultType<
13813 BaseDatagramSocketGetInfoResponse,
13814 fidl_fuchsia_posix::Errno,
13815 >>(
13816 result,
13817 self.tx_id,
13818 0x48aa0a1f6a32d2ed,
13819 fidl::encoding::DynamicFlags::empty(),
13820 )
13821 }
13822}
13823
13824#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
13825pub struct BaseNetworkSocketMarker;
13826
13827impl fidl::endpoints::ProtocolMarker for BaseNetworkSocketMarker {
13828 type Proxy = BaseNetworkSocketProxy;
13829 type RequestStream = BaseNetworkSocketRequestStream;
13830 #[cfg(target_os = "fuchsia")]
13831 type SynchronousProxy = BaseNetworkSocketSynchronousProxy;
13832
13833 const DEBUG_NAME: &'static str = "(anonymous) BaseNetworkSocket";
13834}
13835pub type BaseNetworkSocketBindResult = Result<(), fidl_fuchsia_posix::Errno>;
13836pub type BaseNetworkSocketConnectResult = Result<(), fidl_fuchsia_posix::Errno>;
13837pub type BaseNetworkSocketDisconnectResult = Result<(), fidl_fuchsia_posix::Errno>;
13838pub type BaseNetworkSocketGetSockNameResult =
13839 Result<fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>;
13840pub type BaseNetworkSocketGetPeerNameResult =
13841 Result<fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>;
13842pub type BaseNetworkSocketShutdownResult = Result<(), fidl_fuchsia_posix::Errno>;
13843pub type BaseNetworkSocketSetIpTypeOfServiceResult = Result<(), fidl_fuchsia_posix::Errno>;
13844pub type BaseNetworkSocketGetIpTypeOfServiceResult = Result<u8, fidl_fuchsia_posix::Errno>;
13845pub type BaseNetworkSocketSetIpTtlResult = Result<(), fidl_fuchsia_posix::Errno>;
13846pub type BaseNetworkSocketGetIpTtlResult = Result<u8, fidl_fuchsia_posix::Errno>;
13847pub type BaseNetworkSocketSetIpPacketInfoResult = Result<(), fidl_fuchsia_posix::Errno>;
13848pub type BaseNetworkSocketGetIpPacketInfoResult = Result<bool, fidl_fuchsia_posix::Errno>;
13849pub type BaseNetworkSocketSetIpReceiveTypeOfServiceResult = Result<(), fidl_fuchsia_posix::Errno>;
13850pub type BaseNetworkSocketGetIpReceiveTypeOfServiceResult = Result<bool, fidl_fuchsia_posix::Errno>;
13851pub type BaseNetworkSocketSetIpReceiveTtlResult = Result<(), fidl_fuchsia_posix::Errno>;
13852pub type BaseNetworkSocketGetIpReceiveTtlResult = Result<bool, fidl_fuchsia_posix::Errno>;
13853pub type BaseNetworkSocketSetIpMulticastInterfaceResult = Result<(), fidl_fuchsia_posix::Errno>;
13854pub type BaseNetworkSocketGetIpMulticastInterfaceResult =
13855 Result<fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>;
13856pub type BaseNetworkSocketSetIpMulticastTtlResult = Result<(), fidl_fuchsia_posix::Errno>;
13857pub type BaseNetworkSocketGetIpMulticastTtlResult = Result<u8, fidl_fuchsia_posix::Errno>;
13858pub type BaseNetworkSocketSetIpMulticastLoopbackResult = Result<(), fidl_fuchsia_posix::Errno>;
13859pub type BaseNetworkSocketGetIpMulticastLoopbackResult = Result<bool, fidl_fuchsia_posix::Errno>;
13860pub type BaseNetworkSocketAddIpMembershipResult = Result<(), fidl_fuchsia_posix::Errno>;
13861pub type BaseNetworkSocketDropIpMembershipResult = Result<(), fidl_fuchsia_posix::Errno>;
13862pub type BaseNetworkSocketSetIpTransparentResult = Result<(), fidl_fuchsia_posix::Errno>;
13863pub type BaseNetworkSocketGetIpTransparentResult = Result<bool, fidl_fuchsia_posix::Errno>;
13864pub type BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult =
13865 Result<(), fidl_fuchsia_posix::Errno>;
13866pub type BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult =
13867 Result<bool, fidl_fuchsia_posix::Errno>;
13868pub type BaseNetworkSocketAddIpv6MembershipResult = Result<(), fidl_fuchsia_posix::Errno>;
13869pub type BaseNetworkSocketDropIpv6MembershipResult = Result<(), fidl_fuchsia_posix::Errno>;
13870pub type BaseNetworkSocketSetIpv6MulticastInterfaceResult = Result<(), fidl_fuchsia_posix::Errno>;
13871pub type BaseNetworkSocketGetIpv6MulticastInterfaceResult = Result<u64, fidl_fuchsia_posix::Errno>;
13872pub type BaseNetworkSocketSetIpv6UnicastHopsResult = Result<(), fidl_fuchsia_posix::Errno>;
13873pub type BaseNetworkSocketGetIpv6UnicastHopsResult = Result<u8, fidl_fuchsia_posix::Errno>;
13874pub type BaseNetworkSocketSetIpv6ReceiveHopLimitResult = Result<(), fidl_fuchsia_posix::Errno>;
13875pub type BaseNetworkSocketGetIpv6ReceiveHopLimitResult = Result<bool, fidl_fuchsia_posix::Errno>;
13876pub type BaseNetworkSocketSetIpv6MulticastHopsResult = Result<(), fidl_fuchsia_posix::Errno>;
13877pub type BaseNetworkSocketGetIpv6MulticastHopsResult = Result<u8, fidl_fuchsia_posix::Errno>;
13878pub type BaseNetworkSocketSetIpv6MulticastLoopbackResult = Result<(), fidl_fuchsia_posix::Errno>;
13879pub type BaseNetworkSocketGetIpv6MulticastLoopbackResult = Result<bool, fidl_fuchsia_posix::Errno>;
13880pub type BaseNetworkSocketSetIpv6OnlyResult = Result<(), fidl_fuchsia_posix::Errno>;
13881pub type BaseNetworkSocketGetIpv6OnlyResult = Result<bool, fidl_fuchsia_posix::Errno>;
13882pub type BaseNetworkSocketSetIpv6ReceiveTrafficClassResult = Result<(), fidl_fuchsia_posix::Errno>;
13883pub type BaseNetworkSocketGetIpv6ReceiveTrafficClassResult =
13884 Result<bool, fidl_fuchsia_posix::Errno>;
13885pub type BaseNetworkSocketSetIpv6TrafficClassResult = Result<(), fidl_fuchsia_posix::Errno>;
13886pub type BaseNetworkSocketGetIpv6TrafficClassResult = Result<u8, fidl_fuchsia_posix::Errno>;
13887pub type BaseNetworkSocketSetIpv6ReceivePacketInfoResult = Result<(), fidl_fuchsia_posix::Errno>;
13888pub type BaseNetworkSocketGetIpv6ReceivePacketInfoResult = Result<bool, fidl_fuchsia_posix::Errno>;
13889pub type BaseNetworkSocketGetOriginalDestinationResult =
13890 Result<fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>;
13891
13892pub trait BaseNetworkSocketProxyInterface: Send + Sync {
13893 fn r#clone(
13894 &self,
13895 request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
13896 ) -> Result<(), fidl::Error>;
13897 type CloseResponseFut: std::future::Future<
13898 Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
13899 > + Send;
13900 fn r#close(&self) -> Self::CloseResponseFut;
13901 type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
13902 fn r#query(&self) -> Self::QueryResponseFut;
13903 type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
13904 + Send;
13905 fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
13906 type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
13907 + Send;
13908 fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
13909 type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
13910 + Send;
13911 fn r#get_error(&self) -> Self::GetErrorResponseFut;
13912 type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
13913 + Send;
13914 fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
13915 type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
13916 + Send;
13917 fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
13918 type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
13919 + Send;
13920 fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
13921 type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
13922 + Send;
13923 fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
13924 type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
13925 + Send;
13926 fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
13927 type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
13928 + Send;
13929 fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
13930 type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
13931 + Send;
13932 fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
13933 type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
13934 + Send;
13935 fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
13936 type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
13937 + Send;
13938 fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
13939 type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
13940 + Send;
13941 fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
13942 type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
13943 + Send;
13944 fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
13945 type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
13946 + Send;
13947 fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
13948 type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
13949 + Send;
13950 fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
13951 type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
13952 + Send;
13953 fn r#get_linger(&self) -> Self::GetLingerResponseFut;
13954 type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
13955 + Send;
13956 fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
13957 type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
13958 + Send;
13959 fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
13960 type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
13961 + Send;
13962 fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
13963 type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
13964 + Send;
13965 fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
13966 type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
13967 + Send;
13968 fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
13969 type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
13970 + Send;
13971 fn r#set_bind_to_interface_index(&self, value: u64)
13972 -> Self::SetBindToInterfaceIndexResponseFut;
13973 type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
13974 + Send;
13975 fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
13976 type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
13977 + Send;
13978 fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
13979 type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
13980 + Send;
13981 fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
13982 type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
13983 + Send;
13984 fn r#set_mark(
13985 &self,
13986 domain: fidl_fuchsia_net::MarkDomain,
13987 mark: &OptionalUint32,
13988 ) -> Self::SetMarkResponseFut;
13989 type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
13990 + Send;
13991 fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
13992 type BindResponseFut: std::future::Future<Output = Result<BaseNetworkSocketBindResult, fidl::Error>>
13993 + Send;
13994 fn r#bind(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut;
13995 type ConnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketConnectResult, fidl::Error>>
13996 + Send;
13997 fn r#connect(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut;
13998 type DisconnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDisconnectResult, fidl::Error>>
13999 + Send;
14000 fn r#disconnect(&self) -> Self::DisconnectResponseFut;
14001 type GetSockNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetSockNameResult, fidl::Error>>
14002 + Send;
14003 fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
14004 type GetPeerNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetPeerNameResult, fidl::Error>>
14005 + Send;
14006 fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
14007 type ShutdownResponseFut: std::future::Future<Output = Result<BaseNetworkSocketShutdownResult, fidl::Error>>
14008 + Send;
14009 fn r#shutdown(&self, mode: ShutdownMode) -> Self::ShutdownResponseFut;
14010 type SetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>>
14011 + Send;
14012 fn r#set_ip_type_of_service(&self, value: u8) -> Self::SetIpTypeOfServiceResponseFut;
14013 type GetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>>
14014 + Send;
14015 fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut;
14016 type SetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTtlResult, fidl::Error>>
14017 + Send;
14018 fn r#set_ip_ttl(&self, value: &OptionalUint8) -> Self::SetIpTtlResponseFut;
14019 type GetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTtlResult, fidl::Error>>
14020 + Send;
14021 fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut;
14022 type SetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>>
14023 + Send;
14024 fn r#set_ip_packet_info(&self, value: bool) -> Self::SetIpPacketInfoResponseFut;
14025 type GetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>>
14026 + Send;
14027 fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut;
14028 type SetIpReceiveTypeOfServiceResponseFut: std::future::Future<
14029 Output = Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error>,
14030 > + Send;
14031 fn r#set_ip_receive_type_of_service(
14032 &self,
14033 value: bool,
14034 ) -> Self::SetIpReceiveTypeOfServiceResponseFut;
14035 type GetIpReceiveTypeOfServiceResponseFut: std::future::Future<
14036 Output = Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error>,
14037 > + Send;
14038 fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut;
14039 type SetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>>
14040 + Send;
14041 fn r#set_ip_receive_ttl(&self, value: bool) -> Self::SetIpReceiveTtlResponseFut;
14042 type GetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>>
14043 + Send;
14044 fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut;
14045 type SetIpMulticastInterfaceResponseFut: std::future::Future<
14046 Output = Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error>,
14047 > + Send;
14048 fn r#set_ip_multicast_interface(
14049 &self,
14050 iface: u64,
14051 address: &fidl_fuchsia_net::Ipv4Address,
14052 ) -> Self::SetIpMulticastInterfaceResponseFut;
14053 type GetIpMulticastInterfaceResponseFut: std::future::Future<
14054 Output = Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error>,
14055 > + Send;
14056 fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut;
14057 type SetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>>
14058 + Send;
14059 fn r#set_ip_multicast_ttl(&self, value: &OptionalUint8) -> Self::SetIpMulticastTtlResponseFut;
14060 type GetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>>
14061 + Send;
14062 fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut;
14063 type SetIpMulticastLoopbackResponseFut: std::future::Future<
14064 Output = Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error>,
14065 > + Send;
14066 fn r#set_ip_multicast_loopback(&self, value: bool) -> Self::SetIpMulticastLoopbackResponseFut;
14067 type GetIpMulticastLoopbackResponseFut: std::future::Future<
14068 Output = Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error>,
14069 > + Send;
14070 fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut;
14071 type AddIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error>>
14072 + Send;
14073 fn r#add_ip_membership(
14074 &self,
14075 membership: &IpMulticastMembership,
14076 ) -> Self::AddIpMembershipResponseFut;
14077 type DropIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error>>
14078 + Send;
14079 fn r#drop_ip_membership(
14080 &self,
14081 membership: &IpMulticastMembership,
14082 ) -> Self::DropIpMembershipResponseFut;
14083 type SetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error>>
14084 + Send;
14085 fn r#set_ip_transparent(&self, value: bool) -> Self::SetIpTransparentResponseFut;
14086 type GetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error>>
14087 + Send;
14088 fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut;
14089 type SetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
14090 Output = Result<
14091 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
14092 fidl::Error,
14093 >,
14094 > + Send;
14095 fn r#set_ip_receive_original_destination_address(
14096 &self,
14097 value: bool,
14098 ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut;
14099 type GetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
14100 Output = Result<
14101 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
14102 fidl::Error,
14103 >,
14104 > + Send;
14105 fn r#get_ip_receive_original_destination_address(
14106 &self,
14107 ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut;
14108 type AddIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>>
14109 + Send;
14110 fn r#add_ipv6_membership(
14111 &self,
14112 membership: &Ipv6MulticastMembership,
14113 ) -> Self::AddIpv6MembershipResponseFut;
14114 type DropIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>>
14115 + Send;
14116 fn r#drop_ipv6_membership(
14117 &self,
14118 membership: &Ipv6MulticastMembership,
14119 ) -> Self::DropIpv6MembershipResponseFut;
14120 type SetIpv6MulticastInterfaceResponseFut: std::future::Future<
14121 Output = Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error>,
14122 > + Send;
14123 fn r#set_ipv6_multicast_interface(
14124 &self,
14125 value: u64,
14126 ) -> Self::SetIpv6MulticastInterfaceResponseFut;
14127 type GetIpv6MulticastInterfaceResponseFut: std::future::Future<
14128 Output = Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error>,
14129 > + Send;
14130 fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut;
14131 type SetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>>
14132 + Send;
14133 fn r#set_ipv6_unicast_hops(&self, value: &OptionalUint8)
14134 -> Self::SetIpv6UnicastHopsResponseFut;
14135 type GetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>>
14136 + Send;
14137 fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut;
14138 type SetIpv6ReceiveHopLimitResponseFut: std::future::Future<
14139 Output = Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error>,
14140 > + Send;
14141 fn r#set_ipv6_receive_hop_limit(&self, value: bool) -> Self::SetIpv6ReceiveHopLimitResponseFut;
14142 type GetIpv6ReceiveHopLimitResponseFut: std::future::Future<
14143 Output = Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error>,
14144 > + Send;
14145 fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut;
14146 type SetIpv6MulticastHopsResponseFut: std::future::Future<
14147 Output = Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error>,
14148 > + Send;
14149 fn r#set_ipv6_multicast_hops(
14150 &self,
14151 value: &OptionalUint8,
14152 ) -> Self::SetIpv6MulticastHopsResponseFut;
14153 type GetIpv6MulticastHopsResponseFut: std::future::Future<
14154 Output = Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error>,
14155 > + Send;
14156 fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut;
14157 type SetIpv6MulticastLoopbackResponseFut: std::future::Future<
14158 Output = Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error>,
14159 > + Send;
14160 fn r#set_ipv6_multicast_loopback(
14161 &self,
14162 value: bool,
14163 ) -> Self::SetIpv6MulticastLoopbackResponseFut;
14164 type GetIpv6MulticastLoopbackResponseFut: std::future::Future<
14165 Output = Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error>,
14166 > + Send;
14167 fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut;
14168 type SetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error>>
14169 + Send;
14170 fn r#set_ipv6_only(&self, value: bool) -> Self::SetIpv6OnlyResponseFut;
14171 type GetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error>>
14172 + Send;
14173 fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut;
14174 type SetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
14175 Output = Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error>,
14176 > + Send;
14177 fn r#set_ipv6_receive_traffic_class(
14178 &self,
14179 value: bool,
14180 ) -> Self::SetIpv6ReceiveTrafficClassResponseFut;
14181 type GetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
14182 Output = Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error>,
14183 > + Send;
14184 fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut;
14185 type SetIpv6TrafficClassResponseFut: std::future::Future<
14186 Output = Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error>,
14187 > + Send;
14188 fn r#set_ipv6_traffic_class(
14189 &self,
14190 value: &OptionalUint8,
14191 ) -> Self::SetIpv6TrafficClassResponseFut;
14192 type GetIpv6TrafficClassResponseFut: std::future::Future<
14193 Output = Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error>,
14194 > + Send;
14195 fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut;
14196 type SetIpv6ReceivePacketInfoResponseFut: std::future::Future<
14197 Output = Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error>,
14198 > + Send;
14199 fn r#set_ipv6_receive_packet_info(
14200 &self,
14201 value: bool,
14202 ) -> Self::SetIpv6ReceivePacketInfoResponseFut;
14203 type GetIpv6ReceivePacketInfoResponseFut: std::future::Future<
14204 Output = Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error>,
14205 > + Send;
14206 fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut;
14207 type GetOriginalDestinationResponseFut: std::future::Future<
14208 Output = Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error>,
14209 > + Send;
14210 fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut;
14211}
14212#[derive(Debug)]
14213#[cfg(target_os = "fuchsia")]
14214pub struct BaseNetworkSocketSynchronousProxy {
14215 client: fidl::client::sync::Client,
14216}
14217
14218#[cfg(target_os = "fuchsia")]
14219impl fidl::endpoints::SynchronousProxy for BaseNetworkSocketSynchronousProxy {
14220 type Proxy = BaseNetworkSocketProxy;
14221 type Protocol = BaseNetworkSocketMarker;
14222
14223 fn from_channel(inner: fidl::Channel) -> Self {
14224 Self::new(inner)
14225 }
14226
14227 fn into_channel(self) -> fidl::Channel {
14228 self.client.into_channel()
14229 }
14230
14231 fn as_channel(&self) -> &fidl::Channel {
14232 self.client.as_channel()
14233 }
14234}
14235
14236#[cfg(target_os = "fuchsia")]
14237impl BaseNetworkSocketSynchronousProxy {
14238 pub fn new(channel: fidl::Channel) -> Self {
14239 let protocol_name =
14240 <BaseNetworkSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
14241 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
14242 }
14243
14244 pub fn into_channel(self) -> fidl::Channel {
14245 self.client.into_channel()
14246 }
14247
14248 pub fn wait_for_event(
14251 &self,
14252 deadline: zx::MonotonicInstant,
14253 ) -> Result<BaseNetworkSocketEvent, fidl::Error> {
14254 BaseNetworkSocketEvent::decode(self.client.wait_for_event(deadline)?)
14255 }
14256
14257 pub fn r#clone(
14258 &self,
14259 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
14260 ) -> Result<(), fidl::Error> {
14261 self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
14262 (request,),
14263 0x20d8a7aba2168a79,
14264 fidl::encoding::DynamicFlags::empty(),
14265 )
14266 }
14267
14268 pub fn r#close(
14279 &self,
14280 ___deadline: zx::MonotonicInstant,
14281 ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
14282 let _response = self.client.send_query::<
14283 fidl::encoding::EmptyPayload,
14284 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
14285 >(
14286 (),
14287 0x5ac5d459ad7f657e,
14288 fidl::encoding::DynamicFlags::empty(),
14289 ___deadline,
14290 )?;
14291 Ok(_response.map(|x| x))
14292 }
14293
14294 pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
14295 let _response = self.client.send_query::<
14296 fidl::encoding::EmptyPayload,
14297 fidl_fuchsia_unknown::QueryableQueryResponse,
14298 >(
14299 (),
14300 0x2658edee9decfc06,
14301 fidl::encoding::DynamicFlags::empty(),
14302 ___deadline,
14303 )?;
14304 Ok(_response.protocol)
14305 }
14306
14307 pub fn r#set_reuse_address(
14309 &self,
14310 mut value: bool,
14311 ___deadline: zx::MonotonicInstant,
14312 ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
14313 let _response =
14314 self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
14315 fidl::encoding::EmptyStruct,
14316 fidl_fuchsia_posix::Errno,
14317 >>(
14318 (value,),
14319 0x1fd74ee8b9a4a876,
14320 fidl::encoding::DynamicFlags::empty(),
14321 ___deadline,
14322 )?;
14323 Ok(_response.map(|x| x))
14324 }
14325
14326 pub fn r#get_reuse_address(
14328 &self,
14329 ___deadline: zx::MonotonicInstant,
14330 ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
14331 let _response = self
14332 .client
14333 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14334 BaseSocketGetReuseAddressResponse,
14335 fidl_fuchsia_posix::Errno,
14336 >>(
14337 (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
14338 )?;
14339 Ok(_response.map(|x| x.value))
14340 }
14341
14342 pub fn r#get_error(
14345 &self,
14346 ___deadline: zx::MonotonicInstant,
14347 ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
14348 let _response =
14349 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14350 fidl::encoding::EmptyStruct,
14351 fidl_fuchsia_posix::Errno,
14352 >>(
14353 (),
14354 0x5aad39b33e5f6ebb,
14355 fidl::encoding::DynamicFlags::empty(),
14356 ___deadline,
14357 )?;
14358 Ok(_response.map(|x| x))
14359 }
14360
14361 pub fn r#set_broadcast(
14363 &self,
14364 mut value: bool,
14365 ___deadline: zx::MonotonicInstant,
14366 ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
14367 let _response =
14368 self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
14369 fidl::encoding::EmptyStruct,
14370 fidl_fuchsia_posix::Errno,
14371 >>(
14372 (value,),
14373 0x6023e081ce3cd947,
14374 fidl::encoding::DynamicFlags::empty(),
14375 ___deadline,
14376 )?;
14377 Ok(_response.map(|x| x))
14378 }
14379
14380 pub fn r#get_broadcast(
14382 &self,
14383 ___deadline: zx::MonotonicInstant,
14384 ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
14385 let _response =
14386 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14387 BaseSocketGetBroadcastResponse,
14388 fidl_fuchsia_posix::Errno,
14389 >>(
14390 (),
14391 0x68796fc556f9780d,
14392 fidl::encoding::DynamicFlags::empty(),
14393 ___deadline,
14394 )?;
14395 Ok(_response.map(|x| x.value))
14396 }
14397
14398 pub fn r#set_send_buffer(
14400 &self,
14401 mut value_bytes: u64,
14402 ___deadline: zx::MonotonicInstant,
14403 ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
14404 let _response =
14405 self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
14406 fidl::encoding::EmptyStruct,
14407 fidl_fuchsia_posix::Errno,
14408 >>(
14409 (value_bytes,),
14410 0x756eac32d73a7a70,
14411 fidl::encoding::DynamicFlags::empty(),
14412 ___deadline,
14413 )?;
14414 Ok(_response.map(|x| x))
14415 }
14416
14417 pub fn r#get_send_buffer(
14419 &self,
14420 ___deadline: zx::MonotonicInstant,
14421 ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
14422 let _response = self
14423 .client
14424 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14425 BaseSocketGetSendBufferResponse,
14426 fidl_fuchsia_posix::Errno,
14427 >>(
14428 (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
14429 )?;
14430 Ok(_response.map(|x| x.value_bytes))
14431 }
14432
14433 pub fn r#set_receive_buffer(
14435 &self,
14436 mut value_bytes: u64,
14437 ___deadline: zx::MonotonicInstant,
14438 ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
14439 let _response =
14440 self.client
14441 .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
14442 fidl::encoding::EmptyStruct,
14443 fidl_fuchsia_posix::Errno,
14444 >>(
14445 (value_bytes,),
14446 0x6b0cf2f1919c7001,
14447 fidl::encoding::DynamicFlags::empty(),
14448 ___deadline,
14449 )?;
14450 Ok(_response.map(|x| x))
14451 }
14452
14453 pub fn r#get_receive_buffer(
14455 &self,
14456 ___deadline: zx::MonotonicInstant,
14457 ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
14458 let _response = self
14459 .client
14460 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14461 BaseSocketGetReceiveBufferResponse,
14462 fidl_fuchsia_posix::Errno,
14463 >>(
14464 (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
14465 )?;
14466 Ok(_response.map(|x| x.value_bytes))
14467 }
14468
14469 pub fn r#set_keep_alive(
14471 &self,
14472 mut value: bool,
14473 ___deadline: zx::MonotonicInstant,
14474 ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
14475 let _response =
14476 self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
14477 fidl::encoding::EmptyStruct,
14478 fidl_fuchsia_posix::Errno,
14479 >>(
14480 (value,),
14481 0x572df8f0b920d2c7,
14482 fidl::encoding::DynamicFlags::empty(),
14483 ___deadline,
14484 )?;
14485 Ok(_response.map(|x| x))
14486 }
14487
14488 pub fn r#get_keep_alive(
14490 &self,
14491 ___deadline: zx::MonotonicInstant,
14492 ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
14493 let _response =
14494 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14495 BaseSocketGetKeepAliveResponse,
14496 fidl_fuchsia_posix::Errno,
14497 >>(
14498 (),
14499 0x2dd29d3215f2c9d2,
14500 fidl::encoding::DynamicFlags::empty(),
14501 ___deadline,
14502 )?;
14503 Ok(_response.map(|x| x.value))
14504 }
14505
14506 pub fn r#set_out_of_band_inline(
14508 &self,
14509 mut value: bool,
14510 ___deadline: zx::MonotonicInstant,
14511 ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
14512 let _response =
14513 self.client
14514 .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
14515 fidl::encoding::EmptyStruct,
14516 fidl_fuchsia_posix::Errno,
14517 >>(
14518 (value,),
14519 0x3ecb49968bee439,
14520 fidl::encoding::DynamicFlags::empty(),
14521 ___deadline,
14522 )?;
14523 Ok(_response.map(|x| x))
14524 }
14525
14526 pub fn r#get_out_of_band_inline(
14528 &self,
14529 ___deadline: zx::MonotonicInstant,
14530 ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
14531 let _response = self
14532 .client
14533 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14534 BaseSocketGetOutOfBandInlineResponse,
14535 fidl_fuchsia_posix::Errno,
14536 >>(
14537 (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
14538 )?;
14539 Ok(_response.map(|x| x.value))
14540 }
14541
14542 pub fn r#set_no_check(
14544 &self,
14545 mut value: bool,
14546 ___deadline: zx::MonotonicInstant,
14547 ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
14548 let _response =
14549 self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
14550 fidl::encoding::EmptyStruct,
14551 fidl_fuchsia_posix::Errno,
14552 >>(
14553 (value,),
14554 0x6bbf00c53a4c78c2,
14555 fidl::encoding::DynamicFlags::empty(),
14556 ___deadline,
14557 )?;
14558 Ok(_response.map(|x| x))
14559 }
14560
14561 pub fn r#get_no_check(
14563 &self,
14564 ___deadline: zx::MonotonicInstant,
14565 ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
14566 let _response =
14567 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14568 BaseSocketGetNoCheckResponse,
14569 fidl_fuchsia_posix::Errno,
14570 >>(
14571 (),
14572 0x2cd4249286417694,
14573 fidl::encoding::DynamicFlags::empty(),
14574 ___deadline,
14575 )?;
14576 Ok(_response.map(|x| x.value))
14577 }
14578
14579 pub fn r#set_linger(
14581 &self,
14582 mut linger: bool,
14583 mut length_secs: u32,
14584 ___deadline: zx::MonotonicInstant,
14585 ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
14586 let _response =
14587 self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
14588 fidl::encoding::EmptyStruct,
14589 fidl_fuchsia_posix::Errno,
14590 >>(
14591 (linger, length_secs),
14592 0x45386351246e998e,
14593 fidl::encoding::DynamicFlags::empty(),
14594 ___deadline,
14595 )?;
14596 Ok(_response.map(|x| x))
14597 }
14598
14599 pub fn r#get_linger(
14601 &self,
14602 ___deadline: zx::MonotonicInstant,
14603 ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
14604 let _response =
14605 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14606 BaseSocketGetLingerResponse,
14607 fidl_fuchsia_posix::Errno,
14608 >>(
14609 (),
14610 0x48eb20fc5ccb0e45,
14611 fidl::encoding::DynamicFlags::empty(),
14612 ___deadline,
14613 )?;
14614 Ok(_response.map(|x| (x.linger, x.length_secs)))
14615 }
14616
14617 pub fn r#set_reuse_port(
14619 &self,
14620 mut value: bool,
14621 ___deadline: zx::MonotonicInstant,
14622 ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
14623 let _response =
14624 self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
14625 fidl::encoding::EmptyStruct,
14626 fidl_fuchsia_posix::Errno,
14627 >>(
14628 (value,),
14629 0x24dd3e5cb36d9ccb,
14630 fidl::encoding::DynamicFlags::empty(),
14631 ___deadline,
14632 )?;
14633 Ok(_response.map(|x| x))
14634 }
14635
14636 pub fn r#get_reuse_port(
14638 &self,
14639 ___deadline: zx::MonotonicInstant,
14640 ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
14641 let _response =
14642 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14643 BaseSocketGetReusePortResponse,
14644 fidl_fuchsia_posix::Errno,
14645 >>(
14646 (),
14647 0x7a112c1ab54ff828,
14648 fidl::encoding::DynamicFlags::empty(),
14649 ___deadline,
14650 )?;
14651 Ok(_response.map(|x| x.value))
14652 }
14653
14654 pub fn r#get_accept_conn(
14656 &self,
14657 ___deadline: zx::MonotonicInstant,
14658 ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
14659 let _response = self
14660 .client
14661 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14662 BaseSocketGetAcceptConnResponse,
14663 fidl_fuchsia_posix::Errno,
14664 >>(
14665 (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
14666 )?;
14667 Ok(_response.map(|x| x.value))
14668 }
14669
14670 pub fn r#set_bind_to_device(
14672 &self,
14673 mut value: &str,
14674 ___deadline: zx::MonotonicInstant,
14675 ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
14676 let _response =
14677 self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
14678 fidl::encoding::EmptyStruct,
14679 fidl_fuchsia_posix::Errno,
14680 >>(
14681 (value,),
14682 0x2118b483f28aafc4,
14683 fidl::encoding::DynamicFlags::empty(),
14684 ___deadline,
14685 )?;
14686 Ok(_response.map(|x| x))
14687 }
14688
14689 pub fn r#get_bind_to_device(
14691 &self,
14692 ___deadline: zx::MonotonicInstant,
14693 ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
14694 let _response = self
14695 .client
14696 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14697 BaseSocketGetBindToDeviceResponse,
14698 fidl_fuchsia_posix::Errno,
14699 >>(
14700 (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
14701 )?;
14702 Ok(_response.map(|x| x.value))
14703 }
14704
14705 pub fn r#set_bind_to_interface_index(
14708 &self,
14709 mut value: u64,
14710 ___deadline: zx::MonotonicInstant,
14711 ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
14712 let _response =
14713 self.client
14714 .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
14715 fidl::encoding::EmptyStruct,
14716 fidl_fuchsia_posix::Errno,
14717 >>(
14718 (value,),
14719 0x6e387a0def00821,
14720 fidl::encoding::DynamicFlags::empty(),
14721 ___deadline,
14722 )?;
14723 Ok(_response.map(|x| x))
14724 }
14725
14726 pub fn r#get_bind_to_interface_index(
14728 &self,
14729 ___deadline: zx::MonotonicInstant,
14730 ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
14731 let _response = self
14732 .client
14733 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14734 BaseSocketGetBindToInterfaceIndexResponse,
14735 fidl_fuchsia_posix::Errno,
14736 >>(
14737 (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
14738 )?;
14739 Ok(_response.map(|x| x.value))
14740 }
14741
14742 pub fn r#set_timestamp(
14744 &self,
14745 mut value: TimestampOption,
14746 ___deadline: zx::MonotonicInstant,
14747 ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
14748 let _response =
14749 self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
14750 fidl::encoding::EmptyStruct,
14751 fidl_fuchsia_posix::Errno,
14752 >>(
14753 (value,),
14754 0x285d6516c263d839,
14755 fidl::encoding::DynamicFlags::empty(),
14756 ___deadline,
14757 )?;
14758 Ok(_response.map(|x| x))
14759 }
14760
14761 pub fn r#get_timestamp(
14763 &self,
14764 ___deadline: zx::MonotonicInstant,
14765 ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
14766 let _response =
14767 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14768 BaseSocketGetTimestampResponse,
14769 fidl_fuchsia_posix::Errno,
14770 >>(
14771 (),
14772 0x49f2fffbbcc2bd27,
14773 fidl::encoding::DynamicFlags::empty(),
14774 ___deadline,
14775 )?;
14776 Ok(_response.map(|x| x.value))
14777 }
14778
14779 pub fn r#set_mark(
14783 &self,
14784 mut domain: fidl_fuchsia_net::MarkDomain,
14785 mut mark: &OptionalUint32,
14786 ___deadline: zx::MonotonicInstant,
14787 ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
14788 let _response =
14789 self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
14790 fidl::encoding::EmptyStruct,
14791 fidl_fuchsia_posix::Errno,
14792 >>(
14793 (domain, mark),
14794 0x6ead6de09f653236,
14795 fidl::encoding::DynamicFlags::empty(),
14796 ___deadline,
14797 )?;
14798 Ok(_response.map(|x| x))
14799 }
14800
14801 pub fn r#get_mark(
14805 &self,
14806 mut domain: fidl_fuchsia_net::MarkDomain,
14807 ___deadline: zx::MonotonicInstant,
14808 ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
14809 let _response =
14810 self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
14811 BaseSocketGetMarkResponse,
14812 fidl_fuchsia_posix::Errno,
14813 >>(
14814 (domain,),
14815 0x57a2752c61d93d47,
14816 fidl::encoding::DynamicFlags::empty(),
14817 ___deadline,
14818 )?;
14819 Ok(_response.map(|x| x.mark))
14820 }
14821
14822 pub fn r#bind(
14824 &self,
14825 mut addr: &fidl_fuchsia_net::SocketAddress,
14826 ___deadline: zx::MonotonicInstant,
14827 ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
14828 let _response =
14829 self.client.send_query::<BaseNetworkSocketBindRequest, fidl::encoding::ResultType<
14830 fidl::encoding::EmptyStruct,
14831 fidl_fuchsia_posix::Errno,
14832 >>(
14833 (addr,),
14834 0x4bc6400ae92125d,
14835 fidl::encoding::DynamicFlags::empty(),
14836 ___deadline,
14837 )?;
14838 Ok(_response.map(|x| x))
14839 }
14840
14841 pub fn r#connect(
14843 &self,
14844 mut addr: &fidl_fuchsia_net::SocketAddress,
14845 ___deadline: zx::MonotonicInstant,
14846 ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
14847 let _response =
14848 self.client.send_query::<BaseNetworkSocketConnectRequest, fidl::encoding::ResultType<
14849 fidl::encoding::EmptyStruct,
14850 fidl_fuchsia_posix::Errno,
14851 >>(
14852 (addr,),
14853 0x5f05f19bfdd38871,
14854 fidl::encoding::DynamicFlags::empty(),
14855 ___deadline,
14856 )?;
14857 Ok(_response.map(|x| x))
14858 }
14859
14860 pub fn r#disconnect(
14862 &self,
14863 ___deadline: zx::MonotonicInstant,
14864 ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
14865 let _response =
14866 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14867 fidl::encoding::EmptyStruct,
14868 fidl_fuchsia_posix::Errno,
14869 >>(
14870 (),
14871 0x74e63b91f7b29b2,
14872 fidl::encoding::DynamicFlags::empty(),
14873 ___deadline,
14874 )?;
14875 Ok(_response.map(|x| x))
14876 }
14877
14878 pub fn r#get_sock_name(
14880 &self,
14881 ___deadline: zx::MonotonicInstant,
14882 ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
14883 let _response = self
14884 .client
14885 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14886 BaseNetworkSocketGetSockNameResponse,
14887 fidl_fuchsia_posix::Errno,
14888 >>(
14889 (), 0x475f23f84a1a4f85, fidl::encoding::DynamicFlags::empty(), ___deadline
14890 )?;
14891 Ok(_response.map(|x| x.addr))
14892 }
14893
14894 pub fn r#get_peer_name(
14896 &self,
14897 ___deadline: zx::MonotonicInstant,
14898 ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
14899 let _response = self
14900 .client
14901 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14902 BaseNetworkSocketGetPeerNameResponse,
14903 fidl_fuchsia_posix::Errno,
14904 >>(
14905 (), 0x1ffecf4bd5b6432e, fidl::encoding::DynamicFlags::empty(), ___deadline
14906 )?;
14907 Ok(_response.map(|x| x.addr))
14908 }
14909
14910 pub fn r#shutdown(
14912 &self,
14913 mut mode: ShutdownMode,
14914 ___deadline: zx::MonotonicInstant,
14915 ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
14916 let _response =
14917 self.client.send_query::<BaseNetworkSocketShutdownRequest, fidl::encoding::ResultType<
14918 fidl::encoding::EmptyStruct,
14919 fidl_fuchsia_posix::Errno,
14920 >>(
14921 (mode,),
14922 0x247f38b6db68c336,
14923 fidl::encoding::DynamicFlags::empty(),
14924 ___deadline,
14925 )?;
14926 Ok(_response.map(|x| x))
14927 }
14928
14929 pub fn r#set_ip_type_of_service(
14931 &self,
14932 mut value: u8,
14933 ___deadline: zx::MonotonicInstant,
14934 ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
14935 let _response = self.client.send_query::<
14936 BaseNetworkSocketSetIpTypeOfServiceRequest,
14937 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
14938 >(
14939 (value,),
14940 0x995c600475b6d46,
14941 fidl::encoding::DynamicFlags::empty(),
14942 ___deadline,
14943 )?;
14944 Ok(_response.map(|x| x))
14945 }
14946
14947 pub fn r#get_ip_type_of_service(
14949 &self,
14950 ___deadline: zx::MonotonicInstant,
14951 ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
14952 let _response = self
14953 .client
14954 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14955 BaseNetworkSocketGetIpTypeOfServiceResponse,
14956 fidl_fuchsia_posix::Errno,
14957 >>(
14958 (), 0x3814a04259f75fcb, fidl::encoding::DynamicFlags::empty(), ___deadline
14959 )?;
14960 Ok(_response.map(|x| x.value))
14961 }
14962
14963 pub fn r#set_ip_ttl(
14965 &self,
14966 mut value: &OptionalUint8,
14967 ___deadline: zx::MonotonicInstant,
14968 ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
14969 let _response =
14970 self.client.send_query::<BaseNetworkSocketSetIpTtlRequest, fidl::encoding::ResultType<
14971 fidl::encoding::EmptyStruct,
14972 fidl_fuchsia_posix::Errno,
14973 >>(
14974 (value,),
14975 0x29e2424b433ae1ef,
14976 fidl::encoding::DynamicFlags::empty(),
14977 ___deadline,
14978 )?;
14979 Ok(_response.map(|x| x))
14980 }
14981
14982 pub fn r#get_ip_ttl(
14984 &self,
14985 ___deadline: zx::MonotonicInstant,
14986 ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
14987 let _response = self
14988 .client
14989 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14990 BaseNetworkSocketGetIpTtlResponse,
14991 fidl_fuchsia_posix::Errno,
14992 >>(
14993 (), 0x47e47fa1f24da471, fidl::encoding::DynamicFlags::empty(), ___deadline
14994 )?;
14995 Ok(_response.map(|x| x.value))
14996 }
14997
14998 pub fn r#set_ip_packet_info(
15000 &self,
15001 mut value: bool,
15002 ___deadline: zx::MonotonicInstant,
15003 ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
15004 let _response =
15005 self.client
15006 .send_query::<BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::ResultType<
15007 fidl::encoding::EmptyStruct,
15008 fidl_fuchsia_posix::Errno,
15009 >>(
15010 (value,),
15011 0x392d16bee20c0e16,
15012 fidl::encoding::DynamicFlags::empty(),
15013 ___deadline,
15014 )?;
15015 Ok(_response.map(|x| x))
15016 }
15017
15018 pub fn r#get_ip_packet_info(
15020 &self,
15021 ___deadline: zx::MonotonicInstant,
15022 ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
15023 let _response = self
15024 .client
15025 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15026 BaseNetworkSocketGetIpPacketInfoResponse,
15027 fidl_fuchsia_posix::Errno,
15028 >>(
15029 (), 0x54b505f242280740, fidl::encoding::DynamicFlags::empty(), ___deadline
15030 )?;
15031 Ok(_response.map(|x| x.value))
15032 }
15033
15034 pub fn r#set_ip_receive_type_of_service(
15036 &self,
15037 mut value: bool,
15038 ___deadline: zx::MonotonicInstant,
15039 ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
15040 let _response = self.client.send_query::<
15041 BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
15042 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15043 >(
15044 (value,),
15045 0x6c4f6714995f84ef,
15046 fidl::encoding::DynamicFlags::empty(),
15047 ___deadline,
15048 )?;
15049 Ok(_response.map(|x| x))
15050 }
15051
15052 pub fn r#get_ip_receive_type_of_service(
15054 &self,
15055 ___deadline: zx::MonotonicInstant,
15056 ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
15057 let _response = self
15058 .client
15059 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15060 BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
15061 fidl_fuchsia_posix::Errno,
15062 >>(
15063 (), 0x4158ba7dc2795960, fidl::encoding::DynamicFlags::empty(), ___deadline
15064 )?;
15065 Ok(_response.map(|x| x.value))
15066 }
15067
15068 pub fn r#set_ip_receive_ttl(
15070 &self,
15071 mut value: bool,
15072 ___deadline: zx::MonotonicInstant,
15073 ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
15074 let _response =
15075 self.client
15076 .send_query::<BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::ResultType<
15077 fidl::encoding::EmptyStruct,
15078 fidl_fuchsia_posix::Errno,
15079 >>(
15080 (value,),
15081 0x46f15be0ce0ab82b,
15082 fidl::encoding::DynamicFlags::empty(),
15083 ___deadline,
15084 )?;
15085 Ok(_response.map(|x| x))
15086 }
15087
15088 pub fn r#get_ip_receive_ttl(
15090 &self,
15091 ___deadline: zx::MonotonicInstant,
15092 ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
15093 let _response = self
15094 .client
15095 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15096 BaseNetworkSocketGetIpReceiveTtlResponse,
15097 fidl_fuchsia_posix::Errno,
15098 >>(
15099 (), 0x678ddd5a5dfa2eb5, fidl::encoding::DynamicFlags::empty(), ___deadline
15100 )?;
15101 Ok(_response.map(|x| x.value))
15102 }
15103
15104 pub fn r#set_ip_multicast_interface(
15106 &self,
15107 mut iface: u64,
15108 mut address: &fidl_fuchsia_net::Ipv4Address,
15109 ___deadline: zx::MonotonicInstant,
15110 ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
15111 let _response = self.client.send_query::<
15112 BaseNetworkSocketSetIpMulticastInterfaceRequest,
15113 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15114 >(
15115 (iface, address,),
15116 0x752fbfa9b12befe,
15117 fidl::encoding::DynamicFlags::empty(),
15118 ___deadline,
15119 )?;
15120 Ok(_response.map(|x| x))
15121 }
15122
15123 pub fn r#get_ip_multicast_interface(
15125 &self,
15126 ___deadline: zx::MonotonicInstant,
15127 ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
15128 let _response = self
15129 .client
15130 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15131 BaseNetworkSocketGetIpMulticastInterfaceResponse,
15132 fidl_fuchsia_posix::Errno,
15133 >>(
15134 (), 0x320bd14c4df046c4, fidl::encoding::DynamicFlags::empty(), ___deadline
15135 )?;
15136 Ok(_response.map(|x| x.value))
15137 }
15138
15139 pub fn r#set_ip_multicast_ttl(
15141 &self,
15142 mut value: &OptionalUint8,
15143 ___deadline: zx::MonotonicInstant,
15144 ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
15145 let _response =
15146 self.client
15147 .send_query::<BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::ResultType<
15148 fidl::encoding::EmptyStruct,
15149 fidl_fuchsia_posix::Errno,
15150 >>(
15151 (value,),
15152 0x63134d53772916a1,
15153 fidl::encoding::DynamicFlags::empty(),
15154 ___deadline,
15155 )?;
15156 Ok(_response.map(|x| x))
15157 }
15158
15159 pub fn r#get_ip_multicast_ttl(
15161 &self,
15162 ___deadline: zx::MonotonicInstant,
15163 ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
15164 let _response = self
15165 .client
15166 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15167 BaseNetworkSocketGetIpMulticastTtlResponse,
15168 fidl_fuchsia_posix::Errno,
15169 >>(
15170 (), 0x4665cd378f39e1a, fidl::encoding::DynamicFlags::empty(), ___deadline
15171 )?;
15172 Ok(_response.map(|x| x.value))
15173 }
15174
15175 pub fn r#set_ip_multicast_loopback(
15177 &self,
15178 mut value: bool,
15179 ___deadline: zx::MonotonicInstant,
15180 ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
15181 let _response = self.client.send_query::<
15182 BaseNetworkSocketSetIpMulticastLoopbackRequest,
15183 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15184 >(
15185 (value,),
15186 0x20c55c11f00943ea,
15187 fidl::encoding::DynamicFlags::empty(),
15188 ___deadline,
15189 )?;
15190 Ok(_response.map(|x| x))
15191 }
15192
15193 pub fn r#get_ip_multicast_loopback(
15195 &self,
15196 ___deadline: zx::MonotonicInstant,
15197 ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
15198 let _response = self
15199 .client
15200 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15201 BaseNetworkSocketGetIpMulticastLoopbackResponse,
15202 fidl_fuchsia_posix::Errno,
15203 >>(
15204 (), 0x3b6b26ff558298f2, fidl::encoding::DynamicFlags::empty(), ___deadline
15205 )?;
15206 Ok(_response.map(|x| x.value))
15207 }
15208
15209 pub fn r#add_ip_membership(
15211 &self,
15212 mut membership: &IpMulticastMembership,
15213 ___deadline: zx::MonotonicInstant,
15214 ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
15215 let _response =
15216 self.client
15217 .send_query::<BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::ResultType<
15218 fidl::encoding::EmptyStruct,
15219 fidl_fuchsia_posix::Errno,
15220 >>(
15221 (membership,),
15222 0x76bc7df115a3b4d0,
15223 fidl::encoding::DynamicFlags::empty(),
15224 ___deadline,
15225 )?;
15226 Ok(_response.map(|x| x))
15227 }
15228
15229 pub fn r#drop_ip_membership(
15231 &self,
15232 mut membership: &IpMulticastMembership,
15233 ___deadline: zx::MonotonicInstant,
15234 ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
15235 let _response =
15236 self.client
15237 .send_query::<BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::ResultType<
15238 fidl::encoding::EmptyStruct,
15239 fidl_fuchsia_posix::Errno,
15240 >>(
15241 (membership,),
15242 0x2888f3099188d03,
15243 fidl::encoding::DynamicFlags::empty(),
15244 ___deadline,
15245 )?;
15246 Ok(_response.map(|x| x))
15247 }
15248
15249 pub fn r#set_ip_transparent(
15251 &self,
15252 mut value: bool,
15253 ___deadline: zx::MonotonicInstant,
15254 ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
15255 let _response =
15256 self.client
15257 .send_query::<BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::ResultType<
15258 fidl::encoding::EmptyStruct,
15259 fidl_fuchsia_posix::Errno,
15260 >>(
15261 (value,),
15262 0x1ae532b0c066e3a0,
15263 fidl::encoding::DynamicFlags::empty(),
15264 ___deadline,
15265 )?;
15266 Ok(_response.map(|x| x))
15267 }
15268
15269 pub fn r#get_ip_transparent(
15271 &self,
15272 ___deadline: zx::MonotonicInstant,
15273 ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
15274 let _response = self
15275 .client
15276 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15277 BaseNetworkSocketGetIpTransparentResponse,
15278 fidl_fuchsia_posix::Errno,
15279 >>(
15280 (), 0x51d43695962ebfb5, fidl::encoding::DynamicFlags::empty(), ___deadline
15281 )?;
15282 Ok(_response.map(|x| x.value))
15283 }
15284
15285 pub fn r#set_ip_receive_original_destination_address(
15287 &self,
15288 mut value: bool,
15289 ___deadline: zx::MonotonicInstant,
15290 ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
15291 let _response = self.client.send_query::<
15292 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
15293 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15294 >(
15295 (value,),
15296 0x4722b4ce52f7840,
15297 fidl::encoding::DynamicFlags::empty(),
15298 ___deadline,
15299 )?;
15300 Ok(_response.map(|x| x))
15301 }
15302
15303 pub fn r#get_ip_receive_original_destination_address(
15305 &self,
15306 ___deadline: zx::MonotonicInstant,
15307 ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
15308 let _response = self
15309 .client
15310 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15311 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
15312 fidl_fuchsia_posix::Errno,
15313 >>(
15314 (), 0x2a0e7dc5d6bfdfe9, fidl::encoding::DynamicFlags::empty(), ___deadline
15315 )?;
15316 Ok(_response.map(|x| x.value))
15317 }
15318
15319 pub fn r#add_ipv6_membership(
15321 &self,
15322 mut membership: &Ipv6MulticastMembership,
15323 ___deadline: zx::MonotonicInstant,
15324 ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
15325 let _response =
15326 self.client
15327 .send_query::<BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::ResultType<
15328 fidl::encoding::EmptyStruct,
15329 fidl_fuchsia_posix::Errno,
15330 >>(
15331 (membership,),
15332 0x7c94727acb4ea4b3,
15333 fidl::encoding::DynamicFlags::empty(),
15334 ___deadline,
15335 )?;
15336 Ok(_response.map(|x| x))
15337 }
15338
15339 pub fn r#drop_ipv6_membership(
15341 &self,
15342 mut membership: &Ipv6MulticastMembership,
15343 ___deadline: zx::MonotonicInstant,
15344 ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
15345 let _response = self.client.send_query::<
15346 BaseNetworkSocketDropIpv6MembershipRequest,
15347 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15348 >(
15349 (membership,),
15350 0x42104c70ccaba304,
15351 fidl::encoding::DynamicFlags::empty(),
15352 ___deadline,
15353 )?;
15354 Ok(_response.map(|x| x))
15355 }
15356
15357 pub fn r#set_ipv6_multicast_interface(
15359 &self,
15360 mut value: u64,
15361 ___deadline: zx::MonotonicInstant,
15362 ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
15363 let _response = self.client.send_query::<
15364 BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
15365 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15366 >(
15367 (value,),
15368 0x135f76db3774ab3b,
15369 fidl::encoding::DynamicFlags::empty(),
15370 ___deadline,
15371 )?;
15372 Ok(_response.map(|x| x))
15373 }
15374
15375 pub fn r#get_ipv6_multicast_interface(
15377 &self,
15378 ___deadline: zx::MonotonicInstant,
15379 ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
15380 let _response = self
15381 .client
15382 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15383 BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
15384 fidl_fuchsia_posix::Errno,
15385 >>(
15386 (), 0x1f26fcdd348f1882, fidl::encoding::DynamicFlags::empty(), ___deadline
15387 )?;
15388 Ok(_response.map(|x| x.value))
15389 }
15390
15391 pub fn r#set_ipv6_unicast_hops(
15393 &self,
15394 mut value: &OptionalUint8,
15395 ___deadline: zx::MonotonicInstant,
15396 ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
15397 let _response = self.client.send_query::<
15398 BaseNetworkSocketSetIpv6UnicastHopsRequest,
15399 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15400 >(
15401 (value,),
15402 0x157d51e98f462859,
15403 fidl::encoding::DynamicFlags::empty(),
15404 ___deadline,
15405 )?;
15406 Ok(_response.map(|x| x))
15407 }
15408
15409 pub fn r#get_ipv6_unicast_hops(
15411 &self,
15412 ___deadline: zx::MonotonicInstant,
15413 ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
15414 let _response = self
15415 .client
15416 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15417 BaseNetworkSocketGetIpv6UnicastHopsResponse,
15418 fidl_fuchsia_posix::Errno,
15419 >>(
15420 (), 0x21f4641cad8bd8d2, fidl::encoding::DynamicFlags::empty(), ___deadline
15421 )?;
15422 Ok(_response.map(|x| x.value))
15423 }
15424
15425 pub fn r#set_ipv6_receive_hop_limit(
15427 &self,
15428 mut value: bool,
15429 ___deadline: zx::MonotonicInstant,
15430 ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
15431 let _response = self.client.send_query::<
15432 BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
15433 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15434 >(
15435 (value,),
15436 0x5c24808ed2e84a1e,
15437 fidl::encoding::DynamicFlags::empty(),
15438 ___deadline,
15439 )?;
15440 Ok(_response.map(|x| x))
15441 }
15442
15443 pub fn r#get_ipv6_receive_hop_limit(
15445 &self,
15446 ___deadline: zx::MonotonicInstant,
15447 ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
15448 let _response = self
15449 .client
15450 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15451 BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
15452 fidl_fuchsia_posix::Errno,
15453 >>(
15454 (), 0x341e06689885b4c0, fidl::encoding::DynamicFlags::empty(), ___deadline
15455 )?;
15456 Ok(_response.map(|x| x.value))
15457 }
15458
15459 pub fn r#set_ipv6_multicast_hops(
15461 &self,
15462 mut value: &OptionalUint8,
15463 ___deadline: zx::MonotonicInstant,
15464 ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
15465 let _response = self.client.send_query::<
15466 BaseNetworkSocketSetIpv6MulticastHopsRequest,
15467 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15468 >(
15469 (value,),
15470 0x25b9cd4d181f82c1,
15471 fidl::encoding::DynamicFlags::empty(),
15472 ___deadline,
15473 )?;
15474 Ok(_response.map(|x| x))
15475 }
15476
15477 pub fn r#get_ipv6_multicast_hops(
15479 &self,
15480 ___deadline: zx::MonotonicInstant,
15481 ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
15482 let _response = self
15483 .client
15484 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15485 BaseNetworkSocketGetIpv6MulticastHopsResponse,
15486 fidl_fuchsia_posix::Errno,
15487 >>(
15488 (), 0x52916948a365012a, fidl::encoding::DynamicFlags::empty(), ___deadline
15489 )?;
15490 Ok(_response.map(|x| x.value))
15491 }
15492
15493 pub fn r#set_ipv6_multicast_loopback(
15495 &self,
15496 mut value: bool,
15497 ___deadline: zx::MonotonicInstant,
15498 ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
15499 let _response = self.client.send_query::<
15500 BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
15501 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15502 >(
15503 (value,),
15504 0x55701c409ff41b40,
15505 fidl::encoding::DynamicFlags::empty(),
15506 ___deadline,
15507 )?;
15508 Ok(_response.map(|x| x))
15509 }
15510
15511 pub fn r#get_ipv6_multicast_loopback(
15513 &self,
15514 ___deadline: zx::MonotonicInstant,
15515 ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
15516 let _response = self
15517 .client
15518 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15519 BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
15520 fidl_fuchsia_posix::Errno,
15521 >>(
15522 (), 0x4415b701fde319c3, fidl::encoding::DynamicFlags::empty(), ___deadline
15523 )?;
15524 Ok(_response.map(|x| x.value))
15525 }
15526
15527 pub fn r#set_ipv6_only(
15529 &self,
15530 mut value: bool,
15531 ___deadline: zx::MonotonicInstant,
15532 ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
15533 let _response =
15534 self.client
15535 .send_query::<BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::ResultType<
15536 fidl::encoding::EmptyStruct,
15537 fidl_fuchsia_posix::Errno,
15538 >>(
15539 (value,),
15540 0x4873f1364758cbba,
15541 fidl::encoding::DynamicFlags::empty(),
15542 ___deadline,
15543 )?;
15544 Ok(_response.map(|x| x))
15545 }
15546
15547 pub fn r#get_ipv6_only(
15549 &self,
15550 ___deadline: zx::MonotonicInstant,
15551 ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
15552 let _response = self
15553 .client
15554 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15555 BaseNetworkSocketGetIpv6OnlyResponse,
15556 fidl_fuchsia_posix::Errno,
15557 >>(
15558 (), 0x4aa3340a1a26b89c, fidl::encoding::DynamicFlags::empty(), ___deadline
15559 )?;
15560 Ok(_response.map(|x| x.value))
15561 }
15562
15563 pub fn r#set_ipv6_receive_traffic_class(
15565 &self,
15566 mut value: bool,
15567 ___deadline: zx::MonotonicInstant,
15568 ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
15569 let _response = self.client.send_query::<
15570 BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
15571 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15572 >(
15573 (value,),
15574 0x58f07c8788d099a0,
15575 fidl::encoding::DynamicFlags::empty(),
15576 ___deadline,
15577 )?;
15578 Ok(_response.map(|x| x))
15579 }
15580
15581 pub fn r#get_ipv6_receive_traffic_class(
15583 &self,
15584 ___deadline: zx::MonotonicInstant,
15585 ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
15586 let _response = self
15587 .client
15588 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15589 BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
15590 fidl_fuchsia_posix::Errno,
15591 >>(
15592 (), 0x2e334df1da553ffa, fidl::encoding::DynamicFlags::empty(), ___deadline
15593 )?;
15594 Ok(_response.map(|x| x.value))
15595 }
15596
15597 pub fn r#set_ipv6_traffic_class(
15599 &self,
15600 mut value: &OptionalUint8,
15601 ___deadline: zx::MonotonicInstant,
15602 ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
15603 let _response = self.client.send_query::<
15604 BaseNetworkSocketSetIpv6TrafficClassRequest,
15605 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15606 >(
15607 (value,),
15608 0x6af077800c5a0b4f,
15609 fidl::encoding::DynamicFlags::empty(),
15610 ___deadline,
15611 )?;
15612 Ok(_response.map(|x| x))
15613 }
15614
15615 pub fn r#get_ipv6_traffic_class(
15617 &self,
15618 ___deadline: zx::MonotonicInstant,
15619 ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
15620 let _response = self
15621 .client
15622 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15623 BaseNetworkSocketGetIpv6TrafficClassResponse,
15624 fidl_fuchsia_posix::Errno,
15625 >>(
15626 (), 0x6baf6eed8fc2f04, fidl::encoding::DynamicFlags::empty(), ___deadline
15627 )?;
15628 Ok(_response.map(|x| x.value))
15629 }
15630
15631 pub fn r#set_ipv6_receive_packet_info(
15633 &self,
15634 mut value: bool,
15635 ___deadline: zx::MonotonicInstant,
15636 ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
15637 let _response = self.client.send_query::<
15638 BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
15639 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15640 >(
15641 (value,),
15642 0x19259775b1a92768,
15643 fidl::encoding::DynamicFlags::empty(),
15644 ___deadline,
15645 )?;
15646 Ok(_response.map(|x| x))
15647 }
15648
15649 pub fn r#get_ipv6_receive_packet_info(
15651 &self,
15652 ___deadline: zx::MonotonicInstant,
15653 ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
15654 let _response = self
15655 .client
15656 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15657 BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
15658 fidl_fuchsia_posix::Errno,
15659 >>(
15660 (), 0x7acd4a2775baec75, fidl::encoding::DynamicFlags::empty(), ___deadline
15661 )?;
15662 Ok(_response.map(|x| x.value))
15663 }
15664
15665 pub fn r#get_original_destination(
15667 &self,
15668 ___deadline: zx::MonotonicInstant,
15669 ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
15670 let _response = self
15671 .client
15672 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15673 BaseNetworkSocketGetOriginalDestinationResponse,
15674 fidl_fuchsia_posix::Errno,
15675 >>(
15676 (), 0x38bf28f0dafdbac0, fidl::encoding::DynamicFlags::empty(), ___deadline
15677 )?;
15678 Ok(_response.map(|x| x.value))
15679 }
15680}
15681
15682#[cfg(target_os = "fuchsia")]
15683impl From<BaseNetworkSocketSynchronousProxy> for zx::Handle {
15684 fn from(value: BaseNetworkSocketSynchronousProxy) -> Self {
15685 value.into_channel().into()
15686 }
15687}
15688
15689#[cfg(target_os = "fuchsia")]
15690impl From<fidl::Channel> for BaseNetworkSocketSynchronousProxy {
15691 fn from(value: fidl::Channel) -> Self {
15692 Self::new(value)
15693 }
15694}
15695
15696#[derive(Debug, Clone)]
15697pub struct BaseNetworkSocketProxy {
15698 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
15699}
15700
15701impl fidl::endpoints::Proxy for BaseNetworkSocketProxy {
15702 type Protocol = BaseNetworkSocketMarker;
15703
15704 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
15705 Self::new(inner)
15706 }
15707
15708 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
15709 self.client.into_channel().map_err(|client| Self { client })
15710 }
15711
15712 fn as_channel(&self) -> &::fidl::AsyncChannel {
15713 self.client.as_channel()
15714 }
15715}
15716
15717impl BaseNetworkSocketProxy {
15718 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
15720 let protocol_name =
15721 <BaseNetworkSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
15722 Self { client: fidl::client::Client::new(channel, protocol_name) }
15723 }
15724
15725 pub fn take_event_stream(&self) -> BaseNetworkSocketEventStream {
15731 BaseNetworkSocketEventStream { event_receiver: self.client.take_event_receiver() }
15732 }
15733
15734 pub fn r#clone(
15735 &self,
15736 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
15737 ) -> Result<(), fidl::Error> {
15738 BaseNetworkSocketProxyInterface::r#clone(self, request)
15739 }
15740
15741 pub fn r#close(
15752 &self,
15753 ) -> fidl::client::QueryResponseFut<
15754 fidl_fuchsia_unknown::CloseableCloseResult,
15755 fidl::encoding::DefaultFuchsiaResourceDialect,
15756 > {
15757 BaseNetworkSocketProxyInterface::r#close(self)
15758 }
15759
15760 pub fn r#query(
15761 &self,
15762 ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
15763 {
15764 BaseNetworkSocketProxyInterface::r#query(self)
15765 }
15766
15767 pub fn r#set_reuse_address(
15769 &self,
15770 mut value: bool,
15771 ) -> fidl::client::QueryResponseFut<
15772 BaseSocketSetReuseAddressResult,
15773 fidl::encoding::DefaultFuchsiaResourceDialect,
15774 > {
15775 BaseNetworkSocketProxyInterface::r#set_reuse_address(self, value)
15776 }
15777
15778 pub fn r#get_reuse_address(
15780 &self,
15781 ) -> fidl::client::QueryResponseFut<
15782 BaseSocketGetReuseAddressResult,
15783 fidl::encoding::DefaultFuchsiaResourceDialect,
15784 > {
15785 BaseNetworkSocketProxyInterface::r#get_reuse_address(self)
15786 }
15787
15788 pub fn r#get_error(
15791 &self,
15792 ) -> fidl::client::QueryResponseFut<
15793 BaseSocketGetErrorResult,
15794 fidl::encoding::DefaultFuchsiaResourceDialect,
15795 > {
15796 BaseNetworkSocketProxyInterface::r#get_error(self)
15797 }
15798
15799 pub fn r#set_broadcast(
15801 &self,
15802 mut value: bool,
15803 ) -> fidl::client::QueryResponseFut<
15804 BaseSocketSetBroadcastResult,
15805 fidl::encoding::DefaultFuchsiaResourceDialect,
15806 > {
15807 BaseNetworkSocketProxyInterface::r#set_broadcast(self, value)
15808 }
15809
15810 pub fn r#get_broadcast(
15812 &self,
15813 ) -> fidl::client::QueryResponseFut<
15814 BaseSocketGetBroadcastResult,
15815 fidl::encoding::DefaultFuchsiaResourceDialect,
15816 > {
15817 BaseNetworkSocketProxyInterface::r#get_broadcast(self)
15818 }
15819
15820 pub fn r#set_send_buffer(
15822 &self,
15823 mut value_bytes: u64,
15824 ) -> fidl::client::QueryResponseFut<
15825 BaseSocketSetSendBufferResult,
15826 fidl::encoding::DefaultFuchsiaResourceDialect,
15827 > {
15828 BaseNetworkSocketProxyInterface::r#set_send_buffer(self, value_bytes)
15829 }
15830
15831 pub fn r#get_send_buffer(
15833 &self,
15834 ) -> fidl::client::QueryResponseFut<
15835 BaseSocketGetSendBufferResult,
15836 fidl::encoding::DefaultFuchsiaResourceDialect,
15837 > {
15838 BaseNetworkSocketProxyInterface::r#get_send_buffer(self)
15839 }
15840
15841 pub fn r#set_receive_buffer(
15843 &self,
15844 mut value_bytes: u64,
15845 ) -> fidl::client::QueryResponseFut<
15846 BaseSocketSetReceiveBufferResult,
15847 fidl::encoding::DefaultFuchsiaResourceDialect,
15848 > {
15849 BaseNetworkSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
15850 }
15851
15852 pub fn r#get_receive_buffer(
15854 &self,
15855 ) -> fidl::client::QueryResponseFut<
15856 BaseSocketGetReceiveBufferResult,
15857 fidl::encoding::DefaultFuchsiaResourceDialect,
15858 > {
15859 BaseNetworkSocketProxyInterface::r#get_receive_buffer(self)
15860 }
15861
15862 pub fn r#set_keep_alive(
15864 &self,
15865 mut value: bool,
15866 ) -> fidl::client::QueryResponseFut<
15867 BaseSocketSetKeepAliveResult,
15868 fidl::encoding::DefaultFuchsiaResourceDialect,
15869 > {
15870 BaseNetworkSocketProxyInterface::r#set_keep_alive(self, value)
15871 }
15872
15873 pub fn r#get_keep_alive(
15875 &self,
15876 ) -> fidl::client::QueryResponseFut<
15877 BaseSocketGetKeepAliveResult,
15878 fidl::encoding::DefaultFuchsiaResourceDialect,
15879 > {
15880 BaseNetworkSocketProxyInterface::r#get_keep_alive(self)
15881 }
15882
15883 pub fn r#set_out_of_band_inline(
15885 &self,
15886 mut value: bool,
15887 ) -> fidl::client::QueryResponseFut<
15888 BaseSocketSetOutOfBandInlineResult,
15889 fidl::encoding::DefaultFuchsiaResourceDialect,
15890 > {
15891 BaseNetworkSocketProxyInterface::r#set_out_of_band_inline(self, value)
15892 }
15893
15894 pub fn r#get_out_of_band_inline(
15896 &self,
15897 ) -> fidl::client::QueryResponseFut<
15898 BaseSocketGetOutOfBandInlineResult,
15899 fidl::encoding::DefaultFuchsiaResourceDialect,
15900 > {
15901 BaseNetworkSocketProxyInterface::r#get_out_of_band_inline(self)
15902 }
15903
15904 pub fn r#set_no_check(
15906 &self,
15907 mut value: bool,
15908 ) -> fidl::client::QueryResponseFut<
15909 BaseSocketSetNoCheckResult,
15910 fidl::encoding::DefaultFuchsiaResourceDialect,
15911 > {
15912 BaseNetworkSocketProxyInterface::r#set_no_check(self, value)
15913 }
15914
15915 pub fn r#get_no_check(
15917 &self,
15918 ) -> fidl::client::QueryResponseFut<
15919 BaseSocketGetNoCheckResult,
15920 fidl::encoding::DefaultFuchsiaResourceDialect,
15921 > {
15922 BaseNetworkSocketProxyInterface::r#get_no_check(self)
15923 }
15924
15925 pub fn r#set_linger(
15927 &self,
15928 mut linger: bool,
15929 mut length_secs: u32,
15930 ) -> fidl::client::QueryResponseFut<
15931 BaseSocketSetLingerResult,
15932 fidl::encoding::DefaultFuchsiaResourceDialect,
15933 > {
15934 BaseNetworkSocketProxyInterface::r#set_linger(self, linger, length_secs)
15935 }
15936
15937 pub fn r#get_linger(
15939 &self,
15940 ) -> fidl::client::QueryResponseFut<
15941 BaseSocketGetLingerResult,
15942 fidl::encoding::DefaultFuchsiaResourceDialect,
15943 > {
15944 BaseNetworkSocketProxyInterface::r#get_linger(self)
15945 }
15946
15947 pub fn r#set_reuse_port(
15949 &self,
15950 mut value: bool,
15951 ) -> fidl::client::QueryResponseFut<
15952 BaseSocketSetReusePortResult,
15953 fidl::encoding::DefaultFuchsiaResourceDialect,
15954 > {
15955 BaseNetworkSocketProxyInterface::r#set_reuse_port(self, value)
15956 }
15957
15958 pub fn r#get_reuse_port(
15960 &self,
15961 ) -> fidl::client::QueryResponseFut<
15962 BaseSocketGetReusePortResult,
15963 fidl::encoding::DefaultFuchsiaResourceDialect,
15964 > {
15965 BaseNetworkSocketProxyInterface::r#get_reuse_port(self)
15966 }
15967
15968 pub fn r#get_accept_conn(
15970 &self,
15971 ) -> fidl::client::QueryResponseFut<
15972 BaseSocketGetAcceptConnResult,
15973 fidl::encoding::DefaultFuchsiaResourceDialect,
15974 > {
15975 BaseNetworkSocketProxyInterface::r#get_accept_conn(self)
15976 }
15977
15978 pub fn r#set_bind_to_device(
15980 &self,
15981 mut value: &str,
15982 ) -> fidl::client::QueryResponseFut<
15983 BaseSocketSetBindToDeviceResult,
15984 fidl::encoding::DefaultFuchsiaResourceDialect,
15985 > {
15986 BaseNetworkSocketProxyInterface::r#set_bind_to_device(self, value)
15987 }
15988
15989 pub fn r#get_bind_to_device(
15991 &self,
15992 ) -> fidl::client::QueryResponseFut<
15993 BaseSocketGetBindToDeviceResult,
15994 fidl::encoding::DefaultFuchsiaResourceDialect,
15995 > {
15996 BaseNetworkSocketProxyInterface::r#get_bind_to_device(self)
15997 }
15998
15999 pub fn r#set_bind_to_interface_index(
16002 &self,
16003 mut value: u64,
16004 ) -> fidl::client::QueryResponseFut<
16005 BaseSocketSetBindToInterfaceIndexResult,
16006 fidl::encoding::DefaultFuchsiaResourceDialect,
16007 > {
16008 BaseNetworkSocketProxyInterface::r#set_bind_to_interface_index(self, value)
16009 }
16010
16011 pub fn r#get_bind_to_interface_index(
16013 &self,
16014 ) -> fidl::client::QueryResponseFut<
16015 BaseSocketGetBindToInterfaceIndexResult,
16016 fidl::encoding::DefaultFuchsiaResourceDialect,
16017 > {
16018 BaseNetworkSocketProxyInterface::r#get_bind_to_interface_index(self)
16019 }
16020
16021 pub fn r#set_timestamp(
16023 &self,
16024 mut value: TimestampOption,
16025 ) -> fidl::client::QueryResponseFut<
16026 BaseSocketSetTimestampResult,
16027 fidl::encoding::DefaultFuchsiaResourceDialect,
16028 > {
16029 BaseNetworkSocketProxyInterface::r#set_timestamp(self, value)
16030 }
16031
16032 pub fn r#get_timestamp(
16034 &self,
16035 ) -> fidl::client::QueryResponseFut<
16036 BaseSocketGetTimestampResult,
16037 fidl::encoding::DefaultFuchsiaResourceDialect,
16038 > {
16039 BaseNetworkSocketProxyInterface::r#get_timestamp(self)
16040 }
16041
16042 pub fn r#set_mark(
16046 &self,
16047 mut domain: fidl_fuchsia_net::MarkDomain,
16048 mut mark: &OptionalUint32,
16049 ) -> fidl::client::QueryResponseFut<
16050 BaseSocketSetMarkResult,
16051 fidl::encoding::DefaultFuchsiaResourceDialect,
16052 > {
16053 BaseNetworkSocketProxyInterface::r#set_mark(self, domain, mark)
16054 }
16055
16056 pub fn r#get_mark(
16060 &self,
16061 mut domain: fidl_fuchsia_net::MarkDomain,
16062 ) -> fidl::client::QueryResponseFut<
16063 BaseSocketGetMarkResult,
16064 fidl::encoding::DefaultFuchsiaResourceDialect,
16065 > {
16066 BaseNetworkSocketProxyInterface::r#get_mark(self, domain)
16067 }
16068
16069 pub fn r#bind(
16071 &self,
16072 mut addr: &fidl_fuchsia_net::SocketAddress,
16073 ) -> fidl::client::QueryResponseFut<
16074 BaseNetworkSocketBindResult,
16075 fidl::encoding::DefaultFuchsiaResourceDialect,
16076 > {
16077 BaseNetworkSocketProxyInterface::r#bind(self, addr)
16078 }
16079
16080 pub fn r#connect(
16082 &self,
16083 mut addr: &fidl_fuchsia_net::SocketAddress,
16084 ) -> fidl::client::QueryResponseFut<
16085 BaseNetworkSocketConnectResult,
16086 fidl::encoding::DefaultFuchsiaResourceDialect,
16087 > {
16088 BaseNetworkSocketProxyInterface::r#connect(self, addr)
16089 }
16090
16091 pub fn r#disconnect(
16093 &self,
16094 ) -> fidl::client::QueryResponseFut<
16095 BaseNetworkSocketDisconnectResult,
16096 fidl::encoding::DefaultFuchsiaResourceDialect,
16097 > {
16098 BaseNetworkSocketProxyInterface::r#disconnect(self)
16099 }
16100
16101 pub fn r#get_sock_name(
16103 &self,
16104 ) -> fidl::client::QueryResponseFut<
16105 BaseNetworkSocketGetSockNameResult,
16106 fidl::encoding::DefaultFuchsiaResourceDialect,
16107 > {
16108 BaseNetworkSocketProxyInterface::r#get_sock_name(self)
16109 }
16110
16111 pub fn r#get_peer_name(
16113 &self,
16114 ) -> fidl::client::QueryResponseFut<
16115 BaseNetworkSocketGetPeerNameResult,
16116 fidl::encoding::DefaultFuchsiaResourceDialect,
16117 > {
16118 BaseNetworkSocketProxyInterface::r#get_peer_name(self)
16119 }
16120
16121 pub fn r#shutdown(
16123 &self,
16124 mut mode: ShutdownMode,
16125 ) -> fidl::client::QueryResponseFut<
16126 BaseNetworkSocketShutdownResult,
16127 fidl::encoding::DefaultFuchsiaResourceDialect,
16128 > {
16129 BaseNetworkSocketProxyInterface::r#shutdown(self, mode)
16130 }
16131
16132 pub fn r#set_ip_type_of_service(
16134 &self,
16135 mut value: u8,
16136 ) -> fidl::client::QueryResponseFut<
16137 BaseNetworkSocketSetIpTypeOfServiceResult,
16138 fidl::encoding::DefaultFuchsiaResourceDialect,
16139 > {
16140 BaseNetworkSocketProxyInterface::r#set_ip_type_of_service(self, value)
16141 }
16142
16143 pub fn r#get_ip_type_of_service(
16145 &self,
16146 ) -> fidl::client::QueryResponseFut<
16147 BaseNetworkSocketGetIpTypeOfServiceResult,
16148 fidl::encoding::DefaultFuchsiaResourceDialect,
16149 > {
16150 BaseNetworkSocketProxyInterface::r#get_ip_type_of_service(self)
16151 }
16152
16153 pub fn r#set_ip_ttl(
16155 &self,
16156 mut value: &OptionalUint8,
16157 ) -> fidl::client::QueryResponseFut<
16158 BaseNetworkSocketSetIpTtlResult,
16159 fidl::encoding::DefaultFuchsiaResourceDialect,
16160 > {
16161 BaseNetworkSocketProxyInterface::r#set_ip_ttl(self, value)
16162 }
16163
16164 pub fn r#get_ip_ttl(
16166 &self,
16167 ) -> fidl::client::QueryResponseFut<
16168 BaseNetworkSocketGetIpTtlResult,
16169 fidl::encoding::DefaultFuchsiaResourceDialect,
16170 > {
16171 BaseNetworkSocketProxyInterface::r#get_ip_ttl(self)
16172 }
16173
16174 pub fn r#set_ip_packet_info(
16176 &self,
16177 mut value: bool,
16178 ) -> fidl::client::QueryResponseFut<
16179 BaseNetworkSocketSetIpPacketInfoResult,
16180 fidl::encoding::DefaultFuchsiaResourceDialect,
16181 > {
16182 BaseNetworkSocketProxyInterface::r#set_ip_packet_info(self, value)
16183 }
16184
16185 pub fn r#get_ip_packet_info(
16187 &self,
16188 ) -> fidl::client::QueryResponseFut<
16189 BaseNetworkSocketGetIpPacketInfoResult,
16190 fidl::encoding::DefaultFuchsiaResourceDialect,
16191 > {
16192 BaseNetworkSocketProxyInterface::r#get_ip_packet_info(self)
16193 }
16194
16195 pub fn r#set_ip_receive_type_of_service(
16197 &self,
16198 mut value: bool,
16199 ) -> fidl::client::QueryResponseFut<
16200 BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
16201 fidl::encoding::DefaultFuchsiaResourceDialect,
16202 > {
16203 BaseNetworkSocketProxyInterface::r#set_ip_receive_type_of_service(self, value)
16204 }
16205
16206 pub fn r#get_ip_receive_type_of_service(
16208 &self,
16209 ) -> fidl::client::QueryResponseFut<
16210 BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
16211 fidl::encoding::DefaultFuchsiaResourceDialect,
16212 > {
16213 BaseNetworkSocketProxyInterface::r#get_ip_receive_type_of_service(self)
16214 }
16215
16216 pub fn r#set_ip_receive_ttl(
16218 &self,
16219 mut value: bool,
16220 ) -> fidl::client::QueryResponseFut<
16221 BaseNetworkSocketSetIpReceiveTtlResult,
16222 fidl::encoding::DefaultFuchsiaResourceDialect,
16223 > {
16224 BaseNetworkSocketProxyInterface::r#set_ip_receive_ttl(self, value)
16225 }
16226
16227 pub fn r#get_ip_receive_ttl(
16229 &self,
16230 ) -> fidl::client::QueryResponseFut<
16231 BaseNetworkSocketGetIpReceiveTtlResult,
16232 fidl::encoding::DefaultFuchsiaResourceDialect,
16233 > {
16234 BaseNetworkSocketProxyInterface::r#get_ip_receive_ttl(self)
16235 }
16236
16237 pub fn r#set_ip_multicast_interface(
16239 &self,
16240 mut iface: u64,
16241 mut address: &fidl_fuchsia_net::Ipv4Address,
16242 ) -> fidl::client::QueryResponseFut<
16243 BaseNetworkSocketSetIpMulticastInterfaceResult,
16244 fidl::encoding::DefaultFuchsiaResourceDialect,
16245 > {
16246 BaseNetworkSocketProxyInterface::r#set_ip_multicast_interface(self, iface, address)
16247 }
16248
16249 pub fn r#get_ip_multicast_interface(
16251 &self,
16252 ) -> fidl::client::QueryResponseFut<
16253 BaseNetworkSocketGetIpMulticastInterfaceResult,
16254 fidl::encoding::DefaultFuchsiaResourceDialect,
16255 > {
16256 BaseNetworkSocketProxyInterface::r#get_ip_multicast_interface(self)
16257 }
16258
16259 pub fn r#set_ip_multicast_ttl(
16261 &self,
16262 mut value: &OptionalUint8,
16263 ) -> fidl::client::QueryResponseFut<
16264 BaseNetworkSocketSetIpMulticastTtlResult,
16265 fidl::encoding::DefaultFuchsiaResourceDialect,
16266 > {
16267 BaseNetworkSocketProxyInterface::r#set_ip_multicast_ttl(self, value)
16268 }
16269
16270 pub fn r#get_ip_multicast_ttl(
16272 &self,
16273 ) -> fidl::client::QueryResponseFut<
16274 BaseNetworkSocketGetIpMulticastTtlResult,
16275 fidl::encoding::DefaultFuchsiaResourceDialect,
16276 > {
16277 BaseNetworkSocketProxyInterface::r#get_ip_multicast_ttl(self)
16278 }
16279
16280 pub fn r#set_ip_multicast_loopback(
16282 &self,
16283 mut value: bool,
16284 ) -> fidl::client::QueryResponseFut<
16285 BaseNetworkSocketSetIpMulticastLoopbackResult,
16286 fidl::encoding::DefaultFuchsiaResourceDialect,
16287 > {
16288 BaseNetworkSocketProxyInterface::r#set_ip_multicast_loopback(self, value)
16289 }
16290
16291 pub fn r#get_ip_multicast_loopback(
16293 &self,
16294 ) -> fidl::client::QueryResponseFut<
16295 BaseNetworkSocketGetIpMulticastLoopbackResult,
16296 fidl::encoding::DefaultFuchsiaResourceDialect,
16297 > {
16298 BaseNetworkSocketProxyInterface::r#get_ip_multicast_loopback(self)
16299 }
16300
16301 pub fn r#add_ip_membership(
16303 &self,
16304 mut membership: &IpMulticastMembership,
16305 ) -> fidl::client::QueryResponseFut<
16306 BaseNetworkSocketAddIpMembershipResult,
16307 fidl::encoding::DefaultFuchsiaResourceDialect,
16308 > {
16309 BaseNetworkSocketProxyInterface::r#add_ip_membership(self, membership)
16310 }
16311
16312 pub fn r#drop_ip_membership(
16314 &self,
16315 mut membership: &IpMulticastMembership,
16316 ) -> fidl::client::QueryResponseFut<
16317 BaseNetworkSocketDropIpMembershipResult,
16318 fidl::encoding::DefaultFuchsiaResourceDialect,
16319 > {
16320 BaseNetworkSocketProxyInterface::r#drop_ip_membership(self, membership)
16321 }
16322
16323 pub fn r#set_ip_transparent(
16325 &self,
16326 mut value: bool,
16327 ) -> fidl::client::QueryResponseFut<
16328 BaseNetworkSocketSetIpTransparentResult,
16329 fidl::encoding::DefaultFuchsiaResourceDialect,
16330 > {
16331 BaseNetworkSocketProxyInterface::r#set_ip_transparent(self, value)
16332 }
16333
16334 pub fn r#get_ip_transparent(
16336 &self,
16337 ) -> fidl::client::QueryResponseFut<
16338 BaseNetworkSocketGetIpTransparentResult,
16339 fidl::encoding::DefaultFuchsiaResourceDialect,
16340 > {
16341 BaseNetworkSocketProxyInterface::r#get_ip_transparent(self)
16342 }
16343
16344 pub fn r#set_ip_receive_original_destination_address(
16346 &self,
16347 mut value: bool,
16348 ) -> fidl::client::QueryResponseFut<
16349 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
16350 fidl::encoding::DefaultFuchsiaResourceDialect,
16351 > {
16352 BaseNetworkSocketProxyInterface::r#set_ip_receive_original_destination_address(self, value)
16353 }
16354
16355 pub fn r#get_ip_receive_original_destination_address(
16357 &self,
16358 ) -> fidl::client::QueryResponseFut<
16359 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
16360 fidl::encoding::DefaultFuchsiaResourceDialect,
16361 > {
16362 BaseNetworkSocketProxyInterface::r#get_ip_receive_original_destination_address(self)
16363 }
16364
16365 pub fn r#add_ipv6_membership(
16367 &self,
16368 mut membership: &Ipv6MulticastMembership,
16369 ) -> fidl::client::QueryResponseFut<
16370 BaseNetworkSocketAddIpv6MembershipResult,
16371 fidl::encoding::DefaultFuchsiaResourceDialect,
16372 > {
16373 BaseNetworkSocketProxyInterface::r#add_ipv6_membership(self, membership)
16374 }
16375
16376 pub fn r#drop_ipv6_membership(
16378 &self,
16379 mut membership: &Ipv6MulticastMembership,
16380 ) -> fidl::client::QueryResponseFut<
16381 BaseNetworkSocketDropIpv6MembershipResult,
16382 fidl::encoding::DefaultFuchsiaResourceDialect,
16383 > {
16384 BaseNetworkSocketProxyInterface::r#drop_ipv6_membership(self, membership)
16385 }
16386
16387 pub fn r#set_ipv6_multicast_interface(
16389 &self,
16390 mut value: u64,
16391 ) -> fidl::client::QueryResponseFut<
16392 BaseNetworkSocketSetIpv6MulticastInterfaceResult,
16393 fidl::encoding::DefaultFuchsiaResourceDialect,
16394 > {
16395 BaseNetworkSocketProxyInterface::r#set_ipv6_multicast_interface(self, value)
16396 }
16397
16398 pub fn r#get_ipv6_multicast_interface(
16400 &self,
16401 ) -> fidl::client::QueryResponseFut<
16402 BaseNetworkSocketGetIpv6MulticastInterfaceResult,
16403 fidl::encoding::DefaultFuchsiaResourceDialect,
16404 > {
16405 BaseNetworkSocketProxyInterface::r#get_ipv6_multicast_interface(self)
16406 }
16407
16408 pub fn r#set_ipv6_unicast_hops(
16410 &self,
16411 mut value: &OptionalUint8,
16412 ) -> fidl::client::QueryResponseFut<
16413 BaseNetworkSocketSetIpv6UnicastHopsResult,
16414 fidl::encoding::DefaultFuchsiaResourceDialect,
16415 > {
16416 BaseNetworkSocketProxyInterface::r#set_ipv6_unicast_hops(self, value)
16417 }
16418
16419 pub fn r#get_ipv6_unicast_hops(
16421 &self,
16422 ) -> fidl::client::QueryResponseFut<
16423 BaseNetworkSocketGetIpv6UnicastHopsResult,
16424 fidl::encoding::DefaultFuchsiaResourceDialect,
16425 > {
16426 BaseNetworkSocketProxyInterface::r#get_ipv6_unicast_hops(self)
16427 }
16428
16429 pub fn r#set_ipv6_receive_hop_limit(
16431 &self,
16432 mut value: bool,
16433 ) -> fidl::client::QueryResponseFut<
16434 BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
16435 fidl::encoding::DefaultFuchsiaResourceDialect,
16436 > {
16437 BaseNetworkSocketProxyInterface::r#set_ipv6_receive_hop_limit(self, value)
16438 }
16439
16440 pub fn r#get_ipv6_receive_hop_limit(
16442 &self,
16443 ) -> fidl::client::QueryResponseFut<
16444 BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
16445 fidl::encoding::DefaultFuchsiaResourceDialect,
16446 > {
16447 BaseNetworkSocketProxyInterface::r#get_ipv6_receive_hop_limit(self)
16448 }
16449
16450 pub fn r#set_ipv6_multicast_hops(
16452 &self,
16453 mut value: &OptionalUint8,
16454 ) -> fidl::client::QueryResponseFut<
16455 BaseNetworkSocketSetIpv6MulticastHopsResult,
16456 fidl::encoding::DefaultFuchsiaResourceDialect,
16457 > {
16458 BaseNetworkSocketProxyInterface::r#set_ipv6_multicast_hops(self, value)
16459 }
16460
16461 pub fn r#get_ipv6_multicast_hops(
16463 &self,
16464 ) -> fidl::client::QueryResponseFut<
16465 BaseNetworkSocketGetIpv6MulticastHopsResult,
16466 fidl::encoding::DefaultFuchsiaResourceDialect,
16467 > {
16468 BaseNetworkSocketProxyInterface::r#get_ipv6_multicast_hops(self)
16469 }
16470
16471 pub fn r#set_ipv6_multicast_loopback(
16473 &self,
16474 mut value: bool,
16475 ) -> fidl::client::QueryResponseFut<
16476 BaseNetworkSocketSetIpv6MulticastLoopbackResult,
16477 fidl::encoding::DefaultFuchsiaResourceDialect,
16478 > {
16479 BaseNetworkSocketProxyInterface::r#set_ipv6_multicast_loopback(self, value)
16480 }
16481
16482 pub fn r#get_ipv6_multicast_loopback(
16484 &self,
16485 ) -> fidl::client::QueryResponseFut<
16486 BaseNetworkSocketGetIpv6MulticastLoopbackResult,
16487 fidl::encoding::DefaultFuchsiaResourceDialect,
16488 > {
16489 BaseNetworkSocketProxyInterface::r#get_ipv6_multicast_loopback(self)
16490 }
16491
16492 pub fn r#set_ipv6_only(
16494 &self,
16495 mut value: bool,
16496 ) -> fidl::client::QueryResponseFut<
16497 BaseNetworkSocketSetIpv6OnlyResult,
16498 fidl::encoding::DefaultFuchsiaResourceDialect,
16499 > {
16500 BaseNetworkSocketProxyInterface::r#set_ipv6_only(self, value)
16501 }
16502
16503 pub fn r#get_ipv6_only(
16505 &self,
16506 ) -> fidl::client::QueryResponseFut<
16507 BaseNetworkSocketGetIpv6OnlyResult,
16508 fidl::encoding::DefaultFuchsiaResourceDialect,
16509 > {
16510 BaseNetworkSocketProxyInterface::r#get_ipv6_only(self)
16511 }
16512
16513 pub fn r#set_ipv6_receive_traffic_class(
16515 &self,
16516 mut value: bool,
16517 ) -> fidl::client::QueryResponseFut<
16518 BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
16519 fidl::encoding::DefaultFuchsiaResourceDialect,
16520 > {
16521 BaseNetworkSocketProxyInterface::r#set_ipv6_receive_traffic_class(self, value)
16522 }
16523
16524 pub fn r#get_ipv6_receive_traffic_class(
16526 &self,
16527 ) -> fidl::client::QueryResponseFut<
16528 BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
16529 fidl::encoding::DefaultFuchsiaResourceDialect,
16530 > {
16531 BaseNetworkSocketProxyInterface::r#get_ipv6_receive_traffic_class(self)
16532 }
16533
16534 pub fn r#set_ipv6_traffic_class(
16536 &self,
16537 mut value: &OptionalUint8,
16538 ) -> fidl::client::QueryResponseFut<
16539 BaseNetworkSocketSetIpv6TrafficClassResult,
16540 fidl::encoding::DefaultFuchsiaResourceDialect,
16541 > {
16542 BaseNetworkSocketProxyInterface::r#set_ipv6_traffic_class(self, value)
16543 }
16544
16545 pub fn r#get_ipv6_traffic_class(
16547 &self,
16548 ) -> fidl::client::QueryResponseFut<
16549 BaseNetworkSocketGetIpv6TrafficClassResult,
16550 fidl::encoding::DefaultFuchsiaResourceDialect,
16551 > {
16552 BaseNetworkSocketProxyInterface::r#get_ipv6_traffic_class(self)
16553 }
16554
16555 pub fn r#set_ipv6_receive_packet_info(
16557 &self,
16558 mut value: bool,
16559 ) -> fidl::client::QueryResponseFut<
16560 BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
16561 fidl::encoding::DefaultFuchsiaResourceDialect,
16562 > {
16563 BaseNetworkSocketProxyInterface::r#set_ipv6_receive_packet_info(self, value)
16564 }
16565
16566 pub fn r#get_ipv6_receive_packet_info(
16568 &self,
16569 ) -> fidl::client::QueryResponseFut<
16570 BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
16571 fidl::encoding::DefaultFuchsiaResourceDialect,
16572 > {
16573 BaseNetworkSocketProxyInterface::r#get_ipv6_receive_packet_info(self)
16574 }
16575
16576 pub fn r#get_original_destination(
16578 &self,
16579 ) -> fidl::client::QueryResponseFut<
16580 BaseNetworkSocketGetOriginalDestinationResult,
16581 fidl::encoding::DefaultFuchsiaResourceDialect,
16582 > {
16583 BaseNetworkSocketProxyInterface::r#get_original_destination(self)
16584 }
16585}
16586
16587impl BaseNetworkSocketProxyInterface for BaseNetworkSocketProxy {
16588 fn r#clone(
16589 &self,
16590 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
16591 ) -> Result<(), fidl::Error> {
16592 self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
16593 (request,),
16594 0x20d8a7aba2168a79,
16595 fidl::encoding::DynamicFlags::empty(),
16596 )
16597 }
16598
16599 type CloseResponseFut = fidl::client::QueryResponseFut<
16600 fidl_fuchsia_unknown::CloseableCloseResult,
16601 fidl::encoding::DefaultFuchsiaResourceDialect,
16602 >;
16603 fn r#close(&self) -> Self::CloseResponseFut {
16604 fn _decode(
16605 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16606 ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
16607 let _response = fidl::client::decode_transaction_body::<
16608 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
16609 fidl::encoding::DefaultFuchsiaResourceDialect,
16610 0x5ac5d459ad7f657e,
16611 >(_buf?)?;
16612 Ok(_response.map(|x| x))
16613 }
16614 self.client.send_query_and_decode::<
16615 fidl::encoding::EmptyPayload,
16616 fidl_fuchsia_unknown::CloseableCloseResult,
16617 >(
16618 (),
16619 0x5ac5d459ad7f657e,
16620 fidl::encoding::DynamicFlags::empty(),
16621 _decode,
16622 )
16623 }
16624
16625 type QueryResponseFut =
16626 fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
16627 fn r#query(&self) -> Self::QueryResponseFut {
16628 fn _decode(
16629 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16630 ) -> Result<Vec<u8>, fidl::Error> {
16631 let _response = fidl::client::decode_transaction_body::<
16632 fidl_fuchsia_unknown::QueryableQueryResponse,
16633 fidl::encoding::DefaultFuchsiaResourceDialect,
16634 0x2658edee9decfc06,
16635 >(_buf?)?;
16636 Ok(_response.protocol)
16637 }
16638 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
16639 (),
16640 0x2658edee9decfc06,
16641 fidl::encoding::DynamicFlags::empty(),
16642 _decode,
16643 )
16644 }
16645
16646 type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
16647 BaseSocketSetReuseAddressResult,
16648 fidl::encoding::DefaultFuchsiaResourceDialect,
16649 >;
16650 fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
16651 fn _decode(
16652 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16653 ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
16654 let _response = fidl::client::decode_transaction_body::<
16655 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
16656 fidl::encoding::DefaultFuchsiaResourceDialect,
16657 0x1fd74ee8b9a4a876,
16658 >(_buf?)?;
16659 Ok(_response.map(|x| x))
16660 }
16661 self.client.send_query_and_decode::<
16662 BaseSocketSetReuseAddressRequest,
16663 BaseSocketSetReuseAddressResult,
16664 >(
16665 (value,),
16666 0x1fd74ee8b9a4a876,
16667 fidl::encoding::DynamicFlags::empty(),
16668 _decode,
16669 )
16670 }
16671
16672 type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
16673 BaseSocketGetReuseAddressResult,
16674 fidl::encoding::DefaultFuchsiaResourceDialect,
16675 >;
16676 fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
16677 fn _decode(
16678 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16679 ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
16680 let _response = fidl::client::decode_transaction_body::<
16681 fidl::encoding::ResultType<
16682 BaseSocketGetReuseAddressResponse,
16683 fidl_fuchsia_posix::Errno,
16684 >,
16685 fidl::encoding::DefaultFuchsiaResourceDialect,
16686 0x67b7206b8d1bc0a5,
16687 >(_buf?)?;
16688 Ok(_response.map(|x| x.value))
16689 }
16690 self.client
16691 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
16692 (),
16693 0x67b7206b8d1bc0a5,
16694 fidl::encoding::DynamicFlags::empty(),
16695 _decode,
16696 )
16697 }
16698
16699 type GetErrorResponseFut = fidl::client::QueryResponseFut<
16700 BaseSocketGetErrorResult,
16701 fidl::encoding::DefaultFuchsiaResourceDialect,
16702 >;
16703 fn r#get_error(&self) -> Self::GetErrorResponseFut {
16704 fn _decode(
16705 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16706 ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
16707 let _response = fidl::client::decode_transaction_body::<
16708 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
16709 fidl::encoding::DefaultFuchsiaResourceDialect,
16710 0x5aad39b33e5f6ebb,
16711 >(_buf?)?;
16712 Ok(_response.map(|x| x))
16713 }
16714 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
16715 (),
16716 0x5aad39b33e5f6ebb,
16717 fidl::encoding::DynamicFlags::empty(),
16718 _decode,
16719 )
16720 }
16721
16722 type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
16723 BaseSocketSetBroadcastResult,
16724 fidl::encoding::DefaultFuchsiaResourceDialect,
16725 >;
16726 fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
16727 fn _decode(
16728 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16729 ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
16730 let _response = fidl::client::decode_transaction_body::<
16731 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
16732 fidl::encoding::DefaultFuchsiaResourceDialect,
16733 0x6023e081ce3cd947,
16734 >(_buf?)?;
16735 Ok(_response.map(|x| x))
16736 }
16737 self.client
16738 .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
16739 (value,),
16740 0x6023e081ce3cd947,
16741 fidl::encoding::DynamicFlags::empty(),
16742 _decode,
16743 )
16744 }
16745
16746 type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
16747 BaseSocketGetBroadcastResult,
16748 fidl::encoding::DefaultFuchsiaResourceDialect,
16749 >;
16750 fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
16751 fn _decode(
16752 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16753 ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
16754 let _response = fidl::client::decode_transaction_body::<
16755 fidl::encoding::ResultType<
16756 BaseSocketGetBroadcastResponse,
16757 fidl_fuchsia_posix::Errno,
16758 >,
16759 fidl::encoding::DefaultFuchsiaResourceDialect,
16760 0x68796fc556f9780d,
16761 >(_buf?)?;
16762 Ok(_response.map(|x| x.value))
16763 }
16764 self.client
16765 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
16766 (),
16767 0x68796fc556f9780d,
16768 fidl::encoding::DynamicFlags::empty(),
16769 _decode,
16770 )
16771 }
16772
16773 type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
16774 BaseSocketSetSendBufferResult,
16775 fidl::encoding::DefaultFuchsiaResourceDialect,
16776 >;
16777 fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
16778 fn _decode(
16779 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16780 ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
16781 let _response = fidl::client::decode_transaction_body::<
16782 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
16783 fidl::encoding::DefaultFuchsiaResourceDialect,
16784 0x756eac32d73a7a70,
16785 >(_buf?)?;
16786 Ok(_response.map(|x| x))
16787 }
16788 self.client
16789 .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
16790 (value_bytes,),
16791 0x756eac32d73a7a70,
16792 fidl::encoding::DynamicFlags::empty(),
16793 _decode,
16794 )
16795 }
16796
16797 type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
16798 BaseSocketGetSendBufferResult,
16799 fidl::encoding::DefaultFuchsiaResourceDialect,
16800 >;
16801 fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
16802 fn _decode(
16803 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16804 ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
16805 let _response = fidl::client::decode_transaction_body::<
16806 fidl::encoding::ResultType<
16807 BaseSocketGetSendBufferResponse,
16808 fidl_fuchsia_posix::Errno,
16809 >,
16810 fidl::encoding::DefaultFuchsiaResourceDialect,
16811 0x78a52fd9c7b2410b,
16812 >(_buf?)?;
16813 Ok(_response.map(|x| x.value_bytes))
16814 }
16815 self.client
16816 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
16817 (),
16818 0x78a52fd9c7b2410b,
16819 fidl::encoding::DynamicFlags::empty(),
16820 _decode,
16821 )
16822 }
16823
16824 type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
16825 BaseSocketSetReceiveBufferResult,
16826 fidl::encoding::DefaultFuchsiaResourceDialect,
16827 >;
16828 fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
16829 fn _decode(
16830 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16831 ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
16832 let _response = fidl::client::decode_transaction_body::<
16833 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
16834 fidl::encoding::DefaultFuchsiaResourceDialect,
16835 0x6b0cf2f1919c7001,
16836 >(_buf?)?;
16837 Ok(_response.map(|x| x))
16838 }
16839 self.client.send_query_and_decode::<
16840 BaseSocketSetReceiveBufferRequest,
16841 BaseSocketSetReceiveBufferResult,
16842 >(
16843 (value_bytes,),
16844 0x6b0cf2f1919c7001,
16845 fidl::encoding::DynamicFlags::empty(),
16846 _decode,
16847 )
16848 }
16849
16850 type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
16851 BaseSocketGetReceiveBufferResult,
16852 fidl::encoding::DefaultFuchsiaResourceDialect,
16853 >;
16854 fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
16855 fn _decode(
16856 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16857 ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
16858 let _response = fidl::client::decode_transaction_body::<
16859 fidl::encoding::ResultType<
16860 BaseSocketGetReceiveBufferResponse,
16861 fidl_fuchsia_posix::Errno,
16862 >,
16863 fidl::encoding::DefaultFuchsiaResourceDialect,
16864 0x14c1a4b64f709e5c,
16865 >(_buf?)?;
16866 Ok(_response.map(|x| x.value_bytes))
16867 }
16868 self.client.send_query_and_decode::<
16869 fidl::encoding::EmptyPayload,
16870 BaseSocketGetReceiveBufferResult,
16871 >(
16872 (),
16873 0x14c1a4b64f709e5c,
16874 fidl::encoding::DynamicFlags::empty(),
16875 _decode,
16876 )
16877 }
16878
16879 type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
16880 BaseSocketSetKeepAliveResult,
16881 fidl::encoding::DefaultFuchsiaResourceDialect,
16882 >;
16883 fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
16884 fn _decode(
16885 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16886 ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
16887 let _response = fidl::client::decode_transaction_body::<
16888 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
16889 fidl::encoding::DefaultFuchsiaResourceDialect,
16890 0x572df8f0b920d2c7,
16891 >(_buf?)?;
16892 Ok(_response.map(|x| x))
16893 }
16894 self.client
16895 .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
16896 (value,),
16897 0x572df8f0b920d2c7,
16898 fidl::encoding::DynamicFlags::empty(),
16899 _decode,
16900 )
16901 }
16902
16903 type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
16904 BaseSocketGetKeepAliveResult,
16905 fidl::encoding::DefaultFuchsiaResourceDialect,
16906 >;
16907 fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
16908 fn _decode(
16909 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16910 ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
16911 let _response = fidl::client::decode_transaction_body::<
16912 fidl::encoding::ResultType<
16913 BaseSocketGetKeepAliveResponse,
16914 fidl_fuchsia_posix::Errno,
16915 >,
16916 fidl::encoding::DefaultFuchsiaResourceDialect,
16917 0x2dd29d3215f2c9d2,
16918 >(_buf?)?;
16919 Ok(_response.map(|x| x.value))
16920 }
16921 self.client
16922 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
16923 (),
16924 0x2dd29d3215f2c9d2,
16925 fidl::encoding::DynamicFlags::empty(),
16926 _decode,
16927 )
16928 }
16929
16930 type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
16931 BaseSocketSetOutOfBandInlineResult,
16932 fidl::encoding::DefaultFuchsiaResourceDialect,
16933 >;
16934 fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
16935 fn _decode(
16936 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16937 ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
16938 let _response = fidl::client::decode_transaction_body::<
16939 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
16940 fidl::encoding::DefaultFuchsiaResourceDialect,
16941 0x3ecb49968bee439,
16942 >(_buf?)?;
16943 Ok(_response.map(|x| x))
16944 }
16945 self.client.send_query_and_decode::<
16946 BaseSocketSetOutOfBandInlineRequest,
16947 BaseSocketSetOutOfBandInlineResult,
16948 >(
16949 (value,),
16950 0x3ecb49968bee439,
16951 fidl::encoding::DynamicFlags::empty(),
16952 _decode,
16953 )
16954 }
16955
16956 type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
16957 BaseSocketGetOutOfBandInlineResult,
16958 fidl::encoding::DefaultFuchsiaResourceDialect,
16959 >;
16960 fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
16961 fn _decode(
16962 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16963 ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
16964 let _response = fidl::client::decode_transaction_body::<
16965 fidl::encoding::ResultType<
16966 BaseSocketGetOutOfBandInlineResponse,
16967 fidl_fuchsia_posix::Errno,
16968 >,
16969 fidl::encoding::DefaultFuchsiaResourceDialect,
16970 0x348c1ab3aeca1745,
16971 >(_buf?)?;
16972 Ok(_response.map(|x| x.value))
16973 }
16974 self.client.send_query_and_decode::<
16975 fidl::encoding::EmptyPayload,
16976 BaseSocketGetOutOfBandInlineResult,
16977 >(
16978 (),
16979 0x348c1ab3aeca1745,
16980 fidl::encoding::DynamicFlags::empty(),
16981 _decode,
16982 )
16983 }
16984
16985 type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
16986 BaseSocketSetNoCheckResult,
16987 fidl::encoding::DefaultFuchsiaResourceDialect,
16988 >;
16989 fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
16990 fn _decode(
16991 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16992 ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
16993 let _response = fidl::client::decode_transaction_body::<
16994 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
16995 fidl::encoding::DefaultFuchsiaResourceDialect,
16996 0x6bbf00c53a4c78c2,
16997 >(_buf?)?;
16998 Ok(_response.map(|x| x))
16999 }
17000 self.client
17001 .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
17002 (value,),
17003 0x6bbf00c53a4c78c2,
17004 fidl::encoding::DynamicFlags::empty(),
17005 _decode,
17006 )
17007 }
17008
17009 type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
17010 BaseSocketGetNoCheckResult,
17011 fidl::encoding::DefaultFuchsiaResourceDialect,
17012 >;
17013 fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
17014 fn _decode(
17015 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17016 ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
17017 let _response = fidl::client::decode_transaction_body::<
17018 fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
17019 fidl::encoding::DefaultFuchsiaResourceDialect,
17020 0x2cd4249286417694,
17021 >(_buf?)?;
17022 Ok(_response.map(|x| x.value))
17023 }
17024 self.client
17025 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
17026 (),
17027 0x2cd4249286417694,
17028 fidl::encoding::DynamicFlags::empty(),
17029 _decode,
17030 )
17031 }
17032
17033 type SetLingerResponseFut = fidl::client::QueryResponseFut<
17034 BaseSocketSetLingerResult,
17035 fidl::encoding::DefaultFuchsiaResourceDialect,
17036 >;
17037 fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
17038 fn _decode(
17039 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17040 ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
17041 let _response = fidl::client::decode_transaction_body::<
17042 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17043 fidl::encoding::DefaultFuchsiaResourceDialect,
17044 0x45386351246e998e,
17045 >(_buf?)?;
17046 Ok(_response.map(|x| x))
17047 }
17048 self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
17049 (linger, length_secs),
17050 0x45386351246e998e,
17051 fidl::encoding::DynamicFlags::empty(),
17052 _decode,
17053 )
17054 }
17055
17056 type GetLingerResponseFut = fidl::client::QueryResponseFut<
17057 BaseSocketGetLingerResult,
17058 fidl::encoding::DefaultFuchsiaResourceDialect,
17059 >;
17060 fn r#get_linger(&self) -> Self::GetLingerResponseFut {
17061 fn _decode(
17062 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17063 ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
17064 let _response = fidl::client::decode_transaction_body::<
17065 fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
17066 fidl::encoding::DefaultFuchsiaResourceDialect,
17067 0x48eb20fc5ccb0e45,
17068 >(_buf?)?;
17069 Ok(_response.map(|x| (x.linger, x.length_secs)))
17070 }
17071 self.client
17072 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
17073 (),
17074 0x48eb20fc5ccb0e45,
17075 fidl::encoding::DynamicFlags::empty(),
17076 _decode,
17077 )
17078 }
17079
17080 type SetReusePortResponseFut = fidl::client::QueryResponseFut<
17081 BaseSocketSetReusePortResult,
17082 fidl::encoding::DefaultFuchsiaResourceDialect,
17083 >;
17084 fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
17085 fn _decode(
17086 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17087 ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
17088 let _response = fidl::client::decode_transaction_body::<
17089 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17090 fidl::encoding::DefaultFuchsiaResourceDialect,
17091 0x24dd3e5cb36d9ccb,
17092 >(_buf?)?;
17093 Ok(_response.map(|x| x))
17094 }
17095 self.client
17096 .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
17097 (value,),
17098 0x24dd3e5cb36d9ccb,
17099 fidl::encoding::DynamicFlags::empty(),
17100 _decode,
17101 )
17102 }
17103
17104 type GetReusePortResponseFut = fidl::client::QueryResponseFut<
17105 BaseSocketGetReusePortResult,
17106 fidl::encoding::DefaultFuchsiaResourceDialect,
17107 >;
17108 fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
17109 fn _decode(
17110 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17111 ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
17112 let _response = fidl::client::decode_transaction_body::<
17113 fidl::encoding::ResultType<
17114 BaseSocketGetReusePortResponse,
17115 fidl_fuchsia_posix::Errno,
17116 >,
17117 fidl::encoding::DefaultFuchsiaResourceDialect,
17118 0x7a112c1ab54ff828,
17119 >(_buf?)?;
17120 Ok(_response.map(|x| x.value))
17121 }
17122 self.client
17123 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
17124 (),
17125 0x7a112c1ab54ff828,
17126 fidl::encoding::DynamicFlags::empty(),
17127 _decode,
17128 )
17129 }
17130
17131 type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
17132 BaseSocketGetAcceptConnResult,
17133 fidl::encoding::DefaultFuchsiaResourceDialect,
17134 >;
17135 fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
17136 fn _decode(
17137 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17138 ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
17139 let _response = fidl::client::decode_transaction_body::<
17140 fidl::encoding::ResultType<
17141 BaseSocketGetAcceptConnResponse,
17142 fidl_fuchsia_posix::Errno,
17143 >,
17144 fidl::encoding::DefaultFuchsiaResourceDialect,
17145 0x67ce6db6c2ec8966,
17146 >(_buf?)?;
17147 Ok(_response.map(|x| x.value))
17148 }
17149 self.client
17150 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
17151 (),
17152 0x67ce6db6c2ec8966,
17153 fidl::encoding::DynamicFlags::empty(),
17154 _decode,
17155 )
17156 }
17157
17158 type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
17159 BaseSocketSetBindToDeviceResult,
17160 fidl::encoding::DefaultFuchsiaResourceDialect,
17161 >;
17162 fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
17163 fn _decode(
17164 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17165 ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
17166 let _response = fidl::client::decode_transaction_body::<
17167 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17168 fidl::encoding::DefaultFuchsiaResourceDialect,
17169 0x2118b483f28aafc4,
17170 >(_buf?)?;
17171 Ok(_response.map(|x| x))
17172 }
17173 self.client.send_query_and_decode::<
17174 BaseSocketSetBindToDeviceRequest,
17175 BaseSocketSetBindToDeviceResult,
17176 >(
17177 (value,),
17178 0x2118b483f28aafc4,
17179 fidl::encoding::DynamicFlags::empty(),
17180 _decode,
17181 )
17182 }
17183
17184 type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
17185 BaseSocketGetBindToDeviceResult,
17186 fidl::encoding::DefaultFuchsiaResourceDialect,
17187 >;
17188 fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
17189 fn _decode(
17190 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17191 ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
17192 let _response = fidl::client::decode_transaction_body::<
17193 fidl::encoding::ResultType<
17194 BaseSocketGetBindToDeviceResponse,
17195 fidl_fuchsia_posix::Errno,
17196 >,
17197 fidl::encoding::DefaultFuchsiaResourceDialect,
17198 0x1ab1fbf0ef7906c8,
17199 >(_buf?)?;
17200 Ok(_response.map(|x| x.value))
17201 }
17202 self.client
17203 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
17204 (),
17205 0x1ab1fbf0ef7906c8,
17206 fidl::encoding::DynamicFlags::empty(),
17207 _decode,
17208 )
17209 }
17210
17211 type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
17212 BaseSocketSetBindToInterfaceIndexResult,
17213 fidl::encoding::DefaultFuchsiaResourceDialect,
17214 >;
17215 fn r#set_bind_to_interface_index(
17216 &self,
17217 mut value: u64,
17218 ) -> Self::SetBindToInterfaceIndexResponseFut {
17219 fn _decode(
17220 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17221 ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
17222 let _response = fidl::client::decode_transaction_body::<
17223 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17224 fidl::encoding::DefaultFuchsiaResourceDialect,
17225 0x6e387a0def00821,
17226 >(_buf?)?;
17227 Ok(_response.map(|x| x))
17228 }
17229 self.client.send_query_and_decode::<
17230 BaseSocketSetBindToInterfaceIndexRequest,
17231 BaseSocketSetBindToInterfaceIndexResult,
17232 >(
17233 (value,),
17234 0x6e387a0def00821,
17235 fidl::encoding::DynamicFlags::empty(),
17236 _decode,
17237 )
17238 }
17239
17240 type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
17241 BaseSocketGetBindToInterfaceIndexResult,
17242 fidl::encoding::DefaultFuchsiaResourceDialect,
17243 >;
17244 fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
17245 fn _decode(
17246 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17247 ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
17248 let _response = fidl::client::decode_transaction_body::<
17249 fidl::encoding::ResultType<
17250 BaseSocketGetBindToInterfaceIndexResponse,
17251 fidl_fuchsia_posix::Errno,
17252 >,
17253 fidl::encoding::DefaultFuchsiaResourceDialect,
17254 0x59c31dd3e3078295,
17255 >(_buf?)?;
17256 Ok(_response.map(|x| x.value))
17257 }
17258 self.client.send_query_and_decode::<
17259 fidl::encoding::EmptyPayload,
17260 BaseSocketGetBindToInterfaceIndexResult,
17261 >(
17262 (),
17263 0x59c31dd3e3078295,
17264 fidl::encoding::DynamicFlags::empty(),
17265 _decode,
17266 )
17267 }
17268
17269 type SetTimestampResponseFut = fidl::client::QueryResponseFut<
17270 BaseSocketSetTimestampResult,
17271 fidl::encoding::DefaultFuchsiaResourceDialect,
17272 >;
17273 fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
17274 fn _decode(
17275 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17276 ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
17277 let _response = fidl::client::decode_transaction_body::<
17278 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17279 fidl::encoding::DefaultFuchsiaResourceDialect,
17280 0x285d6516c263d839,
17281 >(_buf?)?;
17282 Ok(_response.map(|x| x))
17283 }
17284 self.client
17285 .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
17286 (value,),
17287 0x285d6516c263d839,
17288 fidl::encoding::DynamicFlags::empty(),
17289 _decode,
17290 )
17291 }
17292
17293 type GetTimestampResponseFut = fidl::client::QueryResponseFut<
17294 BaseSocketGetTimestampResult,
17295 fidl::encoding::DefaultFuchsiaResourceDialect,
17296 >;
17297 fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
17298 fn _decode(
17299 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17300 ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
17301 let _response = fidl::client::decode_transaction_body::<
17302 fidl::encoding::ResultType<
17303 BaseSocketGetTimestampResponse,
17304 fidl_fuchsia_posix::Errno,
17305 >,
17306 fidl::encoding::DefaultFuchsiaResourceDialect,
17307 0x49f2fffbbcc2bd27,
17308 >(_buf?)?;
17309 Ok(_response.map(|x| x.value))
17310 }
17311 self.client
17312 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
17313 (),
17314 0x49f2fffbbcc2bd27,
17315 fidl::encoding::DynamicFlags::empty(),
17316 _decode,
17317 )
17318 }
17319
17320 type SetMarkResponseFut = fidl::client::QueryResponseFut<
17321 BaseSocketSetMarkResult,
17322 fidl::encoding::DefaultFuchsiaResourceDialect,
17323 >;
17324 fn r#set_mark(
17325 &self,
17326 mut domain: fidl_fuchsia_net::MarkDomain,
17327 mut mark: &OptionalUint32,
17328 ) -> Self::SetMarkResponseFut {
17329 fn _decode(
17330 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17331 ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
17332 let _response = fidl::client::decode_transaction_body::<
17333 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17334 fidl::encoding::DefaultFuchsiaResourceDialect,
17335 0x6ead6de09f653236,
17336 >(_buf?)?;
17337 Ok(_response.map(|x| x))
17338 }
17339 self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
17340 (domain, mark),
17341 0x6ead6de09f653236,
17342 fidl::encoding::DynamicFlags::empty(),
17343 _decode,
17344 )
17345 }
17346
17347 type GetMarkResponseFut = fidl::client::QueryResponseFut<
17348 BaseSocketGetMarkResult,
17349 fidl::encoding::DefaultFuchsiaResourceDialect,
17350 >;
17351 fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
17352 fn _decode(
17353 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17354 ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
17355 let _response = fidl::client::decode_transaction_body::<
17356 fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
17357 fidl::encoding::DefaultFuchsiaResourceDialect,
17358 0x57a2752c61d93d47,
17359 >(_buf?)?;
17360 Ok(_response.map(|x| x.mark))
17361 }
17362 self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
17363 (domain,),
17364 0x57a2752c61d93d47,
17365 fidl::encoding::DynamicFlags::empty(),
17366 _decode,
17367 )
17368 }
17369
17370 type BindResponseFut = fidl::client::QueryResponseFut<
17371 BaseNetworkSocketBindResult,
17372 fidl::encoding::DefaultFuchsiaResourceDialect,
17373 >;
17374 fn r#bind(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut {
17375 fn _decode(
17376 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17377 ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
17378 let _response = fidl::client::decode_transaction_body::<
17379 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17380 fidl::encoding::DefaultFuchsiaResourceDialect,
17381 0x4bc6400ae92125d,
17382 >(_buf?)?;
17383 Ok(_response.map(|x| x))
17384 }
17385 self.client
17386 .send_query_and_decode::<BaseNetworkSocketBindRequest, BaseNetworkSocketBindResult>(
17387 (addr,),
17388 0x4bc6400ae92125d,
17389 fidl::encoding::DynamicFlags::empty(),
17390 _decode,
17391 )
17392 }
17393
17394 type ConnectResponseFut = fidl::client::QueryResponseFut<
17395 BaseNetworkSocketConnectResult,
17396 fidl::encoding::DefaultFuchsiaResourceDialect,
17397 >;
17398 fn r#connect(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut {
17399 fn _decode(
17400 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17401 ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
17402 let _response = fidl::client::decode_transaction_body::<
17403 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17404 fidl::encoding::DefaultFuchsiaResourceDialect,
17405 0x5f05f19bfdd38871,
17406 >(_buf?)?;
17407 Ok(_response.map(|x| x))
17408 }
17409 self.client.send_query_and_decode::<
17410 BaseNetworkSocketConnectRequest,
17411 BaseNetworkSocketConnectResult,
17412 >(
17413 (addr,),
17414 0x5f05f19bfdd38871,
17415 fidl::encoding::DynamicFlags::empty(),
17416 _decode,
17417 )
17418 }
17419
17420 type DisconnectResponseFut = fidl::client::QueryResponseFut<
17421 BaseNetworkSocketDisconnectResult,
17422 fidl::encoding::DefaultFuchsiaResourceDialect,
17423 >;
17424 fn r#disconnect(&self) -> Self::DisconnectResponseFut {
17425 fn _decode(
17426 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17427 ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
17428 let _response = fidl::client::decode_transaction_body::<
17429 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17430 fidl::encoding::DefaultFuchsiaResourceDialect,
17431 0x74e63b91f7b29b2,
17432 >(_buf?)?;
17433 Ok(_response.map(|x| x))
17434 }
17435 self.client.send_query_and_decode::<
17436 fidl::encoding::EmptyPayload,
17437 BaseNetworkSocketDisconnectResult,
17438 >(
17439 (),
17440 0x74e63b91f7b29b2,
17441 fidl::encoding::DynamicFlags::empty(),
17442 _decode,
17443 )
17444 }
17445
17446 type GetSockNameResponseFut = fidl::client::QueryResponseFut<
17447 BaseNetworkSocketGetSockNameResult,
17448 fidl::encoding::DefaultFuchsiaResourceDialect,
17449 >;
17450 fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
17451 fn _decode(
17452 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17453 ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
17454 let _response = fidl::client::decode_transaction_body::<
17455 fidl::encoding::ResultType<
17456 BaseNetworkSocketGetSockNameResponse,
17457 fidl_fuchsia_posix::Errno,
17458 >,
17459 fidl::encoding::DefaultFuchsiaResourceDialect,
17460 0x475f23f84a1a4f85,
17461 >(_buf?)?;
17462 Ok(_response.map(|x| x.addr))
17463 }
17464 self.client.send_query_and_decode::<
17465 fidl::encoding::EmptyPayload,
17466 BaseNetworkSocketGetSockNameResult,
17467 >(
17468 (),
17469 0x475f23f84a1a4f85,
17470 fidl::encoding::DynamicFlags::empty(),
17471 _decode,
17472 )
17473 }
17474
17475 type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
17476 BaseNetworkSocketGetPeerNameResult,
17477 fidl::encoding::DefaultFuchsiaResourceDialect,
17478 >;
17479 fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
17480 fn _decode(
17481 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17482 ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
17483 let _response = fidl::client::decode_transaction_body::<
17484 fidl::encoding::ResultType<
17485 BaseNetworkSocketGetPeerNameResponse,
17486 fidl_fuchsia_posix::Errno,
17487 >,
17488 fidl::encoding::DefaultFuchsiaResourceDialect,
17489 0x1ffecf4bd5b6432e,
17490 >(_buf?)?;
17491 Ok(_response.map(|x| x.addr))
17492 }
17493 self.client.send_query_and_decode::<
17494 fidl::encoding::EmptyPayload,
17495 BaseNetworkSocketGetPeerNameResult,
17496 >(
17497 (),
17498 0x1ffecf4bd5b6432e,
17499 fidl::encoding::DynamicFlags::empty(),
17500 _decode,
17501 )
17502 }
17503
17504 type ShutdownResponseFut = fidl::client::QueryResponseFut<
17505 BaseNetworkSocketShutdownResult,
17506 fidl::encoding::DefaultFuchsiaResourceDialect,
17507 >;
17508 fn r#shutdown(&self, mut mode: ShutdownMode) -> Self::ShutdownResponseFut {
17509 fn _decode(
17510 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17511 ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
17512 let _response = fidl::client::decode_transaction_body::<
17513 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17514 fidl::encoding::DefaultFuchsiaResourceDialect,
17515 0x247f38b6db68c336,
17516 >(_buf?)?;
17517 Ok(_response.map(|x| x))
17518 }
17519 self.client.send_query_and_decode::<
17520 BaseNetworkSocketShutdownRequest,
17521 BaseNetworkSocketShutdownResult,
17522 >(
17523 (mode,),
17524 0x247f38b6db68c336,
17525 fidl::encoding::DynamicFlags::empty(),
17526 _decode,
17527 )
17528 }
17529
17530 type SetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
17531 BaseNetworkSocketSetIpTypeOfServiceResult,
17532 fidl::encoding::DefaultFuchsiaResourceDialect,
17533 >;
17534 fn r#set_ip_type_of_service(&self, mut value: u8) -> Self::SetIpTypeOfServiceResponseFut {
17535 fn _decode(
17536 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17537 ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
17538 let _response = fidl::client::decode_transaction_body::<
17539 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17540 fidl::encoding::DefaultFuchsiaResourceDialect,
17541 0x995c600475b6d46,
17542 >(_buf?)?;
17543 Ok(_response.map(|x| x))
17544 }
17545 self.client.send_query_and_decode::<
17546 BaseNetworkSocketSetIpTypeOfServiceRequest,
17547 BaseNetworkSocketSetIpTypeOfServiceResult,
17548 >(
17549 (value,),
17550 0x995c600475b6d46,
17551 fidl::encoding::DynamicFlags::empty(),
17552 _decode,
17553 )
17554 }
17555
17556 type GetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
17557 BaseNetworkSocketGetIpTypeOfServiceResult,
17558 fidl::encoding::DefaultFuchsiaResourceDialect,
17559 >;
17560 fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut {
17561 fn _decode(
17562 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17563 ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
17564 let _response = fidl::client::decode_transaction_body::<
17565 fidl::encoding::ResultType<
17566 BaseNetworkSocketGetIpTypeOfServiceResponse,
17567 fidl_fuchsia_posix::Errno,
17568 >,
17569 fidl::encoding::DefaultFuchsiaResourceDialect,
17570 0x3814a04259f75fcb,
17571 >(_buf?)?;
17572 Ok(_response.map(|x| x.value))
17573 }
17574 self.client.send_query_and_decode::<
17575 fidl::encoding::EmptyPayload,
17576 BaseNetworkSocketGetIpTypeOfServiceResult,
17577 >(
17578 (),
17579 0x3814a04259f75fcb,
17580 fidl::encoding::DynamicFlags::empty(),
17581 _decode,
17582 )
17583 }
17584
17585 type SetIpTtlResponseFut = fidl::client::QueryResponseFut<
17586 BaseNetworkSocketSetIpTtlResult,
17587 fidl::encoding::DefaultFuchsiaResourceDialect,
17588 >;
17589 fn r#set_ip_ttl(&self, mut value: &OptionalUint8) -> Self::SetIpTtlResponseFut {
17590 fn _decode(
17591 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17592 ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
17593 let _response = fidl::client::decode_transaction_body::<
17594 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17595 fidl::encoding::DefaultFuchsiaResourceDialect,
17596 0x29e2424b433ae1ef,
17597 >(_buf?)?;
17598 Ok(_response.map(|x| x))
17599 }
17600 self.client.send_query_and_decode::<
17601 BaseNetworkSocketSetIpTtlRequest,
17602 BaseNetworkSocketSetIpTtlResult,
17603 >(
17604 (value,),
17605 0x29e2424b433ae1ef,
17606 fidl::encoding::DynamicFlags::empty(),
17607 _decode,
17608 )
17609 }
17610
17611 type GetIpTtlResponseFut = fidl::client::QueryResponseFut<
17612 BaseNetworkSocketGetIpTtlResult,
17613 fidl::encoding::DefaultFuchsiaResourceDialect,
17614 >;
17615 fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut {
17616 fn _decode(
17617 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17618 ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
17619 let _response = fidl::client::decode_transaction_body::<
17620 fidl::encoding::ResultType<
17621 BaseNetworkSocketGetIpTtlResponse,
17622 fidl_fuchsia_posix::Errno,
17623 >,
17624 fidl::encoding::DefaultFuchsiaResourceDialect,
17625 0x47e47fa1f24da471,
17626 >(_buf?)?;
17627 Ok(_response.map(|x| x.value))
17628 }
17629 self.client
17630 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseNetworkSocketGetIpTtlResult>(
17631 (),
17632 0x47e47fa1f24da471,
17633 fidl::encoding::DynamicFlags::empty(),
17634 _decode,
17635 )
17636 }
17637
17638 type SetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
17639 BaseNetworkSocketSetIpPacketInfoResult,
17640 fidl::encoding::DefaultFuchsiaResourceDialect,
17641 >;
17642 fn r#set_ip_packet_info(&self, mut value: bool) -> Self::SetIpPacketInfoResponseFut {
17643 fn _decode(
17644 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17645 ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
17646 let _response = fidl::client::decode_transaction_body::<
17647 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17648 fidl::encoding::DefaultFuchsiaResourceDialect,
17649 0x392d16bee20c0e16,
17650 >(_buf?)?;
17651 Ok(_response.map(|x| x))
17652 }
17653 self.client.send_query_and_decode::<
17654 BaseNetworkSocketSetIpPacketInfoRequest,
17655 BaseNetworkSocketSetIpPacketInfoResult,
17656 >(
17657 (value,),
17658 0x392d16bee20c0e16,
17659 fidl::encoding::DynamicFlags::empty(),
17660 _decode,
17661 )
17662 }
17663
17664 type GetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
17665 BaseNetworkSocketGetIpPacketInfoResult,
17666 fidl::encoding::DefaultFuchsiaResourceDialect,
17667 >;
17668 fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut {
17669 fn _decode(
17670 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17671 ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
17672 let _response = fidl::client::decode_transaction_body::<
17673 fidl::encoding::ResultType<
17674 BaseNetworkSocketGetIpPacketInfoResponse,
17675 fidl_fuchsia_posix::Errno,
17676 >,
17677 fidl::encoding::DefaultFuchsiaResourceDialect,
17678 0x54b505f242280740,
17679 >(_buf?)?;
17680 Ok(_response.map(|x| x.value))
17681 }
17682 self.client.send_query_and_decode::<
17683 fidl::encoding::EmptyPayload,
17684 BaseNetworkSocketGetIpPacketInfoResult,
17685 >(
17686 (),
17687 0x54b505f242280740,
17688 fidl::encoding::DynamicFlags::empty(),
17689 _decode,
17690 )
17691 }
17692
17693 type SetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
17694 BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
17695 fidl::encoding::DefaultFuchsiaResourceDialect,
17696 >;
17697 fn r#set_ip_receive_type_of_service(
17698 &self,
17699 mut value: bool,
17700 ) -> Self::SetIpReceiveTypeOfServiceResponseFut {
17701 fn _decode(
17702 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17703 ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
17704 let _response = fidl::client::decode_transaction_body::<
17705 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17706 fidl::encoding::DefaultFuchsiaResourceDialect,
17707 0x6c4f6714995f84ef,
17708 >(_buf?)?;
17709 Ok(_response.map(|x| x))
17710 }
17711 self.client.send_query_and_decode::<
17712 BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
17713 BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
17714 >(
17715 (value,),
17716 0x6c4f6714995f84ef,
17717 fidl::encoding::DynamicFlags::empty(),
17718 _decode,
17719 )
17720 }
17721
17722 type GetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
17723 BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
17724 fidl::encoding::DefaultFuchsiaResourceDialect,
17725 >;
17726 fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut {
17727 fn _decode(
17728 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17729 ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
17730 let _response = fidl::client::decode_transaction_body::<
17731 fidl::encoding::ResultType<
17732 BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
17733 fidl_fuchsia_posix::Errno,
17734 >,
17735 fidl::encoding::DefaultFuchsiaResourceDialect,
17736 0x4158ba7dc2795960,
17737 >(_buf?)?;
17738 Ok(_response.map(|x| x.value))
17739 }
17740 self.client.send_query_and_decode::<
17741 fidl::encoding::EmptyPayload,
17742 BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
17743 >(
17744 (),
17745 0x4158ba7dc2795960,
17746 fidl::encoding::DynamicFlags::empty(),
17747 _decode,
17748 )
17749 }
17750
17751 type SetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
17752 BaseNetworkSocketSetIpReceiveTtlResult,
17753 fidl::encoding::DefaultFuchsiaResourceDialect,
17754 >;
17755 fn r#set_ip_receive_ttl(&self, mut value: bool) -> Self::SetIpReceiveTtlResponseFut {
17756 fn _decode(
17757 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17758 ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
17759 let _response = fidl::client::decode_transaction_body::<
17760 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17761 fidl::encoding::DefaultFuchsiaResourceDialect,
17762 0x46f15be0ce0ab82b,
17763 >(_buf?)?;
17764 Ok(_response.map(|x| x))
17765 }
17766 self.client.send_query_and_decode::<
17767 BaseNetworkSocketSetIpReceiveTtlRequest,
17768 BaseNetworkSocketSetIpReceiveTtlResult,
17769 >(
17770 (value,),
17771 0x46f15be0ce0ab82b,
17772 fidl::encoding::DynamicFlags::empty(),
17773 _decode,
17774 )
17775 }
17776
17777 type GetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
17778 BaseNetworkSocketGetIpReceiveTtlResult,
17779 fidl::encoding::DefaultFuchsiaResourceDialect,
17780 >;
17781 fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut {
17782 fn _decode(
17783 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17784 ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
17785 let _response = fidl::client::decode_transaction_body::<
17786 fidl::encoding::ResultType<
17787 BaseNetworkSocketGetIpReceiveTtlResponse,
17788 fidl_fuchsia_posix::Errno,
17789 >,
17790 fidl::encoding::DefaultFuchsiaResourceDialect,
17791 0x678ddd5a5dfa2eb5,
17792 >(_buf?)?;
17793 Ok(_response.map(|x| x.value))
17794 }
17795 self.client.send_query_and_decode::<
17796 fidl::encoding::EmptyPayload,
17797 BaseNetworkSocketGetIpReceiveTtlResult,
17798 >(
17799 (),
17800 0x678ddd5a5dfa2eb5,
17801 fidl::encoding::DynamicFlags::empty(),
17802 _decode,
17803 )
17804 }
17805
17806 type SetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
17807 BaseNetworkSocketSetIpMulticastInterfaceResult,
17808 fidl::encoding::DefaultFuchsiaResourceDialect,
17809 >;
17810 fn r#set_ip_multicast_interface(
17811 &self,
17812 mut iface: u64,
17813 mut address: &fidl_fuchsia_net::Ipv4Address,
17814 ) -> Self::SetIpMulticastInterfaceResponseFut {
17815 fn _decode(
17816 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17817 ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
17818 let _response = fidl::client::decode_transaction_body::<
17819 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17820 fidl::encoding::DefaultFuchsiaResourceDialect,
17821 0x752fbfa9b12befe,
17822 >(_buf?)?;
17823 Ok(_response.map(|x| x))
17824 }
17825 self.client.send_query_and_decode::<
17826 BaseNetworkSocketSetIpMulticastInterfaceRequest,
17827 BaseNetworkSocketSetIpMulticastInterfaceResult,
17828 >(
17829 (iface, address,),
17830 0x752fbfa9b12befe,
17831 fidl::encoding::DynamicFlags::empty(),
17832 _decode,
17833 )
17834 }
17835
17836 type GetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
17837 BaseNetworkSocketGetIpMulticastInterfaceResult,
17838 fidl::encoding::DefaultFuchsiaResourceDialect,
17839 >;
17840 fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut {
17841 fn _decode(
17842 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17843 ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
17844 let _response = fidl::client::decode_transaction_body::<
17845 fidl::encoding::ResultType<
17846 BaseNetworkSocketGetIpMulticastInterfaceResponse,
17847 fidl_fuchsia_posix::Errno,
17848 >,
17849 fidl::encoding::DefaultFuchsiaResourceDialect,
17850 0x320bd14c4df046c4,
17851 >(_buf?)?;
17852 Ok(_response.map(|x| x.value))
17853 }
17854 self.client.send_query_and_decode::<
17855 fidl::encoding::EmptyPayload,
17856 BaseNetworkSocketGetIpMulticastInterfaceResult,
17857 >(
17858 (),
17859 0x320bd14c4df046c4,
17860 fidl::encoding::DynamicFlags::empty(),
17861 _decode,
17862 )
17863 }
17864
17865 type SetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
17866 BaseNetworkSocketSetIpMulticastTtlResult,
17867 fidl::encoding::DefaultFuchsiaResourceDialect,
17868 >;
17869 fn r#set_ip_multicast_ttl(
17870 &self,
17871 mut value: &OptionalUint8,
17872 ) -> Self::SetIpMulticastTtlResponseFut {
17873 fn _decode(
17874 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17875 ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
17876 let _response = fidl::client::decode_transaction_body::<
17877 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17878 fidl::encoding::DefaultFuchsiaResourceDialect,
17879 0x63134d53772916a1,
17880 >(_buf?)?;
17881 Ok(_response.map(|x| x))
17882 }
17883 self.client.send_query_and_decode::<
17884 BaseNetworkSocketSetIpMulticastTtlRequest,
17885 BaseNetworkSocketSetIpMulticastTtlResult,
17886 >(
17887 (value,),
17888 0x63134d53772916a1,
17889 fidl::encoding::DynamicFlags::empty(),
17890 _decode,
17891 )
17892 }
17893
17894 type GetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
17895 BaseNetworkSocketGetIpMulticastTtlResult,
17896 fidl::encoding::DefaultFuchsiaResourceDialect,
17897 >;
17898 fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut {
17899 fn _decode(
17900 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17901 ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
17902 let _response = fidl::client::decode_transaction_body::<
17903 fidl::encoding::ResultType<
17904 BaseNetworkSocketGetIpMulticastTtlResponse,
17905 fidl_fuchsia_posix::Errno,
17906 >,
17907 fidl::encoding::DefaultFuchsiaResourceDialect,
17908 0x4665cd378f39e1a,
17909 >(_buf?)?;
17910 Ok(_response.map(|x| x.value))
17911 }
17912 self.client.send_query_and_decode::<
17913 fidl::encoding::EmptyPayload,
17914 BaseNetworkSocketGetIpMulticastTtlResult,
17915 >(
17916 (),
17917 0x4665cd378f39e1a,
17918 fidl::encoding::DynamicFlags::empty(),
17919 _decode,
17920 )
17921 }
17922
17923 type SetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
17924 BaseNetworkSocketSetIpMulticastLoopbackResult,
17925 fidl::encoding::DefaultFuchsiaResourceDialect,
17926 >;
17927 fn r#set_ip_multicast_loopback(
17928 &self,
17929 mut value: bool,
17930 ) -> Self::SetIpMulticastLoopbackResponseFut {
17931 fn _decode(
17932 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17933 ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
17934 let _response = fidl::client::decode_transaction_body::<
17935 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17936 fidl::encoding::DefaultFuchsiaResourceDialect,
17937 0x20c55c11f00943ea,
17938 >(_buf?)?;
17939 Ok(_response.map(|x| x))
17940 }
17941 self.client.send_query_and_decode::<
17942 BaseNetworkSocketSetIpMulticastLoopbackRequest,
17943 BaseNetworkSocketSetIpMulticastLoopbackResult,
17944 >(
17945 (value,),
17946 0x20c55c11f00943ea,
17947 fidl::encoding::DynamicFlags::empty(),
17948 _decode,
17949 )
17950 }
17951
17952 type GetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
17953 BaseNetworkSocketGetIpMulticastLoopbackResult,
17954 fidl::encoding::DefaultFuchsiaResourceDialect,
17955 >;
17956 fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut {
17957 fn _decode(
17958 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17959 ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
17960 let _response = fidl::client::decode_transaction_body::<
17961 fidl::encoding::ResultType<
17962 BaseNetworkSocketGetIpMulticastLoopbackResponse,
17963 fidl_fuchsia_posix::Errno,
17964 >,
17965 fidl::encoding::DefaultFuchsiaResourceDialect,
17966 0x3b6b26ff558298f2,
17967 >(_buf?)?;
17968 Ok(_response.map(|x| x.value))
17969 }
17970 self.client.send_query_and_decode::<
17971 fidl::encoding::EmptyPayload,
17972 BaseNetworkSocketGetIpMulticastLoopbackResult,
17973 >(
17974 (),
17975 0x3b6b26ff558298f2,
17976 fidl::encoding::DynamicFlags::empty(),
17977 _decode,
17978 )
17979 }
17980
17981 type AddIpMembershipResponseFut = fidl::client::QueryResponseFut<
17982 BaseNetworkSocketAddIpMembershipResult,
17983 fidl::encoding::DefaultFuchsiaResourceDialect,
17984 >;
17985 fn r#add_ip_membership(
17986 &self,
17987 mut membership: &IpMulticastMembership,
17988 ) -> Self::AddIpMembershipResponseFut {
17989 fn _decode(
17990 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17991 ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
17992 let _response = fidl::client::decode_transaction_body::<
17993 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17994 fidl::encoding::DefaultFuchsiaResourceDialect,
17995 0x76bc7df115a3b4d0,
17996 >(_buf?)?;
17997 Ok(_response.map(|x| x))
17998 }
17999 self.client.send_query_and_decode::<
18000 BaseNetworkSocketAddIpMembershipRequest,
18001 BaseNetworkSocketAddIpMembershipResult,
18002 >(
18003 (membership,),
18004 0x76bc7df115a3b4d0,
18005 fidl::encoding::DynamicFlags::empty(),
18006 _decode,
18007 )
18008 }
18009
18010 type DropIpMembershipResponseFut = fidl::client::QueryResponseFut<
18011 BaseNetworkSocketDropIpMembershipResult,
18012 fidl::encoding::DefaultFuchsiaResourceDialect,
18013 >;
18014 fn r#drop_ip_membership(
18015 &self,
18016 mut membership: &IpMulticastMembership,
18017 ) -> Self::DropIpMembershipResponseFut {
18018 fn _decode(
18019 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18020 ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
18021 let _response = fidl::client::decode_transaction_body::<
18022 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18023 fidl::encoding::DefaultFuchsiaResourceDialect,
18024 0x2888f3099188d03,
18025 >(_buf?)?;
18026 Ok(_response.map(|x| x))
18027 }
18028 self.client.send_query_and_decode::<
18029 BaseNetworkSocketDropIpMembershipRequest,
18030 BaseNetworkSocketDropIpMembershipResult,
18031 >(
18032 (membership,),
18033 0x2888f3099188d03,
18034 fidl::encoding::DynamicFlags::empty(),
18035 _decode,
18036 )
18037 }
18038
18039 type SetIpTransparentResponseFut = fidl::client::QueryResponseFut<
18040 BaseNetworkSocketSetIpTransparentResult,
18041 fidl::encoding::DefaultFuchsiaResourceDialect,
18042 >;
18043 fn r#set_ip_transparent(&self, mut value: bool) -> Self::SetIpTransparentResponseFut {
18044 fn _decode(
18045 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18046 ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
18047 let _response = fidl::client::decode_transaction_body::<
18048 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18049 fidl::encoding::DefaultFuchsiaResourceDialect,
18050 0x1ae532b0c066e3a0,
18051 >(_buf?)?;
18052 Ok(_response.map(|x| x))
18053 }
18054 self.client.send_query_and_decode::<
18055 BaseNetworkSocketSetIpTransparentRequest,
18056 BaseNetworkSocketSetIpTransparentResult,
18057 >(
18058 (value,),
18059 0x1ae532b0c066e3a0,
18060 fidl::encoding::DynamicFlags::empty(),
18061 _decode,
18062 )
18063 }
18064
18065 type GetIpTransparentResponseFut = fidl::client::QueryResponseFut<
18066 BaseNetworkSocketGetIpTransparentResult,
18067 fidl::encoding::DefaultFuchsiaResourceDialect,
18068 >;
18069 fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut {
18070 fn _decode(
18071 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18072 ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
18073 let _response = fidl::client::decode_transaction_body::<
18074 fidl::encoding::ResultType<
18075 BaseNetworkSocketGetIpTransparentResponse,
18076 fidl_fuchsia_posix::Errno,
18077 >,
18078 fidl::encoding::DefaultFuchsiaResourceDialect,
18079 0x51d43695962ebfb5,
18080 >(_buf?)?;
18081 Ok(_response.map(|x| x.value))
18082 }
18083 self.client.send_query_and_decode::<
18084 fidl::encoding::EmptyPayload,
18085 BaseNetworkSocketGetIpTransparentResult,
18086 >(
18087 (),
18088 0x51d43695962ebfb5,
18089 fidl::encoding::DynamicFlags::empty(),
18090 _decode,
18091 )
18092 }
18093
18094 type SetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
18095 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
18096 fidl::encoding::DefaultFuchsiaResourceDialect,
18097 >;
18098 fn r#set_ip_receive_original_destination_address(
18099 &self,
18100 mut value: bool,
18101 ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut {
18102 fn _decode(
18103 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18104 ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>
18105 {
18106 let _response = fidl::client::decode_transaction_body::<
18107 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18108 fidl::encoding::DefaultFuchsiaResourceDialect,
18109 0x4722b4ce52f7840,
18110 >(_buf?)?;
18111 Ok(_response.map(|x| x))
18112 }
18113 self.client.send_query_and_decode::<
18114 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
18115 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
18116 >(
18117 (value,),
18118 0x4722b4ce52f7840,
18119 fidl::encoding::DynamicFlags::empty(),
18120 _decode,
18121 )
18122 }
18123
18124 type GetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
18125 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
18126 fidl::encoding::DefaultFuchsiaResourceDialect,
18127 >;
18128 fn r#get_ip_receive_original_destination_address(
18129 &self,
18130 ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut {
18131 fn _decode(
18132 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18133 ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>
18134 {
18135 let _response = fidl::client::decode_transaction_body::<
18136 fidl::encoding::ResultType<
18137 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
18138 fidl_fuchsia_posix::Errno,
18139 >,
18140 fidl::encoding::DefaultFuchsiaResourceDialect,
18141 0x2a0e7dc5d6bfdfe9,
18142 >(_buf?)?;
18143 Ok(_response.map(|x| x.value))
18144 }
18145 self.client.send_query_and_decode::<
18146 fidl::encoding::EmptyPayload,
18147 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
18148 >(
18149 (),
18150 0x2a0e7dc5d6bfdfe9,
18151 fidl::encoding::DynamicFlags::empty(),
18152 _decode,
18153 )
18154 }
18155
18156 type AddIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
18157 BaseNetworkSocketAddIpv6MembershipResult,
18158 fidl::encoding::DefaultFuchsiaResourceDialect,
18159 >;
18160 fn r#add_ipv6_membership(
18161 &self,
18162 mut membership: &Ipv6MulticastMembership,
18163 ) -> Self::AddIpv6MembershipResponseFut {
18164 fn _decode(
18165 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18166 ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
18167 let _response = fidl::client::decode_transaction_body::<
18168 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18169 fidl::encoding::DefaultFuchsiaResourceDialect,
18170 0x7c94727acb4ea4b3,
18171 >(_buf?)?;
18172 Ok(_response.map(|x| x))
18173 }
18174 self.client.send_query_and_decode::<
18175 BaseNetworkSocketAddIpv6MembershipRequest,
18176 BaseNetworkSocketAddIpv6MembershipResult,
18177 >(
18178 (membership,),
18179 0x7c94727acb4ea4b3,
18180 fidl::encoding::DynamicFlags::empty(),
18181 _decode,
18182 )
18183 }
18184
18185 type DropIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
18186 BaseNetworkSocketDropIpv6MembershipResult,
18187 fidl::encoding::DefaultFuchsiaResourceDialect,
18188 >;
18189 fn r#drop_ipv6_membership(
18190 &self,
18191 mut membership: &Ipv6MulticastMembership,
18192 ) -> Self::DropIpv6MembershipResponseFut {
18193 fn _decode(
18194 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18195 ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
18196 let _response = fidl::client::decode_transaction_body::<
18197 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18198 fidl::encoding::DefaultFuchsiaResourceDialect,
18199 0x42104c70ccaba304,
18200 >(_buf?)?;
18201 Ok(_response.map(|x| x))
18202 }
18203 self.client.send_query_and_decode::<
18204 BaseNetworkSocketDropIpv6MembershipRequest,
18205 BaseNetworkSocketDropIpv6MembershipResult,
18206 >(
18207 (membership,),
18208 0x42104c70ccaba304,
18209 fidl::encoding::DynamicFlags::empty(),
18210 _decode,
18211 )
18212 }
18213
18214 type SetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
18215 BaseNetworkSocketSetIpv6MulticastInterfaceResult,
18216 fidl::encoding::DefaultFuchsiaResourceDialect,
18217 >;
18218 fn r#set_ipv6_multicast_interface(
18219 &self,
18220 mut value: u64,
18221 ) -> Self::SetIpv6MulticastInterfaceResponseFut {
18222 fn _decode(
18223 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18224 ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
18225 let _response = fidl::client::decode_transaction_body::<
18226 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18227 fidl::encoding::DefaultFuchsiaResourceDialect,
18228 0x135f76db3774ab3b,
18229 >(_buf?)?;
18230 Ok(_response.map(|x| x))
18231 }
18232 self.client.send_query_and_decode::<
18233 BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
18234 BaseNetworkSocketSetIpv6MulticastInterfaceResult,
18235 >(
18236 (value,),
18237 0x135f76db3774ab3b,
18238 fidl::encoding::DynamicFlags::empty(),
18239 _decode,
18240 )
18241 }
18242
18243 type GetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
18244 BaseNetworkSocketGetIpv6MulticastInterfaceResult,
18245 fidl::encoding::DefaultFuchsiaResourceDialect,
18246 >;
18247 fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut {
18248 fn _decode(
18249 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18250 ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
18251 let _response = fidl::client::decode_transaction_body::<
18252 fidl::encoding::ResultType<
18253 BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
18254 fidl_fuchsia_posix::Errno,
18255 >,
18256 fidl::encoding::DefaultFuchsiaResourceDialect,
18257 0x1f26fcdd348f1882,
18258 >(_buf?)?;
18259 Ok(_response.map(|x| x.value))
18260 }
18261 self.client.send_query_and_decode::<
18262 fidl::encoding::EmptyPayload,
18263 BaseNetworkSocketGetIpv6MulticastInterfaceResult,
18264 >(
18265 (),
18266 0x1f26fcdd348f1882,
18267 fidl::encoding::DynamicFlags::empty(),
18268 _decode,
18269 )
18270 }
18271
18272 type SetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
18273 BaseNetworkSocketSetIpv6UnicastHopsResult,
18274 fidl::encoding::DefaultFuchsiaResourceDialect,
18275 >;
18276 fn r#set_ipv6_unicast_hops(
18277 &self,
18278 mut value: &OptionalUint8,
18279 ) -> Self::SetIpv6UnicastHopsResponseFut {
18280 fn _decode(
18281 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18282 ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
18283 let _response = fidl::client::decode_transaction_body::<
18284 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18285 fidl::encoding::DefaultFuchsiaResourceDialect,
18286 0x157d51e98f462859,
18287 >(_buf?)?;
18288 Ok(_response.map(|x| x))
18289 }
18290 self.client.send_query_and_decode::<
18291 BaseNetworkSocketSetIpv6UnicastHopsRequest,
18292 BaseNetworkSocketSetIpv6UnicastHopsResult,
18293 >(
18294 (value,),
18295 0x157d51e98f462859,
18296 fidl::encoding::DynamicFlags::empty(),
18297 _decode,
18298 )
18299 }
18300
18301 type GetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
18302 BaseNetworkSocketGetIpv6UnicastHopsResult,
18303 fidl::encoding::DefaultFuchsiaResourceDialect,
18304 >;
18305 fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut {
18306 fn _decode(
18307 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18308 ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
18309 let _response = fidl::client::decode_transaction_body::<
18310 fidl::encoding::ResultType<
18311 BaseNetworkSocketGetIpv6UnicastHopsResponse,
18312 fidl_fuchsia_posix::Errno,
18313 >,
18314 fidl::encoding::DefaultFuchsiaResourceDialect,
18315 0x21f4641cad8bd8d2,
18316 >(_buf?)?;
18317 Ok(_response.map(|x| x.value))
18318 }
18319 self.client.send_query_and_decode::<
18320 fidl::encoding::EmptyPayload,
18321 BaseNetworkSocketGetIpv6UnicastHopsResult,
18322 >(
18323 (),
18324 0x21f4641cad8bd8d2,
18325 fidl::encoding::DynamicFlags::empty(),
18326 _decode,
18327 )
18328 }
18329
18330 type SetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
18331 BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
18332 fidl::encoding::DefaultFuchsiaResourceDialect,
18333 >;
18334 fn r#set_ipv6_receive_hop_limit(
18335 &self,
18336 mut value: bool,
18337 ) -> Self::SetIpv6ReceiveHopLimitResponseFut {
18338 fn _decode(
18339 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18340 ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
18341 let _response = fidl::client::decode_transaction_body::<
18342 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18343 fidl::encoding::DefaultFuchsiaResourceDialect,
18344 0x5c24808ed2e84a1e,
18345 >(_buf?)?;
18346 Ok(_response.map(|x| x))
18347 }
18348 self.client.send_query_and_decode::<
18349 BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
18350 BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
18351 >(
18352 (value,),
18353 0x5c24808ed2e84a1e,
18354 fidl::encoding::DynamicFlags::empty(),
18355 _decode,
18356 )
18357 }
18358
18359 type GetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
18360 BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
18361 fidl::encoding::DefaultFuchsiaResourceDialect,
18362 >;
18363 fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut {
18364 fn _decode(
18365 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18366 ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
18367 let _response = fidl::client::decode_transaction_body::<
18368 fidl::encoding::ResultType<
18369 BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
18370 fidl_fuchsia_posix::Errno,
18371 >,
18372 fidl::encoding::DefaultFuchsiaResourceDialect,
18373 0x341e06689885b4c0,
18374 >(_buf?)?;
18375 Ok(_response.map(|x| x.value))
18376 }
18377 self.client.send_query_and_decode::<
18378 fidl::encoding::EmptyPayload,
18379 BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
18380 >(
18381 (),
18382 0x341e06689885b4c0,
18383 fidl::encoding::DynamicFlags::empty(),
18384 _decode,
18385 )
18386 }
18387
18388 type SetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
18389 BaseNetworkSocketSetIpv6MulticastHopsResult,
18390 fidl::encoding::DefaultFuchsiaResourceDialect,
18391 >;
18392 fn r#set_ipv6_multicast_hops(
18393 &self,
18394 mut value: &OptionalUint8,
18395 ) -> Self::SetIpv6MulticastHopsResponseFut {
18396 fn _decode(
18397 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18398 ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
18399 let _response = fidl::client::decode_transaction_body::<
18400 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18401 fidl::encoding::DefaultFuchsiaResourceDialect,
18402 0x25b9cd4d181f82c1,
18403 >(_buf?)?;
18404 Ok(_response.map(|x| x))
18405 }
18406 self.client.send_query_and_decode::<
18407 BaseNetworkSocketSetIpv6MulticastHopsRequest,
18408 BaseNetworkSocketSetIpv6MulticastHopsResult,
18409 >(
18410 (value,),
18411 0x25b9cd4d181f82c1,
18412 fidl::encoding::DynamicFlags::empty(),
18413 _decode,
18414 )
18415 }
18416
18417 type GetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
18418 BaseNetworkSocketGetIpv6MulticastHopsResult,
18419 fidl::encoding::DefaultFuchsiaResourceDialect,
18420 >;
18421 fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut {
18422 fn _decode(
18423 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18424 ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
18425 let _response = fidl::client::decode_transaction_body::<
18426 fidl::encoding::ResultType<
18427 BaseNetworkSocketGetIpv6MulticastHopsResponse,
18428 fidl_fuchsia_posix::Errno,
18429 >,
18430 fidl::encoding::DefaultFuchsiaResourceDialect,
18431 0x52916948a365012a,
18432 >(_buf?)?;
18433 Ok(_response.map(|x| x.value))
18434 }
18435 self.client.send_query_and_decode::<
18436 fidl::encoding::EmptyPayload,
18437 BaseNetworkSocketGetIpv6MulticastHopsResult,
18438 >(
18439 (),
18440 0x52916948a365012a,
18441 fidl::encoding::DynamicFlags::empty(),
18442 _decode,
18443 )
18444 }
18445
18446 type SetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
18447 BaseNetworkSocketSetIpv6MulticastLoopbackResult,
18448 fidl::encoding::DefaultFuchsiaResourceDialect,
18449 >;
18450 fn r#set_ipv6_multicast_loopback(
18451 &self,
18452 mut value: bool,
18453 ) -> Self::SetIpv6MulticastLoopbackResponseFut {
18454 fn _decode(
18455 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18456 ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
18457 let _response = fidl::client::decode_transaction_body::<
18458 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18459 fidl::encoding::DefaultFuchsiaResourceDialect,
18460 0x55701c409ff41b40,
18461 >(_buf?)?;
18462 Ok(_response.map(|x| x))
18463 }
18464 self.client.send_query_and_decode::<
18465 BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
18466 BaseNetworkSocketSetIpv6MulticastLoopbackResult,
18467 >(
18468 (value,),
18469 0x55701c409ff41b40,
18470 fidl::encoding::DynamicFlags::empty(),
18471 _decode,
18472 )
18473 }
18474
18475 type GetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
18476 BaseNetworkSocketGetIpv6MulticastLoopbackResult,
18477 fidl::encoding::DefaultFuchsiaResourceDialect,
18478 >;
18479 fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut {
18480 fn _decode(
18481 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18482 ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
18483 let _response = fidl::client::decode_transaction_body::<
18484 fidl::encoding::ResultType<
18485 BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
18486 fidl_fuchsia_posix::Errno,
18487 >,
18488 fidl::encoding::DefaultFuchsiaResourceDialect,
18489 0x4415b701fde319c3,
18490 >(_buf?)?;
18491 Ok(_response.map(|x| x.value))
18492 }
18493 self.client.send_query_and_decode::<
18494 fidl::encoding::EmptyPayload,
18495 BaseNetworkSocketGetIpv6MulticastLoopbackResult,
18496 >(
18497 (),
18498 0x4415b701fde319c3,
18499 fidl::encoding::DynamicFlags::empty(),
18500 _decode,
18501 )
18502 }
18503
18504 type SetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
18505 BaseNetworkSocketSetIpv6OnlyResult,
18506 fidl::encoding::DefaultFuchsiaResourceDialect,
18507 >;
18508 fn r#set_ipv6_only(&self, mut value: bool) -> Self::SetIpv6OnlyResponseFut {
18509 fn _decode(
18510 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18511 ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
18512 let _response = fidl::client::decode_transaction_body::<
18513 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18514 fidl::encoding::DefaultFuchsiaResourceDialect,
18515 0x4873f1364758cbba,
18516 >(_buf?)?;
18517 Ok(_response.map(|x| x))
18518 }
18519 self.client.send_query_and_decode::<
18520 BaseNetworkSocketSetIpv6OnlyRequest,
18521 BaseNetworkSocketSetIpv6OnlyResult,
18522 >(
18523 (value,),
18524 0x4873f1364758cbba,
18525 fidl::encoding::DynamicFlags::empty(),
18526 _decode,
18527 )
18528 }
18529
18530 type GetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
18531 BaseNetworkSocketGetIpv6OnlyResult,
18532 fidl::encoding::DefaultFuchsiaResourceDialect,
18533 >;
18534 fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut {
18535 fn _decode(
18536 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18537 ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
18538 let _response = fidl::client::decode_transaction_body::<
18539 fidl::encoding::ResultType<
18540 BaseNetworkSocketGetIpv6OnlyResponse,
18541 fidl_fuchsia_posix::Errno,
18542 >,
18543 fidl::encoding::DefaultFuchsiaResourceDialect,
18544 0x4aa3340a1a26b89c,
18545 >(_buf?)?;
18546 Ok(_response.map(|x| x.value))
18547 }
18548 self.client.send_query_and_decode::<
18549 fidl::encoding::EmptyPayload,
18550 BaseNetworkSocketGetIpv6OnlyResult,
18551 >(
18552 (),
18553 0x4aa3340a1a26b89c,
18554 fidl::encoding::DynamicFlags::empty(),
18555 _decode,
18556 )
18557 }
18558
18559 type SetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
18560 BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
18561 fidl::encoding::DefaultFuchsiaResourceDialect,
18562 >;
18563 fn r#set_ipv6_receive_traffic_class(
18564 &self,
18565 mut value: bool,
18566 ) -> Self::SetIpv6ReceiveTrafficClassResponseFut {
18567 fn _decode(
18568 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18569 ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
18570 let _response = fidl::client::decode_transaction_body::<
18571 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18572 fidl::encoding::DefaultFuchsiaResourceDialect,
18573 0x58f07c8788d099a0,
18574 >(_buf?)?;
18575 Ok(_response.map(|x| x))
18576 }
18577 self.client.send_query_and_decode::<
18578 BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
18579 BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
18580 >(
18581 (value,),
18582 0x58f07c8788d099a0,
18583 fidl::encoding::DynamicFlags::empty(),
18584 _decode,
18585 )
18586 }
18587
18588 type GetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
18589 BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
18590 fidl::encoding::DefaultFuchsiaResourceDialect,
18591 >;
18592 fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut {
18593 fn _decode(
18594 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18595 ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
18596 let _response = fidl::client::decode_transaction_body::<
18597 fidl::encoding::ResultType<
18598 BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
18599 fidl_fuchsia_posix::Errno,
18600 >,
18601 fidl::encoding::DefaultFuchsiaResourceDialect,
18602 0x2e334df1da553ffa,
18603 >(_buf?)?;
18604 Ok(_response.map(|x| x.value))
18605 }
18606 self.client.send_query_and_decode::<
18607 fidl::encoding::EmptyPayload,
18608 BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
18609 >(
18610 (),
18611 0x2e334df1da553ffa,
18612 fidl::encoding::DynamicFlags::empty(),
18613 _decode,
18614 )
18615 }
18616
18617 type SetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
18618 BaseNetworkSocketSetIpv6TrafficClassResult,
18619 fidl::encoding::DefaultFuchsiaResourceDialect,
18620 >;
18621 fn r#set_ipv6_traffic_class(
18622 &self,
18623 mut value: &OptionalUint8,
18624 ) -> Self::SetIpv6TrafficClassResponseFut {
18625 fn _decode(
18626 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18627 ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
18628 let _response = fidl::client::decode_transaction_body::<
18629 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18630 fidl::encoding::DefaultFuchsiaResourceDialect,
18631 0x6af077800c5a0b4f,
18632 >(_buf?)?;
18633 Ok(_response.map(|x| x))
18634 }
18635 self.client.send_query_and_decode::<
18636 BaseNetworkSocketSetIpv6TrafficClassRequest,
18637 BaseNetworkSocketSetIpv6TrafficClassResult,
18638 >(
18639 (value,),
18640 0x6af077800c5a0b4f,
18641 fidl::encoding::DynamicFlags::empty(),
18642 _decode,
18643 )
18644 }
18645
18646 type GetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
18647 BaseNetworkSocketGetIpv6TrafficClassResult,
18648 fidl::encoding::DefaultFuchsiaResourceDialect,
18649 >;
18650 fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut {
18651 fn _decode(
18652 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18653 ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
18654 let _response = fidl::client::decode_transaction_body::<
18655 fidl::encoding::ResultType<
18656 BaseNetworkSocketGetIpv6TrafficClassResponse,
18657 fidl_fuchsia_posix::Errno,
18658 >,
18659 fidl::encoding::DefaultFuchsiaResourceDialect,
18660 0x6baf6eed8fc2f04,
18661 >(_buf?)?;
18662 Ok(_response.map(|x| x.value))
18663 }
18664 self.client.send_query_and_decode::<
18665 fidl::encoding::EmptyPayload,
18666 BaseNetworkSocketGetIpv6TrafficClassResult,
18667 >(
18668 (),
18669 0x6baf6eed8fc2f04,
18670 fidl::encoding::DynamicFlags::empty(),
18671 _decode,
18672 )
18673 }
18674
18675 type SetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
18676 BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
18677 fidl::encoding::DefaultFuchsiaResourceDialect,
18678 >;
18679 fn r#set_ipv6_receive_packet_info(
18680 &self,
18681 mut value: bool,
18682 ) -> Self::SetIpv6ReceivePacketInfoResponseFut {
18683 fn _decode(
18684 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18685 ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
18686 let _response = fidl::client::decode_transaction_body::<
18687 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18688 fidl::encoding::DefaultFuchsiaResourceDialect,
18689 0x19259775b1a92768,
18690 >(_buf?)?;
18691 Ok(_response.map(|x| x))
18692 }
18693 self.client.send_query_and_decode::<
18694 BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
18695 BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
18696 >(
18697 (value,),
18698 0x19259775b1a92768,
18699 fidl::encoding::DynamicFlags::empty(),
18700 _decode,
18701 )
18702 }
18703
18704 type GetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
18705 BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
18706 fidl::encoding::DefaultFuchsiaResourceDialect,
18707 >;
18708 fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut {
18709 fn _decode(
18710 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18711 ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
18712 let _response = fidl::client::decode_transaction_body::<
18713 fidl::encoding::ResultType<
18714 BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
18715 fidl_fuchsia_posix::Errno,
18716 >,
18717 fidl::encoding::DefaultFuchsiaResourceDialect,
18718 0x7acd4a2775baec75,
18719 >(_buf?)?;
18720 Ok(_response.map(|x| x.value))
18721 }
18722 self.client.send_query_and_decode::<
18723 fidl::encoding::EmptyPayload,
18724 BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
18725 >(
18726 (),
18727 0x7acd4a2775baec75,
18728 fidl::encoding::DynamicFlags::empty(),
18729 _decode,
18730 )
18731 }
18732
18733 type GetOriginalDestinationResponseFut = fidl::client::QueryResponseFut<
18734 BaseNetworkSocketGetOriginalDestinationResult,
18735 fidl::encoding::DefaultFuchsiaResourceDialect,
18736 >;
18737 fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut {
18738 fn _decode(
18739 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18740 ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
18741 let _response = fidl::client::decode_transaction_body::<
18742 fidl::encoding::ResultType<
18743 BaseNetworkSocketGetOriginalDestinationResponse,
18744 fidl_fuchsia_posix::Errno,
18745 >,
18746 fidl::encoding::DefaultFuchsiaResourceDialect,
18747 0x38bf28f0dafdbac0,
18748 >(_buf?)?;
18749 Ok(_response.map(|x| x.value))
18750 }
18751 self.client.send_query_and_decode::<
18752 fidl::encoding::EmptyPayload,
18753 BaseNetworkSocketGetOriginalDestinationResult,
18754 >(
18755 (),
18756 0x38bf28f0dafdbac0,
18757 fidl::encoding::DynamicFlags::empty(),
18758 _decode,
18759 )
18760 }
18761}
18762
18763pub struct BaseNetworkSocketEventStream {
18764 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
18765}
18766
18767impl std::marker::Unpin for BaseNetworkSocketEventStream {}
18768
18769impl futures::stream::FusedStream for BaseNetworkSocketEventStream {
18770 fn is_terminated(&self) -> bool {
18771 self.event_receiver.is_terminated()
18772 }
18773}
18774
18775impl futures::Stream for BaseNetworkSocketEventStream {
18776 type Item = Result<BaseNetworkSocketEvent, fidl::Error>;
18777
18778 fn poll_next(
18779 mut self: std::pin::Pin<&mut Self>,
18780 cx: &mut std::task::Context<'_>,
18781 ) -> std::task::Poll<Option<Self::Item>> {
18782 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
18783 &mut self.event_receiver,
18784 cx
18785 )?) {
18786 Some(buf) => std::task::Poll::Ready(Some(BaseNetworkSocketEvent::decode(buf))),
18787 None => std::task::Poll::Ready(None),
18788 }
18789 }
18790}
18791
18792#[derive(Debug)]
18793pub enum BaseNetworkSocketEvent {}
18794
18795impl BaseNetworkSocketEvent {
18796 fn decode(
18798 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
18799 ) -> Result<BaseNetworkSocketEvent, fidl::Error> {
18800 let (bytes, _handles) = buf.split_mut();
18801 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
18802 debug_assert_eq!(tx_header.tx_id, 0);
18803 match tx_header.ordinal {
18804 _ => Err(fidl::Error::UnknownOrdinal {
18805 ordinal: tx_header.ordinal,
18806 protocol_name:
18807 <BaseNetworkSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
18808 }),
18809 }
18810 }
18811}
18812
18813pub struct BaseNetworkSocketRequestStream {
18815 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
18816 is_terminated: bool,
18817}
18818
18819impl std::marker::Unpin for BaseNetworkSocketRequestStream {}
18820
18821impl futures::stream::FusedStream for BaseNetworkSocketRequestStream {
18822 fn is_terminated(&self) -> bool {
18823 self.is_terminated
18824 }
18825}
18826
18827impl fidl::endpoints::RequestStream for BaseNetworkSocketRequestStream {
18828 type Protocol = BaseNetworkSocketMarker;
18829 type ControlHandle = BaseNetworkSocketControlHandle;
18830
18831 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
18832 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
18833 }
18834
18835 fn control_handle(&self) -> Self::ControlHandle {
18836 BaseNetworkSocketControlHandle { inner: self.inner.clone() }
18837 }
18838
18839 fn into_inner(
18840 self,
18841 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
18842 {
18843 (self.inner, self.is_terminated)
18844 }
18845
18846 fn from_inner(
18847 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
18848 is_terminated: bool,
18849 ) -> Self {
18850 Self { inner, is_terminated }
18851 }
18852}
18853
18854impl futures::Stream for BaseNetworkSocketRequestStream {
18855 type Item = Result<BaseNetworkSocketRequest, fidl::Error>;
18856
18857 fn poll_next(
18858 mut self: std::pin::Pin<&mut Self>,
18859 cx: &mut std::task::Context<'_>,
18860 ) -> std::task::Poll<Option<Self::Item>> {
18861 let this = &mut *self;
18862 if this.inner.check_shutdown(cx) {
18863 this.is_terminated = true;
18864 return std::task::Poll::Ready(None);
18865 }
18866 if this.is_terminated {
18867 panic!("polled BaseNetworkSocketRequestStream after completion");
18868 }
18869 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
18870 |bytes, handles| {
18871 match this.inner.channel().read_etc(cx, bytes, handles) {
18872 std::task::Poll::Ready(Ok(())) => {}
18873 std::task::Poll::Pending => return std::task::Poll::Pending,
18874 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
18875 this.is_terminated = true;
18876 return std::task::Poll::Ready(None);
18877 }
18878 std::task::Poll::Ready(Err(e)) => {
18879 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
18880 e.into(),
18881 ))))
18882 }
18883 }
18884
18885 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
18887
18888 std::task::Poll::Ready(Some(match header.ordinal {
18889 0x20d8a7aba2168a79 => {
18890 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
18891 let mut req = fidl::new_empty!(
18892 fidl_fuchsia_unknown::CloneableCloneRequest,
18893 fidl::encoding::DefaultFuchsiaResourceDialect
18894 );
18895 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
18896 let control_handle =
18897 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
18898 Ok(BaseNetworkSocketRequest::Clone { request: req.request, control_handle })
18899 }
18900 0x5ac5d459ad7f657e => {
18901 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
18902 let mut req = fidl::new_empty!(
18903 fidl::encoding::EmptyPayload,
18904 fidl::encoding::DefaultFuchsiaResourceDialect
18905 );
18906 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
18907 let control_handle =
18908 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
18909 Ok(BaseNetworkSocketRequest::Close {
18910 responder: BaseNetworkSocketCloseResponder {
18911 control_handle: std::mem::ManuallyDrop::new(control_handle),
18912 tx_id: header.tx_id,
18913 },
18914 })
18915 }
18916 0x2658edee9decfc06 => {
18917 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
18918 let mut req = fidl::new_empty!(
18919 fidl::encoding::EmptyPayload,
18920 fidl::encoding::DefaultFuchsiaResourceDialect
18921 );
18922 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
18923 let control_handle =
18924 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
18925 Ok(BaseNetworkSocketRequest::Query {
18926 responder: BaseNetworkSocketQueryResponder {
18927 control_handle: std::mem::ManuallyDrop::new(control_handle),
18928 tx_id: header.tx_id,
18929 },
18930 })
18931 }
18932 0x1fd74ee8b9a4a876 => {
18933 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
18934 let mut req = fidl::new_empty!(
18935 BaseSocketSetReuseAddressRequest,
18936 fidl::encoding::DefaultFuchsiaResourceDialect
18937 );
18938 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
18939 let control_handle =
18940 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
18941 Ok(BaseNetworkSocketRequest::SetReuseAddress {
18942 value: req.value,
18943
18944 responder: BaseNetworkSocketSetReuseAddressResponder {
18945 control_handle: std::mem::ManuallyDrop::new(control_handle),
18946 tx_id: header.tx_id,
18947 },
18948 })
18949 }
18950 0x67b7206b8d1bc0a5 => {
18951 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
18952 let mut req = fidl::new_empty!(
18953 fidl::encoding::EmptyPayload,
18954 fidl::encoding::DefaultFuchsiaResourceDialect
18955 );
18956 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
18957 let control_handle =
18958 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
18959 Ok(BaseNetworkSocketRequest::GetReuseAddress {
18960 responder: BaseNetworkSocketGetReuseAddressResponder {
18961 control_handle: std::mem::ManuallyDrop::new(control_handle),
18962 tx_id: header.tx_id,
18963 },
18964 })
18965 }
18966 0x5aad39b33e5f6ebb => {
18967 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
18968 let mut req = fidl::new_empty!(
18969 fidl::encoding::EmptyPayload,
18970 fidl::encoding::DefaultFuchsiaResourceDialect
18971 );
18972 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
18973 let control_handle =
18974 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
18975 Ok(BaseNetworkSocketRequest::GetError {
18976 responder: BaseNetworkSocketGetErrorResponder {
18977 control_handle: std::mem::ManuallyDrop::new(control_handle),
18978 tx_id: header.tx_id,
18979 },
18980 })
18981 }
18982 0x6023e081ce3cd947 => {
18983 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
18984 let mut req = fidl::new_empty!(
18985 BaseSocketSetBroadcastRequest,
18986 fidl::encoding::DefaultFuchsiaResourceDialect
18987 );
18988 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
18989 let control_handle =
18990 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
18991 Ok(BaseNetworkSocketRequest::SetBroadcast {
18992 value: req.value,
18993
18994 responder: BaseNetworkSocketSetBroadcastResponder {
18995 control_handle: std::mem::ManuallyDrop::new(control_handle),
18996 tx_id: header.tx_id,
18997 },
18998 })
18999 }
19000 0x68796fc556f9780d => {
19001 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19002 let mut req = fidl::new_empty!(
19003 fidl::encoding::EmptyPayload,
19004 fidl::encoding::DefaultFuchsiaResourceDialect
19005 );
19006 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19007 let control_handle =
19008 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19009 Ok(BaseNetworkSocketRequest::GetBroadcast {
19010 responder: BaseNetworkSocketGetBroadcastResponder {
19011 control_handle: std::mem::ManuallyDrop::new(control_handle),
19012 tx_id: header.tx_id,
19013 },
19014 })
19015 }
19016 0x756eac32d73a7a70 => {
19017 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19018 let mut req = fidl::new_empty!(
19019 BaseSocketSetSendBufferRequest,
19020 fidl::encoding::DefaultFuchsiaResourceDialect
19021 );
19022 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
19023 let control_handle =
19024 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19025 Ok(BaseNetworkSocketRequest::SetSendBuffer {
19026 value_bytes: req.value_bytes,
19027
19028 responder: BaseNetworkSocketSetSendBufferResponder {
19029 control_handle: std::mem::ManuallyDrop::new(control_handle),
19030 tx_id: header.tx_id,
19031 },
19032 })
19033 }
19034 0x78a52fd9c7b2410b => {
19035 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19036 let mut req = fidl::new_empty!(
19037 fidl::encoding::EmptyPayload,
19038 fidl::encoding::DefaultFuchsiaResourceDialect
19039 );
19040 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19041 let control_handle =
19042 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19043 Ok(BaseNetworkSocketRequest::GetSendBuffer {
19044 responder: BaseNetworkSocketGetSendBufferResponder {
19045 control_handle: std::mem::ManuallyDrop::new(control_handle),
19046 tx_id: header.tx_id,
19047 },
19048 })
19049 }
19050 0x6b0cf2f1919c7001 => {
19051 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19052 let mut req = fidl::new_empty!(
19053 BaseSocketSetReceiveBufferRequest,
19054 fidl::encoding::DefaultFuchsiaResourceDialect
19055 );
19056 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
19057 let control_handle =
19058 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19059 Ok(BaseNetworkSocketRequest::SetReceiveBuffer {
19060 value_bytes: req.value_bytes,
19061
19062 responder: BaseNetworkSocketSetReceiveBufferResponder {
19063 control_handle: std::mem::ManuallyDrop::new(control_handle),
19064 tx_id: header.tx_id,
19065 },
19066 })
19067 }
19068 0x14c1a4b64f709e5c => {
19069 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19070 let mut req = fidl::new_empty!(
19071 fidl::encoding::EmptyPayload,
19072 fidl::encoding::DefaultFuchsiaResourceDialect
19073 );
19074 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19075 let control_handle =
19076 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19077 Ok(BaseNetworkSocketRequest::GetReceiveBuffer {
19078 responder: BaseNetworkSocketGetReceiveBufferResponder {
19079 control_handle: std::mem::ManuallyDrop::new(control_handle),
19080 tx_id: header.tx_id,
19081 },
19082 })
19083 }
19084 0x572df8f0b920d2c7 => {
19085 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19086 let mut req = fidl::new_empty!(
19087 BaseSocketSetKeepAliveRequest,
19088 fidl::encoding::DefaultFuchsiaResourceDialect
19089 );
19090 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
19091 let control_handle =
19092 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19093 Ok(BaseNetworkSocketRequest::SetKeepAlive {
19094 value: req.value,
19095
19096 responder: BaseNetworkSocketSetKeepAliveResponder {
19097 control_handle: std::mem::ManuallyDrop::new(control_handle),
19098 tx_id: header.tx_id,
19099 },
19100 })
19101 }
19102 0x2dd29d3215f2c9d2 => {
19103 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19104 let mut req = fidl::new_empty!(
19105 fidl::encoding::EmptyPayload,
19106 fidl::encoding::DefaultFuchsiaResourceDialect
19107 );
19108 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19109 let control_handle =
19110 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19111 Ok(BaseNetworkSocketRequest::GetKeepAlive {
19112 responder: BaseNetworkSocketGetKeepAliveResponder {
19113 control_handle: std::mem::ManuallyDrop::new(control_handle),
19114 tx_id: header.tx_id,
19115 },
19116 })
19117 }
19118 0x3ecb49968bee439 => {
19119 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19120 let mut req = fidl::new_empty!(
19121 BaseSocketSetOutOfBandInlineRequest,
19122 fidl::encoding::DefaultFuchsiaResourceDialect
19123 );
19124 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
19125 let control_handle =
19126 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19127 Ok(BaseNetworkSocketRequest::SetOutOfBandInline {
19128 value: req.value,
19129
19130 responder: BaseNetworkSocketSetOutOfBandInlineResponder {
19131 control_handle: std::mem::ManuallyDrop::new(control_handle),
19132 tx_id: header.tx_id,
19133 },
19134 })
19135 }
19136 0x348c1ab3aeca1745 => {
19137 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19138 let mut req = fidl::new_empty!(
19139 fidl::encoding::EmptyPayload,
19140 fidl::encoding::DefaultFuchsiaResourceDialect
19141 );
19142 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19143 let control_handle =
19144 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19145 Ok(BaseNetworkSocketRequest::GetOutOfBandInline {
19146 responder: BaseNetworkSocketGetOutOfBandInlineResponder {
19147 control_handle: std::mem::ManuallyDrop::new(control_handle),
19148 tx_id: header.tx_id,
19149 },
19150 })
19151 }
19152 0x6bbf00c53a4c78c2 => {
19153 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19154 let mut req = fidl::new_empty!(
19155 BaseSocketSetNoCheckRequest,
19156 fidl::encoding::DefaultFuchsiaResourceDialect
19157 );
19158 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
19159 let control_handle =
19160 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19161 Ok(BaseNetworkSocketRequest::SetNoCheck {
19162 value: req.value,
19163
19164 responder: BaseNetworkSocketSetNoCheckResponder {
19165 control_handle: std::mem::ManuallyDrop::new(control_handle),
19166 tx_id: header.tx_id,
19167 },
19168 })
19169 }
19170 0x2cd4249286417694 => {
19171 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19172 let mut req = fidl::new_empty!(
19173 fidl::encoding::EmptyPayload,
19174 fidl::encoding::DefaultFuchsiaResourceDialect
19175 );
19176 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19177 let control_handle =
19178 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19179 Ok(BaseNetworkSocketRequest::GetNoCheck {
19180 responder: BaseNetworkSocketGetNoCheckResponder {
19181 control_handle: std::mem::ManuallyDrop::new(control_handle),
19182 tx_id: header.tx_id,
19183 },
19184 })
19185 }
19186 0x45386351246e998e => {
19187 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19188 let mut req = fidl::new_empty!(
19189 BaseSocketSetLingerRequest,
19190 fidl::encoding::DefaultFuchsiaResourceDialect
19191 );
19192 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
19193 let control_handle =
19194 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19195 Ok(BaseNetworkSocketRequest::SetLinger {
19196 linger: req.linger,
19197 length_secs: req.length_secs,
19198
19199 responder: BaseNetworkSocketSetLingerResponder {
19200 control_handle: std::mem::ManuallyDrop::new(control_handle),
19201 tx_id: header.tx_id,
19202 },
19203 })
19204 }
19205 0x48eb20fc5ccb0e45 => {
19206 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19207 let mut req = fidl::new_empty!(
19208 fidl::encoding::EmptyPayload,
19209 fidl::encoding::DefaultFuchsiaResourceDialect
19210 );
19211 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19212 let control_handle =
19213 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19214 Ok(BaseNetworkSocketRequest::GetLinger {
19215 responder: BaseNetworkSocketGetLingerResponder {
19216 control_handle: std::mem::ManuallyDrop::new(control_handle),
19217 tx_id: header.tx_id,
19218 },
19219 })
19220 }
19221 0x24dd3e5cb36d9ccb => {
19222 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19223 let mut req = fidl::new_empty!(
19224 BaseSocketSetReusePortRequest,
19225 fidl::encoding::DefaultFuchsiaResourceDialect
19226 );
19227 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
19228 let control_handle =
19229 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19230 Ok(BaseNetworkSocketRequest::SetReusePort {
19231 value: req.value,
19232
19233 responder: BaseNetworkSocketSetReusePortResponder {
19234 control_handle: std::mem::ManuallyDrop::new(control_handle),
19235 tx_id: header.tx_id,
19236 },
19237 })
19238 }
19239 0x7a112c1ab54ff828 => {
19240 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19241 let mut req = fidl::new_empty!(
19242 fidl::encoding::EmptyPayload,
19243 fidl::encoding::DefaultFuchsiaResourceDialect
19244 );
19245 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19246 let control_handle =
19247 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19248 Ok(BaseNetworkSocketRequest::GetReusePort {
19249 responder: BaseNetworkSocketGetReusePortResponder {
19250 control_handle: std::mem::ManuallyDrop::new(control_handle),
19251 tx_id: header.tx_id,
19252 },
19253 })
19254 }
19255 0x67ce6db6c2ec8966 => {
19256 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19257 let mut req = fidl::new_empty!(
19258 fidl::encoding::EmptyPayload,
19259 fidl::encoding::DefaultFuchsiaResourceDialect
19260 );
19261 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19262 let control_handle =
19263 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19264 Ok(BaseNetworkSocketRequest::GetAcceptConn {
19265 responder: BaseNetworkSocketGetAcceptConnResponder {
19266 control_handle: std::mem::ManuallyDrop::new(control_handle),
19267 tx_id: header.tx_id,
19268 },
19269 })
19270 }
19271 0x2118b483f28aafc4 => {
19272 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19273 let mut req = fidl::new_empty!(
19274 BaseSocketSetBindToDeviceRequest,
19275 fidl::encoding::DefaultFuchsiaResourceDialect
19276 );
19277 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
19278 let control_handle =
19279 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19280 Ok(BaseNetworkSocketRequest::SetBindToDevice {
19281 value: req.value,
19282
19283 responder: BaseNetworkSocketSetBindToDeviceResponder {
19284 control_handle: std::mem::ManuallyDrop::new(control_handle),
19285 tx_id: header.tx_id,
19286 },
19287 })
19288 }
19289 0x1ab1fbf0ef7906c8 => {
19290 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19291 let mut req = fidl::new_empty!(
19292 fidl::encoding::EmptyPayload,
19293 fidl::encoding::DefaultFuchsiaResourceDialect
19294 );
19295 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19296 let control_handle =
19297 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19298 Ok(BaseNetworkSocketRequest::GetBindToDevice {
19299 responder: BaseNetworkSocketGetBindToDeviceResponder {
19300 control_handle: std::mem::ManuallyDrop::new(control_handle),
19301 tx_id: header.tx_id,
19302 },
19303 })
19304 }
19305 0x6e387a0def00821 => {
19306 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19307 let mut req = fidl::new_empty!(
19308 BaseSocketSetBindToInterfaceIndexRequest,
19309 fidl::encoding::DefaultFuchsiaResourceDialect
19310 );
19311 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
19312 let control_handle =
19313 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19314 Ok(BaseNetworkSocketRequest::SetBindToInterfaceIndex {
19315 value: req.value,
19316
19317 responder: BaseNetworkSocketSetBindToInterfaceIndexResponder {
19318 control_handle: std::mem::ManuallyDrop::new(control_handle),
19319 tx_id: header.tx_id,
19320 },
19321 })
19322 }
19323 0x59c31dd3e3078295 => {
19324 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19325 let mut req = fidl::new_empty!(
19326 fidl::encoding::EmptyPayload,
19327 fidl::encoding::DefaultFuchsiaResourceDialect
19328 );
19329 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19330 let control_handle =
19331 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19332 Ok(BaseNetworkSocketRequest::GetBindToInterfaceIndex {
19333 responder: BaseNetworkSocketGetBindToInterfaceIndexResponder {
19334 control_handle: std::mem::ManuallyDrop::new(control_handle),
19335 tx_id: header.tx_id,
19336 },
19337 })
19338 }
19339 0x285d6516c263d839 => {
19340 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19341 let mut req = fidl::new_empty!(
19342 BaseSocketSetTimestampRequest,
19343 fidl::encoding::DefaultFuchsiaResourceDialect
19344 );
19345 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
19346 let control_handle =
19347 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19348 Ok(BaseNetworkSocketRequest::SetTimestamp {
19349 value: req.value,
19350
19351 responder: BaseNetworkSocketSetTimestampResponder {
19352 control_handle: std::mem::ManuallyDrop::new(control_handle),
19353 tx_id: header.tx_id,
19354 },
19355 })
19356 }
19357 0x49f2fffbbcc2bd27 => {
19358 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19359 let mut req = fidl::new_empty!(
19360 fidl::encoding::EmptyPayload,
19361 fidl::encoding::DefaultFuchsiaResourceDialect
19362 );
19363 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19364 let control_handle =
19365 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19366 Ok(BaseNetworkSocketRequest::GetTimestamp {
19367 responder: BaseNetworkSocketGetTimestampResponder {
19368 control_handle: std::mem::ManuallyDrop::new(control_handle),
19369 tx_id: header.tx_id,
19370 },
19371 })
19372 }
19373 0x6ead6de09f653236 => {
19374 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19375 let mut req = fidl::new_empty!(
19376 BaseSocketSetMarkRequest,
19377 fidl::encoding::DefaultFuchsiaResourceDialect
19378 );
19379 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
19380 let control_handle =
19381 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19382 Ok(BaseNetworkSocketRequest::SetMark {
19383 domain: req.domain,
19384 mark: req.mark,
19385
19386 responder: BaseNetworkSocketSetMarkResponder {
19387 control_handle: std::mem::ManuallyDrop::new(control_handle),
19388 tx_id: header.tx_id,
19389 },
19390 })
19391 }
19392 0x57a2752c61d93d47 => {
19393 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19394 let mut req = fidl::new_empty!(
19395 BaseSocketGetMarkRequest,
19396 fidl::encoding::DefaultFuchsiaResourceDialect
19397 );
19398 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
19399 let control_handle =
19400 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19401 Ok(BaseNetworkSocketRequest::GetMark {
19402 domain: req.domain,
19403
19404 responder: BaseNetworkSocketGetMarkResponder {
19405 control_handle: std::mem::ManuallyDrop::new(control_handle),
19406 tx_id: header.tx_id,
19407 },
19408 })
19409 }
19410 0x4bc6400ae92125d => {
19411 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19412 let mut req = fidl::new_empty!(
19413 BaseNetworkSocketBindRequest,
19414 fidl::encoding::DefaultFuchsiaResourceDialect
19415 );
19416 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
19417 let control_handle =
19418 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19419 Ok(BaseNetworkSocketRequest::Bind {
19420 addr: req.addr,
19421
19422 responder: BaseNetworkSocketBindResponder {
19423 control_handle: std::mem::ManuallyDrop::new(control_handle),
19424 tx_id: header.tx_id,
19425 },
19426 })
19427 }
19428 0x5f05f19bfdd38871 => {
19429 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19430 let mut req = fidl::new_empty!(
19431 BaseNetworkSocketConnectRequest,
19432 fidl::encoding::DefaultFuchsiaResourceDialect
19433 );
19434 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
19435 let control_handle =
19436 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19437 Ok(BaseNetworkSocketRequest::Connect {
19438 addr: req.addr,
19439
19440 responder: BaseNetworkSocketConnectResponder {
19441 control_handle: std::mem::ManuallyDrop::new(control_handle),
19442 tx_id: header.tx_id,
19443 },
19444 })
19445 }
19446 0x74e63b91f7b29b2 => {
19447 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19448 let mut req = fidl::new_empty!(
19449 fidl::encoding::EmptyPayload,
19450 fidl::encoding::DefaultFuchsiaResourceDialect
19451 );
19452 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19453 let control_handle =
19454 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19455 Ok(BaseNetworkSocketRequest::Disconnect {
19456 responder: BaseNetworkSocketDisconnectResponder {
19457 control_handle: std::mem::ManuallyDrop::new(control_handle),
19458 tx_id: header.tx_id,
19459 },
19460 })
19461 }
19462 0x475f23f84a1a4f85 => {
19463 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19464 let mut req = fidl::new_empty!(
19465 fidl::encoding::EmptyPayload,
19466 fidl::encoding::DefaultFuchsiaResourceDialect
19467 );
19468 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19469 let control_handle =
19470 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19471 Ok(BaseNetworkSocketRequest::GetSockName {
19472 responder: BaseNetworkSocketGetSockNameResponder {
19473 control_handle: std::mem::ManuallyDrop::new(control_handle),
19474 tx_id: header.tx_id,
19475 },
19476 })
19477 }
19478 0x1ffecf4bd5b6432e => {
19479 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19480 let mut req = fidl::new_empty!(
19481 fidl::encoding::EmptyPayload,
19482 fidl::encoding::DefaultFuchsiaResourceDialect
19483 );
19484 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19485 let control_handle =
19486 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19487 Ok(BaseNetworkSocketRequest::GetPeerName {
19488 responder: BaseNetworkSocketGetPeerNameResponder {
19489 control_handle: std::mem::ManuallyDrop::new(control_handle),
19490 tx_id: header.tx_id,
19491 },
19492 })
19493 }
19494 0x247f38b6db68c336 => {
19495 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19496 let mut req = fidl::new_empty!(
19497 BaseNetworkSocketShutdownRequest,
19498 fidl::encoding::DefaultFuchsiaResourceDialect
19499 );
19500 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketShutdownRequest>(&header, _body_bytes, handles, &mut req)?;
19501 let control_handle =
19502 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19503 Ok(BaseNetworkSocketRequest::Shutdown {
19504 mode: req.mode,
19505
19506 responder: BaseNetworkSocketShutdownResponder {
19507 control_handle: std::mem::ManuallyDrop::new(control_handle),
19508 tx_id: header.tx_id,
19509 },
19510 })
19511 }
19512 0x995c600475b6d46 => {
19513 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19514 let mut req = fidl::new_empty!(
19515 BaseNetworkSocketSetIpTypeOfServiceRequest,
19516 fidl::encoding::DefaultFuchsiaResourceDialect
19517 );
19518 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
19519 let control_handle =
19520 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19521 Ok(BaseNetworkSocketRequest::SetIpTypeOfService {
19522 value: req.value,
19523
19524 responder: BaseNetworkSocketSetIpTypeOfServiceResponder {
19525 control_handle: std::mem::ManuallyDrop::new(control_handle),
19526 tx_id: header.tx_id,
19527 },
19528 })
19529 }
19530 0x3814a04259f75fcb => {
19531 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19532 let mut req = fidl::new_empty!(
19533 fidl::encoding::EmptyPayload,
19534 fidl::encoding::DefaultFuchsiaResourceDialect
19535 );
19536 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19537 let control_handle =
19538 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19539 Ok(BaseNetworkSocketRequest::GetIpTypeOfService {
19540 responder: BaseNetworkSocketGetIpTypeOfServiceResponder {
19541 control_handle: std::mem::ManuallyDrop::new(control_handle),
19542 tx_id: header.tx_id,
19543 },
19544 })
19545 }
19546 0x29e2424b433ae1ef => {
19547 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19548 let mut req = fidl::new_empty!(
19549 BaseNetworkSocketSetIpTtlRequest,
19550 fidl::encoding::DefaultFuchsiaResourceDialect
19551 );
19552 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTtlRequest>(&header, _body_bytes, handles, &mut req)?;
19553 let control_handle =
19554 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19555 Ok(BaseNetworkSocketRequest::SetIpTtl {
19556 value: req.value,
19557
19558 responder: BaseNetworkSocketSetIpTtlResponder {
19559 control_handle: std::mem::ManuallyDrop::new(control_handle),
19560 tx_id: header.tx_id,
19561 },
19562 })
19563 }
19564 0x47e47fa1f24da471 => {
19565 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19566 let mut req = fidl::new_empty!(
19567 fidl::encoding::EmptyPayload,
19568 fidl::encoding::DefaultFuchsiaResourceDialect
19569 );
19570 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19571 let control_handle =
19572 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19573 Ok(BaseNetworkSocketRequest::GetIpTtl {
19574 responder: BaseNetworkSocketGetIpTtlResponder {
19575 control_handle: std::mem::ManuallyDrop::new(control_handle),
19576 tx_id: header.tx_id,
19577 },
19578 })
19579 }
19580 0x392d16bee20c0e16 => {
19581 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19582 let mut req = fidl::new_empty!(
19583 BaseNetworkSocketSetIpPacketInfoRequest,
19584 fidl::encoding::DefaultFuchsiaResourceDialect
19585 );
19586 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpPacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
19587 let control_handle =
19588 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19589 Ok(BaseNetworkSocketRequest::SetIpPacketInfo {
19590 value: req.value,
19591
19592 responder: BaseNetworkSocketSetIpPacketInfoResponder {
19593 control_handle: std::mem::ManuallyDrop::new(control_handle),
19594 tx_id: header.tx_id,
19595 },
19596 })
19597 }
19598 0x54b505f242280740 => {
19599 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19600 let mut req = fidl::new_empty!(
19601 fidl::encoding::EmptyPayload,
19602 fidl::encoding::DefaultFuchsiaResourceDialect
19603 );
19604 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19605 let control_handle =
19606 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19607 Ok(BaseNetworkSocketRequest::GetIpPacketInfo {
19608 responder: BaseNetworkSocketGetIpPacketInfoResponder {
19609 control_handle: std::mem::ManuallyDrop::new(control_handle),
19610 tx_id: header.tx_id,
19611 },
19612 })
19613 }
19614 0x6c4f6714995f84ef => {
19615 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19616 let mut req = fidl::new_empty!(
19617 BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
19618 fidl::encoding::DefaultFuchsiaResourceDialect
19619 );
19620 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
19621 let control_handle =
19622 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19623 Ok(BaseNetworkSocketRequest::SetIpReceiveTypeOfService {
19624 value: req.value,
19625
19626 responder: BaseNetworkSocketSetIpReceiveTypeOfServiceResponder {
19627 control_handle: std::mem::ManuallyDrop::new(control_handle),
19628 tx_id: header.tx_id,
19629 },
19630 })
19631 }
19632 0x4158ba7dc2795960 => {
19633 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19634 let mut req = fidl::new_empty!(
19635 fidl::encoding::EmptyPayload,
19636 fidl::encoding::DefaultFuchsiaResourceDialect
19637 );
19638 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19639 let control_handle =
19640 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19641 Ok(BaseNetworkSocketRequest::GetIpReceiveTypeOfService {
19642 responder: BaseNetworkSocketGetIpReceiveTypeOfServiceResponder {
19643 control_handle: std::mem::ManuallyDrop::new(control_handle),
19644 tx_id: header.tx_id,
19645 },
19646 })
19647 }
19648 0x46f15be0ce0ab82b => {
19649 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19650 let mut req = fidl::new_empty!(
19651 BaseNetworkSocketSetIpReceiveTtlRequest,
19652 fidl::encoding::DefaultFuchsiaResourceDialect
19653 );
19654 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTtlRequest>(&header, _body_bytes, handles, &mut req)?;
19655 let control_handle =
19656 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19657 Ok(BaseNetworkSocketRequest::SetIpReceiveTtl {
19658 value: req.value,
19659
19660 responder: BaseNetworkSocketSetIpReceiveTtlResponder {
19661 control_handle: std::mem::ManuallyDrop::new(control_handle),
19662 tx_id: header.tx_id,
19663 },
19664 })
19665 }
19666 0x678ddd5a5dfa2eb5 => {
19667 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19668 let mut req = fidl::new_empty!(
19669 fidl::encoding::EmptyPayload,
19670 fidl::encoding::DefaultFuchsiaResourceDialect
19671 );
19672 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19673 let control_handle =
19674 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19675 Ok(BaseNetworkSocketRequest::GetIpReceiveTtl {
19676 responder: BaseNetworkSocketGetIpReceiveTtlResponder {
19677 control_handle: std::mem::ManuallyDrop::new(control_handle),
19678 tx_id: header.tx_id,
19679 },
19680 })
19681 }
19682 0x752fbfa9b12befe => {
19683 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19684 let mut req = fidl::new_empty!(
19685 BaseNetworkSocketSetIpMulticastInterfaceRequest,
19686 fidl::encoding::DefaultFuchsiaResourceDialect
19687 );
19688 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
19689 let control_handle =
19690 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19691 Ok(BaseNetworkSocketRequest::SetIpMulticastInterface {
19692 iface: req.iface,
19693 address: req.address,
19694
19695 responder: BaseNetworkSocketSetIpMulticastInterfaceResponder {
19696 control_handle: std::mem::ManuallyDrop::new(control_handle),
19697 tx_id: header.tx_id,
19698 },
19699 })
19700 }
19701 0x320bd14c4df046c4 => {
19702 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19703 let mut req = fidl::new_empty!(
19704 fidl::encoding::EmptyPayload,
19705 fidl::encoding::DefaultFuchsiaResourceDialect
19706 );
19707 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19708 let control_handle =
19709 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19710 Ok(BaseNetworkSocketRequest::GetIpMulticastInterface {
19711 responder: BaseNetworkSocketGetIpMulticastInterfaceResponder {
19712 control_handle: std::mem::ManuallyDrop::new(control_handle),
19713 tx_id: header.tx_id,
19714 },
19715 })
19716 }
19717 0x63134d53772916a1 => {
19718 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19719 let mut req = fidl::new_empty!(
19720 BaseNetworkSocketSetIpMulticastTtlRequest,
19721 fidl::encoding::DefaultFuchsiaResourceDialect
19722 );
19723 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastTtlRequest>(&header, _body_bytes, handles, &mut req)?;
19724 let control_handle =
19725 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19726 Ok(BaseNetworkSocketRequest::SetIpMulticastTtl {
19727 value: req.value,
19728
19729 responder: BaseNetworkSocketSetIpMulticastTtlResponder {
19730 control_handle: std::mem::ManuallyDrop::new(control_handle),
19731 tx_id: header.tx_id,
19732 },
19733 })
19734 }
19735 0x4665cd378f39e1a => {
19736 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19737 let mut req = fidl::new_empty!(
19738 fidl::encoding::EmptyPayload,
19739 fidl::encoding::DefaultFuchsiaResourceDialect
19740 );
19741 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19742 let control_handle =
19743 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19744 Ok(BaseNetworkSocketRequest::GetIpMulticastTtl {
19745 responder: BaseNetworkSocketGetIpMulticastTtlResponder {
19746 control_handle: std::mem::ManuallyDrop::new(control_handle),
19747 tx_id: header.tx_id,
19748 },
19749 })
19750 }
19751 0x20c55c11f00943ea => {
19752 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19753 let mut req = fidl::new_empty!(
19754 BaseNetworkSocketSetIpMulticastLoopbackRequest,
19755 fidl::encoding::DefaultFuchsiaResourceDialect
19756 );
19757 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
19758 let control_handle =
19759 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19760 Ok(BaseNetworkSocketRequest::SetIpMulticastLoopback {
19761 value: req.value,
19762
19763 responder: BaseNetworkSocketSetIpMulticastLoopbackResponder {
19764 control_handle: std::mem::ManuallyDrop::new(control_handle),
19765 tx_id: header.tx_id,
19766 },
19767 })
19768 }
19769 0x3b6b26ff558298f2 => {
19770 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19771 let mut req = fidl::new_empty!(
19772 fidl::encoding::EmptyPayload,
19773 fidl::encoding::DefaultFuchsiaResourceDialect
19774 );
19775 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19776 let control_handle =
19777 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19778 Ok(BaseNetworkSocketRequest::GetIpMulticastLoopback {
19779 responder: BaseNetworkSocketGetIpMulticastLoopbackResponder {
19780 control_handle: std::mem::ManuallyDrop::new(control_handle),
19781 tx_id: header.tx_id,
19782 },
19783 })
19784 }
19785 0x76bc7df115a3b4d0 => {
19786 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19787 let mut req = fidl::new_empty!(
19788 BaseNetworkSocketAddIpMembershipRequest,
19789 fidl::encoding::DefaultFuchsiaResourceDialect
19790 );
19791 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
19792 let control_handle =
19793 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19794 Ok(BaseNetworkSocketRequest::AddIpMembership {
19795 membership: req.membership,
19796
19797 responder: BaseNetworkSocketAddIpMembershipResponder {
19798 control_handle: std::mem::ManuallyDrop::new(control_handle),
19799 tx_id: header.tx_id,
19800 },
19801 })
19802 }
19803 0x2888f3099188d03 => {
19804 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19805 let mut req = fidl::new_empty!(
19806 BaseNetworkSocketDropIpMembershipRequest,
19807 fidl::encoding::DefaultFuchsiaResourceDialect
19808 );
19809 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
19810 let control_handle =
19811 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19812 Ok(BaseNetworkSocketRequest::DropIpMembership {
19813 membership: req.membership,
19814
19815 responder: BaseNetworkSocketDropIpMembershipResponder {
19816 control_handle: std::mem::ManuallyDrop::new(control_handle),
19817 tx_id: header.tx_id,
19818 },
19819 })
19820 }
19821 0x1ae532b0c066e3a0 => {
19822 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19823 let mut req = fidl::new_empty!(
19824 BaseNetworkSocketSetIpTransparentRequest,
19825 fidl::encoding::DefaultFuchsiaResourceDialect
19826 );
19827 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTransparentRequest>(&header, _body_bytes, handles, &mut req)?;
19828 let control_handle =
19829 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19830 Ok(BaseNetworkSocketRequest::SetIpTransparent {
19831 value: req.value,
19832
19833 responder: BaseNetworkSocketSetIpTransparentResponder {
19834 control_handle: std::mem::ManuallyDrop::new(control_handle),
19835 tx_id: header.tx_id,
19836 },
19837 })
19838 }
19839 0x51d43695962ebfb5 => {
19840 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19841 let mut req = fidl::new_empty!(
19842 fidl::encoding::EmptyPayload,
19843 fidl::encoding::DefaultFuchsiaResourceDialect
19844 );
19845 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19846 let control_handle =
19847 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19848 Ok(BaseNetworkSocketRequest::GetIpTransparent {
19849 responder: BaseNetworkSocketGetIpTransparentResponder {
19850 control_handle: std::mem::ManuallyDrop::new(control_handle),
19851 tx_id: header.tx_id,
19852 },
19853 })
19854 }
19855 0x4722b4ce52f7840 => {
19856 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19857 let mut req = fidl::new_empty!(
19858 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
19859 fidl::encoding::DefaultFuchsiaResourceDialect
19860 );
19861 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest>(&header, _body_bytes, handles, &mut req)?;
19862 let control_handle =
19863 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19864 Ok(BaseNetworkSocketRequest::SetIpReceiveOriginalDestinationAddress {
19865 value: req.value,
19866
19867 responder:
19868 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder {
19869 control_handle: std::mem::ManuallyDrop::new(control_handle),
19870 tx_id: header.tx_id,
19871 },
19872 })
19873 }
19874 0x2a0e7dc5d6bfdfe9 => {
19875 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19876 let mut req = fidl::new_empty!(
19877 fidl::encoding::EmptyPayload,
19878 fidl::encoding::DefaultFuchsiaResourceDialect
19879 );
19880 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19881 let control_handle =
19882 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19883 Ok(BaseNetworkSocketRequest::GetIpReceiveOriginalDestinationAddress {
19884 responder:
19885 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder {
19886 control_handle: std::mem::ManuallyDrop::new(control_handle),
19887 tx_id: header.tx_id,
19888 },
19889 })
19890 }
19891 0x7c94727acb4ea4b3 => {
19892 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19893 let mut req = fidl::new_empty!(
19894 BaseNetworkSocketAddIpv6MembershipRequest,
19895 fidl::encoding::DefaultFuchsiaResourceDialect
19896 );
19897 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
19898 let control_handle =
19899 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19900 Ok(BaseNetworkSocketRequest::AddIpv6Membership {
19901 membership: req.membership,
19902
19903 responder: BaseNetworkSocketAddIpv6MembershipResponder {
19904 control_handle: std::mem::ManuallyDrop::new(control_handle),
19905 tx_id: header.tx_id,
19906 },
19907 })
19908 }
19909 0x42104c70ccaba304 => {
19910 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19911 let mut req = fidl::new_empty!(
19912 BaseNetworkSocketDropIpv6MembershipRequest,
19913 fidl::encoding::DefaultFuchsiaResourceDialect
19914 );
19915 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
19916 let control_handle =
19917 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19918 Ok(BaseNetworkSocketRequest::DropIpv6Membership {
19919 membership: req.membership,
19920
19921 responder: BaseNetworkSocketDropIpv6MembershipResponder {
19922 control_handle: std::mem::ManuallyDrop::new(control_handle),
19923 tx_id: header.tx_id,
19924 },
19925 })
19926 }
19927 0x135f76db3774ab3b => {
19928 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19929 let mut req = fidl::new_empty!(
19930 BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
19931 fidl::encoding::DefaultFuchsiaResourceDialect
19932 );
19933 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
19934 let control_handle =
19935 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19936 Ok(BaseNetworkSocketRequest::SetIpv6MulticastInterface {
19937 value: req.value,
19938
19939 responder: BaseNetworkSocketSetIpv6MulticastInterfaceResponder {
19940 control_handle: std::mem::ManuallyDrop::new(control_handle),
19941 tx_id: header.tx_id,
19942 },
19943 })
19944 }
19945 0x1f26fcdd348f1882 => {
19946 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19947 let mut req = fidl::new_empty!(
19948 fidl::encoding::EmptyPayload,
19949 fidl::encoding::DefaultFuchsiaResourceDialect
19950 );
19951 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19952 let control_handle =
19953 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19954 Ok(BaseNetworkSocketRequest::GetIpv6MulticastInterface {
19955 responder: BaseNetworkSocketGetIpv6MulticastInterfaceResponder {
19956 control_handle: std::mem::ManuallyDrop::new(control_handle),
19957 tx_id: header.tx_id,
19958 },
19959 })
19960 }
19961 0x157d51e98f462859 => {
19962 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19963 let mut req = fidl::new_empty!(
19964 BaseNetworkSocketSetIpv6UnicastHopsRequest,
19965 fidl::encoding::DefaultFuchsiaResourceDialect
19966 );
19967 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6UnicastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
19968 let control_handle =
19969 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19970 Ok(BaseNetworkSocketRequest::SetIpv6UnicastHops {
19971 value: req.value,
19972
19973 responder: BaseNetworkSocketSetIpv6UnicastHopsResponder {
19974 control_handle: std::mem::ManuallyDrop::new(control_handle),
19975 tx_id: header.tx_id,
19976 },
19977 })
19978 }
19979 0x21f4641cad8bd8d2 => {
19980 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19981 let mut req = fidl::new_empty!(
19982 fidl::encoding::EmptyPayload,
19983 fidl::encoding::DefaultFuchsiaResourceDialect
19984 );
19985 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19986 let control_handle =
19987 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19988 Ok(BaseNetworkSocketRequest::GetIpv6UnicastHops {
19989 responder: BaseNetworkSocketGetIpv6UnicastHopsResponder {
19990 control_handle: std::mem::ManuallyDrop::new(control_handle),
19991 tx_id: header.tx_id,
19992 },
19993 })
19994 }
19995 0x5c24808ed2e84a1e => {
19996 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19997 let mut req = fidl::new_empty!(
19998 BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
19999 fidl::encoding::DefaultFuchsiaResourceDialect
20000 );
20001 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveHopLimitRequest>(&header, _body_bytes, handles, &mut req)?;
20002 let control_handle =
20003 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20004 Ok(BaseNetworkSocketRequest::SetIpv6ReceiveHopLimit {
20005 value: req.value,
20006
20007 responder: BaseNetworkSocketSetIpv6ReceiveHopLimitResponder {
20008 control_handle: std::mem::ManuallyDrop::new(control_handle),
20009 tx_id: header.tx_id,
20010 },
20011 })
20012 }
20013 0x341e06689885b4c0 => {
20014 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20015 let mut req = fidl::new_empty!(
20016 fidl::encoding::EmptyPayload,
20017 fidl::encoding::DefaultFuchsiaResourceDialect
20018 );
20019 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
20020 let control_handle =
20021 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20022 Ok(BaseNetworkSocketRequest::GetIpv6ReceiveHopLimit {
20023 responder: BaseNetworkSocketGetIpv6ReceiveHopLimitResponder {
20024 control_handle: std::mem::ManuallyDrop::new(control_handle),
20025 tx_id: header.tx_id,
20026 },
20027 })
20028 }
20029 0x25b9cd4d181f82c1 => {
20030 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20031 let mut req = fidl::new_empty!(
20032 BaseNetworkSocketSetIpv6MulticastHopsRequest,
20033 fidl::encoding::DefaultFuchsiaResourceDialect
20034 );
20035 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
20036 let control_handle =
20037 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20038 Ok(BaseNetworkSocketRequest::SetIpv6MulticastHops {
20039 value: req.value,
20040
20041 responder: BaseNetworkSocketSetIpv6MulticastHopsResponder {
20042 control_handle: std::mem::ManuallyDrop::new(control_handle),
20043 tx_id: header.tx_id,
20044 },
20045 })
20046 }
20047 0x52916948a365012a => {
20048 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20049 let mut req = fidl::new_empty!(
20050 fidl::encoding::EmptyPayload,
20051 fidl::encoding::DefaultFuchsiaResourceDialect
20052 );
20053 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
20054 let control_handle =
20055 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20056 Ok(BaseNetworkSocketRequest::GetIpv6MulticastHops {
20057 responder: BaseNetworkSocketGetIpv6MulticastHopsResponder {
20058 control_handle: std::mem::ManuallyDrop::new(control_handle),
20059 tx_id: header.tx_id,
20060 },
20061 })
20062 }
20063 0x55701c409ff41b40 => {
20064 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20065 let mut req = fidl::new_empty!(
20066 BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
20067 fidl::encoding::DefaultFuchsiaResourceDialect
20068 );
20069 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
20070 let control_handle =
20071 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20072 Ok(BaseNetworkSocketRequest::SetIpv6MulticastLoopback {
20073 value: req.value,
20074
20075 responder: BaseNetworkSocketSetIpv6MulticastLoopbackResponder {
20076 control_handle: std::mem::ManuallyDrop::new(control_handle),
20077 tx_id: header.tx_id,
20078 },
20079 })
20080 }
20081 0x4415b701fde319c3 => {
20082 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20083 let mut req = fidl::new_empty!(
20084 fidl::encoding::EmptyPayload,
20085 fidl::encoding::DefaultFuchsiaResourceDialect
20086 );
20087 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
20088 let control_handle =
20089 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20090 Ok(BaseNetworkSocketRequest::GetIpv6MulticastLoopback {
20091 responder: BaseNetworkSocketGetIpv6MulticastLoopbackResponder {
20092 control_handle: std::mem::ManuallyDrop::new(control_handle),
20093 tx_id: header.tx_id,
20094 },
20095 })
20096 }
20097 0x4873f1364758cbba => {
20098 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20099 let mut req = fidl::new_empty!(
20100 BaseNetworkSocketSetIpv6OnlyRequest,
20101 fidl::encoding::DefaultFuchsiaResourceDialect
20102 );
20103 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6OnlyRequest>(&header, _body_bytes, handles, &mut req)?;
20104 let control_handle =
20105 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20106 Ok(BaseNetworkSocketRequest::SetIpv6Only {
20107 value: req.value,
20108
20109 responder: BaseNetworkSocketSetIpv6OnlyResponder {
20110 control_handle: std::mem::ManuallyDrop::new(control_handle),
20111 tx_id: header.tx_id,
20112 },
20113 })
20114 }
20115 0x4aa3340a1a26b89c => {
20116 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20117 let mut req = fidl::new_empty!(
20118 fidl::encoding::EmptyPayload,
20119 fidl::encoding::DefaultFuchsiaResourceDialect
20120 );
20121 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
20122 let control_handle =
20123 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20124 Ok(BaseNetworkSocketRequest::GetIpv6Only {
20125 responder: BaseNetworkSocketGetIpv6OnlyResponder {
20126 control_handle: std::mem::ManuallyDrop::new(control_handle),
20127 tx_id: header.tx_id,
20128 },
20129 })
20130 }
20131 0x58f07c8788d099a0 => {
20132 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20133 let mut req = fidl::new_empty!(
20134 BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
20135 fidl::encoding::DefaultFuchsiaResourceDialect
20136 );
20137 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
20138 let control_handle =
20139 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20140 Ok(BaseNetworkSocketRequest::SetIpv6ReceiveTrafficClass {
20141 value: req.value,
20142
20143 responder: BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder {
20144 control_handle: std::mem::ManuallyDrop::new(control_handle),
20145 tx_id: header.tx_id,
20146 },
20147 })
20148 }
20149 0x2e334df1da553ffa => {
20150 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20151 let mut req = fidl::new_empty!(
20152 fidl::encoding::EmptyPayload,
20153 fidl::encoding::DefaultFuchsiaResourceDialect
20154 );
20155 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
20156 let control_handle =
20157 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20158 Ok(BaseNetworkSocketRequest::GetIpv6ReceiveTrafficClass {
20159 responder: BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder {
20160 control_handle: std::mem::ManuallyDrop::new(control_handle),
20161 tx_id: header.tx_id,
20162 },
20163 })
20164 }
20165 0x6af077800c5a0b4f => {
20166 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20167 let mut req = fidl::new_empty!(
20168 BaseNetworkSocketSetIpv6TrafficClassRequest,
20169 fidl::encoding::DefaultFuchsiaResourceDialect
20170 );
20171 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6TrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
20172 let control_handle =
20173 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20174 Ok(BaseNetworkSocketRequest::SetIpv6TrafficClass {
20175 value: req.value,
20176
20177 responder: BaseNetworkSocketSetIpv6TrafficClassResponder {
20178 control_handle: std::mem::ManuallyDrop::new(control_handle),
20179 tx_id: header.tx_id,
20180 },
20181 })
20182 }
20183 0x6baf6eed8fc2f04 => {
20184 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20185 let mut req = fidl::new_empty!(
20186 fidl::encoding::EmptyPayload,
20187 fidl::encoding::DefaultFuchsiaResourceDialect
20188 );
20189 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
20190 let control_handle =
20191 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20192 Ok(BaseNetworkSocketRequest::GetIpv6TrafficClass {
20193 responder: BaseNetworkSocketGetIpv6TrafficClassResponder {
20194 control_handle: std::mem::ManuallyDrop::new(control_handle),
20195 tx_id: header.tx_id,
20196 },
20197 })
20198 }
20199 0x19259775b1a92768 => {
20200 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20201 let mut req = fidl::new_empty!(
20202 BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
20203 fidl::encoding::DefaultFuchsiaResourceDialect
20204 );
20205 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceivePacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
20206 let control_handle =
20207 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20208 Ok(BaseNetworkSocketRequest::SetIpv6ReceivePacketInfo {
20209 value: req.value,
20210
20211 responder: BaseNetworkSocketSetIpv6ReceivePacketInfoResponder {
20212 control_handle: std::mem::ManuallyDrop::new(control_handle),
20213 tx_id: header.tx_id,
20214 },
20215 })
20216 }
20217 0x7acd4a2775baec75 => {
20218 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20219 let mut req = fidl::new_empty!(
20220 fidl::encoding::EmptyPayload,
20221 fidl::encoding::DefaultFuchsiaResourceDialect
20222 );
20223 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
20224 let control_handle =
20225 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20226 Ok(BaseNetworkSocketRequest::GetIpv6ReceivePacketInfo {
20227 responder: BaseNetworkSocketGetIpv6ReceivePacketInfoResponder {
20228 control_handle: std::mem::ManuallyDrop::new(control_handle),
20229 tx_id: header.tx_id,
20230 },
20231 })
20232 }
20233 0x38bf28f0dafdbac0 => {
20234 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20235 let mut req = fidl::new_empty!(
20236 fidl::encoding::EmptyPayload,
20237 fidl::encoding::DefaultFuchsiaResourceDialect
20238 );
20239 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
20240 let control_handle =
20241 BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20242 Ok(BaseNetworkSocketRequest::GetOriginalDestination {
20243 responder: BaseNetworkSocketGetOriginalDestinationResponder {
20244 control_handle: std::mem::ManuallyDrop::new(control_handle),
20245 tx_id: header.tx_id,
20246 },
20247 })
20248 }
20249 _ => Err(fidl::Error::UnknownOrdinal {
20250 ordinal: header.ordinal,
20251 protocol_name:
20252 <BaseNetworkSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
20253 }),
20254 }))
20255 },
20256 )
20257 }
20258}
20259
20260#[derive(Debug)]
20262pub enum BaseNetworkSocketRequest {
20263 Clone {
20264 request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
20265 control_handle: BaseNetworkSocketControlHandle,
20266 },
20267 Close {
20278 responder: BaseNetworkSocketCloseResponder,
20279 },
20280 Query {
20281 responder: BaseNetworkSocketQueryResponder,
20282 },
20283 SetReuseAddress {
20285 value: bool,
20286 responder: BaseNetworkSocketSetReuseAddressResponder,
20287 },
20288 GetReuseAddress {
20290 responder: BaseNetworkSocketGetReuseAddressResponder,
20291 },
20292 GetError {
20295 responder: BaseNetworkSocketGetErrorResponder,
20296 },
20297 SetBroadcast {
20299 value: bool,
20300 responder: BaseNetworkSocketSetBroadcastResponder,
20301 },
20302 GetBroadcast {
20304 responder: BaseNetworkSocketGetBroadcastResponder,
20305 },
20306 SetSendBuffer {
20308 value_bytes: u64,
20309 responder: BaseNetworkSocketSetSendBufferResponder,
20310 },
20311 GetSendBuffer {
20313 responder: BaseNetworkSocketGetSendBufferResponder,
20314 },
20315 SetReceiveBuffer {
20317 value_bytes: u64,
20318 responder: BaseNetworkSocketSetReceiveBufferResponder,
20319 },
20320 GetReceiveBuffer {
20322 responder: BaseNetworkSocketGetReceiveBufferResponder,
20323 },
20324 SetKeepAlive {
20326 value: bool,
20327 responder: BaseNetworkSocketSetKeepAliveResponder,
20328 },
20329 GetKeepAlive {
20331 responder: BaseNetworkSocketGetKeepAliveResponder,
20332 },
20333 SetOutOfBandInline {
20335 value: bool,
20336 responder: BaseNetworkSocketSetOutOfBandInlineResponder,
20337 },
20338 GetOutOfBandInline {
20340 responder: BaseNetworkSocketGetOutOfBandInlineResponder,
20341 },
20342 SetNoCheck {
20344 value: bool,
20345 responder: BaseNetworkSocketSetNoCheckResponder,
20346 },
20347 GetNoCheck {
20349 responder: BaseNetworkSocketGetNoCheckResponder,
20350 },
20351 SetLinger {
20353 linger: bool,
20354 length_secs: u32,
20355 responder: BaseNetworkSocketSetLingerResponder,
20356 },
20357 GetLinger {
20359 responder: BaseNetworkSocketGetLingerResponder,
20360 },
20361 SetReusePort {
20363 value: bool,
20364 responder: BaseNetworkSocketSetReusePortResponder,
20365 },
20366 GetReusePort {
20368 responder: BaseNetworkSocketGetReusePortResponder,
20369 },
20370 GetAcceptConn {
20372 responder: BaseNetworkSocketGetAcceptConnResponder,
20373 },
20374 SetBindToDevice {
20376 value: String,
20377 responder: BaseNetworkSocketSetBindToDeviceResponder,
20378 },
20379 GetBindToDevice {
20381 responder: BaseNetworkSocketGetBindToDeviceResponder,
20382 },
20383 SetBindToInterfaceIndex {
20386 value: u64,
20387 responder: BaseNetworkSocketSetBindToInterfaceIndexResponder,
20388 },
20389 GetBindToInterfaceIndex {
20391 responder: BaseNetworkSocketGetBindToInterfaceIndexResponder,
20392 },
20393 SetTimestamp {
20395 value: TimestampOption,
20396 responder: BaseNetworkSocketSetTimestampResponder,
20397 },
20398 GetTimestamp {
20400 responder: BaseNetworkSocketGetTimestampResponder,
20401 },
20402 SetMark {
20406 domain: fidl_fuchsia_net::MarkDomain,
20407 mark: OptionalUint32,
20408 responder: BaseNetworkSocketSetMarkResponder,
20409 },
20410 GetMark {
20414 domain: fidl_fuchsia_net::MarkDomain,
20415 responder: BaseNetworkSocketGetMarkResponder,
20416 },
20417 Bind {
20419 addr: fidl_fuchsia_net::SocketAddress,
20420 responder: BaseNetworkSocketBindResponder,
20421 },
20422 Connect {
20424 addr: fidl_fuchsia_net::SocketAddress,
20425 responder: BaseNetworkSocketConnectResponder,
20426 },
20427 Disconnect {
20429 responder: BaseNetworkSocketDisconnectResponder,
20430 },
20431 GetSockName {
20433 responder: BaseNetworkSocketGetSockNameResponder,
20434 },
20435 GetPeerName {
20437 responder: BaseNetworkSocketGetPeerNameResponder,
20438 },
20439 Shutdown {
20441 mode: ShutdownMode,
20442 responder: BaseNetworkSocketShutdownResponder,
20443 },
20444 SetIpTypeOfService {
20446 value: u8,
20447 responder: BaseNetworkSocketSetIpTypeOfServiceResponder,
20448 },
20449 GetIpTypeOfService {
20451 responder: BaseNetworkSocketGetIpTypeOfServiceResponder,
20452 },
20453 SetIpTtl {
20455 value: OptionalUint8,
20456 responder: BaseNetworkSocketSetIpTtlResponder,
20457 },
20458 GetIpTtl {
20460 responder: BaseNetworkSocketGetIpTtlResponder,
20461 },
20462 SetIpPacketInfo {
20464 value: bool,
20465 responder: BaseNetworkSocketSetIpPacketInfoResponder,
20466 },
20467 GetIpPacketInfo {
20469 responder: BaseNetworkSocketGetIpPacketInfoResponder,
20470 },
20471 SetIpReceiveTypeOfService {
20473 value: bool,
20474 responder: BaseNetworkSocketSetIpReceiveTypeOfServiceResponder,
20475 },
20476 GetIpReceiveTypeOfService {
20478 responder: BaseNetworkSocketGetIpReceiveTypeOfServiceResponder,
20479 },
20480 SetIpReceiveTtl {
20482 value: bool,
20483 responder: BaseNetworkSocketSetIpReceiveTtlResponder,
20484 },
20485 GetIpReceiveTtl {
20487 responder: BaseNetworkSocketGetIpReceiveTtlResponder,
20488 },
20489 SetIpMulticastInterface {
20491 iface: u64,
20492 address: fidl_fuchsia_net::Ipv4Address,
20493 responder: BaseNetworkSocketSetIpMulticastInterfaceResponder,
20494 },
20495 GetIpMulticastInterface {
20497 responder: BaseNetworkSocketGetIpMulticastInterfaceResponder,
20498 },
20499 SetIpMulticastTtl {
20501 value: OptionalUint8,
20502 responder: BaseNetworkSocketSetIpMulticastTtlResponder,
20503 },
20504 GetIpMulticastTtl {
20506 responder: BaseNetworkSocketGetIpMulticastTtlResponder,
20507 },
20508 SetIpMulticastLoopback {
20510 value: bool,
20511 responder: BaseNetworkSocketSetIpMulticastLoopbackResponder,
20512 },
20513 GetIpMulticastLoopback {
20515 responder: BaseNetworkSocketGetIpMulticastLoopbackResponder,
20516 },
20517 AddIpMembership {
20519 membership: IpMulticastMembership,
20520 responder: BaseNetworkSocketAddIpMembershipResponder,
20521 },
20522 DropIpMembership {
20524 membership: IpMulticastMembership,
20525 responder: BaseNetworkSocketDropIpMembershipResponder,
20526 },
20527 SetIpTransparent {
20529 value: bool,
20530 responder: BaseNetworkSocketSetIpTransparentResponder,
20531 },
20532 GetIpTransparent {
20534 responder: BaseNetworkSocketGetIpTransparentResponder,
20535 },
20536 SetIpReceiveOriginalDestinationAddress {
20538 value: bool,
20539 responder: BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder,
20540 },
20541 GetIpReceiveOriginalDestinationAddress {
20543 responder: BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder,
20544 },
20545 AddIpv6Membership {
20547 membership: Ipv6MulticastMembership,
20548 responder: BaseNetworkSocketAddIpv6MembershipResponder,
20549 },
20550 DropIpv6Membership {
20552 membership: Ipv6MulticastMembership,
20553 responder: BaseNetworkSocketDropIpv6MembershipResponder,
20554 },
20555 SetIpv6MulticastInterface {
20557 value: u64,
20558 responder: BaseNetworkSocketSetIpv6MulticastInterfaceResponder,
20559 },
20560 GetIpv6MulticastInterface {
20562 responder: BaseNetworkSocketGetIpv6MulticastInterfaceResponder,
20563 },
20564 SetIpv6UnicastHops {
20566 value: OptionalUint8,
20567 responder: BaseNetworkSocketSetIpv6UnicastHopsResponder,
20568 },
20569 GetIpv6UnicastHops {
20571 responder: BaseNetworkSocketGetIpv6UnicastHopsResponder,
20572 },
20573 SetIpv6ReceiveHopLimit {
20575 value: bool,
20576 responder: BaseNetworkSocketSetIpv6ReceiveHopLimitResponder,
20577 },
20578 GetIpv6ReceiveHopLimit {
20580 responder: BaseNetworkSocketGetIpv6ReceiveHopLimitResponder,
20581 },
20582 SetIpv6MulticastHops {
20584 value: OptionalUint8,
20585 responder: BaseNetworkSocketSetIpv6MulticastHopsResponder,
20586 },
20587 GetIpv6MulticastHops {
20589 responder: BaseNetworkSocketGetIpv6MulticastHopsResponder,
20590 },
20591 SetIpv6MulticastLoopback {
20593 value: bool,
20594 responder: BaseNetworkSocketSetIpv6MulticastLoopbackResponder,
20595 },
20596 GetIpv6MulticastLoopback {
20598 responder: BaseNetworkSocketGetIpv6MulticastLoopbackResponder,
20599 },
20600 SetIpv6Only {
20602 value: bool,
20603 responder: BaseNetworkSocketSetIpv6OnlyResponder,
20604 },
20605 GetIpv6Only {
20607 responder: BaseNetworkSocketGetIpv6OnlyResponder,
20608 },
20609 SetIpv6ReceiveTrafficClass {
20611 value: bool,
20612 responder: BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder,
20613 },
20614 GetIpv6ReceiveTrafficClass {
20616 responder: BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder,
20617 },
20618 SetIpv6TrafficClass {
20620 value: OptionalUint8,
20621 responder: BaseNetworkSocketSetIpv6TrafficClassResponder,
20622 },
20623 GetIpv6TrafficClass {
20625 responder: BaseNetworkSocketGetIpv6TrafficClassResponder,
20626 },
20627 SetIpv6ReceivePacketInfo {
20629 value: bool,
20630 responder: BaseNetworkSocketSetIpv6ReceivePacketInfoResponder,
20631 },
20632 GetIpv6ReceivePacketInfo {
20634 responder: BaseNetworkSocketGetIpv6ReceivePacketInfoResponder,
20635 },
20636 GetOriginalDestination {
20638 responder: BaseNetworkSocketGetOriginalDestinationResponder,
20639 },
20640}
20641
20642impl BaseNetworkSocketRequest {
20643 #[allow(irrefutable_let_patterns)]
20644 pub fn into_clone(
20645 self,
20646 ) -> Option<(
20647 fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
20648 BaseNetworkSocketControlHandle,
20649 )> {
20650 if let BaseNetworkSocketRequest::Clone { request, control_handle } = self {
20651 Some((request, control_handle))
20652 } else {
20653 None
20654 }
20655 }
20656
20657 #[allow(irrefutable_let_patterns)]
20658 pub fn into_close(self) -> Option<(BaseNetworkSocketCloseResponder)> {
20659 if let BaseNetworkSocketRequest::Close { responder } = self {
20660 Some((responder))
20661 } else {
20662 None
20663 }
20664 }
20665
20666 #[allow(irrefutable_let_patterns)]
20667 pub fn into_query(self) -> Option<(BaseNetworkSocketQueryResponder)> {
20668 if let BaseNetworkSocketRequest::Query { responder } = self {
20669 Some((responder))
20670 } else {
20671 None
20672 }
20673 }
20674
20675 #[allow(irrefutable_let_patterns)]
20676 pub fn into_set_reuse_address(
20677 self,
20678 ) -> Option<(bool, BaseNetworkSocketSetReuseAddressResponder)> {
20679 if let BaseNetworkSocketRequest::SetReuseAddress { value, responder } = self {
20680 Some((value, responder))
20681 } else {
20682 None
20683 }
20684 }
20685
20686 #[allow(irrefutable_let_patterns)]
20687 pub fn into_get_reuse_address(self) -> Option<(BaseNetworkSocketGetReuseAddressResponder)> {
20688 if let BaseNetworkSocketRequest::GetReuseAddress { responder } = self {
20689 Some((responder))
20690 } else {
20691 None
20692 }
20693 }
20694
20695 #[allow(irrefutable_let_patterns)]
20696 pub fn into_get_error(self) -> Option<(BaseNetworkSocketGetErrorResponder)> {
20697 if let BaseNetworkSocketRequest::GetError { responder } = self {
20698 Some((responder))
20699 } else {
20700 None
20701 }
20702 }
20703
20704 #[allow(irrefutable_let_patterns)]
20705 pub fn into_set_broadcast(self) -> Option<(bool, BaseNetworkSocketSetBroadcastResponder)> {
20706 if let BaseNetworkSocketRequest::SetBroadcast { value, responder } = self {
20707 Some((value, responder))
20708 } else {
20709 None
20710 }
20711 }
20712
20713 #[allow(irrefutable_let_patterns)]
20714 pub fn into_get_broadcast(self) -> Option<(BaseNetworkSocketGetBroadcastResponder)> {
20715 if let BaseNetworkSocketRequest::GetBroadcast { responder } = self {
20716 Some((responder))
20717 } else {
20718 None
20719 }
20720 }
20721
20722 #[allow(irrefutable_let_patterns)]
20723 pub fn into_set_send_buffer(self) -> Option<(u64, BaseNetworkSocketSetSendBufferResponder)> {
20724 if let BaseNetworkSocketRequest::SetSendBuffer { value_bytes, responder } = self {
20725 Some((value_bytes, responder))
20726 } else {
20727 None
20728 }
20729 }
20730
20731 #[allow(irrefutable_let_patterns)]
20732 pub fn into_get_send_buffer(self) -> Option<(BaseNetworkSocketGetSendBufferResponder)> {
20733 if let BaseNetworkSocketRequest::GetSendBuffer { responder } = self {
20734 Some((responder))
20735 } else {
20736 None
20737 }
20738 }
20739
20740 #[allow(irrefutable_let_patterns)]
20741 pub fn into_set_receive_buffer(
20742 self,
20743 ) -> Option<(u64, BaseNetworkSocketSetReceiveBufferResponder)> {
20744 if let BaseNetworkSocketRequest::SetReceiveBuffer { value_bytes, responder } = self {
20745 Some((value_bytes, responder))
20746 } else {
20747 None
20748 }
20749 }
20750
20751 #[allow(irrefutable_let_patterns)]
20752 pub fn into_get_receive_buffer(self) -> Option<(BaseNetworkSocketGetReceiveBufferResponder)> {
20753 if let BaseNetworkSocketRequest::GetReceiveBuffer { responder } = self {
20754 Some((responder))
20755 } else {
20756 None
20757 }
20758 }
20759
20760 #[allow(irrefutable_let_patterns)]
20761 pub fn into_set_keep_alive(self) -> Option<(bool, BaseNetworkSocketSetKeepAliveResponder)> {
20762 if let BaseNetworkSocketRequest::SetKeepAlive { value, responder } = self {
20763 Some((value, responder))
20764 } else {
20765 None
20766 }
20767 }
20768
20769 #[allow(irrefutable_let_patterns)]
20770 pub fn into_get_keep_alive(self) -> Option<(BaseNetworkSocketGetKeepAliveResponder)> {
20771 if let BaseNetworkSocketRequest::GetKeepAlive { responder } = self {
20772 Some((responder))
20773 } else {
20774 None
20775 }
20776 }
20777
20778 #[allow(irrefutable_let_patterns)]
20779 pub fn into_set_out_of_band_inline(
20780 self,
20781 ) -> Option<(bool, BaseNetworkSocketSetOutOfBandInlineResponder)> {
20782 if let BaseNetworkSocketRequest::SetOutOfBandInline { value, responder } = self {
20783 Some((value, responder))
20784 } else {
20785 None
20786 }
20787 }
20788
20789 #[allow(irrefutable_let_patterns)]
20790 pub fn into_get_out_of_band_inline(
20791 self,
20792 ) -> Option<(BaseNetworkSocketGetOutOfBandInlineResponder)> {
20793 if let BaseNetworkSocketRequest::GetOutOfBandInline { responder } = self {
20794 Some((responder))
20795 } else {
20796 None
20797 }
20798 }
20799
20800 #[allow(irrefutable_let_patterns)]
20801 pub fn into_set_no_check(self) -> Option<(bool, BaseNetworkSocketSetNoCheckResponder)> {
20802 if let BaseNetworkSocketRequest::SetNoCheck { value, responder } = self {
20803 Some((value, responder))
20804 } else {
20805 None
20806 }
20807 }
20808
20809 #[allow(irrefutable_let_patterns)]
20810 pub fn into_get_no_check(self) -> Option<(BaseNetworkSocketGetNoCheckResponder)> {
20811 if let BaseNetworkSocketRequest::GetNoCheck { responder } = self {
20812 Some((responder))
20813 } else {
20814 None
20815 }
20816 }
20817
20818 #[allow(irrefutable_let_patterns)]
20819 pub fn into_set_linger(self) -> Option<(bool, u32, BaseNetworkSocketSetLingerResponder)> {
20820 if let BaseNetworkSocketRequest::SetLinger { linger, length_secs, responder } = self {
20821 Some((linger, length_secs, responder))
20822 } else {
20823 None
20824 }
20825 }
20826
20827 #[allow(irrefutable_let_patterns)]
20828 pub fn into_get_linger(self) -> Option<(BaseNetworkSocketGetLingerResponder)> {
20829 if let BaseNetworkSocketRequest::GetLinger { responder } = self {
20830 Some((responder))
20831 } else {
20832 None
20833 }
20834 }
20835
20836 #[allow(irrefutable_let_patterns)]
20837 pub fn into_set_reuse_port(self) -> Option<(bool, BaseNetworkSocketSetReusePortResponder)> {
20838 if let BaseNetworkSocketRequest::SetReusePort { value, responder } = self {
20839 Some((value, responder))
20840 } else {
20841 None
20842 }
20843 }
20844
20845 #[allow(irrefutable_let_patterns)]
20846 pub fn into_get_reuse_port(self) -> Option<(BaseNetworkSocketGetReusePortResponder)> {
20847 if let BaseNetworkSocketRequest::GetReusePort { responder } = self {
20848 Some((responder))
20849 } else {
20850 None
20851 }
20852 }
20853
20854 #[allow(irrefutable_let_patterns)]
20855 pub fn into_get_accept_conn(self) -> Option<(BaseNetworkSocketGetAcceptConnResponder)> {
20856 if let BaseNetworkSocketRequest::GetAcceptConn { responder } = self {
20857 Some((responder))
20858 } else {
20859 None
20860 }
20861 }
20862
20863 #[allow(irrefutable_let_patterns)]
20864 pub fn into_set_bind_to_device(
20865 self,
20866 ) -> Option<(String, BaseNetworkSocketSetBindToDeviceResponder)> {
20867 if let BaseNetworkSocketRequest::SetBindToDevice { value, responder } = self {
20868 Some((value, responder))
20869 } else {
20870 None
20871 }
20872 }
20873
20874 #[allow(irrefutable_let_patterns)]
20875 pub fn into_get_bind_to_device(self) -> Option<(BaseNetworkSocketGetBindToDeviceResponder)> {
20876 if let BaseNetworkSocketRequest::GetBindToDevice { responder } = self {
20877 Some((responder))
20878 } else {
20879 None
20880 }
20881 }
20882
20883 #[allow(irrefutable_let_patterns)]
20884 pub fn into_set_bind_to_interface_index(
20885 self,
20886 ) -> Option<(u64, BaseNetworkSocketSetBindToInterfaceIndexResponder)> {
20887 if let BaseNetworkSocketRequest::SetBindToInterfaceIndex { value, responder } = self {
20888 Some((value, responder))
20889 } else {
20890 None
20891 }
20892 }
20893
20894 #[allow(irrefutable_let_patterns)]
20895 pub fn into_get_bind_to_interface_index(
20896 self,
20897 ) -> Option<(BaseNetworkSocketGetBindToInterfaceIndexResponder)> {
20898 if let BaseNetworkSocketRequest::GetBindToInterfaceIndex { responder } = self {
20899 Some((responder))
20900 } else {
20901 None
20902 }
20903 }
20904
20905 #[allow(irrefutable_let_patterns)]
20906 pub fn into_set_timestamp(
20907 self,
20908 ) -> Option<(TimestampOption, BaseNetworkSocketSetTimestampResponder)> {
20909 if let BaseNetworkSocketRequest::SetTimestamp { value, responder } = self {
20910 Some((value, responder))
20911 } else {
20912 None
20913 }
20914 }
20915
20916 #[allow(irrefutable_let_patterns)]
20917 pub fn into_get_timestamp(self) -> Option<(BaseNetworkSocketGetTimestampResponder)> {
20918 if let BaseNetworkSocketRequest::GetTimestamp { responder } = self {
20919 Some((responder))
20920 } else {
20921 None
20922 }
20923 }
20924
20925 #[allow(irrefutable_let_patterns)]
20926 pub fn into_set_mark(
20927 self,
20928 ) -> Option<(fidl_fuchsia_net::MarkDomain, OptionalUint32, BaseNetworkSocketSetMarkResponder)>
20929 {
20930 if let BaseNetworkSocketRequest::SetMark { domain, mark, responder } = self {
20931 Some((domain, mark, responder))
20932 } else {
20933 None
20934 }
20935 }
20936
20937 #[allow(irrefutable_let_patterns)]
20938 pub fn into_get_mark(
20939 self,
20940 ) -> Option<(fidl_fuchsia_net::MarkDomain, BaseNetworkSocketGetMarkResponder)> {
20941 if let BaseNetworkSocketRequest::GetMark { domain, responder } = self {
20942 Some((domain, responder))
20943 } else {
20944 None
20945 }
20946 }
20947
20948 #[allow(irrefutable_let_patterns)]
20949 pub fn into_bind(
20950 self,
20951 ) -> Option<(fidl_fuchsia_net::SocketAddress, BaseNetworkSocketBindResponder)> {
20952 if let BaseNetworkSocketRequest::Bind { addr, responder } = self {
20953 Some((addr, responder))
20954 } else {
20955 None
20956 }
20957 }
20958
20959 #[allow(irrefutable_let_patterns)]
20960 pub fn into_connect(
20961 self,
20962 ) -> Option<(fidl_fuchsia_net::SocketAddress, BaseNetworkSocketConnectResponder)> {
20963 if let BaseNetworkSocketRequest::Connect { addr, responder } = self {
20964 Some((addr, responder))
20965 } else {
20966 None
20967 }
20968 }
20969
20970 #[allow(irrefutable_let_patterns)]
20971 pub fn into_disconnect(self) -> Option<(BaseNetworkSocketDisconnectResponder)> {
20972 if let BaseNetworkSocketRequest::Disconnect { responder } = self {
20973 Some((responder))
20974 } else {
20975 None
20976 }
20977 }
20978
20979 #[allow(irrefutable_let_patterns)]
20980 pub fn into_get_sock_name(self) -> Option<(BaseNetworkSocketGetSockNameResponder)> {
20981 if let BaseNetworkSocketRequest::GetSockName { responder } = self {
20982 Some((responder))
20983 } else {
20984 None
20985 }
20986 }
20987
20988 #[allow(irrefutable_let_patterns)]
20989 pub fn into_get_peer_name(self) -> Option<(BaseNetworkSocketGetPeerNameResponder)> {
20990 if let BaseNetworkSocketRequest::GetPeerName { responder } = self {
20991 Some((responder))
20992 } else {
20993 None
20994 }
20995 }
20996
20997 #[allow(irrefutable_let_patterns)]
20998 pub fn into_shutdown(self) -> Option<(ShutdownMode, BaseNetworkSocketShutdownResponder)> {
20999 if let BaseNetworkSocketRequest::Shutdown { mode, responder } = self {
21000 Some((mode, responder))
21001 } else {
21002 None
21003 }
21004 }
21005
21006 #[allow(irrefutable_let_patterns)]
21007 pub fn into_set_ip_type_of_service(
21008 self,
21009 ) -> Option<(u8, BaseNetworkSocketSetIpTypeOfServiceResponder)> {
21010 if let BaseNetworkSocketRequest::SetIpTypeOfService { value, responder } = self {
21011 Some((value, responder))
21012 } else {
21013 None
21014 }
21015 }
21016
21017 #[allow(irrefutable_let_patterns)]
21018 pub fn into_get_ip_type_of_service(
21019 self,
21020 ) -> Option<(BaseNetworkSocketGetIpTypeOfServiceResponder)> {
21021 if let BaseNetworkSocketRequest::GetIpTypeOfService { responder } = self {
21022 Some((responder))
21023 } else {
21024 None
21025 }
21026 }
21027
21028 #[allow(irrefutable_let_patterns)]
21029 pub fn into_set_ip_ttl(self) -> Option<(OptionalUint8, BaseNetworkSocketSetIpTtlResponder)> {
21030 if let BaseNetworkSocketRequest::SetIpTtl { value, responder } = self {
21031 Some((value, responder))
21032 } else {
21033 None
21034 }
21035 }
21036
21037 #[allow(irrefutable_let_patterns)]
21038 pub fn into_get_ip_ttl(self) -> Option<(BaseNetworkSocketGetIpTtlResponder)> {
21039 if let BaseNetworkSocketRequest::GetIpTtl { responder } = self {
21040 Some((responder))
21041 } else {
21042 None
21043 }
21044 }
21045
21046 #[allow(irrefutable_let_patterns)]
21047 pub fn into_set_ip_packet_info(
21048 self,
21049 ) -> Option<(bool, BaseNetworkSocketSetIpPacketInfoResponder)> {
21050 if let BaseNetworkSocketRequest::SetIpPacketInfo { value, responder } = self {
21051 Some((value, responder))
21052 } else {
21053 None
21054 }
21055 }
21056
21057 #[allow(irrefutable_let_patterns)]
21058 pub fn into_get_ip_packet_info(self) -> Option<(BaseNetworkSocketGetIpPacketInfoResponder)> {
21059 if let BaseNetworkSocketRequest::GetIpPacketInfo { responder } = self {
21060 Some((responder))
21061 } else {
21062 None
21063 }
21064 }
21065
21066 #[allow(irrefutable_let_patterns)]
21067 pub fn into_set_ip_receive_type_of_service(
21068 self,
21069 ) -> Option<(bool, BaseNetworkSocketSetIpReceiveTypeOfServiceResponder)> {
21070 if let BaseNetworkSocketRequest::SetIpReceiveTypeOfService { value, responder } = self {
21071 Some((value, responder))
21072 } else {
21073 None
21074 }
21075 }
21076
21077 #[allow(irrefutable_let_patterns)]
21078 pub fn into_get_ip_receive_type_of_service(
21079 self,
21080 ) -> Option<(BaseNetworkSocketGetIpReceiveTypeOfServiceResponder)> {
21081 if let BaseNetworkSocketRequest::GetIpReceiveTypeOfService { responder } = self {
21082 Some((responder))
21083 } else {
21084 None
21085 }
21086 }
21087
21088 #[allow(irrefutable_let_patterns)]
21089 pub fn into_set_ip_receive_ttl(
21090 self,
21091 ) -> Option<(bool, BaseNetworkSocketSetIpReceiveTtlResponder)> {
21092 if let BaseNetworkSocketRequest::SetIpReceiveTtl { value, responder } = self {
21093 Some((value, responder))
21094 } else {
21095 None
21096 }
21097 }
21098
21099 #[allow(irrefutable_let_patterns)]
21100 pub fn into_get_ip_receive_ttl(self) -> Option<(BaseNetworkSocketGetIpReceiveTtlResponder)> {
21101 if let BaseNetworkSocketRequest::GetIpReceiveTtl { responder } = self {
21102 Some((responder))
21103 } else {
21104 None
21105 }
21106 }
21107
21108 #[allow(irrefutable_let_patterns)]
21109 pub fn into_set_ip_multicast_interface(
21110 self,
21111 ) -> Option<(
21112 u64,
21113 fidl_fuchsia_net::Ipv4Address,
21114 BaseNetworkSocketSetIpMulticastInterfaceResponder,
21115 )> {
21116 if let BaseNetworkSocketRequest::SetIpMulticastInterface { iface, address, responder } =
21117 self
21118 {
21119 Some((iface, address, responder))
21120 } else {
21121 None
21122 }
21123 }
21124
21125 #[allow(irrefutable_let_patterns)]
21126 pub fn into_get_ip_multicast_interface(
21127 self,
21128 ) -> Option<(BaseNetworkSocketGetIpMulticastInterfaceResponder)> {
21129 if let BaseNetworkSocketRequest::GetIpMulticastInterface { responder } = self {
21130 Some((responder))
21131 } else {
21132 None
21133 }
21134 }
21135
21136 #[allow(irrefutable_let_patterns)]
21137 pub fn into_set_ip_multicast_ttl(
21138 self,
21139 ) -> Option<(OptionalUint8, BaseNetworkSocketSetIpMulticastTtlResponder)> {
21140 if let BaseNetworkSocketRequest::SetIpMulticastTtl { value, responder } = self {
21141 Some((value, responder))
21142 } else {
21143 None
21144 }
21145 }
21146
21147 #[allow(irrefutable_let_patterns)]
21148 pub fn into_get_ip_multicast_ttl(
21149 self,
21150 ) -> Option<(BaseNetworkSocketGetIpMulticastTtlResponder)> {
21151 if let BaseNetworkSocketRequest::GetIpMulticastTtl { responder } = self {
21152 Some((responder))
21153 } else {
21154 None
21155 }
21156 }
21157
21158 #[allow(irrefutable_let_patterns)]
21159 pub fn into_set_ip_multicast_loopback(
21160 self,
21161 ) -> Option<(bool, BaseNetworkSocketSetIpMulticastLoopbackResponder)> {
21162 if let BaseNetworkSocketRequest::SetIpMulticastLoopback { value, responder } = self {
21163 Some((value, responder))
21164 } else {
21165 None
21166 }
21167 }
21168
21169 #[allow(irrefutable_let_patterns)]
21170 pub fn into_get_ip_multicast_loopback(
21171 self,
21172 ) -> Option<(BaseNetworkSocketGetIpMulticastLoopbackResponder)> {
21173 if let BaseNetworkSocketRequest::GetIpMulticastLoopback { responder } = self {
21174 Some((responder))
21175 } else {
21176 None
21177 }
21178 }
21179
21180 #[allow(irrefutable_let_patterns)]
21181 pub fn into_add_ip_membership(
21182 self,
21183 ) -> Option<(IpMulticastMembership, BaseNetworkSocketAddIpMembershipResponder)> {
21184 if let BaseNetworkSocketRequest::AddIpMembership { membership, responder } = self {
21185 Some((membership, responder))
21186 } else {
21187 None
21188 }
21189 }
21190
21191 #[allow(irrefutable_let_patterns)]
21192 pub fn into_drop_ip_membership(
21193 self,
21194 ) -> Option<(IpMulticastMembership, BaseNetworkSocketDropIpMembershipResponder)> {
21195 if let BaseNetworkSocketRequest::DropIpMembership { membership, responder } = self {
21196 Some((membership, responder))
21197 } else {
21198 None
21199 }
21200 }
21201
21202 #[allow(irrefutable_let_patterns)]
21203 pub fn into_set_ip_transparent(
21204 self,
21205 ) -> Option<(bool, BaseNetworkSocketSetIpTransparentResponder)> {
21206 if let BaseNetworkSocketRequest::SetIpTransparent { value, responder } = self {
21207 Some((value, responder))
21208 } else {
21209 None
21210 }
21211 }
21212
21213 #[allow(irrefutable_let_patterns)]
21214 pub fn into_get_ip_transparent(self) -> Option<(BaseNetworkSocketGetIpTransparentResponder)> {
21215 if let BaseNetworkSocketRequest::GetIpTransparent { responder } = self {
21216 Some((responder))
21217 } else {
21218 None
21219 }
21220 }
21221
21222 #[allow(irrefutable_let_patterns)]
21223 pub fn into_set_ip_receive_original_destination_address(
21224 self,
21225 ) -> Option<(bool, BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder)> {
21226 if let BaseNetworkSocketRequest::SetIpReceiveOriginalDestinationAddress {
21227 value,
21228 responder,
21229 } = self
21230 {
21231 Some((value, responder))
21232 } else {
21233 None
21234 }
21235 }
21236
21237 #[allow(irrefutable_let_patterns)]
21238 pub fn into_get_ip_receive_original_destination_address(
21239 self,
21240 ) -> Option<(BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder)> {
21241 if let BaseNetworkSocketRequest::GetIpReceiveOriginalDestinationAddress { responder } = self
21242 {
21243 Some((responder))
21244 } else {
21245 None
21246 }
21247 }
21248
21249 #[allow(irrefutable_let_patterns)]
21250 pub fn into_add_ipv6_membership(
21251 self,
21252 ) -> Option<(Ipv6MulticastMembership, BaseNetworkSocketAddIpv6MembershipResponder)> {
21253 if let BaseNetworkSocketRequest::AddIpv6Membership { membership, responder } = self {
21254 Some((membership, responder))
21255 } else {
21256 None
21257 }
21258 }
21259
21260 #[allow(irrefutable_let_patterns)]
21261 pub fn into_drop_ipv6_membership(
21262 self,
21263 ) -> Option<(Ipv6MulticastMembership, BaseNetworkSocketDropIpv6MembershipResponder)> {
21264 if let BaseNetworkSocketRequest::DropIpv6Membership { membership, responder } = self {
21265 Some((membership, responder))
21266 } else {
21267 None
21268 }
21269 }
21270
21271 #[allow(irrefutable_let_patterns)]
21272 pub fn into_set_ipv6_multicast_interface(
21273 self,
21274 ) -> Option<(u64, BaseNetworkSocketSetIpv6MulticastInterfaceResponder)> {
21275 if let BaseNetworkSocketRequest::SetIpv6MulticastInterface { value, responder } = self {
21276 Some((value, responder))
21277 } else {
21278 None
21279 }
21280 }
21281
21282 #[allow(irrefutable_let_patterns)]
21283 pub fn into_get_ipv6_multicast_interface(
21284 self,
21285 ) -> Option<(BaseNetworkSocketGetIpv6MulticastInterfaceResponder)> {
21286 if let BaseNetworkSocketRequest::GetIpv6MulticastInterface { responder } = self {
21287 Some((responder))
21288 } else {
21289 None
21290 }
21291 }
21292
21293 #[allow(irrefutable_let_patterns)]
21294 pub fn into_set_ipv6_unicast_hops(
21295 self,
21296 ) -> Option<(OptionalUint8, BaseNetworkSocketSetIpv6UnicastHopsResponder)> {
21297 if let BaseNetworkSocketRequest::SetIpv6UnicastHops { value, responder } = self {
21298 Some((value, responder))
21299 } else {
21300 None
21301 }
21302 }
21303
21304 #[allow(irrefutable_let_patterns)]
21305 pub fn into_get_ipv6_unicast_hops(
21306 self,
21307 ) -> Option<(BaseNetworkSocketGetIpv6UnicastHopsResponder)> {
21308 if let BaseNetworkSocketRequest::GetIpv6UnicastHops { responder } = self {
21309 Some((responder))
21310 } else {
21311 None
21312 }
21313 }
21314
21315 #[allow(irrefutable_let_patterns)]
21316 pub fn into_set_ipv6_receive_hop_limit(
21317 self,
21318 ) -> Option<(bool, BaseNetworkSocketSetIpv6ReceiveHopLimitResponder)> {
21319 if let BaseNetworkSocketRequest::SetIpv6ReceiveHopLimit { value, responder } = self {
21320 Some((value, responder))
21321 } else {
21322 None
21323 }
21324 }
21325
21326 #[allow(irrefutable_let_patterns)]
21327 pub fn into_get_ipv6_receive_hop_limit(
21328 self,
21329 ) -> Option<(BaseNetworkSocketGetIpv6ReceiveHopLimitResponder)> {
21330 if let BaseNetworkSocketRequest::GetIpv6ReceiveHopLimit { responder } = self {
21331 Some((responder))
21332 } else {
21333 None
21334 }
21335 }
21336
21337 #[allow(irrefutable_let_patterns)]
21338 pub fn into_set_ipv6_multicast_hops(
21339 self,
21340 ) -> Option<(OptionalUint8, BaseNetworkSocketSetIpv6MulticastHopsResponder)> {
21341 if let BaseNetworkSocketRequest::SetIpv6MulticastHops { value, responder } = self {
21342 Some((value, responder))
21343 } else {
21344 None
21345 }
21346 }
21347
21348 #[allow(irrefutable_let_patterns)]
21349 pub fn into_get_ipv6_multicast_hops(
21350 self,
21351 ) -> Option<(BaseNetworkSocketGetIpv6MulticastHopsResponder)> {
21352 if let BaseNetworkSocketRequest::GetIpv6MulticastHops { responder } = self {
21353 Some((responder))
21354 } else {
21355 None
21356 }
21357 }
21358
21359 #[allow(irrefutable_let_patterns)]
21360 pub fn into_set_ipv6_multicast_loopback(
21361 self,
21362 ) -> Option<(bool, BaseNetworkSocketSetIpv6MulticastLoopbackResponder)> {
21363 if let BaseNetworkSocketRequest::SetIpv6MulticastLoopback { value, responder } = self {
21364 Some((value, responder))
21365 } else {
21366 None
21367 }
21368 }
21369
21370 #[allow(irrefutable_let_patterns)]
21371 pub fn into_get_ipv6_multicast_loopback(
21372 self,
21373 ) -> Option<(BaseNetworkSocketGetIpv6MulticastLoopbackResponder)> {
21374 if let BaseNetworkSocketRequest::GetIpv6MulticastLoopback { responder } = self {
21375 Some((responder))
21376 } else {
21377 None
21378 }
21379 }
21380
21381 #[allow(irrefutable_let_patterns)]
21382 pub fn into_set_ipv6_only(self) -> Option<(bool, BaseNetworkSocketSetIpv6OnlyResponder)> {
21383 if let BaseNetworkSocketRequest::SetIpv6Only { value, responder } = self {
21384 Some((value, responder))
21385 } else {
21386 None
21387 }
21388 }
21389
21390 #[allow(irrefutable_let_patterns)]
21391 pub fn into_get_ipv6_only(self) -> Option<(BaseNetworkSocketGetIpv6OnlyResponder)> {
21392 if let BaseNetworkSocketRequest::GetIpv6Only { responder } = self {
21393 Some((responder))
21394 } else {
21395 None
21396 }
21397 }
21398
21399 #[allow(irrefutable_let_patterns)]
21400 pub fn into_set_ipv6_receive_traffic_class(
21401 self,
21402 ) -> Option<(bool, BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder)> {
21403 if let BaseNetworkSocketRequest::SetIpv6ReceiveTrafficClass { value, responder } = self {
21404 Some((value, responder))
21405 } else {
21406 None
21407 }
21408 }
21409
21410 #[allow(irrefutable_let_patterns)]
21411 pub fn into_get_ipv6_receive_traffic_class(
21412 self,
21413 ) -> Option<(BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder)> {
21414 if let BaseNetworkSocketRequest::GetIpv6ReceiveTrafficClass { responder } = self {
21415 Some((responder))
21416 } else {
21417 None
21418 }
21419 }
21420
21421 #[allow(irrefutable_let_patterns)]
21422 pub fn into_set_ipv6_traffic_class(
21423 self,
21424 ) -> Option<(OptionalUint8, BaseNetworkSocketSetIpv6TrafficClassResponder)> {
21425 if let BaseNetworkSocketRequest::SetIpv6TrafficClass { value, responder } = self {
21426 Some((value, responder))
21427 } else {
21428 None
21429 }
21430 }
21431
21432 #[allow(irrefutable_let_patterns)]
21433 pub fn into_get_ipv6_traffic_class(
21434 self,
21435 ) -> Option<(BaseNetworkSocketGetIpv6TrafficClassResponder)> {
21436 if let BaseNetworkSocketRequest::GetIpv6TrafficClass { responder } = self {
21437 Some((responder))
21438 } else {
21439 None
21440 }
21441 }
21442
21443 #[allow(irrefutable_let_patterns)]
21444 pub fn into_set_ipv6_receive_packet_info(
21445 self,
21446 ) -> Option<(bool, BaseNetworkSocketSetIpv6ReceivePacketInfoResponder)> {
21447 if let BaseNetworkSocketRequest::SetIpv6ReceivePacketInfo { value, responder } = self {
21448 Some((value, responder))
21449 } else {
21450 None
21451 }
21452 }
21453
21454 #[allow(irrefutable_let_patterns)]
21455 pub fn into_get_ipv6_receive_packet_info(
21456 self,
21457 ) -> Option<(BaseNetworkSocketGetIpv6ReceivePacketInfoResponder)> {
21458 if let BaseNetworkSocketRequest::GetIpv6ReceivePacketInfo { responder } = self {
21459 Some((responder))
21460 } else {
21461 None
21462 }
21463 }
21464
21465 #[allow(irrefutable_let_patterns)]
21466 pub fn into_get_original_destination(
21467 self,
21468 ) -> Option<(BaseNetworkSocketGetOriginalDestinationResponder)> {
21469 if let BaseNetworkSocketRequest::GetOriginalDestination { responder } = self {
21470 Some((responder))
21471 } else {
21472 None
21473 }
21474 }
21475
21476 pub fn method_name(&self) -> &'static str {
21478 match *self {
21479 BaseNetworkSocketRequest::Clone { .. } => "clone",
21480 BaseNetworkSocketRequest::Close { .. } => "close",
21481 BaseNetworkSocketRequest::Query { .. } => "query",
21482 BaseNetworkSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
21483 BaseNetworkSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
21484 BaseNetworkSocketRequest::GetError { .. } => "get_error",
21485 BaseNetworkSocketRequest::SetBroadcast { .. } => "set_broadcast",
21486 BaseNetworkSocketRequest::GetBroadcast { .. } => "get_broadcast",
21487 BaseNetworkSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
21488 BaseNetworkSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
21489 BaseNetworkSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
21490 BaseNetworkSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
21491 BaseNetworkSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
21492 BaseNetworkSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
21493 BaseNetworkSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
21494 BaseNetworkSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
21495 BaseNetworkSocketRequest::SetNoCheck { .. } => "set_no_check",
21496 BaseNetworkSocketRequest::GetNoCheck { .. } => "get_no_check",
21497 BaseNetworkSocketRequest::SetLinger { .. } => "set_linger",
21498 BaseNetworkSocketRequest::GetLinger { .. } => "get_linger",
21499 BaseNetworkSocketRequest::SetReusePort { .. } => "set_reuse_port",
21500 BaseNetworkSocketRequest::GetReusePort { .. } => "get_reuse_port",
21501 BaseNetworkSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
21502 BaseNetworkSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
21503 BaseNetworkSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
21504 BaseNetworkSocketRequest::SetBindToInterfaceIndex { .. } => {
21505 "set_bind_to_interface_index"
21506 }
21507 BaseNetworkSocketRequest::GetBindToInterfaceIndex { .. } => {
21508 "get_bind_to_interface_index"
21509 }
21510 BaseNetworkSocketRequest::SetTimestamp { .. } => "set_timestamp",
21511 BaseNetworkSocketRequest::GetTimestamp { .. } => "get_timestamp",
21512 BaseNetworkSocketRequest::SetMark { .. } => "set_mark",
21513 BaseNetworkSocketRequest::GetMark { .. } => "get_mark",
21514 BaseNetworkSocketRequest::Bind { .. } => "bind",
21515 BaseNetworkSocketRequest::Connect { .. } => "connect",
21516 BaseNetworkSocketRequest::Disconnect { .. } => "disconnect",
21517 BaseNetworkSocketRequest::GetSockName { .. } => "get_sock_name",
21518 BaseNetworkSocketRequest::GetPeerName { .. } => "get_peer_name",
21519 BaseNetworkSocketRequest::Shutdown { .. } => "shutdown",
21520 BaseNetworkSocketRequest::SetIpTypeOfService { .. } => "set_ip_type_of_service",
21521 BaseNetworkSocketRequest::GetIpTypeOfService { .. } => "get_ip_type_of_service",
21522 BaseNetworkSocketRequest::SetIpTtl { .. } => "set_ip_ttl",
21523 BaseNetworkSocketRequest::GetIpTtl { .. } => "get_ip_ttl",
21524 BaseNetworkSocketRequest::SetIpPacketInfo { .. } => "set_ip_packet_info",
21525 BaseNetworkSocketRequest::GetIpPacketInfo { .. } => "get_ip_packet_info",
21526 BaseNetworkSocketRequest::SetIpReceiveTypeOfService { .. } => {
21527 "set_ip_receive_type_of_service"
21528 }
21529 BaseNetworkSocketRequest::GetIpReceiveTypeOfService { .. } => {
21530 "get_ip_receive_type_of_service"
21531 }
21532 BaseNetworkSocketRequest::SetIpReceiveTtl { .. } => "set_ip_receive_ttl",
21533 BaseNetworkSocketRequest::GetIpReceiveTtl { .. } => "get_ip_receive_ttl",
21534 BaseNetworkSocketRequest::SetIpMulticastInterface { .. } => {
21535 "set_ip_multicast_interface"
21536 }
21537 BaseNetworkSocketRequest::GetIpMulticastInterface { .. } => {
21538 "get_ip_multicast_interface"
21539 }
21540 BaseNetworkSocketRequest::SetIpMulticastTtl { .. } => "set_ip_multicast_ttl",
21541 BaseNetworkSocketRequest::GetIpMulticastTtl { .. } => "get_ip_multicast_ttl",
21542 BaseNetworkSocketRequest::SetIpMulticastLoopback { .. } => "set_ip_multicast_loopback",
21543 BaseNetworkSocketRequest::GetIpMulticastLoopback { .. } => "get_ip_multicast_loopback",
21544 BaseNetworkSocketRequest::AddIpMembership { .. } => "add_ip_membership",
21545 BaseNetworkSocketRequest::DropIpMembership { .. } => "drop_ip_membership",
21546 BaseNetworkSocketRequest::SetIpTransparent { .. } => "set_ip_transparent",
21547 BaseNetworkSocketRequest::GetIpTransparent { .. } => "get_ip_transparent",
21548 BaseNetworkSocketRequest::SetIpReceiveOriginalDestinationAddress { .. } => {
21549 "set_ip_receive_original_destination_address"
21550 }
21551 BaseNetworkSocketRequest::GetIpReceiveOriginalDestinationAddress { .. } => {
21552 "get_ip_receive_original_destination_address"
21553 }
21554 BaseNetworkSocketRequest::AddIpv6Membership { .. } => "add_ipv6_membership",
21555 BaseNetworkSocketRequest::DropIpv6Membership { .. } => "drop_ipv6_membership",
21556 BaseNetworkSocketRequest::SetIpv6MulticastInterface { .. } => {
21557 "set_ipv6_multicast_interface"
21558 }
21559 BaseNetworkSocketRequest::GetIpv6MulticastInterface { .. } => {
21560 "get_ipv6_multicast_interface"
21561 }
21562 BaseNetworkSocketRequest::SetIpv6UnicastHops { .. } => "set_ipv6_unicast_hops",
21563 BaseNetworkSocketRequest::GetIpv6UnicastHops { .. } => "get_ipv6_unicast_hops",
21564 BaseNetworkSocketRequest::SetIpv6ReceiveHopLimit { .. } => "set_ipv6_receive_hop_limit",
21565 BaseNetworkSocketRequest::GetIpv6ReceiveHopLimit { .. } => "get_ipv6_receive_hop_limit",
21566 BaseNetworkSocketRequest::SetIpv6MulticastHops { .. } => "set_ipv6_multicast_hops",
21567 BaseNetworkSocketRequest::GetIpv6MulticastHops { .. } => "get_ipv6_multicast_hops",
21568 BaseNetworkSocketRequest::SetIpv6MulticastLoopback { .. } => {
21569 "set_ipv6_multicast_loopback"
21570 }
21571 BaseNetworkSocketRequest::GetIpv6MulticastLoopback { .. } => {
21572 "get_ipv6_multicast_loopback"
21573 }
21574 BaseNetworkSocketRequest::SetIpv6Only { .. } => "set_ipv6_only",
21575 BaseNetworkSocketRequest::GetIpv6Only { .. } => "get_ipv6_only",
21576 BaseNetworkSocketRequest::SetIpv6ReceiveTrafficClass { .. } => {
21577 "set_ipv6_receive_traffic_class"
21578 }
21579 BaseNetworkSocketRequest::GetIpv6ReceiveTrafficClass { .. } => {
21580 "get_ipv6_receive_traffic_class"
21581 }
21582 BaseNetworkSocketRequest::SetIpv6TrafficClass { .. } => "set_ipv6_traffic_class",
21583 BaseNetworkSocketRequest::GetIpv6TrafficClass { .. } => "get_ipv6_traffic_class",
21584 BaseNetworkSocketRequest::SetIpv6ReceivePacketInfo { .. } => {
21585 "set_ipv6_receive_packet_info"
21586 }
21587 BaseNetworkSocketRequest::GetIpv6ReceivePacketInfo { .. } => {
21588 "get_ipv6_receive_packet_info"
21589 }
21590 BaseNetworkSocketRequest::GetOriginalDestination { .. } => "get_original_destination",
21591 }
21592 }
21593}
21594
21595#[derive(Debug, Clone)]
21596pub struct BaseNetworkSocketControlHandle {
21597 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
21598}
21599
21600impl fidl::endpoints::ControlHandle for BaseNetworkSocketControlHandle {
21601 fn shutdown(&self) {
21602 self.inner.shutdown()
21603 }
21604 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
21605 self.inner.shutdown_with_epitaph(status)
21606 }
21607
21608 fn is_closed(&self) -> bool {
21609 self.inner.channel().is_closed()
21610 }
21611 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
21612 self.inner.channel().on_closed()
21613 }
21614
21615 #[cfg(target_os = "fuchsia")]
21616 fn signal_peer(
21617 &self,
21618 clear_mask: zx::Signals,
21619 set_mask: zx::Signals,
21620 ) -> Result<(), zx_status::Status> {
21621 use fidl::Peered;
21622 self.inner.channel().signal_peer(clear_mask, set_mask)
21623 }
21624}
21625
21626impl BaseNetworkSocketControlHandle {}
21627
21628#[must_use = "FIDL methods require a response to be sent"]
21629#[derive(Debug)]
21630pub struct BaseNetworkSocketCloseResponder {
21631 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
21632 tx_id: u32,
21633}
21634
21635impl std::ops::Drop for BaseNetworkSocketCloseResponder {
21639 fn drop(&mut self) {
21640 self.control_handle.shutdown();
21641 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21643 }
21644}
21645
21646impl fidl::endpoints::Responder for BaseNetworkSocketCloseResponder {
21647 type ControlHandle = BaseNetworkSocketControlHandle;
21648
21649 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
21650 &self.control_handle
21651 }
21652
21653 fn drop_without_shutdown(mut self) {
21654 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21656 std::mem::forget(self);
21658 }
21659}
21660
21661impl BaseNetworkSocketCloseResponder {
21662 pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
21666 let _result = self.send_raw(result);
21667 if _result.is_err() {
21668 self.control_handle.shutdown();
21669 }
21670 self.drop_without_shutdown();
21671 _result
21672 }
21673
21674 pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
21676 let _result = self.send_raw(result);
21677 self.drop_without_shutdown();
21678 _result
21679 }
21680
21681 fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
21682 self.control_handle
21683 .inner
21684 .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
21685 result,
21686 self.tx_id,
21687 0x5ac5d459ad7f657e,
21688 fidl::encoding::DynamicFlags::empty(),
21689 )
21690 }
21691}
21692
21693#[must_use = "FIDL methods require a response to be sent"]
21694#[derive(Debug)]
21695pub struct BaseNetworkSocketQueryResponder {
21696 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
21697 tx_id: u32,
21698}
21699
21700impl std::ops::Drop for BaseNetworkSocketQueryResponder {
21704 fn drop(&mut self) {
21705 self.control_handle.shutdown();
21706 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21708 }
21709}
21710
21711impl fidl::endpoints::Responder for BaseNetworkSocketQueryResponder {
21712 type ControlHandle = BaseNetworkSocketControlHandle;
21713
21714 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
21715 &self.control_handle
21716 }
21717
21718 fn drop_without_shutdown(mut self) {
21719 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21721 std::mem::forget(self);
21723 }
21724}
21725
21726impl BaseNetworkSocketQueryResponder {
21727 pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
21731 let _result = self.send_raw(protocol);
21732 if _result.is_err() {
21733 self.control_handle.shutdown();
21734 }
21735 self.drop_without_shutdown();
21736 _result
21737 }
21738
21739 pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
21741 let _result = self.send_raw(protocol);
21742 self.drop_without_shutdown();
21743 _result
21744 }
21745
21746 fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
21747 self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
21748 (protocol,),
21749 self.tx_id,
21750 0x2658edee9decfc06,
21751 fidl::encoding::DynamicFlags::empty(),
21752 )
21753 }
21754}
21755
21756#[must_use = "FIDL methods require a response to be sent"]
21757#[derive(Debug)]
21758pub struct BaseNetworkSocketSetReuseAddressResponder {
21759 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
21760 tx_id: u32,
21761}
21762
21763impl std::ops::Drop for BaseNetworkSocketSetReuseAddressResponder {
21767 fn drop(&mut self) {
21768 self.control_handle.shutdown();
21769 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21771 }
21772}
21773
21774impl fidl::endpoints::Responder for BaseNetworkSocketSetReuseAddressResponder {
21775 type ControlHandle = BaseNetworkSocketControlHandle;
21776
21777 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
21778 &self.control_handle
21779 }
21780
21781 fn drop_without_shutdown(mut self) {
21782 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21784 std::mem::forget(self);
21786 }
21787}
21788
21789impl BaseNetworkSocketSetReuseAddressResponder {
21790 pub fn send(
21794 self,
21795 mut result: Result<(), fidl_fuchsia_posix::Errno>,
21796 ) -> Result<(), fidl::Error> {
21797 let _result = self.send_raw(result);
21798 if _result.is_err() {
21799 self.control_handle.shutdown();
21800 }
21801 self.drop_without_shutdown();
21802 _result
21803 }
21804
21805 pub fn send_no_shutdown_on_err(
21807 self,
21808 mut result: Result<(), fidl_fuchsia_posix::Errno>,
21809 ) -> Result<(), fidl::Error> {
21810 let _result = self.send_raw(result);
21811 self.drop_without_shutdown();
21812 _result
21813 }
21814
21815 fn send_raw(
21816 &self,
21817 mut result: Result<(), fidl_fuchsia_posix::Errno>,
21818 ) -> Result<(), fidl::Error> {
21819 self.control_handle.inner.send::<fidl::encoding::ResultType<
21820 fidl::encoding::EmptyStruct,
21821 fidl_fuchsia_posix::Errno,
21822 >>(
21823 result,
21824 self.tx_id,
21825 0x1fd74ee8b9a4a876,
21826 fidl::encoding::DynamicFlags::empty(),
21827 )
21828 }
21829}
21830
21831#[must_use = "FIDL methods require a response to be sent"]
21832#[derive(Debug)]
21833pub struct BaseNetworkSocketGetReuseAddressResponder {
21834 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
21835 tx_id: u32,
21836}
21837
21838impl std::ops::Drop for BaseNetworkSocketGetReuseAddressResponder {
21842 fn drop(&mut self) {
21843 self.control_handle.shutdown();
21844 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21846 }
21847}
21848
21849impl fidl::endpoints::Responder for BaseNetworkSocketGetReuseAddressResponder {
21850 type ControlHandle = BaseNetworkSocketControlHandle;
21851
21852 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
21853 &self.control_handle
21854 }
21855
21856 fn drop_without_shutdown(mut self) {
21857 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21859 std::mem::forget(self);
21861 }
21862}
21863
21864impl BaseNetworkSocketGetReuseAddressResponder {
21865 pub fn send(
21869 self,
21870 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
21871 ) -> Result<(), fidl::Error> {
21872 let _result = self.send_raw(result);
21873 if _result.is_err() {
21874 self.control_handle.shutdown();
21875 }
21876 self.drop_without_shutdown();
21877 _result
21878 }
21879
21880 pub fn send_no_shutdown_on_err(
21882 self,
21883 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
21884 ) -> Result<(), fidl::Error> {
21885 let _result = self.send_raw(result);
21886 self.drop_without_shutdown();
21887 _result
21888 }
21889
21890 fn send_raw(
21891 &self,
21892 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
21893 ) -> Result<(), fidl::Error> {
21894 self.control_handle.inner.send::<fidl::encoding::ResultType<
21895 BaseSocketGetReuseAddressResponse,
21896 fidl_fuchsia_posix::Errno,
21897 >>(
21898 result.map(|value| (value,)),
21899 self.tx_id,
21900 0x67b7206b8d1bc0a5,
21901 fidl::encoding::DynamicFlags::empty(),
21902 )
21903 }
21904}
21905
21906#[must_use = "FIDL methods require a response to be sent"]
21907#[derive(Debug)]
21908pub struct BaseNetworkSocketGetErrorResponder {
21909 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
21910 tx_id: u32,
21911}
21912
21913impl std::ops::Drop for BaseNetworkSocketGetErrorResponder {
21917 fn drop(&mut self) {
21918 self.control_handle.shutdown();
21919 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21921 }
21922}
21923
21924impl fidl::endpoints::Responder for BaseNetworkSocketGetErrorResponder {
21925 type ControlHandle = BaseNetworkSocketControlHandle;
21926
21927 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
21928 &self.control_handle
21929 }
21930
21931 fn drop_without_shutdown(mut self) {
21932 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21934 std::mem::forget(self);
21936 }
21937}
21938
21939impl BaseNetworkSocketGetErrorResponder {
21940 pub fn send(
21944 self,
21945 mut result: Result<(), fidl_fuchsia_posix::Errno>,
21946 ) -> Result<(), fidl::Error> {
21947 let _result = self.send_raw(result);
21948 if _result.is_err() {
21949 self.control_handle.shutdown();
21950 }
21951 self.drop_without_shutdown();
21952 _result
21953 }
21954
21955 pub fn send_no_shutdown_on_err(
21957 self,
21958 mut result: Result<(), fidl_fuchsia_posix::Errno>,
21959 ) -> Result<(), fidl::Error> {
21960 let _result = self.send_raw(result);
21961 self.drop_without_shutdown();
21962 _result
21963 }
21964
21965 fn send_raw(
21966 &self,
21967 mut result: Result<(), fidl_fuchsia_posix::Errno>,
21968 ) -> Result<(), fidl::Error> {
21969 self.control_handle.inner.send::<fidl::encoding::ResultType<
21970 fidl::encoding::EmptyStruct,
21971 fidl_fuchsia_posix::Errno,
21972 >>(
21973 result,
21974 self.tx_id,
21975 0x5aad39b33e5f6ebb,
21976 fidl::encoding::DynamicFlags::empty(),
21977 )
21978 }
21979}
21980
21981#[must_use = "FIDL methods require a response to be sent"]
21982#[derive(Debug)]
21983pub struct BaseNetworkSocketSetBroadcastResponder {
21984 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
21985 tx_id: u32,
21986}
21987
21988impl std::ops::Drop for BaseNetworkSocketSetBroadcastResponder {
21992 fn drop(&mut self) {
21993 self.control_handle.shutdown();
21994 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21996 }
21997}
21998
21999impl fidl::endpoints::Responder for BaseNetworkSocketSetBroadcastResponder {
22000 type ControlHandle = BaseNetworkSocketControlHandle;
22001
22002 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22003 &self.control_handle
22004 }
22005
22006 fn drop_without_shutdown(mut self) {
22007 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22009 std::mem::forget(self);
22011 }
22012}
22013
22014impl BaseNetworkSocketSetBroadcastResponder {
22015 pub fn send(
22019 self,
22020 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22021 ) -> Result<(), fidl::Error> {
22022 let _result = self.send_raw(result);
22023 if _result.is_err() {
22024 self.control_handle.shutdown();
22025 }
22026 self.drop_without_shutdown();
22027 _result
22028 }
22029
22030 pub fn send_no_shutdown_on_err(
22032 self,
22033 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22034 ) -> Result<(), fidl::Error> {
22035 let _result = self.send_raw(result);
22036 self.drop_without_shutdown();
22037 _result
22038 }
22039
22040 fn send_raw(
22041 &self,
22042 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22043 ) -> Result<(), fidl::Error> {
22044 self.control_handle.inner.send::<fidl::encoding::ResultType<
22045 fidl::encoding::EmptyStruct,
22046 fidl_fuchsia_posix::Errno,
22047 >>(
22048 result,
22049 self.tx_id,
22050 0x6023e081ce3cd947,
22051 fidl::encoding::DynamicFlags::empty(),
22052 )
22053 }
22054}
22055
22056#[must_use = "FIDL methods require a response to be sent"]
22057#[derive(Debug)]
22058pub struct BaseNetworkSocketGetBroadcastResponder {
22059 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22060 tx_id: u32,
22061}
22062
22063impl std::ops::Drop for BaseNetworkSocketGetBroadcastResponder {
22067 fn drop(&mut self) {
22068 self.control_handle.shutdown();
22069 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22071 }
22072}
22073
22074impl fidl::endpoints::Responder for BaseNetworkSocketGetBroadcastResponder {
22075 type ControlHandle = BaseNetworkSocketControlHandle;
22076
22077 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22078 &self.control_handle
22079 }
22080
22081 fn drop_without_shutdown(mut self) {
22082 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22084 std::mem::forget(self);
22086 }
22087}
22088
22089impl BaseNetworkSocketGetBroadcastResponder {
22090 pub fn send(
22094 self,
22095 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22096 ) -> Result<(), fidl::Error> {
22097 let _result = self.send_raw(result);
22098 if _result.is_err() {
22099 self.control_handle.shutdown();
22100 }
22101 self.drop_without_shutdown();
22102 _result
22103 }
22104
22105 pub fn send_no_shutdown_on_err(
22107 self,
22108 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22109 ) -> Result<(), fidl::Error> {
22110 let _result = self.send_raw(result);
22111 self.drop_without_shutdown();
22112 _result
22113 }
22114
22115 fn send_raw(
22116 &self,
22117 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22118 ) -> Result<(), fidl::Error> {
22119 self.control_handle.inner.send::<fidl::encoding::ResultType<
22120 BaseSocketGetBroadcastResponse,
22121 fidl_fuchsia_posix::Errno,
22122 >>(
22123 result.map(|value| (value,)),
22124 self.tx_id,
22125 0x68796fc556f9780d,
22126 fidl::encoding::DynamicFlags::empty(),
22127 )
22128 }
22129}
22130
22131#[must_use = "FIDL methods require a response to be sent"]
22132#[derive(Debug)]
22133pub struct BaseNetworkSocketSetSendBufferResponder {
22134 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22135 tx_id: u32,
22136}
22137
22138impl std::ops::Drop for BaseNetworkSocketSetSendBufferResponder {
22142 fn drop(&mut self) {
22143 self.control_handle.shutdown();
22144 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22146 }
22147}
22148
22149impl fidl::endpoints::Responder for BaseNetworkSocketSetSendBufferResponder {
22150 type ControlHandle = BaseNetworkSocketControlHandle;
22151
22152 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22153 &self.control_handle
22154 }
22155
22156 fn drop_without_shutdown(mut self) {
22157 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22159 std::mem::forget(self);
22161 }
22162}
22163
22164impl BaseNetworkSocketSetSendBufferResponder {
22165 pub fn send(
22169 self,
22170 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22171 ) -> Result<(), fidl::Error> {
22172 let _result = self.send_raw(result);
22173 if _result.is_err() {
22174 self.control_handle.shutdown();
22175 }
22176 self.drop_without_shutdown();
22177 _result
22178 }
22179
22180 pub fn send_no_shutdown_on_err(
22182 self,
22183 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22184 ) -> Result<(), fidl::Error> {
22185 let _result = self.send_raw(result);
22186 self.drop_without_shutdown();
22187 _result
22188 }
22189
22190 fn send_raw(
22191 &self,
22192 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22193 ) -> Result<(), fidl::Error> {
22194 self.control_handle.inner.send::<fidl::encoding::ResultType<
22195 fidl::encoding::EmptyStruct,
22196 fidl_fuchsia_posix::Errno,
22197 >>(
22198 result,
22199 self.tx_id,
22200 0x756eac32d73a7a70,
22201 fidl::encoding::DynamicFlags::empty(),
22202 )
22203 }
22204}
22205
22206#[must_use = "FIDL methods require a response to be sent"]
22207#[derive(Debug)]
22208pub struct BaseNetworkSocketGetSendBufferResponder {
22209 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22210 tx_id: u32,
22211}
22212
22213impl std::ops::Drop for BaseNetworkSocketGetSendBufferResponder {
22217 fn drop(&mut self) {
22218 self.control_handle.shutdown();
22219 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22221 }
22222}
22223
22224impl fidl::endpoints::Responder for BaseNetworkSocketGetSendBufferResponder {
22225 type ControlHandle = BaseNetworkSocketControlHandle;
22226
22227 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22228 &self.control_handle
22229 }
22230
22231 fn drop_without_shutdown(mut self) {
22232 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22234 std::mem::forget(self);
22236 }
22237}
22238
22239impl BaseNetworkSocketGetSendBufferResponder {
22240 pub fn send(
22244 self,
22245 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
22246 ) -> Result<(), fidl::Error> {
22247 let _result = self.send_raw(result);
22248 if _result.is_err() {
22249 self.control_handle.shutdown();
22250 }
22251 self.drop_without_shutdown();
22252 _result
22253 }
22254
22255 pub fn send_no_shutdown_on_err(
22257 self,
22258 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
22259 ) -> Result<(), fidl::Error> {
22260 let _result = self.send_raw(result);
22261 self.drop_without_shutdown();
22262 _result
22263 }
22264
22265 fn send_raw(
22266 &self,
22267 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
22268 ) -> Result<(), fidl::Error> {
22269 self.control_handle.inner.send::<fidl::encoding::ResultType<
22270 BaseSocketGetSendBufferResponse,
22271 fidl_fuchsia_posix::Errno,
22272 >>(
22273 result.map(|value_bytes| (value_bytes,)),
22274 self.tx_id,
22275 0x78a52fd9c7b2410b,
22276 fidl::encoding::DynamicFlags::empty(),
22277 )
22278 }
22279}
22280
22281#[must_use = "FIDL methods require a response to be sent"]
22282#[derive(Debug)]
22283pub struct BaseNetworkSocketSetReceiveBufferResponder {
22284 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22285 tx_id: u32,
22286}
22287
22288impl std::ops::Drop for BaseNetworkSocketSetReceiveBufferResponder {
22292 fn drop(&mut self) {
22293 self.control_handle.shutdown();
22294 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22296 }
22297}
22298
22299impl fidl::endpoints::Responder for BaseNetworkSocketSetReceiveBufferResponder {
22300 type ControlHandle = BaseNetworkSocketControlHandle;
22301
22302 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22303 &self.control_handle
22304 }
22305
22306 fn drop_without_shutdown(mut self) {
22307 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22309 std::mem::forget(self);
22311 }
22312}
22313
22314impl BaseNetworkSocketSetReceiveBufferResponder {
22315 pub fn send(
22319 self,
22320 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22321 ) -> Result<(), fidl::Error> {
22322 let _result = self.send_raw(result);
22323 if _result.is_err() {
22324 self.control_handle.shutdown();
22325 }
22326 self.drop_without_shutdown();
22327 _result
22328 }
22329
22330 pub fn send_no_shutdown_on_err(
22332 self,
22333 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22334 ) -> Result<(), fidl::Error> {
22335 let _result = self.send_raw(result);
22336 self.drop_without_shutdown();
22337 _result
22338 }
22339
22340 fn send_raw(
22341 &self,
22342 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22343 ) -> Result<(), fidl::Error> {
22344 self.control_handle.inner.send::<fidl::encoding::ResultType<
22345 fidl::encoding::EmptyStruct,
22346 fidl_fuchsia_posix::Errno,
22347 >>(
22348 result,
22349 self.tx_id,
22350 0x6b0cf2f1919c7001,
22351 fidl::encoding::DynamicFlags::empty(),
22352 )
22353 }
22354}
22355
22356#[must_use = "FIDL methods require a response to be sent"]
22357#[derive(Debug)]
22358pub struct BaseNetworkSocketGetReceiveBufferResponder {
22359 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22360 tx_id: u32,
22361}
22362
22363impl std::ops::Drop for BaseNetworkSocketGetReceiveBufferResponder {
22367 fn drop(&mut self) {
22368 self.control_handle.shutdown();
22369 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22371 }
22372}
22373
22374impl fidl::endpoints::Responder for BaseNetworkSocketGetReceiveBufferResponder {
22375 type ControlHandle = BaseNetworkSocketControlHandle;
22376
22377 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22378 &self.control_handle
22379 }
22380
22381 fn drop_without_shutdown(mut self) {
22382 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22384 std::mem::forget(self);
22386 }
22387}
22388
22389impl BaseNetworkSocketGetReceiveBufferResponder {
22390 pub fn send(
22394 self,
22395 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
22396 ) -> Result<(), fidl::Error> {
22397 let _result = self.send_raw(result);
22398 if _result.is_err() {
22399 self.control_handle.shutdown();
22400 }
22401 self.drop_without_shutdown();
22402 _result
22403 }
22404
22405 pub fn send_no_shutdown_on_err(
22407 self,
22408 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
22409 ) -> Result<(), fidl::Error> {
22410 let _result = self.send_raw(result);
22411 self.drop_without_shutdown();
22412 _result
22413 }
22414
22415 fn send_raw(
22416 &self,
22417 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
22418 ) -> Result<(), fidl::Error> {
22419 self.control_handle.inner.send::<fidl::encoding::ResultType<
22420 BaseSocketGetReceiveBufferResponse,
22421 fidl_fuchsia_posix::Errno,
22422 >>(
22423 result.map(|value_bytes| (value_bytes,)),
22424 self.tx_id,
22425 0x14c1a4b64f709e5c,
22426 fidl::encoding::DynamicFlags::empty(),
22427 )
22428 }
22429}
22430
22431#[must_use = "FIDL methods require a response to be sent"]
22432#[derive(Debug)]
22433pub struct BaseNetworkSocketSetKeepAliveResponder {
22434 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22435 tx_id: u32,
22436}
22437
22438impl std::ops::Drop for BaseNetworkSocketSetKeepAliveResponder {
22442 fn drop(&mut self) {
22443 self.control_handle.shutdown();
22444 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22446 }
22447}
22448
22449impl fidl::endpoints::Responder for BaseNetworkSocketSetKeepAliveResponder {
22450 type ControlHandle = BaseNetworkSocketControlHandle;
22451
22452 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22453 &self.control_handle
22454 }
22455
22456 fn drop_without_shutdown(mut self) {
22457 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22459 std::mem::forget(self);
22461 }
22462}
22463
22464impl BaseNetworkSocketSetKeepAliveResponder {
22465 pub fn send(
22469 self,
22470 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22471 ) -> Result<(), fidl::Error> {
22472 let _result = self.send_raw(result);
22473 if _result.is_err() {
22474 self.control_handle.shutdown();
22475 }
22476 self.drop_without_shutdown();
22477 _result
22478 }
22479
22480 pub fn send_no_shutdown_on_err(
22482 self,
22483 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22484 ) -> Result<(), fidl::Error> {
22485 let _result = self.send_raw(result);
22486 self.drop_without_shutdown();
22487 _result
22488 }
22489
22490 fn send_raw(
22491 &self,
22492 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22493 ) -> Result<(), fidl::Error> {
22494 self.control_handle.inner.send::<fidl::encoding::ResultType<
22495 fidl::encoding::EmptyStruct,
22496 fidl_fuchsia_posix::Errno,
22497 >>(
22498 result,
22499 self.tx_id,
22500 0x572df8f0b920d2c7,
22501 fidl::encoding::DynamicFlags::empty(),
22502 )
22503 }
22504}
22505
22506#[must_use = "FIDL methods require a response to be sent"]
22507#[derive(Debug)]
22508pub struct BaseNetworkSocketGetKeepAliveResponder {
22509 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22510 tx_id: u32,
22511}
22512
22513impl std::ops::Drop for BaseNetworkSocketGetKeepAliveResponder {
22517 fn drop(&mut self) {
22518 self.control_handle.shutdown();
22519 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22521 }
22522}
22523
22524impl fidl::endpoints::Responder for BaseNetworkSocketGetKeepAliveResponder {
22525 type ControlHandle = BaseNetworkSocketControlHandle;
22526
22527 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22528 &self.control_handle
22529 }
22530
22531 fn drop_without_shutdown(mut self) {
22532 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22534 std::mem::forget(self);
22536 }
22537}
22538
22539impl BaseNetworkSocketGetKeepAliveResponder {
22540 pub fn send(
22544 self,
22545 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22546 ) -> Result<(), fidl::Error> {
22547 let _result = self.send_raw(result);
22548 if _result.is_err() {
22549 self.control_handle.shutdown();
22550 }
22551 self.drop_without_shutdown();
22552 _result
22553 }
22554
22555 pub fn send_no_shutdown_on_err(
22557 self,
22558 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22559 ) -> Result<(), fidl::Error> {
22560 let _result = self.send_raw(result);
22561 self.drop_without_shutdown();
22562 _result
22563 }
22564
22565 fn send_raw(
22566 &self,
22567 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22568 ) -> Result<(), fidl::Error> {
22569 self.control_handle.inner.send::<fidl::encoding::ResultType<
22570 BaseSocketGetKeepAliveResponse,
22571 fidl_fuchsia_posix::Errno,
22572 >>(
22573 result.map(|value| (value,)),
22574 self.tx_id,
22575 0x2dd29d3215f2c9d2,
22576 fidl::encoding::DynamicFlags::empty(),
22577 )
22578 }
22579}
22580
22581#[must_use = "FIDL methods require a response to be sent"]
22582#[derive(Debug)]
22583pub struct BaseNetworkSocketSetOutOfBandInlineResponder {
22584 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22585 tx_id: u32,
22586}
22587
22588impl std::ops::Drop for BaseNetworkSocketSetOutOfBandInlineResponder {
22592 fn drop(&mut self) {
22593 self.control_handle.shutdown();
22594 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22596 }
22597}
22598
22599impl fidl::endpoints::Responder for BaseNetworkSocketSetOutOfBandInlineResponder {
22600 type ControlHandle = BaseNetworkSocketControlHandle;
22601
22602 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22603 &self.control_handle
22604 }
22605
22606 fn drop_without_shutdown(mut self) {
22607 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22609 std::mem::forget(self);
22611 }
22612}
22613
22614impl BaseNetworkSocketSetOutOfBandInlineResponder {
22615 pub fn send(
22619 self,
22620 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22621 ) -> Result<(), fidl::Error> {
22622 let _result = self.send_raw(result);
22623 if _result.is_err() {
22624 self.control_handle.shutdown();
22625 }
22626 self.drop_without_shutdown();
22627 _result
22628 }
22629
22630 pub fn send_no_shutdown_on_err(
22632 self,
22633 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22634 ) -> Result<(), fidl::Error> {
22635 let _result = self.send_raw(result);
22636 self.drop_without_shutdown();
22637 _result
22638 }
22639
22640 fn send_raw(
22641 &self,
22642 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22643 ) -> Result<(), fidl::Error> {
22644 self.control_handle.inner.send::<fidl::encoding::ResultType<
22645 fidl::encoding::EmptyStruct,
22646 fidl_fuchsia_posix::Errno,
22647 >>(
22648 result,
22649 self.tx_id,
22650 0x3ecb49968bee439,
22651 fidl::encoding::DynamicFlags::empty(),
22652 )
22653 }
22654}
22655
22656#[must_use = "FIDL methods require a response to be sent"]
22657#[derive(Debug)]
22658pub struct BaseNetworkSocketGetOutOfBandInlineResponder {
22659 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22660 tx_id: u32,
22661}
22662
22663impl std::ops::Drop for BaseNetworkSocketGetOutOfBandInlineResponder {
22667 fn drop(&mut self) {
22668 self.control_handle.shutdown();
22669 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22671 }
22672}
22673
22674impl fidl::endpoints::Responder for BaseNetworkSocketGetOutOfBandInlineResponder {
22675 type ControlHandle = BaseNetworkSocketControlHandle;
22676
22677 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22678 &self.control_handle
22679 }
22680
22681 fn drop_without_shutdown(mut self) {
22682 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22684 std::mem::forget(self);
22686 }
22687}
22688
22689impl BaseNetworkSocketGetOutOfBandInlineResponder {
22690 pub fn send(
22694 self,
22695 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22696 ) -> Result<(), fidl::Error> {
22697 let _result = self.send_raw(result);
22698 if _result.is_err() {
22699 self.control_handle.shutdown();
22700 }
22701 self.drop_without_shutdown();
22702 _result
22703 }
22704
22705 pub fn send_no_shutdown_on_err(
22707 self,
22708 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22709 ) -> Result<(), fidl::Error> {
22710 let _result = self.send_raw(result);
22711 self.drop_without_shutdown();
22712 _result
22713 }
22714
22715 fn send_raw(
22716 &self,
22717 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22718 ) -> Result<(), fidl::Error> {
22719 self.control_handle.inner.send::<fidl::encoding::ResultType<
22720 BaseSocketGetOutOfBandInlineResponse,
22721 fidl_fuchsia_posix::Errno,
22722 >>(
22723 result.map(|value| (value,)),
22724 self.tx_id,
22725 0x348c1ab3aeca1745,
22726 fidl::encoding::DynamicFlags::empty(),
22727 )
22728 }
22729}
22730
22731#[must_use = "FIDL methods require a response to be sent"]
22732#[derive(Debug)]
22733pub struct BaseNetworkSocketSetNoCheckResponder {
22734 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22735 tx_id: u32,
22736}
22737
22738impl std::ops::Drop for BaseNetworkSocketSetNoCheckResponder {
22742 fn drop(&mut self) {
22743 self.control_handle.shutdown();
22744 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22746 }
22747}
22748
22749impl fidl::endpoints::Responder for BaseNetworkSocketSetNoCheckResponder {
22750 type ControlHandle = BaseNetworkSocketControlHandle;
22751
22752 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22753 &self.control_handle
22754 }
22755
22756 fn drop_without_shutdown(mut self) {
22757 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22759 std::mem::forget(self);
22761 }
22762}
22763
22764impl BaseNetworkSocketSetNoCheckResponder {
22765 pub fn send(
22769 self,
22770 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22771 ) -> Result<(), fidl::Error> {
22772 let _result = self.send_raw(result);
22773 if _result.is_err() {
22774 self.control_handle.shutdown();
22775 }
22776 self.drop_without_shutdown();
22777 _result
22778 }
22779
22780 pub fn send_no_shutdown_on_err(
22782 self,
22783 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22784 ) -> Result<(), fidl::Error> {
22785 let _result = self.send_raw(result);
22786 self.drop_without_shutdown();
22787 _result
22788 }
22789
22790 fn send_raw(
22791 &self,
22792 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22793 ) -> Result<(), fidl::Error> {
22794 self.control_handle.inner.send::<fidl::encoding::ResultType<
22795 fidl::encoding::EmptyStruct,
22796 fidl_fuchsia_posix::Errno,
22797 >>(
22798 result,
22799 self.tx_id,
22800 0x6bbf00c53a4c78c2,
22801 fidl::encoding::DynamicFlags::empty(),
22802 )
22803 }
22804}
22805
22806#[must_use = "FIDL methods require a response to be sent"]
22807#[derive(Debug)]
22808pub struct BaseNetworkSocketGetNoCheckResponder {
22809 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22810 tx_id: u32,
22811}
22812
22813impl std::ops::Drop for BaseNetworkSocketGetNoCheckResponder {
22817 fn drop(&mut self) {
22818 self.control_handle.shutdown();
22819 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22821 }
22822}
22823
22824impl fidl::endpoints::Responder for BaseNetworkSocketGetNoCheckResponder {
22825 type ControlHandle = BaseNetworkSocketControlHandle;
22826
22827 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22828 &self.control_handle
22829 }
22830
22831 fn drop_without_shutdown(mut self) {
22832 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22834 std::mem::forget(self);
22836 }
22837}
22838
22839impl BaseNetworkSocketGetNoCheckResponder {
22840 pub fn send(
22844 self,
22845 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22846 ) -> Result<(), fidl::Error> {
22847 let _result = self.send_raw(result);
22848 if _result.is_err() {
22849 self.control_handle.shutdown();
22850 }
22851 self.drop_without_shutdown();
22852 _result
22853 }
22854
22855 pub fn send_no_shutdown_on_err(
22857 self,
22858 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22859 ) -> Result<(), fidl::Error> {
22860 let _result = self.send_raw(result);
22861 self.drop_without_shutdown();
22862 _result
22863 }
22864
22865 fn send_raw(
22866 &self,
22867 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22868 ) -> Result<(), fidl::Error> {
22869 self.control_handle.inner.send::<fidl::encoding::ResultType<
22870 BaseSocketGetNoCheckResponse,
22871 fidl_fuchsia_posix::Errno,
22872 >>(
22873 result.map(|value| (value,)),
22874 self.tx_id,
22875 0x2cd4249286417694,
22876 fidl::encoding::DynamicFlags::empty(),
22877 )
22878 }
22879}
22880
22881#[must_use = "FIDL methods require a response to be sent"]
22882#[derive(Debug)]
22883pub struct BaseNetworkSocketSetLingerResponder {
22884 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22885 tx_id: u32,
22886}
22887
22888impl std::ops::Drop for BaseNetworkSocketSetLingerResponder {
22892 fn drop(&mut self) {
22893 self.control_handle.shutdown();
22894 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22896 }
22897}
22898
22899impl fidl::endpoints::Responder for BaseNetworkSocketSetLingerResponder {
22900 type ControlHandle = BaseNetworkSocketControlHandle;
22901
22902 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22903 &self.control_handle
22904 }
22905
22906 fn drop_without_shutdown(mut self) {
22907 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22909 std::mem::forget(self);
22911 }
22912}
22913
22914impl BaseNetworkSocketSetLingerResponder {
22915 pub fn send(
22919 self,
22920 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22921 ) -> Result<(), fidl::Error> {
22922 let _result = self.send_raw(result);
22923 if _result.is_err() {
22924 self.control_handle.shutdown();
22925 }
22926 self.drop_without_shutdown();
22927 _result
22928 }
22929
22930 pub fn send_no_shutdown_on_err(
22932 self,
22933 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22934 ) -> Result<(), fidl::Error> {
22935 let _result = self.send_raw(result);
22936 self.drop_without_shutdown();
22937 _result
22938 }
22939
22940 fn send_raw(
22941 &self,
22942 mut result: Result<(), fidl_fuchsia_posix::Errno>,
22943 ) -> Result<(), fidl::Error> {
22944 self.control_handle.inner.send::<fidl::encoding::ResultType<
22945 fidl::encoding::EmptyStruct,
22946 fidl_fuchsia_posix::Errno,
22947 >>(
22948 result,
22949 self.tx_id,
22950 0x45386351246e998e,
22951 fidl::encoding::DynamicFlags::empty(),
22952 )
22953 }
22954}
22955
22956#[must_use = "FIDL methods require a response to be sent"]
22957#[derive(Debug)]
22958pub struct BaseNetworkSocketGetLingerResponder {
22959 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22960 tx_id: u32,
22961}
22962
22963impl std::ops::Drop for BaseNetworkSocketGetLingerResponder {
22967 fn drop(&mut self) {
22968 self.control_handle.shutdown();
22969 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22971 }
22972}
22973
22974impl fidl::endpoints::Responder for BaseNetworkSocketGetLingerResponder {
22975 type ControlHandle = BaseNetworkSocketControlHandle;
22976
22977 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22978 &self.control_handle
22979 }
22980
22981 fn drop_without_shutdown(mut self) {
22982 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22984 std::mem::forget(self);
22986 }
22987}
22988
22989impl BaseNetworkSocketGetLingerResponder {
22990 pub fn send(
22994 self,
22995 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
22996 ) -> Result<(), fidl::Error> {
22997 let _result = self.send_raw(result);
22998 if _result.is_err() {
22999 self.control_handle.shutdown();
23000 }
23001 self.drop_without_shutdown();
23002 _result
23003 }
23004
23005 pub fn send_no_shutdown_on_err(
23007 self,
23008 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
23009 ) -> Result<(), fidl::Error> {
23010 let _result = self.send_raw(result);
23011 self.drop_without_shutdown();
23012 _result
23013 }
23014
23015 fn send_raw(
23016 &self,
23017 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
23018 ) -> Result<(), fidl::Error> {
23019 self.control_handle.inner.send::<fidl::encoding::ResultType<
23020 BaseSocketGetLingerResponse,
23021 fidl_fuchsia_posix::Errno,
23022 >>(
23023 result,
23024 self.tx_id,
23025 0x48eb20fc5ccb0e45,
23026 fidl::encoding::DynamicFlags::empty(),
23027 )
23028 }
23029}
23030
23031#[must_use = "FIDL methods require a response to be sent"]
23032#[derive(Debug)]
23033pub struct BaseNetworkSocketSetReusePortResponder {
23034 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23035 tx_id: u32,
23036}
23037
23038impl std::ops::Drop for BaseNetworkSocketSetReusePortResponder {
23042 fn drop(&mut self) {
23043 self.control_handle.shutdown();
23044 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23046 }
23047}
23048
23049impl fidl::endpoints::Responder for BaseNetworkSocketSetReusePortResponder {
23050 type ControlHandle = BaseNetworkSocketControlHandle;
23051
23052 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23053 &self.control_handle
23054 }
23055
23056 fn drop_without_shutdown(mut self) {
23057 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23059 std::mem::forget(self);
23061 }
23062}
23063
23064impl BaseNetworkSocketSetReusePortResponder {
23065 pub fn send(
23069 self,
23070 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23071 ) -> Result<(), fidl::Error> {
23072 let _result = self.send_raw(result);
23073 if _result.is_err() {
23074 self.control_handle.shutdown();
23075 }
23076 self.drop_without_shutdown();
23077 _result
23078 }
23079
23080 pub fn send_no_shutdown_on_err(
23082 self,
23083 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23084 ) -> Result<(), fidl::Error> {
23085 let _result = self.send_raw(result);
23086 self.drop_without_shutdown();
23087 _result
23088 }
23089
23090 fn send_raw(
23091 &self,
23092 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23093 ) -> Result<(), fidl::Error> {
23094 self.control_handle.inner.send::<fidl::encoding::ResultType<
23095 fidl::encoding::EmptyStruct,
23096 fidl_fuchsia_posix::Errno,
23097 >>(
23098 result,
23099 self.tx_id,
23100 0x24dd3e5cb36d9ccb,
23101 fidl::encoding::DynamicFlags::empty(),
23102 )
23103 }
23104}
23105
23106#[must_use = "FIDL methods require a response to be sent"]
23107#[derive(Debug)]
23108pub struct BaseNetworkSocketGetReusePortResponder {
23109 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23110 tx_id: u32,
23111}
23112
23113impl std::ops::Drop for BaseNetworkSocketGetReusePortResponder {
23117 fn drop(&mut self) {
23118 self.control_handle.shutdown();
23119 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23121 }
23122}
23123
23124impl fidl::endpoints::Responder for BaseNetworkSocketGetReusePortResponder {
23125 type ControlHandle = BaseNetworkSocketControlHandle;
23126
23127 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23128 &self.control_handle
23129 }
23130
23131 fn drop_without_shutdown(mut self) {
23132 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23134 std::mem::forget(self);
23136 }
23137}
23138
23139impl BaseNetworkSocketGetReusePortResponder {
23140 pub fn send(
23144 self,
23145 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
23146 ) -> Result<(), fidl::Error> {
23147 let _result = self.send_raw(result);
23148 if _result.is_err() {
23149 self.control_handle.shutdown();
23150 }
23151 self.drop_without_shutdown();
23152 _result
23153 }
23154
23155 pub fn send_no_shutdown_on_err(
23157 self,
23158 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
23159 ) -> Result<(), fidl::Error> {
23160 let _result = self.send_raw(result);
23161 self.drop_without_shutdown();
23162 _result
23163 }
23164
23165 fn send_raw(
23166 &self,
23167 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
23168 ) -> Result<(), fidl::Error> {
23169 self.control_handle.inner.send::<fidl::encoding::ResultType<
23170 BaseSocketGetReusePortResponse,
23171 fidl_fuchsia_posix::Errno,
23172 >>(
23173 result.map(|value| (value,)),
23174 self.tx_id,
23175 0x7a112c1ab54ff828,
23176 fidl::encoding::DynamicFlags::empty(),
23177 )
23178 }
23179}
23180
23181#[must_use = "FIDL methods require a response to be sent"]
23182#[derive(Debug)]
23183pub struct BaseNetworkSocketGetAcceptConnResponder {
23184 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23185 tx_id: u32,
23186}
23187
23188impl std::ops::Drop for BaseNetworkSocketGetAcceptConnResponder {
23192 fn drop(&mut self) {
23193 self.control_handle.shutdown();
23194 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23196 }
23197}
23198
23199impl fidl::endpoints::Responder for BaseNetworkSocketGetAcceptConnResponder {
23200 type ControlHandle = BaseNetworkSocketControlHandle;
23201
23202 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23203 &self.control_handle
23204 }
23205
23206 fn drop_without_shutdown(mut self) {
23207 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23209 std::mem::forget(self);
23211 }
23212}
23213
23214impl BaseNetworkSocketGetAcceptConnResponder {
23215 pub fn send(
23219 self,
23220 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
23221 ) -> Result<(), fidl::Error> {
23222 let _result = self.send_raw(result);
23223 if _result.is_err() {
23224 self.control_handle.shutdown();
23225 }
23226 self.drop_without_shutdown();
23227 _result
23228 }
23229
23230 pub fn send_no_shutdown_on_err(
23232 self,
23233 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
23234 ) -> Result<(), fidl::Error> {
23235 let _result = self.send_raw(result);
23236 self.drop_without_shutdown();
23237 _result
23238 }
23239
23240 fn send_raw(
23241 &self,
23242 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
23243 ) -> Result<(), fidl::Error> {
23244 self.control_handle.inner.send::<fidl::encoding::ResultType<
23245 BaseSocketGetAcceptConnResponse,
23246 fidl_fuchsia_posix::Errno,
23247 >>(
23248 result.map(|value| (value,)),
23249 self.tx_id,
23250 0x67ce6db6c2ec8966,
23251 fidl::encoding::DynamicFlags::empty(),
23252 )
23253 }
23254}
23255
23256#[must_use = "FIDL methods require a response to be sent"]
23257#[derive(Debug)]
23258pub struct BaseNetworkSocketSetBindToDeviceResponder {
23259 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23260 tx_id: u32,
23261}
23262
23263impl std::ops::Drop for BaseNetworkSocketSetBindToDeviceResponder {
23267 fn drop(&mut self) {
23268 self.control_handle.shutdown();
23269 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23271 }
23272}
23273
23274impl fidl::endpoints::Responder for BaseNetworkSocketSetBindToDeviceResponder {
23275 type ControlHandle = BaseNetworkSocketControlHandle;
23276
23277 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23278 &self.control_handle
23279 }
23280
23281 fn drop_without_shutdown(mut self) {
23282 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23284 std::mem::forget(self);
23286 }
23287}
23288
23289impl BaseNetworkSocketSetBindToDeviceResponder {
23290 pub fn send(
23294 self,
23295 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23296 ) -> Result<(), fidl::Error> {
23297 let _result = self.send_raw(result);
23298 if _result.is_err() {
23299 self.control_handle.shutdown();
23300 }
23301 self.drop_without_shutdown();
23302 _result
23303 }
23304
23305 pub fn send_no_shutdown_on_err(
23307 self,
23308 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23309 ) -> Result<(), fidl::Error> {
23310 let _result = self.send_raw(result);
23311 self.drop_without_shutdown();
23312 _result
23313 }
23314
23315 fn send_raw(
23316 &self,
23317 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23318 ) -> Result<(), fidl::Error> {
23319 self.control_handle.inner.send::<fidl::encoding::ResultType<
23320 fidl::encoding::EmptyStruct,
23321 fidl_fuchsia_posix::Errno,
23322 >>(
23323 result,
23324 self.tx_id,
23325 0x2118b483f28aafc4,
23326 fidl::encoding::DynamicFlags::empty(),
23327 )
23328 }
23329}
23330
23331#[must_use = "FIDL methods require a response to be sent"]
23332#[derive(Debug)]
23333pub struct BaseNetworkSocketGetBindToDeviceResponder {
23334 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23335 tx_id: u32,
23336}
23337
23338impl std::ops::Drop for BaseNetworkSocketGetBindToDeviceResponder {
23342 fn drop(&mut self) {
23343 self.control_handle.shutdown();
23344 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23346 }
23347}
23348
23349impl fidl::endpoints::Responder for BaseNetworkSocketGetBindToDeviceResponder {
23350 type ControlHandle = BaseNetworkSocketControlHandle;
23351
23352 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23353 &self.control_handle
23354 }
23355
23356 fn drop_without_shutdown(mut self) {
23357 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23359 std::mem::forget(self);
23361 }
23362}
23363
23364impl BaseNetworkSocketGetBindToDeviceResponder {
23365 pub fn send(
23369 self,
23370 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
23371 ) -> Result<(), fidl::Error> {
23372 let _result = self.send_raw(result);
23373 if _result.is_err() {
23374 self.control_handle.shutdown();
23375 }
23376 self.drop_without_shutdown();
23377 _result
23378 }
23379
23380 pub fn send_no_shutdown_on_err(
23382 self,
23383 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
23384 ) -> Result<(), fidl::Error> {
23385 let _result = self.send_raw(result);
23386 self.drop_without_shutdown();
23387 _result
23388 }
23389
23390 fn send_raw(
23391 &self,
23392 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
23393 ) -> Result<(), fidl::Error> {
23394 self.control_handle.inner.send::<fidl::encoding::ResultType<
23395 BaseSocketGetBindToDeviceResponse,
23396 fidl_fuchsia_posix::Errno,
23397 >>(
23398 result.map(|value| (value,)),
23399 self.tx_id,
23400 0x1ab1fbf0ef7906c8,
23401 fidl::encoding::DynamicFlags::empty(),
23402 )
23403 }
23404}
23405
23406#[must_use = "FIDL methods require a response to be sent"]
23407#[derive(Debug)]
23408pub struct BaseNetworkSocketSetBindToInterfaceIndexResponder {
23409 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23410 tx_id: u32,
23411}
23412
23413impl std::ops::Drop for BaseNetworkSocketSetBindToInterfaceIndexResponder {
23417 fn drop(&mut self) {
23418 self.control_handle.shutdown();
23419 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23421 }
23422}
23423
23424impl fidl::endpoints::Responder for BaseNetworkSocketSetBindToInterfaceIndexResponder {
23425 type ControlHandle = BaseNetworkSocketControlHandle;
23426
23427 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23428 &self.control_handle
23429 }
23430
23431 fn drop_without_shutdown(mut self) {
23432 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23434 std::mem::forget(self);
23436 }
23437}
23438
23439impl BaseNetworkSocketSetBindToInterfaceIndexResponder {
23440 pub fn send(
23444 self,
23445 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23446 ) -> Result<(), fidl::Error> {
23447 let _result = self.send_raw(result);
23448 if _result.is_err() {
23449 self.control_handle.shutdown();
23450 }
23451 self.drop_without_shutdown();
23452 _result
23453 }
23454
23455 pub fn send_no_shutdown_on_err(
23457 self,
23458 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23459 ) -> Result<(), fidl::Error> {
23460 let _result = self.send_raw(result);
23461 self.drop_without_shutdown();
23462 _result
23463 }
23464
23465 fn send_raw(
23466 &self,
23467 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23468 ) -> Result<(), fidl::Error> {
23469 self.control_handle.inner.send::<fidl::encoding::ResultType<
23470 fidl::encoding::EmptyStruct,
23471 fidl_fuchsia_posix::Errno,
23472 >>(
23473 result,
23474 self.tx_id,
23475 0x6e387a0def00821,
23476 fidl::encoding::DynamicFlags::empty(),
23477 )
23478 }
23479}
23480
23481#[must_use = "FIDL methods require a response to be sent"]
23482#[derive(Debug)]
23483pub struct BaseNetworkSocketGetBindToInterfaceIndexResponder {
23484 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23485 tx_id: u32,
23486}
23487
23488impl std::ops::Drop for BaseNetworkSocketGetBindToInterfaceIndexResponder {
23492 fn drop(&mut self) {
23493 self.control_handle.shutdown();
23494 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23496 }
23497}
23498
23499impl fidl::endpoints::Responder for BaseNetworkSocketGetBindToInterfaceIndexResponder {
23500 type ControlHandle = BaseNetworkSocketControlHandle;
23501
23502 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23503 &self.control_handle
23504 }
23505
23506 fn drop_without_shutdown(mut self) {
23507 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23509 std::mem::forget(self);
23511 }
23512}
23513
23514impl BaseNetworkSocketGetBindToInterfaceIndexResponder {
23515 pub fn send(
23519 self,
23520 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
23521 ) -> Result<(), fidl::Error> {
23522 let _result = self.send_raw(result);
23523 if _result.is_err() {
23524 self.control_handle.shutdown();
23525 }
23526 self.drop_without_shutdown();
23527 _result
23528 }
23529
23530 pub fn send_no_shutdown_on_err(
23532 self,
23533 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
23534 ) -> Result<(), fidl::Error> {
23535 let _result = self.send_raw(result);
23536 self.drop_without_shutdown();
23537 _result
23538 }
23539
23540 fn send_raw(
23541 &self,
23542 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
23543 ) -> Result<(), fidl::Error> {
23544 self.control_handle.inner.send::<fidl::encoding::ResultType<
23545 BaseSocketGetBindToInterfaceIndexResponse,
23546 fidl_fuchsia_posix::Errno,
23547 >>(
23548 result.map(|value| (value,)),
23549 self.tx_id,
23550 0x59c31dd3e3078295,
23551 fidl::encoding::DynamicFlags::empty(),
23552 )
23553 }
23554}
23555
23556#[must_use = "FIDL methods require a response to be sent"]
23557#[derive(Debug)]
23558pub struct BaseNetworkSocketSetTimestampResponder {
23559 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23560 tx_id: u32,
23561}
23562
23563impl std::ops::Drop for BaseNetworkSocketSetTimestampResponder {
23567 fn drop(&mut self) {
23568 self.control_handle.shutdown();
23569 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23571 }
23572}
23573
23574impl fidl::endpoints::Responder for BaseNetworkSocketSetTimestampResponder {
23575 type ControlHandle = BaseNetworkSocketControlHandle;
23576
23577 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23578 &self.control_handle
23579 }
23580
23581 fn drop_without_shutdown(mut self) {
23582 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23584 std::mem::forget(self);
23586 }
23587}
23588
23589impl BaseNetworkSocketSetTimestampResponder {
23590 pub fn send(
23594 self,
23595 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23596 ) -> Result<(), fidl::Error> {
23597 let _result = self.send_raw(result);
23598 if _result.is_err() {
23599 self.control_handle.shutdown();
23600 }
23601 self.drop_without_shutdown();
23602 _result
23603 }
23604
23605 pub fn send_no_shutdown_on_err(
23607 self,
23608 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23609 ) -> Result<(), fidl::Error> {
23610 let _result = self.send_raw(result);
23611 self.drop_without_shutdown();
23612 _result
23613 }
23614
23615 fn send_raw(
23616 &self,
23617 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23618 ) -> Result<(), fidl::Error> {
23619 self.control_handle.inner.send::<fidl::encoding::ResultType<
23620 fidl::encoding::EmptyStruct,
23621 fidl_fuchsia_posix::Errno,
23622 >>(
23623 result,
23624 self.tx_id,
23625 0x285d6516c263d839,
23626 fidl::encoding::DynamicFlags::empty(),
23627 )
23628 }
23629}
23630
23631#[must_use = "FIDL methods require a response to be sent"]
23632#[derive(Debug)]
23633pub struct BaseNetworkSocketGetTimestampResponder {
23634 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23635 tx_id: u32,
23636}
23637
23638impl std::ops::Drop for BaseNetworkSocketGetTimestampResponder {
23642 fn drop(&mut self) {
23643 self.control_handle.shutdown();
23644 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23646 }
23647}
23648
23649impl fidl::endpoints::Responder for BaseNetworkSocketGetTimestampResponder {
23650 type ControlHandle = BaseNetworkSocketControlHandle;
23651
23652 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23653 &self.control_handle
23654 }
23655
23656 fn drop_without_shutdown(mut self) {
23657 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23659 std::mem::forget(self);
23661 }
23662}
23663
23664impl BaseNetworkSocketGetTimestampResponder {
23665 pub fn send(
23669 self,
23670 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
23671 ) -> Result<(), fidl::Error> {
23672 let _result = self.send_raw(result);
23673 if _result.is_err() {
23674 self.control_handle.shutdown();
23675 }
23676 self.drop_without_shutdown();
23677 _result
23678 }
23679
23680 pub fn send_no_shutdown_on_err(
23682 self,
23683 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
23684 ) -> Result<(), fidl::Error> {
23685 let _result = self.send_raw(result);
23686 self.drop_without_shutdown();
23687 _result
23688 }
23689
23690 fn send_raw(
23691 &self,
23692 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
23693 ) -> Result<(), fidl::Error> {
23694 self.control_handle.inner.send::<fidl::encoding::ResultType<
23695 BaseSocketGetTimestampResponse,
23696 fidl_fuchsia_posix::Errno,
23697 >>(
23698 result.map(|value| (value,)),
23699 self.tx_id,
23700 0x49f2fffbbcc2bd27,
23701 fidl::encoding::DynamicFlags::empty(),
23702 )
23703 }
23704}
23705
23706#[must_use = "FIDL methods require a response to be sent"]
23707#[derive(Debug)]
23708pub struct BaseNetworkSocketSetMarkResponder {
23709 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23710 tx_id: u32,
23711}
23712
23713impl std::ops::Drop for BaseNetworkSocketSetMarkResponder {
23717 fn drop(&mut self) {
23718 self.control_handle.shutdown();
23719 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23721 }
23722}
23723
23724impl fidl::endpoints::Responder for BaseNetworkSocketSetMarkResponder {
23725 type ControlHandle = BaseNetworkSocketControlHandle;
23726
23727 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23728 &self.control_handle
23729 }
23730
23731 fn drop_without_shutdown(mut self) {
23732 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23734 std::mem::forget(self);
23736 }
23737}
23738
23739impl BaseNetworkSocketSetMarkResponder {
23740 pub fn send(
23744 self,
23745 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23746 ) -> Result<(), fidl::Error> {
23747 let _result = self.send_raw(result);
23748 if _result.is_err() {
23749 self.control_handle.shutdown();
23750 }
23751 self.drop_without_shutdown();
23752 _result
23753 }
23754
23755 pub fn send_no_shutdown_on_err(
23757 self,
23758 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23759 ) -> Result<(), fidl::Error> {
23760 let _result = self.send_raw(result);
23761 self.drop_without_shutdown();
23762 _result
23763 }
23764
23765 fn send_raw(
23766 &self,
23767 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23768 ) -> Result<(), fidl::Error> {
23769 self.control_handle.inner.send::<fidl::encoding::ResultType<
23770 fidl::encoding::EmptyStruct,
23771 fidl_fuchsia_posix::Errno,
23772 >>(
23773 result,
23774 self.tx_id,
23775 0x6ead6de09f653236,
23776 fidl::encoding::DynamicFlags::empty(),
23777 )
23778 }
23779}
23780
23781#[must_use = "FIDL methods require a response to be sent"]
23782#[derive(Debug)]
23783pub struct BaseNetworkSocketGetMarkResponder {
23784 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23785 tx_id: u32,
23786}
23787
23788impl std::ops::Drop for BaseNetworkSocketGetMarkResponder {
23792 fn drop(&mut self) {
23793 self.control_handle.shutdown();
23794 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23796 }
23797}
23798
23799impl fidl::endpoints::Responder for BaseNetworkSocketGetMarkResponder {
23800 type ControlHandle = BaseNetworkSocketControlHandle;
23801
23802 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23803 &self.control_handle
23804 }
23805
23806 fn drop_without_shutdown(mut self) {
23807 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23809 std::mem::forget(self);
23811 }
23812}
23813
23814impl BaseNetworkSocketGetMarkResponder {
23815 pub fn send(
23819 self,
23820 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
23821 ) -> Result<(), fidl::Error> {
23822 let _result = self.send_raw(result);
23823 if _result.is_err() {
23824 self.control_handle.shutdown();
23825 }
23826 self.drop_without_shutdown();
23827 _result
23828 }
23829
23830 pub fn send_no_shutdown_on_err(
23832 self,
23833 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
23834 ) -> Result<(), fidl::Error> {
23835 let _result = self.send_raw(result);
23836 self.drop_without_shutdown();
23837 _result
23838 }
23839
23840 fn send_raw(
23841 &self,
23842 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
23843 ) -> Result<(), fidl::Error> {
23844 self.control_handle.inner.send::<fidl::encoding::ResultType<
23845 BaseSocketGetMarkResponse,
23846 fidl_fuchsia_posix::Errno,
23847 >>(
23848 result.map(|mark| (mark,)),
23849 self.tx_id,
23850 0x57a2752c61d93d47,
23851 fidl::encoding::DynamicFlags::empty(),
23852 )
23853 }
23854}
23855
23856#[must_use = "FIDL methods require a response to be sent"]
23857#[derive(Debug)]
23858pub struct BaseNetworkSocketBindResponder {
23859 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23860 tx_id: u32,
23861}
23862
23863impl std::ops::Drop for BaseNetworkSocketBindResponder {
23867 fn drop(&mut self) {
23868 self.control_handle.shutdown();
23869 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23871 }
23872}
23873
23874impl fidl::endpoints::Responder for BaseNetworkSocketBindResponder {
23875 type ControlHandle = BaseNetworkSocketControlHandle;
23876
23877 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23878 &self.control_handle
23879 }
23880
23881 fn drop_without_shutdown(mut self) {
23882 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23884 std::mem::forget(self);
23886 }
23887}
23888
23889impl BaseNetworkSocketBindResponder {
23890 pub fn send(
23894 self,
23895 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23896 ) -> Result<(), fidl::Error> {
23897 let _result = self.send_raw(result);
23898 if _result.is_err() {
23899 self.control_handle.shutdown();
23900 }
23901 self.drop_without_shutdown();
23902 _result
23903 }
23904
23905 pub fn send_no_shutdown_on_err(
23907 self,
23908 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23909 ) -> Result<(), fidl::Error> {
23910 let _result = self.send_raw(result);
23911 self.drop_without_shutdown();
23912 _result
23913 }
23914
23915 fn send_raw(
23916 &self,
23917 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23918 ) -> Result<(), fidl::Error> {
23919 self.control_handle.inner.send::<fidl::encoding::ResultType<
23920 fidl::encoding::EmptyStruct,
23921 fidl_fuchsia_posix::Errno,
23922 >>(
23923 result,
23924 self.tx_id,
23925 0x4bc6400ae92125d,
23926 fidl::encoding::DynamicFlags::empty(),
23927 )
23928 }
23929}
23930
23931#[must_use = "FIDL methods require a response to be sent"]
23932#[derive(Debug)]
23933pub struct BaseNetworkSocketConnectResponder {
23934 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23935 tx_id: u32,
23936}
23937
23938impl std::ops::Drop for BaseNetworkSocketConnectResponder {
23942 fn drop(&mut self) {
23943 self.control_handle.shutdown();
23944 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23946 }
23947}
23948
23949impl fidl::endpoints::Responder for BaseNetworkSocketConnectResponder {
23950 type ControlHandle = BaseNetworkSocketControlHandle;
23951
23952 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23953 &self.control_handle
23954 }
23955
23956 fn drop_without_shutdown(mut self) {
23957 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23959 std::mem::forget(self);
23961 }
23962}
23963
23964impl BaseNetworkSocketConnectResponder {
23965 pub fn send(
23969 self,
23970 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23971 ) -> Result<(), fidl::Error> {
23972 let _result = self.send_raw(result);
23973 if _result.is_err() {
23974 self.control_handle.shutdown();
23975 }
23976 self.drop_without_shutdown();
23977 _result
23978 }
23979
23980 pub fn send_no_shutdown_on_err(
23982 self,
23983 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23984 ) -> Result<(), fidl::Error> {
23985 let _result = self.send_raw(result);
23986 self.drop_without_shutdown();
23987 _result
23988 }
23989
23990 fn send_raw(
23991 &self,
23992 mut result: Result<(), fidl_fuchsia_posix::Errno>,
23993 ) -> Result<(), fidl::Error> {
23994 self.control_handle.inner.send::<fidl::encoding::ResultType<
23995 fidl::encoding::EmptyStruct,
23996 fidl_fuchsia_posix::Errno,
23997 >>(
23998 result,
23999 self.tx_id,
24000 0x5f05f19bfdd38871,
24001 fidl::encoding::DynamicFlags::empty(),
24002 )
24003 }
24004}
24005
24006#[must_use = "FIDL methods require a response to be sent"]
24007#[derive(Debug)]
24008pub struct BaseNetworkSocketDisconnectResponder {
24009 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24010 tx_id: u32,
24011}
24012
24013impl std::ops::Drop for BaseNetworkSocketDisconnectResponder {
24017 fn drop(&mut self) {
24018 self.control_handle.shutdown();
24019 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24021 }
24022}
24023
24024impl fidl::endpoints::Responder for BaseNetworkSocketDisconnectResponder {
24025 type ControlHandle = BaseNetworkSocketControlHandle;
24026
24027 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24028 &self.control_handle
24029 }
24030
24031 fn drop_without_shutdown(mut self) {
24032 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24034 std::mem::forget(self);
24036 }
24037}
24038
24039impl BaseNetworkSocketDisconnectResponder {
24040 pub fn send(
24044 self,
24045 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24046 ) -> Result<(), fidl::Error> {
24047 let _result = self.send_raw(result);
24048 if _result.is_err() {
24049 self.control_handle.shutdown();
24050 }
24051 self.drop_without_shutdown();
24052 _result
24053 }
24054
24055 pub fn send_no_shutdown_on_err(
24057 self,
24058 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24059 ) -> Result<(), fidl::Error> {
24060 let _result = self.send_raw(result);
24061 self.drop_without_shutdown();
24062 _result
24063 }
24064
24065 fn send_raw(
24066 &self,
24067 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24068 ) -> Result<(), fidl::Error> {
24069 self.control_handle.inner.send::<fidl::encoding::ResultType<
24070 fidl::encoding::EmptyStruct,
24071 fidl_fuchsia_posix::Errno,
24072 >>(
24073 result,
24074 self.tx_id,
24075 0x74e63b91f7b29b2,
24076 fidl::encoding::DynamicFlags::empty(),
24077 )
24078 }
24079}
24080
24081#[must_use = "FIDL methods require a response to be sent"]
24082#[derive(Debug)]
24083pub struct BaseNetworkSocketGetSockNameResponder {
24084 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24085 tx_id: u32,
24086}
24087
24088impl std::ops::Drop for BaseNetworkSocketGetSockNameResponder {
24092 fn drop(&mut self) {
24093 self.control_handle.shutdown();
24094 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24096 }
24097}
24098
24099impl fidl::endpoints::Responder for BaseNetworkSocketGetSockNameResponder {
24100 type ControlHandle = BaseNetworkSocketControlHandle;
24101
24102 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24103 &self.control_handle
24104 }
24105
24106 fn drop_without_shutdown(mut self) {
24107 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24109 std::mem::forget(self);
24111 }
24112}
24113
24114impl BaseNetworkSocketGetSockNameResponder {
24115 pub fn send(
24119 self,
24120 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
24121 ) -> Result<(), fidl::Error> {
24122 let _result = self.send_raw(result);
24123 if _result.is_err() {
24124 self.control_handle.shutdown();
24125 }
24126 self.drop_without_shutdown();
24127 _result
24128 }
24129
24130 pub fn send_no_shutdown_on_err(
24132 self,
24133 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
24134 ) -> Result<(), fidl::Error> {
24135 let _result = self.send_raw(result);
24136 self.drop_without_shutdown();
24137 _result
24138 }
24139
24140 fn send_raw(
24141 &self,
24142 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
24143 ) -> Result<(), fidl::Error> {
24144 self.control_handle.inner.send::<fidl::encoding::ResultType<
24145 BaseNetworkSocketGetSockNameResponse,
24146 fidl_fuchsia_posix::Errno,
24147 >>(
24148 result.map(|addr| (addr,)),
24149 self.tx_id,
24150 0x475f23f84a1a4f85,
24151 fidl::encoding::DynamicFlags::empty(),
24152 )
24153 }
24154}
24155
24156#[must_use = "FIDL methods require a response to be sent"]
24157#[derive(Debug)]
24158pub struct BaseNetworkSocketGetPeerNameResponder {
24159 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24160 tx_id: u32,
24161}
24162
24163impl std::ops::Drop for BaseNetworkSocketGetPeerNameResponder {
24167 fn drop(&mut self) {
24168 self.control_handle.shutdown();
24169 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24171 }
24172}
24173
24174impl fidl::endpoints::Responder for BaseNetworkSocketGetPeerNameResponder {
24175 type ControlHandle = BaseNetworkSocketControlHandle;
24176
24177 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24178 &self.control_handle
24179 }
24180
24181 fn drop_without_shutdown(mut self) {
24182 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24184 std::mem::forget(self);
24186 }
24187}
24188
24189impl BaseNetworkSocketGetPeerNameResponder {
24190 pub fn send(
24194 self,
24195 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
24196 ) -> Result<(), fidl::Error> {
24197 let _result = self.send_raw(result);
24198 if _result.is_err() {
24199 self.control_handle.shutdown();
24200 }
24201 self.drop_without_shutdown();
24202 _result
24203 }
24204
24205 pub fn send_no_shutdown_on_err(
24207 self,
24208 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
24209 ) -> Result<(), fidl::Error> {
24210 let _result = self.send_raw(result);
24211 self.drop_without_shutdown();
24212 _result
24213 }
24214
24215 fn send_raw(
24216 &self,
24217 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
24218 ) -> Result<(), fidl::Error> {
24219 self.control_handle.inner.send::<fidl::encoding::ResultType<
24220 BaseNetworkSocketGetPeerNameResponse,
24221 fidl_fuchsia_posix::Errno,
24222 >>(
24223 result.map(|addr| (addr,)),
24224 self.tx_id,
24225 0x1ffecf4bd5b6432e,
24226 fidl::encoding::DynamicFlags::empty(),
24227 )
24228 }
24229}
24230
24231#[must_use = "FIDL methods require a response to be sent"]
24232#[derive(Debug)]
24233pub struct BaseNetworkSocketShutdownResponder {
24234 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24235 tx_id: u32,
24236}
24237
24238impl std::ops::Drop for BaseNetworkSocketShutdownResponder {
24242 fn drop(&mut self) {
24243 self.control_handle.shutdown();
24244 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24246 }
24247}
24248
24249impl fidl::endpoints::Responder for BaseNetworkSocketShutdownResponder {
24250 type ControlHandle = BaseNetworkSocketControlHandle;
24251
24252 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24253 &self.control_handle
24254 }
24255
24256 fn drop_without_shutdown(mut self) {
24257 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24259 std::mem::forget(self);
24261 }
24262}
24263
24264impl BaseNetworkSocketShutdownResponder {
24265 pub fn send(
24269 self,
24270 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24271 ) -> Result<(), fidl::Error> {
24272 let _result = self.send_raw(result);
24273 if _result.is_err() {
24274 self.control_handle.shutdown();
24275 }
24276 self.drop_without_shutdown();
24277 _result
24278 }
24279
24280 pub fn send_no_shutdown_on_err(
24282 self,
24283 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24284 ) -> Result<(), fidl::Error> {
24285 let _result = self.send_raw(result);
24286 self.drop_without_shutdown();
24287 _result
24288 }
24289
24290 fn send_raw(
24291 &self,
24292 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24293 ) -> Result<(), fidl::Error> {
24294 self.control_handle.inner.send::<fidl::encoding::ResultType<
24295 fidl::encoding::EmptyStruct,
24296 fidl_fuchsia_posix::Errno,
24297 >>(
24298 result,
24299 self.tx_id,
24300 0x247f38b6db68c336,
24301 fidl::encoding::DynamicFlags::empty(),
24302 )
24303 }
24304}
24305
24306#[must_use = "FIDL methods require a response to be sent"]
24307#[derive(Debug)]
24308pub struct BaseNetworkSocketSetIpTypeOfServiceResponder {
24309 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24310 tx_id: u32,
24311}
24312
24313impl std::ops::Drop for BaseNetworkSocketSetIpTypeOfServiceResponder {
24317 fn drop(&mut self) {
24318 self.control_handle.shutdown();
24319 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24321 }
24322}
24323
24324impl fidl::endpoints::Responder for BaseNetworkSocketSetIpTypeOfServiceResponder {
24325 type ControlHandle = BaseNetworkSocketControlHandle;
24326
24327 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24328 &self.control_handle
24329 }
24330
24331 fn drop_without_shutdown(mut self) {
24332 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24334 std::mem::forget(self);
24336 }
24337}
24338
24339impl BaseNetworkSocketSetIpTypeOfServiceResponder {
24340 pub fn send(
24344 self,
24345 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24346 ) -> Result<(), fidl::Error> {
24347 let _result = self.send_raw(result);
24348 if _result.is_err() {
24349 self.control_handle.shutdown();
24350 }
24351 self.drop_without_shutdown();
24352 _result
24353 }
24354
24355 pub fn send_no_shutdown_on_err(
24357 self,
24358 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24359 ) -> Result<(), fidl::Error> {
24360 let _result = self.send_raw(result);
24361 self.drop_without_shutdown();
24362 _result
24363 }
24364
24365 fn send_raw(
24366 &self,
24367 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24368 ) -> Result<(), fidl::Error> {
24369 self.control_handle.inner.send::<fidl::encoding::ResultType<
24370 fidl::encoding::EmptyStruct,
24371 fidl_fuchsia_posix::Errno,
24372 >>(
24373 result,
24374 self.tx_id,
24375 0x995c600475b6d46,
24376 fidl::encoding::DynamicFlags::empty(),
24377 )
24378 }
24379}
24380
24381#[must_use = "FIDL methods require a response to be sent"]
24382#[derive(Debug)]
24383pub struct BaseNetworkSocketGetIpTypeOfServiceResponder {
24384 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24385 tx_id: u32,
24386}
24387
24388impl std::ops::Drop for BaseNetworkSocketGetIpTypeOfServiceResponder {
24392 fn drop(&mut self) {
24393 self.control_handle.shutdown();
24394 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24396 }
24397}
24398
24399impl fidl::endpoints::Responder for BaseNetworkSocketGetIpTypeOfServiceResponder {
24400 type ControlHandle = BaseNetworkSocketControlHandle;
24401
24402 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24403 &self.control_handle
24404 }
24405
24406 fn drop_without_shutdown(mut self) {
24407 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24409 std::mem::forget(self);
24411 }
24412}
24413
24414impl BaseNetworkSocketGetIpTypeOfServiceResponder {
24415 pub fn send(
24419 self,
24420 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
24421 ) -> Result<(), fidl::Error> {
24422 let _result = self.send_raw(result);
24423 if _result.is_err() {
24424 self.control_handle.shutdown();
24425 }
24426 self.drop_without_shutdown();
24427 _result
24428 }
24429
24430 pub fn send_no_shutdown_on_err(
24432 self,
24433 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
24434 ) -> Result<(), fidl::Error> {
24435 let _result = self.send_raw(result);
24436 self.drop_without_shutdown();
24437 _result
24438 }
24439
24440 fn send_raw(
24441 &self,
24442 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
24443 ) -> Result<(), fidl::Error> {
24444 self.control_handle.inner.send::<fidl::encoding::ResultType<
24445 BaseNetworkSocketGetIpTypeOfServiceResponse,
24446 fidl_fuchsia_posix::Errno,
24447 >>(
24448 result.map(|value| (value,)),
24449 self.tx_id,
24450 0x3814a04259f75fcb,
24451 fidl::encoding::DynamicFlags::empty(),
24452 )
24453 }
24454}
24455
24456#[must_use = "FIDL methods require a response to be sent"]
24457#[derive(Debug)]
24458pub struct BaseNetworkSocketSetIpTtlResponder {
24459 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24460 tx_id: u32,
24461}
24462
24463impl std::ops::Drop for BaseNetworkSocketSetIpTtlResponder {
24467 fn drop(&mut self) {
24468 self.control_handle.shutdown();
24469 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24471 }
24472}
24473
24474impl fidl::endpoints::Responder for BaseNetworkSocketSetIpTtlResponder {
24475 type ControlHandle = BaseNetworkSocketControlHandle;
24476
24477 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24478 &self.control_handle
24479 }
24480
24481 fn drop_without_shutdown(mut self) {
24482 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24484 std::mem::forget(self);
24486 }
24487}
24488
24489impl BaseNetworkSocketSetIpTtlResponder {
24490 pub fn send(
24494 self,
24495 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24496 ) -> Result<(), fidl::Error> {
24497 let _result = self.send_raw(result);
24498 if _result.is_err() {
24499 self.control_handle.shutdown();
24500 }
24501 self.drop_without_shutdown();
24502 _result
24503 }
24504
24505 pub fn send_no_shutdown_on_err(
24507 self,
24508 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24509 ) -> Result<(), fidl::Error> {
24510 let _result = self.send_raw(result);
24511 self.drop_without_shutdown();
24512 _result
24513 }
24514
24515 fn send_raw(
24516 &self,
24517 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24518 ) -> Result<(), fidl::Error> {
24519 self.control_handle.inner.send::<fidl::encoding::ResultType<
24520 fidl::encoding::EmptyStruct,
24521 fidl_fuchsia_posix::Errno,
24522 >>(
24523 result,
24524 self.tx_id,
24525 0x29e2424b433ae1ef,
24526 fidl::encoding::DynamicFlags::empty(),
24527 )
24528 }
24529}
24530
24531#[must_use = "FIDL methods require a response to be sent"]
24532#[derive(Debug)]
24533pub struct BaseNetworkSocketGetIpTtlResponder {
24534 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24535 tx_id: u32,
24536}
24537
24538impl std::ops::Drop for BaseNetworkSocketGetIpTtlResponder {
24542 fn drop(&mut self) {
24543 self.control_handle.shutdown();
24544 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24546 }
24547}
24548
24549impl fidl::endpoints::Responder for BaseNetworkSocketGetIpTtlResponder {
24550 type ControlHandle = BaseNetworkSocketControlHandle;
24551
24552 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24553 &self.control_handle
24554 }
24555
24556 fn drop_without_shutdown(mut self) {
24557 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24559 std::mem::forget(self);
24561 }
24562}
24563
24564impl BaseNetworkSocketGetIpTtlResponder {
24565 pub fn send(
24569 self,
24570 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
24571 ) -> Result<(), fidl::Error> {
24572 let _result = self.send_raw(result);
24573 if _result.is_err() {
24574 self.control_handle.shutdown();
24575 }
24576 self.drop_without_shutdown();
24577 _result
24578 }
24579
24580 pub fn send_no_shutdown_on_err(
24582 self,
24583 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
24584 ) -> Result<(), fidl::Error> {
24585 let _result = self.send_raw(result);
24586 self.drop_without_shutdown();
24587 _result
24588 }
24589
24590 fn send_raw(
24591 &self,
24592 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
24593 ) -> Result<(), fidl::Error> {
24594 self.control_handle.inner.send::<fidl::encoding::ResultType<
24595 BaseNetworkSocketGetIpTtlResponse,
24596 fidl_fuchsia_posix::Errno,
24597 >>(
24598 result.map(|value| (value,)),
24599 self.tx_id,
24600 0x47e47fa1f24da471,
24601 fidl::encoding::DynamicFlags::empty(),
24602 )
24603 }
24604}
24605
24606#[must_use = "FIDL methods require a response to be sent"]
24607#[derive(Debug)]
24608pub struct BaseNetworkSocketSetIpPacketInfoResponder {
24609 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24610 tx_id: u32,
24611}
24612
24613impl std::ops::Drop for BaseNetworkSocketSetIpPacketInfoResponder {
24617 fn drop(&mut self) {
24618 self.control_handle.shutdown();
24619 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24621 }
24622}
24623
24624impl fidl::endpoints::Responder for BaseNetworkSocketSetIpPacketInfoResponder {
24625 type ControlHandle = BaseNetworkSocketControlHandle;
24626
24627 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24628 &self.control_handle
24629 }
24630
24631 fn drop_without_shutdown(mut self) {
24632 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24634 std::mem::forget(self);
24636 }
24637}
24638
24639impl BaseNetworkSocketSetIpPacketInfoResponder {
24640 pub fn send(
24644 self,
24645 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24646 ) -> Result<(), fidl::Error> {
24647 let _result = self.send_raw(result);
24648 if _result.is_err() {
24649 self.control_handle.shutdown();
24650 }
24651 self.drop_without_shutdown();
24652 _result
24653 }
24654
24655 pub fn send_no_shutdown_on_err(
24657 self,
24658 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24659 ) -> Result<(), fidl::Error> {
24660 let _result = self.send_raw(result);
24661 self.drop_without_shutdown();
24662 _result
24663 }
24664
24665 fn send_raw(
24666 &self,
24667 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24668 ) -> Result<(), fidl::Error> {
24669 self.control_handle.inner.send::<fidl::encoding::ResultType<
24670 fidl::encoding::EmptyStruct,
24671 fidl_fuchsia_posix::Errno,
24672 >>(
24673 result,
24674 self.tx_id,
24675 0x392d16bee20c0e16,
24676 fidl::encoding::DynamicFlags::empty(),
24677 )
24678 }
24679}
24680
24681#[must_use = "FIDL methods require a response to be sent"]
24682#[derive(Debug)]
24683pub struct BaseNetworkSocketGetIpPacketInfoResponder {
24684 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24685 tx_id: u32,
24686}
24687
24688impl std::ops::Drop for BaseNetworkSocketGetIpPacketInfoResponder {
24692 fn drop(&mut self) {
24693 self.control_handle.shutdown();
24694 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24696 }
24697}
24698
24699impl fidl::endpoints::Responder for BaseNetworkSocketGetIpPacketInfoResponder {
24700 type ControlHandle = BaseNetworkSocketControlHandle;
24701
24702 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24703 &self.control_handle
24704 }
24705
24706 fn drop_without_shutdown(mut self) {
24707 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24709 std::mem::forget(self);
24711 }
24712}
24713
24714impl BaseNetworkSocketGetIpPacketInfoResponder {
24715 pub fn send(
24719 self,
24720 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
24721 ) -> Result<(), fidl::Error> {
24722 let _result = self.send_raw(result);
24723 if _result.is_err() {
24724 self.control_handle.shutdown();
24725 }
24726 self.drop_without_shutdown();
24727 _result
24728 }
24729
24730 pub fn send_no_shutdown_on_err(
24732 self,
24733 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
24734 ) -> Result<(), fidl::Error> {
24735 let _result = self.send_raw(result);
24736 self.drop_without_shutdown();
24737 _result
24738 }
24739
24740 fn send_raw(
24741 &self,
24742 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
24743 ) -> Result<(), fidl::Error> {
24744 self.control_handle.inner.send::<fidl::encoding::ResultType<
24745 BaseNetworkSocketGetIpPacketInfoResponse,
24746 fidl_fuchsia_posix::Errno,
24747 >>(
24748 result.map(|value| (value,)),
24749 self.tx_id,
24750 0x54b505f242280740,
24751 fidl::encoding::DynamicFlags::empty(),
24752 )
24753 }
24754}
24755
24756#[must_use = "FIDL methods require a response to be sent"]
24757#[derive(Debug)]
24758pub struct BaseNetworkSocketSetIpReceiveTypeOfServiceResponder {
24759 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24760 tx_id: u32,
24761}
24762
24763impl std::ops::Drop for BaseNetworkSocketSetIpReceiveTypeOfServiceResponder {
24767 fn drop(&mut self) {
24768 self.control_handle.shutdown();
24769 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24771 }
24772}
24773
24774impl fidl::endpoints::Responder for BaseNetworkSocketSetIpReceiveTypeOfServiceResponder {
24775 type ControlHandle = BaseNetworkSocketControlHandle;
24776
24777 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24778 &self.control_handle
24779 }
24780
24781 fn drop_without_shutdown(mut self) {
24782 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24784 std::mem::forget(self);
24786 }
24787}
24788
24789impl BaseNetworkSocketSetIpReceiveTypeOfServiceResponder {
24790 pub fn send(
24794 self,
24795 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24796 ) -> Result<(), fidl::Error> {
24797 let _result = self.send_raw(result);
24798 if _result.is_err() {
24799 self.control_handle.shutdown();
24800 }
24801 self.drop_without_shutdown();
24802 _result
24803 }
24804
24805 pub fn send_no_shutdown_on_err(
24807 self,
24808 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24809 ) -> Result<(), fidl::Error> {
24810 let _result = self.send_raw(result);
24811 self.drop_without_shutdown();
24812 _result
24813 }
24814
24815 fn send_raw(
24816 &self,
24817 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24818 ) -> Result<(), fidl::Error> {
24819 self.control_handle.inner.send::<fidl::encoding::ResultType<
24820 fidl::encoding::EmptyStruct,
24821 fidl_fuchsia_posix::Errno,
24822 >>(
24823 result,
24824 self.tx_id,
24825 0x6c4f6714995f84ef,
24826 fidl::encoding::DynamicFlags::empty(),
24827 )
24828 }
24829}
24830
24831#[must_use = "FIDL methods require a response to be sent"]
24832#[derive(Debug)]
24833pub struct BaseNetworkSocketGetIpReceiveTypeOfServiceResponder {
24834 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24835 tx_id: u32,
24836}
24837
24838impl std::ops::Drop for BaseNetworkSocketGetIpReceiveTypeOfServiceResponder {
24842 fn drop(&mut self) {
24843 self.control_handle.shutdown();
24844 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24846 }
24847}
24848
24849impl fidl::endpoints::Responder for BaseNetworkSocketGetIpReceiveTypeOfServiceResponder {
24850 type ControlHandle = BaseNetworkSocketControlHandle;
24851
24852 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24853 &self.control_handle
24854 }
24855
24856 fn drop_without_shutdown(mut self) {
24857 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24859 std::mem::forget(self);
24861 }
24862}
24863
24864impl BaseNetworkSocketGetIpReceiveTypeOfServiceResponder {
24865 pub fn send(
24869 self,
24870 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
24871 ) -> Result<(), fidl::Error> {
24872 let _result = self.send_raw(result);
24873 if _result.is_err() {
24874 self.control_handle.shutdown();
24875 }
24876 self.drop_without_shutdown();
24877 _result
24878 }
24879
24880 pub fn send_no_shutdown_on_err(
24882 self,
24883 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
24884 ) -> Result<(), fidl::Error> {
24885 let _result = self.send_raw(result);
24886 self.drop_without_shutdown();
24887 _result
24888 }
24889
24890 fn send_raw(
24891 &self,
24892 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
24893 ) -> Result<(), fidl::Error> {
24894 self.control_handle.inner.send::<fidl::encoding::ResultType<
24895 BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
24896 fidl_fuchsia_posix::Errno,
24897 >>(
24898 result.map(|value| (value,)),
24899 self.tx_id,
24900 0x4158ba7dc2795960,
24901 fidl::encoding::DynamicFlags::empty(),
24902 )
24903 }
24904}
24905
24906#[must_use = "FIDL methods require a response to be sent"]
24907#[derive(Debug)]
24908pub struct BaseNetworkSocketSetIpReceiveTtlResponder {
24909 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24910 tx_id: u32,
24911}
24912
24913impl std::ops::Drop for BaseNetworkSocketSetIpReceiveTtlResponder {
24917 fn drop(&mut self) {
24918 self.control_handle.shutdown();
24919 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24921 }
24922}
24923
24924impl fidl::endpoints::Responder for BaseNetworkSocketSetIpReceiveTtlResponder {
24925 type ControlHandle = BaseNetworkSocketControlHandle;
24926
24927 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24928 &self.control_handle
24929 }
24930
24931 fn drop_without_shutdown(mut self) {
24932 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24934 std::mem::forget(self);
24936 }
24937}
24938
24939impl BaseNetworkSocketSetIpReceiveTtlResponder {
24940 pub fn send(
24944 self,
24945 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24946 ) -> Result<(), fidl::Error> {
24947 let _result = self.send_raw(result);
24948 if _result.is_err() {
24949 self.control_handle.shutdown();
24950 }
24951 self.drop_without_shutdown();
24952 _result
24953 }
24954
24955 pub fn send_no_shutdown_on_err(
24957 self,
24958 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24959 ) -> Result<(), fidl::Error> {
24960 let _result = self.send_raw(result);
24961 self.drop_without_shutdown();
24962 _result
24963 }
24964
24965 fn send_raw(
24966 &self,
24967 mut result: Result<(), fidl_fuchsia_posix::Errno>,
24968 ) -> Result<(), fidl::Error> {
24969 self.control_handle.inner.send::<fidl::encoding::ResultType<
24970 fidl::encoding::EmptyStruct,
24971 fidl_fuchsia_posix::Errno,
24972 >>(
24973 result,
24974 self.tx_id,
24975 0x46f15be0ce0ab82b,
24976 fidl::encoding::DynamicFlags::empty(),
24977 )
24978 }
24979}
24980
24981#[must_use = "FIDL methods require a response to be sent"]
24982#[derive(Debug)]
24983pub struct BaseNetworkSocketGetIpReceiveTtlResponder {
24984 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24985 tx_id: u32,
24986}
24987
24988impl std::ops::Drop for BaseNetworkSocketGetIpReceiveTtlResponder {
24992 fn drop(&mut self) {
24993 self.control_handle.shutdown();
24994 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24996 }
24997}
24998
24999impl fidl::endpoints::Responder for BaseNetworkSocketGetIpReceiveTtlResponder {
25000 type ControlHandle = BaseNetworkSocketControlHandle;
25001
25002 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25003 &self.control_handle
25004 }
25005
25006 fn drop_without_shutdown(mut self) {
25007 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25009 std::mem::forget(self);
25011 }
25012}
25013
25014impl BaseNetworkSocketGetIpReceiveTtlResponder {
25015 pub fn send(
25019 self,
25020 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25021 ) -> Result<(), fidl::Error> {
25022 let _result = self.send_raw(result);
25023 if _result.is_err() {
25024 self.control_handle.shutdown();
25025 }
25026 self.drop_without_shutdown();
25027 _result
25028 }
25029
25030 pub fn send_no_shutdown_on_err(
25032 self,
25033 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25034 ) -> Result<(), fidl::Error> {
25035 let _result = self.send_raw(result);
25036 self.drop_without_shutdown();
25037 _result
25038 }
25039
25040 fn send_raw(
25041 &self,
25042 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25043 ) -> Result<(), fidl::Error> {
25044 self.control_handle.inner.send::<fidl::encoding::ResultType<
25045 BaseNetworkSocketGetIpReceiveTtlResponse,
25046 fidl_fuchsia_posix::Errno,
25047 >>(
25048 result.map(|value| (value,)),
25049 self.tx_id,
25050 0x678ddd5a5dfa2eb5,
25051 fidl::encoding::DynamicFlags::empty(),
25052 )
25053 }
25054}
25055
25056#[must_use = "FIDL methods require a response to be sent"]
25057#[derive(Debug)]
25058pub struct BaseNetworkSocketSetIpMulticastInterfaceResponder {
25059 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25060 tx_id: u32,
25061}
25062
25063impl std::ops::Drop for BaseNetworkSocketSetIpMulticastInterfaceResponder {
25067 fn drop(&mut self) {
25068 self.control_handle.shutdown();
25069 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25071 }
25072}
25073
25074impl fidl::endpoints::Responder for BaseNetworkSocketSetIpMulticastInterfaceResponder {
25075 type ControlHandle = BaseNetworkSocketControlHandle;
25076
25077 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25078 &self.control_handle
25079 }
25080
25081 fn drop_without_shutdown(mut self) {
25082 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25084 std::mem::forget(self);
25086 }
25087}
25088
25089impl BaseNetworkSocketSetIpMulticastInterfaceResponder {
25090 pub fn send(
25094 self,
25095 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25096 ) -> Result<(), fidl::Error> {
25097 let _result = self.send_raw(result);
25098 if _result.is_err() {
25099 self.control_handle.shutdown();
25100 }
25101 self.drop_without_shutdown();
25102 _result
25103 }
25104
25105 pub fn send_no_shutdown_on_err(
25107 self,
25108 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25109 ) -> Result<(), fidl::Error> {
25110 let _result = self.send_raw(result);
25111 self.drop_without_shutdown();
25112 _result
25113 }
25114
25115 fn send_raw(
25116 &self,
25117 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25118 ) -> Result<(), fidl::Error> {
25119 self.control_handle.inner.send::<fidl::encoding::ResultType<
25120 fidl::encoding::EmptyStruct,
25121 fidl_fuchsia_posix::Errno,
25122 >>(
25123 result,
25124 self.tx_id,
25125 0x752fbfa9b12befe,
25126 fidl::encoding::DynamicFlags::empty(),
25127 )
25128 }
25129}
25130
25131#[must_use = "FIDL methods require a response to be sent"]
25132#[derive(Debug)]
25133pub struct BaseNetworkSocketGetIpMulticastInterfaceResponder {
25134 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25135 tx_id: u32,
25136}
25137
25138impl std::ops::Drop for BaseNetworkSocketGetIpMulticastInterfaceResponder {
25142 fn drop(&mut self) {
25143 self.control_handle.shutdown();
25144 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25146 }
25147}
25148
25149impl fidl::endpoints::Responder for BaseNetworkSocketGetIpMulticastInterfaceResponder {
25150 type ControlHandle = BaseNetworkSocketControlHandle;
25151
25152 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25153 &self.control_handle
25154 }
25155
25156 fn drop_without_shutdown(mut self) {
25157 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25159 std::mem::forget(self);
25161 }
25162}
25163
25164impl BaseNetworkSocketGetIpMulticastInterfaceResponder {
25165 pub fn send(
25169 self,
25170 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
25171 ) -> Result<(), fidl::Error> {
25172 let _result = self.send_raw(result);
25173 if _result.is_err() {
25174 self.control_handle.shutdown();
25175 }
25176 self.drop_without_shutdown();
25177 _result
25178 }
25179
25180 pub fn send_no_shutdown_on_err(
25182 self,
25183 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
25184 ) -> Result<(), fidl::Error> {
25185 let _result = self.send_raw(result);
25186 self.drop_without_shutdown();
25187 _result
25188 }
25189
25190 fn send_raw(
25191 &self,
25192 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
25193 ) -> Result<(), fidl::Error> {
25194 self.control_handle.inner.send::<fidl::encoding::ResultType<
25195 BaseNetworkSocketGetIpMulticastInterfaceResponse,
25196 fidl_fuchsia_posix::Errno,
25197 >>(
25198 result.map(|value| (value,)),
25199 self.tx_id,
25200 0x320bd14c4df046c4,
25201 fidl::encoding::DynamicFlags::empty(),
25202 )
25203 }
25204}
25205
25206#[must_use = "FIDL methods require a response to be sent"]
25207#[derive(Debug)]
25208pub struct BaseNetworkSocketSetIpMulticastTtlResponder {
25209 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25210 tx_id: u32,
25211}
25212
25213impl std::ops::Drop for BaseNetworkSocketSetIpMulticastTtlResponder {
25217 fn drop(&mut self) {
25218 self.control_handle.shutdown();
25219 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25221 }
25222}
25223
25224impl fidl::endpoints::Responder for BaseNetworkSocketSetIpMulticastTtlResponder {
25225 type ControlHandle = BaseNetworkSocketControlHandle;
25226
25227 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25228 &self.control_handle
25229 }
25230
25231 fn drop_without_shutdown(mut self) {
25232 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25234 std::mem::forget(self);
25236 }
25237}
25238
25239impl BaseNetworkSocketSetIpMulticastTtlResponder {
25240 pub fn send(
25244 self,
25245 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25246 ) -> Result<(), fidl::Error> {
25247 let _result = self.send_raw(result);
25248 if _result.is_err() {
25249 self.control_handle.shutdown();
25250 }
25251 self.drop_without_shutdown();
25252 _result
25253 }
25254
25255 pub fn send_no_shutdown_on_err(
25257 self,
25258 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25259 ) -> Result<(), fidl::Error> {
25260 let _result = self.send_raw(result);
25261 self.drop_without_shutdown();
25262 _result
25263 }
25264
25265 fn send_raw(
25266 &self,
25267 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25268 ) -> Result<(), fidl::Error> {
25269 self.control_handle.inner.send::<fidl::encoding::ResultType<
25270 fidl::encoding::EmptyStruct,
25271 fidl_fuchsia_posix::Errno,
25272 >>(
25273 result,
25274 self.tx_id,
25275 0x63134d53772916a1,
25276 fidl::encoding::DynamicFlags::empty(),
25277 )
25278 }
25279}
25280
25281#[must_use = "FIDL methods require a response to be sent"]
25282#[derive(Debug)]
25283pub struct BaseNetworkSocketGetIpMulticastTtlResponder {
25284 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25285 tx_id: u32,
25286}
25287
25288impl std::ops::Drop for BaseNetworkSocketGetIpMulticastTtlResponder {
25292 fn drop(&mut self) {
25293 self.control_handle.shutdown();
25294 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25296 }
25297}
25298
25299impl fidl::endpoints::Responder for BaseNetworkSocketGetIpMulticastTtlResponder {
25300 type ControlHandle = BaseNetworkSocketControlHandle;
25301
25302 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25303 &self.control_handle
25304 }
25305
25306 fn drop_without_shutdown(mut self) {
25307 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25309 std::mem::forget(self);
25311 }
25312}
25313
25314impl BaseNetworkSocketGetIpMulticastTtlResponder {
25315 pub fn send(
25319 self,
25320 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
25321 ) -> Result<(), fidl::Error> {
25322 let _result = self.send_raw(result);
25323 if _result.is_err() {
25324 self.control_handle.shutdown();
25325 }
25326 self.drop_without_shutdown();
25327 _result
25328 }
25329
25330 pub fn send_no_shutdown_on_err(
25332 self,
25333 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
25334 ) -> Result<(), fidl::Error> {
25335 let _result = self.send_raw(result);
25336 self.drop_without_shutdown();
25337 _result
25338 }
25339
25340 fn send_raw(
25341 &self,
25342 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
25343 ) -> Result<(), fidl::Error> {
25344 self.control_handle.inner.send::<fidl::encoding::ResultType<
25345 BaseNetworkSocketGetIpMulticastTtlResponse,
25346 fidl_fuchsia_posix::Errno,
25347 >>(
25348 result.map(|value| (value,)),
25349 self.tx_id,
25350 0x4665cd378f39e1a,
25351 fidl::encoding::DynamicFlags::empty(),
25352 )
25353 }
25354}
25355
25356#[must_use = "FIDL methods require a response to be sent"]
25357#[derive(Debug)]
25358pub struct BaseNetworkSocketSetIpMulticastLoopbackResponder {
25359 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25360 tx_id: u32,
25361}
25362
25363impl std::ops::Drop for BaseNetworkSocketSetIpMulticastLoopbackResponder {
25367 fn drop(&mut self) {
25368 self.control_handle.shutdown();
25369 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25371 }
25372}
25373
25374impl fidl::endpoints::Responder for BaseNetworkSocketSetIpMulticastLoopbackResponder {
25375 type ControlHandle = BaseNetworkSocketControlHandle;
25376
25377 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25378 &self.control_handle
25379 }
25380
25381 fn drop_without_shutdown(mut self) {
25382 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25384 std::mem::forget(self);
25386 }
25387}
25388
25389impl BaseNetworkSocketSetIpMulticastLoopbackResponder {
25390 pub fn send(
25394 self,
25395 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25396 ) -> Result<(), fidl::Error> {
25397 let _result = self.send_raw(result);
25398 if _result.is_err() {
25399 self.control_handle.shutdown();
25400 }
25401 self.drop_without_shutdown();
25402 _result
25403 }
25404
25405 pub fn send_no_shutdown_on_err(
25407 self,
25408 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25409 ) -> Result<(), fidl::Error> {
25410 let _result = self.send_raw(result);
25411 self.drop_without_shutdown();
25412 _result
25413 }
25414
25415 fn send_raw(
25416 &self,
25417 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25418 ) -> Result<(), fidl::Error> {
25419 self.control_handle.inner.send::<fidl::encoding::ResultType<
25420 fidl::encoding::EmptyStruct,
25421 fidl_fuchsia_posix::Errno,
25422 >>(
25423 result,
25424 self.tx_id,
25425 0x20c55c11f00943ea,
25426 fidl::encoding::DynamicFlags::empty(),
25427 )
25428 }
25429}
25430
25431#[must_use = "FIDL methods require a response to be sent"]
25432#[derive(Debug)]
25433pub struct BaseNetworkSocketGetIpMulticastLoopbackResponder {
25434 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25435 tx_id: u32,
25436}
25437
25438impl std::ops::Drop for BaseNetworkSocketGetIpMulticastLoopbackResponder {
25442 fn drop(&mut self) {
25443 self.control_handle.shutdown();
25444 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25446 }
25447}
25448
25449impl fidl::endpoints::Responder for BaseNetworkSocketGetIpMulticastLoopbackResponder {
25450 type ControlHandle = BaseNetworkSocketControlHandle;
25451
25452 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25453 &self.control_handle
25454 }
25455
25456 fn drop_without_shutdown(mut self) {
25457 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25459 std::mem::forget(self);
25461 }
25462}
25463
25464impl BaseNetworkSocketGetIpMulticastLoopbackResponder {
25465 pub fn send(
25469 self,
25470 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25471 ) -> Result<(), fidl::Error> {
25472 let _result = self.send_raw(result);
25473 if _result.is_err() {
25474 self.control_handle.shutdown();
25475 }
25476 self.drop_without_shutdown();
25477 _result
25478 }
25479
25480 pub fn send_no_shutdown_on_err(
25482 self,
25483 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25484 ) -> Result<(), fidl::Error> {
25485 let _result = self.send_raw(result);
25486 self.drop_without_shutdown();
25487 _result
25488 }
25489
25490 fn send_raw(
25491 &self,
25492 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25493 ) -> Result<(), fidl::Error> {
25494 self.control_handle.inner.send::<fidl::encoding::ResultType<
25495 BaseNetworkSocketGetIpMulticastLoopbackResponse,
25496 fidl_fuchsia_posix::Errno,
25497 >>(
25498 result.map(|value| (value,)),
25499 self.tx_id,
25500 0x3b6b26ff558298f2,
25501 fidl::encoding::DynamicFlags::empty(),
25502 )
25503 }
25504}
25505
25506#[must_use = "FIDL methods require a response to be sent"]
25507#[derive(Debug)]
25508pub struct BaseNetworkSocketAddIpMembershipResponder {
25509 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25510 tx_id: u32,
25511}
25512
25513impl std::ops::Drop for BaseNetworkSocketAddIpMembershipResponder {
25517 fn drop(&mut self) {
25518 self.control_handle.shutdown();
25519 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25521 }
25522}
25523
25524impl fidl::endpoints::Responder for BaseNetworkSocketAddIpMembershipResponder {
25525 type ControlHandle = BaseNetworkSocketControlHandle;
25526
25527 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25528 &self.control_handle
25529 }
25530
25531 fn drop_without_shutdown(mut self) {
25532 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25534 std::mem::forget(self);
25536 }
25537}
25538
25539impl BaseNetworkSocketAddIpMembershipResponder {
25540 pub fn send(
25544 self,
25545 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25546 ) -> Result<(), fidl::Error> {
25547 let _result = self.send_raw(result);
25548 if _result.is_err() {
25549 self.control_handle.shutdown();
25550 }
25551 self.drop_without_shutdown();
25552 _result
25553 }
25554
25555 pub fn send_no_shutdown_on_err(
25557 self,
25558 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25559 ) -> Result<(), fidl::Error> {
25560 let _result = self.send_raw(result);
25561 self.drop_without_shutdown();
25562 _result
25563 }
25564
25565 fn send_raw(
25566 &self,
25567 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25568 ) -> Result<(), fidl::Error> {
25569 self.control_handle.inner.send::<fidl::encoding::ResultType<
25570 fidl::encoding::EmptyStruct,
25571 fidl_fuchsia_posix::Errno,
25572 >>(
25573 result,
25574 self.tx_id,
25575 0x76bc7df115a3b4d0,
25576 fidl::encoding::DynamicFlags::empty(),
25577 )
25578 }
25579}
25580
25581#[must_use = "FIDL methods require a response to be sent"]
25582#[derive(Debug)]
25583pub struct BaseNetworkSocketDropIpMembershipResponder {
25584 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25585 tx_id: u32,
25586}
25587
25588impl std::ops::Drop for BaseNetworkSocketDropIpMembershipResponder {
25592 fn drop(&mut self) {
25593 self.control_handle.shutdown();
25594 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25596 }
25597}
25598
25599impl fidl::endpoints::Responder for BaseNetworkSocketDropIpMembershipResponder {
25600 type ControlHandle = BaseNetworkSocketControlHandle;
25601
25602 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25603 &self.control_handle
25604 }
25605
25606 fn drop_without_shutdown(mut self) {
25607 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25609 std::mem::forget(self);
25611 }
25612}
25613
25614impl BaseNetworkSocketDropIpMembershipResponder {
25615 pub fn send(
25619 self,
25620 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25621 ) -> Result<(), fidl::Error> {
25622 let _result = self.send_raw(result);
25623 if _result.is_err() {
25624 self.control_handle.shutdown();
25625 }
25626 self.drop_without_shutdown();
25627 _result
25628 }
25629
25630 pub fn send_no_shutdown_on_err(
25632 self,
25633 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25634 ) -> Result<(), fidl::Error> {
25635 let _result = self.send_raw(result);
25636 self.drop_without_shutdown();
25637 _result
25638 }
25639
25640 fn send_raw(
25641 &self,
25642 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25643 ) -> Result<(), fidl::Error> {
25644 self.control_handle.inner.send::<fidl::encoding::ResultType<
25645 fidl::encoding::EmptyStruct,
25646 fidl_fuchsia_posix::Errno,
25647 >>(
25648 result,
25649 self.tx_id,
25650 0x2888f3099188d03,
25651 fidl::encoding::DynamicFlags::empty(),
25652 )
25653 }
25654}
25655
25656#[must_use = "FIDL methods require a response to be sent"]
25657#[derive(Debug)]
25658pub struct BaseNetworkSocketSetIpTransparentResponder {
25659 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25660 tx_id: u32,
25661}
25662
25663impl std::ops::Drop for BaseNetworkSocketSetIpTransparentResponder {
25667 fn drop(&mut self) {
25668 self.control_handle.shutdown();
25669 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25671 }
25672}
25673
25674impl fidl::endpoints::Responder for BaseNetworkSocketSetIpTransparentResponder {
25675 type ControlHandle = BaseNetworkSocketControlHandle;
25676
25677 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25678 &self.control_handle
25679 }
25680
25681 fn drop_without_shutdown(mut self) {
25682 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25684 std::mem::forget(self);
25686 }
25687}
25688
25689impl BaseNetworkSocketSetIpTransparentResponder {
25690 pub fn send(
25694 self,
25695 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25696 ) -> Result<(), fidl::Error> {
25697 let _result = self.send_raw(result);
25698 if _result.is_err() {
25699 self.control_handle.shutdown();
25700 }
25701 self.drop_without_shutdown();
25702 _result
25703 }
25704
25705 pub fn send_no_shutdown_on_err(
25707 self,
25708 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25709 ) -> Result<(), fidl::Error> {
25710 let _result = self.send_raw(result);
25711 self.drop_without_shutdown();
25712 _result
25713 }
25714
25715 fn send_raw(
25716 &self,
25717 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25718 ) -> Result<(), fidl::Error> {
25719 self.control_handle.inner.send::<fidl::encoding::ResultType<
25720 fidl::encoding::EmptyStruct,
25721 fidl_fuchsia_posix::Errno,
25722 >>(
25723 result,
25724 self.tx_id,
25725 0x1ae532b0c066e3a0,
25726 fidl::encoding::DynamicFlags::empty(),
25727 )
25728 }
25729}
25730
25731#[must_use = "FIDL methods require a response to be sent"]
25732#[derive(Debug)]
25733pub struct BaseNetworkSocketGetIpTransparentResponder {
25734 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25735 tx_id: u32,
25736}
25737
25738impl std::ops::Drop for BaseNetworkSocketGetIpTransparentResponder {
25742 fn drop(&mut self) {
25743 self.control_handle.shutdown();
25744 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25746 }
25747}
25748
25749impl fidl::endpoints::Responder for BaseNetworkSocketGetIpTransparentResponder {
25750 type ControlHandle = BaseNetworkSocketControlHandle;
25751
25752 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25753 &self.control_handle
25754 }
25755
25756 fn drop_without_shutdown(mut self) {
25757 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25759 std::mem::forget(self);
25761 }
25762}
25763
25764impl BaseNetworkSocketGetIpTransparentResponder {
25765 pub fn send(
25769 self,
25770 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25771 ) -> Result<(), fidl::Error> {
25772 let _result = self.send_raw(result);
25773 if _result.is_err() {
25774 self.control_handle.shutdown();
25775 }
25776 self.drop_without_shutdown();
25777 _result
25778 }
25779
25780 pub fn send_no_shutdown_on_err(
25782 self,
25783 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25784 ) -> Result<(), fidl::Error> {
25785 let _result = self.send_raw(result);
25786 self.drop_without_shutdown();
25787 _result
25788 }
25789
25790 fn send_raw(
25791 &self,
25792 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25793 ) -> Result<(), fidl::Error> {
25794 self.control_handle.inner.send::<fidl::encoding::ResultType<
25795 BaseNetworkSocketGetIpTransparentResponse,
25796 fidl_fuchsia_posix::Errno,
25797 >>(
25798 result.map(|value| (value,)),
25799 self.tx_id,
25800 0x51d43695962ebfb5,
25801 fidl::encoding::DynamicFlags::empty(),
25802 )
25803 }
25804}
25805
25806#[must_use = "FIDL methods require a response to be sent"]
25807#[derive(Debug)]
25808pub struct BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder {
25809 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25810 tx_id: u32,
25811}
25812
25813impl std::ops::Drop for BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder {
25817 fn drop(&mut self) {
25818 self.control_handle.shutdown();
25819 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25821 }
25822}
25823
25824impl fidl::endpoints::Responder
25825 for BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder
25826{
25827 type ControlHandle = BaseNetworkSocketControlHandle;
25828
25829 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25830 &self.control_handle
25831 }
25832
25833 fn drop_without_shutdown(mut self) {
25834 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25836 std::mem::forget(self);
25838 }
25839}
25840
25841impl BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder {
25842 pub fn send(
25846 self,
25847 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25848 ) -> Result<(), fidl::Error> {
25849 let _result = self.send_raw(result);
25850 if _result.is_err() {
25851 self.control_handle.shutdown();
25852 }
25853 self.drop_without_shutdown();
25854 _result
25855 }
25856
25857 pub fn send_no_shutdown_on_err(
25859 self,
25860 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25861 ) -> Result<(), fidl::Error> {
25862 let _result = self.send_raw(result);
25863 self.drop_without_shutdown();
25864 _result
25865 }
25866
25867 fn send_raw(
25868 &self,
25869 mut result: Result<(), fidl_fuchsia_posix::Errno>,
25870 ) -> Result<(), fidl::Error> {
25871 self.control_handle.inner.send::<fidl::encoding::ResultType<
25872 fidl::encoding::EmptyStruct,
25873 fidl_fuchsia_posix::Errno,
25874 >>(
25875 result,
25876 self.tx_id,
25877 0x4722b4ce52f7840,
25878 fidl::encoding::DynamicFlags::empty(),
25879 )
25880 }
25881}
25882
25883#[must_use = "FIDL methods require a response to be sent"]
25884#[derive(Debug)]
25885pub struct BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder {
25886 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25887 tx_id: u32,
25888}
25889
25890impl std::ops::Drop for BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder {
25894 fn drop(&mut self) {
25895 self.control_handle.shutdown();
25896 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25898 }
25899}
25900
25901impl fidl::endpoints::Responder
25902 for BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder
25903{
25904 type ControlHandle = BaseNetworkSocketControlHandle;
25905
25906 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25907 &self.control_handle
25908 }
25909
25910 fn drop_without_shutdown(mut self) {
25911 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25913 std::mem::forget(self);
25915 }
25916}
25917
25918impl BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder {
25919 pub fn send(
25923 self,
25924 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25925 ) -> Result<(), fidl::Error> {
25926 let _result = self.send_raw(result);
25927 if _result.is_err() {
25928 self.control_handle.shutdown();
25929 }
25930 self.drop_without_shutdown();
25931 _result
25932 }
25933
25934 pub fn send_no_shutdown_on_err(
25936 self,
25937 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25938 ) -> Result<(), fidl::Error> {
25939 let _result = self.send_raw(result);
25940 self.drop_without_shutdown();
25941 _result
25942 }
25943
25944 fn send_raw(
25945 &self,
25946 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25947 ) -> Result<(), fidl::Error> {
25948 self.control_handle.inner.send::<fidl::encoding::ResultType<
25949 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
25950 fidl_fuchsia_posix::Errno,
25951 >>(
25952 result.map(|value| (value,)),
25953 self.tx_id,
25954 0x2a0e7dc5d6bfdfe9,
25955 fidl::encoding::DynamicFlags::empty(),
25956 )
25957 }
25958}
25959
25960#[must_use = "FIDL methods require a response to be sent"]
25961#[derive(Debug)]
25962pub struct BaseNetworkSocketAddIpv6MembershipResponder {
25963 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25964 tx_id: u32,
25965}
25966
25967impl std::ops::Drop for BaseNetworkSocketAddIpv6MembershipResponder {
25971 fn drop(&mut self) {
25972 self.control_handle.shutdown();
25973 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25975 }
25976}
25977
25978impl fidl::endpoints::Responder for BaseNetworkSocketAddIpv6MembershipResponder {
25979 type ControlHandle = BaseNetworkSocketControlHandle;
25980
25981 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25982 &self.control_handle
25983 }
25984
25985 fn drop_without_shutdown(mut self) {
25986 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25988 std::mem::forget(self);
25990 }
25991}
25992
25993impl BaseNetworkSocketAddIpv6MembershipResponder {
25994 pub fn send(
25998 self,
25999 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26000 ) -> Result<(), fidl::Error> {
26001 let _result = self.send_raw(result);
26002 if _result.is_err() {
26003 self.control_handle.shutdown();
26004 }
26005 self.drop_without_shutdown();
26006 _result
26007 }
26008
26009 pub fn send_no_shutdown_on_err(
26011 self,
26012 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26013 ) -> Result<(), fidl::Error> {
26014 let _result = self.send_raw(result);
26015 self.drop_without_shutdown();
26016 _result
26017 }
26018
26019 fn send_raw(
26020 &self,
26021 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26022 ) -> Result<(), fidl::Error> {
26023 self.control_handle.inner.send::<fidl::encoding::ResultType<
26024 fidl::encoding::EmptyStruct,
26025 fidl_fuchsia_posix::Errno,
26026 >>(
26027 result,
26028 self.tx_id,
26029 0x7c94727acb4ea4b3,
26030 fidl::encoding::DynamicFlags::empty(),
26031 )
26032 }
26033}
26034
26035#[must_use = "FIDL methods require a response to be sent"]
26036#[derive(Debug)]
26037pub struct BaseNetworkSocketDropIpv6MembershipResponder {
26038 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26039 tx_id: u32,
26040}
26041
26042impl std::ops::Drop for BaseNetworkSocketDropIpv6MembershipResponder {
26046 fn drop(&mut self) {
26047 self.control_handle.shutdown();
26048 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26050 }
26051}
26052
26053impl fidl::endpoints::Responder for BaseNetworkSocketDropIpv6MembershipResponder {
26054 type ControlHandle = BaseNetworkSocketControlHandle;
26055
26056 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26057 &self.control_handle
26058 }
26059
26060 fn drop_without_shutdown(mut self) {
26061 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26063 std::mem::forget(self);
26065 }
26066}
26067
26068impl BaseNetworkSocketDropIpv6MembershipResponder {
26069 pub fn send(
26073 self,
26074 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26075 ) -> Result<(), fidl::Error> {
26076 let _result = self.send_raw(result);
26077 if _result.is_err() {
26078 self.control_handle.shutdown();
26079 }
26080 self.drop_without_shutdown();
26081 _result
26082 }
26083
26084 pub fn send_no_shutdown_on_err(
26086 self,
26087 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26088 ) -> Result<(), fidl::Error> {
26089 let _result = self.send_raw(result);
26090 self.drop_without_shutdown();
26091 _result
26092 }
26093
26094 fn send_raw(
26095 &self,
26096 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26097 ) -> Result<(), fidl::Error> {
26098 self.control_handle.inner.send::<fidl::encoding::ResultType<
26099 fidl::encoding::EmptyStruct,
26100 fidl_fuchsia_posix::Errno,
26101 >>(
26102 result,
26103 self.tx_id,
26104 0x42104c70ccaba304,
26105 fidl::encoding::DynamicFlags::empty(),
26106 )
26107 }
26108}
26109
26110#[must_use = "FIDL methods require a response to be sent"]
26111#[derive(Debug)]
26112pub struct BaseNetworkSocketSetIpv6MulticastInterfaceResponder {
26113 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26114 tx_id: u32,
26115}
26116
26117impl std::ops::Drop for BaseNetworkSocketSetIpv6MulticastInterfaceResponder {
26121 fn drop(&mut self) {
26122 self.control_handle.shutdown();
26123 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26125 }
26126}
26127
26128impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6MulticastInterfaceResponder {
26129 type ControlHandle = BaseNetworkSocketControlHandle;
26130
26131 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26132 &self.control_handle
26133 }
26134
26135 fn drop_without_shutdown(mut self) {
26136 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26138 std::mem::forget(self);
26140 }
26141}
26142
26143impl BaseNetworkSocketSetIpv6MulticastInterfaceResponder {
26144 pub fn send(
26148 self,
26149 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26150 ) -> Result<(), fidl::Error> {
26151 let _result = self.send_raw(result);
26152 if _result.is_err() {
26153 self.control_handle.shutdown();
26154 }
26155 self.drop_without_shutdown();
26156 _result
26157 }
26158
26159 pub fn send_no_shutdown_on_err(
26161 self,
26162 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26163 ) -> Result<(), fidl::Error> {
26164 let _result = self.send_raw(result);
26165 self.drop_without_shutdown();
26166 _result
26167 }
26168
26169 fn send_raw(
26170 &self,
26171 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26172 ) -> Result<(), fidl::Error> {
26173 self.control_handle.inner.send::<fidl::encoding::ResultType<
26174 fidl::encoding::EmptyStruct,
26175 fidl_fuchsia_posix::Errno,
26176 >>(
26177 result,
26178 self.tx_id,
26179 0x135f76db3774ab3b,
26180 fidl::encoding::DynamicFlags::empty(),
26181 )
26182 }
26183}
26184
26185#[must_use = "FIDL methods require a response to be sent"]
26186#[derive(Debug)]
26187pub struct BaseNetworkSocketGetIpv6MulticastInterfaceResponder {
26188 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26189 tx_id: u32,
26190}
26191
26192impl std::ops::Drop for BaseNetworkSocketGetIpv6MulticastInterfaceResponder {
26196 fn drop(&mut self) {
26197 self.control_handle.shutdown();
26198 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26200 }
26201}
26202
26203impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6MulticastInterfaceResponder {
26204 type ControlHandle = BaseNetworkSocketControlHandle;
26205
26206 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26207 &self.control_handle
26208 }
26209
26210 fn drop_without_shutdown(mut self) {
26211 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26213 std::mem::forget(self);
26215 }
26216}
26217
26218impl BaseNetworkSocketGetIpv6MulticastInterfaceResponder {
26219 pub fn send(
26223 self,
26224 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
26225 ) -> Result<(), fidl::Error> {
26226 let _result = self.send_raw(result);
26227 if _result.is_err() {
26228 self.control_handle.shutdown();
26229 }
26230 self.drop_without_shutdown();
26231 _result
26232 }
26233
26234 pub fn send_no_shutdown_on_err(
26236 self,
26237 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
26238 ) -> Result<(), fidl::Error> {
26239 let _result = self.send_raw(result);
26240 self.drop_without_shutdown();
26241 _result
26242 }
26243
26244 fn send_raw(
26245 &self,
26246 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
26247 ) -> Result<(), fidl::Error> {
26248 self.control_handle.inner.send::<fidl::encoding::ResultType<
26249 BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
26250 fidl_fuchsia_posix::Errno,
26251 >>(
26252 result.map(|value| (value,)),
26253 self.tx_id,
26254 0x1f26fcdd348f1882,
26255 fidl::encoding::DynamicFlags::empty(),
26256 )
26257 }
26258}
26259
26260#[must_use = "FIDL methods require a response to be sent"]
26261#[derive(Debug)]
26262pub struct BaseNetworkSocketSetIpv6UnicastHopsResponder {
26263 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26264 tx_id: u32,
26265}
26266
26267impl std::ops::Drop for BaseNetworkSocketSetIpv6UnicastHopsResponder {
26271 fn drop(&mut self) {
26272 self.control_handle.shutdown();
26273 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26275 }
26276}
26277
26278impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6UnicastHopsResponder {
26279 type ControlHandle = BaseNetworkSocketControlHandle;
26280
26281 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26282 &self.control_handle
26283 }
26284
26285 fn drop_without_shutdown(mut self) {
26286 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26288 std::mem::forget(self);
26290 }
26291}
26292
26293impl BaseNetworkSocketSetIpv6UnicastHopsResponder {
26294 pub fn send(
26298 self,
26299 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26300 ) -> Result<(), fidl::Error> {
26301 let _result = self.send_raw(result);
26302 if _result.is_err() {
26303 self.control_handle.shutdown();
26304 }
26305 self.drop_without_shutdown();
26306 _result
26307 }
26308
26309 pub fn send_no_shutdown_on_err(
26311 self,
26312 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26313 ) -> Result<(), fidl::Error> {
26314 let _result = self.send_raw(result);
26315 self.drop_without_shutdown();
26316 _result
26317 }
26318
26319 fn send_raw(
26320 &self,
26321 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26322 ) -> Result<(), fidl::Error> {
26323 self.control_handle.inner.send::<fidl::encoding::ResultType<
26324 fidl::encoding::EmptyStruct,
26325 fidl_fuchsia_posix::Errno,
26326 >>(
26327 result,
26328 self.tx_id,
26329 0x157d51e98f462859,
26330 fidl::encoding::DynamicFlags::empty(),
26331 )
26332 }
26333}
26334
26335#[must_use = "FIDL methods require a response to be sent"]
26336#[derive(Debug)]
26337pub struct BaseNetworkSocketGetIpv6UnicastHopsResponder {
26338 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26339 tx_id: u32,
26340}
26341
26342impl std::ops::Drop for BaseNetworkSocketGetIpv6UnicastHopsResponder {
26346 fn drop(&mut self) {
26347 self.control_handle.shutdown();
26348 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26350 }
26351}
26352
26353impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6UnicastHopsResponder {
26354 type ControlHandle = BaseNetworkSocketControlHandle;
26355
26356 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26357 &self.control_handle
26358 }
26359
26360 fn drop_without_shutdown(mut self) {
26361 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26363 std::mem::forget(self);
26365 }
26366}
26367
26368impl BaseNetworkSocketGetIpv6UnicastHopsResponder {
26369 pub fn send(
26373 self,
26374 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
26375 ) -> Result<(), fidl::Error> {
26376 let _result = self.send_raw(result);
26377 if _result.is_err() {
26378 self.control_handle.shutdown();
26379 }
26380 self.drop_without_shutdown();
26381 _result
26382 }
26383
26384 pub fn send_no_shutdown_on_err(
26386 self,
26387 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
26388 ) -> Result<(), fidl::Error> {
26389 let _result = self.send_raw(result);
26390 self.drop_without_shutdown();
26391 _result
26392 }
26393
26394 fn send_raw(
26395 &self,
26396 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
26397 ) -> Result<(), fidl::Error> {
26398 self.control_handle.inner.send::<fidl::encoding::ResultType<
26399 BaseNetworkSocketGetIpv6UnicastHopsResponse,
26400 fidl_fuchsia_posix::Errno,
26401 >>(
26402 result.map(|value| (value,)),
26403 self.tx_id,
26404 0x21f4641cad8bd8d2,
26405 fidl::encoding::DynamicFlags::empty(),
26406 )
26407 }
26408}
26409
26410#[must_use = "FIDL methods require a response to be sent"]
26411#[derive(Debug)]
26412pub struct BaseNetworkSocketSetIpv6ReceiveHopLimitResponder {
26413 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26414 tx_id: u32,
26415}
26416
26417impl std::ops::Drop for BaseNetworkSocketSetIpv6ReceiveHopLimitResponder {
26421 fn drop(&mut self) {
26422 self.control_handle.shutdown();
26423 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26425 }
26426}
26427
26428impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6ReceiveHopLimitResponder {
26429 type ControlHandle = BaseNetworkSocketControlHandle;
26430
26431 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26432 &self.control_handle
26433 }
26434
26435 fn drop_without_shutdown(mut self) {
26436 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26438 std::mem::forget(self);
26440 }
26441}
26442
26443impl BaseNetworkSocketSetIpv6ReceiveHopLimitResponder {
26444 pub fn send(
26448 self,
26449 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26450 ) -> Result<(), fidl::Error> {
26451 let _result = self.send_raw(result);
26452 if _result.is_err() {
26453 self.control_handle.shutdown();
26454 }
26455 self.drop_without_shutdown();
26456 _result
26457 }
26458
26459 pub fn send_no_shutdown_on_err(
26461 self,
26462 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26463 ) -> Result<(), fidl::Error> {
26464 let _result = self.send_raw(result);
26465 self.drop_without_shutdown();
26466 _result
26467 }
26468
26469 fn send_raw(
26470 &self,
26471 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26472 ) -> Result<(), fidl::Error> {
26473 self.control_handle.inner.send::<fidl::encoding::ResultType<
26474 fidl::encoding::EmptyStruct,
26475 fidl_fuchsia_posix::Errno,
26476 >>(
26477 result,
26478 self.tx_id,
26479 0x5c24808ed2e84a1e,
26480 fidl::encoding::DynamicFlags::empty(),
26481 )
26482 }
26483}
26484
26485#[must_use = "FIDL methods require a response to be sent"]
26486#[derive(Debug)]
26487pub struct BaseNetworkSocketGetIpv6ReceiveHopLimitResponder {
26488 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26489 tx_id: u32,
26490}
26491
26492impl std::ops::Drop for BaseNetworkSocketGetIpv6ReceiveHopLimitResponder {
26496 fn drop(&mut self) {
26497 self.control_handle.shutdown();
26498 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26500 }
26501}
26502
26503impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6ReceiveHopLimitResponder {
26504 type ControlHandle = BaseNetworkSocketControlHandle;
26505
26506 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26507 &self.control_handle
26508 }
26509
26510 fn drop_without_shutdown(mut self) {
26511 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26513 std::mem::forget(self);
26515 }
26516}
26517
26518impl BaseNetworkSocketGetIpv6ReceiveHopLimitResponder {
26519 pub fn send(
26523 self,
26524 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26525 ) -> Result<(), fidl::Error> {
26526 let _result = self.send_raw(result);
26527 if _result.is_err() {
26528 self.control_handle.shutdown();
26529 }
26530 self.drop_without_shutdown();
26531 _result
26532 }
26533
26534 pub fn send_no_shutdown_on_err(
26536 self,
26537 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26538 ) -> Result<(), fidl::Error> {
26539 let _result = self.send_raw(result);
26540 self.drop_without_shutdown();
26541 _result
26542 }
26543
26544 fn send_raw(
26545 &self,
26546 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26547 ) -> Result<(), fidl::Error> {
26548 self.control_handle.inner.send::<fidl::encoding::ResultType<
26549 BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
26550 fidl_fuchsia_posix::Errno,
26551 >>(
26552 result.map(|value| (value,)),
26553 self.tx_id,
26554 0x341e06689885b4c0,
26555 fidl::encoding::DynamicFlags::empty(),
26556 )
26557 }
26558}
26559
26560#[must_use = "FIDL methods require a response to be sent"]
26561#[derive(Debug)]
26562pub struct BaseNetworkSocketSetIpv6MulticastHopsResponder {
26563 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26564 tx_id: u32,
26565}
26566
26567impl std::ops::Drop for BaseNetworkSocketSetIpv6MulticastHopsResponder {
26571 fn drop(&mut self) {
26572 self.control_handle.shutdown();
26573 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26575 }
26576}
26577
26578impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6MulticastHopsResponder {
26579 type ControlHandle = BaseNetworkSocketControlHandle;
26580
26581 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26582 &self.control_handle
26583 }
26584
26585 fn drop_without_shutdown(mut self) {
26586 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26588 std::mem::forget(self);
26590 }
26591}
26592
26593impl BaseNetworkSocketSetIpv6MulticastHopsResponder {
26594 pub fn send(
26598 self,
26599 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26600 ) -> Result<(), fidl::Error> {
26601 let _result = self.send_raw(result);
26602 if _result.is_err() {
26603 self.control_handle.shutdown();
26604 }
26605 self.drop_without_shutdown();
26606 _result
26607 }
26608
26609 pub fn send_no_shutdown_on_err(
26611 self,
26612 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26613 ) -> Result<(), fidl::Error> {
26614 let _result = self.send_raw(result);
26615 self.drop_without_shutdown();
26616 _result
26617 }
26618
26619 fn send_raw(
26620 &self,
26621 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26622 ) -> Result<(), fidl::Error> {
26623 self.control_handle.inner.send::<fidl::encoding::ResultType<
26624 fidl::encoding::EmptyStruct,
26625 fidl_fuchsia_posix::Errno,
26626 >>(
26627 result,
26628 self.tx_id,
26629 0x25b9cd4d181f82c1,
26630 fidl::encoding::DynamicFlags::empty(),
26631 )
26632 }
26633}
26634
26635#[must_use = "FIDL methods require a response to be sent"]
26636#[derive(Debug)]
26637pub struct BaseNetworkSocketGetIpv6MulticastHopsResponder {
26638 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26639 tx_id: u32,
26640}
26641
26642impl std::ops::Drop for BaseNetworkSocketGetIpv6MulticastHopsResponder {
26646 fn drop(&mut self) {
26647 self.control_handle.shutdown();
26648 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26650 }
26651}
26652
26653impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6MulticastHopsResponder {
26654 type ControlHandle = BaseNetworkSocketControlHandle;
26655
26656 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26657 &self.control_handle
26658 }
26659
26660 fn drop_without_shutdown(mut self) {
26661 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26663 std::mem::forget(self);
26665 }
26666}
26667
26668impl BaseNetworkSocketGetIpv6MulticastHopsResponder {
26669 pub fn send(
26673 self,
26674 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
26675 ) -> Result<(), fidl::Error> {
26676 let _result = self.send_raw(result);
26677 if _result.is_err() {
26678 self.control_handle.shutdown();
26679 }
26680 self.drop_without_shutdown();
26681 _result
26682 }
26683
26684 pub fn send_no_shutdown_on_err(
26686 self,
26687 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
26688 ) -> Result<(), fidl::Error> {
26689 let _result = self.send_raw(result);
26690 self.drop_without_shutdown();
26691 _result
26692 }
26693
26694 fn send_raw(
26695 &self,
26696 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
26697 ) -> Result<(), fidl::Error> {
26698 self.control_handle.inner.send::<fidl::encoding::ResultType<
26699 BaseNetworkSocketGetIpv6MulticastHopsResponse,
26700 fidl_fuchsia_posix::Errno,
26701 >>(
26702 result.map(|value| (value,)),
26703 self.tx_id,
26704 0x52916948a365012a,
26705 fidl::encoding::DynamicFlags::empty(),
26706 )
26707 }
26708}
26709
26710#[must_use = "FIDL methods require a response to be sent"]
26711#[derive(Debug)]
26712pub struct BaseNetworkSocketSetIpv6MulticastLoopbackResponder {
26713 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26714 tx_id: u32,
26715}
26716
26717impl std::ops::Drop for BaseNetworkSocketSetIpv6MulticastLoopbackResponder {
26721 fn drop(&mut self) {
26722 self.control_handle.shutdown();
26723 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26725 }
26726}
26727
26728impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6MulticastLoopbackResponder {
26729 type ControlHandle = BaseNetworkSocketControlHandle;
26730
26731 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26732 &self.control_handle
26733 }
26734
26735 fn drop_without_shutdown(mut self) {
26736 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26738 std::mem::forget(self);
26740 }
26741}
26742
26743impl BaseNetworkSocketSetIpv6MulticastLoopbackResponder {
26744 pub fn send(
26748 self,
26749 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26750 ) -> Result<(), fidl::Error> {
26751 let _result = self.send_raw(result);
26752 if _result.is_err() {
26753 self.control_handle.shutdown();
26754 }
26755 self.drop_without_shutdown();
26756 _result
26757 }
26758
26759 pub fn send_no_shutdown_on_err(
26761 self,
26762 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26763 ) -> Result<(), fidl::Error> {
26764 let _result = self.send_raw(result);
26765 self.drop_without_shutdown();
26766 _result
26767 }
26768
26769 fn send_raw(
26770 &self,
26771 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26772 ) -> Result<(), fidl::Error> {
26773 self.control_handle.inner.send::<fidl::encoding::ResultType<
26774 fidl::encoding::EmptyStruct,
26775 fidl_fuchsia_posix::Errno,
26776 >>(
26777 result,
26778 self.tx_id,
26779 0x55701c409ff41b40,
26780 fidl::encoding::DynamicFlags::empty(),
26781 )
26782 }
26783}
26784
26785#[must_use = "FIDL methods require a response to be sent"]
26786#[derive(Debug)]
26787pub struct BaseNetworkSocketGetIpv6MulticastLoopbackResponder {
26788 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26789 tx_id: u32,
26790}
26791
26792impl std::ops::Drop for BaseNetworkSocketGetIpv6MulticastLoopbackResponder {
26796 fn drop(&mut self) {
26797 self.control_handle.shutdown();
26798 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26800 }
26801}
26802
26803impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6MulticastLoopbackResponder {
26804 type ControlHandle = BaseNetworkSocketControlHandle;
26805
26806 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26807 &self.control_handle
26808 }
26809
26810 fn drop_without_shutdown(mut self) {
26811 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26813 std::mem::forget(self);
26815 }
26816}
26817
26818impl BaseNetworkSocketGetIpv6MulticastLoopbackResponder {
26819 pub fn send(
26823 self,
26824 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26825 ) -> Result<(), fidl::Error> {
26826 let _result = self.send_raw(result);
26827 if _result.is_err() {
26828 self.control_handle.shutdown();
26829 }
26830 self.drop_without_shutdown();
26831 _result
26832 }
26833
26834 pub fn send_no_shutdown_on_err(
26836 self,
26837 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26838 ) -> Result<(), fidl::Error> {
26839 let _result = self.send_raw(result);
26840 self.drop_without_shutdown();
26841 _result
26842 }
26843
26844 fn send_raw(
26845 &self,
26846 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26847 ) -> Result<(), fidl::Error> {
26848 self.control_handle.inner.send::<fidl::encoding::ResultType<
26849 BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
26850 fidl_fuchsia_posix::Errno,
26851 >>(
26852 result.map(|value| (value,)),
26853 self.tx_id,
26854 0x4415b701fde319c3,
26855 fidl::encoding::DynamicFlags::empty(),
26856 )
26857 }
26858}
26859
26860#[must_use = "FIDL methods require a response to be sent"]
26861#[derive(Debug)]
26862pub struct BaseNetworkSocketSetIpv6OnlyResponder {
26863 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26864 tx_id: u32,
26865}
26866
26867impl std::ops::Drop for BaseNetworkSocketSetIpv6OnlyResponder {
26871 fn drop(&mut self) {
26872 self.control_handle.shutdown();
26873 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26875 }
26876}
26877
26878impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6OnlyResponder {
26879 type ControlHandle = BaseNetworkSocketControlHandle;
26880
26881 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26882 &self.control_handle
26883 }
26884
26885 fn drop_without_shutdown(mut self) {
26886 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26888 std::mem::forget(self);
26890 }
26891}
26892
26893impl BaseNetworkSocketSetIpv6OnlyResponder {
26894 pub fn send(
26898 self,
26899 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26900 ) -> Result<(), fidl::Error> {
26901 let _result = self.send_raw(result);
26902 if _result.is_err() {
26903 self.control_handle.shutdown();
26904 }
26905 self.drop_without_shutdown();
26906 _result
26907 }
26908
26909 pub fn send_no_shutdown_on_err(
26911 self,
26912 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26913 ) -> Result<(), fidl::Error> {
26914 let _result = self.send_raw(result);
26915 self.drop_without_shutdown();
26916 _result
26917 }
26918
26919 fn send_raw(
26920 &self,
26921 mut result: Result<(), fidl_fuchsia_posix::Errno>,
26922 ) -> Result<(), fidl::Error> {
26923 self.control_handle.inner.send::<fidl::encoding::ResultType<
26924 fidl::encoding::EmptyStruct,
26925 fidl_fuchsia_posix::Errno,
26926 >>(
26927 result,
26928 self.tx_id,
26929 0x4873f1364758cbba,
26930 fidl::encoding::DynamicFlags::empty(),
26931 )
26932 }
26933}
26934
26935#[must_use = "FIDL methods require a response to be sent"]
26936#[derive(Debug)]
26937pub struct BaseNetworkSocketGetIpv6OnlyResponder {
26938 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26939 tx_id: u32,
26940}
26941
26942impl std::ops::Drop for BaseNetworkSocketGetIpv6OnlyResponder {
26946 fn drop(&mut self) {
26947 self.control_handle.shutdown();
26948 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26950 }
26951}
26952
26953impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6OnlyResponder {
26954 type ControlHandle = BaseNetworkSocketControlHandle;
26955
26956 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26957 &self.control_handle
26958 }
26959
26960 fn drop_without_shutdown(mut self) {
26961 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26963 std::mem::forget(self);
26965 }
26966}
26967
26968impl BaseNetworkSocketGetIpv6OnlyResponder {
26969 pub fn send(
26973 self,
26974 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26975 ) -> Result<(), fidl::Error> {
26976 let _result = self.send_raw(result);
26977 if _result.is_err() {
26978 self.control_handle.shutdown();
26979 }
26980 self.drop_without_shutdown();
26981 _result
26982 }
26983
26984 pub fn send_no_shutdown_on_err(
26986 self,
26987 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26988 ) -> Result<(), fidl::Error> {
26989 let _result = self.send_raw(result);
26990 self.drop_without_shutdown();
26991 _result
26992 }
26993
26994 fn send_raw(
26995 &self,
26996 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26997 ) -> Result<(), fidl::Error> {
26998 self.control_handle.inner.send::<fidl::encoding::ResultType<
26999 BaseNetworkSocketGetIpv6OnlyResponse,
27000 fidl_fuchsia_posix::Errno,
27001 >>(
27002 result.map(|value| (value,)),
27003 self.tx_id,
27004 0x4aa3340a1a26b89c,
27005 fidl::encoding::DynamicFlags::empty(),
27006 )
27007 }
27008}
27009
27010#[must_use = "FIDL methods require a response to be sent"]
27011#[derive(Debug)]
27012pub struct BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder {
27013 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
27014 tx_id: u32,
27015}
27016
27017impl std::ops::Drop for BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder {
27021 fn drop(&mut self) {
27022 self.control_handle.shutdown();
27023 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27025 }
27026}
27027
27028impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder {
27029 type ControlHandle = BaseNetworkSocketControlHandle;
27030
27031 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
27032 &self.control_handle
27033 }
27034
27035 fn drop_without_shutdown(mut self) {
27036 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27038 std::mem::forget(self);
27040 }
27041}
27042
27043impl BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder {
27044 pub fn send(
27048 self,
27049 mut result: Result<(), fidl_fuchsia_posix::Errno>,
27050 ) -> Result<(), fidl::Error> {
27051 let _result = self.send_raw(result);
27052 if _result.is_err() {
27053 self.control_handle.shutdown();
27054 }
27055 self.drop_without_shutdown();
27056 _result
27057 }
27058
27059 pub fn send_no_shutdown_on_err(
27061 self,
27062 mut result: Result<(), fidl_fuchsia_posix::Errno>,
27063 ) -> Result<(), fidl::Error> {
27064 let _result = self.send_raw(result);
27065 self.drop_without_shutdown();
27066 _result
27067 }
27068
27069 fn send_raw(
27070 &self,
27071 mut result: Result<(), fidl_fuchsia_posix::Errno>,
27072 ) -> Result<(), fidl::Error> {
27073 self.control_handle.inner.send::<fidl::encoding::ResultType<
27074 fidl::encoding::EmptyStruct,
27075 fidl_fuchsia_posix::Errno,
27076 >>(
27077 result,
27078 self.tx_id,
27079 0x58f07c8788d099a0,
27080 fidl::encoding::DynamicFlags::empty(),
27081 )
27082 }
27083}
27084
27085#[must_use = "FIDL methods require a response to be sent"]
27086#[derive(Debug)]
27087pub struct BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder {
27088 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
27089 tx_id: u32,
27090}
27091
27092impl std::ops::Drop for BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder {
27096 fn drop(&mut self) {
27097 self.control_handle.shutdown();
27098 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27100 }
27101}
27102
27103impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder {
27104 type ControlHandle = BaseNetworkSocketControlHandle;
27105
27106 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
27107 &self.control_handle
27108 }
27109
27110 fn drop_without_shutdown(mut self) {
27111 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27113 std::mem::forget(self);
27115 }
27116}
27117
27118impl BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder {
27119 pub fn send(
27123 self,
27124 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
27125 ) -> Result<(), fidl::Error> {
27126 let _result = self.send_raw(result);
27127 if _result.is_err() {
27128 self.control_handle.shutdown();
27129 }
27130 self.drop_without_shutdown();
27131 _result
27132 }
27133
27134 pub fn send_no_shutdown_on_err(
27136 self,
27137 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
27138 ) -> Result<(), fidl::Error> {
27139 let _result = self.send_raw(result);
27140 self.drop_without_shutdown();
27141 _result
27142 }
27143
27144 fn send_raw(
27145 &self,
27146 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
27147 ) -> Result<(), fidl::Error> {
27148 self.control_handle.inner.send::<fidl::encoding::ResultType<
27149 BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
27150 fidl_fuchsia_posix::Errno,
27151 >>(
27152 result.map(|value| (value,)),
27153 self.tx_id,
27154 0x2e334df1da553ffa,
27155 fidl::encoding::DynamicFlags::empty(),
27156 )
27157 }
27158}
27159
27160#[must_use = "FIDL methods require a response to be sent"]
27161#[derive(Debug)]
27162pub struct BaseNetworkSocketSetIpv6TrafficClassResponder {
27163 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
27164 tx_id: u32,
27165}
27166
27167impl std::ops::Drop for BaseNetworkSocketSetIpv6TrafficClassResponder {
27171 fn drop(&mut self) {
27172 self.control_handle.shutdown();
27173 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27175 }
27176}
27177
27178impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6TrafficClassResponder {
27179 type ControlHandle = BaseNetworkSocketControlHandle;
27180
27181 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
27182 &self.control_handle
27183 }
27184
27185 fn drop_without_shutdown(mut self) {
27186 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27188 std::mem::forget(self);
27190 }
27191}
27192
27193impl BaseNetworkSocketSetIpv6TrafficClassResponder {
27194 pub fn send(
27198 self,
27199 mut result: Result<(), fidl_fuchsia_posix::Errno>,
27200 ) -> Result<(), fidl::Error> {
27201 let _result = self.send_raw(result);
27202 if _result.is_err() {
27203 self.control_handle.shutdown();
27204 }
27205 self.drop_without_shutdown();
27206 _result
27207 }
27208
27209 pub fn send_no_shutdown_on_err(
27211 self,
27212 mut result: Result<(), fidl_fuchsia_posix::Errno>,
27213 ) -> Result<(), fidl::Error> {
27214 let _result = self.send_raw(result);
27215 self.drop_without_shutdown();
27216 _result
27217 }
27218
27219 fn send_raw(
27220 &self,
27221 mut result: Result<(), fidl_fuchsia_posix::Errno>,
27222 ) -> Result<(), fidl::Error> {
27223 self.control_handle.inner.send::<fidl::encoding::ResultType<
27224 fidl::encoding::EmptyStruct,
27225 fidl_fuchsia_posix::Errno,
27226 >>(
27227 result,
27228 self.tx_id,
27229 0x6af077800c5a0b4f,
27230 fidl::encoding::DynamicFlags::empty(),
27231 )
27232 }
27233}
27234
27235#[must_use = "FIDL methods require a response to be sent"]
27236#[derive(Debug)]
27237pub struct BaseNetworkSocketGetIpv6TrafficClassResponder {
27238 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
27239 tx_id: u32,
27240}
27241
27242impl std::ops::Drop for BaseNetworkSocketGetIpv6TrafficClassResponder {
27246 fn drop(&mut self) {
27247 self.control_handle.shutdown();
27248 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27250 }
27251}
27252
27253impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6TrafficClassResponder {
27254 type ControlHandle = BaseNetworkSocketControlHandle;
27255
27256 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
27257 &self.control_handle
27258 }
27259
27260 fn drop_without_shutdown(mut self) {
27261 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27263 std::mem::forget(self);
27265 }
27266}
27267
27268impl BaseNetworkSocketGetIpv6TrafficClassResponder {
27269 pub fn send(
27273 self,
27274 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
27275 ) -> Result<(), fidl::Error> {
27276 let _result = self.send_raw(result);
27277 if _result.is_err() {
27278 self.control_handle.shutdown();
27279 }
27280 self.drop_without_shutdown();
27281 _result
27282 }
27283
27284 pub fn send_no_shutdown_on_err(
27286 self,
27287 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
27288 ) -> Result<(), fidl::Error> {
27289 let _result = self.send_raw(result);
27290 self.drop_without_shutdown();
27291 _result
27292 }
27293
27294 fn send_raw(
27295 &self,
27296 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
27297 ) -> Result<(), fidl::Error> {
27298 self.control_handle.inner.send::<fidl::encoding::ResultType<
27299 BaseNetworkSocketGetIpv6TrafficClassResponse,
27300 fidl_fuchsia_posix::Errno,
27301 >>(
27302 result.map(|value| (value,)),
27303 self.tx_id,
27304 0x6baf6eed8fc2f04,
27305 fidl::encoding::DynamicFlags::empty(),
27306 )
27307 }
27308}
27309
27310#[must_use = "FIDL methods require a response to be sent"]
27311#[derive(Debug)]
27312pub struct BaseNetworkSocketSetIpv6ReceivePacketInfoResponder {
27313 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
27314 tx_id: u32,
27315}
27316
27317impl std::ops::Drop for BaseNetworkSocketSetIpv6ReceivePacketInfoResponder {
27321 fn drop(&mut self) {
27322 self.control_handle.shutdown();
27323 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27325 }
27326}
27327
27328impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6ReceivePacketInfoResponder {
27329 type ControlHandle = BaseNetworkSocketControlHandle;
27330
27331 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
27332 &self.control_handle
27333 }
27334
27335 fn drop_without_shutdown(mut self) {
27336 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27338 std::mem::forget(self);
27340 }
27341}
27342
27343impl BaseNetworkSocketSetIpv6ReceivePacketInfoResponder {
27344 pub fn send(
27348 self,
27349 mut result: Result<(), fidl_fuchsia_posix::Errno>,
27350 ) -> Result<(), fidl::Error> {
27351 let _result = self.send_raw(result);
27352 if _result.is_err() {
27353 self.control_handle.shutdown();
27354 }
27355 self.drop_without_shutdown();
27356 _result
27357 }
27358
27359 pub fn send_no_shutdown_on_err(
27361 self,
27362 mut result: Result<(), fidl_fuchsia_posix::Errno>,
27363 ) -> Result<(), fidl::Error> {
27364 let _result = self.send_raw(result);
27365 self.drop_without_shutdown();
27366 _result
27367 }
27368
27369 fn send_raw(
27370 &self,
27371 mut result: Result<(), fidl_fuchsia_posix::Errno>,
27372 ) -> Result<(), fidl::Error> {
27373 self.control_handle.inner.send::<fidl::encoding::ResultType<
27374 fidl::encoding::EmptyStruct,
27375 fidl_fuchsia_posix::Errno,
27376 >>(
27377 result,
27378 self.tx_id,
27379 0x19259775b1a92768,
27380 fidl::encoding::DynamicFlags::empty(),
27381 )
27382 }
27383}
27384
27385#[must_use = "FIDL methods require a response to be sent"]
27386#[derive(Debug)]
27387pub struct BaseNetworkSocketGetIpv6ReceivePacketInfoResponder {
27388 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
27389 tx_id: u32,
27390}
27391
27392impl std::ops::Drop for BaseNetworkSocketGetIpv6ReceivePacketInfoResponder {
27396 fn drop(&mut self) {
27397 self.control_handle.shutdown();
27398 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27400 }
27401}
27402
27403impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6ReceivePacketInfoResponder {
27404 type ControlHandle = BaseNetworkSocketControlHandle;
27405
27406 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
27407 &self.control_handle
27408 }
27409
27410 fn drop_without_shutdown(mut self) {
27411 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27413 std::mem::forget(self);
27415 }
27416}
27417
27418impl BaseNetworkSocketGetIpv6ReceivePacketInfoResponder {
27419 pub fn send(
27423 self,
27424 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
27425 ) -> Result<(), fidl::Error> {
27426 let _result = self.send_raw(result);
27427 if _result.is_err() {
27428 self.control_handle.shutdown();
27429 }
27430 self.drop_without_shutdown();
27431 _result
27432 }
27433
27434 pub fn send_no_shutdown_on_err(
27436 self,
27437 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
27438 ) -> Result<(), fidl::Error> {
27439 let _result = self.send_raw(result);
27440 self.drop_without_shutdown();
27441 _result
27442 }
27443
27444 fn send_raw(
27445 &self,
27446 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
27447 ) -> Result<(), fidl::Error> {
27448 self.control_handle.inner.send::<fidl::encoding::ResultType<
27449 BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
27450 fidl_fuchsia_posix::Errno,
27451 >>(
27452 result.map(|value| (value,)),
27453 self.tx_id,
27454 0x7acd4a2775baec75,
27455 fidl::encoding::DynamicFlags::empty(),
27456 )
27457 }
27458}
27459
27460#[must_use = "FIDL methods require a response to be sent"]
27461#[derive(Debug)]
27462pub struct BaseNetworkSocketGetOriginalDestinationResponder {
27463 control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
27464 tx_id: u32,
27465}
27466
27467impl std::ops::Drop for BaseNetworkSocketGetOriginalDestinationResponder {
27471 fn drop(&mut self) {
27472 self.control_handle.shutdown();
27473 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27475 }
27476}
27477
27478impl fidl::endpoints::Responder for BaseNetworkSocketGetOriginalDestinationResponder {
27479 type ControlHandle = BaseNetworkSocketControlHandle;
27480
27481 fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
27482 &self.control_handle
27483 }
27484
27485 fn drop_without_shutdown(mut self) {
27486 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27488 std::mem::forget(self);
27490 }
27491}
27492
27493impl BaseNetworkSocketGetOriginalDestinationResponder {
27494 pub fn send(
27498 self,
27499 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
27500 ) -> Result<(), fidl::Error> {
27501 let _result = self.send_raw(result);
27502 if _result.is_err() {
27503 self.control_handle.shutdown();
27504 }
27505 self.drop_without_shutdown();
27506 _result
27507 }
27508
27509 pub fn send_no_shutdown_on_err(
27511 self,
27512 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
27513 ) -> Result<(), fidl::Error> {
27514 let _result = self.send_raw(result);
27515 self.drop_without_shutdown();
27516 _result
27517 }
27518
27519 fn send_raw(
27520 &self,
27521 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
27522 ) -> Result<(), fidl::Error> {
27523 self.control_handle.inner.send::<fidl::encoding::ResultType<
27524 BaseNetworkSocketGetOriginalDestinationResponse,
27525 fidl_fuchsia_posix::Errno,
27526 >>(
27527 result.map(|value| (value,)),
27528 self.tx_id,
27529 0x38bf28f0dafdbac0,
27530 fidl::encoding::DynamicFlags::empty(),
27531 )
27532 }
27533}
27534
27535#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
27536pub struct BaseSocketMarker;
27537
27538impl fidl::endpoints::ProtocolMarker for BaseSocketMarker {
27539 type Proxy = BaseSocketProxy;
27540 type RequestStream = BaseSocketRequestStream;
27541 #[cfg(target_os = "fuchsia")]
27542 type SynchronousProxy = BaseSocketSynchronousProxy;
27543
27544 const DEBUG_NAME: &'static str = "(anonymous) BaseSocket";
27545}
27546pub type BaseSocketSetReuseAddressResult = Result<(), fidl_fuchsia_posix::Errno>;
27547pub type BaseSocketGetReuseAddressResult = Result<bool, fidl_fuchsia_posix::Errno>;
27548pub type BaseSocketGetErrorResult = Result<(), fidl_fuchsia_posix::Errno>;
27549pub type BaseSocketSetBroadcastResult = Result<(), fidl_fuchsia_posix::Errno>;
27550pub type BaseSocketGetBroadcastResult = Result<bool, fidl_fuchsia_posix::Errno>;
27551pub type BaseSocketSetSendBufferResult = Result<(), fidl_fuchsia_posix::Errno>;
27552pub type BaseSocketGetSendBufferResult = Result<u64, fidl_fuchsia_posix::Errno>;
27553pub type BaseSocketSetReceiveBufferResult = Result<(), fidl_fuchsia_posix::Errno>;
27554pub type BaseSocketGetReceiveBufferResult = Result<u64, fidl_fuchsia_posix::Errno>;
27555pub type BaseSocketSetKeepAliveResult = Result<(), fidl_fuchsia_posix::Errno>;
27556pub type BaseSocketGetKeepAliveResult = Result<bool, fidl_fuchsia_posix::Errno>;
27557pub type BaseSocketSetOutOfBandInlineResult = Result<(), fidl_fuchsia_posix::Errno>;
27558pub type BaseSocketGetOutOfBandInlineResult = Result<bool, fidl_fuchsia_posix::Errno>;
27559pub type BaseSocketSetNoCheckResult = Result<(), fidl_fuchsia_posix::Errno>;
27560pub type BaseSocketGetNoCheckResult = Result<bool, fidl_fuchsia_posix::Errno>;
27561pub type BaseSocketSetLingerResult = Result<(), fidl_fuchsia_posix::Errno>;
27562pub type BaseSocketGetLingerResult = Result<(bool, u32), fidl_fuchsia_posix::Errno>;
27563pub type BaseSocketSetReusePortResult = Result<(), fidl_fuchsia_posix::Errno>;
27564pub type BaseSocketGetReusePortResult = Result<bool, fidl_fuchsia_posix::Errno>;
27565pub type BaseSocketGetAcceptConnResult = Result<bool, fidl_fuchsia_posix::Errno>;
27566pub type BaseSocketSetBindToDeviceResult = Result<(), fidl_fuchsia_posix::Errno>;
27567pub type BaseSocketGetBindToDeviceResult = Result<String, fidl_fuchsia_posix::Errno>;
27568pub type BaseSocketSetBindToInterfaceIndexResult = Result<(), fidl_fuchsia_posix::Errno>;
27569pub type BaseSocketGetBindToInterfaceIndexResult = Result<u64, fidl_fuchsia_posix::Errno>;
27570pub type BaseSocketSetTimestampResult = Result<(), fidl_fuchsia_posix::Errno>;
27571pub type BaseSocketGetTimestampResult = Result<TimestampOption, fidl_fuchsia_posix::Errno>;
27572pub type BaseSocketSetMarkResult = Result<(), fidl_fuchsia_posix::Errno>;
27573pub type BaseSocketGetMarkResult = Result<OptionalUint32, fidl_fuchsia_posix::Errno>;
27574
27575pub trait BaseSocketProxyInterface: Send + Sync {
27576 fn r#clone(
27577 &self,
27578 request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
27579 ) -> Result<(), fidl::Error>;
27580 type CloseResponseFut: std::future::Future<
27581 Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
27582 > + Send;
27583 fn r#close(&self) -> Self::CloseResponseFut;
27584 type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
27585 fn r#query(&self) -> Self::QueryResponseFut;
27586 type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
27587 + Send;
27588 fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
27589 type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
27590 + Send;
27591 fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
27592 type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
27593 + Send;
27594 fn r#get_error(&self) -> Self::GetErrorResponseFut;
27595 type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
27596 + Send;
27597 fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
27598 type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
27599 + Send;
27600 fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
27601 type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
27602 + Send;
27603 fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
27604 type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
27605 + Send;
27606 fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
27607 type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
27608 + Send;
27609 fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
27610 type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
27611 + Send;
27612 fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
27613 type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
27614 + Send;
27615 fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
27616 type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
27617 + Send;
27618 fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
27619 type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
27620 + Send;
27621 fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
27622 type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
27623 + Send;
27624 fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
27625 type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
27626 + Send;
27627 fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
27628 type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
27629 + Send;
27630 fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
27631 type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
27632 + Send;
27633 fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
27634 type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
27635 + Send;
27636 fn r#get_linger(&self) -> Self::GetLingerResponseFut;
27637 type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
27638 + Send;
27639 fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
27640 type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
27641 + Send;
27642 fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
27643 type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
27644 + Send;
27645 fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
27646 type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
27647 + Send;
27648 fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
27649 type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
27650 + Send;
27651 fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
27652 type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
27653 + Send;
27654 fn r#set_bind_to_interface_index(&self, value: u64)
27655 -> Self::SetBindToInterfaceIndexResponseFut;
27656 type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
27657 + Send;
27658 fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
27659 type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
27660 + Send;
27661 fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
27662 type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
27663 + Send;
27664 fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
27665 type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
27666 + Send;
27667 fn r#set_mark(
27668 &self,
27669 domain: fidl_fuchsia_net::MarkDomain,
27670 mark: &OptionalUint32,
27671 ) -> Self::SetMarkResponseFut;
27672 type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
27673 + Send;
27674 fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
27675}
27676#[derive(Debug)]
27677#[cfg(target_os = "fuchsia")]
27678pub struct BaseSocketSynchronousProxy {
27679 client: fidl::client::sync::Client,
27680}
27681
27682#[cfg(target_os = "fuchsia")]
27683impl fidl::endpoints::SynchronousProxy for BaseSocketSynchronousProxy {
27684 type Proxy = BaseSocketProxy;
27685 type Protocol = BaseSocketMarker;
27686
27687 fn from_channel(inner: fidl::Channel) -> Self {
27688 Self::new(inner)
27689 }
27690
27691 fn into_channel(self) -> fidl::Channel {
27692 self.client.into_channel()
27693 }
27694
27695 fn as_channel(&self) -> &fidl::Channel {
27696 self.client.as_channel()
27697 }
27698}
27699
27700#[cfg(target_os = "fuchsia")]
27701impl BaseSocketSynchronousProxy {
27702 pub fn new(channel: fidl::Channel) -> Self {
27703 let protocol_name = <BaseSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
27704 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
27705 }
27706
27707 pub fn into_channel(self) -> fidl::Channel {
27708 self.client.into_channel()
27709 }
27710
27711 pub fn wait_for_event(
27714 &self,
27715 deadline: zx::MonotonicInstant,
27716 ) -> Result<BaseSocketEvent, fidl::Error> {
27717 BaseSocketEvent::decode(self.client.wait_for_event(deadline)?)
27718 }
27719
27720 pub fn r#clone(
27721 &self,
27722 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
27723 ) -> Result<(), fidl::Error> {
27724 self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
27725 (request,),
27726 0x20d8a7aba2168a79,
27727 fidl::encoding::DynamicFlags::empty(),
27728 )
27729 }
27730
27731 pub fn r#close(
27742 &self,
27743 ___deadline: zx::MonotonicInstant,
27744 ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
27745 let _response = self.client.send_query::<
27746 fidl::encoding::EmptyPayload,
27747 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
27748 >(
27749 (),
27750 0x5ac5d459ad7f657e,
27751 fidl::encoding::DynamicFlags::empty(),
27752 ___deadline,
27753 )?;
27754 Ok(_response.map(|x| x))
27755 }
27756
27757 pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
27758 let _response = self.client.send_query::<
27759 fidl::encoding::EmptyPayload,
27760 fidl_fuchsia_unknown::QueryableQueryResponse,
27761 >(
27762 (),
27763 0x2658edee9decfc06,
27764 fidl::encoding::DynamicFlags::empty(),
27765 ___deadline,
27766 )?;
27767 Ok(_response.protocol)
27768 }
27769
27770 pub fn r#set_reuse_address(
27772 &self,
27773 mut value: bool,
27774 ___deadline: zx::MonotonicInstant,
27775 ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
27776 let _response =
27777 self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
27778 fidl::encoding::EmptyStruct,
27779 fidl_fuchsia_posix::Errno,
27780 >>(
27781 (value,),
27782 0x1fd74ee8b9a4a876,
27783 fidl::encoding::DynamicFlags::empty(),
27784 ___deadline,
27785 )?;
27786 Ok(_response.map(|x| x))
27787 }
27788
27789 pub fn r#get_reuse_address(
27791 &self,
27792 ___deadline: zx::MonotonicInstant,
27793 ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
27794 let _response = self
27795 .client
27796 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
27797 BaseSocketGetReuseAddressResponse,
27798 fidl_fuchsia_posix::Errno,
27799 >>(
27800 (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
27801 )?;
27802 Ok(_response.map(|x| x.value))
27803 }
27804
27805 pub fn r#get_error(
27808 &self,
27809 ___deadline: zx::MonotonicInstant,
27810 ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
27811 let _response =
27812 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
27813 fidl::encoding::EmptyStruct,
27814 fidl_fuchsia_posix::Errno,
27815 >>(
27816 (),
27817 0x5aad39b33e5f6ebb,
27818 fidl::encoding::DynamicFlags::empty(),
27819 ___deadline,
27820 )?;
27821 Ok(_response.map(|x| x))
27822 }
27823
27824 pub fn r#set_broadcast(
27826 &self,
27827 mut value: bool,
27828 ___deadline: zx::MonotonicInstant,
27829 ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
27830 let _response =
27831 self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
27832 fidl::encoding::EmptyStruct,
27833 fidl_fuchsia_posix::Errno,
27834 >>(
27835 (value,),
27836 0x6023e081ce3cd947,
27837 fidl::encoding::DynamicFlags::empty(),
27838 ___deadline,
27839 )?;
27840 Ok(_response.map(|x| x))
27841 }
27842
27843 pub fn r#get_broadcast(
27845 &self,
27846 ___deadline: zx::MonotonicInstant,
27847 ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
27848 let _response =
27849 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
27850 BaseSocketGetBroadcastResponse,
27851 fidl_fuchsia_posix::Errno,
27852 >>(
27853 (),
27854 0x68796fc556f9780d,
27855 fidl::encoding::DynamicFlags::empty(),
27856 ___deadline,
27857 )?;
27858 Ok(_response.map(|x| x.value))
27859 }
27860
27861 pub fn r#set_send_buffer(
27863 &self,
27864 mut value_bytes: u64,
27865 ___deadline: zx::MonotonicInstant,
27866 ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
27867 let _response =
27868 self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
27869 fidl::encoding::EmptyStruct,
27870 fidl_fuchsia_posix::Errno,
27871 >>(
27872 (value_bytes,),
27873 0x756eac32d73a7a70,
27874 fidl::encoding::DynamicFlags::empty(),
27875 ___deadline,
27876 )?;
27877 Ok(_response.map(|x| x))
27878 }
27879
27880 pub fn r#get_send_buffer(
27882 &self,
27883 ___deadline: zx::MonotonicInstant,
27884 ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
27885 let _response = self
27886 .client
27887 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
27888 BaseSocketGetSendBufferResponse,
27889 fidl_fuchsia_posix::Errno,
27890 >>(
27891 (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
27892 )?;
27893 Ok(_response.map(|x| x.value_bytes))
27894 }
27895
27896 pub fn r#set_receive_buffer(
27898 &self,
27899 mut value_bytes: u64,
27900 ___deadline: zx::MonotonicInstant,
27901 ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
27902 let _response =
27903 self.client
27904 .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
27905 fidl::encoding::EmptyStruct,
27906 fidl_fuchsia_posix::Errno,
27907 >>(
27908 (value_bytes,),
27909 0x6b0cf2f1919c7001,
27910 fidl::encoding::DynamicFlags::empty(),
27911 ___deadline,
27912 )?;
27913 Ok(_response.map(|x| x))
27914 }
27915
27916 pub fn r#get_receive_buffer(
27918 &self,
27919 ___deadline: zx::MonotonicInstant,
27920 ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
27921 let _response = self
27922 .client
27923 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
27924 BaseSocketGetReceiveBufferResponse,
27925 fidl_fuchsia_posix::Errno,
27926 >>(
27927 (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
27928 )?;
27929 Ok(_response.map(|x| x.value_bytes))
27930 }
27931
27932 pub fn r#set_keep_alive(
27934 &self,
27935 mut value: bool,
27936 ___deadline: zx::MonotonicInstant,
27937 ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
27938 let _response =
27939 self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
27940 fidl::encoding::EmptyStruct,
27941 fidl_fuchsia_posix::Errno,
27942 >>(
27943 (value,),
27944 0x572df8f0b920d2c7,
27945 fidl::encoding::DynamicFlags::empty(),
27946 ___deadline,
27947 )?;
27948 Ok(_response.map(|x| x))
27949 }
27950
27951 pub fn r#get_keep_alive(
27953 &self,
27954 ___deadline: zx::MonotonicInstant,
27955 ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
27956 let _response =
27957 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
27958 BaseSocketGetKeepAliveResponse,
27959 fidl_fuchsia_posix::Errno,
27960 >>(
27961 (),
27962 0x2dd29d3215f2c9d2,
27963 fidl::encoding::DynamicFlags::empty(),
27964 ___deadline,
27965 )?;
27966 Ok(_response.map(|x| x.value))
27967 }
27968
27969 pub fn r#set_out_of_band_inline(
27971 &self,
27972 mut value: bool,
27973 ___deadline: zx::MonotonicInstant,
27974 ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
27975 let _response =
27976 self.client
27977 .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
27978 fidl::encoding::EmptyStruct,
27979 fidl_fuchsia_posix::Errno,
27980 >>(
27981 (value,),
27982 0x3ecb49968bee439,
27983 fidl::encoding::DynamicFlags::empty(),
27984 ___deadline,
27985 )?;
27986 Ok(_response.map(|x| x))
27987 }
27988
27989 pub fn r#get_out_of_band_inline(
27991 &self,
27992 ___deadline: zx::MonotonicInstant,
27993 ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
27994 let _response = self
27995 .client
27996 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
27997 BaseSocketGetOutOfBandInlineResponse,
27998 fidl_fuchsia_posix::Errno,
27999 >>(
28000 (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
28001 )?;
28002 Ok(_response.map(|x| x.value))
28003 }
28004
28005 pub fn r#set_no_check(
28007 &self,
28008 mut value: bool,
28009 ___deadline: zx::MonotonicInstant,
28010 ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
28011 let _response =
28012 self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
28013 fidl::encoding::EmptyStruct,
28014 fidl_fuchsia_posix::Errno,
28015 >>(
28016 (value,),
28017 0x6bbf00c53a4c78c2,
28018 fidl::encoding::DynamicFlags::empty(),
28019 ___deadline,
28020 )?;
28021 Ok(_response.map(|x| x))
28022 }
28023
28024 pub fn r#get_no_check(
28026 &self,
28027 ___deadline: zx::MonotonicInstant,
28028 ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
28029 let _response =
28030 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
28031 BaseSocketGetNoCheckResponse,
28032 fidl_fuchsia_posix::Errno,
28033 >>(
28034 (),
28035 0x2cd4249286417694,
28036 fidl::encoding::DynamicFlags::empty(),
28037 ___deadline,
28038 )?;
28039 Ok(_response.map(|x| x.value))
28040 }
28041
28042 pub fn r#set_linger(
28044 &self,
28045 mut linger: bool,
28046 mut length_secs: u32,
28047 ___deadline: zx::MonotonicInstant,
28048 ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
28049 let _response =
28050 self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
28051 fidl::encoding::EmptyStruct,
28052 fidl_fuchsia_posix::Errno,
28053 >>(
28054 (linger, length_secs),
28055 0x45386351246e998e,
28056 fidl::encoding::DynamicFlags::empty(),
28057 ___deadline,
28058 )?;
28059 Ok(_response.map(|x| x))
28060 }
28061
28062 pub fn r#get_linger(
28064 &self,
28065 ___deadline: zx::MonotonicInstant,
28066 ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
28067 let _response =
28068 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
28069 BaseSocketGetLingerResponse,
28070 fidl_fuchsia_posix::Errno,
28071 >>(
28072 (),
28073 0x48eb20fc5ccb0e45,
28074 fidl::encoding::DynamicFlags::empty(),
28075 ___deadline,
28076 )?;
28077 Ok(_response.map(|x| (x.linger, x.length_secs)))
28078 }
28079
28080 pub fn r#set_reuse_port(
28082 &self,
28083 mut value: bool,
28084 ___deadline: zx::MonotonicInstant,
28085 ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
28086 let _response =
28087 self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
28088 fidl::encoding::EmptyStruct,
28089 fidl_fuchsia_posix::Errno,
28090 >>(
28091 (value,),
28092 0x24dd3e5cb36d9ccb,
28093 fidl::encoding::DynamicFlags::empty(),
28094 ___deadline,
28095 )?;
28096 Ok(_response.map(|x| x))
28097 }
28098
28099 pub fn r#get_reuse_port(
28101 &self,
28102 ___deadline: zx::MonotonicInstant,
28103 ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
28104 let _response =
28105 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
28106 BaseSocketGetReusePortResponse,
28107 fidl_fuchsia_posix::Errno,
28108 >>(
28109 (),
28110 0x7a112c1ab54ff828,
28111 fidl::encoding::DynamicFlags::empty(),
28112 ___deadline,
28113 )?;
28114 Ok(_response.map(|x| x.value))
28115 }
28116
28117 pub fn r#get_accept_conn(
28119 &self,
28120 ___deadline: zx::MonotonicInstant,
28121 ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
28122 let _response = self
28123 .client
28124 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
28125 BaseSocketGetAcceptConnResponse,
28126 fidl_fuchsia_posix::Errno,
28127 >>(
28128 (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
28129 )?;
28130 Ok(_response.map(|x| x.value))
28131 }
28132
28133 pub fn r#set_bind_to_device(
28135 &self,
28136 mut value: &str,
28137 ___deadline: zx::MonotonicInstant,
28138 ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
28139 let _response =
28140 self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
28141 fidl::encoding::EmptyStruct,
28142 fidl_fuchsia_posix::Errno,
28143 >>(
28144 (value,),
28145 0x2118b483f28aafc4,
28146 fidl::encoding::DynamicFlags::empty(),
28147 ___deadline,
28148 )?;
28149 Ok(_response.map(|x| x))
28150 }
28151
28152 pub fn r#get_bind_to_device(
28154 &self,
28155 ___deadline: zx::MonotonicInstant,
28156 ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
28157 let _response = self
28158 .client
28159 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
28160 BaseSocketGetBindToDeviceResponse,
28161 fidl_fuchsia_posix::Errno,
28162 >>(
28163 (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
28164 )?;
28165 Ok(_response.map(|x| x.value))
28166 }
28167
28168 pub fn r#set_bind_to_interface_index(
28171 &self,
28172 mut value: u64,
28173 ___deadline: zx::MonotonicInstant,
28174 ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
28175 let _response =
28176 self.client
28177 .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
28178 fidl::encoding::EmptyStruct,
28179 fidl_fuchsia_posix::Errno,
28180 >>(
28181 (value,),
28182 0x6e387a0def00821,
28183 fidl::encoding::DynamicFlags::empty(),
28184 ___deadline,
28185 )?;
28186 Ok(_response.map(|x| x))
28187 }
28188
28189 pub fn r#get_bind_to_interface_index(
28191 &self,
28192 ___deadline: zx::MonotonicInstant,
28193 ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
28194 let _response = self
28195 .client
28196 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
28197 BaseSocketGetBindToInterfaceIndexResponse,
28198 fidl_fuchsia_posix::Errno,
28199 >>(
28200 (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
28201 )?;
28202 Ok(_response.map(|x| x.value))
28203 }
28204
28205 pub fn r#set_timestamp(
28207 &self,
28208 mut value: TimestampOption,
28209 ___deadline: zx::MonotonicInstant,
28210 ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
28211 let _response =
28212 self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
28213 fidl::encoding::EmptyStruct,
28214 fidl_fuchsia_posix::Errno,
28215 >>(
28216 (value,),
28217 0x285d6516c263d839,
28218 fidl::encoding::DynamicFlags::empty(),
28219 ___deadline,
28220 )?;
28221 Ok(_response.map(|x| x))
28222 }
28223
28224 pub fn r#get_timestamp(
28226 &self,
28227 ___deadline: zx::MonotonicInstant,
28228 ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
28229 let _response =
28230 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
28231 BaseSocketGetTimestampResponse,
28232 fidl_fuchsia_posix::Errno,
28233 >>(
28234 (),
28235 0x49f2fffbbcc2bd27,
28236 fidl::encoding::DynamicFlags::empty(),
28237 ___deadline,
28238 )?;
28239 Ok(_response.map(|x| x.value))
28240 }
28241
28242 pub fn r#set_mark(
28246 &self,
28247 mut domain: fidl_fuchsia_net::MarkDomain,
28248 mut mark: &OptionalUint32,
28249 ___deadline: zx::MonotonicInstant,
28250 ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
28251 let _response =
28252 self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
28253 fidl::encoding::EmptyStruct,
28254 fidl_fuchsia_posix::Errno,
28255 >>(
28256 (domain, mark),
28257 0x6ead6de09f653236,
28258 fidl::encoding::DynamicFlags::empty(),
28259 ___deadline,
28260 )?;
28261 Ok(_response.map(|x| x))
28262 }
28263
28264 pub fn r#get_mark(
28268 &self,
28269 mut domain: fidl_fuchsia_net::MarkDomain,
28270 ___deadline: zx::MonotonicInstant,
28271 ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
28272 let _response =
28273 self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
28274 BaseSocketGetMarkResponse,
28275 fidl_fuchsia_posix::Errno,
28276 >>(
28277 (domain,),
28278 0x57a2752c61d93d47,
28279 fidl::encoding::DynamicFlags::empty(),
28280 ___deadline,
28281 )?;
28282 Ok(_response.map(|x| x.mark))
28283 }
28284}
28285
28286#[cfg(target_os = "fuchsia")]
28287impl From<BaseSocketSynchronousProxy> for zx::Handle {
28288 fn from(value: BaseSocketSynchronousProxy) -> Self {
28289 value.into_channel().into()
28290 }
28291}
28292
28293#[cfg(target_os = "fuchsia")]
28294impl From<fidl::Channel> for BaseSocketSynchronousProxy {
28295 fn from(value: fidl::Channel) -> Self {
28296 Self::new(value)
28297 }
28298}
28299
28300#[derive(Debug, Clone)]
28301pub struct BaseSocketProxy {
28302 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
28303}
28304
28305impl fidl::endpoints::Proxy for BaseSocketProxy {
28306 type Protocol = BaseSocketMarker;
28307
28308 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
28309 Self::new(inner)
28310 }
28311
28312 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
28313 self.client.into_channel().map_err(|client| Self { client })
28314 }
28315
28316 fn as_channel(&self) -> &::fidl::AsyncChannel {
28317 self.client.as_channel()
28318 }
28319}
28320
28321impl BaseSocketProxy {
28322 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
28324 let protocol_name = <BaseSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
28325 Self { client: fidl::client::Client::new(channel, protocol_name) }
28326 }
28327
28328 pub fn take_event_stream(&self) -> BaseSocketEventStream {
28334 BaseSocketEventStream { event_receiver: self.client.take_event_receiver() }
28335 }
28336
28337 pub fn r#clone(
28338 &self,
28339 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
28340 ) -> Result<(), fidl::Error> {
28341 BaseSocketProxyInterface::r#clone(self, request)
28342 }
28343
28344 pub fn r#close(
28355 &self,
28356 ) -> fidl::client::QueryResponseFut<
28357 fidl_fuchsia_unknown::CloseableCloseResult,
28358 fidl::encoding::DefaultFuchsiaResourceDialect,
28359 > {
28360 BaseSocketProxyInterface::r#close(self)
28361 }
28362
28363 pub fn r#query(
28364 &self,
28365 ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
28366 {
28367 BaseSocketProxyInterface::r#query(self)
28368 }
28369
28370 pub fn r#set_reuse_address(
28372 &self,
28373 mut value: bool,
28374 ) -> fidl::client::QueryResponseFut<
28375 BaseSocketSetReuseAddressResult,
28376 fidl::encoding::DefaultFuchsiaResourceDialect,
28377 > {
28378 BaseSocketProxyInterface::r#set_reuse_address(self, value)
28379 }
28380
28381 pub fn r#get_reuse_address(
28383 &self,
28384 ) -> fidl::client::QueryResponseFut<
28385 BaseSocketGetReuseAddressResult,
28386 fidl::encoding::DefaultFuchsiaResourceDialect,
28387 > {
28388 BaseSocketProxyInterface::r#get_reuse_address(self)
28389 }
28390
28391 pub fn r#get_error(
28394 &self,
28395 ) -> fidl::client::QueryResponseFut<
28396 BaseSocketGetErrorResult,
28397 fidl::encoding::DefaultFuchsiaResourceDialect,
28398 > {
28399 BaseSocketProxyInterface::r#get_error(self)
28400 }
28401
28402 pub fn r#set_broadcast(
28404 &self,
28405 mut value: bool,
28406 ) -> fidl::client::QueryResponseFut<
28407 BaseSocketSetBroadcastResult,
28408 fidl::encoding::DefaultFuchsiaResourceDialect,
28409 > {
28410 BaseSocketProxyInterface::r#set_broadcast(self, value)
28411 }
28412
28413 pub fn r#get_broadcast(
28415 &self,
28416 ) -> fidl::client::QueryResponseFut<
28417 BaseSocketGetBroadcastResult,
28418 fidl::encoding::DefaultFuchsiaResourceDialect,
28419 > {
28420 BaseSocketProxyInterface::r#get_broadcast(self)
28421 }
28422
28423 pub fn r#set_send_buffer(
28425 &self,
28426 mut value_bytes: u64,
28427 ) -> fidl::client::QueryResponseFut<
28428 BaseSocketSetSendBufferResult,
28429 fidl::encoding::DefaultFuchsiaResourceDialect,
28430 > {
28431 BaseSocketProxyInterface::r#set_send_buffer(self, value_bytes)
28432 }
28433
28434 pub fn r#get_send_buffer(
28436 &self,
28437 ) -> fidl::client::QueryResponseFut<
28438 BaseSocketGetSendBufferResult,
28439 fidl::encoding::DefaultFuchsiaResourceDialect,
28440 > {
28441 BaseSocketProxyInterface::r#get_send_buffer(self)
28442 }
28443
28444 pub fn r#set_receive_buffer(
28446 &self,
28447 mut value_bytes: u64,
28448 ) -> fidl::client::QueryResponseFut<
28449 BaseSocketSetReceiveBufferResult,
28450 fidl::encoding::DefaultFuchsiaResourceDialect,
28451 > {
28452 BaseSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
28453 }
28454
28455 pub fn r#get_receive_buffer(
28457 &self,
28458 ) -> fidl::client::QueryResponseFut<
28459 BaseSocketGetReceiveBufferResult,
28460 fidl::encoding::DefaultFuchsiaResourceDialect,
28461 > {
28462 BaseSocketProxyInterface::r#get_receive_buffer(self)
28463 }
28464
28465 pub fn r#set_keep_alive(
28467 &self,
28468 mut value: bool,
28469 ) -> fidl::client::QueryResponseFut<
28470 BaseSocketSetKeepAliveResult,
28471 fidl::encoding::DefaultFuchsiaResourceDialect,
28472 > {
28473 BaseSocketProxyInterface::r#set_keep_alive(self, value)
28474 }
28475
28476 pub fn r#get_keep_alive(
28478 &self,
28479 ) -> fidl::client::QueryResponseFut<
28480 BaseSocketGetKeepAliveResult,
28481 fidl::encoding::DefaultFuchsiaResourceDialect,
28482 > {
28483 BaseSocketProxyInterface::r#get_keep_alive(self)
28484 }
28485
28486 pub fn r#set_out_of_band_inline(
28488 &self,
28489 mut value: bool,
28490 ) -> fidl::client::QueryResponseFut<
28491 BaseSocketSetOutOfBandInlineResult,
28492 fidl::encoding::DefaultFuchsiaResourceDialect,
28493 > {
28494 BaseSocketProxyInterface::r#set_out_of_band_inline(self, value)
28495 }
28496
28497 pub fn r#get_out_of_band_inline(
28499 &self,
28500 ) -> fidl::client::QueryResponseFut<
28501 BaseSocketGetOutOfBandInlineResult,
28502 fidl::encoding::DefaultFuchsiaResourceDialect,
28503 > {
28504 BaseSocketProxyInterface::r#get_out_of_band_inline(self)
28505 }
28506
28507 pub fn r#set_no_check(
28509 &self,
28510 mut value: bool,
28511 ) -> fidl::client::QueryResponseFut<
28512 BaseSocketSetNoCheckResult,
28513 fidl::encoding::DefaultFuchsiaResourceDialect,
28514 > {
28515 BaseSocketProxyInterface::r#set_no_check(self, value)
28516 }
28517
28518 pub fn r#get_no_check(
28520 &self,
28521 ) -> fidl::client::QueryResponseFut<
28522 BaseSocketGetNoCheckResult,
28523 fidl::encoding::DefaultFuchsiaResourceDialect,
28524 > {
28525 BaseSocketProxyInterface::r#get_no_check(self)
28526 }
28527
28528 pub fn r#set_linger(
28530 &self,
28531 mut linger: bool,
28532 mut length_secs: u32,
28533 ) -> fidl::client::QueryResponseFut<
28534 BaseSocketSetLingerResult,
28535 fidl::encoding::DefaultFuchsiaResourceDialect,
28536 > {
28537 BaseSocketProxyInterface::r#set_linger(self, linger, length_secs)
28538 }
28539
28540 pub fn r#get_linger(
28542 &self,
28543 ) -> fidl::client::QueryResponseFut<
28544 BaseSocketGetLingerResult,
28545 fidl::encoding::DefaultFuchsiaResourceDialect,
28546 > {
28547 BaseSocketProxyInterface::r#get_linger(self)
28548 }
28549
28550 pub fn r#set_reuse_port(
28552 &self,
28553 mut value: bool,
28554 ) -> fidl::client::QueryResponseFut<
28555 BaseSocketSetReusePortResult,
28556 fidl::encoding::DefaultFuchsiaResourceDialect,
28557 > {
28558 BaseSocketProxyInterface::r#set_reuse_port(self, value)
28559 }
28560
28561 pub fn r#get_reuse_port(
28563 &self,
28564 ) -> fidl::client::QueryResponseFut<
28565 BaseSocketGetReusePortResult,
28566 fidl::encoding::DefaultFuchsiaResourceDialect,
28567 > {
28568 BaseSocketProxyInterface::r#get_reuse_port(self)
28569 }
28570
28571 pub fn r#get_accept_conn(
28573 &self,
28574 ) -> fidl::client::QueryResponseFut<
28575 BaseSocketGetAcceptConnResult,
28576 fidl::encoding::DefaultFuchsiaResourceDialect,
28577 > {
28578 BaseSocketProxyInterface::r#get_accept_conn(self)
28579 }
28580
28581 pub fn r#set_bind_to_device(
28583 &self,
28584 mut value: &str,
28585 ) -> fidl::client::QueryResponseFut<
28586 BaseSocketSetBindToDeviceResult,
28587 fidl::encoding::DefaultFuchsiaResourceDialect,
28588 > {
28589 BaseSocketProxyInterface::r#set_bind_to_device(self, value)
28590 }
28591
28592 pub fn r#get_bind_to_device(
28594 &self,
28595 ) -> fidl::client::QueryResponseFut<
28596 BaseSocketGetBindToDeviceResult,
28597 fidl::encoding::DefaultFuchsiaResourceDialect,
28598 > {
28599 BaseSocketProxyInterface::r#get_bind_to_device(self)
28600 }
28601
28602 pub fn r#set_bind_to_interface_index(
28605 &self,
28606 mut value: u64,
28607 ) -> fidl::client::QueryResponseFut<
28608 BaseSocketSetBindToInterfaceIndexResult,
28609 fidl::encoding::DefaultFuchsiaResourceDialect,
28610 > {
28611 BaseSocketProxyInterface::r#set_bind_to_interface_index(self, value)
28612 }
28613
28614 pub fn r#get_bind_to_interface_index(
28616 &self,
28617 ) -> fidl::client::QueryResponseFut<
28618 BaseSocketGetBindToInterfaceIndexResult,
28619 fidl::encoding::DefaultFuchsiaResourceDialect,
28620 > {
28621 BaseSocketProxyInterface::r#get_bind_to_interface_index(self)
28622 }
28623
28624 pub fn r#set_timestamp(
28626 &self,
28627 mut value: TimestampOption,
28628 ) -> fidl::client::QueryResponseFut<
28629 BaseSocketSetTimestampResult,
28630 fidl::encoding::DefaultFuchsiaResourceDialect,
28631 > {
28632 BaseSocketProxyInterface::r#set_timestamp(self, value)
28633 }
28634
28635 pub fn r#get_timestamp(
28637 &self,
28638 ) -> fidl::client::QueryResponseFut<
28639 BaseSocketGetTimestampResult,
28640 fidl::encoding::DefaultFuchsiaResourceDialect,
28641 > {
28642 BaseSocketProxyInterface::r#get_timestamp(self)
28643 }
28644
28645 pub fn r#set_mark(
28649 &self,
28650 mut domain: fidl_fuchsia_net::MarkDomain,
28651 mut mark: &OptionalUint32,
28652 ) -> fidl::client::QueryResponseFut<
28653 BaseSocketSetMarkResult,
28654 fidl::encoding::DefaultFuchsiaResourceDialect,
28655 > {
28656 BaseSocketProxyInterface::r#set_mark(self, domain, mark)
28657 }
28658
28659 pub fn r#get_mark(
28663 &self,
28664 mut domain: fidl_fuchsia_net::MarkDomain,
28665 ) -> fidl::client::QueryResponseFut<
28666 BaseSocketGetMarkResult,
28667 fidl::encoding::DefaultFuchsiaResourceDialect,
28668 > {
28669 BaseSocketProxyInterface::r#get_mark(self, domain)
28670 }
28671}
28672
28673impl BaseSocketProxyInterface for BaseSocketProxy {
28674 fn r#clone(
28675 &self,
28676 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
28677 ) -> Result<(), fidl::Error> {
28678 self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
28679 (request,),
28680 0x20d8a7aba2168a79,
28681 fidl::encoding::DynamicFlags::empty(),
28682 )
28683 }
28684
28685 type CloseResponseFut = fidl::client::QueryResponseFut<
28686 fidl_fuchsia_unknown::CloseableCloseResult,
28687 fidl::encoding::DefaultFuchsiaResourceDialect,
28688 >;
28689 fn r#close(&self) -> Self::CloseResponseFut {
28690 fn _decode(
28691 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28692 ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
28693 let _response = fidl::client::decode_transaction_body::<
28694 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
28695 fidl::encoding::DefaultFuchsiaResourceDialect,
28696 0x5ac5d459ad7f657e,
28697 >(_buf?)?;
28698 Ok(_response.map(|x| x))
28699 }
28700 self.client.send_query_and_decode::<
28701 fidl::encoding::EmptyPayload,
28702 fidl_fuchsia_unknown::CloseableCloseResult,
28703 >(
28704 (),
28705 0x5ac5d459ad7f657e,
28706 fidl::encoding::DynamicFlags::empty(),
28707 _decode,
28708 )
28709 }
28710
28711 type QueryResponseFut =
28712 fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
28713 fn r#query(&self) -> Self::QueryResponseFut {
28714 fn _decode(
28715 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28716 ) -> Result<Vec<u8>, fidl::Error> {
28717 let _response = fidl::client::decode_transaction_body::<
28718 fidl_fuchsia_unknown::QueryableQueryResponse,
28719 fidl::encoding::DefaultFuchsiaResourceDialect,
28720 0x2658edee9decfc06,
28721 >(_buf?)?;
28722 Ok(_response.protocol)
28723 }
28724 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
28725 (),
28726 0x2658edee9decfc06,
28727 fidl::encoding::DynamicFlags::empty(),
28728 _decode,
28729 )
28730 }
28731
28732 type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
28733 BaseSocketSetReuseAddressResult,
28734 fidl::encoding::DefaultFuchsiaResourceDialect,
28735 >;
28736 fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
28737 fn _decode(
28738 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28739 ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
28740 let _response = fidl::client::decode_transaction_body::<
28741 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
28742 fidl::encoding::DefaultFuchsiaResourceDialect,
28743 0x1fd74ee8b9a4a876,
28744 >(_buf?)?;
28745 Ok(_response.map(|x| x))
28746 }
28747 self.client.send_query_and_decode::<
28748 BaseSocketSetReuseAddressRequest,
28749 BaseSocketSetReuseAddressResult,
28750 >(
28751 (value,),
28752 0x1fd74ee8b9a4a876,
28753 fidl::encoding::DynamicFlags::empty(),
28754 _decode,
28755 )
28756 }
28757
28758 type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
28759 BaseSocketGetReuseAddressResult,
28760 fidl::encoding::DefaultFuchsiaResourceDialect,
28761 >;
28762 fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
28763 fn _decode(
28764 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28765 ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
28766 let _response = fidl::client::decode_transaction_body::<
28767 fidl::encoding::ResultType<
28768 BaseSocketGetReuseAddressResponse,
28769 fidl_fuchsia_posix::Errno,
28770 >,
28771 fidl::encoding::DefaultFuchsiaResourceDialect,
28772 0x67b7206b8d1bc0a5,
28773 >(_buf?)?;
28774 Ok(_response.map(|x| x.value))
28775 }
28776 self.client
28777 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
28778 (),
28779 0x67b7206b8d1bc0a5,
28780 fidl::encoding::DynamicFlags::empty(),
28781 _decode,
28782 )
28783 }
28784
28785 type GetErrorResponseFut = fidl::client::QueryResponseFut<
28786 BaseSocketGetErrorResult,
28787 fidl::encoding::DefaultFuchsiaResourceDialect,
28788 >;
28789 fn r#get_error(&self) -> Self::GetErrorResponseFut {
28790 fn _decode(
28791 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28792 ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
28793 let _response = fidl::client::decode_transaction_body::<
28794 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
28795 fidl::encoding::DefaultFuchsiaResourceDialect,
28796 0x5aad39b33e5f6ebb,
28797 >(_buf?)?;
28798 Ok(_response.map(|x| x))
28799 }
28800 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
28801 (),
28802 0x5aad39b33e5f6ebb,
28803 fidl::encoding::DynamicFlags::empty(),
28804 _decode,
28805 )
28806 }
28807
28808 type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
28809 BaseSocketSetBroadcastResult,
28810 fidl::encoding::DefaultFuchsiaResourceDialect,
28811 >;
28812 fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
28813 fn _decode(
28814 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28815 ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
28816 let _response = fidl::client::decode_transaction_body::<
28817 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
28818 fidl::encoding::DefaultFuchsiaResourceDialect,
28819 0x6023e081ce3cd947,
28820 >(_buf?)?;
28821 Ok(_response.map(|x| x))
28822 }
28823 self.client
28824 .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
28825 (value,),
28826 0x6023e081ce3cd947,
28827 fidl::encoding::DynamicFlags::empty(),
28828 _decode,
28829 )
28830 }
28831
28832 type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
28833 BaseSocketGetBroadcastResult,
28834 fidl::encoding::DefaultFuchsiaResourceDialect,
28835 >;
28836 fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
28837 fn _decode(
28838 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28839 ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
28840 let _response = fidl::client::decode_transaction_body::<
28841 fidl::encoding::ResultType<
28842 BaseSocketGetBroadcastResponse,
28843 fidl_fuchsia_posix::Errno,
28844 >,
28845 fidl::encoding::DefaultFuchsiaResourceDialect,
28846 0x68796fc556f9780d,
28847 >(_buf?)?;
28848 Ok(_response.map(|x| x.value))
28849 }
28850 self.client
28851 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
28852 (),
28853 0x68796fc556f9780d,
28854 fidl::encoding::DynamicFlags::empty(),
28855 _decode,
28856 )
28857 }
28858
28859 type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
28860 BaseSocketSetSendBufferResult,
28861 fidl::encoding::DefaultFuchsiaResourceDialect,
28862 >;
28863 fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
28864 fn _decode(
28865 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28866 ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
28867 let _response = fidl::client::decode_transaction_body::<
28868 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
28869 fidl::encoding::DefaultFuchsiaResourceDialect,
28870 0x756eac32d73a7a70,
28871 >(_buf?)?;
28872 Ok(_response.map(|x| x))
28873 }
28874 self.client
28875 .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
28876 (value_bytes,),
28877 0x756eac32d73a7a70,
28878 fidl::encoding::DynamicFlags::empty(),
28879 _decode,
28880 )
28881 }
28882
28883 type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
28884 BaseSocketGetSendBufferResult,
28885 fidl::encoding::DefaultFuchsiaResourceDialect,
28886 >;
28887 fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
28888 fn _decode(
28889 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28890 ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
28891 let _response = fidl::client::decode_transaction_body::<
28892 fidl::encoding::ResultType<
28893 BaseSocketGetSendBufferResponse,
28894 fidl_fuchsia_posix::Errno,
28895 >,
28896 fidl::encoding::DefaultFuchsiaResourceDialect,
28897 0x78a52fd9c7b2410b,
28898 >(_buf?)?;
28899 Ok(_response.map(|x| x.value_bytes))
28900 }
28901 self.client
28902 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
28903 (),
28904 0x78a52fd9c7b2410b,
28905 fidl::encoding::DynamicFlags::empty(),
28906 _decode,
28907 )
28908 }
28909
28910 type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
28911 BaseSocketSetReceiveBufferResult,
28912 fidl::encoding::DefaultFuchsiaResourceDialect,
28913 >;
28914 fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
28915 fn _decode(
28916 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28917 ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
28918 let _response = fidl::client::decode_transaction_body::<
28919 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
28920 fidl::encoding::DefaultFuchsiaResourceDialect,
28921 0x6b0cf2f1919c7001,
28922 >(_buf?)?;
28923 Ok(_response.map(|x| x))
28924 }
28925 self.client.send_query_and_decode::<
28926 BaseSocketSetReceiveBufferRequest,
28927 BaseSocketSetReceiveBufferResult,
28928 >(
28929 (value_bytes,),
28930 0x6b0cf2f1919c7001,
28931 fidl::encoding::DynamicFlags::empty(),
28932 _decode,
28933 )
28934 }
28935
28936 type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
28937 BaseSocketGetReceiveBufferResult,
28938 fidl::encoding::DefaultFuchsiaResourceDialect,
28939 >;
28940 fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
28941 fn _decode(
28942 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28943 ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
28944 let _response = fidl::client::decode_transaction_body::<
28945 fidl::encoding::ResultType<
28946 BaseSocketGetReceiveBufferResponse,
28947 fidl_fuchsia_posix::Errno,
28948 >,
28949 fidl::encoding::DefaultFuchsiaResourceDialect,
28950 0x14c1a4b64f709e5c,
28951 >(_buf?)?;
28952 Ok(_response.map(|x| x.value_bytes))
28953 }
28954 self.client.send_query_and_decode::<
28955 fidl::encoding::EmptyPayload,
28956 BaseSocketGetReceiveBufferResult,
28957 >(
28958 (),
28959 0x14c1a4b64f709e5c,
28960 fidl::encoding::DynamicFlags::empty(),
28961 _decode,
28962 )
28963 }
28964
28965 type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
28966 BaseSocketSetKeepAliveResult,
28967 fidl::encoding::DefaultFuchsiaResourceDialect,
28968 >;
28969 fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
28970 fn _decode(
28971 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28972 ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
28973 let _response = fidl::client::decode_transaction_body::<
28974 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
28975 fidl::encoding::DefaultFuchsiaResourceDialect,
28976 0x572df8f0b920d2c7,
28977 >(_buf?)?;
28978 Ok(_response.map(|x| x))
28979 }
28980 self.client
28981 .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
28982 (value,),
28983 0x572df8f0b920d2c7,
28984 fidl::encoding::DynamicFlags::empty(),
28985 _decode,
28986 )
28987 }
28988
28989 type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
28990 BaseSocketGetKeepAliveResult,
28991 fidl::encoding::DefaultFuchsiaResourceDialect,
28992 >;
28993 fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
28994 fn _decode(
28995 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28996 ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
28997 let _response = fidl::client::decode_transaction_body::<
28998 fidl::encoding::ResultType<
28999 BaseSocketGetKeepAliveResponse,
29000 fidl_fuchsia_posix::Errno,
29001 >,
29002 fidl::encoding::DefaultFuchsiaResourceDialect,
29003 0x2dd29d3215f2c9d2,
29004 >(_buf?)?;
29005 Ok(_response.map(|x| x.value))
29006 }
29007 self.client
29008 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
29009 (),
29010 0x2dd29d3215f2c9d2,
29011 fidl::encoding::DynamicFlags::empty(),
29012 _decode,
29013 )
29014 }
29015
29016 type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
29017 BaseSocketSetOutOfBandInlineResult,
29018 fidl::encoding::DefaultFuchsiaResourceDialect,
29019 >;
29020 fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
29021 fn _decode(
29022 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29023 ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
29024 let _response = fidl::client::decode_transaction_body::<
29025 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
29026 fidl::encoding::DefaultFuchsiaResourceDialect,
29027 0x3ecb49968bee439,
29028 >(_buf?)?;
29029 Ok(_response.map(|x| x))
29030 }
29031 self.client.send_query_and_decode::<
29032 BaseSocketSetOutOfBandInlineRequest,
29033 BaseSocketSetOutOfBandInlineResult,
29034 >(
29035 (value,),
29036 0x3ecb49968bee439,
29037 fidl::encoding::DynamicFlags::empty(),
29038 _decode,
29039 )
29040 }
29041
29042 type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
29043 BaseSocketGetOutOfBandInlineResult,
29044 fidl::encoding::DefaultFuchsiaResourceDialect,
29045 >;
29046 fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
29047 fn _decode(
29048 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29049 ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
29050 let _response = fidl::client::decode_transaction_body::<
29051 fidl::encoding::ResultType<
29052 BaseSocketGetOutOfBandInlineResponse,
29053 fidl_fuchsia_posix::Errno,
29054 >,
29055 fidl::encoding::DefaultFuchsiaResourceDialect,
29056 0x348c1ab3aeca1745,
29057 >(_buf?)?;
29058 Ok(_response.map(|x| x.value))
29059 }
29060 self.client.send_query_and_decode::<
29061 fidl::encoding::EmptyPayload,
29062 BaseSocketGetOutOfBandInlineResult,
29063 >(
29064 (),
29065 0x348c1ab3aeca1745,
29066 fidl::encoding::DynamicFlags::empty(),
29067 _decode,
29068 )
29069 }
29070
29071 type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
29072 BaseSocketSetNoCheckResult,
29073 fidl::encoding::DefaultFuchsiaResourceDialect,
29074 >;
29075 fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
29076 fn _decode(
29077 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29078 ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
29079 let _response = fidl::client::decode_transaction_body::<
29080 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
29081 fidl::encoding::DefaultFuchsiaResourceDialect,
29082 0x6bbf00c53a4c78c2,
29083 >(_buf?)?;
29084 Ok(_response.map(|x| x))
29085 }
29086 self.client
29087 .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
29088 (value,),
29089 0x6bbf00c53a4c78c2,
29090 fidl::encoding::DynamicFlags::empty(),
29091 _decode,
29092 )
29093 }
29094
29095 type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
29096 BaseSocketGetNoCheckResult,
29097 fidl::encoding::DefaultFuchsiaResourceDialect,
29098 >;
29099 fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
29100 fn _decode(
29101 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29102 ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
29103 let _response = fidl::client::decode_transaction_body::<
29104 fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
29105 fidl::encoding::DefaultFuchsiaResourceDialect,
29106 0x2cd4249286417694,
29107 >(_buf?)?;
29108 Ok(_response.map(|x| x.value))
29109 }
29110 self.client
29111 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
29112 (),
29113 0x2cd4249286417694,
29114 fidl::encoding::DynamicFlags::empty(),
29115 _decode,
29116 )
29117 }
29118
29119 type SetLingerResponseFut = fidl::client::QueryResponseFut<
29120 BaseSocketSetLingerResult,
29121 fidl::encoding::DefaultFuchsiaResourceDialect,
29122 >;
29123 fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
29124 fn _decode(
29125 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29126 ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
29127 let _response = fidl::client::decode_transaction_body::<
29128 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
29129 fidl::encoding::DefaultFuchsiaResourceDialect,
29130 0x45386351246e998e,
29131 >(_buf?)?;
29132 Ok(_response.map(|x| x))
29133 }
29134 self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
29135 (linger, length_secs),
29136 0x45386351246e998e,
29137 fidl::encoding::DynamicFlags::empty(),
29138 _decode,
29139 )
29140 }
29141
29142 type GetLingerResponseFut = fidl::client::QueryResponseFut<
29143 BaseSocketGetLingerResult,
29144 fidl::encoding::DefaultFuchsiaResourceDialect,
29145 >;
29146 fn r#get_linger(&self) -> Self::GetLingerResponseFut {
29147 fn _decode(
29148 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29149 ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
29150 let _response = fidl::client::decode_transaction_body::<
29151 fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
29152 fidl::encoding::DefaultFuchsiaResourceDialect,
29153 0x48eb20fc5ccb0e45,
29154 >(_buf?)?;
29155 Ok(_response.map(|x| (x.linger, x.length_secs)))
29156 }
29157 self.client
29158 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
29159 (),
29160 0x48eb20fc5ccb0e45,
29161 fidl::encoding::DynamicFlags::empty(),
29162 _decode,
29163 )
29164 }
29165
29166 type SetReusePortResponseFut = fidl::client::QueryResponseFut<
29167 BaseSocketSetReusePortResult,
29168 fidl::encoding::DefaultFuchsiaResourceDialect,
29169 >;
29170 fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
29171 fn _decode(
29172 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29173 ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
29174 let _response = fidl::client::decode_transaction_body::<
29175 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
29176 fidl::encoding::DefaultFuchsiaResourceDialect,
29177 0x24dd3e5cb36d9ccb,
29178 >(_buf?)?;
29179 Ok(_response.map(|x| x))
29180 }
29181 self.client
29182 .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
29183 (value,),
29184 0x24dd3e5cb36d9ccb,
29185 fidl::encoding::DynamicFlags::empty(),
29186 _decode,
29187 )
29188 }
29189
29190 type GetReusePortResponseFut = fidl::client::QueryResponseFut<
29191 BaseSocketGetReusePortResult,
29192 fidl::encoding::DefaultFuchsiaResourceDialect,
29193 >;
29194 fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
29195 fn _decode(
29196 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29197 ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
29198 let _response = fidl::client::decode_transaction_body::<
29199 fidl::encoding::ResultType<
29200 BaseSocketGetReusePortResponse,
29201 fidl_fuchsia_posix::Errno,
29202 >,
29203 fidl::encoding::DefaultFuchsiaResourceDialect,
29204 0x7a112c1ab54ff828,
29205 >(_buf?)?;
29206 Ok(_response.map(|x| x.value))
29207 }
29208 self.client
29209 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
29210 (),
29211 0x7a112c1ab54ff828,
29212 fidl::encoding::DynamicFlags::empty(),
29213 _decode,
29214 )
29215 }
29216
29217 type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
29218 BaseSocketGetAcceptConnResult,
29219 fidl::encoding::DefaultFuchsiaResourceDialect,
29220 >;
29221 fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
29222 fn _decode(
29223 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29224 ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
29225 let _response = fidl::client::decode_transaction_body::<
29226 fidl::encoding::ResultType<
29227 BaseSocketGetAcceptConnResponse,
29228 fidl_fuchsia_posix::Errno,
29229 >,
29230 fidl::encoding::DefaultFuchsiaResourceDialect,
29231 0x67ce6db6c2ec8966,
29232 >(_buf?)?;
29233 Ok(_response.map(|x| x.value))
29234 }
29235 self.client
29236 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
29237 (),
29238 0x67ce6db6c2ec8966,
29239 fidl::encoding::DynamicFlags::empty(),
29240 _decode,
29241 )
29242 }
29243
29244 type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
29245 BaseSocketSetBindToDeviceResult,
29246 fidl::encoding::DefaultFuchsiaResourceDialect,
29247 >;
29248 fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
29249 fn _decode(
29250 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29251 ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
29252 let _response = fidl::client::decode_transaction_body::<
29253 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
29254 fidl::encoding::DefaultFuchsiaResourceDialect,
29255 0x2118b483f28aafc4,
29256 >(_buf?)?;
29257 Ok(_response.map(|x| x))
29258 }
29259 self.client.send_query_and_decode::<
29260 BaseSocketSetBindToDeviceRequest,
29261 BaseSocketSetBindToDeviceResult,
29262 >(
29263 (value,),
29264 0x2118b483f28aafc4,
29265 fidl::encoding::DynamicFlags::empty(),
29266 _decode,
29267 )
29268 }
29269
29270 type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
29271 BaseSocketGetBindToDeviceResult,
29272 fidl::encoding::DefaultFuchsiaResourceDialect,
29273 >;
29274 fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
29275 fn _decode(
29276 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29277 ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
29278 let _response = fidl::client::decode_transaction_body::<
29279 fidl::encoding::ResultType<
29280 BaseSocketGetBindToDeviceResponse,
29281 fidl_fuchsia_posix::Errno,
29282 >,
29283 fidl::encoding::DefaultFuchsiaResourceDialect,
29284 0x1ab1fbf0ef7906c8,
29285 >(_buf?)?;
29286 Ok(_response.map(|x| x.value))
29287 }
29288 self.client
29289 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
29290 (),
29291 0x1ab1fbf0ef7906c8,
29292 fidl::encoding::DynamicFlags::empty(),
29293 _decode,
29294 )
29295 }
29296
29297 type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
29298 BaseSocketSetBindToInterfaceIndexResult,
29299 fidl::encoding::DefaultFuchsiaResourceDialect,
29300 >;
29301 fn r#set_bind_to_interface_index(
29302 &self,
29303 mut value: u64,
29304 ) -> Self::SetBindToInterfaceIndexResponseFut {
29305 fn _decode(
29306 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29307 ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
29308 let _response = fidl::client::decode_transaction_body::<
29309 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
29310 fidl::encoding::DefaultFuchsiaResourceDialect,
29311 0x6e387a0def00821,
29312 >(_buf?)?;
29313 Ok(_response.map(|x| x))
29314 }
29315 self.client.send_query_and_decode::<
29316 BaseSocketSetBindToInterfaceIndexRequest,
29317 BaseSocketSetBindToInterfaceIndexResult,
29318 >(
29319 (value,),
29320 0x6e387a0def00821,
29321 fidl::encoding::DynamicFlags::empty(),
29322 _decode,
29323 )
29324 }
29325
29326 type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
29327 BaseSocketGetBindToInterfaceIndexResult,
29328 fidl::encoding::DefaultFuchsiaResourceDialect,
29329 >;
29330 fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
29331 fn _decode(
29332 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29333 ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
29334 let _response = fidl::client::decode_transaction_body::<
29335 fidl::encoding::ResultType<
29336 BaseSocketGetBindToInterfaceIndexResponse,
29337 fidl_fuchsia_posix::Errno,
29338 >,
29339 fidl::encoding::DefaultFuchsiaResourceDialect,
29340 0x59c31dd3e3078295,
29341 >(_buf?)?;
29342 Ok(_response.map(|x| x.value))
29343 }
29344 self.client.send_query_and_decode::<
29345 fidl::encoding::EmptyPayload,
29346 BaseSocketGetBindToInterfaceIndexResult,
29347 >(
29348 (),
29349 0x59c31dd3e3078295,
29350 fidl::encoding::DynamicFlags::empty(),
29351 _decode,
29352 )
29353 }
29354
29355 type SetTimestampResponseFut = fidl::client::QueryResponseFut<
29356 BaseSocketSetTimestampResult,
29357 fidl::encoding::DefaultFuchsiaResourceDialect,
29358 >;
29359 fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
29360 fn _decode(
29361 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29362 ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
29363 let _response = fidl::client::decode_transaction_body::<
29364 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
29365 fidl::encoding::DefaultFuchsiaResourceDialect,
29366 0x285d6516c263d839,
29367 >(_buf?)?;
29368 Ok(_response.map(|x| x))
29369 }
29370 self.client
29371 .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
29372 (value,),
29373 0x285d6516c263d839,
29374 fidl::encoding::DynamicFlags::empty(),
29375 _decode,
29376 )
29377 }
29378
29379 type GetTimestampResponseFut = fidl::client::QueryResponseFut<
29380 BaseSocketGetTimestampResult,
29381 fidl::encoding::DefaultFuchsiaResourceDialect,
29382 >;
29383 fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
29384 fn _decode(
29385 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29386 ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
29387 let _response = fidl::client::decode_transaction_body::<
29388 fidl::encoding::ResultType<
29389 BaseSocketGetTimestampResponse,
29390 fidl_fuchsia_posix::Errno,
29391 >,
29392 fidl::encoding::DefaultFuchsiaResourceDialect,
29393 0x49f2fffbbcc2bd27,
29394 >(_buf?)?;
29395 Ok(_response.map(|x| x.value))
29396 }
29397 self.client
29398 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
29399 (),
29400 0x49f2fffbbcc2bd27,
29401 fidl::encoding::DynamicFlags::empty(),
29402 _decode,
29403 )
29404 }
29405
29406 type SetMarkResponseFut = fidl::client::QueryResponseFut<
29407 BaseSocketSetMarkResult,
29408 fidl::encoding::DefaultFuchsiaResourceDialect,
29409 >;
29410 fn r#set_mark(
29411 &self,
29412 mut domain: fidl_fuchsia_net::MarkDomain,
29413 mut mark: &OptionalUint32,
29414 ) -> Self::SetMarkResponseFut {
29415 fn _decode(
29416 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29417 ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
29418 let _response = fidl::client::decode_transaction_body::<
29419 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
29420 fidl::encoding::DefaultFuchsiaResourceDialect,
29421 0x6ead6de09f653236,
29422 >(_buf?)?;
29423 Ok(_response.map(|x| x))
29424 }
29425 self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
29426 (domain, mark),
29427 0x6ead6de09f653236,
29428 fidl::encoding::DynamicFlags::empty(),
29429 _decode,
29430 )
29431 }
29432
29433 type GetMarkResponseFut = fidl::client::QueryResponseFut<
29434 BaseSocketGetMarkResult,
29435 fidl::encoding::DefaultFuchsiaResourceDialect,
29436 >;
29437 fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
29438 fn _decode(
29439 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29440 ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
29441 let _response = fidl::client::decode_transaction_body::<
29442 fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
29443 fidl::encoding::DefaultFuchsiaResourceDialect,
29444 0x57a2752c61d93d47,
29445 >(_buf?)?;
29446 Ok(_response.map(|x| x.mark))
29447 }
29448 self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
29449 (domain,),
29450 0x57a2752c61d93d47,
29451 fidl::encoding::DynamicFlags::empty(),
29452 _decode,
29453 )
29454 }
29455}
29456
29457pub struct BaseSocketEventStream {
29458 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
29459}
29460
29461impl std::marker::Unpin for BaseSocketEventStream {}
29462
29463impl futures::stream::FusedStream for BaseSocketEventStream {
29464 fn is_terminated(&self) -> bool {
29465 self.event_receiver.is_terminated()
29466 }
29467}
29468
29469impl futures::Stream for BaseSocketEventStream {
29470 type Item = Result<BaseSocketEvent, fidl::Error>;
29471
29472 fn poll_next(
29473 mut self: std::pin::Pin<&mut Self>,
29474 cx: &mut std::task::Context<'_>,
29475 ) -> std::task::Poll<Option<Self::Item>> {
29476 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
29477 &mut self.event_receiver,
29478 cx
29479 )?) {
29480 Some(buf) => std::task::Poll::Ready(Some(BaseSocketEvent::decode(buf))),
29481 None => std::task::Poll::Ready(None),
29482 }
29483 }
29484}
29485
29486#[derive(Debug)]
29487pub enum BaseSocketEvent {}
29488
29489impl BaseSocketEvent {
29490 fn decode(
29492 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
29493 ) -> Result<BaseSocketEvent, fidl::Error> {
29494 let (bytes, _handles) = buf.split_mut();
29495 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
29496 debug_assert_eq!(tx_header.tx_id, 0);
29497 match tx_header.ordinal {
29498 _ => Err(fidl::Error::UnknownOrdinal {
29499 ordinal: tx_header.ordinal,
29500 protocol_name: <BaseSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
29501 }),
29502 }
29503 }
29504}
29505
29506pub struct BaseSocketRequestStream {
29508 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
29509 is_terminated: bool,
29510}
29511
29512impl std::marker::Unpin for BaseSocketRequestStream {}
29513
29514impl futures::stream::FusedStream for BaseSocketRequestStream {
29515 fn is_terminated(&self) -> bool {
29516 self.is_terminated
29517 }
29518}
29519
29520impl fidl::endpoints::RequestStream for BaseSocketRequestStream {
29521 type Protocol = BaseSocketMarker;
29522 type ControlHandle = BaseSocketControlHandle;
29523
29524 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
29525 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
29526 }
29527
29528 fn control_handle(&self) -> Self::ControlHandle {
29529 BaseSocketControlHandle { inner: self.inner.clone() }
29530 }
29531
29532 fn into_inner(
29533 self,
29534 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
29535 {
29536 (self.inner, self.is_terminated)
29537 }
29538
29539 fn from_inner(
29540 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
29541 is_terminated: bool,
29542 ) -> Self {
29543 Self { inner, is_terminated }
29544 }
29545}
29546
29547impl futures::Stream for BaseSocketRequestStream {
29548 type Item = Result<BaseSocketRequest, fidl::Error>;
29549
29550 fn poll_next(
29551 mut self: std::pin::Pin<&mut Self>,
29552 cx: &mut std::task::Context<'_>,
29553 ) -> std::task::Poll<Option<Self::Item>> {
29554 let this = &mut *self;
29555 if this.inner.check_shutdown(cx) {
29556 this.is_terminated = true;
29557 return std::task::Poll::Ready(None);
29558 }
29559 if this.is_terminated {
29560 panic!("polled BaseSocketRequestStream after completion");
29561 }
29562 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
29563 |bytes, handles| {
29564 match this.inner.channel().read_etc(cx, bytes, handles) {
29565 std::task::Poll::Ready(Ok(())) => {}
29566 std::task::Poll::Pending => return std::task::Poll::Pending,
29567 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
29568 this.is_terminated = true;
29569 return std::task::Poll::Ready(None);
29570 }
29571 std::task::Poll::Ready(Err(e)) => {
29572 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
29573 e.into(),
29574 ))))
29575 }
29576 }
29577
29578 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
29580
29581 std::task::Poll::Ready(Some(match header.ordinal {
29582 0x20d8a7aba2168a79 => {
29583 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
29584 let mut req = fidl::new_empty!(
29585 fidl_fuchsia_unknown::CloneableCloneRequest,
29586 fidl::encoding::DefaultFuchsiaResourceDialect
29587 );
29588 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
29589 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29590 Ok(BaseSocketRequest::Clone { request: req.request, control_handle })
29591 }
29592 0x5ac5d459ad7f657e => {
29593 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29594 let mut req = fidl::new_empty!(
29595 fidl::encoding::EmptyPayload,
29596 fidl::encoding::DefaultFuchsiaResourceDialect
29597 );
29598 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29599 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29600 Ok(BaseSocketRequest::Close {
29601 responder: BaseSocketCloseResponder {
29602 control_handle: std::mem::ManuallyDrop::new(control_handle),
29603 tx_id: header.tx_id,
29604 },
29605 })
29606 }
29607 0x2658edee9decfc06 => {
29608 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29609 let mut req = fidl::new_empty!(
29610 fidl::encoding::EmptyPayload,
29611 fidl::encoding::DefaultFuchsiaResourceDialect
29612 );
29613 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29614 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29615 Ok(BaseSocketRequest::Query {
29616 responder: BaseSocketQueryResponder {
29617 control_handle: std::mem::ManuallyDrop::new(control_handle),
29618 tx_id: header.tx_id,
29619 },
29620 })
29621 }
29622 0x1fd74ee8b9a4a876 => {
29623 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29624 let mut req = fidl::new_empty!(
29625 BaseSocketSetReuseAddressRequest,
29626 fidl::encoding::DefaultFuchsiaResourceDialect
29627 );
29628 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
29629 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29630 Ok(BaseSocketRequest::SetReuseAddress {
29631 value: req.value,
29632
29633 responder: BaseSocketSetReuseAddressResponder {
29634 control_handle: std::mem::ManuallyDrop::new(control_handle),
29635 tx_id: header.tx_id,
29636 },
29637 })
29638 }
29639 0x67b7206b8d1bc0a5 => {
29640 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29641 let mut req = fidl::new_empty!(
29642 fidl::encoding::EmptyPayload,
29643 fidl::encoding::DefaultFuchsiaResourceDialect
29644 );
29645 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29646 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29647 Ok(BaseSocketRequest::GetReuseAddress {
29648 responder: BaseSocketGetReuseAddressResponder {
29649 control_handle: std::mem::ManuallyDrop::new(control_handle),
29650 tx_id: header.tx_id,
29651 },
29652 })
29653 }
29654 0x5aad39b33e5f6ebb => {
29655 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29656 let mut req = fidl::new_empty!(
29657 fidl::encoding::EmptyPayload,
29658 fidl::encoding::DefaultFuchsiaResourceDialect
29659 );
29660 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29661 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29662 Ok(BaseSocketRequest::GetError {
29663 responder: BaseSocketGetErrorResponder {
29664 control_handle: std::mem::ManuallyDrop::new(control_handle),
29665 tx_id: header.tx_id,
29666 },
29667 })
29668 }
29669 0x6023e081ce3cd947 => {
29670 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29671 let mut req = fidl::new_empty!(
29672 BaseSocketSetBroadcastRequest,
29673 fidl::encoding::DefaultFuchsiaResourceDialect
29674 );
29675 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
29676 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29677 Ok(BaseSocketRequest::SetBroadcast {
29678 value: req.value,
29679
29680 responder: BaseSocketSetBroadcastResponder {
29681 control_handle: std::mem::ManuallyDrop::new(control_handle),
29682 tx_id: header.tx_id,
29683 },
29684 })
29685 }
29686 0x68796fc556f9780d => {
29687 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29688 let mut req = fidl::new_empty!(
29689 fidl::encoding::EmptyPayload,
29690 fidl::encoding::DefaultFuchsiaResourceDialect
29691 );
29692 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29693 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29694 Ok(BaseSocketRequest::GetBroadcast {
29695 responder: BaseSocketGetBroadcastResponder {
29696 control_handle: std::mem::ManuallyDrop::new(control_handle),
29697 tx_id: header.tx_id,
29698 },
29699 })
29700 }
29701 0x756eac32d73a7a70 => {
29702 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29703 let mut req = fidl::new_empty!(
29704 BaseSocketSetSendBufferRequest,
29705 fidl::encoding::DefaultFuchsiaResourceDialect
29706 );
29707 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
29708 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29709 Ok(BaseSocketRequest::SetSendBuffer {
29710 value_bytes: req.value_bytes,
29711
29712 responder: BaseSocketSetSendBufferResponder {
29713 control_handle: std::mem::ManuallyDrop::new(control_handle),
29714 tx_id: header.tx_id,
29715 },
29716 })
29717 }
29718 0x78a52fd9c7b2410b => {
29719 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29720 let mut req = fidl::new_empty!(
29721 fidl::encoding::EmptyPayload,
29722 fidl::encoding::DefaultFuchsiaResourceDialect
29723 );
29724 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29725 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29726 Ok(BaseSocketRequest::GetSendBuffer {
29727 responder: BaseSocketGetSendBufferResponder {
29728 control_handle: std::mem::ManuallyDrop::new(control_handle),
29729 tx_id: header.tx_id,
29730 },
29731 })
29732 }
29733 0x6b0cf2f1919c7001 => {
29734 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29735 let mut req = fidl::new_empty!(
29736 BaseSocketSetReceiveBufferRequest,
29737 fidl::encoding::DefaultFuchsiaResourceDialect
29738 );
29739 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
29740 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29741 Ok(BaseSocketRequest::SetReceiveBuffer {
29742 value_bytes: req.value_bytes,
29743
29744 responder: BaseSocketSetReceiveBufferResponder {
29745 control_handle: std::mem::ManuallyDrop::new(control_handle),
29746 tx_id: header.tx_id,
29747 },
29748 })
29749 }
29750 0x14c1a4b64f709e5c => {
29751 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29752 let mut req = fidl::new_empty!(
29753 fidl::encoding::EmptyPayload,
29754 fidl::encoding::DefaultFuchsiaResourceDialect
29755 );
29756 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29757 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29758 Ok(BaseSocketRequest::GetReceiveBuffer {
29759 responder: BaseSocketGetReceiveBufferResponder {
29760 control_handle: std::mem::ManuallyDrop::new(control_handle),
29761 tx_id: header.tx_id,
29762 },
29763 })
29764 }
29765 0x572df8f0b920d2c7 => {
29766 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29767 let mut req = fidl::new_empty!(
29768 BaseSocketSetKeepAliveRequest,
29769 fidl::encoding::DefaultFuchsiaResourceDialect
29770 );
29771 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
29772 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29773 Ok(BaseSocketRequest::SetKeepAlive {
29774 value: req.value,
29775
29776 responder: BaseSocketSetKeepAliveResponder {
29777 control_handle: std::mem::ManuallyDrop::new(control_handle),
29778 tx_id: header.tx_id,
29779 },
29780 })
29781 }
29782 0x2dd29d3215f2c9d2 => {
29783 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29784 let mut req = fidl::new_empty!(
29785 fidl::encoding::EmptyPayload,
29786 fidl::encoding::DefaultFuchsiaResourceDialect
29787 );
29788 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29789 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29790 Ok(BaseSocketRequest::GetKeepAlive {
29791 responder: BaseSocketGetKeepAliveResponder {
29792 control_handle: std::mem::ManuallyDrop::new(control_handle),
29793 tx_id: header.tx_id,
29794 },
29795 })
29796 }
29797 0x3ecb49968bee439 => {
29798 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29799 let mut req = fidl::new_empty!(
29800 BaseSocketSetOutOfBandInlineRequest,
29801 fidl::encoding::DefaultFuchsiaResourceDialect
29802 );
29803 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
29804 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29805 Ok(BaseSocketRequest::SetOutOfBandInline {
29806 value: req.value,
29807
29808 responder: BaseSocketSetOutOfBandInlineResponder {
29809 control_handle: std::mem::ManuallyDrop::new(control_handle),
29810 tx_id: header.tx_id,
29811 },
29812 })
29813 }
29814 0x348c1ab3aeca1745 => {
29815 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29816 let mut req = fidl::new_empty!(
29817 fidl::encoding::EmptyPayload,
29818 fidl::encoding::DefaultFuchsiaResourceDialect
29819 );
29820 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29821 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29822 Ok(BaseSocketRequest::GetOutOfBandInline {
29823 responder: BaseSocketGetOutOfBandInlineResponder {
29824 control_handle: std::mem::ManuallyDrop::new(control_handle),
29825 tx_id: header.tx_id,
29826 },
29827 })
29828 }
29829 0x6bbf00c53a4c78c2 => {
29830 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29831 let mut req = fidl::new_empty!(
29832 BaseSocketSetNoCheckRequest,
29833 fidl::encoding::DefaultFuchsiaResourceDialect
29834 );
29835 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
29836 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29837 Ok(BaseSocketRequest::SetNoCheck {
29838 value: req.value,
29839
29840 responder: BaseSocketSetNoCheckResponder {
29841 control_handle: std::mem::ManuallyDrop::new(control_handle),
29842 tx_id: header.tx_id,
29843 },
29844 })
29845 }
29846 0x2cd4249286417694 => {
29847 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29848 let mut req = fidl::new_empty!(
29849 fidl::encoding::EmptyPayload,
29850 fidl::encoding::DefaultFuchsiaResourceDialect
29851 );
29852 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29853 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29854 Ok(BaseSocketRequest::GetNoCheck {
29855 responder: BaseSocketGetNoCheckResponder {
29856 control_handle: std::mem::ManuallyDrop::new(control_handle),
29857 tx_id: header.tx_id,
29858 },
29859 })
29860 }
29861 0x45386351246e998e => {
29862 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29863 let mut req = fidl::new_empty!(
29864 BaseSocketSetLingerRequest,
29865 fidl::encoding::DefaultFuchsiaResourceDialect
29866 );
29867 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
29868 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29869 Ok(BaseSocketRequest::SetLinger {
29870 linger: req.linger,
29871 length_secs: req.length_secs,
29872
29873 responder: BaseSocketSetLingerResponder {
29874 control_handle: std::mem::ManuallyDrop::new(control_handle),
29875 tx_id: header.tx_id,
29876 },
29877 })
29878 }
29879 0x48eb20fc5ccb0e45 => {
29880 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29881 let mut req = fidl::new_empty!(
29882 fidl::encoding::EmptyPayload,
29883 fidl::encoding::DefaultFuchsiaResourceDialect
29884 );
29885 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29886 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29887 Ok(BaseSocketRequest::GetLinger {
29888 responder: BaseSocketGetLingerResponder {
29889 control_handle: std::mem::ManuallyDrop::new(control_handle),
29890 tx_id: header.tx_id,
29891 },
29892 })
29893 }
29894 0x24dd3e5cb36d9ccb => {
29895 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29896 let mut req = fidl::new_empty!(
29897 BaseSocketSetReusePortRequest,
29898 fidl::encoding::DefaultFuchsiaResourceDialect
29899 );
29900 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
29901 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29902 Ok(BaseSocketRequest::SetReusePort {
29903 value: req.value,
29904
29905 responder: BaseSocketSetReusePortResponder {
29906 control_handle: std::mem::ManuallyDrop::new(control_handle),
29907 tx_id: header.tx_id,
29908 },
29909 })
29910 }
29911 0x7a112c1ab54ff828 => {
29912 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29913 let mut req = fidl::new_empty!(
29914 fidl::encoding::EmptyPayload,
29915 fidl::encoding::DefaultFuchsiaResourceDialect
29916 );
29917 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29918 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29919 Ok(BaseSocketRequest::GetReusePort {
29920 responder: BaseSocketGetReusePortResponder {
29921 control_handle: std::mem::ManuallyDrop::new(control_handle),
29922 tx_id: header.tx_id,
29923 },
29924 })
29925 }
29926 0x67ce6db6c2ec8966 => {
29927 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29928 let mut req = fidl::new_empty!(
29929 fidl::encoding::EmptyPayload,
29930 fidl::encoding::DefaultFuchsiaResourceDialect
29931 );
29932 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29933 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29934 Ok(BaseSocketRequest::GetAcceptConn {
29935 responder: BaseSocketGetAcceptConnResponder {
29936 control_handle: std::mem::ManuallyDrop::new(control_handle),
29937 tx_id: header.tx_id,
29938 },
29939 })
29940 }
29941 0x2118b483f28aafc4 => {
29942 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29943 let mut req = fidl::new_empty!(
29944 BaseSocketSetBindToDeviceRequest,
29945 fidl::encoding::DefaultFuchsiaResourceDialect
29946 );
29947 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
29948 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29949 Ok(BaseSocketRequest::SetBindToDevice {
29950 value: req.value,
29951
29952 responder: BaseSocketSetBindToDeviceResponder {
29953 control_handle: std::mem::ManuallyDrop::new(control_handle),
29954 tx_id: header.tx_id,
29955 },
29956 })
29957 }
29958 0x1ab1fbf0ef7906c8 => {
29959 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29960 let mut req = fidl::new_empty!(
29961 fidl::encoding::EmptyPayload,
29962 fidl::encoding::DefaultFuchsiaResourceDialect
29963 );
29964 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29965 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29966 Ok(BaseSocketRequest::GetBindToDevice {
29967 responder: BaseSocketGetBindToDeviceResponder {
29968 control_handle: std::mem::ManuallyDrop::new(control_handle),
29969 tx_id: header.tx_id,
29970 },
29971 })
29972 }
29973 0x6e387a0def00821 => {
29974 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29975 let mut req = fidl::new_empty!(
29976 BaseSocketSetBindToInterfaceIndexRequest,
29977 fidl::encoding::DefaultFuchsiaResourceDialect
29978 );
29979 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
29980 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29981 Ok(BaseSocketRequest::SetBindToInterfaceIndex {
29982 value: req.value,
29983
29984 responder: BaseSocketSetBindToInterfaceIndexResponder {
29985 control_handle: std::mem::ManuallyDrop::new(control_handle),
29986 tx_id: header.tx_id,
29987 },
29988 })
29989 }
29990 0x59c31dd3e3078295 => {
29991 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29992 let mut req = fidl::new_empty!(
29993 fidl::encoding::EmptyPayload,
29994 fidl::encoding::DefaultFuchsiaResourceDialect
29995 );
29996 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29997 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29998 Ok(BaseSocketRequest::GetBindToInterfaceIndex {
29999 responder: BaseSocketGetBindToInterfaceIndexResponder {
30000 control_handle: std::mem::ManuallyDrop::new(control_handle),
30001 tx_id: header.tx_id,
30002 },
30003 })
30004 }
30005 0x285d6516c263d839 => {
30006 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
30007 let mut req = fidl::new_empty!(
30008 BaseSocketSetTimestampRequest,
30009 fidl::encoding::DefaultFuchsiaResourceDialect
30010 );
30011 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
30012 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
30013 Ok(BaseSocketRequest::SetTimestamp {
30014 value: req.value,
30015
30016 responder: BaseSocketSetTimestampResponder {
30017 control_handle: std::mem::ManuallyDrop::new(control_handle),
30018 tx_id: header.tx_id,
30019 },
30020 })
30021 }
30022 0x49f2fffbbcc2bd27 => {
30023 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
30024 let mut req = fidl::new_empty!(
30025 fidl::encoding::EmptyPayload,
30026 fidl::encoding::DefaultFuchsiaResourceDialect
30027 );
30028 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
30029 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
30030 Ok(BaseSocketRequest::GetTimestamp {
30031 responder: BaseSocketGetTimestampResponder {
30032 control_handle: std::mem::ManuallyDrop::new(control_handle),
30033 tx_id: header.tx_id,
30034 },
30035 })
30036 }
30037 0x6ead6de09f653236 => {
30038 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
30039 let mut req = fidl::new_empty!(
30040 BaseSocketSetMarkRequest,
30041 fidl::encoding::DefaultFuchsiaResourceDialect
30042 );
30043 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
30044 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
30045 Ok(BaseSocketRequest::SetMark {
30046 domain: req.domain,
30047 mark: req.mark,
30048
30049 responder: BaseSocketSetMarkResponder {
30050 control_handle: std::mem::ManuallyDrop::new(control_handle),
30051 tx_id: header.tx_id,
30052 },
30053 })
30054 }
30055 0x57a2752c61d93d47 => {
30056 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
30057 let mut req = fidl::new_empty!(
30058 BaseSocketGetMarkRequest,
30059 fidl::encoding::DefaultFuchsiaResourceDialect
30060 );
30061 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
30062 let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
30063 Ok(BaseSocketRequest::GetMark {
30064 domain: req.domain,
30065
30066 responder: BaseSocketGetMarkResponder {
30067 control_handle: std::mem::ManuallyDrop::new(control_handle),
30068 tx_id: header.tx_id,
30069 },
30070 })
30071 }
30072 _ => Err(fidl::Error::UnknownOrdinal {
30073 ordinal: header.ordinal,
30074 protocol_name:
30075 <BaseSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
30076 }),
30077 }))
30078 },
30079 )
30080 }
30081}
30082
30083#[derive(Debug)]
30085pub enum BaseSocketRequest {
30086 Clone {
30087 request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
30088 control_handle: BaseSocketControlHandle,
30089 },
30090 Close {
30101 responder: BaseSocketCloseResponder,
30102 },
30103 Query {
30104 responder: BaseSocketQueryResponder,
30105 },
30106 SetReuseAddress {
30108 value: bool,
30109 responder: BaseSocketSetReuseAddressResponder,
30110 },
30111 GetReuseAddress {
30113 responder: BaseSocketGetReuseAddressResponder,
30114 },
30115 GetError {
30118 responder: BaseSocketGetErrorResponder,
30119 },
30120 SetBroadcast {
30122 value: bool,
30123 responder: BaseSocketSetBroadcastResponder,
30124 },
30125 GetBroadcast {
30127 responder: BaseSocketGetBroadcastResponder,
30128 },
30129 SetSendBuffer {
30131 value_bytes: u64,
30132 responder: BaseSocketSetSendBufferResponder,
30133 },
30134 GetSendBuffer {
30136 responder: BaseSocketGetSendBufferResponder,
30137 },
30138 SetReceiveBuffer {
30140 value_bytes: u64,
30141 responder: BaseSocketSetReceiveBufferResponder,
30142 },
30143 GetReceiveBuffer {
30145 responder: BaseSocketGetReceiveBufferResponder,
30146 },
30147 SetKeepAlive {
30149 value: bool,
30150 responder: BaseSocketSetKeepAliveResponder,
30151 },
30152 GetKeepAlive {
30154 responder: BaseSocketGetKeepAliveResponder,
30155 },
30156 SetOutOfBandInline {
30158 value: bool,
30159 responder: BaseSocketSetOutOfBandInlineResponder,
30160 },
30161 GetOutOfBandInline {
30163 responder: BaseSocketGetOutOfBandInlineResponder,
30164 },
30165 SetNoCheck {
30167 value: bool,
30168 responder: BaseSocketSetNoCheckResponder,
30169 },
30170 GetNoCheck {
30172 responder: BaseSocketGetNoCheckResponder,
30173 },
30174 SetLinger {
30176 linger: bool,
30177 length_secs: u32,
30178 responder: BaseSocketSetLingerResponder,
30179 },
30180 GetLinger {
30182 responder: BaseSocketGetLingerResponder,
30183 },
30184 SetReusePort {
30186 value: bool,
30187 responder: BaseSocketSetReusePortResponder,
30188 },
30189 GetReusePort {
30191 responder: BaseSocketGetReusePortResponder,
30192 },
30193 GetAcceptConn {
30195 responder: BaseSocketGetAcceptConnResponder,
30196 },
30197 SetBindToDevice {
30199 value: String,
30200 responder: BaseSocketSetBindToDeviceResponder,
30201 },
30202 GetBindToDevice {
30204 responder: BaseSocketGetBindToDeviceResponder,
30205 },
30206 SetBindToInterfaceIndex {
30209 value: u64,
30210 responder: BaseSocketSetBindToInterfaceIndexResponder,
30211 },
30212 GetBindToInterfaceIndex {
30214 responder: BaseSocketGetBindToInterfaceIndexResponder,
30215 },
30216 SetTimestamp {
30218 value: TimestampOption,
30219 responder: BaseSocketSetTimestampResponder,
30220 },
30221 GetTimestamp {
30223 responder: BaseSocketGetTimestampResponder,
30224 },
30225 SetMark {
30229 domain: fidl_fuchsia_net::MarkDomain,
30230 mark: OptionalUint32,
30231 responder: BaseSocketSetMarkResponder,
30232 },
30233 GetMark {
30237 domain: fidl_fuchsia_net::MarkDomain,
30238 responder: BaseSocketGetMarkResponder,
30239 },
30240}
30241
30242impl BaseSocketRequest {
30243 #[allow(irrefutable_let_patterns)]
30244 pub fn into_clone(
30245 self,
30246 ) -> Option<(
30247 fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
30248 BaseSocketControlHandle,
30249 )> {
30250 if let BaseSocketRequest::Clone { request, control_handle } = self {
30251 Some((request, control_handle))
30252 } else {
30253 None
30254 }
30255 }
30256
30257 #[allow(irrefutable_let_patterns)]
30258 pub fn into_close(self) -> Option<(BaseSocketCloseResponder)> {
30259 if let BaseSocketRequest::Close { responder } = self {
30260 Some((responder))
30261 } else {
30262 None
30263 }
30264 }
30265
30266 #[allow(irrefutable_let_patterns)]
30267 pub fn into_query(self) -> Option<(BaseSocketQueryResponder)> {
30268 if let BaseSocketRequest::Query { responder } = self {
30269 Some((responder))
30270 } else {
30271 None
30272 }
30273 }
30274
30275 #[allow(irrefutable_let_patterns)]
30276 pub fn into_set_reuse_address(self) -> Option<(bool, BaseSocketSetReuseAddressResponder)> {
30277 if let BaseSocketRequest::SetReuseAddress { value, responder } = self {
30278 Some((value, responder))
30279 } else {
30280 None
30281 }
30282 }
30283
30284 #[allow(irrefutable_let_patterns)]
30285 pub fn into_get_reuse_address(self) -> Option<(BaseSocketGetReuseAddressResponder)> {
30286 if let BaseSocketRequest::GetReuseAddress { responder } = self {
30287 Some((responder))
30288 } else {
30289 None
30290 }
30291 }
30292
30293 #[allow(irrefutable_let_patterns)]
30294 pub fn into_get_error(self) -> Option<(BaseSocketGetErrorResponder)> {
30295 if let BaseSocketRequest::GetError { responder } = self {
30296 Some((responder))
30297 } else {
30298 None
30299 }
30300 }
30301
30302 #[allow(irrefutable_let_patterns)]
30303 pub fn into_set_broadcast(self) -> Option<(bool, BaseSocketSetBroadcastResponder)> {
30304 if let BaseSocketRequest::SetBroadcast { value, responder } = self {
30305 Some((value, responder))
30306 } else {
30307 None
30308 }
30309 }
30310
30311 #[allow(irrefutable_let_patterns)]
30312 pub fn into_get_broadcast(self) -> Option<(BaseSocketGetBroadcastResponder)> {
30313 if let BaseSocketRequest::GetBroadcast { responder } = self {
30314 Some((responder))
30315 } else {
30316 None
30317 }
30318 }
30319
30320 #[allow(irrefutable_let_patterns)]
30321 pub fn into_set_send_buffer(self) -> Option<(u64, BaseSocketSetSendBufferResponder)> {
30322 if let BaseSocketRequest::SetSendBuffer { value_bytes, responder } = self {
30323 Some((value_bytes, responder))
30324 } else {
30325 None
30326 }
30327 }
30328
30329 #[allow(irrefutable_let_patterns)]
30330 pub fn into_get_send_buffer(self) -> Option<(BaseSocketGetSendBufferResponder)> {
30331 if let BaseSocketRequest::GetSendBuffer { responder } = self {
30332 Some((responder))
30333 } else {
30334 None
30335 }
30336 }
30337
30338 #[allow(irrefutable_let_patterns)]
30339 pub fn into_set_receive_buffer(self) -> Option<(u64, BaseSocketSetReceiveBufferResponder)> {
30340 if let BaseSocketRequest::SetReceiveBuffer { value_bytes, responder } = self {
30341 Some((value_bytes, responder))
30342 } else {
30343 None
30344 }
30345 }
30346
30347 #[allow(irrefutable_let_patterns)]
30348 pub fn into_get_receive_buffer(self) -> Option<(BaseSocketGetReceiveBufferResponder)> {
30349 if let BaseSocketRequest::GetReceiveBuffer { responder } = self {
30350 Some((responder))
30351 } else {
30352 None
30353 }
30354 }
30355
30356 #[allow(irrefutable_let_patterns)]
30357 pub fn into_set_keep_alive(self) -> Option<(bool, BaseSocketSetKeepAliveResponder)> {
30358 if let BaseSocketRequest::SetKeepAlive { value, responder } = self {
30359 Some((value, responder))
30360 } else {
30361 None
30362 }
30363 }
30364
30365 #[allow(irrefutable_let_patterns)]
30366 pub fn into_get_keep_alive(self) -> Option<(BaseSocketGetKeepAliveResponder)> {
30367 if let BaseSocketRequest::GetKeepAlive { responder } = self {
30368 Some((responder))
30369 } else {
30370 None
30371 }
30372 }
30373
30374 #[allow(irrefutable_let_patterns)]
30375 pub fn into_set_out_of_band_inline(
30376 self,
30377 ) -> Option<(bool, BaseSocketSetOutOfBandInlineResponder)> {
30378 if let BaseSocketRequest::SetOutOfBandInline { value, responder } = self {
30379 Some((value, responder))
30380 } else {
30381 None
30382 }
30383 }
30384
30385 #[allow(irrefutable_let_patterns)]
30386 pub fn into_get_out_of_band_inline(self) -> Option<(BaseSocketGetOutOfBandInlineResponder)> {
30387 if let BaseSocketRequest::GetOutOfBandInline { responder } = self {
30388 Some((responder))
30389 } else {
30390 None
30391 }
30392 }
30393
30394 #[allow(irrefutable_let_patterns)]
30395 pub fn into_set_no_check(self) -> Option<(bool, BaseSocketSetNoCheckResponder)> {
30396 if let BaseSocketRequest::SetNoCheck { value, responder } = self {
30397 Some((value, responder))
30398 } else {
30399 None
30400 }
30401 }
30402
30403 #[allow(irrefutable_let_patterns)]
30404 pub fn into_get_no_check(self) -> Option<(BaseSocketGetNoCheckResponder)> {
30405 if let BaseSocketRequest::GetNoCheck { responder } = self {
30406 Some((responder))
30407 } else {
30408 None
30409 }
30410 }
30411
30412 #[allow(irrefutable_let_patterns)]
30413 pub fn into_set_linger(self) -> Option<(bool, u32, BaseSocketSetLingerResponder)> {
30414 if let BaseSocketRequest::SetLinger { linger, length_secs, responder } = self {
30415 Some((linger, length_secs, responder))
30416 } else {
30417 None
30418 }
30419 }
30420
30421 #[allow(irrefutable_let_patterns)]
30422 pub fn into_get_linger(self) -> Option<(BaseSocketGetLingerResponder)> {
30423 if let BaseSocketRequest::GetLinger { responder } = self {
30424 Some((responder))
30425 } else {
30426 None
30427 }
30428 }
30429
30430 #[allow(irrefutable_let_patterns)]
30431 pub fn into_set_reuse_port(self) -> Option<(bool, BaseSocketSetReusePortResponder)> {
30432 if let BaseSocketRequest::SetReusePort { value, responder } = self {
30433 Some((value, responder))
30434 } else {
30435 None
30436 }
30437 }
30438
30439 #[allow(irrefutable_let_patterns)]
30440 pub fn into_get_reuse_port(self) -> Option<(BaseSocketGetReusePortResponder)> {
30441 if let BaseSocketRequest::GetReusePort { responder } = self {
30442 Some((responder))
30443 } else {
30444 None
30445 }
30446 }
30447
30448 #[allow(irrefutable_let_patterns)]
30449 pub fn into_get_accept_conn(self) -> Option<(BaseSocketGetAcceptConnResponder)> {
30450 if let BaseSocketRequest::GetAcceptConn { responder } = self {
30451 Some((responder))
30452 } else {
30453 None
30454 }
30455 }
30456
30457 #[allow(irrefutable_let_patterns)]
30458 pub fn into_set_bind_to_device(self) -> Option<(String, BaseSocketSetBindToDeviceResponder)> {
30459 if let BaseSocketRequest::SetBindToDevice { value, responder } = self {
30460 Some((value, responder))
30461 } else {
30462 None
30463 }
30464 }
30465
30466 #[allow(irrefutable_let_patterns)]
30467 pub fn into_get_bind_to_device(self) -> Option<(BaseSocketGetBindToDeviceResponder)> {
30468 if let BaseSocketRequest::GetBindToDevice { responder } = self {
30469 Some((responder))
30470 } else {
30471 None
30472 }
30473 }
30474
30475 #[allow(irrefutable_let_patterns)]
30476 pub fn into_set_bind_to_interface_index(
30477 self,
30478 ) -> Option<(u64, BaseSocketSetBindToInterfaceIndexResponder)> {
30479 if let BaseSocketRequest::SetBindToInterfaceIndex { value, responder } = self {
30480 Some((value, responder))
30481 } else {
30482 None
30483 }
30484 }
30485
30486 #[allow(irrefutable_let_patterns)]
30487 pub fn into_get_bind_to_interface_index(
30488 self,
30489 ) -> Option<(BaseSocketGetBindToInterfaceIndexResponder)> {
30490 if let BaseSocketRequest::GetBindToInterfaceIndex { responder } = self {
30491 Some((responder))
30492 } else {
30493 None
30494 }
30495 }
30496
30497 #[allow(irrefutable_let_patterns)]
30498 pub fn into_set_timestamp(self) -> Option<(TimestampOption, BaseSocketSetTimestampResponder)> {
30499 if let BaseSocketRequest::SetTimestamp { value, responder } = self {
30500 Some((value, responder))
30501 } else {
30502 None
30503 }
30504 }
30505
30506 #[allow(irrefutable_let_patterns)]
30507 pub fn into_get_timestamp(self) -> Option<(BaseSocketGetTimestampResponder)> {
30508 if let BaseSocketRequest::GetTimestamp { responder } = self {
30509 Some((responder))
30510 } else {
30511 None
30512 }
30513 }
30514
30515 #[allow(irrefutable_let_patterns)]
30516 pub fn into_set_mark(
30517 self,
30518 ) -> Option<(fidl_fuchsia_net::MarkDomain, OptionalUint32, BaseSocketSetMarkResponder)> {
30519 if let BaseSocketRequest::SetMark { domain, mark, responder } = self {
30520 Some((domain, mark, responder))
30521 } else {
30522 None
30523 }
30524 }
30525
30526 #[allow(irrefutable_let_patterns)]
30527 pub fn into_get_mark(
30528 self,
30529 ) -> Option<(fidl_fuchsia_net::MarkDomain, BaseSocketGetMarkResponder)> {
30530 if let BaseSocketRequest::GetMark { domain, responder } = self {
30531 Some((domain, responder))
30532 } else {
30533 None
30534 }
30535 }
30536
30537 pub fn method_name(&self) -> &'static str {
30539 match *self {
30540 BaseSocketRequest::Clone { .. } => "clone",
30541 BaseSocketRequest::Close { .. } => "close",
30542 BaseSocketRequest::Query { .. } => "query",
30543 BaseSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
30544 BaseSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
30545 BaseSocketRequest::GetError { .. } => "get_error",
30546 BaseSocketRequest::SetBroadcast { .. } => "set_broadcast",
30547 BaseSocketRequest::GetBroadcast { .. } => "get_broadcast",
30548 BaseSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
30549 BaseSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
30550 BaseSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
30551 BaseSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
30552 BaseSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
30553 BaseSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
30554 BaseSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
30555 BaseSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
30556 BaseSocketRequest::SetNoCheck { .. } => "set_no_check",
30557 BaseSocketRequest::GetNoCheck { .. } => "get_no_check",
30558 BaseSocketRequest::SetLinger { .. } => "set_linger",
30559 BaseSocketRequest::GetLinger { .. } => "get_linger",
30560 BaseSocketRequest::SetReusePort { .. } => "set_reuse_port",
30561 BaseSocketRequest::GetReusePort { .. } => "get_reuse_port",
30562 BaseSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
30563 BaseSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
30564 BaseSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
30565 BaseSocketRequest::SetBindToInterfaceIndex { .. } => "set_bind_to_interface_index",
30566 BaseSocketRequest::GetBindToInterfaceIndex { .. } => "get_bind_to_interface_index",
30567 BaseSocketRequest::SetTimestamp { .. } => "set_timestamp",
30568 BaseSocketRequest::GetTimestamp { .. } => "get_timestamp",
30569 BaseSocketRequest::SetMark { .. } => "set_mark",
30570 BaseSocketRequest::GetMark { .. } => "get_mark",
30571 }
30572 }
30573}
30574
30575#[derive(Debug, Clone)]
30576pub struct BaseSocketControlHandle {
30577 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
30578}
30579
30580impl fidl::endpoints::ControlHandle for BaseSocketControlHandle {
30581 fn shutdown(&self) {
30582 self.inner.shutdown()
30583 }
30584 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
30585 self.inner.shutdown_with_epitaph(status)
30586 }
30587
30588 fn is_closed(&self) -> bool {
30589 self.inner.channel().is_closed()
30590 }
30591 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
30592 self.inner.channel().on_closed()
30593 }
30594
30595 #[cfg(target_os = "fuchsia")]
30596 fn signal_peer(
30597 &self,
30598 clear_mask: zx::Signals,
30599 set_mask: zx::Signals,
30600 ) -> Result<(), zx_status::Status> {
30601 use fidl::Peered;
30602 self.inner.channel().signal_peer(clear_mask, set_mask)
30603 }
30604}
30605
30606impl BaseSocketControlHandle {}
30607
30608#[must_use = "FIDL methods require a response to be sent"]
30609#[derive(Debug)]
30610pub struct BaseSocketCloseResponder {
30611 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
30612 tx_id: u32,
30613}
30614
30615impl std::ops::Drop for BaseSocketCloseResponder {
30619 fn drop(&mut self) {
30620 self.control_handle.shutdown();
30621 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30623 }
30624}
30625
30626impl fidl::endpoints::Responder for BaseSocketCloseResponder {
30627 type ControlHandle = BaseSocketControlHandle;
30628
30629 fn control_handle(&self) -> &BaseSocketControlHandle {
30630 &self.control_handle
30631 }
30632
30633 fn drop_without_shutdown(mut self) {
30634 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30636 std::mem::forget(self);
30638 }
30639}
30640
30641impl BaseSocketCloseResponder {
30642 pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
30646 let _result = self.send_raw(result);
30647 if _result.is_err() {
30648 self.control_handle.shutdown();
30649 }
30650 self.drop_without_shutdown();
30651 _result
30652 }
30653
30654 pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
30656 let _result = self.send_raw(result);
30657 self.drop_without_shutdown();
30658 _result
30659 }
30660
30661 fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
30662 self.control_handle
30663 .inner
30664 .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
30665 result,
30666 self.tx_id,
30667 0x5ac5d459ad7f657e,
30668 fidl::encoding::DynamicFlags::empty(),
30669 )
30670 }
30671}
30672
30673#[must_use = "FIDL methods require a response to be sent"]
30674#[derive(Debug)]
30675pub struct BaseSocketQueryResponder {
30676 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
30677 tx_id: u32,
30678}
30679
30680impl std::ops::Drop for BaseSocketQueryResponder {
30684 fn drop(&mut self) {
30685 self.control_handle.shutdown();
30686 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30688 }
30689}
30690
30691impl fidl::endpoints::Responder for BaseSocketQueryResponder {
30692 type ControlHandle = BaseSocketControlHandle;
30693
30694 fn control_handle(&self) -> &BaseSocketControlHandle {
30695 &self.control_handle
30696 }
30697
30698 fn drop_without_shutdown(mut self) {
30699 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30701 std::mem::forget(self);
30703 }
30704}
30705
30706impl BaseSocketQueryResponder {
30707 pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
30711 let _result = self.send_raw(protocol);
30712 if _result.is_err() {
30713 self.control_handle.shutdown();
30714 }
30715 self.drop_without_shutdown();
30716 _result
30717 }
30718
30719 pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
30721 let _result = self.send_raw(protocol);
30722 self.drop_without_shutdown();
30723 _result
30724 }
30725
30726 fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
30727 self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
30728 (protocol,),
30729 self.tx_id,
30730 0x2658edee9decfc06,
30731 fidl::encoding::DynamicFlags::empty(),
30732 )
30733 }
30734}
30735
30736#[must_use = "FIDL methods require a response to be sent"]
30737#[derive(Debug)]
30738pub struct BaseSocketSetReuseAddressResponder {
30739 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
30740 tx_id: u32,
30741}
30742
30743impl std::ops::Drop for BaseSocketSetReuseAddressResponder {
30747 fn drop(&mut self) {
30748 self.control_handle.shutdown();
30749 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30751 }
30752}
30753
30754impl fidl::endpoints::Responder for BaseSocketSetReuseAddressResponder {
30755 type ControlHandle = BaseSocketControlHandle;
30756
30757 fn control_handle(&self) -> &BaseSocketControlHandle {
30758 &self.control_handle
30759 }
30760
30761 fn drop_without_shutdown(mut self) {
30762 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30764 std::mem::forget(self);
30766 }
30767}
30768
30769impl BaseSocketSetReuseAddressResponder {
30770 pub fn send(
30774 self,
30775 mut result: Result<(), fidl_fuchsia_posix::Errno>,
30776 ) -> Result<(), fidl::Error> {
30777 let _result = self.send_raw(result);
30778 if _result.is_err() {
30779 self.control_handle.shutdown();
30780 }
30781 self.drop_without_shutdown();
30782 _result
30783 }
30784
30785 pub fn send_no_shutdown_on_err(
30787 self,
30788 mut result: Result<(), fidl_fuchsia_posix::Errno>,
30789 ) -> Result<(), fidl::Error> {
30790 let _result = self.send_raw(result);
30791 self.drop_without_shutdown();
30792 _result
30793 }
30794
30795 fn send_raw(
30796 &self,
30797 mut result: Result<(), fidl_fuchsia_posix::Errno>,
30798 ) -> Result<(), fidl::Error> {
30799 self.control_handle.inner.send::<fidl::encoding::ResultType<
30800 fidl::encoding::EmptyStruct,
30801 fidl_fuchsia_posix::Errno,
30802 >>(
30803 result,
30804 self.tx_id,
30805 0x1fd74ee8b9a4a876,
30806 fidl::encoding::DynamicFlags::empty(),
30807 )
30808 }
30809}
30810
30811#[must_use = "FIDL methods require a response to be sent"]
30812#[derive(Debug)]
30813pub struct BaseSocketGetReuseAddressResponder {
30814 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
30815 tx_id: u32,
30816}
30817
30818impl std::ops::Drop for BaseSocketGetReuseAddressResponder {
30822 fn drop(&mut self) {
30823 self.control_handle.shutdown();
30824 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30826 }
30827}
30828
30829impl fidl::endpoints::Responder for BaseSocketGetReuseAddressResponder {
30830 type ControlHandle = BaseSocketControlHandle;
30831
30832 fn control_handle(&self) -> &BaseSocketControlHandle {
30833 &self.control_handle
30834 }
30835
30836 fn drop_without_shutdown(mut self) {
30837 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30839 std::mem::forget(self);
30841 }
30842}
30843
30844impl BaseSocketGetReuseAddressResponder {
30845 pub fn send(
30849 self,
30850 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
30851 ) -> Result<(), fidl::Error> {
30852 let _result = self.send_raw(result);
30853 if _result.is_err() {
30854 self.control_handle.shutdown();
30855 }
30856 self.drop_without_shutdown();
30857 _result
30858 }
30859
30860 pub fn send_no_shutdown_on_err(
30862 self,
30863 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
30864 ) -> Result<(), fidl::Error> {
30865 let _result = self.send_raw(result);
30866 self.drop_without_shutdown();
30867 _result
30868 }
30869
30870 fn send_raw(
30871 &self,
30872 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
30873 ) -> Result<(), fidl::Error> {
30874 self.control_handle.inner.send::<fidl::encoding::ResultType<
30875 BaseSocketGetReuseAddressResponse,
30876 fidl_fuchsia_posix::Errno,
30877 >>(
30878 result.map(|value| (value,)),
30879 self.tx_id,
30880 0x67b7206b8d1bc0a5,
30881 fidl::encoding::DynamicFlags::empty(),
30882 )
30883 }
30884}
30885
30886#[must_use = "FIDL methods require a response to be sent"]
30887#[derive(Debug)]
30888pub struct BaseSocketGetErrorResponder {
30889 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
30890 tx_id: u32,
30891}
30892
30893impl std::ops::Drop for BaseSocketGetErrorResponder {
30897 fn drop(&mut self) {
30898 self.control_handle.shutdown();
30899 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30901 }
30902}
30903
30904impl fidl::endpoints::Responder for BaseSocketGetErrorResponder {
30905 type ControlHandle = BaseSocketControlHandle;
30906
30907 fn control_handle(&self) -> &BaseSocketControlHandle {
30908 &self.control_handle
30909 }
30910
30911 fn drop_without_shutdown(mut self) {
30912 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30914 std::mem::forget(self);
30916 }
30917}
30918
30919impl BaseSocketGetErrorResponder {
30920 pub fn send(
30924 self,
30925 mut result: Result<(), fidl_fuchsia_posix::Errno>,
30926 ) -> Result<(), fidl::Error> {
30927 let _result = self.send_raw(result);
30928 if _result.is_err() {
30929 self.control_handle.shutdown();
30930 }
30931 self.drop_without_shutdown();
30932 _result
30933 }
30934
30935 pub fn send_no_shutdown_on_err(
30937 self,
30938 mut result: Result<(), fidl_fuchsia_posix::Errno>,
30939 ) -> Result<(), fidl::Error> {
30940 let _result = self.send_raw(result);
30941 self.drop_without_shutdown();
30942 _result
30943 }
30944
30945 fn send_raw(
30946 &self,
30947 mut result: Result<(), fidl_fuchsia_posix::Errno>,
30948 ) -> Result<(), fidl::Error> {
30949 self.control_handle.inner.send::<fidl::encoding::ResultType<
30950 fidl::encoding::EmptyStruct,
30951 fidl_fuchsia_posix::Errno,
30952 >>(
30953 result,
30954 self.tx_id,
30955 0x5aad39b33e5f6ebb,
30956 fidl::encoding::DynamicFlags::empty(),
30957 )
30958 }
30959}
30960
30961#[must_use = "FIDL methods require a response to be sent"]
30962#[derive(Debug)]
30963pub struct BaseSocketSetBroadcastResponder {
30964 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
30965 tx_id: u32,
30966}
30967
30968impl std::ops::Drop for BaseSocketSetBroadcastResponder {
30972 fn drop(&mut self) {
30973 self.control_handle.shutdown();
30974 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30976 }
30977}
30978
30979impl fidl::endpoints::Responder for BaseSocketSetBroadcastResponder {
30980 type ControlHandle = BaseSocketControlHandle;
30981
30982 fn control_handle(&self) -> &BaseSocketControlHandle {
30983 &self.control_handle
30984 }
30985
30986 fn drop_without_shutdown(mut self) {
30987 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30989 std::mem::forget(self);
30991 }
30992}
30993
30994impl BaseSocketSetBroadcastResponder {
30995 pub fn send(
30999 self,
31000 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31001 ) -> Result<(), fidl::Error> {
31002 let _result = self.send_raw(result);
31003 if _result.is_err() {
31004 self.control_handle.shutdown();
31005 }
31006 self.drop_without_shutdown();
31007 _result
31008 }
31009
31010 pub fn send_no_shutdown_on_err(
31012 self,
31013 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31014 ) -> Result<(), fidl::Error> {
31015 let _result = self.send_raw(result);
31016 self.drop_without_shutdown();
31017 _result
31018 }
31019
31020 fn send_raw(
31021 &self,
31022 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31023 ) -> Result<(), fidl::Error> {
31024 self.control_handle.inner.send::<fidl::encoding::ResultType<
31025 fidl::encoding::EmptyStruct,
31026 fidl_fuchsia_posix::Errno,
31027 >>(
31028 result,
31029 self.tx_id,
31030 0x6023e081ce3cd947,
31031 fidl::encoding::DynamicFlags::empty(),
31032 )
31033 }
31034}
31035
31036#[must_use = "FIDL methods require a response to be sent"]
31037#[derive(Debug)]
31038pub struct BaseSocketGetBroadcastResponder {
31039 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31040 tx_id: u32,
31041}
31042
31043impl std::ops::Drop for BaseSocketGetBroadcastResponder {
31047 fn drop(&mut self) {
31048 self.control_handle.shutdown();
31049 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31051 }
31052}
31053
31054impl fidl::endpoints::Responder for BaseSocketGetBroadcastResponder {
31055 type ControlHandle = BaseSocketControlHandle;
31056
31057 fn control_handle(&self) -> &BaseSocketControlHandle {
31058 &self.control_handle
31059 }
31060
31061 fn drop_without_shutdown(mut self) {
31062 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31064 std::mem::forget(self);
31066 }
31067}
31068
31069impl BaseSocketGetBroadcastResponder {
31070 pub fn send(
31074 self,
31075 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31076 ) -> Result<(), fidl::Error> {
31077 let _result = self.send_raw(result);
31078 if _result.is_err() {
31079 self.control_handle.shutdown();
31080 }
31081 self.drop_without_shutdown();
31082 _result
31083 }
31084
31085 pub fn send_no_shutdown_on_err(
31087 self,
31088 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31089 ) -> Result<(), fidl::Error> {
31090 let _result = self.send_raw(result);
31091 self.drop_without_shutdown();
31092 _result
31093 }
31094
31095 fn send_raw(
31096 &self,
31097 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31098 ) -> Result<(), fidl::Error> {
31099 self.control_handle.inner.send::<fidl::encoding::ResultType<
31100 BaseSocketGetBroadcastResponse,
31101 fidl_fuchsia_posix::Errno,
31102 >>(
31103 result.map(|value| (value,)),
31104 self.tx_id,
31105 0x68796fc556f9780d,
31106 fidl::encoding::DynamicFlags::empty(),
31107 )
31108 }
31109}
31110
31111#[must_use = "FIDL methods require a response to be sent"]
31112#[derive(Debug)]
31113pub struct BaseSocketSetSendBufferResponder {
31114 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31115 tx_id: u32,
31116}
31117
31118impl std::ops::Drop for BaseSocketSetSendBufferResponder {
31122 fn drop(&mut self) {
31123 self.control_handle.shutdown();
31124 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31126 }
31127}
31128
31129impl fidl::endpoints::Responder for BaseSocketSetSendBufferResponder {
31130 type ControlHandle = BaseSocketControlHandle;
31131
31132 fn control_handle(&self) -> &BaseSocketControlHandle {
31133 &self.control_handle
31134 }
31135
31136 fn drop_without_shutdown(mut self) {
31137 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31139 std::mem::forget(self);
31141 }
31142}
31143
31144impl BaseSocketSetSendBufferResponder {
31145 pub fn send(
31149 self,
31150 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31151 ) -> Result<(), fidl::Error> {
31152 let _result = self.send_raw(result);
31153 if _result.is_err() {
31154 self.control_handle.shutdown();
31155 }
31156 self.drop_without_shutdown();
31157 _result
31158 }
31159
31160 pub fn send_no_shutdown_on_err(
31162 self,
31163 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31164 ) -> Result<(), fidl::Error> {
31165 let _result = self.send_raw(result);
31166 self.drop_without_shutdown();
31167 _result
31168 }
31169
31170 fn send_raw(
31171 &self,
31172 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31173 ) -> Result<(), fidl::Error> {
31174 self.control_handle.inner.send::<fidl::encoding::ResultType<
31175 fidl::encoding::EmptyStruct,
31176 fidl_fuchsia_posix::Errno,
31177 >>(
31178 result,
31179 self.tx_id,
31180 0x756eac32d73a7a70,
31181 fidl::encoding::DynamicFlags::empty(),
31182 )
31183 }
31184}
31185
31186#[must_use = "FIDL methods require a response to be sent"]
31187#[derive(Debug)]
31188pub struct BaseSocketGetSendBufferResponder {
31189 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31190 tx_id: u32,
31191}
31192
31193impl std::ops::Drop for BaseSocketGetSendBufferResponder {
31197 fn drop(&mut self) {
31198 self.control_handle.shutdown();
31199 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31201 }
31202}
31203
31204impl fidl::endpoints::Responder for BaseSocketGetSendBufferResponder {
31205 type ControlHandle = BaseSocketControlHandle;
31206
31207 fn control_handle(&self) -> &BaseSocketControlHandle {
31208 &self.control_handle
31209 }
31210
31211 fn drop_without_shutdown(mut self) {
31212 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31214 std::mem::forget(self);
31216 }
31217}
31218
31219impl BaseSocketGetSendBufferResponder {
31220 pub fn send(
31224 self,
31225 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
31226 ) -> Result<(), fidl::Error> {
31227 let _result = self.send_raw(result);
31228 if _result.is_err() {
31229 self.control_handle.shutdown();
31230 }
31231 self.drop_without_shutdown();
31232 _result
31233 }
31234
31235 pub fn send_no_shutdown_on_err(
31237 self,
31238 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
31239 ) -> Result<(), fidl::Error> {
31240 let _result = self.send_raw(result);
31241 self.drop_without_shutdown();
31242 _result
31243 }
31244
31245 fn send_raw(
31246 &self,
31247 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
31248 ) -> Result<(), fidl::Error> {
31249 self.control_handle.inner.send::<fidl::encoding::ResultType<
31250 BaseSocketGetSendBufferResponse,
31251 fidl_fuchsia_posix::Errno,
31252 >>(
31253 result.map(|value_bytes| (value_bytes,)),
31254 self.tx_id,
31255 0x78a52fd9c7b2410b,
31256 fidl::encoding::DynamicFlags::empty(),
31257 )
31258 }
31259}
31260
31261#[must_use = "FIDL methods require a response to be sent"]
31262#[derive(Debug)]
31263pub struct BaseSocketSetReceiveBufferResponder {
31264 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31265 tx_id: u32,
31266}
31267
31268impl std::ops::Drop for BaseSocketSetReceiveBufferResponder {
31272 fn drop(&mut self) {
31273 self.control_handle.shutdown();
31274 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31276 }
31277}
31278
31279impl fidl::endpoints::Responder for BaseSocketSetReceiveBufferResponder {
31280 type ControlHandle = BaseSocketControlHandle;
31281
31282 fn control_handle(&self) -> &BaseSocketControlHandle {
31283 &self.control_handle
31284 }
31285
31286 fn drop_without_shutdown(mut self) {
31287 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31289 std::mem::forget(self);
31291 }
31292}
31293
31294impl BaseSocketSetReceiveBufferResponder {
31295 pub fn send(
31299 self,
31300 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31301 ) -> Result<(), fidl::Error> {
31302 let _result = self.send_raw(result);
31303 if _result.is_err() {
31304 self.control_handle.shutdown();
31305 }
31306 self.drop_without_shutdown();
31307 _result
31308 }
31309
31310 pub fn send_no_shutdown_on_err(
31312 self,
31313 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31314 ) -> Result<(), fidl::Error> {
31315 let _result = self.send_raw(result);
31316 self.drop_without_shutdown();
31317 _result
31318 }
31319
31320 fn send_raw(
31321 &self,
31322 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31323 ) -> Result<(), fidl::Error> {
31324 self.control_handle.inner.send::<fidl::encoding::ResultType<
31325 fidl::encoding::EmptyStruct,
31326 fidl_fuchsia_posix::Errno,
31327 >>(
31328 result,
31329 self.tx_id,
31330 0x6b0cf2f1919c7001,
31331 fidl::encoding::DynamicFlags::empty(),
31332 )
31333 }
31334}
31335
31336#[must_use = "FIDL methods require a response to be sent"]
31337#[derive(Debug)]
31338pub struct BaseSocketGetReceiveBufferResponder {
31339 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31340 tx_id: u32,
31341}
31342
31343impl std::ops::Drop for BaseSocketGetReceiveBufferResponder {
31347 fn drop(&mut self) {
31348 self.control_handle.shutdown();
31349 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31351 }
31352}
31353
31354impl fidl::endpoints::Responder for BaseSocketGetReceiveBufferResponder {
31355 type ControlHandle = BaseSocketControlHandle;
31356
31357 fn control_handle(&self) -> &BaseSocketControlHandle {
31358 &self.control_handle
31359 }
31360
31361 fn drop_without_shutdown(mut self) {
31362 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31364 std::mem::forget(self);
31366 }
31367}
31368
31369impl BaseSocketGetReceiveBufferResponder {
31370 pub fn send(
31374 self,
31375 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
31376 ) -> Result<(), fidl::Error> {
31377 let _result = self.send_raw(result);
31378 if _result.is_err() {
31379 self.control_handle.shutdown();
31380 }
31381 self.drop_without_shutdown();
31382 _result
31383 }
31384
31385 pub fn send_no_shutdown_on_err(
31387 self,
31388 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
31389 ) -> Result<(), fidl::Error> {
31390 let _result = self.send_raw(result);
31391 self.drop_without_shutdown();
31392 _result
31393 }
31394
31395 fn send_raw(
31396 &self,
31397 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
31398 ) -> Result<(), fidl::Error> {
31399 self.control_handle.inner.send::<fidl::encoding::ResultType<
31400 BaseSocketGetReceiveBufferResponse,
31401 fidl_fuchsia_posix::Errno,
31402 >>(
31403 result.map(|value_bytes| (value_bytes,)),
31404 self.tx_id,
31405 0x14c1a4b64f709e5c,
31406 fidl::encoding::DynamicFlags::empty(),
31407 )
31408 }
31409}
31410
31411#[must_use = "FIDL methods require a response to be sent"]
31412#[derive(Debug)]
31413pub struct BaseSocketSetKeepAliveResponder {
31414 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31415 tx_id: u32,
31416}
31417
31418impl std::ops::Drop for BaseSocketSetKeepAliveResponder {
31422 fn drop(&mut self) {
31423 self.control_handle.shutdown();
31424 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31426 }
31427}
31428
31429impl fidl::endpoints::Responder for BaseSocketSetKeepAliveResponder {
31430 type ControlHandle = BaseSocketControlHandle;
31431
31432 fn control_handle(&self) -> &BaseSocketControlHandle {
31433 &self.control_handle
31434 }
31435
31436 fn drop_without_shutdown(mut self) {
31437 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31439 std::mem::forget(self);
31441 }
31442}
31443
31444impl BaseSocketSetKeepAliveResponder {
31445 pub fn send(
31449 self,
31450 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31451 ) -> Result<(), fidl::Error> {
31452 let _result = self.send_raw(result);
31453 if _result.is_err() {
31454 self.control_handle.shutdown();
31455 }
31456 self.drop_without_shutdown();
31457 _result
31458 }
31459
31460 pub fn send_no_shutdown_on_err(
31462 self,
31463 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31464 ) -> Result<(), fidl::Error> {
31465 let _result = self.send_raw(result);
31466 self.drop_without_shutdown();
31467 _result
31468 }
31469
31470 fn send_raw(
31471 &self,
31472 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31473 ) -> Result<(), fidl::Error> {
31474 self.control_handle.inner.send::<fidl::encoding::ResultType<
31475 fidl::encoding::EmptyStruct,
31476 fidl_fuchsia_posix::Errno,
31477 >>(
31478 result,
31479 self.tx_id,
31480 0x572df8f0b920d2c7,
31481 fidl::encoding::DynamicFlags::empty(),
31482 )
31483 }
31484}
31485
31486#[must_use = "FIDL methods require a response to be sent"]
31487#[derive(Debug)]
31488pub struct BaseSocketGetKeepAliveResponder {
31489 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31490 tx_id: u32,
31491}
31492
31493impl std::ops::Drop for BaseSocketGetKeepAliveResponder {
31497 fn drop(&mut self) {
31498 self.control_handle.shutdown();
31499 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31501 }
31502}
31503
31504impl fidl::endpoints::Responder for BaseSocketGetKeepAliveResponder {
31505 type ControlHandle = BaseSocketControlHandle;
31506
31507 fn control_handle(&self) -> &BaseSocketControlHandle {
31508 &self.control_handle
31509 }
31510
31511 fn drop_without_shutdown(mut self) {
31512 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31514 std::mem::forget(self);
31516 }
31517}
31518
31519impl BaseSocketGetKeepAliveResponder {
31520 pub fn send(
31524 self,
31525 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31526 ) -> Result<(), fidl::Error> {
31527 let _result = self.send_raw(result);
31528 if _result.is_err() {
31529 self.control_handle.shutdown();
31530 }
31531 self.drop_without_shutdown();
31532 _result
31533 }
31534
31535 pub fn send_no_shutdown_on_err(
31537 self,
31538 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31539 ) -> Result<(), fidl::Error> {
31540 let _result = self.send_raw(result);
31541 self.drop_without_shutdown();
31542 _result
31543 }
31544
31545 fn send_raw(
31546 &self,
31547 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31548 ) -> Result<(), fidl::Error> {
31549 self.control_handle.inner.send::<fidl::encoding::ResultType<
31550 BaseSocketGetKeepAliveResponse,
31551 fidl_fuchsia_posix::Errno,
31552 >>(
31553 result.map(|value| (value,)),
31554 self.tx_id,
31555 0x2dd29d3215f2c9d2,
31556 fidl::encoding::DynamicFlags::empty(),
31557 )
31558 }
31559}
31560
31561#[must_use = "FIDL methods require a response to be sent"]
31562#[derive(Debug)]
31563pub struct BaseSocketSetOutOfBandInlineResponder {
31564 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31565 tx_id: u32,
31566}
31567
31568impl std::ops::Drop for BaseSocketSetOutOfBandInlineResponder {
31572 fn drop(&mut self) {
31573 self.control_handle.shutdown();
31574 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31576 }
31577}
31578
31579impl fidl::endpoints::Responder for BaseSocketSetOutOfBandInlineResponder {
31580 type ControlHandle = BaseSocketControlHandle;
31581
31582 fn control_handle(&self) -> &BaseSocketControlHandle {
31583 &self.control_handle
31584 }
31585
31586 fn drop_without_shutdown(mut self) {
31587 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31589 std::mem::forget(self);
31591 }
31592}
31593
31594impl BaseSocketSetOutOfBandInlineResponder {
31595 pub fn send(
31599 self,
31600 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31601 ) -> Result<(), fidl::Error> {
31602 let _result = self.send_raw(result);
31603 if _result.is_err() {
31604 self.control_handle.shutdown();
31605 }
31606 self.drop_without_shutdown();
31607 _result
31608 }
31609
31610 pub fn send_no_shutdown_on_err(
31612 self,
31613 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31614 ) -> Result<(), fidl::Error> {
31615 let _result = self.send_raw(result);
31616 self.drop_without_shutdown();
31617 _result
31618 }
31619
31620 fn send_raw(
31621 &self,
31622 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31623 ) -> Result<(), fidl::Error> {
31624 self.control_handle.inner.send::<fidl::encoding::ResultType<
31625 fidl::encoding::EmptyStruct,
31626 fidl_fuchsia_posix::Errno,
31627 >>(
31628 result,
31629 self.tx_id,
31630 0x3ecb49968bee439,
31631 fidl::encoding::DynamicFlags::empty(),
31632 )
31633 }
31634}
31635
31636#[must_use = "FIDL methods require a response to be sent"]
31637#[derive(Debug)]
31638pub struct BaseSocketGetOutOfBandInlineResponder {
31639 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31640 tx_id: u32,
31641}
31642
31643impl std::ops::Drop for BaseSocketGetOutOfBandInlineResponder {
31647 fn drop(&mut self) {
31648 self.control_handle.shutdown();
31649 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31651 }
31652}
31653
31654impl fidl::endpoints::Responder for BaseSocketGetOutOfBandInlineResponder {
31655 type ControlHandle = BaseSocketControlHandle;
31656
31657 fn control_handle(&self) -> &BaseSocketControlHandle {
31658 &self.control_handle
31659 }
31660
31661 fn drop_without_shutdown(mut self) {
31662 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31664 std::mem::forget(self);
31666 }
31667}
31668
31669impl BaseSocketGetOutOfBandInlineResponder {
31670 pub fn send(
31674 self,
31675 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31676 ) -> Result<(), fidl::Error> {
31677 let _result = self.send_raw(result);
31678 if _result.is_err() {
31679 self.control_handle.shutdown();
31680 }
31681 self.drop_without_shutdown();
31682 _result
31683 }
31684
31685 pub fn send_no_shutdown_on_err(
31687 self,
31688 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31689 ) -> Result<(), fidl::Error> {
31690 let _result = self.send_raw(result);
31691 self.drop_without_shutdown();
31692 _result
31693 }
31694
31695 fn send_raw(
31696 &self,
31697 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31698 ) -> Result<(), fidl::Error> {
31699 self.control_handle.inner.send::<fidl::encoding::ResultType<
31700 BaseSocketGetOutOfBandInlineResponse,
31701 fidl_fuchsia_posix::Errno,
31702 >>(
31703 result.map(|value| (value,)),
31704 self.tx_id,
31705 0x348c1ab3aeca1745,
31706 fidl::encoding::DynamicFlags::empty(),
31707 )
31708 }
31709}
31710
31711#[must_use = "FIDL methods require a response to be sent"]
31712#[derive(Debug)]
31713pub struct BaseSocketSetNoCheckResponder {
31714 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31715 tx_id: u32,
31716}
31717
31718impl std::ops::Drop for BaseSocketSetNoCheckResponder {
31722 fn drop(&mut self) {
31723 self.control_handle.shutdown();
31724 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31726 }
31727}
31728
31729impl fidl::endpoints::Responder for BaseSocketSetNoCheckResponder {
31730 type ControlHandle = BaseSocketControlHandle;
31731
31732 fn control_handle(&self) -> &BaseSocketControlHandle {
31733 &self.control_handle
31734 }
31735
31736 fn drop_without_shutdown(mut self) {
31737 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31739 std::mem::forget(self);
31741 }
31742}
31743
31744impl BaseSocketSetNoCheckResponder {
31745 pub fn send(
31749 self,
31750 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31751 ) -> Result<(), fidl::Error> {
31752 let _result = self.send_raw(result);
31753 if _result.is_err() {
31754 self.control_handle.shutdown();
31755 }
31756 self.drop_without_shutdown();
31757 _result
31758 }
31759
31760 pub fn send_no_shutdown_on_err(
31762 self,
31763 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31764 ) -> Result<(), fidl::Error> {
31765 let _result = self.send_raw(result);
31766 self.drop_without_shutdown();
31767 _result
31768 }
31769
31770 fn send_raw(
31771 &self,
31772 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31773 ) -> Result<(), fidl::Error> {
31774 self.control_handle.inner.send::<fidl::encoding::ResultType<
31775 fidl::encoding::EmptyStruct,
31776 fidl_fuchsia_posix::Errno,
31777 >>(
31778 result,
31779 self.tx_id,
31780 0x6bbf00c53a4c78c2,
31781 fidl::encoding::DynamicFlags::empty(),
31782 )
31783 }
31784}
31785
31786#[must_use = "FIDL methods require a response to be sent"]
31787#[derive(Debug)]
31788pub struct BaseSocketGetNoCheckResponder {
31789 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31790 tx_id: u32,
31791}
31792
31793impl std::ops::Drop for BaseSocketGetNoCheckResponder {
31797 fn drop(&mut self) {
31798 self.control_handle.shutdown();
31799 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31801 }
31802}
31803
31804impl fidl::endpoints::Responder for BaseSocketGetNoCheckResponder {
31805 type ControlHandle = BaseSocketControlHandle;
31806
31807 fn control_handle(&self) -> &BaseSocketControlHandle {
31808 &self.control_handle
31809 }
31810
31811 fn drop_without_shutdown(mut self) {
31812 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31814 std::mem::forget(self);
31816 }
31817}
31818
31819impl BaseSocketGetNoCheckResponder {
31820 pub fn send(
31824 self,
31825 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31826 ) -> Result<(), fidl::Error> {
31827 let _result = self.send_raw(result);
31828 if _result.is_err() {
31829 self.control_handle.shutdown();
31830 }
31831 self.drop_without_shutdown();
31832 _result
31833 }
31834
31835 pub fn send_no_shutdown_on_err(
31837 self,
31838 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31839 ) -> Result<(), fidl::Error> {
31840 let _result = self.send_raw(result);
31841 self.drop_without_shutdown();
31842 _result
31843 }
31844
31845 fn send_raw(
31846 &self,
31847 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31848 ) -> Result<(), fidl::Error> {
31849 self.control_handle.inner.send::<fidl::encoding::ResultType<
31850 BaseSocketGetNoCheckResponse,
31851 fidl_fuchsia_posix::Errno,
31852 >>(
31853 result.map(|value| (value,)),
31854 self.tx_id,
31855 0x2cd4249286417694,
31856 fidl::encoding::DynamicFlags::empty(),
31857 )
31858 }
31859}
31860
31861#[must_use = "FIDL methods require a response to be sent"]
31862#[derive(Debug)]
31863pub struct BaseSocketSetLingerResponder {
31864 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31865 tx_id: u32,
31866}
31867
31868impl std::ops::Drop for BaseSocketSetLingerResponder {
31872 fn drop(&mut self) {
31873 self.control_handle.shutdown();
31874 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31876 }
31877}
31878
31879impl fidl::endpoints::Responder for BaseSocketSetLingerResponder {
31880 type ControlHandle = BaseSocketControlHandle;
31881
31882 fn control_handle(&self) -> &BaseSocketControlHandle {
31883 &self.control_handle
31884 }
31885
31886 fn drop_without_shutdown(mut self) {
31887 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31889 std::mem::forget(self);
31891 }
31892}
31893
31894impl BaseSocketSetLingerResponder {
31895 pub fn send(
31899 self,
31900 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31901 ) -> Result<(), fidl::Error> {
31902 let _result = self.send_raw(result);
31903 if _result.is_err() {
31904 self.control_handle.shutdown();
31905 }
31906 self.drop_without_shutdown();
31907 _result
31908 }
31909
31910 pub fn send_no_shutdown_on_err(
31912 self,
31913 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31914 ) -> Result<(), fidl::Error> {
31915 let _result = self.send_raw(result);
31916 self.drop_without_shutdown();
31917 _result
31918 }
31919
31920 fn send_raw(
31921 &self,
31922 mut result: Result<(), fidl_fuchsia_posix::Errno>,
31923 ) -> Result<(), fidl::Error> {
31924 self.control_handle.inner.send::<fidl::encoding::ResultType<
31925 fidl::encoding::EmptyStruct,
31926 fidl_fuchsia_posix::Errno,
31927 >>(
31928 result,
31929 self.tx_id,
31930 0x45386351246e998e,
31931 fidl::encoding::DynamicFlags::empty(),
31932 )
31933 }
31934}
31935
31936#[must_use = "FIDL methods require a response to be sent"]
31937#[derive(Debug)]
31938pub struct BaseSocketGetLingerResponder {
31939 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31940 tx_id: u32,
31941}
31942
31943impl std::ops::Drop for BaseSocketGetLingerResponder {
31947 fn drop(&mut self) {
31948 self.control_handle.shutdown();
31949 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31951 }
31952}
31953
31954impl fidl::endpoints::Responder for BaseSocketGetLingerResponder {
31955 type ControlHandle = BaseSocketControlHandle;
31956
31957 fn control_handle(&self) -> &BaseSocketControlHandle {
31958 &self.control_handle
31959 }
31960
31961 fn drop_without_shutdown(mut self) {
31962 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31964 std::mem::forget(self);
31966 }
31967}
31968
31969impl BaseSocketGetLingerResponder {
31970 pub fn send(
31974 self,
31975 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
31976 ) -> Result<(), fidl::Error> {
31977 let _result = self.send_raw(result);
31978 if _result.is_err() {
31979 self.control_handle.shutdown();
31980 }
31981 self.drop_without_shutdown();
31982 _result
31983 }
31984
31985 pub fn send_no_shutdown_on_err(
31987 self,
31988 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
31989 ) -> Result<(), fidl::Error> {
31990 let _result = self.send_raw(result);
31991 self.drop_without_shutdown();
31992 _result
31993 }
31994
31995 fn send_raw(
31996 &self,
31997 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
31998 ) -> Result<(), fidl::Error> {
31999 self.control_handle.inner.send::<fidl::encoding::ResultType<
32000 BaseSocketGetLingerResponse,
32001 fidl_fuchsia_posix::Errno,
32002 >>(
32003 result,
32004 self.tx_id,
32005 0x48eb20fc5ccb0e45,
32006 fidl::encoding::DynamicFlags::empty(),
32007 )
32008 }
32009}
32010
32011#[must_use = "FIDL methods require a response to be sent"]
32012#[derive(Debug)]
32013pub struct BaseSocketSetReusePortResponder {
32014 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32015 tx_id: u32,
32016}
32017
32018impl std::ops::Drop for BaseSocketSetReusePortResponder {
32022 fn drop(&mut self) {
32023 self.control_handle.shutdown();
32024 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32026 }
32027}
32028
32029impl fidl::endpoints::Responder for BaseSocketSetReusePortResponder {
32030 type ControlHandle = BaseSocketControlHandle;
32031
32032 fn control_handle(&self) -> &BaseSocketControlHandle {
32033 &self.control_handle
32034 }
32035
32036 fn drop_without_shutdown(mut self) {
32037 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32039 std::mem::forget(self);
32041 }
32042}
32043
32044impl BaseSocketSetReusePortResponder {
32045 pub fn send(
32049 self,
32050 mut result: Result<(), fidl_fuchsia_posix::Errno>,
32051 ) -> Result<(), fidl::Error> {
32052 let _result = self.send_raw(result);
32053 if _result.is_err() {
32054 self.control_handle.shutdown();
32055 }
32056 self.drop_without_shutdown();
32057 _result
32058 }
32059
32060 pub fn send_no_shutdown_on_err(
32062 self,
32063 mut result: Result<(), fidl_fuchsia_posix::Errno>,
32064 ) -> Result<(), fidl::Error> {
32065 let _result = self.send_raw(result);
32066 self.drop_without_shutdown();
32067 _result
32068 }
32069
32070 fn send_raw(
32071 &self,
32072 mut result: Result<(), fidl_fuchsia_posix::Errno>,
32073 ) -> Result<(), fidl::Error> {
32074 self.control_handle.inner.send::<fidl::encoding::ResultType<
32075 fidl::encoding::EmptyStruct,
32076 fidl_fuchsia_posix::Errno,
32077 >>(
32078 result,
32079 self.tx_id,
32080 0x24dd3e5cb36d9ccb,
32081 fidl::encoding::DynamicFlags::empty(),
32082 )
32083 }
32084}
32085
32086#[must_use = "FIDL methods require a response to be sent"]
32087#[derive(Debug)]
32088pub struct BaseSocketGetReusePortResponder {
32089 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32090 tx_id: u32,
32091}
32092
32093impl std::ops::Drop for BaseSocketGetReusePortResponder {
32097 fn drop(&mut self) {
32098 self.control_handle.shutdown();
32099 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32101 }
32102}
32103
32104impl fidl::endpoints::Responder for BaseSocketGetReusePortResponder {
32105 type ControlHandle = BaseSocketControlHandle;
32106
32107 fn control_handle(&self) -> &BaseSocketControlHandle {
32108 &self.control_handle
32109 }
32110
32111 fn drop_without_shutdown(mut self) {
32112 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32114 std::mem::forget(self);
32116 }
32117}
32118
32119impl BaseSocketGetReusePortResponder {
32120 pub fn send(
32124 self,
32125 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
32126 ) -> Result<(), fidl::Error> {
32127 let _result = self.send_raw(result);
32128 if _result.is_err() {
32129 self.control_handle.shutdown();
32130 }
32131 self.drop_without_shutdown();
32132 _result
32133 }
32134
32135 pub fn send_no_shutdown_on_err(
32137 self,
32138 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
32139 ) -> Result<(), fidl::Error> {
32140 let _result = self.send_raw(result);
32141 self.drop_without_shutdown();
32142 _result
32143 }
32144
32145 fn send_raw(
32146 &self,
32147 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
32148 ) -> Result<(), fidl::Error> {
32149 self.control_handle.inner.send::<fidl::encoding::ResultType<
32150 BaseSocketGetReusePortResponse,
32151 fidl_fuchsia_posix::Errno,
32152 >>(
32153 result.map(|value| (value,)),
32154 self.tx_id,
32155 0x7a112c1ab54ff828,
32156 fidl::encoding::DynamicFlags::empty(),
32157 )
32158 }
32159}
32160
32161#[must_use = "FIDL methods require a response to be sent"]
32162#[derive(Debug)]
32163pub struct BaseSocketGetAcceptConnResponder {
32164 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32165 tx_id: u32,
32166}
32167
32168impl std::ops::Drop for BaseSocketGetAcceptConnResponder {
32172 fn drop(&mut self) {
32173 self.control_handle.shutdown();
32174 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32176 }
32177}
32178
32179impl fidl::endpoints::Responder for BaseSocketGetAcceptConnResponder {
32180 type ControlHandle = BaseSocketControlHandle;
32181
32182 fn control_handle(&self) -> &BaseSocketControlHandle {
32183 &self.control_handle
32184 }
32185
32186 fn drop_without_shutdown(mut self) {
32187 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32189 std::mem::forget(self);
32191 }
32192}
32193
32194impl BaseSocketGetAcceptConnResponder {
32195 pub fn send(
32199 self,
32200 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
32201 ) -> Result<(), fidl::Error> {
32202 let _result = self.send_raw(result);
32203 if _result.is_err() {
32204 self.control_handle.shutdown();
32205 }
32206 self.drop_without_shutdown();
32207 _result
32208 }
32209
32210 pub fn send_no_shutdown_on_err(
32212 self,
32213 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
32214 ) -> Result<(), fidl::Error> {
32215 let _result = self.send_raw(result);
32216 self.drop_without_shutdown();
32217 _result
32218 }
32219
32220 fn send_raw(
32221 &self,
32222 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
32223 ) -> Result<(), fidl::Error> {
32224 self.control_handle.inner.send::<fidl::encoding::ResultType<
32225 BaseSocketGetAcceptConnResponse,
32226 fidl_fuchsia_posix::Errno,
32227 >>(
32228 result.map(|value| (value,)),
32229 self.tx_id,
32230 0x67ce6db6c2ec8966,
32231 fidl::encoding::DynamicFlags::empty(),
32232 )
32233 }
32234}
32235
32236#[must_use = "FIDL methods require a response to be sent"]
32237#[derive(Debug)]
32238pub struct BaseSocketSetBindToDeviceResponder {
32239 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32240 tx_id: u32,
32241}
32242
32243impl std::ops::Drop for BaseSocketSetBindToDeviceResponder {
32247 fn drop(&mut self) {
32248 self.control_handle.shutdown();
32249 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32251 }
32252}
32253
32254impl fidl::endpoints::Responder for BaseSocketSetBindToDeviceResponder {
32255 type ControlHandle = BaseSocketControlHandle;
32256
32257 fn control_handle(&self) -> &BaseSocketControlHandle {
32258 &self.control_handle
32259 }
32260
32261 fn drop_without_shutdown(mut self) {
32262 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32264 std::mem::forget(self);
32266 }
32267}
32268
32269impl BaseSocketSetBindToDeviceResponder {
32270 pub fn send(
32274 self,
32275 mut result: Result<(), fidl_fuchsia_posix::Errno>,
32276 ) -> Result<(), fidl::Error> {
32277 let _result = self.send_raw(result);
32278 if _result.is_err() {
32279 self.control_handle.shutdown();
32280 }
32281 self.drop_without_shutdown();
32282 _result
32283 }
32284
32285 pub fn send_no_shutdown_on_err(
32287 self,
32288 mut result: Result<(), fidl_fuchsia_posix::Errno>,
32289 ) -> Result<(), fidl::Error> {
32290 let _result = self.send_raw(result);
32291 self.drop_without_shutdown();
32292 _result
32293 }
32294
32295 fn send_raw(
32296 &self,
32297 mut result: Result<(), fidl_fuchsia_posix::Errno>,
32298 ) -> Result<(), fidl::Error> {
32299 self.control_handle.inner.send::<fidl::encoding::ResultType<
32300 fidl::encoding::EmptyStruct,
32301 fidl_fuchsia_posix::Errno,
32302 >>(
32303 result,
32304 self.tx_id,
32305 0x2118b483f28aafc4,
32306 fidl::encoding::DynamicFlags::empty(),
32307 )
32308 }
32309}
32310
32311#[must_use = "FIDL methods require a response to be sent"]
32312#[derive(Debug)]
32313pub struct BaseSocketGetBindToDeviceResponder {
32314 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32315 tx_id: u32,
32316}
32317
32318impl std::ops::Drop for BaseSocketGetBindToDeviceResponder {
32322 fn drop(&mut self) {
32323 self.control_handle.shutdown();
32324 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32326 }
32327}
32328
32329impl fidl::endpoints::Responder for BaseSocketGetBindToDeviceResponder {
32330 type ControlHandle = BaseSocketControlHandle;
32331
32332 fn control_handle(&self) -> &BaseSocketControlHandle {
32333 &self.control_handle
32334 }
32335
32336 fn drop_without_shutdown(mut self) {
32337 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32339 std::mem::forget(self);
32341 }
32342}
32343
32344impl BaseSocketGetBindToDeviceResponder {
32345 pub fn send(
32349 self,
32350 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
32351 ) -> Result<(), fidl::Error> {
32352 let _result = self.send_raw(result);
32353 if _result.is_err() {
32354 self.control_handle.shutdown();
32355 }
32356 self.drop_without_shutdown();
32357 _result
32358 }
32359
32360 pub fn send_no_shutdown_on_err(
32362 self,
32363 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
32364 ) -> Result<(), fidl::Error> {
32365 let _result = self.send_raw(result);
32366 self.drop_without_shutdown();
32367 _result
32368 }
32369
32370 fn send_raw(
32371 &self,
32372 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
32373 ) -> Result<(), fidl::Error> {
32374 self.control_handle.inner.send::<fidl::encoding::ResultType<
32375 BaseSocketGetBindToDeviceResponse,
32376 fidl_fuchsia_posix::Errno,
32377 >>(
32378 result.map(|value| (value,)),
32379 self.tx_id,
32380 0x1ab1fbf0ef7906c8,
32381 fidl::encoding::DynamicFlags::empty(),
32382 )
32383 }
32384}
32385
32386#[must_use = "FIDL methods require a response to be sent"]
32387#[derive(Debug)]
32388pub struct BaseSocketSetBindToInterfaceIndexResponder {
32389 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32390 tx_id: u32,
32391}
32392
32393impl std::ops::Drop for BaseSocketSetBindToInterfaceIndexResponder {
32397 fn drop(&mut self) {
32398 self.control_handle.shutdown();
32399 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32401 }
32402}
32403
32404impl fidl::endpoints::Responder for BaseSocketSetBindToInterfaceIndexResponder {
32405 type ControlHandle = BaseSocketControlHandle;
32406
32407 fn control_handle(&self) -> &BaseSocketControlHandle {
32408 &self.control_handle
32409 }
32410
32411 fn drop_without_shutdown(mut self) {
32412 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32414 std::mem::forget(self);
32416 }
32417}
32418
32419impl BaseSocketSetBindToInterfaceIndexResponder {
32420 pub fn send(
32424 self,
32425 mut result: Result<(), fidl_fuchsia_posix::Errno>,
32426 ) -> Result<(), fidl::Error> {
32427 let _result = self.send_raw(result);
32428 if _result.is_err() {
32429 self.control_handle.shutdown();
32430 }
32431 self.drop_without_shutdown();
32432 _result
32433 }
32434
32435 pub fn send_no_shutdown_on_err(
32437 self,
32438 mut result: Result<(), fidl_fuchsia_posix::Errno>,
32439 ) -> Result<(), fidl::Error> {
32440 let _result = self.send_raw(result);
32441 self.drop_without_shutdown();
32442 _result
32443 }
32444
32445 fn send_raw(
32446 &self,
32447 mut result: Result<(), fidl_fuchsia_posix::Errno>,
32448 ) -> Result<(), fidl::Error> {
32449 self.control_handle.inner.send::<fidl::encoding::ResultType<
32450 fidl::encoding::EmptyStruct,
32451 fidl_fuchsia_posix::Errno,
32452 >>(
32453 result,
32454 self.tx_id,
32455 0x6e387a0def00821,
32456 fidl::encoding::DynamicFlags::empty(),
32457 )
32458 }
32459}
32460
32461#[must_use = "FIDL methods require a response to be sent"]
32462#[derive(Debug)]
32463pub struct BaseSocketGetBindToInterfaceIndexResponder {
32464 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32465 tx_id: u32,
32466}
32467
32468impl std::ops::Drop for BaseSocketGetBindToInterfaceIndexResponder {
32472 fn drop(&mut self) {
32473 self.control_handle.shutdown();
32474 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32476 }
32477}
32478
32479impl fidl::endpoints::Responder for BaseSocketGetBindToInterfaceIndexResponder {
32480 type ControlHandle = BaseSocketControlHandle;
32481
32482 fn control_handle(&self) -> &BaseSocketControlHandle {
32483 &self.control_handle
32484 }
32485
32486 fn drop_without_shutdown(mut self) {
32487 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32489 std::mem::forget(self);
32491 }
32492}
32493
32494impl BaseSocketGetBindToInterfaceIndexResponder {
32495 pub fn send(
32499 self,
32500 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
32501 ) -> Result<(), fidl::Error> {
32502 let _result = self.send_raw(result);
32503 if _result.is_err() {
32504 self.control_handle.shutdown();
32505 }
32506 self.drop_without_shutdown();
32507 _result
32508 }
32509
32510 pub fn send_no_shutdown_on_err(
32512 self,
32513 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
32514 ) -> Result<(), fidl::Error> {
32515 let _result = self.send_raw(result);
32516 self.drop_without_shutdown();
32517 _result
32518 }
32519
32520 fn send_raw(
32521 &self,
32522 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
32523 ) -> Result<(), fidl::Error> {
32524 self.control_handle.inner.send::<fidl::encoding::ResultType<
32525 BaseSocketGetBindToInterfaceIndexResponse,
32526 fidl_fuchsia_posix::Errno,
32527 >>(
32528 result.map(|value| (value,)),
32529 self.tx_id,
32530 0x59c31dd3e3078295,
32531 fidl::encoding::DynamicFlags::empty(),
32532 )
32533 }
32534}
32535
32536#[must_use = "FIDL methods require a response to be sent"]
32537#[derive(Debug)]
32538pub struct BaseSocketSetTimestampResponder {
32539 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32540 tx_id: u32,
32541}
32542
32543impl std::ops::Drop for BaseSocketSetTimestampResponder {
32547 fn drop(&mut self) {
32548 self.control_handle.shutdown();
32549 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32551 }
32552}
32553
32554impl fidl::endpoints::Responder for BaseSocketSetTimestampResponder {
32555 type ControlHandle = BaseSocketControlHandle;
32556
32557 fn control_handle(&self) -> &BaseSocketControlHandle {
32558 &self.control_handle
32559 }
32560
32561 fn drop_without_shutdown(mut self) {
32562 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32564 std::mem::forget(self);
32566 }
32567}
32568
32569impl BaseSocketSetTimestampResponder {
32570 pub fn send(
32574 self,
32575 mut result: Result<(), fidl_fuchsia_posix::Errno>,
32576 ) -> Result<(), fidl::Error> {
32577 let _result = self.send_raw(result);
32578 if _result.is_err() {
32579 self.control_handle.shutdown();
32580 }
32581 self.drop_without_shutdown();
32582 _result
32583 }
32584
32585 pub fn send_no_shutdown_on_err(
32587 self,
32588 mut result: Result<(), fidl_fuchsia_posix::Errno>,
32589 ) -> Result<(), fidl::Error> {
32590 let _result = self.send_raw(result);
32591 self.drop_without_shutdown();
32592 _result
32593 }
32594
32595 fn send_raw(
32596 &self,
32597 mut result: Result<(), fidl_fuchsia_posix::Errno>,
32598 ) -> Result<(), fidl::Error> {
32599 self.control_handle.inner.send::<fidl::encoding::ResultType<
32600 fidl::encoding::EmptyStruct,
32601 fidl_fuchsia_posix::Errno,
32602 >>(
32603 result,
32604 self.tx_id,
32605 0x285d6516c263d839,
32606 fidl::encoding::DynamicFlags::empty(),
32607 )
32608 }
32609}
32610
32611#[must_use = "FIDL methods require a response to be sent"]
32612#[derive(Debug)]
32613pub struct BaseSocketGetTimestampResponder {
32614 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32615 tx_id: u32,
32616}
32617
32618impl std::ops::Drop for BaseSocketGetTimestampResponder {
32622 fn drop(&mut self) {
32623 self.control_handle.shutdown();
32624 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32626 }
32627}
32628
32629impl fidl::endpoints::Responder for BaseSocketGetTimestampResponder {
32630 type ControlHandle = BaseSocketControlHandle;
32631
32632 fn control_handle(&self) -> &BaseSocketControlHandle {
32633 &self.control_handle
32634 }
32635
32636 fn drop_without_shutdown(mut self) {
32637 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32639 std::mem::forget(self);
32641 }
32642}
32643
32644impl BaseSocketGetTimestampResponder {
32645 pub fn send(
32649 self,
32650 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
32651 ) -> Result<(), fidl::Error> {
32652 let _result = self.send_raw(result);
32653 if _result.is_err() {
32654 self.control_handle.shutdown();
32655 }
32656 self.drop_without_shutdown();
32657 _result
32658 }
32659
32660 pub fn send_no_shutdown_on_err(
32662 self,
32663 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
32664 ) -> Result<(), fidl::Error> {
32665 let _result = self.send_raw(result);
32666 self.drop_without_shutdown();
32667 _result
32668 }
32669
32670 fn send_raw(
32671 &self,
32672 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
32673 ) -> Result<(), fidl::Error> {
32674 self.control_handle.inner.send::<fidl::encoding::ResultType<
32675 BaseSocketGetTimestampResponse,
32676 fidl_fuchsia_posix::Errno,
32677 >>(
32678 result.map(|value| (value,)),
32679 self.tx_id,
32680 0x49f2fffbbcc2bd27,
32681 fidl::encoding::DynamicFlags::empty(),
32682 )
32683 }
32684}
32685
32686#[must_use = "FIDL methods require a response to be sent"]
32687#[derive(Debug)]
32688pub struct BaseSocketSetMarkResponder {
32689 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32690 tx_id: u32,
32691}
32692
32693impl std::ops::Drop for BaseSocketSetMarkResponder {
32697 fn drop(&mut self) {
32698 self.control_handle.shutdown();
32699 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32701 }
32702}
32703
32704impl fidl::endpoints::Responder for BaseSocketSetMarkResponder {
32705 type ControlHandle = BaseSocketControlHandle;
32706
32707 fn control_handle(&self) -> &BaseSocketControlHandle {
32708 &self.control_handle
32709 }
32710
32711 fn drop_without_shutdown(mut self) {
32712 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32714 std::mem::forget(self);
32716 }
32717}
32718
32719impl BaseSocketSetMarkResponder {
32720 pub fn send(
32724 self,
32725 mut result: Result<(), fidl_fuchsia_posix::Errno>,
32726 ) -> Result<(), fidl::Error> {
32727 let _result = self.send_raw(result);
32728 if _result.is_err() {
32729 self.control_handle.shutdown();
32730 }
32731 self.drop_without_shutdown();
32732 _result
32733 }
32734
32735 pub fn send_no_shutdown_on_err(
32737 self,
32738 mut result: Result<(), fidl_fuchsia_posix::Errno>,
32739 ) -> Result<(), fidl::Error> {
32740 let _result = self.send_raw(result);
32741 self.drop_without_shutdown();
32742 _result
32743 }
32744
32745 fn send_raw(
32746 &self,
32747 mut result: Result<(), fidl_fuchsia_posix::Errno>,
32748 ) -> Result<(), fidl::Error> {
32749 self.control_handle.inner.send::<fidl::encoding::ResultType<
32750 fidl::encoding::EmptyStruct,
32751 fidl_fuchsia_posix::Errno,
32752 >>(
32753 result,
32754 self.tx_id,
32755 0x6ead6de09f653236,
32756 fidl::encoding::DynamicFlags::empty(),
32757 )
32758 }
32759}
32760
32761#[must_use = "FIDL methods require a response to be sent"]
32762#[derive(Debug)]
32763pub struct BaseSocketGetMarkResponder {
32764 control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32765 tx_id: u32,
32766}
32767
32768impl std::ops::Drop for BaseSocketGetMarkResponder {
32772 fn drop(&mut self) {
32773 self.control_handle.shutdown();
32774 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32776 }
32777}
32778
32779impl fidl::endpoints::Responder for BaseSocketGetMarkResponder {
32780 type ControlHandle = BaseSocketControlHandle;
32781
32782 fn control_handle(&self) -> &BaseSocketControlHandle {
32783 &self.control_handle
32784 }
32785
32786 fn drop_without_shutdown(mut self) {
32787 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32789 std::mem::forget(self);
32791 }
32792}
32793
32794impl BaseSocketGetMarkResponder {
32795 pub fn send(
32799 self,
32800 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
32801 ) -> Result<(), fidl::Error> {
32802 let _result = self.send_raw(result);
32803 if _result.is_err() {
32804 self.control_handle.shutdown();
32805 }
32806 self.drop_without_shutdown();
32807 _result
32808 }
32809
32810 pub fn send_no_shutdown_on_err(
32812 self,
32813 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
32814 ) -> Result<(), fidl::Error> {
32815 let _result = self.send_raw(result);
32816 self.drop_without_shutdown();
32817 _result
32818 }
32819
32820 fn send_raw(
32821 &self,
32822 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
32823 ) -> Result<(), fidl::Error> {
32824 self.control_handle.inner.send::<fidl::encoding::ResultType<
32825 BaseSocketGetMarkResponse,
32826 fidl_fuchsia_posix::Errno,
32827 >>(
32828 result.map(|mark| (mark,)),
32829 self.tx_id,
32830 0x57a2752c61d93d47,
32831 fidl::encoding::DynamicFlags::empty(),
32832 )
32833 }
32834}
32835
32836#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
32837pub struct DatagramSocketMarker;
32838
32839impl fidl::endpoints::ProtocolMarker for DatagramSocketMarker {
32840 type Proxy = DatagramSocketProxy;
32841 type RequestStream = DatagramSocketRequestStream;
32842 #[cfg(target_os = "fuchsia")]
32843 type SynchronousProxy = DatagramSocketSynchronousProxy;
32844
32845 const DEBUG_NAME: &'static str = "fuchsia.posix.socket.DatagramSocket";
32846}
32847impl fidl::endpoints::DiscoverableProtocolMarker for DatagramSocketMarker {}
32848pub type DatagramSocketSendMsgPreflightResult =
32849 Result<DatagramSocketSendMsgPreflightResponse, fidl_fuchsia_posix::Errno>;
32850pub type DatagramSocketRecvMsgPostflightResult =
32851 Result<DatagramSocketRecvMsgPostflightResponse, fidl_fuchsia_posix::Errno>;
32852
32853pub trait DatagramSocketProxyInterface: Send + Sync {
32854 fn r#clone(
32855 &self,
32856 request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
32857 ) -> Result<(), fidl::Error>;
32858 type CloseResponseFut: std::future::Future<
32859 Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
32860 > + Send;
32861 fn r#close(&self) -> Self::CloseResponseFut;
32862 type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
32863 fn r#query(&self) -> Self::QueryResponseFut;
32864 type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
32865 + Send;
32866 fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
32867 type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
32868 + Send;
32869 fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
32870 type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
32871 + Send;
32872 fn r#get_error(&self) -> Self::GetErrorResponseFut;
32873 type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
32874 + Send;
32875 fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
32876 type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
32877 + Send;
32878 fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
32879 type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
32880 + Send;
32881 fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
32882 type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
32883 + Send;
32884 fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
32885 type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
32886 + Send;
32887 fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
32888 type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
32889 + Send;
32890 fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
32891 type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
32892 + Send;
32893 fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
32894 type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
32895 + Send;
32896 fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
32897 type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
32898 + Send;
32899 fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
32900 type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
32901 + Send;
32902 fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
32903 type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
32904 + Send;
32905 fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
32906 type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
32907 + Send;
32908 fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
32909 type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
32910 + Send;
32911 fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
32912 type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
32913 + Send;
32914 fn r#get_linger(&self) -> Self::GetLingerResponseFut;
32915 type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
32916 + Send;
32917 fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
32918 type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
32919 + Send;
32920 fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
32921 type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
32922 + Send;
32923 fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
32924 type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
32925 + Send;
32926 fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
32927 type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
32928 + Send;
32929 fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
32930 type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
32931 + Send;
32932 fn r#set_bind_to_interface_index(&self, value: u64)
32933 -> Self::SetBindToInterfaceIndexResponseFut;
32934 type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
32935 + Send;
32936 fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
32937 type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
32938 + Send;
32939 fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
32940 type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
32941 + Send;
32942 fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
32943 type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
32944 + Send;
32945 fn r#set_mark(
32946 &self,
32947 domain: fidl_fuchsia_net::MarkDomain,
32948 mark: &OptionalUint32,
32949 ) -> Self::SetMarkResponseFut;
32950 type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
32951 + Send;
32952 fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
32953 type BindResponseFut: std::future::Future<Output = Result<BaseNetworkSocketBindResult, fidl::Error>>
32954 + Send;
32955 fn r#bind(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut;
32956 type ConnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketConnectResult, fidl::Error>>
32957 + Send;
32958 fn r#connect(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut;
32959 type DisconnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDisconnectResult, fidl::Error>>
32960 + Send;
32961 fn r#disconnect(&self) -> Self::DisconnectResponseFut;
32962 type GetSockNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetSockNameResult, fidl::Error>>
32963 + Send;
32964 fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
32965 type GetPeerNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetPeerNameResult, fidl::Error>>
32966 + Send;
32967 fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
32968 type ShutdownResponseFut: std::future::Future<Output = Result<BaseNetworkSocketShutdownResult, fidl::Error>>
32969 + Send;
32970 fn r#shutdown(&self, mode: ShutdownMode) -> Self::ShutdownResponseFut;
32971 type SetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>>
32972 + Send;
32973 fn r#set_ip_type_of_service(&self, value: u8) -> Self::SetIpTypeOfServiceResponseFut;
32974 type GetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>>
32975 + Send;
32976 fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut;
32977 type SetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTtlResult, fidl::Error>>
32978 + Send;
32979 fn r#set_ip_ttl(&self, value: &OptionalUint8) -> Self::SetIpTtlResponseFut;
32980 type GetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTtlResult, fidl::Error>>
32981 + Send;
32982 fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut;
32983 type SetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>>
32984 + Send;
32985 fn r#set_ip_packet_info(&self, value: bool) -> Self::SetIpPacketInfoResponseFut;
32986 type GetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>>
32987 + Send;
32988 fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut;
32989 type SetIpReceiveTypeOfServiceResponseFut: std::future::Future<
32990 Output = Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error>,
32991 > + Send;
32992 fn r#set_ip_receive_type_of_service(
32993 &self,
32994 value: bool,
32995 ) -> Self::SetIpReceiveTypeOfServiceResponseFut;
32996 type GetIpReceiveTypeOfServiceResponseFut: std::future::Future<
32997 Output = Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error>,
32998 > + Send;
32999 fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut;
33000 type SetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>>
33001 + Send;
33002 fn r#set_ip_receive_ttl(&self, value: bool) -> Self::SetIpReceiveTtlResponseFut;
33003 type GetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>>
33004 + Send;
33005 fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut;
33006 type SetIpMulticastInterfaceResponseFut: std::future::Future<
33007 Output = Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error>,
33008 > + Send;
33009 fn r#set_ip_multicast_interface(
33010 &self,
33011 iface: u64,
33012 address: &fidl_fuchsia_net::Ipv4Address,
33013 ) -> Self::SetIpMulticastInterfaceResponseFut;
33014 type GetIpMulticastInterfaceResponseFut: std::future::Future<
33015 Output = Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error>,
33016 > + Send;
33017 fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut;
33018 type SetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>>
33019 + Send;
33020 fn r#set_ip_multicast_ttl(&self, value: &OptionalUint8) -> Self::SetIpMulticastTtlResponseFut;
33021 type GetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>>
33022 + Send;
33023 fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut;
33024 type SetIpMulticastLoopbackResponseFut: std::future::Future<
33025 Output = Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error>,
33026 > + Send;
33027 fn r#set_ip_multicast_loopback(&self, value: bool) -> Self::SetIpMulticastLoopbackResponseFut;
33028 type GetIpMulticastLoopbackResponseFut: std::future::Future<
33029 Output = Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error>,
33030 > + Send;
33031 fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut;
33032 type AddIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error>>
33033 + Send;
33034 fn r#add_ip_membership(
33035 &self,
33036 membership: &IpMulticastMembership,
33037 ) -> Self::AddIpMembershipResponseFut;
33038 type DropIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error>>
33039 + Send;
33040 fn r#drop_ip_membership(
33041 &self,
33042 membership: &IpMulticastMembership,
33043 ) -> Self::DropIpMembershipResponseFut;
33044 type SetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error>>
33045 + Send;
33046 fn r#set_ip_transparent(&self, value: bool) -> Self::SetIpTransparentResponseFut;
33047 type GetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error>>
33048 + Send;
33049 fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut;
33050 type SetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
33051 Output = Result<
33052 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
33053 fidl::Error,
33054 >,
33055 > + Send;
33056 fn r#set_ip_receive_original_destination_address(
33057 &self,
33058 value: bool,
33059 ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut;
33060 type GetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
33061 Output = Result<
33062 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
33063 fidl::Error,
33064 >,
33065 > + Send;
33066 fn r#get_ip_receive_original_destination_address(
33067 &self,
33068 ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut;
33069 type AddIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>>
33070 + Send;
33071 fn r#add_ipv6_membership(
33072 &self,
33073 membership: &Ipv6MulticastMembership,
33074 ) -> Self::AddIpv6MembershipResponseFut;
33075 type DropIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>>
33076 + Send;
33077 fn r#drop_ipv6_membership(
33078 &self,
33079 membership: &Ipv6MulticastMembership,
33080 ) -> Self::DropIpv6MembershipResponseFut;
33081 type SetIpv6MulticastInterfaceResponseFut: std::future::Future<
33082 Output = Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error>,
33083 > + Send;
33084 fn r#set_ipv6_multicast_interface(
33085 &self,
33086 value: u64,
33087 ) -> Self::SetIpv6MulticastInterfaceResponseFut;
33088 type GetIpv6MulticastInterfaceResponseFut: std::future::Future<
33089 Output = Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error>,
33090 > + Send;
33091 fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut;
33092 type SetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>>
33093 + Send;
33094 fn r#set_ipv6_unicast_hops(&self, value: &OptionalUint8)
33095 -> Self::SetIpv6UnicastHopsResponseFut;
33096 type GetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>>
33097 + Send;
33098 fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut;
33099 type SetIpv6ReceiveHopLimitResponseFut: std::future::Future<
33100 Output = Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error>,
33101 > + Send;
33102 fn r#set_ipv6_receive_hop_limit(&self, value: bool) -> Self::SetIpv6ReceiveHopLimitResponseFut;
33103 type GetIpv6ReceiveHopLimitResponseFut: std::future::Future<
33104 Output = Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error>,
33105 > + Send;
33106 fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut;
33107 type SetIpv6MulticastHopsResponseFut: std::future::Future<
33108 Output = Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error>,
33109 > + Send;
33110 fn r#set_ipv6_multicast_hops(
33111 &self,
33112 value: &OptionalUint8,
33113 ) -> Self::SetIpv6MulticastHopsResponseFut;
33114 type GetIpv6MulticastHopsResponseFut: std::future::Future<
33115 Output = Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error>,
33116 > + Send;
33117 fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut;
33118 type SetIpv6MulticastLoopbackResponseFut: std::future::Future<
33119 Output = Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error>,
33120 > + Send;
33121 fn r#set_ipv6_multicast_loopback(
33122 &self,
33123 value: bool,
33124 ) -> Self::SetIpv6MulticastLoopbackResponseFut;
33125 type GetIpv6MulticastLoopbackResponseFut: std::future::Future<
33126 Output = Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error>,
33127 > + Send;
33128 fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut;
33129 type SetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error>>
33130 + Send;
33131 fn r#set_ipv6_only(&self, value: bool) -> Self::SetIpv6OnlyResponseFut;
33132 type GetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error>>
33133 + Send;
33134 fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut;
33135 type SetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
33136 Output = Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error>,
33137 > + Send;
33138 fn r#set_ipv6_receive_traffic_class(
33139 &self,
33140 value: bool,
33141 ) -> Self::SetIpv6ReceiveTrafficClassResponseFut;
33142 type GetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
33143 Output = Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error>,
33144 > + Send;
33145 fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut;
33146 type SetIpv6TrafficClassResponseFut: std::future::Future<
33147 Output = Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error>,
33148 > + Send;
33149 fn r#set_ipv6_traffic_class(
33150 &self,
33151 value: &OptionalUint8,
33152 ) -> Self::SetIpv6TrafficClassResponseFut;
33153 type GetIpv6TrafficClassResponseFut: std::future::Future<
33154 Output = Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error>,
33155 > + Send;
33156 fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut;
33157 type SetIpv6ReceivePacketInfoResponseFut: std::future::Future<
33158 Output = Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error>,
33159 > + Send;
33160 fn r#set_ipv6_receive_packet_info(
33161 &self,
33162 value: bool,
33163 ) -> Self::SetIpv6ReceivePacketInfoResponseFut;
33164 type GetIpv6ReceivePacketInfoResponseFut: std::future::Future<
33165 Output = Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error>,
33166 > + Send;
33167 fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut;
33168 type GetOriginalDestinationResponseFut: std::future::Future<
33169 Output = Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error>,
33170 > + Send;
33171 fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut;
33172 type GetInfoResponseFut: std::future::Future<Output = Result<BaseDatagramSocketGetInfoResult, fidl::Error>>
33173 + Send;
33174 fn r#get_info(&self) -> Self::GetInfoResponseFut;
33175 type DescribeResponseFut: std::future::Future<Output = Result<DatagramSocketDescribeResponse, fidl::Error>>
33176 + Send;
33177 fn r#describe(&self) -> Self::DescribeResponseFut;
33178 type SendMsgPreflightResponseFut: std::future::Future<Output = Result<DatagramSocketSendMsgPreflightResult, fidl::Error>>
33179 + Send;
33180 fn r#send_msg_preflight(
33181 &self,
33182 payload: &DatagramSocketSendMsgPreflightRequest,
33183 ) -> Self::SendMsgPreflightResponseFut;
33184 type RecvMsgPostflightResponseFut: std::future::Future<Output = Result<DatagramSocketRecvMsgPostflightResult, fidl::Error>>
33185 + Send;
33186 fn r#recv_msg_postflight(&self) -> Self::RecvMsgPostflightResponseFut;
33187}
33188#[derive(Debug)]
33189#[cfg(target_os = "fuchsia")]
33190pub struct DatagramSocketSynchronousProxy {
33191 client: fidl::client::sync::Client,
33192}
33193
33194#[cfg(target_os = "fuchsia")]
33195impl fidl::endpoints::SynchronousProxy for DatagramSocketSynchronousProxy {
33196 type Proxy = DatagramSocketProxy;
33197 type Protocol = DatagramSocketMarker;
33198
33199 fn from_channel(inner: fidl::Channel) -> Self {
33200 Self::new(inner)
33201 }
33202
33203 fn into_channel(self) -> fidl::Channel {
33204 self.client.into_channel()
33205 }
33206
33207 fn as_channel(&self) -> &fidl::Channel {
33208 self.client.as_channel()
33209 }
33210}
33211
33212#[cfg(target_os = "fuchsia")]
33213impl DatagramSocketSynchronousProxy {
33214 pub fn new(channel: fidl::Channel) -> Self {
33215 let protocol_name = <DatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
33216 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
33217 }
33218
33219 pub fn into_channel(self) -> fidl::Channel {
33220 self.client.into_channel()
33221 }
33222
33223 pub fn wait_for_event(
33226 &self,
33227 deadline: zx::MonotonicInstant,
33228 ) -> Result<DatagramSocketEvent, fidl::Error> {
33229 DatagramSocketEvent::decode(self.client.wait_for_event(deadline)?)
33230 }
33231
33232 pub fn r#clone(
33233 &self,
33234 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
33235 ) -> Result<(), fidl::Error> {
33236 self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
33237 (request,),
33238 0x20d8a7aba2168a79,
33239 fidl::encoding::DynamicFlags::empty(),
33240 )
33241 }
33242
33243 pub fn r#close(
33254 &self,
33255 ___deadline: zx::MonotonicInstant,
33256 ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
33257 let _response = self.client.send_query::<
33258 fidl::encoding::EmptyPayload,
33259 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
33260 >(
33261 (),
33262 0x5ac5d459ad7f657e,
33263 fidl::encoding::DynamicFlags::empty(),
33264 ___deadline,
33265 )?;
33266 Ok(_response.map(|x| x))
33267 }
33268
33269 pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
33270 let _response = self.client.send_query::<
33271 fidl::encoding::EmptyPayload,
33272 fidl_fuchsia_unknown::QueryableQueryResponse,
33273 >(
33274 (),
33275 0x2658edee9decfc06,
33276 fidl::encoding::DynamicFlags::empty(),
33277 ___deadline,
33278 )?;
33279 Ok(_response.protocol)
33280 }
33281
33282 pub fn r#set_reuse_address(
33284 &self,
33285 mut value: bool,
33286 ___deadline: zx::MonotonicInstant,
33287 ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
33288 let _response =
33289 self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
33290 fidl::encoding::EmptyStruct,
33291 fidl_fuchsia_posix::Errno,
33292 >>(
33293 (value,),
33294 0x1fd74ee8b9a4a876,
33295 fidl::encoding::DynamicFlags::empty(),
33296 ___deadline,
33297 )?;
33298 Ok(_response.map(|x| x))
33299 }
33300
33301 pub fn r#get_reuse_address(
33303 &self,
33304 ___deadline: zx::MonotonicInstant,
33305 ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
33306 let _response = self
33307 .client
33308 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33309 BaseSocketGetReuseAddressResponse,
33310 fidl_fuchsia_posix::Errno,
33311 >>(
33312 (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
33313 )?;
33314 Ok(_response.map(|x| x.value))
33315 }
33316
33317 pub fn r#get_error(
33320 &self,
33321 ___deadline: zx::MonotonicInstant,
33322 ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
33323 let _response =
33324 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33325 fidl::encoding::EmptyStruct,
33326 fidl_fuchsia_posix::Errno,
33327 >>(
33328 (),
33329 0x5aad39b33e5f6ebb,
33330 fidl::encoding::DynamicFlags::empty(),
33331 ___deadline,
33332 )?;
33333 Ok(_response.map(|x| x))
33334 }
33335
33336 pub fn r#set_broadcast(
33338 &self,
33339 mut value: bool,
33340 ___deadline: zx::MonotonicInstant,
33341 ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
33342 let _response =
33343 self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
33344 fidl::encoding::EmptyStruct,
33345 fidl_fuchsia_posix::Errno,
33346 >>(
33347 (value,),
33348 0x6023e081ce3cd947,
33349 fidl::encoding::DynamicFlags::empty(),
33350 ___deadline,
33351 )?;
33352 Ok(_response.map(|x| x))
33353 }
33354
33355 pub fn r#get_broadcast(
33357 &self,
33358 ___deadline: zx::MonotonicInstant,
33359 ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
33360 let _response =
33361 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33362 BaseSocketGetBroadcastResponse,
33363 fidl_fuchsia_posix::Errno,
33364 >>(
33365 (),
33366 0x68796fc556f9780d,
33367 fidl::encoding::DynamicFlags::empty(),
33368 ___deadline,
33369 )?;
33370 Ok(_response.map(|x| x.value))
33371 }
33372
33373 pub fn r#set_send_buffer(
33375 &self,
33376 mut value_bytes: u64,
33377 ___deadline: zx::MonotonicInstant,
33378 ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
33379 let _response =
33380 self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
33381 fidl::encoding::EmptyStruct,
33382 fidl_fuchsia_posix::Errno,
33383 >>(
33384 (value_bytes,),
33385 0x756eac32d73a7a70,
33386 fidl::encoding::DynamicFlags::empty(),
33387 ___deadline,
33388 )?;
33389 Ok(_response.map(|x| x))
33390 }
33391
33392 pub fn r#get_send_buffer(
33394 &self,
33395 ___deadline: zx::MonotonicInstant,
33396 ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
33397 let _response = self
33398 .client
33399 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33400 BaseSocketGetSendBufferResponse,
33401 fidl_fuchsia_posix::Errno,
33402 >>(
33403 (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
33404 )?;
33405 Ok(_response.map(|x| x.value_bytes))
33406 }
33407
33408 pub fn r#set_receive_buffer(
33410 &self,
33411 mut value_bytes: u64,
33412 ___deadline: zx::MonotonicInstant,
33413 ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
33414 let _response =
33415 self.client
33416 .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
33417 fidl::encoding::EmptyStruct,
33418 fidl_fuchsia_posix::Errno,
33419 >>(
33420 (value_bytes,),
33421 0x6b0cf2f1919c7001,
33422 fidl::encoding::DynamicFlags::empty(),
33423 ___deadline,
33424 )?;
33425 Ok(_response.map(|x| x))
33426 }
33427
33428 pub fn r#get_receive_buffer(
33430 &self,
33431 ___deadline: zx::MonotonicInstant,
33432 ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
33433 let _response = self
33434 .client
33435 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33436 BaseSocketGetReceiveBufferResponse,
33437 fidl_fuchsia_posix::Errno,
33438 >>(
33439 (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
33440 )?;
33441 Ok(_response.map(|x| x.value_bytes))
33442 }
33443
33444 pub fn r#set_keep_alive(
33446 &self,
33447 mut value: bool,
33448 ___deadline: zx::MonotonicInstant,
33449 ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
33450 let _response =
33451 self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
33452 fidl::encoding::EmptyStruct,
33453 fidl_fuchsia_posix::Errno,
33454 >>(
33455 (value,),
33456 0x572df8f0b920d2c7,
33457 fidl::encoding::DynamicFlags::empty(),
33458 ___deadline,
33459 )?;
33460 Ok(_response.map(|x| x))
33461 }
33462
33463 pub fn r#get_keep_alive(
33465 &self,
33466 ___deadline: zx::MonotonicInstant,
33467 ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
33468 let _response =
33469 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33470 BaseSocketGetKeepAliveResponse,
33471 fidl_fuchsia_posix::Errno,
33472 >>(
33473 (),
33474 0x2dd29d3215f2c9d2,
33475 fidl::encoding::DynamicFlags::empty(),
33476 ___deadline,
33477 )?;
33478 Ok(_response.map(|x| x.value))
33479 }
33480
33481 pub fn r#set_out_of_band_inline(
33483 &self,
33484 mut value: bool,
33485 ___deadline: zx::MonotonicInstant,
33486 ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
33487 let _response =
33488 self.client
33489 .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
33490 fidl::encoding::EmptyStruct,
33491 fidl_fuchsia_posix::Errno,
33492 >>(
33493 (value,),
33494 0x3ecb49968bee439,
33495 fidl::encoding::DynamicFlags::empty(),
33496 ___deadline,
33497 )?;
33498 Ok(_response.map(|x| x))
33499 }
33500
33501 pub fn r#get_out_of_band_inline(
33503 &self,
33504 ___deadline: zx::MonotonicInstant,
33505 ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
33506 let _response = self
33507 .client
33508 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33509 BaseSocketGetOutOfBandInlineResponse,
33510 fidl_fuchsia_posix::Errno,
33511 >>(
33512 (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
33513 )?;
33514 Ok(_response.map(|x| x.value))
33515 }
33516
33517 pub fn r#set_no_check(
33519 &self,
33520 mut value: bool,
33521 ___deadline: zx::MonotonicInstant,
33522 ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
33523 let _response =
33524 self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
33525 fidl::encoding::EmptyStruct,
33526 fidl_fuchsia_posix::Errno,
33527 >>(
33528 (value,),
33529 0x6bbf00c53a4c78c2,
33530 fidl::encoding::DynamicFlags::empty(),
33531 ___deadline,
33532 )?;
33533 Ok(_response.map(|x| x))
33534 }
33535
33536 pub fn r#get_no_check(
33538 &self,
33539 ___deadline: zx::MonotonicInstant,
33540 ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
33541 let _response =
33542 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33543 BaseSocketGetNoCheckResponse,
33544 fidl_fuchsia_posix::Errno,
33545 >>(
33546 (),
33547 0x2cd4249286417694,
33548 fidl::encoding::DynamicFlags::empty(),
33549 ___deadline,
33550 )?;
33551 Ok(_response.map(|x| x.value))
33552 }
33553
33554 pub fn r#set_linger(
33556 &self,
33557 mut linger: bool,
33558 mut length_secs: u32,
33559 ___deadline: zx::MonotonicInstant,
33560 ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
33561 let _response =
33562 self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
33563 fidl::encoding::EmptyStruct,
33564 fidl_fuchsia_posix::Errno,
33565 >>(
33566 (linger, length_secs),
33567 0x45386351246e998e,
33568 fidl::encoding::DynamicFlags::empty(),
33569 ___deadline,
33570 )?;
33571 Ok(_response.map(|x| x))
33572 }
33573
33574 pub fn r#get_linger(
33576 &self,
33577 ___deadline: zx::MonotonicInstant,
33578 ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
33579 let _response =
33580 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33581 BaseSocketGetLingerResponse,
33582 fidl_fuchsia_posix::Errno,
33583 >>(
33584 (),
33585 0x48eb20fc5ccb0e45,
33586 fidl::encoding::DynamicFlags::empty(),
33587 ___deadline,
33588 )?;
33589 Ok(_response.map(|x| (x.linger, x.length_secs)))
33590 }
33591
33592 pub fn r#set_reuse_port(
33594 &self,
33595 mut value: bool,
33596 ___deadline: zx::MonotonicInstant,
33597 ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
33598 let _response =
33599 self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
33600 fidl::encoding::EmptyStruct,
33601 fidl_fuchsia_posix::Errno,
33602 >>(
33603 (value,),
33604 0x24dd3e5cb36d9ccb,
33605 fidl::encoding::DynamicFlags::empty(),
33606 ___deadline,
33607 )?;
33608 Ok(_response.map(|x| x))
33609 }
33610
33611 pub fn r#get_reuse_port(
33613 &self,
33614 ___deadline: zx::MonotonicInstant,
33615 ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
33616 let _response =
33617 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33618 BaseSocketGetReusePortResponse,
33619 fidl_fuchsia_posix::Errno,
33620 >>(
33621 (),
33622 0x7a112c1ab54ff828,
33623 fidl::encoding::DynamicFlags::empty(),
33624 ___deadline,
33625 )?;
33626 Ok(_response.map(|x| x.value))
33627 }
33628
33629 pub fn r#get_accept_conn(
33631 &self,
33632 ___deadline: zx::MonotonicInstant,
33633 ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
33634 let _response = self
33635 .client
33636 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33637 BaseSocketGetAcceptConnResponse,
33638 fidl_fuchsia_posix::Errno,
33639 >>(
33640 (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
33641 )?;
33642 Ok(_response.map(|x| x.value))
33643 }
33644
33645 pub fn r#set_bind_to_device(
33647 &self,
33648 mut value: &str,
33649 ___deadline: zx::MonotonicInstant,
33650 ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
33651 let _response =
33652 self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
33653 fidl::encoding::EmptyStruct,
33654 fidl_fuchsia_posix::Errno,
33655 >>(
33656 (value,),
33657 0x2118b483f28aafc4,
33658 fidl::encoding::DynamicFlags::empty(),
33659 ___deadline,
33660 )?;
33661 Ok(_response.map(|x| x))
33662 }
33663
33664 pub fn r#get_bind_to_device(
33666 &self,
33667 ___deadline: zx::MonotonicInstant,
33668 ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
33669 let _response = self
33670 .client
33671 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33672 BaseSocketGetBindToDeviceResponse,
33673 fidl_fuchsia_posix::Errno,
33674 >>(
33675 (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
33676 )?;
33677 Ok(_response.map(|x| x.value))
33678 }
33679
33680 pub fn r#set_bind_to_interface_index(
33683 &self,
33684 mut value: u64,
33685 ___deadline: zx::MonotonicInstant,
33686 ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
33687 let _response =
33688 self.client
33689 .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
33690 fidl::encoding::EmptyStruct,
33691 fidl_fuchsia_posix::Errno,
33692 >>(
33693 (value,),
33694 0x6e387a0def00821,
33695 fidl::encoding::DynamicFlags::empty(),
33696 ___deadline,
33697 )?;
33698 Ok(_response.map(|x| x))
33699 }
33700
33701 pub fn r#get_bind_to_interface_index(
33703 &self,
33704 ___deadline: zx::MonotonicInstant,
33705 ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
33706 let _response = self
33707 .client
33708 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33709 BaseSocketGetBindToInterfaceIndexResponse,
33710 fidl_fuchsia_posix::Errno,
33711 >>(
33712 (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
33713 )?;
33714 Ok(_response.map(|x| x.value))
33715 }
33716
33717 pub fn r#set_timestamp(
33719 &self,
33720 mut value: TimestampOption,
33721 ___deadline: zx::MonotonicInstant,
33722 ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
33723 let _response =
33724 self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
33725 fidl::encoding::EmptyStruct,
33726 fidl_fuchsia_posix::Errno,
33727 >>(
33728 (value,),
33729 0x285d6516c263d839,
33730 fidl::encoding::DynamicFlags::empty(),
33731 ___deadline,
33732 )?;
33733 Ok(_response.map(|x| x))
33734 }
33735
33736 pub fn r#get_timestamp(
33738 &self,
33739 ___deadline: zx::MonotonicInstant,
33740 ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
33741 let _response =
33742 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33743 BaseSocketGetTimestampResponse,
33744 fidl_fuchsia_posix::Errno,
33745 >>(
33746 (),
33747 0x49f2fffbbcc2bd27,
33748 fidl::encoding::DynamicFlags::empty(),
33749 ___deadline,
33750 )?;
33751 Ok(_response.map(|x| x.value))
33752 }
33753
33754 pub fn r#set_mark(
33758 &self,
33759 mut domain: fidl_fuchsia_net::MarkDomain,
33760 mut mark: &OptionalUint32,
33761 ___deadline: zx::MonotonicInstant,
33762 ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
33763 let _response =
33764 self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
33765 fidl::encoding::EmptyStruct,
33766 fidl_fuchsia_posix::Errno,
33767 >>(
33768 (domain, mark),
33769 0x6ead6de09f653236,
33770 fidl::encoding::DynamicFlags::empty(),
33771 ___deadline,
33772 )?;
33773 Ok(_response.map(|x| x))
33774 }
33775
33776 pub fn r#get_mark(
33780 &self,
33781 mut domain: fidl_fuchsia_net::MarkDomain,
33782 ___deadline: zx::MonotonicInstant,
33783 ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
33784 let _response =
33785 self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
33786 BaseSocketGetMarkResponse,
33787 fidl_fuchsia_posix::Errno,
33788 >>(
33789 (domain,),
33790 0x57a2752c61d93d47,
33791 fidl::encoding::DynamicFlags::empty(),
33792 ___deadline,
33793 )?;
33794 Ok(_response.map(|x| x.mark))
33795 }
33796
33797 pub fn r#bind(
33799 &self,
33800 mut addr: &fidl_fuchsia_net::SocketAddress,
33801 ___deadline: zx::MonotonicInstant,
33802 ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
33803 let _response =
33804 self.client.send_query::<BaseNetworkSocketBindRequest, fidl::encoding::ResultType<
33805 fidl::encoding::EmptyStruct,
33806 fidl_fuchsia_posix::Errno,
33807 >>(
33808 (addr,),
33809 0x4bc6400ae92125d,
33810 fidl::encoding::DynamicFlags::empty(),
33811 ___deadline,
33812 )?;
33813 Ok(_response.map(|x| x))
33814 }
33815
33816 pub fn r#connect(
33818 &self,
33819 mut addr: &fidl_fuchsia_net::SocketAddress,
33820 ___deadline: zx::MonotonicInstant,
33821 ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
33822 let _response =
33823 self.client.send_query::<BaseNetworkSocketConnectRequest, fidl::encoding::ResultType<
33824 fidl::encoding::EmptyStruct,
33825 fidl_fuchsia_posix::Errno,
33826 >>(
33827 (addr,),
33828 0x5f05f19bfdd38871,
33829 fidl::encoding::DynamicFlags::empty(),
33830 ___deadline,
33831 )?;
33832 Ok(_response.map(|x| x))
33833 }
33834
33835 pub fn r#disconnect(
33837 &self,
33838 ___deadline: zx::MonotonicInstant,
33839 ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
33840 let _response =
33841 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33842 fidl::encoding::EmptyStruct,
33843 fidl_fuchsia_posix::Errno,
33844 >>(
33845 (),
33846 0x74e63b91f7b29b2,
33847 fidl::encoding::DynamicFlags::empty(),
33848 ___deadline,
33849 )?;
33850 Ok(_response.map(|x| x))
33851 }
33852
33853 pub fn r#get_sock_name(
33855 &self,
33856 ___deadline: zx::MonotonicInstant,
33857 ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
33858 let _response = self
33859 .client
33860 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33861 BaseNetworkSocketGetSockNameResponse,
33862 fidl_fuchsia_posix::Errno,
33863 >>(
33864 (), 0x475f23f84a1a4f85, fidl::encoding::DynamicFlags::empty(), ___deadline
33865 )?;
33866 Ok(_response.map(|x| x.addr))
33867 }
33868
33869 pub fn r#get_peer_name(
33871 &self,
33872 ___deadline: zx::MonotonicInstant,
33873 ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
33874 let _response = self
33875 .client
33876 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33877 BaseNetworkSocketGetPeerNameResponse,
33878 fidl_fuchsia_posix::Errno,
33879 >>(
33880 (), 0x1ffecf4bd5b6432e, fidl::encoding::DynamicFlags::empty(), ___deadline
33881 )?;
33882 Ok(_response.map(|x| x.addr))
33883 }
33884
33885 pub fn r#shutdown(
33887 &self,
33888 mut mode: ShutdownMode,
33889 ___deadline: zx::MonotonicInstant,
33890 ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
33891 let _response =
33892 self.client.send_query::<BaseNetworkSocketShutdownRequest, fidl::encoding::ResultType<
33893 fidl::encoding::EmptyStruct,
33894 fidl_fuchsia_posix::Errno,
33895 >>(
33896 (mode,),
33897 0x247f38b6db68c336,
33898 fidl::encoding::DynamicFlags::empty(),
33899 ___deadline,
33900 )?;
33901 Ok(_response.map(|x| x))
33902 }
33903
33904 pub fn r#set_ip_type_of_service(
33906 &self,
33907 mut value: u8,
33908 ___deadline: zx::MonotonicInstant,
33909 ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
33910 let _response = self.client.send_query::<
33911 BaseNetworkSocketSetIpTypeOfServiceRequest,
33912 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
33913 >(
33914 (value,),
33915 0x995c600475b6d46,
33916 fidl::encoding::DynamicFlags::empty(),
33917 ___deadline,
33918 )?;
33919 Ok(_response.map(|x| x))
33920 }
33921
33922 pub fn r#get_ip_type_of_service(
33924 &self,
33925 ___deadline: zx::MonotonicInstant,
33926 ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
33927 let _response = self
33928 .client
33929 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33930 BaseNetworkSocketGetIpTypeOfServiceResponse,
33931 fidl_fuchsia_posix::Errno,
33932 >>(
33933 (), 0x3814a04259f75fcb, fidl::encoding::DynamicFlags::empty(), ___deadline
33934 )?;
33935 Ok(_response.map(|x| x.value))
33936 }
33937
33938 pub fn r#set_ip_ttl(
33940 &self,
33941 mut value: &OptionalUint8,
33942 ___deadline: zx::MonotonicInstant,
33943 ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
33944 let _response =
33945 self.client.send_query::<BaseNetworkSocketSetIpTtlRequest, fidl::encoding::ResultType<
33946 fidl::encoding::EmptyStruct,
33947 fidl_fuchsia_posix::Errno,
33948 >>(
33949 (value,),
33950 0x29e2424b433ae1ef,
33951 fidl::encoding::DynamicFlags::empty(),
33952 ___deadline,
33953 )?;
33954 Ok(_response.map(|x| x))
33955 }
33956
33957 pub fn r#get_ip_ttl(
33959 &self,
33960 ___deadline: zx::MonotonicInstant,
33961 ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
33962 let _response = self
33963 .client
33964 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33965 BaseNetworkSocketGetIpTtlResponse,
33966 fidl_fuchsia_posix::Errno,
33967 >>(
33968 (), 0x47e47fa1f24da471, fidl::encoding::DynamicFlags::empty(), ___deadline
33969 )?;
33970 Ok(_response.map(|x| x.value))
33971 }
33972
33973 pub fn r#set_ip_packet_info(
33975 &self,
33976 mut value: bool,
33977 ___deadline: zx::MonotonicInstant,
33978 ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
33979 let _response =
33980 self.client
33981 .send_query::<BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::ResultType<
33982 fidl::encoding::EmptyStruct,
33983 fidl_fuchsia_posix::Errno,
33984 >>(
33985 (value,),
33986 0x392d16bee20c0e16,
33987 fidl::encoding::DynamicFlags::empty(),
33988 ___deadline,
33989 )?;
33990 Ok(_response.map(|x| x))
33991 }
33992
33993 pub fn r#get_ip_packet_info(
33995 &self,
33996 ___deadline: zx::MonotonicInstant,
33997 ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
33998 let _response = self
33999 .client
34000 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34001 BaseNetworkSocketGetIpPacketInfoResponse,
34002 fidl_fuchsia_posix::Errno,
34003 >>(
34004 (), 0x54b505f242280740, fidl::encoding::DynamicFlags::empty(), ___deadline
34005 )?;
34006 Ok(_response.map(|x| x.value))
34007 }
34008
34009 pub fn r#set_ip_receive_type_of_service(
34011 &self,
34012 mut value: bool,
34013 ___deadline: zx::MonotonicInstant,
34014 ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
34015 let _response = self.client.send_query::<
34016 BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
34017 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34018 >(
34019 (value,),
34020 0x6c4f6714995f84ef,
34021 fidl::encoding::DynamicFlags::empty(),
34022 ___deadline,
34023 )?;
34024 Ok(_response.map(|x| x))
34025 }
34026
34027 pub fn r#get_ip_receive_type_of_service(
34029 &self,
34030 ___deadline: zx::MonotonicInstant,
34031 ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
34032 let _response = self
34033 .client
34034 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34035 BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
34036 fidl_fuchsia_posix::Errno,
34037 >>(
34038 (), 0x4158ba7dc2795960, fidl::encoding::DynamicFlags::empty(), ___deadline
34039 )?;
34040 Ok(_response.map(|x| x.value))
34041 }
34042
34043 pub fn r#set_ip_receive_ttl(
34045 &self,
34046 mut value: bool,
34047 ___deadline: zx::MonotonicInstant,
34048 ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
34049 let _response =
34050 self.client
34051 .send_query::<BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::ResultType<
34052 fidl::encoding::EmptyStruct,
34053 fidl_fuchsia_posix::Errno,
34054 >>(
34055 (value,),
34056 0x46f15be0ce0ab82b,
34057 fidl::encoding::DynamicFlags::empty(),
34058 ___deadline,
34059 )?;
34060 Ok(_response.map(|x| x))
34061 }
34062
34063 pub fn r#get_ip_receive_ttl(
34065 &self,
34066 ___deadline: zx::MonotonicInstant,
34067 ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
34068 let _response = self
34069 .client
34070 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34071 BaseNetworkSocketGetIpReceiveTtlResponse,
34072 fidl_fuchsia_posix::Errno,
34073 >>(
34074 (), 0x678ddd5a5dfa2eb5, fidl::encoding::DynamicFlags::empty(), ___deadline
34075 )?;
34076 Ok(_response.map(|x| x.value))
34077 }
34078
34079 pub fn r#set_ip_multicast_interface(
34081 &self,
34082 mut iface: u64,
34083 mut address: &fidl_fuchsia_net::Ipv4Address,
34084 ___deadline: zx::MonotonicInstant,
34085 ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
34086 let _response = self.client.send_query::<
34087 BaseNetworkSocketSetIpMulticastInterfaceRequest,
34088 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34089 >(
34090 (iface, address,),
34091 0x752fbfa9b12befe,
34092 fidl::encoding::DynamicFlags::empty(),
34093 ___deadline,
34094 )?;
34095 Ok(_response.map(|x| x))
34096 }
34097
34098 pub fn r#get_ip_multicast_interface(
34100 &self,
34101 ___deadline: zx::MonotonicInstant,
34102 ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
34103 let _response = self
34104 .client
34105 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34106 BaseNetworkSocketGetIpMulticastInterfaceResponse,
34107 fidl_fuchsia_posix::Errno,
34108 >>(
34109 (), 0x320bd14c4df046c4, fidl::encoding::DynamicFlags::empty(), ___deadline
34110 )?;
34111 Ok(_response.map(|x| x.value))
34112 }
34113
34114 pub fn r#set_ip_multicast_ttl(
34116 &self,
34117 mut value: &OptionalUint8,
34118 ___deadline: zx::MonotonicInstant,
34119 ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
34120 let _response =
34121 self.client
34122 .send_query::<BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::ResultType<
34123 fidl::encoding::EmptyStruct,
34124 fidl_fuchsia_posix::Errno,
34125 >>(
34126 (value,),
34127 0x63134d53772916a1,
34128 fidl::encoding::DynamicFlags::empty(),
34129 ___deadline,
34130 )?;
34131 Ok(_response.map(|x| x))
34132 }
34133
34134 pub fn r#get_ip_multicast_ttl(
34136 &self,
34137 ___deadline: zx::MonotonicInstant,
34138 ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
34139 let _response = self
34140 .client
34141 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34142 BaseNetworkSocketGetIpMulticastTtlResponse,
34143 fidl_fuchsia_posix::Errno,
34144 >>(
34145 (), 0x4665cd378f39e1a, fidl::encoding::DynamicFlags::empty(), ___deadline
34146 )?;
34147 Ok(_response.map(|x| x.value))
34148 }
34149
34150 pub fn r#set_ip_multicast_loopback(
34152 &self,
34153 mut value: bool,
34154 ___deadline: zx::MonotonicInstant,
34155 ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
34156 let _response = self.client.send_query::<
34157 BaseNetworkSocketSetIpMulticastLoopbackRequest,
34158 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34159 >(
34160 (value,),
34161 0x20c55c11f00943ea,
34162 fidl::encoding::DynamicFlags::empty(),
34163 ___deadline,
34164 )?;
34165 Ok(_response.map(|x| x))
34166 }
34167
34168 pub fn r#get_ip_multicast_loopback(
34170 &self,
34171 ___deadline: zx::MonotonicInstant,
34172 ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
34173 let _response = self
34174 .client
34175 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34176 BaseNetworkSocketGetIpMulticastLoopbackResponse,
34177 fidl_fuchsia_posix::Errno,
34178 >>(
34179 (), 0x3b6b26ff558298f2, fidl::encoding::DynamicFlags::empty(), ___deadline
34180 )?;
34181 Ok(_response.map(|x| x.value))
34182 }
34183
34184 pub fn r#add_ip_membership(
34186 &self,
34187 mut membership: &IpMulticastMembership,
34188 ___deadline: zx::MonotonicInstant,
34189 ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
34190 let _response =
34191 self.client
34192 .send_query::<BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::ResultType<
34193 fidl::encoding::EmptyStruct,
34194 fidl_fuchsia_posix::Errno,
34195 >>(
34196 (membership,),
34197 0x76bc7df115a3b4d0,
34198 fidl::encoding::DynamicFlags::empty(),
34199 ___deadline,
34200 )?;
34201 Ok(_response.map(|x| x))
34202 }
34203
34204 pub fn r#drop_ip_membership(
34206 &self,
34207 mut membership: &IpMulticastMembership,
34208 ___deadline: zx::MonotonicInstant,
34209 ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
34210 let _response =
34211 self.client
34212 .send_query::<BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::ResultType<
34213 fidl::encoding::EmptyStruct,
34214 fidl_fuchsia_posix::Errno,
34215 >>(
34216 (membership,),
34217 0x2888f3099188d03,
34218 fidl::encoding::DynamicFlags::empty(),
34219 ___deadline,
34220 )?;
34221 Ok(_response.map(|x| x))
34222 }
34223
34224 pub fn r#set_ip_transparent(
34226 &self,
34227 mut value: bool,
34228 ___deadline: zx::MonotonicInstant,
34229 ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
34230 let _response =
34231 self.client
34232 .send_query::<BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::ResultType<
34233 fidl::encoding::EmptyStruct,
34234 fidl_fuchsia_posix::Errno,
34235 >>(
34236 (value,),
34237 0x1ae532b0c066e3a0,
34238 fidl::encoding::DynamicFlags::empty(),
34239 ___deadline,
34240 )?;
34241 Ok(_response.map(|x| x))
34242 }
34243
34244 pub fn r#get_ip_transparent(
34246 &self,
34247 ___deadline: zx::MonotonicInstant,
34248 ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
34249 let _response = self
34250 .client
34251 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34252 BaseNetworkSocketGetIpTransparentResponse,
34253 fidl_fuchsia_posix::Errno,
34254 >>(
34255 (), 0x51d43695962ebfb5, fidl::encoding::DynamicFlags::empty(), ___deadline
34256 )?;
34257 Ok(_response.map(|x| x.value))
34258 }
34259
34260 pub fn r#set_ip_receive_original_destination_address(
34262 &self,
34263 mut value: bool,
34264 ___deadline: zx::MonotonicInstant,
34265 ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
34266 let _response = self.client.send_query::<
34267 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
34268 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34269 >(
34270 (value,),
34271 0x4722b4ce52f7840,
34272 fidl::encoding::DynamicFlags::empty(),
34273 ___deadline,
34274 )?;
34275 Ok(_response.map(|x| x))
34276 }
34277
34278 pub fn r#get_ip_receive_original_destination_address(
34280 &self,
34281 ___deadline: zx::MonotonicInstant,
34282 ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
34283 let _response = self
34284 .client
34285 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34286 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
34287 fidl_fuchsia_posix::Errno,
34288 >>(
34289 (), 0x2a0e7dc5d6bfdfe9, fidl::encoding::DynamicFlags::empty(), ___deadline
34290 )?;
34291 Ok(_response.map(|x| x.value))
34292 }
34293
34294 pub fn r#add_ipv6_membership(
34296 &self,
34297 mut membership: &Ipv6MulticastMembership,
34298 ___deadline: zx::MonotonicInstant,
34299 ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
34300 let _response =
34301 self.client
34302 .send_query::<BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::ResultType<
34303 fidl::encoding::EmptyStruct,
34304 fidl_fuchsia_posix::Errno,
34305 >>(
34306 (membership,),
34307 0x7c94727acb4ea4b3,
34308 fidl::encoding::DynamicFlags::empty(),
34309 ___deadline,
34310 )?;
34311 Ok(_response.map(|x| x))
34312 }
34313
34314 pub fn r#drop_ipv6_membership(
34316 &self,
34317 mut membership: &Ipv6MulticastMembership,
34318 ___deadline: zx::MonotonicInstant,
34319 ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
34320 let _response = self.client.send_query::<
34321 BaseNetworkSocketDropIpv6MembershipRequest,
34322 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34323 >(
34324 (membership,),
34325 0x42104c70ccaba304,
34326 fidl::encoding::DynamicFlags::empty(),
34327 ___deadline,
34328 )?;
34329 Ok(_response.map(|x| x))
34330 }
34331
34332 pub fn r#set_ipv6_multicast_interface(
34334 &self,
34335 mut value: u64,
34336 ___deadline: zx::MonotonicInstant,
34337 ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
34338 let _response = self.client.send_query::<
34339 BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
34340 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34341 >(
34342 (value,),
34343 0x135f76db3774ab3b,
34344 fidl::encoding::DynamicFlags::empty(),
34345 ___deadline,
34346 )?;
34347 Ok(_response.map(|x| x))
34348 }
34349
34350 pub fn r#get_ipv6_multicast_interface(
34352 &self,
34353 ___deadline: zx::MonotonicInstant,
34354 ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
34355 let _response = self
34356 .client
34357 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34358 BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
34359 fidl_fuchsia_posix::Errno,
34360 >>(
34361 (), 0x1f26fcdd348f1882, fidl::encoding::DynamicFlags::empty(), ___deadline
34362 )?;
34363 Ok(_response.map(|x| x.value))
34364 }
34365
34366 pub fn r#set_ipv6_unicast_hops(
34368 &self,
34369 mut value: &OptionalUint8,
34370 ___deadline: zx::MonotonicInstant,
34371 ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
34372 let _response = self.client.send_query::<
34373 BaseNetworkSocketSetIpv6UnicastHopsRequest,
34374 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34375 >(
34376 (value,),
34377 0x157d51e98f462859,
34378 fidl::encoding::DynamicFlags::empty(),
34379 ___deadline,
34380 )?;
34381 Ok(_response.map(|x| x))
34382 }
34383
34384 pub fn r#get_ipv6_unicast_hops(
34386 &self,
34387 ___deadline: zx::MonotonicInstant,
34388 ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
34389 let _response = self
34390 .client
34391 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34392 BaseNetworkSocketGetIpv6UnicastHopsResponse,
34393 fidl_fuchsia_posix::Errno,
34394 >>(
34395 (), 0x21f4641cad8bd8d2, fidl::encoding::DynamicFlags::empty(), ___deadline
34396 )?;
34397 Ok(_response.map(|x| x.value))
34398 }
34399
34400 pub fn r#set_ipv6_receive_hop_limit(
34402 &self,
34403 mut value: bool,
34404 ___deadline: zx::MonotonicInstant,
34405 ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
34406 let _response = self.client.send_query::<
34407 BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
34408 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34409 >(
34410 (value,),
34411 0x5c24808ed2e84a1e,
34412 fidl::encoding::DynamicFlags::empty(),
34413 ___deadline,
34414 )?;
34415 Ok(_response.map(|x| x))
34416 }
34417
34418 pub fn r#get_ipv6_receive_hop_limit(
34420 &self,
34421 ___deadline: zx::MonotonicInstant,
34422 ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
34423 let _response = self
34424 .client
34425 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34426 BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
34427 fidl_fuchsia_posix::Errno,
34428 >>(
34429 (), 0x341e06689885b4c0, fidl::encoding::DynamicFlags::empty(), ___deadline
34430 )?;
34431 Ok(_response.map(|x| x.value))
34432 }
34433
34434 pub fn r#set_ipv6_multicast_hops(
34436 &self,
34437 mut value: &OptionalUint8,
34438 ___deadline: zx::MonotonicInstant,
34439 ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
34440 let _response = self.client.send_query::<
34441 BaseNetworkSocketSetIpv6MulticastHopsRequest,
34442 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34443 >(
34444 (value,),
34445 0x25b9cd4d181f82c1,
34446 fidl::encoding::DynamicFlags::empty(),
34447 ___deadline,
34448 )?;
34449 Ok(_response.map(|x| x))
34450 }
34451
34452 pub fn r#get_ipv6_multicast_hops(
34454 &self,
34455 ___deadline: zx::MonotonicInstant,
34456 ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
34457 let _response = self
34458 .client
34459 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34460 BaseNetworkSocketGetIpv6MulticastHopsResponse,
34461 fidl_fuchsia_posix::Errno,
34462 >>(
34463 (), 0x52916948a365012a, fidl::encoding::DynamicFlags::empty(), ___deadline
34464 )?;
34465 Ok(_response.map(|x| x.value))
34466 }
34467
34468 pub fn r#set_ipv6_multicast_loopback(
34470 &self,
34471 mut value: bool,
34472 ___deadline: zx::MonotonicInstant,
34473 ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
34474 let _response = self.client.send_query::<
34475 BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
34476 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34477 >(
34478 (value,),
34479 0x55701c409ff41b40,
34480 fidl::encoding::DynamicFlags::empty(),
34481 ___deadline,
34482 )?;
34483 Ok(_response.map(|x| x))
34484 }
34485
34486 pub fn r#get_ipv6_multicast_loopback(
34488 &self,
34489 ___deadline: zx::MonotonicInstant,
34490 ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
34491 let _response = self
34492 .client
34493 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34494 BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
34495 fidl_fuchsia_posix::Errno,
34496 >>(
34497 (), 0x4415b701fde319c3, fidl::encoding::DynamicFlags::empty(), ___deadline
34498 )?;
34499 Ok(_response.map(|x| x.value))
34500 }
34501
34502 pub fn r#set_ipv6_only(
34504 &self,
34505 mut value: bool,
34506 ___deadline: zx::MonotonicInstant,
34507 ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
34508 let _response =
34509 self.client
34510 .send_query::<BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::ResultType<
34511 fidl::encoding::EmptyStruct,
34512 fidl_fuchsia_posix::Errno,
34513 >>(
34514 (value,),
34515 0x4873f1364758cbba,
34516 fidl::encoding::DynamicFlags::empty(),
34517 ___deadline,
34518 )?;
34519 Ok(_response.map(|x| x))
34520 }
34521
34522 pub fn r#get_ipv6_only(
34524 &self,
34525 ___deadline: zx::MonotonicInstant,
34526 ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
34527 let _response = self
34528 .client
34529 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34530 BaseNetworkSocketGetIpv6OnlyResponse,
34531 fidl_fuchsia_posix::Errno,
34532 >>(
34533 (), 0x4aa3340a1a26b89c, fidl::encoding::DynamicFlags::empty(), ___deadline
34534 )?;
34535 Ok(_response.map(|x| x.value))
34536 }
34537
34538 pub fn r#set_ipv6_receive_traffic_class(
34540 &self,
34541 mut value: bool,
34542 ___deadline: zx::MonotonicInstant,
34543 ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
34544 let _response = self.client.send_query::<
34545 BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
34546 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34547 >(
34548 (value,),
34549 0x58f07c8788d099a0,
34550 fidl::encoding::DynamicFlags::empty(),
34551 ___deadline,
34552 )?;
34553 Ok(_response.map(|x| x))
34554 }
34555
34556 pub fn r#get_ipv6_receive_traffic_class(
34558 &self,
34559 ___deadline: zx::MonotonicInstant,
34560 ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
34561 let _response = self
34562 .client
34563 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34564 BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
34565 fidl_fuchsia_posix::Errno,
34566 >>(
34567 (), 0x2e334df1da553ffa, fidl::encoding::DynamicFlags::empty(), ___deadline
34568 )?;
34569 Ok(_response.map(|x| x.value))
34570 }
34571
34572 pub fn r#set_ipv6_traffic_class(
34574 &self,
34575 mut value: &OptionalUint8,
34576 ___deadline: zx::MonotonicInstant,
34577 ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
34578 let _response = self.client.send_query::<
34579 BaseNetworkSocketSetIpv6TrafficClassRequest,
34580 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34581 >(
34582 (value,),
34583 0x6af077800c5a0b4f,
34584 fidl::encoding::DynamicFlags::empty(),
34585 ___deadline,
34586 )?;
34587 Ok(_response.map(|x| x))
34588 }
34589
34590 pub fn r#get_ipv6_traffic_class(
34592 &self,
34593 ___deadline: zx::MonotonicInstant,
34594 ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
34595 let _response = self
34596 .client
34597 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34598 BaseNetworkSocketGetIpv6TrafficClassResponse,
34599 fidl_fuchsia_posix::Errno,
34600 >>(
34601 (), 0x6baf6eed8fc2f04, fidl::encoding::DynamicFlags::empty(), ___deadline
34602 )?;
34603 Ok(_response.map(|x| x.value))
34604 }
34605
34606 pub fn r#set_ipv6_receive_packet_info(
34608 &self,
34609 mut value: bool,
34610 ___deadline: zx::MonotonicInstant,
34611 ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
34612 let _response = self.client.send_query::<
34613 BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
34614 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34615 >(
34616 (value,),
34617 0x19259775b1a92768,
34618 fidl::encoding::DynamicFlags::empty(),
34619 ___deadline,
34620 )?;
34621 Ok(_response.map(|x| x))
34622 }
34623
34624 pub fn r#get_ipv6_receive_packet_info(
34626 &self,
34627 ___deadline: zx::MonotonicInstant,
34628 ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
34629 let _response = self
34630 .client
34631 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34632 BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
34633 fidl_fuchsia_posix::Errno,
34634 >>(
34635 (), 0x7acd4a2775baec75, fidl::encoding::DynamicFlags::empty(), ___deadline
34636 )?;
34637 Ok(_response.map(|x| x.value))
34638 }
34639
34640 pub fn r#get_original_destination(
34642 &self,
34643 ___deadline: zx::MonotonicInstant,
34644 ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
34645 let _response = self
34646 .client
34647 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34648 BaseNetworkSocketGetOriginalDestinationResponse,
34649 fidl_fuchsia_posix::Errno,
34650 >>(
34651 (), 0x38bf28f0dafdbac0, fidl::encoding::DynamicFlags::empty(), ___deadline
34652 )?;
34653 Ok(_response.map(|x| x.value))
34654 }
34655
34656 pub fn r#get_info(
34661 &self,
34662 ___deadline: zx::MonotonicInstant,
34663 ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
34664 let _response = self
34665 .client
34666 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34667 BaseDatagramSocketGetInfoResponse,
34668 fidl_fuchsia_posix::Errno,
34669 >>(
34670 (), 0x48aa0a1f6a32d2ed, fidl::encoding::DynamicFlags::empty(), ___deadline
34671 )?;
34672 Ok(_response.map(|x| (x.domain, x.proto)))
34673 }
34674
34675 pub fn r#describe(
34676 &self,
34677 ___deadline: zx::MonotonicInstant,
34678 ) -> Result<DatagramSocketDescribeResponse, fidl::Error> {
34679 let _response = self
34680 .client
34681 .send_query::<fidl::encoding::EmptyPayload, DatagramSocketDescribeResponse>(
34682 (),
34683 0xbf1e2f0a86601f3,
34684 fidl::encoding::DynamicFlags::empty(),
34685 ___deadline,
34686 )?;
34687 Ok(_response)
34688 }
34689
34690 pub fn r#send_msg_preflight(
34696 &self,
34697 mut payload: &DatagramSocketSendMsgPreflightRequest,
34698 ___deadline: zx::MonotonicInstant,
34699 ) -> Result<DatagramSocketSendMsgPreflightResult, fidl::Error> {
34700 let _response = self
34701 .client
34702 .send_query::<DatagramSocketSendMsgPreflightRequest, fidl::encoding::ResultType<
34703 DatagramSocketSendMsgPreflightResponse,
34704 fidl_fuchsia_posix::Errno,
34705 >>(
34706 payload, 0x5362e668e777248a, fidl::encoding::DynamicFlags::empty(), ___deadline
34707 )?;
34708 Ok(_response.map(|x| x))
34709 }
34710
34711 pub fn r#recv_msg_postflight(
34715 &self,
34716 ___deadline: zx::MonotonicInstant,
34717 ) -> Result<DatagramSocketRecvMsgPostflightResult, fidl::Error> {
34718 let _response = self
34719 .client
34720 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34721 DatagramSocketRecvMsgPostflightResponse,
34722 fidl_fuchsia_posix::Errno,
34723 >>(
34724 (), 0x1a7cdeca5f3eb8e2, fidl::encoding::DynamicFlags::empty(), ___deadline
34725 )?;
34726 Ok(_response.map(|x| x))
34727 }
34728}
34729
34730#[cfg(target_os = "fuchsia")]
34731impl From<DatagramSocketSynchronousProxy> for zx::Handle {
34732 fn from(value: DatagramSocketSynchronousProxy) -> Self {
34733 value.into_channel().into()
34734 }
34735}
34736
34737#[cfg(target_os = "fuchsia")]
34738impl From<fidl::Channel> for DatagramSocketSynchronousProxy {
34739 fn from(value: fidl::Channel) -> Self {
34740 Self::new(value)
34741 }
34742}
34743
34744#[derive(Debug, Clone)]
34745pub struct DatagramSocketProxy {
34746 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
34747}
34748
34749impl fidl::endpoints::Proxy for DatagramSocketProxy {
34750 type Protocol = DatagramSocketMarker;
34751
34752 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
34753 Self::new(inner)
34754 }
34755
34756 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
34757 self.client.into_channel().map_err(|client| Self { client })
34758 }
34759
34760 fn as_channel(&self) -> &::fidl::AsyncChannel {
34761 self.client.as_channel()
34762 }
34763}
34764
34765impl DatagramSocketProxy {
34766 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
34768 let protocol_name = <DatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
34769 Self { client: fidl::client::Client::new(channel, protocol_name) }
34770 }
34771
34772 pub fn take_event_stream(&self) -> DatagramSocketEventStream {
34778 DatagramSocketEventStream { event_receiver: self.client.take_event_receiver() }
34779 }
34780
34781 pub fn r#clone(
34782 &self,
34783 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
34784 ) -> Result<(), fidl::Error> {
34785 DatagramSocketProxyInterface::r#clone(self, request)
34786 }
34787
34788 pub fn r#close(
34799 &self,
34800 ) -> fidl::client::QueryResponseFut<
34801 fidl_fuchsia_unknown::CloseableCloseResult,
34802 fidl::encoding::DefaultFuchsiaResourceDialect,
34803 > {
34804 DatagramSocketProxyInterface::r#close(self)
34805 }
34806
34807 pub fn r#query(
34808 &self,
34809 ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
34810 {
34811 DatagramSocketProxyInterface::r#query(self)
34812 }
34813
34814 pub fn r#set_reuse_address(
34816 &self,
34817 mut value: bool,
34818 ) -> fidl::client::QueryResponseFut<
34819 BaseSocketSetReuseAddressResult,
34820 fidl::encoding::DefaultFuchsiaResourceDialect,
34821 > {
34822 DatagramSocketProxyInterface::r#set_reuse_address(self, value)
34823 }
34824
34825 pub fn r#get_reuse_address(
34827 &self,
34828 ) -> fidl::client::QueryResponseFut<
34829 BaseSocketGetReuseAddressResult,
34830 fidl::encoding::DefaultFuchsiaResourceDialect,
34831 > {
34832 DatagramSocketProxyInterface::r#get_reuse_address(self)
34833 }
34834
34835 pub fn r#get_error(
34838 &self,
34839 ) -> fidl::client::QueryResponseFut<
34840 BaseSocketGetErrorResult,
34841 fidl::encoding::DefaultFuchsiaResourceDialect,
34842 > {
34843 DatagramSocketProxyInterface::r#get_error(self)
34844 }
34845
34846 pub fn r#set_broadcast(
34848 &self,
34849 mut value: bool,
34850 ) -> fidl::client::QueryResponseFut<
34851 BaseSocketSetBroadcastResult,
34852 fidl::encoding::DefaultFuchsiaResourceDialect,
34853 > {
34854 DatagramSocketProxyInterface::r#set_broadcast(self, value)
34855 }
34856
34857 pub fn r#get_broadcast(
34859 &self,
34860 ) -> fidl::client::QueryResponseFut<
34861 BaseSocketGetBroadcastResult,
34862 fidl::encoding::DefaultFuchsiaResourceDialect,
34863 > {
34864 DatagramSocketProxyInterface::r#get_broadcast(self)
34865 }
34866
34867 pub fn r#set_send_buffer(
34869 &self,
34870 mut value_bytes: u64,
34871 ) -> fidl::client::QueryResponseFut<
34872 BaseSocketSetSendBufferResult,
34873 fidl::encoding::DefaultFuchsiaResourceDialect,
34874 > {
34875 DatagramSocketProxyInterface::r#set_send_buffer(self, value_bytes)
34876 }
34877
34878 pub fn r#get_send_buffer(
34880 &self,
34881 ) -> fidl::client::QueryResponseFut<
34882 BaseSocketGetSendBufferResult,
34883 fidl::encoding::DefaultFuchsiaResourceDialect,
34884 > {
34885 DatagramSocketProxyInterface::r#get_send_buffer(self)
34886 }
34887
34888 pub fn r#set_receive_buffer(
34890 &self,
34891 mut value_bytes: u64,
34892 ) -> fidl::client::QueryResponseFut<
34893 BaseSocketSetReceiveBufferResult,
34894 fidl::encoding::DefaultFuchsiaResourceDialect,
34895 > {
34896 DatagramSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
34897 }
34898
34899 pub fn r#get_receive_buffer(
34901 &self,
34902 ) -> fidl::client::QueryResponseFut<
34903 BaseSocketGetReceiveBufferResult,
34904 fidl::encoding::DefaultFuchsiaResourceDialect,
34905 > {
34906 DatagramSocketProxyInterface::r#get_receive_buffer(self)
34907 }
34908
34909 pub fn r#set_keep_alive(
34911 &self,
34912 mut value: bool,
34913 ) -> fidl::client::QueryResponseFut<
34914 BaseSocketSetKeepAliveResult,
34915 fidl::encoding::DefaultFuchsiaResourceDialect,
34916 > {
34917 DatagramSocketProxyInterface::r#set_keep_alive(self, value)
34918 }
34919
34920 pub fn r#get_keep_alive(
34922 &self,
34923 ) -> fidl::client::QueryResponseFut<
34924 BaseSocketGetKeepAliveResult,
34925 fidl::encoding::DefaultFuchsiaResourceDialect,
34926 > {
34927 DatagramSocketProxyInterface::r#get_keep_alive(self)
34928 }
34929
34930 pub fn r#set_out_of_band_inline(
34932 &self,
34933 mut value: bool,
34934 ) -> fidl::client::QueryResponseFut<
34935 BaseSocketSetOutOfBandInlineResult,
34936 fidl::encoding::DefaultFuchsiaResourceDialect,
34937 > {
34938 DatagramSocketProxyInterface::r#set_out_of_band_inline(self, value)
34939 }
34940
34941 pub fn r#get_out_of_band_inline(
34943 &self,
34944 ) -> fidl::client::QueryResponseFut<
34945 BaseSocketGetOutOfBandInlineResult,
34946 fidl::encoding::DefaultFuchsiaResourceDialect,
34947 > {
34948 DatagramSocketProxyInterface::r#get_out_of_band_inline(self)
34949 }
34950
34951 pub fn r#set_no_check(
34953 &self,
34954 mut value: bool,
34955 ) -> fidl::client::QueryResponseFut<
34956 BaseSocketSetNoCheckResult,
34957 fidl::encoding::DefaultFuchsiaResourceDialect,
34958 > {
34959 DatagramSocketProxyInterface::r#set_no_check(self, value)
34960 }
34961
34962 pub fn r#get_no_check(
34964 &self,
34965 ) -> fidl::client::QueryResponseFut<
34966 BaseSocketGetNoCheckResult,
34967 fidl::encoding::DefaultFuchsiaResourceDialect,
34968 > {
34969 DatagramSocketProxyInterface::r#get_no_check(self)
34970 }
34971
34972 pub fn r#set_linger(
34974 &self,
34975 mut linger: bool,
34976 mut length_secs: u32,
34977 ) -> fidl::client::QueryResponseFut<
34978 BaseSocketSetLingerResult,
34979 fidl::encoding::DefaultFuchsiaResourceDialect,
34980 > {
34981 DatagramSocketProxyInterface::r#set_linger(self, linger, length_secs)
34982 }
34983
34984 pub fn r#get_linger(
34986 &self,
34987 ) -> fidl::client::QueryResponseFut<
34988 BaseSocketGetLingerResult,
34989 fidl::encoding::DefaultFuchsiaResourceDialect,
34990 > {
34991 DatagramSocketProxyInterface::r#get_linger(self)
34992 }
34993
34994 pub fn r#set_reuse_port(
34996 &self,
34997 mut value: bool,
34998 ) -> fidl::client::QueryResponseFut<
34999 BaseSocketSetReusePortResult,
35000 fidl::encoding::DefaultFuchsiaResourceDialect,
35001 > {
35002 DatagramSocketProxyInterface::r#set_reuse_port(self, value)
35003 }
35004
35005 pub fn r#get_reuse_port(
35007 &self,
35008 ) -> fidl::client::QueryResponseFut<
35009 BaseSocketGetReusePortResult,
35010 fidl::encoding::DefaultFuchsiaResourceDialect,
35011 > {
35012 DatagramSocketProxyInterface::r#get_reuse_port(self)
35013 }
35014
35015 pub fn r#get_accept_conn(
35017 &self,
35018 ) -> fidl::client::QueryResponseFut<
35019 BaseSocketGetAcceptConnResult,
35020 fidl::encoding::DefaultFuchsiaResourceDialect,
35021 > {
35022 DatagramSocketProxyInterface::r#get_accept_conn(self)
35023 }
35024
35025 pub fn r#set_bind_to_device(
35027 &self,
35028 mut value: &str,
35029 ) -> fidl::client::QueryResponseFut<
35030 BaseSocketSetBindToDeviceResult,
35031 fidl::encoding::DefaultFuchsiaResourceDialect,
35032 > {
35033 DatagramSocketProxyInterface::r#set_bind_to_device(self, value)
35034 }
35035
35036 pub fn r#get_bind_to_device(
35038 &self,
35039 ) -> fidl::client::QueryResponseFut<
35040 BaseSocketGetBindToDeviceResult,
35041 fidl::encoding::DefaultFuchsiaResourceDialect,
35042 > {
35043 DatagramSocketProxyInterface::r#get_bind_to_device(self)
35044 }
35045
35046 pub fn r#set_bind_to_interface_index(
35049 &self,
35050 mut value: u64,
35051 ) -> fidl::client::QueryResponseFut<
35052 BaseSocketSetBindToInterfaceIndexResult,
35053 fidl::encoding::DefaultFuchsiaResourceDialect,
35054 > {
35055 DatagramSocketProxyInterface::r#set_bind_to_interface_index(self, value)
35056 }
35057
35058 pub fn r#get_bind_to_interface_index(
35060 &self,
35061 ) -> fidl::client::QueryResponseFut<
35062 BaseSocketGetBindToInterfaceIndexResult,
35063 fidl::encoding::DefaultFuchsiaResourceDialect,
35064 > {
35065 DatagramSocketProxyInterface::r#get_bind_to_interface_index(self)
35066 }
35067
35068 pub fn r#set_timestamp(
35070 &self,
35071 mut value: TimestampOption,
35072 ) -> fidl::client::QueryResponseFut<
35073 BaseSocketSetTimestampResult,
35074 fidl::encoding::DefaultFuchsiaResourceDialect,
35075 > {
35076 DatagramSocketProxyInterface::r#set_timestamp(self, value)
35077 }
35078
35079 pub fn r#get_timestamp(
35081 &self,
35082 ) -> fidl::client::QueryResponseFut<
35083 BaseSocketGetTimestampResult,
35084 fidl::encoding::DefaultFuchsiaResourceDialect,
35085 > {
35086 DatagramSocketProxyInterface::r#get_timestamp(self)
35087 }
35088
35089 pub fn r#set_mark(
35093 &self,
35094 mut domain: fidl_fuchsia_net::MarkDomain,
35095 mut mark: &OptionalUint32,
35096 ) -> fidl::client::QueryResponseFut<
35097 BaseSocketSetMarkResult,
35098 fidl::encoding::DefaultFuchsiaResourceDialect,
35099 > {
35100 DatagramSocketProxyInterface::r#set_mark(self, domain, mark)
35101 }
35102
35103 pub fn r#get_mark(
35107 &self,
35108 mut domain: fidl_fuchsia_net::MarkDomain,
35109 ) -> fidl::client::QueryResponseFut<
35110 BaseSocketGetMarkResult,
35111 fidl::encoding::DefaultFuchsiaResourceDialect,
35112 > {
35113 DatagramSocketProxyInterface::r#get_mark(self, domain)
35114 }
35115
35116 pub fn r#bind(
35118 &self,
35119 mut addr: &fidl_fuchsia_net::SocketAddress,
35120 ) -> fidl::client::QueryResponseFut<
35121 BaseNetworkSocketBindResult,
35122 fidl::encoding::DefaultFuchsiaResourceDialect,
35123 > {
35124 DatagramSocketProxyInterface::r#bind(self, addr)
35125 }
35126
35127 pub fn r#connect(
35129 &self,
35130 mut addr: &fidl_fuchsia_net::SocketAddress,
35131 ) -> fidl::client::QueryResponseFut<
35132 BaseNetworkSocketConnectResult,
35133 fidl::encoding::DefaultFuchsiaResourceDialect,
35134 > {
35135 DatagramSocketProxyInterface::r#connect(self, addr)
35136 }
35137
35138 pub fn r#disconnect(
35140 &self,
35141 ) -> fidl::client::QueryResponseFut<
35142 BaseNetworkSocketDisconnectResult,
35143 fidl::encoding::DefaultFuchsiaResourceDialect,
35144 > {
35145 DatagramSocketProxyInterface::r#disconnect(self)
35146 }
35147
35148 pub fn r#get_sock_name(
35150 &self,
35151 ) -> fidl::client::QueryResponseFut<
35152 BaseNetworkSocketGetSockNameResult,
35153 fidl::encoding::DefaultFuchsiaResourceDialect,
35154 > {
35155 DatagramSocketProxyInterface::r#get_sock_name(self)
35156 }
35157
35158 pub fn r#get_peer_name(
35160 &self,
35161 ) -> fidl::client::QueryResponseFut<
35162 BaseNetworkSocketGetPeerNameResult,
35163 fidl::encoding::DefaultFuchsiaResourceDialect,
35164 > {
35165 DatagramSocketProxyInterface::r#get_peer_name(self)
35166 }
35167
35168 pub fn r#shutdown(
35170 &self,
35171 mut mode: ShutdownMode,
35172 ) -> fidl::client::QueryResponseFut<
35173 BaseNetworkSocketShutdownResult,
35174 fidl::encoding::DefaultFuchsiaResourceDialect,
35175 > {
35176 DatagramSocketProxyInterface::r#shutdown(self, mode)
35177 }
35178
35179 pub fn r#set_ip_type_of_service(
35181 &self,
35182 mut value: u8,
35183 ) -> fidl::client::QueryResponseFut<
35184 BaseNetworkSocketSetIpTypeOfServiceResult,
35185 fidl::encoding::DefaultFuchsiaResourceDialect,
35186 > {
35187 DatagramSocketProxyInterface::r#set_ip_type_of_service(self, value)
35188 }
35189
35190 pub fn r#get_ip_type_of_service(
35192 &self,
35193 ) -> fidl::client::QueryResponseFut<
35194 BaseNetworkSocketGetIpTypeOfServiceResult,
35195 fidl::encoding::DefaultFuchsiaResourceDialect,
35196 > {
35197 DatagramSocketProxyInterface::r#get_ip_type_of_service(self)
35198 }
35199
35200 pub fn r#set_ip_ttl(
35202 &self,
35203 mut value: &OptionalUint8,
35204 ) -> fidl::client::QueryResponseFut<
35205 BaseNetworkSocketSetIpTtlResult,
35206 fidl::encoding::DefaultFuchsiaResourceDialect,
35207 > {
35208 DatagramSocketProxyInterface::r#set_ip_ttl(self, value)
35209 }
35210
35211 pub fn r#get_ip_ttl(
35213 &self,
35214 ) -> fidl::client::QueryResponseFut<
35215 BaseNetworkSocketGetIpTtlResult,
35216 fidl::encoding::DefaultFuchsiaResourceDialect,
35217 > {
35218 DatagramSocketProxyInterface::r#get_ip_ttl(self)
35219 }
35220
35221 pub fn r#set_ip_packet_info(
35223 &self,
35224 mut value: bool,
35225 ) -> fidl::client::QueryResponseFut<
35226 BaseNetworkSocketSetIpPacketInfoResult,
35227 fidl::encoding::DefaultFuchsiaResourceDialect,
35228 > {
35229 DatagramSocketProxyInterface::r#set_ip_packet_info(self, value)
35230 }
35231
35232 pub fn r#get_ip_packet_info(
35234 &self,
35235 ) -> fidl::client::QueryResponseFut<
35236 BaseNetworkSocketGetIpPacketInfoResult,
35237 fidl::encoding::DefaultFuchsiaResourceDialect,
35238 > {
35239 DatagramSocketProxyInterface::r#get_ip_packet_info(self)
35240 }
35241
35242 pub fn r#set_ip_receive_type_of_service(
35244 &self,
35245 mut value: bool,
35246 ) -> fidl::client::QueryResponseFut<
35247 BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
35248 fidl::encoding::DefaultFuchsiaResourceDialect,
35249 > {
35250 DatagramSocketProxyInterface::r#set_ip_receive_type_of_service(self, value)
35251 }
35252
35253 pub fn r#get_ip_receive_type_of_service(
35255 &self,
35256 ) -> fidl::client::QueryResponseFut<
35257 BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
35258 fidl::encoding::DefaultFuchsiaResourceDialect,
35259 > {
35260 DatagramSocketProxyInterface::r#get_ip_receive_type_of_service(self)
35261 }
35262
35263 pub fn r#set_ip_receive_ttl(
35265 &self,
35266 mut value: bool,
35267 ) -> fidl::client::QueryResponseFut<
35268 BaseNetworkSocketSetIpReceiveTtlResult,
35269 fidl::encoding::DefaultFuchsiaResourceDialect,
35270 > {
35271 DatagramSocketProxyInterface::r#set_ip_receive_ttl(self, value)
35272 }
35273
35274 pub fn r#get_ip_receive_ttl(
35276 &self,
35277 ) -> fidl::client::QueryResponseFut<
35278 BaseNetworkSocketGetIpReceiveTtlResult,
35279 fidl::encoding::DefaultFuchsiaResourceDialect,
35280 > {
35281 DatagramSocketProxyInterface::r#get_ip_receive_ttl(self)
35282 }
35283
35284 pub fn r#set_ip_multicast_interface(
35286 &self,
35287 mut iface: u64,
35288 mut address: &fidl_fuchsia_net::Ipv4Address,
35289 ) -> fidl::client::QueryResponseFut<
35290 BaseNetworkSocketSetIpMulticastInterfaceResult,
35291 fidl::encoding::DefaultFuchsiaResourceDialect,
35292 > {
35293 DatagramSocketProxyInterface::r#set_ip_multicast_interface(self, iface, address)
35294 }
35295
35296 pub fn r#get_ip_multicast_interface(
35298 &self,
35299 ) -> fidl::client::QueryResponseFut<
35300 BaseNetworkSocketGetIpMulticastInterfaceResult,
35301 fidl::encoding::DefaultFuchsiaResourceDialect,
35302 > {
35303 DatagramSocketProxyInterface::r#get_ip_multicast_interface(self)
35304 }
35305
35306 pub fn r#set_ip_multicast_ttl(
35308 &self,
35309 mut value: &OptionalUint8,
35310 ) -> fidl::client::QueryResponseFut<
35311 BaseNetworkSocketSetIpMulticastTtlResult,
35312 fidl::encoding::DefaultFuchsiaResourceDialect,
35313 > {
35314 DatagramSocketProxyInterface::r#set_ip_multicast_ttl(self, value)
35315 }
35316
35317 pub fn r#get_ip_multicast_ttl(
35319 &self,
35320 ) -> fidl::client::QueryResponseFut<
35321 BaseNetworkSocketGetIpMulticastTtlResult,
35322 fidl::encoding::DefaultFuchsiaResourceDialect,
35323 > {
35324 DatagramSocketProxyInterface::r#get_ip_multicast_ttl(self)
35325 }
35326
35327 pub fn r#set_ip_multicast_loopback(
35329 &self,
35330 mut value: bool,
35331 ) -> fidl::client::QueryResponseFut<
35332 BaseNetworkSocketSetIpMulticastLoopbackResult,
35333 fidl::encoding::DefaultFuchsiaResourceDialect,
35334 > {
35335 DatagramSocketProxyInterface::r#set_ip_multicast_loopback(self, value)
35336 }
35337
35338 pub fn r#get_ip_multicast_loopback(
35340 &self,
35341 ) -> fidl::client::QueryResponseFut<
35342 BaseNetworkSocketGetIpMulticastLoopbackResult,
35343 fidl::encoding::DefaultFuchsiaResourceDialect,
35344 > {
35345 DatagramSocketProxyInterface::r#get_ip_multicast_loopback(self)
35346 }
35347
35348 pub fn r#add_ip_membership(
35350 &self,
35351 mut membership: &IpMulticastMembership,
35352 ) -> fidl::client::QueryResponseFut<
35353 BaseNetworkSocketAddIpMembershipResult,
35354 fidl::encoding::DefaultFuchsiaResourceDialect,
35355 > {
35356 DatagramSocketProxyInterface::r#add_ip_membership(self, membership)
35357 }
35358
35359 pub fn r#drop_ip_membership(
35361 &self,
35362 mut membership: &IpMulticastMembership,
35363 ) -> fidl::client::QueryResponseFut<
35364 BaseNetworkSocketDropIpMembershipResult,
35365 fidl::encoding::DefaultFuchsiaResourceDialect,
35366 > {
35367 DatagramSocketProxyInterface::r#drop_ip_membership(self, membership)
35368 }
35369
35370 pub fn r#set_ip_transparent(
35372 &self,
35373 mut value: bool,
35374 ) -> fidl::client::QueryResponseFut<
35375 BaseNetworkSocketSetIpTransparentResult,
35376 fidl::encoding::DefaultFuchsiaResourceDialect,
35377 > {
35378 DatagramSocketProxyInterface::r#set_ip_transparent(self, value)
35379 }
35380
35381 pub fn r#get_ip_transparent(
35383 &self,
35384 ) -> fidl::client::QueryResponseFut<
35385 BaseNetworkSocketGetIpTransparentResult,
35386 fidl::encoding::DefaultFuchsiaResourceDialect,
35387 > {
35388 DatagramSocketProxyInterface::r#get_ip_transparent(self)
35389 }
35390
35391 pub fn r#set_ip_receive_original_destination_address(
35393 &self,
35394 mut value: bool,
35395 ) -> fidl::client::QueryResponseFut<
35396 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
35397 fidl::encoding::DefaultFuchsiaResourceDialect,
35398 > {
35399 DatagramSocketProxyInterface::r#set_ip_receive_original_destination_address(self, value)
35400 }
35401
35402 pub fn r#get_ip_receive_original_destination_address(
35404 &self,
35405 ) -> fidl::client::QueryResponseFut<
35406 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
35407 fidl::encoding::DefaultFuchsiaResourceDialect,
35408 > {
35409 DatagramSocketProxyInterface::r#get_ip_receive_original_destination_address(self)
35410 }
35411
35412 pub fn r#add_ipv6_membership(
35414 &self,
35415 mut membership: &Ipv6MulticastMembership,
35416 ) -> fidl::client::QueryResponseFut<
35417 BaseNetworkSocketAddIpv6MembershipResult,
35418 fidl::encoding::DefaultFuchsiaResourceDialect,
35419 > {
35420 DatagramSocketProxyInterface::r#add_ipv6_membership(self, membership)
35421 }
35422
35423 pub fn r#drop_ipv6_membership(
35425 &self,
35426 mut membership: &Ipv6MulticastMembership,
35427 ) -> fidl::client::QueryResponseFut<
35428 BaseNetworkSocketDropIpv6MembershipResult,
35429 fidl::encoding::DefaultFuchsiaResourceDialect,
35430 > {
35431 DatagramSocketProxyInterface::r#drop_ipv6_membership(self, membership)
35432 }
35433
35434 pub fn r#set_ipv6_multicast_interface(
35436 &self,
35437 mut value: u64,
35438 ) -> fidl::client::QueryResponseFut<
35439 BaseNetworkSocketSetIpv6MulticastInterfaceResult,
35440 fidl::encoding::DefaultFuchsiaResourceDialect,
35441 > {
35442 DatagramSocketProxyInterface::r#set_ipv6_multicast_interface(self, value)
35443 }
35444
35445 pub fn r#get_ipv6_multicast_interface(
35447 &self,
35448 ) -> fidl::client::QueryResponseFut<
35449 BaseNetworkSocketGetIpv6MulticastInterfaceResult,
35450 fidl::encoding::DefaultFuchsiaResourceDialect,
35451 > {
35452 DatagramSocketProxyInterface::r#get_ipv6_multicast_interface(self)
35453 }
35454
35455 pub fn r#set_ipv6_unicast_hops(
35457 &self,
35458 mut value: &OptionalUint8,
35459 ) -> fidl::client::QueryResponseFut<
35460 BaseNetworkSocketSetIpv6UnicastHopsResult,
35461 fidl::encoding::DefaultFuchsiaResourceDialect,
35462 > {
35463 DatagramSocketProxyInterface::r#set_ipv6_unicast_hops(self, value)
35464 }
35465
35466 pub fn r#get_ipv6_unicast_hops(
35468 &self,
35469 ) -> fidl::client::QueryResponseFut<
35470 BaseNetworkSocketGetIpv6UnicastHopsResult,
35471 fidl::encoding::DefaultFuchsiaResourceDialect,
35472 > {
35473 DatagramSocketProxyInterface::r#get_ipv6_unicast_hops(self)
35474 }
35475
35476 pub fn r#set_ipv6_receive_hop_limit(
35478 &self,
35479 mut value: bool,
35480 ) -> fidl::client::QueryResponseFut<
35481 BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
35482 fidl::encoding::DefaultFuchsiaResourceDialect,
35483 > {
35484 DatagramSocketProxyInterface::r#set_ipv6_receive_hop_limit(self, value)
35485 }
35486
35487 pub fn r#get_ipv6_receive_hop_limit(
35489 &self,
35490 ) -> fidl::client::QueryResponseFut<
35491 BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
35492 fidl::encoding::DefaultFuchsiaResourceDialect,
35493 > {
35494 DatagramSocketProxyInterface::r#get_ipv6_receive_hop_limit(self)
35495 }
35496
35497 pub fn r#set_ipv6_multicast_hops(
35499 &self,
35500 mut value: &OptionalUint8,
35501 ) -> fidl::client::QueryResponseFut<
35502 BaseNetworkSocketSetIpv6MulticastHopsResult,
35503 fidl::encoding::DefaultFuchsiaResourceDialect,
35504 > {
35505 DatagramSocketProxyInterface::r#set_ipv6_multicast_hops(self, value)
35506 }
35507
35508 pub fn r#get_ipv6_multicast_hops(
35510 &self,
35511 ) -> fidl::client::QueryResponseFut<
35512 BaseNetworkSocketGetIpv6MulticastHopsResult,
35513 fidl::encoding::DefaultFuchsiaResourceDialect,
35514 > {
35515 DatagramSocketProxyInterface::r#get_ipv6_multicast_hops(self)
35516 }
35517
35518 pub fn r#set_ipv6_multicast_loopback(
35520 &self,
35521 mut value: bool,
35522 ) -> fidl::client::QueryResponseFut<
35523 BaseNetworkSocketSetIpv6MulticastLoopbackResult,
35524 fidl::encoding::DefaultFuchsiaResourceDialect,
35525 > {
35526 DatagramSocketProxyInterface::r#set_ipv6_multicast_loopback(self, value)
35527 }
35528
35529 pub fn r#get_ipv6_multicast_loopback(
35531 &self,
35532 ) -> fidl::client::QueryResponseFut<
35533 BaseNetworkSocketGetIpv6MulticastLoopbackResult,
35534 fidl::encoding::DefaultFuchsiaResourceDialect,
35535 > {
35536 DatagramSocketProxyInterface::r#get_ipv6_multicast_loopback(self)
35537 }
35538
35539 pub fn r#set_ipv6_only(
35541 &self,
35542 mut value: bool,
35543 ) -> fidl::client::QueryResponseFut<
35544 BaseNetworkSocketSetIpv6OnlyResult,
35545 fidl::encoding::DefaultFuchsiaResourceDialect,
35546 > {
35547 DatagramSocketProxyInterface::r#set_ipv6_only(self, value)
35548 }
35549
35550 pub fn r#get_ipv6_only(
35552 &self,
35553 ) -> fidl::client::QueryResponseFut<
35554 BaseNetworkSocketGetIpv6OnlyResult,
35555 fidl::encoding::DefaultFuchsiaResourceDialect,
35556 > {
35557 DatagramSocketProxyInterface::r#get_ipv6_only(self)
35558 }
35559
35560 pub fn r#set_ipv6_receive_traffic_class(
35562 &self,
35563 mut value: bool,
35564 ) -> fidl::client::QueryResponseFut<
35565 BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
35566 fidl::encoding::DefaultFuchsiaResourceDialect,
35567 > {
35568 DatagramSocketProxyInterface::r#set_ipv6_receive_traffic_class(self, value)
35569 }
35570
35571 pub fn r#get_ipv6_receive_traffic_class(
35573 &self,
35574 ) -> fidl::client::QueryResponseFut<
35575 BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
35576 fidl::encoding::DefaultFuchsiaResourceDialect,
35577 > {
35578 DatagramSocketProxyInterface::r#get_ipv6_receive_traffic_class(self)
35579 }
35580
35581 pub fn r#set_ipv6_traffic_class(
35583 &self,
35584 mut value: &OptionalUint8,
35585 ) -> fidl::client::QueryResponseFut<
35586 BaseNetworkSocketSetIpv6TrafficClassResult,
35587 fidl::encoding::DefaultFuchsiaResourceDialect,
35588 > {
35589 DatagramSocketProxyInterface::r#set_ipv6_traffic_class(self, value)
35590 }
35591
35592 pub fn r#get_ipv6_traffic_class(
35594 &self,
35595 ) -> fidl::client::QueryResponseFut<
35596 BaseNetworkSocketGetIpv6TrafficClassResult,
35597 fidl::encoding::DefaultFuchsiaResourceDialect,
35598 > {
35599 DatagramSocketProxyInterface::r#get_ipv6_traffic_class(self)
35600 }
35601
35602 pub fn r#set_ipv6_receive_packet_info(
35604 &self,
35605 mut value: bool,
35606 ) -> fidl::client::QueryResponseFut<
35607 BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
35608 fidl::encoding::DefaultFuchsiaResourceDialect,
35609 > {
35610 DatagramSocketProxyInterface::r#set_ipv6_receive_packet_info(self, value)
35611 }
35612
35613 pub fn r#get_ipv6_receive_packet_info(
35615 &self,
35616 ) -> fidl::client::QueryResponseFut<
35617 BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
35618 fidl::encoding::DefaultFuchsiaResourceDialect,
35619 > {
35620 DatagramSocketProxyInterface::r#get_ipv6_receive_packet_info(self)
35621 }
35622
35623 pub fn r#get_original_destination(
35625 &self,
35626 ) -> fidl::client::QueryResponseFut<
35627 BaseNetworkSocketGetOriginalDestinationResult,
35628 fidl::encoding::DefaultFuchsiaResourceDialect,
35629 > {
35630 DatagramSocketProxyInterface::r#get_original_destination(self)
35631 }
35632
35633 pub fn r#get_info(
35638 &self,
35639 ) -> fidl::client::QueryResponseFut<
35640 BaseDatagramSocketGetInfoResult,
35641 fidl::encoding::DefaultFuchsiaResourceDialect,
35642 > {
35643 DatagramSocketProxyInterface::r#get_info(self)
35644 }
35645
35646 pub fn r#describe(
35647 &self,
35648 ) -> fidl::client::QueryResponseFut<
35649 DatagramSocketDescribeResponse,
35650 fidl::encoding::DefaultFuchsiaResourceDialect,
35651 > {
35652 DatagramSocketProxyInterface::r#describe(self)
35653 }
35654
35655 pub fn r#send_msg_preflight(
35661 &self,
35662 mut payload: &DatagramSocketSendMsgPreflightRequest,
35663 ) -> fidl::client::QueryResponseFut<
35664 DatagramSocketSendMsgPreflightResult,
35665 fidl::encoding::DefaultFuchsiaResourceDialect,
35666 > {
35667 DatagramSocketProxyInterface::r#send_msg_preflight(self, payload)
35668 }
35669
35670 pub fn r#recv_msg_postflight(
35674 &self,
35675 ) -> fidl::client::QueryResponseFut<
35676 DatagramSocketRecvMsgPostflightResult,
35677 fidl::encoding::DefaultFuchsiaResourceDialect,
35678 > {
35679 DatagramSocketProxyInterface::r#recv_msg_postflight(self)
35680 }
35681}
35682
35683impl DatagramSocketProxyInterface for DatagramSocketProxy {
35684 fn r#clone(
35685 &self,
35686 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
35687 ) -> Result<(), fidl::Error> {
35688 self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
35689 (request,),
35690 0x20d8a7aba2168a79,
35691 fidl::encoding::DynamicFlags::empty(),
35692 )
35693 }
35694
35695 type CloseResponseFut = fidl::client::QueryResponseFut<
35696 fidl_fuchsia_unknown::CloseableCloseResult,
35697 fidl::encoding::DefaultFuchsiaResourceDialect,
35698 >;
35699 fn r#close(&self) -> Self::CloseResponseFut {
35700 fn _decode(
35701 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35702 ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
35703 let _response = fidl::client::decode_transaction_body::<
35704 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
35705 fidl::encoding::DefaultFuchsiaResourceDialect,
35706 0x5ac5d459ad7f657e,
35707 >(_buf?)?;
35708 Ok(_response.map(|x| x))
35709 }
35710 self.client.send_query_and_decode::<
35711 fidl::encoding::EmptyPayload,
35712 fidl_fuchsia_unknown::CloseableCloseResult,
35713 >(
35714 (),
35715 0x5ac5d459ad7f657e,
35716 fidl::encoding::DynamicFlags::empty(),
35717 _decode,
35718 )
35719 }
35720
35721 type QueryResponseFut =
35722 fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
35723 fn r#query(&self) -> Self::QueryResponseFut {
35724 fn _decode(
35725 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35726 ) -> Result<Vec<u8>, fidl::Error> {
35727 let _response = fidl::client::decode_transaction_body::<
35728 fidl_fuchsia_unknown::QueryableQueryResponse,
35729 fidl::encoding::DefaultFuchsiaResourceDialect,
35730 0x2658edee9decfc06,
35731 >(_buf?)?;
35732 Ok(_response.protocol)
35733 }
35734 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
35735 (),
35736 0x2658edee9decfc06,
35737 fidl::encoding::DynamicFlags::empty(),
35738 _decode,
35739 )
35740 }
35741
35742 type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
35743 BaseSocketSetReuseAddressResult,
35744 fidl::encoding::DefaultFuchsiaResourceDialect,
35745 >;
35746 fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
35747 fn _decode(
35748 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35749 ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
35750 let _response = fidl::client::decode_transaction_body::<
35751 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
35752 fidl::encoding::DefaultFuchsiaResourceDialect,
35753 0x1fd74ee8b9a4a876,
35754 >(_buf?)?;
35755 Ok(_response.map(|x| x))
35756 }
35757 self.client.send_query_and_decode::<
35758 BaseSocketSetReuseAddressRequest,
35759 BaseSocketSetReuseAddressResult,
35760 >(
35761 (value,),
35762 0x1fd74ee8b9a4a876,
35763 fidl::encoding::DynamicFlags::empty(),
35764 _decode,
35765 )
35766 }
35767
35768 type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
35769 BaseSocketGetReuseAddressResult,
35770 fidl::encoding::DefaultFuchsiaResourceDialect,
35771 >;
35772 fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
35773 fn _decode(
35774 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35775 ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
35776 let _response = fidl::client::decode_transaction_body::<
35777 fidl::encoding::ResultType<
35778 BaseSocketGetReuseAddressResponse,
35779 fidl_fuchsia_posix::Errno,
35780 >,
35781 fidl::encoding::DefaultFuchsiaResourceDialect,
35782 0x67b7206b8d1bc0a5,
35783 >(_buf?)?;
35784 Ok(_response.map(|x| x.value))
35785 }
35786 self.client
35787 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
35788 (),
35789 0x67b7206b8d1bc0a5,
35790 fidl::encoding::DynamicFlags::empty(),
35791 _decode,
35792 )
35793 }
35794
35795 type GetErrorResponseFut = fidl::client::QueryResponseFut<
35796 BaseSocketGetErrorResult,
35797 fidl::encoding::DefaultFuchsiaResourceDialect,
35798 >;
35799 fn r#get_error(&self) -> Self::GetErrorResponseFut {
35800 fn _decode(
35801 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35802 ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
35803 let _response = fidl::client::decode_transaction_body::<
35804 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
35805 fidl::encoding::DefaultFuchsiaResourceDialect,
35806 0x5aad39b33e5f6ebb,
35807 >(_buf?)?;
35808 Ok(_response.map(|x| x))
35809 }
35810 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
35811 (),
35812 0x5aad39b33e5f6ebb,
35813 fidl::encoding::DynamicFlags::empty(),
35814 _decode,
35815 )
35816 }
35817
35818 type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
35819 BaseSocketSetBroadcastResult,
35820 fidl::encoding::DefaultFuchsiaResourceDialect,
35821 >;
35822 fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
35823 fn _decode(
35824 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35825 ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
35826 let _response = fidl::client::decode_transaction_body::<
35827 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
35828 fidl::encoding::DefaultFuchsiaResourceDialect,
35829 0x6023e081ce3cd947,
35830 >(_buf?)?;
35831 Ok(_response.map(|x| x))
35832 }
35833 self.client
35834 .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
35835 (value,),
35836 0x6023e081ce3cd947,
35837 fidl::encoding::DynamicFlags::empty(),
35838 _decode,
35839 )
35840 }
35841
35842 type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
35843 BaseSocketGetBroadcastResult,
35844 fidl::encoding::DefaultFuchsiaResourceDialect,
35845 >;
35846 fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
35847 fn _decode(
35848 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35849 ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
35850 let _response = fidl::client::decode_transaction_body::<
35851 fidl::encoding::ResultType<
35852 BaseSocketGetBroadcastResponse,
35853 fidl_fuchsia_posix::Errno,
35854 >,
35855 fidl::encoding::DefaultFuchsiaResourceDialect,
35856 0x68796fc556f9780d,
35857 >(_buf?)?;
35858 Ok(_response.map(|x| x.value))
35859 }
35860 self.client
35861 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
35862 (),
35863 0x68796fc556f9780d,
35864 fidl::encoding::DynamicFlags::empty(),
35865 _decode,
35866 )
35867 }
35868
35869 type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
35870 BaseSocketSetSendBufferResult,
35871 fidl::encoding::DefaultFuchsiaResourceDialect,
35872 >;
35873 fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
35874 fn _decode(
35875 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35876 ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
35877 let _response = fidl::client::decode_transaction_body::<
35878 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
35879 fidl::encoding::DefaultFuchsiaResourceDialect,
35880 0x756eac32d73a7a70,
35881 >(_buf?)?;
35882 Ok(_response.map(|x| x))
35883 }
35884 self.client
35885 .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
35886 (value_bytes,),
35887 0x756eac32d73a7a70,
35888 fidl::encoding::DynamicFlags::empty(),
35889 _decode,
35890 )
35891 }
35892
35893 type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
35894 BaseSocketGetSendBufferResult,
35895 fidl::encoding::DefaultFuchsiaResourceDialect,
35896 >;
35897 fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
35898 fn _decode(
35899 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35900 ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
35901 let _response = fidl::client::decode_transaction_body::<
35902 fidl::encoding::ResultType<
35903 BaseSocketGetSendBufferResponse,
35904 fidl_fuchsia_posix::Errno,
35905 >,
35906 fidl::encoding::DefaultFuchsiaResourceDialect,
35907 0x78a52fd9c7b2410b,
35908 >(_buf?)?;
35909 Ok(_response.map(|x| x.value_bytes))
35910 }
35911 self.client
35912 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
35913 (),
35914 0x78a52fd9c7b2410b,
35915 fidl::encoding::DynamicFlags::empty(),
35916 _decode,
35917 )
35918 }
35919
35920 type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
35921 BaseSocketSetReceiveBufferResult,
35922 fidl::encoding::DefaultFuchsiaResourceDialect,
35923 >;
35924 fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
35925 fn _decode(
35926 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35927 ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
35928 let _response = fidl::client::decode_transaction_body::<
35929 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
35930 fidl::encoding::DefaultFuchsiaResourceDialect,
35931 0x6b0cf2f1919c7001,
35932 >(_buf?)?;
35933 Ok(_response.map(|x| x))
35934 }
35935 self.client.send_query_and_decode::<
35936 BaseSocketSetReceiveBufferRequest,
35937 BaseSocketSetReceiveBufferResult,
35938 >(
35939 (value_bytes,),
35940 0x6b0cf2f1919c7001,
35941 fidl::encoding::DynamicFlags::empty(),
35942 _decode,
35943 )
35944 }
35945
35946 type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
35947 BaseSocketGetReceiveBufferResult,
35948 fidl::encoding::DefaultFuchsiaResourceDialect,
35949 >;
35950 fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
35951 fn _decode(
35952 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35953 ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
35954 let _response = fidl::client::decode_transaction_body::<
35955 fidl::encoding::ResultType<
35956 BaseSocketGetReceiveBufferResponse,
35957 fidl_fuchsia_posix::Errno,
35958 >,
35959 fidl::encoding::DefaultFuchsiaResourceDialect,
35960 0x14c1a4b64f709e5c,
35961 >(_buf?)?;
35962 Ok(_response.map(|x| x.value_bytes))
35963 }
35964 self.client.send_query_and_decode::<
35965 fidl::encoding::EmptyPayload,
35966 BaseSocketGetReceiveBufferResult,
35967 >(
35968 (),
35969 0x14c1a4b64f709e5c,
35970 fidl::encoding::DynamicFlags::empty(),
35971 _decode,
35972 )
35973 }
35974
35975 type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
35976 BaseSocketSetKeepAliveResult,
35977 fidl::encoding::DefaultFuchsiaResourceDialect,
35978 >;
35979 fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
35980 fn _decode(
35981 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35982 ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
35983 let _response = fidl::client::decode_transaction_body::<
35984 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
35985 fidl::encoding::DefaultFuchsiaResourceDialect,
35986 0x572df8f0b920d2c7,
35987 >(_buf?)?;
35988 Ok(_response.map(|x| x))
35989 }
35990 self.client
35991 .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
35992 (value,),
35993 0x572df8f0b920d2c7,
35994 fidl::encoding::DynamicFlags::empty(),
35995 _decode,
35996 )
35997 }
35998
35999 type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
36000 BaseSocketGetKeepAliveResult,
36001 fidl::encoding::DefaultFuchsiaResourceDialect,
36002 >;
36003 fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
36004 fn _decode(
36005 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36006 ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
36007 let _response = fidl::client::decode_transaction_body::<
36008 fidl::encoding::ResultType<
36009 BaseSocketGetKeepAliveResponse,
36010 fidl_fuchsia_posix::Errno,
36011 >,
36012 fidl::encoding::DefaultFuchsiaResourceDialect,
36013 0x2dd29d3215f2c9d2,
36014 >(_buf?)?;
36015 Ok(_response.map(|x| x.value))
36016 }
36017 self.client
36018 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
36019 (),
36020 0x2dd29d3215f2c9d2,
36021 fidl::encoding::DynamicFlags::empty(),
36022 _decode,
36023 )
36024 }
36025
36026 type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
36027 BaseSocketSetOutOfBandInlineResult,
36028 fidl::encoding::DefaultFuchsiaResourceDialect,
36029 >;
36030 fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
36031 fn _decode(
36032 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36033 ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
36034 let _response = fidl::client::decode_transaction_body::<
36035 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36036 fidl::encoding::DefaultFuchsiaResourceDialect,
36037 0x3ecb49968bee439,
36038 >(_buf?)?;
36039 Ok(_response.map(|x| x))
36040 }
36041 self.client.send_query_and_decode::<
36042 BaseSocketSetOutOfBandInlineRequest,
36043 BaseSocketSetOutOfBandInlineResult,
36044 >(
36045 (value,),
36046 0x3ecb49968bee439,
36047 fidl::encoding::DynamicFlags::empty(),
36048 _decode,
36049 )
36050 }
36051
36052 type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
36053 BaseSocketGetOutOfBandInlineResult,
36054 fidl::encoding::DefaultFuchsiaResourceDialect,
36055 >;
36056 fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
36057 fn _decode(
36058 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36059 ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
36060 let _response = fidl::client::decode_transaction_body::<
36061 fidl::encoding::ResultType<
36062 BaseSocketGetOutOfBandInlineResponse,
36063 fidl_fuchsia_posix::Errno,
36064 >,
36065 fidl::encoding::DefaultFuchsiaResourceDialect,
36066 0x348c1ab3aeca1745,
36067 >(_buf?)?;
36068 Ok(_response.map(|x| x.value))
36069 }
36070 self.client.send_query_and_decode::<
36071 fidl::encoding::EmptyPayload,
36072 BaseSocketGetOutOfBandInlineResult,
36073 >(
36074 (),
36075 0x348c1ab3aeca1745,
36076 fidl::encoding::DynamicFlags::empty(),
36077 _decode,
36078 )
36079 }
36080
36081 type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
36082 BaseSocketSetNoCheckResult,
36083 fidl::encoding::DefaultFuchsiaResourceDialect,
36084 >;
36085 fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
36086 fn _decode(
36087 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36088 ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
36089 let _response = fidl::client::decode_transaction_body::<
36090 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36091 fidl::encoding::DefaultFuchsiaResourceDialect,
36092 0x6bbf00c53a4c78c2,
36093 >(_buf?)?;
36094 Ok(_response.map(|x| x))
36095 }
36096 self.client
36097 .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
36098 (value,),
36099 0x6bbf00c53a4c78c2,
36100 fidl::encoding::DynamicFlags::empty(),
36101 _decode,
36102 )
36103 }
36104
36105 type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
36106 BaseSocketGetNoCheckResult,
36107 fidl::encoding::DefaultFuchsiaResourceDialect,
36108 >;
36109 fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
36110 fn _decode(
36111 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36112 ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
36113 let _response = fidl::client::decode_transaction_body::<
36114 fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
36115 fidl::encoding::DefaultFuchsiaResourceDialect,
36116 0x2cd4249286417694,
36117 >(_buf?)?;
36118 Ok(_response.map(|x| x.value))
36119 }
36120 self.client
36121 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
36122 (),
36123 0x2cd4249286417694,
36124 fidl::encoding::DynamicFlags::empty(),
36125 _decode,
36126 )
36127 }
36128
36129 type SetLingerResponseFut = fidl::client::QueryResponseFut<
36130 BaseSocketSetLingerResult,
36131 fidl::encoding::DefaultFuchsiaResourceDialect,
36132 >;
36133 fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
36134 fn _decode(
36135 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36136 ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
36137 let _response = fidl::client::decode_transaction_body::<
36138 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36139 fidl::encoding::DefaultFuchsiaResourceDialect,
36140 0x45386351246e998e,
36141 >(_buf?)?;
36142 Ok(_response.map(|x| x))
36143 }
36144 self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
36145 (linger, length_secs),
36146 0x45386351246e998e,
36147 fidl::encoding::DynamicFlags::empty(),
36148 _decode,
36149 )
36150 }
36151
36152 type GetLingerResponseFut = fidl::client::QueryResponseFut<
36153 BaseSocketGetLingerResult,
36154 fidl::encoding::DefaultFuchsiaResourceDialect,
36155 >;
36156 fn r#get_linger(&self) -> Self::GetLingerResponseFut {
36157 fn _decode(
36158 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36159 ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
36160 let _response = fidl::client::decode_transaction_body::<
36161 fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
36162 fidl::encoding::DefaultFuchsiaResourceDialect,
36163 0x48eb20fc5ccb0e45,
36164 >(_buf?)?;
36165 Ok(_response.map(|x| (x.linger, x.length_secs)))
36166 }
36167 self.client
36168 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
36169 (),
36170 0x48eb20fc5ccb0e45,
36171 fidl::encoding::DynamicFlags::empty(),
36172 _decode,
36173 )
36174 }
36175
36176 type SetReusePortResponseFut = fidl::client::QueryResponseFut<
36177 BaseSocketSetReusePortResult,
36178 fidl::encoding::DefaultFuchsiaResourceDialect,
36179 >;
36180 fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
36181 fn _decode(
36182 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36183 ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
36184 let _response = fidl::client::decode_transaction_body::<
36185 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36186 fidl::encoding::DefaultFuchsiaResourceDialect,
36187 0x24dd3e5cb36d9ccb,
36188 >(_buf?)?;
36189 Ok(_response.map(|x| x))
36190 }
36191 self.client
36192 .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
36193 (value,),
36194 0x24dd3e5cb36d9ccb,
36195 fidl::encoding::DynamicFlags::empty(),
36196 _decode,
36197 )
36198 }
36199
36200 type GetReusePortResponseFut = fidl::client::QueryResponseFut<
36201 BaseSocketGetReusePortResult,
36202 fidl::encoding::DefaultFuchsiaResourceDialect,
36203 >;
36204 fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
36205 fn _decode(
36206 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36207 ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
36208 let _response = fidl::client::decode_transaction_body::<
36209 fidl::encoding::ResultType<
36210 BaseSocketGetReusePortResponse,
36211 fidl_fuchsia_posix::Errno,
36212 >,
36213 fidl::encoding::DefaultFuchsiaResourceDialect,
36214 0x7a112c1ab54ff828,
36215 >(_buf?)?;
36216 Ok(_response.map(|x| x.value))
36217 }
36218 self.client
36219 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
36220 (),
36221 0x7a112c1ab54ff828,
36222 fidl::encoding::DynamicFlags::empty(),
36223 _decode,
36224 )
36225 }
36226
36227 type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
36228 BaseSocketGetAcceptConnResult,
36229 fidl::encoding::DefaultFuchsiaResourceDialect,
36230 >;
36231 fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
36232 fn _decode(
36233 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36234 ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
36235 let _response = fidl::client::decode_transaction_body::<
36236 fidl::encoding::ResultType<
36237 BaseSocketGetAcceptConnResponse,
36238 fidl_fuchsia_posix::Errno,
36239 >,
36240 fidl::encoding::DefaultFuchsiaResourceDialect,
36241 0x67ce6db6c2ec8966,
36242 >(_buf?)?;
36243 Ok(_response.map(|x| x.value))
36244 }
36245 self.client
36246 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
36247 (),
36248 0x67ce6db6c2ec8966,
36249 fidl::encoding::DynamicFlags::empty(),
36250 _decode,
36251 )
36252 }
36253
36254 type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
36255 BaseSocketSetBindToDeviceResult,
36256 fidl::encoding::DefaultFuchsiaResourceDialect,
36257 >;
36258 fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
36259 fn _decode(
36260 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36261 ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
36262 let _response = fidl::client::decode_transaction_body::<
36263 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36264 fidl::encoding::DefaultFuchsiaResourceDialect,
36265 0x2118b483f28aafc4,
36266 >(_buf?)?;
36267 Ok(_response.map(|x| x))
36268 }
36269 self.client.send_query_and_decode::<
36270 BaseSocketSetBindToDeviceRequest,
36271 BaseSocketSetBindToDeviceResult,
36272 >(
36273 (value,),
36274 0x2118b483f28aafc4,
36275 fidl::encoding::DynamicFlags::empty(),
36276 _decode,
36277 )
36278 }
36279
36280 type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
36281 BaseSocketGetBindToDeviceResult,
36282 fidl::encoding::DefaultFuchsiaResourceDialect,
36283 >;
36284 fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
36285 fn _decode(
36286 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36287 ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
36288 let _response = fidl::client::decode_transaction_body::<
36289 fidl::encoding::ResultType<
36290 BaseSocketGetBindToDeviceResponse,
36291 fidl_fuchsia_posix::Errno,
36292 >,
36293 fidl::encoding::DefaultFuchsiaResourceDialect,
36294 0x1ab1fbf0ef7906c8,
36295 >(_buf?)?;
36296 Ok(_response.map(|x| x.value))
36297 }
36298 self.client
36299 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
36300 (),
36301 0x1ab1fbf0ef7906c8,
36302 fidl::encoding::DynamicFlags::empty(),
36303 _decode,
36304 )
36305 }
36306
36307 type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
36308 BaseSocketSetBindToInterfaceIndexResult,
36309 fidl::encoding::DefaultFuchsiaResourceDialect,
36310 >;
36311 fn r#set_bind_to_interface_index(
36312 &self,
36313 mut value: u64,
36314 ) -> Self::SetBindToInterfaceIndexResponseFut {
36315 fn _decode(
36316 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36317 ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
36318 let _response = fidl::client::decode_transaction_body::<
36319 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36320 fidl::encoding::DefaultFuchsiaResourceDialect,
36321 0x6e387a0def00821,
36322 >(_buf?)?;
36323 Ok(_response.map(|x| x))
36324 }
36325 self.client.send_query_and_decode::<
36326 BaseSocketSetBindToInterfaceIndexRequest,
36327 BaseSocketSetBindToInterfaceIndexResult,
36328 >(
36329 (value,),
36330 0x6e387a0def00821,
36331 fidl::encoding::DynamicFlags::empty(),
36332 _decode,
36333 )
36334 }
36335
36336 type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
36337 BaseSocketGetBindToInterfaceIndexResult,
36338 fidl::encoding::DefaultFuchsiaResourceDialect,
36339 >;
36340 fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
36341 fn _decode(
36342 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36343 ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
36344 let _response = fidl::client::decode_transaction_body::<
36345 fidl::encoding::ResultType<
36346 BaseSocketGetBindToInterfaceIndexResponse,
36347 fidl_fuchsia_posix::Errno,
36348 >,
36349 fidl::encoding::DefaultFuchsiaResourceDialect,
36350 0x59c31dd3e3078295,
36351 >(_buf?)?;
36352 Ok(_response.map(|x| x.value))
36353 }
36354 self.client.send_query_and_decode::<
36355 fidl::encoding::EmptyPayload,
36356 BaseSocketGetBindToInterfaceIndexResult,
36357 >(
36358 (),
36359 0x59c31dd3e3078295,
36360 fidl::encoding::DynamicFlags::empty(),
36361 _decode,
36362 )
36363 }
36364
36365 type SetTimestampResponseFut = fidl::client::QueryResponseFut<
36366 BaseSocketSetTimestampResult,
36367 fidl::encoding::DefaultFuchsiaResourceDialect,
36368 >;
36369 fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
36370 fn _decode(
36371 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36372 ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
36373 let _response = fidl::client::decode_transaction_body::<
36374 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36375 fidl::encoding::DefaultFuchsiaResourceDialect,
36376 0x285d6516c263d839,
36377 >(_buf?)?;
36378 Ok(_response.map(|x| x))
36379 }
36380 self.client
36381 .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
36382 (value,),
36383 0x285d6516c263d839,
36384 fidl::encoding::DynamicFlags::empty(),
36385 _decode,
36386 )
36387 }
36388
36389 type GetTimestampResponseFut = fidl::client::QueryResponseFut<
36390 BaseSocketGetTimestampResult,
36391 fidl::encoding::DefaultFuchsiaResourceDialect,
36392 >;
36393 fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
36394 fn _decode(
36395 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36396 ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
36397 let _response = fidl::client::decode_transaction_body::<
36398 fidl::encoding::ResultType<
36399 BaseSocketGetTimestampResponse,
36400 fidl_fuchsia_posix::Errno,
36401 >,
36402 fidl::encoding::DefaultFuchsiaResourceDialect,
36403 0x49f2fffbbcc2bd27,
36404 >(_buf?)?;
36405 Ok(_response.map(|x| x.value))
36406 }
36407 self.client
36408 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
36409 (),
36410 0x49f2fffbbcc2bd27,
36411 fidl::encoding::DynamicFlags::empty(),
36412 _decode,
36413 )
36414 }
36415
36416 type SetMarkResponseFut = fidl::client::QueryResponseFut<
36417 BaseSocketSetMarkResult,
36418 fidl::encoding::DefaultFuchsiaResourceDialect,
36419 >;
36420 fn r#set_mark(
36421 &self,
36422 mut domain: fidl_fuchsia_net::MarkDomain,
36423 mut mark: &OptionalUint32,
36424 ) -> Self::SetMarkResponseFut {
36425 fn _decode(
36426 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36427 ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
36428 let _response = fidl::client::decode_transaction_body::<
36429 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36430 fidl::encoding::DefaultFuchsiaResourceDialect,
36431 0x6ead6de09f653236,
36432 >(_buf?)?;
36433 Ok(_response.map(|x| x))
36434 }
36435 self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
36436 (domain, mark),
36437 0x6ead6de09f653236,
36438 fidl::encoding::DynamicFlags::empty(),
36439 _decode,
36440 )
36441 }
36442
36443 type GetMarkResponseFut = fidl::client::QueryResponseFut<
36444 BaseSocketGetMarkResult,
36445 fidl::encoding::DefaultFuchsiaResourceDialect,
36446 >;
36447 fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
36448 fn _decode(
36449 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36450 ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
36451 let _response = fidl::client::decode_transaction_body::<
36452 fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
36453 fidl::encoding::DefaultFuchsiaResourceDialect,
36454 0x57a2752c61d93d47,
36455 >(_buf?)?;
36456 Ok(_response.map(|x| x.mark))
36457 }
36458 self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
36459 (domain,),
36460 0x57a2752c61d93d47,
36461 fidl::encoding::DynamicFlags::empty(),
36462 _decode,
36463 )
36464 }
36465
36466 type BindResponseFut = fidl::client::QueryResponseFut<
36467 BaseNetworkSocketBindResult,
36468 fidl::encoding::DefaultFuchsiaResourceDialect,
36469 >;
36470 fn r#bind(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut {
36471 fn _decode(
36472 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36473 ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
36474 let _response = fidl::client::decode_transaction_body::<
36475 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36476 fidl::encoding::DefaultFuchsiaResourceDialect,
36477 0x4bc6400ae92125d,
36478 >(_buf?)?;
36479 Ok(_response.map(|x| x))
36480 }
36481 self.client
36482 .send_query_and_decode::<BaseNetworkSocketBindRequest, BaseNetworkSocketBindResult>(
36483 (addr,),
36484 0x4bc6400ae92125d,
36485 fidl::encoding::DynamicFlags::empty(),
36486 _decode,
36487 )
36488 }
36489
36490 type ConnectResponseFut = fidl::client::QueryResponseFut<
36491 BaseNetworkSocketConnectResult,
36492 fidl::encoding::DefaultFuchsiaResourceDialect,
36493 >;
36494 fn r#connect(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut {
36495 fn _decode(
36496 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36497 ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
36498 let _response = fidl::client::decode_transaction_body::<
36499 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36500 fidl::encoding::DefaultFuchsiaResourceDialect,
36501 0x5f05f19bfdd38871,
36502 >(_buf?)?;
36503 Ok(_response.map(|x| x))
36504 }
36505 self.client.send_query_and_decode::<
36506 BaseNetworkSocketConnectRequest,
36507 BaseNetworkSocketConnectResult,
36508 >(
36509 (addr,),
36510 0x5f05f19bfdd38871,
36511 fidl::encoding::DynamicFlags::empty(),
36512 _decode,
36513 )
36514 }
36515
36516 type DisconnectResponseFut = fidl::client::QueryResponseFut<
36517 BaseNetworkSocketDisconnectResult,
36518 fidl::encoding::DefaultFuchsiaResourceDialect,
36519 >;
36520 fn r#disconnect(&self) -> Self::DisconnectResponseFut {
36521 fn _decode(
36522 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36523 ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
36524 let _response = fidl::client::decode_transaction_body::<
36525 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36526 fidl::encoding::DefaultFuchsiaResourceDialect,
36527 0x74e63b91f7b29b2,
36528 >(_buf?)?;
36529 Ok(_response.map(|x| x))
36530 }
36531 self.client.send_query_and_decode::<
36532 fidl::encoding::EmptyPayload,
36533 BaseNetworkSocketDisconnectResult,
36534 >(
36535 (),
36536 0x74e63b91f7b29b2,
36537 fidl::encoding::DynamicFlags::empty(),
36538 _decode,
36539 )
36540 }
36541
36542 type GetSockNameResponseFut = fidl::client::QueryResponseFut<
36543 BaseNetworkSocketGetSockNameResult,
36544 fidl::encoding::DefaultFuchsiaResourceDialect,
36545 >;
36546 fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
36547 fn _decode(
36548 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36549 ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
36550 let _response = fidl::client::decode_transaction_body::<
36551 fidl::encoding::ResultType<
36552 BaseNetworkSocketGetSockNameResponse,
36553 fidl_fuchsia_posix::Errno,
36554 >,
36555 fidl::encoding::DefaultFuchsiaResourceDialect,
36556 0x475f23f84a1a4f85,
36557 >(_buf?)?;
36558 Ok(_response.map(|x| x.addr))
36559 }
36560 self.client.send_query_and_decode::<
36561 fidl::encoding::EmptyPayload,
36562 BaseNetworkSocketGetSockNameResult,
36563 >(
36564 (),
36565 0x475f23f84a1a4f85,
36566 fidl::encoding::DynamicFlags::empty(),
36567 _decode,
36568 )
36569 }
36570
36571 type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
36572 BaseNetworkSocketGetPeerNameResult,
36573 fidl::encoding::DefaultFuchsiaResourceDialect,
36574 >;
36575 fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
36576 fn _decode(
36577 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36578 ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
36579 let _response = fidl::client::decode_transaction_body::<
36580 fidl::encoding::ResultType<
36581 BaseNetworkSocketGetPeerNameResponse,
36582 fidl_fuchsia_posix::Errno,
36583 >,
36584 fidl::encoding::DefaultFuchsiaResourceDialect,
36585 0x1ffecf4bd5b6432e,
36586 >(_buf?)?;
36587 Ok(_response.map(|x| x.addr))
36588 }
36589 self.client.send_query_and_decode::<
36590 fidl::encoding::EmptyPayload,
36591 BaseNetworkSocketGetPeerNameResult,
36592 >(
36593 (),
36594 0x1ffecf4bd5b6432e,
36595 fidl::encoding::DynamicFlags::empty(),
36596 _decode,
36597 )
36598 }
36599
36600 type ShutdownResponseFut = fidl::client::QueryResponseFut<
36601 BaseNetworkSocketShutdownResult,
36602 fidl::encoding::DefaultFuchsiaResourceDialect,
36603 >;
36604 fn r#shutdown(&self, mut mode: ShutdownMode) -> Self::ShutdownResponseFut {
36605 fn _decode(
36606 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36607 ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
36608 let _response = fidl::client::decode_transaction_body::<
36609 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36610 fidl::encoding::DefaultFuchsiaResourceDialect,
36611 0x247f38b6db68c336,
36612 >(_buf?)?;
36613 Ok(_response.map(|x| x))
36614 }
36615 self.client.send_query_and_decode::<
36616 BaseNetworkSocketShutdownRequest,
36617 BaseNetworkSocketShutdownResult,
36618 >(
36619 (mode,),
36620 0x247f38b6db68c336,
36621 fidl::encoding::DynamicFlags::empty(),
36622 _decode,
36623 )
36624 }
36625
36626 type SetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
36627 BaseNetworkSocketSetIpTypeOfServiceResult,
36628 fidl::encoding::DefaultFuchsiaResourceDialect,
36629 >;
36630 fn r#set_ip_type_of_service(&self, mut value: u8) -> Self::SetIpTypeOfServiceResponseFut {
36631 fn _decode(
36632 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36633 ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
36634 let _response = fidl::client::decode_transaction_body::<
36635 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36636 fidl::encoding::DefaultFuchsiaResourceDialect,
36637 0x995c600475b6d46,
36638 >(_buf?)?;
36639 Ok(_response.map(|x| x))
36640 }
36641 self.client.send_query_and_decode::<
36642 BaseNetworkSocketSetIpTypeOfServiceRequest,
36643 BaseNetworkSocketSetIpTypeOfServiceResult,
36644 >(
36645 (value,),
36646 0x995c600475b6d46,
36647 fidl::encoding::DynamicFlags::empty(),
36648 _decode,
36649 )
36650 }
36651
36652 type GetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
36653 BaseNetworkSocketGetIpTypeOfServiceResult,
36654 fidl::encoding::DefaultFuchsiaResourceDialect,
36655 >;
36656 fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut {
36657 fn _decode(
36658 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36659 ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
36660 let _response = fidl::client::decode_transaction_body::<
36661 fidl::encoding::ResultType<
36662 BaseNetworkSocketGetIpTypeOfServiceResponse,
36663 fidl_fuchsia_posix::Errno,
36664 >,
36665 fidl::encoding::DefaultFuchsiaResourceDialect,
36666 0x3814a04259f75fcb,
36667 >(_buf?)?;
36668 Ok(_response.map(|x| x.value))
36669 }
36670 self.client.send_query_and_decode::<
36671 fidl::encoding::EmptyPayload,
36672 BaseNetworkSocketGetIpTypeOfServiceResult,
36673 >(
36674 (),
36675 0x3814a04259f75fcb,
36676 fidl::encoding::DynamicFlags::empty(),
36677 _decode,
36678 )
36679 }
36680
36681 type SetIpTtlResponseFut = fidl::client::QueryResponseFut<
36682 BaseNetworkSocketSetIpTtlResult,
36683 fidl::encoding::DefaultFuchsiaResourceDialect,
36684 >;
36685 fn r#set_ip_ttl(&self, mut value: &OptionalUint8) -> Self::SetIpTtlResponseFut {
36686 fn _decode(
36687 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36688 ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
36689 let _response = fidl::client::decode_transaction_body::<
36690 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36691 fidl::encoding::DefaultFuchsiaResourceDialect,
36692 0x29e2424b433ae1ef,
36693 >(_buf?)?;
36694 Ok(_response.map(|x| x))
36695 }
36696 self.client.send_query_and_decode::<
36697 BaseNetworkSocketSetIpTtlRequest,
36698 BaseNetworkSocketSetIpTtlResult,
36699 >(
36700 (value,),
36701 0x29e2424b433ae1ef,
36702 fidl::encoding::DynamicFlags::empty(),
36703 _decode,
36704 )
36705 }
36706
36707 type GetIpTtlResponseFut = fidl::client::QueryResponseFut<
36708 BaseNetworkSocketGetIpTtlResult,
36709 fidl::encoding::DefaultFuchsiaResourceDialect,
36710 >;
36711 fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut {
36712 fn _decode(
36713 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36714 ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
36715 let _response = fidl::client::decode_transaction_body::<
36716 fidl::encoding::ResultType<
36717 BaseNetworkSocketGetIpTtlResponse,
36718 fidl_fuchsia_posix::Errno,
36719 >,
36720 fidl::encoding::DefaultFuchsiaResourceDialect,
36721 0x47e47fa1f24da471,
36722 >(_buf?)?;
36723 Ok(_response.map(|x| x.value))
36724 }
36725 self.client
36726 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseNetworkSocketGetIpTtlResult>(
36727 (),
36728 0x47e47fa1f24da471,
36729 fidl::encoding::DynamicFlags::empty(),
36730 _decode,
36731 )
36732 }
36733
36734 type SetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
36735 BaseNetworkSocketSetIpPacketInfoResult,
36736 fidl::encoding::DefaultFuchsiaResourceDialect,
36737 >;
36738 fn r#set_ip_packet_info(&self, mut value: bool) -> Self::SetIpPacketInfoResponseFut {
36739 fn _decode(
36740 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36741 ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
36742 let _response = fidl::client::decode_transaction_body::<
36743 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36744 fidl::encoding::DefaultFuchsiaResourceDialect,
36745 0x392d16bee20c0e16,
36746 >(_buf?)?;
36747 Ok(_response.map(|x| x))
36748 }
36749 self.client.send_query_and_decode::<
36750 BaseNetworkSocketSetIpPacketInfoRequest,
36751 BaseNetworkSocketSetIpPacketInfoResult,
36752 >(
36753 (value,),
36754 0x392d16bee20c0e16,
36755 fidl::encoding::DynamicFlags::empty(),
36756 _decode,
36757 )
36758 }
36759
36760 type GetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
36761 BaseNetworkSocketGetIpPacketInfoResult,
36762 fidl::encoding::DefaultFuchsiaResourceDialect,
36763 >;
36764 fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut {
36765 fn _decode(
36766 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36767 ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
36768 let _response = fidl::client::decode_transaction_body::<
36769 fidl::encoding::ResultType<
36770 BaseNetworkSocketGetIpPacketInfoResponse,
36771 fidl_fuchsia_posix::Errno,
36772 >,
36773 fidl::encoding::DefaultFuchsiaResourceDialect,
36774 0x54b505f242280740,
36775 >(_buf?)?;
36776 Ok(_response.map(|x| x.value))
36777 }
36778 self.client.send_query_and_decode::<
36779 fidl::encoding::EmptyPayload,
36780 BaseNetworkSocketGetIpPacketInfoResult,
36781 >(
36782 (),
36783 0x54b505f242280740,
36784 fidl::encoding::DynamicFlags::empty(),
36785 _decode,
36786 )
36787 }
36788
36789 type SetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
36790 BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
36791 fidl::encoding::DefaultFuchsiaResourceDialect,
36792 >;
36793 fn r#set_ip_receive_type_of_service(
36794 &self,
36795 mut value: bool,
36796 ) -> Self::SetIpReceiveTypeOfServiceResponseFut {
36797 fn _decode(
36798 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36799 ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
36800 let _response = fidl::client::decode_transaction_body::<
36801 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36802 fidl::encoding::DefaultFuchsiaResourceDialect,
36803 0x6c4f6714995f84ef,
36804 >(_buf?)?;
36805 Ok(_response.map(|x| x))
36806 }
36807 self.client.send_query_and_decode::<
36808 BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
36809 BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
36810 >(
36811 (value,),
36812 0x6c4f6714995f84ef,
36813 fidl::encoding::DynamicFlags::empty(),
36814 _decode,
36815 )
36816 }
36817
36818 type GetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
36819 BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
36820 fidl::encoding::DefaultFuchsiaResourceDialect,
36821 >;
36822 fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut {
36823 fn _decode(
36824 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36825 ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
36826 let _response = fidl::client::decode_transaction_body::<
36827 fidl::encoding::ResultType<
36828 BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
36829 fidl_fuchsia_posix::Errno,
36830 >,
36831 fidl::encoding::DefaultFuchsiaResourceDialect,
36832 0x4158ba7dc2795960,
36833 >(_buf?)?;
36834 Ok(_response.map(|x| x.value))
36835 }
36836 self.client.send_query_and_decode::<
36837 fidl::encoding::EmptyPayload,
36838 BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
36839 >(
36840 (),
36841 0x4158ba7dc2795960,
36842 fidl::encoding::DynamicFlags::empty(),
36843 _decode,
36844 )
36845 }
36846
36847 type SetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
36848 BaseNetworkSocketSetIpReceiveTtlResult,
36849 fidl::encoding::DefaultFuchsiaResourceDialect,
36850 >;
36851 fn r#set_ip_receive_ttl(&self, mut value: bool) -> Self::SetIpReceiveTtlResponseFut {
36852 fn _decode(
36853 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36854 ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
36855 let _response = fidl::client::decode_transaction_body::<
36856 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36857 fidl::encoding::DefaultFuchsiaResourceDialect,
36858 0x46f15be0ce0ab82b,
36859 >(_buf?)?;
36860 Ok(_response.map(|x| x))
36861 }
36862 self.client.send_query_and_decode::<
36863 BaseNetworkSocketSetIpReceiveTtlRequest,
36864 BaseNetworkSocketSetIpReceiveTtlResult,
36865 >(
36866 (value,),
36867 0x46f15be0ce0ab82b,
36868 fidl::encoding::DynamicFlags::empty(),
36869 _decode,
36870 )
36871 }
36872
36873 type GetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
36874 BaseNetworkSocketGetIpReceiveTtlResult,
36875 fidl::encoding::DefaultFuchsiaResourceDialect,
36876 >;
36877 fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut {
36878 fn _decode(
36879 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36880 ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
36881 let _response = fidl::client::decode_transaction_body::<
36882 fidl::encoding::ResultType<
36883 BaseNetworkSocketGetIpReceiveTtlResponse,
36884 fidl_fuchsia_posix::Errno,
36885 >,
36886 fidl::encoding::DefaultFuchsiaResourceDialect,
36887 0x678ddd5a5dfa2eb5,
36888 >(_buf?)?;
36889 Ok(_response.map(|x| x.value))
36890 }
36891 self.client.send_query_and_decode::<
36892 fidl::encoding::EmptyPayload,
36893 BaseNetworkSocketGetIpReceiveTtlResult,
36894 >(
36895 (),
36896 0x678ddd5a5dfa2eb5,
36897 fidl::encoding::DynamicFlags::empty(),
36898 _decode,
36899 )
36900 }
36901
36902 type SetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
36903 BaseNetworkSocketSetIpMulticastInterfaceResult,
36904 fidl::encoding::DefaultFuchsiaResourceDialect,
36905 >;
36906 fn r#set_ip_multicast_interface(
36907 &self,
36908 mut iface: u64,
36909 mut address: &fidl_fuchsia_net::Ipv4Address,
36910 ) -> Self::SetIpMulticastInterfaceResponseFut {
36911 fn _decode(
36912 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36913 ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
36914 let _response = fidl::client::decode_transaction_body::<
36915 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36916 fidl::encoding::DefaultFuchsiaResourceDialect,
36917 0x752fbfa9b12befe,
36918 >(_buf?)?;
36919 Ok(_response.map(|x| x))
36920 }
36921 self.client.send_query_and_decode::<
36922 BaseNetworkSocketSetIpMulticastInterfaceRequest,
36923 BaseNetworkSocketSetIpMulticastInterfaceResult,
36924 >(
36925 (iface, address,),
36926 0x752fbfa9b12befe,
36927 fidl::encoding::DynamicFlags::empty(),
36928 _decode,
36929 )
36930 }
36931
36932 type GetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
36933 BaseNetworkSocketGetIpMulticastInterfaceResult,
36934 fidl::encoding::DefaultFuchsiaResourceDialect,
36935 >;
36936 fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut {
36937 fn _decode(
36938 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36939 ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
36940 let _response = fidl::client::decode_transaction_body::<
36941 fidl::encoding::ResultType<
36942 BaseNetworkSocketGetIpMulticastInterfaceResponse,
36943 fidl_fuchsia_posix::Errno,
36944 >,
36945 fidl::encoding::DefaultFuchsiaResourceDialect,
36946 0x320bd14c4df046c4,
36947 >(_buf?)?;
36948 Ok(_response.map(|x| x.value))
36949 }
36950 self.client.send_query_and_decode::<
36951 fidl::encoding::EmptyPayload,
36952 BaseNetworkSocketGetIpMulticastInterfaceResult,
36953 >(
36954 (),
36955 0x320bd14c4df046c4,
36956 fidl::encoding::DynamicFlags::empty(),
36957 _decode,
36958 )
36959 }
36960
36961 type SetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
36962 BaseNetworkSocketSetIpMulticastTtlResult,
36963 fidl::encoding::DefaultFuchsiaResourceDialect,
36964 >;
36965 fn r#set_ip_multicast_ttl(
36966 &self,
36967 mut value: &OptionalUint8,
36968 ) -> Self::SetIpMulticastTtlResponseFut {
36969 fn _decode(
36970 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36971 ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
36972 let _response = fidl::client::decode_transaction_body::<
36973 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36974 fidl::encoding::DefaultFuchsiaResourceDialect,
36975 0x63134d53772916a1,
36976 >(_buf?)?;
36977 Ok(_response.map(|x| x))
36978 }
36979 self.client.send_query_and_decode::<
36980 BaseNetworkSocketSetIpMulticastTtlRequest,
36981 BaseNetworkSocketSetIpMulticastTtlResult,
36982 >(
36983 (value,),
36984 0x63134d53772916a1,
36985 fidl::encoding::DynamicFlags::empty(),
36986 _decode,
36987 )
36988 }
36989
36990 type GetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
36991 BaseNetworkSocketGetIpMulticastTtlResult,
36992 fidl::encoding::DefaultFuchsiaResourceDialect,
36993 >;
36994 fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut {
36995 fn _decode(
36996 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36997 ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
36998 let _response = fidl::client::decode_transaction_body::<
36999 fidl::encoding::ResultType<
37000 BaseNetworkSocketGetIpMulticastTtlResponse,
37001 fidl_fuchsia_posix::Errno,
37002 >,
37003 fidl::encoding::DefaultFuchsiaResourceDialect,
37004 0x4665cd378f39e1a,
37005 >(_buf?)?;
37006 Ok(_response.map(|x| x.value))
37007 }
37008 self.client.send_query_and_decode::<
37009 fidl::encoding::EmptyPayload,
37010 BaseNetworkSocketGetIpMulticastTtlResult,
37011 >(
37012 (),
37013 0x4665cd378f39e1a,
37014 fidl::encoding::DynamicFlags::empty(),
37015 _decode,
37016 )
37017 }
37018
37019 type SetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
37020 BaseNetworkSocketSetIpMulticastLoopbackResult,
37021 fidl::encoding::DefaultFuchsiaResourceDialect,
37022 >;
37023 fn r#set_ip_multicast_loopback(
37024 &self,
37025 mut value: bool,
37026 ) -> Self::SetIpMulticastLoopbackResponseFut {
37027 fn _decode(
37028 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37029 ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
37030 let _response = fidl::client::decode_transaction_body::<
37031 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37032 fidl::encoding::DefaultFuchsiaResourceDialect,
37033 0x20c55c11f00943ea,
37034 >(_buf?)?;
37035 Ok(_response.map(|x| x))
37036 }
37037 self.client.send_query_and_decode::<
37038 BaseNetworkSocketSetIpMulticastLoopbackRequest,
37039 BaseNetworkSocketSetIpMulticastLoopbackResult,
37040 >(
37041 (value,),
37042 0x20c55c11f00943ea,
37043 fidl::encoding::DynamicFlags::empty(),
37044 _decode,
37045 )
37046 }
37047
37048 type GetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
37049 BaseNetworkSocketGetIpMulticastLoopbackResult,
37050 fidl::encoding::DefaultFuchsiaResourceDialect,
37051 >;
37052 fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut {
37053 fn _decode(
37054 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37055 ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
37056 let _response = fidl::client::decode_transaction_body::<
37057 fidl::encoding::ResultType<
37058 BaseNetworkSocketGetIpMulticastLoopbackResponse,
37059 fidl_fuchsia_posix::Errno,
37060 >,
37061 fidl::encoding::DefaultFuchsiaResourceDialect,
37062 0x3b6b26ff558298f2,
37063 >(_buf?)?;
37064 Ok(_response.map(|x| x.value))
37065 }
37066 self.client.send_query_and_decode::<
37067 fidl::encoding::EmptyPayload,
37068 BaseNetworkSocketGetIpMulticastLoopbackResult,
37069 >(
37070 (),
37071 0x3b6b26ff558298f2,
37072 fidl::encoding::DynamicFlags::empty(),
37073 _decode,
37074 )
37075 }
37076
37077 type AddIpMembershipResponseFut = fidl::client::QueryResponseFut<
37078 BaseNetworkSocketAddIpMembershipResult,
37079 fidl::encoding::DefaultFuchsiaResourceDialect,
37080 >;
37081 fn r#add_ip_membership(
37082 &self,
37083 mut membership: &IpMulticastMembership,
37084 ) -> Self::AddIpMembershipResponseFut {
37085 fn _decode(
37086 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37087 ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
37088 let _response = fidl::client::decode_transaction_body::<
37089 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37090 fidl::encoding::DefaultFuchsiaResourceDialect,
37091 0x76bc7df115a3b4d0,
37092 >(_buf?)?;
37093 Ok(_response.map(|x| x))
37094 }
37095 self.client.send_query_and_decode::<
37096 BaseNetworkSocketAddIpMembershipRequest,
37097 BaseNetworkSocketAddIpMembershipResult,
37098 >(
37099 (membership,),
37100 0x76bc7df115a3b4d0,
37101 fidl::encoding::DynamicFlags::empty(),
37102 _decode,
37103 )
37104 }
37105
37106 type DropIpMembershipResponseFut = fidl::client::QueryResponseFut<
37107 BaseNetworkSocketDropIpMembershipResult,
37108 fidl::encoding::DefaultFuchsiaResourceDialect,
37109 >;
37110 fn r#drop_ip_membership(
37111 &self,
37112 mut membership: &IpMulticastMembership,
37113 ) -> Self::DropIpMembershipResponseFut {
37114 fn _decode(
37115 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37116 ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
37117 let _response = fidl::client::decode_transaction_body::<
37118 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37119 fidl::encoding::DefaultFuchsiaResourceDialect,
37120 0x2888f3099188d03,
37121 >(_buf?)?;
37122 Ok(_response.map(|x| x))
37123 }
37124 self.client.send_query_and_decode::<
37125 BaseNetworkSocketDropIpMembershipRequest,
37126 BaseNetworkSocketDropIpMembershipResult,
37127 >(
37128 (membership,),
37129 0x2888f3099188d03,
37130 fidl::encoding::DynamicFlags::empty(),
37131 _decode,
37132 )
37133 }
37134
37135 type SetIpTransparentResponseFut = fidl::client::QueryResponseFut<
37136 BaseNetworkSocketSetIpTransparentResult,
37137 fidl::encoding::DefaultFuchsiaResourceDialect,
37138 >;
37139 fn r#set_ip_transparent(&self, mut value: bool) -> Self::SetIpTransparentResponseFut {
37140 fn _decode(
37141 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37142 ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
37143 let _response = fidl::client::decode_transaction_body::<
37144 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37145 fidl::encoding::DefaultFuchsiaResourceDialect,
37146 0x1ae532b0c066e3a0,
37147 >(_buf?)?;
37148 Ok(_response.map(|x| x))
37149 }
37150 self.client.send_query_and_decode::<
37151 BaseNetworkSocketSetIpTransparentRequest,
37152 BaseNetworkSocketSetIpTransparentResult,
37153 >(
37154 (value,),
37155 0x1ae532b0c066e3a0,
37156 fidl::encoding::DynamicFlags::empty(),
37157 _decode,
37158 )
37159 }
37160
37161 type GetIpTransparentResponseFut = fidl::client::QueryResponseFut<
37162 BaseNetworkSocketGetIpTransparentResult,
37163 fidl::encoding::DefaultFuchsiaResourceDialect,
37164 >;
37165 fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut {
37166 fn _decode(
37167 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37168 ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
37169 let _response = fidl::client::decode_transaction_body::<
37170 fidl::encoding::ResultType<
37171 BaseNetworkSocketGetIpTransparentResponse,
37172 fidl_fuchsia_posix::Errno,
37173 >,
37174 fidl::encoding::DefaultFuchsiaResourceDialect,
37175 0x51d43695962ebfb5,
37176 >(_buf?)?;
37177 Ok(_response.map(|x| x.value))
37178 }
37179 self.client.send_query_and_decode::<
37180 fidl::encoding::EmptyPayload,
37181 BaseNetworkSocketGetIpTransparentResult,
37182 >(
37183 (),
37184 0x51d43695962ebfb5,
37185 fidl::encoding::DynamicFlags::empty(),
37186 _decode,
37187 )
37188 }
37189
37190 type SetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
37191 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
37192 fidl::encoding::DefaultFuchsiaResourceDialect,
37193 >;
37194 fn r#set_ip_receive_original_destination_address(
37195 &self,
37196 mut value: bool,
37197 ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut {
37198 fn _decode(
37199 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37200 ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>
37201 {
37202 let _response = fidl::client::decode_transaction_body::<
37203 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37204 fidl::encoding::DefaultFuchsiaResourceDialect,
37205 0x4722b4ce52f7840,
37206 >(_buf?)?;
37207 Ok(_response.map(|x| x))
37208 }
37209 self.client.send_query_and_decode::<
37210 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
37211 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
37212 >(
37213 (value,),
37214 0x4722b4ce52f7840,
37215 fidl::encoding::DynamicFlags::empty(),
37216 _decode,
37217 )
37218 }
37219
37220 type GetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
37221 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
37222 fidl::encoding::DefaultFuchsiaResourceDialect,
37223 >;
37224 fn r#get_ip_receive_original_destination_address(
37225 &self,
37226 ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut {
37227 fn _decode(
37228 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37229 ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>
37230 {
37231 let _response = fidl::client::decode_transaction_body::<
37232 fidl::encoding::ResultType<
37233 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
37234 fidl_fuchsia_posix::Errno,
37235 >,
37236 fidl::encoding::DefaultFuchsiaResourceDialect,
37237 0x2a0e7dc5d6bfdfe9,
37238 >(_buf?)?;
37239 Ok(_response.map(|x| x.value))
37240 }
37241 self.client.send_query_and_decode::<
37242 fidl::encoding::EmptyPayload,
37243 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
37244 >(
37245 (),
37246 0x2a0e7dc5d6bfdfe9,
37247 fidl::encoding::DynamicFlags::empty(),
37248 _decode,
37249 )
37250 }
37251
37252 type AddIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
37253 BaseNetworkSocketAddIpv6MembershipResult,
37254 fidl::encoding::DefaultFuchsiaResourceDialect,
37255 >;
37256 fn r#add_ipv6_membership(
37257 &self,
37258 mut membership: &Ipv6MulticastMembership,
37259 ) -> Self::AddIpv6MembershipResponseFut {
37260 fn _decode(
37261 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37262 ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
37263 let _response = fidl::client::decode_transaction_body::<
37264 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37265 fidl::encoding::DefaultFuchsiaResourceDialect,
37266 0x7c94727acb4ea4b3,
37267 >(_buf?)?;
37268 Ok(_response.map(|x| x))
37269 }
37270 self.client.send_query_and_decode::<
37271 BaseNetworkSocketAddIpv6MembershipRequest,
37272 BaseNetworkSocketAddIpv6MembershipResult,
37273 >(
37274 (membership,),
37275 0x7c94727acb4ea4b3,
37276 fidl::encoding::DynamicFlags::empty(),
37277 _decode,
37278 )
37279 }
37280
37281 type DropIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
37282 BaseNetworkSocketDropIpv6MembershipResult,
37283 fidl::encoding::DefaultFuchsiaResourceDialect,
37284 >;
37285 fn r#drop_ipv6_membership(
37286 &self,
37287 mut membership: &Ipv6MulticastMembership,
37288 ) -> Self::DropIpv6MembershipResponseFut {
37289 fn _decode(
37290 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37291 ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
37292 let _response = fidl::client::decode_transaction_body::<
37293 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37294 fidl::encoding::DefaultFuchsiaResourceDialect,
37295 0x42104c70ccaba304,
37296 >(_buf?)?;
37297 Ok(_response.map(|x| x))
37298 }
37299 self.client.send_query_and_decode::<
37300 BaseNetworkSocketDropIpv6MembershipRequest,
37301 BaseNetworkSocketDropIpv6MembershipResult,
37302 >(
37303 (membership,),
37304 0x42104c70ccaba304,
37305 fidl::encoding::DynamicFlags::empty(),
37306 _decode,
37307 )
37308 }
37309
37310 type SetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
37311 BaseNetworkSocketSetIpv6MulticastInterfaceResult,
37312 fidl::encoding::DefaultFuchsiaResourceDialect,
37313 >;
37314 fn r#set_ipv6_multicast_interface(
37315 &self,
37316 mut value: u64,
37317 ) -> Self::SetIpv6MulticastInterfaceResponseFut {
37318 fn _decode(
37319 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37320 ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
37321 let _response = fidl::client::decode_transaction_body::<
37322 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37323 fidl::encoding::DefaultFuchsiaResourceDialect,
37324 0x135f76db3774ab3b,
37325 >(_buf?)?;
37326 Ok(_response.map(|x| x))
37327 }
37328 self.client.send_query_and_decode::<
37329 BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
37330 BaseNetworkSocketSetIpv6MulticastInterfaceResult,
37331 >(
37332 (value,),
37333 0x135f76db3774ab3b,
37334 fidl::encoding::DynamicFlags::empty(),
37335 _decode,
37336 )
37337 }
37338
37339 type GetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
37340 BaseNetworkSocketGetIpv6MulticastInterfaceResult,
37341 fidl::encoding::DefaultFuchsiaResourceDialect,
37342 >;
37343 fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut {
37344 fn _decode(
37345 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37346 ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
37347 let _response = fidl::client::decode_transaction_body::<
37348 fidl::encoding::ResultType<
37349 BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
37350 fidl_fuchsia_posix::Errno,
37351 >,
37352 fidl::encoding::DefaultFuchsiaResourceDialect,
37353 0x1f26fcdd348f1882,
37354 >(_buf?)?;
37355 Ok(_response.map(|x| x.value))
37356 }
37357 self.client.send_query_and_decode::<
37358 fidl::encoding::EmptyPayload,
37359 BaseNetworkSocketGetIpv6MulticastInterfaceResult,
37360 >(
37361 (),
37362 0x1f26fcdd348f1882,
37363 fidl::encoding::DynamicFlags::empty(),
37364 _decode,
37365 )
37366 }
37367
37368 type SetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
37369 BaseNetworkSocketSetIpv6UnicastHopsResult,
37370 fidl::encoding::DefaultFuchsiaResourceDialect,
37371 >;
37372 fn r#set_ipv6_unicast_hops(
37373 &self,
37374 mut value: &OptionalUint8,
37375 ) -> Self::SetIpv6UnicastHopsResponseFut {
37376 fn _decode(
37377 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37378 ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
37379 let _response = fidl::client::decode_transaction_body::<
37380 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37381 fidl::encoding::DefaultFuchsiaResourceDialect,
37382 0x157d51e98f462859,
37383 >(_buf?)?;
37384 Ok(_response.map(|x| x))
37385 }
37386 self.client.send_query_and_decode::<
37387 BaseNetworkSocketSetIpv6UnicastHopsRequest,
37388 BaseNetworkSocketSetIpv6UnicastHopsResult,
37389 >(
37390 (value,),
37391 0x157d51e98f462859,
37392 fidl::encoding::DynamicFlags::empty(),
37393 _decode,
37394 )
37395 }
37396
37397 type GetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
37398 BaseNetworkSocketGetIpv6UnicastHopsResult,
37399 fidl::encoding::DefaultFuchsiaResourceDialect,
37400 >;
37401 fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut {
37402 fn _decode(
37403 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37404 ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
37405 let _response = fidl::client::decode_transaction_body::<
37406 fidl::encoding::ResultType<
37407 BaseNetworkSocketGetIpv6UnicastHopsResponse,
37408 fidl_fuchsia_posix::Errno,
37409 >,
37410 fidl::encoding::DefaultFuchsiaResourceDialect,
37411 0x21f4641cad8bd8d2,
37412 >(_buf?)?;
37413 Ok(_response.map(|x| x.value))
37414 }
37415 self.client.send_query_and_decode::<
37416 fidl::encoding::EmptyPayload,
37417 BaseNetworkSocketGetIpv6UnicastHopsResult,
37418 >(
37419 (),
37420 0x21f4641cad8bd8d2,
37421 fidl::encoding::DynamicFlags::empty(),
37422 _decode,
37423 )
37424 }
37425
37426 type SetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
37427 BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
37428 fidl::encoding::DefaultFuchsiaResourceDialect,
37429 >;
37430 fn r#set_ipv6_receive_hop_limit(
37431 &self,
37432 mut value: bool,
37433 ) -> Self::SetIpv6ReceiveHopLimitResponseFut {
37434 fn _decode(
37435 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37436 ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
37437 let _response = fidl::client::decode_transaction_body::<
37438 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37439 fidl::encoding::DefaultFuchsiaResourceDialect,
37440 0x5c24808ed2e84a1e,
37441 >(_buf?)?;
37442 Ok(_response.map(|x| x))
37443 }
37444 self.client.send_query_and_decode::<
37445 BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
37446 BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
37447 >(
37448 (value,),
37449 0x5c24808ed2e84a1e,
37450 fidl::encoding::DynamicFlags::empty(),
37451 _decode,
37452 )
37453 }
37454
37455 type GetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
37456 BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
37457 fidl::encoding::DefaultFuchsiaResourceDialect,
37458 >;
37459 fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut {
37460 fn _decode(
37461 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37462 ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
37463 let _response = fidl::client::decode_transaction_body::<
37464 fidl::encoding::ResultType<
37465 BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
37466 fidl_fuchsia_posix::Errno,
37467 >,
37468 fidl::encoding::DefaultFuchsiaResourceDialect,
37469 0x341e06689885b4c0,
37470 >(_buf?)?;
37471 Ok(_response.map(|x| x.value))
37472 }
37473 self.client.send_query_and_decode::<
37474 fidl::encoding::EmptyPayload,
37475 BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
37476 >(
37477 (),
37478 0x341e06689885b4c0,
37479 fidl::encoding::DynamicFlags::empty(),
37480 _decode,
37481 )
37482 }
37483
37484 type SetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
37485 BaseNetworkSocketSetIpv6MulticastHopsResult,
37486 fidl::encoding::DefaultFuchsiaResourceDialect,
37487 >;
37488 fn r#set_ipv6_multicast_hops(
37489 &self,
37490 mut value: &OptionalUint8,
37491 ) -> Self::SetIpv6MulticastHopsResponseFut {
37492 fn _decode(
37493 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37494 ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
37495 let _response = fidl::client::decode_transaction_body::<
37496 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37497 fidl::encoding::DefaultFuchsiaResourceDialect,
37498 0x25b9cd4d181f82c1,
37499 >(_buf?)?;
37500 Ok(_response.map(|x| x))
37501 }
37502 self.client.send_query_and_decode::<
37503 BaseNetworkSocketSetIpv6MulticastHopsRequest,
37504 BaseNetworkSocketSetIpv6MulticastHopsResult,
37505 >(
37506 (value,),
37507 0x25b9cd4d181f82c1,
37508 fidl::encoding::DynamicFlags::empty(),
37509 _decode,
37510 )
37511 }
37512
37513 type GetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
37514 BaseNetworkSocketGetIpv6MulticastHopsResult,
37515 fidl::encoding::DefaultFuchsiaResourceDialect,
37516 >;
37517 fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut {
37518 fn _decode(
37519 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37520 ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
37521 let _response = fidl::client::decode_transaction_body::<
37522 fidl::encoding::ResultType<
37523 BaseNetworkSocketGetIpv6MulticastHopsResponse,
37524 fidl_fuchsia_posix::Errno,
37525 >,
37526 fidl::encoding::DefaultFuchsiaResourceDialect,
37527 0x52916948a365012a,
37528 >(_buf?)?;
37529 Ok(_response.map(|x| x.value))
37530 }
37531 self.client.send_query_and_decode::<
37532 fidl::encoding::EmptyPayload,
37533 BaseNetworkSocketGetIpv6MulticastHopsResult,
37534 >(
37535 (),
37536 0x52916948a365012a,
37537 fidl::encoding::DynamicFlags::empty(),
37538 _decode,
37539 )
37540 }
37541
37542 type SetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
37543 BaseNetworkSocketSetIpv6MulticastLoopbackResult,
37544 fidl::encoding::DefaultFuchsiaResourceDialect,
37545 >;
37546 fn r#set_ipv6_multicast_loopback(
37547 &self,
37548 mut value: bool,
37549 ) -> Self::SetIpv6MulticastLoopbackResponseFut {
37550 fn _decode(
37551 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37552 ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
37553 let _response = fidl::client::decode_transaction_body::<
37554 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37555 fidl::encoding::DefaultFuchsiaResourceDialect,
37556 0x55701c409ff41b40,
37557 >(_buf?)?;
37558 Ok(_response.map(|x| x))
37559 }
37560 self.client.send_query_and_decode::<
37561 BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
37562 BaseNetworkSocketSetIpv6MulticastLoopbackResult,
37563 >(
37564 (value,),
37565 0x55701c409ff41b40,
37566 fidl::encoding::DynamicFlags::empty(),
37567 _decode,
37568 )
37569 }
37570
37571 type GetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
37572 BaseNetworkSocketGetIpv6MulticastLoopbackResult,
37573 fidl::encoding::DefaultFuchsiaResourceDialect,
37574 >;
37575 fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut {
37576 fn _decode(
37577 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37578 ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
37579 let _response = fidl::client::decode_transaction_body::<
37580 fidl::encoding::ResultType<
37581 BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
37582 fidl_fuchsia_posix::Errno,
37583 >,
37584 fidl::encoding::DefaultFuchsiaResourceDialect,
37585 0x4415b701fde319c3,
37586 >(_buf?)?;
37587 Ok(_response.map(|x| x.value))
37588 }
37589 self.client.send_query_and_decode::<
37590 fidl::encoding::EmptyPayload,
37591 BaseNetworkSocketGetIpv6MulticastLoopbackResult,
37592 >(
37593 (),
37594 0x4415b701fde319c3,
37595 fidl::encoding::DynamicFlags::empty(),
37596 _decode,
37597 )
37598 }
37599
37600 type SetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
37601 BaseNetworkSocketSetIpv6OnlyResult,
37602 fidl::encoding::DefaultFuchsiaResourceDialect,
37603 >;
37604 fn r#set_ipv6_only(&self, mut value: bool) -> Self::SetIpv6OnlyResponseFut {
37605 fn _decode(
37606 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37607 ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
37608 let _response = fidl::client::decode_transaction_body::<
37609 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37610 fidl::encoding::DefaultFuchsiaResourceDialect,
37611 0x4873f1364758cbba,
37612 >(_buf?)?;
37613 Ok(_response.map(|x| x))
37614 }
37615 self.client.send_query_and_decode::<
37616 BaseNetworkSocketSetIpv6OnlyRequest,
37617 BaseNetworkSocketSetIpv6OnlyResult,
37618 >(
37619 (value,),
37620 0x4873f1364758cbba,
37621 fidl::encoding::DynamicFlags::empty(),
37622 _decode,
37623 )
37624 }
37625
37626 type GetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
37627 BaseNetworkSocketGetIpv6OnlyResult,
37628 fidl::encoding::DefaultFuchsiaResourceDialect,
37629 >;
37630 fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut {
37631 fn _decode(
37632 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37633 ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
37634 let _response = fidl::client::decode_transaction_body::<
37635 fidl::encoding::ResultType<
37636 BaseNetworkSocketGetIpv6OnlyResponse,
37637 fidl_fuchsia_posix::Errno,
37638 >,
37639 fidl::encoding::DefaultFuchsiaResourceDialect,
37640 0x4aa3340a1a26b89c,
37641 >(_buf?)?;
37642 Ok(_response.map(|x| x.value))
37643 }
37644 self.client.send_query_and_decode::<
37645 fidl::encoding::EmptyPayload,
37646 BaseNetworkSocketGetIpv6OnlyResult,
37647 >(
37648 (),
37649 0x4aa3340a1a26b89c,
37650 fidl::encoding::DynamicFlags::empty(),
37651 _decode,
37652 )
37653 }
37654
37655 type SetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
37656 BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
37657 fidl::encoding::DefaultFuchsiaResourceDialect,
37658 >;
37659 fn r#set_ipv6_receive_traffic_class(
37660 &self,
37661 mut value: bool,
37662 ) -> Self::SetIpv6ReceiveTrafficClassResponseFut {
37663 fn _decode(
37664 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37665 ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
37666 let _response = fidl::client::decode_transaction_body::<
37667 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37668 fidl::encoding::DefaultFuchsiaResourceDialect,
37669 0x58f07c8788d099a0,
37670 >(_buf?)?;
37671 Ok(_response.map(|x| x))
37672 }
37673 self.client.send_query_and_decode::<
37674 BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
37675 BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
37676 >(
37677 (value,),
37678 0x58f07c8788d099a0,
37679 fidl::encoding::DynamicFlags::empty(),
37680 _decode,
37681 )
37682 }
37683
37684 type GetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
37685 BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
37686 fidl::encoding::DefaultFuchsiaResourceDialect,
37687 >;
37688 fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut {
37689 fn _decode(
37690 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37691 ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
37692 let _response = fidl::client::decode_transaction_body::<
37693 fidl::encoding::ResultType<
37694 BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
37695 fidl_fuchsia_posix::Errno,
37696 >,
37697 fidl::encoding::DefaultFuchsiaResourceDialect,
37698 0x2e334df1da553ffa,
37699 >(_buf?)?;
37700 Ok(_response.map(|x| x.value))
37701 }
37702 self.client.send_query_and_decode::<
37703 fidl::encoding::EmptyPayload,
37704 BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
37705 >(
37706 (),
37707 0x2e334df1da553ffa,
37708 fidl::encoding::DynamicFlags::empty(),
37709 _decode,
37710 )
37711 }
37712
37713 type SetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
37714 BaseNetworkSocketSetIpv6TrafficClassResult,
37715 fidl::encoding::DefaultFuchsiaResourceDialect,
37716 >;
37717 fn r#set_ipv6_traffic_class(
37718 &self,
37719 mut value: &OptionalUint8,
37720 ) -> Self::SetIpv6TrafficClassResponseFut {
37721 fn _decode(
37722 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37723 ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
37724 let _response = fidl::client::decode_transaction_body::<
37725 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37726 fidl::encoding::DefaultFuchsiaResourceDialect,
37727 0x6af077800c5a0b4f,
37728 >(_buf?)?;
37729 Ok(_response.map(|x| x))
37730 }
37731 self.client.send_query_and_decode::<
37732 BaseNetworkSocketSetIpv6TrafficClassRequest,
37733 BaseNetworkSocketSetIpv6TrafficClassResult,
37734 >(
37735 (value,),
37736 0x6af077800c5a0b4f,
37737 fidl::encoding::DynamicFlags::empty(),
37738 _decode,
37739 )
37740 }
37741
37742 type GetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
37743 BaseNetworkSocketGetIpv6TrafficClassResult,
37744 fidl::encoding::DefaultFuchsiaResourceDialect,
37745 >;
37746 fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut {
37747 fn _decode(
37748 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37749 ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
37750 let _response = fidl::client::decode_transaction_body::<
37751 fidl::encoding::ResultType<
37752 BaseNetworkSocketGetIpv6TrafficClassResponse,
37753 fidl_fuchsia_posix::Errno,
37754 >,
37755 fidl::encoding::DefaultFuchsiaResourceDialect,
37756 0x6baf6eed8fc2f04,
37757 >(_buf?)?;
37758 Ok(_response.map(|x| x.value))
37759 }
37760 self.client.send_query_and_decode::<
37761 fidl::encoding::EmptyPayload,
37762 BaseNetworkSocketGetIpv6TrafficClassResult,
37763 >(
37764 (),
37765 0x6baf6eed8fc2f04,
37766 fidl::encoding::DynamicFlags::empty(),
37767 _decode,
37768 )
37769 }
37770
37771 type SetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
37772 BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
37773 fidl::encoding::DefaultFuchsiaResourceDialect,
37774 >;
37775 fn r#set_ipv6_receive_packet_info(
37776 &self,
37777 mut value: bool,
37778 ) -> Self::SetIpv6ReceivePacketInfoResponseFut {
37779 fn _decode(
37780 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37781 ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
37782 let _response = fidl::client::decode_transaction_body::<
37783 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37784 fidl::encoding::DefaultFuchsiaResourceDialect,
37785 0x19259775b1a92768,
37786 >(_buf?)?;
37787 Ok(_response.map(|x| x))
37788 }
37789 self.client.send_query_and_decode::<
37790 BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
37791 BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
37792 >(
37793 (value,),
37794 0x19259775b1a92768,
37795 fidl::encoding::DynamicFlags::empty(),
37796 _decode,
37797 )
37798 }
37799
37800 type GetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
37801 BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
37802 fidl::encoding::DefaultFuchsiaResourceDialect,
37803 >;
37804 fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut {
37805 fn _decode(
37806 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37807 ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
37808 let _response = fidl::client::decode_transaction_body::<
37809 fidl::encoding::ResultType<
37810 BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
37811 fidl_fuchsia_posix::Errno,
37812 >,
37813 fidl::encoding::DefaultFuchsiaResourceDialect,
37814 0x7acd4a2775baec75,
37815 >(_buf?)?;
37816 Ok(_response.map(|x| x.value))
37817 }
37818 self.client.send_query_and_decode::<
37819 fidl::encoding::EmptyPayload,
37820 BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
37821 >(
37822 (),
37823 0x7acd4a2775baec75,
37824 fidl::encoding::DynamicFlags::empty(),
37825 _decode,
37826 )
37827 }
37828
37829 type GetOriginalDestinationResponseFut = fidl::client::QueryResponseFut<
37830 BaseNetworkSocketGetOriginalDestinationResult,
37831 fidl::encoding::DefaultFuchsiaResourceDialect,
37832 >;
37833 fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut {
37834 fn _decode(
37835 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37836 ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
37837 let _response = fidl::client::decode_transaction_body::<
37838 fidl::encoding::ResultType<
37839 BaseNetworkSocketGetOriginalDestinationResponse,
37840 fidl_fuchsia_posix::Errno,
37841 >,
37842 fidl::encoding::DefaultFuchsiaResourceDialect,
37843 0x38bf28f0dafdbac0,
37844 >(_buf?)?;
37845 Ok(_response.map(|x| x.value))
37846 }
37847 self.client.send_query_and_decode::<
37848 fidl::encoding::EmptyPayload,
37849 BaseNetworkSocketGetOriginalDestinationResult,
37850 >(
37851 (),
37852 0x38bf28f0dafdbac0,
37853 fidl::encoding::DynamicFlags::empty(),
37854 _decode,
37855 )
37856 }
37857
37858 type GetInfoResponseFut = fidl::client::QueryResponseFut<
37859 BaseDatagramSocketGetInfoResult,
37860 fidl::encoding::DefaultFuchsiaResourceDialect,
37861 >;
37862 fn r#get_info(&self) -> Self::GetInfoResponseFut {
37863 fn _decode(
37864 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37865 ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
37866 let _response = fidl::client::decode_transaction_body::<
37867 fidl::encoding::ResultType<
37868 BaseDatagramSocketGetInfoResponse,
37869 fidl_fuchsia_posix::Errno,
37870 >,
37871 fidl::encoding::DefaultFuchsiaResourceDialect,
37872 0x48aa0a1f6a32d2ed,
37873 >(_buf?)?;
37874 Ok(_response.map(|x| (x.domain, x.proto)))
37875 }
37876 self.client
37877 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseDatagramSocketGetInfoResult>(
37878 (),
37879 0x48aa0a1f6a32d2ed,
37880 fidl::encoding::DynamicFlags::empty(),
37881 _decode,
37882 )
37883 }
37884
37885 type DescribeResponseFut = fidl::client::QueryResponseFut<
37886 DatagramSocketDescribeResponse,
37887 fidl::encoding::DefaultFuchsiaResourceDialect,
37888 >;
37889 fn r#describe(&self) -> Self::DescribeResponseFut {
37890 fn _decode(
37891 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37892 ) -> Result<DatagramSocketDescribeResponse, fidl::Error> {
37893 let _response = fidl::client::decode_transaction_body::<
37894 DatagramSocketDescribeResponse,
37895 fidl::encoding::DefaultFuchsiaResourceDialect,
37896 0xbf1e2f0a86601f3,
37897 >(_buf?)?;
37898 Ok(_response)
37899 }
37900 self.client
37901 .send_query_and_decode::<fidl::encoding::EmptyPayload, DatagramSocketDescribeResponse>(
37902 (),
37903 0xbf1e2f0a86601f3,
37904 fidl::encoding::DynamicFlags::empty(),
37905 _decode,
37906 )
37907 }
37908
37909 type SendMsgPreflightResponseFut = fidl::client::QueryResponseFut<
37910 DatagramSocketSendMsgPreflightResult,
37911 fidl::encoding::DefaultFuchsiaResourceDialect,
37912 >;
37913 fn r#send_msg_preflight(
37914 &self,
37915 mut payload: &DatagramSocketSendMsgPreflightRequest,
37916 ) -> Self::SendMsgPreflightResponseFut {
37917 fn _decode(
37918 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37919 ) -> Result<DatagramSocketSendMsgPreflightResult, fidl::Error> {
37920 let _response = fidl::client::decode_transaction_body::<
37921 fidl::encoding::ResultType<
37922 DatagramSocketSendMsgPreflightResponse,
37923 fidl_fuchsia_posix::Errno,
37924 >,
37925 fidl::encoding::DefaultFuchsiaResourceDialect,
37926 0x5362e668e777248a,
37927 >(_buf?)?;
37928 Ok(_response.map(|x| x))
37929 }
37930 self.client.send_query_and_decode::<
37931 DatagramSocketSendMsgPreflightRequest,
37932 DatagramSocketSendMsgPreflightResult,
37933 >(
37934 payload,
37935 0x5362e668e777248a,
37936 fidl::encoding::DynamicFlags::empty(),
37937 _decode,
37938 )
37939 }
37940
37941 type RecvMsgPostflightResponseFut = fidl::client::QueryResponseFut<
37942 DatagramSocketRecvMsgPostflightResult,
37943 fidl::encoding::DefaultFuchsiaResourceDialect,
37944 >;
37945 fn r#recv_msg_postflight(&self) -> Self::RecvMsgPostflightResponseFut {
37946 fn _decode(
37947 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37948 ) -> Result<DatagramSocketRecvMsgPostflightResult, fidl::Error> {
37949 let _response = fidl::client::decode_transaction_body::<
37950 fidl::encoding::ResultType<
37951 DatagramSocketRecvMsgPostflightResponse,
37952 fidl_fuchsia_posix::Errno,
37953 >,
37954 fidl::encoding::DefaultFuchsiaResourceDialect,
37955 0x1a7cdeca5f3eb8e2,
37956 >(_buf?)?;
37957 Ok(_response.map(|x| x))
37958 }
37959 self.client.send_query_and_decode::<
37960 fidl::encoding::EmptyPayload,
37961 DatagramSocketRecvMsgPostflightResult,
37962 >(
37963 (),
37964 0x1a7cdeca5f3eb8e2,
37965 fidl::encoding::DynamicFlags::empty(),
37966 _decode,
37967 )
37968 }
37969}
37970
37971pub struct DatagramSocketEventStream {
37972 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
37973}
37974
37975impl std::marker::Unpin for DatagramSocketEventStream {}
37976
37977impl futures::stream::FusedStream for DatagramSocketEventStream {
37978 fn is_terminated(&self) -> bool {
37979 self.event_receiver.is_terminated()
37980 }
37981}
37982
37983impl futures::Stream for DatagramSocketEventStream {
37984 type Item = Result<DatagramSocketEvent, fidl::Error>;
37985
37986 fn poll_next(
37987 mut self: std::pin::Pin<&mut Self>,
37988 cx: &mut std::task::Context<'_>,
37989 ) -> std::task::Poll<Option<Self::Item>> {
37990 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
37991 &mut self.event_receiver,
37992 cx
37993 )?) {
37994 Some(buf) => std::task::Poll::Ready(Some(DatagramSocketEvent::decode(buf))),
37995 None => std::task::Poll::Ready(None),
37996 }
37997 }
37998}
37999
38000#[derive(Debug)]
38001pub enum DatagramSocketEvent {}
38002
38003impl DatagramSocketEvent {
38004 fn decode(
38006 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
38007 ) -> Result<DatagramSocketEvent, fidl::Error> {
38008 let (bytes, _handles) = buf.split_mut();
38009 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
38010 debug_assert_eq!(tx_header.tx_id, 0);
38011 match tx_header.ordinal {
38012 _ => Err(fidl::Error::UnknownOrdinal {
38013 ordinal: tx_header.ordinal,
38014 protocol_name:
38015 <DatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
38016 }),
38017 }
38018 }
38019}
38020
38021pub struct DatagramSocketRequestStream {
38023 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
38024 is_terminated: bool,
38025}
38026
38027impl std::marker::Unpin for DatagramSocketRequestStream {}
38028
38029impl futures::stream::FusedStream for DatagramSocketRequestStream {
38030 fn is_terminated(&self) -> bool {
38031 self.is_terminated
38032 }
38033}
38034
38035impl fidl::endpoints::RequestStream for DatagramSocketRequestStream {
38036 type Protocol = DatagramSocketMarker;
38037 type ControlHandle = DatagramSocketControlHandle;
38038
38039 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
38040 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
38041 }
38042
38043 fn control_handle(&self) -> Self::ControlHandle {
38044 DatagramSocketControlHandle { inner: self.inner.clone() }
38045 }
38046
38047 fn into_inner(
38048 self,
38049 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
38050 {
38051 (self.inner, self.is_terminated)
38052 }
38053
38054 fn from_inner(
38055 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
38056 is_terminated: bool,
38057 ) -> Self {
38058 Self { inner, is_terminated }
38059 }
38060}
38061
38062impl futures::Stream for DatagramSocketRequestStream {
38063 type Item = Result<DatagramSocketRequest, fidl::Error>;
38064
38065 fn poll_next(
38066 mut self: std::pin::Pin<&mut Self>,
38067 cx: &mut std::task::Context<'_>,
38068 ) -> std::task::Poll<Option<Self::Item>> {
38069 let this = &mut *self;
38070 if this.inner.check_shutdown(cx) {
38071 this.is_terminated = true;
38072 return std::task::Poll::Ready(None);
38073 }
38074 if this.is_terminated {
38075 panic!("polled DatagramSocketRequestStream after completion");
38076 }
38077 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
38078 |bytes, handles| {
38079 match this.inner.channel().read_etc(cx, bytes, handles) {
38080 std::task::Poll::Ready(Ok(())) => {}
38081 std::task::Poll::Pending => return std::task::Poll::Pending,
38082 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
38083 this.is_terminated = true;
38084 return std::task::Poll::Ready(None);
38085 }
38086 std::task::Poll::Ready(Err(e)) => {
38087 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
38088 e.into(),
38089 ))))
38090 }
38091 }
38092
38093 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
38095
38096 std::task::Poll::Ready(Some(match header.ordinal {
38097 0x20d8a7aba2168a79 => {
38098 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
38099 let mut req = fidl::new_empty!(
38100 fidl_fuchsia_unknown::CloneableCloneRequest,
38101 fidl::encoding::DefaultFuchsiaResourceDialect
38102 );
38103 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
38104 let control_handle =
38105 DatagramSocketControlHandle { inner: this.inner.clone() };
38106 Ok(DatagramSocketRequest::Clone { request: req.request, control_handle })
38107 }
38108 0x5ac5d459ad7f657e => {
38109 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38110 let mut req = fidl::new_empty!(
38111 fidl::encoding::EmptyPayload,
38112 fidl::encoding::DefaultFuchsiaResourceDialect
38113 );
38114 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38115 let control_handle =
38116 DatagramSocketControlHandle { inner: this.inner.clone() };
38117 Ok(DatagramSocketRequest::Close {
38118 responder: DatagramSocketCloseResponder {
38119 control_handle: std::mem::ManuallyDrop::new(control_handle),
38120 tx_id: header.tx_id,
38121 },
38122 })
38123 }
38124 0x2658edee9decfc06 => {
38125 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38126 let mut req = fidl::new_empty!(
38127 fidl::encoding::EmptyPayload,
38128 fidl::encoding::DefaultFuchsiaResourceDialect
38129 );
38130 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38131 let control_handle =
38132 DatagramSocketControlHandle { inner: this.inner.clone() };
38133 Ok(DatagramSocketRequest::Query {
38134 responder: DatagramSocketQueryResponder {
38135 control_handle: std::mem::ManuallyDrop::new(control_handle),
38136 tx_id: header.tx_id,
38137 },
38138 })
38139 }
38140 0x1fd74ee8b9a4a876 => {
38141 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38142 let mut req = fidl::new_empty!(
38143 BaseSocketSetReuseAddressRequest,
38144 fidl::encoding::DefaultFuchsiaResourceDialect
38145 );
38146 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
38147 let control_handle =
38148 DatagramSocketControlHandle { inner: this.inner.clone() };
38149 Ok(DatagramSocketRequest::SetReuseAddress {
38150 value: req.value,
38151
38152 responder: DatagramSocketSetReuseAddressResponder {
38153 control_handle: std::mem::ManuallyDrop::new(control_handle),
38154 tx_id: header.tx_id,
38155 },
38156 })
38157 }
38158 0x67b7206b8d1bc0a5 => {
38159 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38160 let mut req = fidl::new_empty!(
38161 fidl::encoding::EmptyPayload,
38162 fidl::encoding::DefaultFuchsiaResourceDialect
38163 );
38164 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38165 let control_handle =
38166 DatagramSocketControlHandle { inner: this.inner.clone() };
38167 Ok(DatagramSocketRequest::GetReuseAddress {
38168 responder: DatagramSocketGetReuseAddressResponder {
38169 control_handle: std::mem::ManuallyDrop::new(control_handle),
38170 tx_id: header.tx_id,
38171 },
38172 })
38173 }
38174 0x5aad39b33e5f6ebb => {
38175 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38176 let mut req = fidl::new_empty!(
38177 fidl::encoding::EmptyPayload,
38178 fidl::encoding::DefaultFuchsiaResourceDialect
38179 );
38180 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38181 let control_handle =
38182 DatagramSocketControlHandle { inner: this.inner.clone() };
38183 Ok(DatagramSocketRequest::GetError {
38184 responder: DatagramSocketGetErrorResponder {
38185 control_handle: std::mem::ManuallyDrop::new(control_handle),
38186 tx_id: header.tx_id,
38187 },
38188 })
38189 }
38190 0x6023e081ce3cd947 => {
38191 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38192 let mut req = fidl::new_empty!(
38193 BaseSocketSetBroadcastRequest,
38194 fidl::encoding::DefaultFuchsiaResourceDialect
38195 );
38196 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
38197 let control_handle =
38198 DatagramSocketControlHandle { inner: this.inner.clone() };
38199 Ok(DatagramSocketRequest::SetBroadcast {
38200 value: req.value,
38201
38202 responder: DatagramSocketSetBroadcastResponder {
38203 control_handle: std::mem::ManuallyDrop::new(control_handle),
38204 tx_id: header.tx_id,
38205 },
38206 })
38207 }
38208 0x68796fc556f9780d => {
38209 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38210 let mut req = fidl::new_empty!(
38211 fidl::encoding::EmptyPayload,
38212 fidl::encoding::DefaultFuchsiaResourceDialect
38213 );
38214 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38215 let control_handle =
38216 DatagramSocketControlHandle { inner: this.inner.clone() };
38217 Ok(DatagramSocketRequest::GetBroadcast {
38218 responder: DatagramSocketGetBroadcastResponder {
38219 control_handle: std::mem::ManuallyDrop::new(control_handle),
38220 tx_id: header.tx_id,
38221 },
38222 })
38223 }
38224 0x756eac32d73a7a70 => {
38225 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38226 let mut req = fidl::new_empty!(
38227 BaseSocketSetSendBufferRequest,
38228 fidl::encoding::DefaultFuchsiaResourceDialect
38229 );
38230 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
38231 let control_handle =
38232 DatagramSocketControlHandle { inner: this.inner.clone() };
38233 Ok(DatagramSocketRequest::SetSendBuffer {
38234 value_bytes: req.value_bytes,
38235
38236 responder: DatagramSocketSetSendBufferResponder {
38237 control_handle: std::mem::ManuallyDrop::new(control_handle),
38238 tx_id: header.tx_id,
38239 },
38240 })
38241 }
38242 0x78a52fd9c7b2410b => {
38243 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38244 let mut req = fidl::new_empty!(
38245 fidl::encoding::EmptyPayload,
38246 fidl::encoding::DefaultFuchsiaResourceDialect
38247 );
38248 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38249 let control_handle =
38250 DatagramSocketControlHandle { inner: this.inner.clone() };
38251 Ok(DatagramSocketRequest::GetSendBuffer {
38252 responder: DatagramSocketGetSendBufferResponder {
38253 control_handle: std::mem::ManuallyDrop::new(control_handle),
38254 tx_id: header.tx_id,
38255 },
38256 })
38257 }
38258 0x6b0cf2f1919c7001 => {
38259 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38260 let mut req = fidl::new_empty!(
38261 BaseSocketSetReceiveBufferRequest,
38262 fidl::encoding::DefaultFuchsiaResourceDialect
38263 );
38264 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
38265 let control_handle =
38266 DatagramSocketControlHandle { inner: this.inner.clone() };
38267 Ok(DatagramSocketRequest::SetReceiveBuffer {
38268 value_bytes: req.value_bytes,
38269
38270 responder: DatagramSocketSetReceiveBufferResponder {
38271 control_handle: std::mem::ManuallyDrop::new(control_handle),
38272 tx_id: header.tx_id,
38273 },
38274 })
38275 }
38276 0x14c1a4b64f709e5c => {
38277 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38278 let mut req = fidl::new_empty!(
38279 fidl::encoding::EmptyPayload,
38280 fidl::encoding::DefaultFuchsiaResourceDialect
38281 );
38282 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38283 let control_handle =
38284 DatagramSocketControlHandle { inner: this.inner.clone() };
38285 Ok(DatagramSocketRequest::GetReceiveBuffer {
38286 responder: DatagramSocketGetReceiveBufferResponder {
38287 control_handle: std::mem::ManuallyDrop::new(control_handle),
38288 tx_id: header.tx_id,
38289 },
38290 })
38291 }
38292 0x572df8f0b920d2c7 => {
38293 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38294 let mut req = fidl::new_empty!(
38295 BaseSocketSetKeepAliveRequest,
38296 fidl::encoding::DefaultFuchsiaResourceDialect
38297 );
38298 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
38299 let control_handle =
38300 DatagramSocketControlHandle { inner: this.inner.clone() };
38301 Ok(DatagramSocketRequest::SetKeepAlive {
38302 value: req.value,
38303
38304 responder: DatagramSocketSetKeepAliveResponder {
38305 control_handle: std::mem::ManuallyDrop::new(control_handle),
38306 tx_id: header.tx_id,
38307 },
38308 })
38309 }
38310 0x2dd29d3215f2c9d2 => {
38311 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38312 let mut req = fidl::new_empty!(
38313 fidl::encoding::EmptyPayload,
38314 fidl::encoding::DefaultFuchsiaResourceDialect
38315 );
38316 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38317 let control_handle =
38318 DatagramSocketControlHandle { inner: this.inner.clone() };
38319 Ok(DatagramSocketRequest::GetKeepAlive {
38320 responder: DatagramSocketGetKeepAliveResponder {
38321 control_handle: std::mem::ManuallyDrop::new(control_handle),
38322 tx_id: header.tx_id,
38323 },
38324 })
38325 }
38326 0x3ecb49968bee439 => {
38327 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38328 let mut req = fidl::new_empty!(
38329 BaseSocketSetOutOfBandInlineRequest,
38330 fidl::encoding::DefaultFuchsiaResourceDialect
38331 );
38332 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
38333 let control_handle =
38334 DatagramSocketControlHandle { inner: this.inner.clone() };
38335 Ok(DatagramSocketRequest::SetOutOfBandInline {
38336 value: req.value,
38337
38338 responder: DatagramSocketSetOutOfBandInlineResponder {
38339 control_handle: std::mem::ManuallyDrop::new(control_handle),
38340 tx_id: header.tx_id,
38341 },
38342 })
38343 }
38344 0x348c1ab3aeca1745 => {
38345 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38346 let mut req = fidl::new_empty!(
38347 fidl::encoding::EmptyPayload,
38348 fidl::encoding::DefaultFuchsiaResourceDialect
38349 );
38350 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38351 let control_handle =
38352 DatagramSocketControlHandle { inner: this.inner.clone() };
38353 Ok(DatagramSocketRequest::GetOutOfBandInline {
38354 responder: DatagramSocketGetOutOfBandInlineResponder {
38355 control_handle: std::mem::ManuallyDrop::new(control_handle),
38356 tx_id: header.tx_id,
38357 },
38358 })
38359 }
38360 0x6bbf00c53a4c78c2 => {
38361 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38362 let mut req = fidl::new_empty!(
38363 BaseSocketSetNoCheckRequest,
38364 fidl::encoding::DefaultFuchsiaResourceDialect
38365 );
38366 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
38367 let control_handle =
38368 DatagramSocketControlHandle { inner: this.inner.clone() };
38369 Ok(DatagramSocketRequest::SetNoCheck {
38370 value: req.value,
38371
38372 responder: DatagramSocketSetNoCheckResponder {
38373 control_handle: std::mem::ManuallyDrop::new(control_handle),
38374 tx_id: header.tx_id,
38375 },
38376 })
38377 }
38378 0x2cd4249286417694 => {
38379 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38380 let mut req = fidl::new_empty!(
38381 fidl::encoding::EmptyPayload,
38382 fidl::encoding::DefaultFuchsiaResourceDialect
38383 );
38384 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38385 let control_handle =
38386 DatagramSocketControlHandle { inner: this.inner.clone() };
38387 Ok(DatagramSocketRequest::GetNoCheck {
38388 responder: DatagramSocketGetNoCheckResponder {
38389 control_handle: std::mem::ManuallyDrop::new(control_handle),
38390 tx_id: header.tx_id,
38391 },
38392 })
38393 }
38394 0x45386351246e998e => {
38395 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38396 let mut req = fidl::new_empty!(
38397 BaseSocketSetLingerRequest,
38398 fidl::encoding::DefaultFuchsiaResourceDialect
38399 );
38400 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
38401 let control_handle =
38402 DatagramSocketControlHandle { inner: this.inner.clone() };
38403 Ok(DatagramSocketRequest::SetLinger {
38404 linger: req.linger,
38405 length_secs: req.length_secs,
38406
38407 responder: DatagramSocketSetLingerResponder {
38408 control_handle: std::mem::ManuallyDrop::new(control_handle),
38409 tx_id: header.tx_id,
38410 },
38411 })
38412 }
38413 0x48eb20fc5ccb0e45 => {
38414 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38415 let mut req = fidl::new_empty!(
38416 fidl::encoding::EmptyPayload,
38417 fidl::encoding::DefaultFuchsiaResourceDialect
38418 );
38419 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38420 let control_handle =
38421 DatagramSocketControlHandle { inner: this.inner.clone() };
38422 Ok(DatagramSocketRequest::GetLinger {
38423 responder: DatagramSocketGetLingerResponder {
38424 control_handle: std::mem::ManuallyDrop::new(control_handle),
38425 tx_id: header.tx_id,
38426 },
38427 })
38428 }
38429 0x24dd3e5cb36d9ccb => {
38430 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38431 let mut req = fidl::new_empty!(
38432 BaseSocketSetReusePortRequest,
38433 fidl::encoding::DefaultFuchsiaResourceDialect
38434 );
38435 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
38436 let control_handle =
38437 DatagramSocketControlHandle { inner: this.inner.clone() };
38438 Ok(DatagramSocketRequest::SetReusePort {
38439 value: req.value,
38440
38441 responder: DatagramSocketSetReusePortResponder {
38442 control_handle: std::mem::ManuallyDrop::new(control_handle),
38443 tx_id: header.tx_id,
38444 },
38445 })
38446 }
38447 0x7a112c1ab54ff828 => {
38448 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38449 let mut req = fidl::new_empty!(
38450 fidl::encoding::EmptyPayload,
38451 fidl::encoding::DefaultFuchsiaResourceDialect
38452 );
38453 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38454 let control_handle =
38455 DatagramSocketControlHandle { inner: this.inner.clone() };
38456 Ok(DatagramSocketRequest::GetReusePort {
38457 responder: DatagramSocketGetReusePortResponder {
38458 control_handle: std::mem::ManuallyDrop::new(control_handle),
38459 tx_id: header.tx_id,
38460 },
38461 })
38462 }
38463 0x67ce6db6c2ec8966 => {
38464 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38465 let mut req = fidl::new_empty!(
38466 fidl::encoding::EmptyPayload,
38467 fidl::encoding::DefaultFuchsiaResourceDialect
38468 );
38469 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38470 let control_handle =
38471 DatagramSocketControlHandle { inner: this.inner.clone() };
38472 Ok(DatagramSocketRequest::GetAcceptConn {
38473 responder: DatagramSocketGetAcceptConnResponder {
38474 control_handle: std::mem::ManuallyDrop::new(control_handle),
38475 tx_id: header.tx_id,
38476 },
38477 })
38478 }
38479 0x2118b483f28aafc4 => {
38480 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38481 let mut req = fidl::new_empty!(
38482 BaseSocketSetBindToDeviceRequest,
38483 fidl::encoding::DefaultFuchsiaResourceDialect
38484 );
38485 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
38486 let control_handle =
38487 DatagramSocketControlHandle { inner: this.inner.clone() };
38488 Ok(DatagramSocketRequest::SetBindToDevice {
38489 value: req.value,
38490
38491 responder: DatagramSocketSetBindToDeviceResponder {
38492 control_handle: std::mem::ManuallyDrop::new(control_handle),
38493 tx_id: header.tx_id,
38494 },
38495 })
38496 }
38497 0x1ab1fbf0ef7906c8 => {
38498 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38499 let mut req = fidl::new_empty!(
38500 fidl::encoding::EmptyPayload,
38501 fidl::encoding::DefaultFuchsiaResourceDialect
38502 );
38503 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38504 let control_handle =
38505 DatagramSocketControlHandle { inner: this.inner.clone() };
38506 Ok(DatagramSocketRequest::GetBindToDevice {
38507 responder: DatagramSocketGetBindToDeviceResponder {
38508 control_handle: std::mem::ManuallyDrop::new(control_handle),
38509 tx_id: header.tx_id,
38510 },
38511 })
38512 }
38513 0x6e387a0def00821 => {
38514 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38515 let mut req = fidl::new_empty!(
38516 BaseSocketSetBindToInterfaceIndexRequest,
38517 fidl::encoding::DefaultFuchsiaResourceDialect
38518 );
38519 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
38520 let control_handle =
38521 DatagramSocketControlHandle { inner: this.inner.clone() };
38522 Ok(DatagramSocketRequest::SetBindToInterfaceIndex {
38523 value: req.value,
38524
38525 responder: DatagramSocketSetBindToInterfaceIndexResponder {
38526 control_handle: std::mem::ManuallyDrop::new(control_handle),
38527 tx_id: header.tx_id,
38528 },
38529 })
38530 }
38531 0x59c31dd3e3078295 => {
38532 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38533 let mut req = fidl::new_empty!(
38534 fidl::encoding::EmptyPayload,
38535 fidl::encoding::DefaultFuchsiaResourceDialect
38536 );
38537 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38538 let control_handle =
38539 DatagramSocketControlHandle { inner: this.inner.clone() };
38540 Ok(DatagramSocketRequest::GetBindToInterfaceIndex {
38541 responder: DatagramSocketGetBindToInterfaceIndexResponder {
38542 control_handle: std::mem::ManuallyDrop::new(control_handle),
38543 tx_id: header.tx_id,
38544 },
38545 })
38546 }
38547 0x285d6516c263d839 => {
38548 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38549 let mut req = fidl::new_empty!(
38550 BaseSocketSetTimestampRequest,
38551 fidl::encoding::DefaultFuchsiaResourceDialect
38552 );
38553 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
38554 let control_handle =
38555 DatagramSocketControlHandle { inner: this.inner.clone() };
38556 Ok(DatagramSocketRequest::SetTimestamp {
38557 value: req.value,
38558
38559 responder: DatagramSocketSetTimestampResponder {
38560 control_handle: std::mem::ManuallyDrop::new(control_handle),
38561 tx_id: header.tx_id,
38562 },
38563 })
38564 }
38565 0x49f2fffbbcc2bd27 => {
38566 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38567 let mut req = fidl::new_empty!(
38568 fidl::encoding::EmptyPayload,
38569 fidl::encoding::DefaultFuchsiaResourceDialect
38570 );
38571 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38572 let control_handle =
38573 DatagramSocketControlHandle { inner: this.inner.clone() };
38574 Ok(DatagramSocketRequest::GetTimestamp {
38575 responder: DatagramSocketGetTimestampResponder {
38576 control_handle: std::mem::ManuallyDrop::new(control_handle),
38577 tx_id: header.tx_id,
38578 },
38579 })
38580 }
38581 0x6ead6de09f653236 => {
38582 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38583 let mut req = fidl::new_empty!(
38584 BaseSocketSetMarkRequest,
38585 fidl::encoding::DefaultFuchsiaResourceDialect
38586 );
38587 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
38588 let control_handle =
38589 DatagramSocketControlHandle { inner: this.inner.clone() };
38590 Ok(DatagramSocketRequest::SetMark {
38591 domain: req.domain,
38592 mark: req.mark,
38593
38594 responder: DatagramSocketSetMarkResponder {
38595 control_handle: std::mem::ManuallyDrop::new(control_handle),
38596 tx_id: header.tx_id,
38597 },
38598 })
38599 }
38600 0x57a2752c61d93d47 => {
38601 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38602 let mut req = fidl::new_empty!(
38603 BaseSocketGetMarkRequest,
38604 fidl::encoding::DefaultFuchsiaResourceDialect
38605 );
38606 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
38607 let control_handle =
38608 DatagramSocketControlHandle { inner: this.inner.clone() };
38609 Ok(DatagramSocketRequest::GetMark {
38610 domain: req.domain,
38611
38612 responder: DatagramSocketGetMarkResponder {
38613 control_handle: std::mem::ManuallyDrop::new(control_handle),
38614 tx_id: header.tx_id,
38615 },
38616 })
38617 }
38618 0x4bc6400ae92125d => {
38619 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38620 let mut req = fidl::new_empty!(
38621 BaseNetworkSocketBindRequest,
38622 fidl::encoding::DefaultFuchsiaResourceDialect
38623 );
38624 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
38625 let control_handle =
38626 DatagramSocketControlHandle { inner: this.inner.clone() };
38627 Ok(DatagramSocketRequest::Bind {
38628 addr: req.addr,
38629
38630 responder: DatagramSocketBindResponder {
38631 control_handle: std::mem::ManuallyDrop::new(control_handle),
38632 tx_id: header.tx_id,
38633 },
38634 })
38635 }
38636 0x5f05f19bfdd38871 => {
38637 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38638 let mut req = fidl::new_empty!(
38639 BaseNetworkSocketConnectRequest,
38640 fidl::encoding::DefaultFuchsiaResourceDialect
38641 );
38642 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
38643 let control_handle =
38644 DatagramSocketControlHandle { inner: this.inner.clone() };
38645 Ok(DatagramSocketRequest::Connect {
38646 addr: req.addr,
38647
38648 responder: DatagramSocketConnectResponder {
38649 control_handle: std::mem::ManuallyDrop::new(control_handle),
38650 tx_id: header.tx_id,
38651 },
38652 })
38653 }
38654 0x74e63b91f7b29b2 => {
38655 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38656 let mut req = fidl::new_empty!(
38657 fidl::encoding::EmptyPayload,
38658 fidl::encoding::DefaultFuchsiaResourceDialect
38659 );
38660 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38661 let control_handle =
38662 DatagramSocketControlHandle { inner: this.inner.clone() };
38663 Ok(DatagramSocketRequest::Disconnect {
38664 responder: DatagramSocketDisconnectResponder {
38665 control_handle: std::mem::ManuallyDrop::new(control_handle),
38666 tx_id: header.tx_id,
38667 },
38668 })
38669 }
38670 0x475f23f84a1a4f85 => {
38671 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38672 let mut req = fidl::new_empty!(
38673 fidl::encoding::EmptyPayload,
38674 fidl::encoding::DefaultFuchsiaResourceDialect
38675 );
38676 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38677 let control_handle =
38678 DatagramSocketControlHandle { inner: this.inner.clone() };
38679 Ok(DatagramSocketRequest::GetSockName {
38680 responder: DatagramSocketGetSockNameResponder {
38681 control_handle: std::mem::ManuallyDrop::new(control_handle),
38682 tx_id: header.tx_id,
38683 },
38684 })
38685 }
38686 0x1ffecf4bd5b6432e => {
38687 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38688 let mut req = fidl::new_empty!(
38689 fidl::encoding::EmptyPayload,
38690 fidl::encoding::DefaultFuchsiaResourceDialect
38691 );
38692 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38693 let control_handle =
38694 DatagramSocketControlHandle { inner: this.inner.clone() };
38695 Ok(DatagramSocketRequest::GetPeerName {
38696 responder: DatagramSocketGetPeerNameResponder {
38697 control_handle: std::mem::ManuallyDrop::new(control_handle),
38698 tx_id: header.tx_id,
38699 },
38700 })
38701 }
38702 0x247f38b6db68c336 => {
38703 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38704 let mut req = fidl::new_empty!(
38705 BaseNetworkSocketShutdownRequest,
38706 fidl::encoding::DefaultFuchsiaResourceDialect
38707 );
38708 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketShutdownRequest>(&header, _body_bytes, handles, &mut req)?;
38709 let control_handle =
38710 DatagramSocketControlHandle { inner: this.inner.clone() };
38711 Ok(DatagramSocketRequest::Shutdown {
38712 mode: req.mode,
38713
38714 responder: DatagramSocketShutdownResponder {
38715 control_handle: std::mem::ManuallyDrop::new(control_handle),
38716 tx_id: header.tx_id,
38717 },
38718 })
38719 }
38720 0x995c600475b6d46 => {
38721 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38722 let mut req = fidl::new_empty!(
38723 BaseNetworkSocketSetIpTypeOfServiceRequest,
38724 fidl::encoding::DefaultFuchsiaResourceDialect
38725 );
38726 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
38727 let control_handle =
38728 DatagramSocketControlHandle { inner: this.inner.clone() };
38729 Ok(DatagramSocketRequest::SetIpTypeOfService {
38730 value: req.value,
38731
38732 responder: DatagramSocketSetIpTypeOfServiceResponder {
38733 control_handle: std::mem::ManuallyDrop::new(control_handle),
38734 tx_id: header.tx_id,
38735 },
38736 })
38737 }
38738 0x3814a04259f75fcb => {
38739 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38740 let mut req = fidl::new_empty!(
38741 fidl::encoding::EmptyPayload,
38742 fidl::encoding::DefaultFuchsiaResourceDialect
38743 );
38744 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38745 let control_handle =
38746 DatagramSocketControlHandle { inner: this.inner.clone() };
38747 Ok(DatagramSocketRequest::GetIpTypeOfService {
38748 responder: DatagramSocketGetIpTypeOfServiceResponder {
38749 control_handle: std::mem::ManuallyDrop::new(control_handle),
38750 tx_id: header.tx_id,
38751 },
38752 })
38753 }
38754 0x29e2424b433ae1ef => {
38755 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38756 let mut req = fidl::new_empty!(
38757 BaseNetworkSocketSetIpTtlRequest,
38758 fidl::encoding::DefaultFuchsiaResourceDialect
38759 );
38760 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTtlRequest>(&header, _body_bytes, handles, &mut req)?;
38761 let control_handle =
38762 DatagramSocketControlHandle { inner: this.inner.clone() };
38763 Ok(DatagramSocketRequest::SetIpTtl {
38764 value: req.value,
38765
38766 responder: DatagramSocketSetIpTtlResponder {
38767 control_handle: std::mem::ManuallyDrop::new(control_handle),
38768 tx_id: header.tx_id,
38769 },
38770 })
38771 }
38772 0x47e47fa1f24da471 => {
38773 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38774 let mut req = fidl::new_empty!(
38775 fidl::encoding::EmptyPayload,
38776 fidl::encoding::DefaultFuchsiaResourceDialect
38777 );
38778 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38779 let control_handle =
38780 DatagramSocketControlHandle { inner: this.inner.clone() };
38781 Ok(DatagramSocketRequest::GetIpTtl {
38782 responder: DatagramSocketGetIpTtlResponder {
38783 control_handle: std::mem::ManuallyDrop::new(control_handle),
38784 tx_id: header.tx_id,
38785 },
38786 })
38787 }
38788 0x392d16bee20c0e16 => {
38789 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38790 let mut req = fidl::new_empty!(
38791 BaseNetworkSocketSetIpPacketInfoRequest,
38792 fidl::encoding::DefaultFuchsiaResourceDialect
38793 );
38794 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpPacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
38795 let control_handle =
38796 DatagramSocketControlHandle { inner: this.inner.clone() };
38797 Ok(DatagramSocketRequest::SetIpPacketInfo {
38798 value: req.value,
38799
38800 responder: DatagramSocketSetIpPacketInfoResponder {
38801 control_handle: std::mem::ManuallyDrop::new(control_handle),
38802 tx_id: header.tx_id,
38803 },
38804 })
38805 }
38806 0x54b505f242280740 => {
38807 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38808 let mut req = fidl::new_empty!(
38809 fidl::encoding::EmptyPayload,
38810 fidl::encoding::DefaultFuchsiaResourceDialect
38811 );
38812 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38813 let control_handle =
38814 DatagramSocketControlHandle { inner: this.inner.clone() };
38815 Ok(DatagramSocketRequest::GetIpPacketInfo {
38816 responder: DatagramSocketGetIpPacketInfoResponder {
38817 control_handle: std::mem::ManuallyDrop::new(control_handle),
38818 tx_id: header.tx_id,
38819 },
38820 })
38821 }
38822 0x6c4f6714995f84ef => {
38823 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38824 let mut req = fidl::new_empty!(
38825 BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
38826 fidl::encoding::DefaultFuchsiaResourceDialect
38827 );
38828 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
38829 let control_handle =
38830 DatagramSocketControlHandle { inner: this.inner.clone() };
38831 Ok(DatagramSocketRequest::SetIpReceiveTypeOfService {
38832 value: req.value,
38833
38834 responder: DatagramSocketSetIpReceiveTypeOfServiceResponder {
38835 control_handle: std::mem::ManuallyDrop::new(control_handle),
38836 tx_id: header.tx_id,
38837 },
38838 })
38839 }
38840 0x4158ba7dc2795960 => {
38841 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38842 let mut req = fidl::new_empty!(
38843 fidl::encoding::EmptyPayload,
38844 fidl::encoding::DefaultFuchsiaResourceDialect
38845 );
38846 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38847 let control_handle =
38848 DatagramSocketControlHandle { inner: this.inner.clone() };
38849 Ok(DatagramSocketRequest::GetIpReceiveTypeOfService {
38850 responder: DatagramSocketGetIpReceiveTypeOfServiceResponder {
38851 control_handle: std::mem::ManuallyDrop::new(control_handle),
38852 tx_id: header.tx_id,
38853 },
38854 })
38855 }
38856 0x46f15be0ce0ab82b => {
38857 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38858 let mut req = fidl::new_empty!(
38859 BaseNetworkSocketSetIpReceiveTtlRequest,
38860 fidl::encoding::DefaultFuchsiaResourceDialect
38861 );
38862 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTtlRequest>(&header, _body_bytes, handles, &mut req)?;
38863 let control_handle =
38864 DatagramSocketControlHandle { inner: this.inner.clone() };
38865 Ok(DatagramSocketRequest::SetIpReceiveTtl {
38866 value: req.value,
38867
38868 responder: DatagramSocketSetIpReceiveTtlResponder {
38869 control_handle: std::mem::ManuallyDrop::new(control_handle),
38870 tx_id: header.tx_id,
38871 },
38872 })
38873 }
38874 0x678ddd5a5dfa2eb5 => {
38875 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38876 let mut req = fidl::new_empty!(
38877 fidl::encoding::EmptyPayload,
38878 fidl::encoding::DefaultFuchsiaResourceDialect
38879 );
38880 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38881 let control_handle =
38882 DatagramSocketControlHandle { inner: this.inner.clone() };
38883 Ok(DatagramSocketRequest::GetIpReceiveTtl {
38884 responder: DatagramSocketGetIpReceiveTtlResponder {
38885 control_handle: std::mem::ManuallyDrop::new(control_handle),
38886 tx_id: header.tx_id,
38887 },
38888 })
38889 }
38890 0x752fbfa9b12befe => {
38891 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38892 let mut req = fidl::new_empty!(
38893 BaseNetworkSocketSetIpMulticastInterfaceRequest,
38894 fidl::encoding::DefaultFuchsiaResourceDialect
38895 );
38896 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
38897 let control_handle =
38898 DatagramSocketControlHandle { inner: this.inner.clone() };
38899 Ok(DatagramSocketRequest::SetIpMulticastInterface {
38900 iface: req.iface,
38901 address: req.address,
38902
38903 responder: DatagramSocketSetIpMulticastInterfaceResponder {
38904 control_handle: std::mem::ManuallyDrop::new(control_handle),
38905 tx_id: header.tx_id,
38906 },
38907 })
38908 }
38909 0x320bd14c4df046c4 => {
38910 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38911 let mut req = fidl::new_empty!(
38912 fidl::encoding::EmptyPayload,
38913 fidl::encoding::DefaultFuchsiaResourceDialect
38914 );
38915 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38916 let control_handle =
38917 DatagramSocketControlHandle { inner: this.inner.clone() };
38918 Ok(DatagramSocketRequest::GetIpMulticastInterface {
38919 responder: DatagramSocketGetIpMulticastInterfaceResponder {
38920 control_handle: std::mem::ManuallyDrop::new(control_handle),
38921 tx_id: header.tx_id,
38922 },
38923 })
38924 }
38925 0x63134d53772916a1 => {
38926 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38927 let mut req = fidl::new_empty!(
38928 BaseNetworkSocketSetIpMulticastTtlRequest,
38929 fidl::encoding::DefaultFuchsiaResourceDialect
38930 );
38931 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastTtlRequest>(&header, _body_bytes, handles, &mut req)?;
38932 let control_handle =
38933 DatagramSocketControlHandle { inner: this.inner.clone() };
38934 Ok(DatagramSocketRequest::SetIpMulticastTtl {
38935 value: req.value,
38936
38937 responder: DatagramSocketSetIpMulticastTtlResponder {
38938 control_handle: std::mem::ManuallyDrop::new(control_handle),
38939 tx_id: header.tx_id,
38940 },
38941 })
38942 }
38943 0x4665cd378f39e1a => {
38944 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38945 let mut req = fidl::new_empty!(
38946 fidl::encoding::EmptyPayload,
38947 fidl::encoding::DefaultFuchsiaResourceDialect
38948 );
38949 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38950 let control_handle =
38951 DatagramSocketControlHandle { inner: this.inner.clone() };
38952 Ok(DatagramSocketRequest::GetIpMulticastTtl {
38953 responder: DatagramSocketGetIpMulticastTtlResponder {
38954 control_handle: std::mem::ManuallyDrop::new(control_handle),
38955 tx_id: header.tx_id,
38956 },
38957 })
38958 }
38959 0x20c55c11f00943ea => {
38960 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38961 let mut req = fidl::new_empty!(
38962 BaseNetworkSocketSetIpMulticastLoopbackRequest,
38963 fidl::encoding::DefaultFuchsiaResourceDialect
38964 );
38965 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
38966 let control_handle =
38967 DatagramSocketControlHandle { inner: this.inner.clone() };
38968 Ok(DatagramSocketRequest::SetIpMulticastLoopback {
38969 value: req.value,
38970
38971 responder: DatagramSocketSetIpMulticastLoopbackResponder {
38972 control_handle: std::mem::ManuallyDrop::new(control_handle),
38973 tx_id: header.tx_id,
38974 },
38975 })
38976 }
38977 0x3b6b26ff558298f2 => {
38978 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38979 let mut req = fidl::new_empty!(
38980 fidl::encoding::EmptyPayload,
38981 fidl::encoding::DefaultFuchsiaResourceDialect
38982 );
38983 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38984 let control_handle =
38985 DatagramSocketControlHandle { inner: this.inner.clone() };
38986 Ok(DatagramSocketRequest::GetIpMulticastLoopback {
38987 responder: DatagramSocketGetIpMulticastLoopbackResponder {
38988 control_handle: std::mem::ManuallyDrop::new(control_handle),
38989 tx_id: header.tx_id,
38990 },
38991 })
38992 }
38993 0x76bc7df115a3b4d0 => {
38994 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38995 let mut req = fidl::new_empty!(
38996 BaseNetworkSocketAddIpMembershipRequest,
38997 fidl::encoding::DefaultFuchsiaResourceDialect
38998 );
38999 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
39000 let control_handle =
39001 DatagramSocketControlHandle { inner: this.inner.clone() };
39002 Ok(DatagramSocketRequest::AddIpMembership {
39003 membership: req.membership,
39004
39005 responder: DatagramSocketAddIpMembershipResponder {
39006 control_handle: std::mem::ManuallyDrop::new(control_handle),
39007 tx_id: header.tx_id,
39008 },
39009 })
39010 }
39011 0x2888f3099188d03 => {
39012 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39013 let mut req = fidl::new_empty!(
39014 BaseNetworkSocketDropIpMembershipRequest,
39015 fidl::encoding::DefaultFuchsiaResourceDialect
39016 );
39017 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
39018 let control_handle =
39019 DatagramSocketControlHandle { inner: this.inner.clone() };
39020 Ok(DatagramSocketRequest::DropIpMembership {
39021 membership: req.membership,
39022
39023 responder: DatagramSocketDropIpMembershipResponder {
39024 control_handle: std::mem::ManuallyDrop::new(control_handle),
39025 tx_id: header.tx_id,
39026 },
39027 })
39028 }
39029 0x1ae532b0c066e3a0 => {
39030 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39031 let mut req = fidl::new_empty!(
39032 BaseNetworkSocketSetIpTransparentRequest,
39033 fidl::encoding::DefaultFuchsiaResourceDialect
39034 );
39035 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTransparentRequest>(&header, _body_bytes, handles, &mut req)?;
39036 let control_handle =
39037 DatagramSocketControlHandle { inner: this.inner.clone() };
39038 Ok(DatagramSocketRequest::SetIpTransparent {
39039 value: req.value,
39040
39041 responder: DatagramSocketSetIpTransparentResponder {
39042 control_handle: std::mem::ManuallyDrop::new(control_handle),
39043 tx_id: header.tx_id,
39044 },
39045 })
39046 }
39047 0x51d43695962ebfb5 => {
39048 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39049 let mut req = fidl::new_empty!(
39050 fidl::encoding::EmptyPayload,
39051 fidl::encoding::DefaultFuchsiaResourceDialect
39052 );
39053 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39054 let control_handle =
39055 DatagramSocketControlHandle { inner: this.inner.clone() };
39056 Ok(DatagramSocketRequest::GetIpTransparent {
39057 responder: DatagramSocketGetIpTransparentResponder {
39058 control_handle: std::mem::ManuallyDrop::new(control_handle),
39059 tx_id: header.tx_id,
39060 },
39061 })
39062 }
39063 0x4722b4ce52f7840 => {
39064 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39065 let mut req = fidl::new_empty!(
39066 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
39067 fidl::encoding::DefaultFuchsiaResourceDialect
39068 );
39069 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest>(&header, _body_bytes, handles, &mut req)?;
39070 let control_handle =
39071 DatagramSocketControlHandle { inner: this.inner.clone() };
39072 Ok(DatagramSocketRequest::SetIpReceiveOriginalDestinationAddress {
39073 value: req.value,
39074
39075 responder:
39076 DatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
39077 control_handle: std::mem::ManuallyDrop::new(control_handle),
39078 tx_id: header.tx_id,
39079 },
39080 })
39081 }
39082 0x2a0e7dc5d6bfdfe9 => {
39083 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39084 let mut req = fidl::new_empty!(
39085 fidl::encoding::EmptyPayload,
39086 fidl::encoding::DefaultFuchsiaResourceDialect
39087 );
39088 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39089 let control_handle =
39090 DatagramSocketControlHandle { inner: this.inner.clone() };
39091 Ok(DatagramSocketRequest::GetIpReceiveOriginalDestinationAddress {
39092 responder:
39093 DatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
39094 control_handle: std::mem::ManuallyDrop::new(control_handle),
39095 tx_id: header.tx_id,
39096 },
39097 })
39098 }
39099 0x7c94727acb4ea4b3 => {
39100 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39101 let mut req = fidl::new_empty!(
39102 BaseNetworkSocketAddIpv6MembershipRequest,
39103 fidl::encoding::DefaultFuchsiaResourceDialect
39104 );
39105 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
39106 let control_handle =
39107 DatagramSocketControlHandle { inner: this.inner.clone() };
39108 Ok(DatagramSocketRequest::AddIpv6Membership {
39109 membership: req.membership,
39110
39111 responder: DatagramSocketAddIpv6MembershipResponder {
39112 control_handle: std::mem::ManuallyDrop::new(control_handle),
39113 tx_id: header.tx_id,
39114 },
39115 })
39116 }
39117 0x42104c70ccaba304 => {
39118 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39119 let mut req = fidl::new_empty!(
39120 BaseNetworkSocketDropIpv6MembershipRequest,
39121 fidl::encoding::DefaultFuchsiaResourceDialect
39122 );
39123 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
39124 let control_handle =
39125 DatagramSocketControlHandle { inner: this.inner.clone() };
39126 Ok(DatagramSocketRequest::DropIpv6Membership {
39127 membership: req.membership,
39128
39129 responder: DatagramSocketDropIpv6MembershipResponder {
39130 control_handle: std::mem::ManuallyDrop::new(control_handle),
39131 tx_id: header.tx_id,
39132 },
39133 })
39134 }
39135 0x135f76db3774ab3b => {
39136 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39137 let mut req = fidl::new_empty!(
39138 BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
39139 fidl::encoding::DefaultFuchsiaResourceDialect
39140 );
39141 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
39142 let control_handle =
39143 DatagramSocketControlHandle { inner: this.inner.clone() };
39144 Ok(DatagramSocketRequest::SetIpv6MulticastInterface {
39145 value: req.value,
39146
39147 responder: DatagramSocketSetIpv6MulticastInterfaceResponder {
39148 control_handle: std::mem::ManuallyDrop::new(control_handle),
39149 tx_id: header.tx_id,
39150 },
39151 })
39152 }
39153 0x1f26fcdd348f1882 => {
39154 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39155 let mut req = fidl::new_empty!(
39156 fidl::encoding::EmptyPayload,
39157 fidl::encoding::DefaultFuchsiaResourceDialect
39158 );
39159 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39160 let control_handle =
39161 DatagramSocketControlHandle { inner: this.inner.clone() };
39162 Ok(DatagramSocketRequest::GetIpv6MulticastInterface {
39163 responder: DatagramSocketGetIpv6MulticastInterfaceResponder {
39164 control_handle: std::mem::ManuallyDrop::new(control_handle),
39165 tx_id: header.tx_id,
39166 },
39167 })
39168 }
39169 0x157d51e98f462859 => {
39170 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39171 let mut req = fidl::new_empty!(
39172 BaseNetworkSocketSetIpv6UnicastHopsRequest,
39173 fidl::encoding::DefaultFuchsiaResourceDialect
39174 );
39175 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6UnicastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
39176 let control_handle =
39177 DatagramSocketControlHandle { inner: this.inner.clone() };
39178 Ok(DatagramSocketRequest::SetIpv6UnicastHops {
39179 value: req.value,
39180
39181 responder: DatagramSocketSetIpv6UnicastHopsResponder {
39182 control_handle: std::mem::ManuallyDrop::new(control_handle),
39183 tx_id: header.tx_id,
39184 },
39185 })
39186 }
39187 0x21f4641cad8bd8d2 => {
39188 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39189 let mut req = fidl::new_empty!(
39190 fidl::encoding::EmptyPayload,
39191 fidl::encoding::DefaultFuchsiaResourceDialect
39192 );
39193 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39194 let control_handle =
39195 DatagramSocketControlHandle { inner: this.inner.clone() };
39196 Ok(DatagramSocketRequest::GetIpv6UnicastHops {
39197 responder: DatagramSocketGetIpv6UnicastHopsResponder {
39198 control_handle: std::mem::ManuallyDrop::new(control_handle),
39199 tx_id: header.tx_id,
39200 },
39201 })
39202 }
39203 0x5c24808ed2e84a1e => {
39204 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39205 let mut req = fidl::new_empty!(
39206 BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
39207 fidl::encoding::DefaultFuchsiaResourceDialect
39208 );
39209 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveHopLimitRequest>(&header, _body_bytes, handles, &mut req)?;
39210 let control_handle =
39211 DatagramSocketControlHandle { inner: this.inner.clone() };
39212 Ok(DatagramSocketRequest::SetIpv6ReceiveHopLimit {
39213 value: req.value,
39214
39215 responder: DatagramSocketSetIpv6ReceiveHopLimitResponder {
39216 control_handle: std::mem::ManuallyDrop::new(control_handle),
39217 tx_id: header.tx_id,
39218 },
39219 })
39220 }
39221 0x341e06689885b4c0 => {
39222 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39223 let mut req = fidl::new_empty!(
39224 fidl::encoding::EmptyPayload,
39225 fidl::encoding::DefaultFuchsiaResourceDialect
39226 );
39227 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39228 let control_handle =
39229 DatagramSocketControlHandle { inner: this.inner.clone() };
39230 Ok(DatagramSocketRequest::GetIpv6ReceiveHopLimit {
39231 responder: DatagramSocketGetIpv6ReceiveHopLimitResponder {
39232 control_handle: std::mem::ManuallyDrop::new(control_handle),
39233 tx_id: header.tx_id,
39234 },
39235 })
39236 }
39237 0x25b9cd4d181f82c1 => {
39238 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39239 let mut req = fidl::new_empty!(
39240 BaseNetworkSocketSetIpv6MulticastHopsRequest,
39241 fidl::encoding::DefaultFuchsiaResourceDialect
39242 );
39243 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
39244 let control_handle =
39245 DatagramSocketControlHandle { inner: this.inner.clone() };
39246 Ok(DatagramSocketRequest::SetIpv6MulticastHops {
39247 value: req.value,
39248
39249 responder: DatagramSocketSetIpv6MulticastHopsResponder {
39250 control_handle: std::mem::ManuallyDrop::new(control_handle),
39251 tx_id: header.tx_id,
39252 },
39253 })
39254 }
39255 0x52916948a365012a => {
39256 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39257 let mut req = fidl::new_empty!(
39258 fidl::encoding::EmptyPayload,
39259 fidl::encoding::DefaultFuchsiaResourceDialect
39260 );
39261 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39262 let control_handle =
39263 DatagramSocketControlHandle { inner: this.inner.clone() };
39264 Ok(DatagramSocketRequest::GetIpv6MulticastHops {
39265 responder: DatagramSocketGetIpv6MulticastHopsResponder {
39266 control_handle: std::mem::ManuallyDrop::new(control_handle),
39267 tx_id: header.tx_id,
39268 },
39269 })
39270 }
39271 0x55701c409ff41b40 => {
39272 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39273 let mut req = fidl::new_empty!(
39274 BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
39275 fidl::encoding::DefaultFuchsiaResourceDialect
39276 );
39277 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
39278 let control_handle =
39279 DatagramSocketControlHandle { inner: this.inner.clone() };
39280 Ok(DatagramSocketRequest::SetIpv6MulticastLoopback {
39281 value: req.value,
39282
39283 responder: DatagramSocketSetIpv6MulticastLoopbackResponder {
39284 control_handle: std::mem::ManuallyDrop::new(control_handle),
39285 tx_id: header.tx_id,
39286 },
39287 })
39288 }
39289 0x4415b701fde319c3 => {
39290 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39291 let mut req = fidl::new_empty!(
39292 fidl::encoding::EmptyPayload,
39293 fidl::encoding::DefaultFuchsiaResourceDialect
39294 );
39295 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39296 let control_handle =
39297 DatagramSocketControlHandle { inner: this.inner.clone() };
39298 Ok(DatagramSocketRequest::GetIpv6MulticastLoopback {
39299 responder: DatagramSocketGetIpv6MulticastLoopbackResponder {
39300 control_handle: std::mem::ManuallyDrop::new(control_handle),
39301 tx_id: header.tx_id,
39302 },
39303 })
39304 }
39305 0x4873f1364758cbba => {
39306 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39307 let mut req = fidl::new_empty!(
39308 BaseNetworkSocketSetIpv6OnlyRequest,
39309 fidl::encoding::DefaultFuchsiaResourceDialect
39310 );
39311 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6OnlyRequest>(&header, _body_bytes, handles, &mut req)?;
39312 let control_handle =
39313 DatagramSocketControlHandle { inner: this.inner.clone() };
39314 Ok(DatagramSocketRequest::SetIpv6Only {
39315 value: req.value,
39316
39317 responder: DatagramSocketSetIpv6OnlyResponder {
39318 control_handle: std::mem::ManuallyDrop::new(control_handle),
39319 tx_id: header.tx_id,
39320 },
39321 })
39322 }
39323 0x4aa3340a1a26b89c => {
39324 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39325 let mut req = fidl::new_empty!(
39326 fidl::encoding::EmptyPayload,
39327 fidl::encoding::DefaultFuchsiaResourceDialect
39328 );
39329 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39330 let control_handle =
39331 DatagramSocketControlHandle { inner: this.inner.clone() };
39332 Ok(DatagramSocketRequest::GetIpv6Only {
39333 responder: DatagramSocketGetIpv6OnlyResponder {
39334 control_handle: std::mem::ManuallyDrop::new(control_handle),
39335 tx_id: header.tx_id,
39336 },
39337 })
39338 }
39339 0x58f07c8788d099a0 => {
39340 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39341 let mut req = fidl::new_empty!(
39342 BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
39343 fidl::encoding::DefaultFuchsiaResourceDialect
39344 );
39345 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
39346 let control_handle =
39347 DatagramSocketControlHandle { inner: this.inner.clone() };
39348 Ok(DatagramSocketRequest::SetIpv6ReceiveTrafficClass {
39349 value: req.value,
39350
39351 responder: DatagramSocketSetIpv6ReceiveTrafficClassResponder {
39352 control_handle: std::mem::ManuallyDrop::new(control_handle),
39353 tx_id: header.tx_id,
39354 },
39355 })
39356 }
39357 0x2e334df1da553ffa => {
39358 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39359 let mut req = fidl::new_empty!(
39360 fidl::encoding::EmptyPayload,
39361 fidl::encoding::DefaultFuchsiaResourceDialect
39362 );
39363 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39364 let control_handle =
39365 DatagramSocketControlHandle { inner: this.inner.clone() };
39366 Ok(DatagramSocketRequest::GetIpv6ReceiveTrafficClass {
39367 responder: DatagramSocketGetIpv6ReceiveTrafficClassResponder {
39368 control_handle: std::mem::ManuallyDrop::new(control_handle),
39369 tx_id: header.tx_id,
39370 },
39371 })
39372 }
39373 0x6af077800c5a0b4f => {
39374 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39375 let mut req = fidl::new_empty!(
39376 BaseNetworkSocketSetIpv6TrafficClassRequest,
39377 fidl::encoding::DefaultFuchsiaResourceDialect
39378 );
39379 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6TrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
39380 let control_handle =
39381 DatagramSocketControlHandle { inner: this.inner.clone() };
39382 Ok(DatagramSocketRequest::SetIpv6TrafficClass {
39383 value: req.value,
39384
39385 responder: DatagramSocketSetIpv6TrafficClassResponder {
39386 control_handle: std::mem::ManuallyDrop::new(control_handle),
39387 tx_id: header.tx_id,
39388 },
39389 })
39390 }
39391 0x6baf6eed8fc2f04 => {
39392 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39393 let mut req = fidl::new_empty!(
39394 fidl::encoding::EmptyPayload,
39395 fidl::encoding::DefaultFuchsiaResourceDialect
39396 );
39397 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39398 let control_handle =
39399 DatagramSocketControlHandle { inner: this.inner.clone() };
39400 Ok(DatagramSocketRequest::GetIpv6TrafficClass {
39401 responder: DatagramSocketGetIpv6TrafficClassResponder {
39402 control_handle: std::mem::ManuallyDrop::new(control_handle),
39403 tx_id: header.tx_id,
39404 },
39405 })
39406 }
39407 0x19259775b1a92768 => {
39408 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39409 let mut req = fidl::new_empty!(
39410 BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
39411 fidl::encoding::DefaultFuchsiaResourceDialect
39412 );
39413 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceivePacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
39414 let control_handle =
39415 DatagramSocketControlHandle { inner: this.inner.clone() };
39416 Ok(DatagramSocketRequest::SetIpv6ReceivePacketInfo {
39417 value: req.value,
39418
39419 responder: DatagramSocketSetIpv6ReceivePacketInfoResponder {
39420 control_handle: std::mem::ManuallyDrop::new(control_handle),
39421 tx_id: header.tx_id,
39422 },
39423 })
39424 }
39425 0x7acd4a2775baec75 => {
39426 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39427 let mut req = fidl::new_empty!(
39428 fidl::encoding::EmptyPayload,
39429 fidl::encoding::DefaultFuchsiaResourceDialect
39430 );
39431 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39432 let control_handle =
39433 DatagramSocketControlHandle { inner: this.inner.clone() };
39434 Ok(DatagramSocketRequest::GetIpv6ReceivePacketInfo {
39435 responder: DatagramSocketGetIpv6ReceivePacketInfoResponder {
39436 control_handle: std::mem::ManuallyDrop::new(control_handle),
39437 tx_id: header.tx_id,
39438 },
39439 })
39440 }
39441 0x38bf28f0dafdbac0 => {
39442 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39443 let mut req = fidl::new_empty!(
39444 fidl::encoding::EmptyPayload,
39445 fidl::encoding::DefaultFuchsiaResourceDialect
39446 );
39447 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39448 let control_handle =
39449 DatagramSocketControlHandle { inner: this.inner.clone() };
39450 Ok(DatagramSocketRequest::GetOriginalDestination {
39451 responder: DatagramSocketGetOriginalDestinationResponder {
39452 control_handle: std::mem::ManuallyDrop::new(control_handle),
39453 tx_id: header.tx_id,
39454 },
39455 })
39456 }
39457 0x48aa0a1f6a32d2ed => {
39458 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39459 let mut req = fidl::new_empty!(
39460 fidl::encoding::EmptyPayload,
39461 fidl::encoding::DefaultFuchsiaResourceDialect
39462 );
39463 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39464 let control_handle =
39465 DatagramSocketControlHandle { inner: this.inner.clone() };
39466 Ok(DatagramSocketRequest::GetInfo {
39467 responder: DatagramSocketGetInfoResponder {
39468 control_handle: std::mem::ManuallyDrop::new(control_handle),
39469 tx_id: header.tx_id,
39470 },
39471 })
39472 }
39473 0xbf1e2f0a86601f3 => {
39474 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39475 let mut req = fidl::new_empty!(
39476 fidl::encoding::EmptyPayload,
39477 fidl::encoding::DefaultFuchsiaResourceDialect
39478 );
39479 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39480 let control_handle =
39481 DatagramSocketControlHandle { inner: this.inner.clone() };
39482 Ok(DatagramSocketRequest::Describe {
39483 responder: DatagramSocketDescribeResponder {
39484 control_handle: std::mem::ManuallyDrop::new(control_handle),
39485 tx_id: header.tx_id,
39486 },
39487 })
39488 }
39489 0x5362e668e777248a => {
39490 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39491 let mut req = fidl::new_empty!(
39492 DatagramSocketSendMsgPreflightRequest,
39493 fidl::encoding::DefaultFuchsiaResourceDialect
39494 );
39495 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DatagramSocketSendMsgPreflightRequest>(&header, _body_bytes, handles, &mut req)?;
39496 let control_handle =
39497 DatagramSocketControlHandle { inner: this.inner.clone() };
39498 Ok(DatagramSocketRequest::SendMsgPreflight {
39499 payload: req,
39500 responder: DatagramSocketSendMsgPreflightResponder {
39501 control_handle: std::mem::ManuallyDrop::new(control_handle),
39502 tx_id: header.tx_id,
39503 },
39504 })
39505 }
39506 0x1a7cdeca5f3eb8e2 => {
39507 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39508 let mut req = fidl::new_empty!(
39509 fidl::encoding::EmptyPayload,
39510 fidl::encoding::DefaultFuchsiaResourceDialect
39511 );
39512 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39513 let control_handle =
39514 DatagramSocketControlHandle { inner: this.inner.clone() };
39515 Ok(DatagramSocketRequest::RecvMsgPostflight {
39516 responder: DatagramSocketRecvMsgPostflightResponder {
39517 control_handle: std::mem::ManuallyDrop::new(control_handle),
39518 tx_id: header.tx_id,
39519 },
39520 })
39521 }
39522 _ => Err(fidl::Error::UnknownOrdinal {
39523 ordinal: header.ordinal,
39524 protocol_name:
39525 <DatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
39526 }),
39527 }))
39528 },
39529 )
39530 }
39531}
39532
39533#[derive(Debug)]
39535pub enum DatagramSocketRequest {
39536 Clone {
39537 request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
39538 control_handle: DatagramSocketControlHandle,
39539 },
39540 Close {
39551 responder: DatagramSocketCloseResponder,
39552 },
39553 Query {
39554 responder: DatagramSocketQueryResponder,
39555 },
39556 SetReuseAddress {
39558 value: bool,
39559 responder: DatagramSocketSetReuseAddressResponder,
39560 },
39561 GetReuseAddress {
39563 responder: DatagramSocketGetReuseAddressResponder,
39564 },
39565 GetError {
39568 responder: DatagramSocketGetErrorResponder,
39569 },
39570 SetBroadcast {
39572 value: bool,
39573 responder: DatagramSocketSetBroadcastResponder,
39574 },
39575 GetBroadcast {
39577 responder: DatagramSocketGetBroadcastResponder,
39578 },
39579 SetSendBuffer {
39581 value_bytes: u64,
39582 responder: DatagramSocketSetSendBufferResponder,
39583 },
39584 GetSendBuffer {
39586 responder: DatagramSocketGetSendBufferResponder,
39587 },
39588 SetReceiveBuffer {
39590 value_bytes: u64,
39591 responder: DatagramSocketSetReceiveBufferResponder,
39592 },
39593 GetReceiveBuffer {
39595 responder: DatagramSocketGetReceiveBufferResponder,
39596 },
39597 SetKeepAlive {
39599 value: bool,
39600 responder: DatagramSocketSetKeepAliveResponder,
39601 },
39602 GetKeepAlive {
39604 responder: DatagramSocketGetKeepAliveResponder,
39605 },
39606 SetOutOfBandInline {
39608 value: bool,
39609 responder: DatagramSocketSetOutOfBandInlineResponder,
39610 },
39611 GetOutOfBandInline {
39613 responder: DatagramSocketGetOutOfBandInlineResponder,
39614 },
39615 SetNoCheck {
39617 value: bool,
39618 responder: DatagramSocketSetNoCheckResponder,
39619 },
39620 GetNoCheck {
39622 responder: DatagramSocketGetNoCheckResponder,
39623 },
39624 SetLinger {
39626 linger: bool,
39627 length_secs: u32,
39628 responder: DatagramSocketSetLingerResponder,
39629 },
39630 GetLinger {
39632 responder: DatagramSocketGetLingerResponder,
39633 },
39634 SetReusePort {
39636 value: bool,
39637 responder: DatagramSocketSetReusePortResponder,
39638 },
39639 GetReusePort {
39641 responder: DatagramSocketGetReusePortResponder,
39642 },
39643 GetAcceptConn {
39645 responder: DatagramSocketGetAcceptConnResponder,
39646 },
39647 SetBindToDevice {
39649 value: String,
39650 responder: DatagramSocketSetBindToDeviceResponder,
39651 },
39652 GetBindToDevice {
39654 responder: DatagramSocketGetBindToDeviceResponder,
39655 },
39656 SetBindToInterfaceIndex {
39659 value: u64,
39660 responder: DatagramSocketSetBindToInterfaceIndexResponder,
39661 },
39662 GetBindToInterfaceIndex {
39664 responder: DatagramSocketGetBindToInterfaceIndexResponder,
39665 },
39666 SetTimestamp {
39668 value: TimestampOption,
39669 responder: DatagramSocketSetTimestampResponder,
39670 },
39671 GetTimestamp {
39673 responder: DatagramSocketGetTimestampResponder,
39674 },
39675 SetMark {
39679 domain: fidl_fuchsia_net::MarkDomain,
39680 mark: OptionalUint32,
39681 responder: DatagramSocketSetMarkResponder,
39682 },
39683 GetMark {
39687 domain: fidl_fuchsia_net::MarkDomain,
39688 responder: DatagramSocketGetMarkResponder,
39689 },
39690 Bind {
39692 addr: fidl_fuchsia_net::SocketAddress,
39693 responder: DatagramSocketBindResponder,
39694 },
39695 Connect {
39697 addr: fidl_fuchsia_net::SocketAddress,
39698 responder: DatagramSocketConnectResponder,
39699 },
39700 Disconnect {
39702 responder: DatagramSocketDisconnectResponder,
39703 },
39704 GetSockName {
39706 responder: DatagramSocketGetSockNameResponder,
39707 },
39708 GetPeerName {
39710 responder: DatagramSocketGetPeerNameResponder,
39711 },
39712 Shutdown {
39714 mode: ShutdownMode,
39715 responder: DatagramSocketShutdownResponder,
39716 },
39717 SetIpTypeOfService {
39719 value: u8,
39720 responder: DatagramSocketSetIpTypeOfServiceResponder,
39721 },
39722 GetIpTypeOfService {
39724 responder: DatagramSocketGetIpTypeOfServiceResponder,
39725 },
39726 SetIpTtl {
39728 value: OptionalUint8,
39729 responder: DatagramSocketSetIpTtlResponder,
39730 },
39731 GetIpTtl {
39733 responder: DatagramSocketGetIpTtlResponder,
39734 },
39735 SetIpPacketInfo {
39737 value: bool,
39738 responder: DatagramSocketSetIpPacketInfoResponder,
39739 },
39740 GetIpPacketInfo {
39742 responder: DatagramSocketGetIpPacketInfoResponder,
39743 },
39744 SetIpReceiveTypeOfService {
39746 value: bool,
39747 responder: DatagramSocketSetIpReceiveTypeOfServiceResponder,
39748 },
39749 GetIpReceiveTypeOfService {
39751 responder: DatagramSocketGetIpReceiveTypeOfServiceResponder,
39752 },
39753 SetIpReceiveTtl {
39755 value: bool,
39756 responder: DatagramSocketSetIpReceiveTtlResponder,
39757 },
39758 GetIpReceiveTtl {
39760 responder: DatagramSocketGetIpReceiveTtlResponder,
39761 },
39762 SetIpMulticastInterface {
39764 iface: u64,
39765 address: fidl_fuchsia_net::Ipv4Address,
39766 responder: DatagramSocketSetIpMulticastInterfaceResponder,
39767 },
39768 GetIpMulticastInterface {
39770 responder: DatagramSocketGetIpMulticastInterfaceResponder,
39771 },
39772 SetIpMulticastTtl {
39774 value: OptionalUint8,
39775 responder: DatagramSocketSetIpMulticastTtlResponder,
39776 },
39777 GetIpMulticastTtl {
39779 responder: DatagramSocketGetIpMulticastTtlResponder,
39780 },
39781 SetIpMulticastLoopback {
39783 value: bool,
39784 responder: DatagramSocketSetIpMulticastLoopbackResponder,
39785 },
39786 GetIpMulticastLoopback {
39788 responder: DatagramSocketGetIpMulticastLoopbackResponder,
39789 },
39790 AddIpMembership {
39792 membership: IpMulticastMembership,
39793 responder: DatagramSocketAddIpMembershipResponder,
39794 },
39795 DropIpMembership {
39797 membership: IpMulticastMembership,
39798 responder: DatagramSocketDropIpMembershipResponder,
39799 },
39800 SetIpTransparent {
39802 value: bool,
39803 responder: DatagramSocketSetIpTransparentResponder,
39804 },
39805 GetIpTransparent {
39807 responder: DatagramSocketGetIpTransparentResponder,
39808 },
39809 SetIpReceiveOriginalDestinationAddress {
39811 value: bool,
39812 responder: DatagramSocketSetIpReceiveOriginalDestinationAddressResponder,
39813 },
39814 GetIpReceiveOriginalDestinationAddress {
39816 responder: DatagramSocketGetIpReceiveOriginalDestinationAddressResponder,
39817 },
39818 AddIpv6Membership {
39820 membership: Ipv6MulticastMembership,
39821 responder: DatagramSocketAddIpv6MembershipResponder,
39822 },
39823 DropIpv6Membership {
39825 membership: Ipv6MulticastMembership,
39826 responder: DatagramSocketDropIpv6MembershipResponder,
39827 },
39828 SetIpv6MulticastInterface {
39830 value: u64,
39831 responder: DatagramSocketSetIpv6MulticastInterfaceResponder,
39832 },
39833 GetIpv6MulticastInterface {
39835 responder: DatagramSocketGetIpv6MulticastInterfaceResponder,
39836 },
39837 SetIpv6UnicastHops {
39839 value: OptionalUint8,
39840 responder: DatagramSocketSetIpv6UnicastHopsResponder,
39841 },
39842 GetIpv6UnicastHops {
39844 responder: DatagramSocketGetIpv6UnicastHopsResponder,
39845 },
39846 SetIpv6ReceiveHopLimit {
39848 value: bool,
39849 responder: DatagramSocketSetIpv6ReceiveHopLimitResponder,
39850 },
39851 GetIpv6ReceiveHopLimit {
39853 responder: DatagramSocketGetIpv6ReceiveHopLimitResponder,
39854 },
39855 SetIpv6MulticastHops {
39857 value: OptionalUint8,
39858 responder: DatagramSocketSetIpv6MulticastHopsResponder,
39859 },
39860 GetIpv6MulticastHops {
39862 responder: DatagramSocketGetIpv6MulticastHopsResponder,
39863 },
39864 SetIpv6MulticastLoopback {
39866 value: bool,
39867 responder: DatagramSocketSetIpv6MulticastLoopbackResponder,
39868 },
39869 GetIpv6MulticastLoopback {
39871 responder: DatagramSocketGetIpv6MulticastLoopbackResponder,
39872 },
39873 SetIpv6Only {
39875 value: bool,
39876 responder: DatagramSocketSetIpv6OnlyResponder,
39877 },
39878 GetIpv6Only {
39880 responder: DatagramSocketGetIpv6OnlyResponder,
39881 },
39882 SetIpv6ReceiveTrafficClass {
39884 value: bool,
39885 responder: DatagramSocketSetIpv6ReceiveTrafficClassResponder,
39886 },
39887 GetIpv6ReceiveTrafficClass {
39889 responder: DatagramSocketGetIpv6ReceiveTrafficClassResponder,
39890 },
39891 SetIpv6TrafficClass {
39893 value: OptionalUint8,
39894 responder: DatagramSocketSetIpv6TrafficClassResponder,
39895 },
39896 GetIpv6TrafficClass {
39898 responder: DatagramSocketGetIpv6TrafficClassResponder,
39899 },
39900 SetIpv6ReceivePacketInfo {
39902 value: bool,
39903 responder: DatagramSocketSetIpv6ReceivePacketInfoResponder,
39904 },
39905 GetIpv6ReceivePacketInfo {
39907 responder: DatagramSocketGetIpv6ReceivePacketInfoResponder,
39908 },
39909 GetOriginalDestination {
39911 responder: DatagramSocketGetOriginalDestinationResponder,
39912 },
39913 GetInfo {
39918 responder: DatagramSocketGetInfoResponder,
39919 },
39920 Describe {
39921 responder: DatagramSocketDescribeResponder,
39922 },
39923 SendMsgPreflight {
39929 payload: DatagramSocketSendMsgPreflightRequest,
39930 responder: DatagramSocketSendMsgPreflightResponder,
39931 },
39932 RecvMsgPostflight {
39936 responder: DatagramSocketRecvMsgPostflightResponder,
39937 },
39938}
39939
39940impl DatagramSocketRequest {
39941 #[allow(irrefutable_let_patterns)]
39942 pub fn into_clone(
39943 self,
39944 ) -> Option<(
39945 fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
39946 DatagramSocketControlHandle,
39947 )> {
39948 if let DatagramSocketRequest::Clone { request, control_handle } = self {
39949 Some((request, control_handle))
39950 } else {
39951 None
39952 }
39953 }
39954
39955 #[allow(irrefutable_let_patterns)]
39956 pub fn into_close(self) -> Option<(DatagramSocketCloseResponder)> {
39957 if let DatagramSocketRequest::Close { responder } = self {
39958 Some((responder))
39959 } else {
39960 None
39961 }
39962 }
39963
39964 #[allow(irrefutable_let_patterns)]
39965 pub fn into_query(self) -> Option<(DatagramSocketQueryResponder)> {
39966 if let DatagramSocketRequest::Query { responder } = self {
39967 Some((responder))
39968 } else {
39969 None
39970 }
39971 }
39972
39973 #[allow(irrefutable_let_patterns)]
39974 pub fn into_set_reuse_address(self) -> Option<(bool, DatagramSocketSetReuseAddressResponder)> {
39975 if let DatagramSocketRequest::SetReuseAddress { value, responder } = self {
39976 Some((value, responder))
39977 } else {
39978 None
39979 }
39980 }
39981
39982 #[allow(irrefutable_let_patterns)]
39983 pub fn into_get_reuse_address(self) -> Option<(DatagramSocketGetReuseAddressResponder)> {
39984 if let DatagramSocketRequest::GetReuseAddress { responder } = self {
39985 Some((responder))
39986 } else {
39987 None
39988 }
39989 }
39990
39991 #[allow(irrefutable_let_patterns)]
39992 pub fn into_get_error(self) -> Option<(DatagramSocketGetErrorResponder)> {
39993 if let DatagramSocketRequest::GetError { responder } = self {
39994 Some((responder))
39995 } else {
39996 None
39997 }
39998 }
39999
40000 #[allow(irrefutable_let_patterns)]
40001 pub fn into_set_broadcast(self) -> Option<(bool, DatagramSocketSetBroadcastResponder)> {
40002 if let DatagramSocketRequest::SetBroadcast { value, responder } = self {
40003 Some((value, responder))
40004 } else {
40005 None
40006 }
40007 }
40008
40009 #[allow(irrefutable_let_patterns)]
40010 pub fn into_get_broadcast(self) -> Option<(DatagramSocketGetBroadcastResponder)> {
40011 if let DatagramSocketRequest::GetBroadcast { responder } = self {
40012 Some((responder))
40013 } else {
40014 None
40015 }
40016 }
40017
40018 #[allow(irrefutable_let_patterns)]
40019 pub fn into_set_send_buffer(self) -> Option<(u64, DatagramSocketSetSendBufferResponder)> {
40020 if let DatagramSocketRequest::SetSendBuffer { value_bytes, responder } = self {
40021 Some((value_bytes, responder))
40022 } else {
40023 None
40024 }
40025 }
40026
40027 #[allow(irrefutable_let_patterns)]
40028 pub fn into_get_send_buffer(self) -> Option<(DatagramSocketGetSendBufferResponder)> {
40029 if let DatagramSocketRequest::GetSendBuffer { responder } = self {
40030 Some((responder))
40031 } else {
40032 None
40033 }
40034 }
40035
40036 #[allow(irrefutable_let_patterns)]
40037 pub fn into_set_receive_buffer(self) -> Option<(u64, DatagramSocketSetReceiveBufferResponder)> {
40038 if let DatagramSocketRequest::SetReceiveBuffer { value_bytes, responder } = self {
40039 Some((value_bytes, responder))
40040 } else {
40041 None
40042 }
40043 }
40044
40045 #[allow(irrefutable_let_patterns)]
40046 pub fn into_get_receive_buffer(self) -> Option<(DatagramSocketGetReceiveBufferResponder)> {
40047 if let DatagramSocketRequest::GetReceiveBuffer { responder } = self {
40048 Some((responder))
40049 } else {
40050 None
40051 }
40052 }
40053
40054 #[allow(irrefutable_let_patterns)]
40055 pub fn into_set_keep_alive(self) -> Option<(bool, DatagramSocketSetKeepAliveResponder)> {
40056 if let DatagramSocketRequest::SetKeepAlive { value, responder } = self {
40057 Some((value, responder))
40058 } else {
40059 None
40060 }
40061 }
40062
40063 #[allow(irrefutable_let_patterns)]
40064 pub fn into_get_keep_alive(self) -> Option<(DatagramSocketGetKeepAliveResponder)> {
40065 if let DatagramSocketRequest::GetKeepAlive { responder } = self {
40066 Some((responder))
40067 } else {
40068 None
40069 }
40070 }
40071
40072 #[allow(irrefutable_let_patterns)]
40073 pub fn into_set_out_of_band_inline(
40074 self,
40075 ) -> Option<(bool, DatagramSocketSetOutOfBandInlineResponder)> {
40076 if let DatagramSocketRequest::SetOutOfBandInline { value, responder } = self {
40077 Some((value, responder))
40078 } else {
40079 None
40080 }
40081 }
40082
40083 #[allow(irrefutable_let_patterns)]
40084 pub fn into_get_out_of_band_inline(
40085 self,
40086 ) -> Option<(DatagramSocketGetOutOfBandInlineResponder)> {
40087 if let DatagramSocketRequest::GetOutOfBandInline { responder } = self {
40088 Some((responder))
40089 } else {
40090 None
40091 }
40092 }
40093
40094 #[allow(irrefutable_let_patterns)]
40095 pub fn into_set_no_check(self) -> Option<(bool, DatagramSocketSetNoCheckResponder)> {
40096 if let DatagramSocketRequest::SetNoCheck { value, responder } = self {
40097 Some((value, responder))
40098 } else {
40099 None
40100 }
40101 }
40102
40103 #[allow(irrefutable_let_patterns)]
40104 pub fn into_get_no_check(self) -> Option<(DatagramSocketGetNoCheckResponder)> {
40105 if let DatagramSocketRequest::GetNoCheck { responder } = self {
40106 Some((responder))
40107 } else {
40108 None
40109 }
40110 }
40111
40112 #[allow(irrefutable_let_patterns)]
40113 pub fn into_set_linger(self) -> Option<(bool, u32, DatagramSocketSetLingerResponder)> {
40114 if let DatagramSocketRequest::SetLinger { linger, length_secs, responder } = self {
40115 Some((linger, length_secs, responder))
40116 } else {
40117 None
40118 }
40119 }
40120
40121 #[allow(irrefutable_let_patterns)]
40122 pub fn into_get_linger(self) -> Option<(DatagramSocketGetLingerResponder)> {
40123 if let DatagramSocketRequest::GetLinger { responder } = self {
40124 Some((responder))
40125 } else {
40126 None
40127 }
40128 }
40129
40130 #[allow(irrefutable_let_patterns)]
40131 pub fn into_set_reuse_port(self) -> Option<(bool, DatagramSocketSetReusePortResponder)> {
40132 if let DatagramSocketRequest::SetReusePort { value, responder } = self {
40133 Some((value, responder))
40134 } else {
40135 None
40136 }
40137 }
40138
40139 #[allow(irrefutable_let_patterns)]
40140 pub fn into_get_reuse_port(self) -> Option<(DatagramSocketGetReusePortResponder)> {
40141 if let DatagramSocketRequest::GetReusePort { responder } = self {
40142 Some((responder))
40143 } else {
40144 None
40145 }
40146 }
40147
40148 #[allow(irrefutable_let_patterns)]
40149 pub fn into_get_accept_conn(self) -> Option<(DatagramSocketGetAcceptConnResponder)> {
40150 if let DatagramSocketRequest::GetAcceptConn { responder } = self {
40151 Some((responder))
40152 } else {
40153 None
40154 }
40155 }
40156
40157 #[allow(irrefutable_let_patterns)]
40158 pub fn into_set_bind_to_device(
40159 self,
40160 ) -> Option<(String, DatagramSocketSetBindToDeviceResponder)> {
40161 if let DatagramSocketRequest::SetBindToDevice { value, responder } = self {
40162 Some((value, responder))
40163 } else {
40164 None
40165 }
40166 }
40167
40168 #[allow(irrefutable_let_patterns)]
40169 pub fn into_get_bind_to_device(self) -> Option<(DatagramSocketGetBindToDeviceResponder)> {
40170 if let DatagramSocketRequest::GetBindToDevice { responder } = self {
40171 Some((responder))
40172 } else {
40173 None
40174 }
40175 }
40176
40177 #[allow(irrefutable_let_patterns)]
40178 pub fn into_set_bind_to_interface_index(
40179 self,
40180 ) -> Option<(u64, DatagramSocketSetBindToInterfaceIndexResponder)> {
40181 if let DatagramSocketRequest::SetBindToInterfaceIndex { value, responder } = self {
40182 Some((value, responder))
40183 } else {
40184 None
40185 }
40186 }
40187
40188 #[allow(irrefutable_let_patterns)]
40189 pub fn into_get_bind_to_interface_index(
40190 self,
40191 ) -> Option<(DatagramSocketGetBindToInterfaceIndexResponder)> {
40192 if let DatagramSocketRequest::GetBindToInterfaceIndex { responder } = self {
40193 Some((responder))
40194 } else {
40195 None
40196 }
40197 }
40198
40199 #[allow(irrefutable_let_patterns)]
40200 pub fn into_set_timestamp(
40201 self,
40202 ) -> Option<(TimestampOption, DatagramSocketSetTimestampResponder)> {
40203 if let DatagramSocketRequest::SetTimestamp { value, responder } = self {
40204 Some((value, responder))
40205 } else {
40206 None
40207 }
40208 }
40209
40210 #[allow(irrefutable_let_patterns)]
40211 pub fn into_get_timestamp(self) -> Option<(DatagramSocketGetTimestampResponder)> {
40212 if let DatagramSocketRequest::GetTimestamp { responder } = self {
40213 Some((responder))
40214 } else {
40215 None
40216 }
40217 }
40218
40219 #[allow(irrefutable_let_patterns)]
40220 pub fn into_set_mark(
40221 self,
40222 ) -> Option<(fidl_fuchsia_net::MarkDomain, OptionalUint32, DatagramSocketSetMarkResponder)>
40223 {
40224 if let DatagramSocketRequest::SetMark { domain, mark, responder } = self {
40225 Some((domain, mark, responder))
40226 } else {
40227 None
40228 }
40229 }
40230
40231 #[allow(irrefutable_let_patterns)]
40232 pub fn into_get_mark(
40233 self,
40234 ) -> Option<(fidl_fuchsia_net::MarkDomain, DatagramSocketGetMarkResponder)> {
40235 if let DatagramSocketRequest::GetMark { domain, responder } = self {
40236 Some((domain, responder))
40237 } else {
40238 None
40239 }
40240 }
40241
40242 #[allow(irrefutable_let_patterns)]
40243 pub fn into_bind(
40244 self,
40245 ) -> Option<(fidl_fuchsia_net::SocketAddress, DatagramSocketBindResponder)> {
40246 if let DatagramSocketRequest::Bind { addr, responder } = self {
40247 Some((addr, responder))
40248 } else {
40249 None
40250 }
40251 }
40252
40253 #[allow(irrefutable_let_patterns)]
40254 pub fn into_connect(
40255 self,
40256 ) -> Option<(fidl_fuchsia_net::SocketAddress, DatagramSocketConnectResponder)> {
40257 if let DatagramSocketRequest::Connect { addr, responder } = self {
40258 Some((addr, responder))
40259 } else {
40260 None
40261 }
40262 }
40263
40264 #[allow(irrefutable_let_patterns)]
40265 pub fn into_disconnect(self) -> Option<(DatagramSocketDisconnectResponder)> {
40266 if let DatagramSocketRequest::Disconnect { responder } = self {
40267 Some((responder))
40268 } else {
40269 None
40270 }
40271 }
40272
40273 #[allow(irrefutable_let_patterns)]
40274 pub fn into_get_sock_name(self) -> Option<(DatagramSocketGetSockNameResponder)> {
40275 if let DatagramSocketRequest::GetSockName { responder } = self {
40276 Some((responder))
40277 } else {
40278 None
40279 }
40280 }
40281
40282 #[allow(irrefutable_let_patterns)]
40283 pub fn into_get_peer_name(self) -> Option<(DatagramSocketGetPeerNameResponder)> {
40284 if let DatagramSocketRequest::GetPeerName { responder } = self {
40285 Some((responder))
40286 } else {
40287 None
40288 }
40289 }
40290
40291 #[allow(irrefutable_let_patterns)]
40292 pub fn into_shutdown(self) -> Option<(ShutdownMode, DatagramSocketShutdownResponder)> {
40293 if let DatagramSocketRequest::Shutdown { mode, responder } = self {
40294 Some((mode, responder))
40295 } else {
40296 None
40297 }
40298 }
40299
40300 #[allow(irrefutable_let_patterns)]
40301 pub fn into_set_ip_type_of_service(
40302 self,
40303 ) -> Option<(u8, DatagramSocketSetIpTypeOfServiceResponder)> {
40304 if let DatagramSocketRequest::SetIpTypeOfService { value, responder } = self {
40305 Some((value, responder))
40306 } else {
40307 None
40308 }
40309 }
40310
40311 #[allow(irrefutable_let_patterns)]
40312 pub fn into_get_ip_type_of_service(
40313 self,
40314 ) -> Option<(DatagramSocketGetIpTypeOfServiceResponder)> {
40315 if let DatagramSocketRequest::GetIpTypeOfService { responder } = self {
40316 Some((responder))
40317 } else {
40318 None
40319 }
40320 }
40321
40322 #[allow(irrefutable_let_patterns)]
40323 pub fn into_set_ip_ttl(self) -> Option<(OptionalUint8, DatagramSocketSetIpTtlResponder)> {
40324 if let DatagramSocketRequest::SetIpTtl { value, responder } = self {
40325 Some((value, responder))
40326 } else {
40327 None
40328 }
40329 }
40330
40331 #[allow(irrefutable_let_patterns)]
40332 pub fn into_get_ip_ttl(self) -> Option<(DatagramSocketGetIpTtlResponder)> {
40333 if let DatagramSocketRequest::GetIpTtl { responder } = self {
40334 Some((responder))
40335 } else {
40336 None
40337 }
40338 }
40339
40340 #[allow(irrefutable_let_patterns)]
40341 pub fn into_set_ip_packet_info(self) -> Option<(bool, DatagramSocketSetIpPacketInfoResponder)> {
40342 if let DatagramSocketRequest::SetIpPacketInfo { value, responder } = self {
40343 Some((value, responder))
40344 } else {
40345 None
40346 }
40347 }
40348
40349 #[allow(irrefutable_let_patterns)]
40350 pub fn into_get_ip_packet_info(self) -> Option<(DatagramSocketGetIpPacketInfoResponder)> {
40351 if let DatagramSocketRequest::GetIpPacketInfo { responder } = self {
40352 Some((responder))
40353 } else {
40354 None
40355 }
40356 }
40357
40358 #[allow(irrefutable_let_patterns)]
40359 pub fn into_set_ip_receive_type_of_service(
40360 self,
40361 ) -> Option<(bool, DatagramSocketSetIpReceiveTypeOfServiceResponder)> {
40362 if let DatagramSocketRequest::SetIpReceiveTypeOfService { value, responder } = self {
40363 Some((value, responder))
40364 } else {
40365 None
40366 }
40367 }
40368
40369 #[allow(irrefutable_let_patterns)]
40370 pub fn into_get_ip_receive_type_of_service(
40371 self,
40372 ) -> Option<(DatagramSocketGetIpReceiveTypeOfServiceResponder)> {
40373 if let DatagramSocketRequest::GetIpReceiveTypeOfService { responder } = self {
40374 Some((responder))
40375 } else {
40376 None
40377 }
40378 }
40379
40380 #[allow(irrefutable_let_patterns)]
40381 pub fn into_set_ip_receive_ttl(self) -> Option<(bool, DatagramSocketSetIpReceiveTtlResponder)> {
40382 if let DatagramSocketRequest::SetIpReceiveTtl { value, responder } = self {
40383 Some((value, responder))
40384 } else {
40385 None
40386 }
40387 }
40388
40389 #[allow(irrefutable_let_patterns)]
40390 pub fn into_get_ip_receive_ttl(self) -> Option<(DatagramSocketGetIpReceiveTtlResponder)> {
40391 if let DatagramSocketRequest::GetIpReceiveTtl { responder } = self {
40392 Some((responder))
40393 } else {
40394 None
40395 }
40396 }
40397
40398 #[allow(irrefutable_let_patterns)]
40399 pub fn into_set_ip_multicast_interface(
40400 self,
40401 ) -> Option<(u64, fidl_fuchsia_net::Ipv4Address, DatagramSocketSetIpMulticastInterfaceResponder)>
40402 {
40403 if let DatagramSocketRequest::SetIpMulticastInterface { iface, address, responder } = self {
40404 Some((iface, address, responder))
40405 } else {
40406 None
40407 }
40408 }
40409
40410 #[allow(irrefutable_let_patterns)]
40411 pub fn into_get_ip_multicast_interface(
40412 self,
40413 ) -> Option<(DatagramSocketGetIpMulticastInterfaceResponder)> {
40414 if let DatagramSocketRequest::GetIpMulticastInterface { responder } = self {
40415 Some((responder))
40416 } else {
40417 None
40418 }
40419 }
40420
40421 #[allow(irrefutable_let_patterns)]
40422 pub fn into_set_ip_multicast_ttl(
40423 self,
40424 ) -> Option<(OptionalUint8, DatagramSocketSetIpMulticastTtlResponder)> {
40425 if let DatagramSocketRequest::SetIpMulticastTtl { value, responder } = self {
40426 Some((value, responder))
40427 } else {
40428 None
40429 }
40430 }
40431
40432 #[allow(irrefutable_let_patterns)]
40433 pub fn into_get_ip_multicast_ttl(self) -> Option<(DatagramSocketGetIpMulticastTtlResponder)> {
40434 if let DatagramSocketRequest::GetIpMulticastTtl { responder } = self {
40435 Some((responder))
40436 } else {
40437 None
40438 }
40439 }
40440
40441 #[allow(irrefutable_let_patterns)]
40442 pub fn into_set_ip_multicast_loopback(
40443 self,
40444 ) -> Option<(bool, DatagramSocketSetIpMulticastLoopbackResponder)> {
40445 if let DatagramSocketRequest::SetIpMulticastLoopback { value, responder } = self {
40446 Some((value, responder))
40447 } else {
40448 None
40449 }
40450 }
40451
40452 #[allow(irrefutable_let_patterns)]
40453 pub fn into_get_ip_multicast_loopback(
40454 self,
40455 ) -> Option<(DatagramSocketGetIpMulticastLoopbackResponder)> {
40456 if let DatagramSocketRequest::GetIpMulticastLoopback { responder } = self {
40457 Some((responder))
40458 } else {
40459 None
40460 }
40461 }
40462
40463 #[allow(irrefutable_let_patterns)]
40464 pub fn into_add_ip_membership(
40465 self,
40466 ) -> Option<(IpMulticastMembership, DatagramSocketAddIpMembershipResponder)> {
40467 if let DatagramSocketRequest::AddIpMembership { membership, responder } = self {
40468 Some((membership, responder))
40469 } else {
40470 None
40471 }
40472 }
40473
40474 #[allow(irrefutable_let_patterns)]
40475 pub fn into_drop_ip_membership(
40476 self,
40477 ) -> Option<(IpMulticastMembership, DatagramSocketDropIpMembershipResponder)> {
40478 if let DatagramSocketRequest::DropIpMembership { membership, responder } = self {
40479 Some((membership, responder))
40480 } else {
40481 None
40482 }
40483 }
40484
40485 #[allow(irrefutable_let_patterns)]
40486 pub fn into_set_ip_transparent(
40487 self,
40488 ) -> Option<(bool, DatagramSocketSetIpTransparentResponder)> {
40489 if let DatagramSocketRequest::SetIpTransparent { value, responder } = self {
40490 Some((value, responder))
40491 } else {
40492 None
40493 }
40494 }
40495
40496 #[allow(irrefutable_let_patterns)]
40497 pub fn into_get_ip_transparent(self) -> Option<(DatagramSocketGetIpTransparentResponder)> {
40498 if let DatagramSocketRequest::GetIpTransparent { responder } = self {
40499 Some((responder))
40500 } else {
40501 None
40502 }
40503 }
40504
40505 #[allow(irrefutable_let_patterns)]
40506 pub fn into_set_ip_receive_original_destination_address(
40507 self,
40508 ) -> Option<(bool, DatagramSocketSetIpReceiveOriginalDestinationAddressResponder)> {
40509 if let DatagramSocketRequest::SetIpReceiveOriginalDestinationAddress { value, responder } =
40510 self
40511 {
40512 Some((value, responder))
40513 } else {
40514 None
40515 }
40516 }
40517
40518 #[allow(irrefutable_let_patterns)]
40519 pub fn into_get_ip_receive_original_destination_address(
40520 self,
40521 ) -> Option<(DatagramSocketGetIpReceiveOriginalDestinationAddressResponder)> {
40522 if let DatagramSocketRequest::GetIpReceiveOriginalDestinationAddress { responder } = self {
40523 Some((responder))
40524 } else {
40525 None
40526 }
40527 }
40528
40529 #[allow(irrefutable_let_patterns)]
40530 pub fn into_add_ipv6_membership(
40531 self,
40532 ) -> Option<(Ipv6MulticastMembership, DatagramSocketAddIpv6MembershipResponder)> {
40533 if let DatagramSocketRequest::AddIpv6Membership { membership, responder } = self {
40534 Some((membership, responder))
40535 } else {
40536 None
40537 }
40538 }
40539
40540 #[allow(irrefutable_let_patterns)]
40541 pub fn into_drop_ipv6_membership(
40542 self,
40543 ) -> Option<(Ipv6MulticastMembership, DatagramSocketDropIpv6MembershipResponder)> {
40544 if let DatagramSocketRequest::DropIpv6Membership { membership, responder } = self {
40545 Some((membership, responder))
40546 } else {
40547 None
40548 }
40549 }
40550
40551 #[allow(irrefutable_let_patterns)]
40552 pub fn into_set_ipv6_multicast_interface(
40553 self,
40554 ) -> Option<(u64, DatagramSocketSetIpv6MulticastInterfaceResponder)> {
40555 if let DatagramSocketRequest::SetIpv6MulticastInterface { value, responder } = self {
40556 Some((value, responder))
40557 } else {
40558 None
40559 }
40560 }
40561
40562 #[allow(irrefutable_let_patterns)]
40563 pub fn into_get_ipv6_multicast_interface(
40564 self,
40565 ) -> Option<(DatagramSocketGetIpv6MulticastInterfaceResponder)> {
40566 if let DatagramSocketRequest::GetIpv6MulticastInterface { responder } = self {
40567 Some((responder))
40568 } else {
40569 None
40570 }
40571 }
40572
40573 #[allow(irrefutable_let_patterns)]
40574 pub fn into_set_ipv6_unicast_hops(
40575 self,
40576 ) -> Option<(OptionalUint8, DatagramSocketSetIpv6UnicastHopsResponder)> {
40577 if let DatagramSocketRequest::SetIpv6UnicastHops { value, responder } = self {
40578 Some((value, responder))
40579 } else {
40580 None
40581 }
40582 }
40583
40584 #[allow(irrefutable_let_patterns)]
40585 pub fn into_get_ipv6_unicast_hops(self) -> Option<(DatagramSocketGetIpv6UnicastHopsResponder)> {
40586 if let DatagramSocketRequest::GetIpv6UnicastHops { responder } = self {
40587 Some((responder))
40588 } else {
40589 None
40590 }
40591 }
40592
40593 #[allow(irrefutable_let_patterns)]
40594 pub fn into_set_ipv6_receive_hop_limit(
40595 self,
40596 ) -> Option<(bool, DatagramSocketSetIpv6ReceiveHopLimitResponder)> {
40597 if let DatagramSocketRequest::SetIpv6ReceiveHopLimit { value, responder } = self {
40598 Some((value, responder))
40599 } else {
40600 None
40601 }
40602 }
40603
40604 #[allow(irrefutable_let_patterns)]
40605 pub fn into_get_ipv6_receive_hop_limit(
40606 self,
40607 ) -> Option<(DatagramSocketGetIpv6ReceiveHopLimitResponder)> {
40608 if let DatagramSocketRequest::GetIpv6ReceiveHopLimit { responder } = self {
40609 Some((responder))
40610 } else {
40611 None
40612 }
40613 }
40614
40615 #[allow(irrefutable_let_patterns)]
40616 pub fn into_set_ipv6_multicast_hops(
40617 self,
40618 ) -> Option<(OptionalUint8, DatagramSocketSetIpv6MulticastHopsResponder)> {
40619 if let DatagramSocketRequest::SetIpv6MulticastHops { value, responder } = self {
40620 Some((value, responder))
40621 } else {
40622 None
40623 }
40624 }
40625
40626 #[allow(irrefutable_let_patterns)]
40627 pub fn into_get_ipv6_multicast_hops(
40628 self,
40629 ) -> Option<(DatagramSocketGetIpv6MulticastHopsResponder)> {
40630 if let DatagramSocketRequest::GetIpv6MulticastHops { responder } = self {
40631 Some((responder))
40632 } else {
40633 None
40634 }
40635 }
40636
40637 #[allow(irrefutable_let_patterns)]
40638 pub fn into_set_ipv6_multicast_loopback(
40639 self,
40640 ) -> Option<(bool, DatagramSocketSetIpv6MulticastLoopbackResponder)> {
40641 if let DatagramSocketRequest::SetIpv6MulticastLoopback { value, responder } = self {
40642 Some((value, responder))
40643 } else {
40644 None
40645 }
40646 }
40647
40648 #[allow(irrefutable_let_patterns)]
40649 pub fn into_get_ipv6_multicast_loopback(
40650 self,
40651 ) -> Option<(DatagramSocketGetIpv6MulticastLoopbackResponder)> {
40652 if let DatagramSocketRequest::GetIpv6MulticastLoopback { responder } = self {
40653 Some((responder))
40654 } else {
40655 None
40656 }
40657 }
40658
40659 #[allow(irrefutable_let_patterns)]
40660 pub fn into_set_ipv6_only(self) -> Option<(bool, DatagramSocketSetIpv6OnlyResponder)> {
40661 if let DatagramSocketRequest::SetIpv6Only { value, responder } = self {
40662 Some((value, responder))
40663 } else {
40664 None
40665 }
40666 }
40667
40668 #[allow(irrefutable_let_patterns)]
40669 pub fn into_get_ipv6_only(self) -> Option<(DatagramSocketGetIpv6OnlyResponder)> {
40670 if let DatagramSocketRequest::GetIpv6Only { responder } = self {
40671 Some((responder))
40672 } else {
40673 None
40674 }
40675 }
40676
40677 #[allow(irrefutable_let_patterns)]
40678 pub fn into_set_ipv6_receive_traffic_class(
40679 self,
40680 ) -> Option<(bool, DatagramSocketSetIpv6ReceiveTrafficClassResponder)> {
40681 if let DatagramSocketRequest::SetIpv6ReceiveTrafficClass { value, responder } = self {
40682 Some((value, responder))
40683 } else {
40684 None
40685 }
40686 }
40687
40688 #[allow(irrefutable_let_patterns)]
40689 pub fn into_get_ipv6_receive_traffic_class(
40690 self,
40691 ) -> Option<(DatagramSocketGetIpv6ReceiveTrafficClassResponder)> {
40692 if let DatagramSocketRequest::GetIpv6ReceiveTrafficClass { responder } = self {
40693 Some((responder))
40694 } else {
40695 None
40696 }
40697 }
40698
40699 #[allow(irrefutable_let_patterns)]
40700 pub fn into_set_ipv6_traffic_class(
40701 self,
40702 ) -> Option<(OptionalUint8, DatagramSocketSetIpv6TrafficClassResponder)> {
40703 if let DatagramSocketRequest::SetIpv6TrafficClass { value, responder } = self {
40704 Some((value, responder))
40705 } else {
40706 None
40707 }
40708 }
40709
40710 #[allow(irrefutable_let_patterns)]
40711 pub fn into_get_ipv6_traffic_class(
40712 self,
40713 ) -> Option<(DatagramSocketGetIpv6TrafficClassResponder)> {
40714 if let DatagramSocketRequest::GetIpv6TrafficClass { responder } = self {
40715 Some((responder))
40716 } else {
40717 None
40718 }
40719 }
40720
40721 #[allow(irrefutable_let_patterns)]
40722 pub fn into_set_ipv6_receive_packet_info(
40723 self,
40724 ) -> Option<(bool, DatagramSocketSetIpv6ReceivePacketInfoResponder)> {
40725 if let DatagramSocketRequest::SetIpv6ReceivePacketInfo { value, responder } = self {
40726 Some((value, responder))
40727 } else {
40728 None
40729 }
40730 }
40731
40732 #[allow(irrefutable_let_patterns)]
40733 pub fn into_get_ipv6_receive_packet_info(
40734 self,
40735 ) -> Option<(DatagramSocketGetIpv6ReceivePacketInfoResponder)> {
40736 if let DatagramSocketRequest::GetIpv6ReceivePacketInfo { responder } = self {
40737 Some((responder))
40738 } else {
40739 None
40740 }
40741 }
40742
40743 #[allow(irrefutable_let_patterns)]
40744 pub fn into_get_original_destination(
40745 self,
40746 ) -> Option<(DatagramSocketGetOriginalDestinationResponder)> {
40747 if let DatagramSocketRequest::GetOriginalDestination { responder } = self {
40748 Some((responder))
40749 } else {
40750 None
40751 }
40752 }
40753
40754 #[allow(irrefutable_let_patterns)]
40755 pub fn into_get_info(self) -> Option<(DatagramSocketGetInfoResponder)> {
40756 if let DatagramSocketRequest::GetInfo { responder } = self {
40757 Some((responder))
40758 } else {
40759 None
40760 }
40761 }
40762
40763 #[allow(irrefutable_let_patterns)]
40764 pub fn into_describe(self) -> Option<(DatagramSocketDescribeResponder)> {
40765 if let DatagramSocketRequest::Describe { responder } = self {
40766 Some((responder))
40767 } else {
40768 None
40769 }
40770 }
40771
40772 #[allow(irrefutable_let_patterns)]
40773 pub fn into_send_msg_preflight(
40774 self,
40775 ) -> Option<(DatagramSocketSendMsgPreflightRequest, DatagramSocketSendMsgPreflightResponder)>
40776 {
40777 if let DatagramSocketRequest::SendMsgPreflight { payload, responder } = self {
40778 Some((payload, responder))
40779 } else {
40780 None
40781 }
40782 }
40783
40784 #[allow(irrefutable_let_patterns)]
40785 pub fn into_recv_msg_postflight(self) -> Option<(DatagramSocketRecvMsgPostflightResponder)> {
40786 if let DatagramSocketRequest::RecvMsgPostflight { responder } = self {
40787 Some((responder))
40788 } else {
40789 None
40790 }
40791 }
40792
40793 pub fn method_name(&self) -> &'static str {
40795 match *self {
40796 DatagramSocketRequest::Clone { .. } => "clone",
40797 DatagramSocketRequest::Close { .. } => "close",
40798 DatagramSocketRequest::Query { .. } => "query",
40799 DatagramSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
40800 DatagramSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
40801 DatagramSocketRequest::GetError { .. } => "get_error",
40802 DatagramSocketRequest::SetBroadcast { .. } => "set_broadcast",
40803 DatagramSocketRequest::GetBroadcast { .. } => "get_broadcast",
40804 DatagramSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
40805 DatagramSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
40806 DatagramSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
40807 DatagramSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
40808 DatagramSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
40809 DatagramSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
40810 DatagramSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
40811 DatagramSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
40812 DatagramSocketRequest::SetNoCheck { .. } => "set_no_check",
40813 DatagramSocketRequest::GetNoCheck { .. } => "get_no_check",
40814 DatagramSocketRequest::SetLinger { .. } => "set_linger",
40815 DatagramSocketRequest::GetLinger { .. } => "get_linger",
40816 DatagramSocketRequest::SetReusePort { .. } => "set_reuse_port",
40817 DatagramSocketRequest::GetReusePort { .. } => "get_reuse_port",
40818 DatagramSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
40819 DatagramSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
40820 DatagramSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
40821 DatagramSocketRequest::SetBindToInterfaceIndex { .. } => "set_bind_to_interface_index",
40822 DatagramSocketRequest::GetBindToInterfaceIndex { .. } => "get_bind_to_interface_index",
40823 DatagramSocketRequest::SetTimestamp { .. } => "set_timestamp",
40824 DatagramSocketRequest::GetTimestamp { .. } => "get_timestamp",
40825 DatagramSocketRequest::SetMark { .. } => "set_mark",
40826 DatagramSocketRequest::GetMark { .. } => "get_mark",
40827 DatagramSocketRequest::Bind { .. } => "bind",
40828 DatagramSocketRequest::Connect { .. } => "connect",
40829 DatagramSocketRequest::Disconnect { .. } => "disconnect",
40830 DatagramSocketRequest::GetSockName { .. } => "get_sock_name",
40831 DatagramSocketRequest::GetPeerName { .. } => "get_peer_name",
40832 DatagramSocketRequest::Shutdown { .. } => "shutdown",
40833 DatagramSocketRequest::SetIpTypeOfService { .. } => "set_ip_type_of_service",
40834 DatagramSocketRequest::GetIpTypeOfService { .. } => "get_ip_type_of_service",
40835 DatagramSocketRequest::SetIpTtl { .. } => "set_ip_ttl",
40836 DatagramSocketRequest::GetIpTtl { .. } => "get_ip_ttl",
40837 DatagramSocketRequest::SetIpPacketInfo { .. } => "set_ip_packet_info",
40838 DatagramSocketRequest::GetIpPacketInfo { .. } => "get_ip_packet_info",
40839 DatagramSocketRequest::SetIpReceiveTypeOfService { .. } => {
40840 "set_ip_receive_type_of_service"
40841 }
40842 DatagramSocketRequest::GetIpReceiveTypeOfService { .. } => {
40843 "get_ip_receive_type_of_service"
40844 }
40845 DatagramSocketRequest::SetIpReceiveTtl { .. } => "set_ip_receive_ttl",
40846 DatagramSocketRequest::GetIpReceiveTtl { .. } => "get_ip_receive_ttl",
40847 DatagramSocketRequest::SetIpMulticastInterface { .. } => "set_ip_multicast_interface",
40848 DatagramSocketRequest::GetIpMulticastInterface { .. } => "get_ip_multicast_interface",
40849 DatagramSocketRequest::SetIpMulticastTtl { .. } => "set_ip_multicast_ttl",
40850 DatagramSocketRequest::GetIpMulticastTtl { .. } => "get_ip_multicast_ttl",
40851 DatagramSocketRequest::SetIpMulticastLoopback { .. } => "set_ip_multicast_loopback",
40852 DatagramSocketRequest::GetIpMulticastLoopback { .. } => "get_ip_multicast_loopback",
40853 DatagramSocketRequest::AddIpMembership { .. } => "add_ip_membership",
40854 DatagramSocketRequest::DropIpMembership { .. } => "drop_ip_membership",
40855 DatagramSocketRequest::SetIpTransparent { .. } => "set_ip_transparent",
40856 DatagramSocketRequest::GetIpTransparent { .. } => "get_ip_transparent",
40857 DatagramSocketRequest::SetIpReceiveOriginalDestinationAddress { .. } => {
40858 "set_ip_receive_original_destination_address"
40859 }
40860 DatagramSocketRequest::GetIpReceiveOriginalDestinationAddress { .. } => {
40861 "get_ip_receive_original_destination_address"
40862 }
40863 DatagramSocketRequest::AddIpv6Membership { .. } => "add_ipv6_membership",
40864 DatagramSocketRequest::DropIpv6Membership { .. } => "drop_ipv6_membership",
40865 DatagramSocketRequest::SetIpv6MulticastInterface { .. } => {
40866 "set_ipv6_multicast_interface"
40867 }
40868 DatagramSocketRequest::GetIpv6MulticastInterface { .. } => {
40869 "get_ipv6_multicast_interface"
40870 }
40871 DatagramSocketRequest::SetIpv6UnicastHops { .. } => "set_ipv6_unicast_hops",
40872 DatagramSocketRequest::GetIpv6UnicastHops { .. } => "get_ipv6_unicast_hops",
40873 DatagramSocketRequest::SetIpv6ReceiveHopLimit { .. } => "set_ipv6_receive_hop_limit",
40874 DatagramSocketRequest::GetIpv6ReceiveHopLimit { .. } => "get_ipv6_receive_hop_limit",
40875 DatagramSocketRequest::SetIpv6MulticastHops { .. } => "set_ipv6_multicast_hops",
40876 DatagramSocketRequest::GetIpv6MulticastHops { .. } => "get_ipv6_multicast_hops",
40877 DatagramSocketRequest::SetIpv6MulticastLoopback { .. } => "set_ipv6_multicast_loopback",
40878 DatagramSocketRequest::GetIpv6MulticastLoopback { .. } => "get_ipv6_multicast_loopback",
40879 DatagramSocketRequest::SetIpv6Only { .. } => "set_ipv6_only",
40880 DatagramSocketRequest::GetIpv6Only { .. } => "get_ipv6_only",
40881 DatagramSocketRequest::SetIpv6ReceiveTrafficClass { .. } => {
40882 "set_ipv6_receive_traffic_class"
40883 }
40884 DatagramSocketRequest::GetIpv6ReceiveTrafficClass { .. } => {
40885 "get_ipv6_receive_traffic_class"
40886 }
40887 DatagramSocketRequest::SetIpv6TrafficClass { .. } => "set_ipv6_traffic_class",
40888 DatagramSocketRequest::GetIpv6TrafficClass { .. } => "get_ipv6_traffic_class",
40889 DatagramSocketRequest::SetIpv6ReceivePacketInfo { .. } => {
40890 "set_ipv6_receive_packet_info"
40891 }
40892 DatagramSocketRequest::GetIpv6ReceivePacketInfo { .. } => {
40893 "get_ipv6_receive_packet_info"
40894 }
40895 DatagramSocketRequest::GetOriginalDestination { .. } => "get_original_destination",
40896 DatagramSocketRequest::GetInfo { .. } => "get_info",
40897 DatagramSocketRequest::Describe { .. } => "describe",
40898 DatagramSocketRequest::SendMsgPreflight { .. } => "send_msg_preflight",
40899 DatagramSocketRequest::RecvMsgPostflight { .. } => "recv_msg_postflight",
40900 }
40901 }
40902}
40903
40904#[derive(Debug, Clone)]
40905pub struct DatagramSocketControlHandle {
40906 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
40907}
40908
40909impl fidl::endpoints::ControlHandle for DatagramSocketControlHandle {
40910 fn shutdown(&self) {
40911 self.inner.shutdown()
40912 }
40913 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
40914 self.inner.shutdown_with_epitaph(status)
40915 }
40916
40917 fn is_closed(&self) -> bool {
40918 self.inner.channel().is_closed()
40919 }
40920 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
40921 self.inner.channel().on_closed()
40922 }
40923
40924 #[cfg(target_os = "fuchsia")]
40925 fn signal_peer(
40926 &self,
40927 clear_mask: zx::Signals,
40928 set_mask: zx::Signals,
40929 ) -> Result<(), zx_status::Status> {
40930 use fidl::Peered;
40931 self.inner.channel().signal_peer(clear_mask, set_mask)
40932 }
40933}
40934
40935impl DatagramSocketControlHandle {}
40936
40937#[must_use = "FIDL methods require a response to be sent"]
40938#[derive(Debug)]
40939pub struct DatagramSocketCloseResponder {
40940 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
40941 tx_id: u32,
40942}
40943
40944impl std::ops::Drop for DatagramSocketCloseResponder {
40948 fn drop(&mut self) {
40949 self.control_handle.shutdown();
40950 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
40952 }
40953}
40954
40955impl fidl::endpoints::Responder for DatagramSocketCloseResponder {
40956 type ControlHandle = DatagramSocketControlHandle;
40957
40958 fn control_handle(&self) -> &DatagramSocketControlHandle {
40959 &self.control_handle
40960 }
40961
40962 fn drop_without_shutdown(mut self) {
40963 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
40965 std::mem::forget(self);
40967 }
40968}
40969
40970impl DatagramSocketCloseResponder {
40971 pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
40975 let _result = self.send_raw(result);
40976 if _result.is_err() {
40977 self.control_handle.shutdown();
40978 }
40979 self.drop_without_shutdown();
40980 _result
40981 }
40982
40983 pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
40985 let _result = self.send_raw(result);
40986 self.drop_without_shutdown();
40987 _result
40988 }
40989
40990 fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
40991 self.control_handle
40992 .inner
40993 .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
40994 result,
40995 self.tx_id,
40996 0x5ac5d459ad7f657e,
40997 fidl::encoding::DynamicFlags::empty(),
40998 )
40999 }
41000}
41001
41002#[must_use = "FIDL methods require a response to be sent"]
41003#[derive(Debug)]
41004pub struct DatagramSocketQueryResponder {
41005 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41006 tx_id: u32,
41007}
41008
41009impl std::ops::Drop for DatagramSocketQueryResponder {
41013 fn drop(&mut self) {
41014 self.control_handle.shutdown();
41015 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41017 }
41018}
41019
41020impl fidl::endpoints::Responder for DatagramSocketQueryResponder {
41021 type ControlHandle = DatagramSocketControlHandle;
41022
41023 fn control_handle(&self) -> &DatagramSocketControlHandle {
41024 &self.control_handle
41025 }
41026
41027 fn drop_without_shutdown(mut self) {
41028 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41030 std::mem::forget(self);
41032 }
41033}
41034
41035impl DatagramSocketQueryResponder {
41036 pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
41040 let _result = self.send_raw(protocol);
41041 if _result.is_err() {
41042 self.control_handle.shutdown();
41043 }
41044 self.drop_without_shutdown();
41045 _result
41046 }
41047
41048 pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
41050 let _result = self.send_raw(protocol);
41051 self.drop_without_shutdown();
41052 _result
41053 }
41054
41055 fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
41056 self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
41057 (protocol,),
41058 self.tx_id,
41059 0x2658edee9decfc06,
41060 fidl::encoding::DynamicFlags::empty(),
41061 )
41062 }
41063}
41064
41065#[must_use = "FIDL methods require a response to be sent"]
41066#[derive(Debug)]
41067pub struct DatagramSocketSetReuseAddressResponder {
41068 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41069 tx_id: u32,
41070}
41071
41072impl std::ops::Drop for DatagramSocketSetReuseAddressResponder {
41076 fn drop(&mut self) {
41077 self.control_handle.shutdown();
41078 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41080 }
41081}
41082
41083impl fidl::endpoints::Responder for DatagramSocketSetReuseAddressResponder {
41084 type ControlHandle = DatagramSocketControlHandle;
41085
41086 fn control_handle(&self) -> &DatagramSocketControlHandle {
41087 &self.control_handle
41088 }
41089
41090 fn drop_without_shutdown(mut self) {
41091 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41093 std::mem::forget(self);
41095 }
41096}
41097
41098impl DatagramSocketSetReuseAddressResponder {
41099 pub fn send(
41103 self,
41104 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41105 ) -> Result<(), fidl::Error> {
41106 let _result = self.send_raw(result);
41107 if _result.is_err() {
41108 self.control_handle.shutdown();
41109 }
41110 self.drop_without_shutdown();
41111 _result
41112 }
41113
41114 pub fn send_no_shutdown_on_err(
41116 self,
41117 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41118 ) -> Result<(), fidl::Error> {
41119 let _result = self.send_raw(result);
41120 self.drop_without_shutdown();
41121 _result
41122 }
41123
41124 fn send_raw(
41125 &self,
41126 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41127 ) -> Result<(), fidl::Error> {
41128 self.control_handle.inner.send::<fidl::encoding::ResultType<
41129 fidl::encoding::EmptyStruct,
41130 fidl_fuchsia_posix::Errno,
41131 >>(
41132 result,
41133 self.tx_id,
41134 0x1fd74ee8b9a4a876,
41135 fidl::encoding::DynamicFlags::empty(),
41136 )
41137 }
41138}
41139
41140#[must_use = "FIDL methods require a response to be sent"]
41141#[derive(Debug)]
41142pub struct DatagramSocketGetReuseAddressResponder {
41143 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41144 tx_id: u32,
41145}
41146
41147impl std::ops::Drop for DatagramSocketGetReuseAddressResponder {
41151 fn drop(&mut self) {
41152 self.control_handle.shutdown();
41153 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41155 }
41156}
41157
41158impl fidl::endpoints::Responder for DatagramSocketGetReuseAddressResponder {
41159 type ControlHandle = DatagramSocketControlHandle;
41160
41161 fn control_handle(&self) -> &DatagramSocketControlHandle {
41162 &self.control_handle
41163 }
41164
41165 fn drop_without_shutdown(mut self) {
41166 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41168 std::mem::forget(self);
41170 }
41171}
41172
41173impl DatagramSocketGetReuseAddressResponder {
41174 pub fn send(
41178 self,
41179 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41180 ) -> Result<(), fidl::Error> {
41181 let _result = self.send_raw(result);
41182 if _result.is_err() {
41183 self.control_handle.shutdown();
41184 }
41185 self.drop_without_shutdown();
41186 _result
41187 }
41188
41189 pub fn send_no_shutdown_on_err(
41191 self,
41192 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41193 ) -> Result<(), fidl::Error> {
41194 let _result = self.send_raw(result);
41195 self.drop_without_shutdown();
41196 _result
41197 }
41198
41199 fn send_raw(
41200 &self,
41201 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41202 ) -> Result<(), fidl::Error> {
41203 self.control_handle.inner.send::<fidl::encoding::ResultType<
41204 BaseSocketGetReuseAddressResponse,
41205 fidl_fuchsia_posix::Errno,
41206 >>(
41207 result.map(|value| (value,)),
41208 self.tx_id,
41209 0x67b7206b8d1bc0a5,
41210 fidl::encoding::DynamicFlags::empty(),
41211 )
41212 }
41213}
41214
41215#[must_use = "FIDL methods require a response to be sent"]
41216#[derive(Debug)]
41217pub struct DatagramSocketGetErrorResponder {
41218 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41219 tx_id: u32,
41220}
41221
41222impl std::ops::Drop for DatagramSocketGetErrorResponder {
41226 fn drop(&mut self) {
41227 self.control_handle.shutdown();
41228 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41230 }
41231}
41232
41233impl fidl::endpoints::Responder for DatagramSocketGetErrorResponder {
41234 type ControlHandle = DatagramSocketControlHandle;
41235
41236 fn control_handle(&self) -> &DatagramSocketControlHandle {
41237 &self.control_handle
41238 }
41239
41240 fn drop_without_shutdown(mut self) {
41241 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41243 std::mem::forget(self);
41245 }
41246}
41247
41248impl DatagramSocketGetErrorResponder {
41249 pub fn send(
41253 self,
41254 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41255 ) -> Result<(), fidl::Error> {
41256 let _result = self.send_raw(result);
41257 if _result.is_err() {
41258 self.control_handle.shutdown();
41259 }
41260 self.drop_without_shutdown();
41261 _result
41262 }
41263
41264 pub fn send_no_shutdown_on_err(
41266 self,
41267 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41268 ) -> Result<(), fidl::Error> {
41269 let _result = self.send_raw(result);
41270 self.drop_without_shutdown();
41271 _result
41272 }
41273
41274 fn send_raw(
41275 &self,
41276 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41277 ) -> Result<(), fidl::Error> {
41278 self.control_handle.inner.send::<fidl::encoding::ResultType<
41279 fidl::encoding::EmptyStruct,
41280 fidl_fuchsia_posix::Errno,
41281 >>(
41282 result,
41283 self.tx_id,
41284 0x5aad39b33e5f6ebb,
41285 fidl::encoding::DynamicFlags::empty(),
41286 )
41287 }
41288}
41289
41290#[must_use = "FIDL methods require a response to be sent"]
41291#[derive(Debug)]
41292pub struct DatagramSocketSetBroadcastResponder {
41293 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41294 tx_id: u32,
41295}
41296
41297impl std::ops::Drop for DatagramSocketSetBroadcastResponder {
41301 fn drop(&mut self) {
41302 self.control_handle.shutdown();
41303 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41305 }
41306}
41307
41308impl fidl::endpoints::Responder for DatagramSocketSetBroadcastResponder {
41309 type ControlHandle = DatagramSocketControlHandle;
41310
41311 fn control_handle(&self) -> &DatagramSocketControlHandle {
41312 &self.control_handle
41313 }
41314
41315 fn drop_without_shutdown(mut self) {
41316 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41318 std::mem::forget(self);
41320 }
41321}
41322
41323impl DatagramSocketSetBroadcastResponder {
41324 pub fn send(
41328 self,
41329 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41330 ) -> Result<(), fidl::Error> {
41331 let _result = self.send_raw(result);
41332 if _result.is_err() {
41333 self.control_handle.shutdown();
41334 }
41335 self.drop_without_shutdown();
41336 _result
41337 }
41338
41339 pub fn send_no_shutdown_on_err(
41341 self,
41342 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41343 ) -> Result<(), fidl::Error> {
41344 let _result = self.send_raw(result);
41345 self.drop_without_shutdown();
41346 _result
41347 }
41348
41349 fn send_raw(
41350 &self,
41351 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41352 ) -> Result<(), fidl::Error> {
41353 self.control_handle.inner.send::<fidl::encoding::ResultType<
41354 fidl::encoding::EmptyStruct,
41355 fidl_fuchsia_posix::Errno,
41356 >>(
41357 result,
41358 self.tx_id,
41359 0x6023e081ce3cd947,
41360 fidl::encoding::DynamicFlags::empty(),
41361 )
41362 }
41363}
41364
41365#[must_use = "FIDL methods require a response to be sent"]
41366#[derive(Debug)]
41367pub struct DatagramSocketGetBroadcastResponder {
41368 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41369 tx_id: u32,
41370}
41371
41372impl std::ops::Drop for DatagramSocketGetBroadcastResponder {
41376 fn drop(&mut self) {
41377 self.control_handle.shutdown();
41378 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41380 }
41381}
41382
41383impl fidl::endpoints::Responder for DatagramSocketGetBroadcastResponder {
41384 type ControlHandle = DatagramSocketControlHandle;
41385
41386 fn control_handle(&self) -> &DatagramSocketControlHandle {
41387 &self.control_handle
41388 }
41389
41390 fn drop_without_shutdown(mut self) {
41391 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41393 std::mem::forget(self);
41395 }
41396}
41397
41398impl DatagramSocketGetBroadcastResponder {
41399 pub fn send(
41403 self,
41404 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41405 ) -> Result<(), fidl::Error> {
41406 let _result = self.send_raw(result);
41407 if _result.is_err() {
41408 self.control_handle.shutdown();
41409 }
41410 self.drop_without_shutdown();
41411 _result
41412 }
41413
41414 pub fn send_no_shutdown_on_err(
41416 self,
41417 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41418 ) -> Result<(), fidl::Error> {
41419 let _result = self.send_raw(result);
41420 self.drop_without_shutdown();
41421 _result
41422 }
41423
41424 fn send_raw(
41425 &self,
41426 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41427 ) -> Result<(), fidl::Error> {
41428 self.control_handle.inner.send::<fidl::encoding::ResultType<
41429 BaseSocketGetBroadcastResponse,
41430 fidl_fuchsia_posix::Errno,
41431 >>(
41432 result.map(|value| (value,)),
41433 self.tx_id,
41434 0x68796fc556f9780d,
41435 fidl::encoding::DynamicFlags::empty(),
41436 )
41437 }
41438}
41439
41440#[must_use = "FIDL methods require a response to be sent"]
41441#[derive(Debug)]
41442pub struct DatagramSocketSetSendBufferResponder {
41443 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41444 tx_id: u32,
41445}
41446
41447impl std::ops::Drop for DatagramSocketSetSendBufferResponder {
41451 fn drop(&mut self) {
41452 self.control_handle.shutdown();
41453 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41455 }
41456}
41457
41458impl fidl::endpoints::Responder for DatagramSocketSetSendBufferResponder {
41459 type ControlHandle = DatagramSocketControlHandle;
41460
41461 fn control_handle(&self) -> &DatagramSocketControlHandle {
41462 &self.control_handle
41463 }
41464
41465 fn drop_without_shutdown(mut self) {
41466 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41468 std::mem::forget(self);
41470 }
41471}
41472
41473impl DatagramSocketSetSendBufferResponder {
41474 pub fn send(
41478 self,
41479 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41480 ) -> Result<(), fidl::Error> {
41481 let _result = self.send_raw(result);
41482 if _result.is_err() {
41483 self.control_handle.shutdown();
41484 }
41485 self.drop_without_shutdown();
41486 _result
41487 }
41488
41489 pub fn send_no_shutdown_on_err(
41491 self,
41492 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41493 ) -> Result<(), fidl::Error> {
41494 let _result = self.send_raw(result);
41495 self.drop_without_shutdown();
41496 _result
41497 }
41498
41499 fn send_raw(
41500 &self,
41501 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41502 ) -> Result<(), fidl::Error> {
41503 self.control_handle.inner.send::<fidl::encoding::ResultType<
41504 fidl::encoding::EmptyStruct,
41505 fidl_fuchsia_posix::Errno,
41506 >>(
41507 result,
41508 self.tx_id,
41509 0x756eac32d73a7a70,
41510 fidl::encoding::DynamicFlags::empty(),
41511 )
41512 }
41513}
41514
41515#[must_use = "FIDL methods require a response to be sent"]
41516#[derive(Debug)]
41517pub struct DatagramSocketGetSendBufferResponder {
41518 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41519 tx_id: u32,
41520}
41521
41522impl std::ops::Drop for DatagramSocketGetSendBufferResponder {
41526 fn drop(&mut self) {
41527 self.control_handle.shutdown();
41528 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41530 }
41531}
41532
41533impl fidl::endpoints::Responder for DatagramSocketGetSendBufferResponder {
41534 type ControlHandle = DatagramSocketControlHandle;
41535
41536 fn control_handle(&self) -> &DatagramSocketControlHandle {
41537 &self.control_handle
41538 }
41539
41540 fn drop_without_shutdown(mut self) {
41541 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41543 std::mem::forget(self);
41545 }
41546}
41547
41548impl DatagramSocketGetSendBufferResponder {
41549 pub fn send(
41553 self,
41554 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
41555 ) -> Result<(), fidl::Error> {
41556 let _result = self.send_raw(result);
41557 if _result.is_err() {
41558 self.control_handle.shutdown();
41559 }
41560 self.drop_without_shutdown();
41561 _result
41562 }
41563
41564 pub fn send_no_shutdown_on_err(
41566 self,
41567 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
41568 ) -> Result<(), fidl::Error> {
41569 let _result = self.send_raw(result);
41570 self.drop_without_shutdown();
41571 _result
41572 }
41573
41574 fn send_raw(
41575 &self,
41576 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
41577 ) -> Result<(), fidl::Error> {
41578 self.control_handle.inner.send::<fidl::encoding::ResultType<
41579 BaseSocketGetSendBufferResponse,
41580 fidl_fuchsia_posix::Errno,
41581 >>(
41582 result.map(|value_bytes| (value_bytes,)),
41583 self.tx_id,
41584 0x78a52fd9c7b2410b,
41585 fidl::encoding::DynamicFlags::empty(),
41586 )
41587 }
41588}
41589
41590#[must_use = "FIDL methods require a response to be sent"]
41591#[derive(Debug)]
41592pub struct DatagramSocketSetReceiveBufferResponder {
41593 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41594 tx_id: u32,
41595}
41596
41597impl std::ops::Drop for DatagramSocketSetReceiveBufferResponder {
41601 fn drop(&mut self) {
41602 self.control_handle.shutdown();
41603 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41605 }
41606}
41607
41608impl fidl::endpoints::Responder for DatagramSocketSetReceiveBufferResponder {
41609 type ControlHandle = DatagramSocketControlHandle;
41610
41611 fn control_handle(&self) -> &DatagramSocketControlHandle {
41612 &self.control_handle
41613 }
41614
41615 fn drop_without_shutdown(mut self) {
41616 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41618 std::mem::forget(self);
41620 }
41621}
41622
41623impl DatagramSocketSetReceiveBufferResponder {
41624 pub fn send(
41628 self,
41629 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41630 ) -> Result<(), fidl::Error> {
41631 let _result = self.send_raw(result);
41632 if _result.is_err() {
41633 self.control_handle.shutdown();
41634 }
41635 self.drop_without_shutdown();
41636 _result
41637 }
41638
41639 pub fn send_no_shutdown_on_err(
41641 self,
41642 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41643 ) -> Result<(), fidl::Error> {
41644 let _result = self.send_raw(result);
41645 self.drop_without_shutdown();
41646 _result
41647 }
41648
41649 fn send_raw(
41650 &self,
41651 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41652 ) -> Result<(), fidl::Error> {
41653 self.control_handle.inner.send::<fidl::encoding::ResultType<
41654 fidl::encoding::EmptyStruct,
41655 fidl_fuchsia_posix::Errno,
41656 >>(
41657 result,
41658 self.tx_id,
41659 0x6b0cf2f1919c7001,
41660 fidl::encoding::DynamicFlags::empty(),
41661 )
41662 }
41663}
41664
41665#[must_use = "FIDL methods require a response to be sent"]
41666#[derive(Debug)]
41667pub struct DatagramSocketGetReceiveBufferResponder {
41668 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41669 tx_id: u32,
41670}
41671
41672impl std::ops::Drop for DatagramSocketGetReceiveBufferResponder {
41676 fn drop(&mut self) {
41677 self.control_handle.shutdown();
41678 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41680 }
41681}
41682
41683impl fidl::endpoints::Responder for DatagramSocketGetReceiveBufferResponder {
41684 type ControlHandle = DatagramSocketControlHandle;
41685
41686 fn control_handle(&self) -> &DatagramSocketControlHandle {
41687 &self.control_handle
41688 }
41689
41690 fn drop_without_shutdown(mut self) {
41691 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41693 std::mem::forget(self);
41695 }
41696}
41697
41698impl DatagramSocketGetReceiveBufferResponder {
41699 pub fn send(
41703 self,
41704 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
41705 ) -> Result<(), fidl::Error> {
41706 let _result = self.send_raw(result);
41707 if _result.is_err() {
41708 self.control_handle.shutdown();
41709 }
41710 self.drop_without_shutdown();
41711 _result
41712 }
41713
41714 pub fn send_no_shutdown_on_err(
41716 self,
41717 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
41718 ) -> Result<(), fidl::Error> {
41719 let _result = self.send_raw(result);
41720 self.drop_without_shutdown();
41721 _result
41722 }
41723
41724 fn send_raw(
41725 &self,
41726 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
41727 ) -> Result<(), fidl::Error> {
41728 self.control_handle.inner.send::<fidl::encoding::ResultType<
41729 BaseSocketGetReceiveBufferResponse,
41730 fidl_fuchsia_posix::Errno,
41731 >>(
41732 result.map(|value_bytes| (value_bytes,)),
41733 self.tx_id,
41734 0x14c1a4b64f709e5c,
41735 fidl::encoding::DynamicFlags::empty(),
41736 )
41737 }
41738}
41739
41740#[must_use = "FIDL methods require a response to be sent"]
41741#[derive(Debug)]
41742pub struct DatagramSocketSetKeepAliveResponder {
41743 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41744 tx_id: u32,
41745}
41746
41747impl std::ops::Drop for DatagramSocketSetKeepAliveResponder {
41751 fn drop(&mut self) {
41752 self.control_handle.shutdown();
41753 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41755 }
41756}
41757
41758impl fidl::endpoints::Responder for DatagramSocketSetKeepAliveResponder {
41759 type ControlHandle = DatagramSocketControlHandle;
41760
41761 fn control_handle(&self) -> &DatagramSocketControlHandle {
41762 &self.control_handle
41763 }
41764
41765 fn drop_without_shutdown(mut self) {
41766 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41768 std::mem::forget(self);
41770 }
41771}
41772
41773impl DatagramSocketSetKeepAliveResponder {
41774 pub fn send(
41778 self,
41779 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41780 ) -> Result<(), fidl::Error> {
41781 let _result = self.send_raw(result);
41782 if _result.is_err() {
41783 self.control_handle.shutdown();
41784 }
41785 self.drop_without_shutdown();
41786 _result
41787 }
41788
41789 pub fn send_no_shutdown_on_err(
41791 self,
41792 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41793 ) -> Result<(), fidl::Error> {
41794 let _result = self.send_raw(result);
41795 self.drop_without_shutdown();
41796 _result
41797 }
41798
41799 fn send_raw(
41800 &self,
41801 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41802 ) -> Result<(), fidl::Error> {
41803 self.control_handle.inner.send::<fidl::encoding::ResultType<
41804 fidl::encoding::EmptyStruct,
41805 fidl_fuchsia_posix::Errno,
41806 >>(
41807 result,
41808 self.tx_id,
41809 0x572df8f0b920d2c7,
41810 fidl::encoding::DynamicFlags::empty(),
41811 )
41812 }
41813}
41814
41815#[must_use = "FIDL methods require a response to be sent"]
41816#[derive(Debug)]
41817pub struct DatagramSocketGetKeepAliveResponder {
41818 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41819 tx_id: u32,
41820}
41821
41822impl std::ops::Drop for DatagramSocketGetKeepAliveResponder {
41826 fn drop(&mut self) {
41827 self.control_handle.shutdown();
41828 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41830 }
41831}
41832
41833impl fidl::endpoints::Responder for DatagramSocketGetKeepAliveResponder {
41834 type ControlHandle = DatagramSocketControlHandle;
41835
41836 fn control_handle(&self) -> &DatagramSocketControlHandle {
41837 &self.control_handle
41838 }
41839
41840 fn drop_without_shutdown(mut self) {
41841 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41843 std::mem::forget(self);
41845 }
41846}
41847
41848impl DatagramSocketGetKeepAliveResponder {
41849 pub fn send(
41853 self,
41854 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41855 ) -> Result<(), fidl::Error> {
41856 let _result = self.send_raw(result);
41857 if _result.is_err() {
41858 self.control_handle.shutdown();
41859 }
41860 self.drop_without_shutdown();
41861 _result
41862 }
41863
41864 pub fn send_no_shutdown_on_err(
41866 self,
41867 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41868 ) -> Result<(), fidl::Error> {
41869 let _result = self.send_raw(result);
41870 self.drop_without_shutdown();
41871 _result
41872 }
41873
41874 fn send_raw(
41875 &self,
41876 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41877 ) -> Result<(), fidl::Error> {
41878 self.control_handle.inner.send::<fidl::encoding::ResultType<
41879 BaseSocketGetKeepAliveResponse,
41880 fidl_fuchsia_posix::Errno,
41881 >>(
41882 result.map(|value| (value,)),
41883 self.tx_id,
41884 0x2dd29d3215f2c9d2,
41885 fidl::encoding::DynamicFlags::empty(),
41886 )
41887 }
41888}
41889
41890#[must_use = "FIDL methods require a response to be sent"]
41891#[derive(Debug)]
41892pub struct DatagramSocketSetOutOfBandInlineResponder {
41893 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41894 tx_id: u32,
41895}
41896
41897impl std::ops::Drop for DatagramSocketSetOutOfBandInlineResponder {
41901 fn drop(&mut self) {
41902 self.control_handle.shutdown();
41903 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41905 }
41906}
41907
41908impl fidl::endpoints::Responder for DatagramSocketSetOutOfBandInlineResponder {
41909 type ControlHandle = DatagramSocketControlHandle;
41910
41911 fn control_handle(&self) -> &DatagramSocketControlHandle {
41912 &self.control_handle
41913 }
41914
41915 fn drop_without_shutdown(mut self) {
41916 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41918 std::mem::forget(self);
41920 }
41921}
41922
41923impl DatagramSocketSetOutOfBandInlineResponder {
41924 pub fn send(
41928 self,
41929 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41930 ) -> Result<(), fidl::Error> {
41931 let _result = self.send_raw(result);
41932 if _result.is_err() {
41933 self.control_handle.shutdown();
41934 }
41935 self.drop_without_shutdown();
41936 _result
41937 }
41938
41939 pub fn send_no_shutdown_on_err(
41941 self,
41942 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41943 ) -> Result<(), fidl::Error> {
41944 let _result = self.send_raw(result);
41945 self.drop_without_shutdown();
41946 _result
41947 }
41948
41949 fn send_raw(
41950 &self,
41951 mut result: Result<(), fidl_fuchsia_posix::Errno>,
41952 ) -> Result<(), fidl::Error> {
41953 self.control_handle.inner.send::<fidl::encoding::ResultType<
41954 fidl::encoding::EmptyStruct,
41955 fidl_fuchsia_posix::Errno,
41956 >>(
41957 result,
41958 self.tx_id,
41959 0x3ecb49968bee439,
41960 fidl::encoding::DynamicFlags::empty(),
41961 )
41962 }
41963}
41964
41965#[must_use = "FIDL methods require a response to be sent"]
41966#[derive(Debug)]
41967pub struct DatagramSocketGetOutOfBandInlineResponder {
41968 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41969 tx_id: u32,
41970}
41971
41972impl std::ops::Drop for DatagramSocketGetOutOfBandInlineResponder {
41976 fn drop(&mut self) {
41977 self.control_handle.shutdown();
41978 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41980 }
41981}
41982
41983impl fidl::endpoints::Responder for DatagramSocketGetOutOfBandInlineResponder {
41984 type ControlHandle = DatagramSocketControlHandle;
41985
41986 fn control_handle(&self) -> &DatagramSocketControlHandle {
41987 &self.control_handle
41988 }
41989
41990 fn drop_without_shutdown(mut self) {
41991 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41993 std::mem::forget(self);
41995 }
41996}
41997
41998impl DatagramSocketGetOutOfBandInlineResponder {
41999 pub fn send(
42003 self,
42004 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42005 ) -> Result<(), fidl::Error> {
42006 let _result = self.send_raw(result);
42007 if _result.is_err() {
42008 self.control_handle.shutdown();
42009 }
42010 self.drop_without_shutdown();
42011 _result
42012 }
42013
42014 pub fn send_no_shutdown_on_err(
42016 self,
42017 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42018 ) -> Result<(), fidl::Error> {
42019 let _result = self.send_raw(result);
42020 self.drop_without_shutdown();
42021 _result
42022 }
42023
42024 fn send_raw(
42025 &self,
42026 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42027 ) -> Result<(), fidl::Error> {
42028 self.control_handle.inner.send::<fidl::encoding::ResultType<
42029 BaseSocketGetOutOfBandInlineResponse,
42030 fidl_fuchsia_posix::Errno,
42031 >>(
42032 result.map(|value| (value,)),
42033 self.tx_id,
42034 0x348c1ab3aeca1745,
42035 fidl::encoding::DynamicFlags::empty(),
42036 )
42037 }
42038}
42039
42040#[must_use = "FIDL methods require a response to be sent"]
42041#[derive(Debug)]
42042pub struct DatagramSocketSetNoCheckResponder {
42043 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42044 tx_id: u32,
42045}
42046
42047impl std::ops::Drop for DatagramSocketSetNoCheckResponder {
42051 fn drop(&mut self) {
42052 self.control_handle.shutdown();
42053 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42055 }
42056}
42057
42058impl fidl::endpoints::Responder for DatagramSocketSetNoCheckResponder {
42059 type ControlHandle = DatagramSocketControlHandle;
42060
42061 fn control_handle(&self) -> &DatagramSocketControlHandle {
42062 &self.control_handle
42063 }
42064
42065 fn drop_without_shutdown(mut self) {
42066 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42068 std::mem::forget(self);
42070 }
42071}
42072
42073impl DatagramSocketSetNoCheckResponder {
42074 pub fn send(
42078 self,
42079 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42080 ) -> Result<(), fidl::Error> {
42081 let _result = self.send_raw(result);
42082 if _result.is_err() {
42083 self.control_handle.shutdown();
42084 }
42085 self.drop_without_shutdown();
42086 _result
42087 }
42088
42089 pub fn send_no_shutdown_on_err(
42091 self,
42092 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42093 ) -> Result<(), fidl::Error> {
42094 let _result = self.send_raw(result);
42095 self.drop_without_shutdown();
42096 _result
42097 }
42098
42099 fn send_raw(
42100 &self,
42101 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42102 ) -> Result<(), fidl::Error> {
42103 self.control_handle.inner.send::<fidl::encoding::ResultType<
42104 fidl::encoding::EmptyStruct,
42105 fidl_fuchsia_posix::Errno,
42106 >>(
42107 result,
42108 self.tx_id,
42109 0x6bbf00c53a4c78c2,
42110 fidl::encoding::DynamicFlags::empty(),
42111 )
42112 }
42113}
42114
42115#[must_use = "FIDL methods require a response to be sent"]
42116#[derive(Debug)]
42117pub struct DatagramSocketGetNoCheckResponder {
42118 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42119 tx_id: u32,
42120}
42121
42122impl std::ops::Drop for DatagramSocketGetNoCheckResponder {
42126 fn drop(&mut self) {
42127 self.control_handle.shutdown();
42128 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42130 }
42131}
42132
42133impl fidl::endpoints::Responder for DatagramSocketGetNoCheckResponder {
42134 type ControlHandle = DatagramSocketControlHandle;
42135
42136 fn control_handle(&self) -> &DatagramSocketControlHandle {
42137 &self.control_handle
42138 }
42139
42140 fn drop_without_shutdown(mut self) {
42141 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42143 std::mem::forget(self);
42145 }
42146}
42147
42148impl DatagramSocketGetNoCheckResponder {
42149 pub fn send(
42153 self,
42154 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42155 ) -> Result<(), fidl::Error> {
42156 let _result = self.send_raw(result);
42157 if _result.is_err() {
42158 self.control_handle.shutdown();
42159 }
42160 self.drop_without_shutdown();
42161 _result
42162 }
42163
42164 pub fn send_no_shutdown_on_err(
42166 self,
42167 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42168 ) -> Result<(), fidl::Error> {
42169 let _result = self.send_raw(result);
42170 self.drop_without_shutdown();
42171 _result
42172 }
42173
42174 fn send_raw(
42175 &self,
42176 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42177 ) -> Result<(), fidl::Error> {
42178 self.control_handle.inner.send::<fidl::encoding::ResultType<
42179 BaseSocketGetNoCheckResponse,
42180 fidl_fuchsia_posix::Errno,
42181 >>(
42182 result.map(|value| (value,)),
42183 self.tx_id,
42184 0x2cd4249286417694,
42185 fidl::encoding::DynamicFlags::empty(),
42186 )
42187 }
42188}
42189
42190#[must_use = "FIDL methods require a response to be sent"]
42191#[derive(Debug)]
42192pub struct DatagramSocketSetLingerResponder {
42193 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42194 tx_id: u32,
42195}
42196
42197impl std::ops::Drop for DatagramSocketSetLingerResponder {
42201 fn drop(&mut self) {
42202 self.control_handle.shutdown();
42203 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42205 }
42206}
42207
42208impl fidl::endpoints::Responder for DatagramSocketSetLingerResponder {
42209 type ControlHandle = DatagramSocketControlHandle;
42210
42211 fn control_handle(&self) -> &DatagramSocketControlHandle {
42212 &self.control_handle
42213 }
42214
42215 fn drop_without_shutdown(mut self) {
42216 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42218 std::mem::forget(self);
42220 }
42221}
42222
42223impl DatagramSocketSetLingerResponder {
42224 pub fn send(
42228 self,
42229 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42230 ) -> Result<(), fidl::Error> {
42231 let _result = self.send_raw(result);
42232 if _result.is_err() {
42233 self.control_handle.shutdown();
42234 }
42235 self.drop_without_shutdown();
42236 _result
42237 }
42238
42239 pub fn send_no_shutdown_on_err(
42241 self,
42242 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42243 ) -> Result<(), fidl::Error> {
42244 let _result = self.send_raw(result);
42245 self.drop_without_shutdown();
42246 _result
42247 }
42248
42249 fn send_raw(
42250 &self,
42251 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42252 ) -> Result<(), fidl::Error> {
42253 self.control_handle.inner.send::<fidl::encoding::ResultType<
42254 fidl::encoding::EmptyStruct,
42255 fidl_fuchsia_posix::Errno,
42256 >>(
42257 result,
42258 self.tx_id,
42259 0x45386351246e998e,
42260 fidl::encoding::DynamicFlags::empty(),
42261 )
42262 }
42263}
42264
42265#[must_use = "FIDL methods require a response to be sent"]
42266#[derive(Debug)]
42267pub struct DatagramSocketGetLingerResponder {
42268 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42269 tx_id: u32,
42270}
42271
42272impl std::ops::Drop for DatagramSocketGetLingerResponder {
42276 fn drop(&mut self) {
42277 self.control_handle.shutdown();
42278 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42280 }
42281}
42282
42283impl fidl::endpoints::Responder for DatagramSocketGetLingerResponder {
42284 type ControlHandle = DatagramSocketControlHandle;
42285
42286 fn control_handle(&self) -> &DatagramSocketControlHandle {
42287 &self.control_handle
42288 }
42289
42290 fn drop_without_shutdown(mut self) {
42291 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42293 std::mem::forget(self);
42295 }
42296}
42297
42298impl DatagramSocketGetLingerResponder {
42299 pub fn send(
42303 self,
42304 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
42305 ) -> Result<(), fidl::Error> {
42306 let _result = self.send_raw(result);
42307 if _result.is_err() {
42308 self.control_handle.shutdown();
42309 }
42310 self.drop_without_shutdown();
42311 _result
42312 }
42313
42314 pub fn send_no_shutdown_on_err(
42316 self,
42317 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
42318 ) -> Result<(), fidl::Error> {
42319 let _result = self.send_raw(result);
42320 self.drop_without_shutdown();
42321 _result
42322 }
42323
42324 fn send_raw(
42325 &self,
42326 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
42327 ) -> Result<(), fidl::Error> {
42328 self.control_handle.inner.send::<fidl::encoding::ResultType<
42329 BaseSocketGetLingerResponse,
42330 fidl_fuchsia_posix::Errno,
42331 >>(
42332 result,
42333 self.tx_id,
42334 0x48eb20fc5ccb0e45,
42335 fidl::encoding::DynamicFlags::empty(),
42336 )
42337 }
42338}
42339
42340#[must_use = "FIDL methods require a response to be sent"]
42341#[derive(Debug)]
42342pub struct DatagramSocketSetReusePortResponder {
42343 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42344 tx_id: u32,
42345}
42346
42347impl std::ops::Drop for DatagramSocketSetReusePortResponder {
42351 fn drop(&mut self) {
42352 self.control_handle.shutdown();
42353 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42355 }
42356}
42357
42358impl fidl::endpoints::Responder for DatagramSocketSetReusePortResponder {
42359 type ControlHandle = DatagramSocketControlHandle;
42360
42361 fn control_handle(&self) -> &DatagramSocketControlHandle {
42362 &self.control_handle
42363 }
42364
42365 fn drop_without_shutdown(mut self) {
42366 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42368 std::mem::forget(self);
42370 }
42371}
42372
42373impl DatagramSocketSetReusePortResponder {
42374 pub fn send(
42378 self,
42379 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42380 ) -> Result<(), fidl::Error> {
42381 let _result = self.send_raw(result);
42382 if _result.is_err() {
42383 self.control_handle.shutdown();
42384 }
42385 self.drop_without_shutdown();
42386 _result
42387 }
42388
42389 pub fn send_no_shutdown_on_err(
42391 self,
42392 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42393 ) -> Result<(), fidl::Error> {
42394 let _result = self.send_raw(result);
42395 self.drop_without_shutdown();
42396 _result
42397 }
42398
42399 fn send_raw(
42400 &self,
42401 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42402 ) -> Result<(), fidl::Error> {
42403 self.control_handle.inner.send::<fidl::encoding::ResultType<
42404 fidl::encoding::EmptyStruct,
42405 fidl_fuchsia_posix::Errno,
42406 >>(
42407 result,
42408 self.tx_id,
42409 0x24dd3e5cb36d9ccb,
42410 fidl::encoding::DynamicFlags::empty(),
42411 )
42412 }
42413}
42414
42415#[must_use = "FIDL methods require a response to be sent"]
42416#[derive(Debug)]
42417pub struct DatagramSocketGetReusePortResponder {
42418 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42419 tx_id: u32,
42420}
42421
42422impl std::ops::Drop for DatagramSocketGetReusePortResponder {
42426 fn drop(&mut self) {
42427 self.control_handle.shutdown();
42428 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42430 }
42431}
42432
42433impl fidl::endpoints::Responder for DatagramSocketGetReusePortResponder {
42434 type ControlHandle = DatagramSocketControlHandle;
42435
42436 fn control_handle(&self) -> &DatagramSocketControlHandle {
42437 &self.control_handle
42438 }
42439
42440 fn drop_without_shutdown(mut self) {
42441 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42443 std::mem::forget(self);
42445 }
42446}
42447
42448impl DatagramSocketGetReusePortResponder {
42449 pub fn send(
42453 self,
42454 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42455 ) -> Result<(), fidl::Error> {
42456 let _result = self.send_raw(result);
42457 if _result.is_err() {
42458 self.control_handle.shutdown();
42459 }
42460 self.drop_without_shutdown();
42461 _result
42462 }
42463
42464 pub fn send_no_shutdown_on_err(
42466 self,
42467 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42468 ) -> Result<(), fidl::Error> {
42469 let _result = self.send_raw(result);
42470 self.drop_without_shutdown();
42471 _result
42472 }
42473
42474 fn send_raw(
42475 &self,
42476 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42477 ) -> Result<(), fidl::Error> {
42478 self.control_handle.inner.send::<fidl::encoding::ResultType<
42479 BaseSocketGetReusePortResponse,
42480 fidl_fuchsia_posix::Errno,
42481 >>(
42482 result.map(|value| (value,)),
42483 self.tx_id,
42484 0x7a112c1ab54ff828,
42485 fidl::encoding::DynamicFlags::empty(),
42486 )
42487 }
42488}
42489
42490#[must_use = "FIDL methods require a response to be sent"]
42491#[derive(Debug)]
42492pub struct DatagramSocketGetAcceptConnResponder {
42493 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42494 tx_id: u32,
42495}
42496
42497impl std::ops::Drop for DatagramSocketGetAcceptConnResponder {
42501 fn drop(&mut self) {
42502 self.control_handle.shutdown();
42503 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42505 }
42506}
42507
42508impl fidl::endpoints::Responder for DatagramSocketGetAcceptConnResponder {
42509 type ControlHandle = DatagramSocketControlHandle;
42510
42511 fn control_handle(&self) -> &DatagramSocketControlHandle {
42512 &self.control_handle
42513 }
42514
42515 fn drop_without_shutdown(mut self) {
42516 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42518 std::mem::forget(self);
42520 }
42521}
42522
42523impl DatagramSocketGetAcceptConnResponder {
42524 pub fn send(
42528 self,
42529 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42530 ) -> Result<(), fidl::Error> {
42531 let _result = self.send_raw(result);
42532 if _result.is_err() {
42533 self.control_handle.shutdown();
42534 }
42535 self.drop_without_shutdown();
42536 _result
42537 }
42538
42539 pub fn send_no_shutdown_on_err(
42541 self,
42542 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42543 ) -> Result<(), fidl::Error> {
42544 let _result = self.send_raw(result);
42545 self.drop_without_shutdown();
42546 _result
42547 }
42548
42549 fn send_raw(
42550 &self,
42551 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42552 ) -> Result<(), fidl::Error> {
42553 self.control_handle.inner.send::<fidl::encoding::ResultType<
42554 BaseSocketGetAcceptConnResponse,
42555 fidl_fuchsia_posix::Errno,
42556 >>(
42557 result.map(|value| (value,)),
42558 self.tx_id,
42559 0x67ce6db6c2ec8966,
42560 fidl::encoding::DynamicFlags::empty(),
42561 )
42562 }
42563}
42564
42565#[must_use = "FIDL methods require a response to be sent"]
42566#[derive(Debug)]
42567pub struct DatagramSocketSetBindToDeviceResponder {
42568 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42569 tx_id: u32,
42570}
42571
42572impl std::ops::Drop for DatagramSocketSetBindToDeviceResponder {
42576 fn drop(&mut self) {
42577 self.control_handle.shutdown();
42578 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42580 }
42581}
42582
42583impl fidl::endpoints::Responder for DatagramSocketSetBindToDeviceResponder {
42584 type ControlHandle = DatagramSocketControlHandle;
42585
42586 fn control_handle(&self) -> &DatagramSocketControlHandle {
42587 &self.control_handle
42588 }
42589
42590 fn drop_without_shutdown(mut self) {
42591 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42593 std::mem::forget(self);
42595 }
42596}
42597
42598impl DatagramSocketSetBindToDeviceResponder {
42599 pub fn send(
42603 self,
42604 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42605 ) -> Result<(), fidl::Error> {
42606 let _result = self.send_raw(result);
42607 if _result.is_err() {
42608 self.control_handle.shutdown();
42609 }
42610 self.drop_without_shutdown();
42611 _result
42612 }
42613
42614 pub fn send_no_shutdown_on_err(
42616 self,
42617 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42618 ) -> Result<(), fidl::Error> {
42619 let _result = self.send_raw(result);
42620 self.drop_without_shutdown();
42621 _result
42622 }
42623
42624 fn send_raw(
42625 &self,
42626 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42627 ) -> Result<(), fidl::Error> {
42628 self.control_handle.inner.send::<fidl::encoding::ResultType<
42629 fidl::encoding::EmptyStruct,
42630 fidl_fuchsia_posix::Errno,
42631 >>(
42632 result,
42633 self.tx_id,
42634 0x2118b483f28aafc4,
42635 fidl::encoding::DynamicFlags::empty(),
42636 )
42637 }
42638}
42639
42640#[must_use = "FIDL methods require a response to be sent"]
42641#[derive(Debug)]
42642pub struct DatagramSocketGetBindToDeviceResponder {
42643 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42644 tx_id: u32,
42645}
42646
42647impl std::ops::Drop for DatagramSocketGetBindToDeviceResponder {
42651 fn drop(&mut self) {
42652 self.control_handle.shutdown();
42653 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42655 }
42656}
42657
42658impl fidl::endpoints::Responder for DatagramSocketGetBindToDeviceResponder {
42659 type ControlHandle = DatagramSocketControlHandle;
42660
42661 fn control_handle(&self) -> &DatagramSocketControlHandle {
42662 &self.control_handle
42663 }
42664
42665 fn drop_without_shutdown(mut self) {
42666 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42668 std::mem::forget(self);
42670 }
42671}
42672
42673impl DatagramSocketGetBindToDeviceResponder {
42674 pub fn send(
42678 self,
42679 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
42680 ) -> Result<(), fidl::Error> {
42681 let _result = self.send_raw(result);
42682 if _result.is_err() {
42683 self.control_handle.shutdown();
42684 }
42685 self.drop_without_shutdown();
42686 _result
42687 }
42688
42689 pub fn send_no_shutdown_on_err(
42691 self,
42692 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
42693 ) -> Result<(), fidl::Error> {
42694 let _result = self.send_raw(result);
42695 self.drop_without_shutdown();
42696 _result
42697 }
42698
42699 fn send_raw(
42700 &self,
42701 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
42702 ) -> Result<(), fidl::Error> {
42703 self.control_handle.inner.send::<fidl::encoding::ResultType<
42704 BaseSocketGetBindToDeviceResponse,
42705 fidl_fuchsia_posix::Errno,
42706 >>(
42707 result.map(|value| (value,)),
42708 self.tx_id,
42709 0x1ab1fbf0ef7906c8,
42710 fidl::encoding::DynamicFlags::empty(),
42711 )
42712 }
42713}
42714
42715#[must_use = "FIDL methods require a response to be sent"]
42716#[derive(Debug)]
42717pub struct DatagramSocketSetBindToInterfaceIndexResponder {
42718 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42719 tx_id: u32,
42720}
42721
42722impl std::ops::Drop for DatagramSocketSetBindToInterfaceIndexResponder {
42726 fn drop(&mut self) {
42727 self.control_handle.shutdown();
42728 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42730 }
42731}
42732
42733impl fidl::endpoints::Responder for DatagramSocketSetBindToInterfaceIndexResponder {
42734 type ControlHandle = DatagramSocketControlHandle;
42735
42736 fn control_handle(&self) -> &DatagramSocketControlHandle {
42737 &self.control_handle
42738 }
42739
42740 fn drop_without_shutdown(mut self) {
42741 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42743 std::mem::forget(self);
42745 }
42746}
42747
42748impl DatagramSocketSetBindToInterfaceIndexResponder {
42749 pub fn send(
42753 self,
42754 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42755 ) -> Result<(), fidl::Error> {
42756 let _result = self.send_raw(result);
42757 if _result.is_err() {
42758 self.control_handle.shutdown();
42759 }
42760 self.drop_without_shutdown();
42761 _result
42762 }
42763
42764 pub fn send_no_shutdown_on_err(
42766 self,
42767 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42768 ) -> Result<(), fidl::Error> {
42769 let _result = self.send_raw(result);
42770 self.drop_without_shutdown();
42771 _result
42772 }
42773
42774 fn send_raw(
42775 &self,
42776 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42777 ) -> Result<(), fidl::Error> {
42778 self.control_handle.inner.send::<fidl::encoding::ResultType<
42779 fidl::encoding::EmptyStruct,
42780 fidl_fuchsia_posix::Errno,
42781 >>(
42782 result,
42783 self.tx_id,
42784 0x6e387a0def00821,
42785 fidl::encoding::DynamicFlags::empty(),
42786 )
42787 }
42788}
42789
42790#[must_use = "FIDL methods require a response to be sent"]
42791#[derive(Debug)]
42792pub struct DatagramSocketGetBindToInterfaceIndexResponder {
42793 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42794 tx_id: u32,
42795}
42796
42797impl std::ops::Drop for DatagramSocketGetBindToInterfaceIndexResponder {
42801 fn drop(&mut self) {
42802 self.control_handle.shutdown();
42803 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42805 }
42806}
42807
42808impl fidl::endpoints::Responder for DatagramSocketGetBindToInterfaceIndexResponder {
42809 type ControlHandle = DatagramSocketControlHandle;
42810
42811 fn control_handle(&self) -> &DatagramSocketControlHandle {
42812 &self.control_handle
42813 }
42814
42815 fn drop_without_shutdown(mut self) {
42816 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42818 std::mem::forget(self);
42820 }
42821}
42822
42823impl DatagramSocketGetBindToInterfaceIndexResponder {
42824 pub fn send(
42828 self,
42829 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
42830 ) -> Result<(), fidl::Error> {
42831 let _result = self.send_raw(result);
42832 if _result.is_err() {
42833 self.control_handle.shutdown();
42834 }
42835 self.drop_without_shutdown();
42836 _result
42837 }
42838
42839 pub fn send_no_shutdown_on_err(
42841 self,
42842 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
42843 ) -> Result<(), fidl::Error> {
42844 let _result = self.send_raw(result);
42845 self.drop_without_shutdown();
42846 _result
42847 }
42848
42849 fn send_raw(
42850 &self,
42851 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
42852 ) -> Result<(), fidl::Error> {
42853 self.control_handle.inner.send::<fidl::encoding::ResultType<
42854 BaseSocketGetBindToInterfaceIndexResponse,
42855 fidl_fuchsia_posix::Errno,
42856 >>(
42857 result.map(|value| (value,)),
42858 self.tx_id,
42859 0x59c31dd3e3078295,
42860 fidl::encoding::DynamicFlags::empty(),
42861 )
42862 }
42863}
42864
42865#[must_use = "FIDL methods require a response to be sent"]
42866#[derive(Debug)]
42867pub struct DatagramSocketSetTimestampResponder {
42868 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42869 tx_id: u32,
42870}
42871
42872impl std::ops::Drop for DatagramSocketSetTimestampResponder {
42876 fn drop(&mut self) {
42877 self.control_handle.shutdown();
42878 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42880 }
42881}
42882
42883impl fidl::endpoints::Responder for DatagramSocketSetTimestampResponder {
42884 type ControlHandle = DatagramSocketControlHandle;
42885
42886 fn control_handle(&self) -> &DatagramSocketControlHandle {
42887 &self.control_handle
42888 }
42889
42890 fn drop_without_shutdown(mut self) {
42891 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42893 std::mem::forget(self);
42895 }
42896}
42897
42898impl DatagramSocketSetTimestampResponder {
42899 pub fn send(
42903 self,
42904 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42905 ) -> Result<(), fidl::Error> {
42906 let _result = self.send_raw(result);
42907 if _result.is_err() {
42908 self.control_handle.shutdown();
42909 }
42910 self.drop_without_shutdown();
42911 _result
42912 }
42913
42914 pub fn send_no_shutdown_on_err(
42916 self,
42917 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42918 ) -> Result<(), fidl::Error> {
42919 let _result = self.send_raw(result);
42920 self.drop_without_shutdown();
42921 _result
42922 }
42923
42924 fn send_raw(
42925 &self,
42926 mut result: Result<(), fidl_fuchsia_posix::Errno>,
42927 ) -> Result<(), fidl::Error> {
42928 self.control_handle.inner.send::<fidl::encoding::ResultType<
42929 fidl::encoding::EmptyStruct,
42930 fidl_fuchsia_posix::Errno,
42931 >>(
42932 result,
42933 self.tx_id,
42934 0x285d6516c263d839,
42935 fidl::encoding::DynamicFlags::empty(),
42936 )
42937 }
42938}
42939
42940#[must_use = "FIDL methods require a response to be sent"]
42941#[derive(Debug)]
42942pub struct DatagramSocketGetTimestampResponder {
42943 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42944 tx_id: u32,
42945}
42946
42947impl std::ops::Drop for DatagramSocketGetTimestampResponder {
42951 fn drop(&mut self) {
42952 self.control_handle.shutdown();
42953 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42955 }
42956}
42957
42958impl fidl::endpoints::Responder for DatagramSocketGetTimestampResponder {
42959 type ControlHandle = DatagramSocketControlHandle;
42960
42961 fn control_handle(&self) -> &DatagramSocketControlHandle {
42962 &self.control_handle
42963 }
42964
42965 fn drop_without_shutdown(mut self) {
42966 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42968 std::mem::forget(self);
42970 }
42971}
42972
42973impl DatagramSocketGetTimestampResponder {
42974 pub fn send(
42978 self,
42979 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
42980 ) -> Result<(), fidl::Error> {
42981 let _result = self.send_raw(result);
42982 if _result.is_err() {
42983 self.control_handle.shutdown();
42984 }
42985 self.drop_without_shutdown();
42986 _result
42987 }
42988
42989 pub fn send_no_shutdown_on_err(
42991 self,
42992 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
42993 ) -> Result<(), fidl::Error> {
42994 let _result = self.send_raw(result);
42995 self.drop_without_shutdown();
42996 _result
42997 }
42998
42999 fn send_raw(
43000 &self,
43001 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
43002 ) -> Result<(), fidl::Error> {
43003 self.control_handle.inner.send::<fidl::encoding::ResultType<
43004 BaseSocketGetTimestampResponse,
43005 fidl_fuchsia_posix::Errno,
43006 >>(
43007 result.map(|value| (value,)),
43008 self.tx_id,
43009 0x49f2fffbbcc2bd27,
43010 fidl::encoding::DynamicFlags::empty(),
43011 )
43012 }
43013}
43014
43015#[must_use = "FIDL methods require a response to be sent"]
43016#[derive(Debug)]
43017pub struct DatagramSocketSetMarkResponder {
43018 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43019 tx_id: u32,
43020}
43021
43022impl std::ops::Drop for DatagramSocketSetMarkResponder {
43026 fn drop(&mut self) {
43027 self.control_handle.shutdown();
43028 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43030 }
43031}
43032
43033impl fidl::endpoints::Responder for DatagramSocketSetMarkResponder {
43034 type ControlHandle = DatagramSocketControlHandle;
43035
43036 fn control_handle(&self) -> &DatagramSocketControlHandle {
43037 &self.control_handle
43038 }
43039
43040 fn drop_without_shutdown(mut self) {
43041 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43043 std::mem::forget(self);
43045 }
43046}
43047
43048impl DatagramSocketSetMarkResponder {
43049 pub fn send(
43053 self,
43054 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43055 ) -> Result<(), fidl::Error> {
43056 let _result = self.send_raw(result);
43057 if _result.is_err() {
43058 self.control_handle.shutdown();
43059 }
43060 self.drop_without_shutdown();
43061 _result
43062 }
43063
43064 pub fn send_no_shutdown_on_err(
43066 self,
43067 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43068 ) -> Result<(), fidl::Error> {
43069 let _result = self.send_raw(result);
43070 self.drop_without_shutdown();
43071 _result
43072 }
43073
43074 fn send_raw(
43075 &self,
43076 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43077 ) -> Result<(), fidl::Error> {
43078 self.control_handle.inner.send::<fidl::encoding::ResultType<
43079 fidl::encoding::EmptyStruct,
43080 fidl_fuchsia_posix::Errno,
43081 >>(
43082 result,
43083 self.tx_id,
43084 0x6ead6de09f653236,
43085 fidl::encoding::DynamicFlags::empty(),
43086 )
43087 }
43088}
43089
43090#[must_use = "FIDL methods require a response to be sent"]
43091#[derive(Debug)]
43092pub struct DatagramSocketGetMarkResponder {
43093 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43094 tx_id: u32,
43095}
43096
43097impl std::ops::Drop for DatagramSocketGetMarkResponder {
43101 fn drop(&mut self) {
43102 self.control_handle.shutdown();
43103 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43105 }
43106}
43107
43108impl fidl::endpoints::Responder for DatagramSocketGetMarkResponder {
43109 type ControlHandle = DatagramSocketControlHandle;
43110
43111 fn control_handle(&self) -> &DatagramSocketControlHandle {
43112 &self.control_handle
43113 }
43114
43115 fn drop_without_shutdown(mut self) {
43116 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43118 std::mem::forget(self);
43120 }
43121}
43122
43123impl DatagramSocketGetMarkResponder {
43124 pub fn send(
43128 self,
43129 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
43130 ) -> Result<(), fidl::Error> {
43131 let _result = self.send_raw(result);
43132 if _result.is_err() {
43133 self.control_handle.shutdown();
43134 }
43135 self.drop_without_shutdown();
43136 _result
43137 }
43138
43139 pub fn send_no_shutdown_on_err(
43141 self,
43142 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
43143 ) -> Result<(), fidl::Error> {
43144 let _result = self.send_raw(result);
43145 self.drop_without_shutdown();
43146 _result
43147 }
43148
43149 fn send_raw(
43150 &self,
43151 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
43152 ) -> Result<(), fidl::Error> {
43153 self.control_handle.inner.send::<fidl::encoding::ResultType<
43154 BaseSocketGetMarkResponse,
43155 fidl_fuchsia_posix::Errno,
43156 >>(
43157 result.map(|mark| (mark,)),
43158 self.tx_id,
43159 0x57a2752c61d93d47,
43160 fidl::encoding::DynamicFlags::empty(),
43161 )
43162 }
43163}
43164
43165#[must_use = "FIDL methods require a response to be sent"]
43166#[derive(Debug)]
43167pub struct DatagramSocketBindResponder {
43168 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43169 tx_id: u32,
43170}
43171
43172impl std::ops::Drop for DatagramSocketBindResponder {
43176 fn drop(&mut self) {
43177 self.control_handle.shutdown();
43178 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43180 }
43181}
43182
43183impl fidl::endpoints::Responder for DatagramSocketBindResponder {
43184 type ControlHandle = DatagramSocketControlHandle;
43185
43186 fn control_handle(&self) -> &DatagramSocketControlHandle {
43187 &self.control_handle
43188 }
43189
43190 fn drop_without_shutdown(mut self) {
43191 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43193 std::mem::forget(self);
43195 }
43196}
43197
43198impl DatagramSocketBindResponder {
43199 pub fn send(
43203 self,
43204 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43205 ) -> Result<(), fidl::Error> {
43206 let _result = self.send_raw(result);
43207 if _result.is_err() {
43208 self.control_handle.shutdown();
43209 }
43210 self.drop_without_shutdown();
43211 _result
43212 }
43213
43214 pub fn send_no_shutdown_on_err(
43216 self,
43217 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43218 ) -> Result<(), fidl::Error> {
43219 let _result = self.send_raw(result);
43220 self.drop_without_shutdown();
43221 _result
43222 }
43223
43224 fn send_raw(
43225 &self,
43226 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43227 ) -> Result<(), fidl::Error> {
43228 self.control_handle.inner.send::<fidl::encoding::ResultType<
43229 fidl::encoding::EmptyStruct,
43230 fidl_fuchsia_posix::Errno,
43231 >>(
43232 result,
43233 self.tx_id,
43234 0x4bc6400ae92125d,
43235 fidl::encoding::DynamicFlags::empty(),
43236 )
43237 }
43238}
43239
43240#[must_use = "FIDL methods require a response to be sent"]
43241#[derive(Debug)]
43242pub struct DatagramSocketConnectResponder {
43243 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43244 tx_id: u32,
43245}
43246
43247impl std::ops::Drop for DatagramSocketConnectResponder {
43251 fn drop(&mut self) {
43252 self.control_handle.shutdown();
43253 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43255 }
43256}
43257
43258impl fidl::endpoints::Responder for DatagramSocketConnectResponder {
43259 type ControlHandle = DatagramSocketControlHandle;
43260
43261 fn control_handle(&self) -> &DatagramSocketControlHandle {
43262 &self.control_handle
43263 }
43264
43265 fn drop_without_shutdown(mut self) {
43266 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43268 std::mem::forget(self);
43270 }
43271}
43272
43273impl DatagramSocketConnectResponder {
43274 pub fn send(
43278 self,
43279 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43280 ) -> Result<(), fidl::Error> {
43281 let _result = self.send_raw(result);
43282 if _result.is_err() {
43283 self.control_handle.shutdown();
43284 }
43285 self.drop_without_shutdown();
43286 _result
43287 }
43288
43289 pub fn send_no_shutdown_on_err(
43291 self,
43292 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43293 ) -> Result<(), fidl::Error> {
43294 let _result = self.send_raw(result);
43295 self.drop_without_shutdown();
43296 _result
43297 }
43298
43299 fn send_raw(
43300 &self,
43301 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43302 ) -> Result<(), fidl::Error> {
43303 self.control_handle.inner.send::<fidl::encoding::ResultType<
43304 fidl::encoding::EmptyStruct,
43305 fidl_fuchsia_posix::Errno,
43306 >>(
43307 result,
43308 self.tx_id,
43309 0x5f05f19bfdd38871,
43310 fidl::encoding::DynamicFlags::empty(),
43311 )
43312 }
43313}
43314
43315#[must_use = "FIDL methods require a response to be sent"]
43316#[derive(Debug)]
43317pub struct DatagramSocketDisconnectResponder {
43318 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43319 tx_id: u32,
43320}
43321
43322impl std::ops::Drop for DatagramSocketDisconnectResponder {
43326 fn drop(&mut self) {
43327 self.control_handle.shutdown();
43328 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43330 }
43331}
43332
43333impl fidl::endpoints::Responder for DatagramSocketDisconnectResponder {
43334 type ControlHandle = DatagramSocketControlHandle;
43335
43336 fn control_handle(&self) -> &DatagramSocketControlHandle {
43337 &self.control_handle
43338 }
43339
43340 fn drop_without_shutdown(mut self) {
43341 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43343 std::mem::forget(self);
43345 }
43346}
43347
43348impl DatagramSocketDisconnectResponder {
43349 pub fn send(
43353 self,
43354 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43355 ) -> Result<(), fidl::Error> {
43356 let _result = self.send_raw(result);
43357 if _result.is_err() {
43358 self.control_handle.shutdown();
43359 }
43360 self.drop_without_shutdown();
43361 _result
43362 }
43363
43364 pub fn send_no_shutdown_on_err(
43366 self,
43367 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43368 ) -> Result<(), fidl::Error> {
43369 let _result = self.send_raw(result);
43370 self.drop_without_shutdown();
43371 _result
43372 }
43373
43374 fn send_raw(
43375 &self,
43376 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43377 ) -> Result<(), fidl::Error> {
43378 self.control_handle.inner.send::<fidl::encoding::ResultType<
43379 fidl::encoding::EmptyStruct,
43380 fidl_fuchsia_posix::Errno,
43381 >>(
43382 result,
43383 self.tx_id,
43384 0x74e63b91f7b29b2,
43385 fidl::encoding::DynamicFlags::empty(),
43386 )
43387 }
43388}
43389
43390#[must_use = "FIDL methods require a response to be sent"]
43391#[derive(Debug)]
43392pub struct DatagramSocketGetSockNameResponder {
43393 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43394 tx_id: u32,
43395}
43396
43397impl std::ops::Drop for DatagramSocketGetSockNameResponder {
43401 fn drop(&mut self) {
43402 self.control_handle.shutdown();
43403 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43405 }
43406}
43407
43408impl fidl::endpoints::Responder for DatagramSocketGetSockNameResponder {
43409 type ControlHandle = DatagramSocketControlHandle;
43410
43411 fn control_handle(&self) -> &DatagramSocketControlHandle {
43412 &self.control_handle
43413 }
43414
43415 fn drop_without_shutdown(mut self) {
43416 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43418 std::mem::forget(self);
43420 }
43421}
43422
43423impl DatagramSocketGetSockNameResponder {
43424 pub fn send(
43428 self,
43429 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
43430 ) -> Result<(), fidl::Error> {
43431 let _result = self.send_raw(result);
43432 if _result.is_err() {
43433 self.control_handle.shutdown();
43434 }
43435 self.drop_without_shutdown();
43436 _result
43437 }
43438
43439 pub fn send_no_shutdown_on_err(
43441 self,
43442 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
43443 ) -> Result<(), fidl::Error> {
43444 let _result = self.send_raw(result);
43445 self.drop_without_shutdown();
43446 _result
43447 }
43448
43449 fn send_raw(
43450 &self,
43451 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
43452 ) -> Result<(), fidl::Error> {
43453 self.control_handle.inner.send::<fidl::encoding::ResultType<
43454 BaseNetworkSocketGetSockNameResponse,
43455 fidl_fuchsia_posix::Errno,
43456 >>(
43457 result.map(|addr| (addr,)),
43458 self.tx_id,
43459 0x475f23f84a1a4f85,
43460 fidl::encoding::DynamicFlags::empty(),
43461 )
43462 }
43463}
43464
43465#[must_use = "FIDL methods require a response to be sent"]
43466#[derive(Debug)]
43467pub struct DatagramSocketGetPeerNameResponder {
43468 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43469 tx_id: u32,
43470}
43471
43472impl std::ops::Drop for DatagramSocketGetPeerNameResponder {
43476 fn drop(&mut self) {
43477 self.control_handle.shutdown();
43478 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43480 }
43481}
43482
43483impl fidl::endpoints::Responder for DatagramSocketGetPeerNameResponder {
43484 type ControlHandle = DatagramSocketControlHandle;
43485
43486 fn control_handle(&self) -> &DatagramSocketControlHandle {
43487 &self.control_handle
43488 }
43489
43490 fn drop_without_shutdown(mut self) {
43491 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43493 std::mem::forget(self);
43495 }
43496}
43497
43498impl DatagramSocketGetPeerNameResponder {
43499 pub fn send(
43503 self,
43504 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
43505 ) -> Result<(), fidl::Error> {
43506 let _result = self.send_raw(result);
43507 if _result.is_err() {
43508 self.control_handle.shutdown();
43509 }
43510 self.drop_without_shutdown();
43511 _result
43512 }
43513
43514 pub fn send_no_shutdown_on_err(
43516 self,
43517 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
43518 ) -> Result<(), fidl::Error> {
43519 let _result = self.send_raw(result);
43520 self.drop_without_shutdown();
43521 _result
43522 }
43523
43524 fn send_raw(
43525 &self,
43526 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
43527 ) -> Result<(), fidl::Error> {
43528 self.control_handle.inner.send::<fidl::encoding::ResultType<
43529 BaseNetworkSocketGetPeerNameResponse,
43530 fidl_fuchsia_posix::Errno,
43531 >>(
43532 result.map(|addr| (addr,)),
43533 self.tx_id,
43534 0x1ffecf4bd5b6432e,
43535 fidl::encoding::DynamicFlags::empty(),
43536 )
43537 }
43538}
43539
43540#[must_use = "FIDL methods require a response to be sent"]
43541#[derive(Debug)]
43542pub struct DatagramSocketShutdownResponder {
43543 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43544 tx_id: u32,
43545}
43546
43547impl std::ops::Drop for DatagramSocketShutdownResponder {
43551 fn drop(&mut self) {
43552 self.control_handle.shutdown();
43553 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43555 }
43556}
43557
43558impl fidl::endpoints::Responder for DatagramSocketShutdownResponder {
43559 type ControlHandle = DatagramSocketControlHandle;
43560
43561 fn control_handle(&self) -> &DatagramSocketControlHandle {
43562 &self.control_handle
43563 }
43564
43565 fn drop_without_shutdown(mut self) {
43566 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43568 std::mem::forget(self);
43570 }
43571}
43572
43573impl DatagramSocketShutdownResponder {
43574 pub fn send(
43578 self,
43579 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43580 ) -> Result<(), fidl::Error> {
43581 let _result = self.send_raw(result);
43582 if _result.is_err() {
43583 self.control_handle.shutdown();
43584 }
43585 self.drop_without_shutdown();
43586 _result
43587 }
43588
43589 pub fn send_no_shutdown_on_err(
43591 self,
43592 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43593 ) -> Result<(), fidl::Error> {
43594 let _result = self.send_raw(result);
43595 self.drop_without_shutdown();
43596 _result
43597 }
43598
43599 fn send_raw(
43600 &self,
43601 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43602 ) -> Result<(), fidl::Error> {
43603 self.control_handle.inner.send::<fidl::encoding::ResultType<
43604 fidl::encoding::EmptyStruct,
43605 fidl_fuchsia_posix::Errno,
43606 >>(
43607 result,
43608 self.tx_id,
43609 0x247f38b6db68c336,
43610 fidl::encoding::DynamicFlags::empty(),
43611 )
43612 }
43613}
43614
43615#[must_use = "FIDL methods require a response to be sent"]
43616#[derive(Debug)]
43617pub struct DatagramSocketSetIpTypeOfServiceResponder {
43618 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43619 tx_id: u32,
43620}
43621
43622impl std::ops::Drop for DatagramSocketSetIpTypeOfServiceResponder {
43626 fn drop(&mut self) {
43627 self.control_handle.shutdown();
43628 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43630 }
43631}
43632
43633impl fidl::endpoints::Responder for DatagramSocketSetIpTypeOfServiceResponder {
43634 type ControlHandle = DatagramSocketControlHandle;
43635
43636 fn control_handle(&self) -> &DatagramSocketControlHandle {
43637 &self.control_handle
43638 }
43639
43640 fn drop_without_shutdown(mut self) {
43641 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43643 std::mem::forget(self);
43645 }
43646}
43647
43648impl DatagramSocketSetIpTypeOfServiceResponder {
43649 pub fn send(
43653 self,
43654 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43655 ) -> Result<(), fidl::Error> {
43656 let _result = self.send_raw(result);
43657 if _result.is_err() {
43658 self.control_handle.shutdown();
43659 }
43660 self.drop_without_shutdown();
43661 _result
43662 }
43663
43664 pub fn send_no_shutdown_on_err(
43666 self,
43667 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43668 ) -> Result<(), fidl::Error> {
43669 let _result = self.send_raw(result);
43670 self.drop_without_shutdown();
43671 _result
43672 }
43673
43674 fn send_raw(
43675 &self,
43676 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43677 ) -> Result<(), fidl::Error> {
43678 self.control_handle.inner.send::<fidl::encoding::ResultType<
43679 fidl::encoding::EmptyStruct,
43680 fidl_fuchsia_posix::Errno,
43681 >>(
43682 result,
43683 self.tx_id,
43684 0x995c600475b6d46,
43685 fidl::encoding::DynamicFlags::empty(),
43686 )
43687 }
43688}
43689
43690#[must_use = "FIDL methods require a response to be sent"]
43691#[derive(Debug)]
43692pub struct DatagramSocketGetIpTypeOfServiceResponder {
43693 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43694 tx_id: u32,
43695}
43696
43697impl std::ops::Drop for DatagramSocketGetIpTypeOfServiceResponder {
43701 fn drop(&mut self) {
43702 self.control_handle.shutdown();
43703 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43705 }
43706}
43707
43708impl fidl::endpoints::Responder for DatagramSocketGetIpTypeOfServiceResponder {
43709 type ControlHandle = DatagramSocketControlHandle;
43710
43711 fn control_handle(&self) -> &DatagramSocketControlHandle {
43712 &self.control_handle
43713 }
43714
43715 fn drop_without_shutdown(mut self) {
43716 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43718 std::mem::forget(self);
43720 }
43721}
43722
43723impl DatagramSocketGetIpTypeOfServiceResponder {
43724 pub fn send(
43728 self,
43729 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
43730 ) -> Result<(), fidl::Error> {
43731 let _result = self.send_raw(result);
43732 if _result.is_err() {
43733 self.control_handle.shutdown();
43734 }
43735 self.drop_without_shutdown();
43736 _result
43737 }
43738
43739 pub fn send_no_shutdown_on_err(
43741 self,
43742 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
43743 ) -> Result<(), fidl::Error> {
43744 let _result = self.send_raw(result);
43745 self.drop_without_shutdown();
43746 _result
43747 }
43748
43749 fn send_raw(
43750 &self,
43751 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
43752 ) -> Result<(), fidl::Error> {
43753 self.control_handle.inner.send::<fidl::encoding::ResultType<
43754 BaseNetworkSocketGetIpTypeOfServiceResponse,
43755 fidl_fuchsia_posix::Errno,
43756 >>(
43757 result.map(|value| (value,)),
43758 self.tx_id,
43759 0x3814a04259f75fcb,
43760 fidl::encoding::DynamicFlags::empty(),
43761 )
43762 }
43763}
43764
43765#[must_use = "FIDL methods require a response to be sent"]
43766#[derive(Debug)]
43767pub struct DatagramSocketSetIpTtlResponder {
43768 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43769 tx_id: u32,
43770}
43771
43772impl std::ops::Drop for DatagramSocketSetIpTtlResponder {
43776 fn drop(&mut self) {
43777 self.control_handle.shutdown();
43778 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43780 }
43781}
43782
43783impl fidl::endpoints::Responder for DatagramSocketSetIpTtlResponder {
43784 type ControlHandle = DatagramSocketControlHandle;
43785
43786 fn control_handle(&self) -> &DatagramSocketControlHandle {
43787 &self.control_handle
43788 }
43789
43790 fn drop_without_shutdown(mut self) {
43791 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43793 std::mem::forget(self);
43795 }
43796}
43797
43798impl DatagramSocketSetIpTtlResponder {
43799 pub fn send(
43803 self,
43804 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43805 ) -> Result<(), fidl::Error> {
43806 let _result = self.send_raw(result);
43807 if _result.is_err() {
43808 self.control_handle.shutdown();
43809 }
43810 self.drop_without_shutdown();
43811 _result
43812 }
43813
43814 pub fn send_no_shutdown_on_err(
43816 self,
43817 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43818 ) -> Result<(), fidl::Error> {
43819 let _result = self.send_raw(result);
43820 self.drop_without_shutdown();
43821 _result
43822 }
43823
43824 fn send_raw(
43825 &self,
43826 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43827 ) -> Result<(), fidl::Error> {
43828 self.control_handle.inner.send::<fidl::encoding::ResultType<
43829 fidl::encoding::EmptyStruct,
43830 fidl_fuchsia_posix::Errno,
43831 >>(
43832 result,
43833 self.tx_id,
43834 0x29e2424b433ae1ef,
43835 fidl::encoding::DynamicFlags::empty(),
43836 )
43837 }
43838}
43839
43840#[must_use = "FIDL methods require a response to be sent"]
43841#[derive(Debug)]
43842pub struct DatagramSocketGetIpTtlResponder {
43843 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43844 tx_id: u32,
43845}
43846
43847impl std::ops::Drop for DatagramSocketGetIpTtlResponder {
43851 fn drop(&mut self) {
43852 self.control_handle.shutdown();
43853 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43855 }
43856}
43857
43858impl fidl::endpoints::Responder for DatagramSocketGetIpTtlResponder {
43859 type ControlHandle = DatagramSocketControlHandle;
43860
43861 fn control_handle(&self) -> &DatagramSocketControlHandle {
43862 &self.control_handle
43863 }
43864
43865 fn drop_without_shutdown(mut self) {
43866 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43868 std::mem::forget(self);
43870 }
43871}
43872
43873impl DatagramSocketGetIpTtlResponder {
43874 pub fn send(
43878 self,
43879 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
43880 ) -> Result<(), fidl::Error> {
43881 let _result = self.send_raw(result);
43882 if _result.is_err() {
43883 self.control_handle.shutdown();
43884 }
43885 self.drop_without_shutdown();
43886 _result
43887 }
43888
43889 pub fn send_no_shutdown_on_err(
43891 self,
43892 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
43893 ) -> Result<(), fidl::Error> {
43894 let _result = self.send_raw(result);
43895 self.drop_without_shutdown();
43896 _result
43897 }
43898
43899 fn send_raw(
43900 &self,
43901 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
43902 ) -> Result<(), fidl::Error> {
43903 self.control_handle.inner.send::<fidl::encoding::ResultType<
43904 BaseNetworkSocketGetIpTtlResponse,
43905 fidl_fuchsia_posix::Errno,
43906 >>(
43907 result.map(|value| (value,)),
43908 self.tx_id,
43909 0x47e47fa1f24da471,
43910 fidl::encoding::DynamicFlags::empty(),
43911 )
43912 }
43913}
43914
43915#[must_use = "FIDL methods require a response to be sent"]
43916#[derive(Debug)]
43917pub struct DatagramSocketSetIpPacketInfoResponder {
43918 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43919 tx_id: u32,
43920}
43921
43922impl std::ops::Drop for DatagramSocketSetIpPacketInfoResponder {
43926 fn drop(&mut self) {
43927 self.control_handle.shutdown();
43928 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43930 }
43931}
43932
43933impl fidl::endpoints::Responder for DatagramSocketSetIpPacketInfoResponder {
43934 type ControlHandle = DatagramSocketControlHandle;
43935
43936 fn control_handle(&self) -> &DatagramSocketControlHandle {
43937 &self.control_handle
43938 }
43939
43940 fn drop_without_shutdown(mut self) {
43941 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43943 std::mem::forget(self);
43945 }
43946}
43947
43948impl DatagramSocketSetIpPacketInfoResponder {
43949 pub fn send(
43953 self,
43954 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43955 ) -> Result<(), fidl::Error> {
43956 let _result = self.send_raw(result);
43957 if _result.is_err() {
43958 self.control_handle.shutdown();
43959 }
43960 self.drop_without_shutdown();
43961 _result
43962 }
43963
43964 pub fn send_no_shutdown_on_err(
43966 self,
43967 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43968 ) -> Result<(), fidl::Error> {
43969 let _result = self.send_raw(result);
43970 self.drop_without_shutdown();
43971 _result
43972 }
43973
43974 fn send_raw(
43975 &self,
43976 mut result: Result<(), fidl_fuchsia_posix::Errno>,
43977 ) -> Result<(), fidl::Error> {
43978 self.control_handle.inner.send::<fidl::encoding::ResultType<
43979 fidl::encoding::EmptyStruct,
43980 fidl_fuchsia_posix::Errno,
43981 >>(
43982 result,
43983 self.tx_id,
43984 0x392d16bee20c0e16,
43985 fidl::encoding::DynamicFlags::empty(),
43986 )
43987 }
43988}
43989
43990#[must_use = "FIDL methods require a response to be sent"]
43991#[derive(Debug)]
43992pub struct DatagramSocketGetIpPacketInfoResponder {
43993 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43994 tx_id: u32,
43995}
43996
43997impl std::ops::Drop for DatagramSocketGetIpPacketInfoResponder {
44001 fn drop(&mut self) {
44002 self.control_handle.shutdown();
44003 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44005 }
44006}
44007
44008impl fidl::endpoints::Responder for DatagramSocketGetIpPacketInfoResponder {
44009 type ControlHandle = DatagramSocketControlHandle;
44010
44011 fn control_handle(&self) -> &DatagramSocketControlHandle {
44012 &self.control_handle
44013 }
44014
44015 fn drop_without_shutdown(mut self) {
44016 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44018 std::mem::forget(self);
44020 }
44021}
44022
44023impl DatagramSocketGetIpPacketInfoResponder {
44024 pub fn send(
44028 self,
44029 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44030 ) -> Result<(), fidl::Error> {
44031 let _result = self.send_raw(result);
44032 if _result.is_err() {
44033 self.control_handle.shutdown();
44034 }
44035 self.drop_without_shutdown();
44036 _result
44037 }
44038
44039 pub fn send_no_shutdown_on_err(
44041 self,
44042 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44043 ) -> Result<(), fidl::Error> {
44044 let _result = self.send_raw(result);
44045 self.drop_without_shutdown();
44046 _result
44047 }
44048
44049 fn send_raw(
44050 &self,
44051 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44052 ) -> Result<(), fidl::Error> {
44053 self.control_handle.inner.send::<fidl::encoding::ResultType<
44054 BaseNetworkSocketGetIpPacketInfoResponse,
44055 fidl_fuchsia_posix::Errno,
44056 >>(
44057 result.map(|value| (value,)),
44058 self.tx_id,
44059 0x54b505f242280740,
44060 fidl::encoding::DynamicFlags::empty(),
44061 )
44062 }
44063}
44064
44065#[must_use = "FIDL methods require a response to be sent"]
44066#[derive(Debug)]
44067pub struct DatagramSocketSetIpReceiveTypeOfServiceResponder {
44068 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44069 tx_id: u32,
44070}
44071
44072impl std::ops::Drop for DatagramSocketSetIpReceiveTypeOfServiceResponder {
44076 fn drop(&mut self) {
44077 self.control_handle.shutdown();
44078 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44080 }
44081}
44082
44083impl fidl::endpoints::Responder for DatagramSocketSetIpReceiveTypeOfServiceResponder {
44084 type ControlHandle = DatagramSocketControlHandle;
44085
44086 fn control_handle(&self) -> &DatagramSocketControlHandle {
44087 &self.control_handle
44088 }
44089
44090 fn drop_without_shutdown(mut self) {
44091 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44093 std::mem::forget(self);
44095 }
44096}
44097
44098impl DatagramSocketSetIpReceiveTypeOfServiceResponder {
44099 pub fn send(
44103 self,
44104 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44105 ) -> Result<(), fidl::Error> {
44106 let _result = self.send_raw(result);
44107 if _result.is_err() {
44108 self.control_handle.shutdown();
44109 }
44110 self.drop_without_shutdown();
44111 _result
44112 }
44113
44114 pub fn send_no_shutdown_on_err(
44116 self,
44117 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44118 ) -> Result<(), fidl::Error> {
44119 let _result = self.send_raw(result);
44120 self.drop_without_shutdown();
44121 _result
44122 }
44123
44124 fn send_raw(
44125 &self,
44126 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44127 ) -> Result<(), fidl::Error> {
44128 self.control_handle.inner.send::<fidl::encoding::ResultType<
44129 fidl::encoding::EmptyStruct,
44130 fidl_fuchsia_posix::Errno,
44131 >>(
44132 result,
44133 self.tx_id,
44134 0x6c4f6714995f84ef,
44135 fidl::encoding::DynamicFlags::empty(),
44136 )
44137 }
44138}
44139
44140#[must_use = "FIDL methods require a response to be sent"]
44141#[derive(Debug)]
44142pub struct DatagramSocketGetIpReceiveTypeOfServiceResponder {
44143 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44144 tx_id: u32,
44145}
44146
44147impl std::ops::Drop for DatagramSocketGetIpReceiveTypeOfServiceResponder {
44151 fn drop(&mut self) {
44152 self.control_handle.shutdown();
44153 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44155 }
44156}
44157
44158impl fidl::endpoints::Responder for DatagramSocketGetIpReceiveTypeOfServiceResponder {
44159 type ControlHandle = DatagramSocketControlHandle;
44160
44161 fn control_handle(&self) -> &DatagramSocketControlHandle {
44162 &self.control_handle
44163 }
44164
44165 fn drop_without_shutdown(mut self) {
44166 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44168 std::mem::forget(self);
44170 }
44171}
44172
44173impl DatagramSocketGetIpReceiveTypeOfServiceResponder {
44174 pub fn send(
44178 self,
44179 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44180 ) -> Result<(), fidl::Error> {
44181 let _result = self.send_raw(result);
44182 if _result.is_err() {
44183 self.control_handle.shutdown();
44184 }
44185 self.drop_without_shutdown();
44186 _result
44187 }
44188
44189 pub fn send_no_shutdown_on_err(
44191 self,
44192 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44193 ) -> Result<(), fidl::Error> {
44194 let _result = self.send_raw(result);
44195 self.drop_without_shutdown();
44196 _result
44197 }
44198
44199 fn send_raw(
44200 &self,
44201 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44202 ) -> Result<(), fidl::Error> {
44203 self.control_handle.inner.send::<fidl::encoding::ResultType<
44204 BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
44205 fidl_fuchsia_posix::Errno,
44206 >>(
44207 result.map(|value| (value,)),
44208 self.tx_id,
44209 0x4158ba7dc2795960,
44210 fidl::encoding::DynamicFlags::empty(),
44211 )
44212 }
44213}
44214
44215#[must_use = "FIDL methods require a response to be sent"]
44216#[derive(Debug)]
44217pub struct DatagramSocketSetIpReceiveTtlResponder {
44218 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44219 tx_id: u32,
44220}
44221
44222impl std::ops::Drop for DatagramSocketSetIpReceiveTtlResponder {
44226 fn drop(&mut self) {
44227 self.control_handle.shutdown();
44228 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44230 }
44231}
44232
44233impl fidl::endpoints::Responder for DatagramSocketSetIpReceiveTtlResponder {
44234 type ControlHandle = DatagramSocketControlHandle;
44235
44236 fn control_handle(&self) -> &DatagramSocketControlHandle {
44237 &self.control_handle
44238 }
44239
44240 fn drop_without_shutdown(mut self) {
44241 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44243 std::mem::forget(self);
44245 }
44246}
44247
44248impl DatagramSocketSetIpReceiveTtlResponder {
44249 pub fn send(
44253 self,
44254 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44255 ) -> Result<(), fidl::Error> {
44256 let _result = self.send_raw(result);
44257 if _result.is_err() {
44258 self.control_handle.shutdown();
44259 }
44260 self.drop_without_shutdown();
44261 _result
44262 }
44263
44264 pub fn send_no_shutdown_on_err(
44266 self,
44267 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44268 ) -> Result<(), fidl::Error> {
44269 let _result = self.send_raw(result);
44270 self.drop_without_shutdown();
44271 _result
44272 }
44273
44274 fn send_raw(
44275 &self,
44276 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44277 ) -> Result<(), fidl::Error> {
44278 self.control_handle.inner.send::<fidl::encoding::ResultType<
44279 fidl::encoding::EmptyStruct,
44280 fidl_fuchsia_posix::Errno,
44281 >>(
44282 result,
44283 self.tx_id,
44284 0x46f15be0ce0ab82b,
44285 fidl::encoding::DynamicFlags::empty(),
44286 )
44287 }
44288}
44289
44290#[must_use = "FIDL methods require a response to be sent"]
44291#[derive(Debug)]
44292pub struct DatagramSocketGetIpReceiveTtlResponder {
44293 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44294 tx_id: u32,
44295}
44296
44297impl std::ops::Drop for DatagramSocketGetIpReceiveTtlResponder {
44301 fn drop(&mut self) {
44302 self.control_handle.shutdown();
44303 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44305 }
44306}
44307
44308impl fidl::endpoints::Responder for DatagramSocketGetIpReceiveTtlResponder {
44309 type ControlHandle = DatagramSocketControlHandle;
44310
44311 fn control_handle(&self) -> &DatagramSocketControlHandle {
44312 &self.control_handle
44313 }
44314
44315 fn drop_without_shutdown(mut self) {
44316 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44318 std::mem::forget(self);
44320 }
44321}
44322
44323impl DatagramSocketGetIpReceiveTtlResponder {
44324 pub fn send(
44328 self,
44329 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44330 ) -> Result<(), fidl::Error> {
44331 let _result = self.send_raw(result);
44332 if _result.is_err() {
44333 self.control_handle.shutdown();
44334 }
44335 self.drop_without_shutdown();
44336 _result
44337 }
44338
44339 pub fn send_no_shutdown_on_err(
44341 self,
44342 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44343 ) -> Result<(), fidl::Error> {
44344 let _result = self.send_raw(result);
44345 self.drop_without_shutdown();
44346 _result
44347 }
44348
44349 fn send_raw(
44350 &self,
44351 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44352 ) -> Result<(), fidl::Error> {
44353 self.control_handle.inner.send::<fidl::encoding::ResultType<
44354 BaseNetworkSocketGetIpReceiveTtlResponse,
44355 fidl_fuchsia_posix::Errno,
44356 >>(
44357 result.map(|value| (value,)),
44358 self.tx_id,
44359 0x678ddd5a5dfa2eb5,
44360 fidl::encoding::DynamicFlags::empty(),
44361 )
44362 }
44363}
44364
44365#[must_use = "FIDL methods require a response to be sent"]
44366#[derive(Debug)]
44367pub struct DatagramSocketSetIpMulticastInterfaceResponder {
44368 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44369 tx_id: u32,
44370}
44371
44372impl std::ops::Drop for DatagramSocketSetIpMulticastInterfaceResponder {
44376 fn drop(&mut self) {
44377 self.control_handle.shutdown();
44378 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44380 }
44381}
44382
44383impl fidl::endpoints::Responder for DatagramSocketSetIpMulticastInterfaceResponder {
44384 type ControlHandle = DatagramSocketControlHandle;
44385
44386 fn control_handle(&self) -> &DatagramSocketControlHandle {
44387 &self.control_handle
44388 }
44389
44390 fn drop_without_shutdown(mut self) {
44391 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44393 std::mem::forget(self);
44395 }
44396}
44397
44398impl DatagramSocketSetIpMulticastInterfaceResponder {
44399 pub fn send(
44403 self,
44404 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44405 ) -> Result<(), fidl::Error> {
44406 let _result = self.send_raw(result);
44407 if _result.is_err() {
44408 self.control_handle.shutdown();
44409 }
44410 self.drop_without_shutdown();
44411 _result
44412 }
44413
44414 pub fn send_no_shutdown_on_err(
44416 self,
44417 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44418 ) -> Result<(), fidl::Error> {
44419 let _result = self.send_raw(result);
44420 self.drop_without_shutdown();
44421 _result
44422 }
44423
44424 fn send_raw(
44425 &self,
44426 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44427 ) -> Result<(), fidl::Error> {
44428 self.control_handle.inner.send::<fidl::encoding::ResultType<
44429 fidl::encoding::EmptyStruct,
44430 fidl_fuchsia_posix::Errno,
44431 >>(
44432 result,
44433 self.tx_id,
44434 0x752fbfa9b12befe,
44435 fidl::encoding::DynamicFlags::empty(),
44436 )
44437 }
44438}
44439
44440#[must_use = "FIDL methods require a response to be sent"]
44441#[derive(Debug)]
44442pub struct DatagramSocketGetIpMulticastInterfaceResponder {
44443 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44444 tx_id: u32,
44445}
44446
44447impl std::ops::Drop for DatagramSocketGetIpMulticastInterfaceResponder {
44451 fn drop(&mut self) {
44452 self.control_handle.shutdown();
44453 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44455 }
44456}
44457
44458impl fidl::endpoints::Responder for DatagramSocketGetIpMulticastInterfaceResponder {
44459 type ControlHandle = DatagramSocketControlHandle;
44460
44461 fn control_handle(&self) -> &DatagramSocketControlHandle {
44462 &self.control_handle
44463 }
44464
44465 fn drop_without_shutdown(mut self) {
44466 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44468 std::mem::forget(self);
44470 }
44471}
44472
44473impl DatagramSocketGetIpMulticastInterfaceResponder {
44474 pub fn send(
44478 self,
44479 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
44480 ) -> Result<(), fidl::Error> {
44481 let _result = self.send_raw(result);
44482 if _result.is_err() {
44483 self.control_handle.shutdown();
44484 }
44485 self.drop_without_shutdown();
44486 _result
44487 }
44488
44489 pub fn send_no_shutdown_on_err(
44491 self,
44492 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
44493 ) -> Result<(), fidl::Error> {
44494 let _result = self.send_raw(result);
44495 self.drop_without_shutdown();
44496 _result
44497 }
44498
44499 fn send_raw(
44500 &self,
44501 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
44502 ) -> Result<(), fidl::Error> {
44503 self.control_handle.inner.send::<fidl::encoding::ResultType<
44504 BaseNetworkSocketGetIpMulticastInterfaceResponse,
44505 fidl_fuchsia_posix::Errno,
44506 >>(
44507 result.map(|value| (value,)),
44508 self.tx_id,
44509 0x320bd14c4df046c4,
44510 fidl::encoding::DynamicFlags::empty(),
44511 )
44512 }
44513}
44514
44515#[must_use = "FIDL methods require a response to be sent"]
44516#[derive(Debug)]
44517pub struct DatagramSocketSetIpMulticastTtlResponder {
44518 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44519 tx_id: u32,
44520}
44521
44522impl std::ops::Drop for DatagramSocketSetIpMulticastTtlResponder {
44526 fn drop(&mut self) {
44527 self.control_handle.shutdown();
44528 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44530 }
44531}
44532
44533impl fidl::endpoints::Responder for DatagramSocketSetIpMulticastTtlResponder {
44534 type ControlHandle = DatagramSocketControlHandle;
44535
44536 fn control_handle(&self) -> &DatagramSocketControlHandle {
44537 &self.control_handle
44538 }
44539
44540 fn drop_without_shutdown(mut self) {
44541 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44543 std::mem::forget(self);
44545 }
44546}
44547
44548impl DatagramSocketSetIpMulticastTtlResponder {
44549 pub fn send(
44553 self,
44554 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44555 ) -> Result<(), fidl::Error> {
44556 let _result = self.send_raw(result);
44557 if _result.is_err() {
44558 self.control_handle.shutdown();
44559 }
44560 self.drop_without_shutdown();
44561 _result
44562 }
44563
44564 pub fn send_no_shutdown_on_err(
44566 self,
44567 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44568 ) -> Result<(), fidl::Error> {
44569 let _result = self.send_raw(result);
44570 self.drop_without_shutdown();
44571 _result
44572 }
44573
44574 fn send_raw(
44575 &self,
44576 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44577 ) -> Result<(), fidl::Error> {
44578 self.control_handle.inner.send::<fidl::encoding::ResultType<
44579 fidl::encoding::EmptyStruct,
44580 fidl_fuchsia_posix::Errno,
44581 >>(
44582 result,
44583 self.tx_id,
44584 0x63134d53772916a1,
44585 fidl::encoding::DynamicFlags::empty(),
44586 )
44587 }
44588}
44589
44590#[must_use = "FIDL methods require a response to be sent"]
44591#[derive(Debug)]
44592pub struct DatagramSocketGetIpMulticastTtlResponder {
44593 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44594 tx_id: u32,
44595}
44596
44597impl std::ops::Drop for DatagramSocketGetIpMulticastTtlResponder {
44601 fn drop(&mut self) {
44602 self.control_handle.shutdown();
44603 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44605 }
44606}
44607
44608impl fidl::endpoints::Responder for DatagramSocketGetIpMulticastTtlResponder {
44609 type ControlHandle = DatagramSocketControlHandle;
44610
44611 fn control_handle(&self) -> &DatagramSocketControlHandle {
44612 &self.control_handle
44613 }
44614
44615 fn drop_without_shutdown(mut self) {
44616 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44618 std::mem::forget(self);
44620 }
44621}
44622
44623impl DatagramSocketGetIpMulticastTtlResponder {
44624 pub fn send(
44628 self,
44629 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
44630 ) -> Result<(), fidl::Error> {
44631 let _result = self.send_raw(result);
44632 if _result.is_err() {
44633 self.control_handle.shutdown();
44634 }
44635 self.drop_without_shutdown();
44636 _result
44637 }
44638
44639 pub fn send_no_shutdown_on_err(
44641 self,
44642 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
44643 ) -> Result<(), fidl::Error> {
44644 let _result = self.send_raw(result);
44645 self.drop_without_shutdown();
44646 _result
44647 }
44648
44649 fn send_raw(
44650 &self,
44651 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
44652 ) -> Result<(), fidl::Error> {
44653 self.control_handle.inner.send::<fidl::encoding::ResultType<
44654 BaseNetworkSocketGetIpMulticastTtlResponse,
44655 fidl_fuchsia_posix::Errno,
44656 >>(
44657 result.map(|value| (value,)),
44658 self.tx_id,
44659 0x4665cd378f39e1a,
44660 fidl::encoding::DynamicFlags::empty(),
44661 )
44662 }
44663}
44664
44665#[must_use = "FIDL methods require a response to be sent"]
44666#[derive(Debug)]
44667pub struct DatagramSocketSetIpMulticastLoopbackResponder {
44668 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44669 tx_id: u32,
44670}
44671
44672impl std::ops::Drop for DatagramSocketSetIpMulticastLoopbackResponder {
44676 fn drop(&mut self) {
44677 self.control_handle.shutdown();
44678 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44680 }
44681}
44682
44683impl fidl::endpoints::Responder for DatagramSocketSetIpMulticastLoopbackResponder {
44684 type ControlHandle = DatagramSocketControlHandle;
44685
44686 fn control_handle(&self) -> &DatagramSocketControlHandle {
44687 &self.control_handle
44688 }
44689
44690 fn drop_without_shutdown(mut self) {
44691 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44693 std::mem::forget(self);
44695 }
44696}
44697
44698impl DatagramSocketSetIpMulticastLoopbackResponder {
44699 pub fn send(
44703 self,
44704 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44705 ) -> Result<(), fidl::Error> {
44706 let _result = self.send_raw(result);
44707 if _result.is_err() {
44708 self.control_handle.shutdown();
44709 }
44710 self.drop_without_shutdown();
44711 _result
44712 }
44713
44714 pub fn send_no_shutdown_on_err(
44716 self,
44717 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44718 ) -> Result<(), fidl::Error> {
44719 let _result = self.send_raw(result);
44720 self.drop_without_shutdown();
44721 _result
44722 }
44723
44724 fn send_raw(
44725 &self,
44726 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44727 ) -> Result<(), fidl::Error> {
44728 self.control_handle.inner.send::<fidl::encoding::ResultType<
44729 fidl::encoding::EmptyStruct,
44730 fidl_fuchsia_posix::Errno,
44731 >>(
44732 result,
44733 self.tx_id,
44734 0x20c55c11f00943ea,
44735 fidl::encoding::DynamicFlags::empty(),
44736 )
44737 }
44738}
44739
44740#[must_use = "FIDL methods require a response to be sent"]
44741#[derive(Debug)]
44742pub struct DatagramSocketGetIpMulticastLoopbackResponder {
44743 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44744 tx_id: u32,
44745}
44746
44747impl std::ops::Drop for DatagramSocketGetIpMulticastLoopbackResponder {
44751 fn drop(&mut self) {
44752 self.control_handle.shutdown();
44753 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44755 }
44756}
44757
44758impl fidl::endpoints::Responder for DatagramSocketGetIpMulticastLoopbackResponder {
44759 type ControlHandle = DatagramSocketControlHandle;
44760
44761 fn control_handle(&self) -> &DatagramSocketControlHandle {
44762 &self.control_handle
44763 }
44764
44765 fn drop_without_shutdown(mut self) {
44766 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44768 std::mem::forget(self);
44770 }
44771}
44772
44773impl DatagramSocketGetIpMulticastLoopbackResponder {
44774 pub fn send(
44778 self,
44779 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44780 ) -> Result<(), fidl::Error> {
44781 let _result = self.send_raw(result);
44782 if _result.is_err() {
44783 self.control_handle.shutdown();
44784 }
44785 self.drop_without_shutdown();
44786 _result
44787 }
44788
44789 pub fn send_no_shutdown_on_err(
44791 self,
44792 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44793 ) -> Result<(), fidl::Error> {
44794 let _result = self.send_raw(result);
44795 self.drop_without_shutdown();
44796 _result
44797 }
44798
44799 fn send_raw(
44800 &self,
44801 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44802 ) -> Result<(), fidl::Error> {
44803 self.control_handle.inner.send::<fidl::encoding::ResultType<
44804 BaseNetworkSocketGetIpMulticastLoopbackResponse,
44805 fidl_fuchsia_posix::Errno,
44806 >>(
44807 result.map(|value| (value,)),
44808 self.tx_id,
44809 0x3b6b26ff558298f2,
44810 fidl::encoding::DynamicFlags::empty(),
44811 )
44812 }
44813}
44814
44815#[must_use = "FIDL methods require a response to be sent"]
44816#[derive(Debug)]
44817pub struct DatagramSocketAddIpMembershipResponder {
44818 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44819 tx_id: u32,
44820}
44821
44822impl std::ops::Drop for DatagramSocketAddIpMembershipResponder {
44826 fn drop(&mut self) {
44827 self.control_handle.shutdown();
44828 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44830 }
44831}
44832
44833impl fidl::endpoints::Responder for DatagramSocketAddIpMembershipResponder {
44834 type ControlHandle = DatagramSocketControlHandle;
44835
44836 fn control_handle(&self) -> &DatagramSocketControlHandle {
44837 &self.control_handle
44838 }
44839
44840 fn drop_without_shutdown(mut self) {
44841 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44843 std::mem::forget(self);
44845 }
44846}
44847
44848impl DatagramSocketAddIpMembershipResponder {
44849 pub fn send(
44853 self,
44854 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44855 ) -> Result<(), fidl::Error> {
44856 let _result = self.send_raw(result);
44857 if _result.is_err() {
44858 self.control_handle.shutdown();
44859 }
44860 self.drop_without_shutdown();
44861 _result
44862 }
44863
44864 pub fn send_no_shutdown_on_err(
44866 self,
44867 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44868 ) -> Result<(), fidl::Error> {
44869 let _result = self.send_raw(result);
44870 self.drop_without_shutdown();
44871 _result
44872 }
44873
44874 fn send_raw(
44875 &self,
44876 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44877 ) -> Result<(), fidl::Error> {
44878 self.control_handle.inner.send::<fidl::encoding::ResultType<
44879 fidl::encoding::EmptyStruct,
44880 fidl_fuchsia_posix::Errno,
44881 >>(
44882 result,
44883 self.tx_id,
44884 0x76bc7df115a3b4d0,
44885 fidl::encoding::DynamicFlags::empty(),
44886 )
44887 }
44888}
44889
44890#[must_use = "FIDL methods require a response to be sent"]
44891#[derive(Debug)]
44892pub struct DatagramSocketDropIpMembershipResponder {
44893 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44894 tx_id: u32,
44895}
44896
44897impl std::ops::Drop for DatagramSocketDropIpMembershipResponder {
44901 fn drop(&mut self) {
44902 self.control_handle.shutdown();
44903 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44905 }
44906}
44907
44908impl fidl::endpoints::Responder for DatagramSocketDropIpMembershipResponder {
44909 type ControlHandle = DatagramSocketControlHandle;
44910
44911 fn control_handle(&self) -> &DatagramSocketControlHandle {
44912 &self.control_handle
44913 }
44914
44915 fn drop_without_shutdown(mut self) {
44916 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44918 std::mem::forget(self);
44920 }
44921}
44922
44923impl DatagramSocketDropIpMembershipResponder {
44924 pub fn send(
44928 self,
44929 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44930 ) -> Result<(), fidl::Error> {
44931 let _result = self.send_raw(result);
44932 if _result.is_err() {
44933 self.control_handle.shutdown();
44934 }
44935 self.drop_without_shutdown();
44936 _result
44937 }
44938
44939 pub fn send_no_shutdown_on_err(
44941 self,
44942 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44943 ) -> Result<(), fidl::Error> {
44944 let _result = self.send_raw(result);
44945 self.drop_without_shutdown();
44946 _result
44947 }
44948
44949 fn send_raw(
44950 &self,
44951 mut result: Result<(), fidl_fuchsia_posix::Errno>,
44952 ) -> Result<(), fidl::Error> {
44953 self.control_handle.inner.send::<fidl::encoding::ResultType<
44954 fidl::encoding::EmptyStruct,
44955 fidl_fuchsia_posix::Errno,
44956 >>(
44957 result,
44958 self.tx_id,
44959 0x2888f3099188d03,
44960 fidl::encoding::DynamicFlags::empty(),
44961 )
44962 }
44963}
44964
44965#[must_use = "FIDL methods require a response to be sent"]
44966#[derive(Debug)]
44967pub struct DatagramSocketSetIpTransparentResponder {
44968 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44969 tx_id: u32,
44970}
44971
44972impl std::ops::Drop for DatagramSocketSetIpTransparentResponder {
44976 fn drop(&mut self) {
44977 self.control_handle.shutdown();
44978 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44980 }
44981}
44982
44983impl fidl::endpoints::Responder for DatagramSocketSetIpTransparentResponder {
44984 type ControlHandle = DatagramSocketControlHandle;
44985
44986 fn control_handle(&self) -> &DatagramSocketControlHandle {
44987 &self.control_handle
44988 }
44989
44990 fn drop_without_shutdown(mut self) {
44991 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44993 std::mem::forget(self);
44995 }
44996}
44997
44998impl DatagramSocketSetIpTransparentResponder {
44999 pub fn send(
45003 self,
45004 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45005 ) -> Result<(), fidl::Error> {
45006 let _result = self.send_raw(result);
45007 if _result.is_err() {
45008 self.control_handle.shutdown();
45009 }
45010 self.drop_without_shutdown();
45011 _result
45012 }
45013
45014 pub fn send_no_shutdown_on_err(
45016 self,
45017 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45018 ) -> Result<(), fidl::Error> {
45019 let _result = self.send_raw(result);
45020 self.drop_without_shutdown();
45021 _result
45022 }
45023
45024 fn send_raw(
45025 &self,
45026 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45027 ) -> Result<(), fidl::Error> {
45028 self.control_handle.inner.send::<fidl::encoding::ResultType<
45029 fidl::encoding::EmptyStruct,
45030 fidl_fuchsia_posix::Errno,
45031 >>(
45032 result,
45033 self.tx_id,
45034 0x1ae532b0c066e3a0,
45035 fidl::encoding::DynamicFlags::empty(),
45036 )
45037 }
45038}
45039
45040#[must_use = "FIDL methods require a response to be sent"]
45041#[derive(Debug)]
45042pub struct DatagramSocketGetIpTransparentResponder {
45043 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45044 tx_id: u32,
45045}
45046
45047impl std::ops::Drop for DatagramSocketGetIpTransparentResponder {
45051 fn drop(&mut self) {
45052 self.control_handle.shutdown();
45053 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45055 }
45056}
45057
45058impl fidl::endpoints::Responder for DatagramSocketGetIpTransparentResponder {
45059 type ControlHandle = DatagramSocketControlHandle;
45060
45061 fn control_handle(&self) -> &DatagramSocketControlHandle {
45062 &self.control_handle
45063 }
45064
45065 fn drop_without_shutdown(mut self) {
45066 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45068 std::mem::forget(self);
45070 }
45071}
45072
45073impl DatagramSocketGetIpTransparentResponder {
45074 pub fn send(
45078 self,
45079 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45080 ) -> Result<(), fidl::Error> {
45081 let _result = self.send_raw(result);
45082 if _result.is_err() {
45083 self.control_handle.shutdown();
45084 }
45085 self.drop_without_shutdown();
45086 _result
45087 }
45088
45089 pub fn send_no_shutdown_on_err(
45091 self,
45092 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45093 ) -> Result<(), fidl::Error> {
45094 let _result = self.send_raw(result);
45095 self.drop_without_shutdown();
45096 _result
45097 }
45098
45099 fn send_raw(
45100 &self,
45101 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45102 ) -> Result<(), fidl::Error> {
45103 self.control_handle.inner.send::<fidl::encoding::ResultType<
45104 BaseNetworkSocketGetIpTransparentResponse,
45105 fidl_fuchsia_posix::Errno,
45106 >>(
45107 result.map(|value| (value,)),
45108 self.tx_id,
45109 0x51d43695962ebfb5,
45110 fidl::encoding::DynamicFlags::empty(),
45111 )
45112 }
45113}
45114
45115#[must_use = "FIDL methods require a response to be sent"]
45116#[derive(Debug)]
45117pub struct DatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
45118 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45119 tx_id: u32,
45120}
45121
45122impl std::ops::Drop for DatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
45126 fn drop(&mut self) {
45127 self.control_handle.shutdown();
45128 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45130 }
45131}
45132
45133impl fidl::endpoints::Responder for DatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
45134 type ControlHandle = DatagramSocketControlHandle;
45135
45136 fn control_handle(&self) -> &DatagramSocketControlHandle {
45137 &self.control_handle
45138 }
45139
45140 fn drop_without_shutdown(mut self) {
45141 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45143 std::mem::forget(self);
45145 }
45146}
45147
45148impl DatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
45149 pub fn send(
45153 self,
45154 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45155 ) -> Result<(), fidl::Error> {
45156 let _result = self.send_raw(result);
45157 if _result.is_err() {
45158 self.control_handle.shutdown();
45159 }
45160 self.drop_without_shutdown();
45161 _result
45162 }
45163
45164 pub fn send_no_shutdown_on_err(
45166 self,
45167 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45168 ) -> Result<(), fidl::Error> {
45169 let _result = self.send_raw(result);
45170 self.drop_without_shutdown();
45171 _result
45172 }
45173
45174 fn send_raw(
45175 &self,
45176 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45177 ) -> Result<(), fidl::Error> {
45178 self.control_handle.inner.send::<fidl::encoding::ResultType<
45179 fidl::encoding::EmptyStruct,
45180 fidl_fuchsia_posix::Errno,
45181 >>(
45182 result,
45183 self.tx_id,
45184 0x4722b4ce52f7840,
45185 fidl::encoding::DynamicFlags::empty(),
45186 )
45187 }
45188}
45189
45190#[must_use = "FIDL methods require a response to be sent"]
45191#[derive(Debug)]
45192pub struct DatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
45193 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45194 tx_id: u32,
45195}
45196
45197impl std::ops::Drop for DatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
45201 fn drop(&mut self) {
45202 self.control_handle.shutdown();
45203 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45205 }
45206}
45207
45208impl fidl::endpoints::Responder for DatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
45209 type ControlHandle = DatagramSocketControlHandle;
45210
45211 fn control_handle(&self) -> &DatagramSocketControlHandle {
45212 &self.control_handle
45213 }
45214
45215 fn drop_without_shutdown(mut self) {
45216 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45218 std::mem::forget(self);
45220 }
45221}
45222
45223impl DatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
45224 pub fn send(
45228 self,
45229 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45230 ) -> Result<(), fidl::Error> {
45231 let _result = self.send_raw(result);
45232 if _result.is_err() {
45233 self.control_handle.shutdown();
45234 }
45235 self.drop_without_shutdown();
45236 _result
45237 }
45238
45239 pub fn send_no_shutdown_on_err(
45241 self,
45242 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45243 ) -> Result<(), fidl::Error> {
45244 let _result = self.send_raw(result);
45245 self.drop_without_shutdown();
45246 _result
45247 }
45248
45249 fn send_raw(
45250 &self,
45251 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45252 ) -> Result<(), fidl::Error> {
45253 self.control_handle.inner.send::<fidl::encoding::ResultType<
45254 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
45255 fidl_fuchsia_posix::Errno,
45256 >>(
45257 result.map(|value| (value,)),
45258 self.tx_id,
45259 0x2a0e7dc5d6bfdfe9,
45260 fidl::encoding::DynamicFlags::empty(),
45261 )
45262 }
45263}
45264
45265#[must_use = "FIDL methods require a response to be sent"]
45266#[derive(Debug)]
45267pub struct DatagramSocketAddIpv6MembershipResponder {
45268 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45269 tx_id: u32,
45270}
45271
45272impl std::ops::Drop for DatagramSocketAddIpv6MembershipResponder {
45276 fn drop(&mut self) {
45277 self.control_handle.shutdown();
45278 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45280 }
45281}
45282
45283impl fidl::endpoints::Responder for DatagramSocketAddIpv6MembershipResponder {
45284 type ControlHandle = DatagramSocketControlHandle;
45285
45286 fn control_handle(&self) -> &DatagramSocketControlHandle {
45287 &self.control_handle
45288 }
45289
45290 fn drop_without_shutdown(mut self) {
45291 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45293 std::mem::forget(self);
45295 }
45296}
45297
45298impl DatagramSocketAddIpv6MembershipResponder {
45299 pub fn send(
45303 self,
45304 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45305 ) -> Result<(), fidl::Error> {
45306 let _result = self.send_raw(result);
45307 if _result.is_err() {
45308 self.control_handle.shutdown();
45309 }
45310 self.drop_without_shutdown();
45311 _result
45312 }
45313
45314 pub fn send_no_shutdown_on_err(
45316 self,
45317 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45318 ) -> Result<(), fidl::Error> {
45319 let _result = self.send_raw(result);
45320 self.drop_without_shutdown();
45321 _result
45322 }
45323
45324 fn send_raw(
45325 &self,
45326 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45327 ) -> Result<(), fidl::Error> {
45328 self.control_handle.inner.send::<fidl::encoding::ResultType<
45329 fidl::encoding::EmptyStruct,
45330 fidl_fuchsia_posix::Errno,
45331 >>(
45332 result,
45333 self.tx_id,
45334 0x7c94727acb4ea4b3,
45335 fidl::encoding::DynamicFlags::empty(),
45336 )
45337 }
45338}
45339
45340#[must_use = "FIDL methods require a response to be sent"]
45341#[derive(Debug)]
45342pub struct DatagramSocketDropIpv6MembershipResponder {
45343 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45344 tx_id: u32,
45345}
45346
45347impl std::ops::Drop for DatagramSocketDropIpv6MembershipResponder {
45351 fn drop(&mut self) {
45352 self.control_handle.shutdown();
45353 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45355 }
45356}
45357
45358impl fidl::endpoints::Responder for DatagramSocketDropIpv6MembershipResponder {
45359 type ControlHandle = DatagramSocketControlHandle;
45360
45361 fn control_handle(&self) -> &DatagramSocketControlHandle {
45362 &self.control_handle
45363 }
45364
45365 fn drop_without_shutdown(mut self) {
45366 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45368 std::mem::forget(self);
45370 }
45371}
45372
45373impl DatagramSocketDropIpv6MembershipResponder {
45374 pub fn send(
45378 self,
45379 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45380 ) -> Result<(), fidl::Error> {
45381 let _result = self.send_raw(result);
45382 if _result.is_err() {
45383 self.control_handle.shutdown();
45384 }
45385 self.drop_without_shutdown();
45386 _result
45387 }
45388
45389 pub fn send_no_shutdown_on_err(
45391 self,
45392 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45393 ) -> Result<(), fidl::Error> {
45394 let _result = self.send_raw(result);
45395 self.drop_without_shutdown();
45396 _result
45397 }
45398
45399 fn send_raw(
45400 &self,
45401 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45402 ) -> Result<(), fidl::Error> {
45403 self.control_handle.inner.send::<fidl::encoding::ResultType<
45404 fidl::encoding::EmptyStruct,
45405 fidl_fuchsia_posix::Errno,
45406 >>(
45407 result,
45408 self.tx_id,
45409 0x42104c70ccaba304,
45410 fidl::encoding::DynamicFlags::empty(),
45411 )
45412 }
45413}
45414
45415#[must_use = "FIDL methods require a response to be sent"]
45416#[derive(Debug)]
45417pub struct DatagramSocketSetIpv6MulticastInterfaceResponder {
45418 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45419 tx_id: u32,
45420}
45421
45422impl std::ops::Drop for DatagramSocketSetIpv6MulticastInterfaceResponder {
45426 fn drop(&mut self) {
45427 self.control_handle.shutdown();
45428 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45430 }
45431}
45432
45433impl fidl::endpoints::Responder for DatagramSocketSetIpv6MulticastInterfaceResponder {
45434 type ControlHandle = DatagramSocketControlHandle;
45435
45436 fn control_handle(&self) -> &DatagramSocketControlHandle {
45437 &self.control_handle
45438 }
45439
45440 fn drop_without_shutdown(mut self) {
45441 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45443 std::mem::forget(self);
45445 }
45446}
45447
45448impl DatagramSocketSetIpv6MulticastInterfaceResponder {
45449 pub fn send(
45453 self,
45454 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45455 ) -> Result<(), fidl::Error> {
45456 let _result = self.send_raw(result);
45457 if _result.is_err() {
45458 self.control_handle.shutdown();
45459 }
45460 self.drop_without_shutdown();
45461 _result
45462 }
45463
45464 pub fn send_no_shutdown_on_err(
45466 self,
45467 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45468 ) -> Result<(), fidl::Error> {
45469 let _result = self.send_raw(result);
45470 self.drop_without_shutdown();
45471 _result
45472 }
45473
45474 fn send_raw(
45475 &self,
45476 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45477 ) -> Result<(), fidl::Error> {
45478 self.control_handle.inner.send::<fidl::encoding::ResultType<
45479 fidl::encoding::EmptyStruct,
45480 fidl_fuchsia_posix::Errno,
45481 >>(
45482 result,
45483 self.tx_id,
45484 0x135f76db3774ab3b,
45485 fidl::encoding::DynamicFlags::empty(),
45486 )
45487 }
45488}
45489
45490#[must_use = "FIDL methods require a response to be sent"]
45491#[derive(Debug)]
45492pub struct DatagramSocketGetIpv6MulticastInterfaceResponder {
45493 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45494 tx_id: u32,
45495}
45496
45497impl std::ops::Drop for DatagramSocketGetIpv6MulticastInterfaceResponder {
45501 fn drop(&mut self) {
45502 self.control_handle.shutdown();
45503 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45505 }
45506}
45507
45508impl fidl::endpoints::Responder for DatagramSocketGetIpv6MulticastInterfaceResponder {
45509 type ControlHandle = DatagramSocketControlHandle;
45510
45511 fn control_handle(&self) -> &DatagramSocketControlHandle {
45512 &self.control_handle
45513 }
45514
45515 fn drop_without_shutdown(mut self) {
45516 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45518 std::mem::forget(self);
45520 }
45521}
45522
45523impl DatagramSocketGetIpv6MulticastInterfaceResponder {
45524 pub fn send(
45528 self,
45529 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
45530 ) -> Result<(), fidl::Error> {
45531 let _result = self.send_raw(result);
45532 if _result.is_err() {
45533 self.control_handle.shutdown();
45534 }
45535 self.drop_without_shutdown();
45536 _result
45537 }
45538
45539 pub fn send_no_shutdown_on_err(
45541 self,
45542 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
45543 ) -> Result<(), fidl::Error> {
45544 let _result = self.send_raw(result);
45545 self.drop_without_shutdown();
45546 _result
45547 }
45548
45549 fn send_raw(
45550 &self,
45551 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
45552 ) -> Result<(), fidl::Error> {
45553 self.control_handle.inner.send::<fidl::encoding::ResultType<
45554 BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
45555 fidl_fuchsia_posix::Errno,
45556 >>(
45557 result.map(|value| (value,)),
45558 self.tx_id,
45559 0x1f26fcdd348f1882,
45560 fidl::encoding::DynamicFlags::empty(),
45561 )
45562 }
45563}
45564
45565#[must_use = "FIDL methods require a response to be sent"]
45566#[derive(Debug)]
45567pub struct DatagramSocketSetIpv6UnicastHopsResponder {
45568 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45569 tx_id: u32,
45570}
45571
45572impl std::ops::Drop for DatagramSocketSetIpv6UnicastHopsResponder {
45576 fn drop(&mut self) {
45577 self.control_handle.shutdown();
45578 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45580 }
45581}
45582
45583impl fidl::endpoints::Responder for DatagramSocketSetIpv6UnicastHopsResponder {
45584 type ControlHandle = DatagramSocketControlHandle;
45585
45586 fn control_handle(&self) -> &DatagramSocketControlHandle {
45587 &self.control_handle
45588 }
45589
45590 fn drop_without_shutdown(mut self) {
45591 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45593 std::mem::forget(self);
45595 }
45596}
45597
45598impl DatagramSocketSetIpv6UnicastHopsResponder {
45599 pub fn send(
45603 self,
45604 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45605 ) -> Result<(), fidl::Error> {
45606 let _result = self.send_raw(result);
45607 if _result.is_err() {
45608 self.control_handle.shutdown();
45609 }
45610 self.drop_without_shutdown();
45611 _result
45612 }
45613
45614 pub fn send_no_shutdown_on_err(
45616 self,
45617 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45618 ) -> Result<(), fidl::Error> {
45619 let _result = self.send_raw(result);
45620 self.drop_without_shutdown();
45621 _result
45622 }
45623
45624 fn send_raw(
45625 &self,
45626 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45627 ) -> Result<(), fidl::Error> {
45628 self.control_handle.inner.send::<fidl::encoding::ResultType<
45629 fidl::encoding::EmptyStruct,
45630 fidl_fuchsia_posix::Errno,
45631 >>(
45632 result,
45633 self.tx_id,
45634 0x157d51e98f462859,
45635 fidl::encoding::DynamicFlags::empty(),
45636 )
45637 }
45638}
45639
45640#[must_use = "FIDL methods require a response to be sent"]
45641#[derive(Debug)]
45642pub struct DatagramSocketGetIpv6UnicastHopsResponder {
45643 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45644 tx_id: u32,
45645}
45646
45647impl std::ops::Drop for DatagramSocketGetIpv6UnicastHopsResponder {
45651 fn drop(&mut self) {
45652 self.control_handle.shutdown();
45653 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45655 }
45656}
45657
45658impl fidl::endpoints::Responder for DatagramSocketGetIpv6UnicastHopsResponder {
45659 type ControlHandle = DatagramSocketControlHandle;
45660
45661 fn control_handle(&self) -> &DatagramSocketControlHandle {
45662 &self.control_handle
45663 }
45664
45665 fn drop_without_shutdown(mut self) {
45666 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45668 std::mem::forget(self);
45670 }
45671}
45672
45673impl DatagramSocketGetIpv6UnicastHopsResponder {
45674 pub fn send(
45678 self,
45679 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
45680 ) -> Result<(), fidl::Error> {
45681 let _result = self.send_raw(result);
45682 if _result.is_err() {
45683 self.control_handle.shutdown();
45684 }
45685 self.drop_without_shutdown();
45686 _result
45687 }
45688
45689 pub fn send_no_shutdown_on_err(
45691 self,
45692 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
45693 ) -> Result<(), fidl::Error> {
45694 let _result = self.send_raw(result);
45695 self.drop_without_shutdown();
45696 _result
45697 }
45698
45699 fn send_raw(
45700 &self,
45701 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
45702 ) -> Result<(), fidl::Error> {
45703 self.control_handle.inner.send::<fidl::encoding::ResultType<
45704 BaseNetworkSocketGetIpv6UnicastHopsResponse,
45705 fidl_fuchsia_posix::Errno,
45706 >>(
45707 result.map(|value| (value,)),
45708 self.tx_id,
45709 0x21f4641cad8bd8d2,
45710 fidl::encoding::DynamicFlags::empty(),
45711 )
45712 }
45713}
45714
45715#[must_use = "FIDL methods require a response to be sent"]
45716#[derive(Debug)]
45717pub struct DatagramSocketSetIpv6ReceiveHopLimitResponder {
45718 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45719 tx_id: u32,
45720}
45721
45722impl std::ops::Drop for DatagramSocketSetIpv6ReceiveHopLimitResponder {
45726 fn drop(&mut self) {
45727 self.control_handle.shutdown();
45728 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45730 }
45731}
45732
45733impl fidl::endpoints::Responder for DatagramSocketSetIpv6ReceiveHopLimitResponder {
45734 type ControlHandle = DatagramSocketControlHandle;
45735
45736 fn control_handle(&self) -> &DatagramSocketControlHandle {
45737 &self.control_handle
45738 }
45739
45740 fn drop_without_shutdown(mut self) {
45741 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45743 std::mem::forget(self);
45745 }
45746}
45747
45748impl DatagramSocketSetIpv6ReceiveHopLimitResponder {
45749 pub fn send(
45753 self,
45754 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45755 ) -> Result<(), fidl::Error> {
45756 let _result = self.send_raw(result);
45757 if _result.is_err() {
45758 self.control_handle.shutdown();
45759 }
45760 self.drop_without_shutdown();
45761 _result
45762 }
45763
45764 pub fn send_no_shutdown_on_err(
45766 self,
45767 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45768 ) -> Result<(), fidl::Error> {
45769 let _result = self.send_raw(result);
45770 self.drop_without_shutdown();
45771 _result
45772 }
45773
45774 fn send_raw(
45775 &self,
45776 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45777 ) -> Result<(), fidl::Error> {
45778 self.control_handle.inner.send::<fidl::encoding::ResultType<
45779 fidl::encoding::EmptyStruct,
45780 fidl_fuchsia_posix::Errno,
45781 >>(
45782 result,
45783 self.tx_id,
45784 0x5c24808ed2e84a1e,
45785 fidl::encoding::DynamicFlags::empty(),
45786 )
45787 }
45788}
45789
45790#[must_use = "FIDL methods require a response to be sent"]
45791#[derive(Debug)]
45792pub struct DatagramSocketGetIpv6ReceiveHopLimitResponder {
45793 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45794 tx_id: u32,
45795}
45796
45797impl std::ops::Drop for DatagramSocketGetIpv6ReceiveHopLimitResponder {
45801 fn drop(&mut self) {
45802 self.control_handle.shutdown();
45803 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45805 }
45806}
45807
45808impl fidl::endpoints::Responder for DatagramSocketGetIpv6ReceiveHopLimitResponder {
45809 type ControlHandle = DatagramSocketControlHandle;
45810
45811 fn control_handle(&self) -> &DatagramSocketControlHandle {
45812 &self.control_handle
45813 }
45814
45815 fn drop_without_shutdown(mut self) {
45816 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45818 std::mem::forget(self);
45820 }
45821}
45822
45823impl DatagramSocketGetIpv6ReceiveHopLimitResponder {
45824 pub fn send(
45828 self,
45829 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45830 ) -> Result<(), fidl::Error> {
45831 let _result = self.send_raw(result);
45832 if _result.is_err() {
45833 self.control_handle.shutdown();
45834 }
45835 self.drop_without_shutdown();
45836 _result
45837 }
45838
45839 pub fn send_no_shutdown_on_err(
45841 self,
45842 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45843 ) -> Result<(), fidl::Error> {
45844 let _result = self.send_raw(result);
45845 self.drop_without_shutdown();
45846 _result
45847 }
45848
45849 fn send_raw(
45850 &self,
45851 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45852 ) -> Result<(), fidl::Error> {
45853 self.control_handle.inner.send::<fidl::encoding::ResultType<
45854 BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
45855 fidl_fuchsia_posix::Errno,
45856 >>(
45857 result.map(|value| (value,)),
45858 self.tx_id,
45859 0x341e06689885b4c0,
45860 fidl::encoding::DynamicFlags::empty(),
45861 )
45862 }
45863}
45864
45865#[must_use = "FIDL methods require a response to be sent"]
45866#[derive(Debug)]
45867pub struct DatagramSocketSetIpv6MulticastHopsResponder {
45868 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45869 tx_id: u32,
45870}
45871
45872impl std::ops::Drop for DatagramSocketSetIpv6MulticastHopsResponder {
45876 fn drop(&mut self) {
45877 self.control_handle.shutdown();
45878 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45880 }
45881}
45882
45883impl fidl::endpoints::Responder for DatagramSocketSetIpv6MulticastHopsResponder {
45884 type ControlHandle = DatagramSocketControlHandle;
45885
45886 fn control_handle(&self) -> &DatagramSocketControlHandle {
45887 &self.control_handle
45888 }
45889
45890 fn drop_without_shutdown(mut self) {
45891 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45893 std::mem::forget(self);
45895 }
45896}
45897
45898impl DatagramSocketSetIpv6MulticastHopsResponder {
45899 pub fn send(
45903 self,
45904 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45905 ) -> Result<(), fidl::Error> {
45906 let _result = self.send_raw(result);
45907 if _result.is_err() {
45908 self.control_handle.shutdown();
45909 }
45910 self.drop_without_shutdown();
45911 _result
45912 }
45913
45914 pub fn send_no_shutdown_on_err(
45916 self,
45917 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45918 ) -> Result<(), fidl::Error> {
45919 let _result = self.send_raw(result);
45920 self.drop_without_shutdown();
45921 _result
45922 }
45923
45924 fn send_raw(
45925 &self,
45926 mut result: Result<(), fidl_fuchsia_posix::Errno>,
45927 ) -> Result<(), fidl::Error> {
45928 self.control_handle.inner.send::<fidl::encoding::ResultType<
45929 fidl::encoding::EmptyStruct,
45930 fidl_fuchsia_posix::Errno,
45931 >>(
45932 result,
45933 self.tx_id,
45934 0x25b9cd4d181f82c1,
45935 fidl::encoding::DynamicFlags::empty(),
45936 )
45937 }
45938}
45939
45940#[must_use = "FIDL methods require a response to be sent"]
45941#[derive(Debug)]
45942pub struct DatagramSocketGetIpv6MulticastHopsResponder {
45943 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45944 tx_id: u32,
45945}
45946
45947impl std::ops::Drop for DatagramSocketGetIpv6MulticastHopsResponder {
45951 fn drop(&mut self) {
45952 self.control_handle.shutdown();
45953 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45955 }
45956}
45957
45958impl fidl::endpoints::Responder for DatagramSocketGetIpv6MulticastHopsResponder {
45959 type ControlHandle = DatagramSocketControlHandle;
45960
45961 fn control_handle(&self) -> &DatagramSocketControlHandle {
45962 &self.control_handle
45963 }
45964
45965 fn drop_without_shutdown(mut self) {
45966 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45968 std::mem::forget(self);
45970 }
45971}
45972
45973impl DatagramSocketGetIpv6MulticastHopsResponder {
45974 pub fn send(
45978 self,
45979 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
45980 ) -> Result<(), fidl::Error> {
45981 let _result = self.send_raw(result);
45982 if _result.is_err() {
45983 self.control_handle.shutdown();
45984 }
45985 self.drop_without_shutdown();
45986 _result
45987 }
45988
45989 pub fn send_no_shutdown_on_err(
45991 self,
45992 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
45993 ) -> Result<(), fidl::Error> {
45994 let _result = self.send_raw(result);
45995 self.drop_without_shutdown();
45996 _result
45997 }
45998
45999 fn send_raw(
46000 &self,
46001 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
46002 ) -> Result<(), fidl::Error> {
46003 self.control_handle.inner.send::<fidl::encoding::ResultType<
46004 BaseNetworkSocketGetIpv6MulticastHopsResponse,
46005 fidl_fuchsia_posix::Errno,
46006 >>(
46007 result.map(|value| (value,)),
46008 self.tx_id,
46009 0x52916948a365012a,
46010 fidl::encoding::DynamicFlags::empty(),
46011 )
46012 }
46013}
46014
46015#[must_use = "FIDL methods require a response to be sent"]
46016#[derive(Debug)]
46017pub struct DatagramSocketSetIpv6MulticastLoopbackResponder {
46018 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46019 tx_id: u32,
46020}
46021
46022impl std::ops::Drop for DatagramSocketSetIpv6MulticastLoopbackResponder {
46026 fn drop(&mut self) {
46027 self.control_handle.shutdown();
46028 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46030 }
46031}
46032
46033impl fidl::endpoints::Responder for DatagramSocketSetIpv6MulticastLoopbackResponder {
46034 type ControlHandle = DatagramSocketControlHandle;
46035
46036 fn control_handle(&self) -> &DatagramSocketControlHandle {
46037 &self.control_handle
46038 }
46039
46040 fn drop_without_shutdown(mut self) {
46041 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46043 std::mem::forget(self);
46045 }
46046}
46047
46048impl DatagramSocketSetIpv6MulticastLoopbackResponder {
46049 pub fn send(
46053 self,
46054 mut result: Result<(), fidl_fuchsia_posix::Errno>,
46055 ) -> Result<(), fidl::Error> {
46056 let _result = self.send_raw(result);
46057 if _result.is_err() {
46058 self.control_handle.shutdown();
46059 }
46060 self.drop_without_shutdown();
46061 _result
46062 }
46063
46064 pub fn send_no_shutdown_on_err(
46066 self,
46067 mut result: Result<(), fidl_fuchsia_posix::Errno>,
46068 ) -> Result<(), fidl::Error> {
46069 let _result = self.send_raw(result);
46070 self.drop_without_shutdown();
46071 _result
46072 }
46073
46074 fn send_raw(
46075 &self,
46076 mut result: Result<(), fidl_fuchsia_posix::Errno>,
46077 ) -> Result<(), fidl::Error> {
46078 self.control_handle.inner.send::<fidl::encoding::ResultType<
46079 fidl::encoding::EmptyStruct,
46080 fidl_fuchsia_posix::Errno,
46081 >>(
46082 result,
46083 self.tx_id,
46084 0x55701c409ff41b40,
46085 fidl::encoding::DynamicFlags::empty(),
46086 )
46087 }
46088}
46089
46090#[must_use = "FIDL methods require a response to be sent"]
46091#[derive(Debug)]
46092pub struct DatagramSocketGetIpv6MulticastLoopbackResponder {
46093 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46094 tx_id: u32,
46095}
46096
46097impl std::ops::Drop for DatagramSocketGetIpv6MulticastLoopbackResponder {
46101 fn drop(&mut self) {
46102 self.control_handle.shutdown();
46103 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46105 }
46106}
46107
46108impl fidl::endpoints::Responder for DatagramSocketGetIpv6MulticastLoopbackResponder {
46109 type ControlHandle = DatagramSocketControlHandle;
46110
46111 fn control_handle(&self) -> &DatagramSocketControlHandle {
46112 &self.control_handle
46113 }
46114
46115 fn drop_without_shutdown(mut self) {
46116 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46118 std::mem::forget(self);
46120 }
46121}
46122
46123impl DatagramSocketGetIpv6MulticastLoopbackResponder {
46124 pub fn send(
46128 self,
46129 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46130 ) -> Result<(), fidl::Error> {
46131 let _result = self.send_raw(result);
46132 if _result.is_err() {
46133 self.control_handle.shutdown();
46134 }
46135 self.drop_without_shutdown();
46136 _result
46137 }
46138
46139 pub fn send_no_shutdown_on_err(
46141 self,
46142 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46143 ) -> Result<(), fidl::Error> {
46144 let _result = self.send_raw(result);
46145 self.drop_without_shutdown();
46146 _result
46147 }
46148
46149 fn send_raw(
46150 &self,
46151 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46152 ) -> Result<(), fidl::Error> {
46153 self.control_handle.inner.send::<fidl::encoding::ResultType<
46154 BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
46155 fidl_fuchsia_posix::Errno,
46156 >>(
46157 result.map(|value| (value,)),
46158 self.tx_id,
46159 0x4415b701fde319c3,
46160 fidl::encoding::DynamicFlags::empty(),
46161 )
46162 }
46163}
46164
46165#[must_use = "FIDL methods require a response to be sent"]
46166#[derive(Debug)]
46167pub struct DatagramSocketSetIpv6OnlyResponder {
46168 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46169 tx_id: u32,
46170}
46171
46172impl std::ops::Drop for DatagramSocketSetIpv6OnlyResponder {
46176 fn drop(&mut self) {
46177 self.control_handle.shutdown();
46178 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46180 }
46181}
46182
46183impl fidl::endpoints::Responder for DatagramSocketSetIpv6OnlyResponder {
46184 type ControlHandle = DatagramSocketControlHandle;
46185
46186 fn control_handle(&self) -> &DatagramSocketControlHandle {
46187 &self.control_handle
46188 }
46189
46190 fn drop_without_shutdown(mut self) {
46191 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46193 std::mem::forget(self);
46195 }
46196}
46197
46198impl DatagramSocketSetIpv6OnlyResponder {
46199 pub fn send(
46203 self,
46204 mut result: Result<(), fidl_fuchsia_posix::Errno>,
46205 ) -> Result<(), fidl::Error> {
46206 let _result = self.send_raw(result);
46207 if _result.is_err() {
46208 self.control_handle.shutdown();
46209 }
46210 self.drop_without_shutdown();
46211 _result
46212 }
46213
46214 pub fn send_no_shutdown_on_err(
46216 self,
46217 mut result: Result<(), fidl_fuchsia_posix::Errno>,
46218 ) -> Result<(), fidl::Error> {
46219 let _result = self.send_raw(result);
46220 self.drop_without_shutdown();
46221 _result
46222 }
46223
46224 fn send_raw(
46225 &self,
46226 mut result: Result<(), fidl_fuchsia_posix::Errno>,
46227 ) -> Result<(), fidl::Error> {
46228 self.control_handle.inner.send::<fidl::encoding::ResultType<
46229 fidl::encoding::EmptyStruct,
46230 fidl_fuchsia_posix::Errno,
46231 >>(
46232 result,
46233 self.tx_id,
46234 0x4873f1364758cbba,
46235 fidl::encoding::DynamicFlags::empty(),
46236 )
46237 }
46238}
46239
46240#[must_use = "FIDL methods require a response to be sent"]
46241#[derive(Debug)]
46242pub struct DatagramSocketGetIpv6OnlyResponder {
46243 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46244 tx_id: u32,
46245}
46246
46247impl std::ops::Drop for DatagramSocketGetIpv6OnlyResponder {
46251 fn drop(&mut self) {
46252 self.control_handle.shutdown();
46253 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46255 }
46256}
46257
46258impl fidl::endpoints::Responder for DatagramSocketGetIpv6OnlyResponder {
46259 type ControlHandle = DatagramSocketControlHandle;
46260
46261 fn control_handle(&self) -> &DatagramSocketControlHandle {
46262 &self.control_handle
46263 }
46264
46265 fn drop_without_shutdown(mut self) {
46266 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46268 std::mem::forget(self);
46270 }
46271}
46272
46273impl DatagramSocketGetIpv6OnlyResponder {
46274 pub fn send(
46278 self,
46279 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46280 ) -> Result<(), fidl::Error> {
46281 let _result = self.send_raw(result);
46282 if _result.is_err() {
46283 self.control_handle.shutdown();
46284 }
46285 self.drop_without_shutdown();
46286 _result
46287 }
46288
46289 pub fn send_no_shutdown_on_err(
46291 self,
46292 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46293 ) -> Result<(), fidl::Error> {
46294 let _result = self.send_raw(result);
46295 self.drop_without_shutdown();
46296 _result
46297 }
46298
46299 fn send_raw(
46300 &self,
46301 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46302 ) -> Result<(), fidl::Error> {
46303 self.control_handle.inner.send::<fidl::encoding::ResultType<
46304 BaseNetworkSocketGetIpv6OnlyResponse,
46305 fidl_fuchsia_posix::Errno,
46306 >>(
46307 result.map(|value| (value,)),
46308 self.tx_id,
46309 0x4aa3340a1a26b89c,
46310 fidl::encoding::DynamicFlags::empty(),
46311 )
46312 }
46313}
46314
46315#[must_use = "FIDL methods require a response to be sent"]
46316#[derive(Debug)]
46317pub struct DatagramSocketSetIpv6ReceiveTrafficClassResponder {
46318 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46319 tx_id: u32,
46320}
46321
46322impl std::ops::Drop for DatagramSocketSetIpv6ReceiveTrafficClassResponder {
46326 fn drop(&mut self) {
46327 self.control_handle.shutdown();
46328 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46330 }
46331}
46332
46333impl fidl::endpoints::Responder for DatagramSocketSetIpv6ReceiveTrafficClassResponder {
46334 type ControlHandle = DatagramSocketControlHandle;
46335
46336 fn control_handle(&self) -> &DatagramSocketControlHandle {
46337 &self.control_handle
46338 }
46339
46340 fn drop_without_shutdown(mut self) {
46341 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46343 std::mem::forget(self);
46345 }
46346}
46347
46348impl DatagramSocketSetIpv6ReceiveTrafficClassResponder {
46349 pub fn send(
46353 self,
46354 mut result: Result<(), fidl_fuchsia_posix::Errno>,
46355 ) -> Result<(), fidl::Error> {
46356 let _result = self.send_raw(result);
46357 if _result.is_err() {
46358 self.control_handle.shutdown();
46359 }
46360 self.drop_without_shutdown();
46361 _result
46362 }
46363
46364 pub fn send_no_shutdown_on_err(
46366 self,
46367 mut result: Result<(), fidl_fuchsia_posix::Errno>,
46368 ) -> Result<(), fidl::Error> {
46369 let _result = self.send_raw(result);
46370 self.drop_without_shutdown();
46371 _result
46372 }
46373
46374 fn send_raw(
46375 &self,
46376 mut result: Result<(), fidl_fuchsia_posix::Errno>,
46377 ) -> Result<(), fidl::Error> {
46378 self.control_handle.inner.send::<fidl::encoding::ResultType<
46379 fidl::encoding::EmptyStruct,
46380 fidl_fuchsia_posix::Errno,
46381 >>(
46382 result,
46383 self.tx_id,
46384 0x58f07c8788d099a0,
46385 fidl::encoding::DynamicFlags::empty(),
46386 )
46387 }
46388}
46389
46390#[must_use = "FIDL methods require a response to be sent"]
46391#[derive(Debug)]
46392pub struct DatagramSocketGetIpv6ReceiveTrafficClassResponder {
46393 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46394 tx_id: u32,
46395}
46396
46397impl std::ops::Drop for DatagramSocketGetIpv6ReceiveTrafficClassResponder {
46401 fn drop(&mut self) {
46402 self.control_handle.shutdown();
46403 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46405 }
46406}
46407
46408impl fidl::endpoints::Responder for DatagramSocketGetIpv6ReceiveTrafficClassResponder {
46409 type ControlHandle = DatagramSocketControlHandle;
46410
46411 fn control_handle(&self) -> &DatagramSocketControlHandle {
46412 &self.control_handle
46413 }
46414
46415 fn drop_without_shutdown(mut self) {
46416 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46418 std::mem::forget(self);
46420 }
46421}
46422
46423impl DatagramSocketGetIpv6ReceiveTrafficClassResponder {
46424 pub fn send(
46428 self,
46429 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46430 ) -> Result<(), fidl::Error> {
46431 let _result = self.send_raw(result);
46432 if _result.is_err() {
46433 self.control_handle.shutdown();
46434 }
46435 self.drop_without_shutdown();
46436 _result
46437 }
46438
46439 pub fn send_no_shutdown_on_err(
46441 self,
46442 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46443 ) -> Result<(), fidl::Error> {
46444 let _result = self.send_raw(result);
46445 self.drop_without_shutdown();
46446 _result
46447 }
46448
46449 fn send_raw(
46450 &self,
46451 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46452 ) -> Result<(), fidl::Error> {
46453 self.control_handle.inner.send::<fidl::encoding::ResultType<
46454 BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
46455 fidl_fuchsia_posix::Errno,
46456 >>(
46457 result.map(|value| (value,)),
46458 self.tx_id,
46459 0x2e334df1da553ffa,
46460 fidl::encoding::DynamicFlags::empty(),
46461 )
46462 }
46463}
46464
46465#[must_use = "FIDL methods require a response to be sent"]
46466#[derive(Debug)]
46467pub struct DatagramSocketSetIpv6TrafficClassResponder {
46468 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46469 tx_id: u32,
46470}
46471
46472impl std::ops::Drop for DatagramSocketSetIpv6TrafficClassResponder {
46476 fn drop(&mut self) {
46477 self.control_handle.shutdown();
46478 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46480 }
46481}
46482
46483impl fidl::endpoints::Responder for DatagramSocketSetIpv6TrafficClassResponder {
46484 type ControlHandle = DatagramSocketControlHandle;
46485
46486 fn control_handle(&self) -> &DatagramSocketControlHandle {
46487 &self.control_handle
46488 }
46489
46490 fn drop_without_shutdown(mut self) {
46491 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46493 std::mem::forget(self);
46495 }
46496}
46497
46498impl DatagramSocketSetIpv6TrafficClassResponder {
46499 pub fn send(
46503 self,
46504 mut result: Result<(), fidl_fuchsia_posix::Errno>,
46505 ) -> Result<(), fidl::Error> {
46506 let _result = self.send_raw(result);
46507 if _result.is_err() {
46508 self.control_handle.shutdown();
46509 }
46510 self.drop_without_shutdown();
46511 _result
46512 }
46513
46514 pub fn send_no_shutdown_on_err(
46516 self,
46517 mut result: Result<(), fidl_fuchsia_posix::Errno>,
46518 ) -> Result<(), fidl::Error> {
46519 let _result = self.send_raw(result);
46520 self.drop_without_shutdown();
46521 _result
46522 }
46523
46524 fn send_raw(
46525 &self,
46526 mut result: Result<(), fidl_fuchsia_posix::Errno>,
46527 ) -> Result<(), fidl::Error> {
46528 self.control_handle.inner.send::<fidl::encoding::ResultType<
46529 fidl::encoding::EmptyStruct,
46530 fidl_fuchsia_posix::Errno,
46531 >>(
46532 result,
46533 self.tx_id,
46534 0x6af077800c5a0b4f,
46535 fidl::encoding::DynamicFlags::empty(),
46536 )
46537 }
46538}
46539
46540#[must_use = "FIDL methods require a response to be sent"]
46541#[derive(Debug)]
46542pub struct DatagramSocketGetIpv6TrafficClassResponder {
46543 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46544 tx_id: u32,
46545}
46546
46547impl std::ops::Drop for DatagramSocketGetIpv6TrafficClassResponder {
46551 fn drop(&mut self) {
46552 self.control_handle.shutdown();
46553 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46555 }
46556}
46557
46558impl fidl::endpoints::Responder for DatagramSocketGetIpv6TrafficClassResponder {
46559 type ControlHandle = DatagramSocketControlHandle;
46560
46561 fn control_handle(&self) -> &DatagramSocketControlHandle {
46562 &self.control_handle
46563 }
46564
46565 fn drop_without_shutdown(mut self) {
46566 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46568 std::mem::forget(self);
46570 }
46571}
46572
46573impl DatagramSocketGetIpv6TrafficClassResponder {
46574 pub fn send(
46578 self,
46579 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
46580 ) -> Result<(), fidl::Error> {
46581 let _result = self.send_raw(result);
46582 if _result.is_err() {
46583 self.control_handle.shutdown();
46584 }
46585 self.drop_without_shutdown();
46586 _result
46587 }
46588
46589 pub fn send_no_shutdown_on_err(
46591 self,
46592 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
46593 ) -> Result<(), fidl::Error> {
46594 let _result = self.send_raw(result);
46595 self.drop_without_shutdown();
46596 _result
46597 }
46598
46599 fn send_raw(
46600 &self,
46601 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
46602 ) -> Result<(), fidl::Error> {
46603 self.control_handle.inner.send::<fidl::encoding::ResultType<
46604 BaseNetworkSocketGetIpv6TrafficClassResponse,
46605 fidl_fuchsia_posix::Errno,
46606 >>(
46607 result.map(|value| (value,)),
46608 self.tx_id,
46609 0x6baf6eed8fc2f04,
46610 fidl::encoding::DynamicFlags::empty(),
46611 )
46612 }
46613}
46614
46615#[must_use = "FIDL methods require a response to be sent"]
46616#[derive(Debug)]
46617pub struct DatagramSocketSetIpv6ReceivePacketInfoResponder {
46618 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46619 tx_id: u32,
46620}
46621
46622impl std::ops::Drop for DatagramSocketSetIpv6ReceivePacketInfoResponder {
46626 fn drop(&mut self) {
46627 self.control_handle.shutdown();
46628 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46630 }
46631}
46632
46633impl fidl::endpoints::Responder for DatagramSocketSetIpv6ReceivePacketInfoResponder {
46634 type ControlHandle = DatagramSocketControlHandle;
46635
46636 fn control_handle(&self) -> &DatagramSocketControlHandle {
46637 &self.control_handle
46638 }
46639
46640 fn drop_without_shutdown(mut self) {
46641 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46643 std::mem::forget(self);
46645 }
46646}
46647
46648impl DatagramSocketSetIpv6ReceivePacketInfoResponder {
46649 pub fn send(
46653 self,
46654 mut result: Result<(), fidl_fuchsia_posix::Errno>,
46655 ) -> Result<(), fidl::Error> {
46656 let _result = self.send_raw(result);
46657 if _result.is_err() {
46658 self.control_handle.shutdown();
46659 }
46660 self.drop_without_shutdown();
46661 _result
46662 }
46663
46664 pub fn send_no_shutdown_on_err(
46666 self,
46667 mut result: Result<(), fidl_fuchsia_posix::Errno>,
46668 ) -> Result<(), fidl::Error> {
46669 let _result = self.send_raw(result);
46670 self.drop_without_shutdown();
46671 _result
46672 }
46673
46674 fn send_raw(
46675 &self,
46676 mut result: Result<(), fidl_fuchsia_posix::Errno>,
46677 ) -> Result<(), fidl::Error> {
46678 self.control_handle.inner.send::<fidl::encoding::ResultType<
46679 fidl::encoding::EmptyStruct,
46680 fidl_fuchsia_posix::Errno,
46681 >>(
46682 result,
46683 self.tx_id,
46684 0x19259775b1a92768,
46685 fidl::encoding::DynamicFlags::empty(),
46686 )
46687 }
46688}
46689
46690#[must_use = "FIDL methods require a response to be sent"]
46691#[derive(Debug)]
46692pub struct DatagramSocketGetIpv6ReceivePacketInfoResponder {
46693 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46694 tx_id: u32,
46695}
46696
46697impl std::ops::Drop for DatagramSocketGetIpv6ReceivePacketInfoResponder {
46701 fn drop(&mut self) {
46702 self.control_handle.shutdown();
46703 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46705 }
46706}
46707
46708impl fidl::endpoints::Responder for DatagramSocketGetIpv6ReceivePacketInfoResponder {
46709 type ControlHandle = DatagramSocketControlHandle;
46710
46711 fn control_handle(&self) -> &DatagramSocketControlHandle {
46712 &self.control_handle
46713 }
46714
46715 fn drop_without_shutdown(mut self) {
46716 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46718 std::mem::forget(self);
46720 }
46721}
46722
46723impl DatagramSocketGetIpv6ReceivePacketInfoResponder {
46724 pub fn send(
46728 self,
46729 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46730 ) -> Result<(), fidl::Error> {
46731 let _result = self.send_raw(result);
46732 if _result.is_err() {
46733 self.control_handle.shutdown();
46734 }
46735 self.drop_without_shutdown();
46736 _result
46737 }
46738
46739 pub fn send_no_shutdown_on_err(
46741 self,
46742 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46743 ) -> Result<(), fidl::Error> {
46744 let _result = self.send_raw(result);
46745 self.drop_without_shutdown();
46746 _result
46747 }
46748
46749 fn send_raw(
46750 &self,
46751 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46752 ) -> Result<(), fidl::Error> {
46753 self.control_handle.inner.send::<fidl::encoding::ResultType<
46754 BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
46755 fidl_fuchsia_posix::Errno,
46756 >>(
46757 result.map(|value| (value,)),
46758 self.tx_id,
46759 0x7acd4a2775baec75,
46760 fidl::encoding::DynamicFlags::empty(),
46761 )
46762 }
46763}
46764
46765#[must_use = "FIDL methods require a response to be sent"]
46766#[derive(Debug)]
46767pub struct DatagramSocketGetOriginalDestinationResponder {
46768 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46769 tx_id: u32,
46770}
46771
46772impl std::ops::Drop for DatagramSocketGetOriginalDestinationResponder {
46776 fn drop(&mut self) {
46777 self.control_handle.shutdown();
46778 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46780 }
46781}
46782
46783impl fidl::endpoints::Responder for DatagramSocketGetOriginalDestinationResponder {
46784 type ControlHandle = DatagramSocketControlHandle;
46785
46786 fn control_handle(&self) -> &DatagramSocketControlHandle {
46787 &self.control_handle
46788 }
46789
46790 fn drop_without_shutdown(mut self) {
46791 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46793 std::mem::forget(self);
46795 }
46796}
46797
46798impl DatagramSocketGetOriginalDestinationResponder {
46799 pub fn send(
46803 self,
46804 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
46805 ) -> Result<(), fidl::Error> {
46806 let _result = self.send_raw(result);
46807 if _result.is_err() {
46808 self.control_handle.shutdown();
46809 }
46810 self.drop_without_shutdown();
46811 _result
46812 }
46813
46814 pub fn send_no_shutdown_on_err(
46816 self,
46817 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
46818 ) -> Result<(), fidl::Error> {
46819 let _result = self.send_raw(result);
46820 self.drop_without_shutdown();
46821 _result
46822 }
46823
46824 fn send_raw(
46825 &self,
46826 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
46827 ) -> Result<(), fidl::Error> {
46828 self.control_handle.inner.send::<fidl::encoding::ResultType<
46829 BaseNetworkSocketGetOriginalDestinationResponse,
46830 fidl_fuchsia_posix::Errno,
46831 >>(
46832 result.map(|value| (value,)),
46833 self.tx_id,
46834 0x38bf28f0dafdbac0,
46835 fidl::encoding::DynamicFlags::empty(),
46836 )
46837 }
46838}
46839
46840#[must_use = "FIDL methods require a response to be sent"]
46841#[derive(Debug)]
46842pub struct DatagramSocketGetInfoResponder {
46843 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46844 tx_id: u32,
46845}
46846
46847impl std::ops::Drop for DatagramSocketGetInfoResponder {
46851 fn drop(&mut self) {
46852 self.control_handle.shutdown();
46853 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46855 }
46856}
46857
46858impl fidl::endpoints::Responder for DatagramSocketGetInfoResponder {
46859 type ControlHandle = DatagramSocketControlHandle;
46860
46861 fn control_handle(&self) -> &DatagramSocketControlHandle {
46862 &self.control_handle
46863 }
46864
46865 fn drop_without_shutdown(mut self) {
46866 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46868 std::mem::forget(self);
46870 }
46871}
46872
46873impl DatagramSocketGetInfoResponder {
46874 pub fn send(
46878 self,
46879 mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
46880 ) -> Result<(), fidl::Error> {
46881 let _result = self.send_raw(result);
46882 if _result.is_err() {
46883 self.control_handle.shutdown();
46884 }
46885 self.drop_without_shutdown();
46886 _result
46887 }
46888
46889 pub fn send_no_shutdown_on_err(
46891 self,
46892 mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
46893 ) -> Result<(), fidl::Error> {
46894 let _result = self.send_raw(result);
46895 self.drop_without_shutdown();
46896 _result
46897 }
46898
46899 fn send_raw(
46900 &self,
46901 mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
46902 ) -> Result<(), fidl::Error> {
46903 self.control_handle.inner.send::<fidl::encoding::ResultType<
46904 BaseDatagramSocketGetInfoResponse,
46905 fidl_fuchsia_posix::Errno,
46906 >>(
46907 result,
46908 self.tx_id,
46909 0x48aa0a1f6a32d2ed,
46910 fidl::encoding::DynamicFlags::empty(),
46911 )
46912 }
46913}
46914
46915#[must_use = "FIDL methods require a response to be sent"]
46916#[derive(Debug)]
46917pub struct DatagramSocketDescribeResponder {
46918 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46919 tx_id: u32,
46920}
46921
46922impl std::ops::Drop for DatagramSocketDescribeResponder {
46926 fn drop(&mut self) {
46927 self.control_handle.shutdown();
46928 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46930 }
46931}
46932
46933impl fidl::endpoints::Responder for DatagramSocketDescribeResponder {
46934 type ControlHandle = DatagramSocketControlHandle;
46935
46936 fn control_handle(&self) -> &DatagramSocketControlHandle {
46937 &self.control_handle
46938 }
46939
46940 fn drop_without_shutdown(mut self) {
46941 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46943 std::mem::forget(self);
46945 }
46946}
46947
46948impl DatagramSocketDescribeResponder {
46949 pub fn send(self, mut payload: DatagramSocketDescribeResponse) -> Result<(), fidl::Error> {
46953 let _result = self.send_raw(payload);
46954 if _result.is_err() {
46955 self.control_handle.shutdown();
46956 }
46957 self.drop_without_shutdown();
46958 _result
46959 }
46960
46961 pub fn send_no_shutdown_on_err(
46963 self,
46964 mut payload: DatagramSocketDescribeResponse,
46965 ) -> Result<(), fidl::Error> {
46966 let _result = self.send_raw(payload);
46967 self.drop_without_shutdown();
46968 _result
46969 }
46970
46971 fn send_raw(&self, mut payload: DatagramSocketDescribeResponse) -> Result<(), fidl::Error> {
46972 self.control_handle.inner.send::<DatagramSocketDescribeResponse>(
46973 &mut payload,
46974 self.tx_id,
46975 0xbf1e2f0a86601f3,
46976 fidl::encoding::DynamicFlags::empty(),
46977 )
46978 }
46979}
46980
46981#[must_use = "FIDL methods require a response to be sent"]
46982#[derive(Debug)]
46983pub struct DatagramSocketSendMsgPreflightResponder {
46984 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46985 tx_id: u32,
46986}
46987
46988impl std::ops::Drop for DatagramSocketSendMsgPreflightResponder {
46992 fn drop(&mut self) {
46993 self.control_handle.shutdown();
46994 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46996 }
46997}
46998
46999impl fidl::endpoints::Responder for DatagramSocketSendMsgPreflightResponder {
47000 type ControlHandle = DatagramSocketControlHandle;
47001
47002 fn control_handle(&self) -> &DatagramSocketControlHandle {
47003 &self.control_handle
47004 }
47005
47006 fn drop_without_shutdown(mut self) {
47007 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
47009 std::mem::forget(self);
47011 }
47012}
47013
47014impl DatagramSocketSendMsgPreflightResponder {
47015 pub fn send(
47019 self,
47020 mut result: Result<DatagramSocketSendMsgPreflightResponse, fidl_fuchsia_posix::Errno>,
47021 ) -> Result<(), fidl::Error> {
47022 let _result = self.send_raw(result);
47023 if _result.is_err() {
47024 self.control_handle.shutdown();
47025 }
47026 self.drop_without_shutdown();
47027 _result
47028 }
47029
47030 pub fn send_no_shutdown_on_err(
47032 self,
47033 mut result: Result<DatagramSocketSendMsgPreflightResponse, fidl_fuchsia_posix::Errno>,
47034 ) -> Result<(), fidl::Error> {
47035 let _result = self.send_raw(result);
47036 self.drop_without_shutdown();
47037 _result
47038 }
47039
47040 fn send_raw(
47041 &self,
47042 mut result: Result<DatagramSocketSendMsgPreflightResponse, fidl_fuchsia_posix::Errno>,
47043 ) -> Result<(), fidl::Error> {
47044 self.control_handle.inner.send::<fidl::encoding::ResultType<
47045 DatagramSocketSendMsgPreflightResponse,
47046 fidl_fuchsia_posix::Errno,
47047 >>(
47048 result.as_mut().map_err(|e| *e),
47049 self.tx_id,
47050 0x5362e668e777248a,
47051 fidl::encoding::DynamicFlags::empty(),
47052 )
47053 }
47054}
47055
47056#[must_use = "FIDL methods require a response to be sent"]
47057#[derive(Debug)]
47058pub struct DatagramSocketRecvMsgPostflightResponder {
47059 control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
47060 tx_id: u32,
47061}
47062
47063impl std::ops::Drop for DatagramSocketRecvMsgPostflightResponder {
47067 fn drop(&mut self) {
47068 self.control_handle.shutdown();
47069 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
47071 }
47072}
47073
47074impl fidl::endpoints::Responder for DatagramSocketRecvMsgPostflightResponder {
47075 type ControlHandle = DatagramSocketControlHandle;
47076
47077 fn control_handle(&self) -> &DatagramSocketControlHandle {
47078 &self.control_handle
47079 }
47080
47081 fn drop_without_shutdown(mut self) {
47082 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
47084 std::mem::forget(self);
47086 }
47087}
47088
47089impl DatagramSocketRecvMsgPostflightResponder {
47090 pub fn send(
47094 self,
47095 mut result: Result<DatagramSocketRecvMsgPostflightResponse, fidl_fuchsia_posix::Errno>,
47096 ) -> Result<(), fidl::Error> {
47097 let _result = self.send_raw(result);
47098 if _result.is_err() {
47099 self.control_handle.shutdown();
47100 }
47101 self.drop_without_shutdown();
47102 _result
47103 }
47104
47105 pub fn send_no_shutdown_on_err(
47107 self,
47108 mut result: Result<DatagramSocketRecvMsgPostflightResponse, fidl_fuchsia_posix::Errno>,
47109 ) -> Result<(), fidl::Error> {
47110 let _result = self.send_raw(result);
47111 self.drop_without_shutdown();
47112 _result
47113 }
47114
47115 fn send_raw(
47116 &self,
47117 mut result: Result<DatagramSocketRecvMsgPostflightResponse, fidl_fuchsia_posix::Errno>,
47118 ) -> Result<(), fidl::Error> {
47119 self.control_handle.inner.send::<fidl::encoding::ResultType<
47120 DatagramSocketRecvMsgPostflightResponse,
47121 fidl_fuchsia_posix::Errno,
47122 >>(
47123 result.as_mut().map_err(|e| *e),
47124 self.tx_id,
47125 0x1a7cdeca5f3eb8e2,
47126 fidl::encoding::DynamicFlags::empty(),
47127 )
47128 }
47129}
47130
47131#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
47132pub struct ProviderMarker;
47133
47134impl fidl::endpoints::ProtocolMarker for ProviderMarker {
47135 type Proxy = ProviderProxy;
47136 type RequestStream = ProviderRequestStream;
47137 #[cfg(target_os = "fuchsia")]
47138 type SynchronousProxy = ProviderSynchronousProxy;
47139
47140 const DEBUG_NAME: &'static str = "fuchsia.posix.socket.Provider";
47141}
47142impl fidl::endpoints::DiscoverableProtocolMarker for ProviderMarker {}
47143pub type ProviderStreamSocketWithOptionsResult =
47144 Result<fidl::endpoints::ClientEnd<StreamSocketMarker>, fidl_fuchsia_posix::Errno>;
47145pub type ProviderStreamSocketResult =
47146 Result<fidl::endpoints::ClientEnd<StreamSocketMarker>, fidl_fuchsia_posix::Errno>;
47147pub type ProviderDatagramSocketDeprecatedResult =
47148 Result<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>, fidl_fuchsia_posix::Errno>;
47149pub type ProviderDatagramSocketResult =
47150 Result<ProviderDatagramSocketResponse, fidl_fuchsia_posix::Errno>;
47151pub type ProviderDatagramSocketWithOptionsResult =
47152 Result<ProviderDatagramSocketWithOptionsResponse, fidl_fuchsia_posix::Errno>;
47153pub type ProviderInterfaceIndexToNameResult = Result<String, i32>;
47154pub type ProviderInterfaceNameToIndexResult = Result<u64, i32>;
47155pub type ProviderInterfaceNameToFlagsResult = Result<InterfaceFlags, i32>;
47156
47157pub trait ProviderProxyInterface: Send + Sync {
47158 type StreamSocketWithOptionsResponseFut: std::future::Future<Output = Result<ProviderStreamSocketWithOptionsResult, fidl::Error>>
47159 + Send;
47160 fn r#stream_socket_with_options(
47161 &self,
47162 domain: Domain,
47163 proto: StreamSocketProtocol,
47164 opts: &SocketCreationOptions,
47165 ) -> Self::StreamSocketWithOptionsResponseFut;
47166 type StreamSocketResponseFut: std::future::Future<Output = Result<ProviderStreamSocketResult, fidl::Error>>
47167 + Send;
47168 fn r#stream_socket(
47169 &self,
47170 domain: Domain,
47171 proto: StreamSocketProtocol,
47172 ) -> Self::StreamSocketResponseFut;
47173 type DatagramSocketDeprecatedResponseFut: std::future::Future<Output = Result<ProviderDatagramSocketDeprecatedResult, fidl::Error>>
47174 + Send;
47175 fn r#datagram_socket_deprecated(
47176 &self,
47177 domain: Domain,
47178 proto: DatagramSocketProtocol,
47179 ) -> Self::DatagramSocketDeprecatedResponseFut;
47180 type DatagramSocketResponseFut: std::future::Future<Output = Result<ProviderDatagramSocketResult, fidl::Error>>
47181 + Send;
47182 fn r#datagram_socket(
47183 &self,
47184 domain: Domain,
47185 proto: DatagramSocketProtocol,
47186 ) -> Self::DatagramSocketResponseFut;
47187 type DatagramSocketWithOptionsResponseFut: std::future::Future<Output = Result<ProviderDatagramSocketWithOptionsResult, fidl::Error>>
47188 + Send;
47189 fn r#datagram_socket_with_options(
47190 &self,
47191 domain: Domain,
47192 proto: DatagramSocketProtocol,
47193 opts: &SocketCreationOptions,
47194 ) -> Self::DatagramSocketWithOptionsResponseFut;
47195 type InterfaceIndexToNameResponseFut: std::future::Future<Output = Result<ProviderInterfaceIndexToNameResult, fidl::Error>>
47196 + Send;
47197 fn r#interface_index_to_name(&self, index: u64) -> Self::InterfaceIndexToNameResponseFut;
47198 type InterfaceNameToIndexResponseFut: std::future::Future<Output = Result<ProviderInterfaceNameToIndexResult, fidl::Error>>
47199 + Send;
47200 fn r#interface_name_to_index(&self, name: &str) -> Self::InterfaceNameToIndexResponseFut;
47201 type InterfaceNameToFlagsResponseFut: std::future::Future<Output = Result<ProviderInterfaceNameToFlagsResult, fidl::Error>>
47202 + Send;
47203 fn r#interface_name_to_flags(&self, name: &str) -> Self::InterfaceNameToFlagsResponseFut;
47204 type GetInterfaceAddressesResponseFut: std::future::Future<Output = Result<Vec<InterfaceAddresses>, fidl::Error>>
47205 + Send;
47206 fn r#get_interface_addresses(&self) -> Self::GetInterfaceAddressesResponseFut;
47207}
47208#[derive(Debug)]
47209#[cfg(target_os = "fuchsia")]
47210pub struct ProviderSynchronousProxy {
47211 client: fidl::client::sync::Client,
47212}
47213
47214#[cfg(target_os = "fuchsia")]
47215impl fidl::endpoints::SynchronousProxy for ProviderSynchronousProxy {
47216 type Proxy = ProviderProxy;
47217 type Protocol = ProviderMarker;
47218
47219 fn from_channel(inner: fidl::Channel) -> Self {
47220 Self::new(inner)
47221 }
47222
47223 fn into_channel(self) -> fidl::Channel {
47224 self.client.into_channel()
47225 }
47226
47227 fn as_channel(&self) -> &fidl::Channel {
47228 self.client.as_channel()
47229 }
47230}
47231
47232#[cfg(target_os = "fuchsia")]
47233impl ProviderSynchronousProxy {
47234 pub fn new(channel: fidl::Channel) -> Self {
47235 let protocol_name = <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
47236 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
47237 }
47238
47239 pub fn into_channel(self) -> fidl::Channel {
47240 self.client.into_channel()
47241 }
47242
47243 pub fn wait_for_event(
47246 &self,
47247 deadline: zx::MonotonicInstant,
47248 ) -> Result<ProviderEvent, fidl::Error> {
47249 ProviderEvent::decode(self.client.wait_for_event(deadline)?)
47250 }
47251
47252 pub fn r#stream_socket_with_options(
47255 &self,
47256 mut domain: Domain,
47257 mut proto: StreamSocketProtocol,
47258 mut opts: &SocketCreationOptions,
47259 ___deadline: zx::MonotonicInstant,
47260 ) -> Result<ProviderStreamSocketWithOptionsResult, fidl::Error> {
47261 let _response = self
47262 .client
47263 .send_query::<ProviderStreamSocketWithOptionsRequest, fidl::encoding::ResultType<
47264 ProviderStreamSocketWithOptionsResponse,
47265 fidl_fuchsia_posix::Errno,
47266 >>(
47267 (domain, proto, opts),
47268 0x3969bf7eb78386e0,
47269 fidl::encoding::DynamicFlags::empty(),
47270 ___deadline,
47271 )?;
47272 Ok(_response.map(|x| x.s))
47273 }
47274
47275 pub fn r#stream_socket(
47277 &self,
47278 mut domain: Domain,
47279 mut proto: StreamSocketProtocol,
47280 ___deadline: zx::MonotonicInstant,
47281 ) -> Result<ProviderStreamSocketResult, fidl::Error> {
47282 let _response =
47283 self.client.send_query::<ProviderStreamSocketRequest, fidl::encoding::ResultType<
47284 ProviderStreamSocketResponse,
47285 fidl_fuchsia_posix::Errno,
47286 >>(
47287 (domain, proto),
47288 0x27c3581da2155545,
47289 fidl::encoding::DynamicFlags::empty(),
47290 ___deadline,
47291 )?;
47292 Ok(_response.map(|x| x.s))
47293 }
47294
47295 pub fn r#datagram_socket_deprecated(
47298 &self,
47299 mut domain: Domain,
47300 mut proto: DatagramSocketProtocol,
47301 ___deadline: zx::MonotonicInstant,
47302 ) -> Result<ProviderDatagramSocketDeprecatedResult, fidl::Error> {
47303 let _response = self
47304 .client
47305 .send_query::<ProviderDatagramSocketDeprecatedRequest, fidl::encoding::ResultType<
47306 ProviderDatagramSocketDeprecatedResponse,
47307 fidl_fuchsia_posix::Errno,
47308 >>(
47309 (domain, proto),
47310 0x38876c87cf031cb1,
47311 fidl::encoding::DynamicFlags::empty(),
47312 ___deadline,
47313 )?;
47314 Ok(_response.map(|x| x.s))
47315 }
47316
47317 pub fn r#datagram_socket(
47319 &self,
47320 mut domain: Domain,
47321 mut proto: DatagramSocketProtocol,
47322 ___deadline: zx::MonotonicInstant,
47323 ) -> Result<ProviderDatagramSocketResult, fidl::Error> {
47324 let _response =
47325 self.client.send_query::<ProviderDatagramSocketRequest, fidl::encoding::ResultType<
47326 ProviderDatagramSocketResponse,
47327 fidl_fuchsia_posix::Errno,
47328 >>(
47329 (domain, proto),
47330 0x4021b4fa1b6452f2,
47331 fidl::encoding::DynamicFlags::empty(),
47332 ___deadline,
47333 )?;
47334 Ok(_response.map(|x| x))
47335 }
47336
47337 pub fn r#datagram_socket_with_options(
47340 &self,
47341 mut domain: Domain,
47342 mut proto: DatagramSocketProtocol,
47343 mut opts: &SocketCreationOptions,
47344 ___deadline: zx::MonotonicInstant,
47345 ) -> Result<ProviderDatagramSocketWithOptionsResult, fidl::Error> {
47346 let _response = self
47347 .client
47348 .send_query::<ProviderDatagramSocketWithOptionsRequest, fidl::encoding::ResultType<
47349 ProviderDatagramSocketWithOptionsResponse,
47350 fidl_fuchsia_posix::Errno,
47351 >>(
47352 (domain, proto, opts),
47353 0x4cd0cffbffa39eb1,
47354 fidl::encoding::DynamicFlags::empty(),
47355 ___deadline,
47356 )?;
47357 Ok(_response.map(|x| x))
47358 }
47359
47360 pub fn r#interface_index_to_name(
47363 &self,
47364 mut index: u64,
47365 ___deadline: zx::MonotonicInstant,
47366 ) -> Result<ProviderInterfaceIndexToNameResult, fidl::Error> {
47367 let _response = self.client.send_query::<
47368 ProviderInterfaceIndexToNameRequest,
47369 fidl::encoding::ResultType<ProviderInterfaceIndexToNameResponse, i32>,
47370 >(
47371 (index,),
47372 0x4d59a64fce98272f,
47373 fidl::encoding::DynamicFlags::empty(),
47374 ___deadline,
47375 )?;
47376 Ok(_response.map(|x| x.name))
47377 }
47378
47379 pub fn r#interface_name_to_index(
47382 &self,
47383 mut name: &str,
47384 ___deadline: zx::MonotonicInstant,
47385 ) -> Result<ProviderInterfaceNameToIndexResult, fidl::Error> {
47386 let _response = self.client.send_query::<
47387 ProviderInterfaceNameToIndexRequest,
47388 fidl::encoding::ResultType<ProviderInterfaceNameToIndexResponse, i32>,
47389 >(
47390 (name,),
47391 0x690cd8d2f2d650f8,
47392 fidl::encoding::DynamicFlags::empty(),
47393 ___deadline,
47394 )?;
47395 Ok(_response.map(|x| x.index))
47396 }
47397
47398 pub fn r#interface_name_to_flags(
47401 &self,
47402 mut name: &str,
47403 ___deadline: zx::MonotonicInstant,
47404 ) -> Result<ProviderInterfaceNameToFlagsResult, fidl::Error> {
47405 let _response = self.client.send_query::<
47406 ProviderInterfaceNameToFlagsRequest,
47407 fidl::encoding::ResultType<ProviderInterfaceNameToFlagsResponse, i32>,
47408 >(
47409 (name,),
47410 0x25d0efcdb6671a0b,
47411 fidl::encoding::DynamicFlags::empty(),
47412 ___deadline,
47413 )?;
47414 Ok(_response.map(|x| x.flags))
47415 }
47416
47417 pub fn r#get_interface_addresses(
47420 &self,
47421 ___deadline: zx::MonotonicInstant,
47422 ) -> Result<Vec<InterfaceAddresses>, fidl::Error> {
47423 let _response = self
47424 .client
47425 .send_query::<fidl::encoding::EmptyPayload, ProviderGetInterfaceAddressesResponse>(
47426 (),
47427 0x2e7b9aaf327c870,
47428 fidl::encoding::DynamicFlags::empty(),
47429 ___deadline,
47430 )?;
47431 Ok(_response.interfaces)
47432 }
47433}
47434
47435#[cfg(target_os = "fuchsia")]
47436impl From<ProviderSynchronousProxy> for zx::Handle {
47437 fn from(value: ProviderSynchronousProxy) -> Self {
47438 value.into_channel().into()
47439 }
47440}
47441
47442#[cfg(target_os = "fuchsia")]
47443impl From<fidl::Channel> for ProviderSynchronousProxy {
47444 fn from(value: fidl::Channel) -> Self {
47445 Self::new(value)
47446 }
47447}
47448
47449#[derive(Debug, Clone)]
47450pub struct ProviderProxy {
47451 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
47452}
47453
47454impl fidl::endpoints::Proxy for ProviderProxy {
47455 type Protocol = ProviderMarker;
47456
47457 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
47458 Self::new(inner)
47459 }
47460
47461 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
47462 self.client.into_channel().map_err(|client| Self { client })
47463 }
47464
47465 fn as_channel(&self) -> &::fidl::AsyncChannel {
47466 self.client.as_channel()
47467 }
47468}
47469
47470impl ProviderProxy {
47471 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
47473 let protocol_name = <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
47474 Self { client: fidl::client::Client::new(channel, protocol_name) }
47475 }
47476
47477 pub fn take_event_stream(&self) -> ProviderEventStream {
47483 ProviderEventStream { event_receiver: self.client.take_event_receiver() }
47484 }
47485
47486 pub fn r#stream_socket_with_options(
47489 &self,
47490 mut domain: Domain,
47491 mut proto: StreamSocketProtocol,
47492 mut opts: &SocketCreationOptions,
47493 ) -> fidl::client::QueryResponseFut<
47494 ProviderStreamSocketWithOptionsResult,
47495 fidl::encoding::DefaultFuchsiaResourceDialect,
47496 > {
47497 ProviderProxyInterface::r#stream_socket_with_options(self, domain, proto, opts)
47498 }
47499
47500 pub fn r#stream_socket(
47502 &self,
47503 mut domain: Domain,
47504 mut proto: StreamSocketProtocol,
47505 ) -> fidl::client::QueryResponseFut<
47506 ProviderStreamSocketResult,
47507 fidl::encoding::DefaultFuchsiaResourceDialect,
47508 > {
47509 ProviderProxyInterface::r#stream_socket(self, domain, proto)
47510 }
47511
47512 pub fn r#datagram_socket_deprecated(
47515 &self,
47516 mut domain: Domain,
47517 mut proto: DatagramSocketProtocol,
47518 ) -> fidl::client::QueryResponseFut<
47519 ProviderDatagramSocketDeprecatedResult,
47520 fidl::encoding::DefaultFuchsiaResourceDialect,
47521 > {
47522 ProviderProxyInterface::r#datagram_socket_deprecated(self, domain, proto)
47523 }
47524
47525 pub fn r#datagram_socket(
47527 &self,
47528 mut domain: Domain,
47529 mut proto: DatagramSocketProtocol,
47530 ) -> fidl::client::QueryResponseFut<
47531 ProviderDatagramSocketResult,
47532 fidl::encoding::DefaultFuchsiaResourceDialect,
47533 > {
47534 ProviderProxyInterface::r#datagram_socket(self, domain, proto)
47535 }
47536
47537 pub fn r#datagram_socket_with_options(
47540 &self,
47541 mut domain: Domain,
47542 mut proto: DatagramSocketProtocol,
47543 mut opts: &SocketCreationOptions,
47544 ) -> fidl::client::QueryResponseFut<
47545 ProviderDatagramSocketWithOptionsResult,
47546 fidl::encoding::DefaultFuchsiaResourceDialect,
47547 > {
47548 ProviderProxyInterface::r#datagram_socket_with_options(self, domain, proto, opts)
47549 }
47550
47551 pub fn r#interface_index_to_name(
47554 &self,
47555 mut index: u64,
47556 ) -> fidl::client::QueryResponseFut<
47557 ProviderInterfaceIndexToNameResult,
47558 fidl::encoding::DefaultFuchsiaResourceDialect,
47559 > {
47560 ProviderProxyInterface::r#interface_index_to_name(self, index)
47561 }
47562
47563 pub fn r#interface_name_to_index(
47566 &self,
47567 mut name: &str,
47568 ) -> fidl::client::QueryResponseFut<
47569 ProviderInterfaceNameToIndexResult,
47570 fidl::encoding::DefaultFuchsiaResourceDialect,
47571 > {
47572 ProviderProxyInterface::r#interface_name_to_index(self, name)
47573 }
47574
47575 pub fn r#interface_name_to_flags(
47578 &self,
47579 mut name: &str,
47580 ) -> fidl::client::QueryResponseFut<
47581 ProviderInterfaceNameToFlagsResult,
47582 fidl::encoding::DefaultFuchsiaResourceDialect,
47583 > {
47584 ProviderProxyInterface::r#interface_name_to_flags(self, name)
47585 }
47586
47587 pub fn r#get_interface_addresses(
47590 &self,
47591 ) -> fidl::client::QueryResponseFut<
47592 Vec<InterfaceAddresses>,
47593 fidl::encoding::DefaultFuchsiaResourceDialect,
47594 > {
47595 ProviderProxyInterface::r#get_interface_addresses(self)
47596 }
47597}
47598
47599impl ProviderProxyInterface for ProviderProxy {
47600 type StreamSocketWithOptionsResponseFut = fidl::client::QueryResponseFut<
47601 ProviderStreamSocketWithOptionsResult,
47602 fidl::encoding::DefaultFuchsiaResourceDialect,
47603 >;
47604 fn r#stream_socket_with_options(
47605 &self,
47606 mut domain: Domain,
47607 mut proto: StreamSocketProtocol,
47608 mut opts: &SocketCreationOptions,
47609 ) -> Self::StreamSocketWithOptionsResponseFut {
47610 fn _decode(
47611 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47612 ) -> Result<ProviderStreamSocketWithOptionsResult, fidl::Error> {
47613 let _response = fidl::client::decode_transaction_body::<
47614 fidl::encoding::ResultType<
47615 ProviderStreamSocketWithOptionsResponse,
47616 fidl_fuchsia_posix::Errno,
47617 >,
47618 fidl::encoding::DefaultFuchsiaResourceDialect,
47619 0x3969bf7eb78386e0,
47620 >(_buf?)?;
47621 Ok(_response.map(|x| x.s))
47622 }
47623 self.client.send_query_and_decode::<
47624 ProviderStreamSocketWithOptionsRequest,
47625 ProviderStreamSocketWithOptionsResult,
47626 >(
47627 (domain, proto, opts,),
47628 0x3969bf7eb78386e0,
47629 fidl::encoding::DynamicFlags::empty(),
47630 _decode,
47631 )
47632 }
47633
47634 type StreamSocketResponseFut = fidl::client::QueryResponseFut<
47635 ProviderStreamSocketResult,
47636 fidl::encoding::DefaultFuchsiaResourceDialect,
47637 >;
47638 fn r#stream_socket(
47639 &self,
47640 mut domain: Domain,
47641 mut proto: StreamSocketProtocol,
47642 ) -> Self::StreamSocketResponseFut {
47643 fn _decode(
47644 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47645 ) -> Result<ProviderStreamSocketResult, fidl::Error> {
47646 let _response = fidl::client::decode_transaction_body::<
47647 fidl::encoding::ResultType<ProviderStreamSocketResponse, fidl_fuchsia_posix::Errno>,
47648 fidl::encoding::DefaultFuchsiaResourceDialect,
47649 0x27c3581da2155545,
47650 >(_buf?)?;
47651 Ok(_response.map(|x| x.s))
47652 }
47653 self.client
47654 .send_query_and_decode::<ProviderStreamSocketRequest, ProviderStreamSocketResult>(
47655 (domain, proto),
47656 0x27c3581da2155545,
47657 fidl::encoding::DynamicFlags::empty(),
47658 _decode,
47659 )
47660 }
47661
47662 type DatagramSocketDeprecatedResponseFut = fidl::client::QueryResponseFut<
47663 ProviderDatagramSocketDeprecatedResult,
47664 fidl::encoding::DefaultFuchsiaResourceDialect,
47665 >;
47666 fn r#datagram_socket_deprecated(
47667 &self,
47668 mut domain: Domain,
47669 mut proto: DatagramSocketProtocol,
47670 ) -> Self::DatagramSocketDeprecatedResponseFut {
47671 fn _decode(
47672 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47673 ) -> Result<ProviderDatagramSocketDeprecatedResult, fidl::Error> {
47674 let _response = fidl::client::decode_transaction_body::<
47675 fidl::encoding::ResultType<
47676 ProviderDatagramSocketDeprecatedResponse,
47677 fidl_fuchsia_posix::Errno,
47678 >,
47679 fidl::encoding::DefaultFuchsiaResourceDialect,
47680 0x38876c87cf031cb1,
47681 >(_buf?)?;
47682 Ok(_response.map(|x| x.s))
47683 }
47684 self.client.send_query_and_decode::<
47685 ProviderDatagramSocketDeprecatedRequest,
47686 ProviderDatagramSocketDeprecatedResult,
47687 >(
47688 (domain, proto,),
47689 0x38876c87cf031cb1,
47690 fidl::encoding::DynamicFlags::empty(),
47691 _decode,
47692 )
47693 }
47694
47695 type DatagramSocketResponseFut = fidl::client::QueryResponseFut<
47696 ProviderDatagramSocketResult,
47697 fidl::encoding::DefaultFuchsiaResourceDialect,
47698 >;
47699 fn r#datagram_socket(
47700 &self,
47701 mut domain: Domain,
47702 mut proto: DatagramSocketProtocol,
47703 ) -> Self::DatagramSocketResponseFut {
47704 fn _decode(
47705 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47706 ) -> Result<ProviderDatagramSocketResult, fidl::Error> {
47707 let _response = fidl::client::decode_transaction_body::<
47708 fidl::encoding::ResultType<
47709 ProviderDatagramSocketResponse,
47710 fidl_fuchsia_posix::Errno,
47711 >,
47712 fidl::encoding::DefaultFuchsiaResourceDialect,
47713 0x4021b4fa1b6452f2,
47714 >(_buf?)?;
47715 Ok(_response.map(|x| x))
47716 }
47717 self.client
47718 .send_query_and_decode::<ProviderDatagramSocketRequest, ProviderDatagramSocketResult>(
47719 (domain, proto),
47720 0x4021b4fa1b6452f2,
47721 fidl::encoding::DynamicFlags::empty(),
47722 _decode,
47723 )
47724 }
47725
47726 type DatagramSocketWithOptionsResponseFut = fidl::client::QueryResponseFut<
47727 ProviderDatagramSocketWithOptionsResult,
47728 fidl::encoding::DefaultFuchsiaResourceDialect,
47729 >;
47730 fn r#datagram_socket_with_options(
47731 &self,
47732 mut domain: Domain,
47733 mut proto: DatagramSocketProtocol,
47734 mut opts: &SocketCreationOptions,
47735 ) -> Self::DatagramSocketWithOptionsResponseFut {
47736 fn _decode(
47737 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47738 ) -> Result<ProviderDatagramSocketWithOptionsResult, fidl::Error> {
47739 let _response = fidl::client::decode_transaction_body::<
47740 fidl::encoding::ResultType<
47741 ProviderDatagramSocketWithOptionsResponse,
47742 fidl_fuchsia_posix::Errno,
47743 >,
47744 fidl::encoding::DefaultFuchsiaResourceDialect,
47745 0x4cd0cffbffa39eb1,
47746 >(_buf?)?;
47747 Ok(_response.map(|x| x))
47748 }
47749 self.client.send_query_and_decode::<
47750 ProviderDatagramSocketWithOptionsRequest,
47751 ProviderDatagramSocketWithOptionsResult,
47752 >(
47753 (domain, proto, opts,),
47754 0x4cd0cffbffa39eb1,
47755 fidl::encoding::DynamicFlags::empty(),
47756 _decode,
47757 )
47758 }
47759
47760 type InterfaceIndexToNameResponseFut = fidl::client::QueryResponseFut<
47761 ProviderInterfaceIndexToNameResult,
47762 fidl::encoding::DefaultFuchsiaResourceDialect,
47763 >;
47764 fn r#interface_index_to_name(&self, mut index: u64) -> Self::InterfaceIndexToNameResponseFut {
47765 fn _decode(
47766 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47767 ) -> Result<ProviderInterfaceIndexToNameResult, fidl::Error> {
47768 let _response = fidl::client::decode_transaction_body::<
47769 fidl::encoding::ResultType<ProviderInterfaceIndexToNameResponse, i32>,
47770 fidl::encoding::DefaultFuchsiaResourceDialect,
47771 0x4d59a64fce98272f,
47772 >(_buf?)?;
47773 Ok(_response.map(|x| x.name))
47774 }
47775 self.client.send_query_and_decode::<
47776 ProviderInterfaceIndexToNameRequest,
47777 ProviderInterfaceIndexToNameResult,
47778 >(
47779 (index,),
47780 0x4d59a64fce98272f,
47781 fidl::encoding::DynamicFlags::empty(),
47782 _decode,
47783 )
47784 }
47785
47786 type InterfaceNameToIndexResponseFut = fidl::client::QueryResponseFut<
47787 ProviderInterfaceNameToIndexResult,
47788 fidl::encoding::DefaultFuchsiaResourceDialect,
47789 >;
47790 fn r#interface_name_to_index(&self, mut name: &str) -> Self::InterfaceNameToIndexResponseFut {
47791 fn _decode(
47792 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47793 ) -> Result<ProviderInterfaceNameToIndexResult, fidl::Error> {
47794 let _response = fidl::client::decode_transaction_body::<
47795 fidl::encoding::ResultType<ProviderInterfaceNameToIndexResponse, i32>,
47796 fidl::encoding::DefaultFuchsiaResourceDialect,
47797 0x690cd8d2f2d650f8,
47798 >(_buf?)?;
47799 Ok(_response.map(|x| x.index))
47800 }
47801 self.client.send_query_and_decode::<
47802 ProviderInterfaceNameToIndexRequest,
47803 ProviderInterfaceNameToIndexResult,
47804 >(
47805 (name,),
47806 0x690cd8d2f2d650f8,
47807 fidl::encoding::DynamicFlags::empty(),
47808 _decode,
47809 )
47810 }
47811
47812 type InterfaceNameToFlagsResponseFut = fidl::client::QueryResponseFut<
47813 ProviderInterfaceNameToFlagsResult,
47814 fidl::encoding::DefaultFuchsiaResourceDialect,
47815 >;
47816 fn r#interface_name_to_flags(&self, mut name: &str) -> Self::InterfaceNameToFlagsResponseFut {
47817 fn _decode(
47818 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47819 ) -> Result<ProviderInterfaceNameToFlagsResult, fidl::Error> {
47820 let _response = fidl::client::decode_transaction_body::<
47821 fidl::encoding::ResultType<ProviderInterfaceNameToFlagsResponse, i32>,
47822 fidl::encoding::DefaultFuchsiaResourceDialect,
47823 0x25d0efcdb6671a0b,
47824 >(_buf?)?;
47825 Ok(_response.map(|x| x.flags))
47826 }
47827 self.client.send_query_and_decode::<
47828 ProviderInterfaceNameToFlagsRequest,
47829 ProviderInterfaceNameToFlagsResult,
47830 >(
47831 (name,),
47832 0x25d0efcdb6671a0b,
47833 fidl::encoding::DynamicFlags::empty(),
47834 _decode,
47835 )
47836 }
47837
47838 type GetInterfaceAddressesResponseFut = fidl::client::QueryResponseFut<
47839 Vec<InterfaceAddresses>,
47840 fidl::encoding::DefaultFuchsiaResourceDialect,
47841 >;
47842 fn r#get_interface_addresses(&self) -> Self::GetInterfaceAddressesResponseFut {
47843 fn _decode(
47844 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47845 ) -> Result<Vec<InterfaceAddresses>, fidl::Error> {
47846 let _response = fidl::client::decode_transaction_body::<
47847 ProviderGetInterfaceAddressesResponse,
47848 fidl::encoding::DefaultFuchsiaResourceDialect,
47849 0x2e7b9aaf327c870,
47850 >(_buf?)?;
47851 Ok(_response.interfaces)
47852 }
47853 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<InterfaceAddresses>>(
47854 (),
47855 0x2e7b9aaf327c870,
47856 fidl::encoding::DynamicFlags::empty(),
47857 _decode,
47858 )
47859 }
47860}
47861
47862pub struct ProviderEventStream {
47863 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
47864}
47865
47866impl std::marker::Unpin for ProviderEventStream {}
47867
47868impl futures::stream::FusedStream for ProviderEventStream {
47869 fn is_terminated(&self) -> bool {
47870 self.event_receiver.is_terminated()
47871 }
47872}
47873
47874impl futures::Stream for ProviderEventStream {
47875 type Item = Result<ProviderEvent, fidl::Error>;
47876
47877 fn poll_next(
47878 mut self: std::pin::Pin<&mut Self>,
47879 cx: &mut std::task::Context<'_>,
47880 ) -> std::task::Poll<Option<Self::Item>> {
47881 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
47882 &mut self.event_receiver,
47883 cx
47884 )?) {
47885 Some(buf) => std::task::Poll::Ready(Some(ProviderEvent::decode(buf))),
47886 None => std::task::Poll::Ready(None),
47887 }
47888 }
47889}
47890
47891#[derive(Debug)]
47892pub enum ProviderEvent {}
47893
47894impl ProviderEvent {
47895 fn decode(
47897 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
47898 ) -> Result<ProviderEvent, fidl::Error> {
47899 let (bytes, _handles) = buf.split_mut();
47900 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
47901 debug_assert_eq!(tx_header.tx_id, 0);
47902 match tx_header.ordinal {
47903 _ => Err(fidl::Error::UnknownOrdinal {
47904 ordinal: tx_header.ordinal,
47905 protocol_name: <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
47906 }),
47907 }
47908 }
47909}
47910
47911pub struct ProviderRequestStream {
47913 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
47914 is_terminated: bool,
47915}
47916
47917impl std::marker::Unpin for ProviderRequestStream {}
47918
47919impl futures::stream::FusedStream for ProviderRequestStream {
47920 fn is_terminated(&self) -> bool {
47921 self.is_terminated
47922 }
47923}
47924
47925impl fidl::endpoints::RequestStream for ProviderRequestStream {
47926 type Protocol = ProviderMarker;
47927 type ControlHandle = ProviderControlHandle;
47928
47929 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
47930 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
47931 }
47932
47933 fn control_handle(&self) -> Self::ControlHandle {
47934 ProviderControlHandle { inner: self.inner.clone() }
47935 }
47936
47937 fn into_inner(
47938 self,
47939 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
47940 {
47941 (self.inner, self.is_terminated)
47942 }
47943
47944 fn from_inner(
47945 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
47946 is_terminated: bool,
47947 ) -> Self {
47948 Self { inner, is_terminated }
47949 }
47950}
47951
47952impl futures::Stream for ProviderRequestStream {
47953 type Item = Result<ProviderRequest, fidl::Error>;
47954
47955 fn poll_next(
47956 mut self: std::pin::Pin<&mut Self>,
47957 cx: &mut std::task::Context<'_>,
47958 ) -> std::task::Poll<Option<Self::Item>> {
47959 let this = &mut *self;
47960 if this.inner.check_shutdown(cx) {
47961 this.is_terminated = true;
47962 return std::task::Poll::Ready(None);
47963 }
47964 if this.is_terminated {
47965 panic!("polled ProviderRequestStream after completion");
47966 }
47967 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
47968 |bytes, handles| {
47969 match this.inner.channel().read_etc(cx, bytes, handles) {
47970 std::task::Poll::Ready(Ok(())) => {}
47971 std::task::Poll::Pending => return std::task::Poll::Pending,
47972 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
47973 this.is_terminated = true;
47974 return std::task::Poll::Ready(None);
47975 }
47976 std::task::Poll::Ready(Err(e)) => {
47977 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
47978 e.into(),
47979 ))))
47980 }
47981 }
47982
47983 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
47985
47986 std::task::Poll::Ready(Some(match header.ordinal {
47987 0x3969bf7eb78386e0 => {
47988 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
47989 let mut req = fidl::new_empty!(
47990 ProviderStreamSocketWithOptionsRequest,
47991 fidl::encoding::DefaultFuchsiaResourceDialect
47992 );
47993 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderStreamSocketWithOptionsRequest>(&header, _body_bytes, handles, &mut req)?;
47994 let control_handle = ProviderControlHandle { inner: this.inner.clone() };
47995 Ok(ProviderRequest::StreamSocketWithOptions {
47996 domain: req.domain,
47997 proto: req.proto,
47998 opts: req.opts,
47999
48000 responder: ProviderStreamSocketWithOptionsResponder {
48001 control_handle: std::mem::ManuallyDrop::new(control_handle),
48002 tx_id: header.tx_id,
48003 },
48004 })
48005 }
48006 0x27c3581da2155545 => {
48007 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
48008 let mut req = fidl::new_empty!(
48009 ProviderStreamSocketRequest,
48010 fidl::encoding::DefaultFuchsiaResourceDialect
48011 );
48012 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderStreamSocketRequest>(&header, _body_bytes, handles, &mut req)?;
48013 let control_handle = ProviderControlHandle { inner: this.inner.clone() };
48014 Ok(ProviderRequest::StreamSocket {
48015 domain: req.domain,
48016 proto: req.proto,
48017
48018 responder: ProviderStreamSocketResponder {
48019 control_handle: std::mem::ManuallyDrop::new(control_handle),
48020 tx_id: header.tx_id,
48021 },
48022 })
48023 }
48024 0x38876c87cf031cb1 => {
48025 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
48026 let mut req = fidl::new_empty!(
48027 ProviderDatagramSocketDeprecatedRequest,
48028 fidl::encoding::DefaultFuchsiaResourceDialect
48029 );
48030 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderDatagramSocketDeprecatedRequest>(&header, _body_bytes, handles, &mut req)?;
48031 let control_handle = ProviderControlHandle { inner: this.inner.clone() };
48032 Ok(ProviderRequest::DatagramSocketDeprecated {
48033 domain: req.domain,
48034 proto: req.proto,
48035
48036 responder: ProviderDatagramSocketDeprecatedResponder {
48037 control_handle: std::mem::ManuallyDrop::new(control_handle),
48038 tx_id: header.tx_id,
48039 },
48040 })
48041 }
48042 0x4021b4fa1b6452f2 => {
48043 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
48044 let mut req = fidl::new_empty!(
48045 ProviderDatagramSocketRequest,
48046 fidl::encoding::DefaultFuchsiaResourceDialect
48047 );
48048 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderDatagramSocketRequest>(&header, _body_bytes, handles, &mut req)?;
48049 let control_handle = ProviderControlHandle { inner: this.inner.clone() };
48050 Ok(ProviderRequest::DatagramSocket {
48051 domain: req.domain,
48052 proto: req.proto,
48053
48054 responder: ProviderDatagramSocketResponder {
48055 control_handle: std::mem::ManuallyDrop::new(control_handle),
48056 tx_id: header.tx_id,
48057 },
48058 })
48059 }
48060 0x4cd0cffbffa39eb1 => {
48061 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
48062 let mut req = fidl::new_empty!(
48063 ProviderDatagramSocketWithOptionsRequest,
48064 fidl::encoding::DefaultFuchsiaResourceDialect
48065 );
48066 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderDatagramSocketWithOptionsRequest>(&header, _body_bytes, handles, &mut req)?;
48067 let control_handle = ProviderControlHandle { inner: this.inner.clone() };
48068 Ok(ProviderRequest::DatagramSocketWithOptions {
48069 domain: req.domain,
48070 proto: req.proto,
48071 opts: req.opts,
48072
48073 responder: ProviderDatagramSocketWithOptionsResponder {
48074 control_handle: std::mem::ManuallyDrop::new(control_handle),
48075 tx_id: header.tx_id,
48076 },
48077 })
48078 }
48079 0x4d59a64fce98272f => {
48080 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
48081 let mut req = fidl::new_empty!(
48082 ProviderInterfaceIndexToNameRequest,
48083 fidl::encoding::DefaultFuchsiaResourceDialect
48084 );
48085 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderInterfaceIndexToNameRequest>(&header, _body_bytes, handles, &mut req)?;
48086 let control_handle = ProviderControlHandle { inner: this.inner.clone() };
48087 Ok(ProviderRequest::InterfaceIndexToName {
48088 index: req.index,
48089
48090 responder: ProviderInterfaceIndexToNameResponder {
48091 control_handle: std::mem::ManuallyDrop::new(control_handle),
48092 tx_id: header.tx_id,
48093 },
48094 })
48095 }
48096 0x690cd8d2f2d650f8 => {
48097 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
48098 let mut req = fidl::new_empty!(
48099 ProviderInterfaceNameToIndexRequest,
48100 fidl::encoding::DefaultFuchsiaResourceDialect
48101 );
48102 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderInterfaceNameToIndexRequest>(&header, _body_bytes, handles, &mut req)?;
48103 let control_handle = ProviderControlHandle { inner: this.inner.clone() };
48104 Ok(ProviderRequest::InterfaceNameToIndex {
48105 name: req.name,
48106
48107 responder: ProviderInterfaceNameToIndexResponder {
48108 control_handle: std::mem::ManuallyDrop::new(control_handle),
48109 tx_id: header.tx_id,
48110 },
48111 })
48112 }
48113 0x25d0efcdb6671a0b => {
48114 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
48115 let mut req = fidl::new_empty!(
48116 ProviderInterfaceNameToFlagsRequest,
48117 fidl::encoding::DefaultFuchsiaResourceDialect
48118 );
48119 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderInterfaceNameToFlagsRequest>(&header, _body_bytes, handles, &mut req)?;
48120 let control_handle = ProviderControlHandle { inner: this.inner.clone() };
48121 Ok(ProviderRequest::InterfaceNameToFlags {
48122 name: req.name,
48123
48124 responder: ProviderInterfaceNameToFlagsResponder {
48125 control_handle: std::mem::ManuallyDrop::new(control_handle),
48126 tx_id: header.tx_id,
48127 },
48128 })
48129 }
48130 0x2e7b9aaf327c870 => {
48131 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
48132 let mut req = fidl::new_empty!(
48133 fidl::encoding::EmptyPayload,
48134 fidl::encoding::DefaultFuchsiaResourceDialect
48135 );
48136 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
48137 let control_handle = ProviderControlHandle { inner: this.inner.clone() };
48138 Ok(ProviderRequest::GetInterfaceAddresses {
48139 responder: ProviderGetInterfaceAddressesResponder {
48140 control_handle: std::mem::ManuallyDrop::new(control_handle),
48141 tx_id: header.tx_id,
48142 },
48143 })
48144 }
48145 _ => Err(fidl::Error::UnknownOrdinal {
48146 ordinal: header.ordinal,
48147 protocol_name:
48148 <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
48149 }),
48150 }))
48151 },
48152 )
48153 }
48154}
48155
48156#[derive(Debug)]
48163pub enum ProviderRequest {
48164 StreamSocketWithOptions {
48167 domain: Domain,
48168 proto: StreamSocketProtocol,
48169 opts: SocketCreationOptions,
48170 responder: ProviderStreamSocketWithOptionsResponder,
48171 },
48172 StreamSocket {
48174 domain: Domain,
48175 proto: StreamSocketProtocol,
48176 responder: ProviderStreamSocketResponder,
48177 },
48178 DatagramSocketDeprecated {
48181 domain: Domain,
48182 proto: DatagramSocketProtocol,
48183 responder: ProviderDatagramSocketDeprecatedResponder,
48184 },
48185 DatagramSocket {
48187 domain: Domain,
48188 proto: DatagramSocketProtocol,
48189 responder: ProviderDatagramSocketResponder,
48190 },
48191 DatagramSocketWithOptions {
48194 domain: Domain,
48195 proto: DatagramSocketProtocol,
48196 opts: SocketCreationOptions,
48197 responder: ProviderDatagramSocketWithOptionsResponder,
48198 },
48199 InterfaceIndexToName { index: u64, responder: ProviderInterfaceIndexToNameResponder },
48202 InterfaceNameToIndex { name: String, responder: ProviderInterfaceNameToIndexResponder },
48205 InterfaceNameToFlags { name: String, responder: ProviderInterfaceNameToFlagsResponder },
48208 GetInterfaceAddresses { responder: ProviderGetInterfaceAddressesResponder },
48211}
48212
48213impl ProviderRequest {
48214 #[allow(irrefutable_let_patterns)]
48215 pub fn into_stream_socket_with_options(
48216 self,
48217 ) -> Option<(
48218 Domain,
48219 StreamSocketProtocol,
48220 SocketCreationOptions,
48221 ProviderStreamSocketWithOptionsResponder,
48222 )> {
48223 if let ProviderRequest::StreamSocketWithOptions { domain, proto, opts, responder } = self {
48224 Some((domain, proto, opts, responder))
48225 } else {
48226 None
48227 }
48228 }
48229
48230 #[allow(irrefutable_let_patterns)]
48231 pub fn into_stream_socket(
48232 self,
48233 ) -> Option<(Domain, StreamSocketProtocol, ProviderStreamSocketResponder)> {
48234 if let ProviderRequest::StreamSocket { domain, proto, responder } = self {
48235 Some((domain, proto, responder))
48236 } else {
48237 None
48238 }
48239 }
48240
48241 #[allow(irrefutable_let_patterns)]
48242 pub fn into_datagram_socket_deprecated(
48243 self,
48244 ) -> Option<(Domain, DatagramSocketProtocol, ProviderDatagramSocketDeprecatedResponder)> {
48245 if let ProviderRequest::DatagramSocketDeprecated { domain, proto, responder } = self {
48246 Some((domain, proto, responder))
48247 } else {
48248 None
48249 }
48250 }
48251
48252 #[allow(irrefutable_let_patterns)]
48253 pub fn into_datagram_socket(
48254 self,
48255 ) -> Option<(Domain, DatagramSocketProtocol, ProviderDatagramSocketResponder)> {
48256 if let ProviderRequest::DatagramSocket { domain, proto, responder } = self {
48257 Some((domain, proto, responder))
48258 } else {
48259 None
48260 }
48261 }
48262
48263 #[allow(irrefutable_let_patterns)]
48264 pub fn into_datagram_socket_with_options(
48265 self,
48266 ) -> Option<(
48267 Domain,
48268 DatagramSocketProtocol,
48269 SocketCreationOptions,
48270 ProviderDatagramSocketWithOptionsResponder,
48271 )> {
48272 if let ProviderRequest::DatagramSocketWithOptions { domain, proto, opts, responder } = self
48273 {
48274 Some((domain, proto, opts, responder))
48275 } else {
48276 None
48277 }
48278 }
48279
48280 #[allow(irrefutable_let_patterns)]
48281 pub fn into_interface_index_to_name(
48282 self,
48283 ) -> Option<(u64, ProviderInterfaceIndexToNameResponder)> {
48284 if let ProviderRequest::InterfaceIndexToName { index, responder } = self {
48285 Some((index, responder))
48286 } else {
48287 None
48288 }
48289 }
48290
48291 #[allow(irrefutable_let_patterns)]
48292 pub fn into_interface_name_to_index(
48293 self,
48294 ) -> Option<(String, ProviderInterfaceNameToIndexResponder)> {
48295 if let ProviderRequest::InterfaceNameToIndex { name, responder } = self {
48296 Some((name, responder))
48297 } else {
48298 None
48299 }
48300 }
48301
48302 #[allow(irrefutable_let_patterns)]
48303 pub fn into_interface_name_to_flags(
48304 self,
48305 ) -> Option<(String, ProviderInterfaceNameToFlagsResponder)> {
48306 if let ProviderRequest::InterfaceNameToFlags { name, responder } = self {
48307 Some((name, responder))
48308 } else {
48309 None
48310 }
48311 }
48312
48313 #[allow(irrefutable_let_patterns)]
48314 pub fn into_get_interface_addresses(self) -> Option<(ProviderGetInterfaceAddressesResponder)> {
48315 if let ProviderRequest::GetInterfaceAddresses { responder } = self {
48316 Some((responder))
48317 } else {
48318 None
48319 }
48320 }
48321
48322 pub fn method_name(&self) -> &'static str {
48324 match *self {
48325 ProviderRequest::StreamSocketWithOptions { .. } => "stream_socket_with_options",
48326 ProviderRequest::StreamSocket { .. } => "stream_socket",
48327 ProviderRequest::DatagramSocketDeprecated { .. } => "datagram_socket_deprecated",
48328 ProviderRequest::DatagramSocket { .. } => "datagram_socket",
48329 ProviderRequest::DatagramSocketWithOptions { .. } => "datagram_socket_with_options",
48330 ProviderRequest::InterfaceIndexToName { .. } => "interface_index_to_name",
48331 ProviderRequest::InterfaceNameToIndex { .. } => "interface_name_to_index",
48332 ProviderRequest::InterfaceNameToFlags { .. } => "interface_name_to_flags",
48333 ProviderRequest::GetInterfaceAddresses { .. } => "get_interface_addresses",
48334 }
48335 }
48336}
48337
48338#[derive(Debug, Clone)]
48339pub struct ProviderControlHandle {
48340 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
48341}
48342
48343impl fidl::endpoints::ControlHandle for ProviderControlHandle {
48344 fn shutdown(&self) {
48345 self.inner.shutdown()
48346 }
48347 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
48348 self.inner.shutdown_with_epitaph(status)
48349 }
48350
48351 fn is_closed(&self) -> bool {
48352 self.inner.channel().is_closed()
48353 }
48354 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
48355 self.inner.channel().on_closed()
48356 }
48357
48358 #[cfg(target_os = "fuchsia")]
48359 fn signal_peer(
48360 &self,
48361 clear_mask: zx::Signals,
48362 set_mask: zx::Signals,
48363 ) -> Result<(), zx_status::Status> {
48364 use fidl::Peered;
48365 self.inner.channel().signal_peer(clear_mask, set_mask)
48366 }
48367}
48368
48369impl ProviderControlHandle {}
48370
48371#[must_use = "FIDL methods require a response to be sent"]
48372#[derive(Debug)]
48373pub struct ProviderStreamSocketWithOptionsResponder {
48374 control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48375 tx_id: u32,
48376}
48377
48378impl std::ops::Drop for ProviderStreamSocketWithOptionsResponder {
48382 fn drop(&mut self) {
48383 self.control_handle.shutdown();
48384 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48386 }
48387}
48388
48389impl fidl::endpoints::Responder for ProviderStreamSocketWithOptionsResponder {
48390 type ControlHandle = ProviderControlHandle;
48391
48392 fn control_handle(&self) -> &ProviderControlHandle {
48393 &self.control_handle
48394 }
48395
48396 fn drop_without_shutdown(mut self) {
48397 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48399 std::mem::forget(self);
48401 }
48402}
48403
48404impl ProviderStreamSocketWithOptionsResponder {
48405 pub fn send(
48409 self,
48410 mut result: Result<
48411 fidl::endpoints::ClientEnd<StreamSocketMarker>,
48412 fidl_fuchsia_posix::Errno,
48413 >,
48414 ) -> Result<(), fidl::Error> {
48415 let _result = self.send_raw(result);
48416 if _result.is_err() {
48417 self.control_handle.shutdown();
48418 }
48419 self.drop_without_shutdown();
48420 _result
48421 }
48422
48423 pub fn send_no_shutdown_on_err(
48425 self,
48426 mut result: Result<
48427 fidl::endpoints::ClientEnd<StreamSocketMarker>,
48428 fidl_fuchsia_posix::Errno,
48429 >,
48430 ) -> Result<(), fidl::Error> {
48431 let _result = self.send_raw(result);
48432 self.drop_without_shutdown();
48433 _result
48434 }
48435
48436 fn send_raw(
48437 &self,
48438 mut result: Result<
48439 fidl::endpoints::ClientEnd<StreamSocketMarker>,
48440 fidl_fuchsia_posix::Errno,
48441 >,
48442 ) -> Result<(), fidl::Error> {
48443 self.control_handle.inner.send::<fidl::encoding::ResultType<
48444 ProviderStreamSocketWithOptionsResponse,
48445 fidl_fuchsia_posix::Errno,
48446 >>(
48447 result.map(|s| (s,)),
48448 self.tx_id,
48449 0x3969bf7eb78386e0,
48450 fidl::encoding::DynamicFlags::empty(),
48451 )
48452 }
48453}
48454
48455#[must_use = "FIDL methods require a response to be sent"]
48456#[derive(Debug)]
48457pub struct ProviderStreamSocketResponder {
48458 control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48459 tx_id: u32,
48460}
48461
48462impl std::ops::Drop for ProviderStreamSocketResponder {
48466 fn drop(&mut self) {
48467 self.control_handle.shutdown();
48468 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48470 }
48471}
48472
48473impl fidl::endpoints::Responder for ProviderStreamSocketResponder {
48474 type ControlHandle = ProviderControlHandle;
48475
48476 fn control_handle(&self) -> &ProviderControlHandle {
48477 &self.control_handle
48478 }
48479
48480 fn drop_without_shutdown(mut self) {
48481 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48483 std::mem::forget(self);
48485 }
48486}
48487
48488impl ProviderStreamSocketResponder {
48489 pub fn send(
48493 self,
48494 mut result: Result<
48495 fidl::endpoints::ClientEnd<StreamSocketMarker>,
48496 fidl_fuchsia_posix::Errno,
48497 >,
48498 ) -> Result<(), fidl::Error> {
48499 let _result = self.send_raw(result);
48500 if _result.is_err() {
48501 self.control_handle.shutdown();
48502 }
48503 self.drop_without_shutdown();
48504 _result
48505 }
48506
48507 pub fn send_no_shutdown_on_err(
48509 self,
48510 mut result: Result<
48511 fidl::endpoints::ClientEnd<StreamSocketMarker>,
48512 fidl_fuchsia_posix::Errno,
48513 >,
48514 ) -> Result<(), fidl::Error> {
48515 let _result = self.send_raw(result);
48516 self.drop_without_shutdown();
48517 _result
48518 }
48519
48520 fn send_raw(
48521 &self,
48522 mut result: Result<
48523 fidl::endpoints::ClientEnd<StreamSocketMarker>,
48524 fidl_fuchsia_posix::Errno,
48525 >,
48526 ) -> Result<(), fidl::Error> {
48527 self.control_handle.inner.send::<fidl::encoding::ResultType<
48528 ProviderStreamSocketResponse,
48529 fidl_fuchsia_posix::Errno,
48530 >>(
48531 result.map(|s| (s,)),
48532 self.tx_id,
48533 0x27c3581da2155545,
48534 fidl::encoding::DynamicFlags::empty(),
48535 )
48536 }
48537}
48538
48539#[must_use = "FIDL methods require a response to be sent"]
48540#[derive(Debug)]
48541pub struct ProviderDatagramSocketDeprecatedResponder {
48542 control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48543 tx_id: u32,
48544}
48545
48546impl std::ops::Drop for ProviderDatagramSocketDeprecatedResponder {
48550 fn drop(&mut self) {
48551 self.control_handle.shutdown();
48552 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48554 }
48555}
48556
48557impl fidl::endpoints::Responder for ProviderDatagramSocketDeprecatedResponder {
48558 type ControlHandle = ProviderControlHandle;
48559
48560 fn control_handle(&self) -> &ProviderControlHandle {
48561 &self.control_handle
48562 }
48563
48564 fn drop_without_shutdown(mut self) {
48565 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48567 std::mem::forget(self);
48569 }
48570}
48571
48572impl ProviderDatagramSocketDeprecatedResponder {
48573 pub fn send(
48577 self,
48578 mut result: Result<
48579 fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
48580 fidl_fuchsia_posix::Errno,
48581 >,
48582 ) -> Result<(), fidl::Error> {
48583 let _result = self.send_raw(result);
48584 if _result.is_err() {
48585 self.control_handle.shutdown();
48586 }
48587 self.drop_without_shutdown();
48588 _result
48589 }
48590
48591 pub fn send_no_shutdown_on_err(
48593 self,
48594 mut result: Result<
48595 fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
48596 fidl_fuchsia_posix::Errno,
48597 >,
48598 ) -> Result<(), fidl::Error> {
48599 let _result = self.send_raw(result);
48600 self.drop_without_shutdown();
48601 _result
48602 }
48603
48604 fn send_raw(
48605 &self,
48606 mut result: Result<
48607 fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
48608 fidl_fuchsia_posix::Errno,
48609 >,
48610 ) -> Result<(), fidl::Error> {
48611 self.control_handle.inner.send::<fidl::encoding::ResultType<
48612 ProviderDatagramSocketDeprecatedResponse,
48613 fidl_fuchsia_posix::Errno,
48614 >>(
48615 result.map(|s| (s,)),
48616 self.tx_id,
48617 0x38876c87cf031cb1,
48618 fidl::encoding::DynamicFlags::empty(),
48619 )
48620 }
48621}
48622
48623#[must_use = "FIDL methods require a response to be sent"]
48624#[derive(Debug)]
48625pub struct ProviderDatagramSocketResponder {
48626 control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48627 tx_id: u32,
48628}
48629
48630impl std::ops::Drop for ProviderDatagramSocketResponder {
48634 fn drop(&mut self) {
48635 self.control_handle.shutdown();
48636 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48638 }
48639}
48640
48641impl fidl::endpoints::Responder for ProviderDatagramSocketResponder {
48642 type ControlHandle = ProviderControlHandle;
48643
48644 fn control_handle(&self) -> &ProviderControlHandle {
48645 &self.control_handle
48646 }
48647
48648 fn drop_without_shutdown(mut self) {
48649 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48651 std::mem::forget(self);
48653 }
48654}
48655
48656impl ProviderDatagramSocketResponder {
48657 pub fn send(
48661 self,
48662 mut result: Result<ProviderDatagramSocketResponse, fidl_fuchsia_posix::Errno>,
48663 ) -> Result<(), fidl::Error> {
48664 let _result = self.send_raw(result);
48665 if _result.is_err() {
48666 self.control_handle.shutdown();
48667 }
48668 self.drop_without_shutdown();
48669 _result
48670 }
48671
48672 pub fn send_no_shutdown_on_err(
48674 self,
48675 mut result: Result<ProviderDatagramSocketResponse, fidl_fuchsia_posix::Errno>,
48676 ) -> Result<(), fidl::Error> {
48677 let _result = self.send_raw(result);
48678 self.drop_without_shutdown();
48679 _result
48680 }
48681
48682 fn send_raw(
48683 &self,
48684 mut result: Result<ProviderDatagramSocketResponse, fidl_fuchsia_posix::Errno>,
48685 ) -> Result<(), fidl::Error> {
48686 self.control_handle.inner.send::<fidl::encoding::ResultType<
48687 ProviderDatagramSocketResponse,
48688 fidl_fuchsia_posix::Errno,
48689 >>(
48690 result.as_mut().map_err(|e| *e),
48691 self.tx_id,
48692 0x4021b4fa1b6452f2,
48693 fidl::encoding::DynamicFlags::empty(),
48694 )
48695 }
48696}
48697
48698#[must_use = "FIDL methods require a response to be sent"]
48699#[derive(Debug)]
48700pub struct ProviderDatagramSocketWithOptionsResponder {
48701 control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48702 tx_id: u32,
48703}
48704
48705impl std::ops::Drop for ProviderDatagramSocketWithOptionsResponder {
48709 fn drop(&mut self) {
48710 self.control_handle.shutdown();
48711 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48713 }
48714}
48715
48716impl fidl::endpoints::Responder for ProviderDatagramSocketWithOptionsResponder {
48717 type ControlHandle = ProviderControlHandle;
48718
48719 fn control_handle(&self) -> &ProviderControlHandle {
48720 &self.control_handle
48721 }
48722
48723 fn drop_without_shutdown(mut self) {
48724 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48726 std::mem::forget(self);
48728 }
48729}
48730
48731impl ProviderDatagramSocketWithOptionsResponder {
48732 pub fn send(
48736 self,
48737 mut result: Result<ProviderDatagramSocketWithOptionsResponse, fidl_fuchsia_posix::Errno>,
48738 ) -> Result<(), fidl::Error> {
48739 let _result = self.send_raw(result);
48740 if _result.is_err() {
48741 self.control_handle.shutdown();
48742 }
48743 self.drop_without_shutdown();
48744 _result
48745 }
48746
48747 pub fn send_no_shutdown_on_err(
48749 self,
48750 mut result: Result<ProviderDatagramSocketWithOptionsResponse, fidl_fuchsia_posix::Errno>,
48751 ) -> Result<(), fidl::Error> {
48752 let _result = self.send_raw(result);
48753 self.drop_without_shutdown();
48754 _result
48755 }
48756
48757 fn send_raw(
48758 &self,
48759 mut result: Result<ProviderDatagramSocketWithOptionsResponse, fidl_fuchsia_posix::Errno>,
48760 ) -> Result<(), fidl::Error> {
48761 self.control_handle.inner.send::<fidl::encoding::ResultType<
48762 ProviderDatagramSocketWithOptionsResponse,
48763 fidl_fuchsia_posix::Errno,
48764 >>(
48765 result.as_mut().map_err(|e| *e),
48766 self.tx_id,
48767 0x4cd0cffbffa39eb1,
48768 fidl::encoding::DynamicFlags::empty(),
48769 )
48770 }
48771}
48772
48773#[must_use = "FIDL methods require a response to be sent"]
48774#[derive(Debug)]
48775pub struct ProviderInterfaceIndexToNameResponder {
48776 control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48777 tx_id: u32,
48778}
48779
48780impl std::ops::Drop for ProviderInterfaceIndexToNameResponder {
48784 fn drop(&mut self) {
48785 self.control_handle.shutdown();
48786 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48788 }
48789}
48790
48791impl fidl::endpoints::Responder for ProviderInterfaceIndexToNameResponder {
48792 type ControlHandle = ProviderControlHandle;
48793
48794 fn control_handle(&self) -> &ProviderControlHandle {
48795 &self.control_handle
48796 }
48797
48798 fn drop_without_shutdown(mut self) {
48799 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48801 std::mem::forget(self);
48803 }
48804}
48805
48806impl ProviderInterfaceIndexToNameResponder {
48807 pub fn send(self, mut result: Result<&str, i32>) -> Result<(), fidl::Error> {
48811 let _result = self.send_raw(result);
48812 if _result.is_err() {
48813 self.control_handle.shutdown();
48814 }
48815 self.drop_without_shutdown();
48816 _result
48817 }
48818
48819 pub fn send_no_shutdown_on_err(self, mut result: Result<&str, i32>) -> Result<(), fidl::Error> {
48821 let _result = self.send_raw(result);
48822 self.drop_without_shutdown();
48823 _result
48824 }
48825
48826 fn send_raw(&self, mut result: Result<&str, i32>) -> Result<(), fidl::Error> {
48827 self.control_handle.inner.send::<fidl::encoding::ResultType<
48828 ProviderInterfaceIndexToNameResponse,
48829 i32,
48830 >>(
48831 result.map(|name| (name,)),
48832 self.tx_id,
48833 0x4d59a64fce98272f,
48834 fidl::encoding::DynamicFlags::empty(),
48835 )
48836 }
48837}
48838
48839#[must_use = "FIDL methods require a response to be sent"]
48840#[derive(Debug)]
48841pub struct ProviderInterfaceNameToIndexResponder {
48842 control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48843 tx_id: u32,
48844}
48845
48846impl std::ops::Drop for ProviderInterfaceNameToIndexResponder {
48850 fn drop(&mut self) {
48851 self.control_handle.shutdown();
48852 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48854 }
48855}
48856
48857impl fidl::endpoints::Responder for ProviderInterfaceNameToIndexResponder {
48858 type ControlHandle = ProviderControlHandle;
48859
48860 fn control_handle(&self) -> &ProviderControlHandle {
48861 &self.control_handle
48862 }
48863
48864 fn drop_without_shutdown(mut self) {
48865 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48867 std::mem::forget(self);
48869 }
48870}
48871
48872impl ProviderInterfaceNameToIndexResponder {
48873 pub fn send(self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
48877 let _result = self.send_raw(result);
48878 if _result.is_err() {
48879 self.control_handle.shutdown();
48880 }
48881 self.drop_without_shutdown();
48882 _result
48883 }
48884
48885 pub fn send_no_shutdown_on_err(self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
48887 let _result = self.send_raw(result);
48888 self.drop_without_shutdown();
48889 _result
48890 }
48891
48892 fn send_raw(&self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
48893 self.control_handle.inner.send::<fidl::encoding::ResultType<
48894 ProviderInterfaceNameToIndexResponse,
48895 i32,
48896 >>(
48897 result.map(|index| (index,)),
48898 self.tx_id,
48899 0x690cd8d2f2d650f8,
48900 fidl::encoding::DynamicFlags::empty(),
48901 )
48902 }
48903}
48904
48905#[must_use = "FIDL methods require a response to be sent"]
48906#[derive(Debug)]
48907pub struct ProviderInterfaceNameToFlagsResponder {
48908 control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48909 tx_id: u32,
48910}
48911
48912impl std::ops::Drop for ProviderInterfaceNameToFlagsResponder {
48916 fn drop(&mut self) {
48917 self.control_handle.shutdown();
48918 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48920 }
48921}
48922
48923impl fidl::endpoints::Responder for ProviderInterfaceNameToFlagsResponder {
48924 type ControlHandle = ProviderControlHandle;
48925
48926 fn control_handle(&self) -> &ProviderControlHandle {
48927 &self.control_handle
48928 }
48929
48930 fn drop_without_shutdown(mut self) {
48931 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48933 std::mem::forget(self);
48935 }
48936}
48937
48938impl ProviderInterfaceNameToFlagsResponder {
48939 pub fn send(self, mut result: Result<InterfaceFlags, i32>) -> Result<(), fidl::Error> {
48943 let _result = self.send_raw(result);
48944 if _result.is_err() {
48945 self.control_handle.shutdown();
48946 }
48947 self.drop_without_shutdown();
48948 _result
48949 }
48950
48951 pub fn send_no_shutdown_on_err(
48953 self,
48954 mut result: Result<InterfaceFlags, i32>,
48955 ) -> Result<(), fidl::Error> {
48956 let _result = self.send_raw(result);
48957 self.drop_without_shutdown();
48958 _result
48959 }
48960
48961 fn send_raw(&self, mut result: Result<InterfaceFlags, i32>) -> Result<(), fidl::Error> {
48962 self.control_handle.inner.send::<fidl::encoding::ResultType<
48963 ProviderInterfaceNameToFlagsResponse,
48964 i32,
48965 >>(
48966 result.map(|flags| (flags,)),
48967 self.tx_id,
48968 0x25d0efcdb6671a0b,
48969 fidl::encoding::DynamicFlags::empty(),
48970 )
48971 }
48972}
48973
48974#[must_use = "FIDL methods require a response to be sent"]
48975#[derive(Debug)]
48976pub struct ProviderGetInterfaceAddressesResponder {
48977 control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48978 tx_id: u32,
48979}
48980
48981impl std::ops::Drop for ProviderGetInterfaceAddressesResponder {
48985 fn drop(&mut self) {
48986 self.control_handle.shutdown();
48987 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48989 }
48990}
48991
48992impl fidl::endpoints::Responder for ProviderGetInterfaceAddressesResponder {
48993 type ControlHandle = ProviderControlHandle;
48994
48995 fn control_handle(&self) -> &ProviderControlHandle {
48996 &self.control_handle
48997 }
48998
48999 fn drop_without_shutdown(mut self) {
49000 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
49002 std::mem::forget(self);
49004 }
49005}
49006
49007impl ProviderGetInterfaceAddressesResponder {
49008 pub fn send(self, mut interfaces: &[InterfaceAddresses]) -> Result<(), fidl::Error> {
49012 let _result = self.send_raw(interfaces);
49013 if _result.is_err() {
49014 self.control_handle.shutdown();
49015 }
49016 self.drop_without_shutdown();
49017 _result
49018 }
49019
49020 pub fn send_no_shutdown_on_err(
49022 self,
49023 mut interfaces: &[InterfaceAddresses],
49024 ) -> Result<(), fidl::Error> {
49025 let _result = self.send_raw(interfaces);
49026 self.drop_without_shutdown();
49027 _result
49028 }
49029
49030 fn send_raw(&self, mut interfaces: &[InterfaceAddresses]) -> Result<(), fidl::Error> {
49031 self.control_handle.inner.send::<ProviderGetInterfaceAddressesResponse>(
49032 (interfaces,),
49033 self.tx_id,
49034 0x2e7b9aaf327c870,
49035 fidl::encoding::DynamicFlags::empty(),
49036 )
49037 }
49038}
49039
49040#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
49041pub struct StreamSocketMarker;
49042
49043impl fidl::endpoints::ProtocolMarker for StreamSocketMarker {
49044 type Proxy = StreamSocketProxy;
49045 type RequestStream = StreamSocketRequestStream;
49046 #[cfg(target_os = "fuchsia")]
49047 type SynchronousProxy = StreamSocketSynchronousProxy;
49048
49049 const DEBUG_NAME: &'static str = "fuchsia.posix.socket.StreamSocket";
49050}
49051impl fidl::endpoints::DiscoverableProtocolMarker for StreamSocketMarker {}
49052pub type StreamSocketListenResult = Result<(), fidl_fuchsia_posix::Errno>;
49053pub type StreamSocketAcceptResult = Result<
49054 (Option<Box<fidl_fuchsia_net::SocketAddress>>, fidl::endpoints::ClientEnd<StreamSocketMarker>),
49055 fidl_fuchsia_posix::Errno,
49056>;
49057pub type StreamSocketGetInfoResult =
49058 Result<(Domain, StreamSocketProtocol), fidl_fuchsia_posix::Errno>;
49059pub type StreamSocketSetTcpNoDelayResult = Result<(), fidl_fuchsia_posix::Errno>;
49060pub type StreamSocketGetTcpNoDelayResult = Result<bool, fidl_fuchsia_posix::Errno>;
49061pub type StreamSocketSetTcpMaxSegmentResult = Result<(), fidl_fuchsia_posix::Errno>;
49062pub type StreamSocketGetTcpMaxSegmentResult = Result<u32, fidl_fuchsia_posix::Errno>;
49063pub type StreamSocketSetTcpCorkResult = Result<(), fidl_fuchsia_posix::Errno>;
49064pub type StreamSocketGetTcpCorkResult = Result<bool, fidl_fuchsia_posix::Errno>;
49065pub type StreamSocketSetTcpKeepAliveIdleResult = Result<(), fidl_fuchsia_posix::Errno>;
49066pub type StreamSocketGetTcpKeepAliveIdleResult = Result<u32, fidl_fuchsia_posix::Errno>;
49067pub type StreamSocketSetTcpKeepAliveIntervalResult = Result<(), fidl_fuchsia_posix::Errno>;
49068pub type StreamSocketGetTcpKeepAliveIntervalResult = Result<u32, fidl_fuchsia_posix::Errno>;
49069pub type StreamSocketSetTcpKeepAliveCountResult = Result<(), fidl_fuchsia_posix::Errno>;
49070pub type StreamSocketGetTcpKeepAliveCountResult = Result<u32, fidl_fuchsia_posix::Errno>;
49071pub type StreamSocketSetTcpSynCountResult = Result<(), fidl_fuchsia_posix::Errno>;
49072pub type StreamSocketGetTcpSynCountResult = Result<u32, fidl_fuchsia_posix::Errno>;
49073pub type StreamSocketSetTcpLingerResult = Result<(), fidl_fuchsia_posix::Errno>;
49074pub type StreamSocketGetTcpLingerResult = Result<OptionalUint32, fidl_fuchsia_posix::Errno>;
49075pub type StreamSocketSetTcpDeferAcceptResult = Result<(), fidl_fuchsia_posix::Errno>;
49076pub type StreamSocketGetTcpDeferAcceptResult = Result<u32, fidl_fuchsia_posix::Errno>;
49077pub type StreamSocketSetTcpWindowClampResult = Result<(), fidl_fuchsia_posix::Errno>;
49078pub type StreamSocketGetTcpWindowClampResult = Result<u32, fidl_fuchsia_posix::Errno>;
49079pub type StreamSocketGetTcpInfoResult = Result<TcpInfo, fidl_fuchsia_posix::Errno>;
49080pub type StreamSocketSetTcpQuickAckResult = Result<(), fidl_fuchsia_posix::Errno>;
49081pub type StreamSocketGetTcpQuickAckResult = Result<bool, fidl_fuchsia_posix::Errno>;
49082pub type StreamSocketSetTcpCongestionResult = Result<(), fidl_fuchsia_posix::Errno>;
49083pub type StreamSocketGetTcpCongestionResult =
49084 Result<TcpCongestionControl, fidl_fuchsia_posix::Errno>;
49085pub type StreamSocketSetTcpUserTimeoutResult = Result<(), fidl_fuchsia_posix::Errno>;
49086pub type StreamSocketGetTcpUserTimeoutResult = Result<u32, fidl_fuchsia_posix::Errno>;
49087
49088pub trait StreamSocketProxyInterface: Send + Sync {
49089 fn r#clone(
49090 &self,
49091 request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
49092 ) -> Result<(), fidl::Error>;
49093 type CloseResponseFut: std::future::Future<
49094 Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
49095 > + Send;
49096 fn r#close(&self) -> Self::CloseResponseFut;
49097 type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
49098 fn r#query(&self) -> Self::QueryResponseFut;
49099 type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
49100 + Send;
49101 fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
49102 type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
49103 + Send;
49104 fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
49105 type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
49106 + Send;
49107 fn r#get_error(&self) -> Self::GetErrorResponseFut;
49108 type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
49109 + Send;
49110 fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
49111 type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
49112 + Send;
49113 fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
49114 type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
49115 + Send;
49116 fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
49117 type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
49118 + Send;
49119 fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
49120 type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
49121 + Send;
49122 fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
49123 type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
49124 + Send;
49125 fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
49126 type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
49127 + Send;
49128 fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
49129 type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
49130 + Send;
49131 fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
49132 type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
49133 + Send;
49134 fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
49135 type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
49136 + Send;
49137 fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
49138 type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
49139 + Send;
49140 fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
49141 type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
49142 + Send;
49143 fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
49144 type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
49145 + Send;
49146 fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
49147 type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
49148 + Send;
49149 fn r#get_linger(&self) -> Self::GetLingerResponseFut;
49150 type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
49151 + Send;
49152 fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
49153 type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
49154 + Send;
49155 fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
49156 type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
49157 + Send;
49158 fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
49159 type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
49160 + Send;
49161 fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
49162 type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
49163 + Send;
49164 fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
49165 type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
49166 + Send;
49167 fn r#set_bind_to_interface_index(&self, value: u64)
49168 -> Self::SetBindToInterfaceIndexResponseFut;
49169 type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
49170 + Send;
49171 fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
49172 type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
49173 + Send;
49174 fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
49175 type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
49176 + Send;
49177 fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
49178 type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
49179 + Send;
49180 fn r#set_mark(
49181 &self,
49182 domain: fidl_fuchsia_net::MarkDomain,
49183 mark: &OptionalUint32,
49184 ) -> Self::SetMarkResponseFut;
49185 type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
49186 + Send;
49187 fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
49188 type BindResponseFut: std::future::Future<Output = Result<BaseNetworkSocketBindResult, fidl::Error>>
49189 + Send;
49190 fn r#bind(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut;
49191 type ConnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketConnectResult, fidl::Error>>
49192 + Send;
49193 fn r#connect(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut;
49194 type DisconnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDisconnectResult, fidl::Error>>
49195 + Send;
49196 fn r#disconnect(&self) -> Self::DisconnectResponseFut;
49197 type GetSockNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetSockNameResult, fidl::Error>>
49198 + Send;
49199 fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
49200 type GetPeerNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetPeerNameResult, fidl::Error>>
49201 + Send;
49202 fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
49203 type ShutdownResponseFut: std::future::Future<Output = Result<BaseNetworkSocketShutdownResult, fidl::Error>>
49204 + Send;
49205 fn r#shutdown(&self, mode: ShutdownMode) -> Self::ShutdownResponseFut;
49206 type SetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>>
49207 + Send;
49208 fn r#set_ip_type_of_service(&self, value: u8) -> Self::SetIpTypeOfServiceResponseFut;
49209 type GetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>>
49210 + Send;
49211 fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut;
49212 type SetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTtlResult, fidl::Error>>
49213 + Send;
49214 fn r#set_ip_ttl(&self, value: &OptionalUint8) -> Self::SetIpTtlResponseFut;
49215 type GetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTtlResult, fidl::Error>>
49216 + Send;
49217 fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut;
49218 type SetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>>
49219 + Send;
49220 fn r#set_ip_packet_info(&self, value: bool) -> Self::SetIpPacketInfoResponseFut;
49221 type GetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>>
49222 + Send;
49223 fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut;
49224 type SetIpReceiveTypeOfServiceResponseFut: std::future::Future<
49225 Output = Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error>,
49226 > + Send;
49227 fn r#set_ip_receive_type_of_service(
49228 &self,
49229 value: bool,
49230 ) -> Self::SetIpReceiveTypeOfServiceResponseFut;
49231 type GetIpReceiveTypeOfServiceResponseFut: std::future::Future<
49232 Output = Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error>,
49233 > + Send;
49234 fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut;
49235 type SetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>>
49236 + Send;
49237 fn r#set_ip_receive_ttl(&self, value: bool) -> Self::SetIpReceiveTtlResponseFut;
49238 type GetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>>
49239 + Send;
49240 fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut;
49241 type SetIpMulticastInterfaceResponseFut: std::future::Future<
49242 Output = Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error>,
49243 > + Send;
49244 fn r#set_ip_multicast_interface(
49245 &self,
49246 iface: u64,
49247 address: &fidl_fuchsia_net::Ipv4Address,
49248 ) -> Self::SetIpMulticastInterfaceResponseFut;
49249 type GetIpMulticastInterfaceResponseFut: std::future::Future<
49250 Output = Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error>,
49251 > + Send;
49252 fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut;
49253 type SetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>>
49254 + Send;
49255 fn r#set_ip_multicast_ttl(&self, value: &OptionalUint8) -> Self::SetIpMulticastTtlResponseFut;
49256 type GetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>>
49257 + Send;
49258 fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut;
49259 type SetIpMulticastLoopbackResponseFut: std::future::Future<
49260 Output = Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error>,
49261 > + Send;
49262 fn r#set_ip_multicast_loopback(&self, value: bool) -> Self::SetIpMulticastLoopbackResponseFut;
49263 type GetIpMulticastLoopbackResponseFut: std::future::Future<
49264 Output = Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error>,
49265 > + Send;
49266 fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut;
49267 type AddIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error>>
49268 + Send;
49269 fn r#add_ip_membership(
49270 &self,
49271 membership: &IpMulticastMembership,
49272 ) -> Self::AddIpMembershipResponseFut;
49273 type DropIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error>>
49274 + Send;
49275 fn r#drop_ip_membership(
49276 &self,
49277 membership: &IpMulticastMembership,
49278 ) -> Self::DropIpMembershipResponseFut;
49279 type SetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error>>
49280 + Send;
49281 fn r#set_ip_transparent(&self, value: bool) -> Self::SetIpTransparentResponseFut;
49282 type GetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error>>
49283 + Send;
49284 fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut;
49285 type SetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
49286 Output = Result<
49287 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
49288 fidl::Error,
49289 >,
49290 > + Send;
49291 fn r#set_ip_receive_original_destination_address(
49292 &self,
49293 value: bool,
49294 ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut;
49295 type GetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
49296 Output = Result<
49297 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
49298 fidl::Error,
49299 >,
49300 > + Send;
49301 fn r#get_ip_receive_original_destination_address(
49302 &self,
49303 ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut;
49304 type AddIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>>
49305 + Send;
49306 fn r#add_ipv6_membership(
49307 &self,
49308 membership: &Ipv6MulticastMembership,
49309 ) -> Self::AddIpv6MembershipResponseFut;
49310 type DropIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>>
49311 + Send;
49312 fn r#drop_ipv6_membership(
49313 &self,
49314 membership: &Ipv6MulticastMembership,
49315 ) -> Self::DropIpv6MembershipResponseFut;
49316 type SetIpv6MulticastInterfaceResponseFut: std::future::Future<
49317 Output = Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error>,
49318 > + Send;
49319 fn r#set_ipv6_multicast_interface(
49320 &self,
49321 value: u64,
49322 ) -> Self::SetIpv6MulticastInterfaceResponseFut;
49323 type GetIpv6MulticastInterfaceResponseFut: std::future::Future<
49324 Output = Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error>,
49325 > + Send;
49326 fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut;
49327 type SetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>>
49328 + Send;
49329 fn r#set_ipv6_unicast_hops(&self, value: &OptionalUint8)
49330 -> Self::SetIpv6UnicastHopsResponseFut;
49331 type GetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>>
49332 + Send;
49333 fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut;
49334 type SetIpv6ReceiveHopLimitResponseFut: std::future::Future<
49335 Output = Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error>,
49336 > + Send;
49337 fn r#set_ipv6_receive_hop_limit(&self, value: bool) -> Self::SetIpv6ReceiveHopLimitResponseFut;
49338 type GetIpv6ReceiveHopLimitResponseFut: std::future::Future<
49339 Output = Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error>,
49340 > + Send;
49341 fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut;
49342 type SetIpv6MulticastHopsResponseFut: std::future::Future<
49343 Output = Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error>,
49344 > + Send;
49345 fn r#set_ipv6_multicast_hops(
49346 &self,
49347 value: &OptionalUint8,
49348 ) -> Self::SetIpv6MulticastHopsResponseFut;
49349 type GetIpv6MulticastHopsResponseFut: std::future::Future<
49350 Output = Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error>,
49351 > + Send;
49352 fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut;
49353 type SetIpv6MulticastLoopbackResponseFut: std::future::Future<
49354 Output = Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error>,
49355 > + Send;
49356 fn r#set_ipv6_multicast_loopback(
49357 &self,
49358 value: bool,
49359 ) -> Self::SetIpv6MulticastLoopbackResponseFut;
49360 type GetIpv6MulticastLoopbackResponseFut: std::future::Future<
49361 Output = Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error>,
49362 > + Send;
49363 fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut;
49364 type SetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error>>
49365 + Send;
49366 fn r#set_ipv6_only(&self, value: bool) -> Self::SetIpv6OnlyResponseFut;
49367 type GetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error>>
49368 + Send;
49369 fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut;
49370 type SetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
49371 Output = Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error>,
49372 > + Send;
49373 fn r#set_ipv6_receive_traffic_class(
49374 &self,
49375 value: bool,
49376 ) -> Self::SetIpv6ReceiveTrafficClassResponseFut;
49377 type GetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
49378 Output = Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error>,
49379 > + Send;
49380 fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut;
49381 type SetIpv6TrafficClassResponseFut: std::future::Future<
49382 Output = Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error>,
49383 > + Send;
49384 fn r#set_ipv6_traffic_class(
49385 &self,
49386 value: &OptionalUint8,
49387 ) -> Self::SetIpv6TrafficClassResponseFut;
49388 type GetIpv6TrafficClassResponseFut: std::future::Future<
49389 Output = Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error>,
49390 > + Send;
49391 fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut;
49392 type SetIpv6ReceivePacketInfoResponseFut: std::future::Future<
49393 Output = Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error>,
49394 > + Send;
49395 fn r#set_ipv6_receive_packet_info(
49396 &self,
49397 value: bool,
49398 ) -> Self::SetIpv6ReceivePacketInfoResponseFut;
49399 type GetIpv6ReceivePacketInfoResponseFut: std::future::Future<
49400 Output = Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error>,
49401 > + Send;
49402 fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut;
49403 type GetOriginalDestinationResponseFut: std::future::Future<
49404 Output = Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error>,
49405 > + Send;
49406 fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut;
49407 type DescribeResponseFut: std::future::Future<Output = Result<StreamSocketDescribeResponse, fidl::Error>>
49408 + Send;
49409 fn r#describe(&self) -> Self::DescribeResponseFut;
49410 type ListenResponseFut: std::future::Future<Output = Result<StreamSocketListenResult, fidl::Error>>
49411 + Send;
49412 fn r#listen(&self, backlog: i16) -> Self::ListenResponseFut;
49413 type AcceptResponseFut: std::future::Future<Output = Result<StreamSocketAcceptResult, fidl::Error>>
49414 + Send;
49415 fn r#accept(&self, want_addr: bool) -> Self::AcceptResponseFut;
49416 type GetInfoResponseFut: std::future::Future<Output = Result<StreamSocketGetInfoResult, fidl::Error>>
49417 + Send;
49418 fn r#get_info(&self) -> Self::GetInfoResponseFut;
49419 type SetTcpNoDelayResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpNoDelayResult, fidl::Error>>
49420 + Send;
49421 fn r#set_tcp_no_delay(&self, value: bool) -> Self::SetTcpNoDelayResponseFut;
49422 type GetTcpNoDelayResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpNoDelayResult, fidl::Error>>
49423 + Send;
49424 fn r#get_tcp_no_delay(&self) -> Self::GetTcpNoDelayResponseFut;
49425 type SetTcpMaxSegmentResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpMaxSegmentResult, fidl::Error>>
49426 + Send;
49427 fn r#set_tcp_max_segment(&self, value_bytes: u32) -> Self::SetTcpMaxSegmentResponseFut;
49428 type GetTcpMaxSegmentResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpMaxSegmentResult, fidl::Error>>
49429 + Send;
49430 fn r#get_tcp_max_segment(&self) -> Self::GetTcpMaxSegmentResponseFut;
49431 type SetTcpCorkResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpCorkResult, fidl::Error>>
49432 + Send;
49433 fn r#set_tcp_cork(&self, value: bool) -> Self::SetTcpCorkResponseFut;
49434 type GetTcpCorkResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpCorkResult, fidl::Error>>
49435 + Send;
49436 fn r#get_tcp_cork(&self) -> Self::GetTcpCorkResponseFut;
49437 type SetTcpKeepAliveIdleResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpKeepAliveIdleResult, fidl::Error>>
49438 + Send;
49439 fn r#set_tcp_keep_alive_idle(&self, value_secs: u32) -> Self::SetTcpKeepAliveIdleResponseFut;
49440 type GetTcpKeepAliveIdleResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpKeepAliveIdleResult, fidl::Error>>
49441 + Send;
49442 fn r#get_tcp_keep_alive_idle(&self) -> Self::GetTcpKeepAliveIdleResponseFut;
49443 type SetTcpKeepAliveIntervalResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpKeepAliveIntervalResult, fidl::Error>>
49444 + Send;
49445 fn r#set_tcp_keep_alive_interval(
49446 &self,
49447 value_secs: u32,
49448 ) -> Self::SetTcpKeepAliveIntervalResponseFut;
49449 type GetTcpKeepAliveIntervalResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpKeepAliveIntervalResult, fidl::Error>>
49450 + Send;
49451 fn r#get_tcp_keep_alive_interval(&self) -> Self::GetTcpKeepAliveIntervalResponseFut;
49452 type SetTcpKeepAliveCountResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpKeepAliveCountResult, fidl::Error>>
49453 + Send;
49454 fn r#set_tcp_keep_alive_count(&self, value: u32) -> Self::SetTcpKeepAliveCountResponseFut;
49455 type GetTcpKeepAliveCountResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpKeepAliveCountResult, fidl::Error>>
49456 + Send;
49457 fn r#get_tcp_keep_alive_count(&self) -> Self::GetTcpKeepAliveCountResponseFut;
49458 type SetTcpSynCountResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpSynCountResult, fidl::Error>>
49459 + Send;
49460 fn r#set_tcp_syn_count(&self, value: u32) -> Self::SetTcpSynCountResponseFut;
49461 type GetTcpSynCountResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpSynCountResult, fidl::Error>>
49462 + Send;
49463 fn r#get_tcp_syn_count(&self) -> Self::GetTcpSynCountResponseFut;
49464 type SetTcpLingerResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpLingerResult, fidl::Error>>
49465 + Send;
49466 fn r#set_tcp_linger(&self, value_secs: &OptionalUint32) -> Self::SetTcpLingerResponseFut;
49467 type GetTcpLingerResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpLingerResult, fidl::Error>>
49468 + Send;
49469 fn r#get_tcp_linger(&self) -> Self::GetTcpLingerResponseFut;
49470 type SetTcpDeferAcceptResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpDeferAcceptResult, fidl::Error>>
49471 + Send;
49472 fn r#set_tcp_defer_accept(&self, value_secs: u32) -> Self::SetTcpDeferAcceptResponseFut;
49473 type GetTcpDeferAcceptResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpDeferAcceptResult, fidl::Error>>
49474 + Send;
49475 fn r#get_tcp_defer_accept(&self) -> Self::GetTcpDeferAcceptResponseFut;
49476 type SetTcpWindowClampResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpWindowClampResult, fidl::Error>>
49477 + Send;
49478 fn r#set_tcp_window_clamp(&self, value: u32) -> Self::SetTcpWindowClampResponseFut;
49479 type GetTcpWindowClampResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpWindowClampResult, fidl::Error>>
49480 + Send;
49481 fn r#get_tcp_window_clamp(&self) -> Self::GetTcpWindowClampResponseFut;
49482 type GetTcpInfoResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpInfoResult, fidl::Error>>
49483 + Send;
49484 fn r#get_tcp_info(&self) -> Self::GetTcpInfoResponseFut;
49485 type SetTcpQuickAckResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpQuickAckResult, fidl::Error>>
49486 + Send;
49487 fn r#set_tcp_quick_ack(&self, value: bool) -> Self::SetTcpQuickAckResponseFut;
49488 type GetTcpQuickAckResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpQuickAckResult, fidl::Error>>
49489 + Send;
49490 fn r#get_tcp_quick_ack(&self) -> Self::GetTcpQuickAckResponseFut;
49491 type SetTcpCongestionResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpCongestionResult, fidl::Error>>
49492 + Send;
49493 fn r#set_tcp_congestion(
49494 &self,
49495 value: TcpCongestionControl,
49496 ) -> Self::SetTcpCongestionResponseFut;
49497 type GetTcpCongestionResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpCongestionResult, fidl::Error>>
49498 + Send;
49499 fn r#get_tcp_congestion(&self) -> Self::GetTcpCongestionResponseFut;
49500 type SetTcpUserTimeoutResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpUserTimeoutResult, fidl::Error>>
49501 + Send;
49502 fn r#set_tcp_user_timeout(&self, value_millis: u32) -> Self::SetTcpUserTimeoutResponseFut;
49503 type GetTcpUserTimeoutResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpUserTimeoutResult, fidl::Error>>
49504 + Send;
49505 fn r#get_tcp_user_timeout(&self) -> Self::GetTcpUserTimeoutResponseFut;
49506}
49507#[derive(Debug)]
49508#[cfg(target_os = "fuchsia")]
49509pub struct StreamSocketSynchronousProxy {
49510 client: fidl::client::sync::Client,
49511}
49512
49513#[cfg(target_os = "fuchsia")]
49514impl fidl::endpoints::SynchronousProxy for StreamSocketSynchronousProxy {
49515 type Proxy = StreamSocketProxy;
49516 type Protocol = StreamSocketMarker;
49517
49518 fn from_channel(inner: fidl::Channel) -> Self {
49519 Self::new(inner)
49520 }
49521
49522 fn into_channel(self) -> fidl::Channel {
49523 self.client.into_channel()
49524 }
49525
49526 fn as_channel(&self) -> &fidl::Channel {
49527 self.client.as_channel()
49528 }
49529}
49530
49531#[cfg(target_os = "fuchsia")]
49532impl StreamSocketSynchronousProxy {
49533 pub fn new(channel: fidl::Channel) -> Self {
49534 let protocol_name = <StreamSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
49535 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
49536 }
49537
49538 pub fn into_channel(self) -> fidl::Channel {
49539 self.client.into_channel()
49540 }
49541
49542 pub fn wait_for_event(
49545 &self,
49546 deadline: zx::MonotonicInstant,
49547 ) -> Result<StreamSocketEvent, fidl::Error> {
49548 StreamSocketEvent::decode(self.client.wait_for_event(deadline)?)
49549 }
49550
49551 pub fn r#clone(
49552 &self,
49553 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
49554 ) -> Result<(), fidl::Error> {
49555 self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
49556 (request,),
49557 0x20d8a7aba2168a79,
49558 fidl::encoding::DynamicFlags::empty(),
49559 )
49560 }
49561
49562 pub fn r#close(
49573 &self,
49574 ___deadline: zx::MonotonicInstant,
49575 ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
49576 let _response = self.client.send_query::<
49577 fidl::encoding::EmptyPayload,
49578 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
49579 >(
49580 (),
49581 0x5ac5d459ad7f657e,
49582 fidl::encoding::DynamicFlags::empty(),
49583 ___deadline,
49584 )?;
49585 Ok(_response.map(|x| x))
49586 }
49587
49588 pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
49589 let _response = self.client.send_query::<
49590 fidl::encoding::EmptyPayload,
49591 fidl_fuchsia_unknown::QueryableQueryResponse,
49592 >(
49593 (),
49594 0x2658edee9decfc06,
49595 fidl::encoding::DynamicFlags::empty(),
49596 ___deadline,
49597 )?;
49598 Ok(_response.protocol)
49599 }
49600
49601 pub fn r#set_reuse_address(
49603 &self,
49604 mut value: bool,
49605 ___deadline: zx::MonotonicInstant,
49606 ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
49607 let _response =
49608 self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
49609 fidl::encoding::EmptyStruct,
49610 fidl_fuchsia_posix::Errno,
49611 >>(
49612 (value,),
49613 0x1fd74ee8b9a4a876,
49614 fidl::encoding::DynamicFlags::empty(),
49615 ___deadline,
49616 )?;
49617 Ok(_response.map(|x| x))
49618 }
49619
49620 pub fn r#get_reuse_address(
49622 &self,
49623 ___deadline: zx::MonotonicInstant,
49624 ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
49625 let _response = self
49626 .client
49627 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49628 BaseSocketGetReuseAddressResponse,
49629 fidl_fuchsia_posix::Errno,
49630 >>(
49631 (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
49632 )?;
49633 Ok(_response.map(|x| x.value))
49634 }
49635
49636 pub fn r#get_error(
49639 &self,
49640 ___deadline: zx::MonotonicInstant,
49641 ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
49642 let _response =
49643 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49644 fidl::encoding::EmptyStruct,
49645 fidl_fuchsia_posix::Errno,
49646 >>(
49647 (),
49648 0x5aad39b33e5f6ebb,
49649 fidl::encoding::DynamicFlags::empty(),
49650 ___deadline,
49651 )?;
49652 Ok(_response.map(|x| x))
49653 }
49654
49655 pub fn r#set_broadcast(
49657 &self,
49658 mut value: bool,
49659 ___deadline: zx::MonotonicInstant,
49660 ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
49661 let _response =
49662 self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
49663 fidl::encoding::EmptyStruct,
49664 fidl_fuchsia_posix::Errno,
49665 >>(
49666 (value,),
49667 0x6023e081ce3cd947,
49668 fidl::encoding::DynamicFlags::empty(),
49669 ___deadline,
49670 )?;
49671 Ok(_response.map(|x| x))
49672 }
49673
49674 pub fn r#get_broadcast(
49676 &self,
49677 ___deadline: zx::MonotonicInstant,
49678 ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
49679 let _response =
49680 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49681 BaseSocketGetBroadcastResponse,
49682 fidl_fuchsia_posix::Errno,
49683 >>(
49684 (),
49685 0x68796fc556f9780d,
49686 fidl::encoding::DynamicFlags::empty(),
49687 ___deadline,
49688 )?;
49689 Ok(_response.map(|x| x.value))
49690 }
49691
49692 pub fn r#set_send_buffer(
49694 &self,
49695 mut value_bytes: u64,
49696 ___deadline: zx::MonotonicInstant,
49697 ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
49698 let _response =
49699 self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
49700 fidl::encoding::EmptyStruct,
49701 fidl_fuchsia_posix::Errno,
49702 >>(
49703 (value_bytes,),
49704 0x756eac32d73a7a70,
49705 fidl::encoding::DynamicFlags::empty(),
49706 ___deadline,
49707 )?;
49708 Ok(_response.map(|x| x))
49709 }
49710
49711 pub fn r#get_send_buffer(
49713 &self,
49714 ___deadline: zx::MonotonicInstant,
49715 ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
49716 let _response = self
49717 .client
49718 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49719 BaseSocketGetSendBufferResponse,
49720 fidl_fuchsia_posix::Errno,
49721 >>(
49722 (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
49723 )?;
49724 Ok(_response.map(|x| x.value_bytes))
49725 }
49726
49727 pub fn r#set_receive_buffer(
49729 &self,
49730 mut value_bytes: u64,
49731 ___deadline: zx::MonotonicInstant,
49732 ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
49733 let _response =
49734 self.client
49735 .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
49736 fidl::encoding::EmptyStruct,
49737 fidl_fuchsia_posix::Errno,
49738 >>(
49739 (value_bytes,),
49740 0x6b0cf2f1919c7001,
49741 fidl::encoding::DynamicFlags::empty(),
49742 ___deadline,
49743 )?;
49744 Ok(_response.map(|x| x))
49745 }
49746
49747 pub fn r#get_receive_buffer(
49749 &self,
49750 ___deadline: zx::MonotonicInstant,
49751 ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
49752 let _response = self
49753 .client
49754 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49755 BaseSocketGetReceiveBufferResponse,
49756 fidl_fuchsia_posix::Errno,
49757 >>(
49758 (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
49759 )?;
49760 Ok(_response.map(|x| x.value_bytes))
49761 }
49762
49763 pub fn r#set_keep_alive(
49765 &self,
49766 mut value: bool,
49767 ___deadline: zx::MonotonicInstant,
49768 ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
49769 let _response =
49770 self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
49771 fidl::encoding::EmptyStruct,
49772 fidl_fuchsia_posix::Errno,
49773 >>(
49774 (value,),
49775 0x572df8f0b920d2c7,
49776 fidl::encoding::DynamicFlags::empty(),
49777 ___deadline,
49778 )?;
49779 Ok(_response.map(|x| x))
49780 }
49781
49782 pub fn r#get_keep_alive(
49784 &self,
49785 ___deadline: zx::MonotonicInstant,
49786 ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
49787 let _response =
49788 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49789 BaseSocketGetKeepAliveResponse,
49790 fidl_fuchsia_posix::Errno,
49791 >>(
49792 (),
49793 0x2dd29d3215f2c9d2,
49794 fidl::encoding::DynamicFlags::empty(),
49795 ___deadline,
49796 )?;
49797 Ok(_response.map(|x| x.value))
49798 }
49799
49800 pub fn r#set_out_of_band_inline(
49802 &self,
49803 mut value: bool,
49804 ___deadline: zx::MonotonicInstant,
49805 ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
49806 let _response =
49807 self.client
49808 .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
49809 fidl::encoding::EmptyStruct,
49810 fidl_fuchsia_posix::Errno,
49811 >>(
49812 (value,),
49813 0x3ecb49968bee439,
49814 fidl::encoding::DynamicFlags::empty(),
49815 ___deadline,
49816 )?;
49817 Ok(_response.map(|x| x))
49818 }
49819
49820 pub fn r#get_out_of_band_inline(
49822 &self,
49823 ___deadline: zx::MonotonicInstant,
49824 ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
49825 let _response = self
49826 .client
49827 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49828 BaseSocketGetOutOfBandInlineResponse,
49829 fidl_fuchsia_posix::Errno,
49830 >>(
49831 (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
49832 )?;
49833 Ok(_response.map(|x| x.value))
49834 }
49835
49836 pub fn r#set_no_check(
49838 &self,
49839 mut value: bool,
49840 ___deadline: zx::MonotonicInstant,
49841 ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
49842 let _response =
49843 self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
49844 fidl::encoding::EmptyStruct,
49845 fidl_fuchsia_posix::Errno,
49846 >>(
49847 (value,),
49848 0x6bbf00c53a4c78c2,
49849 fidl::encoding::DynamicFlags::empty(),
49850 ___deadline,
49851 )?;
49852 Ok(_response.map(|x| x))
49853 }
49854
49855 pub fn r#get_no_check(
49857 &self,
49858 ___deadline: zx::MonotonicInstant,
49859 ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
49860 let _response =
49861 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49862 BaseSocketGetNoCheckResponse,
49863 fidl_fuchsia_posix::Errno,
49864 >>(
49865 (),
49866 0x2cd4249286417694,
49867 fidl::encoding::DynamicFlags::empty(),
49868 ___deadline,
49869 )?;
49870 Ok(_response.map(|x| x.value))
49871 }
49872
49873 pub fn r#set_linger(
49875 &self,
49876 mut linger: bool,
49877 mut length_secs: u32,
49878 ___deadline: zx::MonotonicInstant,
49879 ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
49880 let _response =
49881 self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
49882 fidl::encoding::EmptyStruct,
49883 fidl_fuchsia_posix::Errno,
49884 >>(
49885 (linger, length_secs),
49886 0x45386351246e998e,
49887 fidl::encoding::DynamicFlags::empty(),
49888 ___deadline,
49889 )?;
49890 Ok(_response.map(|x| x))
49891 }
49892
49893 pub fn r#get_linger(
49895 &self,
49896 ___deadline: zx::MonotonicInstant,
49897 ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
49898 let _response =
49899 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49900 BaseSocketGetLingerResponse,
49901 fidl_fuchsia_posix::Errno,
49902 >>(
49903 (),
49904 0x48eb20fc5ccb0e45,
49905 fidl::encoding::DynamicFlags::empty(),
49906 ___deadline,
49907 )?;
49908 Ok(_response.map(|x| (x.linger, x.length_secs)))
49909 }
49910
49911 pub fn r#set_reuse_port(
49913 &self,
49914 mut value: bool,
49915 ___deadline: zx::MonotonicInstant,
49916 ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
49917 let _response =
49918 self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
49919 fidl::encoding::EmptyStruct,
49920 fidl_fuchsia_posix::Errno,
49921 >>(
49922 (value,),
49923 0x24dd3e5cb36d9ccb,
49924 fidl::encoding::DynamicFlags::empty(),
49925 ___deadline,
49926 )?;
49927 Ok(_response.map(|x| x))
49928 }
49929
49930 pub fn r#get_reuse_port(
49932 &self,
49933 ___deadline: zx::MonotonicInstant,
49934 ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
49935 let _response =
49936 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49937 BaseSocketGetReusePortResponse,
49938 fidl_fuchsia_posix::Errno,
49939 >>(
49940 (),
49941 0x7a112c1ab54ff828,
49942 fidl::encoding::DynamicFlags::empty(),
49943 ___deadline,
49944 )?;
49945 Ok(_response.map(|x| x.value))
49946 }
49947
49948 pub fn r#get_accept_conn(
49950 &self,
49951 ___deadline: zx::MonotonicInstant,
49952 ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
49953 let _response = self
49954 .client
49955 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49956 BaseSocketGetAcceptConnResponse,
49957 fidl_fuchsia_posix::Errno,
49958 >>(
49959 (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
49960 )?;
49961 Ok(_response.map(|x| x.value))
49962 }
49963
49964 pub fn r#set_bind_to_device(
49966 &self,
49967 mut value: &str,
49968 ___deadline: zx::MonotonicInstant,
49969 ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
49970 let _response =
49971 self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
49972 fidl::encoding::EmptyStruct,
49973 fidl_fuchsia_posix::Errno,
49974 >>(
49975 (value,),
49976 0x2118b483f28aafc4,
49977 fidl::encoding::DynamicFlags::empty(),
49978 ___deadline,
49979 )?;
49980 Ok(_response.map(|x| x))
49981 }
49982
49983 pub fn r#get_bind_to_device(
49985 &self,
49986 ___deadline: zx::MonotonicInstant,
49987 ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
49988 let _response = self
49989 .client
49990 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49991 BaseSocketGetBindToDeviceResponse,
49992 fidl_fuchsia_posix::Errno,
49993 >>(
49994 (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
49995 )?;
49996 Ok(_response.map(|x| x.value))
49997 }
49998
49999 pub fn r#set_bind_to_interface_index(
50002 &self,
50003 mut value: u64,
50004 ___deadline: zx::MonotonicInstant,
50005 ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
50006 let _response =
50007 self.client
50008 .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
50009 fidl::encoding::EmptyStruct,
50010 fidl_fuchsia_posix::Errno,
50011 >>(
50012 (value,),
50013 0x6e387a0def00821,
50014 fidl::encoding::DynamicFlags::empty(),
50015 ___deadline,
50016 )?;
50017 Ok(_response.map(|x| x))
50018 }
50019
50020 pub fn r#get_bind_to_interface_index(
50022 &self,
50023 ___deadline: zx::MonotonicInstant,
50024 ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
50025 let _response = self
50026 .client
50027 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50028 BaseSocketGetBindToInterfaceIndexResponse,
50029 fidl_fuchsia_posix::Errno,
50030 >>(
50031 (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
50032 )?;
50033 Ok(_response.map(|x| x.value))
50034 }
50035
50036 pub fn r#set_timestamp(
50038 &self,
50039 mut value: TimestampOption,
50040 ___deadline: zx::MonotonicInstant,
50041 ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
50042 let _response =
50043 self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
50044 fidl::encoding::EmptyStruct,
50045 fidl_fuchsia_posix::Errno,
50046 >>(
50047 (value,),
50048 0x285d6516c263d839,
50049 fidl::encoding::DynamicFlags::empty(),
50050 ___deadline,
50051 )?;
50052 Ok(_response.map(|x| x))
50053 }
50054
50055 pub fn r#get_timestamp(
50057 &self,
50058 ___deadline: zx::MonotonicInstant,
50059 ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
50060 let _response =
50061 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50062 BaseSocketGetTimestampResponse,
50063 fidl_fuchsia_posix::Errno,
50064 >>(
50065 (),
50066 0x49f2fffbbcc2bd27,
50067 fidl::encoding::DynamicFlags::empty(),
50068 ___deadline,
50069 )?;
50070 Ok(_response.map(|x| x.value))
50071 }
50072
50073 pub fn r#set_mark(
50077 &self,
50078 mut domain: fidl_fuchsia_net::MarkDomain,
50079 mut mark: &OptionalUint32,
50080 ___deadline: zx::MonotonicInstant,
50081 ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
50082 let _response =
50083 self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
50084 fidl::encoding::EmptyStruct,
50085 fidl_fuchsia_posix::Errno,
50086 >>(
50087 (domain, mark),
50088 0x6ead6de09f653236,
50089 fidl::encoding::DynamicFlags::empty(),
50090 ___deadline,
50091 )?;
50092 Ok(_response.map(|x| x))
50093 }
50094
50095 pub fn r#get_mark(
50099 &self,
50100 mut domain: fidl_fuchsia_net::MarkDomain,
50101 ___deadline: zx::MonotonicInstant,
50102 ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
50103 let _response =
50104 self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
50105 BaseSocketGetMarkResponse,
50106 fidl_fuchsia_posix::Errno,
50107 >>(
50108 (domain,),
50109 0x57a2752c61d93d47,
50110 fidl::encoding::DynamicFlags::empty(),
50111 ___deadline,
50112 )?;
50113 Ok(_response.map(|x| x.mark))
50114 }
50115
50116 pub fn r#bind(
50118 &self,
50119 mut addr: &fidl_fuchsia_net::SocketAddress,
50120 ___deadline: zx::MonotonicInstant,
50121 ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
50122 let _response =
50123 self.client.send_query::<BaseNetworkSocketBindRequest, fidl::encoding::ResultType<
50124 fidl::encoding::EmptyStruct,
50125 fidl_fuchsia_posix::Errno,
50126 >>(
50127 (addr,),
50128 0x4bc6400ae92125d,
50129 fidl::encoding::DynamicFlags::empty(),
50130 ___deadline,
50131 )?;
50132 Ok(_response.map(|x| x))
50133 }
50134
50135 pub fn r#connect(
50137 &self,
50138 mut addr: &fidl_fuchsia_net::SocketAddress,
50139 ___deadline: zx::MonotonicInstant,
50140 ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
50141 let _response =
50142 self.client.send_query::<BaseNetworkSocketConnectRequest, fidl::encoding::ResultType<
50143 fidl::encoding::EmptyStruct,
50144 fidl_fuchsia_posix::Errno,
50145 >>(
50146 (addr,),
50147 0x5f05f19bfdd38871,
50148 fidl::encoding::DynamicFlags::empty(),
50149 ___deadline,
50150 )?;
50151 Ok(_response.map(|x| x))
50152 }
50153
50154 pub fn r#disconnect(
50156 &self,
50157 ___deadline: zx::MonotonicInstant,
50158 ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
50159 let _response =
50160 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50161 fidl::encoding::EmptyStruct,
50162 fidl_fuchsia_posix::Errno,
50163 >>(
50164 (),
50165 0x74e63b91f7b29b2,
50166 fidl::encoding::DynamicFlags::empty(),
50167 ___deadline,
50168 )?;
50169 Ok(_response.map(|x| x))
50170 }
50171
50172 pub fn r#get_sock_name(
50174 &self,
50175 ___deadline: zx::MonotonicInstant,
50176 ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
50177 let _response = self
50178 .client
50179 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50180 BaseNetworkSocketGetSockNameResponse,
50181 fidl_fuchsia_posix::Errno,
50182 >>(
50183 (), 0x475f23f84a1a4f85, fidl::encoding::DynamicFlags::empty(), ___deadline
50184 )?;
50185 Ok(_response.map(|x| x.addr))
50186 }
50187
50188 pub fn r#get_peer_name(
50190 &self,
50191 ___deadline: zx::MonotonicInstant,
50192 ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
50193 let _response = self
50194 .client
50195 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50196 BaseNetworkSocketGetPeerNameResponse,
50197 fidl_fuchsia_posix::Errno,
50198 >>(
50199 (), 0x1ffecf4bd5b6432e, fidl::encoding::DynamicFlags::empty(), ___deadline
50200 )?;
50201 Ok(_response.map(|x| x.addr))
50202 }
50203
50204 pub fn r#shutdown(
50206 &self,
50207 mut mode: ShutdownMode,
50208 ___deadline: zx::MonotonicInstant,
50209 ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
50210 let _response =
50211 self.client.send_query::<BaseNetworkSocketShutdownRequest, fidl::encoding::ResultType<
50212 fidl::encoding::EmptyStruct,
50213 fidl_fuchsia_posix::Errno,
50214 >>(
50215 (mode,),
50216 0x247f38b6db68c336,
50217 fidl::encoding::DynamicFlags::empty(),
50218 ___deadline,
50219 )?;
50220 Ok(_response.map(|x| x))
50221 }
50222
50223 pub fn r#set_ip_type_of_service(
50225 &self,
50226 mut value: u8,
50227 ___deadline: zx::MonotonicInstant,
50228 ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
50229 let _response = self.client.send_query::<
50230 BaseNetworkSocketSetIpTypeOfServiceRequest,
50231 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50232 >(
50233 (value,),
50234 0x995c600475b6d46,
50235 fidl::encoding::DynamicFlags::empty(),
50236 ___deadline,
50237 )?;
50238 Ok(_response.map(|x| x))
50239 }
50240
50241 pub fn r#get_ip_type_of_service(
50243 &self,
50244 ___deadline: zx::MonotonicInstant,
50245 ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
50246 let _response = self
50247 .client
50248 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50249 BaseNetworkSocketGetIpTypeOfServiceResponse,
50250 fidl_fuchsia_posix::Errno,
50251 >>(
50252 (), 0x3814a04259f75fcb, fidl::encoding::DynamicFlags::empty(), ___deadline
50253 )?;
50254 Ok(_response.map(|x| x.value))
50255 }
50256
50257 pub fn r#set_ip_ttl(
50259 &self,
50260 mut value: &OptionalUint8,
50261 ___deadline: zx::MonotonicInstant,
50262 ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
50263 let _response =
50264 self.client.send_query::<BaseNetworkSocketSetIpTtlRequest, fidl::encoding::ResultType<
50265 fidl::encoding::EmptyStruct,
50266 fidl_fuchsia_posix::Errno,
50267 >>(
50268 (value,),
50269 0x29e2424b433ae1ef,
50270 fidl::encoding::DynamicFlags::empty(),
50271 ___deadline,
50272 )?;
50273 Ok(_response.map(|x| x))
50274 }
50275
50276 pub fn r#get_ip_ttl(
50278 &self,
50279 ___deadline: zx::MonotonicInstant,
50280 ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
50281 let _response = self
50282 .client
50283 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50284 BaseNetworkSocketGetIpTtlResponse,
50285 fidl_fuchsia_posix::Errno,
50286 >>(
50287 (), 0x47e47fa1f24da471, fidl::encoding::DynamicFlags::empty(), ___deadline
50288 )?;
50289 Ok(_response.map(|x| x.value))
50290 }
50291
50292 pub fn r#set_ip_packet_info(
50294 &self,
50295 mut value: bool,
50296 ___deadline: zx::MonotonicInstant,
50297 ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
50298 let _response =
50299 self.client
50300 .send_query::<BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::ResultType<
50301 fidl::encoding::EmptyStruct,
50302 fidl_fuchsia_posix::Errno,
50303 >>(
50304 (value,),
50305 0x392d16bee20c0e16,
50306 fidl::encoding::DynamicFlags::empty(),
50307 ___deadline,
50308 )?;
50309 Ok(_response.map(|x| x))
50310 }
50311
50312 pub fn r#get_ip_packet_info(
50314 &self,
50315 ___deadline: zx::MonotonicInstant,
50316 ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
50317 let _response = self
50318 .client
50319 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50320 BaseNetworkSocketGetIpPacketInfoResponse,
50321 fidl_fuchsia_posix::Errno,
50322 >>(
50323 (), 0x54b505f242280740, fidl::encoding::DynamicFlags::empty(), ___deadline
50324 )?;
50325 Ok(_response.map(|x| x.value))
50326 }
50327
50328 pub fn r#set_ip_receive_type_of_service(
50330 &self,
50331 mut value: bool,
50332 ___deadline: zx::MonotonicInstant,
50333 ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
50334 let _response = self.client.send_query::<
50335 BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
50336 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50337 >(
50338 (value,),
50339 0x6c4f6714995f84ef,
50340 fidl::encoding::DynamicFlags::empty(),
50341 ___deadline,
50342 )?;
50343 Ok(_response.map(|x| x))
50344 }
50345
50346 pub fn r#get_ip_receive_type_of_service(
50348 &self,
50349 ___deadline: zx::MonotonicInstant,
50350 ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
50351 let _response = self
50352 .client
50353 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50354 BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
50355 fidl_fuchsia_posix::Errno,
50356 >>(
50357 (), 0x4158ba7dc2795960, fidl::encoding::DynamicFlags::empty(), ___deadline
50358 )?;
50359 Ok(_response.map(|x| x.value))
50360 }
50361
50362 pub fn r#set_ip_receive_ttl(
50364 &self,
50365 mut value: bool,
50366 ___deadline: zx::MonotonicInstant,
50367 ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
50368 let _response =
50369 self.client
50370 .send_query::<BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::ResultType<
50371 fidl::encoding::EmptyStruct,
50372 fidl_fuchsia_posix::Errno,
50373 >>(
50374 (value,),
50375 0x46f15be0ce0ab82b,
50376 fidl::encoding::DynamicFlags::empty(),
50377 ___deadline,
50378 )?;
50379 Ok(_response.map(|x| x))
50380 }
50381
50382 pub fn r#get_ip_receive_ttl(
50384 &self,
50385 ___deadline: zx::MonotonicInstant,
50386 ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
50387 let _response = self
50388 .client
50389 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50390 BaseNetworkSocketGetIpReceiveTtlResponse,
50391 fidl_fuchsia_posix::Errno,
50392 >>(
50393 (), 0x678ddd5a5dfa2eb5, fidl::encoding::DynamicFlags::empty(), ___deadline
50394 )?;
50395 Ok(_response.map(|x| x.value))
50396 }
50397
50398 pub fn r#set_ip_multicast_interface(
50400 &self,
50401 mut iface: u64,
50402 mut address: &fidl_fuchsia_net::Ipv4Address,
50403 ___deadline: zx::MonotonicInstant,
50404 ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
50405 let _response = self.client.send_query::<
50406 BaseNetworkSocketSetIpMulticastInterfaceRequest,
50407 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50408 >(
50409 (iface, address,),
50410 0x752fbfa9b12befe,
50411 fidl::encoding::DynamicFlags::empty(),
50412 ___deadline,
50413 )?;
50414 Ok(_response.map(|x| x))
50415 }
50416
50417 pub fn r#get_ip_multicast_interface(
50419 &self,
50420 ___deadline: zx::MonotonicInstant,
50421 ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
50422 let _response = self
50423 .client
50424 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50425 BaseNetworkSocketGetIpMulticastInterfaceResponse,
50426 fidl_fuchsia_posix::Errno,
50427 >>(
50428 (), 0x320bd14c4df046c4, fidl::encoding::DynamicFlags::empty(), ___deadline
50429 )?;
50430 Ok(_response.map(|x| x.value))
50431 }
50432
50433 pub fn r#set_ip_multicast_ttl(
50435 &self,
50436 mut value: &OptionalUint8,
50437 ___deadline: zx::MonotonicInstant,
50438 ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
50439 let _response =
50440 self.client
50441 .send_query::<BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::ResultType<
50442 fidl::encoding::EmptyStruct,
50443 fidl_fuchsia_posix::Errno,
50444 >>(
50445 (value,),
50446 0x63134d53772916a1,
50447 fidl::encoding::DynamicFlags::empty(),
50448 ___deadline,
50449 )?;
50450 Ok(_response.map(|x| x))
50451 }
50452
50453 pub fn r#get_ip_multicast_ttl(
50455 &self,
50456 ___deadline: zx::MonotonicInstant,
50457 ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
50458 let _response = self
50459 .client
50460 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50461 BaseNetworkSocketGetIpMulticastTtlResponse,
50462 fidl_fuchsia_posix::Errno,
50463 >>(
50464 (), 0x4665cd378f39e1a, fidl::encoding::DynamicFlags::empty(), ___deadline
50465 )?;
50466 Ok(_response.map(|x| x.value))
50467 }
50468
50469 pub fn r#set_ip_multicast_loopback(
50471 &self,
50472 mut value: bool,
50473 ___deadline: zx::MonotonicInstant,
50474 ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
50475 let _response = self.client.send_query::<
50476 BaseNetworkSocketSetIpMulticastLoopbackRequest,
50477 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50478 >(
50479 (value,),
50480 0x20c55c11f00943ea,
50481 fidl::encoding::DynamicFlags::empty(),
50482 ___deadline,
50483 )?;
50484 Ok(_response.map(|x| x))
50485 }
50486
50487 pub fn r#get_ip_multicast_loopback(
50489 &self,
50490 ___deadline: zx::MonotonicInstant,
50491 ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
50492 let _response = self
50493 .client
50494 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50495 BaseNetworkSocketGetIpMulticastLoopbackResponse,
50496 fidl_fuchsia_posix::Errno,
50497 >>(
50498 (), 0x3b6b26ff558298f2, fidl::encoding::DynamicFlags::empty(), ___deadline
50499 )?;
50500 Ok(_response.map(|x| x.value))
50501 }
50502
50503 pub fn r#add_ip_membership(
50505 &self,
50506 mut membership: &IpMulticastMembership,
50507 ___deadline: zx::MonotonicInstant,
50508 ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
50509 let _response =
50510 self.client
50511 .send_query::<BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::ResultType<
50512 fidl::encoding::EmptyStruct,
50513 fidl_fuchsia_posix::Errno,
50514 >>(
50515 (membership,),
50516 0x76bc7df115a3b4d0,
50517 fidl::encoding::DynamicFlags::empty(),
50518 ___deadline,
50519 )?;
50520 Ok(_response.map(|x| x))
50521 }
50522
50523 pub fn r#drop_ip_membership(
50525 &self,
50526 mut membership: &IpMulticastMembership,
50527 ___deadline: zx::MonotonicInstant,
50528 ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
50529 let _response =
50530 self.client
50531 .send_query::<BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::ResultType<
50532 fidl::encoding::EmptyStruct,
50533 fidl_fuchsia_posix::Errno,
50534 >>(
50535 (membership,),
50536 0x2888f3099188d03,
50537 fidl::encoding::DynamicFlags::empty(),
50538 ___deadline,
50539 )?;
50540 Ok(_response.map(|x| x))
50541 }
50542
50543 pub fn r#set_ip_transparent(
50545 &self,
50546 mut value: bool,
50547 ___deadline: zx::MonotonicInstant,
50548 ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
50549 let _response =
50550 self.client
50551 .send_query::<BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::ResultType<
50552 fidl::encoding::EmptyStruct,
50553 fidl_fuchsia_posix::Errno,
50554 >>(
50555 (value,),
50556 0x1ae532b0c066e3a0,
50557 fidl::encoding::DynamicFlags::empty(),
50558 ___deadline,
50559 )?;
50560 Ok(_response.map(|x| x))
50561 }
50562
50563 pub fn r#get_ip_transparent(
50565 &self,
50566 ___deadline: zx::MonotonicInstant,
50567 ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
50568 let _response = self
50569 .client
50570 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50571 BaseNetworkSocketGetIpTransparentResponse,
50572 fidl_fuchsia_posix::Errno,
50573 >>(
50574 (), 0x51d43695962ebfb5, fidl::encoding::DynamicFlags::empty(), ___deadline
50575 )?;
50576 Ok(_response.map(|x| x.value))
50577 }
50578
50579 pub fn r#set_ip_receive_original_destination_address(
50581 &self,
50582 mut value: bool,
50583 ___deadline: zx::MonotonicInstant,
50584 ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
50585 let _response = self.client.send_query::<
50586 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
50587 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50588 >(
50589 (value,),
50590 0x4722b4ce52f7840,
50591 fidl::encoding::DynamicFlags::empty(),
50592 ___deadline,
50593 )?;
50594 Ok(_response.map(|x| x))
50595 }
50596
50597 pub fn r#get_ip_receive_original_destination_address(
50599 &self,
50600 ___deadline: zx::MonotonicInstant,
50601 ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
50602 let _response = self
50603 .client
50604 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50605 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
50606 fidl_fuchsia_posix::Errno,
50607 >>(
50608 (), 0x2a0e7dc5d6bfdfe9, fidl::encoding::DynamicFlags::empty(), ___deadline
50609 )?;
50610 Ok(_response.map(|x| x.value))
50611 }
50612
50613 pub fn r#add_ipv6_membership(
50615 &self,
50616 mut membership: &Ipv6MulticastMembership,
50617 ___deadline: zx::MonotonicInstant,
50618 ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
50619 let _response =
50620 self.client
50621 .send_query::<BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::ResultType<
50622 fidl::encoding::EmptyStruct,
50623 fidl_fuchsia_posix::Errno,
50624 >>(
50625 (membership,),
50626 0x7c94727acb4ea4b3,
50627 fidl::encoding::DynamicFlags::empty(),
50628 ___deadline,
50629 )?;
50630 Ok(_response.map(|x| x))
50631 }
50632
50633 pub fn r#drop_ipv6_membership(
50635 &self,
50636 mut membership: &Ipv6MulticastMembership,
50637 ___deadline: zx::MonotonicInstant,
50638 ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
50639 let _response = self.client.send_query::<
50640 BaseNetworkSocketDropIpv6MembershipRequest,
50641 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50642 >(
50643 (membership,),
50644 0x42104c70ccaba304,
50645 fidl::encoding::DynamicFlags::empty(),
50646 ___deadline,
50647 )?;
50648 Ok(_response.map(|x| x))
50649 }
50650
50651 pub fn r#set_ipv6_multicast_interface(
50653 &self,
50654 mut value: u64,
50655 ___deadline: zx::MonotonicInstant,
50656 ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
50657 let _response = self.client.send_query::<
50658 BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
50659 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50660 >(
50661 (value,),
50662 0x135f76db3774ab3b,
50663 fidl::encoding::DynamicFlags::empty(),
50664 ___deadline,
50665 )?;
50666 Ok(_response.map(|x| x))
50667 }
50668
50669 pub fn r#get_ipv6_multicast_interface(
50671 &self,
50672 ___deadline: zx::MonotonicInstant,
50673 ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
50674 let _response = self
50675 .client
50676 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50677 BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
50678 fidl_fuchsia_posix::Errno,
50679 >>(
50680 (), 0x1f26fcdd348f1882, fidl::encoding::DynamicFlags::empty(), ___deadline
50681 )?;
50682 Ok(_response.map(|x| x.value))
50683 }
50684
50685 pub fn r#set_ipv6_unicast_hops(
50687 &self,
50688 mut value: &OptionalUint8,
50689 ___deadline: zx::MonotonicInstant,
50690 ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
50691 let _response = self.client.send_query::<
50692 BaseNetworkSocketSetIpv6UnicastHopsRequest,
50693 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50694 >(
50695 (value,),
50696 0x157d51e98f462859,
50697 fidl::encoding::DynamicFlags::empty(),
50698 ___deadline,
50699 )?;
50700 Ok(_response.map(|x| x))
50701 }
50702
50703 pub fn r#get_ipv6_unicast_hops(
50705 &self,
50706 ___deadline: zx::MonotonicInstant,
50707 ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
50708 let _response = self
50709 .client
50710 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50711 BaseNetworkSocketGetIpv6UnicastHopsResponse,
50712 fidl_fuchsia_posix::Errno,
50713 >>(
50714 (), 0x21f4641cad8bd8d2, fidl::encoding::DynamicFlags::empty(), ___deadline
50715 )?;
50716 Ok(_response.map(|x| x.value))
50717 }
50718
50719 pub fn r#set_ipv6_receive_hop_limit(
50721 &self,
50722 mut value: bool,
50723 ___deadline: zx::MonotonicInstant,
50724 ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
50725 let _response = self.client.send_query::<
50726 BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
50727 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50728 >(
50729 (value,),
50730 0x5c24808ed2e84a1e,
50731 fidl::encoding::DynamicFlags::empty(),
50732 ___deadline,
50733 )?;
50734 Ok(_response.map(|x| x))
50735 }
50736
50737 pub fn r#get_ipv6_receive_hop_limit(
50739 &self,
50740 ___deadline: zx::MonotonicInstant,
50741 ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
50742 let _response = self
50743 .client
50744 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50745 BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
50746 fidl_fuchsia_posix::Errno,
50747 >>(
50748 (), 0x341e06689885b4c0, fidl::encoding::DynamicFlags::empty(), ___deadline
50749 )?;
50750 Ok(_response.map(|x| x.value))
50751 }
50752
50753 pub fn r#set_ipv6_multicast_hops(
50755 &self,
50756 mut value: &OptionalUint8,
50757 ___deadline: zx::MonotonicInstant,
50758 ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
50759 let _response = self.client.send_query::<
50760 BaseNetworkSocketSetIpv6MulticastHopsRequest,
50761 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50762 >(
50763 (value,),
50764 0x25b9cd4d181f82c1,
50765 fidl::encoding::DynamicFlags::empty(),
50766 ___deadline,
50767 )?;
50768 Ok(_response.map(|x| x))
50769 }
50770
50771 pub fn r#get_ipv6_multicast_hops(
50773 &self,
50774 ___deadline: zx::MonotonicInstant,
50775 ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
50776 let _response = self
50777 .client
50778 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50779 BaseNetworkSocketGetIpv6MulticastHopsResponse,
50780 fidl_fuchsia_posix::Errno,
50781 >>(
50782 (), 0x52916948a365012a, fidl::encoding::DynamicFlags::empty(), ___deadline
50783 )?;
50784 Ok(_response.map(|x| x.value))
50785 }
50786
50787 pub fn r#set_ipv6_multicast_loopback(
50789 &self,
50790 mut value: bool,
50791 ___deadline: zx::MonotonicInstant,
50792 ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
50793 let _response = self.client.send_query::<
50794 BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
50795 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50796 >(
50797 (value,),
50798 0x55701c409ff41b40,
50799 fidl::encoding::DynamicFlags::empty(),
50800 ___deadline,
50801 )?;
50802 Ok(_response.map(|x| x))
50803 }
50804
50805 pub fn r#get_ipv6_multicast_loopback(
50807 &self,
50808 ___deadline: zx::MonotonicInstant,
50809 ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
50810 let _response = self
50811 .client
50812 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50813 BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
50814 fidl_fuchsia_posix::Errno,
50815 >>(
50816 (), 0x4415b701fde319c3, fidl::encoding::DynamicFlags::empty(), ___deadline
50817 )?;
50818 Ok(_response.map(|x| x.value))
50819 }
50820
50821 pub fn r#set_ipv6_only(
50823 &self,
50824 mut value: bool,
50825 ___deadline: zx::MonotonicInstant,
50826 ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
50827 let _response =
50828 self.client
50829 .send_query::<BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::ResultType<
50830 fidl::encoding::EmptyStruct,
50831 fidl_fuchsia_posix::Errno,
50832 >>(
50833 (value,),
50834 0x4873f1364758cbba,
50835 fidl::encoding::DynamicFlags::empty(),
50836 ___deadline,
50837 )?;
50838 Ok(_response.map(|x| x))
50839 }
50840
50841 pub fn r#get_ipv6_only(
50843 &self,
50844 ___deadline: zx::MonotonicInstant,
50845 ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
50846 let _response = self
50847 .client
50848 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50849 BaseNetworkSocketGetIpv6OnlyResponse,
50850 fidl_fuchsia_posix::Errno,
50851 >>(
50852 (), 0x4aa3340a1a26b89c, fidl::encoding::DynamicFlags::empty(), ___deadline
50853 )?;
50854 Ok(_response.map(|x| x.value))
50855 }
50856
50857 pub fn r#set_ipv6_receive_traffic_class(
50859 &self,
50860 mut value: bool,
50861 ___deadline: zx::MonotonicInstant,
50862 ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
50863 let _response = self.client.send_query::<
50864 BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
50865 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50866 >(
50867 (value,),
50868 0x58f07c8788d099a0,
50869 fidl::encoding::DynamicFlags::empty(),
50870 ___deadline,
50871 )?;
50872 Ok(_response.map(|x| x))
50873 }
50874
50875 pub fn r#get_ipv6_receive_traffic_class(
50877 &self,
50878 ___deadline: zx::MonotonicInstant,
50879 ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
50880 let _response = self
50881 .client
50882 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50883 BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
50884 fidl_fuchsia_posix::Errno,
50885 >>(
50886 (), 0x2e334df1da553ffa, fidl::encoding::DynamicFlags::empty(), ___deadline
50887 )?;
50888 Ok(_response.map(|x| x.value))
50889 }
50890
50891 pub fn r#set_ipv6_traffic_class(
50893 &self,
50894 mut value: &OptionalUint8,
50895 ___deadline: zx::MonotonicInstant,
50896 ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
50897 let _response = self.client.send_query::<
50898 BaseNetworkSocketSetIpv6TrafficClassRequest,
50899 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50900 >(
50901 (value,),
50902 0x6af077800c5a0b4f,
50903 fidl::encoding::DynamicFlags::empty(),
50904 ___deadline,
50905 )?;
50906 Ok(_response.map(|x| x))
50907 }
50908
50909 pub fn r#get_ipv6_traffic_class(
50911 &self,
50912 ___deadline: zx::MonotonicInstant,
50913 ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
50914 let _response = self
50915 .client
50916 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50917 BaseNetworkSocketGetIpv6TrafficClassResponse,
50918 fidl_fuchsia_posix::Errno,
50919 >>(
50920 (), 0x6baf6eed8fc2f04, fidl::encoding::DynamicFlags::empty(), ___deadline
50921 )?;
50922 Ok(_response.map(|x| x.value))
50923 }
50924
50925 pub fn r#set_ipv6_receive_packet_info(
50927 &self,
50928 mut value: bool,
50929 ___deadline: zx::MonotonicInstant,
50930 ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
50931 let _response = self.client.send_query::<
50932 BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
50933 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50934 >(
50935 (value,),
50936 0x19259775b1a92768,
50937 fidl::encoding::DynamicFlags::empty(),
50938 ___deadline,
50939 )?;
50940 Ok(_response.map(|x| x))
50941 }
50942
50943 pub fn r#get_ipv6_receive_packet_info(
50945 &self,
50946 ___deadline: zx::MonotonicInstant,
50947 ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
50948 let _response = self
50949 .client
50950 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50951 BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
50952 fidl_fuchsia_posix::Errno,
50953 >>(
50954 (), 0x7acd4a2775baec75, fidl::encoding::DynamicFlags::empty(), ___deadline
50955 )?;
50956 Ok(_response.map(|x| x.value))
50957 }
50958
50959 pub fn r#get_original_destination(
50961 &self,
50962 ___deadline: zx::MonotonicInstant,
50963 ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
50964 let _response = self
50965 .client
50966 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50967 BaseNetworkSocketGetOriginalDestinationResponse,
50968 fidl_fuchsia_posix::Errno,
50969 >>(
50970 (), 0x38bf28f0dafdbac0, fidl::encoding::DynamicFlags::empty(), ___deadline
50971 )?;
50972 Ok(_response.map(|x| x.value))
50973 }
50974
50975 pub fn r#describe(
50976 &self,
50977 ___deadline: zx::MonotonicInstant,
50978 ) -> Result<StreamSocketDescribeResponse, fidl::Error> {
50979 let _response =
50980 self.client.send_query::<fidl::encoding::EmptyPayload, StreamSocketDescribeResponse>(
50981 (),
50982 0x29e22969a7dadc32,
50983 fidl::encoding::DynamicFlags::empty(),
50984 ___deadline,
50985 )?;
50986 Ok(_response)
50987 }
50988
50989 pub fn r#listen(
50992 &self,
50993 mut backlog: i16,
50994 ___deadline: zx::MonotonicInstant,
50995 ) -> Result<StreamSocketListenResult, fidl::Error> {
50996 let _response =
50997 self.client.send_query::<StreamSocketListenRequest, fidl::encoding::ResultType<
50998 fidl::encoding::EmptyStruct,
50999 fidl_fuchsia_posix::Errno,
51000 >>(
51001 (backlog,),
51002 0x3d0a65ced3d10108,
51003 fidl::encoding::DynamicFlags::empty(),
51004 ___deadline,
51005 )?;
51006 Ok(_response.map(|x| x))
51007 }
51008
51009 pub fn r#accept(
51011 &self,
51012 mut want_addr: bool,
51013 ___deadline: zx::MonotonicInstant,
51014 ) -> Result<StreamSocketAcceptResult, fidl::Error> {
51015 let _response =
51016 self.client.send_query::<StreamSocketAcceptRequest, fidl::encoding::ResultType<
51017 StreamSocketAcceptResponse,
51018 fidl_fuchsia_posix::Errno,
51019 >>(
51020 (want_addr,),
51021 0x5ab7ad620424c163,
51022 fidl::encoding::DynamicFlags::empty(),
51023 ___deadline,
51024 )?;
51025 Ok(_response.map(|x| (x.addr, x.s)))
51026 }
51027
51028 pub fn r#get_info(
51030 &self,
51031 ___deadline: zx::MonotonicInstant,
51032 ) -> Result<StreamSocketGetInfoResult, fidl::Error> {
51033 let _response =
51034 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51035 StreamSocketGetInfoResponse,
51036 fidl_fuchsia_posix::Errno,
51037 >>(
51038 (),
51039 0x87cfa55d19f878f,
51040 fidl::encoding::DynamicFlags::empty(),
51041 ___deadline,
51042 )?;
51043 Ok(_response.map(|x| (x.domain, x.proto)))
51044 }
51045
51046 pub fn r#set_tcp_no_delay(
51048 &self,
51049 mut value: bool,
51050 ___deadline: zx::MonotonicInstant,
51051 ) -> Result<StreamSocketSetTcpNoDelayResult, fidl::Error> {
51052 let _response =
51053 self.client.send_query::<StreamSocketSetTcpNoDelayRequest, fidl::encoding::ResultType<
51054 fidl::encoding::EmptyStruct,
51055 fidl_fuchsia_posix::Errno,
51056 >>(
51057 (value,),
51058 0x5a59b778f7333ada,
51059 fidl::encoding::DynamicFlags::empty(),
51060 ___deadline,
51061 )?;
51062 Ok(_response.map(|x| x))
51063 }
51064
51065 pub fn r#get_tcp_no_delay(
51067 &self,
51068 ___deadline: zx::MonotonicInstant,
51069 ) -> Result<StreamSocketGetTcpNoDelayResult, fidl::Error> {
51070 let _response = self
51071 .client
51072 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51073 StreamSocketGetTcpNoDelayResponse,
51074 fidl_fuchsia_posix::Errno,
51075 >>(
51076 (), 0xac219a3218b0799, fidl::encoding::DynamicFlags::empty(), ___deadline
51077 )?;
51078 Ok(_response.map(|x| x.value))
51079 }
51080
51081 pub fn r#set_tcp_max_segment(
51083 &self,
51084 mut value_bytes: u32,
51085 ___deadline: zx::MonotonicInstant,
51086 ) -> Result<StreamSocketSetTcpMaxSegmentResult, fidl::Error> {
51087 let _response =
51088 self.client
51089 .send_query::<StreamSocketSetTcpMaxSegmentRequest, fidl::encoding::ResultType<
51090 fidl::encoding::EmptyStruct,
51091 fidl_fuchsia_posix::Errno,
51092 >>(
51093 (value_bytes,),
51094 0xb3d30c498266d18,
51095 fidl::encoding::DynamicFlags::empty(),
51096 ___deadline,
51097 )?;
51098 Ok(_response.map(|x| x))
51099 }
51100
51101 pub fn r#get_tcp_max_segment(
51103 &self,
51104 ___deadline: zx::MonotonicInstant,
51105 ) -> Result<StreamSocketGetTcpMaxSegmentResult, fidl::Error> {
51106 let _response = self
51107 .client
51108 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51109 StreamSocketGetTcpMaxSegmentResponse,
51110 fidl_fuchsia_posix::Errno,
51111 >>(
51112 (), 0x637404d1b4b9982c, fidl::encoding::DynamicFlags::empty(), ___deadline
51113 )?;
51114 Ok(_response.map(|x| x.value_bytes))
51115 }
51116
51117 pub fn r#set_tcp_cork(
51119 &self,
51120 mut value: bool,
51121 ___deadline: zx::MonotonicInstant,
51122 ) -> Result<StreamSocketSetTcpCorkResult, fidl::Error> {
51123 let _response =
51124 self.client.send_query::<StreamSocketSetTcpCorkRequest, fidl::encoding::ResultType<
51125 fidl::encoding::EmptyStruct,
51126 fidl_fuchsia_posix::Errno,
51127 >>(
51128 (value,),
51129 0x62e26891541143a0,
51130 fidl::encoding::DynamicFlags::empty(),
51131 ___deadline,
51132 )?;
51133 Ok(_response.map(|x| x))
51134 }
51135
51136 pub fn r#get_tcp_cork(
51138 &self,
51139 ___deadline: zx::MonotonicInstant,
51140 ) -> Result<StreamSocketGetTcpCorkResult, fidl::Error> {
51141 let _response =
51142 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51143 StreamSocketGetTcpCorkResponse,
51144 fidl_fuchsia_posix::Errno,
51145 >>(
51146 (),
51147 0x435bb232e0e74f32,
51148 fidl::encoding::DynamicFlags::empty(),
51149 ___deadline,
51150 )?;
51151 Ok(_response.map(|x| x.value))
51152 }
51153
51154 pub fn r#set_tcp_keep_alive_idle(
51156 &self,
51157 mut value_secs: u32,
51158 ___deadline: zx::MonotonicInstant,
51159 ) -> Result<StreamSocketSetTcpKeepAliveIdleResult, fidl::Error> {
51160 let _response =
51161 self.client
51162 .send_query::<StreamSocketSetTcpKeepAliveIdleRequest, fidl::encoding::ResultType<
51163 fidl::encoding::EmptyStruct,
51164 fidl_fuchsia_posix::Errno,
51165 >>(
51166 (value_secs,),
51167 0x196d053d8363c42,
51168 fidl::encoding::DynamicFlags::empty(),
51169 ___deadline,
51170 )?;
51171 Ok(_response.map(|x| x))
51172 }
51173
51174 pub fn r#get_tcp_keep_alive_idle(
51176 &self,
51177 ___deadline: zx::MonotonicInstant,
51178 ) -> Result<StreamSocketGetTcpKeepAliveIdleResult, fidl::Error> {
51179 let _response = self
51180 .client
51181 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51182 StreamSocketGetTcpKeepAliveIdleResponse,
51183 fidl_fuchsia_posix::Errno,
51184 >>(
51185 (), 0x35ec58564879dac, fidl::encoding::DynamicFlags::empty(), ___deadline
51186 )?;
51187 Ok(_response.map(|x| x.value_secs))
51188 }
51189
51190 pub fn r#set_tcp_keep_alive_interval(
51192 &self,
51193 mut value_secs: u32,
51194 ___deadline: zx::MonotonicInstant,
51195 ) -> Result<StreamSocketSetTcpKeepAliveIntervalResult, fidl::Error> {
51196 let _response = self.client.send_query::<
51197 StreamSocketSetTcpKeepAliveIntervalRequest,
51198 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
51199 >(
51200 (value_secs,),
51201 0x485ffbc2da1243f2,
51202 fidl::encoding::DynamicFlags::empty(),
51203 ___deadline,
51204 )?;
51205 Ok(_response.map(|x| x))
51206 }
51207
51208 pub fn r#get_tcp_keep_alive_interval(
51210 &self,
51211 ___deadline: zx::MonotonicInstant,
51212 ) -> Result<StreamSocketGetTcpKeepAliveIntervalResult, fidl::Error> {
51213 let _response = self
51214 .client
51215 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51216 StreamSocketGetTcpKeepAliveIntervalResponse,
51217 fidl_fuchsia_posix::Errno,
51218 >>(
51219 (), 0x264eaf46306b284, fidl::encoding::DynamicFlags::empty(), ___deadline
51220 )?;
51221 Ok(_response.map(|x| x.value_secs))
51222 }
51223
51224 pub fn r#set_tcp_keep_alive_count(
51226 &self,
51227 mut value: u32,
51228 ___deadline: zx::MonotonicInstant,
51229 ) -> Result<StreamSocketSetTcpKeepAliveCountResult, fidl::Error> {
51230 let _response =
51231 self.client
51232 .send_query::<StreamSocketSetTcpKeepAliveCountRequest, fidl::encoding::ResultType<
51233 fidl::encoding::EmptyStruct,
51234 fidl_fuchsia_posix::Errno,
51235 >>(
51236 (value,),
51237 0x2ab2e8c111708421,
51238 fidl::encoding::DynamicFlags::empty(),
51239 ___deadline,
51240 )?;
51241 Ok(_response.map(|x| x))
51242 }
51243
51244 pub fn r#get_tcp_keep_alive_count(
51246 &self,
51247 ___deadline: zx::MonotonicInstant,
51248 ) -> Result<StreamSocketGetTcpKeepAliveCountResult, fidl::Error> {
51249 let _response = self
51250 .client
51251 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51252 StreamSocketGetTcpKeepAliveCountResponse,
51253 fidl_fuchsia_posix::Errno,
51254 >>(
51255 (), 0x2f176ae271fe7a09, fidl::encoding::DynamicFlags::empty(), ___deadline
51256 )?;
51257 Ok(_response.map(|x| x.value))
51258 }
51259
51260 pub fn r#set_tcp_syn_count(
51262 &self,
51263 mut value: u32,
51264 ___deadline: zx::MonotonicInstant,
51265 ) -> Result<StreamSocketSetTcpSynCountResult, fidl::Error> {
51266 let _response =
51267 self.client
51268 .send_query::<StreamSocketSetTcpSynCountRequest, fidl::encoding::ResultType<
51269 fidl::encoding::EmptyStruct,
51270 fidl_fuchsia_posix::Errno,
51271 >>(
51272 (value,),
51273 0x4dcd6ab5573c1eb3,
51274 fidl::encoding::DynamicFlags::empty(),
51275 ___deadline,
51276 )?;
51277 Ok(_response.map(|x| x))
51278 }
51279
51280 pub fn r#get_tcp_syn_count(
51282 &self,
51283 ___deadline: zx::MonotonicInstant,
51284 ) -> Result<StreamSocketGetTcpSynCountResult, fidl::Error> {
51285 let _response = self
51286 .client
51287 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51288 StreamSocketGetTcpSynCountResponse,
51289 fidl_fuchsia_posix::Errno,
51290 >>(
51291 (), 0x7d457cba8f5f3ee6, fidl::encoding::DynamicFlags::empty(), ___deadline
51292 )?;
51293 Ok(_response.map(|x| x.value))
51294 }
51295
51296 pub fn r#set_tcp_linger(
51298 &self,
51299 mut value_secs: &OptionalUint32,
51300 ___deadline: zx::MonotonicInstant,
51301 ) -> Result<StreamSocketSetTcpLingerResult, fidl::Error> {
51302 let _response =
51303 self.client.send_query::<StreamSocketSetTcpLingerRequest, fidl::encoding::ResultType<
51304 fidl::encoding::EmptyStruct,
51305 fidl_fuchsia_posix::Errno,
51306 >>(
51307 (value_secs,),
51308 0xd5cc1e8654d36e4,
51309 fidl::encoding::DynamicFlags::empty(),
51310 ___deadline,
51311 )?;
51312 Ok(_response.map(|x| x))
51313 }
51314
51315 pub fn r#get_tcp_linger(
51317 &self,
51318 ___deadline: zx::MonotonicInstant,
51319 ) -> Result<StreamSocketGetTcpLingerResult, fidl::Error> {
51320 let _response = self
51321 .client
51322 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51323 StreamSocketGetTcpLingerResponse,
51324 fidl_fuchsia_posix::Errno,
51325 >>(
51326 (), 0xad870d311cf30eb, fidl::encoding::DynamicFlags::empty(), ___deadline
51327 )?;
51328 Ok(_response.map(|x| x.value_secs))
51329 }
51330
51331 pub fn r#set_tcp_defer_accept(
51333 &self,
51334 mut value_secs: u32,
51335 ___deadline: zx::MonotonicInstant,
51336 ) -> Result<StreamSocketSetTcpDeferAcceptResult, fidl::Error> {
51337 let _response =
51338 self.client
51339 .send_query::<StreamSocketSetTcpDeferAcceptRequest, fidl::encoding::ResultType<
51340 fidl::encoding::EmptyStruct,
51341 fidl_fuchsia_posix::Errno,
51342 >>(
51343 (value_secs,),
51344 0x15092f181e57c404,
51345 fidl::encoding::DynamicFlags::empty(),
51346 ___deadline,
51347 )?;
51348 Ok(_response.map(|x| x))
51349 }
51350
51351 pub fn r#get_tcp_defer_accept(
51353 &self,
51354 ___deadline: zx::MonotonicInstant,
51355 ) -> Result<StreamSocketGetTcpDeferAcceptResult, fidl::Error> {
51356 let _response = self
51357 .client
51358 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51359 StreamSocketGetTcpDeferAcceptResponse,
51360 fidl_fuchsia_posix::Errno,
51361 >>(
51362 (), 0x64589790842cb7c6, fidl::encoding::DynamicFlags::empty(), ___deadline
51363 )?;
51364 Ok(_response.map(|x| x.value_secs))
51365 }
51366
51367 pub fn r#set_tcp_window_clamp(
51369 &self,
51370 mut value: u32,
51371 ___deadline: zx::MonotonicInstant,
51372 ) -> Result<StreamSocketSetTcpWindowClampResult, fidl::Error> {
51373 let _response =
51374 self.client
51375 .send_query::<StreamSocketSetTcpWindowClampRequest, fidl::encoding::ResultType<
51376 fidl::encoding::EmptyStruct,
51377 fidl_fuchsia_posix::Errno,
51378 >>(
51379 (value,),
51380 0x4a26ce07d847f1c6,
51381 fidl::encoding::DynamicFlags::empty(),
51382 ___deadline,
51383 )?;
51384 Ok(_response.map(|x| x))
51385 }
51386
51387 pub fn r#get_tcp_window_clamp(
51389 &self,
51390 ___deadline: zx::MonotonicInstant,
51391 ) -> Result<StreamSocketGetTcpWindowClampResult, fidl::Error> {
51392 let _response = self
51393 .client
51394 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51395 StreamSocketGetTcpWindowClampResponse,
51396 fidl_fuchsia_posix::Errno,
51397 >>(
51398 (), 0x2df6b636bf0a6a4e, fidl::encoding::DynamicFlags::empty(), ___deadline
51399 )?;
51400 Ok(_response.map(|x| x.value))
51401 }
51402
51403 pub fn r#get_tcp_info(
51405 &self,
51406 ___deadline: zx::MonotonicInstant,
51407 ) -> Result<StreamSocketGetTcpInfoResult, fidl::Error> {
51408 let _response =
51409 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51410 StreamSocketGetTcpInfoResponse,
51411 fidl_fuchsia_posix::Errno,
51412 >>(
51413 (),
51414 0x1ffb123d9f03ead2,
51415 fidl::encoding::DynamicFlags::empty(),
51416 ___deadline,
51417 )?;
51418 Ok(_response.map(|x| x.info))
51419 }
51420
51421 pub fn r#set_tcp_quick_ack(
51423 &self,
51424 mut value: bool,
51425 ___deadline: zx::MonotonicInstant,
51426 ) -> Result<StreamSocketSetTcpQuickAckResult, fidl::Error> {
51427 let _response =
51428 self.client
51429 .send_query::<StreamSocketSetTcpQuickAckRequest, fidl::encoding::ResultType<
51430 fidl::encoding::EmptyStruct,
51431 fidl_fuchsia_posix::Errno,
51432 >>(
51433 (value,),
51434 0x6fa811be8fde7457,
51435 fidl::encoding::DynamicFlags::empty(),
51436 ___deadline,
51437 )?;
51438 Ok(_response.map(|x| x))
51439 }
51440
51441 pub fn r#get_tcp_quick_ack(
51443 &self,
51444 ___deadline: zx::MonotonicInstant,
51445 ) -> Result<StreamSocketGetTcpQuickAckResult, fidl::Error> {
51446 let _response = self
51447 .client
51448 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51449 StreamSocketGetTcpQuickAckResponse,
51450 fidl_fuchsia_posix::Errno,
51451 >>(
51452 (), 0x7356a949bef2df32, fidl::encoding::DynamicFlags::empty(), ___deadline
51453 )?;
51454 Ok(_response.map(|x| x.value))
51455 }
51456
51457 pub fn r#set_tcp_congestion(
51459 &self,
51460 mut value: TcpCongestionControl,
51461 ___deadline: zx::MonotonicInstant,
51462 ) -> Result<StreamSocketSetTcpCongestionResult, fidl::Error> {
51463 let _response =
51464 self.client
51465 .send_query::<StreamSocketSetTcpCongestionRequest, fidl::encoding::ResultType<
51466 fidl::encoding::EmptyStruct,
51467 fidl_fuchsia_posix::Errno,
51468 >>(
51469 (value,),
51470 0x7924c6eabde7819e,
51471 fidl::encoding::DynamicFlags::empty(),
51472 ___deadline,
51473 )?;
51474 Ok(_response.map(|x| x))
51475 }
51476
51477 pub fn r#get_tcp_congestion(
51479 &self,
51480 ___deadline: zx::MonotonicInstant,
51481 ) -> Result<StreamSocketGetTcpCongestionResult, fidl::Error> {
51482 let _response = self
51483 .client
51484 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51485 StreamSocketGetTcpCongestionResponse,
51486 fidl_fuchsia_posix::Errno,
51487 >>(
51488 (), 0x11e16397e1b72a47, fidl::encoding::DynamicFlags::empty(), ___deadline
51489 )?;
51490 Ok(_response.map(|x| x.value))
51491 }
51492
51493 pub fn r#set_tcp_user_timeout(
51495 &self,
51496 mut value_millis: u32,
51497 ___deadline: zx::MonotonicInstant,
51498 ) -> Result<StreamSocketSetTcpUserTimeoutResult, fidl::Error> {
51499 let _response =
51500 self.client
51501 .send_query::<StreamSocketSetTcpUserTimeoutRequest, fidl::encoding::ResultType<
51502 fidl::encoding::EmptyStruct,
51503 fidl_fuchsia_posix::Errno,
51504 >>(
51505 (value_millis,),
51506 0x6b459e81c3741a60,
51507 fidl::encoding::DynamicFlags::empty(),
51508 ___deadline,
51509 )?;
51510 Ok(_response.map(|x| x))
51511 }
51512
51513 pub fn r#get_tcp_user_timeout(
51515 &self,
51516 ___deadline: zx::MonotonicInstant,
51517 ) -> Result<StreamSocketGetTcpUserTimeoutResult, fidl::Error> {
51518 let _response = self
51519 .client
51520 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51521 StreamSocketGetTcpUserTimeoutResponse,
51522 fidl_fuchsia_posix::Errno,
51523 >>(
51524 (), 0x24bbd5858ad8c380, fidl::encoding::DynamicFlags::empty(), ___deadline
51525 )?;
51526 Ok(_response.map(|x| x.value_millis))
51527 }
51528}
51529
51530#[cfg(target_os = "fuchsia")]
51531impl From<StreamSocketSynchronousProxy> for zx::Handle {
51532 fn from(value: StreamSocketSynchronousProxy) -> Self {
51533 value.into_channel().into()
51534 }
51535}
51536
51537#[cfg(target_os = "fuchsia")]
51538impl From<fidl::Channel> for StreamSocketSynchronousProxy {
51539 fn from(value: fidl::Channel) -> Self {
51540 Self::new(value)
51541 }
51542}
51543
51544#[derive(Debug, Clone)]
51545pub struct StreamSocketProxy {
51546 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
51547}
51548
51549impl fidl::endpoints::Proxy for StreamSocketProxy {
51550 type Protocol = StreamSocketMarker;
51551
51552 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
51553 Self::new(inner)
51554 }
51555
51556 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
51557 self.client.into_channel().map_err(|client| Self { client })
51558 }
51559
51560 fn as_channel(&self) -> &::fidl::AsyncChannel {
51561 self.client.as_channel()
51562 }
51563}
51564
51565impl StreamSocketProxy {
51566 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
51568 let protocol_name = <StreamSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
51569 Self { client: fidl::client::Client::new(channel, protocol_name) }
51570 }
51571
51572 pub fn take_event_stream(&self) -> StreamSocketEventStream {
51578 StreamSocketEventStream { event_receiver: self.client.take_event_receiver() }
51579 }
51580
51581 pub fn r#clone(
51582 &self,
51583 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
51584 ) -> Result<(), fidl::Error> {
51585 StreamSocketProxyInterface::r#clone(self, request)
51586 }
51587
51588 pub fn r#close(
51599 &self,
51600 ) -> fidl::client::QueryResponseFut<
51601 fidl_fuchsia_unknown::CloseableCloseResult,
51602 fidl::encoding::DefaultFuchsiaResourceDialect,
51603 > {
51604 StreamSocketProxyInterface::r#close(self)
51605 }
51606
51607 pub fn r#query(
51608 &self,
51609 ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
51610 {
51611 StreamSocketProxyInterface::r#query(self)
51612 }
51613
51614 pub fn r#set_reuse_address(
51616 &self,
51617 mut value: bool,
51618 ) -> fidl::client::QueryResponseFut<
51619 BaseSocketSetReuseAddressResult,
51620 fidl::encoding::DefaultFuchsiaResourceDialect,
51621 > {
51622 StreamSocketProxyInterface::r#set_reuse_address(self, value)
51623 }
51624
51625 pub fn r#get_reuse_address(
51627 &self,
51628 ) -> fidl::client::QueryResponseFut<
51629 BaseSocketGetReuseAddressResult,
51630 fidl::encoding::DefaultFuchsiaResourceDialect,
51631 > {
51632 StreamSocketProxyInterface::r#get_reuse_address(self)
51633 }
51634
51635 pub fn r#get_error(
51638 &self,
51639 ) -> fidl::client::QueryResponseFut<
51640 BaseSocketGetErrorResult,
51641 fidl::encoding::DefaultFuchsiaResourceDialect,
51642 > {
51643 StreamSocketProxyInterface::r#get_error(self)
51644 }
51645
51646 pub fn r#set_broadcast(
51648 &self,
51649 mut value: bool,
51650 ) -> fidl::client::QueryResponseFut<
51651 BaseSocketSetBroadcastResult,
51652 fidl::encoding::DefaultFuchsiaResourceDialect,
51653 > {
51654 StreamSocketProxyInterface::r#set_broadcast(self, value)
51655 }
51656
51657 pub fn r#get_broadcast(
51659 &self,
51660 ) -> fidl::client::QueryResponseFut<
51661 BaseSocketGetBroadcastResult,
51662 fidl::encoding::DefaultFuchsiaResourceDialect,
51663 > {
51664 StreamSocketProxyInterface::r#get_broadcast(self)
51665 }
51666
51667 pub fn r#set_send_buffer(
51669 &self,
51670 mut value_bytes: u64,
51671 ) -> fidl::client::QueryResponseFut<
51672 BaseSocketSetSendBufferResult,
51673 fidl::encoding::DefaultFuchsiaResourceDialect,
51674 > {
51675 StreamSocketProxyInterface::r#set_send_buffer(self, value_bytes)
51676 }
51677
51678 pub fn r#get_send_buffer(
51680 &self,
51681 ) -> fidl::client::QueryResponseFut<
51682 BaseSocketGetSendBufferResult,
51683 fidl::encoding::DefaultFuchsiaResourceDialect,
51684 > {
51685 StreamSocketProxyInterface::r#get_send_buffer(self)
51686 }
51687
51688 pub fn r#set_receive_buffer(
51690 &self,
51691 mut value_bytes: u64,
51692 ) -> fidl::client::QueryResponseFut<
51693 BaseSocketSetReceiveBufferResult,
51694 fidl::encoding::DefaultFuchsiaResourceDialect,
51695 > {
51696 StreamSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
51697 }
51698
51699 pub fn r#get_receive_buffer(
51701 &self,
51702 ) -> fidl::client::QueryResponseFut<
51703 BaseSocketGetReceiveBufferResult,
51704 fidl::encoding::DefaultFuchsiaResourceDialect,
51705 > {
51706 StreamSocketProxyInterface::r#get_receive_buffer(self)
51707 }
51708
51709 pub fn r#set_keep_alive(
51711 &self,
51712 mut value: bool,
51713 ) -> fidl::client::QueryResponseFut<
51714 BaseSocketSetKeepAliveResult,
51715 fidl::encoding::DefaultFuchsiaResourceDialect,
51716 > {
51717 StreamSocketProxyInterface::r#set_keep_alive(self, value)
51718 }
51719
51720 pub fn r#get_keep_alive(
51722 &self,
51723 ) -> fidl::client::QueryResponseFut<
51724 BaseSocketGetKeepAliveResult,
51725 fidl::encoding::DefaultFuchsiaResourceDialect,
51726 > {
51727 StreamSocketProxyInterface::r#get_keep_alive(self)
51728 }
51729
51730 pub fn r#set_out_of_band_inline(
51732 &self,
51733 mut value: bool,
51734 ) -> fidl::client::QueryResponseFut<
51735 BaseSocketSetOutOfBandInlineResult,
51736 fidl::encoding::DefaultFuchsiaResourceDialect,
51737 > {
51738 StreamSocketProxyInterface::r#set_out_of_band_inline(self, value)
51739 }
51740
51741 pub fn r#get_out_of_band_inline(
51743 &self,
51744 ) -> fidl::client::QueryResponseFut<
51745 BaseSocketGetOutOfBandInlineResult,
51746 fidl::encoding::DefaultFuchsiaResourceDialect,
51747 > {
51748 StreamSocketProxyInterface::r#get_out_of_band_inline(self)
51749 }
51750
51751 pub fn r#set_no_check(
51753 &self,
51754 mut value: bool,
51755 ) -> fidl::client::QueryResponseFut<
51756 BaseSocketSetNoCheckResult,
51757 fidl::encoding::DefaultFuchsiaResourceDialect,
51758 > {
51759 StreamSocketProxyInterface::r#set_no_check(self, value)
51760 }
51761
51762 pub fn r#get_no_check(
51764 &self,
51765 ) -> fidl::client::QueryResponseFut<
51766 BaseSocketGetNoCheckResult,
51767 fidl::encoding::DefaultFuchsiaResourceDialect,
51768 > {
51769 StreamSocketProxyInterface::r#get_no_check(self)
51770 }
51771
51772 pub fn r#set_linger(
51774 &self,
51775 mut linger: bool,
51776 mut length_secs: u32,
51777 ) -> fidl::client::QueryResponseFut<
51778 BaseSocketSetLingerResult,
51779 fidl::encoding::DefaultFuchsiaResourceDialect,
51780 > {
51781 StreamSocketProxyInterface::r#set_linger(self, linger, length_secs)
51782 }
51783
51784 pub fn r#get_linger(
51786 &self,
51787 ) -> fidl::client::QueryResponseFut<
51788 BaseSocketGetLingerResult,
51789 fidl::encoding::DefaultFuchsiaResourceDialect,
51790 > {
51791 StreamSocketProxyInterface::r#get_linger(self)
51792 }
51793
51794 pub fn r#set_reuse_port(
51796 &self,
51797 mut value: bool,
51798 ) -> fidl::client::QueryResponseFut<
51799 BaseSocketSetReusePortResult,
51800 fidl::encoding::DefaultFuchsiaResourceDialect,
51801 > {
51802 StreamSocketProxyInterface::r#set_reuse_port(self, value)
51803 }
51804
51805 pub fn r#get_reuse_port(
51807 &self,
51808 ) -> fidl::client::QueryResponseFut<
51809 BaseSocketGetReusePortResult,
51810 fidl::encoding::DefaultFuchsiaResourceDialect,
51811 > {
51812 StreamSocketProxyInterface::r#get_reuse_port(self)
51813 }
51814
51815 pub fn r#get_accept_conn(
51817 &self,
51818 ) -> fidl::client::QueryResponseFut<
51819 BaseSocketGetAcceptConnResult,
51820 fidl::encoding::DefaultFuchsiaResourceDialect,
51821 > {
51822 StreamSocketProxyInterface::r#get_accept_conn(self)
51823 }
51824
51825 pub fn r#set_bind_to_device(
51827 &self,
51828 mut value: &str,
51829 ) -> fidl::client::QueryResponseFut<
51830 BaseSocketSetBindToDeviceResult,
51831 fidl::encoding::DefaultFuchsiaResourceDialect,
51832 > {
51833 StreamSocketProxyInterface::r#set_bind_to_device(self, value)
51834 }
51835
51836 pub fn r#get_bind_to_device(
51838 &self,
51839 ) -> fidl::client::QueryResponseFut<
51840 BaseSocketGetBindToDeviceResult,
51841 fidl::encoding::DefaultFuchsiaResourceDialect,
51842 > {
51843 StreamSocketProxyInterface::r#get_bind_to_device(self)
51844 }
51845
51846 pub fn r#set_bind_to_interface_index(
51849 &self,
51850 mut value: u64,
51851 ) -> fidl::client::QueryResponseFut<
51852 BaseSocketSetBindToInterfaceIndexResult,
51853 fidl::encoding::DefaultFuchsiaResourceDialect,
51854 > {
51855 StreamSocketProxyInterface::r#set_bind_to_interface_index(self, value)
51856 }
51857
51858 pub fn r#get_bind_to_interface_index(
51860 &self,
51861 ) -> fidl::client::QueryResponseFut<
51862 BaseSocketGetBindToInterfaceIndexResult,
51863 fidl::encoding::DefaultFuchsiaResourceDialect,
51864 > {
51865 StreamSocketProxyInterface::r#get_bind_to_interface_index(self)
51866 }
51867
51868 pub fn r#set_timestamp(
51870 &self,
51871 mut value: TimestampOption,
51872 ) -> fidl::client::QueryResponseFut<
51873 BaseSocketSetTimestampResult,
51874 fidl::encoding::DefaultFuchsiaResourceDialect,
51875 > {
51876 StreamSocketProxyInterface::r#set_timestamp(self, value)
51877 }
51878
51879 pub fn r#get_timestamp(
51881 &self,
51882 ) -> fidl::client::QueryResponseFut<
51883 BaseSocketGetTimestampResult,
51884 fidl::encoding::DefaultFuchsiaResourceDialect,
51885 > {
51886 StreamSocketProxyInterface::r#get_timestamp(self)
51887 }
51888
51889 pub fn r#set_mark(
51893 &self,
51894 mut domain: fidl_fuchsia_net::MarkDomain,
51895 mut mark: &OptionalUint32,
51896 ) -> fidl::client::QueryResponseFut<
51897 BaseSocketSetMarkResult,
51898 fidl::encoding::DefaultFuchsiaResourceDialect,
51899 > {
51900 StreamSocketProxyInterface::r#set_mark(self, domain, mark)
51901 }
51902
51903 pub fn r#get_mark(
51907 &self,
51908 mut domain: fidl_fuchsia_net::MarkDomain,
51909 ) -> fidl::client::QueryResponseFut<
51910 BaseSocketGetMarkResult,
51911 fidl::encoding::DefaultFuchsiaResourceDialect,
51912 > {
51913 StreamSocketProxyInterface::r#get_mark(self, domain)
51914 }
51915
51916 pub fn r#bind(
51918 &self,
51919 mut addr: &fidl_fuchsia_net::SocketAddress,
51920 ) -> fidl::client::QueryResponseFut<
51921 BaseNetworkSocketBindResult,
51922 fidl::encoding::DefaultFuchsiaResourceDialect,
51923 > {
51924 StreamSocketProxyInterface::r#bind(self, addr)
51925 }
51926
51927 pub fn r#connect(
51929 &self,
51930 mut addr: &fidl_fuchsia_net::SocketAddress,
51931 ) -> fidl::client::QueryResponseFut<
51932 BaseNetworkSocketConnectResult,
51933 fidl::encoding::DefaultFuchsiaResourceDialect,
51934 > {
51935 StreamSocketProxyInterface::r#connect(self, addr)
51936 }
51937
51938 pub fn r#disconnect(
51940 &self,
51941 ) -> fidl::client::QueryResponseFut<
51942 BaseNetworkSocketDisconnectResult,
51943 fidl::encoding::DefaultFuchsiaResourceDialect,
51944 > {
51945 StreamSocketProxyInterface::r#disconnect(self)
51946 }
51947
51948 pub fn r#get_sock_name(
51950 &self,
51951 ) -> fidl::client::QueryResponseFut<
51952 BaseNetworkSocketGetSockNameResult,
51953 fidl::encoding::DefaultFuchsiaResourceDialect,
51954 > {
51955 StreamSocketProxyInterface::r#get_sock_name(self)
51956 }
51957
51958 pub fn r#get_peer_name(
51960 &self,
51961 ) -> fidl::client::QueryResponseFut<
51962 BaseNetworkSocketGetPeerNameResult,
51963 fidl::encoding::DefaultFuchsiaResourceDialect,
51964 > {
51965 StreamSocketProxyInterface::r#get_peer_name(self)
51966 }
51967
51968 pub fn r#shutdown(
51970 &self,
51971 mut mode: ShutdownMode,
51972 ) -> fidl::client::QueryResponseFut<
51973 BaseNetworkSocketShutdownResult,
51974 fidl::encoding::DefaultFuchsiaResourceDialect,
51975 > {
51976 StreamSocketProxyInterface::r#shutdown(self, mode)
51977 }
51978
51979 pub fn r#set_ip_type_of_service(
51981 &self,
51982 mut value: u8,
51983 ) -> fidl::client::QueryResponseFut<
51984 BaseNetworkSocketSetIpTypeOfServiceResult,
51985 fidl::encoding::DefaultFuchsiaResourceDialect,
51986 > {
51987 StreamSocketProxyInterface::r#set_ip_type_of_service(self, value)
51988 }
51989
51990 pub fn r#get_ip_type_of_service(
51992 &self,
51993 ) -> fidl::client::QueryResponseFut<
51994 BaseNetworkSocketGetIpTypeOfServiceResult,
51995 fidl::encoding::DefaultFuchsiaResourceDialect,
51996 > {
51997 StreamSocketProxyInterface::r#get_ip_type_of_service(self)
51998 }
51999
52000 pub fn r#set_ip_ttl(
52002 &self,
52003 mut value: &OptionalUint8,
52004 ) -> fidl::client::QueryResponseFut<
52005 BaseNetworkSocketSetIpTtlResult,
52006 fidl::encoding::DefaultFuchsiaResourceDialect,
52007 > {
52008 StreamSocketProxyInterface::r#set_ip_ttl(self, value)
52009 }
52010
52011 pub fn r#get_ip_ttl(
52013 &self,
52014 ) -> fidl::client::QueryResponseFut<
52015 BaseNetworkSocketGetIpTtlResult,
52016 fidl::encoding::DefaultFuchsiaResourceDialect,
52017 > {
52018 StreamSocketProxyInterface::r#get_ip_ttl(self)
52019 }
52020
52021 pub fn r#set_ip_packet_info(
52023 &self,
52024 mut value: bool,
52025 ) -> fidl::client::QueryResponseFut<
52026 BaseNetworkSocketSetIpPacketInfoResult,
52027 fidl::encoding::DefaultFuchsiaResourceDialect,
52028 > {
52029 StreamSocketProxyInterface::r#set_ip_packet_info(self, value)
52030 }
52031
52032 pub fn r#get_ip_packet_info(
52034 &self,
52035 ) -> fidl::client::QueryResponseFut<
52036 BaseNetworkSocketGetIpPacketInfoResult,
52037 fidl::encoding::DefaultFuchsiaResourceDialect,
52038 > {
52039 StreamSocketProxyInterface::r#get_ip_packet_info(self)
52040 }
52041
52042 pub fn r#set_ip_receive_type_of_service(
52044 &self,
52045 mut value: bool,
52046 ) -> fidl::client::QueryResponseFut<
52047 BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
52048 fidl::encoding::DefaultFuchsiaResourceDialect,
52049 > {
52050 StreamSocketProxyInterface::r#set_ip_receive_type_of_service(self, value)
52051 }
52052
52053 pub fn r#get_ip_receive_type_of_service(
52055 &self,
52056 ) -> fidl::client::QueryResponseFut<
52057 BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
52058 fidl::encoding::DefaultFuchsiaResourceDialect,
52059 > {
52060 StreamSocketProxyInterface::r#get_ip_receive_type_of_service(self)
52061 }
52062
52063 pub fn r#set_ip_receive_ttl(
52065 &self,
52066 mut value: bool,
52067 ) -> fidl::client::QueryResponseFut<
52068 BaseNetworkSocketSetIpReceiveTtlResult,
52069 fidl::encoding::DefaultFuchsiaResourceDialect,
52070 > {
52071 StreamSocketProxyInterface::r#set_ip_receive_ttl(self, value)
52072 }
52073
52074 pub fn r#get_ip_receive_ttl(
52076 &self,
52077 ) -> fidl::client::QueryResponseFut<
52078 BaseNetworkSocketGetIpReceiveTtlResult,
52079 fidl::encoding::DefaultFuchsiaResourceDialect,
52080 > {
52081 StreamSocketProxyInterface::r#get_ip_receive_ttl(self)
52082 }
52083
52084 pub fn r#set_ip_multicast_interface(
52086 &self,
52087 mut iface: u64,
52088 mut address: &fidl_fuchsia_net::Ipv4Address,
52089 ) -> fidl::client::QueryResponseFut<
52090 BaseNetworkSocketSetIpMulticastInterfaceResult,
52091 fidl::encoding::DefaultFuchsiaResourceDialect,
52092 > {
52093 StreamSocketProxyInterface::r#set_ip_multicast_interface(self, iface, address)
52094 }
52095
52096 pub fn r#get_ip_multicast_interface(
52098 &self,
52099 ) -> fidl::client::QueryResponseFut<
52100 BaseNetworkSocketGetIpMulticastInterfaceResult,
52101 fidl::encoding::DefaultFuchsiaResourceDialect,
52102 > {
52103 StreamSocketProxyInterface::r#get_ip_multicast_interface(self)
52104 }
52105
52106 pub fn r#set_ip_multicast_ttl(
52108 &self,
52109 mut value: &OptionalUint8,
52110 ) -> fidl::client::QueryResponseFut<
52111 BaseNetworkSocketSetIpMulticastTtlResult,
52112 fidl::encoding::DefaultFuchsiaResourceDialect,
52113 > {
52114 StreamSocketProxyInterface::r#set_ip_multicast_ttl(self, value)
52115 }
52116
52117 pub fn r#get_ip_multicast_ttl(
52119 &self,
52120 ) -> fidl::client::QueryResponseFut<
52121 BaseNetworkSocketGetIpMulticastTtlResult,
52122 fidl::encoding::DefaultFuchsiaResourceDialect,
52123 > {
52124 StreamSocketProxyInterface::r#get_ip_multicast_ttl(self)
52125 }
52126
52127 pub fn r#set_ip_multicast_loopback(
52129 &self,
52130 mut value: bool,
52131 ) -> fidl::client::QueryResponseFut<
52132 BaseNetworkSocketSetIpMulticastLoopbackResult,
52133 fidl::encoding::DefaultFuchsiaResourceDialect,
52134 > {
52135 StreamSocketProxyInterface::r#set_ip_multicast_loopback(self, value)
52136 }
52137
52138 pub fn r#get_ip_multicast_loopback(
52140 &self,
52141 ) -> fidl::client::QueryResponseFut<
52142 BaseNetworkSocketGetIpMulticastLoopbackResult,
52143 fidl::encoding::DefaultFuchsiaResourceDialect,
52144 > {
52145 StreamSocketProxyInterface::r#get_ip_multicast_loopback(self)
52146 }
52147
52148 pub fn r#add_ip_membership(
52150 &self,
52151 mut membership: &IpMulticastMembership,
52152 ) -> fidl::client::QueryResponseFut<
52153 BaseNetworkSocketAddIpMembershipResult,
52154 fidl::encoding::DefaultFuchsiaResourceDialect,
52155 > {
52156 StreamSocketProxyInterface::r#add_ip_membership(self, membership)
52157 }
52158
52159 pub fn r#drop_ip_membership(
52161 &self,
52162 mut membership: &IpMulticastMembership,
52163 ) -> fidl::client::QueryResponseFut<
52164 BaseNetworkSocketDropIpMembershipResult,
52165 fidl::encoding::DefaultFuchsiaResourceDialect,
52166 > {
52167 StreamSocketProxyInterface::r#drop_ip_membership(self, membership)
52168 }
52169
52170 pub fn r#set_ip_transparent(
52172 &self,
52173 mut value: bool,
52174 ) -> fidl::client::QueryResponseFut<
52175 BaseNetworkSocketSetIpTransparentResult,
52176 fidl::encoding::DefaultFuchsiaResourceDialect,
52177 > {
52178 StreamSocketProxyInterface::r#set_ip_transparent(self, value)
52179 }
52180
52181 pub fn r#get_ip_transparent(
52183 &self,
52184 ) -> fidl::client::QueryResponseFut<
52185 BaseNetworkSocketGetIpTransparentResult,
52186 fidl::encoding::DefaultFuchsiaResourceDialect,
52187 > {
52188 StreamSocketProxyInterface::r#get_ip_transparent(self)
52189 }
52190
52191 pub fn r#set_ip_receive_original_destination_address(
52193 &self,
52194 mut value: bool,
52195 ) -> fidl::client::QueryResponseFut<
52196 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
52197 fidl::encoding::DefaultFuchsiaResourceDialect,
52198 > {
52199 StreamSocketProxyInterface::r#set_ip_receive_original_destination_address(self, value)
52200 }
52201
52202 pub fn r#get_ip_receive_original_destination_address(
52204 &self,
52205 ) -> fidl::client::QueryResponseFut<
52206 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
52207 fidl::encoding::DefaultFuchsiaResourceDialect,
52208 > {
52209 StreamSocketProxyInterface::r#get_ip_receive_original_destination_address(self)
52210 }
52211
52212 pub fn r#add_ipv6_membership(
52214 &self,
52215 mut membership: &Ipv6MulticastMembership,
52216 ) -> fidl::client::QueryResponseFut<
52217 BaseNetworkSocketAddIpv6MembershipResult,
52218 fidl::encoding::DefaultFuchsiaResourceDialect,
52219 > {
52220 StreamSocketProxyInterface::r#add_ipv6_membership(self, membership)
52221 }
52222
52223 pub fn r#drop_ipv6_membership(
52225 &self,
52226 mut membership: &Ipv6MulticastMembership,
52227 ) -> fidl::client::QueryResponseFut<
52228 BaseNetworkSocketDropIpv6MembershipResult,
52229 fidl::encoding::DefaultFuchsiaResourceDialect,
52230 > {
52231 StreamSocketProxyInterface::r#drop_ipv6_membership(self, membership)
52232 }
52233
52234 pub fn r#set_ipv6_multicast_interface(
52236 &self,
52237 mut value: u64,
52238 ) -> fidl::client::QueryResponseFut<
52239 BaseNetworkSocketSetIpv6MulticastInterfaceResult,
52240 fidl::encoding::DefaultFuchsiaResourceDialect,
52241 > {
52242 StreamSocketProxyInterface::r#set_ipv6_multicast_interface(self, value)
52243 }
52244
52245 pub fn r#get_ipv6_multicast_interface(
52247 &self,
52248 ) -> fidl::client::QueryResponseFut<
52249 BaseNetworkSocketGetIpv6MulticastInterfaceResult,
52250 fidl::encoding::DefaultFuchsiaResourceDialect,
52251 > {
52252 StreamSocketProxyInterface::r#get_ipv6_multicast_interface(self)
52253 }
52254
52255 pub fn r#set_ipv6_unicast_hops(
52257 &self,
52258 mut value: &OptionalUint8,
52259 ) -> fidl::client::QueryResponseFut<
52260 BaseNetworkSocketSetIpv6UnicastHopsResult,
52261 fidl::encoding::DefaultFuchsiaResourceDialect,
52262 > {
52263 StreamSocketProxyInterface::r#set_ipv6_unicast_hops(self, value)
52264 }
52265
52266 pub fn r#get_ipv6_unicast_hops(
52268 &self,
52269 ) -> fidl::client::QueryResponseFut<
52270 BaseNetworkSocketGetIpv6UnicastHopsResult,
52271 fidl::encoding::DefaultFuchsiaResourceDialect,
52272 > {
52273 StreamSocketProxyInterface::r#get_ipv6_unicast_hops(self)
52274 }
52275
52276 pub fn r#set_ipv6_receive_hop_limit(
52278 &self,
52279 mut value: bool,
52280 ) -> fidl::client::QueryResponseFut<
52281 BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
52282 fidl::encoding::DefaultFuchsiaResourceDialect,
52283 > {
52284 StreamSocketProxyInterface::r#set_ipv6_receive_hop_limit(self, value)
52285 }
52286
52287 pub fn r#get_ipv6_receive_hop_limit(
52289 &self,
52290 ) -> fidl::client::QueryResponseFut<
52291 BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
52292 fidl::encoding::DefaultFuchsiaResourceDialect,
52293 > {
52294 StreamSocketProxyInterface::r#get_ipv6_receive_hop_limit(self)
52295 }
52296
52297 pub fn r#set_ipv6_multicast_hops(
52299 &self,
52300 mut value: &OptionalUint8,
52301 ) -> fidl::client::QueryResponseFut<
52302 BaseNetworkSocketSetIpv6MulticastHopsResult,
52303 fidl::encoding::DefaultFuchsiaResourceDialect,
52304 > {
52305 StreamSocketProxyInterface::r#set_ipv6_multicast_hops(self, value)
52306 }
52307
52308 pub fn r#get_ipv6_multicast_hops(
52310 &self,
52311 ) -> fidl::client::QueryResponseFut<
52312 BaseNetworkSocketGetIpv6MulticastHopsResult,
52313 fidl::encoding::DefaultFuchsiaResourceDialect,
52314 > {
52315 StreamSocketProxyInterface::r#get_ipv6_multicast_hops(self)
52316 }
52317
52318 pub fn r#set_ipv6_multicast_loopback(
52320 &self,
52321 mut value: bool,
52322 ) -> fidl::client::QueryResponseFut<
52323 BaseNetworkSocketSetIpv6MulticastLoopbackResult,
52324 fidl::encoding::DefaultFuchsiaResourceDialect,
52325 > {
52326 StreamSocketProxyInterface::r#set_ipv6_multicast_loopback(self, value)
52327 }
52328
52329 pub fn r#get_ipv6_multicast_loopback(
52331 &self,
52332 ) -> fidl::client::QueryResponseFut<
52333 BaseNetworkSocketGetIpv6MulticastLoopbackResult,
52334 fidl::encoding::DefaultFuchsiaResourceDialect,
52335 > {
52336 StreamSocketProxyInterface::r#get_ipv6_multicast_loopback(self)
52337 }
52338
52339 pub fn r#set_ipv6_only(
52341 &self,
52342 mut value: bool,
52343 ) -> fidl::client::QueryResponseFut<
52344 BaseNetworkSocketSetIpv6OnlyResult,
52345 fidl::encoding::DefaultFuchsiaResourceDialect,
52346 > {
52347 StreamSocketProxyInterface::r#set_ipv6_only(self, value)
52348 }
52349
52350 pub fn r#get_ipv6_only(
52352 &self,
52353 ) -> fidl::client::QueryResponseFut<
52354 BaseNetworkSocketGetIpv6OnlyResult,
52355 fidl::encoding::DefaultFuchsiaResourceDialect,
52356 > {
52357 StreamSocketProxyInterface::r#get_ipv6_only(self)
52358 }
52359
52360 pub fn r#set_ipv6_receive_traffic_class(
52362 &self,
52363 mut value: bool,
52364 ) -> fidl::client::QueryResponseFut<
52365 BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
52366 fidl::encoding::DefaultFuchsiaResourceDialect,
52367 > {
52368 StreamSocketProxyInterface::r#set_ipv6_receive_traffic_class(self, value)
52369 }
52370
52371 pub fn r#get_ipv6_receive_traffic_class(
52373 &self,
52374 ) -> fidl::client::QueryResponseFut<
52375 BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
52376 fidl::encoding::DefaultFuchsiaResourceDialect,
52377 > {
52378 StreamSocketProxyInterface::r#get_ipv6_receive_traffic_class(self)
52379 }
52380
52381 pub fn r#set_ipv6_traffic_class(
52383 &self,
52384 mut value: &OptionalUint8,
52385 ) -> fidl::client::QueryResponseFut<
52386 BaseNetworkSocketSetIpv6TrafficClassResult,
52387 fidl::encoding::DefaultFuchsiaResourceDialect,
52388 > {
52389 StreamSocketProxyInterface::r#set_ipv6_traffic_class(self, value)
52390 }
52391
52392 pub fn r#get_ipv6_traffic_class(
52394 &self,
52395 ) -> fidl::client::QueryResponseFut<
52396 BaseNetworkSocketGetIpv6TrafficClassResult,
52397 fidl::encoding::DefaultFuchsiaResourceDialect,
52398 > {
52399 StreamSocketProxyInterface::r#get_ipv6_traffic_class(self)
52400 }
52401
52402 pub fn r#set_ipv6_receive_packet_info(
52404 &self,
52405 mut value: bool,
52406 ) -> fidl::client::QueryResponseFut<
52407 BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
52408 fidl::encoding::DefaultFuchsiaResourceDialect,
52409 > {
52410 StreamSocketProxyInterface::r#set_ipv6_receive_packet_info(self, value)
52411 }
52412
52413 pub fn r#get_ipv6_receive_packet_info(
52415 &self,
52416 ) -> fidl::client::QueryResponseFut<
52417 BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
52418 fidl::encoding::DefaultFuchsiaResourceDialect,
52419 > {
52420 StreamSocketProxyInterface::r#get_ipv6_receive_packet_info(self)
52421 }
52422
52423 pub fn r#get_original_destination(
52425 &self,
52426 ) -> fidl::client::QueryResponseFut<
52427 BaseNetworkSocketGetOriginalDestinationResult,
52428 fidl::encoding::DefaultFuchsiaResourceDialect,
52429 > {
52430 StreamSocketProxyInterface::r#get_original_destination(self)
52431 }
52432
52433 pub fn r#describe(
52434 &self,
52435 ) -> fidl::client::QueryResponseFut<
52436 StreamSocketDescribeResponse,
52437 fidl::encoding::DefaultFuchsiaResourceDialect,
52438 > {
52439 StreamSocketProxyInterface::r#describe(self)
52440 }
52441
52442 pub fn r#listen(
52445 &self,
52446 mut backlog: i16,
52447 ) -> fidl::client::QueryResponseFut<
52448 StreamSocketListenResult,
52449 fidl::encoding::DefaultFuchsiaResourceDialect,
52450 > {
52451 StreamSocketProxyInterface::r#listen(self, backlog)
52452 }
52453
52454 pub fn r#accept(
52456 &self,
52457 mut want_addr: bool,
52458 ) -> fidl::client::QueryResponseFut<
52459 StreamSocketAcceptResult,
52460 fidl::encoding::DefaultFuchsiaResourceDialect,
52461 > {
52462 StreamSocketProxyInterface::r#accept(self, want_addr)
52463 }
52464
52465 pub fn r#get_info(
52467 &self,
52468 ) -> fidl::client::QueryResponseFut<
52469 StreamSocketGetInfoResult,
52470 fidl::encoding::DefaultFuchsiaResourceDialect,
52471 > {
52472 StreamSocketProxyInterface::r#get_info(self)
52473 }
52474
52475 pub fn r#set_tcp_no_delay(
52477 &self,
52478 mut value: bool,
52479 ) -> fidl::client::QueryResponseFut<
52480 StreamSocketSetTcpNoDelayResult,
52481 fidl::encoding::DefaultFuchsiaResourceDialect,
52482 > {
52483 StreamSocketProxyInterface::r#set_tcp_no_delay(self, value)
52484 }
52485
52486 pub fn r#get_tcp_no_delay(
52488 &self,
52489 ) -> fidl::client::QueryResponseFut<
52490 StreamSocketGetTcpNoDelayResult,
52491 fidl::encoding::DefaultFuchsiaResourceDialect,
52492 > {
52493 StreamSocketProxyInterface::r#get_tcp_no_delay(self)
52494 }
52495
52496 pub fn r#set_tcp_max_segment(
52498 &self,
52499 mut value_bytes: u32,
52500 ) -> fidl::client::QueryResponseFut<
52501 StreamSocketSetTcpMaxSegmentResult,
52502 fidl::encoding::DefaultFuchsiaResourceDialect,
52503 > {
52504 StreamSocketProxyInterface::r#set_tcp_max_segment(self, value_bytes)
52505 }
52506
52507 pub fn r#get_tcp_max_segment(
52509 &self,
52510 ) -> fidl::client::QueryResponseFut<
52511 StreamSocketGetTcpMaxSegmentResult,
52512 fidl::encoding::DefaultFuchsiaResourceDialect,
52513 > {
52514 StreamSocketProxyInterface::r#get_tcp_max_segment(self)
52515 }
52516
52517 pub fn r#set_tcp_cork(
52519 &self,
52520 mut value: bool,
52521 ) -> fidl::client::QueryResponseFut<
52522 StreamSocketSetTcpCorkResult,
52523 fidl::encoding::DefaultFuchsiaResourceDialect,
52524 > {
52525 StreamSocketProxyInterface::r#set_tcp_cork(self, value)
52526 }
52527
52528 pub fn r#get_tcp_cork(
52530 &self,
52531 ) -> fidl::client::QueryResponseFut<
52532 StreamSocketGetTcpCorkResult,
52533 fidl::encoding::DefaultFuchsiaResourceDialect,
52534 > {
52535 StreamSocketProxyInterface::r#get_tcp_cork(self)
52536 }
52537
52538 pub fn r#set_tcp_keep_alive_idle(
52540 &self,
52541 mut value_secs: u32,
52542 ) -> fidl::client::QueryResponseFut<
52543 StreamSocketSetTcpKeepAliveIdleResult,
52544 fidl::encoding::DefaultFuchsiaResourceDialect,
52545 > {
52546 StreamSocketProxyInterface::r#set_tcp_keep_alive_idle(self, value_secs)
52547 }
52548
52549 pub fn r#get_tcp_keep_alive_idle(
52551 &self,
52552 ) -> fidl::client::QueryResponseFut<
52553 StreamSocketGetTcpKeepAliveIdleResult,
52554 fidl::encoding::DefaultFuchsiaResourceDialect,
52555 > {
52556 StreamSocketProxyInterface::r#get_tcp_keep_alive_idle(self)
52557 }
52558
52559 pub fn r#set_tcp_keep_alive_interval(
52561 &self,
52562 mut value_secs: u32,
52563 ) -> fidl::client::QueryResponseFut<
52564 StreamSocketSetTcpKeepAliveIntervalResult,
52565 fidl::encoding::DefaultFuchsiaResourceDialect,
52566 > {
52567 StreamSocketProxyInterface::r#set_tcp_keep_alive_interval(self, value_secs)
52568 }
52569
52570 pub fn r#get_tcp_keep_alive_interval(
52572 &self,
52573 ) -> fidl::client::QueryResponseFut<
52574 StreamSocketGetTcpKeepAliveIntervalResult,
52575 fidl::encoding::DefaultFuchsiaResourceDialect,
52576 > {
52577 StreamSocketProxyInterface::r#get_tcp_keep_alive_interval(self)
52578 }
52579
52580 pub fn r#set_tcp_keep_alive_count(
52582 &self,
52583 mut value: u32,
52584 ) -> fidl::client::QueryResponseFut<
52585 StreamSocketSetTcpKeepAliveCountResult,
52586 fidl::encoding::DefaultFuchsiaResourceDialect,
52587 > {
52588 StreamSocketProxyInterface::r#set_tcp_keep_alive_count(self, value)
52589 }
52590
52591 pub fn r#get_tcp_keep_alive_count(
52593 &self,
52594 ) -> fidl::client::QueryResponseFut<
52595 StreamSocketGetTcpKeepAliveCountResult,
52596 fidl::encoding::DefaultFuchsiaResourceDialect,
52597 > {
52598 StreamSocketProxyInterface::r#get_tcp_keep_alive_count(self)
52599 }
52600
52601 pub fn r#set_tcp_syn_count(
52603 &self,
52604 mut value: u32,
52605 ) -> fidl::client::QueryResponseFut<
52606 StreamSocketSetTcpSynCountResult,
52607 fidl::encoding::DefaultFuchsiaResourceDialect,
52608 > {
52609 StreamSocketProxyInterface::r#set_tcp_syn_count(self, value)
52610 }
52611
52612 pub fn r#get_tcp_syn_count(
52614 &self,
52615 ) -> fidl::client::QueryResponseFut<
52616 StreamSocketGetTcpSynCountResult,
52617 fidl::encoding::DefaultFuchsiaResourceDialect,
52618 > {
52619 StreamSocketProxyInterface::r#get_tcp_syn_count(self)
52620 }
52621
52622 pub fn r#set_tcp_linger(
52624 &self,
52625 mut value_secs: &OptionalUint32,
52626 ) -> fidl::client::QueryResponseFut<
52627 StreamSocketSetTcpLingerResult,
52628 fidl::encoding::DefaultFuchsiaResourceDialect,
52629 > {
52630 StreamSocketProxyInterface::r#set_tcp_linger(self, value_secs)
52631 }
52632
52633 pub fn r#get_tcp_linger(
52635 &self,
52636 ) -> fidl::client::QueryResponseFut<
52637 StreamSocketGetTcpLingerResult,
52638 fidl::encoding::DefaultFuchsiaResourceDialect,
52639 > {
52640 StreamSocketProxyInterface::r#get_tcp_linger(self)
52641 }
52642
52643 pub fn r#set_tcp_defer_accept(
52645 &self,
52646 mut value_secs: u32,
52647 ) -> fidl::client::QueryResponseFut<
52648 StreamSocketSetTcpDeferAcceptResult,
52649 fidl::encoding::DefaultFuchsiaResourceDialect,
52650 > {
52651 StreamSocketProxyInterface::r#set_tcp_defer_accept(self, value_secs)
52652 }
52653
52654 pub fn r#get_tcp_defer_accept(
52656 &self,
52657 ) -> fidl::client::QueryResponseFut<
52658 StreamSocketGetTcpDeferAcceptResult,
52659 fidl::encoding::DefaultFuchsiaResourceDialect,
52660 > {
52661 StreamSocketProxyInterface::r#get_tcp_defer_accept(self)
52662 }
52663
52664 pub fn r#set_tcp_window_clamp(
52666 &self,
52667 mut value: u32,
52668 ) -> fidl::client::QueryResponseFut<
52669 StreamSocketSetTcpWindowClampResult,
52670 fidl::encoding::DefaultFuchsiaResourceDialect,
52671 > {
52672 StreamSocketProxyInterface::r#set_tcp_window_clamp(self, value)
52673 }
52674
52675 pub fn r#get_tcp_window_clamp(
52677 &self,
52678 ) -> fidl::client::QueryResponseFut<
52679 StreamSocketGetTcpWindowClampResult,
52680 fidl::encoding::DefaultFuchsiaResourceDialect,
52681 > {
52682 StreamSocketProxyInterface::r#get_tcp_window_clamp(self)
52683 }
52684
52685 pub fn r#get_tcp_info(
52687 &self,
52688 ) -> fidl::client::QueryResponseFut<
52689 StreamSocketGetTcpInfoResult,
52690 fidl::encoding::DefaultFuchsiaResourceDialect,
52691 > {
52692 StreamSocketProxyInterface::r#get_tcp_info(self)
52693 }
52694
52695 pub fn r#set_tcp_quick_ack(
52697 &self,
52698 mut value: bool,
52699 ) -> fidl::client::QueryResponseFut<
52700 StreamSocketSetTcpQuickAckResult,
52701 fidl::encoding::DefaultFuchsiaResourceDialect,
52702 > {
52703 StreamSocketProxyInterface::r#set_tcp_quick_ack(self, value)
52704 }
52705
52706 pub fn r#get_tcp_quick_ack(
52708 &self,
52709 ) -> fidl::client::QueryResponseFut<
52710 StreamSocketGetTcpQuickAckResult,
52711 fidl::encoding::DefaultFuchsiaResourceDialect,
52712 > {
52713 StreamSocketProxyInterface::r#get_tcp_quick_ack(self)
52714 }
52715
52716 pub fn r#set_tcp_congestion(
52718 &self,
52719 mut value: TcpCongestionControl,
52720 ) -> fidl::client::QueryResponseFut<
52721 StreamSocketSetTcpCongestionResult,
52722 fidl::encoding::DefaultFuchsiaResourceDialect,
52723 > {
52724 StreamSocketProxyInterface::r#set_tcp_congestion(self, value)
52725 }
52726
52727 pub fn r#get_tcp_congestion(
52729 &self,
52730 ) -> fidl::client::QueryResponseFut<
52731 StreamSocketGetTcpCongestionResult,
52732 fidl::encoding::DefaultFuchsiaResourceDialect,
52733 > {
52734 StreamSocketProxyInterface::r#get_tcp_congestion(self)
52735 }
52736
52737 pub fn r#set_tcp_user_timeout(
52739 &self,
52740 mut value_millis: u32,
52741 ) -> fidl::client::QueryResponseFut<
52742 StreamSocketSetTcpUserTimeoutResult,
52743 fidl::encoding::DefaultFuchsiaResourceDialect,
52744 > {
52745 StreamSocketProxyInterface::r#set_tcp_user_timeout(self, value_millis)
52746 }
52747
52748 pub fn r#get_tcp_user_timeout(
52750 &self,
52751 ) -> fidl::client::QueryResponseFut<
52752 StreamSocketGetTcpUserTimeoutResult,
52753 fidl::encoding::DefaultFuchsiaResourceDialect,
52754 > {
52755 StreamSocketProxyInterface::r#get_tcp_user_timeout(self)
52756 }
52757}
52758
52759impl StreamSocketProxyInterface for StreamSocketProxy {
52760 fn r#clone(
52761 &self,
52762 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
52763 ) -> Result<(), fidl::Error> {
52764 self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
52765 (request,),
52766 0x20d8a7aba2168a79,
52767 fidl::encoding::DynamicFlags::empty(),
52768 )
52769 }
52770
52771 type CloseResponseFut = fidl::client::QueryResponseFut<
52772 fidl_fuchsia_unknown::CloseableCloseResult,
52773 fidl::encoding::DefaultFuchsiaResourceDialect,
52774 >;
52775 fn r#close(&self) -> Self::CloseResponseFut {
52776 fn _decode(
52777 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52778 ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
52779 let _response = fidl::client::decode_transaction_body::<
52780 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
52781 fidl::encoding::DefaultFuchsiaResourceDialect,
52782 0x5ac5d459ad7f657e,
52783 >(_buf?)?;
52784 Ok(_response.map(|x| x))
52785 }
52786 self.client.send_query_and_decode::<
52787 fidl::encoding::EmptyPayload,
52788 fidl_fuchsia_unknown::CloseableCloseResult,
52789 >(
52790 (),
52791 0x5ac5d459ad7f657e,
52792 fidl::encoding::DynamicFlags::empty(),
52793 _decode,
52794 )
52795 }
52796
52797 type QueryResponseFut =
52798 fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
52799 fn r#query(&self) -> Self::QueryResponseFut {
52800 fn _decode(
52801 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52802 ) -> Result<Vec<u8>, fidl::Error> {
52803 let _response = fidl::client::decode_transaction_body::<
52804 fidl_fuchsia_unknown::QueryableQueryResponse,
52805 fidl::encoding::DefaultFuchsiaResourceDialect,
52806 0x2658edee9decfc06,
52807 >(_buf?)?;
52808 Ok(_response.protocol)
52809 }
52810 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
52811 (),
52812 0x2658edee9decfc06,
52813 fidl::encoding::DynamicFlags::empty(),
52814 _decode,
52815 )
52816 }
52817
52818 type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
52819 BaseSocketSetReuseAddressResult,
52820 fidl::encoding::DefaultFuchsiaResourceDialect,
52821 >;
52822 fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
52823 fn _decode(
52824 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52825 ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
52826 let _response = fidl::client::decode_transaction_body::<
52827 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
52828 fidl::encoding::DefaultFuchsiaResourceDialect,
52829 0x1fd74ee8b9a4a876,
52830 >(_buf?)?;
52831 Ok(_response.map(|x| x))
52832 }
52833 self.client.send_query_and_decode::<
52834 BaseSocketSetReuseAddressRequest,
52835 BaseSocketSetReuseAddressResult,
52836 >(
52837 (value,),
52838 0x1fd74ee8b9a4a876,
52839 fidl::encoding::DynamicFlags::empty(),
52840 _decode,
52841 )
52842 }
52843
52844 type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
52845 BaseSocketGetReuseAddressResult,
52846 fidl::encoding::DefaultFuchsiaResourceDialect,
52847 >;
52848 fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
52849 fn _decode(
52850 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52851 ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
52852 let _response = fidl::client::decode_transaction_body::<
52853 fidl::encoding::ResultType<
52854 BaseSocketGetReuseAddressResponse,
52855 fidl_fuchsia_posix::Errno,
52856 >,
52857 fidl::encoding::DefaultFuchsiaResourceDialect,
52858 0x67b7206b8d1bc0a5,
52859 >(_buf?)?;
52860 Ok(_response.map(|x| x.value))
52861 }
52862 self.client
52863 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
52864 (),
52865 0x67b7206b8d1bc0a5,
52866 fidl::encoding::DynamicFlags::empty(),
52867 _decode,
52868 )
52869 }
52870
52871 type GetErrorResponseFut = fidl::client::QueryResponseFut<
52872 BaseSocketGetErrorResult,
52873 fidl::encoding::DefaultFuchsiaResourceDialect,
52874 >;
52875 fn r#get_error(&self) -> Self::GetErrorResponseFut {
52876 fn _decode(
52877 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52878 ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
52879 let _response = fidl::client::decode_transaction_body::<
52880 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
52881 fidl::encoding::DefaultFuchsiaResourceDialect,
52882 0x5aad39b33e5f6ebb,
52883 >(_buf?)?;
52884 Ok(_response.map(|x| x))
52885 }
52886 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
52887 (),
52888 0x5aad39b33e5f6ebb,
52889 fidl::encoding::DynamicFlags::empty(),
52890 _decode,
52891 )
52892 }
52893
52894 type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
52895 BaseSocketSetBroadcastResult,
52896 fidl::encoding::DefaultFuchsiaResourceDialect,
52897 >;
52898 fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
52899 fn _decode(
52900 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52901 ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
52902 let _response = fidl::client::decode_transaction_body::<
52903 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
52904 fidl::encoding::DefaultFuchsiaResourceDialect,
52905 0x6023e081ce3cd947,
52906 >(_buf?)?;
52907 Ok(_response.map(|x| x))
52908 }
52909 self.client
52910 .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
52911 (value,),
52912 0x6023e081ce3cd947,
52913 fidl::encoding::DynamicFlags::empty(),
52914 _decode,
52915 )
52916 }
52917
52918 type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
52919 BaseSocketGetBroadcastResult,
52920 fidl::encoding::DefaultFuchsiaResourceDialect,
52921 >;
52922 fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
52923 fn _decode(
52924 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52925 ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
52926 let _response = fidl::client::decode_transaction_body::<
52927 fidl::encoding::ResultType<
52928 BaseSocketGetBroadcastResponse,
52929 fidl_fuchsia_posix::Errno,
52930 >,
52931 fidl::encoding::DefaultFuchsiaResourceDialect,
52932 0x68796fc556f9780d,
52933 >(_buf?)?;
52934 Ok(_response.map(|x| x.value))
52935 }
52936 self.client
52937 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
52938 (),
52939 0x68796fc556f9780d,
52940 fidl::encoding::DynamicFlags::empty(),
52941 _decode,
52942 )
52943 }
52944
52945 type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
52946 BaseSocketSetSendBufferResult,
52947 fidl::encoding::DefaultFuchsiaResourceDialect,
52948 >;
52949 fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
52950 fn _decode(
52951 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52952 ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
52953 let _response = fidl::client::decode_transaction_body::<
52954 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
52955 fidl::encoding::DefaultFuchsiaResourceDialect,
52956 0x756eac32d73a7a70,
52957 >(_buf?)?;
52958 Ok(_response.map(|x| x))
52959 }
52960 self.client
52961 .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
52962 (value_bytes,),
52963 0x756eac32d73a7a70,
52964 fidl::encoding::DynamicFlags::empty(),
52965 _decode,
52966 )
52967 }
52968
52969 type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
52970 BaseSocketGetSendBufferResult,
52971 fidl::encoding::DefaultFuchsiaResourceDialect,
52972 >;
52973 fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
52974 fn _decode(
52975 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52976 ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
52977 let _response = fidl::client::decode_transaction_body::<
52978 fidl::encoding::ResultType<
52979 BaseSocketGetSendBufferResponse,
52980 fidl_fuchsia_posix::Errno,
52981 >,
52982 fidl::encoding::DefaultFuchsiaResourceDialect,
52983 0x78a52fd9c7b2410b,
52984 >(_buf?)?;
52985 Ok(_response.map(|x| x.value_bytes))
52986 }
52987 self.client
52988 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
52989 (),
52990 0x78a52fd9c7b2410b,
52991 fidl::encoding::DynamicFlags::empty(),
52992 _decode,
52993 )
52994 }
52995
52996 type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
52997 BaseSocketSetReceiveBufferResult,
52998 fidl::encoding::DefaultFuchsiaResourceDialect,
52999 >;
53000 fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
53001 fn _decode(
53002 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53003 ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
53004 let _response = fidl::client::decode_transaction_body::<
53005 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53006 fidl::encoding::DefaultFuchsiaResourceDialect,
53007 0x6b0cf2f1919c7001,
53008 >(_buf?)?;
53009 Ok(_response.map(|x| x))
53010 }
53011 self.client.send_query_and_decode::<
53012 BaseSocketSetReceiveBufferRequest,
53013 BaseSocketSetReceiveBufferResult,
53014 >(
53015 (value_bytes,),
53016 0x6b0cf2f1919c7001,
53017 fidl::encoding::DynamicFlags::empty(),
53018 _decode,
53019 )
53020 }
53021
53022 type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
53023 BaseSocketGetReceiveBufferResult,
53024 fidl::encoding::DefaultFuchsiaResourceDialect,
53025 >;
53026 fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
53027 fn _decode(
53028 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53029 ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
53030 let _response = fidl::client::decode_transaction_body::<
53031 fidl::encoding::ResultType<
53032 BaseSocketGetReceiveBufferResponse,
53033 fidl_fuchsia_posix::Errno,
53034 >,
53035 fidl::encoding::DefaultFuchsiaResourceDialect,
53036 0x14c1a4b64f709e5c,
53037 >(_buf?)?;
53038 Ok(_response.map(|x| x.value_bytes))
53039 }
53040 self.client.send_query_and_decode::<
53041 fidl::encoding::EmptyPayload,
53042 BaseSocketGetReceiveBufferResult,
53043 >(
53044 (),
53045 0x14c1a4b64f709e5c,
53046 fidl::encoding::DynamicFlags::empty(),
53047 _decode,
53048 )
53049 }
53050
53051 type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
53052 BaseSocketSetKeepAliveResult,
53053 fidl::encoding::DefaultFuchsiaResourceDialect,
53054 >;
53055 fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
53056 fn _decode(
53057 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53058 ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
53059 let _response = fidl::client::decode_transaction_body::<
53060 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53061 fidl::encoding::DefaultFuchsiaResourceDialect,
53062 0x572df8f0b920d2c7,
53063 >(_buf?)?;
53064 Ok(_response.map(|x| x))
53065 }
53066 self.client
53067 .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
53068 (value,),
53069 0x572df8f0b920d2c7,
53070 fidl::encoding::DynamicFlags::empty(),
53071 _decode,
53072 )
53073 }
53074
53075 type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
53076 BaseSocketGetKeepAliveResult,
53077 fidl::encoding::DefaultFuchsiaResourceDialect,
53078 >;
53079 fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
53080 fn _decode(
53081 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53082 ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
53083 let _response = fidl::client::decode_transaction_body::<
53084 fidl::encoding::ResultType<
53085 BaseSocketGetKeepAliveResponse,
53086 fidl_fuchsia_posix::Errno,
53087 >,
53088 fidl::encoding::DefaultFuchsiaResourceDialect,
53089 0x2dd29d3215f2c9d2,
53090 >(_buf?)?;
53091 Ok(_response.map(|x| x.value))
53092 }
53093 self.client
53094 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
53095 (),
53096 0x2dd29d3215f2c9d2,
53097 fidl::encoding::DynamicFlags::empty(),
53098 _decode,
53099 )
53100 }
53101
53102 type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
53103 BaseSocketSetOutOfBandInlineResult,
53104 fidl::encoding::DefaultFuchsiaResourceDialect,
53105 >;
53106 fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
53107 fn _decode(
53108 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53109 ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
53110 let _response = fidl::client::decode_transaction_body::<
53111 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53112 fidl::encoding::DefaultFuchsiaResourceDialect,
53113 0x3ecb49968bee439,
53114 >(_buf?)?;
53115 Ok(_response.map(|x| x))
53116 }
53117 self.client.send_query_and_decode::<
53118 BaseSocketSetOutOfBandInlineRequest,
53119 BaseSocketSetOutOfBandInlineResult,
53120 >(
53121 (value,),
53122 0x3ecb49968bee439,
53123 fidl::encoding::DynamicFlags::empty(),
53124 _decode,
53125 )
53126 }
53127
53128 type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
53129 BaseSocketGetOutOfBandInlineResult,
53130 fidl::encoding::DefaultFuchsiaResourceDialect,
53131 >;
53132 fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
53133 fn _decode(
53134 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53135 ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
53136 let _response = fidl::client::decode_transaction_body::<
53137 fidl::encoding::ResultType<
53138 BaseSocketGetOutOfBandInlineResponse,
53139 fidl_fuchsia_posix::Errno,
53140 >,
53141 fidl::encoding::DefaultFuchsiaResourceDialect,
53142 0x348c1ab3aeca1745,
53143 >(_buf?)?;
53144 Ok(_response.map(|x| x.value))
53145 }
53146 self.client.send_query_and_decode::<
53147 fidl::encoding::EmptyPayload,
53148 BaseSocketGetOutOfBandInlineResult,
53149 >(
53150 (),
53151 0x348c1ab3aeca1745,
53152 fidl::encoding::DynamicFlags::empty(),
53153 _decode,
53154 )
53155 }
53156
53157 type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
53158 BaseSocketSetNoCheckResult,
53159 fidl::encoding::DefaultFuchsiaResourceDialect,
53160 >;
53161 fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
53162 fn _decode(
53163 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53164 ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
53165 let _response = fidl::client::decode_transaction_body::<
53166 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53167 fidl::encoding::DefaultFuchsiaResourceDialect,
53168 0x6bbf00c53a4c78c2,
53169 >(_buf?)?;
53170 Ok(_response.map(|x| x))
53171 }
53172 self.client
53173 .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
53174 (value,),
53175 0x6bbf00c53a4c78c2,
53176 fidl::encoding::DynamicFlags::empty(),
53177 _decode,
53178 )
53179 }
53180
53181 type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
53182 BaseSocketGetNoCheckResult,
53183 fidl::encoding::DefaultFuchsiaResourceDialect,
53184 >;
53185 fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
53186 fn _decode(
53187 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53188 ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
53189 let _response = fidl::client::decode_transaction_body::<
53190 fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
53191 fidl::encoding::DefaultFuchsiaResourceDialect,
53192 0x2cd4249286417694,
53193 >(_buf?)?;
53194 Ok(_response.map(|x| x.value))
53195 }
53196 self.client
53197 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
53198 (),
53199 0x2cd4249286417694,
53200 fidl::encoding::DynamicFlags::empty(),
53201 _decode,
53202 )
53203 }
53204
53205 type SetLingerResponseFut = fidl::client::QueryResponseFut<
53206 BaseSocketSetLingerResult,
53207 fidl::encoding::DefaultFuchsiaResourceDialect,
53208 >;
53209 fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
53210 fn _decode(
53211 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53212 ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
53213 let _response = fidl::client::decode_transaction_body::<
53214 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53215 fidl::encoding::DefaultFuchsiaResourceDialect,
53216 0x45386351246e998e,
53217 >(_buf?)?;
53218 Ok(_response.map(|x| x))
53219 }
53220 self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
53221 (linger, length_secs),
53222 0x45386351246e998e,
53223 fidl::encoding::DynamicFlags::empty(),
53224 _decode,
53225 )
53226 }
53227
53228 type GetLingerResponseFut = fidl::client::QueryResponseFut<
53229 BaseSocketGetLingerResult,
53230 fidl::encoding::DefaultFuchsiaResourceDialect,
53231 >;
53232 fn r#get_linger(&self) -> Self::GetLingerResponseFut {
53233 fn _decode(
53234 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53235 ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
53236 let _response = fidl::client::decode_transaction_body::<
53237 fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
53238 fidl::encoding::DefaultFuchsiaResourceDialect,
53239 0x48eb20fc5ccb0e45,
53240 >(_buf?)?;
53241 Ok(_response.map(|x| (x.linger, x.length_secs)))
53242 }
53243 self.client
53244 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
53245 (),
53246 0x48eb20fc5ccb0e45,
53247 fidl::encoding::DynamicFlags::empty(),
53248 _decode,
53249 )
53250 }
53251
53252 type SetReusePortResponseFut = fidl::client::QueryResponseFut<
53253 BaseSocketSetReusePortResult,
53254 fidl::encoding::DefaultFuchsiaResourceDialect,
53255 >;
53256 fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
53257 fn _decode(
53258 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53259 ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
53260 let _response = fidl::client::decode_transaction_body::<
53261 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53262 fidl::encoding::DefaultFuchsiaResourceDialect,
53263 0x24dd3e5cb36d9ccb,
53264 >(_buf?)?;
53265 Ok(_response.map(|x| x))
53266 }
53267 self.client
53268 .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
53269 (value,),
53270 0x24dd3e5cb36d9ccb,
53271 fidl::encoding::DynamicFlags::empty(),
53272 _decode,
53273 )
53274 }
53275
53276 type GetReusePortResponseFut = fidl::client::QueryResponseFut<
53277 BaseSocketGetReusePortResult,
53278 fidl::encoding::DefaultFuchsiaResourceDialect,
53279 >;
53280 fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
53281 fn _decode(
53282 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53283 ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
53284 let _response = fidl::client::decode_transaction_body::<
53285 fidl::encoding::ResultType<
53286 BaseSocketGetReusePortResponse,
53287 fidl_fuchsia_posix::Errno,
53288 >,
53289 fidl::encoding::DefaultFuchsiaResourceDialect,
53290 0x7a112c1ab54ff828,
53291 >(_buf?)?;
53292 Ok(_response.map(|x| x.value))
53293 }
53294 self.client
53295 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
53296 (),
53297 0x7a112c1ab54ff828,
53298 fidl::encoding::DynamicFlags::empty(),
53299 _decode,
53300 )
53301 }
53302
53303 type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
53304 BaseSocketGetAcceptConnResult,
53305 fidl::encoding::DefaultFuchsiaResourceDialect,
53306 >;
53307 fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
53308 fn _decode(
53309 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53310 ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
53311 let _response = fidl::client::decode_transaction_body::<
53312 fidl::encoding::ResultType<
53313 BaseSocketGetAcceptConnResponse,
53314 fidl_fuchsia_posix::Errno,
53315 >,
53316 fidl::encoding::DefaultFuchsiaResourceDialect,
53317 0x67ce6db6c2ec8966,
53318 >(_buf?)?;
53319 Ok(_response.map(|x| x.value))
53320 }
53321 self.client
53322 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
53323 (),
53324 0x67ce6db6c2ec8966,
53325 fidl::encoding::DynamicFlags::empty(),
53326 _decode,
53327 )
53328 }
53329
53330 type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
53331 BaseSocketSetBindToDeviceResult,
53332 fidl::encoding::DefaultFuchsiaResourceDialect,
53333 >;
53334 fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
53335 fn _decode(
53336 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53337 ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
53338 let _response = fidl::client::decode_transaction_body::<
53339 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53340 fidl::encoding::DefaultFuchsiaResourceDialect,
53341 0x2118b483f28aafc4,
53342 >(_buf?)?;
53343 Ok(_response.map(|x| x))
53344 }
53345 self.client.send_query_and_decode::<
53346 BaseSocketSetBindToDeviceRequest,
53347 BaseSocketSetBindToDeviceResult,
53348 >(
53349 (value,),
53350 0x2118b483f28aafc4,
53351 fidl::encoding::DynamicFlags::empty(),
53352 _decode,
53353 )
53354 }
53355
53356 type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
53357 BaseSocketGetBindToDeviceResult,
53358 fidl::encoding::DefaultFuchsiaResourceDialect,
53359 >;
53360 fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
53361 fn _decode(
53362 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53363 ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
53364 let _response = fidl::client::decode_transaction_body::<
53365 fidl::encoding::ResultType<
53366 BaseSocketGetBindToDeviceResponse,
53367 fidl_fuchsia_posix::Errno,
53368 >,
53369 fidl::encoding::DefaultFuchsiaResourceDialect,
53370 0x1ab1fbf0ef7906c8,
53371 >(_buf?)?;
53372 Ok(_response.map(|x| x.value))
53373 }
53374 self.client
53375 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
53376 (),
53377 0x1ab1fbf0ef7906c8,
53378 fidl::encoding::DynamicFlags::empty(),
53379 _decode,
53380 )
53381 }
53382
53383 type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
53384 BaseSocketSetBindToInterfaceIndexResult,
53385 fidl::encoding::DefaultFuchsiaResourceDialect,
53386 >;
53387 fn r#set_bind_to_interface_index(
53388 &self,
53389 mut value: u64,
53390 ) -> Self::SetBindToInterfaceIndexResponseFut {
53391 fn _decode(
53392 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53393 ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
53394 let _response = fidl::client::decode_transaction_body::<
53395 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53396 fidl::encoding::DefaultFuchsiaResourceDialect,
53397 0x6e387a0def00821,
53398 >(_buf?)?;
53399 Ok(_response.map(|x| x))
53400 }
53401 self.client.send_query_and_decode::<
53402 BaseSocketSetBindToInterfaceIndexRequest,
53403 BaseSocketSetBindToInterfaceIndexResult,
53404 >(
53405 (value,),
53406 0x6e387a0def00821,
53407 fidl::encoding::DynamicFlags::empty(),
53408 _decode,
53409 )
53410 }
53411
53412 type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
53413 BaseSocketGetBindToInterfaceIndexResult,
53414 fidl::encoding::DefaultFuchsiaResourceDialect,
53415 >;
53416 fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
53417 fn _decode(
53418 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53419 ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
53420 let _response = fidl::client::decode_transaction_body::<
53421 fidl::encoding::ResultType<
53422 BaseSocketGetBindToInterfaceIndexResponse,
53423 fidl_fuchsia_posix::Errno,
53424 >,
53425 fidl::encoding::DefaultFuchsiaResourceDialect,
53426 0x59c31dd3e3078295,
53427 >(_buf?)?;
53428 Ok(_response.map(|x| x.value))
53429 }
53430 self.client.send_query_and_decode::<
53431 fidl::encoding::EmptyPayload,
53432 BaseSocketGetBindToInterfaceIndexResult,
53433 >(
53434 (),
53435 0x59c31dd3e3078295,
53436 fidl::encoding::DynamicFlags::empty(),
53437 _decode,
53438 )
53439 }
53440
53441 type SetTimestampResponseFut = fidl::client::QueryResponseFut<
53442 BaseSocketSetTimestampResult,
53443 fidl::encoding::DefaultFuchsiaResourceDialect,
53444 >;
53445 fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
53446 fn _decode(
53447 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53448 ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
53449 let _response = fidl::client::decode_transaction_body::<
53450 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53451 fidl::encoding::DefaultFuchsiaResourceDialect,
53452 0x285d6516c263d839,
53453 >(_buf?)?;
53454 Ok(_response.map(|x| x))
53455 }
53456 self.client
53457 .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
53458 (value,),
53459 0x285d6516c263d839,
53460 fidl::encoding::DynamicFlags::empty(),
53461 _decode,
53462 )
53463 }
53464
53465 type GetTimestampResponseFut = fidl::client::QueryResponseFut<
53466 BaseSocketGetTimestampResult,
53467 fidl::encoding::DefaultFuchsiaResourceDialect,
53468 >;
53469 fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
53470 fn _decode(
53471 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53472 ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
53473 let _response = fidl::client::decode_transaction_body::<
53474 fidl::encoding::ResultType<
53475 BaseSocketGetTimestampResponse,
53476 fidl_fuchsia_posix::Errno,
53477 >,
53478 fidl::encoding::DefaultFuchsiaResourceDialect,
53479 0x49f2fffbbcc2bd27,
53480 >(_buf?)?;
53481 Ok(_response.map(|x| x.value))
53482 }
53483 self.client
53484 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
53485 (),
53486 0x49f2fffbbcc2bd27,
53487 fidl::encoding::DynamicFlags::empty(),
53488 _decode,
53489 )
53490 }
53491
53492 type SetMarkResponseFut = fidl::client::QueryResponseFut<
53493 BaseSocketSetMarkResult,
53494 fidl::encoding::DefaultFuchsiaResourceDialect,
53495 >;
53496 fn r#set_mark(
53497 &self,
53498 mut domain: fidl_fuchsia_net::MarkDomain,
53499 mut mark: &OptionalUint32,
53500 ) -> Self::SetMarkResponseFut {
53501 fn _decode(
53502 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53503 ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
53504 let _response = fidl::client::decode_transaction_body::<
53505 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53506 fidl::encoding::DefaultFuchsiaResourceDialect,
53507 0x6ead6de09f653236,
53508 >(_buf?)?;
53509 Ok(_response.map(|x| x))
53510 }
53511 self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
53512 (domain, mark),
53513 0x6ead6de09f653236,
53514 fidl::encoding::DynamicFlags::empty(),
53515 _decode,
53516 )
53517 }
53518
53519 type GetMarkResponseFut = fidl::client::QueryResponseFut<
53520 BaseSocketGetMarkResult,
53521 fidl::encoding::DefaultFuchsiaResourceDialect,
53522 >;
53523 fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
53524 fn _decode(
53525 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53526 ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
53527 let _response = fidl::client::decode_transaction_body::<
53528 fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
53529 fidl::encoding::DefaultFuchsiaResourceDialect,
53530 0x57a2752c61d93d47,
53531 >(_buf?)?;
53532 Ok(_response.map(|x| x.mark))
53533 }
53534 self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
53535 (domain,),
53536 0x57a2752c61d93d47,
53537 fidl::encoding::DynamicFlags::empty(),
53538 _decode,
53539 )
53540 }
53541
53542 type BindResponseFut = fidl::client::QueryResponseFut<
53543 BaseNetworkSocketBindResult,
53544 fidl::encoding::DefaultFuchsiaResourceDialect,
53545 >;
53546 fn r#bind(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut {
53547 fn _decode(
53548 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53549 ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
53550 let _response = fidl::client::decode_transaction_body::<
53551 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53552 fidl::encoding::DefaultFuchsiaResourceDialect,
53553 0x4bc6400ae92125d,
53554 >(_buf?)?;
53555 Ok(_response.map(|x| x))
53556 }
53557 self.client
53558 .send_query_and_decode::<BaseNetworkSocketBindRequest, BaseNetworkSocketBindResult>(
53559 (addr,),
53560 0x4bc6400ae92125d,
53561 fidl::encoding::DynamicFlags::empty(),
53562 _decode,
53563 )
53564 }
53565
53566 type ConnectResponseFut = fidl::client::QueryResponseFut<
53567 BaseNetworkSocketConnectResult,
53568 fidl::encoding::DefaultFuchsiaResourceDialect,
53569 >;
53570 fn r#connect(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut {
53571 fn _decode(
53572 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53573 ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
53574 let _response = fidl::client::decode_transaction_body::<
53575 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53576 fidl::encoding::DefaultFuchsiaResourceDialect,
53577 0x5f05f19bfdd38871,
53578 >(_buf?)?;
53579 Ok(_response.map(|x| x))
53580 }
53581 self.client.send_query_and_decode::<
53582 BaseNetworkSocketConnectRequest,
53583 BaseNetworkSocketConnectResult,
53584 >(
53585 (addr,),
53586 0x5f05f19bfdd38871,
53587 fidl::encoding::DynamicFlags::empty(),
53588 _decode,
53589 )
53590 }
53591
53592 type DisconnectResponseFut = fidl::client::QueryResponseFut<
53593 BaseNetworkSocketDisconnectResult,
53594 fidl::encoding::DefaultFuchsiaResourceDialect,
53595 >;
53596 fn r#disconnect(&self) -> Self::DisconnectResponseFut {
53597 fn _decode(
53598 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53599 ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
53600 let _response = fidl::client::decode_transaction_body::<
53601 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53602 fidl::encoding::DefaultFuchsiaResourceDialect,
53603 0x74e63b91f7b29b2,
53604 >(_buf?)?;
53605 Ok(_response.map(|x| x))
53606 }
53607 self.client.send_query_and_decode::<
53608 fidl::encoding::EmptyPayload,
53609 BaseNetworkSocketDisconnectResult,
53610 >(
53611 (),
53612 0x74e63b91f7b29b2,
53613 fidl::encoding::DynamicFlags::empty(),
53614 _decode,
53615 )
53616 }
53617
53618 type GetSockNameResponseFut = fidl::client::QueryResponseFut<
53619 BaseNetworkSocketGetSockNameResult,
53620 fidl::encoding::DefaultFuchsiaResourceDialect,
53621 >;
53622 fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
53623 fn _decode(
53624 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53625 ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
53626 let _response = fidl::client::decode_transaction_body::<
53627 fidl::encoding::ResultType<
53628 BaseNetworkSocketGetSockNameResponse,
53629 fidl_fuchsia_posix::Errno,
53630 >,
53631 fidl::encoding::DefaultFuchsiaResourceDialect,
53632 0x475f23f84a1a4f85,
53633 >(_buf?)?;
53634 Ok(_response.map(|x| x.addr))
53635 }
53636 self.client.send_query_and_decode::<
53637 fidl::encoding::EmptyPayload,
53638 BaseNetworkSocketGetSockNameResult,
53639 >(
53640 (),
53641 0x475f23f84a1a4f85,
53642 fidl::encoding::DynamicFlags::empty(),
53643 _decode,
53644 )
53645 }
53646
53647 type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
53648 BaseNetworkSocketGetPeerNameResult,
53649 fidl::encoding::DefaultFuchsiaResourceDialect,
53650 >;
53651 fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
53652 fn _decode(
53653 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53654 ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
53655 let _response = fidl::client::decode_transaction_body::<
53656 fidl::encoding::ResultType<
53657 BaseNetworkSocketGetPeerNameResponse,
53658 fidl_fuchsia_posix::Errno,
53659 >,
53660 fidl::encoding::DefaultFuchsiaResourceDialect,
53661 0x1ffecf4bd5b6432e,
53662 >(_buf?)?;
53663 Ok(_response.map(|x| x.addr))
53664 }
53665 self.client.send_query_and_decode::<
53666 fidl::encoding::EmptyPayload,
53667 BaseNetworkSocketGetPeerNameResult,
53668 >(
53669 (),
53670 0x1ffecf4bd5b6432e,
53671 fidl::encoding::DynamicFlags::empty(),
53672 _decode,
53673 )
53674 }
53675
53676 type ShutdownResponseFut = fidl::client::QueryResponseFut<
53677 BaseNetworkSocketShutdownResult,
53678 fidl::encoding::DefaultFuchsiaResourceDialect,
53679 >;
53680 fn r#shutdown(&self, mut mode: ShutdownMode) -> Self::ShutdownResponseFut {
53681 fn _decode(
53682 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53683 ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
53684 let _response = fidl::client::decode_transaction_body::<
53685 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53686 fidl::encoding::DefaultFuchsiaResourceDialect,
53687 0x247f38b6db68c336,
53688 >(_buf?)?;
53689 Ok(_response.map(|x| x))
53690 }
53691 self.client.send_query_and_decode::<
53692 BaseNetworkSocketShutdownRequest,
53693 BaseNetworkSocketShutdownResult,
53694 >(
53695 (mode,),
53696 0x247f38b6db68c336,
53697 fidl::encoding::DynamicFlags::empty(),
53698 _decode,
53699 )
53700 }
53701
53702 type SetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
53703 BaseNetworkSocketSetIpTypeOfServiceResult,
53704 fidl::encoding::DefaultFuchsiaResourceDialect,
53705 >;
53706 fn r#set_ip_type_of_service(&self, mut value: u8) -> Self::SetIpTypeOfServiceResponseFut {
53707 fn _decode(
53708 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53709 ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
53710 let _response = fidl::client::decode_transaction_body::<
53711 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53712 fidl::encoding::DefaultFuchsiaResourceDialect,
53713 0x995c600475b6d46,
53714 >(_buf?)?;
53715 Ok(_response.map(|x| x))
53716 }
53717 self.client.send_query_and_decode::<
53718 BaseNetworkSocketSetIpTypeOfServiceRequest,
53719 BaseNetworkSocketSetIpTypeOfServiceResult,
53720 >(
53721 (value,),
53722 0x995c600475b6d46,
53723 fidl::encoding::DynamicFlags::empty(),
53724 _decode,
53725 )
53726 }
53727
53728 type GetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
53729 BaseNetworkSocketGetIpTypeOfServiceResult,
53730 fidl::encoding::DefaultFuchsiaResourceDialect,
53731 >;
53732 fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut {
53733 fn _decode(
53734 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53735 ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
53736 let _response = fidl::client::decode_transaction_body::<
53737 fidl::encoding::ResultType<
53738 BaseNetworkSocketGetIpTypeOfServiceResponse,
53739 fidl_fuchsia_posix::Errno,
53740 >,
53741 fidl::encoding::DefaultFuchsiaResourceDialect,
53742 0x3814a04259f75fcb,
53743 >(_buf?)?;
53744 Ok(_response.map(|x| x.value))
53745 }
53746 self.client.send_query_and_decode::<
53747 fidl::encoding::EmptyPayload,
53748 BaseNetworkSocketGetIpTypeOfServiceResult,
53749 >(
53750 (),
53751 0x3814a04259f75fcb,
53752 fidl::encoding::DynamicFlags::empty(),
53753 _decode,
53754 )
53755 }
53756
53757 type SetIpTtlResponseFut = fidl::client::QueryResponseFut<
53758 BaseNetworkSocketSetIpTtlResult,
53759 fidl::encoding::DefaultFuchsiaResourceDialect,
53760 >;
53761 fn r#set_ip_ttl(&self, mut value: &OptionalUint8) -> Self::SetIpTtlResponseFut {
53762 fn _decode(
53763 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53764 ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
53765 let _response = fidl::client::decode_transaction_body::<
53766 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53767 fidl::encoding::DefaultFuchsiaResourceDialect,
53768 0x29e2424b433ae1ef,
53769 >(_buf?)?;
53770 Ok(_response.map(|x| x))
53771 }
53772 self.client.send_query_and_decode::<
53773 BaseNetworkSocketSetIpTtlRequest,
53774 BaseNetworkSocketSetIpTtlResult,
53775 >(
53776 (value,),
53777 0x29e2424b433ae1ef,
53778 fidl::encoding::DynamicFlags::empty(),
53779 _decode,
53780 )
53781 }
53782
53783 type GetIpTtlResponseFut = fidl::client::QueryResponseFut<
53784 BaseNetworkSocketGetIpTtlResult,
53785 fidl::encoding::DefaultFuchsiaResourceDialect,
53786 >;
53787 fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut {
53788 fn _decode(
53789 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53790 ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
53791 let _response = fidl::client::decode_transaction_body::<
53792 fidl::encoding::ResultType<
53793 BaseNetworkSocketGetIpTtlResponse,
53794 fidl_fuchsia_posix::Errno,
53795 >,
53796 fidl::encoding::DefaultFuchsiaResourceDialect,
53797 0x47e47fa1f24da471,
53798 >(_buf?)?;
53799 Ok(_response.map(|x| x.value))
53800 }
53801 self.client
53802 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseNetworkSocketGetIpTtlResult>(
53803 (),
53804 0x47e47fa1f24da471,
53805 fidl::encoding::DynamicFlags::empty(),
53806 _decode,
53807 )
53808 }
53809
53810 type SetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
53811 BaseNetworkSocketSetIpPacketInfoResult,
53812 fidl::encoding::DefaultFuchsiaResourceDialect,
53813 >;
53814 fn r#set_ip_packet_info(&self, mut value: bool) -> Self::SetIpPacketInfoResponseFut {
53815 fn _decode(
53816 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53817 ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
53818 let _response = fidl::client::decode_transaction_body::<
53819 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53820 fidl::encoding::DefaultFuchsiaResourceDialect,
53821 0x392d16bee20c0e16,
53822 >(_buf?)?;
53823 Ok(_response.map(|x| x))
53824 }
53825 self.client.send_query_and_decode::<
53826 BaseNetworkSocketSetIpPacketInfoRequest,
53827 BaseNetworkSocketSetIpPacketInfoResult,
53828 >(
53829 (value,),
53830 0x392d16bee20c0e16,
53831 fidl::encoding::DynamicFlags::empty(),
53832 _decode,
53833 )
53834 }
53835
53836 type GetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
53837 BaseNetworkSocketGetIpPacketInfoResult,
53838 fidl::encoding::DefaultFuchsiaResourceDialect,
53839 >;
53840 fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut {
53841 fn _decode(
53842 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53843 ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
53844 let _response = fidl::client::decode_transaction_body::<
53845 fidl::encoding::ResultType<
53846 BaseNetworkSocketGetIpPacketInfoResponse,
53847 fidl_fuchsia_posix::Errno,
53848 >,
53849 fidl::encoding::DefaultFuchsiaResourceDialect,
53850 0x54b505f242280740,
53851 >(_buf?)?;
53852 Ok(_response.map(|x| x.value))
53853 }
53854 self.client.send_query_and_decode::<
53855 fidl::encoding::EmptyPayload,
53856 BaseNetworkSocketGetIpPacketInfoResult,
53857 >(
53858 (),
53859 0x54b505f242280740,
53860 fidl::encoding::DynamicFlags::empty(),
53861 _decode,
53862 )
53863 }
53864
53865 type SetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
53866 BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
53867 fidl::encoding::DefaultFuchsiaResourceDialect,
53868 >;
53869 fn r#set_ip_receive_type_of_service(
53870 &self,
53871 mut value: bool,
53872 ) -> Self::SetIpReceiveTypeOfServiceResponseFut {
53873 fn _decode(
53874 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53875 ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
53876 let _response = fidl::client::decode_transaction_body::<
53877 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53878 fidl::encoding::DefaultFuchsiaResourceDialect,
53879 0x6c4f6714995f84ef,
53880 >(_buf?)?;
53881 Ok(_response.map(|x| x))
53882 }
53883 self.client.send_query_and_decode::<
53884 BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
53885 BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
53886 >(
53887 (value,),
53888 0x6c4f6714995f84ef,
53889 fidl::encoding::DynamicFlags::empty(),
53890 _decode,
53891 )
53892 }
53893
53894 type GetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
53895 BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
53896 fidl::encoding::DefaultFuchsiaResourceDialect,
53897 >;
53898 fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut {
53899 fn _decode(
53900 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53901 ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
53902 let _response = fidl::client::decode_transaction_body::<
53903 fidl::encoding::ResultType<
53904 BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
53905 fidl_fuchsia_posix::Errno,
53906 >,
53907 fidl::encoding::DefaultFuchsiaResourceDialect,
53908 0x4158ba7dc2795960,
53909 >(_buf?)?;
53910 Ok(_response.map(|x| x.value))
53911 }
53912 self.client.send_query_and_decode::<
53913 fidl::encoding::EmptyPayload,
53914 BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
53915 >(
53916 (),
53917 0x4158ba7dc2795960,
53918 fidl::encoding::DynamicFlags::empty(),
53919 _decode,
53920 )
53921 }
53922
53923 type SetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
53924 BaseNetworkSocketSetIpReceiveTtlResult,
53925 fidl::encoding::DefaultFuchsiaResourceDialect,
53926 >;
53927 fn r#set_ip_receive_ttl(&self, mut value: bool) -> Self::SetIpReceiveTtlResponseFut {
53928 fn _decode(
53929 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53930 ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
53931 let _response = fidl::client::decode_transaction_body::<
53932 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53933 fidl::encoding::DefaultFuchsiaResourceDialect,
53934 0x46f15be0ce0ab82b,
53935 >(_buf?)?;
53936 Ok(_response.map(|x| x))
53937 }
53938 self.client.send_query_and_decode::<
53939 BaseNetworkSocketSetIpReceiveTtlRequest,
53940 BaseNetworkSocketSetIpReceiveTtlResult,
53941 >(
53942 (value,),
53943 0x46f15be0ce0ab82b,
53944 fidl::encoding::DynamicFlags::empty(),
53945 _decode,
53946 )
53947 }
53948
53949 type GetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
53950 BaseNetworkSocketGetIpReceiveTtlResult,
53951 fidl::encoding::DefaultFuchsiaResourceDialect,
53952 >;
53953 fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut {
53954 fn _decode(
53955 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53956 ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
53957 let _response = fidl::client::decode_transaction_body::<
53958 fidl::encoding::ResultType<
53959 BaseNetworkSocketGetIpReceiveTtlResponse,
53960 fidl_fuchsia_posix::Errno,
53961 >,
53962 fidl::encoding::DefaultFuchsiaResourceDialect,
53963 0x678ddd5a5dfa2eb5,
53964 >(_buf?)?;
53965 Ok(_response.map(|x| x.value))
53966 }
53967 self.client.send_query_and_decode::<
53968 fidl::encoding::EmptyPayload,
53969 BaseNetworkSocketGetIpReceiveTtlResult,
53970 >(
53971 (),
53972 0x678ddd5a5dfa2eb5,
53973 fidl::encoding::DynamicFlags::empty(),
53974 _decode,
53975 )
53976 }
53977
53978 type SetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
53979 BaseNetworkSocketSetIpMulticastInterfaceResult,
53980 fidl::encoding::DefaultFuchsiaResourceDialect,
53981 >;
53982 fn r#set_ip_multicast_interface(
53983 &self,
53984 mut iface: u64,
53985 mut address: &fidl_fuchsia_net::Ipv4Address,
53986 ) -> Self::SetIpMulticastInterfaceResponseFut {
53987 fn _decode(
53988 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53989 ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
53990 let _response = fidl::client::decode_transaction_body::<
53991 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53992 fidl::encoding::DefaultFuchsiaResourceDialect,
53993 0x752fbfa9b12befe,
53994 >(_buf?)?;
53995 Ok(_response.map(|x| x))
53996 }
53997 self.client.send_query_and_decode::<
53998 BaseNetworkSocketSetIpMulticastInterfaceRequest,
53999 BaseNetworkSocketSetIpMulticastInterfaceResult,
54000 >(
54001 (iface, address,),
54002 0x752fbfa9b12befe,
54003 fidl::encoding::DynamicFlags::empty(),
54004 _decode,
54005 )
54006 }
54007
54008 type GetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
54009 BaseNetworkSocketGetIpMulticastInterfaceResult,
54010 fidl::encoding::DefaultFuchsiaResourceDialect,
54011 >;
54012 fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut {
54013 fn _decode(
54014 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54015 ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
54016 let _response = fidl::client::decode_transaction_body::<
54017 fidl::encoding::ResultType<
54018 BaseNetworkSocketGetIpMulticastInterfaceResponse,
54019 fidl_fuchsia_posix::Errno,
54020 >,
54021 fidl::encoding::DefaultFuchsiaResourceDialect,
54022 0x320bd14c4df046c4,
54023 >(_buf?)?;
54024 Ok(_response.map(|x| x.value))
54025 }
54026 self.client.send_query_and_decode::<
54027 fidl::encoding::EmptyPayload,
54028 BaseNetworkSocketGetIpMulticastInterfaceResult,
54029 >(
54030 (),
54031 0x320bd14c4df046c4,
54032 fidl::encoding::DynamicFlags::empty(),
54033 _decode,
54034 )
54035 }
54036
54037 type SetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
54038 BaseNetworkSocketSetIpMulticastTtlResult,
54039 fidl::encoding::DefaultFuchsiaResourceDialect,
54040 >;
54041 fn r#set_ip_multicast_ttl(
54042 &self,
54043 mut value: &OptionalUint8,
54044 ) -> Self::SetIpMulticastTtlResponseFut {
54045 fn _decode(
54046 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54047 ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
54048 let _response = fidl::client::decode_transaction_body::<
54049 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54050 fidl::encoding::DefaultFuchsiaResourceDialect,
54051 0x63134d53772916a1,
54052 >(_buf?)?;
54053 Ok(_response.map(|x| x))
54054 }
54055 self.client.send_query_and_decode::<
54056 BaseNetworkSocketSetIpMulticastTtlRequest,
54057 BaseNetworkSocketSetIpMulticastTtlResult,
54058 >(
54059 (value,),
54060 0x63134d53772916a1,
54061 fidl::encoding::DynamicFlags::empty(),
54062 _decode,
54063 )
54064 }
54065
54066 type GetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
54067 BaseNetworkSocketGetIpMulticastTtlResult,
54068 fidl::encoding::DefaultFuchsiaResourceDialect,
54069 >;
54070 fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut {
54071 fn _decode(
54072 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54073 ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
54074 let _response = fidl::client::decode_transaction_body::<
54075 fidl::encoding::ResultType<
54076 BaseNetworkSocketGetIpMulticastTtlResponse,
54077 fidl_fuchsia_posix::Errno,
54078 >,
54079 fidl::encoding::DefaultFuchsiaResourceDialect,
54080 0x4665cd378f39e1a,
54081 >(_buf?)?;
54082 Ok(_response.map(|x| x.value))
54083 }
54084 self.client.send_query_and_decode::<
54085 fidl::encoding::EmptyPayload,
54086 BaseNetworkSocketGetIpMulticastTtlResult,
54087 >(
54088 (),
54089 0x4665cd378f39e1a,
54090 fidl::encoding::DynamicFlags::empty(),
54091 _decode,
54092 )
54093 }
54094
54095 type SetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
54096 BaseNetworkSocketSetIpMulticastLoopbackResult,
54097 fidl::encoding::DefaultFuchsiaResourceDialect,
54098 >;
54099 fn r#set_ip_multicast_loopback(
54100 &self,
54101 mut value: bool,
54102 ) -> Self::SetIpMulticastLoopbackResponseFut {
54103 fn _decode(
54104 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54105 ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
54106 let _response = fidl::client::decode_transaction_body::<
54107 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54108 fidl::encoding::DefaultFuchsiaResourceDialect,
54109 0x20c55c11f00943ea,
54110 >(_buf?)?;
54111 Ok(_response.map(|x| x))
54112 }
54113 self.client.send_query_and_decode::<
54114 BaseNetworkSocketSetIpMulticastLoopbackRequest,
54115 BaseNetworkSocketSetIpMulticastLoopbackResult,
54116 >(
54117 (value,),
54118 0x20c55c11f00943ea,
54119 fidl::encoding::DynamicFlags::empty(),
54120 _decode,
54121 )
54122 }
54123
54124 type GetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
54125 BaseNetworkSocketGetIpMulticastLoopbackResult,
54126 fidl::encoding::DefaultFuchsiaResourceDialect,
54127 >;
54128 fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut {
54129 fn _decode(
54130 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54131 ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
54132 let _response = fidl::client::decode_transaction_body::<
54133 fidl::encoding::ResultType<
54134 BaseNetworkSocketGetIpMulticastLoopbackResponse,
54135 fidl_fuchsia_posix::Errno,
54136 >,
54137 fidl::encoding::DefaultFuchsiaResourceDialect,
54138 0x3b6b26ff558298f2,
54139 >(_buf?)?;
54140 Ok(_response.map(|x| x.value))
54141 }
54142 self.client.send_query_and_decode::<
54143 fidl::encoding::EmptyPayload,
54144 BaseNetworkSocketGetIpMulticastLoopbackResult,
54145 >(
54146 (),
54147 0x3b6b26ff558298f2,
54148 fidl::encoding::DynamicFlags::empty(),
54149 _decode,
54150 )
54151 }
54152
54153 type AddIpMembershipResponseFut = fidl::client::QueryResponseFut<
54154 BaseNetworkSocketAddIpMembershipResult,
54155 fidl::encoding::DefaultFuchsiaResourceDialect,
54156 >;
54157 fn r#add_ip_membership(
54158 &self,
54159 mut membership: &IpMulticastMembership,
54160 ) -> Self::AddIpMembershipResponseFut {
54161 fn _decode(
54162 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54163 ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
54164 let _response = fidl::client::decode_transaction_body::<
54165 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54166 fidl::encoding::DefaultFuchsiaResourceDialect,
54167 0x76bc7df115a3b4d0,
54168 >(_buf?)?;
54169 Ok(_response.map(|x| x))
54170 }
54171 self.client.send_query_and_decode::<
54172 BaseNetworkSocketAddIpMembershipRequest,
54173 BaseNetworkSocketAddIpMembershipResult,
54174 >(
54175 (membership,),
54176 0x76bc7df115a3b4d0,
54177 fidl::encoding::DynamicFlags::empty(),
54178 _decode,
54179 )
54180 }
54181
54182 type DropIpMembershipResponseFut = fidl::client::QueryResponseFut<
54183 BaseNetworkSocketDropIpMembershipResult,
54184 fidl::encoding::DefaultFuchsiaResourceDialect,
54185 >;
54186 fn r#drop_ip_membership(
54187 &self,
54188 mut membership: &IpMulticastMembership,
54189 ) -> Self::DropIpMembershipResponseFut {
54190 fn _decode(
54191 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54192 ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
54193 let _response = fidl::client::decode_transaction_body::<
54194 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54195 fidl::encoding::DefaultFuchsiaResourceDialect,
54196 0x2888f3099188d03,
54197 >(_buf?)?;
54198 Ok(_response.map(|x| x))
54199 }
54200 self.client.send_query_and_decode::<
54201 BaseNetworkSocketDropIpMembershipRequest,
54202 BaseNetworkSocketDropIpMembershipResult,
54203 >(
54204 (membership,),
54205 0x2888f3099188d03,
54206 fidl::encoding::DynamicFlags::empty(),
54207 _decode,
54208 )
54209 }
54210
54211 type SetIpTransparentResponseFut = fidl::client::QueryResponseFut<
54212 BaseNetworkSocketSetIpTransparentResult,
54213 fidl::encoding::DefaultFuchsiaResourceDialect,
54214 >;
54215 fn r#set_ip_transparent(&self, mut value: bool) -> Self::SetIpTransparentResponseFut {
54216 fn _decode(
54217 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54218 ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
54219 let _response = fidl::client::decode_transaction_body::<
54220 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54221 fidl::encoding::DefaultFuchsiaResourceDialect,
54222 0x1ae532b0c066e3a0,
54223 >(_buf?)?;
54224 Ok(_response.map(|x| x))
54225 }
54226 self.client.send_query_and_decode::<
54227 BaseNetworkSocketSetIpTransparentRequest,
54228 BaseNetworkSocketSetIpTransparentResult,
54229 >(
54230 (value,),
54231 0x1ae532b0c066e3a0,
54232 fidl::encoding::DynamicFlags::empty(),
54233 _decode,
54234 )
54235 }
54236
54237 type GetIpTransparentResponseFut = fidl::client::QueryResponseFut<
54238 BaseNetworkSocketGetIpTransparentResult,
54239 fidl::encoding::DefaultFuchsiaResourceDialect,
54240 >;
54241 fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut {
54242 fn _decode(
54243 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54244 ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
54245 let _response = fidl::client::decode_transaction_body::<
54246 fidl::encoding::ResultType<
54247 BaseNetworkSocketGetIpTransparentResponse,
54248 fidl_fuchsia_posix::Errno,
54249 >,
54250 fidl::encoding::DefaultFuchsiaResourceDialect,
54251 0x51d43695962ebfb5,
54252 >(_buf?)?;
54253 Ok(_response.map(|x| x.value))
54254 }
54255 self.client.send_query_and_decode::<
54256 fidl::encoding::EmptyPayload,
54257 BaseNetworkSocketGetIpTransparentResult,
54258 >(
54259 (),
54260 0x51d43695962ebfb5,
54261 fidl::encoding::DynamicFlags::empty(),
54262 _decode,
54263 )
54264 }
54265
54266 type SetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
54267 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
54268 fidl::encoding::DefaultFuchsiaResourceDialect,
54269 >;
54270 fn r#set_ip_receive_original_destination_address(
54271 &self,
54272 mut value: bool,
54273 ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut {
54274 fn _decode(
54275 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54276 ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>
54277 {
54278 let _response = fidl::client::decode_transaction_body::<
54279 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54280 fidl::encoding::DefaultFuchsiaResourceDialect,
54281 0x4722b4ce52f7840,
54282 >(_buf?)?;
54283 Ok(_response.map(|x| x))
54284 }
54285 self.client.send_query_and_decode::<
54286 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
54287 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
54288 >(
54289 (value,),
54290 0x4722b4ce52f7840,
54291 fidl::encoding::DynamicFlags::empty(),
54292 _decode,
54293 )
54294 }
54295
54296 type GetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
54297 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
54298 fidl::encoding::DefaultFuchsiaResourceDialect,
54299 >;
54300 fn r#get_ip_receive_original_destination_address(
54301 &self,
54302 ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut {
54303 fn _decode(
54304 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54305 ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>
54306 {
54307 let _response = fidl::client::decode_transaction_body::<
54308 fidl::encoding::ResultType<
54309 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
54310 fidl_fuchsia_posix::Errno,
54311 >,
54312 fidl::encoding::DefaultFuchsiaResourceDialect,
54313 0x2a0e7dc5d6bfdfe9,
54314 >(_buf?)?;
54315 Ok(_response.map(|x| x.value))
54316 }
54317 self.client.send_query_and_decode::<
54318 fidl::encoding::EmptyPayload,
54319 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
54320 >(
54321 (),
54322 0x2a0e7dc5d6bfdfe9,
54323 fidl::encoding::DynamicFlags::empty(),
54324 _decode,
54325 )
54326 }
54327
54328 type AddIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
54329 BaseNetworkSocketAddIpv6MembershipResult,
54330 fidl::encoding::DefaultFuchsiaResourceDialect,
54331 >;
54332 fn r#add_ipv6_membership(
54333 &self,
54334 mut membership: &Ipv6MulticastMembership,
54335 ) -> Self::AddIpv6MembershipResponseFut {
54336 fn _decode(
54337 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54338 ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
54339 let _response = fidl::client::decode_transaction_body::<
54340 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54341 fidl::encoding::DefaultFuchsiaResourceDialect,
54342 0x7c94727acb4ea4b3,
54343 >(_buf?)?;
54344 Ok(_response.map(|x| x))
54345 }
54346 self.client.send_query_and_decode::<
54347 BaseNetworkSocketAddIpv6MembershipRequest,
54348 BaseNetworkSocketAddIpv6MembershipResult,
54349 >(
54350 (membership,),
54351 0x7c94727acb4ea4b3,
54352 fidl::encoding::DynamicFlags::empty(),
54353 _decode,
54354 )
54355 }
54356
54357 type DropIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
54358 BaseNetworkSocketDropIpv6MembershipResult,
54359 fidl::encoding::DefaultFuchsiaResourceDialect,
54360 >;
54361 fn r#drop_ipv6_membership(
54362 &self,
54363 mut membership: &Ipv6MulticastMembership,
54364 ) -> Self::DropIpv6MembershipResponseFut {
54365 fn _decode(
54366 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54367 ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
54368 let _response = fidl::client::decode_transaction_body::<
54369 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54370 fidl::encoding::DefaultFuchsiaResourceDialect,
54371 0x42104c70ccaba304,
54372 >(_buf?)?;
54373 Ok(_response.map(|x| x))
54374 }
54375 self.client.send_query_and_decode::<
54376 BaseNetworkSocketDropIpv6MembershipRequest,
54377 BaseNetworkSocketDropIpv6MembershipResult,
54378 >(
54379 (membership,),
54380 0x42104c70ccaba304,
54381 fidl::encoding::DynamicFlags::empty(),
54382 _decode,
54383 )
54384 }
54385
54386 type SetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
54387 BaseNetworkSocketSetIpv6MulticastInterfaceResult,
54388 fidl::encoding::DefaultFuchsiaResourceDialect,
54389 >;
54390 fn r#set_ipv6_multicast_interface(
54391 &self,
54392 mut value: u64,
54393 ) -> Self::SetIpv6MulticastInterfaceResponseFut {
54394 fn _decode(
54395 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54396 ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
54397 let _response = fidl::client::decode_transaction_body::<
54398 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54399 fidl::encoding::DefaultFuchsiaResourceDialect,
54400 0x135f76db3774ab3b,
54401 >(_buf?)?;
54402 Ok(_response.map(|x| x))
54403 }
54404 self.client.send_query_and_decode::<
54405 BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
54406 BaseNetworkSocketSetIpv6MulticastInterfaceResult,
54407 >(
54408 (value,),
54409 0x135f76db3774ab3b,
54410 fidl::encoding::DynamicFlags::empty(),
54411 _decode,
54412 )
54413 }
54414
54415 type GetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
54416 BaseNetworkSocketGetIpv6MulticastInterfaceResult,
54417 fidl::encoding::DefaultFuchsiaResourceDialect,
54418 >;
54419 fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut {
54420 fn _decode(
54421 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54422 ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
54423 let _response = fidl::client::decode_transaction_body::<
54424 fidl::encoding::ResultType<
54425 BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
54426 fidl_fuchsia_posix::Errno,
54427 >,
54428 fidl::encoding::DefaultFuchsiaResourceDialect,
54429 0x1f26fcdd348f1882,
54430 >(_buf?)?;
54431 Ok(_response.map(|x| x.value))
54432 }
54433 self.client.send_query_and_decode::<
54434 fidl::encoding::EmptyPayload,
54435 BaseNetworkSocketGetIpv6MulticastInterfaceResult,
54436 >(
54437 (),
54438 0x1f26fcdd348f1882,
54439 fidl::encoding::DynamicFlags::empty(),
54440 _decode,
54441 )
54442 }
54443
54444 type SetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
54445 BaseNetworkSocketSetIpv6UnicastHopsResult,
54446 fidl::encoding::DefaultFuchsiaResourceDialect,
54447 >;
54448 fn r#set_ipv6_unicast_hops(
54449 &self,
54450 mut value: &OptionalUint8,
54451 ) -> Self::SetIpv6UnicastHopsResponseFut {
54452 fn _decode(
54453 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54454 ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
54455 let _response = fidl::client::decode_transaction_body::<
54456 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54457 fidl::encoding::DefaultFuchsiaResourceDialect,
54458 0x157d51e98f462859,
54459 >(_buf?)?;
54460 Ok(_response.map(|x| x))
54461 }
54462 self.client.send_query_and_decode::<
54463 BaseNetworkSocketSetIpv6UnicastHopsRequest,
54464 BaseNetworkSocketSetIpv6UnicastHopsResult,
54465 >(
54466 (value,),
54467 0x157d51e98f462859,
54468 fidl::encoding::DynamicFlags::empty(),
54469 _decode,
54470 )
54471 }
54472
54473 type GetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
54474 BaseNetworkSocketGetIpv6UnicastHopsResult,
54475 fidl::encoding::DefaultFuchsiaResourceDialect,
54476 >;
54477 fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut {
54478 fn _decode(
54479 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54480 ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
54481 let _response = fidl::client::decode_transaction_body::<
54482 fidl::encoding::ResultType<
54483 BaseNetworkSocketGetIpv6UnicastHopsResponse,
54484 fidl_fuchsia_posix::Errno,
54485 >,
54486 fidl::encoding::DefaultFuchsiaResourceDialect,
54487 0x21f4641cad8bd8d2,
54488 >(_buf?)?;
54489 Ok(_response.map(|x| x.value))
54490 }
54491 self.client.send_query_and_decode::<
54492 fidl::encoding::EmptyPayload,
54493 BaseNetworkSocketGetIpv6UnicastHopsResult,
54494 >(
54495 (),
54496 0x21f4641cad8bd8d2,
54497 fidl::encoding::DynamicFlags::empty(),
54498 _decode,
54499 )
54500 }
54501
54502 type SetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
54503 BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
54504 fidl::encoding::DefaultFuchsiaResourceDialect,
54505 >;
54506 fn r#set_ipv6_receive_hop_limit(
54507 &self,
54508 mut value: bool,
54509 ) -> Self::SetIpv6ReceiveHopLimitResponseFut {
54510 fn _decode(
54511 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54512 ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
54513 let _response = fidl::client::decode_transaction_body::<
54514 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54515 fidl::encoding::DefaultFuchsiaResourceDialect,
54516 0x5c24808ed2e84a1e,
54517 >(_buf?)?;
54518 Ok(_response.map(|x| x))
54519 }
54520 self.client.send_query_and_decode::<
54521 BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
54522 BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
54523 >(
54524 (value,),
54525 0x5c24808ed2e84a1e,
54526 fidl::encoding::DynamicFlags::empty(),
54527 _decode,
54528 )
54529 }
54530
54531 type GetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
54532 BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
54533 fidl::encoding::DefaultFuchsiaResourceDialect,
54534 >;
54535 fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut {
54536 fn _decode(
54537 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54538 ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
54539 let _response = fidl::client::decode_transaction_body::<
54540 fidl::encoding::ResultType<
54541 BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
54542 fidl_fuchsia_posix::Errno,
54543 >,
54544 fidl::encoding::DefaultFuchsiaResourceDialect,
54545 0x341e06689885b4c0,
54546 >(_buf?)?;
54547 Ok(_response.map(|x| x.value))
54548 }
54549 self.client.send_query_and_decode::<
54550 fidl::encoding::EmptyPayload,
54551 BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
54552 >(
54553 (),
54554 0x341e06689885b4c0,
54555 fidl::encoding::DynamicFlags::empty(),
54556 _decode,
54557 )
54558 }
54559
54560 type SetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
54561 BaseNetworkSocketSetIpv6MulticastHopsResult,
54562 fidl::encoding::DefaultFuchsiaResourceDialect,
54563 >;
54564 fn r#set_ipv6_multicast_hops(
54565 &self,
54566 mut value: &OptionalUint8,
54567 ) -> Self::SetIpv6MulticastHopsResponseFut {
54568 fn _decode(
54569 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54570 ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
54571 let _response = fidl::client::decode_transaction_body::<
54572 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54573 fidl::encoding::DefaultFuchsiaResourceDialect,
54574 0x25b9cd4d181f82c1,
54575 >(_buf?)?;
54576 Ok(_response.map(|x| x))
54577 }
54578 self.client.send_query_and_decode::<
54579 BaseNetworkSocketSetIpv6MulticastHopsRequest,
54580 BaseNetworkSocketSetIpv6MulticastHopsResult,
54581 >(
54582 (value,),
54583 0x25b9cd4d181f82c1,
54584 fidl::encoding::DynamicFlags::empty(),
54585 _decode,
54586 )
54587 }
54588
54589 type GetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
54590 BaseNetworkSocketGetIpv6MulticastHopsResult,
54591 fidl::encoding::DefaultFuchsiaResourceDialect,
54592 >;
54593 fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut {
54594 fn _decode(
54595 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54596 ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
54597 let _response = fidl::client::decode_transaction_body::<
54598 fidl::encoding::ResultType<
54599 BaseNetworkSocketGetIpv6MulticastHopsResponse,
54600 fidl_fuchsia_posix::Errno,
54601 >,
54602 fidl::encoding::DefaultFuchsiaResourceDialect,
54603 0x52916948a365012a,
54604 >(_buf?)?;
54605 Ok(_response.map(|x| x.value))
54606 }
54607 self.client.send_query_and_decode::<
54608 fidl::encoding::EmptyPayload,
54609 BaseNetworkSocketGetIpv6MulticastHopsResult,
54610 >(
54611 (),
54612 0x52916948a365012a,
54613 fidl::encoding::DynamicFlags::empty(),
54614 _decode,
54615 )
54616 }
54617
54618 type SetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
54619 BaseNetworkSocketSetIpv6MulticastLoopbackResult,
54620 fidl::encoding::DefaultFuchsiaResourceDialect,
54621 >;
54622 fn r#set_ipv6_multicast_loopback(
54623 &self,
54624 mut value: bool,
54625 ) -> Self::SetIpv6MulticastLoopbackResponseFut {
54626 fn _decode(
54627 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54628 ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
54629 let _response = fidl::client::decode_transaction_body::<
54630 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54631 fidl::encoding::DefaultFuchsiaResourceDialect,
54632 0x55701c409ff41b40,
54633 >(_buf?)?;
54634 Ok(_response.map(|x| x))
54635 }
54636 self.client.send_query_and_decode::<
54637 BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
54638 BaseNetworkSocketSetIpv6MulticastLoopbackResult,
54639 >(
54640 (value,),
54641 0x55701c409ff41b40,
54642 fidl::encoding::DynamicFlags::empty(),
54643 _decode,
54644 )
54645 }
54646
54647 type GetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
54648 BaseNetworkSocketGetIpv6MulticastLoopbackResult,
54649 fidl::encoding::DefaultFuchsiaResourceDialect,
54650 >;
54651 fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut {
54652 fn _decode(
54653 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54654 ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
54655 let _response = fidl::client::decode_transaction_body::<
54656 fidl::encoding::ResultType<
54657 BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
54658 fidl_fuchsia_posix::Errno,
54659 >,
54660 fidl::encoding::DefaultFuchsiaResourceDialect,
54661 0x4415b701fde319c3,
54662 >(_buf?)?;
54663 Ok(_response.map(|x| x.value))
54664 }
54665 self.client.send_query_and_decode::<
54666 fidl::encoding::EmptyPayload,
54667 BaseNetworkSocketGetIpv6MulticastLoopbackResult,
54668 >(
54669 (),
54670 0x4415b701fde319c3,
54671 fidl::encoding::DynamicFlags::empty(),
54672 _decode,
54673 )
54674 }
54675
54676 type SetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
54677 BaseNetworkSocketSetIpv6OnlyResult,
54678 fidl::encoding::DefaultFuchsiaResourceDialect,
54679 >;
54680 fn r#set_ipv6_only(&self, mut value: bool) -> Self::SetIpv6OnlyResponseFut {
54681 fn _decode(
54682 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54683 ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
54684 let _response = fidl::client::decode_transaction_body::<
54685 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54686 fidl::encoding::DefaultFuchsiaResourceDialect,
54687 0x4873f1364758cbba,
54688 >(_buf?)?;
54689 Ok(_response.map(|x| x))
54690 }
54691 self.client.send_query_and_decode::<
54692 BaseNetworkSocketSetIpv6OnlyRequest,
54693 BaseNetworkSocketSetIpv6OnlyResult,
54694 >(
54695 (value,),
54696 0x4873f1364758cbba,
54697 fidl::encoding::DynamicFlags::empty(),
54698 _decode,
54699 )
54700 }
54701
54702 type GetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
54703 BaseNetworkSocketGetIpv6OnlyResult,
54704 fidl::encoding::DefaultFuchsiaResourceDialect,
54705 >;
54706 fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut {
54707 fn _decode(
54708 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54709 ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
54710 let _response = fidl::client::decode_transaction_body::<
54711 fidl::encoding::ResultType<
54712 BaseNetworkSocketGetIpv6OnlyResponse,
54713 fidl_fuchsia_posix::Errno,
54714 >,
54715 fidl::encoding::DefaultFuchsiaResourceDialect,
54716 0x4aa3340a1a26b89c,
54717 >(_buf?)?;
54718 Ok(_response.map(|x| x.value))
54719 }
54720 self.client.send_query_and_decode::<
54721 fidl::encoding::EmptyPayload,
54722 BaseNetworkSocketGetIpv6OnlyResult,
54723 >(
54724 (),
54725 0x4aa3340a1a26b89c,
54726 fidl::encoding::DynamicFlags::empty(),
54727 _decode,
54728 )
54729 }
54730
54731 type SetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
54732 BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
54733 fidl::encoding::DefaultFuchsiaResourceDialect,
54734 >;
54735 fn r#set_ipv6_receive_traffic_class(
54736 &self,
54737 mut value: bool,
54738 ) -> Self::SetIpv6ReceiveTrafficClassResponseFut {
54739 fn _decode(
54740 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54741 ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
54742 let _response = fidl::client::decode_transaction_body::<
54743 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54744 fidl::encoding::DefaultFuchsiaResourceDialect,
54745 0x58f07c8788d099a0,
54746 >(_buf?)?;
54747 Ok(_response.map(|x| x))
54748 }
54749 self.client.send_query_and_decode::<
54750 BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
54751 BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
54752 >(
54753 (value,),
54754 0x58f07c8788d099a0,
54755 fidl::encoding::DynamicFlags::empty(),
54756 _decode,
54757 )
54758 }
54759
54760 type GetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
54761 BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
54762 fidl::encoding::DefaultFuchsiaResourceDialect,
54763 >;
54764 fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut {
54765 fn _decode(
54766 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54767 ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
54768 let _response = fidl::client::decode_transaction_body::<
54769 fidl::encoding::ResultType<
54770 BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
54771 fidl_fuchsia_posix::Errno,
54772 >,
54773 fidl::encoding::DefaultFuchsiaResourceDialect,
54774 0x2e334df1da553ffa,
54775 >(_buf?)?;
54776 Ok(_response.map(|x| x.value))
54777 }
54778 self.client.send_query_and_decode::<
54779 fidl::encoding::EmptyPayload,
54780 BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
54781 >(
54782 (),
54783 0x2e334df1da553ffa,
54784 fidl::encoding::DynamicFlags::empty(),
54785 _decode,
54786 )
54787 }
54788
54789 type SetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
54790 BaseNetworkSocketSetIpv6TrafficClassResult,
54791 fidl::encoding::DefaultFuchsiaResourceDialect,
54792 >;
54793 fn r#set_ipv6_traffic_class(
54794 &self,
54795 mut value: &OptionalUint8,
54796 ) -> Self::SetIpv6TrafficClassResponseFut {
54797 fn _decode(
54798 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54799 ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
54800 let _response = fidl::client::decode_transaction_body::<
54801 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54802 fidl::encoding::DefaultFuchsiaResourceDialect,
54803 0x6af077800c5a0b4f,
54804 >(_buf?)?;
54805 Ok(_response.map(|x| x))
54806 }
54807 self.client.send_query_and_decode::<
54808 BaseNetworkSocketSetIpv6TrafficClassRequest,
54809 BaseNetworkSocketSetIpv6TrafficClassResult,
54810 >(
54811 (value,),
54812 0x6af077800c5a0b4f,
54813 fidl::encoding::DynamicFlags::empty(),
54814 _decode,
54815 )
54816 }
54817
54818 type GetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
54819 BaseNetworkSocketGetIpv6TrafficClassResult,
54820 fidl::encoding::DefaultFuchsiaResourceDialect,
54821 >;
54822 fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut {
54823 fn _decode(
54824 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54825 ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
54826 let _response = fidl::client::decode_transaction_body::<
54827 fidl::encoding::ResultType<
54828 BaseNetworkSocketGetIpv6TrafficClassResponse,
54829 fidl_fuchsia_posix::Errno,
54830 >,
54831 fidl::encoding::DefaultFuchsiaResourceDialect,
54832 0x6baf6eed8fc2f04,
54833 >(_buf?)?;
54834 Ok(_response.map(|x| x.value))
54835 }
54836 self.client.send_query_and_decode::<
54837 fidl::encoding::EmptyPayload,
54838 BaseNetworkSocketGetIpv6TrafficClassResult,
54839 >(
54840 (),
54841 0x6baf6eed8fc2f04,
54842 fidl::encoding::DynamicFlags::empty(),
54843 _decode,
54844 )
54845 }
54846
54847 type SetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
54848 BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
54849 fidl::encoding::DefaultFuchsiaResourceDialect,
54850 >;
54851 fn r#set_ipv6_receive_packet_info(
54852 &self,
54853 mut value: bool,
54854 ) -> Self::SetIpv6ReceivePacketInfoResponseFut {
54855 fn _decode(
54856 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54857 ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
54858 let _response = fidl::client::decode_transaction_body::<
54859 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54860 fidl::encoding::DefaultFuchsiaResourceDialect,
54861 0x19259775b1a92768,
54862 >(_buf?)?;
54863 Ok(_response.map(|x| x))
54864 }
54865 self.client.send_query_and_decode::<
54866 BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
54867 BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
54868 >(
54869 (value,),
54870 0x19259775b1a92768,
54871 fidl::encoding::DynamicFlags::empty(),
54872 _decode,
54873 )
54874 }
54875
54876 type GetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
54877 BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
54878 fidl::encoding::DefaultFuchsiaResourceDialect,
54879 >;
54880 fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut {
54881 fn _decode(
54882 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54883 ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
54884 let _response = fidl::client::decode_transaction_body::<
54885 fidl::encoding::ResultType<
54886 BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
54887 fidl_fuchsia_posix::Errno,
54888 >,
54889 fidl::encoding::DefaultFuchsiaResourceDialect,
54890 0x7acd4a2775baec75,
54891 >(_buf?)?;
54892 Ok(_response.map(|x| x.value))
54893 }
54894 self.client.send_query_and_decode::<
54895 fidl::encoding::EmptyPayload,
54896 BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
54897 >(
54898 (),
54899 0x7acd4a2775baec75,
54900 fidl::encoding::DynamicFlags::empty(),
54901 _decode,
54902 )
54903 }
54904
54905 type GetOriginalDestinationResponseFut = fidl::client::QueryResponseFut<
54906 BaseNetworkSocketGetOriginalDestinationResult,
54907 fidl::encoding::DefaultFuchsiaResourceDialect,
54908 >;
54909 fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut {
54910 fn _decode(
54911 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54912 ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
54913 let _response = fidl::client::decode_transaction_body::<
54914 fidl::encoding::ResultType<
54915 BaseNetworkSocketGetOriginalDestinationResponse,
54916 fidl_fuchsia_posix::Errno,
54917 >,
54918 fidl::encoding::DefaultFuchsiaResourceDialect,
54919 0x38bf28f0dafdbac0,
54920 >(_buf?)?;
54921 Ok(_response.map(|x| x.value))
54922 }
54923 self.client.send_query_and_decode::<
54924 fidl::encoding::EmptyPayload,
54925 BaseNetworkSocketGetOriginalDestinationResult,
54926 >(
54927 (),
54928 0x38bf28f0dafdbac0,
54929 fidl::encoding::DynamicFlags::empty(),
54930 _decode,
54931 )
54932 }
54933
54934 type DescribeResponseFut = fidl::client::QueryResponseFut<
54935 StreamSocketDescribeResponse,
54936 fidl::encoding::DefaultFuchsiaResourceDialect,
54937 >;
54938 fn r#describe(&self) -> Self::DescribeResponseFut {
54939 fn _decode(
54940 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54941 ) -> Result<StreamSocketDescribeResponse, fidl::Error> {
54942 let _response = fidl::client::decode_transaction_body::<
54943 StreamSocketDescribeResponse,
54944 fidl::encoding::DefaultFuchsiaResourceDialect,
54945 0x29e22969a7dadc32,
54946 >(_buf?)?;
54947 Ok(_response)
54948 }
54949 self.client
54950 .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketDescribeResponse>(
54951 (),
54952 0x29e22969a7dadc32,
54953 fidl::encoding::DynamicFlags::empty(),
54954 _decode,
54955 )
54956 }
54957
54958 type ListenResponseFut = fidl::client::QueryResponseFut<
54959 StreamSocketListenResult,
54960 fidl::encoding::DefaultFuchsiaResourceDialect,
54961 >;
54962 fn r#listen(&self, mut backlog: i16) -> Self::ListenResponseFut {
54963 fn _decode(
54964 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54965 ) -> Result<StreamSocketListenResult, fidl::Error> {
54966 let _response = fidl::client::decode_transaction_body::<
54967 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54968 fidl::encoding::DefaultFuchsiaResourceDialect,
54969 0x3d0a65ced3d10108,
54970 >(_buf?)?;
54971 Ok(_response.map(|x| x))
54972 }
54973 self.client.send_query_and_decode::<StreamSocketListenRequest, StreamSocketListenResult>(
54974 (backlog,),
54975 0x3d0a65ced3d10108,
54976 fidl::encoding::DynamicFlags::empty(),
54977 _decode,
54978 )
54979 }
54980
54981 type AcceptResponseFut = fidl::client::QueryResponseFut<
54982 StreamSocketAcceptResult,
54983 fidl::encoding::DefaultFuchsiaResourceDialect,
54984 >;
54985 fn r#accept(&self, mut want_addr: bool) -> Self::AcceptResponseFut {
54986 fn _decode(
54987 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54988 ) -> Result<StreamSocketAcceptResult, fidl::Error> {
54989 let _response = fidl::client::decode_transaction_body::<
54990 fidl::encoding::ResultType<StreamSocketAcceptResponse, fidl_fuchsia_posix::Errno>,
54991 fidl::encoding::DefaultFuchsiaResourceDialect,
54992 0x5ab7ad620424c163,
54993 >(_buf?)?;
54994 Ok(_response.map(|x| (x.addr, x.s)))
54995 }
54996 self.client.send_query_and_decode::<StreamSocketAcceptRequest, StreamSocketAcceptResult>(
54997 (want_addr,),
54998 0x5ab7ad620424c163,
54999 fidl::encoding::DynamicFlags::empty(),
55000 _decode,
55001 )
55002 }
55003
55004 type GetInfoResponseFut = fidl::client::QueryResponseFut<
55005 StreamSocketGetInfoResult,
55006 fidl::encoding::DefaultFuchsiaResourceDialect,
55007 >;
55008 fn r#get_info(&self) -> Self::GetInfoResponseFut {
55009 fn _decode(
55010 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55011 ) -> Result<StreamSocketGetInfoResult, fidl::Error> {
55012 let _response = fidl::client::decode_transaction_body::<
55013 fidl::encoding::ResultType<StreamSocketGetInfoResponse, fidl_fuchsia_posix::Errno>,
55014 fidl::encoding::DefaultFuchsiaResourceDialect,
55015 0x87cfa55d19f878f,
55016 >(_buf?)?;
55017 Ok(_response.map(|x| (x.domain, x.proto)))
55018 }
55019 self.client
55020 .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetInfoResult>(
55021 (),
55022 0x87cfa55d19f878f,
55023 fidl::encoding::DynamicFlags::empty(),
55024 _decode,
55025 )
55026 }
55027
55028 type SetTcpNoDelayResponseFut = fidl::client::QueryResponseFut<
55029 StreamSocketSetTcpNoDelayResult,
55030 fidl::encoding::DefaultFuchsiaResourceDialect,
55031 >;
55032 fn r#set_tcp_no_delay(&self, mut value: bool) -> Self::SetTcpNoDelayResponseFut {
55033 fn _decode(
55034 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55035 ) -> Result<StreamSocketSetTcpNoDelayResult, fidl::Error> {
55036 let _response = fidl::client::decode_transaction_body::<
55037 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55038 fidl::encoding::DefaultFuchsiaResourceDialect,
55039 0x5a59b778f7333ada,
55040 >(_buf?)?;
55041 Ok(_response.map(|x| x))
55042 }
55043 self.client.send_query_and_decode::<
55044 StreamSocketSetTcpNoDelayRequest,
55045 StreamSocketSetTcpNoDelayResult,
55046 >(
55047 (value,),
55048 0x5a59b778f7333ada,
55049 fidl::encoding::DynamicFlags::empty(),
55050 _decode,
55051 )
55052 }
55053
55054 type GetTcpNoDelayResponseFut = fidl::client::QueryResponseFut<
55055 StreamSocketGetTcpNoDelayResult,
55056 fidl::encoding::DefaultFuchsiaResourceDialect,
55057 >;
55058 fn r#get_tcp_no_delay(&self) -> Self::GetTcpNoDelayResponseFut {
55059 fn _decode(
55060 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55061 ) -> Result<StreamSocketGetTcpNoDelayResult, fidl::Error> {
55062 let _response = fidl::client::decode_transaction_body::<
55063 fidl::encoding::ResultType<
55064 StreamSocketGetTcpNoDelayResponse,
55065 fidl_fuchsia_posix::Errno,
55066 >,
55067 fidl::encoding::DefaultFuchsiaResourceDialect,
55068 0xac219a3218b0799,
55069 >(_buf?)?;
55070 Ok(_response.map(|x| x.value))
55071 }
55072 self.client
55073 .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetTcpNoDelayResult>(
55074 (),
55075 0xac219a3218b0799,
55076 fidl::encoding::DynamicFlags::empty(),
55077 _decode,
55078 )
55079 }
55080
55081 type SetTcpMaxSegmentResponseFut = fidl::client::QueryResponseFut<
55082 StreamSocketSetTcpMaxSegmentResult,
55083 fidl::encoding::DefaultFuchsiaResourceDialect,
55084 >;
55085 fn r#set_tcp_max_segment(&self, mut value_bytes: u32) -> Self::SetTcpMaxSegmentResponseFut {
55086 fn _decode(
55087 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55088 ) -> Result<StreamSocketSetTcpMaxSegmentResult, fidl::Error> {
55089 let _response = fidl::client::decode_transaction_body::<
55090 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55091 fidl::encoding::DefaultFuchsiaResourceDialect,
55092 0xb3d30c498266d18,
55093 >(_buf?)?;
55094 Ok(_response.map(|x| x))
55095 }
55096 self.client.send_query_and_decode::<
55097 StreamSocketSetTcpMaxSegmentRequest,
55098 StreamSocketSetTcpMaxSegmentResult,
55099 >(
55100 (value_bytes,),
55101 0xb3d30c498266d18,
55102 fidl::encoding::DynamicFlags::empty(),
55103 _decode,
55104 )
55105 }
55106
55107 type GetTcpMaxSegmentResponseFut = fidl::client::QueryResponseFut<
55108 StreamSocketGetTcpMaxSegmentResult,
55109 fidl::encoding::DefaultFuchsiaResourceDialect,
55110 >;
55111 fn r#get_tcp_max_segment(&self) -> Self::GetTcpMaxSegmentResponseFut {
55112 fn _decode(
55113 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55114 ) -> Result<StreamSocketGetTcpMaxSegmentResult, fidl::Error> {
55115 let _response = fidl::client::decode_transaction_body::<
55116 fidl::encoding::ResultType<
55117 StreamSocketGetTcpMaxSegmentResponse,
55118 fidl_fuchsia_posix::Errno,
55119 >,
55120 fidl::encoding::DefaultFuchsiaResourceDialect,
55121 0x637404d1b4b9982c,
55122 >(_buf?)?;
55123 Ok(_response.map(|x| x.value_bytes))
55124 }
55125 self.client.send_query_and_decode::<
55126 fidl::encoding::EmptyPayload,
55127 StreamSocketGetTcpMaxSegmentResult,
55128 >(
55129 (),
55130 0x637404d1b4b9982c,
55131 fidl::encoding::DynamicFlags::empty(),
55132 _decode,
55133 )
55134 }
55135
55136 type SetTcpCorkResponseFut = fidl::client::QueryResponseFut<
55137 StreamSocketSetTcpCorkResult,
55138 fidl::encoding::DefaultFuchsiaResourceDialect,
55139 >;
55140 fn r#set_tcp_cork(&self, mut value: bool) -> Self::SetTcpCorkResponseFut {
55141 fn _decode(
55142 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55143 ) -> Result<StreamSocketSetTcpCorkResult, fidl::Error> {
55144 let _response = fidl::client::decode_transaction_body::<
55145 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55146 fidl::encoding::DefaultFuchsiaResourceDialect,
55147 0x62e26891541143a0,
55148 >(_buf?)?;
55149 Ok(_response.map(|x| x))
55150 }
55151 self.client
55152 .send_query_and_decode::<StreamSocketSetTcpCorkRequest, StreamSocketSetTcpCorkResult>(
55153 (value,),
55154 0x62e26891541143a0,
55155 fidl::encoding::DynamicFlags::empty(),
55156 _decode,
55157 )
55158 }
55159
55160 type GetTcpCorkResponseFut = fidl::client::QueryResponseFut<
55161 StreamSocketGetTcpCorkResult,
55162 fidl::encoding::DefaultFuchsiaResourceDialect,
55163 >;
55164 fn r#get_tcp_cork(&self) -> Self::GetTcpCorkResponseFut {
55165 fn _decode(
55166 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55167 ) -> Result<StreamSocketGetTcpCorkResult, fidl::Error> {
55168 let _response = fidl::client::decode_transaction_body::<
55169 fidl::encoding::ResultType<
55170 StreamSocketGetTcpCorkResponse,
55171 fidl_fuchsia_posix::Errno,
55172 >,
55173 fidl::encoding::DefaultFuchsiaResourceDialect,
55174 0x435bb232e0e74f32,
55175 >(_buf?)?;
55176 Ok(_response.map(|x| x.value))
55177 }
55178 self.client
55179 .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetTcpCorkResult>(
55180 (),
55181 0x435bb232e0e74f32,
55182 fidl::encoding::DynamicFlags::empty(),
55183 _decode,
55184 )
55185 }
55186
55187 type SetTcpKeepAliveIdleResponseFut = fidl::client::QueryResponseFut<
55188 StreamSocketSetTcpKeepAliveIdleResult,
55189 fidl::encoding::DefaultFuchsiaResourceDialect,
55190 >;
55191 fn r#set_tcp_keep_alive_idle(
55192 &self,
55193 mut value_secs: u32,
55194 ) -> Self::SetTcpKeepAliveIdleResponseFut {
55195 fn _decode(
55196 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55197 ) -> Result<StreamSocketSetTcpKeepAliveIdleResult, fidl::Error> {
55198 let _response = fidl::client::decode_transaction_body::<
55199 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55200 fidl::encoding::DefaultFuchsiaResourceDialect,
55201 0x196d053d8363c42,
55202 >(_buf?)?;
55203 Ok(_response.map(|x| x))
55204 }
55205 self.client.send_query_and_decode::<
55206 StreamSocketSetTcpKeepAliveIdleRequest,
55207 StreamSocketSetTcpKeepAliveIdleResult,
55208 >(
55209 (value_secs,),
55210 0x196d053d8363c42,
55211 fidl::encoding::DynamicFlags::empty(),
55212 _decode,
55213 )
55214 }
55215
55216 type GetTcpKeepAliveIdleResponseFut = fidl::client::QueryResponseFut<
55217 StreamSocketGetTcpKeepAliveIdleResult,
55218 fidl::encoding::DefaultFuchsiaResourceDialect,
55219 >;
55220 fn r#get_tcp_keep_alive_idle(&self) -> Self::GetTcpKeepAliveIdleResponseFut {
55221 fn _decode(
55222 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55223 ) -> Result<StreamSocketGetTcpKeepAliveIdleResult, fidl::Error> {
55224 let _response = fidl::client::decode_transaction_body::<
55225 fidl::encoding::ResultType<
55226 StreamSocketGetTcpKeepAliveIdleResponse,
55227 fidl_fuchsia_posix::Errno,
55228 >,
55229 fidl::encoding::DefaultFuchsiaResourceDialect,
55230 0x35ec58564879dac,
55231 >(_buf?)?;
55232 Ok(_response.map(|x| x.value_secs))
55233 }
55234 self.client.send_query_and_decode::<
55235 fidl::encoding::EmptyPayload,
55236 StreamSocketGetTcpKeepAliveIdleResult,
55237 >(
55238 (),
55239 0x35ec58564879dac,
55240 fidl::encoding::DynamicFlags::empty(),
55241 _decode,
55242 )
55243 }
55244
55245 type SetTcpKeepAliveIntervalResponseFut = fidl::client::QueryResponseFut<
55246 StreamSocketSetTcpKeepAliveIntervalResult,
55247 fidl::encoding::DefaultFuchsiaResourceDialect,
55248 >;
55249 fn r#set_tcp_keep_alive_interval(
55250 &self,
55251 mut value_secs: u32,
55252 ) -> Self::SetTcpKeepAliveIntervalResponseFut {
55253 fn _decode(
55254 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55255 ) -> Result<StreamSocketSetTcpKeepAliveIntervalResult, fidl::Error> {
55256 let _response = fidl::client::decode_transaction_body::<
55257 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55258 fidl::encoding::DefaultFuchsiaResourceDialect,
55259 0x485ffbc2da1243f2,
55260 >(_buf?)?;
55261 Ok(_response.map(|x| x))
55262 }
55263 self.client.send_query_and_decode::<
55264 StreamSocketSetTcpKeepAliveIntervalRequest,
55265 StreamSocketSetTcpKeepAliveIntervalResult,
55266 >(
55267 (value_secs,),
55268 0x485ffbc2da1243f2,
55269 fidl::encoding::DynamicFlags::empty(),
55270 _decode,
55271 )
55272 }
55273
55274 type GetTcpKeepAliveIntervalResponseFut = fidl::client::QueryResponseFut<
55275 StreamSocketGetTcpKeepAliveIntervalResult,
55276 fidl::encoding::DefaultFuchsiaResourceDialect,
55277 >;
55278 fn r#get_tcp_keep_alive_interval(&self) -> Self::GetTcpKeepAliveIntervalResponseFut {
55279 fn _decode(
55280 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55281 ) -> Result<StreamSocketGetTcpKeepAliveIntervalResult, fidl::Error> {
55282 let _response = fidl::client::decode_transaction_body::<
55283 fidl::encoding::ResultType<
55284 StreamSocketGetTcpKeepAliveIntervalResponse,
55285 fidl_fuchsia_posix::Errno,
55286 >,
55287 fidl::encoding::DefaultFuchsiaResourceDialect,
55288 0x264eaf46306b284,
55289 >(_buf?)?;
55290 Ok(_response.map(|x| x.value_secs))
55291 }
55292 self.client.send_query_and_decode::<
55293 fidl::encoding::EmptyPayload,
55294 StreamSocketGetTcpKeepAliveIntervalResult,
55295 >(
55296 (),
55297 0x264eaf46306b284,
55298 fidl::encoding::DynamicFlags::empty(),
55299 _decode,
55300 )
55301 }
55302
55303 type SetTcpKeepAliveCountResponseFut = fidl::client::QueryResponseFut<
55304 StreamSocketSetTcpKeepAliveCountResult,
55305 fidl::encoding::DefaultFuchsiaResourceDialect,
55306 >;
55307 fn r#set_tcp_keep_alive_count(&self, mut value: u32) -> Self::SetTcpKeepAliveCountResponseFut {
55308 fn _decode(
55309 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55310 ) -> Result<StreamSocketSetTcpKeepAliveCountResult, fidl::Error> {
55311 let _response = fidl::client::decode_transaction_body::<
55312 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55313 fidl::encoding::DefaultFuchsiaResourceDialect,
55314 0x2ab2e8c111708421,
55315 >(_buf?)?;
55316 Ok(_response.map(|x| x))
55317 }
55318 self.client.send_query_and_decode::<
55319 StreamSocketSetTcpKeepAliveCountRequest,
55320 StreamSocketSetTcpKeepAliveCountResult,
55321 >(
55322 (value,),
55323 0x2ab2e8c111708421,
55324 fidl::encoding::DynamicFlags::empty(),
55325 _decode,
55326 )
55327 }
55328
55329 type GetTcpKeepAliveCountResponseFut = fidl::client::QueryResponseFut<
55330 StreamSocketGetTcpKeepAliveCountResult,
55331 fidl::encoding::DefaultFuchsiaResourceDialect,
55332 >;
55333 fn r#get_tcp_keep_alive_count(&self) -> Self::GetTcpKeepAliveCountResponseFut {
55334 fn _decode(
55335 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55336 ) -> Result<StreamSocketGetTcpKeepAliveCountResult, fidl::Error> {
55337 let _response = fidl::client::decode_transaction_body::<
55338 fidl::encoding::ResultType<
55339 StreamSocketGetTcpKeepAliveCountResponse,
55340 fidl_fuchsia_posix::Errno,
55341 >,
55342 fidl::encoding::DefaultFuchsiaResourceDialect,
55343 0x2f176ae271fe7a09,
55344 >(_buf?)?;
55345 Ok(_response.map(|x| x.value))
55346 }
55347 self.client.send_query_and_decode::<
55348 fidl::encoding::EmptyPayload,
55349 StreamSocketGetTcpKeepAliveCountResult,
55350 >(
55351 (),
55352 0x2f176ae271fe7a09,
55353 fidl::encoding::DynamicFlags::empty(),
55354 _decode,
55355 )
55356 }
55357
55358 type SetTcpSynCountResponseFut = fidl::client::QueryResponseFut<
55359 StreamSocketSetTcpSynCountResult,
55360 fidl::encoding::DefaultFuchsiaResourceDialect,
55361 >;
55362 fn r#set_tcp_syn_count(&self, mut value: u32) -> Self::SetTcpSynCountResponseFut {
55363 fn _decode(
55364 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55365 ) -> Result<StreamSocketSetTcpSynCountResult, fidl::Error> {
55366 let _response = fidl::client::decode_transaction_body::<
55367 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55368 fidl::encoding::DefaultFuchsiaResourceDialect,
55369 0x4dcd6ab5573c1eb3,
55370 >(_buf?)?;
55371 Ok(_response.map(|x| x))
55372 }
55373 self.client.send_query_and_decode::<
55374 StreamSocketSetTcpSynCountRequest,
55375 StreamSocketSetTcpSynCountResult,
55376 >(
55377 (value,),
55378 0x4dcd6ab5573c1eb3,
55379 fidl::encoding::DynamicFlags::empty(),
55380 _decode,
55381 )
55382 }
55383
55384 type GetTcpSynCountResponseFut = fidl::client::QueryResponseFut<
55385 StreamSocketGetTcpSynCountResult,
55386 fidl::encoding::DefaultFuchsiaResourceDialect,
55387 >;
55388 fn r#get_tcp_syn_count(&self) -> Self::GetTcpSynCountResponseFut {
55389 fn _decode(
55390 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55391 ) -> Result<StreamSocketGetTcpSynCountResult, fidl::Error> {
55392 let _response = fidl::client::decode_transaction_body::<
55393 fidl::encoding::ResultType<
55394 StreamSocketGetTcpSynCountResponse,
55395 fidl_fuchsia_posix::Errno,
55396 >,
55397 fidl::encoding::DefaultFuchsiaResourceDialect,
55398 0x7d457cba8f5f3ee6,
55399 >(_buf?)?;
55400 Ok(_response.map(|x| x.value))
55401 }
55402 self.client.send_query_and_decode::<
55403 fidl::encoding::EmptyPayload,
55404 StreamSocketGetTcpSynCountResult,
55405 >(
55406 (),
55407 0x7d457cba8f5f3ee6,
55408 fidl::encoding::DynamicFlags::empty(),
55409 _decode,
55410 )
55411 }
55412
55413 type SetTcpLingerResponseFut = fidl::client::QueryResponseFut<
55414 StreamSocketSetTcpLingerResult,
55415 fidl::encoding::DefaultFuchsiaResourceDialect,
55416 >;
55417 fn r#set_tcp_linger(&self, mut value_secs: &OptionalUint32) -> Self::SetTcpLingerResponseFut {
55418 fn _decode(
55419 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55420 ) -> Result<StreamSocketSetTcpLingerResult, fidl::Error> {
55421 let _response = fidl::client::decode_transaction_body::<
55422 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55423 fidl::encoding::DefaultFuchsiaResourceDialect,
55424 0xd5cc1e8654d36e4,
55425 >(_buf?)?;
55426 Ok(_response.map(|x| x))
55427 }
55428 self.client.send_query_and_decode::<
55429 StreamSocketSetTcpLingerRequest,
55430 StreamSocketSetTcpLingerResult,
55431 >(
55432 (value_secs,),
55433 0xd5cc1e8654d36e4,
55434 fidl::encoding::DynamicFlags::empty(),
55435 _decode,
55436 )
55437 }
55438
55439 type GetTcpLingerResponseFut = fidl::client::QueryResponseFut<
55440 StreamSocketGetTcpLingerResult,
55441 fidl::encoding::DefaultFuchsiaResourceDialect,
55442 >;
55443 fn r#get_tcp_linger(&self) -> Self::GetTcpLingerResponseFut {
55444 fn _decode(
55445 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55446 ) -> Result<StreamSocketGetTcpLingerResult, fidl::Error> {
55447 let _response = fidl::client::decode_transaction_body::<
55448 fidl::encoding::ResultType<
55449 StreamSocketGetTcpLingerResponse,
55450 fidl_fuchsia_posix::Errno,
55451 >,
55452 fidl::encoding::DefaultFuchsiaResourceDialect,
55453 0xad870d311cf30eb,
55454 >(_buf?)?;
55455 Ok(_response.map(|x| x.value_secs))
55456 }
55457 self.client
55458 .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetTcpLingerResult>(
55459 (),
55460 0xad870d311cf30eb,
55461 fidl::encoding::DynamicFlags::empty(),
55462 _decode,
55463 )
55464 }
55465
55466 type SetTcpDeferAcceptResponseFut = fidl::client::QueryResponseFut<
55467 StreamSocketSetTcpDeferAcceptResult,
55468 fidl::encoding::DefaultFuchsiaResourceDialect,
55469 >;
55470 fn r#set_tcp_defer_accept(&self, mut value_secs: u32) -> Self::SetTcpDeferAcceptResponseFut {
55471 fn _decode(
55472 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55473 ) -> Result<StreamSocketSetTcpDeferAcceptResult, fidl::Error> {
55474 let _response = fidl::client::decode_transaction_body::<
55475 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55476 fidl::encoding::DefaultFuchsiaResourceDialect,
55477 0x15092f181e57c404,
55478 >(_buf?)?;
55479 Ok(_response.map(|x| x))
55480 }
55481 self.client.send_query_and_decode::<
55482 StreamSocketSetTcpDeferAcceptRequest,
55483 StreamSocketSetTcpDeferAcceptResult,
55484 >(
55485 (value_secs,),
55486 0x15092f181e57c404,
55487 fidl::encoding::DynamicFlags::empty(),
55488 _decode,
55489 )
55490 }
55491
55492 type GetTcpDeferAcceptResponseFut = fidl::client::QueryResponseFut<
55493 StreamSocketGetTcpDeferAcceptResult,
55494 fidl::encoding::DefaultFuchsiaResourceDialect,
55495 >;
55496 fn r#get_tcp_defer_accept(&self) -> Self::GetTcpDeferAcceptResponseFut {
55497 fn _decode(
55498 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55499 ) -> Result<StreamSocketGetTcpDeferAcceptResult, fidl::Error> {
55500 let _response = fidl::client::decode_transaction_body::<
55501 fidl::encoding::ResultType<
55502 StreamSocketGetTcpDeferAcceptResponse,
55503 fidl_fuchsia_posix::Errno,
55504 >,
55505 fidl::encoding::DefaultFuchsiaResourceDialect,
55506 0x64589790842cb7c6,
55507 >(_buf?)?;
55508 Ok(_response.map(|x| x.value_secs))
55509 }
55510 self.client.send_query_and_decode::<
55511 fidl::encoding::EmptyPayload,
55512 StreamSocketGetTcpDeferAcceptResult,
55513 >(
55514 (),
55515 0x64589790842cb7c6,
55516 fidl::encoding::DynamicFlags::empty(),
55517 _decode,
55518 )
55519 }
55520
55521 type SetTcpWindowClampResponseFut = fidl::client::QueryResponseFut<
55522 StreamSocketSetTcpWindowClampResult,
55523 fidl::encoding::DefaultFuchsiaResourceDialect,
55524 >;
55525 fn r#set_tcp_window_clamp(&self, mut value: u32) -> Self::SetTcpWindowClampResponseFut {
55526 fn _decode(
55527 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55528 ) -> Result<StreamSocketSetTcpWindowClampResult, fidl::Error> {
55529 let _response = fidl::client::decode_transaction_body::<
55530 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55531 fidl::encoding::DefaultFuchsiaResourceDialect,
55532 0x4a26ce07d847f1c6,
55533 >(_buf?)?;
55534 Ok(_response.map(|x| x))
55535 }
55536 self.client.send_query_and_decode::<
55537 StreamSocketSetTcpWindowClampRequest,
55538 StreamSocketSetTcpWindowClampResult,
55539 >(
55540 (value,),
55541 0x4a26ce07d847f1c6,
55542 fidl::encoding::DynamicFlags::empty(),
55543 _decode,
55544 )
55545 }
55546
55547 type GetTcpWindowClampResponseFut = fidl::client::QueryResponseFut<
55548 StreamSocketGetTcpWindowClampResult,
55549 fidl::encoding::DefaultFuchsiaResourceDialect,
55550 >;
55551 fn r#get_tcp_window_clamp(&self) -> Self::GetTcpWindowClampResponseFut {
55552 fn _decode(
55553 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55554 ) -> Result<StreamSocketGetTcpWindowClampResult, fidl::Error> {
55555 let _response = fidl::client::decode_transaction_body::<
55556 fidl::encoding::ResultType<
55557 StreamSocketGetTcpWindowClampResponse,
55558 fidl_fuchsia_posix::Errno,
55559 >,
55560 fidl::encoding::DefaultFuchsiaResourceDialect,
55561 0x2df6b636bf0a6a4e,
55562 >(_buf?)?;
55563 Ok(_response.map(|x| x.value))
55564 }
55565 self.client.send_query_and_decode::<
55566 fidl::encoding::EmptyPayload,
55567 StreamSocketGetTcpWindowClampResult,
55568 >(
55569 (),
55570 0x2df6b636bf0a6a4e,
55571 fidl::encoding::DynamicFlags::empty(),
55572 _decode,
55573 )
55574 }
55575
55576 type GetTcpInfoResponseFut = fidl::client::QueryResponseFut<
55577 StreamSocketGetTcpInfoResult,
55578 fidl::encoding::DefaultFuchsiaResourceDialect,
55579 >;
55580 fn r#get_tcp_info(&self) -> Self::GetTcpInfoResponseFut {
55581 fn _decode(
55582 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55583 ) -> Result<StreamSocketGetTcpInfoResult, fidl::Error> {
55584 let _response = fidl::client::decode_transaction_body::<
55585 fidl::encoding::ResultType<
55586 StreamSocketGetTcpInfoResponse,
55587 fidl_fuchsia_posix::Errno,
55588 >,
55589 fidl::encoding::DefaultFuchsiaResourceDialect,
55590 0x1ffb123d9f03ead2,
55591 >(_buf?)?;
55592 Ok(_response.map(|x| x.info))
55593 }
55594 self.client
55595 .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetTcpInfoResult>(
55596 (),
55597 0x1ffb123d9f03ead2,
55598 fidl::encoding::DynamicFlags::empty(),
55599 _decode,
55600 )
55601 }
55602
55603 type SetTcpQuickAckResponseFut = fidl::client::QueryResponseFut<
55604 StreamSocketSetTcpQuickAckResult,
55605 fidl::encoding::DefaultFuchsiaResourceDialect,
55606 >;
55607 fn r#set_tcp_quick_ack(&self, mut value: bool) -> Self::SetTcpQuickAckResponseFut {
55608 fn _decode(
55609 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55610 ) -> Result<StreamSocketSetTcpQuickAckResult, fidl::Error> {
55611 let _response = fidl::client::decode_transaction_body::<
55612 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55613 fidl::encoding::DefaultFuchsiaResourceDialect,
55614 0x6fa811be8fde7457,
55615 >(_buf?)?;
55616 Ok(_response.map(|x| x))
55617 }
55618 self.client.send_query_and_decode::<
55619 StreamSocketSetTcpQuickAckRequest,
55620 StreamSocketSetTcpQuickAckResult,
55621 >(
55622 (value,),
55623 0x6fa811be8fde7457,
55624 fidl::encoding::DynamicFlags::empty(),
55625 _decode,
55626 )
55627 }
55628
55629 type GetTcpQuickAckResponseFut = fidl::client::QueryResponseFut<
55630 StreamSocketGetTcpQuickAckResult,
55631 fidl::encoding::DefaultFuchsiaResourceDialect,
55632 >;
55633 fn r#get_tcp_quick_ack(&self) -> Self::GetTcpQuickAckResponseFut {
55634 fn _decode(
55635 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55636 ) -> Result<StreamSocketGetTcpQuickAckResult, fidl::Error> {
55637 let _response = fidl::client::decode_transaction_body::<
55638 fidl::encoding::ResultType<
55639 StreamSocketGetTcpQuickAckResponse,
55640 fidl_fuchsia_posix::Errno,
55641 >,
55642 fidl::encoding::DefaultFuchsiaResourceDialect,
55643 0x7356a949bef2df32,
55644 >(_buf?)?;
55645 Ok(_response.map(|x| x.value))
55646 }
55647 self.client.send_query_and_decode::<
55648 fidl::encoding::EmptyPayload,
55649 StreamSocketGetTcpQuickAckResult,
55650 >(
55651 (),
55652 0x7356a949bef2df32,
55653 fidl::encoding::DynamicFlags::empty(),
55654 _decode,
55655 )
55656 }
55657
55658 type SetTcpCongestionResponseFut = fidl::client::QueryResponseFut<
55659 StreamSocketSetTcpCongestionResult,
55660 fidl::encoding::DefaultFuchsiaResourceDialect,
55661 >;
55662 fn r#set_tcp_congestion(
55663 &self,
55664 mut value: TcpCongestionControl,
55665 ) -> Self::SetTcpCongestionResponseFut {
55666 fn _decode(
55667 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55668 ) -> Result<StreamSocketSetTcpCongestionResult, fidl::Error> {
55669 let _response = fidl::client::decode_transaction_body::<
55670 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55671 fidl::encoding::DefaultFuchsiaResourceDialect,
55672 0x7924c6eabde7819e,
55673 >(_buf?)?;
55674 Ok(_response.map(|x| x))
55675 }
55676 self.client.send_query_and_decode::<
55677 StreamSocketSetTcpCongestionRequest,
55678 StreamSocketSetTcpCongestionResult,
55679 >(
55680 (value,),
55681 0x7924c6eabde7819e,
55682 fidl::encoding::DynamicFlags::empty(),
55683 _decode,
55684 )
55685 }
55686
55687 type GetTcpCongestionResponseFut = fidl::client::QueryResponseFut<
55688 StreamSocketGetTcpCongestionResult,
55689 fidl::encoding::DefaultFuchsiaResourceDialect,
55690 >;
55691 fn r#get_tcp_congestion(&self) -> Self::GetTcpCongestionResponseFut {
55692 fn _decode(
55693 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55694 ) -> Result<StreamSocketGetTcpCongestionResult, fidl::Error> {
55695 let _response = fidl::client::decode_transaction_body::<
55696 fidl::encoding::ResultType<
55697 StreamSocketGetTcpCongestionResponse,
55698 fidl_fuchsia_posix::Errno,
55699 >,
55700 fidl::encoding::DefaultFuchsiaResourceDialect,
55701 0x11e16397e1b72a47,
55702 >(_buf?)?;
55703 Ok(_response.map(|x| x.value))
55704 }
55705 self.client.send_query_and_decode::<
55706 fidl::encoding::EmptyPayload,
55707 StreamSocketGetTcpCongestionResult,
55708 >(
55709 (),
55710 0x11e16397e1b72a47,
55711 fidl::encoding::DynamicFlags::empty(),
55712 _decode,
55713 )
55714 }
55715
55716 type SetTcpUserTimeoutResponseFut = fidl::client::QueryResponseFut<
55717 StreamSocketSetTcpUserTimeoutResult,
55718 fidl::encoding::DefaultFuchsiaResourceDialect,
55719 >;
55720 fn r#set_tcp_user_timeout(&self, mut value_millis: u32) -> Self::SetTcpUserTimeoutResponseFut {
55721 fn _decode(
55722 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55723 ) -> Result<StreamSocketSetTcpUserTimeoutResult, fidl::Error> {
55724 let _response = fidl::client::decode_transaction_body::<
55725 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55726 fidl::encoding::DefaultFuchsiaResourceDialect,
55727 0x6b459e81c3741a60,
55728 >(_buf?)?;
55729 Ok(_response.map(|x| x))
55730 }
55731 self.client.send_query_and_decode::<
55732 StreamSocketSetTcpUserTimeoutRequest,
55733 StreamSocketSetTcpUserTimeoutResult,
55734 >(
55735 (value_millis,),
55736 0x6b459e81c3741a60,
55737 fidl::encoding::DynamicFlags::empty(),
55738 _decode,
55739 )
55740 }
55741
55742 type GetTcpUserTimeoutResponseFut = fidl::client::QueryResponseFut<
55743 StreamSocketGetTcpUserTimeoutResult,
55744 fidl::encoding::DefaultFuchsiaResourceDialect,
55745 >;
55746 fn r#get_tcp_user_timeout(&self) -> Self::GetTcpUserTimeoutResponseFut {
55747 fn _decode(
55748 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55749 ) -> Result<StreamSocketGetTcpUserTimeoutResult, fidl::Error> {
55750 let _response = fidl::client::decode_transaction_body::<
55751 fidl::encoding::ResultType<
55752 StreamSocketGetTcpUserTimeoutResponse,
55753 fidl_fuchsia_posix::Errno,
55754 >,
55755 fidl::encoding::DefaultFuchsiaResourceDialect,
55756 0x24bbd5858ad8c380,
55757 >(_buf?)?;
55758 Ok(_response.map(|x| x.value_millis))
55759 }
55760 self.client.send_query_and_decode::<
55761 fidl::encoding::EmptyPayload,
55762 StreamSocketGetTcpUserTimeoutResult,
55763 >(
55764 (),
55765 0x24bbd5858ad8c380,
55766 fidl::encoding::DynamicFlags::empty(),
55767 _decode,
55768 )
55769 }
55770}
55771
55772pub struct StreamSocketEventStream {
55773 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
55774}
55775
55776impl std::marker::Unpin for StreamSocketEventStream {}
55777
55778impl futures::stream::FusedStream for StreamSocketEventStream {
55779 fn is_terminated(&self) -> bool {
55780 self.event_receiver.is_terminated()
55781 }
55782}
55783
55784impl futures::Stream for StreamSocketEventStream {
55785 type Item = Result<StreamSocketEvent, fidl::Error>;
55786
55787 fn poll_next(
55788 mut self: std::pin::Pin<&mut Self>,
55789 cx: &mut std::task::Context<'_>,
55790 ) -> std::task::Poll<Option<Self::Item>> {
55791 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
55792 &mut self.event_receiver,
55793 cx
55794 )?) {
55795 Some(buf) => std::task::Poll::Ready(Some(StreamSocketEvent::decode(buf))),
55796 None => std::task::Poll::Ready(None),
55797 }
55798 }
55799}
55800
55801#[derive(Debug)]
55802pub enum StreamSocketEvent {}
55803
55804impl StreamSocketEvent {
55805 fn decode(
55807 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
55808 ) -> Result<StreamSocketEvent, fidl::Error> {
55809 let (bytes, _handles) = buf.split_mut();
55810 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
55811 debug_assert_eq!(tx_header.tx_id, 0);
55812 match tx_header.ordinal {
55813 _ => Err(fidl::Error::UnknownOrdinal {
55814 ordinal: tx_header.ordinal,
55815 protocol_name: <StreamSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
55816 }),
55817 }
55818 }
55819}
55820
55821pub struct StreamSocketRequestStream {
55823 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
55824 is_terminated: bool,
55825}
55826
55827impl std::marker::Unpin for StreamSocketRequestStream {}
55828
55829impl futures::stream::FusedStream for StreamSocketRequestStream {
55830 fn is_terminated(&self) -> bool {
55831 self.is_terminated
55832 }
55833}
55834
55835impl fidl::endpoints::RequestStream for StreamSocketRequestStream {
55836 type Protocol = StreamSocketMarker;
55837 type ControlHandle = StreamSocketControlHandle;
55838
55839 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
55840 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
55841 }
55842
55843 fn control_handle(&self) -> Self::ControlHandle {
55844 StreamSocketControlHandle { inner: self.inner.clone() }
55845 }
55846
55847 fn into_inner(
55848 self,
55849 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
55850 {
55851 (self.inner, self.is_terminated)
55852 }
55853
55854 fn from_inner(
55855 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
55856 is_terminated: bool,
55857 ) -> Self {
55858 Self { inner, is_terminated }
55859 }
55860}
55861
55862impl futures::Stream for StreamSocketRequestStream {
55863 type Item = Result<StreamSocketRequest, fidl::Error>;
55864
55865 fn poll_next(
55866 mut self: std::pin::Pin<&mut Self>,
55867 cx: &mut std::task::Context<'_>,
55868 ) -> std::task::Poll<Option<Self::Item>> {
55869 let this = &mut *self;
55870 if this.inner.check_shutdown(cx) {
55871 this.is_terminated = true;
55872 return std::task::Poll::Ready(None);
55873 }
55874 if this.is_terminated {
55875 panic!("polled StreamSocketRequestStream after completion");
55876 }
55877 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
55878 |bytes, handles| {
55879 match this.inner.channel().read_etc(cx, bytes, handles) {
55880 std::task::Poll::Ready(Ok(())) => {}
55881 std::task::Poll::Pending => return std::task::Poll::Pending,
55882 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
55883 this.is_terminated = true;
55884 return std::task::Poll::Ready(None);
55885 }
55886 std::task::Poll::Ready(Err(e)) => {
55887 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
55888 e.into(),
55889 ))))
55890 }
55891 }
55892
55893 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
55895
55896 std::task::Poll::Ready(Some(match header.ordinal {
55897 0x20d8a7aba2168a79 => {
55898 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
55899 let mut req = fidl::new_empty!(
55900 fidl_fuchsia_unknown::CloneableCloneRequest,
55901 fidl::encoding::DefaultFuchsiaResourceDialect
55902 );
55903 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
55904 let control_handle =
55905 StreamSocketControlHandle { inner: this.inner.clone() };
55906 Ok(StreamSocketRequest::Clone { request: req.request, control_handle })
55907 }
55908 0x5ac5d459ad7f657e => {
55909 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
55910 let mut req = fidl::new_empty!(
55911 fidl::encoding::EmptyPayload,
55912 fidl::encoding::DefaultFuchsiaResourceDialect
55913 );
55914 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
55915 let control_handle =
55916 StreamSocketControlHandle { inner: this.inner.clone() };
55917 Ok(StreamSocketRequest::Close {
55918 responder: StreamSocketCloseResponder {
55919 control_handle: std::mem::ManuallyDrop::new(control_handle),
55920 tx_id: header.tx_id,
55921 },
55922 })
55923 }
55924 0x2658edee9decfc06 => {
55925 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
55926 let mut req = fidl::new_empty!(
55927 fidl::encoding::EmptyPayload,
55928 fidl::encoding::DefaultFuchsiaResourceDialect
55929 );
55930 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
55931 let control_handle =
55932 StreamSocketControlHandle { inner: this.inner.clone() };
55933 Ok(StreamSocketRequest::Query {
55934 responder: StreamSocketQueryResponder {
55935 control_handle: std::mem::ManuallyDrop::new(control_handle),
55936 tx_id: header.tx_id,
55937 },
55938 })
55939 }
55940 0x1fd74ee8b9a4a876 => {
55941 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
55942 let mut req = fidl::new_empty!(
55943 BaseSocketSetReuseAddressRequest,
55944 fidl::encoding::DefaultFuchsiaResourceDialect
55945 );
55946 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
55947 let control_handle =
55948 StreamSocketControlHandle { inner: this.inner.clone() };
55949 Ok(StreamSocketRequest::SetReuseAddress {
55950 value: req.value,
55951
55952 responder: StreamSocketSetReuseAddressResponder {
55953 control_handle: std::mem::ManuallyDrop::new(control_handle),
55954 tx_id: header.tx_id,
55955 },
55956 })
55957 }
55958 0x67b7206b8d1bc0a5 => {
55959 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
55960 let mut req = fidl::new_empty!(
55961 fidl::encoding::EmptyPayload,
55962 fidl::encoding::DefaultFuchsiaResourceDialect
55963 );
55964 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
55965 let control_handle =
55966 StreamSocketControlHandle { inner: this.inner.clone() };
55967 Ok(StreamSocketRequest::GetReuseAddress {
55968 responder: StreamSocketGetReuseAddressResponder {
55969 control_handle: std::mem::ManuallyDrop::new(control_handle),
55970 tx_id: header.tx_id,
55971 },
55972 })
55973 }
55974 0x5aad39b33e5f6ebb => {
55975 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
55976 let mut req = fidl::new_empty!(
55977 fidl::encoding::EmptyPayload,
55978 fidl::encoding::DefaultFuchsiaResourceDialect
55979 );
55980 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
55981 let control_handle =
55982 StreamSocketControlHandle { inner: this.inner.clone() };
55983 Ok(StreamSocketRequest::GetError {
55984 responder: StreamSocketGetErrorResponder {
55985 control_handle: std::mem::ManuallyDrop::new(control_handle),
55986 tx_id: header.tx_id,
55987 },
55988 })
55989 }
55990 0x6023e081ce3cd947 => {
55991 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
55992 let mut req = fidl::new_empty!(
55993 BaseSocketSetBroadcastRequest,
55994 fidl::encoding::DefaultFuchsiaResourceDialect
55995 );
55996 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
55997 let control_handle =
55998 StreamSocketControlHandle { inner: this.inner.clone() };
55999 Ok(StreamSocketRequest::SetBroadcast {
56000 value: req.value,
56001
56002 responder: StreamSocketSetBroadcastResponder {
56003 control_handle: std::mem::ManuallyDrop::new(control_handle),
56004 tx_id: header.tx_id,
56005 },
56006 })
56007 }
56008 0x68796fc556f9780d => {
56009 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56010 let mut req = fidl::new_empty!(
56011 fidl::encoding::EmptyPayload,
56012 fidl::encoding::DefaultFuchsiaResourceDialect
56013 );
56014 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56015 let control_handle =
56016 StreamSocketControlHandle { inner: this.inner.clone() };
56017 Ok(StreamSocketRequest::GetBroadcast {
56018 responder: StreamSocketGetBroadcastResponder {
56019 control_handle: std::mem::ManuallyDrop::new(control_handle),
56020 tx_id: header.tx_id,
56021 },
56022 })
56023 }
56024 0x756eac32d73a7a70 => {
56025 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56026 let mut req = fidl::new_empty!(
56027 BaseSocketSetSendBufferRequest,
56028 fidl::encoding::DefaultFuchsiaResourceDialect
56029 );
56030 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
56031 let control_handle =
56032 StreamSocketControlHandle { inner: this.inner.clone() };
56033 Ok(StreamSocketRequest::SetSendBuffer {
56034 value_bytes: req.value_bytes,
56035
56036 responder: StreamSocketSetSendBufferResponder {
56037 control_handle: std::mem::ManuallyDrop::new(control_handle),
56038 tx_id: header.tx_id,
56039 },
56040 })
56041 }
56042 0x78a52fd9c7b2410b => {
56043 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56044 let mut req = fidl::new_empty!(
56045 fidl::encoding::EmptyPayload,
56046 fidl::encoding::DefaultFuchsiaResourceDialect
56047 );
56048 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56049 let control_handle =
56050 StreamSocketControlHandle { inner: this.inner.clone() };
56051 Ok(StreamSocketRequest::GetSendBuffer {
56052 responder: StreamSocketGetSendBufferResponder {
56053 control_handle: std::mem::ManuallyDrop::new(control_handle),
56054 tx_id: header.tx_id,
56055 },
56056 })
56057 }
56058 0x6b0cf2f1919c7001 => {
56059 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56060 let mut req = fidl::new_empty!(
56061 BaseSocketSetReceiveBufferRequest,
56062 fidl::encoding::DefaultFuchsiaResourceDialect
56063 );
56064 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
56065 let control_handle =
56066 StreamSocketControlHandle { inner: this.inner.clone() };
56067 Ok(StreamSocketRequest::SetReceiveBuffer {
56068 value_bytes: req.value_bytes,
56069
56070 responder: StreamSocketSetReceiveBufferResponder {
56071 control_handle: std::mem::ManuallyDrop::new(control_handle),
56072 tx_id: header.tx_id,
56073 },
56074 })
56075 }
56076 0x14c1a4b64f709e5c => {
56077 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56078 let mut req = fidl::new_empty!(
56079 fidl::encoding::EmptyPayload,
56080 fidl::encoding::DefaultFuchsiaResourceDialect
56081 );
56082 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56083 let control_handle =
56084 StreamSocketControlHandle { inner: this.inner.clone() };
56085 Ok(StreamSocketRequest::GetReceiveBuffer {
56086 responder: StreamSocketGetReceiveBufferResponder {
56087 control_handle: std::mem::ManuallyDrop::new(control_handle),
56088 tx_id: header.tx_id,
56089 },
56090 })
56091 }
56092 0x572df8f0b920d2c7 => {
56093 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56094 let mut req = fidl::new_empty!(
56095 BaseSocketSetKeepAliveRequest,
56096 fidl::encoding::DefaultFuchsiaResourceDialect
56097 );
56098 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
56099 let control_handle =
56100 StreamSocketControlHandle { inner: this.inner.clone() };
56101 Ok(StreamSocketRequest::SetKeepAlive {
56102 value: req.value,
56103
56104 responder: StreamSocketSetKeepAliveResponder {
56105 control_handle: std::mem::ManuallyDrop::new(control_handle),
56106 tx_id: header.tx_id,
56107 },
56108 })
56109 }
56110 0x2dd29d3215f2c9d2 => {
56111 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56112 let mut req = fidl::new_empty!(
56113 fidl::encoding::EmptyPayload,
56114 fidl::encoding::DefaultFuchsiaResourceDialect
56115 );
56116 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56117 let control_handle =
56118 StreamSocketControlHandle { inner: this.inner.clone() };
56119 Ok(StreamSocketRequest::GetKeepAlive {
56120 responder: StreamSocketGetKeepAliveResponder {
56121 control_handle: std::mem::ManuallyDrop::new(control_handle),
56122 tx_id: header.tx_id,
56123 },
56124 })
56125 }
56126 0x3ecb49968bee439 => {
56127 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56128 let mut req = fidl::new_empty!(
56129 BaseSocketSetOutOfBandInlineRequest,
56130 fidl::encoding::DefaultFuchsiaResourceDialect
56131 );
56132 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
56133 let control_handle =
56134 StreamSocketControlHandle { inner: this.inner.clone() };
56135 Ok(StreamSocketRequest::SetOutOfBandInline {
56136 value: req.value,
56137
56138 responder: StreamSocketSetOutOfBandInlineResponder {
56139 control_handle: std::mem::ManuallyDrop::new(control_handle),
56140 tx_id: header.tx_id,
56141 },
56142 })
56143 }
56144 0x348c1ab3aeca1745 => {
56145 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56146 let mut req = fidl::new_empty!(
56147 fidl::encoding::EmptyPayload,
56148 fidl::encoding::DefaultFuchsiaResourceDialect
56149 );
56150 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56151 let control_handle =
56152 StreamSocketControlHandle { inner: this.inner.clone() };
56153 Ok(StreamSocketRequest::GetOutOfBandInline {
56154 responder: StreamSocketGetOutOfBandInlineResponder {
56155 control_handle: std::mem::ManuallyDrop::new(control_handle),
56156 tx_id: header.tx_id,
56157 },
56158 })
56159 }
56160 0x6bbf00c53a4c78c2 => {
56161 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56162 let mut req = fidl::new_empty!(
56163 BaseSocketSetNoCheckRequest,
56164 fidl::encoding::DefaultFuchsiaResourceDialect
56165 );
56166 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
56167 let control_handle =
56168 StreamSocketControlHandle { inner: this.inner.clone() };
56169 Ok(StreamSocketRequest::SetNoCheck {
56170 value: req.value,
56171
56172 responder: StreamSocketSetNoCheckResponder {
56173 control_handle: std::mem::ManuallyDrop::new(control_handle),
56174 tx_id: header.tx_id,
56175 },
56176 })
56177 }
56178 0x2cd4249286417694 => {
56179 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56180 let mut req = fidl::new_empty!(
56181 fidl::encoding::EmptyPayload,
56182 fidl::encoding::DefaultFuchsiaResourceDialect
56183 );
56184 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56185 let control_handle =
56186 StreamSocketControlHandle { inner: this.inner.clone() };
56187 Ok(StreamSocketRequest::GetNoCheck {
56188 responder: StreamSocketGetNoCheckResponder {
56189 control_handle: std::mem::ManuallyDrop::new(control_handle),
56190 tx_id: header.tx_id,
56191 },
56192 })
56193 }
56194 0x45386351246e998e => {
56195 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56196 let mut req = fidl::new_empty!(
56197 BaseSocketSetLingerRequest,
56198 fidl::encoding::DefaultFuchsiaResourceDialect
56199 );
56200 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
56201 let control_handle =
56202 StreamSocketControlHandle { inner: this.inner.clone() };
56203 Ok(StreamSocketRequest::SetLinger {
56204 linger: req.linger,
56205 length_secs: req.length_secs,
56206
56207 responder: StreamSocketSetLingerResponder {
56208 control_handle: std::mem::ManuallyDrop::new(control_handle),
56209 tx_id: header.tx_id,
56210 },
56211 })
56212 }
56213 0x48eb20fc5ccb0e45 => {
56214 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56215 let mut req = fidl::new_empty!(
56216 fidl::encoding::EmptyPayload,
56217 fidl::encoding::DefaultFuchsiaResourceDialect
56218 );
56219 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56220 let control_handle =
56221 StreamSocketControlHandle { inner: this.inner.clone() };
56222 Ok(StreamSocketRequest::GetLinger {
56223 responder: StreamSocketGetLingerResponder {
56224 control_handle: std::mem::ManuallyDrop::new(control_handle),
56225 tx_id: header.tx_id,
56226 },
56227 })
56228 }
56229 0x24dd3e5cb36d9ccb => {
56230 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56231 let mut req = fidl::new_empty!(
56232 BaseSocketSetReusePortRequest,
56233 fidl::encoding::DefaultFuchsiaResourceDialect
56234 );
56235 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
56236 let control_handle =
56237 StreamSocketControlHandle { inner: this.inner.clone() };
56238 Ok(StreamSocketRequest::SetReusePort {
56239 value: req.value,
56240
56241 responder: StreamSocketSetReusePortResponder {
56242 control_handle: std::mem::ManuallyDrop::new(control_handle),
56243 tx_id: header.tx_id,
56244 },
56245 })
56246 }
56247 0x7a112c1ab54ff828 => {
56248 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56249 let mut req = fidl::new_empty!(
56250 fidl::encoding::EmptyPayload,
56251 fidl::encoding::DefaultFuchsiaResourceDialect
56252 );
56253 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56254 let control_handle =
56255 StreamSocketControlHandle { inner: this.inner.clone() };
56256 Ok(StreamSocketRequest::GetReusePort {
56257 responder: StreamSocketGetReusePortResponder {
56258 control_handle: std::mem::ManuallyDrop::new(control_handle),
56259 tx_id: header.tx_id,
56260 },
56261 })
56262 }
56263 0x67ce6db6c2ec8966 => {
56264 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56265 let mut req = fidl::new_empty!(
56266 fidl::encoding::EmptyPayload,
56267 fidl::encoding::DefaultFuchsiaResourceDialect
56268 );
56269 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56270 let control_handle =
56271 StreamSocketControlHandle { inner: this.inner.clone() };
56272 Ok(StreamSocketRequest::GetAcceptConn {
56273 responder: StreamSocketGetAcceptConnResponder {
56274 control_handle: std::mem::ManuallyDrop::new(control_handle),
56275 tx_id: header.tx_id,
56276 },
56277 })
56278 }
56279 0x2118b483f28aafc4 => {
56280 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56281 let mut req = fidl::new_empty!(
56282 BaseSocketSetBindToDeviceRequest,
56283 fidl::encoding::DefaultFuchsiaResourceDialect
56284 );
56285 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
56286 let control_handle =
56287 StreamSocketControlHandle { inner: this.inner.clone() };
56288 Ok(StreamSocketRequest::SetBindToDevice {
56289 value: req.value,
56290
56291 responder: StreamSocketSetBindToDeviceResponder {
56292 control_handle: std::mem::ManuallyDrop::new(control_handle),
56293 tx_id: header.tx_id,
56294 },
56295 })
56296 }
56297 0x1ab1fbf0ef7906c8 => {
56298 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56299 let mut req = fidl::new_empty!(
56300 fidl::encoding::EmptyPayload,
56301 fidl::encoding::DefaultFuchsiaResourceDialect
56302 );
56303 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56304 let control_handle =
56305 StreamSocketControlHandle { inner: this.inner.clone() };
56306 Ok(StreamSocketRequest::GetBindToDevice {
56307 responder: StreamSocketGetBindToDeviceResponder {
56308 control_handle: std::mem::ManuallyDrop::new(control_handle),
56309 tx_id: header.tx_id,
56310 },
56311 })
56312 }
56313 0x6e387a0def00821 => {
56314 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56315 let mut req = fidl::new_empty!(
56316 BaseSocketSetBindToInterfaceIndexRequest,
56317 fidl::encoding::DefaultFuchsiaResourceDialect
56318 );
56319 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
56320 let control_handle =
56321 StreamSocketControlHandle { inner: this.inner.clone() };
56322 Ok(StreamSocketRequest::SetBindToInterfaceIndex {
56323 value: req.value,
56324
56325 responder: StreamSocketSetBindToInterfaceIndexResponder {
56326 control_handle: std::mem::ManuallyDrop::new(control_handle),
56327 tx_id: header.tx_id,
56328 },
56329 })
56330 }
56331 0x59c31dd3e3078295 => {
56332 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56333 let mut req = fidl::new_empty!(
56334 fidl::encoding::EmptyPayload,
56335 fidl::encoding::DefaultFuchsiaResourceDialect
56336 );
56337 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56338 let control_handle =
56339 StreamSocketControlHandle { inner: this.inner.clone() };
56340 Ok(StreamSocketRequest::GetBindToInterfaceIndex {
56341 responder: StreamSocketGetBindToInterfaceIndexResponder {
56342 control_handle: std::mem::ManuallyDrop::new(control_handle),
56343 tx_id: header.tx_id,
56344 },
56345 })
56346 }
56347 0x285d6516c263d839 => {
56348 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56349 let mut req = fidl::new_empty!(
56350 BaseSocketSetTimestampRequest,
56351 fidl::encoding::DefaultFuchsiaResourceDialect
56352 );
56353 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
56354 let control_handle =
56355 StreamSocketControlHandle { inner: this.inner.clone() };
56356 Ok(StreamSocketRequest::SetTimestamp {
56357 value: req.value,
56358
56359 responder: StreamSocketSetTimestampResponder {
56360 control_handle: std::mem::ManuallyDrop::new(control_handle),
56361 tx_id: header.tx_id,
56362 },
56363 })
56364 }
56365 0x49f2fffbbcc2bd27 => {
56366 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56367 let mut req = fidl::new_empty!(
56368 fidl::encoding::EmptyPayload,
56369 fidl::encoding::DefaultFuchsiaResourceDialect
56370 );
56371 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56372 let control_handle =
56373 StreamSocketControlHandle { inner: this.inner.clone() };
56374 Ok(StreamSocketRequest::GetTimestamp {
56375 responder: StreamSocketGetTimestampResponder {
56376 control_handle: std::mem::ManuallyDrop::new(control_handle),
56377 tx_id: header.tx_id,
56378 },
56379 })
56380 }
56381 0x6ead6de09f653236 => {
56382 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56383 let mut req = fidl::new_empty!(
56384 BaseSocketSetMarkRequest,
56385 fidl::encoding::DefaultFuchsiaResourceDialect
56386 );
56387 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
56388 let control_handle =
56389 StreamSocketControlHandle { inner: this.inner.clone() };
56390 Ok(StreamSocketRequest::SetMark {
56391 domain: req.domain,
56392 mark: req.mark,
56393
56394 responder: StreamSocketSetMarkResponder {
56395 control_handle: std::mem::ManuallyDrop::new(control_handle),
56396 tx_id: header.tx_id,
56397 },
56398 })
56399 }
56400 0x57a2752c61d93d47 => {
56401 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56402 let mut req = fidl::new_empty!(
56403 BaseSocketGetMarkRequest,
56404 fidl::encoding::DefaultFuchsiaResourceDialect
56405 );
56406 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
56407 let control_handle =
56408 StreamSocketControlHandle { inner: this.inner.clone() };
56409 Ok(StreamSocketRequest::GetMark {
56410 domain: req.domain,
56411
56412 responder: StreamSocketGetMarkResponder {
56413 control_handle: std::mem::ManuallyDrop::new(control_handle),
56414 tx_id: header.tx_id,
56415 },
56416 })
56417 }
56418 0x4bc6400ae92125d => {
56419 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56420 let mut req = fidl::new_empty!(
56421 BaseNetworkSocketBindRequest,
56422 fidl::encoding::DefaultFuchsiaResourceDialect
56423 );
56424 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
56425 let control_handle =
56426 StreamSocketControlHandle { inner: this.inner.clone() };
56427 Ok(StreamSocketRequest::Bind {
56428 addr: req.addr,
56429
56430 responder: StreamSocketBindResponder {
56431 control_handle: std::mem::ManuallyDrop::new(control_handle),
56432 tx_id: header.tx_id,
56433 },
56434 })
56435 }
56436 0x5f05f19bfdd38871 => {
56437 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56438 let mut req = fidl::new_empty!(
56439 BaseNetworkSocketConnectRequest,
56440 fidl::encoding::DefaultFuchsiaResourceDialect
56441 );
56442 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
56443 let control_handle =
56444 StreamSocketControlHandle { inner: this.inner.clone() };
56445 Ok(StreamSocketRequest::Connect {
56446 addr: req.addr,
56447
56448 responder: StreamSocketConnectResponder {
56449 control_handle: std::mem::ManuallyDrop::new(control_handle),
56450 tx_id: header.tx_id,
56451 },
56452 })
56453 }
56454 0x74e63b91f7b29b2 => {
56455 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56456 let mut req = fidl::new_empty!(
56457 fidl::encoding::EmptyPayload,
56458 fidl::encoding::DefaultFuchsiaResourceDialect
56459 );
56460 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56461 let control_handle =
56462 StreamSocketControlHandle { inner: this.inner.clone() };
56463 Ok(StreamSocketRequest::Disconnect {
56464 responder: StreamSocketDisconnectResponder {
56465 control_handle: std::mem::ManuallyDrop::new(control_handle),
56466 tx_id: header.tx_id,
56467 },
56468 })
56469 }
56470 0x475f23f84a1a4f85 => {
56471 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56472 let mut req = fidl::new_empty!(
56473 fidl::encoding::EmptyPayload,
56474 fidl::encoding::DefaultFuchsiaResourceDialect
56475 );
56476 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56477 let control_handle =
56478 StreamSocketControlHandle { inner: this.inner.clone() };
56479 Ok(StreamSocketRequest::GetSockName {
56480 responder: StreamSocketGetSockNameResponder {
56481 control_handle: std::mem::ManuallyDrop::new(control_handle),
56482 tx_id: header.tx_id,
56483 },
56484 })
56485 }
56486 0x1ffecf4bd5b6432e => {
56487 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56488 let mut req = fidl::new_empty!(
56489 fidl::encoding::EmptyPayload,
56490 fidl::encoding::DefaultFuchsiaResourceDialect
56491 );
56492 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56493 let control_handle =
56494 StreamSocketControlHandle { inner: this.inner.clone() };
56495 Ok(StreamSocketRequest::GetPeerName {
56496 responder: StreamSocketGetPeerNameResponder {
56497 control_handle: std::mem::ManuallyDrop::new(control_handle),
56498 tx_id: header.tx_id,
56499 },
56500 })
56501 }
56502 0x247f38b6db68c336 => {
56503 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56504 let mut req = fidl::new_empty!(
56505 BaseNetworkSocketShutdownRequest,
56506 fidl::encoding::DefaultFuchsiaResourceDialect
56507 );
56508 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketShutdownRequest>(&header, _body_bytes, handles, &mut req)?;
56509 let control_handle =
56510 StreamSocketControlHandle { inner: this.inner.clone() };
56511 Ok(StreamSocketRequest::Shutdown {
56512 mode: req.mode,
56513
56514 responder: StreamSocketShutdownResponder {
56515 control_handle: std::mem::ManuallyDrop::new(control_handle),
56516 tx_id: header.tx_id,
56517 },
56518 })
56519 }
56520 0x995c600475b6d46 => {
56521 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56522 let mut req = fidl::new_empty!(
56523 BaseNetworkSocketSetIpTypeOfServiceRequest,
56524 fidl::encoding::DefaultFuchsiaResourceDialect
56525 );
56526 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
56527 let control_handle =
56528 StreamSocketControlHandle { inner: this.inner.clone() };
56529 Ok(StreamSocketRequest::SetIpTypeOfService {
56530 value: req.value,
56531
56532 responder: StreamSocketSetIpTypeOfServiceResponder {
56533 control_handle: std::mem::ManuallyDrop::new(control_handle),
56534 tx_id: header.tx_id,
56535 },
56536 })
56537 }
56538 0x3814a04259f75fcb => {
56539 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56540 let mut req = fidl::new_empty!(
56541 fidl::encoding::EmptyPayload,
56542 fidl::encoding::DefaultFuchsiaResourceDialect
56543 );
56544 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56545 let control_handle =
56546 StreamSocketControlHandle { inner: this.inner.clone() };
56547 Ok(StreamSocketRequest::GetIpTypeOfService {
56548 responder: StreamSocketGetIpTypeOfServiceResponder {
56549 control_handle: std::mem::ManuallyDrop::new(control_handle),
56550 tx_id: header.tx_id,
56551 },
56552 })
56553 }
56554 0x29e2424b433ae1ef => {
56555 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56556 let mut req = fidl::new_empty!(
56557 BaseNetworkSocketSetIpTtlRequest,
56558 fidl::encoding::DefaultFuchsiaResourceDialect
56559 );
56560 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTtlRequest>(&header, _body_bytes, handles, &mut req)?;
56561 let control_handle =
56562 StreamSocketControlHandle { inner: this.inner.clone() };
56563 Ok(StreamSocketRequest::SetIpTtl {
56564 value: req.value,
56565
56566 responder: StreamSocketSetIpTtlResponder {
56567 control_handle: std::mem::ManuallyDrop::new(control_handle),
56568 tx_id: header.tx_id,
56569 },
56570 })
56571 }
56572 0x47e47fa1f24da471 => {
56573 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56574 let mut req = fidl::new_empty!(
56575 fidl::encoding::EmptyPayload,
56576 fidl::encoding::DefaultFuchsiaResourceDialect
56577 );
56578 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56579 let control_handle =
56580 StreamSocketControlHandle { inner: this.inner.clone() };
56581 Ok(StreamSocketRequest::GetIpTtl {
56582 responder: StreamSocketGetIpTtlResponder {
56583 control_handle: std::mem::ManuallyDrop::new(control_handle),
56584 tx_id: header.tx_id,
56585 },
56586 })
56587 }
56588 0x392d16bee20c0e16 => {
56589 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56590 let mut req = fidl::new_empty!(
56591 BaseNetworkSocketSetIpPacketInfoRequest,
56592 fidl::encoding::DefaultFuchsiaResourceDialect
56593 );
56594 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpPacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
56595 let control_handle =
56596 StreamSocketControlHandle { inner: this.inner.clone() };
56597 Ok(StreamSocketRequest::SetIpPacketInfo {
56598 value: req.value,
56599
56600 responder: StreamSocketSetIpPacketInfoResponder {
56601 control_handle: std::mem::ManuallyDrop::new(control_handle),
56602 tx_id: header.tx_id,
56603 },
56604 })
56605 }
56606 0x54b505f242280740 => {
56607 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56608 let mut req = fidl::new_empty!(
56609 fidl::encoding::EmptyPayload,
56610 fidl::encoding::DefaultFuchsiaResourceDialect
56611 );
56612 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56613 let control_handle =
56614 StreamSocketControlHandle { inner: this.inner.clone() };
56615 Ok(StreamSocketRequest::GetIpPacketInfo {
56616 responder: StreamSocketGetIpPacketInfoResponder {
56617 control_handle: std::mem::ManuallyDrop::new(control_handle),
56618 tx_id: header.tx_id,
56619 },
56620 })
56621 }
56622 0x6c4f6714995f84ef => {
56623 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56624 let mut req = fidl::new_empty!(
56625 BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
56626 fidl::encoding::DefaultFuchsiaResourceDialect
56627 );
56628 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
56629 let control_handle =
56630 StreamSocketControlHandle { inner: this.inner.clone() };
56631 Ok(StreamSocketRequest::SetIpReceiveTypeOfService {
56632 value: req.value,
56633
56634 responder: StreamSocketSetIpReceiveTypeOfServiceResponder {
56635 control_handle: std::mem::ManuallyDrop::new(control_handle),
56636 tx_id: header.tx_id,
56637 },
56638 })
56639 }
56640 0x4158ba7dc2795960 => {
56641 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56642 let mut req = fidl::new_empty!(
56643 fidl::encoding::EmptyPayload,
56644 fidl::encoding::DefaultFuchsiaResourceDialect
56645 );
56646 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56647 let control_handle =
56648 StreamSocketControlHandle { inner: this.inner.clone() };
56649 Ok(StreamSocketRequest::GetIpReceiveTypeOfService {
56650 responder: StreamSocketGetIpReceiveTypeOfServiceResponder {
56651 control_handle: std::mem::ManuallyDrop::new(control_handle),
56652 tx_id: header.tx_id,
56653 },
56654 })
56655 }
56656 0x46f15be0ce0ab82b => {
56657 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56658 let mut req = fidl::new_empty!(
56659 BaseNetworkSocketSetIpReceiveTtlRequest,
56660 fidl::encoding::DefaultFuchsiaResourceDialect
56661 );
56662 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTtlRequest>(&header, _body_bytes, handles, &mut req)?;
56663 let control_handle =
56664 StreamSocketControlHandle { inner: this.inner.clone() };
56665 Ok(StreamSocketRequest::SetIpReceiveTtl {
56666 value: req.value,
56667
56668 responder: StreamSocketSetIpReceiveTtlResponder {
56669 control_handle: std::mem::ManuallyDrop::new(control_handle),
56670 tx_id: header.tx_id,
56671 },
56672 })
56673 }
56674 0x678ddd5a5dfa2eb5 => {
56675 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56676 let mut req = fidl::new_empty!(
56677 fidl::encoding::EmptyPayload,
56678 fidl::encoding::DefaultFuchsiaResourceDialect
56679 );
56680 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56681 let control_handle =
56682 StreamSocketControlHandle { inner: this.inner.clone() };
56683 Ok(StreamSocketRequest::GetIpReceiveTtl {
56684 responder: StreamSocketGetIpReceiveTtlResponder {
56685 control_handle: std::mem::ManuallyDrop::new(control_handle),
56686 tx_id: header.tx_id,
56687 },
56688 })
56689 }
56690 0x752fbfa9b12befe => {
56691 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56692 let mut req = fidl::new_empty!(
56693 BaseNetworkSocketSetIpMulticastInterfaceRequest,
56694 fidl::encoding::DefaultFuchsiaResourceDialect
56695 );
56696 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
56697 let control_handle =
56698 StreamSocketControlHandle { inner: this.inner.clone() };
56699 Ok(StreamSocketRequest::SetIpMulticastInterface {
56700 iface: req.iface,
56701 address: req.address,
56702
56703 responder: StreamSocketSetIpMulticastInterfaceResponder {
56704 control_handle: std::mem::ManuallyDrop::new(control_handle),
56705 tx_id: header.tx_id,
56706 },
56707 })
56708 }
56709 0x320bd14c4df046c4 => {
56710 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56711 let mut req = fidl::new_empty!(
56712 fidl::encoding::EmptyPayload,
56713 fidl::encoding::DefaultFuchsiaResourceDialect
56714 );
56715 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56716 let control_handle =
56717 StreamSocketControlHandle { inner: this.inner.clone() };
56718 Ok(StreamSocketRequest::GetIpMulticastInterface {
56719 responder: StreamSocketGetIpMulticastInterfaceResponder {
56720 control_handle: std::mem::ManuallyDrop::new(control_handle),
56721 tx_id: header.tx_id,
56722 },
56723 })
56724 }
56725 0x63134d53772916a1 => {
56726 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56727 let mut req = fidl::new_empty!(
56728 BaseNetworkSocketSetIpMulticastTtlRequest,
56729 fidl::encoding::DefaultFuchsiaResourceDialect
56730 );
56731 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastTtlRequest>(&header, _body_bytes, handles, &mut req)?;
56732 let control_handle =
56733 StreamSocketControlHandle { inner: this.inner.clone() };
56734 Ok(StreamSocketRequest::SetIpMulticastTtl {
56735 value: req.value,
56736
56737 responder: StreamSocketSetIpMulticastTtlResponder {
56738 control_handle: std::mem::ManuallyDrop::new(control_handle),
56739 tx_id: header.tx_id,
56740 },
56741 })
56742 }
56743 0x4665cd378f39e1a => {
56744 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56745 let mut req = fidl::new_empty!(
56746 fidl::encoding::EmptyPayload,
56747 fidl::encoding::DefaultFuchsiaResourceDialect
56748 );
56749 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56750 let control_handle =
56751 StreamSocketControlHandle { inner: this.inner.clone() };
56752 Ok(StreamSocketRequest::GetIpMulticastTtl {
56753 responder: StreamSocketGetIpMulticastTtlResponder {
56754 control_handle: std::mem::ManuallyDrop::new(control_handle),
56755 tx_id: header.tx_id,
56756 },
56757 })
56758 }
56759 0x20c55c11f00943ea => {
56760 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56761 let mut req = fidl::new_empty!(
56762 BaseNetworkSocketSetIpMulticastLoopbackRequest,
56763 fidl::encoding::DefaultFuchsiaResourceDialect
56764 );
56765 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
56766 let control_handle =
56767 StreamSocketControlHandle { inner: this.inner.clone() };
56768 Ok(StreamSocketRequest::SetIpMulticastLoopback {
56769 value: req.value,
56770
56771 responder: StreamSocketSetIpMulticastLoopbackResponder {
56772 control_handle: std::mem::ManuallyDrop::new(control_handle),
56773 tx_id: header.tx_id,
56774 },
56775 })
56776 }
56777 0x3b6b26ff558298f2 => {
56778 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56779 let mut req = fidl::new_empty!(
56780 fidl::encoding::EmptyPayload,
56781 fidl::encoding::DefaultFuchsiaResourceDialect
56782 );
56783 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56784 let control_handle =
56785 StreamSocketControlHandle { inner: this.inner.clone() };
56786 Ok(StreamSocketRequest::GetIpMulticastLoopback {
56787 responder: StreamSocketGetIpMulticastLoopbackResponder {
56788 control_handle: std::mem::ManuallyDrop::new(control_handle),
56789 tx_id: header.tx_id,
56790 },
56791 })
56792 }
56793 0x76bc7df115a3b4d0 => {
56794 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56795 let mut req = fidl::new_empty!(
56796 BaseNetworkSocketAddIpMembershipRequest,
56797 fidl::encoding::DefaultFuchsiaResourceDialect
56798 );
56799 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
56800 let control_handle =
56801 StreamSocketControlHandle { inner: this.inner.clone() };
56802 Ok(StreamSocketRequest::AddIpMembership {
56803 membership: req.membership,
56804
56805 responder: StreamSocketAddIpMembershipResponder {
56806 control_handle: std::mem::ManuallyDrop::new(control_handle),
56807 tx_id: header.tx_id,
56808 },
56809 })
56810 }
56811 0x2888f3099188d03 => {
56812 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56813 let mut req = fidl::new_empty!(
56814 BaseNetworkSocketDropIpMembershipRequest,
56815 fidl::encoding::DefaultFuchsiaResourceDialect
56816 );
56817 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
56818 let control_handle =
56819 StreamSocketControlHandle { inner: this.inner.clone() };
56820 Ok(StreamSocketRequest::DropIpMembership {
56821 membership: req.membership,
56822
56823 responder: StreamSocketDropIpMembershipResponder {
56824 control_handle: std::mem::ManuallyDrop::new(control_handle),
56825 tx_id: header.tx_id,
56826 },
56827 })
56828 }
56829 0x1ae532b0c066e3a0 => {
56830 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56831 let mut req = fidl::new_empty!(
56832 BaseNetworkSocketSetIpTransparentRequest,
56833 fidl::encoding::DefaultFuchsiaResourceDialect
56834 );
56835 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTransparentRequest>(&header, _body_bytes, handles, &mut req)?;
56836 let control_handle =
56837 StreamSocketControlHandle { inner: this.inner.clone() };
56838 Ok(StreamSocketRequest::SetIpTransparent {
56839 value: req.value,
56840
56841 responder: StreamSocketSetIpTransparentResponder {
56842 control_handle: std::mem::ManuallyDrop::new(control_handle),
56843 tx_id: header.tx_id,
56844 },
56845 })
56846 }
56847 0x51d43695962ebfb5 => {
56848 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56849 let mut req = fidl::new_empty!(
56850 fidl::encoding::EmptyPayload,
56851 fidl::encoding::DefaultFuchsiaResourceDialect
56852 );
56853 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56854 let control_handle =
56855 StreamSocketControlHandle { inner: this.inner.clone() };
56856 Ok(StreamSocketRequest::GetIpTransparent {
56857 responder: StreamSocketGetIpTransparentResponder {
56858 control_handle: std::mem::ManuallyDrop::new(control_handle),
56859 tx_id: header.tx_id,
56860 },
56861 })
56862 }
56863 0x4722b4ce52f7840 => {
56864 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56865 let mut req = fidl::new_empty!(
56866 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
56867 fidl::encoding::DefaultFuchsiaResourceDialect
56868 );
56869 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest>(&header, _body_bytes, handles, &mut req)?;
56870 let control_handle =
56871 StreamSocketControlHandle { inner: this.inner.clone() };
56872 Ok(StreamSocketRequest::SetIpReceiveOriginalDestinationAddress {
56873 value: req.value,
56874
56875 responder:
56876 StreamSocketSetIpReceiveOriginalDestinationAddressResponder {
56877 control_handle: std::mem::ManuallyDrop::new(control_handle),
56878 tx_id: header.tx_id,
56879 },
56880 })
56881 }
56882 0x2a0e7dc5d6bfdfe9 => {
56883 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56884 let mut req = fidl::new_empty!(
56885 fidl::encoding::EmptyPayload,
56886 fidl::encoding::DefaultFuchsiaResourceDialect
56887 );
56888 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56889 let control_handle =
56890 StreamSocketControlHandle { inner: this.inner.clone() };
56891 Ok(StreamSocketRequest::GetIpReceiveOriginalDestinationAddress {
56892 responder:
56893 StreamSocketGetIpReceiveOriginalDestinationAddressResponder {
56894 control_handle: std::mem::ManuallyDrop::new(control_handle),
56895 tx_id: header.tx_id,
56896 },
56897 })
56898 }
56899 0x7c94727acb4ea4b3 => {
56900 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56901 let mut req = fidl::new_empty!(
56902 BaseNetworkSocketAddIpv6MembershipRequest,
56903 fidl::encoding::DefaultFuchsiaResourceDialect
56904 );
56905 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
56906 let control_handle =
56907 StreamSocketControlHandle { inner: this.inner.clone() };
56908 Ok(StreamSocketRequest::AddIpv6Membership {
56909 membership: req.membership,
56910
56911 responder: StreamSocketAddIpv6MembershipResponder {
56912 control_handle: std::mem::ManuallyDrop::new(control_handle),
56913 tx_id: header.tx_id,
56914 },
56915 })
56916 }
56917 0x42104c70ccaba304 => {
56918 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56919 let mut req = fidl::new_empty!(
56920 BaseNetworkSocketDropIpv6MembershipRequest,
56921 fidl::encoding::DefaultFuchsiaResourceDialect
56922 );
56923 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
56924 let control_handle =
56925 StreamSocketControlHandle { inner: this.inner.clone() };
56926 Ok(StreamSocketRequest::DropIpv6Membership {
56927 membership: req.membership,
56928
56929 responder: StreamSocketDropIpv6MembershipResponder {
56930 control_handle: std::mem::ManuallyDrop::new(control_handle),
56931 tx_id: header.tx_id,
56932 },
56933 })
56934 }
56935 0x135f76db3774ab3b => {
56936 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56937 let mut req = fidl::new_empty!(
56938 BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
56939 fidl::encoding::DefaultFuchsiaResourceDialect
56940 );
56941 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
56942 let control_handle =
56943 StreamSocketControlHandle { inner: this.inner.clone() };
56944 Ok(StreamSocketRequest::SetIpv6MulticastInterface {
56945 value: req.value,
56946
56947 responder: StreamSocketSetIpv6MulticastInterfaceResponder {
56948 control_handle: std::mem::ManuallyDrop::new(control_handle),
56949 tx_id: header.tx_id,
56950 },
56951 })
56952 }
56953 0x1f26fcdd348f1882 => {
56954 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56955 let mut req = fidl::new_empty!(
56956 fidl::encoding::EmptyPayload,
56957 fidl::encoding::DefaultFuchsiaResourceDialect
56958 );
56959 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56960 let control_handle =
56961 StreamSocketControlHandle { inner: this.inner.clone() };
56962 Ok(StreamSocketRequest::GetIpv6MulticastInterface {
56963 responder: StreamSocketGetIpv6MulticastInterfaceResponder {
56964 control_handle: std::mem::ManuallyDrop::new(control_handle),
56965 tx_id: header.tx_id,
56966 },
56967 })
56968 }
56969 0x157d51e98f462859 => {
56970 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56971 let mut req = fidl::new_empty!(
56972 BaseNetworkSocketSetIpv6UnicastHopsRequest,
56973 fidl::encoding::DefaultFuchsiaResourceDialect
56974 );
56975 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6UnicastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
56976 let control_handle =
56977 StreamSocketControlHandle { inner: this.inner.clone() };
56978 Ok(StreamSocketRequest::SetIpv6UnicastHops {
56979 value: req.value,
56980
56981 responder: StreamSocketSetIpv6UnicastHopsResponder {
56982 control_handle: std::mem::ManuallyDrop::new(control_handle),
56983 tx_id: header.tx_id,
56984 },
56985 })
56986 }
56987 0x21f4641cad8bd8d2 => {
56988 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56989 let mut req = fidl::new_empty!(
56990 fidl::encoding::EmptyPayload,
56991 fidl::encoding::DefaultFuchsiaResourceDialect
56992 );
56993 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56994 let control_handle =
56995 StreamSocketControlHandle { inner: this.inner.clone() };
56996 Ok(StreamSocketRequest::GetIpv6UnicastHops {
56997 responder: StreamSocketGetIpv6UnicastHopsResponder {
56998 control_handle: std::mem::ManuallyDrop::new(control_handle),
56999 tx_id: header.tx_id,
57000 },
57001 })
57002 }
57003 0x5c24808ed2e84a1e => {
57004 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57005 let mut req = fidl::new_empty!(
57006 BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
57007 fidl::encoding::DefaultFuchsiaResourceDialect
57008 );
57009 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveHopLimitRequest>(&header, _body_bytes, handles, &mut req)?;
57010 let control_handle =
57011 StreamSocketControlHandle { inner: this.inner.clone() };
57012 Ok(StreamSocketRequest::SetIpv6ReceiveHopLimit {
57013 value: req.value,
57014
57015 responder: StreamSocketSetIpv6ReceiveHopLimitResponder {
57016 control_handle: std::mem::ManuallyDrop::new(control_handle),
57017 tx_id: header.tx_id,
57018 },
57019 })
57020 }
57021 0x341e06689885b4c0 => {
57022 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57023 let mut req = fidl::new_empty!(
57024 fidl::encoding::EmptyPayload,
57025 fidl::encoding::DefaultFuchsiaResourceDialect
57026 );
57027 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57028 let control_handle =
57029 StreamSocketControlHandle { inner: this.inner.clone() };
57030 Ok(StreamSocketRequest::GetIpv6ReceiveHopLimit {
57031 responder: StreamSocketGetIpv6ReceiveHopLimitResponder {
57032 control_handle: std::mem::ManuallyDrop::new(control_handle),
57033 tx_id: header.tx_id,
57034 },
57035 })
57036 }
57037 0x25b9cd4d181f82c1 => {
57038 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57039 let mut req = fidl::new_empty!(
57040 BaseNetworkSocketSetIpv6MulticastHopsRequest,
57041 fidl::encoding::DefaultFuchsiaResourceDialect
57042 );
57043 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
57044 let control_handle =
57045 StreamSocketControlHandle { inner: this.inner.clone() };
57046 Ok(StreamSocketRequest::SetIpv6MulticastHops {
57047 value: req.value,
57048
57049 responder: StreamSocketSetIpv6MulticastHopsResponder {
57050 control_handle: std::mem::ManuallyDrop::new(control_handle),
57051 tx_id: header.tx_id,
57052 },
57053 })
57054 }
57055 0x52916948a365012a => {
57056 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57057 let mut req = fidl::new_empty!(
57058 fidl::encoding::EmptyPayload,
57059 fidl::encoding::DefaultFuchsiaResourceDialect
57060 );
57061 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57062 let control_handle =
57063 StreamSocketControlHandle { inner: this.inner.clone() };
57064 Ok(StreamSocketRequest::GetIpv6MulticastHops {
57065 responder: StreamSocketGetIpv6MulticastHopsResponder {
57066 control_handle: std::mem::ManuallyDrop::new(control_handle),
57067 tx_id: header.tx_id,
57068 },
57069 })
57070 }
57071 0x55701c409ff41b40 => {
57072 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57073 let mut req = fidl::new_empty!(
57074 BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
57075 fidl::encoding::DefaultFuchsiaResourceDialect
57076 );
57077 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
57078 let control_handle =
57079 StreamSocketControlHandle { inner: this.inner.clone() };
57080 Ok(StreamSocketRequest::SetIpv6MulticastLoopback {
57081 value: req.value,
57082
57083 responder: StreamSocketSetIpv6MulticastLoopbackResponder {
57084 control_handle: std::mem::ManuallyDrop::new(control_handle),
57085 tx_id: header.tx_id,
57086 },
57087 })
57088 }
57089 0x4415b701fde319c3 => {
57090 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57091 let mut req = fidl::new_empty!(
57092 fidl::encoding::EmptyPayload,
57093 fidl::encoding::DefaultFuchsiaResourceDialect
57094 );
57095 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57096 let control_handle =
57097 StreamSocketControlHandle { inner: this.inner.clone() };
57098 Ok(StreamSocketRequest::GetIpv6MulticastLoopback {
57099 responder: StreamSocketGetIpv6MulticastLoopbackResponder {
57100 control_handle: std::mem::ManuallyDrop::new(control_handle),
57101 tx_id: header.tx_id,
57102 },
57103 })
57104 }
57105 0x4873f1364758cbba => {
57106 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57107 let mut req = fidl::new_empty!(
57108 BaseNetworkSocketSetIpv6OnlyRequest,
57109 fidl::encoding::DefaultFuchsiaResourceDialect
57110 );
57111 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6OnlyRequest>(&header, _body_bytes, handles, &mut req)?;
57112 let control_handle =
57113 StreamSocketControlHandle { inner: this.inner.clone() };
57114 Ok(StreamSocketRequest::SetIpv6Only {
57115 value: req.value,
57116
57117 responder: StreamSocketSetIpv6OnlyResponder {
57118 control_handle: std::mem::ManuallyDrop::new(control_handle),
57119 tx_id: header.tx_id,
57120 },
57121 })
57122 }
57123 0x4aa3340a1a26b89c => {
57124 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57125 let mut req = fidl::new_empty!(
57126 fidl::encoding::EmptyPayload,
57127 fidl::encoding::DefaultFuchsiaResourceDialect
57128 );
57129 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57130 let control_handle =
57131 StreamSocketControlHandle { inner: this.inner.clone() };
57132 Ok(StreamSocketRequest::GetIpv6Only {
57133 responder: StreamSocketGetIpv6OnlyResponder {
57134 control_handle: std::mem::ManuallyDrop::new(control_handle),
57135 tx_id: header.tx_id,
57136 },
57137 })
57138 }
57139 0x58f07c8788d099a0 => {
57140 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57141 let mut req = fidl::new_empty!(
57142 BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
57143 fidl::encoding::DefaultFuchsiaResourceDialect
57144 );
57145 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
57146 let control_handle =
57147 StreamSocketControlHandle { inner: this.inner.clone() };
57148 Ok(StreamSocketRequest::SetIpv6ReceiveTrafficClass {
57149 value: req.value,
57150
57151 responder: StreamSocketSetIpv6ReceiveTrafficClassResponder {
57152 control_handle: std::mem::ManuallyDrop::new(control_handle),
57153 tx_id: header.tx_id,
57154 },
57155 })
57156 }
57157 0x2e334df1da553ffa => {
57158 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57159 let mut req = fidl::new_empty!(
57160 fidl::encoding::EmptyPayload,
57161 fidl::encoding::DefaultFuchsiaResourceDialect
57162 );
57163 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57164 let control_handle =
57165 StreamSocketControlHandle { inner: this.inner.clone() };
57166 Ok(StreamSocketRequest::GetIpv6ReceiveTrafficClass {
57167 responder: StreamSocketGetIpv6ReceiveTrafficClassResponder {
57168 control_handle: std::mem::ManuallyDrop::new(control_handle),
57169 tx_id: header.tx_id,
57170 },
57171 })
57172 }
57173 0x6af077800c5a0b4f => {
57174 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57175 let mut req = fidl::new_empty!(
57176 BaseNetworkSocketSetIpv6TrafficClassRequest,
57177 fidl::encoding::DefaultFuchsiaResourceDialect
57178 );
57179 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6TrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
57180 let control_handle =
57181 StreamSocketControlHandle { inner: this.inner.clone() };
57182 Ok(StreamSocketRequest::SetIpv6TrafficClass {
57183 value: req.value,
57184
57185 responder: StreamSocketSetIpv6TrafficClassResponder {
57186 control_handle: std::mem::ManuallyDrop::new(control_handle),
57187 tx_id: header.tx_id,
57188 },
57189 })
57190 }
57191 0x6baf6eed8fc2f04 => {
57192 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57193 let mut req = fidl::new_empty!(
57194 fidl::encoding::EmptyPayload,
57195 fidl::encoding::DefaultFuchsiaResourceDialect
57196 );
57197 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57198 let control_handle =
57199 StreamSocketControlHandle { inner: this.inner.clone() };
57200 Ok(StreamSocketRequest::GetIpv6TrafficClass {
57201 responder: StreamSocketGetIpv6TrafficClassResponder {
57202 control_handle: std::mem::ManuallyDrop::new(control_handle),
57203 tx_id: header.tx_id,
57204 },
57205 })
57206 }
57207 0x19259775b1a92768 => {
57208 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57209 let mut req = fidl::new_empty!(
57210 BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
57211 fidl::encoding::DefaultFuchsiaResourceDialect
57212 );
57213 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceivePacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
57214 let control_handle =
57215 StreamSocketControlHandle { inner: this.inner.clone() };
57216 Ok(StreamSocketRequest::SetIpv6ReceivePacketInfo {
57217 value: req.value,
57218
57219 responder: StreamSocketSetIpv6ReceivePacketInfoResponder {
57220 control_handle: std::mem::ManuallyDrop::new(control_handle),
57221 tx_id: header.tx_id,
57222 },
57223 })
57224 }
57225 0x7acd4a2775baec75 => {
57226 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57227 let mut req = fidl::new_empty!(
57228 fidl::encoding::EmptyPayload,
57229 fidl::encoding::DefaultFuchsiaResourceDialect
57230 );
57231 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57232 let control_handle =
57233 StreamSocketControlHandle { inner: this.inner.clone() };
57234 Ok(StreamSocketRequest::GetIpv6ReceivePacketInfo {
57235 responder: StreamSocketGetIpv6ReceivePacketInfoResponder {
57236 control_handle: std::mem::ManuallyDrop::new(control_handle),
57237 tx_id: header.tx_id,
57238 },
57239 })
57240 }
57241 0x38bf28f0dafdbac0 => {
57242 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57243 let mut req = fidl::new_empty!(
57244 fidl::encoding::EmptyPayload,
57245 fidl::encoding::DefaultFuchsiaResourceDialect
57246 );
57247 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57248 let control_handle =
57249 StreamSocketControlHandle { inner: this.inner.clone() };
57250 Ok(StreamSocketRequest::GetOriginalDestination {
57251 responder: StreamSocketGetOriginalDestinationResponder {
57252 control_handle: std::mem::ManuallyDrop::new(control_handle),
57253 tx_id: header.tx_id,
57254 },
57255 })
57256 }
57257 0x29e22969a7dadc32 => {
57258 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57259 let mut req = fidl::new_empty!(
57260 fidl::encoding::EmptyPayload,
57261 fidl::encoding::DefaultFuchsiaResourceDialect
57262 );
57263 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57264 let control_handle =
57265 StreamSocketControlHandle { inner: this.inner.clone() };
57266 Ok(StreamSocketRequest::Describe {
57267 responder: StreamSocketDescribeResponder {
57268 control_handle: std::mem::ManuallyDrop::new(control_handle),
57269 tx_id: header.tx_id,
57270 },
57271 })
57272 }
57273 0x3d0a65ced3d10108 => {
57274 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57275 let mut req = fidl::new_empty!(
57276 StreamSocketListenRequest,
57277 fidl::encoding::DefaultFuchsiaResourceDialect
57278 );
57279 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketListenRequest>(&header, _body_bytes, handles, &mut req)?;
57280 let control_handle =
57281 StreamSocketControlHandle { inner: this.inner.clone() };
57282 Ok(StreamSocketRequest::Listen {
57283 backlog: req.backlog,
57284
57285 responder: StreamSocketListenResponder {
57286 control_handle: std::mem::ManuallyDrop::new(control_handle),
57287 tx_id: header.tx_id,
57288 },
57289 })
57290 }
57291 0x5ab7ad620424c163 => {
57292 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57293 let mut req = fidl::new_empty!(
57294 StreamSocketAcceptRequest,
57295 fidl::encoding::DefaultFuchsiaResourceDialect
57296 );
57297 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketAcceptRequest>(&header, _body_bytes, handles, &mut req)?;
57298 let control_handle =
57299 StreamSocketControlHandle { inner: this.inner.clone() };
57300 Ok(StreamSocketRequest::Accept {
57301 want_addr: req.want_addr,
57302
57303 responder: StreamSocketAcceptResponder {
57304 control_handle: std::mem::ManuallyDrop::new(control_handle),
57305 tx_id: header.tx_id,
57306 },
57307 })
57308 }
57309 0x87cfa55d19f878f => {
57310 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57311 let mut req = fidl::new_empty!(
57312 fidl::encoding::EmptyPayload,
57313 fidl::encoding::DefaultFuchsiaResourceDialect
57314 );
57315 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57316 let control_handle =
57317 StreamSocketControlHandle { inner: this.inner.clone() };
57318 Ok(StreamSocketRequest::GetInfo {
57319 responder: StreamSocketGetInfoResponder {
57320 control_handle: std::mem::ManuallyDrop::new(control_handle),
57321 tx_id: header.tx_id,
57322 },
57323 })
57324 }
57325 0x5a59b778f7333ada => {
57326 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57327 let mut req = fidl::new_empty!(
57328 StreamSocketSetTcpNoDelayRequest,
57329 fidl::encoding::DefaultFuchsiaResourceDialect
57330 );
57331 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpNoDelayRequest>(&header, _body_bytes, handles, &mut req)?;
57332 let control_handle =
57333 StreamSocketControlHandle { inner: this.inner.clone() };
57334 Ok(StreamSocketRequest::SetTcpNoDelay {
57335 value: req.value,
57336
57337 responder: StreamSocketSetTcpNoDelayResponder {
57338 control_handle: std::mem::ManuallyDrop::new(control_handle),
57339 tx_id: header.tx_id,
57340 },
57341 })
57342 }
57343 0xac219a3218b0799 => {
57344 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57345 let mut req = fidl::new_empty!(
57346 fidl::encoding::EmptyPayload,
57347 fidl::encoding::DefaultFuchsiaResourceDialect
57348 );
57349 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57350 let control_handle =
57351 StreamSocketControlHandle { inner: this.inner.clone() };
57352 Ok(StreamSocketRequest::GetTcpNoDelay {
57353 responder: StreamSocketGetTcpNoDelayResponder {
57354 control_handle: std::mem::ManuallyDrop::new(control_handle),
57355 tx_id: header.tx_id,
57356 },
57357 })
57358 }
57359 0xb3d30c498266d18 => {
57360 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57361 let mut req = fidl::new_empty!(
57362 StreamSocketSetTcpMaxSegmentRequest,
57363 fidl::encoding::DefaultFuchsiaResourceDialect
57364 );
57365 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpMaxSegmentRequest>(&header, _body_bytes, handles, &mut req)?;
57366 let control_handle =
57367 StreamSocketControlHandle { inner: this.inner.clone() };
57368 Ok(StreamSocketRequest::SetTcpMaxSegment {
57369 value_bytes: req.value_bytes,
57370
57371 responder: StreamSocketSetTcpMaxSegmentResponder {
57372 control_handle: std::mem::ManuallyDrop::new(control_handle),
57373 tx_id: header.tx_id,
57374 },
57375 })
57376 }
57377 0x637404d1b4b9982c => {
57378 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57379 let mut req = fidl::new_empty!(
57380 fidl::encoding::EmptyPayload,
57381 fidl::encoding::DefaultFuchsiaResourceDialect
57382 );
57383 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57384 let control_handle =
57385 StreamSocketControlHandle { inner: this.inner.clone() };
57386 Ok(StreamSocketRequest::GetTcpMaxSegment {
57387 responder: StreamSocketGetTcpMaxSegmentResponder {
57388 control_handle: std::mem::ManuallyDrop::new(control_handle),
57389 tx_id: header.tx_id,
57390 },
57391 })
57392 }
57393 0x62e26891541143a0 => {
57394 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57395 let mut req = fidl::new_empty!(
57396 StreamSocketSetTcpCorkRequest,
57397 fidl::encoding::DefaultFuchsiaResourceDialect
57398 );
57399 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpCorkRequest>(&header, _body_bytes, handles, &mut req)?;
57400 let control_handle =
57401 StreamSocketControlHandle { inner: this.inner.clone() };
57402 Ok(StreamSocketRequest::SetTcpCork {
57403 value: req.value,
57404
57405 responder: StreamSocketSetTcpCorkResponder {
57406 control_handle: std::mem::ManuallyDrop::new(control_handle),
57407 tx_id: header.tx_id,
57408 },
57409 })
57410 }
57411 0x435bb232e0e74f32 => {
57412 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57413 let mut req = fidl::new_empty!(
57414 fidl::encoding::EmptyPayload,
57415 fidl::encoding::DefaultFuchsiaResourceDialect
57416 );
57417 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57418 let control_handle =
57419 StreamSocketControlHandle { inner: this.inner.clone() };
57420 Ok(StreamSocketRequest::GetTcpCork {
57421 responder: StreamSocketGetTcpCorkResponder {
57422 control_handle: std::mem::ManuallyDrop::new(control_handle),
57423 tx_id: header.tx_id,
57424 },
57425 })
57426 }
57427 0x196d053d8363c42 => {
57428 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57429 let mut req = fidl::new_empty!(
57430 StreamSocketSetTcpKeepAliveIdleRequest,
57431 fidl::encoding::DefaultFuchsiaResourceDialect
57432 );
57433 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpKeepAliveIdleRequest>(&header, _body_bytes, handles, &mut req)?;
57434 let control_handle =
57435 StreamSocketControlHandle { inner: this.inner.clone() };
57436 Ok(StreamSocketRequest::SetTcpKeepAliveIdle {
57437 value_secs: req.value_secs,
57438
57439 responder: StreamSocketSetTcpKeepAliveIdleResponder {
57440 control_handle: std::mem::ManuallyDrop::new(control_handle),
57441 tx_id: header.tx_id,
57442 },
57443 })
57444 }
57445 0x35ec58564879dac => {
57446 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57447 let mut req = fidl::new_empty!(
57448 fidl::encoding::EmptyPayload,
57449 fidl::encoding::DefaultFuchsiaResourceDialect
57450 );
57451 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57452 let control_handle =
57453 StreamSocketControlHandle { inner: this.inner.clone() };
57454 Ok(StreamSocketRequest::GetTcpKeepAliveIdle {
57455 responder: StreamSocketGetTcpKeepAliveIdleResponder {
57456 control_handle: std::mem::ManuallyDrop::new(control_handle),
57457 tx_id: header.tx_id,
57458 },
57459 })
57460 }
57461 0x485ffbc2da1243f2 => {
57462 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57463 let mut req = fidl::new_empty!(
57464 StreamSocketSetTcpKeepAliveIntervalRequest,
57465 fidl::encoding::DefaultFuchsiaResourceDialect
57466 );
57467 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpKeepAliveIntervalRequest>(&header, _body_bytes, handles, &mut req)?;
57468 let control_handle =
57469 StreamSocketControlHandle { inner: this.inner.clone() };
57470 Ok(StreamSocketRequest::SetTcpKeepAliveInterval {
57471 value_secs: req.value_secs,
57472
57473 responder: StreamSocketSetTcpKeepAliveIntervalResponder {
57474 control_handle: std::mem::ManuallyDrop::new(control_handle),
57475 tx_id: header.tx_id,
57476 },
57477 })
57478 }
57479 0x264eaf46306b284 => {
57480 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57481 let mut req = fidl::new_empty!(
57482 fidl::encoding::EmptyPayload,
57483 fidl::encoding::DefaultFuchsiaResourceDialect
57484 );
57485 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57486 let control_handle =
57487 StreamSocketControlHandle { inner: this.inner.clone() };
57488 Ok(StreamSocketRequest::GetTcpKeepAliveInterval {
57489 responder: StreamSocketGetTcpKeepAliveIntervalResponder {
57490 control_handle: std::mem::ManuallyDrop::new(control_handle),
57491 tx_id: header.tx_id,
57492 },
57493 })
57494 }
57495 0x2ab2e8c111708421 => {
57496 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57497 let mut req = fidl::new_empty!(
57498 StreamSocketSetTcpKeepAliveCountRequest,
57499 fidl::encoding::DefaultFuchsiaResourceDialect
57500 );
57501 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpKeepAliveCountRequest>(&header, _body_bytes, handles, &mut req)?;
57502 let control_handle =
57503 StreamSocketControlHandle { inner: this.inner.clone() };
57504 Ok(StreamSocketRequest::SetTcpKeepAliveCount {
57505 value: req.value,
57506
57507 responder: StreamSocketSetTcpKeepAliveCountResponder {
57508 control_handle: std::mem::ManuallyDrop::new(control_handle),
57509 tx_id: header.tx_id,
57510 },
57511 })
57512 }
57513 0x2f176ae271fe7a09 => {
57514 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57515 let mut req = fidl::new_empty!(
57516 fidl::encoding::EmptyPayload,
57517 fidl::encoding::DefaultFuchsiaResourceDialect
57518 );
57519 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57520 let control_handle =
57521 StreamSocketControlHandle { inner: this.inner.clone() };
57522 Ok(StreamSocketRequest::GetTcpKeepAliveCount {
57523 responder: StreamSocketGetTcpKeepAliveCountResponder {
57524 control_handle: std::mem::ManuallyDrop::new(control_handle),
57525 tx_id: header.tx_id,
57526 },
57527 })
57528 }
57529 0x4dcd6ab5573c1eb3 => {
57530 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57531 let mut req = fidl::new_empty!(
57532 StreamSocketSetTcpSynCountRequest,
57533 fidl::encoding::DefaultFuchsiaResourceDialect
57534 );
57535 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpSynCountRequest>(&header, _body_bytes, handles, &mut req)?;
57536 let control_handle =
57537 StreamSocketControlHandle { inner: this.inner.clone() };
57538 Ok(StreamSocketRequest::SetTcpSynCount {
57539 value: req.value,
57540
57541 responder: StreamSocketSetTcpSynCountResponder {
57542 control_handle: std::mem::ManuallyDrop::new(control_handle),
57543 tx_id: header.tx_id,
57544 },
57545 })
57546 }
57547 0x7d457cba8f5f3ee6 => {
57548 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57549 let mut req = fidl::new_empty!(
57550 fidl::encoding::EmptyPayload,
57551 fidl::encoding::DefaultFuchsiaResourceDialect
57552 );
57553 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57554 let control_handle =
57555 StreamSocketControlHandle { inner: this.inner.clone() };
57556 Ok(StreamSocketRequest::GetTcpSynCount {
57557 responder: StreamSocketGetTcpSynCountResponder {
57558 control_handle: std::mem::ManuallyDrop::new(control_handle),
57559 tx_id: header.tx_id,
57560 },
57561 })
57562 }
57563 0xd5cc1e8654d36e4 => {
57564 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57565 let mut req = fidl::new_empty!(
57566 StreamSocketSetTcpLingerRequest,
57567 fidl::encoding::DefaultFuchsiaResourceDialect
57568 );
57569 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpLingerRequest>(&header, _body_bytes, handles, &mut req)?;
57570 let control_handle =
57571 StreamSocketControlHandle { inner: this.inner.clone() };
57572 Ok(StreamSocketRequest::SetTcpLinger {
57573 value_secs: req.value_secs,
57574
57575 responder: StreamSocketSetTcpLingerResponder {
57576 control_handle: std::mem::ManuallyDrop::new(control_handle),
57577 tx_id: header.tx_id,
57578 },
57579 })
57580 }
57581 0xad870d311cf30eb => {
57582 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57583 let mut req = fidl::new_empty!(
57584 fidl::encoding::EmptyPayload,
57585 fidl::encoding::DefaultFuchsiaResourceDialect
57586 );
57587 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57588 let control_handle =
57589 StreamSocketControlHandle { inner: this.inner.clone() };
57590 Ok(StreamSocketRequest::GetTcpLinger {
57591 responder: StreamSocketGetTcpLingerResponder {
57592 control_handle: std::mem::ManuallyDrop::new(control_handle),
57593 tx_id: header.tx_id,
57594 },
57595 })
57596 }
57597 0x15092f181e57c404 => {
57598 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57599 let mut req = fidl::new_empty!(
57600 StreamSocketSetTcpDeferAcceptRequest,
57601 fidl::encoding::DefaultFuchsiaResourceDialect
57602 );
57603 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpDeferAcceptRequest>(&header, _body_bytes, handles, &mut req)?;
57604 let control_handle =
57605 StreamSocketControlHandle { inner: this.inner.clone() };
57606 Ok(StreamSocketRequest::SetTcpDeferAccept {
57607 value_secs: req.value_secs,
57608
57609 responder: StreamSocketSetTcpDeferAcceptResponder {
57610 control_handle: std::mem::ManuallyDrop::new(control_handle),
57611 tx_id: header.tx_id,
57612 },
57613 })
57614 }
57615 0x64589790842cb7c6 => {
57616 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57617 let mut req = fidl::new_empty!(
57618 fidl::encoding::EmptyPayload,
57619 fidl::encoding::DefaultFuchsiaResourceDialect
57620 );
57621 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57622 let control_handle =
57623 StreamSocketControlHandle { inner: this.inner.clone() };
57624 Ok(StreamSocketRequest::GetTcpDeferAccept {
57625 responder: StreamSocketGetTcpDeferAcceptResponder {
57626 control_handle: std::mem::ManuallyDrop::new(control_handle),
57627 tx_id: header.tx_id,
57628 },
57629 })
57630 }
57631 0x4a26ce07d847f1c6 => {
57632 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57633 let mut req = fidl::new_empty!(
57634 StreamSocketSetTcpWindowClampRequest,
57635 fidl::encoding::DefaultFuchsiaResourceDialect
57636 );
57637 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpWindowClampRequest>(&header, _body_bytes, handles, &mut req)?;
57638 let control_handle =
57639 StreamSocketControlHandle { inner: this.inner.clone() };
57640 Ok(StreamSocketRequest::SetTcpWindowClamp {
57641 value: req.value,
57642
57643 responder: StreamSocketSetTcpWindowClampResponder {
57644 control_handle: std::mem::ManuallyDrop::new(control_handle),
57645 tx_id: header.tx_id,
57646 },
57647 })
57648 }
57649 0x2df6b636bf0a6a4e => {
57650 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57651 let mut req = fidl::new_empty!(
57652 fidl::encoding::EmptyPayload,
57653 fidl::encoding::DefaultFuchsiaResourceDialect
57654 );
57655 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57656 let control_handle =
57657 StreamSocketControlHandle { inner: this.inner.clone() };
57658 Ok(StreamSocketRequest::GetTcpWindowClamp {
57659 responder: StreamSocketGetTcpWindowClampResponder {
57660 control_handle: std::mem::ManuallyDrop::new(control_handle),
57661 tx_id: header.tx_id,
57662 },
57663 })
57664 }
57665 0x1ffb123d9f03ead2 => {
57666 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57667 let mut req = fidl::new_empty!(
57668 fidl::encoding::EmptyPayload,
57669 fidl::encoding::DefaultFuchsiaResourceDialect
57670 );
57671 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57672 let control_handle =
57673 StreamSocketControlHandle { inner: this.inner.clone() };
57674 Ok(StreamSocketRequest::GetTcpInfo {
57675 responder: StreamSocketGetTcpInfoResponder {
57676 control_handle: std::mem::ManuallyDrop::new(control_handle),
57677 tx_id: header.tx_id,
57678 },
57679 })
57680 }
57681 0x6fa811be8fde7457 => {
57682 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57683 let mut req = fidl::new_empty!(
57684 StreamSocketSetTcpQuickAckRequest,
57685 fidl::encoding::DefaultFuchsiaResourceDialect
57686 );
57687 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpQuickAckRequest>(&header, _body_bytes, handles, &mut req)?;
57688 let control_handle =
57689 StreamSocketControlHandle { inner: this.inner.clone() };
57690 Ok(StreamSocketRequest::SetTcpQuickAck {
57691 value: req.value,
57692
57693 responder: StreamSocketSetTcpQuickAckResponder {
57694 control_handle: std::mem::ManuallyDrop::new(control_handle),
57695 tx_id: header.tx_id,
57696 },
57697 })
57698 }
57699 0x7356a949bef2df32 => {
57700 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57701 let mut req = fidl::new_empty!(
57702 fidl::encoding::EmptyPayload,
57703 fidl::encoding::DefaultFuchsiaResourceDialect
57704 );
57705 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57706 let control_handle =
57707 StreamSocketControlHandle { inner: this.inner.clone() };
57708 Ok(StreamSocketRequest::GetTcpQuickAck {
57709 responder: StreamSocketGetTcpQuickAckResponder {
57710 control_handle: std::mem::ManuallyDrop::new(control_handle),
57711 tx_id: header.tx_id,
57712 },
57713 })
57714 }
57715 0x7924c6eabde7819e => {
57716 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57717 let mut req = fidl::new_empty!(
57718 StreamSocketSetTcpCongestionRequest,
57719 fidl::encoding::DefaultFuchsiaResourceDialect
57720 );
57721 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpCongestionRequest>(&header, _body_bytes, handles, &mut req)?;
57722 let control_handle =
57723 StreamSocketControlHandle { inner: this.inner.clone() };
57724 Ok(StreamSocketRequest::SetTcpCongestion {
57725 value: req.value,
57726
57727 responder: StreamSocketSetTcpCongestionResponder {
57728 control_handle: std::mem::ManuallyDrop::new(control_handle),
57729 tx_id: header.tx_id,
57730 },
57731 })
57732 }
57733 0x11e16397e1b72a47 => {
57734 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57735 let mut req = fidl::new_empty!(
57736 fidl::encoding::EmptyPayload,
57737 fidl::encoding::DefaultFuchsiaResourceDialect
57738 );
57739 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57740 let control_handle =
57741 StreamSocketControlHandle { inner: this.inner.clone() };
57742 Ok(StreamSocketRequest::GetTcpCongestion {
57743 responder: StreamSocketGetTcpCongestionResponder {
57744 control_handle: std::mem::ManuallyDrop::new(control_handle),
57745 tx_id: header.tx_id,
57746 },
57747 })
57748 }
57749 0x6b459e81c3741a60 => {
57750 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57751 let mut req = fidl::new_empty!(
57752 StreamSocketSetTcpUserTimeoutRequest,
57753 fidl::encoding::DefaultFuchsiaResourceDialect
57754 );
57755 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpUserTimeoutRequest>(&header, _body_bytes, handles, &mut req)?;
57756 let control_handle =
57757 StreamSocketControlHandle { inner: this.inner.clone() };
57758 Ok(StreamSocketRequest::SetTcpUserTimeout {
57759 value_millis: req.value_millis,
57760
57761 responder: StreamSocketSetTcpUserTimeoutResponder {
57762 control_handle: std::mem::ManuallyDrop::new(control_handle),
57763 tx_id: header.tx_id,
57764 },
57765 })
57766 }
57767 0x24bbd5858ad8c380 => {
57768 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57769 let mut req = fidl::new_empty!(
57770 fidl::encoding::EmptyPayload,
57771 fidl::encoding::DefaultFuchsiaResourceDialect
57772 );
57773 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57774 let control_handle =
57775 StreamSocketControlHandle { inner: this.inner.clone() };
57776 Ok(StreamSocketRequest::GetTcpUserTimeout {
57777 responder: StreamSocketGetTcpUserTimeoutResponder {
57778 control_handle: std::mem::ManuallyDrop::new(control_handle),
57779 tx_id: header.tx_id,
57780 },
57781 })
57782 }
57783 _ => Err(fidl::Error::UnknownOrdinal {
57784 ordinal: header.ordinal,
57785 protocol_name:
57786 <StreamSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
57787 }),
57788 }))
57789 },
57790 )
57791 }
57792}
57793
57794#[derive(Debug)]
57804pub enum StreamSocketRequest {
57805 Clone {
57806 request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
57807 control_handle: StreamSocketControlHandle,
57808 },
57809 Close {
57820 responder: StreamSocketCloseResponder,
57821 },
57822 Query {
57823 responder: StreamSocketQueryResponder,
57824 },
57825 SetReuseAddress {
57827 value: bool,
57828 responder: StreamSocketSetReuseAddressResponder,
57829 },
57830 GetReuseAddress {
57832 responder: StreamSocketGetReuseAddressResponder,
57833 },
57834 GetError {
57837 responder: StreamSocketGetErrorResponder,
57838 },
57839 SetBroadcast {
57841 value: bool,
57842 responder: StreamSocketSetBroadcastResponder,
57843 },
57844 GetBroadcast {
57846 responder: StreamSocketGetBroadcastResponder,
57847 },
57848 SetSendBuffer {
57850 value_bytes: u64,
57851 responder: StreamSocketSetSendBufferResponder,
57852 },
57853 GetSendBuffer {
57855 responder: StreamSocketGetSendBufferResponder,
57856 },
57857 SetReceiveBuffer {
57859 value_bytes: u64,
57860 responder: StreamSocketSetReceiveBufferResponder,
57861 },
57862 GetReceiveBuffer {
57864 responder: StreamSocketGetReceiveBufferResponder,
57865 },
57866 SetKeepAlive {
57868 value: bool,
57869 responder: StreamSocketSetKeepAliveResponder,
57870 },
57871 GetKeepAlive {
57873 responder: StreamSocketGetKeepAliveResponder,
57874 },
57875 SetOutOfBandInline {
57877 value: bool,
57878 responder: StreamSocketSetOutOfBandInlineResponder,
57879 },
57880 GetOutOfBandInline {
57882 responder: StreamSocketGetOutOfBandInlineResponder,
57883 },
57884 SetNoCheck {
57886 value: bool,
57887 responder: StreamSocketSetNoCheckResponder,
57888 },
57889 GetNoCheck {
57891 responder: StreamSocketGetNoCheckResponder,
57892 },
57893 SetLinger {
57895 linger: bool,
57896 length_secs: u32,
57897 responder: StreamSocketSetLingerResponder,
57898 },
57899 GetLinger {
57901 responder: StreamSocketGetLingerResponder,
57902 },
57903 SetReusePort {
57905 value: bool,
57906 responder: StreamSocketSetReusePortResponder,
57907 },
57908 GetReusePort {
57910 responder: StreamSocketGetReusePortResponder,
57911 },
57912 GetAcceptConn {
57914 responder: StreamSocketGetAcceptConnResponder,
57915 },
57916 SetBindToDevice {
57918 value: String,
57919 responder: StreamSocketSetBindToDeviceResponder,
57920 },
57921 GetBindToDevice {
57923 responder: StreamSocketGetBindToDeviceResponder,
57924 },
57925 SetBindToInterfaceIndex {
57928 value: u64,
57929 responder: StreamSocketSetBindToInterfaceIndexResponder,
57930 },
57931 GetBindToInterfaceIndex {
57933 responder: StreamSocketGetBindToInterfaceIndexResponder,
57934 },
57935 SetTimestamp {
57937 value: TimestampOption,
57938 responder: StreamSocketSetTimestampResponder,
57939 },
57940 GetTimestamp {
57942 responder: StreamSocketGetTimestampResponder,
57943 },
57944 SetMark {
57948 domain: fidl_fuchsia_net::MarkDomain,
57949 mark: OptionalUint32,
57950 responder: StreamSocketSetMarkResponder,
57951 },
57952 GetMark {
57956 domain: fidl_fuchsia_net::MarkDomain,
57957 responder: StreamSocketGetMarkResponder,
57958 },
57959 Bind {
57961 addr: fidl_fuchsia_net::SocketAddress,
57962 responder: StreamSocketBindResponder,
57963 },
57964 Connect {
57966 addr: fidl_fuchsia_net::SocketAddress,
57967 responder: StreamSocketConnectResponder,
57968 },
57969 Disconnect {
57971 responder: StreamSocketDisconnectResponder,
57972 },
57973 GetSockName {
57975 responder: StreamSocketGetSockNameResponder,
57976 },
57977 GetPeerName {
57979 responder: StreamSocketGetPeerNameResponder,
57980 },
57981 Shutdown {
57983 mode: ShutdownMode,
57984 responder: StreamSocketShutdownResponder,
57985 },
57986 SetIpTypeOfService {
57988 value: u8,
57989 responder: StreamSocketSetIpTypeOfServiceResponder,
57990 },
57991 GetIpTypeOfService {
57993 responder: StreamSocketGetIpTypeOfServiceResponder,
57994 },
57995 SetIpTtl {
57997 value: OptionalUint8,
57998 responder: StreamSocketSetIpTtlResponder,
57999 },
58000 GetIpTtl {
58002 responder: StreamSocketGetIpTtlResponder,
58003 },
58004 SetIpPacketInfo {
58006 value: bool,
58007 responder: StreamSocketSetIpPacketInfoResponder,
58008 },
58009 GetIpPacketInfo {
58011 responder: StreamSocketGetIpPacketInfoResponder,
58012 },
58013 SetIpReceiveTypeOfService {
58015 value: bool,
58016 responder: StreamSocketSetIpReceiveTypeOfServiceResponder,
58017 },
58018 GetIpReceiveTypeOfService {
58020 responder: StreamSocketGetIpReceiveTypeOfServiceResponder,
58021 },
58022 SetIpReceiveTtl {
58024 value: bool,
58025 responder: StreamSocketSetIpReceiveTtlResponder,
58026 },
58027 GetIpReceiveTtl {
58029 responder: StreamSocketGetIpReceiveTtlResponder,
58030 },
58031 SetIpMulticastInterface {
58033 iface: u64,
58034 address: fidl_fuchsia_net::Ipv4Address,
58035 responder: StreamSocketSetIpMulticastInterfaceResponder,
58036 },
58037 GetIpMulticastInterface {
58039 responder: StreamSocketGetIpMulticastInterfaceResponder,
58040 },
58041 SetIpMulticastTtl {
58043 value: OptionalUint8,
58044 responder: StreamSocketSetIpMulticastTtlResponder,
58045 },
58046 GetIpMulticastTtl {
58048 responder: StreamSocketGetIpMulticastTtlResponder,
58049 },
58050 SetIpMulticastLoopback {
58052 value: bool,
58053 responder: StreamSocketSetIpMulticastLoopbackResponder,
58054 },
58055 GetIpMulticastLoopback {
58057 responder: StreamSocketGetIpMulticastLoopbackResponder,
58058 },
58059 AddIpMembership {
58061 membership: IpMulticastMembership,
58062 responder: StreamSocketAddIpMembershipResponder,
58063 },
58064 DropIpMembership {
58066 membership: IpMulticastMembership,
58067 responder: StreamSocketDropIpMembershipResponder,
58068 },
58069 SetIpTransparent {
58071 value: bool,
58072 responder: StreamSocketSetIpTransparentResponder,
58073 },
58074 GetIpTransparent {
58076 responder: StreamSocketGetIpTransparentResponder,
58077 },
58078 SetIpReceiveOriginalDestinationAddress {
58080 value: bool,
58081 responder: StreamSocketSetIpReceiveOriginalDestinationAddressResponder,
58082 },
58083 GetIpReceiveOriginalDestinationAddress {
58085 responder: StreamSocketGetIpReceiveOriginalDestinationAddressResponder,
58086 },
58087 AddIpv6Membership {
58089 membership: Ipv6MulticastMembership,
58090 responder: StreamSocketAddIpv6MembershipResponder,
58091 },
58092 DropIpv6Membership {
58094 membership: Ipv6MulticastMembership,
58095 responder: StreamSocketDropIpv6MembershipResponder,
58096 },
58097 SetIpv6MulticastInterface {
58099 value: u64,
58100 responder: StreamSocketSetIpv6MulticastInterfaceResponder,
58101 },
58102 GetIpv6MulticastInterface {
58104 responder: StreamSocketGetIpv6MulticastInterfaceResponder,
58105 },
58106 SetIpv6UnicastHops {
58108 value: OptionalUint8,
58109 responder: StreamSocketSetIpv6UnicastHopsResponder,
58110 },
58111 GetIpv6UnicastHops {
58113 responder: StreamSocketGetIpv6UnicastHopsResponder,
58114 },
58115 SetIpv6ReceiveHopLimit {
58117 value: bool,
58118 responder: StreamSocketSetIpv6ReceiveHopLimitResponder,
58119 },
58120 GetIpv6ReceiveHopLimit {
58122 responder: StreamSocketGetIpv6ReceiveHopLimitResponder,
58123 },
58124 SetIpv6MulticastHops {
58126 value: OptionalUint8,
58127 responder: StreamSocketSetIpv6MulticastHopsResponder,
58128 },
58129 GetIpv6MulticastHops {
58131 responder: StreamSocketGetIpv6MulticastHopsResponder,
58132 },
58133 SetIpv6MulticastLoopback {
58135 value: bool,
58136 responder: StreamSocketSetIpv6MulticastLoopbackResponder,
58137 },
58138 GetIpv6MulticastLoopback {
58140 responder: StreamSocketGetIpv6MulticastLoopbackResponder,
58141 },
58142 SetIpv6Only {
58144 value: bool,
58145 responder: StreamSocketSetIpv6OnlyResponder,
58146 },
58147 GetIpv6Only {
58149 responder: StreamSocketGetIpv6OnlyResponder,
58150 },
58151 SetIpv6ReceiveTrafficClass {
58153 value: bool,
58154 responder: StreamSocketSetIpv6ReceiveTrafficClassResponder,
58155 },
58156 GetIpv6ReceiveTrafficClass {
58158 responder: StreamSocketGetIpv6ReceiveTrafficClassResponder,
58159 },
58160 SetIpv6TrafficClass {
58162 value: OptionalUint8,
58163 responder: StreamSocketSetIpv6TrafficClassResponder,
58164 },
58165 GetIpv6TrafficClass {
58167 responder: StreamSocketGetIpv6TrafficClassResponder,
58168 },
58169 SetIpv6ReceivePacketInfo {
58171 value: bool,
58172 responder: StreamSocketSetIpv6ReceivePacketInfoResponder,
58173 },
58174 GetIpv6ReceivePacketInfo {
58176 responder: StreamSocketGetIpv6ReceivePacketInfoResponder,
58177 },
58178 GetOriginalDestination {
58180 responder: StreamSocketGetOriginalDestinationResponder,
58181 },
58182 Describe {
58183 responder: StreamSocketDescribeResponder,
58184 },
58185 Listen {
58188 backlog: i16,
58189 responder: StreamSocketListenResponder,
58190 },
58191 Accept {
58193 want_addr: bool,
58194 responder: StreamSocketAcceptResponder,
58195 },
58196 GetInfo {
58198 responder: StreamSocketGetInfoResponder,
58199 },
58200 SetTcpNoDelay {
58202 value: bool,
58203 responder: StreamSocketSetTcpNoDelayResponder,
58204 },
58205 GetTcpNoDelay {
58207 responder: StreamSocketGetTcpNoDelayResponder,
58208 },
58209 SetTcpMaxSegment {
58211 value_bytes: u32,
58212 responder: StreamSocketSetTcpMaxSegmentResponder,
58213 },
58214 GetTcpMaxSegment {
58216 responder: StreamSocketGetTcpMaxSegmentResponder,
58217 },
58218 SetTcpCork {
58220 value: bool,
58221 responder: StreamSocketSetTcpCorkResponder,
58222 },
58223 GetTcpCork {
58225 responder: StreamSocketGetTcpCorkResponder,
58226 },
58227 SetTcpKeepAliveIdle {
58229 value_secs: u32,
58230 responder: StreamSocketSetTcpKeepAliveIdleResponder,
58231 },
58232 GetTcpKeepAliveIdle {
58234 responder: StreamSocketGetTcpKeepAliveIdleResponder,
58235 },
58236 SetTcpKeepAliveInterval {
58238 value_secs: u32,
58239 responder: StreamSocketSetTcpKeepAliveIntervalResponder,
58240 },
58241 GetTcpKeepAliveInterval {
58243 responder: StreamSocketGetTcpKeepAliveIntervalResponder,
58244 },
58245 SetTcpKeepAliveCount {
58247 value: u32,
58248 responder: StreamSocketSetTcpKeepAliveCountResponder,
58249 },
58250 GetTcpKeepAliveCount {
58252 responder: StreamSocketGetTcpKeepAliveCountResponder,
58253 },
58254 SetTcpSynCount {
58256 value: u32,
58257 responder: StreamSocketSetTcpSynCountResponder,
58258 },
58259 GetTcpSynCount {
58261 responder: StreamSocketGetTcpSynCountResponder,
58262 },
58263 SetTcpLinger {
58265 value_secs: OptionalUint32,
58266 responder: StreamSocketSetTcpLingerResponder,
58267 },
58268 GetTcpLinger {
58270 responder: StreamSocketGetTcpLingerResponder,
58271 },
58272 SetTcpDeferAccept {
58274 value_secs: u32,
58275 responder: StreamSocketSetTcpDeferAcceptResponder,
58276 },
58277 GetTcpDeferAccept {
58279 responder: StreamSocketGetTcpDeferAcceptResponder,
58280 },
58281 SetTcpWindowClamp {
58283 value: u32,
58284 responder: StreamSocketSetTcpWindowClampResponder,
58285 },
58286 GetTcpWindowClamp {
58288 responder: StreamSocketGetTcpWindowClampResponder,
58289 },
58290 GetTcpInfo {
58292 responder: StreamSocketGetTcpInfoResponder,
58293 },
58294 SetTcpQuickAck {
58296 value: bool,
58297 responder: StreamSocketSetTcpQuickAckResponder,
58298 },
58299 GetTcpQuickAck {
58301 responder: StreamSocketGetTcpQuickAckResponder,
58302 },
58303 SetTcpCongestion {
58305 value: TcpCongestionControl,
58306 responder: StreamSocketSetTcpCongestionResponder,
58307 },
58308 GetTcpCongestion {
58310 responder: StreamSocketGetTcpCongestionResponder,
58311 },
58312 SetTcpUserTimeout {
58314 value_millis: u32,
58315 responder: StreamSocketSetTcpUserTimeoutResponder,
58316 },
58317 GetTcpUserTimeout {
58319 responder: StreamSocketGetTcpUserTimeoutResponder,
58320 },
58321}
58322
58323impl StreamSocketRequest {
58324 #[allow(irrefutable_let_patterns)]
58325 pub fn into_clone(
58326 self,
58327 ) -> Option<(
58328 fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
58329 StreamSocketControlHandle,
58330 )> {
58331 if let StreamSocketRequest::Clone { request, control_handle } = self {
58332 Some((request, control_handle))
58333 } else {
58334 None
58335 }
58336 }
58337
58338 #[allow(irrefutable_let_patterns)]
58339 pub fn into_close(self) -> Option<(StreamSocketCloseResponder)> {
58340 if let StreamSocketRequest::Close { responder } = self {
58341 Some((responder))
58342 } else {
58343 None
58344 }
58345 }
58346
58347 #[allow(irrefutable_let_patterns)]
58348 pub fn into_query(self) -> Option<(StreamSocketQueryResponder)> {
58349 if let StreamSocketRequest::Query { responder } = self {
58350 Some((responder))
58351 } else {
58352 None
58353 }
58354 }
58355
58356 #[allow(irrefutable_let_patterns)]
58357 pub fn into_set_reuse_address(self) -> Option<(bool, StreamSocketSetReuseAddressResponder)> {
58358 if let StreamSocketRequest::SetReuseAddress { value, responder } = self {
58359 Some((value, responder))
58360 } else {
58361 None
58362 }
58363 }
58364
58365 #[allow(irrefutable_let_patterns)]
58366 pub fn into_get_reuse_address(self) -> Option<(StreamSocketGetReuseAddressResponder)> {
58367 if let StreamSocketRequest::GetReuseAddress { responder } = self {
58368 Some((responder))
58369 } else {
58370 None
58371 }
58372 }
58373
58374 #[allow(irrefutable_let_patterns)]
58375 pub fn into_get_error(self) -> Option<(StreamSocketGetErrorResponder)> {
58376 if let StreamSocketRequest::GetError { responder } = self {
58377 Some((responder))
58378 } else {
58379 None
58380 }
58381 }
58382
58383 #[allow(irrefutable_let_patterns)]
58384 pub fn into_set_broadcast(self) -> Option<(bool, StreamSocketSetBroadcastResponder)> {
58385 if let StreamSocketRequest::SetBroadcast { value, responder } = self {
58386 Some((value, responder))
58387 } else {
58388 None
58389 }
58390 }
58391
58392 #[allow(irrefutable_let_patterns)]
58393 pub fn into_get_broadcast(self) -> Option<(StreamSocketGetBroadcastResponder)> {
58394 if let StreamSocketRequest::GetBroadcast { responder } = self {
58395 Some((responder))
58396 } else {
58397 None
58398 }
58399 }
58400
58401 #[allow(irrefutable_let_patterns)]
58402 pub fn into_set_send_buffer(self) -> Option<(u64, StreamSocketSetSendBufferResponder)> {
58403 if let StreamSocketRequest::SetSendBuffer { value_bytes, responder } = self {
58404 Some((value_bytes, responder))
58405 } else {
58406 None
58407 }
58408 }
58409
58410 #[allow(irrefutable_let_patterns)]
58411 pub fn into_get_send_buffer(self) -> Option<(StreamSocketGetSendBufferResponder)> {
58412 if let StreamSocketRequest::GetSendBuffer { responder } = self {
58413 Some((responder))
58414 } else {
58415 None
58416 }
58417 }
58418
58419 #[allow(irrefutable_let_patterns)]
58420 pub fn into_set_receive_buffer(self) -> Option<(u64, StreamSocketSetReceiveBufferResponder)> {
58421 if let StreamSocketRequest::SetReceiveBuffer { value_bytes, responder } = self {
58422 Some((value_bytes, responder))
58423 } else {
58424 None
58425 }
58426 }
58427
58428 #[allow(irrefutable_let_patterns)]
58429 pub fn into_get_receive_buffer(self) -> Option<(StreamSocketGetReceiveBufferResponder)> {
58430 if let StreamSocketRequest::GetReceiveBuffer { responder } = self {
58431 Some((responder))
58432 } else {
58433 None
58434 }
58435 }
58436
58437 #[allow(irrefutable_let_patterns)]
58438 pub fn into_set_keep_alive(self) -> Option<(bool, StreamSocketSetKeepAliveResponder)> {
58439 if let StreamSocketRequest::SetKeepAlive { value, responder } = self {
58440 Some((value, responder))
58441 } else {
58442 None
58443 }
58444 }
58445
58446 #[allow(irrefutable_let_patterns)]
58447 pub fn into_get_keep_alive(self) -> Option<(StreamSocketGetKeepAliveResponder)> {
58448 if let StreamSocketRequest::GetKeepAlive { responder } = self {
58449 Some((responder))
58450 } else {
58451 None
58452 }
58453 }
58454
58455 #[allow(irrefutable_let_patterns)]
58456 pub fn into_set_out_of_band_inline(
58457 self,
58458 ) -> Option<(bool, StreamSocketSetOutOfBandInlineResponder)> {
58459 if let StreamSocketRequest::SetOutOfBandInline { value, responder } = self {
58460 Some((value, responder))
58461 } else {
58462 None
58463 }
58464 }
58465
58466 #[allow(irrefutable_let_patterns)]
58467 pub fn into_get_out_of_band_inline(self) -> Option<(StreamSocketGetOutOfBandInlineResponder)> {
58468 if let StreamSocketRequest::GetOutOfBandInline { responder } = self {
58469 Some((responder))
58470 } else {
58471 None
58472 }
58473 }
58474
58475 #[allow(irrefutable_let_patterns)]
58476 pub fn into_set_no_check(self) -> Option<(bool, StreamSocketSetNoCheckResponder)> {
58477 if let StreamSocketRequest::SetNoCheck { value, responder } = self {
58478 Some((value, responder))
58479 } else {
58480 None
58481 }
58482 }
58483
58484 #[allow(irrefutable_let_patterns)]
58485 pub fn into_get_no_check(self) -> Option<(StreamSocketGetNoCheckResponder)> {
58486 if let StreamSocketRequest::GetNoCheck { responder } = self {
58487 Some((responder))
58488 } else {
58489 None
58490 }
58491 }
58492
58493 #[allow(irrefutable_let_patterns)]
58494 pub fn into_set_linger(self) -> Option<(bool, u32, StreamSocketSetLingerResponder)> {
58495 if let StreamSocketRequest::SetLinger { linger, length_secs, responder } = self {
58496 Some((linger, length_secs, responder))
58497 } else {
58498 None
58499 }
58500 }
58501
58502 #[allow(irrefutable_let_patterns)]
58503 pub fn into_get_linger(self) -> Option<(StreamSocketGetLingerResponder)> {
58504 if let StreamSocketRequest::GetLinger { responder } = self {
58505 Some((responder))
58506 } else {
58507 None
58508 }
58509 }
58510
58511 #[allow(irrefutable_let_patterns)]
58512 pub fn into_set_reuse_port(self) -> Option<(bool, StreamSocketSetReusePortResponder)> {
58513 if let StreamSocketRequest::SetReusePort { value, responder } = self {
58514 Some((value, responder))
58515 } else {
58516 None
58517 }
58518 }
58519
58520 #[allow(irrefutable_let_patterns)]
58521 pub fn into_get_reuse_port(self) -> Option<(StreamSocketGetReusePortResponder)> {
58522 if let StreamSocketRequest::GetReusePort { responder } = self {
58523 Some((responder))
58524 } else {
58525 None
58526 }
58527 }
58528
58529 #[allow(irrefutable_let_patterns)]
58530 pub fn into_get_accept_conn(self) -> Option<(StreamSocketGetAcceptConnResponder)> {
58531 if let StreamSocketRequest::GetAcceptConn { responder } = self {
58532 Some((responder))
58533 } else {
58534 None
58535 }
58536 }
58537
58538 #[allow(irrefutable_let_patterns)]
58539 pub fn into_set_bind_to_device(self) -> Option<(String, StreamSocketSetBindToDeviceResponder)> {
58540 if let StreamSocketRequest::SetBindToDevice { value, responder } = self {
58541 Some((value, responder))
58542 } else {
58543 None
58544 }
58545 }
58546
58547 #[allow(irrefutable_let_patterns)]
58548 pub fn into_get_bind_to_device(self) -> Option<(StreamSocketGetBindToDeviceResponder)> {
58549 if let StreamSocketRequest::GetBindToDevice { responder } = self {
58550 Some((responder))
58551 } else {
58552 None
58553 }
58554 }
58555
58556 #[allow(irrefutable_let_patterns)]
58557 pub fn into_set_bind_to_interface_index(
58558 self,
58559 ) -> Option<(u64, StreamSocketSetBindToInterfaceIndexResponder)> {
58560 if let StreamSocketRequest::SetBindToInterfaceIndex { value, responder } = self {
58561 Some((value, responder))
58562 } else {
58563 None
58564 }
58565 }
58566
58567 #[allow(irrefutable_let_patterns)]
58568 pub fn into_get_bind_to_interface_index(
58569 self,
58570 ) -> Option<(StreamSocketGetBindToInterfaceIndexResponder)> {
58571 if let StreamSocketRequest::GetBindToInterfaceIndex { responder } = self {
58572 Some((responder))
58573 } else {
58574 None
58575 }
58576 }
58577
58578 #[allow(irrefutable_let_patterns)]
58579 pub fn into_set_timestamp(
58580 self,
58581 ) -> Option<(TimestampOption, StreamSocketSetTimestampResponder)> {
58582 if let StreamSocketRequest::SetTimestamp { value, responder } = self {
58583 Some((value, responder))
58584 } else {
58585 None
58586 }
58587 }
58588
58589 #[allow(irrefutable_let_patterns)]
58590 pub fn into_get_timestamp(self) -> Option<(StreamSocketGetTimestampResponder)> {
58591 if let StreamSocketRequest::GetTimestamp { responder } = self {
58592 Some((responder))
58593 } else {
58594 None
58595 }
58596 }
58597
58598 #[allow(irrefutable_let_patterns)]
58599 pub fn into_set_mark(
58600 self,
58601 ) -> Option<(fidl_fuchsia_net::MarkDomain, OptionalUint32, StreamSocketSetMarkResponder)> {
58602 if let StreamSocketRequest::SetMark { domain, mark, responder } = self {
58603 Some((domain, mark, responder))
58604 } else {
58605 None
58606 }
58607 }
58608
58609 #[allow(irrefutable_let_patterns)]
58610 pub fn into_get_mark(
58611 self,
58612 ) -> Option<(fidl_fuchsia_net::MarkDomain, StreamSocketGetMarkResponder)> {
58613 if let StreamSocketRequest::GetMark { domain, responder } = self {
58614 Some((domain, responder))
58615 } else {
58616 None
58617 }
58618 }
58619
58620 #[allow(irrefutable_let_patterns)]
58621 pub fn into_bind(self) -> Option<(fidl_fuchsia_net::SocketAddress, StreamSocketBindResponder)> {
58622 if let StreamSocketRequest::Bind { addr, responder } = self {
58623 Some((addr, responder))
58624 } else {
58625 None
58626 }
58627 }
58628
58629 #[allow(irrefutable_let_patterns)]
58630 pub fn into_connect(
58631 self,
58632 ) -> Option<(fidl_fuchsia_net::SocketAddress, StreamSocketConnectResponder)> {
58633 if let StreamSocketRequest::Connect { addr, responder } = self {
58634 Some((addr, responder))
58635 } else {
58636 None
58637 }
58638 }
58639
58640 #[allow(irrefutable_let_patterns)]
58641 pub fn into_disconnect(self) -> Option<(StreamSocketDisconnectResponder)> {
58642 if let StreamSocketRequest::Disconnect { responder } = self {
58643 Some((responder))
58644 } else {
58645 None
58646 }
58647 }
58648
58649 #[allow(irrefutable_let_patterns)]
58650 pub fn into_get_sock_name(self) -> Option<(StreamSocketGetSockNameResponder)> {
58651 if let StreamSocketRequest::GetSockName { responder } = self {
58652 Some((responder))
58653 } else {
58654 None
58655 }
58656 }
58657
58658 #[allow(irrefutable_let_patterns)]
58659 pub fn into_get_peer_name(self) -> Option<(StreamSocketGetPeerNameResponder)> {
58660 if let StreamSocketRequest::GetPeerName { responder } = self {
58661 Some((responder))
58662 } else {
58663 None
58664 }
58665 }
58666
58667 #[allow(irrefutable_let_patterns)]
58668 pub fn into_shutdown(self) -> Option<(ShutdownMode, StreamSocketShutdownResponder)> {
58669 if let StreamSocketRequest::Shutdown { mode, responder } = self {
58670 Some((mode, responder))
58671 } else {
58672 None
58673 }
58674 }
58675
58676 #[allow(irrefutable_let_patterns)]
58677 pub fn into_set_ip_type_of_service(
58678 self,
58679 ) -> Option<(u8, StreamSocketSetIpTypeOfServiceResponder)> {
58680 if let StreamSocketRequest::SetIpTypeOfService { value, responder } = self {
58681 Some((value, responder))
58682 } else {
58683 None
58684 }
58685 }
58686
58687 #[allow(irrefutable_let_patterns)]
58688 pub fn into_get_ip_type_of_service(self) -> Option<(StreamSocketGetIpTypeOfServiceResponder)> {
58689 if let StreamSocketRequest::GetIpTypeOfService { responder } = self {
58690 Some((responder))
58691 } else {
58692 None
58693 }
58694 }
58695
58696 #[allow(irrefutable_let_patterns)]
58697 pub fn into_set_ip_ttl(self) -> Option<(OptionalUint8, StreamSocketSetIpTtlResponder)> {
58698 if let StreamSocketRequest::SetIpTtl { value, responder } = self {
58699 Some((value, responder))
58700 } else {
58701 None
58702 }
58703 }
58704
58705 #[allow(irrefutable_let_patterns)]
58706 pub fn into_get_ip_ttl(self) -> Option<(StreamSocketGetIpTtlResponder)> {
58707 if let StreamSocketRequest::GetIpTtl { responder } = self {
58708 Some((responder))
58709 } else {
58710 None
58711 }
58712 }
58713
58714 #[allow(irrefutable_let_patterns)]
58715 pub fn into_set_ip_packet_info(self) -> Option<(bool, StreamSocketSetIpPacketInfoResponder)> {
58716 if let StreamSocketRequest::SetIpPacketInfo { value, responder } = self {
58717 Some((value, responder))
58718 } else {
58719 None
58720 }
58721 }
58722
58723 #[allow(irrefutable_let_patterns)]
58724 pub fn into_get_ip_packet_info(self) -> Option<(StreamSocketGetIpPacketInfoResponder)> {
58725 if let StreamSocketRequest::GetIpPacketInfo { responder } = self {
58726 Some((responder))
58727 } else {
58728 None
58729 }
58730 }
58731
58732 #[allow(irrefutable_let_patterns)]
58733 pub fn into_set_ip_receive_type_of_service(
58734 self,
58735 ) -> Option<(bool, StreamSocketSetIpReceiveTypeOfServiceResponder)> {
58736 if let StreamSocketRequest::SetIpReceiveTypeOfService { value, responder } = self {
58737 Some((value, responder))
58738 } else {
58739 None
58740 }
58741 }
58742
58743 #[allow(irrefutable_let_patterns)]
58744 pub fn into_get_ip_receive_type_of_service(
58745 self,
58746 ) -> Option<(StreamSocketGetIpReceiveTypeOfServiceResponder)> {
58747 if let StreamSocketRequest::GetIpReceiveTypeOfService { responder } = self {
58748 Some((responder))
58749 } else {
58750 None
58751 }
58752 }
58753
58754 #[allow(irrefutable_let_patterns)]
58755 pub fn into_set_ip_receive_ttl(self) -> Option<(bool, StreamSocketSetIpReceiveTtlResponder)> {
58756 if let StreamSocketRequest::SetIpReceiveTtl { value, responder } = self {
58757 Some((value, responder))
58758 } else {
58759 None
58760 }
58761 }
58762
58763 #[allow(irrefutable_let_patterns)]
58764 pub fn into_get_ip_receive_ttl(self) -> Option<(StreamSocketGetIpReceiveTtlResponder)> {
58765 if let StreamSocketRequest::GetIpReceiveTtl { responder } = self {
58766 Some((responder))
58767 } else {
58768 None
58769 }
58770 }
58771
58772 #[allow(irrefutable_let_patterns)]
58773 pub fn into_set_ip_multicast_interface(
58774 self,
58775 ) -> Option<(u64, fidl_fuchsia_net::Ipv4Address, StreamSocketSetIpMulticastInterfaceResponder)>
58776 {
58777 if let StreamSocketRequest::SetIpMulticastInterface { iface, address, responder } = self {
58778 Some((iface, address, responder))
58779 } else {
58780 None
58781 }
58782 }
58783
58784 #[allow(irrefutable_let_patterns)]
58785 pub fn into_get_ip_multicast_interface(
58786 self,
58787 ) -> Option<(StreamSocketGetIpMulticastInterfaceResponder)> {
58788 if let StreamSocketRequest::GetIpMulticastInterface { responder } = self {
58789 Some((responder))
58790 } else {
58791 None
58792 }
58793 }
58794
58795 #[allow(irrefutable_let_patterns)]
58796 pub fn into_set_ip_multicast_ttl(
58797 self,
58798 ) -> Option<(OptionalUint8, StreamSocketSetIpMulticastTtlResponder)> {
58799 if let StreamSocketRequest::SetIpMulticastTtl { value, responder } = self {
58800 Some((value, responder))
58801 } else {
58802 None
58803 }
58804 }
58805
58806 #[allow(irrefutable_let_patterns)]
58807 pub fn into_get_ip_multicast_ttl(self) -> Option<(StreamSocketGetIpMulticastTtlResponder)> {
58808 if let StreamSocketRequest::GetIpMulticastTtl { responder } = self {
58809 Some((responder))
58810 } else {
58811 None
58812 }
58813 }
58814
58815 #[allow(irrefutable_let_patterns)]
58816 pub fn into_set_ip_multicast_loopback(
58817 self,
58818 ) -> Option<(bool, StreamSocketSetIpMulticastLoopbackResponder)> {
58819 if let StreamSocketRequest::SetIpMulticastLoopback { value, responder } = self {
58820 Some((value, responder))
58821 } else {
58822 None
58823 }
58824 }
58825
58826 #[allow(irrefutable_let_patterns)]
58827 pub fn into_get_ip_multicast_loopback(
58828 self,
58829 ) -> Option<(StreamSocketGetIpMulticastLoopbackResponder)> {
58830 if let StreamSocketRequest::GetIpMulticastLoopback { responder } = self {
58831 Some((responder))
58832 } else {
58833 None
58834 }
58835 }
58836
58837 #[allow(irrefutable_let_patterns)]
58838 pub fn into_add_ip_membership(
58839 self,
58840 ) -> Option<(IpMulticastMembership, StreamSocketAddIpMembershipResponder)> {
58841 if let StreamSocketRequest::AddIpMembership { membership, responder } = self {
58842 Some((membership, responder))
58843 } else {
58844 None
58845 }
58846 }
58847
58848 #[allow(irrefutable_let_patterns)]
58849 pub fn into_drop_ip_membership(
58850 self,
58851 ) -> Option<(IpMulticastMembership, StreamSocketDropIpMembershipResponder)> {
58852 if let StreamSocketRequest::DropIpMembership { membership, responder } = self {
58853 Some((membership, responder))
58854 } else {
58855 None
58856 }
58857 }
58858
58859 #[allow(irrefutable_let_patterns)]
58860 pub fn into_set_ip_transparent(self) -> Option<(bool, StreamSocketSetIpTransparentResponder)> {
58861 if let StreamSocketRequest::SetIpTransparent { value, responder } = self {
58862 Some((value, responder))
58863 } else {
58864 None
58865 }
58866 }
58867
58868 #[allow(irrefutable_let_patterns)]
58869 pub fn into_get_ip_transparent(self) -> Option<(StreamSocketGetIpTransparentResponder)> {
58870 if let StreamSocketRequest::GetIpTransparent { responder } = self {
58871 Some((responder))
58872 } else {
58873 None
58874 }
58875 }
58876
58877 #[allow(irrefutable_let_patterns)]
58878 pub fn into_set_ip_receive_original_destination_address(
58879 self,
58880 ) -> Option<(bool, StreamSocketSetIpReceiveOriginalDestinationAddressResponder)> {
58881 if let StreamSocketRequest::SetIpReceiveOriginalDestinationAddress { value, responder } =
58882 self
58883 {
58884 Some((value, responder))
58885 } else {
58886 None
58887 }
58888 }
58889
58890 #[allow(irrefutable_let_patterns)]
58891 pub fn into_get_ip_receive_original_destination_address(
58892 self,
58893 ) -> Option<(StreamSocketGetIpReceiveOriginalDestinationAddressResponder)> {
58894 if let StreamSocketRequest::GetIpReceiveOriginalDestinationAddress { responder } = self {
58895 Some((responder))
58896 } else {
58897 None
58898 }
58899 }
58900
58901 #[allow(irrefutable_let_patterns)]
58902 pub fn into_add_ipv6_membership(
58903 self,
58904 ) -> Option<(Ipv6MulticastMembership, StreamSocketAddIpv6MembershipResponder)> {
58905 if let StreamSocketRequest::AddIpv6Membership { membership, responder } = self {
58906 Some((membership, responder))
58907 } else {
58908 None
58909 }
58910 }
58911
58912 #[allow(irrefutable_let_patterns)]
58913 pub fn into_drop_ipv6_membership(
58914 self,
58915 ) -> Option<(Ipv6MulticastMembership, StreamSocketDropIpv6MembershipResponder)> {
58916 if let StreamSocketRequest::DropIpv6Membership { membership, responder } = self {
58917 Some((membership, responder))
58918 } else {
58919 None
58920 }
58921 }
58922
58923 #[allow(irrefutable_let_patterns)]
58924 pub fn into_set_ipv6_multicast_interface(
58925 self,
58926 ) -> Option<(u64, StreamSocketSetIpv6MulticastInterfaceResponder)> {
58927 if let StreamSocketRequest::SetIpv6MulticastInterface { value, responder } = self {
58928 Some((value, responder))
58929 } else {
58930 None
58931 }
58932 }
58933
58934 #[allow(irrefutable_let_patterns)]
58935 pub fn into_get_ipv6_multicast_interface(
58936 self,
58937 ) -> Option<(StreamSocketGetIpv6MulticastInterfaceResponder)> {
58938 if let StreamSocketRequest::GetIpv6MulticastInterface { responder } = self {
58939 Some((responder))
58940 } else {
58941 None
58942 }
58943 }
58944
58945 #[allow(irrefutable_let_patterns)]
58946 pub fn into_set_ipv6_unicast_hops(
58947 self,
58948 ) -> Option<(OptionalUint8, StreamSocketSetIpv6UnicastHopsResponder)> {
58949 if let StreamSocketRequest::SetIpv6UnicastHops { value, responder } = self {
58950 Some((value, responder))
58951 } else {
58952 None
58953 }
58954 }
58955
58956 #[allow(irrefutable_let_patterns)]
58957 pub fn into_get_ipv6_unicast_hops(self) -> Option<(StreamSocketGetIpv6UnicastHopsResponder)> {
58958 if let StreamSocketRequest::GetIpv6UnicastHops { responder } = self {
58959 Some((responder))
58960 } else {
58961 None
58962 }
58963 }
58964
58965 #[allow(irrefutable_let_patterns)]
58966 pub fn into_set_ipv6_receive_hop_limit(
58967 self,
58968 ) -> Option<(bool, StreamSocketSetIpv6ReceiveHopLimitResponder)> {
58969 if let StreamSocketRequest::SetIpv6ReceiveHopLimit { value, responder } = self {
58970 Some((value, responder))
58971 } else {
58972 None
58973 }
58974 }
58975
58976 #[allow(irrefutable_let_patterns)]
58977 pub fn into_get_ipv6_receive_hop_limit(
58978 self,
58979 ) -> Option<(StreamSocketGetIpv6ReceiveHopLimitResponder)> {
58980 if let StreamSocketRequest::GetIpv6ReceiveHopLimit { responder } = self {
58981 Some((responder))
58982 } else {
58983 None
58984 }
58985 }
58986
58987 #[allow(irrefutable_let_patterns)]
58988 pub fn into_set_ipv6_multicast_hops(
58989 self,
58990 ) -> Option<(OptionalUint8, StreamSocketSetIpv6MulticastHopsResponder)> {
58991 if let StreamSocketRequest::SetIpv6MulticastHops { value, responder } = self {
58992 Some((value, responder))
58993 } else {
58994 None
58995 }
58996 }
58997
58998 #[allow(irrefutable_let_patterns)]
58999 pub fn into_get_ipv6_multicast_hops(
59000 self,
59001 ) -> Option<(StreamSocketGetIpv6MulticastHopsResponder)> {
59002 if let StreamSocketRequest::GetIpv6MulticastHops { responder } = self {
59003 Some((responder))
59004 } else {
59005 None
59006 }
59007 }
59008
59009 #[allow(irrefutable_let_patterns)]
59010 pub fn into_set_ipv6_multicast_loopback(
59011 self,
59012 ) -> Option<(bool, StreamSocketSetIpv6MulticastLoopbackResponder)> {
59013 if let StreamSocketRequest::SetIpv6MulticastLoopback { value, responder } = self {
59014 Some((value, responder))
59015 } else {
59016 None
59017 }
59018 }
59019
59020 #[allow(irrefutable_let_patterns)]
59021 pub fn into_get_ipv6_multicast_loopback(
59022 self,
59023 ) -> Option<(StreamSocketGetIpv6MulticastLoopbackResponder)> {
59024 if let StreamSocketRequest::GetIpv6MulticastLoopback { responder } = self {
59025 Some((responder))
59026 } else {
59027 None
59028 }
59029 }
59030
59031 #[allow(irrefutable_let_patterns)]
59032 pub fn into_set_ipv6_only(self) -> Option<(bool, StreamSocketSetIpv6OnlyResponder)> {
59033 if let StreamSocketRequest::SetIpv6Only { value, responder } = self {
59034 Some((value, responder))
59035 } else {
59036 None
59037 }
59038 }
59039
59040 #[allow(irrefutable_let_patterns)]
59041 pub fn into_get_ipv6_only(self) -> Option<(StreamSocketGetIpv6OnlyResponder)> {
59042 if let StreamSocketRequest::GetIpv6Only { responder } = self {
59043 Some((responder))
59044 } else {
59045 None
59046 }
59047 }
59048
59049 #[allow(irrefutable_let_patterns)]
59050 pub fn into_set_ipv6_receive_traffic_class(
59051 self,
59052 ) -> Option<(bool, StreamSocketSetIpv6ReceiveTrafficClassResponder)> {
59053 if let StreamSocketRequest::SetIpv6ReceiveTrafficClass { value, responder } = self {
59054 Some((value, responder))
59055 } else {
59056 None
59057 }
59058 }
59059
59060 #[allow(irrefutable_let_patterns)]
59061 pub fn into_get_ipv6_receive_traffic_class(
59062 self,
59063 ) -> Option<(StreamSocketGetIpv6ReceiveTrafficClassResponder)> {
59064 if let StreamSocketRequest::GetIpv6ReceiveTrafficClass { responder } = self {
59065 Some((responder))
59066 } else {
59067 None
59068 }
59069 }
59070
59071 #[allow(irrefutable_let_patterns)]
59072 pub fn into_set_ipv6_traffic_class(
59073 self,
59074 ) -> Option<(OptionalUint8, StreamSocketSetIpv6TrafficClassResponder)> {
59075 if let StreamSocketRequest::SetIpv6TrafficClass { value, responder } = self {
59076 Some((value, responder))
59077 } else {
59078 None
59079 }
59080 }
59081
59082 #[allow(irrefutable_let_patterns)]
59083 pub fn into_get_ipv6_traffic_class(self) -> Option<(StreamSocketGetIpv6TrafficClassResponder)> {
59084 if let StreamSocketRequest::GetIpv6TrafficClass { responder } = self {
59085 Some((responder))
59086 } else {
59087 None
59088 }
59089 }
59090
59091 #[allow(irrefutable_let_patterns)]
59092 pub fn into_set_ipv6_receive_packet_info(
59093 self,
59094 ) -> Option<(bool, StreamSocketSetIpv6ReceivePacketInfoResponder)> {
59095 if let StreamSocketRequest::SetIpv6ReceivePacketInfo { value, responder } = self {
59096 Some((value, responder))
59097 } else {
59098 None
59099 }
59100 }
59101
59102 #[allow(irrefutable_let_patterns)]
59103 pub fn into_get_ipv6_receive_packet_info(
59104 self,
59105 ) -> Option<(StreamSocketGetIpv6ReceivePacketInfoResponder)> {
59106 if let StreamSocketRequest::GetIpv6ReceivePacketInfo { responder } = self {
59107 Some((responder))
59108 } else {
59109 None
59110 }
59111 }
59112
59113 #[allow(irrefutable_let_patterns)]
59114 pub fn into_get_original_destination(
59115 self,
59116 ) -> Option<(StreamSocketGetOriginalDestinationResponder)> {
59117 if let StreamSocketRequest::GetOriginalDestination { responder } = self {
59118 Some((responder))
59119 } else {
59120 None
59121 }
59122 }
59123
59124 #[allow(irrefutable_let_patterns)]
59125 pub fn into_describe(self) -> Option<(StreamSocketDescribeResponder)> {
59126 if let StreamSocketRequest::Describe { responder } = self {
59127 Some((responder))
59128 } else {
59129 None
59130 }
59131 }
59132
59133 #[allow(irrefutable_let_patterns)]
59134 pub fn into_listen(self) -> Option<(i16, StreamSocketListenResponder)> {
59135 if let StreamSocketRequest::Listen { backlog, responder } = self {
59136 Some((backlog, responder))
59137 } else {
59138 None
59139 }
59140 }
59141
59142 #[allow(irrefutable_let_patterns)]
59143 pub fn into_accept(self) -> Option<(bool, StreamSocketAcceptResponder)> {
59144 if let StreamSocketRequest::Accept { want_addr, responder } = self {
59145 Some((want_addr, responder))
59146 } else {
59147 None
59148 }
59149 }
59150
59151 #[allow(irrefutable_let_patterns)]
59152 pub fn into_get_info(self) -> Option<(StreamSocketGetInfoResponder)> {
59153 if let StreamSocketRequest::GetInfo { responder } = self {
59154 Some((responder))
59155 } else {
59156 None
59157 }
59158 }
59159
59160 #[allow(irrefutable_let_patterns)]
59161 pub fn into_set_tcp_no_delay(self) -> Option<(bool, StreamSocketSetTcpNoDelayResponder)> {
59162 if let StreamSocketRequest::SetTcpNoDelay { value, responder } = self {
59163 Some((value, responder))
59164 } else {
59165 None
59166 }
59167 }
59168
59169 #[allow(irrefutable_let_patterns)]
59170 pub fn into_get_tcp_no_delay(self) -> Option<(StreamSocketGetTcpNoDelayResponder)> {
59171 if let StreamSocketRequest::GetTcpNoDelay { responder } = self {
59172 Some((responder))
59173 } else {
59174 None
59175 }
59176 }
59177
59178 #[allow(irrefutable_let_patterns)]
59179 pub fn into_set_tcp_max_segment(self) -> Option<(u32, StreamSocketSetTcpMaxSegmentResponder)> {
59180 if let StreamSocketRequest::SetTcpMaxSegment { value_bytes, responder } = self {
59181 Some((value_bytes, responder))
59182 } else {
59183 None
59184 }
59185 }
59186
59187 #[allow(irrefutable_let_patterns)]
59188 pub fn into_get_tcp_max_segment(self) -> Option<(StreamSocketGetTcpMaxSegmentResponder)> {
59189 if let StreamSocketRequest::GetTcpMaxSegment { responder } = self {
59190 Some((responder))
59191 } else {
59192 None
59193 }
59194 }
59195
59196 #[allow(irrefutable_let_patterns)]
59197 pub fn into_set_tcp_cork(self) -> Option<(bool, StreamSocketSetTcpCorkResponder)> {
59198 if let StreamSocketRequest::SetTcpCork { value, responder } = self {
59199 Some((value, responder))
59200 } else {
59201 None
59202 }
59203 }
59204
59205 #[allow(irrefutable_let_patterns)]
59206 pub fn into_get_tcp_cork(self) -> Option<(StreamSocketGetTcpCorkResponder)> {
59207 if let StreamSocketRequest::GetTcpCork { responder } = self {
59208 Some((responder))
59209 } else {
59210 None
59211 }
59212 }
59213
59214 #[allow(irrefutable_let_patterns)]
59215 pub fn into_set_tcp_keep_alive_idle(
59216 self,
59217 ) -> Option<(u32, StreamSocketSetTcpKeepAliveIdleResponder)> {
59218 if let StreamSocketRequest::SetTcpKeepAliveIdle { value_secs, responder } = self {
59219 Some((value_secs, responder))
59220 } else {
59221 None
59222 }
59223 }
59224
59225 #[allow(irrefutable_let_patterns)]
59226 pub fn into_get_tcp_keep_alive_idle(
59227 self,
59228 ) -> Option<(StreamSocketGetTcpKeepAliveIdleResponder)> {
59229 if let StreamSocketRequest::GetTcpKeepAliveIdle { responder } = self {
59230 Some((responder))
59231 } else {
59232 None
59233 }
59234 }
59235
59236 #[allow(irrefutable_let_patterns)]
59237 pub fn into_set_tcp_keep_alive_interval(
59238 self,
59239 ) -> Option<(u32, StreamSocketSetTcpKeepAliveIntervalResponder)> {
59240 if let StreamSocketRequest::SetTcpKeepAliveInterval { value_secs, responder } = self {
59241 Some((value_secs, responder))
59242 } else {
59243 None
59244 }
59245 }
59246
59247 #[allow(irrefutable_let_patterns)]
59248 pub fn into_get_tcp_keep_alive_interval(
59249 self,
59250 ) -> Option<(StreamSocketGetTcpKeepAliveIntervalResponder)> {
59251 if let StreamSocketRequest::GetTcpKeepAliveInterval { responder } = self {
59252 Some((responder))
59253 } else {
59254 None
59255 }
59256 }
59257
59258 #[allow(irrefutable_let_patterns)]
59259 pub fn into_set_tcp_keep_alive_count(
59260 self,
59261 ) -> Option<(u32, StreamSocketSetTcpKeepAliveCountResponder)> {
59262 if let StreamSocketRequest::SetTcpKeepAliveCount { value, responder } = self {
59263 Some((value, responder))
59264 } else {
59265 None
59266 }
59267 }
59268
59269 #[allow(irrefutable_let_patterns)]
59270 pub fn into_get_tcp_keep_alive_count(
59271 self,
59272 ) -> Option<(StreamSocketGetTcpKeepAliveCountResponder)> {
59273 if let StreamSocketRequest::GetTcpKeepAliveCount { responder } = self {
59274 Some((responder))
59275 } else {
59276 None
59277 }
59278 }
59279
59280 #[allow(irrefutable_let_patterns)]
59281 pub fn into_set_tcp_syn_count(self) -> Option<(u32, StreamSocketSetTcpSynCountResponder)> {
59282 if let StreamSocketRequest::SetTcpSynCount { value, responder } = self {
59283 Some((value, responder))
59284 } else {
59285 None
59286 }
59287 }
59288
59289 #[allow(irrefutable_let_patterns)]
59290 pub fn into_get_tcp_syn_count(self) -> Option<(StreamSocketGetTcpSynCountResponder)> {
59291 if let StreamSocketRequest::GetTcpSynCount { responder } = self {
59292 Some((responder))
59293 } else {
59294 None
59295 }
59296 }
59297
59298 #[allow(irrefutable_let_patterns)]
59299 pub fn into_set_tcp_linger(
59300 self,
59301 ) -> Option<(OptionalUint32, StreamSocketSetTcpLingerResponder)> {
59302 if let StreamSocketRequest::SetTcpLinger { value_secs, responder } = self {
59303 Some((value_secs, responder))
59304 } else {
59305 None
59306 }
59307 }
59308
59309 #[allow(irrefutable_let_patterns)]
59310 pub fn into_get_tcp_linger(self) -> Option<(StreamSocketGetTcpLingerResponder)> {
59311 if let StreamSocketRequest::GetTcpLinger { responder } = self {
59312 Some((responder))
59313 } else {
59314 None
59315 }
59316 }
59317
59318 #[allow(irrefutable_let_patterns)]
59319 pub fn into_set_tcp_defer_accept(
59320 self,
59321 ) -> Option<(u32, StreamSocketSetTcpDeferAcceptResponder)> {
59322 if let StreamSocketRequest::SetTcpDeferAccept { value_secs, responder } = self {
59323 Some((value_secs, responder))
59324 } else {
59325 None
59326 }
59327 }
59328
59329 #[allow(irrefutable_let_patterns)]
59330 pub fn into_get_tcp_defer_accept(self) -> Option<(StreamSocketGetTcpDeferAcceptResponder)> {
59331 if let StreamSocketRequest::GetTcpDeferAccept { responder } = self {
59332 Some((responder))
59333 } else {
59334 None
59335 }
59336 }
59337
59338 #[allow(irrefutable_let_patterns)]
59339 pub fn into_set_tcp_window_clamp(
59340 self,
59341 ) -> Option<(u32, StreamSocketSetTcpWindowClampResponder)> {
59342 if let StreamSocketRequest::SetTcpWindowClamp { value, responder } = self {
59343 Some((value, responder))
59344 } else {
59345 None
59346 }
59347 }
59348
59349 #[allow(irrefutable_let_patterns)]
59350 pub fn into_get_tcp_window_clamp(self) -> Option<(StreamSocketGetTcpWindowClampResponder)> {
59351 if let StreamSocketRequest::GetTcpWindowClamp { responder } = self {
59352 Some((responder))
59353 } else {
59354 None
59355 }
59356 }
59357
59358 #[allow(irrefutable_let_patterns)]
59359 pub fn into_get_tcp_info(self) -> Option<(StreamSocketGetTcpInfoResponder)> {
59360 if let StreamSocketRequest::GetTcpInfo { responder } = self {
59361 Some((responder))
59362 } else {
59363 None
59364 }
59365 }
59366
59367 #[allow(irrefutable_let_patterns)]
59368 pub fn into_set_tcp_quick_ack(self) -> Option<(bool, StreamSocketSetTcpQuickAckResponder)> {
59369 if let StreamSocketRequest::SetTcpQuickAck { value, responder } = self {
59370 Some((value, responder))
59371 } else {
59372 None
59373 }
59374 }
59375
59376 #[allow(irrefutable_let_patterns)]
59377 pub fn into_get_tcp_quick_ack(self) -> Option<(StreamSocketGetTcpQuickAckResponder)> {
59378 if let StreamSocketRequest::GetTcpQuickAck { responder } = self {
59379 Some((responder))
59380 } else {
59381 None
59382 }
59383 }
59384
59385 #[allow(irrefutable_let_patterns)]
59386 pub fn into_set_tcp_congestion(
59387 self,
59388 ) -> Option<(TcpCongestionControl, StreamSocketSetTcpCongestionResponder)> {
59389 if let StreamSocketRequest::SetTcpCongestion { value, responder } = self {
59390 Some((value, responder))
59391 } else {
59392 None
59393 }
59394 }
59395
59396 #[allow(irrefutable_let_patterns)]
59397 pub fn into_get_tcp_congestion(self) -> Option<(StreamSocketGetTcpCongestionResponder)> {
59398 if let StreamSocketRequest::GetTcpCongestion { responder } = self {
59399 Some((responder))
59400 } else {
59401 None
59402 }
59403 }
59404
59405 #[allow(irrefutable_let_patterns)]
59406 pub fn into_set_tcp_user_timeout(
59407 self,
59408 ) -> Option<(u32, StreamSocketSetTcpUserTimeoutResponder)> {
59409 if let StreamSocketRequest::SetTcpUserTimeout { value_millis, responder } = self {
59410 Some((value_millis, responder))
59411 } else {
59412 None
59413 }
59414 }
59415
59416 #[allow(irrefutable_let_patterns)]
59417 pub fn into_get_tcp_user_timeout(self) -> Option<(StreamSocketGetTcpUserTimeoutResponder)> {
59418 if let StreamSocketRequest::GetTcpUserTimeout { responder } = self {
59419 Some((responder))
59420 } else {
59421 None
59422 }
59423 }
59424
59425 pub fn method_name(&self) -> &'static str {
59427 match *self {
59428 StreamSocketRequest::Clone { .. } => "clone",
59429 StreamSocketRequest::Close { .. } => "close",
59430 StreamSocketRequest::Query { .. } => "query",
59431 StreamSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
59432 StreamSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
59433 StreamSocketRequest::GetError { .. } => "get_error",
59434 StreamSocketRequest::SetBroadcast { .. } => "set_broadcast",
59435 StreamSocketRequest::GetBroadcast { .. } => "get_broadcast",
59436 StreamSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
59437 StreamSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
59438 StreamSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
59439 StreamSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
59440 StreamSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
59441 StreamSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
59442 StreamSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
59443 StreamSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
59444 StreamSocketRequest::SetNoCheck { .. } => "set_no_check",
59445 StreamSocketRequest::GetNoCheck { .. } => "get_no_check",
59446 StreamSocketRequest::SetLinger { .. } => "set_linger",
59447 StreamSocketRequest::GetLinger { .. } => "get_linger",
59448 StreamSocketRequest::SetReusePort { .. } => "set_reuse_port",
59449 StreamSocketRequest::GetReusePort { .. } => "get_reuse_port",
59450 StreamSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
59451 StreamSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
59452 StreamSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
59453 StreamSocketRequest::SetBindToInterfaceIndex { .. } => "set_bind_to_interface_index",
59454 StreamSocketRequest::GetBindToInterfaceIndex { .. } => "get_bind_to_interface_index",
59455 StreamSocketRequest::SetTimestamp { .. } => "set_timestamp",
59456 StreamSocketRequest::GetTimestamp { .. } => "get_timestamp",
59457 StreamSocketRequest::SetMark { .. } => "set_mark",
59458 StreamSocketRequest::GetMark { .. } => "get_mark",
59459 StreamSocketRequest::Bind { .. } => "bind",
59460 StreamSocketRequest::Connect { .. } => "connect",
59461 StreamSocketRequest::Disconnect { .. } => "disconnect",
59462 StreamSocketRequest::GetSockName { .. } => "get_sock_name",
59463 StreamSocketRequest::GetPeerName { .. } => "get_peer_name",
59464 StreamSocketRequest::Shutdown { .. } => "shutdown",
59465 StreamSocketRequest::SetIpTypeOfService { .. } => "set_ip_type_of_service",
59466 StreamSocketRequest::GetIpTypeOfService { .. } => "get_ip_type_of_service",
59467 StreamSocketRequest::SetIpTtl { .. } => "set_ip_ttl",
59468 StreamSocketRequest::GetIpTtl { .. } => "get_ip_ttl",
59469 StreamSocketRequest::SetIpPacketInfo { .. } => "set_ip_packet_info",
59470 StreamSocketRequest::GetIpPacketInfo { .. } => "get_ip_packet_info",
59471 StreamSocketRequest::SetIpReceiveTypeOfService { .. } => {
59472 "set_ip_receive_type_of_service"
59473 }
59474 StreamSocketRequest::GetIpReceiveTypeOfService { .. } => {
59475 "get_ip_receive_type_of_service"
59476 }
59477 StreamSocketRequest::SetIpReceiveTtl { .. } => "set_ip_receive_ttl",
59478 StreamSocketRequest::GetIpReceiveTtl { .. } => "get_ip_receive_ttl",
59479 StreamSocketRequest::SetIpMulticastInterface { .. } => "set_ip_multicast_interface",
59480 StreamSocketRequest::GetIpMulticastInterface { .. } => "get_ip_multicast_interface",
59481 StreamSocketRequest::SetIpMulticastTtl { .. } => "set_ip_multicast_ttl",
59482 StreamSocketRequest::GetIpMulticastTtl { .. } => "get_ip_multicast_ttl",
59483 StreamSocketRequest::SetIpMulticastLoopback { .. } => "set_ip_multicast_loopback",
59484 StreamSocketRequest::GetIpMulticastLoopback { .. } => "get_ip_multicast_loopback",
59485 StreamSocketRequest::AddIpMembership { .. } => "add_ip_membership",
59486 StreamSocketRequest::DropIpMembership { .. } => "drop_ip_membership",
59487 StreamSocketRequest::SetIpTransparent { .. } => "set_ip_transparent",
59488 StreamSocketRequest::GetIpTransparent { .. } => "get_ip_transparent",
59489 StreamSocketRequest::SetIpReceiveOriginalDestinationAddress { .. } => {
59490 "set_ip_receive_original_destination_address"
59491 }
59492 StreamSocketRequest::GetIpReceiveOriginalDestinationAddress { .. } => {
59493 "get_ip_receive_original_destination_address"
59494 }
59495 StreamSocketRequest::AddIpv6Membership { .. } => "add_ipv6_membership",
59496 StreamSocketRequest::DropIpv6Membership { .. } => "drop_ipv6_membership",
59497 StreamSocketRequest::SetIpv6MulticastInterface { .. } => "set_ipv6_multicast_interface",
59498 StreamSocketRequest::GetIpv6MulticastInterface { .. } => "get_ipv6_multicast_interface",
59499 StreamSocketRequest::SetIpv6UnicastHops { .. } => "set_ipv6_unicast_hops",
59500 StreamSocketRequest::GetIpv6UnicastHops { .. } => "get_ipv6_unicast_hops",
59501 StreamSocketRequest::SetIpv6ReceiveHopLimit { .. } => "set_ipv6_receive_hop_limit",
59502 StreamSocketRequest::GetIpv6ReceiveHopLimit { .. } => "get_ipv6_receive_hop_limit",
59503 StreamSocketRequest::SetIpv6MulticastHops { .. } => "set_ipv6_multicast_hops",
59504 StreamSocketRequest::GetIpv6MulticastHops { .. } => "get_ipv6_multicast_hops",
59505 StreamSocketRequest::SetIpv6MulticastLoopback { .. } => "set_ipv6_multicast_loopback",
59506 StreamSocketRequest::GetIpv6MulticastLoopback { .. } => "get_ipv6_multicast_loopback",
59507 StreamSocketRequest::SetIpv6Only { .. } => "set_ipv6_only",
59508 StreamSocketRequest::GetIpv6Only { .. } => "get_ipv6_only",
59509 StreamSocketRequest::SetIpv6ReceiveTrafficClass { .. } => {
59510 "set_ipv6_receive_traffic_class"
59511 }
59512 StreamSocketRequest::GetIpv6ReceiveTrafficClass { .. } => {
59513 "get_ipv6_receive_traffic_class"
59514 }
59515 StreamSocketRequest::SetIpv6TrafficClass { .. } => "set_ipv6_traffic_class",
59516 StreamSocketRequest::GetIpv6TrafficClass { .. } => "get_ipv6_traffic_class",
59517 StreamSocketRequest::SetIpv6ReceivePacketInfo { .. } => "set_ipv6_receive_packet_info",
59518 StreamSocketRequest::GetIpv6ReceivePacketInfo { .. } => "get_ipv6_receive_packet_info",
59519 StreamSocketRequest::GetOriginalDestination { .. } => "get_original_destination",
59520 StreamSocketRequest::Describe { .. } => "describe",
59521 StreamSocketRequest::Listen { .. } => "listen",
59522 StreamSocketRequest::Accept { .. } => "accept",
59523 StreamSocketRequest::GetInfo { .. } => "get_info",
59524 StreamSocketRequest::SetTcpNoDelay { .. } => "set_tcp_no_delay",
59525 StreamSocketRequest::GetTcpNoDelay { .. } => "get_tcp_no_delay",
59526 StreamSocketRequest::SetTcpMaxSegment { .. } => "set_tcp_max_segment",
59527 StreamSocketRequest::GetTcpMaxSegment { .. } => "get_tcp_max_segment",
59528 StreamSocketRequest::SetTcpCork { .. } => "set_tcp_cork",
59529 StreamSocketRequest::GetTcpCork { .. } => "get_tcp_cork",
59530 StreamSocketRequest::SetTcpKeepAliveIdle { .. } => "set_tcp_keep_alive_idle",
59531 StreamSocketRequest::GetTcpKeepAliveIdle { .. } => "get_tcp_keep_alive_idle",
59532 StreamSocketRequest::SetTcpKeepAliveInterval { .. } => "set_tcp_keep_alive_interval",
59533 StreamSocketRequest::GetTcpKeepAliveInterval { .. } => "get_tcp_keep_alive_interval",
59534 StreamSocketRequest::SetTcpKeepAliveCount { .. } => "set_tcp_keep_alive_count",
59535 StreamSocketRequest::GetTcpKeepAliveCount { .. } => "get_tcp_keep_alive_count",
59536 StreamSocketRequest::SetTcpSynCount { .. } => "set_tcp_syn_count",
59537 StreamSocketRequest::GetTcpSynCount { .. } => "get_tcp_syn_count",
59538 StreamSocketRequest::SetTcpLinger { .. } => "set_tcp_linger",
59539 StreamSocketRequest::GetTcpLinger { .. } => "get_tcp_linger",
59540 StreamSocketRequest::SetTcpDeferAccept { .. } => "set_tcp_defer_accept",
59541 StreamSocketRequest::GetTcpDeferAccept { .. } => "get_tcp_defer_accept",
59542 StreamSocketRequest::SetTcpWindowClamp { .. } => "set_tcp_window_clamp",
59543 StreamSocketRequest::GetTcpWindowClamp { .. } => "get_tcp_window_clamp",
59544 StreamSocketRequest::GetTcpInfo { .. } => "get_tcp_info",
59545 StreamSocketRequest::SetTcpQuickAck { .. } => "set_tcp_quick_ack",
59546 StreamSocketRequest::GetTcpQuickAck { .. } => "get_tcp_quick_ack",
59547 StreamSocketRequest::SetTcpCongestion { .. } => "set_tcp_congestion",
59548 StreamSocketRequest::GetTcpCongestion { .. } => "get_tcp_congestion",
59549 StreamSocketRequest::SetTcpUserTimeout { .. } => "set_tcp_user_timeout",
59550 StreamSocketRequest::GetTcpUserTimeout { .. } => "get_tcp_user_timeout",
59551 }
59552 }
59553}
59554
59555#[derive(Debug, Clone)]
59556pub struct StreamSocketControlHandle {
59557 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
59558}
59559
59560impl fidl::endpoints::ControlHandle for StreamSocketControlHandle {
59561 fn shutdown(&self) {
59562 self.inner.shutdown()
59563 }
59564 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
59565 self.inner.shutdown_with_epitaph(status)
59566 }
59567
59568 fn is_closed(&self) -> bool {
59569 self.inner.channel().is_closed()
59570 }
59571 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
59572 self.inner.channel().on_closed()
59573 }
59574
59575 #[cfg(target_os = "fuchsia")]
59576 fn signal_peer(
59577 &self,
59578 clear_mask: zx::Signals,
59579 set_mask: zx::Signals,
59580 ) -> Result<(), zx_status::Status> {
59581 use fidl::Peered;
59582 self.inner.channel().signal_peer(clear_mask, set_mask)
59583 }
59584}
59585
59586impl StreamSocketControlHandle {}
59587
59588#[must_use = "FIDL methods require a response to be sent"]
59589#[derive(Debug)]
59590pub struct StreamSocketCloseResponder {
59591 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
59592 tx_id: u32,
59593}
59594
59595impl std::ops::Drop for StreamSocketCloseResponder {
59599 fn drop(&mut self) {
59600 self.control_handle.shutdown();
59601 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59603 }
59604}
59605
59606impl fidl::endpoints::Responder for StreamSocketCloseResponder {
59607 type ControlHandle = StreamSocketControlHandle;
59608
59609 fn control_handle(&self) -> &StreamSocketControlHandle {
59610 &self.control_handle
59611 }
59612
59613 fn drop_without_shutdown(mut self) {
59614 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59616 std::mem::forget(self);
59618 }
59619}
59620
59621impl StreamSocketCloseResponder {
59622 pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
59626 let _result = self.send_raw(result);
59627 if _result.is_err() {
59628 self.control_handle.shutdown();
59629 }
59630 self.drop_without_shutdown();
59631 _result
59632 }
59633
59634 pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
59636 let _result = self.send_raw(result);
59637 self.drop_without_shutdown();
59638 _result
59639 }
59640
59641 fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
59642 self.control_handle
59643 .inner
59644 .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
59645 result,
59646 self.tx_id,
59647 0x5ac5d459ad7f657e,
59648 fidl::encoding::DynamicFlags::empty(),
59649 )
59650 }
59651}
59652
59653#[must_use = "FIDL methods require a response to be sent"]
59654#[derive(Debug)]
59655pub struct StreamSocketQueryResponder {
59656 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
59657 tx_id: u32,
59658}
59659
59660impl std::ops::Drop for StreamSocketQueryResponder {
59664 fn drop(&mut self) {
59665 self.control_handle.shutdown();
59666 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59668 }
59669}
59670
59671impl fidl::endpoints::Responder for StreamSocketQueryResponder {
59672 type ControlHandle = StreamSocketControlHandle;
59673
59674 fn control_handle(&self) -> &StreamSocketControlHandle {
59675 &self.control_handle
59676 }
59677
59678 fn drop_without_shutdown(mut self) {
59679 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59681 std::mem::forget(self);
59683 }
59684}
59685
59686impl StreamSocketQueryResponder {
59687 pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
59691 let _result = self.send_raw(protocol);
59692 if _result.is_err() {
59693 self.control_handle.shutdown();
59694 }
59695 self.drop_without_shutdown();
59696 _result
59697 }
59698
59699 pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
59701 let _result = self.send_raw(protocol);
59702 self.drop_without_shutdown();
59703 _result
59704 }
59705
59706 fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
59707 self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
59708 (protocol,),
59709 self.tx_id,
59710 0x2658edee9decfc06,
59711 fidl::encoding::DynamicFlags::empty(),
59712 )
59713 }
59714}
59715
59716#[must_use = "FIDL methods require a response to be sent"]
59717#[derive(Debug)]
59718pub struct StreamSocketSetReuseAddressResponder {
59719 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
59720 tx_id: u32,
59721}
59722
59723impl std::ops::Drop for StreamSocketSetReuseAddressResponder {
59727 fn drop(&mut self) {
59728 self.control_handle.shutdown();
59729 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59731 }
59732}
59733
59734impl fidl::endpoints::Responder for StreamSocketSetReuseAddressResponder {
59735 type ControlHandle = StreamSocketControlHandle;
59736
59737 fn control_handle(&self) -> &StreamSocketControlHandle {
59738 &self.control_handle
59739 }
59740
59741 fn drop_without_shutdown(mut self) {
59742 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59744 std::mem::forget(self);
59746 }
59747}
59748
59749impl StreamSocketSetReuseAddressResponder {
59750 pub fn send(
59754 self,
59755 mut result: Result<(), fidl_fuchsia_posix::Errno>,
59756 ) -> Result<(), fidl::Error> {
59757 let _result = self.send_raw(result);
59758 if _result.is_err() {
59759 self.control_handle.shutdown();
59760 }
59761 self.drop_without_shutdown();
59762 _result
59763 }
59764
59765 pub fn send_no_shutdown_on_err(
59767 self,
59768 mut result: Result<(), fidl_fuchsia_posix::Errno>,
59769 ) -> Result<(), fidl::Error> {
59770 let _result = self.send_raw(result);
59771 self.drop_without_shutdown();
59772 _result
59773 }
59774
59775 fn send_raw(
59776 &self,
59777 mut result: Result<(), fidl_fuchsia_posix::Errno>,
59778 ) -> Result<(), fidl::Error> {
59779 self.control_handle.inner.send::<fidl::encoding::ResultType<
59780 fidl::encoding::EmptyStruct,
59781 fidl_fuchsia_posix::Errno,
59782 >>(
59783 result,
59784 self.tx_id,
59785 0x1fd74ee8b9a4a876,
59786 fidl::encoding::DynamicFlags::empty(),
59787 )
59788 }
59789}
59790
59791#[must_use = "FIDL methods require a response to be sent"]
59792#[derive(Debug)]
59793pub struct StreamSocketGetReuseAddressResponder {
59794 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
59795 tx_id: u32,
59796}
59797
59798impl std::ops::Drop for StreamSocketGetReuseAddressResponder {
59802 fn drop(&mut self) {
59803 self.control_handle.shutdown();
59804 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59806 }
59807}
59808
59809impl fidl::endpoints::Responder for StreamSocketGetReuseAddressResponder {
59810 type ControlHandle = StreamSocketControlHandle;
59811
59812 fn control_handle(&self) -> &StreamSocketControlHandle {
59813 &self.control_handle
59814 }
59815
59816 fn drop_without_shutdown(mut self) {
59817 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59819 std::mem::forget(self);
59821 }
59822}
59823
59824impl StreamSocketGetReuseAddressResponder {
59825 pub fn send(
59829 self,
59830 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
59831 ) -> Result<(), fidl::Error> {
59832 let _result = self.send_raw(result);
59833 if _result.is_err() {
59834 self.control_handle.shutdown();
59835 }
59836 self.drop_without_shutdown();
59837 _result
59838 }
59839
59840 pub fn send_no_shutdown_on_err(
59842 self,
59843 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
59844 ) -> Result<(), fidl::Error> {
59845 let _result = self.send_raw(result);
59846 self.drop_without_shutdown();
59847 _result
59848 }
59849
59850 fn send_raw(
59851 &self,
59852 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
59853 ) -> Result<(), fidl::Error> {
59854 self.control_handle.inner.send::<fidl::encoding::ResultType<
59855 BaseSocketGetReuseAddressResponse,
59856 fidl_fuchsia_posix::Errno,
59857 >>(
59858 result.map(|value| (value,)),
59859 self.tx_id,
59860 0x67b7206b8d1bc0a5,
59861 fidl::encoding::DynamicFlags::empty(),
59862 )
59863 }
59864}
59865
59866#[must_use = "FIDL methods require a response to be sent"]
59867#[derive(Debug)]
59868pub struct StreamSocketGetErrorResponder {
59869 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
59870 tx_id: u32,
59871}
59872
59873impl std::ops::Drop for StreamSocketGetErrorResponder {
59877 fn drop(&mut self) {
59878 self.control_handle.shutdown();
59879 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59881 }
59882}
59883
59884impl fidl::endpoints::Responder for StreamSocketGetErrorResponder {
59885 type ControlHandle = StreamSocketControlHandle;
59886
59887 fn control_handle(&self) -> &StreamSocketControlHandle {
59888 &self.control_handle
59889 }
59890
59891 fn drop_without_shutdown(mut self) {
59892 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59894 std::mem::forget(self);
59896 }
59897}
59898
59899impl StreamSocketGetErrorResponder {
59900 pub fn send(
59904 self,
59905 mut result: Result<(), fidl_fuchsia_posix::Errno>,
59906 ) -> Result<(), fidl::Error> {
59907 let _result = self.send_raw(result);
59908 if _result.is_err() {
59909 self.control_handle.shutdown();
59910 }
59911 self.drop_without_shutdown();
59912 _result
59913 }
59914
59915 pub fn send_no_shutdown_on_err(
59917 self,
59918 mut result: Result<(), fidl_fuchsia_posix::Errno>,
59919 ) -> Result<(), fidl::Error> {
59920 let _result = self.send_raw(result);
59921 self.drop_without_shutdown();
59922 _result
59923 }
59924
59925 fn send_raw(
59926 &self,
59927 mut result: Result<(), fidl_fuchsia_posix::Errno>,
59928 ) -> Result<(), fidl::Error> {
59929 self.control_handle.inner.send::<fidl::encoding::ResultType<
59930 fidl::encoding::EmptyStruct,
59931 fidl_fuchsia_posix::Errno,
59932 >>(
59933 result,
59934 self.tx_id,
59935 0x5aad39b33e5f6ebb,
59936 fidl::encoding::DynamicFlags::empty(),
59937 )
59938 }
59939}
59940
59941#[must_use = "FIDL methods require a response to be sent"]
59942#[derive(Debug)]
59943pub struct StreamSocketSetBroadcastResponder {
59944 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
59945 tx_id: u32,
59946}
59947
59948impl std::ops::Drop for StreamSocketSetBroadcastResponder {
59952 fn drop(&mut self) {
59953 self.control_handle.shutdown();
59954 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59956 }
59957}
59958
59959impl fidl::endpoints::Responder for StreamSocketSetBroadcastResponder {
59960 type ControlHandle = StreamSocketControlHandle;
59961
59962 fn control_handle(&self) -> &StreamSocketControlHandle {
59963 &self.control_handle
59964 }
59965
59966 fn drop_without_shutdown(mut self) {
59967 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59969 std::mem::forget(self);
59971 }
59972}
59973
59974impl StreamSocketSetBroadcastResponder {
59975 pub fn send(
59979 self,
59980 mut result: Result<(), fidl_fuchsia_posix::Errno>,
59981 ) -> Result<(), fidl::Error> {
59982 let _result = self.send_raw(result);
59983 if _result.is_err() {
59984 self.control_handle.shutdown();
59985 }
59986 self.drop_without_shutdown();
59987 _result
59988 }
59989
59990 pub fn send_no_shutdown_on_err(
59992 self,
59993 mut result: Result<(), fidl_fuchsia_posix::Errno>,
59994 ) -> Result<(), fidl::Error> {
59995 let _result = self.send_raw(result);
59996 self.drop_without_shutdown();
59997 _result
59998 }
59999
60000 fn send_raw(
60001 &self,
60002 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60003 ) -> Result<(), fidl::Error> {
60004 self.control_handle.inner.send::<fidl::encoding::ResultType<
60005 fidl::encoding::EmptyStruct,
60006 fidl_fuchsia_posix::Errno,
60007 >>(
60008 result,
60009 self.tx_id,
60010 0x6023e081ce3cd947,
60011 fidl::encoding::DynamicFlags::empty(),
60012 )
60013 }
60014}
60015
60016#[must_use = "FIDL methods require a response to be sent"]
60017#[derive(Debug)]
60018pub struct StreamSocketGetBroadcastResponder {
60019 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60020 tx_id: u32,
60021}
60022
60023impl std::ops::Drop for StreamSocketGetBroadcastResponder {
60027 fn drop(&mut self) {
60028 self.control_handle.shutdown();
60029 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60031 }
60032}
60033
60034impl fidl::endpoints::Responder for StreamSocketGetBroadcastResponder {
60035 type ControlHandle = StreamSocketControlHandle;
60036
60037 fn control_handle(&self) -> &StreamSocketControlHandle {
60038 &self.control_handle
60039 }
60040
60041 fn drop_without_shutdown(mut self) {
60042 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60044 std::mem::forget(self);
60046 }
60047}
60048
60049impl StreamSocketGetBroadcastResponder {
60050 pub fn send(
60054 self,
60055 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60056 ) -> Result<(), fidl::Error> {
60057 let _result = self.send_raw(result);
60058 if _result.is_err() {
60059 self.control_handle.shutdown();
60060 }
60061 self.drop_without_shutdown();
60062 _result
60063 }
60064
60065 pub fn send_no_shutdown_on_err(
60067 self,
60068 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60069 ) -> Result<(), fidl::Error> {
60070 let _result = self.send_raw(result);
60071 self.drop_without_shutdown();
60072 _result
60073 }
60074
60075 fn send_raw(
60076 &self,
60077 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60078 ) -> Result<(), fidl::Error> {
60079 self.control_handle.inner.send::<fidl::encoding::ResultType<
60080 BaseSocketGetBroadcastResponse,
60081 fidl_fuchsia_posix::Errno,
60082 >>(
60083 result.map(|value| (value,)),
60084 self.tx_id,
60085 0x68796fc556f9780d,
60086 fidl::encoding::DynamicFlags::empty(),
60087 )
60088 }
60089}
60090
60091#[must_use = "FIDL methods require a response to be sent"]
60092#[derive(Debug)]
60093pub struct StreamSocketSetSendBufferResponder {
60094 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60095 tx_id: u32,
60096}
60097
60098impl std::ops::Drop for StreamSocketSetSendBufferResponder {
60102 fn drop(&mut self) {
60103 self.control_handle.shutdown();
60104 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60106 }
60107}
60108
60109impl fidl::endpoints::Responder for StreamSocketSetSendBufferResponder {
60110 type ControlHandle = StreamSocketControlHandle;
60111
60112 fn control_handle(&self) -> &StreamSocketControlHandle {
60113 &self.control_handle
60114 }
60115
60116 fn drop_without_shutdown(mut self) {
60117 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60119 std::mem::forget(self);
60121 }
60122}
60123
60124impl StreamSocketSetSendBufferResponder {
60125 pub fn send(
60129 self,
60130 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60131 ) -> Result<(), fidl::Error> {
60132 let _result = self.send_raw(result);
60133 if _result.is_err() {
60134 self.control_handle.shutdown();
60135 }
60136 self.drop_without_shutdown();
60137 _result
60138 }
60139
60140 pub fn send_no_shutdown_on_err(
60142 self,
60143 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60144 ) -> Result<(), fidl::Error> {
60145 let _result = self.send_raw(result);
60146 self.drop_without_shutdown();
60147 _result
60148 }
60149
60150 fn send_raw(
60151 &self,
60152 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60153 ) -> Result<(), fidl::Error> {
60154 self.control_handle.inner.send::<fidl::encoding::ResultType<
60155 fidl::encoding::EmptyStruct,
60156 fidl_fuchsia_posix::Errno,
60157 >>(
60158 result,
60159 self.tx_id,
60160 0x756eac32d73a7a70,
60161 fidl::encoding::DynamicFlags::empty(),
60162 )
60163 }
60164}
60165
60166#[must_use = "FIDL methods require a response to be sent"]
60167#[derive(Debug)]
60168pub struct StreamSocketGetSendBufferResponder {
60169 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60170 tx_id: u32,
60171}
60172
60173impl std::ops::Drop for StreamSocketGetSendBufferResponder {
60177 fn drop(&mut self) {
60178 self.control_handle.shutdown();
60179 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60181 }
60182}
60183
60184impl fidl::endpoints::Responder for StreamSocketGetSendBufferResponder {
60185 type ControlHandle = StreamSocketControlHandle;
60186
60187 fn control_handle(&self) -> &StreamSocketControlHandle {
60188 &self.control_handle
60189 }
60190
60191 fn drop_without_shutdown(mut self) {
60192 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60194 std::mem::forget(self);
60196 }
60197}
60198
60199impl StreamSocketGetSendBufferResponder {
60200 pub fn send(
60204 self,
60205 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
60206 ) -> Result<(), fidl::Error> {
60207 let _result = self.send_raw(result);
60208 if _result.is_err() {
60209 self.control_handle.shutdown();
60210 }
60211 self.drop_without_shutdown();
60212 _result
60213 }
60214
60215 pub fn send_no_shutdown_on_err(
60217 self,
60218 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
60219 ) -> Result<(), fidl::Error> {
60220 let _result = self.send_raw(result);
60221 self.drop_without_shutdown();
60222 _result
60223 }
60224
60225 fn send_raw(
60226 &self,
60227 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
60228 ) -> Result<(), fidl::Error> {
60229 self.control_handle.inner.send::<fidl::encoding::ResultType<
60230 BaseSocketGetSendBufferResponse,
60231 fidl_fuchsia_posix::Errno,
60232 >>(
60233 result.map(|value_bytes| (value_bytes,)),
60234 self.tx_id,
60235 0x78a52fd9c7b2410b,
60236 fidl::encoding::DynamicFlags::empty(),
60237 )
60238 }
60239}
60240
60241#[must_use = "FIDL methods require a response to be sent"]
60242#[derive(Debug)]
60243pub struct StreamSocketSetReceiveBufferResponder {
60244 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60245 tx_id: u32,
60246}
60247
60248impl std::ops::Drop for StreamSocketSetReceiveBufferResponder {
60252 fn drop(&mut self) {
60253 self.control_handle.shutdown();
60254 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60256 }
60257}
60258
60259impl fidl::endpoints::Responder for StreamSocketSetReceiveBufferResponder {
60260 type ControlHandle = StreamSocketControlHandle;
60261
60262 fn control_handle(&self) -> &StreamSocketControlHandle {
60263 &self.control_handle
60264 }
60265
60266 fn drop_without_shutdown(mut self) {
60267 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60269 std::mem::forget(self);
60271 }
60272}
60273
60274impl StreamSocketSetReceiveBufferResponder {
60275 pub fn send(
60279 self,
60280 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60281 ) -> Result<(), fidl::Error> {
60282 let _result = self.send_raw(result);
60283 if _result.is_err() {
60284 self.control_handle.shutdown();
60285 }
60286 self.drop_without_shutdown();
60287 _result
60288 }
60289
60290 pub fn send_no_shutdown_on_err(
60292 self,
60293 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60294 ) -> Result<(), fidl::Error> {
60295 let _result = self.send_raw(result);
60296 self.drop_without_shutdown();
60297 _result
60298 }
60299
60300 fn send_raw(
60301 &self,
60302 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60303 ) -> Result<(), fidl::Error> {
60304 self.control_handle.inner.send::<fidl::encoding::ResultType<
60305 fidl::encoding::EmptyStruct,
60306 fidl_fuchsia_posix::Errno,
60307 >>(
60308 result,
60309 self.tx_id,
60310 0x6b0cf2f1919c7001,
60311 fidl::encoding::DynamicFlags::empty(),
60312 )
60313 }
60314}
60315
60316#[must_use = "FIDL methods require a response to be sent"]
60317#[derive(Debug)]
60318pub struct StreamSocketGetReceiveBufferResponder {
60319 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60320 tx_id: u32,
60321}
60322
60323impl std::ops::Drop for StreamSocketGetReceiveBufferResponder {
60327 fn drop(&mut self) {
60328 self.control_handle.shutdown();
60329 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60331 }
60332}
60333
60334impl fidl::endpoints::Responder for StreamSocketGetReceiveBufferResponder {
60335 type ControlHandle = StreamSocketControlHandle;
60336
60337 fn control_handle(&self) -> &StreamSocketControlHandle {
60338 &self.control_handle
60339 }
60340
60341 fn drop_without_shutdown(mut self) {
60342 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60344 std::mem::forget(self);
60346 }
60347}
60348
60349impl StreamSocketGetReceiveBufferResponder {
60350 pub fn send(
60354 self,
60355 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
60356 ) -> Result<(), fidl::Error> {
60357 let _result = self.send_raw(result);
60358 if _result.is_err() {
60359 self.control_handle.shutdown();
60360 }
60361 self.drop_without_shutdown();
60362 _result
60363 }
60364
60365 pub fn send_no_shutdown_on_err(
60367 self,
60368 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
60369 ) -> Result<(), fidl::Error> {
60370 let _result = self.send_raw(result);
60371 self.drop_without_shutdown();
60372 _result
60373 }
60374
60375 fn send_raw(
60376 &self,
60377 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
60378 ) -> Result<(), fidl::Error> {
60379 self.control_handle.inner.send::<fidl::encoding::ResultType<
60380 BaseSocketGetReceiveBufferResponse,
60381 fidl_fuchsia_posix::Errno,
60382 >>(
60383 result.map(|value_bytes| (value_bytes,)),
60384 self.tx_id,
60385 0x14c1a4b64f709e5c,
60386 fidl::encoding::DynamicFlags::empty(),
60387 )
60388 }
60389}
60390
60391#[must_use = "FIDL methods require a response to be sent"]
60392#[derive(Debug)]
60393pub struct StreamSocketSetKeepAliveResponder {
60394 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60395 tx_id: u32,
60396}
60397
60398impl std::ops::Drop for StreamSocketSetKeepAliveResponder {
60402 fn drop(&mut self) {
60403 self.control_handle.shutdown();
60404 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60406 }
60407}
60408
60409impl fidl::endpoints::Responder for StreamSocketSetKeepAliveResponder {
60410 type ControlHandle = StreamSocketControlHandle;
60411
60412 fn control_handle(&self) -> &StreamSocketControlHandle {
60413 &self.control_handle
60414 }
60415
60416 fn drop_without_shutdown(mut self) {
60417 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60419 std::mem::forget(self);
60421 }
60422}
60423
60424impl StreamSocketSetKeepAliveResponder {
60425 pub fn send(
60429 self,
60430 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60431 ) -> Result<(), fidl::Error> {
60432 let _result = self.send_raw(result);
60433 if _result.is_err() {
60434 self.control_handle.shutdown();
60435 }
60436 self.drop_without_shutdown();
60437 _result
60438 }
60439
60440 pub fn send_no_shutdown_on_err(
60442 self,
60443 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60444 ) -> Result<(), fidl::Error> {
60445 let _result = self.send_raw(result);
60446 self.drop_without_shutdown();
60447 _result
60448 }
60449
60450 fn send_raw(
60451 &self,
60452 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60453 ) -> Result<(), fidl::Error> {
60454 self.control_handle.inner.send::<fidl::encoding::ResultType<
60455 fidl::encoding::EmptyStruct,
60456 fidl_fuchsia_posix::Errno,
60457 >>(
60458 result,
60459 self.tx_id,
60460 0x572df8f0b920d2c7,
60461 fidl::encoding::DynamicFlags::empty(),
60462 )
60463 }
60464}
60465
60466#[must_use = "FIDL methods require a response to be sent"]
60467#[derive(Debug)]
60468pub struct StreamSocketGetKeepAliveResponder {
60469 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60470 tx_id: u32,
60471}
60472
60473impl std::ops::Drop for StreamSocketGetKeepAliveResponder {
60477 fn drop(&mut self) {
60478 self.control_handle.shutdown();
60479 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60481 }
60482}
60483
60484impl fidl::endpoints::Responder for StreamSocketGetKeepAliveResponder {
60485 type ControlHandle = StreamSocketControlHandle;
60486
60487 fn control_handle(&self) -> &StreamSocketControlHandle {
60488 &self.control_handle
60489 }
60490
60491 fn drop_without_shutdown(mut self) {
60492 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60494 std::mem::forget(self);
60496 }
60497}
60498
60499impl StreamSocketGetKeepAliveResponder {
60500 pub fn send(
60504 self,
60505 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60506 ) -> Result<(), fidl::Error> {
60507 let _result = self.send_raw(result);
60508 if _result.is_err() {
60509 self.control_handle.shutdown();
60510 }
60511 self.drop_without_shutdown();
60512 _result
60513 }
60514
60515 pub fn send_no_shutdown_on_err(
60517 self,
60518 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60519 ) -> Result<(), fidl::Error> {
60520 let _result = self.send_raw(result);
60521 self.drop_without_shutdown();
60522 _result
60523 }
60524
60525 fn send_raw(
60526 &self,
60527 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60528 ) -> Result<(), fidl::Error> {
60529 self.control_handle.inner.send::<fidl::encoding::ResultType<
60530 BaseSocketGetKeepAliveResponse,
60531 fidl_fuchsia_posix::Errno,
60532 >>(
60533 result.map(|value| (value,)),
60534 self.tx_id,
60535 0x2dd29d3215f2c9d2,
60536 fidl::encoding::DynamicFlags::empty(),
60537 )
60538 }
60539}
60540
60541#[must_use = "FIDL methods require a response to be sent"]
60542#[derive(Debug)]
60543pub struct StreamSocketSetOutOfBandInlineResponder {
60544 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60545 tx_id: u32,
60546}
60547
60548impl std::ops::Drop for StreamSocketSetOutOfBandInlineResponder {
60552 fn drop(&mut self) {
60553 self.control_handle.shutdown();
60554 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60556 }
60557}
60558
60559impl fidl::endpoints::Responder for StreamSocketSetOutOfBandInlineResponder {
60560 type ControlHandle = StreamSocketControlHandle;
60561
60562 fn control_handle(&self) -> &StreamSocketControlHandle {
60563 &self.control_handle
60564 }
60565
60566 fn drop_without_shutdown(mut self) {
60567 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60569 std::mem::forget(self);
60571 }
60572}
60573
60574impl StreamSocketSetOutOfBandInlineResponder {
60575 pub fn send(
60579 self,
60580 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60581 ) -> Result<(), fidl::Error> {
60582 let _result = self.send_raw(result);
60583 if _result.is_err() {
60584 self.control_handle.shutdown();
60585 }
60586 self.drop_without_shutdown();
60587 _result
60588 }
60589
60590 pub fn send_no_shutdown_on_err(
60592 self,
60593 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60594 ) -> Result<(), fidl::Error> {
60595 let _result = self.send_raw(result);
60596 self.drop_without_shutdown();
60597 _result
60598 }
60599
60600 fn send_raw(
60601 &self,
60602 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60603 ) -> Result<(), fidl::Error> {
60604 self.control_handle.inner.send::<fidl::encoding::ResultType<
60605 fidl::encoding::EmptyStruct,
60606 fidl_fuchsia_posix::Errno,
60607 >>(
60608 result,
60609 self.tx_id,
60610 0x3ecb49968bee439,
60611 fidl::encoding::DynamicFlags::empty(),
60612 )
60613 }
60614}
60615
60616#[must_use = "FIDL methods require a response to be sent"]
60617#[derive(Debug)]
60618pub struct StreamSocketGetOutOfBandInlineResponder {
60619 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60620 tx_id: u32,
60621}
60622
60623impl std::ops::Drop for StreamSocketGetOutOfBandInlineResponder {
60627 fn drop(&mut self) {
60628 self.control_handle.shutdown();
60629 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60631 }
60632}
60633
60634impl fidl::endpoints::Responder for StreamSocketGetOutOfBandInlineResponder {
60635 type ControlHandle = StreamSocketControlHandle;
60636
60637 fn control_handle(&self) -> &StreamSocketControlHandle {
60638 &self.control_handle
60639 }
60640
60641 fn drop_without_shutdown(mut self) {
60642 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60644 std::mem::forget(self);
60646 }
60647}
60648
60649impl StreamSocketGetOutOfBandInlineResponder {
60650 pub fn send(
60654 self,
60655 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60656 ) -> Result<(), fidl::Error> {
60657 let _result = self.send_raw(result);
60658 if _result.is_err() {
60659 self.control_handle.shutdown();
60660 }
60661 self.drop_without_shutdown();
60662 _result
60663 }
60664
60665 pub fn send_no_shutdown_on_err(
60667 self,
60668 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60669 ) -> Result<(), fidl::Error> {
60670 let _result = self.send_raw(result);
60671 self.drop_without_shutdown();
60672 _result
60673 }
60674
60675 fn send_raw(
60676 &self,
60677 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60678 ) -> Result<(), fidl::Error> {
60679 self.control_handle.inner.send::<fidl::encoding::ResultType<
60680 BaseSocketGetOutOfBandInlineResponse,
60681 fidl_fuchsia_posix::Errno,
60682 >>(
60683 result.map(|value| (value,)),
60684 self.tx_id,
60685 0x348c1ab3aeca1745,
60686 fidl::encoding::DynamicFlags::empty(),
60687 )
60688 }
60689}
60690
60691#[must_use = "FIDL methods require a response to be sent"]
60692#[derive(Debug)]
60693pub struct StreamSocketSetNoCheckResponder {
60694 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60695 tx_id: u32,
60696}
60697
60698impl std::ops::Drop for StreamSocketSetNoCheckResponder {
60702 fn drop(&mut self) {
60703 self.control_handle.shutdown();
60704 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60706 }
60707}
60708
60709impl fidl::endpoints::Responder for StreamSocketSetNoCheckResponder {
60710 type ControlHandle = StreamSocketControlHandle;
60711
60712 fn control_handle(&self) -> &StreamSocketControlHandle {
60713 &self.control_handle
60714 }
60715
60716 fn drop_without_shutdown(mut self) {
60717 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60719 std::mem::forget(self);
60721 }
60722}
60723
60724impl StreamSocketSetNoCheckResponder {
60725 pub fn send(
60729 self,
60730 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60731 ) -> Result<(), fidl::Error> {
60732 let _result = self.send_raw(result);
60733 if _result.is_err() {
60734 self.control_handle.shutdown();
60735 }
60736 self.drop_without_shutdown();
60737 _result
60738 }
60739
60740 pub fn send_no_shutdown_on_err(
60742 self,
60743 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60744 ) -> Result<(), fidl::Error> {
60745 let _result = self.send_raw(result);
60746 self.drop_without_shutdown();
60747 _result
60748 }
60749
60750 fn send_raw(
60751 &self,
60752 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60753 ) -> Result<(), fidl::Error> {
60754 self.control_handle.inner.send::<fidl::encoding::ResultType<
60755 fidl::encoding::EmptyStruct,
60756 fidl_fuchsia_posix::Errno,
60757 >>(
60758 result,
60759 self.tx_id,
60760 0x6bbf00c53a4c78c2,
60761 fidl::encoding::DynamicFlags::empty(),
60762 )
60763 }
60764}
60765
60766#[must_use = "FIDL methods require a response to be sent"]
60767#[derive(Debug)]
60768pub struct StreamSocketGetNoCheckResponder {
60769 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60770 tx_id: u32,
60771}
60772
60773impl std::ops::Drop for StreamSocketGetNoCheckResponder {
60777 fn drop(&mut self) {
60778 self.control_handle.shutdown();
60779 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60781 }
60782}
60783
60784impl fidl::endpoints::Responder for StreamSocketGetNoCheckResponder {
60785 type ControlHandle = StreamSocketControlHandle;
60786
60787 fn control_handle(&self) -> &StreamSocketControlHandle {
60788 &self.control_handle
60789 }
60790
60791 fn drop_without_shutdown(mut self) {
60792 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60794 std::mem::forget(self);
60796 }
60797}
60798
60799impl StreamSocketGetNoCheckResponder {
60800 pub fn send(
60804 self,
60805 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60806 ) -> Result<(), fidl::Error> {
60807 let _result = self.send_raw(result);
60808 if _result.is_err() {
60809 self.control_handle.shutdown();
60810 }
60811 self.drop_without_shutdown();
60812 _result
60813 }
60814
60815 pub fn send_no_shutdown_on_err(
60817 self,
60818 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60819 ) -> Result<(), fidl::Error> {
60820 let _result = self.send_raw(result);
60821 self.drop_without_shutdown();
60822 _result
60823 }
60824
60825 fn send_raw(
60826 &self,
60827 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60828 ) -> Result<(), fidl::Error> {
60829 self.control_handle.inner.send::<fidl::encoding::ResultType<
60830 BaseSocketGetNoCheckResponse,
60831 fidl_fuchsia_posix::Errno,
60832 >>(
60833 result.map(|value| (value,)),
60834 self.tx_id,
60835 0x2cd4249286417694,
60836 fidl::encoding::DynamicFlags::empty(),
60837 )
60838 }
60839}
60840
60841#[must_use = "FIDL methods require a response to be sent"]
60842#[derive(Debug)]
60843pub struct StreamSocketSetLingerResponder {
60844 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60845 tx_id: u32,
60846}
60847
60848impl std::ops::Drop for StreamSocketSetLingerResponder {
60852 fn drop(&mut self) {
60853 self.control_handle.shutdown();
60854 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60856 }
60857}
60858
60859impl fidl::endpoints::Responder for StreamSocketSetLingerResponder {
60860 type ControlHandle = StreamSocketControlHandle;
60861
60862 fn control_handle(&self) -> &StreamSocketControlHandle {
60863 &self.control_handle
60864 }
60865
60866 fn drop_without_shutdown(mut self) {
60867 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60869 std::mem::forget(self);
60871 }
60872}
60873
60874impl StreamSocketSetLingerResponder {
60875 pub fn send(
60879 self,
60880 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60881 ) -> Result<(), fidl::Error> {
60882 let _result = self.send_raw(result);
60883 if _result.is_err() {
60884 self.control_handle.shutdown();
60885 }
60886 self.drop_without_shutdown();
60887 _result
60888 }
60889
60890 pub fn send_no_shutdown_on_err(
60892 self,
60893 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60894 ) -> Result<(), fidl::Error> {
60895 let _result = self.send_raw(result);
60896 self.drop_without_shutdown();
60897 _result
60898 }
60899
60900 fn send_raw(
60901 &self,
60902 mut result: Result<(), fidl_fuchsia_posix::Errno>,
60903 ) -> Result<(), fidl::Error> {
60904 self.control_handle.inner.send::<fidl::encoding::ResultType<
60905 fidl::encoding::EmptyStruct,
60906 fidl_fuchsia_posix::Errno,
60907 >>(
60908 result,
60909 self.tx_id,
60910 0x45386351246e998e,
60911 fidl::encoding::DynamicFlags::empty(),
60912 )
60913 }
60914}
60915
60916#[must_use = "FIDL methods require a response to be sent"]
60917#[derive(Debug)]
60918pub struct StreamSocketGetLingerResponder {
60919 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60920 tx_id: u32,
60921}
60922
60923impl std::ops::Drop for StreamSocketGetLingerResponder {
60927 fn drop(&mut self) {
60928 self.control_handle.shutdown();
60929 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60931 }
60932}
60933
60934impl fidl::endpoints::Responder for StreamSocketGetLingerResponder {
60935 type ControlHandle = StreamSocketControlHandle;
60936
60937 fn control_handle(&self) -> &StreamSocketControlHandle {
60938 &self.control_handle
60939 }
60940
60941 fn drop_without_shutdown(mut self) {
60942 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60944 std::mem::forget(self);
60946 }
60947}
60948
60949impl StreamSocketGetLingerResponder {
60950 pub fn send(
60954 self,
60955 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
60956 ) -> Result<(), fidl::Error> {
60957 let _result = self.send_raw(result);
60958 if _result.is_err() {
60959 self.control_handle.shutdown();
60960 }
60961 self.drop_without_shutdown();
60962 _result
60963 }
60964
60965 pub fn send_no_shutdown_on_err(
60967 self,
60968 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
60969 ) -> Result<(), fidl::Error> {
60970 let _result = self.send_raw(result);
60971 self.drop_without_shutdown();
60972 _result
60973 }
60974
60975 fn send_raw(
60976 &self,
60977 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
60978 ) -> Result<(), fidl::Error> {
60979 self.control_handle.inner.send::<fidl::encoding::ResultType<
60980 BaseSocketGetLingerResponse,
60981 fidl_fuchsia_posix::Errno,
60982 >>(
60983 result,
60984 self.tx_id,
60985 0x48eb20fc5ccb0e45,
60986 fidl::encoding::DynamicFlags::empty(),
60987 )
60988 }
60989}
60990
60991#[must_use = "FIDL methods require a response to be sent"]
60992#[derive(Debug)]
60993pub struct StreamSocketSetReusePortResponder {
60994 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60995 tx_id: u32,
60996}
60997
60998impl std::ops::Drop for StreamSocketSetReusePortResponder {
61002 fn drop(&mut self) {
61003 self.control_handle.shutdown();
61004 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61006 }
61007}
61008
61009impl fidl::endpoints::Responder for StreamSocketSetReusePortResponder {
61010 type ControlHandle = StreamSocketControlHandle;
61011
61012 fn control_handle(&self) -> &StreamSocketControlHandle {
61013 &self.control_handle
61014 }
61015
61016 fn drop_without_shutdown(mut self) {
61017 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61019 std::mem::forget(self);
61021 }
61022}
61023
61024impl StreamSocketSetReusePortResponder {
61025 pub fn send(
61029 self,
61030 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61031 ) -> Result<(), fidl::Error> {
61032 let _result = self.send_raw(result);
61033 if _result.is_err() {
61034 self.control_handle.shutdown();
61035 }
61036 self.drop_without_shutdown();
61037 _result
61038 }
61039
61040 pub fn send_no_shutdown_on_err(
61042 self,
61043 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61044 ) -> Result<(), fidl::Error> {
61045 let _result = self.send_raw(result);
61046 self.drop_without_shutdown();
61047 _result
61048 }
61049
61050 fn send_raw(
61051 &self,
61052 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61053 ) -> Result<(), fidl::Error> {
61054 self.control_handle.inner.send::<fidl::encoding::ResultType<
61055 fidl::encoding::EmptyStruct,
61056 fidl_fuchsia_posix::Errno,
61057 >>(
61058 result,
61059 self.tx_id,
61060 0x24dd3e5cb36d9ccb,
61061 fidl::encoding::DynamicFlags::empty(),
61062 )
61063 }
61064}
61065
61066#[must_use = "FIDL methods require a response to be sent"]
61067#[derive(Debug)]
61068pub struct StreamSocketGetReusePortResponder {
61069 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61070 tx_id: u32,
61071}
61072
61073impl std::ops::Drop for StreamSocketGetReusePortResponder {
61077 fn drop(&mut self) {
61078 self.control_handle.shutdown();
61079 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61081 }
61082}
61083
61084impl fidl::endpoints::Responder for StreamSocketGetReusePortResponder {
61085 type ControlHandle = StreamSocketControlHandle;
61086
61087 fn control_handle(&self) -> &StreamSocketControlHandle {
61088 &self.control_handle
61089 }
61090
61091 fn drop_without_shutdown(mut self) {
61092 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61094 std::mem::forget(self);
61096 }
61097}
61098
61099impl StreamSocketGetReusePortResponder {
61100 pub fn send(
61104 self,
61105 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
61106 ) -> Result<(), fidl::Error> {
61107 let _result = self.send_raw(result);
61108 if _result.is_err() {
61109 self.control_handle.shutdown();
61110 }
61111 self.drop_without_shutdown();
61112 _result
61113 }
61114
61115 pub fn send_no_shutdown_on_err(
61117 self,
61118 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
61119 ) -> Result<(), fidl::Error> {
61120 let _result = self.send_raw(result);
61121 self.drop_without_shutdown();
61122 _result
61123 }
61124
61125 fn send_raw(
61126 &self,
61127 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
61128 ) -> Result<(), fidl::Error> {
61129 self.control_handle.inner.send::<fidl::encoding::ResultType<
61130 BaseSocketGetReusePortResponse,
61131 fidl_fuchsia_posix::Errno,
61132 >>(
61133 result.map(|value| (value,)),
61134 self.tx_id,
61135 0x7a112c1ab54ff828,
61136 fidl::encoding::DynamicFlags::empty(),
61137 )
61138 }
61139}
61140
61141#[must_use = "FIDL methods require a response to be sent"]
61142#[derive(Debug)]
61143pub struct StreamSocketGetAcceptConnResponder {
61144 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61145 tx_id: u32,
61146}
61147
61148impl std::ops::Drop for StreamSocketGetAcceptConnResponder {
61152 fn drop(&mut self) {
61153 self.control_handle.shutdown();
61154 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61156 }
61157}
61158
61159impl fidl::endpoints::Responder for StreamSocketGetAcceptConnResponder {
61160 type ControlHandle = StreamSocketControlHandle;
61161
61162 fn control_handle(&self) -> &StreamSocketControlHandle {
61163 &self.control_handle
61164 }
61165
61166 fn drop_without_shutdown(mut self) {
61167 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61169 std::mem::forget(self);
61171 }
61172}
61173
61174impl StreamSocketGetAcceptConnResponder {
61175 pub fn send(
61179 self,
61180 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
61181 ) -> Result<(), fidl::Error> {
61182 let _result = self.send_raw(result);
61183 if _result.is_err() {
61184 self.control_handle.shutdown();
61185 }
61186 self.drop_without_shutdown();
61187 _result
61188 }
61189
61190 pub fn send_no_shutdown_on_err(
61192 self,
61193 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
61194 ) -> Result<(), fidl::Error> {
61195 let _result = self.send_raw(result);
61196 self.drop_without_shutdown();
61197 _result
61198 }
61199
61200 fn send_raw(
61201 &self,
61202 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
61203 ) -> Result<(), fidl::Error> {
61204 self.control_handle.inner.send::<fidl::encoding::ResultType<
61205 BaseSocketGetAcceptConnResponse,
61206 fidl_fuchsia_posix::Errno,
61207 >>(
61208 result.map(|value| (value,)),
61209 self.tx_id,
61210 0x67ce6db6c2ec8966,
61211 fidl::encoding::DynamicFlags::empty(),
61212 )
61213 }
61214}
61215
61216#[must_use = "FIDL methods require a response to be sent"]
61217#[derive(Debug)]
61218pub struct StreamSocketSetBindToDeviceResponder {
61219 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61220 tx_id: u32,
61221}
61222
61223impl std::ops::Drop for StreamSocketSetBindToDeviceResponder {
61227 fn drop(&mut self) {
61228 self.control_handle.shutdown();
61229 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61231 }
61232}
61233
61234impl fidl::endpoints::Responder for StreamSocketSetBindToDeviceResponder {
61235 type ControlHandle = StreamSocketControlHandle;
61236
61237 fn control_handle(&self) -> &StreamSocketControlHandle {
61238 &self.control_handle
61239 }
61240
61241 fn drop_without_shutdown(mut self) {
61242 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61244 std::mem::forget(self);
61246 }
61247}
61248
61249impl StreamSocketSetBindToDeviceResponder {
61250 pub fn send(
61254 self,
61255 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61256 ) -> Result<(), fidl::Error> {
61257 let _result = self.send_raw(result);
61258 if _result.is_err() {
61259 self.control_handle.shutdown();
61260 }
61261 self.drop_without_shutdown();
61262 _result
61263 }
61264
61265 pub fn send_no_shutdown_on_err(
61267 self,
61268 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61269 ) -> Result<(), fidl::Error> {
61270 let _result = self.send_raw(result);
61271 self.drop_without_shutdown();
61272 _result
61273 }
61274
61275 fn send_raw(
61276 &self,
61277 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61278 ) -> Result<(), fidl::Error> {
61279 self.control_handle.inner.send::<fidl::encoding::ResultType<
61280 fidl::encoding::EmptyStruct,
61281 fidl_fuchsia_posix::Errno,
61282 >>(
61283 result,
61284 self.tx_id,
61285 0x2118b483f28aafc4,
61286 fidl::encoding::DynamicFlags::empty(),
61287 )
61288 }
61289}
61290
61291#[must_use = "FIDL methods require a response to be sent"]
61292#[derive(Debug)]
61293pub struct StreamSocketGetBindToDeviceResponder {
61294 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61295 tx_id: u32,
61296}
61297
61298impl std::ops::Drop for StreamSocketGetBindToDeviceResponder {
61302 fn drop(&mut self) {
61303 self.control_handle.shutdown();
61304 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61306 }
61307}
61308
61309impl fidl::endpoints::Responder for StreamSocketGetBindToDeviceResponder {
61310 type ControlHandle = StreamSocketControlHandle;
61311
61312 fn control_handle(&self) -> &StreamSocketControlHandle {
61313 &self.control_handle
61314 }
61315
61316 fn drop_without_shutdown(mut self) {
61317 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61319 std::mem::forget(self);
61321 }
61322}
61323
61324impl StreamSocketGetBindToDeviceResponder {
61325 pub fn send(
61329 self,
61330 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
61331 ) -> Result<(), fidl::Error> {
61332 let _result = self.send_raw(result);
61333 if _result.is_err() {
61334 self.control_handle.shutdown();
61335 }
61336 self.drop_without_shutdown();
61337 _result
61338 }
61339
61340 pub fn send_no_shutdown_on_err(
61342 self,
61343 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
61344 ) -> Result<(), fidl::Error> {
61345 let _result = self.send_raw(result);
61346 self.drop_without_shutdown();
61347 _result
61348 }
61349
61350 fn send_raw(
61351 &self,
61352 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
61353 ) -> Result<(), fidl::Error> {
61354 self.control_handle.inner.send::<fidl::encoding::ResultType<
61355 BaseSocketGetBindToDeviceResponse,
61356 fidl_fuchsia_posix::Errno,
61357 >>(
61358 result.map(|value| (value,)),
61359 self.tx_id,
61360 0x1ab1fbf0ef7906c8,
61361 fidl::encoding::DynamicFlags::empty(),
61362 )
61363 }
61364}
61365
61366#[must_use = "FIDL methods require a response to be sent"]
61367#[derive(Debug)]
61368pub struct StreamSocketSetBindToInterfaceIndexResponder {
61369 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61370 tx_id: u32,
61371}
61372
61373impl std::ops::Drop for StreamSocketSetBindToInterfaceIndexResponder {
61377 fn drop(&mut self) {
61378 self.control_handle.shutdown();
61379 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61381 }
61382}
61383
61384impl fidl::endpoints::Responder for StreamSocketSetBindToInterfaceIndexResponder {
61385 type ControlHandle = StreamSocketControlHandle;
61386
61387 fn control_handle(&self) -> &StreamSocketControlHandle {
61388 &self.control_handle
61389 }
61390
61391 fn drop_without_shutdown(mut self) {
61392 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61394 std::mem::forget(self);
61396 }
61397}
61398
61399impl StreamSocketSetBindToInterfaceIndexResponder {
61400 pub fn send(
61404 self,
61405 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61406 ) -> Result<(), fidl::Error> {
61407 let _result = self.send_raw(result);
61408 if _result.is_err() {
61409 self.control_handle.shutdown();
61410 }
61411 self.drop_without_shutdown();
61412 _result
61413 }
61414
61415 pub fn send_no_shutdown_on_err(
61417 self,
61418 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61419 ) -> Result<(), fidl::Error> {
61420 let _result = self.send_raw(result);
61421 self.drop_without_shutdown();
61422 _result
61423 }
61424
61425 fn send_raw(
61426 &self,
61427 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61428 ) -> Result<(), fidl::Error> {
61429 self.control_handle.inner.send::<fidl::encoding::ResultType<
61430 fidl::encoding::EmptyStruct,
61431 fidl_fuchsia_posix::Errno,
61432 >>(
61433 result,
61434 self.tx_id,
61435 0x6e387a0def00821,
61436 fidl::encoding::DynamicFlags::empty(),
61437 )
61438 }
61439}
61440
61441#[must_use = "FIDL methods require a response to be sent"]
61442#[derive(Debug)]
61443pub struct StreamSocketGetBindToInterfaceIndexResponder {
61444 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61445 tx_id: u32,
61446}
61447
61448impl std::ops::Drop for StreamSocketGetBindToInterfaceIndexResponder {
61452 fn drop(&mut self) {
61453 self.control_handle.shutdown();
61454 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61456 }
61457}
61458
61459impl fidl::endpoints::Responder for StreamSocketGetBindToInterfaceIndexResponder {
61460 type ControlHandle = StreamSocketControlHandle;
61461
61462 fn control_handle(&self) -> &StreamSocketControlHandle {
61463 &self.control_handle
61464 }
61465
61466 fn drop_without_shutdown(mut self) {
61467 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61469 std::mem::forget(self);
61471 }
61472}
61473
61474impl StreamSocketGetBindToInterfaceIndexResponder {
61475 pub fn send(
61479 self,
61480 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
61481 ) -> Result<(), fidl::Error> {
61482 let _result = self.send_raw(result);
61483 if _result.is_err() {
61484 self.control_handle.shutdown();
61485 }
61486 self.drop_without_shutdown();
61487 _result
61488 }
61489
61490 pub fn send_no_shutdown_on_err(
61492 self,
61493 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
61494 ) -> Result<(), fidl::Error> {
61495 let _result = self.send_raw(result);
61496 self.drop_without_shutdown();
61497 _result
61498 }
61499
61500 fn send_raw(
61501 &self,
61502 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
61503 ) -> Result<(), fidl::Error> {
61504 self.control_handle.inner.send::<fidl::encoding::ResultType<
61505 BaseSocketGetBindToInterfaceIndexResponse,
61506 fidl_fuchsia_posix::Errno,
61507 >>(
61508 result.map(|value| (value,)),
61509 self.tx_id,
61510 0x59c31dd3e3078295,
61511 fidl::encoding::DynamicFlags::empty(),
61512 )
61513 }
61514}
61515
61516#[must_use = "FIDL methods require a response to be sent"]
61517#[derive(Debug)]
61518pub struct StreamSocketSetTimestampResponder {
61519 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61520 tx_id: u32,
61521}
61522
61523impl std::ops::Drop for StreamSocketSetTimestampResponder {
61527 fn drop(&mut self) {
61528 self.control_handle.shutdown();
61529 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61531 }
61532}
61533
61534impl fidl::endpoints::Responder for StreamSocketSetTimestampResponder {
61535 type ControlHandle = StreamSocketControlHandle;
61536
61537 fn control_handle(&self) -> &StreamSocketControlHandle {
61538 &self.control_handle
61539 }
61540
61541 fn drop_without_shutdown(mut self) {
61542 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61544 std::mem::forget(self);
61546 }
61547}
61548
61549impl StreamSocketSetTimestampResponder {
61550 pub fn send(
61554 self,
61555 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61556 ) -> Result<(), fidl::Error> {
61557 let _result = self.send_raw(result);
61558 if _result.is_err() {
61559 self.control_handle.shutdown();
61560 }
61561 self.drop_without_shutdown();
61562 _result
61563 }
61564
61565 pub fn send_no_shutdown_on_err(
61567 self,
61568 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61569 ) -> Result<(), fidl::Error> {
61570 let _result = self.send_raw(result);
61571 self.drop_without_shutdown();
61572 _result
61573 }
61574
61575 fn send_raw(
61576 &self,
61577 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61578 ) -> Result<(), fidl::Error> {
61579 self.control_handle.inner.send::<fidl::encoding::ResultType<
61580 fidl::encoding::EmptyStruct,
61581 fidl_fuchsia_posix::Errno,
61582 >>(
61583 result,
61584 self.tx_id,
61585 0x285d6516c263d839,
61586 fidl::encoding::DynamicFlags::empty(),
61587 )
61588 }
61589}
61590
61591#[must_use = "FIDL methods require a response to be sent"]
61592#[derive(Debug)]
61593pub struct StreamSocketGetTimestampResponder {
61594 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61595 tx_id: u32,
61596}
61597
61598impl std::ops::Drop for StreamSocketGetTimestampResponder {
61602 fn drop(&mut self) {
61603 self.control_handle.shutdown();
61604 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61606 }
61607}
61608
61609impl fidl::endpoints::Responder for StreamSocketGetTimestampResponder {
61610 type ControlHandle = StreamSocketControlHandle;
61611
61612 fn control_handle(&self) -> &StreamSocketControlHandle {
61613 &self.control_handle
61614 }
61615
61616 fn drop_without_shutdown(mut self) {
61617 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61619 std::mem::forget(self);
61621 }
61622}
61623
61624impl StreamSocketGetTimestampResponder {
61625 pub fn send(
61629 self,
61630 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
61631 ) -> Result<(), fidl::Error> {
61632 let _result = self.send_raw(result);
61633 if _result.is_err() {
61634 self.control_handle.shutdown();
61635 }
61636 self.drop_without_shutdown();
61637 _result
61638 }
61639
61640 pub fn send_no_shutdown_on_err(
61642 self,
61643 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
61644 ) -> Result<(), fidl::Error> {
61645 let _result = self.send_raw(result);
61646 self.drop_without_shutdown();
61647 _result
61648 }
61649
61650 fn send_raw(
61651 &self,
61652 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
61653 ) -> Result<(), fidl::Error> {
61654 self.control_handle.inner.send::<fidl::encoding::ResultType<
61655 BaseSocketGetTimestampResponse,
61656 fidl_fuchsia_posix::Errno,
61657 >>(
61658 result.map(|value| (value,)),
61659 self.tx_id,
61660 0x49f2fffbbcc2bd27,
61661 fidl::encoding::DynamicFlags::empty(),
61662 )
61663 }
61664}
61665
61666#[must_use = "FIDL methods require a response to be sent"]
61667#[derive(Debug)]
61668pub struct StreamSocketSetMarkResponder {
61669 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61670 tx_id: u32,
61671}
61672
61673impl std::ops::Drop for StreamSocketSetMarkResponder {
61677 fn drop(&mut self) {
61678 self.control_handle.shutdown();
61679 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61681 }
61682}
61683
61684impl fidl::endpoints::Responder for StreamSocketSetMarkResponder {
61685 type ControlHandle = StreamSocketControlHandle;
61686
61687 fn control_handle(&self) -> &StreamSocketControlHandle {
61688 &self.control_handle
61689 }
61690
61691 fn drop_without_shutdown(mut self) {
61692 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61694 std::mem::forget(self);
61696 }
61697}
61698
61699impl StreamSocketSetMarkResponder {
61700 pub fn send(
61704 self,
61705 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61706 ) -> Result<(), fidl::Error> {
61707 let _result = self.send_raw(result);
61708 if _result.is_err() {
61709 self.control_handle.shutdown();
61710 }
61711 self.drop_without_shutdown();
61712 _result
61713 }
61714
61715 pub fn send_no_shutdown_on_err(
61717 self,
61718 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61719 ) -> Result<(), fidl::Error> {
61720 let _result = self.send_raw(result);
61721 self.drop_without_shutdown();
61722 _result
61723 }
61724
61725 fn send_raw(
61726 &self,
61727 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61728 ) -> Result<(), fidl::Error> {
61729 self.control_handle.inner.send::<fidl::encoding::ResultType<
61730 fidl::encoding::EmptyStruct,
61731 fidl_fuchsia_posix::Errno,
61732 >>(
61733 result,
61734 self.tx_id,
61735 0x6ead6de09f653236,
61736 fidl::encoding::DynamicFlags::empty(),
61737 )
61738 }
61739}
61740
61741#[must_use = "FIDL methods require a response to be sent"]
61742#[derive(Debug)]
61743pub struct StreamSocketGetMarkResponder {
61744 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61745 tx_id: u32,
61746}
61747
61748impl std::ops::Drop for StreamSocketGetMarkResponder {
61752 fn drop(&mut self) {
61753 self.control_handle.shutdown();
61754 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61756 }
61757}
61758
61759impl fidl::endpoints::Responder for StreamSocketGetMarkResponder {
61760 type ControlHandle = StreamSocketControlHandle;
61761
61762 fn control_handle(&self) -> &StreamSocketControlHandle {
61763 &self.control_handle
61764 }
61765
61766 fn drop_without_shutdown(mut self) {
61767 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61769 std::mem::forget(self);
61771 }
61772}
61773
61774impl StreamSocketGetMarkResponder {
61775 pub fn send(
61779 self,
61780 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
61781 ) -> Result<(), fidl::Error> {
61782 let _result = self.send_raw(result);
61783 if _result.is_err() {
61784 self.control_handle.shutdown();
61785 }
61786 self.drop_without_shutdown();
61787 _result
61788 }
61789
61790 pub fn send_no_shutdown_on_err(
61792 self,
61793 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
61794 ) -> Result<(), fidl::Error> {
61795 let _result = self.send_raw(result);
61796 self.drop_without_shutdown();
61797 _result
61798 }
61799
61800 fn send_raw(
61801 &self,
61802 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
61803 ) -> Result<(), fidl::Error> {
61804 self.control_handle.inner.send::<fidl::encoding::ResultType<
61805 BaseSocketGetMarkResponse,
61806 fidl_fuchsia_posix::Errno,
61807 >>(
61808 result.map(|mark| (mark,)),
61809 self.tx_id,
61810 0x57a2752c61d93d47,
61811 fidl::encoding::DynamicFlags::empty(),
61812 )
61813 }
61814}
61815
61816#[must_use = "FIDL methods require a response to be sent"]
61817#[derive(Debug)]
61818pub struct StreamSocketBindResponder {
61819 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61820 tx_id: u32,
61821}
61822
61823impl std::ops::Drop for StreamSocketBindResponder {
61827 fn drop(&mut self) {
61828 self.control_handle.shutdown();
61829 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61831 }
61832}
61833
61834impl fidl::endpoints::Responder for StreamSocketBindResponder {
61835 type ControlHandle = StreamSocketControlHandle;
61836
61837 fn control_handle(&self) -> &StreamSocketControlHandle {
61838 &self.control_handle
61839 }
61840
61841 fn drop_without_shutdown(mut self) {
61842 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61844 std::mem::forget(self);
61846 }
61847}
61848
61849impl StreamSocketBindResponder {
61850 pub fn send(
61854 self,
61855 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61856 ) -> Result<(), fidl::Error> {
61857 let _result = self.send_raw(result);
61858 if _result.is_err() {
61859 self.control_handle.shutdown();
61860 }
61861 self.drop_without_shutdown();
61862 _result
61863 }
61864
61865 pub fn send_no_shutdown_on_err(
61867 self,
61868 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61869 ) -> Result<(), fidl::Error> {
61870 let _result = self.send_raw(result);
61871 self.drop_without_shutdown();
61872 _result
61873 }
61874
61875 fn send_raw(
61876 &self,
61877 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61878 ) -> Result<(), fidl::Error> {
61879 self.control_handle.inner.send::<fidl::encoding::ResultType<
61880 fidl::encoding::EmptyStruct,
61881 fidl_fuchsia_posix::Errno,
61882 >>(
61883 result,
61884 self.tx_id,
61885 0x4bc6400ae92125d,
61886 fidl::encoding::DynamicFlags::empty(),
61887 )
61888 }
61889}
61890
61891#[must_use = "FIDL methods require a response to be sent"]
61892#[derive(Debug)]
61893pub struct StreamSocketConnectResponder {
61894 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61895 tx_id: u32,
61896}
61897
61898impl std::ops::Drop for StreamSocketConnectResponder {
61902 fn drop(&mut self) {
61903 self.control_handle.shutdown();
61904 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61906 }
61907}
61908
61909impl fidl::endpoints::Responder for StreamSocketConnectResponder {
61910 type ControlHandle = StreamSocketControlHandle;
61911
61912 fn control_handle(&self) -> &StreamSocketControlHandle {
61913 &self.control_handle
61914 }
61915
61916 fn drop_without_shutdown(mut self) {
61917 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61919 std::mem::forget(self);
61921 }
61922}
61923
61924impl StreamSocketConnectResponder {
61925 pub fn send(
61929 self,
61930 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61931 ) -> Result<(), fidl::Error> {
61932 let _result = self.send_raw(result);
61933 if _result.is_err() {
61934 self.control_handle.shutdown();
61935 }
61936 self.drop_without_shutdown();
61937 _result
61938 }
61939
61940 pub fn send_no_shutdown_on_err(
61942 self,
61943 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61944 ) -> Result<(), fidl::Error> {
61945 let _result = self.send_raw(result);
61946 self.drop_without_shutdown();
61947 _result
61948 }
61949
61950 fn send_raw(
61951 &self,
61952 mut result: Result<(), fidl_fuchsia_posix::Errno>,
61953 ) -> Result<(), fidl::Error> {
61954 self.control_handle.inner.send::<fidl::encoding::ResultType<
61955 fidl::encoding::EmptyStruct,
61956 fidl_fuchsia_posix::Errno,
61957 >>(
61958 result,
61959 self.tx_id,
61960 0x5f05f19bfdd38871,
61961 fidl::encoding::DynamicFlags::empty(),
61962 )
61963 }
61964}
61965
61966#[must_use = "FIDL methods require a response to be sent"]
61967#[derive(Debug)]
61968pub struct StreamSocketDisconnectResponder {
61969 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61970 tx_id: u32,
61971}
61972
61973impl std::ops::Drop for StreamSocketDisconnectResponder {
61977 fn drop(&mut self) {
61978 self.control_handle.shutdown();
61979 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61981 }
61982}
61983
61984impl fidl::endpoints::Responder for StreamSocketDisconnectResponder {
61985 type ControlHandle = StreamSocketControlHandle;
61986
61987 fn control_handle(&self) -> &StreamSocketControlHandle {
61988 &self.control_handle
61989 }
61990
61991 fn drop_without_shutdown(mut self) {
61992 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61994 std::mem::forget(self);
61996 }
61997}
61998
61999impl StreamSocketDisconnectResponder {
62000 pub fn send(
62004 self,
62005 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62006 ) -> Result<(), fidl::Error> {
62007 let _result = self.send_raw(result);
62008 if _result.is_err() {
62009 self.control_handle.shutdown();
62010 }
62011 self.drop_without_shutdown();
62012 _result
62013 }
62014
62015 pub fn send_no_shutdown_on_err(
62017 self,
62018 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62019 ) -> Result<(), fidl::Error> {
62020 let _result = self.send_raw(result);
62021 self.drop_without_shutdown();
62022 _result
62023 }
62024
62025 fn send_raw(
62026 &self,
62027 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62028 ) -> Result<(), fidl::Error> {
62029 self.control_handle.inner.send::<fidl::encoding::ResultType<
62030 fidl::encoding::EmptyStruct,
62031 fidl_fuchsia_posix::Errno,
62032 >>(
62033 result,
62034 self.tx_id,
62035 0x74e63b91f7b29b2,
62036 fidl::encoding::DynamicFlags::empty(),
62037 )
62038 }
62039}
62040
62041#[must_use = "FIDL methods require a response to be sent"]
62042#[derive(Debug)]
62043pub struct StreamSocketGetSockNameResponder {
62044 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62045 tx_id: u32,
62046}
62047
62048impl std::ops::Drop for StreamSocketGetSockNameResponder {
62052 fn drop(&mut self) {
62053 self.control_handle.shutdown();
62054 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62056 }
62057}
62058
62059impl fidl::endpoints::Responder for StreamSocketGetSockNameResponder {
62060 type ControlHandle = StreamSocketControlHandle;
62061
62062 fn control_handle(&self) -> &StreamSocketControlHandle {
62063 &self.control_handle
62064 }
62065
62066 fn drop_without_shutdown(mut self) {
62067 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62069 std::mem::forget(self);
62071 }
62072}
62073
62074impl StreamSocketGetSockNameResponder {
62075 pub fn send(
62079 self,
62080 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
62081 ) -> Result<(), fidl::Error> {
62082 let _result = self.send_raw(result);
62083 if _result.is_err() {
62084 self.control_handle.shutdown();
62085 }
62086 self.drop_without_shutdown();
62087 _result
62088 }
62089
62090 pub fn send_no_shutdown_on_err(
62092 self,
62093 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
62094 ) -> Result<(), fidl::Error> {
62095 let _result = self.send_raw(result);
62096 self.drop_without_shutdown();
62097 _result
62098 }
62099
62100 fn send_raw(
62101 &self,
62102 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
62103 ) -> Result<(), fidl::Error> {
62104 self.control_handle.inner.send::<fidl::encoding::ResultType<
62105 BaseNetworkSocketGetSockNameResponse,
62106 fidl_fuchsia_posix::Errno,
62107 >>(
62108 result.map(|addr| (addr,)),
62109 self.tx_id,
62110 0x475f23f84a1a4f85,
62111 fidl::encoding::DynamicFlags::empty(),
62112 )
62113 }
62114}
62115
62116#[must_use = "FIDL methods require a response to be sent"]
62117#[derive(Debug)]
62118pub struct StreamSocketGetPeerNameResponder {
62119 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62120 tx_id: u32,
62121}
62122
62123impl std::ops::Drop for StreamSocketGetPeerNameResponder {
62127 fn drop(&mut self) {
62128 self.control_handle.shutdown();
62129 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62131 }
62132}
62133
62134impl fidl::endpoints::Responder for StreamSocketGetPeerNameResponder {
62135 type ControlHandle = StreamSocketControlHandle;
62136
62137 fn control_handle(&self) -> &StreamSocketControlHandle {
62138 &self.control_handle
62139 }
62140
62141 fn drop_without_shutdown(mut self) {
62142 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62144 std::mem::forget(self);
62146 }
62147}
62148
62149impl StreamSocketGetPeerNameResponder {
62150 pub fn send(
62154 self,
62155 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
62156 ) -> Result<(), fidl::Error> {
62157 let _result = self.send_raw(result);
62158 if _result.is_err() {
62159 self.control_handle.shutdown();
62160 }
62161 self.drop_without_shutdown();
62162 _result
62163 }
62164
62165 pub fn send_no_shutdown_on_err(
62167 self,
62168 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
62169 ) -> Result<(), fidl::Error> {
62170 let _result = self.send_raw(result);
62171 self.drop_without_shutdown();
62172 _result
62173 }
62174
62175 fn send_raw(
62176 &self,
62177 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
62178 ) -> Result<(), fidl::Error> {
62179 self.control_handle.inner.send::<fidl::encoding::ResultType<
62180 BaseNetworkSocketGetPeerNameResponse,
62181 fidl_fuchsia_posix::Errno,
62182 >>(
62183 result.map(|addr| (addr,)),
62184 self.tx_id,
62185 0x1ffecf4bd5b6432e,
62186 fidl::encoding::DynamicFlags::empty(),
62187 )
62188 }
62189}
62190
62191#[must_use = "FIDL methods require a response to be sent"]
62192#[derive(Debug)]
62193pub struct StreamSocketShutdownResponder {
62194 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62195 tx_id: u32,
62196}
62197
62198impl std::ops::Drop for StreamSocketShutdownResponder {
62202 fn drop(&mut self) {
62203 self.control_handle.shutdown();
62204 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62206 }
62207}
62208
62209impl fidl::endpoints::Responder for StreamSocketShutdownResponder {
62210 type ControlHandle = StreamSocketControlHandle;
62211
62212 fn control_handle(&self) -> &StreamSocketControlHandle {
62213 &self.control_handle
62214 }
62215
62216 fn drop_without_shutdown(mut self) {
62217 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62219 std::mem::forget(self);
62221 }
62222}
62223
62224impl StreamSocketShutdownResponder {
62225 pub fn send(
62229 self,
62230 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62231 ) -> Result<(), fidl::Error> {
62232 let _result = self.send_raw(result);
62233 if _result.is_err() {
62234 self.control_handle.shutdown();
62235 }
62236 self.drop_without_shutdown();
62237 _result
62238 }
62239
62240 pub fn send_no_shutdown_on_err(
62242 self,
62243 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62244 ) -> Result<(), fidl::Error> {
62245 let _result = self.send_raw(result);
62246 self.drop_without_shutdown();
62247 _result
62248 }
62249
62250 fn send_raw(
62251 &self,
62252 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62253 ) -> Result<(), fidl::Error> {
62254 self.control_handle.inner.send::<fidl::encoding::ResultType<
62255 fidl::encoding::EmptyStruct,
62256 fidl_fuchsia_posix::Errno,
62257 >>(
62258 result,
62259 self.tx_id,
62260 0x247f38b6db68c336,
62261 fidl::encoding::DynamicFlags::empty(),
62262 )
62263 }
62264}
62265
62266#[must_use = "FIDL methods require a response to be sent"]
62267#[derive(Debug)]
62268pub struct StreamSocketSetIpTypeOfServiceResponder {
62269 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62270 tx_id: u32,
62271}
62272
62273impl std::ops::Drop for StreamSocketSetIpTypeOfServiceResponder {
62277 fn drop(&mut self) {
62278 self.control_handle.shutdown();
62279 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62281 }
62282}
62283
62284impl fidl::endpoints::Responder for StreamSocketSetIpTypeOfServiceResponder {
62285 type ControlHandle = StreamSocketControlHandle;
62286
62287 fn control_handle(&self) -> &StreamSocketControlHandle {
62288 &self.control_handle
62289 }
62290
62291 fn drop_without_shutdown(mut self) {
62292 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62294 std::mem::forget(self);
62296 }
62297}
62298
62299impl StreamSocketSetIpTypeOfServiceResponder {
62300 pub fn send(
62304 self,
62305 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62306 ) -> Result<(), fidl::Error> {
62307 let _result = self.send_raw(result);
62308 if _result.is_err() {
62309 self.control_handle.shutdown();
62310 }
62311 self.drop_without_shutdown();
62312 _result
62313 }
62314
62315 pub fn send_no_shutdown_on_err(
62317 self,
62318 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62319 ) -> Result<(), fidl::Error> {
62320 let _result = self.send_raw(result);
62321 self.drop_without_shutdown();
62322 _result
62323 }
62324
62325 fn send_raw(
62326 &self,
62327 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62328 ) -> Result<(), fidl::Error> {
62329 self.control_handle.inner.send::<fidl::encoding::ResultType<
62330 fidl::encoding::EmptyStruct,
62331 fidl_fuchsia_posix::Errno,
62332 >>(
62333 result,
62334 self.tx_id,
62335 0x995c600475b6d46,
62336 fidl::encoding::DynamicFlags::empty(),
62337 )
62338 }
62339}
62340
62341#[must_use = "FIDL methods require a response to be sent"]
62342#[derive(Debug)]
62343pub struct StreamSocketGetIpTypeOfServiceResponder {
62344 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62345 tx_id: u32,
62346}
62347
62348impl std::ops::Drop for StreamSocketGetIpTypeOfServiceResponder {
62352 fn drop(&mut self) {
62353 self.control_handle.shutdown();
62354 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62356 }
62357}
62358
62359impl fidl::endpoints::Responder for StreamSocketGetIpTypeOfServiceResponder {
62360 type ControlHandle = StreamSocketControlHandle;
62361
62362 fn control_handle(&self) -> &StreamSocketControlHandle {
62363 &self.control_handle
62364 }
62365
62366 fn drop_without_shutdown(mut self) {
62367 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62369 std::mem::forget(self);
62371 }
62372}
62373
62374impl StreamSocketGetIpTypeOfServiceResponder {
62375 pub fn send(
62379 self,
62380 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
62381 ) -> Result<(), fidl::Error> {
62382 let _result = self.send_raw(result);
62383 if _result.is_err() {
62384 self.control_handle.shutdown();
62385 }
62386 self.drop_without_shutdown();
62387 _result
62388 }
62389
62390 pub fn send_no_shutdown_on_err(
62392 self,
62393 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
62394 ) -> Result<(), fidl::Error> {
62395 let _result = self.send_raw(result);
62396 self.drop_without_shutdown();
62397 _result
62398 }
62399
62400 fn send_raw(
62401 &self,
62402 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
62403 ) -> Result<(), fidl::Error> {
62404 self.control_handle.inner.send::<fidl::encoding::ResultType<
62405 BaseNetworkSocketGetIpTypeOfServiceResponse,
62406 fidl_fuchsia_posix::Errno,
62407 >>(
62408 result.map(|value| (value,)),
62409 self.tx_id,
62410 0x3814a04259f75fcb,
62411 fidl::encoding::DynamicFlags::empty(),
62412 )
62413 }
62414}
62415
62416#[must_use = "FIDL methods require a response to be sent"]
62417#[derive(Debug)]
62418pub struct StreamSocketSetIpTtlResponder {
62419 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62420 tx_id: u32,
62421}
62422
62423impl std::ops::Drop for StreamSocketSetIpTtlResponder {
62427 fn drop(&mut self) {
62428 self.control_handle.shutdown();
62429 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62431 }
62432}
62433
62434impl fidl::endpoints::Responder for StreamSocketSetIpTtlResponder {
62435 type ControlHandle = StreamSocketControlHandle;
62436
62437 fn control_handle(&self) -> &StreamSocketControlHandle {
62438 &self.control_handle
62439 }
62440
62441 fn drop_without_shutdown(mut self) {
62442 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62444 std::mem::forget(self);
62446 }
62447}
62448
62449impl StreamSocketSetIpTtlResponder {
62450 pub fn send(
62454 self,
62455 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62456 ) -> Result<(), fidl::Error> {
62457 let _result = self.send_raw(result);
62458 if _result.is_err() {
62459 self.control_handle.shutdown();
62460 }
62461 self.drop_without_shutdown();
62462 _result
62463 }
62464
62465 pub fn send_no_shutdown_on_err(
62467 self,
62468 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62469 ) -> Result<(), fidl::Error> {
62470 let _result = self.send_raw(result);
62471 self.drop_without_shutdown();
62472 _result
62473 }
62474
62475 fn send_raw(
62476 &self,
62477 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62478 ) -> Result<(), fidl::Error> {
62479 self.control_handle.inner.send::<fidl::encoding::ResultType<
62480 fidl::encoding::EmptyStruct,
62481 fidl_fuchsia_posix::Errno,
62482 >>(
62483 result,
62484 self.tx_id,
62485 0x29e2424b433ae1ef,
62486 fidl::encoding::DynamicFlags::empty(),
62487 )
62488 }
62489}
62490
62491#[must_use = "FIDL methods require a response to be sent"]
62492#[derive(Debug)]
62493pub struct StreamSocketGetIpTtlResponder {
62494 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62495 tx_id: u32,
62496}
62497
62498impl std::ops::Drop for StreamSocketGetIpTtlResponder {
62502 fn drop(&mut self) {
62503 self.control_handle.shutdown();
62504 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62506 }
62507}
62508
62509impl fidl::endpoints::Responder for StreamSocketGetIpTtlResponder {
62510 type ControlHandle = StreamSocketControlHandle;
62511
62512 fn control_handle(&self) -> &StreamSocketControlHandle {
62513 &self.control_handle
62514 }
62515
62516 fn drop_without_shutdown(mut self) {
62517 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62519 std::mem::forget(self);
62521 }
62522}
62523
62524impl StreamSocketGetIpTtlResponder {
62525 pub fn send(
62529 self,
62530 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
62531 ) -> Result<(), fidl::Error> {
62532 let _result = self.send_raw(result);
62533 if _result.is_err() {
62534 self.control_handle.shutdown();
62535 }
62536 self.drop_without_shutdown();
62537 _result
62538 }
62539
62540 pub fn send_no_shutdown_on_err(
62542 self,
62543 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
62544 ) -> Result<(), fidl::Error> {
62545 let _result = self.send_raw(result);
62546 self.drop_without_shutdown();
62547 _result
62548 }
62549
62550 fn send_raw(
62551 &self,
62552 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
62553 ) -> Result<(), fidl::Error> {
62554 self.control_handle.inner.send::<fidl::encoding::ResultType<
62555 BaseNetworkSocketGetIpTtlResponse,
62556 fidl_fuchsia_posix::Errno,
62557 >>(
62558 result.map(|value| (value,)),
62559 self.tx_id,
62560 0x47e47fa1f24da471,
62561 fidl::encoding::DynamicFlags::empty(),
62562 )
62563 }
62564}
62565
62566#[must_use = "FIDL methods require a response to be sent"]
62567#[derive(Debug)]
62568pub struct StreamSocketSetIpPacketInfoResponder {
62569 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62570 tx_id: u32,
62571}
62572
62573impl std::ops::Drop for StreamSocketSetIpPacketInfoResponder {
62577 fn drop(&mut self) {
62578 self.control_handle.shutdown();
62579 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62581 }
62582}
62583
62584impl fidl::endpoints::Responder for StreamSocketSetIpPacketInfoResponder {
62585 type ControlHandle = StreamSocketControlHandle;
62586
62587 fn control_handle(&self) -> &StreamSocketControlHandle {
62588 &self.control_handle
62589 }
62590
62591 fn drop_without_shutdown(mut self) {
62592 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62594 std::mem::forget(self);
62596 }
62597}
62598
62599impl StreamSocketSetIpPacketInfoResponder {
62600 pub fn send(
62604 self,
62605 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62606 ) -> Result<(), fidl::Error> {
62607 let _result = self.send_raw(result);
62608 if _result.is_err() {
62609 self.control_handle.shutdown();
62610 }
62611 self.drop_without_shutdown();
62612 _result
62613 }
62614
62615 pub fn send_no_shutdown_on_err(
62617 self,
62618 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62619 ) -> Result<(), fidl::Error> {
62620 let _result = self.send_raw(result);
62621 self.drop_without_shutdown();
62622 _result
62623 }
62624
62625 fn send_raw(
62626 &self,
62627 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62628 ) -> Result<(), fidl::Error> {
62629 self.control_handle.inner.send::<fidl::encoding::ResultType<
62630 fidl::encoding::EmptyStruct,
62631 fidl_fuchsia_posix::Errno,
62632 >>(
62633 result,
62634 self.tx_id,
62635 0x392d16bee20c0e16,
62636 fidl::encoding::DynamicFlags::empty(),
62637 )
62638 }
62639}
62640
62641#[must_use = "FIDL methods require a response to be sent"]
62642#[derive(Debug)]
62643pub struct StreamSocketGetIpPacketInfoResponder {
62644 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62645 tx_id: u32,
62646}
62647
62648impl std::ops::Drop for StreamSocketGetIpPacketInfoResponder {
62652 fn drop(&mut self) {
62653 self.control_handle.shutdown();
62654 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62656 }
62657}
62658
62659impl fidl::endpoints::Responder for StreamSocketGetIpPacketInfoResponder {
62660 type ControlHandle = StreamSocketControlHandle;
62661
62662 fn control_handle(&self) -> &StreamSocketControlHandle {
62663 &self.control_handle
62664 }
62665
62666 fn drop_without_shutdown(mut self) {
62667 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62669 std::mem::forget(self);
62671 }
62672}
62673
62674impl StreamSocketGetIpPacketInfoResponder {
62675 pub fn send(
62679 self,
62680 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
62681 ) -> Result<(), fidl::Error> {
62682 let _result = self.send_raw(result);
62683 if _result.is_err() {
62684 self.control_handle.shutdown();
62685 }
62686 self.drop_without_shutdown();
62687 _result
62688 }
62689
62690 pub fn send_no_shutdown_on_err(
62692 self,
62693 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
62694 ) -> Result<(), fidl::Error> {
62695 let _result = self.send_raw(result);
62696 self.drop_without_shutdown();
62697 _result
62698 }
62699
62700 fn send_raw(
62701 &self,
62702 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
62703 ) -> Result<(), fidl::Error> {
62704 self.control_handle.inner.send::<fidl::encoding::ResultType<
62705 BaseNetworkSocketGetIpPacketInfoResponse,
62706 fidl_fuchsia_posix::Errno,
62707 >>(
62708 result.map(|value| (value,)),
62709 self.tx_id,
62710 0x54b505f242280740,
62711 fidl::encoding::DynamicFlags::empty(),
62712 )
62713 }
62714}
62715
62716#[must_use = "FIDL methods require a response to be sent"]
62717#[derive(Debug)]
62718pub struct StreamSocketSetIpReceiveTypeOfServiceResponder {
62719 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62720 tx_id: u32,
62721}
62722
62723impl std::ops::Drop for StreamSocketSetIpReceiveTypeOfServiceResponder {
62727 fn drop(&mut self) {
62728 self.control_handle.shutdown();
62729 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62731 }
62732}
62733
62734impl fidl::endpoints::Responder for StreamSocketSetIpReceiveTypeOfServiceResponder {
62735 type ControlHandle = StreamSocketControlHandle;
62736
62737 fn control_handle(&self) -> &StreamSocketControlHandle {
62738 &self.control_handle
62739 }
62740
62741 fn drop_without_shutdown(mut self) {
62742 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62744 std::mem::forget(self);
62746 }
62747}
62748
62749impl StreamSocketSetIpReceiveTypeOfServiceResponder {
62750 pub fn send(
62754 self,
62755 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62756 ) -> Result<(), fidl::Error> {
62757 let _result = self.send_raw(result);
62758 if _result.is_err() {
62759 self.control_handle.shutdown();
62760 }
62761 self.drop_without_shutdown();
62762 _result
62763 }
62764
62765 pub fn send_no_shutdown_on_err(
62767 self,
62768 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62769 ) -> Result<(), fidl::Error> {
62770 let _result = self.send_raw(result);
62771 self.drop_without_shutdown();
62772 _result
62773 }
62774
62775 fn send_raw(
62776 &self,
62777 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62778 ) -> Result<(), fidl::Error> {
62779 self.control_handle.inner.send::<fidl::encoding::ResultType<
62780 fidl::encoding::EmptyStruct,
62781 fidl_fuchsia_posix::Errno,
62782 >>(
62783 result,
62784 self.tx_id,
62785 0x6c4f6714995f84ef,
62786 fidl::encoding::DynamicFlags::empty(),
62787 )
62788 }
62789}
62790
62791#[must_use = "FIDL methods require a response to be sent"]
62792#[derive(Debug)]
62793pub struct StreamSocketGetIpReceiveTypeOfServiceResponder {
62794 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62795 tx_id: u32,
62796}
62797
62798impl std::ops::Drop for StreamSocketGetIpReceiveTypeOfServiceResponder {
62802 fn drop(&mut self) {
62803 self.control_handle.shutdown();
62804 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62806 }
62807}
62808
62809impl fidl::endpoints::Responder for StreamSocketGetIpReceiveTypeOfServiceResponder {
62810 type ControlHandle = StreamSocketControlHandle;
62811
62812 fn control_handle(&self) -> &StreamSocketControlHandle {
62813 &self.control_handle
62814 }
62815
62816 fn drop_without_shutdown(mut self) {
62817 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62819 std::mem::forget(self);
62821 }
62822}
62823
62824impl StreamSocketGetIpReceiveTypeOfServiceResponder {
62825 pub fn send(
62829 self,
62830 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
62831 ) -> Result<(), fidl::Error> {
62832 let _result = self.send_raw(result);
62833 if _result.is_err() {
62834 self.control_handle.shutdown();
62835 }
62836 self.drop_without_shutdown();
62837 _result
62838 }
62839
62840 pub fn send_no_shutdown_on_err(
62842 self,
62843 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
62844 ) -> Result<(), fidl::Error> {
62845 let _result = self.send_raw(result);
62846 self.drop_without_shutdown();
62847 _result
62848 }
62849
62850 fn send_raw(
62851 &self,
62852 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
62853 ) -> Result<(), fidl::Error> {
62854 self.control_handle.inner.send::<fidl::encoding::ResultType<
62855 BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
62856 fidl_fuchsia_posix::Errno,
62857 >>(
62858 result.map(|value| (value,)),
62859 self.tx_id,
62860 0x4158ba7dc2795960,
62861 fidl::encoding::DynamicFlags::empty(),
62862 )
62863 }
62864}
62865
62866#[must_use = "FIDL methods require a response to be sent"]
62867#[derive(Debug)]
62868pub struct StreamSocketSetIpReceiveTtlResponder {
62869 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62870 tx_id: u32,
62871}
62872
62873impl std::ops::Drop for StreamSocketSetIpReceiveTtlResponder {
62877 fn drop(&mut self) {
62878 self.control_handle.shutdown();
62879 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62881 }
62882}
62883
62884impl fidl::endpoints::Responder for StreamSocketSetIpReceiveTtlResponder {
62885 type ControlHandle = StreamSocketControlHandle;
62886
62887 fn control_handle(&self) -> &StreamSocketControlHandle {
62888 &self.control_handle
62889 }
62890
62891 fn drop_without_shutdown(mut self) {
62892 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62894 std::mem::forget(self);
62896 }
62897}
62898
62899impl StreamSocketSetIpReceiveTtlResponder {
62900 pub fn send(
62904 self,
62905 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62906 ) -> Result<(), fidl::Error> {
62907 let _result = self.send_raw(result);
62908 if _result.is_err() {
62909 self.control_handle.shutdown();
62910 }
62911 self.drop_without_shutdown();
62912 _result
62913 }
62914
62915 pub fn send_no_shutdown_on_err(
62917 self,
62918 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62919 ) -> Result<(), fidl::Error> {
62920 let _result = self.send_raw(result);
62921 self.drop_without_shutdown();
62922 _result
62923 }
62924
62925 fn send_raw(
62926 &self,
62927 mut result: Result<(), fidl_fuchsia_posix::Errno>,
62928 ) -> Result<(), fidl::Error> {
62929 self.control_handle.inner.send::<fidl::encoding::ResultType<
62930 fidl::encoding::EmptyStruct,
62931 fidl_fuchsia_posix::Errno,
62932 >>(
62933 result,
62934 self.tx_id,
62935 0x46f15be0ce0ab82b,
62936 fidl::encoding::DynamicFlags::empty(),
62937 )
62938 }
62939}
62940
62941#[must_use = "FIDL methods require a response to be sent"]
62942#[derive(Debug)]
62943pub struct StreamSocketGetIpReceiveTtlResponder {
62944 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62945 tx_id: u32,
62946}
62947
62948impl std::ops::Drop for StreamSocketGetIpReceiveTtlResponder {
62952 fn drop(&mut self) {
62953 self.control_handle.shutdown();
62954 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62956 }
62957}
62958
62959impl fidl::endpoints::Responder for StreamSocketGetIpReceiveTtlResponder {
62960 type ControlHandle = StreamSocketControlHandle;
62961
62962 fn control_handle(&self) -> &StreamSocketControlHandle {
62963 &self.control_handle
62964 }
62965
62966 fn drop_without_shutdown(mut self) {
62967 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62969 std::mem::forget(self);
62971 }
62972}
62973
62974impl StreamSocketGetIpReceiveTtlResponder {
62975 pub fn send(
62979 self,
62980 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
62981 ) -> Result<(), fidl::Error> {
62982 let _result = self.send_raw(result);
62983 if _result.is_err() {
62984 self.control_handle.shutdown();
62985 }
62986 self.drop_without_shutdown();
62987 _result
62988 }
62989
62990 pub fn send_no_shutdown_on_err(
62992 self,
62993 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
62994 ) -> Result<(), fidl::Error> {
62995 let _result = self.send_raw(result);
62996 self.drop_without_shutdown();
62997 _result
62998 }
62999
63000 fn send_raw(
63001 &self,
63002 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63003 ) -> Result<(), fidl::Error> {
63004 self.control_handle.inner.send::<fidl::encoding::ResultType<
63005 BaseNetworkSocketGetIpReceiveTtlResponse,
63006 fidl_fuchsia_posix::Errno,
63007 >>(
63008 result.map(|value| (value,)),
63009 self.tx_id,
63010 0x678ddd5a5dfa2eb5,
63011 fidl::encoding::DynamicFlags::empty(),
63012 )
63013 }
63014}
63015
63016#[must_use = "FIDL methods require a response to be sent"]
63017#[derive(Debug)]
63018pub struct StreamSocketSetIpMulticastInterfaceResponder {
63019 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63020 tx_id: u32,
63021}
63022
63023impl std::ops::Drop for StreamSocketSetIpMulticastInterfaceResponder {
63027 fn drop(&mut self) {
63028 self.control_handle.shutdown();
63029 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63031 }
63032}
63033
63034impl fidl::endpoints::Responder for StreamSocketSetIpMulticastInterfaceResponder {
63035 type ControlHandle = StreamSocketControlHandle;
63036
63037 fn control_handle(&self) -> &StreamSocketControlHandle {
63038 &self.control_handle
63039 }
63040
63041 fn drop_without_shutdown(mut self) {
63042 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63044 std::mem::forget(self);
63046 }
63047}
63048
63049impl StreamSocketSetIpMulticastInterfaceResponder {
63050 pub fn send(
63054 self,
63055 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63056 ) -> Result<(), fidl::Error> {
63057 let _result = self.send_raw(result);
63058 if _result.is_err() {
63059 self.control_handle.shutdown();
63060 }
63061 self.drop_without_shutdown();
63062 _result
63063 }
63064
63065 pub fn send_no_shutdown_on_err(
63067 self,
63068 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63069 ) -> Result<(), fidl::Error> {
63070 let _result = self.send_raw(result);
63071 self.drop_without_shutdown();
63072 _result
63073 }
63074
63075 fn send_raw(
63076 &self,
63077 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63078 ) -> Result<(), fidl::Error> {
63079 self.control_handle.inner.send::<fidl::encoding::ResultType<
63080 fidl::encoding::EmptyStruct,
63081 fidl_fuchsia_posix::Errno,
63082 >>(
63083 result,
63084 self.tx_id,
63085 0x752fbfa9b12befe,
63086 fidl::encoding::DynamicFlags::empty(),
63087 )
63088 }
63089}
63090
63091#[must_use = "FIDL methods require a response to be sent"]
63092#[derive(Debug)]
63093pub struct StreamSocketGetIpMulticastInterfaceResponder {
63094 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63095 tx_id: u32,
63096}
63097
63098impl std::ops::Drop for StreamSocketGetIpMulticastInterfaceResponder {
63102 fn drop(&mut self) {
63103 self.control_handle.shutdown();
63104 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63106 }
63107}
63108
63109impl fidl::endpoints::Responder for StreamSocketGetIpMulticastInterfaceResponder {
63110 type ControlHandle = StreamSocketControlHandle;
63111
63112 fn control_handle(&self) -> &StreamSocketControlHandle {
63113 &self.control_handle
63114 }
63115
63116 fn drop_without_shutdown(mut self) {
63117 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63119 std::mem::forget(self);
63121 }
63122}
63123
63124impl StreamSocketGetIpMulticastInterfaceResponder {
63125 pub fn send(
63129 self,
63130 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
63131 ) -> Result<(), fidl::Error> {
63132 let _result = self.send_raw(result);
63133 if _result.is_err() {
63134 self.control_handle.shutdown();
63135 }
63136 self.drop_without_shutdown();
63137 _result
63138 }
63139
63140 pub fn send_no_shutdown_on_err(
63142 self,
63143 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
63144 ) -> Result<(), fidl::Error> {
63145 let _result = self.send_raw(result);
63146 self.drop_without_shutdown();
63147 _result
63148 }
63149
63150 fn send_raw(
63151 &self,
63152 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
63153 ) -> Result<(), fidl::Error> {
63154 self.control_handle.inner.send::<fidl::encoding::ResultType<
63155 BaseNetworkSocketGetIpMulticastInterfaceResponse,
63156 fidl_fuchsia_posix::Errno,
63157 >>(
63158 result.map(|value| (value,)),
63159 self.tx_id,
63160 0x320bd14c4df046c4,
63161 fidl::encoding::DynamicFlags::empty(),
63162 )
63163 }
63164}
63165
63166#[must_use = "FIDL methods require a response to be sent"]
63167#[derive(Debug)]
63168pub struct StreamSocketSetIpMulticastTtlResponder {
63169 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63170 tx_id: u32,
63171}
63172
63173impl std::ops::Drop for StreamSocketSetIpMulticastTtlResponder {
63177 fn drop(&mut self) {
63178 self.control_handle.shutdown();
63179 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63181 }
63182}
63183
63184impl fidl::endpoints::Responder for StreamSocketSetIpMulticastTtlResponder {
63185 type ControlHandle = StreamSocketControlHandle;
63186
63187 fn control_handle(&self) -> &StreamSocketControlHandle {
63188 &self.control_handle
63189 }
63190
63191 fn drop_without_shutdown(mut self) {
63192 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63194 std::mem::forget(self);
63196 }
63197}
63198
63199impl StreamSocketSetIpMulticastTtlResponder {
63200 pub fn send(
63204 self,
63205 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63206 ) -> Result<(), fidl::Error> {
63207 let _result = self.send_raw(result);
63208 if _result.is_err() {
63209 self.control_handle.shutdown();
63210 }
63211 self.drop_without_shutdown();
63212 _result
63213 }
63214
63215 pub fn send_no_shutdown_on_err(
63217 self,
63218 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63219 ) -> Result<(), fidl::Error> {
63220 let _result = self.send_raw(result);
63221 self.drop_without_shutdown();
63222 _result
63223 }
63224
63225 fn send_raw(
63226 &self,
63227 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63228 ) -> Result<(), fidl::Error> {
63229 self.control_handle.inner.send::<fidl::encoding::ResultType<
63230 fidl::encoding::EmptyStruct,
63231 fidl_fuchsia_posix::Errno,
63232 >>(
63233 result,
63234 self.tx_id,
63235 0x63134d53772916a1,
63236 fidl::encoding::DynamicFlags::empty(),
63237 )
63238 }
63239}
63240
63241#[must_use = "FIDL methods require a response to be sent"]
63242#[derive(Debug)]
63243pub struct StreamSocketGetIpMulticastTtlResponder {
63244 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63245 tx_id: u32,
63246}
63247
63248impl std::ops::Drop for StreamSocketGetIpMulticastTtlResponder {
63252 fn drop(&mut self) {
63253 self.control_handle.shutdown();
63254 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63256 }
63257}
63258
63259impl fidl::endpoints::Responder for StreamSocketGetIpMulticastTtlResponder {
63260 type ControlHandle = StreamSocketControlHandle;
63261
63262 fn control_handle(&self) -> &StreamSocketControlHandle {
63263 &self.control_handle
63264 }
63265
63266 fn drop_without_shutdown(mut self) {
63267 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63269 std::mem::forget(self);
63271 }
63272}
63273
63274impl StreamSocketGetIpMulticastTtlResponder {
63275 pub fn send(
63279 self,
63280 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
63281 ) -> Result<(), fidl::Error> {
63282 let _result = self.send_raw(result);
63283 if _result.is_err() {
63284 self.control_handle.shutdown();
63285 }
63286 self.drop_without_shutdown();
63287 _result
63288 }
63289
63290 pub fn send_no_shutdown_on_err(
63292 self,
63293 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
63294 ) -> Result<(), fidl::Error> {
63295 let _result = self.send_raw(result);
63296 self.drop_without_shutdown();
63297 _result
63298 }
63299
63300 fn send_raw(
63301 &self,
63302 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
63303 ) -> Result<(), fidl::Error> {
63304 self.control_handle.inner.send::<fidl::encoding::ResultType<
63305 BaseNetworkSocketGetIpMulticastTtlResponse,
63306 fidl_fuchsia_posix::Errno,
63307 >>(
63308 result.map(|value| (value,)),
63309 self.tx_id,
63310 0x4665cd378f39e1a,
63311 fidl::encoding::DynamicFlags::empty(),
63312 )
63313 }
63314}
63315
63316#[must_use = "FIDL methods require a response to be sent"]
63317#[derive(Debug)]
63318pub struct StreamSocketSetIpMulticastLoopbackResponder {
63319 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63320 tx_id: u32,
63321}
63322
63323impl std::ops::Drop for StreamSocketSetIpMulticastLoopbackResponder {
63327 fn drop(&mut self) {
63328 self.control_handle.shutdown();
63329 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63331 }
63332}
63333
63334impl fidl::endpoints::Responder for StreamSocketSetIpMulticastLoopbackResponder {
63335 type ControlHandle = StreamSocketControlHandle;
63336
63337 fn control_handle(&self) -> &StreamSocketControlHandle {
63338 &self.control_handle
63339 }
63340
63341 fn drop_without_shutdown(mut self) {
63342 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63344 std::mem::forget(self);
63346 }
63347}
63348
63349impl StreamSocketSetIpMulticastLoopbackResponder {
63350 pub fn send(
63354 self,
63355 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63356 ) -> Result<(), fidl::Error> {
63357 let _result = self.send_raw(result);
63358 if _result.is_err() {
63359 self.control_handle.shutdown();
63360 }
63361 self.drop_without_shutdown();
63362 _result
63363 }
63364
63365 pub fn send_no_shutdown_on_err(
63367 self,
63368 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63369 ) -> Result<(), fidl::Error> {
63370 let _result = self.send_raw(result);
63371 self.drop_without_shutdown();
63372 _result
63373 }
63374
63375 fn send_raw(
63376 &self,
63377 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63378 ) -> Result<(), fidl::Error> {
63379 self.control_handle.inner.send::<fidl::encoding::ResultType<
63380 fidl::encoding::EmptyStruct,
63381 fidl_fuchsia_posix::Errno,
63382 >>(
63383 result,
63384 self.tx_id,
63385 0x20c55c11f00943ea,
63386 fidl::encoding::DynamicFlags::empty(),
63387 )
63388 }
63389}
63390
63391#[must_use = "FIDL methods require a response to be sent"]
63392#[derive(Debug)]
63393pub struct StreamSocketGetIpMulticastLoopbackResponder {
63394 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63395 tx_id: u32,
63396}
63397
63398impl std::ops::Drop for StreamSocketGetIpMulticastLoopbackResponder {
63402 fn drop(&mut self) {
63403 self.control_handle.shutdown();
63404 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63406 }
63407}
63408
63409impl fidl::endpoints::Responder for StreamSocketGetIpMulticastLoopbackResponder {
63410 type ControlHandle = StreamSocketControlHandle;
63411
63412 fn control_handle(&self) -> &StreamSocketControlHandle {
63413 &self.control_handle
63414 }
63415
63416 fn drop_without_shutdown(mut self) {
63417 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63419 std::mem::forget(self);
63421 }
63422}
63423
63424impl StreamSocketGetIpMulticastLoopbackResponder {
63425 pub fn send(
63429 self,
63430 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63431 ) -> Result<(), fidl::Error> {
63432 let _result = self.send_raw(result);
63433 if _result.is_err() {
63434 self.control_handle.shutdown();
63435 }
63436 self.drop_without_shutdown();
63437 _result
63438 }
63439
63440 pub fn send_no_shutdown_on_err(
63442 self,
63443 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63444 ) -> Result<(), fidl::Error> {
63445 let _result = self.send_raw(result);
63446 self.drop_without_shutdown();
63447 _result
63448 }
63449
63450 fn send_raw(
63451 &self,
63452 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63453 ) -> Result<(), fidl::Error> {
63454 self.control_handle.inner.send::<fidl::encoding::ResultType<
63455 BaseNetworkSocketGetIpMulticastLoopbackResponse,
63456 fidl_fuchsia_posix::Errno,
63457 >>(
63458 result.map(|value| (value,)),
63459 self.tx_id,
63460 0x3b6b26ff558298f2,
63461 fidl::encoding::DynamicFlags::empty(),
63462 )
63463 }
63464}
63465
63466#[must_use = "FIDL methods require a response to be sent"]
63467#[derive(Debug)]
63468pub struct StreamSocketAddIpMembershipResponder {
63469 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63470 tx_id: u32,
63471}
63472
63473impl std::ops::Drop for StreamSocketAddIpMembershipResponder {
63477 fn drop(&mut self) {
63478 self.control_handle.shutdown();
63479 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63481 }
63482}
63483
63484impl fidl::endpoints::Responder for StreamSocketAddIpMembershipResponder {
63485 type ControlHandle = StreamSocketControlHandle;
63486
63487 fn control_handle(&self) -> &StreamSocketControlHandle {
63488 &self.control_handle
63489 }
63490
63491 fn drop_without_shutdown(mut self) {
63492 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63494 std::mem::forget(self);
63496 }
63497}
63498
63499impl StreamSocketAddIpMembershipResponder {
63500 pub fn send(
63504 self,
63505 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63506 ) -> Result<(), fidl::Error> {
63507 let _result = self.send_raw(result);
63508 if _result.is_err() {
63509 self.control_handle.shutdown();
63510 }
63511 self.drop_without_shutdown();
63512 _result
63513 }
63514
63515 pub fn send_no_shutdown_on_err(
63517 self,
63518 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63519 ) -> Result<(), fidl::Error> {
63520 let _result = self.send_raw(result);
63521 self.drop_without_shutdown();
63522 _result
63523 }
63524
63525 fn send_raw(
63526 &self,
63527 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63528 ) -> Result<(), fidl::Error> {
63529 self.control_handle.inner.send::<fidl::encoding::ResultType<
63530 fidl::encoding::EmptyStruct,
63531 fidl_fuchsia_posix::Errno,
63532 >>(
63533 result,
63534 self.tx_id,
63535 0x76bc7df115a3b4d0,
63536 fidl::encoding::DynamicFlags::empty(),
63537 )
63538 }
63539}
63540
63541#[must_use = "FIDL methods require a response to be sent"]
63542#[derive(Debug)]
63543pub struct StreamSocketDropIpMembershipResponder {
63544 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63545 tx_id: u32,
63546}
63547
63548impl std::ops::Drop for StreamSocketDropIpMembershipResponder {
63552 fn drop(&mut self) {
63553 self.control_handle.shutdown();
63554 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63556 }
63557}
63558
63559impl fidl::endpoints::Responder for StreamSocketDropIpMembershipResponder {
63560 type ControlHandle = StreamSocketControlHandle;
63561
63562 fn control_handle(&self) -> &StreamSocketControlHandle {
63563 &self.control_handle
63564 }
63565
63566 fn drop_without_shutdown(mut self) {
63567 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63569 std::mem::forget(self);
63571 }
63572}
63573
63574impl StreamSocketDropIpMembershipResponder {
63575 pub fn send(
63579 self,
63580 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63581 ) -> Result<(), fidl::Error> {
63582 let _result = self.send_raw(result);
63583 if _result.is_err() {
63584 self.control_handle.shutdown();
63585 }
63586 self.drop_without_shutdown();
63587 _result
63588 }
63589
63590 pub fn send_no_shutdown_on_err(
63592 self,
63593 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63594 ) -> Result<(), fidl::Error> {
63595 let _result = self.send_raw(result);
63596 self.drop_without_shutdown();
63597 _result
63598 }
63599
63600 fn send_raw(
63601 &self,
63602 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63603 ) -> Result<(), fidl::Error> {
63604 self.control_handle.inner.send::<fidl::encoding::ResultType<
63605 fidl::encoding::EmptyStruct,
63606 fidl_fuchsia_posix::Errno,
63607 >>(
63608 result,
63609 self.tx_id,
63610 0x2888f3099188d03,
63611 fidl::encoding::DynamicFlags::empty(),
63612 )
63613 }
63614}
63615
63616#[must_use = "FIDL methods require a response to be sent"]
63617#[derive(Debug)]
63618pub struct StreamSocketSetIpTransparentResponder {
63619 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63620 tx_id: u32,
63621}
63622
63623impl std::ops::Drop for StreamSocketSetIpTransparentResponder {
63627 fn drop(&mut self) {
63628 self.control_handle.shutdown();
63629 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63631 }
63632}
63633
63634impl fidl::endpoints::Responder for StreamSocketSetIpTransparentResponder {
63635 type ControlHandle = StreamSocketControlHandle;
63636
63637 fn control_handle(&self) -> &StreamSocketControlHandle {
63638 &self.control_handle
63639 }
63640
63641 fn drop_without_shutdown(mut self) {
63642 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63644 std::mem::forget(self);
63646 }
63647}
63648
63649impl StreamSocketSetIpTransparentResponder {
63650 pub fn send(
63654 self,
63655 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63656 ) -> Result<(), fidl::Error> {
63657 let _result = self.send_raw(result);
63658 if _result.is_err() {
63659 self.control_handle.shutdown();
63660 }
63661 self.drop_without_shutdown();
63662 _result
63663 }
63664
63665 pub fn send_no_shutdown_on_err(
63667 self,
63668 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63669 ) -> Result<(), fidl::Error> {
63670 let _result = self.send_raw(result);
63671 self.drop_without_shutdown();
63672 _result
63673 }
63674
63675 fn send_raw(
63676 &self,
63677 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63678 ) -> Result<(), fidl::Error> {
63679 self.control_handle.inner.send::<fidl::encoding::ResultType<
63680 fidl::encoding::EmptyStruct,
63681 fidl_fuchsia_posix::Errno,
63682 >>(
63683 result,
63684 self.tx_id,
63685 0x1ae532b0c066e3a0,
63686 fidl::encoding::DynamicFlags::empty(),
63687 )
63688 }
63689}
63690
63691#[must_use = "FIDL methods require a response to be sent"]
63692#[derive(Debug)]
63693pub struct StreamSocketGetIpTransparentResponder {
63694 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63695 tx_id: u32,
63696}
63697
63698impl std::ops::Drop for StreamSocketGetIpTransparentResponder {
63702 fn drop(&mut self) {
63703 self.control_handle.shutdown();
63704 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63706 }
63707}
63708
63709impl fidl::endpoints::Responder for StreamSocketGetIpTransparentResponder {
63710 type ControlHandle = StreamSocketControlHandle;
63711
63712 fn control_handle(&self) -> &StreamSocketControlHandle {
63713 &self.control_handle
63714 }
63715
63716 fn drop_without_shutdown(mut self) {
63717 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63719 std::mem::forget(self);
63721 }
63722}
63723
63724impl StreamSocketGetIpTransparentResponder {
63725 pub fn send(
63729 self,
63730 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63731 ) -> Result<(), fidl::Error> {
63732 let _result = self.send_raw(result);
63733 if _result.is_err() {
63734 self.control_handle.shutdown();
63735 }
63736 self.drop_without_shutdown();
63737 _result
63738 }
63739
63740 pub fn send_no_shutdown_on_err(
63742 self,
63743 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63744 ) -> Result<(), fidl::Error> {
63745 let _result = self.send_raw(result);
63746 self.drop_without_shutdown();
63747 _result
63748 }
63749
63750 fn send_raw(
63751 &self,
63752 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63753 ) -> Result<(), fidl::Error> {
63754 self.control_handle.inner.send::<fidl::encoding::ResultType<
63755 BaseNetworkSocketGetIpTransparentResponse,
63756 fidl_fuchsia_posix::Errno,
63757 >>(
63758 result.map(|value| (value,)),
63759 self.tx_id,
63760 0x51d43695962ebfb5,
63761 fidl::encoding::DynamicFlags::empty(),
63762 )
63763 }
63764}
63765
63766#[must_use = "FIDL methods require a response to be sent"]
63767#[derive(Debug)]
63768pub struct StreamSocketSetIpReceiveOriginalDestinationAddressResponder {
63769 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63770 tx_id: u32,
63771}
63772
63773impl std::ops::Drop for StreamSocketSetIpReceiveOriginalDestinationAddressResponder {
63777 fn drop(&mut self) {
63778 self.control_handle.shutdown();
63779 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63781 }
63782}
63783
63784impl fidl::endpoints::Responder for StreamSocketSetIpReceiveOriginalDestinationAddressResponder {
63785 type ControlHandle = StreamSocketControlHandle;
63786
63787 fn control_handle(&self) -> &StreamSocketControlHandle {
63788 &self.control_handle
63789 }
63790
63791 fn drop_without_shutdown(mut self) {
63792 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63794 std::mem::forget(self);
63796 }
63797}
63798
63799impl StreamSocketSetIpReceiveOriginalDestinationAddressResponder {
63800 pub fn send(
63804 self,
63805 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63806 ) -> Result<(), fidl::Error> {
63807 let _result = self.send_raw(result);
63808 if _result.is_err() {
63809 self.control_handle.shutdown();
63810 }
63811 self.drop_without_shutdown();
63812 _result
63813 }
63814
63815 pub fn send_no_shutdown_on_err(
63817 self,
63818 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63819 ) -> Result<(), fidl::Error> {
63820 let _result = self.send_raw(result);
63821 self.drop_without_shutdown();
63822 _result
63823 }
63824
63825 fn send_raw(
63826 &self,
63827 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63828 ) -> Result<(), fidl::Error> {
63829 self.control_handle.inner.send::<fidl::encoding::ResultType<
63830 fidl::encoding::EmptyStruct,
63831 fidl_fuchsia_posix::Errno,
63832 >>(
63833 result,
63834 self.tx_id,
63835 0x4722b4ce52f7840,
63836 fidl::encoding::DynamicFlags::empty(),
63837 )
63838 }
63839}
63840
63841#[must_use = "FIDL methods require a response to be sent"]
63842#[derive(Debug)]
63843pub struct StreamSocketGetIpReceiveOriginalDestinationAddressResponder {
63844 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63845 tx_id: u32,
63846}
63847
63848impl std::ops::Drop for StreamSocketGetIpReceiveOriginalDestinationAddressResponder {
63852 fn drop(&mut self) {
63853 self.control_handle.shutdown();
63854 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63856 }
63857}
63858
63859impl fidl::endpoints::Responder for StreamSocketGetIpReceiveOriginalDestinationAddressResponder {
63860 type ControlHandle = StreamSocketControlHandle;
63861
63862 fn control_handle(&self) -> &StreamSocketControlHandle {
63863 &self.control_handle
63864 }
63865
63866 fn drop_without_shutdown(mut self) {
63867 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63869 std::mem::forget(self);
63871 }
63872}
63873
63874impl StreamSocketGetIpReceiveOriginalDestinationAddressResponder {
63875 pub fn send(
63879 self,
63880 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63881 ) -> Result<(), fidl::Error> {
63882 let _result = self.send_raw(result);
63883 if _result.is_err() {
63884 self.control_handle.shutdown();
63885 }
63886 self.drop_without_shutdown();
63887 _result
63888 }
63889
63890 pub fn send_no_shutdown_on_err(
63892 self,
63893 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63894 ) -> Result<(), fidl::Error> {
63895 let _result = self.send_raw(result);
63896 self.drop_without_shutdown();
63897 _result
63898 }
63899
63900 fn send_raw(
63901 &self,
63902 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63903 ) -> Result<(), fidl::Error> {
63904 self.control_handle.inner.send::<fidl::encoding::ResultType<
63905 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
63906 fidl_fuchsia_posix::Errno,
63907 >>(
63908 result.map(|value| (value,)),
63909 self.tx_id,
63910 0x2a0e7dc5d6bfdfe9,
63911 fidl::encoding::DynamicFlags::empty(),
63912 )
63913 }
63914}
63915
63916#[must_use = "FIDL methods require a response to be sent"]
63917#[derive(Debug)]
63918pub struct StreamSocketAddIpv6MembershipResponder {
63919 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63920 tx_id: u32,
63921}
63922
63923impl std::ops::Drop for StreamSocketAddIpv6MembershipResponder {
63927 fn drop(&mut self) {
63928 self.control_handle.shutdown();
63929 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63931 }
63932}
63933
63934impl fidl::endpoints::Responder for StreamSocketAddIpv6MembershipResponder {
63935 type ControlHandle = StreamSocketControlHandle;
63936
63937 fn control_handle(&self) -> &StreamSocketControlHandle {
63938 &self.control_handle
63939 }
63940
63941 fn drop_without_shutdown(mut self) {
63942 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63944 std::mem::forget(self);
63946 }
63947}
63948
63949impl StreamSocketAddIpv6MembershipResponder {
63950 pub fn send(
63954 self,
63955 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63956 ) -> Result<(), fidl::Error> {
63957 let _result = self.send_raw(result);
63958 if _result.is_err() {
63959 self.control_handle.shutdown();
63960 }
63961 self.drop_without_shutdown();
63962 _result
63963 }
63964
63965 pub fn send_no_shutdown_on_err(
63967 self,
63968 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63969 ) -> Result<(), fidl::Error> {
63970 let _result = self.send_raw(result);
63971 self.drop_without_shutdown();
63972 _result
63973 }
63974
63975 fn send_raw(
63976 &self,
63977 mut result: Result<(), fidl_fuchsia_posix::Errno>,
63978 ) -> Result<(), fidl::Error> {
63979 self.control_handle.inner.send::<fidl::encoding::ResultType<
63980 fidl::encoding::EmptyStruct,
63981 fidl_fuchsia_posix::Errno,
63982 >>(
63983 result,
63984 self.tx_id,
63985 0x7c94727acb4ea4b3,
63986 fidl::encoding::DynamicFlags::empty(),
63987 )
63988 }
63989}
63990
63991#[must_use = "FIDL methods require a response to be sent"]
63992#[derive(Debug)]
63993pub struct StreamSocketDropIpv6MembershipResponder {
63994 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63995 tx_id: u32,
63996}
63997
63998impl std::ops::Drop for StreamSocketDropIpv6MembershipResponder {
64002 fn drop(&mut self) {
64003 self.control_handle.shutdown();
64004 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64006 }
64007}
64008
64009impl fidl::endpoints::Responder for StreamSocketDropIpv6MembershipResponder {
64010 type ControlHandle = StreamSocketControlHandle;
64011
64012 fn control_handle(&self) -> &StreamSocketControlHandle {
64013 &self.control_handle
64014 }
64015
64016 fn drop_without_shutdown(mut self) {
64017 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64019 std::mem::forget(self);
64021 }
64022}
64023
64024impl StreamSocketDropIpv6MembershipResponder {
64025 pub fn send(
64029 self,
64030 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64031 ) -> Result<(), fidl::Error> {
64032 let _result = self.send_raw(result);
64033 if _result.is_err() {
64034 self.control_handle.shutdown();
64035 }
64036 self.drop_without_shutdown();
64037 _result
64038 }
64039
64040 pub fn send_no_shutdown_on_err(
64042 self,
64043 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64044 ) -> Result<(), fidl::Error> {
64045 let _result = self.send_raw(result);
64046 self.drop_without_shutdown();
64047 _result
64048 }
64049
64050 fn send_raw(
64051 &self,
64052 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64053 ) -> Result<(), fidl::Error> {
64054 self.control_handle.inner.send::<fidl::encoding::ResultType<
64055 fidl::encoding::EmptyStruct,
64056 fidl_fuchsia_posix::Errno,
64057 >>(
64058 result,
64059 self.tx_id,
64060 0x42104c70ccaba304,
64061 fidl::encoding::DynamicFlags::empty(),
64062 )
64063 }
64064}
64065
64066#[must_use = "FIDL methods require a response to be sent"]
64067#[derive(Debug)]
64068pub struct StreamSocketSetIpv6MulticastInterfaceResponder {
64069 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64070 tx_id: u32,
64071}
64072
64073impl std::ops::Drop for StreamSocketSetIpv6MulticastInterfaceResponder {
64077 fn drop(&mut self) {
64078 self.control_handle.shutdown();
64079 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64081 }
64082}
64083
64084impl fidl::endpoints::Responder for StreamSocketSetIpv6MulticastInterfaceResponder {
64085 type ControlHandle = StreamSocketControlHandle;
64086
64087 fn control_handle(&self) -> &StreamSocketControlHandle {
64088 &self.control_handle
64089 }
64090
64091 fn drop_without_shutdown(mut self) {
64092 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64094 std::mem::forget(self);
64096 }
64097}
64098
64099impl StreamSocketSetIpv6MulticastInterfaceResponder {
64100 pub fn send(
64104 self,
64105 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64106 ) -> Result<(), fidl::Error> {
64107 let _result = self.send_raw(result);
64108 if _result.is_err() {
64109 self.control_handle.shutdown();
64110 }
64111 self.drop_without_shutdown();
64112 _result
64113 }
64114
64115 pub fn send_no_shutdown_on_err(
64117 self,
64118 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64119 ) -> Result<(), fidl::Error> {
64120 let _result = self.send_raw(result);
64121 self.drop_without_shutdown();
64122 _result
64123 }
64124
64125 fn send_raw(
64126 &self,
64127 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64128 ) -> Result<(), fidl::Error> {
64129 self.control_handle.inner.send::<fidl::encoding::ResultType<
64130 fidl::encoding::EmptyStruct,
64131 fidl_fuchsia_posix::Errno,
64132 >>(
64133 result,
64134 self.tx_id,
64135 0x135f76db3774ab3b,
64136 fidl::encoding::DynamicFlags::empty(),
64137 )
64138 }
64139}
64140
64141#[must_use = "FIDL methods require a response to be sent"]
64142#[derive(Debug)]
64143pub struct StreamSocketGetIpv6MulticastInterfaceResponder {
64144 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64145 tx_id: u32,
64146}
64147
64148impl std::ops::Drop for StreamSocketGetIpv6MulticastInterfaceResponder {
64152 fn drop(&mut self) {
64153 self.control_handle.shutdown();
64154 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64156 }
64157}
64158
64159impl fidl::endpoints::Responder for StreamSocketGetIpv6MulticastInterfaceResponder {
64160 type ControlHandle = StreamSocketControlHandle;
64161
64162 fn control_handle(&self) -> &StreamSocketControlHandle {
64163 &self.control_handle
64164 }
64165
64166 fn drop_without_shutdown(mut self) {
64167 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64169 std::mem::forget(self);
64171 }
64172}
64173
64174impl StreamSocketGetIpv6MulticastInterfaceResponder {
64175 pub fn send(
64179 self,
64180 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
64181 ) -> Result<(), fidl::Error> {
64182 let _result = self.send_raw(result);
64183 if _result.is_err() {
64184 self.control_handle.shutdown();
64185 }
64186 self.drop_without_shutdown();
64187 _result
64188 }
64189
64190 pub fn send_no_shutdown_on_err(
64192 self,
64193 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
64194 ) -> Result<(), fidl::Error> {
64195 let _result = self.send_raw(result);
64196 self.drop_without_shutdown();
64197 _result
64198 }
64199
64200 fn send_raw(
64201 &self,
64202 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
64203 ) -> Result<(), fidl::Error> {
64204 self.control_handle.inner.send::<fidl::encoding::ResultType<
64205 BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
64206 fidl_fuchsia_posix::Errno,
64207 >>(
64208 result.map(|value| (value,)),
64209 self.tx_id,
64210 0x1f26fcdd348f1882,
64211 fidl::encoding::DynamicFlags::empty(),
64212 )
64213 }
64214}
64215
64216#[must_use = "FIDL methods require a response to be sent"]
64217#[derive(Debug)]
64218pub struct StreamSocketSetIpv6UnicastHopsResponder {
64219 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64220 tx_id: u32,
64221}
64222
64223impl std::ops::Drop for StreamSocketSetIpv6UnicastHopsResponder {
64227 fn drop(&mut self) {
64228 self.control_handle.shutdown();
64229 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64231 }
64232}
64233
64234impl fidl::endpoints::Responder for StreamSocketSetIpv6UnicastHopsResponder {
64235 type ControlHandle = StreamSocketControlHandle;
64236
64237 fn control_handle(&self) -> &StreamSocketControlHandle {
64238 &self.control_handle
64239 }
64240
64241 fn drop_without_shutdown(mut self) {
64242 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64244 std::mem::forget(self);
64246 }
64247}
64248
64249impl StreamSocketSetIpv6UnicastHopsResponder {
64250 pub fn send(
64254 self,
64255 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64256 ) -> Result<(), fidl::Error> {
64257 let _result = self.send_raw(result);
64258 if _result.is_err() {
64259 self.control_handle.shutdown();
64260 }
64261 self.drop_without_shutdown();
64262 _result
64263 }
64264
64265 pub fn send_no_shutdown_on_err(
64267 self,
64268 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64269 ) -> Result<(), fidl::Error> {
64270 let _result = self.send_raw(result);
64271 self.drop_without_shutdown();
64272 _result
64273 }
64274
64275 fn send_raw(
64276 &self,
64277 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64278 ) -> Result<(), fidl::Error> {
64279 self.control_handle.inner.send::<fidl::encoding::ResultType<
64280 fidl::encoding::EmptyStruct,
64281 fidl_fuchsia_posix::Errno,
64282 >>(
64283 result,
64284 self.tx_id,
64285 0x157d51e98f462859,
64286 fidl::encoding::DynamicFlags::empty(),
64287 )
64288 }
64289}
64290
64291#[must_use = "FIDL methods require a response to be sent"]
64292#[derive(Debug)]
64293pub struct StreamSocketGetIpv6UnicastHopsResponder {
64294 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64295 tx_id: u32,
64296}
64297
64298impl std::ops::Drop for StreamSocketGetIpv6UnicastHopsResponder {
64302 fn drop(&mut self) {
64303 self.control_handle.shutdown();
64304 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64306 }
64307}
64308
64309impl fidl::endpoints::Responder for StreamSocketGetIpv6UnicastHopsResponder {
64310 type ControlHandle = StreamSocketControlHandle;
64311
64312 fn control_handle(&self) -> &StreamSocketControlHandle {
64313 &self.control_handle
64314 }
64315
64316 fn drop_without_shutdown(mut self) {
64317 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64319 std::mem::forget(self);
64321 }
64322}
64323
64324impl StreamSocketGetIpv6UnicastHopsResponder {
64325 pub fn send(
64329 self,
64330 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
64331 ) -> Result<(), fidl::Error> {
64332 let _result = self.send_raw(result);
64333 if _result.is_err() {
64334 self.control_handle.shutdown();
64335 }
64336 self.drop_without_shutdown();
64337 _result
64338 }
64339
64340 pub fn send_no_shutdown_on_err(
64342 self,
64343 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
64344 ) -> Result<(), fidl::Error> {
64345 let _result = self.send_raw(result);
64346 self.drop_without_shutdown();
64347 _result
64348 }
64349
64350 fn send_raw(
64351 &self,
64352 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
64353 ) -> Result<(), fidl::Error> {
64354 self.control_handle.inner.send::<fidl::encoding::ResultType<
64355 BaseNetworkSocketGetIpv6UnicastHopsResponse,
64356 fidl_fuchsia_posix::Errno,
64357 >>(
64358 result.map(|value| (value,)),
64359 self.tx_id,
64360 0x21f4641cad8bd8d2,
64361 fidl::encoding::DynamicFlags::empty(),
64362 )
64363 }
64364}
64365
64366#[must_use = "FIDL methods require a response to be sent"]
64367#[derive(Debug)]
64368pub struct StreamSocketSetIpv6ReceiveHopLimitResponder {
64369 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64370 tx_id: u32,
64371}
64372
64373impl std::ops::Drop for StreamSocketSetIpv6ReceiveHopLimitResponder {
64377 fn drop(&mut self) {
64378 self.control_handle.shutdown();
64379 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64381 }
64382}
64383
64384impl fidl::endpoints::Responder for StreamSocketSetIpv6ReceiveHopLimitResponder {
64385 type ControlHandle = StreamSocketControlHandle;
64386
64387 fn control_handle(&self) -> &StreamSocketControlHandle {
64388 &self.control_handle
64389 }
64390
64391 fn drop_without_shutdown(mut self) {
64392 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64394 std::mem::forget(self);
64396 }
64397}
64398
64399impl StreamSocketSetIpv6ReceiveHopLimitResponder {
64400 pub fn send(
64404 self,
64405 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64406 ) -> Result<(), fidl::Error> {
64407 let _result = self.send_raw(result);
64408 if _result.is_err() {
64409 self.control_handle.shutdown();
64410 }
64411 self.drop_without_shutdown();
64412 _result
64413 }
64414
64415 pub fn send_no_shutdown_on_err(
64417 self,
64418 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64419 ) -> Result<(), fidl::Error> {
64420 let _result = self.send_raw(result);
64421 self.drop_without_shutdown();
64422 _result
64423 }
64424
64425 fn send_raw(
64426 &self,
64427 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64428 ) -> Result<(), fidl::Error> {
64429 self.control_handle.inner.send::<fidl::encoding::ResultType<
64430 fidl::encoding::EmptyStruct,
64431 fidl_fuchsia_posix::Errno,
64432 >>(
64433 result,
64434 self.tx_id,
64435 0x5c24808ed2e84a1e,
64436 fidl::encoding::DynamicFlags::empty(),
64437 )
64438 }
64439}
64440
64441#[must_use = "FIDL methods require a response to be sent"]
64442#[derive(Debug)]
64443pub struct StreamSocketGetIpv6ReceiveHopLimitResponder {
64444 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64445 tx_id: u32,
64446}
64447
64448impl std::ops::Drop for StreamSocketGetIpv6ReceiveHopLimitResponder {
64452 fn drop(&mut self) {
64453 self.control_handle.shutdown();
64454 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64456 }
64457}
64458
64459impl fidl::endpoints::Responder for StreamSocketGetIpv6ReceiveHopLimitResponder {
64460 type ControlHandle = StreamSocketControlHandle;
64461
64462 fn control_handle(&self) -> &StreamSocketControlHandle {
64463 &self.control_handle
64464 }
64465
64466 fn drop_without_shutdown(mut self) {
64467 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64469 std::mem::forget(self);
64471 }
64472}
64473
64474impl StreamSocketGetIpv6ReceiveHopLimitResponder {
64475 pub fn send(
64479 self,
64480 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64481 ) -> Result<(), fidl::Error> {
64482 let _result = self.send_raw(result);
64483 if _result.is_err() {
64484 self.control_handle.shutdown();
64485 }
64486 self.drop_without_shutdown();
64487 _result
64488 }
64489
64490 pub fn send_no_shutdown_on_err(
64492 self,
64493 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64494 ) -> Result<(), fidl::Error> {
64495 let _result = self.send_raw(result);
64496 self.drop_without_shutdown();
64497 _result
64498 }
64499
64500 fn send_raw(
64501 &self,
64502 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64503 ) -> Result<(), fidl::Error> {
64504 self.control_handle.inner.send::<fidl::encoding::ResultType<
64505 BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
64506 fidl_fuchsia_posix::Errno,
64507 >>(
64508 result.map(|value| (value,)),
64509 self.tx_id,
64510 0x341e06689885b4c0,
64511 fidl::encoding::DynamicFlags::empty(),
64512 )
64513 }
64514}
64515
64516#[must_use = "FIDL methods require a response to be sent"]
64517#[derive(Debug)]
64518pub struct StreamSocketSetIpv6MulticastHopsResponder {
64519 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64520 tx_id: u32,
64521}
64522
64523impl std::ops::Drop for StreamSocketSetIpv6MulticastHopsResponder {
64527 fn drop(&mut self) {
64528 self.control_handle.shutdown();
64529 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64531 }
64532}
64533
64534impl fidl::endpoints::Responder for StreamSocketSetIpv6MulticastHopsResponder {
64535 type ControlHandle = StreamSocketControlHandle;
64536
64537 fn control_handle(&self) -> &StreamSocketControlHandle {
64538 &self.control_handle
64539 }
64540
64541 fn drop_without_shutdown(mut self) {
64542 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64544 std::mem::forget(self);
64546 }
64547}
64548
64549impl StreamSocketSetIpv6MulticastHopsResponder {
64550 pub fn send(
64554 self,
64555 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64556 ) -> Result<(), fidl::Error> {
64557 let _result = self.send_raw(result);
64558 if _result.is_err() {
64559 self.control_handle.shutdown();
64560 }
64561 self.drop_without_shutdown();
64562 _result
64563 }
64564
64565 pub fn send_no_shutdown_on_err(
64567 self,
64568 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64569 ) -> Result<(), fidl::Error> {
64570 let _result = self.send_raw(result);
64571 self.drop_without_shutdown();
64572 _result
64573 }
64574
64575 fn send_raw(
64576 &self,
64577 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64578 ) -> Result<(), fidl::Error> {
64579 self.control_handle.inner.send::<fidl::encoding::ResultType<
64580 fidl::encoding::EmptyStruct,
64581 fidl_fuchsia_posix::Errno,
64582 >>(
64583 result,
64584 self.tx_id,
64585 0x25b9cd4d181f82c1,
64586 fidl::encoding::DynamicFlags::empty(),
64587 )
64588 }
64589}
64590
64591#[must_use = "FIDL methods require a response to be sent"]
64592#[derive(Debug)]
64593pub struct StreamSocketGetIpv6MulticastHopsResponder {
64594 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64595 tx_id: u32,
64596}
64597
64598impl std::ops::Drop for StreamSocketGetIpv6MulticastHopsResponder {
64602 fn drop(&mut self) {
64603 self.control_handle.shutdown();
64604 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64606 }
64607}
64608
64609impl fidl::endpoints::Responder for StreamSocketGetIpv6MulticastHopsResponder {
64610 type ControlHandle = StreamSocketControlHandle;
64611
64612 fn control_handle(&self) -> &StreamSocketControlHandle {
64613 &self.control_handle
64614 }
64615
64616 fn drop_without_shutdown(mut self) {
64617 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64619 std::mem::forget(self);
64621 }
64622}
64623
64624impl StreamSocketGetIpv6MulticastHopsResponder {
64625 pub fn send(
64629 self,
64630 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
64631 ) -> Result<(), fidl::Error> {
64632 let _result = self.send_raw(result);
64633 if _result.is_err() {
64634 self.control_handle.shutdown();
64635 }
64636 self.drop_without_shutdown();
64637 _result
64638 }
64639
64640 pub fn send_no_shutdown_on_err(
64642 self,
64643 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
64644 ) -> Result<(), fidl::Error> {
64645 let _result = self.send_raw(result);
64646 self.drop_without_shutdown();
64647 _result
64648 }
64649
64650 fn send_raw(
64651 &self,
64652 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
64653 ) -> Result<(), fidl::Error> {
64654 self.control_handle.inner.send::<fidl::encoding::ResultType<
64655 BaseNetworkSocketGetIpv6MulticastHopsResponse,
64656 fidl_fuchsia_posix::Errno,
64657 >>(
64658 result.map(|value| (value,)),
64659 self.tx_id,
64660 0x52916948a365012a,
64661 fidl::encoding::DynamicFlags::empty(),
64662 )
64663 }
64664}
64665
64666#[must_use = "FIDL methods require a response to be sent"]
64667#[derive(Debug)]
64668pub struct StreamSocketSetIpv6MulticastLoopbackResponder {
64669 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64670 tx_id: u32,
64671}
64672
64673impl std::ops::Drop for StreamSocketSetIpv6MulticastLoopbackResponder {
64677 fn drop(&mut self) {
64678 self.control_handle.shutdown();
64679 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64681 }
64682}
64683
64684impl fidl::endpoints::Responder for StreamSocketSetIpv6MulticastLoopbackResponder {
64685 type ControlHandle = StreamSocketControlHandle;
64686
64687 fn control_handle(&self) -> &StreamSocketControlHandle {
64688 &self.control_handle
64689 }
64690
64691 fn drop_without_shutdown(mut self) {
64692 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64694 std::mem::forget(self);
64696 }
64697}
64698
64699impl StreamSocketSetIpv6MulticastLoopbackResponder {
64700 pub fn send(
64704 self,
64705 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64706 ) -> Result<(), fidl::Error> {
64707 let _result = self.send_raw(result);
64708 if _result.is_err() {
64709 self.control_handle.shutdown();
64710 }
64711 self.drop_without_shutdown();
64712 _result
64713 }
64714
64715 pub fn send_no_shutdown_on_err(
64717 self,
64718 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64719 ) -> Result<(), fidl::Error> {
64720 let _result = self.send_raw(result);
64721 self.drop_without_shutdown();
64722 _result
64723 }
64724
64725 fn send_raw(
64726 &self,
64727 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64728 ) -> Result<(), fidl::Error> {
64729 self.control_handle.inner.send::<fidl::encoding::ResultType<
64730 fidl::encoding::EmptyStruct,
64731 fidl_fuchsia_posix::Errno,
64732 >>(
64733 result,
64734 self.tx_id,
64735 0x55701c409ff41b40,
64736 fidl::encoding::DynamicFlags::empty(),
64737 )
64738 }
64739}
64740
64741#[must_use = "FIDL methods require a response to be sent"]
64742#[derive(Debug)]
64743pub struct StreamSocketGetIpv6MulticastLoopbackResponder {
64744 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64745 tx_id: u32,
64746}
64747
64748impl std::ops::Drop for StreamSocketGetIpv6MulticastLoopbackResponder {
64752 fn drop(&mut self) {
64753 self.control_handle.shutdown();
64754 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64756 }
64757}
64758
64759impl fidl::endpoints::Responder for StreamSocketGetIpv6MulticastLoopbackResponder {
64760 type ControlHandle = StreamSocketControlHandle;
64761
64762 fn control_handle(&self) -> &StreamSocketControlHandle {
64763 &self.control_handle
64764 }
64765
64766 fn drop_without_shutdown(mut self) {
64767 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64769 std::mem::forget(self);
64771 }
64772}
64773
64774impl StreamSocketGetIpv6MulticastLoopbackResponder {
64775 pub fn send(
64779 self,
64780 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64781 ) -> Result<(), fidl::Error> {
64782 let _result = self.send_raw(result);
64783 if _result.is_err() {
64784 self.control_handle.shutdown();
64785 }
64786 self.drop_without_shutdown();
64787 _result
64788 }
64789
64790 pub fn send_no_shutdown_on_err(
64792 self,
64793 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64794 ) -> Result<(), fidl::Error> {
64795 let _result = self.send_raw(result);
64796 self.drop_without_shutdown();
64797 _result
64798 }
64799
64800 fn send_raw(
64801 &self,
64802 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64803 ) -> Result<(), fidl::Error> {
64804 self.control_handle.inner.send::<fidl::encoding::ResultType<
64805 BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
64806 fidl_fuchsia_posix::Errno,
64807 >>(
64808 result.map(|value| (value,)),
64809 self.tx_id,
64810 0x4415b701fde319c3,
64811 fidl::encoding::DynamicFlags::empty(),
64812 )
64813 }
64814}
64815
64816#[must_use = "FIDL methods require a response to be sent"]
64817#[derive(Debug)]
64818pub struct StreamSocketSetIpv6OnlyResponder {
64819 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64820 tx_id: u32,
64821}
64822
64823impl std::ops::Drop for StreamSocketSetIpv6OnlyResponder {
64827 fn drop(&mut self) {
64828 self.control_handle.shutdown();
64829 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64831 }
64832}
64833
64834impl fidl::endpoints::Responder for StreamSocketSetIpv6OnlyResponder {
64835 type ControlHandle = StreamSocketControlHandle;
64836
64837 fn control_handle(&self) -> &StreamSocketControlHandle {
64838 &self.control_handle
64839 }
64840
64841 fn drop_without_shutdown(mut self) {
64842 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64844 std::mem::forget(self);
64846 }
64847}
64848
64849impl StreamSocketSetIpv6OnlyResponder {
64850 pub fn send(
64854 self,
64855 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64856 ) -> Result<(), fidl::Error> {
64857 let _result = self.send_raw(result);
64858 if _result.is_err() {
64859 self.control_handle.shutdown();
64860 }
64861 self.drop_without_shutdown();
64862 _result
64863 }
64864
64865 pub fn send_no_shutdown_on_err(
64867 self,
64868 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64869 ) -> Result<(), fidl::Error> {
64870 let _result = self.send_raw(result);
64871 self.drop_without_shutdown();
64872 _result
64873 }
64874
64875 fn send_raw(
64876 &self,
64877 mut result: Result<(), fidl_fuchsia_posix::Errno>,
64878 ) -> Result<(), fidl::Error> {
64879 self.control_handle.inner.send::<fidl::encoding::ResultType<
64880 fidl::encoding::EmptyStruct,
64881 fidl_fuchsia_posix::Errno,
64882 >>(
64883 result,
64884 self.tx_id,
64885 0x4873f1364758cbba,
64886 fidl::encoding::DynamicFlags::empty(),
64887 )
64888 }
64889}
64890
64891#[must_use = "FIDL methods require a response to be sent"]
64892#[derive(Debug)]
64893pub struct StreamSocketGetIpv6OnlyResponder {
64894 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64895 tx_id: u32,
64896}
64897
64898impl std::ops::Drop for StreamSocketGetIpv6OnlyResponder {
64902 fn drop(&mut self) {
64903 self.control_handle.shutdown();
64904 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64906 }
64907}
64908
64909impl fidl::endpoints::Responder for StreamSocketGetIpv6OnlyResponder {
64910 type ControlHandle = StreamSocketControlHandle;
64911
64912 fn control_handle(&self) -> &StreamSocketControlHandle {
64913 &self.control_handle
64914 }
64915
64916 fn drop_without_shutdown(mut self) {
64917 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64919 std::mem::forget(self);
64921 }
64922}
64923
64924impl StreamSocketGetIpv6OnlyResponder {
64925 pub fn send(
64929 self,
64930 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64931 ) -> Result<(), fidl::Error> {
64932 let _result = self.send_raw(result);
64933 if _result.is_err() {
64934 self.control_handle.shutdown();
64935 }
64936 self.drop_without_shutdown();
64937 _result
64938 }
64939
64940 pub fn send_no_shutdown_on_err(
64942 self,
64943 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64944 ) -> Result<(), fidl::Error> {
64945 let _result = self.send_raw(result);
64946 self.drop_without_shutdown();
64947 _result
64948 }
64949
64950 fn send_raw(
64951 &self,
64952 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64953 ) -> Result<(), fidl::Error> {
64954 self.control_handle.inner.send::<fidl::encoding::ResultType<
64955 BaseNetworkSocketGetIpv6OnlyResponse,
64956 fidl_fuchsia_posix::Errno,
64957 >>(
64958 result.map(|value| (value,)),
64959 self.tx_id,
64960 0x4aa3340a1a26b89c,
64961 fidl::encoding::DynamicFlags::empty(),
64962 )
64963 }
64964}
64965
64966#[must_use = "FIDL methods require a response to be sent"]
64967#[derive(Debug)]
64968pub struct StreamSocketSetIpv6ReceiveTrafficClassResponder {
64969 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64970 tx_id: u32,
64971}
64972
64973impl std::ops::Drop for StreamSocketSetIpv6ReceiveTrafficClassResponder {
64977 fn drop(&mut self) {
64978 self.control_handle.shutdown();
64979 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64981 }
64982}
64983
64984impl fidl::endpoints::Responder for StreamSocketSetIpv6ReceiveTrafficClassResponder {
64985 type ControlHandle = StreamSocketControlHandle;
64986
64987 fn control_handle(&self) -> &StreamSocketControlHandle {
64988 &self.control_handle
64989 }
64990
64991 fn drop_without_shutdown(mut self) {
64992 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64994 std::mem::forget(self);
64996 }
64997}
64998
64999impl StreamSocketSetIpv6ReceiveTrafficClassResponder {
65000 pub fn send(
65004 self,
65005 mut result: Result<(), fidl_fuchsia_posix::Errno>,
65006 ) -> Result<(), fidl::Error> {
65007 let _result = self.send_raw(result);
65008 if _result.is_err() {
65009 self.control_handle.shutdown();
65010 }
65011 self.drop_without_shutdown();
65012 _result
65013 }
65014
65015 pub fn send_no_shutdown_on_err(
65017 self,
65018 mut result: Result<(), fidl_fuchsia_posix::Errno>,
65019 ) -> Result<(), fidl::Error> {
65020 let _result = self.send_raw(result);
65021 self.drop_without_shutdown();
65022 _result
65023 }
65024
65025 fn send_raw(
65026 &self,
65027 mut result: Result<(), fidl_fuchsia_posix::Errno>,
65028 ) -> Result<(), fidl::Error> {
65029 self.control_handle.inner.send::<fidl::encoding::ResultType<
65030 fidl::encoding::EmptyStruct,
65031 fidl_fuchsia_posix::Errno,
65032 >>(
65033 result,
65034 self.tx_id,
65035 0x58f07c8788d099a0,
65036 fidl::encoding::DynamicFlags::empty(),
65037 )
65038 }
65039}
65040
65041#[must_use = "FIDL methods require a response to be sent"]
65042#[derive(Debug)]
65043pub struct StreamSocketGetIpv6ReceiveTrafficClassResponder {
65044 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65045 tx_id: u32,
65046}
65047
65048impl std::ops::Drop for StreamSocketGetIpv6ReceiveTrafficClassResponder {
65052 fn drop(&mut self) {
65053 self.control_handle.shutdown();
65054 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65056 }
65057}
65058
65059impl fidl::endpoints::Responder for StreamSocketGetIpv6ReceiveTrafficClassResponder {
65060 type ControlHandle = StreamSocketControlHandle;
65061
65062 fn control_handle(&self) -> &StreamSocketControlHandle {
65063 &self.control_handle
65064 }
65065
65066 fn drop_without_shutdown(mut self) {
65067 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65069 std::mem::forget(self);
65071 }
65072}
65073
65074impl StreamSocketGetIpv6ReceiveTrafficClassResponder {
65075 pub fn send(
65079 self,
65080 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65081 ) -> Result<(), fidl::Error> {
65082 let _result = self.send_raw(result);
65083 if _result.is_err() {
65084 self.control_handle.shutdown();
65085 }
65086 self.drop_without_shutdown();
65087 _result
65088 }
65089
65090 pub fn send_no_shutdown_on_err(
65092 self,
65093 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65094 ) -> Result<(), fidl::Error> {
65095 let _result = self.send_raw(result);
65096 self.drop_without_shutdown();
65097 _result
65098 }
65099
65100 fn send_raw(
65101 &self,
65102 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65103 ) -> Result<(), fidl::Error> {
65104 self.control_handle.inner.send::<fidl::encoding::ResultType<
65105 BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
65106 fidl_fuchsia_posix::Errno,
65107 >>(
65108 result.map(|value| (value,)),
65109 self.tx_id,
65110 0x2e334df1da553ffa,
65111 fidl::encoding::DynamicFlags::empty(),
65112 )
65113 }
65114}
65115
65116#[must_use = "FIDL methods require a response to be sent"]
65117#[derive(Debug)]
65118pub struct StreamSocketSetIpv6TrafficClassResponder {
65119 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65120 tx_id: u32,
65121}
65122
65123impl std::ops::Drop for StreamSocketSetIpv6TrafficClassResponder {
65127 fn drop(&mut self) {
65128 self.control_handle.shutdown();
65129 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65131 }
65132}
65133
65134impl fidl::endpoints::Responder for StreamSocketSetIpv6TrafficClassResponder {
65135 type ControlHandle = StreamSocketControlHandle;
65136
65137 fn control_handle(&self) -> &StreamSocketControlHandle {
65138 &self.control_handle
65139 }
65140
65141 fn drop_without_shutdown(mut self) {
65142 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65144 std::mem::forget(self);
65146 }
65147}
65148
65149impl StreamSocketSetIpv6TrafficClassResponder {
65150 pub fn send(
65154 self,
65155 mut result: Result<(), fidl_fuchsia_posix::Errno>,
65156 ) -> Result<(), fidl::Error> {
65157 let _result = self.send_raw(result);
65158 if _result.is_err() {
65159 self.control_handle.shutdown();
65160 }
65161 self.drop_without_shutdown();
65162 _result
65163 }
65164
65165 pub fn send_no_shutdown_on_err(
65167 self,
65168 mut result: Result<(), fidl_fuchsia_posix::Errno>,
65169 ) -> Result<(), fidl::Error> {
65170 let _result = self.send_raw(result);
65171 self.drop_without_shutdown();
65172 _result
65173 }
65174
65175 fn send_raw(
65176 &self,
65177 mut result: Result<(), fidl_fuchsia_posix::Errno>,
65178 ) -> Result<(), fidl::Error> {
65179 self.control_handle.inner.send::<fidl::encoding::ResultType<
65180 fidl::encoding::EmptyStruct,
65181 fidl_fuchsia_posix::Errno,
65182 >>(
65183 result,
65184 self.tx_id,
65185 0x6af077800c5a0b4f,
65186 fidl::encoding::DynamicFlags::empty(),
65187 )
65188 }
65189}
65190
65191#[must_use = "FIDL methods require a response to be sent"]
65192#[derive(Debug)]
65193pub struct StreamSocketGetIpv6TrafficClassResponder {
65194 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65195 tx_id: u32,
65196}
65197
65198impl std::ops::Drop for StreamSocketGetIpv6TrafficClassResponder {
65202 fn drop(&mut self) {
65203 self.control_handle.shutdown();
65204 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65206 }
65207}
65208
65209impl fidl::endpoints::Responder for StreamSocketGetIpv6TrafficClassResponder {
65210 type ControlHandle = StreamSocketControlHandle;
65211
65212 fn control_handle(&self) -> &StreamSocketControlHandle {
65213 &self.control_handle
65214 }
65215
65216 fn drop_without_shutdown(mut self) {
65217 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65219 std::mem::forget(self);
65221 }
65222}
65223
65224impl StreamSocketGetIpv6TrafficClassResponder {
65225 pub fn send(
65229 self,
65230 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
65231 ) -> Result<(), fidl::Error> {
65232 let _result = self.send_raw(result);
65233 if _result.is_err() {
65234 self.control_handle.shutdown();
65235 }
65236 self.drop_without_shutdown();
65237 _result
65238 }
65239
65240 pub fn send_no_shutdown_on_err(
65242 self,
65243 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
65244 ) -> Result<(), fidl::Error> {
65245 let _result = self.send_raw(result);
65246 self.drop_without_shutdown();
65247 _result
65248 }
65249
65250 fn send_raw(
65251 &self,
65252 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
65253 ) -> Result<(), fidl::Error> {
65254 self.control_handle.inner.send::<fidl::encoding::ResultType<
65255 BaseNetworkSocketGetIpv6TrafficClassResponse,
65256 fidl_fuchsia_posix::Errno,
65257 >>(
65258 result.map(|value| (value,)),
65259 self.tx_id,
65260 0x6baf6eed8fc2f04,
65261 fidl::encoding::DynamicFlags::empty(),
65262 )
65263 }
65264}
65265
65266#[must_use = "FIDL methods require a response to be sent"]
65267#[derive(Debug)]
65268pub struct StreamSocketSetIpv6ReceivePacketInfoResponder {
65269 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65270 tx_id: u32,
65271}
65272
65273impl std::ops::Drop for StreamSocketSetIpv6ReceivePacketInfoResponder {
65277 fn drop(&mut self) {
65278 self.control_handle.shutdown();
65279 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65281 }
65282}
65283
65284impl fidl::endpoints::Responder for StreamSocketSetIpv6ReceivePacketInfoResponder {
65285 type ControlHandle = StreamSocketControlHandle;
65286
65287 fn control_handle(&self) -> &StreamSocketControlHandle {
65288 &self.control_handle
65289 }
65290
65291 fn drop_without_shutdown(mut self) {
65292 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65294 std::mem::forget(self);
65296 }
65297}
65298
65299impl StreamSocketSetIpv6ReceivePacketInfoResponder {
65300 pub fn send(
65304 self,
65305 mut result: Result<(), fidl_fuchsia_posix::Errno>,
65306 ) -> Result<(), fidl::Error> {
65307 let _result = self.send_raw(result);
65308 if _result.is_err() {
65309 self.control_handle.shutdown();
65310 }
65311 self.drop_without_shutdown();
65312 _result
65313 }
65314
65315 pub fn send_no_shutdown_on_err(
65317 self,
65318 mut result: Result<(), fidl_fuchsia_posix::Errno>,
65319 ) -> Result<(), fidl::Error> {
65320 let _result = self.send_raw(result);
65321 self.drop_without_shutdown();
65322 _result
65323 }
65324
65325 fn send_raw(
65326 &self,
65327 mut result: Result<(), fidl_fuchsia_posix::Errno>,
65328 ) -> Result<(), fidl::Error> {
65329 self.control_handle.inner.send::<fidl::encoding::ResultType<
65330 fidl::encoding::EmptyStruct,
65331 fidl_fuchsia_posix::Errno,
65332 >>(
65333 result,
65334 self.tx_id,
65335 0x19259775b1a92768,
65336 fidl::encoding::DynamicFlags::empty(),
65337 )
65338 }
65339}
65340
65341#[must_use = "FIDL methods require a response to be sent"]
65342#[derive(Debug)]
65343pub struct StreamSocketGetIpv6ReceivePacketInfoResponder {
65344 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65345 tx_id: u32,
65346}
65347
65348impl std::ops::Drop for StreamSocketGetIpv6ReceivePacketInfoResponder {
65352 fn drop(&mut self) {
65353 self.control_handle.shutdown();
65354 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65356 }
65357}
65358
65359impl fidl::endpoints::Responder for StreamSocketGetIpv6ReceivePacketInfoResponder {
65360 type ControlHandle = StreamSocketControlHandle;
65361
65362 fn control_handle(&self) -> &StreamSocketControlHandle {
65363 &self.control_handle
65364 }
65365
65366 fn drop_without_shutdown(mut self) {
65367 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65369 std::mem::forget(self);
65371 }
65372}
65373
65374impl StreamSocketGetIpv6ReceivePacketInfoResponder {
65375 pub fn send(
65379 self,
65380 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65381 ) -> Result<(), fidl::Error> {
65382 let _result = self.send_raw(result);
65383 if _result.is_err() {
65384 self.control_handle.shutdown();
65385 }
65386 self.drop_without_shutdown();
65387 _result
65388 }
65389
65390 pub fn send_no_shutdown_on_err(
65392 self,
65393 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65394 ) -> Result<(), fidl::Error> {
65395 let _result = self.send_raw(result);
65396 self.drop_without_shutdown();
65397 _result
65398 }
65399
65400 fn send_raw(
65401 &self,
65402 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65403 ) -> Result<(), fidl::Error> {
65404 self.control_handle.inner.send::<fidl::encoding::ResultType<
65405 BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
65406 fidl_fuchsia_posix::Errno,
65407 >>(
65408 result.map(|value| (value,)),
65409 self.tx_id,
65410 0x7acd4a2775baec75,
65411 fidl::encoding::DynamicFlags::empty(),
65412 )
65413 }
65414}
65415
65416#[must_use = "FIDL methods require a response to be sent"]
65417#[derive(Debug)]
65418pub struct StreamSocketGetOriginalDestinationResponder {
65419 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65420 tx_id: u32,
65421}
65422
65423impl std::ops::Drop for StreamSocketGetOriginalDestinationResponder {
65427 fn drop(&mut self) {
65428 self.control_handle.shutdown();
65429 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65431 }
65432}
65433
65434impl fidl::endpoints::Responder for StreamSocketGetOriginalDestinationResponder {
65435 type ControlHandle = StreamSocketControlHandle;
65436
65437 fn control_handle(&self) -> &StreamSocketControlHandle {
65438 &self.control_handle
65439 }
65440
65441 fn drop_without_shutdown(mut self) {
65442 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65444 std::mem::forget(self);
65446 }
65447}
65448
65449impl StreamSocketGetOriginalDestinationResponder {
65450 pub fn send(
65454 self,
65455 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
65456 ) -> Result<(), fidl::Error> {
65457 let _result = self.send_raw(result);
65458 if _result.is_err() {
65459 self.control_handle.shutdown();
65460 }
65461 self.drop_without_shutdown();
65462 _result
65463 }
65464
65465 pub fn send_no_shutdown_on_err(
65467 self,
65468 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
65469 ) -> Result<(), fidl::Error> {
65470 let _result = self.send_raw(result);
65471 self.drop_without_shutdown();
65472 _result
65473 }
65474
65475 fn send_raw(
65476 &self,
65477 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
65478 ) -> Result<(), fidl::Error> {
65479 self.control_handle.inner.send::<fidl::encoding::ResultType<
65480 BaseNetworkSocketGetOriginalDestinationResponse,
65481 fidl_fuchsia_posix::Errno,
65482 >>(
65483 result.map(|value| (value,)),
65484 self.tx_id,
65485 0x38bf28f0dafdbac0,
65486 fidl::encoding::DynamicFlags::empty(),
65487 )
65488 }
65489}
65490
65491#[must_use = "FIDL methods require a response to be sent"]
65492#[derive(Debug)]
65493pub struct StreamSocketDescribeResponder {
65494 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65495 tx_id: u32,
65496}
65497
65498impl std::ops::Drop for StreamSocketDescribeResponder {
65502 fn drop(&mut self) {
65503 self.control_handle.shutdown();
65504 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65506 }
65507}
65508
65509impl fidl::endpoints::Responder for StreamSocketDescribeResponder {
65510 type ControlHandle = StreamSocketControlHandle;
65511
65512 fn control_handle(&self) -> &StreamSocketControlHandle {
65513 &self.control_handle
65514 }
65515
65516 fn drop_without_shutdown(mut self) {
65517 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65519 std::mem::forget(self);
65521 }
65522}
65523
65524impl StreamSocketDescribeResponder {
65525 pub fn send(self, mut payload: StreamSocketDescribeResponse) -> Result<(), fidl::Error> {
65529 let _result = self.send_raw(payload);
65530 if _result.is_err() {
65531 self.control_handle.shutdown();
65532 }
65533 self.drop_without_shutdown();
65534 _result
65535 }
65536
65537 pub fn send_no_shutdown_on_err(
65539 self,
65540 mut payload: StreamSocketDescribeResponse,
65541 ) -> Result<(), fidl::Error> {
65542 let _result = self.send_raw(payload);
65543 self.drop_without_shutdown();
65544 _result
65545 }
65546
65547 fn send_raw(&self, mut payload: StreamSocketDescribeResponse) -> Result<(), fidl::Error> {
65548 self.control_handle.inner.send::<StreamSocketDescribeResponse>(
65549 &mut payload,
65550 self.tx_id,
65551 0x29e22969a7dadc32,
65552 fidl::encoding::DynamicFlags::empty(),
65553 )
65554 }
65555}
65556
65557#[must_use = "FIDL methods require a response to be sent"]
65558#[derive(Debug)]
65559pub struct StreamSocketListenResponder {
65560 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65561 tx_id: u32,
65562}
65563
65564impl std::ops::Drop for StreamSocketListenResponder {
65568 fn drop(&mut self) {
65569 self.control_handle.shutdown();
65570 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65572 }
65573}
65574
65575impl fidl::endpoints::Responder for StreamSocketListenResponder {
65576 type ControlHandle = StreamSocketControlHandle;
65577
65578 fn control_handle(&self) -> &StreamSocketControlHandle {
65579 &self.control_handle
65580 }
65581
65582 fn drop_without_shutdown(mut self) {
65583 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65585 std::mem::forget(self);
65587 }
65588}
65589
65590impl StreamSocketListenResponder {
65591 pub fn send(
65595 self,
65596 mut result: Result<(), fidl_fuchsia_posix::Errno>,
65597 ) -> Result<(), fidl::Error> {
65598 let _result = self.send_raw(result);
65599 if _result.is_err() {
65600 self.control_handle.shutdown();
65601 }
65602 self.drop_without_shutdown();
65603 _result
65604 }
65605
65606 pub fn send_no_shutdown_on_err(
65608 self,
65609 mut result: Result<(), fidl_fuchsia_posix::Errno>,
65610 ) -> Result<(), fidl::Error> {
65611 let _result = self.send_raw(result);
65612 self.drop_without_shutdown();
65613 _result
65614 }
65615
65616 fn send_raw(
65617 &self,
65618 mut result: Result<(), fidl_fuchsia_posix::Errno>,
65619 ) -> Result<(), fidl::Error> {
65620 self.control_handle.inner.send::<fidl::encoding::ResultType<
65621 fidl::encoding::EmptyStruct,
65622 fidl_fuchsia_posix::Errno,
65623 >>(
65624 result,
65625 self.tx_id,
65626 0x3d0a65ced3d10108,
65627 fidl::encoding::DynamicFlags::empty(),
65628 )
65629 }
65630}
65631
65632#[must_use = "FIDL methods require a response to be sent"]
65633#[derive(Debug)]
65634pub struct StreamSocketAcceptResponder {
65635 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65636 tx_id: u32,
65637}
65638
65639impl std::ops::Drop for StreamSocketAcceptResponder {
65643 fn drop(&mut self) {
65644 self.control_handle.shutdown();
65645 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65647 }
65648}
65649
65650impl fidl::endpoints::Responder for StreamSocketAcceptResponder {
65651 type ControlHandle = StreamSocketControlHandle;
65652
65653 fn control_handle(&self) -> &StreamSocketControlHandle {
65654 &self.control_handle
65655 }
65656
65657 fn drop_without_shutdown(mut self) {
65658 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65660 std::mem::forget(self);
65662 }
65663}
65664
65665impl StreamSocketAcceptResponder {
65666 pub fn send(
65670 self,
65671 mut result: Result<
65672 (
65673 Option<&fidl_fuchsia_net::SocketAddress>,
65674 fidl::endpoints::ClientEnd<StreamSocketMarker>,
65675 ),
65676 fidl_fuchsia_posix::Errno,
65677 >,
65678 ) -> Result<(), fidl::Error> {
65679 let _result = self.send_raw(result);
65680 if _result.is_err() {
65681 self.control_handle.shutdown();
65682 }
65683 self.drop_without_shutdown();
65684 _result
65685 }
65686
65687 pub fn send_no_shutdown_on_err(
65689 self,
65690 mut result: Result<
65691 (
65692 Option<&fidl_fuchsia_net::SocketAddress>,
65693 fidl::endpoints::ClientEnd<StreamSocketMarker>,
65694 ),
65695 fidl_fuchsia_posix::Errno,
65696 >,
65697 ) -> Result<(), fidl::Error> {
65698 let _result = self.send_raw(result);
65699 self.drop_without_shutdown();
65700 _result
65701 }
65702
65703 fn send_raw(
65704 &self,
65705 mut result: Result<
65706 (
65707 Option<&fidl_fuchsia_net::SocketAddress>,
65708 fidl::endpoints::ClientEnd<StreamSocketMarker>,
65709 ),
65710 fidl_fuchsia_posix::Errno,
65711 >,
65712 ) -> Result<(), fidl::Error> {
65713 self.control_handle.inner.send::<fidl::encoding::ResultType<
65714 StreamSocketAcceptResponse,
65715 fidl_fuchsia_posix::Errno,
65716 >>(
65717 result,
65718 self.tx_id,
65719 0x5ab7ad620424c163,
65720 fidl::encoding::DynamicFlags::empty(),
65721 )
65722 }
65723}
65724
65725#[must_use = "FIDL methods require a response to be sent"]
65726#[derive(Debug)]
65727pub struct StreamSocketGetInfoResponder {
65728 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65729 tx_id: u32,
65730}
65731
65732impl std::ops::Drop for StreamSocketGetInfoResponder {
65736 fn drop(&mut self) {
65737 self.control_handle.shutdown();
65738 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65740 }
65741}
65742
65743impl fidl::endpoints::Responder for StreamSocketGetInfoResponder {
65744 type ControlHandle = StreamSocketControlHandle;
65745
65746 fn control_handle(&self) -> &StreamSocketControlHandle {
65747 &self.control_handle
65748 }
65749
65750 fn drop_without_shutdown(mut self) {
65751 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65753 std::mem::forget(self);
65755 }
65756}
65757
65758impl StreamSocketGetInfoResponder {
65759 pub fn send(
65763 self,
65764 mut result: Result<(Domain, StreamSocketProtocol), fidl_fuchsia_posix::Errno>,
65765 ) -> Result<(), fidl::Error> {
65766 let _result = self.send_raw(result);
65767 if _result.is_err() {
65768 self.control_handle.shutdown();
65769 }
65770 self.drop_without_shutdown();
65771 _result
65772 }
65773
65774 pub fn send_no_shutdown_on_err(
65776 self,
65777 mut result: Result<(Domain, StreamSocketProtocol), fidl_fuchsia_posix::Errno>,
65778 ) -> Result<(), fidl::Error> {
65779 let _result = self.send_raw(result);
65780 self.drop_without_shutdown();
65781 _result
65782 }
65783
65784 fn send_raw(
65785 &self,
65786 mut result: Result<(Domain, StreamSocketProtocol), fidl_fuchsia_posix::Errno>,
65787 ) -> Result<(), fidl::Error> {
65788 self.control_handle.inner.send::<fidl::encoding::ResultType<
65789 StreamSocketGetInfoResponse,
65790 fidl_fuchsia_posix::Errno,
65791 >>(
65792 result,
65793 self.tx_id,
65794 0x87cfa55d19f878f,
65795 fidl::encoding::DynamicFlags::empty(),
65796 )
65797 }
65798}
65799
65800#[must_use = "FIDL methods require a response to be sent"]
65801#[derive(Debug)]
65802pub struct StreamSocketSetTcpNoDelayResponder {
65803 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65804 tx_id: u32,
65805}
65806
65807impl std::ops::Drop for StreamSocketSetTcpNoDelayResponder {
65811 fn drop(&mut self) {
65812 self.control_handle.shutdown();
65813 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65815 }
65816}
65817
65818impl fidl::endpoints::Responder for StreamSocketSetTcpNoDelayResponder {
65819 type ControlHandle = StreamSocketControlHandle;
65820
65821 fn control_handle(&self) -> &StreamSocketControlHandle {
65822 &self.control_handle
65823 }
65824
65825 fn drop_without_shutdown(mut self) {
65826 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65828 std::mem::forget(self);
65830 }
65831}
65832
65833impl StreamSocketSetTcpNoDelayResponder {
65834 pub fn send(
65838 self,
65839 mut result: Result<(), fidl_fuchsia_posix::Errno>,
65840 ) -> Result<(), fidl::Error> {
65841 let _result = self.send_raw(result);
65842 if _result.is_err() {
65843 self.control_handle.shutdown();
65844 }
65845 self.drop_without_shutdown();
65846 _result
65847 }
65848
65849 pub fn send_no_shutdown_on_err(
65851 self,
65852 mut result: Result<(), fidl_fuchsia_posix::Errno>,
65853 ) -> Result<(), fidl::Error> {
65854 let _result = self.send_raw(result);
65855 self.drop_without_shutdown();
65856 _result
65857 }
65858
65859 fn send_raw(
65860 &self,
65861 mut result: Result<(), fidl_fuchsia_posix::Errno>,
65862 ) -> Result<(), fidl::Error> {
65863 self.control_handle.inner.send::<fidl::encoding::ResultType<
65864 fidl::encoding::EmptyStruct,
65865 fidl_fuchsia_posix::Errno,
65866 >>(
65867 result,
65868 self.tx_id,
65869 0x5a59b778f7333ada,
65870 fidl::encoding::DynamicFlags::empty(),
65871 )
65872 }
65873}
65874
65875#[must_use = "FIDL methods require a response to be sent"]
65876#[derive(Debug)]
65877pub struct StreamSocketGetTcpNoDelayResponder {
65878 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65879 tx_id: u32,
65880}
65881
65882impl std::ops::Drop for StreamSocketGetTcpNoDelayResponder {
65886 fn drop(&mut self) {
65887 self.control_handle.shutdown();
65888 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65890 }
65891}
65892
65893impl fidl::endpoints::Responder for StreamSocketGetTcpNoDelayResponder {
65894 type ControlHandle = StreamSocketControlHandle;
65895
65896 fn control_handle(&self) -> &StreamSocketControlHandle {
65897 &self.control_handle
65898 }
65899
65900 fn drop_without_shutdown(mut self) {
65901 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65903 std::mem::forget(self);
65905 }
65906}
65907
65908impl StreamSocketGetTcpNoDelayResponder {
65909 pub fn send(
65913 self,
65914 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65915 ) -> Result<(), fidl::Error> {
65916 let _result = self.send_raw(result);
65917 if _result.is_err() {
65918 self.control_handle.shutdown();
65919 }
65920 self.drop_without_shutdown();
65921 _result
65922 }
65923
65924 pub fn send_no_shutdown_on_err(
65926 self,
65927 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65928 ) -> Result<(), fidl::Error> {
65929 let _result = self.send_raw(result);
65930 self.drop_without_shutdown();
65931 _result
65932 }
65933
65934 fn send_raw(
65935 &self,
65936 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65937 ) -> Result<(), fidl::Error> {
65938 self.control_handle.inner.send::<fidl::encoding::ResultType<
65939 StreamSocketGetTcpNoDelayResponse,
65940 fidl_fuchsia_posix::Errno,
65941 >>(
65942 result.map(|value| (value,)),
65943 self.tx_id,
65944 0xac219a3218b0799,
65945 fidl::encoding::DynamicFlags::empty(),
65946 )
65947 }
65948}
65949
65950#[must_use = "FIDL methods require a response to be sent"]
65951#[derive(Debug)]
65952pub struct StreamSocketSetTcpMaxSegmentResponder {
65953 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65954 tx_id: u32,
65955}
65956
65957impl std::ops::Drop for StreamSocketSetTcpMaxSegmentResponder {
65961 fn drop(&mut self) {
65962 self.control_handle.shutdown();
65963 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65965 }
65966}
65967
65968impl fidl::endpoints::Responder for StreamSocketSetTcpMaxSegmentResponder {
65969 type ControlHandle = StreamSocketControlHandle;
65970
65971 fn control_handle(&self) -> &StreamSocketControlHandle {
65972 &self.control_handle
65973 }
65974
65975 fn drop_without_shutdown(mut self) {
65976 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65978 std::mem::forget(self);
65980 }
65981}
65982
65983impl StreamSocketSetTcpMaxSegmentResponder {
65984 pub fn send(
65988 self,
65989 mut result: Result<(), fidl_fuchsia_posix::Errno>,
65990 ) -> Result<(), fidl::Error> {
65991 let _result = self.send_raw(result);
65992 if _result.is_err() {
65993 self.control_handle.shutdown();
65994 }
65995 self.drop_without_shutdown();
65996 _result
65997 }
65998
65999 pub fn send_no_shutdown_on_err(
66001 self,
66002 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66003 ) -> Result<(), fidl::Error> {
66004 let _result = self.send_raw(result);
66005 self.drop_without_shutdown();
66006 _result
66007 }
66008
66009 fn send_raw(
66010 &self,
66011 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66012 ) -> Result<(), fidl::Error> {
66013 self.control_handle.inner.send::<fidl::encoding::ResultType<
66014 fidl::encoding::EmptyStruct,
66015 fidl_fuchsia_posix::Errno,
66016 >>(
66017 result,
66018 self.tx_id,
66019 0xb3d30c498266d18,
66020 fidl::encoding::DynamicFlags::empty(),
66021 )
66022 }
66023}
66024
66025#[must_use = "FIDL methods require a response to be sent"]
66026#[derive(Debug)]
66027pub struct StreamSocketGetTcpMaxSegmentResponder {
66028 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66029 tx_id: u32,
66030}
66031
66032impl std::ops::Drop for StreamSocketGetTcpMaxSegmentResponder {
66036 fn drop(&mut self) {
66037 self.control_handle.shutdown();
66038 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66040 }
66041}
66042
66043impl fidl::endpoints::Responder for StreamSocketGetTcpMaxSegmentResponder {
66044 type ControlHandle = StreamSocketControlHandle;
66045
66046 fn control_handle(&self) -> &StreamSocketControlHandle {
66047 &self.control_handle
66048 }
66049
66050 fn drop_without_shutdown(mut self) {
66051 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66053 std::mem::forget(self);
66055 }
66056}
66057
66058impl StreamSocketGetTcpMaxSegmentResponder {
66059 pub fn send(
66063 self,
66064 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66065 ) -> Result<(), fidl::Error> {
66066 let _result = self.send_raw(result);
66067 if _result.is_err() {
66068 self.control_handle.shutdown();
66069 }
66070 self.drop_without_shutdown();
66071 _result
66072 }
66073
66074 pub fn send_no_shutdown_on_err(
66076 self,
66077 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66078 ) -> Result<(), fidl::Error> {
66079 let _result = self.send_raw(result);
66080 self.drop_without_shutdown();
66081 _result
66082 }
66083
66084 fn send_raw(
66085 &self,
66086 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66087 ) -> Result<(), fidl::Error> {
66088 self.control_handle.inner.send::<fidl::encoding::ResultType<
66089 StreamSocketGetTcpMaxSegmentResponse,
66090 fidl_fuchsia_posix::Errno,
66091 >>(
66092 result.map(|value_bytes| (value_bytes,)),
66093 self.tx_id,
66094 0x637404d1b4b9982c,
66095 fidl::encoding::DynamicFlags::empty(),
66096 )
66097 }
66098}
66099
66100#[must_use = "FIDL methods require a response to be sent"]
66101#[derive(Debug)]
66102pub struct StreamSocketSetTcpCorkResponder {
66103 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66104 tx_id: u32,
66105}
66106
66107impl std::ops::Drop for StreamSocketSetTcpCorkResponder {
66111 fn drop(&mut self) {
66112 self.control_handle.shutdown();
66113 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66115 }
66116}
66117
66118impl fidl::endpoints::Responder for StreamSocketSetTcpCorkResponder {
66119 type ControlHandle = StreamSocketControlHandle;
66120
66121 fn control_handle(&self) -> &StreamSocketControlHandle {
66122 &self.control_handle
66123 }
66124
66125 fn drop_without_shutdown(mut self) {
66126 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66128 std::mem::forget(self);
66130 }
66131}
66132
66133impl StreamSocketSetTcpCorkResponder {
66134 pub fn send(
66138 self,
66139 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66140 ) -> Result<(), fidl::Error> {
66141 let _result = self.send_raw(result);
66142 if _result.is_err() {
66143 self.control_handle.shutdown();
66144 }
66145 self.drop_without_shutdown();
66146 _result
66147 }
66148
66149 pub fn send_no_shutdown_on_err(
66151 self,
66152 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66153 ) -> Result<(), fidl::Error> {
66154 let _result = self.send_raw(result);
66155 self.drop_without_shutdown();
66156 _result
66157 }
66158
66159 fn send_raw(
66160 &self,
66161 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66162 ) -> Result<(), fidl::Error> {
66163 self.control_handle.inner.send::<fidl::encoding::ResultType<
66164 fidl::encoding::EmptyStruct,
66165 fidl_fuchsia_posix::Errno,
66166 >>(
66167 result,
66168 self.tx_id,
66169 0x62e26891541143a0,
66170 fidl::encoding::DynamicFlags::empty(),
66171 )
66172 }
66173}
66174
66175#[must_use = "FIDL methods require a response to be sent"]
66176#[derive(Debug)]
66177pub struct StreamSocketGetTcpCorkResponder {
66178 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66179 tx_id: u32,
66180}
66181
66182impl std::ops::Drop for StreamSocketGetTcpCorkResponder {
66186 fn drop(&mut self) {
66187 self.control_handle.shutdown();
66188 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66190 }
66191}
66192
66193impl fidl::endpoints::Responder for StreamSocketGetTcpCorkResponder {
66194 type ControlHandle = StreamSocketControlHandle;
66195
66196 fn control_handle(&self) -> &StreamSocketControlHandle {
66197 &self.control_handle
66198 }
66199
66200 fn drop_without_shutdown(mut self) {
66201 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66203 std::mem::forget(self);
66205 }
66206}
66207
66208impl StreamSocketGetTcpCorkResponder {
66209 pub fn send(
66213 self,
66214 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
66215 ) -> Result<(), fidl::Error> {
66216 let _result = self.send_raw(result);
66217 if _result.is_err() {
66218 self.control_handle.shutdown();
66219 }
66220 self.drop_without_shutdown();
66221 _result
66222 }
66223
66224 pub fn send_no_shutdown_on_err(
66226 self,
66227 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
66228 ) -> Result<(), fidl::Error> {
66229 let _result = self.send_raw(result);
66230 self.drop_without_shutdown();
66231 _result
66232 }
66233
66234 fn send_raw(
66235 &self,
66236 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
66237 ) -> Result<(), fidl::Error> {
66238 self.control_handle.inner.send::<fidl::encoding::ResultType<
66239 StreamSocketGetTcpCorkResponse,
66240 fidl_fuchsia_posix::Errno,
66241 >>(
66242 result.map(|value| (value,)),
66243 self.tx_id,
66244 0x435bb232e0e74f32,
66245 fidl::encoding::DynamicFlags::empty(),
66246 )
66247 }
66248}
66249
66250#[must_use = "FIDL methods require a response to be sent"]
66251#[derive(Debug)]
66252pub struct StreamSocketSetTcpKeepAliveIdleResponder {
66253 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66254 tx_id: u32,
66255}
66256
66257impl std::ops::Drop for StreamSocketSetTcpKeepAliveIdleResponder {
66261 fn drop(&mut self) {
66262 self.control_handle.shutdown();
66263 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66265 }
66266}
66267
66268impl fidl::endpoints::Responder for StreamSocketSetTcpKeepAliveIdleResponder {
66269 type ControlHandle = StreamSocketControlHandle;
66270
66271 fn control_handle(&self) -> &StreamSocketControlHandle {
66272 &self.control_handle
66273 }
66274
66275 fn drop_without_shutdown(mut self) {
66276 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66278 std::mem::forget(self);
66280 }
66281}
66282
66283impl StreamSocketSetTcpKeepAliveIdleResponder {
66284 pub fn send(
66288 self,
66289 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66290 ) -> Result<(), fidl::Error> {
66291 let _result = self.send_raw(result);
66292 if _result.is_err() {
66293 self.control_handle.shutdown();
66294 }
66295 self.drop_without_shutdown();
66296 _result
66297 }
66298
66299 pub fn send_no_shutdown_on_err(
66301 self,
66302 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66303 ) -> Result<(), fidl::Error> {
66304 let _result = self.send_raw(result);
66305 self.drop_without_shutdown();
66306 _result
66307 }
66308
66309 fn send_raw(
66310 &self,
66311 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66312 ) -> Result<(), fidl::Error> {
66313 self.control_handle.inner.send::<fidl::encoding::ResultType<
66314 fidl::encoding::EmptyStruct,
66315 fidl_fuchsia_posix::Errno,
66316 >>(
66317 result,
66318 self.tx_id,
66319 0x196d053d8363c42,
66320 fidl::encoding::DynamicFlags::empty(),
66321 )
66322 }
66323}
66324
66325#[must_use = "FIDL methods require a response to be sent"]
66326#[derive(Debug)]
66327pub struct StreamSocketGetTcpKeepAliveIdleResponder {
66328 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66329 tx_id: u32,
66330}
66331
66332impl std::ops::Drop for StreamSocketGetTcpKeepAliveIdleResponder {
66336 fn drop(&mut self) {
66337 self.control_handle.shutdown();
66338 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66340 }
66341}
66342
66343impl fidl::endpoints::Responder for StreamSocketGetTcpKeepAliveIdleResponder {
66344 type ControlHandle = StreamSocketControlHandle;
66345
66346 fn control_handle(&self) -> &StreamSocketControlHandle {
66347 &self.control_handle
66348 }
66349
66350 fn drop_without_shutdown(mut self) {
66351 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66353 std::mem::forget(self);
66355 }
66356}
66357
66358impl StreamSocketGetTcpKeepAliveIdleResponder {
66359 pub fn send(
66363 self,
66364 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66365 ) -> Result<(), fidl::Error> {
66366 let _result = self.send_raw(result);
66367 if _result.is_err() {
66368 self.control_handle.shutdown();
66369 }
66370 self.drop_without_shutdown();
66371 _result
66372 }
66373
66374 pub fn send_no_shutdown_on_err(
66376 self,
66377 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66378 ) -> Result<(), fidl::Error> {
66379 let _result = self.send_raw(result);
66380 self.drop_without_shutdown();
66381 _result
66382 }
66383
66384 fn send_raw(
66385 &self,
66386 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66387 ) -> Result<(), fidl::Error> {
66388 self.control_handle.inner.send::<fidl::encoding::ResultType<
66389 StreamSocketGetTcpKeepAliveIdleResponse,
66390 fidl_fuchsia_posix::Errno,
66391 >>(
66392 result.map(|value_secs| (value_secs,)),
66393 self.tx_id,
66394 0x35ec58564879dac,
66395 fidl::encoding::DynamicFlags::empty(),
66396 )
66397 }
66398}
66399
66400#[must_use = "FIDL methods require a response to be sent"]
66401#[derive(Debug)]
66402pub struct StreamSocketSetTcpKeepAliveIntervalResponder {
66403 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66404 tx_id: u32,
66405}
66406
66407impl std::ops::Drop for StreamSocketSetTcpKeepAliveIntervalResponder {
66411 fn drop(&mut self) {
66412 self.control_handle.shutdown();
66413 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66415 }
66416}
66417
66418impl fidl::endpoints::Responder for StreamSocketSetTcpKeepAliveIntervalResponder {
66419 type ControlHandle = StreamSocketControlHandle;
66420
66421 fn control_handle(&self) -> &StreamSocketControlHandle {
66422 &self.control_handle
66423 }
66424
66425 fn drop_without_shutdown(mut self) {
66426 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66428 std::mem::forget(self);
66430 }
66431}
66432
66433impl StreamSocketSetTcpKeepAliveIntervalResponder {
66434 pub fn send(
66438 self,
66439 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66440 ) -> Result<(), fidl::Error> {
66441 let _result = self.send_raw(result);
66442 if _result.is_err() {
66443 self.control_handle.shutdown();
66444 }
66445 self.drop_without_shutdown();
66446 _result
66447 }
66448
66449 pub fn send_no_shutdown_on_err(
66451 self,
66452 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66453 ) -> Result<(), fidl::Error> {
66454 let _result = self.send_raw(result);
66455 self.drop_without_shutdown();
66456 _result
66457 }
66458
66459 fn send_raw(
66460 &self,
66461 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66462 ) -> Result<(), fidl::Error> {
66463 self.control_handle.inner.send::<fidl::encoding::ResultType<
66464 fidl::encoding::EmptyStruct,
66465 fidl_fuchsia_posix::Errno,
66466 >>(
66467 result,
66468 self.tx_id,
66469 0x485ffbc2da1243f2,
66470 fidl::encoding::DynamicFlags::empty(),
66471 )
66472 }
66473}
66474
66475#[must_use = "FIDL methods require a response to be sent"]
66476#[derive(Debug)]
66477pub struct StreamSocketGetTcpKeepAliveIntervalResponder {
66478 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66479 tx_id: u32,
66480}
66481
66482impl std::ops::Drop for StreamSocketGetTcpKeepAliveIntervalResponder {
66486 fn drop(&mut self) {
66487 self.control_handle.shutdown();
66488 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66490 }
66491}
66492
66493impl fidl::endpoints::Responder for StreamSocketGetTcpKeepAliveIntervalResponder {
66494 type ControlHandle = StreamSocketControlHandle;
66495
66496 fn control_handle(&self) -> &StreamSocketControlHandle {
66497 &self.control_handle
66498 }
66499
66500 fn drop_without_shutdown(mut self) {
66501 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66503 std::mem::forget(self);
66505 }
66506}
66507
66508impl StreamSocketGetTcpKeepAliveIntervalResponder {
66509 pub fn send(
66513 self,
66514 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66515 ) -> Result<(), fidl::Error> {
66516 let _result = self.send_raw(result);
66517 if _result.is_err() {
66518 self.control_handle.shutdown();
66519 }
66520 self.drop_without_shutdown();
66521 _result
66522 }
66523
66524 pub fn send_no_shutdown_on_err(
66526 self,
66527 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66528 ) -> Result<(), fidl::Error> {
66529 let _result = self.send_raw(result);
66530 self.drop_without_shutdown();
66531 _result
66532 }
66533
66534 fn send_raw(
66535 &self,
66536 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66537 ) -> Result<(), fidl::Error> {
66538 self.control_handle.inner.send::<fidl::encoding::ResultType<
66539 StreamSocketGetTcpKeepAliveIntervalResponse,
66540 fidl_fuchsia_posix::Errno,
66541 >>(
66542 result.map(|value_secs| (value_secs,)),
66543 self.tx_id,
66544 0x264eaf46306b284,
66545 fidl::encoding::DynamicFlags::empty(),
66546 )
66547 }
66548}
66549
66550#[must_use = "FIDL methods require a response to be sent"]
66551#[derive(Debug)]
66552pub struct StreamSocketSetTcpKeepAliveCountResponder {
66553 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66554 tx_id: u32,
66555}
66556
66557impl std::ops::Drop for StreamSocketSetTcpKeepAliveCountResponder {
66561 fn drop(&mut self) {
66562 self.control_handle.shutdown();
66563 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66565 }
66566}
66567
66568impl fidl::endpoints::Responder for StreamSocketSetTcpKeepAliveCountResponder {
66569 type ControlHandle = StreamSocketControlHandle;
66570
66571 fn control_handle(&self) -> &StreamSocketControlHandle {
66572 &self.control_handle
66573 }
66574
66575 fn drop_without_shutdown(mut self) {
66576 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66578 std::mem::forget(self);
66580 }
66581}
66582
66583impl StreamSocketSetTcpKeepAliveCountResponder {
66584 pub fn send(
66588 self,
66589 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66590 ) -> Result<(), fidl::Error> {
66591 let _result = self.send_raw(result);
66592 if _result.is_err() {
66593 self.control_handle.shutdown();
66594 }
66595 self.drop_without_shutdown();
66596 _result
66597 }
66598
66599 pub fn send_no_shutdown_on_err(
66601 self,
66602 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66603 ) -> Result<(), fidl::Error> {
66604 let _result = self.send_raw(result);
66605 self.drop_without_shutdown();
66606 _result
66607 }
66608
66609 fn send_raw(
66610 &self,
66611 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66612 ) -> Result<(), fidl::Error> {
66613 self.control_handle.inner.send::<fidl::encoding::ResultType<
66614 fidl::encoding::EmptyStruct,
66615 fidl_fuchsia_posix::Errno,
66616 >>(
66617 result,
66618 self.tx_id,
66619 0x2ab2e8c111708421,
66620 fidl::encoding::DynamicFlags::empty(),
66621 )
66622 }
66623}
66624
66625#[must_use = "FIDL methods require a response to be sent"]
66626#[derive(Debug)]
66627pub struct StreamSocketGetTcpKeepAliveCountResponder {
66628 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66629 tx_id: u32,
66630}
66631
66632impl std::ops::Drop for StreamSocketGetTcpKeepAliveCountResponder {
66636 fn drop(&mut self) {
66637 self.control_handle.shutdown();
66638 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66640 }
66641}
66642
66643impl fidl::endpoints::Responder for StreamSocketGetTcpKeepAliveCountResponder {
66644 type ControlHandle = StreamSocketControlHandle;
66645
66646 fn control_handle(&self) -> &StreamSocketControlHandle {
66647 &self.control_handle
66648 }
66649
66650 fn drop_without_shutdown(mut self) {
66651 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66653 std::mem::forget(self);
66655 }
66656}
66657
66658impl StreamSocketGetTcpKeepAliveCountResponder {
66659 pub fn send(
66663 self,
66664 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66665 ) -> Result<(), fidl::Error> {
66666 let _result = self.send_raw(result);
66667 if _result.is_err() {
66668 self.control_handle.shutdown();
66669 }
66670 self.drop_without_shutdown();
66671 _result
66672 }
66673
66674 pub fn send_no_shutdown_on_err(
66676 self,
66677 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66678 ) -> Result<(), fidl::Error> {
66679 let _result = self.send_raw(result);
66680 self.drop_without_shutdown();
66681 _result
66682 }
66683
66684 fn send_raw(
66685 &self,
66686 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66687 ) -> Result<(), fidl::Error> {
66688 self.control_handle.inner.send::<fidl::encoding::ResultType<
66689 StreamSocketGetTcpKeepAliveCountResponse,
66690 fidl_fuchsia_posix::Errno,
66691 >>(
66692 result.map(|value| (value,)),
66693 self.tx_id,
66694 0x2f176ae271fe7a09,
66695 fidl::encoding::DynamicFlags::empty(),
66696 )
66697 }
66698}
66699
66700#[must_use = "FIDL methods require a response to be sent"]
66701#[derive(Debug)]
66702pub struct StreamSocketSetTcpSynCountResponder {
66703 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66704 tx_id: u32,
66705}
66706
66707impl std::ops::Drop for StreamSocketSetTcpSynCountResponder {
66711 fn drop(&mut self) {
66712 self.control_handle.shutdown();
66713 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66715 }
66716}
66717
66718impl fidl::endpoints::Responder for StreamSocketSetTcpSynCountResponder {
66719 type ControlHandle = StreamSocketControlHandle;
66720
66721 fn control_handle(&self) -> &StreamSocketControlHandle {
66722 &self.control_handle
66723 }
66724
66725 fn drop_without_shutdown(mut self) {
66726 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66728 std::mem::forget(self);
66730 }
66731}
66732
66733impl StreamSocketSetTcpSynCountResponder {
66734 pub fn send(
66738 self,
66739 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66740 ) -> Result<(), fidl::Error> {
66741 let _result = self.send_raw(result);
66742 if _result.is_err() {
66743 self.control_handle.shutdown();
66744 }
66745 self.drop_without_shutdown();
66746 _result
66747 }
66748
66749 pub fn send_no_shutdown_on_err(
66751 self,
66752 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66753 ) -> Result<(), fidl::Error> {
66754 let _result = self.send_raw(result);
66755 self.drop_without_shutdown();
66756 _result
66757 }
66758
66759 fn send_raw(
66760 &self,
66761 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66762 ) -> Result<(), fidl::Error> {
66763 self.control_handle.inner.send::<fidl::encoding::ResultType<
66764 fidl::encoding::EmptyStruct,
66765 fidl_fuchsia_posix::Errno,
66766 >>(
66767 result,
66768 self.tx_id,
66769 0x4dcd6ab5573c1eb3,
66770 fidl::encoding::DynamicFlags::empty(),
66771 )
66772 }
66773}
66774
66775#[must_use = "FIDL methods require a response to be sent"]
66776#[derive(Debug)]
66777pub struct StreamSocketGetTcpSynCountResponder {
66778 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66779 tx_id: u32,
66780}
66781
66782impl std::ops::Drop for StreamSocketGetTcpSynCountResponder {
66786 fn drop(&mut self) {
66787 self.control_handle.shutdown();
66788 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66790 }
66791}
66792
66793impl fidl::endpoints::Responder for StreamSocketGetTcpSynCountResponder {
66794 type ControlHandle = StreamSocketControlHandle;
66795
66796 fn control_handle(&self) -> &StreamSocketControlHandle {
66797 &self.control_handle
66798 }
66799
66800 fn drop_without_shutdown(mut self) {
66801 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66803 std::mem::forget(self);
66805 }
66806}
66807
66808impl StreamSocketGetTcpSynCountResponder {
66809 pub fn send(
66813 self,
66814 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66815 ) -> Result<(), fidl::Error> {
66816 let _result = self.send_raw(result);
66817 if _result.is_err() {
66818 self.control_handle.shutdown();
66819 }
66820 self.drop_without_shutdown();
66821 _result
66822 }
66823
66824 pub fn send_no_shutdown_on_err(
66826 self,
66827 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66828 ) -> Result<(), fidl::Error> {
66829 let _result = self.send_raw(result);
66830 self.drop_without_shutdown();
66831 _result
66832 }
66833
66834 fn send_raw(
66835 &self,
66836 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66837 ) -> Result<(), fidl::Error> {
66838 self.control_handle.inner.send::<fidl::encoding::ResultType<
66839 StreamSocketGetTcpSynCountResponse,
66840 fidl_fuchsia_posix::Errno,
66841 >>(
66842 result.map(|value| (value,)),
66843 self.tx_id,
66844 0x7d457cba8f5f3ee6,
66845 fidl::encoding::DynamicFlags::empty(),
66846 )
66847 }
66848}
66849
66850#[must_use = "FIDL methods require a response to be sent"]
66851#[derive(Debug)]
66852pub struct StreamSocketSetTcpLingerResponder {
66853 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66854 tx_id: u32,
66855}
66856
66857impl std::ops::Drop for StreamSocketSetTcpLingerResponder {
66861 fn drop(&mut self) {
66862 self.control_handle.shutdown();
66863 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66865 }
66866}
66867
66868impl fidl::endpoints::Responder for StreamSocketSetTcpLingerResponder {
66869 type ControlHandle = StreamSocketControlHandle;
66870
66871 fn control_handle(&self) -> &StreamSocketControlHandle {
66872 &self.control_handle
66873 }
66874
66875 fn drop_without_shutdown(mut self) {
66876 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66878 std::mem::forget(self);
66880 }
66881}
66882
66883impl StreamSocketSetTcpLingerResponder {
66884 pub fn send(
66888 self,
66889 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66890 ) -> Result<(), fidl::Error> {
66891 let _result = self.send_raw(result);
66892 if _result.is_err() {
66893 self.control_handle.shutdown();
66894 }
66895 self.drop_without_shutdown();
66896 _result
66897 }
66898
66899 pub fn send_no_shutdown_on_err(
66901 self,
66902 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66903 ) -> Result<(), fidl::Error> {
66904 let _result = self.send_raw(result);
66905 self.drop_without_shutdown();
66906 _result
66907 }
66908
66909 fn send_raw(
66910 &self,
66911 mut result: Result<(), fidl_fuchsia_posix::Errno>,
66912 ) -> Result<(), fidl::Error> {
66913 self.control_handle.inner.send::<fidl::encoding::ResultType<
66914 fidl::encoding::EmptyStruct,
66915 fidl_fuchsia_posix::Errno,
66916 >>(
66917 result,
66918 self.tx_id,
66919 0xd5cc1e8654d36e4,
66920 fidl::encoding::DynamicFlags::empty(),
66921 )
66922 }
66923}
66924
66925#[must_use = "FIDL methods require a response to be sent"]
66926#[derive(Debug)]
66927pub struct StreamSocketGetTcpLingerResponder {
66928 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66929 tx_id: u32,
66930}
66931
66932impl std::ops::Drop for StreamSocketGetTcpLingerResponder {
66936 fn drop(&mut self) {
66937 self.control_handle.shutdown();
66938 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66940 }
66941}
66942
66943impl fidl::endpoints::Responder for StreamSocketGetTcpLingerResponder {
66944 type ControlHandle = StreamSocketControlHandle;
66945
66946 fn control_handle(&self) -> &StreamSocketControlHandle {
66947 &self.control_handle
66948 }
66949
66950 fn drop_without_shutdown(mut self) {
66951 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66953 std::mem::forget(self);
66955 }
66956}
66957
66958impl StreamSocketGetTcpLingerResponder {
66959 pub fn send(
66963 self,
66964 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
66965 ) -> Result<(), fidl::Error> {
66966 let _result = self.send_raw(result);
66967 if _result.is_err() {
66968 self.control_handle.shutdown();
66969 }
66970 self.drop_without_shutdown();
66971 _result
66972 }
66973
66974 pub fn send_no_shutdown_on_err(
66976 self,
66977 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
66978 ) -> Result<(), fidl::Error> {
66979 let _result = self.send_raw(result);
66980 self.drop_without_shutdown();
66981 _result
66982 }
66983
66984 fn send_raw(
66985 &self,
66986 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
66987 ) -> Result<(), fidl::Error> {
66988 self.control_handle.inner.send::<fidl::encoding::ResultType<
66989 StreamSocketGetTcpLingerResponse,
66990 fidl_fuchsia_posix::Errno,
66991 >>(
66992 result.map(|value_secs| (value_secs,)),
66993 self.tx_id,
66994 0xad870d311cf30eb,
66995 fidl::encoding::DynamicFlags::empty(),
66996 )
66997 }
66998}
66999
67000#[must_use = "FIDL methods require a response to be sent"]
67001#[derive(Debug)]
67002pub struct StreamSocketSetTcpDeferAcceptResponder {
67003 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67004 tx_id: u32,
67005}
67006
67007impl std::ops::Drop for StreamSocketSetTcpDeferAcceptResponder {
67011 fn drop(&mut self) {
67012 self.control_handle.shutdown();
67013 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67015 }
67016}
67017
67018impl fidl::endpoints::Responder for StreamSocketSetTcpDeferAcceptResponder {
67019 type ControlHandle = StreamSocketControlHandle;
67020
67021 fn control_handle(&self) -> &StreamSocketControlHandle {
67022 &self.control_handle
67023 }
67024
67025 fn drop_without_shutdown(mut self) {
67026 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67028 std::mem::forget(self);
67030 }
67031}
67032
67033impl StreamSocketSetTcpDeferAcceptResponder {
67034 pub fn send(
67038 self,
67039 mut result: Result<(), fidl_fuchsia_posix::Errno>,
67040 ) -> Result<(), fidl::Error> {
67041 let _result = self.send_raw(result);
67042 if _result.is_err() {
67043 self.control_handle.shutdown();
67044 }
67045 self.drop_without_shutdown();
67046 _result
67047 }
67048
67049 pub fn send_no_shutdown_on_err(
67051 self,
67052 mut result: Result<(), fidl_fuchsia_posix::Errno>,
67053 ) -> Result<(), fidl::Error> {
67054 let _result = self.send_raw(result);
67055 self.drop_without_shutdown();
67056 _result
67057 }
67058
67059 fn send_raw(
67060 &self,
67061 mut result: Result<(), fidl_fuchsia_posix::Errno>,
67062 ) -> Result<(), fidl::Error> {
67063 self.control_handle.inner.send::<fidl::encoding::ResultType<
67064 fidl::encoding::EmptyStruct,
67065 fidl_fuchsia_posix::Errno,
67066 >>(
67067 result,
67068 self.tx_id,
67069 0x15092f181e57c404,
67070 fidl::encoding::DynamicFlags::empty(),
67071 )
67072 }
67073}
67074
67075#[must_use = "FIDL methods require a response to be sent"]
67076#[derive(Debug)]
67077pub struct StreamSocketGetTcpDeferAcceptResponder {
67078 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67079 tx_id: u32,
67080}
67081
67082impl std::ops::Drop for StreamSocketGetTcpDeferAcceptResponder {
67086 fn drop(&mut self) {
67087 self.control_handle.shutdown();
67088 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67090 }
67091}
67092
67093impl fidl::endpoints::Responder for StreamSocketGetTcpDeferAcceptResponder {
67094 type ControlHandle = StreamSocketControlHandle;
67095
67096 fn control_handle(&self) -> &StreamSocketControlHandle {
67097 &self.control_handle
67098 }
67099
67100 fn drop_without_shutdown(mut self) {
67101 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67103 std::mem::forget(self);
67105 }
67106}
67107
67108impl StreamSocketGetTcpDeferAcceptResponder {
67109 pub fn send(
67113 self,
67114 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67115 ) -> Result<(), fidl::Error> {
67116 let _result = self.send_raw(result);
67117 if _result.is_err() {
67118 self.control_handle.shutdown();
67119 }
67120 self.drop_without_shutdown();
67121 _result
67122 }
67123
67124 pub fn send_no_shutdown_on_err(
67126 self,
67127 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67128 ) -> Result<(), fidl::Error> {
67129 let _result = self.send_raw(result);
67130 self.drop_without_shutdown();
67131 _result
67132 }
67133
67134 fn send_raw(
67135 &self,
67136 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67137 ) -> Result<(), fidl::Error> {
67138 self.control_handle.inner.send::<fidl::encoding::ResultType<
67139 StreamSocketGetTcpDeferAcceptResponse,
67140 fidl_fuchsia_posix::Errno,
67141 >>(
67142 result.map(|value_secs| (value_secs,)),
67143 self.tx_id,
67144 0x64589790842cb7c6,
67145 fidl::encoding::DynamicFlags::empty(),
67146 )
67147 }
67148}
67149
67150#[must_use = "FIDL methods require a response to be sent"]
67151#[derive(Debug)]
67152pub struct StreamSocketSetTcpWindowClampResponder {
67153 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67154 tx_id: u32,
67155}
67156
67157impl std::ops::Drop for StreamSocketSetTcpWindowClampResponder {
67161 fn drop(&mut self) {
67162 self.control_handle.shutdown();
67163 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67165 }
67166}
67167
67168impl fidl::endpoints::Responder for StreamSocketSetTcpWindowClampResponder {
67169 type ControlHandle = StreamSocketControlHandle;
67170
67171 fn control_handle(&self) -> &StreamSocketControlHandle {
67172 &self.control_handle
67173 }
67174
67175 fn drop_without_shutdown(mut self) {
67176 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67178 std::mem::forget(self);
67180 }
67181}
67182
67183impl StreamSocketSetTcpWindowClampResponder {
67184 pub fn send(
67188 self,
67189 mut result: Result<(), fidl_fuchsia_posix::Errno>,
67190 ) -> Result<(), fidl::Error> {
67191 let _result = self.send_raw(result);
67192 if _result.is_err() {
67193 self.control_handle.shutdown();
67194 }
67195 self.drop_without_shutdown();
67196 _result
67197 }
67198
67199 pub fn send_no_shutdown_on_err(
67201 self,
67202 mut result: Result<(), fidl_fuchsia_posix::Errno>,
67203 ) -> Result<(), fidl::Error> {
67204 let _result = self.send_raw(result);
67205 self.drop_without_shutdown();
67206 _result
67207 }
67208
67209 fn send_raw(
67210 &self,
67211 mut result: Result<(), fidl_fuchsia_posix::Errno>,
67212 ) -> Result<(), fidl::Error> {
67213 self.control_handle.inner.send::<fidl::encoding::ResultType<
67214 fidl::encoding::EmptyStruct,
67215 fidl_fuchsia_posix::Errno,
67216 >>(
67217 result,
67218 self.tx_id,
67219 0x4a26ce07d847f1c6,
67220 fidl::encoding::DynamicFlags::empty(),
67221 )
67222 }
67223}
67224
67225#[must_use = "FIDL methods require a response to be sent"]
67226#[derive(Debug)]
67227pub struct StreamSocketGetTcpWindowClampResponder {
67228 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67229 tx_id: u32,
67230}
67231
67232impl std::ops::Drop for StreamSocketGetTcpWindowClampResponder {
67236 fn drop(&mut self) {
67237 self.control_handle.shutdown();
67238 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67240 }
67241}
67242
67243impl fidl::endpoints::Responder for StreamSocketGetTcpWindowClampResponder {
67244 type ControlHandle = StreamSocketControlHandle;
67245
67246 fn control_handle(&self) -> &StreamSocketControlHandle {
67247 &self.control_handle
67248 }
67249
67250 fn drop_without_shutdown(mut self) {
67251 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67253 std::mem::forget(self);
67255 }
67256}
67257
67258impl StreamSocketGetTcpWindowClampResponder {
67259 pub fn send(
67263 self,
67264 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67265 ) -> Result<(), fidl::Error> {
67266 let _result = self.send_raw(result);
67267 if _result.is_err() {
67268 self.control_handle.shutdown();
67269 }
67270 self.drop_without_shutdown();
67271 _result
67272 }
67273
67274 pub fn send_no_shutdown_on_err(
67276 self,
67277 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67278 ) -> Result<(), fidl::Error> {
67279 let _result = self.send_raw(result);
67280 self.drop_without_shutdown();
67281 _result
67282 }
67283
67284 fn send_raw(
67285 &self,
67286 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67287 ) -> Result<(), fidl::Error> {
67288 self.control_handle.inner.send::<fidl::encoding::ResultType<
67289 StreamSocketGetTcpWindowClampResponse,
67290 fidl_fuchsia_posix::Errno,
67291 >>(
67292 result.map(|value| (value,)),
67293 self.tx_id,
67294 0x2df6b636bf0a6a4e,
67295 fidl::encoding::DynamicFlags::empty(),
67296 )
67297 }
67298}
67299
67300#[must_use = "FIDL methods require a response to be sent"]
67301#[derive(Debug)]
67302pub struct StreamSocketGetTcpInfoResponder {
67303 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67304 tx_id: u32,
67305}
67306
67307impl std::ops::Drop for StreamSocketGetTcpInfoResponder {
67311 fn drop(&mut self) {
67312 self.control_handle.shutdown();
67313 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67315 }
67316}
67317
67318impl fidl::endpoints::Responder for StreamSocketGetTcpInfoResponder {
67319 type ControlHandle = StreamSocketControlHandle;
67320
67321 fn control_handle(&self) -> &StreamSocketControlHandle {
67322 &self.control_handle
67323 }
67324
67325 fn drop_without_shutdown(mut self) {
67326 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67328 std::mem::forget(self);
67330 }
67331}
67332
67333impl StreamSocketGetTcpInfoResponder {
67334 pub fn send(
67338 self,
67339 mut result: Result<&TcpInfo, fidl_fuchsia_posix::Errno>,
67340 ) -> Result<(), fidl::Error> {
67341 let _result = self.send_raw(result);
67342 if _result.is_err() {
67343 self.control_handle.shutdown();
67344 }
67345 self.drop_without_shutdown();
67346 _result
67347 }
67348
67349 pub fn send_no_shutdown_on_err(
67351 self,
67352 mut result: Result<&TcpInfo, fidl_fuchsia_posix::Errno>,
67353 ) -> Result<(), fidl::Error> {
67354 let _result = self.send_raw(result);
67355 self.drop_without_shutdown();
67356 _result
67357 }
67358
67359 fn send_raw(
67360 &self,
67361 mut result: Result<&TcpInfo, fidl_fuchsia_posix::Errno>,
67362 ) -> Result<(), fidl::Error> {
67363 self.control_handle.inner.send::<fidl::encoding::ResultType<
67364 StreamSocketGetTcpInfoResponse,
67365 fidl_fuchsia_posix::Errno,
67366 >>(
67367 result.map(|info| (info,)),
67368 self.tx_id,
67369 0x1ffb123d9f03ead2,
67370 fidl::encoding::DynamicFlags::empty(),
67371 )
67372 }
67373}
67374
67375#[must_use = "FIDL methods require a response to be sent"]
67376#[derive(Debug)]
67377pub struct StreamSocketSetTcpQuickAckResponder {
67378 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67379 tx_id: u32,
67380}
67381
67382impl std::ops::Drop for StreamSocketSetTcpQuickAckResponder {
67386 fn drop(&mut self) {
67387 self.control_handle.shutdown();
67388 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67390 }
67391}
67392
67393impl fidl::endpoints::Responder for StreamSocketSetTcpQuickAckResponder {
67394 type ControlHandle = StreamSocketControlHandle;
67395
67396 fn control_handle(&self) -> &StreamSocketControlHandle {
67397 &self.control_handle
67398 }
67399
67400 fn drop_without_shutdown(mut self) {
67401 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67403 std::mem::forget(self);
67405 }
67406}
67407
67408impl StreamSocketSetTcpQuickAckResponder {
67409 pub fn send(
67413 self,
67414 mut result: Result<(), fidl_fuchsia_posix::Errno>,
67415 ) -> Result<(), fidl::Error> {
67416 let _result = self.send_raw(result);
67417 if _result.is_err() {
67418 self.control_handle.shutdown();
67419 }
67420 self.drop_without_shutdown();
67421 _result
67422 }
67423
67424 pub fn send_no_shutdown_on_err(
67426 self,
67427 mut result: Result<(), fidl_fuchsia_posix::Errno>,
67428 ) -> Result<(), fidl::Error> {
67429 let _result = self.send_raw(result);
67430 self.drop_without_shutdown();
67431 _result
67432 }
67433
67434 fn send_raw(
67435 &self,
67436 mut result: Result<(), fidl_fuchsia_posix::Errno>,
67437 ) -> Result<(), fidl::Error> {
67438 self.control_handle.inner.send::<fidl::encoding::ResultType<
67439 fidl::encoding::EmptyStruct,
67440 fidl_fuchsia_posix::Errno,
67441 >>(
67442 result,
67443 self.tx_id,
67444 0x6fa811be8fde7457,
67445 fidl::encoding::DynamicFlags::empty(),
67446 )
67447 }
67448}
67449
67450#[must_use = "FIDL methods require a response to be sent"]
67451#[derive(Debug)]
67452pub struct StreamSocketGetTcpQuickAckResponder {
67453 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67454 tx_id: u32,
67455}
67456
67457impl std::ops::Drop for StreamSocketGetTcpQuickAckResponder {
67461 fn drop(&mut self) {
67462 self.control_handle.shutdown();
67463 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67465 }
67466}
67467
67468impl fidl::endpoints::Responder for StreamSocketGetTcpQuickAckResponder {
67469 type ControlHandle = StreamSocketControlHandle;
67470
67471 fn control_handle(&self) -> &StreamSocketControlHandle {
67472 &self.control_handle
67473 }
67474
67475 fn drop_without_shutdown(mut self) {
67476 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67478 std::mem::forget(self);
67480 }
67481}
67482
67483impl StreamSocketGetTcpQuickAckResponder {
67484 pub fn send(
67488 self,
67489 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
67490 ) -> Result<(), fidl::Error> {
67491 let _result = self.send_raw(result);
67492 if _result.is_err() {
67493 self.control_handle.shutdown();
67494 }
67495 self.drop_without_shutdown();
67496 _result
67497 }
67498
67499 pub fn send_no_shutdown_on_err(
67501 self,
67502 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
67503 ) -> Result<(), fidl::Error> {
67504 let _result = self.send_raw(result);
67505 self.drop_without_shutdown();
67506 _result
67507 }
67508
67509 fn send_raw(
67510 &self,
67511 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
67512 ) -> Result<(), fidl::Error> {
67513 self.control_handle.inner.send::<fidl::encoding::ResultType<
67514 StreamSocketGetTcpQuickAckResponse,
67515 fidl_fuchsia_posix::Errno,
67516 >>(
67517 result.map(|value| (value,)),
67518 self.tx_id,
67519 0x7356a949bef2df32,
67520 fidl::encoding::DynamicFlags::empty(),
67521 )
67522 }
67523}
67524
67525#[must_use = "FIDL methods require a response to be sent"]
67526#[derive(Debug)]
67527pub struct StreamSocketSetTcpCongestionResponder {
67528 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67529 tx_id: u32,
67530}
67531
67532impl std::ops::Drop for StreamSocketSetTcpCongestionResponder {
67536 fn drop(&mut self) {
67537 self.control_handle.shutdown();
67538 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67540 }
67541}
67542
67543impl fidl::endpoints::Responder for StreamSocketSetTcpCongestionResponder {
67544 type ControlHandle = StreamSocketControlHandle;
67545
67546 fn control_handle(&self) -> &StreamSocketControlHandle {
67547 &self.control_handle
67548 }
67549
67550 fn drop_without_shutdown(mut self) {
67551 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67553 std::mem::forget(self);
67555 }
67556}
67557
67558impl StreamSocketSetTcpCongestionResponder {
67559 pub fn send(
67563 self,
67564 mut result: Result<(), fidl_fuchsia_posix::Errno>,
67565 ) -> Result<(), fidl::Error> {
67566 let _result = self.send_raw(result);
67567 if _result.is_err() {
67568 self.control_handle.shutdown();
67569 }
67570 self.drop_without_shutdown();
67571 _result
67572 }
67573
67574 pub fn send_no_shutdown_on_err(
67576 self,
67577 mut result: Result<(), fidl_fuchsia_posix::Errno>,
67578 ) -> Result<(), fidl::Error> {
67579 let _result = self.send_raw(result);
67580 self.drop_without_shutdown();
67581 _result
67582 }
67583
67584 fn send_raw(
67585 &self,
67586 mut result: Result<(), fidl_fuchsia_posix::Errno>,
67587 ) -> Result<(), fidl::Error> {
67588 self.control_handle.inner.send::<fidl::encoding::ResultType<
67589 fidl::encoding::EmptyStruct,
67590 fidl_fuchsia_posix::Errno,
67591 >>(
67592 result,
67593 self.tx_id,
67594 0x7924c6eabde7819e,
67595 fidl::encoding::DynamicFlags::empty(),
67596 )
67597 }
67598}
67599
67600#[must_use = "FIDL methods require a response to be sent"]
67601#[derive(Debug)]
67602pub struct StreamSocketGetTcpCongestionResponder {
67603 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67604 tx_id: u32,
67605}
67606
67607impl std::ops::Drop for StreamSocketGetTcpCongestionResponder {
67611 fn drop(&mut self) {
67612 self.control_handle.shutdown();
67613 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67615 }
67616}
67617
67618impl fidl::endpoints::Responder for StreamSocketGetTcpCongestionResponder {
67619 type ControlHandle = StreamSocketControlHandle;
67620
67621 fn control_handle(&self) -> &StreamSocketControlHandle {
67622 &self.control_handle
67623 }
67624
67625 fn drop_without_shutdown(mut self) {
67626 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67628 std::mem::forget(self);
67630 }
67631}
67632
67633impl StreamSocketGetTcpCongestionResponder {
67634 pub fn send(
67638 self,
67639 mut result: Result<TcpCongestionControl, fidl_fuchsia_posix::Errno>,
67640 ) -> Result<(), fidl::Error> {
67641 let _result = self.send_raw(result);
67642 if _result.is_err() {
67643 self.control_handle.shutdown();
67644 }
67645 self.drop_without_shutdown();
67646 _result
67647 }
67648
67649 pub fn send_no_shutdown_on_err(
67651 self,
67652 mut result: Result<TcpCongestionControl, fidl_fuchsia_posix::Errno>,
67653 ) -> Result<(), fidl::Error> {
67654 let _result = self.send_raw(result);
67655 self.drop_without_shutdown();
67656 _result
67657 }
67658
67659 fn send_raw(
67660 &self,
67661 mut result: Result<TcpCongestionControl, fidl_fuchsia_posix::Errno>,
67662 ) -> Result<(), fidl::Error> {
67663 self.control_handle.inner.send::<fidl::encoding::ResultType<
67664 StreamSocketGetTcpCongestionResponse,
67665 fidl_fuchsia_posix::Errno,
67666 >>(
67667 result.map(|value| (value,)),
67668 self.tx_id,
67669 0x11e16397e1b72a47,
67670 fidl::encoding::DynamicFlags::empty(),
67671 )
67672 }
67673}
67674
67675#[must_use = "FIDL methods require a response to be sent"]
67676#[derive(Debug)]
67677pub struct StreamSocketSetTcpUserTimeoutResponder {
67678 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67679 tx_id: u32,
67680}
67681
67682impl std::ops::Drop for StreamSocketSetTcpUserTimeoutResponder {
67686 fn drop(&mut self) {
67687 self.control_handle.shutdown();
67688 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67690 }
67691}
67692
67693impl fidl::endpoints::Responder for StreamSocketSetTcpUserTimeoutResponder {
67694 type ControlHandle = StreamSocketControlHandle;
67695
67696 fn control_handle(&self) -> &StreamSocketControlHandle {
67697 &self.control_handle
67698 }
67699
67700 fn drop_without_shutdown(mut self) {
67701 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67703 std::mem::forget(self);
67705 }
67706}
67707
67708impl StreamSocketSetTcpUserTimeoutResponder {
67709 pub fn send(
67713 self,
67714 mut result: Result<(), fidl_fuchsia_posix::Errno>,
67715 ) -> Result<(), fidl::Error> {
67716 let _result = self.send_raw(result);
67717 if _result.is_err() {
67718 self.control_handle.shutdown();
67719 }
67720 self.drop_without_shutdown();
67721 _result
67722 }
67723
67724 pub fn send_no_shutdown_on_err(
67726 self,
67727 mut result: Result<(), fidl_fuchsia_posix::Errno>,
67728 ) -> Result<(), fidl::Error> {
67729 let _result = self.send_raw(result);
67730 self.drop_without_shutdown();
67731 _result
67732 }
67733
67734 fn send_raw(
67735 &self,
67736 mut result: Result<(), fidl_fuchsia_posix::Errno>,
67737 ) -> Result<(), fidl::Error> {
67738 self.control_handle.inner.send::<fidl::encoding::ResultType<
67739 fidl::encoding::EmptyStruct,
67740 fidl_fuchsia_posix::Errno,
67741 >>(
67742 result,
67743 self.tx_id,
67744 0x6b459e81c3741a60,
67745 fidl::encoding::DynamicFlags::empty(),
67746 )
67747 }
67748}
67749
67750#[must_use = "FIDL methods require a response to be sent"]
67751#[derive(Debug)]
67752pub struct StreamSocketGetTcpUserTimeoutResponder {
67753 control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67754 tx_id: u32,
67755}
67756
67757impl std::ops::Drop for StreamSocketGetTcpUserTimeoutResponder {
67761 fn drop(&mut self) {
67762 self.control_handle.shutdown();
67763 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67765 }
67766}
67767
67768impl fidl::endpoints::Responder for StreamSocketGetTcpUserTimeoutResponder {
67769 type ControlHandle = StreamSocketControlHandle;
67770
67771 fn control_handle(&self) -> &StreamSocketControlHandle {
67772 &self.control_handle
67773 }
67774
67775 fn drop_without_shutdown(mut self) {
67776 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67778 std::mem::forget(self);
67780 }
67781}
67782
67783impl StreamSocketGetTcpUserTimeoutResponder {
67784 pub fn send(
67788 self,
67789 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67790 ) -> Result<(), fidl::Error> {
67791 let _result = self.send_raw(result);
67792 if _result.is_err() {
67793 self.control_handle.shutdown();
67794 }
67795 self.drop_without_shutdown();
67796 _result
67797 }
67798
67799 pub fn send_no_shutdown_on_err(
67801 self,
67802 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67803 ) -> Result<(), fidl::Error> {
67804 let _result = self.send_raw(result);
67805 self.drop_without_shutdown();
67806 _result
67807 }
67808
67809 fn send_raw(
67810 &self,
67811 mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67812 ) -> Result<(), fidl::Error> {
67813 self.control_handle.inner.send::<fidl::encoding::ResultType<
67814 StreamSocketGetTcpUserTimeoutResponse,
67815 fidl_fuchsia_posix::Errno,
67816 >>(
67817 result.map(|value_millis| (value_millis,)),
67818 self.tx_id,
67819 0x24bbd5858ad8c380,
67820 fidl::encoding::DynamicFlags::empty(),
67821 )
67822 }
67823}
67824
67825#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
67826pub struct SynchronousDatagramSocketMarker;
67827
67828impl fidl::endpoints::ProtocolMarker for SynchronousDatagramSocketMarker {
67829 type Proxy = SynchronousDatagramSocketProxy;
67830 type RequestStream = SynchronousDatagramSocketRequestStream;
67831 #[cfg(target_os = "fuchsia")]
67832 type SynchronousProxy = SynchronousDatagramSocketSynchronousProxy;
67833
67834 const DEBUG_NAME: &'static str = "fuchsia.posix.socket.SynchronousDatagramSocket";
67835}
67836impl fidl::endpoints::DiscoverableProtocolMarker for SynchronousDatagramSocketMarker {}
67837pub type SynchronousDatagramSocketRecvMsgResult = Result<
67838 (Option<Box<fidl_fuchsia_net::SocketAddress>>, Vec<u8>, DatagramSocketRecvControlData, u32),
67839 fidl_fuchsia_posix::Errno,
67840>;
67841pub type SynchronousDatagramSocketSendMsgResult = Result<i64, fidl_fuchsia_posix::Errno>;
67842
67843pub trait SynchronousDatagramSocketProxyInterface: Send + Sync {
67844 fn r#clone(
67845 &self,
67846 request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
67847 ) -> Result<(), fidl::Error>;
67848 type CloseResponseFut: std::future::Future<
67849 Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
67850 > + Send;
67851 fn r#close(&self) -> Self::CloseResponseFut;
67852 type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
67853 fn r#query(&self) -> Self::QueryResponseFut;
67854 type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
67855 + Send;
67856 fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
67857 type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
67858 + Send;
67859 fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
67860 type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
67861 + Send;
67862 fn r#get_error(&self) -> Self::GetErrorResponseFut;
67863 type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
67864 + Send;
67865 fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
67866 type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
67867 + Send;
67868 fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
67869 type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
67870 + Send;
67871 fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
67872 type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
67873 + Send;
67874 fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
67875 type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
67876 + Send;
67877 fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
67878 type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
67879 + Send;
67880 fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
67881 type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
67882 + Send;
67883 fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
67884 type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
67885 + Send;
67886 fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
67887 type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
67888 + Send;
67889 fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
67890 type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
67891 + Send;
67892 fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
67893 type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
67894 + Send;
67895 fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
67896 type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
67897 + Send;
67898 fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
67899 type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
67900 + Send;
67901 fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
67902 type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
67903 + Send;
67904 fn r#get_linger(&self) -> Self::GetLingerResponseFut;
67905 type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
67906 + Send;
67907 fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
67908 type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
67909 + Send;
67910 fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
67911 type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
67912 + Send;
67913 fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
67914 type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
67915 + Send;
67916 fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
67917 type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
67918 + Send;
67919 fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
67920 type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
67921 + Send;
67922 fn r#set_bind_to_interface_index(&self, value: u64)
67923 -> Self::SetBindToInterfaceIndexResponseFut;
67924 type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
67925 + Send;
67926 fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
67927 type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
67928 + Send;
67929 fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
67930 type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
67931 + Send;
67932 fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
67933 type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
67934 + Send;
67935 fn r#set_mark(
67936 &self,
67937 domain: fidl_fuchsia_net::MarkDomain,
67938 mark: &OptionalUint32,
67939 ) -> Self::SetMarkResponseFut;
67940 type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
67941 + Send;
67942 fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
67943 type BindResponseFut: std::future::Future<Output = Result<BaseNetworkSocketBindResult, fidl::Error>>
67944 + Send;
67945 fn r#bind(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut;
67946 type ConnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketConnectResult, fidl::Error>>
67947 + Send;
67948 fn r#connect(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut;
67949 type DisconnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDisconnectResult, fidl::Error>>
67950 + Send;
67951 fn r#disconnect(&self) -> Self::DisconnectResponseFut;
67952 type GetSockNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetSockNameResult, fidl::Error>>
67953 + Send;
67954 fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
67955 type GetPeerNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetPeerNameResult, fidl::Error>>
67956 + Send;
67957 fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
67958 type ShutdownResponseFut: std::future::Future<Output = Result<BaseNetworkSocketShutdownResult, fidl::Error>>
67959 + Send;
67960 fn r#shutdown(&self, mode: ShutdownMode) -> Self::ShutdownResponseFut;
67961 type SetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>>
67962 + Send;
67963 fn r#set_ip_type_of_service(&self, value: u8) -> Self::SetIpTypeOfServiceResponseFut;
67964 type GetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>>
67965 + Send;
67966 fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut;
67967 type SetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTtlResult, fidl::Error>>
67968 + Send;
67969 fn r#set_ip_ttl(&self, value: &OptionalUint8) -> Self::SetIpTtlResponseFut;
67970 type GetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTtlResult, fidl::Error>>
67971 + Send;
67972 fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut;
67973 type SetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>>
67974 + Send;
67975 fn r#set_ip_packet_info(&self, value: bool) -> Self::SetIpPacketInfoResponseFut;
67976 type GetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>>
67977 + Send;
67978 fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut;
67979 type SetIpReceiveTypeOfServiceResponseFut: std::future::Future<
67980 Output = Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error>,
67981 > + Send;
67982 fn r#set_ip_receive_type_of_service(
67983 &self,
67984 value: bool,
67985 ) -> Self::SetIpReceiveTypeOfServiceResponseFut;
67986 type GetIpReceiveTypeOfServiceResponseFut: std::future::Future<
67987 Output = Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error>,
67988 > + Send;
67989 fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut;
67990 type SetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>>
67991 + Send;
67992 fn r#set_ip_receive_ttl(&self, value: bool) -> Self::SetIpReceiveTtlResponseFut;
67993 type GetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>>
67994 + Send;
67995 fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut;
67996 type SetIpMulticastInterfaceResponseFut: std::future::Future<
67997 Output = Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error>,
67998 > + Send;
67999 fn r#set_ip_multicast_interface(
68000 &self,
68001 iface: u64,
68002 address: &fidl_fuchsia_net::Ipv4Address,
68003 ) -> Self::SetIpMulticastInterfaceResponseFut;
68004 type GetIpMulticastInterfaceResponseFut: std::future::Future<
68005 Output = Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error>,
68006 > + Send;
68007 fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut;
68008 type SetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>>
68009 + Send;
68010 fn r#set_ip_multicast_ttl(&self, value: &OptionalUint8) -> Self::SetIpMulticastTtlResponseFut;
68011 type GetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>>
68012 + Send;
68013 fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut;
68014 type SetIpMulticastLoopbackResponseFut: std::future::Future<
68015 Output = Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error>,
68016 > + Send;
68017 fn r#set_ip_multicast_loopback(&self, value: bool) -> Self::SetIpMulticastLoopbackResponseFut;
68018 type GetIpMulticastLoopbackResponseFut: std::future::Future<
68019 Output = Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error>,
68020 > + Send;
68021 fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut;
68022 type AddIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error>>
68023 + Send;
68024 fn r#add_ip_membership(
68025 &self,
68026 membership: &IpMulticastMembership,
68027 ) -> Self::AddIpMembershipResponseFut;
68028 type DropIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error>>
68029 + Send;
68030 fn r#drop_ip_membership(
68031 &self,
68032 membership: &IpMulticastMembership,
68033 ) -> Self::DropIpMembershipResponseFut;
68034 type SetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error>>
68035 + Send;
68036 fn r#set_ip_transparent(&self, value: bool) -> Self::SetIpTransparentResponseFut;
68037 type GetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error>>
68038 + Send;
68039 fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut;
68040 type SetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
68041 Output = Result<
68042 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
68043 fidl::Error,
68044 >,
68045 > + Send;
68046 fn r#set_ip_receive_original_destination_address(
68047 &self,
68048 value: bool,
68049 ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut;
68050 type GetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
68051 Output = Result<
68052 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
68053 fidl::Error,
68054 >,
68055 > + Send;
68056 fn r#get_ip_receive_original_destination_address(
68057 &self,
68058 ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut;
68059 type AddIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>>
68060 + Send;
68061 fn r#add_ipv6_membership(
68062 &self,
68063 membership: &Ipv6MulticastMembership,
68064 ) -> Self::AddIpv6MembershipResponseFut;
68065 type DropIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>>
68066 + Send;
68067 fn r#drop_ipv6_membership(
68068 &self,
68069 membership: &Ipv6MulticastMembership,
68070 ) -> Self::DropIpv6MembershipResponseFut;
68071 type SetIpv6MulticastInterfaceResponseFut: std::future::Future<
68072 Output = Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error>,
68073 > + Send;
68074 fn r#set_ipv6_multicast_interface(
68075 &self,
68076 value: u64,
68077 ) -> Self::SetIpv6MulticastInterfaceResponseFut;
68078 type GetIpv6MulticastInterfaceResponseFut: std::future::Future<
68079 Output = Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error>,
68080 > + Send;
68081 fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut;
68082 type SetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>>
68083 + Send;
68084 fn r#set_ipv6_unicast_hops(&self, value: &OptionalUint8)
68085 -> Self::SetIpv6UnicastHopsResponseFut;
68086 type GetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>>
68087 + Send;
68088 fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut;
68089 type SetIpv6ReceiveHopLimitResponseFut: std::future::Future<
68090 Output = Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error>,
68091 > + Send;
68092 fn r#set_ipv6_receive_hop_limit(&self, value: bool) -> Self::SetIpv6ReceiveHopLimitResponseFut;
68093 type GetIpv6ReceiveHopLimitResponseFut: std::future::Future<
68094 Output = Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error>,
68095 > + Send;
68096 fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut;
68097 type SetIpv6MulticastHopsResponseFut: std::future::Future<
68098 Output = Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error>,
68099 > + Send;
68100 fn r#set_ipv6_multicast_hops(
68101 &self,
68102 value: &OptionalUint8,
68103 ) -> Self::SetIpv6MulticastHopsResponseFut;
68104 type GetIpv6MulticastHopsResponseFut: std::future::Future<
68105 Output = Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error>,
68106 > + Send;
68107 fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut;
68108 type SetIpv6MulticastLoopbackResponseFut: std::future::Future<
68109 Output = Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error>,
68110 > + Send;
68111 fn r#set_ipv6_multicast_loopback(
68112 &self,
68113 value: bool,
68114 ) -> Self::SetIpv6MulticastLoopbackResponseFut;
68115 type GetIpv6MulticastLoopbackResponseFut: std::future::Future<
68116 Output = Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error>,
68117 > + Send;
68118 fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut;
68119 type SetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error>>
68120 + Send;
68121 fn r#set_ipv6_only(&self, value: bool) -> Self::SetIpv6OnlyResponseFut;
68122 type GetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error>>
68123 + Send;
68124 fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut;
68125 type SetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
68126 Output = Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error>,
68127 > + Send;
68128 fn r#set_ipv6_receive_traffic_class(
68129 &self,
68130 value: bool,
68131 ) -> Self::SetIpv6ReceiveTrafficClassResponseFut;
68132 type GetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
68133 Output = Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error>,
68134 > + Send;
68135 fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut;
68136 type SetIpv6TrafficClassResponseFut: std::future::Future<
68137 Output = Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error>,
68138 > + Send;
68139 fn r#set_ipv6_traffic_class(
68140 &self,
68141 value: &OptionalUint8,
68142 ) -> Self::SetIpv6TrafficClassResponseFut;
68143 type GetIpv6TrafficClassResponseFut: std::future::Future<
68144 Output = Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error>,
68145 > + Send;
68146 fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut;
68147 type SetIpv6ReceivePacketInfoResponseFut: std::future::Future<
68148 Output = Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error>,
68149 > + Send;
68150 fn r#set_ipv6_receive_packet_info(
68151 &self,
68152 value: bool,
68153 ) -> Self::SetIpv6ReceivePacketInfoResponseFut;
68154 type GetIpv6ReceivePacketInfoResponseFut: std::future::Future<
68155 Output = Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error>,
68156 > + Send;
68157 fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut;
68158 type GetOriginalDestinationResponseFut: std::future::Future<
68159 Output = Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error>,
68160 > + Send;
68161 fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut;
68162 type GetInfoResponseFut: std::future::Future<Output = Result<BaseDatagramSocketGetInfoResult, fidl::Error>>
68163 + Send;
68164 fn r#get_info(&self) -> Self::GetInfoResponseFut;
68165 type DescribeResponseFut: std::future::Future<Output = Result<SynchronousDatagramSocketDescribeResponse, fidl::Error>>
68166 + Send;
68167 fn r#describe(&self) -> Self::DescribeResponseFut;
68168 type RecvMsgResponseFut: std::future::Future<Output = Result<SynchronousDatagramSocketRecvMsgResult, fidl::Error>>
68169 + Send;
68170 fn r#recv_msg(
68171 &self,
68172 want_addr: bool,
68173 data_len: u32,
68174 want_control: bool,
68175 flags: RecvMsgFlags,
68176 ) -> Self::RecvMsgResponseFut;
68177 type SendMsgResponseFut: std::future::Future<Output = Result<SynchronousDatagramSocketSendMsgResult, fidl::Error>>
68178 + Send;
68179 fn r#send_msg(
68180 &self,
68181 addr: Option<&fidl_fuchsia_net::SocketAddress>,
68182 data: &[u8],
68183 control: &DatagramSocketSendControlData,
68184 flags: SendMsgFlags,
68185 ) -> Self::SendMsgResponseFut;
68186}
68187#[derive(Debug)]
68188#[cfg(target_os = "fuchsia")]
68189pub struct SynchronousDatagramSocketSynchronousProxy {
68190 client: fidl::client::sync::Client,
68191}
68192
68193#[cfg(target_os = "fuchsia")]
68194impl fidl::endpoints::SynchronousProxy for SynchronousDatagramSocketSynchronousProxy {
68195 type Proxy = SynchronousDatagramSocketProxy;
68196 type Protocol = SynchronousDatagramSocketMarker;
68197
68198 fn from_channel(inner: fidl::Channel) -> Self {
68199 Self::new(inner)
68200 }
68201
68202 fn into_channel(self) -> fidl::Channel {
68203 self.client.into_channel()
68204 }
68205
68206 fn as_channel(&self) -> &fidl::Channel {
68207 self.client.as_channel()
68208 }
68209}
68210
68211#[cfg(target_os = "fuchsia")]
68212impl SynchronousDatagramSocketSynchronousProxy {
68213 pub fn new(channel: fidl::Channel) -> Self {
68214 let protocol_name =
68215 <SynchronousDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
68216 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
68217 }
68218
68219 pub fn into_channel(self) -> fidl::Channel {
68220 self.client.into_channel()
68221 }
68222
68223 pub fn wait_for_event(
68226 &self,
68227 deadline: zx::MonotonicInstant,
68228 ) -> Result<SynchronousDatagramSocketEvent, fidl::Error> {
68229 SynchronousDatagramSocketEvent::decode(self.client.wait_for_event(deadline)?)
68230 }
68231
68232 pub fn r#clone(
68233 &self,
68234 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
68235 ) -> Result<(), fidl::Error> {
68236 self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
68237 (request,),
68238 0x20d8a7aba2168a79,
68239 fidl::encoding::DynamicFlags::empty(),
68240 )
68241 }
68242
68243 pub fn r#close(
68254 &self,
68255 ___deadline: zx::MonotonicInstant,
68256 ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
68257 let _response = self.client.send_query::<
68258 fidl::encoding::EmptyPayload,
68259 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
68260 >(
68261 (),
68262 0x5ac5d459ad7f657e,
68263 fidl::encoding::DynamicFlags::empty(),
68264 ___deadline,
68265 )?;
68266 Ok(_response.map(|x| x))
68267 }
68268
68269 pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
68270 let _response = self.client.send_query::<
68271 fidl::encoding::EmptyPayload,
68272 fidl_fuchsia_unknown::QueryableQueryResponse,
68273 >(
68274 (),
68275 0x2658edee9decfc06,
68276 fidl::encoding::DynamicFlags::empty(),
68277 ___deadline,
68278 )?;
68279 Ok(_response.protocol)
68280 }
68281
68282 pub fn r#set_reuse_address(
68284 &self,
68285 mut value: bool,
68286 ___deadline: zx::MonotonicInstant,
68287 ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
68288 let _response =
68289 self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
68290 fidl::encoding::EmptyStruct,
68291 fidl_fuchsia_posix::Errno,
68292 >>(
68293 (value,),
68294 0x1fd74ee8b9a4a876,
68295 fidl::encoding::DynamicFlags::empty(),
68296 ___deadline,
68297 )?;
68298 Ok(_response.map(|x| x))
68299 }
68300
68301 pub fn r#get_reuse_address(
68303 &self,
68304 ___deadline: zx::MonotonicInstant,
68305 ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
68306 let _response = self
68307 .client
68308 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68309 BaseSocketGetReuseAddressResponse,
68310 fidl_fuchsia_posix::Errno,
68311 >>(
68312 (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
68313 )?;
68314 Ok(_response.map(|x| x.value))
68315 }
68316
68317 pub fn r#get_error(
68320 &self,
68321 ___deadline: zx::MonotonicInstant,
68322 ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
68323 let _response =
68324 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68325 fidl::encoding::EmptyStruct,
68326 fidl_fuchsia_posix::Errno,
68327 >>(
68328 (),
68329 0x5aad39b33e5f6ebb,
68330 fidl::encoding::DynamicFlags::empty(),
68331 ___deadline,
68332 )?;
68333 Ok(_response.map(|x| x))
68334 }
68335
68336 pub fn r#set_broadcast(
68338 &self,
68339 mut value: bool,
68340 ___deadline: zx::MonotonicInstant,
68341 ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
68342 let _response =
68343 self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
68344 fidl::encoding::EmptyStruct,
68345 fidl_fuchsia_posix::Errno,
68346 >>(
68347 (value,),
68348 0x6023e081ce3cd947,
68349 fidl::encoding::DynamicFlags::empty(),
68350 ___deadline,
68351 )?;
68352 Ok(_response.map(|x| x))
68353 }
68354
68355 pub fn r#get_broadcast(
68357 &self,
68358 ___deadline: zx::MonotonicInstant,
68359 ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
68360 let _response =
68361 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68362 BaseSocketGetBroadcastResponse,
68363 fidl_fuchsia_posix::Errno,
68364 >>(
68365 (),
68366 0x68796fc556f9780d,
68367 fidl::encoding::DynamicFlags::empty(),
68368 ___deadline,
68369 )?;
68370 Ok(_response.map(|x| x.value))
68371 }
68372
68373 pub fn r#set_send_buffer(
68375 &self,
68376 mut value_bytes: u64,
68377 ___deadline: zx::MonotonicInstant,
68378 ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
68379 let _response =
68380 self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
68381 fidl::encoding::EmptyStruct,
68382 fidl_fuchsia_posix::Errno,
68383 >>(
68384 (value_bytes,),
68385 0x756eac32d73a7a70,
68386 fidl::encoding::DynamicFlags::empty(),
68387 ___deadline,
68388 )?;
68389 Ok(_response.map(|x| x))
68390 }
68391
68392 pub fn r#get_send_buffer(
68394 &self,
68395 ___deadline: zx::MonotonicInstant,
68396 ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
68397 let _response = self
68398 .client
68399 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68400 BaseSocketGetSendBufferResponse,
68401 fidl_fuchsia_posix::Errno,
68402 >>(
68403 (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
68404 )?;
68405 Ok(_response.map(|x| x.value_bytes))
68406 }
68407
68408 pub fn r#set_receive_buffer(
68410 &self,
68411 mut value_bytes: u64,
68412 ___deadline: zx::MonotonicInstant,
68413 ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
68414 let _response =
68415 self.client
68416 .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
68417 fidl::encoding::EmptyStruct,
68418 fidl_fuchsia_posix::Errno,
68419 >>(
68420 (value_bytes,),
68421 0x6b0cf2f1919c7001,
68422 fidl::encoding::DynamicFlags::empty(),
68423 ___deadline,
68424 )?;
68425 Ok(_response.map(|x| x))
68426 }
68427
68428 pub fn r#get_receive_buffer(
68430 &self,
68431 ___deadline: zx::MonotonicInstant,
68432 ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
68433 let _response = self
68434 .client
68435 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68436 BaseSocketGetReceiveBufferResponse,
68437 fidl_fuchsia_posix::Errno,
68438 >>(
68439 (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
68440 )?;
68441 Ok(_response.map(|x| x.value_bytes))
68442 }
68443
68444 pub fn r#set_keep_alive(
68446 &self,
68447 mut value: bool,
68448 ___deadline: zx::MonotonicInstant,
68449 ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
68450 let _response =
68451 self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
68452 fidl::encoding::EmptyStruct,
68453 fidl_fuchsia_posix::Errno,
68454 >>(
68455 (value,),
68456 0x572df8f0b920d2c7,
68457 fidl::encoding::DynamicFlags::empty(),
68458 ___deadline,
68459 )?;
68460 Ok(_response.map(|x| x))
68461 }
68462
68463 pub fn r#get_keep_alive(
68465 &self,
68466 ___deadline: zx::MonotonicInstant,
68467 ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
68468 let _response =
68469 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68470 BaseSocketGetKeepAliveResponse,
68471 fidl_fuchsia_posix::Errno,
68472 >>(
68473 (),
68474 0x2dd29d3215f2c9d2,
68475 fidl::encoding::DynamicFlags::empty(),
68476 ___deadline,
68477 )?;
68478 Ok(_response.map(|x| x.value))
68479 }
68480
68481 pub fn r#set_out_of_band_inline(
68483 &self,
68484 mut value: bool,
68485 ___deadline: zx::MonotonicInstant,
68486 ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
68487 let _response =
68488 self.client
68489 .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
68490 fidl::encoding::EmptyStruct,
68491 fidl_fuchsia_posix::Errno,
68492 >>(
68493 (value,),
68494 0x3ecb49968bee439,
68495 fidl::encoding::DynamicFlags::empty(),
68496 ___deadline,
68497 )?;
68498 Ok(_response.map(|x| x))
68499 }
68500
68501 pub fn r#get_out_of_band_inline(
68503 &self,
68504 ___deadline: zx::MonotonicInstant,
68505 ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
68506 let _response = self
68507 .client
68508 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68509 BaseSocketGetOutOfBandInlineResponse,
68510 fidl_fuchsia_posix::Errno,
68511 >>(
68512 (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
68513 )?;
68514 Ok(_response.map(|x| x.value))
68515 }
68516
68517 pub fn r#set_no_check(
68519 &self,
68520 mut value: bool,
68521 ___deadline: zx::MonotonicInstant,
68522 ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
68523 let _response =
68524 self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
68525 fidl::encoding::EmptyStruct,
68526 fidl_fuchsia_posix::Errno,
68527 >>(
68528 (value,),
68529 0x6bbf00c53a4c78c2,
68530 fidl::encoding::DynamicFlags::empty(),
68531 ___deadline,
68532 )?;
68533 Ok(_response.map(|x| x))
68534 }
68535
68536 pub fn r#get_no_check(
68538 &self,
68539 ___deadline: zx::MonotonicInstant,
68540 ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
68541 let _response =
68542 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68543 BaseSocketGetNoCheckResponse,
68544 fidl_fuchsia_posix::Errno,
68545 >>(
68546 (),
68547 0x2cd4249286417694,
68548 fidl::encoding::DynamicFlags::empty(),
68549 ___deadline,
68550 )?;
68551 Ok(_response.map(|x| x.value))
68552 }
68553
68554 pub fn r#set_linger(
68556 &self,
68557 mut linger: bool,
68558 mut length_secs: u32,
68559 ___deadline: zx::MonotonicInstant,
68560 ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
68561 let _response =
68562 self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
68563 fidl::encoding::EmptyStruct,
68564 fidl_fuchsia_posix::Errno,
68565 >>(
68566 (linger, length_secs),
68567 0x45386351246e998e,
68568 fidl::encoding::DynamicFlags::empty(),
68569 ___deadline,
68570 )?;
68571 Ok(_response.map(|x| x))
68572 }
68573
68574 pub fn r#get_linger(
68576 &self,
68577 ___deadline: zx::MonotonicInstant,
68578 ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
68579 let _response =
68580 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68581 BaseSocketGetLingerResponse,
68582 fidl_fuchsia_posix::Errno,
68583 >>(
68584 (),
68585 0x48eb20fc5ccb0e45,
68586 fidl::encoding::DynamicFlags::empty(),
68587 ___deadline,
68588 )?;
68589 Ok(_response.map(|x| (x.linger, x.length_secs)))
68590 }
68591
68592 pub fn r#set_reuse_port(
68594 &self,
68595 mut value: bool,
68596 ___deadline: zx::MonotonicInstant,
68597 ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
68598 let _response =
68599 self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
68600 fidl::encoding::EmptyStruct,
68601 fidl_fuchsia_posix::Errno,
68602 >>(
68603 (value,),
68604 0x24dd3e5cb36d9ccb,
68605 fidl::encoding::DynamicFlags::empty(),
68606 ___deadline,
68607 )?;
68608 Ok(_response.map(|x| x))
68609 }
68610
68611 pub fn r#get_reuse_port(
68613 &self,
68614 ___deadline: zx::MonotonicInstant,
68615 ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
68616 let _response =
68617 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68618 BaseSocketGetReusePortResponse,
68619 fidl_fuchsia_posix::Errno,
68620 >>(
68621 (),
68622 0x7a112c1ab54ff828,
68623 fidl::encoding::DynamicFlags::empty(),
68624 ___deadline,
68625 )?;
68626 Ok(_response.map(|x| x.value))
68627 }
68628
68629 pub fn r#get_accept_conn(
68631 &self,
68632 ___deadline: zx::MonotonicInstant,
68633 ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
68634 let _response = self
68635 .client
68636 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68637 BaseSocketGetAcceptConnResponse,
68638 fidl_fuchsia_posix::Errno,
68639 >>(
68640 (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
68641 )?;
68642 Ok(_response.map(|x| x.value))
68643 }
68644
68645 pub fn r#set_bind_to_device(
68647 &self,
68648 mut value: &str,
68649 ___deadline: zx::MonotonicInstant,
68650 ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
68651 let _response =
68652 self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
68653 fidl::encoding::EmptyStruct,
68654 fidl_fuchsia_posix::Errno,
68655 >>(
68656 (value,),
68657 0x2118b483f28aafc4,
68658 fidl::encoding::DynamicFlags::empty(),
68659 ___deadline,
68660 )?;
68661 Ok(_response.map(|x| x))
68662 }
68663
68664 pub fn r#get_bind_to_device(
68666 &self,
68667 ___deadline: zx::MonotonicInstant,
68668 ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
68669 let _response = self
68670 .client
68671 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68672 BaseSocketGetBindToDeviceResponse,
68673 fidl_fuchsia_posix::Errno,
68674 >>(
68675 (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
68676 )?;
68677 Ok(_response.map(|x| x.value))
68678 }
68679
68680 pub fn r#set_bind_to_interface_index(
68683 &self,
68684 mut value: u64,
68685 ___deadline: zx::MonotonicInstant,
68686 ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
68687 let _response =
68688 self.client
68689 .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
68690 fidl::encoding::EmptyStruct,
68691 fidl_fuchsia_posix::Errno,
68692 >>(
68693 (value,),
68694 0x6e387a0def00821,
68695 fidl::encoding::DynamicFlags::empty(),
68696 ___deadline,
68697 )?;
68698 Ok(_response.map(|x| x))
68699 }
68700
68701 pub fn r#get_bind_to_interface_index(
68703 &self,
68704 ___deadline: zx::MonotonicInstant,
68705 ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
68706 let _response = self
68707 .client
68708 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68709 BaseSocketGetBindToInterfaceIndexResponse,
68710 fidl_fuchsia_posix::Errno,
68711 >>(
68712 (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
68713 )?;
68714 Ok(_response.map(|x| x.value))
68715 }
68716
68717 pub fn r#set_timestamp(
68719 &self,
68720 mut value: TimestampOption,
68721 ___deadline: zx::MonotonicInstant,
68722 ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
68723 let _response =
68724 self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
68725 fidl::encoding::EmptyStruct,
68726 fidl_fuchsia_posix::Errno,
68727 >>(
68728 (value,),
68729 0x285d6516c263d839,
68730 fidl::encoding::DynamicFlags::empty(),
68731 ___deadline,
68732 )?;
68733 Ok(_response.map(|x| x))
68734 }
68735
68736 pub fn r#get_timestamp(
68738 &self,
68739 ___deadline: zx::MonotonicInstant,
68740 ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
68741 let _response =
68742 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68743 BaseSocketGetTimestampResponse,
68744 fidl_fuchsia_posix::Errno,
68745 >>(
68746 (),
68747 0x49f2fffbbcc2bd27,
68748 fidl::encoding::DynamicFlags::empty(),
68749 ___deadline,
68750 )?;
68751 Ok(_response.map(|x| x.value))
68752 }
68753
68754 pub fn r#set_mark(
68758 &self,
68759 mut domain: fidl_fuchsia_net::MarkDomain,
68760 mut mark: &OptionalUint32,
68761 ___deadline: zx::MonotonicInstant,
68762 ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
68763 let _response =
68764 self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
68765 fidl::encoding::EmptyStruct,
68766 fidl_fuchsia_posix::Errno,
68767 >>(
68768 (domain, mark),
68769 0x6ead6de09f653236,
68770 fidl::encoding::DynamicFlags::empty(),
68771 ___deadline,
68772 )?;
68773 Ok(_response.map(|x| x))
68774 }
68775
68776 pub fn r#get_mark(
68780 &self,
68781 mut domain: fidl_fuchsia_net::MarkDomain,
68782 ___deadline: zx::MonotonicInstant,
68783 ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
68784 let _response =
68785 self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
68786 BaseSocketGetMarkResponse,
68787 fidl_fuchsia_posix::Errno,
68788 >>(
68789 (domain,),
68790 0x57a2752c61d93d47,
68791 fidl::encoding::DynamicFlags::empty(),
68792 ___deadline,
68793 )?;
68794 Ok(_response.map(|x| x.mark))
68795 }
68796
68797 pub fn r#bind(
68799 &self,
68800 mut addr: &fidl_fuchsia_net::SocketAddress,
68801 ___deadline: zx::MonotonicInstant,
68802 ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
68803 let _response =
68804 self.client.send_query::<BaseNetworkSocketBindRequest, fidl::encoding::ResultType<
68805 fidl::encoding::EmptyStruct,
68806 fidl_fuchsia_posix::Errno,
68807 >>(
68808 (addr,),
68809 0x4bc6400ae92125d,
68810 fidl::encoding::DynamicFlags::empty(),
68811 ___deadline,
68812 )?;
68813 Ok(_response.map(|x| x))
68814 }
68815
68816 pub fn r#connect(
68818 &self,
68819 mut addr: &fidl_fuchsia_net::SocketAddress,
68820 ___deadline: zx::MonotonicInstant,
68821 ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
68822 let _response =
68823 self.client.send_query::<BaseNetworkSocketConnectRequest, fidl::encoding::ResultType<
68824 fidl::encoding::EmptyStruct,
68825 fidl_fuchsia_posix::Errno,
68826 >>(
68827 (addr,),
68828 0x5f05f19bfdd38871,
68829 fidl::encoding::DynamicFlags::empty(),
68830 ___deadline,
68831 )?;
68832 Ok(_response.map(|x| x))
68833 }
68834
68835 pub fn r#disconnect(
68837 &self,
68838 ___deadline: zx::MonotonicInstant,
68839 ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
68840 let _response =
68841 self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68842 fidl::encoding::EmptyStruct,
68843 fidl_fuchsia_posix::Errno,
68844 >>(
68845 (),
68846 0x74e63b91f7b29b2,
68847 fidl::encoding::DynamicFlags::empty(),
68848 ___deadline,
68849 )?;
68850 Ok(_response.map(|x| x))
68851 }
68852
68853 pub fn r#get_sock_name(
68855 &self,
68856 ___deadline: zx::MonotonicInstant,
68857 ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
68858 let _response = self
68859 .client
68860 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68861 BaseNetworkSocketGetSockNameResponse,
68862 fidl_fuchsia_posix::Errno,
68863 >>(
68864 (), 0x475f23f84a1a4f85, fidl::encoding::DynamicFlags::empty(), ___deadline
68865 )?;
68866 Ok(_response.map(|x| x.addr))
68867 }
68868
68869 pub fn r#get_peer_name(
68871 &self,
68872 ___deadline: zx::MonotonicInstant,
68873 ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
68874 let _response = self
68875 .client
68876 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68877 BaseNetworkSocketGetPeerNameResponse,
68878 fidl_fuchsia_posix::Errno,
68879 >>(
68880 (), 0x1ffecf4bd5b6432e, fidl::encoding::DynamicFlags::empty(), ___deadline
68881 )?;
68882 Ok(_response.map(|x| x.addr))
68883 }
68884
68885 pub fn r#shutdown(
68887 &self,
68888 mut mode: ShutdownMode,
68889 ___deadline: zx::MonotonicInstant,
68890 ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
68891 let _response =
68892 self.client.send_query::<BaseNetworkSocketShutdownRequest, fidl::encoding::ResultType<
68893 fidl::encoding::EmptyStruct,
68894 fidl_fuchsia_posix::Errno,
68895 >>(
68896 (mode,),
68897 0x247f38b6db68c336,
68898 fidl::encoding::DynamicFlags::empty(),
68899 ___deadline,
68900 )?;
68901 Ok(_response.map(|x| x))
68902 }
68903
68904 pub fn r#set_ip_type_of_service(
68906 &self,
68907 mut value: u8,
68908 ___deadline: zx::MonotonicInstant,
68909 ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
68910 let _response = self.client.send_query::<
68911 BaseNetworkSocketSetIpTypeOfServiceRequest,
68912 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
68913 >(
68914 (value,),
68915 0x995c600475b6d46,
68916 fidl::encoding::DynamicFlags::empty(),
68917 ___deadline,
68918 )?;
68919 Ok(_response.map(|x| x))
68920 }
68921
68922 pub fn r#get_ip_type_of_service(
68924 &self,
68925 ___deadline: zx::MonotonicInstant,
68926 ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
68927 let _response = self
68928 .client
68929 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68930 BaseNetworkSocketGetIpTypeOfServiceResponse,
68931 fidl_fuchsia_posix::Errno,
68932 >>(
68933 (), 0x3814a04259f75fcb, fidl::encoding::DynamicFlags::empty(), ___deadline
68934 )?;
68935 Ok(_response.map(|x| x.value))
68936 }
68937
68938 pub fn r#set_ip_ttl(
68940 &self,
68941 mut value: &OptionalUint8,
68942 ___deadline: zx::MonotonicInstant,
68943 ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
68944 let _response =
68945 self.client.send_query::<BaseNetworkSocketSetIpTtlRequest, fidl::encoding::ResultType<
68946 fidl::encoding::EmptyStruct,
68947 fidl_fuchsia_posix::Errno,
68948 >>(
68949 (value,),
68950 0x29e2424b433ae1ef,
68951 fidl::encoding::DynamicFlags::empty(),
68952 ___deadline,
68953 )?;
68954 Ok(_response.map(|x| x))
68955 }
68956
68957 pub fn r#get_ip_ttl(
68959 &self,
68960 ___deadline: zx::MonotonicInstant,
68961 ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
68962 let _response = self
68963 .client
68964 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68965 BaseNetworkSocketGetIpTtlResponse,
68966 fidl_fuchsia_posix::Errno,
68967 >>(
68968 (), 0x47e47fa1f24da471, fidl::encoding::DynamicFlags::empty(), ___deadline
68969 )?;
68970 Ok(_response.map(|x| x.value))
68971 }
68972
68973 pub fn r#set_ip_packet_info(
68975 &self,
68976 mut value: bool,
68977 ___deadline: zx::MonotonicInstant,
68978 ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
68979 let _response =
68980 self.client
68981 .send_query::<BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::ResultType<
68982 fidl::encoding::EmptyStruct,
68983 fidl_fuchsia_posix::Errno,
68984 >>(
68985 (value,),
68986 0x392d16bee20c0e16,
68987 fidl::encoding::DynamicFlags::empty(),
68988 ___deadline,
68989 )?;
68990 Ok(_response.map(|x| x))
68991 }
68992
68993 pub fn r#get_ip_packet_info(
68995 &self,
68996 ___deadline: zx::MonotonicInstant,
68997 ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
68998 let _response = self
68999 .client
69000 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69001 BaseNetworkSocketGetIpPacketInfoResponse,
69002 fidl_fuchsia_posix::Errno,
69003 >>(
69004 (), 0x54b505f242280740, fidl::encoding::DynamicFlags::empty(), ___deadline
69005 )?;
69006 Ok(_response.map(|x| x.value))
69007 }
69008
69009 pub fn r#set_ip_receive_type_of_service(
69011 &self,
69012 mut value: bool,
69013 ___deadline: zx::MonotonicInstant,
69014 ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
69015 let _response = self.client.send_query::<
69016 BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
69017 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69018 >(
69019 (value,),
69020 0x6c4f6714995f84ef,
69021 fidl::encoding::DynamicFlags::empty(),
69022 ___deadline,
69023 )?;
69024 Ok(_response.map(|x| x))
69025 }
69026
69027 pub fn r#get_ip_receive_type_of_service(
69029 &self,
69030 ___deadline: zx::MonotonicInstant,
69031 ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
69032 let _response = self
69033 .client
69034 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69035 BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
69036 fidl_fuchsia_posix::Errno,
69037 >>(
69038 (), 0x4158ba7dc2795960, fidl::encoding::DynamicFlags::empty(), ___deadline
69039 )?;
69040 Ok(_response.map(|x| x.value))
69041 }
69042
69043 pub fn r#set_ip_receive_ttl(
69045 &self,
69046 mut value: bool,
69047 ___deadline: zx::MonotonicInstant,
69048 ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
69049 let _response =
69050 self.client
69051 .send_query::<BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::ResultType<
69052 fidl::encoding::EmptyStruct,
69053 fidl_fuchsia_posix::Errno,
69054 >>(
69055 (value,),
69056 0x46f15be0ce0ab82b,
69057 fidl::encoding::DynamicFlags::empty(),
69058 ___deadline,
69059 )?;
69060 Ok(_response.map(|x| x))
69061 }
69062
69063 pub fn r#get_ip_receive_ttl(
69065 &self,
69066 ___deadline: zx::MonotonicInstant,
69067 ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
69068 let _response = self
69069 .client
69070 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69071 BaseNetworkSocketGetIpReceiveTtlResponse,
69072 fidl_fuchsia_posix::Errno,
69073 >>(
69074 (), 0x678ddd5a5dfa2eb5, fidl::encoding::DynamicFlags::empty(), ___deadline
69075 )?;
69076 Ok(_response.map(|x| x.value))
69077 }
69078
69079 pub fn r#set_ip_multicast_interface(
69081 &self,
69082 mut iface: u64,
69083 mut address: &fidl_fuchsia_net::Ipv4Address,
69084 ___deadline: zx::MonotonicInstant,
69085 ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
69086 let _response = self.client.send_query::<
69087 BaseNetworkSocketSetIpMulticastInterfaceRequest,
69088 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69089 >(
69090 (iface, address,),
69091 0x752fbfa9b12befe,
69092 fidl::encoding::DynamicFlags::empty(),
69093 ___deadline,
69094 )?;
69095 Ok(_response.map(|x| x))
69096 }
69097
69098 pub fn r#get_ip_multicast_interface(
69100 &self,
69101 ___deadline: zx::MonotonicInstant,
69102 ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
69103 let _response = self
69104 .client
69105 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69106 BaseNetworkSocketGetIpMulticastInterfaceResponse,
69107 fidl_fuchsia_posix::Errno,
69108 >>(
69109 (), 0x320bd14c4df046c4, fidl::encoding::DynamicFlags::empty(), ___deadline
69110 )?;
69111 Ok(_response.map(|x| x.value))
69112 }
69113
69114 pub fn r#set_ip_multicast_ttl(
69116 &self,
69117 mut value: &OptionalUint8,
69118 ___deadline: zx::MonotonicInstant,
69119 ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
69120 let _response =
69121 self.client
69122 .send_query::<BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::ResultType<
69123 fidl::encoding::EmptyStruct,
69124 fidl_fuchsia_posix::Errno,
69125 >>(
69126 (value,),
69127 0x63134d53772916a1,
69128 fidl::encoding::DynamicFlags::empty(),
69129 ___deadline,
69130 )?;
69131 Ok(_response.map(|x| x))
69132 }
69133
69134 pub fn r#get_ip_multicast_ttl(
69136 &self,
69137 ___deadline: zx::MonotonicInstant,
69138 ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
69139 let _response = self
69140 .client
69141 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69142 BaseNetworkSocketGetIpMulticastTtlResponse,
69143 fidl_fuchsia_posix::Errno,
69144 >>(
69145 (), 0x4665cd378f39e1a, fidl::encoding::DynamicFlags::empty(), ___deadline
69146 )?;
69147 Ok(_response.map(|x| x.value))
69148 }
69149
69150 pub fn r#set_ip_multicast_loopback(
69152 &self,
69153 mut value: bool,
69154 ___deadline: zx::MonotonicInstant,
69155 ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
69156 let _response = self.client.send_query::<
69157 BaseNetworkSocketSetIpMulticastLoopbackRequest,
69158 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69159 >(
69160 (value,),
69161 0x20c55c11f00943ea,
69162 fidl::encoding::DynamicFlags::empty(),
69163 ___deadline,
69164 )?;
69165 Ok(_response.map(|x| x))
69166 }
69167
69168 pub fn r#get_ip_multicast_loopback(
69170 &self,
69171 ___deadline: zx::MonotonicInstant,
69172 ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
69173 let _response = self
69174 .client
69175 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69176 BaseNetworkSocketGetIpMulticastLoopbackResponse,
69177 fidl_fuchsia_posix::Errno,
69178 >>(
69179 (), 0x3b6b26ff558298f2, fidl::encoding::DynamicFlags::empty(), ___deadline
69180 )?;
69181 Ok(_response.map(|x| x.value))
69182 }
69183
69184 pub fn r#add_ip_membership(
69186 &self,
69187 mut membership: &IpMulticastMembership,
69188 ___deadline: zx::MonotonicInstant,
69189 ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
69190 let _response =
69191 self.client
69192 .send_query::<BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::ResultType<
69193 fidl::encoding::EmptyStruct,
69194 fidl_fuchsia_posix::Errno,
69195 >>(
69196 (membership,),
69197 0x76bc7df115a3b4d0,
69198 fidl::encoding::DynamicFlags::empty(),
69199 ___deadline,
69200 )?;
69201 Ok(_response.map(|x| x))
69202 }
69203
69204 pub fn r#drop_ip_membership(
69206 &self,
69207 mut membership: &IpMulticastMembership,
69208 ___deadline: zx::MonotonicInstant,
69209 ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
69210 let _response =
69211 self.client
69212 .send_query::<BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::ResultType<
69213 fidl::encoding::EmptyStruct,
69214 fidl_fuchsia_posix::Errno,
69215 >>(
69216 (membership,),
69217 0x2888f3099188d03,
69218 fidl::encoding::DynamicFlags::empty(),
69219 ___deadline,
69220 )?;
69221 Ok(_response.map(|x| x))
69222 }
69223
69224 pub fn r#set_ip_transparent(
69226 &self,
69227 mut value: bool,
69228 ___deadline: zx::MonotonicInstant,
69229 ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
69230 let _response =
69231 self.client
69232 .send_query::<BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::ResultType<
69233 fidl::encoding::EmptyStruct,
69234 fidl_fuchsia_posix::Errno,
69235 >>(
69236 (value,),
69237 0x1ae532b0c066e3a0,
69238 fidl::encoding::DynamicFlags::empty(),
69239 ___deadline,
69240 )?;
69241 Ok(_response.map(|x| x))
69242 }
69243
69244 pub fn r#get_ip_transparent(
69246 &self,
69247 ___deadline: zx::MonotonicInstant,
69248 ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
69249 let _response = self
69250 .client
69251 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69252 BaseNetworkSocketGetIpTransparentResponse,
69253 fidl_fuchsia_posix::Errno,
69254 >>(
69255 (), 0x51d43695962ebfb5, fidl::encoding::DynamicFlags::empty(), ___deadline
69256 )?;
69257 Ok(_response.map(|x| x.value))
69258 }
69259
69260 pub fn r#set_ip_receive_original_destination_address(
69262 &self,
69263 mut value: bool,
69264 ___deadline: zx::MonotonicInstant,
69265 ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
69266 let _response = self.client.send_query::<
69267 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
69268 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69269 >(
69270 (value,),
69271 0x4722b4ce52f7840,
69272 fidl::encoding::DynamicFlags::empty(),
69273 ___deadline,
69274 )?;
69275 Ok(_response.map(|x| x))
69276 }
69277
69278 pub fn r#get_ip_receive_original_destination_address(
69280 &self,
69281 ___deadline: zx::MonotonicInstant,
69282 ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
69283 let _response = self
69284 .client
69285 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69286 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
69287 fidl_fuchsia_posix::Errno,
69288 >>(
69289 (), 0x2a0e7dc5d6bfdfe9, fidl::encoding::DynamicFlags::empty(), ___deadline
69290 )?;
69291 Ok(_response.map(|x| x.value))
69292 }
69293
69294 pub fn r#add_ipv6_membership(
69296 &self,
69297 mut membership: &Ipv6MulticastMembership,
69298 ___deadline: zx::MonotonicInstant,
69299 ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
69300 let _response =
69301 self.client
69302 .send_query::<BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::ResultType<
69303 fidl::encoding::EmptyStruct,
69304 fidl_fuchsia_posix::Errno,
69305 >>(
69306 (membership,),
69307 0x7c94727acb4ea4b3,
69308 fidl::encoding::DynamicFlags::empty(),
69309 ___deadline,
69310 )?;
69311 Ok(_response.map(|x| x))
69312 }
69313
69314 pub fn r#drop_ipv6_membership(
69316 &self,
69317 mut membership: &Ipv6MulticastMembership,
69318 ___deadline: zx::MonotonicInstant,
69319 ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
69320 let _response = self.client.send_query::<
69321 BaseNetworkSocketDropIpv6MembershipRequest,
69322 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69323 >(
69324 (membership,),
69325 0x42104c70ccaba304,
69326 fidl::encoding::DynamicFlags::empty(),
69327 ___deadline,
69328 )?;
69329 Ok(_response.map(|x| x))
69330 }
69331
69332 pub fn r#set_ipv6_multicast_interface(
69334 &self,
69335 mut value: u64,
69336 ___deadline: zx::MonotonicInstant,
69337 ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
69338 let _response = self.client.send_query::<
69339 BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
69340 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69341 >(
69342 (value,),
69343 0x135f76db3774ab3b,
69344 fidl::encoding::DynamicFlags::empty(),
69345 ___deadline,
69346 )?;
69347 Ok(_response.map(|x| x))
69348 }
69349
69350 pub fn r#get_ipv6_multicast_interface(
69352 &self,
69353 ___deadline: zx::MonotonicInstant,
69354 ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
69355 let _response = self
69356 .client
69357 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69358 BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
69359 fidl_fuchsia_posix::Errno,
69360 >>(
69361 (), 0x1f26fcdd348f1882, fidl::encoding::DynamicFlags::empty(), ___deadline
69362 )?;
69363 Ok(_response.map(|x| x.value))
69364 }
69365
69366 pub fn r#set_ipv6_unicast_hops(
69368 &self,
69369 mut value: &OptionalUint8,
69370 ___deadline: zx::MonotonicInstant,
69371 ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
69372 let _response = self.client.send_query::<
69373 BaseNetworkSocketSetIpv6UnicastHopsRequest,
69374 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69375 >(
69376 (value,),
69377 0x157d51e98f462859,
69378 fidl::encoding::DynamicFlags::empty(),
69379 ___deadline,
69380 )?;
69381 Ok(_response.map(|x| x))
69382 }
69383
69384 pub fn r#get_ipv6_unicast_hops(
69386 &self,
69387 ___deadline: zx::MonotonicInstant,
69388 ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
69389 let _response = self
69390 .client
69391 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69392 BaseNetworkSocketGetIpv6UnicastHopsResponse,
69393 fidl_fuchsia_posix::Errno,
69394 >>(
69395 (), 0x21f4641cad8bd8d2, fidl::encoding::DynamicFlags::empty(), ___deadline
69396 )?;
69397 Ok(_response.map(|x| x.value))
69398 }
69399
69400 pub fn r#set_ipv6_receive_hop_limit(
69402 &self,
69403 mut value: bool,
69404 ___deadline: zx::MonotonicInstant,
69405 ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
69406 let _response = self.client.send_query::<
69407 BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
69408 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69409 >(
69410 (value,),
69411 0x5c24808ed2e84a1e,
69412 fidl::encoding::DynamicFlags::empty(),
69413 ___deadline,
69414 )?;
69415 Ok(_response.map(|x| x))
69416 }
69417
69418 pub fn r#get_ipv6_receive_hop_limit(
69420 &self,
69421 ___deadline: zx::MonotonicInstant,
69422 ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
69423 let _response = self
69424 .client
69425 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69426 BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
69427 fidl_fuchsia_posix::Errno,
69428 >>(
69429 (), 0x341e06689885b4c0, fidl::encoding::DynamicFlags::empty(), ___deadline
69430 )?;
69431 Ok(_response.map(|x| x.value))
69432 }
69433
69434 pub fn r#set_ipv6_multicast_hops(
69436 &self,
69437 mut value: &OptionalUint8,
69438 ___deadline: zx::MonotonicInstant,
69439 ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
69440 let _response = self.client.send_query::<
69441 BaseNetworkSocketSetIpv6MulticastHopsRequest,
69442 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69443 >(
69444 (value,),
69445 0x25b9cd4d181f82c1,
69446 fidl::encoding::DynamicFlags::empty(),
69447 ___deadline,
69448 )?;
69449 Ok(_response.map(|x| x))
69450 }
69451
69452 pub fn r#get_ipv6_multicast_hops(
69454 &self,
69455 ___deadline: zx::MonotonicInstant,
69456 ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
69457 let _response = self
69458 .client
69459 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69460 BaseNetworkSocketGetIpv6MulticastHopsResponse,
69461 fidl_fuchsia_posix::Errno,
69462 >>(
69463 (), 0x52916948a365012a, fidl::encoding::DynamicFlags::empty(), ___deadline
69464 )?;
69465 Ok(_response.map(|x| x.value))
69466 }
69467
69468 pub fn r#set_ipv6_multicast_loopback(
69470 &self,
69471 mut value: bool,
69472 ___deadline: zx::MonotonicInstant,
69473 ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
69474 let _response = self.client.send_query::<
69475 BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
69476 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69477 >(
69478 (value,),
69479 0x55701c409ff41b40,
69480 fidl::encoding::DynamicFlags::empty(),
69481 ___deadline,
69482 )?;
69483 Ok(_response.map(|x| x))
69484 }
69485
69486 pub fn r#get_ipv6_multicast_loopback(
69488 &self,
69489 ___deadline: zx::MonotonicInstant,
69490 ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
69491 let _response = self
69492 .client
69493 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69494 BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
69495 fidl_fuchsia_posix::Errno,
69496 >>(
69497 (), 0x4415b701fde319c3, fidl::encoding::DynamicFlags::empty(), ___deadline
69498 )?;
69499 Ok(_response.map(|x| x.value))
69500 }
69501
69502 pub fn r#set_ipv6_only(
69504 &self,
69505 mut value: bool,
69506 ___deadline: zx::MonotonicInstant,
69507 ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
69508 let _response =
69509 self.client
69510 .send_query::<BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::ResultType<
69511 fidl::encoding::EmptyStruct,
69512 fidl_fuchsia_posix::Errno,
69513 >>(
69514 (value,),
69515 0x4873f1364758cbba,
69516 fidl::encoding::DynamicFlags::empty(),
69517 ___deadline,
69518 )?;
69519 Ok(_response.map(|x| x))
69520 }
69521
69522 pub fn r#get_ipv6_only(
69524 &self,
69525 ___deadline: zx::MonotonicInstant,
69526 ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
69527 let _response = self
69528 .client
69529 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69530 BaseNetworkSocketGetIpv6OnlyResponse,
69531 fidl_fuchsia_posix::Errno,
69532 >>(
69533 (), 0x4aa3340a1a26b89c, fidl::encoding::DynamicFlags::empty(), ___deadline
69534 )?;
69535 Ok(_response.map(|x| x.value))
69536 }
69537
69538 pub fn r#set_ipv6_receive_traffic_class(
69540 &self,
69541 mut value: bool,
69542 ___deadline: zx::MonotonicInstant,
69543 ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
69544 let _response = self.client.send_query::<
69545 BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
69546 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69547 >(
69548 (value,),
69549 0x58f07c8788d099a0,
69550 fidl::encoding::DynamicFlags::empty(),
69551 ___deadline,
69552 )?;
69553 Ok(_response.map(|x| x))
69554 }
69555
69556 pub fn r#get_ipv6_receive_traffic_class(
69558 &self,
69559 ___deadline: zx::MonotonicInstant,
69560 ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
69561 let _response = self
69562 .client
69563 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69564 BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
69565 fidl_fuchsia_posix::Errno,
69566 >>(
69567 (), 0x2e334df1da553ffa, fidl::encoding::DynamicFlags::empty(), ___deadline
69568 )?;
69569 Ok(_response.map(|x| x.value))
69570 }
69571
69572 pub fn r#set_ipv6_traffic_class(
69574 &self,
69575 mut value: &OptionalUint8,
69576 ___deadline: zx::MonotonicInstant,
69577 ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
69578 let _response = self.client.send_query::<
69579 BaseNetworkSocketSetIpv6TrafficClassRequest,
69580 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69581 >(
69582 (value,),
69583 0x6af077800c5a0b4f,
69584 fidl::encoding::DynamicFlags::empty(),
69585 ___deadline,
69586 )?;
69587 Ok(_response.map(|x| x))
69588 }
69589
69590 pub fn r#get_ipv6_traffic_class(
69592 &self,
69593 ___deadline: zx::MonotonicInstant,
69594 ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
69595 let _response = self
69596 .client
69597 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69598 BaseNetworkSocketGetIpv6TrafficClassResponse,
69599 fidl_fuchsia_posix::Errno,
69600 >>(
69601 (), 0x6baf6eed8fc2f04, fidl::encoding::DynamicFlags::empty(), ___deadline
69602 )?;
69603 Ok(_response.map(|x| x.value))
69604 }
69605
69606 pub fn r#set_ipv6_receive_packet_info(
69608 &self,
69609 mut value: bool,
69610 ___deadline: zx::MonotonicInstant,
69611 ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
69612 let _response = self.client.send_query::<
69613 BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
69614 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69615 >(
69616 (value,),
69617 0x19259775b1a92768,
69618 fidl::encoding::DynamicFlags::empty(),
69619 ___deadline,
69620 )?;
69621 Ok(_response.map(|x| x))
69622 }
69623
69624 pub fn r#get_ipv6_receive_packet_info(
69626 &self,
69627 ___deadline: zx::MonotonicInstant,
69628 ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
69629 let _response = self
69630 .client
69631 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69632 BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
69633 fidl_fuchsia_posix::Errno,
69634 >>(
69635 (), 0x7acd4a2775baec75, fidl::encoding::DynamicFlags::empty(), ___deadline
69636 )?;
69637 Ok(_response.map(|x| x.value))
69638 }
69639
69640 pub fn r#get_original_destination(
69642 &self,
69643 ___deadline: zx::MonotonicInstant,
69644 ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
69645 let _response = self
69646 .client
69647 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69648 BaseNetworkSocketGetOriginalDestinationResponse,
69649 fidl_fuchsia_posix::Errno,
69650 >>(
69651 (), 0x38bf28f0dafdbac0, fidl::encoding::DynamicFlags::empty(), ___deadline
69652 )?;
69653 Ok(_response.map(|x| x.value))
69654 }
69655
69656 pub fn r#get_info(
69661 &self,
69662 ___deadline: zx::MonotonicInstant,
69663 ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
69664 let _response = self
69665 .client
69666 .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69667 BaseDatagramSocketGetInfoResponse,
69668 fidl_fuchsia_posix::Errno,
69669 >>(
69670 (), 0x48aa0a1f6a32d2ed, fidl::encoding::DynamicFlags::empty(), ___deadline
69671 )?;
69672 Ok(_response.map(|x| (x.domain, x.proto)))
69673 }
69674
69675 pub fn r#describe(
69676 &self,
69677 ___deadline: zx::MonotonicInstant,
69678 ) -> Result<SynchronousDatagramSocketDescribeResponse, fidl::Error> {
69679 let _response = self
69680 .client
69681 .send_query::<fidl::encoding::EmptyPayload, SynchronousDatagramSocketDescribeResponse>(
69682 (),
69683 0x585f20b73631070d,
69684 fidl::encoding::DynamicFlags::empty(),
69685 ___deadline,
69686 )?;
69687 Ok(_response)
69688 }
69689
69690 pub fn r#recv_msg(
69705 &self,
69706 mut want_addr: bool,
69707 mut data_len: u32,
69708 mut want_control: bool,
69709 mut flags: RecvMsgFlags,
69710 ___deadline: zx::MonotonicInstant,
69711 ) -> Result<SynchronousDatagramSocketRecvMsgResult, fidl::Error> {
69712 let _response = self
69713 .client
69714 .send_query::<SynchronousDatagramSocketRecvMsgRequest, fidl::encoding::ResultType<
69715 SynchronousDatagramSocketRecvMsgResponse,
69716 fidl_fuchsia_posix::Errno,
69717 >>(
69718 (want_addr, data_len, want_control, flags),
69719 0x28e494e48fb5dbf3,
69720 fidl::encoding::DynamicFlags::empty(),
69721 ___deadline,
69722 )?;
69723 Ok(_response.map(|x| (x.addr, x.data, x.control, x.truncated)))
69724 }
69725
69726 pub fn r#send_msg(
69735 &self,
69736 mut addr: Option<&fidl_fuchsia_net::SocketAddress>,
69737 mut data: &[u8],
69738 mut control: &DatagramSocketSendControlData,
69739 mut flags: SendMsgFlags,
69740 ___deadline: zx::MonotonicInstant,
69741 ) -> Result<SynchronousDatagramSocketSendMsgResult, fidl::Error> {
69742 let _response = self
69743 .client
69744 .send_query::<SynchronousDatagramSocketSendMsgRequest, fidl::encoding::ResultType<
69745 SynchronousDatagramSocketSendMsgResponse,
69746 fidl_fuchsia_posix::Errno,
69747 >>(
69748 (addr, data, control, flags),
69749 0x12dc2fceab6cefaa,
69750 fidl::encoding::DynamicFlags::empty(),
69751 ___deadline,
69752 )?;
69753 Ok(_response.map(|x| x.len))
69754 }
69755}
69756
69757#[cfg(target_os = "fuchsia")]
69758impl From<SynchronousDatagramSocketSynchronousProxy> for zx::Handle {
69759 fn from(value: SynchronousDatagramSocketSynchronousProxy) -> Self {
69760 value.into_channel().into()
69761 }
69762}
69763
69764#[cfg(target_os = "fuchsia")]
69765impl From<fidl::Channel> for SynchronousDatagramSocketSynchronousProxy {
69766 fn from(value: fidl::Channel) -> Self {
69767 Self::new(value)
69768 }
69769}
69770
69771#[derive(Debug, Clone)]
69772pub struct SynchronousDatagramSocketProxy {
69773 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
69774}
69775
69776impl fidl::endpoints::Proxy for SynchronousDatagramSocketProxy {
69777 type Protocol = SynchronousDatagramSocketMarker;
69778
69779 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
69780 Self::new(inner)
69781 }
69782
69783 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
69784 self.client.into_channel().map_err(|client| Self { client })
69785 }
69786
69787 fn as_channel(&self) -> &::fidl::AsyncChannel {
69788 self.client.as_channel()
69789 }
69790}
69791
69792impl SynchronousDatagramSocketProxy {
69793 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
69795 let protocol_name =
69796 <SynchronousDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
69797 Self { client: fidl::client::Client::new(channel, protocol_name) }
69798 }
69799
69800 pub fn take_event_stream(&self) -> SynchronousDatagramSocketEventStream {
69806 SynchronousDatagramSocketEventStream { event_receiver: self.client.take_event_receiver() }
69807 }
69808
69809 pub fn r#clone(
69810 &self,
69811 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
69812 ) -> Result<(), fidl::Error> {
69813 SynchronousDatagramSocketProxyInterface::r#clone(self, request)
69814 }
69815
69816 pub fn r#close(
69827 &self,
69828 ) -> fidl::client::QueryResponseFut<
69829 fidl_fuchsia_unknown::CloseableCloseResult,
69830 fidl::encoding::DefaultFuchsiaResourceDialect,
69831 > {
69832 SynchronousDatagramSocketProxyInterface::r#close(self)
69833 }
69834
69835 pub fn r#query(
69836 &self,
69837 ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
69838 {
69839 SynchronousDatagramSocketProxyInterface::r#query(self)
69840 }
69841
69842 pub fn r#set_reuse_address(
69844 &self,
69845 mut value: bool,
69846 ) -> fidl::client::QueryResponseFut<
69847 BaseSocketSetReuseAddressResult,
69848 fidl::encoding::DefaultFuchsiaResourceDialect,
69849 > {
69850 SynchronousDatagramSocketProxyInterface::r#set_reuse_address(self, value)
69851 }
69852
69853 pub fn r#get_reuse_address(
69855 &self,
69856 ) -> fidl::client::QueryResponseFut<
69857 BaseSocketGetReuseAddressResult,
69858 fidl::encoding::DefaultFuchsiaResourceDialect,
69859 > {
69860 SynchronousDatagramSocketProxyInterface::r#get_reuse_address(self)
69861 }
69862
69863 pub fn r#get_error(
69866 &self,
69867 ) -> fidl::client::QueryResponseFut<
69868 BaseSocketGetErrorResult,
69869 fidl::encoding::DefaultFuchsiaResourceDialect,
69870 > {
69871 SynchronousDatagramSocketProxyInterface::r#get_error(self)
69872 }
69873
69874 pub fn r#set_broadcast(
69876 &self,
69877 mut value: bool,
69878 ) -> fidl::client::QueryResponseFut<
69879 BaseSocketSetBroadcastResult,
69880 fidl::encoding::DefaultFuchsiaResourceDialect,
69881 > {
69882 SynchronousDatagramSocketProxyInterface::r#set_broadcast(self, value)
69883 }
69884
69885 pub fn r#get_broadcast(
69887 &self,
69888 ) -> fidl::client::QueryResponseFut<
69889 BaseSocketGetBroadcastResult,
69890 fidl::encoding::DefaultFuchsiaResourceDialect,
69891 > {
69892 SynchronousDatagramSocketProxyInterface::r#get_broadcast(self)
69893 }
69894
69895 pub fn r#set_send_buffer(
69897 &self,
69898 mut value_bytes: u64,
69899 ) -> fidl::client::QueryResponseFut<
69900 BaseSocketSetSendBufferResult,
69901 fidl::encoding::DefaultFuchsiaResourceDialect,
69902 > {
69903 SynchronousDatagramSocketProxyInterface::r#set_send_buffer(self, value_bytes)
69904 }
69905
69906 pub fn r#get_send_buffer(
69908 &self,
69909 ) -> fidl::client::QueryResponseFut<
69910 BaseSocketGetSendBufferResult,
69911 fidl::encoding::DefaultFuchsiaResourceDialect,
69912 > {
69913 SynchronousDatagramSocketProxyInterface::r#get_send_buffer(self)
69914 }
69915
69916 pub fn r#set_receive_buffer(
69918 &self,
69919 mut value_bytes: u64,
69920 ) -> fidl::client::QueryResponseFut<
69921 BaseSocketSetReceiveBufferResult,
69922 fidl::encoding::DefaultFuchsiaResourceDialect,
69923 > {
69924 SynchronousDatagramSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
69925 }
69926
69927 pub fn r#get_receive_buffer(
69929 &self,
69930 ) -> fidl::client::QueryResponseFut<
69931 BaseSocketGetReceiveBufferResult,
69932 fidl::encoding::DefaultFuchsiaResourceDialect,
69933 > {
69934 SynchronousDatagramSocketProxyInterface::r#get_receive_buffer(self)
69935 }
69936
69937 pub fn r#set_keep_alive(
69939 &self,
69940 mut value: bool,
69941 ) -> fidl::client::QueryResponseFut<
69942 BaseSocketSetKeepAliveResult,
69943 fidl::encoding::DefaultFuchsiaResourceDialect,
69944 > {
69945 SynchronousDatagramSocketProxyInterface::r#set_keep_alive(self, value)
69946 }
69947
69948 pub fn r#get_keep_alive(
69950 &self,
69951 ) -> fidl::client::QueryResponseFut<
69952 BaseSocketGetKeepAliveResult,
69953 fidl::encoding::DefaultFuchsiaResourceDialect,
69954 > {
69955 SynchronousDatagramSocketProxyInterface::r#get_keep_alive(self)
69956 }
69957
69958 pub fn r#set_out_of_band_inline(
69960 &self,
69961 mut value: bool,
69962 ) -> fidl::client::QueryResponseFut<
69963 BaseSocketSetOutOfBandInlineResult,
69964 fidl::encoding::DefaultFuchsiaResourceDialect,
69965 > {
69966 SynchronousDatagramSocketProxyInterface::r#set_out_of_band_inline(self, value)
69967 }
69968
69969 pub fn r#get_out_of_band_inline(
69971 &self,
69972 ) -> fidl::client::QueryResponseFut<
69973 BaseSocketGetOutOfBandInlineResult,
69974 fidl::encoding::DefaultFuchsiaResourceDialect,
69975 > {
69976 SynchronousDatagramSocketProxyInterface::r#get_out_of_band_inline(self)
69977 }
69978
69979 pub fn r#set_no_check(
69981 &self,
69982 mut value: bool,
69983 ) -> fidl::client::QueryResponseFut<
69984 BaseSocketSetNoCheckResult,
69985 fidl::encoding::DefaultFuchsiaResourceDialect,
69986 > {
69987 SynchronousDatagramSocketProxyInterface::r#set_no_check(self, value)
69988 }
69989
69990 pub fn r#get_no_check(
69992 &self,
69993 ) -> fidl::client::QueryResponseFut<
69994 BaseSocketGetNoCheckResult,
69995 fidl::encoding::DefaultFuchsiaResourceDialect,
69996 > {
69997 SynchronousDatagramSocketProxyInterface::r#get_no_check(self)
69998 }
69999
70000 pub fn r#set_linger(
70002 &self,
70003 mut linger: bool,
70004 mut length_secs: u32,
70005 ) -> fidl::client::QueryResponseFut<
70006 BaseSocketSetLingerResult,
70007 fidl::encoding::DefaultFuchsiaResourceDialect,
70008 > {
70009 SynchronousDatagramSocketProxyInterface::r#set_linger(self, linger, length_secs)
70010 }
70011
70012 pub fn r#get_linger(
70014 &self,
70015 ) -> fidl::client::QueryResponseFut<
70016 BaseSocketGetLingerResult,
70017 fidl::encoding::DefaultFuchsiaResourceDialect,
70018 > {
70019 SynchronousDatagramSocketProxyInterface::r#get_linger(self)
70020 }
70021
70022 pub fn r#set_reuse_port(
70024 &self,
70025 mut value: bool,
70026 ) -> fidl::client::QueryResponseFut<
70027 BaseSocketSetReusePortResult,
70028 fidl::encoding::DefaultFuchsiaResourceDialect,
70029 > {
70030 SynchronousDatagramSocketProxyInterface::r#set_reuse_port(self, value)
70031 }
70032
70033 pub fn r#get_reuse_port(
70035 &self,
70036 ) -> fidl::client::QueryResponseFut<
70037 BaseSocketGetReusePortResult,
70038 fidl::encoding::DefaultFuchsiaResourceDialect,
70039 > {
70040 SynchronousDatagramSocketProxyInterface::r#get_reuse_port(self)
70041 }
70042
70043 pub fn r#get_accept_conn(
70045 &self,
70046 ) -> fidl::client::QueryResponseFut<
70047 BaseSocketGetAcceptConnResult,
70048 fidl::encoding::DefaultFuchsiaResourceDialect,
70049 > {
70050 SynchronousDatagramSocketProxyInterface::r#get_accept_conn(self)
70051 }
70052
70053 pub fn r#set_bind_to_device(
70055 &self,
70056 mut value: &str,
70057 ) -> fidl::client::QueryResponseFut<
70058 BaseSocketSetBindToDeviceResult,
70059 fidl::encoding::DefaultFuchsiaResourceDialect,
70060 > {
70061 SynchronousDatagramSocketProxyInterface::r#set_bind_to_device(self, value)
70062 }
70063
70064 pub fn r#get_bind_to_device(
70066 &self,
70067 ) -> fidl::client::QueryResponseFut<
70068 BaseSocketGetBindToDeviceResult,
70069 fidl::encoding::DefaultFuchsiaResourceDialect,
70070 > {
70071 SynchronousDatagramSocketProxyInterface::r#get_bind_to_device(self)
70072 }
70073
70074 pub fn r#set_bind_to_interface_index(
70077 &self,
70078 mut value: u64,
70079 ) -> fidl::client::QueryResponseFut<
70080 BaseSocketSetBindToInterfaceIndexResult,
70081 fidl::encoding::DefaultFuchsiaResourceDialect,
70082 > {
70083 SynchronousDatagramSocketProxyInterface::r#set_bind_to_interface_index(self, value)
70084 }
70085
70086 pub fn r#get_bind_to_interface_index(
70088 &self,
70089 ) -> fidl::client::QueryResponseFut<
70090 BaseSocketGetBindToInterfaceIndexResult,
70091 fidl::encoding::DefaultFuchsiaResourceDialect,
70092 > {
70093 SynchronousDatagramSocketProxyInterface::r#get_bind_to_interface_index(self)
70094 }
70095
70096 pub fn r#set_timestamp(
70098 &self,
70099 mut value: TimestampOption,
70100 ) -> fidl::client::QueryResponseFut<
70101 BaseSocketSetTimestampResult,
70102 fidl::encoding::DefaultFuchsiaResourceDialect,
70103 > {
70104 SynchronousDatagramSocketProxyInterface::r#set_timestamp(self, value)
70105 }
70106
70107 pub fn r#get_timestamp(
70109 &self,
70110 ) -> fidl::client::QueryResponseFut<
70111 BaseSocketGetTimestampResult,
70112 fidl::encoding::DefaultFuchsiaResourceDialect,
70113 > {
70114 SynchronousDatagramSocketProxyInterface::r#get_timestamp(self)
70115 }
70116
70117 pub fn r#set_mark(
70121 &self,
70122 mut domain: fidl_fuchsia_net::MarkDomain,
70123 mut mark: &OptionalUint32,
70124 ) -> fidl::client::QueryResponseFut<
70125 BaseSocketSetMarkResult,
70126 fidl::encoding::DefaultFuchsiaResourceDialect,
70127 > {
70128 SynchronousDatagramSocketProxyInterface::r#set_mark(self, domain, mark)
70129 }
70130
70131 pub fn r#get_mark(
70135 &self,
70136 mut domain: fidl_fuchsia_net::MarkDomain,
70137 ) -> fidl::client::QueryResponseFut<
70138 BaseSocketGetMarkResult,
70139 fidl::encoding::DefaultFuchsiaResourceDialect,
70140 > {
70141 SynchronousDatagramSocketProxyInterface::r#get_mark(self, domain)
70142 }
70143
70144 pub fn r#bind(
70146 &self,
70147 mut addr: &fidl_fuchsia_net::SocketAddress,
70148 ) -> fidl::client::QueryResponseFut<
70149 BaseNetworkSocketBindResult,
70150 fidl::encoding::DefaultFuchsiaResourceDialect,
70151 > {
70152 SynchronousDatagramSocketProxyInterface::r#bind(self, addr)
70153 }
70154
70155 pub fn r#connect(
70157 &self,
70158 mut addr: &fidl_fuchsia_net::SocketAddress,
70159 ) -> fidl::client::QueryResponseFut<
70160 BaseNetworkSocketConnectResult,
70161 fidl::encoding::DefaultFuchsiaResourceDialect,
70162 > {
70163 SynchronousDatagramSocketProxyInterface::r#connect(self, addr)
70164 }
70165
70166 pub fn r#disconnect(
70168 &self,
70169 ) -> fidl::client::QueryResponseFut<
70170 BaseNetworkSocketDisconnectResult,
70171 fidl::encoding::DefaultFuchsiaResourceDialect,
70172 > {
70173 SynchronousDatagramSocketProxyInterface::r#disconnect(self)
70174 }
70175
70176 pub fn r#get_sock_name(
70178 &self,
70179 ) -> fidl::client::QueryResponseFut<
70180 BaseNetworkSocketGetSockNameResult,
70181 fidl::encoding::DefaultFuchsiaResourceDialect,
70182 > {
70183 SynchronousDatagramSocketProxyInterface::r#get_sock_name(self)
70184 }
70185
70186 pub fn r#get_peer_name(
70188 &self,
70189 ) -> fidl::client::QueryResponseFut<
70190 BaseNetworkSocketGetPeerNameResult,
70191 fidl::encoding::DefaultFuchsiaResourceDialect,
70192 > {
70193 SynchronousDatagramSocketProxyInterface::r#get_peer_name(self)
70194 }
70195
70196 pub fn r#shutdown(
70198 &self,
70199 mut mode: ShutdownMode,
70200 ) -> fidl::client::QueryResponseFut<
70201 BaseNetworkSocketShutdownResult,
70202 fidl::encoding::DefaultFuchsiaResourceDialect,
70203 > {
70204 SynchronousDatagramSocketProxyInterface::r#shutdown(self, mode)
70205 }
70206
70207 pub fn r#set_ip_type_of_service(
70209 &self,
70210 mut value: u8,
70211 ) -> fidl::client::QueryResponseFut<
70212 BaseNetworkSocketSetIpTypeOfServiceResult,
70213 fidl::encoding::DefaultFuchsiaResourceDialect,
70214 > {
70215 SynchronousDatagramSocketProxyInterface::r#set_ip_type_of_service(self, value)
70216 }
70217
70218 pub fn r#get_ip_type_of_service(
70220 &self,
70221 ) -> fidl::client::QueryResponseFut<
70222 BaseNetworkSocketGetIpTypeOfServiceResult,
70223 fidl::encoding::DefaultFuchsiaResourceDialect,
70224 > {
70225 SynchronousDatagramSocketProxyInterface::r#get_ip_type_of_service(self)
70226 }
70227
70228 pub fn r#set_ip_ttl(
70230 &self,
70231 mut value: &OptionalUint8,
70232 ) -> fidl::client::QueryResponseFut<
70233 BaseNetworkSocketSetIpTtlResult,
70234 fidl::encoding::DefaultFuchsiaResourceDialect,
70235 > {
70236 SynchronousDatagramSocketProxyInterface::r#set_ip_ttl(self, value)
70237 }
70238
70239 pub fn r#get_ip_ttl(
70241 &self,
70242 ) -> fidl::client::QueryResponseFut<
70243 BaseNetworkSocketGetIpTtlResult,
70244 fidl::encoding::DefaultFuchsiaResourceDialect,
70245 > {
70246 SynchronousDatagramSocketProxyInterface::r#get_ip_ttl(self)
70247 }
70248
70249 pub fn r#set_ip_packet_info(
70251 &self,
70252 mut value: bool,
70253 ) -> fidl::client::QueryResponseFut<
70254 BaseNetworkSocketSetIpPacketInfoResult,
70255 fidl::encoding::DefaultFuchsiaResourceDialect,
70256 > {
70257 SynchronousDatagramSocketProxyInterface::r#set_ip_packet_info(self, value)
70258 }
70259
70260 pub fn r#get_ip_packet_info(
70262 &self,
70263 ) -> fidl::client::QueryResponseFut<
70264 BaseNetworkSocketGetIpPacketInfoResult,
70265 fidl::encoding::DefaultFuchsiaResourceDialect,
70266 > {
70267 SynchronousDatagramSocketProxyInterface::r#get_ip_packet_info(self)
70268 }
70269
70270 pub fn r#set_ip_receive_type_of_service(
70272 &self,
70273 mut value: bool,
70274 ) -> fidl::client::QueryResponseFut<
70275 BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
70276 fidl::encoding::DefaultFuchsiaResourceDialect,
70277 > {
70278 SynchronousDatagramSocketProxyInterface::r#set_ip_receive_type_of_service(self, value)
70279 }
70280
70281 pub fn r#get_ip_receive_type_of_service(
70283 &self,
70284 ) -> fidl::client::QueryResponseFut<
70285 BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
70286 fidl::encoding::DefaultFuchsiaResourceDialect,
70287 > {
70288 SynchronousDatagramSocketProxyInterface::r#get_ip_receive_type_of_service(self)
70289 }
70290
70291 pub fn r#set_ip_receive_ttl(
70293 &self,
70294 mut value: bool,
70295 ) -> fidl::client::QueryResponseFut<
70296 BaseNetworkSocketSetIpReceiveTtlResult,
70297 fidl::encoding::DefaultFuchsiaResourceDialect,
70298 > {
70299 SynchronousDatagramSocketProxyInterface::r#set_ip_receive_ttl(self, value)
70300 }
70301
70302 pub fn r#get_ip_receive_ttl(
70304 &self,
70305 ) -> fidl::client::QueryResponseFut<
70306 BaseNetworkSocketGetIpReceiveTtlResult,
70307 fidl::encoding::DefaultFuchsiaResourceDialect,
70308 > {
70309 SynchronousDatagramSocketProxyInterface::r#get_ip_receive_ttl(self)
70310 }
70311
70312 pub fn r#set_ip_multicast_interface(
70314 &self,
70315 mut iface: u64,
70316 mut address: &fidl_fuchsia_net::Ipv4Address,
70317 ) -> fidl::client::QueryResponseFut<
70318 BaseNetworkSocketSetIpMulticastInterfaceResult,
70319 fidl::encoding::DefaultFuchsiaResourceDialect,
70320 > {
70321 SynchronousDatagramSocketProxyInterface::r#set_ip_multicast_interface(self, iface, address)
70322 }
70323
70324 pub fn r#get_ip_multicast_interface(
70326 &self,
70327 ) -> fidl::client::QueryResponseFut<
70328 BaseNetworkSocketGetIpMulticastInterfaceResult,
70329 fidl::encoding::DefaultFuchsiaResourceDialect,
70330 > {
70331 SynchronousDatagramSocketProxyInterface::r#get_ip_multicast_interface(self)
70332 }
70333
70334 pub fn r#set_ip_multicast_ttl(
70336 &self,
70337 mut value: &OptionalUint8,
70338 ) -> fidl::client::QueryResponseFut<
70339 BaseNetworkSocketSetIpMulticastTtlResult,
70340 fidl::encoding::DefaultFuchsiaResourceDialect,
70341 > {
70342 SynchronousDatagramSocketProxyInterface::r#set_ip_multicast_ttl(self, value)
70343 }
70344
70345 pub fn r#get_ip_multicast_ttl(
70347 &self,
70348 ) -> fidl::client::QueryResponseFut<
70349 BaseNetworkSocketGetIpMulticastTtlResult,
70350 fidl::encoding::DefaultFuchsiaResourceDialect,
70351 > {
70352 SynchronousDatagramSocketProxyInterface::r#get_ip_multicast_ttl(self)
70353 }
70354
70355 pub fn r#set_ip_multicast_loopback(
70357 &self,
70358 mut value: bool,
70359 ) -> fidl::client::QueryResponseFut<
70360 BaseNetworkSocketSetIpMulticastLoopbackResult,
70361 fidl::encoding::DefaultFuchsiaResourceDialect,
70362 > {
70363 SynchronousDatagramSocketProxyInterface::r#set_ip_multicast_loopback(self, value)
70364 }
70365
70366 pub fn r#get_ip_multicast_loopback(
70368 &self,
70369 ) -> fidl::client::QueryResponseFut<
70370 BaseNetworkSocketGetIpMulticastLoopbackResult,
70371 fidl::encoding::DefaultFuchsiaResourceDialect,
70372 > {
70373 SynchronousDatagramSocketProxyInterface::r#get_ip_multicast_loopback(self)
70374 }
70375
70376 pub fn r#add_ip_membership(
70378 &self,
70379 mut membership: &IpMulticastMembership,
70380 ) -> fidl::client::QueryResponseFut<
70381 BaseNetworkSocketAddIpMembershipResult,
70382 fidl::encoding::DefaultFuchsiaResourceDialect,
70383 > {
70384 SynchronousDatagramSocketProxyInterface::r#add_ip_membership(self, membership)
70385 }
70386
70387 pub fn r#drop_ip_membership(
70389 &self,
70390 mut membership: &IpMulticastMembership,
70391 ) -> fidl::client::QueryResponseFut<
70392 BaseNetworkSocketDropIpMembershipResult,
70393 fidl::encoding::DefaultFuchsiaResourceDialect,
70394 > {
70395 SynchronousDatagramSocketProxyInterface::r#drop_ip_membership(self, membership)
70396 }
70397
70398 pub fn r#set_ip_transparent(
70400 &self,
70401 mut value: bool,
70402 ) -> fidl::client::QueryResponseFut<
70403 BaseNetworkSocketSetIpTransparentResult,
70404 fidl::encoding::DefaultFuchsiaResourceDialect,
70405 > {
70406 SynchronousDatagramSocketProxyInterface::r#set_ip_transparent(self, value)
70407 }
70408
70409 pub fn r#get_ip_transparent(
70411 &self,
70412 ) -> fidl::client::QueryResponseFut<
70413 BaseNetworkSocketGetIpTransparentResult,
70414 fidl::encoding::DefaultFuchsiaResourceDialect,
70415 > {
70416 SynchronousDatagramSocketProxyInterface::r#get_ip_transparent(self)
70417 }
70418
70419 pub fn r#set_ip_receive_original_destination_address(
70421 &self,
70422 mut value: bool,
70423 ) -> fidl::client::QueryResponseFut<
70424 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
70425 fidl::encoding::DefaultFuchsiaResourceDialect,
70426 > {
70427 SynchronousDatagramSocketProxyInterface::r#set_ip_receive_original_destination_address(
70428 self, value,
70429 )
70430 }
70431
70432 pub fn r#get_ip_receive_original_destination_address(
70434 &self,
70435 ) -> fidl::client::QueryResponseFut<
70436 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
70437 fidl::encoding::DefaultFuchsiaResourceDialect,
70438 > {
70439 SynchronousDatagramSocketProxyInterface::r#get_ip_receive_original_destination_address(self)
70440 }
70441
70442 pub fn r#add_ipv6_membership(
70444 &self,
70445 mut membership: &Ipv6MulticastMembership,
70446 ) -> fidl::client::QueryResponseFut<
70447 BaseNetworkSocketAddIpv6MembershipResult,
70448 fidl::encoding::DefaultFuchsiaResourceDialect,
70449 > {
70450 SynchronousDatagramSocketProxyInterface::r#add_ipv6_membership(self, membership)
70451 }
70452
70453 pub fn r#drop_ipv6_membership(
70455 &self,
70456 mut membership: &Ipv6MulticastMembership,
70457 ) -> fidl::client::QueryResponseFut<
70458 BaseNetworkSocketDropIpv6MembershipResult,
70459 fidl::encoding::DefaultFuchsiaResourceDialect,
70460 > {
70461 SynchronousDatagramSocketProxyInterface::r#drop_ipv6_membership(self, membership)
70462 }
70463
70464 pub fn r#set_ipv6_multicast_interface(
70466 &self,
70467 mut value: u64,
70468 ) -> fidl::client::QueryResponseFut<
70469 BaseNetworkSocketSetIpv6MulticastInterfaceResult,
70470 fidl::encoding::DefaultFuchsiaResourceDialect,
70471 > {
70472 SynchronousDatagramSocketProxyInterface::r#set_ipv6_multicast_interface(self, value)
70473 }
70474
70475 pub fn r#get_ipv6_multicast_interface(
70477 &self,
70478 ) -> fidl::client::QueryResponseFut<
70479 BaseNetworkSocketGetIpv6MulticastInterfaceResult,
70480 fidl::encoding::DefaultFuchsiaResourceDialect,
70481 > {
70482 SynchronousDatagramSocketProxyInterface::r#get_ipv6_multicast_interface(self)
70483 }
70484
70485 pub fn r#set_ipv6_unicast_hops(
70487 &self,
70488 mut value: &OptionalUint8,
70489 ) -> fidl::client::QueryResponseFut<
70490 BaseNetworkSocketSetIpv6UnicastHopsResult,
70491 fidl::encoding::DefaultFuchsiaResourceDialect,
70492 > {
70493 SynchronousDatagramSocketProxyInterface::r#set_ipv6_unicast_hops(self, value)
70494 }
70495
70496 pub fn r#get_ipv6_unicast_hops(
70498 &self,
70499 ) -> fidl::client::QueryResponseFut<
70500 BaseNetworkSocketGetIpv6UnicastHopsResult,
70501 fidl::encoding::DefaultFuchsiaResourceDialect,
70502 > {
70503 SynchronousDatagramSocketProxyInterface::r#get_ipv6_unicast_hops(self)
70504 }
70505
70506 pub fn r#set_ipv6_receive_hop_limit(
70508 &self,
70509 mut value: bool,
70510 ) -> fidl::client::QueryResponseFut<
70511 BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
70512 fidl::encoding::DefaultFuchsiaResourceDialect,
70513 > {
70514 SynchronousDatagramSocketProxyInterface::r#set_ipv6_receive_hop_limit(self, value)
70515 }
70516
70517 pub fn r#get_ipv6_receive_hop_limit(
70519 &self,
70520 ) -> fidl::client::QueryResponseFut<
70521 BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
70522 fidl::encoding::DefaultFuchsiaResourceDialect,
70523 > {
70524 SynchronousDatagramSocketProxyInterface::r#get_ipv6_receive_hop_limit(self)
70525 }
70526
70527 pub fn r#set_ipv6_multicast_hops(
70529 &self,
70530 mut value: &OptionalUint8,
70531 ) -> fidl::client::QueryResponseFut<
70532 BaseNetworkSocketSetIpv6MulticastHopsResult,
70533 fidl::encoding::DefaultFuchsiaResourceDialect,
70534 > {
70535 SynchronousDatagramSocketProxyInterface::r#set_ipv6_multicast_hops(self, value)
70536 }
70537
70538 pub fn r#get_ipv6_multicast_hops(
70540 &self,
70541 ) -> fidl::client::QueryResponseFut<
70542 BaseNetworkSocketGetIpv6MulticastHopsResult,
70543 fidl::encoding::DefaultFuchsiaResourceDialect,
70544 > {
70545 SynchronousDatagramSocketProxyInterface::r#get_ipv6_multicast_hops(self)
70546 }
70547
70548 pub fn r#set_ipv6_multicast_loopback(
70550 &self,
70551 mut value: bool,
70552 ) -> fidl::client::QueryResponseFut<
70553 BaseNetworkSocketSetIpv6MulticastLoopbackResult,
70554 fidl::encoding::DefaultFuchsiaResourceDialect,
70555 > {
70556 SynchronousDatagramSocketProxyInterface::r#set_ipv6_multicast_loopback(self, value)
70557 }
70558
70559 pub fn r#get_ipv6_multicast_loopback(
70561 &self,
70562 ) -> fidl::client::QueryResponseFut<
70563 BaseNetworkSocketGetIpv6MulticastLoopbackResult,
70564 fidl::encoding::DefaultFuchsiaResourceDialect,
70565 > {
70566 SynchronousDatagramSocketProxyInterface::r#get_ipv6_multicast_loopback(self)
70567 }
70568
70569 pub fn r#set_ipv6_only(
70571 &self,
70572 mut value: bool,
70573 ) -> fidl::client::QueryResponseFut<
70574 BaseNetworkSocketSetIpv6OnlyResult,
70575 fidl::encoding::DefaultFuchsiaResourceDialect,
70576 > {
70577 SynchronousDatagramSocketProxyInterface::r#set_ipv6_only(self, value)
70578 }
70579
70580 pub fn r#get_ipv6_only(
70582 &self,
70583 ) -> fidl::client::QueryResponseFut<
70584 BaseNetworkSocketGetIpv6OnlyResult,
70585 fidl::encoding::DefaultFuchsiaResourceDialect,
70586 > {
70587 SynchronousDatagramSocketProxyInterface::r#get_ipv6_only(self)
70588 }
70589
70590 pub fn r#set_ipv6_receive_traffic_class(
70592 &self,
70593 mut value: bool,
70594 ) -> fidl::client::QueryResponseFut<
70595 BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
70596 fidl::encoding::DefaultFuchsiaResourceDialect,
70597 > {
70598 SynchronousDatagramSocketProxyInterface::r#set_ipv6_receive_traffic_class(self, value)
70599 }
70600
70601 pub fn r#get_ipv6_receive_traffic_class(
70603 &self,
70604 ) -> fidl::client::QueryResponseFut<
70605 BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
70606 fidl::encoding::DefaultFuchsiaResourceDialect,
70607 > {
70608 SynchronousDatagramSocketProxyInterface::r#get_ipv6_receive_traffic_class(self)
70609 }
70610
70611 pub fn r#set_ipv6_traffic_class(
70613 &self,
70614 mut value: &OptionalUint8,
70615 ) -> fidl::client::QueryResponseFut<
70616 BaseNetworkSocketSetIpv6TrafficClassResult,
70617 fidl::encoding::DefaultFuchsiaResourceDialect,
70618 > {
70619 SynchronousDatagramSocketProxyInterface::r#set_ipv6_traffic_class(self, value)
70620 }
70621
70622 pub fn r#get_ipv6_traffic_class(
70624 &self,
70625 ) -> fidl::client::QueryResponseFut<
70626 BaseNetworkSocketGetIpv6TrafficClassResult,
70627 fidl::encoding::DefaultFuchsiaResourceDialect,
70628 > {
70629 SynchronousDatagramSocketProxyInterface::r#get_ipv6_traffic_class(self)
70630 }
70631
70632 pub fn r#set_ipv6_receive_packet_info(
70634 &self,
70635 mut value: bool,
70636 ) -> fidl::client::QueryResponseFut<
70637 BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
70638 fidl::encoding::DefaultFuchsiaResourceDialect,
70639 > {
70640 SynchronousDatagramSocketProxyInterface::r#set_ipv6_receive_packet_info(self, value)
70641 }
70642
70643 pub fn r#get_ipv6_receive_packet_info(
70645 &self,
70646 ) -> fidl::client::QueryResponseFut<
70647 BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
70648 fidl::encoding::DefaultFuchsiaResourceDialect,
70649 > {
70650 SynchronousDatagramSocketProxyInterface::r#get_ipv6_receive_packet_info(self)
70651 }
70652
70653 pub fn r#get_original_destination(
70655 &self,
70656 ) -> fidl::client::QueryResponseFut<
70657 BaseNetworkSocketGetOriginalDestinationResult,
70658 fidl::encoding::DefaultFuchsiaResourceDialect,
70659 > {
70660 SynchronousDatagramSocketProxyInterface::r#get_original_destination(self)
70661 }
70662
70663 pub fn r#get_info(
70668 &self,
70669 ) -> fidl::client::QueryResponseFut<
70670 BaseDatagramSocketGetInfoResult,
70671 fidl::encoding::DefaultFuchsiaResourceDialect,
70672 > {
70673 SynchronousDatagramSocketProxyInterface::r#get_info(self)
70674 }
70675
70676 pub fn r#describe(
70677 &self,
70678 ) -> fidl::client::QueryResponseFut<
70679 SynchronousDatagramSocketDescribeResponse,
70680 fidl::encoding::DefaultFuchsiaResourceDialect,
70681 > {
70682 SynchronousDatagramSocketProxyInterface::r#describe(self)
70683 }
70684
70685 pub fn r#recv_msg(
70700 &self,
70701 mut want_addr: bool,
70702 mut data_len: u32,
70703 mut want_control: bool,
70704 mut flags: RecvMsgFlags,
70705 ) -> fidl::client::QueryResponseFut<
70706 SynchronousDatagramSocketRecvMsgResult,
70707 fidl::encoding::DefaultFuchsiaResourceDialect,
70708 > {
70709 SynchronousDatagramSocketProxyInterface::r#recv_msg(
70710 self,
70711 want_addr,
70712 data_len,
70713 want_control,
70714 flags,
70715 )
70716 }
70717
70718 pub fn r#send_msg(
70727 &self,
70728 mut addr: Option<&fidl_fuchsia_net::SocketAddress>,
70729 mut data: &[u8],
70730 mut control: &DatagramSocketSendControlData,
70731 mut flags: SendMsgFlags,
70732 ) -> fidl::client::QueryResponseFut<
70733 SynchronousDatagramSocketSendMsgResult,
70734 fidl::encoding::DefaultFuchsiaResourceDialect,
70735 > {
70736 SynchronousDatagramSocketProxyInterface::r#send_msg(self, addr, data, control, flags)
70737 }
70738}
70739
70740impl SynchronousDatagramSocketProxyInterface for SynchronousDatagramSocketProxy {
70741 fn r#clone(
70742 &self,
70743 mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
70744 ) -> Result<(), fidl::Error> {
70745 self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
70746 (request,),
70747 0x20d8a7aba2168a79,
70748 fidl::encoding::DynamicFlags::empty(),
70749 )
70750 }
70751
70752 type CloseResponseFut = fidl::client::QueryResponseFut<
70753 fidl_fuchsia_unknown::CloseableCloseResult,
70754 fidl::encoding::DefaultFuchsiaResourceDialect,
70755 >;
70756 fn r#close(&self) -> Self::CloseResponseFut {
70757 fn _decode(
70758 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70759 ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
70760 let _response = fidl::client::decode_transaction_body::<
70761 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
70762 fidl::encoding::DefaultFuchsiaResourceDialect,
70763 0x5ac5d459ad7f657e,
70764 >(_buf?)?;
70765 Ok(_response.map(|x| x))
70766 }
70767 self.client.send_query_and_decode::<
70768 fidl::encoding::EmptyPayload,
70769 fidl_fuchsia_unknown::CloseableCloseResult,
70770 >(
70771 (),
70772 0x5ac5d459ad7f657e,
70773 fidl::encoding::DynamicFlags::empty(),
70774 _decode,
70775 )
70776 }
70777
70778 type QueryResponseFut =
70779 fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
70780 fn r#query(&self) -> Self::QueryResponseFut {
70781 fn _decode(
70782 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70783 ) -> Result<Vec<u8>, fidl::Error> {
70784 let _response = fidl::client::decode_transaction_body::<
70785 fidl_fuchsia_unknown::QueryableQueryResponse,
70786 fidl::encoding::DefaultFuchsiaResourceDialect,
70787 0x2658edee9decfc06,
70788 >(_buf?)?;
70789 Ok(_response.protocol)
70790 }
70791 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
70792 (),
70793 0x2658edee9decfc06,
70794 fidl::encoding::DynamicFlags::empty(),
70795 _decode,
70796 )
70797 }
70798
70799 type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
70800 BaseSocketSetReuseAddressResult,
70801 fidl::encoding::DefaultFuchsiaResourceDialect,
70802 >;
70803 fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
70804 fn _decode(
70805 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70806 ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
70807 let _response = fidl::client::decode_transaction_body::<
70808 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
70809 fidl::encoding::DefaultFuchsiaResourceDialect,
70810 0x1fd74ee8b9a4a876,
70811 >(_buf?)?;
70812 Ok(_response.map(|x| x))
70813 }
70814 self.client.send_query_and_decode::<
70815 BaseSocketSetReuseAddressRequest,
70816 BaseSocketSetReuseAddressResult,
70817 >(
70818 (value,),
70819 0x1fd74ee8b9a4a876,
70820 fidl::encoding::DynamicFlags::empty(),
70821 _decode,
70822 )
70823 }
70824
70825 type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
70826 BaseSocketGetReuseAddressResult,
70827 fidl::encoding::DefaultFuchsiaResourceDialect,
70828 >;
70829 fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
70830 fn _decode(
70831 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70832 ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
70833 let _response = fidl::client::decode_transaction_body::<
70834 fidl::encoding::ResultType<
70835 BaseSocketGetReuseAddressResponse,
70836 fidl_fuchsia_posix::Errno,
70837 >,
70838 fidl::encoding::DefaultFuchsiaResourceDialect,
70839 0x67b7206b8d1bc0a5,
70840 >(_buf?)?;
70841 Ok(_response.map(|x| x.value))
70842 }
70843 self.client
70844 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
70845 (),
70846 0x67b7206b8d1bc0a5,
70847 fidl::encoding::DynamicFlags::empty(),
70848 _decode,
70849 )
70850 }
70851
70852 type GetErrorResponseFut = fidl::client::QueryResponseFut<
70853 BaseSocketGetErrorResult,
70854 fidl::encoding::DefaultFuchsiaResourceDialect,
70855 >;
70856 fn r#get_error(&self) -> Self::GetErrorResponseFut {
70857 fn _decode(
70858 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70859 ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
70860 let _response = fidl::client::decode_transaction_body::<
70861 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
70862 fidl::encoding::DefaultFuchsiaResourceDialect,
70863 0x5aad39b33e5f6ebb,
70864 >(_buf?)?;
70865 Ok(_response.map(|x| x))
70866 }
70867 self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
70868 (),
70869 0x5aad39b33e5f6ebb,
70870 fidl::encoding::DynamicFlags::empty(),
70871 _decode,
70872 )
70873 }
70874
70875 type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
70876 BaseSocketSetBroadcastResult,
70877 fidl::encoding::DefaultFuchsiaResourceDialect,
70878 >;
70879 fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
70880 fn _decode(
70881 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70882 ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
70883 let _response = fidl::client::decode_transaction_body::<
70884 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
70885 fidl::encoding::DefaultFuchsiaResourceDialect,
70886 0x6023e081ce3cd947,
70887 >(_buf?)?;
70888 Ok(_response.map(|x| x))
70889 }
70890 self.client
70891 .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
70892 (value,),
70893 0x6023e081ce3cd947,
70894 fidl::encoding::DynamicFlags::empty(),
70895 _decode,
70896 )
70897 }
70898
70899 type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
70900 BaseSocketGetBroadcastResult,
70901 fidl::encoding::DefaultFuchsiaResourceDialect,
70902 >;
70903 fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
70904 fn _decode(
70905 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70906 ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
70907 let _response = fidl::client::decode_transaction_body::<
70908 fidl::encoding::ResultType<
70909 BaseSocketGetBroadcastResponse,
70910 fidl_fuchsia_posix::Errno,
70911 >,
70912 fidl::encoding::DefaultFuchsiaResourceDialect,
70913 0x68796fc556f9780d,
70914 >(_buf?)?;
70915 Ok(_response.map(|x| x.value))
70916 }
70917 self.client
70918 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
70919 (),
70920 0x68796fc556f9780d,
70921 fidl::encoding::DynamicFlags::empty(),
70922 _decode,
70923 )
70924 }
70925
70926 type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
70927 BaseSocketSetSendBufferResult,
70928 fidl::encoding::DefaultFuchsiaResourceDialect,
70929 >;
70930 fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
70931 fn _decode(
70932 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70933 ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
70934 let _response = fidl::client::decode_transaction_body::<
70935 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
70936 fidl::encoding::DefaultFuchsiaResourceDialect,
70937 0x756eac32d73a7a70,
70938 >(_buf?)?;
70939 Ok(_response.map(|x| x))
70940 }
70941 self.client
70942 .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
70943 (value_bytes,),
70944 0x756eac32d73a7a70,
70945 fidl::encoding::DynamicFlags::empty(),
70946 _decode,
70947 )
70948 }
70949
70950 type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
70951 BaseSocketGetSendBufferResult,
70952 fidl::encoding::DefaultFuchsiaResourceDialect,
70953 >;
70954 fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
70955 fn _decode(
70956 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70957 ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
70958 let _response = fidl::client::decode_transaction_body::<
70959 fidl::encoding::ResultType<
70960 BaseSocketGetSendBufferResponse,
70961 fidl_fuchsia_posix::Errno,
70962 >,
70963 fidl::encoding::DefaultFuchsiaResourceDialect,
70964 0x78a52fd9c7b2410b,
70965 >(_buf?)?;
70966 Ok(_response.map(|x| x.value_bytes))
70967 }
70968 self.client
70969 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
70970 (),
70971 0x78a52fd9c7b2410b,
70972 fidl::encoding::DynamicFlags::empty(),
70973 _decode,
70974 )
70975 }
70976
70977 type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
70978 BaseSocketSetReceiveBufferResult,
70979 fidl::encoding::DefaultFuchsiaResourceDialect,
70980 >;
70981 fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
70982 fn _decode(
70983 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70984 ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
70985 let _response = fidl::client::decode_transaction_body::<
70986 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
70987 fidl::encoding::DefaultFuchsiaResourceDialect,
70988 0x6b0cf2f1919c7001,
70989 >(_buf?)?;
70990 Ok(_response.map(|x| x))
70991 }
70992 self.client.send_query_and_decode::<
70993 BaseSocketSetReceiveBufferRequest,
70994 BaseSocketSetReceiveBufferResult,
70995 >(
70996 (value_bytes,),
70997 0x6b0cf2f1919c7001,
70998 fidl::encoding::DynamicFlags::empty(),
70999 _decode,
71000 )
71001 }
71002
71003 type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
71004 BaseSocketGetReceiveBufferResult,
71005 fidl::encoding::DefaultFuchsiaResourceDialect,
71006 >;
71007 fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
71008 fn _decode(
71009 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71010 ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
71011 let _response = fidl::client::decode_transaction_body::<
71012 fidl::encoding::ResultType<
71013 BaseSocketGetReceiveBufferResponse,
71014 fidl_fuchsia_posix::Errno,
71015 >,
71016 fidl::encoding::DefaultFuchsiaResourceDialect,
71017 0x14c1a4b64f709e5c,
71018 >(_buf?)?;
71019 Ok(_response.map(|x| x.value_bytes))
71020 }
71021 self.client.send_query_and_decode::<
71022 fidl::encoding::EmptyPayload,
71023 BaseSocketGetReceiveBufferResult,
71024 >(
71025 (),
71026 0x14c1a4b64f709e5c,
71027 fidl::encoding::DynamicFlags::empty(),
71028 _decode,
71029 )
71030 }
71031
71032 type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
71033 BaseSocketSetKeepAliveResult,
71034 fidl::encoding::DefaultFuchsiaResourceDialect,
71035 >;
71036 fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
71037 fn _decode(
71038 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71039 ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
71040 let _response = fidl::client::decode_transaction_body::<
71041 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71042 fidl::encoding::DefaultFuchsiaResourceDialect,
71043 0x572df8f0b920d2c7,
71044 >(_buf?)?;
71045 Ok(_response.map(|x| x))
71046 }
71047 self.client
71048 .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
71049 (value,),
71050 0x572df8f0b920d2c7,
71051 fidl::encoding::DynamicFlags::empty(),
71052 _decode,
71053 )
71054 }
71055
71056 type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
71057 BaseSocketGetKeepAliveResult,
71058 fidl::encoding::DefaultFuchsiaResourceDialect,
71059 >;
71060 fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
71061 fn _decode(
71062 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71063 ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
71064 let _response = fidl::client::decode_transaction_body::<
71065 fidl::encoding::ResultType<
71066 BaseSocketGetKeepAliveResponse,
71067 fidl_fuchsia_posix::Errno,
71068 >,
71069 fidl::encoding::DefaultFuchsiaResourceDialect,
71070 0x2dd29d3215f2c9d2,
71071 >(_buf?)?;
71072 Ok(_response.map(|x| x.value))
71073 }
71074 self.client
71075 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
71076 (),
71077 0x2dd29d3215f2c9d2,
71078 fidl::encoding::DynamicFlags::empty(),
71079 _decode,
71080 )
71081 }
71082
71083 type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
71084 BaseSocketSetOutOfBandInlineResult,
71085 fidl::encoding::DefaultFuchsiaResourceDialect,
71086 >;
71087 fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
71088 fn _decode(
71089 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71090 ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
71091 let _response = fidl::client::decode_transaction_body::<
71092 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71093 fidl::encoding::DefaultFuchsiaResourceDialect,
71094 0x3ecb49968bee439,
71095 >(_buf?)?;
71096 Ok(_response.map(|x| x))
71097 }
71098 self.client.send_query_and_decode::<
71099 BaseSocketSetOutOfBandInlineRequest,
71100 BaseSocketSetOutOfBandInlineResult,
71101 >(
71102 (value,),
71103 0x3ecb49968bee439,
71104 fidl::encoding::DynamicFlags::empty(),
71105 _decode,
71106 )
71107 }
71108
71109 type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
71110 BaseSocketGetOutOfBandInlineResult,
71111 fidl::encoding::DefaultFuchsiaResourceDialect,
71112 >;
71113 fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
71114 fn _decode(
71115 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71116 ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
71117 let _response = fidl::client::decode_transaction_body::<
71118 fidl::encoding::ResultType<
71119 BaseSocketGetOutOfBandInlineResponse,
71120 fidl_fuchsia_posix::Errno,
71121 >,
71122 fidl::encoding::DefaultFuchsiaResourceDialect,
71123 0x348c1ab3aeca1745,
71124 >(_buf?)?;
71125 Ok(_response.map(|x| x.value))
71126 }
71127 self.client.send_query_and_decode::<
71128 fidl::encoding::EmptyPayload,
71129 BaseSocketGetOutOfBandInlineResult,
71130 >(
71131 (),
71132 0x348c1ab3aeca1745,
71133 fidl::encoding::DynamicFlags::empty(),
71134 _decode,
71135 )
71136 }
71137
71138 type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
71139 BaseSocketSetNoCheckResult,
71140 fidl::encoding::DefaultFuchsiaResourceDialect,
71141 >;
71142 fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
71143 fn _decode(
71144 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71145 ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
71146 let _response = fidl::client::decode_transaction_body::<
71147 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71148 fidl::encoding::DefaultFuchsiaResourceDialect,
71149 0x6bbf00c53a4c78c2,
71150 >(_buf?)?;
71151 Ok(_response.map(|x| x))
71152 }
71153 self.client
71154 .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
71155 (value,),
71156 0x6bbf00c53a4c78c2,
71157 fidl::encoding::DynamicFlags::empty(),
71158 _decode,
71159 )
71160 }
71161
71162 type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
71163 BaseSocketGetNoCheckResult,
71164 fidl::encoding::DefaultFuchsiaResourceDialect,
71165 >;
71166 fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
71167 fn _decode(
71168 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71169 ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
71170 let _response = fidl::client::decode_transaction_body::<
71171 fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
71172 fidl::encoding::DefaultFuchsiaResourceDialect,
71173 0x2cd4249286417694,
71174 >(_buf?)?;
71175 Ok(_response.map(|x| x.value))
71176 }
71177 self.client
71178 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
71179 (),
71180 0x2cd4249286417694,
71181 fidl::encoding::DynamicFlags::empty(),
71182 _decode,
71183 )
71184 }
71185
71186 type SetLingerResponseFut = fidl::client::QueryResponseFut<
71187 BaseSocketSetLingerResult,
71188 fidl::encoding::DefaultFuchsiaResourceDialect,
71189 >;
71190 fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
71191 fn _decode(
71192 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71193 ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
71194 let _response = fidl::client::decode_transaction_body::<
71195 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71196 fidl::encoding::DefaultFuchsiaResourceDialect,
71197 0x45386351246e998e,
71198 >(_buf?)?;
71199 Ok(_response.map(|x| x))
71200 }
71201 self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
71202 (linger, length_secs),
71203 0x45386351246e998e,
71204 fidl::encoding::DynamicFlags::empty(),
71205 _decode,
71206 )
71207 }
71208
71209 type GetLingerResponseFut = fidl::client::QueryResponseFut<
71210 BaseSocketGetLingerResult,
71211 fidl::encoding::DefaultFuchsiaResourceDialect,
71212 >;
71213 fn r#get_linger(&self) -> Self::GetLingerResponseFut {
71214 fn _decode(
71215 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71216 ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
71217 let _response = fidl::client::decode_transaction_body::<
71218 fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
71219 fidl::encoding::DefaultFuchsiaResourceDialect,
71220 0x48eb20fc5ccb0e45,
71221 >(_buf?)?;
71222 Ok(_response.map(|x| (x.linger, x.length_secs)))
71223 }
71224 self.client
71225 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
71226 (),
71227 0x48eb20fc5ccb0e45,
71228 fidl::encoding::DynamicFlags::empty(),
71229 _decode,
71230 )
71231 }
71232
71233 type SetReusePortResponseFut = fidl::client::QueryResponseFut<
71234 BaseSocketSetReusePortResult,
71235 fidl::encoding::DefaultFuchsiaResourceDialect,
71236 >;
71237 fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
71238 fn _decode(
71239 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71240 ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
71241 let _response = fidl::client::decode_transaction_body::<
71242 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71243 fidl::encoding::DefaultFuchsiaResourceDialect,
71244 0x24dd3e5cb36d9ccb,
71245 >(_buf?)?;
71246 Ok(_response.map(|x| x))
71247 }
71248 self.client
71249 .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
71250 (value,),
71251 0x24dd3e5cb36d9ccb,
71252 fidl::encoding::DynamicFlags::empty(),
71253 _decode,
71254 )
71255 }
71256
71257 type GetReusePortResponseFut = fidl::client::QueryResponseFut<
71258 BaseSocketGetReusePortResult,
71259 fidl::encoding::DefaultFuchsiaResourceDialect,
71260 >;
71261 fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
71262 fn _decode(
71263 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71264 ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
71265 let _response = fidl::client::decode_transaction_body::<
71266 fidl::encoding::ResultType<
71267 BaseSocketGetReusePortResponse,
71268 fidl_fuchsia_posix::Errno,
71269 >,
71270 fidl::encoding::DefaultFuchsiaResourceDialect,
71271 0x7a112c1ab54ff828,
71272 >(_buf?)?;
71273 Ok(_response.map(|x| x.value))
71274 }
71275 self.client
71276 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
71277 (),
71278 0x7a112c1ab54ff828,
71279 fidl::encoding::DynamicFlags::empty(),
71280 _decode,
71281 )
71282 }
71283
71284 type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
71285 BaseSocketGetAcceptConnResult,
71286 fidl::encoding::DefaultFuchsiaResourceDialect,
71287 >;
71288 fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
71289 fn _decode(
71290 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71291 ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
71292 let _response = fidl::client::decode_transaction_body::<
71293 fidl::encoding::ResultType<
71294 BaseSocketGetAcceptConnResponse,
71295 fidl_fuchsia_posix::Errno,
71296 >,
71297 fidl::encoding::DefaultFuchsiaResourceDialect,
71298 0x67ce6db6c2ec8966,
71299 >(_buf?)?;
71300 Ok(_response.map(|x| x.value))
71301 }
71302 self.client
71303 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
71304 (),
71305 0x67ce6db6c2ec8966,
71306 fidl::encoding::DynamicFlags::empty(),
71307 _decode,
71308 )
71309 }
71310
71311 type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
71312 BaseSocketSetBindToDeviceResult,
71313 fidl::encoding::DefaultFuchsiaResourceDialect,
71314 >;
71315 fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
71316 fn _decode(
71317 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71318 ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
71319 let _response = fidl::client::decode_transaction_body::<
71320 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71321 fidl::encoding::DefaultFuchsiaResourceDialect,
71322 0x2118b483f28aafc4,
71323 >(_buf?)?;
71324 Ok(_response.map(|x| x))
71325 }
71326 self.client.send_query_and_decode::<
71327 BaseSocketSetBindToDeviceRequest,
71328 BaseSocketSetBindToDeviceResult,
71329 >(
71330 (value,),
71331 0x2118b483f28aafc4,
71332 fidl::encoding::DynamicFlags::empty(),
71333 _decode,
71334 )
71335 }
71336
71337 type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
71338 BaseSocketGetBindToDeviceResult,
71339 fidl::encoding::DefaultFuchsiaResourceDialect,
71340 >;
71341 fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
71342 fn _decode(
71343 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71344 ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
71345 let _response = fidl::client::decode_transaction_body::<
71346 fidl::encoding::ResultType<
71347 BaseSocketGetBindToDeviceResponse,
71348 fidl_fuchsia_posix::Errno,
71349 >,
71350 fidl::encoding::DefaultFuchsiaResourceDialect,
71351 0x1ab1fbf0ef7906c8,
71352 >(_buf?)?;
71353 Ok(_response.map(|x| x.value))
71354 }
71355 self.client
71356 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
71357 (),
71358 0x1ab1fbf0ef7906c8,
71359 fidl::encoding::DynamicFlags::empty(),
71360 _decode,
71361 )
71362 }
71363
71364 type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
71365 BaseSocketSetBindToInterfaceIndexResult,
71366 fidl::encoding::DefaultFuchsiaResourceDialect,
71367 >;
71368 fn r#set_bind_to_interface_index(
71369 &self,
71370 mut value: u64,
71371 ) -> Self::SetBindToInterfaceIndexResponseFut {
71372 fn _decode(
71373 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71374 ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
71375 let _response = fidl::client::decode_transaction_body::<
71376 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71377 fidl::encoding::DefaultFuchsiaResourceDialect,
71378 0x6e387a0def00821,
71379 >(_buf?)?;
71380 Ok(_response.map(|x| x))
71381 }
71382 self.client.send_query_and_decode::<
71383 BaseSocketSetBindToInterfaceIndexRequest,
71384 BaseSocketSetBindToInterfaceIndexResult,
71385 >(
71386 (value,),
71387 0x6e387a0def00821,
71388 fidl::encoding::DynamicFlags::empty(),
71389 _decode,
71390 )
71391 }
71392
71393 type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
71394 BaseSocketGetBindToInterfaceIndexResult,
71395 fidl::encoding::DefaultFuchsiaResourceDialect,
71396 >;
71397 fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
71398 fn _decode(
71399 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71400 ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
71401 let _response = fidl::client::decode_transaction_body::<
71402 fidl::encoding::ResultType<
71403 BaseSocketGetBindToInterfaceIndexResponse,
71404 fidl_fuchsia_posix::Errno,
71405 >,
71406 fidl::encoding::DefaultFuchsiaResourceDialect,
71407 0x59c31dd3e3078295,
71408 >(_buf?)?;
71409 Ok(_response.map(|x| x.value))
71410 }
71411 self.client.send_query_and_decode::<
71412 fidl::encoding::EmptyPayload,
71413 BaseSocketGetBindToInterfaceIndexResult,
71414 >(
71415 (),
71416 0x59c31dd3e3078295,
71417 fidl::encoding::DynamicFlags::empty(),
71418 _decode,
71419 )
71420 }
71421
71422 type SetTimestampResponseFut = fidl::client::QueryResponseFut<
71423 BaseSocketSetTimestampResult,
71424 fidl::encoding::DefaultFuchsiaResourceDialect,
71425 >;
71426 fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
71427 fn _decode(
71428 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71429 ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
71430 let _response = fidl::client::decode_transaction_body::<
71431 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71432 fidl::encoding::DefaultFuchsiaResourceDialect,
71433 0x285d6516c263d839,
71434 >(_buf?)?;
71435 Ok(_response.map(|x| x))
71436 }
71437 self.client
71438 .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
71439 (value,),
71440 0x285d6516c263d839,
71441 fidl::encoding::DynamicFlags::empty(),
71442 _decode,
71443 )
71444 }
71445
71446 type GetTimestampResponseFut = fidl::client::QueryResponseFut<
71447 BaseSocketGetTimestampResult,
71448 fidl::encoding::DefaultFuchsiaResourceDialect,
71449 >;
71450 fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
71451 fn _decode(
71452 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71453 ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
71454 let _response = fidl::client::decode_transaction_body::<
71455 fidl::encoding::ResultType<
71456 BaseSocketGetTimestampResponse,
71457 fidl_fuchsia_posix::Errno,
71458 >,
71459 fidl::encoding::DefaultFuchsiaResourceDialect,
71460 0x49f2fffbbcc2bd27,
71461 >(_buf?)?;
71462 Ok(_response.map(|x| x.value))
71463 }
71464 self.client
71465 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
71466 (),
71467 0x49f2fffbbcc2bd27,
71468 fidl::encoding::DynamicFlags::empty(),
71469 _decode,
71470 )
71471 }
71472
71473 type SetMarkResponseFut = fidl::client::QueryResponseFut<
71474 BaseSocketSetMarkResult,
71475 fidl::encoding::DefaultFuchsiaResourceDialect,
71476 >;
71477 fn r#set_mark(
71478 &self,
71479 mut domain: fidl_fuchsia_net::MarkDomain,
71480 mut mark: &OptionalUint32,
71481 ) -> Self::SetMarkResponseFut {
71482 fn _decode(
71483 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71484 ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
71485 let _response = fidl::client::decode_transaction_body::<
71486 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71487 fidl::encoding::DefaultFuchsiaResourceDialect,
71488 0x6ead6de09f653236,
71489 >(_buf?)?;
71490 Ok(_response.map(|x| x))
71491 }
71492 self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
71493 (domain, mark),
71494 0x6ead6de09f653236,
71495 fidl::encoding::DynamicFlags::empty(),
71496 _decode,
71497 )
71498 }
71499
71500 type GetMarkResponseFut = fidl::client::QueryResponseFut<
71501 BaseSocketGetMarkResult,
71502 fidl::encoding::DefaultFuchsiaResourceDialect,
71503 >;
71504 fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
71505 fn _decode(
71506 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71507 ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
71508 let _response = fidl::client::decode_transaction_body::<
71509 fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
71510 fidl::encoding::DefaultFuchsiaResourceDialect,
71511 0x57a2752c61d93d47,
71512 >(_buf?)?;
71513 Ok(_response.map(|x| x.mark))
71514 }
71515 self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
71516 (domain,),
71517 0x57a2752c61d93d47,
71518 fidl::encoding::DynamicFlags::empty(),
71519 _decode,
71520 )
71521 }
71522
71523 type BindResponseFut = fidl::client::QueryResponseFut<
71524 BaseNetworkSocketBindResult,
71525 fidl::encoding::DefaultFuchsiaResourceDialect,
71526 >;
71527 fn r#bind(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut {
71528 fn _decode(
71529 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71530 ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
71531 let _response = fidl::client::decode_transaction_body::<
71532 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71533 fidl::encoding::DefaultFuchsiaResourceDialect,
71534 0x4bc6400ae92125d,
71535 >(_buf?)?;
71536 Ok(_response.map(|x| x))
71537 }
71538 self.client
71539 .send_query_and_decode::<BaseNetworkSocketBindRequest, BaseNetworkSocketBindResult>(
71540 (addr,),
71541 0x4bc6400ae92125d,
71542 fidl::encoding::DynamicFlags::empty(),
71543 _decode,
71544 )
71545 }
71546
71547 type ConnectResponseFut = fidl::client::QueryResponseFut<
71548 BaseNetworkSocketConnectResult,
71549 fidl::encoding::DefaultFuchsiaResourceDialect,
71550 >;
71551 fn r#connect(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut {
71552 fn _decode(
71553 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71554 ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
71555 let _response = fidl::client::decode_transaction_body::<
71556 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71557 fidl::encoding::DefaultFuchsiaResourceDialect,
71558 0x5f05f19bfdd38871,
71559 >(_buf?)?;
71560 Ok(_response.map(|x| x))
71561 }
71562 self.client.send_query_and_decode::<
71563 BaseNetworkSocketConnectRequest,
71564 BaseNetworkSocketConnectResult,
71565 >(
71566 (addr,),
71567 0x5f05f19bfdd38871,
71568 fidl::encoding::DynamicFlags::empty(),
71569 _decode,
71570 )
71571 }
71572
71573 type DisconnectResponseFut = fidl::client::QueryResponseFut<
71574 BaseNetworkSocketDisconnectResult,
71575 fidl::encoding::DefaultFuchsiaResourceDialect,
71576 >;
71577 fn r#disconnect(&self) -> Self::DisconnectResponseFut {
71578 fn _decode(
71579 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71580 ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
71581 let _response = fidl::client::decode_transaction_body::<
71582 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71583 fidl::encoding::DefaultFuchsiaResourceDialect,
71584 0x74e63b91f7b29b2,
71585 >(_buf?)?;
71586 Ok(_response.map(|x| x))
71587 }
71588 self.client.send_query_and_decode::<
71589 fidl::encoding::EmptyPayload,
71590 BaseNetworkSocketDisconnectResult,
71591 >(
71592 (),
71593 0x74e63b91f7b29b2,
71594 fidl::encoding::DynamicFlags::empty(),
71595 _decode,
71596 )
71597 }
71598
71599 type GetSockNameResponseFut = fidl::client::QueryResponseFut<
71600 BaseNetworkSocketGetSockNameResult,
71601 fidl::encoding::DefaultFuchsiaResourceDialect,
71602 >;
71603 fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
71604 fn _decode(
71605 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71606 ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
71607 let _response = fidl::client::decode_transaction_body::<
71608 fidl::encoding::ResultType<
71609 BaseNetworkSocketGetSockNameResponse,
71610 fidl_fuchsia_posix::Errno,
71611 >,
71612 fidl::encoding::DefaultFuchsiaResourceDialect,
71613 0x475f23f84a1a4f85,
71614 >(_buf?)?;
71615 Ok(_response.map(|x| x.addr))
71616 }
71617 self.client.send_query_and_decode::<
71618 fidl::encoding::EmptyPayload,
71619 BaseNetworkSocketGetSockNameResult,
71620 >(
71621 (),
71622 0x475f23f84a1a4f85,
71623 fidl::encoding::DynamicFlags::empty(),
71624 _decode,
71625 )
71626 }
71627
71628 type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
71629 BaseNetworkSocketGetPeerNameResult,
71630 fidl::encoding::DefaultFuchsiaResourceDialect,
71631 >;
71632 fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
71633 fn _decode(
71634 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71635 ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
71636 let _response = fidl::client::decode_transaction_body::<
71637 fidl::encoding::ResultType<
71638 BaseNetworkSocketGetPeerNameResponse,
71639 fidl_fuchsia_posix::Errno,
71640 >,
71641 fidl::encoding::DefaultFuchsiaResourceDialect,
71642 0x1ffecf4bd5b6432e,
71643 >(_buf?)?;
71644 Ok(_response.map(|x| x.addr))
71645 }
71646 self.client.send_query_and_decode::<
71647 fidl::encoding::EmptyPayload,
71648 BaseNetworkSocketGetPeerNameResult,
71649 >(
71650 (),
71651 0x1ffecf4bd5b6432e,
71652 fidl::encoding::DynamicFlags::empty(),
71653 _decode,
71654 )
71655 }
71656
71657 type ShutdownResponseFut = fidl::client::QueryResponseFut<
71658 BaseNetworkSocketShutdownResult,
71659 fidl::encoding::DefaultFuchsiaResourceDialect,
71660 >;
71661 fn r#shutdown(&self, mut mode: ShutdownMode) -> Self::ShutdownResponseFut {
71662 fn _decode(
71663 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71664 ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
71665 let _response = fidl::client::decode_transaction_body::<
71666 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71667 fidl::encoding::DefaultFuchsiaResourceDialect,
71668 0x247f38b6db68c336,
71669 >(_buf?)?;
71670 Ok(_response.map(|x| x))
71671 }
71672 self.client.send_query_and_decode::<
71673 BaseNetworkSocketShutdownRequest,
71674 BaseNetworkSocketShutdownResult,
71675 >(
71676 (mode,),
71677 0x247f38b6db68c336,
71678 fidl::encoding::DynamicFlags::empty(),
71679 _decode,
71680 )
71681 }
71682
71683 type SetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
71684 BaseNetworkSocketSetIpTypeOfServiceResult,
71685 fidl::encoding::DefaultFuchsiaResourceDialect,
71686 >;
71687 fn r#set_ip_type_of_service(&self, mut value: u8) -> Self::SetIpTypeOfServiceResponseFut {
71688 fn _decode(
71689 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71690 ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
71691 let _response = fidl::client::decode_transaction_body::<
71692 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71693 fidl::encoding::DefaultFuchsiaResourceDialect,
71694 0x995c600475b6d46,
71695 >(_buf?)?;
71696 Ok(_response.map(|x| x))
71697 }
71698 self.client.send_query_and_decode::<
71699 BaseNetworkSocketSetIpTypeOfServiceRequest,
71700 BaseNetworkSocketSetIpTypeOfServiceResult,
71701 >(
71702 (value,),
71703 0x995c600475b6d46,
71704 fidl::encoding::DynamicFlags::empty(),
71705 _decode,
71706 )
71707 }
71708
71709 type GetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
71710 BaseNetworkSocketGetIpTypeOfServiceResult,
71711 fidl::encoding::DefaultFuchsiaResourceDialect,
71712 >;
71713 fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut {
71714 fn _decode(
71715 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71716 ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
71717 let _response = fidl::client::decode_transaction_body::<
71718 fidl::encoding::ResultType<
71719 BaseNetworkSocketGetIpTypeOfServiceResponse,
71720 fidl_fuchsia_posix::Errno,
71721 >,
71722 fidl::encoding::DefaultFuchsiaResourceDialect,
71723 0x3814a04259f75fcb,
71724 >(_buf?)?;
71725 Ok(_response.map(|x| x.value))
71726 }
71727 self.client.send_query_and_decode::<
71728 fidl::encoding::EmptyPayload,
71729 BaseNetworkSocketGetIpTypeOfServiceResult,
71730 >(
71731 (),
71732 0x3814a04259f75fcb,
71733 fidl::encoding::DynamicFlags::empty(),
71734 _decode,
71735 )
71736 }
71737
71738 type SetIpTtlResponseFut = fidl::client::QueryResponseFut<
71739 BaseNetworkSocketSetIpTtlResult,
71740 fidl::encoding::DefaultFuchsiaResourceDialect,
71741 >;
71742 fn r#set_ip_ttl(&self, mut value: &OptionalUint8) -> Self::SetIpTtlResponseFut {
71743 fn _decode(
71744 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71745 ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
71746 let _response = fidl::client::decode_transaction_body::<
71747 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71748 fidl::encoding::DefaultFuchsiaResourceDialect,
71749 0x29e2424b433ae1ef,
71750 >(_buf?)?;
71751 Ok(_response.map(|x| x))
71752 }
71753 self.client.send_query_and_decode::<
71754 BaseNetworkSocketSetIpTtlRequest,
71755 BaseNetworkSocketSetIpTtlResult,
71756 >(
71757 (value,),
71758 0x29e2424b433ae1ef,
71759 fidl::encoding::DynamicFlags::empty(),
71760 _decode,
71761 )
71762 }
71763
71764 type GetIpTtlResponseFut = fidl::client::QueryResponseFut<
71765 BaseNetworkSocketGetIpTtlResult,
71766 fidl::encoding::DefaultFuchsiaResourceDialect,
71767 >;
71768 fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut {
71769 fn _decode(
71770 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71771 ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
71772 let _response = fidl::client::decode_transaction_body::<
71773 fidl::encoding::ResultType<
71774 BaseNetworkSocketGetIpTtlResponse,
71775 fidl_fuchsia_posix::Errno,
71776 >,
71777 fidl::encoding::DefaultFuchsiaResourceDialect,
71778 0x47e47fa1f24da471,
71779 >(_buf?)?;
71780 Ok(_response.map(|x| x.value))
71781 }
71782 self.client
71783 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseNetworkSocketGetIpTtlResult>(
71784 (),
71785 0x47e47fa1f24da471,
71786 fidl::encoding::DynamicFlags::empty(),
71787 _decode,
71788 )
71789 }
71790
71791 type SetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
71792 BaseNetworkSocketSetIpPacketInfoResult,
71793 fidl::encoding::DefaultFuchsiaResourceDialect,
71794 >;
71795 fn r#set_ip_packet_info(&self, mut value: bool) -> Self::SetIpPacketInfoResponseFut {
71796 fn _decode(
71797 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71798 ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
71799 let _response = fidl::client::decode_transaction_body::<
71800 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71801 fidl::encoding::DefaultFuchsiaResourceDialect,
71802 0x392d16bee20c0e16,
71803 >(_buf?)?;
71804 Ok(_response.map(|x| x))
71805 }
71806 self.client.send_query_and_decode::<
71807 BaseNetworkSocketSetIpPacketInfoRequest,
71808 BaseNetworkSocketSetIpPacketInfoResult,
71809 >(
71810 (value,),
71811 0x392d16bee20c0e16,
71812 fidl::encoding::DynamicFlags::empty(),
71813 _decode,
71814 )
71815 }
71816
71817 type GetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
71818 BaseNetworkSocketGetIpPacketInfoResult,
71819 fidl::encoding::DefaultFuchsiaResourceDialect,
71820 >;
71821 fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut {
71822 fn _decode(
71823 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71824 ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
71825 let _response = fidl::client::decode_transaction_body::<
71826 fidl::encoding::ResultType<
71827 BaseNetworkSocketGetIpPacketInfoResponse,
71828 fidl_fuchsia_posix::Errno,
71829 >,
71830 fidl::encoding::DefaultFuchsiaResourceDialect,
71831 0x54b505f242280740,
71832 >(_buf?)?;
71833 Ok(_response.map(|x| x.value))
71834 }
71835 self.client.send_query_and_decode::<
71836 fidl::encoding::EmptyPayload,
71837 BaseNetworkSocketGetIpPacketInfoResult,
71838 >(
71839 (),
71840 0x54b505f242280740,
71841 fidl::encoding::DynamicFlags::empty(),
71842 _decode,
71843 )
71844 }
71845
71846 type SetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
71847 BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
71848 fidl::encoding::DefaultFuchsiaResourceDialect,
71849 >;
71850 fn r#set_ip_receive_type_of_service(
71851 &self,
71852 mut value: bool,
71853 ) -> Self::SetIpReceiveTypeOfServiceResponseFut {
71854 fn _decode(
71855 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71856 ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
71857 let _response = fidl::client::decode_transaction_body::<
71858 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71859 fidl::encoding::DefaultFuchsiaResourceDialect,
71860 0x6c4f6714995f84ef,
71861 >(_buf?)?;
71862 Ok(_response.map(|x| x))
71863 }
71864 self.client.send_query_and_decode::<
71865 BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
71866 BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
71867 >(
71868 (value,),
71869 0x6c4f6714995f84ef,
71870 fidl::encoding::DynamicFlags::empty(),
71871 _decode,
71872 )
71873 }
71874
71875 type GetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
71876 BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
71877 fidl::encoding::DefaultFuchsiaResourceDialect,
71878 >;
71879 fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut {
71880 fn _decode(
71881 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71882 ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
71883 let _response = fidl::client::decode_transaction_body::<
71884 fidl::encoding::ResultType<
71885 BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
71886 fidl_fuchsia_posix::Errno,
71887 >,
71888 fidl::encoding::DefaultFuchsiaResourceDialect,
71889 0x4158ba7dc2795960,
71890 >(_buf?)?;
71891 Ok(_response.map(|x| x.value))
71892 }
71893 self.client.send_query_and_decode::<
71894 fidl::encoding::EmptyPayload,
71895 BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
71896 >(
71897 (),
71898 0x4158ba7dc2795960,
71899 fidl::encoding::DynamicFlags::empty(),
71900 _decode,
71901 )
71902 }
71903
71904 type SetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
71905 BaseNetworkSocketSetIpReceiveTtlResult,
71906 fidl::encoding::DefaultFuchsiaResourceDialect,
71907 >;
71908 fn r#set_ip_receive_ttl(&self, mut value: bool) -> Self::SetIpReceiveTtlResponseFut {
71909 fn _decode(
71910 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71911 ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
71912 let _response = fidl::client::decode_transaction_body::<
71913 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71914 fidl::encoding::DefaultFuchsiaResourceDialect,
71915 0x46f15be0ce0ab82b,
71916 >(_buf?)?;
71917 Ok(_response.map(|x| x))
71918 }
71919 self.client.send_query_and_decode::<
71920 BaseNetworkSocketSetIpReceiveTtlRequest,
71921 BaseNetworkSocketSetIpReceiveTtlResult,
71922 >(
71923 (value,),
71924 0x46f15be0ce0ab82b,
71925 fidl::encoding::DynamicFlags::empty(),
71926 _decode,
71927 )
71928 }
71929
71930 type GetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
71931 BaseNetworkSocketGetIpReceiveTtlResult,
71932 fidl::encoding::DefaultFuchsiaResourceDialect,
71933 >;
71934 fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut {
71935 fn _decode(
71936 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71937 ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
71938 let _response = fidl::client::decode_transaction_body::<
71939 fidl::encoding::ResultType<
71940 BaseNetworkSocketGetIpReceiveTtlResponse,
71941 fidl_fuchsia_posix::Errno,
71942 >,
71943 fidl::encoding::DefaultFuchsiaResourceDialect,
71944 0x678ddd5a5dfa2eb5,
71945 >(_buf?)?;
71946 Ok(_response.map(|x| x.value))
71947 }
71948 self.client.send_query_and_decode::<
71949 fidl::encoding::EmptyPayload,
71950 BaseNetworkSocketGetIpReceiveTtlResult,
71951 >(
71952 (),
71953 0x678ddd5a5dfa2eb5,
71954 fidl::encoding::DynamicFlags::empty(),
71955 _decode,
71956 )
71957 }
71958
71959 type SetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
71960 BaseNetworkSocketSetIpMulticastInterfaceResult,
71961 fidl::encoding::DefaultFuchsiaResourceDialect,
71962 >;
71963 fn r#set_ip_multicast_interface(
71964 &self,
71965 mut iface: u64,
71966 mut address: &fidl_fuchsia_net::Ipv4Address,
71967 ) -> Self::SetIpMulticastInterfaceResponseFut {
71968 fn _decode(
71969 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71970 ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
71971 let _response = fidl::client::decode_transaction_body::<
71972 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71973 fidl::encoding::DefaultFuchsiaResourceDialect,
71974 0x752fbfa9b12befe,
71975 >(_buf?)?;
71976 Ok(_response.map(|x| x))
71977 }
71978 self.client.send_query_and_decode::<
71979 BaseNetworkSocketSetIpMulticastInterfaceRequest,
71980 BaseNetworkSocketSetIpMulticastInterfaceResult,
71981 >(
71982 (iface, address,),
71983 0x752fbfa9b12befe,
71984 fidl::encoding::DynamicFlags::empty(),
71985 _decode,
71986 )
71987 }
71988
71989 type GetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
71990 BaseNetworkSocketGetIpMulticastInterfaceResult,
71991 fidl::encoding::DefaultFuchsiaResourceDialect,
71992 >;
71993 fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut {
71994 fn _decode(
71995 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71996 ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
71997 let _response = fidl::client::decode_transaction_body::<
71998 fidl::encoding::ResultType<
71999 BaseNetworkSocketGetIpMulticastInterfaceResponse,
72000 fidl_fuchsia_posix::Errno,
72001 >,
72002 fidl::encoding::DefaultFuchsiaResourceDialect,
72003 0x320bd14c4df046c4,
72004 >(_buf?)?;
72005 Ok(_response.map(|x| x.value))
72006 }
72007 self.client.send_query_and_decode::<
72008 fidl::encoding::EmptyPayload,
72009 BaseNetworkSocketGetIpMulticastInterfaceResult,
72010 >(
72011 (),
72012 0x320bd14c4df046c4,
72013 fidl::encoding::DynamicFlags::empty(),
72014 _decode,
72015 )
72016 }
72017
72018 type SetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
72019 BaseNetworkSocketSetIpMulticastTtlResult,
72020 fidl::encoding::DefaultFuchsiaResourceDialect,
72021 >;
72022 fn r#set_ip_multicast_ttl(
72023 &self,
72024 mut value: &OptionalUint8,
72025 ) -> Self::SetIpMulticastTtlResponseFut {
72026 fn _decode(
72027 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72028 ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
72029 let _response = fidl::client::decode_transaction_body::<
72030 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72031 fidl::encoding::DefaultFuchsiaResourceDialect,
72032 0x63134d53772916a1,
72033 >(_buf?)?;
72034 Ok(_response.map(|x| x))
72035 }
72036 self.client.send_query_and_decode::<
72037 BaseNetworkSocketSetIpMulticastTtlRequest,
72038 BaseNetworkSocketSetIpMulticastTtlResult,
72039 >(
72040 (value,),
72041 0x63134d53772916a1,
72042 fidl::encoding::DynamicFlags::empty(),
72043 _decode,
72044 )
72045 }
72046
72047 type GetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
72048 BaseNetworkSocketGetIpMulticastTtlResult,
72049 fidl::encoding::DefaultFuchsiaResourceDialect,
72050 >;
72051 fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut {
72052 fn _decode(
72053 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72054 ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
72055 let _response = fidl::client::decode_transaction_body::<
72056 fidl::encoding::ResultType<
72057 BaseNetworkSocketGetIpMulticastTtlResponse,
72058 fidl_fuchsia_posix::Errno,
72059 >,
72060 fidl::encoding::DefaultFuchsiaResourceDialect,
72061 0x4665cd378f39e1a,
72062 >(_buf?)?;
72063 Ok(_response.map(|x| x.value))
72064 }
72065 self.client.send_query_and_decode::<
72066 fidl::encoding::EmptyPayload,
72067 BaseNetworkSocketGetIpMulticastTtlResult,
72068 >(
72069 (),
72070 0x4665cd378f39e1a,
72071 fidl::encoding::DynamicFlags::empty(),
72072 _decode,
72073 )
72074 }
72075
72076 type SetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
72077 BaseNetworkSocketSetIpMulticastLoopbackResult,
72078 fidl::encoding::DefaultFuchsiaResourceDialect,
72079 >;
72080 fn r#set_ip_multicast_loopback(
72081 &self,
72082 mut value: bool,
72083 ) -> Self::SetIpMulticastLoopbackResponseFut {
72084 fn _decode(
72085 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72086 ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
72087 let _response = fidl::client::decode_transaction_body::<
72088 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72089 fidl::encoding::DefaultFuchsiaResourceDialect,
72090 0x20c55c11f00943ea,
72091 >(_buf?)?;
72092 Ok(_response.map(|x| x))
72093 }
72094 self.client.send_query_and_decode::<
72095 BaseNetworkSocketSetIpMulticastLoopbackRequest,
72096 BaseNetworkSocketSetIpMulticastLoopbackResult,
72097 >(
72098 (value,),
72099 0x20c55c11f00943ea,
72100 fidl::encoding::DynamicFlags::empty(),
72101 _decode,
72102 )
72103 }
72104
72105 type GetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
72106 BaseNetworkSocketGetIpMulticastLoopbackResult,
72107 fidl::encoding::DefaultFuchsiaResourceDialect,
72108 >;
72109 fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut {
72110 fn _decode(
72111 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72112 ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
72113 let _response = fidl::client::decode_transaction_body::<
72114 fidl::encoding::ResultType<
72115 BaseNetworkSocketGetIpMulticastLoopbackResponse,
72116 fidl_fuchsia_posix::Errno,
72117 >,
72118 fidl::encoding::DefaultFuchsiaResourceDialect,
72119 0x3b6b26ff558298f2,
72120 >(_buf?)?;
72121 Ok(_response.map(|x| x.value))
72122 }
72123 self.client.send_query_and_decode::<
72124 fidl::encoding::EmptyPayload,
72125 BaseNetworkSocketGetIpMulticastLoopbackResult,
72126 >(
72127 (),
72128 0x3b6b26ff558298f2,
72129 fidl::encoding::DynamicFlags::empty(),
72130 _decode,
72131 )
72132 }
72133
72134 type AddIpMembershipResponseFut = fidl::client::QueryResponseFut<
72135 BaseNetworkSocketAddIpMembershipResult,
72136 fidl::encoding::DefaultFuchsiaResourceDialect,
72137 >;
72138 fn r#add_ip_membership(
72139 &self,
72140 mut membership: &IpMulticastMembership,
72141 ) -> Self::AddIpMembershipResponseFut {
72142 fn _decode(
72143 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72144 ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
72145 let _response = fidl::client::decode_transaction_body::<
72146 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72147 fidl::encoding::DefaultFuchsiaResourceDialect,
72148 0x76bc7df115a3b4d0,
72149 >(_buf?)?;
72150 Ok(_response.map(|x| x))
72151 }
72152 self.client.send_query_and_decode::<
72153 BaseNetworkSocketAddIpMembershipRequest,
72154 BaseNetworkSocketAddIpMembershipResult,
72155 >(
72156 (membership,),
72157 0x76bc7df115a3b4d0,
72158 fidl::encoding::DynamicFlags::empty(),
72159 _decode,
72160 )
72161 }
72162
72163 type DropIpMembershipResponseFut = fidl::client::QueryResponseFut<
72164 BaseNetworkSocketDropIpMembershipResult,
72165 fidl::encoding::DefaultFuchsiaResourceDialect,
72166 >;
72167 fn r#drop_ip_membership(
72168 &self,
72169 mut membership: &IpMulticastMembership,
72170 ) -> Self::DropIpMembershipResponseFut {
72171 fn _decode(
72172 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72173 ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
72174 let _response = fidl::client::decode_transaction_body::<
72175 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72176 fidl::encoding::DefaultFuchsiaResourceDialect,
72177 0x2888f3099188d03,
72178 >(_buf?)?;
72179 Ok(_response.map(|x| x))
72180 }
72181 self.client.send_query_and_decode::<
72182 BaseNetworkSocketDropIpMembershipRequest,
72183 BaseNetworkSocketDropIpMembershipResult,
72184 >(
72185 (membership,),
72186 0x2888f3099188d03,
72187 fidl::encoding::DynamicFlags::empty(),
72188 _decode,
72189 )
72190 }
72191
72192 type SetIpTransparentResponseFut = fidl::client::QueryResponseFut<
72193 BaseNetworkSocketSetIpTransparentResult,
72194 fidl::encoding::DefaultFuchsiaResourceDialect,
72195 >;
72196 fn r#set_ip_transparent(&self, mut value: bool) -> Self::SetIpTransparentResponseFut {
72197 fn _decode(
72198 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72199 ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
72200 let _response = fidl::client::decode_transaction_body::<
72201 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72202 fidl::encoding::DefaultFuchsiaResourceDialect,
72203 0x1ae532b0c066e3a0,
72204 >(_buf?)?;
72205 Ok(_response.map(|x| x))
72206 }
72207 self.client.send_query_and_decode::<
72208 BaseNetworkSocketSetIpTransparentRequest,
72209 BaseNetworkSocketSetIpTransparentResult,
72210 >(
72211 (value,),
72212 0x1ae532b0c066e3a0,
72213 fidl::encoding::DynamicFlags::empty(),
72214 _decode,
72215 )
72216 }
72217
72218 type GetIpTransparentResponseFut = fidl::client::QueryResponseFut<
72219 BaseNetworkSocketGetIpTransparentResult,
72220 fidl::encoding::DefaultFuchsiaResourceDialect,
72221 >;
72222 fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut {
72223 fn _decode(
72224 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72225 ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
72226 let _response = fidl::client::decode_transaction_body::<
72227 fidl::encoding::ResultType<
72228 BaseNetworkSocketGetIpTransparentResponse,
72229 fidl_fuchsia_posix::Errno,
72230 >,
72231 fidl::encoding::DefaultFuchsiaResourceDialect,
72232 0x51d43695962ebfb5,
72233 >(_buf?)?;
72234 Ok(_response.map(|x| x.value))
72235 }
72236 self.client.send_query_and_decode::<
72237 fidl::encoding::EmptyPayload,
72238 BaseNetworkSocketGetIpTransparentResult,
72239 >(
72240 (),
72241 0x51d43695962ebfb5,
72242 fidl::encoding::DynamicFlags::empty(),
72243 _decode,
72244 )
72245 }
72246
72247 type SetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
72248 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
72249 fidl::encoding::DefaultFuchsiaResourceDialect,
72250 >;
72251 fn r#set_ip_receive_original_destination_address(
72252 &self,
72253 mut value: bool,
72254 ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut {
72255 fn _decode(
72256 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72257 ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>
72258 {
72259 let _response = fidl::client::decode_transaction_body::<
72260 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72261 fidl::encoding::DefaultFuchsiaResourceDialect,
72262 0x4722b4ce52f7840,
72263 >(_buf?)?;
72264 Ok(_response.map(|x| x))
72265 }
72266 self.client.send_query_and_decode::<
72267 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
72268 BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
72269 >(
72270 (value,),
72271 0x4722b4ce52f7840,
72272 fidl::encoding::DynamicFlags::empty(),
72273 _decode,
72274 )
72275 }
72276
72277 type GetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
72278 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
72279 fidl::encoding::DefaultFuchsiaResourceDialect,
72280 >;
72281 fn r#get_ip_receive_original_destination_address(
72282 &self,
72283 ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut {
72284 fn _decode(
72285 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72286 ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>
72287 {
72288 let _response = fidl::client::decode_transaction_body::<
72289 fidl::encoding::ResultType<
72290 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
72291 fidl_fuchsia_posix::Errno,
72292 >,
72293 fidl::encoding::DefaultFuchsiaResourceDialect,
72294 0x2a0e7dc5d6bfdfe9,
72295 >(_buf?)?;
72296 Ok(_response.map(|x| x.value))
72297 }
72298 self.client.send_query_and_decode::<
72299 fidl::encoding::EmptyPayload,
72300 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
72301 >(
72302 (),
72303 0x2a0e7dc5d6bfdfe9,
72304 fidl::encoding::DynamicFlags::empty(),
72305 _decode,
72306 )
72307 }
72308
72309 type AddIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
72310 BaseNetworkSocketAddIpv6MembershipResult,
72311 fidl::encoding::DefaultFuchsiaResourceDialect,
72312 >;
72313 fn r#add_ipv6_membership(
72314 &self,
72315 mut membership: &Ipv6MulticastMembership,
72316 ) -> Self::AddIpv6MembershipResponseFut {
72317 fn _decode(
72318 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72319 ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
72320 let _response = fidl::client::decode_transaction_body::<
72321 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72322 fidl::encoding::DefaultFuchsiaResourceDialect,
72323 0x7c94727acb4ea4b3,
72324 >(_buf?)?;
72325 Ok(_response.map(|x| x))
72326 }
72327 self.client.send_query_and_decode::<
72328 BaseNetworkSocketAddIpv6MembershipRequest,
72329 BaseNetworkSocketAddIpv6MembershipResult,
72330 >(
72331 (membership,),
72332 0x7c94727acb4ea4b3,
72333 fidl::encoding::DynamicFlags::empty(),
72334 _decode,
72335 )
72336 }
72337
72338 type DropIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
72339 BaseNetworkSocketDropIpv6MembershipResult,
72340 fidl::encoding::DefaultFuchsiaResourceDialect,
72341 >;
72342 fn r#drop_ipv6_membership(
72343 &self,
72344 mut membership: &Ipv6MulticastMembership,
72345 ) -> Self::DropIpv6MembershipResponseFut {
72346 fn _decode(
72347 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72348 ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
72349 let _response = fidl::client::decode_transaction_body::<
72350 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72351 fidl::encoding::DefaultFuchsiaResourceDialect,
72352 0x42104c70ccaba304,
72353 >(_buf?)?;
72354 Ok(_response.map(|x| x))
72355 }
72356 self.client.send_query_and_decode::<
72357 BaseNetworkSocketDropIpv6MembershipRequest,
72358 BaseNetworkSocketDropIpv6MembershipResult,
72359 >(
72360 (membership,),
72361 0x42104c70ccaba304,
72362 fidl::encoding::DynamicFlags::empty(),
72363 _decode,
72364 )
72365 }
72366
72367 type SetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
72368 BaseNetworkSocketSetIpv6MulticastInterfaceResult,
72369 fidl::encoding::DefaultFuchsiaResourceDialect,
72370 >;
72371 fn r#set_ipv6_multicast_interface(
72372 &self,
72373 mut value: u64,
72374 ) -> Self::SetIpv6MulticastInterfaceResponseFut {
72375 fn _decode(
72376 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72377 ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
72378 let _response = fidl::client::decode_transaction_body::<
72379 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72380 fidl::encoding::DefaultFuchsiaResourceDialect,
72381 0x135f76db3774ab3b,
72382 >(_buf?)?;
72383 Ok(_response.map(|x| x))
72384 }
72385 self.client.send_query_and_decode::<
72386 BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
72387 BaseNetworkSocketSetIpv6MulticastInterfaceResult,
72388 >(
72389 (value,),
72390 0x135f76db3774ab3b,
72391 fidl::encoding::DynamicFlags::empty(),
72392 _decode,
72393 )
72394 }
72395
72396 type GetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
72397 BaseNetworkSocketGetIpv6MulticastInterfaceResult,
72398 fidl::encoding::DefaultFuchsiaResourceDialect,
72399 >;
72400 fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut {
72401 fn _decode(
72402 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72403 ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
72404 let _response = fidl::client::decode_transaction_body::<
72405 fidl::encoding::ResultType<
72406 BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
72407 fidl_fuchsia_posix::Errno,
72408 >,
72409 fidl::encoding::DefaultFuchsiaResourceDialect,
72410 0x1f26fcdd348f1882,
72411 >(_buf?)?;
72412 Ok(_response.map(|x| x.value))
72413 }
72414 self.client.send_query_and_decode::<
72415 fidl::encoding::EmptyPayload,
72416 BaseNetworkSocketGetIpv6MulticastInterfaceResult,
72417 >(
72418 (),
72419 0x1f26fcdd348f1882,
72420 fidl::encoding::DynamicFlags::empty(),
72421 _decode,
72422 )
72423 }
72424
72425 type SetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
72426 BaseNetworkSocketSetIpv6UnicastHopsResult,
72427 fidl::encoding::DefaultFuchsiaResourceDialect,
72428 >;
72429 fn r#set_ipv6_unicast_hops(
72430 &self,
72431 mut value: &OptionalUint8,
72432 ) -> Self::SetIpv6UnicastHopsResponseFut {
72433 fn _decode(
72434 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72435 ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
72436 let _response = fidl::client::decode_transaction_body::<
72437 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72438 fidl::encoding::DefaultFuchsiaResourceDialect,
72439 0x157d51e98f462859,
72440 >(_buf?)?;
72441 Ok(_response.map(|x| x))
72442 }
72443 self.client.send_query_and_decode::<
72444 BaseNetworkSocketSetIpv6UnicastHopsRequest,
72445 BaseNetworkSocketSetIpv6UnicastHopsResult,
72446 >(
72447 (value,),
72448 0x157d51e98f462859,
72449 fidl::encoding::DynamicFlags::empty(),
72450 _decode,
72451 )
72452 }
72453
72454 type GetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
72455 BaseNetworkSocketGetIpv6UnicastHopsResult,
72456 fidl::encoding::DefaultFuchsiaResourceDialect,
72457 >;
72458 fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut {
72459 fn _decode(
72460 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72461 ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
72462 let _response = fidl::client::decode_transaction_body::<
72463 fidl::encoding::ResultType<
72464 BaseNetworkSocketGetIpv6UnicastHopsResponse,
72465 fidl_fuchsia_posix::Errno,
72466 >,
72467 fidl::encoding::DefaultFuchsiaResourceDialect,
72468 0x21f4641cad8bd8d2,
72469 >(_buf?)?;
72470 Ok(_response.map(|x| x.value))
72471 }
72472 self.client.send_query_and_decode::<
72473 fidl::encoding::EmptyPayload,
72474 BaseNetworkSocketGetIpv6UnicastHopsResult,
72475 >(
72476 (),
72477 0x21f4641cad8bd8d2,
72478 fidl::encoding::DynamicFlags::empty(),
72479 _decode,
72480 )
72481 }
72482
72483 type SetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
72484 BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
72485 fidl::encoding::DefaultFuchsiaResourceDialect,
72486 >;
72487 fn r#set_ipv6_receive_hop_limit(
72488 &self,
72489 mut value: bool,
72490 ) -> Self::SetIpv6ReceiveHopLimitResponseFut {
72491 fn _decode(
72492 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72493 ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
72494 let _response = fidl::client::decode_transaction_body::<
72495 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72496 fidl::encoding::DefaultFuchsiaResourceDialect,
72497 0x5c24808ed2e84a1e,
72498 >(_buf?)?;
72499 Ok(_response.map(|x| x))
72500 }
72501 self.client.send_query_and_decode::<
72502 BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
72503 BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
72504 >(
72505 (value,),
72506 0x5c24808ed2e84a1e,
72507 fidl::encoding::DynamicFlags::empty(),
72508 _decode,
72509 )
72510 }
72511
72512 type GetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
72513 BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
72514 fidl::encoding::DefaultFuchsiaResourceDialect,
72515 >;
72516 fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut {
72517 fn _decode(
72518 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72519 ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
72520 let _response = fidl::client::decode_transaction_body::<
72521 fidl::encoding::ResultType<
72522 BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
72523 fidl_fuchsia_posix::Errno,
72524 >,
72525 fidl::encoding::DefaultFuchsiaResourceDialect,
72526 0x341e06689885b4c0,
72527 >(_buf?)?;
72528 Ok(_response.map(|x| x.value))
72529 }
72530 self.client.send_query_and_decode::<
72531 fidl::encoding::EmptyPayload,
72532 BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
72533 >(
72534 (),
72535 0x341e06689885b4c0,
72536 fidl::encoding::DynamicFlags::empty(),
72537 _decode,
72538 )
72539 }
72540
72541 type SetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
72542 BaseNetworkSocketSetIpv6MulticastHopsResult,
72543 fidl::encoding::DefaultFuchsiaResourceDialect,
72544 >;
72545 fn r#set_ipv6_multicast_hops(
72546 &self,
72547 mut value: &OptionalUint8,
72548 ) -> Self::SetIpv6MulticastHopsResponseFut {
72549 fn _decode(
72550 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72551 ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
72552 let _response = fidl::client::decode_transaction_body::<
72553 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72554 fidl::encoding::DefaultFuchsiaResourceDialect,
72555 0x25b9cd4d181f82c1,
72556 >(_buf?)?;
72557 Ok(_response.map(|x| x))
72558 }
72559 self.client.send_query_and_decode::<
72560 BaseNetworkSocketSetIpv6MulticastHopsRequest,
72561 BaseNetworkSocketSetIpv6MulticastHopsResult,
72562 >(
72563 (value,),
72564 0x25b9cd4d181f82c1,
72565 fidl::encoding::DynamicFlags::empty(),
72566 _decode,
72567 )
72568 }
72569
72570 type GetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
72571 BaseNetworkSocketGetIpv6MulticastHopsResult,
72572 fidl::encoding::DefaultFuchsiaResourceDialect,
72573 >;
72574 fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut {
72575 fn _decode(
72576 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72577 ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
72578 let _response = fidl::client::decode_transaction_body::<
72579 fidl::encoding::ResultType<
72580 BaseNetworkSocketGetIpv6MulticastHopsResponse,
72581 fidl_fuchsia_posix::Errno,
72582 >,
72583 fidl::encoding::DefaultFuchsiaResourceDialect,
72584 0x52916948a365012a,
72585 >(_buf?)?;
72586 Ok(_response.map(|x| x.value))
72587 }
72588 self.client.send_query_and_decode::<
72589 fidl::encoding::EmptyPayload,
72590 BaseNetworkSocketGetIpv6MulticastHopsResult,
72591 >(
72592 (),
72593 0x52916948a365012a,
72594 fidl::encoding::DynamicFlags::empty(),
72595 _decode,
72596 )
72597 }
72598
72599 type SetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
72600 BaseNetworkSocketSetIpv6MulticastLoopbackResult,
72601 fidl::encoding::DefaultFuchsiaResourceDialect,
72602 >;
72603 fn r#set_ipv6_multicast_loopback(
72604 &self,
72605 mut value: bool,
72606 ) -> Self::SetIpv6MulticastLoopbackResponseFut {
72607 fn _decode(
72608 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72609 ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
72610 let _response = fidl::client::decode_transaction_body::<
72611 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72612 fidl::encoding::DefaultFuchsiaResourceDialect,
72613 0x55701c409ff41b40,
72614 >(_buf?)?;
72615 Ok(_response.map(|x| x))
72616 }
72617 self.client.send_query_and_decode::<
72618 BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
72619 BaseNetworkSocketSetIpv6MulticastLoopbackResult,
72620 >(
72621 (value,),
72622 0x55701c409ff41b40,
72623 fidl::encoding::DynamicFlags::empty(),
72624 _decode,
72625 )
72626 }
72627
72628 type GetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
72629 BaseNetworkSocketGetIpv6MulticastLoopbackResult,
72630 fidl::encoding::DefaultFuchsiaResourceDialect,
72631 >;
72632 fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut {
72633 fn _decode(
72634 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72635 ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
72636 let _response = fidl::client::decode_transaction_body::<
72637 fidl::encoding::ResultType<
72638 BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
72639 fidl_fuchsia_posix::Errno,
72640 >,
72641 fidl::encoding::DefaultFuchsiaResourceDialect,
72642 0x4415b701fde319c3,
72643 >(_buf?)?;
72644 Ok(_response.map(|x| x.value))
72645 }
72646 self.client.send_query_and_decode::<
72647 fidl::encoding::EmptyPayload,
72648 BaseNetworkSocketGetIpv6MulticastLoopbackResult,
72649 >(
72650 (),
72651 0x4415b701fde319c3,
72652 fidl::encoding::DynamicFlags::empty(),
72653 _decode,
72654 )
72655 }
72656
72657 type SetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
72658 BaseNetworkSocketSetIpv6OnlyResult,
72659 fidl::encoding::DefaultFuchsiaResourceDialect,
72660 >;
72661 fn r#set_ipv6_only(&self, mut value: bool) -> Self::SetIpv6OnlyResponseFut {
72662 fn _decode(
72663 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72664 ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
72665 let _response = fidl::client::decode_transaction_body::<
72666 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72667 fidl::encoding::DefaultFuchsiaResourceDialect,
72668 0x4873f1364758cbba,
72669 >(_buf?)?;
72670 Ok(_response.map(|x| x))
72671 }
72672 self.client.send_query_and_decode::<
72673 BaseNetworkSocketSetIpv6OnlyRequest,
72674 BaseNetworkSocketSetIpv6OnlyResult,
72675 >(
72676 (value,),
72677 0x4873f1364758cbba,
72678 fidl::encoding::DynamicFlags::empty(),
72679 _decode,
72680 )
72681 }
72682
72683 type GetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
72684 BaseNetworkSocketGetIpv6OnlyResult,
72685 fidl::encoding::DefaultFuchsiaResourceDialect,
72686 >;
72687 fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut {
72688 fn _decode(
72689 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72690 ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
72691 let _response = fidl::client::decode_transaction_body::<
72692 fidl::encoding::ResultType<
72693 BaseNetworkSocketGetIpv6OnlyResponse,
72694 fidl_fuchsia_posix::Errno,
72695 >,
72696 fidl::encoding::DefaultFuchsiaResourceDialect,
72697 0x4aa3340a1a26b89c,
72698 >(_buf?)?;
72699 Ok(_response.map(|x| x.value))
72700 }
72701 self.client.send_query_and_decode::<
72702 fidl::encoding::EmptyPayload,
72703 BaseNetworkSocketGetIpv6OnlyResult,
72704 >(
72705 (),
72706 0x4aa3340a1a26b89c,
72707 fidl::encoding::DynamicFlags::empty(),
72708 _decode,
72709 )
72710 }
72711
72712 type SetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
72713 BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
72714 fidl::encoding::DefaultFuchsiaResourceDialect,
72715 >;
72716 fn r#set_ipv6_receive_traffic_class(
72717 &self,
72718 mut value: bool,
72719 ) -> Self::SetIpv6ReceiveTrafficClassResponseFut {
72720 fn _decode(
72721 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72722 ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
72723 let _response = fidl::client::decode_transaction_body::<
72724 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72725 fidl::encoding::DefaultFuchsiaResourceDialect,
72726 0x58f07c8788d099a0,
72727 >(_buf?)?;
72728 Ok(_response.map(|x| x))
72729 }
72730 self.client.send_query_and_decode::<
72731 BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
72732 BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
72733 >(
72734 (value,),
72735 0x58f07c8788d099a0,
72736 fidl::encoding::DynamicFlags::empty(),
72737 _decode,
72738 )
72739 }
72740
72741 type GetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
72742 BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
72743 fidl::encoding::DefaultFuchsiaResourceDialect,
72744 >;
72745 fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut {
72746 fn _decode(
72747 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72748 ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
72749 let _response = fidl::client::decode_transaction_body::<
72750 fidl::encoding::ResultType<
72751 BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
72752 fidl_fuchsia_posix::Errno,
72753 >,
72754 fidl::encoding::DefaultFuchsiaResourceDialect,
72755 0x2e334df1da553ffa,
72756 >(_buf?)?;
72757 Ok(_response.map(|x| x.value))
72758 }
72759 self.client.send_query_and_decode::<
72760 fidl::encoding::EmptyPayload,
72761 BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
72762 >(
72763 (),
72764 0x2e334df1da553ffa,
72765 fidl::encoding::DynamicFlags::empty(),
72766 _decode,
72767 )
72768 }
72769
72770 type SetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
72771 BaseNetworkSocketSetIpv6TrafficClassResult,
72772 fidl::encoding::DefaultFuchsiaResourceDialect,
72773 >;
72774 fn r#set_ipv6_traffic_class(
72775 &self,
72776 mut value: &OptionalUint8,
72777 ) -> Self::SetIpv6TrafficClassResponseFut {
72778 fn _decode(
72779 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72780 ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
72781 let _response = fidl::client::decode_transaction_body::<
72782 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72783 fidl::encoding::DefaultFuchsiaResourceDialect,
72784 0x6af077800c5a0b4f,
72785 >(_buf?)?;
72786 Ok(_response.map(|x| x))
72787 }
72788 self.client.send_query_and_decode::<
72789 BaseNetworkSocketSetIpv6TrafficClassRequest,
72790 BaseNetworkSocketSetIpv6TrafficClassResult,
72791 >(
72792 (value,),
72793 0x6af077800c5a0b4f,
72794 fidl::encoding::DynamicFlags::empty(),
72795 _decode,
72796 )
72797 }
72798
72799 type GetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
72800 BaseNetworkSocketGetIpv6TrafficClassResult,
72801 fidl::encoding::DefaultFuchsiaResourceDialect,
72802 >;
72803 fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut {
72804 fn _decode(
72805 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72806 ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
72807 let _response = fidl::client::decode_transaction_body::<
72808 fidl::encoding::ResultType<
72809 BaseNetworkSocketGetIpv6TrafficClassResponse,
72810 fidl_fuchsia_posix::Errno,
72811 >,
72812 fidl::encoding::DefaultFuchsiaResourceDialect,
72813 0x6baf6eed8fc2f04,
72814 >(_buf?)?;
72815 Ok(_response.map(|x| x.value))
72816 }
72817 self.client.send_query_and_decode::<
72818 fidl::encoding::EmptyPayload,
72819 BaseNetworkSocketGetIpv6TrafficClassResult,
72820 >(
72821 (),
72822 0x6baf6eed8fc2f04,
72823 fidl::encoding::DynamicFlags::empty(),
72824 _decode,
72825 )
72826 }
72827
72828 type SetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
72829 BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
72830 fidl::encoding::DefaultFuchsiaResourceDialect,
72831 >;
72832 fn r#set_ipv6_receive_packet_info(
72833 &self,
72834 mut value: bool,
72835 ) -> Self::SetIpv6ReceivePacketInfoResponseFut {
72836 fn _decode(
72837 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72838 ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
72839 let _response = fidl::client::decode_transaction_body::<
72840 fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72841 fidl::encoding::DefaultFuchsiaResourceDialect,
72842 0x19259775b1a92768,
72843 >(_buf?)?;
72844 Ok(_response.map(|x| x))
72845 }
72846 self.client.send_query_and_decode::<
72847 BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
72848 BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
72849 >(
72850 (value,),
72851 0x19259775b1a92768,
72852 fidl::encoding::DynamicFlags::empty(),
72853 _decode,
72854 )
72855 }
72856
72857 type GetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
72858 BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
72859 fidl::encoding::DefaultFuchsiaResourceDialect,
72860 >;
72861 fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut {
72862 fn _decode(
72863 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72864 ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
72865 let _response = fidl::client::decode_transaction_body::<
72866 fidl::encoding::ResultType<
72867 BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
72868 fidl_fuchsia_posix::Errno,
72869 >,
72870 fidl::encoding::DefaultFuchsiaResourceDialect,
72871 0x7acd4a2775baec75,
72872 >(_buf?)?;
72873 Ok(_response.map(|x| x.value))
72874 }
72875 self.client.send_query_and_decode::<
72876 fidl::encoding::EmptyPayload,
72877 BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
72878 >(
72879 (),
72880 0x7acd4a2775baec75,
72881 fidl::encoding::DynamicFlags::empty(),
72882 _decode,
72883 )
72884 }
72885
72886 type GetOriginalDestinationResponseFut = fidl::client::QueryResponseFut<
72887 BaseNetworkSocketGetOriginalDestinationResult,
72888 fidl::encoding::DefaultFuchsiaResourceDialect,
72889 >;
72890 fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut {
72891 fn _decode(
72892 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72893 ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
72894 let _response = fidl::client::decode_transaction_body::<
72895 fidl::encoding::ResultType<
72896 BaseNetworkSocketGetOriginalDestinationResponse,
72897 fidl_fuchsia_posix::Errno,
72898 >,
72899 fidl::encoding::DefaultFuchsiaResourceDialect,
72900 0x38bf28f0dafdbac0,
72901 >(_buf?)?;
72902 Ok(_response.map(|x| x.value))
72903 }
72904 self.client.send_query_and_decode::<
72905 fidl::encoding::EmptyPayload,
72906 BaseNetworkSocketGetOriginalDestinationResult,
72907 >(
72908 (),
72909 0x38bf28f0dafdbac0,
72910 fidl::encoding::DynamicFlags::empty(),
72911 _decode,
72912 )
72913 }
72914
72915 type GetInfoResponseFut = fidl::client::QueryResponseFut<
72916 BaseDatagramSocketGetInfoResult,
72917 fidl::encoding::DefaultFuchsiaResourceDialect,
72918 >;
72919 fn r#get_info(&self) -> Self::GetInfoResponseFut {
72920 fn _decode(
72921 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72922 ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
72923 let _response = fidl::client::decode_transaction_body::<
72924 fidl::encoding::ResultType<
72925 BaseDatagramSocketGetInfoResponse,
72926 fidl_fuchsia_posix::Errno,
72927 >,
72928 fidl::encoding::DefaultFuchsiaResourceDialect,
72929 0x48aa0a1f6a32d2ed,
72930 >(_buf?)?;
72931 Ok(_response.map(|x| (x.domain, x.proto)))
72932 }
72933 self.client
72934 .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseDatagramSocketGetInfoResult>(
72935 (),
72936 0x48aa0a1f6a32d2ed,
72937 fidl::encoding::DynamicFlags::empty(),
72938 _decode,
72939 )
72940 }
72941
72942 type DescribeResponseFut = fidl::client::QueryResponseFut<
72943 SynchronousDatagramSocketDescribeResponse,
72944 fidl::encoding::DefaultFuchsiaResourceDialect,
72945 >;
72946 fn r#describe(&self) -> Self::DescribeResponseFut {
72947 fn _decode(
72948 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72949 ) -> Result<SynchronousDatagramSocketDescribeResponse, fidl::Error> {
72950 let _response = fidl::client::decode_transaction_body::<
72951 SynchronousDatagramSocketDescribeResponse,
72952 fidl::encoding::DefaultFuchsiaResourceDialect,
72953 0x585f20b73631070d,
72954 >(_buf?)?;
72955 Ok(_response)
72956 }
72957 self.client.send_query_and_decode::<
72958 fidl::encoding::EmptyPayload,
72959 SynchronousDatagramSocketDescribeResponse,
72960 >(
72961 (),
72962 0x585f20b73631070d,
72963 fidl::encoding::DynamicFlags::empty(),
72964 _decode,
72965 )
72966 }
72967
72968 type RecvMsgResponseFut = fidl::client::QueryResponseFut<
72969 SynchronousDatagramSocketRecvMsgResult,
72970 fidl::encoding::DefaultFuchsiaResourceDialect,
72971 >;
72972 fn r#recv_msg(
72973 &self,
72974 mut want_addr: bool,
72975 mut data_len: u32,
72976 mut want_control: bool,
72977 mut flags: RecvMsgFlags,
72978 ) -> Self::RecvMsgResponseFut {
72979 fn _decode(
72980 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72981 ) -> Result<SynchronousDatagramSocketRecvMsgResult, fidl::Error> {
72982 let _response = fidl::client::decode_transaction_body::<
72983 fidl::encoding::ResultType<
72984 SynchronousDatagramSocketRecvMsgResponse,
72985 fidl_fuchsia_posix::Errno,
72986 >,
72987 fidl::encoding::DefaultFuchsiaResourceDialect,
72988 0x28e494e48fb5dbf3,
72989 >(_buf?)?;
72990 Ok(_response.map(|x| (x.addr, x.data, x.control, x.truncated)))
72991 }
72992 self.client.send_query_and_decode::<
72993 SynchronousDatagramSocketRecvMsgRequest,
72994 SynchronousDatagramSocketRecvMsgResult,
72995 >(
72996 (want_addr, data_len, want_control, flags,),
72997 0x28e494e48fb5dbf3,
72998 fidl::encoding::DynamicFlags::empty(),
72999 _decode,
73000 )
73001 }
73002
73003 type SendMsgResponseFut = fidl::client::QueryResponseFut<
73004 SynchronousDatagramSocketSendMsgResult,
73005 fidl::encoding::DefaultFuchsiaResourceDialect,
73006 >;
73007 fn r#send_msg(
73008 &self,
73009 mut addr: Option<&fidl_fuchsia_net::SocketAddress>,
73010 mut data: &[u8],
73011 mut control: &DatagramSocketSendControlData,
73012 mut flags: SendMsgFlags,
73013 ) -> Self::SendMsgResponseFut {
73014 fn _decode(
73015 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
73016 ) -> Result<SynchronousDatagramSocketSendMsgResult, fidl::Error> {
73017 let _response = fidl::client::decode_transaction_body::<
73018 fidl::encoding::ResultType<
73019 SynchronousDatagramSocketSendMsgResponse,
73020 fidl_fuchsia_posix::Errno,
73021 >,
73022 fidl::encoding::DefaultFuchsiaResourceDialect,
73023 0x12dc2fceab6cefaa,
73024 >(_buf?)?;
73025 Ok(_response.map(|x| x.len))
73026 }
73027 self.client.send_query_and_decode::<
73028 SynchronousDatagramSocketSendMsgRequest,
73029 SynchronousDatagramSocketSendMsgResult,
73030 >(
73031 (addr, data, control, flags,),
73032 0x12dc2fceab6cefaa,
73033 fidl::encoding::DynamicFlags::empty(),
73034 _decode,
73035 )
73036 }
73037}
73038
73039pub struct SynchronousDatagramSocketEventStream {
73040 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
73041}
73042
73043impl std::marker::Unpin for SynchronousDatagramSocketEventStream {}
73044
73045impl futures::stream::FusedStream for SynchronousDatagramSocketEventStream {
73046 fn is_terminated(&self) -> bool {
73047 self.event_receiver.is_terminated()
73048 }
73049}
73050
73051impl futures::Stream for SynchronousDatagramSocketEventStream {
73052 type Item = Result<SynchronousDatagramSocketEvent, fidl::Error>;
73053
73054 fn poll_next(
73055 mut self: std::pin::Pin<&mut Self>,
73056 cx: &mut std::task::Context<'_>,
73057 ) -> std::task::Poll<Option<Self::Item>> {
73058 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
73059 &mut self.event_receiver,
73060 cx
73061 )?) {
73062 Some(buf) => std::task::Poll::Ready(Some(SynchronousDatagramSocketEvent::decode(buf))),
73063 None => std::task::Poll::Ready(None),
73064 }
73065 }
73066}
73067
73068#[derive(Debug)]
73069pub enum SynchronousDatagramSocketEvent {}
73070
73071impl SynchronousDatagramSocketEvent {
73072 fn decode(
73074 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
73075 ) -> Result<SynchronousDatagramSocketEvent, fidl::Error> {
73076 let (bytes, _handles) = buf.split_mut();
73077 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
73078 debug_assert_eq!(tx_header.tx_id, 0);
73079 match tx_header.ordinal {
73080 _ => Err(fidl::Error::UnknownOrdinal {
73081 ordinal: tx_header.ordinal,
73082 protocol_name:
73083 <SynchronousDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
73084 }),
73085 }
73086 }
73087}
73088
73089pub struct SynchronousDatagramSocketRequestStream {
73091 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
73092 is_terminated: bool,
73093}
73094
73095impl std::marker::Unpin for SynchronousDatagramSocketRequestStream {}
73096
73097impl futures::stream::FusedStream for SynchronousDatagramSocketRequestStream {
73098 fn is_terminated(&self) -> bool {
73099 self.is_terminated
73100 }
73101}
73102
73103impl fidl::endpoints::RequestStream for SynchronousDatagramSocketRequestStream {
73104 type Protocol = SynchronousDatagramSocketMarker;
73105 type ControlHandle = SynchronousDatagramSocketControlHandle;
73106
73107 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
73108 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
73109 }
73110
73111 fn control_handle(&self) -> Self::ControlHandle {
73112 SynchronousDatagramSocketControlHandle { inner: self.inner.clone() }
73113 }
73114
73115 fn into_inner(
73116 self,
73117 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
73118 {
73119 (self.inner, self.is_terminated)
73120 }
73121
73122 fn from_inner(
73123 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
73124 is_terminated: bool,
73125 ) -> Self {
73126 Self { inner, is_terminated }
73127 }
73128}
73129
73130impl futures::Stream for SynchronousDatagramSocketRequestStream {
73131 type Item = Result<SynchronousDatagramSocketRequest, fidl::Error>;
73132
73133 fn poll_next(
73134 mut self: std::pin::Pin<&mut Self>,
73135 cx: &mut std::task::Context<'_>,
73136 ) -> std::task::Poll<Option<Self::Item>> {
73137 let this = &mut *self;
73138 if this.inner.check_shutdown(cx) {
73139 this.is_terminated = true;
73140 return std::task::Poll::Ready(None);
73141 }
73142 if this.is_terminated {
73143 panic!("polled SynchronousDatagramSocketRequestStream after completion");
73144 }
73145 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
73146 |bytes, handles| {
73147 match this.inner.channel().read_etc(cx, bytes, handles) {
73148 std::task::Poll::Ready(Ok(())) => {}
73149 std::task::Poll::Pending => return std::task::Poll::Pending,
73150 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
73151 this.is_terminated = true;
73152 return std::task::Poll::Ready(None);
73153 }
73154 std::task::Poll::Ready(Err(e)) => {
73155 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
73156 e.into(),
73157 ))))
73158 }
73159 }
73160
73161 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
73163
73164 std::task::Poll::Ready(Some(match header.ordinal {
73165 0x20d8a7aba2168a79 => {
73166 header.validate_request_tx_id(fidl::MethodType::OneWay)?;
73167 let mut req = fidl::new_empty!(fidl_fuchsia_unknown::CloneableCloneRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73168 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
73169 let control_handle = SynchronousDatagramSocketControlHandle {
73170 inner: this.inner.clone(),
73171 };
73172 Ok(SynchronousDatagramSocketRequest::Clone {request: req.request,
73173
73174 control_handle,
73175 })
73176 }
73177 0x5ac5d459ad7f657e => {
73178 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73179 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73180 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73181 let control_handle = SynchronousDatagramSocketControlHandle {
73182 inner: this.inner.clone(),
73183 };
73184 Ok(SynchronousDatagramSocketRequest::Close {
73185 responder: SynchronousDatagramSocketCloseResponder {
73186 control_handle: std::mem::ManuallyDrop::new(control_handle),
73187 tx_id: header.tx_id,
73188 },
73189 })
73190 }
73191 0x2658edee9decfc06 => {
73192 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73193 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73194 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73195 let control_handle = SynchronousDatagramSocketControlHandle {
73196 inner: this.inner.clone(),
73197 };
73198 Ok(SynchronousDatagramSocketRequest::Query {
73199 responder: SynchronousDatagramSocketQueryResponder {
73200 control_handle: std::mem::ManuallyDrop::new(control_handle),
73201 tx_id: header.tx_id,
73202 },
73203 })
73204 }
73205 0x1fd74ee8b9a4a876 => {
73206 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73207 let mut req = fidl::new_empty!(BaseSocketSetReuseAddressRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73208 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
73209 let control_handle = SynchronousDatagramSocketControlHandle {
73210 inner: this.inner.clone(),
73211 };
73212 Ok(SynchronousDatagramSocketRequest::SetReuseAddress {value: req.value,
73213
73214 responder: SynchronousDatagramSocketSetReuseAddressResponder {
73215 control_handle: std::mem::ManuallyDrop::new(control_handle),
73216 tx_id: header.tx_id,
73217 },
73218 })
73219 }
73220 0x67b7206b8d1bc0a5 => {
73221 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73222 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73223 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73224 let control_handle = SynchronousDatagramSocketControlHandle {
73225 inner: this.inner.clone(),
73226 };
73227 Ok(SynchronousDatagramSocketRequest::GetReuseAddress {
73228 responder: SynchronousDatagramSocketGetReuseAddressResponder {
73229 control_handle: std::mem::ManuallyDrop::new(control_handle),
73230 tx_id: header.tx_id,
73231 },
73232 })
73233 }
73234 0x5aad39b33e5f6ebb => {
73235 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73236 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73237 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73238 let control_handle = SynchronousDatagramSocketControlHandle {
73239 inner: this.inner.clone(),
73240 };
73241 Ok(SynchronousDatagramSocketRequest::GetError {
73242 responder: SynchronousDatagramSocketGetErrorResponder {
73243 control_handle: std::mem::ManuallyDrop::new(control_handle),
73244 tx_id: header.tx_id,
73245 },
73246 })
73247 }
73248 0x6023e081ce3cd947 => {
73249 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73250 let mut req = fidl::new_empty!(BaseSocketSetBroadcastRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73251 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
73252 let control_handle = SynchronousDatagramSocketControlHandle {
73253 inner: this.inner.clone(),
73254 };
73255 Ok(SynchronousDatagramSocketRequest::SetBroadcast {value: req.value,
73256
73257 responder: SynchronousDatagramSocketSetBroadcastResponder {
73258 control_handle: std::mem::ManuallyDrop::new(control_handle),
73259 tx_id: header.tx_id,
73260 },
73261 })
73262 }
73263 0x68796fc556f9780d => {
73264 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73265 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73266 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73267 let control_handle = SynchronousDatagramSocketControlHandle {
73268 inner: this.inner.clone(),
73269 };
73270 Ok(SynchronousDatagramSocketRequest::GetBroadcast {
73271 responder: SynchronousDatagramSocketGetBroadcastResponder {
73272 control_handle: std::mem::ManuallyDrop::new(control_handle),
73273 tx_id: header.tx_id,
73274 },
73275 })
73276 }
73277 0x756eac32d73a7a70 => {
73278 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73279 let mut req = fidl::new_empty!(BaseSocketSetSendBufferRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73280 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
73281 let control_handle = SynchronousDatagramSocketControlHandle {
73282 inner: this.inner.clone(),
73283 };
73284 Ok(SynchronousDatagramSocketRequest::SetSendBuffer {value_bytes: req.value_bytes,
73285
73286 responder: SynchronousDatagramSocketSetSendBufferResponder {
73287 control_handle: std::mem::ManuallyDrop::new(control_handle),
73288 tx_id: header.tx_id,
73289 },
73290 })
73291 }
73292 0x78a52fd9c7b2410b => {
73293 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73294 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73295 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73296 let control_handle = SynchronousDatagramSocketControlHandle {
73297 inner: this.inner.clone(),
73298 };
73299 Ok(SynchronousDatagramSocketRequest::GetSendBuffer {
73300 responder: SynchronousDatagramSocketGetSendBufferResponder {
73301 control_handle: std::mem::ManuallyDrop::new(control_handle),
73302 tx_id: header.tx_id,
73303 },
73304 })
73305 }
73306 0x6b0cf2f1919c7001 => {
73307 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73308 let mut req = fidl::new_empty!(BaseSocketSetReceiveBufferRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73309 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
73310 let control_handle = SynchronousDatagramSocketControlHandle {
73311 inner: this.inner.clone(),
73312 };
73313 Ok(SynchronousDatagramSocketRequest::SetReceiveBuffer {value_bytes: req.value_bytes,
73314
73315 responder: SynchronousDatagramSocketSetReceiveBufferResponder {
73316 control_handle: std::mem::ManuallyDrop::new(control_handle),
73317 tx_id: header.tx_id,
73318 },
73319 })
73320 }
73321 0x14c1a4b64f709e5c => {
73322 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73323 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73324 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73325 let control_handle = SynchronousDatagramSocketControlHandle {
73326 inner: this.inner.clone(),
73327 };
73328 Ok(SynchronousDatagramSocketRequest::GetReceiveBuffer {
73329 responder: SynchronousDatagramSocketGetReceiveBufferResponder {
73330 control_handle: std::mem::ManuallyDrop::new(control_handle),
73331 tx_id: header.tx_id,
73332 },
73333 })
73334 }
73335 0x572df8f0b920d2c7 => {
73336 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73337 let mut req = fidl::new_empty!(BaseSocketSetKeepAliveRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73338 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
73339 let control_handle = SynchronousDatagramSocketControlHandle {
73340 inner: this.inner.clone(),
73341 };
73342 Ok(SynchronousDatagramSocketRequest::SetKeepAlive {value: req.value,
73343
73344 responder: SynchronousDatagramSocketSetKeepAliveResponder {
73345 control_handle: std::mem::ManuallyDrop::new(control_handle),
73346 tx_id: header.tx_id,
73347 },
73348 })
73349 }
73350 0x2dd29d3215f2c9d2 => {
73351 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73352 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73353 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73354 let control_handle = SynchronousDatagramSocketControlHandle {
73355 inner: this.inner.clone(),
73356 };
73357 Ok(SynchronousDatagramSocketRequest::GetKeepAlive {
73358 responder: SynchronousDatagramSocketGetKeepAliveResponder {
73359 control_handle: std::mem::ManuallyDrop::new(control_handle),
73360 tx_id: header.tx_id,
73361 },
73362 })
73363 }
73364 0x3ecb49968bee439 => {
73365 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73366 let mut req = fidl::new_empty!(BaseSocketSetOutOfBandInlineRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73367 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
73368 let control_handle = SynchronousDatagramSocketControlHandle {
73369 inner: this.inner.clone(),
73370 };
73371 Ok(SynchronousDatagramSocketRequest::SetOutOfBandInline {value: req.value,
73372
73373 responder: SynchronousDatagramSocketSetOutOfBandInlineResponder {
73374 control_handle: std::mem::ManuallyDrop::new(control_handle),
73375 tx_id: header.tx_id,
73376 },
73377 })
73378 }
73379 0x348c1ab3aeca1745 => {
73380 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73381 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73382 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73383 let control_handle = SynchronousDatagramSocketControlHandle {
73384 inner: this.inner.clone(),
73385 };
73386 Ok(SynchronousDatagramSocketRequest::GetOutOfBandInline {
73387 responder: SynchronousDatagramSocketGetOutOfBandInlineResponder {
73388 control_handle: std::mem::ManuallyDrop::new(control_handle),
73389 tx_id: header.tx_id,
73390 },
73391 })
73392 }
73393 0x6bbf00c53a4c78c2 => {
73394 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73395 let mut req = fidl::new_empty!(BaseSocketSetNoCheckRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73396 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
73397 let control_handle = SynchronousDatagramSocketControlHandle {
73398 inner: this.inner.clone(),
73399 };
73400 Ok(SynchronousDatagramSocketRequest::SetNoCheck {value: req.value,
73401
73402 responder: SynchronousDatagramSocketSetNoCheckResponder {
73403 control_handle: std::mem::ManuallyDrop::new(control_handle),
73404 tx_id: header.tx_id,
73405 },
73406 })
73407 }
73408 0x2cd4249286417694 => {
73409 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73410 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73411 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73412 let control_handle = SynchronousDatagramSocketControlHandle {
73413 inner: this.inner.clone(),
73414 };
73415 Ok(SynchronousDatagramSocketRequest::GetNoCheck {
73416 responder: SynchronousDatagramSocketGetNoCheckResponder {
73417 control_handle: std::mem::ManuallyDrop::new(control_handle),
73418 tx_id: header.tx_id,
73419 },
73420 })
73421 }
73422 0x45386351246e998e => {
73423 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73424 let mut req = fidl::new_empty!(BaseSocketSetLingerRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73425 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
73426 let control_handle = SynchronousDatagramSocketControlHandle {
73427 inner: this.inner.clone(),
73428 };
73429 Ok(SynchronousDatagramSocketRequest::SetLinger {linger: req.linger,
73430length_secs: req.length_secs,
73431
73432 responder: SynchronousDatagramSocketSetLingerResponder {
73433 control_handle: std::mem::ManuallyDrop::new(control_handle),
73434 tx_id: header.tx_id,
73435 },
73436 })
73437 }
73438 0x48eb20fc5ccb0e45 => {
73439 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73440 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73441 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73442 let control_handle = SynchronousDatagramSocketControlHandle {
73443 inner: this.inner.clone(),
73444 };
73445 Ok(SynchronousDatagramSocketRequest::GetLinger {
73446 responder: SynchronousDatagramSocketGetLingerResponder {
73447 control_handle: std::mem::ManuallyDrop::new(control_handle),
73448 tx_id: header.tx_id,
73449 },
73450 })
73451 }
73452 0x24dd3e5cb36d9ccb => {
73453 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73454 let mut req = fidl::new_empty!(BaseSocketSetReusePortRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73455 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
73456 let control_handle = SynchronousDatagramSocketControlHandle {
73457 inner: this.inner.clone(),
73458 };
73459 Ok(SynchronousDatagramSocketRequest::SetReusePort {value: req.value,
73460
73461 responder: SynchronousDatagramSocketSetReusePortResponder {
73462 control_handle: std::mem::ManuallyDrop::new(control_handle),
73463 tx_id: header.tx_id,
73464 },
73465 })
73466 }
73467 0x7a112c1ab54ff828 => {
73468 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73469 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73470 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73471 let control_handle = SynchronousDatagramSocketControlHandle {
73472 inner: this.inner.clone(),
73473 };
73474 Ok(SynchronousDatagramSocketRequest::GetReusePort {
73475 responder: SynchronousDatagramSocketGetReusePortResponder {
73476 control_handle: std::mem::ManuallyDrop::new(control_handle),
73477 tx_id: header.tx_id,
73478 },
73479 })
73480 }
73481 0x67ce6db6c2ec8966 => {
73482 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73483 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73484 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73485 let control_handle = SynchronousDatagramSocketControlHandle {
73486 inner: this.inner.clone(),
73487 };
73488 Ok(SynchronousDatagramSocketRequest::GetAcceptConn {
73489 responder: SynchronousDatagramSocketGetAcceptConnResponder {
73490 control_handle: std::mem::ManuallyDrop::new(control_handle),
73491 tx_id: header.tx_id,
73492 },
73493 })
73494 }
73495 0x2118b483f28aafc4 => {
73496 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73497 let mut req = fidl::new_empty!(BaseSocketSetBindToDeviceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73498 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
73499 let control_handle = SynchronousDatagramSocketControlHandle {
73500 inner: this.inner.clone(),
73501 };
73502 Ok(SynchronousDatagramSocketRequest::SetBindToDevice {value: req.value,
73503
73504 responder: SynchronousDatagramSocketSetBindToDeviceResponder {
73505 control_handle: std::mem::ManuallyDrop::new(control_handle),
73506 tx_id: header.tx_id,
73507 },
73508 })
73509 }
73510 0x1ab1fbf0ef7906c8 => {
73511 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73512 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73513 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73514 let control_handle = SynchronousDatagramSocketControlHandle {
73515 inner: this.inner.clone(),
73516 };
73517 Ok(SynchronousDatagramSocketRequest::GetBindToDevice {
73518 responder: SynchronousDatagramSocketGetBindToDeviceResponder {
73519 control_handle: std::mem::ManuallyDrop::new(control_handle),
73520 tx_id: header.tx_id,
73521 },
73522 })
73523 }
73524 0x6e387a0def00821 => {
73525 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73526 let mut req = fidl::new_empty!(BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73527 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
73528 let control_handle = SynchronousDatagramSocketControlHandle {
73529 inner: this.inner.clone(),
73530 };
73531 Ok(SynchronousDatagramSocketRequest::SetBindToInterfaceIndex {value: req.value,
73532
73533 responder: SynchronousDatagramSocketSetBindToInterfaceIndexResponder {
73534 control_handle: std::mem::ManuallyDrop::new(control_handle),
73535 tx_id: header.tx_id,
73536 },
73537 })
73538 }
73539 0x59c31dd3e3078295 => {
73540 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73541 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73542 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73543 let control_handle = SynchronousDatagramSocketControlHandle {
73544 inner: this.inner.clone(),
73545 };
73546 Ok(SynchronousDatagramSocketRequest::GetBindToInterfaceIndex {
73547 responder: SynchronousDatagramSocketGetBindToInterfaceIndexResponder {
73548 control_handle: std::mem::ManuallyDrop::new(control_handle),
73549 tx_id: header.tx_id,
73550 },
73551 })
73552 }
73553 0x285d6516c263d839 => {
73554 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73555 let mut req = fidl::new_empty!(BaseSocketSetTimestampRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73556 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
73557 let control_handle = SynchronousDatagramSocketControlHandle {
73558 inner: this.inner.clone(),
73559 };
73560 Ok(SynchronousDatagramSocketRequest::SetTimestamp {value: req.value,
73561
73562 responder: SynchronousDatagramSocketSetTimestampResponder {
73563 control_handle: std::mem::ManuallyDrop::new(control_handle),
73564 tx_id: header.tx_id,
73565 },
73566 })
73567 }
73568 0x49f2fffbbcc2bd27 => {
73569 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73570 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73571 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73572 let control_handle = SynchronousDatagramSocketControlHandle {
73573 inner: this.inner.clone(),
73574 };
73575 Ok(SynchronousDatagramSocketRequest::GetTimestamp {
73576 responder: SynchronousDatagramSocketGetTimestampResponder {
73577 control_handle: std::mem::ManuallyDrop::new(control_handle),
73578 tx_id: header.tx_id,
73579 },
73580 })
73581 }
73582 0x6ead6de09f653236 => {
73583 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73584 let mut req = fidl::new_empty!(BaseSocketSetMarkRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73585 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
73586 let control_handle = SynchronousDatagramSocketControlHandle {
73587 inner: this.inner.clone(),
73588 };
73589 Ok(SynchronousDatagramSocketRequest::SetMark {domain: req.domain,
73590mark: req.mark,
73591
73592 responder: SynchronousDatagramSocketSetMarkResponder {
73593 control_handle: std::mem::ManuallyDrop::new(control_handle),
73594 tx_id: header.tx_id,
73595 },
73596 })
73597 }
73598 0x57a2752c61d93d47 => {
73599 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73600 let mut req = fidl::new_empty!(BaseSocketGetMarkRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73601 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
73602 let control_handle = SynchronousDatagramSocketControlHandle {
73603 inner: this.inner.clone(),
73604 };
73605 Ok(SynchronousDatagramSocketRequest::GetMark {domain: req.domain,
73606
73607 responder: SynchronousDatagramSocketGetMarkResponder {
73608 control_handle: std::mem::ManuallyDrop::new(control_handle),
73609 tx_id: header.tx_id,
73610 },
73611 })
73612 }
73613 0x4bc6400ae92125d => {
73614 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73615 let mut req = fidl::new_empty!(BaseNetworkSocketBindRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73616 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
73617 let control_handle = SynchronousDatagramSocketControlHandle {
73618 inner: this.inner.clone(),
73619 };
73620 Ok(SynchronousDatagramSocketRequest::Bind {addr: req.addr,
73621
73622 responder: SynchronousDatagramSocketBindResponder {
73623 control_handle: std::mem::ManuallyDrop::new(control_handle),
73624 tx_id: header.tx_id,
73625 },
73626 })
73627 }
73628 0x5f05f19bfdd38871 => {
73629 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73630 let mut req = fidl::new_empty!(BaseNetworkSocketConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73631 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
73632 let control_handle = SynchronousDatagramSocketControlHandle {
73633 inner: this.inner.clone(),
73634 };
73635 Ok(SynchronousDatagramSocketRequest::Connect {addr: req.addr,
73636
73637 responder: SynchronousDatagramSocketConnectResponder {
73638 control_handle: std::mem::ManuallyDrop::new(control_handle),
73639 tx_id: header.tx_id,
73640 },
73641 })
73642 }
73643 0x74e63b91f7b29b2 => {
73644 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73645 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73646 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73647 let control_handle = SynchronousDatagramSocketControlHandle {
73648 inner: this.inner.clone(),
73649 };
73650 Ok(SynchronousDatagramSocketRequest::Disconnect {
73651 responder: SynchronousDatagramSocketDisconnectResponder {
73652 control_handle: std::mem::ManuallyDrop::new(control_handle),
73653 tx_id: header.tx_id,
73654 },
73655 })
73656 }
73657 0x475f23f84a1a4f85 => {
73658 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73659 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73660 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73661 let control_handle = SynchronousDatagramSocketControlHandle {
73662 inner: this.inner.clone(),
73663 };
73664 Ok(SynchronousDatagramSocketRequest::GetSockName {
73665 responder: SynchronousDatagramSocketGetSockNameResponder {
73666 control_handle: std::mem::ManuallyDrop::new(control_handle),
73667 tx_id: header.tx_id,
73668 },
73669 })
73670 }
73671 0x1ffecf4bd5b6432e => {
73672 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73673 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73674 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73675 let control_handle = SynchronousDatagramSocketControlHandle {
73676 inner: this.inner.clone(),
73677 };
73678 Ok(SynchronousDatagramSocketRequest::GetPeerName {
73679 responder: SynchronousDatagramSocketGetPeerNameResponder {
73680 control_handle: std::mem::ManuallyDrop::new(control_handle),
73681 tx_id: header.tx_id,
73682 },
73683 })
73684 }
73685 0x247f38b6db68c336 => {
73686 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73687 let mut req = fidl::new_empty!(BaseNetworkSocketShutdownRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73688 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketShutdownRequest>(&header, _body_bytes, handles, &mut req)?;
73689 let control_handle = SynchronousDatagramSocketControlHandle {
73690 inner: this.inner.clone(),
73691 };
73692 Ok(SynchronousDatagramSocketRequest::Shutdown {mode: req.mode,
73693
73694 responder: SynchronousDatagramSocketShutdownResponder {
73695 control_handle: std::mem::ManuallyDrop::new(control_handle),
73696 tx_id: header.tx_id,
73697 },
73698 })
73699 }
73700 0x995c600475b6d46 => {
73701 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73702 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTypeOfServiceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73703 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
73704 let control_handle = SynchronousDatagramSocketControlHandle {
73705 inner: this.inner.clone(),
73706 };
73707 Ok(SynchronousDatagramSocketRequest::SetIpTypeOfService {value: req.value,
73708
73709 responder: SynchronousDatagramSocketSetIpTypeOfServiceResponder {
73710 control_handle: std::mem::ManuallyDrop::new(control_handle),
73711 tx_id: header.tx_id,
73712 },
73713 })
73714 }
73715 0x3814a04259f75fcb => {
73716 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73717 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73718 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73719 let control_handle = SynchronousDatagramSocketControlHandle {
73720 inner: this.inner.clone(),
73721 };
73722 Ok(SynchronousDatagramSocketRequest::GetIpTypeOfService {
73723 responder: SynchronousDatagramSocketGetIpTypeOfServiceResponder {
73724 control_handle: std::mem::ManuallyDrop::new(control_handle),
73725 tx_id: header.tx_id,
73726 },
73727 })
73728 }
73729 0x29e2424b433ae1ef => {
73730 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73731 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73732 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTtlRequest>(&header, _body_bytes, handles, &mut req)?;
73733 let control_handle = SynchronousDatagramSocketControlHandle {
73734 inner: this.inner.clone(),
73735 };
73736 Ok(SynchronousDatagramSocketRequest::SetIpTtl {value: req.value,
73737
73738 responder: SynchronousDatagramSocketSetIpTtlResponder {
73739 control_handle: std::mem::ManuallyDrop::new(control_handle),
73740 tx_id: header.tx_id,
73741 },
73742 })
73743 }
73744 0x47e47fa1f24da471 => {
73745 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73746 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73747 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73748 let control_handle = SynchronousDatagramSocketControlHandle {
73749 inner: this.inner.clone(),
73750 };
73751 Ok(SynchronousDatagramSocketRequest::GetIpTtl {
73752 responder: SynchronousDatagramSocketGetIpTtlResponder {
73753 control_handle: std::mem::ManuallyDrop::new(control_handle),
73754 tx_id: header.tx_id,
73755 },
73756 })
73757 }
73758 0x392d16bee20c0e16 => {
73759 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73760 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73761 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpPacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
73762 let control_handle = SynchronousDatagramSocketControlHandle {
73763 inner: this.inner.clone(),
73764 };
73765 Ok(SynchronousDatagramSocketRequest::SetIpPacketInfo {value: req.value,
73766
73767 responder: SynchronousDatagramSocketSetIpPacketInfoResponder {
73768 control_handle: std::mem::ManuallyDrop::new(control_handle),
73769 tx_id: header.tx_id,
73770 },
73771 })
73772 }
73773 0x54b505f242280740 => {
73774 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73775 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73776 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73777 let control_handle = SynchronousDatagramSocketControlHandle {
73778 inner: this.inner.clone(),
73779 };
73780 Ok(SynchronousDatagramSocketRequest::GetIpPacketInfo {
73781 responder: SynchronousDatagramSocketGetIpPacketInfoResponder {
73782 control_handle: std::mem::ManuallyDrop::new(control_handle),
73783 tx_id: header.tx_id,
73784 },
73785 })
73786 }
73787 0x6c4f6714995f84ef => {
73788 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73789 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveTypeOfServiceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73790 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
73791 let control_handle = SynchronousDatagramSocketControlHandle {
73792 inner: this.inner.clone(),
73793 };
73794 Ok(SynchronousDatagramSocketRequest::SetIpReceiveTypeOfService {value: req.value,
73795
73796 responder: SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder {
73797 control_handle: std::mem::ManuallyDrop::new(control_handle),
73798 tx_id: header.tx_id,
73799 },
73800 })
73801 }
73802 0x4158ba7dc2795960 => {
73803 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73804 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73805 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73806 let control_handle = SynchronousDatagramSocketControlHandle {
73807 inner: this.inner.clone(),
73808 };
73809 Ok(SynchronousDatagramSocketRequest::GetIpReceiveTypeOfService {
73810 responder: SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder {
73811 control_handle: std::mem::ManuallyDrop::new(control_handle),
73812 tx_id: header.tx_id,
73813 },
73814 })
73815 }
73816 0x46f15be0ce0ab82b => {
73817 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73818 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73819 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTtlRequest>(&header, _body_bytes, handles, &mut req)?;
73820 let control_handle = SynchronousDatagramSocketControlHandle {
73821 inner: this.inner.clone(),
73822 };
73823 Ok(SynchronousDatagramSocketRequest::SetIpReceiveTtl {value: req.value,
73824
73825 responder: SynchronousDatagramSocketSetIpReceiveTtlResponder {
73826 control_handle: std::mem::ManuallyDrop::new(control_handle),
73827 tx_id: header.tx_id,
73828 },
73829 })
73830 }
73831 0x678ddd5a5dfa2eb5 => {
73832 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73833 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73834 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73835 let control_handle = SynchronousDatagramSocketControlHandle {
73836 inner: this.inner.clone(),
73837 };
73838 Ok(SynchronousDatagramSocketRequest::GetIpReceiveTtl {
73839 responder: SynchronousDatagramSocketGetIpReceiveTtlResponder {
73840 control_handle: std::mem::ManuallyDrop::new(control_handle),
73841 tx_id: header.tx_id,
73842 },
73843 })
73844 }
73845 0x752fbfa9b12befe => {
73846 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73847 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastInterfaceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73848 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
73849 let control_handle = SynchronousDatagramSocketControlHandle {
73850 inner: this.inner.clone(),
73851 };
73852 Ok(SynchronousDatagramSocketRequest::SetIpMulticastInterface {iface: req.iface,
73853address: req.address,
73854
73855 responder: SynchronousDatagramSocketSetIpMulticastInterfaceResponder {
73856 control_handle: std::mem::ManuallyDrop::new(control_handle),
73857 tx_id: header.tx_id,
73858 },
73859 })
73860 }
73861 0x320bd14c4df046c4 => {
73862 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73863 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73864 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73865 let control_handle = SynchronousDatagramSocketControlHandle {
73866 inner: this.inner.clone(),
73867 };
73868 Ok(SynchronousDatagramSocketRequest::GetIpMulticastInterface {
73869 responder: SynchronousDatagramSocketGetIpMulticastInterfaceResponder {
73870 control_handle: std::mem::ManuallyDrop::new(control_handle),
73871 tx_id: header.tx_id,
73872 },
73873 })
73874 }
73875 0x63134d53772916a1 => {
73876 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73877 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73878 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastTtlRequest>(&header, _body_bytes, handles, &mut req)?;
73879 let control_handle = SynchronousDatagramSocketControlHandle {
73880 inner: this.inner.clone(),
73881 };
73882 Ok(SynchronousDatagramSocketRequest::SetIpMulticastTtl {value: req.value,
73883
73884 responder: SynchronousDatagramSocketSetIpMulticastTtlResponder {
73885 control_handle: std::mem::ManuallyDrop::new(control_handle),
73886 tx_id: header.tx_id,
73887 },
73888 })
73889 }
73890 0x4665cd378f39e1a => {
73891 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73892 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73893 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73894 let control_handle = SynchronousDatagramSocketControlHandle {
73895 inner: this.inner.clone(),
73896 };
73897 Ok(SynchronousDatagramSocketRequest::GetIpMulticastTtl {
73898 responder: SynchronousDatagramSocketGetIpMulticastTtlResponder {
73899 control_handle: std::mem::ManuallyDrop::new(control_handle),
73900 tx_id: header.tx_id,
73901 },
73902 })
73903 }
73904 0x20c55c11f00943ea => {
73905 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73906 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastLoopbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73907 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
73908 let control_handle = SynchronousDatagramSocketControlHandle {
73909 inner: this.inner.clone(),
73910 };
73911 Ok(SynchronousDatagramSocketRequest::SetIpMulticastLoopback {value: req.value,
73912
73913 responder: SynchronousDatagramSocketSetIpMulticastLoopbackResponder {
73914 control_handle: std::mem::ManuallyDrop::new(control_handle),
73915 tx_id: header.tx_id,
73916 },
73917 })
73918 }
73919 0x3b6b26ff558298f2 => {
73920 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73921 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73922 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73923 let control_handle = SynchronousDatagramSocketControlHandle {
73924 inner: this.inner.clone(),
73925 };
73926 Ok(SynchronousDatagramSocketRequest::GetIpMulticastLoopback {
73927 responder: SynchronousDatagramSocketGetIpMulticastLoopbackResponder {
73928 control_handle: std::mem::ManuallyDrop::new(control_handle),
73929 tx_id: header.tx_id,
73930 },
73931 })
73932 }
73933 0x76bc7df115a3b4d0 => {
73934 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73935 let mut req = fidl::new_empty!(BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73936 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
73937 let control_handle = SynchronousDatagramSocketControlHandle {
73938 inner: this.inner.clone(),
73939 };
73940 Ok(SynchronousDatagramSocketRequest::AddIpMembership {membership: req.membership,
73941
73942 responder: SynchronousDatagramSocketAddIpMembershipResponder {
73943 control_handle: std::mem::ManuallyDrop::new(control_handle),
73944 tx_id: header.tx_id,
73945 },
73946 })
73947 }
73948 0x2888f3099188d03 => {
73949 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73950 let mut req = fidl::new_empty!(BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73951 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
73952 let control_handle = SynchronousDatagramSocketControlHandle {
73953 inner: this.inner.clone(),
73954 };
73955 Ok(SynchronousDatagramSocketRequest::DropIpMembership {membership: req.membership,
73956
73957 responder: SynchronousDatagramSocketDropIpMembershipResponder {
73958 control_handle: std::mem::ManuallyDrop::new(control_handle),
73959 tx_id: header.tx_id,
73960 },
73961 })
73962 }
73963 0x1ae532b0c066e3a0 => {
73964 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73965 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73966 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTransparentRequest>(&header, _body_bytes, handles, &mut req)?;
73967 let control_handle = SynchronousDatagramSocketControlHandle {
73968 inner: this.inner.clone(),
73969 };
73970 Ok(SynchronousDatagramSocketRequest::SetIpTransparent {value: req.value,
73971
73972 responder: SynchronousDatagramSocketSetIpTransparentResponder {
73973 control_handle: std::mem::ManuallyDrop::new(control_handle),
73974 tx_id: header.tx_id,
73975 },
73976 })
73977 }
73978 0x51d43695962ebfb5 => {
73979 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73980 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73981 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73982 let control_handle = SynchronousDatagramSocketControlHandle {
73983 inner: this.inner.clone(),
73984 };
73985 Ok(SynchronousDatagramSocketRequest::GetIpTransparent {
73986 responder: SynchronousDatagramSocketGetIpTransparentResponder {
73987 control_handle: std::mem::ManuallyDrop::new(control_handle),
73988 tx_id: header.tx_id,
73989 },
73990 })
73991 }
73992 0x4722b4ce52f7840 => {
73993 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73994 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73995 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest>(&header, _body_bytes, handles, &mut req)?;
73996 let control_handle = SynchronousDatagramSocketControlHandle {
73997 inner: this.inner.clone(),
73998 };
73999 Ok(SynchronousDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress {value: req.value,
74000
74001 responder: SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
74002 control_handle: std::mem::ManuallyDrop::new(control_handle),
74003 tx_id: header.tx_id,
74004 },
74005 })
74006 }
74007 0x2a0e7dc5d6bfdfe9 => {
74008 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74009 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74010 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74011 let control_handle = SynchronousDatagramSocketControlHandle {
74012 inner: this.inner.clone(),
74013 };
74014 Ok(SynchronousDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress {
74015 responder: SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
74016 control_handle: std::mem::ManuallyDrop::new(control_handle),
74017 tx_id: header.tx_id,
74018 },
74019 })
74020 }
74021 0x7c94727acb4ea4b3 => {
74022 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74023 let mut req = fidl::new_empty!(BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74024 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
74025 let control_handle = SynchronousDatagramSocketControlHandle {
74026 inner: this.inner.clone(),
74027 };
74028 Ok(SynchronousDatagramSocketRequest::AddIpv6Membership {membership: req.membership,
74029
74030 responder: SynchronousDatagramSocketAddIpv6MembershipResponder {
74031 control_handle: std::mem::ManuallyDrop::new(control_handle),
74032 tx_id: header.tx_id,
74033 },
74034 })
74035 }
74036 0x42104c70ccaba304 => {
74037 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74038 let mut req = fidl::new_empty!(BaseNetworkSocketDropIpv6MembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74039 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
74040 let control_handle = SynchronousDatagramSocketControlHandle {
74041 inner: this.inner.clone(),
74042 };
74043 Ok(SynchronousDatagramSocketRequest::DropIpv6Membership {membership: req.membership,
74044
74045 responder: SynchronousDatagramSocketDropIpv6MembershipResponder {
74046 control_handle: std::mem::ManuallyDrop::new(control_handle),
74047 tx_id: header.tx_id,
74048 },
74049 })
74050 }
74051 0x135f76db3774ab3b => {
74052 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74053 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastInterfaceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74054 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
74055 let control_handle = SynchronousDatagramSocketControlHandle {
74056 inner: this.inner.clone(),
74057 };
74058 Ok(SynchronousDatagramSocketRequest::SetIpv6MulticastInterface {value: req.value,
74059
74060 responder: SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder {
74061 control_handle: std::mem::ManuallyDrop::new(control_handle),
74062 tx_id: header.tx_id,
74063 },
74064 })
74065 }
74066 0x1f26fcdd348f1882 => {
74067 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74068 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74069 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74070 let control_handle = SynchronousDatagramSocketControlHandle {
74071 inner: this.inner.clone(),
74072 };
74073 Ok(SynchronousDatagramSocketRequest::GetIpv6MulticastInterface {
74074 responder: SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder {
74075 control_handle: std::mem::ManuallyDrop::new(control_handle),
74076 tx_id: header.tx_id,
74077 },
74078 })
74079 }
74080 0x157d51e98f462859 => {
74081 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74082 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6UnicastHopsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74083 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6UnicastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
74084 let control_handle = SynchronousDatagramSocketControlHandle {
74085 inner: this.inner.clone(),
74086 };
74087 Ok(SynchronousDatagramSocketRequest::SetIpv6UnicastHops {value: req.value,
74088
74089 responder: SynchronousDatagramSocketSetIpv6UnicastHopsResponder {
74090 control_handle: std::mem::ManuallyDrop::new(control_handle),
74091 tx_id: header.tx_id,
74092 },
74093 })
74094 }
74095 0x21f4641cad8bd8d2 => {
74096 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74097 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74098 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74099 let control_handle = SynchronousDatagramSocketControlHandle {
74100 inner: this.inner.clone(),
74101 };
74102 Ok(SynchronousDatagramSocketRequest::GetIpv6UnicastHops {
74103 responder: SynchronousDatagramSocketGetIpv6UnicastHopsResponder {
74104 control_handle: std::mem::ManuallyDrop::new(control_handle),
74105 tx_id: header.tx_id,
74106 },
74107 })
74108 }
74109 0x5c24808ed2e84a1e => {
74110 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74111 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceiveHopLimitRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74112 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveHopLimitRequest>(&header, _body_bytes, handles, &mut req)?;
74113 let control_handle = SynchronousDatagramSocketControlHandle {
74114 inner: this.inner.clone(),
74115 };
74116 Ok(SynchronousDatagramSocketRequest::SetIpv6ReceiveHopLimit {value: req.value,
74117
74118 responder: SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder {
74119 control_handle: std::mem::ManuallyDrop::new(control_handle),
74120 tx_id: header.tx_id,
74121 },
74122 })
74123 }
74124 0x341e06689885b4c0 => {
74125 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74126 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74127 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74128 let control_handle = SynchronousDatagramSocketControlHandle {
74129 inner: this.inner.clone(),
74130 };
74131 Ok(SynchronousDatagramSocketRequest::GetIpv6ReceiveHopLimit {
74132 responder: SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder {
74133 control_handle: std::mem::ManuallyDrop::new(control_handle),
74134 tx_id: header.tx_id,
74135 },
74136 })
74137 }
74138 0x25b9cd4d181f82c1 => {
74139 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74140 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastHopsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74141 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
74142 let control_handle = SynchronousDatagramSocketControlHandle {
74143 inner: this.inner.clone(),
74144 };
74145 Ok(SynchronousDatagramSocketRequest::SetIpv6MulticastHops {value: req.value,
74146
74147 responder: SynchronousDatagramSocketSetIpv6MulticastHopsResponder {
74148 control_handle: std::mem::ManuallyDrop::new(control_handle),
74149 tx_id: header.tx_id,
74150 },
74151 })
74152 }
74153 0x52916948a365012a => {
74154 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74155 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74156 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74157 let control_handle = SynchronousDatagramSocketControlHandle {
74158 inner: this.inner.clone(),
74159 };
74160 Ok(SynchronousDatagramSocketRequest::GetIpv6MulticastHops {
74161 responder: SynchronousDatagramSocketGetIpv6MulticastHopsResponder {
74162 control_handle: std::mem::ManuallyDrop::new(control_handle),
74163 tx_id: header.tx_id,
74164 },
74165 })
74166 }
74167 0x55701c409ff41b40 => {
74168 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74169 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastLoopbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74170 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
74171 let control_handle = SynchronousDatagramSocketControlHandle {
74172 inner: this.inner.clone(),
74173 };
74174 Ok(SynchronousDatagramSocketRequest::SetIpv6MulticastLoopback {value: req.value,
74175
74176 responder: SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder {
74177 control_handle: std::mem::ManuallyDrop::new(control_handle),
74178 tx_id: header.tx_id,
74179 },
74180 })
74181 }
74182 0x4415b701fde319c3 => {
74183 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74184 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74185 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74186 let control_handle = SynchronousDatagramSocketControlHandle {
74187 inner: this.inner.clone(),
74188 };
74189 Ok(SynchronousDatagramSocketRequest::GetIpv6MulticastLoopback {
74190 responder: SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder {
74191 control_handle: std::mem::ManuallyDrop::new(control_handle),
74192 tx_id: header.tx_id,
74193 },
74194 })
74195 }
74196 0x4873f1364758cbba => {
74197 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74198 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74199 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6OnlyRequest>(&header, _body_bytes, handles, &mut req)?;
74200 let control_handle = SynchronousDatagramSocketControlHandle {
74201 inner: this.inner.clone(),
74202 };
74203 Ok(SynchronousDatagramSocketRequest::SetIpv6Only {value: req.value,
74204
74205 responder: SynchronousDatagramSocketSetIpv6OnlyResponder {
74206 control_handle: std::mem::ManuallyDrop::new(control_handle),
74207 tx_id: header.tx_id,
74208 },
74209 })
74210 }
74211 0x4aa3340a1a26b89c => {
74212 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74213 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74214 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74215 let control_handle = SynchronousDatagramSocketControlHandle {
74216 inner: this.inner.clone(),
74217 };
74218 Ok(SynchronousDatagramSocketRequest::GetIpv6Only {
74219 responder: SynchronousDatagramSocketGetIpv6OnlyResponder {
74220 control_handle: std::mem::ManuallyDrop::new(control_handle),
74221 tx_id: header.tx_id,
74222 },
74223 })
74224 }
74225 0x58f07c8788d099a0 => {
74226 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74227 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74228 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
74229 let control_handle = SynchronousDatagramSocketControlHandle {
74230 inner: this.inner.clone(),
74231 };
74232 Ok(SynchronousDatagramSocketRequest::SetIpv6ReceiveTrafficClass {value: req.value,
74233
74234 responder: SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder {
74235 control_handle: std::mem::ManuallyDrop::new(control_handle),
74236 tx_id: header.tx_id,
74237 },
74238 })
74239 }
74240 0x2e334df1da553ffa => {
74241 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74242 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74243 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74244 let control_handle = SynchronousDatagramSocketControlHandle {
74245 inner: this.inner.clone(),
74246 };
74247 Ok(SynchronousDatagramSocketRequest::GetIpv6ReceiveTrafficClass {
74248 responder: SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder {
74249 control_handle: std::mem::ManuallyDrop::new(control_handle),
74250 tx_id: header.tx_id,
74251 },
74252 })
74253 }
74254 0x6af077800c5a0b4f => {
74255 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74256 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6TrafficClassRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74257 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6TrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
74258 let control_handle = SynchronousDatagramSocketControlHandle {
74259 inner: this.inner.clone(),
74260 };
74261 Ok(SynchronousDatagramSocketRequest::SetIpv6TrafficClass {value: req.value,
74262
74263 responder: SynchronousDatagramSocketSetIpv6TrafficClassResponder {
74264 control_handle: std::mem::ManuallyDrop::new(control_handle),
74265 tx_id: header.tx_id,
74266 },
74267 })
74268 }
74269 0x6baf6eed8fc2f04 => {
74270 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74271 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74272 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74273 let control_handle = SynchronousDatagramSocketControlHandle {
74274 inner: this.inner.clone(),
74275 };
74276 Ok(SynchronousDatagramSocketRequest::GetIpv6TrafficClass {
74277 responder: SynchronousDatagramSocketGetIpv6TrafficClassResponder {
74278 control_handle: std::mem::ManuallyDrop::new(control_handle),
74279 tx_id: header.tx_id,
74280 },
74281 })
74282 }
74283 0x19259775b1a92768 => {
74284 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74285 let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceivePacketInfoRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74286 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceivePacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
74287 let control_handle = SynchronousDatagramSocketControlHandle {
74288 inner: this.inner.clone(),
74289 };
74290 Ok(SynchronousDatagramSocketRequest::SetIpv6ReceivePacketInfo {value: req.value,
74291
74292 responder: SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder {
74293 control_handle: std::mem::ManuallyDrop::new(control_handle),
74294 tx_id: header.tx_id,
74295 },
74296 })
74297 }
74298 0x7acd4a2775baec75 => {
74299 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74300 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74301 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74302 let control_handle = SynchronousDatagramSocketControlHandle {
74303 inner: this.inner.clone(),
74304 };
74305 Ok(SynchronousDatagramSocketRequest::GetIpv6ReceivePacketInfo {
74306 responder: SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder {
74307 control_handle: std::mem::ManuallyDrop::new(control_handle),
74308 tx_id: header.tx_id,
74309 },
74310 })
74311 }
74312 0x38bf28f0dafdbac0 => {
74313 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74314 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74315 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74316 let control_handle = SynchronousDatagramSocketControlHandle {
74317 inner: this.inner.clone(),
74318 };
74319 Ok(SynchronousDatagramSocketRequest::GetOriginalDestination {
74320 responder: SynchronousDatagramSocketGetOriginalDestinationResponder {
74321 control_handle: std::mem::ManuallyDrop::new(control_handle),
74322 tx_id: header.tx_id,
74323 },
74324 })
74325 }
74326 0x48aa0a1f6a32d2ed => {
74327 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74328 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74329 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74330 let control_handle = SynchronousDatagramSocketControlHandle {
74331 inner: this.inner.clone(),
74332 };
74333 Ok(SynchronousDatagramSocketRequest::GetInfo {
74334 responder: SynchronousDatagramSocketGetInfoResponder {
74335 control_handle: std::mem::ManuallyDrop::new(control_handle),
74336 tx_id: header.tx_id,
74337 },
74338 })
74339 }
74340 0x585f20b73631070d => {
74341 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74342 let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74343 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74344 let control_handle = SynchronousDatagramSocketControlHandle {
74345 inner: this.inner.clone(),
74346 };
74347 Ok(SynchronousDatagramSocketRequest::Describe {
74348 responder: SynchronousDatagramSocketDescribeResponder {
74349 control_handle: std::mem::ManuallyDrop::new(control_handle),
74350 tx_id: header.tx_id,
74351 },
74352 })
74353 }
74354 0x28e494e48fb5dbf3 => {
74355 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74356 let mut req = fidl::new_empty!(SynchronousDatagramSocketRecvMsgRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74357 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SynchronousDatagramSocketRecvMsgRequest>(&header, _body_bytes, handles, &mut req)?;
74358 let control_handle = SynchronousDatagramSocketControlHandle {
74359 inner: this.inner.clone(),
74360 };
74361 Ok(SynchronousDatagramSocketRequest::RecvMsg {want_addr: req.want_addr,
74362data_len: req.data_len,
74363want_control: req.want_control,
74364flags: req.flags,
74365
74366 responder: SynchronousDatagramSocketRecvMsgResponder {
74367 control_handle: std::mem::ManuallyDrop::new(control_handle),
74368 tx_id: header.tx_id,
74369 },
74370 })
74371 }
74372 0x12dc2fceab6cefaa => {
74373 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74374 let mut req = fidl::new_empty!(SynchronousDatagramSocketSendMsgRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74375 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SynchronousDatagramSocketSendMsgRequest>(&header, _body_bytes, handles, &mut req)?;
74376 let control_handle = SynchronousDatagramSocketControlHandle {
74377 inner: this.inner.clone(),
74378 };
74379 Ok(SynchronousDatagramSocketRequest::SendMsg {addr: req.addr,
74380data: req.data,
74381control: req.control,
74382flags: req.flags,
74383
74384 responder: SynchronousDatagramSocketSendMsgResponder {
74385 control_handle: std::mem::ManuallyDrop::new(control_handle),
74386 tx_id: header.tx_id,
74387 },
74388 })
74389 }
74390 _ => Err(fidl::Error::UnknownOrdinal {
74391 ordinal: header.ordinal,
74392 protocol_name: <SynchronousDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
74393 }),
74394 }))
74395 },
74396 )
74397 }
74398}
74399
74400#[derive(Debug)]
74411pub enum SynchronousDatagramSocketRequest {
74412 Clone {
74413 request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
74414 control_handle: SynchronousDatagramSocketControlHandle,
74415 },
74416 Close {
74427 responder: SynchronousDatagramSocketCloseResponder,
74428 },
74429 Query {
74430 responder: SynchronousDatagramSocketQueryResponder,
74431 },
74432 SetReuseAddress {
74434 value: bool,
74435 responder: SynchronousDatagramSocketSetReuseAddressResponder,
74436 },
74437 GetReuseAddress {
74439 responder: SynchronousDatagramSocketGetReuseAddressResponder,
74440 },
74441 GetError {
74444 responder: SynchronousDatagramSocketGetErrorResponder,
74445 },
74446 SetBroadcast {
74448 value: bool,
74449 responder: SynchronousDatagramSocketSetBroadcastResponder,
74450 },
74451 GetBroadcast {
74453 responder: SynchronousDatagramSocketGetBroadcastResponder,
74454 },
74455 SetSendBuffer {
74457 value_bytes: u64,
74458 responder: SynchronousDatagramSocketSetSendBufferResponder,
74459 },
74460 GetSendBuffer {
74462 responder: SynchronousDatagramSocketGetSendBufferResponder,
74463 },
74464 SetReceiveBuffer {
74466 value_bytes: u64,
74467 responder: SynchronousDatagramSocketSetReceiveBufferResponder,
74468 },
74469 GetReceiveBuffer {
74471 responder: SynchronousDatagramSocketGetReceiveBufferResponder,
74472 },
74473 SetKeepAlive {
74475 value: bool,
74476 responder: SynchronousDatagramSocketSetKeepAliveResponder,
74477 },
74478 GetKeepAlive {
74480 responder: SynchronousDatagramSocketGetKeepAliveResponder,
74481 },
74482 SetOutOfBandInline {
74484 value: bool,
74485 responder: SynchronousDatagramSocketSetOutOfBandInlineResponder,
74486 },
74487 GetOutOfBandInline {
74489 responder: SynchronousDatagramSocketGetOutOfBandInlineResponder,
74490 },
74491 SetNoCheck {
74493 value: bool,
74494 responder: SynchronousDatagramSocketSetNoCheckResponder,
74495 },
74496 GetNoCheck {
74498 responder: SynchronousDatagramSocketGetNoCheckResponder,
74499 },
74500 SetLinger {
74502 linger: bool,
74503 length_secs: u32,
74504 responder: SynchronousDatagramSocketSetLingerResponder,
74505 },
74506 GetLinger {
74508 responder: SynchronousDatagramSocketGetLingerResponder,
74509 },
74510 SetReusePort {
74512 value: bool,
74513 responder: SynchronousDatagramSocketSetReusePortResponder,
74514 },
74515 GetReusePort {
74517 responder: SynchronousDatagramSocketGetReusePortResponder,
74518 },
74519 GetAcceptConn {
74521 responder: SynchronousDatagramSocketGetAcceptConnResponder,
74522 },
74523 SetBindToDevice {
74525 value: String,
74526 responder: SynchronousDatagramSocketSetBindToDeviceResponder,
74527 },
74528 GetBindToDevice {
74530 responder: SynchronousDatagramSocketGetBindToDeviceResponder,
74531 },
74532 SetBindToInterfaceIndex {
74535 value: u64,
74536 responder: SynchronousDatagramSocketSetBindToInterfaceIndexResponder,
74537 },
74538 GetBindToInterfaceIndex {
74540 responder: SynchronousDatagramSocketGetBindToInterfaceIndexResponder,
74541 },
74542 SetTimestamp {
74544 value: TimestampOption,
74545 responder: SynchronousDatagramSocketSetTimestampResponder,
74546 },
74547 GetTimestamp {
74549 responder: SynchronousDatagramSocketGetTimestampResponder,
74550 },
74551 SetMark {
74555 domain: fidl_fuchsia_net::MarkDomain,
74556 mark: OptionalUint32,
74557 responder: SynchronousDatagramSocketSetMarkResponder,
74558 },
74559 GetMark {
74563 domain: fidl_fuchsia_net::MarkDomain,
74564 responder: SynchronousDatagramSocketGetMarkResponder,
74565 },
74566 Bind {
74568 addr: fidl_fuchsia_net::SocketAddress,
74569 responder: SynchronousDatagramSocketBindResponder,
74570 },
74571 Connect {
74573 addr: fidl_fuchsia_net::SocketAddress,
74574 responder: SynchronousDatagramSocketConnectResponder,
74575 },
74576 Disconnect {
74578 responder: SynchronousDatagramSocketDisconnectResponder,
74579 },
74580 GetSockName {
74582 responder: SynchronousDatagramSocketGetSockNameResponder,
74583 },
74584 GetPeerName {
74586 responder: SynchronousDatagramSocketGetPeerNameResponder,
74587 },
74588 Shutdown {
74590 mode: ShutdownMode,
74591 responder: SynchronousDatagramSocketShutdownResponder,
74592 },
74593 SetIpTypeOfService {
74595 value: u8,
74596 responder: SynchronousDatagramSocketSetIpTypeOfServiceResponder,
74597 },
74598 GetIpTypeOfService {
74600 responder: SynchronousDatagramSocketGetIpTypeOfServiceResponder,
74601 },
74602 SetIpTtl {
74604 value: OptionalUint8,
74605 responder: SynchronousDatagramSocketSetIpTtlResponder,
74606 },
74607 GetIpTtl {
74609 responder: SynchronousDatagramSocketGetIpTtlResponder,
74610 },
74611 SetIpPacketInfo {
74613 value: bool,
74614 responder: SynchronousDatagramSocketSetIpPacketInfoResponder,
74615 },
74616 GetIpPacketInfo {
74618 responder: SynchronousDatagramSocketGetIpPacketInfoResponder,
74619 },
74620 SetIpReceiveTypeOfService {
74622 value: bool,
74623 responder: SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder,
74624 },
74625 GetIpReceiveTypeOfService {
74627 responder: SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder,
74628 },
74629 SetIpReceiveTtl {
74631 value: bool,
74632 responder: SynchronousDatagramSocketSetIpReceiveTtlResponder,
74633 },
74634 GetIpReceiveTtl {
74636 responder: SynchronousDatagramSocketGetIpReceiveTtlResponder,
74637 },
74638 SetIpMulticastInterface {
74640 iface: u64,
74641 address: fidl_fuchsia_net::Ipv4Address,
74642 responder: SynchronousDatagramSocketSetIpMulticastInterfaceResponder,
74643 },
74644 GetIpMulticastInterface {
74646 responder: SynchronousDatagramSocketGetIpMulticastInterfaceResponder,
74647 },
74648 SetIpMulticastTtl {
74650 value: OptionalUint8,
74651 responder: SynchronousDatagramSocketSetIpMulticastTtlResponder,
74652 },
74653 GetIpMulticastTtl {
74655 responder: SynchronousDatagramSocketGetIpMulticastTtlResponder,
74656 },
74657 SetIpMulticastLoopback {
74659 value: bool,
74660 responder: SynchronousDatagramSocketSetIpMulticastLoopbackResponder,
74661 },
74662 GetIpMulticastLoopback {
74664 responder: SynchronousDatagramSocketGetIpMulticastLoopbackResponder,
74665 },
74666 AddIpMembership {
74668 membership: IpMulticastMembership,
74669 responder: SynchronousDatagramSocketAddIpMembershipResponder,
74670 },
74671 DropIpMembership {
74673 membership: IpMulticastMembership,
74674 responder: SynchronousDatagramSocketDropIpMembershipResponder,
74675 },
74676 SetIpTransparent {
74678 value: bool,
74679 responder: SynchronousDatagramSocketSetIpTransparentResponder,
74680 },
74681 GetIpTransparent {
74683 responder: SynchronousDatagramSocketGetIpTransparentResponder,
74684 },
74685 SetIpReceiveOriginalDestinationAddress {
74687 value: bool,
74688 responder: SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder,
74689 },
74690 GetIpReceiveOriginalDestinationAddress {
74692 responder: SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder,
74693 },
74694 AddIpv6Membership {
74696 membership: Ipv6MulticastMembership,
74697 responder: SynchronousDatagramSocketAddIpv6MembershipResponder,
74698 },
74699 DropIpv6Membership {
74701 membership: Ipv6MulticastMembership,
74702 responder: SynchronousDatagramSocketDropIpv6MembershipResponder,
74703 },
74704 SetIpv6MulticastInterface {
74706 value: u64,
74707 responder: SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder,
74708 },
74709 GetIpv6MulticastInterface {
74711 responder: SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder,
74712 },
74713 SetIpv6UnicastHops {
74715 value: OptionalUint8,
74716 responder: SynchronousDatagramSocketSetIpv6UnicastHopsResponder,
74717 },
74718 GetIpv6UnicastHops {
74720 responder: SynchronousDatagramSocketGetIpv6UnicastHopsResponder,
74721 },
74722 SetIpv6ReceiveHopLimit {
74724 value: bool,
74725 responder: SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder,
74726 },
74727 GetIpv6ReceiveHopLimit {
74729 responder: SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder,
74730 },
74731 SetIpv6MulticastHops {
74733 value: OptionalUint8,
74734 responder: SynchronousDatagramSocketSetIpv6MulticastHopsResponder,
74735 },
74736 GetIpv6MulticastHops {
74738 responder: SynchronousDatagramSocketGetIpv6MulticastHopsResponder,
74739 },
74740 SetIpv6MulticastLoopback {
74742 value: bool,
74743 responder: SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder,
74744 },
74745 GetIpv6MulticastLoopback {
74747 responder: SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder,
74748 },
74749 SetIpv6Only {
74751 value: bool,
74752 responder: SynchronousDatagramSocketSetIpv6OnlyResponder,
74753 },
74754 GetIpv6Only {
74756 responder: SynchronousDatagramSocketGetIpv6OnlyResponder,
74757 },
74758 SetIpv6ReceiveTrafficClass {
74760 value: bool,
74761 responder: SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder,
74762 },
74763 GetIpv6ReceiveTrafficClass {
74765 responder: SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder,
74766 },
74767 SetIpv6TrafficClass {
74769 value: OptionalUint8,
74770 responder: SynchronousDatagramSocketSetIpv6TrafficClassResponder,
74771 },
74772 GetIpv6TrafficClass {
74774 responder: SynchronousDatagramSocketGetIpv6TrafficClassResponder,
74775 },
74776 SetIpv6ReceivePacketInfo {
74778 value: bool,
74779 responder: SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder,
74780 },
74781 GetIpv6ReceivePacketInfo {
74783 responder: SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder,
74784 },
74785 GetOriginalDestination {
74787 responder: SynchronousDatagramSocketGetOriginalDestinationResponder,
74788 },
74789 GetInfo {
74794 responder: SynchronousDatagramSocketGetInfoResponder,
74795 },
74796 Describe {
74797 responder: SynchronousDatagramSocketDescribeResponder,
74798 },
74799 RecvMsg {
74814 want_addr: bool,
74815 data_len: u32,
74816 want_control: bool,
74817 flags: RecvMsgFlags,
74818 responder: SynchronousDatagramSocketRecvMsgResponder,
74819 },
74820 SendMsg {
74829 addr: Option<Box<fidl_fuchsia_net::SocketAddress>>,
74830 data: Vec<u8>,
74831 control: DatagramSocketSendControlData,
74832 flags: SendMsgFlags,
74833 responder: SynchronousDatagramSocketSendMsgResponder,
74834 },
74835}
74836
74837impl SynchronousDatagramSocketRequest {
74838 #[allow(irrefutable_let_patterns)]
74839 pub fn into_clone(
74840 self,
74841 ) -> Option<(
74842 fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
74843 SynchronousDatagramSocketControlHandle,
74844 )> {
74845 if let SynchronousDatagramSocketRequest::Clone { request, control_handle } = self {
74846 Some((request, control_handle))
74847 } else {
74848 None
74849 }
74850 }
74851
74852 #[allow(irrefutable_let_patterns)]
74853 pub fn into_close(self) -> Option<(SynchronousDatagramSocketCloseResponder)> {
74854 if let SynchronousDatagramSocketRequest::Close { responder } = self {
74855 Some((responder))
74856 } else {
74857 None
74858 }
74859 }
74860
74861 #[allow(irrefutable_let_patterns)]
74862 pub fn into_query(self) -> Option<(SynchronousDatagramSocketQueryResponder)> {
74863 if let SynchronousDatagramSocketRequest::Query { responder } = self {
74864 Some((responder))
74865 } else {
74866 None
74867 }
74868 }
74869
74870 #[allow(irrefutable_let_patterns)]
74871 pub fn into_set_reuse_address(
74872 self,
74873 ) -> Option<(bool, SynchronousDatagramSocketSetReuseAddressResponder)> {
74874 if let SynchronousDatagramSocketRequest::SetReuseAddress { value, responder } = self {
74875 Some((value, responder))
74876 } else {
74877 None
74878 }
74879 }
74880
74881 #[allow(irrefutable_let_patterns)]
74882 pub fn into_get_reuse_address(
74883 self,
74884 ) -> Option<(SynchronousDatagramSocketGetReuseAddressResponder)> {
74885 if let SynchronousDatagramSocketRequest::GetReuseAddress { responder } = self {
74886 Some((responder))
74887 } else {
74888 None
74889 }
74890 }
74891
74892 #[allow(irrefutable_let_patterns)]
74893 pub fn into_get_error(self) -> Option<(SynchronousDatagramSocketGetErrorResponder)> {
74894 if let SynchronousDatagramSocketRequest::GetError { responder } = self {
74895 Some((responder))
74896 } else {
74897 None
74898 }
74899 }
74900
74901 #[allow(irrefutable_let_patterns)]
74902 pub fn into_set_broadcast(
74903 self,
74904 ) -> Option<(bool, SynchronousDatagramSocketSetBroadcastResponder)> {
74905 if let SynchronousDatagramSocketRequest::SetBroadcast { value, responder } = self {
74906 Some((value, responder))
74907 } else {
74908 None
74909 }
74910 }
74911
74912 #[allow(irrefutable_let_patterns)]
74913 pub fn into_get_broadcast(self) -> Option<(SynchronousDatagramSocketGetBroadcastResponder)> {
74914 if let SynchronousDatagramSocketRequest::GetBroadcast { responder } = self {
74915 Some((responder))
74916 } else {
74917 None
74918 }
74919 }
74920
74921 #[allow(irrefutable_let_patterns)]
74922 pub fn into_set_send_buffer(
74923 self,
74924 ) -> Option<(u64, SynchronousDatagramSocketSetSendBufferResponder)> {
74925 if let SynchronousDatagramSocketRequest::SetSendBuffer { value_bytes, responder } = self {
74926 Some((value_bytes, responder))
74927 } else {
74928 None
74929 }
74930 }
74931
74932 #[allow(irrefutable_let_patterns)]
74933 pub fn into_get_send_buffer(self) -> Option<(SynchronousDatagramSocketGetSendBufferResponder)> {
74934 if let SynchronousDatagramSocketRequest::GetSendBuffer { responder } = self {
74935 Some((responder))
74936 } else {
74937 None
74938 }
74939 }
74940
74941 #[allow(irrefutable_let_patterns)]
74942 pub fn into_set_receive_buffer(
74943 self,
74944 ) -> Option<(u64, SynchronousDatagramSocketSetReceiveBufferResponder)> {
74945 if let SynchronousDatagramSocketRequest::SetReceiveBuffer { value_bytes, responder } = self
74946 {
74947 Some((value_bytes, responder))
74948 } else {
74949 None
74950 }
74951 }
74952
74953 #[allow(irrefutable_let_patterns)]
74954 pub fn into_get_receive_buffer(
74955 self,
74956 ) -> Option<(SynchronousDatagramSocketGetReceiveBufferResponder)> {
74957 if let SynchronousDatagramSocketRequest::GetReceiveBuffer { responder } = self {
74958 Some((responder))
74959 } else {
74960 None
74961 }
74962 }
74963
74964 #[allow(irrefutable_let_patterns)]
74965 pub fn into_set_keep_alive(
74966 self,
74967 ) -> Option<(bool, SynchronousDatagramSocketSetKeepAliveResponder)> {
74968 if let SynchronousDatagramSocketRequest::SetKeepAlive { value, responder } = self {
74969 Some((value, responder))
74970 } else {
74971 None
74972 }
74973 }
74974
74975 #[allow(irrefutable_let_patterns)]
74976 pub fn into_get_keep_alive(self) -> Option<(SynchronousDatagramSocketGetKeepAliveResponder)> {
74977 if let SynchronousDatagramSocketRequest::GetKeepAlive { responder } = self {
74978 Some((responder))
74979 } else {
74980 None
74981 }
74982 }
74983
74984 #[allow(irrefutable_let_patterns)]
74985 pub fn into_set_out_of_band_inline(
74986 self,
74987 ) -> Option<(bool, SynchronousDatagramSocketSetOutOfBandInlineResponder)> {
74988 if let SynchronousDatagramSocketRequest::SetOutOfBandInline { value, responder } = self {
74989 Some((value, responder))
74990 } else {
74991 None
74992 }
74993 }
74994
74995 #[allow(irrefutable_let_patterns)]
74996 pub fn into_get_out_of_band_inline(
74997 self,
74998 ) -> Option<(SynchronousDatagramSocketGetOutOfBandInlineResponder)> {
74999 if let SynchronousDatagramSocketRequest::GetOutOfBandInline { responder } = self {
75000 Some((responder))
75001 } else {
75002 None
75003 }
75004 }
75005
75006 #[allow(irrefutable_let_patterns)]
75007 pub fn into_set_no_check(self) -> Option<(bool, SynchronousDatagramSocketSetNoCheckResponder)> {
75008 if let SynchronousDatagramSocketRequest::SetNoCheck { value, responder } = self {
75009 Some((value, responder))
75010 } else {
75011 None
75012 }
75013 }
75014
75015 #[allow(irrefutable_let_patterns)]
75016 pub fn into_get_no_check(self) -> Option<(SynchronousDatagramSocketGetNoCheckResponder)> {
75017 if let SynchronousDatagramSocketRequest::GetNoCheck { responder } = self {
75018 Some((responder))
75019 } else {
75020 None
75021 }
75022 }
75023
75024 #[allow(irrefutable_let_patterns)]
75025 pub fn into_set_linger(
75026 self,
75027 ) -> Option<(bool, u32, SynchronousDatagramSocketSetLingerResponder)> {
75028 if let SynchronousDatagramSocketRequest::SetLinger { linger, length_secs, responder } = self
75029 {
75030 Some((linger, length_secs, responder))
75031 } else {
75032 None
75033 }
75034 }
75035
75036 #[allow(irrefutable_let_patterns)]
75037 pub fn into_get_linger(self) -> Option<(SynchronousDatagramSocketGetLingerResponder)> {
75038 if let SynchronousDatagramSocketRequest::GetLinger { responder } = self {
75039 Some((responder))
75040 } else {
75041 None
75042 }
75043 }
75044
75045 #[allow(irrefutable_let_patterns)]
75046 pub fn into_set_reuse_port(
75047 self,
75048 ) -> Option<(bool, SynchronousDatagramSocketSetReusePortResponder)> {
75049 if let SynchronousDatagramSocketRequest::SetReusePort { value, responder } = self {
75050 Some((value, responder))
75051 } else {
75052 None
75053 }
75054 }
75055
75056 #[allow(irrefutable_let_patterns)]
75057 pub fn into_get_reuse_port(self) -> Option<(SynchronousDatagramSocketGetReusePortResponder)> {
75058 if let SynchronousDatagramSocketRequest::GetReusePort { responder } = self {
75059 Some((responder))
75060 } else {
75061 None
75062 }
75063 }
75064
75065 #[allow(irrefutable_let_patterns)]
75066 pub fn into_get_accept_conn(self) -> Option<(SynchronousDatagramSocketGetAcceptConnResponder)> {
75067 if let SynchronousDatagramSocketRequest::GetAcceptConn { responder } = self {
75068 Some((responder))
75069 } else {
75070 None
75071 }
75072 }
75073
75074 #[allow(irrefutable_let_patterns)]
75075 pub fn into_set_bind_to_device(
75076 self,
75077 ) -> Option<(String, SynchronousDatagramSocketSetBindToDeviceResponder)> {
75078 if let SynchronousDatagramSocketRequest::SetBindToDevice { value, responder } = self {
75079 Some((value, responder))
75080 } else {
75081 None
75082 }
75083 }
75084
75085 #[allow(irrefutable_let_patterns)]
75086 pub fn into_get_bind_to_device(
75087 self,
75088 ) -> Option<(SynchronousDatagramSocketGetBindToDeviceResponder)> {
75089 if let SynchronousDatagramSocketRequest::GetBindToDevice { responder } = self {
75090 Some((responder))
75091 } else {
75092 None
75093 }
75094 }
75095
75096 #[allow(irrefutable_let_patterns)]
75097 pub fn into_set_bind_to_interface_index(
75098 self,
75099 ) -> Option<(u64, SynchronousDatagramSocketSetBindToInterfaceIndexResponder)> {
75100 if let SynchronousDatagramSocketRequest::SetBindToInterfaceIndex { value, responder } = self
75101 {
75102 Some((value, responder))
75103 } else {
75104 None
75105 }
75106 }
75107
75108 #[allow(irrefutable_let_patterns)]
75109 pub fn into_get_bind_to_interface_index(
75110 self,
75111 ) -> Option<(SynchronousDatagramSocketGetBindToInterfaceIndexResponder)> {
75112 if let SynchronousDatagramSocketRequest::GetBindToInterfaceIndex { responder } = self {
75113 Some((responder))
75114 } else {
75115 None
75116 }
75117 }
75118
75119 #[allow(irrefutable_let_patterns)]
75120 pub fn into_set_timestamp(
75121 self,
75122 ) -> Option<(TimestampOption, SynchronousDatagramSocketSetTimestampResponder)> {
75123 if let SynchronousDatagramSocketRequest::SetTimestamp { value, responder } = self {
75124 Some((value, responder))
75125 } else {
75126 None
75127 }
75128 }
75129
75130 #[allow(irrefutable_let_patterns)]
75131 pub fn into_get_timestamp(self) -> Option<(SynchronousDatagramSocketGetTimestampResponder)> {
75132 if let SynchronousDatagramSocketRequest::GetTimestamp { responder } = self {
75133 Some((responder))
75134 } else {
75135 None
75136 }
75137 }
75138
75139 #[allow(irrefutable_let_patterns)]
75140 pub fn into_set_mark(
75141 self,
75142 ) -> Option<(
75143 fidl_fuchsia_net::MarkDomain,
75144 OptionalUint32,
75145 SynchronousDatagramSocketSetMarkResponder,
75146 )> {
75147 if let SynchronousDatagramSocketRequest::SetMark { domain, mark, responder } = self {
75148 Some((domain, mark, responder))
75149 } else {
75150 None
75151 }
75152 }
75153
75154 #[allow(irrefutable_let_patterns)]
75155 pub fn into_get_mark(
75156 self,
75157 ) -> Option<(fidl_fuchsia_net::MarkDomain, SynchronousDatagramSocketGetMarkResponder)> {
75158 if let SynchronousDatagramSocketRequest::GetMark { domain, responder } = self {
75159 Some((domain, responder))
75160 } else {
75161 None
75162 }
75163 }
75164
75165 #[allow(irrefutable_let_patterns)]
75166 pub fn into_bind(
75167 self,
75168 ) -> Option<(fidl_fuchsia_net::SocketAddress, SynchronousDatagramSocketBindResponder)> {
75169 if let SynchronousDatagramSocketRequest::Bind { addr, responder } = self {
75170 Some((addr, responder))
75171 } else {
75172 None
75173 }
75174 }
75175
75176 #[allow(irrefutable_let_patterns)]
75177 pub fn into_connect(
75178 self,
75179 ) -> Option<(fidl_fuchsia_net::SocketAddress, SynchronousDatagramSocketConnectResponder)> {
75180 if let SynchronousDatagramSocketRequest::Connect { addr, responder } = self {
75181 Some((addr, responder))
75182 } else {
75183 None
75184 }
75185 }
75186
75187 #[allow(irrefutable_let_patterns)]
75188 pub fn into_disconnect(self) -> Option<(SynchronousDatagramSocketDisconnectResponder)> {
75189 if let SynchronousDatagramSocketRequest::Disconnect { responder } = self {
75190 Some((responder))
75191 } else {
75192 None
75193 }
75194 }
75195
75196 #[allow(irrefutable_let_patterns)]
75197 pub fn into_get_sock_name(self) -> Option<(SynchronousDatagramSocketGetSockNameResponder)> {
75198 if let SynchronousDatagramSocketRequest::GetSockName { responder } = self {
75199 Some((responder))
75200 } else {
75201 None
75202 }
75203 }
75204
75205 #[allow(irrefutable_let_patterns)]
75206 pub fn into_get_peer_name(self) -> Option<(SynchronousDatagramSocketGetPeerNameResponder)> {
75207 if let SynchronousDatagramSocketRequest::GetPeerName { responder } = self {
75208 Some((responder))
75209 } else {
75210 None
75211 }
75212 }
75213
75214 #[allow(irrefutable_let_patterns)]
75215 pub fn into_shutdown(
75216 self,
75217 ) -> Option<(ShutdownMode, SynchronousDatagramSocketShutdownResponder)> {
75218 if let SynchronousDatagramSocketRequest::Shutdown { mode, responder } = self {
75219 Some((mode, responder))
75220 } else {
75221 None
75222 }
75223 }
75224
75225 #[allow(irrefutable_let_patterns)]
75226 pub fn into_set_ip_type_of_service(
75227 self,
75228 ) -> Option<(u8, SynchronousDatagramSocketSetIpTypeOfServiceResponder)> {
75229 if let SynchronousDatagramSocketRequest::SetIpTypeOfService { value, responder } = self {
75230 Some((value, responder))
75231 } else {
75232 None
75233 }
75234 }
75235
75236 #[allow(irrefutable_let_patterns)]
75237 pub fn into_get_ip_type_of_service(
75238 self,
75239 ) -> Option<(SynchronousDatagramSocketGetIpTypeOfServiceResponder)> {
75240 if let SynchronousDatagramSocketRequest::GetIpTypeOfService { responder } = self {
75241 Some((responder))
75242 } else {
75243 None
75244 }
75245 }
75246
75247 #[allow(irrefutable_let_patterns)]
75248 pub fn into_set_ip_ttl(
75249 self,
75250 ) -> Option<(OptionalUint8, SynchronousDatagramSocketSetIpTtlResponder)> {
75251 if let SynchronousDatagramSocketRequest::SetIpTtl { value, responder } = self {
75252 Some((value, responder))
75253 } else {
75254 None
75255 }
75256 }
75257
75258 #[allow(irrefutable_let_patterns)]
75259 pub fn into_get_ip_ttl(self) -> Option<(SynchronousDatagramSocketGetIpTtlResponder)> {
75260 if let SynchronousDatagramSocketRequest::GetIpTtl { responder } = self {
75261 Some((responder))
75262 } else {
75263 None
75264 }
75265 }
75266
75267 #[allow(irrefutable_let_patterns)]
75268 pub fn into_set_ip_packet_info(
75269 self,
75270 ) -> Option<(bool, SynchronousDatagramSocketSetIpPacketInfoResponder)> {
75271 if let SynchronousDatagramSocketRequest::SetIpPacketInfo { value, responder } = self {
75272 Some((value, responder))
75273 } else {
75274 None
75275 }
75276 }
75277
75278 #[allow(irrefutable_let_patterns)]
75279 pub fn into_get_ip_packet_info(
75280 self,
75281 ) -> Option<(SynchronousDatagramSocketGetIpPacketInfoResponder)> {
75282 if let SynchronousDatagramSocketRequest::GetIpPacketInfo { responder } = self {
75283 Some((responder))
75284 } else {
75285 None
75286 }
75287 }
75288
75289 #[allow(irrefutable_let_patterns)]
75290 pub fn into_set_ip_receive_type_of_service(
75291 self,
75292 ) -> Option<(bool, SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder)> {
75293 if let SynchronousDatagramSocketRequest::SetIpReceiveTypeOfService { value, responder } =
75294 self
75295 {
75296 Some((value, responder))
75297 } else {
75298 None
75299 }
75300 }
75301
75302 #[allow(irrefutable_let_patterns)]
75303 pub fn into_get_ip_receive_type_of_service(
75304 self,
75305 ) -> Option<(SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder)> {
75306 if let SynchronousDatagramSocketRequest::GetIpReceiveTypeOfService { responder } = self {
75307 Some((responder))
75308 } else {
75309 None
75310 }
75311 }
75312
75313 #[allow(irrefutable_let_patterns)]
75314 pub fn into_set_ip_receive_ttl(
75315 self,
75316 ) -> Option<(bool, SynchronousDatagramSocketSetIpReceiveTtlResponder)> {
75317 if let SynchronousDatagramSocketRequest::SetIpReceiveTtl { value, responder } = self {
75318 Some((value, responder))
75319 } else {
75320 None
75321 }
75322 }
75323
75324 #[allow(irrefutable_let_patterns)]
75325 pub fn into_get_ip_receive_ttl(
75326 self,
75327 ) -> Option<(SynchronousDatagramSocketGetIpReceiveTtlResponder)> {
75328 if let SynchronousDatagramSocketRequest::GetIpReceiveTtl { responder } = self {
75329 Some((responder))
75330 } else {
75331 None
75332 }
75333 }
75334
75335 #[allow(irrefutable_let_patterns)]
75336 pub fn into_set_ip_multicast_interface(
75337 self,
75338 ) -> Option<(
75339 u64,
75340 fidl_fuchsia_net::Ipv4Address,
75341 SynchronousDatagramSocketSetIpMulticastInterfaceResponder,
75342 )> {
75343 if let SynchronousDatagramSocketRequest::SetIpMulticastInterface {
75344 iface,
75345 address,
75346 responder,
75347 } = self
75348 {
75349 Some((iface, address, responder))
75350 } else {
75351 None
75352 }
75353 }
75354
75355 #[allow(irrefutable_let_patterns)]
75356 pub fn into_get_ip_multicast_interface(
75357 self,
75358 ) -> Option<(SynchronousDatagramSocketGetIpMulticastInterfaceResponder)> {
75359 if let SynchronousDatagramSocketRequest::GetIpMulticastInterface { responder } = self {
75360 Some((responder))
75361 } else {
75362 None
75363 }
75364 }
75365
75366 #[allow(irrefutable_let_patterns)]
75367 pub fn into_set_ip_multicast_ttl(
75368 self,
75369 ) -> Option<(OptionalUint8, SynchronousDatagramSocketSetIpMulticastTtlResponder)> {
75370 if let SynchronousDatagramSocketRequest::SetIpMulticastTtl { value, responder } = self {
75371 Some((value, responder))
75372 } else {
75373 None
75374 }
75375 }
75376
75377 #[allow(irrefutable_let_patterns)]
75378 pub fn into_get_ip_multicast_ttl(
75379 self,
75380 ) -> Option<(SynchronousDatagramSocketGetIpMulticastTtlResponder)> {
75381 if let SynchronousDatagramSocketRequest::GetIpMulticastTtl { responder } = self {
75382 Some((responder))
75383 } else {
75384 None
75385 }
75386 }
75387
75388 #[allow(irrefutable_let_patterns)]
75389 pub fn into_set_ip_multicast_loopback(
75390 self,
75391 ) -> Option<(bool, SynchronousDatagramSocketSetIpMulticastLoopbackResponder)> {
75392 if let SynchronousDatagramSocketRequest::SetIpMulticastLoopback { value, responder } = self
75393 {
75394 Some((value, responder))
75395 } else {
75396 None
75397 }
75398 }
75399
75400 #[allow(irrefutable_let_patterns)]
75401 pub fn into_get_ip_multicast_loopback(
75402 self,
75403 ) -> Option<(SynchronousDatagramSocketGetIpMulticastLoopbackResponder)> {
75404 if let SynchronousDatagramSocketRequest::GetIpMulticastLoopback { responder } = self {
75405 Some((responder))
75406 } else {
75407 None
75408 }
75409 }
75410
75411 #[allow(irrefutable_let_patterns)]
75412 pub fn into_add_ip_membership(
75413 self,
75414 ) -> Option<(IpMulticastMembership, SynchronousDatagramSocketAddIpMembershipResponder)> {
75415 if let SynchronousDatagramSocketRequest::AddIpMembership { membership, responder } = self {
75416 Some((membership, responder))
75417 } else {
75418 None
75419 }
75420 }
75421
75422 #[allow(irrefutable_let_patterns)]
75423 pub fn into_drop_ip_membership(
75424 self,
75425 ) -> Option<(IpMulticastMembership, SynchronousDatagramSocketDropIpMembershipResponder)> {
75426 if let SynchronousDatagramSocketRequest::DropIpMembership { membership, responder } = self {
75427 Some((membership, responder))
75428 } else {
75429 None
75430 }
75431 }
75432
75433 #[allow(irrefutable_let_patterns)]
75434 pub fn into_set_ip_transparent(
75435 self,
75436 ) -> Option<(bool, SynchronousDatagramSocketSetIpTransparentResponder)> {
75437 if let SynchronousDatagramSocketRequest::SetIpTransparent { value, responder } = self {
75438 Some((value, responder))
75439 } else {
75440 None
75441 }
75442 }
75443
75444 #[allow(irrefutable_let_patterns)]
75445 pub fn into_get_ip_transparent(
75446 self,
75447 ) -> Option<(SynchronousDatagramSocketGetIpTransparentResponder)> {
75448 if let SynchronousDatagramSocketRequest::GetIpTransparent { responder } = self {
75449 Some((responder))
75450 } else {
75451 None
75452 }
75453 }
75454
75455 #[allow(irrefutable_let_patterns)]
75456 pub fn into_set_ip_receive_original_destination_address(
75457 self,
75458 ) -> Option<(bool, SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder)>
75459 {
75460 if let SynchronousDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress {
75461 value,
75462 responder,
75463 } = self
75464 {
75465 Some((value, responder))
75466 } else {
75467 None
75468 }
75469 }
75470
75471 #[allow(irrefutable_let_patterns)]
75472 pub fn into_get_ip_receive_original_destination_address(
75473 self,
75474 ) -> Option<(SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder)> {
75475 if let SynchronousDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress {
75476 responder,
75477 } = self
75478 {
75479 Some((responder))
75480 } else {
75481 None
75482 }
75483 }
75484
75485 #[allow(irrefutable_let_patterns)]
75486 pub fn into_add_ipv6_membership(
75487 self,
75488 ) -> Option<(Ipv6MulticastMembership, SynchronousDatagramSocketAddIpv6MembershipResponder)>
75489 {
75490 if let SynchronousDatagramSocketRequest::AddIpv6Membership { membership, responder } = self
75491 {
75492 Some((membership, responder))
75493 } else {
75494 None
75495 }
75496 }
75497
75498 #[allow(irrefutable_let_patterns)]
75499 pub fn into_drop_ipv6_membership(
75500 self,
75501 ) -> Option<(Ipv6MulticastMembership, SynchronousDatagramSocketDropIpv6MembershipResponder)>
75502 {
75503 if let SynchronousDatagramSocketRequest::DropIpv6Membership { membership, responder } = self
75504 {
75505 Some((membership, responder))
75506 } else {
75507 None
75508 }
75509 }
75510
75511 #[allow(irrefutable_let_patterns)]
75512 pub fn into_set_ipv6_multicast_interface(
75513 self,
75514 ) -> Option<(u64, SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder)> {
75515 if let SynchronousDatagramSocketRequest::SetIpv6MulticastInterface { value, responder } =
75516 self
75517 {
75518 Some((value, responder))
75519 } else {
75520 None
75521 }
75522 }
75523
75524 #[allow(irrefutable_let_patterns)]
75525 pub fn into_get_ipv6_multicast_interface(
75526 self,
75527 ) -> Option<(SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder)> {
75528 if let SynchronousDatagramSocketRequest::GetIpv6MulticastInterface { responder } = self {
75529 Some((responder))
75530 } else {
75531 None
75532 }
75533 }
75534
75535 #[allow(irrefutable_let_patterns)]
75536 pub fn into_set_ipv6_unicast_hops(
75537 self,
75538 ) -> Option<(OptionalUint8, SynchronousDatagramSocketSetIpv6UnicastHopsResponder)> {
75539 if let SynchronousDatagramSocketRequest::SetIpv6UnicastHops { value, responder } = self {
75540 Some((value, responder))
75541 } else {
75542 None
75543 }
75544 }
75545
75546 #[allow(irrefutable_let_patterns)]
75547 pub fn into_get_ipv6_unicast_hops(
75548 self,
75549 ) -> Option<(SynchronousDatagramSocketGetIpv6UnicastHopsResponder)> {
75550 if let SynchronousDatagramSocketRequest::GetIpv6UnicastHops { responder } = self {
75551 Some((responder))
75552 } else {
75553 None
75554 }
75555 }
75556
75557 #[allow(irrefutable_let_patterns)]
75558 pub fn into_set_ipv6_receive_hop_limit(
75559 self,
75560 ) -> Option<(bool, SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder)> {
75561 if let SynchronousDatagramSocketRequest::SetIpv6ReceiveHopLimit { value, responder } = self
75562 {
75563 Some((value, responder))
75564 } else {
75565 None
75566 }
75567 }
75568
75569 #[allow(irrefutable_let_patterns)]
75570 pub fn into_get_ipv6_receive_hop_limit(
75571 self,
75572 ) -> Option<(SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder)> {
75573 if let SynchronousDatagramSocketRequest::GetIpv6ReceiveHopLimit { responder } = self {
75574 Some((responder))
75575 } else {
75576 None
75577 }
75578 }
75579
75580 #[allow(irrefutable_let_patterns)]
75581 pub fn into_set_ipv6_multicast_hops(
75582 self,
75583 ) -> Option<(OptionalUint8, SynchronousDatagramSocketSetIpv6MulticastHopsResponder)> {
75584 if let SynchronousDatagramSocketRequest::SetIpv6MulticastHops { value, responder } = self {
75585 Some((value, responder))
75586 } else {
75587 None
75588 }
75589 }
75590
75591 #[allow(irrefutable_let_patterns)]
75592 pub fn into_get_ipv6_multicast_hops(
75593 self,
75594 ) -> Option<(SynchronousDatagramSocketGetIpv6MulticastHopsResponder)> {
75595 if let SynchronousDatagramSocketRequest::GetIpv6MulticastHops { responder } = self {
75596 Some((responder))
75597 } else {
75598 None
75599 }
75600 }
75601
75602 #[allow(irrefutable_let_patterns)]
75603 pub fn into_set_ipv6_multicast_loopback(
75604 self,
75605 ) -> Option<(bool, SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder)> {
75606 if let SynchronousDatagramSocketRequest::SetIpv6MulticastLoopback { value, responder } =
75607 self
75608 {
75609 Some((value, responder))
75610 } else {
75611 None
75612 }
75613 }
75614
75615 #[allow(irrefutable_let_patterns)]
75616 pub fn into_get_ipv6_multicast_loopback(
75617 self,
75618 ) -> Option<(SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder)> {
75619 if let SynchronousDatagramSocketRequest::GetIpv6MulticastLoopback { responder } = self {
75620 Some((responder))
75621 } else {
75622 None
75623 }
75624 }
75625
75626 #[allow(irrefutable_let_patterns)]
75627 pub fn into_set_ipv6_only(
75628 self,
75629 ) -> Option<(bool, SynchronousDatagramSocketSetIpv6OnlyResponder)> {
75630 if let SynchronousDatagramSocketRequest::SetIpv6Only { value, responder } = self {
75631 Some((value, responder))
75632 } else {
75633 None
75634 }
75635 }
75636
75637 #[allow(irrefutable_let_patterns)]
75638 pub fn into_get_ipv6_only(self) -> Option<(SynchronousDatagramSocketGetIpv6OnlyResponder)> {
75639 if let SynchronousDatagramSocketRequest::GetIpv6Only { responder } = self {
75640 Some((responder))
75641 } else {
75642 None
75643 }
75644 }
75645
75646 #[allow(irrefutable_let_patterns)]
75647 pub fn into_set_ipv6_receive_traffic_class(
75648 self,
75649 ) -> Option<(bool, SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder)> {
75650 if let SynchronousDatagramSocketRequest::SetIpv6ReceiveTrafficClass { value, responder } =
75651 self
75652 {
75653 Some((value, responder))
75654 } else {
75655 None
75656 }
75657 }
75658
75659 #[allow(irrefutable_let_patterns)]
75660 pub fn into_get_ipv6_receive_traffic_class(
75661 self,
75662 ) -> Option<(SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder)> {
75663 if let SynchronousDatagramSocketRequest::GetIpv6ReceiveTrafficClass { responder } = self {
75664 Some((responder))
75665 } else {
75666 None
75667 }
75668 }
75669
75670 #[allow(irrefutable_let_patterns)]
75671 pub fn into_set_ipv6_traffic_class(
75672 self,
75673 ) -> Option<(OptionalUint8, SynchronousDatagramSocketSetIpv6TrafficClassResponder)> {
75674 if let SynchronousDatagramSocketRequest::SetIpv6TrafficClass { value, responder } = self {
75675 Some((value, responder))
75676 } else {
75677 None
75678 }
75679 }
75680
75681 #[allow(irrefutable_let_patterns)]
75682 pub fn into_get_ipv6_traffic_class(
75683 self,
75684 ) -> Option<(SynchronousDatagramSocketGetIpv6TrafficClassResponder)> {
75685 if let SynchronousDatagramSocketRequest::GetIpv6TrafficClass { responder } = self {
75686 Some((responder))
75687 } else {
75688 None
75689 }
75690 }
75691
75692 #[allow(irrefutable_let_patterns)]
75693 pub fn into_set_ipv6_receive_packet_info(
75694 self,
75695 ) -> Option<(bool, SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder)> {
75696 if let SynchronousDatagramSocketRequest::SetIpv6ReceivePacketInfo { value, responder } =
75697 self
75698 {
75699 Some((value, responder))
75700 } else {
75701 None
75702 }
75703 }
75704
75705 #[allow(irrefutable_let_patterns)]
75706 pub fn into_get_ipv6_receive_packet_info(
75707 self,
75708 ) -> Option<(SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder)> {
75709 if let SynchronousDatagramSocketRequest::GetIpv6ReceivePacketInfo { responder } = self {
75710 Some((responder))
75711 } else {
75712 None
75713 }
75714 }
75715
75716 #[allow(irrefutable_let_patterns)]
75717 pub fn into_get_original_destination(
75718 self,
75719 ) -> Option<(SynchronousDatagramSocketGetOriginalDestinationResponder)> {
75720 if let SynchronousDatagramSocketRequest::GetOriginalDestination { responder } = self {
75721 Some((responder))
75722 } else {
75723 None
75724 }
75725 }
75726
75727 #[allow(irrefutable_let_patterns)]
75728 pub fn into_get_info(self) -> Option<(SynchronousDatagramSocketGetInfoResponder)> {
75729 if let SynchronousDatagramSocketRequest::GetInfo { responder } = self {
75730 Some((responder))
75731 } else {
75732 None
75733 }
75734 }
75735
75736 #[allow(irrefutable_let_patterns)]
75737 pub fn into_describe(self) -> Option<(SynchronousDatagramSocketDescribeResponder)> {
75738 if let SynchronousDatagramSocketRequest::Describe { responder } = self {
75739 Some((responder))
75740 } else {
75741 None
75742 }
75743 }
75744
75745 #[allow(irrefutable_let_patterns)]
75746 pub fn into_recv_msg(
75747 self,
75748 ) -> Option<(bool, u32, bool, RecvMsgFlags, SynchronousDatagramSocketRecvMsgResponder)> {
75749 if let SynchronousDatagramSocketRequest::RecvMsg {
75750 want_addr,
75751 data_len,
75752 want_control,
75753 flags,
75754 responder,
75755 } = self
75756 {
75757 Some((want_addr, data_len, want_control, flags, responder))
75758 } else {
75759 None
75760 }
75761 }
75762
75763 #[allow(irrefutable_let_patterns)]
75764 pub fn into_send_msg(
75765 self,
75766 ) -> Option<(
75767 Option<Box<fidl_fuchsia_net::SocketAddress>>,
75768 Vec<u8>,
75769 DatagramSocketSendControlData,
75770 SendMsgFlags,
75771 SynchronousDatagramSocketSendMsgResponder,
75772 )> {
75773 if let SynchronousDatagramSocketRequest::SendMsg { addr, data, control, flags, responder } =
75774 self
75775 {
75776 Some((addr, data, control, flags, responder))
75777 } else {
75778 None
75779 }
75780 }
75781
75782 pub fn method_name(&self) -> &'static str {
75784 match *self {
75785 SynchronousDatagramSocketRequest::Clone { .. } => "clone",
75786 SynchronousDatagramSocketRequest::Close { .. } => "close",
75787 SynchronousDatagramSocketRequest::Query { .. } => "query",
75788 SynchronousDatagramSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
75789 SynchronousDatagramSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
75790 SynchronousDatagramSocketRequest::GetError { .. } => "get_error",
75791 SynchronousDatagramSocketRequest::SetBroadcast { .. } => "set_broadcast",
75792 SynchronousDatagramSocketRequest::GetBroadcast { .. } => "get_broadcast",
75793 SynchronousDatagramSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
75794 SynchronousDatagramSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
75795 SynchronousDatagramSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
75796 SynchronousDatagramSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
75797 SynchronousDatagramSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
75798 SynchronousDatagramSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
75799 SynchronousDatagramSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
75800 SynchronousDatagramSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
75801 SynchronousDatagramSocketRequest::SetNoCheck { .. } => "set_no_check",
75802 SynchronousDatagramSocketRequest::GetNoCheck { .. } => "get_no_check",
75803 SynchronousDatagramSocketRequest::SetLinger { .. } => "set_linger",
75804 SynchronousDatagramSocketRequest::GetLinger { .. } => "get_linger",
75805 SynchronousDatagramSocketRequest::SetReusePort { .. } => "set_reuse_port",
75806 SynchronousDatagramSocketRequest::GetReusePort { .. } => "get_reuse_port",
75807 SynchronousDatagramSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
75808 SynchronousDatagramSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
75809 SynchronousDatagramSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
75810 SynchronousDatagramSocketRequest::SetBindToInterfaceIndex { .. } => {
75811 "set_bind_to_interface_index"
75812 }
75813 SynchronousDatagramSocketRequest::GetBindToInterfaceIndex { .. } => {
75814 "get_bind_to_interface_index"
75815 }
75816 SynchronousDatagramSocketRequest::SetTimestamp { .. } => "set_timestamp",
75817 SynchronousDatagramSocketRequest::GetTimestamp { .. } => "get_timestamp",
75818 SynchronousDatagramSocketRequest::SetMark { .. } => "set_mark",
75819 SynchronousDatagramSocketRequest::GetMark { .. } => "get_mark",
75820 SynchronousDatagramSocketRequest::Bind { .. } => "bind",
75821 SynchronousDatagramSocketRequest::Connect { .. } => "connect",
75822 SynchronousDatagramSocketRequest::Disconnect { .. } => "disconnect",
75823 SynchronousDatagramSocketRequest::GetSockName { .. } => "get_sock_name",
75824 SynchronousDatagramSocketRequest::GetPeerName { .. } => "get_peer_name",
75825 SynchronousDatagramSocketRequest::Shutdown { .. } => "shutdown",
75826 SynchronousDatagramSocketRequest::SetIpTypeOfService { .. } => "set_ip_type_of_service",
75827 SynchronousDatagramSocketRequest::GetIpTypeOfService { .. } => "get_ip_type_of_service",
75828 SynchronousDatagramSocketRequest::SetIpTtl { .. } => "set_ip_ttl",
75829 SynchronousDatagramSocketRequest::GetIpTtl { .. } => "get_ip_ttl",
75830 SynchronousDatagramSocketRequest::SetIpPacketInfo { .. } => "set_ip_packet_info",
75831 SynchronousDatagramSocketRequest::GetIpPacketInfo { .. } => "get_ip_packet_info",
75832 SynchronousDatagramSocketRequest::SetIpReceiveTypeOfService { .. } => {
75833 "set_ip_receive_type_of_service"
75834 }
75835 SynchronousDatagramSocketRequest::GetIpReceiveTypeOfService { .. } => {
75836 "get_ip_receive_type_of_service"
75837 }
75838 SynchronousDatagramSocketRequest::SetIpReceiveTtl { .. } => "set_ip_receive_ttl",
75839 SynchronousDatagramSocketRequest::GetIpReceiveTtl { .. } => "get_ip_receive_ttl",
75840 SynchronousDatagramSocketRequest::SetIpMulticastInterface { .. } => {
75841 "set_ip_multicast_interface"
75842 }
75843 SynchronousDatagramSocketRequest::GetIpMulticastInterface { .. } => {
75844 "get_ip_multicast_interface"
75845 }
75846 SynchronousDatagramSocketRequest::SetIpMulticastTtl { .. } => "set_ip_multicast_ttl",
75847 SynchronousDatagramSocketRequest::GetIpMulticastTtl { .. } => "get_ip_multicast_ttl",
75848 SynchronousDatagramSocketRequest::SetIpMulticastLoopback { .. } => {
75849 "set_ip_multicast_loopback"
75850 }
75851 SynchronousDatagramSocketRequest::GetIpMulticastLoopback { .. } => {
75852 "get_ip_multicast_loopback"
75853 }
75854 SynchronousDatagramSocketRequest::AddIpMembership { .. } => "add_ip_membership",
75855 SynchronousDatagramSocketRequest::DropIpMembership { .. } => "drop_ip_membership",
75856 SynchronousDatagramSocketRequest::SetIpTransparent { .. } => "set_ip_transparent",
75857 SynchronousDatagramSocketRequest::GetIpTransparent { .. } => "get_ip_transparent",
75858 SynchronousDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress { .. } => {
75859 "set_ip_receive_original_destination_address"
75860 }
75861 SynchronousDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress { .. } => {
75862 "get_ip_receive_original_destination_address"
75863 }
75864 SynchronousDatagramSocketRequest::AddIpv6Membership { .. } => "add_ipv6_membership",
75865 SynchronousDatagramSocketRequest::DropIpv6Membership { .. } => "drop_ipv6_membership",
75866 SynchronousDatagramSocketRequest::SetIpv6MulticastInterface { .. } => {
75867 "set_ipv6_multicast_interface"
75868 }
75869 SynchronousDatagramSocketRequest::GetIpv6MulticastInterface { .. } => {
75870 "get_ipv6_multicast_interface"
75871 }
75872 SynchronousDatagramSocketRequest::SetIpv6UnicastHops { .. } => "set_ipv6_unicast_hops",
75873 SynchronousDatagramSocketRequest::GetIpv6UnicastHops { .. } => "get_ipv6_unicast_hops",
75874 SynchronousDatagramSocketRequest::SetIpv6ReceiveHopLimit { .. } => {
75875 "set_ipv6_receive_hop_limit"
75876 }
75877 SynchronousDatagramSocketRequest::GetIpv6ReceiveHopLimit { .. } => {
75878 "get_ipv6_receive_hop_limit"
75879 }
75880 SynchronousDatagramSocketRequest::SetIpv6MulticastHops { .. } => {
75881 "set_ipv6_multicast_hops"
75882 }
75883 SynchronousDatagramSocketRequest::GetIpv6MulticastHops { .. } => {
75884 "get_ipv6_multicast_hops"
75885 }
75886 SynchronousDatagramSocketRequest::SetIpv6MulticastLoopback { .. } => {
75887 "set_ipv6_multicast_loopback"
75888 }
75889 SynchronousDatagramSocketRequest::GetIpv6MulticastLoopback { .. } => {
75890 "get_ipv6_multicast_loopback"
75891 }
75892 SynchronousDatagramSocketRequest::SetIpv6Only { .. } => "set_ipv6_only",
75893 SynchronousDatagramSocketRequest::GetIpv6Only { .. } => "get_ipv6_only",
75894 SynchronousDatagramSocketRequest::SetIpv6ReceiveTrafficClass { .. } => {
75895 "set_ipv6_receive_traffic_class"
75896 }
75897 SynchronousDatagramSocketRequest::GetIpv6ReceiveTrafficClass { .. } => {
75898 "get_ipv6_receive_traffic_class"
75899 }
75900 SynchronousDatagramSocketRequest::SetIpv6TrafficClass { .. } => {
75901 "set_ipv6_traffic_class"
75902 }
75903 SynchronousDatagramSocketRequest::GetIpv6TrafficClass { .. } => {
75904 "get_ipv6_traffic_class"
75905 }
75906 SynchronousDatagramSocketRequest::SetIpv6ReceivePacketInfo { .. } => {
75907 "set_ipv6_receive_packet_info"
75908 }
75909 SynchronousDatagramSocketRequest::GetIpv6ReceivePacketInfo { .. } => {
75910 "get_ipv6_receive_packet_info"
75911 }
75912 SynchronousDatagramSocketRequest::GetOriginalDestination { .. } => {
75913 "get_original_destination"
75914 }
75915 SynchronousDatagramSocketRequest::GetInfo { .. } => "get_info",
75916 SynchronousDatagramSocketRequest::Describe { .. } => "describe",
75917 SynchronousDatagramSocketRequest::RecvMsg { .. } => "recv_msg",
75918 SynchronousDatagramSocketRequest::SendMsg { .. } => "send_msg",
75919 }
75920 }
75921}
75922
75923#[derive(Debug, Clone)]
75924pub struct SynchronousDatagramSocketControlHandle {
75925 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
75926}
75927
75928impl fidl::endpoints::ControlHandle for SynchronousDatagramSocketControlHandle {
75929 fn shutdown(&self) {
75930 self.inner.shutdown()
75931 }
75932 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
75933 self.inner.shutdown_with_epitaph(status)
75934 }
75935
75936 fn is_closed(&self) -> bool {
75937 self.inner.channel().is_closed()
75938 }
75939 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
75940 self.inner.channel().on_closed()
75941 }
75942
75943 #[cfg(target_os = "fuchsia")]
75944 fn signal_peer(
75945 &self,
75946 clear_mask: zx::Signals,
75947 set_mask: zx::Signals,
75948 ) -> Result<(), zx_status::Status> {
75949 use fidl::Peered;
75950 self.inner.channel().signal_peer(clear_mask, set_mask)
75951 }
75952}
75953
75954impl SynchronousDatagramSocketControlHandle {}
75955
75956#[must_use = "FIDL methods require a response to be sent"]
75957#[derive(Debug)]
75958pub struct SynchronousDatagramSocketCloseResponder {
75959 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
75960 tx_id: u32,
75961}
75962
75963impl std::ops::Drop for SynchronousDatagramSocketCloseResponder {
75967 fn drop(&mut self) {
75968 self.control_handle.shutdown();
75969 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
75971 }
75972}
75973
75974impl fidl::endpoints::Responder for SynchronousDatagramSocketCloseResponder {
75975 type ControlHandle = SynchronousDatagramSocketControlHandle;
75976
75977 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
75978 &self.control_handle
75979 }
75980
75981 fn drop_without_shutdown(mut self) {
75982 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
75984 std::mem::forget(self);
75986 }
75987}
75988
75989impl SynchronousDatagramSocketCloseResponder {
75990 pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
75994 let _result = self.send_raw(result);
75995 if _result.is_err() {
75996 self.control_handle.shutdown();
75997 }
75998 self.drop_without_shutdown();
75999 _result
76000 }
76001
76002 pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
76004 let _result = self.send_raw(result);
76005 self.drop_without_shutdown();
76006 _result
76007 }
76008
76009 fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
76010 self.control_handle
76011 .inner
76012 .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
76013 result,
76014 self.tx_id,
76015 0x5ac5d459ad7f657e,
76016 fidl::encoding::DynamicFlags::empty(),
76017 )
76018 }
76019}
76020
76021#[must_use = "FIDL methods require a response to be sent"]
76022#[derive(Debug)]
76023pub struct SynchronousDatagramSocketQueryResponder {
76024 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76025 tx_id: u32,
76026}
76027
76028impl std::ops::Drop for SynchronousDatagramSocketQueryResponder {
76032 fn drop(&mut self) {
76033 self.control_handle.shutdown();
76034 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76036 }
76037}
76038
76039impl fidl::endpoints::Responder for SynchronousDatagramSocketQueryResponder {
76040 type ControlHandle = SynchronousDatagramSocketControlHandle;
76041
76042 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76043 &self.control_handle
76044 }
76045
76046 fn drop_without_shutdown(mut self) {
76047 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76049 std::mem::forget(self);
76051 }
76052}
76053
76054impl SynchronousDatagramSocketQueryResponder {
76055 pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
76059 let _result = self.send_raw(protocol);
76060 if _result.is_err() {
76061 self.control_handle.shutdown();
76062 }
76063 self.drop_without_shutdown();
76064 _result
76065 }
76066
76067 pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
76069 let _result = self.send_raw(protocol);
76070 self.drop_without_shutdown();
76071 _result
76072 }
76073
76074 fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
76075 self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
76076 (protocol,),
76077 self.tx_id,
76078 0x2658edee9decfc06,
76079 fidl::encoding::DynamicFlags::empty(),
76080 )
76081 }
76082}
76083
76084#[must_use = "FIDL methods require a response to be sent"]
76085#[derive(Debug)]
76086pub struct SynchronousDatagramSocketSetReuseAddressResponder {
76087 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76088 tx_id: u32,
76089}
76090
76091impl std::ops::Drop for SynchronousDatagramSocketSetReuseAddressResponder {
76095 fn drop(&mut self) {
76096 self.control_handle.shutdown();
76097 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76099 }
76100}
76101
76102impl fidl::endpoints::Responder for SynchronousDatagramSocketSetReuseAddressResponder {
76103 type ControlHandle = SynchronousDatagramSocketControlHandle;
76104
76105 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76106 &self.control_handle
76107 }
76108
76109 fn drop_without_shutdown(mut self) {
76110 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76112 std::mem::forget(self);
76114 }
76115}
76116
76117impl SynchronousDatagramSocketSetReuseAddressResponder {
76118 pub fn send(
76122 self,
76123 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76124 ) -> Result<(), fidl::Error> {
76125 let _result = self.send_raw(result);
76126 if _result.is_err() {
76127 self.control_handle.shutdown();
76128 }
76129 self.drop_without_shutdown();
76130 _result
76131 }
76132
76133 pub fn send_no_shutdown_on_err(
76135 self,
76136 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76137 ) -> Result<(), fidl::Error> {
76138 let _result = self.send_raw(result);
76139 self.drop_without_shutdown();
76140 _result
76141 }
76142
76143 fn send_raw(
76144 &self,
76145 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76146 ) -> Result<(), fidl::Error> {
76147 self.control_handle.inner.send::<fidl::encoding::ResultType<
76148 fidl::encoding::EmptyStruct,
76149 fidl_fuchsia_posix::Errno,
76150 >>(
76151 result,
76152 self.tx_id,
76153 0x1fd74ee8b9a4a876,
76154 fidl::encoding::DynamicFlags::empty(),
76155 )
76156 }
76157}
76158
76159#[must_use = "FIDL methods require a response to be sent"]
76160#[derive(Debug)]
76161pub struct SynchronousDatagramSocketGetReuseAddressResponder {
76162 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76163 tx_id: u32,
76164}
76165
76166impl std::ops::Drop for SynchronousDatagramSocketGetReuseAddressResponder {
76170 fn drop(&mut self) {
76171 self.control_handle.shutdown();
76172 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76174 }
76175}
76176
76177impl fidl::endpoints::Responder for SynchronousDatagramSocketGetReuseAddressResponder {
76178 type ControlHandle = SynchronousDatagramSocketControlHandle;
76179
76180 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76181 &self.control_handle
76182 }
76183
76184 fn drop_without_shutdown(mut self) {
76185 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76187 std::mem::forget(self);
76189 }
76190}
76191
76192impl SynchronousDatagramSocketGetReuseAddressResponder {
76193 pub fn send(
76197 self,
76198 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76199 ) -> Result<(), fidl::Error> {
76200 let _result = self.send_raw(result);
76201 if _result.is_err() {
76202 self.control_handle.shutdown();
76203 }
76204 self.drop_without_shutdown();
76205 _result
76206 }
76207
76208 pub fn send_no_shutdown_on_err(
76210 self,
76211 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76212 ) -> Result<(), fidl::Error> {
76213 let _result = self.send_raw(result);
76214 self.drop_without_shutdown();
76215 _result
76216 }
76217
76218 fn send_raw(
76219 &self,
76220 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76221 ) -> Result<(), fidl::Error> {
76222 self.control_handle.inner.send::<fidl::encoding::ResultType<
76223 BaseSocketGetReuseAddressResponse,
76224 fidl_fuchsia_posix::Errno,
76225 >>(
76226 result.map(|value| (value,)),
76227 self.tx_id,
76228 0x67b7206b8d1bc0a5,
76229 fidl::encoding::DynamicFlags::empty(),
76230 )
76231 }
76232}
76233
76234#[must_use = "FIDL methods require a response to be sent"]
76235#[derive(Debug)]
76236pub struct SynchronousDatagramSocketGetErrorResponder {
76237 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76238 tx_id: u32,
76239}
76240
76241impl std::ops::Drop for SynchronousDatagramSocketGetErrorResponder {
76245 fn drop(&mut self) {
76246 self.control_handle.shutdown();
76247 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76249 }
76250}
76251
76252impl fidl::endpoints::Responder for SynchronousDatagramSocketGetErrorResponder {
76253 type ControlHandle = SynchronousDatagramSocketControlHandle;
76254
76255 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76256 &self.control_handle
76257 }
76258
76259 fn drop_without_shutdown(mut self) {
76260 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76262 std::mem::forget(self);
76264 }
76265}
76266
76267impl SynchronousDatagramSocketGetErrorResponder {
76268 pub fn send(
76272 self,
76273 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76274 ) -> Result<(), fidl::Error> {
76275 let _result = self.send_raw(result);
76276 if _result.is_err() {
76277 self.control_handle.shutdown();
76278 }
76279 self.drop_without_shutdown();
76280 _result
76281 }
76282
76283 pub fn send_no_shutdown_on_err(
76285 self,
76286 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76287 ) -> Result<(), fidl::Error> {
76288 let _result = self.send_raw(result);
76289 self.drop_without_shutdown();
76290 _result
76291 }
76292
76293 fn send_raw(
76294 &self,
76295 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76296 ) -> Result<(), fidl::Error> {
76297 self.control_handle.inner.send::<fidl::encoding::ResultType<
76298 fidl::encoding::EmptyStruct,
76299 fidl_fuchsia_posix::Errno,
76300 >>(
76301 result,
76302 self.tx_id,
76303 0x5aad39b33e5f6ebb,
76304 fidl::encoding::DynamicFlags::empty(),
76305 )
76306 }
76307}
76308
76309#[must_use = "FIDL methods require a response to be sent"]
76310#[derive(Debug)]
76311pub struct SynchronousDatagramSocketSetBroadcastResponder {
76312 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76313 tx_id: u32,
76314}
76315
76316impl std::ops::Drop for SynchronousDatagramSocketSetBroadcastResponder {
76320 fn drop(&mut self) {
76321 self.control_handle.shutdown();
76322 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76324 }
76325}
76326
76327impl fidl::endpoints::Responder for SynchronousDatagramSocketSetBroadcastResponder {
76328 type ControlHandle = SynchronousDatagramSocketControlHandle;
76329
76330 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76331 &self.control_handle
76332 }
76333
76334 fn drop_without_shutdown(mut self) {
76335 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76337 std::mem::forget(self);
76339 }
76340}
76341
76342impl SynchronousDatagramSocketSetBroadcastResponder {
76343 pub fn send(
76347 self,
76348 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76349 ) -> Result<(), fidl::Error> {
76350 let _result = self.send_raw(result);
76351 if _result.is_err() {
76352 self.control_handle.shutdown();
76353 }
76354 self.drop_without_shutdown();
76355 _result
76356 }
76357
76358 pub fn send_no_shutdown_on_err(
76360 self,
76361 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76362 ) -> Result<(), fidl::Error> {
76363 let _result = self.send_raw(result);
76364 self.drop_without_shutdown();
76365 _result
76366 }
76367
76368 fn send_raw(
76369 &self,
76370 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76371 ) -> Result<(), fidl::Error> {
76372 self.control_handle.inner.send::<fidl::encoding::ResultType<
76373 fidl::encoding::EmptyStruct,
76374 fidl_fuchsia_posix::Errno,
76375 >>(
76376 result,
76377 self.tx_id,
76378 0x6023e081ce3cd947,
76379 fidl::encoding::DynamicFlags::empty(),
76380 )
76381 }
76382}
76383
76384#[must_use = "FIDL methods require a response to be sent"]
76385#[derive(Debug)]
76386pub struct SynchronousDatagramSocketGetBroadcastResponder {
76387 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76388 tx_id: u32,
76389}
76390
76391impl std::ops::Drop for SynchronousDatagramSocketGetBroadcastResponder {
76395 fn drop(&mut self) {
76396 self.control_handle.shutdown();
76397 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76399 }
76400}
76401
76402impl fidl::endpoints::Responder for SynchronousDatagramSocketGetBroadcastResponder {
76403 type ControlHandle = SynchronousDatagramSocketControlHandle;
76404
76405 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76406 &self.control_handle
76407 }
76408
76409 fn drop_without_shutdown(mut self) {
76410 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76412 std::mem::forget(self);
76414 }
76415}
76416
76417impl SynchronousDatagramSocketGetBroadcastResponder {
76418 pub fn send(
76422 self,
76423 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76424 ) -> Result<(), fidl::Error> {
76425 let _result = self.send_raw(result);
76426 if _result.is_err() {
76427 self.control_handle.shutdown();
76428 }
76429 self.drop_without_shutdown();
76430 _result
76431 }
76432
76433 pub fn send_no_shutdown_on_err(
76435 self,
76436 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76437 ) -> Result<(), fidl::Error> {
76438 let _result = self.send_raw(result);
76439 self.drop_without_shutdown();
76440 _result
76441 }
76442
76443 fn send_raw(
76444 &self,
76445 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76446 ) -> Result<(), fidl::Error> {
76447 self.control_handle.inner.send::<fidl::encoding::ResultType<
76448 BaseSocketGetBroadcastResponse,
76449 fidl_fuchsia_posix::Errno,
76450 >>(
76451 result.map(|value| (value,)),
76452 self.tx_id,
76453 0x68796fc556f9780d,
76454 fidl::encoding::DynamicFlags::empty(),
76455 )
76456 }
76457}
76458
76459#[must_use = "FIDL methods require a response to be sent"]
76460#[derive(Debug)]
76461pub struct SynchronousDatagramSocketSetSendBufferResponder {
76462 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76463 tx_id: u32,
76464}
76465
76466impl std::ops::Drop for SynchronousDatagramSocketSetSendBufferResponder {
76470 fn drop(&mut self) {
76471 self.control_handle.shutdown();
76472 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76474 }
76475}
76476
76477impl fidl::endpoints::Responder for SynchronousDatagramSocketSetSendBufferResponder {
76478 type ControlHandle = SynchronousDatagramSocketControlHandle;
76479
76480 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76481 &self.control_handle
76482 }
76483
76484 fn drop_without_shutdown(mut self) {
76485 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76487 std::mem::forget(self);
76489 }
76490}
76491
76492impl SynchronousDatagramSocketSetSendBufferResponder {
76493 pub fn send(
76497 self,
76498 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76499 ) -> Result<(), fidl::Error> {
76500 let _result = self.send_raw(result);
76501 if _result.is_err() {
76502 self.control_handle.shutdown();
76503 }
76504 self.drop_without_shutdown();
76505 _result
76506 }
76507
76508 pub fn send_no_shutdown_on_err(
76510 self,
76511 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76512 ) -> Result<(), fidl::Error> {
76513 let _result = self.send_raw(result);
76514 self.drop_without_shutdown();
76515 _result
76516 }
76517
76518 fn send_raw(
76519 &self,
76520 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76521 ) -> Result<(), fidl::Error> {
76522 self.control_handle.inner.send::<fidl::encoding::ResultType<
76523 fidl::encoding::EmptyStruct,
76524 fidl_fuchsia_posix::Errno,
76525 >>(
76526 result,
76527 self.tx_id,
76528 0x756eac32d73a7a70,
76529 fidl::encoding::DynamicFlags::empty(),
76530 )
76531 }
76532}
76533
76534#[must_use = "FIDL methods require a response to be sent"]
76535#[derive(Debug)]
76536pub struct SynchronousDatagramSocketGetSendBufferResponder {
76537 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76538 tx_id: u32,
76539}
76540
76541impl std::ops::Drop for SynchronousDatagramSocketGetSendBufferResponder {
76545 fn drop(&mut self) {
76546 self.control_handle.shutdown();
76547 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76549 }
76550}
76551
76552impl fidl::endpoints::Responder for SynchronousDatagramSocketGetSendBufferResponder {
76553 type ControlHandle = SynchronousDatagramSocketControlHandle;
76554
76555 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76556 &self.control_handle
76557 }
76558
76559 fn drop_without_shutdown(mut self) {
76560 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76562 std::mem::forget(self);
76564 }
76565}
76566
76567impl SynchronousDatagramSocketGetSendBufferResponder {
76568 pub fn send(
76572 self,
76573 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
76574 ) -> Result<(), fidl::Error> {
76575 let _result = self.send_raw(result);
76576 if _result.is_err() {
76577 self.control_handle.shutdown();
76578 }
76579 self.drop_without_shutdown();
76580 _result
76581 }
76582
76583 pub fn send_no_shutdown_on_err(
76585 self,
76586 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
76587 ) -> Result<(), fidl::Error> {
76588 let _result = self.send_raw(result);
76589 self.drop_without_shutdown();
76590 _result
76591 }
76592
76593 fn send_raw(
76594 &self,
76595 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
76596 ) -> Result<(), fidl::Error> {
76597 self.control_handle.inner.send::<fidl::encoding::ResultType<
76598 BaseSocketGetSendBufferResponse,
76599 fidl_fuchsia_posix::Errno,
76600 >>(
76601 result.map(|value_bytes| (value_bytes,)),
76602 self.tx_id,
76603 0x78a52fd9c7b2410b,
76604 fidl::encoding::DynamicFlags::empty(),
76605 )
76606 }
76607}
76608
76609#[must_use = "FIDL methods require a response to be sent"]
76610#[derive(Debug)]
76611pub struct SynchronousDatagramSocketSetReceiveBufferResponder {
76612 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76613 tx_id: u32,
76614}
76615
76616impl std::ops::Drop for SynchronousDatagramSocketSetReceiveBufferResponder {
76620 fn drop(&mut self) {
76621 self.control_handle.shutdown();
76622 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76624 }
76625}
76626
76627impl fidl::endpoints::Responder for SynchronousDatagramSocketSetReceiveBufferResponder {
76628 type ControlHandle = SynchronousDatagramSocketControlHandle;
76629
76630 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76631 &self.control_handle
76632 }
76633
76634 fn drop_without_shutdown(mut self) {
76635 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76637 std::mem::forget(self);
76639 }
76640}
76641
76642impl SynchronousDatagramSocketSetReceiveBufferResponder {
76643 pub fn send(
76647 self,
76648 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76649 ) -> Result<(), fidl::Error> {
76650 let _result = self.send_raw(result);
76651 if _result.is_err() {
76652 self.control_handle.shutdown();
76653 }
76654 self.drop_without_shutdown();
76655 _result
76656 }
76657
76658 pub fn send_no_shutdown_on_err(
76660 self,
76661 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76662 ) -> Result<(), fidl::Error> {
76663 let _result = self.send_raw(result);
76664 self.drop_without_shutdown();
76665 _result
76666 }
76667
76668 fn send_raw(
76669 &self,
76670 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76671 ) -> Result<(), fidl::Error> {
76672 self.control_handle.inner.send::<fidl::encoding::ResultType<
76673 fidl::encoding::EmptyStruct,
76674 fidl_fuchsia_posix::Errno,
76675 >>(
76676 result,
76677 self.tx_id,
76678 0x6b0cf2f1919c7001,
76679 fidl::encoding::DynamicFlags::empty(),
76680 )
76681 }
76682}
76683
76684#[must_use = "FIDL methods require a response to be sent"]
76685#[derive(Debug)]
76686pub struct SynchronousDatagramSocketGetReceiveBufferResponder {
76687 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76688 tx_id: u32,
76689}
76690
76691impl std::ops::Drop for SynchronousDatagramSocketGetReceiveBufferResponder {
76695 fn drop(&mut self) {
76696 self.control_handle.shutdown();
76697 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76699 }
76700}
76701
76702impl fidl::endpoints::Responder for SynchronousDatagramSocketGetReceiveBufferResponder {
76703 type ControlHandle = SynchronousDatagramSocketControlHandle;
76704
76705 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76706 &self.control_handle
76707 }
76708
76709 fn drop_without_shutdown(mut self) {
76710 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76712 std::mem::forget(self);
76714 }
76715}
76716
76717impl SynchronousDatagramSocketGetReceiveBufferResponder {
76718 pub fn send(
76722 self,
76723 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
76724 ) -> Result<(), fidl::Error> {
76725 let _result = self.send_raw(result);
76726 if _result.is_err() {
76727 self.control_handle.shutdown();
76728 }
76729 self.drop_without_shutdown();
76730 _result
76731 }
76732
76733 pub fn send_no_shutdown_on_err(
76735 self,
76736 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
76737 ) -> Result<(), fidl::Error> {
76738 let _result = self.send_raw(result);
76739 self.drop_without_shutdown();
76740 _result
76741 }
76742
76743 fn send_raw(
76744 &self,
76745 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
76746 ) -> Result<(), fidl::Error> {
76747 self.control_handle.inner.send::<fidl::encoding::ResultType<
76748 BaseSocketGetReceiveBufferResponse,
76749 fidl_fuchsia_posix::Errno,
76750 >>(
76751 result.map(|value_bytes| (value_bytes,)),
76752 self.tx_id,
76753 0x14c1a4b64f709e5c,
76754 fidl::encoding::DynamicFlags::empty(),
76755 )
76756 }
76757}
76758
76759#[must_use = "FIDL methods require a response to be sent"]
76760#[derive(Debug)]
76761pub struct SynchronousDatagramSocketSetKeepAliveResponder {
76762 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76763 tx_id: u32,
76764}
76765
76766impl std::ops::Drop for SynchronousDatagramSocketSetKeepAliveResponder {
76770 fn drop(&mut self) {
76771 self.control_handle.shutdown();
76772 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76774 }
76775}
76776
76777impl fidl::endpoints::Responder for SynchronousDatagramSocketSetKeepAliveResponder {
76778 type ControlHandle = SynchronousDatagramSocketControlHandle;
76779
76780 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76781 &self.control_handle
76782 }
76783
76784 fn drop_without_shutdown(mut self) {
76785 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76787 std::mem::forget(self);
76789 }
76790}
76791
76792impl SynchronousDatagramSocketSetKeepAliveResponder {
76793 pub fn send(
76797 self,
76798 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76799 ) -> Result<(), fidl::Error> {
76800 let _result = self.send_raw(result);
76801 if _result.is_err() {
76802 self.control_handle.shutdown();
76803 }
76804 self.drop_without_shutdown();
76805 _result
76806 }
76807
76808 pub fn send_no_shutdown_on_err(
76810 self,
76811 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76812 ) -> Result<(), fidl::Error> {
76813 let _result = self.send_raw(result);
76814 self.drop_without_shutdown();
76815 _result
76816 }
76817
76818 fn send_raw(
76819 &self,
76820 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76821 ) -> Result<(), fidl::Error> {
76822 self.control_handle.inner.send::<fidl::encoding::ResultType<
76823 fidl::encoding::EmptyStruct,
76824 fidl_fuchsia_posix::Errno,
76825 >>(
76826 result,
76827 self.tx_id,
76828 0x572df8f0b920d2c7,
76829 fidl::encoding::DynamicFlags::empty(),
76830 )
76831 }
76832}
76833
76834#[must_use = "FIDL methods require a response to be sent"]
76835#[derive(Debug)]
76836pub struct SynchronousDatagramSocketGetKeepAliveResponder {
76837 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76838 tx_id: u32,
76839}
76840
76841impl std::ops::Drop for SynchronousDatagramSocketGetKeepAliveResponder {
76845 fn drop(&mut self) {
76846 self.control_handle.shutdown();
76847 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76849 }
76850}
76851
76852impl fidl::endpoints::Responder for SynchronousDatagramSocketGetKeepAliveResponder {
76853 type ControlHandle = SynchronousDatagramSocketControlHandle;
76854
76855 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76856 &self.control_handle
76857 }
76858
76859 fn drop_without_shutdown(mut self) {
76860 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76862 std::mem::forget(self);
76864 }
76865}
76866
76867impl SynchronousDatagramSocketGetKeepAliveResponder {
76868 pub fn send(
76872 self,
76873 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76874 ) -> Result<(), fidl::Error> {
76875 let _result = self.send_raw(result);
76876 if _result.is_err() {
76877 self.control_handle.shutdown();
76878 }
76879 self.drop_without_shutdown();
76880 _result
76881 }
76882
76883 pub fn send_no_shutdown_on_err(
76885 self,
76886 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76887 ) -> Result<(), fidl::Error> {
76888 let _result = self.send_raw(result);
76889 self.drop_without_shutdown();
76890 _result
76891 }
76892
76893 fn send_raw(
76894 &self,
76895 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76896 ) -> Result<(), fidl::Error> {
76897 self.control_handle.inner.send::<fidl::encoding::ResultType<
76898 BaseSocketGetKeepAliveResponse,
76899 fidl_fuchsia_posix::Errno,
76900 >>(
76901 result.map(|value| (value,)),
76902 self.tx_id,
76903 0x2dd29d3215f2c9d2,
76904 fidl::encoding::DynamicFlags::empty(),
76905 )
76906 }
76907}
76908
76909#[must_use = "FIDL methods require a response to be sent"]
76910#[derive(Debug)]
76911pub struct SynchronousDatagramSocketSetOutOfBandInlineResponder {
76912 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76913 tx_id: u32,
76914}
76915
76916impl std::ops::Drop for SynchronousDatagramSocketSetOutOfBandInlineResponder {
76920 fn drop(&mut self) {
76921 self.control_handle.shutdown();
76922 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76924 }
76925}
76926
76927impl fidl::endpoints::Responder for SynchronousDatagramSocketSetOutOfBandInlineResponder {
76928 type ControlHandle = SynchronousDatagramSocketControlHandle;
76929
76930 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76931 &self.control_handle
76932 }
76933
76934 fn drop_without_shutdown(mut self) {
76935 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76937 std::mem::forget(self);
76939 }
76940}
76941
76942impl SynchronousDatagramSocketSetOutOfBandInlineResponder {
76943 pub fn send(
76947 self,
76948 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76949 ) -> Result<(), fidl::Error> {
76950 let _result = self.send_raw(result);
76951 if _result.is_err() {
76952 self.control_handle.shutdown();
76953 }
76954 self.drop_without_shutdown();
76955 _result
76956 }
76957
76958 pub fn send_no_shutdown_on_err(
76960 self,
76961 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76962 ) -> Result<(), fidl::Error> {
76963 let _result = self.send_raw(result);
76964 self.drop_without_shutdown();
76965 _result
76966 }
76967
76968 fn send_raw(
76969 &self,
76970 mut result: Result<(), fidl_fuchsia_posix::Errno>,
76971 ) -> Result<(), fidl::Error> {
76972 self.control_handle.inner.send::<fidl::encoding::ResultType<
76973 fidl::encoding::EmptyStruct,
76974 fidl_fuchsia_posix::Errno,
76975 >>(
76976 result,
76977 self.tx_id,
76978 0x3ecb49968bee439,
76979 fidl::encoding::DynamicFlags::empty(),
76980 )
76981 }
76982}
76983
76984#[must_use = "FIDL methods require a response to be sent"]
76985#[derive(Debug)]
76986pub struct SynchronousDatagramSocketGetOutOfBandInlineResponder {
76987 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76988 tx_id: u32,
76989}
76990
76991impl std::ops::Drop for SynchronousDatagramSocketGetOutOfBandInlineResponder {
76995 fn drop(&mut self) {
76996 self.control_handle.shutdown();
76997 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76999 }
77000}
77001
77002impl fidl::endpoints::Responder for SynchronousDatagramSocketGetOutOfBandInlineResponder {
77003 type ControlHandle = SynchronousDatagramSocketControlHandle;
77004
77005 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77006 &self.control_handle
77007 }
77008
77009 fn drop_without_shutdown(mut self) {
77010 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77012 std::mem::forget(self);
77014 }
77015}
77016
77017impl SynchronousDatagramSocketGetOutOfBandInlineResponder {
77018 pub fn send(
77022 self,
77023 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77024 ) -> Result<(), fidl::Error> {
77025 let _result = self.send_raw(result);
77026 if _result.is_err() {
77027 self.control_handle.shutdown();
77028 }
77029 self.drop_without_shutdown();
77030 _result
77031 }
77032
77033 pub fn send_no_shutdown_on_err(
77035 self,
77036 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77037 ) -> Result<(), fidl::Error> {
77038 let _result = self.send_raw(result);
77039 self.drop_without_shutdown();
77040 _result
77041 }
77042
77043 fn send_raw(
77044 &self,
77045 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77046 ) -> Result<(), fidl::Error> {
77047 self.control_handle.inner.send::<fidl::encoding::ResultType<
77048 BaseSocketGetOutOfBandInlineResponse,
77049 fidl_fuchsia_posix::Errno,
77050 >>(
77051 result.map(|value| (value,)),
77052 self.tx_id,
77053 0x348c1ab3aeca1745,
77054 fidl::encoding::DynamicFlags::empty(),
77055 )
77056 }
77057}
77058
77059#[must_use = "FIDL methods require a response to be sent"]
77060#[derive(Debug)]
77061pub struct SynchronousDatagramSocketSetNoCheckResponder {
77062 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77063 tx_id: u32,
77064}
77065
77066impl std::ops::Drop for SynchronousDatagramSocketSetNoCheckResponder {
77070 fn drop(&mut self) {
77071 self.control_handle.shutdown();
77072 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77074 }
77075}
77076
77077impl fidl::endpoints::Responder for SynchronousDatagramSocketSetNoCheckResponder {
77078 type ControlHandle = SynchronousDatagramSocketControlHandle;
77079
77080 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77081 &self.control_handle
77082 }
77083
77084 fn drop_without_shutdown(mut self) {
77085 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77087 std::mem::forget(self);
77089 }
77090}
77091
77092impl SynchronousDatagramSocketSetNoCheckResponder {
77093 pub fn send(
77097 self,
77098 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77099 ) -> Result<(), fidl::Error> {
77100 let _result = self.send_raw(result);
77101 if _result.is_err() {
77102 self.control_handle.shutdown();
77103 }
77104 self.drop_without_shutdown();
77105 _result
77106 }
77107
77108 pub fn send_no_shutdown_on_err(
77110 self,
77111 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77112 ) -> Result<(), fidl::Error> {
77113 let _result = self.send_raw(result);
77114 self.drop_without_shutdown();
77115 _result
77116 }
77117
77118 fn send_raw(
77119 &self,
77120 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77121 ) -> Result<(), fidl::Error> {
77122 self.control_handle.inner.send::<fidl::encoding::ResultType<
77123 fidl::encoding::EmptyStruct,
77124 fidl_fuchsia_posix::Errno,
77125 >>(
77126 result,
77127 self.tx_id,
77128 0x6bbf00c53a4c78c2,
77129 fidl::encoding::DynamicFlags::empty(),
77130 )
77131 }
77132}
77133
77134#[must_use = "FIDL methods require a response to be sent"]
77135#[derive(Debug)]
77136pub struct SynchronousDatagramSocketGetNoCheckResponder {
77137 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77138 tx_id: u32,
77139}
77140
77141impl std::ops::Drop for SynchronousDatagramSocketGetNoCheckResponder {
77145 fn drop(&mut self) {
77146 self.control_handle.shutdown();
77147 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77149 }
77150}
77151
77152impl fidl::endpoints::Responder for SynchronousDatagramSocketGetNoCheckResponder {
77153 type ControlHandle = SynchronousDatagramSocketControlHandle;
77154
77155 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77156 &self.control_handle
77157 }
77158
77159 fn drop_without_shutdown(mut self) {
77160 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77162 std::mem::forget(self);
77164 }
77165}
77166
77167impl SynchronousDatagramSocketGetNoCheckResponder {
77168 pub fn send(
77172 self,
77173 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77174 ) -> Result<(), fidl::Error> {
77175 let _result = self.send_raw(result);
77176 if _result.is_err() {
77177 self.control_handle.shutdown();
77178 }
77179 self.drop_without_shutdown();
77180 _result
77181 }
77182
77183 pub fn send_no_shutdown_on_err(
77185 self,
77186 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77187 ) -> Result<(), fidl::Error> {
77188 let _result = self.send_raw(result);
77189 self.drop_without_shutdown();
77190 _result
77191 }
77192
77193 fn send_raw(
77194 &self,
77195 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77196 ) -> Result<(), fidl::Error> {
77197 self.control_handle.inner.send::<fidl::encoding::ResultType<
77198 BaseSocketGetNoCheckResponse,
77199 fidl_fuchsia_posix::Errno,
77200 >>(
77201 result.map(|value| (value,)),
77202 self.tx_id,
77203 0x2cd4249286417694,
77204 fidl::encoding::DynamicFlags::empty(),
77205 )
77206 }
77207}
77208
77209#[must_use = "FIDL methods require a response to be sent"]
77210#[derive(Debug)]
77211pub struct SynchronousDatagramSocketSetLingerResponder {
77212 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77213 tx_id: u32,
77214}
77215
77216impl std::ops::Drop for SynchronousDatagramSocketSetLingerResponder {
77220 fn drop(&mut self) {
77221 self.control_handle.shutdown();
77222 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77224 }
77225}
77226
77227impl fidl::endpoints::Responder for SynchronousDatagramSocketSetLingerResponder {
77228 type ControlHandle = SynchronousDatagramSocketControlHandle;
77229
77230 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77231 &self.control_handle
77232 }
77233
77234 fn drop_without_shutdown(mut self) {
77235 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77237 std::mem::forget(self);
77239 }
77240}
77241
77242impl SynchronousDatagramSocketSetLingerResponder {
77243 pub fn send(
77247 self,
77248 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77249 ) -> Result<(), fidl::Error> {
77250 let _result = self.send_raw(result);
77251 if _result.is_err() {
77252 self.control_handle.shutdown();
77253 }
77254 self.drop_without_shutdown();
77255 _result
77256 }
77257
77258 pub fn send_no_shutdown_on_err(
77260 self,
77261 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77262 ) -> Result<(), fidl::Error> {
77263 let _result = self.send_raw(result);
77264 self.drop_without_shutdown();
77265 _result
77266 }
77267
77268 fn send_raw(
77269 &self,
77270 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77271 ) -> Result<(), fidl::Error> {
77272 self.control_handle.inner.send::<fidl::encoding::ResultType<
77273 fidl::encoding::EmptyStruct,
77274 fidl_fuchsia_posix::Errno,
77275 >>(
77276 result,
77277 self.tx_id,
77278 0x45386351246e998e,
77279 fidl::encoding::DynamicFlags::empty(),
77280 )
77281 }
77282}
77283
77284#[must_use = "FIDL methods require a response to be sent"]
77285#[derive(Debug)]
77286pub struct SynchronousDatagramSocketGetLingerResponder {
77287 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77288 tx_id: u32,
77289}
77290
77291impl std::ops::Drop for SynchronousDatagramSocketGetLingerResponder {
77295 fn drop(&mut self) {
77296 self.control_handle.shutdown();
77297 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77299 }
77300}
77301
77302impl fidl::endpoints::Responder for SynchronousDatagramSocketGetLingerResponder {
77303 type ControlHandle = SynchronousDatagramSocketControlHandle;
77304
77305 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77306 &self.control_handle
77307 }
77308
77309 fn drop_without_shutdown(mut self) {
77310 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77312 std::mem::forget(self);
77314 }
77315}
77316
77317impl SynchronousDatagramSocketGetLingerResponder {
77318 pub fn send(
77322 self,
77323 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
77324 ) -> Result<(), fidl::Error> {
77325 let _result = self.send_raw(result);
77326 if _result.is_err() {
77327 self.control_handle.shutdown();
77328 }
77329 self.drop_without_shutdown();
77330 _result
77331 }
77332
77333 pub fn send_no_shutdown_on_err(
77335 self,
77336 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
77337 ) -> Result<(), fidl::Error> {
77338 let _result = self.send_raw(result);
77339 self.drop_without_shutdown();
77340 _result
77341 }
77342
77343 fn send_raw(
77344 &self,
77345 mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
77346 ) -> Result<(), fidl::Error> {
77347 self.control_handle.inner.send::<fidl::encoding::ResultType<
77348 BaseSocketGetLingerResponse,
77349 fidl_fuchsia_posix::Errno,
77350 >>(
77351 result,
77352 self.tx_id,
77353 0x48eb20fc5ccb0e45,
77354 fidl::encoding::DynamicFlags::empty(),
77355 )
77356 }
77357}
77358
77359#[must_use = "FIDL methods require a response to be sent"]
77360#[derive(Debug)]
77361pub struct SynchronousDatagramSocketSetReusePortResponder {
77362 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77363 tx_id: u32,
77364}
77365
77366impl std::ops::Drop for SynchronousDatagramSocketSetReusePortResponder {
77370 fn drop(&mut self) {
77371 self.control_handle.shutdown();
77372 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77374 }
77375}
77376
77377impl fidl::endpoints::Responder for SynchronousDatagramSocketSetReusePortResponder {
77378 type ControlHandle = SynchronousDatagramSocketControlHandle;
77379
77380 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77381 &self.control_handle
77382 }
77383
77384 fn drop_without_shutdown(mut self) {
77385 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77387 std::mem::forget(self);
77389 }
77390}
77391
77392impl SynchronousDatagramSocketSetReusePortResponder {
77393 pub fn send(
77397 self,
77398 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77399 ) -> Result<(), fidl::Error> {
77400 let _result = self.send_raw(result);
77401 if _result.is_err() {
77402 self.control_handle.shutdown();
77403 }
77404 self.drop_without_shutdown();
77405 _result
77406 }
77407
77408 pub fn send_no_shutdown_on_err(
77410 self,
77411 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77412 ) -> Result<(), fidl::Error> {
77413 let _result = self.send_raw(result);
77414 self.drop_without_shutdown();
77415 _result
77416 }
77417
77418 fn send_raw(
77419 &self,
77420 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77421 ) -> Result<(), fidl::Error> {
77422 self.control_handle.inner.send::<fidl::encoding::ResultType<
77423 fidl::encoding::EmptyStruct,
77424 fidl_fuchsia_posix::Errno,
77425 >>(
77426 result,
77427 self.tx_id,
77428 0x24dd3e5cb36d9ccb,
77429 fidl::encoding::DynamicFlags::empty(),
77430 )
77431 }
77432}
77433
77434#[must_use = "FIDL methods require a response to be sent"]
77435#[derive(Debug)]
77436pub struct SynchronousDatagramSocketGetReusePortResponder {
77437 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77438 tx_id: u32,
77439}
77440
77441impl std::ops::Drop for SynchronousDatagramSocketGetReusePortResponder {
77445 fn drop(&mut self) {
77446 self.control_handle.shutdown();
77447 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77449 }
77450}
77451
77452impl fidl::endpoints::Responder for SynchronousDatagramSocketGetReusePortResponder {
77453 type ControlHandle = SynchronousDatagramSocketControlHandle;
77454
77455 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77456 &self.control_handle
77457 }
77458
77459 fn drop_without_shutdown(mut self) {
77460 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77462 std::mem::forget(self);
77464 }
77465}
77466
77467impl SynchronousDatagramSocketGetReusePortResponder {
77468 pub fn send(
77472 self,
77473 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77474 ) -> Result<(), fidl::Error> {
77475 let _result = self.send_raw(result);
77476 if _result.is_err() {
77477 self.control_handle.shutdown();
77478 }
77479 self.drop_without_shutdown();
77480 _result
77481 }
77482
77483 pub fn send_no_shutdown_on_err(
77485 self,
77486 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77487 ) -> Result<(), fidl::Error> {
77488 let _result = self.send_raw(result);
77489 self.drop_without_shutdown();
77490 _result
77491 }
77492
77493 fn send_raw(
77494 &self,
77495 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77496 ) -> Result<(), fidl::Error> {
77497 self.control_handle.inner.send::<fidl::encoding::ResultType<
77498 BaseSocketGetReusePortResponse,
77499 fidl_fuchsia_posix::Errno,
77500 >>(
77501 result.map(|value| (value,)),
77502 self.tx_id,
77503 0x7a112c1ab54ff828,
77504 fidl::encoding::DynamicFlags::empty(),
77505 )
77506 }
77507}
77508
77509#[must_use = "FIDL methods require a response to be sent"]
77510#[derive(Debug)]
77511pub struct SynchronousDatagramSocketGetAcceptConnResponder {
77512 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77513 tx_id: u32,
77514}
77515
77516impl std::ops::Drop for SynchronousDatagramSocketGetAcceptConnResponder {
77520 fn drop(&mut self) {
77521 self.control_handle.shutdown();
77522 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77524 }
77525}
77526
77527impl fidl::endpoints::Responder for SynchronousDatagramSocketGetAcceptConnResponder {
77528 type ControlHandle = SynchronousDatagramSocketControlHandle;
77529
77530 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77531 &self.control_handle
77532 }
77533
77534 fn drop_without_shutdown(mut self) {
77535 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77537 std::mem::forget(self);
77539 }
77540}
77541
77542impl SynchronousDatagramSocketGetAcceptConnResponder {
77543 pub fn send(
77547 self,
77548 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77549 ) -> Result<(), fidl::Error> {
77550 let _result = self.send_raw(result);
77551 if _result.is_err() {
77552 self.control_handle.shutdown();
77553 }
77554 self.drop_without_shutdown();
77555 _result
77556 }
77557
77558 pub fn send_no_shutdown_on_err(
77560 self,
77561 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77562 ) -> Result<(), fidl::Error> {
77563 let _result = self.send_raw(result);
77564 self.drop_without_shutdown();
77565 _result
77566 }
77567
77568 fn send_raw(
77569 &self,
77570 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77571 ) -> Result<(), fidl::Error> {
77572 self.control_handle.inner.send::<fidl::encoding::ResultType<
77573 BaseSocketGetAcceptConnResponse,
77574 fidl_fuchsia_posix::Errno,
77575 >>(
77576 result.map(|value| (value,)),
77577 self.tx_id,
77578 0x67ce6db6c2ec8966,
77579 fidl::encoding::DynamicFlags::empty(),
77580 )
77581 }
77582}
77583
77584#[must_use = "FIDL methods require a response to be sent"]
77585#[derive(Debug)]
77586pub struct SynchronousDatagramSocketSetBindToDeviceResponder {
77587 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77588 tx_id: u32,
77589}
77590
77591impl std::ops::Drop for SynchronousDatagramSocketSetBindToDeviceResponder {
77595 fn drop(&mut self) {
77596 self.control_handle.shutdown();
77597 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77599 }
77600}
77601
77602impl fidl::endpoints::Responder for SynchronousDatagramSocketSetBindToDeviceResponder {
77603 type ControlHandle = SynchronousDatagramSocketControlHandle;
77604
77605 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77606 &self.control_handle
77607 }
77608
77609 fn drop_without_shutdown(mut self) {
77610 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77612 std::mem::forget(self);
77614 }
77615}
77616
77617impl SynchronousDatagramSocketSetBindToDeviceResponder {
77618 pub fn send(
77622 self,
77623 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77624 ) -> Result<(), fidl::Error> {
77625 let _result = self.send_raw(result);
77626 if _result.is_err() {
77627 self.control_handle.shutdown();
77628 }
77629 self.drop_without_shutdown();
77630 _result
77631 }
77632
77633 pub fn send_no_shutdown_on_err(
77635 self,
77636 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77637 ) -> Result<(), fidl::Error> {
77638 let _result = self.send_raw(result);
77639 self.drop_without_shutdown();
77640 _result
77641 }
77642
77643 fn send_raw(
77644 &self,
77645 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77646 ) -> Result<(), fidl::Error> {
77647 self.control_handle.inner.send::<fidl::encoding::ResultType<
77648 fidl::encoding::EmptyStruct,
77649 fidl_fuchsia_posix::Errno,
77650 >>(
77651 result,
77652 self.tx_id,
77653 0x2118b483f28aafc4,
77654 fidl::encoding::DynamicFlags::empty(),
77655 )
77656 }
77657}
77658
77659#[must_use = "FIDL methods require a response to be sent"]
77660#[derive(Debug)]
77661pub struct SynchronousDatagramSocketGetBindToDeviceResponder {
77662 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77663 tx_id: u32,
77664}
77665
77666impl std::ops::Drop for SynchronousDatagramSocketGetBindToDeviceResponder {
77670 fn drop(&mut self) {
77671 self.control_handle.shutdown();
77672 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77674 }
77675}
77676
77677impl fidl::endpoints::Responder for SynchronousDatagramSocketGetBindToDeviceResponder {
77678 type ControlHandle = SynchronousDatagramSocketControlHandle;
77679
77680 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77681 &self.control_handle
77682 }
77683
77684 fn drop_without_shutdown(mut self) {
77685 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77687 std::mem::forget(self);
77689 }
77690}
77691
77692impl SynchronousDatagramSocketGetBindToDeviceResponder {
77693 pub fn send(
77697 self,
77698 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
77699 ) -> Result<(), fidl::Error> {
77700 let _result = self.send_raw(result);
77701 if _result.is_err() {
77702 self.control_handle.shutdown();
77703 }
77704 self.drop_without_shutdown();
77705 _result
77706 }
77707
77708 pub fn send_no_shutdown_on_err(
77710 self,
77711 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
77712 ) -> Result<(), fidl::Error> {
77713 let _result = self.send_raw(result);
77714 self.drop_without_shutdown();
77715 _result
77716 }
77717
77718 fn send_raw(
77719 &self,
77720 mut result: Result<&str, fidl_fuchsia_posix::Errno>,
77721 ) -> Result<(), fidl::Error> {
77722 self.control_handle.inner.send::<fidl::encoding::ResultType<
77723 BaseSocketGetBindToDeviceResponse,
77724 fidl_fuchsia_posix::Errno,
77725 >>(
77726 result.map(|value| (value,)),
77727 self.tx_id,
77728 0x1ab1fbf0ef7906c8,
77729 fidl::encoding::DynamicFlags::empty(),
77730 )
77731 }
77732}
77733
77734#[must_use = "FIDL methods require a response to be sent"]
77735#[derive(Debug)]
77736pub struct SynchronousDatagramSocketSetBindToInterfaceIndexResponder {
77737 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77738 tx_id: u32,
77739}
77740
77741impl std::ops::Drop for SynchronousDatagramSocketSetBindToInterfaceIndexResponder {
77745 fn drop(&mut self) {
77746 self.control_handle.shutdown();
77747 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77749 }
77750}
77751
77752impl fidl::endpoints::Responder for SynchronousDatagramSocketSetBindToInterfaceIndexResponder {
77753 type ControlHandle = SynchronousDatagramSocketControlHandle;
77754
77755 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77756 &self.control_handle
77757 }
77758
77759 fn drop_without_shutdown(mut self) {
77760 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77762 std::mem::forget(self);
77764 }
77765}
77766
77767impl SynchronousDatagramSocketSetBindToInterfaceIndexResponder {
77768 pub fn send(
77772 self,
77773 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77774 ) -> Result<(), fidl::Error> {
77775 let _result = self.send_raw(result);
77776 if _result.is_err() {
77777 self.control_handle.shutdown();
77778 }
77779 self.drop_without_shutdown();
77780 _result
77781 }
77782
77783 pub fn send_no_shutdown_on_err(
77785 self,
77786 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77787 ) -> Result<(), fidl::Error> {
77788 let _result = self.send_raw(result);
77789 self.drop_without_shutdown();
77790 _result
77791 }
77792
77793 fn send_raw(
77794 &self,
77795 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77796 ) -> Result<(), fidl::Error> {
77797 self.control_handle.inner.send::<fidl::encoding::ResultType<
77798 fidl::encoding::EmptyStruct,
77799 fidl_fuchsia_posix::Errno,
77800 >>(
77801 result,
77802 self.tx_id,
77803 0x6e387a0def00821,
77804 fidl::encoding::DynamicFlags::empty(),
77805 )
77806 }
77807}
77808
77809#[must_use = "FIDL methods require a response to be sent"]
77810#[derive(Debug)]
77811pub struct SynchronousDatagramSocketGetBindToInterfaceIndexResponder {
77812 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77813 tx_id: u32,
77814}
77815
77816impl std::ops::Drop for SynchronousDatagramSocketGetBindToInterfaceIndexResponder {
77820 fn drop(&mut self) {
77821 self.control_handle.shutdown();
77822 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77824 }
77825}
77826
77827impl fidl::endpoints::Responder for SynchronousDatagramSocketGetBindToInterfaceIndexResponder {
77828 type ControlHandle = SynchronousDatagramSocketControlHandle;
77829
77830 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77831 &self.control_handle
77832 }
77833
77834 fn drop_without_shutdown(mut self) {
77835 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77837 std::mem::forget(self);
77839 }
77840}
77841
77842impl SynchronousDatagramSocketGetBindToInterfaceIndexResponder {
77843 pub fn send(
77847 self,
77848 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
77849 ) -> Result<(), fidl::Error> {
77850 let _result = self.send_raw(result);
77851 if _result.is_err() {
77852 self.control_handle.shutdown();
77853 }
77854 self.drop_without_shutdown();
77855 _result
77856 }
77857
77858 pub fn send_no_shutdown_on_err(
77860 self,
77861 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
77862 ) -> Result<(), fidl::Error> {
77863 let _result = self.send_raw(result);
77864 self.drop_without_shutdown();
77865 _result
77866 }
77867
77868 fn send_raw(
77869 &self,
77870 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
77871 ) -> Result<(), fidl::Error> {
77872 self.control_handle.inner.send::<fidl::encoding::ResultType<
77873 BaseSocketGetBindToInterfaceIndexResponse,
77874 fidl_fuchsia_posix::Errno,
77875 >>(
77876 result.map(|value| (value,)),
77877 self.tx_id,
77878 0x59c31dd3e3078295,
77879 fidl::encoding::DynamicFlags::empty(),
77880 )
77881 }
77882}
77883
77884#[must_use = "FIDL methods require a response to be sent"]
77885#[derive(Debug)]
77886pub struct SynchronousDatagramSocketSetTimestampResponder {
77887 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77888 tx_id: u32,
77889}
77890
77891impl std::ops::Drop for SynchronousDatagramSocketSetTimestampResponder {
77895 fn drop(&mut self) {
77896 self.control_handle.shutdown();
77897 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77899 }
77900}
77901
77902impl fidl::endpoints::Responder for SynchronousDatagramSocketSetTimestampResponder {
77903 type ControlHandle = SynchronousDatagramSocketControlHandle;
77904
77905 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77906 &self.control_handle
77907 }
77908
77909 fn drop_without_shutdown(mut self) {
77910 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77912 std::mem::forget(self);
77914 }
77915}
77916
77917impl SynchronousDatagramSocketSetTimestampResponder {
77918 pub fn send(
77922 self,
77923 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77924 ) -> Result<(), fidl::Error> {
77925 let _result = self.send_raw(result);
77926 if _result.is_err() {
77927 self.control_handle.shutdown();
77928 }
77929 self.drop_without_shutdown();
77930 _result
77931 }
77932
77933 pub fn send_no_shutdown_on_err(
77935 self,
77936 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77937 ) -> Result<(), fidl::Error> {
77938 let _result = self.send_raw(result);
77939 self.drop_without_shutdown();
77940 _result
77941 }
77942
77943 fn send_raw(
77944 &self,
77945 mut result: Result<(), fidl_fuchsia_posix::Errno>,
77946 ) -> Result<(), fidl::Error> {
77947 self.control_handle.inner.send::<fidl::encoding::ResultType<
77948 fidl::encoding::EmptyStruct,
77949 fidl_fuchsia_posix::Errno,
77950 >>(
77951 result,
77952 self.tx_id,
77953 0x285d6516c263d839,
77954 fidl::encoding::DynamicFlags::empty(),
77955 )
77956 }
77957}
77958
77959#[must_use = "FIDL methods require a response to be sent"]
77960#[derive(Debug)]
77961pub struct SynchronousDatagramSocketGetTimestampResponder {
77962 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77963 tx_id: u32,
77964}
77965
77966impl std::ops::Drop for SynchronousDatagramSocketGetTimestampResponder {
77970 fn drop(&mut self) {
77971 self.control_handle.shutdown();
77972 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77974 }
77975}
77976
77977impl fidl::endpoints::Responder for SynchronousDatagramSocketGetTimestampResponder {
77978 type ControlHandle = SynchronousDatagramSocketControlHandle;
77979
77980 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77981 &self.control_handle
77982 }
77983
77984 fn drop_without_shutdown(mut self) {
77985 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77987 std::mem::forget(self);
77989 }
77990}
77991
77992impl SynchronousDatagramSocketGetTimestampResponder {
77993 pub fn send(
77997 self,
77998 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
77999 ) -> Result<(), fidl::Error> {
78000 let _result = self.send_raw(result);
78001 if _result.is_err() {
78002 self.control_handle.shutdown();
78003 }
78004 self.drop_without_shutdown();
78005 _result
78006 }
78007
78008 pub fn send_no_shutdown_on_err(
78010 self,
78011 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
78012 ) -> Result<(), fidl::Error> {
78013 let _result = self.send_raw(result);
78014 self.drop_without_shutdown();
78015 _result
78016 }
78017
78018 fn send_raw(
78019 &self,
78020 mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
78021 ) -> Result<(), fidl::Error> {
78022 self.control_handle.inner.send::<fidl::encoding::ResultType<
78023 BaseSocketGetTimestampResponse,
78024 fidl_fuchsia_posix::Errno,
78025 >>(
78026 result.map(|value| (value,)),
78027 self.tx_id,
78028 0x49f2fffbbcc2bd27,
78029 fidl::encoding::DynamicFlags::empty(),
78030 )
78031 }
78032}
78033
78034#[must_use = "FIDL methods require a response to be sent"]
78035#[derive(Debug)]
78036pub struct SynchronousDatagramSocketSetMarkResponder {
78037 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78038 tx_id: u32,
78039}
78040
78041impl std::ops::Drop for SynchronousDatagramSocketSetMarkResponder {
78045 fn drop(&mut self) {
78046 self.control_handle.shutdown();
78047 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78049 }
78050}
78051
78052impl fidl::endpoints::Responder for SynchronousDatagramSocketSetMarkResponder {
78053 type ControlHandle = SynchronousDatagramSocketControlHandle;
78054
78055 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78056 &self.control_handle
78057 }
78058
78059 fn drop_without_shutdown(mut self) {
78060 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78062 std::mem::forget(self);
78064 }
78065}
78066
78067impl SynchronousDatagramSocketSetMarkResponder {
78068 pub fn send(
78072 self,
78073 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78074 ) -> Result<(), fidl::Error> {
78075 let _result = self.send_raw(result);
78076 if _result.is_err() {
78077 self.control_handle.shutdown();
78078 }
78079 self.drop_without_shutdown();
78080 _result
78081 }
78082
78083 pub fn send_no_shutdown_on_err(
78085 self,
78086 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78087 ) -> Result<(), fidl::Error> {
78088 let _result = self.send_raw(result);
78089 self.drop_without_shutdown();
78090 _result
78091 }
78092
78093 fn send_raw(
78094 &self,
78095 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78096 ) -> Result<(), fidl::Error> {
78097 self.control_handle.inner.send::<fidl::encoding::ResultType<
78098 fidl::encoding::EmptyStruct,
78099 fidl_fuchsia_posix::Errno,
78100 >>(
78101 result,
78102 self.tx_id,
78103 0x6ead6de09f653236,
78104 fidl::encoding::DynamicFlags::empty(),
78105 )
78106 }
78107}
78108
78109#[must_use = "FIDL methods require a response to be sent"]
78110#[derive(Debug)]
78111pub struct SynchronousDatagramSocketGetMarkResponder {
78112 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78113 tx_id: u32,
78114}
78115
78116impl std::ops::Drop for SynchronousDatagramSocketGetMarkResponder {
78120 fn drop(&mut self) {
78121 self.control_handle.shutdown();
78122 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78124 }
78125}
78126
78127impl fidl::endpoints::Responder for SynchronousDatagramSocketGetMarkResponder {
78128 type ControlHandle = SynchronousDatagramSocketControlHandle;
78129
78130 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78131 &self.control_handle
78132 }
78133
78134 fn drop_without_shutdown(mut self) {
78135 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78137 std::mem::forget(self);
78139 }
78140}
78141
78142impl SynchronousDatagramSocketGetMarkResponder {
78143 pub fn send(
78147 self,
78148 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
78149 ) -> Result<(), fidl::Error> {
78150 let _result = self.send_raw(result);
78151 if _result.is_err() {
78152 self.control_handle.shutdown();
78153 }
78154 self.drop_without_shutdown();
78155 _result
78156 }
78157
78158 pub fn send_no_shutdown_on_err(
78160 self,
78161 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
78162 ) -> Result<(), fidl::Error> {
78163 let _result = self.send_raw(result);
78164 self.drop_without_shutdown();
78165 _result
78166 }
78167
78168 fn send_raw(
78169 &self,
78170 mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
78171 ) -> Result<(), fidl::Error> {
78172 self.control_handle.inner.send::<fidl::encoding::ResultType<
78173 BaseSocketGetMarkResponse,
78174 fidl_fuchsia_posix::Errno,
78175 >>(
78176 result.map(|mark| (mark,)),
78177 self.tx_id,
78178 0x57a2752c61d93d47,
78179 fidl::encoding::DynamicFlags::empty(),
78180 )
78181 }
78182}
78183
78184#[must_use = "FIDL methods require a response to be sent"]
78185#[derive(Debug)]
78186pub struct SynchronousDatagramSocketBindResponder {
78187 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78188 tx_id: u32,
78189}
78190
78191impl std::ops::Drop for SynchronousDatagramSocketBindResponder {
78195 fn drop(&mut self) {
78196 self.control_handle.shutdown();
78197 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78199 }
78200}
78201
78202impl fidl::endpoints::Responder for SynchronousDatagramSocketBindResponder {
78203 type ControlHandle = SynchronousDatagramSocketControlHandle;
78204
78205 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78206 &self.control_handle
78207 }
78208
78209 fn drop_without_shutdown(mut self) {
78210 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78212 std::mem::forget(self);
78214 }
78215}
78216
78217impl SynchronousDatagramSocketBindResponder {
78218 pub fn send(
78222 self,
78223 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78224 ) -> Result<(), fidl::Error> {
78225 let _result = self.send_raw(result);
78226 if _result.is_err() {
78227 self.control_handle.shutdown();
78228 }
78229 self.drop_without_shutdown();
78230 _result
78231 }
78232
78233 pub fn send_no_shutdown_on_err(
78235 self,
78236 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78237 ) -> Result<(), fidl::Error> {
78238 let _result = self.send_raw(result);
78239 self.drop_without_shutdown();
78240 _result
78241 }
78242
78243 fn send_raw(
78244 &self,
78245 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78246 ) -> Result<(), fidl::Error> {
78247 self.control_handle.inner.send::<fidl::encoding::ResultType<
78248 fidl::encoding::EmptyStruct,
78249 fidl_fuchsia_posix::Errno,
78250 >>(
78251 result,
78252 self.tx_id,
78253 0x4bc6400ae92125d,
78254 fidl::encoding::DynamicFlags::empty(),
78255 )
78256 }
78257}
78258
78259#[must_use = "FIDL methods require a response to be sent"]
78260#[derive(Debug)]
78261pub struct SynchronousDatagramSocketConnectResponder {
78262 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78263 tx_id: u32,
78264}
78265
78266impl std::ops::Drop for SynchronousDatagramSocketConnectResponder {
78270 fn drop(&mut self) {
78271 self.control_handle.shutdown();
78272 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78274 }
78275}
78276
78277impl fidl::endpoints::Responder for SynchronousDatagramSocketConnectResponder {
78278 type ControlHandle = SynchronousDatagramSocketControlHandle;
78279
78280 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78281 &self.control_handle
78282 }
78283
78284 fn drop_without_shutdown(mut self) {
78285 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78287 std::mem::forget(self);
78289 }
78290}
78291
78292impl SynchronousDatagramSocketConnectResponder {
78293 pub fn send(
78297 self,
78298 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78299 ) -> Result<(), fidl::Error> {
78300 let _result = self.send_raw(result);
78301 if _result.is_err() {
78302 self.control_handle.shutdown();
78303 }
78304 self.drop_without_shutdown();
78305 _result
78306 }
78307
78308 pub fn send_no_shutdown_on_err(
78310 self,
78311 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78312 ) -> Result<(), fidl::Error> {
78313 let _result = self.send_raw(result);
78314 self.drop_without_shutdown();
78315 _result
78316 }
78317
78318 fn send_raw(
78319 &self,
78320 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78321 ) -> Result<(), fidl::Error> {
78322 self.control_handle.inner.send::<fidl::encoding::ResultType<
78323 fidl::encoding::EmptyStruct,
78324 fidl_fuchsia_posix::Errno,
78325 >>(
78326 result,
78327 self.tx_id,
78328 0x5f05f19bfdd38871,
78329 fidl::encoding::DynamicFlags::empty(),
78330 )
78331 }
78332}
78333
78334#[must_use = "FIDL methods require a response to be sent"]
78335#[derive(Debug)]
78336pub struct SynchronousDatagramSocketDisconnectResponder {
78337 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78338 tx_id: u32,
78339}
78340
78341impl std::ops::Drop for SynchronousDatagramSocketDisconnectResponder {
78345 fn drop(&mut self) {
78346 self.control_handle.shutdown();
78347 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78349 }
78350}
78351
78352impl fidl::endpoints::Responder for SynchronousDatagramSocketDisconnectResponder {
78353 type ControlHandle = SynchronousDatagramSocketControlHandle;
78354
78355 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78356 &self.control_handle
78357 }
78358
78359 fn drop_without_shutdown(mut self) {
78360 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78362 std::mem::forget(self);
78364 }
78365}
78366
78367impl SynchronousDatagramSocketDisconnectResponder {
78368 pub fn send(
78372 self,
78373 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78374 ) -> Result<(), fidl::Error> {
78375 let _result = self.send_raw(result);
78376 if _result.is_err() {
78377 self.control_handle.shutdown();
78378 }
78379 self.drop_without_shutdown();
78380 _result
78381 }
78382
78383 pub fn send_no_shutdown_on_err(
78385 self,
78386 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78387 ) -> Result<(), fidl::Error> {
78388 let _result = self.send_raw(result);
78389 self.drop_without_shutdown();
78390 _result
78391 }
78392
78393 fn send_raw(
78394 &self,
78395 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78396 ) -> Result<(), fidl::Error> {
78397 self.control_handle.inner.send::<fidl::encoding::ResultType<
78398 fidl::encoding::EmptyStruct,
78399 fidl_fuchsia_posix::Errno,
78400 >>(
78401 result,
78402 self.tx_id,
78403 0x74e63b91f7b29b2,
78404 fidl::encoding::DynamicFlags::empty(),
78405 )
78406 }
78407}
78408
78409#[must_use = "FIDL methods require a response to be sent"]
78410#[derive(Debug)]
78411pub struct SynchronousDatagramSocketGetSockNameResponder {
78412 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78413 tx_id: u32,
78414}
78415
78416impl std::ops::Drop for SynchronousDatagramSocketGetSockNameResponder {
78420 fn drop(&mut self) {
78421 self.control_handle.shutdown();
78422 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78424 }
78425}
78426
78427impl fidl::endpoints::Responder for SynchronousDatagramSocketGetSockNameResponder {
78428 type ControlHandle = SynchronousDatagramSocketControlHandle;
78429
78430 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78431 &self.control_handle
78432 }
78433
78434 fn drop_without_shutdown(mut self) {
78435 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78437 std::mem::forget(self);
78439 }
78440}
78441
78442impl SynchronousDatagramSocketGetSockNameResponder {
78443 pub fn send(
78447 self,
78448 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
78449 ) -> Result<(), fidl::Error> {
78450 let _result = self.send_raw(result);
78451 if _result.is_err() {
78452 self.control_handle.shutdown();
78453 }
78454 self.drop_without_shutdown();
78455 _result
78456 }
78457
78458 pub fn send_no_shutdown_on_err(
78460 self,
78461 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
78462 ) -> Result<(), fidl::Error> {
78463 let _result = self.send_raw(result);
78464 self.drop_without_shutdown();
78465 _result
78466 }
78467
78468 fn send_raw(
78469 &self,
78470 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
78471 ) -> Result<(), fidl::Error> {
78472 self.control_handle.inner.send::<fidl::encoding::ResultType<
78473 BaseNetworkSocketGetSockNameResponse,
78474 fidl_fuchsia_posix::Errno,
78475 >>(
78476 result.map(|addr| (addr,)),
78477 self.tx_id,
78478 0x475f23f84a1a4f85,
78479 fidl::encoding::DynamicFlags::empty(),
78480 )
78481 }
78482}
78483
78484#[must_use = "FIDL methods require a response to be sent"]
78485#[derive(Debug)]
78486pub struct SynchronousDatagramSocketGetPeerNameResponder {
78487 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78488 tx_id: u32,
78489}
78490
78491impl std::ops::Drop for SynchronousDatagramSocketGetPeerNameResponder {
78495 fn drop(&mut self) {
78496 self.control_handle.shutdown();
78497 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78499 }
78500}
78501
78502impl fidl::endpoints::Responder for SynchronousDatagramSocketGetPeerNameResponder {
78503 type ControlHandle = SynchronousDatagramSocketControlHandle;
78504
78505 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78506 &self.control_handle
78507 }
78508
78509 fn drop_without_shutdown(mut self) {
78510 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78512 std::mem::forget(self);
78514 }
78515}
78516
78517impl SynchronousDatagramSocketGetPeerNameResponder {
78518 pub fn send(
78522 self,
78523 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
78524 ) -> Result<(), fidl::Error> {
78525 let _result = self.send_raw(result);
78526 if _result.is_err() {
78527 self.control_handle.shutdown();
78528 }
78529 self.drop_without_shutdown();
78530 _result
78531 }
78532
78533 pub fn send_no_shutdown_on_err(
78535 self,
78536 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
78537 ) -> Result<(), fidl::Error> {
78538 let _result = self.send_raw(result);
78539 self.drop_without_shutdown();
78540 _result
78541 }
78542
78543 fn send_raw(
78544 &self,
78545 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
78546 ) -> Result<(), fidl::Error> {
78547 self.control_handle.inner.send::<fidl::encoding::ResultType<
78548 BaseNetworkSocketGetPeerNameResponse,
78549 fidl_fuchsia_posix::Errno,
78550 >>(
78551 result.map(|addr| (addr,)),
78552 self.tx_id,
78553 0x1ffecf4bd5b6432e,
78554 fidl::encoding::DynamicFlags::empty(),
78555 )
78556 }
78557}
78558
78559#[must_use = "FIDL methods require a response to be sent"]
78560#[derive(Debug)]
78561pub struct SynchronousDatagramSocketShutdownResponder {
78562 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78563 tx_id: u32,
78564}
78565
78566impl std::ops::Drop for SynchronousDatagramSocketShutdownResponder {
78570 fn drop(&mut self) {
78571 self.control_handle.shutdown();
78572 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78574 }
78575}
78576
78577impl fidl::endpoints::Responder for SynchronousDatagramSocketShutdownResponder {
78578 type ControlHandle = SynchronousDatagramSocketControlHandle;
78579
78580 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78581 &self.control_handle
78582 }
78583
78584 fn drop_without_shutdown(mut self) {
78585 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78587 std::mem::forget(self);
78589 }
78590}
78591
78592impl SynchronousDatagramSocketShutdownResponder {
78593 pub fn send(
78597 self,
78598 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78599 ) -> Result<(), fidl::Error> {
78600 let _result = self.send_raw(result);
78601 if _result.is_err() {
78602 self.control_handle.shutdown();
78603 }
78604 self.drop_without_shutdown();
78605 _result
78606 }
78607
78608 pub fn send_no_shutdown_on_err(
78610 self,
78611 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78612 ) -> Result<(), fidl::Error> {
78613 let _result = self.send_raw(result);
78614 self.drop_without_shutdown();
78615 _result
78616 }
78617
78618 fn send_raw(
78619 &self,
78620 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78621 ) -> Result<(), fidl::Error> {
78622 self.control_handle.inner.send::<fidl::encoding::ResultType<
78623 fidl::encoding::EmptyStruct,
78624 fidl_fuchsia_posix::Errno,
78625 >>(
78626 result,
78627 self.tx_id,
78628 0x247f38b6db68c336,
78629 fidl::encoding::DynamicFlags::empty(),
78630 )
78631 }
78632}
78633
78634#[must_use = "FIDL methods require a response to be sent"]
78635#[derive(Debug)]
78636pub struct SynchronousDatagramSocketSetIpTypeOfServiceResponder {
78637 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78638 tx_id: u32,
78639}
78640
78641impl std::ops::Drop for SynchronousDatagramSocketSetIpTypeOfServiceResponder {
78645 fn drop(&mut self) {
78646 self.control_handle.shutdown();
78647 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78649 }
78650}
78651
78652impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpTypeOfServiceResponder {
78653 type ControlHandle = SynchronousDatagramSocketControlHandle;
78654
78655 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78656 &self.control_handle
78657 }
78658
78659 fn drop_without_shutdown(mut self) {
78660 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78662 std::mem::forget(self);
78664 }
78665}
78666
78667impl SynchronousDatagramSocketSetIpTypeOfServiceResponder {
78668 pub fn send(
78672 self,
78673 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78674 ) -> Result<(), fidl::Error> {
78675 let _result = self.send_raw(result);
78676 if _result.is_err() {
78677 self.control_handle.shutdown();
78678 }
78679 self.drop_without_shutdown();
78680 _result
78681 }
78682
78683 pub fn send_no_shutdown_on_err(
78685 self,
78686 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78687 ) -> Result<(), fidl::Error> {
78688 let _result = self.send_raw(result);
78689 self.drop_without_shutdown();
78690 _result
78691 }
78692
78693 fn send_raw(
78694 &self,
78695 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78696 ) -> Result<(), fidl::Error> {
78697 self.control_handle.inner.send::<fidl::encoding::ResultType<
78698 fidl::encoding::EmptyStruct,
78699 fidl_fuchsia_posix::Errno,
78700 >>(
78701 result,
78702 self.tx_id,
78703 0x995c600475b6d46,
78704 fidl::encoding::DynamicFlags::empty(),
78705 )
78706 }
78707}
78708
78709#[must_use = "FIDL methods require a response to be sent"]
78710#[derive(Debug)]
78711pub struct SynchronousDatagramSocketGetIpTypeOfServiceResponder {
78712 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78713 tx_id: u32,
78714}
78715
78716impl std::ops::Drop for SynchronousDatagramSocketGetIpTypeOfServiceResponder {
78720 fn drop(&mut self) {
78721 self.control_handle.shutdown();
78722 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78724 }
78725}
78726
78727impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpTypeOfServiceResponder {
78728 type ControlHandle = SynchronousDatagramSocketControlHandle;
78729
78730 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78731 &self.control_handle
78732 }
78733
78734 fn drop_without_shutdown(mut self) {
78735 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78737 std::mem::forget(self);
78739 }
78740}
78741
78742impl SynchronousDatagramSocketGetIpTypeOfServiceResponder {
78743 pub fn send(
78747 self,
78748 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
78749 ) -> Result<(), fidl::Error> {
78750 let _result = self.send_raw(result);
78751 if _result.is_err() {
78752 self.control_handle.shutdown();
78753 }
78754 self.drop_without_shutdown();
78755 _result
78756 }
78757
78758 pub fn send_no_shutdown_on_err(
78760 self,
78761 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
78762 ) -> Result<(), fidl::Error> {
78763 let _result = self.send_raw(result);
78764 self.drop_without_shutdown();
78765 _result
78766 }
78767
78768 fn send_raw(
78769 &self,
78770 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
78771 ) -> Result<(), fidl::Error> {
78772 self.control_handle.inner.send::<fidl::encoding::ResultType<
78773 BaseNetworkSocketGetIpTypeOfServiceResponse,
78774 fidl_fuchsia_posix::Errno,
78775 >>(
78776 result.map(|value| (value,)),
78777 self.tx_id,
78778 0x3814a04259f75fcb,
78779 fidl::encoding::DynamicFlags::empty(),
78780 )
78781 }
78782}
78783
78784#[must_use = "FIDL methods require a response to be sent"]
78785#[derive(Debug)]
78786pub struct SynchronousDatagramSocketSetIpTtlResponder {
78787 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78788 tx_id: u32,
78789}
78790
78791impl std::ops::Drop for SynchronousDatagramSocketSetIpTtlResponder {
78795 fn drop(&mut self) {
78796 self.control_handle.shutdown();
78797 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78799 }
78800}
78801
78802impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpTtlResponder {
78803 type ControlHandle = SynchronousDatagramSocketControlHandle;
78804
78805 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78806 &self.control_handle
78807 }
78808
78809 fn drop_without_shutdown(mut self) {
78810 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78812 std::mem::forget(self);
78814 }
78815}
78816
78817impl SynchronousDatagramSocketSetIpTtlResponder {
78818 pub fn send(
78822 self,
78823 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78824 ) -> Result<(), fidl::Error> {
78825 let _result = self.send_raw(result);
78826 if _result.is_err() {
78827 self.control_handle.shutdown();
78828 }
78829 self.drop_without_shutdown();
78830 _result
78831 }
78832
78833 pub fn send_no_shutdown_on_err(
78835 self,
78836 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78837 ) -> Result<(), fidl::Error> {
78838 let _result = self.send_raw(result);
78839 self.drop_without_shutdown();
78840 _result
78841 }
78842
78843 fn send_raw(
78844 &self,
78845 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78846 ) -> Result<(), fidl::Error> {
78847 self.control_handle.inner.send::<fidl::encoding::ResultType<
78848 fidl::encoding::EmptyStruct,
78849 fidl_fuchsia_posix::Errno,
78850 >>(
78851 result,
78852 self.tx_id,
78853 0x29e2424b433ae1ef,
78854 fidl::encoding::DynamicFlags::empty(),
78855 )
78856 }
78857}
78858
78859#[must_use = "FIDL methods require a response to be sent"]
78860#[derive(Debug)]
78861pub struct SynchronousDatagramSocketGetIpTtlResponder {
78862 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78863 tx_id: u32,
78864}
78865
78866impl std::ops::Drop for SynchronousDatagramSocketGetIpTtlResponder {
78870 fn drop(&mut self) {
78871 self.control_handle.shutdown();
78872 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78874 }
78875}
78876
78877impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpTtlResponder {
78878 type ControlHandle = SynchronousDatagramSocketControlHandle;
78879
78880 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78881 &self.control_handle
78882 }
78883
78884 fn drop_without_shutdown(mut self) {
78885 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78887 std::mem::forget(self);
78889 }
78890}
78891
78892impl SynchronousDatagramSocketGetIpTtlResponder {
78893 pub fn send(
78897 self,
78898 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
78899 ) -> Result<(), fidl::Error> {
78900 let _result = self.send_raw(result);
78901 if _result.is_err() {
78902 self.control_handle.shutdown();
78903 }
78904 self.drop_without_shutdown();
78905 _result
78906 }
78907
78908 pub fn send_no_shutdown_on_err(
78910 self,
78911 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
78912 ) -> Result<(), fidl::Error> {
78913 let _result = self.send_raw(result);
78914 self.drop_without_shutdown();
78915 _result
78916 }
78917
78918 fn send_raw(
78919 &self,
78920 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
78921 ) -> Result<(), fidl::Error> {
78922 self.control_handle.inner.send::<fidl::encoding::ResultType<
78923 BaseNetworkSocketGetIpTtlResponse,
78924 fidl_fuchsia_posix::Errno,
78925 >>(
78926 result.map(|value| (value,)),
78927 self.tx_id,
78928 0x47e47fa1f24da471,
78929 fidl::encoding::DynamicFlags::empty(),
78930 )
78931 }
78932}
78933
78934#[must_use = "FIDL methods require a response to be sent"]
78935#[derive(Debug)]
78936pub struct SynchronousDatagramSocketSetIpPacketInfoResponder {
78937 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78938 tx_id: u32,
78939}
78940
78941impl std::ops::Drop for SynchronousDatagramSocketSetIpPacketInfoResponder {
78945 fn drop(&mut self) {
78946 self.control_handle.shutdown();
78947 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78949 }
78950}
78951
78952impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpPacketInfoResponder {
78953 type ControlHandle = SynchronousDatagramSocketControlHandle;
78954
78955 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78956 &self.control_handle
78957 }
78958
78959 fn drop_without_shutdown(mut self) {
78960 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78962 std::mem::forget(self);
78964 }
78965}
78966
78967impl SynchronousDatagramSocketSetIpPacketInfoResponder {
78968 pub fn send(
78972 self,
78973 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78974 ) -> Result<(), fidl::Error> {
78975 let _result = self.send_raw(result);
78976 if _result.is_err() {
78977 self.control_handle.shutdown();
78978 }
78979 self.drop_without_shutdown();
78980 _result
78981 }
78982
78983 pub fn send_no_shutdown_on_err(
78985 self,
78986 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78987 ) -> Result<(), fidl::Error> {
78988 let _result = self.send_raw(result);
78989 self.drop_without_shutdown();
78990 _result
78991 }
78992
78993 fn send_raw(
78994 &self,
78995 mut result: Result<(), fidl_fuchsia_posix::Errno>,
78996 ) -> Result<(), fidl::Error> {
78997 self.control_handle.inner.send::<fidl::encoding::ResultType<
78998 fidl::encoding::EmptyStruct,
78999 fidl_fuchsia_posix::Errno,
79000 >>(
79001 result,
79002 self.tx_id,
79003 0x392d16bee20c0e16,
79004 fidl::encoding::DynamicFlags::empty(),
79005 )
79006 }
79007}
79008
79009#[must_use = "FIDL methods require a response to be sent"]
79010#[derive(Debug)]
79011pub struct SynchronousDatagramSocketGetIpPacketInfoResponder {
79012 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79013 tx_id: u32,
79014}
79015
79016impl std::ops::Drop for SynchronousDatagramSocketGetIpPacketInfoResponder {
79020 fn drop(&mut self) {
79021 self.control_handle.shutdown();
79022 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79024 }
79025}
79026
79027impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpPacketInfoResponder {
79028 type ControlHandle = SynchronousDatagramSocketControlHandle;
79029
79030 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79031 &self.control_handle
79032 }
79033
79034 fn drop_without_shutdown(mut self) {
79035 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79037 std::mem::forget(self);
79039 }
79040}
79041
79042impl SynchronousDatagramSocketGetIpPacketInfoResponder {
79043 pub fn send(
79047 self,
79048 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79049 ) -> Result<(), fidl::Error> {
79050 let _result = self.send_raw(result);
79051 if _result.is_err() {
79052 self.control_handle.shutdown();
79053 }
79054 self.drop_without_shutdown();
79055 _result
79056 }
79057
79058 pub fn send_no_shutdown_on_err(
79060 self,
79061 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79062 ) -> Result<(), fidl::Error> {
79063 let _result = self.send_raw(result);
79064 self.drop_without_shutdown();
79065 _result
79066 }
79067
79068 fn send_raw(
79069 &self,
79070 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79071 ) -> Result<(), fidl::Error> {
79072 self.control_handle.inner.send::<fidl::encoding::ResultType<
79073 BaseNetworkSocketGetIpPacketInfoResponse,
79074 fidl_fuchsia_posix::Errno,
79075 >>(
79076 result.map(|value| (value,)),
79077 self.tx_id,
79078 0x54b505f242280740,
79079 fidl::encoding::DynamicFlags::empty(),
79080 )
79081 }
79082}
79083
79084#[must_use = "FIDL methods require a response to be sent"]
79085#[derive(Debug)]
79086pub struct SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder {
79087 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79088 tx_id: u32,
79089}
79090
79091impl std::ops::Drop for SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder {
79095 fn drop(&mut self) {
79096 self.control_handle.shutdown();
79097 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79099 }
79100}
79101
79102impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder {
79103 type ControlHandle = SynchronousDatagramSocketControlHandle;
79104
79105 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79106 &self.control_handle
79107 }
79108
79109 fn drop_without_shutdown(mut self) {
79110 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79112 std::mem::forget(self);
79114 }
79115}
79116
79117impl SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder {
79118 pub fn send(
79122 self,
79123 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79124 ) -> Result<(), fidl::Error> {
79125 let _result = self.send_raw(result);
79126 if _result.is_err() {
79127 self.control_handle.shutdown();
79128 }
79129 self.drop_without_shutdown();
79130 _result
79131 }
79132
79133 pub fn send_no_shutdown_on_err(
79135 self,
79136 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79137 ) -> Result<(), fidl::Error> {
79138 let _result = self.send_raw(result);
79139 self.drop_without_shutdown();
79140 _result
79141 }
79142
79143 fn send_raw(
79144 &self,
79145 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79146 ) -> Result<(), fidl::Error> {
79147 self.control_handle.inner.send::<fidl::encoding::ResultType<
79148 fidl::encoding::EmptyStruct,
79149 fidl_fuchsia_posix::Errno,
79150 >>(
79151 result,
79152 self.tx_id,
79153 0x6c4f6714995f84ef,
79154 fidl::encoding::DynamicFlags::empty(),
79155 )
79156 }
79157}
79158
79159#[must_use = "FIDL methods require a response to be sent"]
79160#[derive(Debug)]
79161pub struct SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder {
79162 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79163 tx_id: u32,
79164}
79165
79166impl std::ops::Drop for SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder {
79170 fn drop(&mut self) {
79171 self.control_handle.shutdown();
79172 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79174 }
79175}
79176
79177impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder {
79178 type ControlHandle = SynchronousDatagramSocketControlHandle;
79179
79180 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79181 &self.control_handle
79182 }
79183
79184 fn drop_without_shutdown(mut self) {
79185 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79187 std::mem::forget(self);
79189 }
79190}
79191
79192impl SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder {
79193 pub fn send(
79197 self,
79198 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79199 ) -> Result<(), fidl::Error> {
79200 let _result = self.send_raw(result);
79201 if _result.is_err() {
79202 self.control_handle.shutdown();
79203 }
79204 self.drop_without_shutdown();
79205 _result
79206 }
79207
79208 pub fn send_no_shutdown_on_err(
79210 self,
79211 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79212 ) -> Result<(), fidl::Error> {
79213 let _result = self.send_raw(result);
79214 self.drop_without_shutdown();
79215 _result
79216 }
79217
79218 fn send_raw(
79219 &self,
79220 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79221 ) -> Result<(), fidl::Error> {
79222 self.control_handle.inner.send::<fidl::encoding::ResultType<
79223 BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
79224 fidl_fuchsia_posix::Errno,
79225 >>(
79226 result.map(|value| (value,)),
79227 self.tx_id,
79228 0x4158ba7dc2795960,
79229 fidl::encoding::DynamicFlags::empty(),
79230 )
79231 }
79232}
79233
79234#[must_use = "FIDL methods require a response to be sent"]
79235#[derive(Debug)]
79236pub struct SynchronousDatagramSocketSetIpReceiveTtlResponder {
79237 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79238 tx_id: u32,
79239}
79240
79241impl std::ops::Drop for SynchronousDatagramSocketSetIpReceiveTtlResponder {
79245 fn drop(&mut self) {
79246 self.control_handle.shutdown();
79247 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79249 }
79250}
79251
79252impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpReceiveTtlResponder {
79253 type ControlHandle = SynchronousDatagramSocketControlHandle;
79254
79255 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79256 &self.control_handle
79257 }
79258
79259 fn drop_without_shutdown(mut self) {
79260 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79262 std::mem::forget(self);
79264 }
79265}
79266
79267impl SynchronousDatagramSocketSetIpReceiveTtlResponder {
79268 pub fn send(
79272 self,
79273 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79274 ) -> Result<(), fidl::Error> {
79275 let _result = self.send_raw(result);
79276 if _result.is_err() {
79277 self.control_handle.shutdown();
79278 }
79279 self.drop_without_shutdown();
79280 _result
79281 }
79282
79283 pub fn send_no_shutdown_on_err(
79285 self,
79286 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79287 ) -> Result<(), fidl::Error> {
79288 let _result = self.send_raw(result);
79289 self.drop_without_shutdown();
79290 _result
79291 }
79292
79293 fn send_raw(
79294 &self,
79295 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79296 ) -> Result<(), fidl::Error> {
79297 self.control_handle.inner.send::<fidl::encoding::ResultType<
79298 fidl::encoding::EmptyStruct,
79299 fidl_fuchsia_posix::Errno,
79300 >>(
79301 result,
79302 self.tx_id,
79303 0x46f15be0ce0ab82b,
79304 fidl::encoding::DynamicFlags::empty(),
79305 )
79306 }
79307}
79308
79309#[must_use = "FIDL methods require a response to be sent"]
79310#[derive(Debug)]
79311pub struct SynchronousDatagramSocketGetIpReceiveTtlResponder {
79312 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79313 tx_id: u32,
79314}
79315
79316impl std::ops::Drop for SynchronousDatagramSocketGetIpReceiveTtlResponder {
79320 fn drop(&mut self) {
79321 self.control_handle.shutdown();
79322 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79324 }
79325}
79326
79327impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpReceiveTtlResponder {
79328 type ControlHandle = SynchronousDatagramSocketControlHandle;
79329
79330 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79331 &self.control_handle
79332 }
79333
79334 fn drop_without_shutdown(mut self) {
79335 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79337 std::mem::forget(self);
79339 }
79340}
79341
79342impl SynchronousDatagramSocketGetIpReceiveTtlResponder {
79343 pub fn send(
79347 self,
79348 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79349 ) -> Result<(), fidl::Error> {
79350 let _result = self.send_raw(result);
79351 if _result.is_err() {
79352 self.control_handle.shutdown();
79353 }
79354 self.drop_without_shutdown();
79355 _result
79356 }
79357
79358 pub fn send_no_shutdown_on_err(
79360 self,
79361 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79362 ) -> Result<(), fidl::Error> {
79363 let _result = self.send_raw(result);
79364 self.drop_without_shutdown();
79365 _result
79366 }
79367
79368 fn send_raw(
79369 &self,
79370 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79371 ) -> Result<(), fidl::Error> {
79372 self.control_handle.inner.send::<fidl::encoding::ResultType<
79373 BaseNetworkSocketGetIpReceiveTtlResponse,
79374 fidl_fuchsia_posix::Errno,
79375 >>(
79376 result.map(|value| (value,)),
79377 self.tx_id,
79378 0x678ddd5a5dfa2eb5,
79379 fidl::encoding::DynamicFlags::empty(),
79380 )
79381 }
79382}
79383
79384#[must_use = "FIDL methods require a response to be sent"]
79385#[derive(Debug)]
79386pub struct SynchronousDatagramSocketSetIpMulticastInterfaceResponder {
79387 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79388 tx_id: u32,
79389}
79390
79391impl std::ops::Drop for SynchronousDatagramSocketSetIpMulticastInterfaceResponder {
79395 fn drop(&mut self) {
79396 self.control_handle.shutdown();
79397 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79399 }
79400}
79401
79402impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpMulticastInterfaceResponder {
79403 type ControlHandle = SynchronousDatagramSocketControlHandle;
79404
79405 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79406 &self.control_handle
79407 }
79408
79409 fn drop_without_shutdown(mut self) {
79410 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79412 std::mem::forget(self);
79414 }
79415}
79416
79417impl SynchronousDatagramSocketSetIpMulticastInterfaceResponder {
79418 pub fn send(
79422 self,
79423 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79424 ) -> Result<(), fidl::Error> {
79425 let _result = self.send_raw(result);
79426 if _result.is_err() {
79427 self.control_handle.shutdown();
79428 }
79429 self.drop_without_shutdown();
79430 _result
79431 }
79432
79433 pub fn send_no_shutdown_on_err(
79435 self,
79436 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79437 ) -> Result<(), fidl::Error> {
79438 let _result = self.send_raw(result);
79439 self.drop_without_shutdown();
79440 _result
79441 }
79442
79443 fn send_raw(
79444 &self,
79445 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79446 ) -> Result<(), fidl::Error> {
79447 self.control_handle.inner.send::<fidl::encoding::ResultType<
79448 fidl::encoding::EmptyStruct,
79449 fidl_fuchsia_posix::Errno,
79450 >>(
79451 result,
79452 self.tx_id,
79453 0x752fbfa9b12befe,
79454 fidl::encoding::DynamicFlags::empty(),
79455 )
79456 }
79457}
79458
79459#[must_use = "FIDL methods require a response to be sent"]
79460#[derive(Debug)]
79461pub struct SynchronousDatagramSocketGetIpMulticastInterfaceResponder {
79462 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79463 tx_id: u32,
79464}
79465
79466impl std::ops::Drop for SynchronousDatagramSocketGetIpMulticastInterfaceResponder {
79470 fn drop(&mut self) {
79471 self.control_handle.shutdown();
79472 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79474 }
79475}
79476
79477impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpMulticastInterfaceResponder {
79478 type ControlHandle = SynchronousDatagramSocketControlHandle;
79479
79480 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79481 &self.control_handle
79482 }
79483
79484 fn drop_without_shutdown(mut self) {
79485 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79487 std::mem::forget(self);
79489 }
79490}
79491
79492impl SynchronousDatagramSocketGetIpMulticastInterfaceResponder {
79493 pub fn send(
79497 self,
79498 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
79499 ) -> Result<(), fidl::Error> {
79500 let _result = self.send_raw(result);
79501 if _result.is_err() {
79502 self.control_handle.shutdown();
79503 }
79504 self.drop_without_shutdown();
79505 _result
79506 }
79507
79508 pub fn send_no_shutdown_on_err(
79510 self,
79511 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
79512 ) -> Result<(), fidl::Error> {
79513 let _result = self.send_raw(result);
79514 self.drop_without_shutdown();
79515 _result
79516 }
79517
79518 fn send_raw(
79519 &self,
79520 mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
79521 ) -> Result<(), fidl::Error> {
79522 self.control_handle.inner.send::<fidl::encoding::ResultType<
79523 BaseNetworkSocketGetIpMulticastInterfaceResponse,
79524 fidl_fuchsia_posix::Errno,
79525 >>(
79526 result.map(|value| (value,)),
79527 self.tx_id,
79528 0x320bd14c4df046c4,
79529 fidl::encoding::DynamicFlags::empty(),
79530 )
79531 }
79532}
79533
79534#[must_use = "FIDL methods require a response to be sent"]
79535#[derive(Debug)]
79536pub struct SynchronousDatagramSocketSetIpMulticastTtlResponder {
79537 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79538 tx_id: u32,
79539}
79540
79541impl std::ops::Drop for SynchronousDatagramSocketSetIpMulticastTtlResponder {
79545 fn drop(&mut self) {
79546 self.control_handle.shutdown();
79547 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79549 }
79550}
79551
79552impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpMulticastTtlResponder {
79553 type ControlHandle = SynchronousDatagramSocketControlHandle;
79554
79555 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79556 &self.control_handle
79557 }
79558
79559 fn drop_without_shutdown(mut self) {
79560 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79562 std::mem::forget(self);
79564 }
79565}
79566
79567impl SynchronousDatagramSocketSetIpMulticastTtlResponder {
79568 pub fn send(
79572 self,
79573 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79574 ) -> Result<(), fidl::Error> {
79575 let _result = self.send_raw(result);
79576 if _result.is_err() {
79577 self.control_handle.shutdown();
79578 }
79579 self.drop_without_shutdown();
79580 _result
79581 }
79582
79583 pub fn send_no_shutdown_on_err(
79585 self,
79586 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79587 ) -> Result<(), fidl::Error> {
79588 let _result = self.send_raw(result);
79589 self.drop_without_shutdown();
79590 _result
79591 }
79592
79593 fn send_raw(
79594 &self,
79595 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79596 ) -> Result<(), fidl::Error> {
79597 self.control_handle.inner.send::<fidl::encoding::ResultType<
79598 fidl::encoding::EmptyStruct,
79599 fidl_fuchsia_posix::Errno,
79600 >>(
79601 result,
79602 self.tx_id,
79603 0x63134d53772916a1,
79604 fidl::encoding::DynamicFlags::empty(),
79605 )
79606 }
79607}
79608
79609#[must_use = "FIDL methods require a response to be sent"]
79610#[derive(Debug)]
79611pub struct SynchronousDatagramSocketGetIpMulticastTtlResponder {
79612 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79613 tx_id: u32,
79614}
79615
79616impl std::ops::Drop for SynchronousDatagramSocketGetIpMulticastTtlResponder {
79620 fn drop(&mut self) {
79621 self.control_handle.shutdown();
79622 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79624 }
79625}
79626
79627impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpMulticastTtlResponder {
79628 type ControlHandle = SynchronousDatagramSocketControlHandle;
79629
79630 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79631 &self.control_handle
79632 }
79633
79634 fn drop_without_shutdown(mut self) {
79635 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79637 std::mem::forget(self);
79639 }
79640}
79641
79642impl SynchronousDatagramSocketGetIpMulticastTtlResponder {
79643 pub fn send(
79647 self,
79648 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
79649 ) -> Result<(), fidl::Error> {
79650 let _result = self.send_raw(result);
79651 if _result.is_err() {
79652 self.control_handle.shutdown();
79653 }
79654 self.drop_without_shutdown();
79655 _result
79656 }
79657
79658 pub fn send_no_shutdown_on_err(
79660 self,
79661 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
79662 ) -> Result<(), fidl::Error> {
79663 let _result = self.send_raw(result);
79664 self.drop_without_shutdown();
79665 _result
79666 }
79667
79668 fn send_raw(
79669 &self,
79670 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
79671 ) -> Result<(), fidl::Error> {
79672 self.control_handle.inner.send::<fidl::encoding::ResultType<
79673 BaseNetworkSocketGetIpMulticastTtlResponse,
79674 fidl_fuchsia_posix::Errno,
79675 >>(
79676 result.map(|value| (value,)),
79677 self.tx_id,
79678 0x4665cd378f39e1a,
79679 fidl::encoding::DynamicFlags::empty(),
79680 )
79681 }
79682}
79683
79684#[must_use = "FIDL methods require a response to be sent"]
79685#[derive(Debug)]
79686pub struct SynchronousDatagramSocketSetIpMulticastLoopbackResponder {
79687 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79688 tx_id: u32,
79689}
79690
79691impl std::ops::Drop for SynchronousDatagramSocketSetIpMulticastLoopbackResponder {
79695 fn drop(&mut self) {
79696 self.control_handle.shutdown();
79697 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79699 }
79700}
79701
79702impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpMulticastLoopbackResponder {
79703 type ControlHandle = SynchronousDatagramSocketControlHandle;
79704
79705 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79706 &self.control_handle
79707 }
79708
79709 fn drop_without_shutdown(mut self) {
79710 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79712 std::mem::forget(self);
79714 }
79715}
79716
79717impl SynchronousDatagramSocketSetIpMulticastLoopbackResponder {
79718 pub fn send(
79722 self,
79723 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79724 ) -> Result<(), fidl::Error> {
79725 let _result = self.send_raw(result);
79726 if _result.is_err() {
79727 self.control_handle.shutdown();
79728 }
79729 self.drop_without_shutdown();
79730 _result
79731 }
79732
79733 pub fn send_no_shutdown_on_err(
79735 self,
79736 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79737 ) -> Result<(), fidl::Error> {
79738 let _result = self.send_raw(result);
79739 self.drop_without_shutdown();
79740 _result
79741 }
79742
79743 fn send_raw(
79744 &self,
79745 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79746 ) -> Result<(), fidl::Error> {
79747 self.control_handle.inner.send::<fidl::encoding::ResultType<
79748 fidl::encoding::EmptyStruct,
79749 fidl_fuchsia_posix::Errno,
79750 >>(
79751 result,
79752 self.tx_id,
79753 0x20c55c11f00943ea,
79754 fidl::encoding::DynamicFlags::empty(),
79755 )
79756 }
79757}
79758
79759#[must_use = "FIDL methods require a response to be sent"]
79760#[derive(Debug)]
79761pub struct SynchronousDatagramSocketGetIpMulticastLoopbackResponder {
79762 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79763 tx_id: u32,
79764}
79765
79766impl std::ops::Drop for SynchronousDatagramSocketGetIpMulticastLoopbackResponder {
79770 fn drop(&mut self) {
79771 self.control_handle.shutdown();
79772 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79774 }
79775}
79776
79777impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpMulticastLoopbackResponder {
79778 type ControlHandle = SynchronousDatagramSocketControlHandle;
79779
79780 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79781 &self.control_handle
79782 }
79783
79784 fn drop_without_shutdown(mut self) {
79785 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79787 std::mem::forget(self);
79789 }
79790}
79791
79792impl SynchronousDatagramSocketGetIpMulticastLoopbackResponder {
79793 pub fn send(
79797 self,
79798 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79799 ) -> Result<(), fidl::Error> {
79800 let _result = self.send_raw(result);
79801 if _result.is_err() {
79802 self.control_handle.shutdown();
79803 }
79804 self.drop_without_shutdown();
79805 _result
79806 }
79807
79808 pub fn send_no_shutdown_on_err(
79810 self,
79811 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79812 ) -> Result<(), fidl::Error> {
79813 let _result = self.send_raw(result);
79814 self.drop_without_shutdown();
79815 _result
79816 }
79817
79818 fn send_raw(
79819 &self,
79820 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79821 ) -> Result<(), fidl::Error> {
79822 self.control_handle.inner.send::<fidl::encoding::ResultType<
79823 BaseNetworkSocketGetIpMulticastLoopbackResponse,
79824 fidl_fuchsia_posix::Errno,
79825 >>(
79826 result.map(|value| (value,)),
79827 self.tx_id,
79828 0x3b6b26ff558298f2,
79829 fidl::encoding::DynamicFlags::empty(),
79830 )
79831 }
79832}
79833
79834#[must_use = "FIDL methods require a response to be sent"]
79835#[derive(Debug)]
79836pub struct SynchronousDatagramSocketAddIpMembershipResponder {
79837 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79838 tx_id: u32,
79839}
79840
79841impl std::ops::Drop for SynchronousDatagramSocketAddIpMembershipResponder {
79845 fn drop(&mut self) {
79846 self.control_handle.shutdown();
79847 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79849 }
79850}
79851
79852impl fidl::endpoints::Responder for SynchronousDatagramSocketAddIpMembershipResponder {
79853 type ControlHandle = SynchronousDatagramSocketControlHandle;
79854
79855 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79856 &self.control_handle
79857 }
79858
79859 fn drop_without_shutdown(mut self) {
79860 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79862 std::mem::forget(self);
79864 }
79865}
79866
79867impl SynchronousDatagramSocketAddIpMembershipResponder {
79868 pub fn send(
79872 self,
79873 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79874 ) -> Result<(), fidl::Error> {
79875 let _result = self.send_raw(result);
79876 if _result.is_err() {
79877 self.control_handle.shutdown();
79878 }
79879 self.drop_without_shutdown();
79880 _result
79881 }
79882
79883 pub fn send_no_shutdown_on_err(
79885 self,
79886 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79887 ) -> Result<(), fidl::Error> {
79888 let _result = self.send_raw(result);
79889 self.drop_without_shutdown();
79890 _result
79891 }
79892
79893 fn send_raw(
79894 &self,
79895 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79896 ) -> Result<(), fidl::Error> {
79897 self.control_handle.inner.send::<fidl::encoding::ResultType<
79898 fidl::encoding::EmptyStruct,
79899 fidl_fuchsia_posix::Errno,
79900 >>(
79901 result,
79902 self.tx_id,
79903 0x76bc7df115a3b4d0,
79904 fidl::encoding::DynamicFlags::empty(),
79905 )
79906 }
79907}
79908
79909#[must_use = "FIDL methods require a response to be sent"]
79910#[derive(Debug)]
79911pub struct SynchronousDatagramSocketDropIpMembershipResponder {
79912 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79913 tx_id: u32,
79914}
79915
79916impl std::ops::Drop for SynchronousDatagramSocketDropIpMembershipResponder {
79920 fn drop(&mut self) {
79921 self.control_handle.shutdown();
79922 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79924 }
79925}
79926
79927impl fidl::endpoints::Responder for SynchronousDatagramSocketDropIpMembershipResponder {
79928 type ControlHandle = SynchronousDatagramSocketControlHandle;
79929
79930 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79931 &self.control_handle
79932 }
79933
79934 fn drop_without_shutdown(mut self) {
79935 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79937 std::mem::forget(self);
79939 }
79940}
79941
79942impl SynchronousDatagramSocketDropIpMembershipResponder {
79943 pub fn send(
79947 self,
79948 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79949 ) -> Result<(), fidl::Error> {
79950 let _result = self.send_raw(result);
79951 if _result.is_err() {
79952 self.control_handle.shutdown();
79953 }
79954 self.drop_without_shutdown();
79955 _result
79956 }
79957
79958 pub fn send_no_shutdown_on_err(
79960 self,
79961 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79962 ) -> Result<(), fidl::Error> {
79963 let _result = self.send_raw(result);
79964 self.drop_without_shutdown();
79965 _result
79966 }
79967
79968 fn send_raw(
79969 &self,
79970 mut result: Result<(), fidl_fuchsia_posix::Errno>,
79971 ) -> Result<(), fidl::Error> {
79972 self.control_handle.inner.send::<fidl::encoding::ResultType<
79973 fidl::encoding::EmptyStruct,
79974 fidl_fuchsia_posix::Errno,
79975 >>(
79976 result,
79977 self.tx_id,
79978 0x2888f3099188d03,
79979 fidl::encoding::DynamicFlags::empty(),
79980 )
79981 }
79982}
79983
79984#[must_use = "FIDL methods require a response to be sent"]
79985#[derive(Debug)]
79986pub struct SynchronousDatagramSocketSetIpTransparentResponder {
79987 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79988 tx_id: u32,
79989}
79990
79991impl std::ops::Drop for SynchronousDatagramSocketSetIpTransparentResponder {
79995 fn drop(&mut self) {
79996 self.control_handle.shutdown();
79997 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79999 }
80000}
80001
80002impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpTransparentResponder {
80003 type ControlHandle = SynchronousDatagramSocketControlHandle;
80004
80005 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80006 &self.control_handle
80007 }
80008
80009 fn drop_without_shutdown(mut self) {
80010 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80012 std::mem::forget(self);
80014 }
80015}
80016
80017impl SynchronousDatagramSocketSetIpTransparentResponder {
80018 pub fn send(
80022 self,
80023 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80024 ) -> Result<(), fidl::Error> {
80025 let _result = self.send_raw(result);
80026 if _result.is_err() {
80027 self.control_handle.shutdown();
80028 }
80029 self.drop_without_shutdown();
80030 _result
80031 }
80032
80033 pub fn send_no_shutdown_on_err(
80035 self,
80036 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80037 ) -> Result<(), fidl::Error> {
80038 let _result = self.send_raw(result);
80039 self.drop_without_shutdown();
80040 _result
80041 }
80042
80043 fn send_raw(
80044 &self,
80045 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80046 ) -> Result<(), fidl::Error> {
80047 self.control_handle.inner.send::<fidl::encoding::ResultType<
80048 fidl::encoding::EmptyStruct,
80049 fidl_fuchsia_posix::Errno,
80050 >>(
80051 result,
80052 self.tx_id,
80053 0x1ae532b0c066e3a0,
80054 fidl::encoding::DynamicFlags::empty(),
80055 )
80056 }
80057}
80058
80059#[must_use = "FIDL methods require a response to be sent"]
80060#[derive(Debug)]
80061pub struct SynchronousDatagramSocketGetIpTransparentResponder {
80062 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80063 tx_id: u32,
80064}
80065
80066impl std::ops::Drop for SynchronousDatagramSocketGetIpTransparentResponder {
80070 fn drop(&mut self) {
80071 self.control_handle.shutdown();
80072 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80074 }
80075}
80076
80077impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpTransparentResponder {
80078 type ControlHandle = SynchronousDatagramSocketControlHandle;
80079
80080 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80081 &self.control_handle
80082 }
80083
80084 fn drop_without_shutdown(mut self) {
80085 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80087 std::mem::forget(self);
80089 }
80090}
80091
80092impl SynchronousDatagramSocketGetIpTransparentResponder {
80093 pub fn send(
80097 self,
80098 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80099 ) -> Result<(), fidl::Error> {
80100 let _result = self.send_raw(result);
80101 if _result.is_err() {
80102 self.control_handle.shutdown();
80103 }
80104 self.drop_without_shutdown();
80105 _result
80106 }
80107
80108 pub fn send_no_shutdown_on_err(
80110 self,
80111 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80112 ) -> Result<(), fidl::Error> {
80113 let _result = self.send_raw(result);
80114 self.drop_without_shutdown();
80115 _result
80116 }
80117
80118 fn send_raw(
80119 &self,
80120 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80121 ) -> Result<(), fidl::Error> {
80122 self.control_handle.inner.send::<fidl::encoding::ResultType<
80123 BaseNetworkSocketGetIpTransparentResponse,
80124 fidl_fuchsia_posix::Errno,
80125 >>(
80126 result.map(|value| (value,)),
80127 self.tx_id,
80128 0x51d43695962ebfb5,
80129 fidl::encoding::DynamicFlags::empty(),
80130 )
80131 }
80132}
80133
80134#[must_use = "FIDL methods require a response to be sent"]
80135#[derive(Debug)]
80136pub struct SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
80137 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80138 tx_id: u32,
80139}
80140
80141impl std::ops::Drop for SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
80145 fn drop(&mut self) {
80146 self.control_handle.shutdown();
80147 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80149 }
80150}
80151
80152impl fidl::endpoints::Responder
80153 for SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder
80154{
80155 type ControlHandle = SynchronousDatagramSocketControlHandle;
80156
80157 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80158 &self.control_handle
80159 }
80160
80161 fn drop_without_shutdown(mut self) {
80162 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80164 std::mem::forget(self);
80166 }
80167}
80168
80169impl SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
80170 pub fn send(
80174 self,
80175 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80176 ) -> Result<(), fidl::Error> {
80177 let _result = self.send_raw(result);
80178 if _result.is_err() {
80179 self.control_handle.shutdown();
80180 }
80181 self.drop_without_shutdown();
80182 _result
80183 }
80184
80185 pub fn send_no_shutdown_on_err(
80187 self,
80188 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80189 ) -> Result<(), fidl::Error> {
80190 let _result = self.send_raw(result);
80191 self.drop_without_shutdown();
80192 _result
80193 }
80194
80195 fn send_raw(
80196 &self,
80197 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80198 ) -> Result<(), fidl::Error> {
80199 self.control_handle.inner.send::<fidl::encoding::ResultType<
80200 fidl::encoding::EmptyStruct,
80201 fidl_fuchsia_posix::Errno,
80202 >>(
80203 result,
80204 self.tx_id,
80205 0x4722b4ce52f7840,
80206 fidl::encoding::DynamicFlags::empty(),
80207 )
80208 }
80209}
80210
80211#[must_use = "FIDL methods require a response to be sent"]
80212#[derive(Debug)]
80213pub struct SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
80214 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80215 tx_id: u32,
80216}
80217
80218impl std::ops::Drop for SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
80222 fn drop(&mut self) {
80223 self.control_handle.shutdown();
80224 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80226 }
80227}
80228
80229impl fidl::endpoints::Responder
80230 for SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder
80231{
80232 type ControlHandle = SynchronousDatagramSocketControlHandle;
80233
80234 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80235 &self.control_handle
80236 }
80237
80238 fn drop_without_shutdown(mut self) {
80239 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80241 std::mem::forget(self);
80243 }
80244}
80245
80246impl SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
80247 pub fn send(
80251 self,
80252 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80253 ) -> Result<(), fidl::Error> {
80254 let _result = self.send_raw(result);
80255 if _result.is_err() {
80256 self.control_handle.shutdown();
80257 }
80258 self.drop_without_shutdown();
80259 _result
80260 }
80261
80262 pub fn send_no_shutdown_on_err(
80264 self,
80265 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80266 ) -> Result<(), fidl::Error> {
80267 let _result = self.send_raw(result);
80268 self.drop_without_shutdown();
80269 _result
80270 }
80271
80272 fn send_raw(
80273 &self,
80274 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80275 ) -> Result<(), fidl::Error> {
80276 self.control_handle.inner.send::<fidl::encoding::ResultType<
80277 BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
80278 fidl_fuchsia_posix::Errno,
80279 >>(
80280 result.map(|value| (value,)),
80281 self.tx_id,
80282 0x2a0e7dc5d6bfdfe9,
80283 fidl::encoding::DynamicFlags::empty(),
80284 )
80285 }
80286}
80287
80288#[must_use = "FIDL methods require a response to be sent"]
80289#[derive(Debug)]
80290pub struct SynchronousDatagramSocketAddIpv6MembershipResponder {
80291 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80292 tx_id: u32,
80293}
80294
80295impl std::ops::Drop for SynchronousDatagramSocketAddIpv6MembershipResponder {
80299 fn drop(&mut self) {
80300 self.control_handle.shutdown();
80301 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80303 }
80304}
80305
80306impl fidl::endpoints::Responder for SynchronousDatagramSocketAddIpv6MembershipResponder {
80307 type ControlHandle = SynchronousDatagramSocketControlHandle;
80308
80309 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80310 &self.control_handle
80311 }
80312
80313 fn drop_without_shutdown(mut self) {
80314 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80316 std::mem::forget(self);
80318 }
80319}
80320
80321impl SynchronousDatagramSocketAddIpv6MembershipResponder {
80322 pub fn send(
80326 self,
80327 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80328 ) -> Result<(), fidl::Error> {
80329 let _result = self.send_raw(result);
80330 if _result.is_err() {
80331 self.control_handle.shutdown();
80332 }
80333 self.drop_without_shutdown();
80334 _result
80335 }
80336
80337 pub fn send_no_shutdown_on_err(
80339 self,
80340 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80341 ) -> Result<(), fidl::Error> {
80342 let _result = self.send_raw(result);
80343 self.drop_without_shutdown();
80344 _result
80345 }
80346
80347 fn send_raw(
80348 &self,
80349 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80350 ) -> Result<(), fidl::Error> {
80351 self.control_handle.inner.send::<fidl::encoding::ResultType<
80352 fidl::encoding::EmptyStruct,
80353 fidl_fuchsia_posix::Errno,
80354 >>(
80355 result,
80356 self.tx_id,
80357 0x7c94727acb4ea4b3,
80358 fidl::encoding::DynamicFlags::empty(),
80359 )
80360 }
80361}
80362
80363#[must_use = "FIDL methods require a response to be sent"]
80364#[derive(Debug)]
80365pub struct SynchronousDatagramSocketDropIpv6MembershipResponder {
80366 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80367 tx_id: u32,
80368}
80369
80370impl std::ops::Drop for SynchronousDatagramSocketDropIpv6MembershipResponder {
80374 fn drop(&mut self) {
80375 self.control_handle.shutdown();
80376 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80378 }
80379}
80380
80381impl fidl::endpoints::Responder for SynchronousDatagramSocketDropIpv6MembershipResponder {
80382 type ControlHandle = SynchronousDatagramSocketControlHandle;
80383
80384 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80385 &self.control_handle
80386 }
80387
80388 fn drop_without_shutdown(mut self) {
80389 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80391 std::mem::forget(self);
80393 }
80394}
80395
80396impl SynchronousDatagramSocketDropIpv6MembershipResponder {
80397 pub fn send(
80401 self,
80402 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80403 ) -> Result<(), fidl::Error> {
80404 let _result = self.send_raw(result);
80405 if _result.is_err() {
80406 self.control_handle.shutdown();
80407 }
80408 self.drop_without_shutdown();
80409 _result
80410 }
80411
80412 pub fn send_no_shutdown_on_err(
80414 self,
80415 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80416 ) -> Result<(), fidl::Error> {
80417 let _result = self.send_raw(result);
80418 self.drop_without_shutdown();
80419 _result
80420 }
80421
80422 fn send_raw(
80423 &self,
80424 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80425 ) -> Result<(), fidl::Error> {
80426 self.control_handle.inner.send::<fidl::encoding::ResultType<
80427 fidl::encoding::EmptyStruct,
80428 fidl_fuchsia_posix::Errno,
80429 >>(
80430 result,
80431 self.tx_id,
80432 0x42104c70ccaba304,
80433 fidl::encoding::DynamicFlags::empty(),
80434 )
80435 }
80436}
80437
80438#[must_use = "FIDL methods require a response to be sent"]
80439#[derive(Debug)]
80440pub struct SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder {
80441 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80442 tx_id: u32,
80443}
80444
80445impl std::ops::Drop for SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder {
80449 fn drop(&mut self) {
80450 self.control_handle.shutdown();
80451 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80453 }
80454}
80455
80456impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder {
80457 type ControlHandle = SynchronousDatagramSocketControlHandle;
80458
80459 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80460 &self.control_handle
80461 }
80462
80463 fn drop_without_shutdown(mut self) {
80464 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80466 std::mem::forget(self);
80468 }
80469}
80470
80471impl SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder {
80472 pub fn send(
80476 self,
80477 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80478 ) -> Result<(), fidl::Error> {
80479 let _result = self.send_raw(result);
80480 if _result.is_err() {
80481 self.control_handle.shutdown();
80482 }
80483 self.drop_without_shutdown();
80484 _result
80485 }
80486
80487 pub fn send_no_shutdown_on_err(
80489 self,
80490 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80491 ) -> Result<(), fidl::Error> {
80492 let _result = self.send_raw(result);
80493 self.drop_without_shutdown();
80494 _result
80495 }
80496
80497 fn send_raw(
80498 &self,
80499 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80500 ) -> Result<(), fidl::Error> {
80501 self.control_handle.inner.send::<fidl::encoding::ResultType<
80502 fidl::encoding::EmptyStruct,
80503 fidl_fuchsia_posix::Errno,
80504 >>(
80505 result,
80506 self.tx_id,
80507 0x135f76db3774ab3b,
80508 fidl::encoding::DynamicFlags::empty(),
80509 )
80510 }
80511}
80512
80513#[must_use = "FIDL methods require a response to be sent"]
80514#[derive(Debug)]
80515pub struct SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder {
80516 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80517 tx_id: u32,
80518}
80519
80520impl std::ops::Drop for SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder {
80524 fn drop(&mut self) {
80525 self.control_handle.shutdown();
80526 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80528 }
80529}
80530
80531impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder {
80532 type ControlHandle = SynchronousDatagramSocketControlHandle;
80533
80534 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80535 &self.control_handle
80536 }
80537
80538 fn drop_without_shutdown(mut self) {
80539 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80541 std::mem::forget(self);
80543 }
80544}
80545
80546impl SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder {
80547 pub fn send(
80551 self,
80552 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
80553 ) -> Result<(), fidl::Error> {
80554 let _result = self.send_raw(result);
80555 if _result.is_err() {
80556 self.control_handle.shutdown();
80557 }
80558 self.drop_without_shutdown();
80559 _result
80560 }
80561
80562 pub fn send_no_shutdown_on_err(
80564 self,
80565 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
80566 ) -> Result<(), fidl::Error> {
80567 let _result = self.send_raw(result);
80568 self.drop_without_shutdown();
80569 _result
80570 }
80571
80572 fn send_raw(
80573 &self,
80574 mut result: Result<u64, fidl_fuchsia_posix::Errno>,
80575 ) -> Result<(), fidl::Error> {
80576 self.control_handle.inner.send::<fidl::encoding::ResultType<
80577 BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
80578 fidl_fuchsia_posix::Errno,
80579 >>(
80580 result.map(|value| (value,)),
80581 self.tx_id,
80582 0x1f26fcdd348f1882,
80583 fidl::encoding::DynamicFlags::empty(),
80584 )
80585 }
80586}
80587
80588#[must_use = "FIDL methods require a response to be sent"]
80589#[derive(Debug)]
80590pub struct SynchronousDatagramSocketSetIpv6UnicastHopsResponder {
80591 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80592 tx_id: u32,
80593}
80594
80595impl std::ops::Drop for SynchronousDatagramSocketSetIpv6UnicastHopsResponder {
80599 fn drop(&mut self) {
80600 self.control_handle.shutdown();
80601 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80603 }
80604}
80605
80606impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6UnicastHopsResponder {
80607 type ControlHandle = SynchronousDatagramSocketControlHandle;
80608
80609 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80610 &self.control_handle
80611 }
80612
80613 fn drop_without_shutdown(mut self) {
80614 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80616 std::mem::forget(self);
80618 }
80619}
80620
80621impl SynchronousDatagramSocketSetIpv6UnicastHopsResponder {
80622 pub fn send(
80626 self,
80627 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80628 ) -> Result<(), fidl::Error> {
80629 let _result = self.send_raw(result);
80630 if _result.is_err() {
80631 self.control_handle.shutdown();
80632 }
80633 self.drop_without_shutdown();
80634 _result
80635 }
80636
80637 pub fn send_no_shutdown_on_err(
80639 self,
80640 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80641 ) -> Result<(), fidl::Error> {
80642 let _result = self.send_raw(result);
80643 self.drop_without_shutdown();
80644 _result
80645 }
80646
80647 fn send_raw(
80648 &self,
80649 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80650 ) -> Result<(), fidl::Error> {
80651 self.control_handle.inner.send::<fidl::encoding::ResultType<
80652 fidl::encoding::EmptyStruct,
80653 fidl_fuchsia_posix::Errno,
80654 >>(
80655 result,
80656 self.tx_id,
80657 0x157d51e98f462859,
80658 fidl::encoding::DynamicFlags::empty(),
80659 )
80660 }
80661}
80662
80663#[must_use = "FIDL methods require a response to be sent"]
80664#[derive(Debug)]
80665pub struct SynchronousDatagramSocketGetIpv6UnicastHopsResponder {
80666 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80667 tx_id: u32,
80668}
80669
80670impl std::ops::Drop for SynchronousDatagramSocketGetIpv6UnicastHopsResponder {
80674 fn drop(&mut self) {
80675 self.control_handle.shutdown();
80676 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80678 }
80679}
80680
80681impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6UnicastHopsResponder {
80682 type ControlHandle = SynchronousDatagramSocketControlHandle;
80683
80684 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80685 &self.control_handle
80686 }
80687
80688 fn drop_without_shutdown(mut self) {
80689 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80691 std::mem::forget(self);
80693 }
80694}
80695
80696impl SynchronousDatagramSocketGetIpv6UnicastHopsResponder {
80697 pub fn send(
80701 self,
80702 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
80703 ) -> Result<(), fidl::Error> {
80704 let _result = self.send_raw(result);
80705 if _result.is_err() {
80706 self.control_handle.shutdown();
80707 }
80708 self.drop_without_shutdown();
80709 _result
80710 }
80711
80712 pub fn send_no_shutdown_on_err(
80714 self,
80715 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
80716 ) -> Result<(), fidl::Error> {
80717 let _result = self.send_raw(result);
80718 self.drop_without_shutdown();
80719 _result
80720 }
80721
80722 fn send_raw(
80723 &self,
80724 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
80725 ) -> Result<(), fidl::Error> {
80726 self.control_handle.inner.send::<fidl::encoding::ResultType<
80727 BaseNetworkSocketGetIpv6UnicastHopsResponse,
80728 fidl_fuchsia_posix::Errno,
80729 >>(
80730 result.map(|value| (value,)),
80731 self.tx_id,
80732 0x21f4641cad8bd8d2,
80733 fidl::encoding::DynamicFlags::empty(),
80734 )
80735 }
80736}
80737
80738#[must_use = "FIDL methods require a response to be sent"]
80739#[derive(Debug)]
80740pub struct SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder {
80741 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80742 tx_id: u32,
80743}
80744
80745impl std::ops::Drop for SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder {
80749 fn drop(&mut self) {
80750 self.control_handle.shutdown();
80751 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80753 }
80754}
80755
80756impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder {
80757 type ControlHandle = SynchronousDatagramSocketControlHandle;
80758
80759 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80760 &self.control_handle
80761 }
80762
80763 fn drop_without_shutdown(mut self) {
80764 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80766 std::mem::forget(self);
80768 }
80769}
80770
80771impl SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder {
80772 pub fn send(
80776 self,
80777 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80778 ) -> Result<(), fidl::Error> {
80779 let _result = self.send_raw(result);
80780 if _result.is_err() {
80781 self.control_handle.shutdown();
80782 }
80783 self.drop_without_shutdown();
80784 _result
80785 }
80786
80787 pub fn send_no_shutdown_on_err(
80789 self,
80790 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80791 ) -> Result<(), fidl::Error> {
80792 let _result = self.send_raw(result);
80793 self.drop_without_shutdown();
80794 _result
80795 }
80796
80797 fn send_raw(
80798 &self,
80799 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80800 ) -> Result<(), fidl::Error> {
80801 self.control_handle.inner.send::<fidl::encoding::ResultType<
80802 fidl::encoding::EmptyStruct,
80803 fidl_fuchsia_posix::Errno,
80804 >>(
80805 result,
80806 self.tx_id,
80807 0x5c24808ed2e84a1e,
80808 fidl::encoding::DynamicFlags::empty(),
80809 )
80810 }
80811}
80812
80813#[must_use = "FIDL methods require a response to be sent"]
80814#[derive(Debug)]
80815pub struct SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder {
80816 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80817 tx_id: u32,
80818}
80819
80820impl std::ops::Drop for SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder {
80824 fn drop(&mut self) {
80825 self.control_handle.shutdown();
80826 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80828 }
80829}
80830
80831impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder {
80832 type ControlHandle = SynchronousDatagramSocketControlHandle;
80833
80834 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80835 &self.control_handle
80836 }
80837
80838 fn drop_without_shutdown(mut self) {
80839 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80841 std::mem::forget(self);
80843 }
80844}
80845
80846impl SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder {
80847 pub fn send(
80851 self,
80852 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80853 ) -> Result<(), fidl::Error> {
80854 let _result = self.send_raw(result);
80855 if _result.is_err() {
80856 self.control_handle.shutdown();
80857 }
80858 self.drop_without_shutdown();
80859 _result
80860 }
80861
80862 pub fn send_no_shutdown_on_err(
80864 self,
80865 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80866 ) -> Result<(), fidl::Error> {
80867 let _result = self.send_raw(result);
80868 self.drop_without_shutdown();
80869 _result
80870 }
80871
80872 fn send_raw(
80873 &self,
80874 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80875 ) -> Result<(), fidl::Error> {
80876 self.control_handle.inner.send::<fidl::encoding::ResultType<
80877 BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
80878 fidl_fuchsia_posix::Errno,
80879 >>(
80880 result.map(|value| (value,)),
80881 self.tx_id,
80882 0x341e06689885b4c0,
80883 fidl::encoding::DynamicFlags::empty(),
80884 )
80885 }
80886}
80887
80888#[must_use = "FIDL methods require a response to be sent"]
80889#[derive(Debug)]
80890pub struct SynchronousDatagramSocketSetIpv6MulticastHopsResponder {
80891 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80892 tx_id: u32,
80893}
80894
80895impl std::ops::Drop for SynchronousDatagramSocketSetIpv6MulticastHopsResponder {
80899 fn drop(&mut self) {
80900 self.control_handle.shutdown();
80901 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80903 }
80904}
80905
80906impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6MulticastHopsResponder {
80907 type ControlHandle = SynchronousDatagramSocketControlHandle;
80908
80909 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80910 &self.control_handle
80911 }
80912
80913 fn drop_without_shutdown(mut self) {
80914 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80916 std::mem::forget(self);
80918 }
80919}
80920
80921impl SynchronousDatagramSocketSetIpv6MulticastHopsResponder {
80922 pub fn send(
80926 self,
80927 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80928 ) -> Result<(), fidl::Error> {
80929 let _result = self.send_raw(result);
80930 if _result.is_err() {
80931 self.control_handle.shutdown();
80932 }
80933 self.drop_without_shutdown();
80934 _result
80935 }
80936
80937 pub fn send_no_shutdown_on_err(
80939 self,
80940 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80941 ) -> Result<(), fidl::Error> {
80942 let _result = self.send_raw(result);
80943 self.drop_without_shutdown();
80944 _result
80945 }
80946
80947 fn send_raw(
80948 &self,
80949 mut result: Result<(), fidl_fuchsia_posix::Errno>,
80950 ) -> Result<(), fidl::Error> {
80951 self.control_handle.inner.send::<fidl::encoding::ResultType<
80952 fidl::encoding::EmptyStruct,
80953 fidl_fuchsia_posix::Errno,
80954 >>(
80955 result,
80956 self.tx_id,
80957 0x25b9cd4d181f82c1,
80958 fidl::encoding::DynamicFlags::empty(),
80959 )
80960 }
80961}
80962
80963#[must_use = "FIDL methods require a response to be sent"]
80964#[derive(Debug)]
80965pub struct SynchronousDatagramSocketGetIpv6MulticastHopsResponder {
80966 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80967 tx_id: u32,
80968}
80969
80970impl std::ops::Drop for SynchronousDatagramSocketGetIpv6MulticastHopsResponder {
80974 fn drop(&mut self) {
80975 self.control_handle.shutdown();
80976 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80978 }
80979}
80980
80981impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6MulticastHopsResponder {
80982 type ControlHandle = SynchronousDatagramSocketControlHandle;
80983
80984 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80985 &self.control_handle
80986 }
80987
80988 fn drop_without_shutdown(mut self) {
80989 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80991 std::mem::forget(self);
80993 }
80994}
80995
80996impl SynchronousDatagramSocketGetIpv6MulticastHopsResponder {
80997 pub fn send(
81001 self,
81002 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
81003 ) -> Result<(), fidl::Error> {
81004 let _result = self.send_raw(result);
81005 if _result.is_err() {
81006 self.control_handle.shutdown();
81007 }
81008 self.drop_without_shutdown();
81009 _result
81010 }
81011
81012 pub fn send_no_shutdown_on_err(
81014 self,
81015 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
81016 ) -> Result<(), fidl::Error> {
81017 let _result = self.send_raw(result);
81018 self.drop_without_shutdown();
81019 _result
81020 }
81021
81022 fn send_raw(
81023 &self,
81024 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
81025 ) -> Result<(), fidl::Error> {
81026 self.control_handle.inner.send::<fidl::encoding::ResultType<
81027 BaseNetworkSocketGetIpv6MulticastHopsResponse,
81028 fidl_fuchsia_posix::Errno,
81029 >>(
81030 result.map(|value| (value,)),
81031 self.tx_id,
81032 0x52916948a365012a,
81033 fidl::encoding::DynamicFlags::empty(),
81034 )
81035 }
81036}
81037
81038#[must_use = "FIDL methods require a response to be sent"]
81039#[derive(Debug)]
81040pub struct SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder {
81041 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81042 tx_id: u32,
81043}
81044
81045impl std::ops::Drop for SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder {
81049 fn drop(&mut self) {
81050 self.control_handle.shutdown();
81051 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81053 }
81054}
81055
81056impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder {
81057 type ControlHandle = SynchronousDatagramSocketControlHandle;
81058
81059 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81060 &self.control_handle
81061 }
81062
81063 fn drop_without_shutdown(mut self) {
81064 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81066 std::mem::forget(self);
81068 }
81069}
81070
81071impl SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder {
81072 pub fn send(
81076 self,
81077 mut result: Result<(), fidl_fuchsia_posix::Errno>,
81078 ) -> Result<(), fidl::Error> {
81079 let _result = self.send_raw(result);
81080 if _result.is_err() {
81081 self.control_handle.shutdown();
81082 }
81083 self.drop_without_shutdown();
81084 _result
81085 }
81086
81087 pub fn send_no_shutdown_on_err(
81089 self,
81090 mut result: Result<(), fidl_fuchsia_posix::Errno>,
81091 ) -> Result<(), fidl::Error> {
81092 let _result = self.send_raw(result);
81093 self.drop_without_shutdown();
81094 _result
81095 }
81096
81097 fn send_raw(
81098 &self,
81099 mut result: Result<(), fidl_fuchsia_posix::Errno>,
81100 ) -> Result<(), fidl::Error> {
81101 self.control_handle.inner.send::<fidl::encoding::ResultType<
81102 fidl::encoding::EmptyStruct,
81103 fidl_fuchsia_posix::Errno,
81104 >>(
81105 result,
81106 self.tx_id,
81107 0x55701c409ff41b40,
81108 fidl::encoding::DynamicFlags::empty(),
81109 )
81110 }
81111}
81112
81113#[must_use = "FIDL methods require a response to be sent"]
81114#[derive(Debug)]
81115pub struct SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder {
81116 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81117 tx_id: u32,
81118}
81119
81120impl std::ops::Drop for SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder {
81124 fn drop(&mut self) {
81125 self.control_handle.shutdown();
81126 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81128 }
81129}
81130
81131impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder {
81132 type ControlHandle = SynchronousDatagramSocketControlHandle;
81133
81134 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81135 &self.control_handle
81136 }
81137
81138 fn drop_without_shutdown(mut self) {
81139 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81141 std::mem::forget(self);
81143 }
81144}
81145
81146impl SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder {
81147 pub fn send(
81151 self,
81152 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81153 ) -> Result<(), fidl::Error> {
81154 let _result = self.send_raw(result);
81155 if _result.is_err() {
81156 self.control_handle.shutdown();
81157 }
81158 self.drop_without_shutdown();
81159 _result
81160 }
81161
81162 pub fn send_no_shutdown_on_err(
81164 self,
81165 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81166 ) -> Result<(), fidl::Error> {
81167 let _result = self.send_raw(result);
81168 self.drop_without_shutdown();
81169 _result
81170 }
81171
81172 fn send_raw(
81173 &self,
81174 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81175 ) -> Result<(), fidl::Error> {
81176 self.control_handle.inner.send::<fidl::encoding::ResultType<
81177 BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
81178 fidl_fuchsia_posix::Errno,
81179 >>(
81180 result.map(|value| (value,)),
81181 self.tx_id,
81182 0x4415b701fde319c3,
81183 fidl::encoding::DynamicFlags::empty(),
81184 )
81185 }
81186}
81187
81188#[must_use = "FIDL methods require a response to be sent"]
81189#[derive(Debug)]
81190pub struct SynchronousDatagramSocketSetIpv6OnlyResponder {
81191 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81192 tx_id: u32,
81193}
81194
81195impl std::ops::Drop for SynchronousDatagramSocketSetIpv6OnlyResponder {
81199 fn drop(&mut self) {
81200 self.control_handle.shutdown();
81201 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81203 }
81204}
81205
81206impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6OnlyResponder {
81207 type ControlHandle = SynchronousDatagramSocketControlHandle;
81208
81209 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81210 &self.control_handle
81211 }
81212
81213 fn drop_without_shutdown(mut self) {
81214 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81216 std::mem::forget(self);
81218 }
81219}
81220
81221impl SynchronousDatagramSocketSetIpv6OnlyResponder {
81222 pub fn send(
81226 self,
81227 mut result: Result<(), fidl_fuchsia_posix::Errno>,
81228 ) -> Result<(), fidl::Error> {
81229 let _result = self.send_raw(result);
81230 if _result.is_err() {
81231 self.control_handle.shutdown();
81232 }
81233 self.drop_without_shutdown();
81234 _result
81235 }
81236
81237 pub fn send_no_shutdown_on_err(
81239 self,
81240 mut result: Result<(), fidl_fuchsia_posix::Errno>,
81241 ) -> Result<(), fidl::Error> {
81242 let _result = self.send_raw(result);
81243 self.drop_without_shutdown();
81244 _result
81245 }
81246
81247 fn send_raw(
81248 &self,
81249 mut result: Result<(), fidl_fuchsia_posix::Errno>,
81250 ) -> Result<(), fidl::Error> {
81251 self.control_handle.inner.send::<fidl::encoding::ResultType<
81252 fidl::encoding::EmptyStruct,
81253 fidl_fuchsia_posix::Errno,
81254 >>(
81255 result,
81256 self.tx_id,
81257 0x4873f1364758cbba,
81258 fidl::encoding::DynamicFlags::empty(),
81259 )
81260 }
81261}
81262
81263#[must_use = "FIDL methods require a response to be sent"]
81264#[derive(Debug)]
81265pub struct SynchronousDatagramSocketGetIpv6OnlyResponder {
81266 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81267 tx_id: u32,
81268}
81269
81270impl std::ops::Drop for SynchronousDatagramSocketGetIpv6OnlyResponder {
81274 fn drop(&mut self) {
81275 self.control_handle.shutdown();
81276 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81278 }
81279}
81280
81281impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6OnlyResponder {
81282 type ControlHandle = SynchronousDatagramSocketControlHandle;
81283
81284 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81285 &self.control_handle
81286 }
81287
81288 fn drop_without_shutdown(mut self) {
81289 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81291 std::mem::forget(self);
81293 }
81294}
81295
81296impl SynchronousDatagramSocketGetIpv6OnlyResponder {
81297 pub fn send(
81301 self,
81302 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81303 ) -> Result<(), fidl::Error> {
81304 let _result = self.send_raw(result);
81305 if _result.is_err() {
81306 self.control_handle.shutdown();
81307 }
81308 self.drop_without_shutdown();
81309 _result
81310 }
81311
81312 pub fn send_no_shutdown_on_err(
81314 self,
81315 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81316 ) -> Result<(), fidl::Error> {
81317 let _result = self.send_raw(result);
81318 self.drop_without_shutdown();
81319 _result
81320 }
81321
81322 fn send_raw(
81323 &self,
81324 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81325 ) -> Result<(), fidl::Error> {
81326 self.control_handle.inner.send::<fidl::encoding::ResultType<
81327 BaseNetworkSocketGetIpv6OnlyResponse,
81328 fidl_fuchsia_posix::Errno,
81329 >>(
81330 result.map(|value| (value,)),
81331 self.tx_id,
81332 0x4aa3340a1a26b89c,
81333 fidl::encoding::DynamicFlags::empty(),
81334 )
81335 }
81336}
81337
81338#[must_use = "FIDL methods require a response to be sent"]
81339#[derive(Debug)]
81340pub struct SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder {
81341 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81342 tx_id: u32,
81343}
81344
81345impl std::ops::Drop for SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder {
81349 fn drop(&mut self) {
81350 self.control_handle.shutdown();
81351 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81353 }
81354}
81355
81356impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder {
81357 type ControlHandle = SynchronousDatagramSocketControlHandle;
81358
81359 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81360 &self.control_handle
81361 }
81362
81363 fn drop_without_shutdown(mut self) {
81364 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81366 std::mem::forget(self);
81368 }
81369}
81370
81371impl SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder {
81372 pub fn send(
81376 self,
81377 mut result: Result<(), fidl_fuchsia_posix::Errno>,
81378 ) -> Result<(), fidl::Error> {
81379 let _result = self.send_raw(result);
81380 if _result.is_err() {
81381 self.control_handle.shutdown();
81382 }
81383 self.drop_without_shutdown();
81384 _result
81385 }
81386
81387 pub fn send_no_shutdown_on_err(
81389 self,
81390 mut result: Result<(), fidl_fuchsia_posix::Errno>,
81391 ) -> Result<(), fidl::Error> {
81392 let _result = self.send_raw(result);
81393 self.drop_without_shutdown();
81394 _result
81395 }
81396
81397 fn send_raw(
81398 &self,
81399 mut result: Result<(), fidl_fuchsia_posix::Errno>,
81400 ) -> Result<(), fidl::Error> {
81401 self.control_handle.inner.send::<fidl::encoding::ResultType<
81402 fidl::encoding::EmptyStruct,
81403 fidl_fuchsia_posix::Errno,
81404 >>(
81405 result,
81406 self.tx_id,
81407 0x58f07c8788d099a0,
81408 fidl::encoding::DynamicFlags::empty(),
81409 )
81410 }
81411}
81412
81413#[must_use = "FIDL methods require a response to be sent"]
81414#[derive(Debug)]
81415pub struct SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder {
81416 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81417 tx_id: u32,
81418}
81419
81420impl std::ops::Drop for SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder {
81424 fn drop(&mut self) {
81425 self.control_handle.shutdown();
81426 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81428 }
81429}
81430
81431impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder {
81432 type ControlHandle = SynchronousDatagramSocketControlHandle;
81433
81434 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81435 &self.control_handle
81436 }
81437
81438 fn drop_without_shutdown(mut self) {
81439 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81441 std::mem::forget(self);
81443 }
81444}
81445
81446impl SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder {
81447 pub fn send(
81451 self,
81452 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81453 ) -> Result<(), fidl::Error> {
81454 let _result = self.send_raw(result);
81455 if _result.is_err() {
81456 self.control_handle.shutdown();
81457 }
81458 self.drop_without_shutdown();
81459 _result
81460 }
81461
81462 pub fn send_no_shutdown_on_err(
81464 self,
81465 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81466 ) -> Result<(), fidl::Error> {
81467 let _result = self.send_raw(result);
81468 self.drop_without_shutdown();
81469 _result
81470 }
81471
81472 fn send_raw(
81473 &self,
81474 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81475 ) -> Result<(), fidl::Error> {
81476 self.control_handle.inner.send::<fidl::encoding::ResultType<
81477 BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
81478 fidl_fuchsia_posix::Errno,
81479 >>(
81480 result.map(|value| (value,)),
81481 self.tx_id,
81482 0x2e334df1da553ffa,
81483 fidl::encoding::DynamicFlags::empty(),
81484 )
81485 }
81486}
81487
81488#[must_use = "FIDL methods require a response to be sent"]
81489#[derive(Debug)]
81490pub struct SynchronousDatagramSocketSetIpv6TrafficClassResponder {
81491 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81492 tx_id: u32,
81493}
81494
81495impl std::ops::Drop for SynchronousDatagramSocketSetIpv6TrafficClassResponder {
81499 fn drop(&mut self) {
81500 self.control_handle.shutdown();
81501 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81503 }
81504}
81505
81506impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6TrafficClassResponder {
81507 type ControlHandle = SynchronousDatagramSocketControlHandle;
81508
81509 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81510 &self.control_handle
81511 }
81512
81513 fn drop_without_shutdown(mut self) {
81514 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81516 std::mem::forget(self);
81518 }
81519}
81520
81521impl SynchronousDatagramSocketSetIpv6TrafficClassResponder {
81522 pub fn send(
81526 self,
81527 mut result: Result<(), fidl_fuchsia_posix::Errno>,
81528 ) -> Result<(), fidl::Error> {
81529 let _result = self.send_raw(result);
81530 if _result.is_err() {
81531 self.control_handle.shutdown();
81532 }
81533 self.drop_without_shutdown();
81534 _result
81535 }
81536
81537 pub fn send_no_shutdown_on_err(
81539 self,
81540 mut result: Result<(), fidl_fuchsia_posix::Errno>,
81541 ) -> Result<(), fidl::Error> {
81542 let _result = self.send_raw(result);
81543 self.drop_without_shutdown();
81544 _result
81545 }
81546
81547 fn send_raw(
81548 &self,
81549 mut result: Result<(), fidl_fuchsia_posix::Errno>,
81550 ) -> Result<(), fidl::Error> {
81551 self.control_handle.inner.send::<fidl::encoding::ResultType<
81552 fidl::encoding::EmptyStruct,
81553 fidl_fuchsia_posix::Errno,
81554 >>(
81555 result,
81556 self.tx_id,
81557 0x6af077800c5a0b4f,
81558 fidl::encoding::DynamicFlags::empty(),
81559 )
81560 }
81561}
81562
81563#[must_use = "FIDL methods require a response to be sent"]
81564#[derive(Debug)]
81565pub struct SynchronousDatagramSocketGetIpv6TrafficClassResponder {
81566 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81567 tx_id: u32,
81568}
81569
81570impl std::ops::Drop for SynchronousDatagramSocketGetIpv6TrafficClassResponder {
81574 fn drop(&mut self) {
81575 self.control_handle.shutdown();
81576 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81578 }
81579}
81580
81581impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6TrafficClassResponder {
81582 type ControlHandle = SynchronousDatagramSocketControlHandle;
81583
81584 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81585 &self.control_handle
81586 }
81587
81588 fn drop_without_shutdown(mut self) {
81589 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81591 std::mem::forget(self);
81593 }
81594}
81595
81596impl SynchronousDatagramSocketGetIpv6TrafficClassResponder {
81597 pub fn send(
81601 self,
81602 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
81603 ) -> Result<(), fidl::Error> {
81604 let _result = self.send_raw(result);
81605 if _result.is_err() {
81606 self.control_handle.shutdown();
81607 }
81608 self.drop_without_shutdown();
81609 _result
81610 }
81611
81612 pub fn send_no_shutdown_on_err(
81614 self,
81615 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
81616 ) -> Result<(), fidl::Error> {
81617 let _result = self.send_raw(result);
81618 self.drop_without_shutdown();
81619 _result
81620 }
81621
81622 fn send_raw(
81623 &self,
81624 mut result: Result<u8, fidl_fuchsia_posix::Errno>,
81625 ) -> Result<(), fidl::Error> {
81626 self.control_handle.inner.send::<fidl::encoding::ResultType<
81627 BaseNetworkSocketGetIpv6TrafficClassResponse,
81628 fidl_fuchsia_posix::Errno,
81629 >>(
81630 result.map(|value| (value,)),
81631 self.tx_id,
81632 0x6baf6eed8fc2f04,
81633 fidl::encoding::DynamicFlags::empty(),
81634 )
81635 }
81636}
81637
81638#[must_use = "FIDL methods require a response to be sent"]
81639#[derive(Debug)]
81640pub struct SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder {
81641 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81642 tx_id: u32,
81643}
81644
81645impl std::ops::Drop for SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder {
81649 fn drop(&mut self) {
81650 self.control_handle.shutdown();
81651 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81653 }
81654}
81655
81656impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder {
81657 type ControlHandle = SynchronousDatagramSocketControlHandle;
81658
81659 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81660 &self.control_handle
81661 }
81662
81663 fn drop_without_shutdown(mut self) {
81664 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81666 std::mem::forget(self);
81668 }
81669}
81670
81671impl SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder {
81672 pub fn send(
81676 self,
81677 mut result: Result<(), fidl_fuchsia_posix::Errno>,
81678 ) -> Result<(), fidl::Error> {
81679 let _result = self.send_raw(result);
81680 if _result.is_err() {
81681 self.control_handle.shutdown();
81682 }
81683 self.drop_without_shutdown();
81684 _result
81685 }
81686
81687 pub fn send_no_shutdown_on_err(
81689 self,
81690 mut result: Result<(), fidl_fuchsia_posix::Errno>,
81691 ) -> Result<(), fidl::Error> {
81692 let _result = self.send_raw(result);
81693 self.drop_without_shutdown();
81694 _result
81695 }
81696
81697 fn send_raw(
81698 &self,
81699 mut result: Result<(), fidl_fuchsia_posix::Errno>,
81700 ) -> Result<(), fidl::Error> {
81701 self.control_handle.inner.send::<fidl::encoding::ResultType<
81702 fidl::encoding::EmptyStruct,
81703 fidl_fuchsia_posix::Errno,
81704 >>(
81705 result,
81706 self.tx_id,
81707 0x19259775b1a92768,
81708 fidl::encoding::DynamicFlags::empty(),
81709 )
81710 }
81711}
81712
81713#[must_use = "FIDL methods require a response to be sent"]
81714#[derive(Debug)]
81715pub struct SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder {
81716 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81717 tx_id: u32,
81718}
81719
81720impl std::ops::Drop for SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder {
81724 fn drop(&mut self) {
81725 self.control_handle.shutdown();
81726 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81728 }
81729}
81730
81731impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder {
81732 type ControlHandle = SynchronousDatagramSocketControlHandle;
81733
81734 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81735 &self.control_handle
81736 }
81737
81738 fn drop_without_shutdown(mut self) {
81739 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81741 std::mem::forget(self);
81743 }
81744}
81745
81746impl SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder {
81747 pub fn send(
81751 self,
81752 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81753 ) -> Result<(), fidl::Error> {
81754 let _result = self.send_raw(result);
81755 if _result.is_err() {
81756 self.control_handle.shutdown();
81757 }
81758 self.drop_without_shutdown();
81759 _result
81760 }
81761
81762 pub fn send_no_shutdown_on_err(
81764 self,
81765 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81766 ) -> Result<(), fidl::Error> {
81767 let _result = self.send_raw(result);
81768 self.drop_without_shutdown();
81769 _result
81770 }
81771
81772 fn send_raw(
81773 &self,
81774 mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81775 ) -> Result<(), fidl::Error> {
81776 self.control_handle.inner.send::<fidl::encoding::ResultType<
81777 BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
81778 fidl_fuchsia_posix::Errno,
81779 >>(
81780 result.map(|value| (value,)),
81781 self.tx_id,
81782 0x7acd4a2775baec75,
81783 fidl::encoding::DynamicFlags::empty(),
81784 )
81785 }
81786}
81787
81788#[must_use = "FIDL methods require a response to be sent"]
81789#[derive(Debug)]
81790pub struct SynchronousDatagramSocketGetOriginalDestinationResponder {
81791 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81792 tx_id: u32,
81793}
81794
81795impl std::ops::Drop for SynchronousDatagramSocketGetOriginalDestinationResponder {
81799 fn drop(&mut self) {
81800 self.control_handle.shutdown();
81801 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81803 }
81804}
81805
81806impl fidl::endpoints::Responder for SynchronousDatagramSocketGetOriginalDestinationResponder {
81807 type ControlHandle = SynchronousDatagramSocketControlHandle;
81808
81809 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81810 &self.control_handle
81811 }
81812
81813 fn drop_without_shutdown(mut self) {
81814 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81816 std::mem::forget(self);
81818 }
81819}
81820
81821impl SynchronousDatagramSocketGetOriginalDestinationResponder {
81822 pub fn send(
81826 self,
81827 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
81828 ) -> Result<(), fidl::Error> {
81829 let _result = self.send_raw(result);
81830 if _result.is_err() {
81831 self.control_handle.shutdown();
81832 }
81833 self.drop_without_shutdown();
81834 _result
81835 }
81836
81837 pub fn send_no_shutdown_on_err(
81839 self,
81840 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
81841 ) -> Result<(), fidl::Error> {
81842 let _result = self.send_raw(result);
81843 self.drop_without_shutdown();
81844 _result
81845 }
81846
81847 fn send_raw(
81848 &self,
81849 mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
81850 ) -> Result<(), fidl::Error> {
81851 self.control_handle.inner.send::<fidl::encoding::ResultType<
81852 BaseNetworkSocketGetOriginalDestinationResponse,
81853 fidl_fuchsia_posix::Errno,
81854 >>(
81855 result.map(|value| (value,)),
81856 self.tx_id,
81857 0x38bf28f0dafdbac0,
81858 fidl::encoding::DynamicFlags::empty(),
81859 )
81860 }
81861}
81862
81863#[must_use = "FIDL methods require a response to be sent"]
81864#[derive(Debug)]
81865pub struct SynchronousDatagramSocketGetInfoResponder {
81866 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81867 tx_id: u32,
81868}
81869
81870impl std::ops::Drop for SynchronousDatagramSocketGetInfoResponder {
81874 fn drop(&mut self) {
81875 self.control_handle.shutdown();
81876 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81878 }
81879}
81880
81881impl fidl::endpoints::Responder for SynchronousDatagramSocketGetInfoResponder {
81882 type ControlHandle = SynchronousDatagramSocketControlHandle;
81883
81884 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81885 &self.control_handle
81886 }
81887
81888 fn drop_without_shutdown(mut self) {
81889 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81891 std::mem::forget(self);
81893 }
81894}
81895
81896impl SynchronousDatagramSocketGetInfoResponder {
81897 pub fn send(
81901 self,
81902 mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
81903 ) -> Result<(), fidl::Error> {
81904 let _result = self.send_raw(result);
81905 if _result.is_err() {
81906 self.control_handle.shutdown();
81907 }
81908 self.drop_without_shutdown();
81909 _result
81910 }
81911
81912 pub fn send_no_shutdown_on_err(
81914 self,
81915 mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
81916 ) -> Result<(), fidl::Error> {
81917 let _result = self.send_raw(result);
81918 self.drop_without_shutdown();
81919 _result
81920 }
81921
81922 fn send_raw(
81923 &self,
81924 mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
81925 ) -> Result<(), fidl::Error> {
81926 self.control_handle.inner.send::<fidl::encoding::ResultType<
81927 BaseDatagramSocketGetInfoResponse,
81928 fidl_fuchsia_posix::Errno,
81929 >>(
81930 result,
81931 self.tx_id,
81932 0x48aa0a1f6a32d2ed,
81933 fidl::encoding::DynamicFlags::empty(),
81934 )
81935 }
81936}
81937
81938#[must_use = "FIDL methods require a response to be sent"]
81939#[derive(Debug)]
81940pub struct SynchronousDatagramSocketDescribeResponder {
81941 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81942 tx_id: u32,
81943}
81944
81945impl std::ops::Drop for SynchronousDatagramSocketDescribeResponder {
81949 fn drop(&mut self) {
81950 self.control_handle.shutdown();
81951 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81953 }
81954}
81955
81956impl fidl::endpoints::Responder for SynchronousDatagramSocketDescribeResponder {
81957 type ControlHandle = SynchronousDatagramSocketControlHandle;
81958
81959 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81960 &self.control_handle
81961 }
81962
81963 fn drop_without_shutdown(mut self) {
81964 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81966 std::mem::forget(self);
81968 }
81969}
81970
81971impl SynchronousDatagramSocketDescribeResponder {
81972 pub fn send(
81976 self,
81977 mut payload: SynchronousDatagramSocketDescribeResponse,
81978 ) -> Result<(), fidl::Error> {
81979 let _result = self.send_raw(payload);
81980 if _result.is_err() {
81981 self.control_handle.shutdown();
81982 }
81983 self.drop_without_shutdown();
81984 _result
81985 }
81986
81987 pub fn send_no_shutdown_on_err(
81989 self,
81990 mut payload: SynchronousDatagramSocketDescribeResponse,
81991 ) -> Result<(), fidl::Error> {
81992 let _result = self.send_raw(payload);
81993 self.drop_without_shutdown();
81994 _result
81995 }
81996
81997 fn send_raw(
81998 &self,
81999 mut payload: SynchronousDatagramSocketDescribeResponse,
82000 ) -> Result<(), fidl::Error> {
82001 self.control_handle.inner.send::<SynchronousDatagramSocketDescribeResponse>(
82002 &mut payload,
82003 self.tx_id,
82004 0x585f20b73631070d,
82005 fidl::encoding::DynamicFlags::empty(),
82006 )
82007 }
82008}
82009
82010#[must_use = "FIDL methods require a response to be sent"]
82011#[derive(Debug)]
82012pub struct SynchronousDatagramSocketRecvMsgResponder {
82013 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
82014 tx_id: u32,
82015}
82016
82017impl std::ops::Drop for SynchronousDatagramSocketRecvMsgResponder {
82021 fn drop(&mut self) {
82022 self.control_handle.shutdown();
82023 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
82025 }
82026}
82027
82028impl fidl::endpoints::Responder for SynchronousDatagramSocketRecvMsgResponder {
82029 type ControlHandle = SynchronousDatagramSocketControlHandle;
82030
82031 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
82032 &self.control_handle
82033 }
82034
82035 fn drop_without_shutdown(mut self) {
82036 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
82038 std::mem::forget(self);
82040 }
82041}
82042
82043impl SynchronousDatagramSocketRecvMsgResponder {
82044 pub fn send(
82048 self,
82049 mut result: Result<
82050 (Option<&fidl_fuchsia_net::SocketAddress>, &[u8], &DatagramSocketRecvControlData, u32),
82051 fidl_fuchsia_posix::Errno,
82052 >,
82053 ) -> Result<(), fidl::Error> {
82054 let _result = self.send_raw(result);
82055 if _result.is_err() {
82056 self.control_handle.shutdown();
82057 }
82058 self.drop_without_shutdown();
82059 _result
82060 }
82061
82062 pub fn send_no_shutdown_on_err(
82064 self,
82065 mut result: Result<
82066 (Option<&fidl_fuchsia_net::SocketAddress>, &[u8], &DatagramSocketRecvControlData, u32),
82067 fidl_fuchsia_posix::Errno,
82068 >,
82069 ) -> Result<(), fidl::Error> {
82070 let _result = self.send_raw(result);
82071 self.drop_without_shutdown();
82072 _result
82073 }
82074
82075 fn send_raw(
82076 &self,
82077 mut result: Result<
82078 (Option<&fidl_fuchsia_net::SocketAddress>, &[u8], &DatagramSocketRecvControlData, u32),
82079 fidl_fuchsia_posix::Errno,
82080 >,
82081 ) -> Result<(), fidl::Error> {
82082 self.control_handle.inner.send::<fidl::encoding::ResultType<
82083 SynchronousDatagramSocketRecvMsgResponse,
82084 fidl_fuchsia_posix::Errno,
82085 >>(
82086 result,
82087 self.tx_id,
82088 0x28e494e48fb5dbf3,
82089 fidl::encoding::DynamicFlags::empty(),
82090 )
82091 }
82092}
82093
82094#[must_use = "FIDL methods require a response to be sent"]
82095#[derive(Debug)]
82096pub struct SynchronousDatagramSocketSendMsgResponder {
82097 control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
82098 tx_id: u32,
82099}
82100
82101impl std::ops::Drop for SynchronousDatagramSocketSendMsgResponder {
82105 fn drop(&mut self) {
82106 self.control_handle.shutdown();
82107 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
82109 }
82110}
82111
82112impl fidl::endpoints::Responder for SynchronousDatagramSocketSendMsgResponder {
82113 type ControlHandle = SynchronousDatagramSocketControlHandle;
82114
82115 fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
82116 &self.control_handle
82117 }
82118
82119 fn drop_without_shutdown(mut self) {
82120 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
82122 std::mem::forget(self);
82124 }
82125}
82126
82127impl SynchronousDatagramSocketSendMsgResponder {
82128 pub fn send(
82132 self,
82133 mut result: Result<i64, fidl_fuchsia_posix::Errno>,
82134 ) -> Result<(), fidl::Error> {
82135 let _result = self.send_raw(result);
82136 if _result.is_err() {
82137 self.control_handle.shutdown();
82138 }
82139 self.drop_without_shutdown();
82140 _result
82141 }
82142
82143 pub fn send_no_shutdown_on_err(
82145 self,
82146 mut result: Result<i64, fidl_fuchsia_posix::Errno>,
82147 ) -> Result<(), fidl::Error> {
82148 let _result = self.send_raw(result);
82149 self.drop_without_shutdown();
82150 _result
82151 }
82152
82153 fn send_raw(
82154 &self,
82155 mut result: Result<i64, fidl_fuchsia_posix::Errno>,
82156 ) -> Result<(), fidl::Error> {
82157 self.control_handle.inner.send::<fidl::encoding::ResultType<
82158 SynchronousDatagramSocketSendMsgResponse,
82159 fidl_fuchsia_posix::Errno,
82160 >>(
82161 result.map(|len| (len,)),
82162 self.tx_id,
82163 0x12dc2fceab6cefaa,
82164 fidl::encoding::DynamicFlags::empty(),
82165 )
82166 }
82167}
82168
82169mod internal {
82170 use super::*;
82171
82172 impl fidl::encoding::ResourceTypeMarker for ProviderDatagramSocketDeprecatedResponse {
82173 type Borrowed<'a> = &'a mut Self;
82174 fn take_or_borrow<'a>(
82175 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
82176 ) -> Self::Borrowed<'a> {
82177 value
82178 }
82179 }
82180
82181 unsafe impl fidl::encoding::TypeMarker for ProviderDatagramSocketDeprecatedResponse {
82182 type Owned = Self;
82183
82184 #[inline(always)]
82185 fn inline_align(_context: fidl::encoding::Context) -> usize {
82186 4
82187 }
82188
82189 #[inline(always)]
82190 fn inline_size(_context: fidl::encoding::Context) -> usize {
82191 4
82192 }
82193 }
82194
82195 unsafe impl
82196 fidl::encoding::Encode<
82197 ProviderDatagramSocketDeprecatedResponse,
82198 fidl::encoding::DefaultFuchsiaResourceDialect,
82199 > for &mut ProviderDatagramSocketDeprecatedResponse
82200 {
82201 #[inline]
82202 unsafe fn encode(
82203 self,
82204 encoder: &mut fidl::encoding::Encoder<
82205 '_,
82206 fidl::encoding::DefaultFuchsiaResourceDialect,
82207 >,
82208 offset: usize,
82209 _depth: fidl::encoding::Depth,
82210 ) -> fidl::Result<()> {
82211 encoder.debug_check_bounds::<ProviderDatagramSocketDeprecatedResponse>(offset);
82212 fidl::encoding::Encode::<
82214 ProviderDatagramSocketDeprecatedResponse,
82215 fidl::encoding::DefaultFuchsiaResourceDialect,
82216 >::encode(
82217 (<fidl::encoding::Endpoint<
82218 fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
82219 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
82220 &mut self.s
82221 ),),
82222 encoder,
82223 offset,
82224 _depth,
82225 )
82226 }
82227 }
82228 unsafe impl<
82229 T0: fidl::encoding::Encode<
82230 fidl::encoding::Endpoint<
82231 fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
82232 >,
82233 fidl::encoding::DefaultFuchsiaResourceDialect,
82234 >,
82235 >
82236 fidl::encoding::Encode<
82237 ProviderDatagramSocketDeprecatedResponse,
82238 fidl::encoding::DefaultFuchsiaResourceDialect,
82239 > for (T0,)
82240 {
82241 #[inline]
82242 unsafe fn encode(
82243 self,
82244 encoder: &mut fidl::encoding::Encoder<
82245 '_,
82246 fidl::encoding::DefaultFuchsiaResourceDialect,
82247 >,
82248 offset: usize,
82249 depth: fidl::encoding::Depth,
82250 ) -> fidl::Result<()> {
82251 encoder.debug_check_bounds::<ProviderDatagramSocketDeprecatedResponse>(offset);
82252 self.0.encode(encoder, offset + 0, depth)?;
82256 Ok(())
82257 }
82258 }
82259
82260 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
82261 for ProviderDatagramSocketDeprecatedResponse
82262 {
82263 #[inline(always)]
82264 fn new_empty() -> Self {
82265 Self {
82266 s: fidl::new_empty!(
82267 fidl::encoding::Endpoint<
82268 fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
82269 >,
82270 fidl::encoding::DefaultFuchsiaResourceDialect
82271 ),
82272 }
82273 }
82274
82275 #[inline]
82276 unsafe fn decode(
82277 &mut self,
82278 decoder: &mut fidl::encoding::Decoder<
82279 '_,
82280 fidl::encoding::DefaultFuchsiaResourceDialect,
82281 >,
82282 offset: usize,
82283 _depth: fidl::encoding::Depth,
82284 ) -> fidl::Result<()> {
82285 decoder.debug_check_bounds::<Self>(offset);
82286 fidl::decode!(
82288 fidl::encoding::Endpoint<
82289 fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
82290 >,
82291 fidl::encoding::DefaultFuchsiaResourceDialect,
82292 &mut self.s,
82293 decoder,
82294 offset + 0,
82295 _depth
82296 )?;
82297 Ok(())
82298 }
82299 }
82300
82301 impl fidl::encoding::ResourceTypeMarker for ProviderStreamSocketWithOptionsResponse {
82302 type Borrowed<'a> = &'a mut Self;
82303 fn take_or_borrow<'a>(
82304 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
82305 ) -> Self::Borrowed<'a> {
82306 value
82307 }
82308 }
82309
82310 unsafe impl fidl::encoding::TypeMarker for ProviderStreamSocketWithOptionsResponse {
82311 type Owned = Self;
82312
82313 #[inline(always)]
82314 fn inline_align(_context: fidl::encoding::Context) -> usize {
82315 4
82316 }
82317
82318 #[inline(always)]
82319 fn inline_size(_context: fidl::encoding::Context) -> usize {
82320 4
82321 }
82322 }
82323
82324 unsafe impl
82325 fidl::encoding::Encode<
82326 ProviderStreamSocketWithOptionsResponse,
82327 fidl::encoding::DefaultFuchsiaResourceDialect,
82328 > for &mut ProviderStreamSocketWithOptionsResponse
82329 {
82330 #[inline]
82331 unsafe fn encode(
82332 self,
82333 encoder: &mut fidl::encoding::Encoder<
82334 '_,
82335 fidl::encoding::DefaultFuchsiaResourceDialect,
82336 >,
82337 offset: usize,
82338 _depth: fidl::encoding::Depth,
82339 ) -> fidl::Result<()> {
82340 encoder.debug_check_bounds::<ProviderStreamSocketWithOptionsResponse>(offset);
82341 fidl::encoding::Encode::<ProviderStreamSocketWithOptionsResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
82343 (
82344 <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.s),
82345 ),
82346 encoder, offset, _depth
82347 )
82348 }
82349 }
82350 unsafe impl<
82351 T0: fidl::encoding::Encode<
82352 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82353 fidl::encoding::DefaultFuchsiaResourceDialect,
82354 >,
82355 >
82356 fidl::encoding::Encode<
82357 ProviderStreamSocketWithOptionsResponse,
82358 fidl::encoding::DefaultFuchsiaResourceDialect,
82359 > for (T0,)
82360 {
82361 #[inline]
82362 unsafe fn encode(
82363 self,
82364 encoder: &mut fidl::encoding::Encoder<
82365 '_,
82366 fidl::encoding::DefaultFuchsiaResourceDialect,
82367 >,
82368 offset: usize,
82369 depth: fidl::encoding::Depth,
82370 ) -> fidl::Result<()> {
82371 encoder.debug_check_bounds::<ProviderStreamSocketWithOptionsResponse>(offset);
82372 self.0.encode(encoder, offset + 0, depth)?;
82376 Ok(())
82377 }
82378 }
82379
82380 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
82381 for ProviderStreamSocketWithOptionsResponse
82382 {
82383 #[inline(always)]
82384 fn new_empty() -> Self {
82385 Self {
82386 s: fidl::new_empty!(
82387 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82388 fidl::encoding::DefaultFuchsiaResourceDialect
82389 ),
82390 }
82391 }
82392
82393 #[inline]
82394 unsafe fn decode(
82395 &mut self,
82396 decoder: &mut fidl::encoding::Decoder<
82397 '_,
82398 fidl::encoding::DefaultFuchsiaResourceDialect,
82399 >,
82400 offset: usize,
82401 _depth: fidl::encoding::Depth,
82402 ) -> fidl::Result<()> {
82403 decoder.debug_check_bounds::<Self>(offset);
82404 fidl::decode!(
82406 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82407 fidl::encoding::DefaultFuchsiaResourceDialect,
82408 &mut self.s,
82409 decoder,
82410 offset + 0,
82411 _depth
82412 )?;
82413 Ok(())
82414 }
82415 }
82416
82417 impl fidl::encoding::ResourceTypeMarker for ProviderStreamSocketResponse {
82418 type Borrowed<'a> = &'a mut Self;
82419 fn take_or_borrow<'a>(
82420 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
82421 ) -> Self::Borrowed<'a> {
82422 value
82423 }
82424 }
82425
82426 unsafe impl fidl::encoding::TypeMarker for ProviderStreamSocketResponse {
82427 type Owned = Self;
82428
82429 #[inline(always)]
82430 fn inline_align(_context: fidl::encoding::Context) -> usize {
82431 4
82432 }
82433
82434 #[inline(always)]
82435 fn inline_size(_context: fidl::encoding::Context) -> usize {
82436 4
82437 }
82438 }
82439
82440 unsafe impl
82441 fidl::encoding::Encode<
82442 ProviderStreamSocketResponse,
82443 fidl::encoding::DefaultFuchsiaResourceDialect,
82444 > for &mut ProviderStreamSocketResponse
82445 {
82446 #[inline]
82447 unsafe fn encode(
82448 self,
82449 encoder: &mut fidl::encoding::Encoder<
82450 '_,
82451 fidl::encoding::DefaultFuchsiaResourceDialect,
82452 >,
82453 offset: usize,
82454 _depth: fidl::encoding::Depth,
82455 ) -> fidl::Result<()> {
82456 encoder.debug_check_bounds::<ProviderStreamSocketResponse>(offset);
82457 fidl::encoding::Encode::<ProviderStreamSocketResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
82459 (
82460 <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.s),
82461 ),
82462 encoder, offset, _depth
82463 )
82464 }
82465 }
82466 unsafe impl<
82467 T0: fidl::encoding::Encode<
82468 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82469 fidl::encoding::DefaultFuchsiaResourceDialect,
82470 >,
82471 >
82472 fidl::encoding::Encode<
82473 ProviderStreamSocketResponse,
82474 fidl::encoding::DefaultFuchsiaResourceDialect,
82475 > for (T0,)
82476 {
82477 #[inline]
82478 unsafe fn encode(
82479 self,
82480 encoder: &mut fidl::encoding::Encoder<
82481 '_,
82482 fidl::encoding::DefaultFuchsiaResourceDialect,
82483 >,
82484 offset: usize,
82485 depth: fidl::encoding::Depth,
82486 ) -> fidl::Result<()> {
82487 encoder.debug_check_bounds::<ProviderStreamSocketResponse>(offset);
82488 self.0.encode(encoder, offset + 0, depth)?;
82492 Ok(())
82493 }
82494 }
82495
82496 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
82497 for ProviderStreamSocketResponse
82498 {
82499 #[inline(always)]
82500 fn new_empty() -> Self {
82501 Self {
82502 s: fidl::new_empty!(
82503 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82504 fidl::encoding::DefaultFuchsiaResourceDialect
82505 ),
82506 }
82507 }
82508
82509 #[inline]
82510 unsafe fn decode(
82511 &mut self,
82512 decoder: &mut fidl::encoding::Decoder<
82513 '_,
82514 fidl::encoding::DefaultFuchsiaResourceDialect,
82515 >,
82516 offset: usize,
82517 _depth: fidl::encoding::Depth,
82518 ) -> fidl::Result<()> {
82519 decoder.debug_check_bounds::<Self>(offset);
82520 fidl::decode!(
82522 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82523 fidl::encoding::DefaultFuchsiaResourceDialect,
82524 &mut self.s,
82525 decoder,
82526 offset + 0,
82527 _depth
82528 )?;
82529 Ok(())
82530 }
82531 }
82532
82533 impl fidl::encoding::ResourceTypeMarker for StreamSocketAcceptResponse {
82534 type Borrowed<'a> = &'a mut Self;
82535 fn take_or_borrow<'a>(
82536 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
82537 ) -> Self::Borrowed<'a> {
82538 value
82539 }
82540 }
82541
82542 unsafe impl fidl::encoding::TypeMarker for StreamSocketAcceptResponse {
82543 type Owned = Self;
82544
82545 #[inline(always)]
82546 fn inline_align(_context: fidl::encoding::Context) -> usize {
82547 8
82548 }
82549
82550 #[inline(always)]
82551 fn inline_size(_context: fidl::encoding::Context) -> usize {
82552 24
82553 }
82554 }
82555
82556 unsafe impl
82557 fidl::encoding::Encode<
82558 StreamSocketAcceptResponse,
82559 fidl::encoding::DefaultFuchsiaResourceDialect,
82560 > for &mut StreamSocketAcceptResponse
82561 {
82562 #[inline]
82563 unsafe fn encode(
82564 self,
82565 encoder: &mut fidl::encoding::Encoder<
82566 '_,
82567 fidl::encoding::DefaultFuchsiaResourceDialect,
82568 >,
82569 offset: usize,
82570 _depth: fidl::encoding::Depth,
82571 ) -> fidl::Result<()> {
82572 encoder.debug_check_bounds::<StreamSocketAcceptResponse>(offset);
82573 fidl::encoding::Encode::<StreamSocketAcceptResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
82575 (
82576 <fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress> as fidl::encoding::ValueTypeMarker>::borrow(&self.addr),
82577 <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.s),
82578 ),
82579 encoder, offset, _depth
82580 )
82581 }
82582 }
82583 unsafe impl<
82584 T0: fidl::encoding::Encode<
82585 fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress>,
82586 fidl::encoding::DefaultFuchsiaResourceDialect,
82587 >,
82588 T1: fidl::encoding::Encode<
82589 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82590 fidl::encoding::DefaultFuchsiaResourceDialect,
82591 >,
82592 >
82593 fidl::encoding::Encode<
82594 StreamSocketAcceptResponse,
82595 fidl::encoding::DefaultFuchsiaResourceDialect,
82596 > for (T0, T1)
82597 {
82598 #[inline]
82599 unsafe fn encode(
82600 self,
82601 encoder: &mut fidl::encoding::Encoder<
82602 '_,
82603 fidl::encoding::DefaultFuchsiaResourceDialect,
82604 >,
82605 offset: usize,
82606 depth: fidl::encoding::Depth,
82607 ) -> fidl::Result<()> {
82608 encoder.debug_check_bounds::<StreamSocketAcceptResponse>(offset);
82609 unsafe {
82612 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
82613 (ptr as *mut u64).write_unaligned(0);
82614 }
82615 self.0.encode(encoder, offset + 0, depth)?;
82617 self.1.encode(encoder, offset + 16, depth)?;
82618 Ok(())
82619 }
82620 }
82621
82622 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
82623 for StreamSocketAcceptResponse
82624 {
82625 #[inline(always)]
82626 fn new_empty() -> Self {
82627 Self {
82628 addr: fidl::new_empty!(
82629 fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress>,
82630 fidl::encoding::DefaultFuchsiaResourceDialect
82631 ),
82632 s: fidl::new_empty!(
82633 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82634 fidl::encoding::DefaultFuchsiaResourceDialect
82635 ),
82636 }
82637 }
82638
82639 #[inline]
82640 unsafe fn decode(
82641 &mut self,
82642 decoder: &mut fidl::encoding::Decoder<
82643 '_,
82644 fidl::encoding::DefaultFuchsiaResourceDialect,
82645 >,
82646 offset: usize,
82647 _depth: fidl::encoding::Depth,
82648 ) -> fidl::Result<()> {
82649 decoder.debug_check_bounds::<Self>(offset);
82650 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
82652 let padval = unsafe { (ptr as *const u64).read_unaligned() };
82653 let mask = 0xffffffff00000000u64;
82654 let maskedval = padval & mask;
82655 if maskedval != 0 {
82656 return Err(fidl::Error::NonZeroPadding {
82657 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
82658 });
82659 }
82660 fidl::decode!(
82661 fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress>,
82662 fidl::encoding::DefaultFuchsiaResourceDialect,
82663 &mut self.addr,
82664 decoder,
82665 offset + 0,
82666 _depth
82667 )?;
82668 fidl::decode!(
82669 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82670 fidl::encoding::DefaultFuchsiaResourceDialect,
82671 &mut self.s,
82672 decoder,
82673 offset + 16,
82674 _depth
82675 )?;
82676 Ok(())
82677 }
82678 }
82679
82680 impl DatagramSocketDescribeResponse {
82681 #[inline(always)]
82682 fn max_ordinal_present(&self) -> u64 {
82683 if let Some(_) = self.metadata_encoding_protocol_version {
82684 return 4;
82685 }
82686 if let Some(_) = self.rx_meta_buf_size {
82687 return 3;
82688 }
82689 if let Some(_) = self.tx_meta_buf_size {
82690 return 2;
82691 }
82692 if let Some(_) = self.socket {
82693 return 1;
82694 }
82695 0
82696 }
82697 }
82698
82699 impl fidl::encoding::ResourceTypeMarker for DatagramSocketDescribeResponse {
82700 type Borrowed<'a> = &'a mut Self;
82701 fn take_or_borrow<'a>(
82702 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
82703 ) -> Self::Borrowed<'a> {
82704 value
82705 }
82706 }
82707
82708 unsafe impl fidl::encoding::TypeMarker for DatagramSocketDescribeResponse {
82709 type Owned = Self;
82710
82711 #[inline(always)]
82712 fn inline_align(_context: fidl::encoding::Context) -> usize {
82713 8
82714 }
82715
82716 #[inline(always)]
82717 fn inline_size(_context: fidl::encoding::Context) -> usize {
82718 16
82719 }
82720 }
82721
82722 unsafe impl
82723 fidl::encoding::Encode<
82724 DatagramSocketDescribeResponse,
82725 fidl::encoding::DefaultFuchsiaResourceDialect,
82726 > for &mut DatagramSocketDescribeResponse
82727 {
82728 unsafe fn encode(
82729 self,
82730 encoder: &mut fidl::encoding::Encoder<
82731 '_,
82732 fidl::encoding::DefaultFuchsiaResourceDialect,
82733 >,
82734 offset: usize,
82735 mut depth: fidl::encoding::Depth,
82736 ) -> fidl::Result<()> {
82737 encoder.debug_check_bounds::<DatagramSocketDescribeResponse>(offset);
82738 let max_ordinal: u64 = self.max_ordinal_present();
82740 encoder.write_num(max_ordinal, offset);
82741 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
82742 if max_ordinal == 0 {
82744 return Ok(());
82745 }
82746 depth.increment()?;
82747 let envelope_size = 8;
82748 let bytes_len = max_ordinal as usize * envelope_size;
82749 #[allow(unused_variables)]
82750 let offset = encoder.out_of_line_offset(bytes_len);
82751 let mut _prev_end_offset: usize = 0;
82752 if 1 > max_ordinal {
82753 return Ok(());
82754 }
82755
82756 let cur_offset: usize = (1 - 1) * envelope_size;
82759
82760 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
82762
82763 fidl::encoding::encode_in_envelope_optional::<
82768 fidl::encoding::HandleType<
82769 fidl::Socket,
82770 { fidl::ObjectType::SOCKET.into_raw() },
82771 2147483648,
82772 >,
82773 fidl::encoding::DefaultFuchsiaResourceDialect,
82774 >(
82775 self.socket.as_mut().map(
82776 <fidl::encoding::HandleType<
82777 fidl::Socket,
82778 { fidl::ObjectType::SOCKET.into_raw() },
82779 2147483648,
82780 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
82781 ),
82782 encoder,
82783 offset + cur_offset,
82784 depth,
82785 )?;
82786
82787 _prev_end_offset = cur_offset + envelope_size;
82788 if 2 > max_ordinal {
82789 return Ok(());
82790 }
82791
82792 let cur_offset: usize = (2 - 1) * envelope_size;
82795
82796 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
82798
82799 fidl::encoding::encode_in_envelope_optional::<
82804 u64,
82805 fidl::encoding::DefaultFuchsiaResourceDialect,
82806 >(
82807 self.tx_meta_buf_size
82808 .as_ref()
82809 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
82810 encoder,
82811 offset + cur_offset,
82812 depth,
82813 )?;
82814
82815 _prev_end_offset = cur_offset + envelope_size;
82816 if 3 > max_ordinal {
82817 return Ok(());
82818 }
82819
82820 let cur_offset: usize = (3 - 1) * envelope_size;
82823
82824 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
82826
82827 fidl::encoding::encode_in_envelope_optional::<
82832 u64,
82833 fidl::encoding::DefaultFuchsiaResourceDialect,
82834 >(
82835 self.rx_meta_buf_size
82836 .as_ref()
82837 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
82838 encoder,
82839 offset + cur_offset,
82840 depth,
82841 )?;
82842
82843 _prev_end_offset = cur_offset + envelope_size;
82844 if 4 > max_ordinal {
82845 return Ok(());
82846 }
82847
82848 let cur_offset: usize = (4 - 1) * envelope_size;
82851
82852 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
82854
82855 fidl::encoding::encode_in_envelope_optional::<
82860 UdpMetadataEncodingProtocolVersion,
82861 fidl::encoding::DefaultFuchsiaResourceDialect,
82862 >(
82863 self.metadata_encoding_protocol_version.as_ref().map(
82864 <UdpMetadataEncodingProtocolVersion as fidl::encoding::ValueTypeMarker>::borrow,
82865 ),
82866 encoder,
82867 offset + cur_offset,
82868 depth,
82869 )?;
82870
82871 _prev_end_offset = cur_offset + envelope_size;
82872
82873 Ok(())
82874 }
82875 }
82876
82877 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
82878 for DatagramSocketDescribeResponse
82879 {
82880 #[inline(always)]
82881 fn new_empty() -> Self {
82882 Self::default()
82883 }
82884
82885 unsafe fn decode(
82886 &mut self,
82887 decoder: &mut fidl::encoding::Decoder<
82888 '_,
82889 fidl::encoding::DefaultFuchsiaResourceDialect,
82890 >,
82891 offset: usize,
82892 mut depth: fidl::encoding::Depth,
82893 ) -> fidl::Result<()> {
82894 decoder.debug_check_bounds::<Self>(offset);
82895 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
82896 None => return Err(fidl::Error::NotNullable),
82897 Some(len) => len,
82898 };
82899 if len == 0 {
82901 return Ok(());
82902 };
82903 depth.increment()?;
82904 let envelope_size = 8;
82905 let bytes_len = len * envelope_size;
82906 let offset = decoder.out_of_line_offset(bytes_len)?;
82907 let mut _next_ordinal_to_read = 0;
82909 let mut next_offset = offset;
82910 let end_offset = offset + bytes_len;
82911 _next_ordinal_to_read += 1;
82912 if next_offset >= end_offset {
82913 return Ok(());
82914 }
82915
82916 while _next_ordinal_to_read < 1 {
82918 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
82919 _next_ordinal_to_read += 1;
82920 next_offset += envelope_size;
82921 }
82922
82923 let next_out_of_line = decoder.next_out_of_line();
82924 let handles_before = decoder.remaining_handles();
82925 if let Some((inlined, num_bytes, num_handles)) =
82926 fidl::encoding::decode_envelope_header(decoder, next_offset)?
82927 {
82928 let member_inline_size = <fidl::encoding::HandleType<
82929 fidl::Socket,
82930 { fidl::ObjectType::SOCKET.into_raw() },
82931 2147483648,
82932 > as fidl::encoding::TypeMarker>::inline_size(
82933 decoder.context
82934 );
82935 if inlined != (member_inline_size <= 4) {
82936 return Err(fidl::Error::InvalidInlineBitInEnvelope);
82937 }
82938 let inner_offset;
82939 let mut inner_depth = depth.clone();
82940 if inlined {
82941 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
82942 inner_offset = next_offset;
82943 } else {
82944 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
82945 inner_depth.increment()?;
82946 }
82947 let val_ref =
82948 self.socket.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
82949 fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
82950 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
82951 {
82952 return Err(fidl::Error::InvalidNumBytesInEnvelope);
82953 }
82954 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
82955 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
82956 }
82957 }
82958
82959 next_offset += envelope_size;
82960 _next_ordinal_to_read += 1;
82961 if next_offset >= end_offset {
82962 return Ok(());
82963 }
82964
82965 while _next_ordinal_to_read < 2 {
82967 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
82968 _next_ordinal_to_read += 1;
82969 next_offset += envelope_size;
82970 }
82971
82972 let next_out_of_line = decoder.next_out_of_line();
82973 let handles_before = decoder.remaining_handles();
82974 if let Some((inlined, num_bytes, num_handles)) =
82975 fidl::encoding::decode_envelope_header(decoder, next_offset)?
82976 {
82977 let member_inline_size =
82978 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
82979 if inlined != (member_inline_size <= 4) {
82980 return Err(fidl::Error::InvalidInlineBitInEnvelope);
82981 }
82982 let inner_offset;
82983 let mut inner_depth = depth.clone();
82984 if inlined {
82985 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
82986 inner_offset = next_offset;
82987 } else {
82988 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
82989 inner_depth.increment()?;
82990 }
82991 let val_ref = self.tx_meta_buf_size.get_or_insert_with(|| {
82992 fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
82993 });
82994 fidl::decode!(
82995 u64,
82996 fidl::encoding::DefaultFuchsiaResourceDialect,
82997 val_ref,
82998 decoder,
82999 inner_offset,
83000 inner_depth
83001 )?;
83002 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83003 {
83004 return Err(fidl::Error::InvalidNumBytesInEnvelope);
83005 }
83006 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83007 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83008 }
83009 }
83010
83011 next_offset += envelope_size;
83012 _next_ordinal_to_read += 1;
83013 if next_offset >= end_offset {
83014 return Ok(());
83015 }
83016
83017 while _next_ordinal_to_read < 3 {
83019 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83020 _next_ordinal_to_read += 1;
83021 next_offset += envelope_size;
83022 }
83023
83024 let next_out_of_line = decoder.next_out_of_line();
83025 let handles_before = decoder.remaining_handles();
83026 if let Some((inlined, num_bytes, num_handles)) =
83027 fidl::encoding::decode_envelope_header(decoder, next_offset)?
83028 {
83029 let member_inline_size =
83030 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
83031 if inlined != (member_inline_size <= 4) {
83032 return Err(fidl::Error::InvalidInlineBitInEnvelope);
83033 }
83034 let inner_offset;
83035 let mut inner_depth = depth.clone();
83036 if inlined {
83037 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
83038 inner_offset = next_offset;
83039 } else {
83040 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
83041 inner_depth.increment()?;
83042 }
83043 let val_ref = self.rx_meta_buf_size.get_or_insert_with(|| {
83044 fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
83045 });
83046 fidl::decode!(
83047 u64,
83048 fidl::encoding::DefaultFuchsiaResourceDialect,
83049 val_ref,
83050 decoder,
83051 inner_offset,
83052 inner_depth
83053 )?;
83054 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83055 {
83056 return Err(fidl::Error::InvalidNumBytesInEnvelope);
83057 }
83058 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83059 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83060 }
83061 }
83062
83063 next_offset += envelope_size;
83064 _next_ordinal_to_read += 1;
83065 if next_offset >= end_offset {
83066 return Ok(());
83067 }
83068
83069 while _next_ordinal_to_read < 4 {
83071 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83072 _next_ordinal_to_read += 1;
83073 next_offset += envelope_size;
83074 }
83075
83076 let next_out_of_line = decoder.next_out_of_line();
83077 let handles_before = decoder.remaining_handles();
83078 if let Some((inlined, num_bytes, num_handles)) =
83079 fidl::encoding::decode_envelope_header(decoder, next_offset)?
83080 {
83081 let member_inline_size =
83082 <UdpMetadataEncodingProtocolVersion as fidl::encoding::TypeMarker>::inline_size(
83083 decoder.context,
83084 );
83085 if inlined != (member_inline_size <= 4) {
83086 return Err(fidl::Error::InvalidInlineBitInEnvelope);
83087 }
83088 let inner_offset;
83089 let mut inner_depth = depth.clone();
83090 if inlined {
83091 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
83092 inner_offset = next_offset;
83093 } else {
83094 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
83095 inner_depth.increment()?;
83096 }
83097 let val_ref = self.metadata_encoding_protocol_version.get_or_insert_with(|| {
83098 fidl::new_empty!(
83099 UdpMetadataEncodingProtocolVersion,
83100 fidl::encoding::DefaultFuchsiaResourceDialect
83101 )
83102 });
83103 fidl::decode!(
83104 UdpMetadataEncodingProtocolVersion,
83105 fidl::encoding::DefaultFuchsiaResourceDialect,
83106 val_ref,
83107 decoder,
83108 inner_offset,
83109 inner_depth
83110 )?;
83111 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83112 {
83113 return Err(fidl::Error::InvalidNumBytesInEnvelope);
83114 }
83115 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83116 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83117 }
83118 }
83119
83120 next_offset += envelope_size;
83121
83122 while next_offset < end_offset {
83124 _next_ordinal_to_read += 1;
83125 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83126 next_offset += envelope_size;
83127 }
83128
83129 Ok(())
83130 }
83131 }
83132
83133 impl DatagramSocketRecvMsgPostflightResponse {
83134 #[inline(always)]
83135 fn max_ordinal_present(&self) -> u64 {
83136 if let Some(_) = self.requests {
83137 return 3;
83138 }
83139 if let Some(_) = self.timestamp {
83140 return 2;
83141 }
83142 if let Some(_) = self.validity {
83143 return 1;
83144 }
83145 0
83146 }
83147 }
83148
83149 impl fidl::encoding::ResourceTypeMarker for DatagramSocketRecvMsgPostflightResponse {
83150 type Borrowed<'a> = &'a mut Self;
83151 fn take_or_borrow<'a>(
83152 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
83153 ) -> Self::Borrowed<'a> {
83154 value
83155 }
83156 }
83157
83158 unsafe impl fidl::encoding::TypeMarker for DatagramSocketRecvMsgPostflightResponse {
83159 type Owned = Self;
83160
83161 #[inline(always)]
83162 fn inline_align(_context: fidl::encoding::Context) -> usize {
83163 8
83164 }
83165
83166 #[inline(always)]
83167 fn inline_size(_context: fidl::encoding::Context) -> usize {
83168 16
83169 }
83170 }
83171
83172 unsafe impl
83173 fidl::encoding::Encode<
83174 DatagramSocketRecvMsgPostflightResponse,
83175 fidl::encoding::DefaultFuchsiaResourceDialect,
83176 > for &mut DatagramSocketRecvMsgPostflightResponse
83177 {
83178 unsafe fn encode(
83179 self,
83180 encoder: &mut fidl::encoding::Encoder<
83181 '_,
83182 fidl::encoding::DefaultFuchsiaResourceDialect,
83183 >,
83184 offset: usize,
83185 mut depth: fidl::encoding::Depth,
83186 ) -> fidl::Result<()> {
83187 encoder.debug_check_bounds::<DatagramSocketRecvMsgPostflightResponse>(offset);
83188 let max_ordinal: u64 = self.max_ordinal_present();
83190 encoder.write_num(max_ordinal, offset);
83191 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
83192 if max_ordinal == 0 {
83194 return Ok(());
83195 }
83196 depth.increment()?;
83197 let envelope_size = 8;
83198 let bytes_len = max_ordinal as usize * envelope_size;
83199 #[allow(unused_variables)]
83200 let offset = encoder.out_of_line_offset(bytes_len);
83201 let mut _prev_end_offset: usize = 0;
83202 if 1 > max_ordinal {
83203 return Ok(());
83204 }
83205
83206 let cur_offset: usize = (1 - 1) * envelope_size;
83209
83210 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
83212
83213 fidl::encoding::encode_in_envelope_optional::<
83218 fidl::encoding::HandleType<
83219 fidl::EventPair,
83220 { fidl::ObjectType::EVENTPAIR.into_raw() },
83221 49155,
83222 >,
83223 fidl::encoding::DefaultFuchsiaResourceDialect,
83224 >(
83225 self.validity.as_mut().map(
83226 <fidl::encoding::HandleType<
83227 fidl::EventPair,
83228 { fidl::ObjectType::EVENTPAIR.into_raw() },
83229 49155,
83230 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
83231 ),
83232 encoder,
83233 offset + cur_offset,
83234 depth,
83235 )?;
83236
83237 _prev_end_offset = cur_offset + envelope_size;
83238 if 2 > max_ordinal {
83239 return Ok(());
83240 }
83241
83242 let cur_offset: usize = (2 - 1) * envelope_size;
83245
83246 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
83248
83249 fidl::encoding::encode_in_envelope_optional::<
83254 TimestampOption,
83255 fidl::encoding::DefaultFuchsiaResourceDialect,
83256 >(
83257 self.timestamp
83258 .as_ref()
83259 .map(<TimestampOption as fidl::encoding::ValueTypeMarker>::borrow),
83260 encoder,
83261 offset + cur_offset,
83262 depth,
83263 )?;
83264
83265 _prev_end_offset = cur_offset + envelope_size;
83266 if 3 > max_ordinal {
83267 return Ok(());
83268 }
83269
83270 let cur_offset: usize = (3 - 1) * envelope_size;
83273
83274 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
83276
83277 fidl::encoding::encode_in_envelope_optional::<
83282 CmsgRequests,
83283 fidl::encoding::DefaultFuchsiaResourceDialect,
83284 >(
83285 self.requests
83286 .as_ref()
83287 .map(<CmsgRequests as fidl::encoding::ValueTypeMarker>::borrow),
83288 encoder,
83289 offset + cur_offset,
83290 depth,
83291 )?;
83292
83293 _prev_end_offset = cur_offset + envelope_size;
83294
83295 Ok(())
83296 }
83297 }
83298
83299 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
83300 for DatagramSocketRecvMsgPostflightResponse
83301 {
83302 #[inline(always)]
83303 fn new_empty() -> Self {
83304 Self::default()
83305 }
83306
83307 unsafe fn decode(
83308 &mut self,
83309 decoder: &mut fidl::encoding::Decoder<
83310 '_,
83311 fidl::encoding::DefaultFuchsiaResourceDialect,
83312 >,
83313 offset: usize,
83314 mut depth: fidl::encoding::Depth,
83315 ) -> fidl::Result<()> {
83316 decoder.debug_check_bounds::<Self>(offset);
83317 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
83318 None => return Err(fidl::Error::NotNullable),
83319 Some(len) => len,
83320 };
83321 if len == 0 {
83323 return Ok(());
83324 };
83325 depth.increment()?;
83326 let envelope_size = 8;
83327 let bytes_len = len * envelope_size;
83328 let offset = decoder.out_of_line_offset(bytes_len)?;
83329 let mut _next_ordinal_to_read = 0;
83331 let mut next_offset = offset;
83332 let end_offset = offset + bytes_len;
83333 _next_ordinal_to_read += 1;
83334 if next_offset >= end_offset {
83335 return Ok(());
83336 }
83337
83338 while _next_ordinal_to_read < 1 {
83340 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83341 _next_ordinal_to_read += 1;
83342 next_offset += envelope_size;
83343 }
83344
83345 let next_out_of_line = decoder.next_out_of_line();
83346 let handles_before = decoder.remaining_handles();
83347 if let Some((inlined, num_bytes, num_handles)) =
83348 fidl::encoding::decode_envelope_header(decoder, next_offset)?
83349 {
83350 let member_inline_size = <fidl::encoding::HandleType<
83351 fidl::EventPair,
83352 { fidl::ObjectType::EVENTPAIR.into_raw() },
83353 49155,
83354 > as fidl::encoding::TypeMarker>::inline_size(
83355 decoder.context
83356 );
83357 if inlined != (member_inline_size <= 4) {
83358 return Err(fidl::Error::InvalidInlineBitInEnvelope);
83359 }
83360 let inner_offset;
83361 let mut inner_depth = depth.clone();
83362 if inlined {
83363 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
83364 inner_offset = next_offset;
83365 } else {
83366 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
83367 inner_depth.increment()?;
83368 }
83369 let val_ref =
83370 self.validity.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 49155>, fidl::encoding::DefaultFuchsiaResourceDialect));
83371 fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 49155>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
83372 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83373 {
83374 return Err(fidl::Error::InvalidNumBytesInEnvelope);
83375 }
83376 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83377 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83378 }
83379 }
83380
83381 next_offset += envelope_size;
83382 _next_ordinal_to_read += 1;
83383 if next_offset >= end_offset {
83384 return Ok(());
83385 }
83386
83387 while _next_ordinal_to_read < 2 {
83389 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83390 _next_ordinal_to_read += 1;
83391 next_offset += envelope_size;
83392 }
83393
83394 let next_out_of_line = decoder.next_out_of_line();
83395 let handles_before = decoder.remaining_handles();
83396 if let Some((inlined, num_bytes, num_handles)) =
83397 fidl::encoding::decode_envelope_header(decoder, next_offset)?
83398 {
83399 let member_inline_size =
83400 <TimestampOption as fidl::encoding::TypeMarker>::inline_size(decoder.context);
83401 if inlined != (member_inline_size <= 4) {
83402 return Err(fidl::Error::InvalidInlineBitInEnvelope);
83403 }
83404 let inner_offset;
83405 let mut inner_depth = depth.clone();
83406 if inlined {
83407 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
83408 inner_offset = next_offset;
83409 } else {
83410 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
83411 inner_depth.increment()?;
83412 }
83413 let val_ref = self.timestamp.get_or_insert_with(|| {
83414 fidl::new_empty!(TimestampOption, fidl::encoding::DefaultFuchsiaResourceDialect)
83415 });
83416 fidl::decode!(
83417 TimestampOption,
83418 fidl::encoding::DefaultFuchsiaResourceDialect,
83419 val_ref,
83420 decoder,
83421 inner_offset,
83422 inner_depth
83423 )?;
83424 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83425 {
83426 return Err(fidl::Error::InvalidNumBytesInEnvelope);
83427 }
83428 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83429 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83430 }
83431 }
83432
83433 next_offset += envelope_size;
83434 _next_ordinal_to_read += 1;
83435 if next_offset >= end_offset {
83436 return Ok(());
83437 }
83438
83439 while _next_ordinal_to_read < 3 {
83441 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83442 _next_ordinal_to_read += 1;
83443 next_offset += envelope_size;
83444 }
83445
83446 let next_out_of_line = decoder.next_out_of_line();
83447 let handles_before = decoder.remaining_handles();
83448 if let Some((inlined, num_bytes, num_handles)) =
83449 fidl::encoding::decode_envelope_header(decoder, next_offset)?
83450 {
83451 let member_inline_size =
83452 <CmsgRequests as fidl::encoding::TypeMarker>::inline_size(decoder.context);
83453 if inlined != (member_inline_size <= 4) {
83454 return Err(fidl::Error::InvalidInlineBitInEnvelope);
83455 }
83456 let inner_offset;
83457 let mut inner_depth = depth.clone();
83458 if inlined {
83459 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
83460 inner_offset = next_offset;
83461 } else {
83462 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
83463 inner_depth.increment()?;
83464 }
83465 let val_ref = self.requests.get_or_insert_with(|| {
83466 fidl::new_empty!(CmsgRequests, fidl::encoding::DefaultFuchsiaResourceDialect)
83467 });
83468 fidl::decode!(
83469 CmsgRequests,
83470 fidl::encoding::DefaultFuchsiaResourceDialect,
83471 val_ref,
83472 decoder,
83473 inner_offset,
83474 inner_depth
83475 )?;
83476 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83477 {
83478 return Err(fidl::Error::InvalidNumBytesInEnvelope);
83479 }
83480 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83481 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83482 }
83483 }
83484
83485 next_offset += envelope_size;
83486
83487 while next_offset < end_offset {
83489 _next_ordinal_to_read += 1;
83490 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83491 next_offset += envelope_size;
83492 }
83493
83494 Ok(())
83495 }
83496 }
83497
83498 impl DatagramSocketSendMsgPreflightResponse {
83499 #[inline(always)]
83500 fn max_ordinal_present(&self) -> u64 {
83501 if let Some(_) = self.maximum_size {
83502 return 3;
83503 }
83504 if let Some(_) = self.validity {
83505 return 2;
83506 }
83507 if let Some(_) = self.to {
83508 return 1;
83509 }
83510 0
83511 }
83512 }
83513
83514 impl fidl::encoding::ResourceTypeMarker for DatagramSocketSendMsgPreflightResponse {
83515 type Borrowed<'a> = &'a mut Self;
83516 fn take_or_borrow<'a>(
83517 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
83518 ) -> Self::Borrowed<'a> {
83519 value
83520 }
83521 }
83522
83523 unsafe impl fidl::encoding::TypeMarker for DatagramSocketSendMsgPreflightResponse {
83524 type Owned = Self;
83525
83526 #[inline(always)]
83527 fn inline_align(_context: fidl::encoding::Context) -> usize {
83528 8
83529 }
83530
83531 #[inline(always)]
83532 fn inline_size(_context: fidl::encoding::Context) -> usize {
83533 16
83534 }
83535 }
83536
83537 unsafe impl
83538 fidl::encoding::Encode<
83539 DatagramSocketSendMsgPreflightResponse,
83540 fidl::encoding::DefaultFuchsiaResourceDialect,
83541 > for &mut DatagramSocketSendMsgPreflightResponse
83542 {
83543 unsafe fn encode(
83544 self,
83545 encoder: &mut fidl::encoding::Encoder<
83546 '_,
83547 fidl::encoding::DefaultFuchsiaResourceDialect,
83548 >,
83549 offset: usize,
83550 mut depth: fidl::encoding::Depth,
83551 ) -> fidl::Result<()> {
83552 encoder.debug_check_bounds::<DatagramSocketSendMsgPreflightResponse>(offset);
83553 let max_ordinal: u64 = self.max_ordinal_present();
83555 encoder.write_num(max_ordinal, offset);
83556 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
83557 if max_ordinal == 0 {
83559 return Ok(());
83560 }
83561 depth.increment()?;
83562 let envelope_size = 8;
83563 let bytes_len = max_ordinal as usize * envelope_size;
83564 #[allow(unused_variables)]
83565 let offset = encoder.out_of_line_offset(bytes_len);
83566 let mut _prev_end_offset: usize = 0;
83567 if 1 > max_ordinal {
83568 return Ok(());
83569 }
83570
83571 let cur_offset: usize = (1 - 1) * envelope_size;
83574
83575 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
83577
83578 fidl::encoding::encode_in_envelope_optional::<
83583 fidl_fuchsia_net::SocketAddress,
83584 fidl::encoding::DefaultFuchsiaResourceDialect,
83585 >(
83586 self.to.as_ref().map(
83587 <fidl_fuchsia_net::SocketAddress as fidl::encoding::ValueTypeMarker>::borrow,
83588 ),
83589 encoder,
83590 offset + cur_offset,
83591 depth,
83592 )?;
83593
83594 _prev_end_offset = cur_offset + envelope_size;
83595 if 2 > max_ordinal {
83596 return Ok(());
83597 }
83598
83599 let cur_offset: usize = (2 - 1) * envelope_size;
83602
83603 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
83605
83606 fidl::encoding::encode_in_envelope_optional::<
83611 fidl::encoding::Vector<
83612 fidl::encoding::HandleType<
83613 fidl::EventPair,
83614 { fidl::ObjectType::EVENTPAIR.into_raw() },
83615 49155,
83616 >,
83617 63,
83618 >,
83619 fidl::encoding::DefaultFuchsiaResourceDialect,
83620 >(
83621 self.validity.as_mut().map(
83622 <fidl::encoding::Vector<
83623 fidl::encoding::HandleType<
83624 fidl::EventPair,
83625 { fidl::ObjectType::EVENTPAIR.into_raw() },
83626 49155,
83627 >,
83628 63,
83629 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
83630 ),
83631 encoder,
83632 offset + cur_offset,
83633 depth,
83634 )?;
83635
83636 _prev_end_offset = cur_offset + envelope_size;
83637 if 3 > max_ordinal {
83638 return Ok(());
83639 }
83640
83641 let cur_offset: usize = (3 - 1) * envelope_size;
83644
83645 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
83647
83648 fidl::encoding::encode_in_envelope_optional::<
83653 u32,
83654 fidl::encoding::DefaultFuchsiaResourceDialect,
83655 >(
83656 self.maximum_size.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
83657 encoder,
83658 offset + cur_offset,
83659 depth,
83660 )?;
83661
83662 _prev_end_offset = cur_offset + envelope_size;
83663
83664 Ok(())
83665 }
83666 }
83667
83668 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
83669 for DatagramSocketSendMsgPreflightResponse
83670 {
83671 #[inline(always)]
83672 fn new_empty() -> Self {
83673 Self::default()
83674 }
83675
83676 unsafe fn decode(
83677 &mut self,
83678 decoder: &mut fidl::encoding::Decoder<
83679 '_,
83680 fidl::encoding::DefaultFuchsiaResourceDialect,
83681 >,
83682 offset: usize,
83683 mut depth: fidl::encoding::Depth,
83684 ) -> fidl::Result<()> {
83685 decoder.debug_check_bounds::<Self>(offset);
83686 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
83687 None => return Err(fidl::Error::NotNullable),
83688 Some(len) => len,
83689 };
83690 if len == 0 {
83692 return Ok(());
83693 };
83694 depth.increment()?;
83695 let envelope_size = 8;
83696 let bytes_len = len * envelope_size;
83697 let offset = decoder.out_of_line_offset(bytes_len)?;
83698 let mut _next_ordinal_to_read = 0;
83700 let mut next_offset = offset;
83701 let end_offset = offset + bytes_len;
83702 _next_ordinal_to_read += 1;
83703 if next_offset >= end_offset {
83704 return Ok(());
83705 }
83706
83707 while _next_ordinal_to_read < 1 {
83709 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83710 _next_ordinal_to_read += 1;
83711 next_offset += envelope_size;
83712 }
83713
83714 let next_out_of_line = decoder.next_out_of_line();
83715 let handles_before = decoder.remaining_handles();
83716 if let Some((inlined, num_bytes, num_handles)) =
83717 fidl::encoding::decode_envelope_header(decoder, next_offset)?
83718 {
83719 let member_inline_size =
83720 <fidl_fuchsia_net::SocketAddress as fidl::encoding::TypeMarker>::inline_size(
83721 decoder.context,
83722 );
83723 if inlined != (member_inline_size <= 4) {
83724 return Err(fidl::Error::InvalidInlineBitInEnvelope);
83725 }
83726 let inner_offset;
83727 let mut inner_depth = depth.clone();
83728 if inlined {
83729 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
83730 inner_offset = next_offset;
83731 } else {
83732 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
83733 inner_depth.increment()?;
83734 }
83735 let val_ref = self.to.get_or_insert_with(|| {
83736 fidl::new_empty!(
83737 fidl_fuchsia_net::SocketAddress,
83738 fidl::encoding::DefaultFuchsiaResourceDialect
83739 )
83740 });
83741 fidl::decode!(
83742 fidl_fuchsia_net::SocketAddress,
83743 fidl::encoding::DefaultFuchsiaResourceDialect,
83744 val_ref,
83745 decoder,
83746 inner_offset,
83747 inner_depth
83748 )?;
83749 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83750 {
83751 return Err(fidl::Error::InvalidNumBytesInEnvelope);
83752 }
83753 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83754 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83755 }
83756 }
83757
83758 next_offset += envelope_size;
83759 _next_ordinal_to_read += 1;
83760 if next_offset >= end_offset {
83761 return Ok(());
83762 }
83763
83764 while _next_ordinal_to_read < 2 {
83766 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83767 _next_ordinal_to_read += 1;
83768 next_offset += envelope_size;
83769 }
83770
83771 let next_out_of_line = decoder.next_out_of_line();
83772 let handles_before = decoder.remaining_handles();
83773 if let Some((inlined, num_bytes, num_handles)) =
83774 fidl::encoding::decode_envelope_header(decoder, next_offset)?
83775 {
83776 let member_inline_size = <fidl::encoding::Vector<
83777 fidl::encoding::HandleType<
83778 fidl::EventPair,
83779 { fidl::ObjectType::EVENTPAIR.into_raw() },
83780 49155,
83781 >,
83782 63,
83783 > as fidl::encoding::TypeMarker>::inline_size(
83784 decoder.context
83785 );
83786 if inlined != (member_inline_size <= 4) {
83787 return Err(fidl::Error::InvalidInlineBitInEnvelope);
83788 }
83789 let inner_offset;
83790 let mut inner_depth = depth.clone();
83791 if inlined {
83792 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
83793 inner_offset = next_offset;
83794 } else {
83795 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
83796 inner_depth.increment()?;
83797 }
83798 let val_ref = self.validity.get_or_insert_with(|| {
83799 fidl::new_empty!(
83800 fidl::encoding::Vector<
83801 fidl::encoding::HandleType<
83802 fidl::EventPair,
83803 { fidl::ObjectType::EVENTPAIR.into_raw() },
83804 49155,
83805 >,
83806 63,
83807 >,
83808 fidl::encoding::DefaultFuchsiaResourceDialect
83809 )
83810 });
83811 fidl::decode!(
83812 fidl::encoding::Vector<
83813 fidl::encoding::HandleType<
83814 fidl::EventPair,
83815 { fidl::ObjectType::EVENTPAIR.into_raw() },
83816 49155,
83817 >,
83818 63,
83819 >,
83820 fidl::encoding::DefaultFuchsiaResourceDialect,
83821 val_ref,
83822 decoder,
83823 inner_offset,
83824 inner_depth
83825 )?;
83826 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83827 {
83828 return Err(fidl::Error::InvalidNumBytesInEnvelope);
83829 }
83830 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83831 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83832 }
83833 }
83834
83835 next_offset += envelope_size;
83836 _next_ordinal_to_read += 1;
83837 if next_offset >= end_offset {
83838 return Ok(());
83839 }
83840
83841 while _next_ordinal_to_read < 3 {
83843 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83844 _next_ordinal_to_read += 1;
83845 next_offset += envelope_size;
83846 }
83847
83848 let next_out_of_line = decoder.next_out_of_line();
83849 let handles_before = decoder.remaining_handles();
83850 if let Some((inlined, num_bytes, num_handles)) =
83851 fidl::encoding::decode_envelope_header(decoder, next_offset)?
83852 {
83853 let member_inline_size =
83854 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
83855 if inlined != (member_inline_size <= 4) {
83856 return Err(fidl::Error::InvalidInlineBitInEnvelope);
83857 }
83858 let inner_offset;
83859 let mut inner_depth = depth.clone();
83860 if inlined {
83861 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
83862 inner_offset = next_offset;
83863 } else {
83864 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
83865 inner_depth.increment()?;
83866 }
83867 let val_ref = self.maximum_size.get_or_insert_with(|| {
83868 fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
83869 });
83870 fidl::decode!(
83871 u32,
83872 fidl::encoding::DefaultFuchsiaResourceDialect,
83873 val_ref,
83874 decoder,
83875 inner_offset,
83876 inner_depth
83877 )?;
83878 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83879 {
83880 return Err(fidl::Error::InvalidNumBytesInEnvelope);
83881 }
83882 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83883 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83884 }
83885 }
83886
83887 next_offset += envelope_size;
83888
83889 while next_offset < end_offset {
83891 _next_ordinal_to_read += 1;
83892 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83893 next_offset += envelope_size;
83894 }
83895
83896 Ok(())
83897 }
83898 }
83899
83900 impl StreamSocketDescribeResponse {
83901 #[inline(always)]
83902 fn max_ordinal_present(&self) -> u64 {
83903 if let Some(_) = self.socket {
83904 return 1;
83905 }
83906 0
83907 }
83908 }
83909
83910 impl fidl::encoding::ResourceTypeMarker for StreamSocketDescribeResponse {
83911 type Borrowed<'a> = &'a mut Self;
83912 fn take_or_borrow<'a>(
83913 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
83914 ) -> Self::Borrowed<'a> {
83915 value
83916 }
83917 }
83918
83919 unsafe impl fidl::encoding::TypeMarker for StreamSocketDescribeResponse {
83920 type Owned = Self;
83921
83922 #[inline(always)]
83923 fn inline_align(_context: fidl::encoding::Context) -> usize {
83924 8
83925 }
83926
83927 #[inline(always)]
83928 fn inline_size(_context: fidl::encoding::Context) -> usize {
83929 16
83930 }
83931 }
83932
83933 unsafe impl
83934 fidl::encoding::Encode<
83935 StreamSocketDescribeResponse,
83936 fidl::encoding::DefaultFuchsiaResourceDialect,
83937 > for &mut StreamSocketDescribeResponse
83938 {
83939 unsafe fn encode(
83940 self,
83941 encoder: &mut fidl::encoding::Encoder<
83942 '_,
83943 fidl::encoding::DefaultFuchsiaResourceDialect,
83944 >,
83945 offset: usize,
83946 mut depth: fidl::encoding::Depth,
83947 ) -> fidl::Result<()> {
83948 encoder.debug_check_bounds::<StreamSocketDescribeResponse>(offset);
83949 let max_ordinal: u64 = self.max_ordinal_present();
83951 encoder.write_num(max_ordinal, offset);
83952 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
83953 if max_ordinal == 0 {
83955 return Ok(());
83956 }
83957 depth.increment()?;
83958 let envelope_size = 8;
83959 let bytes_len = max_ordinal as usize * envelope_size;
83960 #[allow(unused_variables)]
83961 let offset = encoder.out_of_line_offset(bytes_len);
83962 let mut _prev_end_offset: usize = 0;
83963 if 1 > max_ordinal {
83964 return Ok(());
83965 }
83966
83967 let cur_offset: usize = (1 - 1) * envelope_size;
83970
83971 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
83973
83974 fidl::encoding::encode_in_envelope_optional::<
83979 fidl::encoding::HandleType<
83980 fidl::Socket,
83981 { fidl::ObjectType::SOCKET.into_raw() },
83982 2147483648,
83983 >,
83984 fidl::encoding::DefaultFuchsiaResourceDialect,
83985 >(
83986 self.socket.as_mut().map(
83987 <fidl::encoding::HandleType<
83988 fidl::Socket,
83989 { fidl::ObjectType::SOCKET.into_raw() },
83990 2147483648,
83991 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
83992 ),
83993 encoder,
83994 offset + cur_offset,
83995 depth,
83996 )?;
83997
83998 _prev_end_offset = cur_offset + envelope_size;
83999
84000 Ok(())
84001 }
84002 }
84003
84004 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
84005 for StreamSocketDescribeResponse
84006 {
84007 #[inline(always)]
84008 fn new_empty() -> Self {
84009 Self::default()
84010 }
84011
84012 unsafe fn decode(
84013 &mut self,
84014 decoder: &mut fidl::encoding::Decoder<
84015 '_,
84016 fidl::encoding::DefaultFuchsiaResourceDialect,
84017 >,
84018 offset: usize,
84019 mut depth: fidl::encoding::Depth,
84020 ) -> fidl::Result<()> {
84021 decoder.debug_check_bounds::<Self>(offset);
84022 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
84023 None => return Err(fidl::Error::NotNullable),
84024 Some(len) => len,
84025 };
84026 if len == 0 {
84028 return Ok(());
84029 };
84030 depth.increment()?;
84031 let envelope_size = 8;
84032 let bytes_len = len * envelope_size;
84033 let offset = decoder.out_of_line_offset(bytes_len)?;
84034 let mut _next_ordinal_to_read = 0;
84036 let mut next_offset = offset;
84037 let end_offset = offset + bytes_len;
84038 _next_ordinal_to_read += 1;
84039 if next_offset >= end_offset {
84040 return Ok(());
84041 }
84042
84043 while _next_ordinal_to_read < 1 {
84045 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
84046 _next_ordinal_to_read += 1;
84047 next_offset += envelope_size;
84048 }
84049
84050 let next_out_of_line = decoder.next_out_of_line();
84051 let handles_before = decoder.remaining_handles();
84052 if let Some((inlined, num_bytes, num_handles)) =
84053 fidl::encoding::decode_envelope_header(decoder, next_offset)?
84054 {
84055 let member_inline_size = <fidl::encoding::HandleType<
84056 fidl::Socket,
84057 { fidl::ObjectType::SOCKET.into_raw() },
84058 2147483648,
84059 > as fidl::encoding::TypeMarker>::inline_size(
84060 decoder.context
84061 );
84062 if inlined != (member_inline_size <= 4) {
84063 return Err(fidl::Error::InvalidInlineBitInEnvelope);
84064 }
84065 let inner_offset;
84066 let mut inner_depth = depth.clone();
84067 if inlined {
84068 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
84069 inner_offset = next_offset;
84070 } else {
84071 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
84072 inner_depth.increment()?;
84073 }
84074 let val_ref =
84075 self.socket.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
84076 fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
84077 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
84078 {
84079 return Err(fidl::Error::InvalidNumBytesInEnvelope);
84080 }
84081 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
84082 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
84083 }
84084 }
84085
84086 next_offset += envelope_size;
84087
84088 while next_offset < end_offset {
84090 _next_ordinal_to_read += 1;
84091 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
84092 next_offset += envelope_size;
84093 }
84094
84095 Ok(())
84096 }
84097 }
84098
84099 impl SynchronousDatagramSocketDescribeResponse {
84100 #[inline(always)]
84101 fn max_ordinal_present(&self) -> u64 {
84102 if let Some(_) = self.event {
84103 return 1;
84104 }
84105 0
84106 }
84107 }
84108
84109 impl fidl::encoding::ResourceTypeMarker for SynchronousDatagramSocketDescribeResponse {
84110 type Borrowed<'a> = &'a mut Self;
84111 fn take_or_borrow<'a>(
84112 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
84113 ) -> Self::Borrowed<'a> {
84114 value
84115 }
84116 }
84117
84118 unsafe impl fidl::encoding::TypeMarker for SynchronousDatagramSocketDescribeResponse {
84119 type Owned = Self;
84120
84121 #[inline(always)]
84122 fn inline_align(_context: fidl::encoding::Context) -> usize {
84123 8
84124 }
84125
84126 #[inline(always)]
84127 fn inline_size(_context: fidl::encoding::Context) -> usize {
84128 16
84129 }
84130 }
84131
84132 unsafe impl
84133 fidl::encoding::Encode<
84134 SynchronousDatagramSocketDescribeResponse,
84135 fidl::encoding::DefaultFuchsiaResourceDialect,
84136 > for &mut SynchronousDatagramSocketDescribeResponse
84137 {
84138 unsafe fn encode(
84139 self,
84140 encoder: &mut fidl::encoding::Encoder<
84141 '_,
84142 fidl::encoding::DefaultFuchsiaResourceDialect,
84143 >,
84144 offset: usize,
84145 mut depth: fidl::encoding::Depth,
84146 ) -> fidl::Result<()> {
84147 encoder.debug_check_bounds::<SynchronousDatagramSocketDescribeResponse>(offset);
84148 let max_ordinal: u64 = self.max_ordinal_present();
84150 encoder.write_num(max_ordinal, offset);
84151 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
84152 if max_ordinal == 0 {
84154 return Ok(());
84155 }
84156 depth.increment()?;
84157 let envelope_size = 8;
84158 let bytes_len = max_ordinal as usize * envelope_size;
84159 #[allow(unused_variables)]
84160 let offset = encoder.out_of_line_offset(bytes_len);
84161 let mut _prev_end_offset: usize = 0;
84162 if 1 > max_ordinal {
84163 return Ok(());
84164 }
84165
84166 let cur_offset: usize = (1 - 1) * envelope_size;
84169
84170 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
84172
84173 fidl::encoding::encode_in_envelope_optional::<
84178 fidl::encoding::HandleType<
84179 fidl::EventPair,
84180 { fidl::ObjectType::EVENTPAIR.into_raw() },
84181 2147483648,
84182 >,
84183 fidl::encoding::DefaultFuchsiaResourceDialect,
84184 >(
84185 self.event.as_mut().map(
84186 <fidl::encoding::HandleType<
84187 fidl::EventPair,
84188 { fidl::ObjectType::EVENTPAIR.into_raw() },
84189 2147483648,
84190 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
84191 ),
84192 encoder,
84193 offset + cur_offset,
84194 depth,
84195 )?;
84196
84197 _prev_end_offset = cur_offset + envelope_size;
84198
84199 Ok(())
84200 }
84201 }
84202
84203 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
84204 for SynchronousDatagramSocketDescribeResponse
84205 {
84206 #[inline(always)]
84207 fn new_empty() -> Self {
84208 Self::default()
84209 }
84210
84211 unsafe fn decode(
84212 &mut self,
84213 decoder: &mut fidl::encoding::Decoder<
84214 '_,
84215 fidl::encoding::DefaultFuchsiaResourceDialect,
84216 >,
84217 offset: usize,
84218 mut depth: fidl::encoding::Depth,
84219 ) -> fidl::Result<()> {
84220 decoder.debug_check_bounds::<Self>(offset);
84221 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
84222 None => return Err(fidl::Error::NotNullable),
84223 Some(len) => len,
84224 };
84225 if len == 0 {
84227 return Ok(());
84228 };
84229 depth.increment()?;
84230 let envelope_size = 8;
84231 let bytes_len = len * envelope_size;
84232 let offset = decoder.out_of_line_offset(bytes_len)?;
84233 let mut _next_ordinal_to_read = 0;
84235 let mut next_offset = offset;
84236 let end_offset = offset + bytes_len;
84237 _next_ordinal_to_read += 1;
84238 if next_offset >= end_offset {
84239 return Ok(());
84240 }
84241
84242 while _next_ordinal_to_read < 1 {
84244 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
84245 _next_ordinal_to_read += 1;
84246 next_offset += envelope_size;
84247 }
84248
84249 let next_out_of_line = decoder.next_out_of_line();
84250 let handles_before = decoder.remaining_handles();
84251 if let Some((inlined, num_bytes, num_handles)) =
84252 fidl::encoding::decode_envelope_header(decoder, next_offset)?
84253 {
84254 let member_inline_size = <fidl::encoding::HandleType<
84255 fidl::EventPair,
84256 { fidl::ObjectType::EVENTPAIR.into_raw() },
84257 2147483648,
84258 > as fidl::encoding::TypeMarker>::inline_size(
84259 decoder.context
84260 );
84261 if inlined != (member_inline_size <= 4) {
84262 return Err(fidl::Error::InvalidInlineBitInEnvelope);
84263 }
84264 let inner_offset;
84265 let mut inner_depth = depth.clone();
84266 if inlined {
84267 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
84268 inner_offset = next_offset;
84269 } else {
84270 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
84271 inner_depth.increment()?;
84272 }
84273 let val_ref =
84274 self.event.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
84275 fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
84276 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
84277 {
84278 return Err(fidl::Error::InvalidNumBytesInEnvelope);
84279 }
84280 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
84281 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
84282 }
84283 }
84284
84285 next_offset += envelope_size;
84286
84287 while next_offset < end_offset {
84289 _next_ordinal_to_read += 1;
84290 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
84291 next_offset += envelope_size;
84292 }
84293
84294 Ok(())
84295 }
84296 }
84297
84298 impl fidl::encoding::ResourceTypeMarker for ProviderDatagramSocketWithOptionsResponse {
84299 type Borrowed<'a> = &'a mut Self;
84300 fn take_or_borrow<'a>(
84301 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
84302 ) -> Self::Borrowed<'a> {
84303 value
84304 }
84305 }
84306
84307 unsafe impl fidl::encoding::TypeMarker for ProviderDatagramSocketWithOptionsResponse {
84308 type Owned = Self;
84309
84310 #[inline(always)]
84311 fn inline_align(_context: fidl::encoding::Context) -> usize {
84312 8
84313 }
84314
84315 #[inline(always)]
84316 fn inline_size(_context: fidl::encoding::Context) -> usize {
84317 16
84318 }
84319 }
84320
84321 unsafe impl
84322 fidl::encoding::Encode<
84323 ProviderDatagramSocketWithOptionsResponse,
84324 fidl::encoding::DefaultFuchsiaResourceDialect,
84325 > for &mut ProviderDatagramSocketWithOptionsResponse
84326 {
84327 #[inline]
84328 unsafe fn encode(
84329 self,
84330 encoder: &mut fidl::encoding::Encoder<
84331 '_,
84332 fidl::encoding::DefaultFuchsiaResourceDialect,
84333 >,
84334 offset: usize,
84335 _depth: fidl::encoding::Depth,
84336 ) -> fidl::Result<()> {
84337 encoder.debug_check_bounds::<ProviderDatagramSocketWithOptionsResponse>(offset);
84338 encoder.write_num::<u64>(self.ordinal(), offset);
84339 match self {
84340 ProviderDatagramSocketWithOptionsResponse::DatagramSocket(ref mut val) => {
84341 fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
84342 <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
84343 encoder, offset + 8, _depth
84344 )
84345 }
84346 ProviderDatagramSocketWithOptionsResponse::SynchronousDatagramSocket(ref mut val) => {
84347 fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
84348 <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
84349 encoder, offset + 8, _depth
84350 )
84351 }
84352 }
84353 }
84354 }
84355
84356 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
84357 for ProviderDatagramSocketWithOptionsResponse
84358 {
84359 #[inline(always)]
84360 fn new_empty() -> Self {
84361 Self::DatagramSocket(fidl::new_empty!(
84362 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>>,
84363 fidl::encoding::DefaultFuchsiaResourceDialect
84364 ))
84365 }
84366
84367 #[inline]
84368 unsafe fn decode(
84369 &mut self,
84370 decoder: &mut fidl::encoding::Decoder<
84371 '_,
84372 fidl::encoding::DefaultFuchsiaResourceDialect,
84373 >,
84374 offset: usize,
84375 mut depth: fidl::encoding::Depth,
84376 ) -> fidl::Result<()> {
84377 decoder.debug_check_bounds::<Self>(offset);
84378 #[allow(unused_variables)]
84379 let next_out_of_line = decoder.next_out_of_line();
84380 let handles_before = decoder.remaining_handles();
84381 let (ordinal, inlined, num_bytes, num_handles) =
84382 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
84383
84384 let member_inline_size = match ordinal {
84385 1 => <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
84386 2 => <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
84387 _ => return Err(fidl::Error::UnknownUnionTag),
84388 };
84389
84390 if inlined != (member_inline_size <= 4) {
84391 return Err(fidl::Error::InvalidInlineBitInEnvelope);
84392 }
84393 let _inner_offset;
84394 if inlined {
84395 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
84396 _inner_offset = offset + 8;
84397 } else {
84398 depth.increment()?;
84399 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
84400 }
84401 match ordinal {
84402 1 => {
84403 #[allow(irrefutable_let_patterns)]
84404 if let ProviderDatagramSocketWithOptionsResponse::DatagramSocket(_) = self {
84405 } else {
84407 *self = ProviderDatagramSocketWithOptionsResponse::DatagramSocket(
84409 fidl::new_empty!(
84410 fidl::encoding::Endpoint<
84411 fidl::endpoints::ClientEnd<DatagramSocketMarker>,
84412 >,
84413 fidl::encoding::DefaultFuchsiaResourceDialect
84414 ),
84415 );
84416 }
84417 #[allow(irrefutable_let_patterns)]
84418 if let ProviderDatagramSocketWithOptionsResponse::DatagramSocket(ref mut val) =
84419 self
84420 {
84421 fidl::decode!(
84422 fidl::encoding::Endpoint<
84423 fidl::endpoints::ClientEnd<DatagramSocketMarker>,
84424 >,
84425 fidl::encoding::DefaultFuchsiaResourceDialect,
84426 val,
84427 decoder,
84428 _inner_offset,
84429 depth
84430 )?;
84431 } else {
84432 unreachable!()
84433 }
84434 }
84435 2 => {
84436 #[allow(irrefutable_let_patterns)]
84437 if let ProviderDatagramSocketWithOptionsResponse::SynchronousDatagramSocket(_) =
84438 self
84439 {
84440 } else {
84442 *self =
84444 ProviderDatagramSocketWithOptionsResponse::SynchronousDatagramSocket(
84445 fidl::new_empty!(
84446 fidl::encoding::Endpoint<
84447 fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
84448 >,
84449 fidl::encoding::DefaultFuchsiaResourceDialect
84450 ),
84451 );
84452 }
84453 #[allow(irrefutable_let_patterns)]
84454 if let ProviderDatagramSocketWithOptionsResponse::SynchronousDatagramSocket(
84455 ref mut val,
84456 ) = self
84457 {
84458 fidl::decode!(
84459 fidl::encoding::Endpoint<
84460 fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
84461 >,
84462 fidl::encoding::DefaultFuchsiaResourceDialect,
84463 val,
84464 decoder,
84465 _inner_offset,
84466 depth
84467 )?;
84468 } else {
84469 unreachable!()
84470 }
84471 }
84472 ordinal => panic!("unexpected ordinal {:?}", ordinal),
84473 }
84474 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
84475 return Err(fidl::Error::InvalidNumBytesInEnvelope);
84476 }
84477 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
84478 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
84479 }
84480 Ok(())
84481 }
84482 }
84483
84484 impl fidl::encoding::ResourceTypeMarker for ProviderDatagramSocketResponse {
84485 type Borrowed<'a> = &'a mut Self;
84486 fn take_or_borrow<'a>(
84487 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
84488 ) -> Self::Borrowed<'a> {
84489 value
84490 }
84491 }
84492
84493 unsafe impl fidl::encoding::TypeMarker for ProviderDatagramSocketResponse {
84494 type Owned = Self;
84495
84496 #[inline(always)]
84497 fn inline_align(_context: fidl::encoding::Context) -> usize {
84498 8
84499 }
84500
84501 #[inline(always)]
84502 fn inline_size(_context: fidl::encoding::Context) -> usize {
84503 16
84504 }
84505 }
84506
84507 unsafe impl
84508 fidl::encoding::Encode<
84509 ProviderDatagramSocketResponse,
84510 fidl::encoding::DefaultFuchsiaResourceDialect,
84511 > for &mut ProviderDatagramSocketResponse
84512 {
84513 #[inline]
84514 unsafe fn encode(
84515 self,
84516 encoder: &mut fidl::encoding::Encoder<
84517 '_,
84518 fidl::encoding::DefaultFuchsiaResourceDialect,
84519 >,
84520 offset: usize,
84521 _depth: fidl::encoding::Depth,
84522 ) -> fidl::Result<()> {
84523 encoder.debug_check_bounds::<ProviderDatagramSocketResponse>(offset);
84524 encoder.write_num::<u64>(self.ordinal(), offset);
84525 match self {
84526 ProviderDatagramSocketResponse::DatagramSocket(ref mut val) => {
84527 fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
84528 <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
84529 encoder, offset + 8, _depth
84530 )
84531 }
84532 ProviderDatagramSocketResponse::SynchronousDatagramSocket(ref mut val) => {
84533 fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
84534 <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
84535 encoder, offset + 8, _depth
84536 )
84537 }
84538 }
84539 }
84540 }
84541
84542 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
84543 for ProviderDatagramSocketResponse
84544 {
84545 #[inline(always)]
84546 fn new_empty() -> Self {
84547 Self::DatagramSocket(fidl::new_empty!(
84548 fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>>,
84549 fidl::encoding::DefaultFuchsiaResourceDialect
84550 ))
84551 }
84552
84553 #[inline]
84554 unsafe fn decode(
84555 &mut self,
84556 decoder: &mut fidl::encoding::Decoder<
84557 '_,
84558 fidl::encoding::DefaultFuchsiaResourceDialect,
84559 >,
84560 offset: usize,
84561 mut depth: fidl::encoding::Depth,
84562 ) -> fidl::Result<()> {
84563 decoder.debug_check_bounds::<Self>(offset);
84564 #[allow(unused_variables)]
84565 let next_out_of_line = decoder.next_out_of_line();
84566 let handles_before = decoder.remaining_handles();
84567 let (ordinal, inlined, num_bytes, num_handles) =
84568 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
84569
84570 let member_inline_size = match ordinal {
84571 1 => <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
84572 2 => <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
84573 _ => return Err(fidl::Error::UnknownUnionTag),
84574 };
84575
84576 if inlined != (member_inline_size <= 4) {
84577 return Err(fidl::Error::InvalidInlineBitInEnvelope);
84578 }
84579 let _inner_offset;
84580 if inlined {
84581 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
84582 _inner_offset = offset + 8;
84583 } else {
84584 depth.increment()?;
84585 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
84586 }
84587 match ordinal {
84588 1 => {
84589 #[allow(irrefutable_let_patterns)]
84590 if let ProviderDatagramSocketResponse::DatagramSocket(_) = self {
84591 } else {
84593 *self = ProviderDatagramSocketResponse::DatagramSocket(fidl::new_empty!(
84595 fidl::encoding::Endpoint<
84596 fidl::endpoints::ClientEnd<DatagramSocketMarker>,
84597 >,
84598 fidl::encoding::DefaultFuchsiaResourceDialect
84599 ));
84600 }
84601 #[allow(irrefutable_let_patterns)]
84602 if let ProviderDatagramSocketResponse::DatagramSocket(ref mut val) = self {
84603 fidl::decode!(
84604 fidl::encoding::Endpoint<
84605 fidl::endpoints::ClientEnd<DatagramSocketMarker>,
84606 >,
84607 fidl::encoding::DefaultFuchsiaResourceDialect,
84608 val,
84609 decoder,
84610 _inner_offset,
84611 depth
84612 )?;
84613 } else {
84614 unreachable!()
84615 }
84616 }
84617 2 => {
84618 #[allow(irrefutable_let_patterns)]
84619 if let ProviderDatagramSocketResponse::SynchronousDatagramSocket(_) = self {
84620 } else {
84622 *self = ProviderDatagramSocketResponse::SynchronousDatagramSocket(
84624 fidl::new_empty!(
84625 fidl::encoding::Endpoint<
84626 fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
84627 >,
84628 fidl::encoding::DefaultFuchsiaResourceDialect
84629 ),
84630 );
84631 }
84632 #[allow(irrefutable_let_patterns)]
84633 if let ProviderDatagramSocketResponse::SynchronousDatagramSocket(ref mut val) =
84634 self
84635 {
84636 fidl::decode!(
84637 fidl::encoding::Endpoint<
84638 fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
84639 >,
84640 fidl::encoding::DefaultFuchsiaResourceDialect,
84641 val,
84642 decoder,
84643 _inner_offset,
84644 depth
84645 )?;
84646 } else {
84647 unreachable!()
84648 }
84649 }
84650 ordinal => panic!("unexpected ordinal {:?}", ordinal),
84651 }
84652 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
84653 return Err(fidl::Error::InvalidNumBytesInEnvelope);
84654 }
84655 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
84656 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
84657 }
84658 Ok(())
84659 }
84660 }
84661}