fidl_fuchsia_net_masquerade/
fidl_fuchsia_net_masquerade.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_net_masquerade_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, PartialEq)]
15pub struct FactoryCreateRequest {
16    pub config: ControlConfig,
17    pub control: fidl::endpoints::ServerEnd<ControlMarker>,
18}
19
20impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for FactoryCreateRequest {}
21
22#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
23pub struct ControlMarker;
24
25impl fidl::endpoints::ProtocolMarker for ControlMarker {
26    type Proxy = ControlProxy;
27    type RequestStream = ControlRequestStream;
28    #[cfg(target_os = "fuchsia")]
29    type SynchronousProxy = ControlSynchronousProxy;
30
31    const DEBUG_NAME: &'static str = "(anonymous) Control";
32}
33pub type ControlSetEnabledResult = Result<bool, Error>;
34
35pub trait ControlProxyInterface: Send + Sync {
36    type SetEnabledResponseFut: std::future::Future<Output = Result<ControlSetEnabledResult, fidl::Error>>
37        + Send;
38    fn r#set_enabled(&self, enabled: bool) -> Self::SetEnabledResponseFut;
39}
40#[derive(Debug)]
41#[cfg(target_os = "fuchsia")]
42pub struct ControlSynchronousProxy {
43    client: fidl::client::sync::Client,
44}
45
46#[cfg(target_os = "fuchsia")]
47impl fidl::endpoints::SynchronousProxy for ControlSynchronousProxy {
48    type Proxy = ControlProxy;
49    type Protocol = ControlMarker;
50
51    fn from_channel(inner: fidl::Channel) -> Self {
52        Self::new(inner)
53    }
54
55    fn into_channel(self) -> fidl::Channel {
56        self.client.into_channel()
57    }
58
59    fn as_channel(&self) -> &fidl::Channel {
60        self.client.as_channel()
61    }
62}
63
64#[cfg(target_os = "fuchsia")]
65impl ControlSynchronousProxy {
66    pub fn new(channel: fidl::Channel) -> Self {
67        let protocol_name = <ControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
68        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
69    }
70
71    pub fn into_channel(self) -> fidl::Channel {
72        self.client.into_channel()
73    }
74
75    /// Waits until an event arrives and returns it. It is safe for other
76    /// threads to make concurrent requests while waiting for an event.
77    pub fn wait_for_event(
78        &self,
79        deadline: zx::MonotonicInstant,
80    ) -> Result<ControlEvent, fidl::Error> {
81        ControlEvent::decode(self.client.wait_for_event(deadline)?)
82    }
83
84    /// SetEnabled enables or disabled IP masquerading for the configured
85    /// instance. Newly created instances are disabled and must be enabled
86    /// via this API.
87    ///
88    /// + request `enabled` True to enable masquerade; false to disable.
89    /// - response `was_enabled` True if the interface was enabled before this call.
90    pub fn r#set_enabled(
91        &self,
92        mut enabled: bool,
93        ___deadline: zx::MonotonicInstant,
94    ) -> Result<ControlSetEnabledResult, fidl::Error> {
95        let _response = self.client.send_query::<
96            ControlSetEnabledRequest,
97            fidl::encoding::ResultType<ControlSetEnabledResponse, Error>,
98        >(
99            (enabled,),
100            0x13b7914afdb709a6,
101            fidl::encoding::DynamicFlags::empty(),
102            ___deadline,
103        )?;
104        Ok(_response.map(|x| x.was_enabled))
105    }
106}
107
108#[cfg(target_os = "fuchsia")]
109impl From<ControlSynchronousProxy> for zx::Handle {
110    fn from(value: ControlSynchronousProxy) -> Self {
111        value.into_channel().into()
112    }
113}
114
115#[cfg(target_os = "fuchsia")]
116impl From<fidl::Channel> for ControlSynchronousProxy {
117    fn from(value: fidl::Channel) -> Self {
118        Self::new(value)
119    }
120}
121
122#[derive(Debug, Clone)]
123pub struct ControlProxy {
124    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
125}
126
127impl fidl::endpoints::Proxy for ControlProxy {
128    type Protocol = ControlMarker;
129
130    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
131        Self::new(inner)
132    }
133
134    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
135        self.client.into_channel().map_err(|client| Self { client })
136    }
137
138    fn as_channel(&self) -> &::fidl::AsyncChannel {
139        self.client.as_channel()
140    }
141}
142
143impl ControlProxy {
144    /// Create a new Proxy for fuchsia.net.masquerade/Control.
145    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
146        let protocol_name = <ControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
147        Self { client: fidl::client::Client::new(channel, protocol_name) }
148    }
149
150    /// Get a Stream of events from the remote end of the protocol.
151    ///
152    /// # Panics
153    ///
154    /// Panics if the event stream was already taken.
155    pub fn take_event_stream(&self) -> ControlEventStream {
156        ControlEventStream { event_receiver: self.client.take_event_receiver() }
157    }
158
159    /// SetEnabled enables or disabled IP masquerading for the configured
160    /// instance. Newly created instances are disabled and must be enabled
161    /// via this API.
162    ///
163    /// + request `enabled` True to enable masquerade; false to disable.
164    /// - response `was_enabled` True if the interface was enabled before this call.
165    pub fn r#set_enabled(
166        &self,
167        mut enabled: bool,
168    ) -> fidl::client::QueryResponseFut<
169        ControlSetEnabledResult,
170        fidl::encoding::DefaultFuchsiaResourceDialect,
171    > {
172        ControlProxyInterface::r#set_enabled(self, enabled)
173    }
174}
175
176impl ControlProxyInterface for ControlProxy {
177    type SetEnabledResponseFut = fidl::client::QueryResponseFut<
178        ControlSetEnabledResult,
179        fidl::encoding::DefaultFuchsiaResourceDialect,
180    >;
181    fn r#set_enabled(&self, mut enabled: bool) -> Self::SetEnabledResponseFut {
182        fn _decode(
183            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
184        ) -> Result<ControlSetEnabledResult, fidl::Error> {
185            let _response = fidl::client::decode_transaction_body::<
186                fidl::encoding::ResultType<ControlSetEnabledResponse, Error>,
187                fidl::encoding::DefaultFuchsiaResourceDialect,
188                0x13b7914afdb709a6,
189            >(_buf?)?;
190            Ok(_response.map(|x| x.was_enabled))
191        }
192        self.client.send_query_and_decode::<ControlSetEnabledRequest, ControlSetEnabledResult>(
193            (enabled,),
194            0x13b7914afdb709a6,
195            fidl::encoding::DynamicFlags::empty(),
196            _decode,
197        )
198    }
199}
200
201pub struct ControlEventStream {
202    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
203}
204
205impl std::marker::Unpin for ControlEventStream {}
206
207impl futures::stream::FusedStream for ControlEventStream {
208    fn is_terminated(&self) -> bool {
209        self.event_receiver.is_terminated()
210    }
211}
212
213impl futures::Stream for ControlEventStream {
214    type Item = Result<ControlEvent, fidl::Error>;
215
216    fn poll_next(
217        mut self: std::pin::Pin<&mut Self>,
218        cx: &mut std::task::Context<'_>,
219    ) -> std::task::Poll<Option<Self::Item>> {
220        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
221            &mut self.event_receiver,
222            cx
223        )?) {
224            Some(buf) => std::task::Poll::Ready(Some(ControlEvent::decode(buf))),
225            None => std::task::Poll::Ready(None),
226        }
227    }
228}
229
230#[derive(Debug)]
231pub enum ControlEvent {}
232
233impl ControlEvent {
234    /// Decodes a message buffer as a [`ControlEvent`].
235    fn decode(
236        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
237    ) -> Result<ControlEvent, fidl::Error> {
238        let (bytes, _handles) = buf.split_mut();
239        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
240        debug_assert_eq!(tx_header.tx_id, 0);
241        match tx_header.ordinal {
242            _ => Err(fidl::Error::UnknownOrdinal {
243                ordinal: tx_header.ordinal,
244                protocol_name: <ControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
245            }),
246        }
247    }
248}
249
250/// A Stream of incoming requests for fuchsia.net.masquerade/Control.
251pub struct ControlRequestStream {
252    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
253    is_terminated: bool,
254}
255
256impl std::marker::Unpin for ControlRequestStream {}
257
258impl futures::stream::FusedStream for ControlRequestStream {
259    fn is_terminated(&self) -> bool {
260        self.is_terminated
261    }
262}
263
264impl fidl::endpoints::RequestStream for ControlRequestStream {
265    type Protocol = ControlMarker;
266    type ControlHandle = ControlControlHandle;
267
268    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
269        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
270    }
271
272    fn control_handle(&self) -> Self::ControlHandle {
273        ControlControlHandle { inner: self.inner.clone() }
274    }
275
276    fn into_inner(
277        self,
278    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
279    {
280        (self.inner, self.is_terminated)
281    }
282
283    fn from_inner(
284        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
285        is_terminated: bool,
286    ) -> Self {
287        Self { inner, is_terminated }
288    }
289}
290
291impl futures::Stream for ControlRequestStream {
292    type Item = Result<ControlRequest, fidl::Error>;
293
294    fn poll_next(
295        mut self: std::pin::Pin<&mut Self>,
296        cx: &mut std::task::Context<'_>,
297    ) -> std::task::Poll<Option<Self::Item>> {
298        let this = &mut *self;
299        if this.inner.check_shutdown(cx) {
300            this.is_terminated = true;
301            return std::task::Poll::Ready(None);
302        }
303        if this.is_terminated {
304            panic!("polled ControlRequestStream after completion");
305        }
306        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
307            |bytes, handles| {
308                match this.inner.channel().read_etc(cx, bytes, handles) {
309                    std::task::Poll::Ready(Ok(())) => {}
310                    std::task::Poll::Pending => return std::task::Poll::Pending,
311                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
312                        this.is_terminated = true;
313                        return std::task::Poll::Ready(None);
314                    }
315                    std::task::Poll::Ready(Err(e)) => {
316                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
317                            e.into(),
318                        ))))
319                    }
320                }
321
322                // A message has been received from the channel
323                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
324
325                std::task::Poll::Ready(Some(match header.ordinal {
326                    0x13b7914afdb709a6 => {
327                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
328                        let mut req = fidl::new_empty!(
329                            ControlSetEnabledRequest,
330                            fidl::encoding::DefaultFuchsiaResourceDialect
331                        );
332                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ControlSetEnabledRequest>(&header, _body_bytes, handles, &mut req)?;
333                        let control_handle = ControlControlHandle { inner: this.inner.clone() };
334                        Ok(ControlRequest::SetEnabled {
335                            enabled: req.enabled,
336
337                            responder: ControlSetEnabledResponder {
338                                control_handle: std::mem::ManuallyDrop::new(control_handle),
339                                tx_id: header.tx_id,
340                            },
341                        })
342                    }
343                    _ => Err(fidl::Error::UnknownOrdinal {
344                        ordinal: header.ordinal,
345                        protocol_name:
346                            <ControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
347                    }),
348                }))
349            },
350        )
351    }
352}
353
354/// Control provides a IP masquerade instance.
355///
356/// This protocol is associated with the lifetime of the IP masquerade. This
357/// configuration will be torn down whenever either end of the protocol is
358/// closed.
359#[derive(Debug)]
360pub enum ControlRequest {
361    /// SetEnabled enables or disabled IP masquerading for the configured
362    /// instance. Newly created instances are disabled and must be enabled
363    /// via this API.
364    ///
365    /// + request `enabled` True to enable masquerade; false to disable.
366    /// - response `was_enabled` True if the interface was enabled before this call.
367    SetEnabled { enabled: bool, responder: ControlSetEnabledResponder },
368}
369
370impl ControlRequest {
371    #[allow(irrefutable_let_patterns)]
372    pub fn into_set_enabled(self) -> Option<(bool, ControlSetEnabledResponder)> {
373        if let ControlRequest::SetEnabled { enabled, responder } = self {
374            Some((enabled, responder))
375        } else {
376            None
377        }
378    }
379
380    /// Name of the method defined in FIDL
381    pub fn method_name(&self) -> &'static str {
382        match *self {
383            ControlRequest::SetEnabled { .. } => "set_enabled",
384        }
385    }
386}
387
388#[derive(Debug, Clone)]
389pub struct ControlControlHandle {
390    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
391}
392
393impl fidl::endpoints::ControlHandle for ControlControlHandle {
394    fn shutdown(&self) {
395        self.inner.shutdown()
396    }
397    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
398        self.inner.shutdown_with_epitaph(status)
399    }
400
401    fn is_closed(&self) -> bool {
402        self.inner.channel().is_closed()
403    }
404    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
405        self.inner.channel().on_closed()
406    }
407
408    #[cfg(target_os = "fuchsia")]
409    fn signal_peer(
410        &self,
411        clear_mask: zx::Signals,
412        set_mask: zx::Signals,
413    ) -> Result<(), zx_status::Status> {
414        use fidl::Peered;
415        self.inner.channel().signal_peer(clear_mask, set_mask)
416    }
417}
418
419impl ControlControlHandle {}
420
421#[must_use = "FIDL methods require a response to be sent"]
422#[derive(Debug)]
423pub struct ControlSetEnabledResponder {
424    control_handle: std::mem::ManuallyDrop<ControlControlHandle>,
425    tx_id: u32,
426}
427
428/// Set the the channel to be shutdown (see [`ControlControlHandle::shutdown`])
429/// if the responder is dropped without sending a response, so that the client
430/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
431impl std::ops::Drop for ControlSetEnabledResponder {
432    fn drop(&mut self) {
433        self.control_handle.shutdown();
434        // Safety: drops once, never accessed again
435        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
436    }
437}
438
439impl fidl::endpoints::Responder for ControlSetEnabledResponder {
440    type ControlHandle = ControlControlHandle;
441
442    fn control_handle(&self) -> &ControlControlHandle {
443        &self.control_handle
444    }
445
446    fn drop_without_shutdown(mut self) {
447        // Safety: drops once, never accessed again due to mem::forget
448        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
449        // Prevent Drop from running (which would shut down the channel)
450        std::mem::forget(self);
451    }
452}
453
454impl ControlSetEnabledResponder {
455    /// Sends a response to the FIDL transaction.
456    ///
457    /// Sets the channel to shutdown if an error occurs.
458    pub fn send(self, mut result: Result<bool, Error>) -> Result<(), fidl::Error> {
459        let _result = self.send_raw(result);
460        if _result.is_err() {
461            self.control_handle.shutdown();
462        }
463        self.drop_without_shutdown();
464        _result
465    }
466
467    /// Similar to "send" but does not shutdown the channel if an error occurs.
468    pub fn send_no_shutdown_on_err(
469        self,
470        mut result: Result<bool, Error>,
471    ) -> Result<(), fidl::Error> {
472        let _result = self.send_raw(result);
473        self.drop_without_shutdown();
474        _result
475    }
476
477    fn send_raw(&self, mut result: Result<bool, Error>) -> Result<(), fidl::Error> {
478        self.control_handle
479            .inner
480            .send::<fidl::encoding::ResultType<ControlSetEnabledResponse, Error>>(
481                result.map(|was_enabled| (was_enabled,)),
482                self.tx_id,
483                0x13b7914afdb709a6,
484                fidl::encoding::DynamicFlags::empty(),
485            )
486    }
487}
488
489#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
490pub struct FactoryMarker;
491
492impl fidl::endpoints::ProtocolMarker for FactoryMarker {
493    type Proxy = FactoryProxy;
494    type RequestStream = FactoryRequestStream;
495    #[cfg(target_os = "fuchsia")]
496    type SynchronousProxy = FactorySynchronousProxy;
497
498    const DEBUG_NAME: &'static str = "fuchsia.net.masquerade.Factory";
499}
500impl fidl::endpoints::DiscoverableProtocolMarker for FactoryMarker {}
501pub type FactoryCreateResult = Result<(), Error>;
502
503pub trait FactoryProxyInterface: Send + Sync {
504    type CreateResponseFut: std::future::Future<Output = Result<FactoryCreateResult, fidl::Error>>
505        + Send;
506    fn r#create(
507        &self,
508        config: &ControlConfig,
509        control: fidl::endpoints::ServerEnd<ControlMarker>,
510    ) -> Self::CreateResponseFut;
511}
512#[derive(Debug)]
513#[cfg(target_os = "fuchsia")]
514pub struct FactorySynchronousProxy {
515    client: fidl::client::sync::Client,
516}
517
518#[cfg(target_os = "fuchsia")]
519impl fidl::endpoints::SynchronousProxy for FactorySynchronousProxy {
520    type Proxy = FactoryProxy;
521    type Protocol = FactoryMarker;
522
523    fn from_channel(inner: fidl::Channel) -> Self {
524        Self::new(inner)
525    }
526
527    fn into_channel(self) -> fidl::Channel {
528        self.client.into_channel()
529    }
530
531    fn as_channel(&self) -> &fidl::Channel {
532        self.client.as_channel()
533    }
534}
535
536#[cfg(target_os = "fuchsia")]
537impl FactorySynchronousProxy {
538    pub fn new(channel: fidl::Channel) -> Self {
539        let protocol_name = <FactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
540        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
541    }
542
543    pub fn into_channel(self) -> fidl::Channel {
544        self.client.into_channel()
545    }
546
547    /// Waits until an event arrives and returns it. It is safe for other
548    /// threads to make concurrent requests while waiting for an event.
549    pub fn wait_for_event(
550        &self,
551        deadline: zx::MonotonicInstant,
552    ) -> Result<FactoryEvent, fidl::Error> {
553        FactoryEvent::decode(self.client.wait_for_event(deadline)?)
554    }
555
556    /// Create a new IP masquerade instance using the supplied
557    /// configuration.
558    ///
559    /// Configurations cannot be changed once instantiated. If a different
560    /// configuration is to be applied, the prior instance should first be
561    /// disabled and the channel torn down.
562    ///
563    /// The instance that is returned is initially in a disabled state and
564    /// must be explicitly enabled prior to use.
565    ///
566    /// + request `config` Configuration to use for the IP masquerade
567    ///   instance.
568    /// + request `control` Control handle to use for configuring the
569    ///   instance.
570    pub fn r#create(
571        &self,
572        mut config: &ControlConfig,
573        mut control: fidl::endpoints::ServerEnd<ControlMarker>,
574        ___deadline: zx::MonotonicInstant,
575    ) -> Result<FactoryCreateResult, fidl::Error> {
576        let _response = self.client.send_query::<FactoryCreateRequest, fidl::encoding::ResultType<
577            fidl::encoding::EmptyStruct,
578            Error,
579        >>(
580            (config, control),
581            0x65f64a124fd0170e,
582            fidl::encoding::DynamicFlags::empty(),
583            ___deadline,
584        )?;
585        Ok(_response.map(|x| x))
586    }
587}
588
589#[cfg(target_os = "fuchsia")]
590impl From<FactorySynchronousProxy> for zx::Handle {
591    fn from(value: FactorySynchronousProxy) -> Self {
592        value.into_channel().into()
593    }
594}
595
596#[cfg(target_os = "fuchsia")]
597impl From<fidl::Channel> for FactorySynchronousProxy {
598    fn from(value: fidl::Channel) -> Self {
599        Self::new(value)
600    }
601}
602
603#[derive(Debug, Clone)]
604pub struct FactoryProxy {
605    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
606}
607
608impl fidl::endpoints::Proxy for FactoryProxy {
609    type Protocol = FactoryMarker;
610
611    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
612        Self::new(inner)
613    }
614
615    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
616        self.client.into_channel().map_err(|client| Self { client })
617    }
618
619    fn as_channel(&self) -> &::fidl::AsyncChannel {
620        self.client.as_channel()
621    }
622}
623
624impl FactoryProxy {
625    /// Create a new Proxy for fuchsia.net.masquerade/Factory.
626    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
627        let protocol_name = <FactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
628        Self { client: fidl::client::Client::new(channel, protocol_name) }
629    }
630
631    /// Get a Stream of events from the remote end of the protocol.
632    ///
633    /// # Panics
634    ///
635    /// Panics if the event stream was already taken.
636    pub fn take_event_stream(&self) -> FactoryEventStream {
637        FactoryEventStream { event_receiver: self.client.take_event_receiver() }
638    }
639
640    /// Create a new IP masquerade instance using the supplied
641    /// configuration.
642    ///
643    /// Configurations cannot be changed once instantiated. If a different
644    /// configuration is to be applied, the prior instance should first be
645    /// disabled and the channel torn down.
646    ///
647    /// The instance that is returned is initially in a disabled state and
648    /// must be explicitly enabled prior to use.
649    ///
650    /// + request `config` Configuration to use for the IP masquerade
651    ///   instance.
652    /// + request `control` Control handle to use for configuring the
653    ///   instance.
654    pub fn r#create(
655        &self,
656        mut config: &ControlConfig,
657        mut control: fidl::endpoints::ServerEnd<ControlMarker>,
658    ) -> fidl::client::QueryResponseFut<
659        FactoryCreateResult,
660        fidl::encoding::DefaultFuchsiaResourceDialect,
661    > {
662        FactoryProxyInterface::r#create(self, config, control)
663    }
664}
665
666impl FactoryProxyInterface for FactoryProxy {
667    type CreateResponseFut = fidl::client::QueryResponseFut<
668        FactoryCreateResult,
669        fidl::encoding::DefaultFuchsiaResourceDialect,
670    >;
671    fn r#create(
672        &self,
673        mut config: &ControlConfig,
674        mut control: fidl::endpoints::ServerEnd<ControlMarker>,
675    ) -> Self::CreateResponseFut {
676        fn _decode(
677            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
678        ) -> Result<FactoryCreateResult, fidl::Error> {
679            let _response = fidl::client::decode_transaction_body::<
680                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
681                fidl::encoding::DefaultFuchsiaResourceDialect,
682                0x65f64a124fd0170e,
683            >(_buf?)?;
684            Ok(_response.map(|x| x))
685        }
686        self.client.send_query_and_decode::<FactoryCreateRequest, FactoryCreateResult>(
687            (config, control),
688            0x65f64a124fd0170e,
689            fidl::encoding::DynamicFlags::empty(),
690            _decode,
691        )
692    }
693}
694
695pub struct FactoryEventStream {
696    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
697}
698
699impl std::marker::Unpin for FactoryEventStream {}
700
701impl futures::stream::FusedStream for FactoryEventStream {
702    fn is_terminated(&self) -> bool {
703        self.event_receiver.is_terminated()
704    }
705}
706
707impl futures::Stream for FactoryEventStream {
708    type Item = Result<FactoryEvent, fidl::Error>;
709
710    fn poll_next(
711        mut self: std::pin::Pin<&mut Self>,
712        cx: &mut std::task::Context<'_>,
713    ) -> std::task::Poll<Option<Self::Item>> {
714        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
715            &mut self.event_receiver,
716            cx
717        )?) {
718            Some(buf) => std::task::Poll::Ready(Some(FactoryEvent::decode(buf))),
719            None => std::task::Poll::Ready(None),
720        }
721    }
722}
723
724#[derive(Debug)]
725pub enum FactoryEvent {}
726
727impl FactoryEvent {
728    /// Decodes a message buffer as a [`FactoryEvent`].
729    fn decode(
730        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
731    ) -> Result<FactoryEvent, fidl::Error> {
732        let (bytes, _handles) = buf.split_mut();
733        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
734        debug_assert_eq!(tx_header.tx_id, 0);
735        match tx_header.ordinal {
736            _ => Err(fidl::Error::UnknownOrdinal {
737                ordinal: tx_header.ordinal,
738                protocol_name: <FactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
739            }),
740        }
741    }
742}
743
744/// A Stream of incoming requests for fuchsia.net.masquerade/Factory.
745pub struct FactoryRequestStream {
746    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
747    is_terminated: bool,
748}
749
750impl std::marker::Unpin for FactoryRequestStream {}
751
752impl futures::stream::FusedStream for FactoryRequestStream {
753    fn is_terminated(&self) -> bool {
754        self.is_terminated
755    }
756}
757
758impl fidl::endpoints::RequestStream for FactoryRequestStream {
759    type Protocol = FactoryMarker;
760    type ControlHandle = FactoryControlHandle;
761
762    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
763        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
764    }
765
766    fn control_handle(&self) -> Self::ControlHandle {
767        FactoryControlHandle { inner: self.inner.clone() }
768    }
769
770    fn into_inner(
771        self,
772    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
773    {
774        (self.inner, self.is_terminated)
775    }
776
777    fn from_inner(
778        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
779        is_terminated: bool,
780    ) -> Self {
781        Self { inner, is_terminated }
782    }
783}
784
785impl futures::Stream for FactoryRequestStream {
786    type Item = Result<FactoryRequest, fidl::Error>;
787
788    fn poll_next(
789        mut self: std::pin::Pin<&mut Self>,
790        cx: &mut std::task::Context<'_>,
791    ) -> std::task::Poll<Option<Self::Item>> {
792        let this = &mut *self;
793        if this.inner.check_shutdown(cx) {
794            this.is_terminated = true;
795            return std::task::Poll::Ready(None);
796        }
797        if this.is_terminated {
798            panic!("polled FactoryRequestStream after completion");
799        }
800        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
801            |bytes, handles| {
802                match this.inner.channel().read_etc(cx, bytes, handles) {
803                    std::task::Poll::Ready(Ok(())) => {}
804                    std::task::Poll::Pending => return std::task::Poll::Pending,
805                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
806                        this.is_terminated = true;
807                        return std::task::Poll::Ready(None);
808                    }
809                    std::task::Poll::Ready(Err(e)) => {
810                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
811                            e.into(),
812                        ))))
813                    }
814                }
815
816                // A message has been received from the channel
817                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
818
819                std::task::Poll::Ready(Some(match header.ordinal {
820                    0x65f64a124fd0170e => {
821                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
822                        let mut req = fidl::new_empty!(
823                            FactoryCreateRequest,
824                            fidl::encoding::DefaultFuchsiaResourceDialect
825                        );
826                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FactoryCreateRequest>(&header, _body_bytes, handles, &mut req)?;
827                        let control_handle = FactoryControlHandle { inner: this.inner.clone() };
828                        Ok(FactoryRequest::Create {
829                            config: req.config,
830                            control: req.control,
831
832                            responder: FactoryCreateResponder {
833                                control_handle: std::mem::ManuallyDrop::new(control_handle),
834                                tx_id: header.tx_id,
835                            },
836                        })
837                    }
838                    _ => Err(fidl::Error::UnknownOrdinal {
839                        ordinal: header.ordinal,
840                        protocol_name:
841                            <FactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
842                    }),
843                }))
844            },
845        )
846    }
847}
848
849/// Factory instantiates Control protocol instances for IP masquerading.
850///
851/// This protocol is used to create instances allowing for the control of
852/// IP masquerade of a particular network.
853#[derive(Debug)]
854pub enum FactoryRequest {
855    /// Create a new IP masquerade instance using the supplied
856    /// configuration.
857    ///
858    /// Configurations cannot be changed once instantiated. If a different
859    /// configuration is to be applied, the prior instance should first be
860    /// disabled and the channel torn down.
861    ///
862    /// The instance that is returned is initially in a disabled state and
863    /// must be explicitly enabled prior to use.
864    ///
865    /// + request `config` Configuration to use for the IP masquerade
866    ///   instance.
867    /// + request `control` Control handle to use for configuring the
868    ///   instance.
869    Create {
870        config: ControlConfig,
871        control: fidl::endpoints::ServerEnd<ControlMarker>,
872        responder: FactoryCreateResponder,
873    },
874}
875
876impl FactoryRequest {
877    #[allow(irrefutable_let_patterns)]
878    pub fn into_create(
879        self,
880    ) -> Option<(ControlConfig, fidl::endpoints::ServerEnd<ControlMarker>, FactoryCreateResponder)>
881    {
882        if let FactoryRequest::Create { config, control, responder } = self {
883            Some((config, control, responder))
884        } else {
885            None
886        }
887    }
888
889    /// Name of the method defined in FIDL
890    pub fn method_name(&self) -> &'static str {
891        match *self {
892            FactoryRequest::Create { .. } => "create",
893        }
894    }
895}
896
897#[derive(Debug, Clone)]
898pub struct FactoryControlHandle {
899    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
900}
901
902impl fidl::endpoints::ControlHandle for FactoryControlHandle {
903    fn shutdown(&self) {
904        self.inner.shutdown()
905    }
906    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
907        self.inner.shutdown_with_epitaph(status)
908    }
909
910    fn is_closed(&self) -> bool {
911        self.inner.channel().is_closed()
912    }
913    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
914        self.inner.channel().on_closed()
915    }
916
917    #[cfg(target_os = "fuchsia")]
918    fn signal_peer(
919        &self,
920        clear_mask: zx::Signals,
921        set_mask: zx::Signals,
922    ) -> Result<(), zx_status::Status> {
923        use fidl::Peered;
924        self.inner.channel().signal_peer(clear_mask, set_mask)
925    }
926}
927
928impl FactoryControlHandle {}
929
930#[must_use = "FIDL methods require a response to be sent"]
931#[derive(Debug)]
932pub struct FactoryCreateResponder {
933    control_handle: std::mem::ManuallyDrop<FactoryControlHandle>,
934    tx_id: u32,
935}
936
937/// Set the the channel to be shutdown (see [`FactoryControlHandle::shutdown`])
938/// if the responder is dropped without sending a response, so that the client
939/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
940impl std::ops::Drop for FactoryCreateResponder {
941    fn drop(&mut self) {
942        self.control_handle.shutdown();
943        // Safety: drops once, never accessed again
944        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
945    }
946}
947
948impl fidl::endpoints::Responder for FactoryCreateResponder {
949    type ControlHandle = FactoryControlHandle;
950
951    fn control_handle(&self) -> &FactoryControlHandle {
952        &self.control_handle
953    }
954
955    fn drop_without_shutdown(mut self) {
956        // Safety: drops once, never accessed again due to mem::forget
957        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
958        // Prevent Drop from running (which would shut down the channel)
959        std::mem::forget(self);
960    }
961}
962
963impl FactoryCreateResponder {
964    /// Sends a response to the FIDL transaction.
965    ///
966    /// Sets the channel to shutdown if an error occurs.
967    pub fn send(self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
968        let _result = self.send_raw(result);
969        if _result.is_err() {
970            self.control_handle.shutdown();
971        }
972        self.drop_without_shutdown();
973        _result
974    }
975
976    /// Similar to "send" but does not shutdown the channel if an error occurs.
977    pub fn send_no_shutdown_on_err(self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
978        let _result = self.send_raw(result);
979        self.drop_without_shutdown();
980        _result
981    }
982
983    fn send_raw(&self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
984        self.control_handle
985            .inner
986            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>>(
987                result,
988                self.tx_id,
989                0x65f64a124fd0170e,
990                fidl::encoding::DynamicFlags::empty(),
991            )
992    }
993}
994
995mod internal {
996    use super::*;
997
998    impl fidl::encoding::ResourceTypeMarker for FactoryCreateRequest {
999        type Borrowed<'a> = &'a mut Self;
1000        fn take_or_borrow<'a>(
1001            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1002        ) -> Self::Borrowed<'a> {
1003            value
1004        }
1005    }
1006
1007    unsafe impl fidl::encoding::TypeMarker for FactoryCreateRequest {
1008        type Owned = Self;
1009
1010        #[inline(always)]
1011        fn inline_align(_context: fidl::encoding::Context) -> usize {
1012            8
1013        }
1014
1015        #[inline(always)]
1016        fn inline_size(_context: fidl::encoding::Context) -> usize {
1017            40
1018        }
1019    }
1020
1021    unsafe impl
1022        fidl::encoding::Encode<FactoryCreateRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
1023        for &mut FactoryCreateRequest
1024    {
1025        #[inline]
1026        unsafe fn encode(
1027            self,
1028            encoder: &mut fidl::encoding::Encoder<
1029                '_,
1030                fidl::encoding::DefaultFuchsiaResourceDialect,
1031            >,
1032            offset: usize,
1033            _depth: fidl::encoding::Depth,
1034        ) -> fidl::Result<()> {
1035            encoder.debug_check_bounds::<FactoryCreateRequest>(offset);
1036            // Delegate to tuple encoding.
1037            fidl::encoding::Encode::<FactoryCreateRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
1038                (
1039                    <ControlConfig as fidl::encoding::ValueTypeMarker>::borrow(&self.config),
1040                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControlMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.control),
1041                ),
1042                encoder, offset, _depth
1043            )
1044        }
1045    }
1046    unsafe impl<
1047            T0: fidl::encoding::Encode<ControlConfig, fidl::encoding::DefaultFuchsiaResourceDialect>,
1048            T1: fidl::encoding::Encode<
1049                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControlMarker>>,
1050                fidl::encoding::DefaultFuchsiaResourceDialect,
1051            >,
1052        >
1053        fidl::encoding::Encode<FactoryCreateRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
1054        for (T0, T1)
1055    {
1056        #[inline]
1057        unsafe fn encode(
1058            self,
1059            encoder: &mut fidl::encoding::Encoder<
1060                '_,
1061                fidl::encoding::DefaultFuchsiaResourceDialect,
1062            >,
1063            offset: usize,
1064            depth: fidl::encoding::Depth,
1065        ) -> fidl::Result<()> {
1066            encoder.debug_check_bounds::<FactoryCreateRequest>(offset);
1067            // Zero out padding regions. There's no need to apply masks
1068            // because the unmasked parts will be overwritten by fields.
1069            unsafe {
1070                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
1071                (ptr as *mut u64).write_unaligned(0);
1072            }
1073            // Write the fields.
1074            self.0.encode(encoder, offset + 0, depth)?;
1075            self.1.encode(encoder, offset + 32, depth)?;
1076            Ok(())
1077        }
1078    }
1079
1080    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1081        for FactoryCreateRequest
1082    {
1083        #[inline(always)]
1084        fn new_empty() -> Self {
1085            Self {
1086                config: fidl::new_empty!(
1087                    ControlConfig,
1088                    fidl::encoding::DefaultFuchsiaResourceDialect
1089                ),
1090                control: fidl::new_empty!(
1091                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControlMarker>>,
1092                    fidl::encoding::DefaultFuchsiaResourceDialect
1093                ),
1094            }
1095        }
1096
1097        #[inline]
1098        unsafe fn decode(
1099            &mut self,
1100            decoder: &mut fidl::encoding::Decoder<
1101                '_,
1102                fidl::encoding::DefaultFuchsiaResourceDialect,
1103            >,
1104            offset: usize,
1105            _depth: fidl::encoding::Depth,
1106        ) -> fidl::Result<()> {
1107            decoder.debug_check_bounds::<Self>(offset);
1108            // Verify that padding bytes are zero.
1109            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
1110            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1111            let mask = 0xffffffff00000000u64;
1112            let maskedval = padval & mask;
1113            if maskedval != 0 {
1114                return Err(fidl::Error::NonZeroPadding {
1115                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
1116                });
1117            }
1118            fidl::decode!(
1119                ControlConfig,
1120                fidl::encoding::DefaultFuchsiaResourceDialect,
1121                &mut self.config,
1122                decoder,
1123                offset + 0,
1124                _depth
1125            )?;
1126            fidl::decode!(
1127                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControlMarker>>,
1128                fidl::encoding::DefaultFuchsiaResourceDialect,
1129                &mut self.control,
1130                decoder,
1131                offset + 32,
1132                _depth
1133            )?;
1134            Ok(())
1135        }
1136    }
1137}
fidl_fuchsia_net_masquerade/fidl_fuchsia_net_masquerade.rs

fidl_fuchsia_net_masquerade/
fidl_fuchsia_net_masquerade.rs
