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
