suricatasc: reconnect on loss of connection

If the connection is lost (for example, Suricata is restarted), try to
re-open the connect and re-execute the command.

This was the behavior of the Python implementation.

Ticket: #7746

rust/suricatasc/src/unix/client.rs

@@ -19,6 +19,7 @@ pub enum ClientError {
 }
 
 pub struct Client {
+    filename: String,
     socket: UnixStream,
 
     // If set, the client will print to stdout the messages sent and
@@ -30,12 +31,25 @@ pub struct Client {
 impl Client {
     pub fn connect<T: AsRef<str>>(filename: T, verbose: bool) -> Result<Self, ClientError> {
         let filename = filename.as_ref().to_string();
-        let socket = UnixStream::connect(filename)?;
-        let mut client = Self { socket, verbose };
+        let socket = UnixStream::connect(&filename)?;
+        let mut client = Self {
+            filename,
+            socket,
+            verbose,
+        };
         client.handshake()?;
         Ok(client)
     }
 
+    pub fn reconnect(&mut self) -> Result<(), ClientError> {
+        if self.verbose {
+            println!("Reconnecting to socket: {}", self.filename);
+        }
+        self.socket = UnixStream::connect(&self.filename)?;
+        self.handshake()?;
+        Ok(())
+    }
+
     fn handshake(&mut self) -> Result<(), ClientError> {
         self.send(&json!({"version": "0.2"}))?;
         self.read().map(serde_json::from_value::<Response>)??;

rust/suricatasc/src/unix/main.rs

@@ -71,6 +71,8 @@ fn run_interactive(mut client: Client) -> Result<(), Box<dyn std::error::Error>>
         if line.starts_with("quit") {
             break;
         }
+        let mut retry = false;
+        loop {
             match command_parser.parse(&line) {
                 Ok(command) => match interactive_request_response(&mut client, &command) {
                     Ok(response) => {
@@ -85,13 +87,26 @@ fn run_interactive(mut client: Client) -> Result<(), Box<dyn std::error::Error>>
                             println!("Error:");
                             println!("{}", serde_json::to_string(&response.message).unwrap());
                         }
+                        break;
                     }
                     Err(err) => {
-                    println!("{}", err);
+                        println!("Error: {}", err);
+                        if retry {
+                            break;
+                        }
+                        if let Err(err) = client.reconnect() {
+                            println!("Error: {}", &err);
+                            break;
+                        } else {
+                            retry = true;
+                            continue;
+                        }
                     }
                 },
                 Err(err) => {
                     println!("{}", err);
+                    break;
+                }
             }
         }
     }