#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
use {
bitflags::bitflags,
fidl::{
client::QueryResponseFut,
endpoints::{ControlHandle as _, Responder as _},
},
fuchsia_zircon_status as zx_status,
futures::future::{self, MaybeDone, TryFutureExt},
};
#[cfg(target_os = "fuchsia")]
use fuchsia_zircon as zx;
pub const MAX_RULES: u32 = 128;
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum Action {
Pass = 0,
Drop = 1,
DropReset = 2,
}
impl Action {
#[inline]
pub fn from_primitive(prim: u32) -> Option<Self> {
match prim {
0 => Some(Self::Pass),
1 => Some(Self::Drop),
2 => Some(Self::DropReset),
_ => None,
}
}
#[inline]
pub const fn into_primitive(self) -> u32 {
self as u32
}
#[deprecated = "Strict enums should not use `is_unknown`"]
#[inline]
pub fn is_unknown(&self) -> bool {
false
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum Direction {
Incoming = 0,
Outgoing = 1,
}
impl Direction {
#[inline]
pub fn from_primitive(prim: u32) -> Option<Self> {
match prim {
0 => Some(Self::Incoming),
1 => Some(Self::Outgoing),
_ => None,
}
}
#[inline]
pub const fn into_primitive(self) -> u32 {
self as u32
}
#[deprecated = "Strict enums should not use `is_unknown`"]
#[inline]
pub fn is_unknown(&self) -> bool {
false
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum EnableDisableInterfaceError {
NotFound = 1,
}
impl EnableDisableInterfaceError {
#[inline]
pub fn from_primitive(prim: u32) -> Option<Self> {
match prim {
1 => Some(Self::NotFound),
_ => None,
}
}
#[inline]
pub const fn into_primitive(self) -> u32 {
self as u32
}
#[deprecated = "Strict enums should not use `is_unknown`"]
#[inline]
pub fn is_unknown(&self) -> bool {
false
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum FilterUpdateNatRulesError {
GenerationMismatch = 1,
BadRule = 2,
}
impl FilterUpdateNatRulesError {
#[inline]
pub fn from_primitive(prim: u32) -> Option<Self> {
match prim {
1 => Some(Self::GenerationMismatch),
2 => Some(Self::BadRule),
_ => None,
}
}
#[inline]
pub const fn into_primitive(self) -> u32 {
self as u32
}
#[deprecated = "Strict enums should not use `is_unknown`"]
#[inline]
pub fn is_unknown(&self) -> bool {
false
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum FilterUpdateRdrRulesError {
NotSupported = 1,
}
impl FilterUpdateRdrRulesError {
#[inline]
pub fn from_primitive(prim: u32) -> Option<Self> {
match prim {
1 => Some(Self::NotSupported),
_ => None,
}
}
#[inline]
pub const fn into_primitive(self) -> u32 {
self as u32
}
#[deprecated = "Strict enums should not use `is_unknown`"]
#[inline]
pub fn is_unknown(&self) -> bool {
false
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum FilterUpdateRulesError {
GenerationMismatch = 1,
BadRule = 2,
}
impl FilterUpdateRulesError {
#[inline]
pub fn from_primitive(prim: u32) -> Option<Self> {
match prim {
1 => Some(Self::GenerationMismatch),
2 => Some(Self::BadRule),
_ => None,
}
}
#[inline]
pub const fn into_primitive(self) -> u32 {
self as u32
}
#[deprecated = "Strict enums should not use `is_unknown`"]
#[inline]
pub fn is_unknown(&self) -> bool {
false
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum SocketProtocol {
Any = 0,
Icmp = 1,
Tcp = 2,
Udp = 3,
Icmpv6 = 4,
}
impl SocketProtocol {
#[inline]
pub fn from_primitive(prim: u32) -> Option<Self> {
match prim {
0 => Some(Self::Any),
1 => Some(Self::Icmp),
2 => Some(Self::Tcp),
3 => Some(Self::Udp),
4 => Some(Self::Icmpv6),
_ => None,
}
}
#[inline]
pub const fn into_primitive(self) -> u32 {
self as u32
}
#[deprecated = "Strict enums should not use `is_unknown`"]
#[inline]
pub fn is_unknown(&self) -> bool {
false
}
}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Empty;
impl fidl::Persistable for Empty {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FilterDisableInterfaceRequest {
pub id: u64,
}
impl fidl::Persistable for FilterDisableInterfaceRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FilterEnableInterfaceRequest {
pub id: u64,
}
impl fidl::Persistable for FilterEnableInterfaceRequest {}
#[derive(Clone, Debug, PartialEq)]
pub struct FilterGetNatRulesResponse {
pub rules: Vec<Nat>,
pub generation: u32,
}
impl fidl::Persistable for FilterGetNatRulesResponse {}
#[derive(Clone, Debug, PartialEq)]
pub struct FilterGetRdrRulesResponse {
pub rules: Vec<Rdr>,
pub generation: u32,
}
impl fidl::Persistable for FilterGetRdrRulesResponse {}
#[derive(Clone, Debug, PartialEq)]
pub struct FilterGetRulesResponse {
pub rules: Vec<Rule>,
pub generation: u32,
}
impl fidl::Persistable for FilterGetRulesResponse {}
#[derive(Clone, Debug, PartialEq)]
pub struct FilterUpdateNatRulesRequest {
pub rules: Vec<Nat>,
pub generation: u32,
}
impl fidl::Persistable for FilterUpdateNatRulesRequest {}
#[derive(Clone, Debug, PartialEq)]
pub struct FilterUpdateRdrRulesRequest {
pub rules: Vec<Rdr>,
pub generation: u32,
}
impl fidl::Persistable for FilterUpdateRdrRulesRequest {}
#[derive(Clone, Debug, PartialEq)]
pub struct FilterUpdateRulesRequest {
pub rules: Vec<Rule>,
pub generation: u32,
}
impl fidl::Persistable for FilterUpdateRulesRequest {}
#[derive(Clone, Debug, PartialEq)]
pub struct Nat {
pub proto: SocketProtocol,
pub src_subnet: fidl_fuchsia_net::Subnet,
pub outgoing_nic: u32,
}
impl fidl::Persistable for Nat {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct PortRange {
pub start: u16,
pub end: u16,
}
impl fidl::Persistable for PortRange {}
#[derive(Clone, Debug, PartialEq)]
pub struct Rdr {
pub proto: SocketProtocol,
pub dst_addr: fidl_fuchsia_net::IpAddress,
pub dst_port_range: PortRange,
pub new_dst_addr: fidl_fuchsia_net::IpAddress,
pub new_dst_port_range: PortRange,
pub nic: u32,
}
impl fidl::Persistable for Rdr {}
#[derive(Clone, Debug, PartialEq)]
pub struct Rule {
pub action: Action,
pub direction: Direction,
pub proto: SocketProtocol,
pub src_subnet: Option<Box<fidl_fuchsia_net::Subnet>>,
pub src_subnet_invert_match: bool,
pub src_port_range: PortRange,
pub dst_subnet: Option<Box<fidl_fuchsia_net::Subnet>>,
pub dst_subnet_invert_match: bool,
pub dst_port_range: PortRange,
pub nic: u32,
pub log: bool,
pub keep_state: bool,
pub device_class: DeviceClass,
}
impl fidl::Persistable for Rule {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum DeviceClass {
Any(Empty),
Match_(fidl_fuchsia_hardware_network::DeviceClass),
}
impl DeviceClass {
#[inline]
pub fn ordinal(&self) -> u64 {
match *self {
Self::Any(_) => 1,
Self::Match_(_) => 2,
}
}
#[deprecated = "Strict unions should not use `is_unknown`"]
#[inline]
pub fn is_unknown(&self) -> bool {
false
}
}
impl fidl::Persistable for DeviceClass {}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct FilterMarker;
impl fidl::endpoints::ProtocolMarker for FilterMarker {
type Proxy = FilterProxy;
type RequestStream = FilterRequestStream;
#[cfg(target_os = "fuchsia")]
type SynchronousProxy = FilterSynchronousProxy;
const DEBUG_NAME: &'static str = "fuchsia.net.filter.deprecated.Filter";
}
impl fidl::endpoints::DiscoverableProtocolMarker for FilterMarker {}
pub type FilterEnableInterfaceResult = Result<(), EnableDisableInterfaceError>;
pub type FilterDisableInterfaceResult = Result<(), EnableDisableInterfaceError>;
pub type FilterUpdateRulesResult = Result<(), FilterUpdateRulesError>;
pub type FilterUpdateNatRulesResult = Result<(), FilterUpdateNatRulesError>;
pub type FilterUpdateRdrRulesResult = Result<(), FilterUpdateRdrRulesError>;
pub trait FilterProxyInterface: Send + Sync {
type EnableInterfaceResponseFut: std::future::Future<Output = Result<FilterEnableInterfaceResult, fidl::Error>>
+ Send;
fn r#enable_interface(&self, id: u64) -> Self::EnableInterfaceResponseFut;
type DisableInterfaceResponseFut: std::future::Future<Output = Result<FilterDisableInterfaceResult, fidl::Error>>
+ Send;
fn r#disable_interface(&self, id: u64) -> Self::DisableInterfaceResponseFut;
type GetRulesResponseFut: std::future::Future<Output = Result<(Vec<Rule>, u32), fidl::Error>>
+ Send;
fn r#get_rules(&self) -> Self::GetRulesResponseFut;
type UpdateRulesResponseFut: std::future::Future<Output = Result<FilterUpdateRulesResult, fidl::Error>>
+ Send;
fn r#update_rules(&self, rules: &[Rule], generation: u32) -> Self::UpdateRulesResponseFut;
type GetNatRulesResponseFut: std::future::Future<Output = Result<(Vec<Nat>, u32), fidl::Error>>
+ Send;
fn r#get_nat_rules(&self) -> Self::GetNatRulesResponseFut;
type UpdateNatRulesResponseFut: std::future::Future<Output = Result<FilterUpdateNatRulesResult, fidl::Error>>
+ Send;
fn r#update_nat_rules(&self, rules: &[Nat], generation: u32)
-> Self::UpdateNatRulesResponseFut;
type GetRdrRulesResponseFut: std::future::Future<Output = Result<(Vec<Rdr>, u32), fidl::Error>>
+ Send;
fn r#get_rdr_rules(&self) -> Self::GetRdrRulesResponseFut;
type UpdateRdrRulesResponseFut: std::future::Future<Output = Result<FilterUpdateRdrRulesResult, fidl::Error>>
+ Send;
fn r#update_rdr_rules(&self, rules: &[Rdr], generation: u32)
-> Self::UpdateRdrRulesResponseFut;
type CheckPresenceResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#check_presence(&self) -> Self::CheckPresenceResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct FilterSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for FilterSynchronousProxy {
type Proxy = FilterProxy;
type Protocol = FilterMarker;
fn from_channel(inner: fidl::Channel) -> Self {
Self::new(inner)
}
fn into_channel(self) -> fidl::Channel {
self.client.into_channel()
}
fn as_channel(&self) -> &fidl::Channel {
self.client.as_channel()
}
}
#[cfg(target_os = "fuchsia")]
impl FilterSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name = <FilterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
}
pub fn into_channel(self) -> fidl::Channel {
self.client.into_channel()
}
pub fn wait_for_event(&self, deadline: zx::Time) -> Result<FilterEvent, fidl::Error> {
FilterEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#enable_interface(
&self,
mut id: u64,
___deadline: zx::Time,
) -> Result<FilterEnableInterfaceResult, fidl::Error> {
let _response =
self.client.send_query::<FilterEnableInterfaceRequest, fidl::encoding::ResultType<
fidl::encoding::EmptyStruct,
EnableDisableInterfaceError,
>>(
(id,),
0xbf4c680f4001075,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x))
}
pub fn r#disable_interface(
&self,
mut id: u64,
___deadline: zx::Time,
) -> Result<FilterDisableInterfaceResult, fidl::Error> {
let _response =
self.client.send_query::<FilterDisableInterfaceRequest, fidl::encoding::ResultType<
fidl::encoding::EmptyStruct,
EnableDisableInterfaceError,
>>(
(id,),
0x30d2e0e00378a294,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x))
}
pub fn r#get_rules(&self, ___deadline: zx::Time) -> Result<(Vec<Rule>, u32), fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, FilterGetRulesResponse>(
(),
0x284ee4bab557a949,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok((_response.rules, _response.generation))
}
pub fn r#update_rules(
&self,
mut rules: &[Rule],
mut generation: u32,
___deadline: zx::Time,
) -> Result<FilterUpdateRulesResult, fidl::Error> {
let _response =
self.client.send_query::<FilterUpdateRulesRequest, fidl::encoding::ResultType<
fidl::encoding::EmptyStruct,
FilterUpdateRulesError,
>>(
(rules, generation),
0x32181f0bf9bb9a07,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x))
}
pub fn r#get_nat_rules(&self, ___deadline: zx::Time) -> Result<(Vec<Nat>, u32), fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, FilterGetNatRulesResponse>(
(),
0x5d61f46aabe0443b,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok((_response.rules, _response.generation))
}
pub fn r#update_nat_rules(
&self,
mut rules: &[Nat],
mut generation: u32,
___deadline: zx::Time,
) -> Result<FilterUpdateNatRulesResult, fidl::Error> {
let _response =
self.client.send_query::<FilterUpdateNatRulesRequest, fidl::encoding::ResultType<
fidl::encoding::EmptyStruct,
FilterUpdateNatRulesError,
>>(
(rules, generation),
0x1711b0f7d45a2ce2,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x))
}
pub fn r#get_rdr_rules(&self, ___deadline: zx::Time) -> Result<(Vec<Rdr>, u32), fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, FilterGetRdrRulesResponse>(
(),
0x10c953b9ce96e5ed,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok((_response.rules, _response.generation))
}
pub fn r#update_rdr_rules(
&self,
mut rules: &[Rdr],
mut generation: u32,
___deadline: zx::Time,
) -> Result<FilterUpdateRdrRulesResult, fidl::Error> {
let _response =
self.client.send_query::<FilterUpdateRdrRulesRequest, fidl::encoding::ResultType<
fidl::encoding::EmptyStruct,
FilterUpdateRdrRulesError,
>>(
(rules, generation),
0x640119eed9f46c55,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x))
}
pub fn r#check_presence(&self, ___deadline: zx::Time) -> Result<(), fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
(),
0x5b2e2293c3aa2942,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
}
#[derive(Debug, Clone)]
pub struct FilterProxy {
client: fidl::client::Client,
}
impl fidl::endpoints::Proxy for FilterProxy {
type Protocol = FilterMarker;
fn from_channel(inner: fidl::AsyncChannel) -> Self {
Self::new(inner)
}
fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
self.client.into_channel().map_err(|client| Self { client })
}
fn as_channel(&self) -> &::fidl::AsyncChannel {
self.client.as_channel()
}
}
impl FilterProxy {
pub fn new(channel: fidl::AsyncChannel) -> Self {
let protocol_name = <FilterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
pub fn take_event_stream(&self) -> FilterEventStream {
FilterEventStream { event_receiver: self.client.take_event_receiver() }
}
pub fn r#enable_interface(
&self,
mut id: u64,
) -> fidl::client::QueryResponseFut<FilterEnableInterfaceResult> {
FilterProxyInterface::r#enable_interface(self, id)
}
pub fn r#disable_interface(
&self,
mut id: u64,
) -> fidl::client::QueryResponseFut<FilterDisableInterfaceResult> {
FilterProxyInterface::r#disable_interface(self, id)
}
pub fn r#get_rules(&self) -> fidl::client::QueryResponseFut<(Vec<Rule>, u32)> {
FilterProxyInterface::r#get_rules(self)
}
pub fn r#update_rules(
&self,
mut rules: &[Rule],
mut generation: u32,
) -> fidl::client::QueryResponseFut<FilterUpdateRulesResult> {
FilterProxyInterface::r#update_rules(self, rules, generation)
}
pub fn r#get_nat_rules(&self) -> fidl::client::QueryResponseFut<(Vec<Nat>, u32)> {
FilterProxyInterface::r#get_nat_rules(self)
}
pub fn r#update_nat_rules(
&self,
mut rules: &[Nat],
mut generation: u32,
) -> fidl::client::QueryResponseFut<FilterUpdateNatRulesResult> {
FilterProxyInterface::r#update_nat_rules(self, rules, generation)
}
pub fn r#get_rdr_rules(&self) -> fidl::client::QueryResponseFut<(Vec<Rdr>, u32)> {
FilterProxyInterface::r#get_rdr_rules(self)
}
pub fn r#update_rdr_rules(
&self,
mut rules: &[Rdr],
mut generation: u32,
) -> fidl::client::QueryResponseFut<FilterUpdateRdrRulesResult> {
FilterProxyInterface::r#update_rdr_rules(self, rules, generation)
}
pub fn r#check_presence(&self) -> fidl::client::QueryResponseFut<()> {
FilterProxyInterface::r#check_presence(self)
}
}
impl FilterProxyInterface for FilterProxy {
type EnableInterfaceResponseFut = fidl::client::QueryResponseFut<FilterEnableInterfaceResult>;
fn r#enable_interface(&self, mut id: u64) -> Self::EnableInterfaceResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<FilterEnableInterfaceResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<
fidl::encoding::EmptyStruct,
EnableDisableInterfaceError,
>,
0xbf4c680f4001075,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client
.send_query_and_decode::<FilterEnableInterfaceRequest, FilterEnableInterfaceResult>(
(id,),
0xbf4c680f4001075,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type DisableInterfaceResponseFut = fidl::client::QueryResponseFut<FilterDisableInterfaceResult>;
fn r#disable_interface(&self, mut id: u64) -> Self::DisableInterfaceResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<FilterDisableInterfaceResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<
fidl::encoding::EmptyStruct,
EnableDisableInterfaceError,
>,
0x30d2e0e00378a294,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client
.send_query_and_decode::<FilterDisableInterfaceRequest, FilterDisableInterfaceResult>(
(id,),
0x30d2e0e00378a294,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type GetRulesResponseFut = fidl::client::QueryResponseFut<(Vec<Rule>, u32)>;
fn r#get_rules(&self) -> Self::GetRulesResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<(Vec<Rule>, u32), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
FilterGetRulesResponse,
0x284ee4bab557a949,
>(_buf?)?;
Ok((_response.rules, _response.generation))
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (Vec<Rule>, u32)>(
(),
0x284ee4bab557a949,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type UpdateRulesResponseFut = fidl::client::QueryResponseFut<FilterUpdateRulesResult>;
fn r#update_rules(
&self,
mut rules: &[Rule],
mut generation: u32,
) -> Self::UpdateRulesResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<FilterUpdateRulesResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, FilterUpdateRulesError>,
0x32181f0bf9bb9a07,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<FilterUpdateRulesRequest, FilterUpdateRulesResult>(
(rules, generation),
0x32181f0bf9bb9a07,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type GetNatRulesResponseFut = fidl::client::QueryResponseFut<(Vec<Nat>, u32)>;
fn r#get_nat_rules(&self) -> Self::GetNatRulesResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<(Vec<Nat>, u32), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
FilterGetNatRulesResponse,
0x5d61f46aabe0443b,
>(_buf?)?;
Ok((_response.rules, _response.generation))
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (Vec<Nat>, u32)>(
(),
0x5d61f46aabe0443b,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type UpdateNatRulesResponseFut = fidl::client::QueryResponseFut<FilterUpdateNatRulesResult>;
fn r#update_nat_rules(
&self,
mut rules: &[Nat],
mut generation: u32,
) -> Self::UpdateNatRulesResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<FilterUpdateNatRulesResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, FilterUpdateNatRulesError>,
0x1711b0f7d45a2ce2,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client
.send_query_and_decode::<FilterUpdateNatRulesRequest, FilterUpdateNatRulesResult>(
(rules, generation),
0x1711b0f7d45a2ce2,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type GetRdrRulesResponseFut = fidl::client::QueryResponseFut<(Vec<Rdr>, u32)>;
fn r#get_rdr_rules(&self) -> Self::GetRdrRulesResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<(Vec<Rdr>, u32), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
FilterGetRdrRulesResponse,
0x10c953b9ce96e5ed,
>(_buf?)?;
Ok((_response.rules, _response.generation))
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (Vec<Rdr>, u32)>(
(),
0x10c953b9ce96e5ed,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type UpdateRdrRulesResponseFut = fidl::client::QueryResponseFut<FilterUpdateRdrRulesResult>;
fn r#update_rdr_rules(
&self,
mut rules: &[Rdr],
mut generation: u32,
) -> Self::UpdateRdrRulesResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<FilterUpdateRdrRulesResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, FilterUpdateRdrRulesError>,
0x640119eed9f46c55,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client
.send_query_and_decode::<FilterUpdateRdrRulesRequest, FilterUpdateRdrRulesResult>(
(rules, generation),
0x640119eed9f46c55,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type CheckPresenceResponseFut = fidl::client::QueryResponseFut<()>;
fn r#check_presence(&self) -> Self::CheckPresenceResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
0x5b2e2293c3aa2942,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
(),
0x5b2e2293c3aa2942,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
}
pub struct FilterEventStream {
event_receiver: fidl::client::EventReceiver,
}
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 {
fn decode(mut buf: fidl::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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}
}
}
pub struct FilterRequestStream {
inner: std::sync::Arc<fidl::ServeInner>,
is_terminated: bool,
}
impl std::marker::Unpin for FilterRequestStream {}
impl futures::stream::FusedStream for FilterRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for FilterRequestStream {
type Protocol = FilterMarker;
type ControlHandle = FilterControlHandle;
fn from_channel(channel: fidl::AsyncChannel) -> 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>, bool) {
(self.inner, self.is_terminated)
}
fn from_inner(inner: std::sync::Arc<fidl::ServeInner>, 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(|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(zx_status::Status::PEER_CLOSED)) => {
this.is_terminated = true;
return std::task::Poll::Ready(None);
}
std::task::Poll::Ready(Err(e)) => {
return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(e))))
}
}
let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
std::task::Poll::Ready(Some(match header.ordinal {
0xbf4c680f4001075 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(FilterEnableInterfaceRequest);
fidl::encoding::Decoder::decode_into::<FilterEnableInterfaceRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = FilterControlHandle { inner: this.inner.clone() };
Ok(FilterRequest::EnableInterface {
id: req.id,
responder: FilterEnableInterfaceResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x30d2e0e00378a294 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(FilterDisableInterfaceRequest);
fidl::encoding::Decoder::decode_into::<FilterDisableInterfaceRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = FilterControlHandle { inner: this.inner.clone() };
Ok(FilterRequest::DisableInterface {
id: req.id,
responder: FilterDisableInterfaceResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x284ee4bab557a949 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = FilterControlHandle { inner: this.inner.clone() };
Ok(FilterRequest::GetRules {
responder: FilterGetRulesResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x32181f0bf9bb9a07 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(FilterUpdateRulesRequest);
fidl::encoding::Decoder::decode_into::<FilterUpdateRulesRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = FilterControlHandle { inner: this.inner.clone() };
Ok(FilterRequest::UpdateRules {
rules: req.rules,
generation: req.generation,
responder: FilterUpdateRulesResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x5d61f46aabe0443b => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = FilterControlHandle { inner: this.inner.clone() };
Ok(FilterRequest::GetNatRules {
responder: FilterGetNatRulesResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x1711b0f7d45a2ce2 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(FilterUpdateNatRulesRequest);
fidl::encoding::Decoder::decode_into::<FilterUpdateNatRulesRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = FilterControlHandle { inner: this.inner.clone() };
Ok(FilterRequest::UpdateNatRules {
rules: req.rules,
generation: req.generation,
responder: FilterUpdateNatRulesResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x10c953b9ce96e5ed => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = FilterControlHandle { inner: this.inner.clone() };
Ok(FilterRequest::GetRdrRules {
responder: FilterGetRdrRulesResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x640119eed9f46c55 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(FilterUpdateRdrRulesRequest);
fidl::encoding::Decoder::decode_into::<FilterUpdateRdrRulesRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = FilterControlHandle { inner: this.inner.clone() };
Ok(FilterRequest::UpdateRdrRules {
rules: req.rules,
generation: req.generation,
responder: FilterUpdateRdrRulesResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x5b2e2293c3aa2942 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = FilterControlHandle { inner: this.inner.clone() };
Ok(FilterRequest::CheckPresence {
responder: FilterCheckPresenceResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name: <FilterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
})
}
}
#[derive(Debug)]
pub enum FilterRequest {
EnableInterface { id: u64, responder: FilterEnableInterfaceResponder },
DisableInterface { id: u64, responder: FilterDisableInterfaceResponder },
GetRules { responder: FilterGetRulesResponder },
UpdateRules { rules: Vec<Rule>, generation: u32, responder: FilterUpdateRulesResponder },
GetNatRules { responder: FilterGetNatRulesResponder },
UpdateNatRules { rules: Vec<Nat>, generation: u32, responder: FilterUpdateNatRulesResponder },
GetRdrRules { responder: FilterGetRdrRulesResponder },
UpdateRdrRules { rules: Vec<Rdr>, generation: u32, responder: FilterUpdateRdrRulesResponder },
CheckPresence { responder: FilterCheckPresenceResponder },
}
impl FilterRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_enable_interface(self) -> Option<(u64, FilterEnableInterfaceResponder)> {
if let FilterRequest::EnableInterface { id, responder } = self {
Some((id, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_disable_interface(self) -> Option<(u64, FilterDisableInterfaceResponder)> {
if let FilterRequest::DisableInterface { id, responder } = self {
Some((id, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_get_rules(self) -> Option<(FilterGetRulesResponder)> {
if let FilterRequest::GetRules { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_update_rules(self) -> Option<(Vec<Rule>, u32, FilterUpdateRulesResponder)> {
if let FilterRequest::UpdateRules { rules, generation, responder } = self {
Some((rules, generation, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_get_nat_rules(self) -> Option<(FilterGetNatRulesResponder)> {
if let FilterRequest::GetNatRules { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_update_nat_rules(self) -> Option<(Vec<Nat>, u32, FilterUpdateNatRulesResponder)> {
if let FilterRequest::UpdateNatRules { rules, generation, responder } = self {
Some((rules, generation, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_get_rdr_rules(self) -> Option<(FilterGetRdrRulesResponder)> {
if let FilterRequest::GetRdrRules { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_update_rdr_rules(self) -> Option<(Vec<Rdr>, u32, FilterUpdateRdrRulesResponder)> {
if let FilterRequest::UpdateRdrRules { rules, generation, responder } = self {
Some((rules, generation, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_check_presence(self) -> Option<(FilterCheckPresenceResponder)> {
if let FilterRequest::CheckPresence { responder } = self {
Some((responder))
} else {
None
}
}
pub fn method_name(&self) -> &'static str {
match *self {
FilterRequest::EnableInterface { .. } => "enable_interface",
FilterRequest::DisableInterface { .. } => "disable_interface",
FilterRequest::GetRules { .. } => "get_rules",
FilterRequest::UpdateRules { .. } => "update_rules",
FilterRequest::GetNatRules { .. } => "get_nat_rules",
FilterRequest::UpdateNatRules { .. } => "update_nat_rules",
FilterRequest::GetRdrRules { .. } => "get_rdr_rules",
FilterRequest::UpdateRdrRules { .. } => "update_rdr_rules",
FilterRequest::CheckPresence { .. } => "check_presence",
}
}
}
#[derive(Debug, Clone)]
pub struct FilterControlHandle {
inner: std::sync::Arc<fidl::ServeInner>,
}
impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
self.inner.channel().on_closed()
}
}
impl FilterControlHandle {}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct FilterEnableInterfaceResponder {
control_handle: std::mem::ManuallyDrop<FilterControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for FilterEnableInterfaceResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for FilterEnableInterfaceResponder {
type ControlHandle = FilterControlHandle;
fn control_handle(&self) -> &FilterControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl FilterEnableInterfaceResponder {
pub fn send(
self,
mut result: Result<(), EnableDisableInterfaceError>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<(), EnableDisableInterfaceError>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<(), EnableDisableInterfaceError>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
fidl::encoding::EmptyStruct,
EnableDisableInterfaceError,
>>(
result,
self.tx_id,
0xbf4c680f4001075,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct FilterDisableInterfaceResponder {
control_handle: std::mem::ManuallyDrop<FilterControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for FilterDisableInterfaceResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for FilterDisableInterfaceResponder {
type ControlHandle = FilterControlHandle;
fn control_handle(&self) -> &FilterControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl FilterDisableInterfaceResponder {
pub fn send(
self,
mut result: Result<(), EnableDisableInterfaceError>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<(), EnableDisableInterfaceError>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<(), EnableDisableInterfaceError>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
fidl::encoding::EmptyStruct,
EnableDisableInterfaceError,
>>(
result,
self.tx_id,
0x30d2e0e00378a294,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct FilterGetRulesResponder {
control_handle: std::mem::ManuallyDrop<FilterControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for FilterGetRulesResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for FilterGetRulesResponder {
type ControlHandle = FilterControlHandle;
fn control_handle(&self) -> &FilterControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl FilterGetRulesResponder {
pub fn send(self, mut rules: &[Rule], mut generation: u32) -> Result<(), fidl::Error> {
let _result = self.send_raw(rules, generation);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut rules: &[Rule],
mut generation: u32,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(rules, generation);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut rules: &[Rule], mut generation: u32) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<FilterGetRulesResponse>(
(rules, generation),
self.tx_id,
0x284ee4bab557a949,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct FilterUpdateRulesResponder {
control_handle: std::mem::ManuallyDrop<FilterControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for FilterUpdateRulesResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for FilterUpdateRulesResponder {
type ControlHandle = FilterControlHandle;
fn control_handle(&self) -> &FilterControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl FilterUpdateRulesResponder {
pub fn send(self, mut result: Result<(), FilterUpdateRulesError>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<(), FilterUpdateRulesError>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<(), FilterUpdateRulesError>) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
fidl::encoding::EmptyStruct,
FilterUpdateRulesError,
>>(
result,
self.tx_id,
0x32181f0bf9bb9a07,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct FilterGetNatRulesResponder {
control_handle: std::mem::ManuallyDrop<FilterControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for FilterGetNatRulesResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for FilterGetNatRulesResponder {
type ControlHandle = FilterControlHandle;
fn control_handle(&self) -> &FilterControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl FilterGetNatRulesResponder {
pub fn send(self, mut rules: &[Nat], mut generation: u32) -> Result<(), fidl::Error> {
let _result = self.send_raw(rules, generation);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut rules: &[Nat],
mut generation: u32,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(rules, generation);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut rules: &[Nat], mut generation: u32) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<FilterGetNatRulesResponse>(
(rules, generation),
self.tx_id,
0x5d61f46aabe0443b,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct FilterUpdateNatRulesResponder {
control_handle: std::mem::ManuallyDrop<FilterControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for FilterUpdateNatRulesResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for FilterUpdateNatRulesResponder {
type ControlHandle = FilterControlHandle;
fn control_handle(&self) -> &FilterControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl FilterUpdateNatRulesResponder {
pub fn send(
self,
mut result: Result<(), FilterUpdateNatRulesError>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<(), FilterUpdateNatRulesError>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<(), FilterUpdateNatRulesError>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
fidl::encoding::EmptyStruct,
FilterUpdateNatRulesError,
>>(
result,
self.tx_id,
0x1711b0f7d45a2ce2,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct FilterGetRdrRulesResponder {
control_handle: std::mem::ManuallyDrop<FilterControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for FilterGetRdrRulesResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for FilterGetRdrRulesResponder {
type ControlHandle = FilterControlHandle;
fn control_handle(&self) -> &FilterControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl FilterGetRdrRulesResponder {
pub fn send(self, mut rules: &[Rdr], mut generation: u32) -> Result<(), fidl::Error> {
let _result = self.send_raw(rules, generation);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut rules: &[Rdr],
mut generation: u32,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(rules, generation);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut rules: &[Rdr], mut generation: u32) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<FilterGetRdrRulesResponse>(
(rules, generation),
self.tx_id,
0x10c953b9ce96e5ed,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct FilterUpdateRdrRulesResponder {
control_handle: std::mem::ManuallyDrop<FilterControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for FilterUpdateRdrRulesResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for FilterUpdateRdrRulesResponder {
type ControlHandle = FilterControlHandle;
fn control_handle(&self) -> &FilterControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl FilterUpdateRdrRulesResponder {
pub fn send(
self,
mut result: Result<(), FilterUpdateRdrRulesError>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<(), FilterUpdateRdrRulesError>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<(), FilterUpdateRdrRulesError>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
fidl::encoding::EmptyStruct,
FilterUpdateRdrRulesError,
>>(
result,
self.tx_id,
0x640119eed9f46c55,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct FilterCheckPresenceResponder {
control_handle: std::mem::ManuallyDrop<FilterControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for FilterCheckPresenceResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for FilterCheckPresenceResponder {
type ControlHandle = FilterControlHandle;
fn control_handle(&self) -> &FilterControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl FilterCheckPresenceResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x5b2e2293c3aa2942,
fidl::encoding::DynamicFlags::empty(),
)
}
}
mod internal {
use super::*;
unsafe impl fidl::encoding::TypeMarker for Action {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u32>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u32>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for Action {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for Action {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for Action {
#[inline(always)]
fn new_empty() -> Self {
Self::Pass
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u32>(offset);
*self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for Direction {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u32>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u32>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for Direction {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for Direction {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for Direction {
#[inline(always)]
fn new_empty() -> Self {
Self::Incoming
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u32>(offset);
*self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for EnableDisableInterfaceError {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u32>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u32>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for EnableDisableInterfaceError {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for EnableDisableInterfaceError {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for EnableDisableInterfaceError {
#[inline(always)]
fn new_empty() -> Self {
Self::NotFound
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u32>(offset);
*self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for FilterUpdateNatRulesError {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u32>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u32>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for FilterUpdateNatRulesError {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for FilterUpdateNatRulesError {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for FilterUpdateNatRulesError {
#[inline(always)]
fn new_empty() -> Self {
Self::GenerationMismatch
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u32>(offset);
*self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for FilterUpdateRdrRulesError {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u32>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u32>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for FilterUpdateRdrRulesError {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for FilterUpdateRdrRulesError {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for FilterUpdateRdrRulesError {
#[inline(always)]
fn new_empty() -> Self {
Self::NotSupported
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u32>(offset);
*self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for FilterUpdateRulesError {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u32>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u32>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for FilterUpdateRulesError {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for FilterUpdateRulesError {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for FilterUpdateRulesError {
#[inline(always)]
fn new_empty() -> Self {
Self::GenerationMismatch
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u32>(offset);
*self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for SocketProtocol {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u32>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u32>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for SocketProtocol {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for SocketProtocol {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for SocketProtocol {
#[inline(always)]
fn new_empty() -> Self {
Self::Any
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u32>(offset);
*self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for Empty {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
1
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
1
}
}
impl fidl::encoding::ValueTypeMarker for Empty {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<Empty> for &Empty {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Empty>(offset);
encoder.write_num(0u8, offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for Empty {
#[inline(always)]
fn new_empty() -> Self {
Self
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
match decoder.read_num::<u8>(offset) {
0 => Ok(()),
_ => Err(fidl::Error::Invalid),
}
}
}
unsafe impl fidl::encoding::TypeMarker for FilterDisableInterfaceRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for FilterDisableInterfaceRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<FilterDisableInterfaceRequest>
for &FilterDisableInterfaceRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<FilterDisableInterfaceRequest>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut FilterDisableInterfaceRequest)
.write_unaligned((self as *const FilterDisableInterfaceRequest).read());
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<u64>>
fidl::encoding::Encode<FilterDisableInterfaceRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<FilterDisableInterfaceRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for FilterDisableInterfaceRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { id: fidl::new_empty!(u64) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for FilterEnableInterfaceRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for FilterEnableInterfaceRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<FilterEnableInterfaceRequest> for &FilterEnableInterfaceRequest {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<FilterEnableInterfaceRequest>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut FilterEnableInterfaceRequest)
.write_unaligned((self as *const FilterEnableInterfaceRequest).read());
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<u64>>
fidl::encoding::Encode<FilterEnableInterfaceRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<FilterEnableInterfaceRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for FilterEnableInterfaceRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { id: fidl::new_empty!(u64) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for FilterGetNatRulesResponse {
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
}
}
impl fidl::encoding::ValueTypeMarker for FilterGetNatRulesResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<FilterGetNatRulesResponse> for &FilterGetNatRulesResponse {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<FilterGetNatRulesResponse>(offset);
fidl::encoding::Encode::<FilterGetNatRulesResponse>::encode(
(
<fidl::encoding::Vector<Nat, 128> as fidl::encoding::ValueTypeMarker>::borrow(
&self.rules,
),
<u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.generation),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Vector<Nat, 128>>,
T1: fidl::encoding::Encode<u32>,
> fidl::encoding::Encode<FilterGetNatRulesResponse> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<FilterGetNatRulesResponse>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for FilterGetNatRulesResponse {
#[inline(always)]
fn new_empty() -> Self {
Self {
rules: fidl::new_empty!(fidl::encoding::Vector<Nat, 128>),
generation: fidl::new_empty!(u32),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
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::Vector<Nat, 128>, &mut self.rules, decoder, offset + 0, _depth)?;
fidl::decode!(u32, &mut self.generation, decoder, offset + 16, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for FilterGetRdrRulesResponse {
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
}
}
impl fidl::encoding::ValueTypeMarker for FilterGetRdrRulesResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<FilterGetRdrRulesResponse> for &FilterGetRdrRulesResponse {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<FilterGetRdrRulesResponse>(offset);
fidl::encoding::Encode::<FilterGetRdrRulesResponse>::encode(
(
<fidl::encoding::Vector<Rdr, 128> as fidl::encoding::ValueTypeMarker>::borrow(
&self.rules,
),
<u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.generation),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Vector<Rdr, 128>>,
T1: fidl::encoding::Encode<u32>,
> fidl::encoding::Encode<FilterGetRdrRulesResponse> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<FilterGetRdrRulesResponse>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for FilterGetRdrRulesResponse {
#[inline(always)]
fn new_empty() -> Self {
Self {
rules: fidl::new_empty!(fidl::encoding::Vector<Rdr, 128>),
generation: fidl::new_empty!(u32),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
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::Vector<Rdr, 128>, &mut self.rules, decoder, offset + 0, _depth)?;
fidl::decode!(u32, &mut self.generation, decoder, offset + 16, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for FilterGetRulesResponse {
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
}
}
impl fidl::encoding::ValueTypeMarker for FilterGetRulesResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<FilterGetRulesResponse> for &FilterGetRulesResponse {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<FilterGetRulesResponse>(offset);
fidl::encoding::Encode::<FilterGetRulesResponse>::encode(
(
<fidl::encoding::Vector<Rule, 128> as fidl::encoding::ValueTypeMarker>::borrow(
&self.rules,
),
<u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.generation),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Vector<Rule, 128>>,
T1: fidl::encoding::Encode<u32>,
> fidl::encoding::Encode<FilterGetRulesResponse> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<FilterGetRulesResponse>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for FilterGetRulesResponse {
#[inline(always)]
fn new_empty() -> Self {
Self {
rules: fidl::new_empty!(fidl::encoding::Vector<Rule, 128>),
generation: fidl::new_empty!(u32),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
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::Vector<Rule, 128>, &mut self.rules, decoder, offset + 0, _depth)?;
fidl::decode!(u32, &mut self.generation, decoder, offset + 16, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for FilterUpdateNatRulesRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for FilterUpdateNatRulesRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<FilterUpdateNatRulesRequest> for &FilterUpdateNatRulesRequest {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<FilterUpdateNatRulesRequest>(offset);
fidl::encoding::Encode::<FilterUpdateNatRulesRequest>::encode(
(
<fidl::encoding::Vector<Nat, 128> as fidl::encoding::ValueTypeMarker>::borrow(
&self.rules,
),
<u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.generation),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Vector<Nat, 128>>,
T1: fidl::encoding::Encode<u32>,
> fidl::encoding::Encode<FilterUpdateNatRulesRequest> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<FilterUpdateNatRulesRequest>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for FilterUpdateNatRulesRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
rules: fidl::new_empty!(fidl::encoding::Vector<Nat, 128>),
generation: fidl::new_empty!(u32),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
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::Vector<Nat, 128>, &mut self.rules, decoder, offset + 0, _depth)?;
fidl::decode!(u32, &mut self.generation, decoder, offset + 16, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for FilterUpdateRdrRulesRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for FilterUpdateRdrRulesRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<FilterUpdateRdrRulesRequest> for &FilterUpdateRdrRulesRequest {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<FilterUpdateRdrRulesRequest>(offset);
fidl::encoding::Encode::<FilterUpdateRdrRulesRequest>::encode(
(
<fidl::encoding::Vector<Rdr, 128> as fidl::encoding::ValueTypeMarker>::borrow(
&self.rules,
),
<u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.generation),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Vector<Rdr, 128>>,
T1: fidl::encoding::Encode<u32>,
> fidl::encoding::Encode<FilterUpdateRdrRulesRequest> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<FilterUpdateRdrRulesRequest>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for FilterUpdateRdrRulesRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
rules: fidl::new_empty!(fidl::encoding::Vector<Rdr, 128>),
generation: fidl::new_empty!(u32),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
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::Vector<Rdr, 128>, &mut self.rules, decoder, offset + 0, _depth)?;
fidl::decode!(u32, &mut self.generation, decoder, offset + 16, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for FilterUpdateRulesRequest {
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
}
}
impl fidl::encoding::ValueTypeMarker for FilterUpdateRulesRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<FilterUpdateRulesRequest> for &FilterUpdateRulesRequest {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<FilterUpdateRulesRequest>(offset);
fidl::encoding::Encode::<FilterUpdateRulesRequest>::encode(
(
<fidl::encoding::Vector<Rule, 128> as fidl::encoding::ValueTypeMarker>::borrow(
&self.rules,
),
<u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.generation),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Vector<Rule, 128>>,
T1: fidl::encoding::Encode<u32>,
> fidl::encoding::Encode<FilterUpdateRulesRequest> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<FilterUpdateRulesRequest>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for FilterUpdateRulesRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
rules: fidl::new_empty!(fidl::encoding::Vector<Rule, 128>),
generation: fidl::new_empty!(u32),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
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::Vector<Rule, 128>, &mut self.rules, decoder, offset + 0, _depth)?;
fidl::decode!(u32, &mut self.generation, decoder, offset + 16, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for Nat {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
40
}
}
impl fidl::encoding::ValueTypeMarker for Nat {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<Nat> for &Nat {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Nat>(offset);
fidl::encoding::Encode::<Nat>::encode(
(
<SocketProtocol as fidl::encoding::ValueTypeMarker>::borrow(&self.proto),
<fidl_fuchsia_net::Subnet as fidl::encoding::ValueTypeMarker>::borrow(
&self.src_subnet,
),
<u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.outgoing_nic),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<SocketProtocol>,
T1: fidl::encoding::Encode<fidl_fuchsia_net::Subnet>,
T2: fidl::encoding::Encode<u32>,
> fidl::encoding::Encode<Nat> for (T0, T1, T2)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Nat>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
(ptr as *mut u64).write_unaligned(0);
}
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 8, depth)?;
self.2.encode(encoder, offset + 32, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for Nat {
#[inline(always)]
fn new_empty() -> Self {
Self {
proto: fidl::new_empty!(SocketProtocol),
src_subnet: fidl::new_empty!(fidl_fuchsia_net::Subnet),
outgoing_nic: fidl::new_empty!(u32),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
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 + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
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 + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(SocketProtocol, &mut self.proto, decoder, offset + 0, _depth)?;
fidl::decode!(
fidl_fuchsia_net::Subnet,
&mut self.src_subnet,
decoder,
offset + 8,
_depth
)?;
fidl::decode!(u32, &mut self.outgoing_nic, decoder, offset + 32, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for PortRange {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
2
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for PortRange {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<PortRange> for &PortRange {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<PortRange>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut PortRange).write_unaligned((self as *const PortRange).read());
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<u16>, T1: fidl::encoding::Encode<u16>>
fidl::encoding::Encode<PortRange> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<PortRange>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 2, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for PortRange {
#[inline(always)]
fn new_empty() -> Self {
Self { start: fidl::new_empty!(u16), end: fidl::new_empty!(u16) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for Rdr {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
56
}
}
impl fidl::encoding::ValueTypeMarker for Rdr {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<Rdr> for &Rdr {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Rdr>(offset);
fidl::encoding::Encode::<Rdr>::encode(
(
<SocketProtocol as fidl::encoding::ValueTypeMarker>::borrow(&self.proto),
<fidl_fuchsia_net::IpAddress as fidl::encoding::ValueTypeMarker>::borrow(
&self.dst_addr,
),
<PortRange as fidl::encoding::ValueTypeMarker>::borrow(&self.dst_port_range),
<fidl_fuchsia_net::IpAddress as fidl::encoding::ValueTypeMarker>::borrow(
&self.new_dst_addr,
),
<PortRange as fidl::encoding::ValueTypeMarker>::borrow(
&self.new_dst_port_range,
),
<u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.nic),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<SocketProtocol>,
T1: fidl::encoding::Encode<fidl_fuchsia_net::IpAddress>,
T2: fidl::encoding::Encode<PortRange>,
T3: fidl::encoding::Encode<fidl_fuchsia_net::IpAddress>,
T4: fidl::encoding::Encode<PortRange>,
T5: fidl::encoding::Encode<u32>,
> fidl::encoding::Encode<Rdr> for (T0, T1, T2, T3, T4, T5)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Rdr>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
(ptr as *mut u64).write_unaligned(0);
}
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 8, depth)?;
self.2.encode(encoder, offset + 24, depth)?;
self.3.encode(encoder, offset + 32, depth)?;
self.4.encode(encoder, offset + 48, depth)?;
self.5.encode(encoder, offset + 52, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for Rdr {
#[inline(always)]
fn new_empty() -> Self {
Self {
proto: fidl::new_empty!(SocketProtocol),
dst_addr: fidl::new_empty!(fidl_fuchsia_net::IpAddress),
dst_port_range: fidl::new_empty!(PortRange),
new_dst_addr: fidl::new_empty!(fidl_fuchsia_net::IpAddress),
new_dst_port_range: fidl::new_empty!(PortRange),
nic: fidl::new_empty!(u32),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
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 + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
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 + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(SocketProtocol, &mut self.proto, decoder, offset + 0, _depth)?;
fidl::decode!(
fidl_fuchsia_net::IpAddress,
&mut self.dst_addr,
decoder,
offset + 8,
_depth
)?;
fidl::decode!(PortRange, &mut self.dst_port_range, decoder, offset + 24, _depth)?;
fidl::decode!(
fidl_fuchsia_net::IpAddress,
&mut self.new_dst_addr,
decoder,
offset + 32,
_depth
)?;
fidl::decode!(PortRange, &mut self.new_dst_port_range, decoder, offset + 48, _depth)?;
fidl::decode!(u32, &mut self.nic, decoder, offset + 52, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for Rule {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
72
}
}
impl fidl::encoding::ValueTypeMarker for Rule {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<Rule> for &Rule {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Rule>(offset);
fidl::encoding::Encode::<Rule>::encode(
(
<Action as fidl::encoding::ValueTypeMarker>::borrow(&self.action),
<Direction as fidl::encoding::ValueTypeMarker>::borrow(&self.direction),
<SocketProtocol as fidl::encoding::ValueTypeMarker>::borrow(&self.proto),
<fidl::encoding::Boxed<fidl_fuchsia_net::Subnet> as fidl::encoding::ValueTypeMarker>::borrow(&self.src_subnet),
<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.src_subnet_invert_match),
<PortRange as fidl::encoding::ValueTypeMarker>::borrow(&self.src_port_range),
<fidl::encoding::Boxed<fidl_fuchsia_net::Subnet> as fidl::encoding::ValueTypeMarker>::borrow(&self.dst_subnet),
<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.dst_subnet_invert_match),
<PortRange as fidl::encoding::ValueTypeMarker>::borrow(&self.dst_port_range),
<u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.nic),
<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.log),
<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.keep_state),
<DeviceClass as fidl::encoding::ValueTypeMarker>::borrow(&self.device_class),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<Action>,
T1: fidl::encoding::Encode<Direction>,
T2: fidl::encoding::Encode<SocketProtocol>,
T3: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_net::Subnet>>,
T4: fidl::encoding::Encode<bool>,
T5: fidl::encoding::Encode<PortRange>,
T6: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_net::Subnet>>,
T7: fidl::encoding::Encode<bool>,
T8: fidl::encoding::Encode<PortRange>,
T9: fidl::encoding::Encode<u32>,
T10: fidl::encoding::Encode<bool>,
T11: fidl::encoding::Encode<bool>,
T12: fidl::encoding::Encode<DeviceClass>,
> fidl::encoding::Encode<Rule> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Rule>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
(ptr as *mut u64).write_unaligned(0);
}
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
(ptr as *mut u64).write_unaligned(0);
}
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
(ptr as *mut u64).write_unaligned(0);
}
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 4, depth)?;
self.2.encode(encoder, offset + 8, depth)?;
self.3.encode(encoder, offset + 16, depth)?;
self.4.encode(encoder, offset + 24, depth)?;
self.5.encode(encoder, offset + 26, depth)?;
self.6.encode(encoder, offset + 32, depth)?;
self.7.encode(encoder, offset + 40, depth)?;
self.8.encode(encoder, offset + 42, depth)?;
self.9.encode(encoder, offset + 48, depth)?;
self.10.encode(encoder, offset + 52, depth)?;
self.11.encode(encoder, offset + 53, depth)?;
self.12.encode(encoder, offset + 56, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for Rule {
#[inline(always)]
fn new_empty() -> Self {
Self {
action: fidl::new_empty!(Action),
direction: fidl::new_empty!(Direction),
proto: fidl::new_empty!(SocketProtocol),
src_subnet: fidl::new_empty!(fidl::encoding::Boxed<fidl_fuchsia_net::Subnet>),
src_subnet_invert_match: fidl::new_empty!(bool),
src_port_range: fidl::new_empty!(PortRange),
dst_subnet: fidl::new_empty!(fidl::encoding::Boxed<fidl_fuchsia_net::Subnet>),
dst_subnet_invert_match: fidl::new_empty!(bool),
dst_port_range: fidl::new_empty!(PortRange),
nic: fidl::new_empty!(u32),
log: fidl::new_empty!(bool),
keep_state: fidl::new_empty!(bool),
device_class: fidl::new_empty!(DeviceClass),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
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,
});
}
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let mask = 0xffff00000000ff00u64;
let maskedval = padval & mask;
if maskedval != 0 {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let mask = 0xffff00000000ff00u64;
let maskedval = padval & mask;
if maskedval != 0 {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let mask = 0xffff000000000000u64;
let maskedval = padval & mask;
if maskedval != 0 {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(Action, &mut self.action, decoder, offset + 0, _depth)?;
fidl::decode!(Direction, &mut self.direction, decoder, offset + 4, _depth)?;
fidl::decode!(SocketProtocol, &mut self.proto, decoder, offset + 8, _depth)?;
fidl::decode!(
fidl::encoding::Boxed<fidl_fuchsia_net::Subnet>,
&mut self.src_subnet,
decoder,
offset + 16,
_depth
)?;
fidl::decode!(bool, &mut self.src_subnet_invert_match, decoder, offset + 24, _depth)?;
fidl::decode!(PortRange, &mut self.src_port_range, decoder, offset + 26, _depth)?;
fidl::decode!(
fidl::encoding::Boxed<fidl_fuchsia_net::Subnet>,
&mut self.dst_subnet,
decoder,
offset + 32,
_depth
)?;
fidl::decode!(bool, &mut self.dst_subnet_invert_match, decoder, offset + 40, _depth)?;
fidl::decode!(PortRange, &mut self.dst_port_range, decoder, offset + 42, _depth)?;
fidl::decode!(u32, &mut self.nic, decoder, offset + 48, _depth)?;
fidl::decode!(bool, &mut self.log, decoder, offset + 52, _depth)?;
fidl::decode!(bool, &mut self.keep_state, decoder, offset + 53, _depth)?;
fidl::decode!(DeviceClass, &mut self.device_class, decoder, offset + 56, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceClass {
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
}
}
impl fidl::encoding::ValueTypeMarker for DeviceClass {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeviceClass> for &DeviceClass {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceClass>(offset);
encoder.write_num::<u64>(self.ordinal(), offset);
match self {
DeviceClass::Any(ref val) => {
fidl::encoding::encode_in_envelope::<Empty>(
<Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
encoder, offset + 8, _depth
)
}
DeviceClass::Match_(ref val) => {
fidl::encoding::encode_in_envelope::<fidl_fuchsia_hardware_network::DeviceClass>(
<fidl_fuchsia_hardware_network::DeviceClass as fidl::encoding::ValueTypeMarker>::borrow(val),
encoder, offset + 8, _depth
)
}
}
}
}
impl fidl::encoding::Decode<Self> for DeviceClass {
#[inline(always)]
fn new_empty() -> Self {
Self::Any(fidl::new_empty!(Empty))
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
#[allow(unused_variables)]
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
let (ordinal, inlined, num_bytes, num_handles) =
fidl::encoding::decode_union_inline_portion(decoder, offset)?;
let member_inline_size = match ordinal {
1 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2 => <fidl_fuchsia_hardware_network::DeviceClass as fidl::encoding::TypeMarker>::inline_size(decoder.context),
_ => return Err(fidl::Error::UnknownUnionTag),
};
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let _inner_offset;
if inlined {
decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
_inner_offset = offset + 8;
} else {
depth.increment()?;
_inner_offset = decoder.out_of_line_offset(member_inline_size)?;
}
match ordinal {
1 => {
#[allow(irrefutable_let_patterns)]
if let DeviceClass::Any(_) = self {
} else {
*self = DeviceClass::Any(fidl::new_empty!(Empty));
}
#[allow(irrefutable_let_patterns)]
if let DeviceClass::Any(ref mut val) = self {
fidl::decode!(Empty, val, decoder, _inner_offset, depth)?;
} else {
unreachable!()
}
}
2 => {
#[allow(irrefutable_let_patterns)]
if let DeviceClass::Match_(_) = self {
} else {
*self = DeviceClass::Match_(fidl::new_empty!(
fidl_fuchsia_hardware_network::DeviceClass
));
}
#[allow(irrefutable_let_patterns)]
if let DeviceClass::Match_(ref mut val) = self {
fidl::decode!(
fidl_fuchsia_hardware_network::DeviceClass,
val,
decoder,
_inner_offset,
depth
)?;
} else {
unreachable!()
}
}
ordinal => panic!("unexpected ordinal {:?}", ordinal),
}
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
Ok(())
}
}
}