Lines Matching refs:self
21 def __init__(self, ifname=None, global_iface=None, hostname=None, argument
23 self.monitor = monitor
24 self.hostname = hostname
25 self.group_ifname = None
26 self.global_mon = None
27 self.global_ctrl = None
28 self.gctrl_mon = None
29 self.ctrl = None
30 self.mon = None
31 self.ifname = None
32 self.host = remotehost.Host(hostname, ifname)
33 self._group_dbg = None
35 self.set_ifname(ifname, hostname, port)
36 res = self.get_driver_status()
38 self.p2p_dev_ifname = 'p2p-dev-' + self.ifname
40 self.p2p_dev_ifname = ifname
42 self.global_iface = global_iface
45 self.global_ctrl = wpaspy.Ctrl(hostname, global_port)
46 if self.monitor:
47 self.global_mon = wpaspy.Ctrl(hostname, global_port)
48 self.global_dbg = hostname + "/" + str(global_port) + "/"
50 self.global_ctrl = wpaspy.Ctrl(global_iface)
51 if self.monitor:
52 self.global_mon = wpaspy.Ctrl(global_iface)
53 self.global_dbg = ""
54 if self.monitor:
55 self.global_mon.attach()
57 def __del__(self): argument
58 self.close_monitor()
59 self.close_control()
61 def close_control_ctrl(self): argument
62 if self.ctrl:
63 del self.ctrl
64 self.ctrl = None
66 def close_control_global(self): argument
67 if self.global_ctrl:
68 del self.global_ctrl
69 self.global_ctrl = None
71 def close_control(self): argument
72 self.close_control_ctrl()
73 self.close_control_global()
75 def close_monitor_mon(self): argument
76 if not self.mon:
79 while self.mon.pending():
80 ev = self.mon.recv()
81 logger.debug(self.dbg + ": " + ev)
85 self.mon.detach()
93 del self.mon
94 self.mon = None
96 def close_monitor_global(self): argument
97 if not self.global_mon:
100 while self.global_mon.pending():
101 ev = self.global_mon.recv()
102 logger.debug(self.global_dbg + ": " + ev)
106 self.global_mon.detach()
114 del self.global_mon
115 self.global_mon = None
117 def close_monitor_group(self): argument
118 if not self.gctrl_mon:
121 while self.gctrl_mon.pending():
122 ev = self.gctrl_mon.recv()
123 logger.debug(self.dbg + ": " + ev)
127 self.gctrl_mon.detach()
130 del self.gctrl_mon
131 self.gctrl_mon = None
133 def close_monitor(self): argument
134 self.close_monitor_mon()
135 self.close_monitor_global()
136 self.close_monitor_group()
138 def cmd_execute(self, cmd_array, shell=False): argument
139 if self.hostname is None:
150 return self.host.execute(cmd_array)
152 def terminate(self): argument
153 if self.global_mon:
154 self.close_monitor_global()
155 self.global_ctrl.terminate()
156 self.global_ctrl = None
158 def close_ctrl(self): argument
159 self.close_monitor_global()
160 self.close_control_global()
161 self.remove_ifname()
163 def set_ifname(self, ifname, hostname=None, port=9877): argument
164 self.remove_ifname()
165 self.ifname = ifname
167 self.ctrl = wpaspy.Ctrl(hostname, port)
168 if self.monitor:
169 self.mon = wpaspy.Ctrl(hostname, port)
170 self.host = remotehost.Host(hostname, ifname)
171 self.dbg = hostname + "/" + ifname
173 self.ctrl = wpaspy.Ctrl(os.path.join(wpas_ctrl, ifname))
174 if self.monitor:
175 self.mon = wpaspy.Ctrl(os.path.join(wpas_ctrl, ifname))
176 self.dbg = ifname
177 if self.monitor:
178 self.mon.attach()
180 def remove_ifname(self): argument
181 self.close_monitor_mon()
182 self.close_control_ctrl()
183 self.ifname = None
185 def get_ctrl_iface_port(self, ifname): argument
186 if self.hostname is None:
189 res = self.global_request("INTERFACES ctrl")
205 def interface_add(self, ifname, config="", driver="nl80211", argument
208 status, groups = self.host.execute(["id"])
233 if "FAIL" in self.global_request(cmd):
236 port = self.get_ctrl_iface_port(ifname)
237 self.set_ifname(ifname, self.hostname, port)
238 res = self.get_driver_status()
240 self.p2p_dev_ifname = 'p2p-dev-' + self.ifname
242 self.p2p_dev_ifname = ifname
244 def interface_remove(self, ifname): argument
245 self.remove_ifname()
246 self.global_request("INTERFACE_REMOVE " + ifname)
248 def request(self, cmd, timeout=10): argument
249 logger.debug(self.dbg + ": CTRL: " + cmd)
250 return self.ctrl.request(cmd, timeout=timeout)
252 def global_request(self, cmd): argument
253 if self.global_iface is None:
254 return self.request(cmd)
256 ifname = self.ifname or self.global_iface
257 logger.debug(self.global_dbg + ifname + ": CTRL(global): " + cmd)
258 return self.global_ctrl.request(cmd)
261 def group_dbg(self): argument
262 if self._group_dbg is not None:
263 return self._group_dbg
264 if self.group_ifname is None:
266 if self.hostname is None:
267 self._group_dbg = self.group_ifname
269 self._group_dbg = self.hostname + "/" + self.group_ifname
270 return self._group_dbg
272 def group_request(self, cmd): argument
273 if self.group_ifname and self.group_ifname != self.ifname:
274 if self.hostname is None:
275 gctrl = wpaspy.Ctrl(os.path.join(wpas_ctrl, self.group_ifname))
277 port = self.get_ctrl_iface_port(self.group_ifname)
278 gctrl = wpaspy.Ctrl(self.hostname, port)
279 logger.debug(self.group_dbg + ": CTRL(group): " + cmd)
281 return self.request(cmd)
283 def ping(self): argument
284 return "PONG" in self.request("PING")
286 def global_ping(self): argument
287 return "PONG" in self.global_request("PING")
289 def reset(self): argument
290 self.dump_monitor()
291 res = self.request("FLUSH")
293 logger.info("FLUSH to " + self.ifname + " failed: " + res)
294 self.global_request("REMOVE_NETWORK all")
295 self.global_request("SET p2p_no_group_iface 1")
296 self.global_request("P2P_FLUSH")
297 self.close_monitor_group()
298 self.group_ifname = None
299 self.dump_monitor()
303 state1 = self.get_driver_status_field("scan_state")
304 p2pdev = "p2p-dev-" + self.ifname
305 state2 = self.get_driver_status_field("scan_state", ifname=p2pdev)
308 … logger.info(self.ifname + ": Waiting for scan operation to complete before continuing")
314 logger.error(self.ifname + ": Driver scan state did not clear")
316 status, buf = self.host.execute(["ifconfig", self.ifname, "down"])
320 status, buf = self.host.execute(["ifconfig", self.ifname, "up"])
327 self.request("FLUSH")
328 self.dump_monitor()
330 if not self.ping():
331 logger.info("No PING response from " + self.ifname + " after reset")
333 def set(self, field, value, allow_fail=False): argument
334 if "OK" not in self.request("SET " + field + " " + value):
339 def add_network(self): argument
340 id = self.request("ADD_NETWORK")
345 def remove_network(self, id): argument
346 id = self.request("REMOVE_NETWORK " + str(id))
351 def get_network(self, id, field): argument
352 res = self.request("GET_NETWORK " + str(id) + " " + field)
357 def set_network(self, id, field, value): argument
358 res = self.request("SET_NETWORK " + str(id) + " " + field + " " + value)
363 def set_network_quoted(self, id, field, value): argument
364 res = self.request("SET_NETWORK " + str(id) + " " + field + ' "' + value + '"')
369 def p2pdev_request(self, cmd): argument
370 return self.global_request("IFNAME=" + self.p2p_dev_ifname + " " + cmd)
372 def p2pdev_add_network(self): argument
373 id = self.p2pdev_request("ADD_NETWORK")
378 def p2pdev_set_network(self, id, field, value): argument
379 res = self.p2pdev_request("SET_NETWORK " + str(id) + " " + field + " " + value)
384 def p2pdev_set_network_quoted(self, id, field, value): argument
385 res = self.p2pdev_request("SET_NETWORK " + str(id) + " " + field + ' "' + value + '"')
390 def list_networks(self, p2p=False): argument
392 res = self.global_request("LIST_NETWORKS")
394 res = self.request("LIST_NETWORKS")
409 def hs20_enable(self, auto_interworking=False): argument
410 self.request("SET interworking 1")
411 self.request("SET hs20 1")
413 self.request("SET auto_interworking 1")
415 self.request("SET auto_interworking 0")
417 def interworking_add_network(self, bssid): argument
418 id = self.request("INTERWORKING_ADD_NETWORK " + bssid)
423 def add_cred(self): argument
424 id = self.request("ADD_CRED")
429 def remove_cred(self, id): argument
430 id = self.request("REMOVE_CRED " + str(id))
435 def set_cred(self, id, field, value): argument
436 res = self.request("SET_CRED " + str(id) + " " + field + " " + value)
441 def set_cred_quoted(self, id, field, value): argument
442 res = self.request("SET_CRED " + str(id) + " " + field + ' "' + value + '"')
447 def get_cred(self, id, field): argument
448 return self.request("GET_CRED " + str(id) + " " + field)
450 def add_cred_values(self, params): argument
451 id = self.add_cred()
461 self.set_cred_quoted(id, field, params[field])
470 self.set_cred(id, field, params[field])
475 self.set_cred_quoted(id, field, ','.join(params[field]))
479 def select_network(self, id, freq=None): argument
484 id = self.request("SELECT_NETWORK " + str(id) + extra)
489 def mesh_group_add(self, id): argument
490 id = self.request("MESH_GROUP_ADD " + str(id))
495 def mesh_group_remove(self): argument
496 id = self.request("MESH_GROUP_REMOVE " + str(self.ifname))
501 def connect_network(self, id, timeout=None): argument
503 timeout = 10 if self.hostname is None else 60
504 self.dump_monitor()
505 self.select_network(id)
506 self.wait_connected(timeout=timeout)
508 def get_status(self, extra=None): argument
513 res = self.request("STATUS" + extra)
521 logger.info(self.ifname + ": Ignore unexpected STATUS line: " + l)
524 def get_status_field(self, field, extra=None): argument
525 vals = self.get_status(extra)
530 def get_group_status(self, extra=None): argument
535 res = self.group_request("STATUS" + extra)
542 logger.info(self.ifname + ": Ignore unexpected status line: " + l)
547 def get_group_status_field(self, field, extra=None): argument
548 vals = self.get_group_status(extra)
553 def get_driver_status(self, ifname=None): argument
555 res = self.request("STATUS-DRIVER")
557 res = self.global_request("IFNAME=%s STATUS-DRIVER" % ifname)
566 logger.info(self.ifname + ": Ignore unexpected status-driver line: " + l)
571 def get_driver_status_field(self, field, ifname=None): argument
572 vals = self.get_driver_status(ifname)
577 def get_mcc(self): argument
578 mcc = int(self.get_driver_status_field('capa.num_multichan_concurrent'))
581 def get_mib(self): argument
582 res = self.request("MIB")
590 logger.info(self.ifname + ": Ignore unexpected MIB line: " + l)
593 def p2p_dev_addr(self): argument
594 return self.get_status_field("p2p_device_address")
596 def p2p_interface_addr(self): argument
597 return self.get_group_status_field("address")
599 def own_addr(self): argument
601 res = self.p2p_interface_addr()
603 res = self.p2p_dev_addr()
606 def get_addr(self, group=False): argument
607 dev_addr = self.own_addr()
609 addr = self.get_status_field('address')
615 def p2p_listen(self): argument
616 return self.global_request("P2P_LISTEN")
618 def p2p_ext_listen(self, period, interval): argument
619 return self.global_request("P2P_EXT_LISTEN %d %d" % (period, interval))
621 def p2p_cancel_ext_listen(self): argument
622 return self.global_request("P2P_EXT_LISTEN")
624 def p2p_find(self, social=False, progressive=False, dev_id=None, argument
639 return self.global_request(cmd)
641 def p2p_stop_find(self): argument
642 return self.global_request("P2P_STOP_FIND")
644 def wps_read_pin(self): argument
645 self.pin = self.request("WPS_PIN get").rstrip("\n")
646 if "FAIL" in self.pin:
648 return self.pin
650 def peer_known(self, peer, full=True): argument
651 res = self.global_request("P2P_PEER " + peer)
658 def discover_peer(self, peer, full=True, timeout=15, social=True, argument
660 logger.info(self.ifname + ": Trying to discover peer " + peer)
661 if not force_find and self.peer_known(peer, full):
663 self.p2p_find(social, freq=freq)
668 if self.peer_known(peer, full):
672 def get_peer(self, peer): argument
673 res = self.global_request("P2P_PEER " + peer)
684 def group_form_result(self, ev, expect_failure=False, go_neg_res=None): argument
710 self.group_ifname = s[2]
712 if self.hostname is None:
713 self.gctrl_mon = wpaspy.Ctrl(os.path.join(wpas_ctrl,
714 self.group_ifname))
716 port = self.get_ctrl_iface_port(self.group_ifname)
717 self.gctrl_mon = wpaspy.Ctrl(self.hostname, port)
718 if self.monitor:
719 self.gctrl_mon.attach()
722 self.gctrl_mon = None
755 def p2p_go_neg_auth(self, peer, pin, method, go_intent=None, argument
758 if not self.discover_peer(peer):
760 self.dump_monitor()
779 if "OK" in self.global_request(cmd):
783 def p2p_go_neg_auth_result(self, timeout=None, expect_failure=False): argument
787 ev = self.wait_global_event(["P2P-GO-NEG-SUCCESS",
795 ev = self.wait_global_event(["P2P-GROUP-STARTED"], timeout)
800 return self.group_form_result(ev, expect_failure, go_neg_res)
802 def p2p_go_neg_init(self, peer, pin, method, timeout=0, go_intent=None, argument
807 if not self.discover_peer(peer,timeout=timeout if timeout else 15):
809 self.dump_monitor()
832 if "OK" in self.global_request(cmd):
836 ev = self.wait_global_event(["P2P-GO-NEG-SUCCESS",
846 ev = self.wait_global_event(["P2P-GROUP-STARTED"], timeout)
851 self.dump_monitor()
852 return self.group_form_result(ev, expect_failure, go_neg_res)
855 def _wait_event(self, mon, pfx, events, timeout): argument
862 logger.debug(self.dbg + pfx + ev)
874 def wait_event(self, events, timeout=10): argument
875 return self._wait_event(self.mon, ": ", events, timeout)
877 def wait_global_event(self, events, timeout): argument
878 if self.global_iface is None:
879 return self.wait_event(events, timeout)
880 return self._wait_event(self.global_mon, "(global): ",
883 def wait_group_event(self, events, timeout=10): argument
886 if self.group_ifname and self.group_ifname != self.ifname:
887 if self.gctrl_mon is None:
891 while self.gctrl_mon.pending():
892 ev = self.gctrl_mon.recv()
893 logger.debug(self.group_dbg + "(group): " + ev)
901 if not self.gctrl_mon.pending(timeout=remaining):
905 return self.wait_event(events, timeout)
907 def wait_go_ending_session(self): argument
908 self.close_monitor_group()
909 timeout = 3 if self.hostname is None else 10
910 ev = self.wait_global_event(["P2P-GROUP-REMOVED"], timeout=timeout)
916 def dump_monitor(self, mon=True, global_mon=True): argument
919 while mon and self.monitor and self.mon.pending():
920 ev = self.mon.recv()
921 logger.debug(self.dbg + ": " + ev)
923 while global_mon and self.monitor and self.global_mon and self.global_mon.pending():
924 ev = self.global_mon.recv()
925 logger.debug(self.global_dbg + self.ifname + "(global): " + ev)
929 def remove_group(self, ifname=None): argument
930 self.close_monitor_group()
932 ifname = self.group_ifname if self.group_ifname else self.ifname
933 if "OK" not in self.global_request("P2P_GROUP_REMOVE " + ifname):
935 self.group_ifname = None
937 def p2p_start_go(self, persistent=None, freq=None, no_event_clear=False): argument
938 self.dump_monitor()
948 if "OK" in self.global_request(cmd):
949 ev = self.wait_global_event(["P2P-GROUP-STARTED"], timeout=5)
953 self.dump_monitor()
954 return self.group_form_result(ev)
957 def p2p_go_authorize_client(self, pin): argument
959 if "FAIL" in self.group_request(cmd):
963 def p2p_go_authorize_client_pbc(self): argument
965 if "FAIL" in self.group_request(cmd):
969 def p2p_connect_group(self, go_addr, pin, timeout=0, social=False, argument
971 self.dump_monitor()
972 if not self.discover_peer(go_addr, social=social, freq=freq):
973 if social or not self.discover_peer(go_addr, social=social):
975 self.p2p_stop_find()
976 self.dump_monitor()
980 if "OK" in self.global_request(cmd):
982 self.dump_monitor()
984 ev = self.wait_global_event(["P2P-GROUP-STARTED",
991 self.dump_monitor()
992 return self.group_form_result(ev)
995 def tdls_setup(self, peer): argument
997 if "FAIL" in self.group_request(cmd):
1001 def tdls_teardown(self, peer): argument
1003 if "FAIL" in self.group_request(cmd):
1007 def tdls_link_status(self, peer): argument
1009 ret = self.group_request(cmd)
1014 def tspecs(self): argument
1016 res = self.request("WMM_AC_STATUS")
1023 def add_ts(self, tsid, up, direction="downlink", expect_failure=False, argument
1037 if self.request(cmd).strip() != "OK":
1041 ev = self.wait_event(["TSPEC-REQ-FAILED"], timeout=2)
1048 ev = self.wait_event(["TSPEC-ADDED"], timeout=1)
1054 if (tsid, up) not in self.tspecs():
1057 def del_ts(self, tsid): argument
1058 if self.request("WMM_AC_DELTS %d" % (tsid)).strip() != "OK":
1061 ev = self.wait_event(["TSPEC-REMOVED"], timeout=1)
1067 tspecs = [(t, u) for (t, u) in self.tspecs() if t == tsid]
1071 def connect(self, ssid=None, ssid2=None, timeout=None, **kwargs): argument
1072 logger.info("Connect STA " + self.ifname + " to AP")
1073 id = self.add_network()
1075 self.set_network_quoted(id, "ssid", ssid)
1077 self.set_network(id, "ssid", ssid2)
1093 self.set_network_quoted(id, field, kwargs[field])
1123 self.set_network(id, field, kwargs[field])
1141 self.set_network(id, "identity", kwargs['raw_identity'])
1143 self.set_network(id, "psk", kwargs['raw_psk'])
1145 self.set_network(id, "password", kwargs['password_hex'])
1147 self.set_network(id, "peerkey", "1")
1149 self.set_network(id, "proactive_key_caching", "1")
1151 self.set_network(id, "ocsp", str(kwargs['ocsp']))
1155 self.connect_network(id, timeout=timeout)
1157 self.dump_monitor()
1158 self.select_network(id)
1161 def scan(self, type=None, freq=None, no_wait=False, only_new=False, argument
1164 self.dump_monitor()
1176 self.dump_monitor()
1177 res = self.request(cmd)
1182 ev = self.wait_event(["CTRL-EVENT-SCAN-RESULTS",
1189 def scan_for_bss(self, bssid, freq=None, force_scan=False, only_new=False, argument
1191 if not force_scan and self.get_bss(bssid) is not None:
1194 self.scan(freq=freq, type="ONLY", only_new=only_new,
1196 if self.get_bss(bssid) is not None:
1200 def flush_scan_cache(self, freq=2417): argument
1202 self.request("BSS_FLUSH 0")
1204 self.scan(freq=freq, only_new=True)
1208 self.request("ABORT_SCAN")
1210 res = self.request("SCAN_RESULTS")
1213 self.request("BSS_FLUSH 0")
1214 self.scan(freq=2422, only_new=True)
1215 res = self.request("SCAN_RESULTS")
1219 def disconnect_and_stop_scan(self): argument
1220 self.request("DISCONNECT")
1221 res = self.request("ABORT_SCAN")
1223 self.wait_event(["CTRL-EVENT-DISCONNECTED",
1225 self.dump_monitor()
1227 def roam(self, bssid, fail_test=False, assoc_reject_ok=False, argument
1229 self.dump_monitor()
1230 if "OK" not in self.request("ROAM " + bssid):
1234 ev = self.wait_event(["CTRL-EVENT-CONNECTED",
1238 ev = self.wait_event(["CTRL-EVENT-CONNECTED",
1241 self.dump_monitor()
1245 self.dump_monitor()
1248 ev = self.wait_event(["CTRL-EVENT-CONNECTED",
1251 ev = self.wait_event(["CTRL-EVENT-CONNECTED",
1260 self.dump_monitor()
1261 if check_bssid and self.get_status_field('bssid') != bssid:
1264 def roam_over_ds(self, bssid, fail_test=False, force=False): argument
1265 self.dump_monitor()
1269 if "OK" not in self.request(cmd):
1272 ev = self.wait_event(["CTRL-EVENT-CONNECTED"], timeout=1)
1275 self.dump_monitor()
1277 ev = self.wait_event(["CTRL-EVENT-CONNECTED",
1283 self.dump_monitor()
1285 def wps_reg(self, bssid, pin, new_ssid=None, key_mgmt=None, cipher=None, argument
1287 self.dump_monitor()
1289 self.request("WPS_REG " + bssid + " " + pin + " " +
1295 ev = self.wait_event(["WPS-SUCCESS"], timeout=15)
1297 self.request("WPS_REG " + bssid + " " + pin)
1300 ev = self.wait_event(["WPS-CRED-RECEIVED"], timeout=15)
1303 ev = self.wait_event(["WPS-FAIL"], timeout=15)
1306 self.wait_connected(timeout=15)
1308 def relog(self): argument
1309 self.global_request("RELOG")
1311 def wait_completed(self, timeout=10): argument
1313 if self.get_status_field("wpa_state") == "COMPLETED":
1318 def get_capability(self, field): argument
1319 res = self.request("GET_CAPABILITY " + field)
1324 def get_bss(self, bssid, ifname=None): argument
1325 if not ifname or ifname == self.ifname:
1326 res = self.request("BSS " + bssid)
1327 elif ifname == self.group_ifname:
1328 res = self.group_request("BSS " + bssid)
1343 def get_pmksa(self, bssid): argument
1344 res = self.request("PMKSA")
1364 def get_pmk(self, network_id): argument
1365 bssid = self.get_status_field('bssid')
1366 res = self.request("PMKSA_GET %d" % network_id)
1372 def get_sta(self, addr, info=None, next=False): argument
1375 res = self.request("STA-FIRST")
1377 res = self.request(cmd + addr + " " + info)
1379 res = self.request(cmd + addr)
1392 def mgmt_rx(self, timeout=5): argument
1393 ev = self.wait_event(["MGMT-RX"], timeout=timeout)
1396 return self.mgmt_rx_parse(ev)
1398 def mgmt_rx_parse(self, ev): argument
1436 def wait_connected(self, timeout=10, error="Connection timed out"): argument
1437 ev = self.wait_event(["CTRL-EVENT-CONNECTED"], timeout=timeout)
1442 def wait_disconnected(self, timeout=None, error="Disconnection timed out"): argument
1444 timeout = 10 if self.hostname is None else 30
1445 ev = self.wait_event(["CTRL-EVENT-DISCONNECTED"], timeout=timeout)
1450 def get_group_ifname(self): argument
1451 return self.group_ifname if self.group_ifname else self.ifname
1453 def get_config(self): argument
1454 res = self.request("DUMP")
1464 def asp_provision(self, peer, adv_id, adv_mac, session_id, session_mac, argument
1478 … if "OK" not in self.global_request("%s %s adv_id=%s adv_mac=%s session=%d session_mac=%s %s" %
1482 def note(self, txt): argument
1483 self.request("NOTE " + txt)
1485 def save_config(self): argument
1486 if "OK" not in self.request("SAVE_CONFIG"):
1489 def wait_regdom(self, country_ie=False): argument
1491 ev = self.wait_event(["CTRL-EVENT-REGDOM-CHANGE"], timeout=1)
1500 def dpp_qr_code(self, uri): argument
1501 res = self.request("DPP_QR_CODE " + uri)
1506 def dpp_nfc_uri(self, uri): argument
1507 res = self.request("DPP_NFC_URI " + uri)
1512 def dpp_bootstrap_gen(self, type="qrcode", chan=None, mac=None, info=None, argument
1520 mac = self.own_addr()
1532 res = self.request(cmd)
1537 def dpp_bootstrap_set(self, id, conf=None, configurator=None, ssid=None, argument
1548 if "OK" not in self.request(cmd):
1551 def dpp_listen(self, freq, netrole=None, qr=None, role=None): argument
1559 if "OK" not in self.request(cmd):
1564 work_started = "dpp-listen@" + self.ifname + ":" + str(freq) + ":1"
1566 if work_started in self.request("RADIO_WORK show"):
1572 def dpp_auth_init(self, peer=None, uri=None, conf=None, configurator=None, argument
1581 peer = self.dpp_nfc_uri(nfc_uri)
1583 peer = self.dpp_qr_code(uri)
1613 res = self.request(cmd)
1622 def dpp_pkex_init(self, identifier, code, role=None, key=None, curve=None, argument
1626 id1 = self.dpp_bootstrap_gen(type="pkex", key=key, curve=curve)
1644 res = self.request("DPP_PKEX_ADD " + cmd)
1651 def dpp_pkex_resp(self, freq, identifier, code, key=None, curve=None, argument
1654 id0 = self.dpp_bootstrap_gen(type="pkex", key=key, curve=curve)
1661 res = self.request("DPP_PKEX_ADD " + cmd)
1664 self.dpp_listen(freq, role=listen_role)
1667 def dpp_configurator_add(self, curve=None, key=None, argument
1676 res = self.request(cmd)
1681 def dpp_configurator_set(self, conf_id, net_access_key_curve=None): argument
1685 res = self.request(cmd)
1689 def dpp_configurator_remove(self, conf_id): argument
1690 res = self.request("DPP_CONFIGURATOR_REMOVE %d" % conf_id)
1694 def get_ptksa(self, bssid, cipher): argument
1695 res = self.request("PTKSA_CACHE_LIST")
1712 def wait_sta(self, addr=None, timeout=2, wait_4way_hs=False): argument
1713 ev = self.wait_group_event(["AP-STA-CONNECT"], timeout=timeout)
1715 ev = self.wait_event(["AP-STA-CONNECT"], timeout=timeout)
1721 ev2 = self.wait_group_event(["EAPOL-4WAY-HS-COMPLETED"],
1729 def wait_sta_disconnect(self, addr=None, timeout=2): argument
1730 ev = self.wait_group_event(["AP-STA-DISCONNECT"], timeout=timeout)
1732 ev = self.wait_event(["AP-STA-CONNECT"], timeout=timeout)