How to know if a non-blocking socket is closed?

Question

I'm trying to write my own TCP Non-Blocking Server to handle multiple long lasting socket connections rather than opening many threads to handle them.

I've written my over-complicated, hard to use syntax but have the issue forms when I'm trying to detect a closed socket.

In a normal threaded TCP Socket Server I would use detected a b'' from the socket.read(size) function, However this is not possible with a nonblocking socket as it will always return a BlockingIOError

I have also tried catching theese following events

except BrokenPipeError:
    conn.abort()
except ConnectionResetError:
    conn.abort()
except ConnectionAbortedError:
    conn.abort()
except socket.error:
    conn.abort()

(conn is a class that houses the client socket and address from socket.accept())

I'm unsure what to do, but here is a deeply simplified extract from my code:

def loop_listen(self):
    while self.running == True:
    cr, addr = self.server.accept()
    crs = SocketHandler(self, cr, addr)
    self.client_handler(crs)
    self.connections.append(crs)
    crs.events["open"]()
    crs.cr.setblocking(0)

def loop_recv(self):
    while self.running == True:
        time.sleep(self.poll_time)

        for conn in self.connections:
        try:
            data = conn.cr.recv(self.poll_size)
            print(data)
            if (data == b''):
                conn.abort()
        except BlockingIOError:
            data = None
        except BrokenPipeError:
            conn.abort()
        except ConnectionResetError:
            conn.abort()
        except ConnectionAbortedError:
            conn.abort()
        except socket.error:
            conn.abort()
        if (data != None):
            conn.events["msg"](data)

(Both loops are separate threads)

And incase you wanted it, here is the conn class

class SocketHandler:
    def __init__(self, server, cr, addr):
        self.server = server
        self.cr = cr
        self.addr = addr
        self.events = {"msg": emptyCallback, "close": "emptyCallback","open":emptyCallback}
        self.cache = b""

    def message(self, func):
        self.events["msg"] = func

    def close(self, func):
        self.events["close"] = func

    def open(self, func):
        self.events["open"] = func

    def send(self, data):
        self.cr.send(data)
    def abort(self):
        self.cr.close()
        self.events["close"]()
        self.server.connections.remove(conn)

This works fine on Windows but on Ubuntu it does not call the conn.abort().

Any help would be greatly appreciated.

Thanks, Sam.

Answer 1

The official way to detect a closed connection on a non-blocking socket is exactly the same as blocking sockets. They return empty data from recv().

Example:

# Server
import socket
import time

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('localhost', 12345))
s.listen(1)

while True:
    conn, addr = s.accept()
    conn.setblocking(0)
    print("New connection from " + str(addr) + ".")
    while True:
        try:
            data = conn.recv(1024)
            if not data:
                break
            print("Received:", data)
        except BlockingIOError:
            time.sleep(0.001) 

    print("Closed.")

# Client
import socket
import time

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('localhost', 12345))

for i in range(5):
    time.sleep(0.3)
    s.send(str(i).encode('utf-8'))
s.close()

There is one special case where this won't work, as described in the official docs, section When Sockets Die. It happens, when sockets don't shut down gracefully. There basically is no way for recv() to detect when a socket is dead without a graceful shutdown. It might be that this is what you are seeing.

There are multiple ways to resolve that. For one, create some kind of timeout that closes and discards a socket if it didn't receive a message for a sensible amount of time. Secondly, you could actively send messages. Detecting a dead socket is much easier for send() than for recv().

Further, this works on Linux. I didn't test it on Windows. The internal implementation of the sockets class is very platform dependent, so it might be a Windows bug.