wip

src/main.rs

@@ -1,3 +1,5 @@
+use std::fmt::Display;
+use std::str::FromStr;
 use std::time::Duration;
 
 use clap::{Parser, Subcommand};
@@ -10,7 +12,6 @@ use reticulum::destination::link::{Link, LinkEvent, LinkStatus};
 use reticulum::destination::{DestinationName, SingleInputDestination};
 use reticulum::hash::AddressHash;
 use reticulum::identity::PrivateIdentity;
-use reticulum::iface::tcp_client::TcpClient;
 use reticulum::transport::{Transport, TransportConfig};
 
 use tokio::time::interval;
@@ -51,24 +52,64 @@ mod number_station {
     }
 }
 
-#[derive(Subcommand)]
+#[derive(Subcommand, Debug)]
 enum Mode {
     Receiver,
     Generator,
 }
 
-enum ReticulumLink {
-    TcpClient { socket_addr: std::net::SocketAddr },
+#[derive(clap::Parser, serde::Deserialize, serde::Serialize, Clone, Debug)]
+enum ReticulumInterface {
+    TcpClient {
+        server_addr: std::net::SocketAddr,
+    },
+    Udp {
+        bind_addr: std::net::SocketAddr,
+        forward_addr: std::net::SocketAddr,
+    },
 }
 
-#[derive(Parser)]
+// impl std::fmt::Display for ReticulumInterface {
+//     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+//         write!(f, "{}", self.to_string())
+//     }
+// }
+
+impl FromStr for ReticulumInterface {
+    type Err = toml::de::Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        toml::from_str(s)
+    }
+}
+
+impl Display for ReticulumInterface {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        let mut value = String::new();
+        serde::Serialize::serialize(self, toml::ser::ValueSerializer::new(&mut value))
+            .map_err(|_| std::fmt::Error)?;
+
+        write!(f, "{value}")
+
+        // write!(
+        //     f,
+        //     "{}",
+        //     toml::to_string_pretty(self).map_err(|_| std::fmt::Error)?
+        // )
+    }
+}
+
+#[derive(Parser, Debug)]
 struct Cli {
     #[command(subcommand)]
     mode: Mode,
 
-    /// Connect to Reticulum Network by making a TCP Client interface to this host:port.
-    #[arg(short, long, default_value_t = String::from("127.0.0.1:4242"))]
-    tcp_client: String,
+    /// Connect to Reticulum Network via this specified interface.
+    /// Accepted formats:
+    ///     TcpClient={server_addr="HOST:PORT"}
+    ///     Udp={bind_addr="HOST:PORT", forward_addr="HOST:PORT"}
+    ///
+    #[arg(short = 'l', long, default_value_t = ReticulumInterface::from_str("TcpClient = { server_addr=\"127.0.0.1:4242\" }").unwrap(), verbatim_doc_comment)]
+    reticulum_interface: ReticulumInterface,
 }
 
 async fn run_client(transport: &mut reticulum::transport::Transport) {
@@ -176,13 +217,46 @@ async fn main() {
 
     let cli = Cli::parse();
 
+    //println!("{cli:?}");
+    println!("{}", cli.reticulum_interface);
+    println!("{:?}", cli.reticulum_interface);
+    println!(
+        "to_string: {}",
+        toml::ser::to_string(&cli.reticulum_interface).unwrap()
+    );
+    println!(
+        "to_string_pretty: {}",
+        toml::ser::to_string_pretty(&cli.reticulum_interface).unwrap()
+    );
+
+    let mut value = String::new();
+    serde::Serialize::serialize(
+        &cli.reticulum_interface,
+        toml::ser::ValueSerializer::new(&mut value),
+    )
+    .unwrap();
+    println!("ValueSerializer: {}", value);
+
     let mut transport = Transport::new(TransportConfig::default());
 
-    let client_addr = transport
-        .iface_manager()
-        .lock()
-        .await
-        .spawn(TcpClient::new(cli.tcp_client), TcpClient::spawn);
+    let client_addr = match cli.reticulum_interface {
+        ReticulumInterface::TcpClient { server_addr } => {
+            transport.iface_manager().lock().await.spawn(
+                reticulum::iface::tcp_client::TcpClient::new(server_addr.to_string()),
+                reticulum::iface::tcp_client::TcpClient::spawn,
+            )
+        }
+        ReticulumInterface::Udp {
+            bind_addr,
+            forward_addr,
+        } => transport.iface_manager().lock().await.spawn(
+            reticulum::iface::udp::UdpInterface::new(
+                bind_addr.to_string(),
+                Some(forward_addr.to_string()),
+            ),
+            reticulum::iface::udp::UdpInterface::spawn,
+        ),
+    };
 
     log::info!("client ID: {}", client_addr);