Struct SnapTunnel 

pub struct SnapTunnel { /* private fields */ }

A SNAP tunnel connection.

A background driver task runs the WireGuard session. Once the driver stops the tunnel is closed for good: receiving fails with SnapTunnelReceiveError::ReceiveQueueClosed and sending fails with an io::ErrorKind::ConnectionReset error. See SnapTunnel::is_closed for when that happens.

Implementations

impl SnapTunnel

pub async fn send(&self, packet: Packet) -> Result<()>

Send a packet to the remote server.

While a handshake is in progress the packet is queued and sent when the handshake completes. Fails with io::ErrorKind::ConnectionReset once the tunnel is closed.

pub fn try_send(&self, packet: Packet) -> Result<()>

Try to send a packet to the remote server. Returns error of try_send_to.

Fails with io::ErrorKind::ConnectionReset once the tunnel is closed.

pub async fn recv(&self) -> Result<Bytes, SnapTunnelReceiveError>

Receive a packet from the remote server.

Fails with SnapTunnelReceiveError::ReceiveQueueClosed once the tunnel is closed.

pub fn try_recv(&self) -> Result<Option<Bytes>, SnapTunnelReceiveError>

Try to receive a packet from the remote server without blocking.

Returns Ok(None) if no packet is currently available.

pub fn poll_recv( &self, cx: &mut Context<'_>, ) -> Poll<Result<Bytes, SnapTunnelReceiveError>>

Poll for a packet from the remote server.

pub fn local_addr(&self) -> SocketAddr

Get the local socket address. Assigned by the remote server.

pub fn is_closed(&self) -> bool

Whether the tunnel is closed. A closed tunnel delivers nothing in either direction.

The tunnel closes when the driver stops. The driver stops when the consumer of the receive queue is gone, when an expired session cannot be re-established within a fixed budget, when a re-handshake fails permanently, or when a re-handshake assigns a different local address. The last case happens after the local network changed, because the data plane derives the address from the source address it observes. An application that wants to continue then connects a new tunnel; see the rules on super::SnapTunEndpoint.

pub async fn writable(&self) -> Result<()>

Check if the socket is writable.

pub fn data_plane_address(&self) -> SocketAddr

The data plane the tunnel is connected to.

pub fn discarded_datagrams(&self) -> u64

Total number of outbound datagrams the underlay socket refused since the tunnel was created.

A refused datagram is dropped rather than retried, because retrying one the socket will never accept blocks every packet queued behind it. The tunnel therefore stays up when sending fails persistently, for example because the interface went down or a firewall answers EPERM, and this counter is what tells such a tunnel apart from a healthy one.

Trait Implementations

impl Drop for SnapTunnel

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.