added protocol header checking

.vscode/launch.json

@@ -0,0 +1,72 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Launch",
+            "program": "${workspaceFolder}/<program>",
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug unit tests in library 'Uno'",
+            "cargo": {
+                "args": [
+                    "test",
+                    "--no-run",
+                    "--lib",
+                    "--package=Uno"
+                ],
+                "filter": {
+                    "name": "Uno",
+                    "kind": "lib"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug executable 'Uno'",
+            "cargo": {
+                "args": [
+                    "build",
+                    "--bin=Uno",
+                    "--package=Uno"
+                ],
+                "filter": {
+                    "name": "Uno",
+                    "kind": "bin"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug unit tests in executable 'Uno'",
+            "cargo": {
+                "args": [
+                    "test",
+                    "--no-run",
+                    "--bin=Uno",
+                    "--package=Uno"
+                ],
+                "filter": {
+                    "name": "Uno",
+                    "kind": "bin"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        }
+    ]
+}

src/main.rs

@@ -1,5 +1,5 @@
 pub mod tcp_server;
 
 fn main() {
-    println!("Hello, world!");
+    tcp_server::main();
 }

src/tcp_server.rs

@@ -1,50 +1,56 @@
 use std::{
-    net::{TcpListener, TcpStream},
+    io::{ prelude::*, BufReader, BufWriter },
-    io::{prelude::*, BufReader, BufWriter},
+    net::{ TcpListener, TcpStream },
 };
 
-fn main(){
+const PROTOCOL_ERROR_STRING: &str = "Client/Server protocol mismatch";
+
+pub fn main() {
     let listener = TcpListener::bind("0.0.0.0:8000").unwrap();
 
-    for stream in listener{
+    for stream in listener.incoming() {
-        let (reader, writer) = create_buffers(stream.unwrap());
+        let (reader, writer) = create_buffers(stream.unwrap().try_clone().unwrap());
         let result = check_protocol(reader, writer).unwrap();
-        if result.equals("Uno-Enthusiast99") {
+        if result == "Uno-Enthusiast99" {
             println!("It works!");
         }
-
     }
-        
 }
 
-fn create_buffers(&mut stream : TcpStream) -> (BufReader, BufWriter) {
+fn create_buffers(stream: TcpStream) -> (BufReader<TcpStream>, BufWriter<TcpStream>) {
-    (BufReader::new(stream), BufWriter::new(stream))
+    (
-
+        BufReader::new(stream.try_clone().expect("Could not clone TcpStreams")),
+        BufWriter::new(stream),
+    )
 }
-    fn check_protocol(&reader : BufReader, &writer : BufWriter) -> Result {
+fn check_protocol(
-        let init_message : Vec<_> = reader
+    reader: BufReader<TcpStream>,
+    mut writer: BufWriter<TcpStream>
+) -> Result<String, String> {
+    let protocol_error_string = PROTOCOL_ERROR_STRING.to_string();
+    let init_message: Vec<_> = reader
         .lines()
         .map(|result| result.unwrap())
         .take_while(|line| !line.is_empty())
-                                      .collect()
+        .collect();
-                                      .iter();
+    let mut init_message = init_message.iter();
-        let mut is_valid = true;
+    let is_valid1 = init_message.next().unwrap_or_else(|| &protocol_error_string) == "app:uno";
-        is_valid = init_message.next().unwrap_or_else(|| "invalid") == "app:uno";
+    let is_valid2= init_message.next().unwrap_or_else(|| &protocol_error_string) == "version:0.1";
-        is_valid = init_message.next().unwrap(|| "invalid") == "version:0.1";
+    let player_name: &str = init_message.next().unwrap_or_else(|| &protocol_error_string);
-        is_valid = init_message.next().unwrap(|| "invalid").contains("player_name:");
+    let is_valid3 = if player_name != "invalid" && player_name.contains("player_name:") {
-        if init_message.next() != None {
+        true
-            is_valid = false;
+    } else {
-        }
+        false
-           
+    };
-        if !is_valid {
+    if init_message.next() != None || !(is_valid1 && is_valid2 && is_valid3){
-            writer.write("Error").unwrap();
+        writer.write(protocol_error_string.as_bytes()).unwrap();
         writer.flush().unwrap();
-            return Err;
+        return Err(protocol_error_string);
     }
-        writer.write("Ok").unwrap();
+    writer.write("Ok".as_bytes()).unwrap();
     writer.flush().unwrap();
-        Ok( item.split(':').unwrap() )
+    return Ok(player_name.split(':').collect::<Vec<_>>()[1].to_owned());
-    }
+}
 
 //    fn register_player(player_name : &str, reader : BufReader, writer : BufWriter){
 //