from construct import Struct, Union, Enum, SLInt32 announcement_type = Enum( SLInt32("type"), LAUNCH=0, EXIT=1, ) announcement = Struct( "announcement", announcement_type, Union( "args", SLInt32("rank"), ), ) ANNOUNCEMENT_PACKET_LEN = announcement.sizeof()
@since: July 2015 @status: in development @requires: construct 2.5.2 """ from construct import SLInt8, SLInt32, ULInt64, CString from construct import Embed, Struct, Container from construct import If from pox.ethanol.ssl_message.msg_core import msg_default from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION, tri_boolean from pox.ethanol.ssl_message.msg_common import send_and_receive_msg, len_of_string field_mac_ap = Struct( 'mac_ap', SLInt32('mac_ap_size'), If(lambda ctx: ctx["mac_ap_size"] > 0, CString("mac_ap")), ) """ handles the ap's mac address used in msg_association """ field_mac_sta = Struct( 'mac_sta', SLInt32('mac_sta_size'), If(lambda ctx: ctx["mac_sta_size"] > 0, CString("mac_sta")), ) """ handles the station's mac address used in msg_association """ msg_association = Struct( 'msg_association', Embed(msg_default), # default fields
from construct import ULInt32, SLInt32, ULInt64 from construct import Embed, Struct, Container, Array from pox.ethanol.ssl_message.msg_core import msg_default from pox.ethanol.ssl_message.msg_core import field_station, field_mac_addr, field_ssid, field_intf_name from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION from pox.ethanol.ssl_message.msg_common import send_and_receive_msg, len_of_string # ############################################################### # # MSG_TYPE.MSG_WLAN_INFO # # ############################################################### wlan_entry = Struct( 'wlan_entry', SLInt32('ifindex'), Embed(field_intf_name), ULInt32('wlan_indx'), ULInt32('phy_indx'), ULInt64('dev'), Embed(field_mac_addr), Embed(field_ssid), ULInt32('channel_type'), ULInt32('chan_width'), ULInt32('freq'), ULInt32('freq1'), ULInt32('freq2'), SLInt32('iftype'), ) """ information about a wifi interface"""
from construct import SLInt32 from construct import Embed from construct import Struct from construct import Container # from construct.debug import Probe from pox.ethanol.ssl_message.msg_core import msg_default from pox.ethanol.ssl_message.msg_core import field_intf_name from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION from pox.ethanol.ssl_message.msg_common import send_and_receive_msg, len_of_string msg_ap_dtiminterval = Struct('msg_ap_dtiminterval', Embed(msg_default), # default fields Embed(field_intf_name), SLInt32('dtim_interval'), # Probe() ) def get_ap_dtiminterval(server, id=0, intf_name=None): """ get the DTIM interval set in the interface intf_name @param server: tuple (ip, port_num) @param id: message id @param intf_name: name of the wireless interface @type intf_name: str @return msg: received message @return value: """ if intf_name is None:
""" from datetime import datetime from construct import SLInt32, LFloat32, CString, SLInt8 from construct import Embed, Struct, Container from construct import If # from construct.debug import Probe from pox.ethanol.ssl_message.msg_core import msg_default from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION, BUFFER_SIZE from pox.ethanol.ssl_message.msg_common import connect_ssl_socket from pox.ethanol.ssl_message.msg_common import is_error_msg, tri_boolean, len_of_string msg_ping = Struct( 'msg_ping', Embed(msg_default), # default fields SLInt32('data_size'), If(lambda ctx: ctx["data_size"] > 0, CString("data")), # Probe(), ) """ ping message data structure """ msg_pong = Struct( 'msg_pong', Embed(msg_default), # default fields LFloat32('rtt'), # float com 32 bits, LFloat32 (C little endian 32 bits) SLInt8('verify_data'), # class boolean # Probe(), ) """ pong message data structure """
from pox.ethanol.ssl_message.msg_log import log from pox.ethanol.ethanol.ap import add_ap from pox.ethanol.ethanol.station import add_station from pox.ethanol.events import Events events_hello = Events() """to handle a receiving hello message, just add your function to events_hello your function must use 'def my_funct(**kwargs)' signature for compatibility @change: we send to parameters: msg, fromaddr """ msg_hello = Struct('msg_hello', Embed(msg_default), # default fields SLInt32('device_type'), # 0 = controller, 1 = ap, 2 = station SLInt32('tcp_port'), LFloat32('rtt') # float com 32 bits ) def send_msg_hello(server, m_id=0): """ @param server: tuple (ip, port_num) @param m_id: message id @return: msg - received message """ ssl_sock, sckt = connect_ssl_socket(server) # print "send_msg_hello id:", m_id
LFloat64('tx_carrier_errors'), LFloat64('tx_compressed'), LFloat64('tx_dropped'), LFloat64('tx_errors'), LFloat64('tx_fifo_errors'), LFloat64('tx_heartbeat_errors'), LFloat64('tx_packets'), LFloat64('tx_window_errors'), # Probe() ) msg_mean_statistics = Struct( 'msg_mean_statistics', Embed(msg_default), # default fields Embed(field_station), SLInt32('num'), Array(lambda ctx: ctx.num, CString('intf')), Array(lambda ctx: ctx.num, mean_net_statistics), # Probe() ) def send_msg_mean_sta_statistics(server, id=0, sta_ip=None, sta_port=0): """ @param server: tuple (ip, port_num) @param id: message id @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
), # long in c is coded as a unsigned 64-bit integer little endian SLInt64( 'receive_time' ), # long long in c is coded as a unsigned 64-bit integer little endian SLInt64('transmit_time'), SLInt64('active_time'), SLInt64('busy_time'), SLInt64('channel_type'), SLInt64('extension_channel_busy_time'), ) msg_channelinfo = Struct( 'msg_channelinfo', Embed(msg_default), # default fields Embed(field_intf_name), SLInt32('channel'), SLInt32('num_freqs'), # Probe(), Array(lambda ctx: ctx.num_freqs, channel_info), ) def get_channelinfo(server, id=0, intf_name=None, channel=0, only_channel_in_use=False): """ get the channels the interface inff_name supports, this function applies to access points @param server: tuple (ip, port_num) @param id: message id
@requires: construct 2.5.2 """ from construct import SLInt8, SLInt32, ULInt64, LFloat32 from construct import Embed, Struct, Container from pox.ethanol.ssl_message.msg_core import msg_default from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION, tri_boolean from pox.ethanol.ssl_message.msg_common import send_and_receive_msg, len_of_string from pox.ethanol.ssl_message.msg_core import field_mac_addr msg_metric = Struct( 'msg_metric', Embed(msg_default), # default fields SLInt8('enable'), # boolean enable or disable SLInt32('period'), ULInt64( 'metric' ), # bit array, bit=0 is not considered, bit=1 apply 'enable' action ) """ all metric message types are the same """ def set_metric(server, id=0, metric=0, enable=True, period=100): """ only for tests. the controller don't use this!!! """ if metric == 0: return None msg_struct = Container( m_type=MSG_TYPE.MSG_SET_METRIC,
@requires: construct 2.5.2 """ from construct import SLInt32, CString from construct import Embed, If from construct import Struct from construct import Container # from construct.debug import Probe from pox.ethanol.ssl_message.msg_core import msg_default from pox.ethanol.ssl_message.msg_core import field_intf_name from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION from pox.ethanol.ssl_message.msg_common import send_and_receive_msg, len_of_string field_current_ap = Struct('current_ap', SLInt32('current_ap_size'), If(lambda ctx: ctx["current_ap_size"] > 0, CString("current_ap")), ) msg_changed_ap = Struct('msg_changed_ap', Embed(msg_default), # default fields Embed(field_intf_name), Embed(field_current_ap), SLInt32('status'), # Probe() ) def changed_ap(server, id=0, status=0, current_ap=None, intf_name=None): """ verify is the interface is broadcasting the SSID @param server: tuple (ip, port_num)
from pox.ethanol.ssl_message.msg_core import field_intf_name, field_station from pox.ethanol.ssl_message.msg_core import field_mac_addr from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION from pox.ethanol.ssl_message.msg_common import send_and_receive_msg, len_of_string from pox.ethanol.events import Events events_snr_threshold_reached = Events() """to handle a receiving snr_threshold_reached message, just add your function to events_snr_threshold_reached your function must use 'def my_funct(**kwargs)' signature for compatibility @change: we send to parameters: msg, fromaddr, sta_mac, intf_name, mac_ap """ field_mac_ap = Struct( 'mac_ap', SLInt32('mac_ap_size'), If(lambda ctx: ctx["mac_ap_size"] > 0, CString("mac_ap")), ) """ handles a mac address field for the new ap (a C char * field) """ msg_snr_threshold_reached = Struct( 'msg_snr_threshold_reached', Embed(msg_default), # default fields Embed(field_station), Embed(field_mac_addr), # sta_mac Embed(field_intf_name), # intf_name Embed(field_mac_ap), # mac_ap SLInt64('snr'), # Probe() )
@status: in development @requires: construct 2.5.2 """ from construct import SLInt32, CString from construct import Embed, Struct, Container, If from pox.ethanol.ssl_message.msg_core import msg_default from pox.ethanol.ssl_message.msg_core import field_intf_name from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION from pox.ethanol.ssl_message.msg_common import send_and_receive_msg, len_of_string field_parameter = Struct( 'param_name', SLInt32('param_name_size'), If(lambda ctx: ctx["param_name_size"] > 0, CString("param_name")), ) """ name of the parameter """ field_parameter_value = Struct( 'param_name_value', SLInt32('param_name_value_size'), If(lambda ctx: ctx["param_name_value_size"] > 0, CString("param_value_name")), ) """ value of the parameter """ msg_hostapd_conf = Struct(
from construct import Array from construct import Struct from construct import Container # from construct.debug import Probe from pox.ethanol.ssl_message.msg_core import msg_default from pox.ethanol.ssl_message.msg_core import field_mac_addr, field_ssid, field_intf_name, field_station from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION from pox.ethanol.ssl_message.msg_common import send_and_receive_msg, tri_boolean, len_of_string ap_in_range = Struct( 'ap_in_range', Embed(field_intf_name), Embed(field_mac_addr), Embed(field_ssid), SLInt32('status'), SLInt64('frequency'), SLInt32('channel'), LFloat32('signal'), # float in C is coded as little endian 32 bit number SLInt32('powerconstraint'), SLInt32('tx_power'), SLInt32('link_margin'), SLInt32('age'), SLInt8('is_dBm'), # this is a boolean coded as a 8 bit integer ) msg_ap_in_range = Struct( 'msg_ap_in_range', Embed(msg_default), # default fields Embed(field_intf_name), Embed(field_station),
@requires: construct 2.5.2 """ from construct import SLInt32, SLInt64, CString from construct import Embed, If from construct import Struct from construct import Container # from construct.debug import Probe from pox.ethanol.ssl_message.msg_core import msg_default, field_intf_name, field_station from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION from pox.ethanol.ssl_message.msg_common import send_and_receive_msg, len_of_string, return_from_dict field_time_stamp = Struct( 'time_stamp', SLInt32('time_stamp_size'), If(lambda ctx: ctx["time_stamp_size"] > 0, CString("time_stamp")), ) msg_statistics = Struct( 'msg_statistics', Embed(msg_default), # default fields Embed(field_intf_name), Embed(field_station), SLInt64('rx_packets'), SLInt64('rx_bytes'), SLInt64('rx_dropped'), SLInt64('rx_errors'), SLInt64('tx_packets'), SLInt64('tx_bytes'), SLInt64('tx_dropped'),
from construct import Container # from construct.debug import Probe from pox.ethanol.ssl_message.msg_core import msg_default from pox.ethanol.ssl_message.msg_core import field_station, field_ssid, field_intf_name, field_mac_addr from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION from pox.ethanol.ssl_message.msg_common import send_and_receive_msg, len_of_string msg_sta_link_info = Struct( 'msg_sta_link_info', Embed(msg_default), Embed(field_intf_name), Embed(field_station), Embed(field_mac_addr), Embed(field_ssid), SLInt32('frequency'), ) def get_sta_link_info(server, id=0, sta_ip=None, sta_port=0, intf_name=None): """ returns three values: mac_addr, ssid, frequency None equals an error has occured (or no interface found) @todo: Nao eh necessario retornar intf_name @param server: tuple (ip, port_num) @param id: message id @param intf_name: names of the wireless interface @type intf_name: list of str @param sta_ip: ip address of the station that this message should be relayed to, if sta_ip is different from None
@requires: construct 2.5.2 """ from construct import SLInt32 from construct import Embed, Struct, Container from pox.ethanol.ssl_message.msg_core import msg_default from pox.ethanol.ssl_message.msg_core import field_intf_name from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION from pox.ethanol.ssl_message.msg_common import send_and_receive_msg, len_of_string msg_preamble = Struct( 'msg_preamble', Embed(msg_default), # default fields Embed(field_intf_name), SLInt32('preamble'), ) def get_preamble(server, id=0, intf_name=None): """ gets if the configured preamble is long or short @param server: tuple (ip, port_num) @param id: message id @param intf_name: name of the wireless interface @type intf_name: str @return: msg - received message """ # 1) create message if intf_name is None: return
from pox.ethanol.ssl_message.msg_core import msg_default from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION from pox.ethanol.ssl_message.msg_common import send_and_receive_msg, len_of_string from pox.ethanol.events import Events events_bye = Events() """to handle a receiving bye messages, just add your function to events_bye your function must use 'def my_funct(**kwargs)' signature for compatibility @change: we send to parameters: msg, fromaddr """ msg_bye = Struct( 'msg_bye', Embed(msg_default), # default fields SLInt32('tcp_port'), ) def send_msg_bye(server, id=0, tcp_port=None): """ disconnects the ethanol device from the controller @param server: tuple (ip, port_num) @param id: message id @param tcp_port: socket port number of the device @type tcp_port: int """ if (tcp_port is None): return None # error # print "send_msg_bye id:", id # 1) create message
""" return SymmetricMapping( Field(name, 4), # FormatField(name, "<", "l") { True: int32_to_bytes(truth_value), False: int32_to_bytes(false_value) }, default=default, ) msg_default = Struct( 'msg_default', # Probe(), # utilizado para debug SLInt32('m_type'), SLInt32('m_id'), SLInt32('p_version_length'), If(lambda ctx: ctx["p_version_length"] > 0, CString("p_version")), # Probe(), SLInt32('m_size'), ) """ default message structure to be embedded in the first part of every message """ field_intf_name = Struct( 'intf_name', SLInt32('intf_name_size'), If(lambda ctx: ctx["intf_name_size"] > 0, CString("intf_name")),
from construct import SLInt32, CString from construct import Embed from construct import Struct from construct import Container, If # from construct.debug import Probe from pox.ethanol.ssl_message.msg_core import msg_default from pox.ethanol.ssl_message.msg_core import field_mac_addr from pox.ethanol.ssl_message.msg_core import field_intf_name from pox.ethanol.ssl_message.msg_core import field_station from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION from pox.ethanol.ssl_message.msg_common import send_and_receive_msg, len_of_string field_mac_new_ap = Struct('mac_new_ap', SLInt32('mac_new_ap_size'), If(lambda ctx: ctx["mac_new_ap_size"] > 0, CString("mac_new_ap") ), ) """ handles a mac address field for the new ap (a C char * field) """ msg_station_trigger_transition = Struct('msg_station_trigger_transition', Embed(msg_default), # default fields Embed(field_station), Embed(field_mac_addr), # mac_sta Embed(field_intf_name), # intf_name Embed(field_mac_new_ap), # mac_new_ap # Probe() )
from construct import SLInt32 from construct import Embed, Struct, Container from pox.ethanol.ssl_message.msg_core import msg_default from pox.ethanol.ssl_message.msg_core import field_station from pox.ethanol.ssl_message.msg_core import field_intf_name from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION from pox.ethanol.ssl_message.msg_common import send_and_receive_msg, len_of_string msg_mtu_qlen = Struct( 'msg_mtu_qlen', Embed(msg_default), # default fields Embed(field_station), Embed(field_intf_name), SLInt32('value'), ) """ message structure """ def set_msg_mtu_qlen(server, m_type, m_id=0, sta_ip=None, sta_port=0, intf_name=None, value=None): """ sets the MTU or Queue Len values @param server: tuple (ip, port_num) @param id: message id @param sta_ip: ip address of the station that this message should be relayed to, if sta_ip is different from None
BEAT = Struct('ebeats', LFloat32('time'), ULInt16('measure'), ULInt16('beat'), ULInt32('phraseIteration'), ULInt32('mask')) PHRASE = Struct('phrases', SLInt8('solo'), SLInt8('disparity'), SLInt8('ignore'), Padding(1), ULInt32('maxDifficulty'), ULInt32('phraseIterationLinks'), String('name', 32, padchar='\x00')) CHORD_TEMPLATE = Struct('chordTemplates', ULInt32('mask'), SLInt8('fret0'), SLInt8('fret1'), SLInt8('fret2'), SLInt8('fret3'), SLInt8('fret4'), SLInt8('fret5'), SLInt8('finger0'), SLInt8('finger1'), SLInt8('finger2'), SLInt8('finger3'), SLInt8('finger4'), SLInt8('finger5'), Array(6, SLInt32('notes')), String('chordName', 32, padchar='\x00')) BEND_VALUE = Struct( 'bendValues', LFloat32('time'), LFloat32('step'), Padding(3), # Seens values: 0 1 3 31 32 36..49 51..54 56 SLInt8('UNK')) BEND_VALUES_32 = Struct('bendValues32', Array(32, BEND_VALUE), ULInt32('usedCount')) CHORD_NOTE = Struct( 'chordNotes',
m_id=id, p_version_length=len(VERSION), p_version=VERSION, m_size=0, ) send_and_receive_msg(server, msg_struct, msg_tos_cleanall.build, msg_tos_cleanall.parse, only_send=True) msg_tos = Struct( 'msg_tos', Embed(msg_default), # default fields SLInt32('rule_id'), Embed(field_intf_name), SLInt32('proto_size'), If(lambda ctx: ctx["proto_size"] > 0, CString("proto")), SLInt32('sip_size'), If(lambda ctx: ctx["sip_size"] > 0, CString("sip")), SLInt32('sport_size'), If(lambda ctx: ctx["sport_size"] > 0, CString("sport")), SLInt32('dip_size'), If(lambda ctx: ctx["dip_size"] > 0, CString("dip")), SLInt32('dport_size'), If(lambda ctx: ctx["dport_size"] > 0, CString("dport")), SLInt32('wmm_class'), # Probe(), ) """ message to add or replace mange rules """
@requires: construct 2.5.2 """ from construct import SLInt32 from construct import Embed, Struct, Container from pox.ethanol.ssl_message.msg_core import msg_default from pox.ethanol.ssl_message.msg_core import field_intf_name from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION from pox.ethanol.ssl_message.msg_common import send_and_receive_msg, len_of_string msg_beacon_interval = Struct( 'msg_beacon_interval', Embed(msg_default), # default fields Embed(field_intf_name), SLInt32('beacon_interval'), ) ERROR = -1 def get_beacon_interval(server, id=0, intf_name=None): """ get beacon interval in miliseconds for the interface intf_name @param server: tuple (ip, port_num) @param id: message id @param intf_name: name of the wireless interface @type intf_name: str @return: -1 if an error occurs """
def __iter__(self): table_definition = self.tables.get_definition( self.current_table_number) for page_ref in self.pages.list(): if self.pages[page_ref].hierarchy_level == 0: for record in TpsRecordsList(self, self.pages[page_ref], encoding=self.encoding, check=self.check): if record.type == 'DATA' and record.data.table_number == self.current_table_number: check_value('table_record_size', len(record.data.data), table_definition.record_size) # TODO convert name to string fields = {"b':RecNo'": record.data.record_number} for field in table_definition.record_table_definition_field: field_data = record.data.data[field. offset:field.offset + field.size] value = '' if field.type == 'BYTE': value = ULInt8('byte').parse(field_data) elif field.type == 'SHORT': value = SLInt16('short').parse(field_data) elif field.type == 'USHORT': value = ULInt16('ushort').parse(field_data) elif field.type == 'DATE': value = self.to_date(field_data) elif field.type == 'TIME': value = self.to_time(field_data) elif field.type == 'LONG': #TODO if field.name.decode(encoding='cp437').split( ':')[1].lower() in self.date_fieldname: if SLInt32('long').parse(field_data) == 0: value = None else: value = date.fromordinal( 657433 + SLInt32('long').parse(field_data)) elif field.name.decode(encoding='cp437').split( ':')[1].lower() in self.time_fieldname: s, ms = divmod( SLInt32('long').parse(field_data), 100) value = str('{}.{:03d}'.format( time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime(s)), ms)) else: value = SLInt32('long').parse(field_data) elif field.type == 'ULONG': value = ULInt32('ulong').parse(field_data) elif field.type == 'FLOAT': value = LFloat32('float').parse(field_data) elif field.type == 'DOUBLE': value = LFloat64('double').parse(field_data) elif field.type == 'DECIMAL': # TODO BCD if field_data[0] & 0xF0 == 0xF0: sign = -1 field_data = bytearray(field_data) field_data[0] &= 0x0F else: sign = 1 value = sign * int(hexlify( field_data)) / 10**field.decimal_count elif field.type == 'STRING': value = text_type( field_data, encoding=self.encoding).strip() elif field.type == 'CSTRING': value = text_type( field_data, encoding=self.encoding).strip() elif field.type == 'PSTRING': value = text_type( field_data[1:field_data[0] + 1], encoding=self.encoding).strip() else: # GROUP=0x16 # raise ValueError #TODO pass fields[text_type(field.name)] = value # print(fields) yield fields
ssid_info = Struct( 'ssid_info', Embed(field_intf_name), Embed(field_ssid), ULInt32('channel'), ULInt32('frequency'), ) """ information about the configured SSID: wiphy, ESSID, channel, frequency, mode """ msg_ap_ssid = Struct( 'msg_ap_ssid', Embed(msg_default), # default fields Embed(field_station), SLInt32('num_ssids'), Array(lambda ctx: ctx.num_ssids, ssid_info), ) """ message structure """ def get_ap_ssids(server, id=0, sta_ip=None, sta_port=0, intf_names=[]): """ returns the channel and frequency of the ssid for each intf_names @param server: tuple (ip, port_num) @param id: message id @param intf_names: names of the wireless interface @type intf_names: list of 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
""" from construct import SLInt32 from construct import Struct, Embed from construct import Container from pox.ethanol.ssl_message.msg_common import MSG_TYPE, MSG_ERROR_TYPE from pox.ethanol.ssl_message.msg_common import VERSION from pox.ethanol.ssl_message.msg_common import len_of_string from pox.ethanol.ssl_message.msg_core import msg_default, decode_default_fields msg_error = Struct( 'msg_error', Embed(msg_default), # default fields SLInt32( 'error_type' ) # int (32 bits) - little endian --> define the type of error, default UNKNOWN ) def return_error_msg_struct(m_id, error_type=MSG_ERROR_TYPE.ERROR_UNKNOWN): """ return error message as an array of bytes @param id: message id @return: msg - received message """ msg_struct = Container( m_type=MSG_TYPE.MSG_ERR_TYPE, m_id=m_id, p_version_length=len_of_string(VERSION),
@requires: construct 2.5.2 """ from construct import SLInt32, SLInt64, CString, LFloat32 from construct import Embed, If from construct import Struct, Array from construct import Container # from construct.debug import Probe from pox.ethanol.ssl_message.msg_core import msg_default from pox.ethanol.ssl_message.msg_core import field_station, field_intf_name, field_mac_addr from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION from pox.ethanol.ssl_message.msg_common import send_and_receive_msg, len_of_string field_time_stamp = Struct('time_stamp', SLInt32('time_stamp_size'), If(lambda ctx: ctx["time_stamp_size"] > 0, CString("time_stamp")), ) stats_field = Struct('stats', Embed(field_mac_addr), Embed(field_intf_name), SLInt32('inactive_time'), # long SLInt64('rx_bytes'), SLInt64('tx_bytes'), SLInt64('rx_packets'), SLInt64('rx_duration'), SLInt64('tx_packets'), SLInt64('tx_retries'), SLInt64('tx_failed'), SLInt64('beacon_loss'),
from construct import Array from construct import Struct from construct import Container # from construct.debug import Probe from pox.ethanol.ssl_message.msg_core import msg_default from pox.ethanol.ssl_message.msg_core import field_intf_name, field_station from pox.ethanol.ssl_message.msg_common import MSG_TYPE, VERSION from pox.ethanol.ssl_message.msg_common import send_and_receive_msg, len_of_string msg_acs = Struct( 'msg_ap_in_range', Embed(msg_default), # default fields Embed(field_intf_name), Embed(field_station), SLInt32('num_tests'), SLInt32('num_chan'), Array(lambda ctx: ctx.num_chan, SLInt32('freq')), # int Array(lambda ctx: ctx.num_chan, SLInt64('factor')), # long double == LFloat64 ?? # Probe(), ) ACS_SCALE_FACTOR = 1000000000000000000.0 def get_acs(server, id=0, intf_name=None, sta_ip=None, sta_port=0,