def __init__(self, port, baud_rate, terminal=None, reset=False): Connection.__init__(self, terminal) self._port = port self._baud_rate = baud_rate try: # These timeouts should be large enough so that any continuous transmission is fully received self._serial = serial.Serial(None, self._baud_rate, timeout=0.2, write_timeout=0.2) self._serial.dtr = False self._serial.rts = False self._serial.port = port self._serial.open() if reset: self._serial.rts = True time.sleep(0.1) self._serial.rts = False x = "" while not x.endswith(">>>"): x += self._serial.read().decode('utf-8', errors="ignore") self.send_kill() except (OSError, serial.SerialException) as e: self._serial = None return except Exception as e: return self._reader_thread = Thread(target=self._reader_thread_routine) self._reader_thread.start()
def __init__(self, transport, source_address, source_port, destination_address, destination_port, app=None, window=1000): Connection.__init__(self, transport, source_address, source_port, destination_address, destination_port, app) ### Sender functionality # send window; represents the total number of bytes that may # be outstanding at one time self.window = window # send buffer self.send_buffer = SendBuffer() # maximum segment size, in bytes self.mss = 1000 # largest sequence number that has been ACKed so far; represents # the next sequence number the client expects to receive self.sequence = 0 # retransmission timer self.timer = None # timeout duration in seconds self.timeout = 1 ### Receiver functionality # receive buffer self.receive_buffer = ReceiveBuffer() # ack number to send; represents the largest in-order sequence # number not yet received self.ack = 0
def __init__(self,transport,source_address,source_port, destination_address,destination_port,app=None,window=1000): Connection.__init__(self,transport,source_address,source_port, destination_address,destination_port,app) ### Sender functionality # send window; represents the total number of bytes that may # be outstanding at one time self.window = window # send buffer self.send_buffer = SendBuffer() # maximum segment size, in bytes self.mss = 1000 # largest sequence number that has been ACKed so far; represents # the next sequence number the client expects to receive self.sequence = 0 # retransmission timer self.timer = None # timeout duration in seconds self.timeout = 1 ### Receiver functionality # receive buffer self.receive_buffer = ReceiveBuffer() # ack number to send; represents the largest in-order sequence # number not yet received self.ack = 0
def __init__( self, transport, source_address, source_port, destination_address, destination_port, app=None, window=1000, dynamic_rto=True, type="Tahoe", ): Connection.__init__(self, transport, source_address, source_port, destination_address, destination_port, app) ### Sender functionality # send window; represents the total number of bytes that may # be outstanding at one time self.window = default_mss # send buffer self.send_buffer = SendBuffer() # maximum segment size, in bytes self.mss = default_mss # largest sequence number that has been ACKed so far; represents # the next sequence number the client expects to receive self.sequence = 0 # retransmission timer self.timer = None # timeout duration in seconds self.timeout = 1 self.threshold = 100000 self.ack_received_count = {} self.wait_for_timeout = False self.reno_fast_recovery = type == "Reno" # constants self.k = 4 self.g = 0.1 self.alpha = 1 / 8 self.beta = 1 / 4 self.dynamic_rto = dynamic_rto self.rto = 3 self.srtt = None self.rttvar = None ### Receiver functionality # receive buffer self.receive_buffer = ReceiveBuffer() # ack number to send; represents the largest in-order sequence # number not yet received self.ack = 0
def __init__(self, transport, source_address, source_port, destination_address, destination_port, app=None, drop=[], fast_retransmit=False, measure=False): Connection.__init__(self, transport, source_address, source_port, destination_address, destination_port, app) # -- Sender functionality # send buffer self.send_buffer = SendBuffer() # maximum segment size, in bytes self.mss = 1000 # initial cwnd is equal to 1mss self.cwnd = float(self.mss) # boolean flag that indicates if in slow start or additive increase self.slow_start = True # When cwnd >= ss_thresh, slow start ends self.ss_thresh = 100000 if self.node.hostname == 'n1': self.trace("Entering Slow Start: SS Thresh = %s" % (self.ss_thresh)) # Tracks additive increase - determines when to add another MSS to cwnd self.cwnd_inc = 0 # largest sequence number that has been ACKed so far; represents # the next sequence number the client expects to receive self.sequence = 0 # plot sequence numbers self.plot_sequence_header() self.plot_cwnd_header() self.plot_cwnd() # packets to drop self.drop = drop self.dropped = [] # retransmission timer self.timer = None # timeout duration in seconds self.timeout = 1 # -- Receiver functionality # receive buffer self.receive_buffer = ReceiveBuffer() # ack number to send; represents the largest in-order sequence # number not yet received self.ack = 0 self.fast_retransmit = fast_retransmit self.last_ack = 0 self.last_ack_count = 0
def __init__(self, transport, source_address, source_port, destination_address, destination_port, app=None, window=1000, drop=[]): Connection.__init__(self, transport, source_address, source_port, destination_address, destination_port, app) # -- Sender functionality # send window; represents the total number of bytes that may # be outstanding at one time self.window = window # send buffer self.send_buffer = SendBuffer() # maximum segment size, in bytes self.mss = 1000 # largest sequence number that has been ACKed so far; represents # the next sequence number the client expects to receive self.sequence = 0 # plot sequence numbers self.plot_sequence_header() # packets to drop self.drop = drop self.dropped = [] # retransmission timer self.timer = None # timeout duration in seconds self.timeout = 1 # RTO calculation variables self.rto = 1 self.srtt = 0 self.rttvar = 0 # Variables for handling fast retransmit self.fast_enable = False self.last_ack = 0 self.same_ack_count = 0 self.fast_retransmitted = False # -- Receiver functionality # receive buffer self.receive_buffer = ReceiveBuffer() # ack number to send; represents the largest in-order sequence # number not yet received self.ack = 0
def __init__(self, host, port, terminal, password_prompt): Connection.__init__(self, terminal) self._host = host self._port = port self.s = None self.ws = None if not self._start_connection(): return if not self.handle_password(password_prompt): self._clear() raise PasswordException() self._reader_thread = Thread(target=self._reader_thread_routine) self._reader_thread.start()
def __init__(self, transport, source_address, source_port, destination_address, destination_port, app=None, window=1000): Connection.__init__(self, transport, source_address, source_port, destination_address, destination_port, app) ### Sender functionality # send window; represents the total number of bytes that may # be outstanding at one time # Step 2 self.window = window # send buffer self.send_buffer = SendBuffer() # maximum segment size, in bytes # self.mss = 1000 self.mss = min(1000, window) # largest sequence number that has been ACKed so far; represents # the next sequence number the client expects to receive self.sequence = 0 # retransmission timer self.timer = None # timeout duration in seconds self.timeout = 3.0 # estimated rtt self.est_rtt = None # alpha self.alpha = 0.125 # variation rtt self.var_rtt = None ## TODO: revisit this later # beta self.beta = 0.25 # timer start self.start_time = 0.0 ### Receiver functionality # receive buffer self.receive_buffer = ReceiveBuffer() # ack number to send; represents the largest in-order sequence # number not yet received self.ack = 0
def __init__(self,transport,source_address,source_port, destination_address,destination_port,window_size,app=None): Connection.__init__(self,transport,source_address,source_port, destination_address,destination_port,app) self.send_buffer = '' self.next_sequence_num = 0 self.received_ack_number = 0 self.unacked_packet_count = 0 self.mss = 1000 self.sequence = 0 self.received_sequences = set([]) self.receive_buffer = [] self.ack = 0 self.timer = None self.timeout = 1 self.max_sequence = math.pow(2,64) self.window_size = window_size
def __init__(self,transport,source_address,source_port, destination_address,destination_port,app=None): Connection.__init__(self,transport,source_address,source_port, destination_address,destination_port,app) self.send_buffer = '' self.receive_buffer = [] self.packets_outstanding = 0 self.mss = 1000 self.sequence = 0 self.ack = 0 self.timer = None self.timeout = 1 self.max_sequence = math.pow(2,64) self.window_size = 1 self.window_start = 0 self.timer_set = False self.queueing_delay = 0 self.pkt_q_delay_threshold = 0.0000000001 self.pkts_rcvd = 0
def __init__(self,transport,source_address,source_port, destination_address,destination_port,app=None): Connection.__init__(self,transport,source_address,source_port, destination_address,destination_port,app) self.send_buffer = '' self.received_ack_number = 0 self.unacked_packet_count = 0 self.mss = 1000 self.sequence = 0 self.received_sequences = set([]) self.receive_buffer = [] self.ack = 0 self.cwnd = 0 self.threshold = 100000 self.timer = None self.timeout = 0.1 self.max_sequence = math.pow(2,64) self.rate_file = open ('output/rate%d.txt' % source_port, 'w+') self.sequence_file = open('output/sequence%d.txt' % source_port, 'w+') self.window_file = open('output/window%d.txt' % source_port, 'w+') self.ack_file = open('output/acks%d.txt' % source_port, 'w+')
def __init__(self,transport,source_address,source_port, destination_address,destination_port,window,app=None): Connection.__init__(self,transport,source_address,source_port, destination_address,destination_port,app) #sender self.send_buffer = '' self.next_sequence_num = 0 self.send_base = self.next_sequence_num self.not_yet_acknowledged_segments = 0 #receiver self.receive_temp_buffer = set([]) self.receive_packet_buffer = [] self.ack = 0 self.timer_counter = 0 self.triple_dup_ack_counter = 0 self.mss = 1000 self.window = window self.timer = None self.timeout = 1 # 1 second self.max_sequence = math.pow(2,64)
def __init__(self, host, port, terminal, ask_for_password): Connection.__init__(self, terminal) self.s = socket.socket() self.s.settimeout(3) errno = self.s.connect_ex((host, port)) if errno != 0: self._clear() return self.s.settimeout(None) websocket_helper.client_handshake(self.s) self.ws = WebSocket(self.s) self.login(ask_for_password()) try: self.read_all() except: self._clear() return self._reader_thread = Thread(target=self._reader_thread_routine) self._reader_thread.start()
def __init__(self, transport, source_address, source_port, destination_address, destination_port, app=None, window=1000, threshold=100000, fast_recovery=False, aiad=False, aimdc=0.5): Connection.__init__(self, transport, source_address, source_port, destination_address, destination_port, app) ### Sender functionality # send window; represents the total number of bytes that may # be outstanding at one time (cwnd) self.window = window # send buffer self.send_buffer = SendBuffer() # maximum segment size, in bytes self.mss = 1000 # largest sequence number that has been ACKed so far; represents # the next sequence number the client expects to receive self.sequence = 0 # retransmission timer self.timer = None # timeout duration in seconds self.timeout = 1 # Round trip time in seconds self.estimated_rtt = None # Deviation of sample rtt from estimated rtt self.deviation_rtt = None # State determines slow start vs. additive increase # 0 = slow start # 1 = additive increase self.state = 0 # Threshold for slow start self.threshold = threshold self.trace("Threshold starting at %d" % self.threshold) # Same ack count (used for calculating three duplicate acks) self.same_ack_count = 0 # Most recent ack (used for calculating three duplicate acks) self.last_ack = None # Make sure settings start with slow start self.window = self.mss # Used when dropping certain packets self.dropped_count = 0 # Fast Recovery (Reno) self.fast_recovery = fast_recovery # AIAD self.aiad = aiad # AIMD Constant self.aimdc = aimdc ### Used to make TCP Sequence Graphs self.x = [] self.y = [] self.dropX = [] self.dropY = [] self.ackX = [] self.ackY = [] ### Used to make window size graphs self.window_x = [] self.window_y = [] ### Receiver functionality # receive buffer self.receive_buffer = ReceiveBuffer() # ack number to send; represents the largest in-order sequence # number not yet received self.ack = 0 # a list of all the queuing delays from the sender to receiver self.queueing_delay_list = [] # keep track of when packets were received self.packets_received = {}
def __init__(self,transport,source_address,source_port, destination_address,destination_port,app=None,window=1000, threshold=100000,fast_recovery=False): Connection.__init__(self,transport,source_address,source_port, destination_address,destination_port,app) ### Sender functionality # send window; represents the total number of bytes that may # be outstanding at one time (cwnd) self.window = window # send buffer self.send_buffer = SendBuffer() # maximum segment size, in bytes self.mss = 1000 # largest sequence number that has been ACKed so far; represents # the next sequence number the client expects to receive self.sequence = 0 # retransmission timer self.timer = None # timeout duration in seconds self.timeout = 1 # Round trip time in seconds self.estimated_rtt = None # Deviation of sample rtt from estimated rtt self.deviation_rtt = None # State determines slow start vs. additive increase # 0 = slow start # 1 = additive increase self.state = 0 # Threshold for slow start self.threshold = threshold self.trace("Threshold starting at %d" % self.threshold) # Same ack count (used for calculating three duplicate acks) self.same_ack_count = 0 # Most recent ack (used for calculating three duplicate acks) self.last_ack = None # Make sure settings start with slow start self.window = self.mss # Used when dropping certain packets self.dropped_count = 0 # Fast Recovery (Reno) self.fast_recovery=fast_recovery ### Used to make TCP Sequence Graphs self.x = [] self.y = [] self.dropX = [] self.dropY = [] self.ackX = [] self.ackY = [] ### Receiver functionality # receive buffer self.receive_buffer = ReceiveBuffer() # ack number to send; represents the largest in-order sequence # number not yet received self.ack = 0 # a list of all the queuing delays from the sender to receiver self.queueing_delay_list = []