Clean codes.

Author: zhboner

readme.md

@@ -0,0 +1,8 @@
+## Introduction
+
+realm is a simple, high performance relay server written in rust.
+
+## Features
+- Zero configuration. Setup and run in one command.
+- Concurrency. Bidirectional concurrent traffic leads to high performance.
+- Low resources cost.

src/main.rs

@@ -1,13 +1,11 @@
 use std::thread;
 // use std::io::Read;
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
-use std::net::{TcpListener, TcpStream, Shutdown};
+use std::net::{Shutdown, TcpListener, TcpStream};
 use structopt::StructOpt;
 
 mod relay;
 
-
-
 /// Search for a pattern in a file and display the lines that contain it.
 #[derive(StructOpt)]
 #[structopt(name = "example", about = "An example of StructOpt usage.")]
@@ -20,8 +18,6 @@ struct Cli {
     remote: String,
 }
 
-
-
 fn main() {
     let cli = Cli::from_args();
     let client_socket: SocketAddr = cli.client.parse().expect("Unable to parse client address");

src/relay.rs

@@ -1,13 +1,12 @@
-use std::thread;
-use std::sync::mpsc;
-use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
-use std::net::{TcpListener, TcpStream, Shutdown};
 use std::io::prelude::*;
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
+use std::net::{Shutdown, TcpListener, TcpStream};
+use std::sync::mpsc;
+use std::thread;
 use std::time::Duration;
 
 const BUFFER_SIZE: usize = 1024 * 2;
 
-
 pub fn start(client_socket: SocketAddr, remote_socket: SocketAddr) {
     let listener = TcpListener::bind(client_socket).unwrap_or_else(|err| {
         println!("Failed to start listener.");
@@ -20,83 +19,83 @@ pub fn start(client_socket: SocketAddr, remote_socket: SocketAddr) {
             Ok(stream) => {
                 thread::spawn(move || handle_client(stream, remote_socket));
             }
-            
         }
     }
 }
 
 fn handle_client(mut stream: TcpStream, remote_socket: SocketAddr) {
-
     let (forward_tx, forward_rx) = mpsc::channel();
     let (backward_tx, backward_rx) = mpsc::channel();
 
-    // stream.set_read_timeout(None).expect("set_read_timeout call failed");
-    // stream.set_write_timeout(None).expect("set_read_timeout call failed");
     let mut cl_stream = stream;
-    let mut lc_stream = cl_stream.try_clone().expect("Failed to clone client stream");
+    let mut lc_stream = cl_stream
+        .try_clone()
+        .expect("Failed to clone client stream");
 
-    let mut lr_stream = TcpStream::connect(remote_socket).expect("Failed to connect to remote host");
-    // lr_stream.set_read_timeout(None).expect("set_read_timeout call failed");
-    // lr_stream.set_write_timeout(None).expect("set_read_timeout call failed");
-    let mut rl_stream = lr_stream.try_clone().expect("Failed to clone remote stream");
+    let mut lr_stream =
+        TcpStream::connect(remote_socket).expect("Failed to connect to remote host");
+    let mut rl_stream = lr_stream
+        .try_clone()
+        .expect("Failed to clone remote stream");
 
-
-    thread::spawn(move || {             // client -> local
-        let mut data = [0 as u8; BUFFER_SIZE];   // using 2048 byte buffer
+    thread::spawn(move || {
+        // client -> local
+        let mut data = [0 as u8; BUFFER_SIZE]; // using 2048 byte buffer
         loop {
             match cl_stream.read(&mut data) {
                 Ok(size) => {
-                    if let Err(_) = forward_tx.send((data, size)) {break}
+                    if let Err(_) = forward_tx.send((data, size)) {
+                        break;
+                    }
                     if size == 0 {
-                        // thread::sleep(Duration::from_millis(1));
-                        break
+                        break;
                     }
-                },
+                }
                 Err(e) => {
                     forward_tx.send((data, 0)).unwrap();
-                    // println!("Failed to read from client, {}", e);
-                    break
+                    break;
                 }
             }
         }
-        cl_stream.shutdown(Shutdown::Read);        
+        cl_stream.shutdown(Shutdown::Read);
     });
 
-    thread::spawn(move || {             // local -> remote
+    thread::spawn(move || {
+        // local -> remote
         loop {
             if let Ok((mut data, size)) = forward_rx.recv() {
                 if size == 0 {
-                    break  
+                    break;
                 }
                 if let Err(_) = lr_stream.write(&mut data[..size]) {
-                    break
+                    break;
                 }
             } else {
-                break
+                break;
             }
-            
         }
         lr_stream.shutdown(Shutdown::Write);
-        return  
+        return;
     });
 
-    thread::spawn(move || {             // remote -> local
+    thread::spawn(move || {
+        // remote -> local
         let mut data = [0 as u8; BUFFER_SIZE];
         loop {
             match rl_stream.read(&mut data) {
                 Ok(size) => {
-                    if let Err(_) = backward_tx.send((data, size)) {break}
+                    if let Err(_) = backward_tx.send((data, size)) {
+                        break;
+                    }
                     if size == 0 {
-                        // thread::sleep(Duration::from_millis(1));
-                        break
+                        break;
                     }
-                },
+                }
                 Err(e) => {
                     backward_tx.send((data, 0)).unwrap();
-                    // println!("Failed to read from remote, {}", e);
-                    break
+                    break;
                 }
-            } 
+            }
         }
         rl_stream.shutdown(Shutdown::Read);
     });
@@ -105,20 +104,15 @@ fn handle_client(mut stream: TcpStream, remote_socket: SocketAddr) {
     loop {
         if let Ok((mut data, size)) = backward_rx.recv() {
             if size == 0 {
-                break  
+                break;
             }
             if let Err(_) = lc_stream.write(&mut data[..size]) {
-                break
+                break;
             }
         } else {
-            break
+            break;
         }
-        
     }
-    lc_stream.shutdown(Shutdown::Write);   
-    return
+    lc_stream.shutdown(Shutdown::Write);
+    return;
 }
-
-    
-    
-