fidl_fuchsia_netemul_guest/
fidl_fuchsia_netemul_guest.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_netemul_guest_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, PartialEq)]
15pub struct ControllerCreateGuestRequest {
16    pub name: String,
17    pub network: fidl::endpoints::ClientEnd<fidl_fuchsia_netemul_network::NetworkMarker>,
18    pub mac: Option<Box<fidl_fuchsia_net::MacAddress>>,
19}
20
21impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
22    for ControllerCreateGuestRequest
23{
24}
25
26#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
27pub struct ControllerCreateGuestResponse {
28    pub s: fidl::endpoints::ClientEnd<GuestMarker>,
29}
30
31impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
32    for ControllerCreateGuestResponse
33{
34}
35
36#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
37pub struct ControllerMarker;
38
39impl fidl::endpoints::ProtocolMarker for ControllerMarker {
40    type Proxy = ControllerProxy;
41    type RequestStream = ControllerRequestStream;
42    #[cfg(target_os = "fuchsia")]
43    type SynchronousProxy = ControllerSynchronousProxy;
44
45    const DEBUG_NAME: &'static str = "fuchsia.netemul.guest.Controller";
46}
47impl fidl::endpoints::DiscoverableProtocolMarker for ControllerMarker {}
48pub type ControllerCreateGuestResult =
49    Result<fidl::endpoints::ClientEnd<GuestMarker>, ControllerCreateGuestError>;
50
51pub trait ControllerProxyInterface: Send + Sync {
52    type CreateGuestResponseFut: std::future::Future<Output = Result<ControllerCreateGuestResult, fidl::Error>>
53        + Send;
54    fn r#create_guest(
55        &self,
56        name: &str,
57        network: fidl::endpoints::ClientEnd<fidl_fuchsia_netemul_network::NetworkMarker>,
58        mac: Option<&fidl_fuchsia_net::MacAddress>,
59    ) -> Self::CreateGuestResponseFut;
60}
61#[derive(Debug)]
62#[cfg(target_os = "fuchsia")]
63pub struct ControllerSynchronousProxy {
64    client: fidl::client::sync::Client,
65}
66
67#[cfg(target_os = "fuchsia")]
68impl fidl::endpoints::SynchronousProxy for ControllerSynchronousProxy {
69    type Proxy = ControllerProxy;
70    type Protocol = ControllerMarker;
71
72    fn from_channel(inner: fidl::Channel) -> Self {
73        Self::new(inner)
74    }
75
76    fn into_channel(self) -> fidl::Channel {
77        self.client.into_channel()
78    }
79
80    fn as_channel(&self) -> &fidl::Channel {
81        self.client.as_channel()
82    }
83}
84
85#[cfg(target_os = "fuchsia")]
86impl ControllerSynchronousProxy {
87    pub fn new(channel: fidl::Channel) -> Self {
88        let protocol_name = <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
89        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
90    }
91
92    pub fn into_channel(self) -> fidl::Channel {
93        self.client.into_channel()
94    }
95
96    /// Waits until an event arrives and returns it. It is safe for other
97    /// threads to make concurrent requests while waiting for an event.
98    pub fn wait_for_event(
99        &self,
100        deadline: zx::MonotonicInstant,
101    ) -> Result<ControllerEvent, fidl::Error> {
102        ControllerEvent::decode(self.client.wait_for_event(deadline)?)
103    }
104
105    /// Creates a new guest instance, attaches it to the provided `network`, optionally
106    /// with `mac` as its mac address, and starts serving the `Guest` protocol over
107    /// the returned client end.
108    ///
109    /// + request `name` a name to be associated with the guest, to be used in logs
110    ///   and assertions.
111    /// + request `network` the client end of a netemul network, to which the guest
112    ///   should be attached.
113    /// + request `mac` an optional mac address which is provided to the guest on
114    ///   on creation. If `mac` is not provided, the guest's mac address is picked
115    ///   by guest-manager.
116    /// + response `guest` the client end of a `Guest` protocol which can be used to
117    ///   interact with the guest.
118    pub fn r#create_guest(
119        &self,
120        mut name: &str,
121        mut network: fidl::endpoints::ClientEnd<fidl_fuchsia_netemul_network::NetworkMarker>,
122        mut mac: Option<&fidl_fuchsia_net::MacAddress>,
123        ___deadline: zx::MonotonicInstant,
124    ) -> Result<ControllerCreateGuestResult, fidl::Error> {
125        let _response =
126            self.client.send_query::<ControllerCreateGuestRequest, fidl::encoding::ResultType<
127                ControllerCreateGuestResponse,
128                ControllerCreateGuestError,
129            >>(
130                (name, network, mac),
131                0x5c49cf5272f818c0,
132                fidl::encoding::DynamicFlags::empty(),
133                ___deadline,
134            )?;
135        Ok(_response.map(|x| x.s))
136    }
137}
138
139#[cfg(target_os = "fuchsia")]
140impl From<ControllerSynchronousProxy> for zx::Handle {
141    fn from(value: ControllerSynchronousProxy) -> Self {
142        value.into_channel().into()
143    }
144}
145
146#[cfg(target_os = "fuchsia")]
147impl From<fidl::Channel> for ControllerSynchronousProxy {
148    fn from(value: fidl::Channel) -> Self {
149        Self::new(value)
150    }
151}
152
153#[derive(Debug, Clone)]
154pub struct ControllerProxy {
155    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
156}
157
158impl fidl::endpoints::Proxy for ControllerProxy {
159    type Protocol = ControllerMarker;
160
161    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
162        Self::new(inner)
163    }
164
165    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
166        self.client.into_channel().map_err(|client| Self { client })
167    }
168
169    fn as_channel(&self) -> &::fidl::AsyncChannel {
170        self.client.as_channel()
171    }
172}
173
174impl ControllerProxy {
175    /// Create a new Proxy for fuchsia.netemul.guest/Controller.
176    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
177        let protocol_name = <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
178        Self { client: fidl::client::Client::new(channel, protocol_name) }
179    }
180
181    /// Get a Stream of events from the remote end of the protocol.
182    ///
183    /// # Panics
184    ///
185    /// Panics if the event stream was already taken.
186    pub fn take_event_stream(&self) -> ControllerEventStream {
187        ControllerEventStream { event_receiver: self.client.take_event_receiver() }
188    }
189
190    /// Creates a new guest instance, attaches it to the provided `network`, optionally
191    /// with `mac` as its mac address, and starts serving the `Guest` protocol over
192    /// the returned client end.
193    ///
194    /// + request `name` a name to be associated with the guest, to be used in logs
195    ///   and assertions.
196    /// + request `network` the client end of a netemul network, to which the guest
197    ///   should be attached.
198    /// + request `mac` an optional mac address which is provided to the guest on
199    ///   on creation. If `mac` is not provided, the guest's mac address is picked
200    ///   by guest-manager.
201    /// + response `guest` the client end of a `Guest` protocol which can be used to
202    ///   interact with the guest.
203    pub fn r#create_guest(
204        &self,
205        mut name: &str,
206        mut network: fidl::endpoints::ClientEnd<fidl_fuchsia_netemul_network::NetworkMarker>,
207        mut mac: Option<&fidl_fuchsia_net::MacAddress>,
208    ) -> fidl::client::QueryResponseFut<
209        ControllerCreateGuestResult,
210        fidl::encoding::DefaultFuchsiaResourceDialect,
211    > {
212        ControllerProxyInterface::r#create_guest(self, name, network, mac)
213    }
214}
215
216impl ControllerProxyInterface for ControllerProxy {
217    type CreateGuestResponseFut = fidl::client::QueryResponseFut<
218        ControllerCreateGuestResult,
219        fidl::encoding::DefaultFuchsiaResourceDialect,
220    >;
221    fn r#create_guest(
222        &self,
223        mut name: &str,
224        mut network: fidl::endpoints::ClientEnd<fidl_fuchsia_netemul_network::NetworkMarker>,
225        mut mac: Option<&fidl_fuchsia_net::MacAddress>,
226    ) -> Self::CreateGuestResponseFut {
227        fn _decode(
228            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
229        ) -> Result<ControllerCreateGuestResult, fidl::Error> {
230            let _response = fidl::client::decode_transaction_body::<
231                fidl::encoding::ResultType<
232                    ControllerCreateGuestResponse,
233                    ControllerCreateGuestError,
234                >,
235                fidl::encoding::DefaultFuchsiaResourceDialect,
236                0x5c49cf5272f818c0,
237            >(_buf?)?;
238            Ok(_response.map(|x| x.s))
239        }
240        self.client
241            .send_query_and_decode::<ControllerCreateGuestRequest, ControllerCreateGuestResult>(
242                (name, network, mac),
243                0x5c49cf5272f818c0,
244                fidl::encoding::DynamicFlags::empty(),
245                _decode,
246            )
247    }
248}
249
250pub struct ControllerEventStream {
251    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
252}
253
254impl std::marker::Unpin for ControllerEventStream {}
255
256impl futures::stream::FusedStream for ControllerEventStream {
257    fn is_terminated(&self) -> bool {
258        self.event_receiver.is_terminated()
259    }
260}
261
262impl futures::Stream for ControllerEventStream {
263    type Item = Result<ControllerEvent, fidl::Error>;
264
265    fn poll_next(
266        mut self: std::pin::Pin<&mut Self>,
267        cx: &mut std::task::Context<'_>,
268    ) -> std::task::Poll<Option<Self::Item>> {
269        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
270            &mut self.event_receiver,
271            cx
272        )?) {
273            Some(buf) => std::task::Poll::Ready(Some(ControllerEvent::decode(buf))),
274            None => std::task::Poll::Ready(None),
275        }
276    }
277}
278
279#[derive(Debug)]
280pub enum ControllerEvent {}
281
282impl ControllerEvent {
283    /// Decodes a message buffer as a [`ControllerEvent`].
284    fn decode(
285        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
286    ) -> Result<ControllerEvent, fidl::Error> {
287        let (bytes, _handles) = buf.split_mut();
288        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
289        debug_assert_eq!(tx_header.tx_id, 0);
290        match tx_header.ordinal {
291            _ => Err(fidl::Error::UnknownOrdinal {
292                ordinal: tx_header.ordinal,
293                protocol_name: <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
294            }),
295        }
296    }
297}
298
299/// A Stream of incoming requests for fuchsia.netemul.guest/Controller.
300pub struct ControllerRequestStream {
301    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
302    is_terminated: bool,
303}
304
305impl std::marker::Unpin for ControllerRequestStream {}
306
307impl futures::stream::FusedStream for ControllerRequestStream {
308    fn is_terminated(&self) -> bool {
309        self.is_terminated
310    }
311}
312
313impl fidl::endpoints::RequestStream for ControllerRequestStream {
314    type Protocol = ControllerMarker;
315    type ControlHandle = ControllerControlHandle;
316
317    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
318        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
319    }
320
321    fn control_handle(&self) -> Self::ControlHandle {
322        ControllerControlHandle { inner: self.inner.clone() }
323    }
324
325    fn into_inner(
326        self,
327    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
328    {
329        (self.inner, self.is_terminated)
330    }
331
332    fn from_inner(
333        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
334        is_terminated: bool,
335    ) -> Self {
336        Self { inner, is_terminated }
337    }
338}
339
340impl futures::Stream for ControllerRequestStream {
341    type Item = Result<ControllerRequest, fidl::Error>;
342
343    fn poll_next(
344        mut self: std::pin::Pin<&mut Self>,
345        cx: &mut std::task::Context<'_>,
346    ) -> std::task::Poll<Option<Self::Item>> {
347        let this = &mut *self;
348        if this.inner.check_shutdown(cx) {
349            this.is_terminated = true;
350            return std::task::Poll::Ready(None);
351        }
352        if this.is_terminated {
353            panic!("polled ControllerRequestStream after completion");
354        }
355        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
356            |bytes, handles| {
357                match this.inner.channel().read_etc(cx, bytes, handles) {
358                    std::task::Poll::Ready(Ok(())) => {}
359                    std::task::Poll::Pending => return std::task::Poll::Pending,
360                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
361                        this.is_terminated = true;
362                        return std::task::Poll::Ready(None);
363                    }
364                    std::task::Poll::Ready(Err(e)) => {
365                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
366                            e.into(),
367                        ))))
368                    }
369                }
370
371                // A message has been received from the channel
372                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
373
374                std::task::Poll::Ready(Some(match header.ordinal {
375                    0x5c49cf5272f818c0 => {
376                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
377                        let mut req = fidl::new_empty!(
378                            ControllerCreateGuestRequest,
379                            fidl::encoding::DefaultFuchsiaResourceDialect
380                        );
381                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ControllerCreateGuestRequest>(&header, _body_bytes, handles, &mut req)?;
382                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
383                        Ok(ControllerRequest::CreateGuest {
384                            name: req.name,
385                            network: req.network,
386                            mac: req.mac,
387
388                            responder: ControllerCreateGuestResponder {
389                                control_handle: std::mem::ManuallyDrop::new(control_handle),
390                                tx_id: header.tx_id,
391                            },
392                        })
393                    }
394                    _ => Err(fidl::Error::UnknownOrdinal {
395                        ordinal: header.ordinal,
396                        protocol_name:
397                            <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
398                    }),
399                }))
400            },
401        )
402    }
403}
404
405/// `Controller` exposes methods for interacting with the guest manager.
406#[derive(Debug)]
407pub enum ControllerRequest {
408    /// Creates a new guest instance, attaches it to the provided `network`, optionally
409    /// with `mac` as its mac address, and starts serving the `Guest` protocol over
410    /// the returned client end.
411    ///
412    /// + request `name` a name to be associated with the guest, to be used in logs
413    ///   and assertions.
414    /// + request `network` the client end of a netemul network, to which the guest
415    ///   should be attached.
416    /// + request `mac` an optional mac address which is provided to the guest on
417    ///   on creation. If `mac` is not provided, the guest's mac address is picked
418    ///   by guest-manager.
419    /// + response `guest` the client end of a `Guest` protocol which can be used to
420    ///   interact with the guest.
421    CreateGuest {
422        name: String,
423        network: fidl::endpoints::ClientEnd<fidl_fuchsia_netemul_network::NetworkMarker>,
424        mac: Option<Box<fidl_fuchsia_net::MacAddress>>,
425        responder: ControllerCreateGuestResponder,
426    },
427}
428
429impl ControllerRequest {
430    #[allow(irrefutable_let_patterns)]
431    pub fn into_create_guest(
432        self,
433    ) -> Option<(
434        String,
435        fidl::endpoints::ClientEnd<fidl_fuchsia_netemul_network::NetworkMarker>,
436        Option<Box<fidl_fuchsia_net::MacAddress>>,
437        ControllerCreateGuestResponder,
438    )> {
439        if let ControllerRequest::CreateGuest { name, network, mac, responder } = self {
440            Some((name, network, mac, responder))
441        } else {
442            None
443        }
444    }
445
446    /// Name of the method defined in FIDL
447    pub fn method_name(&self) -> &'static str {
448        match *self {
449            ControllerRequest::CreateGuest { .. } => "create_guest",
450        }
451    }
452}
453
454#[derive(Debug, Clone)]
455pub struct ControllerControlHandle {
456    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
457}
458
459impl fidl::endpoints::ControlHandle for ControllerControlHandle {
460    fn shutdown(&self) {
461        self.inner.shutdown()
462    }
463    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
464        self.inner.shutdown_with_epitaph(status)
465    }
466
467    fn is_closed(&self) -> bool {
468        self.inner.channel().is_closed()
469    }
470    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
471        self.inner.channel().on_closed()
472    }
473
474    #[cfg(target_os = "fuchsia")]
475    fn signal_peer(
476        &self,
477        clear_mask: zx::Signals,
478        set_mask: zx::Signals,
479    ) -> Result<(), zx_status::Status> {
480        use fidl::Peered;
481        self.inner.channel().signal_peer(clear_mask, set_mask)
482    }
483}
484
485impl ControllerControlHandle {}
486
487#[must_use = "FIDL methods require a response to be sent"]
488#[derive(Debug)]
489pub struct ControllerCreateGuestResponder {
490    control_handle: std::mem::ManuallyDrop<ControllerControlHandle>,
491    tx_id: u32,
492}
493
494/// Set the the channel to be shutdown (see [`ControllerControlHandle::shutdown`])
495/// if the responder is dropped without sending a response, so that the client
496/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
497impl std::ops::Drop for ControllerCreateGuestResponder {
498    fn drop(&mut self) {
499        self.control_handle.shutdown();
500        // Safety: drops once, never accessed again
501        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
502    }
503}
504
505impl fidl::endpoints::Responder for ControllerCreateGuestResponder {
506    type ControlHandle = ControllerControlHandle;
507
508    fn control_handle(&self) -> &ControllerControlHandle {
509        &self.control_handle
510    }
511
512    fn drop_without_shutdown(mut self) {
513        // Safety: drops once, never accessed again due to mem::forget
514        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
515        // Prevent Drop from running (which would shut down the channel)
516        std::mem::forget(self);
517    }
518}
519
520impl ControllerCreateGuestResponder {
521    /// Sends a response to the FIDL transaction.
522    ///
523    /// Sets the channel to shutdown if an error occurs.
524    pub fn send(
525        self,
526        mut result: Result<fidl::endpoints::ClientEnd<GuestMarker>, ControllerCreateGuestError>,
527    ) -> Result<(), fidl::Error> {
528        let _result = self.send_raw(result);
529        if _result.is_err() {
530            self.control_handle.shutdown();
531        }
532        self.drop_without_shutdown();
533        _result
534    }
535
536    /// Similar to "send" but does not shutdown the channel if an error occurs.
537    pub fn send_no_shutdown_on_err(
538        self,
539        mut result: Result<fidl::endpoints::ClientEnd<GuestMarker>, ControllerCreateGuestError>,
540    ) -> Result<(), fidl::Error> {
541        let _result = self.send_raw(result);
542        self.drop_without_shutdown();
543        _result
544    }
545
546    fn send_raw(
547        &self,
548        mut result: Result<fidl::endpoints::ClientEnd<GuestMarker>, ControllerCreateGuestError>,
549    ) -> Result<(), fidl::Error> {
550        self.control_handle.inner.send::<fidl::encoding::ResultType<
551            ControllerCreateGuestResponse,
552            ControllerCreateGuestError,
553        >>(
554            result.map(|s| (s,)),
555            self.tx_id,
556            0x5c49cf5272f818c0,
557            fidl::encoding::DynamicFlags::empty(),
558        )
559    }
560}
561
562#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
563pub struct GuestMarker;
564
565impl fidl::endpoints::ProtocolMarker for GuestMarker {
566    type Proxy = GuestProxy;
567    type RequestStream = GuestRequestStream;
568    #[cfg(target_os = "fuchsia")]
569    type SynchronousProxy = GuestSynchronousProxy;
570
571    const DEBUG_NAME: &'static str = "(anonymous) Guest";
572}
573
574pub trait GuestProxyInterface: Send + Sync {
575    type PutFileResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
576    fn r#put_file(
577        &self,
578        local_file: fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
579        remote_path: &str,
580    ) -> Self::PutFileResponseFut;
581    type GetFileResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
582    fn r#get_file(
583        &self,
584        remote_path: &str,
585        local_file: fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
586    ) -> Self::GetFileResponseFut;
587    fn r#execute_command(
588        &self,
589        command: &str,
590        env: &[fidl_fuchsia_virtualization_guest_interaction::EnvironmentVariable],
591        stdin: Option<fidl::Socket>,
592        stdout: Option<fidl::Socket>,
593        stderr: Option<fidl::Socket>,
594        command_listener: fidl::endpoints::ServerEnd<
595            fidl_fuchsia_virtualization_guest_interaction::CommandListenerMarker,
596        >,
597    ) -> Result<(), fidl::Error>;
598    type ShutdownResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
599    fn r#shutdown(&self) -> Self::ShutdownResponseFut;
600}
601#[derive(Debug)]
602#[cfg(target_os = "fuchsia")]
603pub struct GuestSynchronousProxy {
604    client: fidl::client::sync::Client,
605}
606
607#[cfg(target_os = "fuchsia")]
608impl fidl::endpoints::SynchronousProxy for GuestSynchronousProxy {
609    type Proxy = GuestProxy;
610    type Protocol = GuestMarker;
611
612    fn from_channel(inner: fidl::Channel) -> Self {
613        Self::new(inner)
614    }
615
616    fn into_channel(self) -> fidl::Channel {
617        self.client.into_channel()
618    }
619
620    fn as_channel(&self) -> &fidl::Channel {
621        self.client.as_channel()
622    }
623}
624
625#[cfg(target_os = "fuchsia")]
626impl GuestSynchronousProxy {
627    pub fn new(channel: fidl::Channel) -> Self {
628        let protocol_name = <GuestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
629        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
630    }
631
632    pub fn into_channel(self) -> fidl::Channel {
633        self.client.into_channel()
634    }
635
636    /// Waits until an event arrives and returns it. It is safe for other
637    /// threads to make concurrent requests while waiting for an event.
638    pub fn wait_for_event(
639        &self,
640        deadline: zx::MonotonicInstant,
641    ) -> Result<GuestEvent, fidl::Error> {
642        GuestEvent::decode(self.client.wait_for_event(deadline)?)
643    }
644
645    /// Take a local file from the Fuchsia host and transfer it to a destination
646    /// location on the guest under test.
647    pub fn r#put_file(
648        &self,
649        mut local_file: fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
650        mut remote_path: &str,
651        ___deadline: zx::MonotonicInstant,
652    ) -> Result<i32, fidl::Error> {
653        let _response = self.client.send_query::<
654            fidl_fuchsia_virtualization_guest_interaction::InteractionPutFileRequest,
655            fidl_fuchsia_virtualization_guest_interaction::InteractionPutFileResponse,
656        >(
657            (local_file, remote_path,),
658            0x223bc20da4a7cddd,
659            fidl::encoding::DynamicFlags::empty(),
660            ___deadline,
661        )?;
662        Ok(_response.status)
663    }
664
665    /// Pull a file from the guest under test and copy it to the specified
666    /// location on the Fuchsia host.
667    pub fn r#get_file(
668        &self,
669        mut remote_path: &str,
670        mut local_file: fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
671        ___deadline: zx::MonotonicInstant,
672    ) -> Result<i32, fidl::Error> {
673        let _response = self.client.send_query::<
674            fidl_fuchsia_virtualization_guest_interaction::InteractionGetFileRequest,
675            fidl_fuchsia_virtualization_guest_interaction::InteractionGetFileResponse,
676        >(
677            (remote_path, local_file,),
678            0x7696bea472ca0f2d,
679            fidl::encoding::DynamicFlags::empty(),
680            ___deadline,
681        )?;
682        Ok(_response.status)
683    }
684
685    /// Execute command on the guest under test and return the resulting output,
686    /// error, and return code.
687    pub fn r#execute_command(
688        &self,
689        mut command: &str,
690        mut env: &[fidl_fuchsia_virtualization_guest_interaction::EnvironmentVariable],
691        mut stdin: Option<fidl::Socket>,
692        mut stdout: Option<fidl::Socket>,
693        mut stderr: Option<fidl::Socket>,
694        mut command_listener: fidl::endpoints::ServerEnd<
695            fidl_fuchsia_virtualization_guest_interaction::CommandListenerMarker,
696        >,
697    ) -> Result<(), fidl::Error> {
698        self.client.send::<fidl_fuchsia_virtualization_guest_interaction::InteractionExecuteCommandRequest>(
699            (command, env, stdin, stdout, stderr, command_listener,),
700            0x612641220a1556d8,
701            fidl::encoding::DynamicFlags::empty(),
702        )
703    }
704
705    /// Shuts down the guest and closes the channel over which `Guest` is being
706    /// served.
707    pub fn r#shutdown(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
708        let _response =
709            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
710                (),
711                0x287e71d61642d1cc,
712                fidl::encoding::DynamicFlags::empty(),
713                ___deadline,
714            )?;
715        Ok(_response)
716    }
717}
718
719#[cfg(target_os = "fuchsia")]
720impl From<GuestSynchronousProxy> for zx::Handle {
721    fn from(value: GuestSynchronousProxy) -> Self {
722        value.into_channel().into()
723    }
724}
725
726#[cfg(target_os = "fuchsia")]
727impl From<fidl::Channel> for GuestSynchronousProxy {
728    fn from(value: fidl::Channel) -> Self {
729        Self::new(value)
730    }
731}
732
733#[derive(Debug, Clone)]
734pub struct GuestProxy {
735    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
736}
737
738impl fidl::endpoints::Proxy for GuestProxy {
739    type Protocol = GuestMarker;
740
741    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
742        Self::new(inner)
743    }
744
745    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
746        self.client.into_channel().map_err(|client| Self { client })
747    }
748
749    fn as_channel(&self) -> &::fidl::AsyncChannel {
750        self.client.as_channel()
751    }
752}
753
754impl GuestProxy {
755    /// Create a new Proxy for fuchsia.netemul.guest/Guest.
756    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
757        let protocol_name = <GuestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
758        Self { client: fidl::client::Client::new(channel, protocol_name) }
759    }
760
761    /// Get a Stream of events from the remote end of the protocol.
762    ///
763    /// # Panics
764    ///
765    /// Panics if the event stream was already taken.
766    pub fn take_event_stream(&self) -> GuestEventStream {
767        GuestEventStream { event_receiver: self.client.take_event_receiver() }
768    }
769
770    /// Take a local file from the Fuchsia host and transfer it to a destination
771    /// location on the guest under test.
772    pub fn r#put_file(
773        &self,
774        mut local_file: fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
775        mut remote_path: &str,
776    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
777        GuestProxyInterface::r#put_file(self, local_file, remote_path)
778    }
779
780    /// Pull a file from the guest under test and copy it to the specified
781    /// location on the Fuchsia host.
782    pub fn r#get_file(
783        &self,
784        mut remote_path: &str,
785        mut local_file: fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
786    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
787        GuestProxyInterface::r#get_file(self, remote_path, local_file)
788    }
789
790    /// Execute command on the guest under test and return the resulting output,
791    /// error, and return code.
792    pub fn r#execute_command(
793        &self,
794        mut command: &str,
795        mut env: &[fidl_fuchsia_virtualization_guest_interaction::EnvironmentVariable],
796        mut stdin: Option<fidl::Socket>,
797        mut stdout: Option<fidl::Socket>,
798        mut stderr: Option<fidl::Socket>,
799        mut command_listener: fidl::endpoints::ServerEnd<
800            fidl_fuchsia_virtualization_guest_interaction::CommandListenerMarker,
801        >,
802    ) -> Result<(), fidl::Error> {
803        GuestProxyInterface::r#execute_command(
804            self,
805            command,
806            env,
807            stdin,
808            stdout,
809            stderr,
810            command_listener,
811        )
812    }
813
814    /// Shuts down the guest and closes the channel over which `Guest` is being
815    /// served.
816    pub fn r#shutdown(
817        &self,
818    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
819        GuestProxyInterface::r#shutdown(self)
820    }
821}
822
823impl GuestProxyInterface for GuestProxy {
824    type PutFileResponseFut =
825        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
826    fn r#put_file(
827        &self,
828        mut local_file: fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
829        mut remote_path: &str,
830    ) -> Self::PutFileResponseFut {
831        fn _decode(
832            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
833        ) -> Result<i32, fidl::Error> {
834            let _response = fidl::client::decode_transaction_body::<
835                fidl_fuchsia_virtualization_guest_interaction::InteractionPutFileResponse,
836                fidl::encoding::DefaultFuchsiaResourceDialect,
837                0x223bc20da4a7cddd,
838            >(_buf?)?;
839            Ok(_response.status)
840        }
841        self.client.send_query_and_decode::<
842            fidl_fuchsia_virtualization_guest_interaction::InteractionPutFileRequest,
843            i32,
844        >(
845            (local_file, remote_path,),
846            0x223bc20da4a7cddd,
847            fidl::encoding::DynamicFlags::empty(),
848            _decode,
849        )
850    }
851
852    type GetFileResponseFut =
853        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
854    fn r#get_file(
855        &self,
856        mut remote_path: &str,
857        mut local_file: fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
858    ) -> Self::GetFileResponseFut {
859        fn _decode(
860            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
861        ) -> Result<i32, fidl::Error> {
862            let _response = fidl::client::decode_transaction_body::<
863                fidl_fuchsia_virtualization_guest_interaction::InteractionGetFileResponse,
864                fidl::encoding::DefaultFuchsiaResourceDialect,
865                0x7696bea472ca0f2d,
866            >(_buf?)?;
867            Ok(_response.status)
868        }
869        self.client.send_query_and_decode::<
870            fidl_fuchsia_virtualization_guest_interaction::InteractionGetFileRequest,
871            i32,
872        >(
873            (remote_path, local_file,),
874            0x7696bea472ca0f2d,
875            fidl::encoding::DynamicFlags::empty(),
876            _decode,
877        )
878    }
879
880    fn r#execute_command(
881        &self,
882        mut command: &str,
883        mut env: &[fidl_fuchsia_virtualization_guest_interaction::EnvironmentVariable],
884        mut stdin: Option<fidl::Socket>,
885        mut stdout: Option<fidl::Socket>,
886        mut stderr: Option<fidl::Socket>,
887        mut command_listener: fidl::endpoints::ServerEnd<
888            fidl_fuchsia_virtualization_guest_interaction::CommandListenerMarker,
889        >,
890    ) -> Result<(), fidl::Error> {
891        self.client.send::<fidl_fuchsia_virtualization_guest_interaction::InteractionExecuteCommandRequest>(
892            (command, env, stdin, stdout, stderr, command_listener,),
893            0x612641220a1556d8,
894            fidl::encoding::DynamicFlags::empty(),
895        )
896    }
897
898    type ShutdownResponseFut =
899        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
900    fn r#shutdown(&self) -> Self::ShutdownResponseFut {
901        fn _decode(
902            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
903        ) -> Result<(), fidl::Error> {
904            let _response = fidl::client::decode_transaction_body::<
905                fidl::encoding::EmptyPayload,
906                fidl::encoding::DefaultFuchsiaResourceDialect,
907                0x287e71d61642d1cc,
908            >(_buf?)?;
909            Ok(_response)
910        }
911        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
912            (),
913            0x287e71d61642d1cc,
914            fidl::encoding::DynamicFlags::empty(),
915            _decode,
916        )
917    }
918}
919
920pub struct GuestEventStream {
921    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
922}
923
924impl std::marker::Unpin for GuestEventStream {}
925
926impl futures::stream::FusedStream for GuestEventStream {
927    fn is_terminated(&self) -> bool {
928        self.event_receiver.is_terminated()
929    }
930}
931
932impl futures::Stream for GuestEventStream {
933    type Item = Result<GuestEvent, fidl::Error>;
934
935    fn poll_next(
936        mut self: std::pin::Pin<&mut Self>,
937        cx: &mut std::task::Context<'_>,
938    ) -> std::task::Poll<Option<Self::Item>> {
939        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
940            &mut self.event_receiver,
941            cx
942        )?) {
943            Some(buf) => std::task::Poll::Ready(Some(GuestEvent::decode(buf))),
944            None => std::task::Poll::Ready(None),
945        }
946    }
947}
948
949#[derive(Debug)]
950pub enum GuestEvent {}
951
952impl GuestEvent {
953    /// Decodes a message buffer as a [`GuestEvent`].
954    fn decode(
955        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
956    ) -> Result<GuestEvent, fidl::Error> {
957        let (bytes, _handles) = buf.split_mut();
958        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
959        debug_assert_eq!(tx_header.tx_id, 0);
960        match tx_header.ordinal {
961            _ => Err(fidl::Error::UnknownOrdinal {
962                ordinal: tx_header.ordinal,
963                protocol_name: <GuestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
964            }),
965        }
966    }
967}
968
969/// A Stream of incoming requests for fuchsia.netemul.guest/Guest.
970pub struct GuestRequestStream {
971    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
972    is_terminated: bool,
973}
974
975impl std::marker::Unpin for GuestRequestStream {}
976
977impl futures::stream::FusedStream for GuestRequestStream {
978    fn is_terminated(&self) -> bool {
979        self.is_terminated
980    }
981}
982
983impl fidl::endpoints::RequestStream for GuestRequestStream {
984    type Protocol = GuestMarker;
985    type ControlHandle = GuestControlHandle;
986
987    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
988        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
989    }
990
991    fn control_handle(&self) -> Self::ControlHandle {
992        GuestControlHandle { inner: self.inner.clone() }
993    }
994
995    fn into_inner(
996        self,
997    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
998    {
999        (self.inner, self.is_terminated)
1000    }
1001
1002    fn from_inner(
1003        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1004        is_terminated: bool,
1005    ) -> Self {
1006        Self { inner, is_terminated }
1007    }
1008}
1009
1010impl futures::Stream for GuestRequestStream {
1011    type Item = Result<GuestRequest, fidl::Error>;
1012
1013    fn poll_next(
1014        mut self: std::pin::Pin<&mut Self>,
1015        cx: &mut std::task::Context<'_>,
1016    ) -> std::task::Poll<Option<Self::Item>> {
1017        let this = &mut *self;
1018        if this.inner.check_shutdown(cx) {
1019            this.is_terminated = true;
1020            return std::task::Poll::Ready(None);
1021        }
1022        if this.is_terminated {
1023            panic!("polled GuestRequestStream after completion");
1024        }
1025        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1026            |bytes, handles| {
1027                match this.inner.channel().read_etc(cx, bytes, handles) {
1028                    std::task::Poll::Ready(Ok(())) => {}
1029                    std::task::Poll::Pending => return std::task::Poll::Pending,
1030                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1031                        this.is_terminated = true;
1032                        return std::task::Poll::Ready(None);
1033                    }
1034                    std::task::Poll::Ready(Err(e)) => {
1035                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1036                            e.into(),
1037                        ))))
1038                    }
1039                }
1040
1041                // A message has been received from the channel
1042                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1043
1044                std::task::Poll::Ready(Some(match header.ordinal {
1045                    0x223bc20da4a7cddd => {
1046                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1047                        let mut req = fidl::new_empty!(fidl_fuchsia_virtualization_guest_interaction::InteractionPutFileRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
1048                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_virtualization_guest_interaction::InteractionPutFileRequest>(&header, _body_bytes, handles, &mut req)?;
1049                        let control_handle = GuestControlHandle { inner: this.inner.clone() };
1050                        Ok(GuestRequest::PutFile {
1051                            local_file: req.local_file,
1052                            remote_path: req.remote_path,
1053
1054                            responder: GuestPutFileResponder {
1055                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1056                                tx_id: header.tx_id,
1057                            },
1058                        })
1059                    }
1060                    0x7696bea472ca0f2d => {
1061                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1062                        let mut req = fidl::new_empty!(fidl_fuchsia_virtualization_guest_interaction::InteractionGetFileRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
1063                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_virtualization_guest_interaction::InteractionGetFileRequest>(&header, _body_bytes, handles, &mut req)?;
1064                        let control_handle = GuestControlHandle { inner: this.inner.clone() };
1065                        Ok(GuestRequest::GetFile {
1066                            remote_path: req.remote_path,
1067                            local_file: req.local_file,
1068
1069                            responder: GuestGetFileResponder {
1070                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1071                                tx_id: header.tx_id,
1072                            },
1073                        })
1074                    }
1075                    0x612641220a1556d8 => {
1076                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
1077                        let mut req = fidl::new_empty!(fidl_fuchsia_virtualization_guest_interaction::InteractionExecuteCommandRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
1078                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_virtualization_guest_interaction::InteractionExecuteCommandRequest>(&header, _body_bytes, handles, &mut req)?;
1079                        let control_handle = GuestControlHandle { inner: this.inner.clone() };
1080                        Ok(GuestRequest::ExecuteCommand {
1081                            command: req.command,
1082                            env: req.env,
1083                            stdin: req.stdin,
1084                            stdout: req.stdout,
1085                            stderr: req.stderr,
1086                            command_listener: req.command_listener,
1087
1088                            control_handle,
1089                        })
1090                    }
1091                    0x287e71d61642d1cc => {
1092                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1093                        let mut req = fidl::new_empty!(
1094                            fidl::encoding::EmptyPayload,
1095                            fidl::encoding::DefaultFuchsiaResourceDialect
1096                        );
1097                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1098                        let control_handle = GuestControlHandle { inner: this.inner.clone() };
1099                        Ok(GuestRequest::Shutdown {
1100                            responder: GuestShutdownResponder {
1101                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1102                                tx_id: header.tx_id,
1103                            },
1104                        })
1105                    }
1106                    _ => Err(fidl::Error::UnknownOrdinal {
1107                        ordinal: header.ordinal,
1108                        protocol_name: <GuestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1109                    }),
1110                }))
1111            },
1112        )
1113    }
1114}
1115
1116/// `Guest` exposes methods for interacting with a virtualized guest.
1117///
1118/// A connection to `Guest` provides access to a single virtualized guest.
1119/// The guest lifetime is bound to the connection; when the client handle
1120/// is dropped, the guest will be shutdown. NOTE however that this
1121/// shutdown-on-drop happens asynchronously; clients should always use
1122/// the synchronous method below to avoid flakes when running multiple
1123/// tests.
1124#[derive(Debug)]
1125pub enum GuestRequest {
1126    /// Take a local file from the Fuchsia host and transfer it to a destination
1127    /// location on the guest under test.
1128    PutFile {
1129        local_file: fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
1130        remote_path: String,
1131        responder: GuestPutFileResponder,
1132    },
1133    /// Pull a file from the guest under test and copy it to the specified
1134    /// location on the Fuchsia host.
1135    GetFile {
1136        remote_path: String,
1137        local_file: fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
1138        responder: GuestGetFileResponder,
1139    },
1140    /// Execute command on the guest under test and return the resulting output,
1141    /// error, and return code.
1142    ExecuteCommand {
1143        command: String,
1144        env: Vec<fidl_fuchsia_virtualization_guest_interaction::EnvironmentVariable>,
1145        stdin: Option<fidl::Socket>,
1146        stdout: Option<fidl::Socket>,
1147        stderr: Option<fidl::Socket>,
1148        command_listener: fidl::endpoints::ServerEnd<
1149            fidl_fuchsia_virtualization_guest_interaction::CommandListenerMarker,
1150        >,
1151        control_handle: GuestControlHandle,
1152    },
1153    /// Shuts down the guest and closes the channel over which `Guest` is being
1154    /// served.
1155    Shutdown { responder: GuestShutdownResponder },
1156}
1157
1158impl GuestRequest {
1159    #[allow(irrefutable_let_patterns)]
1160    pub fn into_put_file(
1161        self,
1162    ) -> Option<(
1163        fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
1164        String,
1165        GuestPutFileResponder,
1166    )> {
1167        if let GuestRequest::PutFile { local_file, remote_path, responder } = self {
1168            Some((local_file, remote_path, responder))
1169        } else {
1170            None
1171        }
1172    }
1173
1174    #[allow(irrefutable_let_patterns)]
1175    pub fn into_get_file(
1176        self,
1177    ) -> Option<(
1178        String,
1179        fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
1180        GuestGetFileResponder,
1181    )> {
1182        if let GuestRequest::GetFile { remote_path, local_file, responder } = self {
1183            Some((remote_path, local_file, responder))
1184        } else {
1185            None
1186        }
1187    }
1188
1189    #[allow(irrefutable_let_patterns)]
1190    pub fn into_execute_command(
1191        self,
1192    ) -> Option<(
1193        String,
1194        Vec<fidl_fuchsia_virtualization_guest_interaction::EnvironmentVariable>,
1195        Option<fidl::Socket>,
1196        Option<fidl::Socket>,
1197        Option<fidl::Socket>,
1198        fidl::endpoints::ServerEnd<
1199            fidl_fuchsia_virtualization_guest_interaction::CommandListenerMarker,
1200        >,
1201        GuestControlHandle,
1202    )> {
1203        if let GuestRequest::ExecuteCommand {
1204            command,
1205            env,
1206            stdin,
1207            stdout,
1208            stderr,
1209            command_listener,
1210            control_handle,
1211        } = self
1212        {
1213            Some((command, env, stdin, stdout, stderr, command_listener, control_handle))
1214        } else {
1215            None
1216        }
1217    }
1218
1219    #[allow(irrefutable_let_patterns)]
1220    pub fn into_shutdown(self) -> Option<(GuestShutdownResponder)> {
1221        if let GuestRequest::Shutdown { responder } = self {
1222            Some((responder))
1223        } else {
1224            None
1225        }
1226    }
1227
1228    /// Name of the method defined in FIDL
1229    pub fn method_name(&self) -> &'static str {
1230        match *self {
1231            GuestRequest::PutFile { .. } => "put_file",
1232            GuestRequest::GetFile { .. } => "get_file",
1233            GuestRequest::ExecuteCommand { .. } => "execute_command",
1234            GuestRequest::Shutdown { .. } => "shutdown",
1235        }
1236    }
1237}
1238
1239#[derive(Debug, Clone)]
1240pub struct GuestControlHandle {
1241    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1242}
1243
1244impl fidl::endpoints::ControlHandle for GuestControlHandle {
1245    fn shutdown(&self) {
1246        self.inner.shutdown()
1247    }
1248    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1249        self.inner.shutdown_with_epitaph(status)
1250    }
1251
1252    fn is_closed(&self) -> bool {
1253        self.inner.channel().is_closed()
1254    }
1255    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1256        self.inner.channel().on_closed()
1257    }
1258
1259    #[cfg(target_os = "fuchsia")]
1260    fn signal_peer(
1261        &self,
1262        clear_mask: zx::Signals,
1263        set_mask: zx::Signals,
1264    ) -> Result<(), zx_status::Status> {
1265        use fidl::Peered;
1266        self.inner.channel().signal_peer(clear_mask, set_mask)
1267    }
1268}
1269
1270impl GuestControlHandle {}
1271
1272#[must_use = "FIDL methods require a response to be sent"]
1273#[derive(Debug)]
1274pub struct GuestPutFileResponder {
1275    control_handle: std::mem::ManuallyDrop<GuestControlHandle>,
1276    tx_id: u32,
1277}
1278
1279/// Set the the channel to be shutdown (see [`GuestControlHandle::shutdown`])
1280/// if the responder is dropped without sending a response, so that the client
1281/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1282impl std::ops::Drop for GuestPutFileResponder {
1283    fn drop(&mut self) {
1284        self.control_handle.shutdown();
1285        // Safety: drops once, never accessed again
1286        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1287    }
1288}
1289
1290impl fidl::endpoints::Responder for GuestPutFileResponder {
1291    type ControlHandle = GuestControlHandle;
1292
1293    fn control_handle(&self) -> &GuestControlHandle {
1294        &self.control_handle
1295    }
1296
1297    fn drop_without_shutdown(mut self) {
1298        // Safety: drops once, never accessed again due to mem::forget
1299        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1300        // Prevent Drop from running (which would shut down the channel)
1301        std::mem::forget(self);
1302    }
1303}
1304
1305impl GuestPutFileResponder {
1306    /// Sends a response to the FIDL transaction.
1307    ///
1308    /// Sets the channel to shutdown if an error occurs.
1309    pub fn send(self, mut status: i32) -> Result<(), fidl::Error> {
1310        let _result = self.send_raw(status);
1311        if _result.is_err() {
1312            self.control_handle.shutdown();
1313        }
1314        self.drop_without_shutdown();
1315        _result
1316    }
1317
1318    /// Similar to "send" but does not shutdown the channel if an error occurs.
1319    pub fn send_no_shutdown_on_err(self, mut status: i32) -> Result<(), fidl::Error> {
1320        let _result = self.send_raw(status);
1321        self.drop_without_shutdown();
1322        _result
1323    }
1324
1325    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
1326        self.control_handle
1327            .inner
1328            .send::<fidl_fuchsia_virtualization_guest_interaction::InteractionPutFileResponse>(
1329            (status,),
1330            self.tx_id,
1331            0x223bc20da4a7cddd,
1332            fidl::encoding::DynamicFlags::empty(),
1333        )
1334    }
1335}
1336
1337#[must_use = "FIDL methods require a response to be sent"]
1338#[derive(Debug)]
1339pub struct GuestGetFileResponder {
1340    control_handle: std::mem::ManuallyDrop<GuestControlHandle>,
1341    tx_id: u32,
1342}
1343
1344/// Set the the channel to be shutdown (see [`GuestControlHandle::shutdown`])
1345/// if the responder is dropped without sending a response, so that the client
1346/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1347impl std::ops::Drop for GuestGetFileResponder {
1348    fn drop(&mut self) {
1349        self.control_handle.shutdown();
1350        // Safety: drops once, never accessed again
1351        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1352    }
1353}
1354
1355impl fidl::endpoints::Responder for GuestGetFileResponder {
1356    type ControlHandle = GuestControlHandle;
1357
1358    fn control_handle(&self) -> &GuestControlHandle {
1359        &self.control_handle
1360    }
1361
1362    fn drop_without_shutdown(mut self) {
1363        // Safety: drops once, never accessed again due to mem::forget
1364        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1365        // Prevent Drop from running (which would shut down the channel)
1366        std::mem::forget(self);
1367    }
1368}
1369
1370impl GuestGetFileResponder {
1371    /// Sends a response to the FIDL transaction.
1372    ///
1373    /// Sets the channel to shutdown if an error occurs.
1374    pub fn send(self, mut status: i32) -> Result<(), fidl::Error> {
1375        let _result = self.send_raw(status);
1376        if _result.is_err() {
1377            self.control_handle.shutdown();
1378        }
1379        self.drop_without_shutdown();
1380        _result
1381    }
1382
1383    /// Similar to "send" but does not shutdown the channel if an error occurs.
1384    pub fn send_no_shutdown_on_err(self, mut status: i32) -> Result<(), fidl::Error> {
1385        let _result = self.send_raw(status);
1386        self.drop_without_shutdown();
1387        _result
1388    }
1389
1390    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
1391        self.control_handle
1392            .inner
1393            .send::<fidl_fuchsia_virtualization_guest_interaction::InteractionGetFileResponse>(
1394            (status,),
1395            self.tx_id,
1396            0x7696bea472ca0f2d,
1397            fidl::encoding::DynamicFlags::empty(),
1398        )
1399    }
1400}
1401
1402#[must_use = "FIDL methods require a response to be sent"]
1403#[derive(Debug)]
1404pub struct GuestShutdownResponder {
1405    control_handle: std::mem::ManuallyDrop<GuestControlHandle>,
1406    tx_id: u32,
1407}
1408
1409/// Set the the channel to be shutdown (see [`GuestControlHandle::shutdown`])
1410/// if the responder is dropped without sending a response, so that the client
1411/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1412impl std::ops::Drop for GuestShutdownResponder {
1413    fn drop(&mut self) {
1414        self.control_handle.shutdown();
1415        // Safety: drops once, never accessed again
1416        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1417    }
1418}
1419
1420impl fidl::endpoints::Responder for GuestShutdownResponder {
1421    type ControlHandle = GuestControlHandle;
1422
1423    fn control_handle(&self) -> &GuestControlHandle {
1424        &self.control_handle
1425    }
1426
1427    fn drop_without_shutdown(mut self) {
1428        // Safety: drops once, never accessed again due to mem::forget
1429        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1430        // Prevent Drop from running (which would shut down the channel)
1431        std::mem::forget(self);
1432    }
1433}
1434
1435impl GuestShutdownResponder {
1436    /// Sends a response to the FIDL transaction.
1437    ///
1438    /// Sets the channel to shutdown if an error occurs.
1439    pub fn send(self) -> Result<(), fidl::Error> {
1440        let _result = self.send_raw();
1441        if _result.is_err() {
1442            self.control_handle.shutdown();
1443        }
1444        self.drop_without_shutdown();
1445        _result
1446    }
1447
1448    /// Similar to "send" but does not shutdown the channel if an error occurs.
1449    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
1450        let _result = self.send_raw();
1451        self.drop_without_shutdown();
1452        _result
1453    }
1454
1455    fn send_raw(&self) -> Result<(), fidl::Error> {
1456        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
1457            (),
1458            self.tx_id,
1459            0x287e71d61642d1cc,
1460            fidl::encoding::DynamicFlags::empty(),
1461        )
1462    }
1463}
1464
1465mod internal {
1466    use super::*;
1467
1468    impl fidl::encoding::ResourceTypeMarker for ControllerCreateGuestRequest {
1469        type Borrowed<'a> = &'a mut Self;
1470        fn take_or_borrow<'a>(
1471            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1472        ) -> Self::Borrowed<'a> {
1473            value
1474        }
1475    }
1476
1477    unsafe impl fidl::encoding::TypeMarker for ControllerCreateGuestRequest {
1478        type Owned = Self;
1479
1480        #[inline(always)]
1481        fn inline_align(_context: fidl::encoding::Context) -> usize {
1482            8
1483        }
1484
1485        #[inline(always)]
1486        fn inline_size(_context: fidl::encoding::Context) -> usize {
1487            32
1488        }
1489    }
1490
1491    unsafe impl
1492        fidl::encoding::Encode<
1493            ControllerCreateGuestRequest,
1494            fidl::encoding::DefaultFuchsiaResourceDialect,
1495        > for &mut ControllerCreateGuestRequest
1496    {
1497        #[inline]
1498        unsafe fn encode(
1499            self,
1500            encoder: &mut fidl::encoding::Encoder<
1501                '_,
1502                fidl::encoding::DefaultFuchsiaResourceDialect,
1503            >,
1504            offset: usize,
1505            _depth: fidl::encoding::Depth,
1506        ) -> fidl::Result<()> {
1507            encoder.debug_check_bounds::<ControllerCreateGuestRequest>(offset);
1508            // Delegate to tuple encoding.
1509            fidl::encoding::Encode::<ControllerCreateGuestRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
1510                (
1511                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1512                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<fidl_fuchsia_netemul_network::NetworkMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.network),
1513                    <fidl::encoding::Boxed<fidl_fuchsia_net::MacAddress> as fidl::encoding::ValueTypeMarker>::borrow(&self.mac),
1514                ),
1515                encoder, offset, _depth
1516            )
1517        }
1518    }
1519    unsafe impl<
1520            T0: fidl::encoding::Encode<
1521                fidl::encoding::BoundedString<32>,
1522                fidl::encoding::DefaultFuchsiaResourceDialect,
1523            >,
1524            T1: fidl::encoding::Encode<
1525                fidl::encoding::Endpoint<
1526                    fidl::endpoints::ClientEnd<fidl_fuchsia_netemul_network::NetworkMarker>,
1527                >,
1528                fidl::encoding::DefaultFuchsiaResourceDialect,
1529            >,
1530            T2: fidl::encoding::Encode<
1531                fidl::encoding::Boxed<fidl_fuchsia_net::MacAddress>,
1532                fidl::encoding::DefaultFuchsiaResourceDialect,
1533            >,
1534        >
1535        fidl::encoding::Encode<
1536            ControllerCreateGuestRequest,
1537            fidl::encoding::DefaultFuchsiaResourceDialect,
1538        > for (T0, T1, T2)
1539    {
1540        #[inline]
1541        unsafe fn encode(
1542            self,
1543            encoder: &mut fidl::encoding::Encoder<
1544                '_,
1545                fidl::encoding::DefaultFuchsiaResourceDialect,
1546            >,
1547            offset: usize,
1548            depth: fidl::encoding::Depth,
1549        ) -> fidl::Result<()> {
1550            encoder.debug_check_bounds::<ControllerCreateGuestRequest>(offset);
1551            // Zero out padding regions. There's no need to apply masks
1552            // because the unmasked parts will be overwritten by fields.
1553            unsafe {
1554                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
1555                (ptr as *mut u64).write_unaligned(0);
1556            }
1557            // Write the fields.
1558            self.0.encode(encoder, offset + 0, depth)?;
1559            self.1.encode(encoder, offset + 16, depth)?;
1560            self.2.encode(encoder, offset + 24, depth)?;
1561            Ok(())
1562        }
1563    }
1564
1565    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1566        for ControllerCreateGuestRequest
1567    {
1568        #[inline(always)]
1569        fn new_empty() -> Self {
1570            Self {
1571                name: fidl::new_empty!(
1572                    fidl::encoding::BoundedString<32>,
1573                    fidl::encoding::DefaultFuchsiaResourceDialect
1574                ),
1575                network: fidl::new_empty!(
1576                    fidl::encoding::Endpoint<
1577                        fidl::endpoints::ClientEnd<fidl_fuchsia_netemul_network::NetworkMarker>,
1578                    >,
1579                    fidl::encoding::DefaultFuchsiaResourceDialect
1580                ),
1581                mac: fidl::new_empty!(
1582                    fidl::encoding::Boxed<fidl_fuchsia_net::MacAddress>,
1583                    fidl::encoding::DefaultFuchsiaResourceDialect
1584                ),
1585            }
1586        }
1587
1588        #[inline]
1589        unsafe fn decode(
1590            &mut self,
1591            decoder: &mut fidl::encoding::Decoder<
1592                '_,
1593                fidl::encoding::DefaultFuchsiaResourceDialect,
1594            >,
1595            offset: usize,
1596            _depth: fidl::encoding::Depth,
1597        ) -> fidl::Result<()> {
1598            decoder.debug_check_bounds::<Self>(offset);
1599            // Verify that padding bytes are zero.
1600            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
1601            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1602            let mask = 0xffffffff00000000u64;
1603            let maskedval = padval & mask;
1604            if maskedval != 0 {
1605                return Err(fidl::Error::NonZeroPadding {
1606                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
1607                });
1608            }
1609            fidl::decode!(
1610                fidl::encoding::BoundedString<32>,
1611                fidl::encoding::DefaultFuchsiaResourceDialect,
1612                &mut self.name,
1613                decoder,
1614                offset + 0,
1615                _depth
1616            )?;
1617            fidl::decode!(
1618                fidl::encoding::Endpoint<
1619                    fidl::endpoints::ClientEnd<fidl_fuchsia_netemul_network::NetworkMarker>,
1620                >,
1621                fidl::encoding::DefaultFuchsiaResourceDialect,
1622                &mut self.network,
1623                decoder,
1624                offset + 16,
1625                _depth
1626            )?;
1627            fidl::decode!(
1628                fidl::encoding::Boxed<fidl_fuchsia_net::MacAddress>,
1629                fidl::encoding::DefaultFuchsiaResourceDialect,
1630                &mut self.mac,
1631                decoder,
1632                offset + 24,
1633                _depth
1634            )?;
1635            Ok(())
1636        }
1637    }
1638
1639    impl fidl::encoding::ResourceTypeMarker for ControllerCreateGuestResponse {
1640        type Borrowed<'a> = &'a mut Self;
1641        fn take_or_borrow<'a>(
1642            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1643        ) -> Self::Borrowed<'a> {
1644            value
1645        }
1646    }
1647
1648    unsafe impl fidl::encoding::TypeMarker for ControllerCreateGuestResponse {
1649        type Owned = Self;
1650
1651        #[inline(always)]
1652        fn inline_align(_context: fidl::encoding::Context) -> usize {
1653            4
1654        }
1655
1656        #[inline(always)]
1657        fn inline_size(_context: fidl::encoding::Context) -> usize {
1658            4
1659        }
1660    }
1661
1662    unsafe impl
1663        fidl::encoding::Encode<
1664            ControllerCreateGuestResponse,
1665            fidl::encoding::DefaultFuchsiaResourceDialect,
1666        > for &mut ControllerCreateGuestResponse
1667    {
1668        #[inline]
1669        unsafe fn encode(
1670            self,
1671            encoder: &mut fidl::encoding::Encoder<
1672                '_,
1673                fidl::encoding::DefaultFuchsiaResourceDialect,
1674            >,
1675            offset: usize,
1676            _depth: fidl::encoding::Depth,
1677        ) -> fidl::Result<()> {
1678            encoder.debug_check_bounds::<ControllerCreateGuestResponse>(offset);
1679            // Delegate to tuple encoding.
1680            fidl::encoding::Encode::<ControllerCreateGuestResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
1681                (
1682                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<GuestMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.s),
1683                ),
1684                encoder, offset, _depth
1685            )
1686        }
1687    }
1688    unsafe impl<
1689            T0: fidl::encoding::Encode<
1690                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<GuestMarker>>,
1691                fidl::encoding::DefaultFuchsiaResourceDialect,
1692            >,
1693        >
1694        fidl::encoding::Encode<
1695            ControllerCreateGuestResponse,
1696            fidl::encoding::DefaultFuchsiaResourceDialect,
1697        > for (T0,)
1698    {
1699        #[inline]
1700        unsafe fn encode(
1701            self,
1702            encoder: &mut fidl::encoding::Encoder<
1703                '_,
1704                fidl::encoding::DefaultFuchsiaResourceDialect,
1705            >,
1706            offset: usize,
1707            depth: fidl::encoding::Depth,
1708        ) -> fidl::Result<()> {
1709            encoder.debug_check_bounds::<ControllerCreateGuestResponse>(offset);
1710            // Zero out padding regions. There's no need to apply masks
1711            // because the unmasked parts will be overwritten by fields.
1712            // Write the fields.
1713            self.0.encode(encoder, offset + 0, depth)?;
1714            Ok(())
1715        }
1716    }
1717
1718    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1719        for ControllerCreateGuestResponse
1720    {
1721        #[inline(always)]
1722        fn new_empty() -> Self {
1723            Self {
1724                s: fidl::new_empty!(
1725                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<GuestMarker>>,
1726                    fidl::encoding::DefaultFuchsiaResourceDialect
1727                ),
1728            }
1729        }
1730
1731        #[inline]
1732        unsafe fn decode(
1733            &mut self,
1734            decoder: &mut fidl::encoding::Decoder<
1735                '_,
1736                fidl::encoding::DefaultFuchsiaResourceDialect,
1737            >,
1738            offset: usize,
1739            _depth: fidl::encoding::Depth,
1740        ) -> fidl::Result<()> {
1741            decoder.debug_check_bounds::<Self>(offset);
1742            // Verify that padding bytes are zero.
1743            fidl::decode!(
1744                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<GuestMarker>>,
1745                fidl::encoding::DefaultFuchsiaResourceDialect,
1746                &mut self.s,
1747                decoder,
1748                offset + 0,
1749                _depth
1750            )?;
1751            Ok(())
1752        }
1753    }
1754}
fidl_fuchsia_netemul_guest/fidl_fuchsia_netemul_guest.rs

fidl_fuchsia_netemul_guest/
fidl_fuchsia_netemul_guest.rs
