Librarify

Author: vi

Cargo.lock

@@ -24,6 +24,10 @@ smoltcp = { version = "0.10.0", default-features = false, features = ["socket",
 tokio = { version = "1.29.1", features = ["rt", "net", "sync", "macros", "io-util", "time"] }
 tracing = "0.1.37"
 tracing-subscriber = {version="0.3.17", optional=true}
+libwgslirpy = {version = "0.2.0", path="crates/libwgslirpy"}
 
 [features]
 default = ["tracing-subscriber", "tracing/release_max_level_debug"]
+
+[workspace]
+members = ["crates/*"]

Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "libwgslirpy"
+version = "0.2.0"
+edition = "2021"
+repository = "https://github.com/vi/wgslirpy"
+license = "MIT/Apache-2.0"
+description = "User-space Wireguard to internet router, like SLiRP, but with Wireguard instead of PPP (library part of the CLI tool)"
+categories = ["network-programming"]
+keywords = ["wireguard","onetun","slirp","nat"]
+
+[dependencies]
+anyhow = "1.0.72"
+base64 = "0.21.2"
+boringtun = "0.6.0"
+bytes = "1.4.0"
+hashbrown = "0.14.0"
+simple-dns = "0.5.3"
+smoltcp = { version = "0.10.0", default-features = false, features = ["socket", "socket-tcp", "socket-udp", "std", "proto-ipv4", "proto-ipv4-fragmentation", "proto-ipv6", "fragmentation-buffer-size-65536", "assembler-max-segment-count-32", "log", "medium-ip"] }
+tokio = { version = "1.29.1", features = ["rt", "net", "sync", "macros", "io-util", "time"] }
+tracing = "0.1.37"

crates/libwgslirpy/Cargo.toml

@@ -5,7 +5,7 @@ use smoltcp::phy::{Device,RxToken,TxToken, Checksum};
 use tokio::sync::mpsc::Sender;
 use tracing::warn;
 
-use crate::TEAR_OF_ALLOCATION;
+use crate::TEAR_OF_ALLOCATION_SIZE;
 
 pub struct ChannelizedDevice {
     pub tx : Sender<BytesMut>,
@@ -19,7 +19,7 @@ impl ChannelizedDevice {
         ChannelizedDevice {
             tx,
             rx: None,
-            tear_off_buffer: BytesMut::with_capacity(TEAR_OF_ALLOCATION),
+            tear_off_buffer: BytesMut::with_capacity(TEAR_OF_ALLOCATION_SIZE),
             mtu,
         }
     }
@@ -84,7 +84,7 @@ impl<'a> TxToken for &'a mut ChannelizedDevice {
             warn!("Failed to transmit into a ChannelizedDevice");
         }
         if self.tear_off_buffer.capacity() < 2048 {
-            self.tear_off_buffer = BytesMut::with_capacity(TEAR_OF_ALLOCATION);
+            self.tear_off_buffer = BytesMut::with_capacity(TEAR_OF_ALLOCATION_SIZE);
         }
         ret
     }

src/channelized_smoltcp_device.rs …slirpy/src/channelized_smoltcp_device.rssrc/channelized_smoltcp_device.rs renamed to crates/libwgslirpy/src/channelized_smoltcp_device.rs src/channelized_smoltcp_device.rs renamed to crates/libwgslirpy/src/channelized_smoltcp_device.rs

@@ -0,0 +1,31 @@
+const TEAR_OF_ALLOCATION_SIZE : usize = 65536;
+
+pub mod wg;
+pub mod router;
+pub mod channelized_smoltcp_device;
+
+use tracing::warn;
+
+pub use wg::parsebase64_32;
+
+pub async fn run(wireguard_options: wg::Opts, router_options: router::Opts, transmit_queue_capacity: usize) -> anyhow::Result<()> { 
+    let (tx_towg, rx_towg) = tokio::sync::mpsc::channel(transmit_queue_capacity);
+    let (tx_fromwg, rx_fromwg) = tokio::sync::mpsc::channel(4);
+    let _jh = ArmedJoinHandle(tokio::spawn(async move {
+        match wireguard_options.start(tx_fromwg, rx_towg).await {
+            Ok(()) => warn!("Exited from Wireguard loop"),
+            Err(e) => warn!("Exiten from Wireguard loop: {e}"),
+        }
+    }));
+
+    router::run(rx_fromwg, tx_towg, router_options).await?;
+
+    Ok(())
+}
+struct ArmedJoinHandle(tokio::task::JoinHandle<()>);
+
+impl Drop for ArmedJoinHandle {
+    fn drop(&mut self) {
+        self.0.abort();
+    }
+}

crates/libwgslirpy/src/lib.rs

@@ -9,6 +9,8 @@ use smoltcp::wire::{IpEndpoint, IpVersion, TcpPacket};
 use tokio::sync::mpsc::{channel, Receiver, Sender};
 use tracing::{debug, error, info, warn};
 
+use crate::ArmedJoinHandle;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 enum NatKey {
     Tcp {
@@ -60,14 +62,6 @@ mod serve_pingable;
 mod serve_tcp;
 mod serve_udp;
 
-struct ArmedJoinHandle(tokio::task::JoinHandle<()>);
-
-impl Drop for ArmedJoinHandle {
-    fn drop(&mut self) {
-        self.0.abort();
-    }
-}
-
 pub async fn run(
     mut rx_from_wg: Receiver<BytesMut>,
     tx_to_wg: Sender<BytesMut>,

src/router.rs crates/libwgslirpy/src/router.rssrc/router.rs renamed to crates/libwgslirpy/src/router.rs

@@ -14,7 +14,7 @@ use tokio::{
 };
 use tracing::{warn, debug};
 
-use crate::TEAR_OF_ALLOCATION;
+use crate::TEAR_OF_ALLOCATION_SIZE;
 
 pub const UDP_CONNECTION_EXPIRATION_SECONDS : u64 = 92;
 
@@ -51,7 +51,7 @@ pub async fn serve_udp(
     checksummer.ipv4 = Checksum::Tx;
     checksummer.tcp = Checksum::Tx;
 
-    let mut tear_off_buffer = BytesMut::with_capacity(TEAR_OF_ALLOCATION);
+    let mut tear_off_buffer = BytesMut::with_capacity(TEAR_OF_ALLOCATION_SIZE);
 
     enum SelectOutcome {
         FromWg(Option<BytesMut>),
@@ -176,7 +176,7 @@ pub async fn serve_udp(
                 let buf = tear_off_buffer.split();
                 tx_to_wg.send(buf).await?;
                 if tear_off_buffer.capacity() < 2048 {
-                    tear_off_buffer = BytesMut::with_capacity(TEAR_OF_ALLOCATION);
+                    tear_off_buffer = BytesMut::with_capacity(TEAR_OF_ALLOCATION_SIZE);
                 }
             }
             SelectOutcome::Timeout => {