Struct MapTunnel

pub struct MapTunnel { /* private fields */ }

MAP tunnel implementation supporting both MAP-E and MAP-T

Implementations

impl MapTunnel

pub fn new(config: TunnelConfig, protocol_variant: MapProtocol) -> Result<Self>

Create a new MAP tunnel

pub fn add_map_rule(&mut self, rule: MapRule)

Add a MAP rule to the configuration

pub fn calculate_ipv6_address( &self, ipv4_addr: Ipv4Addr, rule: &MapRule, ) -> Result<Ipv6Addr>

Calculate IPv6 address from IPv4 address and MAP rule

pub fn calculate_port_set(&self, psid: u16, rule: &MapRule) -> PortSet

Calculate port set for a given PSID

pub fn extract_psid(&self, ipv4_addr: Ipv4Addr, rule: &MapRule) -> u16

Extract PSID from IPv4 address using MAP rule

pub async fn initialize_addresses(&mut self) -> Result<()>

Initialize local IPv4 address and generate ISATAP address (public for testing)

pub fn encapsulate_ipv4_in_ipv6(&self, ipv4_packet: &[u8]) -> Result<Vec<u8>>

Encapsulate IPv4 packet in IPv6 for MAP-E

pub fn translate_ipv4_to_ipv6(&mut self, ipv4_packet: &[u8]) -> Result<Vec<u8>>

Translate IPv4 packet to IPv6 for MAP-T

pub fn is_port_allowed(&self, port: u16) -> bool

Validate port against assigned port set

Trait Implementations

impl Tunnel for MapTunnel

fn protocol(&self) -> TunnelProtocol

Get the protocol type for this tunnel

fn config(&self) -> &TunnelConfig

Get the current configuration

fn state<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = TunnelState> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the current tunnel state

fn metrics<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = TunnelMetrics> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get tunnel performance metrics

fn connect<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Establish the tunnel connection

fn is_active<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Check if the tunnel is currently active and usable

fn disconnect<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Close the tunnel connection

fn encapsulate<'life0, 'life1, 'async_trait>( &'life0 self, ipv4_packet: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Encapsulate IPv6 packet for transmission over IPv4

fn decapsulate<'life0, 'life1, 'async_trait>( &'life0 self, packet: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Decapsulate IPv4 packet to extract IPv6 content

fn send<'life0, 'life1, 'async_trait>( &'life0 mut self, packet: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Send a packet through the tunnel

fn receive<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Receive a packet from the tunnel

fn maintain<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Perform periodic maintenance (keepalive, metrics update, etc.)

fn local_ipv6_addr<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Ipv6Addr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the IPv6 address assigned to this tunnel

fn local_ipv4_addr<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Ipv4Addr>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the IPv4 endpoint address for this tunnel

fn ping<'life0, 'async_trait>( &'life0 mut self, _timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<Duration>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Test tunnel connectivity with a ping