libeap/tests/hwsim/test_p2p_messages.py

   1 # P2P protocol tests for various messages
   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 binascii
   8 import struct
   9 import time
  10 import logging
  11 logger = logging.getLogger()
  12
  13 import hostapd
  14 from test_p2p_persistent import form
  15 from test_p2p_persistent import invite
  16
  17 MGMT_SUBTYPE_PROBE_REQ = 4
  18 MGMT_SUBTYPE_ACTION = 13
  19 ACTION_CATEG_PUBLIC = 4
  20
  21 P2P_GO_NEG_REQ = 0
  22 P2P_GO_NEG_RESP = 1
  23 P2P_GO_NEG_CONF = 2
  24 P2P_INVITATION_REQ = 3
  25 P2P_INVITATION_RESP = 4
  26 P2P_DEV_DISC_REQ = 5
  27 P2P_DEV_DISC_RESP = 6
  28 P2P_PROV_DISC_REQ = 7
  29 P2P_PROV_DISC_RESP = 8
  30
  31 P2P_ATTR_STATUS = 0
  32 P2P_ATTR_MINOR_REASON_CODE = 1
  33 P2P_ATTR_CAPABILITY = 2
  34 P2P_ATTR_DEVICE_ID = 3
  35 P2P_ATTR_GROUP_OWNER_INTENT = 4
  36 P2P_ATTR_CONFIGURATION_TIMEOUT = 5
  37 P2P_ATTR_LISTEN_CHANNEL = 6
  38 P2P_ATTR_GROUP_BSSID = 7
  39 P2P_ATTR_EXT_LISTEN_TIMING = 8
  40 P2P_ATTR_INTENDED_INTERFACE_ADDR = 9
  41 P2P_ATTR_MANAGEABILITY = 10
  42 P2P_ATTR_CHANNEL_LIST = 11
  43 P2P_ATTR_NOTICE_OF_ABSENCE = 12
  44 P2P_ATTR_DEVICE_INFO = 13
  45 P2P_ATTR_GROUP_INFO = 14
  46 P2P_ATTR_GROUP_ID = 15
  47 P2P_ATTR_INTERFACE = 16
  48 P2P_ATTR_OPERATING_CHANNEL = 17
  49 P2P_ATTR_INVITATION_FLAGS = 18
  50 P2P_ATTR_OOB_GO_NEG_CHANNEL = 19
  51 P2P_ATTR_SERVICE_HASH = 21
  52 P2P_ATTR_SESSION_INFORMATION_DATA = 22
  53 P2P_ATTR_CONNECTION_CAPABILITY = 23
  54 P2P_ATTR_ADVERTISEMENT_ID = 24
  55 P2P_ATTR_ADVERTISED_SERVICE = 25
  56 P2P_ATTR_SESSION_ID = 26
  57 P2P_ATTR_FEATURE_CAPABILITY = 27
  58 P2P_ATTR_PERSISTENT_GROUP = 28
  59 P2P_ATTR_VENDOR_SPECIFIC = 221
  60
  61 P2P_SC_SUCCESS = 0
  62 P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE = 1
  63 P2P_SC_FAIL_INCOMPATIBLE_PARAMS = 2
  64 P2P_SC_FAIL_LIMIT_REACHED = 3
  65 P2P_SC_FAIL_INVALID_PARAMS = 4
  66 P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE = 5
  67 P2P_SC_FAIL_PREV_PROTOCOL_ERROR = 6
  68 P2P_SC_FAIL_NO_COMMON_CHANNELS = 7
  69 P2P_SC_FAIL_UNKNOWN_GROUP = 8
  70 P2P_SC_FAIL_BOTH_GO_INTENT_15 = 9
  71 P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD = 10
  72 P2P_SC_FAIL_REJECTED_BY_USER = 11
  73
  74 WSC_ATTR_CONFIG_METHODS = 0x1008
  75
  76 WLAN_EID_SSID = 0
  77 WLAN_EID_SUPP_RATES = 1
  78 WLAN_EID_VENDOR_SPECIFIC = 221
  79
  80 def ie_ssid(ssid):
  81     return struct.pack("<BB", WLAN_EID_SSID, len(ssid)) + ssid
  82
  83 def ie_supp_rates():
  84     return struct.pack("<BBBBBBBBBB", WLAN_EID_SUPP_RATES, 8,
  85                        2*6, 2*9, 2*12, 2*18, 2*24, 2*36, 2*48, 2*54)
  86
  87 def ie_p2p(attrs):
  88     return struct.pack("<BBBBBB", WLAN_EID_VENDOR_SPECIFIC, 4 + len(attrs),
  89                        0x50, 0x6f, 0x9a, 9) + attrs
  90
  91 def ie_wsc(attrs):
  92     return struct.pack("<BBBBBB", WLAN_EID_VENDOR_SPECIFIC, 4 + len(attrs),
  93                        0x00, 0x50, 0xf2, 4) + attrs
  94
  95 def wsc_attr_config_methods(methods=0):
  96     return struct.pack(">HHH", WSC_ATTR_CONFIG_METHODS, 2, methods)
  97
  98 def p2p_attr_status(status=P2P_SC_SUCCESS):
  99     return struct.pack("<BHB", P2P_ATTR_STATUS, 1, status)
 100
 101 def p2p_attr_minor_reason_code(code=0):
 102     return struct.pack("<BHB", P2P_ATTR_MINOR_REASON_CODE, 1, code)
 103
 104 def p2p_attr_capability(dev_capab=0, group_capab=0):
 105     return struct.pack("<BHBB", P2P_ATTR_CAPABILITY, 2, dev_capab, group_capab)
 106
 107 def p2p_attr_device_id(addr):
 108     val = struct.unpack('6B', binascii.unhexlify(addr.replace(':','')))
 109     t = (P2P_ATTR_DEVICE_ID, 6) + val
 110     return struct.pack('<BH6B', *t)
 111
 112 def p2p_attr_go_intent(go_intent=0, tie_breaker=0):
 113     return struct.pack("<BHB", P2P_ATTR_GROUP_OWNER_INTENT, 1,
 114                        (go_intent << 1) | (tie_breaker & 0x01))
 115
 116 def p2p_attr_config_timeout(go_config_timeout=0, client_config_timeout=0):
 117     return struct.pack("<BHBB", P2P_ATTR_CONFIGURATION_TIMEOUT, 2,
 118                        go_config_timeout, client_config_timeout)
 119
 120 def p2p_attr_listen_channel(op_class=81, chan=1):
 121     return struct.pack("<BHBBBBB", P2P_ATTR_LISTEN_CHANNEL, 5,
 122                        0x58, 0x58, 0x04, op_class, chan)
 123
 124 def p2p_attr_group_bssid(addr):
 125     val = struct.unpack('6B', binascii.unhexlify(addr.replace(':','')))
 126     t = (P2P_ATTR_GROUP_BSSID, 6) + val
 127     return struct.pack('<BH6B', *t)
 128
 129 def p2p_attr_ext_listen_timing(period=0, interval=0):
 130     return struct.pack("<BHHH", P2P_ATTR_EXT_LISTEN_TIMING, 4, period, interval)
 131
 132 def p2p_attr_intended_interface_addr(addr):
 133     val = struct.unpack('6B', binascii.unhexlify(addr.replace(':','')))
 134     t = (P2P_ATTR_INTENDED_INTERFACE_ADDR, 6) + val
 135     return struct.pack('<BH6B', *t)
 136
 137 def p2p_attr_manageability(bitmap=0):
 138     return struct.pack("<BHB", P2P_ATTR_MANAGEABILITY, 1, bitmap)
 139
 140 def p2p_attr_channel_list():
 141     return struct.pack("<BH3BBB11B", P2P_ATTR_CHANNEL_LIST, 16,
 142                        0x58, 0x58, 0x04,
 143                        81, 11, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
 144
 145 def p2p_attr_device_info(addr, name="Test", config_methods=0, dev_type="00010050F2040001"):
 146     val = struct.unpack('6B', binascii.unhexlify(addr.replace(':','')))
 147     val2 = struct.unpack('8B', binascii.unhexlify(dev_type))
 148     t = (P2P_ATTR_DEVICE_INFO, 6 + 2 + 8 + 1 + 4 + len(name)) + val + (config_methods,) + val2 + (0,)
 149     return struct.pack("<BH6BH8BB", *t) + struct.pack('>HH', 0x1011, len(name)) +name
 150
 151 def p2p_attr_group_id(addr, ssid):
 152     val = struct.unpack('6B', binascii.unhexlify(addr.replace(':','')))
 153     t = (P2P_ATTR_GROUP_ID, 6 + len(ssid)) + val
 154     return struct.pack('<BH6B', *t) + ssid
 155
 156 def p2p_attr_operating_channel(op_class=81, chan=1):
 157     return struct.pack("<BHBBBBB", P2P_ATTR_OPERATING_CHANNEL, 5,
 158                        0x58, 0x58, 0x04, op_class, chan)
 159
 160 def p2p_attr_invitation_flags(bitmap=0):
 161     return struct.pack("<BHB", P2P_ATTR_INVITATION_FLAGS, 1, bitmap)
 162
 163 def p2p_hdr_helper(dst, src, type=None, dialog_token=1, req=True):
 164     msg = {}
 165     msg['fc'] = MGMT_SUBTYPE_ACTION << 4
 166     msg['da'] = dst
 167     msg['sa'] = src
 168     if req:
 169         msg['bssid'] = dst
 170     else:
 171         msg['bssid'] = src
 172     msg['payload'] = struct.pack("<BBBBBB",
 173                                  ACTION_CATEG_PUBLIC, 9, 0x50, 0x6f, 0x9a, 9)
 174     if type is not None:
 175         msg['payload'] += struct.pack("<B", type)
 176         if dialog_token:
 177             msg['payload'] += struct.pack("<B", dialog_token)
 178     return msg
 179
 180 def p2p_hdr(dst, src, type=None, dialog_token=1):
 181     return p2p_hdr_helper(dst, src, type, dialog_token, True)
 182
 183 def p2p_hdr_resp(dst, src, type=None, dialog_token=1):
 184     return p2p_hdr_helper(dst, src, type, dialog_token, False)
 185
 186 def start_p2p(dev, apdev):
 187     addr0 = dev[0].p2p_dev_addr()
 188     dev[0].p2p_listen()
 189     dev[1].p2p_find(social=True)
 190     ev = dev[1].wait_global_event(["P2P-DEVICE-FOUND"], timeout=5)
 191     if ev is None:
 192         raise Exception("Device discovery timed out")
 193     dev[1].p2p_stop_find()
 194     peer = dev[1].get_peer(addr0)
 195
 196     bssid = apdev[0]['bssid']
 197     params = { 'ssid': "test", 'beacon_int': "2000" }
 198     if peer['listen_freq'] == "2412":
 199         params['channel'] = '1'
 200     elif peer['listen_freq'] == "2437":
 201         params['channel'] = '6'
 202     elif peer['listen_freq'] == "2462":
 203         params['channel'] = '11'
 204     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
 205     hapd.set("ext_mgmt_frame_handling", "1")
 206     return addr0, bssid, hapd, int(params['channel'])
 207
 208 def p2p_probe(hapd, src, chan=1):
 209     msg = {}
 210     msg['fc'] = MGMT_SUBTYPE_PROBE_REQ << 4
 211     msg['da'] = "ff:ff:ff:ff:ff:ff"
 212     msg['sa'] = src
 213     msg['bssid'] = "ff:ff:ff:ff:ff:ff"
 214     attrs = p2p_attr_listen_channel(chan=chan)
 215     msg['payload'] = ie_ssid("DIRECT-") + ie_supp_rates() + ie_p2p(attrs)
 216     hapd.mgmt_tx(msg)
 217
 218 def parse_p2p_public_action(payload):
 219     pos = payload
 220     (category, action) = struct.unpack('BB', pos[0:2])
 221     if category != ACTION_CATEG_PUBLIC:
 222         return None
 223     if action != 9:
 224         return None
 225     pos = pos[2:]
 226     (oui1,oui2,oui3,subtype) = struct.unpack('BBBB', pos[0:4])
 227     if oui1 != 0x50 or oui2 != 0x6f or oui3 != 0x9a or subtype != 9:
 228         return None
 229     pos = pos[4:]
 230     (subtype,dialog_token) = struct.unpack('BB', pos[0:2])
 231     p2p = {}
 232     p2p['subtype'] = subtype
 233     p2p['dialog_token'] = dialog_token
 234     pos = pos[2:]
 235     p2p['elements'] = pos
 236     while len(pos) > 2:
 237         (id,elen) = struct.unpack('BB', pos[0:2])
 238         pos = pos[2:]
 239         if elen > len(pos):
 240             raise Exception("Truncated IE in P2P Public Action frame (elen=%d left=%d)" % (elen, len(pos)))
 241         if id == WLAN_EID_VENDOR_SPECIFIC:
 242             if elen < 4:
 243                 raise Exception("Too short vendor specific IE in P2P Public Action frame (elen=%d)" % elen)
 244             (oui1,oui2,oui3,subtype) = struct.unpack('BBBB', pos[0:4])
 245             if oui1 == 0x50 and oui2 == 0x6f and oui3 == 0x9a and subtype == 9:
 246                 if 'p2p' in p2p:
 247                     p2p['p2p'] += pos[4:elen]
 248                 else:
 249                     p2p['p2p'] = pos[4:elen]
 250             if oui1 == 0x00 and oui2 == 0x50 and oui3 == 0xf2 and subtype == 4:
 251                 p2p['wsc'] = pos[4:elen]
 252         pos = pos[elen:]
 253     if len(pos) > 0:
 254         raise Exception("Invalid element in P2P Public Action frame")
 255
 256     if 'p2p' in p2p:
 257         p2p['p2p_attrs'] = {}
 258         pos = p2p['p2p']
 259         while len(pos) >= 3:
 260             (id,alen) = struct.unpack('<BH', pos[0:3])
 261             pos = pos[3:]
 262             if alen > len(pos):
 263                 logger.info("P2P payload: " + binascii.hexlify(p2p['p2p']))
 264                 raise Exception("Truncated P2P attribute in P2P Public Action frame (alen=%d left=%d p2p-payload=%d)" % (alen, len(pos), len(p2p['p2p'])))
 265             p2p['p2p_attrs'][id] = pos[0:alen]
 266             pos = pos[alen:]
 267         if P2P_ATTR_STATUS in p2p['p2p_attrs']:
 268             p2p['p2p_status'] = struct.unpack('B', p2p['p2p_attrs'][P2P_ATTR_STATUS])[0]
 269
 270     if 'wsc' in p2p:
 271         p2p['wsc_attrs'] = {}
 272         pos = p2p['wsc']
 273         while len(pos) >= 4:
 274             (id,alen) = struct.unpack('>HH', pos[0:4])
 275             pos = pos[4:]
 276             if alen > len(pos):
 277                 logger.info("WSC payload: " + binascii.hexlify(p2p['wsc']))
 278                 raise Exception("Truncated WSC attribute in P2P Public Action frame (alen=%d left=%d wsc-payload=%d)" % (alen, len(pos), len(p2p['wsc'])))
 279             p2p['wsc_attrs'][id] = pos[0:alen]
 280             pos = pos[alen:]
 281
 282     return p2p
 283
 284 def test_p2p_msg_empty(dev, apdev):
 285     """P2P protocol test: empty P2P Public Action frame"""
 286     dst, src, hapd, channel = start_p2p(dev, apdev)
 287     msg = p2p_hdr(dst, src)
 288     hapd.mgmt_tx(msg)
 289
 290 def test_p2p_msg_long_ssid(dev, apdev):
 291     """P2P protocol test: Too long SSID in P2P Public Action frame"""
 292     dst, src, hapd, channel = start_p2p(dev, apdev)
 293
 294     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=1)
 295     attrs = p2p_attr_config_timeout()
 296     attrs += p2p_attr_invitation_flags()
 297     attrs += p2p_attr_operating_channel()
 298     attrs += p2p_attr_group_bssid(src)
 299     attrs += p2p_attr_channel_list()
 300     attrs += p2p_attr_group_id(src, 'DIRECT-foo')
 301     attrs += p2p_attr_device_info(src, config_methods=0x0108)
 302     msg['payload'] += ie_p2p(attrs)
 303     msg['payload'] += ie_ssid(255 * 'A')
 304     hapd.mgmt_tx(msg)
 305     ev = dev[0].wait_event(["P2P-DEVICE-FOUND"], timeout=5)
 306     if ev is None:
 307         raise Exception("Timeout on device found event")
 308
 309 def test_p2p_msg_long_dev_name(dev, apdev):
 310     """P2P protocol test: Too long Device Name in P2P Public Action frame"""
 311     dst, src, hapd, channel = start_p2p(dev, apdev)
 312
 313     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=1)
 314     attrs = p2p_attr_config_timeout()
 315     attrs += p2p_attr_invitation_flags()
 316     attrs += p2p_attr_operating_channel()
 317     attrs += p2p_attr_group_bssid(src)
 318     attrs += p2p_attr_channel_list()
 319     attrs += p2p_attr_group_id(src, 'DIRECT-foo')
 320     attrs += p2p_attr_device_info(src, config_methods=0x0108,
 321                                   name="123456789012345678901234567890123")
 322     msg['payload'] += ie_p2p(attrs)
 323     hapd.mgmt_tx(msg)
 324     ev = dev[0].wait_event(["P2P-DEVICE-FOUND"], timeout=0.1)
 325     if ev is not None:
 326         raise Exception("Unexpected device found event")
 327
 328 def test_p2p_msg_invitation_req(dev, apdev):
 329     """P2P protocol tests for invitation request processing"""
 330     dst, src, hapd, channel = start_p2p(dev, apdev)
 331
 332     # Empty P2P Invitation Request (missing dialog token)
 333     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=None)
 334     hapd.mgmt_tx(msg)
 335     dialog_token = 0
 336
 337     # Various p2p_parse() failure cases due to invalid attributes
 338
 339     # Too short attribute header
 340     dialog_token += 1
 341     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 342     attrs = struct.pack("<BB", P2P_ATTR_CAPABILITY, 0)
 343     msg['payload'] += ie_p2p(attrs)
 344     hapd.mgmt_tx(msg)
 345
 346     # Minimal attribute underflow
 347     dialog_token += 1
 348     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 349     attrs = struct.pack("<BH", P2P_ATTR_CAPABILITY, 1)
 350     msg['payload'] += ie_p2p(attrs)
 351     hapd.mgmt_tx(msg)
 352
 353     # Large attribute underflow
 354     dialog_token += 1
 355     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 356     attrs = struct.pack("<BHB", P2P_ATTR_CAPABILITY, 0xffff, 1)
 357     msg['payload'] += ie_p2p(attrs)
 358     hapd.mgmt_tx(msg)
 359
 360     # Too short Capability attribute
 361     dialog_token += 1
 362     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 363     attrs = struct.pack("<BHB", P2P_ATTR_CAPABILITY, 1, 0)
 364     msg['payload'] += ie_p2p(attrs)
 365     hapd.mgmt_tx(msg)
 366
 367     # Too short Device ID attribute
 368     dialog_token += 1
 369     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 370     val = struct.unpack('5B', binascii.unhexlify("1122334455"))
 371     t = (P2P_ATTR_DEVICE_ID, 5) + val
 372     attrs = struct.pack('<BH5B', *t)
 373     msg['payload'] += ie_p2p(attrs)
 374     hapd.mgmt_tx(msg)
 375
 376     # Too short GO Intent attribute
 377     dialog_token += 1
 378     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 379     attrs = struct.pack("<BH", P2P_ATTR_GROUP_OWNER_INTENT, 0)
 380     msg['payload'] += ie_p2p(attrs)
 381     hapd.mgmt_tx(msg)
 382
 383     # Too short Status attribute
 384     dialog_token += 1
 385     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 386     attrs = struct.pack("<BH", P2P_ATTR_STATUS, 0)
 387     msg['payload'] += ie_p2p(attrs)
 388     hapd.mgmt_tx(msg)
 389
 390     # null Listen channel and too short Listen Channel attribute
 391     dialog_token += 1
 392     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 393     attrs = struct.pack("<BH", P2P_ATTR_LISTEN_CHANNEL, 0)
 394     attrs += struct.pack("<BHB", P2P_ATTR_LISTEN_CHANNEL, 1, 0)
 395     msg['payload'] += ie_p2p(attrs)
 396     hapd.mgmt_tx(msg)
 397
 398     # null Operating channel and too short Operating Channel attribute
 399     dialog_token += 1
 400     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 401     attrs = struct.pack("<BH", P2P_ATTR_OPERATING_CHANNEL, 0)
 402     attrs += struct.pack("<BHB", P2P_ATTR_OPERATING_CHANNEL, 1, 0)
 403     msg['payload'] += ie_p2p(attrs)
 404     hapd.mgmt_tx(msg)
 405
 406     # Too short Channel List attribute
 407     dialog_token += 1
 408     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 409     attrs = struct.pack("<BHBB", P2P_ATTR_CHANNEL_LIST, 2, 1, 2)
 410     msg['payload'] += ie_p2p(attrs)
 411     hapd.mgmt_tx(msg)
 412
 413     # Too short Device Info attribute
 414     dialog_token += 1
 415     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 416     attrs = struct.pack("<BHBB", P2P_ATTR_DEVICE_INFO, 2, 1, 2)
 417     msg['payload'] += ie_p2p(attrs)
 418     hapd.mgmt_tx(msg)
 419
 420     # Truncated Secondary Device Types in Device Info attribute
 421     dialog_token += 1
 422     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 423     attrs = struct.pack("<BH6BH8BB", P2P_ATTR_DEVICE_INFO, 6 + 2 + 8 + 1,
 424                         0, 0, 0, 0, 0, 0,
 425                         0,
 426                         0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x11, 0x22,
 427                         255)
 428     msg['payload'] += ie_p2p(attrs)
 429     hapd.mgmt_tx(msg)
 430
 431     # Missing Device Name in Device Info attribute
 432     dialog_token += 1
 433     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 434     attrs = struct.pack("<BH6BH8BB8B", P2P_ATTR_DEVICE_INFO, 6 + 2 + 8 + 1 + 8,
 435                         0, 0, 0, 0, 0, 0,
 436                         0,
 437                         0, 0, 0, 0, 0, 0, 0, 0,
 438                         1,
 439                         1, 2, 3, 4, 5, 6, 7, 8)
 440     msg['payload'] += ie_p2p(attrs)
 441     hapd.mgmt_tx(msg)
 442
 443     # Invalid Device Name header in Device Info attribute
 444     dialog_token += 1
 445     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 446     attrs = struct.pack("<BH6BH8BB8B4B", P2P_ATTR_DEVICE_INFO, 6 + 2 + 8 + 1 + 8 + 4,
 447                         0, 0, 0, 0, 0, 0,
 448                         0,
 449                         0, 0, 0, 0, 0, 0, 0, 0,
 450                         1,
 451                         1, 2, 3, 4, 5, 6, 7, 8,
 452                         0x11, 0x12, 0, 0)
 453     msg['payload'] += ie_p2p(attrs)
 454     hapd.mgmt_tx(msg)
 455
 456     # Invalid Device Name header length in Device Info attribute
 457     dialog_token += 1
 458     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 459     attrs = struct.pack("<BH6BH8BB8B4B", P2P_ATTR_DEVICE_INFO, 6 + 2 + 8 + 1 + 8 + 4,
 460                         0, 0, 0, 0, 0, 0,
 461                         0,
 462                         0, 0, 0, 0, 0, 0, 0, 0,
 463                         1,
 464                         1, 2, 3, 4, 5, 6, 7, 8,
 465                         0x10, 0x11, 0xff, 0xff)
 466     msg['payload'] += ie_p2p(attrs)
 467     hapd.mgmt_tx(msg)
 468
 469     # Invalid Device Name header length in Device Info attribute
 470     dialog_token += 1
 471     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 472     devname = 'A'
 473     attrs = struct.pack("<BH6BH8BB8B4B", P2P_ATTR_DEVICE_INFO, 6 + 2 + 8 + 1 + 8 + 4 + len(devname),
 474                         0, 0, 0, 0, 0, 0,
 475                         0,
 476                         0, 0, 0, 0, 0, 0, 0, 0,
 477                         1,
 478                         1, 2, 3, 4, 5, 6, 7, 8,
 479                         0x10, 0x11, 0, len(devname) + 1) + devname
 480     msg['payload'] += ie_p2p(attrs)
 481     hapd.mgmt_tx(msg)
 482
 483     # Device Name filtering and too long Device Name in Device Info attribute
 484     dialog_token += 1
 485     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 486     attrs = struct.pack("<BH6BH8BB8B4B4B", P2P_ATTR_DEVICE_INFO, 6 + 2 + 8 + 1 + 8 + 4 + 4,
 487                         0, 0, 0, 0, 0, 0,
 488                         0,
 489                         0, 0, 0, 0, 0, 0, 0, 0,
 490                         1,
 491                         1, 2, 3, 4, 5, 6, 7, 8,
 492                         0x10, 0x11, 0, 4,
 493                         64, 9, 0, 64)
 494     devname = '123456789012345678901234567890123'
 495     attrs += struct.pack("<BH6BH8BB8B4B", P2P_ATTR_DEVICE_INFO, 6 + 2 + 8 + 1 + 8 + 4 + len(devname),
 496                          0, 0, 0, 0, 0, 0,
 497                          0,
 498                          0, 0, 0, 0, 0, 0, 0, 0,
 499                          1,
 500                          1, 2, 3, 4, 5, 6, 7, 8,
 501                          0x10, 0x11, 0, len(devname)) + devname
 502     msg['payload'] += ie_p2p(attrs)
 503     hapd.mgmt_tx(msg)
 504
 505     # Too short Configuration Timeout attribute
 506     dialog_token += 1
 507     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 508     attrs = struct.pack("<BHB", P2P_ATTR_CONFIGURATION_TIMEOUT, 1, 1)
 509     msg['payload'] += ie_p2p(attrs)
 510     hapd.mgmt_tx(msg)
 511
 512     # Too short Intended P2P Interface Address attribute
 513     dialog_token += 1
 514     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 515     attrs = struct.pack("<BHB", P2P_ATTR_INTENDED_INTERFACE_ADDR, 1, 1)
 516     msg['payload'] += ie_p2p(attrs)
 517     hapd.mgmt_tx(msg)
 518
 519     # Too short P2P Group BSSID attribute
 520     dialog_token += 1
 521     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 522     attrs = struct.pack("<BHB", P2P_ATTR_GROUP_BSSID, 1, 1)
 523     msg['payload'] += ie_p2p(attrs)
 524     hapd.mgmt_tx(msg)
 525
 526     # Too short P2P Group ID attribute
 527     dialog_token += 1
 528     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 529     attrs = struct.pack("<BHB", P2P_ATTR_GROUP_ID, 1, 1)
 530     msg['payload'] += ie_p2p(attrs)
 531     hapd.mgmt_tx(msg)
 532
 533     # Too long P2P Group ID attribute
 534     dialog_token += 1
 535     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 536     attrs = struct.pack("<BH6B", P2P_ATTR_GROUP_ID, 6 + 33, 0, 0, 0, 0, 0, 0) + "123456789012345678901234567890123"
 537     msg['payload'] += ie_p2p(attrs)
 538     hapd.mgmt_tx(msg)
 539
 540     # Too short Invitation Flags attribute
 541     dialog_token += 1
 542     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 543     attrs = struct.pack("<BH", P2P_ATTR_INVITATION_FLAGS, 0)
 544     msg['payload'] += ie_p2p(attrs)
 545     hapd.mgmt_tx(msg)
 546
 547     # Valid and too short Manageability attribute
 548     dialog_token += 1
 549     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 550     attrs = p2p_attr_manageability()
 551     attrs += struct.pack("<BH", P2P_ATTR_MANAGEABILITY, 0)
 552     msg['payload'] += ie_p2p(attrs)
 553     hapd.mgmt_tx(msg)
 554
 555     # Too short NoA attribute
 556     dialog_token += 1
 557     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 558     attrs = struct.pack("<BHB", P2P_ATTR_NOTICE_OF_ABSENCE, 1, 1)
 559     msg['payload'] += ie_p2p(attrs)
 560     hapd.mgmt_tx(msg)
 561
 562     # Valid and too short Extended Listen Timing attributes
 563     dialog_token += 1
 564     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 565     attrs = p2p_attr_ext_listen_timing(period=100, interval=50)
 566     attrs += struct.pack("<BHBBB", P2P_ATTR_EXT_LISTEN_TIMING, 3, 0, 0, 0)
 567     msg['payload'] += ie_p2p(attrs)
 568     hapd.mgmt_tx(msg)
 569
 570     # Valid and too short Minor Reason Code attributes
 571     dialog_token += 1
 572     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 573     attrs = p2p_attr_minor_reason_code(code=2)
 574     attrs += struct.pack("<BH", P2P_ATTR_MINOR_REASON_CODE, 0)
 575     msg['payload'] += ie_p2p(attrs)
 576     hapd.mgmt_tx(msg)
 577
 578     # Unknown attribute and too short OOB GO Negotiation Channel attribute
 579     dialog_token += 1
 580     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 581     attrs = struct.pack("<BHB", 99, 1, 1)
 582     attrs += struct.pack("<BHB", P2P_ATTR_OOB_GO_NEG_CHANNEL, 1, 1)
 583     msg['payload'] += ie_p2p(attrs)
 584     hapd.mgmt_tx(msg)
 585
 586     # Too short Service Hash attribute
 587     dialog_token += 1
 588     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 589     attrs = struct.pack("<BH5B", P2P_ATTR_SERVICE_HASH, 5, 1, 2, 3, 4, 5)
 590     msg['payload'] += ie_p2p(attrs)
 591     hapd.mgmt_tx(msg)
 592
 593     # Too short Connection Capability attribute
 594     dialog_token += 1
 595     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 596     attrs = struct.pack("<BH", P2P_ATTR_CONNECTION_CAPABILITY, 0)
 597     msg['payload'] += ie_p2p(attrs)
 598     hapd.mgmt_tx(msg)
 599
 600     # Too short Advertisement ID attribute
 601     dialog_token += 1
 602     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 603     attrs = struct.pack("<BH9B", P2P_ATTR_ADVERTISEMENT_ID, 9, 1, 2, 3, 4, 5,
 604                         6, 7, 8, 9)
 605     msg['payload'] += ie_p2p(attrs)
 606     hapd.mgmt_tx(msg)
 607
 608     # Truncated and too short Service Instance attributes
 609     dialog_token += 1
 610     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 611     attrs = struct.pack("<BH8B", P2P_ATTR_ADVERTISED_SERVICE, 8, 1, 2, 3, 4, 5,
 612                         6, 2, 8)
 613     attrs += struct.pack("<BH7B", P2P_ATTR_ADVERTISED_SERVICE, 7, 1, 2, 3, 4, 5,
 614                          6, 7)
 615     msg['payload'] += ie_p2p(attrs)
 616     hapd.mgmt_tx(msg)
 617
 618     # Too short Session ID attribute
 619     dialog_token += 1
 620     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 621     attrs = struct.pack("<BH4B", P2P_ATTR_SESSION_ID, 4, 1, 2, 3, 4)
 622     msg['payload'] += ie_p2p(attrs)
 623     hapd.mgmt_tx(msg)
 624
 625     # Too short Feature Capability attribute
 626     dialog_token += 1
 627     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 628     attrs = struct.pack("<BH", P2P_ATTR_FEATURE_CAPABILITY, 0)
 629     msg['payload'] += ie_p2p(attrs)
 630     hapd.mgmt_tx(msg)
 631
 632     # Too short Persistent Group attribute
 633     dialog_token += 1
 634     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 635     attrs = struct.pack("<BH5B", P2P_ATTR_PERSISTENT_GROUP, 5, 1, 2, 3, 4, 5)
 636     msg['payload'] += ie_p2p(attrs)
 637     hapd.mgmt_tx(msg)
 638
 639     # Too long Persistent Group attribute
 640     dialog_token += 1
 641     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 642     attrs = struct.pack("<BH9L3B", P2P_ATTR_PERSISTENT_GROUP, 6 + 32 + 1,
 643                         1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3)
 644     msg['payload'] += ie_p2p(attrs)
 645     hapd.mgmt_tx(msg)
 646
 647     if hapd.mgmt_rx(timeout=0.5) is not None:
 648         raise Exception("Unexpected management frame received")
 649
 650     dev[0].dump_monitor()
 651     dialog_token += 1
 652     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 653     attrs = p2p_attr_config_timeout()
 654     attrs += p2p_attr_invitation_flags()
 655     attrs += p2p_attr_operating_channel()
 656     attrs += p2p_attr_group_bssid(src)
 657     attrs += p2p_attr_channel_list()
 658     attrs += p2p_attr_group_id(src, "DIRECT-foo")
 659     attrs += p2p_attr_device_info(src, config_methods=0x0108)
 660     msg['payload'] += ie_p2p(attrs)
 661     hapd.mgmt_tx(msg)
 662     ev = dev[0].wait_global_event(["P2P-DEVICE-FOUND"], timeout=5)
 663     if ev is None:
 664         raise Exception("Timeout on device found event")
 665     ev = dev[0].wait_global_event(["P2P-INVITATION-RECEIVED"], timeout=5)
 666     if ev is None:
 667         raise Exception("Timeout on invitation event " + str(dialog_token))
 668     if hapd.mgmt_rx(timeout=1) is None:
 669         raise Exception("No invitation response " + str(dialog_token))
 670
 671     time.sleep(0.1)
 672     dev[0].dump_monitor()
 673     dialog_token += 1
 674     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 675     attrs = p2p_attr_config_timeout()
 676     attrs += p2p_attr_invitation_flags()
 677     attrs += p2p_attr_operating_channel()
 678     attrs += p2p_attr_group_bssid(src)
 679     attrs += p2p_attr_channel_list()
 680     attrs += p2p_attr_group_id(src, "DIRECT-foo")
 681     attrs += p2p_attr_device_info(src, config_methods=0x0108)
 682     msg['payload'] += ie_p2p(attrs)
 683     hapd.mgmt_tx(msg)
 684     ev = dev[0].wait_global_event(["P2P-INVITATION-RECEIVED"], timeout=5)
 685     if ev is None:
 686         raise Exception("Timeout on invitation event " + str(dialog_token))
 687     if hapd.mgmt_rx(timeout=1) is None:
 688         raise Exception("No invitation response " + str(dialog_token))
 689
 690     time.sleep(0.1)
 691     dev[0].dump_monitor()
 692     dialog_token += 1
 693     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 694     #attrs = p2p_attr_config_timeout()
 695     attrs = p2p_attr_invitation_flags()
 696     attrs += p2p_attr_operating_channel()
 697     attrs += p2p_attr_group_bssid(src)
 698     attrs += p2p_attr_channel_list()
 699     attrs += p2p_attr_group_id(src, "DIRECT-foo")
 700     attrs += p2p_attr_device_info(src, config_methods=0x0108)
 701     msg['payload'] += ie_p2p(attrs)
 702     hapd.mgmt_tx(msg)
 703     if hapd.mgmt_rx(timeout=1) is None:
 704         raise Exception("No invitation response " + str(dialog_token))
 705
 706     time.sleep(0.1)
 707     dev[0].dump_monitor()
 708     dialog_token += 1
 709     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 710     attrs = p2p_attr_config_timeout()
 711     #attrs = p2p_attr_invitation_flags()
 712     attrs += p2p_attr_operating_channel()
 713     attrs += p2p_attr_group_bssid(src)
 714     attrs += p2p_attr_channel_list()
 715     attrs += p2p_attr_group_id(src, "DIRECT-foo")
 716     attrs += p2p_attr_device_info(src, config_methods=0x0108)
 717     msg['payload'] += ie_p2p(attrs)
 718     hapd.mgmt_tx(msg)
 719     if hapd.mgmt_rx(timeout=1) is None:
 720         raise Exception("No invitation response " + str(dialog_token))
 721
 722     time.sleep(0.1)
 723     dev[0].dump_monitor()
 724     dialog_token += 1
 725     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 726     attrs = p2p_attr_config_timeout()
 727     attrs = p2p_attr_invitation_flags()
 728     #attrs += p2p_attr_operating_channel()
 729     attrs += p2p_attr_group_bssid(src)
 730     attrs += p2p_attr_channel_list()
 731     attrs += p2p_attr_group_id(src, "DIRECT-foo")
 732     attrs += p2p_attr_device_info(src, config_methods=0x0108)
 733     msg['payload'] += ie_p2p(attrs)
 734     hapd.mgmt_tx(msg)
 735     if hapd.mgmt_rx(timeout=1) is None:
 736         raise Exception("No invitation response " + str(dialog_token))
 737
 738     time.sleep(0.1)
 739     dev[0].dump_monitor()
 740     dialog_token += 1
 741     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 742     attrs = p2p_attr_config_timeout()
 743     attrs = p2p_attr_invitation_flags()
 744     attrs += p2p_attr_operating_channel()
 745     #attrs += p2p_attr_group_bssid(src)
 746     attrs += p2p_attr_channel_list()
 747     attrs += p2p_attr_group_id(src, "DIRECT-foo")
 748     attrs += p2p_attr_device_info(src, config_methods=0x0108)
 749     msg['payload'] += ie_p2p(attrs)
 750     hapd.mgmt_tx(msg)
 751     if hapd.mgmt_rx(timeout=1) is None:
 752         raise Exception("No invitation response " + str(dialog_token))
 753
 754     time.sleep(0.1)
 755     dev[0].dump_monitor()
 756     dialog_token += 1
 757     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 758     attrs = p2p_attr_config_timeout()
 759     attrs = p2p_attr_invitation_flags()
 760     attrs += p2p_attr_operating_channel()
 761     attrs += p2p_attr_group_bssid(src)
 762     #attrs += p2p_attr_channel_list()
 763     attrs += p2p_attr_group_id(src, "DIRECT-foo")
 764     attrs += p2p_attr_device_info(src, config_methods=0x0108)
 765     msg['payload'] += ie_p2p(attrs)
 766     hapd.mgmt_tx(msg)
 767     if hapd.mgmt_rx(timeout=1) is None:
 768         raise Exception("No invitation response " + str(dialog_token))
 769
 770     time.sleep(0.1)
 771     dev[0].dump_monitor()
 772     dialog_token += 1
 773     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 774     attrs = p2p_attr_config_timeout()
 775     attrs = p2p_attr_invitation_flags()
 776     attrs += p2p_attr_operating_channel()
 777     attrs += p2p_attr_group_bssid(src)
 778     attrs += p2p_attr_channel_list()
 779     #attrs += p2p_attr_group_id(src, "DIRECT-foo")
 780     attrs += p2p_attr_device_info(src, config_methods=0x0108)
 781     msg['payload'] += ie_p2p(attrs)
 782     hapd.mgmt_tx(msg)
 783     if hapd.mgmt_rx(timeout=1) is None:
 784         raise Exception("No invitation response " + str(dialog_token))
 785
 786     time.sleep(0.1)
 787     dev[0].dump_monitor()
 788     dialog_token += 1
 789     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 790     attrs = p2p_attr_config_timeout()
 791     attrs = p2p_attr_invitation_flags()
 792     attrs += p2p_attr_operating_channel()
 793     attrs += p2p_attr_group_bssid(src)
 794     attrs += p2p_attr_channel_list()
 795     attrs += p2p_attr_group_id(src, "DIRECT-foo")
 796     #attrs += p2p_attr_device_info(src, config_methods=0x0108)
 797     msg['payload'] += ie_p2p(attrs)
 798     hapd.mgmt_tx(msg)
 799     if hapd.mgmt_rx(timeout=1) is None:
 800         raise Exception("No invitation response " + str(dialog_token))
 801
 802     time.sleep(0.1)
 803     dev[0].dump_monitor()
 804     dialog_token += 1
 805     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 806     hapd.mgmt_tx(msg)
 807     if hapd.mgmt_rx(timeout=1) is None:
 808         raise Exception("No invitation response " + str(dialog_token))
 809
 810     # Unusable peer operating channel preference
 811     time.sleep(0.1)
 812     dev[0].dump_monitor()
 813     dialog_token += 1
 814     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 815     attrs = p2p_attr_config_timeout()
 816     attrs = p2p_attr_invitation_flags()
 817     attrs += p2p_attr_operating_channel(chan=15)
 818     attrs += p2p_attr_group_bssid(src)
 819     attrs += p2p_attr_channel_list()
 820     attrs += p2p_attr_group_id(src, "DIRECT-foo")
 821     attrs += p2p_attr_device_info(src, config_methods=0x0108)
 822     msg['payload'] += ie_p2p(attrs)
 823     hapd.mgmt_tx(msg)
 824     if hapd.mgmt_rx(timeout=1) is None:
 825         raise Exception("No invitation response " + str(dialog_token))
 826
 827 def test_p2p_msg_invitation_req_to_go(dev, apdev):
 828     """P2P protocol tests for invitation request processing on GO device"""
 829     res = form(dev[0], dev[1])
 830     dev[0].dump_monitor()
 831     dev[1].dump_monitor()
 832     addr0 = dev[0].p2p_dev_addr()
 833     addr1 = dev[1].p2p_dev_addr()
 834     peer = dev[1].get_peer(addr0)
 835     listen_freq = peer['listen_freq']
 836
 837     if "FAIL" in dev[1].request("SET ext_mgmt_frame_handling 1"):
 838         raise Exception("Failed to enable external management frame handling")
 839
 840     networks = dev[0].list_networks()
 841     if len(networks) != 1:
 842         raise Exception("Unexpected number of networks")
 843     if "[P2P-PERSISTENT]" not in networks[0]['flags']:
 844         raise Exception("Not the persistent group data")
 845     dev[0].p2p_start_go(persistent=networks[0]['id'], freq=listen_freq)
 846
 847     dialog_token = 0
 848
 849     # Unusable peer operating channel preference
 850     dialog_token += 1
 851     msg = p2p_hdr(addr0, addr1, type=P2P_INVITATION_REQ,
 852                   dialog_token=dialog_token)
 853     attrs = p2p_attr_config_timeout()
 854     attrs = p2p_attr_invitation_flags(bitmap=1)
 855     attrs += p2p_attr_operating_channel(chan=15)
 856     attrs += p2p_attr_channel_list()
 857     attrs += p2p_attr_group_id(res['go_dev_addr'], res['ssid'])
 858     attrs += p2p_attr_device_info(addr1, config_methods=0x0108)
 859     msg['payload'] += ie_p2p(attrs)
 860
 861     mgmt_tx(dev[1], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr0, addr0, peer['listen_freq'], binascii.hexlify(msg['payload'])))
 862
 863     rx_msg = dev[1].mgmt_rx()
 864     if rx_msg is None:
 865         raise Exception("MGMT-RX timeout")
 866     p2p = parse_p2p_public_action(rx_msg['payload'])
 867     if p2p is None:
 868         raise Exception("Not a P2P Public Action frame " + str(dialog_token))
 869     if p2p['subtype'] != P2P_INVITATION_RESP:
 870         raise Exception("Unexpected subtype %d" % p2p['subtype'])
 871     if p2p['p2p_status'] != 0:
 872         raise Exception("Unexpected status %d" % p2p['p2p_status'])
 873
 874     # Forced channel re-selection due to channel list
 875     dialog_token += 1
 876     msg = p2p_hdr(addr0, addr1, type=P2P_INVITATION_REQ,
 877                   dialog_token=dialog_token)
 878     attrs = p2p_attr_config_timeout()
 879     attrs = p2p_attr_invitation_flags(bitmap=1)
 880     attrs += struct.pack("<BH3BBBB", P2P_ATTR_CHANNEL_LIST, 6,
 881                          0x58, 0x58, 0x04,
 882                          81, 1, 3)
 883     attrs += p2p_attr_group_id(res['go_dev_addr'], res['ssid'])
 884     attrs += p2p_attr_device_info(addr1, config_methods=0x0108)
 885     msg['payload'] += ie_p2p(attrs)
 886
 887     mgmt_tx(dev[1], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr0, addr0, peer['listen_freq'], binascii.hexlify(msg['payload'])))
 888
 889     rx_msg = dev[1].mgmt_rx()
 890     if rx_msg is None:
 891         raise Exception("MGMT-RX timeout")
 892     p2p = parse_p2p_public_action(rx_msg['payload'])
 893     if p2p is None:
 894         raise Exception("Not a P2P Public Action frame " + str(dialog_token))
 895     if p2p['subtype'] != P2P_INVITATION_RESP:
 896         raise Exception("Unexpected subtype %d" % p2p['subtype'])
 897     if p2p['p2p_status'] != 7 and dev[1].get_mcc() <= 1:
 898         raise Exception("Unexpected status %d" % p2p['p2p_status'])
 899
 900 def test_p2p_msg_invitation_req_unknown(dev, apdev):
 901     """P2P protocol tests for invitation request from unknown peer"""
 902     dst, src, hapd, channel = start_p2p(dev, apdev)
 903     dialog_token = 0
 904
 905     dialog_token += 1
 906     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 907     attrs = p2p_attr_config_timeout()
 908     attrs += p2p_attr_invitation_flags()
 909     attrs += p2p_attr_operating_channel()
 910     attrs += p2p_attr_group_bssid(src)
 911     attrs += p2p_attr_channel_list()
 912     #attrs += p2p_attr_group_id(src, "DIRECT-foo")
 913     #attrs += p2p_attr_device_info(src, config_methods=0x0108)
 914     msg['payload'] += ie_p2p(attrs)
 915     hapd.mgmt_tx(msg)
 916     ev = dev[0].wait_global_event(["P2P-INVITATION-RECEIVED"], timeout=5)
 917     if ev is None:
 918         raise Exception("Timeout on invitation event " + str(dialog_token))
 919     if hapd.mgmt_rx(timeout=1) is None:
 920         raise Exception("No invitation response " + str(dialog_token))
 921
 922 def test_p2p_msg_invitation_no_common_channels(dev, apdev):
 923     """P2P protocol tests for invitation request without common channels"""
 924     dst, src, hapd, channel = start_p2p(dev, apdev)
 925     dialog_token = 0
 926
 927     dialog_token += 1
 928     msg = p2p_hdr(dst, src, type=P2P_INVITATION_REQ, dialog_token=dialog_token)
 929     attrs = p2p_attr_config_timeout()
 930     attrs += p2p_attr_invitation_flags()
 931     attrs += p2p_attr_operating_channel()
 932     attrs += p2p_attr_group_bssid(src)
 933     attrs += struct.pack("<BH3BBB", P2P_ATTR_CHANNEL_LIST, 5,
 934                          0x58, 0x58, 0x04,
 935                          81, 0)
 936     attrs += p2p_attr_group_id(src, "DIRECT-foo")
 937     attrs += p2p_attr_device_info(src, config_methods=0x0108)
 938     msg['payload'] += ie_p2p(attrs)
 939     hapd.mgmt_tx(msg)
 940     if hapd.mgmt_rx(timeout=1) is None:
 941         raise Exception("No invitation response " + str(dialog_token))
 942     ev = dev[0].wait_event(["P2P-INVITATION-RECEIVED"], timeout=0.1)
 943     if ev is not None:
 944         raise Exception("Unexpected invitation event")
 945
 946 def test_p2p_msg_invitation_resp(dev, apdev):
 947     """P2P protocol tests for invitation response processing"""
 948     form(dev[0], dev[1])
 949     dev[0].dump_monitor()
 950     dev[1].dump_monitor()
 951
 952     dst, src, hapd, channel = start_p2p(dev, apdev)
 953
 954     addr0 = dev[0].p2p_dev_addr()
 955     addr1 = dev[1].p2p_dev_addr()
 956     peer = dev[1].get_peer(addr0)
 957
 958     # P2P Invitation Response from unknown peer
 959     msg = p2p_hdr(dst, src, type=P2P_INVITATION_RESP, dialog_token=1)
 960     hapd.mgmt_tx(msg)
 961
 962     # P2P Invitation Response from peer that is not in invitation
 963     msg = p2p_hdr(dst, src, type=P2P_INVITATION_RESP, dialog_token=2)
 964     attrs = p2p_attr_status()
 965     msg['payload'] += ie_p2p(attrs)
 966     mgmt_tx(dev[1], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr0, addr0, peer['listen_freq'], binascii.hexlify(msg['payload'])))
 967     time.sleep(0.25)
 968
 969     if "FAIL" in dev[1].request("SET ext_mgmt_frame_handling 1"):
 970         raise Exception("Failed to enable external management frame handling")
 971
 972     invite(dev[0], dev[1])
 973     rx_msg = dev[1].mgmt_rx()
 974     if rx_msg is None:
 975         raise Exception("MGMT-RX timeout")
 976     p2p = parse_p2p_public_action(rx_msg['payload'])
 977     if p2p is None:
 978         raise Exception("Not a P2P Public Action frame " + str(dialog_token))
 979     if p2p['subtype'] != P2P_INVITATION_REQ:
 980         raise Exception("Unexpected subtype %d" % p2p['subtype'])
 981
 982     # Invalid attribute to cause p2p_parse() failure
 983     msg = p2p_hdr(dst, src, type=P2P_INVITATION_RESP, dialog_token=p2p['dialog_token'])
 984     attrs = struct.pack("<BB", P2P_ATTR_CAPABILITY, 0)
 985     msg['payload'] += ie_p2p(attrs)
 986     mgmt_tx(dev[1], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr0, addr0, rx_msg['freq'], binascii.hexlify(msg['payload'])))
 987
 988     invite(dev[0], dev[1])
 989     rx_msg = dev[1].mgmt_rx()
 990     if rx_msg is None:
 991         raise Exception("MGMT-RX timeout")
 992     p2p = parse_p2p_public_action(rx_msg['payload'])
 993     if p2p is None:
 994         raise Exception("Not a P2P Public Action frame " + str(dialog_token))
 995     if p2p['subtype'] != P2P_INVITATION_REQ:
 996         raise Exception("Unexpected subtype %d" % p2p['subtype'])
 997
 998     # missing mandatory Status attribute
 999     msg = p2p_hdr(dst, src, type=P2P_INVITATION_RESP, dialog_token=p2p['dialog_token'])
