repo stringlengths 6 65 | file_url stringlengths 81 311 | file_path stringlengths 6 227 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:31:58 2026-01-04 20:25:31 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/async_device/unix/mod.rs | src/async_device/unix/mod.rs | #[cfg(all(target_os = "linux", not(target_env = "ohos")))]
use crate::platform::offload::{handle_gro, VirtioNetHdr, VIRTIO_NET_HDR_LEN};
use crate::platform::DeviceImpl;
#[cfg(all(target_os = "linux", not(target_env = "ohos")))]
use crate::platform::GROTable;
use crate::SyncDevice;
use std::io;
use std::io::{IoSlice, IoSliceMut};
use std::ops::Deref;
use std::os::fd::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
#[cfg(feature = "async_tokio")]
mod tokio;
#[cfg(feature = "async_tokio")]
pub use self::tokio::AsyncDevice;
#[cfg(all(feature = "async_io", not(feature = "async_tokio")))]
mod async_io;
#[cfg(all(feature = "async_io", not(feature = "async_tokio")))]
pub use self::async_io::AsyncDevice;
impl FromRawFd for AsyncDevice {
unsafe fn from_raw_fd(fd: RawFd) -> Self {
AsyncDevice::from_fd(fd).unwrap()
}
}
impl IntoRawFd for AsyncDevice {
fn into_raw_fd(self) -> RawFd {
self.into_fd().unwrap()
}
}
impl AsRawFd for AsyncDevice {
fn as_raw_fd(&self) -> RawFd {
self.get_ref().as_raw_fd()
}
}
impl Deref for AsyncDevice {
type Target = DeviceImpl;
fn deref(&self) -> &Self::Target {
self.get_ref()
}
}
impl AsyncDevice {
#[allow(dead_code)]
pub fn new(device: SyncDevice) -> io::Result<AsyncDevice> {
AsyncDevice::new_dev(device.0)
}
/// # Safety
/// This method is safe if the provided fd is valid
/// Construct a AsyncDevice from an existing file descriptor
pub unsafe fn from_fd(fd: RawFd) -> io::Result<AsyncDevice> {
AsyncDevice::new_dev(DeviceImpl::from_fd(fd)?)
}
/// # Safety
/// The fd passed in must be a valid, open file descriptor.
/// Unlike [`from_fd`], this function does **not** take ownership of `fd`,
/// and therefore will not close it when dropped.
/// The caller is responsible for ensuring the lifetime and eventual closure of `fd`.
#[allow(dead_code)]
pub(crate) unsafe fn borrow_raw(fd: RawFd) -> io::Result<Self> {
AsyncDevice::new_dev(DeviceImpl::borrow_raw(fd)?)
}
pub fn into_fd(self) -> io::Result<RawFd> {
Ok(self.into_device()?.into_raw_fd())
}
/// Waits for the device to become readable.
///
/// This function is usually paired with `try_recv()`.
///
/// The function may complete without the device being readable. This is a
/// false-positive and attempting a `try_recv()` will return with
/// `io::ErrorKind::WouldBlock`.
///
/// # Cancel safety
///
/// This method is cancel safe. Once a readiness event occurs, the method
/// will continue to return immediately until the readiness event is
/// consumed by an attempt to read that fails with `WouldBlock` or
/// `Poll::Pending`.
pub async fn readable(&self) -> io::Result<()> {
self.0.readable().await.map(|_| ())
}
/// Waits for the device to become writable.
///
/// This function is usually paired with `try_send()`.
///
/// The function may complete without the device being writable. This is a
/// false-positive and attempting a `try_send()` will return with
/// `io::ErrorKind::WouldBlock`.
///
/// # Cancel safety
///
/// This method is cancel safe. Once a readiness event occurs, the method
/// will continue to return immediately until the readiness event is
/// consumed by an attempt to write that fails with `WouldBlock` or
/// `Poll::Pending`.
pub async fn writable(&self) -> io::Result<()> {
self.0.writable().await.map(|_| ())
}
/// Receives a single packet from the device.
/// On success, returns the number of bytes read.
///
/// The function must be called with valid byte array `buf` of sufficient
/// size to hold the message bytes. If a message is too long to fit in the
/// supplied buffer, excess bytes may be discarded.
pub async fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
self.read_with(|device| device.recv(buf)).await
}
/// Tries to receive a single packet from the device.
/// On success, returns the number of bytes read.
///
/// This method must be called with valid byte array `buf` of sufficient size
/// to hold the message bytes. If a message is too long to fit in the
/// supplied buffer, excess bytes may be discarded.
///
/// When there is no pending data, `Err(io::ErrorKind::WouldBlock)` is
/// returned. This function is usually paired with `readable()`.
pub fn try_recv(&self, buf: &mut [u8]) -> io::Result<usize> {
self.try_read_io(|device| device.recv(buf))
}
/// Send a packet to the device
///
/// # Return
/// On success, the number of bytes sent is returned, otherwise, the encountered error is returned.
pub async fn send(&self, buf: &[u8]) -> io::Result<usize> {
self.write_with(|device| device.send(buf)).await
}
/// Tries to send packet to the device.
///
/// When the device buffer is full, `Err(io::ErrorKind::WouldBlock)` is
/// returned. This function is usually paired with `writable()`.
///
/// # Returns
///
/// If successful, `Ok(n)` is returned, where `n` is the number of bytes
/// sent. If the device is not ready to send data,
/// `Err(ErrorKind::WouldBlock)` is returned.
pub fn try_send(&self, buf: &[u8]) -> io::Result<usize> {
self.try_write_io(|device| device.send(buf))
}
/// Receives a packet into multiple buffers (scatter read).
/// **Processes single packet per call**.
pub async fn recv_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
self.read_with(|device| device.recv_vectored(bufs)).await
}
/// Non-blocking version of `recv_vectored`.
pub fn try_recv_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
self.try_read_io(|device| device.recv_vectored(bufs))
}
/// Sends multiple buffers as a single packet (gather write).
pub async fn send_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
self.write_with(|device| device.send_vectored(bufs)).await
}
/// Non-blocking version of `send_vectored`.
pub fn try_send_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
self.try_write_io(|device| device.send_vectored(bufs))
}
}
#[cfg(all(target_os = "linux", not(target_env = "ohos")))]
impl AsyncDevice {
/// # Prerequisites
/// - The `IFF_MULTI_QUEUE` flag must be enabled.
/// - The system must support network interface multi-queue functionality.
///
/// # Description
/// When multi-queue is enabled, create a new queue by duplicating an existing one.
pub fn try_clone(&self) -> io::Result<Self> {
AsyncDevice::new_dev(self.get_ref().try_clone()?)
}
/// Recv a packet from the device.
/// If offload is enabled. This method can be used to obtain processed data.
///
/// original_buffer is used to store raw data, including the VirtioNetHdr and the unsplit IP packet. The recommended size is 10 + 65535.
/// bufs and sizes are used to store the segmented IP packets. bufs.len == sizes.len > 65535/MTU
/// offset: Starting position
#[cfg(target_os = "linux")]
pub async fn recv_multiple<B: AsRef<[u8]> + AsMut<[u8]>>(
&self,
original_buffer: &mut [u8],
bufs: &mut [B],
sizes: &mut [usize],
offset: usize,
) -> io::Result<usize> {
if bufs.is_empty() || bufs.len() != sizes.len() {
return Err(io::Error::other("bufs error"));
}
let tun = self.get_ref();
if tun.vnet_hdr {
let len = self.recv(original_buffer).await?;
if len <= VIRTIO_NET_HDR_LEN {
Err(io::Error::other(format!(
"length of packet ({len}) <= VIRTIO_NET_HDR_LEN ({VIRTIO_NET_HDR_LEN})",
)))?
}
let hdr = VirtioNetHdr::decode(&original_buffer[..VIRTIO_NET_HDR_LEN])?;
tun.handle_virtio_read(
hdr,
&mut original_buffer[VIRTIO_NET_HDR_LEN..len],
bufs,
sizes,
offset,
)
} else {
let len = self.recv(&mut bufs[0].as_mut()[offset..]).await?;
sizes[0] = len;
Ok(1)
}
}
/// send multiple fragmented data packets.
/// GROTable can be reused, as it is used to assist in data merging.
/// Offset is the starting position of the data. Need to meet offset>10.
#[cfg(target_os = "linux")]
pub async fn send_multiple<B: crate::platform::ExpandBuffer>(
&self,
gro_table: &mut GROTable,
bufs: &mut [B],
mut offset: usize,
) -> io::Result<usize> {
gro_table.reset();
let tun = self.get_ref();
if tun.vnet_hdr {
handle_gro(
bufs,
offset,
&mut gro_table.tcp_gro_table,
&mut gro_table.udp_gro_table,
tun.udp_gso,
&mut gro_table.to_write,
)?;
offset -= VIRTIO_NET_HDR_LEN;
} else {
for i in 0..bufs.len() {
gro_table.to_write.push(i);
}
}
let mut total = 0;
let mut err = Ok(());
for buf_idx in &gro_table.to_write {
match self.send(&bufs[*buf_idx].as_ref()[offset..]).await {
Ok(n) => {
total += n;
}
Err(e) => {
if let Some(code) = e.raw_os_error() {
if libc::EBADFD == code {
return Err(e);
}
}
err = Err(e)
}
}
}
err?;
Ok(total)
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/async_device/unix/tokio.rs | src/async_device/unix/tokio.rs | use std::io;
use std::task::{Context, Poll};
use crate::platform::DeviceImpl;
use ::tokio::io::unix::AsyncFd as TokioAsyncFd;
use ::tokio::io::Interest;
/// An async Tun/Tap device wrapper around a Tun/Tap device.
///
/// This type does not provide a split method, because this functionality can be achieved by instead wrapping the socket in an Arc.
///
/// # Streams
///
/// If you need to produce a `Stream`, you can look at `DeviceFramed`.
///
/// **Note:** `DeviceFramed` is only available when the `async_framed` feature is enabled.
///
/// [`Stream`]: https://docs.rs/futures/0.3/futures/stream/trait.Stream.html
///
/// # Examples
///
/// ```no_run
/// use tun_rs::{AsyncDevice, DeviceBuilder};
///
/// #[tokio::main]
/// async fn main() -> std::io::Result<()> {
/// // Create a TUN device with basic configuration
/// let dev = DeviceBuilder::new()
/// .name("tun0")
/// .mtu(1500)
/// .ipv4("10.0.0.1", "255.255.255.0", None)
/// .build_async()?;
///
/// // Send a simple packet (Replace with real IP message)
/// let packet = b"[IP Packet: 10.0.0.1 -> 10.0.0.2] Hello, Async TUN!";
/// dev.send(packet).await?;
///
/// // Receive a packet
/// let mut buf = [0u8; 1500];
/// let n = dev.recv(&mut buf).await?;
/// println!("Received {} bytes: {:?}", n, &buf[..n]);
///
/// Ok(())
/// }
/// ```
pub struct AsyncDevice(pub(crate) TokioAsyncFd<DeviceImpl>);
impl AsyncDevice {
/// Polls the I/O handle for readability.
///
/// # Caveats
///
/// Note that on multiple calls to a `poll_*` method in the `recv` direction, only the
/// `Waker` from the `Context` passed to the most recent call will be scheduled to
/// receive a wakeup.
///
/// # Return value
///
/// The function returns:
///
/// * `Poll::Pending` if the device is not ready for reading.
/// * `Poll::Ready(Ok(()))` if the device is ready for reading.
/// * `Poll::Ready(Err(e))` if an error is encountered.
///
/// # Errors
///
/// This function may encounter any standard I/O error except `WouldBlock`.
pub fn poll_readable(&self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
self.0.poll_read_ready(cx).map_ok(|_| ())
}
/// Attempts to receive a single packet from the device
///
/// # Caveats
///
/// Note that on multiple calls to a `poll_*` method in the `recv` direction, only the
/// `Waker` from the `Context` passed to the most recent call will be scheduled to
/// receive a wakeup.
///
/// # Return value
///
/// The function returns:
///
/// * `Poll::Pending` if the device is not ready to read
/// * `Poll::Ready(Ok(()))` reads data `buf` if the device is ready
/// * `Poll::Ready(Err(e))` if an error is encountered.
///
/// # Errors
///
/// This function may encounter any standard I/O error except `WouldBlock`.
pub fn poll_recv(&self, cx: &mut Context<'_>, buf: &mut [u8]) -> Poll<io::Result<usize>> {
loop {
return match self.0.poll_read_ready(cx) {
Poll::Ready(Ok(mut rs)) => {
let n = match rs.try_io(|dev| dev.get_ref().recv(buf)) {
Ok(rs) => rs?,
Err(_) => continue,
};
Poll::Ready(Ok(n))
}
Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
Poll::Pending => Poll::Pending,
};
}
}
/// Polls the I/O handle for writability.
///
/// # Caveats
///
/// Note that on multiple calls to a `poll_*` method in the send direction,
/// only the `Waker` from the `Context` passed to the most recent call will
/// be scheduled to receive a wakeup.
///
/// # Return value
///
/// The function returns:
///
/// * `Poll::Pending` if the device is not ready for writing.
/// * `Poll::Ready(Ok(()))` if the device is ready for writing.
/// * `Poll::Ready(Err(e))` if an error is encountered.
///
/// # Errors
///
/// This function may encounter any standard I/O error except `WouldBlock`.
pub fn poll_writable(&self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
self.0.poll_write_ready(cx).map_ok(|_| ())
}
/// Attempts to send packet to the device
///
/// # Caveats
///
/// Note that on multiple calls to a `poll_*` method in the send direction,
/// only the `Waker` from the `Context` passed to the most recent call will
/// be scheduled to receive a wakeup.
///
/// # Return value
///
/// The function returns:
///
/// * `Poll::Pending` if the device is not available to write
/// * `Poll::Ready(Ok(n))` `n` is the number of bytes sent
/// * `Poll::Ready(Err(e))` if an error is encountered.
///
/// # Errors
///
/// This function may encounter any standard I/O error except `WouldBlock`.
pub fn poll_send(&self, cx: &mut Context<'_>, buf: &[u8]) -> Poll<io::Result<usize>> {
loop {
return match self.0.poll_write_ready(cx) {
Poll::Ready(Ok(mut rs)) => {
let n = match rs.try_io(|dev| dev.get_ref().send(buf)) {
Ok(rs) => rs?,
Err(_) => continue,
};
Poll::Ready(Ok(n))
}
Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
Poll::Pending => Poll::Pending,
};
}
}
}
impl AsyncDevice {
pub(crate) fn new_dev(device: DeviceImpl) -> io::Result<Self> {
device.set_nonblocking(true)?;
Ok(Self(TokioAsyncFd::new(device)?))
}
pub(crate) fn into_device(self) -> io::Result<DeviceImpl> {
Ok(self.0.into_inner())
}
pub(crate) async fn read_with<R>(
&self,
mut op: impl FnMut(&DeviceImpl) -> io::Result<R>,
) -> io::Result<R> {
self.0
.async_io(Interest::READABLE, |device| op(device))
.await
}
pub(crate) async fn write_with<R>(
&self,
mut op: impl FnMut(&DeviceImpl) -> io::Result<R>,
) -> io::Result<R> {
self.0
.async_io(Interest::WRITABLE, |device| op(device))
.await
}
pub(crate) fn try_read_io<R>(
&self,
f: impl FnOnce(&DeviceImpl) -> io::Result<R>,
) -> io::Result<R> {
self.0.try_io(Interest::READABLE, |device| f(device))
}
pub(crate) fn try_write_io<R>(
&self,
f: impl FnOnce(&DeviceImpl) -> io::Result<R>,
) -> io::Result<R> {
self.0.try_io(Interest::WRITABLE, |device| f(device))
}
pub(crate) fn get_ref(&self) -> &DeviceImpl {
self.0.get_ref()
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/async_device/unix/async_io.rs | src/async_device/unix/async_io.rs | use crate::platform::DeviceImpl;
use ::async_io::Async;
use std::io;
use std::task::{Context, Poll};
/// An async Tun/Tap device wrapper around a Tun/Tap device.
///
/// This type does not provide a split method, because this functionality can be achieved by instead wrapping the socket in an Arc.
///
/// # Streams
///
/// If you need to produce a [`Stream`], you can look at [`DeviceFramed`](crate::async_framed::DeviceFramed).
///
/// **Note:** `DeviceFramed` is only available when the `async_framed` feature is enabled.
///
/// [`Stream`]: https://docs.rs/futures/0.3/futures/stream/trait.Stream.html
///
/// # Examples
///
/// ```no_run
/// use tun_rs::{AsyncDevice, DeviceBuilder};
///
/// #[tokio::main]
/// async fn main() -> std::io::Result<()> {
/// // Create a TUN device with basic configuration
/// let dev = DeviceBuilder::new()
/// .name("tun0")
/// .mtu(1500)
/// .ipv4("10.0.0.1", "255.255.255.0", None)
/// .build_async()?;
///
/// // Send a simple packet (Replace with real IP message)
/// let packet = b"[IP Packet: 10.0.0.1 -> 10.0.0.2] Hello, Async TUN!";
/// dev.send(packet).await?;
///
/// // Receive a packet
/// let mut buf = [0u8; 1500];
/// let n = dev.recv(&mut buf).await?;
/// println!("Received {} bytes: {:?}", n, &buf[..n]);
///
/// Ok(())
/// }
/// ```
pub struct AsyncDevice(pub(crate) Async<DeviceImpl>);
impl AsyncDevice {
/// Polls the I/O handle for readability.
///
/// When this method returns [`Poll::Ready`], that means the OS has delivered an event
/// indicating readability since the last time this task has called the method and received
/// [`Poll::Pending`].
///
/// # Caveats
///
/// Two different tasks should not call this method concurrently. Otherwise, conflicting tasks
/// will just keep waking each other in turn, thus wasting CPU time.
///
/// # Return value
///
/// The function returns:
///
/// * `Poll::Pending` if the device is not ready for reading.
/// * `Poll::Ready(Ok(()))` if the device is ready for reading.
/// * `Poll::Ready(Err(e))` if an error is encountered.
///
/// # Errors
///
/// This function may encounter any standard I/O error except `WouldBlock`.
pub fn poll_readable(&self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
self.0.poll_readable(cx)
}
/// Attempts to receive a single packet from the device
///
/// # Caveats
///
/// Two different tasks should not call this method concurrently. Otherwise, conflicting tasks
/// will just keep waking each other in turn, thus wasting CPU time.
///
/// # Return value
///
/// The function returns:
///
/// * `Poll::Pending` if the device is not ready to read
/// * `Poll::Ready(Ok(()))` reads data `buf` if the device is ready
/// * `Poll::Ready(Err(e))` if an error is encountered.
///
/// # Errors
///
/// This function may encounter any standard I/O error except `WouldBlock`.
pub fn poll_recv(&self, cx: &mut Context<'_>, buf: &mut [u8]) -> Poll<io::Result<usize>> {
match self.0.get_ref().recv(buf) {
Err(e) if e.kind() == io::ErrorKind::WouldBlock => {}
rs => return Poll::Ready(rs),
}
match self.0.poll_readable(cx) {
Poll::Ready(Ok(())) => Poll::Ready(self.0.get_ref().recv(buf)),
Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
Poll::Pending => Poll::Pending,
}
}
/// Polls the I/O handle for writability.
///
/// When this method returns [`Poll::Ready`], that means the OS has delivered an event
/// indicating writability since the last time this task has called the method and received
/// [`Poll::Pending`].
///
/// # Caveats
///
/// Two different tasks should not call this method concurrently. Otherwise, conflicting tasks
/// will just keep waking each other in turn, thus wasting CPU time.
///
/// # Return value
///
/// The function returns:
///
/// * `Poll::Pending` if the device is not ready for writing.
/// * `Poll::Ready(Ok(()))` if the device is ready for writing.
/// * `Poll::Ready(Err(e))` if an error is encountered.
///
/// # Errors
///
/// This function may encounter any standard I/O error except `WouldBlock`.
pub fn poll_writable(&self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
self.0.poll_writable(cx)
}
/// Attempts to send packet to the device
///
/// # Caveats
///
/// Two different tasks should not call this method concurrently. Otherwise, conflicting tasks
/// will just keep waking each other in turn, thus wasting CPU time.
/// # Return value
///
/// The function returns:
///
/// * `Poll::Pending` if the device is not available to write
/// * `Poll::Ready(Ok(n))` `n` is the number of bytes sent
/// * `Poll::Ready(Err(e))` if an error is encountered.
///
/// # Errors
///
/// This function may encounter any standard I/O error except `WouldBlock`.
pub fn poll_send(&self, cx: &mut Context<'_>, buf: &[u8]) -> Poll<io::Result<usize>> {
match self.0.get_ref().send(buf) {
Err(e) if e.kind() == io::ErrorKind::WouldBlock => {}
rs => return Poll::Ready(rs),
}
match self.0.poll_writable(cx) {
Poll::Ready(Ok(())) => Poll::Ready(self.0.get_ref().send(buf)),
Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
Poll::Pending => Poll::Pending,
}
}
}
impl AsyncDevice {
pub(crate) fn new_dev(device: DeviceImpl) -> io::Result<Self> {
Ok(Self(Async::new(device)?))
}
pub(crate) fn into_device(self) -> io::Result<DeviceImpl> {
self.0.into_inner()
}
pub(crate) async fn read_with<R>(
&self,
op: impl FnMut(&DeviceImpl) -> io::Result<R>,
) -> io::Result<R> {
self.0.read_with(op).await
}
pub(crate) async fn write_with<R>(
&self,
op: impl FnMut(&DeviceImpl) -> io::Result<R>,
) -> io::Result<R> {
self.0.write_with(op).await
}
pub(crate) fn try_read_io<R>(
&self,
f: impl FnOnce(&DeviceImpl) -> io::Result<R>,
) -> io::Result<R> {
f(self.0.get_ref())
}
pub(crate) fn try_write_io<R>(
&self,
f: impl FnOnce(&DeviceImpl) -> io::Result<R>,
) -> io::Result<R> {
f(self.0.get_ref())
}
pub(crate) fn get_ref(&self) -> &DeviceImpl {
self.0.get_ref()
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/async_device/windows/mod.rs | src/async_device/windows/mod.rs | use crate::platform::windows::{ffi, InterruptEvent};
use crate::platform::DeviceImpl;
use crate::SyncDevice;
use std::future::Future;
use std::io;
use std::ops::Deref;
use std::os::windows::io::{AsRawHandle, OwnedHandle};
use std::pin::Pin;
use std::sync::{Arc, Mutex};
use std::task::{Context, Poll};
/// An async Tun/Tap device wrapper around a Tun/Tap device.
///
/// This type does not provide a split method, because this functionality can be achieved by instead wrapping the device in an Arc.
///
/// # Streams
///
/// If you need to produce a [`Stream`], you can look at [`DeviceFramed`](crate::async_framed::DeviceFramed).
///
/// **Note:** `DeviceFramed` is only available when the `async_framed` feature is enabled.
///
/// [`Stream`]: https://docs.rs/futures/0.3/futures/stream/trait.Stream.html
///
/// # Examples
///
/// ```no_run
/// use tun_rs::{AsyncDevice, DeviceBuilder};
///
/// #[tokio::main]
/// async fn main() -> std::io::Result<()> {
/// // Create a TUN device with basic configuration
/// let dev = DeviceBuilder::new()
/// .name("tun0")
/// .mtu(1500)
/// .ipv4("10.0.0.1", "255.255.255.0", None)
/// .build_async()?;
///
/// // Send a simple packet (Replace with real IP message)
/// let packet = b"[IP Packet: 10.0.0.1 -> 10.0.0.2] Hello, Async TUN!";
/// dev.send(packet).await?;
///
/// // Receive a packet
/// let mut buf = [0u8; 1500];
/// let n = dev.recv(&mut buf).await?;
/// println!("Received {} bytes: {:?}", n, &buf[..n]);
///
/// Ok(())
/// }
/// ```
pub struct AsyncDevice {
inner: Arc<DeviceImpl>,
recv_task_lock: Arc<Mutex<Option<RecvTask>>>,
send_task_lock: Arc<Mutex<Option<SendTask>>>,
}
type RecvTask = blocking::Task<io::Result<(Vec<u8>, usize)>>;
type SendTask = blocking::Task<io::Result<usize>>;
impl Deref for AsyncDevice {
type Target = DeviceImpl;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl Drop for AsyncDevice {
fn drop(&mut self) {
_ = self.inner.shutdown();
}
}
impl AsyncDevice {
/// Creates a new async wrapper around a TUN/TAP device
pub fn new(device: SyncDevice) -> io::Result<AsyncDevice> {
AsyncDevice::new_dev(device.0)
}
/// Create a new `AsyncDevice` wrapping around a `Device`.
pub(crate) fn new_dev(device: DeviceImpl) -> io::Result<AsyncDevice> {
let inner = Arc::new(device);
Ok(AsyncDevice {
inner,
recv_task_lock: Arc::new(Mutex::new(None)),
send_task_lock: Arc::new(Mutex::new(None)),
})
}
/// Attempts to receive a single packet from the device
///
/// # Caveats
///
/// Two different tasks should not call this method concurrently. Otherwise, conflicting tasks
/// will just keep waking each other in turn, thus wasting CPU time.
///
/// # Return value
///
/// The function returns:
///
/// * `Poll::Pending` if the device is not ready to read
/// * `Poll::Ready(Ok(()))` reads data `buf` if the device is ready
/// * `Poll::Ready(Err(e))` if an error is encountered.
///
/// # Errors
///
/// This function may encounter any standard I/O error except `WouldBlock`.
pub fn poll_recv(&self, cx: &mut Context<'_>, mut buf: &mut [u8]) -> Poll<io::Result<usize>> {
match self.try_recv(buf) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
rs => return Poll::Ready(rs),
}
let mut guard = self.recv_task_lock.lock().unwrap();
let mut task = if let Some(task) = guard.take() {
task
} else {
let device = self.inner.clone();
let size = buf.len();
blocking::unblock(move || {
let mut in_buf = vec![0; size];
let n = device.recv(&mut in_buf)?;
Ok((in_buf, n))
})
};
match Pin::new(&mut task).poll(cx) {
Poll::Ready(rs) => {
drop(guard);
match rs {
Ok((packet, n)) => {
let mut packet: &[u8] = &packet[..n];
match io::copy(&mut packet, &mut buf) {
Ok(n) => Poll::Ready(Ok(n as usize)),
Err(e) => Poll::Ready(Err(e)),
}
}
Err(e) => Poll::Ready(Err(e)),
}
}
Poll::Pending => {
guard.replace(task);
Poll::Pending
}
}
}
/// Attempts to send packet to the device
///
/// # Caveats
///
/// Two different tasks should not call this method concurrently. Otherwise, conflicting tasks
/// will just keep waking each other in turn, thus wasting CPU time.
///
/// # Return value
///
/// The function returns:
///
/// * `Poll::Pending` if the device is not available to write
/// * `Poll::Ready(Ok(n))` `n` is the number of bytes sent
/// * `Poll::Ready(Err(e))` if an error is encountered.
///
/// # Errors
///
/// This function may encounter any standard I/O error except `WouldBlock`.
pub fn poll_send(&self, cx: &mut Context<'_>, src: &[u8]) -> Poll<io::Result<usize>> {
match self.try_send(src) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
rs => return Poll::Ready(rs),
}
let mut guard = self.send_task_lock.lock().unwrap();
loop {
if let Some(mut task) = guard.take() {
match Pin::new(&mut task).poll(cx) {
Poll::Ready(rs) => {
// If the previous write was successful, continue.
// Otherwise, error.
rs?;
continue;
}
Poll::Pending => {
guard.replace(task);
return Poll::Pending;
}
}
} else {
let device = self.inner.clone();
let buf = src.to_vec();
let task = blocking::unblock(move || device.send(&buf));
guard.replace(task);
drop(guard);
return Poll::Ready(Ok(src.len()));
};
}
}
/// Waits for the device to become readable.
///
/// This function is usually paired with `try_recv()`.
///
/// The function may complete without the device being readable. This is a
/// false-positive and attempting a `try_recv()` will return with
/// `io::ErrorKind::WouldBlock`.
///
/// # Cancel safety
///
/// This method is cancel safe. Once a readiness event occurs, the method
/// will continue to return immediately until the readiness event is
/// consumed by an attempt to read that fails with `WouldBlock` or
/// `Poll::Pending`.
pub async fn readable(&self) -> io::Result<()> {
let mut canceller = Canceller::new_cancelable()?;
let device = self.inner.clone();
let (cancel_guard, exit_guard) = canceller.guard(device);
blocking::unblock(move || {
exit_guard.call(|device, cancel_event_handle| {
device.wait_readable_interruptible(cancel_event_handle, None)
})
})
.await?;
std::mem::forget(cancel_guard);
Ok(())
}
/// Recv a packet from the device
pub async fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
loop {
match self.try_recv(buf) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
rs => return rs,
}
self.readable().await?;
}
}
/// Attempts to read a packet without blocking.
pub fn try_recv(&self, buf: &mut [u8]) -> io::Result<usize> {
self.inner.try_recv(buf)
}
/// Send a packet to the device
///
/// # Cancel safety
/// This method is not cancellation safe.
/// After cancellation, it is uncertain whether the data has been written or not.
pub async fn send(&self, buf: &[u8]) -> io::Result<usize> {
match self.inner.try_send(buf) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
rs => return rs,
}
let buf = buf.to_vec();
let device = self.inner.clone();
let mut canceller = Canceller::new_cancelable()?;
let (cancel_guard, exit_guard) = canceller.guard(device);
let result = blocking::unblock(move || {
exit_guard.call(|device, cancel_event_handle| {
device.write_interruptible(&buf, cancel_event_handle)
})
})
.await;
std::mem::forget(cancel_guard);
result
}
/// Attempts to write a packet without blocking.
pub fn try_send(&self, buf: &[u8]) -> io::Result<usize> {
self.inner.try_send(buf)
}
}
struct ExitSignalGuard {
device: Option<Arc<DeviceImpl>>,
cancel_event_handle: Arc<InterruptEvent>,
exit_event: Arc<OwnedHandle>,
}
impl Drop for ExitSignalGuard {
fn drop(&mut self) {
drop(self.device.take());
_ = ffi::set_event(self.exit_event.as_raw_handle());
}
}
impl ExitSignalGuard {
pub fn call<R>(
&self,
mut op: impl FnMut(&DeviceImpl, &InterruptEvent) -> io::Result<R>,
) -> io::Result<R> {
if let Some(device) = &self.device {
op(device, &self.cancel_event_handle)
} else {
unreachable!()
}
}
}
struct Canceller {
exit_event_handle: Arc<OwnedHandle>,
cancel_event_handle: Arc<InterruptEvent>,
}
impl Canceller {
fn new_cancelable() -> io::Result<Self> {
Ok(Self {
exit_event_handle: Arc::new(ffi::create_event()?),
cancel_event_handle: Arc::new(InterruptEvent::new()?),
})
}
fn guard(&mut self, device_impl: Arc<DeviceImpl>) -> (CancelWaitGuard<'_>, ExitSignalGuard) {
(
CancelWaitGuard {
exit_event_handle: &self.exit_event_handle,
cancel_event_handle: &self.cancel_event_handle,
},
ExitSignalGuard {
device: Some(device_impl),
exit_event: self.exit_event_handle.clone(),
cancel_event_handle: self.cancel_event_handle.clone(),
},
)
}
}
struct CancelWaitGuard<'a> {
exit_event_handle: &'a Arc<OwnedHandle>,
cancel_event_handle: &'a Arc<InterruptEvent>,
}
impl Drop for CancelWaitGuard<'_> {
fn drop(&mut self) {
_ = self.cancel_event_handle.trigger();
_ = ffi::wait_for_single_object(self.exit_event_handle.as_raw_handle(), 10);
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/async_device/macos/select_io.rs | src/async_device/macos/select_io.rs | use crate::DeviceImpl;
use std::cmp::Ordering;
use std::future::Future;
use std::io;
use std::io::{IoSlice, IoSliceMut};
use std::ops::Deref;
use std::os::fd::AsRawFd;
use std::pin::Pin;
use std::sync::{Arc, Mutex};
use std::task::{Context, Poll};
use std::time::Duration;
pub(crate) struct NonBlockingDevice {
device: DeviceImpl,
shutdown_event: EventFd,
}
impl NonBlockingDevice {
pub(crate) fn new_dev(device: DeviceImpl) -> io::Result<Self> {
device.set_nonblocking(true)?;
Ok(Self {
device,
shutdown_event: EventFd::new()?,
})
}
pub fn try_recv(&self, buf: &mut [u8]) -> io::Result<usize> {
self.device.recv(buf)
}
pub fn try_send(&self, buf: &[u8]) -> io::Result<usize> {
self.device.send(buf)
}
pub fn try_recv_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
self.device.recv_vectored(bufs)
}
pub fn try_send_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
self.device.send_vectored(bufs)
}
pub(crate) fn shutdown(&self) -> io::Result<()> {
self.shutdown_event.wake()
}
}
impl NonBlockingDevice {
pub fn wait_writable(&self, cancel_event: Option<libc::c_int>) -> io::Result<()> {
let readfds: libc::fd_set = unsafe { std::mem::zeroed() };
let mut writefds: libc::fd_set = unsafe { std::mem::zeroed() };
let fd = self.device.as_raw_fd();
unsafe {
libc::FD_SET(fd, &mut writefds);
}
self.wait(readfds, writefds, cancel_event)
}
pub fn wait_readable(&self, cancel_event: Option<libc::c_int>) -> io::Result<()> {
let mut readfds: libc::fd_set = unsafe { std::mem::zeroed() };
let writefds: libc::fd_set = unsafe { std::mem::zeroed() };
let fd = self.device.as_raw_fd();
unsafe {
libc::FD_SET(fd, &mut readfds);
}
self.wait(readfds, writefds, cancel_event)
}
fn wait(
&self,
mut readfds: libc::fd_set,
mut writefds: libc::fd_set,
cancel_event: Option<libc::c_int>,
) -> io::Result<()> {
let fd = self.device.as_raw_fd();
let event_fd = self.shutdown_event.as_event_fd();
let mut errorfds: libc::fd_set = unsafe { std::mem::zeroed() };
let mut nfds = fd.max(event_fd);
unsafe {
libc::FD_SET(event_fd, &mut readfds);
if let Some(cancel_event) = cancel_event {
libc::FD_SET(cancel_event, &mut readfds);
nfds = nfds.max(cancel_event);
}
}
let result = unsafe {
libc::select(
nfds + 1,
&mut readfds,
&mut writefds,
&mut errorfds,
std::ptr::null_mut(),
)
};
if result < 0 {
return Err(io::Error::last_os_error());
}
if result == 0 {
return Err(io::Error::from(io::ErrorKind::TimedOut));
}
unsafe {
if libc::FD_ISSET(event_fd, &readfds) {
return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "close"));
}
if let Some(cancel_event) = cancel_event {
if libc::FD_ISSET(cancel_event, &readfds) {
return Err(io::Error::new(io::ErrorKind::Interrupted, "cancel"));
}
}
}
Ok(())
}
}
struct EventFd(libc::c_int, libc::c_int);
impl EventFd {
fn new() -> io::Result<Self> {
let mut fds = [0 as libc::c_int; 2];
if unsafe { libc::pipe(fds.as_mut_ptr()) } == -1 {
return Err(io::Error::last_os_error());
}
let read_fd = fds[0];
let write_fd = fds[1];
Ok(Self(read_fd, write_fd))
}
fn wake(&self) -> io::Result<()> {
let buf: [u8; 8] = 2u64.to_ne_bytes();
let res = unsafe { libc::write(self.1, buf.as_ptr() as *const libc::c_void, buf.len()) };
if res == -1 {
Err(io::Error::last_os_error())
} else {
Ok(())
}
}
fn wait_timeout(&self, timeout: Duration) -> io::Result<()> {
let mut readfds = unsafe {
let mut set = std::mem::zeroed::<libc::fd_set>();
libc::FD_ZERO(&mut set);
libc::FD_SET(self.0, &mut set);
set
};
let mut tv = libc::timeval {
tv_sec: timeout.as_secs() as libc::time_t,
tv_usec: timeout.subsec_micros() as libc::suseconds_t,
};
let res = unsafe {
libc::select(
self.0 + 1,
&mut readfds,
std::ptr::null_mut(),
std::ptr::null_mut(),
&mut tv,
)
};
match res.cmp(&0) {
Ordering::Less => Err(io::Error::last_os_error()),
Ordering::Equal => Err(io::Error::from(io::ErrorKind::TimedOut)),
Ordering::Greater => Ok(()),
}
}
fn as_event_fd(&self) -> libc::c_int {
self.0
}
}
impl Drop for EventFd {
fn drop(&mut self) {
unsafe {
let _ = libc::close(self.0);
let _ = libc::close(self.1);
}
}
}
pub struct AsyncDevice {
inner: Arc<NonBlockingDevice>,
recv_task_lock: Arc<Mutex<Option<blocking::Task<io::Result<()>>>>>,
send_task_lock: Arc<Mutex<Option<blocking::Task<io::Result<()>>>>>,
}
impl Deref for AsyncDevice {
type Target = DeviceImpl;
fn deref(&self) -> &Self::Target {
&self.inner.device
}
}
impl Drop for AsyncDevice {
fn drop(&mut self) {
_ = self.inner.shutdown();
}
}
impl AsyncDevice {
pub(crate) fn new_dev(device: DeviceImpl) -> io::Result<AsyncDevice> {
let inner = Arc::new(NonBlockingDevice::new_dev(device)?);
Ok(AsyncDevice {
inner,
recv_task_lock: Arc::new(Mutex::new(None)),
send_task_lock: Arc::new(Mutex::new(None)),
})
}
}
impl AsyncDevice {
pub async fn readable(&self) -> io::Result<()> {
let device = self.inner.clone();
let mut canceller = Canceller::new_cancelable()?;
let (cancel_guard, exit_guard) = canceller.guard(device);
blocking::unblock(move || {
exit_guard
.call(|device, cancel_event| device.wait_readable(Some(cancel_event.as_event_fd())))
})
.await?;
std::mem::forget(cancel_guard);
Ok(())
}
pub async fn writable(&self) -> io::Result<()> {
let device = self.inner.clone();
let mut canceller = Canceller::new_cancelable()?;
let (cancel_guard, exit_guard) = canceller.guard(device);
blocking::unblock(move || {
exit_guard
.call(|device, cancel_event| device.wait_writable(Some(cancel_event.as_event_fd())))
})
.await?;
std::mem::forget(cancel_guard);
Ok(())
}
pub fn poll_readable(&self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
let mut guard = self.recv_task_lock.lock().unwrap();
let mut task = if let Some(task) = guard.take() {
task
} else {
let device = self.inner.clone();
blocking::unblock(move || device.wait_readable(None))
};
match Pin::new(&mut task).poll(cx) {
Poll::Ready(rs) => {
drop(guard);
match rs {
Ok(_) => Poll::Ready(Ok(())),
Err(e) => Poll::Ready(Err(e)),
}
}
Poll::Pending => {
guard.replace(task);
Poll::Pending
}
}
}
pub fn poll_recv(&self, cx: &mut Context<'_>, buf: &mut [u8]) -> Poll<io::Result<usize>> {
loop {
match self.try_recv(buf) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
rs => return Poll::Ready(rs),
}
match self.poll_readable(cx)? {
Poll::Ready(_) => {}
Poll::Pending => {
return Poll::Pending;
}
}
}
}
pub fn poll_writable(&self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
let mut guard = self.send_task_lock.lock().unwrap();
let mut task = if let Some(task) = guard.take() {
task
} else {
let device = self.inner.clone();
blocking::unblock(move || device.wait_writable(None))
};
match Pin::new(&mut task).poll(cx) {
Poll::Ready(rs) => match rs {
Ok(_) => Poll::Ready(Ok(())),
Err(e) => Poll::Ready(Err(e)),
},
Poll::Pending => {
guard.replace(task);
Poll::Pending
}
}
}
pub fn poll_send(&self, cx: &mut Context<'_>, buf: &[u8]) -> Poll<io::Result<usize>> {
loop {
match self.try_send(buf) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
rs => return Poll::Ready(rs),
}
match self.poll_writable(cx)? {
Poll::Ready(_) => {}
Poll::Pending => {
return Poll::Pending;
}
}
}
}
pub async fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
loop {
match self.try_recv(buf) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
rs => return rs,
}
self.readable().await?;
}
}
pub fn try_recv(&self, buf: &mut [u8]) -> io::Result<usize> {
self.inner.try_recv(buf)
}
pub async fn send(&self, buf: &[u8]) -> io::Result<usize> {
loop {
match self.try_send(buf) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
rs => return rs,
}
self.writable().await?;
}
}
pub fn try_send(&self, buf: &[u8]) -> io::Result<usize> {
self.inner.try_send(buf)
}
pub async fn recv_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
loop {
match self.try_recv_vectored(bufs) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
rs => return rs,
}
self.readable().await?;
}
}
pub fn try_recv_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
self.inner.try_recv_vectored(bufs)
}
pub async fn send_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
loop {
match self.try_send_vectored(bufs) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
rs => return rs,
}
self.writable().await?;
}
}
pub fn try_send_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
self.inner.try_send_vectored(bufs)
}
}
struct ExitSignalGuard {
device: Option<Arc<NonBlockingDevice>>,
cancel_event_handle: Arc<EventFd>,
exit_event: Arc<EventFd>,
}
impl Drop for ExitSignalGuard {
fn drop(&mut self) {
drop(self.device.take());
_ = self.exit_event.wake();
}
}
impl ExitSignalGuard {
pub fn call<R>(
&self,
mut op: impl FnMut(&NonBlockingDevice, &EventFd) -> io::Result<R>,
) -> io::Result<R> {
if let Some(device) = &self.device {
op(device, &self.cancel_event_handle)
} else {
unreachable!()
}
}
}
struct Canceller {
exit_event_handle: Arc<EventFd>,
cancel_event_handle: Arc<EventFd>,
}
impl Canceller {
fn new_cancelable() -> io::Result<Self> {
Ok(Self {
exit_event_handle: Arc::new(EventFd::new()?),
cancel_event_handle: Arc::new(EventFd::new()?),
})
}
fn guard(
&mut self,
device_impl: Arc<NonBlockingDevice>,
) -> (CancelWaitGuard<'_>, ExitSignalGuard) {
(
CancelWaitGuard {
exit_event_handle: &self.exit_event_handle,
cancel_event_handle: &self.cancel_event_handle,
},
ExitSignalGuard {
device: Some(device_impl),
exit_event: self.exit_event_handle.clone(),
cancel_event_handle: self.cancel_event_handle.clone(),
},
)
}
}
struct CancelWaitGuard<'a> {
exit_event_handle: &'a Arc<EventFd>,
cancel_event_handle: &'a Arc<EventFd>,
}
impl Drop for CancelWaitGuard<'_> {
fn drop(&mut self) {
if self.cancel_event_handle.wake().is_ok() {
_ = self
.exit_event_handle
.wait_timeout(Duration::from_millis(1))
}
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/async_device/macos/mod.rs | src/async_device/macos/mod.rs | use crate::async_device::unix;
use crate::{DeviceImpl, SyncDevice};
use std::io;
use std::io::{IoSlice, IoSliceMut};
use std::ops::Deref;
use std::os::fd::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
use std::task::{Context, Poll};
mod select_io;
/// An async Tun/Tap device wrapper around a Tun/Tap device.
///
/// This type does not provide a split method, because this functionality can be achieved by instead wrapping the socket in an Arc.
///
/// # Streams
///
/// If you need to produce a [`Stream`], you can look at [`DeviceFramed`](crate::async_framed::DeviceFramed).
///
/// **Note:** `DeviceFramed` is only available when the `async_framed` feature is enabled.
///
/// [`Stream`]: https://docs.rs/futures/0.3/futures/stream/trait.Stream.html
///
/// # Examples
///
/// ```no_run
/// use tun_rs::{AsyncDevice, DeviceBuilder};
///
/// #[tokio::main]
/// async fn main() -> std::io::Result<()> {
/// // Create a TUN device with basic configuration
/// let dev = DeviceBuilder::new()
/// .name("tun0")
/// .mtu(1500)
/// .ipv4("10.0.0.1", "255.255.255.0", None)
/// .build_async()?;
///
/// // Send a simple packet (Replace with real IP message)
/// let packet = b"[IP Packet: 10.0.0.1 -> 10.0.0.2] Hello, Async TUN!";
/// dev.send(packet).await?;
///
/// // Receive a packet
/// let mut buf = [0u8; 1500];
/// let n = dev.recv(&mut buf).await?;
/// println!("Received {} bytes: {:?}", n, &buf[..n]);
///
/// Ok(())
/// }
/// ```
pub struct AsyncDevice {
async_model: AsyncModel,
}
impl Deref for AsyncDevice {
type Target = DeviceImpl;
fn deref(&self) -> &Self::Target {
self.async_model.as_device()
}
}
enum AsyncModel {
Async(unix::AsyncDevice),
Select(select_io::AsyncDevice),
}
impl AsyncModel {
fn as_device(&self) -> &DeviceImpl {
match &self {
AsyncModel::Async(dev) => dev,
AsyncModel::Select(dev) => dev,
}
}
}
impl FromRawFd for AsyncDevice {
unsafe fn from_raw_fd(fd: RawFd) -> Self {
AsyncDevice::from_fd(fd).unwrap()
}
}
impl IntoRawFd for AsyncDevice {
fn into_raw_fd(self) -> RawFd {
self.into_fd().unwrap()
}
}
impl AsRawFd for AsyncDevice {
fn as_raw_fd(&self) -> RawFd {
self.async_model.as_device().as_raw_fd()
}
}
impl AsyncDevice {
pub fn new(device: SyncDevice) -> io::Result<AsyncDevice> {
AsyncDevice::new_dev(device.0)
}
/// # Safety
/// This method is safe if the provided fd is valid
/// Construct a AsyncDevice from an existing file descriptor
pub unsafe fn from_fd(fd: RawFd) -> io::Result<AsyncDevice> {
AsyncDevice::new_dev(DeviceImpl::from_fd(fd)?)
}
/// # Safety
/// The fd passed in must be a valid, open file descriptor.
/// Unlike [`from_fd`], this function does **not** take ownership of `fd`,
/// and therefore will not close it when dropped.
/// The caller is responsible for ensuring the lifetime and eventual closure of `fd`.
pub(crate) unsafe fn borrow_raw(fd: RawFd) -> io::Result<Self> {
AsyncDevice::new_dev(DeviceImpl::borrow_raw(fd)?)
}
pub fn into_fd(self) -> io::Result<RawFd> {
match self.async_model {
AsyncModel::Async(dev) => Ok(dev.into_device()?.into_raw_fd()),
AsyncModel::Select(_) => Err(io::Error::new(
io::ErrorKind::Unsupported,
"into_raw_fd operation is not supported for feth/bpf devices",
)),
}
}
pub(crate) fn new_dev(device: DeviceImpl) -> io::Result<Self> {
let async_model = if device.tun.is_tun() {
AsyncModel::Async(unix::AsyncDevice::new_dev(device)?)
} else {
AsyncModel::Select(select_io::AsyncDevice::new_dev(device)?)
};
Ok(Self { async_model })
}
}
impl AsyncDevice {
/// Waits for the device to become readable.
///
/// This function is usually paired with `try_recv()`.
///
/// The function may complete without the device being readable. This is a
/// false-positive and attempting a `try_recv()` will return with
/// `io::ErrorKind::WouldBlock`.
///
/// # Cancel safety
///
/// This method is cancel safe. Once a readiness event occurs, the method
/// will continue to return immediately until the readiness event is
/// consumed by an attempt to read that fails with `WouldBlock` or
/// `Poll::Pending`.
pub async fn readable(&self) -> io::Result<()> {
match &self.async_model {
AsyncModel::Async(dev) => dev.readable().await,
AsyncModel::Select(dev) => dev.readable().await,
}
}
/// Waits for the device to become writable.
///
/// This function is usually paired with `try_send()`.
///
/// The function may complete without the device being writable. This is a
/// false-positive and attempting a `try_send()` will return with
/// `io::ErrorKind::WouldBlock`.
///
/// # Cancel safety
///
/// This method is cancel safe. Once a readiness event occurs, the method
/// will continue to return immediately until the readiness event is
/// consumed by an attempt to write that fails with `WouldBlock` or
/// `Poll::Pending`.
pub async fn writable(&self) -> io::Result<()> {
match &self.async_model {
AsyncModel::Async(dev) => dev.writable().await,
AsyncModel::Select(dev) => dev.writable().await,
}
}
/// Polls the I/O handle for readability.
///
/// # Caveats
///
/// Note that on multiple calls to a `poll_*` method in the `recv` direction, only the
/// `Waker` from the `Context` passed to the most recent call will be scheduled to
/// receive a wakeup.
///
/// # Return value
///
/// The function returns:
///
/// * `Poll::Pending` if the device is not ready for reading.
/// * `Poll::Ready(Ok(()))` if the device is ready for reading.
/// * `Poll::Ready(Err(e))` if an error is encountered.
///
/// # Errors
///
/// This function may encounter any standard I/O error except `WouldBlock`.
pub fn poll_readable(&self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
match &self.async_model {
AsyncModel::Async(dev) => dev.poll_readable(cx),
AsyncModel::Select(dev) => dev.poll_readable(cx),
}
}
/// Attempts to receive a single packet from the device
///
/// # Caveats
///
/// Note that on multiple calls to a `poll_*` method in the `recv` direction, only the
/// `Waker` from the `Context` passed to the most recent call will be scheduled to
/// receive a wakeup.
///
/// # Return value
///
/// The function returns:
///
/// * `Poll::Pending` if the device is not ready to read
/// * `Poll::Ready(Ok(()))` reads data `buf` if the device is ready
/// * `Poll::Ready(Err(e))` if an error is encountered.
///
/// # Errors
///
/// This function may encounter any standard I/O error except `WouldBlock`.
pub fn poll_recv(&self, cx: &mut Context<'_>, buf: &mut [u8]) -> Poll<io::Result<usize>> {
match &self.async_model {
AsyncModel::Async(dev) => dev.poll_recv(cx, buf),
AsyncModel::Select(dev) => dev.poll_recv(cx, buf),
}
}
/// Polls the I/O handle for writability.
///
/// # Caveats
///
/// Note that on multiple calls to a `poll_*` method in the send direction,
/// only the `Waker` from the `Context` passed to the most recent call will
/// be scheduled to receive a wakeup.
///
/// # Return value
///
/// The function returns:
///
/// * `Poll::Pending` if the device is not ready for writing.
/// * `Poll::Ready(Ok(()))` if the device is ready for writing.
/// * `Poll::Ready(Err(e))` if an error is encountered.
///
/// # Errors
///
/// This function may encounter any standard I/O error except `WouldBlock`.
pub fn poll_writable(&self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
match &self.async_model {
AsyncModel::Async(dev) => dev.poll_writable(cx),
AsyncModel::Select(dev) => dev.poll_writable(cx),
}
}
/// Attempts to send packet to the device
///
/// # Caveats
///
/// Note that on multiple calls to a `poll_*` method in the send direction,
/// only the `Waker` from the `Context` passed to the most recent call will
/// be scheduled to receive a wakeup.
///
/// # Return value
///
/// The function returns:
///
/// * `Poll::Pending` if the device is not available to write
/// * `Poll::Ready(Ok(n))` `n` is the number of bytes sent
/// * `Poll::Ready(Err(e))` if an error is encountered.
///
/// # Errors
///
/// This function may encounter any standard I/O error except `WouldBlock`.
pub fn poll_send(&self, cx: &mut Context<'_>, buf: &[u8]) -> Poll<io::Result<usize>> {
match &self.async_model {
AsyncModel::Async(dev) => dev.poll_send(cx, buf),
AsyncModel::Select(dev) => dev.poll_send(cx, buf),
}
}
/// Receives a single packet from the device.
/// On success, returns the number of bytes read.
///
/// The function must be called with valid byte array `buf` of sufficient
/// size to hold the message bytes. If a message is too long to fit in the
/// supplied buffer, excess bytes may be discarded.
pub async fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
match &self.async_model {
AsyncModel::Async(dev) => dev.recv(buf).await,
AsyncModel::Select(dev) => dev.recv(buf).await,
}
}
/// Tries to receive a single packet from the device.
/// On success, returns the number of bytes read.
///
/// This method must be called with valid byte array `buf` of sufficient size
/// to hold the message bytes. If a message is too long to fit in the
/// supplied buffer, excess bytes may be discarded.
///
/// When there is no pending data, `Err(io::ErrorKind::WouldBlock)` is
/// returned. This function is usually paired with `readable()`.
pub fn try_recv(&self, buf: &mut [u8]) -> io::Result<usize> {
match &self.async_model {
AsyncModel::Async(dev) => dev.try_recv(buf),
AsyncModel::Select(dev) => dev.try_recv(buf),
}
}
/// Send a packet to the device
///
/// # Return
/// On success, the number of bytes sent is returned, otherwise, the encountered error is returned.
pub async fn send(&self, buf: &[u8]) -> io::Result<usize> {
match &self.async_model {
AsyncModel::Async(dev) => dev.send(buf).await,
AsyncModel::Select(dev) => dev.send(buf).await,
}
}
/// Tries to send packet to the device.
///
/// When the device buffer is full, `Err(io::ErrorKind::WouldBlock)` is
/// returned. This function is usually paired with `writable()`.
///
/// # Returns
///
/// If successful, `Ok(n)` is returned, where `n` is the number of bytes
/// sent. If the device is not ready to send data,
/// `Err(ErrorKind::WouldBlock)` is returned.
pub fn try_send(&self, buf: &[u8]) -> io::Result<usize> {
match &self.async_model {
AsyncModel::Async(dev) => dev.try_send(buf),
AsyncModel::Select(dev) => dev.try_send(buf),
}
}
/// Receives a packet into multiple buffers (scatter read).
/// **Processes single packet per call**.
pub async fn recv_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
match &self.async_model {
AsyncModel::Async(dev) => dev.recv_vectored(bufs).await,
AsyncModel::Select(dev) => dev.recv_vectored(bufs).await,
}
}
/// Non-blocking version of `recv_vectored`.
pub fn try_recv_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
match &self.async_model {
AsyncModel::Async(dev) => dev.try_recv_vectored(bufs),
AsyncModel::Select(dev) => dev.try_recv_vectored(bufs),
}
}
/// Sends multiple buffers as a single packet (gather write).
pub async fn send_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
match &self.async_model {
AsyncModel::Async(dev) => dev.send_vectored(bufs).await,
AsyncModel::Select(dev) => dev.send_vectored(bufs).await,
}
}
/// Non-blocking version of `send_vectored`.
pub fn try_send_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
match &self.async_model {
AsyncModel::Async(dev) => dev.try_send_vectored(bufs),
AsyncModel::Select(dev) => dev.try_send_vectored(bufs),
}
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/mod.rs | src/platform/mod.rs | #[cfg(unix)]
pub(crate) mod unix;
#[cfg(all(
unix,
not(any(
target_os = "windows",
target_os = "macos",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))
))]
pub use self::unix::DeviceImpl;
#[cfg(unix)]
#[cfg(feature = "interruptible")]
pub use unix::InterruptEvent;
#[cfg(windows)]
#[cfg(feature = "interruptible")]
pub use windows::InterruptEvent;
#[cfg(all(target_os = "linux", not(target_env = "ohos")))]
pub(crate) mod linux;
#[cfg(all(target_os = "linux", not(target_env = "ohos")))]
pub use self::linux::*;
#[cfg(target_os = "freebsd")]
pub(crate) mod freebsd;
#[cfg(target_os = "freebsd")]
pub use self::freebsd::DeviceImpl;
#[cfg(target_os = "macos")]
pub(crate) mod macos;
#[cfg(target_os = "macos")]
pub use self::macos::DeviceImpl;
#[cfg(target_os = "openbsd")]
pub(crate) mod openbsd;
#[cfg(target_os = "openbsd")]
pub use self::openbsd::DeviceImpl;
#[cfg(target_os = "netbsd")]
pub(crate) mod netbsd;
#[cfg(target_os = "netbsd")]
pub use self::netbsd::DeviceImpl;
#[cfg(target_os = "windows")]
pub(crate) mod windows;
#[cfg(target_os = "windows")]
pub use self::windows::DeviceImpl;
use getifaddrs::Interface;
#[cfg(unix)]
use std::io::{IoSlice, IoSliceMut};
use std::ops::Deref;
#[cfg(unix)]
use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
#[allow(dead_code)]
pub(crate) const ETHER_ADDR_LEN: u8 = 6;
#[allow(dead_code)]
pub(crate) fn get_if_addrs_by_name(if_name: String) -> std::io::Result<Vec<Interface>> {
let addrs = getifaddrs::getifaddrs()?;
let ifs = addrs.filter(|v| v.name == if_name).collect();
Ok(ifs)
}
/// A transparent wrapper around DeviceImpl, providing synchronous I/O operations.
///
/// # Examples
///
/// Basic read/write operation:
///
/// ```no_run
/// use std::net::Ipv4Addr;
/// use tun_rs::DeviceBuilder;
///
/// fn main() -> std::io::Result<()> {
/// // Create a TUN device using the builder
/// let mut tun = DeviceBuilder::new()
/// .name("my-tun")
/// .ipv4(Ipv4Addr::new(10, 0, 0, 1), 24, None)
/// .build_sync()?;
///
/// // Send a packet
/// // Example IP packet (Replace with real IP message)
/// let packet = b"[IP Packet: 10.0.0.1 -> 10.0.0.2] Hello, TUN!";
/// tun.send(packet)?;
/// println!("Sent {} bytes IP packet", packet.len());
///
/// // Receive a packet
/// let mut buf = [0u8; 1500];
/// let n = tun.recv(&mut buf)?;
/// println!("Received {} bytes: {:?}", n, &buf[..n]);
///
/// Ok(())
/// }
/// ```
#[repr(transparent)]
pub struct SyncDevice(pub(crate) DeviceImpl);
impl SyncDevice {
/// Creates a new SyncDevice from a raw file descriptor.
///
/// # Safety
/// - The file descriptor (`fd`) must be an owned file descriptor.
/// - It must be valid and open.
///
/// This function is only available on Unix platforms.
#[cfg(unix)]
pub unsafe fn from_fd(fd: RawFd) -> std::io::Result<Self> {
Ok(SyncDevice(DeviceImpl::from_fd(fd)?))
}
/// # Safety
/// The fd passed in must be a valid, open file descriptor.
/// Unlike [`from_fd`], this function does **not** take ownership of `fd`,
/// and therefore will not close it when dropped.
/// The caller is responsible for ensuring the lifetime and eventual closure of `fd`.
#[cfg(unix)]
pub(crate) unsafe fn borrow_raw(fd: RawFd) -> std::io::Result<Self> {
Ok(SyncDevice(DeviceImpl::borrow_raw(fd)?))
}
/// Receives data from the device into the provided buffer.
///
/// Returns the number of bytes read, or an I/O error.
///
/// # Example
/// ```no_run
/// use std::net::Ipv4Addr;
/// use tun_rs::DeviceBuilder;
/// let mut tun = DeviceBuilder::new()
/// .name("my-tun")
/// .ipv4(Ipv4Addr::new(10, 0, 0, 1), 24, None)
/// .build_sync()
/// .unwrap();
/// let mut buf = [0u8; 1500];
/// tun.recv(&mut buf).unwrap();
/// ```
/// # Note
/// Blocking the current thread if no packet is available
pub fn recv(&self, buf: &mut [u8]) -> std::io::Result<usize> {
self.0.recv(buf)
}
/// Sends data from the provided buffer to the device.
///
/// Returns the number of bytes written, or an I/O error.
///
/// # Example
/// ```no_run
/// use std::net::Ipv4Addr;
/// use tun_rs::DeviceBuilder;
/// let mut tun = DeviceBuilder::new()
/// .name("my-tun")
/// .ipv4(Ipv4Addr::new(10, 0, 0, 1), 24, None)
/// .build_sync()
/// .unwrap();
/// tun.send(b"hello").unwrap();
/// ```
pub fn send(&self, buf: &[u8]) -> std::io::Result<usize> {
self.0.send(buf)
}
/// Attempts to receive data from the device in a non-blocking fashion.
///
/// Returns the number of bytes read or an error if the operation would block.
#[cfg(target_os = "windows")]
pub fn try_recv(&self, buf: &mut [u8]) -> std::io::Result<usize> {
self.0.try_recv(buf)
}
/// Attempts to send data to the device in a non-blocking fashion.
///
/// Returns the number of bytes written or an error if the operation would block.
#[cfg(target_os = "windows")]
pub fn try_send(&self, buf: &[u8]) -> std::io::Result<usize> {
self.0.try_send(buf)
}
/// Shuts down the device on Windows.
///
/// This may close the device or signal that no further operations will occur.
#[cfg(target_os = "windows")]
pub fn shutdown(&self) -> std::io::Result<()> {
self.0.shutdown()
}
#[cfg(all(unix, feature = "experimental"))]
pub fn shutdown(&self) -> std::io::Result<()> {
Err(std::io::Error::from(std::io::ErrorKind::Unsupported))
}
/// Reads data into the provided buffer, with support for interruption.
///
/// This function attempts to read from the underlying file descriptor into `buf`,
/// and can be interrupted using the given [`InterruptEvent`]. If the `event` is triggered
/// while the read operation is blocked, the function will return early with
/// an error of kind [`std::io::ErrorKind::Interrupted`].
///
/// # Arguments
///
/// * `buf` - The buffer to store the read data.
/// * `event` - An [`InterruptEvent`] used to interrupt the blocking read.
///
/// # Returns
///
/// On success, returns the number of bytes read. On failure, returns an [`std::io::Error`].
///
/// # Platform-specific Behavior
///
/// On **Unix platforms**, it is recommended to use this together with `set_nonblocking(true)`.
/// Without setting non-blocking mode, concurrent reads may not respond properly to interrupt signals.
///
/// # Feature
///
/// This method is only available when the `interruptible` feature is enabled.
#[cfg(feature = "interruptible")]
pub fn recv_intr(&self, buf: &mut [u8], event: &InterruptEvent) -> std::io::Result<usize> {
self.0.read_interruptible(buf, event, None)
}
#[cfg(feature = "interruptible")]
pub fn recv_intr_timeout(
&self,
buf: &mut [u8],
event: &InterruptEvent,
timeout: Option<std::time::Duration>,
) -> std::io::Result<usize> {
self.0.read_interruptible(buf, event, timeout)
}
/// Like [`recv_intr`](Self::recv_intr), but reads into multiple buffers.
///
/// This function behaves the same as [`recv_intr`](Self::recv_intr),
/// but uses `readv` to fill the provided set of non-contiguous buffers.
///
/// # Feature
///
/// This method is only available when the `interruptible` feature is enabled.
#[cfg(all(unix, feature = "interruptible"))]
pub fn recv_vectored_intr(
&self,
bufs: &mut [IoSliceMut<'_>],
event: &InterruptEvent,
) -> std::io::Result<usize> {
self.0.readv_interruptible(bufs, event, None)
}
#[cfg(all(unix, feature = "interruptible"))]
pub fn recv_vectored_intr_timeout(
&self,
bufs: &mut [IoSliceMut<'_>],
event: &InterruptEvent,
timeout: Option<std::time::Duration>,
) -> std::io::Result<usize> {
self.0.readv_interruptible(bufs, event, timeout)
}
#[cfg(feature = "interruptible")]
pub fn wait_readable_intr(&self, event: &InterruptEvent) -> std::io::Result<()> {
self.0.wait_readable_interruptible(event, None)
}
#[cfg(feature = "interruptible")]
pub fn wait_readable_intr_timeout(
&self,
event: &InterruptEvent,
timeout: Option<std::time::Duration>,
) -> std::io::Result<()> {
self.0.wait_readable_interruptible(event, timeout)
}
#[cfg(feature = "interruptible")]
pub fn send_intr(&self, buf: &[u8], event: &InterruptEvent) -> std::io::Result<usize> {
self.0.write_interruptible(buf, event)
}
#[cfg(all(unix, feature = "interruptible"))]
pub fn send_vectored_intr(
&self,
bufs: &[IoSlice<'_>],
event: &InterruptEvent,
) -> std::io::Result<usize> {
self.0.writev_interruptible(bufs, event)
}
#[cfg(all(unix, feature = "interruptible"))]
#[inline]
pub fn wait_writable_intr(&self, event: &InterruptEvent) -> std::io::Result<()> {
self.0.wait_writable_interruptible(event)
}
/// Receives data from the device into multiple buffers using vectored I/O.
///
/// **Note:** This method operates on a single packet only. It will only read data from one packet,
/// even if multiple buffers are provided.
///
/// Returns the total number of bytes read from the packet, or an error.
#[cfg(unix)]
pub fn recv_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> std::io::Result<usize> {
self.0.recv_vectored(bufs)
}
/// Sends data to the device from multiple buffers using vectored I/O.
///
/// **Note:** This method operates on a single packet only. It will only send the data contained in
/// the provided buffers as one packet.
///
/// Returns the total number of bytes written for the packet, or an error.
#[cfg(unix)]
pub fn send_vectored(&self, bufs: &[IoSlice<'_>]) -> std::io::Result<usize> {
self.0.send_vectored(bufs)
}
/// Checks whether the device is currently operating in nonblocking mode.
///
/// Returns `true` if nonblocking mode is enabled, `false` otherwise, or an error.
#[cfg(unix)]
pub fn is_nonblocking(&self) -> std::io::Result<bool> {
self.0.is_nonblocking()
}
/// Sets the nonblocking mode for the device.
///
/// - `nonblocking`: Pass `true` to enable nonblocking mode, `false` to disable.
///
/// Returns an empty result on success or an I/O error.
#[cfg(unix)]
pub fn set_nonblocking(&self, nonblocking: bool) -> std::io::Result<()> {
self.0.set_nonblocking(nonblocking)
}
/// # Prerequisites
/// - The `IFF_MULTI_QUEUE` flag must be enabled.
/// - The system must support network interface multi-queue functionality.
///
/// # Description
/// When multi-queue is enabled, create a new queue by duplicating an existing one.
#[cfg(all(target_os = "linux", not(target_env = "ohos")))]
pub fn try_clone(&self) -> std::io::Result<SyncDevice> {
let device_impl = self.0.try_clone()?;
Ok(SyncDevice(device_impl))
}
}
#[cfg(all(target_os = "linux", not(target_env = "ohos")))]
impl SyncDevice {
#[cfg(feature = "interruptible")]
pub fn send_multiple_intr<B: ExpandBuffer>(
&self,
gro_table: &mut GROTable,
bufs: &mut [B],
offset: usize,
event: &InterruptEvent,
) -> std::io::Result<usize> {
self.send_multiple0(gro_table, bufs, offset, |tun, buf| {
tun.write_interruptible(buf, event)
})
}
#[cfg(feature = "interruptible")]
pub fn recv_multiple_intr<B: AsRef<[u8]> + AsMut<[u8]>>(
&self,
original_buffer: &mut [u8],
bufs: &mut [B],
sizes: &mut [usize],
offset: usize,
event: &InterruptEvent,
) -> std::io::Result<usize> {
self.recv_multiple0(original_buffer, bufs, sizes, offset, |tun, buf| {
tun.read_interruptible(buf, event, None)
})
}
}
impl Deref for SyncDevice {
type Target = DeviceImpl;
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[cfg(unix)]
impl FromRawFd for SyncDevice {
unsafe fn from_raw_fd(fd: RawFd) -> Self {
SyncDevice::from_fd(fd).unwrap()
}
}
#[cfg(unix)]
impl AsRawFd for SyncDevice {
fn as_raw_fd(&self) -> RawFd {
self.0.as_raw_fd()
}
}
#[cfg(unix)]
impl AsFd for SyncDevice {
fn as_fd(&self) -> BorrowedFd<'_> {
unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
}
}
#[cfg(unix)]
impl IntoRawFd for SyncDevice {
fn into_raw_fd(self) -> RawFd {
self.0.into_raw_fd()
}
}
#[cfg(unix)]
pub struct BorrowedSyncDevice<'dev> {
dev: SyncDevice,
_phantom: std::marker::PhantomData<&'dev SyncDevice>,
}
#[cfg(unix)]
impl Deref for BorrowedSyncDevice<'_> {
type Target = SyncDevice;
fn deref(&self) -> &Self::Target {
&self.dev
}
}
#[cfg(unix)]
impl BorrowedSyncDevice<'_> {
/// # Safety
/// The fd passed in must be a valid, open file descriptor.
/// Unlike [`SyncDevice::from_fd`], this function does **not** take ownership of `fd`,
/// and therefore will not close it when dropped.
/// The caller is responsible for ensuring the lifetime and eventual closure of `fd`.
pub unsafe fn borrow_raw(fd: RawFd) -> std::io::Result<Self> {
#[allow(unused_unsafe)]
unsafe {
Ok(Self {
dev: SyncDevice::borrow_raw(fd)?,
_phantom: std::marker::PhantomData,
})
}
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/unix/fd.rs | src/platform/unix/fd.rs | use std::io;
use std::io::{IoSlice, IoSliceMut};
use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd};
use libc::{self, fcntl, F_GETFL, O_NONBLOCK};
/// POSIX file descriptor support for `io` traits.
pub(crate) struct Fd {
pub(crate) inner: RawFd,
borrow: bool,
}
impl Fd {
#[cfg(any(
target_os = "windows",
target_os = "macos",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
pub(crate) fn new(value: RawFd) -> io::Result<Self> {
if value < 0 {
return Err(io::Error::last_os_error());
}
Ok(unsafe { Self::new_unchecked(value) })
}
pub(crate) unsafe fn new_unchecked(value: RawFd) -> Self {
Fd::new_unchecked_with_borrow(value, false)
}
pub(crate) unsafe fn new_unchecked_with_borrow(value: RawFd, borrow: bool) -> Self {
Fd {
inner: value,
borrow,
}
}
pub(crate) fn is_nonblocking(&self) -> io::Result<bool> {
unsafe {
let flags = fcntl(self.inner, F_GETFL);
if flags == -1 {
return Err(io::Error::last_os_error());
}
Ok((flags & O_NONBLOCK) != 0)
}
}
#[cfg(target_os = "macos")]
pub(crate) fn set_cloexec(&self) -> io::Result<()> {
unsafe {
let flags = fcntl(self.inner, libc::F_GETFD);
if flags < 0 {
return Err(io::Error::last_os_error());
}
if fcntl(self.inner, libc::F_SETFD, flags | libc::FD_CLOEXEC) < 0 {
return Err(io::Error::last_os_error());
}
Ok(())
}
}
/// Enable non-blocking mode
pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
let mut nonblocking = nonblocking as libc::c_int;
match unsafe { libc::ioctl(self.as_raw_fd(), libc::FIONBIO, &mut nonblocking) } {
0 => Ok(()),
_ => Err(io::Error::last_os_error()),
}
}
#[inline]
pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
let fd = self.as_raw_fd();
let amount = unsafe { libc::read(fd, buf.as_mut_ptr() as *mut _, buf.len()) };
if amount < 0 {
return Err(io::Error::last_os_error());
}
Ok(amount as usize)
}
#[inline]
pub fn readv(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
if bufs.len() > max_iov() {
return Err(io::Error::from(io::ErrorKind::InvalidInput));
}
let amount = unsafe {
libc::readv(
self.as_raw_fd(),
bufs.as_mut_ptr() as *mut libc::iovec as *const libc::iovec,
bufs.len() as libc::c_int,
)
};
if amount < 0 {
return Err(io::Error::last_os_error());
}
Ok(amount as usize)
}
#[inline]
pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
let fd = self.as_raw_fd();
let amount = unsafe { libc::write(fd, buf.as_ptr() as *const _, buf.len()) };
if amount < 0 {
return Err(io::Error::last_os_error());
}
Ok(amount as usize)
}
#[inline]
pub fn writev(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
if bufs.len() > max_iov() {
return Err(io::Error::from(io::ErrorKind::InvalidInput));
}
let amount = unsafe {
libc::writev(
self.as_raw_fd(),
bufs.as_ptr() as *const libc::iovec,
bufs.len() as libc::c_int,
)
};
if amount < 0 {
return Err(io::Error::last_os_error());
}
Ok(amount as usize)
}
}
#[cfg(any(
target_os = "dragonfly",
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
target_os = "openbsd",
target_vendor = "apple",
))]
pub(crate) const fn max_iov() -> usize {
libc::IOV_MAX as usize
}
#[cfg(any(
target_os = "android",
target_os = "emscripten",
target_os = "linux",
target_os = "nto",
))]
pub(crate) const fn max_iov() -> usize {
libc::UIO_MAXIOV as usize
}
impl AsRawFd for Fd {
fn as_raw_fd(&self) -> RawFd {
self.inner
}
}
impl IntoRawFd for Fd {
fn into_raw_fd(mut self) -> RawFd {
let fd = self.inner;
self.inner = -1;
fd
}
}
impl Drop for Fd {
fn drop(&mut self) {
if !self.borrow && self.inner >= 0 {
unsafe { libc::close(self.inner) };
}
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/unix/device.rs | src/platform/unix/device.rs | use crate::platform::unix::{Fd, Tun};
use crate::platform::DeviceImpl;
#[cfg(any(
all(target_os = "linux", not(target_env = "ohos")),
target_os = "macos",
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
use libc::{AF_INET, AF_INET6, SOCK_DGRAM};
use std::io;
use std::io::{IoSlice, IoSliceMut};
use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, RawFd};
impl FromRawFd for DeviceImpl {
unsafe fn from_raw_fd(fd: RawFd) -> Self {
DeviceImpl::from_fd(fd).unwrap()
}
}
impl AsRawFd for DeviceImpl {
fn as_raw_fd(&self) -> RawFd {
self.tun.as_raw_fd()
}
}
impl AsFd for DeviceImpl {
fn as_fd(&self) -> BorrowedFd<'_> {
unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
}
}
#[cfg(not(any(target_os = "freebsd", target_os = "netbsd", target_os = "openbsd")))]
impl std::os::unix::io::IntoRawFd for DeviceImpl {
fn into_raw_fd(self) -> RawFd {
self.tun.into_raw_fd()
}
}
impl DeviceImpl {
/// # Safety
/// The fd passed in must be an owned file descriptor; in particular, it must be open.
pub(crate) unsafe fn from_fd(fd: RawFd) -> io::Result<Self> {
let tun = Fd::new_unchecked(fd);
DeviceImpl::from_tun(Tun::new(tun))
}
/// # Safety
/// The fd passed in must be a valid, open file descriptor.
/// Unlike [`from_fd`], this function does **not** take ownership of `fd`,
/// and therefore will not close it when dropped.
/// The caller is responsible for ensuring the lifetime and eventual closure of `fd`.
pub(crate) unsafe fn borrow_raw(fd: RawFd) -> io::Result<Self> {
let tun = Fd::new_unchecked_with_borrow(fd, true);
DeviceImpl::from_tun(Tun::new(tun))
}
pub(crate) fn is_nonblocking(&self) -> io::Result<bool> {
self.tun.is_nonblocking()
}
/// Moves this Device into or out of nonblocking mode.
pub(crate) fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
self.tun.set_nonblocking(nonblocking)
}
/// Recv a packet from tun device
pub(crate) fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
self.tun.recv(buf)
}
pub(crate) fn recv_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
self.tun.recv_vectored(bufs)
}
/// Send a packet to tun device
pub(crate) fn send(&self, buf: &[u8]) -> io::Result<usize> {
self.tun.send(buf)
}
pub(crate) fn send_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
self.tun.send_vectored(bufs)
}
#[cfg(feature = "interruptible")]
pub(crate) fn read_interruptible(
&self,
buf: &mut [u8],
event: &crate::InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<usize> {
self.tun.read_interruptible(buf, event, timeout)
}
#[cfg(feature = "interruptible")]
pub(crate) fn readv_interruptible(
&self,
bufs: &mut [IoSliceMut<'_>],
event: &crate::InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<usize> {
self.tun.readv_interruptible(bufs, event, timeout)
}
#[cfg(feature = "interruptible")]
#[inline]
pub(crate) fn wait_readable_interruptible(
&self,
event: &crate::InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<()> {
self.tun.wait_readable_interruptible(event, timeout)
}
#[cfg(feature = "interruptible")]
pub(crate) fn write_interruptible(
&self,
buf: &[u8],
event: &crate::InterruptEvent,
) -> io::Result<usize> {
self.tun.write_interruptible(buf, event)
}
#[cfg(feature = "interruptible")]
#[inline]
pub(crate) fn writev_interruptible(
&self,
bufs: &[IoSlice<'_>],
event: &crate::InterruptEvent,
) -> io::Result<usize> {
self.tun.writev_interruptible(bufs, event)
}
#[cfg(feature = "interruptible")]
#[inline]
pub(crate) fn wait_writable_interruptible(
&self,
event: &crate::InterruptEvent,
) -> io::Result<()> {
self.tun.wait_writable_interruptible(event)
}
}
#[cfg(any(
all(target_os = "linux", not(target_env = "ohos")),
target_os = "macos",
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
impl DeviceImpl {
/// Retrieves the interface index for the network interface.
///
/// This function converts the interface name (obtained via `self.name()`) into a
/// C-compatible string (CString) and then calls the libc function `if_nametoindex`
/// to retrieve the corresponding interface index.
pub fn if_index(&self) -> io::Result<u32> {
let _guard = self.op_lock.lock().unwrap();
self.if_index_impl()
}
pub(crate) fn if_index_impl(&self) -> io::Result<u32> {
let if_name = std::ffi::CString::new(self.name_impl()?)?;
unsafe { Ok(libc::if_nametoindex(if_name.as_ptr())) }
}
/// Retrieves all IP addresses associated with the network interface.
///
/// This function calls `getifaddrs` with the interface name,
/// then iterates over the returned list of interface addresses, extracting and collecting
/// the IP addresses into a vector.
pub fn addresses(&self) -> io::Result<Vec<std::net::IpAddr>> {
Ok(crate::platform::get_if_addrs_by_name(self.name_impl()?)?
.iter()
.map(|v| v.address)
.collect())
}
}
#[cfg(any(target_os = "macos", target_os = "ios", target_os = "tvos",))]
impl DeviceImpl {
/// Returns whether the TUN device is set to ignore packet information (PI).
///
/// When enabled, the device does not prepend the `struct tun_pi` header
/// to packets, which can simplify packet processing in some cases.
///
/// # Returns
/// * `true` - The TUN device ignores packet information.
/// * `false` - The TUN device includes packet information.
/// # Note
/// Retrieve whether the packet is ignored for the TUN Device; The TAP device always returns `false`.
pub fn ignore_packet_info(&self) -> bool {
let _guard = self.op_lock.lock().unwrap();
self.tun.ignore_packet_info()
}
/// Sets whether the TUN device should ignore packet information (PI).
///
/// When `ignore_packet_info` is set to `true`, the TUN device does not
/// prepend the `struct tun_pi` header to packets. This can be useful
/// if the additional metadata is not needed.
///
/// # Parameters
/// * `ign` - If `true`, the TUN device will ignore packet information.
/// ` ` If `false`, it will include packet information.
/// # Note
/// This only works for a TUN device; The invocation will be ignored if the device is a TAP.
pub fn set_ignore_packet_info(&self, ign: bool) {
let _guard = self.op_lock.lock().unwrap();
self.tun.set_ignore_packet_info(ign)
}
}
#[cfg(any(
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
pub(crate) unsafe fn ctl() -> io::Result<Fd> {
Fd::new(libc::socket(AF_INET, SOCK_DGRAM | libc::SOCK_CLOEXEC, 0))
}
#[cfg(target_os = "macos")]
pub(crate) unsafe fn ctl() -> io::Result<Fd> {
let fd = Fd::new(libc::socket(AF_INET, SOCK_DGRAM, 0))?;
_ = fd.set_cloexec();
Ok(fd)
}
#[cfg(any(
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
pub(crate) unsafe fn ctl_v6() -> io::Result<Fd> {
Fd::new(libc::socket(AF_INET6, SOCK_DGRAM | libc::SOCK_CLOEXEC, 0))
}
#[cfg(target_os = "macos")]
pub(crate) unsafe fn ctl_v6() -> io::Result<Fd> {
let fd = Fd::new(libc::socket(AF_INET6, SOCK_DGRAM, 0))?;
_ = fd.set_cloexec();
Ok(fd)
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/unix/mod.rs | src/platform/unix/mod.rs | mod sockaddr;
#[cfg(any(
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
target_os = "macos"
))]
pub(crate) use sockaddr::sockaddr_union;
#[cfg(any(
all(target_os = "linux", not(target_env = "ohos")),
target_os = "macos",
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
#[allow(unused_imports)]
pub(crate) use sockaddr::ipaddr_to_sockaddr;
mod fd;
pub(crate) use self::fd::Fd;
#[cfg(feature = "interruptible")]
mod interrupt;
#[cfg(feature = "interruptible")]
pub use interrupt::InterruptEvent;
mod tun;
pub(crate) use self::tun::Tun;
pub(crate) mod device;
#[cfg(all(
unix,
not(any(
target_os = "windows",
target_os = "macos",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))
))]
/// A TUN device for Android/iOS/...
pub struct DeviceImpl {
pub(crate) tun: Tun,
#[allow(dead_code)]
pub(crate) op_lock: std::sync::Mutex<()>,
}
#[cfg(all(
unix,
not(any(
target_os = "windows",
target_os = "macos",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))
))]
impl DeviceImpl {
pub(crate) fn from_tun(tun: Tun) -> std::io::Result<Self> {
Ok(Self {
tun,
op_lock: std::sync::Mutex::new(()),
})
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/unix/interrupt.rs | src/platform/unix/interrupt.rs | use crate::platform::unix::Fd;
use std::io;
use std::io::{IoSlice, IoSliceMut};
use std::os::fd::AsRawFd;
use std::sync::Mutex;
impl Fd {
pub(crate) fn read_interruptible(
&self,
buf: &mut [u8],
event: &InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<usize> {
loop {
self.wait_readable_interruptible(event, timeout)?;
return match self.read(buf) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
continue;
}
rs => rs,
};
}
}
pub(crate) fn readv_interruptible(
&self,
bufs: &mut [IoSliceMut<'_>],
event: &InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<usize> {
loop {
self.wait_readable_interruptible(event, timeout)?;
return match self.readv(bufs) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
continue;
}
rs => rs,
};
}
}
pub(crate) fn write_interruptible(
&self,
buf: &[u8],
event: &InterruptEvent,
) -> io::Result<usize> {
loop {
self.wait_writable_interruptible(event)?;
return match self.write(buf) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
continue;
}
rs => rs,
};
}
}
pub fn writev_interruptible(
&self,
bufs: &[IoSlice<'_>],
event: &InterruptEvent,
) -> io::Result<usize> {
loop {
self.wait_writable_interruptible(event)?;
return match self.writev(bufs) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
continue;
}
rs => rs,
};
}
}
pub fn wait_readable_interruptible(
&self,
interrupted_event: &InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<()> {
let fd = self.as_raw_fd() as libc::c_int;
let event_fd = interrupted_event.as_event_fd();
let mut fds = [
libc::pollfd {
fd,
events: libc::POLLIN,
revents: 0,
},
libc::pollfd {
fd: event_fd,
events: libc::POLLIN,
revents: 0,
},
];
let result = unsafe {
libc::poll(
fds.as_mut_ptr(),
fds.len() as libc::nfds_t,
timeout
.map(|t| t.as_millis().min(i32::MAX as _) as _)
.unwrap_or(-1),
)
};
if result == -1 {
return Err(io::Error::last_os_error());
}
if result == 0 {
return Err(io::Error::from(io::ErrorKind::TimedOut));
}
if fds[0].revents & libc::POLLIN != 0 {
return Ok(());
}
if fds[1].revents & libc::POLLIN != 0 {
return Err(io::Error::new(
io::ErrorKind::Interrupted,
"trigger interrupt",
));
}
Err(io::Error::other("fd error"))
}
pub fn wait_writable_interruptible(
&self,
interrupted_event: &InterruptEvent,
) -> io::Result<()> {
let fd = self.as_raw_fd() as libc::c_int;
let event_fd = interrupted_event.as_event_fd();
let mut fds = [
libc::pollfd {
fd,
events: libc::POLLOUT,
revents: 0,
},
libc::pollfd {
fd: event_fd,
events: libc::POLLIN,
revents: 0,
},
];
let result = unsafe { libc::poll(fds.as_mut_ptr(), fds.len() as libc::nfds_t, -1) };
if result == -1 {
return Err(io::Error::last_os_error());
}
if fds[0].revents & libc::POLLOUT != 0 {
return Ok(());
}
if fds[1].revents & libc::POLLIN != 0 {
return Err(io::Error::new(
io::ErrorKind::Interrupted,
"trigger interrupt",
));
}
Err(io::Error::other("fd error"))
}
}
#[cfg(target_os = "macos")]
impl Fd {
pub fn wait_writable(
&self,
interrupt_event: Option<&InterruptEvent>,
timeout: Option<std::time::Duration>,
) -> io::Result<()> {
let readfds: libc::fd_set = unsafe { std::mem::zeroed() };
let mut writefds: libc::fd_set = unsafe { std::mem::zeroed() };
let fd = self.as_raw_fd();
unsafe {
libc::FD_SET(fd, &mut writefds);
}
self.wait(readfds, Some(writefds), interrupt_event, timeout)
}
pub fn wait_readable(
&self,
interrupt_event: Option<&InterruptEvent>,
timeout: Option<std::time::Duration>,
) -> io::Result<()> {
let mut readfds: libc::fd_set = unsafe { std::mem::zeroed() };
let fd = self.as_raw_fd();
unsafe {
libc::FD_SET(fd, &mut readfds);
}
self.wait(readfds, None, interrupt_event, timeout)
}
fn wait(
&self,
mut readfds: libc::fd_set,
mut writefds: Option<libc::fd_set>,
interrupt_event: Option<&InterruptEvent>,
timeout: Option<std::time::Duration>,
) -> io::Result<()> {
let fd = self.as_raw_fd();
let mut errorfds: libc::fd_set = unsafe { std::mem::zeroed() };
let mut nfds = fd;
if let Some(interrupt_event) = interrupt_event {
unsafe {
libc::FD_SET(interrupt_event.as_event_fd(), &mut readfds);
}
nfds = nfds.max(interrupt_event.as_event_fd());
}
let mut tv = libc::timeval {
tv_sec: 0,
tv_usec: 0,
};
let tv_ptr = if let Some(timeout) = timeout {
let secs = timeout.as_secs().min(libc::time_t::MAX as u64) as libc::time_t;
let usecs = (timeout.subsec_micros()) as libc::suseconds_t;
tv.tv_sec = secs;
tv.tv_usec = usecs;
&mut tv as *mut libc::timeval
} else {
std::ptr::null_mut()
};
let result = unsafe {
libc::select(
nfds + 1,
&mut readfds,
writefds
.as_mut()
.map(|p| p as *mut _)
.unwrap_or_else(std::ptr::null_mut),
&mut errorfds,
tv_ptr,
)
};
if result < 0 {
return Err(io::Error::last_os_error());
}
if result == 0 {
return Err(io::Error::from(io::ErrorKind::TimedOut));
}
unsafe {
if let Some(cancel_event) = interrupt_event {
if libc::FD_ISSET(cancel_event.as_event_fd(), &readfds) {
return Err(io::Error::new(
io::ErrorKind::Interrupted,
"trigger interrupt",
));
}
}
}
Ok(())
}
}
pub struct InterruptEvent {
state: Mutex<i32>,
read_fd: Fd,
write_fd: Fd,
}
impl InterruptEvent {
pub fn new() -> io::Result<Self> {
let mut fds: [libc::c_int; 2] = [0; 2];
unsafe {
if libc::pipe(fds.as_mut_ptr()) == -1 {
return Err(io::Error::last_os_error());
}
let read_fd = Fd::new_unchecked(fds[0]);
let write_fd = Fd::new_unchecked(fds[1]);
write_fd.set_nonblocking(true)?;
read_fd.set_nonblocking(true)?;
Ok(Self {
state: Mutex::new(0),
read_fd,
write_fd,
})
}
}
pub fn trigger(&self) -> io::Result<()> {
self.trigger_value(1)
}
pub fn trigger_value(&self, val: i32) -> io::Result<()> {
if val == 0 {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"value cannot be 0",
));
}
let mut guard = self.state.lock().unwrap();
if *guard != 0 {
return Ok(());
}
*guard = val;
let buf: [u8; 8] = 1u64.to_ne_bytes();
let res = unsafe {
libc::write(
self.write_fd.as_raw_fd(),
buf.as_ptr() as *const _,
buf.len(),
)
};
if res == -1 {
let e = io::Error::last_os_error();
if e.kind() == io::ErrorKind::WouldBlock {
return Ok(());
}
Err(e)
} else {
Ok(())
}
}
pub fn is_trigger(&self) -> bool {
*self.state.lock().unwrap() != 0
}
pub fn value(&self) -> i32 {
*self.state.lock().unwrap()
}
pub fn reset(&self) -> io::Result<()> {
let mut buf = [0; 8];
let mut guard = self.state.lock().unwrap();
*guard = 0;
loop {
unsafe {
let res = libc::read(
self.read_fd.as_raw_fd(),
buf.as_mut_ptr() as *mut _,
buf.len(),
);
if res == -1 {
let error = io::Error::last_os_error();
return if error.kind() == io::ErrorKind::WouldBlock {
Ok(())
} else {
Err(error)
};
}
}
}
}
fn as_event_fd(&self) -> libc::c_int {
self.read_fd.as_raw_fd()
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/unix/sockaddr.rs | src/platform/unix/sockaddr.rs | /// # Safety
unsafe fn sockaddr_to_rs_addr(sa: &sockaddr_union) -> Option<std::net::SocketAddr> {
match sa.addr_stor.ss_family as libc::c_int {
libc::AF_INET => {
let sa_in = sa.addr4;
let ip = std::net::Ipv4Addr::from(sa_in.sin_addr.s_addr.to_ne_bytes());
let port = u16::from_be(sa_in.sin_port);
Some(std::net::SocketAddr::new(ip.into(), port))
}
libc::AF_INET6 => {
let sa_in6 = sa.addr6;
let ip = std::net::Ipv6Addr::from(sa_in6.sin6_addr.s6_addr);
let port = u16::from_be(sa_in6.sin6_port);
Some(std::net::SocketAddr::new(ip.into(), port))
}
_ => None,
}
}
fn rs_addr_to_sockaddr(addr: std::net::SocketAddr) -> sockaddr_union {
match addr {
std::net::SocketAddr::V4(ipv4) => {
let mut addr: sockaddr_union = unsafe { std::mem::zeroed() };
#[cfg(any(
target_os = "freebsd",
target_os = "macos",
target_os = "openbsd",
target_os = "netbsd"
))]
{
addr.addr4.sin_len = std::mem::size_of::<libc::sockaddr_in>() as u8;
}
addr.addr4.sin_family = libc::AF_INET as libc::sa_family_t;
addr.addr4.sin_addr.s_addr = u32::from_ne_bytes(ipv4.ip().octets());
addr.addr4.sin_port = ipv4.port().to_be();
addr
}
std::net::SocketAddr::V6(ipv6) => {
let mut addr: sockaddr_union = unsafe { std::mem::zeroed() };
#[cfg(any(
target_os = "freebsd",
target_os = "macos",
target_os = "openbsd",
target_os = "netbsd"
))]
{
addr.addr6.sin6_len = std::mem::size_of::<libc::sockaddr_in6>() as u8;
}
addr.addr6.sin6_family = libc::AF_INET6 as libc::sa_family_t;
addr.addr6.sin6_addr.s6_addr = ipv6.ip().octets();
addr.addr6.sin6_port = ipv6.port().to_be();
addr
}
}
}
/// # Safety
/// Fill the `addr` with the `src_addr` and `src_port`, the `size` should be the size of overwriting
#[cfg(any(
target_os = "linux",
target_os = "macos",
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
#[allow(dead_code)]
pub(crate) unsafe fn ipaddr_to_sockaddr<T>(
src_addr: T,
src_port: u16,
addr: &mut libc::sockaddr,
size: usize,
) where
T: Into<std::net::IpAddr>,
{
let sa = rs_addr_to_sockaddr((src_addr.into(), src_port).into());
std::ptr::copy_nonoverlapping(
&sa as *const _ as *const libc::c_void,
addr as *mut _ as *mut libc::c_void,
size.min(std::mem::size_of::<sockaddr_union>()),
);
}
#[repr(C)]
#[derive(Clone, Copy)]
pub union sockaddr_union {
pub addr_stor: libc::sockaddr_storage,
pub addr6: libc::sockaddr_in6,
pub addr4: libc::sockaddr_in,
pub addr: libc::sockaddr,
}
impl From<libc::sockaddr_storage> for sockaddr_union {
fn from(addr: libc::sockaddr_storage) -> Self {
sockaddr_union { addr_stor: addr }
}
}
impl From<libc::sockaddr_in6> for sockaddr_union {
fn from(addr: libc::sockaddr_in6) -> Self {
sockaddr_union { addr6: addr }
}
}
impl From<libc::sockaddr_in> for sockaddr_union {
fn from(addr: libc::sockaddr_in) -> Self {
sockaddr_union { addr4: addr }
}
}
impl From<libc::sockaddr> for sockaddr_union {
fn from(addr: libc::sockaddr) -> Self {
sockaddr_union { addr }
}
}
impl From<std::net::SocketAddr> for sockaddr_union {
fn from(addr: std::net::SocketAddr) -> Self {
rs_addr_to_sockaddr(addr)
}
}
impl TryFrom<sockaddr_union> for std::net::SocketAddr {
type Error = std::io::Error;
fn try_from(addr: sockaddr_union) -> Result<Self, Self::Error> {
unsafe { sockaddr_to_rs_addr(&addr).ok_or(std::io::ErrorKind::InvalidInput.into()) }
}
}
impl<T: Into<std::net::IpAddr>> From<(T, u16)> for sockaddr_union {
fn from((ip, port): (T, u16)) -> Self {
let ip: std::net::IpAddr = ip.into();
rs_addr_to_sockaddr(std::net::SocketAddr::new(ip, port))
}
}
#[test]
fn test_conversion() {
let old = std::net::SocketAddr::new([127, 0, 0, 1].into(), 0x0208);
let addr = rs_addr_to_sockaddr(old);
unsafe {
if cfg!(target_endian = "big") {
assert_eq!(0x7f000001, addr.addr4.sin_addr.s_addr);
assert_eq!(0x0208, addr.addr4.sin_port);
} else if cfg!(target_endian = "little") {
assert_eq!(0x0100007f, addr.addr4.sin_addr.s_addr);
assert_eq!(0x0802, addr.addr4.sin_port);
} else {
unreachable!();
}
};
let ip = unsafe { sockaddr_to_rs_addr(&addr).unwrap() };
assert_eq!(ip, old);
let old = std::net::SocketAddr::new(std::net::Ipv6Addr::LOCALHOST.into(), 0x0208);
let addr = rs_addr_to_sockaddr(old);
let ip = unsafe { sockaddr_to_rs_addr(&addr).unwrap() };
assert_eq!(ip, old);
#[cfg(any(target_os = "linux", target_os = "macos"))]
{
let old = std::net::IpAddr::V4([10, 0, 0, 33].into());
let mut addr: sockaddr_union = unsafe { std::mem::zeroed() };
let size = std::mem::size_of::<libc::sockaddr_in>();
unsafe { ipaddr_to_sockaddr(old, 0x0208, &mut addr.addr, size) };
let ip = unsafe { sockaddr_to_rs_addr(&addr).unwrap() };
assert_eq!(ip, std::net::SocketAddr::new(old, 0x0208));
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/unix/tun.rs | src/platform/unix/tun.rs | use crate::platform::unix::Fd;
#[cfg(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))]
use crate::PACKET_INFORMATION_LENGTH as PIL;
use std::io::{self, IoSlice, IoSliceMut};
use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd};
#[cfg(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))]
use std::sync::atomic::{AtomicBool, Ordering};
/// Infer the protocol based on the first nibble in the packet buffer.
#[cfg(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))]
pub(crate) fn is_ipv6(buf: &[u8]) -> std::io::Result<bool> {
use std::io::{Error, ErrorKind::InvalidData};
if buf.is_empty() {
return Err(Error::new(InvalidData, "Zero-length data"));
}
match buf[0] >> 4 {
4 => Ok(false),
6 => Ok(true),
p => Err(Error::new(InvalidData, format!("IP version {p}"))),
}
}
#[cfg(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))]
pub(crate) fn generate_packet_information(_ipv6: bool) -> [u8; PIL] {
#[cfg(any(target_os = "linux", target_os = "android"))]
const TUN_PROTO_IP6: [u8; PIL] = (libc::ETH_P_IPV6 as u32).to_be_bytes();
#[cfg(any(target_os = "linux", target_os = "android"))]
const TUN_PROTO_IP4: [u8; PIL] = (libc::ETH_P_IP as u32).to_be_bytes();
#[cfg(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))]
const TUN_PROTO_IP6: [u8; PIL] = (libc::AF_INET6 as u32).to_be_bytes();
#[cfg(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))]
const TUN_PROTO_IP4: [u8; PIL] = (libc::AF_INET as u32).to_be_bytes();
if _ipv6 {
TUN_PROTO_IP6
} else {
TUN_PROTO_IP4
}
}
pub(crate) struct Tun {
pub(crate) fd: Fd,
#[cfg(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))]
ignore_packet_information: AtomicBool,
}
impl Tun {
pub(crate) fn new(fd: Fd) -> Self {
Self {
fd,
#[cfg(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))]
ignore_packet_information: AtomicBool::new(true),
}
}
pub fn is_nonblocking(&self) -> io::Result<bool> {
self.fd.is_nonblocking()
}
pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
self.fd.set_nonblocking(nonblocking)
}
#[cfg(not(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
)))]
#[inline]
pub(crate) fn send(&self, buf: &[u8]) -> io::Result<usize> {
self.fd.write(buf)
}
#[cfg(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))]
pub(crate) fn send(&self, buf: &[u8]) -> io::Result<usize> {
if self.ignore_packet_info() {
let ipv6 = is_ipv6(buf)?;
let header = generate_packet_information(ipv6);
let len = self
.fd
.writev(&[IoSlice::new(&header), IoSlice::new(buf)])?;
return Ok(len.saturating_sub(PIL));
}
self.fd.write(buf)
}
#[cfg(not(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
)))]
#[inline]
pub(crate) fn send_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
self.fd.writev(bufs)
}
#[cfg(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))]
#[inline]
pub(crate) fn send_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
if self.ignore_packet_info() {
if crate::platform::unix::fd::max_iov() - 1 < bufs.len() {
return Err(io::Error::from(io::ErrorKind::InvalidInput));
}
let buf = bufs
.iter()
.find(|b| !b.is_empty())
.map_or(&[][..], |b| &**b);
let ipv6 = is_ipv6(buf)?;
let head = generate_packet_information(ipv6);
let mut iov_block = [IoSlice::new(&head); crate::platform::unix::fd::max_iov()];
for (index, buf) in bufs.iter().enumerate() {
iov_block[index + 1] = *buf
}
let len = self.fd.writev(&iov_block[..bufs.len() + 1])?;
Ok(len.saturating_sub(PIL))
} else {
self.fd.writev(bufs)
}
}
#[cfg(not(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
)))]
#[inline]
pub(crate) fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
self.fd.read(buf)
}
#[cfg(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))]
pub(crate) fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
if self.ignore_packet_info() {
let mut head = [0u8; PIL];
let bufs = &mut [IoSliceMut::new(&mut head), IoSliceMut::new(buf)];
let len = self.fd.readv(bufs)?;
Ok(len.saturating_sub(PIL))
} else {
self.fd.read(buf)
}
}
#[cfg(not(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
)))]
#[inline]
pub(crate) fn recv_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
self.fd.readv(bufs)
}
#[cfg(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))]
pub(crate) fn recv_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
if self.ignore_packet_info() {
if crate::platform::unix::fd::max_iov() - 1 < bufs.len() {
return Err(io::Error::from(io::ErrorKind::InvalidInput));
}
let offset = bufs.len() + 1;
let mut head = [0u8; PIL];
let mut iov_block: [std::mem::MaybeUninit<IoSliceMut>;
crate::platform::unix::fd::max_iov()] =
unsafe { std::mem::MaybeUninit::uninit().assume_init() };
iov_block[0] = std::mem::MaybeUninit::new(IoSliceMut::new(&mut head));
for (index, buf) in bufs.iter_mut().enumerate() {
iov_block[index + 1] = std::mem::MaybeUninit::new(IoSliceMut::new(buf.as_mut()));
}
let part: &mut [IoSliceMut] = unsafe {
std::slice::from_raw_parts_mut(iov_block.as_mut_ptr() as *mut IoSliceMut, offset)
};
let len = self.fd.readv(part)?;
Ok(len.saturating_sub(PIL))
} else {
self.fd.readv(bufs)
}
}
#[cfg(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))]
#[inline]
pub(crate) fn ignore_packet_info(&self) -> bool {
self.ignore_packet_information.load(Ordering::Relaxed)
}
#[cfg(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))]
pub(crate) fn set_ignore_packet_info(&self, ign: bool) {
self.ignore_packet_information.store(ign, Ordering::Relaxed);
}
#[cfg(all(
feature = "interruptible",
not(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))
))]
#[inline]
pub(crate) fn read_interruptible(
&self,
buf: &mut [u8],
event: &crate::InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<usize> {
self.fd.read_interruptible(buf, event, timeout)
}
#[cfg(all(
feature = "interruptible",
any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
)
))]
pub(crate) fn read_interruptible(
&self,
buf: &mut [u8],
event: &crate::InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<usize> {
if self.ignore_packet_info() {
let mut head = [0u8; PIL];
let bufs = &mut [IoSliceMut::new(&mut head), IoSliceMut::new(buf)];
let len = self.fd.readv_interruptible(bufs, event, timeout)?;
Ok(len.saturating_sub(PIL))
} else {
self.fd.read_interruptible(buf, event, timeout)
}
}
#[cfg(all(
feature = "interruptible",
not(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))
))]
#[inline]
pub(crate) fn readv_interruptible(
&self,
bufs: &mut [IoSliceMut<'_>],
event: &crate::InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<usize> {
self.fd.readv_interruptible(bufs, event, timeout)
}
#[cfg(all(
feature = "interruptible",
any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
)
))]
pub(crate) fn readv_interruptible(
&self,
bufs: &mut [IoSliceMut<'_>],
event: &crate::InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<usize> {
if self.ignore_packet_info() {
if crate::platform::unix::fd::max_iov() - 1 < bufs.len() {
return Err(io::Error::from(io::ErrorKind::InvalidInput));
}
let offset = bufs.len() + 1;
let mut head = [0u8; PIL];
let mut iov_block: [std::mem::MaybeUninit<IoSliceMut>;
crate::platform::unix::fd::max_iov()] =
unsafe { std::mem::MaybeUninit::uninit().assume_init() };
iov_block[0] = std::mem::MaybeUninit::new(IoSliceMut::new(&mut head));
for (index, buf) in bufs.iter_mut().enumerate() {
iov_block[index + 1] = std::mem::MaybeUninit::new(IoSliceMut::new(buf.as_mut()));
}
let part: &mut [IoSliceMut] = unsafe {
std::slice::from_raw_parts_mut(iov_block.as_mut_ptr() as *mut IoSliceMut, offset)
};
let len = self.fd.readv_interruptible(part, event, timeout)?;
Ok(len.saturating_sub(PIL))
} else {
self.fd.readv_interruptible(bufs, event, timeout)
}
}
#[cfg(feature = "interruptible")]
#[inline]
pub(crate) fn wait_readable_interruptible(
&self,
event: &crate::InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<()> {
self.fd.wait_readable_interruptible(event, timeout)
}
#[cfg(all(
feature = "interruptible",
not(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))
))]
#[inline]
pub(crate) fn write_interruptible(
&self,
buf: &[u8],
event: &crate::InterruptEvent,
) -> io::Result<usize> {
self.fd.write_interruptible(buf, event)
}
#[cfg(all(
feature = "interruptible",
any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
)
))]
pub(crate) fn write_interruptible(
&self,
buf: &[u8],
event: &crate::InterruptEvent,
) -> io::Result<usize> {
if self.ignore_packet_info() {
let ipv6 = is_ipv6(buf)?;
let head = generate_packet_information(ipv6);
let len = self
.fd
.writev_interruptible(&[IoSlice::new(&head), IoSlice::new(buf)], event)?;
Ok(len.saturating_sub(PIL))
} else {
self.fd.write_interruptible(buf, event)
}
}
#[cfg(all(
feature = "interruptible",
not(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
))
))]
#[inline]
pub(crate) fn writev_interruptible(
&self,
bufs: &[IoSlice<'_>],
event: &crate::InterruptEvent,
) -> io::Result<usize> {
self.fd.writev_interruptible(bufs, event)
}
#[cfg(all(
feature = "interruptible",
any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "openbsd",
target_os = "freebsd",
target_os = "netbsd",
)
))]
pub(crate) fn writev_interruptible(
&self,
bufs: &[IoSlice<'_>],
event: &crate::InterruptEvent,
) -> io::Result<usize> {
if self.ignore_packet_info() {
if crate::platform::unix::fd::max_iov() - 1 < bufs.len() {
return Err(io::Error::from(io::ErrorKind::InvalidInput));
}
let buf = bufs
.iter()
.find(|b| !b.is_empty())
.map_or(&[][..], |b| &**b);
let ipv6 = is_ipv6(buf)?;
let head = generate_packet_information(ipv6);
let mut iov_block = [IoSlice::new(&head); crate::platform::unix::fd::max_iov()];
for (index, buf) in bufs.iter().enumerate() {
iov_block[index + 1] = *buf;
}
let len = self
.fd
.writev_interruptible(&iov_block[..bufs.len() + 1], event)?;
Ok(len.saturating_sub(PIL))
} else {
self.fd.writev_interruptible(bufs, event)
}
}
#[cfg(feature = "interruptible")]
#[inline]
pub(crate) fn wait_writable_interruptible(
&self,
event: &crate::InterruptEvent,
) -> io::Result<()> {
self.fd.wait_writable_interruptible(event)
}
}
impl AsRawFd for Tun {
fn as_raw_fd(&self) -> RawFd {
self.fd.as_raw_fd()
}
}
impl IntoRawFd for Tun {
fn into_raw_fd(self) -> RawFd {
self.fd.into_raw_fd()
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/openbsd/device.rs | src/platform/openbsd/device.rs | use crate::{
builder::{DeviceConfig, Layer},
platform::openbsd::sys::*,
platform::{
unix::{sockaddr_union, Fd, Tun},
ETHER_ADDR_LEN,
},
ToIpv4Address, ToIpv4Netmask, ToIpv6Address, ToIpv6Netmask,
};
use crate::platform::unix::device::{ctl, ctl_v6};
use libc::{self, c_char, c_short, ifreq, AF_LINK, IFF_RUNNING, IFF_UP, IFNAMSIZ, O_RDWR};
use mac_address::mac_address_by_name;
use std::io::ErrorKind;
use std::os::fd::{IntoRawFd, RawFd};
use std::sync::Mutex;
use std::{io, mem, net::IpAddr, os::unix::io::AsRawFd, ptr};
/// A TUN device using the TUN/TAP Linux driver.
pub struct DeviceImpl {
name: String,
pub(crate) tun: Tun,
pub(crate) op_lock: Mutex<bool>,
}
impl IntoRawFd for DeviceImpl {
fn into_raw_fd(mut self) -> RawFd {
let fd = self.tun.fd.inner;
self.tun.fd.inner = -1;
fd
}
}
impl Drop for DeviceImpl {
fn drop(&mut self) {
if self.tun.fd.inner < 0 {
return;
}
unsafe {
if let (Ok(ctl), Ok(req)) = (ctl(), self.request()) {
libc::close(self.tun.fd.inner);
self.tun.fd.inner = -1;
_ = siocifdestroy(ctl.as_raw_fd(), &req);
}
}
}
}
impl DeviceImpl {
/// Create a new `Device` for the given `Configuration`.
pub(crate) fn new(config: DeviceConfig) -> io::Result<Self> {
let layer = config.layer.unwrap_or(Layer::L3);
let associate_route = if layer == Layer::L3 {
config.associate_route.unwrap_or(true)
} else {
false
};
if let Some(dev_name) = config.dev_name.as_ref() {
Self::check_name(layer, dev_name)?;
}
let (dev_fd, name) = Self::create_tuntap(layer, config.dev_name)?;
let tun = Tun::new(dev_fd);
if layer == Layer::L2 {
tun.set_ignore_packet_info(false);
} else {
tun.set_ignore_packet_info(!config.packet_information.unwrap_or(false));
}
Ok(DeviceImpl {
name,
tun,
op_lock: Mutex::new(associate_route),
})
}
fn create_tuntap(layer: Layer, dev_name: Option<String>) -> io::Result<(Fd, String)> {
let device_prefix = match layer {
Layer::L2 => "tap",
Layer::L3 => "tun",
};
if let Some(dev_name) = dev_name {
if !dev_name.starts_with(&device_prefix) {
return Err(io::Error::new(
ErrorKind::InvalidInput,
format!("device name must start with {device_prefix}"),
));
}
let if_index = dev_name[3..]
.parse::<u32>()
.map(|v| v)
.map_err(|e| io::Error::new(ErrorKind::InvalidInput, e))?;
let device_path = format!("/dev/{device_prefix}{if_index}\0");
let fd = Self::open_create_dev(&dev_name, &device_path)?;
Ok((fd, dev_name))
} else {
for index in 0..256 {
let dev_name = format!("{device_prefix}{index}");
let device_path = format!("/dev/{device_prefix}{index}\0");
match Self::open_create_dev(&dev_name, &device_path) {
Ok(dev) => {
return Ok((dev, dev_name));
}
Err(e) => {
if e.raw_os_error() != Some(libc::EBUSY) {
return Err(e);
}
}
}
}
Err(io::Error::last_os_error())
}
}
fn check_name(layer: Layer, dev_name: &str) -> io::Result<()> {
if dev_name.len() > IFNAMSIZ {
return Err(io::Error::new(
ErrorKind::InvalidInput,
"device name too long",
));
}
let device_prefix = match layer {
Layer::L2 => "tap",
Layer::L3 => "tun",
};
if !dev_name.starts_with(device_prefix) {
Err(io::Error::new(
ErrorKind::InvalidInput,
format!("device name must start with {device_prefix}"),
))
} else {
Ok(())
}
}
fn open_create_dev(dev_name: &str, device_path: &str) -> io::Result<Fd> {
let fd = unsafe { libc::open(device_path.as_ptr() as *const _, O_RDWR | libc::O_CLOEXEC) };
match Fd::new(fd) {
Ok(dev) => Ok(dev),
Err(ref e) if e.kind() == ErrorKind::NotFound => {
if let Err(e) = DeviceImpl::create_dev(&dev_name) {
if e.kind() != ErrorKind::AlreadyExists {
return Err(e);
}
}
Self::open_and_makedev_dev(dev_name, device_path)
}
Err(e) => Err(e),
}
}
fn open_and_makedev_dev(dev_name: &str, device_path: &str) -> io::Result<Fd> {
let fd = unsafe { libc::open(device_path.as_ptr() as *const _, O_RDWR | libc::O_CLOEXEC) };
match Fd::new(fd) {
Ok(fd) => Ok(fd),
Err(ref e) if e.kind() == ErrorKind::NotFound => {
DeviceImpl::makedev_dev(dev_name)?;
let fd = unsafe {
libc::open(device_path.as_ptr() as *const _, O_RDWR | libc::O_CLOEXEC)
};
Ok(Fd::new(fd)?)
}
Err(e) => Err(e),
}
}
fn makedev_dev(name: &str) -> io::Result<()> {
let status = std::process::Command::new("sh")
.arg("MAKEDEV")
.arg(name)
.current_dir("/dev")
.status()?;
if status.success() {
Ok(())
} else {
Err(io::Error::other(format!(
"MAKEDEV {} failed with status {:?}",
name,
status.code()
)))
}
}
fn create_dev(name: &str) -> io::Result<()> {
unsafe {
let mut req: ifreq = mem::zeroed();
ptr::copy_nonoverlapping(
name.as_ptr() as *const c_char,
req.ifr_name.as_mut_ptr(),
name.len(),
);
if let Err(err) = siocifcreate(ctl()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
}
Ok(())
}
pub(crate) fn from_tun(tun: Tun) -> io::Result<Self> {
let name = Self::name_of_fd(&tun)?;
if name.starts_with("tap") {
// Tap does not have PI
tun.set_ignore_packet_info(false);
} else {
tun.set_ignore_packet_info(true);
}
Ok(Self {
name,
tun,
op_lock: Mutex::new(true),
})
}
fn calc_dest_addr(&self, addr: IpAddr, netmask: IpAddr) -> io::Result<IpAddr> {
let prefix_len = ipnet::ip_mask_to_prefix(netmask)
.map_err(|e| io::Error::new(ErrorKind::InvalidInput, e))?;
Ok(ipnet::IpNet::new(addr, prefix_len)
.map_err(|e| io::Error::new(ErrorKind::InvalidInput, e))?
.broadcast())
}
/// Set the IPv4 alias of the device.
fn add_address(
&self,
addr: IpAddr,
mask: IpAddr,
dest: Option<IpAddr>,
associate_route: bool,
) -> io::Result<()> {
unsafe {
match addr {
IpAddr::V4(_) => {
let ctl = ctl()?;
let mut req: ifaliasreq = mem::zeroed();
let tun_name = self.name_impl()?;
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifra_name.as_mut_ptr(),
tun_name.len(),
);
req.ifra_ifrau.ifrau_addr =
crate::platform::unix::sockaddr_union::from((addr, 0)).addr;
if let Some(dest) = dest {
req.ifra_dstaddr =
crate::platform::unix::sockaddr_union::from((dest, 0)).addr;
}
req.ifra_mask = crate::platform::unix::sockaddr_union::from((mask, 0)).addr;
if let Err(err) = siocaifaddr(ctl.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
if let Err(e) = self.add_route(addr, mask, associate_route) {
log::warn!("add_route {addr}/{mask} {e:?}");
}
}
IpAddr::V6(_) => {
let IpAddr::V6(_) = mask else {
return Err(std::io::Error::from(ErrorKind::InvalidInput));
};
let tun_name = self.name_impl()?;
let mut req: in6_aliasreq = mem::zeroed();
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifra_name.as_mut_ptr(),
tun_name.len(),
);
req.ifra_ifrau.ifrau_addr = sockaddr_union::from((addr, 0)).addr6;
req.ifra_prefixmask = sockaddr_union::from((mask, 0)).addr6;
req.ifra_lifetime.ia6t_vltime = 0xffffffff_u32;
req.ifra_lifetime.ia6t_pltime = 0xffffffff_u32;
req.ifra_flags = IN6_IFF_NODAD;
if let Err(err) = siocaifaddr_in6(ctl_v6()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
}
}
Ok(())
}
}
/// Prepare a new request.
unsafe fn request(&self) -> io::Result<ifreq> {
let mut req: ifreq = mem::zeroed();
let tun_name = self.name_impl()?;
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifr_name.as_mut_ptr(),
tun_name.len(),
);
Ok(req)
}
/// # Safety
unsafe fn request_v6(&self) -> io::Result<in6_ifreq> {
let tun_name = self.name_impl()?;
let mut req: in6_ifreq = mem::zeroed();
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifra_name.as_mut_ptr(),
tun_name.len(),
);
req.ifr_ifru.ifru_flags = IN6_IFF_NODAD as _;
Ok(req)
}
/// If false, the program will not modify or manage routes in any way, allowing the system to handle all routing natively.
/// If true (default), the program will automatically add or remove routes to provide consistent routing behavior across all platforms.
/// Set this to be false to obtain the platform's default routing behavior.
pub fn set_associate_route(&self, associate_route: bool) {
*self.op_lock.lock().unwrap() = associate_route;
}
/// Retrieve whether route is associated with the IP setting interface, see [`DeviceImpl::set_associate_route`]
pub fn associate_route(&self) -> bool {
*self.op_lock.lock().unwrap()
}
fn add_route(&self, addr: IpAddr, netmask: IpAddr, associate_route: bool) -> io::Result<()> {
if !associate_route {
return Ok(());
}
let if_index = self.if_index_impl()?;
let prefix_len = ipnet::ip_mask_to_prefix(netmask)
.map_err(|e| io::Error::new(ErrorKind::InvalidInput, e))?;
let mut manager = route_manager::RouteManager::new()?;
let route = route_manager::Route::new(addr, prefix_len).with_if_index(if_index);
manager.add(&route)?;
Ok(())
}
/// Retrieves the name of the network interface.
pub(crate) fn name_impl(&self) -> io::Result<String> {
Ok(self.name.clone())
}
fn name_of_fd(tun: &Tun) -> io::Result<String> {
unsafe {
let mut st = std::mem::MaybeUninit::<libc::stat>::uninit();
let rs = libc::fstat(tun.as_raw_fd(), st.as_mut_ptr());
if rs < 0 {
return Err(io::Error::last_os_error());
}
let st = st.assume_init();
let typ = st.st_mode & libc::S_IFMT;
if typ != libc::S_IFCHR && typ != libc::S_IFBLK {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"fd is not a device file",
));
}
let p = libc::devname(st.st_rdev, typ);
if !p.is_null() {
let name = std::ffi::CStr::from_ptr(p).to_string_lossy().into_owned();
if name == "??" {
return Err(io::Error::new(
io::ErrorKind::NotFound,
"unknown device name (\"??\")",
));
}
Ok(name)
} else {
Err(io::Error::other("devname returned NULL"))
}
}
}
fn remove_all_address_v4(&self) -> io::Result<()> {
unsafe {
let req_v4 = self.request()?;
loop {
if let Err(err) = siocdifaddr(ctl()?.as_raw_fd(), &req_v4) {
if err == nix::errno::Errno::EADDRNOTAVAIL {
break;
}
return Err(io::Error::from(err));
}
}
}
Ok(())
}
/// Sets the IPv4 network address, netmask, and an optional destination address.
/// Remove all previous set IPv4 addresses and set the specified address.
fn set_network_address_impl<IPv4: ToIpv4Address, Netmask: ToIpv4Netmask>(
&self,
address: IPv4,
netmask: Netmask,
destination: Option<IPv4>,
associate_route: bool,
) -> io::Result<()> {
let addr = address.ipv4()?.into();
let netmask = netmask.netmask()?.into();
let default_dest = self.calc_dest_addr(addr, netmask)?;
let dest = destination
.map(|d| d.ipv4())
.transpose()?
.map(|v| v.into())
.unwrap_or(default_dest);
self.remove_all_address_v4()?;
self.add_address(addr, netmask, Some(dest), associate_route)
}
}
//Public User Interface
impl DeviceImpl {
/// Returns whether the TUN device is set to ignore packet information (PI).
///
/// When enabled, the device does not prepend the `struct tun_pi` header
/// to packets, which can simplify packet processing in some cases.
///
/// # Returns
/// * `true` - The TUN device ignores packet information.
/// * `false` - The TUN device includes packet information.
/// # Note
/// Retrieve whether the packet is ignored for the TUN Device; The TAP device always returns `false`.
pub fn ignore_packet_info(&self) -> bool {
let _guard = self.op_lock.lock().unwrap();
self.tun.ignore_packet_info()
}
/// Sets whether the TUN device should ignore packet information (PI).
///
/// When `ignore_packet_info` is set to `true`, the TUN device does not
/// prepend the `struct tun_pi` header to packets. This can be useful
/// if the additional metadata is not needed.
///
/// # Parameters
/// * `ign`
/// - If `true`, the TUN device will ignore packet information.
/// - If `false`, it will include packet information.
/// # Note
/// This only works for a TUN device; The invocation will be ignored if the device is a TAP.
pub fn set_ignore_packet_info(&self, ign: bool) {
let _guard = self.op_lock.lock().unwrap();
if let Ok(name) = self.name_impl() {
if name.starts_with("tun") {
self.tun.set_ignore_packet_info(ign)
}
}
}
/// Enables or disables the network interface.
pub fn enabled(&self, value: bool) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req = self.request()?;
let ctl = ctl()?;
if let Err(err) = siocgifflags(ctl.as_raw_fd(), &mut req) {
return Err(io::Error::from(err));
}
if value {
req.ifr_ifru.ifru_flags |= (IFF_UP | IFF_RUNNING) as c_short;
} else {
req.ifr_ifru.ifru_flags &= !(IFF_UP as c_short);
}
if let Err(err) = siocsifflags(ctl.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
/// Retrieves the current MTU (Maximum Transmission Unit) for the interface.
pub fn mtu(&self) -> io::Result<u16> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req: ifreq_mtu = mem::zeroed();
let tun_name = self.name_impl()?;
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifr_name.as_mut_ptr(),
tun_name.len(),
);
if let Err(err) = siocgifmtu(ctl()?.as_raw_fd(), &mut req) {
return Err(io::Error::from(err));
}
let r: u16 = req.mtu.try_into().map_err(io::Error::other)?;
Ok(r)
}
}
/// Sets the MTU (Maximum Transmission Unit) for the interface.
pub fn set_mtu(&self, value: u16) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req: ifreq_mtu = mem::zeroed();
let tun_name = self.name_impl()?;
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifr_name.as_mut_ptr(),
tun_name.len(),
);
req.mtu = value as _;
if let Err(err) = siocsifmtu(ctl()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
/// Sets the IPv4 network address, netmask, and an optional destination address.
/// Remove all previous set IPv4 addresses and set the specified address.
pub fn set_network_address<IPv4: ToIpv4Address, Netmask: ToIpv4Netmask>(
&self,
address: IPv4,
netmask: Netmask,
destination: Option<IPv4>,
) -> io::Result<()> {
let guard = self.op_lock.lock().unwrap();
self.set_network_address_impl(address, netmask, destination, *guard)
}
/// Add IPv4 network address, netmask
pub fn add_address_v4<IPv4: ToIpv4Address, Netmask: ToIpv4Netmask>(
&self,
address: IPv4,
netmask: Netmask,
) -> io::Result<()> {
let guard = self.op_lock.lock().unwrap();
let addr = address.ipv4()?.into();
let netmask = netmask.netmask()?.into();
let default_dest = self.calc_dest_addr(addr, netmask)?;
self.add_address(addr, netmask, Some(default_dest), *guard)
}
/// Removes an IP address from the interface.
pub fn remove_address(&self, addr: IpAddr) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
match addr {
IpAddr::V4(addr) => {
let mut req_v4 = self.request()?;
req_v4.ifr_ifru.ifru_addr = sockaddr_union::from((addr, 0)).addr;
if let Err(err) = siocdifaddr(ctl()?.as_raw_fd(), &req_v4) {
return Err(io::Error::from(err));
}
}
IpAddr::V6(addr) => {
let mut req_v6 = self.request_v6()?;
req_v6.ifr_ifru.ifru_addr = sockaddr_union::from((addr, 0)).addr6;
if let Err(err) = siocdifaddr_in6(ctl_v6()?.as_raw_fd(), &req_v6) {
return Err(io::Error::from(err));
}
}
}
Ok(())
}
}
/// Adds an IPv6 address to the interface.
pub fn add_address_v6<IPv6: ToIpv6Address, Netmask: ToIpv6Netmask>(
&self,
addr: IPv6,
netmask: Netmask,
) -> io::Result<()> {
let guard = self.op_lock.lock().unwrap();
self.add_address(addr.ipv6()?.into(), netmask.netmask()?.into(), None, *guard)
}
/// Sets the MAC (hardware) address for the interface.
///
/// This function constructs an interface request and copies the provided MAC address
/// into the hardware address field. It then applies the change via a system call.
/// This operation is typically supported only for TAP devices.
pub fn set_mac_address(&self, eth_addr: [u8; ETHER_ADDR_LEN as usize]) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req = self.request()?;
req.ifr_ifru.ifru_addr.sa_len = ETHER_ADDR_LEN;
req.ifr_ifru.ifru_addr.sa_family = AF_LINK as u8;
req.ifr_ifru.ifru_addr.sa_data[0..ETHER_ADDR_LEN as usize]
.copy_from_slice(eth_addr.map(|c| c as i8).as_slice());
if let Err(err) = siocsiflladdr(ctl()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
/// Retrieves the name of the network interface.
pub fn name(&self) -> io::Result<String> {
let _guard = self.op_lock.lock().unwrap();
self.name_impl()
}
/// Retrieves the MAC (hardware) address of the interface.
///
/// This function queries the MAC address by the interface name using a helper function.
/// An error is returned if the MAC address cannot be found.
pub fn mac_address(&self) -> io::Result<[u8; ETHER_ADDR_LEN as usize]> {
let _guard = self.op_lock.lock().unwrap();
let mac = mac_address_by_name(&self.name_impl()?)
.map_err(|e| io::Error::other(e.to_string()))?
.ok_or(io::Error::new(
ErrorKind::InvalidInput,
"invalid mac address",
))?;
Ok(mac.bytes())
}
}
impl From<Layer> for c_short {
fn from(layer: Layer) -> Self {
match layer {
Layer::L2 => 2,
Layer::L3 => 3,
}
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/openbsd/mod.rs | src/platform/openbsd/mod.rs | mod sys;
mod device;
pub use self::device::DeviceImpl;
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/openbsd/sys.rs | src/platform/openbsd/sys.rs | use libc::{c_char, c_int, c_uint, ifreq, sockaddr, sockaddr_in6, time_t, IFNAMSIZ};
use nix::{ioctl_readwrite, ioctl_write_ptr};
use std::ffi::c_void;
pub const IN6_IFF_NODAD: i32 = 0x0020;
#[allow(dead_code)]
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ctl_info {
pub ctl_id: c_uint,
pub ctl_name: [c_char; 96],
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub union ifra_ifrau {
pub ifrau_addr: sockaddr,
pub ifrau_align: c_int,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ifaliasreq {
pub ifra_name: [c_char; IFNAMSIZ],
pub ifra_ifrau: ifra_ifrau,
pub ifra_dstaddr: sockaddr, // == ifra_broadaddr
pub ifra_mask: sockaddr,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub union ifra_ifrau_in6 {
pub ifrau_addr: sockaddr_in6,
pub ifrau_align: c_int,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct in6_aliasreq {
pub ifra_name: [c_char; IFNAMSIZ],
pub ifra_ifrau: ifra_ifrau_in6,
pub ifra_dstaddr: sockaddr_in6,
pub ifra_prefixmask: sockaddr_in6,
pub ifra_flags: c_int,
pub ifra_lifetime: in6_addrlifetime,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct in6_ifreq {
pub ifra_name: [c_char; IFNAMSIZ],
pub ifr_ifru: ifr_ifru_in6,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub union ifr_ifru_in6 {
pub ifru_addr: sockaddr_in6,
pub ifru_dstaddr: sockaddr_in6,
pub ifru_flags: c_int,
pub ifru_flags6: c_int,
pub ifru_metric: c_int,
pub ifru_data: *const c_void,
pub ifru_lifetime: in6_addrlifetime,
pub ifru_stat: in6_ifstat,
pub ifru_icmp6stat: icmp6_ifstat,
pub ifru_scope_id: [u32; 16],
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct in6_addrlifetime {
pub ia6t_expire: time_t, /* valid lifetime expiration time */
pub ia6t_preferred: time_t, /* preferred lifetime expiration time */
pub ia6t_vltime: u32, /* valid lifetime */
pub ia6t_pltime: u32, /* prefix lifetime */
}
#[allow(non_camel_case_types)]
type u_quad_t = u64;
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct in6_ifstat {
pub ifs6_in_receive: u_quad_t, /* # of total input datagram */
pub ifs6_in_hdrerr: u_quad_t, /* # of datagrams with invalid hdr */
pub ifs6_in_toobig: u_quad_t, /* # of datagrams exceeded MTU */
pub ifs6_in_noroute: u_quad_t, /* # of datagrams with no route */
pub ifs6_in_addrerr: u_quad_t, /* # of datagrams with invalid dst */
pub ifs6_in_protounknown: u_quad_t, /* # of datagrams with unknown proto */
/* NOTE: increment on final dst if */
pub ifs6_in_truncated: u_quad_t, /* # of truncated datagrams */
pub ifs6_in_discard: u_quad_t, /* # of discarded datagrams */
/* NOTE: fragment timeout is not here */
pub ifs6_in_deliver: u_quad_t, /* # of datagrams delivered to ULP */
/* NOTE: increment on final dst if */
pub ifs6_out_forward: u_quad_t, /* # of datagrams forwarded */
/* NOTE: increment on outgoing if */
pub ifs6_out_request: u_quad_t, /* # of outgoing datagrams from ULP */
/* NOTE: does not include forwrads */
pub ifs6_out_discard: u_quad_t, /* # of discarded datagrams */
pub ifs6_out_fragok: u_quad_t, /* # of datagrams fragmented */
pub ifs6_out_fragfail: u_quad_t, /* # of datagrams failed on fragment */
pub ifs6_out_fragcreat: u_quad_t, /* # of fragment datagrams */
/* NOTE: this is # after fragment */
pub ifs6_reass_reqd: u_quad_t, /* # of incoming fragmented packets */
/* NOTE: increment on final dst if */
pub ifs6_reass_ok: u_quad_t, /* # of reassembled packets */
/* NOTE: this is # after reass */
/* NOTE: increment on final dst if */
pub ifs6_reass_fail: u_quad_t, /* # of reass failures */
/* NOTE: may not be packet count */
/* NOTE: increment on final dst if */
pub ifs6_in_mcast: u_quad_t, /* # of inbound multicast datagrams */
pub ifs6_out_mcast: u_quad_t, /* # of outbound multicast datagrams */
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct icmp6_ifstat {
/*
* Input statistics
*/
/* ipv6IfIcmpInMsgs, total # of input messages */
pub ifs6_in_msg: u_quad_t,
/* ipv6IfIcmpInErrors, # of input error messages */
pub ifs6_in_error: u_quad_t,
/* ipv6IfIcmpInDestUnreachs, # of input dest unreach errors */
pub ifs6_in_dstunreach: u_quad_t,
/* ipv6IfIcmpInAdminProhibs, # of input administratively prohibited errs */
pub ifs6_in_adminprohib: u_quad_t,
/* ipv6IfIcmpInTimeExcds, # of input time exceeded errors */
pub ifs6_in_timeexceed: u_quad_t,
/* ipv6IfIcmpInParmProblems, # of input parameter problem errors */
pub ifs6_in_paramprob: u_quad_t,
/* ipv6IfIcmpInPktTooBigs, # of input packet too big errors */
pub ifs6_in_pkttoobig: u_quad_t,
/* ipv6IfIcmpInEchos, # of input echo requests */
pub ifs6_in_echo: u_quad_t,
/* ipv6IfIcmpInEchoReplies, # of input echo replies */
pub ifs6_in_echoreply: u_quad_t,
/* ipv6IfIcmpInRouterSolicits, # of input router solicitations */
pub ifs6_in_routersolicit: u_quad_t,
/* ipv6IfIcmpInRouterAdvertisements, # of input router advertisements */
pub ifs6_in_routeradvert: u_quad_t,
/* ipv6IfIcmpInNeighborSolicits, # of input neighbor solicitations */
pub ifs6_in_neighborsolicit: u_quad_t,
/* ipv6IfIcmpInNeighborAdvertisements, # of input neighbor advertisements */
pub ifs6_in_neighboradvert: u_quad_t,
/* ipv6IfIcmpInRedirects, # of input redirects */
pub ifs6_in_redirect: u_quad_t,
/* ipv6IfIcmpInGroupMembQueries, # of input MLD queries */
pub ifs6_in_mldquery: u_quad_t,
/* ipv6IfIcmpInGroupMembResponses, # of input MLD reports */
pub ifs6_in_mldreport: u_quad_t,
/* ipv6IfIcmpInGroupMembReductions, # of input MLD done */
pub ifs6_in_mlddone: u_quad_t,
/*
* Output statistics. We should solve unresolved routing problem...
*/
/* ipv6IfIcmpOutMsgs, total # of output messages */
pub ifs6_out_msg: u_quad_t,
/* ipv6IfIcmpOutErrors, # of output error messages */
pub ifs6_out_error: u_quad_t,
/* ipv6IfIcmpOutDestUnreachs, # of output dest unreach errors */
pub ifs6_out_dstunreach: u_quad_t,
/* ipv6IfIcmpOutAdminProhibs, # of output administratively prohibited errs */
pub ifs6_out_adminprohib: u_quad_t,
/* ipv6IfIcmpOutTimeExcds, # of output time exceeded errors */
pub ifs6_out_timeexceed: u_quad_t,
/* ipv6IfIcmpOutParmProblems, # of output parameter problem errors */
pub ifs6_out_paramprob: u_quad_t,
/* ipv6IfIcmpOutPktTooBigs, # of output packet too big errors */
pub ifs6_out_pkttoobig: u_quad_t,
/* ipv6IfIcmpOutEchos, # of output echo requests */
pub ifs6_out_echo: u_quad_t,
/* ipv6IfIcmpOutEchoReplies, # of output echo replies */
pub ifs6_out_echoreply: u_quad_t,
/* ipv6IfIcmpOutRouterSolicits, # of output router solicitations */
pub ifs6_out_routersolicit: u_quad_t,
/* ipv6IfIcmpOutRouterAdvertisements, # of output router advertisements */
pub ifs6_out_routeradvert: u_quad_t,
/* ipv6IfIcmpOutNeighborSolicits, # of output neighbor solicitations */
pub ifs6_out_neighborsolicit: u_quad_t,
/* ipv6IfIcmpOutNeighborAdvertisements, # of output neighbor advertisements */
pub ifs6_out_neighboradvert: u_quad_t,
/* ipv6IfIcmpOutRedirects, # of output redirects */
pub ifs6_out_redirect: u_quad_t,
/* ipv6IfIcmpOutGroupMembQueries, # of output MLD queries */
pub ifs6_out_mldquery: u_quad_t,
/* ipv6IfIcmpOutGroupMembResponses, # of output MLD reports */
pub ifs6_out_mldreport: u_quad_t,
/* ipv6IfIcmpOutGroupMembReductions, # of output MLD done */
pub ifs6_out_mlddone: u_quad_t,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ifreq_mtu {
pub ifr_name: [c_char; IFNAMSIZ],
pub mtu: c_uint,
pub pad0: [u8; 12],
}
// https://github.com/openbsd/src/blob/25ed657ec9c4285c385bc3b3556c0dc8eb6d6665/sys/sys/sockio.h#L114
ioctl_write_ptr!(siocsifflags, b'i', 16, ifreq);
ioctl_readwrite!(siocgifflags, b'i', 17, ifreq);
ioctl_write_ptr!(siocsifaddr, b'i', 12, ifreq);
ioctl_readwrite!(siocgifaddr, b'i', 33, ifreq);
ioctl_write_ptr!(siocsifdstaddr, b'i', 14, ifreq);
ioctl_readwrite!(siocgifdstaddr, b'i', 34, ifreq);
ioctl_write_ptr!(siocsifbrdaddr, b'i', 19, ifreq);
ioctl_readwrite!(siocgifbrdaddr, b'i', 35, ifreq);
ioctl_write_ptr!(siocsifnetmask, b'i', 22, ifreq);
ioctl_readwrite!(siocgifnetmask, b'i', 37, ifreq);
ioctl_write_ptr!(siocsifmtu, b'i', 127, ifreq_mtu);
ioctl_readwrite!(siocgifmtu, b'i', 126, ifreq_mtu);
ioctl_write_ptr!(siocaifaddr, b'i', 26, ifaliasreq);
ioctl_write_ptr!(siocdifaddr, b'i', 25, ifreq);
ioctl_write_ptr!(siocsiflladdr, b'i', 31, ifreq);
ioctl_write_ptr!(siocdifaddr_in6, b'i', 25, in6_ifreq);
ioctl_write_ptr!(siocaifaddr_in6, b'i', 26, in6_aliasreq);
ioctl_write_ptr!(siocifdestroy, b'i', 121, ifreq);
ioctl_write_ptr!(siocifcreate, b'i', 122, ifreq);
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/linux/device.rs | src/platform/linux/device.rs | use crate::platform::linux::offload::{
gso_none_checksum, gso_split, handle_gro, VirtioNetHdr, VIRTIO_NET_HDR_F_NEEDS_CSUM,
VIRTIO_NET_HDR_GSO_NONE, VIRTIO_NET_HDR_GSO_TCPV4, VIRTIO_NET_HDR_GSO_TCPV6,
VIRTIO_NET_HDR_GSO_UDP_L4, VIRTIO_NET_HDR_LEN,
};
use crate::platform::unix::device::{ctl, ctl_v6};
use crate::platform::{ExpandBuffer, GROTable};
use crate::{
builder::{DeviceConfig, Layer},
platform::linux::sys::*,
platform::{
unix::{ipaddr_to_sockaddr, sockaddr_union, Fd, Tun},
ETHER_ADDR_LEN,
},
ToIpv4Address, ToIpv4Netmask, ToIpv6Address, ToIpv6Netmask,
};
use ipnet::IpNet;
use libc::{
self, c_char, c_short, ifreq, in6_ifreq, ARPHRD_ETHER, IFF_MULTI_QUEUE, IFF_NO_PI, IFF_RUNNING,
IFF_TAP, IFF_TUN, IFF_UP, IFNAMSIZ, O_RDWR,
};
use std::net::Ipv6Addr;
use std::sync::{Arc, Mutex};
use std::{
ffi::CString,
io, mem,
net::{IpAddr, Ipv4Addr},
os::unix::io::{AsRawFd, RawFd},
ptr,
};
const OVERWRITE_SIZE: usize = mem::size_of::<libc::__c_anonymous_ifr_ifru>();
/// A TUN device using the TUN/TAP Linux driver.
pub struct DeviceImpl {
pub(crate) tun: Tun,
pub(crate) vnet_hdr: bool,
pub(crate) udp_gso: bool,
flags: c_short,
pub(crate) op_lock: Arc<Mutex<()>>,
}
impl DeviceImpl {
/// Create a new `Device` for the given `Configuration`.
pub(crate) fn new(config: DeviceConfig) -> std::io::Result<Self> {
let dev_name = match config.dev_name.as_ref() {
Some(tun_name) => {
let tun_name = CString::new(tun_name.clone())?;
if tun_name.as_bytes_with_nul().len() > IFNAMSIZ {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"device name too long",
));
}
Some(tun_name)
}
None => None,
};
unsafe {
let mut req: ifreq = mem::zeroed();
if let Some(dev_name) = dev_name.as_ref() {
ptr::copy_nonoverlapping(
dev_name.as_ptr() as *const c_char,
req.ifr_name.as_mut_ptr(),
dev_name.as_bytes_with_nul().len(),
);
}
let multi_queue = config.multi_queue.unwrap_or(false);
let device_type: c_short = config.layer.unwrap_or(Layer::L3).into();
let iff_no_pi = IFF_NO_PI as c_short;
let iff_vnet_hdr = libc::IFF_VNET_HDR as c_short;
let iff_multi_queue = IFF_MULTI_QUEUE as c_short;
let packet_information = config.packet_information.unwrap_or(false);
let offload = config.offload.unwrap_or(false);
req.ifr_ifru.ifru_flags = device_type
| if packet_information { 0 } else { iff_no_pi }
| if multi_queue { iff_multi_queue } else { 0 }
| if offload { iff_vnet_hdr } else { 0 };
let fd = libc::open(
c"/dev/net/tun".as_ptr() as *const _,
O_RDWR | libc::O_CLOEXEC,
0,
);
let tun_fd = Fd::new(fd)?;
if let Err(err) = tunsetiff(tun_fd.inner, &mut req as *mut _ as *mut _) {
return Err(io::Error::from(err));
}
let (vnet_hdr, udp_gso) = if offload && libc::IFF_VNET_HDR != 0 {
// tunTCPOffloads were added in Linux v2.6. We require their support if IFF_VNET_HDR is set.
let tun_tcp_offloads = libc::TUN_F_CSUM | libc::TUN_F_TSO4 | libc::TUN_F_TSO6;
let tun_udp_offloads = libc::TUN_F_USO4 | libc::TUN_F_USO6;
if let Err(err) = tunsetoffload(tun_fd.inner, tun_tcp_offloads as _) {
log::warn!("unsupported offload: {err:?}");
(false, false)
} else {
// tunUDPOffloads were added in Linux v6.2. We do not return an
// error if they are unsupported at runtime.
let rs =
tunsetoffload(tun_fd.inner, (tun_tcp_offloads | tun_udp_offloads) as _);
(true, rs.is_ok())
}
} else {
(false, false)
};
let device = DeviceImpl {
tun: Tun::new(tun_fd),
vnet_hdr,
udp_gso,
flags: req.ifr_ifru.ifru_flags,
op_lock: Arc::new(Mutex::new(())),
};
Ok(device)
}
}
unsafe fn set_tcp_offloads(&self) -> io::Result<()> {
let tun_tcp_offloads = libc::TUN_F_CSUM | libc::TUN_F_TSO4 | libc::TUN_F_TSO6;
tunsetoffload(self.as_raw_fd(), tun_tcp_offloads as _)
.map(|_| ())
.map_err(|e| e.into())
}
unsafe fn set_tcp_udp_offloads(&self) -> io::Result<()> {
let tun_tcp_offloads = libc::TUN_F_CSUM | libc::TUN_F_TSO4 | libc::TUN_F_TSO6;
let tun_udp_offloads = libc::TUN_F_USO4 | libc::TUN_F_USO6;
tunsetoffload(self.as_raw_fd(), (tun_tcp_offloads | tun_udp_offloads) as _)
.map(|_| ())
.map_err(|e| e.into())
}
pub(crate) fn from_tun(tun: Tun) -> io::Result<Self> {
Ok(Self {
tun,
vnet_hdr: false,
udp_gso: false,
flags: 0,
op_lock: Arc::new(Mutex::new(())),
})
}
/// # Prerequisites
/// - The `IFF_MULTI_QUEUE` flag must be enabled.
/// - The system must support network interface multi-queue functionality.
///
/// # Description
/// When multi-queue is enabled, create a new queue by duplicating an existing one.
pub(crate) fn try_clone(&self) -> io::Result<DeviceImpl> {
let flags = self.flags;
if flags & (IFF_MULTI_QUEUE as c_short) != IFF_MULTI_QUEUE as c_short {
return Err(io::Error::new(
io::ErrorKind::Unsupported,
"iff_multi_queue not enabled",
));
}
unsafe {
let mut req = self.request()?;
req.ifr_ifru.ifru_flags = flags;
let fd = libc::open(
c"/dev/net/tun".as_ptr() as *const _,
O_RDWR | libc::O_CLOEXEC,
);
let tun_fd = Fd::new(fd)?;
if let Err(err) = tunsetiff(tun_fd.inner, &mut req as *mut _ as *mut _) {
return Err(io::Error::from(err));
}
let dev = DeviceImpl {
tun: Tun::new(tun_fd),
vnet_hdr: self.vnet_hdr,
udp_gso: self.udp_gso,
flags,
op_lock: self.op_lock.clone(),
};
if dev.vnet_hdr {
if dev.udp_gso {
dev.set_tcp_udp_offloads()?
} else {
dev.set_tcp_offloads()?;
}
}
Ok(dev)
}
}
/// Returns whether UDP Generic Segmentation Offload (GSO) is enabled.
///
/// This is determined by the `udp_gso` flag in the device.
pub fn udp_gso(&self) -> bool {
let _guard = self.op_lock.lock().unwrap();
self.udp_gso
}
/// Returns whether TCP Generic Segmentation Offload (GSO) is enabled.
///
/// In this implementation, this is represented by the `vnet_hdr` flag.
pub fn tcp_gso(&self) -> bool {
let _guard = self.op_lock.lock().unwrap();
self.vnet_hdr
}
/// Sets the transmit queue length for the network interface.
///
/// This method constructs an interface request (`ifreq`) structure,
/// assigns the desired transmit queue length to the `ifru_metric` field,
/// and calls the `change_tx_queue_len` function using the control file descriptor.
/// If the underlying operation fails, an I/O error is returned.
pub fn set_tx_queue_len(&self, tx_queue_len: u32) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut ifreq = self.request()?;
ifreq.ifr_ifru.ifru_metric = tx_queue_len as _;
if let Err(err) = change_tx_queue_len(ctl()?.as_raw_fd(), &ifreq) {
return Err(io::Error::from(err));
}
}
Ok(())
}
/// Retrieves the current transmit queue length for the network interface.
///
/// This function constructs an interface request structure and calls `tx_queue_len`
/// to populate it with the current transmit queue length. The value is then returned.
pub fn tx_queue_len(&self) -> io::Result<u32> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut ifreq = self.request()?;
if let Err(err) = tx_queue_len(ctl()?.as_raw_fd(), &mut ifreq) {
return Err(io::Error::from(err));
}
Ok(ifreq.ifr_ifru.ifru_metric as _)
}
}
/// Make the device persistent.
pub fn persist(&self) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
if let Err(err) = tunsetpersist(self.as_raw_fd(), &1) {
Err(io::Error::from(err))
} else {
Ok(())
}
}
}
/// Set the owner of the device.
pub fn user(&self, value: i32) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
if let Err(err) = tunsetowner(self.as_raw_fd(), &value) {
Err(io::Error::from(err))
} else {
Ok(())
}
}
}
/// Set the group of the device.
pub fn group(&self, value: i32) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
if let Err(err) = tunsetgroup(self.as_raw_fd(), &value) {
Err(io::Error::from(err))
} else {
Ok(())
}
}
}
/// send multiple fragmented data packets.
/// GROTable can be reused, as it is used to assist in data merging.
/// Offset is the starting position of the data. Need to meet offset>=10.
pub fn send_multiple<B: ExpandBuffer>(
&self,
gro_table: &mut GROTable,
bufs: &mut [B],
offset: usize,
) -> io::Result<usize> {
self.send_multiple0(gro_table, bufs, offset, |tun, buf| tun.send(buf))
}
pub(crate) fn send_multiple0<B: ExpandBuffer, W: FnMut(&Tun, &[u8]) -> io::Result<usize>>(
&self,
gro_table: &mut GROTable,
bufs: &mut [B],
mut offset: usize,
mut write_f: W,
) -> io::Result<usize> {
gro_table.reset();
if self.vnet_hdr {
handle_gro(
bufs,
offset,
&mut gro_table.tcp_gro_table,
&mut gro_table.udp_gro_table,
self.udp_gso,
&mut gro_table.to_write,
)?;
offset -= VIRTIO_NET_HDR_LEN;
} else {
for i in 0..bufs.len() {
gro_table.to_write.push(i);
}
}
let mut total = 0;
let mut err = Ok(());
for buf_idx in &gro_table.to_write {
match write_f(&self.tun, &bufs[*buf_idx].as_ref()[offset..]) {
Ok(n) => {
total += n;
}
Err(e) => {
if let Some(code) = e.raw_os_error() {
if libc::EBADFD == code {
return Err(e);
}
}
err = Err(e)
}
}
}
err?;
Ok(total)
}
/// Recv a packet from tun device.
/// If offload is enabled. This method can be used to obtain processed data.
///
/// original_buffer is used to store raw data, including the VirtioNetHdr and the unsplit IP packet. The recommended size is 10 + 65535.
/// bufs and sizes are used to store the segmented IP packets. bufs.len == sizes.len > 65535/MTU
/// offset: Starting position
pub fn recv_multiple<B: AsRef<[u8]> + AsMut<[u8]>>(
&self,
original_buffer: &mut [u8],
bufs: &mut [B],
sizes: &mut [usize],
offset: usize,
) -> io::Result<usize> {
self.recv_multiple0(original_buffer, bufs, sizes, offset, |tun, buf| {
tun.recv(buf)
})
}
pub(crate) fn recv_multiple0<
B: AsRef<[u8]> + AsMut<[u8]>,
R: Fn(&Tun, &mut [u8]) -> io::Result<usize>,
>(
&self,
original_buffer: &mut [u8],
bufs: &mut [B],
sizes: &mut [usize],
offset: usize,
read_f: R,
) -> io::Result<usize> {
if bufs.is_empty() || bufs.len() != sizes.len() {
return Err(io::Error::other("bufs error"));
}
if self.vnet_hdr {
let len = read_f(&self.tun, original_buffer)?;
if len <= VIRTIO_NET_HDR_LEN {
Err(io::Error::other(format!(
"length of packet ({len}) <= VIRTIO_NET_HDR_LEN ({VIRTIO_NET_HDR_LEN})",
)))?
}
let hdr = VirtioNetHdr::decode(&original_buffer[..VIRTIO_NET_HDR_LEN])?;
self.handle_virtio_read(
hdr,
&mut original_buffer[VIRTIO_NET_HDR_LEN..len],
bufs,
sizes,
offset,
)
} else {
let len = read_f(&self.tun, &mut bufs[0].as_mut()[offset..])?;
sizes[0] = len;
Ok(1)
}
}
/// https://github.com/WireGuard/wireguard-go/blob/12269c2761734b15625017d8565745096325392f/tun/tun_linux.go#L375
/// handleVirtioRead splits in into bufs, leaving offset bytes at the front of
/// each buffer. It mutates sizes to reflect the size of each element of bufs,
/// and returns the number of packets read.
pub(crate) fn handle_virtio_read<B: AsRef<[u8]> + AsMut<[u8]>>(
&self,
mut hdr: VirtioNetHdr,
input: &mut [u8],
bufs: &mut [B],
sizes: &mut [usize],
offset: usize,
) -> io::Result<usize> {
let len = input.len();
if hdr.gso_type == VIRTIO_NET_HDR_GSO_NONE {
if hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM != 0 {
// This means CHECKSUM_PARTIAL in skb context. We are responsible
// for computing the checksum starting at hdr.csumStart and placing
// at hdr.csumOffset.
gso_none_checksum(input, hdr.csum_start, hdr.csum_offset);
}
if bufs[0].as_ref()[offset..].len() < len {
Err(io::Error::other(format!(
"read len {len} overflows bufs element len {}",
bufs[0].as_ref().len()
)))?
}
sizes[0] = len;
bufs[0].as_mut()[offset..offset + len].copy_from_slice(input);
return Ok(1);
}
if hdr.gso_type != VIRTIO_NET_HDR_GSO_TCPV4
&& hdr.gso_type != VIRTIO_NET_HDR_GSO_TCPV6
&& hdr.gso_type != VIRTIO_NET_HDR_GSO_UDP_L4
{
Err(io::Error::other(format!(
"unsupported virtio GSO type: {}",
hdr.gso_type
)))?
}
let ip_version = input[0] >> 4;
match ip_version {
4 => {
if hdr.gso_type != VIRTIO_NET_HDR_GSO_TCPV4
&& hdr.gso_type != VIRTIO_NET_HDR_GSO_UDP_L4
{
Err(io::Error::other(format!(
"ip header version: 4, GSO type: {}",
hdr.gso_type
)))?
}
}
6 => {
if hdr.gso_type != VIRTIO_NET_HDR_GSO_TCPV6
&& hdr.gso_type != VIRTIO_NET_HDR_GSO_UDP_L4
{
Err(io::Error::other(format!(
"ip header version: 6, GSO type: {}",
hdr.gso_type
)))?
}
}
ip_version => Err(io::Error::other(format!(
"invalid ip header version: {ip_version}"
)))?,
}
// Don't trust hdr.hdrLen from the kernel as it can be equal to the length
// of the entire first packet when the kernel is handling it as part of a
// FORWARD path. Instead, parse the transport header length and add it onto
// csumStart, which is synonymous for IP header length.
if hdr.gso_type == VIRTIO_NET_HDR_GSO_UDP_L4 {
hdr.hdr_len = hdr.csum_start + 8
} else {
if len <= hdr.csum_start as usize + 12 {
Err(io::Error::other("packet is too short"))?
}
let tcp_h_len = ((input[hdr.csum_start as usize + 12] as u16) >> 4) * 4;
if !(20..=60).contains(&tcp_h_len) {
// A TCP header must be between 20 and 60 bytes in length.
Err(io::Error::other(format!(
"tcp header len is invalid: {tcp_h_len}"
)))?
}
hdr.hdr_len = hdr.csum_start + tcp_h_len
}
if len < hdr.hdr_len as usize {
Err(io::Error::other(format!(
"length of packet ({len}) < virtioNetHdr.hdr_len ({})",
hdr.hdr_len
)))?
}
if hdr.hdr_len < hdr.csum_start {
Err(io::Error::other(format!(
"virtioNetHdr.hdrLen ({}) < virtioNetHdr.csumStart ({})",
hdr.hdr_len, hdr.csum_start
)))?
}
let c_sum_at = (hdr.csum_start + hdr.csum_offset) as usize;
if c_sum_at + 1 >= len {
Err(io::Error::other(format!(
"end of checksum offset ({}) exceeds packet length ({len})",
c_sum_at + 1,
)))?
}
gso_split(input, hdr, bufs, sizes, offset, ip_version == 6)
}
pub fn remove_address_v6_impl(&self, addr: Ipv6Addr, prefix: u8) -> io::Result<()> {
unsafe {
let if_index = self.if_index_impl()?;
let ctl = ctl_v6()?;
let mut ifrv6: in6_ifreq = mem::zeroed();
ifrv6.ifr6_ifindex = if_index as i32;
ifrv6.ifr6_prefixlen = prefix as _;
ifrv6.ifr6_addr = sockaddr_union::from(std::net::SocketAddr::new(addr.into(), 0))
.addr6
.sin6_addr;
if let Err(err) = siocdifaddr_in6(ctl.as_raw_fd(), &ifrv6) {
return Err(io::Error::from(err));
}
}
Ok(())
}
}
impl DeviceImpl {
/// Prepare a new request.
unsafe fn request(&self) -> io::Result<ifreq> {
request(&self.name_impl()?)
}
fn set_address_v4(&self, addr: Ipv4Addr) -> io::Result<()> {
unsafe {
let mut req = self.request()?;
ipaddr_to_sockaddr(addr, 0, &mut req.ifr_ifru.ifru_addr, OVERWRITE_SIZE);
if let Err(err) = siocsifaddr(ctl()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
}
Ok(())
}
fn set_netmask(&self, value: Ipv4Addr) -> io::Result<()> {
unsafe {
let mut req = self.request()?;
ipaddr_to_sockaddr(value, 0, &mut req.ifr_ifru.ifru_netmask, OVERWRITE_SIZE);
if let Err(err) = siocsifnetmask(ctl()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
fn set_destination(&self, value: Ipv4Addr) -> io::Result<()> {
unsafe {
let mut req = self.request()?;
ipaddr_to_sockaddr(value, 0, &mut req.ifr_ifru.ifru_dstaddr, OVERWRITE_SIZE);
if let Err(err) = siocsifdstaddr(ctl()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
/// Retrieves the name of the network interface.
pub(crate) fn name_impl(&self) -> io::Result<String> {
unsafe { name(self.as_raw_fd()) }
}
fn ifru_flags(&self) -> io::Result<i16> {
unsafe {
let ctl = ctl()?;
let mut req = self.request()?;
if let Err(err) = siocgifflags(ctl.as_raw_fd(), &mut req) {
return Err(io::Error::from(err));
}
Ok(req.ifr_ifru.ifru_flags)
}
}
fn remove_all_address_v4(&self) -> io::Result<()> {
let interface = netconfig_rs::Interface::try_from_index(self.if_index_impl()?)
.map_err(io::Error::from)?;
let list = interface.addresses().map_err(io::Error::from)?;
for x in list {
if x.addr().is_ipv4() {
interface.remove_address(x).map_err(io::Error::from)?;
}
}
Ok(())
}
}
//Public User Interface
impl DeviceImpl {
/// Retrieves the name of the network interface.
pub fn name(&self) -> io::Result<String> {
let _guard = self.op_lock.lock().unwrap();
self.name_impl()
}
pub fn remove_address_v6(&self, addr: Ipv6Addr, prefix: u8) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
self.remove_address_v6_impl(addr, prefix)
}
/// Sets a new name for the network interface.
///
/// This function converts the provided name into a C-compatible string,
/// checks that its length does not exceed the maximum allowed (IFNAMSIZ),
/// and then copies it into an interface request structure. It then uses a system call
/// (via `siocsifname`) to apply the new name.
pub fn set_name(&self, value: &str) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let tun_name = CString::new(value)?;
if tun_name.as_bytes_with_nul().len() > IFNAMSIZ {
return Err(io::Error::new(io::ErrorKind::InvalidInput, "name too long"));
}
let mut req = self.request()?;
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifr_ifru.ifru_newname.as_mut_ptr(),
value.len(),
);
if let Err(err) = siocsifname(ctl()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
/// Checks whether the network interface is currently running.
///
/// The interface is considered running if both the IFF_UP and IFF_RUNNING flags are set.
pub fn is_running(&self) -> io::Result<bool> {
let _guard = self.op_lock.lock().unwrap();
let flags = self.ifru_flags()?;
Ok(flags & (IFF_UP | IFF_RUNNING) as c_short == (IFF_UP | IFF_RUNNING) as c_short)
}
/// Enables or disables the network interface.
///
/// If `value` is true, the interface is enabled by setting the IFF_UP and IFF_RUNNING flags.
/// If false, the IFF_UP flag is cleared. The change is applied using a system call.
pub fn enabled(&self, value: bool) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let ctl = ctl()?;
let mut req = self.request()?;
if let Err(err) = siocgifflags(ctl.as_raw_fd(), &mut req) {
return Err(io::Error::from(err));
}
if value {
req.ifr_ifru.ifru_flags |= (IFF_UP | IFF_RUNNING) as c_short;
} else {
req.ifr_ifru.ifru_flags &= !(IFF_UP as c_short);
}
if let Err(err) = siocsifflags(ctl.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
/// Retrieves the broadcast address of the network interface.
///
/// This function populates an interface request with the broadcast address via a system call,
/// converts it into a sockaddr structure, and then extracts the IP address.
pub fn broadcast(&self) -> io::Result<IpAddr> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req = self.request()?;
if let Err(err) = siocgifbrdaddr(ctl()?.as_raw_fd(), &mut req) {
return Err(io::Error::from(err));
}
let sa = sockaddr_union::from(req.ifr_ifru.ifru_broadaddr);
Ok(std::net::SocketAddr::try_from(sa)?.ip())
}
}
/// Sets the broadcast address of the network interface.
///
/// This function converts the given IP address into a sockaddr structure (with a specified overwrite size)
/// and then applies it to the interface via a system call.
pub fn set_broadcast(&self, value: IpAddr) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req = self.request()?;
ipaddr_to_sockaddr(value, 0, &mut req.ifr_ifru.ifru_broadaddr, OVERWRITE_SIZE);
if let Err(err) = siocsifbrdaddr(ctl()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
/// Sets the IPv4 network address, netmask, and an optional destination address.
/// Remove all previous set IPv4 addresses and set the specified address.
pub fn set_network_address<IPv4: ToIpv4Address, Netmask: ToIpv4Netmask>(
&self,
address: IPv4,
netmask: Netmask,
destination: Option<IPv4>,
) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
self.remove_all_address_v4()?;
self.set_address_v4(address.ipv4()?)?;
self.set_netmask(netmask.netmask()?)?;
if let Some(destination) = destination {
self.set_destination(destination.ipv4()?)?;
}
Ok(())
}
/// Add IPv4 network address, netmask
pub fn add_address_v4<IPv4: ToIpv4Address, Netmask: ToIpv4Netmask>(
&self,
address: IPv4,
netmask: Netmask,
) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
let interface = netconfig_rs::Interface::try_from_index(self.if_index_impl()?)
.map_err(io::Error::from)?;
interface
.add_address(IpNet::new_assert(address.ipv4()?.into(), netmask.prefix()?))
.map_err(io::Error::from)
}
/// Removes an IP address from the interface.
///
/// For IPv4 addresses, it iterates over the current addresses and if a match is found,
/// resets the address to `0.0.0.0` (unspecified).
/// For IPv6 addresses, it retrieves the interface addresses by name and removes the matching address,
/// taking into account its prefix length.
pub fn remove_address(&self, addr: IpAddr) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
match addr {
IpAddr::V4(_) => {
let interface = netconfig_rs::Interface::try_from_index(self.if_index_impl()?)
.map_err(io::Error::from)?;
let list = interface.addresses().map_err(io::Error::from)?;
for x in list {
if x.addr() == addr {
interface.remove_address(x).map_err(io::Error::from)?;
}
}
}
IpAddr::V6(addr_v6) => {
let addrs = crate::platform::get_if_addrs_by_name(self.name_impl()?)?;
for x in addrs {
if x.address == addr {
if let Some(netmask) = x.netmask {
let prefix = ipnet::ip_mask_to_prefix(netmask).unwrap_or(0);
self.remove_address_v6_impl(addr_v6, prefix)?
}
}
}
}
}
Ok(())
}
/// Adds an IPv6 address to the interface.
///
/// This function creates an `in6_ifreq` structure, fills in the interface index,
/// prefix length, and IPv6 address (converted into a sockaddr structure),
/// and then applies it using a system call.
pub fn add_address_v6<IPv6: ToIpv6Address, Netmask: ToIpv6Netmask>(
&self,
addr: IPv6,
netmask: Netmask,
) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let if_index = self.if_index_impl()?;
let ctl = ctl_v6()?;
let mut ifrv6: in6_ifreq = mem::zeroed();
ifrv6.ifr6_ifindex = if_index as i32;
ifrv6.ifr6_prefixlen = netmask.prefix()? as u32;
ifrv6.ifr6_addr =
sockaddr_union::from(std::net::SocketAddr::new(addr.ipv6()?.into(), 0))
.addr6
.sin6_addr;
if let Err(err) = siocsifaddr_in6(ctl.as_raw_fd(), &ifrv6) {
return Err(io::Error::from(err));
}
}
Ok(())
}
/// Retrieves the current MTU (Maximum Transmission Unit) for the interface.
///
/// This function constructs an interface request and uses a system call (via `siocgifmtu`)
/// to obtain the MTU. The result is then converted to a u16.
pub fn mtu(&self) -> io::Result<u16> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req = self.request()?;
if let Err(err) = siocgifmtu(ctl()?.as_raw_fd(), &mut req) {
return Err(io::Error::from(err));
}
req.ifr_ifru
.ifru_mtu
.try_into()
.map_err(|e| io::Error::new(io::ErrorKind::InvalidData, format!("{e:?}")))
}
}
/// Sets the MTU (Maximum Transmission Unit) for the interface.
///
/// This function creates an interface request, sets the `ifru_mtu` field to the new value,
/// and then applies it via a system call.
pub fn set_mtu(&self, value: u16) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req = self.request()?;
req.ifr_ifru.ifru_mtu = value as i32;
if let Err(err) = siocsifmtu(ctl()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
/// Sets the MAC (hardware) address for the interface.
///
/// This function constructs an interface request and copies the provided MAC address
/// into the hardware address field. It then applies the change via a system call.
/// This operation is typically supported only for TAP devices.
pub fn set_mac_address(&self, eth_addr: [u8; ETHER_ADDR_LEN as usize]) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req = self.request()?;
req.ifr_ifru.ifru_hwaddr.sa_family = ARPHRD_ETHER;
req.ifr_ifru.ifru_hwaddr.sa_data[0..ETHER_ADDR_LEN as usize]
.copy_from_slice(eth_addr.map(|c| c as _).as_slice());
if let Err(err) = siocsifhwaddr(ctl()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
/// Retrieves the MAC (hardware) address of the interface.
///
/// This function queries the MAC address by the interface name using a helper function.
/// An error is returned if the MAC address cannot be found.
pub fn mac_address(&self) -> io::Result<[u8; ETHER_ADDR_LEN as usize]> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req = self.request()?;
siocgifhwaddr(ctl()?.as_raw_fd(), &mut req).map_err(io::Error::from)?;
let hw = &req.ifr_ifru.ifru_hwaddr.sa_data;
let mut mac = [0u8; ETHER_ADDR_LEN as usize];
for (i, b) in hw.iter().take(6).enumerate() {
mac[i] = *b as u8;
}
Ok(mac)
}
}
}
unsafe fn name(fd: RawFd) -> io::Result<String> {
let mut req: ifreq = mem::zeroed();
if let Err(err) = tungetiff(fd, &mut req as *mut _ as *mut _) {
return Err(io::Error::from(err));
}
let c_str = std::ffi::CStr::from_ptr(req.ifr_name.as_ptr() as *const c_char);
let tun_name = c_str.to_string_lossy().into_owned();
Ok(tun_name)
}
unsafe fn request(name: &str) -> io::Result<ifreq> {
let mut req: ifreq = mem::zeroed();
ptr::copy_nonoverlapping(
name.as_ptr() as *const c_char,
req.ifr_name.as_mut_ptr(),
name.len(),
);
Ok(req)
}
impl From<Layer> for c_short {
fn from(layer: Layer) -> Self {
match layer {
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | true |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/linux/checksum.rs | src/platform/linux/checksum.rs | use byteorder::{BigEndian, ByteOrder};
/// A pure Rust scalar (non-SIMD) implementation for the checksum accumulation.
///
/// It uses a simple loop instead of manual unrolling for better clarity and maintainability.
fn checksum_no_fold_scalar(mut b: &[u8], initial: u64) -> u64 {
let mut accumulator = initial;
// Process the slice in 4-byte (u32) chunks.
while b.len() >= 4 {
accumulator += BigEndian::read_u32(&b[0..4]) as u64;
b = &b[4..];
}
// Handle the remaining 1-3 bytes.
if b.len() >= 2 {
accumulator += BigEndian::read_u16(&b[0..2]) as u64;
b = &b[2..];
}
if let Some(&byte) = b.first() {
// For odd-length inputs, the last byte is treated as the high byte
// of a 16-bit word (e.g., [0xAB] becomes 0xAB00), as per RFC 1071.
accumulator += (byte as u64) << 8;
}
accumulator
}
/// A SIMD-accelerated (AVX2) implementation for the checksum accumulation.
///
/// # Safety
/// Caller must ensure this function is called only on CPUs that support AVX2.
#[cfg(target_arch = "x86_64")]
#[target_feature(enable = "avx2")]
unsafe fn checksum_no_fold_avx2(mut b: &[u8], initial: u64) -> u64 {
use std::arch::x86_64::*;
let mut accumulator = initial;
const CHUNK_SIZE: usize = 32; // AVX2 processes 32 bytes (256 bits) at a time.
if b.len() >= CHUNK_SIZE {
// Use a 256-bit vector to hold four 64-bit partial sums.
let mut sums = _mm256_setzero_si256();
// Shuffle mask to reverse byte order from Big Endian to Little Endian for each 32-bit integer.
let shuffle_mask = _mm256_set_epi8(
12, 13, 14, 15, 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15, 8, 9, 10, 11, 4,
5, 6, 7, 0, 1, 2, 3,
);
while b.len() >= CHUNK_SIZE {
// Load 32 bytes of data.
let data = _mm256_loadu_si256(b.as_ptr() as *const __m256i);
// Swap byte order from BE to LE.
let swapped = _mm256_shuffle_epi8(data, shuffle_mask);
// Widen the lower 4 u32s to u64s and add them to the accumulator.
let lower_u64 = _mm256_cvtepu32_epi64(_mm256_extracti128_si256(swapped, 0));
sums = _mm256_add_epi64(sums, lower_u64);
// Widen the upper 4 u32s to u64s and add them to the accumulator.
let upper_u64 = _mm256_cvtepu32_epi64(_mm256_extracti128_si256(swapped, 1));
sums = _mm256_add_epi64(sums, upper_u64);
b = &b[CHUNK_SIZE..];
}
// Perform a horizontal sum to combine the partial sums in the vector.
accumulator += _mm256_extract_epi64(sums, 0) as u64;
accumulator += _mm256_extract_epi64(sums, 1) as u64;
accumulator += _mm256_extract_epi64(sums, 2) as u64;
accumulator += _mm256_extract_epi64(sums, 3) as u64;
}
// Process any remaining data using the scalar implementation.
checksum_no_fold_scalar(b, accumulator)
}
/// A SIMD-accelerated (SSE4.1) implementation for the checksum accumulation.
///
/// # Safety
/// Caller must ensure this function is called only on CPUs that support SSE4.1.
#[cfg(target_arch = "x86_64")]
#[target_feature(enable = "sse4.1")]
unsafe fn checksum_no_fold_sse41(mut b: &[u8], initial: u64) -> u64 {
use std::arch::x86_64::*;
let mut accumulator = initial;
const CHUNK_SIZE: usize = 16; // SSE processes 16 bytes (128 bits) at a time.
if b.len() >= CHUNK_SIZE {
// Use a 128-bit vector to hold two 64-bit partial sums.
let mut sums = _mm_setzero_si128();
// Shuffle mask to reverse byte order from Big Endian to Little Endian for each 32-bit integer.
let shuffle_mask = _mm_set_epi8(12, 13, 14, 15, 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3);
while b.len() >= CHUNK_SIZE {
// Load 16 bytes of data.
let data = _mm_loadu_si128(b.as_ptr() as *const __m128i);
// Swap byte order from BE to LE.
let swapped = _mm_shuffle_epi8(data, shuffle_mask);
// Widen the lower 2 u32s to u64s and add them to the accumulator.
let lower_u64 = _mm_cvtepu32_epi64(swapped);
sums = _mm_add_epi64(sums, lower_u64);
// Widen the upper 2 u32s to u64s and add them to the accumulator.
let upper_u64 = _mm_cvtepu32_epi64(_mm_bsrli_si128(swapped, 8));
sums = _mm_add_epi64(sums, upper_u64);
b = &b[CHUNK_SIZE..];
}
// Horizontal sum of the two 64-bit lanes.
accumulator += _mm_cvtsi128_si64(sums) as u64;
accumulator += _mm_extract_epi64(sums, 1) as u64;
}
// Process any remaining data using the scalar implementation.
checksum_no_fold_scalar(b, accumulator)
}
/// Calculates a checksum accumulator over a byte slice without the final fold.
///
/// This function dispatches to the optimal implementation at runtime (AVX2, SSE4.1,
/// or scalar) based on CPU feature detection. The algorithm is consistent with the
/// WireGuard-Go implementation: it treats the input as a sequence of big-endian u32s,
/// accumulates them as u64s, and handles the remainder.
#[inline]
pub fn checksum_no_fold(b: &[u8], initial: u64) -> u64 {
// Dispatch to the best available implementation based on runtime CPU feature detection.
#[cfg(target_arch = "x86_64")]
{
if is_x86_feature_detected!("avx2") {
// SAFETY: We have just checked that the CPU supports AVX2.
return unsafe { checksum_no_fold_avx2(b, initial) };
}
if is_x86_feature_detected!("sse4.1") {
// SAFETY: We have just checked that the CPU supports SSE4.1.
return unsafe { checksum_no_fold_sse41(b, initial) };
}
}
// TODO: AArch64 (ARM) NEON SIMD optimization could be added here.
// #[cfg(target_arch = "aarch64")] { ... }
// Fall back to the scalar implementation if no SIMD features are available.
checksum_no_fold_scalar(b, initial)
}
/// Calculates the final 16-bit internet checksum.
///
/// This performs the standard one's complement sum fold-down of a 64-bit accumulator
/// into a 16-bit value. The loop ensures correctness regardless of the initial magnitude
/// of the accumulator.
pub fn checksum(b: &[u8], initial: u64) -> u16 {
let mut accumulator = checksum_no_fold(b, initial);
// Fold the 64-bit accumulator into 16 bits.
while accumulator > 0xFFFF {
accumulator = (accumulator >> 16) + (accumulator & 0xFFFF);
}
accumulator as u16
}
/// Calculates the checksum accumulator for a TCP/UDP pseudo-header.
///
/// This function also benefits from the `checksum_no_fold` optimizations.
pub fn pseudo_header_checksum_no_fold(
protocol: u8,
src_addr: &[u8],
dst_addr: &[u8],
total_len: u16,
) -> u64 {
// Accumulate the source and destination addresses.
let sum = checksum_no_fold(src_addr, 0);
let sum = checksum_no_fold(dst_addr, sum);
// The pseudo-header trailer consists of {0, protocol, total_len}.
// We construct this 4-byte sequence and add its checksum to the sum.
let len_bytes = total_len.to_be_bytes();
let trailer = [0, protocol, len_bytes[0], len_bytes[1]];
checksum_no_fold(&trailer, sum)
}
#[cfg(test)]
mod tests {
use rand::Rng;
// Assuming these paths are correct for your project structure
use crate::platform::linux::checksum::{
checksum_no_fold_avx2, checksum_no_fold_scalar, checksum_no_fold_sse41,
};
#[test]
fn test_checksum_avx2_vs_scalar_output() {
// Only run this test on x86/x64 architectures if AVX2 feature is detected
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
if !is_x86_feature_detected!("avx2") {
println!("AVX2 feature not detected. Skipping AVX2 checksum output comparison tests.");
return;
}
// Initialize random number generator
let mut rng = rand::rng(); // Changed from rand::rng() to rand::thread_rng() for correctness
// Test data lengths, including boundary cases and lengths larger than CHUNK_SIZE
let test_lengths = [31, 32, 33, 63, 64, 65, 100, 1024, 4096];
// Different initial accumulator values
let initial_values = [0u64, 1u64, 12345u64];
println!(
"\n--- Comparing checksum_no_fold_avx2 output with checksum_no_fold_scalar output ---"
);
println!("Note: These two functions perform different types of summations (u32 vs u8).");
println!("If this test fails, it's likely due to this fundamental difference in calculation logic,");
println!(
"not necessarily an 'error' in implementation, but a mismatch in expected behavior."
);
for &len in &test_lengths {
for &initial in &initial_values {
// Generate random data
let mut data = vec![0u8; len];
rng.fill(&mut data[..]);
// Calculate the expected value using the scalar benchmark function
let expected = checksum_no_fold_scalar(&data, initial);
if is_x86_feature_detected!("avx2") {
// Calculate the actual value using the AVX2 function
let actual = unsafe { checksum_no_fold_avx2(&data, initial) };
// Assert that the results are equal
assert_eq!(
actual,
expected,
"Output Mismatch! Length: {len}, Initial: {initial}, Data: {data:?}\nAVX2 Result: {actual}\nScalar Result: {expected}",
);
}
if is_x86_feature_detected!("sse4.1") {
let actual = unsafe { checksum_no_fold_sse41(&data, initial) };
// Assert that the results are equal
assert_eq!(
actual,
expected,
"Output Mismatch! Length: {len}, Initial: {initial}, Data: {data:?}\nsse41 Result: {actual}\nScalar Result: {expected}",
);
}
}
}
println!("\nAll output comparison tests passed (assuming expected mismatch is handled by design).");
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/linux/mod.rs | src/platform/linux/mod.rs | mod sys;
mod checksum;
mod device;
pub(crate) mod offload;
pub use device::DeviceImpl;
pub use offload::ExpandBuffer;
pub use offload::GROTable;
pub use offload::IDEAL_BATCH_SIZE;
pub use offload::VIRTIO_NET_HDR_LEN;
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/linux/offload.rs | src/platform/linux/offload.rs | /// https://github.com/WireGuard/wireguard-go/blob/master/tun/offload_linux.go
use crate::platform::linux::checksum::{checksum, pseudo_header_checksum_no_fold};
use byteorder::{BigEndian, ByteOrder};
use bytes::BytesMut;
use libc::{IPPROTO_TCP, IPPROTO_UDP};
use std::collections::HashMap;
use std::io;
/// https://github.com/torvalds/linux/blob/master/include/uapi/linux/virtio_net.h
pub const VIRTIO_NET_HDR_GSO_NONE: u8 = 0;
pub const VIRTIO_NET_HDR_F_NEEDS_CSUM: u8 = 1;
pub const VIRTIO_NET_HDR_GSO_TCPV4: u8 = 1;
pub const VIRTIO_NET_HDR_GSO_TCPV6: u8 = 4;
pub const VIRTIO_NET_HDR_GSO_UDP_L4: u8 = 5;
/// <https://github.com/WireGuard/wireguard-go/blob/master/conn/conn.go#L19>
///
/// maximum number of packets handled per read and write
pub const IDEAL_BATCH_SIZE: usize = 128;
const TCP_FLAGS_OFFSET: usize = 13;
const TCP_FLAG_FIN: u8 = 0x01;
const TCP_FLAG_PSH: u8 = 0x08;
const TCP_FLAG_ACK: u8 = 0x10;
/// virtioNetHdr is defined in the kernel in include/uapi/linux/virtio_net.h. The
/// kernel symbol is virtio_net_hdr.
///
/// https://github.com/torvalds/linux/blob/master/include/uapi/linux/virtio_net.h
#[repr(C)]
#[derive(Debug, Clone, Copy, Default)]
pub struct VirtioNetHdr {
// #define VIRTIO_NET_HDR_F_NEEDS_CSUM 1 /* Use csum_start, csum_offset */
// #define VIRTIO_NET_HDR_F_DATA_VALID 2 /* Csum is valid */
// #define VIRTIO_NET_HDR_F_RSC_INFO 4 /* rsc info in csum_ fields */
pub flags: u8,
// #define VIRTIO_NET_HDR_GSO_NONE 0 /* Not a GSO frame */
// #define VIRTIO_NET_HDR_GSO_TCPV4 1 /* GSO frame, IPv4 TCP (TSO) */
// #define VIRTIO_NET_HDR_GSO_UDP 3 /* GSO frame, IPv4 UDP (UFO) */
// #define VIRTIO_NET_HDR_GSO_TCPV6 4 /* GSO frame, IPv6 TCP */
// #define VIRTIO_NET_HDR_GSO_UDP_L4 5 /* GSO frame, IPv4& IPv6 UDP (USO) */
// #define VIRTIO_NET_HDR_GSO_ECN 0x80 /* TCP has ECN set */
pub gso_type: u8,
// Ethernet + IP + tcp/udp hdrs
pub hdr_len: u16,
// Bytes to append to hdr_len per frame
pub gso_size: u16,
// Checksum calculation
pub csum_start: u16,
pub csum_offset: u16,
}
impl VirtioNetHdr {
pub fn decode(buf: &[u8]) -> io::Result<VirtioNetHdr> {
if buf.len() < VIRTIO_NET_HDR_LEN {
return Err(io::Error::new(io::ErrorKind::InvalidInput, "too short"));
}
let mut hdr = std::mem::MaybeUninit::<VirtioNetHdr>::uninit();
unsafe {
// Safety:
// hdr is written by `buf`, both pointers satisfy the alignment requirement of `u8`
std::ptr::copy_nonoverlapping(
buf.as_ptr(),
hdr.as_mut_ptr() as *mut _,
std::mem::size_of::<VirtioNetHdr>(),
);
Ok(hdr.assume_init())
}
}
pub fn encode(&self, buf: &mut [u8]) -> io::Result<()> {
if buf.len() < VIRTIO_NET_HDR_LEN {
return Err(io::Error::new(io::ErrorKind::InvalidInput, "too short"));
}
unsafe {
let hdr_ptr = self as *const VirtioNetHdr as *const u8;
std::ptr::copy_nonoverlapping(hdr_ptr, buf.as_mut_ptr(), VIRTIO_NET_HDR_LEN);
Ok(())
}
}
}
// virtioNetHdrLen is the length in bytes of virtioNetHdr. This matches the
// shape of the C ABI for its kernel counterpart -- sizeof(virtio_net_hdr).
pub const VIRTIO_NET_HDR_LEN: usize = std::mem::size_of::<VirtioNetHdr>();
/// tcpFlowKey represents the key for a TCP flow.
#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
pub struct TcpFlowKey {
src_addr: [u8; 16],
dst_addr: [u8; 16],
src_port: u16,
dst_port: u16,
rx_ack: u32, // varying ack values should not be coalesced. Treat them as separate flows.
is_v6: bool,
}
/// tcpGROTable holds flow and coalescing information for the purposes of TCP GRO.
pub struct TcpGROTable {
items_by_flow: HashMap<TcpFlowKey, Vec<TcpGROItem>>,
items_pool: Vec<Vec<TcpGROItem>>,
}
impl Default for TcpGROTable {
fn default() -> Self {
Self::new()
}
}
impl TcpGROTable {
fn new() -> Self {
let mut items_pool = Vec::with_capacity(IDEAL_BATCH_SIZE);
for _ in 0..IDEAL_BATCH_SIZE {
items_pool.push(Vec::with_capacity(IDEAL_BATCH_SIZE));
}
TcpGROTable {
items_by_flow: HashMap::with_capacity(IDEAL_BATCH_SIZE),
items_pool,
}
}
}
impl TcpFlowKey {
fn new(pkt: &[u8], src_addr_offset: usize, dst_addr_offset: usize, tcph_offset: usize) -> Self {
let mut key = TcpFlowKey {
src_addr: [0; 16],
dst_addr: [0; 16],
src_port: 0,
dst_port: 0,
rx_ack: 0,
is_v6: false,
};
let addr_size = dst_addr_offset - src_addr_offset;
key.src_addr[..addr_size].copy_from_slice(&pkt[src_addr_offset..dst_addr_offset]);
key.dst_addr[..addr_size]
.copy_from_slice(&pkt[dst_addr_offset..dst_addr_offset + addr_size]);
key.src_port = BigEndian::read_u16(&pkt[tcph_offset..]);
key.dst_port = BigEndian::read_u16(&pkt[tcph_offset + 2..]);
key.rx_ack = BigEndian::read_u32(&pkt[tcph_offset + 8..]);
key.is_v6 = addr_size == 16;
key
}
}
impl TcpGROTable {
/// lookupOrInsert looks up a flow for the provided packet and metadata,
/// returning the packets found for the flow, or inserting a new one if none
/// is found.
fn lookup_or_insert(
&mut self,
pkt: &[u8],
src_addr_offset: usize,
dst_addr_offset: usize,
tcph_offset: usize,
tcph_len: usize,
bufs_index: usize,
) -> Option<&mut Vec<TcpGROItem>> {
let key = TcpFlowKey::new(pkt, src_addr_offset, dst_addr_offset, tcph_offset);
if self.items_by_flow.contains_key(&key) {
return self.items_by_flow.get_mut(&key);
}
// Insert the new item into the table
self.insert(
pkt,
src_addr_offset,
dst_addr_offset,
tcph_offset,
tcph_len,
bufs_index,
);
None
}
/// insert an item in the table for the provided packet and packet metadata.
fn insert(
&mut self,
pkt: &[u8],
src_addr_offset: usize,
dst_addr_offset: usize,
tcph_offset: usize,
tcph_len: usize,
bufs_index: usize,
) {
let key = TcpFlowKey::new(pkt, src_addr_offset, dst_addr_offset, tcph_offset);
let item = TcpGROItem {
key,
bufs_index: bufs_index as u16,
num_merged: 0,
gso_size: pkt[tcph_offset + tcph_len..].len() as u16,
iph_len: tcph_offset as u8,
tcph_len: tcph_len as u8,
sent_seq: BigEndian::read_u32(&pkt[tcph_offset + 4..tcph_offset + 8]),
psh_set: pkt[tcph_offset + TCP_FLAGS_OFFSET] & TCP_FLAG_PSH != 0,
};
let items = self
.items_by_flow
.entry(key)
.or_insert_with(|| self.items_pool.pop().unwrap_or_default());
items.push(item);
}
}
// func (t *tcpGROTable) updateAt(item tcpGROItem, i int) {
// items, _ := t.itemsByFlow[item.key]
// items[i] = item
// }
//
// func (t *tcpGROTable) deleteAt(key tcpFlowKey, i int) {
// items, _ := t.itemsByFlow[key]
// items = append(items[:i], items[i+1:]...)
// t.itemsByFlow[key] = items
// }
/// tcpGROItem represents bookkeeping data for a TCP packet during the lifetime
/// of a GRO evaluation across a vector of packets.
#[derive(Debug, Clone, Copy)]
pub struct TcpGROItem {
key: TcpFlowKey,
sent_seq: u32, // the sequence number
bufs_index: u16, // the index into the original bufs slice
num_merged: u16, // the number of packets merged into this item
gso_size: u16, // payload size
iph_len: u8, // ip header len
tcph_len: u8, // tcp header len
psh_set: bool, // psh flag is set
}
// func (t *tcpGROTable) newItems() []tcpGROItem {
// var items []tcpGROItem
// items, t.itemsPool = t.itemsPool[len(t.itemsPool)-1], t.itemsPool[:len(t.itemsPool)-1]
// return items
// }
impl TcpGROTable {
fn reset(&mut self) {
for (_key, mut items) in self.items_by_flow.drain() {
items.clear();
self.items_pool.push(items);
}
}
}
/// udpFlowKey represents the key for a UDP flow.
#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
pub struct UdpFlowKey {
src_addr: [u8; 16], // srcAddr
dst_addr: [u8; 16], // dstAddr
src_port: u16, // srcPort
dst_port: u16, // dstPort
is_v6: bool, // isV6
}
/// udpGROTable holds flow and coalescing information for the purposes of UDP GRO.
pub struct UdpGROTable {
items_by_flow: HashMap<UdpFlowKey, Vec<UdpGROItem>>,
items_pool: Vec<Vec<UdpGROItem>>,
}
impl Default for UdpGROTable {
fn default() -> Self {
UdpGROTable::new()
}
}
impl UdpGROTable {
pub fn new() -> Self {
let mut items_pool = Vec::with_capacity(IDEAL_BATCH_SIZE);
for _ in 0..IDEAL_BATCH_SIZE {
items_pool.push(Vec::with_capacity(IDEAL_BATCH_SIZE));
}
UdpGROTable {
items_by_flow: HashMap::with_capacity(IDEAL_BATCH_SIZE),
items_pool,
}
}
}
impl UdpFlowKey {
pub fn new(
pkt: &[u8],
src_addr_offset: usize,
dst_addr_offset: usize,
udph_offset: usize,
) -> UdpFlowKey {
let mut key = UdpFlowKey {
src_addr: [0; 16],
dst_addr: [0; 16],
src_port: 0,
dst_port: 0,
is_v6: false,
};
let addr_size = dst_addr_offset - src_addr_offset;
key.src_addr[..addr_size].copy_from_slice(&pkt[src_addr_offset..dst_addr_offset]);
key.dst_addr[..addr_size]
.copy_from_slice(&pkt[dst_addr_offset..dst_addr_offset + addr_size]);
key.src_port = BigEndian::read_u16(&pkt[udph_offset..]);
key.dst_port = BigEndian::read_u16(&pkt[udph_offset + 2..]);
key.is_v6 = addr_size == 16;
key
}
}
impl UdpGROTable {
/// Looks up a flow for the provided packet and metadata.
/// Returns a reference to the packets found for the flow and a boolean indicating if the flow already existed.
/// If the flow is not found, inserts a new flow and returns `None` for the items.
fn lookup_or_insert(
&mut self,
pkt: &[u8],
src_addr_offset: usize,
dst_addr_offset: usize,
udph_offset: usize,
bufs_index: usize,
) -> Option<&mut Vec<UdpGROItem>> {
let key = UdpFlowKey::new(pkt, src_addr_offset, dst_addr_offset, udph_offset);
if self.items_by_flow.contains_key(&key) {
self.items_by_flow.get_mut(&key)
} else {
// If the flow does not exist, insert a new entry.
self.insert(
pkt,
src_addr_offset,
dst_addr_offset,
udph_offset,
bufs_index,
false,
);
None
}
}
/// Inserts an item in the table for the provided packet and its metadata.
fn insert(
&mut self,
pkt: &[u8],
src_addr_offset: usize,
dst_addr_offset: usize,
udph_offset: usize,
bufs_index: usize,
c_sum_known_invalid: bool,
) {
let key = UdpFlowKey::new(pkt, src_addr_offset, dst_addr_offset, udph_offset);
let item = UdpGROItem {
key,
bufs_index: bufs_index as u16,
num_merged: 0,
gso_size: (pkt.len() - (udph_offset + UDP_H_LEN)) as u16,
iph_len: udph_offset as u8,
c_sum_known_invalid,
};
let items = self
.items_by_flow
.entry(key)
.or_insert_with(|| self.items_pool.pop().unwrap_or_default());
items.push(item);
}
}
// func (u *udpGROTable) updateAt(item udpGROItem, i int) {
// items, _ := u.itemsByFlow[item.key]
// items[i] = item
// }
/// udpGROItem represents bookkeeping data for a UDP packet during the lifetime
/// of a GRO evaluation across a vector of packets.
#[derive(Debug, Clone, Copy)]
pub struct UdpGROItem {
key: UdpFlowKey, // udpFlowKey
bufs_index: u16, // the index into the original bufs slice
num_merged: u16, // the number of packets merged into this item
gso_size: u16, // payload size
iph_len: u8, // ip header len
c_sum_known_invalid: bool, // UDP header checksum validity; a false value DOES NOT imply valid, just unknown.
}
// func (u *udpGROTable) newItems() []udpGROItem {
// var items []udpGROItem
// items, u.itemsPool = u.itemsPool[len(u.itemsPool)-1], u.itemsPool[:len(u.itemsPool)-1]
// return items
// }
impl UdpGROTable {
fn reset(&mut self) {
for (_key, mut items) in self.items_by_flow.drain() {
items.clear();
self.items_pool.push(items);
}
}
}
/// canCoalesce represents the outcome of checking if two TCP packets are
/// candidates for coalescing.
#[derive(Copy, Clone, Eq, PartialEq)]
enum CanCoalesce {
Prepend,
Unavailable,
Append,
}
/// ipHeadersCanCoalesce returns true if the IP headers found in pktA and pktB
/// meet all requirements to be merged as part of a GRO operation, otherwise it
/// returns false.
fn ip_headers_can_coalesce(pkt_a: &[u8], pkt_b: &[u8]) -> bool {
if pkt_a.len() < 9 || pkt_b.len() < 9 {
return false;
}
if pkt_a[0] >> 4 == 6 {
if pkt_a[0] != pkt_b[0] || pkt_a[1] >> 4 != pkt_b[1] >> 4 {
// cannot coalesce with unequal Traffic class values
return false;
}
if pkt_a[7] != pkt_b[7] {
// cannot coalesce with unequal Hop limit values
return false;
}
} else {
if pkt_a[1] != pkt_b[1] {
// cannot coalesce with unequal ToS values
return false;
}
if pkt_a[6] >> 5 != pkt_b[6] >> 5 {
// cannot coalesce with unequal DF or reserved bits. MF is checked
// further up the stack.
return false;
}
if pkt_a[8] != pkt_b[8] {
// cannot coalesce with unequal TTL values
return false;
}
}
true
}
/// udpPacketsCanCoalesce evaluates if pkt can be coalesced with the packet
/// described by item. iphLen and gsoSize describe pkt. bufs is the vector of
/// packets involved in the current GRO evaluation. bufsOffset is the offset at
/// which packet data begins within bufs.
fn udp_packets_can_coalesce<B: ExpandBuffer>(
pkt: &[u8],
iph_len: u8,
gso_size: u16,
item: &UdpGROItem,
bufs: &[B],
bufs_offset: usize,
) -> CanCoalesce {
let pkt_target = &bufs[item.bufs_index as usize].as_ref()[bufs_offset..];
if !ip_headers_can_coalesce(pkt, pkt_target) {
return CanCoalesce::Unavailable;
}
if (pkt_target[(iph_len as usize + UDP_H_LEN)..].len()) % (item.gso_size as usize) != 0 {
// A smaller than gsoSize packet has been appended previously.
// Nothing can come after a smaller packet on the end.
return CanCoalesce::Unavailable;
}
if gso_size > item.gso_size {
// We cannot have a larger packet following a smaller one.
return CanCoalesce::Unavailable;
}
CanCoalesce::Append
}
/// tcpPacketsCanCoalesce evaluates if pkt can be coalesced with the packet
/// described by item. This function makes considerations that match the kernel's
/// GRO self tests, which can be found in tools/testing/selftests/net/gro.c.
#[allow(clippy::too_many_arguments)]
fn tcp_packets_can_coalesce<B: ExpandBuffer>(
pkt: &[u8],
iph_len: u8,
tcph_len: u8,
seq: u32,
psh_set: bool,
gso_size: u16,
item: &TcpGROItem,
bufs: &[B],
bufs_offset: usize,
) -> CanCoalesce {
let pkt_target = &bufs[item.bufs_index as usize].as_ref()[bufs_offset..];
if tcph_len != item.tcph_len {
// cannot coalesce with unequal tcp options len
return CanCoalesce::Unavailable;
}
if tcph_len > 20
&& pkt[iph_len as usize + 20..iph_len as usize + tcph_len as usize]
!= pkt_target[item.iph_len as usize + 20..item.iph_len as usize + tcph_len as usize]
{
// cannot coalesce with unequal tcp options
return CanCoalesce::Unavailable;
}
if !ip_headers_can_coalesce(pkt, pkt_target) {
return CanCoalesce::Unavailable;
}
// seq adjacency
let mut lhs_len = item.gso_size as usize;
lhs_len += (item.num_merged as usize) * (item.gso_size as usize);
if seq == item.sent_seq.wrapping_add(lhs_len as u32) {
// pkt aligns following item from a seq num perspective
if item.psh_set {
// We cannot append to a segment that has the PSH flag set, PSH
// can only be set on the final segment in a reassembled group.
return CanCoalesce::Unavailable;
}
if pkt_target[iph_len as usize + tcph_len as usize..].len() % item.gso_size as usize != 0 {
// A smaller than gsoSize packet has been appended previously.
// Nothing can come after a smaller packet on the end.
return CanCoalesce::Unavailable;
}
if gso_size > item.gso_size {
// We cannot have a larger packet following a smaller one.
return CanCoalesce::Unavailable;
}
return CanCoalesce::Append;
} else if seq.wrapping_add(gso_size as u32) == item.sent_seq {
// pkt aligns in front of item from a seq num perspective
if psh_set {
// We cannot prepend with a segment that has the PSH flag set, PSH
// can only be set on the final segment in a reassembled group.
return CanCoalesce::Unavailable;
}
if gso_size < item.gso_size {
// We cannot have a larger packet following a smaller one.
return CanCoalesce::Unavailable;
}
if gso_size > item.gso_size && item.num_merged > 0 {
// There's at least one previous merge, and we're larger than all
// previous. This would put multiple smaller packets on the end.
return CanCoalesce::Unavailable;
}
return CanCoalesce::Prepend;
}
CanCoalesce::Unavailable
}
fn checksum_valid(pkt: &[u8], iph_len: u8, proto: u8, is_v6: bool) -> bool {
let (src_addr_at, addr_size) = if is_v6 {
(IPV6_SRC_ADDR_OFFSET, 16)
} else {
(IPV4_SRC_ADDR_OFFSET, 4)
};
let len_for_pseudo = (pkt.len() as u16).saturating_sub(iph_len as u16);
let c_sum = pseudo_header_checksum_no_fold(
proto,
&pkt[src_addr_at..src_addr_at + addr_size],
&pkt[src_addr_at + addr_size..src_addr_at + addr_size * 2],
len_for_pseudo,
);
!checksum(&pkt[iph_len as usize..], c_sum) == 0
}
/// coalesceResult represents the result of attempting to coalesce two TCP
/// packets.
enum CoalesceResult {
InsufficientCap,
PSHEnding,
ItemInvalidCSum,
PktInvalidCSum,
Success,
}
/// coalesceUDPPackets attempts to coalesce pkt with the packet described by
/// item, and returns the outcome.
fn coalesce_udp_packets<B: ExpandBuffer>(
pkt: &[u8],
item: &mut UdpGROItem,
bufs: &mut [B],
bufs_offset: usize,
is_v6: bool,
) -> CoalesceResult {
let buf = bufs[item.bufs_index as usize].as_ref();
// let pkt_head = &buf[bufs_offset..]; // the packet that will end up at the front
let headers_len = item.iph_len as usize + UDP_H_LEN;
let coalesced_len = buf[bufs_offset..].len() + pkt.len() - headers_len;
if bufs[item.bufs_index as usize].buf_capacity() < bufs_offset * 2 + coalesced_len {
// We don't want to allocate a new underlying array if capacity is
// too small.
return CoalesceResult::InsufficientCap;
}
if item.num_merged == 0
&& (item.c_sum_known_invalid
|| !checksum_valid(&buf[bufs_offset..], item.iph_len, IPPROTO_UDP as _, is_v6))
{
return CoalesceResult::ItemInvalidCSum;
}
if !checksum_valid(pkt, item.iph_len, IPPROTO_UDP as _, is_v6) {
return CoalesceResult::PktInvalidCSum;
}
bufs[item.bufs_index as usize].buf_extend_from_slice(&pkt[headers_len..]);
item.num_merged += 1;
CoalesceResult::Success
}
/// coalesceTCPPackets attempts to coalesce pkt with the packet described by
/// item, and returns the outcome. This function may swap bufs elements in the
/// event of a prepend as item's bufs index is already being tracked for writing
/// to a Device.
#[allow(clippy::too_many_arguments)]
fn coalesce_tcp_packets<B: ExpandBuffer>(
mode: CanCoalesce,
pkt: &[u8],
pkt_bufs_index: usize,
gso_size: u16,
seq: u32,
psh_set: bool,
item: &mut TcpGROItem,
bufs: &mut [B],
bufs_offset: usize,
is_v6: bool,
) -> CoalesceResult {
let pkt_head: &[u8]; // the packet that will end up at the front
let headers_len = (item.iph_len + item.tcph_len) as usize;
let coalesced_len =
bufs[item.bufs_index as usize].as_ref()[bufs_offset..].len() + pkt.len() - headers_len;
// Copy data
if mode == CanCoalesce::Prepend {
pkt_head = pkt;
if bufs[pkt_bufs_index].buf_capacity() < 2 * bufs_offset + coalesced_len {
// We don't want to allocate a new underlying array if capacity is
// too small.
return CoalesceResult::InsufficientCap;
}
if psh_set {
return CoalesceResult::PSHEnding;
}
if item.num_merged == 0
&& !checksum_valid(
&bufs[item.bufs_index as usize].as_ref()[bufs_offset..],
item.iph_len,
IPPROTO_TCP as _,
is_v6,
)
{
return CoalesceResult::ItemInvalidCSum;
}
if !checksum_valid(pkt, item.iph_len, IPPROTO_TCP as _, is_v6) {
return CoalesceResult::PktInvalidCSum;
}
item.sent_seq = seq;
let extend_by = coalesced_len - pkt_head.len();
let len = bufs[pkt_bufs_index].as_ref().len();
bufs[pkt_bufs_index].buf_resize(len + extend_by, 0);
let src = bufs[item.bufs_index as usize].as_ref()[bufs_offset + headers_len..].as_ptr();
let dst = bufs[pkt_bufs_index].as_mut()[bufs_offset + pkt.len()..].as_mut_ptr();
unsafe {
std::ptr::copy_nonoverlapping(src, dst, extend_by);
}
// Flip the slice headers in bufs as part of prepend. The index of item
// is already being tracked for writing.
bufs.swap(item.bufs_index as usize, pkt_bufs_index);
} else {
// pkt_head = &bufs[item.bufs_index as usize][bufs_offset..];
if bufs[item.bufs_index as usize].buf_capacity() < 2 * bufs_offset + coalesced_len {
// We don't want to allocate a new underlying array if capacity is
// too small.
return CoalesceResult::InsufficientCap;
}
if item.num_merged == 0
&& !checksum_valid(
&bufs[item.bufs_index as usize].as_ref()[bufs_offset..],
item.iph_len,
IPPROTO_TCP as _,
is_v6,
)
{
return CoalesceResult::ItemInvalidCSum;
}
if !checksum_valid(pkt, item.iph_len, IPPROTO_TCP as _, is_v6) {
return CoalesceResult::PktInvalidCSum;
}
if psh_set {
// We are appending a segment with PSH set.
item.psh_set = psh_set;
bufs[item.bufs_index as usize].as_mut()
[bufs_offset + item.iph_len as usize + TCP_FLAGS_OFFSET] |= TCP_FLAG_PSH;
}
// https://github.com/WireGuard/wireguard-go/blob/12269c2761734b15625017d8565745096325392f/tun/offload_linux.go#L495
// extendBy := len(pkt) - int(headersLen)
// bufs[item.bufsIndex] = append(bufs[item.bufsIndex], make([]byte, extendBy)...)
// copy(bufs[item.bufsIndex][bufsOffset+len(pktHead):], pkt[headersLen:])
bufs[item.bufs_index as usize].buf_extend_from_slice(&pkt[headers_len..]);
}
if gso_size > item.gso_size {
item.gso_size = gso_size;
}
item.num_merged += 1;
CoalesceResult::Success
}
const IPV4_FLAG_MORE_FRAGMENTS: u8 = 0x20;
const IPV4_SRC_ADDR_OFFSET: usize = 12;
const IPV6_SRC_ADDR_OFFSET: usize = 8;
// maxUint16 = 1<<16 - 1
#[derive(PartialEq, Eq)]
enum GroResult {
Noop,
TableInsert,
Coalesced,
}
/// tcpGRO evaluates the TCP packet at pktI in bufs for coalescing with
/// existing packets tracked in table. It returns a groResultNoop when no
/// action was taken, groResultTableInsert when the evaluated packet was
/// inserted into table, and groResultCoalesced when the evaluated packet was
/// coalesced with another packet in table.
fn tcp_gro<B: ExpandBuffer>(
bufs: &mut [B],
offset: usize,
pkt_i: usize,
table: &mut TcpGROTable,
is_v6: bool,
) -> GroResult {
let pkt = unsafe { &*(&bufs[pkt_i].as_ref()[offset..] as *const [u8]) };
if pkt.len() > u16::MAX as usize {
// A valid IPv4 or IPv6 packet will never exceed this.
return GroResult::Noop;
}
let mut iph_len = ((pkt[0] & 0x0F) * 4) as usize;
if is_v6 {
iph_len = 40;
let ipv6_h_payload_len = u16::from_be_bytes([pkt[4], pkt[5]]) as usize;
if ipv6_h_payload_len != pkt.len() - iph_len {
return GroResult::Noop;
}
} else {
let total_len = u16::from_be_bytes([pkt[2], pkt[3]]) as usize;
if total_len != pkt.len() {
return GroResult::Noop;
}
}
if pkt.len() < iph_len {
return GroResult::Noop;
}
let tcph_len = ((pkt[iph_len + 12] >> 4) * 4) as usize;
if !(20..=60).contains(&tcph_len) {
return GroResult::Noop;
}
if pkt.len() < iph_len + tcph_len {
return GroResult::Noop;
}
if !is_v6 && (pkt[6] & IPV4_FLAG_MORE_FRAGMENTS != 0 || pkt[6] << 3 != 0 || pkt[7] != 0) {
// no GRO support for fragmented segments for now
return GroResult::Noop;
}
let tcp_flags = pkt[iph_len + TCP_FLAGS_OFFSET];
let mut psh_set = false;
// not a candidate if any non-ACK flags (except PSH+ACK) are set
if tcp_flags != TCP_FLAG_ACK {
if pkt[iph_len + TCP_FLAGS_OFFSET] != TCP_FLAG_ACK | TCP_FLAG_PSH {
return GroResult::Noop;
}
psh_set = true;
}
let gso_size = (pkt.len() - tcph_len - iph_len) as u16;
// not a candidate if payload len is 0
if gso_size < 1 {
return GroResult::Noop;
}
let seq = u32::from_be_bytes([
pkt[iph_len + 4],
pkt[iph_len + 5],
pkt[iph_len + 6],
pkt[iph_len + 7],
]);
let mut src_addr_offset = IPV4_SRC_ADDR_OFFSET;
let mut addr_len = 4;
if is_v6 {
src_addr_offset = IPV6_SRC_ADDR_OFFSET;
addr_len = 16;
}
let items = if let Some(items) = table.lookup_or_insert(
pkt,
src_addr_offset,
src_addr_offset + addr_len,
iph_len,
tcph_len,
pkt_i,
) {
items
} else {
return GroResult::TableInsert;
};
for i in (0..items.len()).rev() {
// In the best case of packets arriving in order iterating in reverse is
// more efficient if there are multiple items for a given flow. This
// also enables a natural table.delete_at() in the
// coalesce_item_invalid_csum case without the need for index tracking.
// This algorithm makes a best effort to coalesce in the event of
// unordered packets, where pkt may land anywhere in items from a
// sequence number perspective, however once an item is inserted into
// the table it is never compared across other items later.
let item = &mut items[i];
let can = tcp_packets_can_coalesce(
pkt,
iph_len as u8,
tcph_len as u8,
seq,
psh_set,
gso_size,
item,
bufs,
offset,
);
match can {
CanCoalesce::Unavailable => {}
_ => {
let result = coalesce_tcp_packets(
can, pkt, pkt_i, gso_size, seq, psh_set, item, bufs, offset, is_v6,
);
match result {
CoalesceResult::Success => {
// table.update_at(item, i);
return GroResult::Coalesced;
}
CoalesceResult::ItemInvalidCSum => {
// delete the item with an invalid csum
// table.delete_at(item.key, i);
items.remove(i);
}
CoalesceResult::PktInvalidCSum => {
// no point in inserting an item that we can't coalesce
return GroResult::Noop;
}
_ => {}
}
}
}
}
// failed to coalesce with any other packets; store the item in the flow
table.insert(
pkt,
src_addr_offset,
src_addr_offset + addr_len,
iph_len,
tcph_len,
pkt_i,
);
GroResult::TableInsert
}
/// applyTCPCoalesceAccounting updates bufs to account for coalescing based on the
/// metadata found in table.
pub fn apply_tcp_coalesce_accounting<B: ExpandBuffer>(
bufs: &mut [B],
offset: usize,
table: &TcpGROTable,
) -> io::Result<()> {
for items in table.items_by_flow.values() {
for item in items {
if item.num_merged > 0 {
let mut hdr = VirtioNetHdr {
flags: VIRTIO_NET_HDR_F_NEEDS_CSUM,
hdr_len: (item.iph_len + item.tcph_len) as u16,
gso_size: item.gso_size,
csum_start: item.iph_len as u16,
csum_offset: 16,
gso_type: 0, // Will be set later
};
let buf = bufs[item.bufs_index as usize].as_mut();
let pkt = &mut buf[offset..];
let pkt_len = pkt.len();
// Calculate the pseudo header checksum and place it at the TCP
// checksum offset. Downstream checksum offloading will combine
// this with computation of the tcp header and payload checksum.
let addr_len = if item.key.is_v6 { 16 } else { 4 };
let src_addr_at = if item.key.is_v6 {
IPV6_SRC_ADDR_OFFSET
} else {
IPV4_SRC_ADDR_OFFSET
};
let src_addr =
unsafe { &*(&pkt[src_addr_at..src_addr_at + addr_len] as *const [u8]) };
let dst_addr = unsafe {
&*(&pkt[src_addr_at + addr_len..src_addr_at + addr_len * 2] as *const [u8])
};
// Recalculate the total len (IPv4) or payload len (IPv6).
// Recalculate the (IPv4) header checksum.
if item.key.is_v6 {
hdr.gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
BigEndian::write_u16(&mut pkt[4..6], pkt_len as u16 - item.iph_len as u16);
} else {
hdr.gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
pkt[10] = 0;
pkt[11] = 0;
BigEndian::write_u16(&mut pkt[2..4], pkt_len as u16);
let iph_csum = !checksum(&pkt[..item.iph_len as usize], 0);
BigEndian::write_u16(&mut pkt[10..12], iph_csum);
}
hdr.encode(&mut buf[offset - VIRTIO_NET_HDR_LEN..])?;
let pkt = &mut buf[offset..];
let psum = pseudo_header_checksum_no_fold(
IPPROTO_TCP as _,
src_addr,
dst_addr,
pkt_len as u16 - item.iph_len as u16,
);
let tcp_csum = checksum(&[], psum);
BigEndian::write_u16(
&mut pkt[(hdr.csum_start + hdr.csum_offset) as usize..],
tcp_csum,
);
} else {
let hdr = VirtioNetHdr::default();
hdr.encode(
&mut bufs[item.bufs_index as usize].as_mut()[offset - VIRTIO_NET_HDR_LEN..],
)?;
}
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | true |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/linux/sys.rs | src/platform/linux/sys.rs | use libc::{c_int, ifreq, in6_ifreq};
use nix::{ioctl_read, ioctl_read_bad, ioctl_write_ptr, ioctl_write_ptr_bad};
ioctl_read_bad!(siocgifflags, 0x8913, ifreq);
ioctl_write_ptr_bad!(siocsifflags, 0x8914, ifreq);
ioctl_read_bad!(siocgifaddr, 0x8915, ifreq);
ioctl_write_ptr_bad!(siocsifaddr, 0x8916, ifreq);
ioctl_write_ptr_bad!(siocsifaddr_in6, 0x8916, in6_ifreq);
ioctl_write_ptr_bad!(siocdifaddr, 0x8936, ifreq);
ioctl_write_ptr_bad!(siocdifaddr_in6, 0x8936, in6_ifreq);
ioctl_read_bad!(siocgifdstaddr, 0x8917, ifreq);
ioctl_write_ptr_bad!(siocsifdstaddr, 0x8918, ifreq);
ioctl_read_bad!(siocgifbrdaddr, 0x8919, ifreq);
ioctl_write_ptr_bad!(siocsifbrdaddr, 0x891a, ifreq);
ioctl_read_bad!(siocgifnetmask, 0x891b, ifreq);
ioctl_write_ptr_bad!(siocsifnetmask, 0x891c, ifreq);
ioctl_write_ptr_bad!(siocsifnetmask_in6, 0x891c, in6_ifreq);
ioctl_read_bad!(siocgifmtu, 0x8921, ifreq);
ioctl_write_ptr_bad!(siocsifmtu, 0x8922, ifreq);
ioctl_write_ptr_bad!(siocsifname, 0x8923, ifreq);
ioctl_read_bad!(siocgifhwaddr, 0x8927, ifreq);
ioctl_write_ptr_bad!(siocsifhwaddr, 0x8924, ifreq);
ioctl_read_bad!(tx_queue_len, 0x8942, ifreq);
ioctl_write_ptr_bad!(change_tx_queue_len, 0x8943, ifreq);
ioctl_read!(tungetiff, b'T', 210, c_int);
ioctl_write_ptr!(tunsetiff, b'T', 202, c_int);
ioctl_write_ptr!(tunsetpersist, b'T', 203, c_int);
ioctl_write_ptr!(tunsetowner, b'T', 204, c_int);
ioctl_write_ptr!(tunsetgroup, b'T', 206, c_int);
ioctl_write_ptr!(tunsetoffload, b'T', 208, c_int);
ioctl_write_ptr!(tunsetvnethdrsz, b'T', 216, c_int);
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/windows/netsh.rs | src/platform/windows/netsh.rs | use std::io;
use std::net::IpAddr;
use std::os::windows::process::CommandExt;
use std::process::{Command, Output};
use encoding_rs::GBK;
use windows_sys::Win32::System::Threading::CREATE_NO_WINDOW;
pub fn set_interface_name(old_name: &str, new_name: &str) -> io::Result<()> {
let cmd = format!(" netsh interface set interface name={old_name:?} newname={new_name:?}");
exe_cmd(&cmd)
}
pub fn set_interface_metric(index: u32, metric: u16) -> io::Result<()> {
let cmd = format!("netsh interface ip set interface {index} metric={metric}");
exe_cmd(&cmd)
}
pub fn exe_cmd(cmd: &str) -> io::Result<()> {
let out = Command::new("cmd")
.creation_flags(CREATE_NO_WINDOW)
.arg("/C")
.arg(cmd)
.output()?;
output(cmd, out)
}
fn gbk_to_utf8(bytes: &[u8]) -> String {
let (msg, _, _) = GBK.decode(bytes);
msg.to_string()
}
fn output(cmd: &str, out: Output) -> io::Result<()> {
if !out.status.success() {
let msg = if !out.stderr.is_empty() {
match std::str::from_utf8(&out.stderr) {
Ok(msg) => msg.to_string(),
Err(_) => gbk_to_utf8(&out.stderr),
}
} else if !out.stdout.is_empty() {
match std::str::from_utf8(&out.stdout) {
Ok(msg) => msg.to_string(),
Err(_) => gbk_to_utf8(&out.stdout),
}
} else {
String::new()
};
return Err(io::Error::other(format!(
"cmd=\"{cmd}\",out=\"{}\"",
msg.trim()
)));
}
Ok(())
}
pub fn exe_command(cmd: &mut Command) -> io::Result<()> {
let out = cmd.creation_flags(CREATE_NO_WINDOW).output()?;
let command = cmd
.get_args()
.map(|s| s.to_string_lossy().to_string())
.collect::<Vec<String>>();
output(&command.join(" ").to_string(), out)
}
pub fn delete_interface_ip(index: u32, address: IpAddr) -> io::Result<()> {
let cmd = format!(
"netsh interface {} delete address {index} {address}",
if address.is_ipv4() { "ip" } else { "ipv6" }
);
exe_cmd(&cmd)
}
/// 设置网卡ip
pub fn set_interface_ip(
index: u32,
address: IpAddr,
netmask: IpAddr,
gateway: Option<IpAddr>,
) -> io::Result<()> {
let mut binding = Command::new("netsh");
let cmd = if address.is_ipv4() {
binding
.arg("interface")
.arg("ipv4")
.arg("set")
.arg("address")
.arg(index.to_string().as_str())
.arg("source=static")
.arg(format!("address={address}",).as_str())
.arg(format!("mask={netmask}",).as_str())
} else {
let prefix_len = ipnet::ip_mask_to_prefix(netmask)
.map_err(|_| io::Error::from(io::ErrorKind::InvalidData))?;
binding
.arg("interface")
.arg("ipv6")
.arg("set")
.arg("address")
.arg(index.to_string().as_str())
.arg(format!("address={address}/{prefix_len}").as_str())
};
if let Some(gateway) = gateway {
_ = cmd.arg(format!("gateway={gateway}",).as_str());
}
exe_command(cmd)
}
pub fn set_interface_mtu(index: u32, mtu: u32) -> io::Result<()> {
let cmd = format!("netsh interface ipv4 set subinterface {index} mtu={mtu} store=persistent",);
exe_cmd(&cmd)
}
pub fn set_interface_mtu_v6(index: u32, mtu: u32) -> io::Result<()> {
let cmd = format!("netsh interface ipv6 set subinterface {index} mtu={mtu} store=persistent",);
exe_cmd(&cmd)
}
pub fn set_primary_dns(index: u32, address: IpAddr) -> io::Result<()> {
let (family, addr_str) = match address {
IpAddr::V4(v4) => ("ipv4", v4.to_string()),
IpAddr::V6(v6) => ("ipv6", v6.to_string()),
};
let cmd = format!("netsh interface {family} set dnsservers {index} static {addr_str} primary");
exe_cmd(&cmd)
}
pub fn add_secondary_dns(index: u32, address: IpAddr, index_pos: u32) -> io::Result<()> {
let (family, addr_str) = match address {
IpAddr::V4(v4) => ("ipv4", v4.to_string()),
IpAddr::V6(v6) => ("ipv6", v6.to_string()),
};
let cmd =
format!("netsh interface {family} add dnsservers {index} {addr_str} index={index_pos}");
exe_cmd(&cmd)
}
pub fn clear_dns_servers(index: u32, is_ipv4: bool) -> io::Result<()> {
let family = if is_ipv4 { "ipv4" } else { "ipv6" };
let cmd = format!("netsh interface {family} set dnsservers {index} source=dhcp");
exe_cmd(&cmd)
}
pub fn set_dns_servers(index: u32, dns_servers: &[IpAddr]) -> io::Result<()> {
if dns_servers.is_empty() {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"DNS servers list cannot be empty",
));
}
let is_ipv4 = dns_servers[0].is_ipv4();
if !dns_servers.iter().all(|addr| addr.is_ipv4() == is_ipv4) {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"All DNS servers must be either IPv4 or IPv6",
));
}
clear_dns_servers(index, is_ipv4)?;
set_primary_dns(index, dns_servers[0])?;
for (i, &addr) in dns_servers.iter().skip(1).enumerate() {
add_secondary_dns(index, addr, (i + 2) as u32)?;
}
Ok(())
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/windows/device.rs | src/platform/windows/device.rs | use crate::builder::DeviceConfig;
use crate::platform::windows::netsh;
use crate::platform::windows::tap::TapDevice;
use crate::platform::windows::tun::{check_adapter_if_orphaned_devices, TunDevice};
use crate::platform::ETHER_ADDR_LEN;
use crate::{Layer, ToIpv4Address, ToIpv4Netmask, ToIpv6Address, ToIpv6Netmask};
use getifaddrs::Interface;
use ipnet::IpNet;
use std::collections::HashSet;
use std::io;
use std::net::IpAddr;
use std::sync::Mutex;
use windows_sys::core::GUID;
pub(crate) const GUID_NETWORK_ADAPTER: GUID = GUID {
data1: 0x4d36e972,
data2: 0xe325,
data3: 0x11ce,
data4: [0xbf, 0xc1, 0x08, 0x00, 0x2b, 0xe1, 0x03, 0x18],
};
pub(crate) enum Driver {
Tun(TunDevice),
Tap(TapDevice),
}
/// A TUN device using the wintun driver.
pub struct DeviceImpl {
lock: Mutex<()>,
pub(crate) driver: Driver,
}
impl DeviceImpl {
/// Create a new `Device` for the given `Configuration`.
pub(crate) fn new(config: DeviceConfig) -> io::Result<Self> {
let layer = config.layer.unwrap_or(Layer::L3);
let mut count = 0;
let interfaces: HashSet<String> = Self::get_all_adapter_address()?
.into_iter()
.map(|v| v.description)
.collect();
let device = if layer == Layer::L3 {
let wintun_log = config.wintun_log.unwrap_or(false);
let wintun_file = config.wintun_file.as_deref().unwrap_or("wintun.dll");
let ring_capacity = config.ring_capacity.unwrap_or(0x20_0000);
let delete_driver = config.delete_driver.unwrap_or(false);
let mut attempts = 0;
let tun_device = loop {
let default_name = format!("tun{count}");
count += 1;
let name = config.dev_name.as_deref().unwrap_or(&default_name);
if interfaces.contains(name) {
if config.dev_name.is_none() {
continue;
}
// Resolves an issue where there are orphaned adapters. fixes #33
let is_orphaned_adapter = check_adapter_if_orphaned_devices(name);
if !is_orphaned_adapter {
// Try to open an existing Wintun adapter.
break TunDevice::open(
wintun_file,
name,
ring_capacity,
delete_driver,
wintun_log,
)?;
}
}
let description = config.description.as_deref().unwrap_or(name);
match TunDevice::create(
wintun_file,
name,
description,
config.device_guid,
ring_capacity,
delete_driver,
wintun_log,
) {
Ok(tun_device) => break tun_device,
Err(e) => {
if attempts > 3 {
Err(e)?
}
attempts += 1;
}
}
};
DeviceImpl {
lock: Mutex::new(()),
driver: Driver::Tun(tun_device),
}
} else if layer == Layer::L2 {
const HARDWARE_ID: &str = "tap0901";
let persist = config.persist.unwrap_or(false);
let tap = loop {
let default_name = format!("tap{count}");
let name = config.dev_name.as_deref().unwrap_or(&default_name);
if interfaces.contains(name) {
if config.dev_name.is_none() {
count += 1;
continue;
} else if !config.reuse_dev.unwrap_or(true) {
Err(io::Error::other(format!(
"The network adapter [{name}] already exists."
)))?
}
let tap =
TapDevice::open(HARDWARE_ID, name, persist, config.mac_address.as_ref())?;
break tap;
}
let tap = TapDevice::create(HARDWARE_ID, persist, config.mac_address.as_ref())?;
if let Err(e) = tap.set_name(name) {
if config.dev_name.is_some() {
Err(e)?
}
}
break tap;
};
DeviceImpl {
lock: Mutex::new(()),
driver: Driver::Tap(tap),
}
} else {
panic!("unknown layer {layer:?}");
};
Ok(device)
}
#[cfg(any(
feature = "interruptible",
feature = "async_tokio",
feature = "async_io"
))]
pub(crate) fn wait_readable_interruptible(
&self,
event: &crate::platform::windows::InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<()> {
match &self.driver {
Driver::Tap(tap) => tap.wait_readable_interruptible(&event.handle, timeout),
Driver::Tun(tun) => tun.wait_readable_interruptible(&event.handle, timeout),
}
}
#[cfg(feature = "interruptible")]
pub(crate) fn read_interruptible(
&self,
buf: &mut [u8],
event: &crate::InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<usize> {
loop {
self.wait_readable_interruptible(event, timeout)?;
match self.try_recv(buf) {
Ok(rs) => {
return Ok(rs);
}
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
continue;
}
Err(e) => return Err(e),
}
}
}
/// Recv a packet from tun device
pub(crate) fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
match &self.driver {
Driver::Tap(tap) => tap.read(buf),
Driver::Tun(tun) => tun.recv(buf),
}
}
pub(crate) fn try_recv(&self, buf: &mut [u8]) -> io::Result<usize> {
match &self.driver {
Driver::Tap(tap) => tap.try_read(buf),
Driver::Tun(tun) => tun.try_recv(buf),
}
}
/// Send a packet to tun device
pub(crate) fn send(&self, buf: &[u8]) -> io::Result<usize> {
match &self.driver {
Driver::Tap(tap) => tap.write(buf),
Driver::Tun(tun) => tun.send(buf),
}
}
#[cfg(any(
feature = "interruptible",
feature = "async_tokio",
feature = "async_io"
))]
pub(crate) fn write_interruptible(
&self,
buf: &[u8],
event: &crate::platform::windows::InterruptEvent,
) -> io::Result<usize> {
match &self.driver {
Driver::Tap(tap) => tap.write_interruptible(buf, &event.handle),
Driver::Tun(tun) => tun.send_interruptible(buf, &event.handle),
}
}
pub(crate) fn try_send(&self, buf: &[u8]) -> io::Result<usize> {
match &self.driver {
Driver::Tap(tap) => tap.try_write(buf),
Driver::Tun(tun) => tun.try_send(buf),
}
}
pub(crate) fn shutdown(&self) -> io::Result<()> {
match &self.driver {
Driver::Tun(tun) => tun.shutdown(),
Driver::Tap(tap) => tap.down(),
}
}
fn if_index_impl(&self) -> io::Result<u32> {
match &self.driver {
Driver::Tun(tun) => Ok(tun.index()),
Driver::Tap(tap) => Ok(tap.index()),
}
}
fn get_all_adapter_address() -> io::Result<Vec<Interface>> {
Ok(getifaddrs::getifaddrs()?.collect())
}
fn name_impl(&self) -> io::Result<String> {
match &self.driver {
Driver::Tun(tun) => tun.get_name(),
Driver::Tap(tap) => tap.get_name(),
}
}
}
// Public User interface
impl DeviceImpl {
/// Retrieves the name of the device.
///
/// Calls the appropriate method on the underlying driver (TUN or TAP) to obtain the device name.
pub fn name(&self) -> io::Result<String> {
let _guard = self.lock.lock().unwrap();
self.name_impl()
}
/// Sets a new name for the device.
///
/// This method first checks if the current name is different from the desired one. If it is,
/// it uses the `netsh` command to update the interface name.
pub fn set_name(&self, value: &str) -> io::Result<()> {
let _guard = self.lock.lock().unwrap();
let name = self.name_impl()?;
if value == name {
return Ok(());
}
netsh::set_interface_name(&name, value)
}
/// Retrieves the interface index (if_index) of the device.
///
/// This is used for various network configuration commands.
pub fn if_index(&self) -> io::Result<u32> {
let _guard = self.lock.lock().unwrap();
self.if_index_impl()
}
/// Enables or disables the device.
///
/// For a TUN device, disabling is not supported and will return an error.
/// For a TAP device, this calls the appropriate method to set the device status.
pub fn enabled(&self, value: bool) -> io::Result<()> {
let _guard = self.lock.lock().unwrap();
match &self.driver {
Driver::Tun(tun) => tun.enabled(value),
Driver::Tap(tap) => tap.set_status(value),
}
}
/// Retrieves all IP addresses associated with this device.
///
/// Filters the adapter addresses by matching the device's interface index.
pub fn addresses(&self) -> io::Result<Vec<IpAddr>> {
let _guard = self.lock.lock().unwrap();
let index = self.if_index_impl()?;
let r = Self::get_all_adapter_address()?
.into_iter()
.filter(|v| v.index == Some(index))
.map(|v| v.address)
.collect();
Ok(r)
}
/// Sets the IPv4 network address, netmask, and an optional destination address.
/// Remove all previous set IPv4 addresses and set the specified address.
pub fn set_network_address<IPv4: ToIpv4Address, Netmask: ToIpv4Netmask>(
&self,
address: IPv4,
netmask: Netmask,
destination: Option<IPv4>,
) -> io::Result<()> {
let _guard = self.lock.lock().unwrap();
netsh::set_interface_ip(
self.if_index_impl()?,
address.ipv4()?.into(),
netmask.netmask()?.into(),
destination.map(|v| v.ipv4()).transpose()?.map(|v| v.into()),
)
}
/// Add IPv4 network address, netmask
pub fn add_address_v4<IPv4: ToIpv4Address, Netmask: ToIpv4Netmask>(
&self,
address: IPv4,
netmask: Netmask,
) -> io::Result<()> {
let _guard = self.lock.lock().unwrap();
let interface = netconfig_rs::Interface::try_from_index(self.if_index_impl()?)
.map_err(io::Error::from)?;
interface
.add_address(IpNet::new_assert(address.ipv4()?.into(), netmask.prefix()?))
.map_err(io::Error::from)
}
/// Removes the specified IP address from the device.
pub fn remove_address(&self, addr: IpAddr) -> io::Result<()> {
let _guard = self.lock.lock().unwrap();
netsh::delete_interface_ip(self.if_index_impl()?, addr)
}
/// Adds an IPv6 address to the device.
///
/// Configures the IPv6 address and netmask (converted from prefix) for the interface.
pub fn add_address_v6<IPv6: ToIpv6Address, Netmask: ToIpv6Netmask>(
&self,
addr: IPv6,
netmask: Netmask,
) -> io::Result<()> {
let _guard = self.lock.lock().unwrap();
let mask = netmask.netmask()?;
netsh::set_interface_ip(
self.if_index_impl()?,
addr.ipv6()?.into(),
mask.into(),
None,
)
}
/// Retrieves the MTU for the device (IPv4).
///
/// This method uses a Windows-specific FFI function to query the MTU by interface index.
pub fn mtu(&self) -> io::Result<u16> {
let _guard = self.lock.lock().unwrap();
let index = self.if_index_impl()?;
let mtu = crate::platform::windows::ffi::get_mtu_by_index(index, true)?;
Ok(mtu as _)
}
/// Retrieves the MTU for the device (IPv6).
///
/// This method uses a Windows-specific FFI function to query the IPv6 MTU by interface index.
pub fn mtu_v6(&self) -> io::Result<u16> {
let _guard = self.lock.lock().unwrap();
let index = self.if_index_impl()?;
let mtu = crate::platform::windows::ffi::get_mtu_by_index(index, false)?;
Ok(mtu as _)
}
/// Sets the MTU for the device (IPv4) using the `netsh` command.
pub fn set_mtu(&self, mtu: u16) -> io::Result<()> {
let _guard = self.lock.lock().unwrap();
netsh::set_interface_mtu(self.if_index_impl()?, mtu as _)
}
/// Sets the MTU for the device (IPv6) using the `netsh` command.
pub fn set_mtu_v6(&self, mtu: u16) -> io::Result<()> {
let _guard = self.lock.lock().unwrap();
netsh::set_interface_mtu_v6(self.if_index_impl()?, mtu as _)
}
/// Sets the MAC address for the device.
///
/// This operation is only supported for TAP devices; attempting to set a MAC address on a TUN device
/// will result in an error.
pub fn set_mac_address(&self, eth_addr: [u8; ETHER_ADDR_LEN as usize]) -> io::Result<()> {
let _guard = self.lock.lock().unwrap();
match &self.driver {
Driver::Tun(_tun) => Err(io::Error::from(io::ErrorKind::Unsupported)),
Driver::Tap(tap) => tap.set_mac(ð_addr),
}
}
/// Retrieves the MAC address of the device.
///
/// This operation is only supported for TAP devices.
pub fn mac_address(&self) -> io::Result<[u8; ETHER_ADDR_LEN as usize]> {
let _guard = self.lock.lock().unwrap();
match &self.driver {
Driver::Tun(_tun) => Err(io::Error::from(io::ErrorKind::Unsupported)),
Driver::Tap(tap) => tap.get_mac(),
}
}
/// Sets the interface metric (routing cost) using the `netsh` command.
pub fn set_metric(&self, metric: u16) -> io::Result<()> {
let _guard = self.lock.lock().unwrap();
netsh::set_interface_metric(self.if_index_impl()?, metric)
}
/// Retrieves the version of the underlying driver.
///
/// For TUN devices, this directly queries the driver version.
/// For TAP devices, the version is composed of several components joined by dots.
pub fn version(&self) -> io::Result<String> {
let _guard = self.lock.lock().unwrap();
match &self.driver {
Driver::Tun(tun) => tun.version(),
Driver::Tap(tap) => tap.get_version().map(|v| {
v.iter()
.map(|v| v.to_string())
.collect::<Vec<String>>()
.join(".")
}),
}
}
/// Set DNS servers for the current device (supports primary and secondary DNS)
/// dns_servers: A priority-ordered list of DNS servers (must be all IPv4 or all IPv6)
pub fn set_dns_servers(&self, dns_servers: &[IpAddr]) -> io::Result<()> {
let _guard = self.lock.lock().unwrap();
let index = self.if_index_impl()?;
netsh::set_dns_servers(index, dns_servers)
}
/// Clear DNS configuration for the current device (restore to automatic acquisition)
/// is_ipv4: true to clear IPv4 DNS, false to clear IPv6 DNS
pub fn clear_dns_servers(&self, is_ipv4: bool) -> io::Result<()> {
let _guard = self.lock.lock().unwrap();
let index = self.if_index_impl()?;
netsh::clear_dns_servers(index, is_ipv4)
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/windows/ffi.rs | src/platform/windows/ffi.rs | use std::os::windows::io::{FromRawHandle, OwnedHandle, RawHandle};
use std::{io, mem, ptr};
use windows_sys::Win32::Foundation::{ERROR_IO_PENDING, NO_ERROR};
use windows_sys::Win32::NetworkManagement::IpHelper::{
GetIpInterfaceTable, MIB_IPINTERFACE_ROW, MIB_IPINTERFACE_TABLE,
};
use windows_sys::Win32::Networking::WinSock::{AF_INET, AF_INET6};
use windows_sys::Win32::System::Threading::{ResetEvent, SetEvent};
use windows_sys::Win32::System::IO::{CancelIoEx, GetOverlappedResult, OVERLAPPED};
use windows_sys::{
core::{BOOL, GUID},
Win32::{
Devices::DeviceAndDriverInstallation::{
SetupDiBuildDriverInfoList, SetupDiCallClassInstaller, SetupDiClassNameFromGuidW,
SetupDiCreateDeviceInfoList, SetupDiCreateDeviceInfoW, SetupDiDestroyDeviceInfoList,
SetupDiDestroyDriverInfoList, SetupDiEnumDeviceInfo, SetupDiEnumDriverInfoW,
SetupDiGetClassDevsW, SetupDiGetDeviceRegistryPropertyW, SetupDiGetDriverInfoDetailW,
SetupDiOpenDevRegKey, SetupDiSetDeviceRegistryPropertyW, SetupDiSetSelectedDevice,
SetupDiSetSelectedDriverW, HDEVINFO, MAX_CLASS_NAME_LEN, SP_DEVINFO_DATA,
SP_DRVINFO_DATA_V2_W, SP_DRVINFO_DETAIL_DATA_W,
},
Foundation::{GetLastError, ERROR_NO_MORE_ITEMS, FALSE, FILETIME, HANDLE, TRUE},
NetworkManagement::{
IpHelper::{
ConvertInterfaceAliasToLuid, ConvertInterfaceLuidToAlias,
ConvertInterfaceLuidToGuid, ConvertInterfaceLuidToIndex,
},
Ndis::NET_LUID_LH,
},
Storage::FileSystem::{
CreateFileW, ReadFile, WriteFile, FILE_CREATION_DISPOSITION, FILE_FLAGS_AND_ATTRIBUTES,
FILE_SHARE_MODE,
},
System::{
Com::StringFromGUID2,
Registry::{RegNotifyChangeKeyValue, HKEY},
Threading::{CreateEventW, WaitForSingleObject},
IO::DeviceIoControl,
},
},
};
#[allow(non_camel_case_types)]
#[allow(non_snake_case)]
#[repr(C)]
#[derive(Clone, Copy)]
/// Custom type to handle variable size SP_DRVINFO_DETAIL_DATA_W
pub struct SP_DRVINFO_DETAIL_DATA_W2 {
pub cbSize: u32,
pub InfDate: FILETIME,
pub CompatIDsOffset: u32,
pub CompatIDsLength: u32,
pub Reserved: usize,
pub SectionName: [u16; 256],
pub InfFileName: [u16; 260],
pub DrvDescription: [u16; 256],
pub HardwareID: [u16; 512],
}
/// Encode a string as a utf16 buffer
pub fn encode_utf16(string: &str) -> Vec<u16> {
use std::iter::once;
string.encode_utf16().chain(once(0)).collect()
}
pub fn decode_utf16(string: &[u16]) -> String {
let end = string.iter().position(|b| *b == 0).unwrap_or(string.len());
String::from_utf16_lossy(&string[..end])
}
pub fn string_from_guid(guid: &GUID) -> io::Result<String> {
let mut string = vec![0; 39];
match unsafe { StringFromGUID2(guid, string.as_mut_ptr(), string.len() as _) } {
0 => Err(io::Error::last_os_error()),
_ => Ok(decode_utf16(&string)),
}
}
pub fn alias_to_luid(alias: &str) -> io::Result<NET_LUID_LH> {
let alias = encode_utf16(alias);
let mut luid = unsafe { mem::zeroed() };
match unsafe { ConvertInterfaceAliasToLuid(alias.as_ptr(), &mut luid) } {
0 => Ok(luid),
_err => Err(io::Error::last_os_error()),
}
}
pub fn luid_to_index(luid: &NET_LUID_LH) -> io::Result<u32> {
let mut index = 0;
match unsafe { ConvertInterfaceLuidToIndex(luid, &mut index) } {
0 => Ok(index),
_err => Err(io::Error::last_os_error()),
}
}
pub fn luid_to_guid(luid: &NET_LUID_LH) -> io::Result<GUID> {
let mut guid = unsafe { mem::zeroed() };
match unsafe { ConvertInterfaceLuidToGuid(luid, &mut guid) } {
0 => Ok(guid),
_err => Err(io::Error::last_os_error()),
}
}
pub fn luid_to_alias(luid: &NET_LUID_LH) -> io::Result<String> {
// IF_MAX_STRING_SIZE + 1
let mut alias = vec![0; 257];
match unsafe { ConvertInterfaceLuidToAlias(luid, alias.as_mut_ptr(), alias.len()) } {
0 => Ok(decode_utf16(&alias)),
_err => Err(io::Error::last_os_error()),
}
}
pub fn reset_event(handle: RawHandle) -> io::Result<()> {
unsafe {
if FALSE == ResetEvent(handle) {
return Err(io::Error::last_os_error());
}
}
Ok(())
}
pub fn wait_for_single_object(handle: RawHandle, timeout: u32) -> io::Result<()> {
unsafe {
if 0 == WaitForSingleObject(handle, timeout) {
Ok(())
} else {
Err(io::Error::last_os_error())
}
}
}
pub fn set_event(handle: RawHandle) -> io::Result<()> {
unsafe {
if FALSE == SetEvent(handle) {
return Err(io::Error::last_os_error());
}
}
Ok(())
}
pub fn create_event() -> io::Result<OwnedHandle> {
unsafe {
let read_event_handle = CreateEventW(ptr::null_mut(), 1, 0, ptr::null_mut());
if read_event_handle.is_null() {
Err(io::Error::last_os_error())?
}
Ok(OwnedHandle::from_raw_handle(read_event_handle))
}
}
pub fn create_file(
file_name: &str,
desired_access: u32,
share_mode: FILE_SHARE_MODE,
creation_disposition: FILE_CREATION_DISPOSITION,
flags_and_attributes: FILE_FLAGS_AND_ATTRIBUTES,
) -> io::Result<HANDLE> {
let file_name = encode_utf16(file_name);
let handle = unsafe {
CreateFileW(
file_name.as_ptr(),
desired_access,
share_mode,
ptr::null_mut(),
creation_disposition,
flags_and_attributes,
ptr::null_mut(),
)
};
if handle.is_null() {
Err(io::Error::last_os_error())
} else {
Ok(handle)
}
}
pub fn io_overlapped() -> OVERLAPPED {
OVERLAPPED {
Internal: 0,
InternalHigh: 0,
Anonymous: windows_sys::Win32::System::IO::OVERLAPPED_0 {
Anonymous: windows_sys::Win32::System::IO::OVERLAPPED_0_0 {
Offset: 0,
OffsetHigh: 0,
},
},
hEvent: ptr::null_mut(),
}
}
pub fn try_read_file(
handle: HANDLE,
io_overlapped: &mut OVERLAPPED,
buffer: &mut [u8],
) -> io::Result<u32> {
let mut ret = 0;
//https://www.cnblogs.com/linyilong3/archive/2012/05/03/2480451.html
unsafe {
if 0 == ReadFile(
handle,
buffer.as_mut_ptr() as _,
buffer.len() as _,
&mut ret,
io_overlapped,
) {
Err(error_map())
} else {
Ok(ret)
}
}
}
pub fn try_write_file(
handle: HANDLE,
io_overlapped: &mut OVERLAPPED,
buffer: &[u8],
) -> io::Result<u32> {
let mut ret = 0;
unsafe {
if 0 == WriteFile(
handle,
buffer.as_ptr() as _,
buffer.len() as _,
&mut ret,
io_overlapped,
) {
Err(error_map())
} else {
Ok(ret)
}
}
}
fn error_map() -> io::Error {
let e = io::Error::last_os_error();
if e.raw_os_error().unwrap_or(0) == ERROR_IO_PENDING as i32 {
io::Error::from(io::ErrorKind::WouldBlock)
} else {
e
}
}
pub fn try_io_overlapped(handle: HANDLE, io_overlapped: &OVERLAPPED) -> io::Result<u32> {
let mut ret = 0;
unsafe {
if 0 == GetOverlappedResult(handle, io_overlapped, &mut ret, 0) {
Err(io::Error::from(io::ErrorKind::WouldBlock))
} else {
Ok(ret)
}
}
}
#[allow(dead_code)]
pub fn cancel_io_overlapped(handle: HANDLE, io_overlapped: &OVERLAPPED) -> io::Result<u32> {
unsafe {
CancelIoEx(handle, io_overlapped);
wait_io_overlapped(handle, io_overlapped)
}
}
pub fn wait_io_overlapped(handle: HANDLE, io_overlapped: &OVERLAPPED) -> io::Result<u32> {
let mut ret = 0;
unsafe {
if 0 == GetOverlappedResult(handle, io_overlapped, &mut ret, 1) {
Err(io::Error::last_os_error())
} else {
Ok(ret)
}
}
}
pub fn create_device_info_list(guid: &GUID) -> io::Result<HDEVINFO> {
match unsafe { SetupDiCreateDeviceInfoList(guid, ptr::null_mut()) } {
-1 => Err(io::Error::last_os_error()),
devinfo => Ok(devinfo),
}
}
pub fn get_class_devs(guid: &GUID, flags: u32) -> io::Result<HDEVINFO> {
match unsafe { SetupDiGetClassDevsW(guid, ptr::null(), ptr::null_mut(), flags) } {
-1 => Err(io::Error::last_os_error()),
devinfo => Ok(devinfo),
}
}
pub fn destroy_device_info_list(devinfo: HDEVINFO) -> io::Result<()> {
match unsafe { SetupDiDestroyDeviceInfoList(devinfo) } {
0 => Err(io::Error::last_os_error()),
_ => Ok(()),
}
}
pub fn class_name_from_guid(guid: &GUID) -> io::Result<String> {
let mut class_name = vec![0; MAX_CLASS_NAME_LEN as usize];
match unsafe {
SetupDiClassNameFromGuidW(
guid,
class_name.as_mut_ptr(),
class_name.len() as _,
ptr::null_mut(),
)
} {
0 => Err(io::Error::last_os_error()),
_ => Ok(decode_utf16(&class_name)),
}
}
pub fn create_device_info(
devinfo: HDEVINFO,
device_name: &str,
guid: &GUID,
device_description: &str,
creation_flags: u32,
) -> io::Result<SP_DEVINFO_DATA> {
let mut devinfo_data: SP_DEVINFO_DATA = unsafe { mem::zeroed() };
devinfo_data.cbSize = mem::size_of_val(&devinfo_data) as _;
let device_name = encode_utf16(device_name);
let device_description = encode_utf16(device_description);
match unsafe {
SetupDiCreateDeviceInfoW(
devinfo,
device_name.as_ptr(),
guid,
device_description.as_ptr(),
ptr::null_mut(),
creation_flags,
&mut devinfo_data,
)
} {
0 => Err(io::Error::last_os_error()),
_ => Ok(devinfo_data),
}
}
pub fn set_selected_device(devinfo: HDEVINFO, devinfo_data: &SP_DEVINFO_DATA) -> io::Result<()> {
match unsafe { SetupDiSetSelectedDevice(devinfo, devinfo_data as *const _ as _) } {
0 => Err(io::Error::last_os_error()),
_ => Ok(()),
}
}
pub fn set_device_registry_property(
devinfo: HDEVINFO,
devinfo_data: &SP_DEVINFO_DATA,
property: u32,
value: &str,
) -> io::Result<()> {
let value = encode_utf16(value);
match unsafe {
SetupDiSetDeviceRegistryPropertyW(
devinfo,
devinfo_data as *const _ as _,
property,
value.as_ptr() as _,
(value.len() * 2) as _,
)
} {
0 => Err(io::Error::last_os_error()),
_ => Ok(()),
}
}
pub fn get_device_registry_property(
devinfo: HDEVINFO,
devinfo_data: &SP_DEVINFO_DATA,
property: u32,
) -> io::Result<String> {
let mut value = vec![0; 32];
match unsafe {
SetupDiGetDeviceRegistryPropertyW(
devinfo,
devinfo_data as *const _ as _,
property,
ptr::null_mut(),
value.as_mut_ptr() as _,
(value.len() * 2) as _,
ptr::null_mut(),
)
} {
0 => Err(io::Error::last_os_error()),
_ => Ok(decode_utf16(&value)),
}
}
pub fn build_driver_info_list(
devinfo: HDEVINFO,
devinfo_data: &mut SP_DEVINFO_DATA,
driver_type: u32,
) -> io::Result<()> {
match unsafe { SetupDiBuildDriverInfoList(devinfo, devinfo_data as *const _ as _, driver_type) }
{
0 => Err(io::Error::last_os_error()),
_ => Ok(()),
}
}
pub fn destroy_driver_info_list(
devinfo: HDEVINFO,
devinfo_data: &SP_DEVINFO_DATA,
driver_type: u32,
) -> io::Result<()> {
match unsafe {
SetupDiDestroyDriverInfoList(devinfo, devinfo_data as *const _ as _, driver_type)
} {
0 => Err(io::Error::last_os_error()),
_ => Ok(()),
}
}
pub fn get_driver_info_detail(
devinfo: HDEVINFO,
devinfo_data: &SP_DEVINFO_DATA,
drvinfo_data: &SP_DRVINFO_DATA_V2_W,
) -> io::Result<SP_DRVINFO_DETAIL_DATA_W2> {
let mut drvinfo_detail: SP_DRVINFO_DETAIL_DATA_W2 = unsafe { mem::zeroed() };
drvinfo_detail.cbSize = mem::size_of::<SP_DRVINFO_DETAIL_DATA_W>() as _;
match unsafe {
SetupDiGetDriverInfoDetailW(
devinfo,
devinfo_data as *const _ as _,
drvinfo_data as *const _ as _,
&mut drvinfo_detail as *mut _ as _,
mem::size_of_val(&drvinfo_detail) as _,
ptr::null_mut(),
)
} {
0 => Err(io::Error::last_os_error()),
_ => Ok(drvinfo_detail),
}
}
pub fn set_selected_driver(
devinfo: HDEVINFO,
devinfo_data: &SP_DEVINFO_DATA,
drvinfo_data: &SP_DRVINFO_DATA_V2_W,
) -> io::Result<()> {
match unsafe {
SetupDiSetSelectedDriverW(
devinfo,
devinfo_data as *const _ as _,
drvinfo_data as *const _ as _,
)
} {
0 => Err(io::Error::last_os_error()),
_ => Ok(()),
}
}
pub fn call_class_installer(
devinfo: HDEVINFO,
devinfo_data: &SP_DEVINFO_DATA,
install_function: u32,
) -> io::Result<()> {
match unsafe {
SetupDiCallClassInstaller(install_function, devinfo, devinfo_data as *const _ as _)
} {
0 => Err(io::Error::last_os_error()),
_ => Ok(()),
}
}
pub fn open_dev_reg_key(
devinfo: HDEVINFO,
devinfo_data: &SP_DEVINFO_DATA,
scope: u32,
hw_profile: u32,
key_type: u32,
sam_desired: u32,
) -> io::Result<HKEY> {
const INVALID_KEY_VALUE: HKEY = windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE as _;
match unsafe {
SetupDiOpenDevRegKey(
devinfo,
devinfo_data as *const _ as _,
scope,
hw_profile,
key_type,
sam_desired,
)
} {
INVALID_KEY_VALUE => Err(io::Error::last_os_error()),
key => Ok(key),
}
}
pub fn notify_change_key_value(
key: HKEY,
watch_subtree: BOOL,
notify_filter: u32,
milliseconds: u32,
) -> io::Result<()> {
const INVALID_HANDLE_VALUE: HKEY = windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE as _;
let event = match unsafe { CreateEventW(ptr::null_mut(), FALSE, FALSE, ptr::null()) } {
INVALID_HANDLE_VALUE => Err(io::Error::last_os_error()),
event => Ok(event),
}?;
match unsafe { RegNotifyChangeKeyValue(key, watch_subtree, notify_filter, event, TRUE) } {
0 => Ok(()),
_err => Err(io::Error::last_os_error()),
}?;
match unsafe { WaitForSingleObject(event, milliseconds) } {
0 => Ok(()),
0x102 => Err(io::Error::new(
io::ErrorKind::TimedOut,
"Registry timed out",
)),
_ => Err(io::Error::last_os_error()),
}
}
pub fn enum_driver_info(
devinfo: HDEVINFO,
devinfo_data: &SP_DEVINFO_DATA,
driver_type: u32,
member_index: u32,
) -> Option<io::Result<SP_DRVINFO_DATA_V2_W>> {
let mut drvinfo_data: SP_DRVINFO_DATA_V2_W = unsafe { mem::zeroed() };
drvinfo_data.cbSize = mem::size_of_val(&drvinfo_data) as _;
match unsafe {
SetupDiEnumDriverInfoW(
devinfo,
devinfo_data as *const _ as _,
driver_type,
member_index,
&mut drvinfo_data,
)
} {
0 if unsafe { GetLastError() == ERROR_NO_MORE_ITEMS } => None,
0 => Some(Err(io::Error::last_os_error())),
_ => Some(Ok(drvinfo_data)),
}
}
pub fn enum_device_info(
devinfo: HDEVINFO,
member_index: u32,
) -> Option<io::Result<SP_DEVINFO_DATA>> {
let mut devinfo_data: SP_DEVINFO_DATA = unsafe { mem::zeroed() };
devinfo_data.cbSize = mem::size_of_val(&devinfo_data) as _;
match unsafe { SetupDiEnumDeviceInfo(devinfo, member_index, &mut devinfo_data) } {
0 if unsafe { GetLastError() == ERROR_NO_MORE_ITEMS } => None,
0 => Some(Err(io::Error::last_os_error())),
_ => Some(Ok(devinfo_data)),
}
}
pub fn device_io_control(
handle: HANDLE,
io_control_code: u32,
in_buffer: &impl Copy,
out_buffer: &mut impl Copy,
) -> io::Result<()> {
let mut junk = 0;
match unsafe {
DeviceIoControl(
handle,
io_control_code,
in_buffer as *const _ as _,
mem::size_of_val(in_buffer) as _,
out_buffer as *mut _ as _,
mem::size_of_val(out_buffer) as _,
&mut junk,
ptr::null_mut(),
)
} {
0 => Err(io::Error::last_os_error()),
_ => Ok(()),
}
}
pub fn get_mtu_by_index(index: u32, is_v4: bool) -> io::Result<u32> {
// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/nf-netioapi-getipinterfacetable#examples
let mut if_table: *mut MIB_IPINTERFACE_TABLE = ptr::null_mut();
let mut mtu = None;
unsafe {
if GetIpInterfaceTable(if is_v4 { AF_INET } else { AF_INET6 }, &mut if_table) != NO_ERROR {
return Err(io::Error::last_os_error());
}
let ifaces = std::slice::from_raw_parts::<MIB_IPINTERFACE_ROW>(
&(*if_table).Table[0],
(*if_table).NumEntries as usize,
);
for x in ifaces {
if x.InterfaceIndex == index {
mtu = Some(x.NlMtu);
break;
}
}
windows_sys::Win32::NetworkManagement::IpHelper::FreeMibTable(if_table as _);
}
if let Some(mtu) = mtu {
Ok(mtu)
} else {
Err(io::Error::from(io::ErrorKind::NotFound))
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/windows/mod.rs | src/platform/windows/mod.rs | mod device;
pub(crate) mod ffi;
#[cfg(any(
feature = "interruptible",
feature = "async_tokio",
feature = "async_io"
))]
mod interrupt;
mod netsh;
mod tap;
mod tun;
#[cfg(any(
feature = "interruptible",
feature = "async_tokio",
feature = "async_io"
))]
pub use interrupt::InterruptEvent;
pub use device::DeviceImpl;
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/windows/interrupt.rs | src/platform/windows/interrupt.rs | use crate::platform::windows::ffi;
use std::io;
use std::os::windows::io::{AsRawHandle, OwnedHandle};
use std::sync::Mutex;
pub struct InterruptEvent {
pub(crate) handle: OwnedHandle,
state: Mutex<i32>,
}
impl InterruptEvent {
pub fn new() -> io::Result<Self> {
Ok(Self {
handle: ffi::create_event()?,
state: Mutex::new(0),
})
}
pub fn trigger(&self) -> io::Result<()> {
self.trigger_value(1)
}
pub fn trigger_value(&self, val: i32) -> io::Result<()> {
let mut guard = self.state.lock().unwrap();
*guard = val;
ffi::set_event(self.handle.as_raw_handle())
}
#[cfg(feature = "interruptible")]
pub fn is_trigger(&self) -> bool {
*self.state.lock().unwrap() != 0
}
#[cfg(feature = "interruptible")]
pub fn value(&self) -> i32 {
*self.state.lock().unwrap()
}
#[cfg(feature = "interruptible")]
pub fn reset(&self) -> io::Result<()> {
let mut guard = self.state.lock().unwrap();
*guard = 0;
ffi::reset_event(self.handle.as_raw_handle())
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/windows/tun/bindings_i686.rs | src/platform/windows/tun/bindings_i686.rs | /* automatically generated by rust-bindgen 0.72.0 */
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
Self { storage }
}
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
#[inline]
fn extract_bit(byte: u8, index: usize) -> bool {
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
byte & mask == mask
}
#[inline]
pub fn get_bit(&self, index: usize) -> bool {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = self.storage.as_ref()[byte_index];
Self::extract_bit(byte, index)
}
#[inline]
pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
debug_assert!(index / 8 < core::mem::size_of::<Storage>());
let byte_index = index / 8;
let byte = unsafe {
*(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize)
};
Self::extract_bit(byte, index)
}
#[inline]
fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
if val { byte | mask } else { byte & !mask }
}
#[inline]
pub fn set_bit(&mut self, index: usize, val: bool) {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = &mut self.storage.as_mut()[byte_index];
*byte = Self::change_bit(*byte, index, val);
}
#[inline]
pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
debug_assert!(index / 8 < core::mem::size_of::<Storage>());
let byte_index = index / 8;
let byte = unsafe {
(core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize)
};
unsafe { *byte = Self::change_bit(*byte, index, val) };
}
#[inline]
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
let mut val = 0;
for i in 0..(bit_width as usize) {
if self.get_bit(i + bit_offset) {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
let mut val = 0;
for i in 0..(bit_width as usize) {
if unsafe { Self::raw_get_bit(this, i + bit_offset) } {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
self.set_bit(index + bit_offset, val_bit_is_set);
}
}
#[inline]
pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) };
}
}
}
pub type wchar_t = ::std::os::raw::c_ushort;
pub type DWORD = ::std::os::raw::c_ulong;
pub type BOOL = ::std::os::raw::c_int;
pub type BYTE = ::std::os::raw::c_uchar;
pub type ULONG64 = ::std::os::raw::c_ulonglong;
pub type DWORD64 = ::std::os::raw::c_ulonglong;
pub type WCHAR = wchar_t;
pub type LPCWSTR = *const WCHAR;
pub type HANDLE = *mut ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GUID {
pub Data1: ::std::os::raw::c_ulong,
pub Data2: ::std::os::raw::c_ushort,
pub Data3: ::std::os::raw::c_ushort,
pub Data4: [::std::os::raw::c_uchar; 8usize],
}
pub type GUID = _GUID;
#[repr(C)]
#[derive(Copy, Clone)]
pub union _NET_LUID_LH {
pub Value: ULONG64,
pub Info: _NET_LUID_LH__bindgen_ty_1,
}
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Copy, Clone)]
pub struct _NET_LUID_LH__bindgen_ty_1 {
pub _bitfield_align_1: [u32; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
}
impl _NET_LUID_LH__bindgen_ty_1 {
#[inline]
pub fn Reserved(&self) -> ULONG64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 24u8) as u64) }
}
#[inline]
pub fn set_Reserved(&mut self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 24u8, val as u64)
}
}
#[inline]
pub unsafe fn Reserved_raw(this: *const Self) -> ULONG64 {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
0usize,
24u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_Reserved_raw(this: *mut Self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
0usize,
24u8,
val as u64,
)
}
}
#[inline]
pub fn NetLuidIndex(&self) -> ULONG64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 24u8) as u64) }
}
#[inline]
pub fn set_NetLuidIndex(&mut self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(24usize, 24u8, val as u64)
}
}
#[inline]
pub unsafe fn NetLuidIndex_raw(this: *const Self) -> ULONG64 {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
24usize,
24u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_NetLuidIndex_raw(this: *mut Self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
24usize,
24u8,
val as u64,
)
}
}
#[inline]
pub fn IfType(&self) -> ULONG64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u64) }
}
#[inline]
pub fn set_IfType(&mut self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(48usize, 16u8, val as u64)
}
}
#[inline]
pub unsafe fn IfType_raw(this: *const Self) -> ULONG64 {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
48usize,
16u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_IfType_raw(this: *mut Self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
48usize,
16u8,
val as u64,
)
}
}
#[inline]
pub fn new_bitfield_1(
Reserved: ULONG64,
NetLuidIndex: ULONG64,
IfType: ULONG64,
) -> __BindgenBitfieldUnit<[u8; 8usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 24u8, {
let Reserved: u64 = unsafe { ::std::mem::transmute(Reserved) };
Reserved as u64
});
__bindgen_bitfield_unit.set(24usize, 24u8, {
let NetLuidIndex: u64 = unsafe { ::std::mem::transmute(NetLuidIndex) };
NetLuidIndex as u64
});
__bindgen_bitfield_unit.set(48usize, 16u8, {
let IfType: u64 = unsafe { ::std::mem::transmute(IfType) };
IfType as u64
});
__bindgen_bitfield_unit
}
}
pub type NET_LUID_LH = _NET_LUID_LH;
pub type NET_LUID = NET_LUID_LH;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _WINTUN_ADAPTER {
_unused: [u8; 0],
}
#[doc = " A handle representing Wintun adapter"]
pub type WINTUN_ADAPTER_HANDLE = *mut _WINTUN_ADAPTER;
#[doc = "< Informational"]
pub const WINTUN_LOGGER_LEVEL_WINTUN_LOG_INFO: WINTUN_LOGGER_LEVEL = 0;
#[doc = "< Warning"]
pub const WINTUN_LOGGER_LEVEL_WINTUN_LOG_WARN: WINTUN_LOGGER_LEVEL = 1;
#[doc = "< Error"]
pub const WINTUN_LOGGER_LEVEL_WINTUN_LOG_ERR: WINTUN_LOGGER_LEVEL = 2;
#[doc = " Determines the level of logging, passed to WINTUN_LOGGER_CALLBACK."]
pub type WINTUN_LOGGER_LEVEL = ::std::os::raw::c_int;
#[doc = " Called by internal logger to report diagnostic messages\n\n @param Level Message level.\n\n @param Timestamp Message timestamp in in 100ns intervals since 1601-01-01 UTC.\n\n @param Message Message text."]
pub type WINTUN_LOGGER_CALLBACK = ::std::option::Option<
unsafe extern "stdcall" fn(Level: WINTUN_LOGGER_LEVEL, Timestamp: DWORD64, Message: LPCWSTR),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _TUN_SESSION {
_unused: [u8; 0],
}
#[doc = " A handle representing Wintun session"]
pub type WINTUN_SESSION_HANDLE = *mut _TUN_SESSION;
pub struct wintun {
__library: ::libloading::Library,
pub WintunCreateAdapter: unsafe extern "stdcall" fn(
arg1: LPCWSTR,
arg2: LPCWSTR,
arg3: *const GUID,
) -> WINTUN_ADAPTER_HANDLE,
pub WintunCloseAdapter: unsafe extern "stdcall" fn(arg1: WINTUN_ADAPTER_HANDLE),
pub WintunOpenAdapter: unsafe extern "stdcall" fn(arg1: LPCWSTR) -> WINTUN_ADAPTER_HANDLE,
pub WintunGetAdapterLUID:
unsafe extern "stdcall" fn(arg1: WINTUN_ADAPTER_HANDLE, arg2: *mut NET_LUID),
pub WintunGetRunningDriverVersion: unsafe extern "stdcall" fn() -> DWORD,
pub WintunDeleteDriver: unsafe extern "stdcall" fn() -> BOOL,
pub WintunSetLogger: unsafe extern "stdcall" fn(arg1: WINTUN_LOGGER_CALLBACK),
pub WintunStartSession: unsafe extern "stdcall" fn(
arg1: WINTUN_ADAPTER_HANDLE,
arg2: DWORD,
) -> WINTUN_SESSION_HANDLE,
pub WintunEndSession: unsafe extern "stdcall" fn(arg1: WINTUN_SESSION_HANDLE),
pub WintunGetReadWaitEvent: unsafe extern "stdcall" fn(arg1: WINTUN_SESSION_HANDLE) -> HANDLE,
pub WintunReceivePacket:
unsafe extern "stdcall" fn(arg1: WINTUN_SESSION_HANDLE, arg2: *mut DWORD) -> *mut BYTE,
pub WintunReleaseReceivePacket:
unsafe extern "stdcall" fn(arg1: WINTUN_SESSION_HANDLE, arg2: *const BYTE),
pub WintunAllocateSendPacket:
unsafe extern "stdcall" fn(arg1: WINTUN_SESSION_HANDLE, arg2: DWORD) -> *mut BYTE,
pub WintunSendPacket:
unsafe extern "stdcall" fn(arg1: WINTUN_SESSION_HANDLE, arg2: *const BYTE),
}
impl wintun {
pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
where
P: AsRef<::std::ffi::OsStr>,
{
let library = ::libloading::Library::new(path)?;
Self::from_library(library)
}
pub unsafe fn from_library<L>(library: L) -> Result<Self, ::libloading::Error>
where
L: Into<::libloading::Library>,
{
let __library = library.into();
let WintunCreateAdapter = __library.get(b"WintunCreateAdapter\0").map(|sym| *sym)?;
let WintunCloseAdapter = __library.get(b"WintunCloseAdapter\0").map(|sym| *sym)?;
let WintunOpenAdapter = __library.get(b"WintunOpenAdapter\0").map(|sym| *sym)?;
let WintunGetAdapterLUID = __library.get(b"WintunGetAdapterLUID\0").map(|sym| *sym)?;
let WintunGetRunningDriverVersion = __library
.get(b"WintunGetRunningDriverVersion\0")
.map(|sym| *sym)?;
let WintunDeleteDriver = __library.get(b"WintunDeleteDriver\0").map(|sym| *sym)?;
let WintunSetLogger = __library.get(b"WintunSetLogger\0").map(|sym| *sym)?;
let WintunStartSession = __library.get(b"WintunStartSession\0").map(|sym| *sym)?;
let WintunEndSession = __library.get(b"WintunEndSession\0").map(|sym| *sym)?;
let WintunGetReadWaitEvent = __library.get(b"WintunGetReadWaitEvent\0").map(|sym| *sym)?;
let WintunReceivePacket = __library.get(b"WintunReceivePacket\0").map(|sym| *sym)?;
let WintunReleaseReceivePacket = __library
.get(b"WintunReleaseReceivePacket\0")
.map(|sym| *sym)?;
let WintunAllocateSendPacket = __library
.get(b"WintunAllocateSendPacket\0")
.map(|sym| *sym)?;
let WintunSendPacket = __library.get(b"WintunSendPacket\0").map(|sym| *sym)?;
Ok(wintun {
__library,
WintunCreateAdapter,
WintunCloseAdapter,
WintunOpenAdapter,
WintunGetAdapterLUID,
WintunGetRunningDriverVersion,
WintunDeleteDriver,
WintunSetLogger,
WintunStartSession,
WintunEndSession,
WintunGetReadWaitEvent,
WintunReceivePacket,
WintunReleaseReceivePacket,
WintunAllocateSendPacket,
WintunSendPacket,
})
}
pub unsafe fn WintunCreateAdapter(
&self,
arg1: LPCWSTR,
arg2: LPCWSTR,
arg3: *const GUID,
) -> WINTUN_ADAPTER_HANDLE {
(self.WintunCreateAdapter)(arg1, arg2, arg3)
}
pub unsafe fn WintunCloseAdapter(&self, arg1: WINTUN_ADAPTER_HANDLE) {
(self.WintunCloseAdapter)(arg1)
}
pub unsafe fn WintunOpenAdapter(&self, arg1: LPCWSTR) -> WINTUN_ADAPTER_HANDLE {
(self.WintunOpenAdapter)(arg1)
}
pub unsafe fn WintunGetAdapterLUID(&self, arg1: WINTUN_ADAPTER_HANDLE, arg2: *mut NET_LUID) {
(self.WintunGetAdapterLUID)(arg1, arg2)
}
pub unsafe fn WintunGetRunningDriverVersion(&self) -> DWORD {
(self.WintunGetRunningDriverVersion)()
}
pub unsafe fn WintunDeleteDriver(&self) -> BOOL {
(self.WintunDeleteDriver)()
}
pub unsafe fn WintunSetLogger(&self, arg1: WINTUN_LOGGER_CALLBACK) {
(self.WintunSetLogger)(arg1)
}
pub unsafe fn WintunStartSession(
&self,
arg1: WINTUN_ADAPTER_HANDLE,
arg2: DWORD,
) -> WINTUN_SESSION_HANDLE {
(self.WintunStartSession)(arg1, arg2)
}
pub unsafe fn WintunEndSession(&self, arg1: WINTUN_SESSION_HANDLE) {
(self.WintunEndSession)(arg1)
}
pub unsafe fn WintunGetReadWaitEvent(&self, arg1: WINTUN_SESSION_HANDLE) -> HANDLE {
(self.WintunGetReadWaitEvent)(arg1)
}
pub unsafe fn WintunReceivePacket(
&self,
arg1: WINTUN_SESSION_HANDLE,
arg2: *mut DWORD,
) -> *mut BYTE {
(self.WintunReceivePacket)(arg1, arg2)
}
pub unsafe fn WintunReleaseReceivePacket(
&self,
arg1: WINTUN_SESSION_HANDLE,
arg2: *const BYTE,
) {
(self.WintunReleaseReceivePacket)(arg1, arg2)
}
pub unsafe fn WintunAllocateSendPacket(
&self,
arg1: WINTUN_SESSION_HANDLE,
arg2: DWORD,
) -> *mut BYTE {
(self.WintunAllocateSendPacket)(arg1, arg2)
}
pub unsafe fn WintunSendPacket(&self, arg1: WINTUN_SESSION_HANDLE, arg2: *const BYTE) {
(self.WintunSendPacket)(arg1, arg2)
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/windows/tun/adapter.rs | src/platform/windows/tun/adapter.rs | use std::{io, mem, ptr};
use crate::windows::{
device::GUID_NETWORK_ADAPTER,
ffi::{decode_utf16, destroy_device_info_list, encode_utf16, enum_device_info},
};
use windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE;
use windows_sys::Win32::Foundation::{DEVPROPKEY, ERROR_INSUFFICIENT_BUFFER};
use windows_sys::{
core::GUID,
Win32::{
Devices::{
DeviceAndDriverInstallation::{
CM_Get_DevNode_Status, SetupDiGetClassDevsExW, SetupDiGetDevicePropertyW,
CM_DEVNODE_STATUS_FLAGS, CR_SUCCESS, DN_HAS_PROBLEM, HDEVINFO, SP_DEVINFO_DATA,
},
Properties::DEVPROPID_FIRST_USABLE,
},
System::SystemInformation::{GetVersionExA, OSVERSIONINFOA},
},
};
#[allow(non_upper_case_globals)]
pub const DEVPKEY_Wintun_Name: DEVPROPKEY = DEVPROPKEY {
fmtid: GUID {
data1: 0x3361c968,
data2: 0x2f2e,
data3: 0x4660,
data4: [0xb4, 0x7e, 0x69, 0x9c, 0xdc, 0x4c, 0x32, 0xb9],
},
pid: DEVPROPID_FIRST_USABLE + 1,
};
#[allow(non_upper_case_globals)]
pub const DEVPKEY_Wintun_OwningProcess: DEVPROPKEY = DEVPROPKEY {
fmtid: GUID {
data1: 0x3361c968,
data2: 0x2f2e,
data3: 0x4660,
data4: [0xb4, 0x7e, 0x69, 0x9c, 0xdc, 0x4c, 0x32, 0xb9],
},
pid: DEVPROPID_FIRST_USABLE + 3,
};
pub fn check_adapter_if_orphaned_devices(adapter_name: &str) -> bool {
if is_windows_seven() {
return super::adapter_win7::check_adapter_if_orphaned_devices_win7(adapter_name);
}
let device_name = encode_utf16("SWD\\Wintun");
let dev_info = unsafe {
SetupDiGetClassDevsExW(
&GUID_NETWORK_ADAPTER,
device_name.as_ptr(),
ptr::null_mut(),
0,
0,
ptr::null_mut(),
ptr::null_mut(),
)
};
if dev_info == INVALID_HANDLE_VALUE as isize {
log::error!("Failed to get adapters");
return false;
}
let mut index = 0;
let is_orphaned_adapter = loop {
match enum_device_info(dev_info, index) {
Some(ret) => {
let Ok(devinfo_data) = ret else {
continue;
};
let Ok(status) = dev_node_status(&devinfo_data) else {
index += 1;
continue;
};
if status & DN_HAS_PROBLEM == 0 {
index += 1;
continue;
}
let Ok(name) = get_device_name(dev_info, &devinfo_data) else {
index += 1;
continue;
};
if adapter_name == name {
break true;
}
}
None => break false,
}
index += 1;
};
_ = destroy_device_info_list(dev_info);
is_orphaned_adapter
}
pub fn get_device_name(devinfo: HDEVINFO, devinfo_data: &SP_DEVINFO_DATA) -> io::Result<String> {
let mut prop_type: u32 = 0;
let mut required_size: u32 = 0;
let ok = unsafe {
SetupDiGetDevicePropertyW(
devinfo,
devinfo_data,
&DEVPKEY_Wintun_Name,
&mut prop_type,
ptr::null_mut(),
0,
&mut required_size,
0,
)
};
if ok == 0 {
let err = io::Error::last_os_error();
if err.raw_os_error() != Some(ERROR_INSUFFICIENT_BUFFER as i32) {
return Err(err);
}
}
let mut buf: Vec<u16> = vec![0; (required_size / 2) as usize];
let ok = unsafe {
SetupDiGetDevicePropertyW(
devinfo,
devinfo_data,
&DEVPKEY_Wintun_Name,
&mut prop_type,
buf.as_mut_ptr() as *mut u8,
required_size,
&mut required_size,
0,
)
};
if ok == 0 {
return Err(io::Error::last_os_error());
}
Ok(decode_utf16(&buf))
}
fn is_windows_seven() -> bool {
let mut info = OSVERSIONINFOA {
dwOSVersionInfoSize: mem::size_of::<OSVERSIONINFOA>() as u32,
dwMajorVersion: 0,
dwMinorVersion: 0,
dwBuildNumber: 0,
dwPlatformId: 0,
szCSDVersion: [0; 128],
};
unsafe {
if GetVersionExA(&mut info as *mut _) == 0 {
return false;
}
}
info.dwMajorVersion == 6 && info.dwMinorVersion == 1
}
fn dev_node_status(devinfo_data: &SP_DEVINFO_DATA) -> io::Result<CM_DEVNODE_STATUS_FLAGS> {
let mut pulstatus = 0;
let mut pulproblemnumber = 0;
let cr = unsafe {
CM_Get_DevNode_Status(
&mut pulstatus,
&mut pulproblemnumber,
devinfo_data.DevInst,
0,
)
};
if cr != CR_SUCCESS {
return Err(io::Error::last_os_error());
}
Ok(pulstatus)
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/windows/tun/adapter_win7.rs | src/platform/windows/tun/adapter_win7.rs | use std::{mem, ptr};
use windows_sys::Win32::Devices::DeviceAndDriverInstallation::{
SetupDiGetClassDevsExW, SetupDiGetDevicePropertyW,
};
use windows_sys::Win32::Devices::Properties::DEVPROP_TYPE_BINARY;
use windows_sys::Win32::Foundation::{
CloseHandle, GetLastError, ERROR_INVALID_DATA, FILETIME, INVALID_HANDLE_VALUE,
};
use windows_sys::Win32::System::Threading::{
GetProcessTimes, OpenProcess, PROCESS_QUERY_LIMITED_INFORMATION,
};
use crate::windows::{
device::GUID_NETWORK_ADAPTER,
ffi::{destroy_device_info_list, encode_utf16, enum_device_info},
tun::adapter::{get_device_name, DEVPKEY_Wintun_OwningProcess},
};
#[repr(C)]
pub struct OwningProcess {
process_id: u32,
creation_time: FILETIME,
}
pub fn check_adapter_if_orphaned_devices_win7(adapter_name: &str) -> bool {
let device_name = encode_utf16("ROOT\\Wintun");
let dev_info = unsafe {
SetupDiGetClassDevsExW(
&GUID_NETWORK_ADAPTER,
device_name.as_ptr(),
ptr::null_mut(),
0,
0,
ptr::null_mut(),
ptr::null_mut(),
)
};
if dev_info == INVALID_HANDLE_VALUE as isize {
if unsafe { GetLastError() } != ERROR_INVALID_DATA {
log::error!("Failed to get adapters");
}
return false;
}
let mut index = 0;
let is_orphaned_adapter = loop {
match enum_device_info(dev_info, index) {
Some(ret) => {
let Ok(devinfo_data) = ret else {
continue;
};
unsafe {
let mut ptype = mem::zeroed();
let mut buf: [u8; mem::size_of::<OwningProcess>()] = mem::zeroed();
let ok = SetupDiGetDevicePropertyW(
dev_info,
&devinfo_data,
&DEVPKEY_Wintun_OwningProcess,
&mut ptype,
&mut buf as _,
buf.len() as _,
ptr::null_mut(),
0,
);
if ok != 0 && ptype == DEVPROP_TYPE_BINARY && {
let owning_process = buf.as_ptr() as *const OwningProcess;
!process_is_stale(&*owning_process)
} {
continue;
}
}
let Ok(name) = get_device_name(dev_info, &devinfo_data) else {
index += 1;
continue;
};
if adapter_name == name {
break true;
}
}
None => break false,
}
index += 1;
};
_ = destroy_device_info_list(dev_info);
is_orphaned_adapter
}
fn process_is_stale(owning_process: &OwningProcess) -> bool {
let process = unsafe {
OpenProcess(
PROCESS_QUERY_LIMITED_INFORMATION,
0,
owning_process.process_id,
)
};
if process.is_null() {
return true;
}
let mut creation_time: FILETIME = unsafe { std::mem::zeroed() };
let mut unused: FILETIME = unsafe { std::mem::zeroed() };
let ret = unsafe {
GetProcessTimes(
process,
&mut creation_time,
&mut unused,
&mut unused,
&mut unused,
)
};
_ = unsafe { CloseHandle(process) };
if ret == 0 {
return false;
}
creation_time.dwHighDateTime == owning_process.creation_time.dwHighDateTime
&& creation_time.dwLowDateTime == owning_process.creation_time.dwLowDateTime
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/windows/tun/mod.rs | src/platform/windows/tun/mod.rs | use std::os::windows::io::{AsRawHandle, OwnedHandle};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, MutexGuard, RwLock};
use std::{io, ptr};
use windows_sys::core::GUID;
use windows_sys::Win32::Foundation::{
GetLastError, ERROR_BUFFER_OVERFLOW, ERROR_HANDLE_EOF, ERROR_INVALID_DATA, ERROR_NO_MORE_ITEMS,
WAIT_FAILED, WAIT_OBJECT_0,
};
use windows_sys::Win32::NetworkManagement::Ndis::NET_LUID_LH;
use windows_sys::Win32::System::Threading::{WaitForMultipleObjects, INFINITE};
use crate::platform::windows::ffi;
use crate::platform::windows::ffi::encode_utf16;
mod adapter;
mod adapter_win7;
mod wintun_log;
mod wintun_raw;
pub use adapter::check_adapter_if_orphaned_devices;
/// The maximum size of wintun's internal ring buffer (in bytes)
pub const MAX_RING_CAPACITY: u32 = 0x400_0000;
/// The minimum size of wintun's internal ring buffer (in bytes)
pub const MIN_RING_CAPACITY: u32 = 0x2_0000;
/// Maximum pool name length including zero terminator
pub const MAX_POOL: usize = 256;
pub struct TunDevice {
index: u32,
luid: NET_LUID_LH,
win_tun_adapter: WinTunAdapter,
}
struct WinTunAdapter {
win_tun: Arc<wintun_raw::wintun>,
handle: wintun_raw::WINTUN_ADAPTER_HANDLE,
event: OwnedHandle,
ring_capacity: u32,
state: State,
session: RwLock<Option<WinTunSession>>,
delete_driver: bool,
}
unsafe impl Send for WinTunAdapter {}
unsafe impl Sync for WinTunAdapter {}
struct WinTunSession {
win_tun: Arc<wintun_raw::wintun>,
handle: wintun_raw::WINTUN_SESSION_HANDLE,
read_event: wintun_raw::HANDLE,
}
impl Drop for WinTunAdapter {
fn drop(&mut self) {
let session = self.session.write().unwrap().take();
drop(session);
unsafe {
self.win_tun.WintunCloseAdapter(self.handle);
if self.delete_driver {
self.win_tun.WintunDeleteDriver();
}
}
}
}
#[derive(Default)]
struct State {
state: AtomicBool,
lock: Mutex<()>,
}
impl State {
fn check(&self) -> io::Result<()> {
if self.is_enabled() {
Ok(())
} else {
Err(io::Error::other("The interface has been disabled"))
}
}
fn is_disabled(&self) -> bool {
!self.state.load(Ordering::Relaxed)
}
fn is_enabled(&self) -> bool {
self.state.load(Ordering::Relaxed)
}
fn disable(&self) {
self.state.store(false, Ordering::Relaxed);
}
fn enable(&self) {
self.state.store(true, Ordering::Relaxed);
}
fn lock(&self) -> MutexGuard<'_, ()> {
self.lock.lock().unwrap()
}
}
impl WinTunAdapter {
fn disable(&self) -> io::Result<()> {
let _guard = self.state.lock();
if self.state.is_disabled() {
return Ok(());
}
self.state.disable();
if let Err(e) = ffi::set_event(self.event.as_raw_handle()) {
self.state.enable();
return Err(e);
}
_ = self.session.write().unwrap().take();
ffi::reset_event(self.event.as_raw_handle())
}
fn enable(&self) -> io::Result<()> {
let _guard = self.state.lock();
if self.state.is_disabled() {
let mut session = self.session.write().unwrap();
unsafe {
let session_handle = self
.win_tun
.WintunStartSession(self.handle, self.ring_capacity);
if session_handle.is_null() {
Err(io::Error::last_os_error())?
}
let read_event_handle = self.win_tun.WintunGetReadWaitEvent(session_handle);
if read_event_handle.is_null() {
self.win_tun.WintunEndSession(session_handle);
Err(io::Error::last_os_error())?
}
let wintun_session = WinTunSession {
win_tun: self.win_tun.clone(),
handle: session_handle,
read_event: read_event_handle,
};
session.replace(wintun_session);
}
self.state.enable();
}
Ok(())
}
fn version(&self) -> io::Result<String> {
let version = unsafe { self.win_tun.WintunGetRunningDriverVersion() };
let v = version.to_be_bytes();
Ok(format!(
"{}.{}",
u16::from_be_bytes([v[0], v[1]]),
u16::from_be_bytes([v[2], v[3]])
))
}
fn send(&self, buf: &[u8], event: Option<&OwnedHandle>) -> io::Result<usize> {
let guard = self.session.read().unwrap();
if let Some(session) = guard.as_ref() {
return session.send(buf, &self.state, event);
}
Err(io::Error::other("The interface has been disabled"))
}
fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
let guard = self.session.read().unwrap();
if let Some(session) = guard.as_ref() {
return session.recv(&self.event, buf);
}
Err(io::Error::other("The interface has been disabled"))
}
fn try_send(&self, buf: &[u8]) -> io::Result<usize> {
let guard = self.session.read().unwrap();
if let Some(session) = guard.as_ref() {
return session.try_send(buf);
}
Err(io::Error::other("The interface has been disabled"))
}
fn try_recv(&self, buf: &mut [u8]) -> io::Result<usize> {
let guard = self.session.read().unwrap();
if let Some(session) = guard.as_ref() {
return session.try_recv(buf);
}
Err(io::Error::other("The interface has been disabled"))
}
fn wait_readable_interruptible(
&self,
interrupt_event: &OwnedHandle,
timeout: Option<std::time::Duration>,
) -> io::Result<()> {
let guard = self.session.read().unwrap();
if let Some(session) = guard.as_ref() {
return session.wait_readable_interruptible(&self.event, interrupt_event, timeout);
}
Err(io::Error::other("The interface has been disabled"))
}
}
impl Drop for WinTunSession {
fn drop(&mut self) {
unsafe {
self.win_tun.WintunEndSession(self.handle);
}
}
}
impl WinTunSession {
fn send(&self, buf: &[u8], state: &State, event: Option<&OwnedHandle>) -> io::Result<usize> {
let mut count = 0;
loop {
return match self.try_send(buf) {
Ok(len) => Ok(len),
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
state.check()?;
count += 1;
if count > 50 {
return Err(io::Error::from(io::ErrorKind::TimedOut));
}
if let Some(event) = event {
if ffi::wait_for_single_object(event.as_raw_handle(), 0).is_ok() {
return Err(io::Error::new(
io::ErrorKind::Interrupted,
"trigger interrupt",
));
}
}
std::thread::sleep(std::time::Duration::from_millis(1));
continue;
}
Err(e) => Err(e),
};
}
}
fn recv(&self, inner_event: &OwnedHandle, buf: &mut [u8]) -> io::Result<usize> {
loop {
for i in 0..64 {
return match self.try_recv(buf) {
Ok(n) => Ok(n),
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
if i > 32 {
std::thread::yield_now()
} else {
std::hint::spin_loop();
}
continue;
}
Err(e) => Err(e),
};
}
self.wait_readable(inner_event)?;
}
}
fn try_send(&self, buf: &[u8]) -> io::Result<usize> {
assert!(buf.len() <= u32::MAX as _);
let win_tun = &self.win_tun;
let handle = self.handle;
let bytes_ptr = unsafe { win_tun.WintunAllocateSendPacket(handle, buf.len() as u32) };
if bytes_ptr.is_null() {
match unsafe { GetLastError() } {
ERROR_HANDLE_EOF => Err(std::io::Error::from(io::ErrorKind::WriteZero)),
ERROR_BUFFER_OVERFLOW => Err(std::io::Error::from(io::ErrorKind::WouldBlock)),
ERROR_INVALID_DATA => Err(std::io::Error::from(io::ErrorKind::InvalidData)),
e => Err(io::Error::from_raw_os_error(e as i32)),
}
} else {
unsafe { ptr::copy_nonoverlapping(buf.as_ptr(), bytes_ptr, buf.len()) };
unsafe { win_tun.WintunSendPacket(handle, bytes_ptr) };
Ok(buf.len())
}
}
fn try_recv(&self, buf: &mut [u8]) -> io::Result<usize> {
let mut size = 0u32;
let win_tun = &self.win_tun;
let handle = self.handle;
let ptr = unsafe { win_tun.WintunReceivePacket(handle, &mut size as *mut u32) };
if ptr.is_null() {
// Wintun returns ERROR_NO_MORE_ITEMS instead of blocking if packets are not available
return match unsafe { GetLastError() } {
ERROR_HANDLE_EOF => Err(std::io::Error::from(io::ErrorKind::UnexpectedEof)),
ERROR_NO_MORE_ITEMS => Err(std::io::Error::from(io::ErrorKind::WouldBlock)),
e => Err(io::Error::from_raw_os_error(e as i32)),
};
}
let size = size as usize;
if size > buf.len() {
unsafe { win_tun.WintunReleaseReceivePacket(handle, ptr) };
use std::io::{Error, ErrorKind::InvalidInput};
return Err(Error::new(InvalidInput, "destination buffer too small"));
}
unsafe { ptr::copy_nonoverlapping(ptr, buf.as_mut_ptr(), size) };
unsafe { win_tun.WintunReleaseReceivePacket(handle, ptr) };
Ok(size)
}
fn wait_readable_interruptible(
&self,
inner_event: &OwnedHandle,
interrupt_event: &OwnedHandle,
timeout: Option<std::time::Duration>,
) -> io::Result<()> {
//Wait on both the read handle and the shutdown handle so that we stop when requested
let handles = [
self.read_event,
inner_event.as_raw_handle(),
interrupt_event.as_raw_handle(),
];
let result = unsafe {
//SAFETY: We abide by the requirements of WaitForMultipleObjects, handles is a
//pointer to valid, aligned, stack memory
WaitForMultipleObjects(
3,
&handles as _,
0,
timeout
.map(|t| t.as_millis().min(INFINITE as _) as u32)
.unwrap_or(INFINITE),
)
};
match result {
WAIT_FAILED => Err(io::Error::last_os_error()),
windows_sys::Win32::Foundation::WAIT_TIMEOUT => {
Err(io::Error::from(io::ErrorKind::TimedOut))
}
_ => {
if result == WAIT_OBJECT_0 {
//We have data!
Ok(())
} else if result == WAIT_OBJECT_0 + 1 {
Err(io::Error::other("The interface has been disabled"))
} else if result == WAIT_OBJECT_0 + 2 {
Err(io::Error::new(
io::ErrorKind::Interrupted,
"trigger interrupt",
))
} else {
Err(io::Error::last_os_error())
}
}
}
}
fn wait_readable(&self, inner_event: &OwnedHandle) -> io::Result<()> {
//Wait on both the read handle and the shutdown handle so that we stop when requested
let handles = [self.read_event, inner_event.as_raw_handle()];
let result = unsafe {
//SAFETY: We abide by the requirements of WaitForMultipleObjects, handles is a
//pointer to valid, aligned, stack memory
WaitForMultipleObjects(2, &handles as _, 0, INFINITE)
};
match result {
WAIT_FAILED => Err(io::Error::last_os_error()),
_ => {
if result == WAIT_OBJECT_0 {
//We have data!
Ok(())
} else if result == WAIT_OBJECT_0 + 1 {
Err(io::Error::other("The interface has been disabled"))
} else {
Err(io::Error::last_os_error())
}
}
}
}
}
impl TunDevice {
pub fn open(
wintun_path: &str,
name: &str,
ring_capacity: u32,
delete_driver: bool,
wintun_log: bool,
) -> std::io::Result<Self> {
let range = MIN_RING_CAPACITY..=MAX_RING_CAPACITY;
if !range.contains(&ring_capacity) {
Err(io::Error::other(format!(
"ring capacity {ring_capacity} not in [{MIN_RING_CAPACITY},{MAX_RING_CAPACITY}]"
)))?;
}
let name_utf16 = encode_utf16(name);
if name_utf16.len() > MAX_POOL {
Err(io::Error::other("name too long"))?;
}
unsafe {
let event = ffi::create_event()?;
let win_tun = wintun_raw::wintun::new(wintun_path).map_err(io::Error::other)?;
if wintun_log {
wintun_log::set_default_logger_if_unset(&win_tun);
}
let adapter = win_tun.WintunOpenAdapter(name_utf16.as_ptr());
if adapter.is_null() {
Err(io::Error::last_os_error())?
}
let mut luid: wintun_raw::NET_LUID = std::mem::zeroed();
win_tun.WintunGetAdapterLUID(adapter, &mut luid as *mut wintun_raw::NET_LUID);
let win_tun_adapter = WinTunAdapter {
win_tun: Arc::new(win_tun),
handle: adapter,
state: State::default(),
event,
ring_capacity,
session: Default::default(),
delete_driver,
};
let luid = std::mem::transmute::<wintun_raw::NET_LUID, NET_LUID_LH>(luid);
let index = ffi::luid_to_index(&luid)?;
let tun = Self {
luid,
index,
win_tun_adapter,
};
Ok(tun)
}
}
pub fn create(
wintun_path: &str,
name: &str,
description: &str,
guid: Option<u128>,
ring_capacity: u32,
delete_driver: bool,
wintun_log: bool,
) -> std::io::Result<Self> {
let range = MIN_RING_CAPACITY..=MAX_RING_CAPACITY;
if !range.contains(&ring_capacity) {
Err(io::Error::other(format!(
"ring capacity {ring_capacity} not in [{MIN_RING_CAPACITY},{MAX_RING_CAPACITY}]"
)))?;
}
let name_utf16 = encode_utf16(name);
let description_utf16 = encode_utf16(description);
if name_utf16.len() > MAX_POOL {
Err(io::Error::other("name too long"))?;
}
if description_utf16.len() > MAX_POOL {
Err(io::Error::other("tunnel type too long"))?;
}
unsafe {
let event = ffi::create_event()?;
let win_tun = wintun_raw::wintun::new(wintun_path).map_err(io::Error::other)?;
if wintun_log {
wintun_log::set_default_logger_if_unset(&win_tun);
}
//SAFETY: guid is a unique integer so transmuting either all zeroes or the user's preferred
//guid to the wintun_raw guid type is safe and will allow the windows kernel to see our GUID
let guid = guid.map(|guid| {
let guid = GUID::from_u128(guid);
wintun_raw::GUID {
Data1: guid.data1,
Data2: guid.data2,
Data3: guid.data3,
Data4: guid.data4,
}
});
//SAFETY: the function is loaded from the wintun dll properly, we are providing valid
//pointers, and all the strings are correct null terminated UTF-16. This safety rationale
//applies for all Wintun* functions below
let adapter = win_tun.WintunCreateAdapter(
name_utf16.as_ptr(),
description_utf16.as_ptr(),
guid.as_ref().map_or(ptr::null(), |guid| guid),
);
if adapter.is_null() {
Err(io::Error::last_os_error())?
}
let mut luid: wintun_raw::NET_LUID = std::mem::zeroed();
win_tun.WintunGetAdapterLUID(adapter, &mut luid as *mut wintun_raw::NET_LUID);
let win_tun_adapter = WinTunAdapter {
win_tun: Arc::new(win_tun),
handle: adapter,
state: State::default(),
event,
ring_capacity,
session: Default::default(),
delete_driver,
};
let luid = std::mem::transmute::<wintun_raw::NET_LUID, NET_LUID_LH>(luid);
let index = ffi::luid_to_index(&luid)?;
let tun = Self {
luid,
index,
win_tun_adapter,
};
Ok(tun)
}
}
pub fn index(&self) -> u32 {
self.index
}
pub fn get_name(&self) -> io::Result<String> {
ffi::luid_to_alias(&self.luid)
}
pub fn send(&self, buf: &[u8]) -> io::Result<usize> {
self.win_tun_adapter.send(buf, None)
}
#[allow(dead_code)]
pub(crate) fn send_interruptible(&self, buf: &[u8], event: &OwnedHandle) -> io::Result<usize> {
self.win_tun_adapter.send(buf, Some(event))
}
#[allow(dead_code)]
pub(crate) fn wait_readable_interruptible(
&self,
interrupt_event: &OwnedHandle,
timeout: Option<std::time::Duration>,
) -> io::Result<()> {
self.win_tun_adapter
.wait_readable_interruptible(interrupt_event, timeout)
}
pub fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
self.win_tun_adapter.recv(buf)
}
pub fn try_send(&self, buf: &[u8]) -> io::Result<usize> {
self.win_tun_adapter.try_send(buf)
}
pub fn try_recv(&self, buf: &mut [u8]) -> io::Result<usize> {
self.win_tun_adapter.try_recv(buf)
}
pub fn shutdown(&self) -> io::Result<()> {
self.win_tun_adapter.disable()
}
pub fn version(&self) -> io::Result<String> {
self.win_tun_adapter.version()
}
pub fn enabled(&self, value: bool) -> io::Result<()> {
if value {
self.win_tun_adapter.enable()
} else {
self.win_tun_adapter.disable()
}
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/windows/tun/wintun_raw.rs | src/platform/windows/tun/wintun_raw.rs | #![allow(warnings)]
#[cfg(all(not(docsrs), feature = "bindgen"))]
include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
#[cfg(any(docsrs, not(feature = "bindgen")))]
#[cfg(target_pointer_width = "64")]
include!("bindings_x86_64.rs");
#[cfg(any(docsrs, not(feature = "bindgen")))]
#[cfg(target_pointer_width = "32")]
include!("bindings_i686.rs");
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/windows/tun/bindings_x86_64.rs | src/platform/windows/tun/bindings_x86_64.rs | /* automatically generated by rust-bindgen 0.72.0 */
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
Self { storage }
}
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
#[inline]
fn extract_bit(byte: u8, index: usize) -> bool {
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
byte & mask == mask
}
#[inline]
pub fn get_bit(&self, index: usize) -> bool {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = self.storage.as_ref()[byte_index];
Self::extract_bit(byte, index)
}
#[inline]
pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
debug_assert!(index / 8 < core::mem::size_of::<Storage>());
let byte_index = index / 8;
let byte = unsafe {
*(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize)
};
Self::extract_bit(byte, index)
}
#[inline]
fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
if val { byte | mask } else { byte & !mask }
}
#[inline]
pub fn set_bit(&mut self, index: usize, val: bool) {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = &mut self.storage.as_mut()[byte_index];
*byte = Self::change_bit(*byte, index, val);
}
#[inline]
pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
debug_assert!(index / 8 < core::mem::size_of::<Storage>());
let byte_index = index / 8;
let byte = unsafe {
(core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize)
};
unsafe { *byte = Self::change_bit(*byte, index, val) };
}
#[inline]
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
let mut val = 0;
for i in 0..(bit_width as usize) {
if self.get_bit(i + bit_offset) {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
let mut val = 0;
for i in 0..(bit_width as usize) {
if unsafe { Self::raw_get_bit(this, i + bit_offset) } {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
self.set_bit(index + bit_offset, val_bit_is_set);
}
}
#[inline]
pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) };
}
}
}
pub type wchar_t = ::std::os::raw::c_ushort;
pub type DWORD = ::std::os::raw::c_ulong;
pub type BOOL = ::std::os::raw::c_int;
pub type BYTE = ::std::os::raw::c_uchar;
pub type ULONG64 = ::std::os::raw::c_ulonglong;
pub type DWORD64 = ::std::os::raw::c_ulonglong;
pub type WCHAR = wchar_t;
pub type LPCWSTR = *const WCHAR;
pub type HANDLE = *mut ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GUID {
pub Data1: ::std::os::raw::c_ulong,
pub Data2: ::std::os::raw::c_ushort,
pub Data3: ::std::os::raw::c_ushort,
pub Data4: [::std::os::raw::c_uchar; 8usize],
}
pub type GUID = _GUID;
#[repr(C)]
#[derive(Copy, Clone)]
pub union _NET_LUID_LH {
pub Value: ULONG64,
pub Info: _NET_LUID_LH__bindgen_ty_1,
}
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Copy, Clone)]
pub struct _NET_LUID_LH__bindgen_ty_1 {
pub _bitfield_align_1: [u32; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
}
impl _NET_LUID_LH__bindgen_ty_1 {
#[inline]
pub fn Reserved(&self) -> ULONG64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 24u8) as u64) }
}
#[inline]
pub fn set_Reserved(&mut self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 24u8, val as u64)
}
}
#[inline]
pub unsafe fn Reserved_raw(this: *const Self) -> ULONG64 {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
0usize,
24u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_Reserved_raw(this: *mut Self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
0usize,
24u8,
val as u64,
)
}
}
#[inline]
pub fn NetLuidIndex(&self) -> ULONG64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 24u8) as u64) }
}
#[inline]
pub fn set_NetLuidIndex(&mut self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(24usize, 24u8, val as u64)
}
}
#[inline]
pub unsafe fn NetLuidIndex_raw(this: *const Self) -> ULONG64 {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
24usize,
24u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_NetLuidIndex_raw(this: *mut Self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
24usize,
24u8,
val as u64,
)
}
}
#[inline]
pub fn IfType(&self) -> ULONG64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u64) }
}
#[inline]
pub fn set_IfType(&mut self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(48usize, 16u8, val as u64)
}
}
#[inline]
pub unsafe fn IfType_raw(this: *const Self) -> ULONG64 {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
48usize,
16u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_IfType_raw(this: *mut Self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
48usize,
16u8,
val as u64,
)
}
}
#[inline]
pub fn new_bitfield_1(
Reserved: ULONG64,
NetLuidIndex: ULONG64,
IfType: ULONG64,
) -> __BindgenBitfieldUnit<[u8; 8usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 24u8, {
let Reserved: u64 = unsafe { ::std::mem::transmute(Reserved) };
Reserved as u64
});
__bindgen_bitfield_unit.set(24usize, 24u8, {
let NetLuidIndex: u64 = unsafe { ::std::mem::transmute(NetLuidIndex) };
NetLuidIndex as u64
});
__bindgen_bitfield_unit.set(48usize, 16u8, {
let IfType: u64 = unsafe { ::std::mem::transmute(IfType) };
IfType as u64
});
__bindgen_bitfield_unit
}
}
pub type NET_LUID_LH = _NET_LUID_LH;
pub type NET_LUID = NET_LUID_LH;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _WINTUN_ADAPTER {
_unused: [u8; 0],
}
#[doc = " A handle representing Wintun adapter"]
pub type WINTUN_ADAPTER_HANDLE = *mut _WINTUN_ADAPTER;
#[doc = "< Informational"]
pub const WINTUN_LOGGER_LEVEL_WINTUN_LOG_INFO: WINTUN_LOGGER_LEVEL = 0;
#[doc = "< Warning"]
pub const WINTUN_LOGGER_LEVEL_WINTUN_LOG_WARN: WINTUN_LOGGER_LEVEL = 1;
#[doc = "< Error"]
pub const WINTUN_LOGGER_LEVEL_WINTUN_LOG_ERR: WINTUN_LOGGER_LEVEL = 2;
#[doc = " Determines the level of logging, passed to WINTUN_LOGGER_CALLBACK."]
pub type WINTUN_LOGGER_LEVEL = ::std::os::raw::c_int;
#[doc = " Called by internal logger to report diagnostic messages\n\n @param Level Message level.\n\n @param Timestamp Message timestamp in in 100ns intervals since 1601-01-01 UTC.\n\n @param Message Message text."]
pub type WINTUN_LOGGER_CALLBACK = ::std::option::Option<
unsafe extern "C" fn(Level: WINTUN_LOGGER_LEVEL, Timestamp: DWORD64, Message: LPCWSTR),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _TUN_SESSION {
_unused: [u8; 0],
}
#[doc = " A handle representing Wintun session"]
pub type WINTUN_SESSION_HANDLE = *mut _TUN_SESSION;
pub struct wintun {
__library: ::libloading::Library,
pub WintunCreateAdapter: unsafe extern "C" fn(
arg1: LPCWSTR,
arg2: LPCWSTR,
arg3: *const GUID,
) -> WINTUN_ADAPTER_HANDLE,
pub WintunCloseAdapter: unsafe extern "C" fn(arg1: WINTUN_ADAPTER_HANDLE),
pub WintunOpenAdapter: unsafe extern "C" fn(arg1: LPCWSTR) -> WINTUN_ADAPTER_HANDLE,
pub WintunGetAdapterLUID:
unsafe extern "C" fn(arg1: WINTUN_ADAPTER_HANDLE, arg2: *mut NET_LUID),
pub WintunGetRunningDriverVersion: unsafe extern "C" fn() -> DWORD,
pub WintunDeleteDriver: unsafe extern "C" fn() -> BOOL,
pub WintunSetLogger: unsafe extern "C" fn(arg1: WINTUN_LOGGER_CALLBACK),
pub WintunStartSession:
unsafe extern "C" fn(arg1: WINTUN_ADAPTER_HANDLE, arg2: DWORD) -> WINTUN_SESSION_HANDLE,
pub WintunEndSession: unsafe extern "C" fn(arg1: WINTUN_SESSION_HANDLE),
pub WintunGetReadWaitEvent: unsafe extern "C" fn(arg1: WINTUN_SESSION_HANDLE) -> HANDLE,
pub WintunReceivePacket:
unsafe extern "C" fn(arg1: WINTUN_SESSION_HANDLE, arg2: *mut DWORD) -> *mut BYTE,
pub WintunReleaseReceivePacket:
unsafe extern "C" fn(arg1: WINTUN_SESSION_HANDLE, arg2: *const BYTE),
pub WintunAllocateSendPacket:
unsafe extern "C" fn(arg1: WINTUN_SESSION_HANDLE, arg2: DWORD) -> *mut BYTE,
pub WintunSendPacket: unsafe extern "C" fn(arg1: WINTUN_SESSION_HANDLE, arg2: *const BYTE),
}
impl wintun {
pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
where
P: AsRef<::std::ffi::OsStr>,
{
let library = ::libloading::Library::new(path)?;
Self::from_library(library)
}
pub unsafe fn from_library<L>(library: L) -> Result<Self, ::libloading::Error>
where
L: Into<::libloading::Library>,
{
let __library = library.into();
let WintunCreateAdapter = __library.get(b"WintunCreateAdapter\0").map(|sym| *sym)?;
let WintunCloseAdapter = __library.get(b"WintunCloseAdapter\0").map(|sym| *sym)?;
let WintunOpenAdapter = __library.get(b"WintunOpenAdapter\0").map(|sym| *sym)?;
let WintunGetAdapterLUID = __library.get(b"WintunGetAdapterLUID\0").map(|sym| *sym)?;
let WintunGetRunningDriverVersion = __library
.get(b"WintunGetRunningDriverVersion\0")
.map(|sym| *sym)?;
let WintunDeleteDriver = __library.get(b"WintunDeleteDriver\0").map(|sym| *sym)?;
let WintunSetLogger = __library.get(b"WintunSetLogger\0").map(|sym| *sym)?;
let WintunStartSession = __library.get(b"WintunStartSession\0").map(|sym| *sym)?;
let WintunEndSession = __library.get(b"WintunEndSession\0").map(|sym| *sym)?;
let WintunGetReadWaitEvent = __library.get(b"WintunGetReadWaitEvent\0").map(|sym| *sym)?;
let WintunReceivePacket = __library.get(b"WintunReceivePacket\0").map(|sym| *sym)?;
let WintunReleaseReceivePacket = __library
.get(b"WintunReleaseReceivePacket\0")
.map(|sym| *sym)?;
let WintunAllocateSendPacket = __library
.get(b"WintunAllocateSendPacket\0")
.map(|sym| *sym)?;
let WintunSendPacket = __library.get(b"WintunSendPacket\0").map(|sym| *sym)?;
Ok(wintun {
__library,
WintunCreateAdapter,
WintunCloseAdapter,
WintunOpenAdapter,
WintunGetAdapterLUID,
WintunGetRunningDriverVersion,
WintunDeleteDriver,
WintunSetLogger,
WintunStartSession,
WintunEndSession,
WintunGetReadWaitEvent,
WintunReceivePacket,
WintunReleaseReceivePacket,
WintunAllocateSendPacket,
WintunSendPacket,
})
}
pub unsafe fn WintunCreateAdapter(
&self,
arg1: LPCWSTR,
arg2: LPCWSTR,
arg3: *const GUID,
) -> WINTUN_ADAPTER_HANDLE {
(self.WintunCreateAdapter)(arg1, arg2, arg3)
}
pub unsafe fn WintunCloseAdapter(&self, arg1: WINTUN_ADAPTER_HANDLE) {
(self.WintunCloseAdapter)(arg1)
}
pub unsafe fn WintunOpenAdapter(&self, arg1: LPCWSTR) -> WINTUN_ADAPTER_HANDLE {
(self.WintunOpenAdapter)(arg1)
}
pub unsafe fn WintunGetAdapterLUID(&self, arg1: WINTUN_ADAPTER_HANDLE, arg2: *mut NET_LUID) {
(self.WintunGetAdapterLUID)(arg1, arg2)
}
pub unsafe fn WintunGetRunningDriverVersion(&self) -> DWORD {
(self.WintunGetRunningDriverVersion)()
}
pub unsafe fn WintunDeleteDriver(&self) -> BOOL {
(self.WintunDeleteDriver)()
}
pub unsafe fn WintunSetLogger(&self, arg1: WINTUN_LOGGER_CALLBACK) {
(self.WintunSetLogger)(arg1)
}
pub unsafe fn WintunStartSession(
&self,
arg1: WINTUN_ADAPTER_HANDLE,
arg2: DWORD,
) -> WINTUN_SESSION_HANDLE {
(self.WintunStartSession)(arg1, arg2)
}
pub unsafe fn WintunEndSession(&self, arg1: WINTUN_SESSION_HANDLE) {
(self.WintunEndSession)(arg1)
}
pub unsafe fn WintunGetReadWaitEvent(&self, arg1: WINTUN_SESSION_HANDLE) -> HANDLE {
(self.WintunGetReadWaitEvent)(arg1)
}
pub unsafe fn WintunReceivePacket(
&self,
arg1: WINTUN_SESSION_HANDLE,
arg2: *mut DWORD,
) -> *mut BYTE {
(self.WintunReceivePacket)(arg1, arg2)
}
pub unsafe fn WintunReleaseReceivePacket(
&self,
arg1: WINTUN_SESSION_HANDLE,
arg2: *const BYTE,
) {
(self.WintunReleaseReceivePacket)(arg1, arg2)
}
pub unsafe fn WintunAllocateSendPacket(
&self,
arg1: WINTUN_SESSION_HANDLE,
arg2: DWORD,
) -> *mut BYTE {
(self.WintunAllocateSendPacket)(arg1, arg2)
}
pub unsafe fn WintunSendPacket(&self, arg1: WINTUN_SESSION_HANDLE, arg2: *const BYTE) {
(self.WintunSendPacket)(arg1, arg2)
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/windows/tun/wintun_log.rs | src/platform/windows/tun/wintun_log.rs | #![allow(dead_code)]
use log::*;
use crate::platform::windows::tun::wintun_raw;
use widestring::U16CStr;
/// Sets the logger wintun will use when logging. Maps to the WintunSetLogger C function
pub fn set_logger(win_tun: &wintun_raw::wintun, f: wintun_raw::WINTUN_LOGGER_CALLBACK) {
unsafe { win_tun.WintunSetLogger(f) };
}
pub fn reset_logger(win_tun: &wintun_raw::wintun) {
set_logger(win_tun, None);
}
/// The logger that is active by default. Logs messages to the log crate
///
/// # Safety
/// `message` must be a valid pointer that points to an aligned null terminated UTF-16 string
#[cfg(target_pointer_width = "32")]
pub unsafe extern "stdcall" fn default_logger(
level: wintun_raw::WINTUN_LOGGER_LEVEL,
_timestamp: wintun_raw::DWORD64,
message: *const wintun_raw::WCHAR,
) {
default_logger_(level, message)
}
/// The logger that is active by default. Logs messages to the log crate
///
/// # Safety
/// `message` must be a valid pointer that points to an aligned null terminated UTF-16 string
#[cfg(target_pointer_width = "64")]
pub unsafe extern "C" fn default_logger(
level: wintun_raw::WINTUN_LOGGER_LEVEL,
_timestamp: wintun_raw::DWORD64,
message: *const wintun_raw::WCHAR,
) {
default_logger_(level, message)
}
fn default_logger_(level: wintun_raw::WINTUN_LOGGER_LEVEL, message: *const wintun_raw::WCHAR) {
//Cant wait for RFC 2585
#[allow(unused_unsafe)]
//Wintun will always give us a valid UTF16 null termineted string
let msg = unsafe { U16CStr::from_ptr_str(message) };
let utf8_msg = msg.to_string_lossy();
match level {
wintun_raw::WINTUN_LOGGER_LEVEL_WINTUN_LOG_INFO => info!("WinTun: {utf8_msg}"),
wintun_raw::WINTUN_LOGGER_LEVEL_WINTUN_LOG_WARN => warn!("WinTun: {utf8_msg}"),
wintun_raw::WINTUN_LOGGER_LEVEL_WINTUN_LOG_ERR => error!("WinTun: {utf8_msg}"),
_ => error!("WinTun: {utf8_msg} (with invalid log level {level})"),
}
}
pub(crate) fn set_default_logger_if_unset(win_tun: &wintun_raw::wintun) {
set_logger(win_tun, Some(default_logger));
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/windows/tap/overlapped.rs | src/platform/windows/tap/overlapped.rs | use crate::platform::windows::ffi;
use crate::platform::windows::tap::READ_BUFFER_SIZE;
use bytes::BytesMut;
use std::io;
use std::os::windows::io::{AsRawHandle, OwnedHandle};
use std::sync::Arc;
use windows_sys::Win32::System::Threading::{WaitForMultipleObjects, INFINITE};
use windows_sys::Win32::System::IO::OVERLAPPED;
pub(crate) struct ReadOverlapped {
read_buffer: BytesMut,
inner: OwnedOVERLAPPED,
}
impl ReadOverlapped {
pub fn new(file_handle: Arc<OwnedHandle>) -> io::Result<ReadOverlapped> {
let inner = OwnedOVERLAPPED::new(file_handle)?;
Ok(Self {
read_buffer: BytesMut::zeroed(READ_BUFFER_SIZE),
inner,
})
}
pub fn try_read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
let inner = &mut self.inner;
let result = if inner.no_pending_io {
inner.reset()?;
let result = ffi::try_read_file(
inner.file_handle.as_raw_handle(),
&mut inner.overlapped,
&mut self.read_buffer,
)
.map(|size| size as _);
if let Err(e) = &result {
if e.kind() == io::ErrorKind::WouldBlock {
inner.no_pending_io = false;
}
}
result
} else {
ffi::try_io_overlapped(inner.file_handle.as_raw_handle(), &inner.overlapped)
.map(|size| size as _)
};
match result {
Ok(len) => {
inner.no_pending_io = true;
let result = io::copy(&mut &self.read_buffer[..len], &mut buf);
match result {
Ok(n) => Ok(n as usize),
Err(e) => Err(e),
}
}
Err(e) => Err(e),
}
}
pub fn overlapped_event(&self) -> OverlappedEvent {
OverlappedEvent {
event: self.inner.event_handle.clone(),
}
}
}
pub(crate) struct WriteOverlapped {
read_buffer: BytesMut,
inner: OwnedOVERLAPPED,
}
impl WriteOverlapped {
pub fn new(file_handle: Arc<OwnedHandle>) -> io::Result<WriteOverlapped> {
let inner = OwnedOVERLAPPED::new(file_handle)?;
Ok(Self {
read_buffer: BytesMut::new(),
inner,
})
}
pub fn try_write(&mut self, buf: &[u8]) -> io::Result<usize> {
let inner = &mut self.inner;
loop {
return if inner.no_pending_io {
inner.reset()?;
self.read_buffer.clear();
self.read_buffer.extend_from_slice(buf);
let result = ffi::try_write_file(
inner.file_handle.as_raw_handle(),
&mut inner.overlapped,
&self.read_buffer,
)
.map(|size| size as _);
if let Err(e) = &result {
if e.kind() == io::ErrorKind::WouldBlock {
inner.no_pending_io = false;
// WouldBlock here means the async write was successfully submitted and is still in progress
return Ok(buf.len());
}
}
result
} else {
let result =
ffi::try_io_overlapped(inner.file_handle.as_raw_handle(), &inner.overlapped)
.map(|size| size as _);
if result.is_ok() {
inner.no_pending_io = true;
continue;
}
result
};
}
}
pub fn overlapped_event(&self) -> OverlappedEvent {
OverlappedEvent {
event: self.inner.event_handle.clone(),
}
}
}
pub(crate) struct OwnedOVERLAPPED {
file_handle: Arc<OwnedHandle>,
event_handle: Arc<OwnedHandle>,
overlapped: Box<OVERLAPPED>,
no_pending_io: bool,
}
impl Drop for OwnedOVERLAPPED {
fn drop(&mut self) {
if !self.no_pending_io {
_ = ffi::cancel_io_overlapped(self.file_handle.as_raw_handle(), self.as_overlapped());
}
}
}
impl OwnedOVERLAPPED {
pub fn new(file_handle: Arc<OwnedHandle>) -> io::Result<OwnedOVERLAPPED> {
let event_handle = Arc::new(ffi::create_event()?);
// Set the event to signaled when initializing OVERLAPPED,
// so that the first wait does not block unexpectedly
ffi::set_event(event_handle.as_raw_handle())?;
let mut overlapped = Box::new(ffi::io_overlapped());
overlapped.hEvent = event_handle.as_raw_handle();
Ok(Self {
file_handle,
event_handle,
overlapped,
no_pending_io: true,
})
}
pub fn as_overlapped(&self) -> &OVERLAPPED {
&self.overlapped
}
pub fn reset(&self) -> io::Result<()> {
ffi::reset_event(self.event_handle.as_raw_handle())
}
}
pub struct OverlappedEvent {
event: Arc<OwnedHandle>,
}
impl OverlappedEvent {
pub fn wait(&self) -> io::Result<()> {
ffi::wait_for_single_object(self.event.as_raw_handle(), INFINITE)
}
pub fn wait_interruptible(
&self,
interrupt_event: &OwnedHandle,
timeout: Option<std::time::Duration>,
) -> io::Result<()> {
let handles = [self.event.as_raw_handle(), interrupt_event.as_raw_handle()];
unsafe {
let wait_ret = WaitForMultipleObjects(
2,
handles.as_ptr(),
0,
timeout
.map(|t| t.as_millis().min(INFINITE as _) as _)
.unwrap_or(INFINITE),
);
match wait_ret {
windows_sys::Win32::Foundation::WAIT_OBJECT_0 => Ok(()),
windows_sys::Win32::Foundation::WAIT_TIMEOUT => {
Err(io::Error::from(io::ErrorKind::TimedOut))
}
_ => {
if wait_ret == windows_sys::Win32::Foundation::WAIT_OBJECT_0 + 1 {
Err(io::Error::new(
io::ErrorKind::Interrupted,
"trigger interrupt",
))
} else {
Err(io::Error::last_os_error())
}
}
}
}
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/windows/tap/iface.rs | src/platform/windows/tap/iface.rs | use crate::platform::windows::device::GUID_NETWORK_ADAPTER;
use crate::platform::windows::ffi;
use crate::platform::windows::ffi::decode_utf16;
use scopeguard::{guard, ScopeGuard};
use std::io;
use std::os::windows::io::{FromRawHandle, OwnedHandle};
use std::process::Command;
use windows_sys::Win32::Storage::FileSystem::FILE_FLAG_OVERLAPPED;
use windows_sys::Win32::System::Registry::{
HKEY_LOCAL_MACHINE, KEY_READ, KEY_SET_VALUE, KEY_WRITE,
};
use windows_sys::Win32::{
Devices::DeviceAndDriverInstallation::{
DICD_GENERATE_ID, DICS_FLAG_GLOBAL, DIF_INSTALLDEVICE, DIF_INSTALLINTERFACES,
DIF_REGISTERDEVICE, DIF_REGISTER_COINSTALLERS, DIF_REMOVE, DIGCF_PRESENT, DIREG_DRV,
SPDIT_COMPATDRIVER, SPDRP_HARDWAREID,
},
Foundation::{GENERIC_READ, GENERIC_WRITE, TRUE},
NetworkManagement::Ndis::NET_LUID_LH,
Storage::FileSystem::{
FILE_ATTRIBUTE_SYSTEM, FILE_SHARE_READ, FILE_SHARE_WRITE, OPEN_EXISTING,
},
System::Registry::{KEY_NOTIFY, KEY_QUERY_VALUE, REG_NOTIFY_CHANGE_NAME},
};
use winreg::RegKey;
#[repr(C, align(1))]
#[derive(c2rust_bitfields::BitfieldStruct)]
#[allow(non_snake_case)]
#[allow(non_camel_case_types)]
struct _NET_LUID_LH {
#[bitfield(name = "Reserved", ty = "u64", bits = "0..=23")]
#[bitfield(name = "NetLuidIndex", ty = "u64", bits = "24..=47")]
#[bitfield(name = "IfType", ty = "u64", bits = "48..=63")]
_Value: [u8; 8],
}
/// Create a new interface and returns its NET_LUID
pub fn create_interface(component_id: &str) -> io::Result<NET_LUID_LH> {
let devinfo = ffi::create_device_info_list(&GUID_NETWORK_ADAPTER)?;
let _guard = guard((), |_| {
let _ = ffi::destroy_device_info_list(devinfo);
});
let class_name = ffi::class_name_from_guid(&GUID_NETWORK_ADAPTER)?;
let mut devinfo_data = ffi::create_device_info(
devinfo,
&class_name,
&GUID_NETWORK_ADAPTER,
"",
DICD_GENERATE_ID,
)?;
ffi::set_selected_device(devinfo, &devinfo_data)?;
ffi::set_device_registry_property(devinfo, &devinfo_data, SPDRP_HARDWAREID, component_id)?;
ffi::build_driver_info_list(devinfo, &mut devinfo_data, SPDIT_COMPATDRIVER)?;
let _guard = guard((), |_| {
let _ = ffi::destroy_driver_info_list(devinfo, &devinfo_data, SPDIT_COMPATDRIVER);
});
let mut driver_version = 0;
let mut member_index = 0;
while let Some(drvinfo_data) =
ffi::enum_driver_info(devinfo, &devinfo_data, SPDIT_COMPATDRIVER, member_index)
{
member_index += 1;
if drvinfo_data.is_err() {
continue;
}
let drvinfo_data = drvinfo_data?;
if drvinfo_data.DriverVersion <= driver_version {
continue;
}
let drvinfo_detail =
match ffi::get_driver_info_detail(devinfo, &devinfo_data, &drvinfo_data) {
Ok(drvinfo_detail) => drvinfo_detail,
_ => continue,
};
let hardware_id = decode_utf16(&drvinfo_detail.HardwareID);
if !hardware_id.eq_ignore_ascii_case(component_id) {
continue;
}
if ffi::set_selected_driver(devinfo, &devinfo_data, &drvinfo_data).is_err() {
continue;
}
driver_version = drvinfo_data.DriverVersion;
}
if driver_version == 0 {
return Err(io::Error::new(io::ErrorKind::NotFound, "No driver found"));
}
let uninstaller = guard((), |_| {
let _ = ffi::call_class_installer(devinfo, &devinfo_data, DIF_REMOVE);
});
ffi::call_class_installer(devinfo, &devinfo_data, DIF_REGISTERDEVICE)?;
let _ = ffi::call_class_installer(devinfo, &devinfo_data, DIF_REGISTER_COINSTALLERS);
let _ = ffi::call_class_installer(devinfo, &devinfo_data, DIF_INSTALLINTERFACES);
ffi::call_class_installer(devinfo, &devinfo_data, DIF_INSTALLDEVICE)?;
let key = ffi::open_dev_reg_key(
devinfo,
&devinfo_data,
DICS_FLAG_GLOBAL,
0,
DIREG_DRV,
KEY_QUERY_VALUE | KEY_NOTIFY,
)?;
let key = winreg::RegKey::predef(key as _);
while key.get_value::<u32, &str>("*IfType").is_err() {
ffi::notify_change_key_value(key.raw_handle() as _, TRUE, REG_NOTIFY_CHANGE_NAME, 2000)?;
}
while key.get_value::<u32, &str>("NetLuidIndex").is_err() {
ffi::notify_change_key_value(key.raw_handle() as _, TRUE, REG_NOTIFY_CHANGE_NAME, 2000)?;
}
let if_type: u32 = key.get_value("*IfType")?;
let luid_index: u32 = key.get_value("NetLuidIndex")?;
// Defuse the uninstaller
ScopeGuard::into_inner(uninstaller);
let mut luid = NET_LUID_LH { Value: 0 };
unsafe {
let luid = &mut luid as *mut NET_LUID_LH as *mut _NET_LUID_LH;
(*luid).set_IfType(if_type as _);
(*luid).set_NetLuidIndex(luid_index as _);
}
Ok(luid)
}
/// Check if the given interface exists and is a valid network device
pub fn check_interface(component_id: &str, luid: &NET_LUID_LH) -> io::Result<()> {
let devinfo = ffi::get_class_devs(&GUID_NETWORK_ADAPTER, DIGCF_PRESENT)?;
let _guard = guard((), |_| {
let _ = ffi::destroy_device_info_list(devinfo);
});
let mut member_index = 0;
while let Some(devinfo_data) = ffi::enum_device_info(devinfo, member_index) {
member_index += 1;
if devinfo_data.is_err() {
continue;
}
let devinfo_data = devinfo_data?;
let hardware_id =
ffi::get_device_registry_property(devinfo, &devinfo_data, SPDRP_HARDWAREID);
if hardware_id.is_err() {
continue;
}
if !hardware_id?.eq_ignore_ascii_case(component_id) {
continue;
}
let key = match ffi::open_dev_reg_key(
devinfo,
&devinfo_data,
DICS_FLAG_GLOBAL,
0,
DIREG_DRV,
KEY_QUERY_VALUE | KEY_NOTIFY,
) {
Ok(key) => winreg::RegKey::predef(key as _),
Err(_) => continue,
};
let if_type: u32 = match key.get_value("*IfType") {
Ok(if_type) => if_type,
Err(_) => continue,
};
let luid_index: u32 = match key.get_value("NetLuidIndex") {
Ok(luid_index) => luid_index,
Err(_) => continue,
};
let mut luid2 = NET_LUID_LH { Value: 0 };
unsafe {
let luid2 = &mut luid2 as *mut NET_LUID_LH as *mut _NET_LUID_LH;
(*luid2).set_IfType(if_type as _);
(*luid2).set_NetLuidIndex(luid_index as _);
}
if unsafe { luid.Value != luid2.Value } {
continue;
}
// Found it!
return Ok(());
}
Err(io::Error::new(io::ErrorKind::NotFound, "Device not found"))
}
/// Deletes an existing interface
pub fn delete_interface(component_id: &str, luid: &NET_LUID_LH) -> io::Result<()> {
let devinfo = ffi::get_class_devs(&GUID_NETWORK_ADAPTER, DIGCF_PRESENT)?;
let _guard = guard((), |_| {
let _ = ffi::destroy_device_info_list(devinfo);
});
let mut member_index = 0;
while let Some(devinfo_data) = ffi::enum_device_info(devinfo, member_index) {
member_index += 1;
if devinfo_data.is_err() {
continue;
}
let devinfo_data = devinfo_data?;
let hardware_id =
ffi::get_device_registry_property(devinfo, &devinfo_data, SPDRP_HARDWAREID);
if hardware_id.is_err() {
continue;
}
if !hardware_id?.eq_ignore_ascii_case(component_id) {
continue;
}
let key = ffi::open_dev_reg_key(
devinfo,
&devinfo_data,
DICS_FLAG_GLOBAL,
0,
DIREG_DRV,
KEY_QUERY_VALUE | KEY_NOTIFY,
);
if key.is_err() {
continue;
}
let key = winreg::RegKey::predef(key? as _);
let if_type: u32 = match key.get_value("*IfType") {
Ok(if_type) => if_type,
Err(_) => continue,
};
let luid_index: u32 = match key.get_value("NetLuidIndex") {
Ok(luid_index) => luid_index,
Err(_) => continue,
};
let mut luid2 = NET_LUID_LH { Value: 0 };
unsafe {
let luid2 = &mut luid2 as *mut NET_LUID_LH as *mut _NET_LUID_LH;
(*luid2).set_IfType(if_type as _);
(*luid2).set_NetLuidIndex(luid_index as _);
}
if unsafe { luid.Value != luid2.Value } {
continue;
}
// Found it!
return ffi::call_class_installer(devinfo, &devinfo_data, DIF_REMOVE);
}
Err(io::Error::new(io::ErrorKind::NotFound, "Device not found"))
}
/// Open an handle to an interface
pub fn open_interface(luid: &NET_LUID_LH) -> io::Result<OwnedHandle> {
let guid = ffi::luid_to_guid(luid).and_then(|guid| ffi::string_from_guid(&guid))?;
let path = format!(r"\\.\Global\{guid}.tap");
let handle = ffi::create_file(
&path,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
OPEN_EXISTING,
FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED,
)?;
unsafe { Ok(OwnedHandle::from_raw_handle(handle)) }
}
pub fn set_adapter_mac_by_guid(adapter_guid: &str, new_mac: &str) -> io::Result<()> {
let class_path =
r"SYSTEM\CurrentControlSet\Control\Class\{4D36E972-E325-11CE-BFC1-08002BE10318}";
let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);
let class = hklm.open_subkey_with_flags(class_path, KEY_READ | KEY_WRITE)?;
let mut found = false;
for i in 0..256 {
let subkey_name = format!("{i:04}");
if let Ok(subkey) = class.open_subkey_with_flags(&subkey_name, KEY_READ | KEY_WRITE) {
let guid: String = subkey.get_value("NetCfgInstanceId").unwrap_or_default();
if guid.eq_ignore_ascii_case(adapter_guid) {
let subkey =
class.open_subkey_with_flags(&subkey_name, KEY_SET_VALUE | KEY_WRITE)?;
subkey.set_value("NetworkAddress", &new_mac)?;
found = true;
break;
}
}
}
if !found {
return Err(io::Error::new(
io::ErrorKind::NotFound,
"Registry entry not found for given adapter GUID",
));
}
Ok(())
}
pub fn enable_adapter(adapter_name: &str, val: bool) -> io::Result<()> {
let out = Command::new("wmic")
.args([
"path",
"win32_networkadapter",
"where",
&format!("NetConnectionID='{adapter_name}'",),
"call",
if val { "enable" } else { "disable" },
])
.output()?;
if out.status.success() {
Ok(())
} else {
Err(io::Error::other("Failed to enable adapter"))
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/windows/tap/mod.rs | src/platform/windows/tap/mod.rs | use crate::platform::windows::tap::overlapped::{ReadOverlapped, WriteOverlapped};
use crate::platform::windows::{ffi, netsh};
use std::os::windows::io::{AsRawHandle, OwnedHandle};
use std::sync::{Arc, Mutex};
use std::{io, time};
use windows_sys::Win32::Foundation::HANDLE;
use windows_sys::Win32::NetworkManagement::Ndis::NET_LUID_LH;
use windows_sys::Win32::System::Ioctl::{FILE_ANY_ACCESS, FILE_DEVICE_UNKNOWN, METHOD_BUFFERED};
mod iface;
mod overlapped;
pub struct TapDevice {
tap_interface: TapInterface,
handle: Arc<OwnedHandle>,
index: u32,
read_io_overlapped: Mutex<ReadOverlapped>,
write_io_overlapped: Mutex<WriteOverlapped>,
}
pub(crate) const READ_BUFFER_SIZE: usize = 14 + 65536;
unsafe impl Send for TapDevice {}
unsafe impl Sync for TapDevice {}
impl Drop for TapInterface {
fn drop(&mut self) {
if self.need_delete {
let _ = iface::delete_interface(&self.component_id, &self.luid);
}
}
}
struct TapInterface {
luid: NET_LUID_LH,
component_id: String,
need_delete: bool,
}
fn get_version(handle: HANDLE) -> io::Result<[u64; 3]> {
let in_version: [u64; 3] = [0; 3];
let mut out_version: [u64; 3] = [0; 3];
ffi::device_io_control(handle, TAP_IOCTL_GET_VERSION, &in_version, &mut out_version)
.map(|_| out_version)
}
impl TapDevice {
pub fn index(&self) -> u32 {
self.index
}
/// Creates a new tap-windows device
pub fn create(component_id: &str, persist: bool, mut mac: Option<&String>) -> io::Result<Self> {
let luid = iface::create_interface(component_id)?;
let mut tap_interface = TapInterface {
luid,
component_id: component_id.to_string(),
need_delete: true, // Initialization must be true
};
std::thread::sleep(time::Duration::from_millis(20));
// Even after retrieving the luid, we might need to wait
let start = time::Instant::now();
let handle = loop {
// If we surpassed 2 seconds just return
let now = time::Instant::now();
if now - start > time::Duration::from_secs(3) {
return Err(io::Error::new(
io::ErrorKind::TimedOut,
"Interface timed out",
));
}
match ffi::luid_to_guid(&luid) {
Err(_) => {
std::thread::sleep(time::Duration::from_millis(20));
continue;
}
Ok(guid) => {
if let Some(mac) = mac.take() {
let guid = ffi::string_from_guid(&guid)?;
let name = ffi::luid_to_alias(&luid)?;
iface::set_adapter_mac_by_guid(&guid, mac)?;
std::thread::sleep(time::Duration::from_millis(20));
iface::enable_adapter(&name, false)?;
std::thread::sleep(time::Duration::from_millis(20));
iface::enable_adapter(&name, true)?;
}
let handle = iface::open_interface(&luid)?;
if get_version(handle.as_raw_handle()).is_err() {
std::thread::sleep(time::Duration::from_millis(200));
continue;
}
break handle;
}
};
};
let index = match ffi::luid_to_index(&luid) {
Ok(index) => index,
Err(e) => Err(e)?,
};
let handle = Arc::new(handle);
let read_io_overlapped = ReadOverlapped::new(handle.clone())?;
let write_io_overlapped = WriteOverlapped::new(handle.clone())?;
// Set to desired value after successful creation
tap_interface.need_delete = !persist;
Ok(Self {
tap_interface,
handle,
index,
read_io_overlapped: Mutex::new(read_io_overlapped),
write_io_overlapped: Mutex::new(write_io_overlapped),
})
}
/// Opens an existing tap-windows device by name
pub fn open(
component_id: &str,
name: &str,
persist: bool,
mac: Option<&String>,
) -> io::Result<Self> {
let luid = ffi::alias_to_luid(name)?;
iface::check_interface(component_id, &luid)?;
if let Some(mac) = mac {
let guid = ffi::luid_to_guid(&luid)?;
let guid = ffi::string_from_guid(&guid)?;
iface::set_adapter_mac_by_guid(&guid, mac)?;
std::thread::sleep(time::Duration::from_millis(1));
iface::enable_adapter(name, false)?;
std::thread::sleep(time::Duration::from_millis(1));
iface::enable_adapter(name, true)?;
}
let handle = iface::open_interface(&luid)?;
let index = ffi::luid_to_index(&luid)?;
let tap_interface = TapInterface {
luid,
component_id: component_id.to_string(),
need_delete: !persist,
};
let handle = Arc::new(handle);
let read_io_overlapped = ReadOverlapped::new(handle.clone())?;
let write_io_overlapped = WriteOverlapped::new(handle.clone())?;
Ok(Self {
index,
tap_interface,
handle,
read_io_overlapped: Mutex::new(read_io_overlapped),
write_io_overlapped: Mutex::new(write_io_overlapped),
})
}
/// Sets the status of the interface to disconnected.
/// Equivalent to `.set_status(false)`
pub fn down(&self) -> io::Result<()> {
self.set_status(false)
}
/// Retieve the mac of the interface
pub fn get_mac(&self) -> io::Result<[u8; 6]> {
let mut mac = [0; 6];
ffi::device_io_control(
self.handle.as_raw_handle(),
TAP_IOCTL_GET_MAC,
&(),
&mut mac,
)
.map(|_| mac)
}
pub fn set_mac(&self, _mac: &[u8; 6]) -> io::Result<()> {
Err(io::Error::from(io::ErrorKind::Unsupported))?
}
/// Retrieve the version of the driver
pub fn get_version(&self) -> io::Result<[u64; 3]> {
get_version(self.handle.as_raw_handle())
}
// ///Retieve the mtu of the interface
// pub fn get_mtu(&self) -> io::Result<u32> {
// let in_mtu: u32 = 0;
// let mut out_mtu = 0;
// ffi::device_io_control(self.handle, TAP_IOCTL_GET_MTU, &in_mtu, &mut out_mtu)
// .map(|_| out_mtu)
// }
/// Retrieve the name of the interface
pub fn get_name(&self) -> io::Result<String> {
ffi::luid_to_alias(&self.tap_interface.luid)
}
/// Set the name of the interface
pub fn set_name(&self, newname: &str) -> io::Result<()> {
let name = self.get_name()?;
netsh::set_interface_name(&name, newname)
}
// /// Set the ip of the interface
// pub fn set_ip<A, B>(&self, address: A, mask: B) -> io::Result<()>
// where
// A: Into<net::Ipv4Addr>,
// B: Into<net::Ipv4Addr>,
// {
// let address = address.into().to_string();
// let mask = mask.into().to_string();
//
// netsh::set_interface_ip(self.index, address.into(), mask.into(), None)
// }
/// Set the status of the interface, true for connected,
/// false for disconnected.
pub fn set_status(&self, status: bool) -> io::Result<()> {
let status: u32 = if status { 1 } else { 0 };
let mut out_status: u32 = 0;
ffi::device_io_control(
self.handle.as_raw_handle(),
TAP_IOCTL_SET_MEDIA_STATUS,
&status,
&mut out_status,
)
}
#[cfg(any(
feature = "interruptible",
feature = "async_tokio",
feature = "async_io"
))]
pub fn wait_readable_interruptible(
&self,
interrupt_event: &OwnedHandle,
timeout: Option<std::time::Duration>,
) -> io::Result<()> {
let guard = self.read_io_overlapped.lock().unwrap();
let event = guard.overlapped_event();
drop(guard);
event.wait_interruptible(interrupt_event, timeout)
}
pub fn wait_readable(&self) -> io::Result<()> {
let guard = self.read_io_overlapped.lock().unwrap();
let event_handle = guard.overlapped_event();
drop(guard);
event_handle.wait()
}
pub fn try_read(&self, buf: &mut [u8]) -> io::Result<usize> {
let Ok(mut guard) = self.read_io_overlapped.try_lock() else {
return Err(io::Error::from(io::ErrorKind::WouldBlock));
};
guard.try_read(buf)
}
pub fn try_write(&self, buf: &[u8]) -> io::Result<usize> {
let Ok(mut guard) = self.write_io_overlapped.try_lock() else {
return Err(io::Error::from(io::ErrorKind::WouldBlock));
};
guard.try_write(buf)
}
pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
loop {
match self.try_read(buf) {
Ok(len) => return Ok(len),
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
Err(e) => return Err(e),
}
self.wait_readable()?
}
}
pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
loop {
match self.try_write(buf) {
Ok(len) => return Ok(len),
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
let guard = self.write_io_overlapped.lock().unwrap();
let event = guard.overlapped_event();
drop(guard);
event.wait()?
}
Err(e) => return Err(e),
}
}
}
#[allow(dead_code)]
pub(crate) fn write_interruptible(
&self,
buf: &[u8],
interrupt_event: &OwnedHandle,
) -> io::Result<usize> {
loop {
match self.try_write(buf) {
Ok(len) => return Ok(len),
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
let guard = self.write_io_overlapped.lock().unwrap();
let event = guard.overlapped_event();
drop(guard);
event.wait_interruptible(interrupt_event, None)?
}
Err(e) => return Err(e),
}
}
}
}
#[allow(non_snake_case)]
#[inline]
const fn CTL_CODE(DeviceType: u32, Function: u32, Method: u32, Access: u32) -> u32 {
(DeviceType << 16) | (Access << 14) | (Function << 2) | Method
}
const TAP_IOCTL_GET_MAC: u32 = CTL_CODE(FILE_DEVICE_UNKNOWN, 1, METHOD_BUFFERED, FILE_ANY_ACCESS);
const TAP_IOCTL_GET_VERSION: u32 =
CTL_CODE(FILE_DEVICE_UNKNOWN, 2, METHOD_BUFFERED, FILE_ANY_ACCESS);
// const TAP_IOCTL_GET_MTU: u32 = CTL_CODE(FILE_DEVICE_UNKNOWN, 3, METHOD_BUFFERED, FILE_ANY_ACCESS);
const TAP_IOCTL_SET_MEDIA_STATUS: u32 =
CTL_CODE(FILE_DEVICE_UNKNOWN, 6, METHOD_BUFFERED, FILE_ANY_ACCESS);
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/macos/device.rs | src/platform/macos/device.rs | use crate::{
builder::DeviceConfig,
platform::{macos::sys::*, unix::sockaddr_union},
ToIpv4Address, ToIpv4Netmask, ToIpv6Address, ToIpv6Netmask,
};
//const OVERWRITE_SIZE: usize = std::mem::size_of::<libc::__c_anonymous_ifr_ifru>();
use crate::platform::macos::tuntap::TunTap;
use crate::platform::unix::device::{ctl, ctl_v6};
use crate::platform::unix::Tun;
use crate::platform::ETHER_ADDR_LEN;
use libc::{self, c_char, c_short, IFF_RUNNING, IFF_UP};
use std::io::ErrorKind;
use std::net::Ipv4Addr;
use std::{io, mem, net::IpAddr, os::unix::io::AsRawFd, ptr, sync::Mutex};
/// A TUN device using the TUN macOS driver.
pub struct DeviceImpl {
pub(crate) tun: TunTap,
pub(crate) op_lock: Mutex<bool>,
}
impl DeviceImpl {
/// Create a new `Device` for the given `Configuration`.
pub(crate) fn new(config: DeviceConfig) -> io::Result<Self> {
let associate_route = config.associate_route;
let tun_tap = TunTap::new(config)?;
let associate_route = if tun_tap.is_tun() {
associate_route.unwrap_or(true)
} else {
false
};
let device_impl = DeviceImpl {
tun: tun_tap,
op_lock: Mutex::new(associate_route),
};
Ok(device_impl)
}
pub(crate) fn from_tun(tun: Tun) -> io::Result<Self> {
Ok(Self {
tun: TunTap::Tun(tun),
op_lock: Mutex::new(true),
})
}
/// Prepare a new request.
fn request(&self) -> io::Result<libc::ifreq> {
self.tun.request()
}
fn request_v6(&self) -> io::Result<in6_ifreq> {
self.tun.request_v6()
}
pub(crate) fn calc_dest_addr(&self, addr: IpAddr, netmask: IpAddr) -> io::Result<IpAddr> {
let prefix_len = ipnet::ip_mask_to_prefix(netmask)
.map_err(|e| io::Error::new(ErrorKind::InvalidInput, e))?;
Ok(ipnet::IpNet::new(addr, prefix_len)
.map_err(|e| io::Error::new(ErrorKind::InvalidInput, e))?
.broadcast())
}
/// Set the IPv4 alias of the device.
fn add_address(
&self,
addr: Ipv4Addr,
dest: Ipv4Addr,
mask: Ipv4Addr,
associate_route: bool,
) -> io::Result<()> {
let tun_name = self.name_impl()?;
unsafe {
let mut req: ifaliasreq = mem::zeroed();
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifra_name.as_mut_ptr(),
tun_name.len(),
);
req.ifra_addr = sockaddr_union::from((addr, 0)).addr;
req.ifra_broadaddr = sockaddr_union::from((dest, 0)).addr;
req.ifra_mask = sockaddr_union::from((mask, 0)).addr;
if let Err(err) = siocaifaddr(ctl()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
if let Err(e) = self.add_route(addr.into(), mask.into(), associate_route) {
log::warn!("{e:?}");
}
Ok(())
}
}
fn remove_route(&self, addr: IpAddr, netmask: IpAddr, associate_route: bool) -> io::Result<()> {
if !associate_route {
return Ok(());
}
let if_index = self.if_index_impl()?;
let mut manager = route_manager::RouteManager::new()?;
let net = ipnet::IpNet::with_netmask(addr, netmask)
.map_err(|e| io::Error::new(ErrorKind::InvalidInput, e))?;
let prefix_len = net.prefix_len();
let route = route_manager::Route::new(net.network(), prefix_len)
.with_gateway(addr)
.with_if_index(if_index);
manager.delete(&route)?;
Ok(())
}
fn add_route(&self, addr: IpAddr, netmask: IpAddr, associate_route: bool) -> io::Result<()> {
if !associate_route {
return Ok(());
}
let if_index = self.if_index_impl()?;
let mut manager = route_manager::RouteManager::new()?;
let net = ipnet::IpNet::with_netmask(addr, netmask)
.map_err(|e| io::Error::new(ErrorKind::InvalidInput, e))?;
let prefix_len = net.prefix_len();
let route = route_manager::Route::new(net.network(), prefix_len)
.with_gateway(addr)
.with_if_index(if_index);
manager.add(&route)?;
Ok(())
}
fn remove_all_address_v4(&self, associate_route: bool) -> io::Result<()> {
let mut req_v4 = self.request()?;
if let Ok(addrs) = crate::platform::get_if_addrs_by_name(self.name_impl()?) {
for v in addrs {
let addr = v.address;
let Some(netmask) = v.netmask else {
continue;
};
if addr.is_ipv6() || netmask.is_ipv6() {
continue;
}
unsafe {
req_v4.ifr_ifru.ifru_addr = sockaddr_union::from((addr, 0)).addr;
if let Err(err) = siocdifaddr(ctl()?.as_raw_fd(), &req_v4) {
return Err(io::Error::from(err));
}
}
if let Err(e) = self.remove_route(addr, netmask, associate_route) {
log::warn!("remove_route {addr}-{netmask},{e}")
}
}
}
Ok(())
}
/// Sets the IPv4 network address, netmask, and an optional destination address.
/// Remove all previous set IPv4 addresses and set the specified address.
fn set_network_address_impl<IPv4: ToIpv4Address, Netmask: ToIpv4Netmask>(
&self,
address: IPv4,
netmask: Netmask,
destination: Option<IPv4>,
associate_route: bool,
) -> io::Result<()> {
let netmask = netmask.netmask()?;
let address = address.ipv4()?;
let default_dest = self.calc_dest_addr(address.into(), netmask.into())?;
let IpAddr::V4(default_dest) = default_dest else {
return Err(io::Error::new(
ErrorKind::InvalidInput,
"invalid destination for address/netmask",
));
};
let dest = destination
.map(|v| v.ipv4())
.transpose()?
.unwrap_or(default_dest);
self.remove_all_address_v4(associate_route)?;
self.add_address(address, dest, netmask, associate_route)?;
Ok(())
}
pub(crate) fn name_impl(&self) -> io::Result<String> {
self.tun.name()
}
}
// Public User Interface
impl DeviceImpl {
/// Retrieves the name of the network interface.
pub fn name(&self) -> io::Result<String> {
let _guard = self.op_lock.lock().unwrap();
self.name_impl()
}
/// System behavior:
/// On macOS, adding an IP to a feth interface will automatically add a route,
/// while adding an IP to an utun interface will not.
///
/// If false, the program will not modify or manage routes in any way, allowing the system to handle all routing natively.
/// If true (default), the program will automatically add or remove routes to provide consistent routing behavior across all platforms.
/// Set this to be false to obtain the platform's default routing behavior.
pub fn set_associate_route(&self, associate_route: bool) {
if self.tun.is_tun() {
*self.op_lock.lock().unwrap() = associate_route;
}
}
/// Retrieve whether route is associated with the IP setting interface, see [`DeviceImpl::set_associate_route`]
pub fn associate_route(&self) -> bool {
*self.op_lock.lock().unwrap()
}
/// Enables or disables the network interface.
///
/// If `value` is true, the interface is enabled by setting the IFF_UP and IFF_RUNNING flags.
/// If false, the IFF_UP flag is cleared. The change is applied using a system call.
pub fn enabled(&self, value: bool) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let ctl = ctl()?;
let mut req = self.request()?;
if let Err(err) = siocgifflags(ctl.as_raw_fd(), &mut req) {
return Err(io::Error::from(err));
}
if value {
req.ifr_ifru.ifru_flags |= (IFF_UP | IFF_RUNNING) as c_short;
} else {
req.ifr_ifru.ifru_flags &= !(IFF_UP as c_short);
}
if let Err(err) = siocsifflags(ctl.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
/// Retrieves the current MTU (Maximum Transmission Unit) for the interface.
pub fn mtu(&self) -> io::Result<u16> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let ctl = ctl()?;
let mut req = self.request()?;
if let Err(err) = siocgifmtu(ctl.as_raw_fd(), &mut req) {
return Err(io::Error::from(err));
}
let r: u16 = req.ifr_ifru.ifru_mtu.try_into().map_err(io::Error::other)?;
Ok(r)
}
}
/// Sets the MTU (Maximum Transmission Unit) for the interface.
pub fn set_mtu(&self, value: u16) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
self.tun.set_mtu(value)
}
/// Sets the IPv4 network address, netmask, and an optional destination address.
/// Remove all previous set IPv4 addresses and set the specified address.
pub fn set_network_address<IPv4: ToIpv4Address, Netmask: ToIpv4Netmask>(
&self,
address: IPv4,
netmask: Netmask,
destination: Option<IPv4>,
) -> io::Result<()> {
let guard = self.op_lock.lock().unwrap();
self.set_network_address_impl(address, netmask, destination, *guard)
}
/// Add IPv4 network address, netmask
pub fn add_address_v4<IPv4: ToIpv4Address, Netmask: ToIpv4Netmask>(
&self,
address: IPv4,
netmask: Netmask,
) -> io::Result<()> {
let associate_route = self.op_lock.lock().unwrap();
let netmask = netmask.netmask()?;
let address = address.ipv4()?;
let default_dest = self.calc_dest_addr(address.into(), netmask.into())?;
let IpAddr::V4(default_dest) = default_dest else {
return Err(io::Error::new(
ErrorKind::InvalidInput,
"invalid destination for address/netmask",
));
};
self.add_address(address, default_dest, netmask, *associate_route)?;
Ok(())
}
/// Remove an IP address from the interface.
pub fn remove_address(&self, addr: IpAddr) -> io::Result<()> {
let guard = self.op_lock.lock().unwrap();
let is_associate_route = *guard;
unsafe {
match addr {
IpAddr::V4(addr_v4) => {
let mut req_v4 = self.request()?;
req_v4.ifr_ifru.ifru_addr = sockaddr_union::from((addr_v4, 0)).addr;
if let Err(err) = siocdifaddr(ctl()?.as_raw_fd(), &req_v4) {
return Err(io::Error::from(err));
}
if let Ok(addrs) = crate::platform::get_if_addrs_by_name(self.name_impl()?) {
for v in addrs.iter().filter(|v| v.address == addr) {
let Some(netmask) = v.netmask else {
continue;
};
if let Err(e) = self.remove_route(addr, netmask, is_associate_route) {
log::warn!("remove_route {addr}-{netmask},{e}")
}
}
}
}
IpAddr::V6(addr) => {
let mut req_v6 = self.request_v6()?;
req_v6.ifr_ifru.ifru_addr = sockaddr_union::from((addr, 0)).addr6;
if let Err(err) = siocdifaddr_in6(ctl_v6()?.as_raw_fd(), &req_v6) {
return Err(io::Error::from(err));
}
}
}
Ok(())
}
}
/// Add an IPv6 address to the interface.
pub fn add_address_v6<IPv6: ToIpv6Address, Netmask: ToIpv6Netmask>(
&self,
addr: IPv6,
netmask: Netmask,
) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
let addr = addr.ipv6()?;
unsafe {
let tun_name = self.name_impl()?;
let mut req: in6_ifaliasreq = mem::zeroed();
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifra_name.as_mut_ptr(),
tun_name.len(),
);
req.ifra_addr = sockaddr_union::from((addr, 0)).addr6;
let network_addr = ipnet::IpNet::new(addr.into(), netmask.prefix()?)
.map_err(|e| io::Error::new(ErrorKind::InvalidInput, e))?;
let mask = network_addr.netmask();
req.ifra_prefixmask = sockaddr_union::from((mask, 0)).addr6;
req.in6_addrlifetime.ia6t_vltime = 0xffffffff_u32;
req.in6_addrlifetime.ia6t_pltime = 0xffffffff_u32;
req.ifra_flags = IN6_IFF_NODAD;
if let Err(err) = siocaifaddr_in6(ctl_v6()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
}
Ok(())
}
/// Set MAC address on L2 layer
pub fn set_mac_address(&self, eth_addr: [u8; ETHER_ADDR_LEN as usize]) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
self.tun.set_mac_address(eth_addr)
}
/// Retrieve MAC address for the device
pub fn mac_address(&self) -> io::Result<[u8; ETHER_ADDR_LEN as usize]> {
let _guard = self.op_lock.lock().unwrap();
self.tun.mac_address()
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/macos/tuntap.rs | src/platform/macos/tuntap.rs | use crate::builder::DeviceConfig;
use crate::platform::macos::sys::{
ctl_info, ctliocginfo, in6_ifreq, siocgiflladdr, siocsiflladdr, siocsifmtu, IN6_IFF_NODAD,
UTUN_CONTROL_NAME,
};
use crate::platform::macos::tap::Tap;
use crate::platform::unix::device::ctl;
use crate::platform::unix::Tun;
use crate::platform::ETHER_ADDR_LEN;
use crate::Layer;
use libc::{
c_char, c_uint, sockaddr, socklen_t, AF_SYSTEM, AF_SYS_CONTROL, IFNAMSIZ, PF_SYSTEM,
SOCK_DGRAM, SYSPROTO_CONTROL, UTUN_OPT_IFNAME,
};
use std::ffi::{c_void, CStr};
use std::io::{ErrorKind, IoSlice, IoSliceMut};
use std::os::fd::{AsRawFd, IntoRawFd, RawFd};
use std::{io, mem, ptr};
pub enum TunTap {
Tun(Tun),
Tap(Tap),
}
impl TunTap {
pub fn new(config: DeviceConfig) -> io::Result<Self> {
let layer = config.layer.unwrap_or(Layer::L3);
let packet_information = config.packet_information.unwrap_or(false);
match layer {
Layer::L2 => Ok(TunTap::Tap(Tap::new(&config)?)),
Layer::L3 => {
let id = config
.dev_name
.as_ref()
.map(|tun_name| {
if tun_name.len() > IFNAMSIZ {
return Err(io::Error::new(
ErrorKind::InvalidInput,
"device name too long",
));
}
if !tun_name.starts_with("utun") {
return Err(io::Error::new(
ErrorKind::InvalidInput,
"device name must start with utun",
));
}
tun_name[4..]
.parse::<u32>()
.map(|v| v + 1)
.map_err(|e| io::Error::new(ErrorKind::InvalidInput, e))
})
.transpose()?
.unwrap_or(0);
unsafe {
let fd = libc::socket(PF_SYSTEM, SOCK_DGRAM, SYSPROTO_CONTROL);
let tun = crate::platform::unix::Fd::new(fd)?;
_ = tun.set_cloexec();
let mut info = ctl_info {
ctl_id: 0,
ctl_name: {
let mut buffer = [0; 96];
for (i, o) in UTUN_CONTROL_NAME.as_bytes().iter().zip(buffer.iter_mut())
{
*o = *i as _;
}
buffer
},
};
if let Err(err) = ctliocginfo(tun.inner, &mut info as *mut _ as *mut _) {
return Err(io::Error::from(err));
}
let addr = libc::sockaddr_ctl {
sc_id: info.ctl_id,
sc_len: mem::size_of::<libc::sockaddr_ctl>() as _,
sc_family: AF_SYSTEM as _,
ss_sysaddr: AF_SYS_CONTROL as _,
sc_unit: id as c_uint,
sc_reserved: [0; 5],
};
let address = &addr as *const libc::sockaddr_ctl as *const sockaddr;
if libc::connect(tun.inner, address, mem::size_of_val(&addr) as socklen_t) < 0 {
return Err(io::Error::last_os_error());
}
let mut tun_name = [0u8; 64];
let mut name_len: socklen_t = 64;
let optval = &mut tun_name as *mut _ as *mut c_void;
let optlen = &mut name_len as *mut socklen_t;
if libc::getsockopt(
tun.inner,
SYSPROTO_CONTROL,
UTUN_OPT_IFNAME,
optval,
optlen,
) < 0
{
return Err(io::Error::last_os_error());
}
let tun = Tun::new(tun);
tun.set_ignore_packet_info(!packet_information);
Ok(TunTap::Tun(tun))
}
}
}
}
pub fn name(&self) -> io::Result<String> {
match &self {
TunTap::Tun(tun) => {
let mut tun_name = [0u8; 64];
let mut name_len: socklen_t = 64;
let optval = &mut tun_name as *mut _ as *mut c_void;
let optlen = &mut name_len as *mut socklen_t;
unsafe {
if libc::getsockopt(
tun.as_raw_fd(),
SYSPROTO_CONTROL,
UTUN_OPT_IFNAME,
optval,
optlen,
) < 0
{
return Err(io::Error::last_os_error());
}
Ok(CStr::from_ptr(tun_name.as_ptr() as *const c_char)
.to_string_lossy()
.into())
}
}
TunTap::Tap(tap) => Ok(tap.name().to_string()),
}
}
pub(crate) fn is_tun(&self) -> bool {
match &self {
TunTap::Tun(_) => true,
TunTap::Tap(_) => false,
}
}
pub fn is_nonblocking(&self) -> io::Result<bool> {
match &self {
TunTap::Tun(tun) => tun.is_nonblocking(),
TunTap::Tap(tap) => tap.is_nonblocking(),
}
}
pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
match &self {
TunTap::Tun(tun) => tun.set_nonblocking(nonblocking),
TunTap::Tap(tap) => tap.set_nonblocking(nonblocking),
}
}
pub fn send(&self, buf: &[u8]) -> io::Result<usize> {
match &self {
TunTap::Tun(tun) => tun.send(buf),
TunTap::Tap(tap) => tap.send(buf),
}
}
pub fn send_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
match &self {
TunTap::Tun(tun) => tun.send_vectored(bufs),
TunTap::Tap(tap) => tap.send_vectored(bufs),
}
}
pub fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
match &self {
TunTap::Tun(tun) => tun.recv(buf),
TunTap::Tap(tap) => tap.recv(buf),
}
}
pub fn recv_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
match &self {
TunTap::Tun(tun) => tun.recv_vectored(bufs),
TunTap::Tap(tap) => tap.recv_vectored(bufs),
}
}
#[cfg(feature = "interruptible")]
#[inline]
pub(crate) fn read_interruptible(
&self,
buf: &mut [u8],
event: &crate::InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<usize> {
match &self {
TunTap::Tun(tun) => tun.read_interruptible(buf, event, timeout),
TunTap::Tap(tap) => tap.read_interruptible(buf, event, timeout),
}
}
#[cfg(feature = "interruptible")]
#[inline]
pub(crate) fn readv_interruptible(
&self,
bufs: &mut [IoSliceMut<'_>],
event: &crate::InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<usize> {
match &self {
TunTap::Tun(tun) => tun.readv_interruptible(bufs, event, timeout),
TunTap::Tap(tap) => tap.readv_interruptible(bufs, event, timeout),
}
}
#[cfg(feature = "interruptible")]
#[inline]
pub(crate) fn wait_readable_interruptible(
&self,
event: &crate::InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<()> {
match &self {
TunTap::Tun(tun) => tun.wait_readable_interruptible(event, timeout),
TunTap::Tap(tap) => tap.wait_readable_interruptible(event, timeout),
}
}
#[cfg(feature = "interruptible")]
#[inline]
pub(crate) fn write_interruptible(
&self,
buf: &[u8],
event: &crate::InterruptEvent,
) -> io::Result<usize> {
match &self {
TunTap::Tun(tun) => tun.write_interruptible(buf, event),
TunTap::Tap(tap) => tap.write_interruptible(buf, event),
}
}
#[cfg(feature = "interruptible")]
#[inline]
pub(crate) fn writev_interruptible(
&self,
bufs: &[IoSlice<'_>],
event: &crate::InterruptEvent,
) -> io::Result<usize> {
match &self {
TunTap::Tun(tun) => tun.writev_interruptible(bufs, event),
TunTap::Tap(tap) => tap.writev_interruptible(bufs, event),
}
}
#[cfg(feature = "interruptible")]
#[inline]
pub(crate) fn wait_writable_interruptible(
&self,
event: &crate::InterruptEvent,
) -> io::Result<()> {
match &self {
TunTap::Tun(tun) => tun.wait_writable_interruptible(event),
TunTap::Tap(tap) => tap.wait_writable_interruptible(event),
}
}
pub fn request(&self) -> io::Result<libc::ifreq> {
let tun_name = self.name()?;
unsafe {
let mut req: libc::ifreq = mem::zeroed();
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifr_name.as_mut_ptr(),
tun_name.len(),
);
Ok(req)
}
}
pub fn request_peer(&self) -> Option<libc::ifreq> {
let name = match &self {
TunTap::Tun(_) => {
return None;
}
TunTap::Tap(tap) => tap.peer_name(),
};
unsafe {
let mut req: libc::ifreq = mem::zeroed();
ptr::copy_nonoverlapping(
name.as_ptr() as *const c_char,
req.ifr_name.as_mut_ptr(),
name.len(),
);
Some(req)
}
}
pub fn request_v6(&self) -> io::Result<in6_ifreq> {
let tun_name = self.name()?;
unsafe {
let mut req: in6_ifreq = mem::zeroed();
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifra_name.as_mut_ptr(),
tun_name.len(),
);
req.ifr_ifru.ifru_flags = IN6_IFF_NODAD as _;
Ok(req)
}
}
pub fn set_mac_address(&self, eth_addr: [u8; ETHER_ADDR_LEN as usize]) -> io::Result<()> {
match &self {
TunTap::Tun(_) => Err(io::Error::from(io::ErrorKind::Unsupported)),
TunTap::Tap(_) => {
let mut ifr = self.request()?;
unsafe {
ifr.ifr_ifru.ifru_addr.sa_family = libc::AF_LINK as _;
ifr.ifr_ifru.ifru_addr.sa_len = ETHER_ADDR_LEN;
for (i, v) in eth_addr.iter().enumerate() {
ifr.ifr_ifru.ifru_addr.sa_data[i] = *v as _;
}
siocsiflladdr(ctl()?.inner, &ifr)?;
}
Ok(())
}
}
}
pub fn mac_address(&self) -> io::Result<[u8; ETHER_ADDR_LEN as usize]> {
match &self {
TunTap::Tun(_) => Err(io::Error::from(io::ErrorKind::Unsupported)),
TunTap::Tap(_) => {
let mut ifr = self.request()?;
unsafe {
ifr.ifr_ifru.ifru_addr.sa_family = libc::AF_LINK as _;
ifr.ifr_ifru.ifru_addr.sa_len = ETHER_ADDR_LEN;
siocgiflladdr(ctl()?.inner, &mut ifr)?;
let mut eth_addr = [0; ETHER_ADDR_LEN as usize];
for (i, v) in eth_addr.iter_mut().enumerate() {
*v = ifr.ifr_ifru.ifru_addr.sa_data[i] as _;
}
Ok(eth_addr)
}
}
}
}
#[inline]
pub(crate) fn ignore_packet_info(&self) -> bool {
match &self {
TunTap::Tun(tun) => tun.ignore_packet_info(),
TunTap::Tap(_) => false,
}
}
pub(crate) fn set_ignore_packet_info(&self, ign: bool) {
match &self {
TunTap::Tun(tun) => tun.set_ignore_packet_info(ign),
TunTap::Tap(_) => {}
}
}
pub fn set_mtu(&self, value: u16) -> io::Result<()> {
unsafe {
let ctl = ctl()?;
let mut req = self.request()?;
req.ifr_ifru.ifru_mtu = value as i32;
if let Err(err) = siocsifmtu(ctl.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
// peer feth
if let Some(mut req) = self.request_peer() {
req.ifr_ifru.ifru_mtu = value as i32;
if let Err(err) = siocsifmtu(ctl.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
}
Ok(())
}
}
}
impl AsRawFd for TunTap {
fn as_raw_fd(&self) -> RawFd {
match &self {
TunTap::Tun(tun) => tun.as_raw_fd(),
TunTap::Tap(tap) => tap.as_raw_fd(),
}
}
}
impl IntoRawFd for TunTap {
fn into_raw_fd(self) -> RawFd {
match self {
TunTap::Tun(tun) => tun.into_raw_fd(),
TunTap::Tap(tap) => tap.into_raw_fd(),
}
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/macos/mod.rs | src/platform/macos/mod.rs | mod sys;
mod device;
mod tap;
mod tuntap;
pub use self::device::DeviceImpl;
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/macos/sys.rs | src/platform/macos/sys.rs | use std::{ffi::c_void, os::raw::c_int};
use libc::{c_char, c_short, c_uint, ifreq, sockaddr, sockaddr_in6, time_t, IFNAMSIZ};
use nix::{ioctl_readwrite, ioctl_write_ptr};
pub const UTUN_CONTROL_NAME: &str = "com.apple.net.utun_control";
pub const IN6_IFF_NODAD: i32 = 0x0020;
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ctl_info {
pub ctl_id: c_uint,
pub ctl_name: [c_char; 96],
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ifaliasreq {
pub ifra_name: [c_char; IFNAMSIZ],
pub ifra_addr: sockaddr,
pub ifra_broadaddr: sockaddr,
pub ifra_mask: sockaddr,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct in6_ifaliasreq {
pub ifra_name: [c_char; IFNAMSIZ],
pub ifra_addr: sockaddr_in6,
pub ifra_dstaddr: sockaddr_in6,
pub ifra_prefixmask: sockaddr_in6,
pub ifra_flags: libc::c_int,
pub in6_addrlifetime: in6_addrlifetime,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct in6_addrlifetime {
pub ia6t_expire: time_t, /* valid lifetime expiration time */
pub ia6t_preferred: time_t, /* preferred lifetime expiration time */
pub ia6t_vltime: u32, /* valid lifetime */
pub ia6t_pltime: u32, /* prefix lifetime */
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct in6_ifreq {
pub ifra_name: [c_char; IFNAMSIZ],
pub ifr_ifru: ifr_ifru_in6,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub union ifr_ifru_in6 {
pub ifru_addr: sockaddr_in6,
pub ifru_dstaddr: sockaddr_in6,
pub ifru_flags: c_short,
pub ifru_flags6: c_int,
pub ifru_metric: c_int,
pub ifru_data: *const c_void,
pub ifru_lifetime: in6_addrlifetime,
pub ifru_stat: in6_ifstat,
pub ifru_icmp6stat: icmp6_ifstat,
}
#[allow(non_camel_case_types)]
type u_quad_t = u64;
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct in6_ifstat {
pub ifs6_in_receive: u_quad_t, /* # of total input datagram */
pub ifs6_in_hdrerr: u_quad_t, /* # of datagrams with invalid hdr */
pub ifs6_in_toobig: u_quad_t, /* # of datagrams exceeded MTU */
pub ifs6_in_noroute: u_quad_t, /* # of datagrams with no route */
pub ifs6_in_addrerr: u_quad_t, /* # of datagrams with invalid dst */
pub ifs6_in_protounknown: u_quad_t, /* # of datagrams with unknown proto */
/* NOTE: increment on final dst if */
pub ifs6_in_truncated: u_quad_t, /* # of truncated datagrams */
pub ifs6_in_discard: u_quad_t, /* # of discarded datagrams */
/* NOTE: fragment timeout is not here */
pub ifs6_in_deliver: u_quad_t, /* # of datagrams delivered to ULP */
/* NOTE: increment on final dst if */
pub ifs6_out_forward: u_quad_t, /* # of datagrams forwarded */
/* NOTE: increment on outgoing if */
pub ifs6_out_request: u_quad_t, /* # of outgoing datagrams from ULP */
/* NOTE: does not include forwrads */
pub ifs6_out_discard: u_quad_t, /* # of discarded datagrams */
pub ifs6_out_fragok: u_quad_t, /* # of datagrams fragmented */
pub ifs6_out_fragfail: u_quad_t, /* # of datagrams failed on fragment */
pub ifs6_out_fragcreat: u_quad_t, /* # of fragment datagrams */
/* NOTE: this is # after fragment */
pub ifs6_reass_reqd: u_quad_t, /* # of incoming fragmented packets */
/* NOTE: increment on final dst if */
pub ifs6_reass_ok: u_quad_t, /* # of reassembled packets */
/* NOTE: this is # after reass */
/* NOTE: increment on final dst if */
pub ifs6_reass_fail: u_quad_t, /* # of reass failures */
/* NOTE: may not be packet count */
/* NOTE: increment on final dst if */
pub ifs6_in_mcast: u_quad_t, /* # of inbound multicast datagrams */
pub ifs6_out_mcast: u_quad_t, /* # of outbound multicast datagrams */
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct icmp6_ifstat {
/*
* Input statistics
*/
/* ipv6IfIcmpInMsgs, total # of input messages */
pub ifs6_in_msg: u_quad_t,
/* ipv6IfIcmpInErrors, # of input error messages */
pub ifs6_in_error: u_quad_t,
/* ipv6IfIcmpInDestUnreachs, # of input dest unreach errors */
pub ifs6_in_dstunreach: u_quad_t,
/* ipv6IfIcmpInAdminProhibs, # of input administratively prohibited errs */
pub ifs6_in_adminprohib: u_quad_t,
/* ipv6IfIcmpInTimeExcds, # of input time exceeded errors */
pub ifs6_in_timeexceed: u_quad_t,
/* ipv6IfIcmpInParmProblems, # of input parameter problem errors */
pub ifs6_in_paramprob: u_quad_t,
/* ipv6IfIcmpInPktTooBigs, # of input packet too big errors */
pub ifs6_in_pkttoobig: u_quad_t,
/* ipv6IfIcmpInEchos, # of input echo requests */
pub ifs6_in_echo: u_quad_t,
/* ipv6IfIcmpInEchoReplies, # of input echo replies */
pub ifs6_in_echoreply: u_quad_t,
/* ipv6IfIcmpInRouterSolicits, # of input router solicitations */
pub ifs6_in_routersolicit: u_quad_t,
/* ipv6IfIcmpInRouterAdvertisements, # of input router advertisements */
pub ifs6_in_routeradvert: u_quad_t,
/* ipv6IfIcmpInNeighborSolicits, # of input neighbor solicitations */
pub ifs6_in_neighborsolicit: u_quad_t,
/* ipv6IfIcmpInNeighborAdvertisements, # of input neighbor advertisements */
pub ifs6_in_neighboradvert: u_quad_t,
/* ipv6IfIcmpInRedirects, # of input redirects */
pub ifs6_in_redirect: u_quad_t,
/* ipv6IfIcmpInGroupMembQueries, # of input MLD queries */
pub ifs6_in_mldquery: u_quad_t,
/* ipv6IfIcmpInGroupMembResponses, # of input MLD reports */
pub ifs6_in_mldreport: u_quad_t,
/* ipv6IfIcmpInGroupMembReductions, # of input MLD done */
pub ifs6_in_mlddone: u_quad_t,
/*
* Output statistics. We should solve unresolved routing problem...
*/
/* ipv6IfIcmpOutMsgs, total # of output messages */
pub ifs6_out_msg: u_quad_t,
/* ipv6IfIcmpOutErrors, # of output error messages */
pub ifs6_out_error: u_quad_t,
/* ipv6IfIcmpOutDestUnreachs, # of output dest unreach errors */
pub ifs6_out_dstunreach: u_quad_t,
/* ipv6IfIcmpOutAdminProhibs, # of output administratively prohibited errs */
pub ifs6_out_adminprohib: u_quad_t,
/* ipv6IfIcmpOutTimeExcds, # of output time exceeded errors */
pub ifs6_out_timeexceed: u_quad_t,
/* ipv6IfIcmpOutParmProblems, # of output parameter problem errors */
pub ifs6_out_paramprob: u_quad_t,
/* ipv6IfIcmpOutPktTooBigs, # of output packet too big errors */
pub ifs6_out_pkttoobig: u_quad_t,
/* ipv6IfIcmpOutEchos, # of output echo requests */
pub ifs6_out_echo: u_quad_t,
/* ipv6IfIcmpOutEchoReplies, # of output echo replies */
pub ifs6_out_echoreply: u_quad_t,
/* ipv6IfIcmpOutRouterSolicits, # of output router solicitations */
pub ifs6_out_routersolicit: u_quad_t,
/* ipv6IfIcmpOutRouterAdvertisements, # of output router advertisements */
pub ifs6_out_routeradvert: u_quad_t,
/* ipv6IfIcmpOutNeighborSolicits, # of output neighbor solicitations */
pub ifs6_out_neighborsolicit: u_quad_t,
/* ipv6IfIcmpOutNeighborAdvertisements, # of output neighbor advertisements */
pub ifs6_out_neighboradvert: u_quad_t,
/* ipv6IfIcmpOutRedirects, # of output redirects */
pub ifs6_out_redirect: u_quad_t,
/* ipv6IfIcmpOutGroupMembQueries, # of output MLD queries */
pub ifs6_out_mldquery: u_quad_t,
/* ipv6IfIcmpOutGroupMembResponses, # of output MLD reports */
pub ifs6_out_mldreport: u_quad_t,
/* ipv6IfIcmpOutGroupMembReductions, # of output MLD done */
pub ifs6_out_mlddone: u_quad_t,
}
ioctl_readwrite!(ctliocginfo, b'N', 3, ctl_info);
ioctl_write_ptr!(siocsifflags, b'i', 16, ifreq);
ioctl_readwrite!(siocgifflags, b'i', 17, ifreq);
ioctl_write_ptr!(siocsifaddr, b'i', 12, ifreq);
ioctl_readwrite!(siocgifaddr, b'i', 33, ifreq);
ioctl_write_ptr!(siocsifdstaddr, b'i', 14, ifreq);
ioctl_readwrite!(siocgifdstaddr, b'i', 34, ifreq);
ioctl_write_ptr!(siocsifbrdaddr, b'i', 19, ifreq);
ioctl_readwrite!(siocgifbrdaddr, b'i', 35, ifreq);
ioctl_write_ptr!(siocsifnetmask, b'i', 22, ifreq);
ioctl_readwrite!(siocgifnetmask, b'i', 37, ifreq);
ioctl_write_ptr!(siocsifmtu, b'i', 52, ifreq);
ioctl_readwrite!(siocgifmtu, b'i', 51, ifreq);
ioctl_write_ptr!(siocaifaddr, b'i', 26, ifaliasreq);
ioctl_write_ptr!(siocdifaddr, b'i', 25, ifreq);
ioctl_write_ptr!(siocaifaddr_in6, b'i', 26, in6_ifaliasreq);
ioctl_write_ptr!(siocsifaddr_in6, b'i', 12, in6_ifreq);
ioctl_readwrite!(siocgifaddr_in6, b'i', 33, in6_ifreq);
ioctl_write_ptr!(siocdifaddr_in6, b'i', 25, in6_ifreq);
ioctl_readwrite!(siocifcreate, b'i', 120, ifreq);
ioctl_write_ptr!(siocsiflladdr, b'i', 60, ifreq);
ioctl_readwrite!(siocgiflladdr, b'i', 158, ifreq);
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/macos/tap/mod.rs | src/platform/macos/tap/mod.rs | /*
link https://github.com/apple-oss-distributions/xnu/blob/main/bsd/sys/sockio.h
link https://github.com/apple-oss-distributions/xnu/blob/main/bsd/net/if_fake.c
link https://www.zerotier.com/blog/how-zerotier-eliminated-kernel-extensions-on-macos/
*/
/*
* link https://github.com/zerotier/ZeroTierOne/blob/dev/osdep/MacEthernetTapAgent.c
*
* This creates a pair of feth devices with the lower numbered device
* being the virtual interface and the other being the device
* used to actually read and write packets. The latter gets no IP config
* and is only used for I/O. The behavior of feth is similar to the
* veth pairs that exist on Linux.
*
* The feth device has only existed since MacOS Sierra, but that's fairly
* long ago in Mac terms.
*
* I/O with feth must be done using two different sockets. The BPF socket
* is used to receive packets, while an AF_NDRV (low-level network driver
* access) socket must be used to inject. AF_NDRV can't read IP frames
* since BSD doesn't forward packets out the NDRV tap if they've already
* been handled, and while BPF can inject its MTU for injected packets
* is limited to 2048.
*
* All this stuff is basically undocumented. A lot of tracing through
* the Darwin/XNU kernel source was required to figure out how to make
* this actually work.
*
* See also:
*
* https://apple.stackexchange.com/questions/337715/fake-ethernet-interfaces-feth-if-fake-anyone-ever-seen-this
*
*/
use crate::builder::DeviceConfig;
use crate::platform::macos::sys::siocifcreate;
use crate::platform::unix::Fd;
use bytes::BytesMut;
use libc::{ifreq, IFNAMSIZ};
use nix::errno::Errno;
use std::collections::VecDeque;
use std::ffi::{CStr, CString};
use std::io;
use std::io::{IoSlice, IoSliceMut};
use std::os::fd::{AsRawFd, IntoRawFd, RawFd};
use std::sync::Mutex;
const FETH: &str = "feth";
const BUFFER_LEN: usize = 131072;
pub(crate) fn run_command(command: &str, args: &[&str]) -> io::Result<()> {
let out = std::process::Command::new(command).args(args).output()?;
if !out.status.success() {
let err = String::from_utf8_lossy(if out.stderr.is_empty() {
&out.stdout
} else {
&out.stderr
});
let info = format!("{command} failed with: \"{err}\"");
return Err(io::Error::other(info));
}
Ok(())
}
pub struct Tap {
s_bpf_fd: Fd,
s_ndrv_fd: Fd,
peer_feth: Feth,
dev_feth: Feth,
buffer: Mutex<VecDeque<BytesMut>>,
}
struct Feth {
is_drop: bool,
name: String,
}
impl Drop for Feth {
fn drop(&mut self) {
if self.is_drop {
_ = run_command("ifconfig", &[&self.name, "destroy"]);
self.is_drop = false;
}
}
}
impl IntoRawFd for Tap {
fn into_raw_fd(mut self) -> RawFd {
self.peer_feth.is_drop = false;
self.dev_feth.is_drop = false;
self.s_bpf_fd.into_raw_fd()
}
}
impl Tap {
pub fn new(config: &DeviceConfig) -> io::Result<Tap> {
unsafe {
let s_ndrv_fd = libc::socket(libc::AF_NDRV, libc::SOCK_RAW, 0);
let s_ndrv_fd = Fd::new(s_ndrv_fd)?;
_ = s_ndrv_fd.set_cloexec();
let mut ifr = new_ifreq(config.dev_name.as_ref())?;
if let Err(e) = siocifcreate(s_ndrv_fd.inner, &mut ifr) {
if e != Errno::EEXIST || !config.reuse_dev.unwrap_or(true) {
return Err(e.into());
}
}
let dev_name = CStr::from_ptr(ifr.ifr_name.as_ptr())
.to_string_lossy()
.into_owned();
let dev_feth = Feth {
is_drop: !config.persist.unwrap_or(false),
name: dev_name,
};
std::thread::sleep(std::time::Duration::from_millis(1));
let mut peer_ifr = new_ifreq(config.peer_feth.as_ref())?;
if let Err(e) = siocifcreate(s_ndrv_fd.inner, &mut peer_ifr) {
if e != Errno::EEXIST || !config.reuse_dev.unwrap_or(true) {
return Err(e.into());
}
}
let peer_name = CStr::from_ptr(peer_ifr.ifr_name.as_ptr())
.to_string_lossy()
.into_owned();
let peer_feth = Feth {
is_drop: !config.persist.unwrap_or(false),
name: peer_name,
};
std::thread::sleep(std::time::Duration::from_millis(1));
run_command("ifconfig", &[&peer_feth.name, "peer", &dev_feth.name])?;
let mut nd: libc::sockaddr_ndrv = std::mem::zeroed();
nd.snd_len = size_of::<libc::sockaddr_ndrv>() as u8;
nd.snd_family = libc::AF_NDRV as u8;
nd.snd_name[..peer_feth.name.len()].copy_from_slice(peer_feth.name.as_bytes());
if libc::bind(
s_ndrv_fd.inner,
&nd as *const _ as *const libc::sockaddr,
size_of::<libc::sockaddr_ndrv>() as u32,
) != 0
{
return Err(io::Error::last_os_error());
}
if libc::connect(
s_ndrv_fd.inner,
&nd as *const _ as *const libc::sockaddr,
size_of::<libc::sockaddr_ndrv>() as u32,
) != 0
{
return Err(io::Error::last_os_error());
}
let s_bpf_fd = open_bpf()?;
let mut buffer_len = BUFFER_LEN;
let rs = libc::ioctl(s_bpf_fd.inner, libc::BIOCSBLEN, &mut buffer_len);
if rs != 0 {
return Err(io::Error::last_os_error());
}
let mut enable = 1i32;
let mut disable = 0i32;
let rs = libc::ioctl(s_bpf_fd.inner, libc::BIOCIMMEDIATE, &mut enable);
if rs != 0 {
return Err(io::Error::last_os_error());
}
let rs = libc::ioctl(s_bpf_fd.inner, libc::BIOCSSEESENT, &mut disable);
if rs != 0 {
return Err(io::Error::last_os_error());
}
let rs = libc::ioctl(s_bpf_fd.inner, libc::BIOCSETIF, &mut peer_ifr);
if rs != 0 {
return Err(io::Error::last_os_error());
}
let rs = libc::ioctl(s_bpf_fd.inner, libc::BIOCSHDRCMPLT, &mut enable);
if rs != 0 {
return Err(io::Error::last_os_error());
}
let rs = libc::ioctl(s_bpf_fd.inner, libc::BIOCPROMISC as u64, &mut enable);
if rs != 0 {
return Err(io::Error::last_os_error());
}
Ok(Self {
s_bpf_fd,
s_ndrv_fd,
dev_feth,
peer_feth,
buffer: Default::default(),
})
}
}
// pub fn as_s_ndrv_fd(&self) -> RawFd {
// self.s_ndrv_fd.as_raw_fd()
// }
// pub fn as_s_bpf_fd(&self) -> RawFd {
// self.s_bpf_fd.as_raw_fd()
// }
pub fn name(&self) -> &String {
&self.dev_feth.name
}
pub fn peer_name(&self) -> &String {
&self.peer_feth.name
}
pub fn is_nonblocking(&self) -> io::Result<bool> {
self.s_bpf_fd.is_nonblocking()
}
pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
self.s_bpf_fd.set_nonblocking(nonblocking)?;
self.s_ndrv_fd.set_nonblocking(nonblocking)?;
Ok(())
}
pub fn send(&self, buf: &[u8]) -> io::Result<usize> {
self.s_ndrv_fd.write(buf)
}
pub fn send_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
self.s_ndrv_fd.writev(bufs)
}
pub fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
let mut guard = self.buffer.lock().unwrap();
if guard.is_empty() {
self.recv_to_buffer(&mut guard)?;
}
let Some(buffer) = guard.pop_front() else {
return Err(io::Error::new(
io::ErrorKind::UnexpectedEof,
"recv buffer is empty",
));
};
if buf.len() < buffer.len() {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"buffer too small",
));
}
buf[..buffer.len()].copy_from_slice(&buffer);
Ok(buffer.len())
}
fn recv_to_buffer(&self, bufs: &mut VecDeque<BytesMut>) -> io::Result<()> {
let mut buffer = [0; BUFFER_LEN];
let len = self.s_bpf_fd.read(&mut buffer)?;
if len > 0 {
let mut p = 0;
unsafe {
while p < len {
let hdr = buffer.as_ptr().add(p) as *const libc::bpf_hdr;
let bh_caplen = (*hdr).bh_caplen as usize;
let bh_hdrlen = (*hdr).bh_hdrlen as usize;
if bh_caplen > 0 && p + bh_hdrlen + bh_caplen <= len {
let buf = &buffer[p + bh_hdrlen..p + bh_hdrlen + bh_caplen];
bufs.push_back(buf.into());
}
p += ((*hdr).bh_hdrlen as usize + bh_caplen + 3) & !3;
}
}
}
Ok(())
}
#[allow(dead_code)]
pub fn recv_multiple<B: AsRef<[u8]> + AsMut<[u8]>>(
&self,
bufs: &mut [B],
sizes: &mut [usize],
) -> io::Result<usize> {
let mut buffer = [0; BUFFER_LEN];
let len = self.s_bpf_fd.read(&mut buffer)?;
let mut num = 0;
if len > 0 {
let mut p = 0;
unsafe {
while p < len {
let hdr = buffer.as_ptr().add(p) as *const libc::bpf_hdr;
let bh_caplen = (*hdr).bh_caplen as usize;
let bh_hdrlen = (*hdr).bh_hdrlen as usize;
if bh_caplen > 0 && p + bh_hdrlen + bh_caplen <= len {
let buf = &buffer[p + bh_hdrlen..p + bh_hdrlen + bh_caplen];
if let Some(dst) = bufs.get_mut(num) {
let dst = dst.as_mut();
if dst.len() < buf.len() {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"buffer too small",
));
}
dst[..buf.len()].copy_from_slice(buf);
sizes[num] = buf.len();
num += 1;
} else {
break;
}
}
p += ((*hdr).bh_hdrlen as usize + bh_caplen + 3) & !3;
}
}
}
Ok(num)
}
pub fn recv_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
let mut guard = self.buffer.lock().unwrap();
if guard.is_empty() {
self.recv_to_buffer(&mut guard)?;
}
let Some(buf) = guard.pop_front() else {
return Err(io::Error::new(
io::ErrorKind::UnexpectedEof,
"recv buffer is empty",
));
};
let len: usize = bufs.iter().map(|v| v.len()).sum();
if len < buf.len() {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"buffer too small",
));
}
let mut pos = 0;
for b in bufs {
let n = b.len().min(buf.len() - pos);
if n == 0 {
break;
}
b[..n].copy_from_slice(&buf[pos..pos + n]);
pos += n;
if pos == buf.len() {
break;
}
}
Ok(pos)
}
#[cfg(feature = "interruptible")]
#[inline]
pub(crate) fn read_interruptible(
&self,
buf: &mut [u8],
event: &crate::InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<usize> {
loop {
self.wait_readable_interruptible(event, timeout)?;
match self.recv(buf) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => continue,
rs => return rs,
}
}
}
#[cfg(feature = "interruptible")]
#[inline]
pub(crate) fn readv_interruptible(
&self,
bufs: &mut [IoSliceMut<'_>],
event: &crate::InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<usize> {
loop {
self.wait_readable_interruptible(event, timeout)?;
match self.recv_vectored(bufs) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => continue,
rs => return rs,
}
}
}
#[cfg(feature = "interruptible")]
#[inline]
pub(crate) fn wait_readable_interruptible(
&self,
event: &crate::InterruptEvent,
timeout: Option<std::time::Duration>,
) -> io::Result<()> {
self.s_bpf_fd.wait_readable(Some(event), timeout)
}
#[cfg(feature = "interruptible")]
#[inline]
pub(crate) fn write_interruptible(
&self,
buf: &[u8],
event: &crate::InterruptEvent,
) -> io::Result<usize> {
loop {
self.wait_writable_interruptible(event)?;
return match self.s_ndrv_fd.write(buf) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
continue;
}
rs => rs,
};
}
}
#[cfg(feature = "interruptible")]
#[inline]
pub(crate) fn writev_interruptible(
&self,
bufs: &[IoSlice<'_>],
event: &crate::InterruptEvent,
) -> io::Result<usize> {
loop {
self.wait_writable_interruptible(event)?;
return match self.s_ndrv_fd.writev(bufs) {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
continue;
}
rs => rs,
};
}
}
#[cfg(feature = "interruptible")]
#[inline]
pub(crate) fn wait_writable_interruptible(
&self,
event: &crate::InterruptEvent,
) -> io::Result<()> {
self.s_ndrv_fd.wait_writable(Some(event), None)
}
}
impl AsRawFd for Tap {
fn as_raw_fd(&self) -> RawFd {
self.s_bpf_fd.as_raw_fd()
}
}
fn open_bpf() -> io::Result<Fd> {
for i in 1..5000 {
let path = CString::new(format!("/dev/bpf{i}").into_bytes())?;
let bpf_fd = unsafe { libc::open(path.as_ptr(), libc::O_RDWR) };
match Fd::new(bpf_fd) {
Ok(fd) => {
_ = fd.set_cloexec();
return Ok(fd);
}
Err(e) => {
if e.raw_os_error() == Some(libc::EBUSY) {
continue;
} else {
return Err(e);
}
}
}
}
Err(io::Error::new(
io::ErrorKind::NotFound,
"No available /dev/bpf",
))
}
fn new_ifreq(name: Option<&String>) -> io::Result<ifreq> {
if let Some(name) = name {
new_ifreq_str(name.as_str())
} else {
new_ifreq_str(FETH)
}
}
fn new_ifreq_str(name: &str) -> io::Result<ifreq> {
let bytes = name.as_bytes();
if bytes.len() >= IFNAMSIZ {
return Err(io::Error::new(io::ErrorKind::InvalidInput, "name too long"));
}
if bytes.len() < 4 || &bytes[..4] != FETH.as_bytes() {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"The prefix of the network card name must be 'feth'",
));
}
let mut ifr: ifreq = unsafe { std::mem::zeroed() };
for (i, &b) in bytes.iter().enumerate() {
ifr.ifr_name[i] = b as libc::c_char;
}
ifr.ifr_name[bytes.len()] = 0;
Ok(ifr)
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/freebsd/device.rs | src/platform/freebsd/device.rs | use crate::{
builder::{DeviceConfig, Layer},
platform::freebsd::sys::*,
platform::{
unix::{sockaddr_union, Fd, Tun},
ETHER_ADDR_LEN,
},
ToIpv4Address, ToIpv4Netmask, ToIpv6Address, ToIpv6Netmask,
};
use crate::platform::unix::device::{ctl, ctl_v6};
use libc::{
self, c_char, c_short, fcntl, ifreq, kinfo_file, AF_LINK, F_KINFO, IFF_RUNNING, IFF_UP,
IFNAMSIZ, KINFO_FILE_SIZE, O_RDWR,
};
use mac_address::mac_address_by_name;
use std::io::ErrorKind;
use std::os::fd::{IntoRawFd, RawFd};
use std::{ffi::CStr, io, mem, net::IpAddr, os::unix::io::AsRawFd, ptr, sync::Mutex};
/// A TUN device using the TUN/TAP Linux driver.
pub struct DeviceImpl {
pub(crate) tun: Tun,
pub op_lock: Mutex<bool>,
}
impl IntoRawFd for DeviceImpl {
fn into_raw_fd(mut self) -> RawFd {
let fd = self.tun.fd.inner;
self.tun.fd.inner = -1;
fd
}
}
impl Drop for DeviceImpl {
fn drop(&mut self) {
if self.tun.fd.inner < 0 {
return;
}
unsafe {
if let (Ok(ctl), Ok(req)) = (ctl(), self.request()) {
libc::close(self.tun.fd.inner);
self.tun.fd.inner = -1;
_ = siocifdestroy(ctl.as_raw_fd(), &req);
}
}
}
}
impl DeviceImpl {
/// Create a new `Device` for the given `Configuration`.
pub(crate) fn new(config: DeviceConfig) -> io::Result<Self> {
let layer = config.layer.unwrap_or(Layer::L3);
let associate_route = if layer == Layer::L3 {
config.associate_route.unwrap_or(true)
} else {
false
};
let device_prefix = if layer == Layer::L3 {
"tun".to_string()
} else {
"tap".to_string()
};
let dev_index = match config.dev_name.as_ref() {
Some(tun_name) => {
if tun_name.len() > IFNAMSIZ {
return Err(io::Error::new(
ErrorKind::InvalidInput,
"device name too long",
));
}
match layer {
Layer::L2 => {
if !tun_name.starts_with("tap") {
return Err(io::Error::new(
ErrorKind::InvalidInput,
"device name must start with tap",
));
}
}
Layer::L3 => {
if !tun_name.starts_with("tun") {
return Err(io::Error::new(
ErrorKind::InvalidInput,
"device name must start with tun",
));
}
}
}
Some(
tun_name[3..]
.parse::<u32>()
.map_err(|e| io::Error::new(ErrorKind::InvalidInput, e))?,
)
}
None => None,
};
let tun = unsafe {
if let Some(name_index) = dev_index.as_ref() {
let device_path = format!("/dev/{device_prefix}{name_index}\0");
let fd = libc::open(device_path.as_ptr() as *const _, O_RDWR | libc::O_CLOEXEC);
Fd::new(fd)?
} else {
'End: {
for i in 0..256 {
let device_path = format!("/dev/{device_prefix}{i}\0");
let fd =
libc::open(device_path.as_ptr() as *const _, O_RDWR | libc::O_CLOEXEC);
match Fd::new(fd) {
Ok(tun) => {
break 'End tun;
}
Err(e) => {
if e.raw_os_error() != Some(libc::EBUSY) {
return Err(e);
}
}
}
}
return Err(io::Error::new(
ErrorKind::AlreadyExists,
"no available file descriptor",
));
}
}
};
let tun = Tun::new(tun);
if matches!(layer, Layer::L3) {
Self::enable_tunsifhead_impl(&tun.fd)?;
tun.set_ignore_packet_info(!config.packet_information.unwrap_or(false));
} else {
tun.set_ignore_packet_info(false);
}
let device = DeviceImpl {
tun,
op_lock: Mutex::new(associate_route),
};
device.disable_deafult_sys_local_ipv6()?;
Ok(device)
}
pub(crate) fn from_tun(tun: Tun) -> io::Result<Self> {
let name = Self::name_of_fd(&tun)?;
if name.starts_with("tap") {
// Tap does not have PI
tun.set_ignore_packet_info(false);
} else {
Self::enable_tunsifhead_impl(&tun.fd)?;
tun.set_ignore_packet_info(true);
}
let dev = Self {
tun,
op_lock: Mutex::new(true),
};
Ok(dev)
}
fn disable_deafult_sys_local_ipv6(&self) -> std::io::Result<()> {
unsafe {
let tun_name = self.name_impl()?;
let mut req: in6_ndireq = mem::zeroed();
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifra_name.as_mut_ptr(),
tun_name.len(),
);
req.ndi.flags &= !(ND6_IFF_AUTO_LINKLOCAL as u32);
if let Err(err) = siocsifinfoin6(ctl_v6()?.as_raw_fd(), &mut req) {
return Err(io::Error::from(err));
}
}
Ok(())
}
// https://forums.freebsd.org/threads/ping6-address-family-not-supported-by-protocol-family.51467/
// https://man.freebsd.org/cgi/man.cgi?query=tun&sektion=4&manpath=FreeBSD+5.3-RELEASE
// https://web.mit.edu/freebsd/head/sys/net/if_tun.h
// If the TUNSIFHEAD ioctl has been set, the address family must
// be prepended, otherwise the packet is assumed to be of type AF_INET.
// IPv6 needs AF_INET6.
// The argument should be a pointer to an int; a non-zero value turns off "link-layer" mode, and enables "multi-af"
// mode, where every packet is preceded with a four byte ad-dress family.
fn enable_tunsifhead_impl(device_fd: &Fd) -> std::io::Result<()> {
unsafe {
if let Err(err) = sioctunsifhead(device_fd.as_raw_fd(), &1 as *const _) {
return Err(io::Error::from(err));
}
}
Ok(())
}
fn calc_dest_addr(&self, addr: IpAddr, netmask: IpAddr) -> std::io::Result<IpAddr> {
let prefix_len = ipnet::ip_mask_to_prefix(netmask)
.map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, e))?;
Ok(ipnet::IpNet::new(addr, prefix_len)
.map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, e))?
.broadcast())
}
/// Set the IPv4 alias of the device.
fn add_address(
&self,
addr: IpAddr,
mask: IpAddr,
dest: Option<IpAddr>,
associate_route: bool,
) -> std::io::Result<()> {
unsafe {
match addr {
IpAddr::V4(_) => {
let ctl = ctl()?;
let mut req: ifaliasreq = mem::zeroed();
let tun_name = self.name_impl()?;
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifran.as_mut_ptr(),
tun_name.len(),
);
req.addr = crate::platform::unix::sockaddr_union::from((addr, 0)).addr;
if let Some(dest) = dest {
req.dstaddr = crate::platform::unix::sockaddr_union::from((dest, 0)).addr;
}
req.mask = crate::platform::unix::sockaddr_union::from((mask, 0)).addr;
if let Err(err) = siocaifaddr(ctl.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
if let Err(e) = self.add_route(addr, mask, associate_route) {
log::warn!("{e:?}");
}
}
IpAddr::V6(_) => {
let IpAddr::V6(_) = mask else {
return Err(std::io::Error::from(ErrorKind::InvalidInput));
};
let tun_name = self.name_impl()?;
let mut req: in6_ifaliasreq = mem::zeroed();
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifra_name.as_mut_ptr(),
tun_name.len(),
);
req.ifra_addr = sockaddr_union::from((addr, 0)).addr6;
req.ifra_prefixmask = sockaddr_union::from((mask, 0)).addr6;
req.in6_addrlifetime.ia6t_vltime = 0xffffffff_u32;
req.in6_addrlifetime.ia6t_pltime = 0xffffffff_u32;
req.ifra_flags = IN6_IFF_NODAD;
if let Err(err) = siocaifaddr_in6(ctl_v6()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
}
}
Ok(())
}
}
/// Prepare a new request.
unsafe fn request(&self) -> std::io::Result<ifreq> {
let mut req: ifreq = mem::zeroed();
let tun_name = self.name_impl()?;
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifr_name.as_mut_ptr(),
tun_name.len(),
);
Ok(req)
}
/// # Safety
unsafe fn request_v6(&self) -> std::io::Result<in6_ifreq> {
let tun_name = self.name_impl()?;
let mut req: in6_ifreq = mem::zeroed();
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifra_name.as_mut_ptr(),
tun_name.len(),
);
req.ifr_ifru.ifru_flags = IN6_IFF_NODAD as _;
Ok(req)
}
fn add_route(&self, addr: IpAddr, netmask: IpAddr, associate_route: bool) -> io::Result<()> {
if !associate_route {
return Ok(());
}
let if_index = self.if_index_impl()?;
let prefix_len = ipnet::ip_mask_to_prefix(netmask)
.map_err(|e| io::Error::new(ErrorKind::InvalidInput, e))?;
let mut manager = route_manager::RouteManager::new()?;
let route = route_manager::Route::new(addr, prefix_len)
.with_pref_source(addr)
.with_if_index(if_index);
manager.add(&route)?;
Ok(())
}
fn name_of_fd(tun: &Tun) -> io::Result<String> {
use std::path::PathBuf;
unsafe {
let mut path_info: kinfo_file = std::mem::zeroed();
path_info.kf_structsize = KINFO_FILE_SIZE;
if fcntl(tun.as_raw_fd(), F_KINFO, &mut path_info as *mut _) < 0 {
return Err(io::Error::last_os_error());
}
let dev_path = CStr::from_ptr(path_info.kf_path.as_ptr() as *const c_char)
.to_string_lossy()
.into_owned();
let path = PathBuf::from(dev_path);
let device_name = path
.file_name()
.ok_or(std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"invalid device name",
))?
.to_string_lossy()
.to_string();
Ok(device_name)
}
}
/// Retrieves the name of the network interface.
pub(crate) fn name_impl(&self) -> std::io::Result<String> {
Self::name_of_fd(&self.tun)
}
fn remove_all_address_v4(&self) -> io::Result<()> {
unsafe {
let req_v4 = self.request()?;
loop {
if let Err(err) = siocdifaddr(ctl()?.as_raw_fd(), &req_v4) {
if err == nix::errno::Errno::EADDRNOTAVAIL {
break;
}
return Err(io::Error::from(err));
}
}
}
Ok(())
}
fn set_network_address_impl<IPv4: ToIpv4Address, Netmask: ToIpv4Netmask>(
&self,
address: IPv4,
netmask: Netmask,
destination: Option<IPv4>,
associate_route: bool,
) -> io::Result<()> {
let addr = address.ipv4()?.into();
let netmask = netmask.netmask()?.into();
let default_dest = self.calc_dest_addr(addr, netmask)?;
let dest = destination
.map(|d| d.ipv4())
.transpose()?
.map(|v| v.into())
.unwrap_or(default_dest);
self.remove_all_address_v4()?;
self.add_address(addr, netmask, Some(dest), associate_route)?;
Ok(())
}
}
// Public User Interface
impl DeviceImpl {
/// Retrieves the name of the network interface.
pub fn name(&self) -> std::io::Result<String> {
let _guard = self.op_lock.lock().unwrap();
self.name_impl()
}
/// Sets a new name for the network interface.
pub fn set_name(&self, value: &str) -> std::io::Result<()> {
use std::ffi::CString;
let _guard = self.op_lock.lock().unwrap();
unsafe {
if value.len() > IFNAMSIZ {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"device name too long",
));
}
let mut req = self.request()?;
let tun_name = CString::new(value)?;
let mut tun_name: Vec<c_char> = tun_name
.into_bytes_with_nul()
.into_iter()
.map(|c| c as _)
.collect::<_>();
req.ifr_ifru.ifru_data = tun_name.as_mut_ptr();
if let Err(err) = siocsifname(ctl()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
/// If false, the program will not modify or manage routes in any way, allowing the system to handle all routing natively.
/// If true (default), the program will automatically add or remove routes to provide consistent routing behavior across all platforms.
/// Set this to be false to obtain the platform's default routing behavior.
pub fn set_associate_route(&self, associate_route: bool) {
*self.op_lock.lock().unwrap() = associate_route;
}
/// Retrieve whether route is associated with the IP setting interface, see [`DeviceImpl::set_associate_route`]
pub fn associate_route(&self) -> bool {
*self.op_lock.lock().unwrap()
}
/// Returns whether the TUN device is set to ignore packet information (PI).
///
/// When enabled, the device does not prepend the `struct tun_pi` header
/// to packets, which can simplify packet processing in some cases.
///
/// # Returns
/// * `true` - The TUN device ignores packet information.
/// * `false` - The TUN device includes packet information.
/// # Note
/// Retrieve whether the packet is ignored for the TUN Device; The TAP device always returns `false`.
pub fn ignore_packet_info(&self) -> bool {
let _guard = self.op_lock.lock().unwrap();
self.tun.ignore_packet_info()
}
/// Sets whether the TUN device should ignore packet information (PI).
///
/// When `ignore_packet_info` is set to `true`, the TUN device does not
/// prepend the `struct tun_pi` header to packets. This can be useful
/// if the additional metadata is not needed.
///
/// # Parameters
/// * `ign`
/// - If `true`, the TUN device will ignore packet information.
/// - If `false`, it will include packet information.
/// # Note
/// This only works for a TUN device; The invocation will be ignored if the device is a TAP.
pub fn set_ignore_packet_info(&self, ign: bool) {
let _guard = self.op_lock.lock().unwrap();
if let Ok(name) = self.name_impl() {
if name.starts_with("tun") {
self.tun.set_ignore_packet_info(ign)
}
}
}
/// Enables or disables the network interface.
pub fn enabled(&self, value: bool) -> std::io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req = self.request()?;
let ctl = ctl()?;
if let Err(err) = siocgifflags(ctl.as_raw_fd(), &mut req) {
return Err(io::Error::from(err));
}
if value {
req.ifr_ifru.ifru_flags[0] |= (IFF_UP | IFF_RUNNING) as c_short;
} else {
req.ifr_ifru.ifru_flags[0] &= !(IFF_UP as c_short);
}
if let Err(err) = siocsifflags(ctl.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
/// Retrieves the current MTU (Maximum Transmission Unit) for the interface.
pub fn mtu(&self) -> std::io::Result<u16> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req = self.request()?;
if let Err(err) = siocgifmtu(ctl()?.as_raw_fd(), &mut req) {
return Err(io::Error::from(err));
}
let r: u16 = req.ifr_ifru.ifru_mtu.try_into().map_err(io::Error::other)?;
Ok(r)
}
}
/// Sets the MTU (Maximum Transmission Unit) for the interface.
pub fn set_mtu(&self, value: u16) -> std::io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req = self.request()?;
req.ifr_ifru.ifru_mtu = value as i32;
if let Err(err) = siocsifmtu(ctl()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
/// Sets the IPv4 network address, netmask, and an optional destination address.
/// Remove all previous set IPv4 addresses and set the specified address.
pub fn set_network_address<IPv4: ToIpv4Address, Netmask: ToIpv4Netmask>(
&self,
address: IPv4,
netmask: Netmask,
destination: Option<IPv4>,
) -> io::Result<()> {
let guard = self.op_lock.lock().unwrap();
self.set_network_address_impl(address, netmask, destination, *guard)
}
/// Add IPv4 network address, netmask
pub fn add_address_v4<IPv4: ToIpv4Address, Netmask: ToIpv4Netmask>(
&self,
address: IPv4,
netmask: Netmask,
) -> io::Result<()> {
let guard = self.op_lock.lock().unwrap();
let addr = address.ipv4()?.into();
let netmask = netmask.netmask()?.into();
let default_dest = self.calc_dest_addr(addr, netmask)?;
self.add_address(addr, netmask, Some(default_dest), *guard)
}
/// Removes an IP address from the interface.
pub fn remove_address(&self, addr: IpAddr) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
match addr {
IpAddr::V4(addr) => {
let mut req_v4 = self.request()?;
req_v4.ifr_ifru.ifru_addr = sockaddr_union::from((addr, 0)).addr;
if let Err(err) = siocdifaddr(ctl()?.as_raw_fd(), &req_v4) {
return Err(io::Error::from(err));
}
}
IpAddr::V6(addr) => {
let mut req_v6 = self.request_v6()?;
req_v6.ifr_ifru.ifru_addr = sockaddr_union::from((addr, 0)).addr6;
if let Err(err) = siocdifaddr_in6(ctl_v6()?.as_raw_fd(), &req_v6) {
return Err(io::Error::from(err));
}
}
}
Ok(())
}
}
/// Adds an IPv6 address to the interface.
pub fn add_address_v6<IPv6: ToIpv6Address, Netmask: ToIpv6Netmask>(
&self,
addr: IPv6,
netmask: Netmask,
) -> io::Result<()> {
let guard = self.op_lock.lock().unwrap();
self.add_address(addr.ipv6()?.into(), netmask.netmask()?.into(), None, *guard)
}
/// Sets the MAC (hardware) address for the interface.
///
/// This function constructs an interface request and copies the provided MAC address
/// into the hardware address field. It then applies the change via a system call.
/// This operation is typically supported only for TAP devices.
pub fn set_mac_address(&self, eth_addr: [u8; ETHER_ADDR_LEN as usize]) -> std::io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req = self.request()?;
req.ifr_ifru.ifru_addr.sa_len = ETHER_ADDR_LEN;
req.ifr_ifru.ifru_addr.sa_family = AF_LINK as u8;
req.ifr_ifru.ifru_addr.sa_data[0..ETHER_ADDR_LEN as usize]
.copy_from_slice(eth_addr.map(|c| c as i8).as_slice());
if let Err(err) = siocsiflladdr(ctl()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
/// Retrieves the MAC (hardware) address of the interface.
///
/// This function queries the MAC address by the interface name using a helper function.
/// An error is returned if the MAC address cannot be found.
pub fn mac_address(&self) -> std::io::Result<[u8; ETHER_ADDR_LEN as usize]> {
let _guard = self.op_lock.lock().unwrap();
let mac = mac_address_by_name(&self.name_impl()?)
.map_err(|e| io::Error::other(e.to_string()))?
.ok_or(std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"invalid mac address",
))?;
Ok(mac.bytes())
}
/// In Layer3(i.e. TUN mode), we need to put the tun interface into "multi_af" mode, which will prepend the address
/// family to all packets (same as NetBSD).
/// If this is not enabled, the kernel silently drops all IPv6 packets on output and gets confused on input.
pub fn enable_tunsifhead(&self) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
Self::enable_tunsifhead_impl(&self.tun.fd)
}
}
impl From<Layer> for c_short {
fn from(layer: Layer) -> Self {
match layer {
Layer::L2 => 2,
Layer::L3 => 3,
}
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/freebsd/mod.rs | src/platform/freebsd/mod.rs | mod sys;
mod device;
pub use self::device::DeviceImpl;
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/freebsd/sys.rs | src/platform/freebsd/sys.rs | use libc::{c_char, c_int, c_uint, ifreq, sockaddr, sockaddr_in6, time_t, IFNAMSIZ};
use nix::{ioctl_readwrite, ioctl_write_ptr};
use std::ffi::c_void;
//pub const IN6_IFF_NODAD: i32 = 0x0020;
pub const IN6_IFF_NODAD: i32 = 0x100;
pub const ND6_IFF_AUTO_LINKLOCAL: i32 = 0x20;
#[allow(dead_code)]
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ctl_info {
pub ctl_id: c_uint,
pub ctl_name: [c_char; 96],
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ifaliasreq {
pub ifran: [c_char; IFNAMSIZ],
pub addr: sockaddr,
pub dstaddr: sockaddr,
pub mask: sockaddr,
pub ifra_vhid: c_int,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct in6_ifaliasreq {
pub ifra_name: [c_char; IFNAMSIZ],
pub ifra_addr: sockaddr_in6,
pub ifra_dstaddr: sockaddr_in6,
pub ifra_prefixmask: sockaddr_in6,
pub ifra_flags: libc::c_int,
pub in6_addrlifetime: in6_addrlifetime,
pub ifra_vhid: libc::c_int,
}
// #[allow(non_camel_case_types)]
// #[repr(C)]
// #[derive(Copy, Clone)]
// pub struct in_aliasreq {
// pub ifra_name: [c_char; IFNAMSIZ],
// pub ifra_addr: sockaddr_in,
// pub ifra_dstaddr: sockaddr_in,
// pub ifra_mask: sockaddr_in,
// pub ifra_vhid:c_int
// }
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct in6_ifreq {
pub ifra_name: [c_char; IFNAMSIZ],
pub ifr_ifru: ifr_ifru_in6,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub union ifr_ifru_in6 {
pub ifru_addr: sockaddr_in6,
pub ifru_dstaddr: sockaddr_in6,
pub ifru_flags: c_int,
pub ifru_flags6: c_int,
pub ifru_metric: c_int,
pub ifru_data: *const c_void,
pub ifru_lifetime: in6_addrlifetime,
pub ifru_stat: in6_ifstat,
pub ifru_icmp6stat: icmp6_ifstat,
pub ifru_scope_id: [u32; 16],
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct in6_addrlifetime {
pub ia6t_expire: time_t, /* valid lifetime expiration time */
pub ia6t_preferred: time_t, /* preferred lifetime expiration time */
pub ia6t_vltime: u32, /* valid lifetime */
pub ia6t_pltime: u32, /* prefix lifetime */
}
#[allow(non_camel_case_types)]
type u_quad_t = u64;
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct in6_ifstat {
pub ifs6_in_receive: u_quad_t, /* # of total input datagram */
pub ifs6_in_hdrerr: u_quad_t, /* # of datagrams with invalid hdr */
pub ifs6_in_toobig: u_quad_t, /* # of datagrams exceeded MTU */
pub ifs6_in_noroute: u_quad_t, /* # of datagrams with no route */
pub ifs6_in_addrerr: u_quad_t, /* # of datagrams with invalid dst */
pub ifs6_in_protounknown: u_quad_t, /* # of datagrams with unknown proto */
/* NOTE: increment on final dst if */
pub ifs6_in_truncated: u_quad_t, /* # of truncated datagrams */
pub ifs6_in_discard: u_quad_t, /* # of discarded datagrams */
/* NOTE: fragment timeout is not here */
pub ifs6_in_deliver: u_quad_t, /* # of datagrams delivered to ULP */
/* NOTE: increment on final dst if */
pub ifs6_out_forward: u_quad_t, /* # of datagrams forwarded */
/* NOTE: increment on outgoing if */
pub ifs6_out_request: u_quad_t, /* # of outgoing datagrams from ULP */
/* NOTE: does not include forwrads */
pub ifs6_out_discard: u_quad_t, /* # of discarded datagrams */
pub ifs6_out_fragok: u_quad_t, /* # of datagrams fragmented */
pub ifs6_out_fragfail: u_quad_t, /* # of datagrams failed on fragment */
pub ifs6_out_fragcreat: u_quad_t, /* # of fragment datagrams */
/* NOTE: this is # after fragment */
pub ifs6_reass_reqd: u_quad_t, /* # of incoming fragmented packets */
/* NOTE: increment on final dst if */
pub ifs6_reass_ok: u_quad_t, /* # of reassembled packets */
/* NOTE: this is # after reass */
/* NOTE: increment on final dst if */
pub ifs6_reass_fail: u_quad_t, /* # of reass failures */
/* NOTE: may not be packet count */
/* NOTE: increment on final dst if */
pub ifs6_in_mcast: u_quad_t, /* # of inbound multicast datagrams */
pub ifs6_out_mcast: u_quad_t, /* # of outbound multicast datagrams */
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct icmp6_ifstat {
/*
* Input statistics
*/
/* ipv6IfIcmpInMsgs, total # of input messages */
pub ifs6_in_msg: u_quad_t,
/* ipv6IfIcmpInErrors, # of input error messages */
pub ifs6_in_error: u_quad_t,
/* ipv6IfIcmpInDestUnreachs, # of input dest unreach errors */
pub ifs6_in_dstunreach: u_quad_t,
/* ipv6IfIcmpInAdminProhibs, # of input administratively prohibited errs */
pub ifs6_in_adminprohib: u_quad_t,
/* ipv6IfIcmpInTimeExcds, # of input time exceeded errors */
pub ifs6_in_timeexceed: u_quad_t,
/* ipv6IfIcmpInParmProblems, # of input parameter problem errors */
pub ifs6_in_paramprob: u_quad_t,
/* ipv6IfIcmpInPktTooBigs, # of input packet too big errors */
pub ifs6_in_pkttoobig: u_quad_t,
/* ipv6IfIcmpInEchos, # of input echo requests */
pub ifs6_in_echo: u_quad_t,
/* ipv6IfIcmpInEchoReplies, # of input echo replies */
pub ifs6_in_echoreply: u_quad_t,
/* ipv6IfIcmpInRouterSolicits, # of input router solicitations */
pub ifs6_in_routersolicit: u_quad_t,
/* ipv6IfIcmpInRouterAdvertisements, # of input router advertisements */
pub ifs6_in_routeradvert: u_quad_t,
/* ipv6IfIcmpInNeighborSolicits, # of input neighbor solicitations */
pub ifs6_in_neighborsolicit: u_quad_t,
/* ipv6IfIcmpInNeighborAdvertisements, # of input neighbor advertisements */
pub ifs6_in_neighboradvert: u_quad_t,
/* ipv6IfIcmpInRedirects, # of input redirects */
pub ifs6_in_redirect: u_quad_t,
/* ipv6IfIcmpInGroupMembQueries, # of input MLD queries */
pub ifs6_in_mldquery: u_quad_t,
/* ipv6IfIcmpInGroupMembResponses, # of input MLD reports */
pub ifs6_in_mldreport: u_quad_t,
/* ipv6IfIcmpInGroupMembReductions, # of input MLD done */
pub ifs6_in_mlddone: u_quad_t,
/*
* Output statistics. We should solve unresolved routing problem...
*/
/* ipv6IfIcmpOutMsgs, total # of output messages */
pub ifs6_out_msg: u_quad_t,
/* ipv6IfIcmpOutErrors, # of output error messages */
pub ifs6_out_error: u_quad_t,
/* ipv6IfIcmpOutDestUnreachs, # of output dest unreach errors */
pub ifs6_out_dstunreach: u_quad_t,
/* ipv6IfIcmpOutAdminProhibs, # of output administratively prohibited errs */
pub ifs6_out_adminprohib: u_quad_t,
/* ipv6IfIcmpOutTimeExcds, # of output time exceeded errors */
pub ifs6_out_timeexceed: u_quad_t,
/* ipv6IfIcmpOutParmProblems, # of output parameter problem errors */
pub ifs6_out_paramprob: u_quad_t,
/* ipv6IfIcmpOutPktTooBigs, # of output packet too big errors */
pub ifs6_out_pkttoobig: u_quad_t,
/* ipv6IfIcmpOutEchos, # of output echo requests */
pub ifs6_out_echo: u_quad_t,
/* ipv6IfIcmpOutEchoReplies, # of output echo replies */
pub ifs6_out_echoreply: u_quad_t,
/* ipv6IfIcmpOutRouterSolicits, # of output router solicitations */
pub ifs6_out_routersolicit: u_quad_t,
/* ipv6IfIcmpOutRouterAdvertisements, # of output router advertisements */
pub ifs6_out_routeradvert: u_quad_t,
/* ipv6IfIcmpOutNeighborSolicits, # of output neighbor solicitations */
pub ifs6_out_neighborsolicit: u_quad_t,
/* ipv6IfIcmpOutNeighborAdvertisements, # of output neighbor advertisements */
pub ifs6_out_neighboradvert: u_quad_t,
/* ipv6IfIcmpOutRedirects, # of output redirects */
pub ifs6_out_redirect: u_quad_t,
/* ipv6IfIcmpOutGroupMembQueries, # of output MLD queries */
pub ifs6_out_mldquery: u_quad_t,
/* ipv6IfIcmpOutGroupMembResponses, # of output MLD reports */
pub ifs6_out_mldreport: u_quad_t,
/* ipv6IfIcmpOutGroupMembReductions, # of output MLD done */
pub ifs6_out_mlddone: u_quad_t,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct in6_ndireq {
pub ifra_name: [c_char; IFNAMSIZ],
pub ndi: nd_ifinfo,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nd_ifinfo {
pub linkmtu: u32,
pub maxmtu: u32,
pub basereachable: u32,
pub reachable: u32,
pub retrans: u32,
pub flags: u32,
pub recalctm: c_int,
pub chlim: u8,
pub initialized: u8,
pub randomseed0: [u8; 8],
pub randomseed1: [u8; 8],
pub randomid: [u8; 8],
}
ioctl_write_ptr!(siocsifflags, b'i', 16, ifreq);
ioctl_readwrite!(siocgifflags, b'i', 17, ifreq);
ioctl_write_ptr!(siocsifaddr, b'i', 12, ifreq);
ioctl_readwrite!(siocgifaddr, b'i', 33, ifreq);
ioctl_write_ptr!(siocsifdstaddr, b'i', 14, ifreq);
ioctl_readwrite!(siocgifdstaddr, b'i', 34, ifreq);
ioctl_write_ptr!(siocsifbrdaddr, b'i', 19, ifreq);
ioctl_readwrite!(siocgifbrdaddr, b'i', 35, ifreq);
ioctl_write_ptr!(siocsifnetmask, b'i', 22, ifreq);
ioctl_readwrite!(siocgifnetmask, b'i', 37, ifreq);
ioctl_write_ptr!(siocsifmtu, b'i', 52, ifreq);
ioctl_readwrite!(siocgifmtu, b'i', 51, ifreq);
ioctl_write_ptr!(siocaifaddr, b'i', 43, ifaliasreq);
ioctl_write_ptr!(siocdifaddr, b'i', 25, ifreq);
ioctl_write_ptr!(siocifcreate, b'i', 122, ifreq);
ioctl_write_ptr!(siocsifphyaddr, b'i', 70, ifaliasreq);
ioctl_write_ptr!(siocsifname, b'i', 40, ifreq);
ioctl_write_ptr!(siocsiflladdr, b'i', 60, ifreq);
ioctl_write_ptr!(siocifdestroy, b'i', 121, ifreq);
ioctl_write_ptr!(siocdifaddr_in6, b'i', 25, in6_ifreq);
ioctl_write_ptr!(siocaifaddr_in6, b'i', 27, in6_ifaliasreq);
ioctl_write_ptr!(sioctunsifhead, b't', 96, c_int);
ioctl_readwrite!(siocsifinfoin6, b'i', 109, in6_ndireq);
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/netbsd/device.rs | src/platform/netbsd/device.rs | use crate::{
builder::{DeviceConfig, Layer},
platform::netbsd::sys::*,
platform::{
unix::{sockaddr_union, Fd, Tun},
ETHER_ADDR_LEN,
},
ToIpv4Address, ToIpv4Netmask, ToIpv6Address, ToIpv6Netmask,
};
use crate::platform::unix::device::{ctl, ctl_v6};
use libc::{self, c_char, c_short, AF_LINK, IFF_RUNNING, IFF_UP, IFNAMSIZ, O_RDWR};
use nix::sys::socket::{LinkAddr, SockaddrLike};
use std::io::ErrorKind;
use std::os::fd::{FromRawFd, IntoRawFd, RawFd};
use std::os::unix::fs::MetadataExt;
use std::{io, mem, net::IpAddr, os::unix::io::AsRawFd, ptr, sync::Mutex};
/// A TUN device using the TUN/TAP Linux driver.
pub struct DeviceImpl {
name: String,
pub(crate) tun: Tun,
pub(crate) op_lock: Mutex<bool>,
}
impl IntoRawFd for DeviceImpl {
fn into_raw_fd(mut self) -> RawFd {
let fd = self.tun.fd.inner;
self.tun.fd.inner = -1;
fd
}
}
impl Drop for DeviceImpl {
fn drop(&mut self) {
if self.tun.fd.inner < 0 {
return;
}
unsafe {
if let (Ok(ctl), Ok(req)) = (ctl(), self.request()) {
libc::close(self.tun.fd.inner);
self.tun.fd.inner = -1;
_ = siocifdestroy(ctl.as_raw_fd(), &req);
}
}
}
}
impl DeviceImpl {
/// Create a new `Device` for the given `Configuration`.
pub(crate) fn new(config: DeviceConfig) -> io::Result<Self> {
let layer = config.layer.unwrap_or(Layer::L3);
let associate_route = if layer == Layer::L3 {
config.associate_route.unwrap_or(true)
} else {
false
};
if let Some(dev_name) = config.dev_name.as_ref() {
Self::check_name(layer, dev_name)?;
if !config.reuse_dev.unwrap_or(true) {
let exists = Self::exists(dev_name)?;
if exists {
return Err(io::Error::new(
ErrorKind::AlreadyExists,
format!("device {dev_name} already exists"),
));
}
}
}
let (dev_fd, name) = match layer {
Layer::L2 => Self::create_tap(config.dev_name)?,
Layer::L3 => Self::create_tun(config.dev_name)?,
};
let tun = Tun::new(dev_fd);
if matches!(layer, Layer::L3) {
Self::enable_tunsifhead_impl(&tun.fd)?;
tun.set_ignore_packet_info(!config.packet_information.unwrap_or(false));
} else {
tun.set_ignore_packet_info(false);
}
Ok(DeviceImpl {
name,
tun,
op_lock: Mutex::new(associate_route),
})
}
fn check_name(layer: Layer, dev_name: &str) -> io::Result<()> {
if dev_name.len() > IFNAMSIZ {
return Err(io::Error::new(
ErrorKind::InvalidInput,
"device name too long",
));
}
let device_prefix = match layer {
Layer::L2 => "tap",
Layer::L3 => "tun",
};
if !dev_name.starts_with(device_prefix) {
Err(io::Error::new(
ErrorKind::InvalidInput,
format!("device name must start with {device_prefix}"),
))
} else {
Ok(())
}
}
fn create_tap(dev_name: Option<String>) -> io::Result<(Fd, String)> {
let device_prefix = "tap";
if let Some(dev_name) = dev_name {
if let Err(e) = DeviceImpl::create_dev(&dev_name) {
if e.kind() != ErrorKind::AlreadyExists {
return Err(e);
}
}
let if_index = dev_name[3..]
.parse::<u32>()
.map_err(|e| io::Error::new(ErrorKind::InvalidInput, e))?;
let device_path = format!("/dev/{device_prefix}{if_index}\0");
let fd = Self::open_and_makedev_dev(&dev_name, &device_path)?;
Ok((fd, dev_name))
} else {
let device_path = format!("/dev/{device_prefix}\0");
let fd =
unsafe { libc::open(device_path.as_ptr() as *const _, O_RDWR | libc::O_CLOEXEC) };
let fd = Fd::new(fd)?;
unsafe {
let mut req: ifreq = mem::zeroed();
if let Err(err) = tapgifname(fd.as_raw_fd(), &mut req) {
return Err(io::Error::from(err));
}
let cstr = std::ffi::CStr::from_ptr(req.ifr_name.as_ptr());
let dev_name = cstr.to_string_lossy().to_string();
Ok((fd, dev_name))
}
}
}
fn create_tun(dev_name: Option<String>) -> io::Result<(Fd, String)> {
let device_prefix = "tun";
if let Some(dev_name) = dev_name {
let if_index = dev_name[3..]
.parse::<u32>()
.map_err(|e| io::Error::new(ErrorKind::InvalidInput, e))?;
let device_path = format!("/dev/{device_prefix}{if_index}\0");
let fd = Self::open_and_makedev_dev(&dev_name, &device_path)?;
Ok((fd, dev_name))
} else {
for index in 0..256 {
let dev_name = format!("{device_prefix}{index}");
let device_path = format!("/dev/{device_prefix}{index}\0");
match Self::open_and_makedev_dev(&dev_name, &device_path) {
Ok(dev) => {
return Ok((dev, dev_name));
}
Err(e) => {
if e.raw_os_error() != Some(libc::EBUSY) {
return Err(e);
}
}
}
}
Err(io::Error::last_os_error())
}
}
fn open_and_makedev_dev(dev_name: &str, device_path: &str) -> io::Result<Fd> {
let fd = unsafe { libc::open(device_path.as_ptr() as *const _, O_RDWR | libc::O_CLOEXEC) };
match Fd::new(fd) {
Ok(fd) => Ok(fd),
Err(ref e) if e.kind() == ErrorKind::NotFound => {
DeviceImpl::makedev_dev(dev_name)?;
let fd = unsafe {
libc::open(device_path.as_ptr() as *const _, O_RDWR | libc::O_CLOEXEC)
};
Ok(Fd::new(fd)?)
}
Err(e) => Err(e),
}
}
fn makedev_dev(name: &str) -> io::Result<()> {
let status = std::process::Command::new("sh")
.arg("MAKEDEV")
.arg(name)
.current_dir("/dev")
.status()?;
if status.success() {
Ok(())
} else {
Err(io::Error::other(format!(
"MAKEDEV {} failed with status {:?}",
name,
status.code()
)))
}
}
fn create_dev(name: &str) -> io::Result<()> {
unsafe {
let mut req: ifreq = mem::zeroed();
ptr::copy_nonoverlapping(
name.as_ptr() as *const c_char,
req.ifr_name.as_mut_ptr(),
name.len(),
);
if let Err(err) = siocifcreate(ctl()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
}
Ok(())
}
fn exists(dev_name: &str) -> io::Result<bool> {
unsafe {
let mut req: ifreq = mem::zeroed();
ptr::copy_nonoverlapping(
dev_name.as_ptr() as *const c_char,
req.ifr_name.as_mut_ptr(),
dev_name.len(),
);
let ctl = ctl()?;
if let Err(err) = siocgifflags(ctl.as_raw_fd(), &mut req) {
if err == nix::errno::Errno::ENXIO {
return Ok(false);
}
Err(io::Error::from(err))
} else {
Ok(true)
}
}
}
pub(crate) fn from_tun(tun: Tun) -> io::Result<Self> {
let name = Self::name_of_fd(tun.as_raw_fd())?;
if name.starts_with("tap") {
// Tap does not have PI
tun.set_ignore_packet_info(false);
} else {
Self::enable_tunsifhead_impl(&tun.fd)?;
tun.set_ignore_packet_info(true);
}
Ok(Self {
name,
tun,
op_lock: Mutex::new(true),
})
}
fn enable_tunsifhead_impl(device_fd: &Fd) -> std::io::Result<()> {
unsafe {
if let Err(err) = sioctunsifhead(device_fd.as_raw_fd(), &1 as *const _) {
return Err(io::Error::from(err));
}
}
Ok(())
}
fn calc_dest_addr(&self, addr: IpAddr, netmask: IpAddr) -> io::Result<IpAddr> {
let prefix_len = ipnet::ip_mask_to_prefix(netmask)
.map_err(|e| io::Error::new(ErrorKind::InvalidInput, e))?;
Ok(ipnet::IpNet::new(addr, prefix_len)
.map_err(|e| io::Error::new(ErrorKind::InvalidInput, e))?
.broadcast())
}
/// Set the IPv4 alias of the device.
fn add_address(
&self,
addr: IpAddr,
mask: IpAddr,
dest: Option<IpAddr>,
associate_route: bool,
) -> io::Result<()> {
unsafe {
match (addr, mask) {
(IpAddr::V4(addr), IpAddr::V4(mask)) => {
let ctl = ctl()?;
let mut req: ifaliasreq = mem::zeroed();
let tun_name = self.name_impl()?;
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifra_name.as_mut_ptr(),
tun_name.len(),
);
req.ifra_addr = crate::platform::unix::sockaddr_union::from((addr, 0)).addr;
if let Some(dest) = dest {
req.ifra_dstaddr =
crate::platform::unix::sockaddr_union::from((dest, 0)).addr;
}
req.ifra_mask = crate::platform::unix::sockaddr_union::from((mask, 0)).addr;
if let Err(err) = siocaifaddr(ctl.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
if let Err(e) = self.add_route(addr.into(), mask.into(), associate_route) {
log::warn!("{e:?}");
}
}
(IpAddr::V6(addr), IpAddr::V6(mask)) => {
let tun_name = self.name_impl()?;
let mut req: in6_aliasreq = mem::zeroed();
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifra_name.as_mut_ptr(),
tun_name.len(),
);
req.ifra_addr = sockaddr_union::from((addr, 0)).addr6;
req.ifra_prefixmask = sockaddr_union::from((mask, 0)).addr6;
req.ifra_lifetime.ia6t_vltime = 0xffffffff_u32;
req.ifra_lifetime.ia6t_pltime = 0xffffffff_u32;
// req.ifra_flags = IN6_IFF_NODAD;
if let Err(err) = siocaifaddr_in6(ctl_v6()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
}
_ => {
unreachable!();
}
}
Ok(())
}
}
/// Prepare a new request.
unsafe fn request(&self) -> io::Result<ifreq> {
let mut req: ifreq = mem::zeroed();
let tun_name = self.name_impl()?;
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifr_name.as_mut_ptr(),
tun_name.len(),
);
Ok(req)
}
/// # Safety
unsafe fn request_v6(&self) -> io::Result<in6_ifreq> {
let tun_name = self.name_impl()?;
let mut req: in6_ifreq = mem::zeroed();
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifra_name.as_mut_ptr(),
tun_name.len(),
);
req.ifr_ifru.ifru_flags = IN6_IFF_NODAD as _;
Ok(req)
}
fn add_route(&self, addr: IpAddr, netmask: IpAddr, associate_route: bool) -> io::Result<()> {
if !associate_route {
return Ok(());
}
let if_index = self.if_index_impl()?;
let prefix_len = ipnet::ip_mask_to_prefix(netmask)
.map_err(|e| io::Error::new(ErrorKind::InvalidInput, e))?;
let mut manager = route_manager::RouteManager::new()?;
let route = route_manager::Route::new(addr, prefix_len).with_if_index(if_index);
manager.add(&route)?;
Ok(())
}
/// Retrieves the name of the network interface.
pub(crate) fn name_impl(&self) -> io::Result<String> {
Ok(self.name.clone())
}
fn name_of_fd(tun: RawFd) -> io::Result<String> {
unsafe {
let mut req: ifreq = mem::zeroed();
if tapgifname(tun, &mut req).is_ok() {
let cstr = std::ffi::CStr::from_ptr(req.ifr_name.as_ptr());
let dev_name = cstr.to_string_lossy().to_string();
// tap
return Ok(dev_name);
}
}
let file = unsafe { std::fs::File::from_raw_fd(tun) };
let metadata = file.metadata()?;
let rdev = metadata.rdev();
let index = rdev % 256;
std::mem::forget(file); // prevent fd being closed
Ok(format!("tun{index}"))
}
fn remove_all_address_v4(&self) -> io::Result<()> {
unsafe {
let req_v4 = self.request()?;
loop {
if let Err(err) = siocdifaddr(ctl()?.as_raw_fd(), &req_v4) {
if err == nix::errno::Errno::EADDRNOTAVAIL {
break;
}
return Err(io::Error::from(err));
}
}
}
Ok(())
}
}
// Public User Interface
impl DeviceImpl {
/// Retrieves the name of the network interface.
pub fn name(&self) -> io::Result<String> {
let _guard = self.op_lock.lock().unwrap();
self.name_impl()
}
/// If false, the program will not modify or manage routes in any way, allowing the system to handle all routing natively.
/// If true (default), the program will automatically add or remove routes to provide consistent routing behavior across all platforms.
/// Set this to be false to obtain the platform's default routing behavior.
pub fn set_associate_route(&self, associate_route: bool) {
*self.op_lock.lock().unwrap() = associate_route;
}
/// Retrieve whether route is associated with the IP setting interface, see [`DeviceImpl::set_associate_route`]
pub fn associate_route(&self) -> bool {
*self.op_lock.lock().unwrap()
}
/// Enables or disables the network interface.
pub fn enabled(&self, value: bool) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req = self.request()?;
let ctl = ctl()?;
if let Err(err) = siocgifflags(ctl.as_raw_fd(), &mut req) {
return Err(io::Error::from(err));
}
if value {
req.ifr_ifru.ifru_flags |= (IFF_UP | IFF_RUNNING) as c_short;
} else {
req.ifr_ifru.ifru_flags &= !(IFF_UP as c_short);
}
if let Err(err) = siocsifflags(ctl.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
/// Retrieves the current MTU (Maximum Transmission Unit) for the interface.
pub fn mtu(&self) -> io::Result<u16> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req: ifreq = mem::zeroed();
let tun_name = self.name_impl()?;
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifr_name.as_mut_ptr(),
tun_name.len(),
);
if let Err(err) = siocgifmtu(ctl()?.as_raw_fd(), &mut req) {
return Err(io::Error::from(err));
}
let r: u16 = req.ifr_ifru.ifru_mtu.try_into().map_err(io::Error::other)?;
Ok(r)
}
}
/// Sets the MTU (Maximum Transmission Unit) for the interface.
/// # Note
/// The specified value must be less than or equal to `1500`; it's a limitation of NetBSD.
pub fn set_mtu(&self, value: u16) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req: ifreq = mem::zeroed();
let tun_name = self.name_impl()?;
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifr_name.as_mut_ptr(),
tun_name.len(),
);
req.ifr_ifru.ifru_mtu = value as _;
if let Err(err) = siocsifmtu(ctl()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
/// Sets the IPv4 network address, netmask, and an optional destination address.
/// Remove all previous set IPv4 addresses and set the specified address.
pub fn set_network_address<IPv4: ToIpv4Address, Netmask: ToIpv4Netmask>(
&self,
address: IPv4,
netmask: Netmask,
destination: Option<IPv4>,
) -> io::Result<()> {
let guard = self.op_lock.lock().unwrap();
let addr = address.ipv4()?.into();
let netmask = netmask.netmask()?.into();
let default_dest = self.calc_dest_addr(addr, netmask)?;
let dest = destination
.map(|d| d.ipv4())
.transpose()?
.map(|v| v.into())
.unwrap_or(default_dest);
self.remove_all_address_v4()?;
self.add_address(addr, netmask, Some(dest), *guard)?;
Ok(())
}
/// Add IPv4 network address, netmask
pub fn add_address_v4<IPv4: ToIpv4Address, Netmask: ToIpv4Netmask>(
&self,
address: IPv4,
netmask: Netmask,
) -> io::Result<()> {
let guard = self.op_lock.lock().unwrap();
let addr = address.ipv4()?.into();
let netmask = netmask.netmask()?.into();
let dest = self.calc_dest_addr(addr, netmask)?;
self.add_address(addr, netmask, Some(dest), *guard)?;
Ok(())
}
/// Removes an IP address from the interface.
pub fn remove_address(&self, addr: IpAddr) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
match addr {
IpAddr::V4(addr) => {
let mut req_v4 = self.request()?;
req_v4.ifr_ifru.ifru_addr = sockaddr_union::from((addr, 0)).addr;
if let Err(err) = siocdifaddr(ctl()?.as_raw_fd(), &req_v4) {
return Err(io::Error::from(err));
}
}
IpAddr::V6(addr) => {
let mut req_v6 = self.request_v6()?;
req_v6.ifr_ifru.ifru_addr = sockaddr_union::from((addr, 0)).addr6;
if let Err(err) = siocdifaddr_in6(ctl_v6()?.as_raw_fd(), &req_v6) {
return Err(io::Error::from(err));
}
}
}
Ok(())
}
}
/// Adds an IPv6 address to the interface.
pub fn add_address_v6<IPv6: ToIpv6Address, Netmask: ToIpv6Netmask>(
&self,
addr: IPv6,
netmask: Netmask,
) -> io::Result<()> {
let guard = self.op_lock.lock().unwrap();
let addr = addr.ipv6()?;
let netmask = netmask.netmask()?;
self.add_address(addr.into(), netmask.into(), None, *guard)
}
/// Sets the MAC (hardware) address for the interface.
///
/// This function constructs an interface request and copies the provided MAC address
/// into the hardware address field. It then applies the change via a system call.
/// This operation is typically supported only for TAP devices.
pub fn set_mac_address(&self, eth_addr: [u8; ETHER_ADDR_LEN as usize]) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
unsafe {
let mut req: ifaliasreq = mem::zeroed();
let tun_name = self.name_impl()?;
ptr::copy_nonoverlapping(
tun_name.as_ptr() as *const c_char,
req.ifra_name.as_mut_ptr(),
tun_name.len(),
);
req.ifra_addr.sa_len = ETHER_ADDR_LEN;
req.ifra_addr.sa_family = AF_LINK as u8;
req.ifra_addr.sa_data[0..ETHER_ADDR_LEN as usize]
.copy_from_slice(eth_addr.map(|c| c as i8).as_slice());
if let Err(err) = siocsifphyaddr(ctl()?.as_raw_fd(), &req) {
return Err(io::Error::from(err));
}
Ok(())
}
}
/// Retrieves the MAC (hardware) address of the interface.
///
/// This function queries the MAC address by the interface name using a helper function.
/// An error is returned if the MAC address cannot be found.
pub fn mac_address(&self) -> io::Result<[u8; ETHER_ADDR_LEN as usize]> {
let _guard = self.op_lock.lock().unwrap();
let name = self.name_impl()?;
let interfaces = nix::ifaddrs::getifaddrs()?;
let interfaces = interfaces.filter(|item| item.interface_name == name);
for addr in interfaces {
if let Some(address) = addr.address {
if address.family() == Some(nix::sys::socket::AddressFamily::Link) {
// This is a workaround, but it's safe because `SockaddrStorage` is a union whose layout is represented by C.
// So, casting from `SockaddrStorage` to its variant thereof is safe.
// The `if` condition ensures that the dereferencing of the resulting pointer gets a valid value of `LinkAddr`.
// However, it is preferred to use `as_link_addr` once `nix` fixes it.
unsafe {
let link_ptr = &address as *const _ as *const LinkAddr;
if let Some(mac) = (*link_ptr).addr() {
return Ok(mac);
}
}
}
}
}
Err(std::io::Error::other("Unable to get Mac address"))
}
/// In Layer3(i.e. TUN mode), we need to put the tun interface into "multi_af" mode, which will prepend the address
/// family to all packets (same as FreeBSD).
/// If this is not enabled, the kernel silently drops all IPv6 packets on output and gets confused on input.
pub fn enable_tunsifhead(&self) -> io::Result<()> {
let _guard = self.op_lock.lock().unwrap();
Self::enable_tunsifhead_impl(&self.tun.fd)
}
/// Returns whether the TUN device is set to ignore packet information (PI).
///
/// When enabled, the device does not prepend the `struct tun_pi` header
/// to packets, which can simplify packet processing in some cases.
///
/// # Returns
/// * `true` - The TUN device ignores packet information.
/// * `false` - The TUN device includes packet information.
/// # Note
/// Retrieve whether the packet is ignored for the TUN Device; The TAP device always returns `false`.
pub fn ignore_packet_info(&self) -> bool {
let _guard = self.op_lock.lock().unwrap();
self.tun.ignore_packet_info()
}
/// Sets whether the TUN device should ignore packet information (PI).
///
/// When `ignore_packet_info` is set to `true`, the TUN device does not
/// prepend the `struct tun_pi` header to packets. This can be useful
/// if the additional metadata is not needed.
///
/// # Parameters
/// * `ign`
/// - If `true`, the TUN device will ignore packet information.
/// - If `false`, it will include packet information.
/// # Note
/// This only works for a TUN device; The invocation will be ignored if the device is a TAP.
pub fn set_ignore_packet_info(&self, ign: bool) {
let _guard = self.op_lock.lock().unwrap();
if let Ok(name) = self.name_impl() {
if name.starts_with("tun") {
self.tun.set_ignore_packet_info(ign)
}
}
}
}
impl From<Layer> for c_short {
fn from(layer: Layer) -> Self {
match layer {
Layer::L2 => 2,
Layer::L3 => 3,
}
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/netbsd/mod.rs | src/platform/netbsd/mod.rs | mod sys;
mod device;
pub use self::device::DeviceImpl;
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/src/platform/netbsd/sys.rs | src/platform/netbsd/sys.rs | use libc::{c_char, c_int, c_uint, sockaddr, sockaddr_in6, sockaddr_storage, time_t, IFNAMSIZ};
use nix::{ioctl_read, ioctl_readwrite, ioctl_write_ptr};
use std::ffi::c_void;
// https://github.com/justincormack/netbsd-src/blob/master/src/sys/sys/sockio.h
// https://github.com/justincormack/netbsd-src/blob/master/src/sys/net/if.h
pub const IN6_IFF_NODAD: i32 = 0x0020;
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ifreq {
pub ifr_name: [c_char; IFNAMSIZ],
pub ifr_ifru: ifr_ifru,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub union ifr_ifru {
pub ifru_addr: sockaddr,
pub ifru_dstaddr: sockaddr,
pub ifru_broadaddr: sockaddr,
pub ifru_space: sockaddr_storage,
pub ifru_flags: libc::c_short,
pub ifru_addrflags: libc::c_int,
pub ifru_metric: libc::c_int,
pub ifru_mtu: libc::c_int,
pub ifru_dlt: libc::c_int,
pub ifru_value: libc::c_uint,
pub ifru_data: *mut c_void,
pub ifru_b: ifru_b,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ifru_b {
pub b_buflen: u32,
pub b_buf: *mut c_void,
}
#[allow(dead_code)]
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ctl_info {
pub ctl_id: c_uint,
pub ctl_name: [c_char; 96],
}
#[allow(dead_code)]
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub union ifra_ifrau {
pub ifrau_addr: sockaddr,
pub ifrau_align: c_int,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ifaliasreq {
pub ifra_name: [c_char; IFNAMSIZ],
pub ifra_addr: sockaddr,
pub ifra_dstaddr: sockaddr, // == ifra_broadaddr
pub ifra_mask: sockaddr,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct in6_aliasreq {
pub ifra_name: [c_char; IFNAMSIZ],
pub ifra_addr: sockaddr_in6,
pub ifra_dstaddr: sockaddr_in6,
pub ifra_prefixmask: sockaddr_in6,
pub ifra_flags: c_int,
pub ifra_lifetime: in6_addrlifetime,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct in6_ifreq {
pub ifra_name: [c_char; IFNAMSIZ],
pub ifr_ifru: ifr_ifru_in6,
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub union ifr_ifru_in6 {
pub ifru_addr: sockaddr_in6,
pub ifru_dstaddr: sockaddr_in6,
pub ifru_flags: c_int,
pub ifru_flags6: c_int,
pub ifru_metric: c_int,
pub ifru_data: *const c_void,
pub ifru_lifetime: in6_addrlifetime,
pub ifru_stat: in6_ifstat,
pub ifru_icmp6stat: icmp6_ifstat,
pub ifru_scope_id: [u32; 16],
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct in6_addrlifetime {
pub ia6t_expire: time_t, /* valid lifetime expiration time */
pub ia6t_preferred: time_t, /* preferred lifetime expiration time */
pub ia6t_vltime: u32, /* valid lifetime */
pub ia6t_pltime: u32, /* prefix lifetime */
}
#[allow(non_camel_case_types)]
type u_quad_t = u64;
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct in6_ifstat {
pub ifs6_in_receive: u_quad_t, /* # of total input datagram */
pub ifs6_in_hdrerr: u_quad_t, /* # of datagrams with invalid hdr */
pub ifs6_in_toobig: u_quad_t, /* # of datagrams exceeded MTU */
pub ifs6_in_noroute: u_quad_t, /* # of datagrams with no route */
pub ifs6_in_addrerr: u_quad_t, /* # of datagrams with invalid dst */
pub ifs6_in_protounknown: u_quad_t, /* # of datagrams with unknown proto */
/* NOTE: increment on final dst if */
pub ifs6_in_truncated: u_quad_t, /* # of truncated datagrams */
pub ifs6_in_discard: u_quad_t, /* # of discarded datagrams */
/* NOTE: fragment timeout is not here */
pub ifs6_in_deliver: u_quad_t, /* # of datagrams delivered to ULP */
/* NOTE: increment on final dst if */
pub ifs6_out_forward: u_quad_t, /* # of datagrams forwarded */
/* NOTE: increment on outgoing if */
pub ifs6_out_request: u_quad_t, /* # of outgoing datagrams from ULP */
/* NOTE: does not include forwrads */
pub ifs6_out_discard: u_quad_t, /* # of discarded datagrams */
pub ifs6_out_fragok: u_quad_t, /* # of datagrams fragmented */
pub ifs6_out_fragfail: u_quad_t, /* # of datagrams failed on fragment */
pub ifs6_out_fragcreat: u_quad_t, /* # of fragment datagrams */
/* NOTE: this is # after fragment */
pub ifs6_reass_reqd: u_quad_t, /* # of incoming fragmented packets */
/* NOTE: increment on final dst if */
pub ifs6_reass_ok: u_quad_t, /* # of reassembled packets */
/* NOTE: this is # after reass */
/* NOTE: increment on final dst if */
pub ifs6_reass_fail: u_quad_t, /* # of reass failures */
/* NOTE: may not be packet count */
/* NOTE: increment on final dst if */
pub ifs6_in_mcast: u_quad_t, /* # of inbound multicast datagrams */
pub ifs6_out_mcast: u_quad_t, /* # of outbound multicast datagrams */
}
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct icmp6_ifstat {
/*
* Input statistics
*/
/* ipv6IfIcmpInMsgs, total # of input messages */
pub ifs6_in_msg: u_quad_t,
/* ipv6IfIcmpInErrors, # of input error messages */
pub ifs6_in_error: u_quad_t,
/* ipv6IfIcmpInDestUnreachs, # of input dest unreach errors */
pub ifs6_in_dstunreach: u_quad_t,
/* ipv6IfIcmpInAdminProhibs, # of input administratively prohibited errs */
pub ifs6_in_adminprohib: u_quad_t,
/* ipv6IfIcmpInTimeExcds, # of input time exceeded errors */
pub ifs6_in_timeexceed: u_quad_t,
/* ipv6IfIcmpInParmProblems, # of input parameter problem errors */
pub ifs6_in_paramprob: u_quad_t,
/* ipv6IfIcmpInPktTooBigs, # of input packet too big errors */
pub ifs6_in_pkttoobig: u_quad_t,
/* ipv6IfIcmpInEchos, # of input echo requests */
pub ifs6_in_echo: u_quad_t,
/* ipv6IfIcmpInEchoReplies, # of input echo replies */
pub ifs6_in_echoreply: u_quad_t,
/* ipv6IfIcmpInRouterSolicits, # of input router solicitations */
pub ifs6_in_routersolicit: u_quad_t,
/* ipv6IfIcmpInRouterAdvertisements, # of input router advertisements */
pub ifs6_in_routeradvert: u_quad_t,
/* ipv6IfIcmpInNeighborSolicits, # of input neighbor solicitations */
pub ifs6_in_neighborsolicit: u_quad_t,
/* ipv6IfIcmpInNeighborAdvertisements, # of input neighbor advertisements */
pub ifs6_in_neighboradvert: u_quad_t,
/* ipv6IfIcmpInRedirects, # of input redirects */
pub ifs6_in_redirect: u_quad_t,
/* ipv6IfIcmpInGroupMembQueries, # of input MLD queries */
pub ifs6_in_mldquery: u_quad_t,
/* ipv6IfIcmpInGroupMembResponses, # of input MLD reports */
pub ifs6_in_mldreport: u_quad_t,
/* ipv6IfIcmpInGroupMembReductions, # of input MLD done */
pub ifs6_in_mlddone: u_quad_t,
/*
* Output statistics. We should solve unresolved routing problem...
*/
/* ipv6IfIcmpOutMsgs, total # of output messages */
pub ifs6_out_msg: u_quad_t,
/* ipv6IfIcmpOutErrors, # of output error messages */
pub ifs6_out_error: u_quad_t,
/* ipv6IfIcmpOutDestUnreachs, # of output dest unreach errors */
pub ifs6_out_dstunreach: u_quad_t,
/* ipv6IfIcmpOutAdminProhibs, # of output administratively prohibited errs */
pub ifs6_out_adminprohib: u_quad_t,
/* ipv6IfIcmpOutTimeExcds, # of output time exceeded errors */
pub ifs6_out_timeexceed: u_quad_t,
/* ipv6IfIcmpOutParmProblems, # of output parameter problem errors */
pub ifs6_out_paramprob: u_quad_t,
/* ipv6IfIcmpOutPktTooBigs, # of output packet too big errors */
pub ifs6_out_pkttoobig: u_quad_t,
/* ipv6IfIcmpOutEchos, # of output echo requests */
pub ifs6_out_echo: u_quad_t,
/* ipv6IfIcmpOutEchoReplies, # of output echo replies */
pub ifs6_out_echoreply: u_quad_t,
/* ipv6IfIcmpOutRouterSolicits, # of output router solicitations */
pub ifs6_out_routersolicit: u_quad_t,
/* ipv6IfIcmpOutRouterAdvertisements, # of output router advertisements */
pub ifs6_out_routeradvert: u_quad_t,
/* ipv6IfIcmpOutNeighborSolicits, # of output neighbor solicitations */
pub ifs6_out_neighborsolicit: u_quad_t,
/* ipv6IfIcmpOutNeighborAdvertisements, # of output neighbor advertisements */
pub ifs6_out_neighboradvert: u_quad_t,
/* ipv6IfIcmpOutRedirects, # of output redirects */
pub ifs6_out_redirect: u_quad_t,
/* ipv6IfIcmpOutGroupMembQueries, # of output MLD queries */
pub ifs6_out_mldquery: u_quad_t,
/* ipv6IfIcmpOutGroupMembResponses, # of output MLD reports */
pub ifs6_out_mldreport: u_quad_t,
/* ipv6IfIcmpOutGroupMembReductions, # of output MLD done */
pub ifs6_out_mlddone: u_quad_t,
}
// https://github.com/openbsd/src/blob/25ed657ec9c4285c385bc3b3556c0dc8eb6d6665/sys/sys/sockio.h#L114
ioctl_write_ptr!(siocsifflags, b'i', 16, ifreq);
ioctl_readwrite!(siocgifflags, b'i', 17, ifreq);
ioctl_write_ptr!(siocsifaddr, b'i', 12, ifreq);
ioctl_readwrite!(siocgifaddr, b'i', 33, ifreq);
ioctl_write_ptr!(siocsifdstaddr, b'i', 14, ifreq);
ioctl_readwrite!(siocgifdstaddr, b'i', 34, ifreq);
ioctl_write_ptr!(siocsifbrdaddr, b'i', 19, ifreq);
ioctl_readwrite!(siocgifbrdaddr, b'i', 35, ifreq);
ioctl_write_ptr!(siocsifnetmask, b'i', 22, ifreq);
ioctl_readwrite!(siocgifnetmask, b'i', 37, ifreq);
ioctl_write_ptr!(siocsifmtu, b'i', 127, ifreq);
ioctl_readwrite!(siocgifmtu, b'i', 126, ifreq);
ioctl_write_ptr!(siocaifaddr, b'i', 26, ifaliasreq);
ioctl_write_ptr!(siocdifaddr, b'i', 25, ifreq);
ioctl_write_ptr!(siocsifphyaddr, b'i', 70, ifaliasreq);
ioctl_write_ptr!(siocdifaddr_in6, b'i', 25, in6_ifreq);
ioctl_write_ptr!(siocaifaddr_in6, b'i', 107, in6_aliasreq);
ioctl_write_ptr!(siocifdestroy, b'i', 121, ifreq);
ioctl_write_ptr!(siocifcreate, b'i', 122, ifreq);
ioctl_read!(tapgifname, b'e', 0, ifreq);
// http://fxr.watson.org/fxr/source/net/if_tun.h?v=NETBSD
ioctl_write_ptr!(sioctunsifhead, b't', 66, c_int);
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/tests/test_dev.rs | tests/test_dev.rs | #![allow(unused_imports)]
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::Arc;
use std::time::Duration;
use pnet_packet::ip::IpNextHeaderProtocols;
use pnet_packet::Packet;
#[cfg(any(
target_os = "windows",
target_os = "macos",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
use tun_rs::DeviceBuilder;
use tun_rs::SyncDevice;
#[cfg(any(
target_os = "windows",
target_os = "macos",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
#[cfg(not(any(feature = "async_tokio", feature = "async_io")))]
#[test]
fn test_udp_v4() {
let test_msg = "test udp";
let device = DeviceBuilder::new()
.ipv4("10.26.1.100", 24, None)
.build_sync()
.unwrap();
let device = Arc::new(device);
let _device = device.clone();
let test_udp_v4 = Arc::new(AtomicBool::new(false));
let test_udp_v4_c = test_udp_v4.clone();
let recv_flag = Arc::new(AtomicBool::new(false));
let recv_flag_c = recv_flag.clone();
std::thread::spawn(move || {
let mut buf = [0; 65535];
loop {
let len = device.recv(&mut buf).unwrap();
if let Some(ipv4_packet) = pnet_packet::ipv4::Ipv4Packet::new(&buf[..len]) {
if ipv4_packet.get_next_level_protocol() == IpNextHeaderProtocols::Udp {
if let Some(udp_packet) =
pnet_packet::udp::UdpPacket::new(ipv4_packet.payload())
{
if udp_packet.payload() == test_msg.as_bytes() {
test_udp_v4.store(true, Ordering::Relaxed);
}
}
}
}
if test_udp_v4.load(Ordering::Relaxed) {
recv_flag.store(true, Ordering::Release);
break;
}
}
});
std::thread::sleep(Duration::from_secs(6));
let udp_socket = std::net::UdpSocket::bind("10.26.1.100:0").unwrap();
udp_socket
.send_to(test_msg.as_bytes(), "10.26.1.101:8080")
.unwrap();
let time_now = std::time::Instant::now();
// check whether the thread completes
while !recv_flag_c.load(Ordering::Acquire) {
if time_now.elapsed().as_secs() > 2 {
// no promise due to the timeout
let v4 = test_udp_v4_c.load(Ordering::Relaxed);
assert!(v4, "timeout: test_udp_v4 = {v4}");
return;
}
}
// recv_flag_c == true
// all modifications to test_udp_v4_c must be visible
let v4 = test_udp_v4_c.load(Ordering::Relaxed);
assert!(v4);
}
#[cfg(any(
target_os = "windows",
target_os = "macos",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
#[cfg(not(any(feature = "async_tokio", feature = "async_io")))]
#[test]
fn test_udp_v6() {
let test_msg = "test udp";
let device = DeviceBuilder::new()
.ipv6("fd12:3456:789a:1111:2222:3333:4444:5555", 64)
.build_sync()
.unwrap();
let device = Arc::new(device);
let _device = device.clone();
let test_udp_v6 = Arc::new(AtomicBool::new(false));
let test_udp_v6_c = test_udp_v6.clone();
let recv_flag = Arc::new(AtomicBool::new(false));
let recv_flag_c = recv_flag.clone();
std::thread::spawn(move || {
let mut buf = [0; 65535];
loop {
let len = device.recv(&mut buf).unwrap();
if let Some(ipv6_packet) = pnet_packet::ipv6::Ipv6Packet::new(&buf[..len]) {
if ipv6_packet.get_next_header() == IpNextHeaderProtocols::Udp {
if let Some(udp_packet) =
pnet_packet::udp::UdpPacket::new(ipv6_packet.payload())
{
if udp_packet.payload() == test_msg.as_bytes() {
test_udp_v6.store(true, Ordering::Relaxed);
}
}
}
}
if test_udp_v6.load(Ordering::Relaxed) {
recv_flag.store(true, Ordering::Release);
break;
}
}
});
std::thread::sleep(Duration::from_secs(6));
let udp_socket =
std::net::UdpSocket::bind("[fd12:3456:789a:1111:2222:3333:4444:5555]:0").unwrap();
udp_socket
.send_to(
test_msg.as_bytes(),
"[fd12:3456:789a:1111:2222:3333:4444:5556]:8080",
)
.unwrap();
let time_now = std::time::Instant::now();
// check whether the thread completes
while !recv_flag_c.load(Ordering::Acquire) {
if time_now.elapsed().as_secs() > 2 {
// no promise due to the timeout
let v6 = test_udp_v6_c.load(Ordering::Relaxed);
assert!(v6, "timeout: test_udp_v6 = {v6}");
return;
}
}
// recv_flag_c == true
// all modifications to test_udp_v6_c must be visible
let v6 = test_udp_v6_c.load(Ordering::Relaxed);
assert!(v6);
}
#[cfg(any(
target_os = "windows",
target_os = "macos",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
#[cfg(feature = "async_tokio")]
#[tokio::test]
async fn test_udp_v4() {
let test_msg = "test udp";
let device = DeviceBuilder::new()
.ipv4("10.26.1.100", 24, None)
.build_async()
.unwrap();
let device = Arc::new(device);
let _device = device.clone();
let test_udp_v4 = Arc::new(AtomicBool::new(false));
let test_udp_v4_c = test_udp_v4.clone();
let recv_flag = Arc::new(AtomicBool::new(false));
let recv_flag_c = recv_flag.clone();
let handler = tokio::spawn(async move {
let mut buf = [0; 65535];
loop {
let len = device.recv(&mut buf).await.unwrap();
if let Some(ipv4_packet) = pnet_packet::ipv4::Ipv4Packet::new(&buf[..len]) {
if ipv4_packet.get_next_level_protocol() == IpNextHeaderProtocols::Udp {
if let Some(udp_packet) =
pnet_packet::udp::UdpPacket::new(ipv4_packet.payload())
{
if udp_packet.payload() == test_msg.as_bytes() {
test_udp_v4.store(true, Ordering::Relaxed);
}
}
}
}
if test_udp_v4.load(Ordering::Relaxed) {
recv_flag.store(true, Ordering::Release);
break;
}
}
});
tokio::time::sleep(Duration::from_secs(6)).await;
let udp_socket = tokio::net::UdpSocket::bind("10.26.1.200:0").await.unwrap();
udp_socket
.send_to(test_msg.as_bytes(), "10.26.1.101:8080")
.await
.unwrap();
tokio::select! {
_=tokio::time::sleep(Duration::from_secs(2))=>{
// no promise due to the timeout
let v4 = test_udp_v4_c.load(Ordering::Relaxed);
assert!(v4, "timeout: test_udp_v4 = {v4}");
}
_=handler=>{
// all modifications to test_udp_v4_c and test_udp_v6_c must be visible
let flag = recv_flag_c.load(Ordering::Acquire); //synchronize
assert!(flag, "recv_flag = {flag}");
let v4 = test_udp_v4_c.load(Ordering::Relaxed);
assert!(v4);
}
}
}
#[cfg(any(
target_os = "windows",
target_os = "macos",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
#[cfg(feature = "async_tokio")]
#[tokio::test]
async fn test_udp_v6() {
let test_msg = "test udp";
let device = DeviceBuilder::new()
.ipv6("fd12:3456:789a:1111:2222:3333:4444:5555", 64)
.build_async()
.unwrap();
let device = Arc::new(device);
let _device = device.clone();
let test_udp_v6 = Arc::new(AtomicBool::new(false));
let test_udp_v6_c = test_udp_v6.clone();
let recv_flag = Arc::new(AtomicBool::new(false));
let recv_flag_c = recv_flag.clone();
let handler = tokio::spawn(async move {
let mut buf = [0; 65535];
loop {
let len = device.recv(&mut buf).await.unwrap();
if let Some(ipv6_packet) = pnet_packet::ipv6::Ipv6Packet::new(&buf[..len]) {
if ipv6_packet.get_next_header() == IpNextHeaderProtocols::Udp {
if let Some(udp_packet) =
pnet_packet::udp::UdpPacket::new(ipv6_packet.payload())
{
if udp_packet.payload() == test_msg.as_bytes() {
test_udp_v6.store(true, Ordering::Relaxed);
}
}
}
}
if test_udp_v6.load(Ordering::Relaxed) {
recv_flag.store(true, Ordering::Release);
break;
}
}
});
tokio::time::sleep(Duration::from_secs(6)).await;
let udp_socket = tokio::net::UdpSocket::bind("[fd12:3456:789a:1111:2222:3333:4444:5555]:0")
.await
.unwrap();
udp_socket
.send_to(
test_msg.as_bytes(),
"[fd12:3456:789a:1111:2222:3333:4444:5556]:8080",
)
.await
.unwrap();
tokio::select! {
_=tokio::time::sleep(Duration::from_secs(2))=>{
// no promise due to the timeout
let v6 = test_udp_v6_c.load(Ordering::Relaxed);
assert!(v6, "timeout: test_udp_v6 = {v6}");
}
_=handler=>{
// all modifications to test_udp_v4_c and test_udp_v6_c must be visible
let flag = recv_flag_c.load(Ordering::Acquire); //synchronize
assert!(flag, "recv_flag = {flag}");
let v6 = test_udp_v6_c.load(Ordering::Relaxed);
assert!(v6 );
}
}
}
#[cfg(any(
target_os = "windows",
target_os = "macos",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
#[test]
fn test_op() {
let device = DeviceBuilder::new()
.ipv4("10.26.2.100", 24, None)
.ipv6("fd12:3456:789a:5555:2222:3333:4444:5555", 120)
.build_sync()
.unwrap();
#[cfg(any(target_os = "macos", target_os = "openbsd"))]
device.set_ignore_packet_info(true);
#[cfg(any(target_os = "macos", target_os = "openbsd"))]
assert!(device.ignore_packet_info());
device.set_mtu(1500).unwrap();
assert_eq!(device.mtu().unwrap(), 1500);
#[cfg(target_os = "macos")]
device.set_associate_route(true);
#[cfg(target_os = "macos")]
assert!(device.associate_route());
let vec = device.addresses().unwrap();
assert!(vec
.iter()
.any(|ip| *ip == "10.26.2.100".parse::<std::net::Ipv4Addr>().unwrap()));
assert!(vec.iter().any(|ip| *ip
== "fd12:3456:789a:5555:2222:3333:4444:5555"
.parse::<std::net::Ipv6Addr>()
.unwrap()));
device.set_network_address("10.26.3.200", 24, None).unwrap();
let vec = device.addresses().unwrap();
assert!(vec
.iter()
.any(|ip| *ip == "10.26.3.200".parse::<std::net::Ipv4Addr>().unwrap()));
assert!(vec.iter().any(|ip| *ip
== "fd12:3456:789a:5555:2222:3333:4444:5555"
.parse::<std::net::Ipv6Addr>()
.unwrap()));
assert!(!vec.contains(&"10.26.2.100".parse::<std::net::IpAddr>().unwrap()));
device.add_address_v4("10.6.0.1", 24).unwrap();
let vec = device.addresses().unwrap();
assert!(vec.contains(&"10.6.0.1".parse::<std::net::IpAddr>().unwrap()));
assert!(vec.contains(&"10.26.3.200".parse::<std::net::IpAddr>().unwrap()));
device
.remove_address("10.6.0.1".parse::<std::net::IpAddr>().unwrap())
.unwrap();
let vec = device.addresses().unwrap();
assert!(!vec.contains(&"10.6.0.1".parse::<std::net::IpAddr>().unwrap()));
assert!(vec.contains(&"10.26.3.200".parse::<std::net::IpAddr>().unwrap()));
device
.add_address_v6("fdab:cdef:1234:5678:9abc:def0:1234:5678", 64)
.unwrap();
let vec = device.addresses().unwrap();
assert!(vec.contains(
&"fdab:cdef:1234:5678:9abc:def0:1234:5678"
.parse::<std::net::IpAddr>()
.unwrap()
));
device.enabled(true).unwrap();
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos"))
))]
device.set_name("tun666").unwrap();
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos"))
))]
assert_eq!(device.name().unwrap(), "tun666");
assert!(device.if_index().is_ok());
#[cfg(all(target_os = "linux", not(target_env = "ohos")))]
assert!(device.is_running().unwrap());
}
#[cfg(any(
target_os = "windows",
target_os = "macos",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
#[test]
fn create_tun() {
#[cfg(not(target_os = "macos"))]
let name = "tun12";
#[cfg(target_os = "macos")]
let name = "utun12";
let device = DeviceBuilder::new().name(name).build_sync().unwrap();
let dev_name = device.name().unwrap();
assert_eq!(dev_name.as_str(), name);
#[cfg(unix)]
{
use std::os::fd::IntoRawFd;
let fd = device.into_raw_fd();
unsafe {
let sync_device = SyncDevice::from_fd(fd).unwrap();
let dev_name = sync_device.name().unwrap();
assert_eq!(dev_name, name);
}
}
}
#[cfg(any(
target_os = "windows",
target_os = "macos",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
#[test]
fn create_tap() {
#[cfg(not(target_os = "macos"))]
let name = "tap12";
#[cfg(target_os = "macos")]
let name = "feth12";
let device = DeviceBuilder::new()
.name(name)
.layer(tun_rs::Layer::L2)
.build_sync()
.unwrap();
let dev_name = device.name().unwrap();
assert_eq!(dev_name.as_str(), name);
#[cfg(all(unix, not(target_os = "macos")))]
{
use std::os::fd::IntoRawFd;
let fd = device.into_raw_fd();
unsafe {
let sync_device = SyncDevice::from_fd(fd).unwrap();
let dev_name = sync_device.name().unwrap();
assert_eq!(dev_name, name);
}
}
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/examples/write.rs | examples/write.rs | #[allow(unused_imports)]
use std::net::Ipv4Addr;
#[allow(unused_imports)]
use std::sync::{mpsc::Receiver, Arc};
#[allow(unused_imports)]
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "macos",
target_os = "freebsd",
target_os = "openbsd",
))]
use tun_rs::DeviceBuilder;
#[allow(unused_imports)]
use tun_rs::SyncDevice;
mod protocol_handle;
fn main() -> std::io::Result<()> {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
let (tx, rx) = std::sync::mpsc::channel();
let handle = ctrlc2::set_handler(move || {
tx.send(()).expect("Signal error.");
true
})
.expect("Error setting Ctrl-C handler");
main_entry(rx)?;
handle.join().unwrap();
Ok(())
}
#[cfg(any(
target_os = "ios",
target_os = "tvos",
target_os = "android",
target_os = "netbsd",
all(target_os = "linux", target_env = "ohos")
))]
fn main_entry(_quit: Receiver<()>) -> std::io::Result<()> {
unimplemented!()
}
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "macos",
target_os = "freebsd",
target_os = "openbsd",
))]
fn main_entry(quit: Receiver<()>) -> std::io::Result<()> {
let dev = Arc::new(
DeviceBuilder::new()
.ipv4(Ipv4Addr::new(10, 0, 0, 9), 24, None)
.build_sync()?,
);
#[cfg(target_os = "macos")]
dev.set_ignore_packet_info(true);
let mut buf = [0; 4096];
std::thread::spawn(move || {
loop {
let amount = dev.recv(&mut buf);
println!("amount == {amount:?}");
let amount = amount?;
let pkt = &buf[0..amount];
handle_pkt(pkt, &dev).unwrap();
}
#[allow(unreachable_code)]
Ok::<(), std::io::Error>(())
});
quit.recv().expect("Quit error.");
Ok(())
}
#[allow(dead_code)]
fn handle_pkt(pkt: &[u8], dev: &SyncDevice) -> std::io::Result<()> {
if let Some(buf) = protocol_handle::ping(pkt) {
dev.send(&buf)?;
}
Ok(())
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/examples/named_tun.rs | examples/named_tun.rs | #[allow(unused_imports)]
use std::net::Ipv4Addr;
use std::sync::mpsc::Receiver;
#[allow(unused_imports)]
use std::sync::Arc;
#[allow(unused_imports)]
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "macos",
target_os = "openbsd",
target_os = "netbsd",
))]
use tun_rs::DeviceBuilder;
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
#[allow(unused_imports)]
use tun_rs::Layer;
fn main() -> Result<(), std::io::Error> {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
let (tx, rx) = std::sync::mpsc::channel();
let handle = ctrlc2::set_handler(move || {
tx.send(()).expect("Signal error.");
true
})
.expect("Error setting Ctrl-C handler");
main_entry(rx)?;
handle.join().unwrap();
Ok(())
}
#[cfg(any(
target_os = "ios",
target_os = "tvos",
target_os = "android",
all(target_os = "linux", target_env = "ohos")
))]
fn main_entry(_quit: Receiver<()>) -> Result<(), std::io::Error> {
unimplemented!()
}
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "macos",
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
fn main_entry(quit: Receiver<()>) -> Result<(), std::io::Error> {
#[allow(unused_imports)]
use std::net::IpAddr;
let dev = Arc::new(
DeviceBuilder::new()
.name("utun66")
.ipv4(Ipv4Addr::new(10, 0, 0, 12), 24, None)
.ipv6("CDCD:910A:2222:5498:8475:1111:3900:2021", 64)
.mtu(1400)
.build_sync()?,
);
println!("addr {:?}", dev.addresses());
println!("if_index = {:?}", dev.if_index());
println!("mtu = {:?}", dev.mtu());
#[cfg(windows)]
{
dev.set_mtu_v6(2000)?;
println!("mtu ipv6 = {:?}", dev.mtu_v6());
println!("version = {:?}", dev.version());
}
let _join = std::thread::spawn(move || {
let mut buf = [0; 4096];
loop {
let amount = dev.recv(&mut buf)?;
println!("{:?}", &buf[0..amount]);
}
#[allow(unreachable_code)]
std::io::Result::Ok(())
});
_ = quit.recv();
Ok(())
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/examples/async_tap.rs | examples/async_tap.rs | #![allow(unused_imports)]
use pnet_packet::ethernet::{EtherTypes, EthernetPacket};
use pnet_packet::Packet;
use std::io;
use std::net::Ipv4Addr;
use std::sync::Arc;
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "macos",
target_os = "openbsd",
target_os = "netbsd",
))]
use tun_rs::DeviceBuilder;
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "macos",
target_os = "openbsd",
target_os = "netbsd",
))]
use tun_rs::Layer;
mod protocol_handle;
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "macos",
target_os = "openbsd",
target_os = "netbsd",
))]
#[tokio::main]
async fn main() -> io::Result<()> {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
let dev = DeviceBuilder::new()
// .name("feth0")
.ipv4(Ipv4Addr::from([10, 0, 0, 9]), 24, None)
.layer(Layer::L2)
.mtu(1400)
.build_async()?;
println!("mac address = {:?}", dev.mac_address());
let mut buf = vec![0; 14 + 65536];
loop {
tokio::select! {
_ = tokio::signal::ctrl_c() => {
println!("Quit...");
break;
}
len = dev.recv(&mut buf) => {
if let Some(packet) = EthernetPacket::new(&buf[..len?]){
match packet.get_ethertype(){
EtherTypes::Ipv4=>{
if let Some(buf) = protocol_handle::ping_ethernet(packet.packet()){
dev.send(&buf).await?;
}
}
EtherTypes::Arp=>{
if let Some(rs) = protocol_handle::arp(packet.packet()) {
dev.send(&rs).await?;
}
}
protocol=>{
println!("ignore ether protocol: {protocol}", )
}
}
}
}
}
}
Ok(())
}
#[cfg(any(
all(target_os = "linux", target_env = "ohos"),
target_os = "ios",
target_os = "tvos",
target_os = "android",
))]
fn main() -> io::Result<()> {
unimplemented!()
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/examples/read_interruptible.rs | examples/read_interruptible.rs | #[allow(unused_imports)]
use std::net::Ipv4Addr;
use std::sync::mpsc::Receiver;
#[allow(unused_imports)]
use std::sync::Arc;
#[allow(unused_imports)]
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
target_os = "macos"
))]
use tun_rs::DeviceBuilder;
#[allow(unused_imports)]
use tun_rs::InterruptEvent;
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
#[allow(unused_imports)]
use tun_rs::Layer;
fn main() -> Result<(), std::io::Error> {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
let (tx, rx) = std::sync::mpsc::channel();
let handle = ctrlc2::set_handler(move || {
tx.send(()).expect("Signal error.");
true
})
.expect("Error setting Ctrl-C handler");
main_entry(rx)?;
handle.join().unwrap();
Ok(())
}
#[cfg(any(
target_os = "ios",
target_os = "tvos",
target_os = "android",
all(target_os = "linux", target_env = "ohos")
))]
fn main_entry(_quit: Receiver<()>) -> Result<(), std::io::Error> {
unimplemented!()
}
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "macos",
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
fn main_entry(quit: Receiver<()>) -> Result<(), std::io::Error> {
#[allow(unused_imports)]
use std::net::IpAddr;
let dev = Arc::new(
DeviceBuilder::new()
.ipv4(Ipv4Addr::new(10, 0, 0, 12), 24, None)
.mtu(1400)
.build_sync()?,
);
println!("if_index = {:?}", dev.if_index());
#[cfg(unix)]
dev.set_nonblocking(true)?;
let event = Arc::new(InterruptEvent::new()?);
let event_clone = event.clone();
let join = std::thread::spawn(move || {
let mut buf = [0; 4096];
loop {
match dev.recv_intr(&mut buf, &event_clone) {
Ok(len) => {
println!("read_interruptible Ok({len})");
}
Err(ref e) if e.kind() == std::io::ErrorKind::Interrupted => {
// If the interrupt event is to be reused, it must be reset before the next wait.
if event_clone.is_trigger() {
event_clone.reset().unwrap();
println!("read_interruptible Err({e:?})");
}
return;
}
Err(e) => {
println!("Error: {e:?}");
return;
}
}
}
});
_ = quit.recv();
event.trigger()?;
join.join().unwrap();
Ok(())
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/examples/ping_offload.rs | examples/ping_offload.rs | #[allow(unused_imports)]
use bytes::BytesMut;
#[allow(unused_imports)]
use std::net::Ipv4Addr;
#[allow(unused_imports)]
use std::sync::Arc;
#[allow(unused_imports)]
#[cfg(all(target_os = "linux", not(target_env = "ohos")))]
use tun_rs::{AsyncDevice, DeviceBuilder, SyncDevice};
#[allow(unused_imports)]
#[cfg(all(target_os = "linux", not(target_env = "ohos")))]
use tun_rs::{GROTable, IDEAL_BATCH_SIZE, VIRTIO_NET_HDR_LEN};
mod protocol_handle;
#[cfg(all(target_os = "linux", not(target_env = "ohos")))]
#[tokio::main]
async fn main() -> std::io::Result<()> {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
let dev = Arc::new({
let builder = DeviceBuilder::new().ipv4(Ipv4Addr::from([10, 0, 0, 9]), 24, None);
#[cfg(target_os = "linux")]
let builder = builder.offload(true);
builder.build_async()?
});
println!("TCP-GSO:{},UDP-GSO:{}", dev.tcp_gso(), dev.udp_gso());
let mut original_buffer = vec![0; VIRTIO_NET_HDR_LEN + 65535];
let mut bufs = vec![vec![0u8; 1500]; IDEAL_BATCH_SIZE];
let mut sizes = vec![0; IDEAL_BATCH_SIZE];
let mut gro_table = GROTable::default();
loop {
tokio::select! {
_ = tokio::signal::ctrl_c() => {
println!("Quit...");
break;
}
num = dev.recv_multiple(&mut original_buffer,&mut bufs,&mut sizes,0) => {
let num = num?;
for i in 0..num {
if let Some(reply) = protocol_handle::ping(&bufs[i][..sizes[i]]){
let mut buf = BytesMut::with_capacity(VIRTIO_NET_HDR_LEN+reply.len());
buf.resize(VIRTIO_NET_HDR_LEN,0);
buf.extend_from_slice(&reply);
let mut bufs = [&mut buf];
dev.send_multiple(&mut gro_table,&mut bufs,VIRTIO_NET_HDR_LEN).await?;
}
}
}
}
}
Ok(())
}
#[cfg(not(all(target_os = "linux", not(target_env = "ohos")),))]
fn main() -> std::io::Result<()> {
unimplemented!()
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/examples/async_ping.rs | examples/async_ping.rs | #[allow(unused_imports)]
use std::net::Ipv4Addr;
#[allow(unused_imports)]
use std::sync::Arc;
#[allow(unused_imports)]
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "macos",
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
use tun_rs::DeviceBuilder;
#[allow(unused_imports)]
use tun_rs::{AsyncDevice, SyncDevice};
mod protocol_handle;
#[cfg(feature = "async_tokio")]
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "macos",
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
#[tokio::main]
async fn main() -> std::io::Result<()> {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
let dev = Arc::new(
DeviceBuilder::new()
.ipv4(Ipv4Addr::new(10, 0, 0, 117), 24, None)
.ipv6("CDCD:910A:2222:5498:8475:1111:3900:2021", 64)
.build_async()?,
);
println!("name:{:?}", dev.name()?);
println!("addresses:{:?}", dev.addresses()?);
let size = dev.mtu()? as usize;
println!("mtu:{size:?}",);
let mut buf = vec![0; size];
loop {
tokio::select! {
_ = tokio::signal::ctrl_c() => {
println!("Quit...");
break;
}
len = dev.recv(&mut buf) => {
let len = len?;
println!("len = {len}");
//println!("pkt: {:?}", &buf[..len?]);
handle_pkt(&buf[..len], &dev).await?;
}
}
}
Ok(())
}
#[cfg(feature = "async_io")]
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "macos",
target_os = "freebsd",
target_os = "openbsd",
))]
#[async_std::main]
async fn main() -> std::io::Result<()> {
use async_ctrlc::CtrlC;
use async_std::prelude::FutureExt;
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
let dev = Arc::new(
DeviceBuilder::new()
.ipv4(Ipv4Addr::from([10, 0, 0, 9]), 24, None)
.build_async()?,
);
let size = dev.mtu()? as usize;
let mut buf = vec![0; size];
let ctrlc = CtrlC::new().expect("cannot create Ctrl+C handler?");
ctrlc
.race(async {
while let Ok(len) = dev.recv(&mut buf).await {
println!("len = {len}");
//println!("pkt: {:?}", &buf[..len]);
handle_pkt(&buf[..len], &dev).await.unwrap();
}
})
.await;
Ok(())
}
#[cfg(any(
target_os = "ios",
target_os = "tvos",
target_os = "android",
all(target_os = "linux", target_env = "ohos")
))]
fn main() -> std::io::Result<()> {
unimplemented!()
}
#[allow(dead_code)]
async fn handle_pkt(pkt: &[u8], dev: &AsyncDevice) -> std::io::Result<()> {
if let Some(buf) = protocol_handle::ping(pkt) {
dev.send(&buf).await?;
}
Ok(())
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/examples/read.rs | examples/read.rs | #[allow(unused_imports)]
use std::net::Ipv4Addr;
use std::sync::mpsc::Receiver;
#[allow(unused_imports)]
use std::sync::Arc;
#[allow(unused_imports)]
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "macos",
target_os = "openbsd",
target_os = "netbsd",
))]
use tun_rs::DeviceBuilder;
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
#[allow(unused_imports)]
use tun_rs::Layer;
fn main() -> Result<(), std::io::Error> {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
let (tx, rx) = std::sync::mpsc::channel();
let handle = ctrlc2::set_handler(move || {
tx.send(()).expect("Signal error.");
true
})
.expect("Error setting Ctrl-C handler");
main_entry(rx)?;
handle.join().unwrap();
Ok(())
}
#[cfg(any(
target_os = "ios",
target_os = "tvos",
target_os = "android",
all(target_os = "linux", target_env = "ohos")
))]
fn main_entry(_quit: Receiver<()>) -> Result<(), std::io::Error> {
unimplemented!()
}
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "macos",
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
fn main_entry(quit: Receiver<()>) -> Result<(), std::io::Error> {
#[allow(unused_imports)]
use std::net::IpAddr;
let dev = Arc::new(
DeviceBuilder::new()
// .name("utun7")
.ipv4(Ipv4Addr::new(10, 0, 0, 12), 24, None)
// .ipv4(Ipv4Addr::new(10, 0, 0, 2), Ipv4Addr::new(255, 255, 255, 0), None)
.ipv6("CDCD:910A:2222:5498:8475:1111:3900:2021", 64)
// .multi_queue(true)
.mtu(1400)
// .ipv6(
// "CDCD:910A:2222:5498:8475:1111:3900:2021",
// "FFFF:FFFF:FFFF:FFFF:0000:0000:0000:0000",
// )
// .ipv6_tuple(&[( "CDCD:910A:2222:5498:8475:1111:3900:2022",64),
// ( "CDCD:910A:2222:5498:8475:1111:3900:2023",64)])
.build_sync()?,
);
// // linux multi queue
// let device = dev.try_clone().unwrap();
// println!("clone {:?}", device.name());
println!("addr {:?}", dev.addresses());
println!("if_index = {:?}", dev.if_index());
println!("mtu = {:?}", dev.mtu());
#[cfg(windows)]
{
dev.set_mtu_v6(2000)?;
println!("mtu ipv6 = {:?}", dev.mtu_v6());
println!("version = {:?}", dev.version());
}
let _join = std::thread::spawn(move || {
let mut buf = [0; 4096];
loop {
let amount = dev.recv(&mut buf)?;
println!("{:?}", &buf[0..amount]);
}
#[allow(unreachable_code)]
std::io::Result::Ok(())
});
_ = quit.recv();
Ok(())
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/examples/async_ping_framed.rs | examples/async_ping_framed.rs | #[allow(unused_imports)]
use bytes::BytesMut;
#[allow(unused_imports)]
use futures::{SinkExt, StreamExt};
#[allow(unused_imports)]
use std::net::Ipv4Addr;
#[allow(unused_imports)]
use std::sync::Arc;
use tun_rs::async_framed::{BytesCodec, DeviceFramed};
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "macos",
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
#[allow(unused_imports)]
use tun_rs::DeviceBuilder;
#[allow(unused_imports)]
use tun_rs::{AsyncDevice, SyncDevice};
mod protocol_handle;
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "macos",
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
#[tokio::main]
async fn main() -> std::io::Result<()> {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
let dev = DeviceBuilder::new()
.ipv4(Ipv4Addr::new(10, 0, 0, 21), 24, None)
.build_async()?;
let mut framed = DeviceFramed::new(dev, BytesCodec::new());
loop {
tokio::select! {
_ = tokio::signal::ctrl_c() => {
log::info!("Quit...");
break;
}
next = framed.next() => {
if let Some(rs) = next{
let buf = rs?;
handle_pkt(&buf, &mut framed).await?;
}else{
break;
}
}
}
}
Ok(())
}
#[cfg(any(
target_os = "ios",
target_os = "tvos",
target_os = "android",
all(target_os = "linux", target_env = "ohos")
))]
fn main() -> std::io::Result<()> {
unimplemented!()
}
#[allow(dead_code)]
async fn handle_pkt(pkt: &[u8], framed: &mut DeviceFramed<BytesCodec>) -> std::io::Result<()> {
if let Some(buf) = protocol_handle::ping(pkt) {
framed.send(BytesMut::from(buf.as_slice())).await?;
}
Ok(())
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/examples/read_timeout.rs | examples/read_timeout.rs | #[allow(unused_imports)]
use std::net::Ipv4Addr;
use std::sync::mpsc::Receiver;
#[allow(unused_imports)]
use std::sync::Arc;
use std::time::Duration;
#[allow(unused_imports)]
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
target_os = "macos"
))]
use tun_rs::DeviceBuilder;
#[allow(unused_imports)]
use tun_rs::InterruptEvent;
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
#[allow(unused_imports)]
use tun_rs::Layer;
fn main() -> Result<(), std::io::Error> {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
let (tx, rx) = std::sync::mpsc::channel();
let handle = ctrlc2::set_handler(move || {
tx.send(()).expect("Signal error.");
true
})
.expect("Error setting Ctrl-C handler");
main_entry(rx)?;
handle.join().unwrap();
Ok(())
}
#[cfg(any(
target_os = "ios",
target_os = "tvos",
target_os = "android",
all(target_os = "linux", target_env = "ohos")
))]
fn main_entry(_quit: Receiver<()>) -> Result<(), std::io::Error> {
unimplemented!()
}
#[cfg(any(
target_os = "windows",
all(target_os = "linux", not(target_env = "ohos")),
target_os = "macos",
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
))]
fn main_entry(quit: Receiver<()>) -> Result<(), std::io::Error> {
#[allow(unused_imports)]
use std::net::IpAddr;
let dev = DeviceBuilder::new()
.ipv4(Ipv4Addr::new(10, 0, 0, 12), 24, None)
.mtu(1400)
.build_sync()?;
println!("if_index = {:?}", dev.if_index());
#[cfg(unix)]
dev.set_nonblocking(true)?;
let event = Arc::new(InterruptEvent::new()?);
let event_clone = event.clone();
let join = std::thread::spawn(move || {
let mut buf = [0; 4096];
loop {
match dev.recv_intr_timeout(&mut buf, &event_clone, Some(Duration::from_millis(1000))) {
Ok(len) => {
println!("recv_intr_timeout Ok({len})");
}
Err(ref e) if e.kind() == std::io::ErrorKind::TimedOut => {
println!("read_interruptible Err({e:?})");
}
Err(ref e) if e.kind() == std::io::ErrorKind::Interrupted => {
// If the interrupt event is to be reused, it must be reset before the next wait.
if event_clone.is_trigger() {
event_clone.reset().unwrap();
println!("read_interruptible Err({e:?})");
}
return;
}
Err(e) => {
println!("Error: {e:?}");
return;
}
}
}
});
_ = quit.recv();
std::thread::sleep(Duration::from_millis(100));
event.trigger()?;
join.join().unwrap();
Ok(())
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
tun-rs/tun-rs | https://github.com/tun-rs/tun-rs/blob/c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7/examples/protocol_handle/mod.rs | examples/protocol_handle/mod.rs | #![allow(unused)]
use pnet_packet::arp::{ArpOperations, MutableArpPacket};
use pnet_packet::ethernet::{EthernetPacket, MutableEthernetPacket};
use pnet_packet::icmp::IcmpPacket;
use pnet_packet::icmp::IcmpTypes;
use pnet_packet::icmp::MutableIcmpPacket;
use pnet_packet::icmpv6::Icmpv6Packet;
use pnet_packet::icmpv6::Icmpv6Types;
use pnet_packet::icmpv6::MutableIcmpv6Packet;
use pnet_packet::ip::IpNextHeaderProtocols;
use pnet_packet::ipv4::{Ipv4Packet, MutableIpv4Packet};
use pnet_packet::ipv6::{Ipv6Packet, MutableIpv6Packet};
use pnet_packet::{MutablePacket, Packet};
use std::net::Ipv4Addr;
fn handle_ipv4_ping(ip_pkt: &Ipv4Packet) -> Option<Vec<u8>> {
if ip_pkt.get_next_level_protocol() != IpNextHeaderProtocols::Icmp {
return None;
}
let icmp_pkt = IcmpPacket::new(ip_pkt.payload())?;
if icmp_pkt.get_icmp_type() != IcmpTypes::EchoRequest {
return None;
}
println!(
"IPv4 Ping Request: {} -> {}",
ip_pkt.get_source(),
ip_pkt.get_destination()
);
let mut icmp_payload = ip_pkt.payload().to_owned();
let mut mutable_icmp_pkt = MutableIcmpPacket::new(&mut icmp_payload).unwrap();
mutable_icmp_pkt.set_icmp_type(IcmpTypes::EchoReply);
mutable_icmp_pkt.set_checksum(pnet_packet::icmp::checksum(
&mutable_icmp_pkt.to_immutable(),
));
let total_len = ip_pkt.get_total_length() as usize;
let mut response_buf = vec![0u8; total_len];
let mut res_ipv4_pkt = MutableIpv4Packet::new(&mut response_buf).unwrap();
res_ipv4_pkt.set_version(4);
res_ipv4_pkt.set_header_length(ip_pkt.get_header_length());
res_ipv4_pkt.set_total_length(ip_pkt.get_total_length());
res_ipv4_pkt.set_identification(0x42);
res_ipv4_pkt.set_ttl(64);
res_ipv4_pkt.set_next_level_protocol(IpNextHeaderProtocols::Icmp);
res_ipv4_pkt.set_source(ip_pkt.get_destination());
res_ipv4_pkt.set_destination(ip_pkt.get_source());
res_ipv4_pkt.set_payload(&icmp_payload);
res_ipv4_pkt.set_checksum(pnet_packet::ipv4::checksum(&res_ipv4_pkt.to_immutable()));
Some(response_buf)
}
fn handle_ipv6_ping(ip_pkt: &Ipv6Packet) -> Option<Vec<u8>> {
if ip_pkt.get_next_header() != IpNextHeaderProtocols::Icmpv6 {
return None;
}
let icmpv6_pkt = Icmpv6Packet::new(ip_pkt.payload())?;
if icmpv6_pkt.get_icmpv6_type() != Icmpv6Types::EchoRequest {
return None;
}
println!(
"IPv6 Ping Request: {} -> {}",
ip_pkt.get_source(),
ip_pkt.get_destination()
);
let mut icmp_payload = ip_pkt.payload().to_owned();
let mut mutable_icmpv6_pkt = MutableIcmpv6Packet::new(&mut icmp_payload).unwrap();
mutable_icmpv6_pkt.set_icmpv6_type(Icmpv6Types::EchoReply);
let checksum = pnet_packet::icmpv6::checksum(
&mutable_icmpv6_pkt.to_immutable(),
&ip_pkt.get_destination(),
&ip_pkt.get_source(),
);
mutable_icmpv6_pkt.set_checksum(checksum);
let total_len = 40 + icmp_payload.len();
let mut response_buf = vec![0u8; total_len];
let mut res_ipv6_pkt = MutableIpv6Packet::new(&mut response_buf).unwrap();
res_ipv6_pkt.set_version(6);
res_ipv6_pkt.set_traffic_class(0);
res_ipv6_pkt.set_flow_label(0);
res_ipv6_pkt.set_payload_length(icmp_payload.len() as u16);
res_ipv6_pkt.set_next_header(IpNextHeaderProtocols::Icmpv6);
res_ipv6_pkt.set_hop_limit(64);
res_ipv6_pkt.set_source(ip_pkt.get_destination());
res_ipv6_pkt.set_destination(ip_pkt.get_source());
res_ipv6_pkt.set_payload(&icmp_payload);
Some(response_buf)
}
pub fn ping(buf: &[u8]) -> Option<Vec<u8>> {
if buf.is_empty() {
return None;
}
match buf[0] >> 4 {
4 => {
// IPv4
let ipv4_packet = Ipv4Packet::new(buf)?;
handle_ipv4_ping(&ipv4_packet)
}
6 => {
// IPv6
let ipv6_packet = Ipv6Packet::new(buf)?;
handle_ipv6_ping(&ipv6_packet)
}
_ => {
// unknown
None
}
}
}
pub fn ping_ethernet(buf: &[u8]) -> Option<Vec<u8>> {
if let Some(packet) = EthernetPacket::new(buf) {
if let Some(ping_buf) = ping(packet.payload()) {
let mut buf = vec![0u8; 14 + ping_buf.len()];
let mut ethernet_packet = MutableEthernetPacket::new(&mut buf).unwrap();
ethernet_packet.set_source(packet.get_destination());
ethernet_packet.set_destination(packet.get_source());
ethernet_packet.set_ethertype(packet.get_ethertype());
ethernet_packet.set_payload(&ping_buf);
return Some(buf);
}
}
None
}
pub fn arp(buf: &[u8]) -> Option<Vec<u8>> {
let packet = EthernetPacket::new(buf)?;
// Use a valid MAC address
const MAC: [u8; 6] = [0x2, 0xf, 0xf, 0xf, 0xe, 0x9];
let mut buf = packet.packet().to_vec();
let mut ethernet_packet = MutableEthernetPacket::new(&mut buf).unwrap();
let sender_h = packet.get_source();
let mut arp_packet = MutableArpPacket::new(ethernet_packet.payload_mut())?;
if arp_packet.get_operation() != ArpOperations::Request {
return None;
}
let sender_p = arp_packet.get_sender_proto_addr();
let target_p = arp_packet.get_target_proto_addr();
if target_p == Ipv4Addr::UNSPECIFIED
|| sender_p == Ipv4Addr::UNSPECIFIED
|| target_p == sender_p
{
return None;
}
arp_packet.set_operation(ArpOperations::Reply);
arp_packet.set_target_hw_addr(sender_h);
arp_packet.set_target_proto_addr(sender_p);
arp_packet.set_sender_proto_addr(target_p);
arp_packet.set_sender_hw_addr(MAC.into());
ethernet_packet.set_destination(sender_h);
ethernet_packet.set_source(MAC.into());
println!("arp query {target_p}");
Some(buf)
}
| rust | Apache-2.0 | c8e1cd8eb96adf915f0ae95e7c502e0f9ffd91a7 | 2026-01-04T20:19:01.665942Z | false |
JoshMcguigan/shell_completion | https://github.com/JoshMcguigan/shell_completion/blob/7a07d42bf616e118c9cd692c0c3b63c05350d2e2/shell_completion/src/lib.rs | shell_completion/src/lib.rs | mod bash;
mod split;
pub use bash::BashCompletionInput;
pub trait CompletionInput : Sized {
fn args(&self) -> Vec<&str>;
fn arg_index(&self) -> usize;
fn char_index(&self) -> usize;
// Returns the current word under the users cursor
// Does not include any characters after the cursor
fn current_word(&self) -> &str {
self.args()[self.arg_index()].split_at(self.char_index()).0
}
// Returns the word before the word under the users cursor
fn previous_word(&self) -> &str {
self.args()[self.arg_index() - 1]
}
/// Given a list of subcommands, filter any that match the current word
fn complete_subcommand<'a, T>(&self, subcommands: T) -> Vec<String>
where
T: IntoIterator<Item = &'a str>,
{
subcommands
.into_iter()
.filter(|&subcommand| subcommand.starts_with(self.current_word()))
.map(|s| s.to_string())
.collect()
}
/// Get directory completions based on the current word
fn complete_directory(&self) -> Vec<String> {
private_complete_directory(self, false)
}
/// Get file completions based on the current word
/// Also returns directories because the user may be entering a file within that directory
fn complete_file(&self) -> Vec<String> {
private_complete_directory(self, true)
}
}
pub trait CompletionSet {
fn suggest(self);
}
impl<'a, T, U> CompletionSet for T
where
T: IntoIterator<Item = U>,
U: std::fmt::Display,
{
fn suggest(self) {
self
.into_iter()
.for_each(|completion| println!("{}", completion));
}
}
fn private_complete_directory<C>(completion: &C, include_files: bool) -> Vec<String>
where
C: CompletionInput,
{
let current_word_parts: Vec<&str> = completion.current_word().rsplitn(2, "/").collect();
let (root_path, partial_path) = match current_word_parts.len() {
2 => (current_word_parts[1], current_word_parts[0]),
0 | 1 => ("./", current_word_parts[0]),
_ => unreachable!(),
};
match std::fs::read_dir(&root_path) {
Ok(iter) => {
let paths = iter
.filter_map(|r| r.ok())
// include_files returns files and directories
// because the user may be targeting a file which
// is several directories deep
.filter(|dir| include_files || match dir.metadata() {
Ok(metadata) => metadata.is_dir(),
Err(_) => false,
})
.map(|dir| dir.path().to_string_lossy().into_owned())
.filter(|dir| {
dir.rsplitn(2, "/")
.next()
.unwrap()
.starts_with(partial_path)
});
if completion.current_word().starts_with("./") {
paths.collect()
} else {
paths
.map(|p| p.trim_start_matches("./").to_string())
.collect()
}
}
Err(_) => vec![],
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_previous_word() {
let input = BashCompletionInput::from("democli run --bi");
assert_eq!("run", input.previous_word());
}
#[test]
fn test_subcommand_completions() {
let input = BashCompletionInput::from("democli st");
let completions =input.complete_subcommand(vec!["add", "start", "stop", "delete"]);
assert_eq!(vec!["start", "stop"], completions);
}
#[test]
fn test_directory_completions() {
let input = BashCompletionInput::from("democli sr");
let completions = input.complete_directory();
assert_eq!(vec!["src"], completions);
}
#[test]
fn test_file_completions() {
let input = BashCompletionInput::from("democli src/li");
let completions = input.complete_file();
assert_eq!(vec!["src/lib.rs"], completions);
}
#[test]
fn test_directory_completions_project_root() {
let input = BashCompletionInput::from("democli ./");
let completions = input.complete_directory();
assert!(completions.contains(&String::from("./src")));
assert_eq!(1, completions.len());
}
}
| rust | Apache-2.0 | 7a07d42bf616e118c9cd692c0c3b63c05350d2e2 | 2026-01-04T20:19:09.999923Z | false |
JoshMcguigan/shell_completion | https://github.com/JoshMcguigan/shell_completion/blob/7a07d42bf616e118c9cd692c0c3b63c05350d2e2/shell_completion/src/bash.rs | shell_completion/src/bash.rs | use std::env;
use crate::CompletionInput;
use crate::split::{Split, SplitError};
/// BashCompletionInput is a struct which contains input data passed from the shell into a
/// completion script. Data within this struct should be used by a completion script to determine
/// appropriate completion options.
pub struct BashCompletionInput {
split: Split
}
#[derive(Debug)]
pub enum BashCompletionInputParsingError {
MissingEnvVar,
CursorPositionNotNumber,
SplitError(SplitError),
}
impl BashCompletionInput {
/// Create a new BashCompletionInput by reading environment variables
pub fn from_env() -> Result<Self, BashCompletionInputParsingError> {
let line = env::var("COMP_LINE").map_err(|_| BashCompletionInputParsingError::MissingEnvVar)?;
let cursor_position = env::var("COMP_POINT")
.map_err(|_| BashCompletionInputParsingError::MissingEnvVar)?
.parse::<usize>()
.map_err(|_| BashCompletionInputParsingError::CursorPositionNotNumber)?;
Ok(BashCompletionInput {
split: Split::new(&line, cursor_position)
.map_err(BashCompletionInputParsingError::SplitError)?,
})
}
/// Create a new BashCompletionInput manually, useful for testing
pub fn new(line: &str, cursor_position: usize) -> Result<Self, BashCompletionInputParsingError> {
Ok(BashCompletionInput {
split: Split::new(line, cursor_position)
.map_err(BashCompletionInputParsingError::SplitError)?,
})
}
}
/// Used only for unit testing
impl<T> From<T> for BashCompletionInput
where
T: Into<String>,
{
fn from(s: T) -> Self {
let line = s.into();
let cursor_position = line.len();
BashCompletionInput {
split: Split::new(&line, cursor_position).unwrap(),
}
}
}
impl CompletionInput for BashCompletionInput {
fn args(&self) -> Vec<&str> {
self.split.words.iter().map(|w| w.as_str()).collect()
}
fn arg_index(&self) -> usize {
self.split.current_word
}
fn char_index(&self) -> usize {
self.split.current_character
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_trait_impl_two_parts() {
let input = BashCompletionInput::from("democli src/li");
assert_eq!(vec!["democli", "src/li"], input.args());
assert_eq!(1, input.arg_index());
assert_eq!(6, input.char_index());
}
#[test]
fn test_trait_impl_one_part() {
let input = BashCompletionInput::from("democli ");
assert_eq!(vec!["democli", ""], input.args());
assert_eq!(1, input.arg_index());
assert_eq!(0, input.char_index());
}
}
| rust | Apache-2.0 | 7a07d42bf616e118c9cd692c0c3b63c05350d2e2 | 2026-01-04T20:19:09.999923Z | false |
JoshMcguigan/shell_completion | https://github.com/JoshMcguigan/shell_completion/blob/7a07d42bf616e118c9cd692c0c3b63c05350d2e2/shell_completion/src/split.rs | shell_completion/src/split.rs | /// Unix shell word splitter
/// Derived from
/// https://github.com/AaronErhardt/shell-words/blob/1f0def71072a2be7b1105ee46b989bbb92762372/src/lib.rs#L46-L231
/// https://github.com/tmiasko/shell-words/blob/045e4dccd2478ccc8bfa91bd0fe449dfe5473496/src/lib.rs#L47-L229
use std::{fmt, mem};
/// An error returned when shell parsing fails.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SplitError {
UnfinishedComment,
}
impl fmt::Display for SplitError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
SplitError::UnfinishedComment => f.write_str("missing closing quote"),
}
}
}
impl std::error::Error for SplitError {}
enum State {
/// Within a delimiter.
Delimiter,
/// After backslash, but before starting word.
Backslash,
/// Within an unquoted word.
Unquoted,
/// After backslash in an unquoted word.
UnquotedBackslash,
/// Within a single quoted word.
SingleQuoted,
/// Within a double-quoted word.
DoubleQuoted,
/// After backslash inside a double-quoted word.
DoubleQuotedBackslash,
/// Inside a comment.
Comment,
}
#[derive(Debug, Eq, PartialEq, Clone)]
pub struct Split {
pub words: Vec<String>,
/// Index of the word of the cursor position (a numeric index into `words`)
pub current_word: usize,
/// Index of the cursor position inside the `current_word`
pub current_character: usize,
}
#[derive(Default)]
struct SplitBuilder {
words: Vec<String>,
word: String,
/// Index of current word and current character
location: Option<(usize, usize)>,
}
impl SplitBuilder {
fn update_indexes(&mut self, c_index: usize, comp_point: usize) {
if self.location.is_none() && c_index >= comp_point {
self.location = Some((self.words.len(), self.word.len()))
}
}
fn push_character(&mut self, c_index: usize, comp_point: usize, c: char) {
self.update_indexes(c_index, comp_point);
self.word.push(c);
}
fn complete_word(&mut self, c_index: usize, comp_point: usize) {
self.update_indexes(c_index, comp_point);
self.words.push(mem::take(&mut self.word))
}
fn finish(self, final_state: State) -> Result<Split, SplitError> {
// We can't complete an unfinished comment
if self.location.is_none() && matches!(final_state, State::Comment) {
return Err(SplitError::UnfinishedComment);
}
Ok(Split {
words: self.words,
current_word: self.location.map(|l| l.0).unwrap_or(0),
current_character: self.location.map(|l| l.1).unwrap_or(0),
})
}
}
impl Split {
pub fn new(s: &str, comp_point: usize) -> Result<Self, SplitError> {
use State::*;
let mut state = Delimiter;
let mut builder = SplitBuilder::default();
for (idx, c) in s.chars().enumerate() {
// Process new character
state = match state {
Delimiter => match c {
'\'' => SingleQuoted,
'\"' => DoubleQuoted,
'\\' => Backslash,
'\t' | ' ' | '\n' => Delimiter,
'#' => Comment,
c => {
builder.push_character(idx, comp_point, c);
Unquoted
}
},
Backslash => match c {
'\n' => Delimiter,
c => {
builder.push_character(idx, comp_point, c);
Unquoted
}
},
Unquoted => match c {
'\'' => SingleQuoted,
'\"' => DoubleQuoted,
'\\' => UnquotedBackslash,
'\t' | ' ' | '\n' => {
builder.complete_word(idx, comp_point);
Delimiter
}
c => {
builder.push_character(idx, comp_point, c);
Unquoted
}
},
UnquotedBackslash => match c {
'\n' => Unquoted,
c => {
builder.push_character(idx, comp_point, c);
Unquoted
}
},
SingleQuoted => match c {
'\'' => Unquoted,
c => {
builder.push_character(idx, comp_point, c);
SingleQuoted
}
},
DoubleQuoted => match c {
'\"' => Unquoted,
'\\' => DoubleQuotedBackslash,
c => {
builder.push_character(idx, comp_point, c);
DoubleQuoted
}
},
DoubleQuotedBackslash => match c {
'\n' => DoubleQuoted,
'$' | '`' | '"' | '\\' => {
builder.push_character(idx, comp_point, c);
DoubleQuoted
}
c => {
builder.push_character(idx, comp_point, '\\');
builder.push_character(idx, comp_point, c);
DoubleQuoted
}
},
Comment => match c {
'\n' => Delimiter,
_ => Comment,
},
}
}
// Process end of input
match state {
Comment => {}
Backslash | UnquotedBackslash => {
builder.push_character(s.len(), comp_point, '\\');
builder.complete_word(s.len(), comp_point);
}
_ => {
builder.complete_word(s.len(), comp_point);
}
}
builder.finish(state)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[derive(Debug)]
struct TestCase {
input: String,
comp_point: usize,
expected: Result<Split, SplitError>,
}
impl TestCase {
// Character `|` is used to indicate where the cursor is
fn get_comp_point(input: &str) -> usize {
assert_eq!(
input.chars().filter(|c| *c == '|').count(),
1,
"Input must contain one cursor character '|'"
);
input.find('|').unwrap()
}
fn at_start(input: &str, expected: &[&str]) -> Self {
Self {
input: input.to_string(),
comp_point: 0,
expected: Ok(Split {
words: expected.iter().map(|e| e.to_string()).collect(),
current_word: 0,
current_character: 0,
}),
}
}
fn at_cursor(
input: &str,
expected: &[&str],
current_word: usize,
current_character: usize,
) -> Self {
Self {
input: input.replace('|', ""),
comp_point: Self::get_comp_point(input),
expected: Ok(Split {
words: expected.iter().map(|e| e.to_string()).collect(),
current_word,
current_character,
}),
}
}
fn error_at_cursor(input: &str, expected: SplitError) -> Self {
Self {
input: input.replace('|', ""),
comp_point: Self::get_comp_point(input),
expected: Err(expected),
}
}
}
fn assert_split(cases: &[TestCase]) {
for case in cases {
assert_eq!(Split::new(&case.input, case.comp_point), case.expected);
}
}
#[test]
fn split_empty() {
assert_split(&[TestCase::at_start("", &[""])]);
}
#[test]
fn split_initial_whitespace_is_removed() {
assert_split(&[
TestCase::at_start(" a", &["a"]),
TestCase::at_start("\t\t\t\tbar", &["bar"]),
TestCase::at_start("\t \nc", &["c"]),
]);
}
#[test]
fn split_trailing_whitespace_is_preserved() {
// We should indicate that we are trying to start a new word
assert_split(&[
TestCase::at_start("a ", &["a", ""]),
TestCase::at_start("b\t", &["b", ""]),
TestCase::at_start("c\t \n \n \n", &["c", ""]),
TestCase::at_start("d\n\n", &["d", ""]),
]);
}
#[test]
fn split_carriage_return_is_not_special() {
assert_split(&[TestCase::at_start("c\ra\r'\r'\r", &["c\ra\r\r\r"])]);
}
#[test]
fn split_single_quotes() {
assert_split(&[
TestCase::at_start(r#"''"#, &[r#""#]),
TestCase::at_start(r#"'a'"#, &[r#"a"#]),
TestCase::at_start(r#"'\'"#, &[r#"\"#]),
TestCase::at_start(r#"' \ '"#, &[r#" \ "#]),
TestCase::at_start(r#"'#'"#, &[r#"#"#]),
]);
}
#[test]
fn split_double_quotes() {
assert_split(&[
TestCase::at_start(r#""""#, &[""]),
TestCase::at_start(r#""""""#, &[""]),
TestCase::at_start(r#""a b c' d""#, &["a b c' d"]),
TestCase::at_start(r#""\a""#, &["\\a"]),
TestCase::at_start(r#""$""#, &["$"]),
TestCase::at_start(r#""\$""#, &["$"]),
TestCase::at_start(r#""`""#, &["`"]),
TestCase::at_start(r#""\`""#, &["`"]),
TestCase::at_start(r#""\"""#, &["\""]),
TestCase::at_start(r#""\\""#, &["\\"]),
TestCase::at_start("\"\n\"", &["\n"]),
TestCase::at_start("\"\\\n\"", &[""]),
]);
}
#[test]
fn split_unquoted() {
assert_split(&[
TestCase::at_start(r#"\|\&\;"#, &[r#"|&;"#]),
TestCase::at_start(r#"\<\>"#, &[r#"<>"#]),
TestCase::at_start(r#"\(\)"#, &[r#"()"#]),
TestCase::at_start(r#"\$"#, &[r#"$"#]),
TestCase::at_start(r#"\`"#, &[r#"`"#]),
TestCase::at_start(r#"\""#, &[r#"""#]),
TestCase::at_start(r#"\'"#, &[r#"'"#]),
TestCase::at_start("\\\n", &[""]),
TestCase::at_start(" \\\n \n", &[""]),
TestCase::at_start("a\nb\nc", &["a", "b", "c"]),
TestCase::at_start("a\\\nb\\\nc", &["abc"]),
TestCase::at_start("foo bar baz", &["foo", "bar", "baz"]),
TestCase::at_start(r#"\🦉"#, &[r"🦉"]),
]);
}
#[test]
fn split_trailing_backslash() {
assert_split(&[
TestCase::at_start("\\", &["\\"]),
TestCase::at_start(" \\", &["\\"]),
TestCase::at_start("a\\", &["a\\"]),
]);
}
#[test]
fn split_comments() {
assert_split(&[
TestCase::at_start(r#" x # comment "#, &["x"]),
TestCase::at_start(r#" w1#w2 "#, &["w1#w2", ""]),
TestCase::at_start(r#"'not really a # comment'"#, &["not really a # comment"]),
TestCase::at_start(" a # very long comment \n b # another comment", &["a", "b"]),
TestCase::at_cursor("one t|wo # comment", &["one", "two"], 1, 1),
TestCase::at_cursor("one # comment \n tw|o", &["one", "two"], 1, 2),
TestCase::error_at_cursor("command # begin comment|", SplitError::UnfinishedComment),
]);
}
#[test]
fn split_with_cursor() {
assert_split(&[
// First word
TestCase::at_cursor("|", &[""], 0, 0),
TestCase::at_cursor("|one two three", &["one", "two", "three"], 0, 0),
TestCase::at_cursor("o|ne two three", &["one", "two", "three"], 0, 1),
TestCase::at_cursor("one| two three", &["one", "two", "three"], 0, 3),
TestCase::at_cursor("'one'| two three", &["one", "two", "three"], 0, 3),
// Second word
TestCase::at_cursor("one |two three", &["one", "two", "three"], 1, 0),
TestCase::at_cursor("one t|wo three", &["one", "two", "three"], 1, 1),
TestCase::at_cursor("one two| three", &["one", "two", "three"], 1, 3),
TestCase::at_cursor("one 'two |' three", &["one", "two ", "three"], 1, 6),
// Third word
TestCase::at_cursor("one two |", &["one", "two", ""], 2, 0),
TestCase::at_cursor("one two |", &["one", "two", ""], 2, 0),
TestCase::at_cursor("one two |three", &["one", "two", "three"], 2, 0),
TestCase::at_cursor("one two 'three'|", &["one", "two", "three"], 2, 5),
]);
}
#[test]
fn split_incomplete() {
// Should gracefully handle incomplete statements
assert_split(&[
// Double quotes
TestCase::at_cursor("one \"tw|", &["one", "tw"], 1, 2),
TestCase::at_cursor("one| \"tw", &["one", "tw"], 0, 3),
// Single quotes
TestCase::at_cursor("one 'tw|", &["one", "tw"], 1, 2),
TestCase::at_cursor("one| 'tw", &["one", "tw"], 0, 3),
]);
}
}
| rust | Apache-2.0 | 7a07d42bf616e118c9cd692c0c3b63c05350d2e2 | 2026-01-04T20:19:09.999923Z | false |
JoshMcguigan/shell_completion | https://github.com/JoshMcguigan/shell_completion/blob/7a07d42bf616e118c9cd692c0c3b63c05350d2e2/cargo_completion/src/main.rs | cargo_completion/src/main.rs | use shell_completion::{BashCompletionInput, CompletionInput, CompletionSet};
fn main() {
let input = BashCompletionInput::from_env()
.expect("Missing expected environment variables");
complete(input).suggest();
}
fn complete(input: impl CompletionInput) -> Vec<String> {
match input.arg_index() {
0 => unreachable!(),
1 => complete_cargo_commands(input),
_ => {
match input.args()[1] {
"run" => complete_run(input),
"test" => complete_test(input),
_ => vec![],
}
},
}
}
fn complete_cargo_commands(input: impl CompletionInput) -> Vec<String> {
use std::process::Command;
let output = Command::new("cargo")
.arg("--list")
.output()
.expect("failed to execute cargo");
let stdout = String::from_utf8_lossy(&output.stdout);
let cargo_commands : Vec<&str> = stdout.lines()
.skip(1) // first line is description
.map(|line| line.split_whitespace().next().unwrap()) // each line is COMMAND DESCRIPTION
.collect();
input.complete_subcommand(cargo_commands)
}
fn complete_run(input: impl CompletionInput) -> Vec<String> {
let unary_options = vec![
"--release",
"--all-features",
"--no-default-features",
"--verbose",
"--quiet",
"--frozen",
"--locked",
"--help",
];
let other_options = vec![
"--bin",
"--example",
"--package",
"--jobs",
"--features",
"--target",
"--target-dir",
"--manifest-path",
"--message-format",
"--color",
];
if input.previous_word() == "run"
|| !input.previous_word().starts_with("-")
|| unary_options.contains(&input.previous_word())
{
let all_options = unary_options.into_iter().chain(other_options);
input.complete_subcommand(all_options)
} else {
match input.previous_word() {
"--example" => complete_examples(input),
"--target-dir" => input.complete_directory(),
"--manifest-path" => input.complete_file(),
"--message-format" => input.complete_subcommand(vec!["human", "json", "short"]),
"--color" => input.complete_subcommand(vec!["auto", "always", "never"]),
_ => vec![],
}
}
}
fn complete_examples(input: impl CompletionInput) -> Vec<String> {
use std::process::Command;
let output = Command::new("cargo")
.arg("run")
.arg("--example")
.output()
.expect("failed to execute cargo");
let stdout = String::from_utf8_lossy(&output.stderr);
let examples: Vec<&str> = stdout.lines()
.skip(2) // first two lines are human readable
.map(|line| line.trim()) // each line is an example surrounded by whitespace
.collect();
input.complete_subcommand(examples)
}
fn complete_test(input: impl CompletionInput) -> Vec<String> {
let unary_options = vec![
"--lib",
"--bins",
"--examples",
"--tests",
"--benches",
"--all-targets",
"--doc",
"--no-run",
"--no-fail-fast",
"--all",
"--jobs",
"--release",
"--all-features",
"--no-default-features",
"--verbose",
"--quiet",
"--frozen",
"--locked",
"--help",
];
let other_options = vec![
"--bin",
"--example",
"--test",
"--bench",
"--package",
"--exclude",
"--jobs",
"--features",
"--target",
"--target-dir",
"--manifest-path",
"--message-format",
"--color",
];
if input.previous_word() == "run"
|| !input.previous_word().starts_with("-")
|| unary_options.contains(&input.previous_word())
{
let all_options = unary_options.into_iter().chain(other_options);
input.complete_subcommand(all_options)
} else {
match input.previous_word() {
"--target-dir" => input.complete_directory(),
"--manifest-path" => input.complete_file(),
"--message-format" => input.complete_subcommand(vec!["human", "json", "short"]),
"--color" => input.complete_subcommand(vec!["auto", "always", "never"]),
_ => vec![],
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn complete_subcommand_fetch() {
let input = BashCompletionInput::from("cargo fe");
let completions = complete(input);
assert_eq!(1, completions.len());
assert_eq!("fetch", completions[0]);
}
#[test]
fn complete_run_option_bin() {
let input = BashCompletionInput::from("cargo run --bi");
let completions = complete(input);
assert_eq!(1, completions.len());
assert_eq!("--bin", completions[0]);
}
#[test]
fn complete_run_option_bin_requires_name() {
let input = BashCompletionInput::from("cargo run --bin ");
let completions = complete(input);
// for now, test that this doesn't return the full list of subcommands
// eventually this could return the list of binary targets in the crate
assert_eq!(0, completions.len());
}
#[test]
fn complete_run_option_target_dir() {
let input = BashCompletionInput::from("cargo run --target-dir sr");
let completions = complete(input);
assert_eq!(1, completions.len());
assert_eq!("src", completions[0]);
}
#[test]
fn complete_run_option_manifest_path() {
let input = BashCompletionInput::from("cargo run --manifest-path Cargo.to");
let completions = complete(input);
assert_eq!(1, completions.len());
assert_eq!("Cargo.toml", completions[0]);
}
#[test]
fn complete_run_option_message_format() {
let input = BashCompletionInput::from("cargo run --message-format ");
let completions = complete(input);
assert_eq!(3, completions.len());
assert_eq!("human", completions[0]);
assert_eq!("json", completions[1]);
assert_eq!("short", completions[2]);
}
#[test]
fn complete_run_option_color() {
let input = BashCompletionInput::from("cargo run --color ");
let completions = complete(input);
assert_eq!(3, completions.len());
assert_eq!("auto", completions[0]);
assert_eq!("always", completions[1]);
assert_eq!("never", completions[2]);
}
#[test]
fn complete_run_option_chaining() {
let input = BashCompletionInput::from("cargo run --color auto --manif");
let completions = complete(input);
assert_eq!(1, completions.len());
assert_eq!("--manifest-path", completions[0]);
}
#[test]
fn complete_subcommand_test() {
let input = BashCompletionInput::from("cargo tes");
let completions = complete(input);
assert_eq!(1, completions.len());
assert_eq!("test", completions[0]);
}
#[test]
fn complete_test_option_lib() {
let input = BashCompletionInput::from("cargo test --li");
let completions = complete(input);
assert_eq!(1, completions.len());
assert_eq!("--lib", completions[0]);
}
}
| rust | Apache-2.0 | 7a07d42bf616e118c9cd692c0c3b63c05350d2e2 | 2026-01-04T20:19:09.999923Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/config.rs | src/config.rs | use crate::{
audio::{Endianness, SampleFormat},
constants::{
COMPARATOR_DEFAULT_BAND_SIZE, DETECTOR_DEFAULT_AVG_THRESHOLD, DETECTOR_DEFAULT_MIN_SCORES,
DETECTOR_DEFAULT_REFERENCE, DETECTOR_DEFAULT_THRESHOLD, DETECTOR_INTERNAL_SAMPLE_RATE,
},
};
/// Wav format representation
#[cfg_attr(feature = "debug", derive(Debug))]
pub struct AudioFmt {
/// Indicates the sample rate of the input audio stream.
pub sample_rate: usize,
/// Indicates the sample type and its bit size. It's only used when the audio is provided as bytes.
pub sample_format: SampleFormat,
/// Indicates the number of channels of the input audio stream.
pub channels: u16,
/// Input the sample endianness used to encode the input audio stream bytes.
pub endianness: Endianness,
}
impl Default for AudioFmt {
fn default() -> AudioFmt {
AudioFmt {
sample_rate: DETECTOR_INTERNAL_SAMPLE_RATE,
sample_format: SampleFormat::F32,
channels: 1,
endianness: Endianness::Little,
}
}
}
/// Configures the gain-normalizer audio filter used.
#[cfg_attr(feature = "debug", derive(Debug))]
pub struct GainNormalizationConfig {
/// Enables the filter.
pub enabled: bool,
/// Set the rms level reference used to calculate the gain applied.
/// If unset the estimated wakeword rms level is used.
pub gain_ref: Option<f32>,
/// Min gain applied. (precision of 0.1)
pub min_gain: f32,
/// Max gain applied. (precision of 0.1)
pub max_gain: f32,
}
impl Default for GainNormalizationConfig {
fn default() -> GainNormalizationConfig {
GainNormalizationConfig {
enabled: false,
gain_ref: None,
min_gain: 0.1,
max_gain: 1.0,
}
}
}
/// Configures the band-pass audio filter used.
#[cfg_attr(feature = "debug", derive(Debug))]
pub struct BandPassConfig {
/// Enables the filter.
pub enabled: bool,
/// Low cutoff for the band-pass filter.
pub low_cutoff: f32,
/// High cutoff for the band-pass filter.
pub high_cutoff: f32,
}
impl Default for BandPassConfig {
fn default() -> BandPassConfig {
BandPassConfig {
enabled: false,
low_cutoff: 80.,
high_cutoff: 400.,
}
}
}
/// Configures the audio filters.
#[cfg_attr(feature = "debug", derive(Debug))]
#[derive(Default)]
pub struct FiltersConfig {
/// Enables a gain-normalizer audio filter that intent to approximate the volume of the stream
/// to a reference level (RMS of the samples is used as volume measure).
pub gain_normalizer: GainNormalizationConfig,
/// Enables a band-pass audio filter that attenuates frequencies outside the low cutoff and high cutoff range.
pub band_pass: BandPassConfig,
}
/// Indicates how to calculate the final score.
#[cfg_attr(feature = "debug", derive(Debug))]
#[derive(Clone, Copy)]
pub enum ScoreMode {
Average,
Max,
Median,
P25,
P50,
P75,
P80,
P90,
P95,
}
#[cfg(feature = "display")]
impl std::fmt::Display for ScoreMode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match *self {
ScoreMode::Average => write!(f, "average"),
ScoreMode::Max => write!(f, "max"),
ScoreMode::Median => write!(f, "median"),
ScoreMode::P25 => write!(f, "p25"),
ScoreMode::P50 => write!(f, "p50"),
ScoreMode::P75 => write!(f, "p75"),
ScoreMode::P80 => write!(f, "p80"),
ScoreMode::P90 => write!(f, "p90"),
ScoreMode::P95 => write!(f, "p95"),
}
}
}
#[cfg(feature = "display")]
impl std::str::FromStr for ScoreMode {
type Err = String;
fn from_str(s: &str) -> std::result::Result<Self, String> {
match s.to_lowercase().as_str() {
"average" => Ok(Self::Average),
"max" => Ok(Self::Max),
"median" => Ok(Self::Median),
"p25" => Ok(Self::P25),
"p50" => Ok(Self::P50),
"p75" => Ok(Self::P75),
"p80" => Ok(Self::P80),
"p90" => Ok(Self::P90),
"p95" => Ok(Self::P95),
_ => Err("Unknown score mode".to_string()),
}
}
}
/// Configures VAD detector sensibility.
#[cfg_attr(feature = "debug", derive(Debug))]
#[derive(Clone, Copy)]
pub enum VADMode {
Easy,
Medium,
Hard,
}
impl VADMode {
pub(crate) fn get_value(&self) -> f32 {
match &self {
VADMode::Easy => 2.,
VADMode::Medium => 2.5,
VADMode::Hard => 3.,
}
}
}
#[cfg(feature = "display")]
impl std::fmt::Display for VADMode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match *self {
VADMode::Easy => write!(f, "easy"),
VADMode::Medium => write!(f, "medium"),
VADMode::Hard => write!(f, "hard"),
}
}
}
#[cfg(feature = "display")]
impl std::str::FromStr for VADMode {
type Err = String;
fn from_str(s: &str) -> std::result::Result<Self, String> {
match s.to_lowercase().as_str() {
"easy" => Ok(Self::Easy),
"medium" => Ok(Self::Medium),
"hard" => Ok(Self::Hard),
_ => Err("Unknown vad mode".to_string()),
}
}
}
/// Configures the detector scoring behavior.
#[cfg_attr(feature = "debug", derive(Debug))]
pub struct DetectorConfig {
/// Minimum required score against the wakeword averaged feature frame vector.
pub avg_threshold: f32,
/// Minimum required score against the some of the wakeword feature frame vectors.
pub threshold: f32,
/// Minimum number of positive scores during detection.
pub min_scores: usize,
/// Emit detection on min partial scores.
pub eager: bool,
/// Value used to express the score as a percent in range 0 - 1.
pub score_ref: f32,
/// Comparator band size. Doesn't apply to wakeword models.
pub band_size: u16,
/// How to calculate a unified score. Doesn't apply to wakeword models.
pub score_mode: ScoreMode,
/// How to calculate a unified score. Doesn't apply to wakeword models.
pub vad_mode: Option<VADMode>,
#[cfg(feature = "record")]
/// Path to create records, one on the first partial detection and another each one that scores better.
pub record_path: Option<String>,
}
impl Default for DetectorConfig {
fn default() -> DetectorConfig {
DetectorConfig {
avg_threshold: DETECTOR_DEFAULT_AVG_THRESHOLD,
threshold: DETECTOR_DEFAULT_THRESHOLD,
min_scores: DETECTOR_DEFAULT_MIN_SCORES,
score_ref: DETECTOR_DEFAULT_REFERENCE,
band_size: COMPARATOR_DEFAULT_BAND_SIZE,
vad_mode: None,
score_mode: ScoreMode::Max,
eager: false,
#[cfg(feature = "record")]
record_path: None,
}
}
}
/// Encapsulates all the tool configurations.
#[cfg_attr(feature = "debug", derive(Debug))]
#[derive(Default)]
pub struct RustpotterConfig {
/// Configures expected audio input format.
pub fmt: AudioFmt,
/// Configures detection.
pub detector: DetectorConfig,
/// Configures input audio filters.
pub filters: FiltersConfig,
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/lib.rs | src/lib.rs | mod audio;
mod config;
mod constants;
mod detector;
mod mfcc;
mod wakewords;
#[cfg(feature = "audio")]
pub use audio::{AudioEncoder, BandPassFilter, GainNormalizerFilter};
pub use audio::{Endianness, Sample, SampleFormat};
pub use config::{
AudioFmt, BandPassConfig, DetectorConfig, FiltersConfig, GainNormalizationConfig,
RustpotterConfig, ScoreMode, VADMode,
};
#[cfg(feature = "audio")]
pub use constants::{DETECTOR_INTERNAL_SAMPLE_RATE, MFCCS_EXTRACTOR_FRAME_LENGTH_MS};
pub use detector::{Rustpotter, RustpotterDetection};
pub use wakewords::{
ModelType, ModelWeights, TensorData, WakewordLoad, WakewordModel, WakewordModelTrain,
WakewordModelTrainOptions, WakewordRef, WakewordRefBuildFromBuffers, WakewordRefBuildFromFiles,
WakewordSave,
};
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/detector.rs | src/detector.rs | use std::collections::HashMap;
use crate::{
audio::{AudioEncoder, BandPassFilter, GainNormalizerFilter},
constants::{
DETECTOR_INTERNAL_SAMPLE_RATE, MFCCS_EXTRACTOR_FRAME_LENGTH_MS,
MFCCS_EXTRACTOR_FRAME_SHIFT_MS, MFCCS_EXTRACTOR_PRE_EMPHASIS,
},
mfcc::{MfccExtractor, VadDetector},
wakewords::{WakewordDetector, WakewordFile, WakewordV2},
DetectorConfig, FiltersConfig, RustpotterConfig, Sample, ScoreMode, WakewordLoad,
WakewordModel, WakewordRef,
};
/// Rustpotter is an open source wakeword spotter forged in rust
/// ```
/// use rustpotter::{Rustpotter, RustpotterConfig};
/// // assuming the audio input format match the rustpotter defaults
/// let mut rustpotter_config = RustpotterConfig::default();
/// // Configure the rustpotter
/// // ...
/// let mut rustpotter = Rustpotter::new(&rustpotter_config).unwrap();
/// // load and enable a wakeword
/// rustpotter.add_wakeword_from_file("wakeword_key", "./tests/resources/oye_casa_g.rpw").unwrap();
/// // You need a buffer of size rustpotter.get_samples_per_frame() when using samples or rustpotter.get_bytes_per_frame() when using bytes.
/// let mut sample_buffer: Vec<i16> = vec![0; rustpotter.get_samples_per_frame()];
/// // while true { Iterate forever
/// // fill the buffer with the required samples/bytes...
/// let detection = rustpotter.process_samples(sample_buffer);
/// if let Some(detection) = detection {
/// println!("{:?}", detection);
/// }
/// // }
/// ```
pub struct Rustpotter {
// Config
/// Required score against the averaged mfccs matrix. Only to discard frames.
avg_threshold: f32,
/// Required score while comparing the wakeword against the live stream.
threshold: f32,
/// Required number of partial scores (scores over threshold) to consider the detection real.
min_scores: usize,
/// Emit detection on min partial scores.
eager: bool,
/// How to calculate the final score.
score_mode: ScoreMode,
///
vad_detector: Option<VadDetector>,
// Utils
/// Utility to encode or re-encode the input wav data.
wav_encoder: AudioEncoder,
/// Utility to extract a collection of mfcc for each input audio frame.
mfcc_extractor: MfccExtractor,
/// Score reference for it to be expressed in a 0 - 1 range.
score_ref: f32,
/// Comparator band size.
band_size: u16,
/// Optional band-pass filter implementation.
band_pass_filter: Option<BandPassFilter>,
/// Optional gain filter implementation.
gain_normalizer_filter: Option<GainNormalizerFilter>,
// State
/// The collection of active wakewords detectors.
wakewords: HashMap<String, Box<dyn WakewordDetector>>,
/// Indicates that the audio_mfcc_window has enough mfcc frames to run the detection.
/// This means its length is greater or equal to the max_mfcc_frames value.
buffering: bool,
/// A window of mfccs frames extracted from the input audio.
/// It grows until match the max_mfcc_frames value.
audio_mfcc_window: Vec<Vec<f32>>,
/// Max number of feature frames on the wakewords.
max_mfcc_frames: usize,
/// Stores the partial detection with greater score while waiting for the detection countdown to be zero.
partial_detection: Option<RustpotterDetection>,
/// Countdown until detection fires.
/// Whenever a better partial detection is found, it is set to the double of the max number of feature frames in the wakeword samples.
/// When it gets to zero and a partial detection exists, it'll be considered the final detection.
detection_countdown: usize,
/// Current frame rms level
rms_level: f32,
/// Gain normalization applied to current frame.
gain: f32,
#[cfg(feature = "record")]
// Path to create records
record_path: Option<String>,
#[cfg(feature = "record")]
/// Audio data cache for recording
audio_window: Vec<f32>,
#[cfg(feature = "record")]
/// Max audio data to retain
max_audio_samples: usize,
}
impl Rustpotter {
/// Returns a configured Rustpotter instance.
pub fn new(config: &RustpotterConfig) -> Result<Rustpotter, String> {
let reencoder = AudioEncoder::new(
&config.fmt,
MFCCS_EXTRACTOR_FRAME_LENGTH_MS,
DETECTOR_INTERNAL_SAMPLE_RATE,
)?;
let samples_per_frame = reencoder.get_output_frame_length();
let samples_per_shift = (samples_per_frame as f32
/ (MFCCS_EXTRACTOR_FRAME_LENGTH_MS as f32 / MFCCS_EXTRACTOR_FRAME_SHIFT_MS as f32))
as usize;
let mfcc_extractor = MfccExtractor::new(
DETECTOR_INTERNAL_SAMPLE_RATE,
samples_per_frame,
samples_per_shift,
0, // setup on wakeword added
MFCCS_EXTRACTOR_PRE_EMPHASIS,
);
let gain_normalizer_filter = (&config.filters.gain_normalizer).into();
let band_pass_filter = (&config.filters.band_pass).into();
Ok(Rustpotter {
avg_threshold: config.detector.avg_threshold,
threshold: config.detector.threshold,
min_scores: config.detector.min_scores,
eager: config.detector.eager,
score_mode: config.detector.score_mode,
score_ref: config.detector.score_ref,
band_size: config.detector.band_size,
wav_encoder: reencoder,
vad_detector: config.detector.vad_mode.map(VadDetector::new),
mfcc_extractor,
band_pass_filter,
gain_normalizer_filter,
audio_mfcc_window: Vec::new(),
buffering: true,
max_mfcc_frames: 0,
wakewords: HashMap::new(),
partial_detection: None,
detection_countdown: 0,
rms_level: 0.,
gain: 1.,
#[cfg(feature = "record")]
max_audio_samples: 0,
#[cfg(feature = "record")]
audio_window: Vec::new(),
#[cfg(feature = "record")]
record_path: config.detector.record_path.clone(),
})
}
/// Add wakeword ref to the detector.
pub fn add_wakeword_ref(&mut self, key: &str, wakeword: WakewordRef) -> Result<(), String> {
self.add_wakeword(key, wakeword)
}
/// Add wakeword model to the detector.
pub fn add_wakeword_model(&mut self, key: &str, wakeword: WakewordModel) -> Result<(), String> {
self.add_wakeword(key, wakeword)
}
/// Add wakeword from file bytes.
pub fn add_wakeword_from_buffer(&mut self, key: &str, buffer: &[u8]) -> Result<(), String> {
WakewordV2::load_from_buffer(buffer)
.and_then(|w| self.add_wakeword_ref(key, w.into()))
.or_else(|_| {
WakewordRef::load_from_buffer(buffer)
.and_then(|wakeword| self.add_wakeword_ref(key, wakeword))
.or_else(|_| {
WakewordModel::load_from_buffer(buffer)
.and_then(|wakeword| self.add_wakeword_model(key, wakeword))
})
})
}
/// Add wakeword from file path.
pub fn add_wakeword_from_file(&mut self, key: &str, path: &str) -> Result<(), String> {
WakewordV2::load_from_file(path)
.and_then(|w| self.add_wakeword_ref(key, w.into()))
.or_else(|_| {
WakewordRef::load_from_file(path)
.and_then(|wakeword| self.add_wakeword_ref(key, wakeword))
.or_else(|_| {
WakewordModel::load_from_file(path)
.and_then(|wakeword| self.add_wakeword_model(key, wakeword))
})
})
}
/// Remove wakeword by key.
///
/// Returns true on success.
pub fn remove_wakeword(&mut self, key: &str) -> bool {
let len = self.wakewords.len();
self.wakewords.retain(|k, _| !k.eq(key));
if len != self.wakewords.len() {
self.on_wakeword_change();
true
} else {
false
}
}
/// Remove all wakewords.
///
/// Returns true on success.
pub fn remove_wakewords(&mut self) -> bool {
let len = self.wakewords.len();
self.wakewords.clear();
if len != self.wakewords.len() {
self.on_wakeword_change();
true
} else {
false
}
}
/// Returns the number of audio samples needed by the detector.
pub fn get_samples_per_frame(&self) -> usize {
self.wav_encoder.get_input_frame_length()
}
/// Returns the number of audio bytes needed by the detector.
pub fn get_bytes_per_frame(&self) -> usize {
self.wav_encoder.get_input_byte_length()
}
/// Returns a reference to the current partial detection if any.
pub fn get_partial_detection(&self) -> Option<&RustpotterDetection> {
self.partial_detection.as_ref()
}
/// Returns the rms level of the last frame (before gain normalization)
pub fn get_rms_level(&self) -> f32 {
self.rms_level
}
/// Returns the gain applied to the latest frame by the gain normalizer filter (1. if none or disabled).
pub fn get_gain(&self) -> f32 {
self.gain
}
/// Returns the gain normalizer filter rms level reference.
pub fn get_rms_level_ref(&self) -> f32 {
self.gain_normalizer_filter
.as_ref()
.map(|f| f.get_rms_level_ref())
.unwrap_or(f32::NAN)
}
/// Process bytes buffer.
///
/// Number of bytes provided should match the return of the get_bytes_per_frame method.
///
pub fn process_bytes(&mut self, audio_bytes: &[u8]) -> Option<RustpotterDetection> {
if audio_bytes.len() != self.get_bytes_per_frame() {
return None;
}
let encoded_samples = self.wav_encoder.encode_and_resample(audio_bytes);
self.process_audio(encoded_samples)
}
/// Process encoded audio samples.
///
/// Number of samples provided should match the return of the get_samples_per_frame method.
///
pub fn process_samples<T: Sample>(
&mut self,
audio_samples: Vec<T>,
) -> Option<RustpotterDetection> {
if audio_samples.len() != self.get_samples_per_frame() {
return None;
}
let float_samples = self.wav_encoder.rencode_and_resample::<T>(audio_samples);
self.process_audio(float_samples)
}
/// Updates detector and audio filters configs.
///
pub fn update_config(&mut self, config: &RustpotterConfig) {
self.update_detector_config(&config.detector);
self.update_filters_config(&config.filters);
}
/// Updates detector config.
///
pub fn update_detector_config(&mut self, config: &DetectorConfig) {
self.avg_threshold = config.avg_threshold;
self.threshold = config.threshold;
self.min_scores = config.min_scores;
self.eager = config.eager;
self.band_size = config.band_size;
self.score_ref = config.score_ref;
self.score_mode = config.score_mode;
self.vad_detector = config.vad_mode.map(VadDetector::new);
#[cfg(feature = "record")]
{
self.record_path = config.record_path.clone();
}
for wd in self.wakewords.values_mut() {
wd.update_config(self.score_ref, self.band_size, self.score_mode);
}
self.reset();
}
/// Updates audio filters config.
///
pub fn update_filters_config(&mut self, config: &FiltersConfig) {
self.band_pass_filter = (&config.band_pass).into();
self.gain_normalizer_filter = (&config.gain_normalizer).into();
self.reset();
}
/// Clean internal State
///
pub fn reset(&mut self) {
self.buffering = true;
self.partial_detection = None;
self.audio_mfcc_window.clear();
self.mfcc_extractor.reset();
if let Some(vad) = self.vad_detector.as_mut() {
vad.reset();
}
#[cfg(feature = "record")]
{
self.audio_window.clear();
}
}
fn add_wakeword<T: WakewordFile>(&mut self, name: &str, wakeword: T) -> Result<(), String> {
if self.wakewords.is_empty() {
self.reset();
self.mfcc_extractor.set_out_size(wakeword.get_mfcc_size());
} else if !self
.wakewords
.values()
.next()
.unwrap()
.get_mfcc_size()
.eq(&wakeword.get_mfcc_size())
{
return Err(
"Usage of wakewords with different mfcc size is not supported, ignoring wakeword"
.to_string(),
);
}
self.wakewords.insert(
name.to_string(),
wakeword.get_detector(self.score_ref, self.band_size, self.score_mode),
);
self.on_wakeword_change();
Ok(())
}
fn on_wakeword_change(&mut self) {
let mut max_mfcc_frames = usize::MIN;
let mut target_rms_level = f32::NAN;
for wakeword in self.wakewords.values() {
max_mfcc_frames = wakeword.as_ref().get_mfcc_frame_size().max(max_mfcc_frames);
target_rms_level = wakeword.get_rms_level().max(target_rms_level);
}
self.max_mfcc_frames = max_mfcc_frames;
if let Some(gain_normalizer_filter) = self.gain_normalizer_filter.as_mut() {
gain_normalizer_filter.set_rms_level_ref(target_rms_level, self.max_mfcc_frames / 3);
}
self.buffering = self.audio_mfcc_window.len() < self.max_mfcc_frames;
#[cfg(feature = "record")]
{
self.max_audio_samples = (self.max_mfcc_frames
/ crate::constants::MFCCS_EXTRACTOR_OUT_SHIFTS)
* self.wav_encoder.get_output_frame_length();
}
}
fn process_audio(&mut self, mut audio_buffer: Vec<f32>) -> Option<RustpotterDetection> {
if self.wakewords.is_empty() {
return None;
}
#[cfg(feature = "record")]
if self.record_path.is_some() {
self.audio_window.append(&mut (audio_buffer.clone()));
if self.audio_window.len() > self.max_audio_samples {
self.audio_window.drain(0..audio_buffer.len());
}
}
self.rms_level = GainNormalizerFilter::get_rms_level(&audio_buffer);
if self.gain_normalizer_filter.is_some() {
self.gain = self
.gain_normalizer_filter
.as_mut()
.unwrap()
.filter(&mut audio_buffer, self.rms_level);
}
if self.band_pass_filter.is_some() {
self.band_pass_filter
.as_mut()
.unwrap()
.filter(&mut audio_buffer);
}
self.mfcc_extractor
.compute(&audio_buffer)
.into_iter()
.find_map(|mfccs| self.process_new_mfccs(mfccs))
}
fn process_new_mfccs(&mut self, mfcc_frame: Vec<f32>) -> Option<RustpotterDetection> {
let mut result: Option<RustpotterDetection> = None;
let should_run = self.partial_detection.is_some()
|| self
.vad_detector
.as_mut()
.map_or(true, |v| v.is_voice(&mfcc_frame));
self.audio_mfcc_window.push(mfcc_frame);
if self.audio_mfcc_window.len() >= self.max_mfcc_frames {
if self.buffering {
self.buffering = false;
}
if should_run {
result = self.run_detection();
}
}
if self.audio_mfcc_window.len() >= self.max_mfcc_frames {
self.audio_mfcc_window.drain(0..1);
}
result
}
fn run_detection(&mut self) -> Option<RustpotterDetection> {
if self.detection_countdown != 0 {
self.detection_countdown -= 1;
}
if self.partial_detection.is_some()
&& self.is_detection_done(self.partial_detection.as_ref().unwrap())
{
let wakeword_detection = self.partial_detection.take().unwrap();
if wakeword_detection.counter >= self.min_scores {
self.reset();
return Some(wakeword_detection);
}
}
let wakeword_detection = self.run_wakeword_detectors().map(|mut detection| {
detection.counter = self.partial_detection.as_ref().map_or(1, |d| d.counter + 1);
detection.gain = self.gain;
detection
});
if let Some(wakeword_detection) = wakeword_detection {
if self.partial_detection.is_none()
|| self.partial_detection.as_ref().unwrap().score < wakeword_detection.score
{
#[cfg(feature = "record")]
if let Some(record_path) = self.record_path.as_ref() {
self.create_audio_record(record_path, &wakeword_detection);
}
self.partial_detection = Some(wakeword_detection);
} else {
let partial_detection = self.partial_detection.as_mut().unwrap();
partial_detection.counter = wakeword_detection.counter;
}
self.detection_countdown = self.max_mfcc_frames / 2;
}
None
}
fn run_wakeword_detectors(&mut self) -> Option<RustpotterDetection> {
let mut wakeword_detections = self
.wakewords
.values()
.filter_map(|wakeword| {
wakeword.run_detection(
self.audio_mfcc_window.clone(),
self.avg_threshold,
self.threshold,
)
})
.collect::<Vec<RustpotterDetection>>();
wakeword_detections.sort_by(|a, b| b.score.total_cmp(&a.score));
wakeword_detections.into_iter().next()
}
fn is_detection_done(&self, detection: &RustpotterDetection) -> bool {
if self.detection_countdown == 0 {
true
} else {
self.eager && detection.counter >= self.min_scores
}
}
#[cfg(feature = "record")]
fn create_audio_record(&self, record_path: &str, detection: &RustpotterDetection) {
let spec = hound::WavSpec {
sample_rate: DETECTOR_INTERNAL_SAMPLE_RATE as u32,
sample_format: hound::SampleFormat::Float,
bits_per_sample: 32,
channels: 1,
};
let timestamp = std::time::UNIX_EPOCH.elapsed().unwrap().as_millis();
let record_folder = std::path::Path::new(record_path);
if !record_folder.exists() {
return;
}
let file_path = record_folder.join(
"[".to_string()
+ &detection.name
+ "]"
+ timestamp.to_string().as_str()
+ "-"
+ &detection.score.to_string().replace(".", "_")
+ ".wav",
);
let writer = hound::WavWriter::create(file_path.as_os_str(), spec);
if let Ok(mut writer) = writer {
self.audio_window
.iter()
.for_each(|sample| _ = writer.write_sample(*sample));
_ = writer.flush();
}
}
}
/// Encapsulates the detection information.
#[cfg_attr(feature = "debug", derive(Debug))]
pub struct RustpotterDetection {
/// Detected wakeword name.
pub name: String,
/// Detection score against the averaged template.
pub avg_score: f32,
/// Detection score.
pub score: f32,
/// Detection scores against each template.
pub scores: HashMap<String, f32>,
/// Partial detections counter.
pub counter: usize,
/// Gain applied to the scored frame
pub gain: f32,
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/constants.rs | src/constants.rs | pub const DETECTOR_INTERNAL_SAMPLE_RATE: usize = 16000;
pub const MFCCS_EXTRACTOR_FRAME_LENGTH_MS: usize = 30;
pub(crate) const COMPARATOR_DEFAULT_BAND_SIZE: u16 = 5;
pub(crate) const DETECTOR_DEFAULT_AVG_THRESHOLD: f32 = 0.2;
pub(crate) const DETECTOR_DEFAULT_THRESHOLD: f32 = 0.5;
pub(crate) const DETECTOR_DEFAULT_MIN_SCORES: usize = 5;
pub(crate) const DETECTOR_DEFAULT_REFERENCE: f32 = 0.22;
pub(crate) const MFCCS_EXTRACTOR_FRAME_SHIFT_MS: usize = 10;
pub(crate) const MFCCS_EXTRACTOR_PRE_EMPHASIS: f32 = 0.97;
pub(crate) const MFCCS_EXTRACTOR_OUT_SHIFTS: usize =
MFCCS_EXTRACTOR_FRAME_LENGTH_MS / MFCCS_EXTRACTOR_FRAME_SHIFT_MS;
pub(crate) const NN_NONE_LABEL: &str = "none";
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/wakewords/wakeword_file.rs | src/wakewords/wakeword_file.rs | use std::{fs::File, io::BufReader};
use ciborium::{de, ser};
use serde::{de::DeserializeOwned, Serialize};
use crate::ScoreMode;
use super::WakewordDetector;
pub trait WakewordSave: Serialize {
fn save_to_file(&self, path: &str) -> Result<(), String> {
let mut file = match File::create(path) {
Ok(it) => it,
Err(err) => {
return Err("Unable to open file ".to_owned() + path + ": " + &err.to_string())
}
};
ser::into_writer(self, &mut file).map_err(|err| err.to_string())?;
Ok(())
}
fn save_to_buffer(&self) -> Result<Vec<u8>, String> {
let mut bytes: Vec<u8> = Vec::new();
ser::into_writer(self, &mut bytes).map_err(|err| err.to_string())?;
Ok(bytes)
}
}
pub trait WakewordLoad: DeserializeOwned + Sized {
fn load_from_file(path: &str) -> Result<Self, String> {
let file = match File::open(path) {
Ok(it) => it,
Err(err) => {
return Err("Unable to open file ".to_owned() + path + ": " + &err.to_string())
}
};
let reader = BufReader::new(file);
de::from_reader(reader).map_err(|err| err.to_string())
}
fn load_from_buffer(buffer: &[u8]) -> Result<Self, String> {
let reader = BufReader::new(buffer);
de::from_reader(reader).map_err(|err| err.to_string())
}
}
pub(crate) trait WakewordFile {
fn get_detector(
&self,
score_ref: f32,
band_size: u16,
score_mode: ScoreMode,
) -> Box<dyn WakewordDetector>;
fn get_mfcc_size(&self) -> u16;
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/wakewords/wakeword_model.rs | src/wakewords/wakeword_model.rs | use std::collections::HashMap;
use serde::{Deserialize, Serialize};
use crate::ScoreMode;
use super::nn::{WakewordModelTrain, WakewordNN};
use super::{WakewordDetector, WakewordFile, WakewordLoad, WakewordSave};
#[derive(Serialize, Deserialize)]
pub struct WakewordModel {
pub labels: Vec<String>,
pub train_size: usize,
pub mfcc_size: u16,
pub m_type: ModelType,
pub weights: ModelWeights,
pub rms_level: f32,
}
impl WakewordLoad for WakewordModel {}
impl WakewordSave for WakewordModel {}
impl WakewordFile for WakewordModel {
fn get_detector(&self, score_ref: f32, _: u16, _: ScoreMode) -> Box<dyn WakewordDetector> {
Box::new(WakewordNN::new(self, score_ref))
}
fn get_mfcc_size(&self) -> u16 {
self.mfcc_size
}
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[derive(Serialize, Deserialize, Clone)]
pub enum ModelType {
Tiny = 0,
Small = 1,
Medium = 2,
Large = 3,
}
impl ModelType {
pub fn as_str(&self) -> &'static str {
match self {
Self::Tiny => "tiny",
Self::Small => "small",
Self::Medium => "medium",
Self::Large => "large",
}
}
}
impl std::str::FromStr for ModelType {
type Err = String;
fn from_str(s: &str) -> std::result::Result<Self, String> {
match s.to_lowercase().as_str() {
"tiny" => Ok(Self::Tiny),
"small" => Ok(Self::Small),
"medium" => Ok(Self::Medium),
"large" => Ok(Self::Large),
_ => Err("Unknown model type".to_string()),
}
}
}
#[cfg(feature = "display")]
impl std::fmt::Display for ModelType {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.as_str())
}
}
#[derive(Serialize, Deserialize)]
pub struct TensorData {
pub bytes: Vec<u8>,
pub dims: Vec<usize>,
pub d_type: String,
}
pub type ModelWeights = HashMap<String, TensorData>;
impl WakewordModelTrain for WakewordModel {}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/wakewords/wakeword_v2.rs | src/wakewords/wakeword_v2.rs | use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use crate::{WakewordLoad, WakewordRef};
/// Deprecated wakeword representation from v2
#[derive(Serialize, Deserialize)]
pub struct WakewordV2 {
pub name: String,
pub avg_features: Option<Vec<Vec<f32>>>,
pub samples_features: HashMap<String, Vec<Vec<f32>>>,
pub threshold: Option<f32>,
pub avg_threshold: Option<f32>,
pub rms_level: f32,
pub enabled: bool,
}
impl WakewordLoad for WakewordV2 {}
impl From<WakewordV2> for WakewordRef {
fn from(val: WakewordV2) -> Self {
WakewordRef {
name: val.name,
mfcc_size: val.samples_features.values().next().unwrap()[0].len() as u16,
threshold: val.threshold,
avg_threshold: val.avg_threshold,
avg_features: val.avg_features,
samples_features: val.samples_features,
rms_level: val.rms_level,
}
}
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/wakewords/wakeword_detector.rs | src/wakewords/wakeword_detector.rs | use crate::{RustpotterDetection, ScoreMode};
pub(crate) trait WakewordDetector: Send {
fn get_mfcc_frame_size(&self) -> usize;
fn get_mfcc_size(&self) -> u16;
fn run_detection(
&self,
mfcc_frame: Vec<Vec<f32>>,
avg_threshold: f32,
threshold: f32,
) -> Option<RustpotterDetection>;
fn get_rms_level(&self) -> f32;
fn update_config(&mut self, score_ref: f32, band_size: u16, score_mode: ScoreMode);
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/wakewords/mod.rs | src/wakewords/mod.rs | mod comp;
mod nn;
mod wakeword_detector;
mod wakeword_file;
mod wakeword_model;
mod wakeword_ref;
mod wakeword_v2;
pub use comp::{WakewordRefBuildFromBuffers, WakewordRefBuildFromFiles};
pub use nn::{WakewordModelTrain, WakewordModelTrainOptions};
pub(crate) use wakeword_detector::WakewordDetector;
pub(crate) use wakeword_file::WakewordFile;
pub use wakeword_file::{WakewordLoad, WakewordSave};
pub use wakeword_model::{ModelType, ModelWeights, TensorData, WakewordModel};
pub use wakeword_ref::WakewordRef;
pub(crate) use wakeword_v2::WakewordV2;
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/wakewords/wakeword_ref.rs | src/wakewords/wakeword_ref.rs | use super::{comp::WakewordComparator, WakewordDetector, WakewordFile};
use crate::{
mfcc::MfccComparator,
wakewords::{WakewordLoad, WakewordSave},
ScoreMode, WakewordRefBuildFromBuffers, WakewordRefBuildFromFiles,
};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
/// Wakeword representation.
#[derive(Serialize, Deserialize)]
pub struct WakewordRef {
pub name: String,
pub avg_features: Option<Vec<Vec<f32>>>,
pub samples_features: HashMap<String, Vec<Vec<f32>>>,
pub threshold: Option<f32>,
pub avg_threshold: Option<f32>,
pub rms_level: f32,
pub mfcc_size: u16,
}
impl WakewordLoad for WakewordRef {}
impl WakewordSave for WakewordRef {}
impl WakewordRefBuildFromBuffers for WakewordRef {}
impl WakewordRefBuildFromFiles for WakewordRef {}
impl WakewordFile for WakewordRef {
fn get_detector(
&self,
score_ref: f32,
band_size: u16,
score_mode: ScoreMode,
) -> Box<dyn WakewordDetector> {
Box::new(WakewordComparator::new(
self,
MfccComparator::new(score_ref, band_size),
score_mode,
))
}
fn get_mfcc_size(&self) -> u16 {
self.mfcc_size
}
}
impl WakewordRef {
pub(crate) fn new(
name: String,
threshold: Option<f32>,
avg_threshold: Option<f32>,
avg_features: Option<Vec<Vec<f32>>>,
rms_level: f32,
samples_features: HashMap<String, Vec<Vec<f32>>>,
) -> Result<WakewordRef, String> {
if samples_features.is_empty() {
return Err("Can not create an empty wakeword".to_string());
}
let mfcc_size = samples_features.values().next().unwrap()[0].len() as u16;
Ok(WakewordRef {
name,
threshold,
avg_threshold,
avg_features,
samples_features,
rms_level,
mfcc_size,
})
}
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/wakewords/comp/wakeword_ref_build.rs | src/wakewords/comp/wakeword_ref_build.rs | use std::{cmp::Ordering, collections::HashMap, fs::File, io::BufReader, path::Path};
use crate::{
mfcc::{MfccAverager, MfccWavFileExtractor},
WakewordRef,
};
pub trait WakewordRefBuildFromBuffers {
fn new_from_sample_buffers(
name: String,
threshold: Option<f32>,
avg_threshold: Option<f32>,
samples: HashMap<String, Vec<u8>>,
mfcc_size: u16,
) -> Result<WakewordRef, String> {
let mut samples_features: HashMap<String, Vec<Vec<f32>>> = HashMap::new();
let mut rms_level = 0.;
for (key, buffer) in samples {
let mut sample_rms_level = 0.;
samples_features.insert(
key,
MfccWavFileExtractor::compute_mfccs(
BufReader::new(buffer.as_slice()),
&mut sample_rms_level,
mfcc_size,
)?,
);
if sample_rms_level > rms_level {
rms_level = sample_rms_level;
}
}
WakewordRef::new(
name,
threshold,
avg_threshold,
compute_avg_samples_features(&samples_features),
rms_level,
samples_features,
)
}
}
pub trait WakewordRefBuildFromFiles {
fn new_from_sample_files(
name: String,
threshold: Option<f32>,
avg_threshold: Option<f32>,
samples: Vec<String>,
mfcc_size: u16,
) -> Result<WakewordRef, String> {
let mut samples_features: HashMap<String, Vec<Vec<f32>>> = HashMap::new();
let mut rms_levels: Vec<f32> = Vec::new();
for sample_path in samples {
let path = Path::new(&sample_path);
if !path.exists() || !path.is_file() {
return Err("File not found: ".to_owned() + &sample_path);
}
let file = match File::open(&sample_path) {
Ok(it) => it,
Err(err) => {
return Err("Unable to open file ".to_owned()
+ &sample_path
+ ": "
+ &err.to_string())
}
};
let mut sample_rms_level = 0.;
samples_features.insert(
String::from(path.file_name().unwrap().to_str().unwrap()),
MfccWavFileExtractor::compute_mfccs(
BufReader::new(file),
&mut sample_rms_level,
mfcc_size,
)?,
);
rms_levels.push(sample_rms_level);
}
rms_levels.sort_by(|a, b| a.total_cmp(b));
let rms_level = rms_levels[rms_levels.len() / 2];
WakewordRef::new(
name,
threshold,
avg_threshold,
compute_avg_samples_features(&samples_features),
rms_level,
samples_features,
)
}
}
fn compute_avg_samples_features(
templates: &HashMap<String, Vec<Vec<f32>>>,
) -> Option<Vec<Vec<f32>>> {
if templates.len() <= 1 {
return None;
}
let mut template_values: Vec<_> = templates.iter().collect();
template_values.sort_by(|a, b| {
let equality = b.1.len().cmp(&a.1.len());
if equality == Ordering::Equal {
a.0.cmp(b.0)
} else {
equality
}
});
let template_vec = template_values
.iter()
.map(|(_, sample)| sample.to_vec())
.collect::<Vec<Vec<Vec<f32>>>>();
MfccAverager::average(template_vec)
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/wakewords/comp/wakeword_comp.rs | src/wakewords/comp/wakeword_comp.rs | use std::collections::HashMap;
use crate::{
mfcc::{MfccComparator, MfccNormalizer},
wakewords::WakewordDetector,
RustpotterDetection, ScoreMode, WakewordRef,
};
pub(crate) struct WakewordComparator {
name: String,
avg_features: Option<Vec<Vec<f32>>>,
samples_features: HashMap<String, Vec<Vec<f32>>>,
threshold: Option<f32>,
avg_threshold: Option<f32>,
rms_level: f32,
// state
score_mode: ScoreMode,
mfcc_comparator: MfccComparator,
}
impl WakewordComparator {
fn cut_and_normalize_frame(&self, mut mfccs: Vec<Vec<f32>>, max_len: usize) -> Vec<Vec<f32>> {
if mfccs.len() > max_len {
mfccs.drain(max_len..mfccs.len());
}
MfccNormalizer::normalize(mfccs)
}
fn score_frame(&self, frame_features: &[Vec<f32>], template: &[Vec<f32>]) -> f32 {
let score = self.mfcc_comparator.compare(
&template.iter().map(|item| &item[..]).collect::<Vec<_>>(),
&frame_features
.iter()
.map(|item| &item[..])
.collect::<Vec<_>>(),
);
score
}
fn get_percentile(&self, sorted_values: &[f32], percentile: f32) -> f32 {
let n = sorted_values.len();
let index = percentile / 100.0 * (n - 1) as f32;
let index_floor = index.floor();
if index_floor == index {
sorted_values[index as usize]
} else {
let i = index_floor as usize;
let d = index - index_floor;
sorted_values[i] * (1.0 - d) + sorted_values[i + 1] * d
}
}
pub fn new(
wakeword: &WakewordRef,
mfcc_comparator: MfccComparator,
score_mode: ScoreMode,
) -> Self {
WakewordComparator {
name: wakeword.name.clone(),
avg_features: wakeword.avg_features.clone(),
samples_features: wakeword.samples_features.clone(),
threshold: wakeword.threshold,
avg_threshold: wakeword.avg_threshold,
rms_level: wakeword.rms_level,
score_mode,
mfcc_comparator,
}
}
}
impl WakewordDetector for WakewordComparator {
fn get_mfcc_frame_size(&self) -> usize {
self.samples_features
.values()
.map(Vec::len)
.max()
.unwrap_or(usize::MIN)
}
fn run_detection(
&self,
mfcc_frame: Vec<Vec<f32>>,
avg_threshold: f32,
threshold: f32,
) -> Option<RustpotterDetection> {
let avg_threshold = self.avg_threshold.unwrap_or(avg_threshold);
let mut avg_score = 0.;
if self.avg_features.is_some() && avg_threshold != 0. {
// discard detections against the wakeword averaged features
let wakeword_samples_avg_features = self.avg_features.as_ref().unwrap();
let mfcc_window_normalized = self
.cut_and_normalize_frame(mfcc_frame.to_vec(), wakeword_samples_avg_features.len());
avg_score = self.score_frame(&mfcc_window_normalized, wakeword_samples_avg_features);
if avg_score < avg_threshold {
return None;
}
}
let threshold = self.threshold.unwrap_or(threshold);
let scores = self.samples_features.iter().fold(
HashMap::new(),
|mut acc: HashMap<String, f32>, (name, wakeword_sample_features)| {
let frame_features_normalized = self
.cut_and_normalize_frame(mfcc_frame.to_vec(), wakeword_sample_features.len());
acc.insert(
name.to_string(),
self.score_frame(&frame_features_normalized, wakeword_sample_features),
);
acc
},
);
let mut sorted_scores = scores.values().copied().collect::<Vec<f32>>();
let score = match self.score_mode {
ScoreMode::Average => sorted_scores.iter().sum::<f32>() / sorted_scores.len() as f32,
ScoreMode::Max => {
sorted_scores.sort_by(|a, b| b.total_cmp(a));
sorted_scores[0]
}
ScoreMode::Median | ScoreMode::P50 => {
sorted_scores.sort_by(|a, b| a.total_cmp(b));
self.get_percentile(&sorted_scores, 50.)
}
ScoreMode::P25 => {
sorted_scores.sort_by(|a, b| a.total_cmp(b));
self.get_percentile(&sorted_scores, 25.)
}
ScoreMode::P75 => {
sorted_scores.sort_by(|a, b| a.total_cmp(b));
self.get_percentile(&sorted_scores, 75.)
}
ScoreMode::P80 => {
sorted_scores.sort_by(|a, b| a.total_cmp(b));
self.get_percentile(&sorted_scores, 80.)
}
ScoreMode::P90 => {
sorted_scores.sort_by(|a, b| a.total_cmp(b));
self.get_percentile(&sorted_scores, 90.)
}
ScoreMode::P95 => {
sorted_scores.sort_by(|a, b| a.total_cmp(b));
self.get_percentile(&sorted_scores, 95.)
}
};
if score > threshold {
Some(RustpotterDetection {
name: self.name.clone(),
avg_score,
score,
scores,
counter: usize::MIN, // added by the detector
gain: f32::NAN, // added by the detector
})
} else {
None
}
}
fn get_rms_level(&self) -> f32 {
self.rms_level
}
fn get_mfcc_size(&self) -> u16 {
self.samples_features.values().next().unwrap()[0].len() as u16
}
fn update_config(&mut self, score_ref: f32, band_size: u16, score_mode: ScoreMode) {
self.score_mode = score_mode;
self.mfcc_comparator = MfccComparator::new(score_ref, band_size);
}
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/wakewords/comp/mod.rs | src/wakewords/comp/mod.rs | mod wakeword_comp;
mod wakeword_ref_build;
pub(crate) use wakeword_comp::WakewordComparator;
pub use wakeword_ref_build::{WakewordRefBuildFromBuffers, WakewordRefBuildFromFiles};
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/wakewords/nn/wakeword_nn.rs | src/wakewords/nn/wakeword_nn.rs | use crate::{
constants::{MFCCS_EXTRACTOR_OUT_SHIFTS, NN_NONE_LABEL},
mfcc::MfccNormalizer,
wakewords::WakewordDetector,
wakewords::{ModelWeights, TensorData},
ModelType, RustpotterDetection, ScoreMode, WakewordModel,
};
use candle_core::{DType, Device, Tensor, Var};
use candle_nn::{Linear, Module, VarBuilder, VarMap};
use std::{collections::HashMap, io::Cursor, str::FromStr};
pub(crate) struct WakewordNN {
_var_map: VarMap,
model: Box<dyn ModelImpl>,
mfcc_frames: usize,
labels: Vec<String>,
score_ref: f32,
rms_level: f32,
mfcc_size: u16,
}
impl WakewordNN {
pub fn new(wakeword_model: &WakewordModel, score_ref: f32) -> Self {
let var_map = VarMap::new();
let m_type = wakeword_model.m_type.clone();
let model = init_model(
m_type,
&var_map,
&Device::Cpu,
wakeword_model.train_size * wakeword_model.mfcc_size as usize,
wakeword_model.mfcc_size,
wakeword_model.labels.len(),
Some(wakeword_model),
)
.unwrap();
WakewordNN {
_var_map: var_map,
model,
score_ref: score_ref * 10.,
rms_level: wakeword_model.rms_level,
labels: wakeword_model.labels.clone(),
mfcc_frames: wakeword_model.train_size,
mfcc_size: wakeword_model.mfcc_size,
}
}
fn get_label(&self, prob_vec: &[f32]) -> Option<&str> {
prob_vec
.iter()
.enumerate()
.max_by(|(_, a), (_, b)| a.total_cmp(b))
.map(|(index, _)| index)
.map(|i| {
if i < self.labels.len() {
&self.labels[i]
} else {
NN_NONE_LABEL
}
})
}
fn run_detection_by_label(
&self,
label: &str,
prob_vec: &[f32],
calc_avg_score: bool,
) -> Option<RustpotterDetection> {
if !NN_NONE_LABEL.eq(label) {
let scores: HashMap<String, f32> = prob_vec
.iter()
.enumerate()
.map(|(i, prob)| (self.labels[i].clone(), *prob))
.collect();
let none_prob = scores.get(NN_NONE_LABEL).unwrap_or(&0.);
let label_prob = scores.get(label).unwrap_or(&0.);
let second_prob = if calc_avg_score {
prob_vec
.iter()
.filter(|p| !label_prob.eq(*p))
.max_by(|a, b| b.total_cmp(a))
.unwrap_or(&0.)
} else {
&0.
};
Some(RustpotterDetection {
name: label.to_string(),
avg_score: if calc_avg_score {
calc_inverse_similarity(label_prob, second_prob, &self.score_ref)
} else {
0.
},
score: calc_inverse_similarity(label_prob, none_prob, &self.score_ref),
scores,
counter: usize::MIN, // added by the detector
gain: f32::NAN, // added by the detector
})
} else {
None
}
}
fn predict_labels(&self, mfcc_frame: Vec<Vec<f32>>) -> Option<Vec<f32>> {
Tensor::from_iter(flat_features(mfcc_frame).into_iter(), &Device::Cpu)
.and_then(|tensor| Tensor::stack(&[tensor], 0))
.and_then(|tensor_stack| self.model.forward(&tensor_stack))
.and_then(|logits| logits.get(0))
.and_then(|logits1| logits1.to_vec1::<f32>())
.map_err(|err| {
println!("Error running wakeword nn: {}", err);
err
})
.ok()
}
fn validate_scores(
&self,
detection: RustpotterDetection,
threshold: f32,
avg_threshold: f32,
) -> Option<RustpotterDetection> {
if detection.score >= threshold && detection.avg_score >= avg_threshold {
Some(detection)
} else {
None
}
}
fn handle_probabilities(
&self,
prob_vec: Vec<f32>,
calc_avg_score: bool,
) -> Option<RustpotterDetection> {
self.get_label(&prob_vec)
.and_then(|label| self.run_detection_by_label(label, &prob_vec, calc_avg_score))
}
}
impl WakewordDetector for WakewordNN {
fn get_mfcc_frame_size(&self) -> usize {
self.mfcc_frames
}
fn run_detection(
&self,
mut mfcc_frames: Vec<Vec<f32>>,
avg_threshold: f32,
threshold: f32,
) -> Option<RustpotterDetection> {
mfcc_frames.truncate(self.mfcc_frames);
self.predict_labels(MfccNormalizer::normalize(mfcc_frames))
.and_then(|prob_vec| self.handle_probabilities(prob_vec, avg_threshold != 0.))
.and_then(|detection| self.validate_scores(detection, threshold, avg_threshold))
}
fn get_rms_level(&self) -> f32 {
self.rms_level
}
fn get_mfcc_size(&self) -> u16 {
self.mfcc_size
}
fn update_config(&mut self, score_ref: f32, _: u16, _: ScoreMode) {
self.score_ref = score_ref * 10.;
}
}
fn calc_inverse_similarity(n1: &f32, n2: &f32, reference: &f32) -> f32 {
1. - (1. / (1. + (((n1 - n2) - reference) / reference).exp()))
}
pub(crate) fn init_model(
m_type: ModelType,
var_map: &VarMap,
dev: &Device,
features_size: usize,
mfcc_size: u16,
labels_size: usize,
wakeword: Option<&WakewordModel>,
) -> Result<Box<dyn ModelImpl>, candle_core::Error> {
match m_type {
ModelType::Tiny => init_model_impl::<TinyModel>(
var_map,
dev,
features_size,
mfcc_size,
labels_size,
wakeword,
),
ModelType::Small => init_model_impl::<SmallModel>(
var_map,
dev,
features_size,
mfcc_size,
labels_size,
wakeword,
),
ModelType::Medium => init_model_impl::<MediumModel>(
var_map,
dev,
features_size,
mfcc_size,
labels_size,
wakeword,
),
ModelType::Large => init_model_impl::<LargeModel>(
var_map,
dev,
features_size,
mfcc_size,
labels_size,
wakeword,
),
}
}
pub(super) fn init_model_impl<M: ModelImpl + 'static>(
var_map: &VarMap,
dev: &Device,
features_size: usize,
mfcc_size: u16,
labels_size: usize,
wakeword: Option<&WakewordModel>,
) -> Result<Box<dyn ModelImpl>, candle_core::Error> {
let vs = VarBuilder::from_varmap(var_map, DType::F32, dev);
let model = M::new(vs.clone(), features_size, mfcc_size as usize, labels_size)?;
if let Some(wakeword) = wakeword {
load_weights(var_map, &wakeword.weights)?;
}
Ok(Box::new(model))
}
pub(crate) fn get_tensors_data(var_map: VarMap) -> ModelWeights {
let mut model_weights: HashMap<String, TensorData> = HashMap::new();
for (name, tensor) in var_map.data().lock().unwrap().iter() {
model_weights.insert(name.to_string(), tensor.into());
}
model_weights
}
impl From<&Var> for TensorData {
fn from(tensor: &Var) -> Self {
let mut w = Cursor::new(Vec::new());
let dims = tensor.shape().clone().into_dims();
tensor.write_bytes(&mut w).unwrap();
TensorData {
bytes: w.into_inner(),
d_type: tensor.dtype().as_str().to_string(),
dims,
}
}
}
fn load_weights(
var_map: &VarMap,
model_weights: &HashMap<String, TensorData>,
) -> Result<(), candle_core::Error> {
for (name, var) in var_map.data().lock().unwrap().iter_mut() {
model_weights
.get(name)
.map(|data| var.set(&data.into()))
.unwrap_or(Err(candle_core::Error::Io(std::io::Error::new(
std::io::ErrorKind::Other,
"Incorrect model layers",
))))?;
}
Ok(())
}
impl From<&TensorData> for Tensor {
fn from(val: &TensorData) -> Self {
let d_type = DType::from_str(&val.d_type).unwrap_or(DType::F32);
Tensor::from_raw_buffer(&val.bytes, d_type, &val.dims, &Device::Cpu).unwrap()
}
}
pub(super) fn flat_features(features: Vec<Vec<f32>>) -> Vec<f32> {
features
.into_iter()
.flat_map(|array| array.into_iter())
.collect()
}
pub(super) struct LargeModel {
ln1: Linear,
ln2: Linear,
ln3: Linear,
}
pub(super) struct MediumModel {
ln1: Linear,
ln2: Linear,
ln3: Linear,
}
pub(super) struct SmallModel {
ln1: Linear,
ln2: Linear,
ln3: Linear,
}
pub(super) struct TinyModel {
ln1: Linear,
ln2: Linear,
}
pub(crate) trait ModelImpl: Send {
fn new(
vs: VarBuilder,
input_size: usize,
mfcc_size: usize,
labels_size: usize,
) -> candle_core::Result<Self>
where
Self: Sized;
fn forward(&self, xs: &Tensor) -> candle_core::Result<Tensor>;
}
impl ModelImpl for TinyModel {
fn new(
vs: VarBuilder,
input_size: usize,
mfcc_size: usize,
labels_size: usize,
) -> candle_core::Result<Self> {
let inter_size = (input_size / mfcc_size) / (MFCCS_EXTRACTOR_OUT_SHIFTS * 5);
let ln1 = candle_nn::linear(input_size, inter_size, vs.pp("ln1"))?;
let ln2 = candle_nn::linear(inter_size, labels_size, vs.pp("ln2"))?;
Ok(Self { ln1, ln2 })
}
fn forward(&self, xs: &Tensor) -> candle_core::Result<Tensor> {
let xs = self.ln1.forward(xs)?;
let xs = xs.relu()?;
self.ln2.forward(&xs)
}
}
impl ModelImpl for SmallModel {
fn new(
vs: VarBuilder,
input_size: usize,
mfcc_size: usize,
labels_size: usize,
) -> candle_core::Result<Self> {
let inter_size1 = (input_size / mfcc_size) / (MFCCS_EXTRACTOR_OUT_SHIFTS * 2);
let ln1 = candle_nn::linear(input_size, inter_size1, vs.pp("ln1"))?;
let inter_size2 = inter_size1 / 2;
let ln2: Linear = candle_nn::linear(inter_size1, inter_size2, vs.pp("ln2"))?;
let ln3: Linear = candle_nn::linear(inter_size2, labels_size, vs.pp("ln3"))?;
Ok(Self { ln1, ln2, ln3 })
}
fn forward(&self, xs: &Tensor) -> candle_core::Result<Tensor> {
let xs = self.ln1.forward(xs)?.relu()?;
let xs = self.ln2.forward(&xs)?.relu()?;
self.ln3.forward(&xs)
}
}
impl ModelImpl for MediumModel {
fn new(
vs: VarBuilder,
input_size: usize,
mfcc_size: usize,
labels_size: usize,
) -> candle_core::Result<Self> {
let inter_size1 = (input_size / mfcc_size) / MFCCS_EXTRACTOR_OUT_SHIFTS;
let ln1 = candle_nn::linear(input_size, inter_size1, vs.pp("ln1"))?;
let inter_size2 = (input_size / mfcc_size) / (MFCCS_EXTRACTOR_OUT_SHIFTS * 2);
let ln2: Linear = candle_nn::linear(inter_size1, inter_size2, vs.pp("ln2"))?;
let ln3: Linear = candle_nn::linear(inter_size2, labels_size, vs.pp("ln3"))?;
Ok(Self { ln1, ln2, ln3 })
}
fn forward(&self, xs: &Tensor) -> candle_core::Result<Tensor> {
let xs = self.ln1.forward(xs)?.relu()?;
let xs = self.ln2.forward(&xs)?.relu()?;
self.ln3.forward(&xs)
}
}
impl ModelImpl for LargeModel {
fn new(
vs: VarBuilder,
input_size: usize,
mfcc_size: usize,
labels_size: usize,
) -> candle_core::Result<Self> {
let inter_size1 = ((input_size / mfcc_size) / MFCCS_EXTRACTOR_OUT_SHIFTS) * 2;
let ln1 = candle_nn::linear(input_size, inter_size1, vs.pp("ln1"))?;
let inter_size2 = (input_size / mfcc_size) / (MFCCS_EXTRACTOR_OUT_SHIFTS * 2);
let ln2: Linear = candle_nn::linear(inter_size1, inter_size2, vs.pp("ln2"))?;
let ln3: Linear = candle_nn::linear(inter_size2, labels_size, vs.pp("ln3"))?;
Ok(Self { ln1, ln2, ln3 })
}
fn forward(&self, xs: &Tensor) -> candle_core::Result<Tensor> {
let xs = self.ln1.forward(xs)?.relu()?;
let xs = self.ln2.forward(&xs)?.relu()?;
self.ln3.forward(&xs)
}
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/wakewords/nn/wakeword_model_train.rs | src/wakewords/nn/wakeword_model_train.rs | use super::wakeword_nn::{
flat_features, get_tensors_data, init_model_impl, LargeModel, MediumModel, ModelImpl, TinyModel,
};
use crate::{
constants::NN_NONE_LABEL,
mfcc::MfccWavFileExtractor,
wakewords::{nn::wakeword_nn::SmallModel, ModelWeights},
ModelType, WakewordModel,
};
use candle_core::{DType, Device, Tensor, D};
use candle_nn::Optimizer;
use candle_nn::{loss, ops, VarMap};
use std::{
collections::HashMap,
fs,
io::{BufReader, Error, ErrorKind},
};
pub struct WakewordModelTrainOptions {
m_type: ModelType,
learning_rate: f64,
epochs: usize,
test_epochs: usize,
mfcc_size: u16,
}
impl WakewordModelTrainOptions {
pub fn new(
m_type: ModelType,
learning_rate: f64,
epochs: usize,
test_epochs: usize,
mfcc_size: u16,
) -> Self {
Self {
m_type,
learning_rate,
epochs,
test_epochs,
mfcc_size,
}
}
}
pub trait WakewordModelTrain {
fn train_from_buffers(
options: WakewordModelTrainOptions,
samples: HashMap<String, Vec<u8>>,
test_samples: HashMap<String, Vec<u8>>,
wakeword_model: Option<WakewordModel>,
) -> Result<WakewordModel, Error> {
if samples.is_empty() {
return Err(std::io::Error::new(
ErrorKind::Other,
"No training data provided",
));
}
if test_samples.is_empty() {
return Err(std::io::Error::new(
ErrorKind::Other,
"No test data provided",
));
}
// prepare data
if wakeword_model.is_some() {
println!("Training from previous model, some options will be ignored.");
}
let mut labels: Vec<String> = wakeword_model
.as_ref()
.map(|m| m.labels.clone())
.unwrap_or_else(Vec::new);
let m_type = wakeword_model
.as_ref()
.map(|m| m.m_type.clone())
.unwrap_or(options.m_type);
let mfcc_size = wakeword_model
.as_ref()
.map(|m| m.mfcc_size)
.unwrap_or(options.mfcc_size);
let mut rms_level: f32 = f32::NAN;
let mut labeled_mfccs = get_mfccs_labeled(
&samples,
&mut labels,
&mut rms_level,
wakeword_model.is_none(),
mfcc_size,
)?;
let mut noop_rms_level: f32 = f32::NAN;
let mut test_labeled_mfccs = get_mfccs_labeled(
&test_samples,
&mut labels,
&mut noop_rms_level,
false,
mfcc_size,
)?;
println!("Model type: {}.", m_type.as_str());
println!("Labels: {:?}.", labels);
println!("Training with {} records.", labeled_mfccs.len());
println!("Testing with {} records.", test_labeled_mfccs.len());
// validate labels
if labels.len() < 2 {
return Err(std::io::Error::new(
ErrorKind::Other,
"Your training data need to contain at least two labels",
));
}
// use previous training size or get it from the training samples
let input_len = wakeword_model
.as_ref()
.map(|m| m.train_size * mfcc_size as usize)
.unwrap_or_else(|| labeled_mfccs.iter().map(|f| f.0.len()).max().unwrap());
println!(
"Training on {}ms of audio.",
(input_len / mfcc_size as usize) * 10
);
// pad or truncate data
labeled_mfccs
.iter_mut()
.chain(test_labeled_mfccs.iter_mut())
.for_each(|i| i.0.resize(input_len, 0.));
// run training loop
let dataset = WakewordDataset {
input_len,
mfcc_size,
labels: labels.len(),
train_labels: get_labels_tensor_stack(&labeled_mfccs)?,
train_features: get_mfccs_tensor_stack(labeled_mfccs)?,
test_labels: get_labels_tensor_stack(&test_labeled_mfccs)?,
test_features: get_mfccs_tensor_stack(test_labeled_mfccs)?,
};
let training_args = TrainingArgs {
learning_rate: options.learning_rate,
epochs: options.epochs,
test_epochs: options.test_epochs,
};
let weights = match m_type {
ModelType::Tiny => training_loop::<TinyModel>(dataset, &training_args, wakeword_model)
.map_err(convert_error)?,
ModelType::Small => {
training_loop::<SmallModel>(dataset, &training_args, wakeword_model)
.map_err(convert_error)?
}
ModelType::Medium => {
training_loop::<MediumModel>(dataset, &training_args, wakeword_model)
.map_err(convert_error)?
}
ModelType::Large => {
training_loop::<LargeModel>(dataset, &training_args, wakeword_model)
.map_err(convert_error)?
}
};
// return serializable model struct
Ok(WakewordModel {
labels,
m_type,
train_size: input_len / mfcc_size as usize,
mfcc_size,
weights,
rms_level,
})
}
fn train_from_dirs(
options: WakewordModelTrainOptions,
train_dir: String,
test_dir: String,
wakeword_model: Option<WakewordModel>,
) -> Result<WakewordModel, Error> {
Self::train_from_buffers(
options,
get_files_data_map(train_dir)?,
get_files_data_map(test_dir)?,
wakeword_model,
)
}
}
fn training_loop<M: ModelImpl + 'static>(
m: WakewordDataset,
args: &TrainingArgs,
wakeword: Option<WakewordModel>,
) -> candle_core::Result<ModelWeights> {
let dev = Device::Cpu;
let train_labels = m.train_labels;
let train_features = m.train_features.to_device(&dev)?;
let train_labels = train_labels.to_dtype(DType::U32)?.to_device(&dev)?;
let var_map = VarMap::new();
let from_wakeword = wakeword.is_some();
let model = init_model_impl::<M>(
&var_map,
&dev,
m.input_len,
m.mfcc_size,
m.labels,
wakeword.as_ref(),
)?;
let mut sgd = candle_nn::SGD::new(var_map.all_vars(), args.learning_rate).unwrap();
let test_features = m.test_features.to_device(&dev)?;
let test_labels = m.test_labels.to_dtype(DType::U32)?.to_device(&dev)?;
if from_wakeword {
// test current accuracy
test_model(model.as_ref(), &test_features, &test_labels, 0., 0)?;
}
for epoch in 1..=args.epochs {
let logits = model.forward(&train_features)?;
let log_sm = ops::log_softmax(&logits, D::Minus1)?;
let loss = loss::nll(&log_sm, &train_labels)?;
sgd.backward_step(&loss)?;
// test progress
if (epoch % args.test_epochs) == 0 || epoch == args.epochs {
test_model(
model.as_ref(),
&test_features,
&test_labels,
loss.to_scalar::<f32>()?,
epoch,
)?;
}
}
Ok(get_tensors_data(var_map))
}
struct WakewordDataset {
pub train_features: Tensor,
pub train_labels: Tensor,
pub test_features: Tensor,
pub test_labels: Tensor,
pub labels: usize,
pub input_len: usize,
pub mfcc_size: u16,
}
struct TrainingArgs {
learning_rate: f64,
epochs: usize,
test_epochs: usize,
}
fn get_files_data_map(train_dir: String) -> Result<HashMap<String, Vec<u8>>, Error> {
let paths = fs::read_dir(train_dir)?;
let mut files_map: HashMap<String, Vec<u8>> = HashMap::new();
for path_result in paths {
let path = path_result.unwrap().path();
let filename = path.file_name().unwrap().to_str().unwrap();
if filename.to_string().ends_with(".wav") {
files_map.insert(String::from(filename), std::fs::read(path.as_path())?);
}
}
Ok(files_map)
}
fn test_model<S: candle_core::WithDType>(
model: &dyn ModelImpl,
test_features: &Tensor,
test_labels: &Tensor,
loss: S,
epoch: usize,
) -> Result<(), candle_core::Error> {
let test_logits = model.forward(test_features)?;
let sum_ok = test_logits
.argmax(D::Minus1)?
.eq(test_labels)?
.to_dtype(DType::F32)?
.sum_all()?
.to_scalar::<f32>()?;
let test_accuracy = sum_ok / test_labels.dims1()? as f32;
println!(
"{epoch:4} train loss: {:8.5} test acc: {:5.2}%",
loss,
100. * test_accuracy
);
Ok(())
}
fn get_labels_tensor_stack(labeled_features: &[(Vec<f32>, u32)]) -> Result<Tensor, Error> {
Tensor::from_iter(labeled_features.iter().map(|lf| lf.1), &Device::Cpu).map_err(convert_error)
}
fn get_mfccs_tensor_stack(labeled_mfccs: Vec<(Vec<f32>, u32)>) -> Result<Tensor, Error> {
let tensors_result: Result<Vec<Tensor>, Error> = labeled_mfccs
.into_iter()
.map(|lf| Tensor::from_iter(lf.0.into_iter(), &Device::Cpu).map_err(convert_error))
.collect();
Tensor::stack(&tensors_result?, 0).map_err(convert_error)
}
fn convert_error(err: candle_core::Error) -> Error {
Error::new(ErrorKind::Other, format!("{}", err))
}
fn get_mfccs_labeled(
samples: &HashMap<String, Vec<u8>>,
labels: &mut Vec<String>,
sample_rms_level: &mut f32,
new_labels: bool,
mfcc_size: u16,
) -> Result<Vec<(Vec<f32>, u32)>, Error> {
let mut labeled_data: Vec<(Vec<f32>, u32)> = Vec::new();
for (name, buffer) in samples {
let init_token_index = name.chars().position(|c| c == '[');
let end_token_index = name
.chars()
.position(|c| c == ']')
.filter(|end| init_token_index.map(|start| start < *end).unwrap_or(false));
let label = if let (Some(init_token_index), Some(end_token_index)) =
(init_token_index, end_token_index)
{
name[init_token_index + 1..end_token_index].to_lowercase()
} else {
NN_NONE_LABEL.to_string()
};
if !labels.contains(&label) {
if new_labels {
labels.push(label.clone());
} else {
return Err(Error::new(
ErrorKind::Other,
format!("Forbidden label '{}', it doesn't exists on the training data or in the model you are training from.", label),
));
}
}
let label_index = labels.iter().position(|r| r.eq(&label)).unwrap() as u32;
let mut tmp_sample_rms_level: f32 = 0.;
let mfccs: Vec<Vec<f32>> = MfccWavFileExtractor::compute_mfccs(
BufReader::new(buffer.as_slice()),
&mut tmp_sample_rms_level,
mfcc_size,
)
.map_err(|msg| Error::new(ErrorKind::Other, msg))?;
if !label.eq(NN_NONE_LABEL) {
if !sample_rms_level.is_nan() {
*sample_rms_level = (*sample_rms_level + tmp_sample_rms_level) / 2.;
} else {
*sample_rms_level = tmp_sample_rms_level;
}
}
let flatten_mfccs = flat_features(mfccs);
labeled_data.push((flatten_mfccs, label_index));
}
Ok(labeled_data)
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/wakewords/nn/mod.rs | src/wakewords/nn/mod.rs | mod wakeword_model_train;
mod wakeword_nn;
pub use wakeword_model_train::{WakewordModelTrain, WakewordModelTrainOptions};
pub(crate) use wakeword_nn::WakewordNN;
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/audio/encoder.rs | src/audio/encoder.rs | use rubato::{FftFixedInOut, Resampler};
use crate::{config::AudioFmt, Endianness, Sample, SampleFormat};
/// Encode and convert audio to the supported format.
pub struct AudioEncoder {
resampler: Option<FftFixedInOut<f32>>,
resampler_input_buffer: Option<Vec<Vec<f32>>>,
resampler_out_buffer: Option<Vec<Vec<f32>>>,
source_sample_format: SampleFormat,
source_channels: u16,
source_endianness: Endianness,
input_samples_per_frame: usize,
output_samples_per_frame: usize,
}
impl AudioEncoder {
pub fn get_input_frame_length(&self) -> usize {
self.input_samples_per_frame
}
pub fn get_output_frame_length(&self) -> usize {
self.output_samples_per_frame
}
pub fn get_input_byte_length(&self) -> usize {
self.get_input_frame_length() * self.source_sample_format.get_bytes_per_sample() as usize
}
pub fn encode_and_resample(&mut self, buffer: &[u8]) -> Vec<f32> {
let float_samples = match &self.source_sample_format {
SampleFormat::I8 => encode_audio_bytes::<i8>(buffer, &self.source_endianness),
SampleFormat::I16 => encode_audio_bytes::<i16>(buffer, &self.source_endianness),
SampleFormat::I32 => encode_audio_bytes::<i32>(buffer, &self.source_endianness),
SampleFormat::F32 => encode_audio_bytes::<f32>(buffer, &self.source_endianness),
};
self.reencode_to_mono_with_sample_rate(float_samples)
}
pub fn rencode_and_resample<T: Sample>(&mut self, buffer: Vec<T>) -> Vec<f32> {
self.reencode_to_mono_with_sample_rate(
buffer.into_iter().map(T::into_f32).collect::<Vec<f32>>(),
)
}
fn reencode_to_mono_with_sample_rate(&mut self, buffer: Vec<f32>) -> Vec<f32> {
let mono_buffer = if self.source_channels != 1 {
buffer
.chunks_exact(self.source_channels as usize)
.map(|chunk| chunk[0])
.collect::<Vec<f32>>()
} else {
buffer
};
if self.resampler.is_none() {
mono_buffer
} else {
let waves_in = self.resampler_input_buffer.as_mut().unwrap();
waves_in[0] = mono_buffer;
let waves_out = self.resampler_out_buffer.as_mut().unwrap();
self.resampler
.as_mut()
.unwrap()
.process_into_buffer(waves_in, waves_out, None)
.unwrap();
waves_out.get(0).unwrap().to_vec()
}
}
pub fn new(
input_spec: &AudioFmt,
frame_length_ms: usize,
target_sample_rate: usize,
) -> Result<AudioEncoder, &'static str> {
let mut input_samples_per_frame =
(input_spec.sample_rate * frame_length_ms / 1000) * input_spec.channels as usize;
let output_samples_per_frame = target_sample_rate * frame_length_ms / 1000;
let resampler = if input_spec.sample_rate != target_sample_rate {
let resampler = FftFixedInOut::<f32>::new(
input_spec.sample_rate,
target_sample_rate,
output_samples_per_frame,
1,
)
.map_err(|_| "Unsupported sample rate, unable to initialize the resampler")?;
input_samples_per_frame = resampler.input_frames_next() * input_spec.channels as usize;
Some(resampler)
} else {
None
};
Ok(AudioEncoder {
input_samples_per_frame,
output_samples_per_frame,
resampler_out_buffer: if resampler.is_some() {
Some(resampler.as_ref().unwrap().output_buffer_allocate(true))
} else {
None
},
resampler_input_buffer: if resampler.is_some() {
Some(resampler.as_ref().unwrap().input_buffer_allocate(false))
} else {
None
},
resampler,
source_sample_format: input_spec.sample_format.clone(),
source_channels: input_spec.channels,
source_endianness: input_spec.endianness.clone(),
})
}
}
fn encode_audio_bytes<T: Sample>(audio_buffer: &[u8], endianness: &Endianness) -> Vec<f32> {
let buffer_chunks = audio_buffer.chunks_exact(T::get_byte_size());
match endianness {
Endianness::Little => buffer_chunks.map(T::from_le_bytes).collect::<Vec<T>>(),
Endianness::Big => buffer_chunks.map(T::from_be_bytes).collect::<Vec<T>>(),
Endianness::Native => buffer_chunks.map(T::from_ne_bytes).collect::<Vec<T>>(),
}
.into_iter()
.map(T::into_f32)
.collect()
}
#[test]
fn it_returns_correct_samples_per_frame() {
let dir = env!("CARGO_MANIFEST_DIR");
let file = std::fs::File::open(dir.to_owned() + "/tests/resources/oye_casa_g_1.wav").unwrap();
let wav_reader = hound::WavReader::new(std::io::BufReader::new(file)).unwrap();
let encoder = AudioEncoder::new(
&wav_reader.spec().try_into().unwrap(),
crate::constants::MFCCS_EXTRACTOR_FRAME_LENGTH_MS,
crate::constants::DETECTOR_INTERNAL_SAMPLE_RATE,
)
.unwrap();
let input_length = encoder.get_input_frame_length();
let output_length = encoder.get_output_frame_length();
assert_eq!(
input_length, output_length,
"input and output have same length"
);
assert_eq!(input_length, 480, "input size is correct");
assert_eq!(output_length, 480, "output size is correct");
}
#[test]
fn reencode_wav_with_different_format() {
let dir = env!("CARGO_MANIFEST_DIR");
let i16_samples_file =
std::fs::File::open(dir.to_owned() + "/tests/resources/oye_casa_g_1.wav").unwrap();
let wav_reader = hound::WavReader::new(std::io::BufReader::new(i16_samples_file)).unwrap();
let mut encoder = AudioEncoder::new(
&wav_reader.spec().try_into().unwrap(),
crate::constants::MFCCS_EXTRACTOR_FRAME_LENGTH_MS,
crate::constants::DETECTOR_INTERNAL_SAMPLE_RATE,
)
.unwrap();
let input_length = encoder.get_input_frame_length();
let output_length = encoder.get_output_frame_length();
assert_eq!(
input_length, output_length,
"input and output have same length"
);
assert_eq!(input_length, 480, "input size is correct");
assert_eq!(output_length, 480, "output size is correct");
let samples = wav_reader
.into_samples::<i16>()
.map(|chunk| *chunk.as_ref().unwrap())
.collect::<Vec<_>>();
let internal_spec = hound::WavSpec {
sample_rate: crate::constants::DETECTOR_INTERNAL_SAMPLE_RATE as u32,
bits_per_sample: 32,
sample_format: hound::SampleFormat::Float,
channels: 1,
};
let mut writer = hound::WavWriter::create(
dir.to_owned() + "/tests/resources/oye_casa_g_1_f32.wav",
internal_spec,
)
.unwrap();
samples
.chunks_exact(encoder.get_input_frame_length())
.map(|chuck| encoder.rencode_and_resample::<i16>(chuck.to_vec()))
.for_each(|reencoded_chunk| {
for sample in reencoded_chunk {
writer.write_sample(sample).ok();
}
});
writer.finalize().expect("Unable to save file");
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/audio/audio_types.rs | src/audio/audio_types.rs | /// Indicates the sample format type and size
#[cfg_attr(feature = "debug", derive(Debug))]
#[derive(Clone)]
pub enum SampleFormat {
I8,
I16,
I32,
F32,
}
impl SampleFormat {
pub fn get_bits_per_sample(&self) -> u16 {
match self {
SampleFormat::I8 => 8,
SampleFormat::I16 => 16,
SampleFormat::I32 => 32,
SampleFormat::F32 => 32,
}
}
pub fn get_bytes_per_sample(&self) -> u16 {
self.get_bits_per_sample() / 8
}
pub fn int_of_size(bit_size: u16) -> Option<Self> {
match bit_size {
8 => Some(SampleFormat::I8),
16 => Some(SampleFormat::I16),
32 => Some(SampleFormat::I32),
_ => None,
}
}
pub fn float_of_size(bit_size: u16) -> Option<Self> {
match bit_size {
32 => Some(SampleFormat::F32),
_ => None,
}
}
}
#[cfg(feature = "display")]
impl std::fmt::Display for SampleFormat {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match *self {
SampleFormat::I8 => write!(f, "i8"),
SampleFormat::I16 => write!(f, "i16"),
SampleFormat::I32 => write!(f, "i32"),
SampleFormat::F32 => write!(f, "f32"),
}
}
}
/// Indicates the sample byte order in the audio byte stream
#[cfg_attr(feature = "debug", derive(Debug))]
#[derive(Clone)]
pub enum Endianness {
Big,
Little,
Native,
}
/// Trait for compatible sample number types
pub trait Sample: Sized + Copy + std::cmp::PartialOrd + 'static + Send {
const S_TYPE: SampleFormat;
fn get_byte_size() -> usize;
fn get_format() -> SampleFormat;
fn get_zero() -> Self;
fn from_le_bytes(bytes: &[u8]) -> Self;
fn from_be_bytes(bytes: &[u8]) -> Self;
fn from_ne_bytes(bytes: &[u8]) -> Self;
fn into_f32(self) -> f32;
}
macro_rules! with_sample_type {
($ty:ty, $dsample:ident, $byte_size:literal, $to_f32:expr, $from_le_bytes:expr, $from_be_bytes:expr, $from_ne_bytes:expr, $zero:literal) => {
impl Sample for $ty {
const S_TYPE: SampleFormat = SampleFormat::$dsample;
fn get_byte_size() -> usize {
$byte_size
}
fn get_format() -> SampleFormat {
Self::S_TYPE
}
fn get_zero() -> Self {
$zero
}
fn into_f32(self) -> f32 {
$to_f32(self)
}
fn from_le_bytes(bytes: &[u8]) -> Self {
$from_le_bytes(bytes)
}
fn from_be_bytes(bytes: &[u8]) -> Self {
$from_be_bytes(bytes)
}
fn from_ne_bytes(bytes: &[u8]) -> Self {
$from_ne_bytes(bytes)
}
}
};
}
with_sample_type!(
i8,
I8,
1,
|v: i8| v as f32 / (i8::MAX as f32),
|bytes: &[u8]| i8::from_le_bytes([bytes[0]]),
|bytes: &[u8]| i8::from_be_bytes([bytes[0]]),
|bytes: &[u8]| i8::from_ne_bytes([bytes[0]]),
0
);
with_sample_type!(
i16,
I16,
2,
|v: i16| v as f32 / (i16::MAX as f32),
|bytes: &[u8]| i16::from_le_bytes([bytes[0], bytes[1]]),
|bytes: &[u8]| i16::from_be_bytes([bytes[0], bytes[1]]),
|bytes: &[u8]| i16::from_ne_bytes([bytes[0], bytes[1]]),
0
);
with_sample_type!(
i32,
I32,
4,
|v: i32| v as f32 / (i32::MAX as f32),
|bytes: &[u8]| i32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]),
|bytes: &[u8]| i32::from_be_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]),
|bytes: &[u8]| i32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]),
0
);
with_sample_type!(
f32,
F32,
4,
|v: f32| v,
|bytes: &[u8]| f32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]),
|bytes: &[u8]| f32::from_be_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]),
|bytes: &[u8]| f32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]),
0.
);
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/audio/gain_normalizer_filter.rs | src/audio/gain_normalizer_filter.rs | use crate::GainNormalizationConfig;
pub struct GainNormalizerFilter {
window_size: usize,
fixed_rms_level: bool,
min_gain: f32,
max_gain: f32,
// state
rms_level_ref: f32,
rms_level_sqrt: f32,
rms_level_window: Vec<f32>,
}
impl GainNormalizerFilter {
pub fn filter(&mut self, signal: &mut [f32], rms_level: f32) -> f32 {
if !self.rms_level_ref.is_nan() && rms_level != 0. {
// update the window
self.rms_level_window.push(rms_level);
if self.rms_level_window.len() > self.window_size {
self.rms_level_window.drain(0..1);
}
// calculate the mean of the rms window
let frame_rms_level =
self.rms_level_window.iter().sum::<f32>() / self.rms_level_window.len() as f32;
// calculate the gain to apply
let mut gain = self.rms_level_sqrt / frame_rms_level.sqrt();
// range and round the value, trying to get a mostly uniform gain between frames.
gain = ((gain * 10.).round() / 10.).clamp(self.min_gain, self.max_gain);
// apply gain unless irrelevant
if gain != 1. {
for sample in signal {
*sample = (*sample * gain).clamp(-1., 1.);
}
}
gain
} else {
1.
}
}
pub fn get_rms_level_ref(&self) -> f32 {
self.rms_level_ref
}
pub fn set_rms_level_ref(&mut self, rms_level: f32, window_size: usize) {
if !self.fixed_rms_level {
self.rms_level_ref = rms_level;
self.rms_level_sqrt = rms_level.sqrt();
}
self.window_size = if window_size != 0 { window_size } else { 1 };
}
pub fn get_rms_level(signal: &[f32]) -> f32 {
let mut sum_squared = 0.0;
for sample in signal {
sum_squared += sample * sample;
}
(sum_squared / signal.len() as f32).sqrt()
}
pub fn new(min_gain: f32, max_gain: f32, fixed_rms_level: Option<f32>) -> Self {
Self {
min_gain,
max_gain,
rms_level_ref: fixed_rms_level.unwrap_or(f32::NAN),
rms_level_sqrt: fixed_rms_level.map(|s| s.sqrt()).unwrap_or(f32::NAN),
fixed_rms_level: fixed_rms_level.is_some(),
rms_level_window: Vec::new(),
window_size: 1,
}
}
}
impl From<&GainNormalizationConfig> for Option<GainNormalizerFilter> {
fn from(config: &GainNormalizationConfig) -> Self {
if config.enabled {
Some(GainNormalizerFilter::new(
config.min_gain,
config.max_gain,
config.gain_ref,
))
} else {
None
}
}
}
#[test]
fn filter_audio() {
let dir = env!("CARGO_MANIFEST_DIR");
let sample_file =
std::fs::File::open(dir.to_owned() + "/tests/resources/real_sample.wav").unwrap();
let wav_reader = hound::WavReader::new(std::io::BufReader::new(sample_file)).unwrap();
let mut encoder = crate::audio::AudioEncoder::new(
&wav_reader.spec().try_into().unwrap(),
crate::constants::MFCCS_EXTRACTOR_FRAME_LENGTH_MS,
crate::constants::DETECTOR_INTERNAL_SAMPLE_RATE,
)
.unwrap();
let input_length = encoder.get_input_frame_length();
let output_length = encoder.get_output_frame_length();
assert_ne!(
input_length, output_length,
"input and output not have same length"
);
assert_eq!(input_length, 1440, "input size is correct");
assert_eq!(output_length, 480, "output size is correct");
let samples = wav_reader
.into_samples::<f32>()
.map(|chunk| *chunk.as_ref().unwrap())
.collect::<Vec<_>>();
let internal_spec = hound::WavSpec {
sample_rate: crate::constants::DETECTOR_INTERNAL_SAMPLE_RATE as u32,
bits_per_sample: 32,
sample_format: hound::SampleFormat::Float,
channels: 1,
};
let mut writer = hound::WavWriter::create(
dir.to_owned() + "/tests/resources/gain-normalizer_example.wav",
internal_spec,
)
.unwrap();
let mut filter = GainNormalizerFilter::new(0.1, 1., Some(0.003));
samples
.chunks_exact(encoder.get_input_frame_length())
.map(|chuck| encoder.rencode_and_resample::<f32>(chuck.into()))
.map(|mut chunk| {
let rms_level = GainNormalizerFilter::get_rms_level(&chunk);
filter.filter(&mut chunk, rms_level);
chunk
})
.for_each(|encoded_chunk| {
for sample in encoded_chunk {
writer.write_sample(sample).ok();
}
});
writer.finalize().expect("Unable to save file");
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/audio/band_pass_filter.rs | src/audio/band_pass_filter.rs | use std::f32::consts::PI;
use crate::{constants::DETECTOR_INTERNAL_SAMPLE_RATE, BandPassConfig};
pub struct BandPassFilter {
// options
a0: f32,
a1: f32,
a2: f32,
b1: f32,
b2: f32,
// state
x1: f32,
x2: f32,
y1: f32,
y2: f32,
}
impl BandPassFilter {
pub fn filter(&mut self, signal: &mut [f32]) {
for sample in signal.iter_mut() {
let x = *sample;
*sample = self.a0 * x + self.a1 * self.x1 + self.a2 * self.x2
- self.b1 * self.y1
- self.b2 * self.y2;
self.x2 = self.x1;
self.x1 = x;
self.y2 = self.y1;
self.y1 = *sample;
}
}
pub fn new(sample_rate: f32, low_cutoff: f32, high_cutoff: f32) -> Self {
let omega_low = 2.0 * PI * low_cutoff / sample_rate;
let omega_high = 2.0 * PI * high_cutoff / sample_rate;
let cos_omega_low = omega_low.cos();
let cos_omega_high = omega_high.cos();
let alpha_low = omega_low.sin() / 2.0;
let alpha_high = omega_high.sin() / 2.0;
let a0 = 1.0 / (1.0 + alpha_high - alpha_low);
let a1 = -2.0 * cos_omega_low * a0;
let a2 = (1.0 - alpha_high - alpha_low) * a0;
let b1 = -2.0 * cos_omega_high * a0;
let b2 = (1.0 - alpha_high + alpha_low) * a0;
Self {
a0,
a1,
a2,
b1,
b2,
x1: 0.0,
x2: 0.0,
y1: 0.0,
y2: 0.0,
}
}
}
impl From<&BandPassConfig> for Option<BandPassFilter> {
fn from(config: &BandPassConfig) -> Self {
if config.enabled {
Some(BandPassFilter::new(
DETECTOR_INTERNAL_SAMPLE_RATE as f32,
config.low_cutoff,
config.high_cutoff,
))
} else {
None
}
}
}
#[test]
fn filter_audio() {
let dir = env!("CARGO_MANIFEST_DIR");
let sample_file =
std::fs::File::open(dir.to_owned() + "/tests/resources/real_sample.wav").unwrap();
let wav_reader = hound::WavReader::new(std::io::BufReader::new(sample_file)).unwrap();
let mut encoder = crate::audio::AudioEncoder::new(
&wav_reader.spec().try_into().unwrap(),
crate::constants::MFCCS_EXTRACTOR_FRAME_LENGTH_MS,
crate::constants::DETECTOR_INTERNAL_SAMPLE_RATE,
)
.unwrap();
let input_length = encoder.get_input_frame_length();
let output_length = encoder.get_output_frame_length();
assert_ne!(
input_length, output_length,
"input and output not have same length"
);
assert_eq!(input_length, 1440, "input size is correct");
assert_eq!(output_length, 480, "output size is correct");
let samples = wav_reader
.into_samples::<f32>()
.map(|chunk| *chunk.as_ref().unwrap())
.collect::<Vec<_>>();
let internal_spec = hound::WavSpec {
sample_rate: crate::constants::DETECTOR_INTERNAL_SAMPLE_RATE as u32,
bits_per_sample: 32,
sample_format: hound::SampleFormat::Float,
channels: 1,
};
let mut writer = hound::WavWriter::create(
dir.to_owned() + "/tests/resources/band-pass_example.wav",
internal_spec,
)
.unwrap();
let mut filter = BandPassFilter::new(
crate::constants::DETECTOR_INTERNAL_SAMPLE_RATE as f32,
80.,
400.,
);
samples
.chunks_exact(encoder.get_input_frame_length())
.map(|chuck| encoder.rencode_and_resample::<f32>(chuck.into()))
.map(|mut chunk| {
filter.filter(&mut chunk);
chunk
})
.for_each(|encoded_chunk| {
for sample in encoded_chunk {
writer.write_sample(sample).ok();
}
});
writer.finalize().expect("Unable to save file");
}
#[test]
fn filter_gain_normalized_audio() {
let dir = env!("CARGO_MANIFEST_DIR");
let sample_file =
std::fs::File::open(dir.to_owned() + "/tests/resources/real_sample.wav").unwrap();
let wav_reader = hound::WavReader::new(std::io::BufReader::new(sample_file)).unwrap();
let mut encoder = crate::audio::AudioEncoder::new(
&wav_reader.spec().try_into().unwrap(),
crate::constants::MFCCS_EXTRACTOR_FRAME_LENGTH_MS,
crate::constants::DETECTOR_INTERNAL_SAMPLE_RATE,
)
.unwrap();
let input_length = encoder.get_input_frame_length();
let output_length = encoder.get_output_frame_length();
assert_ne!(
input_length, output_length,
"input and output not have same length"
);
assert_eq!(input_length, 1440, "input size is correct");
assert_eq!(output_length, 480, "output size is correct");
let samples = wav_reader
.into_samples::<f32>()
.map(|chunk| *chunk.as_ref().unwrap())
.collect::<Vec<_>>();
let internal_spec = hound::WavSpec {
sample_rate: crate::constants::DETECTOR_INTERNAL_SAMPLE_RATE as u32,
bits_per_sample: 32,
sample_format: hound::SampleFormat::Float,
channels: 1,
};
let mut writer = hound::WavWriter::create(
dir.to_owned() + "/tests/resources/gain_normalized_band-pass_example.wav",
internal_spec,
)
.unwrap();
let mut gain_filter = crate::audio::GainNormalizerFilter::new(0.1, 1., Some(0.003));
let mut filter = BandPassFilter::new(
crate::constants::DETECTOR_INTERNAL_SAMPLE_RATE as f32,
80.,
400.,
);
samples
.chunks_exact(encoder.get_input_frame_length())
.map(|chuck| encoder.rencode_and_resample::<f32>(chuck.into()))
.map(|mut chunk| {
let rms_level = crate::audio::GainNormalizerFilter::get_rms_level(&chunk);
gain_filter.filter(&mut chunk, rms_level);
filter.filter(&mut chunk);
chunk
})
.for_each(|encoded_chunk| {
for sample in encoded_chunk {
writer.write_sample(sample).ok();
}
});
writer.finalize().expect("Unable to save file");
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/audio/mod.rs | src/audio/mod.rs | mod audio_types;
mod band_pass_filter;
mod encoder;
mod gain_normalizer_filter;
pub use audio_types::{Endianness, Sample, SampleFormat};
pub use band_pass_filter::BandPassFilter;
pub use encoder::AudioEncoder;
pub use gain_normalizer_filter::GainNormalizerFilter;
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/mfcc/extractor.rs | src/mfcc/extractor.rs | use std::f32::consts::PI;
use rustfft::{num_complex::Complex32, FftPlanner};
pub struct MfccExtractor {
num_coefficients: usize,
pre_emphasis_coefficient: f32,
samples_per_frame: usize,
samples_per_shift: usize,
magnitude_spectrum_size: usize,
sample_rate: usize,
// state
filter_bank: Vec<Vec<f32>>,
hamming_window: Vec<f32>,
samples: Vec<f32>,
}
impl MfccExtractor {
pub fn new(
sample_rate: usize,
samples_per_frame: usize,
samples_per_shift: usize,
num_coefficients: u16,
pre_emphasis_coefficient: f32,
) -> MfccExtractor {
let min_frequency = 0;
let max_frequency = sample_rate / 2;
let magnitude_spectrum_size = samples_per_frame / 2;
MfccExtractor {
samples: vec![],
samples_per_shift,
samples_per_frame,
pre_emphasis_coefficient,
num_coefficients: num_coefficients as usize,
magnitude_spectrum_size,
filter_bank: Self::new_mel_filter_bank(
sample_rate,
magnitude_spectrum_size,
num_coefficients as usize,
min_frequency,
max_frequency,
),
hamming_window: Self::new_hamming_window(samples_per_frame),
sample_rate,
}
}
pub fn set_out_size(&mut self, out_size: u16) {
self.num_coefficients = (out_size + 1) as usize; // first coefficient is dropped
let min_frequency = 0;
let max_frequency = self.sample_rate / 2;
self.filter_bank = Self::new_mel_filter_bank(
self.sample_rate,
self.magnitude_spectrum_size,
self.num_coefficients,
min_frequency,
max_frequency,
);
self.reset();
}
pub fn compute(&mut self, audio_samples: &[f32]) -> Vec<Vec<f32>> {
audio_samples
.chunks_exact(self.samples_per_shift)
.filter_map(|audio_part| self.process_audio_part(audio_part))
.collect()
}
pub fn reset(&mut self) {
self.samples.clear();
}
fn process_audio_part(&mut self, audio_buffer: &[f32]) -> Option<Vec<f32>> {
let mut new_samples = self.pre_emphasis(audio_buffer);
if self.samples.len() >= self.samples_per_frame {
self.samples.drain(0..new_samples.len());
self.samples.append(&mut new_samples);
Some(self.extract_mfccs(&self.samples[0..self.samples_per_frame]))
} else {
self.samples.append(&mut new_samples);
None
}
}
fn extract_mfccs(&self, samples: &[f32]) -> Vec<f32> {
let magnitude_spectrum = self.calculate_magnitude_spectrum(samples);
let mut mfcc_frame =
self.calculate_mel_frequency_cepstral_coefficients(&magnitude_spectrum);
mfcc_frame.drain(0..1);
mfcc_frame
}
fn pre_emphasis(&self, audio_buffer: &[f32]) -> Vec<f32> {
let mut tmp_sample = 0.;
audio_buffer
.iter()
.map(|current| {
let previous = tmp_sample;
tmp_sample = *current;
tmp_sample - self.pre_emphasis_coefficient * previous
})
.collect()
}
//==================================================================
// Feature extraction utils
fn calculate_magnitude_spectrum(&self, audio_frame: &[f32]) -> Vec<f32> {
let mut planner = FftPlanner::new();
let fft = planner.plan_fft_forward(self.samples_per_frame);
let mut buffer = (0..self.samples_per_frame)
.map(|i| Complex32 {
re: audio_frame[i] * self.hamming_window[i],
im: 0.,
})
.collect::<Vec<_>>();
fft.process(&mut buffer);
(0..self.magnitude_spectrum_size)
.map(|i| ((buffer[i].re * buffer[i].re) + (buffer[i].im * buffer[i].im)).sqrt())
.collect()
}
fn new_hamming_window(samples_per_frame: usize) -> Vec<f32> {
let ns_minus_1 = samples_per_frame - 1;
(0..samples_per_frame)
.map(|s| 0.54 - (0.46 * (2. * PI * (s as f32 / ns_minus_1 as f32)).cos()))
.collect()
}
fn calculate_mel_frequency_cepstral_coefficients(
&self,
magnitude_spectrum: &[f32],
) -> Vec<f32> {
let mfccs: Vec<f32> = self
.calculate_mel_frequency_cepstrum(magnitude_spectrum)
.iter()
.map(|ms| (ms + f32::MIN_POSITIVE).ln())
.collect();
self.discrete_cosine_transform(mfccs)
}
fn frequency_to_mel(frequency: usize) -> f32 {
1127. * (1. + (frequency as f32 / 700.0)).ln()
}
fn calculate_mel_frequency_cepstrum(&self, magnitude_spectrum: &[f32]) -> Vec<f32> {
(0..self.num_coefficients)
.map(|i| {
magnitude_spectrum
.iter()
.enumerate()
.map(|(j, ms)| ms * ms * self.filter_bank[i][j])
.sum()
})
.collect()
}
fn discrete_cosine_transform(&self, mut input_signal: Vec<f32>) -> Vec<f32> {
let dct_signal: Vec<f32> = input_signal.to_vec();
let pi_over_n = PI / input_signal.len() as f32;
input_signal
.iter_mut()
.enumerate()
.for_each(|(k, input_sample)| {
*input_sample = 2.
* dct_signal
.iter()
.enumerate()
.map(|(n, dct_sample)| {
dct_sample * (pi_over_n * (n as f32 + 0.5) * k as f32).cos()
})
.sum::<f32>();
});
input_signal
}
fn new_mel_filter_bank(
sample_rate: usize,
magnitude_spectrum_size: usize,
num_coefficients: usize,
min_frequency: usize,
max_frequency: usize,
) -> Vec<Vec<f32>> {
let max_mel = Self::frequency_to_mel(max_frequency).floor();
let min_mel = Self::frequency_to_mel(min_frequency).floor();
let mut filter_bank = vec![vec![0.; magnitude_spectrum_size]; num_coefficients];
let centre_indices: Vec<usize> = (0..num_coefficients + 2)
.map(|i| {
let f = i as f32 * (max_mel - min_mel) / (num_coefficients + 1) as f32 + min_mel;
let mut tmp = (1_f32 + 1000.0 / 700.0).ln() / 1000.0;
tmp = ((f * tmp).exp() - 1.) / (sample_rate as f32 / 2.);
(0.5 + 700. * magnitude_spectrum_size as f32 * tmp).floor() as usize
})
.collect();
for i in 0..num_coefficients {
let filter_begin_index = centre_indices[i];
let filter_center_index = centre_indices[i + 1];
let filter_end_index = centre_indices[i + 2];
let triangle_range_up = filter_center_index - filter_begin_index;
let triangle_range_down = filter_end_index - filter_center_index;
// upward slope
for k in filter_begin_index..filter_center_index {
filter_bank[i][k] = (k - filter_begin_index) as f32 / triangle_range_up as f32;
}
// downwards slope
for k in filter_center_index..filter_end_index {
filter_bank[i][k] = (filter_end_index - k) as f32 / triangle_range_down as f32;
}
}
filter_bank
}
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/mfcc/normalizer.rs | src/mfcc/normalizer.rs | pub struct MfccNormalizer {}
impl MfccNormalizer {
pub fn normalize(frames: Vec<Vec<f32>>) -> Vec<Vec<f32>> {
let num_frames = frames.len();
if num_frames == 0 {
return Vec::new();
}
let num_mfccs = frames[0].len();
let mut sum = Vec::with_capacity(num_mfccs);
sum.resize(num_mfccs, 0.);
let mut normalized_frames: Vec<Vec<f32>> = Vec::with_capacity(num_frames);
normalized_frames.resize(num_frames, {
let mut vector = Vec::with_capacity(num_mfccs);
vector.resize(num_mfccs, 0.);
vector
});
for (i, normalized_frames_item) in normalized_frames.iter_mut().enumerate().take(num_frames)
{
for (j, sum_item) in sum.iter_mut().enumerate().take(num_mfccs) {
let value = frames[i][j];
*sum_item += value;
normalized_frames_item[j] = value;
}
}
for normalized_frames_item in normalized_frames.iter_mut().take(num_frames) {
for (j, sum_item) in sum.iter().enumerate().take(num_mfccs) {
normalized_frames_item[j] -= sum_item / num_frames as f32
}
}
normalized_frames
}
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/mfcc/comparator.rs | src/mfcc/comparator.rs | use super::Dtw;
use std::cmp;
pub struct MfccComparator {
score_ref: f32,
band_size: u16,
}
impl MfccComparator {
pub fn new(score_ref: f32, band_size: u16) -> Self {
MfccComparator {
score_ref,
band_size,
}
}
pub fn calculate_distance(ax: &[f32], bx: &[f32]) -> f32 {
1. - cosine_similarity(ax, bx)
}
pub fn compare(&self, a: &[&[f32]], b: &[&[f32]]) -> f32 {
let mut dtw = Dtw::new(MfccComparator::calculate_distance);
let cost = dtw.compute_optimal_path_with_window(a, b, self.band_size);
let normalized_cost = cost / (a.len() + b.len()) as f32;
self.compute_probability(normalized_cost)
}
fn compute_probability(&self, cost: f32) -> f32 {
1. / (1. + ((cost - self.score_ref) / self.score_ref).exp())
}
}
pub fn cosine_similarity(vector_a: &[f32], vector_b: &[f32]) -> f32 {
let dimensionality = cmp::min(vector_a.len(), vector_b.len());
let mut dot_ab = 0.;
let mut dot_a = 0.;
let mut dot_b = 0.;
let mut dimension = 0;
while dimension < dimensionality {
let component_a = vector_a[dimension];
let component_b = vector_b[dimension];
dot_ab += component_a * component_b;
dot_a += component_a * component_a;
dot_b += component_b * component_b;
dimension += 1;
}
let magnitude = f32::sqrt(dot_a * dot_b);
if magnitude == 0. {
0.
} else {
dot_ab / magnitude
}
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/mfcc/averager.rs | src/mfcc/averager.rs | use super::{dtw::Dtw, MfccComparator};
pub struct MfccAverager {}
impl MfccAverager {
pub fn average(mut other_mfccs: Vec<Vec<Vec<f32>>>) -> Option<Vec<Vec<f32>>> {
let mut origin = other_mfccs.drain(0..1).next().unwrap();
for frames in other_mfccs.iter() {
let mut dtw = Dtw::new(MfccComparator::calculate_distance);
dtw.compute_optimal_path(
&origin.iter().map(|item| &item[..]).collect::<Vec<_>>(),
&frames.iter().map(|item| &item[..]).collect::<Vec<_>>(),
);
let mut avgs = origin
.iter()
.map(|x| x.iter().map(|&y| vec![y]).collect::<Vec<_>>())
.collect::<Vec<_>>();
dtw.retrieve_optimal_path()
.unwrap()
.into_iter()
.for_each(|[x, y]| {
frames[y].iter().enumerate().for_each(|(index, feature)| {
avgs[x][index].push(*feature);
})
});
origin = avgs
.iter()
.map(|x| {
x.iter()
.map(|mfcc_shift| {
mfcc_shift.to_vec().iter().sum::<f32>() / mfcc_shift.len() as f32
})
.collect::<Vec<f32>>()
})
.collect::<Vec<_>>();
}
Some(origin)
}
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/mfcc/dtw.rs | src/mfcc/dtw.rs | use std::cmp;
pub struct Dtw<T: Copy> {
state_m: usize,
state_n: usize,
distance_fn: fn(T, T) -> f32,
state_similarity: Option<f32>,
distance_cost_matrix: Option<Vec<Vec<f32>>>,
}
impl<T: Copy> Dtw<T> {
pub fn compute_optimal_path(&mut self, first_sequence: &[T], second_sequence: &[T]) -> f32 {
self.state_m = first_sequence.len();
self.state_n = second_sequence.len();
let mut distance_cost_matrix: Vec<Vec<f32>> = infinity_matrix(self.state_m, self.state_n);
distance_cost_matrix[0][0] = (self.distance_fn)(first_sequence[0], second_sequence[0]);
for (row_index, first_sequence_item) in
first_sequence.iter().enumerate().take(self.state_m).skip(1)
{
let cost = (self.distance_fn)(*first_sequence_item, second_sequence[0]);
distance_cost_matrix[row_index][0] = cost + distance_cost_matrix[row_index - 1][0];
}
for (column_index, second_sequence_item) in second_sequence
.iter()
.enumerate()
.take(self.state_n)
.skip(1)
{
let cost = (self.distance_fn)(first_sequence[0], *second_sequence_item);
distance_cost_matrix[0][column_index] =
cost + distance_cost_matrix[0][column_index - 1];
}
for (row_index, first_sequence_item) in
first_sequence.iter().enumerate().take(self.state_m).skip(1)
{
for (column_index, second_sequence_item) in second_sequence
.iter()
.enumerate()
.take(self.state_n)
.skip(1)
{
let cost = (self.distance_fn)(*first_sequence_item, *second_sequence_item);
let insertion = distance_cost_matrix[row_index - 1][column_index];
let deletion = distance_cost_matrix[row_index][column_index - 1];
let matches = distance_cost_matrix[row_index - 1][column_index - 1];
let min_value = [insertion, deletion, matches]
.iter()
.fold(f32::INFINITY, |a, &b| a.min(b));
distance_cost_matrix[row_index][column_index] = cost + min_value;
}
}
let similarity = distance_cost_matrix[self.state_m - 1][self.state_n - 1];
self.distance_cost_matrix = Option::Some(distance_cost_matrix);
self.state_similarity = Option::Some(similarity);
similarity
}
pub fn compute_optimal_path_with_window(
&mut self,
first_sequence: &[T],
second_sequence: &[T],
w: u16,
) -> f32 {
self.state_m = first_sequence.len();
self.state_n = second_sequence.len();
let window = cmp::max(
w as usize,
abs_diff(first_sequence.len(), second_sequence.len()),
);
let mut distance_cost_matrix: Vec<Vec<f32>> =
infinity_matrix(self.state_m + 1, self.state_n + 1);
distance_cost_matrix[0][0] = 0.;
for row_index in 1..=self.state_m {
let start_index = if row_index > window {
cmp::max(1, row_index - window)
} else {
1
};
for column_index in start_index..cmp::min(self.state_n + 1, row_index + window) {
let cost = (self.distance_fn)(
first_sequence[row_index - 1],
second_sequence[column_index - 1],
);
let insertion = distance_cost_matrix[row_index - 1][column_index];
let deletion = distance_cost_matrix[row_index][column_index - 1];
let matches = distance_cost_matrix[row_index - 1][column_index - 1];
let min_value = [insertion, deletion, matches]
.iter()
.fold(f32::INFINITY, |a, &b| a.min(b));
distance_cost_matrix[row_index][column_index] = cost + min_value;
}
}
// resize matrix
let mut final_distance_cost_matrix: Vec<Vec<f32>> =
infinity_matrix(self.state_m + 1, self.state_n);
for row_index in 0..=self.state_m {
for col_index in 1..=self.state_n {
final_distance_cost_matrix[row_index][col_index - 1] =
distance_cost_matrix[row_index][col_index];
}
}
let similarity = final_distance_cost_matrix[self.state_m - 1][self.state_n - 1];
self.distance_cost_matrix = Option::Some(final_distance_cost_matrix);
self.state_similarity = Option::Some(similarity);
similarity
}
pub fn retrieve_optimal_path(&self) -> Option<Vec<[usize; 2]>> {
self.distance_cost_matrix.as_ref()?;
let distance_cost_matrix = self.distance_cost_matrix.as_ref().unwrap();
let mut row_index = self.state_m - 1;
let mut column_index = self.state_n - 1;
let mut path = vec![[0usize; 2]; cmp::min(row_index, column_index)];
while (row_index > 0) || (column_index > 0) {
if row_index > 0 && column_index > 0 {
let insertion = distance_cost_matrix[row_index - 1][column_index];
let deletion = distance_cost_matrix[row_index][column_index - 1];
let matches = distance_cost_matrix[row_index - 1][column_index - 1];
let min_value = [insertion, deletion, matches]
.iter()
.fold(f32::INFINITY, |a, &b| a.min(b));
if min_value == matches {
row_index -= 1;
column_index -= 1;
} else if min_value == insertion {
row_index -= 1;
} else if min_value == deletion {
column_index -= 1;
}
} else if row_index > 0 && column_index == 0 {
row_index -= 1;
} else if row_index == 0 && column_index > 0 {
column_index -= 1;
}
let part = [row_index, column_index];
path.push(part);
}
path.reverse();
Some(path)
}
pub fn new(distance_fn: fn(T, T) -> f32) -> Dtw<T> {
Dtw {
state_m: 0,
state_n: 0,
distance_fn,
state_similarity: Option::None,
distance_cost_matrix: Option::None,
}
}
}
fn infinity_matrix(rows: usize, cols: usize) -> Vec<Vec<f32>> {
vec![vec![f32::INFINITY; cols]; rows]
}
fn abs_diff(a: usize, b: usize) -> usize {
if a > b {
a - b
} else {
b - a
}
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/mfcc/wav_file_extractor.rs | src/mfcc/wav_file_extractor.rs | use std::io::BufReader;
use hound::{WavReader, WavSpec};
use crate::{
audio::{AudioEncoder, GainNormalizerFilter},
constants::{
DETECTOR_INTERNAL_SAMPLE_RATE, MFCCS_EXTRACTOR_FRAME_LENGTH_MS,
MFCCS_EXTRACTOR_FRAME_SHIFT_MS, MFCCS_EXTRACTOR_PRE_EMPHASIS,
},
AudioFmt, Endianness, Sample, SampleFormat,
};
use super::{MfccExtractor, MfccNormalizer};
pub(crate) struct MfccWavFileExtractor {}
impl MfccWavFileExtractor {
pub(crate) fn compute_mfccs<R: std::io::Read>(
buffer_reader: BufReader<R>,
out_rms_level: &mut f32,
mfcc_size: u16,
) -> Result<Vec<Vec<f32>>, String> {
let wav_reader = WavReader::new(buffer_reader).map_err(|err| err.to_string())?;
let fmt = wav_reader.spec().try_into()?;
let mut encoder = AudioEncoder::new(
&fmt,
MFCCS_EXTRACTOR_FRAME_LENGTH_MS,
DETECTOR_INTERNAL_SAMPLE_RATE,
)?;
let samples_per_frame = encoder.get_output_frame_length();
let samples_per_shift = (samples_per_frame as f32
/ (MFCCS_EXTRACTOR_FRAME_LENGTH_MS as f32 / MFCCS_EXTRACTOR_FRAME_SHIFT_MS as f32))
as usize;
let mut mfcc_extractor = MfccExtractor::new(
DETECTOR_INTERNAL_SAMPLE_RATE,
samples_per_frame,
samples_per_shift,
mfcc_size + 1, // first coefficient is dropped
MFCCS_EXTRACTOR_PRE_EMPHASIS,
);
let mut rms_levels: Vec<f32> = Vec::new();
let encoded_samples = match fmt.sample_format {
SampleFormat::I8 => encode_samples::<R, i8>(wav_reader, &mut encoder, &mut rms_levels),
SampleFormat::I16 => {
encode_samples::<R, i16>(wav_reader, &mut encoder, &mut rms_levels)
}
SampleFormat::I32 => {
encode_samples::<R, i32>(wav_reader, &mut encoder, &mut rms_levels)
}
SampleFormat::F32 => {
encode_samples::<R, f32>(wav_reader, &mut encoder, &mut rms_levels)
}
};
if !rms_levels.is_empty() {
rms_levels.sort_by(|a, b| a.total_cmp(b));
let rms_level = rms_levels[rms_levels.len() / 2];
*out_rms_level = rms_level;
}
let sample_mfccs = encoded_samples
.as_slice()
.chunks_exact(encoder.get_output_frame_length())
.map(|samples_chunk| mfcc_extractor.compute(samples_chunk))
.fold(Vec::new() as Vec<Vec<f32>>, |mut acc, mfcc_matrix| {
mfcc_matrix.into_iter().for_each(|mfccs| acc.push(mfccs));
acc
});
Ok(MfccNormalizer::normalize(sample_mfccs))
}
}
fn encode_samples<R: std::io::Read, S: hound::Sample + Sample>(
wav_reader: WavReader<BufReader<R>>,
encoder: &mut AudioEncoder,
rms_levels: &mut Vec<f32>,
) -> Vec<f32> {
let samples = wav_reader
.into_samples::<S>()
.map(|chunk| chunk.unwrap())
.collect::<Vec<_>>();
samples
.chunks_exact(encoder.get_input_frame_length())
.map(|chuck| encoder.rencode_and_resample::<S>(chuck.into()))
.map(|encoded_buffer| {
rms_levels.push(GainNormalizerFilter::get_rms_level(&encoded_buffer));
encoded_buffer
})
.fold(Vec::new(), |mut acc, mut i| {
acc.append(&mut i);
acc
})
}
impl TryFrom<WavSpec> for AudioFmt {
type Error = String;
fn try_from(spec: WavSpec) -> Result<Self, Self::Error> {
let sample_format = match &spec.sample_format {
hound::SampleFormat::Int => SampleFormat::int_of_size(spec.bits_per_sample),
hound::SampleFormat::Float => SampleFormat::float_of_size(spec.bits_per_sample),
};
if let Some(sample_format) = sample_format {
Ok(AudioFmt {
channels: spec.channels,
sample_format,
sample_rate: spec.sample_rate as usize,
endianness: Endianness::Little,
})
} else {
Err("Unsupported wav format".to_string())
}
}
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/mfcc/mod.rs | src/mfcc/mod.rs | mod averager;
mod comparator;
mod dtw;
mod extractor;
mod normalizer;
mod vad;
mod wav_file_extractor;
pub(crate) use averager::MfccAverager;
pub(crate) use comparator::MfccComparator;
use dtw::Dtw;
pub(crate) use extractor::MfccExtractor;
pub(crate) use normalizer::MfccNormalizer;
pub(crate) use vad::VadDetector;
pub(crate) use wav_file_extractor::MfccWavFileExtractor;
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/src/mfcc/vad.rs | src/mfcc/vad.rs | use crate::config::VADMode;
pub struct VadDetector {
mode: VADMode,
// state
index: usize,
window: Vec<f32>,
voice_countdown: usize,
}
impl VadDetector {
pub fn is_voice(&mut self, mfcc: &[f32]) -> bool {
let value: f32 = mfcc.iter().map(|v| v.abs()).sum::<f32>() / mfcc.len() as f32;
self.window[self.index] = value;
self.index = if self.index >= self.window.len() - 1 {
0
} else {
self.index + 1
};
let min = self
.window
.iter()
.filter(|i| !i.is_nan())
.min_by(|a, b| a.total_cmp(b))
.unwrap().max(0.01);
let th = min * self.mode.get_value();
let n_high_frames = self.window.iter().filter(|v| **v > th).count();
if n_high_frames > 10 {
self.voice_countdown = 500;
}
if self.voice_countdown > 0 {
self.voice_countdown -= 1;
true
} else {
false
}
}
pub fn reset(&mut self) {
self.window.fill(f32::NAN);
self.voice_countdown = 0;
self.index = 0;
}
pub fn new(mode: VADMode) -> VadDetector {
VadDetector {
index: 0,
window: vec![f32::NAN; 50],
voice_countdown: 0,
mode,
}
}
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/tests/detector.rs | tests/detector.rs | use std::{
fs::File,
io::{BufReader, Read},
};
use rustpotter::{Rustpotter, RustpotterConfig, SampleFormat, ScoreMode, VADMode};
#[test]
fn it_can_detect_wakewords_with_v2_file() {
let mut config = RustpotterConfig::default();
config.detector.avg_threshold = 0.2;
config.detector.threshold = 0.5;
config.filters.gain_normalizer.enabled = false;
config.filters.band_pass.enabled = false;
config.detector.score_mode = ScoreMode::Max;
let detected_wakewords = run_detection_simulation(config, "/tests/resources/oye_casa_g_v2.rpw");
assert_eq!(detected_wakewords.len(), 2);
assert_eq!(detected_wakewords[0].avg_score, 0.6495044);
assert_eq!(detected_wakewords[0].score, 0.7310586);
assert_eq!(detected_wakewords[1].avg_score, 0.5804737);
assert_eq!(detected_wakewords[1].score, 0.721843);
}
#[test]
fn it_can_detect_wakewords_with_max_score_mode() {
let mut config = RustpotterConfig::default();
config.detector.avg_threshold = 0.2;
config.detector.threshold = 0.5;
config.filters.gain_normalizer.enabled = false;
config.filters.band_pass.enabled = false;
config.detector.score_mode = ScoreMode::Max;
let detected_wakewords = run_detection_simulation(config, "/tests/resources/oye_casa_g.rpw");
assert_eq!(detected_wakewords.len(), 2);
assert_eq!(detected_wakewords[0].avg_score, 0.6495044);
assert_eq!(detected_wakewords[0].score, 0.7310586);
assert_eq!(detected_wakewords[1].avg_score, 0.5804737);
assert_eq!(detected_wakewords[1].score, 0.721843);
}
#[test]
fn it_can_detect_wakewords_with_median_score_mode() {
let mut config = RustpotterConfig::default();
config.detector.avg_threshold = 0.2;
config.detector.threshold = 0.5;
config.filters.gain_normalizer.enabled = false;
config.filters.band_pass.enabled = false;
config.detector.score_mode = ScoreMode::Median;
let detected_wakewords = run_detection_simulation(config, "/tests/resources/oye_casa_g.rpw");
assert_eq!(detected_wakewords.len(), 2);
assert_eq!(detected_wakewords[0].avg_score, 0.64608675);
assert_eq!(detected_wakewords[0].score, 0.60123634);
assert_eq!(detected_wakewords[1].avg_score, 0.5288923);
assert_eq!(detected_wakewords[1].score, 0.63968724);
}
#[test]
fn it_can_detect_wakewords_with_average_score_mode() {
let mut config = RustpotterConfig::default();
config.detector.avg_threshold = 0.2;
config.detector.threshold = 0.5;
config.filters.gain_normalizer.enabled = false;
config.filters.band_pass.enabled = false;
config.detector.score_mode = ScoreMode::Average;
let detected_wakewords = run_detection_simulation(config, "/tests/resources/oye_casa_g.rpw");
assert_eq!(detected_wakewords.len(), 2);
assert_eq!(detected_wakewords[0].avg_score, 0.64608675);
assert_eq!(detected_wakewords[0].score, 0.60458726);
assert_eq!(detected_wakewords[1].avg_score, 0.5750509);
assert_eq!(detected_wakewords[1].score, 0.6313083);
}
#[test]
fn it_can_detect_wakewords_with_vad_mode() {
let mut config = RustpotterConfig::default();
config.detector.avg_threshold = 0.2;
config.detector.threshold = 0.5;
config.filters.gain_normalizer.enabled = false;
config.filters.band_pass.enabled = false;
config.detector.score_mode = ScoreMode::Max;
config.detector.vad_mode = Some(VADMode::Easy);
let detected_wakewords = run_detection_simulation(config, "/tests/resources/oye_casa_g.rpw");
assert_eq!(detected_wakewords.len(), 2);
assert_eq!(detected_wakewords[0].avg_score, 0.6495044);
assert_eq!(detected_wakewords[0].score, 0.7310586);
assert_eq!(detected_wakewords[1].avg_score, 0.5804737);
assert_eq!(detected_wakewords[1].score, 0.721843);
}
#[test]
fn it_can_ignore_words() {
let mut config = RustpotterConfig::default();
config.detector.avg_threshold = 0.;
config.detector.threshold = 0.45;
config.detector.min_scores = 0;
config.filters.gain_normalizer.enabled = false;
config.filters.band_pass.enabled = false;
config.detector.score_mode = ScoreMode::Max;
let detected_wakewords = run_detection_simulation(config, "/tests/resources/alexa.rpw");
assert_eq!(detected_wakewords.len(), 0);
}
#[test]
fn it_can_ignore_words_while_applying_audio_filters() {
let mut config = RustpotterConfig::default();
config.detector.avg_threshold = 0.;
config.detector.threshold = 0.45;
config.detector.min_scores = 0;
config.filters.gain_normalizer.enabled = true;
config.filters.band_pass.enabled = true;
config.detector.score_mode = ScoreMode::Max;
let detected_wakewords = run_detection_simulation(config, "/tests/resources/alexa.rpw");
assert_eq!(detected_wakewords.len(), 0);
}
#[test]
fn it_can_detect_wakewords_while_applying_band_pass_audio_filter() {
let mut config = RustpotterConfig::default();
config.detector.avg_threshold = 0.;
config.detector.threshold = 0.5;
config.filters.gain_normalizer.enabled = false;
config.filters.band_pass.enabled = true;
config.filters.band_pass.low_cutoff = 80.0;
config.filters.band_pass.high_cutoff = 400.0;
config.detector.score_mode = ScoreMode::Max;
let detected_wakewords = run_detection_simulation(config, "/tests/resources/oye_casa_g.rpw");
assert_eq!(detected_wakewords.len(), 2);
assert_eq!(detected_wakewords[0].score, 0.6858197);
assert_eq!(detected_wakewords[1].score, 0.66327363);
}
#[test]
fn it_can_detect_wakewords_while_applying_gain_normalizer_audio_filter() {
let mut config = RustpotterConfig::default();
config.detector.avg_threshold = 0.;
config.detector.threshold = 0.5;
config.filters.gain_normalizer.enabled = true;
config.filters.band_pass.enabled = false;
config.detector.score_mode = ScoreMode::Max;
let detected_wakewords =
run_detection_simulation_with_gains(config, "/tests/resources/oye_casa_g.rpw", 0.2, 5.);
assert_eq!(detected_wakewords.len(), 2);
assert_eq!(detected_wakewords[0].score, 0.7304294);
assert_eq!(detected_wakewords[1].score, 0.71067876);
}
#[test]
fn it_can_detect_wakewords_while_applying_gain_normalizer_and_band_pass_audio_filters() {
let mut config = RustpotterConfig::default();
config.detector.avg_threshold = 0.;
config.detector.threshold = 0.5;
config.filters.gain_normalizer.enabled = true;
config.filters.band_pass.enabled = true;
config.filters.band_pass.low_cutoff = 80.0;
config.filters.band_pass.high_cutoff = 500.0;
config.detector.score_mode = ScoreMode::Median;
let detected_wakewords =
run_detection_simulation_with_gains(config, "/tests/resources/oye_casa_g.rpw", 0.2, 5.);
assert_eq!(detected_wakewords.len(), 2);
assert_eq!(detected_wakewords[0].score, 0.5775406);
assert_eq!(detected_wakewords[1].score, 0.5828697);
}
#[test]
fn it_can_detect_wakewords_on_record_with_noise() {
let mut config = RustpotterConfig::default();
config.detector.avg_threshold = 0.3;
config.detector.threshold = 0.47;
config.filters.gain_normalizer.enabled = false;
config.filters.band_pass.enabled = false;
config.detector.score_mode = ScoreMode::Max;
config.detector.min_scores = 5;
let detected_wakewords = run_detection_with_audio_file(
config,
"/tests/resources/oye_casa_real.rpw",
"/tests/resources/real_sample.wav",
);
assert_eq!(detected_wakewords.len(), 3);
assert_eq!(detected_wakewords[0].avg_score, 0.4676845);
assert_eq!(detected_wakewords[0].score, 0.527971);
assert_eq!(detected_wakewords[0].counter, 24);
assert_eq!(detected_wakewords[1].avg_score, 0.32865646);
assert_eq!(detected_wakewords[1].score, 0.48120698);
assert_eq!(detected_wakewords[1].counter, 7);
assert_eq!(detected_wakewords[2].avg_score, 0.30807483);
assert_eq!(detected_wakewords[2].score, 0.5164661);
assert_eq!(detected_wakewords[2].counter, 35);
}
#[test]
fn it_can_detect_wakewords_on_record_with_noise_using_filters() {
let mut config = RustpotterConfig::default();
config.detector.avg_threshold = 0.3;
config.detector.threshold = 0.49;
config.filters.gain_normalizer.enabled = true;
config.filters.gain_normalizer.min_gain = 0.4;
config.filters.band_pass.enabled = true;
config.filters.band_pass.low_cutoff = 210.0;
config.filters.band_pass.high_cutoff = 700.0;
config.detector.score_mode = ScoreMode::Max;
config.detector.min_scores = 5;
let detected_wakewords = run_detection_with_audio_file(
config,
"/tests/resources/oye_casa_real.rpw",
"/tests/resources/real_sample.wav",
);
assert_eq!(detected_wakewords.len(), 3);
assert_eq!(detected_wakewords[0].avg_score, 0.45496628);
assert_eq!(detected_wakewords[0].score, 0.5380342);
assert_eq!(detected_wakewords[0].counter, 23);
assert_eq!(detected_wakewords[1].avg_score, 0.336222);
assert_eq!(detected_wakewords[1].score, 0.5001262);
assert_eq!(detected_wakewords[1].counter, 5);
assert_eq!(detected_wakewords[2].avg_score, 0.3049497);
assert_eq!(detected_wakewords[2].score, 0.5189481);
assert_eq!(detected_wakewords[2].counter, 31);
}
#[test]
fn it_can_detect_wakewords_using_trained_model() {
let mut config = RustpotterConfig::default();
config.detector.avg_threshold = 0.;
let detected_wakewords = run_detection_with_audio_file(
config,
"/tests/resources/ok_casa-tiny.rpw",
"/tests/resources/ok_casa.wav",
);
assert_eq!(detected_wakewords.len(), 1);
assert_eq!(detected_wakewords[0].counter, 34);
assert_eq!(detected_wakewords[0].avg_score, 0.);
assert_eq!(detected_wakewords[0].score, 0.9997649);
assert_eq!(detected_wakewords[0].scores["ok_casa"], 3.7506533);
assert_eq!(detected_wakewords[0].scores["none"], -16.83091);
}
#[test]
fn it_can_detect_wakewords_using_trained_model_and_avg_score() {
let mut config = RustpotterConfig::default();
config.detector.avg_threshold = 0.5;
let detected_wakewords = run_detection_with_audio_file(
config,
"/tests/resources/ok_casa-tiny.rpw",
"/tests/resources/ok_casa.wav",
);
assert_eq!(detected_wakewords.len(), 1);
assert_eq!(detected_wakewords[0].counter, 34);
assert_eq!(detected_wakewords[0].avg_score, 0.9997649);
assert_eq!(detected_wakewords[0].score, 0.9997649);
assert_eq!(detected_wakewords[0].scores["ok_casa"], 3.7506533);
assert_eq!(detected_wakewords[0].scores["none"], -16.83091);
}
#[test]
fn it_can_detect_wakewords_in_eager_mode() {
let mut config = RustpotterConfig::default();
config.detector.avg_threshold = 0.;
config.detector.min_scores = 20;
config.detector.eager = true;
let detected_wakewords = run_detection_with_audio_file(
config,
"/tests/resources/ok_casa-tiny.rpw",
"/tests/resources/ok_casa.wav",
);
assert_eq!(detected_wakewords.len(), 1);
assert_eq!(detected_wakewords[0].counter, 20);
assert_eq!(detected_wakewords[0].avg_score, 0.);
assert_eq!(detected_wakewords[0].score, 0.9992142);
assert_eq!(detected_wakewords[0].scores["ok_casa"], 23.990948);
assert_eq!(detected_wakewords[0].scores["none"], 6.0654087);
}
#[test]
fn it_can_remove_wakeword_by_key() {
let config = RustpotterConfig::default();
let mut detector = Rustpotter::new(&config).unwrap();
let wakeword_key = "test_key";
let dir = env!("CARGO_MANIFEST_DIR");
let wakeword_path = dir.to_owned() + "/tests/resources/ok_casa-tiny.rpw";
detector
.add_wakeword_from_file(wakeword_key, &wakeword_path)
.unwrap();
let result = detector.remove_wakeword(wakeword_key);
assert!(result, "Wakeword removed");
}
#[test]
fn it_can_remove_all_wakewords() {
let config = RustpotterConfig::default();
let mut detector = Rustpotter::new(&config).unwrap();
let wakeword_key = "test_key";
let dir = env!("CARGO_MANIFEST_DIR");
let wakeword_path = dir.to_owned() + "/tests/resources/ok_casa-tiny.rpw";
detector
.add_wakeword_from_file(wakeword_key, &wakeword_path)
.unwrap();
let result = detector.remove_wakewords();
assert!(result, "Wakewords removed");
}
fn run_detection_with_audio_file(
mut config: RustpotterConfig,
model_path: &str,
audio_path: &str,
) -> Vec<rustpotter::RustpotterDetection> {
let dir = env!("CARGO_MANIFEST_DIR");
let audio_file = std::fs::File::open(dir.to_owned() + audio_path).unwrap();
let wav_reader = hound::WavReader::new(std::io::BufReader::new(audio_file)).unwrap();
let wav_spec: rustpotter::AudioFmt = wav_reader.spec().try_into().unwrap();
config.fmt = wav_spec;
let mut rustpotter = Rustpotter::new(&config).unwrap();
let model_path = dir.to_owned() + model_path;
rustpotter
.add_wakeword_from_file("wakeword", &model_path)
.unwrap();
let mut audio_samples = wav_reader
.into_samples::<f32>()
.map(|chunk| *chunk.as_ref().unwrap())
.collect::<Vec<_>>();
let mut silence = vec![0_f32; config.fmt.sample_rate * 5];
audio_samples.append(&mut silence);
let detected_wakewords = audio_samples
.chunks_exact(rustpotter.get_samples_per_frame())
.filter_map(|audio_buffer| rustpotter.process_samples(audio_buffer.into()))
.map(|detection| {
print_detection(&detection);
detection
})
.collect::<Vec<_>>();
detected_wakewords
}
fn run_detection_simulation(
config: RustpotterConfig,
model_path: &str,
) -> Vec<rustpotter::RustpotterDetection> {
run_detection_simulation_with_gains(config, model_path, 1.0, 1.0)
}
fn run_detection_simulation_with_gains(
mut config: RustpotterConfig,
model_path: &str,
sample_1_gain: f32,
sample_2_gain: f32,
) -> Vec<rustpotter::RustpotterDetection> {
let dir = env!("CARGO_MANIFEST_DIR");
let sample_rate = 16000;
let bits_per_sample = 16;
config.fmt.sample_rate = sample_rate;
config.fmt.sample_format = SampleFormat::I16;
config.fmt.channels = 1;
let mut rustpotter = Rustpotter::new(&config).unwrap();
let model_path = dir.to_owned() + model_path;
rustpotter
.add_wakeword_from_file("wakeword", &model_path)
.unwrap();
let sample_1_path = dir.to_owned() + "/tests/resources/oye_casa_g_1.wav";
let sample_2_path = dir.to_owned() + "/tests/resources/oye_casa_g_2.wav";
let live_audio_simulation = get_audio_with_two_wakewords_with_gain(
sample_rate,
bits_per_sample,
sample_1_path,
sample_2_path,
sample_1_gain,
sample_2_gain,
);
let detected_wakewords = live_audio_simulation
.chunks_exact(rustpotter.get_bytes_per_frame())
.filter_map(|audio_buffer| rustpotter.process_bytes(audio_buffer))
.map(|detection| {
print_detection(&detection);
detection
})
.collect::<Vec<_>>();
detected_wakewords
}
fn get_audio_with_two_wakewords_with_gain(
sample_rate: usize,
bits_per_sample: u16,
sample_1_path: String,
sample_2_path: String,
sample_1_gain: f32,
sample_2_gain: f32,
) -> Vec<u8> {
let mut live_audio_simulation: Vec<u8> = Vec::new();
live_audio_simulation.append(&mut generate_silence_buffer(
sample_rate,
bits_per_sample,
5,
));
live_audio_simulation.append(&mut read_wav_buffer(&sample_1_path, sample_1_gain));
live_audio_simulation.append(&mut generate_silence_buffer(
sample_rate,
bits_per_sample,
5,
));
live_audio_simulation.append(&mut read_wav_buffer(&sample_2_path, sample_2_gain));
live_audio_simulation.append(&mut generate_silence_buffer(
sample_rate,
bits_per_sample,
5,
));
live_audio_simulation
}
fn generate_silence_buffer(sample_rate: usize, bit_depth: u16, seconds: usize) -> Vec<u8> {
vec![0_u8; sample_rate * (bit_depth / 8) as usize * seconds]
}
// this function assumes wav file has i16 samples
fn read_wav_buffer(path: &str, gain: f32) -> Vec<u8> {
let file = File::open(path).unwrap();
let mut reader = BufReader::new(file);
let mut buffer = Vec::new();
reader.read_to_end(&mut buffer).unwrap();
// remove wav header
buffer.drain(0..44);
let buffer_with_gain = buffer
.chunks_exact(2)
.map(|bytes| {
i16::to_le_bytes(
(i16::from_le_bytes([bytes[0], bytes[1]]) as f32 * gain)
.round()
.clamp(i16::MIN as f32, i16::MAX as f32) as i16,
)
})
.fold(Vec::new(), |mut acc, b| {
acc.append(&mut b.to_vec());
acc
});
buffer_with_gain
}
fn print_detection(detection: &rustpotter::RustpotterDetection) {
println!("-----=====-----");
println!("Detection Score: {}", detection.score);
println!("Avg Score: {}", detection.avg_score);
println!("Scores: {:?}", detection.scores);
println!("Partial detections: {}", detection.counter);
println!("_______________");
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
GiviMAD/rustpotter | https://github.com/GiviMAD/rustpotter/blob/46bbc73223afe5fc7b90f30455046432fc3c9432/tests/wakeword.rs | tests/wakeword.rs | use rustpotter::{
ModelType, WakewordLoad, WakewordModel, WakewordModelTrain, WakewordModelTrainOptions,
WakewordRef, WakewordRefBuildFromFiles, WakewordSave,
};
#[test]
fn it_creates_a_new_wakeword_from_samples() {
let dir = env!("CARGO_MANIFEST_DIR");
let samples = vec![
dir.to_owned() + "/tests/resources/oye_casa_g_1.wav",
dir.to_owned() + "/tests/resources/oye_casa_g_2.wav",
dir.to_owned() + "/tests/resources/oye_casa_g_3.wav",
dir.to_owned() + "/tests/resources/oye_casa_g_4.wav",
dir.to_owned() + "/tests/resources/oye_casa_g_5.wav",
];
let n_samples = samples.len();
let wakeword =
WakewordRef::new_from_sample_files("oye casa".to_string(), None, None, samples, 5).unwrap();
assert_eq!(
wakeword.samples_features.len(),
n_samples,
"Sample features are extracted"
);
}
#[test]
fn it_creates_a_new_wakeword_from_int_samples_which_saves_to_file() {
let dir = env!("CARGO_MANIFEST_DIR");
let samples = vec![
dir.to_owned() + "/tests/resources/oye_casa_g_1.wav",
dir.to_owned() + "/tests/resources/oye_casa_g_2.wav",
dir.to_owned() + "/tests/resources/oye_casa_g_3.wav",
dir.to_owned() + "/tests/resources/oye_casa_g_4.wav",
dir.to_owned() + "/tests/resources/oye_casa_g_5.wav",
];
let wakeword =
WakewordRef::new_from_sample_files("oye casa".to_string(), None, None, samples, 5).unwrap();
let model_path = dir.to_owned() + "/tests/resources/oye_casa_g.rpw";
wakeword.save_to_file(&model_path).unwrap();
}
#[test]
fn it_creates_another_wakeword_from_int_samples_which_saves_to_file() {
let dir = env!("CARGO_MANIFEST_DIR");
let samples = vec![
dir.to_owned() + "/tests/resources/alexa.wav",
dir.to_owned() + "/tests/resources/alexa2.wav",
dir.to_owned() + "/tests/resources/alexa3.wav",
];
let wakeword =
WakewordRef::new_from_sample_files("alexa".to_string(), None, None, samples, 5).unwrap();
let model_path = dir.to_owned() + "/tests/resources/alexa.rpw";
wakeword.save_to_file(&model_path).unwrap();
}
#[test]
fn it_creates_wakeword_from_float_samples_which_saves_to_file() {
let dir = env!("CARGO_MANIFEST_DIR");
let samples = vec![
dir.to_owned() + "/tests/resources/oye_casa_real_1.wav",
dir.to_owned() + "/tests/resources/oye_casa_real_2.wav",
dir.to_owned() + "/tests/resources/oye_casa_real_3.wav",
dir.to_owned() + "/tests/resources/oye_casa_real_4.wav",
dir.to_owned() + "/tests/resources/oye_casa_real_5.wav",
dir.to_owned() + "/tests/resources/oye_casa_real_6.wav",
];
let wakeword =
WakewordRef::new_from_sample_files("oye casa".to_string(), None, None, samples, 5).unwrap();
let model_path = dir.to_owned() + "/tests/resources/oye_casa_real.rpw";
wakeword.save_to_file(&model_path).unwrap();
}
#[test]
fn it_loads_a_wakeword_from_file() {
let dir = env!("CARGO_MANIFEST_DIR");
let n_samples = 5;
let model_path = dir.to_owned() + "/tests/resources/oye_casa_g.rpw";
let wakeword = WakewordRef::load_from_file(&model_path).unwrap();
assert_eq!(
wakeword.samples_features.len(),
n_samples,
"Samples features number is correct"
);
}
#[test]
fn it_train_a_new_wakeword_from_samples() {
let dir = env!("CARGO_MANIFEST_DIR");
let train_dir = dir.to_owned() + "/tests/resources/train";
let test_dir = dir.to_owned() + "/tests/resources/test";
let mfcc_size = 16;
let train_config = WakewordModelTrainOptions::new(ModelType::Medium, 0.027, 10, 10, mfcc_size);
let ww_model = WakewordModel::train_from_dirs(train_config, train_dir, test_dir, None).unwrap();
assert_eq!(ww_model.labels.len(), 2, "Sample features are extracted");
assert_eq!(ww_model.weights.len(), 6, "Model weights are created");
assert_eq!(ww_model.train_size, 168, "Correct number of mfcc vectors");
assert_eq!(ww_model.mfcc_size, mfcc_size, "Correct mfcc vector length");
}
| rust | Apache-2.0 | 46bbc73223afe5fc7b90f30455046432fc3c9432 | 2026-01-04T20:17:53.884437Z | false |
achanda/ipnetwork | https://github.com/achanda/ipnetwork/blob/f01575cbf2fc596c0a1761c122aa92525cbb7974/src/lib.rs | src/lib.rs | //! The `ipnetwork` crate provides a set of APIs to work with IP CIDRs in
//! Rust.
#![crate_type = "lib"]
#![deny(
missing_debug_implementations,
unsafe_code,
unused_extern_crates,
unused_import_braces
)]
use std::{
convert::TryFrom,
fmt,
net::{IpAddr, Ipv4Addr, Ipv6Addr},
str::FromStr,
};
mod error;
mod ipv4;
mod ipv6;
mod parse;
mod size;
pub use crate::error::{IpNetworkError, NetworkSizeError};
pub use crate::ipv4::Ipv4NetworkIterator;
pub use crate::ipv4::{ipv4_mask_to_prefix, ipv4_mask_to_prefix_checked, Ipv4Network};
pub use crate::ipv6::Ipv6NetworkIterator;
pub use crate::ipv6::{ipv6_mask_to_prefix, ipv6_mask_to_prefix_checked, Ipv6Network};
pub use crate::size::NetworkSize;
/// Represents a generic network range. This type can have two variants:
/// the v4 and the v6 case.
#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub enum IpNetwork {
V4(Ipv4Network),
V6(Ipv6Network),
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for IpNetwork {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = <String>::deserialize(deserializer)?;
IpNetwork::from_str(&s).map_err(serde::de::Error::custom)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for IpNetwork {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.collect_str(self)
}
}
#[cfg(feature = "schemars")]
impl schemars::JsonSchema for IpNetwork {
fn schema_name() -> std::borrow::Cow<'static, str> {
std::borrow::Cow::Borrowed("IpNetwork")
}
fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
schemars::json_schema!({
"oneOf": [
{
"title": "v4",
"allOf": [generator.subschema_for::<Ipv4Network>()]
},
{
"title": "v6",
"allOf": [generator.subschema_for::<Ipv6Network>()]
}
],
"x-rust-type": "ipnetwork::IpNetwork"
})
}
}
impl IpNetwork {
/// Constructs a new `IpNetwork` from a given `IpAddr` and a prefix denoting the
/// network size. If the prefix is larger than 32 (for IPv4) or 128 (for IPv6), this
/// will raise an `IpNetworkError::InvalidPrefix` error. Support for IPv6 is not
/// complete yet.
pub fn new(ip: IpAddr, prefix: u8) -> Result<IpNetwork, IpNetworkError> {
match ip {
IpAddr::V4(a) => Ok(IpNetwork::V4(Ipv4Network::new(a, prefix)?)),
IpAddr::V6(a) => Ok(IpNetwork::V6(Ipv6Network::new(a, prefix)?)),
}
}
/// Constructs a new `IpNetwork` from a network address and a network mask.
///
/// If the netmask is not valid this will return an `IpNetworkError::InvalidPrefix`.
pub fn with_netmask(netaddr: IpAddr, netmask: IpAddr) -> Result<Self, IpNetworkError> {
let prefix = ip_mask_to_prefix(netmask)?;
Self::new(netaddr, prefix)
}
/// Returns the IP part of a given `IpNetwork`
pub const fn ip(&self) -> IpAddr {
match *self {
IpNetwork::V4(ref a) => IpAddr::V4(a.ip()),
IpNetwork::V6(ref a) => IpAddr::V6(a.ip()),
}
}
/// Returns the prefix of the given `IpNetwork`
///
/// # Example
/// ```
/// use ipnetwork::IpNetwork;
///
/// assert_eq!(IpNetwork::V4("10.9.0.1".parse().unwrap()).prefix(), 32u8);
/// assert_eq!(IpNetwork::V4("10.9.0.32/16".parse().unwrap()).prefix(), 16u8);
///
/// assert_eq!(IpNetwork::V6("ff01::0".parse().unwrap()).prefix(), 128u8);
/// assert_eq!(IpNetwork::V6("ff01::0/32".parse().unwrap()).prefix(), 32u8);
/// ```
pub const fn prefix(&self) -> u8 {
match *self {
IpNetwork::V4(ref a) => a.prefix(),
IpNetwork::V6(ref a) => a.prefix(),
}
}
/// Returns the address of the network denoted by this `IpNetwork`.
/// This means the lowest possible IP address inside of the network.
///
/// # Examples
///
/// ```
/// use std::net::{Ipv4Addr, Ipv6Addr};
/// use ipnetwork::IpNetwork;
///
/// let net: IpNetwork = "10.1.9.32/16".parse().unwrap();
/// assert_eq!(net.network(), Ipv4Addr::new(10, 1, 0, 0));
/// let net: IpNetwork = "2001:db8::/96".parse().unwrap();
/// assert_eq!(net.network(), Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0));
/// ```
pub const fn network(&self) -> IpAddr {
match *self {
IpNetwork::V4(ref a) => IpAddr::V4(a.network()),
IpNetwork::V6(ref a) => IpAddr::V6(a.network()),
}
}
/// Returns the broadcasting address of this `IpNetwork`.
/// This means the highest possible IP address inside of the network.
///
/// # Examples
///
/// ```
/// use std::net::Ipv4Addr;
/// use ipnetwork::{IpNetwork, Ipv4Network};
///
/// let net: Ipv4Network = "10.9.0.32/16".parse().unwrap();
/// assert_eq!(net.broadcast(), Ipv4Addr::new(10, 9, 255, 255));
/// ```
pub const fn broadcast(&self) -> IpAddr {
match *self {
IpNetwork::V4(ref a) => IpAddr::V4(a.broadcast()),
IpNetwork::V6(ref a) => IpAddr::V6(a.broadcast()),
}
}
/// Returns the mask for this `IpNetwork`.
/// That means the `prefix` most significant bits will be 1 and the rest 0
///
/// # Example
///
/// ```
/// use ipnetwork::IpNetwork;
/// use std::net::{Ipv4Addr, Ipv6Addr};
///
/// let v4_net: IpNetwork = "10.9.0.1".parse().unwrap();
/// assert_eq!(v4_net.mask(), Ipv4Addr::new(255, 255, 255, 255));
/// let v4_net: IpNetwork = "10.9.0.32/16".parse().unwrap();
/// assert_eq!(v4_net.mask(), Ipv4Addr::new(255, 255, 0, 0));
///
/// let v6_net: IpNetwork = "ff01::0".parse().unwrap();
/// assert_eq!(v6_net.mask(), Ipv6Addr::new(0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff));
/// let v6_net: IpNetwork = "ff01::0/32".parse().unwrap();
/// assert_eq!(v6_net.mask(), Ipv6Addr::new(0xffff, 0xffff, 0, 0, 0, 0, 0, 0));
/// ```
pub const fn mask(&self) -> IpAddr {
match *self {
IpNetwork::V4(ref a) => IpAddr::V4(a.mask()),
IpNetwork::V6(ref a) => IpAddr::V6(a.mask()),
}
}
/// Returns true if the IP in this `IpNetwork` is a valid IPv4 address,
/// false if it's a valid IPv6 address.
///
/// # Example
///
///```
/// use ipnetwork::IpNetwork;
///
/// let v4: IpNetwork = IpNetwork::V4("10.9.0.32/16".parse().unwrap());
/// assert_eq!(v4.is_ipv4(), true);
/// assert_eq!(v4.is_ipv6(), false);
///```
pub const fn is_ipv4(&self) -> bool {
match *self {
IpNetwork::V4(_) => true,
IpNetwork::V6(_) => false,
}
}
/// Returns true if the IP in this `IpNetwork` is a valid IPv6 address,
/// false if it's a valid IPv4 address.
///
/// # Example
///
///```
/// use ipnetwork::IpNetwork;
///
/// let v6: IpNetwork = IpNetwork::V6("ff01::0/32".parse().unwrap());
/// assert_eq!(v6.is_ipv6(), true);
/// assert_eq!(v6.is_ipv4(), false);
///```
pub const fn is_ipv6(&self) -> bool {
match *self {
IpNetwork::V4(_) => false,
IpNetwork::V6(_) => true,
}
}
// TODO(abhishek) when TryFrom is stable, implement it for IpNetwork to
// variant conversions. Then use that to implement a generic is_subnet_of
// is_supernet_of, overlaps
/// Checks if a given `IpAddr` is in this `IpNetwork`
///
/// # Examples
///
/// ```
/// use std::net::IpAddr;
/// use ipnetwork::IpNetwork;
///
/// let net: IpNetwork = "127.0.0.0/24".parse().unwrap();
/// let ip1: IpAddr = "127.0.0.1".parse().unwrap();
/// let ip2: IpAddr = "172.0.0.1".parse().unwrap();
/// let ip4: IpAddr = "::1".parse().unwrap();
/// assert!(net.contains(ip1));
/// assert!(!net.contains(ip2));
/// assert!(!net.contains(ip4));
/// ```
#[inline]
pub const fn contains(&self, ip: IpAddr) -> bool {
match (*self, ip) {
(IpNetwork::V4(net), IpAddr::V4(ip)) => net.contains(ip),
(IpNetwork::V6(net), IpAddr::V6(ip)) => net.contains(ip),
_ => false,
}
}
/// Returns the number of possible host addresses in this `IpAddr`
///
/// # Examples
///
/// ```
/// use ipnetwork::{IpNetwork, NetworkSize};
///
///
/// let net: IpNetwork = "127.0.0.0/24".parse().unwrap();
/// assert_eq!(net.size(), NetworkSize::V4(256))
/// ```
pub fn size(&self) -> NetworkSize {
match *self {
IpNetwork::V4(ref ip) => NetworkSize::V4(ip.size()),
IpNetwork::V6(ref ip) => NetworkSize::V6(ip.size()),
}
}
/// Returns an iterator over the addresses contained in the network.
///
/// This lists all the addresses in the network range, in ascending order.
pub fn iter(&self) -> IpNetworkIterator {
let inner = match self {
IpNetwork::V4(ip) => IpNetworkIteratorInner::V4(ip.iter()),
IpNetwork::V6(ip) => IpNetworkIteratorInner::V6(ip.iter()),
};
IpNetworkIterator { inner }
}
}
/// Tries to parse the given string into a `IpNetwork`. Will first try to parse
/// it as an `Ipv4Network` and if that fails as an `Ipv6Network`. If both
/// fails it will return an `InvalidAddr` error.
///
/// # Examples
///
/// ```
/// use std::net::Ipv4Addr;
/// use ipnetwork::{IpNetwork, Ipv4Network};
///
/// let expected = IpNetwork::V4(Ipv4Network::new(Ipv4Addr::new(10, 1, 9, 32), 16).unwrap());
/// let from_cidr: IpNetwork = "10.1.9.32/16".parse().unwrap();
/// assert_eq!(expected, from_cidr);
/// ```
impl FromStr for IpNetwork {
type Err = IpNetworkError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
if let Ok(net) = Ipv4Network::from_str(s) {
Ok(IpNetwork::V4(net))
} else if let Ok(net) = Ipv6Network::from_str(s) {
Ok(IpNetwork::V6(net))
} else {
Err(IpNetworkError::InvalidAddr(s.to_string()))
}
}
}
impl TryFrom<&str> for IpNetwork {
type Error = IpNetworkError;
fn try_from(s: &str) -> Result<Self, Self::Error> {
IpNetwork::from_str(s)
}
}
impl From<Ipv4Network> for IpNetwork {
fn from(v4: Ipv4Network) -> IpNetwork {
IpNetwork::V4(v4)
}
}
impl From<Ipv6Network> for IpNetwork {
fn from(v6: Ipv6Network) -> IpNetwork {
IpNetwork::V6(v6)
}
}
impl From<Ipv4Addr> for IpNetwork {
fn from(addr: Ipv4Addr) -> IpNetwork {
IpNetwork::V4(Ipv4Network::from(addr))
}
}
impl From<Ipv6Addr> for IpNetwork {
fn from(addr: Ipv6Addr) -> IpNetwork {
IpNetwork::V6(Ipv6Network::from(addr))
}
}
impl From<IpAddr> for IpNetwork {
fn from(addr: IpAddr) -> IpNetwork {
match addr {
IpAddr::V4(a) => IpNetwork::from(a),
IpAddr::V6(a) => IpNetwork::from(a),
}
}
}
impl fmt::Display for IpNetwork {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
IpNetwork::V4(net) => net.fmt(f),
IpNetwork::V6(net) => net.fmt(f),
}
}
}
#[derive(Clone, Debug)]
enum IpNetworkIteratorInner {
V4(Ipv4NetworkIterator),
V6(Ipv6NetworkIterator),
}
#[derive(Clone, Debug)]
pub struct IpNetworkIterator {
inner: IpNetworkIteratorInner,
}
impl Iterator for IpNetworkIterator {
type Item = IpAddr;
fn next(&mut self) -> Option<IpAddr> {
match &mut self.inner {
IpNetworkIteratorInner::V4(iter) => iter.next().map(IpAddr::V4),
IpNetworkIteratorInner::V6(iter) => iter.next().map(IpAddr::V6),
}
}
fn size_hint(&self) -> (usize, Option<usize>) {
match &self.inner {
IpNetworkIteratorInner::V4(iter) => iter.size_hint(),
IpNetworkIteratorInner::V6(iter) => iter.size_hint(),
}
}
}
impl IntoIterator for &'_ IpNetwork {
type IntoIter = IpNetworkIterator;
type Item = IpAddr;
fn into_iter(self) -> IpNetworkIterator {
self.iter()
}
}
/// Converts a `IpAddr` network mask into a prefix.
/// If the mask is invalid this will return an `IpNetworkError::InvalidPrefix`.
pub fn ip_mask_to_prefix(mask: IpAddr) -> Result<u8, IpNetworkError> {
match mask {
IpAddr::V4(mask) => ipv4_mask_to_prefix(mask),
IpAddr::V6(mask) => ipv6_mask_to_prefix(mask),
}
}
/// Converts a `IpAddr` network mask into a prefix.
///
/// If the mask is invalid this will return `None`. This is useful in const contexts where
/// [`Option::unwrap`] may be called to trigger a compile-time error if the prefix is invalid.
pub const fn ip_mask_to_prefix_checked(mask: IpAddr) -> Option<u8> {
match mask {
IpAddr::V4(mask) => ipv4_mask_to_prefix_checked(mask),
IpAddr::V6(mask) => ipv6_mask_to_prefix_checked(mask),
}
}
#[cfg(test)]
mod test {
#[test]
#[cfg(feature = "serde")]
fn deserialize_from_serde_json_value() {
use super::*;
let network = IpNetwork::from_str("0.0.0.0/0").unwrap();
let val: serde_json::value::Value =
serde_json::from_str(&serde_json::to_string(&network).unwrap()).unwrap();
let _deser: IpNetwork = serde_json::from_value(val)
.expect("Fails to deserialize from json_value::value::Value");
}
}
| rust | Apache-2.0 | f01575cbf2fc596c0a1761c122aa92525cbb7974 | 2026-01-04T20:19:08.816812Z | false |
achanda/ipnetwork | https://github.com/achanda/ipnetwork/blob/f01575cbf2fc596c0a1761c122aa92525cbb7974/src/parse.rs | src/parse.rs | use crate::error::IpNetworkError;
pub fn cidr_parts(cidr: &str) -> Result<(&str, Option<&str>), IpNetworkError> {
// Try to find a single slash
if let Some(sep) = cidr.find('/') {
let (ip, prefix) = cidr.split_at(sep);
// Error if cidr has multiple slashes
if prefix[1..].find('/').is_some() {
Err(IpNetworkError::InvalidCidrFormat(format!(
"CIDR must contain a single '/': {cidr}"
)))
} else {
// Handle the case when cidr has exactly one slash
Ok((ip, Some(&prefix[1..])))
}
} else {
// Handle the case when cidr does not have a slash
Ok((cidr, None))
}
}
pub fn parse_prefix(prefix: &str, max: u8) -> Result<u8, IpNetworkError> {
prefix
.parse()
.map_err(|_| IpNetworkError::InvalidPrefix)
.and_then(|mask| {
if mask > max {
Err(IpNetworkError::InvalidPrefix)
} else {
Ok(mask)
}
})
}
| rust | Apache-2.0 | f01575cbf2fc596c0a1761c122aa92525cbb7974 | 2026-01-04T20:19:08.816812Z | false |
achanda/ipnetwork | https://github.com/achanda/ipnetwork/blob/f01575cbf2fc596c0a1761c122aa92525cbb7974/src/ipv4.rs | src/ipv4.rs | use crate::error::IpNetworkError;
use crate::parse::{cidr_parts, parse_prefix};
use std::{convert::TryFrom, fmt, net::Ipv4Addr, str::FromStr};
const IPV4_BITS: u8 = 32;
/// Represents a network range where the IP addresses are of v4
#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct Ipv4Network {
addr: Ipv4Addr,
prefix: u8,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Ipv4Network {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = <String>::deserialize(deserializer)?;
Ipv4Network::from_str(&s).map_err(serde::de::Error::custom)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for Ipv4Network {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.collect_str(self)
}
}
#[cfg(feature = "schemars")]
impl schemars::JsonSchema for Ipv4Network {
fn schema_name() -> std::borrow::Cow<'static, str> {
std::borrow::Cow::Borrowed("Ipv4Network")
}
fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
schemars::json_schema!({
"type": "string",
"pattern": concat!(
r#"^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}"#,
r#"(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"#,
r#"\/(3[0-2]|[0-2]?[0-9])$"#,
),
"x-rust-type": "ipnetwork::Ipv4Network"
})
}
}
impl Ipv4Network {
/// Constructs a new `Ipv4Network` from any `Ipv4Addr` and a prefix denoting the network size.
///
/// If the prefix is larger than 32 this will return an `IpNetworkError::InvalidPrefix`.
pub const fn new(addr: Ipv4Addr, prefix: u8) -> Result<Ipv4Network, IpNetworkError> {
match Ipv4Network::new_checked(addr, prefix) {
Some(a) => Ok(a),
None => Err(IpNetworkError::InvalidPrefix),
}
}
/// Constructs a new `Ipv4Network` from any `Ipv4Addr`, and a prefix denoting the network size.
///
/// If the prefix is larger than 32 this will return `None`. This is useful in const contexts,
/// where [`Option::unwrap`] may be called to trigger a compile-time error in case the prefix
/// is an unexpected value.
///
/// # Examples
///
/// ```
/// use std::net::Ipv4Addr;
/// use ipnetwork::Ipv4Network;
///
/// const PREFIX: u8 = 24;
/// const ADDR: Ipv4Addr = Ipv4Addr::new(192, 168, 1, 1);
///
/// // Okay!
/// const NETWORK: Ipv4Network = Ipv4Network::new_checked(ADDR, PREFIX).unwrap();
/// assert_eq!(NETWORK.prefix(), PREFIX);
/// ```
///
/// ```should_panic
/// use std::net::Ipv4Addr;
/// use ipnetwork::Ipv4Network;
///
/// // Prefix is greater than 32.
/// const PREFIX: u8 = 32 + 1;
/// const ADDR: Ipv4Addr = Ipv4Addr::new(192, 168, 1, 1);
///
/// // This fails!
/// const NETWORK: Option<Ipv4Network> = Ipv4Network::new_checked(ADDR, PREFIX);
/// assert_eq!(NETWORK.unwrap().prefix(), PREFIX);
/// ```
pub const fn new_checked(addr: Ipv4Addr, prefix: u8) -> Option<Ipv4Network> {
if prefix > IPV4_BITS {
None
} else {
Some(Ipv4Network { addr, prefix })
}
}
/// Constructs a new `Ipv4Network` from a network address and a network mask.
///
/// If the netmask is not valid this will return an `IpNetworkError::InvalidPrefix`.
pub fn with_netmask(
netaddr: Ipv4Addr,
netmask: Ipv4Addr,
) -> Result<Ipv4Network, IpNetworkError> {
let prefix = ipv4_mask_to_prefix(netmask)?;
let net = Self {
addr: netaddr,
prefix,
};
Ok(net)
}
/// Returns an iterator over `Ipv4Network`. Each call to `next` will return the next
/// `Ipv4Addr` in the given network. `None` will be returned when there are no more
/// addresses.
pub fn iter(self) -> Ipv4NetworkIterator {
let start = u32::from(self.network());
let end = start + (self.size() - 1);
Ipv4NetworkIterator {
next: Some(start),
end,
}
}
pub const fn ip(self) -> Ipv4Addr {
self.addr
}
pub const fn prefix(self) -> u8 {
self.prefix
}
/// Checks if the given `Ipv4Network` is a subnet of the other.
pub fn is_subnet_of(self, other: Ipv4Network) -> bool {
other.ip() <= self.ip() && other.broadcast() >= self.broadcast()
}
/// Checks if the given `Ipv4Network` is a supernet of the other.
pub fn is_supernet_of(self, other: Ipv4Network) -> bool {
other.is_subnet_of(self)
}
/// Checks if the given `Ipv4Network` is partly contained in other.
pub fn overlaps(self, other: Ipv4Network) -> bool {
other.contains(self.ip())
|| other.contains(self.broadcast())
|| self.contains(other.ip())
|| self.contains(other.broadcast())
}
/// Returns the mask for this `Ipv4Network`.
/// That means the `prefix` most significant bits will be 1 and the rest 0
///
/// # Examples
///
/// ```
/// use std::net::Ipv4Addr;
/// use ipnetwork::Ipv4Network;
///
/// let net: Ipv4Network = "127.0.0.0".parse().unwrap();
/// assert_eq!(net.mask(), Ipv4Addr::new(255, 255, 255, 255));
/// let net: Ipv4Network = "127.0.0.0/16".parse().unwrap();
/// assert_eq!(net.mask(), Ipv4Addr::new(255, 255, 0, 0));
/// ```
pub const fn mask(&self) -> Ipv4Addr {
debug_assert!(self.prefix <= 32);
if self.prefix == 0 {
return Ipv4Addr::new(0, 0, 0, 0);
}
let mask = u32::MAX << (IPV4_BITS - self.prefix);
Ipv4Addr::from_bits(mask)
}
/// Returns the address of the network denoted by this `Ipv4Network`.
/// This means the lowest possible IPv4 address inside of the network.
///
/// # Examples
///
/// ```
/// use std::net::Ipv4Addr;
/// use ipnetwork::Ipv4Network;
///
/// let net: Ipv4Network = "10.1.9.32/16".parse().unwrap();
/// assert_eq!(net.network(), Ipv4Addr::new(10, 1, 0, 0));
/// ```
pub const fn network(&self) -> Ipv4Addr {
let mask = self.mask().to_bits();
let ip = self.addr.to_bits() & mask;
Ipv4Addr::from_bits(ip)
}
/// Returns the broadcasting address of this `Ipv4Network`.
/// This means the highest possible IPv4 address inside of the network.
///
/// # Examples
///
/// ```
/// use std::net::Ipv4Addr;
/// use ipnetwork::Ipv4Network;
///
/// let net: Ipv4Network = "10.9.0.32/16".parse().unwrap();
/// assert_eq!(net.broadcast(), Ipv4Addr::new(10, 9, 255, 255));
/// ```
pub const fn broadcast(&self) -> Ipv4Addr {
let mask = self.mask().to_bits();
let broadcast = self.addr.to_bits() | !mask;
Ipv4Addr::from_bits(broadcast)
}
/// Checks if a given `Ipv4Addr` is in this `Ipv4Network`
///
/// # Examples
///
/// ```
/// use std::net::Ipv4Addr;
/// use ipnetwork::Ipv4Network;
///
/// let net: Ipv4Network = "127.0.0.0/24".parse().unwrap();
/// assert!(net.contains(Ipv4Addr::new(127, 0, 0, 70)));
/// assert!(!net.contains(Ipv4Addr::new(127, 0, 1, 70)));
/// ```
#[inline]
pub const fn contains(&self, ip: Ipv4Addr) -> bool {
debug_assert!(self.prefix <= IPV4_BITS);
let mask = !(0xffff_ffff_u64 >> self.prefix) as u32;
let net = self.addr.to_bits() & mask;
(ip.to_bits() & mask) == net
}
/// Returns number of possible host addresses in this `Ipv4Network`.
///
/// # Examples
///
/// ```
/// use std::net::Ipv4Addr;
/// use ipnetwork::Ipv4Network;
///
/// let net: Ipv4Network = "10.1.0.0/16".parse().unwrap();
/// assert_eq!(net.size(), 65536);
///
/// let tinynet: Ipv4Network = "0.0.0.0/32".parse().unwrap();
/// assert_eq!(tinynet.size(), 1);
/// ```
pub fn size(self) -> u32 {
debug_assert!(self.prefix <= 32);
if self.prefix == 0 {
return u32::MAX;
}
1 << (IPV4_BITS - self.prefix)
}
/// Returns the `n`:th address within this network.
/// The adresses are indexed from 0 and `n` must be smaller than the size of the network.
///
/// # Examples
///
/// ```
/// use std::net::Ipv4Addr;
/// use ipnetwork::Ipv4Network;
///
/// let net: Ipv4Network = "192.168.0.0/24".parse().unwrap();
/// assert_eq!(net.nth(0).unwrap(), Ipv4Addr::new(192, 168, 0, 0));
/// assert_eq!(net.nth(15).unwrap(), Ipv4Addr::new(192, 168, 0, 15));
/// assert!(net.nth(256).is_none());
///
/// let net2: Ipv4Network = "10.0.0.0/16".parse().unwrap();
/// assert_eq!(net2.nth(256).unwrap(), Ipv4Addr::new(10, 0, 1, 0));
/// ```
pub fn nth(self, n: u32) -> Option<Ipv4Addr> {
if n < self.size() {
let net = u32::from(self.network());
Some(Ipv4Addr::from(net + n))
} else {
None
}
}
}
impl fmt::Display for Ipv4Network {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(fmt, "{}/{}", self.ip(), self.prefix())
}
}
/// Creates an `Ipv4Network` from parsing a string in CIDR notation.
///
/// # Examples
///
/// ```
/// use std::net::Ipv4Addr;
/// use ipnetwork::Ipv4Network;
///
/// let new = Ipv4Network::new(Ipv4Addr::new(10, 1, 9, 32), 16).unwrap();
/// let from_cidr: Ipv4Network = "10.1.9.32/16".parse().unwrap();
/// assert_eq!(new.ip(), from_cidr.ip());
/// assert_eq!(new.prefix(), from_cidr.prefix());
/// ```
impl FromStr for Ipv4Network {
type Err = IpNetworkError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let (addr_str, prefix_str) = cidr_parts(s)?;
let addr = Ipv4Addr::from_str(addr_str)?;
let prefix = match prefix_str {
Some(v) => {
if let Ok(netmask) = Ipv4Addr::from_str(v) {
ipv4_mask_to_prefix(netmask)?
} else {
parse_prefix(v, IPV4_BITS)?
}
}
None => IPV4_BITS,
};
Ipv4Network::new(addr, prefix)
}
}
impl TryFrom<&str> for Ipv4Network {
type Error = IpNetworkError;
fn try_from(s: &str) -> Result<Self, Self::Error> {
Ipv4Network::from_str(s)
}
}
impl From<Ipv4Addr> for Ipv4Network {
fn from(a: Ipv4Addr) -> Ipv4Network {
Ipv4Network {
addr: a,
prefix: 32,
}
}
}
#[derive(Clone, Debug)]
pub struct Ipv4NetworkIterator {
next: Option<u32>,
end: u32,
}
impl Iterator for Ipv4NetworkIterator {
type Item = Ipv4Addr;
fn next(&mut self) -> Option<Ipv4Addr> {
let next = self.next?;
self.next = if next == self.end {
None
} else {
Some(next + 1)
};
Some(next.into())
}
fn size_hint(&self) -> (usize, Option<usize>) {
if let Some(n) = self.next {
let elms = (self.end - n + 1) as usize;
(elms, Some(elms))
} else {
(0, None)
}
}
}
impl IntoIterator for &'_ Ipv4Network {
type IntoIter = Ipv4NetworkIterator;
type Item = Ipv4Addr;
fn into_iter(self) -> Ipv4NetworkIterator {
self.iter()
}
}
/// Converts a `Ipv4Addr` network mask into a prefix.
///
/// If the mask is invalid this will return an `IpNetworkError::InvalidPrefix`.
pub fn ipv4_mask_to_prefix(mask: Ipv4Addr) -> Result<u8, IpNetworkError> {
match ipv4_mask_to_prefix_checked(mask) {
Some(prefix) => Ok(prefix),
None => Err(IpNetworkError::InvalidPrefix),
}
}
/// Converts a `Ipv4Addr` network mask into a prefix.
///
/// If the mask is invalid this will return `None`. This is useful in const contexts where
/// [`Option::unwrap`] may be called to trigger a compile-time error if the prefix is invalid.
pub const fn ipv4_mask_to_prefix_checked(mask: Ipv4Addr) -> Option<u8> {
let mask = mask.to_bits();
let prefix = (!mask).leading_zeros() as u8;
if ((mask as u64) << prefix) & 0xffff_ffff != 0 {
None
} else {
Some(prefix)
}
}
#[cfg(test)]
mod test {
use super::*;
use std::collections::HashMap;
use std::mem;
use std::net::Ipv4Addr;
#[test]
fn create_v4() {
let cidr = Ipv4Network::new(Ipv4Addr::new(77, 88, 21, 11), 24).unwrap();
assert_eq!(cidr.prefix(), 24);
}
#[test]
fn create_v4_invalid_prefix() {
let net = Ipv4Network::new(Ipv4Addr::new(0, 0, 0, 0), 33);
assert!(net.is_err());
}
#[test]
fn create_checked_v4() {
let cidr = Ipv4Network::new_checked(Ipv4Addr::new(77, 88, 21, 11), 24).unwrap();
assert_eq!(cidr.prefix(), 24);
}
#[test]
#[should_panic]
fn try_create_invalid_checked_v4() {
Ipv4Network::new_checked(Ipv4Addr::new(0, 0, 0, 0), 33).unwrap();
}
#[test]
fn parse_v4_24bit() {
let cidr: Ipv4Network = "127.1.0.0/24".parse().unwrap();
assert_eq!(cidr.ip(), Ipv4Addr::new(127, 1, 0, 0));
assert_eq!(cidr.prefix(), 24);
}
#[test]
fn parse_v4_32bit() {
let cidr: Ipv4Network = "127.0.0.0/32".parse().unwrap();
assert_eq!(cidr.ip(), Ipv4Addr::new(127, 0, 0, 0));
assert_eq!(cidr.prefix(), 32);
}
#[test]
fn parse_v4_noprefix() {
let cidr: Ipv4Network = "127.0.0.0".parse().unwrap();
assert_eq!(cidr.ip(), Ipv4Addr::new(127, 0, 0, 0));
assert_eq!(cidr.prefix(), 32);
}
#[test]
fn parse_v4_fail_addr() {
let cidr: Option<Ipv4Network> = "10.a.b/8".parse().ok();
assert_eq!(None, cidr);
}
#[test]
fn parse_v4_fail_addr2() {
let cidr: Option<Ipv4Network> = "10.1.1.1.0/8".parse().ok();
assert_eq!(None, cidr);
}
#[test]
fn parse_v4_fail_addr3() {
let cidr: Option<Ipv4Network> = "256/8".parse().ok();
assert_eq!(None, cidr);
}
#[test]
fn parse_v4_non_zero_host_bits() {
let cidr: Ipv4Network = "10.1.1.1/24".parse().unwrap();
assert_eq!(cidr.ip(), Ipv4Addr::new(10, 1, 1, 1));
assert_eq!(cidr.prefix(), 24);
}
#[test]
fn parse_v4_fail_prefix() {
let cidr: Option<Ipv4Network> = "0/39".parse().ok();
assert_eq!(None, cidr);
}
#[test]
fn parse_v4_fail_two_slashes() {
let cidr: Option<Ipv4Network> = "10.1.1.1/24/".parse().ok();
assert_eq!(None, cidr);
}
#[test]
fn nth_v4() {
let net = Ipv4Network::new(Ipv4Addr::new(127, 0, 0, 0), 24).unwrap();
assert_eq!(net.nth(0).unwrap(), Ipv4Addr::new(127, 0, 0, 0));
assert_eq!(net.nth(1).unwrap(), Ipv4Addr::new(127, 0, 0, 1));
assert_eq!(net.nth(255).unwrap(), Ipv4Addr::new(127, 0, 0, 255));
assert!(net.nth(256).is_none());
}
#[test]
fn nth_v4_fail() {
let net = Ipv4Network::new(Ipv4Addr::new(10, 0, 0, 0), 32).unwrap();
assert!(net.nth(1).is_none());
}
#[test]
fn hash_eq_compatibility_v4() {
let mut map = HashMap::new();
let net = Ipv4Network::new(Ipv4Addr::new(127, 0, 0, 1), 16).unwrap();
map.insert(net, 137);
assert_eq!(137, map[&net]);
}
#[test]
#[allow(dropping_copy_types)]
fn copy_compatibility_v4() {
let net = Ipv4Network::new(Ipv4Addr::new(127, 0, 0, 1), 16).unwrap();
mem::drop(net);
assert_eq!(16, net.prefix());
}
#[test]
fn mask_v4() {
let cidr = Ipv4Network::new(Ipv4Addr::new(74, 125, 227, 0), 29).unwrap();
let mask = cidr.mask();
assert_eq!(mask, Ipv4Addr::new(255, 255, 255, 248));
}
#[test]
fn network_v4() {
let cidr = Ipv4Network::new(Ipv4Addr::new(10, 10, 1, 97), 23).unwrap();
let net = cidr.network();
assert_eq!(net, Ipv4Addr::new(10, 10, 0, 0));
}
#[test]
fn broadcast_v4() {
let cidr = Ipv4Network::new(Ipv4Addr::new(10, 10, 1, 97), 23).unwrap();
let bcast = cidr.broadcast();
assert_eq!(bcast, Ipv4Addr::new(10, 10, 1, 255));
}
#[test]
fn contains_v4() {
let cidr = Ipv4Network::new(Ipv4Addr::new(74, 125, 227, 0), 25).unwrap();
let ip = Ipv4Addr::new(74, 125, 227, 4);
assert!(cidr.contains(ip));
}
#[test]
fn not_contains_v4() {
let cidr = Ipv4Network::new(Ipv4Addr::new(10, 0, 0, 50), 24).unwrap();
let ip = Ipv4Addr::new(10, 1, 0, 1);
assert!(!cidr.contains(ip));
}
#[test]
fn iterator_v4() {
let cidr: Ipv4Network = "192.168.122.0/30".parse().unwrap();
let mut iter = cidr.iter();
assert_eq!(Ipv4Addr::new(192, 168, 122, 0), iter.next().unwrap());
assert_eq!(Ipv4Addr::new(192, 168, 122, 1), iter.next().unwrap());
assert_eq!(Ipv4Addr::new(192, 168, 122, 2), iter.next().unwrap());
assert_eq!(Ipv4Addr::new(192, 168, 122, 3), iter.next().unwrap());
assert_eq!(None, iter.next());
}
// Tests the entire IPv4 space to see if the iterator will stop at the correct place
// and not overflow or wrap around. Ignored since it takes a long time to run.
#[test]
#[ignore]
fn iterator_v4_huge() {
let cidr: Ipv4Network = "0/0".parse().unwrap();
let mut iter = cidr.iter();
for i in 0..(u32::MAX as u64 + 1) {
assert_eq!(i as u32, u32::from(iter.next().unwrap()));
}
assert_eq!(None, iter.next());
}
#[test]
fn iterator_v4_size_hint() {
let cidr: Ipv4Network = "192.168.0.0/24".parse().unwrap();
let mut iter = cidr.iter();
assert_eq!((256, Some(256)), iter.size_hint());
iter.next();
assert_eq!((255, Some(255)), iter.size_hint());
let cidr: Ipv4Network = "192.168.0.0/32".parse().unwrap();
let mut iter = cidr.iter();
assert_eq!((1, Some(1)), iter.size_hint());
iter.next();
assert_eq!((0, None), iter.size_hint());
let cidr: Ipv4Network = "192.168.0.0/0".parse().unwrap();
let iter = cidr.iter();
assert_eq!((4294967295, Some(4294967295)), iter.size_hint());
}
#[test]
fn v4_mask_to_prefix() {
let mask = Ipv4Addr::new(255, 255, 255, 128);
let prefix = ipv4_mask_to_prefix(mask).unwrap();
assert_eq!(prefix, 25);
}
/// Parse netmask as well as prefix
#[test]
fn parse_netmask() {
let from_netmask: Ipv4Network = "192.168.1.0/255.255.255.0".parse().unwrap();
let from_prefix: Ipv4Network = "192.168.1.0/24".parse().unwrap();
assert_eq!(from_netmask, from_prefix);
}
#[test]
fn parse_netmask_broken_v4() {
assert_eq!(
"192.168.1.0/255.0.255.0".parse::<Ipv4Network>(),
Err(IpNetworkError::InvalidPrefix)
);
}
#[test]
fn invalid_v4_mask_to_prefix() {
let mask = Ipv4Addr::new(255, 0, 255, 0);
let prefix = ipv4_mask_to_prefix(mask);
assert!(prefix.is_err());
}
#[test]
fn ipv4network_with_netmask() {
{
// Positive test-case.
let addr = Ipv4Addr::new(127, 0, 0, 1);
let mask = Ipv4Addr::new(255, 0, 0, 0);
let net = Ipv4Network::with_netmask(addr, mask).unwrap();
let expected = Ipv4Network::new(Ipv4Addr::new(127, 0, 0, 1), 8).unwrap();
assert_eq!(net, expected);
}
{
// Negative test-case.
let addr = Ipv4Addr::new(127, 0, 0, 1);
let mask = Ipv4Addr::new(255, 0, 255, 0);
Ipv4Network::with_netmask(addr, mask).unwrap_err();
}
}
#[test]
fn ipv4network_from_ipv4addr() {
let net = Ipv4Network::from(Ipv4Addr::new(127, 0, 0, 1));
let expected = Ipv4Network::new(Ipv4Addr::new(127, 0, 0, 1), 32).unwrap();
assert_eq!(net, expected);
}
#[test]
fn test_send() {
fn assert_send<T: Send>() {}
assert_send::<Ipv4Network>();
}
#[test]
fn test_sync() {
fn assert_sync<T: Sync>() {}
assert_sync::<Ipv4Network>();
}
// Tests from cpython https://github.com/python/cpython/blob/e9bc4172d18db9c182d8e04dd7b033097a994c06/Lib/test/test_ipaddress.py
#[test]
fn test_is_subnet_of() {
let mut test_cases: HashMap<(Ipv4Network, Ipv4Network), bool> = HashMap::new();
test_cases.insert(
(
"10.0.0.0/30".parse().unwrap(),
"10.0.1.0/24".parse().unwrap(),
),
false,
);
test_cases.insert(
(
"10.0.0.0/30".parse().unwrap(),
"10.0.0.0/24".parse().unwrap(),
),
true,
);
test_cases.insert(
(
"10.0.0.0/30".parse().unwrap(),
"10.0.1.0/24".parse().unwrap(),
),
false,
);
test_cases.insert(
(
"10.0.1.0/24".parse().unwrap(),
"10.0.0.0/30".parse().unwrap(),
),
false,
);
for (key, val) in test_cases.iter() {
let (src, dest) = (key.0, key.1);
assert_eq!(
src.is_subnet_of(dest),
*val,
"testing with {src} and {dest}"
);
}
}
#[test]
fn test_is_supernet_of() {
let mut test_cases: HashMap<(Ipv4Network, Ipv4Network), bool> = HashMap::new();
test_cases.insert(
(
"10.0.0.0/30".parse().unwrap(),
"10.0.1.0/24".parse().unwrap(),
),
false,
);
test_cases.insert(
(
"10.0.0.0/30".parse().unwrap(),
"10.0.0.0/24".parse().unwrap(),
),
false,
);
test_cases.insert(
(
"10.0.0.0/30".parse().unwrap(),
"10.0.1.0/24".parse().unwrap(),
),
false,
);
test_cases.insert(
(
"10.0.0.0/24".parse().unwrap(),
"10.0.0.0/30".parse().unwrap(),
),
true,
);
for (key, val) in test_cases.iter() {
let (src, dest) = (key.0, key.1);
assert_eq!(
src.is_supernet_of(dest),
*val,
"testing with {src} and {dest}"
);
}
}
#[test]
fn test_overlaps() {
let other: Ipv4Network = "1.2.3.0/30".parse().unwrap();
let other2: Ipv4Network = "1.2.2.0/24".parse().unwrap();
let other3: Ipv4Network = "1.2.2.64/26".parse().unwrap();
let skynet: Ipv4Network = "1.2.3.0/24".parse().unwrap();
assert!(skynet.overlaps(other));
assert!(!skynet.overlaps(other2));
assert!(other2.overlaps(other3));
}
#[test]
fn edges() {
let low: Ipv4Network = "0.0.0.0/24".parse().unwrap();
let low_addrs: Vec<Ipv4Addr> = low.iter().collect();
assert_eq!(256, low_addrs.len());
assert_eq!("0.0.0.0".parse::<Ipv4Addr>().unwrap(), low_addrs[0]);
assert_eq!("0.0.0.255".parse::<Ipv4Addr>().unwrap(), low_addrs[255]);
let high: Ipv4Network = "255.255.255.0/24".parse().unwrap();
let high_addrs: Vec<Ipv4Addr> = high.iter().collect();
assert_eq!(256, high_addrs.len());
assert_eq!("255.255.255.0".parse::<Ipv4Addr>().unwrap(), high_addrs[0]);
assert_eq!(
"255.255.255.255".parse::<Ipv4Addr>().unwrap(),
high_addrs[255]
);
}
}
| rust | Apache-2.0 | f01575cbf2fc596c0a1761c122aa92525cbb7974 | 2026-01-04T20:19:08.816812Z | false |
achanda/ipnetwork | https://github.com/achanda/ipnetwork/blob/f01575cbf2fc596c0a1761c122aa92525cbb7974/src/error.rs | src/error.rs | use std::{error::Error, fmt, net::AddrParseError};
use crate::error::IpNetworkError::*;
/// Represents a bunch of errors that can occur while working with a `IpNetwork`
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum IpNetworkError {
InvalidAddr(String),
InvalidPrefix,
InvalidCidrFormat(String),
NetworkSizeError(NetworkSizeError),
}
impl fmt::Display for IpNetworkError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
InvalidAddr(ref s) => write!(f, "invalid address: {s}"),
InvalidPrefix => write!(f, "invalid prefix"),
InvalidCidrFormat(ref s) => write!(f, "invalid cidr format: {s}"),
NetworkSizeError(ref e) => write!(f, "network size error: {e}"),
}
}
}
impl Error for IpNetworkError {
fn description(&self) -> &str {
match *self {
InvalidAddr(_) => "address is invalid",
InvalidPrefix => "prefix is invalid",
InvalidCidrFormat(_) => "cidr is invalid",
NetworkSizeError(_) => "network size error",
}
}
}
impl From<AddrParseError> for IpNetworkError {
fn from(e: AddrParseError) -> Self {
InvalidAddr(e.to_string())
}
}
/// Cannot convert an IPv6 network size to a u32 as it is a 128-bit value.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum NetworkSizeError {
NetworkIsTooLarge,
}
impl fmt::Display for NetworkSizeError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("Network is too large to fit into an unsigned 32-bit integer!")
}
}
impl Error for NetworkSizeError {}
| rust | Apache-2.0 | f01575cbf2fc596c0a1761c122aa92525cbb7974 | 2026-01-04T20:19:08.816812Z | false |
achanda/ipnetwork | https://github.com/achanda/ipnetwork/blob/f01575cbf2fc596c0a1761c122aa92525cbb7974/src/ipv6.rs | src/ipv6.rs | use crate::error::IpNetworkError;
use crate::parse::{cidr_parts, parse_prefix};
use std::{convert::TryFrom, fmt, net::Ipv6Addr, str::FromStr};
const IPV6_BITS: u8 = 128;
const IPV6_SEGMENT_BITS: u8 = 16;
/// Represents a network range where the IP addresses are of v6
#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct Ipv6Network {
addr: Ipv6Addr,
prefix: u8,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Ipv6Network {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = <String>::deserialize(deserializer)?;
Ipv6Network::from_str(&s).map_err(serde::de::Error::custom)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for Ipv6Network {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.collect_str(self)
}
}
#[cfg(feature = "schemars")]
impl schemars::JsonSchema for Ipv6Network {
fn schema_name() -> std::borrow::Cow<'static, str> {
std::borrow::Cow::Borrowed("Ipv6Network")
}
fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
schemars::json_schema!({
"type": "string",
"pattern": concat!(
r#"^("#,
r#"([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}"#,
r#"|([0-9a-fA-F]{1,4}:){1,7}:"#,
r#"|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}"#,
r#"|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}"#,
r#"|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}"#,
r#"|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}"#,
r#"|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}"#,
r#"|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})"#,
r#"|:((:[0-9a-fA-F]{1,4}){1,7}|:)"#,
r#"|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}"#,
r#"|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])"#,
r#"|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])"#,
r#"")[/](12[0-8]|1[0-1][0-9]|[0-9]?[0-9])$"#,
),
"x-rust-type": "ipnetwork::Ipv6Network"
})
}
}
impl Ipv6Network {
/// Constructs a new `Ipv6Network` from any `Ipv6Addr` and a prefix denoting the network size.
///
/// If the prefix is larger than 128 this will return an `IpNetworkError::InvalidPrefix`.
pub const fn new(addr: Ipv6Addr, prefix: u8) -> Result<Ipv6Network, IpNetworkError> {
match Ipv6Network::new_checked(addr, prefix) {
Some(a) => Ok(a),
None => Err(IpNetworkError::InvalidPrefix),
}
}
/// Constructs a new `Ipv6Network` from any `Ipv6Addr`, and a prefix denoting the network size.
///
/// If the prefix is larger than 128 this will return `None`. This is useful in const contexts,
/// where [`Option::unwrap`] may be called to trigger a compile-time error in case the prefix
/// is an unexpected value.
///
/// # Examples
///
/// ```
/// use std::net::Ipv6Addr;
/// use ipnetwork::Ipv6Network;
///
/// const PREFIX: u8 = 64;
/// const ADDR: Ipv6Addr = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);
///
/// // Okay!
/// const NETWORK: Ipv6Network = Ipv6Network::new_checked(ADDR, PREFIX).unwrap();
/// assert_eq!(NETWORK.prefix(), PREFIX);
/// ```
///
/// ```should_panic
/// use std::net::Ipv6Addr;
/// use ipnetwork::Ipv6Network;
///
/// // Prefix is greater than 128.
/// const PREFIX: u8 = 128 + 1;
/// const ADDR: Ipv6Addr = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);
///
/// // This fails!
/// const NETWORK: Option<Ipv6Network> = Ipv6Network::new_checked(ADDR, PREFIX);
/// assert_eq!(NETWORK.unwrap().prefix(), PREFIX);
/// ```
pub const fn new_checked(addr: Ipv6Addr, prefix: u8) -> Option<Ipv6Network> {
if prefix > IPV6_BITS {
None
} else {
Some(Ipv6Network { addr, prefix })
}
}
/// Constructs a new `Ipv6Network` from a network address and a network mask.
///
/// If the netmask is not valid this will return an `IpNetworkError::InvalidPrefix`.
pub fn with_netmask(netaddr: Ipv6Addr, netmask: Ipv6Addr) -> Result<Self, IpNetworkError> {
let prefix = ipv6_mask_to_prefix(netmask)?;
let net = Self {
addr: netaddr,
prefix,
};
Ok(net)
}
/// Returns an iterator over `Ipv6Network`. Each call to `next` will return the next
/// `Ipv6Addr` in the given network. `None` will be returned when there are no more
/// addresses.
///
/// # Warning
///
/// This can return up to 2^128 addresses, which will take a _long_ time to iterate over.
pub fn iter(&self) -> Ipv6NetworkIterator {
let dec = u128::from(self.addr);
let max = u128::MAX;
let prefix = self.prefix;
let mask = max.checked_shl(u32::from(IPV6_BITS - prefix)).unwrap_or(0);
let start: u128 = dec & mask;
let mask = max.checked_shr(u32::from(prefix)).unwrap_or(0);
let end: u128 = dec | mask;
Ipv6NetworkIterator {
next: Some(start),
end,
}
}
pub const fn ip(&self) -> Ipv6Addr {
self.addr
}
pub const fn prefix(&self) -> u8 {
self.prefix
}
/// Checks if the given `Ipv6Network` is a subnet of the other.
pub fn is_subnet_of(self, other: Ipv6Network) -> bool {
other.ip() <= self.ip() && other.broadcast() >= self.broadcast()
}
/// Checks if the given `Ipv6Network` is a supernet of the other.
pub fn is_supernet_of(self, other: Ipv6Network) -> bool {
other.is_subnet_of(self)
}
/// Checks if the given `Ipv6Network` is partly contained in other.
pub fn overlaps(self, other: Ipv6Network) -> bool {
other.contains(self.ip())
|| other.contains(self.broadcast())
|| self.contains(other.ip())
|| self.contains(other.broadcast())
}
/// Returns the mask for this `Ipv6Network`.
/// That means the `prefix` most significant bits will be 1 and the rest 0
///
/// # Examples
///
/// ```
/// use std::net::Ipv6Addr;
/// use ipnetwork::Ipv6Network;
///
/// let net: Ipv6Network = "ff01::0".parse().unwrap();
/// assert_eq!(net.mask(), Ipv6Addr::new(0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff));
/// let net: Ipv6Network = "ff01::0/32".parse().unwrap();
/// assert_eq!(net.mask(), Ipv6Addr::new(0xffff, 0xffff, 0, 0, 0, 0, 0, 0));
/// ```
pub const fn mask(&self) -> Ipv6Addr {
debug_assert!(self.prefix <= IPV6_BITS);
if self.prefix == 0 {
return Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0);
}
let mask = u128::MAX << (IPV6_BITS - self.prefix);
Ipv6Addr::from_bits(mask)
}
/// Returns the address of the network denoted by this `Ipv6Network`.
/// This means the lowest possible IPv6 address inside of the network.
///
/// # Examples
///
/// ```
/// use std::net::Ipv6Addr;
/// use ipnetwork::Ipv6Network;
///
/// let net: Ipv6Network = "2001:db8::/96".parse().unwrap();
/// assert_eq!(net.network(), Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0));
/// ```
pub const fn network(&self) -> Ipv6Addr {
let mask = self.mask().to_bits();
let network = self.addr.to_bits() & mask;
Ipv6Addr::from_bits(network)
}
/// Returns the broadcast address of this `Ipv6Network`.
/// This means the highest possible IPv4 address inside of the network.
///
/// # Examples
///
/// ```
/// use std::net::Ipv6Addr;
/// use ipnetwork::Ipv6Network;
///
/// let net: Ipv6Network = "2001:db8::/96".parse().unwrap();
/// assert_eq!(net.broadcast(), Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0xffff, 0xffff));
/// ```
pub const fn broadcast(&self) -> Ipv6Addr {
let mask = self.mask().to_bits();
let broadcast = self.addr.to_bits() | !mask;
Ipv6Addr::from_bits(broadcast)
}
/// Checks if a given `Ipv6Addr` is in this `Ipv6Network`
///
/// # Examples
///
/// ```
/// use std::net::Ipv6Addr;
/// use ipnetwork::Ipv6Network;
///
/// let net: Ipv6Network = "ff01::0/32".parse().unwrap();
/// assert!(net.contains(Ipv6Addr::new(0xff01, 0, 0, 0, 0, 0, 0, 0x1)));
/// assert!(!net.contains(Ipv6Addr::new(0xffff, 0, 0, 0, 0, 0, 0, 0x1)));
/// ```
#[inline]
pub const fn contains(&self, ip: Ipv6Addr) -> bool {
let ip = ip.to_bits();
let net = self.network().to_bits();
let mask = self.mask().to_bits();
(ip & mask) == net
}
/// Returns number of possible host addresses in this `Ipv6Network`.
///
/// # Examples
///
/// ```
/// use std::net::Ipv6Addr;
/// use ipnetwork::Ipv6Network;
///
/// let net: Ipv6Network = "ff01::0/32".parse().unwrap();
/// assert_eq!(net.size(), 79228162514264337593543950336);
///
/// let tinynet: Ipv6Network = "ff01::0/128".parse().unwrap();
/// assert_eq!(tinynet.size(), 1);
/// ```
pub fn size(&self) -> u128 {
debug_assert!(self.prefix <= IPV6_BITS);
if self.prefix == 0 {
return u128::MAX;
}
1 << (IPV6_BITS - self.prefix)
}
/// Returns the `n`:th address within this network.
/// The addresses are indexed from 0 and `n` must be smaller than the size of the network.
///
/// # Examples
///
/// ```
/// use std::net::Ipv6Addr;
/// use ipnetwork::Ipv6Network;
///
/// let net: Ipv6Network = "ff01::0/32".parse().unwrap();
/// assert_eq!(net.nth(0).unwrap(), "ff01::0".parse::<Ipv6Addr>().unwrap());
/// assert_eq!(net.nth(255).unwrap(), "ff01::ff".parse::<Ipv6Addr>().unwrap());
/// assert_eq!(net.nth(65538).unwrap(), "ff01::1:2".parse::<Ipv6Addr>().unwrap());
/// assert!(net.nth(net.size()).is_none());
/// ```
pub fn nth(self, n: u128) -> Option<Ipv6Addr> {
if n < self.size() {
let net = u128::from(self.network());
Some(Ipv6Addr::from(net + n))
} else {
None
}
}
}
/// Creates an `Ipv6Network` from parsing a string in CIDR notation.
///
/// # Examples
///
/// ```
/// use std::net::Ipv6Addr;
/// use ipnetwork::Ipv6Network;
///
/// let new = Ipv6Network::new(Ipv6Addr::new(0xff01, 0, 0, 0x17, 0, 0, 0, 0x2), 65).unwrap();
/// let from_cidr: Ipv6Network = "FF01:0:0:17:0:0:0:2/65".parse().unwrap();
/// assert_eq!(new.ip(), from_cidr.ip());
/// assert_eq!(new.prefix(), from_cidr.prefix());
/// ```
impl FromStr for Ipv6Network {
type Err = IpNetworkError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let (addr_str, prefix_str) = cidr_parts(s)?;
let addr = Ipv6Addr::from_str(addr_str)?;
let prefix = parse_prefix(prefix_str.unwrap_or(&IPV6_BITS.to_string()), IPV6_BITS)?;
Ipv6Network::new(addr, prefix)
}
}
impl TryFrom<&str> for Ipv6Network {
type Error = IpNetworkError;
fn try_from(s: &str) -> Result<Self, Self::Error> {
Ipv6Network::from_str(s)
}
}
impl From<Ipv6Addr> for Ipv6Network {
fn from(a: Ipv6Addr) -> Ipv6Network {
Ipv6Network {
addr: a,
prefix: 128,
}
}
}
#[derive(Clone, Debug)]
pub struct Ipv6NetworkIterator {
next: Option<u128>,
end: u128,
}
impl Iterator for Ipv6NetworkIterator {
type Item = Ipv6Addr;
fn next(&mut self) -> Option<Ipv6Addr> {
let next = self.next?;
self.next = if next == self.end {
None
} else {
Some(next + 1)
};
Some(next.into())
}
fn size_hint(&self) -> (usize, Option<usize>) {
if let Some(n) = self.next {
let elms = (self.end - n + 1) as usize;
(elms, Some(elms))
} else {
(0, None)
}
}
}
impl IntoIterator for &'_ Ipv6Network {
type IntoIter = Ipv6NetworkIterator;
type Item = Ipv6Addr;
fn into_iter(self) -> Ipv6NetworkIterator {
self.iter()
}
}
impl fmt::Display for Ipv6Network {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(fmt, "{}/{}", self.ip(), self.prefix())
}
}
/// Converts a `Ipv6Addr` network mask into a prefix.
/// If the mask is invalid this will return an `IpNetworkError::InvalidPrefix`.
pub fn ipv6_mask_to_prefix(mask: Ipv6Addr) -> Result<u8, IpNetworkError> {
match ipv6_mask_to_prefix_checked(mask) {
Some(prefix) => Ok(prefix),
None => Err(IpNetworkError::InvalidPrefix),
}
}
/// Converts a `Ipv6Addr` network mask into a prefix.
///
/// If the mask is invalid this will return `None`. This is useful in const contexts where
/// [`Option::unwrap`] may be called to trigger a compile-time error if the prefix is invalid.
pub const fn ipv6_mask_to_prefix_checked(mask: Ipv6Addr) -> Option<u8> {
let mask = mask.segments();
// Count the number of set bits from the start of the address
let mut prefix = 0;
let mut i = 0;
while i < mask.len() {
let segment = mask[i];
i += 1;
if segment == 0xffff {
prefix += IPV6_SEGMENT_BITS;
} else if segment == 0 {
// Prefix finishes on a segment boundary
break;
} else {
let prefix_bits = (!segment).leading_zeros() as u8;
// Check that the remainder of the bits are all unset
if segment << prefix_bits != 0 {
return None;
}
prefix += prefix_bits;
break;
}
}
// Now check all the remaining bits are unset
while i < mask.len() {
let segment = mask[i];
i += 1;
if segment != 0 {
return None;
}
}
Some(prefix)
}
#[cfg(test)]
mod test {
use super::*;
use std::collections::HashMap;
use std::net::Ipv6Addr;
#[test]
fn create_v6() {
let cidr = Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 24).unwrap();
assert_eq!(cidr.prefix(), 24);
}
#[test]
fn parse_netmask_broken_v6() {
assert_eq!(
"FF01:0:0:17:0:0:0:2/255.255.255.0".parse::<Ipv6Network>(),
Err(IpNetworkError::InvalidPrefix)
);
}
#[test]
fn create_v6_invalid_prefix() {
let cidr = Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 129);
assert!(cidr.is_err());
}
#[test]
fn create_checked_v6() {
let cidr = Ipv6Network::new_checked(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 24).unwrap();
assert_eq!(cidr.prefix(), 24);
}
#[test]
#[should_panic]
fn try_create_invalid_checked_v6() {
Ipv6Network::new_checked(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 129).unwrap();
}
#[test]
fn parse_v6() {
let cidr: Ipv6Network = "::1/0".parse().unwrap();
assert_eq!(cidr.ip(), Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));
assert_eq!(cidr.prefix(), 0);
}
#[test]
fn parse_v6_2() {
let cidr: Ipv6Network = "FF01:0:0:17:0:0:0:2/64".parse().unwrap();
assert_eq!(cidr.ip(), Ipv6Addr::new(0xff01, 0, 0, 0x17, 0, 0, 0, 0x2));
assert_eq!(cidr.prefix(), 64);
}
#[test]
fn parse_v6_noprefix() {
let cidr: Ipv6Network = "::1".parse().unwrap();
assert_eq!(cidr.ip(), Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));
assert_eq!(cidr.prefix(), 128);
}
#[test]
fn parse_v6_fail_addr() {
let cidr: Option<Ipv6Network> = "2001::1::/8".parse().ok();
assert_eq!(None, cidr);
}
#[test]
fn parse_v6_fail_prefix() {
let cidr: Option<Ipv6Network> = "::1/129".parse().ok();
assert_eq!(None, cidr);
}
#[test]
fn parse_v6_fail_two_slashes() {
let cidr: Option<Ipv6Network> = "::1/24/".parse().ok();
assert_eq!(None, cidr);
}
#[test]
fn mask_v6() {
let cidr = Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0), 40).unwrap();
let mask = cidr.mask();
assert_eq!(mask, Ipv6Addr::new(0xffff, 0xffff, 0xff00, 0, 0, 0, 0, 0));
}
#[test]
fn contains_v6() {
let cidr = Ipv6Network::new(Ipv6Addr::new(0xff01, 0, 0, 0x17, 0, 0, 0, 0x2), 65).unwrap();
let ip = Ipv6Addr::new(0xff01, 0, 0, 0x17, 0x7fff, 0, 0, 0x2);
assert!(cidr.contains(ip));
}
#[test]
fn not_contains_v6() {
let cidr = Ipv6Network::new(Ipv6Addr::new(0xff01, 0, 0, 0x17, 0, 0, 0, 0x2), 65).unwrap();
let ip = Ipv6Addr::new(0xff01, 0, 0, 0x17, 0xffff, 0, 0, 0x2);
assert!(!cidr.contains(ip));
}
#[test]
fn v6_mask_to_prefix() {
let mask = Ipv6Addr::new(0xffff, 0xffff, 0xffff, 0, 0, 0, 0, 0);
let prefix = ipv6_mask_to_prefix(mask).unwrap();
assert_eq!(prefix, 48);
}
#[test]
fn invalid_v6_mask_to_prefix() {
let mask = Ipv6Addr::new(0, 0, 0xffff, 0xffff, 0, 0, 0, 0);
let prefix = ipv6_mask_to_prefix(mask);
assert!(prefix.is_err());
}
#[test]
fn ipv6network_with_netmask() {
{
// Positive test-case.
let addr = Ipv6Addr::new(0xff01, 0, 0, 0x17, 0, 0, 0, 0x2);
let mask = Ipv6Addr::new(0xffff, 0xffff, 0xffff, 0, 0, 0, 0, 0);
let net = Ipv6Network::with_netmask(addr, mask).unwrap();
let expected =
Ipv6Network::new(Ipv6Addr::new(0xff01, 0, 0, 0x17, 0, 0, 0, 0x2), 48).unwrap();
assert_eq!(net, expected);
}
{
// Negative test-case.
let addr = Ipv6Addr::new(0xff01, 0, 0, 0x17, 0, 0, 0, 0x2);
let mask = Ipv6Addr::new(0, 0, 0xffff, 0xffff, 0, 0, 0, 0);
Ipv6Network::with_netmask(addr, mask).unwrap_err();
}
}
#[test]
fn iterator_v6() {
let cidr: Ipv6Network = "2001:db8::/126".parse().unwrap();
let mut iter = cidr.iter();
assert_eq!(
Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0),
iter.next().unwrap()
);
assert_eq!(
Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1),
iter.next().unwrap()
);
assert_eq!(
Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 2),
iter.next().unwrap()
);
assert_eq!(
Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 3),
iter.next().unwrap()
);
assert_eq!(None, iter.next());
}
#[test]
fn iterator_v6_tiny() {
let cidr: Ipv6Network = "2001:db8::/128".parse().unwrap();
let mut iter = cidr.iter();
assert_eq!(
Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0),
iter.next().unwrap()
);
assert_eq!(None, iter.next());
}
#[test]
fn iterator_v6_huge() {
let cidr: Ipv6Network = "2001:db8::/0".parse().unwrap();
let mut iter = cidr.iter();
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0), iter.next().unwrap());
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), iter.next().unwrap());
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 2), iter.next().unwrap());
}
#[test]
fn iterator_v6_size_hint() {
let cidr: Ipv6Network = "2001:db8::/128".parse().unwrap();
let mut iter = cidr.iter();
assert_eq!((1, Some(1)), iter.size_hint());
assert_eq!(
Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0),
iter.next().unwrap()
);
assert_eq!((0, None), iter.size_hint());
}
#[test]
fn network_v6() {
let cidr: Ipv6Network = "2001:db8::0/96".parse().unwrap();
let net = cidr.network();
let expected: Ipv6Addr = "2001:db8::".parse().unwrap();
assert_eq!(net, expected);
}
#[test]
fn broadcast_v6() {
let cidr: Ipv6Network = "2001:db8::0/96".parse().unwrap();
let net = cidr.broadcast();
let expected: Ipv6Addr = "2001:db8::ffff:ffff".parse().unwrap();
assert_eq!(net, expected);
}
#[test]
fn size_v6() {
let cidr: Ipv6Network = "2001:db8::0/96".parse().unwrap();
assert_eq!(cidr.size(), 4294967296);
}
#[test]
fn ipv6network_from_ipv6addr() {
let net = Ipv6Network::from(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));
let expected = Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 128).unwrap();
assert_eq!(net, expected);
}
#[test]
fn test_send() {
fn assert_send<T: Send>() {}
assert_send::<Ipv6Network>();
}
#[test]
fn test_sync() {
fn assert_sync<T: Sync>() {}
assert_sync::<Ipv6Network>();
}
// Tests from cpython https://github.com/python/cpython/blob/e9bc4172d18db9c182d8e04dd7b033097a994c06/Lib/test/test_ipaddress.py
#[test]
fn test_is_subnet_of() {
let mut test_cases: HashMap<(Ipv6Network, Ipv6Network), bool> = HashMap::new();
test_cases.insert(
(
"2000:999::/56".parse().unwrap(),
"2000:aaa::/48".parse().unwrap(),
),
false,
);
test_cases.insert(
(
"2000:aaa::/56".parse().unwrap(),
"2000:aaa::/48".parse().unwrap(),
),
true,
);
test_cases.insert(
(
"2000:bbb::/56".parse().unwrap(),
"2000:aaa::/48".parse().unwrap(),
),
false,
);
test_cases.insert(
(
"2000:aaa::/48".parse().unwrap(),
"2000:aaa::/56".parse().unwrap(),
),
false,
);
for (key, val) in test_cases.iter() {
let (src, dest) = (key.0, key.1);
assert_eq!(
src.is_subnet_of(dest),
*val,
"testing with {src} and {dest}"
);
}
}
#[test]
fn test_is_supernet_of() {
let mut test_cases: HashMap<(Ipv6Network, Ipv6Network), bool> = HashMap::new();
test_cases.insert(
(
"2000:999::/56".parse().unwrap(),
"2000:aaa::/48".parse().unwrap(),
),
false,
);
test_cases.insert(
(
"2000:aaa::/56".parse().unwrap(),
"2000:aaa::/48".parse().unwrap(),
),
false,
);
test_cases.insert(
(
"2000:bbb::/56".parse().unwrap(),
"2000:aaa::/48".parse().unwrap(),
),
false,
);
test_cases.insert(
(
"2000:aaa::/48".parse().unwrap(),
"2000:aaa::/56".parse().unwrap(),
),
true,
);
for (key, val) in test_cases.iter() {
let (src, dest) = (key.0, key.1);
assert_eq!(
src.is_supernet_of(dest),
*val,
"testing with {src} and {dest}"
);
}
}
#[test]
fn test_overlaps() {
let other: Ipv6Network = "2001:DB8:ACAD::1/64".parse().unwrap();
let other2: Ipv6Network = "2001:DB8:ACAD::20:2/64".parse().unwrap();
assert!(other2.overlaps(other));
}
#[test]
fn edges() {
let low: Ipv6Network = "::0/120".parse().unwrap();
let low_addrs: Vec<Ipv6Addr> = low.iter().collect();
assert_eq!(256, low_addrs.len());
let high: Ipv6Network = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff00/120"
.parse()
.unwrap();
let high_addrs: Vec<Ipv6Addr> = high.iter().collect();
assert_eq!(256, high_addrs.len());
}
#[test]
fn test_nth_ipv6() {
let net = Ipv6Network::from_str("ff01::/32").unwrap();
assert_eq!(
net.nth(0).unwrap(),
Ipv6Addr::from_str("ff01:0:0:0:0:0:0:0").unwrap()
);
assert_eq!(
net.nth(255).unwrap(),
Ipv6Addr::from_str("ff01::ff").unwrap()
);
assert_eq!(
net.nth(65538).unwrap(),
Ipv6Addr::from_str("ff01::1:2").unwrap()
);
assert_eq!(net.nth(net.size()), None);
}
#[test]
fn test_mask_with_prefix_0() {
let network: Ipv6Network = "0::/0".parse().unwrap();
let mask = network.mask();
assert_eq!(mask, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0));
}
#[test]
fn test_size_with_prefix_0() {
let network: Ipv6Network = "0::/0".parse().unwrap();
assert_eq!(network.size(), u128::MAX);
}
}
| rust | Apache-2.0 | f01575cbf2fc596c0a1761c122aa92525cbb7974 | 2026-01-04T20:19:08.816812Z | false |
achanda/ipnetwork | https://github.com/achanda/ipnetwork/blob/f01575cbf2fc596c0a1761c122aa92525cbb7974/src/size.rs | src/size.rs | use std::{
cmp::Ordering,
fmt::Display,
hash::{Hash, Hasher},
};
use crate::error::NetworkSizeError;
use NetworkSize::*;
/// Represents a generic network size.
///
/// IPv4 network sizes are represented as `u32` values, while IPv6 network sizes are represented as `u128` values.
///
/// # Comparisons
///
/// Network sizes are compared by _value_, not by type.
///
/// ```
/// use ipnetwork::NetworkSize;
///
/// let ns1 = NetworkSize::V4(100);
/// let ns2 = NetworkSize::V6(100);
///
/// assert_eq!(ns1, ns2);
/// ```
#[derive(Debug, Clone, Copy)]
pub enum NetworkSize {
V4(u32),
V6(u128),
}
impl NetworkSize {
/// Returns the size of the network as a `u128`
fn as_u128(&self) -> u128 {
match *self {
V4(a) => a as u128,
V6(a) => a,
}
}
}
impl From<u32> for NetworkSize {
fn from(value: u32) -> Self {
V4(value)
}
}
impl From<u128> for NetworkSize {
fn from(value: u128) -> Self {
V6(value)
}
}
impl TryFrom<NetworkSize> for u32 {
type Error = NetworkSizeError;
fn try_from(value: NetworkSize) -> Result<Self, Self::Error> {
match value {
V4(a) => Ok(a),
V6(_) => Err(NetworkSizeError::NetworkIsTooLarge),
}
}
}
impl From<NetworkSize> for u128 {
fn from(val: NetworkSize) -> Self {
val.as_u128()
}
}
impl PartialEq for NetworkSize {
fn eq(&self, other: &Self) -> bool {
let a = self.as_u128();
let b = other.as_u128();
a == b
}
}
impl Eq for NetworkSize {}
impl Hash for NetworkSize {
fn hash<H: Hasher>(&self, state: &mut H) {
let a = self.as_u128();
a.hash(state);
}
}
impl Ord for NetworkSize {
fn cmp(&self, other: &Self) -> Ordering {
let a = self.as_u128();
let b = other.as_u128();
a.cmp(&b)
}
}
impl PartialOrd for NetworkSize {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl Display for NetworkSize {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.as_u128())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_from_u128() {
let value: u128 = 100;
let ns = NetworkSize::from(value);
assert_eq!(ns, V6(100));
}
#[test]
fn test_from_u32() {
let value: u32 = 100;
let ns = NetworkSize::from(value);
assert_eq!(ns, V4(100));
}
#[test]
fn test_try_into_u32() {
let value: u32 = 100;
let ns = V4(value);
let result: Result<u32, _> = ns.try_into();
assert!(result.is_ok());
assert_eq!(result.unwrap(), value);
}
#[test]
fn test_try_into_u32_error() {
let value: u128 = u32::MAX as u128 + 1;
let ns = V6(value);
let result: Result<u32, _> = ns.try_into();
assert!(result.is_err());
}
#[test]
fn test_into_u128() {
let value: u32 = 100;
let ns = V4(value);
let result: u128 = ns.into();
assert_eq!(result, value as u128);
}
#[test]
fn test_eq() {
let ns1 = V4(100);
let ns2 = V4(100);
assert_eq!(ns1, ns2);
let ns1 = V6(100);
let ns2 = V6(100);
assert_eq!(ns1, ns2);
let ns1 = V4(100);
let ns2 = V6(100);
assert_eq!(ns1, ns2);
}
#[test]
fn test_cmp() {
let ns1 = V4(100);
let ns2 = V4(200);
assert!(ns1 < ns2);
let ns1 = V6(200);
let ns2 = V6(100);
assert!(ns1 > ns2);
let ns1 = V4(100);
let ns2 = V6(200);
assert!(ns1 < ns2);
}
#[test]
fn test_display() {
let ns1 = V4(u32::MAX);
let ns2 = V6(ns1.into());
assert_eq!(ns1.to_string(), ns2.to_string());
}
// Verify that [`std::hash::Hash`] and [`std::cmp::PartialEq`] are consistent
#[test]
fn test_hash() {
let a = NetworkSize::V4(100);
let b = NetworkSize::V6(100);
// Calculate the hash of the two values
let mut hasher = std::hash::DefaultHasher::default();
a.hash(&mut hasher);
let hash_a = hasher.finish();
let mut hasher = std::hash::DefaultHasher::default();
b.hash(&mut hasher);
let hash_b = hasher.finish();
// a == b
assert_eq!(a, b);
// implies hash(a) == hash(b)
assert_eq!(hash_a, hash_b);
}
}
| rust | Apache-2.0 | f01575cbf2fc596c0a1761c122aa92525cbb7974 | 2026-01-04T20:19:08.816812Z | false |
achanda/ipnetwork | https://github.com/achanda/ipnetwork/blob/f01575cbf2fc596c0a1761c122aa92525cbb7974/tests/test_json.rs | tests/test_json.rs | #![cfg(feature = "serde")]
#[cfg(test)]
mod tests {
use ipnetwork::{IpNetwork, Ipv4Network, Ipv6Network};
use serde::{Deserialize, Serialize};
use std::net::{Ipv4Addr, Ipv6Addr};
#[test]
fn test_ipv4_json() {
let json_string = r#"{"ipnetwork":"127.1.0.0/24"}"#;
#[derive(Serialize, Deserialize)]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
struct MyStruct {
ipnetwork: Ipv4Network,
}
let mystruct: MyStruct = ::serde_json::from_str(json_string).unwrap();
assert_eq!(mystruct.ipnetwork.ip(), Ipv4Addr::new(127, 1, 0, 0));
assert_eq!(mystruct.ipnetwork.prefix(), 24);
assert_eq!(::serde_json::to_string(&mystruct).unwrap(), json_string);
#[cfg(feature = "schemars")]
{
// Validate that we can generate a schema and it contains expected properties
let schema = schemars::schema_for!(MyStruct);
let schema_value = serde_json::to_value(&schema).unwrap();
// Verify the schema has the expected structure
assert!(schema_value.get("properties").is_some());
assert!(schema_value["properties"].get("ipnetwork").is_some());
// Verify our struct can be serialized to JSON that matches the schema expectations
let json_value = serde_json::to_value(&mystruct).unwrap();
assert!(json_value.get("ipnetwork").is_some());
// For single IpNetwork values, the JSON value should be a string
assert!(json_value["ipnetwork"].is_string());
}
}
#[test]
fn test_ipv6_json() {
let json_string = r#"{"ipnetwork":"::1/0"}"#;
#[derive(Serialize, Deserialize)]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
struct MyStruct {
ipnetwork: Ipv6Network,
}
let mystruct: MyStruct = ::serde_json::from_str(json_string).unwrap();
assert_eq!(
mystruct.ipnetwork.ip(),
Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1)
);
assert_eq!(mystruct.ipnetwork.prefix(), 0);
assert_eq!(::serde_json::to_string(&mystruct).unwrap(), json_string);
#[cfg(feature = "schemars")]
{
// Validate that we can generate a schema and it contains expected properties
let schema = schemars::schema_for!(MyStruct);
let schema_value = serde_json::to_value(&schema).unwrap();
// Verify the schema has the expected structure
assert!(schema_value.get("properties").is_some());
assert!(schema_value["properties"].get("ipnetwork").is_some());
// Verify our struct can be serialized to JSON that matches the schema expectations
let json_value = serde_json::to_value(&mystruct).unwrap();
assert!(json_value.get("ipnetwork").is_some());
// For single IpNetwork values, the JSON value should be a string
assert!(json_value["ipnetwork"].is_string());
}
}
#[test]
fn test_ipnetwork_json() {
let json_string = r#"{"ipnetwork":["127.1.0.0/24","::1/0"]}"#;
#[derive(Serialize, Deserialize)]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
struct MyStruct {
ipnetwork: Vec<IpNetwork>,
}
let mystruct: MyStruct = ::serde_json::from_str(json_string).unwrap();
assert_eq!(mystruct.ipnetwork[0].ip(), Ipv4Addr::new(127, 1, 0, 0));
assert_eq!(mystruct.ipnetwork[0].prefix(), 24);
assert_eq!(
mystruct.ipnetwork[1].ip(),
Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1)
);
assert_eq!(mystruct.ipnetwork[1].prefix(), 0);
assert_eq!(::serde_json::to_string(&mystruct).unwrap(), json_string);
#[cfg(feature = "schemars")]
{
// Validate that we can generate a schema and it contains expected properties
let schema = schemars::schema_for!(MyStruct);
let schema_value = serde_json::to_value(&schema).unwrap();
// Verify the schema has the expected structure
assert!(schema_value.get("properties").is_some());
assert!(schema_value["properties"].get("ipnetwork").is_some());
// Verify our struct can be serialized to JSON that matches the schema expectations
let json_value = serde_json::to_value(&mystruct).unwrap();
assert!(json_value.get("ipnetwork").is_some());
// For Vec<IpNetwork>, the JSON value should be an array
assert!(json_value["ipnetwork"].is_array());
}
}
#[test]
fn test_ipnetwork_size_with_prefix_0() {
let network: Ipv4Network = "0.0.0.0/0".parse().unwrap();
let size = network.size();
assert_eq!(size, u32::MAX);
}
#[test]
#[cfg(feature = "schemars")]
fn test_schema_generation() {
// Test that we can generate schemas for all network types
let ipv4_schema = schemars::schema_for!(Ipv4Network);
let ipv6_schema = schemars::schema_for!(Ipv6Network);
let ip_schema = schemars::schema_for!(IpNetwork);
// Convert to JSON to verify structure
let ipv4_json = serde_json::to_value(&ipv4_schema).unwrap();
let ipv6_json = serde_json::to_value(&ipv6_schema).unwrap();
let ip_json = serde_json::to_value(&ip_schema).unwrap();
// Verify IPv4 schema has string type and pattern
assert_eq!(ipv4_json["type"], "string");
assert!(ipv4_json.get("pattern").is_some());
assert_eq!(ipv4_json["x-rust-type"], "ipnetwork::Ipv4Network");
// Verify IPv6 schema has string type and pattern
assert_eq!(ipv6_json["type"], "string");
assert!(ipv6_json.get("pattern").is_some());
assert_eq!(ipv6_json["x-rust-type"], "ipnetwork::Ipv6Network");
// Verify IpNetwork schema has oneOf structure
assert!(ip_json.get("oneOf").is_some());
assert_eq!(ip_json["x-rust-type"], "ipnetwork::IpNetwork");
let one_of = ip_json["oneOf"].as_array().unwrap();
assert_eq!(one_of.len(), 2);
assert_eq!(one_of[0]["title"], "v4");
assert_eq!(one_of[1]["title"], "v6");
// Verify that the schemas follow the schemars 1.0 migration guide patterns
// The Schema should be a wrapper around serde_json::Value
assert!(ipv4_json.is_object());
assert!(ipv6_json.is_object());
assert!(ip_json.is_object());
// Print schemas for manual verification (useful for debugging)
println!("IPv4 Schema: {}", serde_json::to_string_pretty(&ipv4_json).unwrap());
println!("IPv6 Schema: {}", serde_json::to_string_pretty(&ipv6_json).unwrap());
println!("IpNetwork Schema: {}", serde_json::to_string_pretty(&ip_json).unwrap());
}
}
| rust | Apache-2.0 | f01575cbf2fc596c0a1761c122aa92525cbb7974 | 2026-01-04T20:19:08.816812Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.