TcpStream behaviour and shutdown.

[antglb]

I am writing an application that uses TcpStream to read some data off a tcp socket and process it. The program writing data is in C++ and i cannot change that. in case the TcpStream::read_buf returns 0, I try to reconnect to a different port that i will discover through some utility.

Do I need to manually shutdown the TcpStream or can i just create a new one and bind it to the existing variable? Will the underlying socket of the first TcpStream be dropped when the object gets overwritten by the new function call to connect? If I need a manual shutdown of the socket, why is that API available only on the AsyncWriteExt trait, when the std::net::TcpStream exposes it for the class as a whole?

Also, in case I keep calling read_buf on a TcpStream that returned 0, what will the code do? Could I incur allocation penalties since i would basically be calling into read_buf very often due to the buffer not having data and thus skipping all the data processing parts and going at the beginning of the loop again?

Basically in pseudocode (please ignore the missing async keywords and poor error handling, but look at comment at the bottom):

fn connect() -> TcpStream {
  loop {
    match TcpStream::connect() {
      Ok(s) => return s,
      Err(e) => tokio::time::sleep(5),
    }
  }
}

fn process(buffer: &mut BytesMut, stream: &mut TcpStream) {
    match TcpStream::read_buf(buffer).await {
      Ok(b) => {
        if b == 0 {
          buffer.clear();
          return Err("EOF");
        }
      }
      _ => return Err("err"),
    }
  // do more stuff with the data on the buffer
  }


// inside main or equivalent
let mut buffer = BytesMut::with_capacity(1000);
let mut stream = connect();

tokio::spawn(async move {
  loop {
    if let Err(e) = process(&mut buffer, &mut stream) {
    // Do I need a manual shutdown of TcpStream here?
    // If yes, why is that API available only on the AsyncWriteExt trait?
    stream = connect();
  }
});

[Darksonn]

When you write:

stream = connect();

This will do the following operations:

1. Call connect().
2. Run the destructor of the previous socket in stream.
3. Move the return value of connect() into the stream variable.

Running the destructor is enough to close the socket.

---

Also, in case I keep calling read_buf on a TcpStream that returned 0, what will the code do?

The read_buf method only returns 0 if the read direction of your TcpStream has been closed. Once that happens, you will never get any more data, so all future calls to read_buf will also return 0. You should stop trying to read from it when you get a read of length zero.

---

The AsyncWriteExt::shutdown method doesn't do the same thing as dropping the socket. It will only close the stream in the write direction. That is, the other end of the connection will start getting reads of length zero if they attempt to read more. The read direction is not affected by AsyncWriteExt::shutdown, and you can continue to read until the read direction is closed by the other end of the connection.

You don't have to call shutdown before you drop the socket if you just want to destroy the socket.