mirror of
https://github.com/vcmi/vcmi.git
synced 2025-08-13 19:54:17 +02:00
Remove proxy server from vcmi repo
This commit is contained in:
nordsoft
628
proxyServer.py
628
proxyServer.py
@@ -1,628 +0,0 @@
|
||||
import socket
|
||||
import re
|
||||
import uuid
|
||||
import struct
|
||||
import logging
|
||||
from threading import Thread
|
||||
|
||||
PROTOCOL_VERSION_MIN = 1
|
||||
PROTOCOL_VERSION_MAX = 1
|
||||
|
||||
# server's IP address
|
||||
SERVER_HOST = "0.0.0.0"
|
||||
SERVER_PORT = 5002 # port we want to use
|
||||
|
||||
#logging
|
||||
logHandlerHighlevel = logging.FileHandler('proxyServer.log')
|
||||
logHandlerHighlevel.setLevel(logging.INFO)
|
||||
|
||||
logHandlerLowlevel = logging.FileHandler('proxyServer_debug.log')
|
||||
logHandlerLowlevel.setLevel(logging.DEBUG)
|
||||
|
||||
logging.basicConfig(handlers=[logHandlerHighlevel, logHandlerLowlevel], level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S')
|
||||
|
||||
def receive_packed(sock):
|
||||
# Read message length and unpack it into an integer
|
||||
raw_msglen = recvall(sock, 4)
|
||||
if not raw_msglen:
|
||||
return None
|
||||
msglen = struct.unpack('<I', raw_msglen)[0]
|
||||
# Read the message data
|
||||
return recvall(sock, msglen)
|
||||
|
||||
def recvall(sock, n):
|
||||
# Helper function to recv n bytes or return None if EOF is hit
|
||||
data = bytearray()
|
||||
while len(data) < n:
|
||||
packet = sock.recv(n - len(data))
|
||||
if not packet:
|
||||
return None
|
||||
data.extend(packet)
|
||||
return data
|
||||
|
||||
|
||||
class GameConnection:
|
||||
server: socket # socket to vcmiserver
|
||||
client: socket # socket to vcmiclient
|
||||
serverInit = False # if vcmiserver already connected
|
||||
clientInit = False # if vcmiclient already connected
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.server = None
|
||||
self.client = None
|
||||
pass
|
||||
|
||||
|
||||
class Room:
|
||||
total = 1 # total amount of players
|
||||
joined = 0 # amount of players joined to the session
|
||||
password = "" # password to connect
|
||||
protected = False # if True, password is required to join to the session
|
||||
name: str # name of session
|
||||
host: socket # player socket who created the room
|
||||
players = [] # list of sockets of players, joined to the session
|
||||
started = False
|
||||
|
||||
def __init__(self, host: socket, name: str) -> None:
|
||||
self.name = name
|
||||
self.host = host
|
||||
self.players = [host]
|
||||
self.joined += 1
|
||||
|
||||
def isJoined(self, player: socket) -> bool:
|
||||
return player in self.players
|
||||
|
||||
def join(self, player: socket):
|
||||
if not self.isJoined(player) and self.joined < self.total:
|
||||
self.players.append(player)
|
||||
self.joined += 1
|
||||
|
||||
def leave(self, player: socket):
|
||||
if not self.isJoined(player) or player == self.host:
|
||||
return
|
||||
|
||||
self.players.remove(player)
|
||||
self.joined -= 1
|
||||
|
||||
|
||||
class Session:
|
||||
name: str # name of session
|
||||
host_uuid: str # uuid of vcmiserver for hosting player
|
||||
clients_uuid: list # list od vcmiclients uuid
|
||||
players: list # list of sockets of players, joined to the session
|
||||
connections: list # list of GameConnections for vcmiclient/vcmiserver (game mode)
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.name = ""
|
||||
self.host_uuid = ""
|
||||
self.clients_uuid = []
|
||||
self.connections = []
|
||||
pass
|
||||
|
||||
def addConnection(self, conn: socket, isServer: bool):
|
||||
#find uninitialized server connection
|
||||
for gc in self.connections:
|
||||
if isServer and not gc.serverInit:
|
||||
gc.server = conn
|
||||
gc.serverInit = True
|
||||
if not isServer and not gc.clientInit:
|
||||
gc.client = conn
|
||||
gc.clientInit = True
|
||||
|
||||
#no existing connection - create the new one
|
||||
gc = GameConnection()
|
||||
if isServer:
|
||||
gc.server = conn
|
||||
gc.serverInit = True
|
||||
else:
|
||||
gc.client = conn
|
||||
gc.clientInit = True
|
||||
self.connections.append(gc)
|
||||
|
||||
def removeConnection(self, conn: socket):
|
||||
newConnections = []
|
||||
for c in self.connections:
|
||||
if c.server == conn:
|
||||
c.server = None
|
||||
c.serverInit = False
|
||||
if c.client == conn:
|
||||
c.client = None
|
||||
c.clientInit = False
|
||||
if c.server != None or c.client != None:
|
||||
newConnections.append(c)
|
||||
self.connections = newConnections
|
||||
|
||||
def validPipe(self, conn) -> bool:
|
||||
for gc in self.connections:
|
||||
if gc.server == conn or gc.client == conn:
|
||||
return gc.serverInit and gc.clientInit
|
||||
return False
|
||||
|
||||
def getPipe(self, conn) -> socket:
|
||||
for gc in self.connections:
|
||||
if gc.server == conn:
|
||||
return gc.client
|
||||
if gc.client == conn:
|
||||
return gc.server
|
||||
|
||||
|
||||
class Client:
|
||||
auth: bool
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.auth = False
|
||||
|
||||
|
||||
class ClientLobby(Client):
|
||||
joined: bool
|
||||
username: str
|
||||
room: Room
|
||||
protocolVersion: int
|
||||
encoding: str
|
||||
ready: bool
|
||||
vcmiversion: str #TODO: check version compatibility
|
||||
|
||||
def __init__(self) -> None:
|
||||
super().__init__()
|
||||
self.room = None
|
||||
self.joined = False
|
||||
self.username = ""
|
||||
self.protocolVersion = 0
|
||||
self.encoding = 'utf8'
|
||||
self.ready = False
|
||||
self.vcmiversion = ""
|
||||
|
||||
|
||||
class ClientPipe(Client):
|
||||
apptype: str #client/server
|
||||
prevmessages: list
|
||||
session: Session
|
||||
uuid: str
|
||||
|
||||
def __init__(self) -> None:
|
||||
super().__init__()
|
||||
self.prevmessages = []
|
||||
self.session = None
|
||||
self.apptype = ""
|
||||
self.uuid = ""
|
||||
|
||||
|
||||
class Sender:
|
||||
address: str #full client address
|
||||
client: Client
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.client = None
|
||||
pass
|
||||
|
||||
def isLobby(self) -> bool:
|
||||
return isinstance(self.client, ClientLobby)
|
||||
|
||||
def isPipe(self) -> bool:
|
||||
return isinstance(self.client, ClientPipe)
|
||||
|
||||
|
||||
# create a TCP socket
|
||||
s = socket.socket()
|
||||
# make the port as reusable port
|
||||
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
||||
# bind the socket to the address we specified
|
||||
s.bind((SERVER_HOST, SERVER_PORT))
|
||||
# listen for upcoming connections
|
||||
s.listen(10)
|
||||
logging.critical(f"[*] Listening as {SERVER_HOST}:{SERVER_PORT}")
|
||||
|
||||
# active rooms
|
||||
rooms = {}
|
||||
|
||||
# list of active sessions
|
||||
sessions = []
|
||||
|
||||
# initialize list/set of all connected client's sockets
|
||||
client_sockets = {}
|
||||
|
||||
|
||||
def handleDisconnection(client: socket):
|
||||
logging.warning(f"[!] Disconnecting client {client}")
|
||||
|
||||
if not client in client_sockets:
|
||||
return
|
||||
|
||||
sender = client_sockets[client]
|
||||
if sender.isLobby() and sender.client.joined:
|
||||
if not sender.client.room.started:
|
||||
if sender.client.room.host == client:
|
||||
#destroy the session, sending messages inside the function
|
||||
deleteRoom(sender.client.room)
|
||||
else:
|
||||
sender.client.room.leave(client)
|
||||
sender.client.joined = False
|
||||
message = f":>>KICK:{sender.client.room.name}:{sender.client.username}"
|
||||
broadcast(sender.client.room.players, message.encode())
|
||||
updateStatus(sender.client.room)
|
||||
updateRooms()
|
||||
|
||||
if sender.isPipe() and sender.client.auth:
|
||||
if sender.client.session in sessions:
|
||||
sender.client.session.removeConnection(client)
|
||||
if not len(sender.client.session.connections):
|
||||
logging.warning(f"[*] Destroying session {sender.client.session.name}")
|
||||
sessions.remove(sender.client.session)
|
||||
|
||||
client.close()
|
||||
client_sockets.pop(client)
|
||||
|
||||
|
||||
def send(client: socket, message: str):
|
||||
if client in client_sockets.keys():
|
||||
sender = client_sockets[client]
|
||||
client.send(message.encode(errors='replace'))
|
||||
|
||||
|
||||
def broadcast(clients: list, message: str):
|
||||
for c in clients:
|
||||
if client_sockets[c].isLobby() and client_sockets[c].client.auth:
|
||||
send(c, message)
|
||||
|
||||
|
||||
def sendRooms(client: socket):
|
||||
msg2 = ""
|
||||
counter = 0
|
||||
for s in rooms.values():
|
||||
if not s.started:
|
||||
msg2 += f":{s.name}:{s.joined}:{s.total}:{s.protected}"
|
||||
counter += 1
|
||||
msg = f":>>SESSIONS:{counter}{msg2}"
|
||||
|
||||
send(client, msg)
|
||||
|
||||
|
||||
def updateRooms():
|
||||
for s in client_sockets.keys():
|
||||
sendRooms(s)
|
||||
|
||||
|
||||
def deleteRoom(room: Room):
|
||||
msg = f":>>KICK:{room.name}"
|
||||
for player in room.players:
|
||||
client_sockets[player].client.joined = False
|
||||
msg2 = msg + f":{client_sockets[player].client.username}"
|
||||
send(player, msg2)
|
||||
|
||||
logging.warning(f"[*] Destroying room {room.name}")
|
||||
rooms.pop(room.name)
|
||||
|
||||
|
||||
def updateStatus(room: Room):
|
||||
msg = f":>>STATUS:{room.joined}"
|
||||
for player in room.players:
|
||||
msg += f":{client_sockets[player].client.username}:{client_sockets[player].client.ready}"
|
||||
broadcast(room.players, msg)
|
||||
|
||||
|
||||
def startRoom(room: Room):
|
||||
room.started = True
|
||||
session = Session()
|
||||
session.name = room.name
|
||||
sessions.append(session)
|
||||
logging.warning(f"[*] Starting session {session.name}")
|
||||
session.host_uuid = str(uuid.uuid4())
|
||||
hostMessage = f":>>HOST:{session.host_uuid}:{room.joined - 1}" #one client will be connected locally
|
||||
logging.debug(f" host: {session.host_uuid} connections {room.joined - 1}")
|
||||
#host message must be before start message
|
||||
send(room.host, hostMessage)
|
||||
|
||||
for player in room.players:
|
||||
_uuid = str(uuid.uuid4())
|
||||
session.clients_uuid.append(_uuid)
|
||||
msg = f":>>START:{_uuid}"
|
||||
send(player, msg)
|
||||
#remove this connection
|
||||
player.close
|
||||
client_sockets.pop(player)
|
||||
|
||||
#this room shall not exist anymore
|
||||
logging.info(f"[*] Destroying room {room.name}")
|
||||
rooms.pop(room.name)
|
||||
|
||||
|
||||
def dispatch(cs: socket, sender: Sender, arr: bytes):
|
||||
|
||||
if arr == None or len(arr) == 0:
|
||||
return
|
||||
|
||||
#check for game mode connection
|
||||
msg = str(arr)
|
||||
if msg.find("Aiya!") != -1:
|
||||
sender.client = ClientPipe()
|
||||
logging.debug(" vcmi recognized")
|
||||
|
||||
if sender.isPipe():
|
||||
if sender.client.auth: #if already playing - sending raw bytes as is
|
||||
sender.client.prevmessages.append(arr)
|
||||
else:
|
||||
sender.client.prevmessages.append(struct.pack('<I', len(arr)) + arr) #pack message
|
||||
logging.debug(" packing message")
|
||||
#search fo application type in the message
|
||||
match = re.search(r"\((\w+)\)", msg)
|
||||
_appType = ''
|
||||
if match != None:
|
||||
_appType = match.group(1)
|
||||
sender.client.apptype = _appType
|
||||
|
||||
#extract uuid from message
|
||||
_uuid = arr.decode()
|
||||
logging.debug(f" decoding {_uuid}")
|
||||
if not _uuid == '' and not sender.client.apptype == '':
|
||||
#search for uuid
|
||||
for session in sessions:
|
||||
#verify uuid of connected application
|
||||
if _uuid.find(session.host_uuid) != -1 and sender.client.apptype == "server":
|
||||
logging.info(f" apptype {sender.client.apptype} uuid {_uuid}")
|
||||
session.addConnection(cs, True)
|
||||
sender.client.session = session
|
||||
sender.client.auth = True
|
||||
#read boolean flag for the endian
|
||||
# this is workaround to send only one remaining byte
|
||||
# WARNING: reversed byte order is not supported
|
||||
sender.client.prevmessages.append(cs.recv(1))
|
||||
logging.info(f" binding server connection to session {session.name}")
|
||||
break
|
||||
|
||||
if sender.client.apptype == "client":
|
||||
for p in session.clients_uuid:
|
||||
if _uuid.find(p) != -1:
|
||||
logging.info(f" apptype {sender.client.apptype} uuid {_uuid}")
|
||||
#client connection
|
||||
session.addConnection(cs, False)
|
||||
sender.client.session = session
|
||||
sender.client.auth = True
|
||||
#read boolean flag for the endian
|
||||
# this is workaround to send only one remaining byte
|
||||
# WARNING: reversed byte order is not supported
|
||||
sender.client.prevmessages.append(cs.recv(1))
|
||||
logging.info(f" binding client connection to session {session.name}")
|
||||
break
|
||||
|
||||
#game mode
|
||||
if sender.isPipe() and sender.client.auth and sender.client.session.validPipe(cs):
|
||||
#send messages from queue
|
||||
opposite = sender.client.session.getPipe(cs)
|
||||
for x in client_sockets[opposite].client.prevmessages:
|
||||
cs.sendall(x)
|
||||
client_sockets[opposite].client.prevmessages.clear()
|
||||
|
||||
for x in sender.client.prevmessages:
|
||||
opposite.sendall(x)
|
||||
|
||||
sender.client.prevmessages.clear()
|
||||
return
|
||||
|
||||
#we are in pipe mode but game still not started - waiting other clients to connect
|
||||
if sender.isPipe():
|
||||
logging.debug(f" waiting other clients")
|
||||
return
|
||||
|
||||
#intialize lobby mode
|
||||
if not sender.isLobby():
|
||||
if len(arr) < 2:
|
||||
logging.critical("[!] Error: unknown client tries to connect")
|
||||
#TODO: block address? close the socket?
|
||||
return
|
||||
|
||||
sender.client = ClientLobby()
|
||||
|
||||
# first byte is protocol version
|
||||
sender.client.protocolVersion = arr[0]
|
||||
if arr[0] < PROTOCOL_VERSION_MIN or arr[0] > PROTOCOL_VERSION_MAX:
|
||||
logging.critical(f"[!] Error: client has incompatbile protocol version {arr[0]}")
|
||||
send(cs, ":>>ERROR:Cannot connect to remote server due to protocol incompatibility")
|
||||
return
|
||||
|
||||
# second byte is an encoding str size
|
||||
if arr[1] == 0:
|
||||
sender.client.encoding = "utf8"
|
||||
else:
|
||||
if len(arr) < arr[1] + 2:
|
||||
send(cs, ":>>ERROR:Protocol error")
|
||||
return
|
||||
# read encoding string
|
||||
sender.client.encoding = arr[2:(arr[1] + 2)].decode(errors='ignore')
|
||||
arr = arr[(arr[1] + 2):]
|
||||
msg = str(arr)
|
||||
|
||||
msg = arr.decode(encoding=sender.client.encoding, errors='replace')
|
||||
_open = msg.partition('<')
|
||||
_close = _open[2].partition('>')
|
||||
if _open[0] != '' or _open[1] == '' or _open[2] == '' or _close[0] == '' or _close[1] == '':
|
||||
logging.error(f"[!] Incorrect message from {sender.address}: {msg}")
|
||||
return
|
||||
|
||||
_nextTag = _close[2].partition('<')
|
||||
tag = _close[0]
|
||||
tag_value = _nextTag[0]
|
||||
|
||||
#greetings to the server
|
||||
if tag == "GREETINGS":
|
||||
if sender.client.auth:
|
||||
logging.error(f"[!] Greetings from authorized user {sender.client.username} {sender.address}")
|
||||
send(cs, ":>>ERROR:User already authorized")
|
||||
return
|
||||
|
||||
if len(tag_value) < 3:
|
||||
send(cs, f":>>ERROR:Too short username {tag_value}")
|
||||
return
|
||||
|
||||
for user in client_sockets.values():
|
||||
if user.isLobby() and user.client.username == tag_value:
|
||||
send(cs, f":>>ERROR:Can't connect with the name {tag_value}. This login is already occpupied")
|
||||
return
|
||||
|
||||
logging.info(f"[*] {sender.address} autorized as {tag_value}")
|
||||
sender.client.username = tag_value
|
||||
sender.client.auth = True
|
||||
sendRooms(cs)
|
||||
|
||||
#VCMI version received
|
||||
if tag == "VER" and sender.client.auth:
|
||||
logging.info(f"[*] User {sender.client.username} has version {tag_value}")
|
||||
sender.client.vcmiversion = tag_value
|
||||
|
||||
#message received
|
||||
if tag == "MSG" and sender.client.auth:
|
||||
message = f":>>MSG:{sender.client.username}:{tag_value}"
|
||||
if sender.client.joined:
|
||||
broadcast(sender.client.room.players, message) #send message only to players in the room
|
||||
else:
|
||||
targetClients = [i for i in client_sockets.keys() if not client_sockets[i].client.joined]
|
||||
broadcast(targetClients, message)
|
||||
|
||||
#new room
|
||||
if tag == "NEW" and sender.client.auth and not sender.client.joined:
|
||||
if tag_value in rooms:
|
||||
#refuse creating game
|
||||
message = f":>>ERROR:Cannot create session with name {tag_value}, session with this name already exists"
|
||||
send(cs, message)
|
||||
return
|
||||
|
||||
if tag_value == "" or tag_value.startswith(" ") or len(tag_value) < 3:
|
||||
#refuse creating game
|
||||
message = f":>>ERROR:Cannot create session with invalid name {tag_value}"
|
||||
send(cs, message)
|
||||
return
|
||||
|
||||
rooms[tag_value] = Room(cs, tag_value)
|
||||
sender.client.joined = True
|
||||
sender.client.ready = False
|
||||
sender.client.room = rooms[tag_value]
|
||||
|
||||
#set password for the session
|
||||
if tag == "PSWD" and sender.client.auth and sender.client.joined and sender.client.room.host == cs:
|
||||
sender.client.room.password = tag_value
|
||||
sender.client.room.protected = bool(tag_value != "")
|
||||
|
||||
#set amount of players to the new room
|
||||
if tag == "COUNT" and sender.client.auth and sender.client.joined and sender.client.room.host == cs:
|
||||
if sender.client.room.total != 1:
|
||||
#refuse changing amount of players
|
||||
message = f":>>ERROR:Changing amount of players is not possible for existing session"
|
||||
send(cs, message)
|
||||
return
|
||||
|
||||
if int(tag_value) < 2 or int(tag_value) > 8:
|
||||
#refuse and cleanup room
|
||||
deleteRoom(sender.client.room)
|
||||
message = f":>>ERROR:Cannot create room with invalid amount of players"
|
||||
send(cs, message)
|
||||
return
|
||||
|
||||
sender.client.room.total = int(tag_value)
|
||||
message = f":>>CREATED:{sender.client.room.name}"
|
||||
send(cs, message)
|
||||
#now room is ready to be broadcasted
|
||||
message = f":>>JOIN:{sender.client.room.name}:{sender.client.username}"
|
||||
send(cs, message)
|
||||
updateStatus(sender.client.room)
|
||||
updateRooms()
|
||||
|
||||
#join session
|
||||
if tag == "JOIN" and sender.client.auth and not sender.client.joined:
|
||||
if tag_value not in rooms:
|
||||
message = f":>>ERROR:Room with name {tag_value} doesn't exist"
|
||||
send(cs, message)
|
||||
return
|
||||
|
||||
if rooms[tag_value].joined >= rooms[tag_value].total:
|
||||
message = f":>>ERROR:Room {tag_value} is full"
|
||||
send(cs, message)
|
||||
return
|
||||
|
||||
if rooms[tag_value].started:
|
||||
message = f":>>ERROR:Session {tag_value} is started"
|
||||
send(cs, message)
|
||||
return
|
||||
|
||||
sender.client.joined = True
|
||||
sender.client.ready = False
|
||||
sender.client.room = rooms[tag_value]
|
||||
|
||||
if tag == "PSWD" and sender.client.auth and sender.client.joined and sender.client.room.host != cs:
|
||||
if not sender.client.room.protected or sender.client.room.password == tag_value:
|
||||
sender.client.room.join(cs)
|
||||
message = f":>>JOIN:{sender.client.room.name}:{sender.client.username}"
|
||||
broadcast(sender.client.room.players, message)
|
||||
updateStatus(sender.client.room)
|
||||
updateRooms()
|
||||
|
||||
else:
|
||||
sender.client.joined = False
|
||||
message = f":>>ERROR:Incorrect password"
|
||||
send(cs, message)
|
||||
return
|
||||
|
||||
#leaving session
|
||||
if tag == "LEAVE" and sender.client.auth and sender.client.joined and sender.client.room.name == tag_value:
|
||||
if sender.client.room.host == cs:
|
||||
#destroy the session, sending messages inside the function
|
||||
deleteRoom(sender.client.room)
|
||||
else:
|
||||
message = f":>>KICK:{sender.client.room.name}:{sender.client.username}"
|
||||
broadcast(sender.client.room.players, message)
|
||||
sender.client.room.leave(cs)
|
||||
sender.client.joined = False
|
||||
updateStatus(sender.client.room)
|
||||
updateRooms()
|
||||
|
||||
if tag == "READY" and sender.client.auth and sender.client.joined and sender.client.room.name == tag_value:
|
||||
if sender.client.room.joined > 0 and sender.client.room.host == cs:
|
||||
startRoom(sender.client.room)
|
||||
updateRooms()
|
||||
|
||||
dispatch(cs, sender, (_nextTag[1] + _nextTag[2]).encode())
|
||||
|
||||
|
||||
def listen_for_client(cs):
|
||||
"""
|
||||
This function keep listening for a message from `cs` socket
|
||||
Whenever a message is received, broadcast it to all other connected clients
|
||||
"""
|
||||
while True:
|
||||
try:
|
||||
# keep listening for a message from `cs` socket
|
||||
if client_sockets[cs].isPipe() and client_sockets[cs].client.auth:
|
||||
msg = cs.recv(4096)
|
||||
else:
|
||||
msg = receive_packed(cs)
|
||||
|
||||
if msg == None or msg == b'':
|
||||
handleDisconnection(cs)
|
||||
return
|
||||
|
||||
dispatch(cs, client_sockets[cs], msg)
|
||||
|
||||
except Exception as e:
|
||||
# client no longer connected
|
||||
logging.error(f"[!] Error: {e}")
|
||||
handleDisconnection(cs)
|
||||
return
|
||||
|
||||
|
||||
while True:
|
||||
# we keep listening for new connections all the time
|
||||
client_socket, client_address = s.accept()
|
||||
logging.warning(f"[+] {client_address} connected.")
|
||||
# add the new connected client to connected sockets
|
||||
client_sockets[client_socket] = Sender()
|
||||
client_sockets[client_socket].address = client_address
|
||||
# start a new thread that listens for each client's messages
|
||||
t = Thread(target=listen_for_client, args=(client_socket,))
|
||||
# make the thread daemon so it ends whenever the main thread ends
|
||||
t.daemon = True
|
||||
# start the thread
|
||||
t.start()
|
||||
|
||||
# close client sockets
|
||||
for cs in client_sockets:
|
||||
cs.close()
|
||||
# close server socket
|
||||
s.close()
|
||||
Reference in New Issue
Block a user