tests/hwsim/test_gas.py

   1 # GAS tests
   2 # Copyright (c) 2013, Qualcomm Atheros, Inc.
   3 # Copyright (c) 2013-2014, Jouni Malinen <j@w1.fi>
   4 #
   5 # This software may be distributed under the terms of the BSD license.
   6 # See README for more details.
   7
   8 import time
   9 import binascii
  10 import logging
  11 logger = logging.getLogger()
  12 import re
  13 import struct
  14
  15 import hostapd
  16
  17 def hs20_ap_params():
  18     params = hostapd.wpa2_params(ssid="test-gas")
  19     params['wpa_key_mgmt'] = "WPA-EAP"
  20     params['ieee80211w'] = "1"
  21     params['ieee8021x'] = "1"
  22     params['auth_server_addr'] = "127.0.0.1"
  23     params['auth_server_port'] = "1812"
  24     params['auth_server_shared_secret'] = "radius"
  25     params['interworking'] = "1"
  26     params['access_network_type'] = "14"
  27     params['internet'] = "1"
  28     params['asra'] = "0"
  29     params['esr'] = "0"
  30     params['uesa'] = "0"
  31     params['venue_group'] = "7"
  32     params['venue_type'] = "1"
  33     params['venue_name'] = [ "eng:Example venue", "fin:Esimerkkipaikka" ]
  34     params['roaming_consortium'] = [ "112233", "1020304050", "010203040506",
  35                                      "fedcba" ]
  36     params['domain_name'] = "example.com,another.example.com"
  37     params['nai_realm'] = [ "0,example.com,13[5:6],21[2:4][5:7]",
  38                             "0,another.example.com" ]
  39     params['anqp_3gpp_cell_net'] = "244,91"
  40     params['network_auth_type'] = "02http://www.example.com/redirect/me/here/"
  41     params['ipaddr_type_availability'] = "14"
  42     params['hs20'] = "1"
  43     params['hs20_oper_friendly_name'] = [ "eng:Example operator", "fin:Esimerkkioperaattori" ]
  44     params['hs20_wan_metrics'] = "01:8000:1000:80:240:3000"
  45     params['hs20_conn_capab'] = [ "1:0:2", "6:22:1", "17:5060:0" ]
  46     params['hs20_operating_class'] = "5173"
  47     return params
  48
  49 def start_ap(ap):
  50     params = hs20_ap_params()
  51     params['hessid'] = ap['bssid']
  52     hostapd.add_ap(ap['ifname'], params)
  53     return hostapd.Hostapd(ap['ifname'])
  54
  55 def get_gas_response(dev, bssid, info, allow_fetch_failure=False):
  56     exp = r'<.>(GAS-RESPONSE-INFO) addr=([0-9a-f:]*) dialog_token=([0-9]*) status_code=([0-9]*) resp_len=([\-0-9]*)'
  57     res = re.split(exp, info)
  58     if len(res) < 6:
  59         raise Exception("Could not parse GAS-RESPONSE-INFO")
  60     if res[2] != bssid:
  61         raise Exception("Unexpected BSSID in response")
  62     token = res[3]
  63     status = res[4]
  64     if status != "0":
  65         raise Exception("GAS query failed")
  66     resp_len = res[5]
  67     if resp_len == "-1":
  68         raise Exception("GAS query reported invalid response length")
  69     if int(resp_len) > 2000:
  70         raise Exception("Unexpected long GAS response")
  71
  72     resp = dev.request("GAS_RESPONSE_GET " + bssid + " " + token)
  73     if "FAIL" in resp:
  74         if allow_fetch_failure:
  75             logger.debug("GAS response was not available anymore")
  76             return
  77         raise Exception("Could not fetch GAS response")
  78     if len(resp) != int(resp_len) * 2:
  79         raise Exception("Unexpected GAS response length")
  80     logger.debug("GAS response: " + resp)
  81
  82 def test_gas_generic(dev, apdev):
  83     """Generic GAS query"""
  84     bssid = apdev[0]['bssid']
  85     params = hs20_ap_params()
  86     params['hessid'] = bssid
  87     hostapd.add_ap(apdev[0]['ifname'], params)
  88
  89     dev[0].scan(freq="2412")
  90     req = dev[0].request("GAS_REQUEST " + bssid + " 00 000102000101")
  91     if "FAIL" in req:
  92         raise Exception("GAS query request rejected")
  93     ev = dev[0].wait_event(["GAS-RESPONSE-INFO"], timeout=10)
  94     if ev is None:
  95         raise Exception("GAS query timed out")
  96     get_gas_response(dev[0], bssid, ev)
  97
  98 def test_gas_concurrent_scan(dev, apdev):
  99     """Generic GAS queries with concurrent scan operation"""
 100     bssid = apdev[0]['bssid']
 101     params = hs20_ap_params()
 102     params['hessid'] = bssid
 103     hostapd.add_ap(apdev[0]['ifname'], params)
 104
 105     # get BSS entry available to allow GAS query
 106     dev[0].scan(freq="2412")
 107
 108     logger.info("Request concurrent operations")
 109     req = dev[0].request("GAS_REQUEST " + bssid + " 00 000102000101")
 110     if "FAIL" in req:
 111         raise Exception("GAS query request rejected")
 112     req = dev[0].request("GAS_REQUEST " + bssid + " 00 000102000801")
 113     if "FAIL" in req:
 114         raise Exception("GAS query request rejected")
 115     dev[0].scan(no_wait=True)
 116     req = dev[0].request("GAS_REQUEST " + bssid + " 00 000102000201")
 117     if "FAIL" in req:
 118         raise Exception("GAS query request rejected")
 119     req = dev[0].request("GAS_REQUEST " + bssid + " 00 000102000501")
 120     if "FAIL" in req:
 121         raise Exception("GAS query request rejected")
 122
 123     responses = 0
 124     for i in range(0, 5):
 125         ev = dev[0].wait_event(["GAS-RESPONSE-INFO", "CTRL-EVENT-SCAN-RESULTS"],
 126                                timeout=10)
 127         if ev is None:
 128             raise Exception("Operation timed out")
 129         if "GAS-RESPONSE-INFO" in ev:
 130             responses = responses + 1
 131             get_gas_response(dev[0], bssid, ev, allow_fetch_failure=True)
 132
 133     if responses != 4:
 134         raise Exception("Unexpected number of GAS responses")
 135
 136 def test_gas_concurrent_connect(dev, apdev):
 137     """Generic GAS queries with concurrent connection operation"""
 138     bssid = apdev[0]['bssid']
 139     params = hs20_ap_params()
 140     params['hessid'] = bssid
 141     hostapd.add_ap(apdev[0]['ifname'], params)
 142
 143     dev[0].scan(freq="2412")
 144
 145     logger.debug("Start concurrent connect and GAS request")
 146     dev[0].connect("test-gas", key_mgmt="WPA-EAP", eap="TTLS",
 147                    identity="DOMAIN\mschapv2 user", anonymous_identity="ttls",
 148                    password="password", phase2="auth=MSCHAPV2",
 149                    ca_cert="auth_serv/ca.pem", wait_connect=False,
 150                    scan_freq="2412")
 151     req = dev[0].request("GAS_REQUEST " + bssid + " 00 000102000101")
 152     if "FAIL" in req:
 153         raise Exception("GAS query request rejected")
 154
 155     ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED", "GAS-RESPONSE-INFO"],
 156                            timeout=20)
 157     if ev is None:
 158         raise Exception("Operation timed out")
 159     if "CTRL-EVENT-CONNECTED" not in ev:
 160         raise Exception("Unexpected operation order")
 161
 162     ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED", "GAS-RESPONSE-INFO"],
 163                            timeout=20)
 164     if ev is None:
 165         raise Exception("Operation timed out")
 166     if "GAS-RESPONSE-INFO" not in ev:
 167         raise Exception("Unexpected operation order")
 168     get_gas_response(dev[0], bssid, ev)
 169
 170     dev[0].request("DISCONNECT")
 171     ev = dev[0].wait_event(["CTRL-EVENT-DISCONNECTED"], timeout=5)
 172     if ev is None:
 173         raise Exception("Disconnection timed out")
 174
 175     logger.debug("Wait six seconds for expiration of connect-without-scan")
 176     time.sleep(6)
 177     dev[0].dump_monitor()
 178
 179     logger.debug("Start concurrent GAS request and connect")
 180     req = dev[0].request("GAS_REQUEST " + bssid + " 00 000102000101")
 181     if "FAIL" in req:
 182         raise Exception("GAS query request rejected")
 183     dev[0].request("RECONNECT")
 184
 185     ev = dev[0].wait_event(["GAS-RESPONSE-INFO"], timeout=10)
 186     if ev is None:
 187         raise Exception("Operation timed out")
 188     get_gas_response(dev[0], bssid, ev)
 189
 190     ev = dev[0].wait_event(["CTRL-EVENT-SCAN-RESULTS"], timeout=20)
 191     if ev is None:
 192         raise Exception("No new scan results reported")
 193
 194     ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED"], timeout=20)
 195     if ev is None:
 196         raise Exception("Operation timed out")
 197     if "CTRL-EVENT-CONNECTED" not in ev:
 198         raise Exception("Unexpected operation order")
 199
 200 def test_gas_fragment(dev, apdev):
 201     """GAS fragmentation"""
 202     hapd = start_ap(apdev[0])
 203     hapd.set("gas_frag_limit", "50")
 204
 205     dev[0].scan(freq="2412")
 206     dev[0].request("FETCH_ANQP")
 207     for i in range(0, 13):
 208         ev = dev[0].wait_event(["RX-ANQP", "RX-HS20-ANQP"], timeout=5)
 209         if ev is None:
 210             raise Exception("Operation timed out")
 211
 212 def test_gas_comeback_delay(dev, apdev):
 213     """GAS fragmentation"""
 214     hapd = start_ap(apdev[0])
 215     hapd.set("gas_comeback_delay", "500")
 216
 217     dev[0].scan(freq="2412")
 218     dev[0].request("FETCH_ANQP")
 219     for i in range(0, 6):
 220         ev = dev[0].wait_event(["RX-ANQP"], timeout=5)
 221         if ev is None:
 222             raise Exception("Operation timed out")
 223
 224 def expect_gas_result(dev, result, status=None):
 225     ev = dev.wait_event(["GAS-QUERY-DONE"], timeout=10)
 226     if ev is None:
 227         raise Exception("GAS query timed out")
 228     if "result=" + result not in ev:
 229         raise Exception("Unexpected GAS query result")
 230     if status and "status_code=" + str(status) + ' ' not in ev:
 231         raise Exception("Unexpected GAS status code")
 232
 233 def anqp_get(dev, bssid, id):
 234     dev.request("ANQP_GET " + bssid + " " + str(id))
 235     ev = dev.wait_event(["GAS-QUERY-START"], timeout=5)
 236     if ev is None:
 237         raise Exception("GAS query start timed out")
 238
 239 def test_gas_timeout(dev, apdev):
 240     """GAS timeout"""
 241     hapd = start_ap(apdev[0])
 242     bssid = apdev[0]['bssid']
 243
 244     dev[0].scan(freq="2412")
 245     hapd.set("ext_mgmt_frame_handling", "1")
 246
 247     anqp_get(dev[0], bssid, 263)
 248
 249     ev = hapd.wait_event(["MGMT-RX"], timeout=5)
 250     if ev is None:
 251         raise Exception("MGMT RX wait timed out")
 252
 253     expect_gas_result(dev[0], "TIMEOUT")
 254
 255 MGMT_SUBTYPE_ACTION = 13
 256 ACTION_CATEG_PUBLIC = 4
 257
 258 GAS_INITIAL_REQUEST = 10
 259 GAS_INITIAL_RESPONSE = 11
 260 GAS_COMEBACK_REQUEST = 12
 261 GAS_COMEBACK_RESPONSE = 13
 262 GAS_ACTIONS = [ GAS_INITIAL_REQUEST, GAS_INITIAL_RESPONSE,
 263                 GAS_COMEBACK_REQUEST, GAS_COMEBACK_RESPONSE ]
 264
 265 def anqp_adv_proto():
 266     return struct.pack('BBBB', 108, 2, 127, 0)
 267
 268 def anqp_initial_resp(dialog_token, status_code, comeback_delay=0):
 269     return struct.pack('<BBBHH', ACTION_CATEG_PUBLIC, GAS_INITIAL_RESPONSE,
 270                        dialog_token, status_code, comeback_delay) + anqp_adv_proto()
 271
 272 def anqp_comeback_resp(dialog_token, status_code=0, id=0, more=False, comeback_delay=0, bogus_adv_proto=False):
 273     if more:
 274         id |= 0x80
 275     if bogus_adv_proto:
 276         adv = struct.pack('BBBB', 108, 2, 127, 1)
 277     else:
 278         adv = anqp_adv_proto()
 279     return struct.pack('<BBBHBH', ACTION_CATEG_PUBLIC, GAS_COMEBACK_RESPONSE,
 280                        dialog_token, status_code, id, comeback_delay) + adv
 281
 282 def gas_rx(hapd):
 283     count = 0
 284     while count < 30:
 285         count = count + 1
 286         query = hapd.mgmt_rx()
 287         if query is None:
 288             raise Exception("Action frame not received")
 289         if query['subtype'] != MGMT_SUBTYPE_ACTION:
 290             continue
 291         payload = query['payload']
 292         if len(payload) < 2:
 293             continue
 294         (category, action) = struct.unpack('BB', payload[0:2])
 295         if category != ACTION_CATEG_PUBLIC or action not in GAS_ACTIONS:
 296             continue
 297         return query
 298     raise Exception("No Action frame received")
 299
 300 def parse_gas(payload):
 301     pos = payload
 302     (category, action, dialog_token) = struct.unpack('BBB', pos[0:3])
 303     if category != ACTION_CATEG_PUBLIC:
 304         return None
 305     if action not in GAS_ACTIONS:
 306         return None
 307     gas = {}
 308     gas['action'] = action
 309     pos = pos[3:]
 310
 311     if len(pos) < 1 and action != GAS_COMEBACK_REQUEST:
 312         return None
 313
 314     gas['dialog_token'] = dialog_token
 315     return gas
 316
 317 def action_response(req):
 318     resp = {}
 319     resp['fc'] = req['fc']
 320     resp['da'] = req['sa']
 321     resp['sa'] = req['da']
 322     resp['bssid'] = req['bssid']
 323     return resp
 324
 325 def send_gas_resp(hapd, resp):
 326     hapd.mgmt_tx(resp)
 327     ev = hapd.wait_event(["MGMT-TX-STATUS"], timeout=5)
 328     if ev is None:
 329         raise Exception("Missing TX status for GAS response")
 330     if "ok=1" not in ev:
 331         raise Exception("GAS response not acknowledged")
 332
 333 def test_gas_invalid_response_type(dev, apdev):
 334     """GAS invalid response type"""
 335     hapd = start_ap(apdev[0])
 336     bssid = apdev[0]['bssid']
 337
 338     dev[0].scan(freq="2412")
 339     hapd.set("ext_mgmt_frame_handling", "1")
 340
 341     anqp_get(dev[0], bssid, 263)
 342
 343     query = gas_rx(hapd)
 344     gas = parse_gas(query['payload'])
 345
 346     resp = action_response(query)
 347     # GAS Comeback Response instead of GAS Initial Response
 348     resp['payload'] = anqp_comeback_resp(gas['dialog_token']) + struct.pack('<H', 0)
 349     send_gas_resp(hapd, resp)
 350
 351     # station drops the invalid frame, so this needs to result in GAS timeout
 352     expect_gas_result(dev[0], "TIMEOUT")
 353
 354 def test_gas_failure_status_code(dev, apdev):
 355     """GAS failure status code"""
 356     hapd = start_ap(apdev[0])
 357     bssid = apdev[0]['bssid']
 358
 359     dev[0].scan(freq="2412")
 360     hapd.set("ext_mgmt_frame_handling", "1")
 361
 362     anqp_get(dev[0], bssid, 263)
 363
 364     query = gas_rx(hapd)
 365     gas = parse_gas(query['payload'])
 366
 367     resp = action_response(query)
 368     resp['payload'] = anqp_initial_resp(gas['dialog_token'], 61) + struct.pack('<H', 0)
 369     send_gas_resp(hapd, resp)
 370
 371     expect_gas_result(dev[0], "FAILURE")
 372
 373 def test_gas_malformed(dev, apdev):
 374     """GAS malformed response frames"""
 375     hapd = start_ap(apdev[0])
 376     bssid = apdev[0]['bssid']
 377
 378     dev[0].scan(freq="2412")
 379     hapd.set("ext_mgmt_frame_handling", "1")
 380
 381     anqp_get(dev[0], bssid, 263)
 382
 383     query = gas_rx(hapd)
 384     gas = parse_gas(query['payload'])
 385
 386     resp = action_response(query)
 387
 388     resp['payload'] = struct.pack('<BBBH', ACTION_CATEG_PUBLIC,
 389                                   GAS_COMEBACK_RESPONSE,
 390                                   gas['dialog_token'], 0)
 391     hapd.mgmt_tx(resp)
 392
 393     resp['payload'] = struct.pack('<BBBHB', ACTION_CATEG_PUBLIC,
 394                                   GAS_COMEBACK_RESPONSE,
 395                                   gas['dialog_token'], 0, 0)
 396     hapd.mgmt_tx(resp)
 397
 398     hdr = struct.pack('<BBBHH', ACTION_CATEG_PUBLIC, GAS_INITIAL_RESPONSE,
 399                       gas['dialog_token'], 0, 0)
 400     resp['payload'] = hdr + struct.pack('B', 108)
 401     hapd.mgmt_tx(resp)
 402     resp['payload'] = hdr + struct.pack('BB', 108, 0)
 403     hapd.mgmt_tx(resp)
 404     resp['payload'] = hdr + struct.pack('BB', 108, 1)
 405     hapd.mgmt_tx(resp)
 406     resp['payload'] = hdr + struct.pack('BB', 108, 255)
 407     hapd.mgmt_tx(resp)
 408     resp['payload'] = hdr + struct.pack('BBB', 108, 1, 127)
 409     hapd.mgmt_tx(resp)
 410     resp['payload'] = hdr + struct.pack('BBB', 108, 2, 127)
 411     hapd.mgmt_tx(resp)
 412     resp['payload'] = hdr + struct.pack('BBBB', 0, 2, 127, 0)
 413     hapd.mgmt_tx(resp)
 414
 415     resp['payload'] = anqp_initial_resp(gas['dialog_token'], 0) + struct.pack('<H', 1)
 416     hapd.mgmt_tx(resp)
 417
 418     resp['payload'] = anqp_initial_resp(gas['dialog_token'], 0) + struct.pack('<HB', 2, 0)
 419     hapd.mgmt_tx(resp)
 420
 421     resp['payload'] = anqp_initial_resp(gas['dialog_token'], 0) + struct.pack('<H', 65535)
 422     hapd.mgmt_tx(resp)
 423
 424     resp['payload'] = anqp_initial_resp(gas['dialog_token'], 0) + struct.pack('<HBB', 1, 0, 0)
 425     hapd.mgmt_tx(resp)
 426
 427     # Station drops invalid frames, but the last of the responses is valid from
 428     # GAS view point even though it has an extra octet in the end and the ANQP
 429     # part of the response is not valid. This is reported as successfulyl
 430     # completed GAS exchange.
 431     expect_gas_result(dev[0], "SUCCESS")
 432
 433 def init_gas(hapd, bssid, dev):
 434     anqp_get(dev, bssid, 263)
 435     query = gas_rx(hapd)
 436     gas = parse_gas(query['payload'])
 437     dialog_token = gas['dialog_token']
 438
 439     resp = action_response(query)
 440     resp['payload'] = anqp_initial_resp(dialog_token, 0, comeback_delay=1) + struct.pack('<H', 0)
 441     send_gas_resp(hapd, resp)
 442
 443     query = gas_rx(hapd)
 444     gas = parse_gas(query['payload'])
 445     if gas['action'] != GAS_COMEBACK_REQUEST:
 446         raise Exception("Unexpected request action")
 447     if gas['dialog_token'] != dialog_token:
 448         raise Exception("Unexpected dialog token change")
 449     return query, dialog_token
 450
 451 def test_gas_malformed_comeback_resp(dev, apdev):
 452     """GAS malformed comeback response frames"""
 453     hapd = start_ap(apdev[0])
 454     bssid = apdev[0]['bssid']
 455
 456     dev[0].scan(freq="2412")
 457     hapd.set("ext_mgmt_frame_handling", "1")
 458
 459     logger.debug("Non-zero status code in comeback response")
 460     query, dialog_token = init_gas(hapd, bssid, dev[0])
 461     resp = action_response(query)
 462     resp['payload'] = anqp_comeback_resp(dialog_token, status_code=2) + struct.pack('<H', 0)
 463     send_gas_resp(hapd, resp)
 464     expect_gas_result(dev[0], "FAILURE", status=2)
 465
 466     logger.debug("Different advertisement protocol in comeback response")
 467     query, dialog_token = init_gas(hapd, bssid, dev[0])
 468     resp = action_response(query)
 469     resp['payload'] = anqp_comeback_resp(dialog_token, bogus_adv_proto=True) + struct.pack('<H', 0)
 470     send_gas_resp(hapd, resp)
 471     expect_gas_result(dev[0], "PEER_ERROR")
 472
 473     logger.debug("Non-zero frag id and comeback delay in comeback response")
 474     query, dialog_token = init_gas(hapd, bssid, dev[0])
 475     resp = action_response(query)
 476     resp['payload'] = anqp_comeback_resp(dialog_token, id=1, comeback_delay=1) + struct.pack('<H', 0)
 477     send_gas_resp(hapd, resp)
 478     expect_gas_result(dev[0], "PEER_ERROR")
 479
 480     logger.debug("Unexpected frag id in comeback response")
 481     query, dialog_token = init_gas(hapd, bssid, dev[0])
 482     resp = action_response(query)
 483     resp['payload'] = anqp_comeback_resp(dialog_token, id=1) + struct.pack('<H', 0)
 484     send_gas_resp(hapd, resp)
 485     expect_gas_result(dev[0], "PEER_ERROR")
 486
 487     logger.debug("Empty fragment and replay in comeback response")
 488     query, dialog_token = init_gas(hapd, bssid, dev[0])
 489     resp = action_response(query)
 490     resp['payload'] = anqp_comeback_resp(dialog_token, more=True) + struct.pack('<H', 0)
 491     send_gas_resp(hapd, resp)
 492     query = gas_rx(hapd)
 493     gas = parse_gas(query['payload'])
 494     if gas['action'] != GAS_COMEBACK_REQUEST:
 495         raise Exception("Unexpected request action")
 496     if gas['dialog_token'] != dialog_token:
 497         raise Exception("Unexpected dialog token change")
 498     resp = action_response(query)
 499     resp['payload'] = anqp_comeback_resp(dialog_token) + struct.pack('<H', 0)
 500     send_gas_resp(hapd, resp)
 501     resp['payload'] = anqp_comeback_resp(dialog_token, id=1) + struct.pack('<H', 0)
 502     send_gas_resp(hapd, resp)
 503     expect_gas_result(dev[0], "SUCCESS")
 504
 505     logger.debug("Unexpected initial response when waiting for comeback response")
 506     query, dialog_token = init_gas(hapd, bssid, dev[0])
 507     resp = action_response(query)
 508     resp['payload'] = anqp_initial_resp(dialog_token, 0) + struct.pack('<H', 0)
 509     send_gas_resp(hapd, resp)
 510     ev = hapd.wait_event(["MGMT-RX"], timeout=1)
 511     if ev is not None:
 512         raise Exception("Unexpected management frame")
 513     expect_gas_result(dev[0], "TIMEOUT")
 514
 515     logger.debug("Too short comeback response")
 516     query, dialog_token = init_gas(hapd, bssid, dev[0])
 517     resp = action_response(query)
 518     resp['payload'] = struct.pack('<BBBH', ACTION_CATEG_PUBLIC,
 519                                   GAS_COMEBACK_RESPONSE, dialog_token, 0)
 520     send_gas_resp(hapd, resp)
 521     ev = hapd.wait_event(["MGMT-RX"], timeout=1)
 522     if ev is not None:
 523         raise Exception("Unexpected management frame")
 524     expect_gas_result(dev[0], "TIMEOUT")
 525
 526     logger.debug("Too short comeback response(2)")
 527     query, dialog_token = init_gas(hapd, bssid, dev[0])
 528     resp = action_response(query)
 529     resp['payload'] = struct.pack('<BBBHBB', ACTION_CATEG_PUBLIC,
 530                                   GAS_COMEBACK_RESPONSE, dialog_token, 0, 0x80,
 531                                   0)
 532     send_gas_resp(hapd, resp)
 533     ev = hapd.wait_event(["MGMT-RX"], timeout=1)
 534     if ev is not None:
 535         raise Exception("Unexpected management frame")
 536     expect_gas_result(dev[0], "TIMEOUT")
 537
 538     logger.debug("Maximum comeback response fragment claiming more fragments")
 539     query, dialog_token = init_gas(hapd, bssid, dev[0])
 540     resp = action_response(query)
 541     resp['payload'] = anqp_comeback_resp(dialog_token, more=True) + struct.pack('<H', 0)
 542     send_gas_resp(hapd, resp)
 543     for i in range(1, 129):
 544         query = gas_rx(hapd)
 545         gas = parse_gas(query['payload'])
 546         if gas['action'] != GAS_COMEBACK_REQUEST:
 547             raise Exception("Unexpected request action")
 548         if gas['dialog_token'] != dialog_token:
 549             raise Exception("Unexpected dialog token change")
 550         resp = action_response(query)
 551         resp['payload'] = anqp_comeback_resp(dialog_token, id=i, more=True) + struct.pack('<H', 0)
 552         send_gas_resp(hapd, resp)
 553     expect_gas_result(dev[0], "PEER_ERROR")
 554
 555 def test_gas_comeback_resp_additional_delay(dev, apdev):
 556     """GAS comeback response requesting additional delay"""
 557     hapd = start_ap(apdev[0])
 558     bssid = apdev[0]['bssid']
 559
 560     dev[0].scan(freq="2412")
 561     hapd.set("ext_mgmt_frame_handling", "1")
 562
 563     query, dialog_token = init_gas(hapd, bssid, dev[0])
 564     for i in range(0, 2):
 565         resp = action_response(query)
 566         resp['payload'] = anqp_comeback_resp(dialog_token, status_code=95, comeback_delay=50) + struct.pack('<H', 0)
 567         send_gas_resp(hapd, resp)
 568         query = gas_rx(hapd)
 569         gas = parse_gas(query['payload'])
 570         if gas['action'] != GAS_COMEBACK_REQUEST:
 571             raise Exception("Unexpected request action")
 572         if gas['dialog_token'] != dialog_token:
 573             raise Exception("Unexpected dialog token change")
 574     resp = action_response(query)
 575     resp['payload'] = anqp_comeback_resp(dialog_token, status_code=0) + struct.pack('<H', 0)
 576     send_gas_resp(hapd, resp)
 577     expect_gas_result(dev[0], "SUCCESS")
 578
 579 def test_gas_unknown_adv_proto(dev, apdev):
 580     """Unknown advertisement protocol id"""
 581     bssid = apdev[0]['bssid']
 582     params = hs20_ap_params()
 583     params['hessid'] = bssid
 584     hostapd.add_ap(apdev[0]['ifname'], params)
 585
 586     dev[0].scan(freq="2412")
 587     req = dev[0].request("GAS_REQUEST " + bssid + " 42 000102000101")
 588     if "FAIL" in req:
 589         raise Exception("GAS query request rejected")
 590     expect_gas_result(dev[0], "FAILURE", "59")
 591     ev = dev[0].wait_event(["GAS-RESPONSE-INFO"], timeout=10)
 592     if ev is None:
 593         raise Exception("GAS query timed out")
 594     exp = r'<.>(GAS-RESPONSE-INFO) addr=([0-9a-f:]*) dialog_token=([0-9]*) status_code=([0-9]*) resp_len=([\-0-9]*)'
 595     res = re.split(exp, ev)
 596     if len(res) < 6:
 597         raise Exception("Could not parse GAS-RESPONSE-INFO")
 598     if res[2] != bssid:
 599         raise Exception("Unexpected BSSID in response")
 600     status = res[4]
 601     if status != "59":
 602         raise Exception("Unexpected GAS-RESPONSE-INFO status")