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 tshark import run_tshark
  16 from wpasupplicant import WpaSupplicant
  17 from hwsim import HWSimRadio
  18 from test_p2p_grpform import go_neg_pin_authorized
  19 from test_p2p_grpform import check_grpform_results
  20 from test_p2p_grpform import remove_group
  21 from test_p2p_grpform import go_neg_pbc
  22 from test_p2p_autogo import autogo
  23
  24 def set_country(country, dev=None):
  25     subprocess.call(['sudo', 'iw', 'reg', 'set', country])
  26     time.sleep(0.1)
  27     if dev:
  28         for i in range(10):
  29             ev = dev.wait_event(["CTRL-EVENT-REGDOM-CHANGE"], timeout=15)
  30             if ev is None:
  31                 raise Exception("No regdom change event seen")
  32             if "type=COUNTRY alpha2=" + country in ev:
  33                 return
  34         raise Exception("No matching regdom event seen for set_country(%s)" % country)
  35
  36 def test_p2p_channel_5ghz(dev):
  37     """P2P group formation with 5 GHz preference"""
  38     try:
  39         set_country("US", dev[0])
  40         [i_res, r_res] = go_neg_pin_authorized(i_dev=dev[0], i_intent=15,
  41                                                r_dev=dev[1], r_intent=0,
  42                                                test_data=False)
  43         check_grpform_results(i_res, r_res)
  44         freq = int(i_res['freq'])
  45         if freq < 5000:
  46             raise Exception("Unexpected channel %d MHz - did not follow 5 GHz preference" % freq)
  47         remove_group(dev[0], dev[1])
  48     finally:
  49         set_country("00")
  50         dev[1].flush_scan_cache()
  51
  52 def test_p2p_channel_5ghz_no_vht(dev):
  53     """P2P group formation with 5 GHz preference when VHT channels are disallowed"""
  54     try:
  55         set_country("US", dev[0])
  56         dev[0].request("P2P_SET disallow_freq 5180-5240")
  57         [i_res, r_res] = go_neg_pin_authorized(i_dev=dev[0], i_intent=15,
  58                                                r_dev=dev[1], r_intent=0,
  59                                                test_data=False)
  60         check_grpform_results(i_res, r_res)
  61         freq = int(i_res['freq'])
  62         if freq < 5000:
  63             raise Exception("Unexpected channel %d MHz - did not follow 5 GHz preference" % freq)
  64         remove_group(dev[0], dev[1])
  65     finally:
  66         set_country("00")
  67         dev[0].request("P2P_SET disallow_freq ")
  68         dev[1].flush_scan_cache()
  69
  70 def test_p2p_channel_random_social(dev):
  71     """P2P group formation with 5 GHz preference but all 5 GHz channels disabled"""
  72     try:
  73         set_country("US", dev[0])
  74         dev[0].request("SET p2p_oper_channel 11")
  75         dev[0].request("P2P_SET disallow_freq 5000-6000,2462")
  76         [i_res, r_res] = go_neg_pin_authorized(i_dev=dev[0], i_intent=15,
  77                                                r_dev=dev[1], r_intent=0,
  78                                                test_data=False)
  79         check_grpform_results(i_res, r_res)
  80         freq = int(i_res['freq'])
  81         if freq not in [ 2412, 2437, 2462 ]:
  82             raise Exception("Unexpected channel %d MHz - did not pick random social channel" % freq)
  83         remove_group(dev[0], dev[1])
  84     finally:
  85         set_country("00")
  86         dev[0].request("P2P_SET disallow_freq ")
  87         dev[1].flush_scan_cache()
  88
  89 def test_p2p_channel_random(dev):
  90     """P2P group formation with 5 GHz preference but all 5 GHz channels and all social channels disabled"""
  91     try:
  92         set_country("US", dev[0])
  93         dev[0].request("SET p2p_oper_channel 11")
  94         dev[0].request("P2P_SET disallow_freq 5000-6000,2412,2437,2462")
  95         [i_res, r_res] = go_neg_pin_authorized(i_dev=dev[0], i_intent=15,
  96                                                r_dev=dev[1], r_intent=0,
  97                                                test_data=False)
  98         check_grpform_results(i_res, r_res)
  99         freq = int(i_res['freq'])
 100         if freq > 2500 or freq in [ 2412, 2437, 2462 ]:
 101             raise Exception("Unexpected channel %d MHz" % freq)
 102         remove_group(dev[0], dev[1])
 103     finally:
 104         set_country("00")
 105         dev[0].request("P2P_SET disallow_freq ")
 106         dev[1].flush_scan_cache()
 107
 108 def test_p2p_channel_random_social_with_op_class_change(dev, apdev, params):
 109     """P2P group formation using random social channel with oper class change needed"""
 110     try:
 111         set_country("US", dev[0])
 112         logger.info("Start group on 5 GHz")
 113         [i_res, r_res] = go_neg_pin_authorized(i_dev=dev[0], i_intent=15,
 114                                                r_dev=dev[1], r_intent=0,
 115                                                test_data=False)
 116         check_grpform_results(i_res, r_res)
 117         freq = int(i_res['freq'])
 118         if freq < 5000:
 119             raise Exception("Unexpected channel %d MHz - did not pick 5 GHz preference" % freq)
 120         remove_group(dev[0], dev[1])
 121
 122         logger.info("Disable 5 GHz and try to re-start group based on 5 GHz preference")
 123         dev[0].request("SET p2p_oper_reg_class 115")
 124         dev[0].request("SET p2p_oper_channel 36")
 125         dev[0].request("P2P_SET disallow_freq 5000-6000")
 126         [i_res, r_res] = go_neg_pin_authorized(i_dev=dev[0], i_intent=15,
 127                                                r_dev=dev[1], r_intent=0,
 128                                                test_data=False)
 129         check_grpform_results(i_res, r_res)
 130         freq = int(i_res['freq'])
 131         if freq not in [ 2412, 2437, 2462 ]:
 132             raise Exception("Unexpected channel %d MHz - did not pick random social channel" % freq)
 133         remove_group(dev[0], dev[1])
 134
 135         out = run_tshark(os.path.join(params['logdir'], "hwsim0.pcapng"),
 136                          "wifi_p2p.public_action.subtype == 0")
 137         if out is not None:
 138             last = None
 139             for l in out.splitlines():
 140                 if "Operating Channel:" not in l:
 141                     continue
 142                 last = l
 143             if last is None:
 144                 raise Exception("Could not find GO Negotiation Request")
 145             if "Operating Class 81" not in last:
 146                 raise Exception("Unexpected operating class: " + last.strip())
 147     finally:
 148         set_country("00")
 149         dev[0].request("P2P_SET disallow_freq ")
 150         dev[0].request("SET p2p_oper_reg_class 0")
 151         dev[0].request("SET p2p_oper_channel 0")
 152         dev[1].flush_scan_cache()
 153
 154 def test_p2p_channel_avoid(dev):
 155     """P2P and avoid frequencies driver event"""
 156     try:
 157         set_country("US", dev[0])
 158         if "OK" not in dev[0].request("DRIVER_EVENT AVOID_FREQUENCIES 5000-6000,2412,2437,2462"):
 159             raise Exception("Could not simulate driver event")
 160         ev = dev[0].wait_event(["CTRL-EVENT-AVOID-FREQ"], timeout=10)
 161         if ev is None:
 162             raise Exception("No CTRL-EVENT-AVOID-FREQ event")
 163         [i_res, r_res] = go_neg_pin_authorized(i_dev=dev[0], i_intent=15,
 164                                                r_dev=dev[1], r_intent=0,
 165                                                test_data=False)
 166         check_grpform_results(i_res, r_res)
 167         freq = int(i_res['freq'])
 168         if freq > 2500 or freq in [ 2412, 2437, 2462 ]:
 169             raise Exception("Unexpected channel %d MHz" % freq)
 170
 171         if "OK" not in dev[0].request("DRIVER_EVENT AVOID_FREQUENCIES"):
 172             raise Exception("Could not simulate driver event(2)")
 173         ev = dev[0].wait_event(["CTRL-EVENT-AVOID-FREQ"], timeout=10)
 174         if ev is None:
 175             raise Exception("No CTRL-EVENT-AVOID-FREQ event")
 176         ev = dev[0].wait_event(["P2P-REMOVE-AND-REFORM-GROUP"], timeout=1)
 177         if ev is not None:
 178             raise Exception("Unexpected P2P-REMOVE-AND-REFORM-GROUP event")
 179
 180         if "OK" not in dev[0].request("DRIVER_EVENT AVOID_FREQUENCIES " + str(freq)):
 181             raise Exception("Could not simulate driver event(3)")
 182         ev = dev[0].wait_event(["CTRL-EVENT-AVOID-FREQ"], timeout=10)
 183         if ev is None:
 184             raise Exception("No CTRL-EVENT-AVOID-FREQ event")
 185         ev = dev[0].wait_event(["P2P-REMOVE-AND-REFORM-GROUP"], timeout=10)
 186         if ev is None:
 187             raise Exception("No P2P-REMOVE-AND-REFORM-GROUP event")
 188     finally:
 189         set_country("00")
 190         dev[0].request("DRIVER_EVENT AVOID_FREQUENCIES")
 191         dev[1].flush_scan_cache()
 192
 193 def test_autogo_following_bss(dev, apdev):
 194     """P2P autonomous GO operate on the same channel as station interface"""
 195     if dev[0].get_mcc() > 1:
 196         logger.info("test mode: MCC")
 197
 198     dev[0].request("SET p2p_no_group_iface 0")
 199
 200     channels = { 3 : "2422", 5 : "2432", 9 : "2452" }
 201     for key in channels:
 202         hapd = hostapd.add_ap(apdev[0]['ifname'], { "ssid" : 'ap-test',
 203                                                     "channel" : str(key) })
 204         dev[0].connect("ap-test", key_mgmt="NONE",
 205                        scan_freq=str(channels[key]))
 206         res_go = autogo(dev[0])
 207         if res_go['freq'] != channels[key]:
 208             raise Exception("Group operation channel is not the same as on connected station interface")
 209         hwsim_utils.test_connectivity(dev[0], hapd)
 210         dev[0].remove_group(res_go['ifname'])
 211
 212 def test_go_neg_with_bss_connected(dev, apdev):
 213     """P2P channel selection: GO negotiation when station interface is connected"""
 214
 215     dev[0].flush_scan_cache()
 216     dev[1].flush_scan_cache()
 217     dev[0].request("SET p2p_no_group_iface 0")
 218
 219     hapd = hostapd.add_ap(apdev[0]['ifname'],
 220                           { "ssid": 'bss-2.4ghz', "channel": '5' })
 221     dev[0].connect("bss-2.4ghz", key_mgmt="NONE", scan_freq="2432")
 222     #dev[0] as GO
 223     [i_res, r_res] = go_neg_pbc(i_dev=dev[0], i_intent=10, r_dev=dev[1],
 224                                 r_intent=1)
 225     check_grpform_results(i_res, r_res)
 226     if i_res['role'] != "GO":
 227        raise Exception("GO not selected according to go_intent")
 228     if i_res['freq'] != "2432":
 229        raise Exception("Group formed on a different frequency than BSS")
 230     hwsim_utils.test_connectivity(dev[0], hapd)
 231     dev[0].remove_group(i_res['ifname'])
 232
 233     if dev[0].get_mcc() > 1:
 234         logger.info("Skip as-client case due to MCC being enabled")
 235         return;
 236
 237     #dev[0] as client
 238     [i_res2, r_res2] = go_neg_pbc(i_dev=dev[0], i_intent=1, r_dev=dev[1],
 239                                   r_intent=10)
 240     check_grpform_results(i_res2, r_res2)
 241     if i_res2['role'] != "client":
 242        raise Exception("GO not selected according to go_intent")
 243     if i_res2['freq'] != "2432":
 244        raise Exception("Group formed on a different frequency than BSS")
 245     hwsim_utils.test_connectivity(dev[0], hapd)
 246     dev[1].remove_group(r_res['ifname'])
 247     dev[0].wait_go_ending_session()
 248     dev[0].request("DISCONNECT")
 249     hapd.disable()
 250     dev[0].flush_scan_cache()
 251     dev[1].flush_scan_cache()
 252
 253 def test_autogo_with_bss_on_disallowed_chan(dev, apdev):
 254     """P2P channel selection: Autonomous GO with BSS on a disallowed channel"""
 255
 256     with HWSimRadio(n_channels=2) as (radio, iface):
 257         wpas = WpaSupplicant(global_iface='/tmp/wpas-wlan5')
 258         wpas.interface_add(iface)
 259
 260         wpas.request("SET p2p_no_group_iface 0")
 261
 262         if wpas.get_mcc() < 2:
 263            raise Exception("New radio does not support MCC")
 264
 265         try:
 266             hapd = hostapd.add_ap(apdev[0]['ifname'], { "ssid": 'bss-2.4ghz',
 267                                                         "channel": '1' })
 268             wpas.request("P2P_SET disallow_freq 2412")
 269             wpas.connect("bss-2.4ghz", key_mgmt="NONE", scan_freq="2412")
 270             res = autogo(wpas)
 271             if res['freq'] == "2412":
 272                raise Exception("GO set on a disallowed channel")
 273             hwsim_utils.test_connectivity(wpas, hapd)
 274         finally:
 275             wpas.request("P2P_SET disallow_freq ")
 276
 277 def test_go_neg_with_bss_on_disallowed_chan(dev, apdev):
 278     """P2P channel selection: GO negotiation with station interface on a disallowed channel"""
 279
 280     with HWSimRadio(n_channels=2) as (radio, iface):
 281         wpas = WpaSupplicant(global_iface='/tmp/wpas-wlan5')
 282         wpas.interface_add(iface)
 283
 284         wpas.request("SET p2p_no_group_iface 0")
 285
 286         if wpas.get_mcc() < 2:
 287            raise Exception("New radio does not support MCC")
 288
 289         try:
 290             hapd = hostapd.add_ap(apdev[0]['ifname'],
 291                                   { "ssid": 'bss-2.4ghz', "channel": '1' })
 292             # make sure PBC overlap from old test cases is not maintained
 293             dev[1].flush_scan_cache()
 294             wpas.connect("bss-2.4ghz", key_mgmt="NONE", scan_freq="2412")
 295             wpas.request("P2P_SET disallow_freq 2412")
 296
 297             #wpas as GO
 298             [i_res, r_res] = go_neg_pbc(i_dev=wpas, i_intent=10, r_dev=dev[1],
 299                                         r_intent=1)
 300             check_grpform_results(i_res, r_res)
 301             if i_res['role'] != "GO":
 302                raise Exception("GO not selected according to go_intent")
 303             if i_res['freq'] == "2412":
 304                raise Exception("Group formed on a disallowed channel")
 305             hwsim_utils.test_connectivity(wpas, hapd)
 306             wpas.remove_group(i_res['ifname'])
 307             dev[1].wait_go_ending_session()
 308             dev[1].flush_scan_cache()
 309
 310             wpas.dump_monitor()
 311             dev[1].dump_monitor()
 312
 313             #wpas as client
 314             [i_res2, r_res2] = go_neg_pbc(i_dev=wpas, i_intent=1, r_dev=dev[1],
 315                                           r_intent=10)
 316             check_grpform_results(i_res2, r_res2)
 317             if i_res2['role'] != "client":
 318                raise Exception("GO not selected according to go_intent")
 319             if i_res2['freq'] == "2412":
 320                raise Exception("Group formed on a disallowed channel")
 321             hwsim_utils.test_connectivity(wpas, hapd)
 322             dev[1].remove_group(r_res2['ifname'])
 323             wpas.wait_go_ending_session()
 324             ev = dev[1].wait_global_event(["P2P-GROUP-REMOVED"], timeout=5)
 325             if ev is None:
 326                 raise Exception("Group removal not indicated")
 327             wpas.request("DISCONNECT")
 328             hapd.disable()
 329         finally:
 330             wpas.request("P2P_SET disallow_freq ")
 331
 332 def test_autogo_force_diff_channel(dev, apdev):
 333     """P2P autonomous GO and station interface operate on different channels"""
 334     with HWSimRadio(n_channels=2) as (radio, iface):
 335         wpas = WpaSupplicant(global_iface='/tmp/wpas-wlan5')
 336         wpas.interface_add(iface)
 337
 338         if wpas.get_mcc() < 2:
 339            raise Exception("New radio does not support MCC")
 340
 341         wpas.request("SET p2p_no_group_iface 0")
 342
 343         hapd = hostapd.add_ap(apdev[0]['ifname'],
 344                               {"ssid" : 'ap-test', "channel" : '1'})
 345         wpas.connect("ap-test", key_mgmt = "NONE", scan_freq = "2412")
 346         channels = { 2 : 2417, 5 : 2432, 9 : 2452 }
 347         for key in channels:
 348             res_go = autogo(wpas, channels[key])
 349             hwsim_utils.test_connectivity(wpas, hapd)
 350             if int(res_go['freq']) == 2412:
 351                 raise Exception("Group operation channel is: 2412 excepted: " + res_go['freq'])
 352             wpas.remove_group(res_go['ifname'])
 353
 354 def test_go_neg_forced_freq_diff_than_bss_freq(dev, apdev):
 355     """P2P channel selection: GO negotiation with forced freq different than station interface"""
 356     with HWSimRadio(n_channels=2) as (radio, iface):
 357         wpas = WpaSupplicant(global_iface='/tmp/wpas-wlan5')
 358         wpas.interface_add(iface)
 359
 360         if wpas.get_mcc() < 2:
 361            raise Exception("New radio does not support MCC")
 362
 363         # Clear possible PBC session overlap from previous test case
 364         dev[1].flush_scan_cache()
 365
 366         wpas.request("SET p2p_no_group_iface 0")
 367
 368         hapd = hostapd.add_ap(apdev[0]['ifname'],
 369                               { "country_code": 'US',
 370                                 "ssid": 'bss-5ghz', "hw_mode": 'a',
 371                                 "channel": '40' })
 372         wpas.connect("bss-5ghz", key_mgmt="NONE", scan_freq="5200")
 373
 374         # GO and peer force the same freq, different than BSS freq,
 375         # wpas to become GO
 376         [i_res, r_res] = go_neg_pbc(i_dev=dev[1], i_intent=1, i_freq=5180,
 377                                     r_dev=wpas, r_intent=14, r_freq=5180)
 378         check_grpform_results(i_res, r_res)
 379         if i_res['freq'] != "5180":
 380            raise Exception("P2P group formed on unexpected frequency: " + i_res['freq'])
 381         if r_res['role'] != "GO":
 382            raise Exception("GO not selected according to go_intent")
 383         hwsim_utils.test_connectivity(wpas, hapd)
 384         wpas.remove_group(r_res['ifname'])
 385         dev[1].wait_go_ending_session()
 386         dev[1].flush_scan_cache()
 387
 388         # GO and peer force the same freq, different than BSS freq, wpas to
 389         # become client
 390         [i_res2, r_res2] = go_neg_pbc(i_dev=dev[1], i_intent=14, i_freq=2422,
 391                                       r_dev=wpas, r_intent=1, r_freq=2422)
 392         check_grpform_results(i_res2, r_res2)
 393         if i_res2['freq'] != "2422":
 394            raise Exception("P2P group formed on unexpected frequency: " + i_res2['freq'])
 395         if r_res2['role'] != "client":
 396            raise Exception("GO not selected according to go_intent")
 397         hwsim_utils.test_connectivity(wpas, hapd)
 398
 399         wpas.request("DISCONNECT")
 400         hapd.request("DISABLE")
 401         subprocess.call(['iw', 'reg', 'set', '00'])
 402         wpas.flush_scan_cache()
 403
 404 def test_go_pref_chan_bss_on_diff_chan(dev, apdev):
 405     """P2P channel selection: Station on different channel than GO configured pref channel"""
 406
 407     dev[0].request("SET p2p_no_group_iface 0")
 408
 409     try:
 410         hapd = hostapd.add_ap(apdev[0]['ifname'], { "ssid": 'bss-2.4ghz',
 411                                                     "channel": '1' })
 412         dev[0].request("SET p2p_pref_chan 81:2")
 413         dev[0].connect("bss-2.4ghz", key_mgmt="NONE", scan_freq="2412")
 414         res = autogo(dev[0])
 415         if res['freq'] != "2412":
 416            raise Exception("GO channel did not follow BSS")
 417         hwsim_utils.test_connectivity(dev[0], hapd)
 418     finally:
 419         dev[0].request("SET p2p_pref_chan ")
 420
 421 def test_go_pref_chan_bss_on_disallowed_chan(dev, apdev):
 422     """P2P channel selection: Station interface on different channel than GO configured pref channel, and station channel is disallowed"""
 423     with HWSimRadio(n_channels=2) as (radio, iface):
 424         wpas = WpaSupplicant(global_iface='/tmp/wpas-wlan5')
 425         wpas.interface_add(iface)
 426
 427         if wpas.get_mcc() < 2:
 428            raise Exception("New radio does not support MCC")
 429
 430         wpas.request("SET p2p_no_group_iface 0")
 431
 432         try:
 433             hapd = hostapd.add_ap(apdev[0]['ifname'], { "ssid": 'bss-2.4ghz',
 434                                                         "channel": '1' })
 435             wpas.request("P2P_SET disallow_freq 2412")
 436             wpas.request("SET p2p_pref_chan 81:2")
 437             wpas.connect("bss-2.4ghz", key_mgmt="NONE", scan_freq="2412")
 438             res2 = autogo(wpas)
 439             if res2['freq'] != "2417":
 440                raise Exception("GO channel did not follow pref_chan configuration")
 441             hwsim_utils.test_connectivity(wpas, hapd)
 442         finally:
 443             wpas.request("P2P_SET disallow_freq ")
 444             wpas.request("SET p2p_pref_chan ")
 445
 446 def test_no_go_freq(dev, apdev):
 447     """P2P channel selection: no GO freq"""
 448     try:
 449        dev[0].request("SET p2p_no_go_freq 2412")
 450        # dev[0] as client, channel 1 is ok
 451        [i_res, r_res] = go_neg_pbc(i_dev=dev[0], i_intent=1,
 452                                    r_dev=dev[1], r_intent=14, r_freq=2412)
 453        check_grpform_results(i_res, r_res)
 454        if i_res['freq'] != "2412":
 455           raise Exception("P2P group not formed on forced freq")
 456
 457        dev[1].remove_group(r_res['ifname'])
 458        dev[0].wait_go_ending_session()
 459        dev[0].flush_scan_cache()
 460
 461        fail = False
 462        # dev[0] as GO, channel 1 is not allowed
 463        try:
 464           dev[0].request("SET p2p_no_go_freq 2412")
 465           [i_res2, r_res2] = go_neg_pbc(i_dev=dev[0], i_intent=14,
 466                                         r_dev=dev[1], r_intent=1, r_freq=2412)
 467           check_grpform_results(i_res2, r_res2)
 468           fail = True
 469        except:
 470            pass
 471        if fail:
 472            raise Exception("GO set on a disallowed freq")
 473     finally:
 474        dev[0].request("SET p2p_no_go_freq ")
 475
 476 def test_go_neg_peers_force_diff_freq(dev, apdev):
 477     """P2P channel selection when peers for different frequency"""
 478     try:
 479        [i_res2, r_res2] = go_neg_pbc(i_dev=dev[0], i_intent=14, i_freq=5180,
 480                                      r_dev=dev[1], r_intent=0, r_freq=5200)
 481     except Exception, e:
 482         return
 483     raise Exception("Unexpected group formation success")
 484
 485 def test_autogo_random_channel(dev, apdev):
 486     """P2P channel selection: GO instantiated on random channel 1, 6, 11"""
 487     freqs = []
 488     go_freqs = ["2412", "2437", "2462"]
 489     for i in range(0, 20):
 490         result = autogo(dev[0])
 491         if result['freq'] not in go_freqs:
 492            raise Exception("Unexpected frequency selected: " + result['freq'])
 493         if result['freq'] not in freqs:
 494             freqs.append(result['freq'])
 495         if len(freqs) == 3:
 496             break
 497         dev[0].remove_group(result['ifname'])
 498     if i == 20:
 499        raise Exception("GO created 20 times and not all social channels were selected. freqs not selected: " + str(list(set(go_freqs) - set(freqs))))
 500
 501 def test_p2p_autogo_pref_chan_disallowed(dev, apdev):
 502     """P2P channel selection: GO preferred channels are disallowed"""
 503     try:
 504        dev[0].request("SET p2p_pref_chan 81:1,81:3,81:6,81:9,81:11")
 505        dev[0].request("P2P_SET disallow_freq 2412,2422,2437,2452,2462")
 506        for i in range(0, 5):
 507            res = autogo(dev[0])
 508            if res['freq'] in [ "2412", "2422", "2437", "2452", "2462" ]:
 509                raise Exception("GO channel is disallowed")
 510            dev[0].remove_group(res['ifname'])
 511     finally:
 512        dev[0].request("P2P_SET disallow_freq ")
 513        dev[0].request("SET p2p_pref_chan ")
 514
 515 def test_p2p_autogo_pref_chan_not_in_regulatory(dev, apdev):
 516     """P2P channel selection: GO preferred channel not allowed in the regulatory rules"""
 517     try:
 518         set_country("US", dev[0])
 519         dev[0].request("SET p2p_pref_chan 124:149")
 520         res = autogo(dev[0], persistent=True)
 521         if res['freq'] != "5745":
 522             raise Exception("Unexpected channel selected: " + res['freq'])
 523         dev[0].remove_group(res['ifname'])
 524
 525         netw = dev[0].list_networks()
 526         if len(netw) != 1:
 527             raise Exception("Unexpected number of network blocks: " + str(netw))
 528         id = netw[0]['id']
 529
 530         set_country("DE", dev[0])
 531         res = autogo(dev[0], persistent=id)
 532         if res['freq'] == "5745":
 533             raise Exception("Unexpected channel selected(2): " + res['freq'])
 534         dev[0].remove_group(res['ifname'])
 535     finally:
 536         dev[0].request("SET p2p_pref_chan ")
 537         set_country("00")
 538
 539 def run_autogo(dev, param):
 540     if "OK" not in dev.global_request("P2P_GROUP_ADD " + param):
 541         raise Exception("P2P_GROUP_ADD failed: " + param)
 542     ev = dev.wait_global_event(["P2P-GROUP-STARTED"], timeout=10)
 543     if ev is None:
 544         raise Exception("GO start up timed out")
 545     res = dev.group_form_result(ev)
 546     dev.remove_group()
 547     return res
 548
 549 def _test_autogo_ht_vht(dev):
 550     res = run_autogo(dev[0], "ht40")
 551
 552     res = run_autogo(dev[0], "vht")
 553
 554     res = run_autogo(dev[0], "freq=2")
 555     freq = int(res['freq'])
 556     if freq < 2412 or freq > 2462:
 557         raise Exception("Unexpected freq=2 channel: " + str(freq))
 558
 559     res = run_autogo(dev[0], "freq=5")
 560     freq = int(res['freq'])
 561     if freq < 5000 or freq >= 6000:
 562         raise Exception("Unexpected freq=5 channel: " + str(freq))
 563
 564     res = run_autogo(dev[0], "freq=5 ht40 vht")
 565     logger.info(str(res))
 566     freq = int(res['freq'])
 567     if freq < 5000 or freq >= 6000:
 568         raise Exception("Unexpected freq=5 ht40 vht channel: " + str(freq))
 569
 570 def test_autogo_ht_vht(dev):
 571     """P2P autonomous GO with HT/VHT parameters"""
 572     try:
 573         set_country("US", dev[0])
 574         _test_autogo_ht_vht(dev)
 575     finally:
 576         set_country("00")
 577
 578 def test_p2p_listen_chan_optimize(dev, apdev):
 579     """P2P listen channel optimization"""
 580     wpas = WpaSupplicant(global_iface='/tmp/wpas-wlan5')
 581     wpas.interface_add("wlan5")
 582     addr5 = wpas.p2p_dev_addr()
 583     try:
 584         if "OK" not in wpas.request("SET p2p_optimize_listen_chan 1"):
 585             raise Exception("Failed to set p2p_optimize_listen_chan")
 586         wpas.p2p_listen()
 587         if not dev[0].discover_peer(addr5):
 588             raise Exception("Could not discover peer")
 589         peer = dev[0].get_peer(addr5)
 590         lfreq = peer['listen_freq']
 591         wpas.p2p_stop_find()
 592         dev[0].p2p_stop_find()
 593
 594         channel = "1" if lfreq != '2412' else "6"
 595         freq = "2412" if lfreq != '2412' else "2437"
 596         params = { "ssid": "test-open", "channel": channel }
 597         hapd = hostapd.add_ap(apdev[0]['ifname'], params)
 598
 599         id = wpas.connect("test-open", key_mgmt="NONE", scan_freq=freq)
 600         wpas.p2p_listen()
 601
 602         if "OK" not in dev[0].request("P2P_FLUSH"):
 603             raise Exception("P2P_FLUSH failed")
 604         if not dev[0].discover_peer(addr5):
 605             raise Exception("Could not discover peer")
 606         peer = dev[0].get_peer(addr5)
 607         lfreq2 = peer['listen_freq']
 608         if lfreq == lfreq2:
 609             raise Exception("Listen channel did not change")
 610         if lfreq2 != freq:
 611             raise Exception("Listen channel not on AP's operating channel")
 612         wpas.p2p_stop_find()
 613         dev[0].p2p_stop_find()
 614
 615         wpas.request("DISCONNECT")
 616         wpas.wait_disconnected()
 617
 618         # for larger coverage, cover case of current channel matching
 619         wpas.select_network(id)
 620         wpas.wait_connected()
 621         wpas.request("DISCONNECT")
 622         wpas.wait_disconnected()
 623
 624         lchannel = "1" if channel != "1" else "6"
 625         lfreq3 = "2412" if channel != "1" else "2437"
 626         if "OK" not in wpas.request("P2P_SET listen_channel " + lchannel):
 627             raise Exception("Failed to set listen channel")
 628
 629         wpas.select_network(id)
 630         wpas.wait_connected()
 631         wpas.p2p_listen()
 632
 633         if "OK" not in dev[0].request("P2P_FLUSH"):
 634             raise Exception("P2P_FLUSH failed")
 635         if not dev[0].discover_peer(addr5):
 636             raise Exception("Could not discover peer")
 637         peer = dev[0].get_peer(addr5)
 638         lfreq4 = peer['listen_freq']
 639         if lfreq4 != lfreq3:
 640             raise Exception("Unexpected Listen channel after configuration")
 641         wpas.p2p_stop_find()
 642         dev[0].p2p_stop_find()
 643     finally:
 644         wpas.request("SET p2p_optimize_listen_chan 0")