def init_trig_with_BuzzandTemp(motion):
"""
Waits up to 4 seconds until corresponding sensor is triggered.
If sensor triggered and temperature sensor not been triggered prior,
buzzer will go off.
If had triggered prior, direction of movement sent as message to server.
Parameters:
motion(int): Second motion sensor pin
"""
for x in range(40):
# Loop for 40 iterations.
time.sleep(0.1)
# Delay for 10ms.
if (GPIO.input(motion) == 1):
# Determines if corresponding motion sensor is triggered.
if (motion == 1) and (!tempSensor.scanned):
# Determines if user enters without temp scan.
GPIO.setup(buzzerPin, GPIO.OUT)
# Set buzzerPin to output mode.
GPIO.output(buzzerPin, GPIO.HIGH)
# Set buzzerPin high.
time.sleep(2)
# Delay for 2 seconds.
GPIO.output(buzzerPin, GPIO.LOW)
# Set buzzerPin low.
print("BUZZ")
break
else:
TCP.client(str(motion))
# Sends direction of motion as message to the connected server.
tempSensor.scanned = False
break
def speed(time, distance):
"""
Calculates and sends speed as a message to server.
Parameters:
time(float): Time given in seconds
distance(float): Distance given in meters
"""
speed = distance/time
# Calculates speed in meters/second.
TCP.client(str(speed))
def init_trig(motion):
"""
Waits up to 4 seconds until corresponding sensor is triggered.
motion(int): Second motion sensor pin
"""
for x in range(40):
# Loop for 40 iterations.
time.sleep(0.1)
# Delay for 10ms.
if (GPIO.input(motion) == 1):
# Determines if corresponding motion sensor is triggered.
TCP.client(str(motion))
# Sends direction of motion as message to the connected server.
break
def open(self):
if self.enable:
logger.debug('Opening {} TCP.'.format(self.name))
# check for an old socket and delete it
if self.sock is not None:
logger.debug('Closing previously open sock.')
try:
self.sock.close()
except Exception as e:
logger.debug('Ignoring exception during sock.close() of previously open sock.\n{}\n'.format(e))
try:
del self.sock
except Exception as e:
logger.debug('Ignoring exception during sock.close() of previously open sock.\n{}\n'.format(e))
# Create a TCP/IP socket
logger.debug('{}.open() opening sock'.format(self.name))
try:
self.sock = TCP.CsClientSock(self.IP, self.port, parent=self)
except Exception as e:
logger.warning('Failed to open TCP socket in {}.open():\n{}\n'.format(self.name, e))
raise PauseError
logger.debug('{}.open() sock opened'.format(self.name))
self.connected = True
def client():
s = TCP.make_socket(9800, TCP.AF_INET, 0.9)
print('bind', s.bind())
print(s.connect(socket.gethostname(), 10000))
print(s.dest_addr)
print('timeout interval', s.estimated_RTT + s.dev_RTT * 4)
def tcp_conn(netid, port, tout):
global proto
i = 1
a = []
print("Gathering host IP's now, remember that patience is a virtue...")
try:
stime = time.time()
while i < 255:
host = netid + "." + str(i)
if TCP.connect(host, port, tout):
a.append(host)
i += 1
etime = time.time()
duration = etime - stime
except socket.error:
print("A socket error has occured, exiting")
sys.exit(0)
except KeyboardInterrupt:
sys.exit(0)
# Print awake hosts, if any.
print("Tests took " + str(int(duration)) + " seconds with a " + str(tout) +
" timeout")
if len(a) > 0:
print("The following hosts are running " + proto +
" server software :")
# Do not sort array, it's already done due to i var being incremented.
for x in a:
print(x)
else:
print("No hosts are awake or they're just not responding to " + proto +
" requests")
def server():
if len(sys.argv) != 2:
print("Error: insertion of arguments file missed!")
exit()
server_port_number, \
sending_sliding_window_size, \
random_generate_seed_value, \
loss_probability = get_server_data()
w = int(sending_sliding_window_size)
tcp_socket = TCP.make_socket(int(server_port_number), TCP.AF_INET,
float(loss_probability), w, True)
print("PLP :", tcp_socket.loss_probability)
print("")
if not tcp_socket.bind():
print("Error : Cannot bind a busy port !")
exit()
while True:
success_flag, s = tcp_socket.accept()
if success_flag:
print("Client Accepted !")
serverThread(s).start()
def Pack_tcp_packet(ip_src,port_src,ip_dst,port_dst,mac_src,mac_dst,flags,**kwargs): tcp = TCP.TCP(ip_src,port_src,ip_dst,port_dst,"") if "urg" in flags: tcp.set_urg() if "ack" in flags: tcp.set_ack() if "psh" in flags: tcp.set_psh() if "rst" in flags: tcp.set_rst() if "syn" in flags: tcp.set_syn() if "fin" in flags: tcp.set_fin() if "acknowledgment_number" in kwargs: tcp.acknowledgment_number = kwargs["acknowledgment_number"] if "sequence_number" in kwargs: tcp.sequence_number = kwargs["sequence_number"] if "payload" in kwargs: tcp.payload= kwargs["payload"] tcp_header = tcp.Pack() ip = IP.IP(ip_src,ip_dst,tcp_header) ip_header = ip.Pack() mac_src = Convert_mac_address(mac_src) mac_dst = Convert_mac_address(mac_dst) ethernet = Ethernet.Ethernet(mac_src,mac_dst,0x0800,ip_header) packet = ethernet.Pack() return packet,tcp.sequence_number
def initialize(self):
"""Open the TCP socket"""
if self.enable:
self.socket = TCP.CsClientSock(self.IP, self.port)
# TODO: add here some sort of communications check to see if it worked
self.isInitialized = True
def sendRecording(file_path):
AWS_socket = tcp.TCPsocket()
AWS_socket.connect(AWS_IP, AWS_FILE_PORT)
try:
AWS_socket.sendFile(file_path)
os.remove(file_path)
except:
print("Error sending file: " + file_path)
pass
def client():
if len(sys.argv) != 2:
print(bcolors.FAIL + "Error: insertion of arguments file missed!" +
bcolors.ENDC)
exit()
server_ip, server_port_number, client_port_number, file_name, receiveing_sliding_window_size = get_client_data(
)
s = TCP.make_socket(int(client_port_number), TCP.AF_INET,
0) # check for IPv6
if not s.bind():
print(bcolors.FAIL +
"error : please change port number [ port busy ] " +
bcolors.ENDC)
exit(1)
if server_ip == "localhost":
s.connect(socket.gethostname(), int(server_port_number))
else:
s.connect(server_ip, int(server_port_number))
s.send(file_name)
data = s.receive()
if data == "error":
print(bcolors.FAIL + "Error: File not Found !" + bcolors.ENDC)
else:
file = open(file_name.split("\\")[-1], "ab")
num_of_packets = int(data)
print('Number of packets :', num_of_packets)
before = time.time()
for i in range(0, num_of_packets, 1):
data = s.receive()
percentage = int(i * 100 / num_of_packets)
my_print(percentage, i, num_of_packets, True)
file.write(data)
reception_time = time.time() - before
my_print(100, num_of_packets, num_of_packets, False)
print("Success: File Reception Completed !")
s.close()
print("\nStatistics :-")
print("Reception Time =", "{0:.2f}".format(reception_time), "Sec")
print("Average Speed =",
"{0:.2f}".format(num_of_packets / reception_time), "Packets/Sec")
def server():
s = TCP.make_socket(10000, TCP.AF_INET, 0.9)
print('bind', s.bind())
flag, another_server = s.accept()
print(flag)
print(another_server)
print(another_server.dest_addr)
print('timeout interval', s.estimated_RTT + s.dev_RTT * 4)
class RemotePlayer(Player):
#gets information on moves from a remote player using a TCP socket server and stuff
#needs to be player 2 in the game
def __init__(self, game):
self.tcp = TCP("127.0.0.1", "5005")
self.game.players[0].set_connection(self.tcp)
def select_piece(self):
data = self.tcp.receive_piece()
while data == None:
print "No data received"
return int(data)
def select_position(self, piece):
data = self.tcp.receive_position()
while data == None:
print "No data received"
return int(data)
class RemotePlayer(Player):
#gets information on moves from a remote player using a TCP socket server and stuff
#needs to be player 2 in the game
def __init__(self, game):
self.tcp = TCP("127.0.0.1", "5005")
self.game.players[0].set_connection(self.tcp)
def select_piece(self):
data = self.tcp.receive_piece()
while data == None:
print "No data received"
return int(data)
def select_position(self, piece):
data = self.tcp.receive_position()
while data == None:
print "No data received"
return int(data)
def feverScanner(maxtemp):
"""
Determines if an individual is standing infront of the temperature sensor,
waits a full second and reads the temperature value again to gain a more
stable value. Also determines if temperature is above that of the norm.
This data is relayed as a message to the server.
"""
global init
global scanned
tempReading()
if (tdata[0] > roomtemp) and (tdata[0] > 30):
if (!init):
init = True
feverScanner()
else:
init = False
scanned = True
TCP.client(str(tdata[0]))
if (tdata[0]) > maxtemp:
scanned = False
time.sleep(1)
def UnPack_tcp_packet(packet):
tcp = None
try:
ethernet = Ethernet.Ethernet("","","","")
ethernet_payload = ethernet.UnPack(packet)
ip = IP.IP("","","")
ip.UnPack(ethernet.Ethernet_payload)
tcp = TCP.TCP("","","","","")
tcp.UnPack(ip.payload)
except Exception,e:
return None
def __init__(self, GaiaZomgLib, IP='208.85.93.217', PORT=8080):
self.GaiaZomgLib = GaiaZomgLib
self.IP = IP
self.PORT = PORT
self.TCP = TCP.TCPClient()#(IP, PORT, 1024)
self.decoding_thread = threading.Thread(target=self.decode_packets)
#self.decoding_thread.start()
self.CID = 4
self.event_packet_decoded = Event()
def __init__(self, IP="0.0.0.0", volume_port=5005, dance_port=4204):
self.IP = IP
self.dance_port = dance_port
self.volume_port = volume_port
self.danceDataQueue = queue.Queue()
self.audioFileQueue = queue.Queue()
self.commandQueue = queue.Queue()
self.audioConnection = tcp.TCPsocket()
#get rid of this try block
try:
self.audioConnection.listen(self.IP, self.volume_port)
except:
print("WTFWTFWTF")
pass
def controlInterface():
try:
AWS_socket = tcp.TCPsocket()
AWS_socket.connect(AWS_IP, AWS_COMMAND_PORT)
print("Connected to AWS control interface on port " + str(AWS_COMMAND_PORT))
while True:
message = AWS_socket.receiveMessage()
if message.lower() == "file":
AWS_socket.sendFile(RECORD_QUEUE.get())
elif message in COMMANDS:
# AWS_socket.sendMessage("Received: " + message)
COMMAND_QUEUE.put(message)
if message.lower() == "stop":
AWS_socket.closeSocket()
break
else:
AWS_socket.sendMessage("Invalid command: " + message)
except:
print("Lost connection to AWS control interface")
global LOST_CONNECTION_FLAG
LOST_CONNECTION_FLAG = 1
def validatePacket(packet):
if not IP.validateChecksumZero(packet[0:20]):
return False, "IP"
else:
print "IP VALIDATION: SUCCESS"
ip_header = IP.unpackHeader(packet[0:20])
#Get Length of IP header
ip_ver = ip_header[0] >> 4
ip_header_length = ip_header[0] & 0xF
ip_length = ip_header_length * 4
tcp_packet = packet[ip_length:]
pseudo = pack('!4s4sBBH', ip_header[8], ip_header[9], 0, socket.IPPROTO_TCP, len(tcp_packet))
if not TCP.validateChecksumZero(pseudo + tcp_packet):
return False, "TCP"
else:
print "TCP VALIDATION: SUCCESS"
return True, ""
import TCP
server = TCP.ThreadedServer('192.168.22.1',5000,62)
server.listen()
def getACK(source_ip, destination_ip, packet_id, source_port, destination_port, SEQ_NUM, ACK_NUM, data, window_size):
tcp_header = TCP.createTCPHeader(source_ip, destination_ip, source_port, destination_port, SEQ_NUM, ACK_NUM, data, window_size, [0, 0, 0, 0, 1, 0])
ip_header = IP.createIPHeader(source_ip, destination_ip, packet_id, tcp_header, data)
packet = ip_header + tcp_header + data
return packet
def __init__(self, game):
self.tcp = TCP("127.0.0.1", "5005")
self.game.players[0].set_connection(self.tcp)
#!/usr/bin/env python2
# -*- coding: utf-8 -*
from TCP import *
servidor = TCP()
servidor.server('localhost', 45000)
output = a.stdout.read()
a.stdout.close()
a.stdin.close()
return output
##########################################
#MAIN
##########################################
if __name__ == "__main__":
begin_flag = 1
audioStream = threading.Thread(
target=runFileServer) # should this be processs or thread ?
audioStream.start()
visualizer = tcp.TCPsocket()
visualizerThread = threading.Thread(target=visualizer.listen,
args=[IP, VISUALIZER_PORT])
visualizerThread.start()
mainInterface = CentralIO()
danceIOThread = threading.Thread(target=mainInterface.danceServer)
#danceIOThread.start()
volumeControl = VolumeController()
audioIOThread = threading.Thread(target=mainInterface.audioIO)
audioIOThread.start()
volume = 5 # set this as the begining
epoch = 0
while (True):
epoch += 1
def connect(
self,
remote_address): # real signature unknown; restored from __doc__
"""
connect(address)
Connect the socket to a remote address. For IP sockets, the address
is a pair (host, port).
"""
# init remote_address
self.__remote_address = remote_address
# connect to IP layer
print('connecting to IP layer')
self.__ip = IP.IP(IP.PROTOCOL_TCP,
self.__local_address[0],
dst_ip=remote_address[0])
print('connected to IP layer')
# generate client_isn
self.__isn = random.randint(0, 2147483645)
client_isn = self.__isn
print('generated isn', self.__isn)
# build a tcp object with SYN
tcp = TCP()
tcp.build(type=tcp.SEND_SYN,
src_port=self.__local_address[1],
dst_port=remote_address[1],
sequence_number=self.__isn)
# sign a space in buffer_list
buffer_list['connecting'][remote_address] = []
# sent tcp object
self.__ip.send(bytes(tcp))
print('sent tcp object')
# record first_package_sent_time
first_package_sent_time = time.time()
# wait for sencond hanshake
print('waiting for sencond hanshake')
star_time = time.time()
flag_3 = True
flag_6 = False
flag_12 = False
while buffer_list['connecting'][remote_address] == []:
if flag_3 and time.time() - star_time >= 2:
print('3s timeout')
self.__ip.send(bytes(tcp))
flag_3 = False
flag_6 = True
star_time = time.time()
elif flag_6 and time.time() - star_time >= 2:
print('6s timeout')
self.__ip.send(bytes(tcp))
flag_6 = False
flag_12 = True
star_time = time.time()
elif flag_12 and time.time() - star_time >= 2:
print('12s timeout')
self.__ip.send(bytes(tcp))
flag_12 = False
star_time = time.time()
elif time.time() - star_time >= 4:
print('break')
return
continue
self.status = 'established'
# record first_package_receive_time
self.__sample_RTT = time.time() - first_package_sent_time
self.__estimated_RTT = self.__sample_RTT
self._get_new_timeout()
print('fisrt sampleRTT inited, it\'s', self.__sample_RTT)
# retrive data
data = buffer_list['connecting'][remote_address].pop()
print('retrived')
# parse tcp object
tcp = TCP()
tcp.from_bytes(data)
# check tcp object is right
if not (tcp.SYN == 1 and tcp.ACK == 1
and tcp.acknowledgement_number == client_isn + 1):
print('the tcp object is not right. Connect failed')
return
# if it's right, update server_isn, client_isn
server_isn = tcp.sequence_number
client_isn += 1
self.__next_sequence_number = client_isn
print('client_isn sent', client_isn)
self.__last_ack_received = tcp.acknowledgement_number
# remove from buffer_list['connecting'], added to buffer_list['connected']
buffer_list['connecting'].pop(remote_address)
buffer_list['connected']['objects'][remote_address] = self
# generate last_ack_sent and update ack_to_be_sent list, last_ack_received
self.__last_acked_sent = server_isn + 1
self.__ack_to_be_sent.append(self.__last_acked_sent)
# start sending thread
self.__sending_process = threading.Thread(target=self._sending_thread)
self.__sending_process.start()
print('connected')
def _sending_thread(self):
# build empty tcp object
tcp = TCP()
tcp.build(type=tcp.SEND_DATA,
src_port=self.__local_address[1],
dst_port=self.__remote_address[1])
tcp.sequence_number = self.__next_sequence_number
tcp.acknowledgement_number = self.__last_acked_sent
print('built empty tcp object')
while 1:
time.sleep(0.2)
# print('sending thread begin')
# detect whether there is act_to_be_sent
if self.__ack_to_be_sent != []:
tcp.ACK = 1
tcp.acknowledgement_number = self.__ack_to_be_sent.pop()
self.__last_acked_sent = tcp.acknowledgement_number
print(
'detect there is ack_to_be_sent({}), added to current tcp object, last_acked_number updated'
.format(tcp.acknowledgement_number))
# check time_out
if self.__is_time_out:
print('detect time out')
# get first send_but_not_acked data in tcp.data
try:
tcp_bytes = self.__sent_but_not_acked[0]
tcp = TCP()
tcp.from_bytes(tcp_bytes)
# modify tcp.sequence_number
# tcp.sequence_number = waiting_ack_number - len(tcp.data)
# double timeout
self.__time_out *= 2
if self.__time_out <= 1:
self.__time_out = 1
# cancel SampleRTT recording for this object
self.__sample_RTT_to_record[tcp.sequence_number +
len(tcp.data)] = None
# Done with here
self.__is_time_out = False
self.__timer = threading.Thread()
self.__timer_pid = None
print(self.__time_out)
except:
self.__is_time_out = False
self.__timer = threading.Thread()
self.__timer_pid = None
else:
# print('no timeout detected')
# calculate the spare room in sent_but_not_acked
spare_room_in_window = self.__window_size - (
self.__next_sequence_number - self.__last_ack_received)
if self.__send_buffer != b'' and spare_room_in_window != 0: # specify squence number andNextSeqNum
NextSeqNum = self.__next_sequence_number
# prepare data
data = self.__send_buffer[:self.__segment_size]
# delete that data from send_buffer
self.__send_buffer = self.__send_buffer[self.
__segment_size:]
# update tcp object
tcp.data = data
tcp.sequence_number = NextSeqNum
# check tcp modified
if tcp.data != b'' or tcp.ACK == 1:
# set sequence number
# tcp.sequence_number = self.__next_sequence_number
# if data included, update next_sequence_number
if tcp.data != b'':
self.__next_sequence_number += len(data)
# if the tcp contains data
if tcp.data != b'':
# check the data is first sent or not
# add current value to sent_but_not_acked
if bytes(tcp) not in self.__sent_but_not_acked:
self.__sent_but_not_acked.append(bytes(tcp))
if (tcp.sequence_number + len(tcp.data)
) not in self.__sample_RTT_to_record.keys():
# it's first sent.
# record send time
send_time = time.time()
self.__sample_RTT_to_record[tcp.sequence_number +
len(tcp.data)] = send_time
# print('----------')
# print('record time')
# print(self.__sample_RTT_to_record)
# print('----------')
# check whether there is already a tiemr
print('check timer', self.__timer.is_alive())
if not self.__timer.is_alive():
# there is no timer
# calculate a new time_out
self.__time_out = self._get_new_timeout()
# start a new timer
self.__timer = threading.Thread(
target=self.__check_time,
args=(time.time(), self.__time_out))
self.__timer.start()
else:
# it's not first sent
# double timeout
print(
'detect not first send message, the sequence_number is {}, the ack_number is {}, content:{}'
.format(tcp.sequence_number,
tcp.acknowledgement_number, str(tcp)))
print(self.__sample_RTT_to_record)
self.__time_out *= 2
self.__timer = threading.Thread(
target=self.__check_time,
args=(time.time(), self.__time_out))
self.__timer.start()
# send tcp object
self.__ip.send(bytes(tcp))
print(
'send tcp object with \tsequence number {} and \tacknowledge number {}.'
.format(tcp.sequence_number, tcp.acknowledgement_number))
print('content', str(tcp))
# build new tcp object
tcp = TCP()
tcp.build(type=tcp.SEND_DATA,
src_port=self.__local_address[1],
dst_port=self.__remote_address[1])
tcp.sequence_number = self.__next_sequence_number
tcp.acknowledgement_number = self.__last_acked_sent
# -*- coding: utf-8 -*-
"""
Created on Fri Jul 29 10:21:07 2016
@author: mb22
"""
import TCP
import matplotlib.pyplot as plt
import importlib
importlib.reload(TCP)
TCP = 88
n = 500
alphabeta_use = 3
alphabeta_sd_use = 0.5
d = 2
d_shift = 0
d_sd = 0.5
d_trend = 0
max_d = 100
dose_of_interest = 74
TCP_input = 88
xyz = TCP.calc_dif_sq(x,TCP, n, alphabeta_use, alphabeta_sd_use,d,d_shift,d_sd,d_trend,max_d,dose_of_interest,TCP_input)
def accept(self):
"""accept() -> address tuple, server_isn int
Wait for an incoming connection. Return a new socket
representing the connection, and the address of the client.
For IP sockets, the address info is a pair (hostaddr, port).
"""
# fd, addr = self._accept()
# If our type has the SOCK_NONBLOCK flag, we shouldn't pass it onto the
# new socket. We do not currently allow passing SOCK_NONBLOCK to
# accept4, so the returned socket is always blocking.
# type = self.type & ~globals().get("SOCK_NONBLOCK", 0)
# sock = socket(self.family, type, self.proto, fileno=fd)
# Issue #7995: if no default timeout is set and the listening
# socket had a (non-zero) timeout, force the new socket in blocking
# mode to override platform-specific socket flags inheritance.
# if getdefaulttimeout() is None and self.gettimeout():
# sock.setblocking(True)
# return address, server_isn
# if not self.__address:
# raise AddressNotSpecified("Did you bind address for this socket?")
# wait until one connected
while buffer_list['listening'][self.__local_address[1]]['queue'] == []:
continue
# retrive first handshake
data, (remote_ip, remote_port) = buffer_list['listening'][
self.__local_address[1]]['queue'].pop()
tcp = TCP()
tcp.from_bytes(data)
if not (tcp.SYN == 1 and tcp.ACK == 0):
# print("wrong tcp package received, it's not the first handshake")
return
client_isn = tcp.sequence_number
print('first handshake received')
# reformat remote_address
address = (remote_ip, tcp.src_port)
# generate a inital server_isn
server_isn = random.randint(0, 2147483645)
# build a tcp with server_isn and client_isn + 1
tcp = TCP()
tcp.build(type=tcp.SEND_SYNACK,
src_port=self.__local_address[1],
dst_port=address[1],
sequence_number=server_isn,
acknowledgement_number=client_isn + 1)
# send the second handshake and register a place for handshake
tmp_ip = IP.IP(IP.PROTOCOL_TCP, self.__local_address[0], remote_ip)
tmp_ip.send(bytes(tcp))
buffer_list['connecting'][address] = []
print('second handshake sent, waiting for the third handshake')
# record the first time of send package
fisrt_pacakge_sent_time = time.time()
# wait until third handshake appear
send_send_start_time = time.time()
flag_3 = True
flag_6 = False
flag_12 = False
while buffer_list['connecting'][address] == []:
if flag_3 and (time.time() - send_send_start_time >= 2):
print('waiting second hand time out, wait another 6s')
tmp_ip.send(bytes(tcp))
send_send_start_time = time.time()
flag_3 = False
flag_6 = True
send_send_start_time = time.time()
elif flag_6 and (time.time() - send_send_start_time >= 2):
print('waiting second hand time out, wait another 12s')
tmp_ip.send(bytes(tcp))
send_send_start_time = time.time()
flag_6 = False
flag_12 = True
send_send_start_time = time.time()
elif flag_12 and (time.time() - send_send_start_time >= 2):
print('waiting second hand time out, wait another 24s')
tmp_ip.send(bytes(tcp))
flag_6 = False
flag_12 = False
send_send_start_time = time.time()
elif (time.time() - send_send_start_time >= 4):
print('waiting second hand time out, wait another 6s')
print('break')
return
continue
# record the time of receiving second package
self.__sample_RTT = time.time() - fisrt_pacakge_sent_time
self.__estimated_RTT = self.__sample_RTT
print('first sample RTT generated, it\'s {}'.format(self.__sample_RTT))
# retrive the third handshake
data, address = buffer_list['connecting'][address].pop()
tcp = TCP()
tcp.from_bytes(data)
print('third handshake retrived')
# check third handshake
if not (tcp.sequence_number == client_isn + 1
and tcp.acknowledgement_number == server_isn + 1):
print(
'SYN {}, ACK{}, tcp.sequencenumber({}) ?= client_isn({}), tcp.acknowledgement_number({}) ?= server_isn({})'
.format(tcp.SYN, tcp.ACK, tcp.sequence_number, client_isn + 1,
tcp.acknowledgement_number, server_isn + 1))
print(
"wrong tcp package received, it's not the correct third handshake"
)
return
# update server_isn
server_isn += 1
# open a place for the newly connected socket
buffer_list['connected'][address] = []
# delete the original space
buffer_list['connecting'].pop(address)
# add data to the buffer if any
# buffer_list['connected'][address].append(tcp.data)
# Build a new tcpSocket
tcpSocket = TCPsocket(self.__local_address, address, server_isn,
client_isn + 1, self.__sample_RTT)
# put the conneceted object in buffer
buffer_list['connected']['objects'][address] = tcpSocket
# add data if any
if tcp.data != b'':
tcpSocket._add_data(tcp.data)
print('done with accept, returned address and server_isn')
return address, tcpSocket
import GUI
import TCP
from tkinter import messagebox
if __name__ == "__main__":
gui = GUI.App()
gui.wm_title("TCP")
tcp = TCP.TCP(gui)
gui.set_tcp(tcp)
def on_closing():
if messagebox.askokcancel(
"TCP-protocol",
"Are you sure you want to terminate the connection?"):
gui.destroy()
gui.protocol("WM_DELETE_WINDOW", on_closing)
gui.bind("<<CLOSED>>", gui.change_state_closed)
gui.bind("<<LISTEN>>", gui.change_state_listen)
gui.bind("<<SYN-RECEIVED>>", gui.change_state_syn_received)
gui.bind("<<SYN-SENT>>", gui.change_state_syn_sent)
gui.bind("<<ESTABLISHED>>", gui.change_state_established)
gui.bind("<<FIN-WAIT-1>>", gui.change_state_fin_wait_1)
gui.bind("<<FIN-WAIT-2>>", gui.change_state_fin_wait_2)
gui.bind("<<TIME-WAIT>>", gui.change_state_time_wait)
gui.bind("<<CLOSE-WAIT>>", gui.change_state_close_wait)
gui.bind("<<LAST-ACK>>", gui.change_state_last_ack)
gui.mainloop()
def _add_data(self, data):
tcp = TCP()
tcp.from_bytes(data)
# print('retrived data from IP layer')
# if has ack info
if tcp.ACK == 1:
# print("detect ACK info, it's", tcp.acknowledgement_number)
if tcp.acknowledgement_number == self.__last_ack_received:
# it's duplicated ack
self.__duplicate_ack += 1
print('detect {} duplicated ACK'.format(self.__duplicate_ack))
if self.__duplicate_ack >= 3:
# fast retransmission
# stop timer and make timeout to be true
self.__timer = threading.Thread()
self.__timer_pid = None
self.__is_time_out = True
print(
'timer stoped, set timeout to be true, preparing for retransmission'
)
self.__duplicate_ack = 0
else:
self.__duplicate_ack = 0
# it's not duplicated ack
if tcp.acknowledgement_number > self.__last_ack_received:
print('current SendBase {}, updated to {}'.format(
self.__last_ack_received, tcp.acknowledgement_number))
# update SendBase
self.__last_ack_received = tcp.acknowledgement_number
self.__next_sequence_number = tcp.acknowledgement_number
# calculating a new SampleRTT
# print('----------')
# print('receive time')
# print(self.__sample_RTT_to_record)
# print('tcp info:')
# print('sequence_number:{}, acknowledgement_number:{}, content:{}'.format(tcp.sequence_number, tcp.acknowledgement_number, str(tcp)))
# print('----------')
try:
self.__sample_RTT = time.time(
) - self.__sample_RTT_to_record[
tcp.acknowledgement_number]
except:
pass
# remove self.__send_but_not_acked objects according to the ack number
print('updating sent_but_not_acked list')
remove_list = []
for tcp_bytes in self.__sent_but_not_acked:
tcp_ = TCP()
tcp_.from_bytes(tcp_bytes)
if tcp_.sequence_number + len(
tcp_.data) <= tcp.acknowledgement_number:
remove_list.append(tcp_bytes)
print('removed waiting_ack_number:{}'.format(
tcp_.sequence_number + len(tcp_.data)))
for item in remove_list:
self.__sent_but_not_acked.remove(item)
# print('updated')
# check whether a timer is running
if self.__timer.is_alive():
print('detect a timer still running')
# check whether there are still sent_but_not_acked
if self.__sent_but_not_acked:
print('detect there is still sent_but_not_acked:')
print(self.__sent_but_not_acked)
print('restart timer')
self.__time_out = self._get_new_timeout()
# restart timer
self.__timer = threading.Thread(
target=self.__check_time,
args=(time.time(), self.__time_out))
self.__timer.start()
else:
# stop timer
self.__timer = threading.Thread()
self.__timer_pid = None
self.__is_time_out = False
self.__time_out = self._get_new_timeout()
print(
'no data in sent_but_note_acked, stopped timer'
)
# if has data info:
if tcp.data != b'':
# check whether it's duplicate data
if tcp.sequence_number < self.__last_acked_sent:
print(
'the sequence_number({}) < last_acked_sent({}), omit it.'.
format(tcp.sequence_number, self.__last_acked_sent))
# it's duplicate data
tcp = TCP()
tcp.build(type=tcp.SEND_ACK,
src_port=self.__local_address[1],
dst_port=self.__remote_address[1],
acknowledgement_number=self.__last_acked_sent)
print('duplicate data, send ack')
else:
# it's not duplicate data
# put it in self.__window_buffer and sort
print(tcp.data, 'has added to window buffer')
self.__window_buffer.append((tcp.sequence_number, tcp.data))
self.__window_buffer.sort(key=lambda x: x[0])
# check tmp_buffer in-order data, if any, put it to recv_buffer
while self.__window_buffer[0][0] == self.__last_acked_sent:
# retrive from window_buffer(tmp_buffer)
sequence_number, data = self.__window_buffer.pop()
# calculate and update last_ack_sent
self.__last_acked_sent += len(data)
# put data into recv_buffer
self.__received_buffer += data
print(
'put data with sequence_number {} out of tmp_buffer into recv_buffer, updated last_ack_sent, waiting to be sent later'
.format(tcp.sequence_number))
if len(self.__window_buffer) == 0:
break
# put last_ack_sent to ack_to_be_sent
self.__ack_to_be_sent.append(self.__last_acked_sent)
print('not duplicate, send ack', self.__last_acked_sent)
import time
import TCP
########################################################################
## Main code
while True:
try:
TCP.SocketProcess()
except:
pass
time.sleep(0.01)
def push(data, remote_ip):
# print
# print('[static method]received data from ip, it\'s from', remote_ip)
tcp = TCP()
tcp.from_bytes(data)
# print('current buffer_list is')
# print(buffer_list)
# print('src_port is', tcp.src_port, end=' ')
# print('dst_port is', tcp.dst_port, end=' ')
# print('content is', str(tcp))
# print()
# print basic info
# names = ['CWR','ECE','URG','ACK','PSH','RST','SYN','FIN']
# byte = tcp.flag_bits
# byte = bin(int.from_bytes(byte, 'little'))[2:]
# print(bytes)
# for i in range(8):
# print("{}:{}".format(names[i], byte[i]))
#
# if tcp.SYN == 1 and tcp.ACK != 1:
# b
remote_address = (remote_ip, tcp.src_port)
if tcp.RST:
raise ConnectionResetError
try:
if tcp.SYN == 1 and tcp.ACK == 1:
print('detect second handshake')
try:
buffer_list['connecting'][remote_address].append(data)
except:
server_isn = tcp.sequence_number
client_isn = tcp.acknowledgement_number
remote_port = tcp.src_port
local_port = tcp.dst_port
tcp = TCP()
tcp.sequence_number = client_isn
tcp.acknowledgement_number = server_isn
tcp.src_port = local_port
tcp.dst_port = remote_port
tmp_ip = IP.IP(protocol=IP.PROTOCOL_TCP,
src_ip=local_ip,
dst_ip=remote_ip)
print('retransmitted', tcp.sequence_number,
tcp.acknowledge_number)
print("str", str(tcp))
tmp_ip.send(bytes(tcp))
elif tcp.SYN == 1:
# it's first handshake
print('detect first handshake')
buffer_list['listening'][tcp.dst_port]['queue'].append(
(data, remote_address))
else:
# it's not first handshake
# self.__last_acked_number = tcp.acknowledgement_number # todo update last_acked_number
# check whether it's a third handshake
if remote_address in buffer_list['connected']['objects'].keys(
):
print('detect normal message')
# it's not a third handshake
# buffer_list['connected'][remote_address].append((data, remote_address))
# get tcp object
obj = buffer_list['connected']['objects'][remote_address]
# let obj add data
obj._add_data(data)
else:
# it's a third handshake
print('detect third handshake')
buffer_list['connecting'][remote_address].append(
(data, remote_address))
except:
local_port = tcp.dst_port
remote_port = tcp.src_port
sequence_number = tcp.acknowledgement_number
acknowledge_number = tcp.sequence_number
tcp = TCP()
tcp.RST = 1
tcp.ACK = 0
tcp.src_port = local_port
tcp.dst_port = remote_port
tcp.sequence_number = sequence_number
tcp.acknowledgement_number = acknowledge_number
tmp_ip = IP.IP(protocol=IP.PROTOCOL_TCP,
src_ip=local_ip,
dst_ip=remote_ip)
tmp_ip.send(bytes(tcp))
def __init__(self, game):
self.tcp = TCP("127.0.0.1", "5005")
self.game.players[0].set_connection(self.tcp)
def main():
# Parsing user input
parser = argparse.ArgumentParser()
parser.add_argument(
'-p','--port',
nargs='?',
type=int,
default=8118,
help='TCP Port Number.'
)
parser.add_argument(
'-i','--ip',
nargs='?',
type=str,
default='127.0.0.1',
help='TCP IP Address.'
)
parser.add_argument(
'-b','--buffer_size',
nargs='?',
type=int,
default=256,
help='TCP Socket Buffer Size.'
)
parser.add_argument(
'-m','--mode',
nargs='?',
action='store',
default='client',
choices=['client','server'],
help='Client or Server mode.'
)
args = parser.parse_args()
tcp = TCP(
port = args.port,
ip = args.ip,
buffer_size = args.buffer_size,
mode = args.mode,
)
# Keeps requesting the most recent data
if(tcp.mode=='client'):
try:
for i in range(15):
print i, yaml.load(tcp.request('kayak_0'))
time.sleep(0.5)
except:
pass
# Keeps providing the most recent data
sim_update_secs = 0.010
kayak_rotation_freque = 0.010
glider_rotation_freque = 0.005
if(tcp.mode=='server'):
t = 0.000
try:
while True:
t = time.time()
tcp.database = {
'kayak_0': yaml.dump({
'Depth': 0.0,
'Latitude': 32.0 + math.sin(kayak_rotation_freque*2*math.pi*t),
'Longitude': -119.0 + math.cos(kayak_rotation_freque*2*math.pi*t),
'Salinity': 33.0 + math.sin(0.25*2*math.pi*t),
'Temperature': 16.0 + math.sin(0.50*2*math.pi*t),
'Time': t,
'w': 1.0,
'x': 0.0,
'y': 0.0,
'z': 0.0,
}),
'kayak_1': yaml.dump({
'Depth': 0.0,
'Latitude': 32.0 + math.cos(kayak_rotation_freque*2*math.pi*t),
'Longitude': -119.0 + math.sin(kayak_rotation_freque*2*math.pi*t),
'Salinity': 33.0 + math.sin(0.25*2*math.pi*t),
'Temperature': 16.0 + math.sin(0.50*2*math.pi*t),
'Time': t,
'w': 1.0,
'x': 0.0,
'y': 0.0,
'z': 0.0,
}),
'glider_0': yaml.dump({
'Depth': 50.0,
'Latitude': 32.0 + math.sin(glider_rotation_freque*2*math.pi*t),
'Longitude': -119.0 + math.cos(glider_rotation_freque*2*math.pi*t),
'Salinity': 33.0 + math.sin(0.25*2*math.pi*t),
'Temperature': 16.0 + math.sin(0.50*2*math.pi*t),
'Time': t,
'w': 1.0,
'x': 0.0,
'y': 0.0,
'z': 0.0,
}),
'glider_1': yaml.dump({
'Depth': 100.0,
'Latitude': 32.0 + math.cos(glider_rotation_freque*2*math.pi*t),
'Longitude': -119.0 + math.sin(glider_rotation_freque*2*math.pi*t),
'Salinity': 33.0 + math.sin(0.25*2*math.pi*t),
'Temperature': 16.0 + math.sin(0.50*2*math.pi*t),
'Time': t,
'w': 1.0,
'x': 0.0,
'y': 0.0,
'z': 0.0,
}),
}
t += sim_update_secs
time.sleep(sim_update_secs)
except:
tcp.exit_server()
packet = receiver_socket.recvfrom(65565)
packet = packet[0]
#print packet
validation_status, faulty_packet = validatePacket(packet)
if validation_status:
#IP header bytes
ip_header = IP.unpackHeader(packet[0:20])
if socket.inet_ntoa(ip_header[8]) == DESTINATION_IP and socket.inet_ntoa(ip_header[9]) == SOURCE_IP:
#Get Length of IP header
ip_ver = ip_header[0] >> 4
ip_header_length = ip_header[0] & 0xF
ip_length = ip_header_length * 4
tcp_header = TCP.unpackHeader(packet[ip_length: ip_length + 20])
ack = (tcp_header[5] & 0x10) >> 4
syn = (tcp_header[5] & 0x02) >> 1
if ack == 1 and syn == 1 and tcp_header[0] == DESTINATION_PORT and tcp_header[1] == SOURCE_PORT and tcp_header[3] == (ACK_NUM + 1):
#SYN-ACK received
SEQ_NUM = tcp_header[2] + 1
SEQ_START = tcp_header[2]
ACK_NUM = tcp_header[3]
packet_sent_time = time.time()
#ACKd
if CWND < SSTHRESH:
CWND += 1
