libeap/tests/hwsim/test_p2p_channel.py

   1 # P2P channel selection test cases
   2 # Copyright (c) 2014, 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 os
  10 import subprocess
  11 import time
  12
  13 import hostapd
  14 import hwsim_utils
  15 from utils import HwsimSkip
  16 from tshark import run_tshark
  17 from wpasupplicant import WpaSupplicant
  18 from hwsim import HWSimRadio
  19 from test_p2p_grpform import go_neg_pin_authorized
  20 from test_p2p_grpform import check_grpform_results
  21 from test_p2p_grpform import remove_group
  22 from test_p2p_grpform import go_neg_pbc
  23 from test_p2p_autogo import autogo
  24
  25 def set_country(country, dev=None):
  26     subprocess.call(['iw', 'reg', 'set', country])
  27     time.sleep(0.1)
  28     if dev:
  29         for i in range(10):
  30             ev = dev.wait_global_event(["CTRL-EVENT-REGDOM-CHANGE"], timeout=15)
  31             if ev is None:
  32                 raise Exception("No regdom change event seen")
  33             if "type=COUNTRY alpha2=" + country in ev:
  34                 return
  35         raise Exception("No matching regdom event seen for set_country(%s)" % country)
  36
  37 def test_p2p_channel_5ghz(dev):
  38     """P2P group formation with 5 GHz preference"""
  39     try:
  40         set_country("US", dev[0])
  41         [i_res, r_res] = go_neg_pin_authorized(i_dev=dev[0], i_intent=15,
  42                                                r_dev=dev[1], r_intent=0,
  43                                                test_data=False)
  44         check_grpform_results(i_res, r_res)
  45         freq = int(i_res['freq'])
  46         if freq < 5000:
  47             raise Exception("Unexpected channel %d MHz - did not follow 5 GHz preference" % freq)
  48         remove_group(dev[0], dev[1])
  49     finally:
  50         set_country("00")
  51         dev[1].flush_scan_cache()
  52
  53 def test_p2p_channel_5ghz_no_vht(dev):
  54     """P2P group formation with 5 GHz preference when VHT channels are disallowed"""
  55     try:
  56         set_country("US", dev[0])
  57         dev[0].request("P2P_SET disallow_freq 5180-5240")
  58         [i_res, r_res] = go_neg_pin_authorized(i_dev=dev[0], i_intent=15,
  59                                                r_dev=dev[1], r_intent=0,
  60                                                test_data=False)
  61         check_grpform_results(i_res, r_res)
  62         freq = int(i_res['freq'])
  63         if freq < 5000:
  64             raise Exception("Unexpected channel %d MHz - did not follow 5 GHz preference" % freq)
  65         remove_group(dev[0], dev[1])
  66     finally:
  67         set_country("00")
  68         dev[0].request("P2P_SET disallow_freq ")
  69         dev[1].flush_scan_cache()
  70
  71 def test_p2p_channel_random_social(dev):
  72     """P2P group formation with 5 GHz preference but all 5 GHz channels disabled"""
  73     try:
  74         set_country("US", dev[0])
  75         dev[0].request("SET p2p_oper_channel 11")
  76         dev[0].request("P2P_SET disallow_freq 5000-6000,2462")
  77         [i_res, r_res] = go_neg_pin_authorized(i_dev=dev[0], i_intent=15,
  78                                                r_dev=dev[1], r_intent=0,
  79                                                test_data=False)
  80         check_grpform_results(i_res, r_res)
  81         freq = int(i_res['freq'])
  82         if freq not in [ 2412, 2437, 2462 ]:
  83             raise Exception("Unexpected channel %d MHz - did not pick random social channel" % freq)
  84         remove_group(dev[0], dev[1])
  85     finally:
  86         set_country("00")
  87         dev[0].request("P2P_SET disallow_freq ")
  88         dev[1].flush_scan_cache()
  89
  90 def test_p2p_channel_random(dev):
  91     """P2P group formation with 5 GHz preference but all 5 GHz channels and all social channels disabled"""
  92     try:
  93         set_country("US", dev[0])
  94         dev[0].request("SET p2p_oper_channel 11")
  95         dev[0].request("P2P_SET disallow_freq 5000-6000,2412,2437,2462")
  96         [i_res, r_res] = go_neg_pin_authorized(i_dev=dev[0], i_intent=15,
  97                                                r_dev=dev[1], r_intent=0,
  98                                                test_data=False)
  99         check_grpform_results(i_res, r_res)
 100         freq = int(i_res['freq'])
 101         if freq > 2500 or freq in [ 2412, 2437, 2462 ]:
 102             raise Exception("Unexpected channel %d MHz" % freq)
 103         remove_group(dev[0], dev[1])
 104     finally:
 105         set_country("00")
 106         dev[0].request("P2P_SET disallow_freq ")
 107         dev[1].flush_scan_cache()
 108
 109 def test_p2p_channel_random_social_with_op_class_change(dev, apdev, params):
 110     """P2P group formation using random social channel with oper class change needed"""
 111     try:
 112         set_country("US", dev[0])
 113         logger.info("Start group on 5 GHz")
 114         [i_res, r_res] = go_neg_pin_authorized(i_dev=dev[0], i_intent=15,
 115                                                r_dev=dev[1], r_intent=0,
 116                                                test_data=False)
 117         check_grpform_results(i_res, r_res)
 118         freq = int(i_res['freq'])
 119         if freq < 5000:
 120             raise Exception("Unexpected channel %d MHz - did not pick 5 GHz preference" % freq)
 121         remove_group(dev[0], dev[1])
 122
 123         logger.info("Disable 5 GHz and try to re-start group based on 5 GHz preference")
 124         dev[0].request("SET p2p_oper_reg_class 115")
 125         dev[0].request("SET p2p_oper_channel 36")
 126         dev[0].request("P2P_SET disallow_freq 5000-6000")
 127         [i_res, r_res] = go_neg_pin_authorized(i_dev=dev[0], i_intent=15,
 128                                                r_dev=dev[1], r_intent=0,
 129                                                test_data=False)
 130         check_grpform_results(i_res, r_res)
 131         freq = int(i_res['freq'])
 132         if freq not in [ 2412, 2437, 2462 ]:
 133             raise Exception("Unexpected channel %d MHz - did not pick random social channel" % freq)
 134         remove_group(dev[0], dev[1])
 135
 136         out = run_tshark(os.path.join(params['logdir'], "hwsim0.pcapng"),
 137                          "wifi_p2p.public_action.subtype == 0")
 138         if out is not None:
 139             last = None
 140             for l in out.splitlines():
 141                 if "Operating Channel:" not in l:
 142                     continue
 143                 last = l
 144             if last is None:
 145                 raise Exception("Could not find GO Negotiation Request")
 146             if "Operating Class 81" not in last:
 147                 raise Exception("Unexpected operating class: " + last.strip())
 148     finally:
 149         set_country("00")
 150         dev[0].request("P2P_SET disallow_freq ")
 151         dev[0].request("SET p2p_oper_reg_class 0")
 152         dev[0].request("SET p2p_oper_channel 0")
 153         dev[1].flush_scan_cache()
 154
 155 def test_p2p_channel_avoid(dev):
 156     """P2P and avoid frequencies driver event"""
 157     try:
 158         set_country("US", dev[0])
 159         if "OK" not in dev[0].request("DRIVER_EVENT AVOID_FREQUENCIES 5000-6000,2412,2437,2462"):
 160             raise Exception("Could not simulate driver event")
 161         ev = dev[0].wait_event(["CTRL-EVENT-AVOID-FREQ"], timeout=10)
 162         if ev is None:
 163             raise Exception("No CTRL-EVENT-AVOID-FREQ event")
 164         [i_res, r_res] = go_neg_pin_authorized(i_dev=dev[0], i_intent=15,
 165                                                r_dev=dev[1], r_intent=0,
 166                                                test_data=False)
 167         check_grpform_results(i_res, r_res)
 168         freq = int(i_res['freq'])
 169         if freq > 2500 or freq in [ 2412, 2437, 2462 ]:
 170             raise Exception("Unexpected channel %d MHz" % freq)
 171
 172         if "OK" not in dev[0].request("DRIVER_EVENT AVOID_FREQUENCIES"):
 173             raise Exception("Could not simulate driver event(2)")
 174         ev = dev[0].wait_event(["CTRL-EVENT-AVOID-FREQ"], timeout=10)
 175         if ev is None:
 176             raise Exception("No CTRL-EVENT-AVOID-FREQ event")
 177         ev = dev[0].wait_group_event(["P2P-REMOVE-AND-REFORM-GROUP"], timeout=1)
 178         if ev is not None:
 179             raise Exception("Unexpected P2P-REMOVE-AND-REFORM-GROUP event")
 180
 181         if "OK" not in dev[0].request("DRIVER_EVENT AVOID_FREQUENCIES " + str(freq)):
 182             raise Exception("Could not simulate driver event(3)")
 183         ev = dev[0].wait_event(["CTRL-EVENT-AVOID-FREQ"], timeout=10)
 184         if ev is None:
 185             raise Exception("No CTRL-EVENT-AVOID-FREQ event")
 186         ev = dev[0].wait_group_event(["P2P-REMOVE-AND-REFORM-GROUP"],
 187                                      timeout=10)
 188         if ev is None:
 189             raise Exception("No P2P-REMOVE-AND-REFORM-GROUP event")
 190     finally:
 191         set_country("00")
 192         dev[0].request("DRIVER_EVENT AVOID_FREQUENCIES")
 193         dev[1].flush_scan_cache()
 194
 195 def test_autogo_following_bss(dev, apdev):
 196     """P2P autonomous GO operate on the same channel as station interface"""
 197     if dev[0].get_mcc() > 1:
 198         logger.info("test mode: MCC")
 199
 200     dev[0].request("SET p2p_no_group_iface 0")
 201
 202     channels = { 3 : "2422", 5 : "2432", 9 : "2452" }
 203     for key in channels:
 204         hapd = hostapd.add_ap(apdev[0]['ifname'], { "ssid" : 'ap-test',
 205                                                     "channel" : str(key) })
 206         dev[0].connect("ap-test", key_mgmt="NONE",
 207                        scan_freq=str(channels[key]))
 208         res_go = autogo(dev[0])
 209         if res_go['freq'] != channels[key]:
 210             raise Exception("Group operation channel is not the same as on connected station interface")
 211         hwsim_utils.test_connectivity(dev[0], hapd)
 212         dev[0].remove_group(res_go['ifname'])
 213
 214 def test_go_neg_with_bss_connected(dev, apdev):
 215     """P2P channel selection: GO negotiation when station interface is connected"""
 216
 217     dev[0].flush_scan_cache()
 218     dev[1].flush_scan_cache()
 219     dev[0].request("SET p2p_no_group_iface 0")
 220
 221     hapd = hostapd.add_ap(apdev[0]['ifname'],
 222                           { "ssid": 'bss-2.4ghz', "channel": '5' })
 223     dev[0].connect("bss-2.4ghz", key_mgmt="NONE", scan_freq="2432")
 224     #dev[0] as GO
 225     [i_res, r_res] = go_neg_pbc(i_dev=dev[0], i_intent=10, r_dev=dev[1],
 226                                 r_intent=1)
 227     check_grpform_results(i_res, r_res)
 228     if i_res['role'] != "GO":
 229        raise Exception("GO not selected according to go_intent")
 230     if i_res['freq'] != "2432":
 231        raise Exception("Group formed on a different frequency than BSS")
 232     hwsim_utils.test_connectivity(dev[0], hapd)
 233     dev[0].remove_group(i_res['ifname'])
 234     dev[1].wait_go_ending_session()
 235
 236     if dev[0].get_mcc() > 1:
 237         logger.info("Skip as-client case due to MCC being enabled")
 238         return;
 239
 240     #dev[0] as client
 241     [i_res2, r_res2] = go_neg_pbc(i_dev=dev[0], i_intent=1, r_dev=dev[1],
 242                                   r_intent=10)
 243     check_grpform_results(i_res2, r_res2)
 244     if i_res2['role'] != "client":
 245        raise Exception("GO not selected according to go_intent")
 246     if i_res2['freq'] != "2432":
 247        raise Exception("Group formed on a different frequency than BSS")
 248     hwsim_utils.test_connectivity(dev[0], hapd)
 249     dev[1].remove_group(r_res2['ifname'])
 250     dev[0].wait_go_ending_session()
 251     dev[0].request("DISCONNECT")
 252     hapd.disable()
 253     dev[0].flush_scan_cache()
 254     dev[1].flush_scan_cache()
 255
 256 def test_autogo_with_bss_on_disallowed_chan(dev, apdev):
 257     """P2P channel selection: Autonomous GO with BSS on a disallowed channel"""
 258
 259     with HWSimRadio(n_channels=2) as (radio, iface):
 260         wpas = WpaSupplicant(global_iface='/tmp/wpas-wlan5')
 261         wpas.interface_add(iface)
 262
 263         wpas.request("SET p2p_no_group_iface 0")
 264
 265         if wpas.get_mcc() < 2:
 266            raise Exception("New radio does not support MCC")
 267
 268         try:
 269             hapd = hostapd.add_ap(apdev[0]['ifname'], { "ssid": 'bss-2.4ghz',
 270                                                         "channel": '1' })
 271             wpas.request("P2P_SET disallow_freq 2412")
 272             wpas.connect("bss-2.4ghz", key_mgmt="NONE", scan_freq="2412")
 273             res = autogo(wpas)
 274             if res['freq'] == "2412":
 275                raise Exception("GO set on a disallowed channel")
 276             hwsim_utils.test_connectivity(wpas, hapd)
 277         finally:
 278             wpas.request("P2P_SET disallow_freq ")
 279
 280 def test_go_neg_with_bss_on_disallowed_chan(dev, apdev):
 281     """P2P channel selection: GO negotiation with station interface on a disallowed channel"""
 282
 283     with HWSimRadio(n_channels=2) as (radio, iface):
 284         wpas = WpaSupplicant(global_iface='/tmp/wpas-wlan5')
 285         wpas.interface_add(iface)
 286
 287         wpas.request("SET p2p_no_group_iface 0")
 288
 289         if wpas.get_mcc() < 2:
 290            raise Exception("New radio does not support MCC")
 291
 292         try:
 293             hapd = hostapd.add_ap(apdev[0]['ifname'],
 294                                   { "ssid": 'bss-2.4ghz', "channel": '1' })
 295             # make sure PBC overlap from old test cases is not maintained
 296             dev[1].flush_scan_cache()
 297             wpas.connect("bss-2.4ghz", key_mgmt="NONE", scan_freq="2412")
 298             wpas.request("P2P_SET disallow_freq 2412")
 299
 300             #wpas as GO
 301             [i_res, r_res] = go_neg_pbc(i_dev=wpas, i_intent=10, r_dev=dev[1],
 302                                         r_intent=1)
 303             check_grpform_results(i_res, r_res)
 304             if i_res['role'] != "GO":
 305                raise Exception("GO not selected according to go_intent")
 306             if i_res['freq'] == "2412":
 307                raise Exception("Group formed on a disallowed channel")
 308             hwsim_utils.test_connectivity(wpas, hapd)
 309             wpas.remove_group(i_res['ifname'])
 310             dev[1].wait_go_ending_session()
 311             dev[1].flush_scan_cache()
 312
 313             wpas.dump_monitor()
 314             dev[1].dump_monitor()
 315
 316             #wpas as client
 317             [i_res2, r_res2] = go_neg_pbc(i_dev=wpas, i_intent=1, r_dev=dev[1],
 318                                           r_intent=10)
 319             check_grpform_results(i_res2, r_res2)
 320             if i_res2['role'] != "client":
 321                raise Exception("GO not selected according to go_intent")
 322             if i_res2['freq'] == "2412":
 323                raise Exception("Group formed on a disallowed channel")
 324             hwsim_utils.test_connectivity(wpas, hapd)
 325             dev[1].remove_group(r_res2['ifname'])
 326             wpas.wait_go_ending_session()
 327             ev = dev[1].wait_global_event(["P2P-GROUP-REMOVED"], timeout=5)
 328             if ev is None:
 329                 raise Exception("Group removal not indicated")
 330             wpas.request("DISCONNECT")
 331             hapd.disable()
 332         finally:
 333             wpas.request("P2P_SET disallow_freq ")
 334
 335 def test_autogo_force_diff_channel(dev, apdev):
 336     """P2P autonomous GO and station interface operate on different channels"""
 337     with HWSimRadio(n_channels=2) as (radio, iface):
 338         wpas = WpaSupplicant(global_iface='/tmp/wpas-wlan5')
 339         wpas.interface_add(iface)
 340
 341         if wpas.get_mcc() < 2:
 342            raise Exception("New radio does not support MCC")
 343
 344         wpas.request("SET p2p_no_group_iface 0")
 345
 346         hapd = hostapd.add_ap(apdev[0]['ifname'],
 347                               {"ssid" : 'ap-test', "channel" : '1'})
 348         wpas.connect("ap-test", key_mgmt = "NONE", scan_freq = "2412")
 349         channels = { 2 : 2417, 5 : 2432, 9 : 2452 }
 350         for key in channels:
 351             res_go = autogo(wpas, channels[key])
 352             hwsim_utils.test_connectivity(wpas, hapd)
 353             if int(res_go['freq']) == 2412:
 354                 raise Exception("Group operation channel is: 2412 excepted: " + res_go['freq'])
 355             wpas.remove_group(res_go['ifname'])
 356
 357 def test_go_neg_forced_freq_diff_than_bss_freq(dev, apdev):
 358     """P2P channel selection: GO negotiation with forced freq different than station interface"""
 359     with HWSimRadio(n_channels=2) as (radio, iface):
 360         wpas = WpaSupplicant(global_iface='/tmp/wpas-wlan5')
 361         wpas.interface_add(iface)
 362
 363         if wpas.get_mcc() < 2:
 364            raise Exception("New radio does not support MCC")
 365
 366         # Clear possible PBC session overlap from previous test case
 367         dev[1].flush_scan_cache()
 368
 369         wpas.request("SET p2p_no_group_iface 0")
 370
 371         hapd = hostapd.add_ap(apdev[0]['ifname'],
 372                               { "country_code": 'US',
 373                                 "ssid": 'bss-5ghz', "hw_mode": 'a',
 374                                 "channel": '40' })
 375         wpas.connect("bss-5ghz", key_mgmt="NONE", scan_freq="5200")
 376
 377         # GO and peer force the same freq, different than BSS freq,
 378         # wpas to become GO
 379         [i_res, r_res] = go_neg_pbc(i_dev=dev[1], i_intent=1, i_freq=5180,
 380                                     r_dev=wpas, r_intent=14, r_freq=5180)
 381         check_grpform_results(i_res, r_res)
 382         if i_res['freq'] != "5180":
 383            raise Exception("P2P group formed on unexpected frequency: " + i_res['freq'])
 384         if r_res['role'] != "GO":
 385            raise Exception("GO not selected according to go_intent")
 386         hwsim_utils.test_connectivity(wpas, hapd)
 387         wpas.remove_group(r_res['ifname'])
 388         dev[1].wait_go_ending_session()
 389         dev[1].flush_scan_cache()
 390
 391         # GO and peer force the same freq, different than BSS freq, wpas to
 392         # become client
 393         [i_res2, r_res2] = go_neg_pbc(i_dev=dev[1], i_intent=14, i_freq=2422,
 394                                       r_dev=wpas, r_intent=1, r_freq=2422)
 395         check_grpform_results(i_res2, r_res2)
 396         if i_res2['freq'] != "2422":
 397            raise Exception("P2P group formed on unexpected frequency: " + i_res2['freq'])
 398         if r_res2['role'] != "client":
 399            raise Exception("GO not selected according to go_intent")
 400         hwsim_utils.test_connectivity(wpas, hapd)
 401
 402         wpas.request("DISCONNECT")
 403         hapd.request("DISABLE")
 404         subprocess.call(['iw', 'reg', 'set', '00'])
 405         wpas.flush_scan_cache()
 406
 407 def test_go_pref_chan_bss_on_diff_chan(dev, apdev):
 408     """P2P channel selection: Station on different channel than GO configured pref channel"""
 409
 410     dev[0].request("SET p2p_no_group_iface 0")
 411
 412     try:
 413         hapd = hostapd.add_ap(apdev[0]['ifname'], { "ssid": 'bss-2.4ghz',
 414                                                     "channel": '1' })
 415         dev[0].request("SET p2p_pref_chan 81:2")
 416         dev[0].connect("bss-2.4ghz", key_mgmt="NONE", scan_freq="2412")
 417         res = autogo(dev[0])
 418         if res['freq'] != "2412":
 419            raise Exception("GO channel did not follow BSS")
 420         hwsim_utils.test_connectivity(dev[0], hapd)
 421     finally:
 422         dev[0].request("SET p2p_pref_chan ")
 423
 424 def test_go_pref_chan_bss_on_disallowed_chan(dev, apdev):
 425     """P2P channel selection: Station interface on different channel than GO configured pref channel, and station channel is disallowed"""
 426     with HWSimRadio(n_channels=2) as (radio, iface):
 427         wpas = WpaSupplicant(global_iface='/tmp/wpas-wlan5')
 428         wpas.interface_add(iface)
 429
 430         if wpas.get_mcc() < 2:
 431            raise Exception("New radio does not support MCC")
 432
 433         wpas.request("SET p2p_no_group_iface 0")
 434
 435         try:
 436             hapd = hostapd.add_ap(apdev[0]['ifname'], { "ssid": 'bss-2.4ghz',
 437                                                         "channel": '1' })
 438             wpas.request("P2P_SET disallow_freq 2412")
 439             wpas.request("SET p2p_pref_chan 81:2")
 440             wpas.connect("bss-2.4ghz", key_mgmt="NONE", scan_freq="2412")
 441             res2 = autogo(wpas)
 442             if res2['freq'] != "2417":
 443                raise Exception("GO channel did not follow pref_chan configuration")
 444             hwsim_utils.test_connectivity(wpas, hapd)
 445         finally:
 446             wpas.request("P2P_SET disallow_freq ")
 447             wpas.request("SET p2p_pref_chan ")
 448
 449 def test_no_go_freq(dev, apdev):
 450     """P2P channel selection: no GO freq"""
 451     try:
 452        dev[0].request("SET p2p_no_go_freq 2412")
 453        # dev[0] as client, channel 1 is ok
 454        [i_res, r_res] = go_neg_pbc(i_dev=dev[0], i_intent=1,
 455                                    r_dev=dev[1], r_intent=14, r_freq=2412)
 456        check_grpform_results(i_res, r_res)
 457        if i_res['freq'] != "2412":
 458           raise Exception("P2P group not formed on forced freq")
 459
 460        dev[1].remove_group(r_res['ifname'])
 461        dev[0].wait_go_ending_session()
 462        dev[0].flush_scan_cache()
 463
 464        fail = False
 465        # dev[0] as GO, channel 1 is not allowed
 466        try:
 467           dev[0].request("SET p2p_no_go_freq 2412")
 468           [i_res2, r_res2] = go_neg_pbc(i_dev=dev[0], i_intent=14,
 469                                         r_dev=dev[1], r_intent=1, r_freq=2412)
 470           check_grpform_results(i_res2, r_res2)
 471           fail = True
 472        except:
 473            pass
 474        if fail:
 475            raise Exception("GO set on a disallowed freq")
 476     finally:
 477        dev[0].request("SET p2p_no_go_freq ")
 478
 479 def test_go_neg_peers_force_diff_freq(dev, apdev):
 480     """P2P channel selection when peers for different frequency"""
 481     try:
 482        [i_res2, r_res2] = go_neg_pbc(i_dev=dev[0], i_intent=14, i_freq=5180,
 483                                      r_dev=dev[1], r_intent=0, r_freq=5200)
 484     except Exception, e:
 485         return
 486     raise Exception("Unexpected group formation success")
 487
 488 def test_autogo_random_channel(dev, apdev):
 489     """P2P channel selection: GO instantiated on random channel 1, 6, 11"""
 490     freqs = []
 491     go_freqs = ["2412", "2437", "2462"]
 492     for i in range(0, 20):
 493         result = autogo(dev[0])
 494         if result['freq'] not in go_freqs:
 495            raise Exception("Unexpected frequency selected: " + result['freq'])
 496         if result['freq'] not in freqs:
 497             freqs.append(result['freq'])
 498         if len(freqs) == 3:
 499             break
 500         dev[0].remove_group(result['ifname'])
 501     if i == 20:
 502        raise Exception("GO created 20 times and not all social channels were selected. freqs not selected: " + str(list(set(go_freqs) - set(freqs))))
 503
 504 def test_p2p_autogo_pref_chan_disallowed(dev, apdev):
 505     """P2P channel selection: GO preferred channels are disallowed"""
 506     try:
 507        dev[0].request("SET p2p_pref_chan 81:1,81:3,81:6,81:9,81:11")
 508        dev[0].request("P2P_SET disallow_freq 2412,2422,2437,2452,2462")
 509        for i in range(0, 5):
 510            res = autogo(dev[0])
 511            if res['freq'] in [ "2412", "2422", "2437", "2452", "2462" ]:
 512                raise Exception("GO channel is disallowed")
 513            dev[0].remove_group(res['ifname'])
 514     finally:
 515        dev[0].request("P2P_SET disallow_freq ")
 516        dev[0].request("SET p2p_pref_chan ")
 517
 518 def test_p2p_autogo_pref_chan_not_in_regulatory(dev, apdev):
 519     """P2P channel selection: GO preferred channel not allowed in the regulatory rules"""
 520     try:
 521         set_country("US", dev[0])
 522         dev[0].request("SET p2p_pref_chan 124:149")
 523         res = autogo(dev[0], persistent=True)
 524         if res['freq'] != "5745":
 525             raise Exception("Unexpected channel selected: " + res['freq'])
 526         dev[0].remove_group(res['ifname'])
 527
 528         netw = dev[0].list_networks(p2p=True)
 529         if len(netw) != 1:
 530             raise Exception("Unexpected number of network blocks: " + str(netw))
 531         id = netw[0]['id']
 532
 533         set_country("DE", dev[0])
 534         res = autogo(dev[0], persistent=id)
 535         if res['freq'] == "5745":
 536             raise Exception("Unexpected channel selected(2): " + res['freq'])
 537         dev[0].remove_group(res['ifname'])
 538     finally:
 539         dev[0].request("SET p2p_pref_chan ")
 540         set_country("00")
 541
 542 def run_autogo(dev, param):
 543     if "OK" not in dev.global_request("P2P_GROUP_ADD " + param):
 544         raise Exception("P2P_GROUP_ADD failed: " + param)
 545     ev = dev.wait_global_event(["P2P-GROUP-STARTED"], timeout=10)
 546     if ev is None:
 547         raise Exception("GO start up timed out")
 548     res = dev.group_form_result(ev)
 549     dev.remove_group()
 550     return res
 551
 552 def _test_autogo_ht_vht(dev):
 553     res = run_autogo(dev[0], "ht40")
 554
 555     res = run_autogo(dev[0], "vht")
 556
 557     res = run_autogo(dev[0], "freq=2")
 558     freq = int(res['freq'])
 559     if freq < 2412 or freq > 2462:
 560         raise Exception("Unexpected freq=2 channel: " + str(freq))
 561
 562     res = run_autogo(dev[0], "freq=5")
 563     freq = int(res['freq'])
 564     if freq < 5000 or freq >= 6000:
 565         raise Exception("Unexpected freq=5 channel: " + str(freq))
 566
 567     res = run_autogo(dev[0], "freq=5 ht40 vht")
 568     logger.info(str(res))
 569     freq = int(res['freq'])
 570     if freq < 5000 or freq >= 6000:
 571         raise Exception("Unexpected freq=5 ht40 vht channel: " + str(freq))
 572
 573 def test_autogo_ht_vht(dev):
 574     """P2P autonomous GO with HT/VHT parameters"""
 575     try:
 576         set_country("US", dev[0])
 577         _test_autogo_ht_vht(dev)
 578     finally:
 579         set_country("00")
 580
 581 def test_p2p_listen_chan_optimize(dev, apdev):
 582     """P2P listen channel optimization"""
 583     wpas = WpaSupplicant(global_iface='/tmp/wpas-wlan5')
 584     wpas.interface_add("wlan5")
 585     addr5 = wpas.p2p_dev_addr()
 586     try:
 587         if "OK" not in wpas.request("SET p2p_optimize_listen_chan 1"):
 588             raise Exception("Failed to set p2p_optimize_listen_chan")
 589         wpas.p2p_listen()
 590         if not dev[0].discover_peer(addr5):
 591             raise Exception("Could not discover peer")
 592         peer = dev[0].get_peer(addr5)
 593         lfreq = peer['listen_freq']
 594         wpas.p2p_stop_find()
 595         dev[0].p2p_stop_find()
 596
 597         channel = "1" if lfreq != '2412' else "6"
 598         freq = "2412" if lfreq != '2412' else "2437"
 599         params = { "ssid": "test-open", "channel": channel }
 600         hapd = hostapd.add_ap(apdev[0]['ifname'], params)
 601
 602         id = wpas.connect("test-open", key_mgmt="NONE", scan_freq=freq)
 603         wpas.p2p_listen()
 604
 605         if "OK" not in dev[0].request("P2P_FLUSH"):
 606             raise Exception("P2P_FLUSH failed")
 607         if not dev[0].discover_peer(addr5):
 608             raise Exception("Could not discover peer")
 609         peer = dev[0].get_peer(addr5)
 610         lfreq2 = peer['listen_freq']
 611         if lfreq == lfreq2:
 612             raise Exception("Listen channel did not change")
 613         if lfreq2 != freq:
 614             raise Exception("Listen channel not on AP's operating channel")
 615         wpas.p2p_stop_find()
 616         dev[0].p2p_stop_find()
 617
 618         wpas.request("DISCONNECT")
 619         wpas.wait_disconnected()
 620
 621         # for larger coverage, cover case of current channel matching
 622         wpas.select_network(id)
 623         wpas.wait_connected()
 624         wpas.request("DISCONNECT")
 625         wpas.wait_disconnected()
 626
 627         lchannel = "1" if channel != "1" else "6"
 628         lfreq3 = "2412" if channel != "1" else "2437"
 629         if "OK" not in wpas.request("P2P_SET listen_channel " + lchannel):
 630             raise Exception("Failed to set listen channel")
 631
 632         wpas.select_network(id)
 633         wpas.wait_connected()
 634         wpas.p2p_listen()
 635
 636         if "OK" not in dev[0].request("P2P_FLUSH"):
 637             raise Exception("P2P_FLUSH failed")
 638         if not dev[0].discover_peer(addr5):
 639             raise Exception("Could not discover peer")
 640         peer = dev[0].get_peer(addr5)
 641         lfreq4 = peer['listen_freq']
 642         if lfreq4 != lfreq3:
 643             raise Exception("Unexpected Listen channel after configuration")
 644         wpas.p2p_stop_find()
 645         dev[0].p2p_stop_find()
 646     finally:
 647         wpas.request("SET p2p_optimize_listen_chan 0")
 648
 649 def test_p2p_channel_5ghz_only(dev):
 650     """P2P GO start with only 5 GHz band allowed"""
 651     try:
 652         set_country("US", dev[0])
 653         dev[0].request("P2P_SET disallow_freq 2400-2500")
 654         res = autogo(dev[0])
 655         freq = int(res['freq'])
 656         if freq < 5000:
 657             raise Exception("Unexpected channel %d MHz" % freq)
 658         dev[0].remove_group()
 659     finally:
 660         set_country("00")
 661         dev[0].request("P2P_SET disallow_freq ")
 662
 663 def test_p2p_channel_5ghz_165_169_us(dev):
 664     """P2P GO and 5 GHz channels 165 (allowed) and 169 (disallowed) in US"""
 665     try:
 666         set_country("US", dev[0])
 667         res = dev[0].p2p_start_go(freq=5825)
 668         if res['freq'] != "5825":
 669             raise Exception("Unexpected frequency: " + res['freq'])
 670         dev[0].remove_group()
 671
 672         res = dev[0].global_request("P2P_GROUP_ADD freq=5845")
 673         if "FAIL" not in res:
 674             raise Exception("GO on channel 169 allowed unexpectedly")
 675     finally:
 676         set_country("00")
 677
 678 def test_p2p_go_move_reg_change(dev, apdev, params):
 679     """P2P GO move due to regulatory change [long]"""
 680     if not params['long']:
 681         raise HwsimSkip("Skip test case with long duration due to --long not specified")
 682
 683     try:
 684         set_country("US")
 685         dev[0].global_request("P2P_SET disallow_freq 2400-5000")
 686         res = autogo(dev[0])
 687         freq1 = int(res['freq'])
 688         if freq1 < 5000:
 689             raise Exception("Unexpected channel %d MHz" % freq1)
 690
 691         dev[0].global_request("P2P_SET disallow_freq ")
 692
 693         # GO move is not allowed while waiting for initial client connection
 694         time.sleep(20)
 695         set_country("00")
 696         ev = dev[0].wait_group_event(["P2P-REMOVE-AND-REFORM-GROUP"],
 697                                      timeout=10)
 698         if ev is None:
 699             raise Exception("P2P-REMOVE-AND-REFORM-GROUP not seen")
 700
 701         freq2 = dev[0].get_group_status_field('freq')
 702         if freq1 == freq2:
 703             raise Exception("Unexpected freq after group reform=" + freq2)
 704
 705         dev[0].remove_group()
 706     finally:
 707         dev[0].global_request("P2P_SET disallow_freq ")
 708         set_country("00")
 709
 710 def test_p2p_go_move_active(dev, apdev, params):
 711     """P2P GO stays in freq although SCM is possible [long]"""
 712     if dev[0].get_mcc() <= 1:
 713         raise HwsimSkip("Skip due to MCC not being enabled")
 714
 715     if not params['long']:
 716         raise HwsimSkip("Skip test case with long duration due to --long not specified")
 717
 718     dev[0].request("SET p2p_no_group_iface 0")
 719     try:
 720         dev[0].global_request("P2P_SET disallow_freq 2430-6000")
 721         hapd = hostapd.add_ap(apdev[0]['ifname'], { "ssid" : 'ap-test',
 722                                                     "channel" : '11' })
 723         dev[0].connect("ap-test", key_mgmt="NONE",
 724                        scan_freq="2462")
 725
 726         res = autogo(dev[0])
 727         freq = int(res['freq'])
 728         if freq > 2430:
 729             raise Exception("Unexpected channel %d MHz" % freq)
 730
 731         # GO move is not allowed while waiting for initial client connection
 732         time.sleep(20)
 733         dev[0].global_request("P2P_SET disallow_freq ")
 734
 735         ev = dev[0].wait_group_event(["P2P-REMOVE-AND-REFORM-GROUP"],
 736                                      timeout=10)
 737         if ev is not None:
 738             raise Exception("Unexpected P2P-REMOVE-AND-REFORM-GROUP seen")
 739
 740         dev[0].remove_group()
 741     finally:
 742         dev[0].global_request("P2P_SET disallow_freq ")
 743
 744 def test_p2p_go_move_scm(dev, apdev, params):
 745     """P2P GO move due to SCM operation preference [long]"""
 746     if dev[0].get_mcc() <= 1:
 747         raise HwsimSkip("Skip due to MCC not being enabled")
 748
 749     if not params['long']:
 750         raise HwsimSkip("Skip test case with long duration due to --long not specified")
 751
 752     dev[0].request("SET p2p_no_group_iface 0")
 753     try:
 754         dev[0].global_request("P2P_SET disallow_freq 2430-6000")
 755         hapd = hostapd.add_ap(apdev[0]['ifname'], { "ssid" : 'ap-test',
 756                                                     "channel" : '11' })
 757         dev[0].connect("ap-test", key_mgmt="NONE",
 758                        scan_freq="2462")
 759
 760         dev[0].global_request("SET p2p_go_freq_change_policy 0")
 761         res = autogo(dev[0])
 762         freq = int(res['freq'])
 763         if freq > 2430:
 764             raise Exception("Unexpected channel %d MHz" % freq)
 765
 766         # GO move is not allowed while waiting for initial client connection
 767         time.sleep(20)
 768         dev[0].global_request("P2P_SET disallow_freq ")
 769
 770         ev = dev[0].wait_group_event(["P2P-REMOVE-AND-REFORM-GROUP"], timeout=3)
 771         if ev is None:
 772             raise Exception("P2P-REMOVE-AND-REFORM-GROUP not seen")
 773
 774         freq = dev[0].get_group_status_field('freq')
 775         if freq != '2462':
 776             raise Exception("Unexpected freq after group reform=" + freq)
 777
 778         dev[0].remove_group()
 779     finally:
 780         dev[0].global_request("P2P_SET disallow_freq ")
 781         dev[0].global_request("SET p2p_go_freq_change_policy 2")
 782
 783 def test_p2p_go_move_scm_peer_supports(dev, apdev, params):
 784     """P2P GO move due to SCM operation preference (peer supports) [long]"""
 785     if dev[0].get_mcc() <= 1:
 786         raise HwsimSkip("Skip due to MCC not being enabled")
 787
 788     if not params['long']:
 789         raise HwsimSkip("Skip test case with long duration due to --long not specified")
 790
 791     try:
 792         dev[0].global_request("SET p2p_go_freq_change_policy 1")
 793         set_country("US", dev[0])
 794
 795         dev[0].request("SET p2p_no_group_iface 0")
 796         [i_res, r_res] = go_neg_pin_authorized(i_dev=dev[0], i_intent=15,
 797                                                r_dev=dev[1], r_intent=0,
 798                                                test_data=False)
 799         check_grpform_results(i_res, r_res)
 800         freq = int(i_res['freq'])
 801         if freq < 5000:
 802             raise Exception("Unexpected channel %d MHz - did not follow 5 GHz preference" % freq)
 803
 804         hapd = hostapd.add_ap(apdev[0]['ifname'], { "ssid" : 'ap-test',
 805                                                     "channel" : '11' })
 806         logger.info('Connecting client to to an AP on channel 11');
 807         dev[0].connect("ap-test", key_mgmt="NONE",
 808                        scan_freq="2462")
 809
 810         ev = dev[0].wait_group_event(["P2P-REMOVE-AND-REFORM-GROUP"], timeout=3)
 811         if ev is None:
 812             raise Exception("P2P-REMOVE-AND-REFORM-GROUP not seen")
 813
 814         freq = dev[0].get_group_status_field('freq')
 815         if freq != '2462':
 816             raise Exception("Unexpected freq after group reform=" + freq)
 817
 818         dev[0].remove_group()
 819     finally:
 820         dev[0].global_request("SET p2p_go_freq_change_policy 2")
 821         set_country("00")
 822
 823 def test_p2p_go_move_scm_peer_does_not_support(dev, apdev, params):
 824     """No P2P GO move due to SCM operation (peer does not supports) [long]"""
 825     if dev[0].get_mcc() <= 1:
 826         raise HwsimSkip("Skip due to MCC not being enabled")
 827
 828     if not params['long']:
 829         raise HwsimSkip("Skip test case with long duration due to --long not specified")
 830
 831     try:
 832         dev[0].global_request("SET p2p_go_freq_change_policy 1")
 833         set_country("US", dev[0])
 834
 835         dev[0].request("SET p2p_no_group_iface 0")
 836         if "OK" not in dev[1].request("DRIVER_EVENT AVOID_FREQUENCIES 2400-2500"):
 837             raise Exception("Could not simulate driver event")
 838         [i_res, r_res] = go_neg_pin_authorized(i_dev=dev[0], i_intent=15,
 839                                                r_dev=dev[1], r_intent=0,
 840                                                test_data=False)
 841         check_grpform_results(i_res, r_res)
 842         freq = int(i_res['freq'])
 843         if freq < 5000:
 844             raise Exception("Unexpected channel %d MHz - did not follow 5 GHz preference" % freq)
 845
 846         hapd = hostapd.add_ap(apdev[0]['ifname'], { "ssid" : 'ap-test',
 847                                                     "channel" : '11' })
 848         logger.info('Connecting client to to an AP on channel 11');
 849         dev[0].connect("ap-test", key_mgmt="NONE",
 850                        scan_freq="2462")
 851
 852         ev = dev[0].wait_group_event(["P2P-REMOVE-AND-REFORM-GROUP"],
 853                                      timeout=10)
 854         if ev is not None:
 855             raise Exception("Unexpected P2P-REMOVE-AND-REFORM-GROUP seen")
 856
 857         dev[0].remove_group()
 858     finally:
 859         dev[0].global_request("SET p2p_go_freq_change_policy 2")
 860         set_country("00")
 861
 862 def test_p2p_go_move_scm_multi(dev, apdev, params):
 863     """P2P GO move due to SCM operation preference multiple times [long]"""
 864     if dev[0].get_mcc() <= 1:
 865         raise HwsimSkip("Skip due to MCC not being enabled")
 866
 867     if not params['long']:
 868         raise HwsimSkip("Skip test case with long duration due to --long not specified")
 869
 870     dev[0].request("SET p2p_no_group_iface 0")
 871     try:
 872         dev[0].global_request("P2P_SET disallow_freq 2430-6000")
 873         hapd = hostapd.add_ap(apdev[0]['ifname'], { "ssid" : 'ap-test-1',
 874                                                     "channel" : '11' })
 875         dev[0].connect("ap-test-1", key_mgmt="NONE",
 876                        scan_freq="2462")
 877
 878         dev[0].global_request("SET p2p_go_freq_change_policy 0")
 879         res = autogo(dev[0])
 880         freq = int(res['freq'])
 881         if freq > 2430:
 882             raise Exception("Unexpected channel %d MHz" % freq)
 883
 884         # GO move is not allowed while waiting for initial client connection
 885         time.sleep(20)
 886         dev[0].global_request("P2P_SET disallow_freq ")
 887
 888         ev = dev[0].wait_group_event(["P2P-REMOVE-AND-REFORM-GROUP"], timeout=3)
 889         if ev is None:
 890             raise Exception("P2P-REMOVE-AND-REFORM-GROUP not seen")
 891
 892         freq = dev[0].get_group_status_field('freq')
 893         if freq != '2462':
 894             raise Exception("Unexpected freq after group reform=" + freq)
 895
 896         hapd = hostapd.add_ap(apdev[0]['ifname'], { "ssid" : 'ap-test-2',
 897                                                     "channel" : '6' })
 898         dev[0].connect("ap-test-2", key_mgmt="NONE",
 899                        scan_freq="2437")
 900
 901         ev = dev[0].wait_group_event(["P2P-REMOVE-AND-REFORM-GROUP"], timeout=5)
 902         if ev is None:
 903             raise Exception("(2) P2P-REMOVE-AND-REFORM-GROUP not seen")
 904
 905         freq = dev[0].get_group_status_field('freq')
 906         if freq != '2437':
 907             raise Exception("(2) Unexpected freq after group reform=" + freq)
 908
 909         dev[0].remove_group()
 910     finally:
 911         dev[0].global_request("P2P_SET disallow_freq ")
 912         dev[0].global_request("SET p2p_go_freq_change_policy 2")