fdomain_fuchsia_net_root/

fdomain_fuchsia_net_root.rs

// WARNING: This file is machine generated by fidlgen.

#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]

use bitflags::bitflags;
use fdomain_client::fidl::{ControlHandle as _, FDomainFlexibleIntoResult as _, Responder as _};
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
pub use fidl_fuchsia_net_root_common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FilterOpenControllerRequest {
    pub id: String,
    pub request:
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_net_filter::NamespaceControllerMarker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for FilterOpenControllerRequest
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct InterfacesGetAdminRequest {
    pub id: u64,
    pub control:
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_net_interfaces_admin::ControlMarker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for InterfacesGetAdminRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RoutesV4GlobalRouteSetRequest {
    pub route_set:
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_net_routes_admin::RouteSetV4Marker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for RoutesV4GlobalRouteSetRequest
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RoutesV6GlobalRouteSetRequest {
    pub route_set:
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_net_routes_admin::RouteSetV6Marker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for RoutesV6GlobalRouteSetRequest
{
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct FilterMarker;

impl fdomain_client::fidl::ProtocolMarker for FilterMarker {
    type Proxy = FilterProxy;
    type RequestStream = FilterRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.net.root.Filter";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for FilterMarker {}

pub trait FilterProxyInterface: Send + Sync {
    fn r#open_controller(
        &self,
        id: &str,
        request: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_net_filter::NamespaceControllerMarker,
        >,
    ) -> Result<(), fidl::Error>;
}

#[derive(Debug, Clone)]
pub struct FilterProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for FilterProxy {
    type Protocol = FilterMarker;

    fn from_channel(inner: fdomain_client::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &fdomain_client::Channel {
        self.client.as_channel()
    }
}

impl FilterProxy {
    /// Create a new Proxy for fuchsia.net.root/Filter.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <FilterMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> FilterEventStream {
        FilterEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Open a new *or* existing `NamespaceController`. The server end is
    /// "auto-detached": in other words, it behaves as if the client has called
    /// `Detach` on creation, and the lifetime of the filtering state is not
    /// tied to the client end of the protocol. If the client does call
    /// `Detach` on the `NamespaceController`, the server will close the
    /// channel.
    ///
    /// Clients have unilateral access to add or remove resources owned by the
    /// controller, irrespective of other clients' ownership. This includes the
    /// ability to remove resources installed by other clients.
    pub fn r#open_controller(
        &self,
        mut id: &str,
        mut request: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_net_filter::NamespaceControllerMarker,
        >,
    ) -> Result<(), fidl::Error> {
        FilterProxyInterface::r#open_controller(self, id, request)
    }
}

impl FilterProxyInterface for FilterProxy {
    fn r#open_controller(
        &self,
        mut id: &str,
        mut request: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_net_filter::NamespaceControllerMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FilterOpenControllerRequest>(
            (id, request),
            0x4f8742ed854ea1d1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct FilterEventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

impl std::marker::Unpin for FilterEventStream {}

impl futures::stream::FusedStream for FilterEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for FilterEventStream {
    type Item = Result<FilterEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(FilterEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum FilterEvent {}

impl FilterEvent {
    /// Decodes a message buffer as a [`FilterEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<FilterEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <FilterMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.net.root/Filter.
pub struct FilterRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for FilterRequestStream {}

impl futures::stream::FusedStream for FilterRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fdomain_client::fidl::RequestStream for FilterRequestStream {
    type Protocol = FilterMarker;
    type ControlHandle = FilterControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        FilterControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for FilterRequestStream {
    type Item = Result<FilterRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled FilterRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x4f8742ed854ea1d1 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FilterOpenControllerRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<FilterOpenControllerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FilterControlHandle { inner: this.inner.clone() };
                        Ok(FilterRequest::OpenController {
                            id: req.id,
                            request: req.request,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <FilterMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Provides administrative access to all filtering state.
///
/// This protocol provides the ability to bypass regular ownership controls
/// which allow only the owner of each controller to modify or remove resources
/// they added.
///
/// Circumventing the strong-ownership semantics through use of this protocol
/// is highly discouraged and applications considering use of this protocol
/// are encouraged to exhaust other options first by working with the Netstack
/// team to find an alternative solution.
#[derive(Debug)]
pub enum FilterRequest {
    /// Open a new *or* existing `NamespaceController`. The server end is
    /// "auto-detached": in other words, it behaves as if the client has called
    /// `Detach` on creation, and the lifetime of the filtering state is not
    /// tied to the client end of the protocol. If the client does call
    /// `Detach` on the `NamespaceController`, the server will close the
    /// channel.
    ///
    /// Clients have unilateral access to add or remove resources owned by the
    /// controller, irrespective of other clients' ownership. This includes the
    /// ability to remove resources installed by other clients.
    OpenController {
        id: String,
        request:
            fdomain_client::fidl::ServerEnd<fdomain_fuchsia_net_filter::NamespaceControllerMarker>,
        control_handle: FilterControlHandle,
    },
}

impl FilterRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_open_controller(
        self,
    ) -> Option<(
        String,
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_net_filter::NamespaceControllerMarker>,
        FilterControlHandle,
    )> {
        if let FilterRequest::OpenController { id, request, control_handle } = self {
            Some((id, request, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            FilterRequest::OpenController { .. } => "open_controller",
        }
    }
}

#[derive(Debug, Clone)]
pub struct FilterControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
}

impl fdomain_client::fidl::ControlHandle for FilterControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl FilterControlHandle {}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct InterfacesMarker;

impl fdomain_client::fidl::ProtocolMarker for InterfacesMarker {
    type Proxy = InterfacesProxy;
    type RequestStream = InterfacesRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.net.root.Interfaces";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for InterfacesMarker {}
pub type InterfacesGetMacResult =
    Result<Option<Box<fdomain_fuchsia_net::MacAddress>>, InterfacesGetMacError>;

pub trait InterfacesProxyInterface: Send + Sync {
    fn r#get_admin(
        &self,
        id: u64,
        control: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_net_interfaces_admin::ControlMarker,
        >,
    ) -> Result<(), fidl::Error>;
    type GetMacResponseFut: std::future::Future<Output = Result<InterfacesGetMacResult, fidl::Error>>
        + Send;
    fn r#get_mac(&self, id: u64) -> Self::GetMacResponseFut;
}

#[derive(Debug, Clone)]
pub struct InterfacesProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for InterfacesProxy {
    type Protocol = InterfacesMarker;

    fn from_channel(inner: fdomain_client::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &fdomain_client::Channel {
        self.client.as_channel()
    }
}

impl InterfacesProxy {
    /// Create a new Proxy for fuchsia.net.root/Interfaces.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <InterfacesMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> InterfacesEventStream {
        InterfacesEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Obtain administrative control over a network interface.
    ///
    /// + request `id` identifies the interface to be controlled.
    /// + request `control` grants the client administrative control over
    ///     the interface. Closed without a terminal event if `id` does not
    ///     match an existing interface.
    pub fn r#get_admin(
        &self,
        mut id: u64,
        mut control: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_net_interfaces_admin::ControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        InterfacesProxyInterface::r#get_admin(self, id, control)
    }

    /// Return an interface's MAC address.
    ///
    /// + request `id` identifies the interface whose MAC is requested.
    /// - response `mac` is the interface's MAC address, if it has one.
    pub fn r#get_mac(
        &self,
        mut id: u64,
    ) -> fidl::client::QueryResponseFut<
        InterfacesGetMacResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        InterfacesProxyInterface::r#get_mac(self, id)
    }
}

impl InterfacesProxyInterface for InterfacesProxy {
    fn r#get_admin(
        &self,
        mut id: u64,
        mut control: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_net_interfaces_admin::ControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<InterfacesGetAdminRequest>(
            (id, control),
            0x3cdcbf2452babedd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetMacResponseFut = fidl::client::QueryResponseFut<
        InterfacesGetMacResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_mac(&self, mut id: u64) -> Self::GetMacResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<InterfacesGetMacResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<InterfacesGetMacResponse, InterfacesGetMacError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x720643bc62a26d61,
            >(_buf?)?;
            Ok(_response.map(|x| x.mac))
        }
        self.client.send_query_and_decode::<InterfacesGetMacRequest, InterfacesGetMacResult>(
            (id,),
            0x720643bc62a26d61,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct InterfacesEventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

impl std::marker::Unpin for InterfacesEventStream {}

impl futures::stream::FusedStream for InterfacesEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for InterfacesEventStream {
    type Item = Result<InterfacesEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(InterfacesEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum InterfacesEvent {}

impl InterfacesEvent {
    /// Decodes a message buffer as a [`InterfacesEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<InterfacesEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <InterfacesMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.net.root/Interfaces.
pub struct InterfacesRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for InterfacesRequestStream {}

impl futures::stream::FusedStream for InterfacesRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fdomain_client::fidl::RequestStream for InterfacesRequestStream {
    type Protocol = InterfacesMarker;
    type ControlHandle = InterfacesControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        InterfacesControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for InterfacesRequestStream {
    type Item = Result<InterfacesRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled InterfacesRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x3cdcbf2452babedd => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            InterfacesGetAdminRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<InterfacesGetAdminRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = InterfacesControlHandle { inner: this.inner.clone() };
                        Ok(InterfacesRequest::GetAdmin {
                            id: req.id,
                            control: req.control,

                            control_handle,
                        })
                    }
                    0x720643bc62a26d61 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            InterfacesGetMacRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<InterfacesGetMacRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = InterfacesControlHandle { inner: this.inner.clone() };
                        Ok(InterfacesRequest::GetMac {
                            id: req.id,

                            responder: InterfacesGetMacResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <InterfacesMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Provides access to installed network interfaces.
///
/// This protocol provides the ability to bypass regular ownership-controls
/// which allow only the interface owner (generally the entity installing the
/// interface) to perform management operations on an interface.
///
/// Circumventing the strong-ownership semantics through use of this protocol
/// is highly discouraged and applications considering use of this protocol
/// are encouraged to exhaust other options first by working with the Netstack
/// team to find an alternative solution.
#[derive(Debug)]
pub enum InterfacesRequest {
    /// Obtain administrative control over a network interface.
    ///
    /// + request `id` identifies the interface to be controlled.
    /// + request `control` grants the client administrative control over
    ///     the interface. Closed without a terminal event if `id` does not
    ///     match an existing interface.
    GetAdmin {
        id: u64,
        control:
            fdomain_client::fidl::ServerEnd<fdomain_fuchsia_net_interfaces_admin::ControlMarker>,
        control_handle: InterfacesControlHandle,
    },
    /// Return an interface's MAC address.
    ///
    /// + request `id` identifies the interface whose MAC is requested.
    /// - response `mac` is the interface's MAC address, if it has one.
    GetMac { id: u64, responder: InterfacesGetMacResponder },
}

impl InterfacesRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_admin(
        self,
    ) -> Option<(
        u64,
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_net_interfaces_admin::ControlMarker>,
        InterfacesControlHandle,
    )> {
        if let InterfacesRequest::GetAdmin { id, control, control_handle } = self {
            Some((id, control, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_mac(self) -> Option<(u64, InterfacesGetMacResponder)> {
        if let InterfacesRequest::GetMac { id, responder } = self {
            Some((id, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            InterfacesRequest::GetAdmin { .. } => "get_admin",
            InterfacesRequest::GetMac { .. } => "get_mac",
        }
    }
}

#[derive(Debug, Clone)]
pub struct InterfacesControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
}

impl fdomain_client::fidl::ControlHandle for InterfacesControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl InterfacesControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct InterfacesGetMacResponder {
    control_handle: std::mem::ManuallyDrop<InterfacesControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`InterfacesControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for InterfacesGetMacResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for InterfacesGetMacResponder {
    type ControlHandle = InterfacesControlHandle;

    fn control_handle(&self) -> &InterfacesControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl InterfacesGetMacResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<Option<&fdomain_fuchsia_net::MacAddress>, InterfacesGetMacError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<Option<&fdomain_fuchsia_net::MacAddress>, InterfacesGetMacError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<Option<&fdomain_fuchsia_net::MacAddress>, InterfacesGetMacError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            InterfacesGetMacResponse,
            InterfacesGetMacError,
        >>(
            result.map(|mac| (mac,)),
            self.tx_id,
            0x720643bc62a26d61,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct RoutesV4Marker;

impl fdomain_client::fidl::ProtocolMarker for RoutesV4Marker {
    type Proxy = RoutesV4Proxy;
    type RequestStream = RoutesV4RequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.net.root.RoutesV4";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for RoutesV4Marker {}

pub trait RoutesV4ProxyInterface: Send + Sync {
    fn r#global_route_set(
        &self,
        route_set: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_net_routes_admin::RouteSetV4Marker,
        >,
    ) -> Result<(), fidl::Error>;
}

#[derive(Debug, Clone)]
pub struct RoutesV4Proxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for RoutesV4Proxy {
    type Protocol = RoutesV4Marker;

    fn from_channel(inner: fdomain_client::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &fdomain_client::Channel {
        self.client.as_channel()
    }
}

impl RoutesV4Proxy {
    /// Create a new Proxy for fuchsia.net.root/RoutesV4.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <RoutesV4Marker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> RoutesV4EventStream {
        RoutesV4EventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns a `RouteSetV4` containing all IPv4 routes from the global
    /// routing table. Clients have unilateral access to add or remove routes
    /// from the set. This includes the ability to remove routes installed by
    /// the system, or routes installed by other clients of the `RouteSetV4`
    /// protocol.
    ///
    /// Note that the established connection to the `RouteSetV4` protocol will
    /// have a few notable differences from a `RouteSetV4` obtained by
    /// [`fuchsia.net.routes.admin/RouteTableV4.NewRouteSet`]:
    ///   - When removing a route from this route set, the route will be
    ///     completely removed from the system, including removal from all other
    ///     route sets to which it belongs.
    ///   - The protocol does not encode the lifetime of the route set or its
    ///     routes. Closing the client end will not cause the routes within this
    ///     route set to be removed from the system. Thus, routes added via this
    ///     route set will effectively be abandoned/unowned after this
    ///     client-end closes.
    ///
    /// + request `route set` grants access to the `RouteSetV4` protocol.
    pub fn r#global_route_set(
        &self,
        mut route_set: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_net_routes_admin::RouteSetV4Marker,
        >,
    ) -> Result<(), fidl::Error> {
        RoutesV4ProxyInterface::r#global_route_set(self, route_set)
    }
}

impl RoutesV4ProxyInterface for RoutesV4Proxy {
    fn r#global_route_set(
        &self,
        mut route_set: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_net_routes_admin::RouteSetV4Marker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<RoutesV4GlobalRouteSetRequest>(
            (route_set,),
            0x3c0b279c61d81812,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct RoutesV4EventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

impl std::marker::Unpin for RoutesV4EventStream {}

impl futures::stream::FusedStream for RoutesV4EventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for RoutesV4EventStream {
    type Item = Result<RoutesV4Event, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(RoutesV4Event::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum RoutesV4Event {}

impl RoutesV4Event {
    /// Decodes a message buffer as a [`RoutesV4Event`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<RoutesV4Event, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <RoutesV4Marker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.net.root/RoutesV4.
pub struct RoutesV4RequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for RoutesV4RequestStream {}

impl futures::stream::FusedStream for RoutesV4RequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fdomain_client::fidl::RequestStream for RoutesV4RequestStream {
    type Protocol = RoutesV4Marker;
    type ControlHandle = RoutesV4ControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        RoutesV4ControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for RoutesV4RequestStream {
    type Item = Result<RoutesV4Request, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled RoutesV4RequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x3c0b279c61d81812 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            RoutesV4GlobalRouteSetRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RoutesV4GlobalRouteSetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RoutesV4ControlHandle { inner: this.inner.clone() };
                        Ok(RoutesV4Request::GlobalRouteSet {
                            route_set: req.route_set,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <RoutesV4Marker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Provides access to IPv4 routes.
///
/// This protocol provides the ability to bypass regular ownership-controls
/// which allow only the route set owner to remove routes it added.
///
/// Circumventing the strong-ownership semantics through use of this protocol
/// is highly discouraged and applications considering use of this protocol
/// are encouraged to exhaust other options first by working with the Netstack
/// team to find an alternative solution.
#[derive(Debug)]
pub enum RoutesV4Request {
    /// Returns a `RouteSetV4` containing all IPv4 routes from the global
    /// routing table. Clients have unilateral access to add or remove routes
    /// from the set. This includes the ability to remove routes installed by
    /// the system, or routes installed by other clients of the `RouteSetV4`
    /// protocol.
    ///
    /// Note that the established connection to the `RouteSetV4` protocol will
    /// have a few notable differences from a `RouteSetV4` obtained by
    /// [`fuchsia.net.routes.admin/RouteTableV4.NewRouteSet`]:
    ///   - When removing a route from this route set, the route will be
    ///     completely removed from the system, including removal from all other
    ///     route sets to which it belongs.
    ///   - The protocol does not encode the lifetime of the route set or its
    ///     routes. Closing the client end will not cause the routes within this
    ///     route set to be removed from the system. Thus, routes added via this
    ///     route set will effectively be abandoned/unowned after this
    ///     client-end closes.
    ///
    /// + request `route set` grants access to the `RouteSetV4` protocol.
    GlobalRouteSet {
        route_set:
            fdomain_client::fidl::ServerEnd<fdomain_fuchsia_net_routes_admin::RouteSetV4Marker>,
        control_handle: RoutesV4ControlHandle,
    },
}

impl RoutesV4Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_global_route_set(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_net_routes_admin::RouteSetV4Marker>,
        RoutesV4ControlHandle,
    )> {
        if let RoutesV4Request::GlobalRouteSet { route_set, control_handle } = self {
            Some((route_set, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RoutesV4Request::GlobalRouteSet { .. } => "global_route_set",
        }
    }
}

#[derive(Debug, Clone)]
pub struct RoutesV4ControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
}

impl fdomain_client::fidl::ControlHandle for RoutesV4ControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl RoutesV4ControlHandle {}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct RoutesV6Marker;

impl fdomain_client::fidl::ProtocolMarker for RoutesV6Marker {
    type Proxy = RoutesV6Proxy;
    type RequestStream = RoutesV6RequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.net.root.RoutesV6";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for RoutesV6Marker {}

pub trait RoutesV6ProxyInterface: Send + Sync {
    fn r#global_route_set(
        &self,
        route_set: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_net_routes_admin::RouteSetV6Marker,
        >,
    ) -> Result<(), fidl::Error>;
}

#[derive(Debug, Clone)]
pub struct RoutesV6Proxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for RoutesV6Proxy {
    type Protocol = RoutesV6Marker;

    fn from_channel(inner: fdomain_client::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &fdomain_client::Channel {
        self.client.as_channel()
    }
}

impl RoutesV6Proxy {
    /// Create a new Proxy for fuchsia.net.root/RoutesV6.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <RoutesV6Marker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> RoutesV6EventStream {
        RoutesV6EventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns a `RouteSetV6` containing all IPv6 routes from the global
    /// routing table. Clients have unilateral access to add or remove routes
    /// from the set. This includes the ability to remove routes installed by
    /// the system, or routes installed by other clients of the `RouteSetV6`
    /// protocol.
    ///
    /// Note that the established connection to the `RouteSetV6` protocol will
    /// have a few notable differences from a `RouteSetV6` obtained by
    /// [`fuchsia.net.routes.admin/RouteTableV6.NewRouteSet`]:
    ///   - When removing a route from this route set, the route will be
    ///     completely removed from the system, including removal from all other
    ///     route sets to which it belongs.
    ///   - The protocol does not encode the lifetime of the route set or its
    ///     routes. Closing the client end will not cause the routes within this
    ///     route set to be removed from the system. Thus, routes added via this
    ///     route set will effectively be abandoned/unowned after this
    ///     client-end closes.
    ///
    /// + request `route set` grants access to the `RouteSetV6` protocol.
    pub fn r#global_route_set(
        &self,
        mut route_set: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_net_routes_admin::RouteSetV6Marker,
        >,
    ) -> Result<(), fidl::Error> {
        RoutesV6ProxyInterface::r#global_route_set(self, route_set)
    }
}

impl RoutesV6ProxyInterface for RoutesV6Proxy {
    fn r#global_route_set(
        &self,
        mut route_set: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_net_routes_admin::RouteSetV6Marker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<RoutesV6GlobalRouteSetRequest>(
            (route_set,),
            0x41336f581f8d6a61,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct RoutesV6EventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

impl std::marker::Unpin for RoutesV6EventStream {}

impl futures::stream::FusedStream for RoutesV6EventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for RoutesV6EventStream {
    type Item = Result<RoutesV6Event, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(RoutesV6Event::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum RoutesV6Event {}

impl RoutesV6Event {
    /// Decodes a message buffer as a [`RoutesV6Event`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<RoutesV6Event, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <RoutesV6Marker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.net.root/RoutesV6.
pub struct RoutesV6RequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for RoutesV6RequestStream {}

impl futures::stream::FusedStream for RoutesV6RequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fdomain_client::fidl::RequestStream for RoutesV6RequestStream {
    type Protocol = RoutesV6Marker;
    type ControlHandle = RoutesV6ControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        RoutesV6ControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for RoutesV6RequestStream {
    type Item = Result<RoutesV6Request, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled RoutesV6RequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x41336f581f8d6a61 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            RoutesV6GlobalRouteSetRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RoutesV6GlobalRouteSetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RoutesV6ControlHandle { inner: this.inner.clone() };
                        Ok(RoutesV6Request::GlobalRouteSet {
                            route_set: req.route_set,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <RoutesV6Marker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Provides access to IPv6 routes.
///
/// This protocol provides the ability to bypass regular ownership-controls
/// which allow only the route set owner to remove routes it added.
///
/// Circumventing the strong-ownership semantics through use of this protocol
/// is highly discouraged and applications considering use of this protocol
/// are encouraged to exhaust other options first by working with the Netstack
/// team to find an alternative solution.
#[derive(Debug)]
pub enum RoutesV6Request {
    /// Returns a `RouteSetV6` containing all IPv6 routes from the global
    /// routing table. Clients have unilateral access to add or remove routes
    /// from the set. This includes the ability to remove routes installed by
    /// the system, or routes installed by other clients of the `RouteSetV6`
    /// protocol.
    ///
    /// Note that the established connection to the `RouteSetV6` protocol will
    /// have a few notable differences from a `RouteSetV6` obtained by
    /// [`fuchsia.net.routes.admin/RouteTableV6.NewRouteSet`]:
    ///   - When removing a route from this route set, the route will be
    ///     completely removed from the system, including removal from all other
    ///     route sets to which it belongs.
    ///   - The protocol does not encode the lifetime of the route set or its
    ///     routes. Closing the client end will not cause the routes within this
    ///     route set to be removed from the system. Thus, routes added via this
    ///     route set will effectively be abandoned/unowned after this
    ///     client-end closes.
    ///
    /// + request `route set` grants access to the `RouteSetV6` protocol.
    GlobalRouteSet {
        route_set:
            fdomain_client::fidl::ServerEnd<fdomain_fuchsia_net_routes_admin::RouteSetV6Marker>,
        control_handle: RoutesV6ControlHandle,
    },
}

impl RoutesV6Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_global_route_set(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_net_routes_admin::RouteSetV6Marker>,
        RoutesV6ControlHandle,
    )> {
        if let RoutesV6Request::GlobalRouteSet { route_set, control_handle } = self {
            Some((route_set, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RoutesV6Request::GlobalRouteSet { .. } => "global_route_set",
        }
    }
}

#[derive(Debug, Clone)]
pub struct RoutesV6ControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
}

impl fdomain_client::fidl::ControlHandle for RoutesV6ControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl RoutesV6ControlHandle {}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for FilterOpenControllerRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FilterOpenControllerRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            24
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            FilterOpenControllerRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut FilterOpenControllerRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FilterOpenControllerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FilterOpenControllerRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.id,
                    ),
                    <fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<
                            fdomain_fuchsia_net_filter::NamespaceControllerMarker,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.request
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<
                        fdomain_fuchsia_net_filter::NamespaceControllerMarker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            FilterOpenControllerRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FilterOpenControllerRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for FilterOpenControllerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                id: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                request: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<
                            fdomain_fuchsia_net_filter::NamespaceControllerMarker,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<
                        fdomain_fuchsia_net_filter::NamespaceControllerMarker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.request,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for InterfacesGetAdminRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for InterfacesGetAdminRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            InterfacesGetAdminRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut InterfacesGetAdminRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<InterfacesGetAdminRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                InterfacesGetAdminRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
                    <fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<
                            fdomain_fuchsia_net_interfaces_admin::ControlMarker,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.control
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u64, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<
                        fdomain_fuchsia_net_interfaces_admin::ControlMarker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            InterfacesGetAdminRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<InterfacesGetAdminRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for InterfacesGetAdminRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                id: fidl::new_empty!(u64, fdomain_client::fidl::FDomainResourceDialect),
                control: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<
                            fdomain_fuchsia_net_interfaces_admin::ControlMarker,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                u64,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<
                        fdomain_fuchsia_net_interfaces_admin::ControlMarker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.control,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RoutesV4GlobalRouteSetRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for RoutesV4GlobalRouteSetRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            RoutesV4GlobalRouteSetRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RoutesV4GlobalRouteSetRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RoutesV4GlobalRouteSetRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                RoutesV4GlobalRouteSetRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<
                        fdomain_fuchsia_net_routes_admin::RouteSetV4Marker,
                    >,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.route_set
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<
                        fdomain_fuchsia_net_routes_admin::RouteSetV4Marker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RoutesV4GlobalRouteSetRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RoutesV4GlobalRouteSetRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RoutesV4GlobalRouteSetRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                route_set: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<
                            fdomain_fuchsia_net_routes_admin::RouteSetV4Marker,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<
                        fdomain_fuchsia_net_routes_admin::RouteSetV4Marker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.route_set,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RoutesV6GlobalRouteSetRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for RoutesV6GlobalRouteSetRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            RoutesV6GlobalRouteSetRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RoutesV6GlobalRouteSetRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RoutesV6GlobalRouteSetRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                RoutesV6GlobalRouteSetRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<
                        fdomain_fuchsia_net_routes_admin::RouteSetV6Marker,
                    >,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.route_set
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<
                        fdomain_fuchsia_net_routes_admin::RouteSetV6Marker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RoutesV6GlobalRouteSetRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RoutesV6GlobalRouteSetRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RoutesV6GlobalRouteSetRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                route_set: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<
                            fdomain_fuchsia_net_routes_admin::RouteSetV6Marker,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<
                        fdomain_fuchsia_net_routes_admin::RouteSetV6Marker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.route_set,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }
}