init version

5 files changed, 204 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..ea8c4bf
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+/target
diff --git a/Cargo.lock b/Cargo.lock
new file mode 100644
index 0000000..17b9b81
--- /dev/null
+++ b/Cargo.lock
@@ -0,0 +1,32 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "zagan-bet"
+version = "0.1.0"
+dependencies = [
+ "winapi",
+]
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..33903f4
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "zagan-bet"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+winapi = { version = "0.3", features = ["consoleapi", "processenv", "wincon", "minwindef", "winbase"] }
diff --git a/src/bin/client.rs b/src/bin/client.rs
new file mode 100644
index 0000000..45c5090
--- /dev/null
+++ b/src/bin/client.rs
@@ -0,0 +1,98 @@
+use std::io::{BufRead, BufReader, Write, stdin, stdout};
+use std::net::TcpStream;
+use std::time::Instant;
+
+#[cfg(windows)]
+mod win {
+    use std::io;
+    use std::os::windows::io::AsRawHandle;
+    use winapi::um::consoleapi::GetConsoleMode;
+    use winapi::um::consoleapi::SetConsoleMode;
+    use winapi::um::wincon::ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+    use winapi::um::winbase::STD_OUTPUT_HANDLE;
+    use winapi::um::processenv::GetStdHandle;
+    use winapi::shared::minwindef::DWORD;
+
+    pub fn enable_vt() -> io::Result<()> {
+        unsafe {
+            let h = GetStdHandle(STD_OUTPUT_HANDLE);
+            if h.is_null() { return Err(io::Error::last_os_error()); }
+
+            let mut mode: DWORD = 0;
+            if GetConsoleMode(h, &mut mode) == 0 {
+                return Err(io::Error::last_os_error());
+            }
+            let new = mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+            if SetConsoleMode(h, new) == 0 {
+                return Err(io::Error::last_os_error());
+            }
+            Ok(())
+        }
+    }
+}
+
+fn main() {
+    #[cfg(windows)]
+    win::enable_vt().unwrap();
+
+    let mut addr: Option<String>;
+    let mut stream: Option<TcpStream> = None;
+    loop {
+        print!("Command: ");
+        stdout().flush().unwrap();
+        let mut line = String::new();
+        stdin().read_line(&mut line).unwrap();
+        let line = line.trim();
+        if line.is_empty() {
+            continue;
+        }
+        let parts: Vec<&str> = line.splitn(2, ' ').collect();
+        match parts[0] {
+            "connect" => {
+                if parts.len() < 2 {
+                    println!("Usage: connect <addr>");
+                    continue;
+                }
+                addr = Some(parts[1].to_string());
+                match TcpStream::connect(addr.as_ref().unwrap()) {
+                    Ok(s) => {
+                        let mut ping_writer = s.try_clone().unwrap();
+                        let mut ping_reader = BufReader::new(s.try_clone().unwrap());
+                        let start = Instant::now();
+                        writeln!(ping_writer, "PING").unwrap();
+                        let mut response = String::new();
+                        ping_reader.read_line(&mut response).unwrap();
+                        let elapsed = start.elapsed();
+                        println!("Connected to {} with ping delay: {:?}", addr.as_ref().unwrap(), elapsed);
+                        stream = Some(s);
+                    }
+                    Err(e) => {
+                        println!("Failed to connect: {}", e);
+                    }
+                }
+            }
+            "send" => {
+                if stream.is_none() {
+                    println!("Not connected. Use 'connect <addr>' first.");
+                    continue;
+                }
+                if parts.len() < 2 {
+                    println!("Usage: send <message>");
+                    continue;
+                }
+                let msg = parts[1];
+                let s = stream.as_mut().unwrap();
+                let writer_stream = s.try_clone().unwrap();
+                let mut writer = writer_stream;
+                let response_reader_stream = s.try_clone().unwrap();
+                let mut response_reader = BufReader::new(response_reader_stream);
+                writeln!(writer, "{}", msg).unwrap();
+                let mut response = String::new();
+                response_reader.read_line(&mut response).unwrap();
+                println!("Echo: {}", response.trim());
+            }
+            "quit" => break,
+            _ => println!("Unknown command. Available: connect, send, quit"),
+        }
+    }
+}
diff --git a/src/bin/server.rs b/src/bin/server.rs
new file mode 100644
index 0000000..215d2ae
--- /dev/null
+++ b/src/bin/server.rs
@@ -0,0 +1,66 @@
+use std::io::{BufRead, BufReader, Write};
+use std::net::TcpListener;
+use std::thread;
+
+fn handle_client(stream: std::net::TcpStream) {
+    println!("Client connected");
+    let reader_stream = stream.try_clone().unwrap();
+    let reader = BufReader::new(reader_stream);
+    let mut writer = stream;
+    for line in reader.lines() {
+        let line = line.unwrap();
+        println!("Received: {}", line);
+        writeln!(writer, "{}", line).unwrap();
+    }
+    println!("Client disconnected");
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    let mut ip = "127.0.0.1".to_string();
+    let mut port = 8080;
+    let mut i = 1;
+    while i < args.len() {
+        if args[i] == "-p" {
+            if i + 1 < args.len() {
+                port = args[i + 1].parse::<u16>().unwrap_or_else(|_| {
+                    eprintln!("Invalid port number: {}", args[i + 1]);
+                    std::process::exit(1);
+                });
+                i += 2;
+            } else {
+                eprintln!("-p requires a port number");
+                std::process::exit(1);
+            }
+        } else if args[i] == "-i" {
+            if i + 1 < args.len() {
+                ip = args[i + 1].clone();
+                if ip != "127.0.0.1" && ip != "0.0.0.0" {
+                    eprintln!("Invalid IP address: {}. Must be 127.0.0.1 or 0.0.0.0", ip);
+                    std::process::exit(1);
+                }
+                i += 2;
+            } else {
+                eprintln!("-i requires an IP address");
+                std::process::exit(1);
+            }
+        } else {
+            eprintln!("Unknown argument: {}", args[i]);
+            std::process::exit(1);
+        }
+    }
+    let listener = match TcpListener::bind(format!("{}:{}", ip, port)) {
+        Ok(l) => l,
+        Err(e) => {
+            eprintln!("Failed to bind to {}:{}: {}", ip, port, e);
+            std::process::exit(1);
+        }
+    };
+    println!("Server listening on {}", listener.local_addr().unwrap());
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
+        thread::spawn(move || {
+            handle_client(stream);
+        });
+    }
+}