Connection reset by peer. Tokio, select

Question

I am writing socks5 proxy server. The program is running asynchronously and I am trying to use tokio::select, but the program terminates due to this error when I want to get the size of the received data:

thread 'tokio-runtime-worker' panicked at 'called `Result::unwrap()` on an `Err` value: Os { code: 54, kind: ConnectionReset, message: "Connection reset by peer" }'

The function where the error occurs:

async fn exchange_loop(mut client: TcpStream, address: SocketAddr, cmd: u8) {
    let mut remote = TcpStream::connect(address).await.unwrap();
    let mut buffer_client: [u8; 4096] = [0; 4096];
    let mut buffer_remote: [u8; 4096] = [0; 4096];

    loop {
        tokio::select! {
            size = client.read(&mut buffer_client) => {
                let size = size.unwrap();
                remote.write(buffer_client.as_ref()).await.unwrap();
                println!("Send from client {} => {} {} KB", client.peer_addr().unwrap(), remote.peer_addr().unwrap(), size as f32 / 1024.);
                if size <= 0 {
                    break;
                };
                buffer_client = [0; 4096];
            }
            size = remote.read(&mut buffer_remote) => {
                let size = size.unwrap();
                client.write(buffer_remote.as_ref()).await.unwrap();
                println!("Send from remote {} => {} {} KB", address, client.peer_addr().unwrap(), size as f32 / 1024.);
                if size <= 0 {
                    break;
                };
                buffer_remote = [0; 4096];
            }
        }
    }
    println!("End connection to {}", address);
}

The peer has forcibly closed the connection. The reason for this is unknown. — Steffen Ullrich, Mar 04 '22 at 19:29
You need to add real error handling in your code and stop mindlessly using `unwrap`. The client terminated the connection, which is a case that a real server should handle gracefully. — Colonel Thirty Two, Mar 06 '22 at 19:58

score 0 · Answer 1 · answered Mar 08 '22 at 21:43

You need to handle errors, as specified in the previous comments. You need to be able to recover from whatever the client does on his side, interrupting the connection for example.

An example how to recover:

if let Ok(actual_size) = size {
    if let Ok(_) = remote.write(buffer_client.as_ref()).await {
        println!("Send from client {} => {} {} KB", client.peer_addr().unwrap(), remote.peer_addr().unwrap(), size as f32 / 1024.);
        if size <= 0 {
            break;
        };

        buffer_client = [0; 4096];
    }
}

I put Ok(_) as I do not know what you expect from the 2nd unwrap.

Connection reset by peer. Tokio, select

1 Answers1