1000     attrs = p2p_attr_channel_list()
1001     msg['payload'] += ie_p2p(attrs)
1002     mgmt_tx(dev[1], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr0, addr0, rx_msg['freq'], binascii.hexlify(msg['payload'])))
1003
1004     invite(dev[0], dev[1])
1005     rx_msg = dev[1].mgmt_rx()
1006     if rx_msg is None:
1007         raise Exception("MGMT-RX timeout")
1008     p2p = parse_p2p_public_action(rx_msg['payload'])
1009     if p2p is None:
1010         raise Exception("Not a P2P Public Action frame " + str(dialog_token))
1011     if p2p['subtype'] != P2P_INVITATION_REQ:
1012         raise Exception("Unexpected subtype %d" % p2p['subtype'])
1013
1014     # no channel match (no common channel found at all)
1015     msg = p2p_hdr(dst, src, type=P2P_INVITATION_RESP, dialog_token=p2p['dialog_token'])
1016     attrs = p2p_attr_status()
1017     attrs += struct.pack("<BH3BBBB", P2P_ATTR_CHANNEL_LIST, 6,
1018                          0x58, 0x58, 0x04,
1019                          81, 1, 15)
1020     msg['payload'] += ie_p2p(attrs)
1021     mgmt_tx(dev[1], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr0, addr0, rx_msg['freq'], binascii.hexlify(msg['payload'])))
1022
1023     invite(dev[0], dev[1])
1024     rx_msg = dev[1].mgmt_rx()
1025     if rx_msg is None:
1026         raise Exception("MGMT-RX timeout")
1027     p2p = parse_p2p_public_action(rx_msg['payload'])
1028     if p2p is None:
1029         raise Exception("Not a P2P Public Action frame " + str(dialog_token))
1030     if p2p['subtype'] != P2P_INVITATION_REQ:
1031         raise Exception("Unexpected subtype %d" % p2p['subtype'])
1032
1033     # no channel match (no acceptable P2P channel)
1034     msg = p2p_hdr(dst, src, type=P2P_INVITATION_RESP, dialog_token=p2p['dialog_token'])
1035     attrs = p2p_attr_status()
1036     attrs += struct.pack("<BH3BBBB", P2P_ATTR_CHANNEL_LIST, 6,
1037                          0x58, 0x58, 0x04,
1038                          81, 1, 12)
1039     msg['payload'] += ie_p2p(attrs)
1040     mgmt_tx(dev[1], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr0, addr0, rx_msg['freq'], binascii.hexlify(msg['payload'])))
1041
1042     invite(dev[0], dev[1])
1043     rx_msg = dev[1].mgmt_rx()
1044     if rx_msg is None:
1045         raise Exception("MGMT-RX timeout")
1046     p2p = parse_p2p_public_action(rx_msg['payload'])
1047     if p2p is None:
1048         raise Exception("Not a P2P Public Action frame " + str(dialog_token))
1049     if p2p['subtype'] != P2P_INVITATION_REQ:
1050         raise Exception("Unexpected subtype %d" % p2p['subtype'])
1051
1052     # missing mandatory Channel List attribute (ignored as a workaround)
1053     msg = p2p_hdr(dst, src, type=P2P_INVITATION_RESP, dialog_token=p2p['dialog_token'])
1054     attrs = p2p_attr_status()
1055     msg['payload'] += ie_p2p(attrs)
1056     mgmt_tx(dev[1], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr0, addr0, rx_msg['freq'], binascii.hexlify(msg['payload'])))
1057
1058     ev = dev[0].wait_global_event(["P2P-GROUP-STARTED"], timeout=15);
1059     if ev is None:
1060         raise Exception("Group was not started")
1061
1062 def test_p2p_msg_invitation_resend(dev, apdev):
1063     """P2P protocol tests for invitation resending on no-common-channels"""
1064     form(dev[0], dev[1])
1065     dev[0].dump_monitor()
1066     dev[1].dump_monitor()
1067     addr0 = dev[0].p2p_dev_addr()
1068     addr1 = dev[1].p2p_dev_addr()
1069
1070     if "FAIL" in dev[1].request("SET ext_mgmt_frame_handling 1"):
1071         raise Exception("Failed to enable external management frame handling")
1072
1073     logger.info("Forced channel in invitation")
1074     invite(dev[0], dev[1], extra="freq=2422")
1075     rx_msg = dev[1].mgmt_rx()
1076     if rx_msg is None:
1077         raise Exception("MGMT-RX timeout")
1078     p2p = parse_p2p_public_action(rx_msg['payload'])
1079     if p2p is None:
1080         raise Exception("Not a P2P Public Action frame " + str(dialog_token))
1081     if p2p['subtype'] != P2P_INVITATION_REQ:
1082         raise Exception("Unexpected subtype %d" % p2p['subtype'])
1083     msg = p2p_hdr(addr0, addr1, type=P2P_INVITATION_RESP,
1084                   dialog_token=p2p['dialog_token'])
1085     attrs = p2p_attr_status(status=P2P_SC_FAIL_NO_COMMON_CHANNELS)
1086     msg['payload'] += ie_p2p(attrs)
1087     mgmt_tx(dev[1], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr0, addr0, rx_msg['freq'], binascii.hexlify(msg['payload'])))
1088     ev = dev[0].wait_global_event(["P2P-INVITATION-RESULT"], timeout=15)
1089     if ev is None:
1090         raise Exception("Timeout on invitation result");
1091     if "status=7" not in ev:
1092         raise Exception("Unexpected invitation result: " + ev)
1093
1094     logger.info("Any channel allowed, only preference provided in invitation");
1095     invite(dev[0], dev[1], extra="pref=2422")
1096     rx_msg = dev[1].mgmt_rx()
1097     if rx_msg is None:
1098         raise Exception("MGMT-RX timeout")
1099     p2p = parse_p2p_public_action(rx_msg['payload'])
1100     if p2p is None:
1101         raise Exception("Not a P2P Public Action frame " + str(dialog_token))
1102     if p2p['subtype'] != P2P_INVITATION_REQ:
1103         raise Exception("Unexpected subtype %d" % p2p['subtype'])
1104     msg = p2p_hdr(addr0, addr1, type=P2P_INVITATION_RESP,
1105                   dialog_token=p2p['dialog_token'])
1106     attrs = p2p_attr_status(status=P2P_SC_FAIL_NO_COMMON_CHANNELS)
1107     msg['payload'] += ie_p2p(attrs)
1108     if "FAIL" in dev[1].request("SET ext_mgmt_frame_handling 0"):
1109         raise Exception("Failed to disable external management frame handling")
1110     mgmt_tx(dev[1], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr0, addr0, rx_msg['freq'], binascii.hexlify(msg['payload'])))
1111     ev = dev[0].wait_global_event(["P2P-INVITATION-RESULT"], timeout=15)
1112     if ev is None:
1113         raise Exception("Timeout on invitation result");
1114     if "status=0" not in ev:
1115         raise Exception("Unexpected invitation result: " + ev)
1116
1117     ev = dev[0].wait_global_event(["P2P-GROUP-STARTED"], timeout=15);
1118     if ev is None:
1119         raise Exception("Group was not started on dev0")
1120     ev = dev[1].wait_global_event(["P2P-GROUP-STARTED"], timeout=15);
1121     if ev is None:
1122         raise Exception("Group was not started on dev1")
1123
1124 def test_p2p_msg_invitation_resend_duplicate(dev, apdev):
1125     """P2P protocol tests for invitation resending on no-common-channels and duplicated response"""
1126     form(dev[0], dev[1])
1127     dev[0].dump_monitor()
1128     dev[1].dump_monitor()
1129     addr0 = dev[0].p2p_dev_addr()
1130     addr1 = dev[1].p2p_dev_addr()
1131
1132     if "FAIL" in dev[1].request("SET ext_mgmt_frame_handling 1"):
1133         raise Exception("Failed to enable external management frame handling")
1134
1135     logger.info("Any channel allowed, only preference provided in invitation");
1136     invite(dev[0], dev[1], extra="pref=2422")
1137     rx_msg = dev[1].mgmt_rx()
1138     if rx_msg is None:
1139         raise Exception("MGMT-RX timeout")
1140     p2p = parse_p2p_public_action(rx_msg['payload'])
1141     if p2p is None:
1142         raise Exception("Not a P2P Public Action frame " + str(dialog_token))
1143     if p2p['subtype'] != P2P_INVITATION_REQ:
1144         raise Exception("Unexpected subtype %d" % p2p['subtype'])
1145     msg = p2p_hdr(addr0, addr1, type=P2P_INVITATION_RESP,
1146                   dialog_token=p2p['dialog_token'])
1147     attrs = p2p_attr_status(status=P2P_SC_FAIL_NO_COMMON_CHANNELS)
1148     msg['payload'] += ie_p2p(attrs)
1149     mgmt_tx(dev[1], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr0, addr0, rx_msg['freq'], binascii.hexlify(msg['payload'])))
1150
1151     rx_msg = dev[1].mgmt_rx()
1152     if rx_msg is None:
1153         raise Exception("MGMT-RX timeout")
1154     p2p = parse_p2p_public_action(rx_msg['payload'])
1155     if p2p is None:
1156         raise Exception("Not a P2P Public Action frame " + str(dialog_token))
1157     if p2p['subtype'] != P2P_INVITATION_REQ:
1158         raise Exception("Unexpected subtype %d" % p2p['subtype'])
1159
1160     logger.info("Retransmit duplicate of previous response")
1161     mgmt_tx(dev[1], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr0, addr0, rx_msg['freq'], binascii.hexlify(msg['payload'])))
1162
1163     logger.info("Transmit real response")
1164     msg = p2p_hdr(addr0, addr1, type=P2P_INVITATION_RESP,
1165                   dialog_token=p2p['dialog_token'])
1166     attrs = p2p_attr_status(status=P2P_SC_SUCCESS)
1167     attrs += p2p_attr_channel_list()
1168     msg['payload'] += ie_p2p(attrs)
1169     if "FAIL" in dev[1].request("MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr0, addr0, rx_msg['freq'], binascii.hexlify(msg['payload']))):
1170         raise Exception("Failed to transmit real response")
1171     dev[1].request("SET ext_mgmt_frame_handling 0")
1172
1173     ev = dev[0].wait_global_event(["P2P-INVITATION-RESULT"], timeout=10)
1174     if ev is None:
1175         raise Exception("Timeout on invitation result");
1176     if "status=0" not in ev:
1177         raise Exception("Unexpected invitation result: " + ev)
1178     ev = dev[0].wait_global_event(["P2P-GROUP-STARTED"], timeout=10)
1179     if ev is None:
1180         raise Exception("Group formation timed out")
1181     dev[0].group_form_result(ev)
1182     dev[0].remove_group()
1183
1184 def test_p2p_msg_pd_req(dev, apdev):
1185     """P2P protocol tests for provision discovery request processing"""
1186     dst, src, hapd, channel = start_p2p(dev, apdev)
1187     dialog_token = 0
1188
1189     # Too short attribute header
1190     dialog_token += 1
1191     msg = p2p_hdr(dst, src, type=P2P_PROV_DISC_REQ, dialog_token=dialog_token)
1192     attrs = struct.pack("<BB", P2P_ATTR_CAPABILITY, 0)
1193     msg['payload'] += ie_p2p(attrs)
1194     hapd.mgmt_tx(msg)
1195
1196     if hapd.mgmt_rx(timeout=0.5) is not None:
1197         raise Exception("Unexpected management frame received")
1198
1199     # No attributes
1200     dialog_token += 1
1201     msg = p2p_hdr(dst, src, type=P2P_PROV_DISC_REQ, dialog_token=dialog_token)
1202     attrs = ""
1203     msg['payload'] += ie_p2p(attrs)
1204     hapd.mgmt_tx(msg)
1205     if hapd.mgmt_rx(timeout=1) is None:
1206         raise Exception("No PD response " + str(dialog_token))
1207
1208     # Valid request
1209     time.sleep(0.1)
1210     dialog_token += 1
1211     msg = p2p_hdr(dst, src, type=P2P_PROV_DISC_REQ, dialog_token=dialog_token)
1212     attrs = wsc_attr_config_methods(methods=0x1008)
1213     msg['payload'] += ie_wsc(attrs)
1214     attrs = p2p_attr_capability()
1215     attrs += p2p_attr_device_info(src, config_methods=0x0108)
1216     msg['payload'] += ie_p2p(attrs)
1217     hapd.mgmt_tx(msg)
1218     ev = dev[0].wait_global_event(["P2P-DEVICE-FOUND"], timeout=5)
1219     if ev is None:
1220         raise Exception("Timeout on device found event")
1221     ev = dev[0].wait_global_event(["P2P-PROV-DISC-SHOW-PIN"], timeout=5)
1222     if ev is None:
1223         raise Exception("Timeout on PD event")
1224     if hapd.mgmt_rx(timeout=1) is None:
1225         raise Exception("No PD response " + str(dialog_token))
1226
1227     # Unknown group
1228     time.sleep(0.1)
1229     dialog_token += 1
1230     msg = p2p_hdr(dst, src, type=P2P_PROV_DISC_REQ, dialog_token=dialog_token)
1231     attrs = wsc_attr_config_methods(methods=0x1008)
1232     msg['payload'] += ie_wsc(attrs)
1233     attrs = p2p_attr_capability()
1234     attrs += p2p_attr_device_info(src, config_methods=0x0108)
1235     attrs += p2p_attr_group_id("02:02:02:02:02:02", "DIRECT-foo")
1236     msg['payload'] += ie_p2p(attrs)
1237     hapd.mgmt_tx(msg)
1238     if hapd.mgmt_rx(timeout=1) is None:
1239         raise Exception("No PD response " + str(dialog_token))
1240     ev = dev[0].wait_global_event(["P2P-PROV-DISC-SHOW-PIN"], timeout=1)
1241     if ev is not None:
1242         raise Exception("Unexpected PD event")
1243
1244     # Listen channel is not yet known
1245     if "FAIL" not in dev[0].global_request("P2P_PROV_DISC " + src + " display"):
1246         raise Exception("Unexpected P2P_PROV_DISC success")
1247
1248     # Unknown peer
1249     if "FAIL" not in dev[0].global_request("P2P_PROV_DISC 02:03:04:05:06:07 display"):
1250         raise Exception("Unexpected P2P_PROV_DISC success (2)")
1251
1252 def test_p2p_msg_pd(dev, apdev):
1253     """P2P protocol tests for provision discovery request processing (known)"""
1254     dst, src, hapd, channel = start_p2p(dev, apdev)
1255     dialog_token = 0
1256
1257     p2p_probe(hapd, src, chan=channel)
1258     time.sleep(0.1)
1259
1260     # Valid request
1261     dialog_token += 1
1262     msg = p2p_hdr(dst, src, type=P2P_PROV_DISC_REQ, dialog_token=dialog_token)
1263     attrs = wsc_attr_config_methods(methods=0x1008)
1264     msg['payload'] += ie_wsc(attrs)
1265     attrs = p2p_attr_capability()
1266     attrs += p2p_attr_device_info(src, config_methods=0x0108)
1267     msg['payload'] += ie_p2p(attrs)
1268     hapd.mgmt_tx(msg)
1269     ev = dev[0].wait_global_event(["P2P-DEVICE-FOUND"], timeout=5)
1270     if ev is None:
1271         raise Exception("Timeout on device found event")
1272     ev = dev[0].wait_global_event(["P2P-PROV-DISC-SHOW-PIN"], timeout=5)
1273     if ev is None:
1274         raise Exception("Timeout on PD event")
1275     if hapd.mgmt_rx(timeout=1) is None:
1276         raise Exception("No PD response " + str(dialog_token))
1277
1278     if "FAIL" in dev[0].global_request("P2P_PROV_DISC " + src + " display"):
1279         raise Exception("Unexpected P2P_PROV_DISC failure")
1280     frame = hapd.mgmt_rx(timeout=1)
1281     if frame is None:
1282         raise Exception("No PD request " + str(dialog_token))
1283     p2p = parse_p2p_public_action(frame['payload'])
1284     if p2p is None:
1285         raise Exception("Failed to parse PD request")
1286
1287     # invalid dialog token
1288     msg = p2p_hdr_resp(dst, src, type=P2P_PROV_DISC_RESP,
1289                        dialog_token=p2p['dialog_token'] + 1)
1290     hapd.mgmt_tx(msg)
1291     ev = dev[0].wait_global_event(["P2P-PROV-DISC-FAILURE"], timeout=0.1)
1292     if ev is not None:
1293         raise Exception("Unexpected PD result event")
1294
1295     # valid dialog token
1296     msg = p2p_hdr_resp(dst, src, type=P2P_PROV_DISC_RESP,
1297                        dialog_token=p2p['dialog_token'])
1298     hapd.mgmt_tx(msg)
1299     ev = dev[0].wait_global_event(["P2P-PROV-DISC-FAILURE"], timeout=5)
1300     if ev is None:
1301         raise Exception("Timeout on PD result event")
1302
1303     # valid dialog token
1304     msg = p2p_hdr_resp(dst, src, type=P2P_PROV_DISC_RESP,
1305                        dialog_token=p2p['dialog_token'])
1306     hapd.mgmt_tx(msg)
1307     ev = dev[0].wait_global_event(["P2P-PROV-DISC-FAILURE"], timeout=0.1)
1308     if ev is not None:
1309         raise Exception("Unexpected PD result event")
1310
1311 def check_p2p_response(hapd, dialog_token, status):
1312     resp = hapd.mgmt_rx(timeout=2)
1313     if resp is None:
1314         raise Exception("No GO Neg Response " + str(dialog_token))
1315     p2p = parse_p2p_public_action(resp['payload'])
1316     if p2p is None:
1317         raise Exception("Not a P2P Public Action frame " + str(dialog_token))
1318     if dialog_token != p2p['dialog_token']:
1319         raise Exception("Unexpected dialog token in response")
1320     if p2p['p2p_status'] != status:
1321         raise Exception("Unexpected status code %s in response (expected %d)" % (p2p['p2p_status'], status))
1322
1323 def test_p2p_msg_go_neg_both_start(dev, apdev):
1324     """P2P protocol test for simultaneous GO Neg initiation"""
1325     addr0 = dev[0].p2p_dev_addr()
1326     addr1 = dev[1].p2p_dev_addr()
1327     dev[0].p2p_listen()
1328     dev[1].discover_peer(addr0)
1329     dev[1].p2p_listen()
1330     dev[0].discover_peer(addr1)
1331     dev[0].p2p_listen()
1332     if "FAIL" in dev[0].request("SET ext_mgmt_frame_handling 1"):
1333         raise Exception("Failed to enable external management frame handling")
1334     if "FAIL" in dev[1].request("SET ext_mgmt_frame_handling 1"):
1335         raise Exception("Failed to enable external management frame handling")
1336     dev[0].request("P2P_CONNECT {} pbc".format(addr1))
1337     dev[1].request("P2P_CONNECT {} pbc".format(addr0))
1338     msg = dev[0].mgmt_rx()
1339     if msg is None:
1340         raise Exception("MGMT-RX timeout")
1341     msg = dev[1].mgmt_rx()
1342     if msg is None:
1343         raise Exception("MGMT-RX timeout(2)")
1344     if "FAIL" in dev[0].request("SET ext_mgmt_frame_handling 0"):
1345         raise Exception("Failed to disable external management frame handling")
1346     ev = dev[0].wait_global_event(["P2P-GO-NEG-SUCCESS"], timeout=2)
1347     if ev is not None:
1348         raise Exception("Unexpected GO Neg success")
1349     if "FAIL" in dev[1].request("SET ext_mgmt_frame_handling 0"):
1350         raise Exception("Failed to disable external management frame handling")
1351     ev = dev[0].wait_global_event(["P2P-GO-NEG-SUCCESS"], timeout=10)
1352     if ev is None:
1353         raise Exception("GO Neg did not succeed")
1354     ev = dev[0].wait_global_event(["P2P-GROUP-STARTED"], timeout=5);
1355     if ev is None:
1356         raise Exception("Group formation not succeed")
1357     ev = dev[1].wait_global_event(["P2P-GROUP-STARTED"], timeout=5);
1358     if ev is None:
1359         raise Exception("Group formation not succeed")
1360
1361 def test_p2p_msg_go_neg_req(dev, apdev):
1362     """P2P protocol tests for invitation request from unknown peer"""
1363     dst, src, hapd, channel = start_p2p(dev, apdev)
1364     dialog_token = 0
1365
1366     # invalid attribute
1367     dialog_token += 1
1368     msg = p2p_hdr(dst, src, type=P2P_GO_NEG_REQ, dialog_token=dialog_token)
1369     attrs = struct.pack("<BB", P2P_ATTR_CAPABILITY, 0)
1370     msg['payload'] += ie_p2p(attrs)
1371     hapd.mgmt_tx(msg)
1372     frame = hapd.mgmt_rx(timeout=0.1)
1373     if frame is not None:
1374         print frame
1375         raise Exception("Unexpected GO Neg Response")
1376
1377     # missing atributes
1378     dialog_token += 1
1379     msg = p2p_hdr(dst, src, type=P2P_GO_NEG_REQ, dialog_token=dialog_token)
1380     attrs = p2p_attr_capability()
1381     attrs += p2p_attr_go_intent()
1382     attrs += p2p_attr_config_timeout()
1383     #attrs += p2p_attr_listen_channel()
1384     attrs += p2p_attr_ext_listen_timing()
1385     attrs += p2p_attr_intended_interface_addr("02:02:02:02:02:02")
1386     attrs += p2p_attr_channel_list()
1387     attrs += p2p_attr_device_info(src, config_methods=0x0108)
1388     attrs += p2p_attr_operating_channel()
1389     msg['payload'] += ie_p2p(attrs)
1390     hapd.mgmt_tx(msg)
1391     if hapd.mgmt_rx(timeout=2) is None:
1392         raise Exception("No GO Neg Response " + str(dialog_token))
1393     time.sleep(0.1)
1394
1395     dialog_token += 1
1396     msg = p2p_hdr(dst, src, type=P2P_GO_NEG_REQ, dialog_token=dialog_token)
1397     attrs = p2p_attr_capability()
1398     attrs += p2p_attr_go_intent()
1399     attrs += p2p_attr_config_timeout()
1400     attrs += p2p_attr_listen_channel()
1401     attrs += p2p_attr_ext_listen_timing()
1402     attrs += p2p_attr_intended_interface_addr("02:02:02:02:02:02")
1403     attrs += p2p_attr_channel_list()
1404     attrs += p2p_attr_device_info(src, config_methods=0x0108)
1405     #attrs += p2p_attr_operating_channel()
1406     msg['payload'] += ie_p2p(attrs)
1407     hapd.mgmt_tx(msg)
1408     if hapd.mgmt_rx(timeout=2) is None:
1409         raise Exception("No GO Neg Response " + str(dialog_token))
1410     time.sleep(0.1)
1411
1412     dialog_token += 1
1413     msg = p2p_hdr(dst, src, type=P2P_GO_NEG_REQ, dialog_token=dialog_token)
1414     attrs = p2p_attr_capability()
1415     attrs += p2p_attr_go_intent()
1416     attrs += p2p_attr_config_timeout()
1417     attrs += p2p_attr_listen_channel()
1418     attrs += p2p_attr_ext_listen_timing()
1419     attrs += p2p_attr_intended_interface_addr("02:02:02:02:02:02")
1420     #attrs += p2p_attr_channel_list()
1421     attrs += p2p_attr_device_info(src, config_methods=0x0108)
1422     attrs += p2p_attr_operating_channel()
1423     msg['payload'] += ie_p2p(attrs)
1424     hapd.mgmt_tx(msg)
1425     if hapd.mgmt_rx(timeout=2) is None:
1426         raise Exception("No GO Neg Response " + str(dialog_token))
1427     time.sleep(0.1)
1428
1429     dialog_token += 1
1430     msg = p2p_hdr(dst, src, type=P2P_GO_NEG_REQ, dialog_token=dialog_token)
1431     attrs = p2p_attr_capability()
1432     attrs += p2p_attr_go_intent()
1433     attrs += p2p_attr_config_timeout()
1434     attrs += p2p_attr_listen_channel()
1435     attrs += p2p_attr_ext_listen_timing()
1436     #attrs += p2p_attr_intended_interface_addr("02:02:02:02:02:02")
1437     attrs += p2p_attr_channel_list()
1438     attrs += p2p_attr_device_info(src, config_methods=0x0108)
1439     attrs += p2p_attr_operating_channel()
1440     msg['payload'] += ie_p2p(attrs)
1441     hapd.mgmt_tx(msg)
1442     if hapd.mgmt_rx(timeout=2) is None:
1443         raise Exception("No GO Neg Response " + str(dialog_token))
1444     time.sleep(0.1)
1445
1446     dialog_token += 1
1447     msg = p2p_hdr(dst, src, type=P2P_GO_NEG_REQ, dialog_token=dialog_token)
1448     attrs = p2p_attr_capability()
1449     attrs += p2p_attr_go_intent()
1450     attrs += p2p_attr_config_timeout()
1451     attrs += p2p_attr_listen_channel()
1452     attrs += p2p_attr_ext_listen_timing()
1453     attrs += p2p_attr_intended_interface_addr("02:02:02:02:02:02")
1454     attrs += p2p_attr_channel_list()
1455     #attrs += p2p_attr_device_info(src, config_methods=0x0108)
1456     attrs += p2p_attr_operating_channel()
1457     msg['payload'] += ie_p2p(attrs)
1458     hapd.mgmt_tx(msg)
1459     if hapd.mgmt_rx(timeout=2) is None:
1460         raise Exception("No GO Neg Response " + str(dialog_token))
1461     time.sleep(0.1)
1462
1463     # SA != P2P Device address
1464     dialog_token += 1
1465     msg = p2p_hdr(dst, src, type=P2P_GO_NEG_REQ, dialog_token=dialog_token)
1466     attrs = p2p_attr_capability()
1467     attrs += p2p_attr_go_intent()
1468     attrs += p2p_attr_config_timeout()
1469     attrs += p2p_attr_listen_channel()
1470     attrs += p2p_attr_ext_listen_timing()
1471     attrs += p2p_attr_intended_interface_addr("02:02:02:02:02:02")
1472     attrs += p2p_attr_channel_list()
1473     attrs += p2p_attr_device_info("02:02:02:02:02:02", config_methods=0x0108)
1474     attrs += p2p_attr_operating_channel()
1475     msg['payload'] += ie_p2p(attrs)
1476     hapd.mgmt_tx(msg)
1477     if hapd.mgmt_rx(timeout=2) is None:
1478         raise Exception("No GO Neg Response " + str(dialog_token))
1479     time.sleep(0.1)
1480
1481     # unexpected Status attribute
1482     dialog_token += 1
1483     msg = p2p_hdr(dst, src, type=P2P_GO_NEG_REQ, dialog_token=dialog_token)
1484     attrs = p2p_attr_capability()
1485     attrs += p2p_attr_go_intent()
1486     attrs += p2p_attr_config_timeout()
1487     attrs += p2p_attr_listen_channel()
1488     attrs += p2p_attr_ext_listen_timing()
1489     attrs += p2p_attr_intended_interface_addr("02:02:02:02:02:02")
1490     attrs += p2p_attr_channel_list()
1491     attrs += p2p_attr_device_info(src, config_methods=0x0108)
1492     attrs += p2p_attr_operating_channel()
1493     attrs += p2p_attr_status(status=P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE)
1494     msg['payload'] += ie_p2p(attrs)
1495     hapd.mgmt_tx(msg)
1496     if hapd.mgmt_rx(timeout=2) is None:
1497         raise Exception("No GO Neg Response(1) " + str(dialog_token))
1498     time.sleep(0.1)
1499
1500     # valid (with workarounds) GO Neg Req
1501     dialog_token += 1
1502     msg = p2p_hdr(dst, src, type=P2P_GO_NEG_REQ, dialog_token=dialog_token)
1503     #attrs = p2p_attr_capability()
1504     #attrs += p2p_attr_go_intent()
1505     #attrs += p2p_attr_config_timeout()
1506     attrs = p2p_attr_listen_channel()
1507     attrs += p2p_attr_ext_listen_timing()
1508     attrs += p2p_attr_intended_interface_addr("02:02:02:02:02:02")
1509     attrs += p2p_attr_channel_list()
1510     attrs += p2p_attr_device_info(src, config_methods=0x0108)
1511     attrs += p2p_attr_operating_channel()
1512     msg['payload'] += ie_p2p(attrs)
1513     hapd.mgmt_tx(msg)
1514     check_p2p_response(hapd, dialog_token,
1515                        P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE)
1516     ev = dev[0].wait_global_event(["P2P-GO-NEG-REQUEST"], timeout=2)
1517     if ev is None:
1518         raise Exception("Timeout on GO Neg event " + str(dialog_token))
1519
1520     dev[0].request("P2P_CONNECT " + src + " 12345670 display auth")
1521
1522     # ready - missing attributes (with workarounds) GO Neg Req
1523     time.sleep(0.1)
1524     dialog_token += 1
1525     msg = p2p_hdr(dst, src, type=P2P_GO_NEG_REQ, dialog_token=dialog_token)
1526     #attrs = p2p_attr_capability()
1527     #attrs += p2p_attr_go_intent()
1528     #attrs += p2p_attr_config_timeout()
1529     attrs = p2p_attr_listen_channel()
1530     attrs += p2p_attr_ext_listen_timing()
1531     attrs += p2p_attr_intended_interface_addr("02:02:02:02:02:02")
1532     attrs += p2p_attr_channel_list()
1533     attrs += p2p_attr_device_info(src, config_methods=0x0108)
1534     attrs += p2p_attr_operating_channel()
1535     msg['payload'] += ie_p2p(attrs)
1536     hapd.mgmt_tx(msg)
1537     if hapd.mgmt_rx(timeout=2) is None:
1538         raise Exception("No GO Neg Response " + str(dialog_token))
1539
1540     # ready - invalid GO Intent GO Neg Req
1541     time.sleep(0.1)
1542     dialog_token += 1
1543     msg = p2p_hdr(dst, src, type=P2P_GO_NEG_REQ, dialog_token=dialog_token)
1544     #attrs = p2p_attr_capability()
1545     attrs = p2p_attr_go_intent(go_intent=16)
1546     #attrs += p2p_attr_config_timeout()
1547     attrs += p2p_attr_listen_channel()
1548     attrs += p2p_attr_ext_listen_timing()
1549     attrs += p2p_attr_intended_interface_addr("02:02:02:02:02:02")
1550     attrs += p2p_attr_channel_list()
1551     attrs += p2p_attr_device_info(src, config_methods=0x0108)
1552     attrs += p2p_attr_operating_channel()
1553     msg['payload'] += ie_p2p(attrs)
1554     hapd.mgmt_tx(msg)
1555     check_p2p_response(hapd, dialog_token, P2P_SC_FAIL_INVALID_PARAMS)
1556
1557     # ready - invalid Channel List
1558     time.sleep(0.1)
1559     dialog_token += 1
1560     msg = p2p_hdr(dst, src, type=P2P_GO_NEG_REQ, dialog_token=dialog_token)
1561     attrs = p2p_attr_capability()
1562     attrs += p2p_attr_go_intent()
1563     attrs += p2p_attr_config_timeout()
1564     attrs += p2p_attr_listen_channel()
1565     attrs += p2p_attr_ext_listen_timing()
1566     attrs += p2p_attr_intended_interface_addr("02:02:02:02:02:02")
1567     attrs += struct.pack("<BH3BBB11B", P2P_ATTR_CHANNEL_LIST, 16,
1568                          0x58, 0x58, 0x04,
1569                          81, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
1570     attrs += p2p_attr_device_info(src, config_methods=0x0108)
1571     attrs += p2p_attr_operating_channel()
1572     msg['payload'] += ie_p2p(attrs)
1573     hapd.mgmt_tx(msg)
1574     check_p2p_response(hapd, dialog_token, P2P_SC_FAIL_NO_COMMON_CHANNELS)
1575
1576     # ready - invalid GO Neg Req (unsupported Device Password ID)
1577     time.sleep(0.1)
1578     dialog_token += 1
1579     msg = p2p_hdr(dst, src, type=P2P_GO_NEG_REQ, dialog_token=dialog_token)
1580     attrs = p2p_attr_capability()
1581     attrs += p2p_attr_go_intent()
1582     attrs += p2p_attr_config_timeout()
1583     attrs += p2p_attr_listen_channel()
1584     attrs += p2p_attr_ext_listen_timing()
1585     attrs += p2p_attr_intended_interface_addr("02:02:02:02:02:02")
1586     # very long channel list
1587     attrs += struct.pack("<BH3BBB11B30B", P2P_ATTR_CHANNEL_LIST, 46,
1588                          0x58, 0x58, 0x04,
1589                          81, 11, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
1590                          1, 1, 1, 2, 1, 2, 3, 1, 3, 4, 1, 4, 5, 1, 5,
1591                          6, 1, 6, 7, 1, 7, 8, 1, 8, 9, 1, 9, 10, 1, 10)
1592     attrs += p2p_attr_device_info(src, config_methods=0x0108)
1593     attrs += p2p_attr_operating_channel()
1594     msg['payload'] += ie_p2p(attrs)
1595     hapd.mgmt_tx(msg)
1596     check_p2p_response(hapd, dialog_token, P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD)
1597
1598 def mgmt_tx(dev, msg):
1599     for i in range(0, 20):
1600         if "FAIL" in dev.request(msg):
1601             raise Exception("Failed to send Action frame")
1602         ev = dev.wait_event(["MGMT-TX-STATUS"], timeout=10)
1603         if ev is None:
1604             raise Exception("Timeout on MGMT-TX-STATUS")
1605         if "result=SUCCESS" in ev:
1606             break
1607         time.sleep(0.01)
1608     if "result=SUCCESS" not in ev:
1609         raise Exception("Peer did not ack Action frame")
1610
1611 def rx_go_neg_req(dev):
1612     msg = dev.mgmt_rx()
1613     if msg is None:
1614         raise Exception("MGMT-RX timeout")
1615     p2p = parse_p2p_public_action(msg['payload'])
1616     if p2p is None:
1617         raise Exception("Not a P2P Public Action frame " + str(dialog_token))
1618     if p2p['subtype'] != P2P_GO_NEG_REQ:
1619         raise Exception("Unexpected subtype %d" % p2p['subtype'])
1620     p2p['freq'] = msg['freq']
1621     return p2p
1622
1623 def rx_go_neg_conf(dev, status=None, dialog_token=None):
1624     msg = dev.mgmt_rx()
1625     if msg is None:
1626         raise Exception("MGMT-RX timeout")
1627     p2p = parse_p2p_public_action(msg['payload'])
1628     if p2p is None:
1629         raise Exception("Not a P2P Public Action frame " + str(dialog_token))
1630     if p2p['subtype'] != P2P_GO_NEG_CONF:
1631         raise Exception("Unexpected subtype %d" % p2p['subtype'])
1632     if dialog_token is not None and dialog_token != p2p['dialog_token']:
1633         raise Exception("Unexpected dialog token")
1634     if status is not None and p2p['p2p_status'] != status:
1635         raise Exception("Unexpected status %d" % p2p['p2p_status'])
1636
1637 def check_p2p_go_neg_fail_event(dev, status):
1638     ev = dev.wait_global_event(["P2P-GO-NEG-FAILURE"], timeout=5)
1639     if ev is None:
1640         raise Exception("GO Negotiation failure not reported")
1641     if "status=%d" % status not in ev:
1642         raise Exception("Unexpected failure reason: " + ev)
1643
1644 def test_p2p_msg_go_neg_req_reject(dev, apdev):
1645     """P2P protocol tests for user reject incorrectly in GO Neg Req"""
1646     addr0 = dev[0].p2p_dev_addr()
1647     addr1 = dev[1].p2p_dev_addr()
1648     dev[0].p2p_listen()
1649     dev[1].discover_peer(addr0)
1650     dev[1].group_request("P2P_CONNECT " + addr0 + " pbc")
1651     ev = dev[0].wait_global_event(["P2P-GO-NEG-REQUEST"], timeout=10)
1652     if ev is None:
1653         raise Exception("Timeout on GO Neg Req")
1654
1655     peer = dev[0].get_peer(addr1)
1656     dev[0].p2p_stop_find()
1657
1658     msg = p2p_hdr(addr1, addr0, type=P2P_GO_NEG_REQ, dialog_token=123)
1659     attrs = p2p_attr_capability()
1660     attrs += p2p_attr_status(status=P2P_SC_FAIL_REJECTED_BY_USER)
1661     attrs += p2p_attr_go_intent()
1662     attrs += p2p_attr_config_timeout()
1663     attrs += p2p_attr_listen_channel()
1664     attrs += p2p_attr_ext_listen_timing()
1665     attrs += p2p_attr_intended_interface_addr(addr0)
1666     attrs += p2p_attr_channel_list()
1667     attrs += p2p_attr_device_info(addr0, config_methods=0x0108)
1668     attrs += p2p_attr_operating_channel()
1669     msg['payload'] += ie_p2p(attrs)
1670
1671     mgmt_tx(dev[0], "MGMT_TX {} {} freq={} wait_time=10 no_cck=1 action={}".format(addr1, addr1, peer['listen_freq'], binascii.hexlify(msg['payload'])))
1672
1673     ev = dev[1].wait_global_event(["P2P-GO-NEG-FAILURE"], timeout=5)
1674     if ev is None:
1675         raise Exception("GO Negotiation failure not reported")
1676     if "status=%d" % P2P_SC_FAIL_REJECTED_BY_USER not in ev:
1677         raise Exception("Unexpected failure reason: " + ev)
1678
1679 def test_p2p_msg_unexpected_go_neg_resp(dev, apdev):
1680     """P2P protocol tests for unexpected GO Neg Resp"""
1681     addr0 = dev[0].p2p_dev_addr()
1682     addr1 = dev[1].p2p_dev_addr()
1683     dev[1].p2p_listen()
1684     dev[0].discover_peer(addr1)
1685     dev[0].p2p_stop_find()
1686
1687     peer = dev[0].get_peer(addr1)
1688
1689     logger.debug("GO Neg Resp without GO Neg session")
1690     msg = p2p_hdr(addr1, addr0, type=P2P_GO_NEG_RESP, dialog_token=123)
1691     attrs = p2p_attr_status()
1692     attrs += p2p_attr_capability()
1693     attrs += p2p_attr_go_intent()
1694     attrs += p2p_attr_config_timeout()
1695     attrs += p2p_attr_intended_interface_addr(addr0)
1696     attrs += p2p_attr_channel_list()
1697     attrs += p2p_attr_device_info(addr0, config_methods=0x0108)
1698     attrs += p2p_attr_operating_channel()
1699     msg['payload'] += ie_p2p(attrs)
1700     mgmt_tx(dev[0], "MGMT_TX {} {} freq={} wait_time=10 no_cck=1 action={}".format(addr1, addr1, peer['listen_freq'], binascii.hexlify(msg['payload'])))
1701
1702     dev[0].p2p_listen()
1703     dev[1].discover_peer(addr0)
1704
1705     logger.debug("Unexpected GO Neg Resp while waiting for new GO Neg session")
1706     if "FAIL" in dev[1].global_request("P2P_CONNECT " + addr0 + " pbc"):
1707         raise Exception("P2P_CONNECT failed")
1708     ev = dev[0].wait_global_event(["P2P-GO-NEG-REQUEST"], timeout=10)
1709     if ev is None:
1710         raise Exception("Timeout on GO Neg Req")
1711     dev[0].p2p_stop_find()
1712     mgmt_tx(dev[0], "MGMT_TX {} {} freq={} wait_time=10 no_cck=1 action={}".format(addr1, addr1, peer['listen_freq'], binascii.hexlify(msg['payload'])))
1713
1714     logger.debug("Invalid attribute in GO Neg Response")
1715     msg = p2p_hdr(addr1, addr0, type=P2P_GO_NEG_RESP, dialog_token=197)
1716     attrs = struct.pack("<BB", P2P_ATTR_CAPABILITY, 0)
1717     msg['payload'] += ie_p2p(attrs)
1718     mgmt_tx(dev[0], "MGMT_TX {} {} freq={} wait_time=10 no_cck=1 action={}".format(addr1, addr1, peer['listen_freq'], binascii.hexlify(msg['payload'])))
1719     frame = dev[0].mgmt_rx(timeout=0.1)
1720     if frame is not None:
1721         raise Exception("Unexpected GO Neg Confirm")
1722
1723     logger.debug("GO Neg Resp with unexpected dialog token")
1724     dev[1].p2p_stop_find()
1725     if "FAIL" in dev[0].request("SET ext_mgmt_frame_handling 1"):
1726         raise Exception("Failed to enable external management frame handling")
1727     dev[0].p2p_listen()
1728     if "FAIL" in dev[1].global_request("P2P_CONNECT " + addr0 + " pbc"):
1729         raise Exception("P2P_CONNECT failed(2)")
1730     p2p = rx_go_neg_req(dev[0])
1731     dev[0].p2p_stop_find()
1732     dialog_token = p2p['dialog_token']
1733     if dialog_token < 255:
1734         dialog_token += 1
1735     else:
1736         dialog_token = 1
1737     msg = p2p_hdr(addr1, addr0, type=P2P_GO_NEG_RESP, dialog_token=dialog_token)
1738     attrs = p2p_attr_status()
1739     attrs += p2p_attr_capability()
1740     attrs += p2p_attr_go_intent()
1741     attrs += p2p_attr_config_timeout()
1742     attrs += p2p_attr_intended_interface_addr(addr0)
1743     attrs += p2p_attr_channel_list()
1744     attrs += p2p_attr_device_info(addr0, config_methods=0x0108)
1745     attrs += p2p_attr_operating_channel()
1746     msg['payload'] += ie_p2p(attrs)
1747     mgmt_tx(dev[0], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr1, addr1, p2p['freq'], binascii.hexlify(msg['payload'])))
1748
1749     logger.debug("GO Neg Resp without Status")
1750     dev[1].p2p_stop_find()
1751     dev[0].p2p_listen()
1752     if "FAIL" in dev[1].global_request("P2P_CONNECT " + addr0 + " pbc"):
1753         raise Exception("P2P_CONNECT failed(2)")
1754     p2p = rx_go_neg_req(dev[0])
1755     dev[0].p2p_stop_find()
1756     dialog_token = p2p['dialog_token']
1757     msg = p2p_hdr(addr1, addr0, type=P2P_GO_NEG_RESP, dialog_token=dialog_token)
1758     #attrs = p2p_attr_status()
1759     attrs = p2p_attr_capability()
1760     attrs += p2p_attr_go_intent()
1761     attrs += p2p_attr_config_timeout()
1762     attrs += p2p_attr_intended_interface_addr(addr0)
1763     attrs += p2p_attr_channel_list()
1764     attrs += p2p_attr_device_info(addr0, config_methods=0x0108)
1765     attrs += p2p_attr_operating_channel()
1766     msg['payload'] += ie_p2p(attrs)
1767     mgmt_tx(dev[0], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr1, addr1, p2p['freq'], binascii.hexlify(msg['payload'])))
1768     check_p2p_go_neg_fail_event(dev[1], P2P_SC_FAIL_INVALID_PARAMS)
1769     rx_go_neg_conf(dev[0], P2P_SC_FAIL_INVALID_PARAMS, dialog_token)
1770
1771     logger.debug("GO Neg Resp without Intended Address")
1772     dev[1].p2p_stop_find()
1773     dev[0].p2p_listen()
1774     if "FAIL" in dev[1].global_request("P2P_CONNECT " + addr0 + " pbc"):
1775         raise Exception("P2P_CONNECT failed(2)")
1776     p2p = rx_go_neg_req(dev[0])
1777     dev[0].p2p_stop_find()
1778     dialog_token = p2p['dialog_token']
1779     msg = p2p_hdr(addr1, addr0, type=P2P_GO_NEG_RESP, dialog_token=dialog_token)
1780     attrs = p2p_attr_status()
1781     #attrs += p2p_attr_capability()
1782     attrs += p2p_attr_go_intent()
1783     attrs += p2p_attr_config_timeout()
1784     #attrs += p2p_attr_intended_interface_addr(addr0)
1785     attrs += p2p_attr_channel_list()
1786     #attrs += p2p_attr_device_info(addr0, config_methods=0x0108)
1787     attrs += p2p_attr_operating_channel()
1788     msg['payload'] += ie_p2p(attrs)
1789     mgmt_tx(dev[0], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr1, addr1, p2p['freq'], binascii.hexlify(msg['payload'])))
1790     check_p2p_go_neg_fail_event(dev[1], P2P_SC_FAIL_INVALID_PARAMS)
1791     rx_go_neg_conf(dev[0], P2P_SC_FAIL_INVALID_PARAMS, dialog_token)
1792
1793     logger.debug("GO Neg Resp without GO Intent")
1794     dev[1].p2p_stop_find()
1795     dev[0].p2p_listen()
1796     if "FAIL" in dev[1].global_request("P2P_CONNECT " + addr0 + " pbc"):
1797         raise Exception("P2P_CONNECT failed(2)")
1798     p2p = rx_go_neg_req(dev[0])
1799     dev[0].p2p_stop_find()
1800     dialog_token = p2p['dialog_token']
1801     msg = p2p_hdr(addr1, addr0, type=P2P_GO_NEG_RESP, dialog_token=dialog_token)
1802     attrs = p2p_attr_status()
1803     attrs += p2p_attr_capability()
1804     #attrs += p2p_attr_go_intent()
1805     attrs += p2p_attr_config_timeout()
1806     attrs += p2p_attr_intended_interface_addr(addr0)
1807     attrs += p2p_attr_channel_list()
1808     attrs += p2p_attr_device_info(addr0, config_methods=0x0108)
1809     attrs += p2p_attr_operating_channel()
1810     msg['payload'] += ie_p2p(attrs)
1811     mgmt_tx(dev[0], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr1, addr1, p2p['freq'], binascii.hexlify(msg['payload'])))
1812     check_p2p_go_neg_fail_event(dev[1], P2P_SC_FAIL_INVALID_PARAMS)
1813     rx_go_neg_conf(dev[0], P2P_SC_FAIL_INVALID_PARAMS, dialog_token)
1814
1815     logger.debug("GO Neg Resp with invalid GO Intent")
1816     dev[1].p2p_stop_find()
1817     dev[0].p2p_listen()
1818     if "FAIL" in dev[1].global_request("P2P_CONNECT " + addr0 + " pbc"):
1819         raise Exception("P2P_CONNECT failed(2)")
1820     p2p = rx_go_neg_req(dev[0])
1821     dev[0].p2p_stop_find()
1822     dialog_token = p2p['dialog_token']
1823     msg = p2p_hdr(addr1, addr0, type=P2P_GO_NEG_RESP, dialog_token=dialog_token)
1824     attrs = p2p_attr_status()
1825     attrs += p2p_attr_capability()
1826     attrs += p2p_attr_go_intent(go_intent=16)
1827     attrs += p2p_attr_config_timeout()
1828     attrs += p2p_attr_intended_interface_addr(addr0)
1829     attrs += p2p_attr_channel_list()
1830     attrs += p2p_attr_device_info(addr0, config_methods=0x0108)
1831     attrs += p2p_attr_operating_channel()
1832     msg['payload'] += ie_p2p(attrs)
1833     mgmt_tx(dev[0], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr1, addr1, p2p['freq'], binascii.hexlify(msg['payload'])))
1834     check_p2p_go_neg_fail_event(dev[1], P2P_SC_FAIL_INVALID_PARAMS)
1835     rx_go_neg_conf(dev[0], P2P_SC_FAIL_INVALID_PARAMS, dialog_token)
1836
1837     logger.debug("GO Neg Resp with incompatible GO Intent")
1838     dev[1].p2p_stop_find()
1839     dev[0].p2p_listen()
1840     if "FAIL" in dev[1].global_request("P2P_CONNECT " + addr0 + " pbc go_intent=15"):
1841         raise Exception("P2P_CONNECT failed(2)")
1842     p2p = rx_go_neg_req(dev[0])
1843     dev[0].p2p_stop_find()
1844     dialog_token = p2p['dialog_token']
1845     msg = p2p_hdr(addr1, addr0, type=P2P_GO_NEG_RESP, dialog_token=dialog_token)
1846     attrs = p2p_attr_status()
1847     attrs += p2p_attr_capability()
1848     attrs += p2p_attr_go_intent(go_intent=15)
1849     attrs += p2p_attr_config_timeout()
1850     attrs += p2p_attr_intended_interface_addr(addr0)
1851     attrs += p2p_attr_channel_list()
1852     attrs += p2p_attr_device_info(addr0, config_methods=0x0108)
1853     attrs += p2p_attr_operating_channel()
1854     msg['payload'] += ie_p2p(attrs)
1855     mgmt_tx(dev[0], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr1, addr1, p2p['freq'], binascii.hexlify(msg['payload'])))
1856     check_p2p_go_neg_fail_event(dev[1], P2P_SC_FAIL_INCOMPATIBLE_PARAMS)
1857     rx_go_neg_conf(dev[0], P2P_SC_FAIL_INCOMPATIBLE_PARAMS, dialog_token)
1858
1859     logger.debug("GO Neg Resp without P2P Group ID")
1860     dev[1].p2p_stop_find()
1861     dev[0].p2p_listen()
1862     if "FAIL" in dev[1].global_request("P2P_CONNECT " + addr0 + " pbc go_intent=0"):
1863         raise Exception("P2P_CONNECT failed(2)")
1864     p2p = rx_go_neg_req(dev[0])
1865     dev[0].p2p_stop_find()
1866     dialog_token = p2p['dialog_token']
1867     msg = p2p_hdr(addr1, addr0, type=P2P_GO_NEG_RESP, dialog_token=dialog_token)
1868     attrs = p2p_attr_status()
1869     attrs += p2p_attr_capability()
1870     attrs += p2p_attr_go_intent(go_intent=15)
1871     attrs += p2p_attr_config_timeout()
1872     attrs += p2p_attr_intended_interface_addr(addr0)
1873     attrs += p2p_attr_channel_list()
1874     attrs += p2p_attr_device_info(addr0, config_methods=0x0108)
1875     attrs += p2p_attr_operating_channel()
1876     #attrs += p2p_attr_group_id(src, "DIRECT-foo")
1877     msg['payload'] += ie_p2p(attrs)
1878     mgmt_tx(dev[0], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr1, addr1, p2p['freq'], binascii.hexlify(msg['payload'])))
1879     check_p2p_go_neg_fail_event(dev[1], P2P_SC_FAIL_INVALID_PARAMS)
1880     rx_go_neg_conf(dev[0], P2P_SC_FAIL_INVALID_PARAMS, dialog_token)
1881
1882     logger.debug("GO Neg Resp without Operating Channel")
1883     dev[1].p2p_stop_find()
1884     dev[0].p2p_listen()
1885     if "FAIL" in dev[1].global_request("P2P_CONNECT " + addr0 + " pbc go_intent=0"):
1886         raise Exception("P2P_CONNECT failed(2)")
1887     p2p = rx_go_neg_req(dev[0])
1888     dev[0].p2p_stop_find()
1889     dialog_token = p2p['dialog_token']
1890     msg = p2p_hdr(addr1, addr0, type=P2P_GO_NEG_RESP, dialog_token=dialog_token)
1891     attrs = p2p_attr_status()
1892     attrs += p2p_attr_capability()
1893     attrs += p2p_attr_go_intent(go_intent=15)
1894     #attrs += p2p_attr_config_timeout()
1895     attrs += p2p_attr_intended_interface_addr(addr0)
1896     attrs += p2p_attr_channel_list()
1897     attrs += p2p_attr_device_info(addr0, config_methods=0x0108)
1898     #attrs += p2p_attr_operating_channel()
1899     attrs += p2p_attr_group_id(addr0, "DIRECT-foo")
1900     msg['payload'] += ie_p2p(attrs)
1901     mgmt_tx(dev[0], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr1, addr1, p2p['freq'], binascii.hexlify(msg['payload'])))
1902     check_p2p_go_neg_fail_event(dev[1], P2P_SC_FAIL_INVALID_PARAMS)
1903     rx_go_neg_conf(dev[0], P2P_SC_FAIL_INVALID_PARAMS, dialog_token)
1904
1905     logger.debug("GO Neg Resp without Channel List")
1906     dev[1].p2p_stop_find()
1907     dev[0].p2p_listen()
1908     if "FAIL" in dev[1].global_request("P2P_CONNECT " + addr0 + " pbc go_intent=0"):
1909         raise Exception("P2P_CONNECT failed(2)")
1910     p2p = rx_go_neg_req(dev[0])
1911     dev[0].p2p_stop_find()
1912     dialog_token = p2p['dialog_token']
1913     msg = p2p_hdr(addr1, addr0, type=P2P_GO_NEG_RESP, dialog_token=dialog_token)
1914     attrs = p2p_attr_status()
1915     attrs += p2p_attr_capability()
1916     attrs += p2p_attr_go_intent(go_intent=15)
1917     attrs += p2p_attr_config_timeout()
1918     attrs += p2p_attr_intended_interface_addr(addr0)
1919     #attrs += p2p_attr_channel_list()
1920     attrs += p2p_attr_device_info(addr0, config_methods=0x0108)
1921     attrs += p2p_attr_operating_channel()
1922     attrs += p2p_attr_group_id(addr0, "DIRECT-foo")
1923     msg['payload'] += ie_p2p(attrs)
1924     mgmt_tx(dev[0], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr1, addr1, p2p['freq'], binascii.hexlify(msg['payload'])))
1925     check_p2p_go_neg_fail_event(dev[1], P2P_SC_FAIL_INVALID_PARAMS)
1926     rx_go_neg_conf(dev[0], P2P_SC_FAIL_INVALID_PARAMS, dialog_token)
1927
1928     logger.debug("GO Neg Resp without common channels")
1929     dev[1].p2p_stop_find()
1930     dev[0].p2p_listen()
1931     if "FAIL" in dev[1].global_request("P2P_CONNECT " + addr0 + " pbc go_intent=0"):
1932         raise Exception("P2P_CONNECT failed(2)")
1933     p2p = rx_go_neg_req(dev[0])
1934     dev[0].p2p_stop_find()
1935     dialog_token = p2p['dialog_token']
1936     msg = p2p_hdr(addr1, addr0, type=P2P_GO_NEG_RESP, dialog_token=dialog_token)
1937     attrs = p2p_attr_status()
1938     attrs += p2p_attr_capability()
1939     attrs += p2p_attr_go_intent(go_intent=15)
1940     attrs += p2p_attr_config_timeout()
1941     attrs += p2p_attr_intended_interface_addr(addr0)
1942     attrs += struct.pack("<BH3BBB", P2P_ATTR_CHANNEL_LIST, 5,
1943                          0x58, 0x58, 0x04,
1944                          81, 0)
1945     attrs += p2p_attr_device_info(addr0, config_methods=0x0108)
1946     attrs += p2p_attr_operating_channel()
1947     attrs += p2p_attr_group_id(addr0, "DIRECT-foo")
1948     msg['payload'] += ie_p2p(attrs)
1949     mgmt_tx(dev[0], "MGMT_TX {} {} freq={} wait_time=200 no_cck=1 action={}".format(addr1, addr1, p2p['freq'], binascii.hexlify(msg['payload'])))
1950     check_p2p_go_neg_fail_event(dev[1], P2P_SC_FAIL_NO_COMMON_CHANNELS)
1951     rx_go_neg_conf(dev[0], P2P_SC_FAIL_NO_COMMON_CHANNELS, dialog_token)