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