def receive():
# Establish connection
global buffer
global bufferStatus
global maxLen
global gCounter
sockRec = co.createSocket(co.portReceiverSend)
c, addr = co.allowConn(sockRec)
sockSend = co.createConn(co.portReceiverReceive)
print('Connected to channel')
# Connection established
rn = 0
while True:
# Wait till frame received
print(15 * '-')
frame = sockSend.recv(1024).decode()
print('Frame received ' + frame)
if (frame != '#' and not isValid(
frame, rn)): # wrong frame no received send ack for prev
print('Invalid frame.Not sending ack')
elif (frame != '#'):
ackno = frame[0:3]
ackNo = int(ackno, 2)
buffer[ackNo] = frame[3:7]
bufferStatus[ackNo] = gCounter
# Send an acknowledgement
ack = co.generateAck_gbn(ackno)
time.sleep(5)
# Send the ack
print('Sending ack ' + ack)
co.send_frame(ack, c)
print("DEBUG:", sum(bufferStatus), maxLen * gCounter)
if (sum(bufferStatus) >= maxLen * gCounter):
file = open("output.txt", "a")
print("".join(buffer), end='', file=file)
file.close()
rn = (rn + 1) % (co.window_size + 1)
buffer = co.window_size * ['']
gCounter = gCounter + 1
else:
# For valid frame
maxLen = maxLen - 1
ack = '#'
time.sleep(5)
# Send the ack
print('Sending ack ' + ack)
co.send_frame(ack, c)
print(str(bufferStatus))
print(str(buffer))
print(15 * '-')
# Close the sockets
sockSend.close()
sockRec.close()
def receive():
# Establish connection
sockRec = co.createSocket(co.portReceiverSend)
c, addr = co.allowConn(sockRec)
sockSend = co.createConn(co.portReceiverReceive)
print('Connected to channel')
# Connection established
rn = 0
while True:
# Wait till frame received
print(15 * '-')
frame = sockSend.recv(1024).decode()
print('Frame received ' + frame)
if (frame == '#'):
ack = '#'
else:
if (isValid(frame,
rn) == 0): # wrong frame no received send ack for prev
print('Invalid frame')
print('Sending ack for previous frame')
ackno = (rn) % 2
elif (isValid(frame, rn) == 1):
print('Error in frame')
continue
else: # Valid frame
ackno = (rn + 1) % 2
# For valid data frame
rn = (rn + 1) % 2
# Send an acknowledgement
ack = co.generateAck(ackno)
# Send the ack
print('Sending ack ' + ack)
co.send_frame(ack, c)
if (frame == '#'): # Means end frame
break
print(15 * '-')
# Close the sockets
sockSend.close()
sockRec.close()
def send_all(list_of_frames):
sockSend = co.createSocket(
co.portSenderSend) # sender socket to send data to channel
c, addr = co.allowConn(sockSend)
sockRec = co.createConn(
co.portSenderReceive) # Socket to receive data from channel
sockRec.settimeout(timeoutTime)
print('Connected to channel')
# implementing stop and wait arq
sn = 0
i = 0
while (i < (len(list_of_frames))): # While there are frames send
print(15 * '-')
canSend = True
sn = (i) % 2
stored_frame = list_of_frames[i]
if (stored_frame != '#'):
stored_frame = co.prepare_frame(list_of_frames[i], sn)
print('Sending frame ' + str(i) + ' ' + stored_frame)
co.send_frame(stored_frame, c)
canSend = False
try:
ack = sockRec.recv(1024).decode()
except Exception as e:
# Resend so repeat this iteration of loop
print('Timeout.. Resending')
continue
if (ack == '#'):
break
print('Ack received ' + ack)
if (ack and isValid(ack, sn)): # Wrong acknowledgement
print('Correct ack received')
canSend = True
i = i + 1
elif (not isValid(ack, sn)):
# invalid ack so resend
print('Wrong ack.. resending')
print(15 * '-')
# Close the sockets
sockSend.close()
sockRec.close()
import common as co
import random
import time
import threading
probas = 10
randSendF = 2 # Random probability of sending frame or not
randSendAck = 2
randErrF = -1
randErrAck = -1
# **************** SENDER *****************************
sockSenderReceive = co.createConn(
co.portSenderSend) # Socket to receive data from sender
sockSenderSend = co.createSocket(
co.portSenderReceive) # Socket to send data to sender
senderSend, addr = co.allowConn(sockSenderSend)
print('Channel connected to sender')
#*******************************************************
#****************** RECEIVER **************************
sockReceiverReceive = co.createConn(
co.portReceiverSend) # Socket to receive data from receiver
# sockReceiverReceive.settimeout(11)
sockReceiverSend = co.createSocket(
co.portReceiverReceive) # Socket to send data to receiver
receiverSend, addr = co.allowConn(sockReceiverSend)
print('Channel connected to receiver')
#*******************************************************
if (self.mode == 'guest'
and self.username != reqs['username']):
res.append('Access Denied')
elif (self.username == reqs['username']
or self.mode == 'admin'):
if (reqs['username'] in global_dict):
res.append(global_dict[reqs['username']]._getValue(
reqs['key']))
else:
res.append('Invalid username')
return res
sockServer = co.createSocket(co.portServer)
global_dict = {}
# Function to service a client
def serviceClient(client, clientAddr):
while True:
requestC = clientAddr.recv(1024) # Receive the request dictionary
requestC = pickle.loads(requestC)
res = client.takeAction(requestC)
res = pickle.dumps(res)
clientAddr.sendall(res)
receiveThread.join()
# Close the sockets
sockSend.close()
sockRec.close()
timeoutTime = 17
frame_size = 4
sw = co.window_size
sf = 0
sn = 0
# stored_buffer=[ '' for i in range(sw)]
stored_buffer = {i: '' for i in range(sw)}
print('Demonstrating Go Back N ARQ')
list_of_frames = co.readfile('input.txt', frame_size)
print(list_of_frames)
list_of_frames.append('#') # Attach a blank frame
sockSend = co.createSocket(
co.portSenderSend) # sender socket to send data to channel
sender, addr = co.allowConn(sockSend)
sockRec = co.createConn(
co.portSenderReceive) # Socket to receive data from channel
sockRec.settimeout(timeoutTime)
print('Connected to channel')
send_all(list_of_frames)
import socket
import threading
import common as co
import time
# shared_buffer=[]
sockSenderRec = co.createSocket(co.portSenderReceive)
sockSenderSignal = co.createSocket(co.portSenderSignal)
sockReceiverSend = co.createSocket(co.portReceiverSend)
threadLock = threading.Lock()
def allow_new_conn():
sockReceiverSend.listen(5)
receive, addrrec = sockReceiverSend.accept()
recThread = threading.Thread(target=send_to_receiver, args=[receive])
recThread.start()
while (True):
# Wait for a connection
sockSenderRec.listen(5)
c, addr = sockSenderRec.accept()
print('Connected to sender')
sockSenderSignal.listen(5)
signal, addrsignal = sockSenderSignal.accept()
# Start a new thread for the sender
sendThread = threading.Thread(target=receive_from_sender,
import socket
import threading
import common as co
import time
# shared_buffer=[]
s_sendrec = co.createSocket(co.port_sendrec)
s_sendsignal = co.createSocket(co.port_sendsignal)
s_recsend = co.createSocket(co.port_recsend)
def new_con():
s_recsend.listen(5)
receive, addrrec = s_recsend.accept()
recThread = threading.Thread(target=send_to_receiver, args=[receive])
recThread.start()
while (True):
# Wait for a connection
s_sendrec.listen(5)
c, addr = s_sendrec.accept()
print('Sender is connected...')
s_sendsignal.listen(5)
signal, addrsignal = s_sendsignal.accept()
# Start a new thread for the sender
sendThread = threading.Thread(target=receive_from_sender,
args=[c, addr])
sendThread.start()
elif (self.username == reqs['username']
or self.mode == 'manager'):
if (reqs['username'] in global_dict):
res.append(global_dict[reqs['username']]._getValue(
reqs['key']))
else:
res.append('Invalid username')
elif (reqs['method'].lower() == 'exit'):
#print(self.username+': Exited')
res.append('End')
return res
port_no = input('Enter the port number: ')
sockServer = co.createSocket(int(port_no))
global_dict = {}
# Function to service a client
def serviceClient(client, clientAddr, uname):
while True:
requestC = clientAddr.recv(1024) # Receive the request dictionary
requestC = pickle.loads(requestC)
res = client.takeAction(requestC)
if (res[0] == 'End'):
del global_dict[uname]
print(uname + ': Exited')
break
