working!

src/lib.rs

@@ -1,65 +1,58 @@
-use std::io::{self, Read};
-use std::net::{TcpListener, TcpStream, IpAddr, SocketAddr, Ipv4Addr, SocketAddrV4};
+use std::io::{self, Read, Write};
+use std::net::{TcpListener, TcpStream};
 use std::error::Error;
-use std::str::FromStr;
+use std::sync::mpsc::{Receiver, Sender};
+use std::time::Duration;
 
-type EmptyResult = Result<(), Box<dyn Error>>;
+type StreamResult = Result<TcpStream, Box<dyn Error>>;
 
 
-pub fn listen() -> EmptyResult {
-    let l_stream = listen_on_port(7979)?;
+pub fn listen() -> StreamResult {
+    println!("Listening on {}:8080", local_ipaddress::get().unwrap());
+    let listener = TcpListener::bind(("127.0.0.1", 8080))?;
+    let stream = listener.incoming().next().unwrap()?;
     println!("Connected. Waiting for response stream...");
-    let other_address = l_stream.peer_addr()?.ip();
-    println!("other adress: {}", other_address);
-    let s_stream = connect_to_addr("127.0.0.1", 7980)?;
+    println!("other adress: {}", stream.peer_addr()?.ip());
 
-
-    Ok(())
+    Ok(stream)
 }
 
-pub fn connect(address: String, port: String) -> EmptyResult {
+pub fn connect(address: String, port: String) -> StreamResult {
     println!("Trying to connect to '{}:{}'", &address, &port);
 
     let port: u16 = port.parse()?;
-    let s_stream = connect_to_addr(&*address, port)?;
+    let stream = TcpStream::connect((&*address, port))?;
 
-    println!("Connected. Waiting for response stream...");
-    let l_stream = listen_on_port(7080)?;
-    println!("Connected. Chat is now open...");
+    println!("Connected.");
 
-    Ok(())
+    Ok(stream)
 }
 
-pub fn connect_to_addr(address: &str, port: u16) -> Result<TcpStream, Box<dyn Error>> {
-    let socket_addr = SocketAddrV4::new(Ipv4Addr::from_str(address)?, port);
-    match TcpStream::connect(socket_addr) {
-        Err(e) => Err(Box::new(e)),
-        Ok(s) => Ok(s)
+
+pub fn network_thread(mut stream: TcpStream, rx: Receiver<String>) {
+    let mut data = [0u8; 255]; // using 50 byte buffer
+    stream.set_read_timeout(Some(Duration::from_millis(500))).expect("Could not set timeout");
+    loop {
+        if let Ok(_) = stream.read(&mut data) {
+            println!("> {}", String::from_utf8_lossy(&data));
+            data = [0u8; 255];
+        }
+        if let Ok(v) = rx.recv_timeout(Duration::from_millis(200)) {
+            stream.write(v.as_bytes()).expect("could not send message");
+        }
     }
 }
 
-pub fn listen_on_port(port: u16) -> io::Result<TcpStream> {
-    let listener = TcpListener::bind(("127.0.0.1", port)).unwrap();
-    println!(
-        "Listening on: {}:{}...",
-        local_ipaddress::get().unwrap(),
-        port
-    );
-
-    listener.incoming().next().unwrap()
-}
-
-pub fn read_stream_print(mut stream: TcpStream) {
-    let mut data = [0 as u8; 50]; // using 50 byte buffer
-
-    for _ in stream.read(&mut data) {
-        println!("{}", String::from_utf8_lossy(&data));
+pub fn ui_thread(sx: Sender<String>) {
+    loop {
+        let input = input();
+        sx.send(input).expect("could not send value");
     }
 }
 
 
-fn input() -> String {
+pub fn input() -> String {
     let mut buffer = String::new();
     let _ = io::stdin().read_line(&mut buffer);
-    buffer
+    buffer.trim().to_string()
 }

src/main.rs

@@ -1,8 +1,7 @@
-use std::io::{self, Write};
 use std::thread;
-use terminal_chat::{
-    connect, listen, listen_on_port, read_stream_print,
-};
+use terminal_chat::{connect, listen, network_thread, input, ui_thread};
+use std::sync::{mpsc};
+use std::sync::mpsc::{Sender, Receiver};
 
 fn main() {
     println!(
@@ -29,51 +28,28 @@ Version 0.1"
         };
         println!("Port: (empty for default)");
         let port = match &*input() {
-            "" => String::from("7979"),
+            "" => String::from("8080"),
             s => String::from(s)
         };
         connect(address, port)
     };
 
     match result {
-        Ok(_) => println!("Exited TerminalChat sucessfully."),
+        Ok(s) => {
+            println!("Successful connection established.");
+
+            let (sx, rx): (Sender<String>, Receiver<String>) = mpsc::channel();
+
+            let net = thread::spawn(move || {
+                network_thread(s, rx);
+            });
+            let ui = thread::spawn(move ||{
+                ui_thread(sx)
+            });
+
+            net.join().unwrap();
+            ui.join().unwrap();
+        }
         Err(e) => println!("An error occurred! Error message: '{}'", e)
     }
-
-    // old
-    /*
-
-        let stream = match stream {
-            Ok(x) => x,
-            Err(_) => {
-                println!("Error opening stream");
-                return;
-            }
-        };
-
-        let mut stream2 = match did_listen {
-            true => connect_to_addr(IpAddress::WithPort(String::from("127.0.0.1"), 7980)).unwrap(),
-            false => listen_on_port(7989).unwrap(),
-        };
-
-        thread::spawn(move || {
-            read_stream_print(stream);
-        });
-
-        println!("Connected.");
-
-        let connect_msg = "Hello World!";
-        stream2.write(connect_msg.as_bytes()).unwrap();
-
-        loop {
-            let input = input();
-            stream2.write(input.clone().as_bytes());
-            println!("-- Trying to send {}", input);
-        }*/
-}
-
-fn input() -> String {
-    let mut buffer = String::new();
-    let _ = io::stdin().read_line(&mut buffer);
-    buffer
-}
+}