def test_too_small_packet(self): """ Tests if too small packets are rejected due to the minimum length requirement. """ with self.assertRaises(ValueError): packet.parse_packet([10])
def poll(self): """ poll the socket and see if there is any data to be processed. if so, loop through the packets and process all of it before the next loop. """ if self.sock.read(): messages = [] while self.sock.read(): messages.append(self.sock.get_packet()) for m in messages: parse_packet(self, m) self.sock.buf = '' return True
def test_fuzzy_2(self): """ Fuzzy testing. If parsing of a packet is successful, then unparsing must be successful as well and the buffers must match. """ i = 0 while i < 1024 * 100: buf = self._random_buf_2() plus_packet = None try: plus_packet = packet.parse_packet(buf) except: plus_packet = None if plus_packet != None: try: self.assertEqual(plus_packet.to_bytes(), buf) except: print(plus_packet.to_dict()) raise ValueError("Buffer mismatch?") i += 1
def __handler(data): status, data = packet.parse_packet(data) print(status, data) if status: epoch, temps = data __process(epoch, temps) return packet.make_ack_packet()
def send(self, data, sendTo, flag=0): unacked = len(self.pkts) packet = make_packet(self.nextseq, data, flag) oldest_unack = (self.nextseq - unacked) & 0xffff # fall back to fixed timeout value self.localSocket.settimeout(0.1) lastsent = False if flag == 2 and unacked < self.window_size: self.sendPkt(packet) lastsent = True while unacked >= self.window_size or (flag == 2 and unacked > 0): try: pkt, address = self.localSocket.recvfrom(MAX_SIZE) except socket.timeout: # resend all pkts if time.time() - self.timer < self.TIMEOUT: self.start_timer() self.sendAll(sendTo) print("go back n, resend all") else: csum, rsum, seq, _, _ = parse_packet(pkt) # not corrupted if csum == rsum: # cumulative acknowledgement cum_acks = seq - oldest_unack + 1 if cum_acks < 0: # seqnum restarts from zero cum_acks = seq + 1 + 0xffff - oldest_unack + 1 self.pkts = self.pkts[cum_acks:] #print("seq: {}, oldest: {} cum ACK {}".format(seq, oldest_unack, cum_acks)) unacked -= cum_acks oldest_unack = (oldest_unack + cum_acks) & 0xffff if unacked != 0: self.start_timer() if flag == 2 and not lastsent: self.sendPkt(packet, sendTo) lastsent = True # ok to send now if flag != 2: self.sendPkt(packet, sendTo)
def test_parse_packet_7(self): """ Tests parsing an extended packet. """ buf = bytes([ 0xD8, 0x00, 0x7F, 0xF1, # magic + flags (x bit set) 0x12, 0x34, 0x56, 0x78, # cat 0x12, 0x34, 0x56, 0x71, # cat.. 0x13, 0x11, 0x11, 0x12, # psn 0x23, 0x22, 0x22, 0x23, # pse 0x00, 0x00, 0xF3, # PCF Type := 0x00, # PCF Len 60, PCF I = 11b, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, # 6 bytes PCF value 0x99, 0x98, 0x97, 0x96 ]) # 4 bytes payload # This needs to fail because pcf_len is 60 but pcf_value + payload # aren't even that long in the buf with self.assertRaises(ValueError): plus_packet = packet.parse_packet(buf)
def recv(self): total = 0 self.receiveSocket.settimeout(.1) while True: try: message = self.receiveSocket.recv(MAX_SIZE) _, _, _, flag, data = parse_packet(message) total += 1 print("total: {} data: {}".format(total, len(data)), end="\r") if flag == 2 or not data: break yield data # last packet, don't wait for timeout except socket.timeout: print('timeout. end.') break
def test_fuzzy_3(self): """ Make random packets. Then unparse and parse again and compare. """ i = 0 m = 0 n = 0 while i < 1024 * 100: plus_packet = None plus_packet_ = None try: plus_packet = self._random_packet() n += 1 buf = plus_packet.to_bytes() plus_packet_ = packet.parse_packet(buf) except ValueError as e: pass if plus_packet_ == None: i += 1 continue self.assertEqual(plus_packet.l, plus_packet_.l) self.assertEqual(plus_packet.r, plus_packet_.r) self.assertEqual(plus_packet.s, plus_packet_.s) self.assertEqual(plus_packet.x, plus_packet_.x) self.assertEqual(plus_packet.cat, plus_packet_.cat) self.assertEqual(plus_packet.psn, plus_packet_.psn) self.assertEqual(plus_packet.pse, plus_packet_.pse) self.assertEqual(plus_packet.payload, plus_packet_.payload) self.assertEqual(plus_packet.pcf_type, plus_packet_.pcf_type) self.assertEqual(plus_packet.pcf_value, plus_packet_.pcf_value) self.assertEqual(plus_packet.pcf_integrity, plus_packet_.pcf_integrity) self.assertEqual(plus_packet.is_valid(), True) self.assertEqual(plus_packet_.is_valid(), True) i += 1 m += 1 print(n, m)
def test_parse_packet_3(self): """ Tests parsing an extended packet. """ buf = bytes([ 0xD8, 0x00, 0x7F, 0xFF, # magic + flags (x bit set) 0x12, 0x34, 0x56, 0x78, # cat 0x12, 0x34, 0x56, 0x78, # cat.. 0x13, 0x11, 0x11, 0x11, # psn 0x23, 0x22, 0x22, 0x22, # pse 0xFF, 0x01, 0x00, # PCF Type := 0xFF, # PCF Len := 0, PCF I := 00b, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, # 0x99, 0x98, 0x97, 0x96]) # 10 bytes payload l = True r = True s = True cat = 0x1234567812345678 psn = 0x13111111 pse = 0x23222222 pcf_type = 0xFF pcf_len = None pcf_integrity = None pcf_value = None payload = bytes([0x01, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x99, 0x98, 0x97, 0x96]) plus_packet = packet.parse_packet(buf) self.assertEqual(plus_packet.l, l) self.assertEqual(plus_packet.r, r) self.assertEqual(plus_packet.s, s) self.assertEqual(plus_packet.x, True) self.assertEqual(plus_packet.cat, cat) self.assertEqual(plus_packet.psn, psn) self.assertEqual(plus_packet.pse, pse) self.assertEqual(plus_packet.payload, payload) self.assertEqual(plus_packet.pcf_type, pcf_type) self.assertEqual(plus_packet.pcf_value, pcf_value) self.assertEqual(plus_packet.pcf_integrity, pcf_integrity) self.assertEqual(plus_packet.is_valid(), True)
def test_invalid_magic(self): """ Tests parsing when magic is invalid. """ buf = bytes([ 0x18, 0x00, 0x7F, 0xFA, #magic + flags 0x12, 0x34, 0x56, 0x78, #cat 0x21, 0x43, 0x65, 0x87, 0x87, 0x65, 0x43, 0x21, #psn 0x11, 0x22, 0x33, 0x44, #pse 0x01, 0x02, 0x03, 0x04, #payload 0x10, 0x20, 0x30, 0x40, #payload 0x99, 0x90, 0x99, 0x90 ]) with self.assertRaises(ValueError): plus_packet = packet.parse_packet(buf)
def recv(self): acks = 0 nacs = 0 self.localSocket.settimeout(60) # no one can wait for so long while True: try: message, address = self.localSocket.recvfrom(MAX_SIZE) csum, rsum, seqnum, flag, data = parse_packet(message) # check sum and seqnum if csum != rsum or seqnum != self.seq: ACK = make_ack(1 - self.seq) nacs += 1 self.localSocket.sendto(ACK, address) print("acks: {}, NAK: {}.".format(acks, nacs), end='\r') else: # simulate loss if random.random() < self.prob_loss: ACK = make_ack(1 - self.seq) nacs += 1 self.localSocket.sendto(ACK, address) print("acks: {}, NAK: {}.".format(acks, nacs), end='\r') continue # ack ACK = make_ack(self.seq) self.localSocket.sendto(ACK, address) acks += 1 print("acks: {}, NAK: {}.".format(acks, nacs), end='\r') self.seq = 1 - self.seq yield data # last packet, don't wait for more packets if flag == 2: print("\n last packet received.") break except socket.timeout: print('timeout ? end.') break
def recv(self): # set time out to prevent it from blocking forever self.localSocket.settimeout(10) while True: try: message, address = self.localSocket.recvfrom(MAX_SIZE) _, _, _, flag, data = parse_packet(message) # simulate packet loss #if random.random() < self.prob_loss: # print("packet loss!") # continue yield data # last packet, don't wait for timeout if flag == 2: break except socket.timeout: print('timeout. end.') break
def test_parse_packet_1(self): """ Tests parsing a basic packet. """ buf = bytes([ 0xD8, 0x00, 0x7F, 0xFA, #magic + flags 0x12, 0x34, 0x56, 0x78, #cat 0x21, 0x43, 0x65, 0x87, 0x87, 0x65, 0x43, 0x21, #psn 0x11, 0x22, 0x33, 0x44, #pse 0x01, 0x02, 0x03, 0x04, #payload 0x10, 0x20, 0x30, 0x40, #payload 0x99, 0x90, 0x99, 0x90]) l = True r = False s = True cat = 0x1234567821436587 psn = 0x87654321 pse = 0x11223344 payload = bytes([ 0x01, 0x02, 0x03, 0x04, 0x10, 0x20, 0x30, 0x40, 0x99, 0x90, 0x99, 0x90]) plus_packet = packet.parse_packet(buf) self.assertEqual(plus_packet.l, l) self.assertEqual(plus_packet.r, r) self.assertEqual(plus_packet.s, s) self.assertEqual(plus_packet.x, False) self.assertEqual(plus_packet.cat, cat) self.assertEqual(plus_packet.psn, psn) self.assertEqual(plus_packet.pse, pse) self.assertEqual(plus_packet.payload, payload) self.assertEqual(plus_packet.is_valid(), True)
def send(self, data, sendTo, flag=0): ack_received = False packet = make_packet(self.seq, data, flag) alpha = 0.875 beta = 0.25 ertt = 0.5 devrtt = 0 self.localSocket.settimeout(ertt) retrans = 0 while not ack_received: start = time.time() self.localSocket.sendto(packet, sendTo) try: message, address = self.localSocket.recvfrom(MAX_SIZE) except socket.timeout: retrans += 1 print('timeout, retrans = ' + str(retrans), end='\r') else: csum, rsum, seqnum, flag, data = parse_packet(message) # not corrupted and expected? if csum == rsum and seqnum == self.seq: #print("ACK {} received.".format(self.seq)) end = time.time() samplertt = end - start ertt = alpha * ertt + (1 - alpha) * samplertt devrtt = (1 - beta) * devrtt + beta * abs(samplertt - ertt) self.localSocket.settimeout(ertt + 4 * devrtt) ack_received = True else: retrans += 1 print('timeout, retrans = ' + str(retrans), end='\r') self.seq = 1 - self.seq
def test_parse_packet_6(self): """ Tests parsing an extended packet. """ buf = bytes([ 0xD8, 0x00, 0x7F, 0xF1, # magic + flags (x bit set) 0x12, 0x34, 0x56, 0x78, # cat 0x12, 0x34, 0x56, 0x71, # cat.. 0x13, 0x11, 0x11, 0x12, # psn 0x23, 0x22, 0x22, 0x23, # pse 0x00, 0x00, 0x1B, # PCF Type := 0x00, # PCF Len 6, PCF I = 11b, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, # 6 bytes PCF value 0x99, 0x98, 0x97, 0x96 ]) # 4 bytes payload l = False r = False s = False cat = 0x1234567812345671 psn = 0x13111112 pse = 0x23222223 pcf_type = 0x00 pcf_len = 0x06 pcf_integrity = 0x03 pcf_value = bytes([0x01, 0x02, 0x03, 0x04, 0x05, 0x06]) payload = bytes([0x99, 0x98, 0x97, 0x96]) plus_packet = packet.parse_packet(buf) self.assertEqual(plus_packet.l, l) self.assertEqual(plus_packet.r, r) self.assertEqual(plus_packet.s, s) self.assertEqual(plus_packet.x, True) self.assertEqual(plus_packet.cat, cat) self.assertEqual(plus_packet.psn, psn) self.assertEqual(plus_packet.pse, pse) self.assertEqual(plus_packet.payload, payload) self.assertEqual(plus_packet.pcf_type, pcf_type) self.assertEqual(plus_packet.pcf_value, pcf_value) self.assertEqual(plus_packet.pcf_integrity, pcf_integrity) self.assertEqual(plus_packet.is_valid(), True)