From 8d3a890ca31d3086f90cdec84e2555719a4cd5b9 Mon Sep 17 00:00:00 2001
From: zazedd <leomendesantos@gmail.com>
Date: Wed, 7 Feb 2024 23:42:57 +0000
Subject: [PATCH] Client will keep a connection after sending a message. Client
 ids

---
 Cargo.toml    |  1 +
 src/client.rs | 55 ++++++++++++++++++++++++++++++++++-----------------
 src/server.rs | 38 +++++++++++++++++++++--------------
 3 files changed, 61 insertions(+), 33 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 9bc91ad..cc9c3ca 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,6 +15,7 @@ tungstenite = "0.21.0"
 env_logger = "0.11.0"
 url = "2.5.0"
 serial_test = "3.0.0"
+x25519-dalek = "2.0.1"
 
 [[bin]]
 name = "server"
diff --git a/src/client.rs b/src/client.rs
index beec4b4..3676427 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -7,6 +7,7 @@ use base64::prelude::*;
 use strange_cipher::common;
 
 enum ClientState {
+    Waiting,
     Syncing,
     Encrypting,
     Encrypted(String),
@@ -39,33 +40,51 @@ pub fn main() {
     }
 
     let seed = (-10.0, -7.0, 35.0);
-    let sigma = 25.0;
-    let rho = 2.0;
+    let sigma = 10.0;
+    let rho = 28.0;
     let beta = 8.0 / 3.0;
     let h = 0.01;
-    let mut stream_state = ClientState::Syncing;
+    let mut stream_state = ClientState::Waiting;
     let mut key_stream = Vec::new();
 
     let mut state = common::lorenz_attractor(seed.0, None, seed.1, seed.2, sigma, rho, beta, h);
-
     let mut input = String::new();
-    print!("Type a message you want to encrypt: ");
-    io::stdout().flush().unwrap();
-    io::stdin().read_line(&mut input).unwrap();
-    let input = input.trim().to_string();
-
-    common::send_request(&mut socket, "Sync Request", 1);
-    common::receive_msg(&mut socket);
-
-    match socket.get_mut() {
-        tungstenite::stream::MaybeTlsStream::Plain(stream) => stream.set_nonblocking(true),
-        _ => unimplemented!(),
-    }
-    .expect("Could not make socket non-blocking");
 
     loop {
         match stream_state {
+            ClientState::Waiting => {
+                match socket.get_mut() {
+                    tungstenite::stream::MaybeTlsStream::Plain(stream) => {
+                        stream.set_nonblocking(false)
+                    }
+                    _ => unimplemented!(),
+                }
+                .expect("Could not make socket non-blocking");
+
+                print!("Type a message you want to encrypt (Empty to Cancel): ");
+                input.clear();
+                io::stdout().flush().unwrap();
+                io::stdin().read_line(&mut input).unwrap();
+                let input = input.trim().to_string();
+
+                if input == "" {
+                    common::send_request(&mut socket, "Cancel Request", 0);
+                    break;
+                }
+
+                common::send_request(&mut socket, "Sync Request", 1);
+                common::receive_msg(&mut socket);
+                stream_state = ClientState::Syncing;
+            }
             ClientState::Syncing => {
+                match socket.get_mut() {
+                    tungstenite::stream::MaybeTlsStream::Plain(stream) => {
+                        stream.set_nonblocking(true)
+                    }
+                    _ => unimplemented!(),
+                }
+                .expect("Could not make socket non-blocking");
+
                 state =
                     common::lorenz_attractor(state.0, None, state.1, state.2, sigma, rho, beta, h);
                 socket
@@ -118,7 +137,7 @@ pub fn main() {
                         .expect("Could not send byte")
                 });
 
-                break;
+                stream_state = ClientState::Waiting;
             }
         }
     }
diff --git a/src/server.rs b/src/server.rs
index c4e04a1..9c57007 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -36,7 +36,7 @@ fn main() {
     let server = TcpListener::bind("127.0.0.1:3012").unwrap();
     println!("Server Started");
 
-    for stream in server.incoming() {
+    for (i, stream) in server.incoming().enumerate() {
         spawn(move || {
             let callback = |req: &Request, response: Response| {
                 println!("New Client connected");
@@ -63,8 +63,8 @@ fn main() {
                 .expect("Couldn't make socket non-blocking");
 
             let mut seed = (0.0, 1.0, 2.0);
-            let sigma = 25.0;
-            let rho = 2.0;
+            let sigma = 10.0;
+            let rho = 28.0;
             let beta = 8.0 / 3.0;
             let h = 0.01;
             let mut last_y = 0.;
@@ -81,16 +81,24 @@ fn main() {
                         );
                         seed = (new_x, new_y, new_z);
 
-                        if let Some(Message::Binary(v)) = common::read_non_blocking(&mut websocket)
-                        {
-                            if v.as_slice() == [1] {
-                                time = SystemTime::now();
-                                println!("Received: Sync Request");
-                                websocket
-                                    .send(Message::Text("Sync Request approved".to_string()))
-                                    .unwrap();
-                                stream_state = ServerState::Syncing;
-                            }
+                        match common::read_non_blocking(&mut websocket) {
+                            Some(Message::Binary(v)) => match v.as_slice() {
+                                [1] => {
+                                    time = SystemTime::now();
+                                    println!("Received: Sync Request");
+                                    websocket
+                                        .send(Message::Text("Sync Request approved".to_string()))
+                                        .unwrap();
+                                    stream_state = ServerState::Syncing;
+                                }
+                                [0] => {
+                                    println!("Received: Cancel Request");
+                                    println!("Client Number {} Left", i);
+                                    break;
+                                }
+                                _ => panic!("Invalid Request Received"),
+                            },
+                            _ => (),
                         }
                     }
                     ServerState::Syncing => {
@@ -202,9 +210,9 @@ fn main() {
                         }
                     }
                     ServerState::Decrypted(ref plaintext) => {
-                        println!("Decoded message: {}", plaintext);
+                        println!("Decoded message from client {}: {}", i, plaintext.trim());
                         println!("Took: {}ms", time.elapsed().unwrap().as_millis());
-                        break;
+                        stream_state = ServerState::Unsynced;
                     }
                 }
             }