def receive_response(self):
print("Started receiving response.")
while True:
data, sender = self.socket_object.recvfrom(1024)
pkt = Packet.from_bytes(data)
if pkt.packet_type == packet.DATA or pkt.packet_type == packet.FIN:
self.add_to_buffer(Packet.from_bytes(data))
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 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 send_ack(self, pkt):
global client_ip
global router
new_ip = ipaddress.ip_address(socket.gethostbyname(client_ip))
tmp_pkt = Packet(packet_type=packet.ACK,
seq_num=pkt.seq_num,
peer_ip_addr=new_ip,
peer_port=self.client_port,
payload=b'')
print("Sending Ack#", str(pkt.seq_num))
self.socket_object.sendto(tmp_pkt.to_bytes(), router)
def look_ack(self):
# We are continuously looking for acks
while not self.received_all_acks:
# What we are receiving
data, sender = self.socket_object.recvfrom(1024)
pkt = Packet.from_bytes(data)
if pkt.packet_type == packet.ACK:
self.receive_ack(data)
self.received_all_acks = False
def handle_packet(self, data, sender):
"""receive request from the client and send response"""
self.print_debug(
"Connection established with router " + sender[0] + ":" +
str(sender[1]) + " at " +
time.strftime("%a, %d %b %Y %I:%M:%S %p %Z", time.gmtime()))
pkt = Packet.from_bytes(data)
if pkt.packet_type == packet.SYN:
self.print_debug("SYN packet received.")
new_ip = ipaddress.ip_address(socket.gethostbyname(client_ip))
new_pkt = Packet(packet.SYN_ACK, pkt.seq_num, new_ip,
self.client_port, ''.encode('utf-8'))
self.socket_object.sendto(new_pkt.to_bytes(), sender)
print("Sending syn-ack")
print("Handshaking is done from side of server")
self._handshake_done = True
# When data of ACK packet comes
elif self._handshake_done:
if pkt.packet_type == packet.DATA or pkt.packet_type == packet.FIN:
print("Data#", str(pkt.seq_num))
print(pkt.payload.decode('utf-8'))
self.add_to_buffer(pkt)
def perform_handshaking(self, client_port):
global server_ip
global router
new_ip = ipaddress.ip_address(socket.gethostbyname(server_ip))
pkt = Packet(packet.SYN, Packet.packet_num, new_ip, self.server_port,
''.encode('utf-8'))
self.socket_object.bind(('127.0.0.1', client_port))
self.socket_object.sendto(pkt.to_bytes(), router)
res, rout = self.socket_object.recvfrom(1024)
pkt = Packet.from_bytes(res)
if pkt.packet_type == packet.SYN_ACK:
print("Received SYN-ACK packet.")
new_pkt = Packet(packet.ACK, pkt.seq_num, new_ip, self.server_port,
''.encode('utf-8'))
self.socket_object.sendto(new_pkt.to_bytes(), rout)
else:
print("Received an invalid packet during handshaking.")
self.perform_handshaking(client_port)
def receive_ack(self, data):
pkt = Packet.from_bytes(data)
print("Started receiving ack#", str(pkt.seq_num))
# These are for ack window size
start = self.sent_pkt_window[0].seq_num
end = self.sent_pkt_window[len(self.sent_pkt_window) - 1].seq_num
# Check if fin is contained or not
contains_fin = False
for pkts in self.sent_pkt_window:
if pkts.packet_type == packet.FIN:
contains_fin = True
# getting only valid acks
if pkt.packet_type == packet.ACK and start <= pkt.seq_num <= end:
self.ack_window_lock.acquire()
# add to ack_window
self.all_acks_list.append(pkt.seq_num)
self.ack_window.append(pkt.seq_num)
# if all acks for window have been received
if len(set(self.ack_window)) == len(self.sent_pkt_window):
self.received_all_acks = True # This will close the while loop for receving acks # all acks are received
self.check_flag_aks = True # All acks are received for
print("Current Window acks are receved,:", self.ack_window)
# this means every data packet has been sent and ack have been received
if contains_fin:
print("Received ack#", str(pkt.seq_num))
self.received_acks_for_all_data = True
print(
"Received acks for all data, continue to receive response."
)
if self.ack_window_lock.locked():
self.ack_window_lock.release() # I added this
threading.Thread(target=self.receive_response,
args=()).start()
return
else:
# continue receiving acks
print("Received ack#", pkt.seq_num)
if self.ack_window_lock.locked():
self.ack_window_lock.release()
def create_payload_packets(self, payload, last_pkt):
print("Creating packets started")
global client_ip
global router
self.res_conf2()
MAX_PAYLOAD = packet.MAX_LEN - packet.MIN_LEN
current_byte = [0, 0]
def num_bytes(n):
current_byte[0], current_byte[1] = current_byte[
1], current_byte[1] + n
return payload[current_byte[0]:current_byte[1]]
remaining_data = len(payload) # initialize
tmp = last_pkt
print("Payload:", payload)
self.all_acks_list = self.received_pkt_list
while remaining_data > 0:
self.res_conf2()
while self.pkt_sent_count < self.window_size:
print("sending packet %d", tmp)
if remaining_data > MAX_PAYLOAD:
tmp = tmp + 1
new_ip = ipaddress.ip_address(
socket.gethostbyname(client_ip))
p = Packet(packet_type=packet.DATA,
seq_num=tmp,
peer_ip_addr=new_ip,
peer_port=self.client_port,
payload=num_bytes(MAX_PAYLOAD))
self.socket_object.sendto(p.to_bytes(), router)
threading.Thread(target=self.look_ack, args=()).start()
self.sent_pkt_window.append(p)
# Increase Send window +1
self.pkt_sent_count += 1
# decreasing payload
remaining_data -= MAX_PAYLOAD
Packet.packet_num += 1
# For same packet we are threading for resend
threading.Thread(target=self.check_resend_pkt,
args=(p, )).start()
print("not last packet")
else:
tmp += 1
new_ip = ipaddress.ip_address(
socket.gethostbyname(client_ip))
p = Packet(packet_type=packet.FIN,
seq_num=tmp,
peer_ip_addr=new_ip,
peer_port=self.client_port,
payload=num_bytes(remaining_data))
self.socket_object.sendto(p.to_bytes(), router)
"""We have fin number also"""
self.fin_num = tmp
self.sent_pkt_window.append(p)
threading.Thread(target=self.look_ack, args=()).start()
self.pkt_sent_count += 1
remaining_data -= remaining_data
print("remaining data " + str(remaining_data))
print("is last packet")
threading.Thread(target=self.check_resend_pkt,
args=(p, )).start()
break
while not self.check_flag_aks:
pass
self.check_flag_aks = False # I changed it from True to False
self.pkt_sent_count = 0
def handle_packet(self, data, sender):
pkt = Packet.from_bytes(data)
if pkt.packet_type == packet.DATA or pkt.packet_type == packet.FIN:
# send ack
print("Received response-pkt#", str(pkt.seq_num))
def create_payload_packets(self, payload):
print("Creating packets started")
global server_ip
global router
self.res_configuration()
MAX_PAYLOAD = packet.MAX_LEN - packet.MIN_LEN
current_byte = [0, 0]
def num_bytes(n):
current_byte[0], current_byte[1] = current_byte[
1], current_byte[1] + n
return payload[current_byte[0]:current_byte[1]]
remaining_data = len(payload) # initialize
while remaining_data > 0:
# To reset configuration
self.res_configuration()
while self.pkt_sent_count < self.window_size:
print("sending packet %d" % Packet.packet_num)
# this is to create packet
if remaining_data > MAX_PAYLOAD:
new_ip = ipaddress.ip_address(
socket.gethostbyname(server_ip))
p = Packet(packet_type=packet.DATA,
seq_num=Packet.packet_num,
peer_ip_addr=new_ip,
peer_port=self.server_port,
payload=num_bytes(MAX_PAYLOAD))
# send created packed
self.socket_object.sendto(p.to_bytes(), router)
threading.Thread(target=self.look_ack, args=()).start()
# What ever you are sending append to sent window
self.sent_pkt_window.append(p)
# Increase Send window +1
self.pkt_sent_count += 1
# decreasing payload
remaining_data -= MAX_PAYLOAD
self.next_pkt_num += 1
Packet.packet_num += 1
# For same packet we are threading for resend
threading.Thread(target=self.check_resend_pkt,
args=(p, )).start()
print("not last packet")
else:
new_ip = ipaddress.ip_address(
socket.gethostbyname(server_ip))
p = Packet(packet_type=packet.FIN,
seq_num=Packet.packet_num,
peer_ip_addr=new_ip,
peer_port=self.server_port,
payload=num_bytes(remaining_data))
self.socket_object.sendto(p.to_bytes(), router)
self.fin_num = Packet.packet_num # To use in response
self.last_window_seq_num = self.fin_num
self.sent_pkt_window.append(p)
self.pkt_sent_count += 1
remaining_data -= remaining_data
threading.Thread(target=self.look_ack, args=()).start()
self.next_pkt_num += 1
print("remaining data " + str(remaining_data))
print("is last packet")
threading.Thread(target=self.check_resend_pkt,
args=(p, )).start()
break
while not self.check_flag_aks:
pass
self.check_flag_aks = False # I changed it from True to False
self.pkt_sent_count = 0 # I have done it