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