def RecSendAck(EmulatorHostName, EmulatorPortNumAckFrRec, RecPortNumRecDataFroE, FileNameToWriteData): receiverSocket = socket(AF_INET, SOCK_DGRAM) receiverSocket.bind(('', RecPortNumRecDataFroE)) while True: packet_rec_udp, clientAddress = receiverSocket.recvfrom(2048) # parse the recieved packet packet_rec = packet.parse_udp_data(packet_rec_udp) seq_num_rec = packet_rec.seq_num # if the packet is not EOT, record in the arrival log if (packet_rec.type != 2): arrival_to_write = "{}{}".format(seq_num_rec, '\n') arrival_log.write(arrival_to_write) # deal with the first packet's seq num is not the seq num = 0 situation if (len(rec_seq_num) == 0 and seq_num_rec != 0): continue # receive the first expected packet if (len(rec_seq_num) == 0): rec_seq_num.append(seq_num_rec) Ack_packet = packet.create_ack(seq_num_rec) f.write(packet_rec.data) receiverSocket.sendto(Ack_packet.get_udp_data(), (EmulatorHostName, EmulatorPortNumAckFrRec)) continue #receive the EOT packet if ((packet_rec.type == 2)): EOT_packet = packet.create_eot(seq_num_rec) receiverSocket.sendto(EOT_packet.get_udp_data(), (EmulatorHostName, EmulatorPortNumAckFrRec)) arrival_log.close() receiverSocket.close() f.close() break #not receive the expected packet if (seq_num_rec != (((rec_seq_num[len(rec_seq_num) - 1] + 1) % SEQ_NUM_MODULO))): Ack_packet = packet.create_ack(rec_seq_num[len(rec_seq_num) - 1]) receiverSocket.sendto(Ack_packet.get_udp_data(), (EmulatorHostName, EmulatorPortNumAckFrRec)) continue #receive the expected packet if (seq_num_rec == (((rec_seq_num[len(rec_seq_num) - 1] + 1) % SEQ_NUM_MODULO))): rec_seq_num.append(seq_num_rec) Ack_packet = packet.create_ack(seq_num_rec) f.write(packet_rec.data) receiverSocket.sendto(Ack_packet.get_udp_data(), (EmulatorHostName, EmulatorPortNumAckFrRec)) continue
def run(self): udp_socket_receive = socket(AF_INET, SOCK_DGRAM) udp_socket_receive.bind(('', self.udp_port_data)) udp_socket_send = socket(AF_INET, SOCK_DGRAM) while True: #print("waitting...") row_data, clientAddress = udp_socket_receive.recvfrom( 1024) #1024 if buffer size received_packet = packet.parse_udp_data(row_data) #print("except seqnum: " + str(self.get_expect_squnum())) #print("actual seqnum: " + str(received_packet.seq_num)) #print(received_packet.data) if received_packet.type == 1: self.log(str(received_packet.seq_num)) if (received_packet.seq_num == self.get_expect_squnum()): self.expect_seqnum += 1 if received_packet.type == 1: if (self.expect_seqnum - 1) == 0: with open(self.file_to_write, "w+") as f: f.write(received_packet.data) else: with open(self.file_to_write, "a") as f: f.write(received_packet.data) #last acked pkt's seqnum is excepted next seqnum - 1 packet_to_send = packet.create_ack( self.get_expect_squnum() - 1) #print("send ack: "+ str(packet_to_send.seq_num)) udp_socket_send.sendto( packet_to_send.get_udp_data(), (self.host_address, self.udp_port_ack)) else: #if the last pkt is not what we want, #resend the lastest acked seqnum #last acked pkt's seqnum is excepted next seqnum - 1 if self.expect_seqnum != 0: packet_to_send = packet.create_ack( self.get_expect_squnum() - 1) #print("send previous ack: "+ str(packet_to_send.seq_num)) udp_socket_send.sendto( packet_to_send.get_udp_data(), (self.host_address, self.udp_port_ack)) elif received_packet.type == 2: packet_to_send = packet.create_eot(self.get_expect_squnum()) udp_socket_send.sendto(packet_to_send.get_udp_data(), (self.host_address, self.udp_port_ack)) #print("eot seqnum: " + str(packet_to_send.seq_num)) udp_socket_send.close() break
def receive(filename, emulatorAddr, emuReceiveACK, client_udp_sock): global expected_pkt_num save_data = bytearray() try: file = open(filename, 'wb') except IOError: print('Unable to open', filename) return while True: msg, _ = client_udp_sock.recvfrom(4096) data_packet = packet.parse_udp_data(msg) packet_type = data_packet.type seq_num = data_packet.seq_num data = data_packet.data arrival_log.append(seq_num) # receives EOT, send EOT back and exit if packet_type == 2 and seq_num == expected_pkt_num % SEQ_MODULO: client_udp_sock.sendto(packet.create_eot(seq_num).get_udp_data(), (emulatorAddr, emuReceiveACK)) break # receives expected data packet if seq_num == expected_pkt_num % SEQ_MODULO: expected_pkt_num += 1 save_data.extend(data.encode()) # if the very first data packet #0 get lost, do not ACK and wait for a timeout resend. if expected_pkt_num != 0: ack_num = (expected_pkt_num - 1) % SEQ_MODULO client_udp_sock.sendto(packet.create_ack(ack_num).get_udp_data(), (emulatorAddr, emuReceiveACK)) file.write(save_data) file.close()
def receive(self, emulator_addr, emulator_port): # print("begin to receive -----------------") while True: rcv_data, address = self.rcv_udp_socket.recvfrom(1024) # print("receive a new packet ------------------") rcv_packet = packet.parse_udp_data(rcv_data) # print("receive pkt seq_num" + str(rcv_packet.seq_num)) expected_num = self.expected_seq_num % SEQ_NUM_MODULO if rcv_packet.seq_num == expected_num: if rcv_packet.type == 2: # print("receive all data and begin to send EOT -----------------------") msg = packet.create_eot(rcv_packet.seq_num).get_udp_data() self.send_udp_socket.sendto(msg, (emulator_addr, emulator_port)) self.send_udp_socket.close() self.rcv_udp_socket.close() break elif rcv_packet.type == 1: self.expected_seq_num += 1 self.data_list.append(rcv_packet.data) self.arrival_log.append(rcv_packet.seq_num) if self.expected_seq_num != 0: # print("begin to send ACK ------------------") cur_ack_num = (self.expected_seq_num - 1) % SEQ_NUM_MODULO # print("send ack" + str(cur_ack_num)) ack_msg = packet.create_ack(cur_ack_num).get_udp_data() self.send_udp_socket.sendto(ack_msg, (emulator_addr, emulator_port))
def send_ack(self, seq_num: int): """ Sends an ACK packet for a sequence number. Args: seq_num: Sequence number of the packet to mention in the ACK. """ socket(AF_INET, SOCK_DGRAM).sendto( packet.create_ack(seq_num).get_udp_data(), (self.hostname, self.ack_port))
def main(args): # Check the number of arguments is correct or not if not len(args) == 5: print('Error 2: expected 5 arguments, %d was received' % (len(args))) sys.exit(2) # Check if the type of argument is correct if (not ((args[2]).isdigit())) or (not ((args[3]).isdigit())): print('Error 4: port number must be an integer') sys.exit(4) # Get arguments naddr = args[1] host_port = int(args[2]) file_port = int(args[3]) file_name = args[4] # Open files file = open(file_name, 'w+') Arrive_log = open('arrival.log', 'w+') # Create receiving packet receiver_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) receiver_socket.bind(('', file_port)) # Define useful variables next_seqnum = 0 counter = 0 first = True # Start receving packets while True: try: data_pkt = receiver_socket.recv(1024) except: print('Error: paeket error') sys.exit(2) # Process received packet data_packet = packet.parse_udp_data(data_pkt) # Recevied packet is file data if data_packet.type == 1: # Record received packet sequence number Arrive_log.write('%d\n' % data_packet.seq_num) # Update expected sequence number and write data to file if the sequence is expected if data_packet.seq_num == next_seqnum: file.write(data_packet.data) next_seqnum += 1 next_seqnum = next_seqnum % packet.SEQ_NUM_MODULO ACK_pkt = packet.create_ack(data_packet.seq_num) first = False # Otherwise, ignore and resend the last/duplicate ACK else: last_ACK_seqnum = next_seqnum - 1 if (last_ACK_seqnum < 0): last_ACK_seqnum = 31 ACK_pkt = packet.create_ack(last_ACK_seqnum) # Stop sending any ACK if it is first time and sequence number is not expected if not first: receiver_socket.sendto(ACK_pkt.get_udp_data(), (naddr, host_port)) counter += 1 # Recevied packet is EOT elif data_packet.type == 2: receiver_socket.sendto( packet.create_eot(next_seqnum - 1).get_udp_data(), (naddr, host_port)) sys.exit(0) # Close files file.close() Arrive_log.close()
serverSocket.bind(('', receiveDataPort)) expectingPacket = 0 f = open(filename, "w") while True: UDPdata, clientAddress = serverSocket.recvfrom( 2048 ) p = packet.parse_udp_data(UDPdata) returnPacket = None # if data if p.type == 1: if p.seq_num == expectingPacket % packet.SEQ_NUM_MODULO: f.write(p.data) # read and write to file expectingPacket = expectingPacket + 1 returnPacket = packet.create_ack( expectingPacket % packet.SEQ_NUM_MODULO - 1) # send if not expectingPacket == 0: # if received atleast one good packet serverSocket.sendto( returnPacket.get_udp_data() , (hostAddress, sendAckPort)) # if eot elif p.type == 2: returnPacket = packet.create_eot(-1) # send serverSocket.sendto( returnPacket.get_udp_data() , (hostAddress, sendAckPort)) break f.close() serverSocket.close()
if message_packet.seq_num == expected_seq_num: done_first_packet = True cur_packet_seq_num = expected_seq_num if message_packet.type == 1: out_file_stream.write(message_packet.data) expected_seq_num = (expected_seq_num + 1) % packet.SEQ_NUM_MODULO elif not done_first_packet: continue else: cur_packet_seq_num = \ (packet.SEQ_NUM_MODULO + (expected_seq_num - 1)) % packet.SEQ_NUM_MODULO # send ack if message_packet.type == 2: # EOT ack_packet = packet.create_eot(cur_packet_seq_num) else: ack_packet = packet.create_ack(cur_packet_seq_num) out_socket.sendto(packet.get_udp_data(ack_packet), (emu_addr, emu_port)) if message_packet.type == 2: # since we got EOT, exit break out_file_stream.close()
def main(): #get arguments emulator_hostname = sys.argv[1] emulator_port = sys.argv[2] receiver_port = sys.argv[3] output_file = sys.argv[4] #create udp connection to emulator udpSocket = socket(AF_INET, SOCK_DGRAM) udpSocket.bind(('', int(receiver_port))) #set up needed variables expected_sequence_number = 0 current_sequence_number = -1 first_packet = False #clean output file open("arrival.log", "w").close() open("output.txt", "w").close() #receive packet from emulator while True: udp_data, address = udpSocket.recvfrom(2048) packet_received = packet.parse_udp_data(udp_data) sequence_number = packet_received.seq_num #write into arrival.log # print("receiver receives: " + str(sequence_number)) if packet_received.type == 1: file_arrival = open("arrival.log", "a") file_arrival.write(str(sequence_number) + "\n") file_arrival.close() if sequence_number == expected_sequence_number: first_packet = True if packet_received.type == 1: packet_to_send = packet.create_ack(sequence_number) packet_to_send_encode = packet_to_send.get_udp_data() udpSocket.sendto(packet_to_send_encode, (emulator_hostname, int(emulator_port))) # print("receiver ack: " + str(packet_to_send.seq_num)) current_sequence_number = sequence_number expected_sequence_number = (1 + sequence_number) % 32 data = packet_received.data file_output = open(output_file, "a") file_output.write(data) file_output.close() elif packet_received.type == 2: # print("receive eot") packet_to_send = packet.create_eot(sequence_number) packet_to_send_encode = packet_to_send.get_udp_data() udpSocket.sendto(packet_to_send_encode, (emulator_hostname, int(emulator_port))) file_arrival = open("arrival.log", "a") file_arrival.write(str(packet_to_send.seq_num) + "\n") file_arrival.close() # print("receiver ack: " + str(packet_to_send.seq_num)) udpSocket.close() sys.exit() elif first_packet == False: continue else: packet_to_send = packet.create_ack(current_sequence_number) packet_to_send_encode = packet_to_send.get_udp_data() udpSocket.sendto(packet_to_send_encode, (emulator_hostname, int(emulator_port)))
def main(commandlineArgs): # check if correct number of arguments is supplied if not len(commandlineArgs) == 5: print('Error: the number of parameter supplied is incorrect') sys.exit(2) hostAddr = commandlineArgs[1] hostPort = int(commandlineArgs[2]) recvPort = int(commandlineArgs[3]) fileName = commandlineArgs[4] # open log file and to-be-saved file file = open(fileName, 'w+') arrivalLog = open('arrival.log', 'w+') # create packet receiving packet rSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) rSocket.bind(('', recvPort)) expectedSeqNum = 0 firstRun = True # print('Listenning on port: %d' % recvPort) count = 0 # start listening for packets while True: try: udpData = rSocket.recv(1024) except: print('Error: package error') sys.exit(2) # print('new packet') # process received packet dataPackage = packet.parse_udp_data(udpData) # the received packet is data if dataPackage.type == 1: # print('New packet: %d' % dataPackage.seq_num) # print('Expected: %d' % expectedSeqNum) # write newly received packet sequence number to log file arrivalLog.write('%d\n' % dataPackage.seq_num) # if the packet received has the expected sequence number # update expected sequence number and write data to file if dataPackage.seq_num == expectedSeqNum: file.write(dataPackage.data) expectedSeqNum += 1 expectedSeqNum = expectedSeqNum % packet.SEQ_NUM_MODULO ackPkg = packet.create_ack(dataPackage.seq_num) firstRun = False else: # packet sequence number is not expected # resend ack packet with last received sequence number lastAckSeqNum = expectedSeqNum - 1 if (lastAckSeqNum < 0): lastAckSeqNum = 31 ackPkg = packet.create_ack(lastAckSeqNum) # if it's first run and packet sequence number is not correct # don't send any ack packet if not firstRun: rSocket.sendto(ackPkg.get_udp_data(), (hostAddr, hostPort)) count += 1 elif dataPackage.type == 2: # packet type is eot, send a eot packet then exit rSocket.sendto( packet.create_eot(expectedSeqNum - 1).get_udp_data(), (hostAddr, hostPort)) sys.exit(0)