The callback for the FRAME command was causing a crash in wiphy_radio_work_done when not cancelled when the wiphy was being removed from the system. This was likely to happen if this radio work item was waiting for another item to finish. When the first one was being cancelled due to the wiphy being removed, this one would be started and immediately stopped by the radio work queue. Now this crash could be fixed by dropping all frame exchange instances on an interface that is being removed which is easy to do, but properly cancelling the commands saves us the headache of analysing whether there's a race condition in other situations where a frame exchange is being aborted. --- src/frame-xchg.c | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/src/frame-xchg.c b/src/frame-xchg.c index d26e0c54..0e3e330d 100644 --- a/src/frame-xchg.c +++ b/src/frame-xchg.c @@ -116,6 +116,7 @@ struct frame_xchg_data { unsigned int retries_on_ack; struct wiphy_radio_work_item work; bool no_cck_rates; + unsigned int tx_cmd_id; }; struct frame_xchg_watch_data { @@ -772,6 +773,9 @@ static void frame_xchg_reset(struct frame_xchg_data *fx) if (fx->timeout) l_timeout_remove(fx->timeout); + if (fx->tx_cmd_id) + l_genl_family_cancel(nl80211, fx->tx_cmd_id); + l_free(fx->early_frame.mpdu); fx->early_frame.mpdu = NULL; l_queue_destroy(fx->rx_watches, l_free); @@ -930,12 +934,18 @@ error: frame_xchg_done(fx, error); } +static void frame_xchg_tx_destroy(void *user_data) +{ + struct frame_xchg_data *fx = user_data; + + fx->tx_cmd_id = 0; +} + static bool frame_xchg_tx_retry(struct wiphy_radio_work_item *item) { struct frame_xchg_data *fx = l_container_of(item, struct frame_xchg_data, work); struct l_genl_msg *msg; - uint32_t cmd_id; uint32_t duration = fx->resp_timeout; /* @@ -963,8 +973,9 @@ static bool frame_xchg_tx_retry(struct wiphy_radio_work_item *item) l_genl_msg_append_attr(msg, NL80211_ATTR_DURATION, 4, &duration); - cmd_id = l_genl_family_send(nl80211, msg, frame_xchg_tx_cb, fx, NULL); - if (!cmd_id) { + fx->tx_cmd_id = l_genl_family_send(nl80211, msg, frame_xchg_tx_cb, fx, + frame_xchg_tx_destroy); + if (!fx->tx_cmd_id) { l_error("Error sending frame"); l_genl_msg_unref(msg); frame_xchg_done(fx, -EIO); -- 2.25.1

