def __init__(self, names, nums, index, reformer, i, line):
Container.__init__(self)
data = line.strip("\n").split("\t")
self.__dict__ = (reformer or (lambda x: x))(dict(compress(zip(names, data), nums)))
if index and data[index] and data[index].isdecimal():
i = int(data[index])
elif index:
i = None
self.__dict__["_id"] = i
def _header_digest(
header: c.Container,
header_type: c.Construct,
hash_function: Callable = pyblake2.blake2s,
) -> bytes:
stripped_header = header.copy()
stripped_header.sigmask = 0
stripped_header.signature = b"\0" * 64
stripped_header.v1_key_indexes = [0, 0, 0]
stripped_header.v1_signatures = [b"\0" * 64] * 3
header_bytes = header_type.build(stripped_header)
return hash_function(header_bytes).digest()
def eos_remote_release_on(self, full=False):
'''
Remote control shutter press for EOS cameras
This is the equivalent of pressing the shutter button: all the way in
if `full` or half-way otherwise.
'''
ptp = Container(OperationCode='EOSRemoteReleaseOn',
SessionID=self.__session,
TransactionID=self.__transaction,
Parameter=[0x2 if full else 0x1])
response = self.mesg(ptp)
return response
def eos_event_mode(self, mode):
'''Set event mode on EOS cameras'''
# Canon extension uses this to enrich the events returned by the camera
# as well as allowing for polling at the convenience of the initiator.
# TODO: Add automatic translation of event mode codes and names.
code = mode
ptp = Container(OperationCode='EOSSetEventMode',
SessionID=self.__session,
TransactionID=self.__transaction,
Parameter=[code])
response = self.mesg(ptp)
return response
def send_message(self,
action,
msg_type,
crud_result,
tlvs=None,
callback=None):
"""Send message and set common parameters."""
parser = self.proto.PT_TYPES[action][0]
name = self.proto.PT_TYPES[action][1]
if self.stream.closed():
self.log.warning("Stream closed, unabled to send %s message to %s",
parser.name, self.device)
return 0
msg = Container()
msg.version = self.proto.PT_VERSION
msg.flags = Container(msg_type=msg_type)
msg.tsrc = Container(crud_result=crud_result, action=action)
msg.length = self.proto.HEADER.sizeof()
msg.padding = 0
msg.device = self.device.addr.to_raw()
msg.seq = self.seq
msg.xid = self.xid
msg.tlvs = []
addr = self.stream.socket.getpeername()
self.log.debug("Sending %s message to %s seq %u", name, addr[0],
msg.seq)
self.stream.write(parser.build(msg))
if callback:
self.xids[msg.xid] = (msg, callback)
return msg.xid
def get_tx_bitrates(server, id=0, intf_name=None, sta_ip=None, sta_port=0):
""" get the channels the interface intf_name supports, this function applies to access points
@param server: tuple (ip, port_num)
@param id: message id
@param intf_name: name of the wireless interface
@type intf_name: str
@param sta_ip: ip address of the station that this message should be relayed to, if sta_ip is different from None
@type sta_ip: str
@param sta_port: socket port number of the station
@type sta_port: int
@return: a dictionary, the index is the band
"""
if intf_name is None:
raise ValueError("intf_name must have a valid value!")
# 1) create message
msg_struct = Container(
m_type=MSG_TYPE.MSG_GET_TX_BITRATES,
m_id=id,
p_version_length=len_of_string(VERSION),
p_version=VERSION,
m_size=0,
intf_name_size=len_of_string(intf_name),
intf_name=intf_name,
sta_ip_size=len_of_string(sta_ip),
sta_ip=sta_ip,
sta_port=sta_port,
num_bands=0, # don´t know how many bands are in the AP
iw_bands=[], # field will be filled by the AP
)
error, msg = send_and_receive_msg(server, msg_struct,
msg_tx_bitrates.build,
msg_tx_bitrates.parse)
value = dict()
if not error or ('iw_bands' not in msg):
for v in msg['iw_bands']:
bitrates = []
is_short = []
for e in v['iw_bitrates']:
bitrates.append(e['bitrate'])
is_short.append(e['is_short'] == 1)
value[v['band']] = {
'intf_name': v['intf_name'],
'bitrates': bitrates,
'support_short':
is_short, # if this bitrate supports short preamble or not
}
"""
returns the value, note: {} equals an error has occured or no band found
"""
return msg, value
def send_add_lvap_request(self, lvap, block, set_mask):
"""Send a ADD_LVAP message."""
flags = Container(ht_caps=lvap.ht_caps,
authenticated=lvap.authentication_state,
associated=lvap.association_state,
set_mask=set_mask)
encap = EtherAddress("00:00:00:00:00:00")
if lvap.encap:
encap = lvap.encap
bssid = EtherAddress()
if lvap.bssid:
bssid = lvap.bssid
ssid = SSID()
if lvap.ssid:
ssid = lvap.ssid
msg = Container(length=80,
flags=flags,
assoc_id=lvap.assoc_id,
iface_id=block.block_id,
ht_caps_info=Container(**lvap.ht_caps_info),
sta=lvap.addr.to_raw(),
encap=encap.to_raw(),
bssid=bssid.to_raw(),
ssid=ssid.to_raw(),
networks=[])
for network in lvap.networks:
msg.length = msg.length + 6 + WIFI_NWID_MAXSIZE + 1
msg.networks.append(
Container(bssid=network[0].to_raw(), ssid=network[1].to_raw()))
return self.send_message(self.proto.PT_ADD_LVAP_REQUEST, msg,
lvap.handle_add_lvap_response)
def send_del_ran_mac_slice_request(self, cell, plmn_id, dscp):
"""Send an DEL_SLICE message. """
msg = Container(plmn_id=plmn_id.to_raw(),
dscp=dscp.to_raw(),
padding=b'\x00\x00\x00',
length=REM_RAN_MAC_SLICE_REQUEST.sizeof())
self.send_message(msg,
E_TYPE_SINGLE,
EP_ACT_RAN_MAC_SLICE,
REM_RAN_MAC_SLICE_REQUEST,
opcode=EP_OPERATION_REM,
cellid=cell.pci)
async def handle_panel_raw_message(self, raw: bytes):
"""
Handle message from panel, which must be sent to the client
"""
out_message_container = Container(
header=Container(
message_type=IPMessageType.serial_passthrough_response,
command=IPMessageCommand.passthrough,
flags=Container(
keep_alive=True,
live_events=True,
neware=True,
upload_download=True,
encrypt=self.flags.encrypt,
),
sb=3,
wt=0,
),
payload=raw,
)
await self._send_to_client(out_message_container)
def _decode(self, obj, context, path):
event_group = obj[0]
event_1_high_nibble = obj[1] >> 6
event_2_high_nibble = (obj[1] >> 4) & 0b11
event_1 = obj[2] + (event_1_high_nibble << 8)
event_2 = obj[3] + (event_2_high_nibble << 8)
partition = obj[1] & 0x0F
return Container({
"major": event_group,
"minor": event_1,
"minor2": event_2,
"partition": partition,
})
def run_once(self):
"""Send out rate request."""
if self.tenant_id not in RUNTIME.tenants:
self.log.info("Tenant %s not found", self.tenant_id)
self.unload()
return
tenant = RUNTIME.tenants[self.tenant_id]
if self.imsi not in tenant.ues:
self.log.info("UE %u not found", self.imsi)
self.unload()
return
ue = tenant.ues[self.imsi]
if not ue.vbs or not ue.vbs.is_online():
self.log.info("VBS %s not connected", ue.vbs.addr)
self.unload()
return
self.vbs = ue.vbs
for i in self.measurements:
measurement = self.measurements[i]
rrc_request = Container(type=E_TYPE_TRIG,
version=PT_VERSION,
enbid=self.vbs.enb_id,
cellid=ue.cell.pci,
modid=self.module_id,
length=RRC_REQUEST.sizeof(),
seq=self.vbs.seq,
action=EP_ACT_RRC_MEASUREMENT,
dir=EP_DIR_REQUEST,
op=EP_OPERATION_ADD,
meas_id=i,
rnti=ue.rnti,
earfcn=measurement["earfcn"],
interval=measurement["interval"],
max_cells=measurement["max_cells"],
max_meas=measurement["max_meas"])
self.log.info("Sending rrc request to %s @ %s (id=%u, meas_id=%u)",
ue.rnti, self.vbs.enb_id, self.module_id, i)
msg = RRC_REQUEST.build(rrc_request)
self.vbs.connection.stream.write(msg)
def test_encoding(self):
'''Puesta en hora'''
from datetime import datetime
frame = MaraFrame.build(
Container(
sof=0xFE,
dest=1,
source=0,
sequence=32,
command=0x12,
peh=datetime.now(),
))
parsed = MaraFrame.parse(frame)
self.assertIn('peh', parsed)
def loop(self):
"""Send out requests"""
if self.addr not in self.context.lvaps:
return
lvap = self.context.lvaps[self.addr]
msg = Container(length=TXP_BIN_COUNTERS_REQUEST.sizeof(),
iface_id=self.iface_id,
addr=lvap.addr.to_raw())
lvap.wtp.connection.send_message(PT_TXP_BIN_COUNTERS_REQUEST, msg,
self.handle_response)
async def test_wait_for_message(mocker):
loop = asyncio.get_event_loop()
msg = Container()
mm = AsyncMessageManager()
task1 = loop.create_task(mm.wait_for_message())
s = mm.schedule_message_handling(msg)
assert await task1 == msg
assert task1.done()
assert s.done()
assert len(mm.handler_registry) == 0
def a_tag(self):
"""Devuelve la informacion del apertura para almacenar en tag rfid."""
nombres, dnis, tipos = self.encodear_autoridades()
container = Container(numero_mesa=int(self.mesa.numero),
hora=int(self.hora["horas"]),
minutos=int(self.hora["minutos"]),
cantidad_autoridades=len(self.autoridades),
len_nombres=len(nombres),
nombres=nombres,
tipos=tipos,
dnis=dnis)
built = struct_apertura.build(container)
return built
def send_set_traffic_rule(self, traffic_rule):
"""Send an ADD_TRAFFIC_RULE message.
Args:
traffic_rule: a Traffic Rule object
Returns:
None
"""
flags = Container(amsdu_aggregation=traffic_rule.amsdu_aggregation)
add_tr = Container(version=PT_VERSION,
type=PT_SET_TRAFFIC_RULE,
length=25 + len(traffic_rule.ssid),
seq=self.wtp.seq,
flags=flags,
hwaddr=traffic_rule.block.hwaddr.to_raw(),
channel=traffic_rule.block.channel,
band=traffic_rule.block.band,
quantum=traffic_rule.quantum,
dscp=int(traffic_rule.dscp, 16),
ssid=traffic_rule.ssid.to_raw())
self.send_message(add_tr, SET_TRAFFIC_RULE)
def answer_to_gamecontroller(self, peer):
""" Sends a life sign to the game controller """
return_message = 0 if self.man_penalize else 2
data = Container(header="RGrt",
version=GAME_CONTROLLER_RESPONSE_VERSION,
team=self.team,
player=self.player,
message=return_message)
try:
destination = peer[0], GAME_CONTROLLER_ANSWER_PORT
self.socket.sendto(ReturnData.build(data), destination)
except Exception as e:
logger.log("Network Error: %s" % str(e))
def open_session(self):
self._session += 1
self._transaction = 1
ptp = Container(
OperationCode='OpenSession',
# Only the OpenSession operation is allowed to have a 0
# SessionID, because no session is open yet.
SessionID=0,
TransactionID=0,
Parameter=[self._session])
response = self.mesg(ptp)
if response.ResponseCode == 'OK':
self.__session_open = True
return response
def loop(self):
"""Send out requests"""
if self.sta not in self.context.lvaps:
return
lvap = self.context.lvaps[self.sta]
msg = Container(length=WIFI_RC_STATS_REQUEST.sizeof(),
sta=lvap.addr.to_raw())
lvap.wtp.connection.send_message(PT_WIFI_RC_STATS_REQUEST,
msg,
self.handle_response)
def send_object(self, bytes_data):
'''Send object to responder.
The object should correspond to the latest SendObjectInfo interaction
between Initiator and Responder.
'''
ptp = Container(OperationCode='SendObject',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[])
response = self.send(ptp, bytes_data)
if response.ResponseCode != 'OK':
response = self.send(ptp, bytes_data)
return response
def get_resized_image_object(self, handle, width, height=0):
'''Retrieve resized image object from responder.
The object should correspond to a previous GetObjectInfo interaction
between Initiator and Responder in the same session.
If width is provided then the aspect ratio may change. The device may
not support this.
'''
ptp = Container(OperationCode='GetResizedImageObject',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[handle, width, height])
return self.recv(ptp)
def _decode(self, obj, context, path):
event_group = obj[0]
event_1_high_nibble = obj[1] >> 6
event_2_high_nibble = (obj[1] >> 4) & 0b11
event_1 = obj[2] + (event_1_high_nibble << 8)
event_2 = obj[3] + (event_2_high_nibble << 8)
partition = obj[1] & 0x0f
return Container({
'major': event_group,
'minor': event_1,
'minor2': event_2,
'partition': partition
})
def send_object_info(self, objectinfo):
'''Send ObjectInfo to responder.
The object should correspond to the latest SendObjectInfo interaction
between Initiator and Responder.
'''
objectinfo = self._build_if_not_data(objectinfo, self._ObjectInfo)
ptp = Container(OperationCode='SendObjectInfo',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[])
return self.send(ptp, objectinfo)
def send_caps_request(self):
"""Send a CAPS_REQUEST message.
Args:
vbs: an VBS object
Returns:
None
"""
msg = Container(length=ENB_CAPS_REQUEST.sizeof(), dummy=0)
self.send_message(msg,
E_TYPE_SINGLE,
EP_ACT_CAPS,
ENB_CAPS_REQUEST)
def _Temperature(self):
return ExprAdapter(
self._PTPArray(self._Int32),
encoder=lambda obj, ctx:
[obj.P7, obj.P7MU, obj.DDR.obj.WiFi, obj.IMU, obj.IMUSunshine],
decoder=lambda obj, ctx: Container(
P7=obj[0],
P7MU=obj[1],
DDR=obj[2],
WiFi=obj[3],
IMU=obj[4],
IMUSunshine=obj[5],
),
)
def as_bytes(self):
if self.msg_type in [
HandshakeType.SERVER_HELLO, HandshakeType.CLIENT_HELLO,
HandshakeType.CERTIFICATE, HandshakeType.CERTIFICATE_REQUEST,
HandshakeType.HELLO_REQUEST, HandshakeType.SERVER_HELLO_DONE,
HandshakeType.FINISHED
]:
_body_as_bytes = self.body.as_bytes()
else:
_body_as_bytes = b''
return _constructs.Handshake.build(
Container(msg_type=self.msg_type.value,
length=self.length,
body=_body_as_bytes))
def loop(self):
"""Send out requests"""
for wtp in self.context.lvapp_manager.devices.values():
if not wtp.connection:
continue
msg = Container(length=WIFI_SLICE_STATS_REQUEST.sizeof(),
ssid=self.context.wifi_props.ssid.to_raw(),
slice_id=self.slice_id)
wtp.connection.send_message(PT_WIFI_SLICE_STATS_REQUEST, msg,
self.handle_response)
def get_vendor_device_info(self, extension):
'''Get VendorExtension maps when supporting more than one extension.
'''
code = self.__code(extension, self._VendorExtensionID)
ptp = Container(
OperationCode='GetVendorDeviceInfo',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[code]
)
response = self.recv(ptp)
return self._parse_if_data(
response,
self._DeviceInfo)
def initiate_open_capture(self, storage_id=0, object_format=0):
'''Initiate open capture in `storage_id` of type `object_format`.'''
code = self.__code(object_format, self._ObjectFormatCode)
ptp = Container(
OperationCode='InitiateOpenCapture',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[
storage_id,
code,
]
)
response = self.recv(ptp)
return response
def initiate_capture(self, storage_id=0, object_format=0):
'''Initiate capture with current camera settings.'''
code = self.__code(object_format, self._ObjectFormatCode)
ptp = Container(
OperationCode='InitiateCapture',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[
storage_id,
code,
]
)
response = self.recv(ptp)
return response
def _encode(self, obj, context, path):
passed_time: datetime = obj["date"]
total_time = passed_time.timestamp(
) - MESH_UNIX_EPOCH_DIFF - passed_time.utcoffset().total_seconds()
return Container(tai_seconds=int(total_time),
subsecond=seconds_to_subsecond(total_time),
uncertainty=int(
(obj["uncertainty"].total_seconds() * 100)),
tai_utc_delta=timedelta_to_mesh_tai_utc_delta(
obj["tai_utc_delta"]),
time_authority=bool(obj["time_authority"]),
time_zone_offset=timedelta_to_mesh_time_zone_offset(
passed_time.utcoffset()))
def get_snr_power(server,
id=0,
intf_name=None,
sta_ip=None,
sta_port=0,
m_type=None):
"""INTERVAL FUNCTION: DON'T CALL THIS METHOD.
@param server: tuple (ip, port_num)
@param id: message id
@param intf_name: name of the wireless interface
@type intf_name: str
@param sta_ip: ip address of the station that this message should be relayed to, if sta_ip is different from None
@type sta_ip: str
@param sta_port: socket port number of the station
@type sta_port: int
@return: msg - received message
@return: the value
-1 equals an error has occured
"""
if intf_name is None or \
m_type not in [MSG_TYPE.MSG_GET_SNR, MSG_TYPE.MSG_GET_TXPOWER]:
return None, -1
# 1) create message
msg_struct = Container(m_type=m_type,
m_id=id,
p_version_length=len_of_string(VERSION),
p_version=VERSION,
m_size=0,
intf_name_size=len_of_string(intf_name),
intf_name=intf_name,
sta_ip_size=len_of_string(sta_ip),
sta_ip=sta_ip,
sta_port=sta_port,
value=0)
error, msg = send_and_receive_msg(server, msg_struct, msg_snr_power.build,
msg_snr_power.parse)
# print msg
if not error:
value = msg['value'] if 'value' in msg else -1
else:
value = -1
return msg, value
