Kernel/iwd
3
0
Fork 0
mirror of https://git.kernel.org/pub/scm/network/wireless/iwd.git synced 2024-12-23 06:02:37 +01:00
Code Releases Activity
17c569ba4c
iwd/autotests/util/hostapd.py

230 lines
6.7 KiB
Python
Raw Normal View History

auto-t: Create hostapd_cli py lib
2016-10-05 01:44:27 +02:00
#!/usr/bin/python3
autotests: Support multiple hostapd instances in HostapdCLI Make the HostapdCLI class non-static so that each objects corresponds to a hostapd instance on one network interface (this is independent of whether the AP instances use one or separate hostapd processes)
2017-03-26 03:16:53 +02:00
import os, os.path
autotests: Update the wiphy_map and hostapd_map structs In the test utilties updated the wiphy_map struct built from the TEST_WIPHY_LIST variable to parse the new format and to use a new structure where each wiphy is a namedtuple and each interface under it also contains a reference to that wiphy. The 'use' field is now assigned to the wiphy instead of to the interface.
2019-04-20 22:29:01 +02:00
from wiphy import wiphy_map
auto-t: hostapd util get_config_value and get_freq The hwsim SendFrame method requires the radio frequency which is obtained from the hostapd config file. This adds a generic API to get any config value from the hostapd config, as well as a get_freq API that converts the channel number to a frequency.
2018-01-30 20:19:49 +01:00
import re
auto-t: add eapol reauth cmd into hostapd mngr
2018-05-31 01:39:05 +02:00
import socket
auto-t: support hostapd event processing Hostapd has a feature where you can connect to its control socket and receive events it generates. Currently we only send commands via this socket. First we open the socket (/var/run/hostapd/<iface>) and send the ATTACH command. This tells hostapd we are ready and after this any events will be sent over this socket. A new API, wait_for_event, was added which takes an event string and waits for some timeout. The glib event loop has been integrated into this, though its not technically async since we are selecting over a socket which blocks. To mitigate this a small timeout was chosen for each select call and then wrapped in a while loop which waits for the full timeout.
2019-10-29 18:50:39 +01:00
import select
import time
from gi.repository import GLib
auto-t: hostapd util get_config_value and get_freq The hwsim SendFrame method requires the radio frequency which is obtained from the hostapd config file. This adds a generic API to get any config value from the hostapd config, as well as a get_freq API that converts the channel number to a frequency.
2018-01-30 20:19:49 +01:00
chan_freq_map = [
None,
2412,
2417,
2422,
2427,
2432,
2437,
2442,
2447,
2452,
2457,
2462,
2467,
2472,
2484
]
autotests: Support multiple hostapd instances in HostapdCLI Make the HostapdCLI class non-static so that each objects corresponds to a hostapd instance on one network interface (this is independent of whether the AP instances use one or separate hostapd processes)
2017-03-26 03:16:53 +02:00
auto-t: support hostapd event processing Hostapd has a feature where you can connect to its control socket and receive events it generates. Currently we only send commands via this socket. First we open the socket (/var/run/hostapd/<iface>) and send the ATTACH command. This tells hostapd we are ready and after this any events will be sent over this socket. A new API, wait_for_event, was added which takes an event string and waits for some timeout. The glib event loop has been integrated into this, though its not technically async since we are selecting over a socket which blocks. To mitigate this a small timeout was chosen for each select call and then wrapped in a while loop which waits for the full timeout.
2019-10-29 18:50:39 +01:00
ctrl_count = 0
mainloop = GLib.MainLoop()
autotests: Update the wiphy_map and hostapd_map structs In the test utilties updated the wiphy_map struct built from the TEST_WIPHY_LIST variable to parse the new format and to use a new structure where each wiphy is a namedtuple and each interface under it also contains a reference to that wiphy. The 'use' field is now assigned to the wiphy instead of to the interface.
2019-04-20 22:29:01 +02:00
hostapd_map = {ifname: intf for wname, wiphy in wiphy_map.items()
for ifname, intf in wiphy.interface_map.items()
if wiphy.use == 'hostapd'}
auto-t: Create hostapd_cli py lib
2016-10-05 01:44:27 +02:00
class HostapdCLI:
auto-t: fix hostapd.ungraceful_restart Restarting hostapd from python was actually leaking memory and causing the hostapd object to stay referenced in python. The GLib timeout in wait_for_event was the ultimate cause, but this had no come to light because no tests restarted hostapd then used wait_for_event. In addition, any use of wait_for_event after a restart would cause an exception because the event socket was never re-attached after hostapd restarted. Now we properly clean up the timeout in wait_for_event and re-initialize the hostapd object on restart.
2020-07-14 20:49:07 +02:00
def _init_hostapd(self, interface=None, config=None):
auto-t: support hostapd event processing Hostapd has a feature where you can connect to its control socket and receive events it generates. Currently we only send commands via this socket. First we open the socket (/var/run/hostapd/<iface>) and send the ATTACH command. This tells hostapd we are ready and after this any events will be sent over this socket. A new API, wait_for_event, was added which takes an event string and waits for some timeout. The glib event loop has been integrated into this, though its not technically async since we are selecting over a socket which blocks. To mitigate this a small timeout was chosen for each select call and then wrapped in a while loop which waits for the full timeout.
2019-10-29 18:50:39 +01:00
global ctrl_count
auto-t: hostapd: allow CLI to lookup by config file There is a common interface lookup in many tests in order to initialize the HostapdCLI object e.g.: for intf in hostapd_map.values(): if intf.config == 'ssidOWE.conf': hapd = HostapdCLI(intf) break Instead of having to do this in every test, HostapdCLI will now optionally take a config file (config=<file>). The interface object will still be prefered (i.e. supplying an interface will not even check the config file) as to not break existing tests. But if only a config file is supplied the lookup is done internally. There are some tests that do still need the interface, as they do an interface lookup to initialize both hostapd and hwsim at the same time.
2019-06-05 23:02:25 +02:00
if not interface and not config:
raise Exception('interface or config must be provided')
if not interface:
for intf in hostapd_map.values():
if intf.config == config:
interface = intf
break
auto-t: hostapd: raise exception upon invalid config If the config file passed in is not found we would continue and eventually something else would fail. Instead immediately raise an exception to be more clear on what is actually failing.
2019-10-22 18:14:00 +02:00
if not interface:
raise Exception('config %s not found' % config)
autotests: Support multiple hostapd instances in HostapdCLI Make the HostapdCLI class non-static so that each objects corresponds to a hostapd instance on one network interface (this is independent of whether the AP instances use one or separate hostapd processes)
2017-03-26 03:16:53 +02:00
self.ifname = interface.name
autotests: Remove unneded loops The hostapd_map dictionary is indexed by the interface name so there's no point iterating over it to find that entry whose name matches, we can look up by the name directly. Simplify code.
2019-04-20 22:29:02 +02:00
self.socket_path = os.path.dirname(interface.ctrl_interface)
auto-t: Add functions to hostapd_cli
2016-10-06 20:06:14 +02:00
auto-t: add eapol reauth cmd into hostapd mngr
2018-05-31 01:39:05 +02:00
self.cmdline = 'hostapd_cli -p"' + self.socket_path + '" -i"' + \
autotests: Support multiple hostapd instances in HostapdCLI Make the HostapdCLI class non-static so that each objects corresponds to a hostapd instance on one network interface (this is independent of whether the AP instances use one or separate hostapd processes)
2017-03-26 03:16:53 +02:00
self.ifname + '"'
auto-t: fix hostapd.ungraceful_restart Restarting hostapd from python was actually leaking memory and causing the hostapd object to stay referenced in python. The GLib timeout in wait_for_event was the ultimate cause, but this had no come to light because no tests restarted hostapd then used wait_for_event. In addition, any use of wait_for_event after a restart would cause an exception because the event socket was never re-attached after hostapd restarted. Now we properly clean up the timeout in wait_for_event and re-initialize the hostapd object on restart.
2020-07-14 20:49:07 +02:00
if not hasattr(self, '_hostapd_restarted'):
self._hostapd_restarted = False
auto-t: add ungraceful restart to hostapd util For testing SA Query, the autotest needs the ablility to force kill (and restart) hostapd without giving it time to deauth its stations gracefully. A method was added to the HostapdCLI class which does a killall -9 hostapd, resets the wlnX interface, and restarts hostapd with the same arguments as it had before.
2018-01-29 19:37:05 +01:00
auto-t: support hostapd event processing Hostapd has a feature where you can connect to its control socket and receive events it generates. Currently we only send commands via this socket. First we open the socket (/var/run/hostapd/<iface>) and send the ATTACH command. This tells hostapd we are ready and after this any events will be sent over this socket. A new API, wait_for_event, was added which takes an event string and waits for some timeout. The glib event loop has been integrated into this, though its not technically async since we are selecting over a socket which blocks. To mitigate this a small timeout was chosen for each select call and then wrapped in a while loop which waits for the full timeout.
2019-10-29 18:50:39 +01:00
self.local_ctrl = '/tmp/hostapd_' + str(os.getpid()) + '_' + \
str(ctrl_count)
self.ctrl_sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
self.ctrl_sock.bind(self.local_ctrl)
self.ctrl_sock.connect(self.socket_path + '/' + self.ifname)
if 'OK' not in self._ctrl_request('ATTACH'):
raise Exception('ATTACH failed')
ctrl_count = ctrl_count + 1
auto-t: fix hostapd.ungraceful_restart Restarting hostapd from python was actually leaking memory and causing the hostapd object to stay referenced in python. The GLib timeout in wait_for_event was the ultimate cause, but this had no come to light because no tests restarted hostapd then used wait_for_event. In addition, any use of wait_for_event after a restart would cause an exception because the event socket was never re-attached after hostapd restarted. Now we properly clean up the timeout in wait_for_event and re-initialize the hostapd object on restart.
2020-07-14 20:49:07 +02:00
def __init__(self, interface=None, config=None):
self._init_hostapd(interface, config)
auto-t: support hostapd event processing Hostapd has a feature where you can connect to its control socket and receive events it generates. Currently we only send commands via this socket. First we open the socket (/var/run/hostapd/<iface>) and send the ATTACH command. This tells hostapd we are ready and after this any events will be sent over this socket. A new API, wait_for_event, was added which takes an event string and waits for some timeout. The glib event loop has been integrated into this, though its not technically async since we are selecting over a socket which blocks. To mitigate this a small timeout was chosen for each select call and then wrapped in a while loop which waits for the full timeout.
2019-10-29 18:50:39 +01:00
def wait_for_event(self, event, timeout=10):
global mainloop
self._wait_timed_out = False
def wait_timeout_cb():
self._wait_timed_out = True
return False
timeout = GLib.timeout_add_seconds(timeout, wait_timeout_cb)
context = mainloop.get_context()
while True:
context.iteration(may_block=False)
while self._data_available(0.25):
data = self.ctrl_sock.recv(4096).decode('utf-8')
if event in data:
auto-t: fix hostapd.ungraceful_restart Restarting hostapd from python was actually leaking memory and causing the hostapd object to stay referenced in python. The GLib timeout in wait_for_event was the ultimate cause, but this had no come to light because no tests restarted hostapd then used wait_for_event. In addition, any use of wait_for_event after a restart would cause an exception because the event socket was never re-attached after hostapd restarted. Now we properly clean up the timeout in wait_for_event and re-initialize the hostapd object on restart.
2020-07-14 20:49:07 +02:00
GLib.source_remove(timeout)
auto-t: support hostapd event processing Hostapd has a feature where you can connect to its control socket and receive events it generates. Currently we only send commands via this socket. First we open the socket (/var/run/hostapd/<iface>) and send the ATTACH command. This tells hostapd we are ready and after this any events will be sent over this socket. A new API, wait_for_event, was added which takes an event string and waits for some timeout. The glib event loop has been integrated into this, though its not technically async since we are selecting over a socket which blocks. To mitigate this a small timeout was chosen for each select call and then wrapped in a while loop which waits for the full timeout.
2019-10-29 18:50:39 +01:00
return data
if self._wait_timed_out:
raise TimeoutError('waiting for hostapd event timed out')
return None
def _data_available(self, timeout=2):
[r, w, e] = select.select([self.ctrl_sock], [], [], timeout)
if r:
return True
return False
def _ctrl_request(self, command, timeout=10):
if type(command) is str:
command = str.encode(command)
self.ctrl_sock.send(bytes(command))
if self._data_available(timeout):
return self.ctrl_sock.recv(4096).decode('utf-8')
raise Exception('timeout waiting for control response')
auto-t: fix hostapd.ungraceful_restart Restarting hostapd from python was actually leaking memory and causing the hostapd object to stay referenced in python. The GLib timeout in wait_for_event was the ultimate cause, but this had no come to light because no tests restarted hostapd then used wait_for_event. In addition, any use of wait_for_event after a restart would cause an exception because the event socket was never re-attached after hostapd restarted. Now we properly clean up the timeout in wait_for_event and re-initialize the hostapd object on restart.
2020-07-14 20:49:07 +02:00
def _del_hostapd(self, force=False):
self.ctrl_sock.close()
auto-t: add ungraceful restart to hostapd util For testing SA Query, the autotest needs the ablility to force kill (and restart) hostapd without giving it time to deauth its stations gracefully. A method was added to the HostapdCLI class which does a killall -9 hostapd, resets the wlnX interface, and restarts hostapd with the same arguments as it had before.
2018-01-29 19:37:05 +01:00
if self._hostapd_restarted:
auto-t: fix hostapd.ungraceful_restart Restarting hostapd from python was actually leaking memory and causing the hostapd object to stay referenced in python. The GLib timeout in wait_for_event was the ultimate cause, but this had no come to light because no tests restarted hostapd then used wait_for_event. In addition, any use of wait_for_event after a restart would cause an exception because the event socket was never re-attached after hostapd restarted. Now we properly clean up the timeout in wait_for_event and re-initialize the hostapd object on restart.
2020-07-14 20:49:07 +02:00
if force:
os.system('killall -9 hostapd')
else:
os.system('killall hostapd')
auto-t: add ungraceful restart to hostapd util For testing SA Query, the autotest needs the ablility to force kill (and restart) hostapd without giving it time to deauth its stations gracefully. A method was added to the HostapdCLI class which does a killall -9 hostapd, resets the wlnX interface, and restarts hostapd with the same arguments as it had before.
2018-01-29 19:37:05 +01:00
auto-t: fix hostapd.ungraceful_restart Restarting hostapd from python was actually leaking memory and causing the hostapd object to stay referenced in python. The GLib timeout in wait_for_event was the ultimate cause, but this had no come to light because no tests restarted hostapd then used wait_for_event. In addition, any use of wait_for_event after a restart would cause an exception because the event socket was never re-attached after hostapd restarted. Now we properly clean up the timeout in wait_for_event and re-initialize the hostapd object on restart.
2020-07-14 20:49:07 +02:00
os.system('ifconfig %s down' % self.ifname)
os.system('ifconfig %s up' % self.ifname)
def __del__(self):
self._del_hostapd()
auto-t: support hostapd event processing Hostapd has a feature where you can connect to its control socket and receive events it generates. Currently we only send commands via this socket. First we open the socket (/var/run/hostapd/<iface>) and send the ATTACH command. This tells hostapd we are ready and after this any events will be sent over this socket. A new API, wait_for_event, was added which takes an event string and waits for some timeout. The glib event loop has been integrated into this, though its not technically async since we are selecting over a socket which blocks. To mitigate this a small timeout was chosen for each select call and then wrapped in a while loop which waits for the full timeout.
2019-10-29 18:50:39 +01:00
autotests: Support multiple hostapd instances in HostapdCLI Make the HostapdCLI class non-static so that each objects corresponds to a hostapd instance on one network interface (this is independent of whether the AP instances use one or separate hostapd processes)
2017-03-26 03:16:53 +02:00
def wps_push_button(self):
os.system(self.cmdline + ' wps_pbc')
auto-t: Add additional utilities for WPS PIN support
2018-09-24 19:02:34 +02:00
def wps_pin(self, pin):
os.system(self.cmdline + ' wps_pin any ' + pin)
autotests: Support multiple hostapd instances in HostapdCLI Make the HostapdCLI class non-static so that each objects corresponds to a hostapd instance on one network interface (this is independent of whether the AP instances use one or separate hostapd processes)
2017-03-26 03:16:53 +02:00
def deauthenticate(self, client_address):
os.system(self.cmdline + ' deauthenticate ' + client_address)
auto-t: Add functions to hostapd_cli
2016-10-06 20:06:14 +02:00
auto-t: add eapol reauth cmd into hostapd mngr
2018-05-31 01:39:05 +02:00
def eapol_reauth(self, client_address):
cmd = 'IFNAME=' + self.ifname + ' EAPOL_REAUTH ' + client_address
s = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
s.connect(self.socket_path + '/' + self.ifname)
s.sendall(cmd.encode('utf-8'))
s.close()
autotests: Add FT roaming test and utility functions This tests the FT-PSK initial Mobility Domain authentication, neighbor reports, scanning on a subset of frequencies and FT transition.
2017-03-26 03:16:57 +02:00
def reload(self):
# Seemingly all three commands needed for the instance to notice
# interface's address change
cmds = 'reload\ndisable\nenable\n'
proc = os.popen(self.cmdline, mode='w')
lines = proc.write(cmds)
proc.close()
def list_sta(self):
proc = os.popen(self.cmdline + ' list_sta')
lines = proc.read()
proc.close()
return [line for line in lines.split('\n') if line]
def set_neighbor(self, addr, ssid, nr):
os.system(self.cmdline + ' set_neighbor ' + addr + ' ssid=\\""' + ssid +
'"\\" nr=' + nr)
autotests: add AP roam support to hostapd.py
2018-01-18 22:36:39 +01:00
def send_bss_transition(self, device, nr_list):
# Send a BSS transition to a station (device). nr_list should be an
# array of tuples containing the BSS address and neighbor report.
# Parsing the neighbor report is a bit ugly but it makes it more
# consistent with the set_neighbor() API, i.e. the same neighbor report
# string could be used in both API's.
pref = 1
cmd = self.cmdline + ' bss_tm_req ' + device
for i in nr_list:
addr = i[0]
nr = i[1]
bss_info=str(int(nr[0:8], 16))
op_class=str(int(nr[8:10], 16))
chan_num=nr[10:12]
phy_num=nr[14:16]
cmd += ' pref=%s neighbor=%s,%s,%s,%s,%s' % \
(str(pref), addr, bss_info, op_class, chan_num, phy_num)
pref += 1
os.system(cmd)
auto-t: Add functions to hostapd_cli
2016-10-06 20:06:14 +02:00
@staticmethod
def kill_all():
os.system('killall hostapd')
auto-t: add ungraceful restart to hostapd util For testing SA Query, the autotest needs the ablility to force kill (and restart) hostapd without giving it time to deauth its stations gracefully. A method was added to the HostapdCLI class which does a killall -9 hostapd, resets the wlnX interface, and restarts hostapd with the same arguments as it had before.
2018-01-29 19:37:05 +01:00
auto-t: hostapd util get_config_value and get_freq The hwsim SendFrame method requires the radio frequency which is obtained from the hostapd config file. This adds a generic API to get any config value from the hostapd config, as well as a get_freq API that converts the channel number to a frequency.
2018-01-30 20:19:49 +01:00
def get_config_value(self, key):
# first find the right config file
autotests: Remove unneded loops The hostapd_map dictionary is indexed by the interface name so there's no point iterating over it to find that entry whose name matches, we can look up by the name directly. Simplify code.
2019-04-20 22:29:02 +02:00
with open(hostapd_map[self.ifname].config, 'r') as f:
# read in config file and search for key
cfg = f.read()
match = re.search(r'%s=.*' % key, cfg)
if match:
return match.group(0).split('=')[1]
auto-t: hostapd util get_config_value and get_freq The hwsim SendFrame method requires the radio frequency which is obtained from the hostapd config file. This adds a generic API to get any config value from the hostapd config, as well as a get_freq API that converts the channel number to a frequency.
2018-01-30 20:19:49 +01:00
return None
def get_freq(self):
return chan_freq_map[int(self.get_config_value('channel'))]
auto-t: add ungraceful restart to hostapd util For testing SA Query, the autotest needs the ablility to force kill (and restart) hostapd without giving it time to deauth its stations gracefully. A method was added to the HostapdCLI class which does a killall -9 hostapd, resets the wlnX interface, and restarts hostapd with the same arguments as it had before.
2018-01-29 19:37:05 +01:00
def ungraceful_restart(self):
'''
Ungracefully kill and restart hostapd
'''
auto-t: fix hostapd.ungraceful_restart Restarting hostapd from python was actually leaking memory and causing the hostapd object to stay referenced in python. The GLib timeout in wait_for_event was the ultimate cause, but this had no come to light because no tests restarted hostapd then used wait_for_event. In addition, any use of wait_for_event after a restart would cause an exception because the event socket was never re-attached after hostapd restarted. Now we properly clean up the timeout in wait_for_event and re-initialize the hostapd object on restart.
2020-07-14 20:49:07 +02:00
# set flag so hostapd can be killed after the test
self._hostapd_restarted = True
autotests: Remove unneded loops The hostapd_map dictionary is indexed by the interface name so there's no point iterating over it to find that entry whose name matches, we can look up by the name directly. Simplify code.
2019-04-20 22:29:02 +02:00
intf = hostapd_map[self.ifname]
auto-t: fix hostapd.ungraceful_restart Restarting hostapd from python was actually leaking memory and causing the hostapd object to stay referenced in python. The GLib timeout in wait_for_event was the ultimate cause, but this had no come to light because no tests restarted hostapd then used wait_for_event. In addition, any use of wait_for_event after a restart would cause an exception because the event socket was never re-attached after hostapd restarted. Now we properly clean up the timeout in wait_for_event and re-initialize the hostapd object on restart.
2020-07-14 20:49:07 +02:00
self._del_hostapd(force=True)
autotests: Remove unneded loops The hostapd_map dictionary is indexed by the interface name so there's no point iterating over it to find that entry whose name matches, we can look up by the name directly. Simplify code.
2019-04-20 22:29:02 +02:00
os.system('hostapd -g %s -i %s %s &' %
(intf.ctrl_interface, intf.name, intf.config))
auto-t: add ungraceful restart to hostapd util For testing SA Query, the autotest needs the ablility to force kill (and restart) hostapd without giving it time to deauth its stations gracefully. A method was added to the HostapdCLI class which does a killall -9 hostapd, resets the wlnX interface, and restarts hostapd with the same arguments as it had before.
2018-01-29 19:37:05 +01:00
auto-t: fix hostapd.ungraceful_restart Restarting hostapd from python was actually leaking memory and causing the hostapd object to stay referenced in python. The GLib timeout in wait_for_event was the ultimate cause, but this had no come to light because no tests restarted hostapd then used wait_for_event. In addition, any use of wait_for_event after a restart would cause an exception because the event socket was never re-attached after hostapd restarted. Now we properly clean up the timeout in wait_for_event and re-initialize the hostapd object on restart.
2020-07-14 20:49:07 +02:00
# Give hostapd a second to start and initialize the control interface
time.sleep(1)
# New hostapd process, so re-init
self._init_hostapd(intf)
auto-t: support hostapd event processing Hostapd has a feature where you can connect to its control socket and receive events it generates. Currently we only send commands via this socket. First we open the socket (/var/run/hostapd/<iface>) and send the ATTACH command. This tells hostapd we are ready and after this any events will be sent over this socket. A new API, wait_for_event, was added which takes an event string and waits for some timeout. The glib event loop has been integrated into this, though its not technically async since we are selecting over a socket which blocks. To mitigate this a small timeout was chosen for each select call and then wrapped in a while loop which waits for the full timeout.
2019-10-29 18:50:39 +01:00
def req_beacon(self, addr, request):
'''
Send a RRM Beacon request
'''
os.system(self.cmdline + ' req_beacon ' + addr + ' ' + request)
Copy Permalink