def listen(self, client, address):
size = BUFFER_SIZE
while True:
try:
packet = client.recv(size)
if packet:
print("RECEIVED PACKET FROM {}:{}".format(address[0], address[1]))
unpacked = packet_utils.unpack(packet)
client_packet = packet_utils.unpack(bytes(unpacked.data, "utf-8"))
sequence_number = client_packet.sequence_number
source_ip = address[0]
source_port = address[1]
destination_ip = client_packet.destination_ip
destination_port = client_packet.destination_port
data = bytes(client_packet.data, "utf-8")
print("DESTINATION: {}:{}".format(destination_ip, destination_port))
print("SEQUENCE NO.: {}".format(sequence_number))
server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
server_sock.connect((destination_ip, destination_port))
except ConnectionRefusedError:
print('ERROR: The connection was refused, is the server running?')
input("Press enter to quit")
server_packet = packet_utils.create_packet(sequence_number, source_ip, source_port, destination_ip,
destination_port, data)
packet_utils.to_string(server_packet)
print("forwarding to server...\n")
server_sock.sendall(server_packet)
server_response = server_sock.recv(BUFFER_SIZE)
unpacked = packet_utils.unpack(server_response)
data = unpacked.data
print("SERVER RESPONSE: {}\n".format(data))
client.sendall(server_response)
else:
client.close()
except:
client.close()
return
def listen(self, gateway, address):
size = BUFFER_SIZE
while True:
try:
packet = gateway.recv(size)
if packet:
unpacked = packet_utils.unpack(packet)
client_sequence_num = unpacked.sequence_number
source_ip = unpacked.source_ip
source_port = unpacked.source_port
data = unpacked.data
client_id = source_port
destination_ip = source_ip
destination_port = source_port
if client_id not in self.client_dict:
self.client_dict[client_id] = 0
expected_sequence_number = self.client_dict[client_id]
sequence_number = self.sequence_number
if client_sequence_num == expected_sequence_number:
# 1 in 500 chance to 'drop' the received packet
if randint(1, 500) > 1:
print(data)
self.client_dict[client_id] += 1
if self.client_dict[
client_id] > MAX_SEQUENCE_NUMBER:
self.client_dict[client_id] = 0
next_sequence_number = self.client_dict[client_id]
response_packet = packet_utils.create_packet(
sequence_number, IP, PORT, destination_ip,
destination_port,
bytes(str(next_sequence_number), "utf-8"))
else:
response_packet = packet_utils.create_packet(
sequence_number, IP, PORT, destination_ip,
destination_port,
bytes(str(expected_sequence_number), "utf-8"))
else:
response_packet = packet_utils.create_packet(
sequence_number, IP, PORT, destination_ip,
destination_port,
bytes(str(expected_sequence_number), "utf-8"))
gateway.sendall(response_packet)
gateway.close()
self.sequence_number += 1
if self.sequence_number > MAX_SEQUENCE_NUMBER:
self.sequence_number = 0
else:
gateway.close()
except:
gateway.close()
return
def receive_messages(self):
while True:
packet, address = self.sock.recvfrom(BUFFER_SIZE)
unpacked = packet_utils.unpack(packet)
if unpacked.packet_type == PACKET_TYPE_CLIENT_MSG:
message_in = unpacked.data
sender_address = (unpacked.source_ip, unpacked.source_port)
sender = ''
for name in client_names:
if clients[name] == sender_address:
sender = client_names[name]
print(sender + ": " + message_in)
def listen(self):
while True:
packet, address = self.sock.recvfrom(BUFFER_SIZE)
unpacked = packet_utils.unpack(packet)
packet_type = unpacked.packet_type
# router initialisation information
if packet_type == PACKET_TYPE_HELLO:
self.stable = False
neighbour_info = unpacked.data.split(",")
r_number = neighbour_info[0]
r_ip = unpacked.source_ip
r_port = unpacked.source_port
self.router_addresses[r_number] = (r_ip, r_port)
self.vertices.append(r_number)
self.edges[neighbour_info[0]] = {}
for i in range(1, len(neighbour_info)):
self.edges[neighbour_info[0]][neighbour_info[i]] = 1
# assume any non-ints are clients, catch clients and add them to list
try:
int(neighbour_info[i])
except ValueError:
self.client_list.append(neighbour_info[i])
self.vertices.append(neighbour_info[i])
self.edges[neighbour_info[i]] = {r_number: 1}
# route requests from routers
if packet_type == PACKET_TYPE_LINK_STATE_REQUEST:
route = unpacked.data
if route in self.route_table:
router_path = self.route_table[route]
else:
# reverse the route order and check again, return route in reverse
route = route[-2:] + "-" + route[:2]
if route in self.route_table:
router_path = self.route_table[route][::-1]
route = route[-2:] + "-" + route[:2]
print("\nController sending route information...")
print("{}: {}\n".format(route, router_path))
for i in range(len(router_path) - 1):
r_ip = self.router_addresses[str(router_path[i])][0]
r_port = self.router_addresses[str(router_path[i])][1]
target_router = str(router_path[i + 1])
destination = route[-2:]
info = bytes(destination + target_router, "utf-8")
packet = packet_utils.create_packet(0, PACKET_TYPE_LINK_STATE_UPDATE, CONTROLLER_IP,
CONTROLLER_PORT, r_ip, r_port, info)
self.sock.sendto(packet, (r_ip, r_port))
def receive_messages(self, node, sock):
"""
Listens for incoming traffic
Link State Updates cause the routing table to be updated
Client messages are passed along with the route being requested if necessary
"""
while True:
packet, address = sock.recvfrom(BUFFER_SIZE)
print(str(self.r_number) + ":" + str(node))
unpacked = packet_utils.unpack(packet)
if unpacked.packet_type == PACKET_TYPE_LINK_STATE_UPDATE:
route_info = unpacked.data
destination = route_info[:2]
target_router = route_info[2:]
self.destinations[destination] = target_router
if unpacked.packet_type == PACKET_TYPE_CLIENT_MSG:
source_address = (unpacked.source_ip, unpacked.source_port)
source_client = ''
for c in clients:
if clients[c] == source_address:
source_client = c
destination_address = (unpacked.destination_ip, unpacked.destination_port)
destination_client = ''
for c in clients:
if clients[c] == destination_address:
destination_client = c
if destination_client in self.neighbours:
self.sockets[self.neighbours[destination_client]].sendto(packet,
self.neighbour_nodes[destination_client])
print("")
else:
if destination_client not in self.destinations:
self.send_request(source_client, destination_client)
sleep(.1) # give time to receive link state update
next_router = self.destinations[destination_client]
sending_socket = self.sockets[self.neighbours[next_router]]
receiving_node = self.neighbour_nodes[next_router]
sending_socket.sendto(packet, receiving_node)
def communicate(self):
while self.connected:
try:
server_port = 50003
if server_port not in self.server_dict:
self.server_dict[server_port] = 0
else:
self.server_dict[server_port] += 1
if self.server_dict[server_port] > MAX_SEQUENCE_NUMBER:
self.server_dict[server_port] = 0
sequence_number = self.server_dict[server_port]
message = bytes(str(sequence_number), "utf-8")
server_packet = packet_utils.create_packet(sequence_number, IP, 0, SERVER_IP, server_port, message)
gateway_packet = packet_utils.create_packet(sequence_number, IP, 0, GATEWAY_IP, GATEWAY_PORT,
server_packet)
acknowledged = False
while not acknowledged:
self.sock.sendall(gateway_packet)
try:
ready = select([self.sock], [], [], RETRY_TIMEOUT)
if ready[0]:
response_packet = self.sock.recv(BUFFER_SIZE)
unpacked = packet_utils.unpack(bytes(response_packet))
expected_next_sequence_number = unpacked.data
if int(expected_next_sequence_number) == int(sequence_number):
acknowledged = False
print("resending {}...".format(sequence_number))
else:
acknowledged = True
except ConnectionAbortedError:
print("Your connection has timed out, please restart the program.")
input("Press enter to quit")
break
except ConnectionResetError:
print("Your connection to the gateway has been lost, please restart the program.")
input("Press enter to quit")
break
