gotatun 0.1.1

an implementation of the WireGuard® protocol designed for portability and speed
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

// Copyright (c) 2025 Mullvad VPN AB. All rights reserved.
// SPDX-License-Identifier: BSD-3-Clause

use tokio::sync::watch;

use crate::packet::{Ip, Packet, PacketBufPool};
use std::future::{Future, pending};
use std::io;

pub mod buffer;
pub mod channel;

#[cfg(feature = "pcap")]
pub mod pcap;

#[cfg(feature = "tun")]
pub mod tun_async_device;

/// A type that let's you send an IP packet.
///
/// This is used as an abstraction of the TUN device used by wireguard,
/// and enables us to, for example, swap it out with a channel.
pub trait IpSend: Send + Sync + 'static {
    /// Send a complete IP packet.
    // TODO: consider refactoring trait with methods that take `Packet<Ipv4>` and `Packet<Ipv6>`
    fn send(&mut self, packet: Packet<Ip>) -> impl Future<Output = io::Result<()>> + Send;
}

/// A type that let's you receive an IP packet.
///
/// This is used as an abstraction of the TUN device used by wireguard,
/// and enables us to, for example, swap it out with a channel.
pub trait IpRecv: Send + Sync + 'static {
    /// Receive a complete IP packet.
    // TODO: consider refactoring trait with methods that return `Packet<Ipv4>` and `Packet<Ipv6>`
    fn recv<'a>(
        &'a mut self,
        pool: &mut PacketBufPool,
    ) -> impl Future<Output = io::Result<impl Iterator<Item = Packet<Ip>> + Send + 'a>> + Send;

    /// Get an MTU watcher for this [`IpRecv`].
    ///
    /// The maximum transfer unit is the max size of packets returned from [`IpRecv::recv`].
    /// Don't rely on this being true though. Since the MTU might change, it is inherently racey.
    fn mtu(&self) -> MtuWatcher;
}

#[derive(Clone)]
pub struct MtuWatcher {
    mtu_source: MtuSource,
    modifier: i32,
}

#[derive(Clone)]
enum MtuSource {
    Constant(u16),
    Watch(watch::Receiver<u16>),
}

impl MtuWatcher {
    /// Create an MTU watcher which always returns `mtu`.
    pub const fn new(mtu: u16) -> Self {
        Self {
            mtu_source: MtuSource::Constant(mtu),
            modifier: 0,
        }
    }

    /// Get the current MTU.
    pub fn get(&mut self) -> u16 {
        let mtu = match &mut self.mtu_source {
            MtuSource::Constant(mtu) => *mtu,
            MtuSource::Watch(mtu_rx) => *mtu_rx.borrow_and_update(),
        };

        i32::from(mtu)
            .checked_add(self.modifier)
            .and_then(|int| u16::try_from(int).ok())
            .expect("MTU over/underflow")
    }

    /// Wait for the MTU to change and return the new value.
    pub async fn wait(&mut self) -> u16 {
        match &mut self.mtu_source {
            MtuSource::Constant(_) => return pending().await,
            MtuSource::Watch(mtu_rx) => {
                if mtu_rx.changed().await.is_err() {
                    return pending().await;
                }
            }
        }

        self.get()
    }

    /// Raise the MTU value returned by [Self] by `value`.
    ///
    /// Any downstream (cloned) [Self] will inherit this change, but any upstream [Self] won't.
    pub fn increase(self, value: u16) -> Option<Self> {
        Some(Self {
            modifier: self.modifier.checked_add(i32::from(value))?,
            ..self
        })
    }

    /// Lower the MTU value returned by [Self] by `value`.
    ///
    /// Any downstream (cloned) [Self] will inherit this change, but any upstream [Self] won't.
    pub fn decrease(self, value: u16) -> Option<Self> {
        Some(Self {
            modifier: self.modifier.checked_sub(i32::from(value))?,
            ..self
        })
    }
}

impl From<watch::Receiver<u16>> for MtuWatcher {
    fn from(mtu_rx: watch::Receiver<u16>) -> Self {
        Self {
            mtu_source: MtuSource::Watch(mtu_rx),
            modifier: 0,
        }
    }
}