mutable borrow of TcpStream inside select!

[hardcore-sushi]

Hi,
I'm a beginner with Tokio so this question could be very stupid but I don't know how to solve my problem.
Here is a simplified version of my code:

async fn receive(stream: &mut tokio::net::TcpStream) -> Vec<u8> {
    let mut size = [0; 4];
    stream.read(&mut size).await.unwrap();
    let size = u32::from_be_bytes(message_len) as usize;
    let mut buffer = vec![0; size];
    stream.read(&mut buffer).await.unwrap();
    buffer
}

#[tokio::main]
async fn main() {
    let (sender, receiver) = tokio::sync::mpsc::channel(32);
    //send the sender to other threads

    let stream = tokio::net::TcpStream::connect(SocketAddr::new("127.0.0.1".parse().unwrap(), 7530)).await.unwrap();
    let mut receive_operation = receive(&mut stream);
    tokio::pin!(receive_operation);
    loop {
        tokio::select! {
            buffer = &mut receive_operation => {
                //now, I would like to parse buffer and reply with stream.write()
                receive_operation.set(receive(&mut stream));
            }
            command = receiver.recv() => {
                //parse then send command with stream.write()
            }
        }
    }
}

The problem is that I can't borrow stream as mutable in any of the select! branches because it's already mutable borrowed when declaring receive_operation. One solution could be to convert stream in std::net::TcpStream with into_std() then cloning it with try_clone() and then reconverting it to tokio::net::TcpStream with from_std but I don't think it's the best solution.

EDIT:
I tried to clone the stream but my real code is a bit more complex. It does some encryption stuff before sending data to the socket. Due to nonces synchronization, I cannot clone the stream (the equivalent in my real code) without breaking the encrypted connection.

Please have you an idea how can I solve this problem ? I need your help ;)

[hardcore-sushi]

OK, I solved this problem by splitting the stream in two parts: a reader and a writer. Then, I edited the receive() function to take ownership of the reader and return it at the end, alongside the buffer. receive_operation is now declared like that:

let receive_operation = receive(reader);

That way, I have a mutable reference to writer everywhere in the loop and ownership of reader in the first select! branch so I can call receive_operation.set(receive(reader)).