tests/hwsim/test_p2p_discovery.py

   1 # P2P device discovery test cases
   2 # Copyright (c) 2013, Jouni Malinen <j@w1.fi>
   3 #
   4 # This software may be distributed under the terms of the BSD license.
   5 # See README for more details.
   6
   7 import logging
   8 logger = logging.getLogger()
   9 import time
  10
  11 import hwsim_utils
  12 from wpasupplicant import WpaSupplicant
  13
  14 def test_discovery(dev):
  15     """P2P device discovery and provision discovery"""
  16     addr0 = dev[0].p2p_dev_addr()
  17     addr1 = dev[1].p2p_dev_addr()
  18     logger.info("Start device discovery")
  19     dev[0].p2p_find(social=True, delay=1)
  20     if not dev[1].discover_peer(addr0):
  21         raise Exception("Device discovery timed out")
  22     if not dev[0].discover_peer(addr1):
  23         raise Exception("Device discovery timed out")
  24
  25     logger.info("Test provision discovery for display")
  26     dev[0].global_request("P2P_PROV_DISC " + addr1 + " display")
  27     ev1 = dev[1].wait_global_event(["P2P-PROV-DISC-SHOW-PIN"], timeout=15)
  28     if ev1 is None:
  29         raise Exception("Provision discovery timed out (display/dev1)")
  30     if addr0 not in ev1:
  31         raise Exception("Dev0 not in provision discovery event")
  32     ev0 = dev[0].wait_global_event(["P2P-PROV-DISC-ENTER-PIN",
  33                                     "P2P-PROV-DISC-FAILURE"], timeout=15)
  34     if ev0 is None:
  35         raise Exception("Provision discovery timed out (display/dev0)")
  36     if "P2P-PROV-DISC-FAILURE" in ev0:
  37         raise Exception("Provision discovery failed (display/dev0)")
  38     if addr1 not in ev0:
  39         raise Exception("Dev1 not in provision discovery event")
  40
  41     logger.info("Test provision discovery for keypad")
  42     dev[0].global_request("P2P_PROV_DISC " + addr1 + " keypad")
  43     ev1 = dev[1].wait_global_event(["P2P-PROV-DISC-ENTER-PIN"], timeout=15)
  44     if ev1 is None:
  45         raise Exception("Provision discovery timed out (keypad/dev1)")
  46     if addr0 not in ev1:
  47         raise Exception("Dev0 not in provision discovery event")
  48     ev0 = dev[0].wait_global_event(["P2P-PROV-DISC-SHOW-PIN",
  49                                     "P2P-PROV-DISC-FAILURE"],
  50                                    timeout=15)
  51     if ev0 is None:
  52         raise Exception("Provision discovery timed out (keypad/dev0)")
  53     if "P2P-PROV-DISC-FAILURE" in ev0:
  54         raise Exception("Provision discovery failed (keypad/dev0)")
  55     if addr1 not in ev0:
  56         raise Exception("Dev1 not in provision discovery event")
  57
  58     logger.info("Test provision discovery for push button")
  59     dev[0].global_request("P2P_PROV_DISC " + addr1 + " pbc")
  60     ev1 = dev[1].wait_global_event(["P2P-PROV-DISC-PBC-REQ"], timeout=15)
  61     if ev1 is None:
  62         raise Exception("Provision discovery timed out (pbc/dev1)")
  63     if addr0 not in ev1:
  64         raise Exception("Dev0 not in provision discovery event")
  65     ev0 = dev[0].wait_global_event(["P2P-PROV-DISC-PBC-RESP",
  66                                     "P2P-PROV-DISC-FAILURE"],
  67                                    timeout=15)
  68     if ev0 is None:
  69         raise Exception("Provision discovery timed out (pbc/dev0)")
  70     if "P2P-PROV-DISC-FAILURE" in ev0:
  71         raise Exception("Provision discovery failed (pbc/dev0)")
  72     if addr1 not in ev0:
  73         raise Exception("Dev1 not in provision discovery event")
  74
  75     dev[0].p2p_stop_find
  76     dev[1].p2p_stop_find
  77
  78     if "FAIL" not in dev[0].p2p_find(dev_id="foo"):
  79         raise Exception("P2P_FIND with invalid dev_id accepted")
  80     if "FAIL" not in dev[0].p2p_find(dev_type="foo"):
  81         raise Exception("P2P_FIND with invalid dev_type accepted")
  82
  83     if "FAIL" not in dev[0].global_request("P2P_PROV_DISC foo pbc"):
  84         raise Exception("Invalid P2P_PROV_DISC accepted")
  85     if "FAIL" not in dev[0].global_request("P2P_PROV_DISC 00:11:22:33:44:55"):
  86         raise Exception("Invalid P2P_PROV_DISC accepted")
  87     if "FAIL" not in dev[0].global_request("P2P_PROV_DISC 00:11:22:33:44:55 pbc join"):
  88         raise Exception("Invalid P2P_PROV_DISC accepted")
  89     if "FAIL" not in dev[0].global_request("P2P_PROV_DISC 00:11:22:33:44:55 foo"):
  90         raise Exception("Invalid P2P_PROV_DISC accepted")
  91
  92 def test_discovery_pd_retries(dev):
  93     """P2P device discovery and provision discovery retries"""
  94     addr0 = dev[0].p2p_dev_addr()
  95     addr1 = dev[1].p2p_dev_addr()
  96     dev[1].p2p_listen()
  97     if not dev[0].discover_peer(addr1):
  98         raise Exception("Device discovery timed out")
  99     dev[1].p2p_stop_find()
 100     dev[0].p2p_stop_find()
 101     dev[0].global_request("P2P_PROV_DISC " + addr1 + " display")
 102     ev = dev[0].wait_event(["P2P-PROV-DISC-FAILURE"], timeout=60)
 103     if ev is None:
 104         raise Exception("No PD failure reported")
 105
 106 def test_discovery_group_client(dev):
 107     """P2P device discovery for a client in a group"""
 108     logger.info("Start autonomous GO " + dev[0].ifname)
 109     res = dev[0].p2p_start_go(freq="2422")
 110     logger.debug("res: " + str(res))
 111     logger.info("Connect a client to the GO")
 112     pin = dev[1].wps_read_pin()
 113     dev[0].p2p_go_authorize_client(pin)
 114     dev[1].p2p_connect_group(dev[0].p2p_dev_addr(), pin, timeout=60)
 115     logger.info("Client connected")
 116     hwsim_utils.test_connectivity_p2p(dev[0], dev[1])
 117     logger.info("Try to discover a P2P client in a group")
 118     if not dev[2].discover_peer(dev[1].p2p_dev_addr(), social=False, timeout=10):
 119         if not dev[2].discover_peer(dev[1].p2p_dev_addr(), social=False, timeout=10):
 120             if not dev[2].discover_peer(dev[1].p2p_dev_addr(), social=False, timeout=10):
 121                 raise Exception("Could not discover group client")
 122
 123     # This is not really perfect, but something to get a bit more testing
 124     # coverage.. For proper discoverability mechanism validation, the P2P
 125     # client would need to go to sleep to avoid acknowledging the GO Negotiation
 126     # Request frame. Offchannel Listen mode operation on the P2P Client with
 127     # mac80211_hwsim is apparently not enough to avoid the acknowledgement on
 128     # the operating channel, so need to disconnect from the group which removes
 129     # the GO-to-P2P Client part of the discoverability exchange in practice.
 130
 131     pin = dev[2].wps_read_pin()
 132     # make group client non-responsive on operating channel
 133     dev[1].dump_monitor()
 134     dev[1].group_request("DISCONNECT")
 135     dev[1].wait_disconnected(timeout=10)
 136     dev[2].request("P2P_CONNECT {} {} display".format(dev[1].p2p_dev_addr(),
 137                                                       pin))
 138     ev = dev[1].wait_event(["P2P-GO-NEG-REQUEST"], timeout=2)
 139     if ev:
 140         raise Exception("Unexpected frame RX on P2P client")
 141     # make group client available on operating channe
 142     dev[1].request("REASSOCIATE")
 143     ev = dev[1].wait_event(["CTRL-EVENT-CONNECTED", "P2P-GO-NEG-REQUEST"])
 144     if ev is None:
 145         raise Exception("Timeout on reconnection to group")
 146     if "P2P-GO-NEG-REQUEST" not in ev:
 147         ev = dev[1].wait_event(["P2P-GO-NEG-REQUEST"])
 148         if ev is None:
 149             raise Exception("Timeout on waiting for GO Negotiation Request")
 150
 151 def test_discovery_dev_type(dev):
 152     """P2P device discovery with Device Type filter"""
 153     dev[1].request("SET sec_device_type 1-0050F204-2")
 154     dev[1].p2p_listen()
 155     dev[0].p2p_find(social=True, dev_type="5-0050F204-1")
 156     ev = dev[0].wait_event(['P2P-DEVICE-FOUND'], timeout=1)
 157     if ev:
 158         raise Exception("Unexpected P2P device found")
 159     dev[0].p2p_find(social=True, dev_type="1-0050F204-2")
 160     ev = dev[0].wait_event(['P2P-DEVICE-FOUND'], timeout=2)
 161     if ev is None:
 162         raise Exception("P2P device not found")
 163     peer = dev[0].get_peer(dev[1].p2p_dev_addr())
 164     if "1-0050F204-2" not in peer['sec_dev_type']:
 165         raise Exception("sec_device_type not reported properly")
 166
 167 def test_discovery_dev_type_go(dev):
 168     """P2P device discovery with Device Type filter on GO"""
 169     addr1 = dev[1].p2p_dev_addr()
 170     dev[1].request("SET sec_device_type 1-0050F204-2")
 171     res = dev[0].p2p_start_go(freq="2412")
 172     pin = dev[1].wps_read_pin()
 173     dev[0].p2p_go_authorize_client(pin)
 174     dev[1].p2p_connect_group(dev[0].p2p_dev_addr(), pin, timeout=60)
 175
 176     dev[2].p2p_find(social=True, dev_type="5-0050F204-1")
 177     ev = dev[2].wait_event(['P2P-DEVICE-FOUND'], timeout=1)
 178     if ev:
 179         raise Exception("Unexpected P2P device found")
 180     dev[2].p2p_find(social=True, dev_type="1-0050F204-2")
 181     ev = dev[2].wait_event(['P2P-DEVICE-FOUND ' + addr1], timeout=2)
 182     if ev is None:
 183         raise Exception("P2P device not found")
 184
 185 def test_discovery_dev_id(dev):
 186     """P2P device discovery with Device ID filter"""
 187     wpas = WpaSupplicant(global_iface='/tmp/wpas-wlan5')
 188     wpas.interface_add("wlan5")
 189     wpas.request("P2P_LISTEN 1")
 190     status = wpas.global_request("STATUS")
 191     if "p2p_state=LISTEN_ONLY" not in status:
 192         raise Exception("Unexpected status: " + status)
 193     addr1 = dev[1].p2p_dev_addr()
 194     dev[1].p2p_listen()
 195     dev[0].p2p_find(social=True, dev_id="02:03:04:05:06:07")
 196     ev = dev[0].wait_event(['P2P-DEVICE-FOUND'], timeout=1)
 197     if ev:
 198         raise Exception("Unexpected P2P device found")
 199     dev[0].p2p_find(social=True, dev_id=addr1)
 200     ev = dev[0].wait_event(['P2P-DEVICE-FOUND'], timeout=2)
 201     if ev is None:
 202         raise Exception("P2P device not found")
 203     if addr1 not in ev:
 204         raise Exception("Unexpected P2P peer found")
 205     status = wpas.global_request("STATUS")
 206     for i in range(0, 2):
 207         if "p2p_state=IDLE" in status:
 208             break
 209         time.sleep(0.5)
 210         status = wpas.global_request("STATUS")
 211     if "p2p_state=IDLE" not in status:
 212         raise Exception("Unexpected status: " + status)
 213
 214 def test_discovery_dev_id_go(dev):
 215     """P2P device discovery with Device ID filter on GO"""
 216     addr1 = dev[1].p2p_dev_addr()
 217     res = dev[0].p2p_start_go(freq="2412")
 218     pin = dev[1].wps_read_pin()
 219     dev[0].p2p_go_authorize_client(pin)
 220     dev[1].p2p_connect_group(dev[0].p2p_dev_addr(), pin, timeout=60)
 221
 222     dev[2].p2p_find(social=True, dev_id="02:03:04:05:06:07")
 223     ev = dev[2].wait_event(['P2P-DEVICE-FOUND'], timeout=1)
 224     if ev:
 225         raise Exception("Unexpected P2P device found")
 226     dev[2].p2p_find(social=True, dev_id=addr1)
 227     ev = dev[2].wait_event(['P2P-DEVICE-FOUND ' + addr1], timeout=2)
 228     if ev is None:
 229         raise Exception("P2P device not found")
 230
 231 def test_discovery_social_plus_one(dev):
 232     """P2P device discovery with social-plus-one"""
 233     logger.info("Start autonomous GO " + dev[0].ifname)
 234     dev[1].p2p_find(social=True)
 235     dev[0].p2p_find(progressive=True)
 236     logger.info("Wait for initial progressive find phases")
 237     dev[0].wait_event(["CTRL-EVENT-SCAN-STARTED"])
 238     dev[0].wait_event(["CTRL-EVENT-SCAN-STARTED"])
 239     go = dev[2].p2p_dev_addr()
 240     dev[2].p2p_start_go(freq="2422")
 241     logger.info("Verify whether the GO on non-social channel can be found")
 242     ev = dev[0].wait_global_event(["P2P-DEVICE-FOUND"], timeout=15)
 243     if ev is None:
 244         raise Exception("Peer not found")
 245     if go not in ev:
 246         ev = dev[0].wait_global_event(["P2P-DEVICE-FOUND"], timeout=15)
 247         if ev is None:
 248             raise Exception("Peer not found")
 249     ev = dev[1].wait_global_event(["P2P-DEVICE-FOUND"], timeout=15)
 250     if ev is None:
 251         raise Exception("Peer not found")
 252     dev[0].p2p_stop_find()
 253     dev[1].p2p_stop_find()
 254     if not dev[0].peer_known(go):
 255         raise Exception("GO not found in progressive scan")
 256     if dev[1].peer_known(go):
 257         raise Exception("GO found in social-only scan")
 258
 259 def test_discovery_and_interface_disabled(dev):
 260     """P2P device discovery with interface getting didabled"""
 261     try:
 262         if "OK" not in dev[0].p2p_find():
 263             raise Exception("Failed to start P2P find")
 264         ev = dev[0].wait_event(["CTRL-EVENT-SCAN-STARTED"])
 265         if ev is None:
 266             raise Exception("Scan did not start")
 267         dev[0].request("DRIVER_EVENT INTERFACE_DISABLED")
 268         time.sleep(1)
 269
 270         # verify that P2P_FIND is rejected
 271         if "FAIL" not in dev[0].p2p_find():
 272             raise Exception("New P2P_FIND request was accepted unexpectedly")
 273
 274         dev[0].request("DRIVER_EVENT INTERFACE_ENABLED")
 275         time.sleep(3)
 276         dev[0].scan(freq="2412")
 277         if "OK" not in dev[0].p2p_find():
 278             raise Exception("Failed to start P2P find")
 279         dev[0].dump_monitor()
 280         dev[1].p2p_listen()
 281         ev = dev[0].wait_global_event(["P2P-DEVICE-FOUND"], timeout=15)
 282         if ev is None:
 283             raise Exception("Peer not found")
 284     finally:
 285         dev[0].request("DRIVER_EVENT INTERFACE_ENABLED")
 286
 287 def test_discovery_auto(dev):
 288     """P2P device discovery and provision discovery with auto GO/dev selection"""
 289     addr0 = dev[0].p2p_dev_addr()
 290     addr1 = dev[1].p2p_dev_addr()
 291     addr2 = dev[2].p2p_dev_addr()
 292     dev[2].p2p_start_go(freq="2412")
 293     logger.info("Start device discovery")
 294     dev[0].p2p_listen()
 295     if not dev[1].discover_peer(addr0):
 296         raise Exception("Device discovery timed out")
 297     dev[1].p2p_listen()
 298     if not dev[0].discover_peer(addr1):
 299         raise Exception("Device discovery timed out")
 300     if not dev[0].discover_peer(addr2):
 301         raise Exception("Device discovery timed out")
 302
 303     logger.info("Test provision discovery for display (device)")
 304     dev[0].global_request("P2P_PROV_DISC " + addr1 + " display auto")
 305     ev1 = dev[1].wait_global_event(["P2P-PROV-DISC-SHOW-PIN"], timeout=15)
 306     if ev1 is None:
 307         raise Exception("Provision discovery timed out (display/dev1)")
 308     if addr0 not in ev1:
 309         raise Exception("Dev0 not in provision discovery event")
 310     if " group=" in ev1:
 311         raise Exception("Unexpected group parameter from non-GO")
 312     ev0 = dev[0].wait_global_event(["P2P-PROV-DISC-ENTER-PIN",
 313                                     "P2P-PROV-DISC-FAILURE"], timeout=15)
 314     if ev0 is None:
 315         raise Exception("Provision discovery timed out (display/dev0)")
 316     if "P2P-PROV-DISC-FAILURE" in ev0:
 317         raise Exception("Provision discovery failed (display/dev0)")
 318     if addr1 not in ev0:
 319         raise Exception("Dev1 not in provision discovery event")
 320     if "peer_go=0" not in ev0:
 321         raise Exception("peer_go incorrect in PD response from non-GO")
 322
 323     logger.info("Test provision discovery for display (GO)")
 324     dev[0].global_request("P2P_PROV_DISC " + addr2 + " display auto")
 325     ev2 = dev[2].wait_global_event(["P2P-PROV-DISC-SHOW-PIN"], timeout=15)
 326     if ev2 is None:
 327         raise Exception("Provision discovery timed out (display/dev2)")
 328     if addr0 not in ev2:
 329         raise Exception("Dev0 not in provision discovery event")
 330     if " group=" not in ev2:
 331         raise Exception("Group parameter missing from GO")
 332     ev0 = dev[0].wait_global_event(["P2P-PROV-DISC-ENTER-PIN",
 333                                     "P2P-PROV-DISC-FAILURE"], timeout=15)
 334     if ev0 is None:
 335         raise Exception("Provision discovery timed out (display/dev0)")
 336     if "P2P-PROV-DISC-FAILURE" in ev0:
 337         raise Exception("Provision discovery failed (display/dev0)")
 338     if addr2 not in ev0:
 339         raise Exception("Dev1 not in provision discovery event")
 340     if "peer_go=1" not in ev0:
 341         raise Exception("peer_go incorrect in PD response from GO")
 342
 343 def test_discovery_stop(dev):
 344     """P2P device discovery and p2p_stop_find"""
 345     addr0 = dev[0].p2p_dev_addr()
 346     addr1 = dev[1].p2p_dev_addr()
 347     dev[1].p2p_listen()
 348     dev[2].p2p_listen()
 349
 350     dev[0].p2p_find(social=False)
 351     ev = dev[0].wait_event(["CTRL-EVENT-SCAN-STARTED"], timeout=0.5)
 352     if ev is None:
 353         logger.info("No CTRL-EVENT-SCAN-STARTED event")
 354     dev[0].p2p_stop_find()
 355     ev = dev[0].wait_global_event(["P2P-FIND-STOPPED"], timeout=1)
 356     if ev is None:
 357         raise Exception("P2P_STOP not reported")
 358     ev = dev[0].wait_global_event(["P2P-DEVICE-FOUND"], timeout=5)
 359     if ev is not None:
 360         raise Exception("Peer found unexpectedly: " + ev)
 361
 362     dev[0].p2p_find(social=False)
 363     ev = dev[0].wait_event(["CTRL-EVENT-SCAN-STARTED"], timeout=0.5)
 364     if ev is None:
 365         logger.info("No CTRL-EVENT-SCAN-STARTED event")
 366     dev[0].request("P2P_FLUSH")
 367     ev = dev[0].wait_global_event(["P2P-FIND-STOPPED"], timeout=1)
 368     if ev is None:
 369         raise Exception("P2P_STOP not reported")
 370     ev = dev[0].wait_global_event(["P2P-DEVICE-FOUND"], timeout=5)
 371     if ev is not None:
 372         raise Exception("Peer found unexpectedly: " + ev)
 373
 374 def test_p2p_peer_command(dev):
 375     """P2P_PEER command"""
 376     addr0 = dev[0].p2p_dev_addr()
 377     addr1 = dev[1].p2p_dev_addr()
 378     addr2 = dev[2].p2p_dev_addr()
 379     dev[1].p2p_listen()
 380     dev[2].p2p_listen()
 381     if not dev[0].discover_peer(addr1):
 382         raise Exception("Device discovery timed out")
 383     if not dev[0].discover_peer(addr2):
 384         raise Exception("Device discovery timed out")
 385     dev[0].p2p_stop_find()
 386     dev[1].p2p_stop_find()
 387     dev[2].p2p_stop_find()
 388
 389     res0 = dev[0].request("P2P_PEER FIRST")
 390     peer = res0.splitlines()[0]
 391     if peer not in [ addr1, addr2 ]:
 392         raise Exception("Unexpected P2P_PEER FIRST address")
 393     res1 = dev[0].request("P2P_PEER NEXT-" + peer)
 394     peer2 = res1.splitlines()[0]
 395     if peer2 not in [ addr1, addr2 ] or peer == peer2:
 396         raise Exception("Unexpected P2P_PEER NEXT address")
 397
 398     if "FAIL" not in dev[0].request("P2P_PEER NEXT-foo"):
 399         raise Exception("Invalid P2P_PEER command accepted")
 400     if "FAIL" not in dev[0].request("P2P_PEER foo"):
 401         raise Exception("Invalid P2P_PEER command accepted")
 402     if "FAIL" not in dev[0].request("P2P_PEER 00:11:22:33:44:55"):
 403         raise Exception("P2P_PEER command for unknown peer accepted")
 404
 405 def test_p2p_listen_and_offchannel_tx(dev):
 406     """P2P_LISTEN behavior with offchannel TX"""
 407     addr0 = dev[0].p2p_dev_addr()
 408     addr1 = dev[1].p2p_dev_addr()
 409     addr2 = dev[2].p2p_dev_addr()
 410
 411     dev[1].p2p_listen()
 412     if not dev[0].discover_peer(addr1):
 413         raise Exception("Device discovery timed out")
 414
 415     dev[0].p2p_listen()
 416     dev[0].global_request("P2P_PROV_DISC " + addr1 + " display")
 417     ev = dev[0].wait_event(["P2P-PROV-DISC-ENTER-PIN"], timeout=15)
 418     if ev is None:
 419         raise Exception("No PD result reported")
 420     dev[1].p2p_stop_find()
 421
 422     if not dev[2].discover_peer(addr0):
 423         raise Exception("Device discovery timed out after PD exchange")
 424     dev[2].p2p_stop_find()
 425     dev[0].p2p_stop_find()
 426
 427 def test_p2p_listen_and_scan(dev):
 428     """P2P_LISTEN and scan"""
 429     dev[0].p2p_listen()
 430     if "OK" not in dev[0].request("SCAN freq=2412"):
 431         raise Exception("Failed to request a scan")
 432     ev = dev[0].wait_event(["CTRL-EVENT-SCAN-RESULTS"], 3)
 433     if ev is not None:
 434         raise Exception("Unexpected scan results")
 435     dev[0].p2p_stop_find()
 436     ev = dev[0].wait_event(["CTRL-EVENT-SCAN-RESULTS"], 15)
 437     if ev is None:
 438         raise Exception("Scan timed out")