Refactor code to simplify client deconnection

src/bin/client.rs

@@ -5,7 +5,6 @@ use shakmaty::fen::Fen;
 use shakmaty::{Chess, Color, Outcome, Position, Setup};
 use std::io;
 use std::os::unix::net::UnixStream;
-use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::{channel, Receiver, TryRecvError};
 use std::sync::{Arc, Mutex};
 use std::thread;
@@ -14,13 +13,11 @@ use std::time;
 struct Client {
     player: clichess::Player,
     side: Color,
-    running: Arc<AtomicBool>,
     input_buffer: Arc<Mutex<String>>,
     server_message_recv: Receiver<String>,
 }
 
 fn main() {
-    let running = setupctrlc();
     let username = std::env::args().nth(1).expect("no name given");
     let public_key = std::env::args().nth(2).expect("no public key given");
     //send username and public key to server
@@ -47,7 +44,6 @@ fn main() {
             public_key: public_key,
         },
         side: Color::White,
-        running: running.clone(),
         input_buffer: input_buffer.clone(),
         server_message_recv,
     };
@@ -133,16 +129,6 @@ fn setup_input_buffer() -> Arc<Mutex<String>> {
     buf
 }
 
-fn setupctrlc() -> Arc<AtomicBool> {
-    let running = Arc::new(AtomicBool::new(true));
-    let r = running.clone();
-    ctrlc::set_handler(move || {
-        r.store(false, Ordering::SeqCst);
-    })
-    .expect("Error setting Ctrl-C handler");
-    running
-}
-
 fn setup_server_message_recv(stream: &UnixStream) -> io::Result<Receiver<String>> {
     let (sender, receiver) = channel();
     let thread_stream = stream.try_clone()?;
@@ -165,7 +151,7 @@ fn read_user_input(client: &Client) -> String {
         user_input.clear();
     }
     let mut input = String::new();
-    while client.running.load(Ordering::SeqCst) {
+    loop {
         thread::sleep(time::Duration::from_millis(10));
         {
             let user_input = client.input_buffer.lock().unwrap();
@@ -177,11 +163,7 @@ fn read_user_input(client: &Client) -> String {
             }
         }
     }
-    if client.running.load(Ordering::SeqCst) {
-        input
-    } else {
-        String::from(EXIT_MSG)
-    }
+    input
 }
 
 //wait for next position from server, then return the current board.
@@ -196,7 +178,7 @@ fn get_current_position(client: &Client) -> Result<Chess, RecvPositionError> {
 
 fn fetch_message_from_server(client: &Client) -> String {
     let mut response = String::new();
-    while client.running.load(Ordering::SeqCst) {
+    loop {
         thread::sleep(time::Duration::from_millis(10));
         {
             let server_response_recv = &client.server_message_recv;

src/bin/server.rs

@@ -111,7 +111,9 @@ fn main_loop(stream: &mut UnixStream, server: &Server, player: Player, mut playe
                         others_serv_msg_buf.lock().unwrap().push_str(&chessfen);
                     }
                 }
-                clichess::write_to_stream(stream, chessfen).unwrap();
+                if clichess::write_to_stream(stream, chessfen).is_err() {
+                    break;
+                }
                 player_turn = chess.turn();
             }
         } else {
@@ -151,7 +153,8 @@ fn wait_for_opponent_move(server: &Server) -> Result<String, RecvPositionError>
                                 "Client sent message while it's not its turn, this is an error."
                             );
                             println!("Here is the message: {}", msg);
-                            continue;
+                            returned_result = Err(RecvPositionError::UserCanceledError);
+                            break;
                         }
                     }
                     Err(TryRecvError::Disconnected) => println!("Error: client disconnected."),