TCP socket not closing properly?

[Wratox]

Hello,

I am using smoltcp on a device setup to accept 4 TCP connections at the same time on the same port(plus one DHCP connection if that makes any difference) and I am able to connect to the device from a pc with a simple program I made(not using smoltcp, I've also tested with telnet), even multiple connections at the same time. However when closing the connection on the pc side the socket on the device with smoltcp doesn't close until it receives an RST from somewhere, which makes the socket unable to accept a new connection until it resets. This means I can make 4 connections and even if I've closed all 4 on the pc side the next connection isn't accepted until the first socket is reset.

My knowledge is limited I admit but from my understanding shouldn't the sockets on both sides do some kind of FIN/ACK exchange and then the sockets close and then are able to accept a new connection?
Should I explicitly close the socket on the smoltcp side? If so, where would I do that? I only want the connection to close when the pc client closes its connection.

My simple program panics when trying to connect for the 5th time with the following message:
code: 10061, kind: ConnectionRefused, message: "No connection could be made because the target machine actively refused it."
Which I guess makes sense since no socket on the device is technically available.

Might as well mention that I am using a w5500 on the device in case that matters in any way.

Here's the most relevant parts of my code(let me know if you need anything else):

let w5500 = w5500::UninitializedDevice::new(w5500::bus::FourWire::new(spi))
    .initialize_macraw(MacAddress::new(0, 1, 2, 3, 4, 5))
    .unwrap();

let mut mac = Mac::W5500(w5500);

info!("Creating mac address");
let mac_address_bytes = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab]; // TODO: make sure this is unique!

let hardware_address = HardwareAddress::Ethernet(EthernetAddress::from_bytes(&mac_address_bytes));

let device = &mut mac;

let mut config = smoltcp::iface::Config::new(hardware_address);
config.hardware_addr = smoltcp::wire::HardwareAddress::Ethernet(EthernetAddress([0, 1, 2, 3, 4, 5]).into());

let mut iface = smoltcp::iface::Interface::new(config, device, mock_clock.elapsed());

iface
    .routes_mut()
    .add_default_ipv4_route(Ipv4Address::new(0, 0, 0, 0))
    .unwrap();

iface.update_ip_addrs(|addrs| {
    addrs
        .push(IpCidr::new(smoltcp::wire::IpAddress::v4(0, 0, 0, 0), 0))
        .unwrap()
});

// Create sockets
let dhcp_socket = dhcpv4::Socket::new();
let net_store = cortex_m::singleton!(: NetStorage = NetStorage::new()).unwrap();
let mut sockets = smoltcp::iface::SocketSet::new(&mut net_store.sockets[..]);

let mut tcp_handles: Vec<smoltcp::iface::SocketHandle, NUM_TCP_SOCKETS> = Vec::new();

for storage in net_store.tcp_socket_storage[..].iter_mut() {
    let tcp_socket = {
        let rx_buffer = smoltcp::socket::tcp::SocketBuffer::new(&mut storage.rx_storage[..]);
        let tx_buffer = smoltcp::socket::tcp::SocketBuffer::new(&mut storage.tx_storage[..]);

        smoltcp::socket::tcp::Socket::new(rx_buffer, tx_buffer)
    };

    tcp_handles.push(sockets.add(tcp_socket)).unwrap();
}

let dhcp_handle = sockets.add(dhcp_socket);

// Aquire config via DHCP
loop {
    iface.poll(mock_clock.elapsed(), device, &mut sockets);
    mock_clock.advance(smoltcp::time::Duration::from_millis(1));

    let event = sockets.get_mut::<dhcpv4::Socket>(dhcp_handle).poll();
    match event {
        None => {}
        Some(dhcpv4::Event::Configured(config)) => {
            info!("DHCP config acquired!");

            set_ipv4_addr(&mut iface, config.address);

            if let Some(router) = config.router {
                iface.routes_mut().add_default_ipv4_route(router).unwrap();
            } else {
                iface.routes_mut().remove_default_ipv4_route();
            }

            info!("{}", config.address);
            break;
        }
    Some(dhcpv4::Event::Deconfigured) => {
        info!("DHCP lost config!");
        set_ipv4_addr(&mut iface, Ipv4Cidr::new(Ipv4Address::UNSPECIFIED, 0));
        iface.routes_mut().remove_default_ipv4_route();
        }
    }
}

// Poll sockets
loop {
    iface.poll(mock_clock.elapsed(), device, &mut sockets);
    mock_clock.advance(smoltcp::time::Duration::from_millis(1));

    for (i, tcp_handle) in tcp_handles.iter().enumerate() {
        let socket = sockets.get_mut::<smoltcp::socket::tcp::Socket>(*tcp_handle);
        if !socket.is_open() {
            socket.listen(502).unwrap();
            info!("Reopened socket {}", i);
        }

        if socket.state() == smoltcp::socket::tcp::State::Established {
            let mut buf: ModbusFrameBuf = [0; 256];
            match socket.recv_slice(&mut buf) {
                Ok(0) => (),
                Ok(size) => {
                    info!("Received: {} on socket {}", buf[0..size], i);
                    if socket.can_send() {
                        buf[0..size].reverse();
                        socket.send_slice(&buf[0..size]).unwrap();
                    } else {
                        error!("Could not send response");
                    }
                }
                Err(e) => defmt::error!("{}", e),
            }
        }
    }
}