def server_send(self, connections, peer_ip): threading.Thread(target=self.acks, args=(connections, 1024)).start() if (len(self.send_all_pkt) > 1): send_window_size = int(len(self.send_all_pkt) / 2) else: send_window_size = len(self.send_all_pkt) windowcount = 0 while (len(self.send_all_pkt) != 0): while (len(self.send_window) < send_window_size and len(self.send_all_pkt) != 0): j = 0 windowcount = windowcount + 1 for i in self.send_all_pkt: self.send_window[i] = self.send_all_pkt[i] j = j + 1 if len(self.send_window) == send_window_size: break for i in self.send_window.keys(): del self.send_all_pkt[i] p = Packet(packet_type=0, seq_num=i, peer_ip_addr=peer_ip, peer_port=self.clientport, payload=self.send_window[i]) print('Sending packet:', p.seq_num) connections.sendto(p.to_bytes(), self.sender) time.sleep(self.delay) self.resend_packet(connections, self.router_add, self.router_port, peer_ip, self.server_port)
def _receiver_packet_loop(self): if self.mode == RSMode.SendMode: raise Exception received_files_flag = {} received_files_length = {} while True: try: data, from_addr = self.socket.recvfrom(2048) packet = Packet() packet.from_raw(data) key = utils.endpoint2str(from_addr, packet.header.id) if key not in self.received_files_data: self.received_files_data[key] = [b""] * 100 received_files_flag[key] = False self.received_files_data[key][ packet.header.seq] = rsc.decode(packet.payload) if key in received_files_length and self.is_all_received( key, received_files_length[key]): # ファイル受信完了 received_files_flag[key] = True self.file_received.put( (key, received_files_length[key])) except Exception as e: # recvが失敗した時とputが失敗した時は(適当) if e == KeyboardInterrupt: raise KeyboardInterrupt else: import traceback traceback.print_exc()
def turnRawToPacket(raw): tipe = int(raw[0]).to_bytes(1, 'big') length = int.from_bytes(raw[1:3], 'big') sequenceNumber = int.from_bytes(raw[3:5], 'big') checksum = raw[5:7] data = raw[7:] return Packet(tipe, length, sequenceNumber, data, checksum)
def get_extended_packet(self, receiver, payload): iniciopKp=time.time() packet = Packet(self.id, OP.EXTENDED, receiver, payload) print("{}: Sending EXTENDED packet to {}".format(self.id, receiver)) finpKp=time.time() print('########## Tiempo ##########:',(finpKp-iniciopKp), 'segundos') return packet
def sendTraceroutes(self): """Send traceroute packets to every other client in the network""" for dstClient in self.allClients: packet = Packet(Packet.TRACEROUTE, self.addr, dstClient) if self.link: self.link.send(packet, self.addr) self.updateFunction(packet.srcAddr, packet.dstAddr, [])
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 __init__(self, callback): """ Extend threading class. Parameters ---------- knowledge_base : object Handle to shared knoweldge base. lock : object File lock for concurrent access to knowledge base. initial_config : dict Initial radio configuration """ threading.Thread.__init__(self) # self.kb = knowledge_base # self.lock = lock self.controller_callback = callback self.stop_event = threading.Event() self.data = NodeAData() self.packet = Packet('A') self.radio = RadioAPI() self._fsm_state = 'listen' self.radio_command = 'continue' self.tx_packet_number = 1 self.ack_packet_number = 0 self.goodput = 0
def on_event(self, ioloop, events): if not events and ioloop.nodeid > 0: logging.debug('event handler. try to connect nodeid:%d', 0) ioloop.send_message( Packet(0, 0, 0, 'hello world! from node:%d'%(ioloop.nodeid))) self.sent=True else: pass
def frames_to_packet(self): packets = [] while True: count = len(self.frame_buffer) if count == 0: return packets packet_frames = self.frame_buffer[0].end if packet_frames > count: return packets # we have enough frames to make a packet byte_array = [] for i in range(packet_frames): byte_array += self.frame_buffer[i].data self.frame_buffer = self.frame_buffer[packet_frames:] packet_id = int.from_bytes(byte_array[0:16], 'big') packet_size = int.from_bytes(byte_array[16:18], 'big') packet_receiver = int.from_bytes(byte_array[18:24], 'big') packet_sender = int.from_bytes(byte_array[24:30], 'big') packet_data = byte_array[30:30 + packet_size] packet = Packet(packet_id, packet_data, packet_receiver, packet_sender) packets.append(packet) return packets
def _record(self, channel) -> None: fs = 44100 # Record at 44100 samples per second chunk = 1024 # Record in chunks of 1024 samples sample_format = pyaudio.paInt16 # 16 bits per sample channels = 2 stream = self.py_audio.open(format=sample_format, channels=channels, rate=fs, frames_per_buffer=chunk, input=True) self._recording = True self.logger.info(f'Audio recording started for channel {channel}') while self._recording: senderID = self.serverAPI.getUserID() priority = self.serverAPI.getChannelPriority(channel) message = stream.read(chunk) encodedMessage = base64.b64encode(message).decode('ascii') packet = Packet(priority, channel, senderID, encodedMessage) self.mqttAPI.publish(packet) self.logger.info(f"Audio recording stopped for channel {channel}") stream.stop_stream() stream.close()
def handle_packet(self, pkt_dir, pkt): # TODO: Your main firewall code will be here. packet = Packet(pkt, pkt_dir) # If the packet is an HTTP packet, assemble this packet's payload with the # rest of the data received from this TCP connection. if packet.transport_protocol == 'tcp' and packet.external_port == 80: # Return if the HTTP packet has a forward gap in SEQ number if not self.handle_http_packet(packet): pass verdict = self.verdict(packet) print "%-8s - %s" % (verdict, packet) if verdict == 'pass': self.pass_packet(packet.bytes, packet.direction) if verdict == 'deny-tcp': self.denytcp_packet(packet) if verdict == 'deny-dns': self.denydns_packet(packet) if verdict == 'log': self.log_packet(packet)
def test_long_body(self): packet = Packet( "1f07b1eeae1f07b1ee181f1a0eeb5701b202010a0101a000340034170d000208000186a019" .decode("hex")) self.assertTrue(packet.is_valid()) self.assertEqual(packet.body_len, 31) self.assertEqual(packet.packet_type, PacketType.PDM)
def test_init_ack_packet_with_extraneous_data(self): packet = Packet( "1f01482a5e1f01482ae51824c9e2fa95146a9a9444bbfa0f1474514e7d". decode("hex")) self.assertTrue(packet.is_valid()) self.assertEqual(packet.packet_type, PacketType.ACK) self.assertEqual(packet.raw_hex(), "1f01482a5e1f01482ae5")
def server_message(self, message): peer_ip = ipaddress.ip_address(socket.gethostbyname(self.server_add)) contents = bytearray(message.encode()) no_packets = 0 if (sys.getsizeof(contents) < 1013): self.send_all_pkt[no_packets] = contents no_packets = +1 else: for i in range(0, sys.getsizeof(contents), 100): self.send_all_pkt[no_packets] = contents[i:i + 100] no_packets = no_packets + 1 p = Packet(packet_type=1, seq_num=0, peer_ip_addr=peer_ip, peer_port=self.clientport, payload=str(len(self.send_all_pkt)).encode("utf-8")) threading.Thread(target=self.SYNack, args=(self.connections, )).start() self.connections.sendto(p.to_bytes(), self.sender) print('Send "{}" to client'.format("SYN")) time.sleep(self.delay) if (self.syn_received == False): self.resend_SYN(self.connections, p) if (self.syn_received): print('Begin transmission of packets to Router: ', self.sender) self.server_send(self.connections, peer_ip) else: print('Unknown response: ', self.sender)
def handleRemoveLink(self, port): """TODO: handle removed link""" # Hints: # update the forwarding table # broadcast the new link state of this router to all neighbors #get addr for i in self.forward_table.keys(): if self.forward_table[i]==port: a=i break #update forward table del self.forward_table[a] #remove edge self.graph.remove_edge(self.addr,a) #update state for i in self.state: if i[1] == a: self.state.remove(i) #just to be consistent state=[self.addr,a,69] #broadcasting self.sequence+=1 for i in self.forward_table.keys(): if i == a: continue else: b=Packet(2,self.addr,i,content=dumps({'state':state,'seq':self.sequence,'removal':True})) self.send(self.forward_table[i],b)
def __test_packets(self): for i in range(1, len(PacketType) + 1): print("[", i, "] : ", PacketType(i), sep='') packet_type = int(input("[packet type]>")) packet = Packet(PacketType(packet_type)) print('[0] : send') print('add content: ') print('[1] : Decimal') print('[2] : int') print('[3] : float') print('[4] : str') while True: value = int(input("[data type]>")) if value == 0: self.send(packet) break elif value == 1: dec = input("[Decimal] >") packet.add(Decimal(dec)) elif value == 2: integer = input("[int] >") packet.add(int(integer)) elif value == 3: flt = input("[float] >") packet.add(float(flt)) elif value == 4: str = input("[str] >") packet.add(str)
def handle_read(self): recievedData = self.recv(BS) if recievedData: rec(recievedData) else: player_id = self.pi ids.pop(player_id) un.pop(player_id) if player_id in queue: queue.remove(player_id) num = "" for i in games: check = games[i].check(player_id) if check: packet = Packet() packet.clear() packet.write(2, 'ends') packet.send(games[i].oth(player_id), packet) num = i if num != "": games.pop(num) self.close()
def checkBoard(self): if not self.__connection.isOpen(): return 0 sendPacket = Packet(CMD_NOP, CMD_NOP) self.__connection.write(sendPacket.getByteStream()) result = self.__checkResponse(self.__receive_bytes(3), sendPacket) return result
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 __init__(self, update_flag, update_data, reconfig_flag): """ Extend threading class. Parameters ---------- callback : obj Callback for controller, relays data from rf subsystem to controller """ threading.Thread.__init__(self) self.update_flag = update_flag self.update_data = update_data self.reconfig_flag = reconfig_flag self.stop_event = threading.Event() self.data = NodeAData() self.packet = Packet('A') self.radio = RadioAPI() self.last_state = 'stop' self.current_state = 'stop' self.current_location = 1 self.tx_packet_number = 1 self.cw_rssi = []
def test_pvid_vf_tx(self): """ Add port based vlan on vf device and check vlan tx work """ random_vlan = random.randint(1, MAX_VLAN) self.dut.send_expect( "ip link set %s vf 0 vlan %d" % (self.host_intf0, random_vlan), "# ") out = self.dut.send_expect("ip link show %s" % self.host_intf0, "# ") self.verify("vlan %d" % random_vlan in out, "Failed to add pvid on VF0") self.vm0_dut_ports = self.vm_dut_0.get_ports('any') self.vm0_testpmd = PmdOutput(self.vm_dut_0) self.vm0_testpmd.start_testpmd(VM_CORES_MASK) self.vm0_testpmd.execute_cmd('set fwd mac') self.vm0_testpmd.execute_cmd('start') pkt = Packet(pkt_type='UDP') pkt.config_layer('ether', {'dst': self.vf1_mac}) inst = sniff_packets(self.tester_intf0, timeout=5) pkt.send_pkt(tx_port=self.tester_intf1) pkts = load_sniff_packets(inst) self.verify(len(pkts), "Not receive expected packet") self.vm0_testpmd.quit() # disable pvid self.dut.send_expect( "ip link set %s vf 0 vlan 0" % (self.host_intf0), "# ")
def _send_command(self, command, data): p = Packet(seq=0, cmd=command, data=data, seq_sync=False) msg = p.toMessage() self.logger.debug('Msg to mastercontroller: %s' % list(msg)) self.interface.writeMessage(self.priority, self.address, msg, self.tx_msg_queue)
def send_packet(socket, header, data=None, pld=None, logger=None): is_loss = False packet = Packet() packet.wrap(header, data) print("=====================") print("sending>>>>>>>>>>>>>\n", header, '\n-----------------\n', data, sep='') print("=====================") if pld is not None: # randomly loss packet loss = pld.roll() if loss < pld.p_drop: print('{} not sent'.format(header.seq_num)) is_loss = True logger.pck_loss += 1 if logger is not None: data_len = data and len(data) or 0 logger.log('snd', header, data_len, is_loss) if is_loss: return if pld is not None: is_delay = pld.roll() if is_delay < pld.p_delay: delay = pld.roll() * pld.max_delay print('{} delayed for {} ms'.format(header.seq_num, delay)) time.sleep(delay/1000) logger.pck_delay += 1 socket.send(packet.msg)
def update(self, rtes): ''' Send update to all outputs ''' if self.inputs != {}: sock = list(self.inputs.values())[0] local_header = Header(router_id=self.id) for output in self.outputs: validated_rtes = [] for entry in rtes: if entry.next_hop != output: validated_rtes.append(entry) else: # Split horizon with poisoned reverse - if next_hop is destination output, set metric to unreachable validated_rtes.append( RTE(raw_data=None, src_id=None, address=entry.addr, next_hop=entry.next_hop, metric=RTE.MAX_METRIC, imported=entry.imported)) packet = Packet(header=local_header, rtes=validated_rtes) # Send sock.sendto(packet.serialize(), (self.host, self.outputs[output]["port"]))
def test_port_config(self): """ Test ethtool app port configure """ self.dut.send_expect(self.cmd, "EthApp>", 60) for index in range(len(self.ports)): port = self.ports[index] ori_rx_pkts, _ = self.strip_portstats(index) # add sleep time for update link status with fortville nic time.sleep(10) # stop port self.dut.send_expect("stop %d" % index, "EthApp>") time.sleep(10) # check packet not forwarded when port is stop pkt = Packet() tester_port = self.tester.get_local_port(port) intf = self.tester.get_interface(tester_port) pkt.send_pkt(tx_port=intf) rx_pkts, tx_pkts = self.strip_portstats(index) self.verify(rx_pkts == ori_rx_pkts, "Failed to stop port") # restart port and check packet can normally forwarded time.sleep(2) self.dut.send_expect("open %d" % index, "EthApp>") # wait few time for port ready rx_pkts, tx_pkts = self.strip_portstats(index) time.sleep(2) pkt.send_pkt(tx_port=intf) rx_pkts_open, tx_pkts_open = self.strip_portstats(index) self.verify(rx_pkts_open == rx_pkts + 1, "Failed to reopen port rx") self.verify(tx_pkts_open == tx_pkts + 1, "Failed to reopen port tx") self.dut.send_expect("quit", "# ")
def decode_state_msg(raw_packet): if raw_packet[1] != 0x01: print("- packet parser: decode_state_msg: raw packet not 0x01 type") return None if len(raw_packet) != 24: print("- packet parser: decode_state_msg: raw packet not 24 bytes", raw_packet.hex()) return None unpacked = unpack('<ccfffffcc', raw_packet) pkt = Packet() pkt.message_type = 0x01 pkt.raw = raw_packet state_msg = { 'x': unpacked[2], 'y': unpacked[3], 'phi': unpacked[4], 'sp_x': unpacked[5], 'sp_y': unpacked[6] } crc = ((int.from_bytes(unpacked[7], 'little') & 0xff) << 8) | ( int.from_bytes(unpacked[8], 'little') & 0xff) pkt.valid = validate_crc(raw_packet, crc) pkt.parsed = state_msg return pkt
def handleRemoveLink(self, port): """TODO: handle removed link""" # Hints: # update the forwarding table # broadcast the new link state of this router to all neighbors self.G.remove_node(self.link_state[port]) for who in self.neighbors: if self.neighbors[who] == port: to_remove = who break self.link_state.pop(to_remove) self.neighbors.pop(to_remove) self.G.remove_node(self.link_state[to_remove]) for dst in self.fwd_table: path = nx.dijkstra_path(G, 0, dst, weight='weight') self.fwd_table[dst] = self.neighbors[path[1]] my_seq += 1 to_send_LS = dumps(self.link_state) for dst in fwd_table: pkt = Packet(kind=packet.ROUTING, srcAddr=self.addr, dstAddr=dst, content=[my_seq, to_send_LS]) self.send(self.fwd_table[dst], pkt)
def decode_control_msg(raw_packet): if raw_packet[1] != 0x03: print("- packet parser: decode_control_msg: raw packet not 0x03 type") return None if len(raw_packet) != 10: print("- packet parser: decode_control_msg: raw packet not 10 bytes", raw_packet.hex()) return None unpacked = unpack('<ccccfcc', raw_packet) pkt = Packet() pkt.message_type = 0x03 pkt.raw = raw_packet control_msg = { 'node_id': int.from_bytes(unpacked[2], 'little'), 'type': int.from_bytes(unpacked[3], 'little'), 'u': unpacked[4] } crc = ((int.from_bytes(unpacked[5], 'little') & 0xff) << 8) | ( int.from_bytes(unpacked[6], 'little') & 0xff) pkt.valid = validate_crc(raw_packet, crc) pkt.parsed = control_msg return pkt
def packets(self): message_type = self.body[0:2] body_remaining = self.body[2:] + self.computed_crc_bytes() packets = [] while len(body_remaining) > 0: packet = Packet() packet.pod_address_1 = self.pod_id packet.sequence = self.start_seq + len(packets) * 2 if len(packets) == 0: packet.packet_type = Packet.PACKET_TYPE_PDM packet.pod_address_2 = self.pod_id packet.byte9 = self.byte9 packet.message_type = message_type segment_len = min(Packet.MAX_BODY_SEGMENT_LEN, len(body_remaining)) packet.body = body_remaining[:segment_len] packet.body_len = len(self.body) body_remaining = body_remaining[segment_len:] else: packet.packet_type = Packet.PACKET_TYPE_CON segment_len = min(Packet.MAX_CON_BODY_SEGMENT_LEN, len(body_remaining)) packet.body = body_remaining[:segment_len] body_remaining = body_remaining[segment_len:] packets.append(packet) return packets
def base_id(self): ''' Fetches Base ID from the transmitter, if required. Otherwise returns the currently set Base ID. ''' # If base id is already set, return it. if self._base_id is not None: return self._base_id # Send COMMON_COMMAND 0x08, CO_RD_IDBASE request to the module self.send(Packet(PACKET.COMMON_COMMAND, data=[0x08])) # Loop over 10 times, to make sure we catch the response. # Thanks to timeout, shouldn't take more than a second. # Unfortunately, all other messages received during this time are ignored. for i in range(0, 10): try: packet = self.receive.get(block=True, timeout=0.1) # We're only interested in responses to the request in question. if packet.packet_type == PACKET.RESPONSE and packet.response == RETURN_CODE.OK and len( packet.response_data) == 4: # Base ID is set in the response data. self._base_id = packet.response_data # Put packet back to the Queue, so the user can also react to it if required... self.receive.put(packet) break # Put other packets back to the Queue. self.receive.put(packet) except queue.Empty: continue # Return the current Base ID (might be None). return self._base_id