def receive(sock):
global mutex
expected_num = 0
while True:
mutex.acquire()
pkt, addr = udt.recv(sock)
if not pkt:
break
seq_num, data = packet.extract(pkt) # packet 수신
print('Got packet', seq_num)
if seq_num == expected_num: # 오류 없이 수신되는 경우
print('Expected packet. Sending ACK', expected_num)
pkt = packet.make(expected_num)
udt.send(pkt, sock, addr)
rtt_q.append([pkt, sock, addr])
rtt_timer.append(time.time())
expected_num += 1
else: # 오류로 인해 순서가 잘못 수신되는 경우
print('Unexpected packet. Sending ACK', expected_num - 1)
pkt = packet.make(expected_num - 1)
udt.send(pkt, sock, addr)
rtt_q.append([pkt, sock, addr])
rtt_timer.append(time.time())
time.sleep(UNIT_TIME)
mutex.release()
def receive(sock, filename):
# Open the file for writing
try:
file = open(filename, 'wb')
except IOError:
print('Unable to open', filename)
return
expected_num = 0 #expected seq no of the packet received
while True:
# Get the next packet from the sender
pkt, addr = udt.recv(sock) #these udt functions are defined in udt.py
if not pkt:
break
seq_num, data = packet.extract(pkt)
print('Got packet', seq_num)
# Send back an ACK
if seq_num == expected_num:
print('Got expected packet')
print('Sending ACK', expected_num)
pkt = packet.make(
expected_num,
'') # ''implies an empty string because it's an ACK
udt.send(pkt, sock, addr)
expected_num += 1
file.write(
data) #this copies the data into a.txt, initially it is empty
else:
print('Sending ACK', expected_num - 1)
pkt = packet.make(expected_num - 1, '')
udt.send(pkt, sock, addr)
file.close()
def receive_gbn(sock, filename):
# try to pen file for writing else throw error
try:
file = open(filename, 'wb')
except IOError:
print("Cannot open %s" % filename)
return
expected_seq = 0
while True:
pkt, addr = udt.recv(sock) # receive packet and check if it's valid
if not pkt: # if we receive a sentinel packet break receive
break
seq, data = packet.extract(pkt) # extract packet sequence number
print("Received packet: %s" % seq)
if seq == expected_seq: # if received sequence # is the expected sequence # send ACKs
print("Received expected packet\nSending ACK: %s" % seq)
pkt = packet.make(seq)
udt.send(pkt, sock, addr)
expected_seq += 1 # increment next expected sequence # and write data to file
print("Writing data to file")
file.write(data)
else: # if not expected sequence # then send ACK for most recent ingested packet
print("Sending ACK for latest packet: %s" % (expected_seq - 1))
pkt = packet.make(expected_seq - 1)
udt.send(pkt, sock, addr)
file.close()
def receive_gbn(sock):
end = ""
packetSeq = 0
sock.settimeout(10)
try:
receivedData = open("receivedData.txt", "a")
while end != "END":
try:
pcket, senderAddress = udt.recv(sock)
except socket.timeout():
print("Time out")
break
seq, packetData = packet.extract(pcket)
print("Packet received: ", seq)
print("Packet Data: ", packetData)
if packetSeq != seq:
print("Ack: ", packetSeq - 1)
pcket = packet.make(packetSeq - 1)
udt.send(pcket, sock, senderAddress)
else:
end = packetData.decode()
pcket = packet.make(packetSeq)
udt.send(pcket, sock, senderAddress)
receivedData.write(end)
packetSeq += 1
except IOError:
print(IOError)
return
def send_snw(sock):
# Access to shared resources
global switch
# Track packet count
seq = 0
# Open file as read
with open(filename, "r") as f:
# iterate through file at increments of packet size
for p in iter(partial(f.read, PACKET_SIZE), b''):
# Lock packet transfer
with mutex:
# Generate Packet & Link Buffer
data = p.encode()
pkt = packet.make(seq, data)
pkt_buffer.append(pkt)
# Handle Thread Timing
switch = True
# Send Packet and Increment Sequence
print("Sending seq# ", seq, "\n")
udt.send(pkt, sock, RECEIVER_ADDR)
seq += 1
# Delay Mutex for sister thread
time.sleep(SLEEP_INTERVAL)
if not p:
break
# Prepare & Send END packet
with mutex:
pkt = packet.make(seq, "END".encode())
pkt_buffer.append(pkt)
udt.send(pkt, sock, RECEIVER_ADDR)
def send_snw(sock, filename):
# open file to be read.
file = open(filename, "r", encoding="utf-8")
#The end of file, nothing else to read.
while (file.tell() != 3460):
ack = seq
#Read bytes from file as determines by PACKET_SIZE
data = file.read(PACKET_SIZE)
data = data.encode()
pkt = packet.make(seq, data)
print("Sending seq# ", seq, "\n")
#Loop through sending attempts until sequence as been updated
#signaling packet has been properly sent and ack received.
while (ack == seq):
udt.send(pkt, sock, RECEIVER_ADDR)
#Start thread for receiver_snw.
snwThread = Thread(target=receive_snw, args=(sock, pkt))
snwThread.start()
#Timeout for receiver_snw thread to complete then continue down path.
snwThread.join(timeout=.5)
#Set stop event so receive_snw stops after timeout.
stop_event.set()
#Sends end of file flag to Receiver socket signaling file has been fully read.
pkt = packet.make(seq, "END".encode())
udt.send(pkt, sock, RECEIVER_ADDR)
def receive(sock, filename):
# Open the file for writing
try:
file = open(filename, 'wb')
except IOError:
print('Unable to open', filename)
return
expected_num = 0
while True:
# Get the next packet from the sender
pkt, addr = udt.recv(sock)
if not pkt:
break
seq_num, data = packet.extract(pkt)
print('Got packet', seq_num)
# Send back an ACK
if seq_num == expected_num:
print('Got expected packet')
print('Sending ACK', expected_num)
pkt = packet.make(expected_num)
udt.send(pkt, sock, addr)
expected_num += 1
file.write(data)
else:
print('Sending ACK', expected_num - 1)
pkt = packet.make(expected_num - 1)
udt.send(pkt, sock, addr)
file.close()
def receive_gbn(sock):
initSeq = 0
seqList = [] #Holds Sequence numbers prev received
f = open("receiver_bio.txt", "w")
dataStr = ''
while True:
#while dataStr!='END':
#print("In true loop") #DEBUG
pkt, senderaddr = udt.recv(sock)
seq, data = packet.extract(pkt)
dataStr = data.decode()
#Does not write if duplicate pkt or FIN pkt
#print("data is "+data.decode()) #DEBUG
print("receiver seq:%d, sender gave:%d" %(initSeq, seq))
#print("data:%s" %(dataStr))
if (seq == initSeq and not dataStr == "END"):
#print("packet fine, writing to file")
f.write(dataStr)
ack = packet.make(initSeq, "ACK".encode())
initSeq = initSeq+1
udt.send(ack, sock, senderaddr)
elif not seq == initSeq:
#print("Not in ordered pkt received")
ack = packet.make(initSeq, "ACK".encode())
elif dataStr == 'END':
print("Received end, we're done")
break
f.close()
def send_gbn(sock):
global num_sent_packets
global num_resent_packets
seq = 0
packets = []
start_time = time.time()
f = open(input("File Name: "), 'rb')
data = f.read(PACKET_SIZE)
while data:
pkt = packet.make(seq, data)
packets.append(pkt)
data = f.read(PACKET_SIZE)
seq += 1
pkt = packet.make(seq, "END".encode())
packets.append(pkt)
while packets:
packetsSent = []
for x in range(WINDOW_SIZE):
pkt = packets.pop(0)
packetsSent.append(pkt)
udt.send(pkt, sock, RECEIVER_ADDR)
num_sent_packets += 1
time.sleep(TIMEOUT_INTERVAL)
receive_gbn(sock, packetsSent)
end_time = time.time()
print("Total number of packets sent:", num_sent_packets, "\n")
print("Number of packets resent:", num_resent_packets, "\n")
print("Time taken to complete file transfer:", end_time - start_time,
"seconds")
return
def receive_snw(sock):
endStr = ''
expectedPacket = 0
# While FIN packet has not been received
while endStr != 'END':
pkt, senderaddr = udt.recv(sock)
SEQ, data = packet.extract(pkt)
endStr = data.decode()
print("From: ", senderaddr, ", SEQ# ", SEQ)
# The received packet was not expected. Send ACK with the correct SEQ number
if expectedPacket != SEQ:
print(
'This packet was not expected. Sending ACK %d' %
expectedPacket, "\n")
pkt = packet.make(expectedPacket)
udt.send(pkt, sock, senderaddr)
# This packet was expected. Send ACK with the next SEQ number expected
else:
print(
'Successfully received SEQ #%d. Sending ACK #%d' %
(SEQ, expectedPacket), "\n")
pkt = packet.make(expectedPacket)
udt.send(pkt, sock, senderaddr)
expectedPacket += 1
# Makes sure that the FIN packet is not added to the text
if endStr != 'END':
file.write(data.decode())
print('FIN has been ACK... Ending connection')
def send_snw(sock): #mod sndr by Jennifer
global threads, sync
threads += 1 #Put name in hat
seq = 0 #Tracks pkt count
# Open local stream
with open(filename, "r") as f:
data = True #Do While Trick
while data:
with mutex: #Lock Context
print("1 - Acquired w/ {}".format(seq+1)) #DEBUG
# Generate Packet & Link Buffer
data = f.read(PACKET_SIZE).encode()
pkt = packet.make(seq, data)
pkt_buffer.append(pkt)
sync = True #Handles Thread timing
# Send Packet and Increment Sequence
udt.send(pkt, sock, RECEIVER_ADDR)
seq += 1
# Delay Mutex for sister thread
time.sleep(SLEEP_INTERVAL)
# Prepare & Send END packet
with mutex:
pkt = packet.make(seq, "END".encode())
pkt_buffer.append(pkt)
udt.send(pkt, sock, RECEIVER_ADDR)
threads -= 1 #Remove name from hat
def receive(sock, filename, drop_prob):
try:
file = open(filename, 'wb')
except IOError:
print('Unable to open', filename)
return
expected_num = 0
while True:
pkt, addr = udt.recv(sock)
if not pkt:
break
seq_num, data = packet.extract(pkt)
print('Got packet', seq_num)
if seq_num == expected_num:
print('Sending ACK', expected_num)
pkt = packet.make(expected_num)
udt.send(pkt, sock, addr, drop_prob)
expected_num += 1
file.write(data)
else:
print('Sending ACK', expected_num - 1)
pkt = packet.make(expected_num - 1)
udt.send(pkt, sock, addr, drop_prob)
file.close()
def send_gbn(sock):
# Access to shared resources
global sync, data, sending, receiving
# Track packet count
seq = 0
# Set data proper
data = []
# Open local stream
with open(filename, "r") as f:
print("[I] SEND - Initial Stream")
for i in range(WINDOW_SIZE):
data = f.read(PACKET_SIZE).encode()
if data:
print("[I] SEND - Pushing to Buffer Pkt# {}".format(seq))
pkt = packet.make(seq, data)
pkt_buffer.append((pkt, seq))
seq += 1
_base = 0
# Sequential File Access
while receiving and (data or pkt_buffer):
# Delay Mutex for sister thread
time.sleep(SLEEP_INTERVAL)
with mutex:
sync = True
print("\n[I] SEND - Acquired Lock")
for pkt in pkt_buffer:
print("[I] SEND - Sending Pkt# {}".format(pkt[1]))
udt.send(pkt[0], sock, RECEIVER_ADDR)
for i in range(base - _base):
data = f.read(PACKET_SIZE).encode()
if data:
pkt = packet.make(seq, data)
pkt_buffer.append((pkt, seq))
seq += 1
_base = base
# Prepare & Send END packet
with mutex:
for i in range(0, 3):
pkt = packet.make(seq, "END".encode()) # Prepare last packet
pkt_buffer.append(pkt)
udt.send(pkt, sock, RECEIVER_ADDR) # Send EOF
print("[I] SEND - Terminating Thread, Buffer Size: {}".format(
len(pkt_buffer)))
sending = False
return
def send_gbn(sock):
global base, timer, mutex
pck_store = []
pkt_seq = 0
filePath = 'Bio.txt' #this can be any desired file path or file name
file = open(filePath,'rb')
data = " "
'''making the packets and storing them in a list'''
while data:
data = file.read(PACKET_SIZE)
pck_store.append(packet.make(pkt_seq, data))
pkt_seq= pkt_seq + 1
#reseting packet sequence number
pkt_seq = 0
'''setting up a variable to store the values within the base of
the window and its top'''
window = WINDOW_SIZE
base = 0
'''starting thread'''
_thread.start_new_thread(receive_gbn,(sock,))
print("Starting....")
while base < len(pck_store):
mutex.acquire()
'''Starting timer.......'''''
if not timer.running():
timer.start()
'''Sending the packets in window and checking that the current pkt sequence
is less than the packets stored in buffer'''
while pkt_seq < (base + window) and pkt_seq < len(pck_store):
udt.send(pck_store[pkt_seq], sock, RECEIVER_ADDR)
print("Sending seq#", pkt_seq, "\n")
pkt_seq = pkt_seq + 1
'''checking for a timer timeout, updating window if no timeout has occurred'''
if timer.timeout():
timer.stop()
print("Timeout occurred, resetting.......")
pkt_seq = base
else:
'''updating window'''''
window = min((len(pck_store)-base),WINDOW_SIZE)
while timer.running() and not timer.timeout():
mutex.release()
time.sleep(SLEEP_INTERVAL)
print("Sleeping......")
mutex.acquire()
mutex.release()
'''sending last packet with the content END'''
pkt = packet.make(pkt_seq, "END".encode())
udt.send(pkt, sock, RECEIVER_ADDR)
file.close()
def send_snw(sock):
# Fill out the code here
seq = 0
while(seq < 20):
data = generate_payload(40).encode()
pkt = packet.make(seq, data)
print("Sending seq#", seq, "\n")
udt.send(pkt, sock, RECEIVER_ADDR)
seq = seq+1
time.sleep(TIMEOUT_INTERVAL)
pkt = packet.make(seq, "END".encode())
udt.send(pkt, sock, RECEIVER_ADDR)
def receive(sock, filename):
# Open the file for writing
try:
file = open(filename, 'wb')
except IOError:
print('Unable to open: ', filename)
return
i = 0
expected_num = 0
arr_of_pack = []
while True:
# Get's next packet
pkt, addr = udt.recv(sock)
if not pkt:
break
seq_num, data = packet.extract(pkt)
print('Got packet :', seq_num)
# Send back ACK dependent on if it is correct
if seq_num == expected_num:
print('Got expected Packet')
print('Sending ACK :', expected_num)
pkt = packet.make(expected_num)
udt.send(pkt, sock, addr)
file.write(data)
expected_num += 1
if len(arr_of_pack) > expected_num:
i = expected_num
if arr_of_pack[expected_num] != 0:
while i < len(arr_of_pack) and arr_of_pack[i] != 0:
print('Writing cashed line to file.')
file.write(arr_of_pack[i])
i = i + 1
expected_num = i
else:
pkt2, _ = udt.recv(sock)
print('Staching duplicate or out of order Packet :', seq_num)
if seq_num >= len(arr_of_pack):
missing = seq_num + 1 - len(arr_of_pack)
i = 0
while i <= missing:
arr_of_pack.append(0)
i = i + 1
arr_of_pack[seq_num] = data
print('Sending ACK of duplicate or out of order Packet :', seq_num)
pkt2 = packet.make(seq_num)
udt.send(pkt2, sock, addr)
print('File finished closeing')
file.close()
def send_gbn(sock):
global base, timer, mutex
packetStore = []
packetSeq = 0
try:
file = open("bio.txt", "r") # reads bio.txt file
data = ' '
while data:
data = file.read(PACKET_SIZE) # makes the packets
packetStore.append(packet.make(
packetStore, data)) # stores packets in packet list
packetSeq += 1 # updates packet sequence counter
base = 0
window = WINDOW_SIZE
packetSeq = 0
# Starting a new thread
_thread.start_new_thread(receive_gbn(sock))
while base < len(packetStore):
mutex.acquire()
if not timer.running():
timer.start()
while packetSeq < len(packetStore) & packetSeq < base + window:
print("\nSending Packet Sequence #:", packetSeq)
udt.send(packetStore[packetSeq], sock, RECEIVER_ADDR)
while not timer.timeout() and timer.running():
print("Sleeping")
mutex.release()
time.sleep(SLEEP_INTERVAL)
mutex.acquire()
mutex.release()
if not timer.timeout():
window = min((len(packetStore) - base), WINDOW_SIZE)
else:
print("\nTimeout occurred")
timer.stop()
packetSeq = base
lastPacket = packet.make(packetSeq, "End".encode())
udt.send(lastPacket, sock, RECEIVER_ADDR)
file.close()
except IOError:
print(IOError)
return
def send_snw(sock):
seq = 0
f = open(input("FileName: "), 'rb')
while True:
data = f.read(PACKET_SIZE)
if not data:
break
pkt = packet.make(seq, data)
print("Sending seq# ", seq, "\n")
udt.send(pkt, sock, RECEIVER_ADDR)
seq = seq + 1
time.sleep(TIMEOUT_INTERVAL)
receive_snw(sock, pkt)
pkt = packet.make(seq, "END".encode())
udt.send(pkt, sock, RECEIVER_ADDR)
def receive_gbn(sock):
seqList = [] #Holds Sequence numbers prev received
f = open("gbn_receiver.txt", "w")
dataStr = ''
#While NO FIN pkt
while dataStr != 'END':
pkt, senderaddr = udt.recv(sock)
seq, data = packet.extract(pkt)
dataStr = data.decode()
#Does not write if duplicate pkt or FIN pkt
#print("data is "+data.decode()) #DEBUG
if (seq not in seqList and not dataStr == "END"):
f.write(dataStr)
#Data recv, ensure duplicate packets are ignored
seqList.append(seq)
#print("From: ", senderaddr, ", Seq# ", seq, dataStr) #DEBUG
#Send back ACK to confirm rcpt.
#If ACK lost, retransmission happens on sender side :)
ack = packet.make(seq, "ACK".encode())
udt.send(ack, sock, senderaddr)
#TODO
#I think instead of checking against an entire list we can
#just have it check to see if ACK is
#Sends ACK back to sender to confirm receipt
#Obviously a list is unfeasible for modern comms
#Ex.) Imagine trying to hold a list of ACKs for 512b from a 5GB file??
# That would be like 10 million numbers lol
f.close()
def receive_gbn(sock):
# Fill here
sock.settimeout(10)
try: # open file
file = open('./files/receiver_bio.txt', 'a')
except: # cannot create file
print('Could Access location')
sys.exit(1)
previous = -1
while True:
try:
clientPacket, clientAddress = udt.recv(sock)
except:
print('Server Shutting Down')
sys.exit(1)
clientSequence, clientData = packet.extract(clientPacket)
print('Received client sequence', clientSequence)
if previous + 1 == clientSequence:
file.write(clientData.decode()) # write data to file
previous = clientSequence # update last seen client sequence
acknowledgement = packet.make(clientSequence,
str(clientSequence).encode())
udt.send(acknowledgement, sock, clientAddress)
return
def receive_snw(sock, filename):
global ack
endStr = ''
prevData = '' #Holds previous data incase of packet drop from Receiver to Sender
#If data from packet contains 'END', receive stream has ended.
while endStr != 'END':
#Extracts packet and sender address from socket.
pkt, senderaddr = udt.recv(sock)
#Extracts sequence number and data from packet.
seq, data = packet.extract(pkt)
#If data equals the previous data sent then packet was dropped from Receiver
#to sender. Resend previous ack number with data.
if data == prevData:
print(
"Data received is previous data received. Resending previous ack."
)
if (ack == 0):
pkt = packet.make(ack + 1, data)
udt.send(pkt, sock, senderaddr)
else:
pkt = packet.make(ack - 1, data)
udt.send(pkt, sock, senderaddr)
#If sequence does not equal ack from Sender then packet dropped causing
#misorder. Send the correct sequence from Receiver back to Sender.
elif (seq != ack):
print("Seq ", seq, " and ack ", ack,
" do not match. Waiting for resend.")
pkt = packet.make(ack, data)
udt.send(pkt, sock, senderaddr)
#Sequence matches ack from Sender.
#Write data to new file, incrememnt Receiver ack, send back the Sender ack
#to acknowledge receieved proper sequenced number.
else:
print("Seq ", seq, " and ack ", ack, " match. Will write to file.")
endStr = data.decode()
file = open(filename, "a")
file.write(endStr)
pkt = packet.make(ack, data)
prevData = data
if (ack == 0):
ack = 1
else:
ack = 0
udt.send(pkt, sock, senderaddr)
def package_payload(payload):
# We split up the payload into packets with packet size, while keeping track of the
# sequence number and the data to turn into a packet
packets = []
packet_data = b''
seq_num = 0
for i in range(len(payload)):
packet_data = packet_data + payload[i:i+1]
if len(packet_data) == PACKET_SIZE:
packets.append(packet.make(seq_num, packet_data))
packet_data = b''
seq_num += 1
if len(packet_data) > 0:
packets.append(packet.make(seq_num, packet_data))
return packets
def mod_snw(sock):
seq = 0
#Opens file and reads first 512 bytes to get the ball rolling
#From there, sends those 512 and reads another 512 bytes
#Once file is emptied, sends FIN Packet
with open("helloFr1end.txt", "rb") as file:
data = file.read(PACKET_SIZE)
while data:
pkt = packet.make(seq, data)
print("Sending seq ", seq, "\n")
udt.send(pkt, sock, RECEIVER_ADDR)
seq = seq+1
time.sleep(TIMEOUT_INTERVAL)
data = file.read(PACKET_SIZE)
pkt = packet.make(seq, "END".encode())
udt.send(pkt, sock, RECEIVER_ADDR)
def send(sock, filename, drop_prob):
global mutex
global base
global send_timer
try:
file = open(filename, 'rb')
except IOError:
print('Unable to open', filename)
return
packets = []
seq_num = 0
while True:
data = file.read(PACKET_SIZE)
if not data:
break
packets.append(packet.make(seq_num, data))
seq_num += 1
num_packets = len(packets)
print('Total number of packets: ', num_packets)
window_size = set_window_size(num_packets)
next_to_send = 0
base = 0
_thread.start_new_thread(receive, (sock, ))
while base < num_packets:
mutex.acquire()
while next_to_send < base + window_size:
print('Sending packet', next_to_send)
udt.send(packets[next_to_send], sock, RECEIVER_ADDR, drop_prob)
next_to_send += 1
if not send_timer.running():
print('Starting timer')
send_timer.start()
while send_timer.running() and not send_timer.timeout():
mutex.release()
print('Sleeping')
time.sleep(SLEEP_INTERVAL)
mutex.acquire()
if send_timer.timeout():
print('Timeout')
send_timer.stop()
next_to_send = base
else:
print('Shifting window')
window_size = set_window_size(num_packets)
mutex.release()
udt.send(packet.make_empty(), sock, RECEIVER_ADDR, drop_prob)
file.close()
def send(sock, numbers):
#global mutex
global base
global send_timer
# Add all the packets to the buffer
packets = []
seq_num = 0
while True:
if seq_num >= len(numbers):
break
data = numbers[seq_num]
packets.append(packet.make(seq_num, data))
seq_num += 1
num_packets = len(packets)
print('I got', num_packets, ' to send')
window_size = set_window_size(num_packets)
next_to_send = 0
base = 0
# Start the receiver thread
thread.start_new_thread(receive, (sock, ))
while base < num_packets:
mutex.acquire()
# Send all the packets in the window
while next_to_send < base + window_size:
print('Sending packet', next_to_send)
sock.sendto(packets[next_to_send], RECEIVER_ADDR)
next_to_send += 1
# Start the timer
if not send_timer.running():
print('Starting timer')
send_timer.start()
# Wait until a timer goes off or we get an ACK
while send_timer.running() and not send_timer.timeout():
mutex.release()
print('Sleeping')
time.sleep(SLEEP_INTERVAL)
mutex.acquire()
if send_timer.timeout():
# Looks like we timed out
print('Timeout')
send_timer.stop()
next_to_send = base
else:
print('Shifting window')
window_size = set_window_size(num_packets)
mutex.release()
# Send empty packet as sentinel
sock.sendto(packet.make_empty(), RECEIVER_ADDR)
def send_snw(sock):
# Access to shared resources
global sync, data, alive
# Track packet count
seq = 0
# Open local stream
with open(filename, "r") as f:
# Sequential File Access
while data:
# Lock Context
with mutex:
# Debugging Info
print("[I] SEND - Acquired Lock")
# Generate Packet & Link Buffer
data = f.read(PACKET_SIZE).encode()
pkt = packet.make(seq, data)
pkt_buffer.append(pkt)
# Handle Thread Timing
sync = True
# Send Packet and Increment Sequence
udt.send(pkt, sock, RECEIVER_ADDR)
seq += 1
# Delay Mutex for sister thread
time.sleep(SLEEP_INTERVAL)
# Prepare & Send END packet
with mutex:
pkt = packet.make(seq, "END".encode()) # Prepare last packet
pkt_buffer.append(pkt)
udt.send(pkt, sock, RECEIVER_ADDR) # Send EOF
alive = false
def send_gbn(sock):
seq = 0
packets = []
f = open(input("File Name: "), 'rb')
data = f.read(PACKET_SIZE)
while data:
pkt = packet.make(seq, data)
packets.append(pkt)
data = f.read(PACKET_SIZE)
seq += 1
pkt = packet.make(seq, "END".encode())
packets.append(pkt)
while packets:
packetsSent = []
for x in range(WINDOW_SIZE):
pkt = packets.pop(0)
packetsSent.append(pkt)
udt.send(pkt, sock, RECEIVER_ADDR)
time.sleep(TIMEOUT_INTERVAL)
receive_gbn(sock, packetsSent)
def receive_snw(sock):
endStr = ''
f = open("receiver_file_x.txt", "w")
while endStr != 'END':
pkt, senderaddr = udt.recv(sock)
seq, data = packet.extract(pkt)
endStr = data.decode()
if endStr != "END":
f.write(endStr)
print("From: ", senderaddr, ", Seq# ", seq, "Data ", endStr, "\n")
pkt = packet.make(seq, data)
udt.send(pkt, sock, senderaddr)
def receive_gbn(sock):
previous = -1
packets = []
addr_connection = None
while True:
try:
p, addr = udt.recv(sock)
seq_num, payload = packet.extract(p)
# If this is a new connection, save address and store expected payload length
if addr_connection == None and seq_num == 0:
addr_connection = addr
# if packet received was from the expected sender...
if addr == addr_connection:
# if packet signals end of transmission, stop listening for packets
if seq_num == -1 and payload == b'FIN':
print("File received successfully.")
break
# if sequence number is what we're expecting, send an ack and append packet contents to packet stack
if seq_num == previous + 1:
udt.send(packet.make(seq_num, b'ACK'), sock, addr)
packets.append((seq_num, payload))
previous += 1
print("Received packet: {}".format(seq_num))
# retransmit ack for last-received packet
else:
if len(packets) > 0:
udt.send(packet.make(packets[-1][0], b'ACK'), sock, addr)
except ConnectionError as e:
print(e)
return -1
# because packet list contains sequence numbers, simply form a list
return list(dict(packets).values())
def receive_gbn(sock):
'''file created to save received packets'''
try:
file_out = open('receiver_bio.txt', 'a')
except IOError:
print("File not created")
return
endStr = ''
expected_seq = 0
'''if socket doesnt receive info in 10 seconds, then end communication'''
sock.settimeout(10)
while endStr != 'END':
'''checking if sender continues to transmit data'''
try:
pkt, senderaddr = udt.recv(sock)
except socket.timeout:
print('Sender seems inactive......')
print('Shutting down receiver.....')
break
seq, data = packet.extract(pkt)
print("Received Packet: ",seq)
if seq == expected_seq:
'''extracting valid packet contents and appending contents to receiver_bio.txt file'''
endStr = data.decode()
print("From: ", senderaddr, ", Seq# ", seq, endStr)
print("Sending ACK:", expected_seq)
pkt = packet.make(expected_seq)
udt.send(pkt, sock, senderaddr)
file_out.write(endStr)
expected_seq = expected_seq + 1
else:
##Sending last valid ACK
print("Sending ACK:",expected_seq-1)
pkt = packet.make(expected_seq-1)
udt.send(pkt,sock,senderaddr)
print("End of transmission")
file_out.close()
def send(sock, filename):
global mutex
global base
global send_timer
# Open the file
try:
file = open(filename, 'rb')
except IOError:
print('Unable to open', filename)
return
# Add all the packets to the buffer
packets = []
seq_num = 0
while True:
data = file.read(PACKET_SIZE)
if not data:
break
packets.append(packet.make(seq_num, data))
seq_num += 1
num_packets = len(packets)
print('I gots', num_packets)
window_size = set_window_size(num_packets)
next_to_send = 0
base = 0
# Start the receiver thread
_thread.start_new_thread(receive, (sock,))
while base < num_packets:
mutex.acquire()
# Send all the packets in the window
while next_to_send < base + window_size:
print('Sending packet', next_to_send)
udt.send(packets[next_to_send], sock, RECEIVER_ADDR)
next_to_send += 1
# Start the timer
if not send_timer.running():
print('Starting timer')
send_timer.start()
# Wait until a timer goes off or we get an ACK
while send_timer.running() and not send_timer.timeout():
mutex.release()
print('Sleeping')
time.sleep(SLEEP_INTERVAL)
mutex.acquire()
if send_timer.timeout():
# Looks like we timed out
print('Timeout')
send_timer.stop();
next_to_send = base
else:
print('Shifting window')
window_size = set_window_size(num_packets)
mutex.release()
# Send empty packet as sentinel
udt.send(packet.make_empty(), sock, RECEIVER_ADDR)
file.close()
