tor_proxy 0.1.2

//! # Tor Proxy
//!
//! `proxy_tor` is a simple Tor proxy server implemented in Rust.

// Import necessary libraries
use std::net::{TcpListener, TcpStream};
use std::thread;
use std::io::{Read, Write};

// Function to handle each client connection
pub fn handle_client(mut stream: TcpStream) {
    let mut buffer = [0; 1024];
    // Continuously read data from the client
    while match stream.read(&mut buffer) {
        Ok(size) => {
            if size > 0 {
                // Add your Tor routing logic here
                // For now, just print the received data
                println!("Received data: {}", String::from_utf8_lossy(&buffer[..size]));
                // Echo back the received data to the client
                stream.write_all(&buffer[..size]).unwrap();
                true
            } else {
                false
            }
        },
        Err(_) => {
            println!("An error occurred, terminating connection with {}", stream.peer_addr().unwrap());
            // Close the connection on error
            stream.shutdown(std::net::Shutdown::Both).unwrap();
            false
        }
    } {}
}

fn main() {
    // Bind to the specified address and port
    let listener = TcpListener::bind("127.0.0.1:8080").expect("Could not bind to address");

    // Accept incoming connections and process them in separate threads
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                // Print information about the new connection
                println!("New connection: {}", stream.peer_addr().unwrap());
                // Spawn a new thread to handle the client connection
                thread::spawn(move || {
                    handle_client(stream)
                });
            }
            Err(e) => {
                // Handle errors in accepting connections
                println!("Error: {}", e);
            }
        }
    }
}