--- I have sent this once or twice before but this code is still unused. src/scan.c | 53 ----------------------------------------------------- 1 file changed, 53 deletions(-) diff --git a/src/scan.c b/src/scan.c index b4135d7c..fe780f51 100644 --- a/src/scan.c +++ b/src/scan.c @@ -115,7 +115,6 @@ struct scan_context { struct scan_results { struct scan_context *sc; struct l_queue *bss_list; - struct scan_freq_set *freqs; uint64_t time_stamp; struct scan_request *sr; }; @@ -1200,28 +1199,6 @@ fail: return NULL; } -static struct scan_freq_set *scan_parse_attr_scan_frequencies( - struct l_genl_attr *attr) -{ - uint16_t type, len; - const void *data; - struct scan_freq_set *set; - - set = scan_freq_set_new(); - - while (l_genl_attr_next(attr, &type, &len, &data)) { - uint32_t freq; - - if (len != sizeof(uint32_t)) - continue; - - freq = *((uint32_t *) data); - scan_freq_set_add(set, freq); - } - - return set; -} - static struct scan_bss *scan_parse_result(struct l_genl_msg *msg, uint64_t *out_wdev) { @@ -1541,9 +1518,6 @@ static void get_scan_done(void *user) l_queue_destroy(results->bss_list, (l_queue_destroy_func_t) scan_bss_free); - if (results->freqs) - scan_freq_set_free(results->freqs); - l_free(results); } @@ -1563,31 +1537,6 @@ static bool scan_parse_flush_flag_from_msg(struct l_genl_msg *msg) return false; } -static void scan_parse_new_scan_results(struct l_genl_msg *msg, - struct scan_results *results) -{ - struct l_genl_attr attr, nested; - uint16_t type, len; - const void *data; - - if (!l_genl_attr_init(&attr, msg)) - return; - - while (l_genl_attr_next(&attr, &type, &len, &data)) { - switch (type) { - case NL80211_ATTR_SCAN_FREQUENCIES: - if (!l_genl_attr_recurse(&attr, &nested)) { - l_warn("Failed to parse ATTR_SCAN_FREQUENCIES"); - break; - } - - results->freqs = - scan_parse_attr_scan_frequencies(&nested); - break; - } - } -} - static void scan_notify(struct l_genl_msg *msg, void *user_data) { struct l_genl_attr attr; @@ -1706,8 +1655,6 @@ static void scan_notify(struct l_genl_msg *msg, void *user_data) results->sr = sr; results->bss_list = l_queue_new(); - scan_parse_new_scan_results(msg, results); - scan_msg = l_genl_msg_new_sized(NL80211_CMD_GET_SCAN, 8); l_genl_msg_append_attr(scan_msg, NL80211_ATTR_WDEV, 8, &sc->wdev_id); -- 2.25.1

Since our DBus API and our use cases only support initiating connections and not accepting incoming connections we don't really need to reply to Probe Requests on the P2P-Device interface. Start doing it firstly so that we can test the scenario where we get discovered and pre-authorized to connect in an autotest (wpa_supplicant doesn't seem to have a way to authorize everyone, which is probably why most Wi-Fi Display dongles don't do it and instead reply with "Fail: Information not available" and then restart connection from their side) and secondly because the spec wants us to do it. --- src/p2p.c | 33 +++++++++++++++++---------------- 1 file changed, 17 insertions(+), 16 deletions(-) diff --git a/src/p2p.c b/src/p2p.c index 662fdb61..417ce3d6 100644 --- a/src/p2p.c +++ b/src/p2p.c @@ -3554,6 +3554,20 @@ static void p2p_device_send_probe_resp(struct p2p_device *dev, resp_info.capability = dev->capability; resp_info.device_info = dev->device_info; + /* + * Note the SSID and resp_info.group_clients are not updated with + * our group information because we generally won't be in the + * Listen State on the P2P Device when running a group. Otherwise + * we'd be sending two Probe Responses, one from the P2P Interface + * and another from the P2P Device. According to this part in + * Wi-Fi P2P Technical Specification v1.7 section 3.2.2 it seems + * only the P2P Interface is supposed to be sending Probe + * Responses in that situation: + * "In all Probe Responses that it sends, a P2P Group Owner shall + * set the SSID to the SSID of the group, and shall set the SA and + * BSSID to its P2P Interface Address." + */ + p2p_ie = p2p_build_probe_resp(&resp_info, &p2p_ie_size); if (!p2p_ie) { l_error("Can't build our Probe Response P2P IE"); @@ -3686,23 +3700,10 @@ static void p2p_device_probe_cb(const struct mmpdu_header *mpdu, } /* - * We don't currently have a use case for replying to Probe Requests - * except when waiting for a GO Negotiation Request from our target - * peer. Some of those peers (seemingly running ancient and/or - * hw-manufacturer-provided versions of wpa_s) will only send us GO - * Negotiation Requests each time they receive our Probe Response - * frame, even if that frame's body is unparsable. + * TODO: use ap.c code to check if we match the SSID, BSSID, DSSS + * Channel etc. in the Probe Request, and to build the Response body. */ - if (from_conn_peer) { - /* - * TODO: use ap.c code to check if we match the SSID, BSSID, - * DSSS Channel etc. in the Probe Request, and to build the - * Response body. - */ - p2p_device_send_probe_resp(dev, mpdu->address_2, - from_conn_peer); - goto p2p_free; - } + p2p_device_send_probe_resp(dev, mpdu->address_2, from_conn_peer); /* * The peer's listen frequency may be different from ours. -- 2.25.1

Enable p2p for the hwsim radios so that we can test P2P. This can be made optional for the tests but it seems safe to enable always. --- tools/test-runner | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/test-runner b/tools/test-runner index f2b75bc0..00a0978a 100755 --- a/tools/test-runner +++ b/tools/test-runner @@ -303,7 +303,7 @@ class VirtualRadio(Radio): self.disable_cipher = None self.disable_iftype = None - args = ['hwsim', '--create', '--name', self.name, '--nointerface'] + args = ['hwsim', '--create', '--name', self.name, '--nointerface', '--p2p'] if config: self.disable_iftype = config.get('iftype_disable', False) -- 2.25.1

Allow the "hwsim_medium=no" setting in hw.conf's SETUP section to disable starting hwsim. It looks like the packets going through userspace add enough latency that active scans don't work, probe responses don't arrive within the "dwell time" or probe requests are not ACKed on time. I've tried modifying tools/hwsim.c to respond with the HWSIM_CMD_TX_INFO_FRAME cmd as the first thing after receiving a HWSIM_CMD_FRAME and even skipping the queue in ell/genl.c by writing the command synchronously, but neither helped enough to make the scans work. This does not rule out that hwsim or the way our scans are done can be fixed and that would obviously be better than what I did in this patch. --- tools/test-runner | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tools/test-runner b/tools/test-runner index dc6b1f7a..ea0f7b79 100755 --- a/tools/test-runner +++ b/tools/test-runner @@ -516,8 +516,9 @@ class TestContext: self.radios.append(VirtualRadio(name, rad_config)) self.cur_radio_id += 1 - # register hwsim as medium - self.start_process(['hwsim']) + if self.hw_config['SETUP'].get('hwsim_medium', 'yes') in ['yes', '1', 'true']: + # register hwsim as medium + self.start_process(['hwsim']) def discover_radios(self): phys = [] -- 2.25.1

Add the new wpas.Wpas class roughly based on hostapd.HostapdCLI but only adding methods for the P2P-related stuff. Adding "wpa_supplicant" to will enable output from the wpa_supplicant process to be printed and "wpa_supplicant-dbg" will make it more verbose ("wpa_supplicant" is not needed because it seems to be automatically enabled because of the glob matching in ctx.is_verbose) --- autotests/util/wpas.py | 222 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 222 insertions(+) create mode 100644 autotests/util/wpas.py diff --git a/autotests/util/wpas.py b/autotests/util/wpas.py new file mode 100644 index 00000000..e871b1b1 --- /dev/null +++ b/autotests/util/wpas.py @@ -0,0 +1,222 @@ +#!/usr/bin/python3 +import os +import socket +from gi.repository import GLib +from config import ctx + +ctrl_count = 0 +mainloop = GLib.MainLoop() + +class Wpas: + def _start_wpas(self, config_path, socket_path, main_interface, ifname=None): + global ctrl_count + + self.interface = main_interface + self.ifname = main_interface.name if ifname is None else ifname + self.socket_path = socket_path + self.io_watch = None + + cmd = ['wpa_supplicant', '-i', self.interface.name, '-c', config_path] + if ctx.is_verbose('wpa_supplicant-dbg'): + cmd += ['-d'] + + self.wpa_supplicant = ctx.start_process(cmd) + + self.local_ctrl = '/tmp/wpas_' + str(os.getpid()) + '_' + str(ctrl_count) + ctrl_count = ctrl_count + 1 + self.ctrl_sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM) + self.ctrl_sock.bind(self.local_ctrl) + + self.remote_ctrl = self.socket_path + '/' + self.ifname + self.wpa_supplicant.wait_for_socket(self.remote_ctrl, 2) + self.ctrl_sock.connect(self.remote_ctrl) + self.io_watch = GLib.io_add_watch(self.ctrl_sock, GLib.IO_IN, self._handle_data_in) + + self.p2p_peers = {} + self.p2p_go_neg_requests = {} + self.p2p_clients = {} + self.p2p_group = None + + self._rx_data = [] + self._ctrl_request('ATTACH') + self.wait_for_event('OK') + + def __init__(self, *args, **kwargs): + self._start_wpas(*args, **kwargs) + + 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=True) + + if event in self._rx_data: + GLib.source_remove(timeout) + return self._rx_data + + if self._wait_timed_out: + raise TimeoutError('waiting for wpas event timed out') + + def _event_parse(self, line): + # Unescape event parameter values in '', other escaping rules not implemented + key = None + value = '' + count = 0 + quoted = False + event = {} + + def handle_eow(): + nonlocal key, value, count, event + if count == 0: + if key is not None or not value: + raise Exception('Bad event name') + key = 'event' + elif key is None: + if not value: + return + key = 'arg' + str(count) + event[key] = value + key = None + value = '' + count += 1 + + for ch in line: + if ch == '\'': + quoted = not quoted + elif quoted: + value += ch + elif ch == '=' and key is None: + key = value + value = '' + elif ch in ' \n': + handle_eow() + else: + value += ch + handle_eow() + return event + + def _handle_data_in(self, sock, *args): + newdata = sock.recv(4096) + if len(newdata) == 0: + raise Exception('Wpa_s control socket error') + + decoded = newdata.decode('utf-8') + if len(decoded) >= 3 and decoded[0] == '<' and decoded[2] == '>': + decoded = decoded[3:] + while len(decoded) and decoded[-1] == '\n': + decoded = decoded[:-1] + + self._rx_data.append(decoded) + + event = self._event_parse(decoded) + if event['event'] == 'P2P-DEVICE-FOUND': + event.pop('event') + event.pop('arg1') + self.p2p_peers[event['p2p_dev_addr']] = event + elif event['event'] == 'P2P-DEVICE-LOST': + del self.p2p_peers[event['p2p_dev_addr']] + elif event['event'] == 'P2P-GO-NEG-REQUEST': + event.pop('event') + event['p2p_dev_addr'] = event.pop('arg1') + self.p2p_go_neg_requests[event['p2p_dev_addr']] = event + elif event['event'] == 'P2P-GO-NEG-SUCCESS': + event.pop('event') + addr = event.pop('peer_dev') + event['success'] = True + event['p2p_dev_addr'] = addr + + if addr in self.p2p_go_neg_requests: + self.p2p_go_neg_requests[addr].update(event) + else: + self.p2p_go_neg_requests[addr] = event + elif event['event'] == 'AP-STA-CONNECTED': + event.pop('event') + addr = event.pop('arg1') + self.p2p_clients[addr] = event + elif event['event'] == 'AP-STA-DISCONNECTED': + addr = event.pop('arg1') + del self.p2p_clients[addr] + elif event['event'] == 'P2P-GROUP-STARTED': + event.pop('event') + event['ifname'] = event.pop('arg1') + self.p2p_group = event + elif event['event'] == 'P2P-GROUP-REMOVED': + self.p2p_group = None + + return True + + def _ctrl_request(self, command, timeout=10): + if type(command) is str: + command = str.encode(command) + + self.ctrl_sock.send(bytes(command)) + + # Normal find phase with listen and active scan states + def p2p_find(self): + self._rx_data = [] + self._ctrl_request('P2P_SET disc_int 2 3 300') + self.wait_for_event('OK') + self._rx_data = [] + self._ctrl_request('P2P_FIND type=social') + self.wait_for_event('OK') + + # Like p2p_find but uses only listen states + def p2p_listen(self): + self._rx_data = [] + self._ctrl_request('P2P_LISTEN') + self.wait_for_event('OK') + + # Stop a p2p_find or p2p_listen + def p2p_stop_find_listen(self): + self._rx_data = [] + self._ctrl_request('P2P_STOP_FIND') + self.wait_for_event('OK') + + def p2p_connect(self, peer, pin=None, go_intent=None): + self._rx_data = [] + self._ctrl_request('P2P_CONNECT ' + peer['p2p_dev_addr'] + ' ' + ('pbc' if pin is None else pin) + + ('' if go_intent is None else 'go_intent=' + str(go_intent))) + self.wait_for_event('OK') + + def p2p_accept_go_neg_request(self, request, pin=None, go_intent=None): + self._rx_data = [] + self._ctrl_request('P2P_CONNECT ' + request['p2p_dev_addr'] + ' ' + ('pbc' if pin is None else pin) + + ('' if go_intent is None else 'go_intent=' + str(go_intent))) + self.wait_for_event('OK') + + # Pre-accept the next GO Negotiation Request from this peer to avoid the extra Respone + Request frames + def p2p_authorize(self, peer, pin=None, go_intent=None): + self._rx_data = [] + self._ctrl_request('P2P_CONNECT ' + peer['p2p_dev_addr'] + ' ' + ('pbc' if pin is None else pin) + + ('' if go_intent is None else 'go_intent=' + str(go_intent)) + ' auth') + self.wait_for_event('OK') + + # Probably needed: remove references to self so that the GC can call __del__ automatically + def clean_up(self): + if self.io_watch is not None: + GLib.source_remove(self.io_watch) + self.io_watch = None + if self.wpa_supplicant is not None: + ctx.stop_process(self.wpa_supplicant) + self.wpa_supplicant = None + + def _stop_wpas(self): + self.clean_up() + if self.ctrl_sock: + self.ctrl_sock.close() + self.ctrl_sock = None + if os.path.exists(self.remote_ctrl): + os.remove(self.remote_ctrl) + if os.path.exists(self.local_ctrl): + os.remove(self.local_ctrl) + + def __del__(self): + self._stop_wpas() -- 2.25.1

Add two P2P client connection scenarios. --- autotests/testP2P/client_test.py | 108 +++++++++++++++++++++++++++++++ autotests/testP2P/dhcpd.conf | 4 ++ autotests/testP2P/hw.conf | 4 ++ autotests/testP2P/main.conf | 6 ++ autotests/testP2P/rad1-p2p.conf | 10 +++ 5 files changed, 132 insertions(+) create mode 100644 autotests/testP2P/client_test.py create mode 100644 autotests/testP2P/dhcpd.conf create mode 100644 autotests/testP2P/hw.conf create mode 100644 autotests/testP2P/main.conf create mode 100644 autotests/testP2P/rad1-p2p.conf diff --git a/autotests/testP2P/client_test.py b/autotests/testP2P/client_test.py new file mode 100644 index 00000000..45cde721 --- /dev/null +++ b/autotests/testP2P/client_test.py @@ -0,0 +1,108 @@ +#!/usr/bin/python3 + +import unittest +import sys +import netifaces +import os + +import iwd +from iwd import IWD +import testutil +from config import ctx +from wpas import Wpas + +class Test(unittest.TestCase): + def test_1_client_go_neg_responder(self): + self.p2p_client_test(False) + + def test_2_client_go_neg_initiator(self): + self.p2p_client_test(True) + + def p2p_client_test(self, preauthorize): + wpas_interface = ctx.wpas_interfaces[0] + p2p_ifname = 'p2p-dev-' + wpas_interface.name + wpas = Wpas('/tmp/rad1-p2p.conf', '/tmp/rad1-p2p-wpas', wpas_interface, p2p_ifname) + + wd = IWD() + # Not strictly necessary but prevents the station interface from queuing its scans + # in the wiphy radio work queue and delaying P2P scans. + wd.list_devices(1)[0].disconnect() + + devices = wd.list_p2p_devices(1) + p2p = devices[0] + p2p.enabled = True + p2p.name = 'testdev1' + + wpas.p2p_find() + p2p.discovery_request = True + wd.wait(5) + wd.wait_for_object_condition(wpas, 'len(obj.p2p_peers) == 1', max_wait=20) + p2p.discovery_request = False + wpas.p2p_listen() + + peers = p2p.get_peers() + self.assertEqual(len(peers), 1) + peer = next(iter(peers.values())) + self.assertEqual(peer.name, 'testdev2') + self.assertEqual(peer.category, 'display') + self.assertEqual(peer.subcategory, 'monitor') + + wpas_peer = next(iter(wpas.p2p_peers.values())) + self.assertEqual(wpas_peer['name'], 'testdev1') + self.assertEqual(wpas_peer['pri_dev_type'], '1-0050F204-6') # 1 == Computer, 6 == Desktop + self.assertEqual(wpas_peer['config_methods'], '0x1080') + + if preauthorize: + wpas.p2p_authorize(wpas_peer) + + peer.connect(wait=False) + + self.assertEqual(len(wpas.p2p_go_neg_requests), 0) + self.assertEqual(len(wpas.p2p_clients), 0) + wd.wait_for_object_condition(wpas, 'len(obj.p2p_go_neg_requests) == 1', max_wait=3) + request = wpas.p2p_go_neg_requests[wpas_peer['p2p_dev_addr']] + + if not preauthorize: + self.assertEqual(request['dev_passwd_id'], '4') + self.assertEqual(request['go_intent'], '2') # Hardcoded in src/p2p.c + + wpas.p2p_accept_go_neg_request(request) + + wd.wait_for_object_condition(request, '\'success\' in obj', max_wait=3) + self.assertEqual(request['success'], True) + self.assertEqual(request['role'], 'GO') + self.assertEqual(request['wps_method'], 'PBC') + self.assertEqual(request['p2p_dev_addr'], wpas_peer['p2p_dev_addr']) + + wd.wait_for_object_condition(wpas, 'obj.p2p_group is not None', max_wait=3) + go_ifname = wpas.p2p_group['ifname'] + ctx.start_process(['ifconfig', go_ifname, '192.168.1.20', 'netmask', '255.255.255.0'], wait=True) + os.system('> /tmp/dhcpd.leases') + dhcpd = ctx.start_process(['dhcpd', '-f', '-cf', '/tmp/dhcpd.conf', '-lf', '/tmp/dhcpd.leases', go_ifname]) + + wd.wait_for_object_condition(wpas, 'len(obj.p2p_clients) == 1', max_wait=3) + client = wpas.p2p_clients[request['peer_iface']] + self.assertEqual(client['p2p_dev_addr'], wpas_peer['p2p_dev_addr']) + + wd.wait_for_object_condition(peer, 'obj.connected', max_wait=15) + our_ip = netifaces.ifaddresses(peer.connected_interface)[netifaces.AF_INET][0]['addr'] + self.assertEqual(peer.connected_ip, '192.168.1.20') + self.assertEqual(our_ip, '192.168.1.30') + + testutil.test_iface_operstate(peer.connected_interface) + testutil.test_ifaces_connected(peer.connected_interface, go_ifname) + + peer.disconnect() + wd.wait_for_object_condition(wpas, 'len(obj.p2p_clients) == 0', max_wait=3) + self.assertEqual(peer.connected, False) + + p2p.enabled = False + ctx.stop_process(dhcpd) + wpas.clean_up() + + @classmethod + def tearDownClass(cls): + IWD.clear_storage() + +if __name__ == '__main__': + unittest.main(exit=True) diff --git a/autotests/testP2P/dhcpd.conf b/autotests/testP2P/dhcpd.conf new file mode 100644 index 00000000..a5ef0b4a --- /dev/null +++ b/autotests/testP2P/dhcpd.conf @@ -0,0 +1,4 @@ +subnet 192.168.1.0 netmask 255.255.255.0 + { + range 192.168.1.30; + } diff --git a/autotests/testP2P/hw.conf b/autotests/testP2P/hw.conf new file mode 100644 index 00000000..05d436a6 --- /dev/null +++ b/autotests/testP2P/hw.conf @@ -0,0 +1,4 @@ +[SETUP] +num_radios=2 +wpa_supplicant_radios=rad1 +hwsim_medium=no diff --git a/autotests/testP2P/main.conf b/autotests/testP2P/main.conf new file mode 100644 index 00000000..aeafc2ab --- /dev/null +++ b/autotests/testP2P/main.conf @@ -0,0 +1,6 @@ +[General] +EnableNetworkConfiguration=true + +[P2P] +# Something different from the default for validation +DeviceType=desktop diff --git a/autotests/testP2P/rad1-p2p.conf b/autotests/testP2P/rad1-p2p.conf new file mode 100644 index 00000000..a34f3d91 --- /dev/null +++ b/autotests/testP2P/rad1-p2p.conf @@ -0,0 +1,10 @@ +ctrl_interface=/tmp/rad1-p2p-wpas +update_config=0 +device_name=testdev2 +device_type=7-0050F204-4 # 7 == Display, 4 == Monitor +config_methods=virtual_push_button +p2p_listen_reg_class=81 +p2p_listen_channel=11 +p2p_oper_reg_class=81 +p2p_oper_channel=11 +p2p_go_intent=10 -- 2.25.1

Hi Andrew, On Tue, 2020-09-29 at 18:37 +0200, Andrew Zaborowski wrote: I think this is gonna end causing some weird behavior. Using ctx.mainloop should work better. I had all kinds of strange issues due to test-runner and iwd.py both creating a mainloop.