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
