def receive(conn, router, data): p = Packet.from_bytes(data) print("Router: ", router) print("Packet type: ", p.packet_type) print("Payload: ", p.payload.decode("utf-8")) peer = p.peer_ip_addr, p.peer_port if p.packet_type == SYN: packet_syn_ack = make_ack(SYN_ACK, 0, peer, "Hi R") conn.sendto(packet_syn_ack.to_bytes(), router) payload = [] while True: raw_data, sender = conn.recvfrom(1024) data_packet = Packet.from_bytes(raw_data) print("Packet: ", data_packet) print("Payload: ", data_packet.payload.decode("utf-8")) ack = make_ack(ACK, data_packet.seq_num, peer) conn.sendto(ack.to_bytes(), sender) print("Ack: ", ack) if data_packet.packet_type == FIN: print("LastPacket: ", ack) break else: payload.append(data_packet.payload.decode("utf-8")) return ''.join(payload)
def handle_client(client_socket): bytes = client_socket.recv(512) pack = Packet() pack.rsa = self.serverrsa sig = bytes[:256] try: bytes = pack.decrypt(bytes[256:]) pack.from_bytes(bytes) # Not working for some reason self.serverrsa.verify(bytes, sig, self.__clients[pack.sender]) except ValueError: pack.from_bytes(bytes) if pack.command != Command.REGISTER: client_socket.close() return if self.__verify_packet(pack) or pack.command == Command.REGISTER: resp = self.__commands[pack.command](pack, sock=client_socket) if resp is not None: self._send(client_socket, resp) client_socket.close()
def handle_get_file(router_addr, router_port, server_addr, server_port, route): peer_ip = ipaddress.ip_address(socket.gethostbyname(server_addr)) conn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) timeout = 1 msg = 'get,' + route payload = msg.encode("utf-8") p = Packet(packet_type=0, seq_num=1, peer_ip_addr=peer_ip, peer_port=server_port, payload=payload) try: buffered_file = {} timeout = 2 print('Sending request for file: ' + args.route) conn.sendto(p.to_bytes(), (router_addr, router_port)) conn.settimeout(timeout) # RESPONSE FROM SERVER response, sender = conn.recvfrom(1024) p = Packet.from_bytes(response) if p.packet_type == ACK: buffered_file[p.seq_num] = p while p.packet_type != ACK: print('RECEVIED A PACKET!') print(p) conn.sendto(p.to_bytes(), sender) conn.settimeout(timeout) buffered_file[p.seq_num] = p response, sender = conn.recvfrom(1024) p = Packet.from_bytes(response) # print(p.payload.decode("utf-8")) print('RETRIEVED ALL PACKETS FOR FILE WITHIN CLIENT') print(buffered_file) print('\n--------------------------------') msg = '' for seq_num, packet in sorted(buffered_file.items()): msg += packet.payload.decode('utf-8') print(msg) except socket.timeout: print('No response after {}s'.format(timeout)) handle_get_file(args.routerhost, args.routerport, args.serverhost, args.serverport, args.route) finally: conn.close()
def send_req_udp(router_addr: str, router_port: int, server_addr: str, server_port: int, packet_type: int, seq_num: int, req: str, verbose=False): peer_ip = ipaddress.ip_address(socket.gethostbyname(server_addr)) conn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) timeout = 5 print("sending SYN") syn = Packet(packet_type=1, seq_num=seq_num, peer_ip_addr=peer_ip, peer_port=server_port, payload='') conn.sendto(syn.to_bytes(), (router_addr, router_port)) print("waiting for SYN-ACK") conn.settimeout(timeout) syn.packet_type = -1 while syn.packet_type != 2: resp, send = conn.recvfrom(1024) recv_packet = Packet.from_bytes(resp) syn.packet_type = recv_packet.packet_type print("Received SYN-ACK") print("Sending ACK") ack = Packet(packet_type=3, seq_num=seq_num, peer_ip_addr=peer_ip, peer_port=server_port, payload='') conn.sendto(ack.to_bytes(), (router_addr, router_port)) res = "" try: msg = req p = Packet(packet_type=packet_type, seq_num=seq_num, peer_ip_addr=peer_ip, peer_port=server_port, payload=msg.encode("UTF-8")) conn.sendto(p.to_bytes(), (router_addr, router_port)) print('Send: \n"{}"\nto router'.format(msg)) # Try to receive a response within timeout conn.settimeout(timeout) response, sender = conn.recvfrom(1024) print('Waiting for a response') p = Packet.from_bytes(response) print('Router: ', sender) print('Packet: ', p) res = Response(p.payload.decode("UTF-8")) print('Payload: ' + p.payload.decode("UTF-8")) except socket.timeout: print('No response after {}s'.format(timeout)) finally: conn.close() return res
def handshake(router_addr, router_port, server_addr, server_port): established = False while not established: ip = ipaddress.ip_address(socket.gethostbyname(server_addr)) conn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # conn.bind(("", 41830)) print("First handshake SYN is sending ……") packet_syn = Packet(packet_type=SYN, seq_num=0, peer_ip_addr=ip, peer_port=server_port, payload="".encode("utf-8")) conn.sendto(packet_syn.to_bytes(), (router_addr, router_port)) print("Waiting for response SYN_ACK ……") try: conn.settimeout(TIMEOUT) response, sender = conn.recvfrom(1024) packet_response = Packet.from_bytes(response) if packet_response.packet_type == SYN_ACK: print("Receive response SYN_ACK from " + str(packet_response.peer_ip_addr) + " : " + str(packet_response.peer_port)) established = True packet_ack = Packet(packet_type=ACK, seq_num=0, peer_ip_addr=ip, peer_port=server_port, payload="".encode("utf-8")) for i in range (0,20): conn.sendto(packet_ack.to_bytes(), (router_addr, router_port)) except socket.timeout: print("Handshake fail, handshake again……") finally: conn.close()
def client_thread(sock, conn, ip, port): global connection_established ip = ipaddress.ip_address(socket.gethostbyname(ip)) request_packet = Packet.from_bytes(conn) request = request_packet.payload.decode('utf-8') print(request_packet.packet_type) print(connection_established) print('Connection {ip: %s, port: %s} requested: %s' % (ip, port, request)) if connection_established == False and request_packet.packet_type == 2: print(sock) response_packet = Packet(packet_type=3, seq_num=1, peer_ip_addr=request_packet.peer_ip_addr, peer_port=request_packet.peer_port, payload="SYN-ACK".encode("utf-8")) print(response_packet.payload.decode('utf-8')) sock.sendto(response_packet.to_bytes(), ('127.0.0.1', 3000)) connection_established = True elif connection_established == True and request_packet.packet_type == 0: # prepare response to send back to client response = process_request(directory, request) response_packet = Packet(packet_type=0, seq_num=1, peer_ip_addr=request_packet.peer_ip_addr, peer_port=request_packet.peer_port, payload=response.encode("utf-8")) print(response_packet.payload.decode('utf-8')) sock.sendto(response_packet.to_bytes(), ('127.0.0.1', 3000)) print('Connection from: {ip: %s, port: %s} has closed...' % (ip, port))
def handshake_client(self): established = False server = self.host, self.port while not established: self.conn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) logging.debug("(Starting Handshake)") syn_pkt = make_ack(SYN, 0, server) logging.debug(f'(client->{server}):{syn_pkt}:Sending SYN') self.conn.sendto(syn_pkt.to_bytes(), self.router) # TODO timeout self.conn.settimeout(TIMEOUT) try: raw_packet, router = self.conn.recvfrom(1024) except socket.timeout: logging.debug(f'(client->{server}):Timeout, either SYN dropped or SYN-ACK dropped') continue p = Packet.from_bytes(raw_packet) if p.packet_type == SYN_ACK: logging.debug(f'({server}->client):{p}:Received SYN_ACK') established = True ack_pkt = make_ack(ACK, 0, server) logging.debug(f'(client->{server}):{ack_pkt}:Send ACK') self.conn.sendto(ack_pkt.to_bytes(), router) logging.debug("(Handshake Finished)") return established
def handle_get_directory(router_addr, router_port, server_addr, server_port, route): peer_ip = ipaddress.ip_address(socket.gethostbyname(server_addr)) conn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) timeout = 1 msg = 'get,' + route payload = msg.encode("utf-8") p = Packet(packet_type=0, seq_num=1, peer_ip_addr=peer_ip, peer_port=server_port, payload=payload) try: print('Requesting all files within directory: ' + args.route) conn.sendto(p.to_bytes(), (router_addr, router_port)) conn.settimeout(timeout) response, sender = conn.recvfrom(1024) print('\n--------------------------------') p = Packet.from_bytes(response) print(p.payload.decode("utf-8")) except socket.timeout: print('No response after {}s'.format(timeout)) handle_get_directory(args.routerhost, args.routerport, args.serverhost, args.serverport, args.route) finally: conn.close()
def run_server(self, port, pack=None): self.listen = True print('Echo server is listening at', port) self.connections.bind(('', port)) while self.listen: p = None if pack != None: p, self.sender = pack pack = None else: data, self.sender = self.connections.recvfrom(1024) p = Packet.from_bytes(data) if self.client_port == 0: self.client_port = p.peer_port if self.client_port == p.peer_port: server_port = p.peer_port if (p.packet_type == 0 and self.data_rcv == True): p.packet_type = 4 self.connections.sendto(p.to_bytes(), self.sender) elif (p.packet_type == 5): self.listen = False if (self.recv_data == True and p.packet_type == 0): self.handle_data(self.connections, p, self.sender) else: self.handle_client(self.connections, p, self.sender) else: self.packet_temp.append((p, self.sender)) print(self.packet_temp) self.client_port = 0 return self.final
def post_sendfile(s_n): print(s_n) peer_ip = ipaddress.ip_address(socket.gethostbyname('localhost')) conn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) timeout = 5 with open(postfilename, 'rb') as f1: f1.seek(1013 * s_n) buf = f1.read(1013) if buf: try: p = Packet(packet_type=4, seq_num=s_n, peer_ip_addr=peer_ip, peer_port=8007, payload=buf) conn.sendto(p.to_bytes(), (args.routerhost, args.routerport)) conn.settimeout(timeout) response, sender = conn.recvfrom(1024) p = Packet.from_bytes(response) print('Payload: ' + p.payload.decode("utf-8")) post_sendfile(p.seq_num) except socket.timeout: print('No response after {}s'.format(timeout)) post_sendfile(s_n) finally: conn.close() else: print("finish") exit()
def runClient(routerAddress, routerPort, serverAddress, serverPort): ip_peer = ipaddress.ip_address(socket.gethostbyname(serverAddress)) connection = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) timeout = 10 try: message = "Message to server" message = message + "\r\n" packet = Packet(packet_type=0, seq_num=1, peer_ip_addr=ip_peer, peer_port=serverPort, is_last_packet=True, payload=message.encode("utf-8")) connection.sendto(packet.convertToBytes(), (routerAddress, routerPort)) print('Sending "{}" to router'.format(message)) connection.settimeout(timeout) print('Waiting for a response') response, sender = connection.recvfrom(1024) packet = Packet.from_bytes(response) print('Response from the server !') print('Router: ', sender) print('Packet: ', packet) print('Message from server: ' + packet.payload.decode("utf-8")) except socket.timeout: print('No response after {}s'.format(timeout)) finally: connection.close()
def packetHandler(conn, data, sender): global p_constructor global handshake_completed p = Packet.from_bytes(data) if (p.packet_type == Packet_Constructor.syn_type): if (debug): print("TCP syn received") p.packet_type = Packet_Constructor.syn_ack_type conn.sendto(p.to_bytes(), sender) elif (p.packet_type == Packet_Constructor.ack_type): handshake_completed = True if (debug): print("TCP ack received") elif (handshake_completed): payload = p_constructor.add_packet(p, conn, sender) if (payload): print("Received last packet") response = dataHandler(payload, sender) print("Sending packets") print(response) sleep(0.1) # Time in seconds. Packet_Sender.send_as_packets(response, conn, sender, p.peer_ip_addr, p.peer_port) handshake_completed = False else: print("is not the last packet")
def run_server(port): conn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) try: conn.bind(('', port)) print('Echo server is listening at', port) while True: data, sender = conn.recvfrom(1024) p = Packet.from_bytes(data) rcvd_payload = p.payload.decode("utf-8") if rcvd_payload.split(',')[0] == 'get': filepath = rcvd_payload.split(',')[1] print('performing get in ' + filepath) # print all files in current directory if '.txt' not in filepath: files = "" try: for file in os.listdir('.' + filepath): files += file + '\n' p.payload = files.encode("utf-8") handle_get_directories(conn, p, sender) except: p.payload = "Directory does not exist".encode("utf-8") handle_get_directories(conn, p, sender) else: handle_get_file(conn, p, sender, filepath) else: handle_client(conn, data, sender) finally: conn.close()
def handle_client(conn, data, sender): try: p = Packet.from_bytes(data) global buffered_post_packets print('---------') print('Packet received: {}'.format(p)) # Last packet has been sent so client has sent ACK if p.packet_type == ACK: print(buffered_post_packets) msg = '' for seq_num, packet in sorted(buffered_post_packets.items()): msg += packet.payload.decode("utf-8") filepath = p.payload.decode("utf-8") f = open('./files/' + filepath + '.txt', 'w+') f.write(msg) print('DONE ^^^^') buffered_post_packets = {} else: p.packet_type = ACK print(p.packet_type) print("Router: ", sender) print("Packet: ", p) print("Payload: ", p.payload.decode("utf-8")) buffered_post_packets[p.seq_num] = p # How to send a reply. # The peer address of the packet p is the address of the client already. # We will send the same payload of p. Thus we can re-use either `data` or `p`. conn.sendto(p.to_bytes(), sender) except Exception as e: print("Error: ", e)
def run_client(router_addr, router_port, server_addr, server_port, sequence_number, message): while True: peer_ip = ipaddress.ip_address(socket.gethostbyname(server_addr)) conn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) timeout = 5 try: p = Packet(packet_type=0, seq_num=sequence_number, peer_ip_addr=peer_ip, peer_port=server_port, payload=message.encode("utf-8")) conn.sendto(p.to_bytes(), (router_addr, router_port)) #print('Send "{}" to rout234er'.format(message)) print("[CLIENT] - Sending packet to Router. Sequence Number = ", p.seq_num) # Try to receive a response within timeout conn.settimeout(timeout) # print('Waiting for a response') response, sender = conn.recvfrom(1024) p = Packet.from_bytes(response) # print('Router: ', sender) # print('Packet: ', p) print('[CLIENT] - PayLoad from Packet %d : %s ' % (p.seq_num, p.payload.decode("utf-8")[1:])) # print('[CLIENT] - Payload from Packet: ', p.seq_num, ' - ', p.payload.decode("utf-8")) return True except socket.timeout: print('[CLIENT] - No response after %d for Packet %d ' % (timeout, p.seq_num)) finally: conn.close()
def send_fin_packet(router_addr, router_port, server_ip, server_port): try: timeout = 0.1 conn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) fin_packet = Packet(packet_type=5, seq_num=0, peer_ip_addr=server_ip, peer_port=server_port, payload=''.encode('utf-8')) conn.sendto(fin_packet.to_bytes(), (router_addr, router_port)) logging.debug('Send FIN packet {} to router.'.format( fin_packet.seq_num)) conn.settimeout(timeout) logging.debug('Waiting for FIN-ACK packet {}.'.format( fin_packet.seq_num)) response, sender = conn.recvfrom(1024) p = Packet.from_bytes(response) logging.debug('Received type {} packet {}.'.format( p.packet_type, p.seq_num)) if (p.packet_type == 6) and p.seq_num == 0: global to_be_closed to_be_closed = True # FIN-ACK logging.debug('Client in Fin waiting state...') except socket.timeout: logging.debug('FIN packet {} no response after {}s.'.format( fin_packet.seq_num, timeout)) if to_be_closed is False: send_fin_packet(router_addr, router_port, server_ip, server_port) finally: logging.debug('FIN Packet 0 Connection closed.\n') conn.close()
def ack(router_addr, router_port, server_addr, server_port): while True: peer_ip = ipaddress.ip_address(socket.gethostbyname(server_addr)) conn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) timeout = 5 try: # Packet type to 1 (SYN). Then have the server recognize the packet_type and return a 2 (SYN-ACK) p = Packet(packet_type=3, seq_num=1, peer_ip_addr=peer_ip, peer_port=server_port, payload=message.encode("utf-8")) print("[CLIENT] - Sending ACK") conn.sendto(p.to_bytes(), (router_addr, router_port)) # Receive a response within timeout conn.settimeout(timeout) print("[CLIENT] - Waiting For A Response - (Should be an ACK)") response, sender = conn.recvfrom(1024) p = Packet.from_bytes(response) print( "[CLIENT] - Response Recieved. Is it a SYN-ACK? (Packet of Type 3)" ) print('[CLIENT] - PacketType = ', p.packet_type) print("[CLIENT] - Yes, Got an ACK back. Proceed with request.") return True except socket.timeout: print('[CLIENT] - No response after %ds for Packet %d ' % (timeout, p.seq_num)) finally: conn.close()
def establish_handshake_server(conn, data, sender): global established try: p = Packet.from_bytes(data) peer_ip_addr, peer_port = p.peer_ip_addr, p.peer_port # print("Router: ", sender) # print("Packet: ", p) print("Payload: ", p.payload.decode("utf-8")) if not established: if p.packet_type == SYN: print("Handshake start SYN ") p_synack = Packet(SYN_ACK, 0, peer_ip_addr, peer_port, "Hi R".encode("utf-8")) conn.sendto(p_synack.to_bytes(), sender) print("sending syn_ack") elif p.packet_type == ACK: print("ACK!!") established = True # else: # # p_ack = Packet(ACK, 0, peer_ip_addr, peer_port, p.payload) # # conn.sendto(p_ack.to_bytes(), sender) # # print("Handshake done.") # request = receive(conn, sender, data) # How to send a reply. # The peer address of the packet p is the address of the client already. # We will send the same payload of p. Thus we can re-use either `data` or `p`. # conn.sendto(p.to_bytes(), sender) except Exception as e: print("Error: ", e) finally: return conn
def connect(host, port, peer_ip): global conn global p_constructor global router global seq_num print(peer_ip) print(port) data = b'' p = Packet(packet_type=Packet_Constructor.syn_type, seq_num=seq_num, peer_ip_addr=peer_ip, peer_port=port, is_last_packet=False, payload=data) conn.sendto(p.to_bytes(), router) response, sender = conn.recvfrom(1024) p = Packet.from_bytes(response) if (p.packet_type == Packet_Constructor.syn_ack_type): print("Got syn ack, responding with ack") p.packet_type = Packet_Constructor.ack_type conn.sendto(p.to_bytes(), sender) else: print("During TCP handshake, got the wrong packet type. Restarting") connect(host, port, peer_ip)
def run_client(router_addr, router_port, server_addr, server_port): peer_ip = ipaddress.ip_address(socket.gethostbyname(server_addr)) conn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) timeout = 5 try: # msg = "Hello WorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWorlddWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWodWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWodWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWodWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWodWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWodWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWodWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWodWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWodWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWodWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWodWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWodWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWodWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWodWorldWorldWorldWorldWorld09WorldWorldWorldWorlldWdWorldWorldWrldWrldWorldWorldWorldWorldWorldWodWorldWorldWorldWorldWorldWorldWorldWorlWorldWorldWorldWorldWorldWorldWorldWoWorldWorldWorldWorldWorldWorldWorldWorldWorldWorldWorld" msg = "Hello World" p = Packet(packet_type=0, seq_num=1, peer_ip_addr=peer_ip, peer_port=server_port, payload=msg.encode("utf-8")) conn.sendto(p.to_bytes(), (router_addr, router_port)) print('Send "{}" to router'.format(msg)) # Try to receive a response within timeout conn.settimeout(timeout) print('Waiting for a response') response, sender = conn.recvfrom(1024) p = Packet.from_bytes(response) print('Router: ', sender) print('Packet: ', p) print('Payload: ' + p.payload.decode("utf-8")) except socket.timeout: print('No response after {}s'.format(timeout)) finally: conn.close()
def run(self): recv_packet = Packet.from_bytes(self.data) print(f'{self.sender_addr} -> {str(recv_packet)}') packet_id = recv_packet.id packet_seq = recv_packet.seq curr_tcp_recv = TCPRecvDefragment(self.sender_addr, packet_id) reply = None with find_defragment_lock: for instance in self.all_tcp_recv: if instance == curr_tcp_recv: curr_tcp_recv = instance break else: self.all_tcp_recv.append(curr_tcp_recv) if (curr_tcp_recv.add_packet(recv_packet)): reply = recv_packet.get_reply() if reply is not None: self.sock.sendto(reply.to_bytes(), self.sender_addr) print(f'{self.sender_addr} <- {str(reply)}') if reply.get_type() == 'FIN-ACK': filename = curr_tcp_recv.write_out() if curr_tcp_recv in self.all_tcp_recv: self.all_tcp_recv.remove(curr_tcp_recv) print( f'[i] Written file from {self.sender_addr} with id {packet_id} to {filename}') else: print(f'DROP {str(recv_packet)}')
def recv(self, encrypt=True, server=False): d = self.__client.recv(512) packet = Packet() if encrypt: packet.rsa = self.__rsacrypt msg = packet.decrypt(d[256:]) self.__rsacrypt.verify(msg, d[:256], self.serverkey) packet.from_bytes(msg) if packet.sender != self.serveruuid: packet.aes = self.__aesmapping[packet.sender] packet.decrypt_payload() else: packet.from_bytes(d) if packet.command == Command.SHAREPUB: d = self.__client.recv(21) packet.payload = packet.payload + d return packet
def send_file_packet(conn, packet, sender): timeout = 4 try: conn.sendto(packet.to_bytes(), sender) conn.settimeout(timeout) # print('Waiting for a response') response, sender = conn.recvfrom(1024) print('---------') print('RCVED SOMETHING BACK') print(Packet.from_bytes(response)) return Packet.from_bytes(response) except socket.timeout: print('No packet received') return None
def receive(): while conn.receive_data: try: data, addr = self.recvfrom(10 * 1024 * 1024) packet = Packet.from_bytes(data) conn.on_recv_packet(packet) except: pass
def handle_client(conn, data, router_address): p = Packet.from_bytes(data) sequence_number = p.seq_num decoded_data = p.payload.decode("utf-8") print('Router: ', router_address) print('Packet: ', p) print("router_address: ", p.peer_ip_addr) print('Payload: ', decoded_data) try: useful_data = decoded_data.split(" HTTP/")[0] print(decoded_data) if 'GET' in useful_data: get_request(conn, useful_data, p.peer_ip_addr, p.peer_port, router_address, sequence_number) if 'POST' in useful_data: post_request(conn, useful_data, p.peer_ip_addr, p.peer_port, router_address, sequence_number) if p.packet_type == 1 and p.seq_num == 0: p = Packet(packet_type=2, seq_num=sequence_number, peer_ip_addr=p.peer_ip_addr, peer_port=p.peer_port, payload="") conn.sendto(p.to_bytes(), router_address) except FileNotFoundError: p = Packet(packet_type=0, seq_num=sequence_number, peer_ip_addr=p.peer_ip_addr, peer_port=p.peer_port, payload="404 NOT FOUND") conn.sendto(p.to_bytes(), router_address) except PermissionError: p = Packet(packet_type=0, seq_num=sequence_number, peer_ip_addr=p.peer_ip_addr, peer_port=p.peer_port, payload="403 Forbidden") conn.sendto(p.to_bytes(), router_address) except OSError: p = Packet(packet_type=0, seq_num=sequence_number, peer_ip_addr=p.peer_ip_addr, peer_port=p.peer_port, payload="400 BAD REQUEST") conn.sendto(p.to_bytes(), router_address) finally: print('Client from', router_address, 'has disconnected')
def row_squash(packet_iter, n_rows): for l_list in split_seq(packet_iter, n_rows): a = numpy.array([numpy.fromstring(l.to_bytes(), dtype=numpy.uint8) for l in l_list]) best, counts = mode(a) best = best[0].astype(numpy.uint8) p = Packet.from_bytes(best) p._offset = l_list[0]._offset yield p
def acks(self, conn, port): while self.listen_nak: response, sender = self.connections.recvfrom(1024) p = Packet.from_bytes(response) if (p.packet_type == 4): p.packet_type = 0 print('Recieved ack for packet:', p.seq_num) self.window_acks[p.seq_num] = p.payload return
def run(host, port, router_address, router_port): """ init and run client server """ host = ipaddress.ip_address(socket.gethostbyname(host)) # create socket instance sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) try: print("Establishing connection...") packet = Packet(packet_type=2, seq_num=1, peer_ip_addr=host, peer_port=port, payload="SYN".encode("utf-8")) sock.sendto(packet.to_bytes(), (router_address, router_port)) sock.settimeout(10) server_response = sock.recv(1024) print("Sent SYN") response_packet = Packet.from_bytes(server_response) response_message = response_packet.payload.decode("utf-8") if response_packet.packet_type == 3: packet = Packet(packet_type=1, seq_num=1, peer_ip_addr=host, peer_port=port, payload="ACK".encode("utf-8")) sock.sendto(packet.to_bytes(), (router_address, router_port)) print("Sent ACK") print("Connection Established...") while True: request = input("Please input your request:") packet = Packet(packet_type=0, seq_num=1, peer_ip_addr=host, peer_port=port, payload=request.encode("utf-8")) sock.sendto(packet.to_bytes(), (router_address, router_port)) sock.settimeout(10) server_response = sock.recv(1024) response_packet = Packet.from_bytes(server_response) print(response_packet.payload.decode('utf-8')) except Exception as e: print("Error occured: {}".format(str(e))) sys.exit(0) finally: sock.close()
def receive_udp_packet_from_server(conn, data, sender): try: decoded_response = '' p = Packet.from_bytes(data) global delivered, expected_data_packets_num, received_pkt_count, received_all if p.packet_type == 3: if p.seq_num == 0: expected_data_packets_num = int(p.payload.decode('utf-8')) # receiving data, # re-construct the packet global rcv_window_start, rcv_window_end if p.seq_num - 1 == rcv_window_start: logging.debug('Accept packet {}'.format(p.seq_num)) if delivered[p.seq_num - 1] is None: received_pkt_count = received_pkt_count + 1 delivered[p.seq_num - 1] = p i = rcv_window_start while i < len(delivered) and delivered[i] is not None: i = i + 1 shift = i - rcv_window_start logging.debug('Shift the window by {}'.format(shift)) rcv_window_start = rcv_window_start + shift rcv_window_end = rcv_window_end + shift logging.debug('Extend the delivered list by {}'.format(shift)) extension = [None] * shift delivered.extend(extension) elif rcv_window_start < p.seq_num - 1 < rcv_window_end: logging.debug('Accept packet {}'.format(p.seq_num)) if delivered[p.seq_num - 1] is None: received_pkt_count = received_pkt_count + 1 delivered[p.seq_num - 1] = p else: logging.debug('Discard packet {}'.format(p.seq_num)) # send ACK p.packet_type = 2 conn.sendto(p.to_bytes(), sender) if received_pkt_count == expected_data_packets_num and received_all is False: received_all = True # concatenate the data of all received packets i = 0 while i < expected_data_packets_num: decoded_response = decoded_response + delivered[ i].payload.decode('utf-8') i = i + 1 except Exception as e: logging.debug("Error: ", e) finally: return decoded_response
def row_squash(packet_iter, n_rows): for l_list in split_seq(packet_iter, n_rows): a = numpy.array([ numpy.fromstring(l.to_bytes(), dtype=numpy.uint8) for l in l_list ]) best, counts = mode(a) best = best[0].astype(numpy.uint8) p = Packet.from_bytes(best) p._offset = l_list[0]._offset yield p
def wait_for_fin(conn, data, sender): try: p = Packet.from_bytes(data) if p.packet_type == 5: p.packet_type = 6 conn.sendto(p.to_bytes(), sender) global to_be_closed_confirmed to_be_closed_confirmed = True logging.debug('Client to be closed confirmed.') except Exception as e: logging.debug("Error: ", e)
def reader(infile, start=0, stop=-1): """Helper to read t42 lines from a file-like object.""" if start > 0: infile.seek(start * 42) lines = iter(partial(infile.read, 42), b'') for n,l in enumerate(lines): offset = n + start if len(l) < 42: return elif offset == stop: return else: p = Packet.from_bytes(l) p._offset = offset yield p
def subpage_squash(packet_iter, minimum_dups=3, pages=All, yield_func=packets): subpages = defaultdict(list) for pl in paginate(packet_iter, pages=pages, yield_func=packet_lists, drop_empty=True): subpagekey = (pl[0].mrag.magazine, pl[0].header.page, pl[0].header.subpage) arr = numpy.zeros((42, 32), dtype=numpy.uint8) for p in pl: arr[:,p.mrag.row] = p._original_bytes subpages[subpagekey].append(arr) for arrlist in subpages.itervalues(): if len(arrlist) >= minimum_dups: arr = mode(numpy.array(arrlist), axis=0)[0][0].astype(numpy.uint8) packets = [] for i in range(32): if arr[:,i].any(): packets.append(Packet.from_bytes(arr[:,i])) for item in yield_func(packets): yield item