def __init__(self, send_udp_socket, recv_udp_socket, name):
self.name = name.strip()
print("Hi " + self.name.upper() + ", welcome to the battleship game!")
self.running = True
self.messages = []
self.threads = []
self.host_name = cm.server_host
self.udp_server_port = cm.udp_server_port
self.code = wc.WarCode()
# prepare for UDP transmission (chat room)
self.udp_send_socket = ss.RSASocket(send_udp_socket)
self.udp_recv_socket = ss.RSASocket(recv_udp_socket)
# thread to handle messages reception
msg_reception_t = threading.Thread(
target=self.handle_udp_msg_reception)
msg_reception_t.daemon = True
msg_reception_t.start()
self.threads.append(msg_reception_t)
# thread to handle messages display
msg_handler_t = threading.Thread(target=self.handle_udp_msg_display)
msg_handler_t.daemon = True
msg_handler_t.start()
self.threads.append(msg_handler_t)
def main():
global server_quitting # for the future
threads = []
game_server = None
try:
server_quitting = False
# this is to verify if the server is up (UPD)
t = threading.Thread(target=ping_response)
t.start()
threads.append(t)
maximum_connected = cm.maximum_connected
server_socket = socket(AF_INET, SOCK_STREAM)
server_socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
server_socket.bind(('', cm.tcp_server_port)) # game socket
server_socket.listen(maximum_connected)
chat_socket = socket(AF_INET, SOCK_DGRAM)
chat_socket.bind(('', cm.udp_server_port)) # chat room socket
chat_socket = ss.RSASocket(chat_socket)
# create the game server
game_server = gs.TheGameServer(maximum_connected, chat_socket)
# entry door for incoming players
while not server_quitting:
playersocket, addr = server_socket.accept()
if (not server_quitting):
ss_socket = ss.RSASocket(playersocket)
t = threading.Thread(target=prepare_player,
args=(ss_socket, game_server))
t.start()
threads.append(t)
print("New player registered and waiting for more")
else:
# no more connections allowed
playersocket.send("no more connections allowed".encode())
playersocket.close()
except KeyboardInterrupt:
if (game_server):
game_server.quit()
game_down = True
print("Keyboard Interrupt. Time to say goodbye!!!")
except Exception as e:
print(e)
traceback.print_exc(file=sys.stdout)
finally:
for t in threads:
t.join()
if (game_server):
game_server.quit()
print("Waiting for all active games to finish")
print("The end")
sys.exit(0)
def get_new_socket(player_socket):
global PORT
PORT += 1
port_min = cm.tcp_server_min_port
port_max = cm.tcp_server_max_port
tcp_port = (port_min + PORT) % port_max
temp_socket = socket(AF_INET, SOCK_STREAM)
temp_socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
try:
player_socket.send(str(tcp_port))
temp_socket.bind(('', tcp_port))
temp_socket.listen(15)
new_player_socket, address = temp_socket.accept()
except socket.timeout:
print(
"Socket timeout. Port may have been used recently. wait and try again!"
)
return None, tcp_port
except:
print("Socket error. Try again")
return None, tcp_port
finally:
temp_socket.close()
return ss.RSASocket(new_player_socket), address
def set_connections_threads(self):
print("Connecting server to port ..." + str(self.tcp_port))
temp_socket = socket(AF_INET, SOCK_STREAM)
temp_socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
temp_socket.connect((self.host_name, self.tcp_port))
temp_socket = ss.RSASocket(temp_socket)
temp_socket.send(self.name)
# preparing new port
plain_socket = socket(AF_INET, SOCK_STREAM)
plain_socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.sslsocket = ss.RSASocket(plain_socket) # encrypted socket
error = True
while error:
try:
port = int(temp_socket.recv(1024))
self.sslsocket.connect(
(self.host_name, port)) # connect to the new port
error = False
except Exception as e:
print(e)
traceback.print_exc(file=sys.stdout)
return False
temp_udp_port = randint(2000, 60000)
temp_udp_server_socket = socket(AF_INET, SOCK_DGRAM)
temp_udp_server_socket.bind(('', temp_udp_port))
# to find out what port is assigned to the udp sender socket
temp_send_udp_client_socket = socket(AF_INET, SOCK_DGRAM)
temp_send_udp_client_socket.sendto("Test".encode(),
(cm.server_host, temp_udp_port))
_, chat_sending_address = temp_udp_server_socket.recvfrom(1024)
self.sslsocket.send(str(chat_sending_address))
self.sslsocket.recv(1024)
# to find out what port is assigned to the udp receiver socket
temp_recv_udp_client_socket = socket(AF_INET, SOCK_DGRAM)
temp_recv_udp_client_socket.sendto("Test".encode(),
(cm.server_host, temp_udp_port))
_, chat_receiving_address = temp_udp_server_socket.recvfrom(1024)
self.sslsocket.send(str(chat_receiving_address))
self.sslsocket.recv(1024)
try:
code = str(randint(0, 10000))
chat_file_name = "client" + code
with open(chat_file_name, "a") as my_file:
my_file.write(self.name + "\n")
my_file.write(str(chat_sending_address)[1:-1] + "\n")
my_file.write(str(chat_receiving_address)[1:-1])
print("If you want to use the chat use this code: " + code)
except Exception as e:
traceback.print_exc(file=sys.stdout)
print(e)
print("Unexpected error, not chat client available")
temp_socket.close()
temp_recv_udp_client_socket.close()
temp_send_udp_client_socket.close()
return True