nl-wireguard 0.3.0

// SPDX-License-Identifier: MIT

//! This crate provides methods to manipulate wireguard link via the generic
//! netlink protocol.
//!
//! To query wireguard interface:
//!
//! ```no_run
//! async fn print_wireguard_config(
//!     iface_name: &str,
//! ) -> Result<(), Box<dyn std::error::Error>> {
//!     let (conn, mut handle, _) = nl_wireguard::new_connection()?;
//!     tokio::spawn(conn);
//!
//!     println!("{:?}", handle.get_by_name(iface_name).await?);
//!     Ok(())
//! }
//! ```
//!
//! To set wireguard configuration.
//! You need to use `rtnetlink` crate to create a interface with `wireguard`
//! interface type before.
//!
//! ```no_run
//! use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
//!
//! use nl_wireguard::{
//!     WireguardIpAddress, WireguardParsed, WireguardParsedDeviceFlags,
//!     WireguardParsedPeerFlags, WireguardPeerParsed,
//! };
//!
//! async fn set_wireguard_config(
//!     iface_name: &str,
//! ) -> Result<(), Box<dyn std::error::Error>> {
//!     let mut peer_config = WireguardPeerParsed::default();
//!     peer_config.endpoint = Some(SocketAddr::new(
//!         IpAddr::V4(Ipv4Addr::new(10, 10, 10, 1)),
//!         51820,
//!     ));
//!     peer_config.public_key =
//!         Some("8bdQrVLqiw3ZoHCucNh1YfH0iCWuyStniRr8t7H24Fk=".to_string());
//!     peer_config.allowed_ips = Some(vec![
//!         WireguardIpAddress {
//!             ip_addr: IpAddr::V4(Ipv4Addr::UNSPECIFIED),
//!             prefix_length: 0,
//!             flags: None,
//!         },
//!         WireguardIpAddress {
//!             ip_addr: IpAddr::V6(Ipv6Addr::UNSPECIFIED),
//!             prefix_length: 0,
//!             flags: None,
//!         },
//!     ]);
//!     peer_config.flags =
//!         Some(vec![WireguardParsedPeerFlags::ReplaceAllowedIps]);
//!
//!     let mut config = WireguardParsed::default();
//!     config.iface_name = Some(iface_name.to_string());
//!     config.public_key =
//!         Some("JKossUAjywXuJ2YVcaeD6PaHs+afPmIthDuqEVlspwA=".to_string());
//!     config.private_key =
//!         Some("6LTHiAM4vgKEgi5vm30f/EBIEWFDmySkTc9EWCcIqEs=".to_string());
//!     config.listen_port = Some(51820);
//!     config.fwmark = Some(0);
//!     config.peers = Some(vec![peer_config]);
//!     config.flags = Some(vec![WireguardParsedDeviceFlags::ReplacePeers]);
//!
//!     let (conn, mut handle, _) = nl_wireguard::new_connection()?;
//!     tokio::spawn(conn);
//!     handle.set(config).await?;
//!     Ok(())
//! }
//! ```
//!
//! To remove a wireguard peer, only its public key is needed, the other
//! peers of the interface keep their configuration.
//!
//! ```no_run
//! async fn remove_wireguard_peer(
//!     iface_name: &str,
//!     public_key: &str,
//! ) -> Result<(), Box<dyn std::error::Error>> {
//!     let (conn, mut handle, _) = nl_wireguard::new_connection()?;
//!     tokio::spawn(conn);
//!     handle.remove_peer(iface_name, public_key).await?;
//!     Ok(())
//! }
//! ```
//!
//! `WireguardParsedDeviceFlags::ReplacePeers` and
//! `WireguardParsedPeerFlags::ReplaceAllowedIps` make repeated runs of the
//! example replace the existing configuration instead of appending to it.

mod connection;
mod error;
mod handle;
mod parsed;
mod peer_parsed;
mod redact;

#[cfg(feature = "tokio_socket")]
pub use self::connection::new_connection;
pub use self::{
    connection::new_connection_with_socket,
    error::{ErrorKind, WireguardError},
    handle::WireguardHandle,
    parsed::{WireguardParsed, WireguardParsedDeviceFlags},
    peer_parsed::{
        WireguardIpAddress, WireguardParsedAllowedIpFlags,
        WireguardParsedPeerFlags, WireguardPeerParsed,
    },
};

// Compile the examples of the README as doc tests.
#[cfg(doctest)]
#[doc = include_str!("../README.md")]
struct ReadmeDoctests;