[cli] work on cli

quicktap-cli/src/command.rs

@@ -1,6 +1,15 @@
+use std::error::Error;
+use std::os::unix::net::UnixListener;
+
 pub enum PacketThreadCommand {
     UpdateConfig(UpdateConfigCommand),
     Stop
 }
 
-pub struct UpdateConfigCommand {}
+pub struct UpdateConfigCommand {}
+
+pub fn command_handler(listener: UnixListener) -> Result<(), Box<dyn Error>> {
+    listener.set_nonblocking(true)?;
+
+    Ok(())
+}

quicktap-cli/src/main.rs

@@ -1,24 +1,20 @@
-use std::collections::HashMap;
+
 use std::fs::File;
-use std::io;
+
-use std::io::Read;
+use std::os::unix::net::{UnixListener};
-use std::net::{Ipv4Addr, SocketAddr};
+
-use std::os::unix::net::{UnixListener, UnixStream};
-use std::path::Path;
 use std::sync::mpsc::channel;
-use std::thread::{sleep, spawn};
+use std::thread::{spawn};
-use std::time::Duration;
 
 use clap::Parser;
 use daemonize::Daemonize;
 use log::{error, info};
 
-use quicktap::cidr::{IpInet, Ipv4Inet};
 use quicktap::drivers::tun::TunDevice;
 use quicktap::drivers::tungeneric::{GenericDriver, GenericInterface};
 
 use crate::cli::Cli;
-use crate::command::PacketThreadCommand;
+use crate::command::{command_handler, PacketThreadCommand};
 use crate::pproc::packet_thread;
 
 pub mod cli;
@@ -65,7 +61,7 @@ fn main() {
 
     info!("Creating unconfigured device");
 
-    let mut device = match TunDevice::new(&GenericInterface {
+    let device = match TunDevice::new(&GenericInterface {
         addresses: vec![],
         mtu: None,
         name: args.interface_name.clone(),
@@ -77,23 +73,6 @@ fn main() {
         }
     };
 
-    info!("Device created; opening listening socket");
-
-    let mut config_listener = match UnixListener::bind(format!("/var/run/{}.sock", args.interface_name)) {
-        Ok(s) => s,
-        Err(e) => {
-            error!("Failed to open listen socket /var/run/{}.sock: {}", args.interface_name, e);
-            std::process::exit(3);
-        }
-    };
-    match config_listener.set_nonblocking(true) {
-        Ok(_) => (),
-        Err(e) => {
-            error!("Failed to set stream as nonblocking: {}", e);
-            std::process::exit(4);
-        }
-    };
-
     info!("Spawning packet processor thread");
 
     let (tx, rx) = channel::<PacketThreadCommand>();
@@ -107,7 +86,19 @@ fn main() {
         }
     });
 
-    sleep(Duration::from_secs(10));
+    info!("Creating command listener");
+    match UnixListener::bind(format!("/var/run/{}.sock", args.interface_name)) {
+        Ok(l) => {
+            // handle l
+            match command_handler(l) {
+                Ok(_) => (),
+                Err(e) => error!("Error in command handler: {}", e)
+            }
+        },
+        Err(e) => {
+            error!("Error creating command listener {}: {}", format!("/var/run/{}.sock", args.interface_name), e);
+        }
+    };
 
     match tx.send(PacketThreadCommand::Stop) {
         Ok(_) => (),
@@ -128,13 +119,11 @@ fn main() {
 
     info!("Cleaning up");
 
-    if Path::new(&format!("/var/run/{}.sock", args.interface_name)).exists() {
+    match std::fs::remove_file(format!("/var/run/{}.sock", args.interface_name)) {
-        match std::fs::remove_file(format!("/var/run/{}.sock", args.interface_name)) {
+        Ok(_) => (),
-            Ok(_) => (),
+        Err(e) => {
-            Err(e) => {
+            error!("Failed to remove existing socket: {}", e);
-                error!("Failed to remove existing socket: {}", e);
+            std::process::exit(7);
-                std::process::exit(7);
-            }
         }
     }