def __init__(self, server, ssid, radio, mac_address):
""" constructor:
"""
# if not isinstance(ap, AP):
# raise ValueError("Parameter is must be a AP class")
self.__intf_name = radio.wiphy
log.info("Creating a VAP in %s interface", self.__intf_name)
super(VAP, self).__init__(server, self.__intf_name)
self.__server = server #: saves the reference to server of ap
self.__mac_address = mac_address #: virtual ap's mac address
self.__radio = radio #: physical radio to which the vap is attached
log.debug("Registering_functions: %s", self.__mac_address)
# register the association process for this ap
register_functions(self.__mac_address, self)
""" list of stations connected to this vap """
self.__list_of_stations = []
self.__ssid = ssid #: setting ssid will configure VAP
self.__enabled = False
self.__mgmtFrame = dict() # keep a list of listeners for each type of mgmt frame received
log.info("Created VAP with id:%s in interface %s", self.id, self.__intf_name)
def add_station(client_address):
'''
Create (and return) possibly several objects,
one for each wireless connections identified by (client_address,
interface name).
This function updates a list of these objects.
client_address = (ip, port) used by the Hello message's process
'''
ip = client_address[0]
if ip not in list_of_stations:
log.info("Starting Station object with IP %s", ip)
msg, intfs = get_interfaces(server=client_address, m_id=0)
''' select only wireless interfaces '''
intfs = [intf.intf_name for intf in intfs if intf.is_wifi is True]
log.info("Found %d wireless interface in the device: %s", len(intfs),
",".join(intfs))
if len(intfs) > 0:
list_of_stations[ip] = {}
for intf_name in intfs:
log.info("Station interface: %s", intf_name)
station = Station(socket=client_address, intf_name=intf_name)
list_of_stations[ip][intf_name] = station
else:
log.debug("Station with IP %s exists", ip)
def add_ap(client_address):
"""
Create (and return) an AP object for the the device represented
by the tuple client_address.
This function updates a list of these objects.
used by the Hello message's process
@param client_address: tuple with (ip, port) used to make a socket
connection to the AP
@type client_address: tuple or list
"""
ip = client_address[0]
port = client_address[1]
if not(ip in __list_of_aps):
# create a new ap
# comentado porque nao tem todas as funcoes do AP
__list_of_aps[ip] = AP(ip, port)
log.info("Adding AP with IP %s to the list of connected aps (size %d)"
% (ip, len(__list_of_aps)))
else:
log.debug('AP %s exists' % ip)
pass
def _802_11b_Preamble(self):
""" connect to ap requesting which type of preamble is set"""
server = self.__get_connection()
msg, value = get_preamble(server,
id=self.msg_id,
intf_name=self.__wiphy_name)
log.debug("preamble message received with value %d", value)
return value
def cpu(self):
""" physical device's CPU usage """
if self.__intf_name is None:
return -1
server = self.get_connection
msg, value = get_cpu_usage(server, id=self.msg_id)
log.debug('CPU device %f', value)
return value
def memory(self):
""" physical device's memory usage """
if self.__intf_name is None:
return -1
server = self.get_connection
msg, value = get_memory_usage(server, id=self.msg_id)
log.debug('Memory device %f', value)
return value
def beaconInterval(self):
"""connect to ap requesting beacon interval value"""
server = self.__get_connection()
msg, value = get_beacon_interval(server,
id=self.msg_id,
intf_name=self.__wiphy_name)
log.debug("beacon interval: %d", value)
return value
def __linkando(self):
self.__vap = get_vap_by_mac_address(self.__mac_address)
if self.__vap is None:
self.__radio = None
log.debug("VAP <<nao encontrada>> na criacao da Station")
else:
self.__radio = self.__vap.radio
self.__vap.register_station(station=self)
log.debug("VAP <<encontrada>> na criacao da Station")
def _handle_ConnectionUp(self, event):
""" when a connection is up, inserts this openflow device in a mapping list
if this devices sends an Ethanol Hello then we know that it has openflow and ethanol capabilities
"""
log.debug("Connection %s" % (event.connection, ))
# registra um novo AP
sock = event.connection.sock
ip, port = sock.getpeername()
add_ap_openflow(ip)
def _802_11b_Preamble(self, value):
"""
set new preamble, returns nothing
"""
server = self.__get_connection()
set_preamble(server,
id=self.msg_id,
intf_name=self.__wiphy_name,
preamble=value)
log.debug("preamble set to %d", value)
def packetsLost(self):
""" number of packets lost on this interface (cumulative value) """
if self.__intf_name is None:
return -1
server = self.get_connection
msg, value = send_msg_get_packetslost(server,
id=self.msg_id,
intf_name=self.__intf_name)
log.debug('packetsLost device %f', value)
return value
def txpower(self, new_value):
"""set current tx power"""
if self.__intf_name is None:
return -1
server = self.get_connection
set_txpower(server,
id=self.msg_id,
intf_name=self.__intf_name,
txpower=new_value)
log.debug('set TXPower device to %f', new_value)
def txpower(self):
""" retrieve the TX power """
if self.__intf_name is None:
return -1
server = self.get_connection
msg, value = get_txpower(server,
id=self.msg_id,
intf_name=self.__intf_name)
log.debug('get TXPower device %f', value)
return value
def SNR(self):
""" retrieve current SNR """
if self.__intf_name is None:
return -1
server = self.get_connection
msg, value = get_snr(server,
id=self.msg_id,
intf_name=self.__intf_name)
log.debug('SNR %f', value)
return value
def getACS(self, num_tests=1):
""" request that the AP computes the ACS factor for each frequency
in the intf_name interface
"""
server = self.__get_connection()
msg, num_chan, acs = get_acs(server,
id=self.msg_id,
intf_name=self.__wiphy_name,
num_tests=num_tests)
log.debug("ACS message received with %d channels", num_chan)
return num_chan, acs
def beaconInterval(self, value=100):
""" connect to AP to set beacon interval value
returns nothing
"""
server = self.__get_connection()
set_beacon_interval(server,
value,
id=self.msg_id,
intf_name=self.__wiphy_name,
beacon_interval=value)
log.debug("beacon interval set to %s", value)
def currentChannel(self, new_channel):
"""
tries to set the ap channel.
@note: to confim that the channel was changed, issue currentChannel()
"""
server = self.__get_connection() # allows to send message to the AP
set_currentchannel(server,
id=self.msg_id,
channel=new_channel,
intf_name=self.__wiphy_name)
log.debug("canal: %d interface: %s tcp: %s:%d", new_channel,
self.__wiphy_name, server[0], server[1])
def getAPsInRange(self):
"""get aps that are in range.
@note: this method is not precise, because it relies on the spare
time the device has to scan all the channels
"""
if self.__intf_name is None:
return -1, None
server = self.get_connection
msg, num_aps, aps = get_ap_in_range(server,
id=self.msg_id,
intf_name=self.__intf_name)
log.debug('get ap_in_range device %d, %f', num_aps, aps)
return num_aps, aps
def __init__(self, socket, intf_name):
""" creates a device object (used by VAP and STATION)
@param socket: tuple (ip, port_num)
@param intf_name: name of the wireless interface that this device uses
"""
log.debug("starting DEVICE constructor")
self.__id = uuid.uuid4() # UUID
self.__socket = socket
# socket (ip, port) that will be used to connect to this station
self.__ip, self.__port = socket
self.__intf_name = intf_name
self.__mac_address = None
self.__msg_id = 0
log.debug("DEVICE id:%s created", self.__id)
def process_hello(received_msg, fromaddr):
"""returns the message to the ssl server process
@param received_msg:
@param fromaddr: ip address of the device that sent this message
@func_hello: event
"""
msg = msg_hello.parse(received_msg)
client_port = msg['tcp_port']
client_socket = (fromaddr[0], client_port)
log.debug("Hello msg received.")
if msg['device_type'] == 1:
# create ap object
log.debug("\tConnect to AP @ %s:%d" % client_socket)
ap = add_ap(client_socket) # returns ap
log.debug("AP %s" % ap)
elif msg['device_type'] == 2:
log.info("Connect to STA @ %s:%d" % client_socket)
station = add_station(client_socket)
log.debug("Station %s" % station)
events_hello.on_change(msg=msg, fromaddr=fromaddr) # call all registered functions
# only send back the same message
return received_msg
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
# 1) create message
msg_struct = Container(m_type=MSG_TYPE.MSG_HELLO_TYPE,
m_id=m_id,
p_version_length=len_of_string(VERSION),
p_version=VERSION,
m_size=0,
device_type=0,
tcp_port=SERVER_PORT,
rtt=0
)
msg = msg_hello.build(msg_struct)
# print "hello enviado para servidor > ", hexadecimal(msg)
# 2) sending message
t0 = datetime.now()
log.debug(hexadecimal(msg))
num_bytes = ssl_sock.write(msg)
log.debug("num bytes enviados: %d" % num_bytes)
# 3) retrieve server's response
received_msg = ssl_sock.read(BUFFER_SIZE)
if received_msg != '':
t1 = datetime.now()
# print "msg recebida > ", hexadecimal(received_msg)
if is_error_msg(received_msg):
msg = get_error_msg(received_msg)
else:
# print "msg recebida > ", hexadecimal(received_msg)
msg = msg_hello.parse(received_msg)
msg.rtt = t1 - t0
else:
msg = None
ssl_sock.close()
sckt.close()
return msg
def __init__(self, ssid):
"""
create a network with ESSID = ssid
"""
for i in list_of_networks():
if i[0] == ssid:
raise ValueError("SSID %s already exists!" % self.__SSID)
if ssid in list_of_networks():
log.debug('ssid %s already exists in ')
self.__id = uuid4() # random UUID
self.__SSID = ssid
self.__listVAP = []
self.__msg_id = 0 # message id used to identify the msg to the device
log.info('SSID: %s', self.__SSID)
add_network(self.__SSID, self)
log.info('constructor Network %s ended', self.__SSID)
def process_hello(received_msg, fromaddr):
"""returns the message to the ssl server process
@param received_msg:
@param fromaddr: ip address of the device that sent this message
@func_hello: event
"""
msg = msg_hello.parse(received_msg)
client_port = msg['tcp_port']
client_socket = (fromaddr[0], client_port)
events_hello.on_change(msg=msg,
fromaddr=fromaddr) # call all registered functions
if msg['device_type'] == 1:
# Creates and returns ap object if it doesn't already exist
ap = add_ap(client_socket)
if ap is not None:
log.debug("\tConnected to AP @ %s:%d" % client_socket)
log.debug("List of connected APs: %s", connected_aps().keys())
elif msg['device_type'] == 2:
log.info("Connect to STA @ %s:%d" % client_socket)
station = add_station(client_socket)
log.debug("Station %s" % station)
# only send back the same message
return received_msg
def __init__(self, ssid):
"""
create a network with ESSID = ssid
add the ssid to the list __list_of_networks, if does not exist
if exists triggers an error
"""
if ssid in list_of_networks():
# don't allow to create two networks with the same SSID
log.debug('ssid %s already exists', ssid)
raise ValueError("SSID %s already exists!" % ssid)
else:
# create the network
self.__id = uuid4() # random UUID
# set the name of the SSID
self.__SSID = ssid
self.__listVAP = []
self.__msg_id = 0 # message id used to identify the msg to the device
# if the Netword does not exists, insert it in the list
add_network(ssid, self)
log.info('SSID: %s', self.__SSID)
log.info('Constructor Network %s ended', self.__SSID)
def bogus_hello_on_change(**kwargs):
log.debug("hello message received: %s" % kwargs['fromaddr'][0] if 'fromaddr' in kwargs else "")
def __init__(self, ip, port=SERVER_PORT):
"""
constructor
@param ip: socket IP address to connect to the physical AP
@param port: socket port to connect to the physical AP
"""
# import placed here to avoid 'import loop'
from pox.ethanol.ethanol.radio import Radio
from pox.ethanol.ethanol.network import Network
from pox.ethanol.ethanol.network import add_network, get_or_create_network_by_ssid
self.__id = uuid.uuid4() #
# client_address tuple
self.__ip = ip
self.__port = port
self.__msg_id = 0
self.__radios = {}
self.__listVAP = []
server = self.__get_connection()
self.___wiphys = set()
map_openflow_vs_ethanol_ip[ip] = self
self.__stats_msec = -1 # disabled
self.__stats_alpha = 0.1
""" retrieve and create radios (represented by the physical
wifi interfaces)
"""
msg, wlans = get_radio_wlans(server)
intf_x_mac = {}
log.info('wireless interfaces: [%s]' % ",".join([
_w['intf_name']
for _w in wlans if _w is not None and _w.intf_name is not None
]))
if wlans is not None:
# identify distinct set of phy interfaces
for wlan in wlans:
wiphy_idx = wlan.wiphy
wiphy_name = wlan.intf_name
intf_x_mac[wlan.intf_name] = wlan.mac_addr
self.___wiphys.add(wiphy_name)
# create radio objects belonging to this AP
radio = Radio(self, wiphy_name, ip, port)
self.__radios[wiphy_name] = radio
msg, list_ssids = get_ap_ssids(server)
if list_ssids is not None and len(list_ssids) > 0:
# TODO: tratar quando o ssid vem nulo
log.info("SSIDs in Radio: %s" % ",".join([
_ssid['ssid'] for _ssid in list_ssids
if _ssid is not None and _ssid.ssid is not None
]))
for ssid in list_ssids:
if ssid is None or ssid.ssid is None:
log.info("Detected a invalid SSID!!!")
else:
try:
net = Network(
ssid.ssid
) # create the object. This init also inserts the ssid to a control list
log.info('[%s] added to network (SSID) list',
ssid.ssid)
except ValueError:
# exception if network exists
log.debug('Network SSID %s already exists', ssid.ssid)
net = get_or_create_network_by_ssid(
ssid.ssid) # retrieve the network
log.info('Creating and association the VAP objects')
#
# retrieve configured vaps
# and create vap objects
#
for i in range(len(list_ssids)):
intf_name = list_ssids[i]['intf_name']
ssid = list_ssids[i]['ssid']
if intf_name in self.__radios:
# if there is no such ssid in list_of_networks
# (network.py) add it
vap = \
self.createvirtualap_and_insert_listvap(ssid,
self.__radios[intf_name],
intf_x_mac[intf_name])
log.info("Num# of VAPs: %d" % len(self.__listVAP))
else:
log.debug("AP returned no SSIDs")
log.info('New AP created - id: %s', self.id)
