Rust TCP Proxy to pipe http, ssh and other tcp traffic - tcp

Question

I am new to rust and as learning project I want to create a tcp proxy. Tokio overwhelmed me and I could not find the proper documentation to understand how it works. So I tried to go with std net modules but I stuck at properly piping the traffic. I bound multiple listeners in their own threads and want to pipe the traffic forth and back like a proper tcp proxy would do. Unfortunately I seem to don't understand how that has to work in Rust. Can someone give me an example without 3rd party dependencies?
Here is my code. handle_connection gets called from accepting the connection.
fn forward(direction: &str, input: &mut BufReader<TcpStream>, output: &mut BufWriter<TcpStream>) {
loop {
let mut buffer = [0;1024];
debug!("{} Reading", direction);
match input.read(&mut buffer) {
Ok(bytes) => {
debug!("Read {} bytes", bytes);
if bytes < 1 {
break;
}
match output.write_all(&mut buffer) {
Ok(_) => {
debug!("Forwarded {:#?} bytes", bytes);
output.flush();
if bytes < 1024 {
break; // abort when everything is sent
}
},
Err(error) => panic!("Could not forward: {}", error)
}
},
Err(error) => panic!("Could not read: {}", error)
}
}
}
fn handle_connection(mapping: ProxyMapping, incoming: TcpStream) -> Result<(), String> {
info!("Incoming connection from {}", incoming.peer_addr().map_err(|e| format!("{}", e))?);
// Try to connect to target
let outgoing = TcpStream::connect_timeout(
&mapping.get_target_addr()?,
Duration::from_secs(1)
)?;
// forward tcp steam
debug!("Start sync");
let input_clone = input.try_clone()
.map_err(|error| format!("Couldn't clone {}", error))?;
let mut input_read = BufReader::new(input);
let mut input_write = BufWriter::new(input_clone);
let output_clone = output.try_clone()
.map_err(|error| format!("Couldn't clone {}", error))?;
let mut output_read = BufReader::new(output);
let mut output_write = BufWriter::new(output_clone);
debug!("spawn sync");
loop {
debug!("Forward");
forward("forward", &mut input_read, &mut output_write);
debug!("Backward");
forward("backward",&mut output_read, &mut input_write);
}
Ok(())
}
So far it proxies some data but for http requests it stops at backward reading as I don't know yet when I should shutdown a connection. After some time it just floods the log with read 0 bytes. I added a loop for the sync as for one tcp connection multiple packets could be sent. Any ideas how to improve this?