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