How does my server know that a client has disconnected? - python-3.x

Question

So i have a TCP connection with a select, to handle multiple clients.
These multiple clients chat between each other having a UDP connection independent of the server.
The server keeps a list with all connected clients and notifies each one of them when a new client arrives or when one disconnects.
I have a working code.
I do not understand how, where in the code of the client, does it send the disconnection information to the server. Because the server receives the information that a client disconnects. BUT HOW
server.py:
import pickle
import select
import socket
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = ('0.0.0.0', 7000)
server.bind(address)
print('Starting up on %s port %s' % address)
input_sockets = [server]
output_sockets = []
clients = []
server.listen(10)
i = 0
while True:
readable, writable, exceptional = select.select(input_sockets, output_sockets, input_sockets)
for s in readable:
if s is server:
i = i+1
client_socket, client_address = s.accept()
print('New connection from client ' + str(i) + ' with address: ' + str(client_address))
client_socket.send(pickle.dumps(clients))
for client in input_sockets:
if client is not server:
client.send(pickle.dumps(client_address))
input_sockets.append(client_socket)
clients.append(client_address)
else:
client_address = s.getpeername()
print("Client with address '" + str(client_address) + "' disconnected")
clients.remove(client_address)
input_sockets.remove(s)
for client in input_sockets:
if client is not server:
client.send(pickle.dumps(client_address))
s.close()
client.py
import socket
import pickle
import threading
import select
def chat(udp_sock):
global done
while not done:
message = input()
if message == "QUIT":
done = True
else:
for client in clients:
udp_sock.sendto(message.encode('utf-8'), client)
done = False
server_address = ('127.0.0.1', 7000)
s_tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s_udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s_tcp.connect(server_address)
clients_data = s_tcp.recv(1024)
clients = pickle.loads(clients_data)
s_udp.bind(s_tcp.getsockname())
reading = threading.Thread(target=chat, args=(s_udp,))
reading.start()
while not done:
r, w, e = select.select([s_tcp, s_udp], [], [], 1)
for s in r:
if s == s_tcp:
addr = s_tcp.recv(1024)
addr = pickle.loads(addr)
if addr in clients:
clients.remove(addr)
print("Client " + str(addr) + " has disconnected.")
else:
clients.append(addr)
print("Client " + str(addr) + " is now connected.")
if s == s_udp:
msg, addr = s_udp.recvfrom(1024)
msg = msg.decode()
print("[" + str(addr) + "]: " + str(msg))
reading.join()
s_tcp.close()
s_udp.close()
enter code here

Answer 1

for s in readable:
if s is server:
...
else:
client_address = s.getpeername()
print("Client with address '" + str(client_address) + "' disconnected")
clients.remove(client_address)
input_sockets.remove(s)
The server simply disconnects a client when select shows that it could read from the client socket. Since the client never sends anything to the server on the TCP connection, the only case where the client socket is readable is when the client disconnects. In this case a recv on the client socket would return '', i.e. no data as a sign that the socket has been disconnected. T
The client thus just needs to disconnect the TCP connection in order to signal to the server that the client is done. This is explicitly done in the code by closing the socket, but would also be implicitly done when the client exits.
s_tcp.close()