contrib/wpa/src/p2p/p2p_pd.c

   1 /*
   2  * Wi-Fi Direct - P2P provision discovery
   3  * Copyright (c) 2009-2010, Atheros Communications
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "includes.h"
  10
  11 #include "common.h"
  12 #include "common/ieee802_11_defs.h"
  13 #include "common/wpa_ctrl.h"
  14 #include "wps/wps_defs.h"
  15 #include "p2p_i.h"
  16 #include "p2p.h"
  17
  18
  19 /*
  20  * Number of retries to attempt for provision discovery requests
  21  * in case the peer is not listening.
  22  */
  23 #define MAX_PROV_DISC_REQ_RETRIES 120
  24
  25
  26 static void p2p_build_wps_ie_config_methods(struct wpabuf *buf,
  27                                             u16 config_methods)
  28 {
  29         u8 *len;
  30         wpabuf_put_u8(buf, WLAN_EID_VENDOR_SPECIFIC);
  31         len = wpabuf_put(buf, 1);
  32         wpabuf_put_be32(buf, WPS_DEV_OUI_WFA);
  33
  34         /* Config Methods */
  35         wpabuf_put_be16(buf, ATTR_CONFIG_METHODS);
  36         wpabuf_put_be16(buf, 2);
  37         wpabuf_put_be16(buf, config_methods);
  38
  39         p2p_buf_update_ie_hdr(buf, len);
  40 }
  41
  42
  43 static void p2ps_add_new_group_info(struct p2p_data *p2p,
  44                                     struct p2p_device *dev,
  45                                     struct wpabuf *buf)
  46 {
  47         int found;
  48         u8 intended_addr[ETH_ALEN];
  49         u8 ssid[SSID_MAX_LEN];
  50         size_t ssid_len;
  51         int group_iface;
  52         unsigned int force_freq;
  53
  54         if (!p2p->cfg->get_go_info)
  55                 return;
  56
  57         found = p2p->cfg->get_go_info(
  58                 p2p->cfg->cb_ctx, intended_addr, ssid,
  59                 &ssid_len, &group_iface, &force_freq);
  60         if (found) {
  61                 if (force_freq > 0) {
  62                         p2p->p2ps_prov->force_freq = force_freq;
  63                         p2p->p2ps_prov->pref_freq = 0;
  64
  65                         if (dev)
  66                                 p2p_prepare_channel(p2p, dev, force_freq, 0, 0);
  67                 }
  68                 p2p_buf_add_group_id(buf, p2p->cfg->dev_addr,
  69                                      ssid, ssid_len);
  70
  71                 if (group_iface)
  72                         p2p_buf_add_intended_addr(buf, p2p->intended_addr);
  73                 else
  74                         p2p_buf_add_intended_addr(buf, intended_addr);
  75         } else {
  76                 if (!p2p->ssid_set) {
  77                         p2p_build_ssid(p2p, p2p->ssid, &p2p->ssid_len);
  78                         p2p->ssid_set = 1;
  79                 }
  80
  81                 /* Add pre-composed P2P Group ID */
  82                 p2p_buf_add_group_id(buf, p2p->cfg->dev_addr,
  83                                      p2p->ssid, p2p->ssid_len);
  84
  85                 if (group_iface)
  86                         p2p_buf_add_intended_addr(
  87                                 buf, p2p->intended_addr);
  88                 else
  89                         p2p_buf_add_intended_addr(
  90                                 buf, p2p->cfg->dev_addr);
  91         }
  92 }
  93
  94
  95 static void p2ps_add_pd_req_attrs(struct p2p_data *p2p, struct p2p_device *dev,
  96                                   struct wpabuf *buf, u16 config_methods)
  97 {
  98         struct p2ps_provision *prov = p2p->p2ps_prov;
  99         struct p2ps_feature_capab fcap = { prov->cpt_mask, 0 };
 100         int shared_group = 0;
 101         u8 ssid[SSID_MAX_LEN];
 102         size_t ssid_len;
 103         u8 go_dev_addr[ETH_ALEN];
 104         u8 intended_addr[ETH_ALEN];
 105         int follow_on_req_fail = prov->status >= 0 &&
 106                 prov->status != P2P_SC_SUCCESS_DEFERRED;
 107
 108         /* If we might be explicite group owner, add GO details */
 109         if (!follow_on_req_fail &&
 110             (prov->conncap & (P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_NEW)))
 111                 p2ps_add_new_group_info(p2p, dev, buf);
 112
 113         if (prov->status >= 0)
 114                 p2p_buf_add_status(buf, (u8) prov->status);
 115         else
 116                 prov->method = config_methods;
 117
 118         if (!follow_on_req_fail) {
 119                 if (p2p->cfg->get_persistent_group) {
 120                         shared_group = p2p->cfg->get_persistent_group(
 121                                 p2p->cfg->cb_ctx, dev->info.p2p_device_addr,
 122                                 NULL, 0, go_dev_addr, ssid, &ssid_len,
 123                                 intended_addr);
 124                 }
 125
 126                 if (shared_group ||
 127                     (prov->conncap & (P2PS_SETUP_CLIENT | P2PS_SETUP_NEW)))
 128                         p2p_buf_add_channel_list(buf, p2p->cfg->country,
 129                                                  &p2p->channels);
 130
 131                 if ((shared_group && !is_zero_ether_addr(intended_addr)) ||
 132                     (prov->conncap & (P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_NEW)))
 133                         p2p_buf_add_operating_channel(buf, p2p->cfg->country,
 134                                                       p2p->op_reg_class,
 135                                                       p2p->op_channel);
 136         }
 137
 138         if (prov->status < 0 && prov->info[0])
 139                 p2p_buf_add_session_info(buf, prov->info);
 140
 141         if (!follow_on_req_fail)
 142                 p2p_buf_add_connection_capability(buf, prov->conncap);
 143
 144         p2p_buf_add_advertisement_id(buf, prov->adv_id, prov->adv_mac);
 145
 146         if (!follow_on_req_fail) {
 147                 if (shared_group || prov->conncap == P2PS_SETUP_NEW ||
 148                     prov->conncap ==
 149                     (P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_NEW) ||
 150                     prov->conncap ==
 151                     (P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_CLIENT)) {
 152                         /* Add Config Timeout */
 153                         p2p_buf_add_config_timeout(buf, p2p->go_timeout,
 154                                                    p2p->client_timeout);
 155                 }
 156
 157                 p2p_buf_add_listen_channel(buf, p2p->cfg->country,
 158                                            p2p->cfg->reg_class,
 159                                            p2p->cfg->channel);
 160         }
 161
 162         p2p_buf_add_session_id(buf, prov->session_id, prov->session_mac);
 163
 164         p2p_buf_add_feature_capability(buf, sizeof(fcap), (const u8 *) &fcap);
 165
 166         if (shared_group) {
 167                 p2p_buf_add_persistent_group_info(buf, go_dev_addr,
 168                                                   ssid, ssid_len);
 169                 /* Add intended interface address if it is not added yet */
 170                 if ((prov->conncap == P2PS_SETUP_NONE ||
 171                      prov->conncap == P2PS_SETUP_CLIENT) &&
 172                     !is_zero_ether_addr(intended_addr))
 173                         p2p_buf_add_intended_addr(buf, intended_addr);
 174         }
 175 }
 176
 177
 178 static struct wpabuf * p2p_build_prov_disc_req(struct p2p_data *p2p,
 179                                                struct p2p_device *dev,
 180                                                int join)
 181 {
 182         struct wpabuf *buf;
 183         u8 *len;
 184         size_t extra = 0;
 185         u8 dialog_token = dev->dialog_token;
 186         u16 config_methods = dev->req_config_methods;
 187         struct p2p_device *go = join ? dev : NULL;
 188         u8 group_capab;
 189
 190 #ifdef CONFIG_WIFI_DISPLAY
 191         if (p2p->wfd_ie_prov_disc_req)
 192                 extra = wpabuf_len(p2p->wfd_ie_prov_disc_req);
 193 #endif /* CONFIG_WIFI_DISPLAY */
 194
 195         if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_PD_REQ])
 196                 extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_P2P_PD_REQ]);
 197
 198         if (p2p->p2ps_prov)
 199                 extra += os_strlen(p2p->p2ps_prov->info) + 1 +
 200                         sizeof(struct p2ps_provision);
 201
 202         buf = wpabuf_alloc(1000 + extra);
 203         if (buf == NULL)
 204                 return NULL;
 205
 206         p2p_buf_add_public_action_hdr(buf, P2P_PROV_DISC_REQ, dialog_token);
 207
 208         len = p2p_buf_add_ie_hdr(buf);
 209
 210         group_capab = 0;
 211         if (p2p->p2ps_prov) {
 212                 group_capab |= P2P_GROUP_CAPAB_PERSISTENT_GROUP;
 213                 group_capab |= P2P_GROUP_CAPAB_PERSISTENT_RECONN;
 214                 if (p2p->cross_connect)
 215                         group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
 216                 if (p2p->cfg->p2p_intra_bss)
 217                         group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST;
 218         }
 219         p2p_buf_add_capability(buf, p2p->dev_capab &
 220                                ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY,
 221                                group_capab);
 222         p2p_buf_add_device_info(buf, p2p, NULL);
 223         if (p2p->p2ps_prov) {
 224                 p2ps_add_pd_req_attrs(p2p, dev, buf, config_methods);
 225         } else if (go) {
 226                 p2p_buf_add_group_id(buf, go->info.p2p_device_addr,
 227                                      go->oper_ssid, go->oper_ssid_len);
 228         }
 229         p2p_buf_update_ie_hdr(buf, len);
 230
 231         /* WPS IE with Config Methods attribute */
 232         p2p_build_wps_ie_config_methods(buf, config_methods);
 233
 234 #ifdef CONFIG_WIFI_DISPLAY
 235         if (p2p->wfd_ie_prov_disc_req)
 236                 wpabuf_put_buf(buf, p2p->wfd_ie_prov_disc_req);
 237 #endif /* CONFIG_WIFI_DISPLAY */
 238
 239         if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_PD_REQ])
 240                 wpabuf_put_buf(buf, p2p->vendor_elem[VENDOR_ELEM_P2P_PD_REQ]);
 241
 242         return buf;
 243 }
 244
 245
 246 static struct wpabuf * p2p_build_prov_disc_resp(struct p2p_data *p2p,
 247                                                 struct p2p_device *dev,
 248                                                 u8 dialog_token,
 249                                                 enum p2p_status_code status,
 250                                                 u16 config_methods,
 251                                                 u32 adv_id,
 252                                                 const u8 *group_id,
 253                                                 size_t group_id_len,
 254                                                 const u8 *persist_ssid,
 255                                                 size_t persist_ssid_len,
 256                                                 const u8 *fcap,
 257                                                 u16 fcap_len)
 258 {
 259         struct wpabuf *buf;
 260         size_t extra = 0;
 261         int persist = 0;
 262
 263 #ifdef CONFIG_WIFI_DISPLAY
 264         struct wpabuf *wfd_ie = p2p->wfd_ie_prov_disc_resp;
 265         if (wfd_ie && group_id) {
 266                 size_t i;
 267                 for (i = 0; i < p2p->num_groups; i++) {
 268                         struct p2p_group *g = p2p->groups[i];
 269                         struct wpabuf *ie;
 270                         if (!p2p_group_is_group_id_match(g, group_id,
 271                                                          group_id_len))
 272                                 continue;
 273                         ie = p2p_group_get_wfd_ie(g);
 274                         if (ie) {
 275                                 wfd_ie = ie;
 276                                 break;
 277                         }
 278                 }
 279         }
 280         if (wfd_ie)
 281                 extra = wpabuf_len(wfd_ie);
 282 #endif /* CONFIG_WIFI_DISPLAY */
 283
 284         if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_PD_RESP])
 285                 extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_P2P_PD_RESP]);
 286
 287         buf = wpabuf_alloc(1000 + extra);
 288         if (buf == NULL)
 289                 return NULL;
 290
 291         p2p_buf_add_public_action_hdr(buf, P2P_PROV_DISC_RESP, dialog_token);
 292
 293         /* Add P2P IE for P2PS */
 294         if (p2p->p2ps_prov && p2p->p2ps_prov->adv_id == adv_id) {
 295                 u8 *len = p2p_buf_add_ie_hdr(buf);
 296                 struct p2ps_provision *prov = p2p->p2ps_prov;
 297                 u8 group_capab;
 298                 u8 conncap = 0;
 299
 300                 if (status == P2P_SC_SUCCESS ||
 301                     status == P2P_SC_SUCCESS_DEFERRED)
 302                         conncap = prov->conncap;
 303
 304                 if (!status && prov->status != -1)
 305                         status = prov->status;
 306
 307                 p2p_buf_add_status(buf, status);
 308                 group_capab = P2P_GROUP_CAPAB_PERSISTENT_GROUP |
 309                         P2P_GROUP_CAPAB_PERSISTENT_RECONN;
 310                 if (p2p->cross_connect)
 311                         group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
 312                 if (p2p->cfg->p2p_intra_bss)
 313                         group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST;
 314                 p2p_buf_add_capability(buf, p2p->dev_capab &
 315                                        ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY,
 316                                        group_capab);
 317                 p2p_buf_add_device_info(buf, p2p, NULL);
 318
 319                 if (persist_ssid && p2p->cfg->get_persistent_group && dev &&
 320                     (status == P2P_SC_SUCCESS ||
 321                      status == P2P_SC_SUCCESS_DEFERRED)) {
 322                         u8 ssid[SSID_MAX_LEN];
 323                         size_t ssid_len;
 324                         u8 go_dev_addr[ETH_ALEN];
 325                         u8 intended_addr[ETH_ALEN];
 326
 327                         persist = p2p->cfg->get_persistent_group(
 328                                 p2p->cfg->cb_ctx,
 329                                 dev->info.p2p_device_addr,
 330                                 persist_ssid, persist_ssid_len, go_dev_addr,
 331                                 ssid, &ssid_len, intended_addr);
 332                         if (persist) {
 333                                 p2p_buf_add_persistent_group_info(
 334                                         buf, go_dev_addr, ssid, ssid_len);
 335                                 if (!is_zero_ether_addr(intended_addr))
 336                                         p2p_buf_add_intended_addr(
 337                                                 buf, intended_addr);
 338                         }
 339                 }
 340
 341                 if (!persist && (conncap & P2PS_SETUP_GROUP_OWNER))
 342                         p2ps_add_new_group_info(p2p, dev, buf);
 343
 344                 /* Add Operating Channel if conncap indicates GO */
 345                 if (persist || (conncap & P2PS_SETUP_GROUP_OWNER)) {
 346                         if (p2p->op_reg_class && p2p->op_channel)
 347                                 p2p_buf_add_operating_channel(
 348                                         buf, p2p->cfg->country,
 349                                         p2p->op_reg_class,
 350                                         p2p->op_channel);
 351                         else
 352                                 p2p_buf_add_operating_channel(
 353                                         buf, p2p->cfg->country,
 354                                         p2p->cfg->op_reg_class,
 355                                         p2p->cfg->op_channel);
 356                 }
 357
 358                 if (persist ||
 359                     (conncap & (P2PS_SETUP_CLIENT | P2PS_SETUP_GROUP_OWNER)))
 360                         p2p_buf_add_channel_list(buf, p2p->cfg->country,
 361                                                  &p2p->channels);
 362
 363                 if (!persist && conncap)
 364                         p2p_buf_add_connection_capability(buf, conncap);
 365
 366                 p2p_buf_add_advertisement_id(buf, adv_id, prov->adv_mac);
 367
 368                 if (persist ||
 369                     (conncap & (P2PS_SETUP_CLIENT | P2PS_SETUP_GROUP_OWNER)))
 370                         p2p_buf_add_config_timeout(buf, p2p->go_timeout,
 371                                                    p2p->client_timeout);
 372
 373                 p2p_buf_add_session_id(buf, prov->session_id,
 374                                        prov->session_mac);
 375
 376                 p2p_buf_add_feature_capability(buf, fcap_len, fcap);
 377                 p2p_buf_update_ie_hdr(buf, len);
 378         } else if (status != P2P_SC_SUCCESS || adv_id) {
 379                 u8 *len = p2p_buf_add_ie_hdr(buf);
 380
 381                 p2p_buf_add_status(buf, status);
 382
 383                 if (p2p->p2ps_prov)
 384                         p2p_buf_add_advertisement_id(buf, adv_id,
 385                                                      p2p->p2ps_prov->adv_mac);
 386
 387                 p2p_buf_update_ie_hdr(buf, len);
 388         }
 389
 390         /* WPS IE with Config Methods attribute */
 391         p2p_build_wps_ie_config_methods(buf, config_methods);
 392
 393 #ifdef CONFIG_WIFI_DISPLAY
 394         if (wfd_ie)
 395                 wpabuf_put_buf(buf, wfd_ie);
 396 #endif /* CONFIG_WIFI_DISPLAY */
 397
 398         if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_PD_RESP])
 399                 wpabuf_put_buf(buf, p2p->vendor_elem[VENDOR_ELEM_P2P_PD_RESP]);
 400
 401         return buf;
 402 }
 403
 404
 405 static int p2ps_setup_p2ps_prov(struct p2p_data *p2p, u32 adv_id,
 406                                 u32 session_id, u16 method,
 407                                 const u8 *session_mac, const u8 *adv_mac)
 408 {
 409         struct p2ps_provision *tmp;
 410
 411         if (!p2p->p2ps_prov) {
 412                 p2p->p2ps_prov = os_zalloc(sizeof(struct p2ps_provision) + 1);
 413                 if (!p2p->p2ps_prov)
 414                         return -1;
 415         } else {
 416                 os_memset(p2p->p2ps_prov, 0, sizeof(struct p2ps_provision) + 1);
 417         }
 418
 419         tmp = p2p->p2ps_prov;
 420         tmp->adv_id = adv_id;
 421         tmp->session_id = session_id;
 422         tmp->method = method;
 423         os_memcpy(tmp->session_mac, session_mac, ETH_ALEN);
 424         os_memcpy(tmp->adv_mac, adv_mac, ETH_ALEN);
 425         tmp->info[0] = '\0';
 426
 427         return 0;
 428 }
 429
 430
 431 static u8 p2ps_own_preferred_cpt(const u8 *cpt_priority, u8 req_cpt_mask)
 432 {
 433         int i;
 434
 435         for (i = 0; cpt_priority[i]; i++)
 436                 if (req_cpt_mask & cpt_priority[i])
 437                         return cpt_priority[i];
 438
 439         return 0;
 440 }
 441
 442
 443 /* Check if the message contains a valid P2PS PD Request */
 444 static int p2ps_validate_pd_req(struct p2p_data *p2p, struct p2p_message *msg,
 445                                 const u8 *addr)
 446 {
 447         u8 group_id = 0;
 448         u8 intended_addr = 0;
 449         u8 operating_channel = 0;
 450         u8 channel_list = 0;
 451         u8 config_timeout = 0;
 452         u8 listen_channel = 0;
 453
 454 #define P2PS_PD_REQ_CHECK(_val, _attr) \
 455 do { \
 456         if ((_val) && !msg->_attr) { \
 457                 p2p_dbg(p2p, "Not P2PS PD Request. Missing %s", #_attr); \
 458                 return -1; \
 459         } \
 460 } while (0)
 461
 462         P2PS_PD_REQ_CHECK(1, adv_id);
 463         P2PS_PD_REQ_CHECK(1, session_id);
 464         P2PS_PD_REQ_CHECK(1, session_mac);
 465         P2PS_PD_REQ_CHECK(1, adv_mac);
 466         P2PS_PD_REQ_CHECK(1, capability);
 467         P2PS_PD_REQ_CHECK(1, p2p_device_info);
 468         P2PS_PD_REQ_CHECK(1, feature_cap);
 469
 470         /*
 471          * We don't need to check Connection Capability, Persistent Group,
 472          * and related attributes for follow-on PD Request with a status
 473          * other than SUCCESS_DEFERRED.
 474          */
 475         if (msg->status && *msg->status != P2P_SC_SUCCESS_DEFERRED)
 476                 return 0;
 477
 478         P2PS_PD_REQ_CHECK(1, conn_cap);
 479
 480         /*
 481          * Note 1: A feature capability attribute structure can be changed
 482          * in the future. The assumption is that such modifications are
 483          * backward compatible, therefore we allow processing of msg.feature_cap
 484          * exceeding the size of the p2ps_feature_capab structure.
 485          * Note 2: Verification of msg.feature_cap_len below has to be changed
 486          * to allow 2 byte feature capability processing if
 487          * struct p2ps_feature_capab is extended to include additional fields
 488          * and it affects the structure size.
 489          */
 490         if (msg->feature_cap_len < sizeof(struct p2ps_feature_capab)) {
 491                 p2p_dbg(p2p, "P2PS: Invalid feature capability len");
 492                 return -1;
 493         }
 494
 495         switch (*msg->conn_cap) {
 496         case P2PS_SETUP_NEW:
 497                 group_id = 1;
 498                 intended_addr = 1;
 499                 operating_channel = 1;
 500                 channel_list = 1;
 501                 config_timeout = 1;
 502                 listen_channel = 1;
 503                 break;
 504         case P2PS_SETUP_CLIENT:
 505                 channel_list = 1;
 506                 listen_channel = 1;
 507                 break;
 508         case P2PS_SETUP_GROUP_OWNER:
 509                 group_id = 1;
 510                 intended_addr = 1;
 511                 operating_channel = 1;
 512                 break;
 513         case P2PS_SETUP_NEW | P2PS_SETUP_GROUP_OWNER:
 514                 group_id = 1;
 515                 operating_channel = 1;
 516                 intended_addr = 1;
 517                 channel_list = 1;
 518                 config_timeout = 1;
 519                 break;
 520         case P2PS_SETUP_CLIENT | P2PS_SETUP_GROUP_OWNER:
 521                 group_id = 1;
 522                 intended_addr = 1;
 523                 operating_channel = 1;
 524                 channel_list = 1;
 525                 config_timeout = 1;
 526                 break;
 527         default:
 528                 p2p_dbg(p2p, "Invalid P2PS PD connection capability");
 529                 return -1;
 530         }
 531
 532         if (msg->persistent_dev) {
 533                 channel_list = 1;
 534                 config_timeout = 1;
 535                 if (os_memcmp(msg->persistent_dev, addr, ETH_ALEN) == 0) {
 536                         intended_addr = 1;
 537                         operating_channel = 1;
 538                 }
 539         }
 540
 541         P2PS_PD_REQ_CHECK(group_id, group_id);
 542         P2PS_PD_REQ_CHECK(intended_addr, intended_addr);
 543         P2PS_PD_REQ_CHECK(operating_channel, operating_channel);
 544         P2PS_PD_REQ_CHECK(channel_list, channel_list);
 545         P2PS_PD_REQ_CHECK(config_timeout, config_timeout);
 546         P2PS_PD_REQ_CHECK(listen_channel, listen_channel);
 547
 548 #undef P2PS_PD_REQ_CHECK
 549
 550         return 0;
 551 }
 552
 553
 554 void p2p_process_prov_disc_req(struct p2p_data *p2p, const u8 *sa,
 555                                const u8 *data, size_t len, int rx_freq)
 556 {
 557         struct p2p_message msg;
 558         struct p2p_device *dev;
 559         int freq;
 560         enum p2p_status_code reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
 561         struct wpabuf *resp;
 562         u32 adv_id = 0;
 563         struct p2ps_advertisement *p2ps_adv = NULL;
 564         u8 conncap = P2PS_SETUP_NEW;
 565         u8 auto_accept = 0;
 566         u32 session_id = 0;
 567         u8 session_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
 568         u8 adv_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
 569         const u8 *group_mac;
 570         int passwd_id = DEV_PW_DEFAULT;
 571         u16 config_methods;
 572         u16 allowed_config_methods = WPS_CONFIG_DISPLAY | WPS_CONFIG_KEYPAD;
 573         struct p2ps_feature_capab resp_fcap = { 0, 0 };
 574         struct p2ps_feature_capab *req_fcap = NULL;
 575         u8 remote_conncap;
 576         u16 method;
 577
 578         if (p2p_parse(data, len, &msg))
 579                 return;
 580
 581         p2p_dbg(p2p, "Received Provision Discovery Request from " MACSTR
 582                 " with config methods 0x%x (freq=%d)",
 583                 MAC2STR(sa), msg.wps_config_methods, rx_freq);
 584         group_mac = msg.intended_addr;
 585
 586         dev = p2p_get_device(p2p, sa);
 587         if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
 588                 p2p_dbg(p2p, "Provision Discovery Request from unknown peer "
 589                         MACSTR, MAC2STR(sa));
 590
 591                 if (p2p_add_device(p2p, sa, rx_freq, NULL, 0, data + 1, len - 1,
 592                                    0)) {
 593                         p2p_dbg(p2p, "Provision Discovery Request add device failed "
 594                                 MACSTR, MAC2STR(sa));
 595                         goto out;
 596                 }
 597
 598                 if (!dev) {
 599                         dev = p2p_get_device(p2p, sa);
 600                         if (!dev) {
 601                                 p2p_dbg(p2p,
 602                                         "Provision Discovery device not found "
 603                                         MACSTR, MAC2STR(sa));
 604                                 goto out;
 605                         }
 606                 }
 607         } else if (msg.wfd_subelems) {
 608                 wpabuf_free(dev->info.wfd_subelems);
 609                 dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems);
 610         }
 611
 612         if (!msg.adv_id) {
 613                 allowed_config_methods |= WPS_CONFIG_PUSHBUTTON;
 614                 if (!(msg.wps_config_methods & allowed_config_methods)) {
 615                         p2p_dbg(p2p,
 616                                 "Unsupported Config Methods in Provision Discovery Request");
 617                         goto out;
 618                 }
 619
 620                 /* Legacy (non-P2PS) - Unknown groups allowed for P2PS */
 621                 if (msg.group_id) {
 622                         size_t i;
 623
 624                         for (i = 0; i < p2p->num_groups; i++) {
 625                                 if (p2p_group_is_group_id_match(
 626                                             p2p->groups[i],
 627                                             msg.group_id, msg.group_id_len))
 628                                         break;
 629                         }
 630                         if (i == p2p->num_groups) {
 631                                 p2p_dbg(p2p,
 632                                         "PD request for unknown P2P Group ID - reject");
 633                                 goto out;
 634                         }
 635                 }
 636         } else {
 637                 allowed_config_methods |= WPS_CONFIG_P2PS;
 638
 639                 /*
 640                  * Set adv_id here, so in case of an error, a P2PS PD Response
 641                  * will be sent.
 642                  */
 643                 adv_id = WPA_GET_LE32(msg.adv_id);
 644                 if (p2ps_validate_pd_req(p2p, &msg, sa) < 0) {
 645                         reject = P2P_SC_FAIL_INVALID_PARAMS;
 646                         goto out;
 647                 }
 648
 649                 req_fcap = (struct p2ps_feature_capab *) msg.feature_cap;
 650
 651                 os_memcpy(session_mac, msg.session_mac, ETH_ALEN);
 652                 os_memcpy(adv_mac, msg.adv_mac, ETH_ALEN);
 653
 654                 session_id = WPA_GET_LE32(msg.session_id);
 655
 656                 if (msg.conn_cap)
 657                         conncap = *msg.conn_cap;
 658
 659                 /*
 660                  * We need to verify a P2PS config methog in an initial PD
 661                  * request or in a follow-on PD request with the status
 662                  * SUCCESS_DEFERRED.
 663                  */
 664                 if ((!msg.status || *msg.status == P2P_SC_SUCCESS_DEFERRED) &&
 665                     !(msg.wps_config_methods & allowed_config_methods)) {
 666                         p2p_dbg(p2p,
 667                                 "Unsupported Config Methods in Provision Discovery Request");
 668                         goto out;
 669                 }
 670
 671                 /*
 672                  * TODO: since we don't support multiple PD, reject PD request
 673                  * if we are in the middle of P2PS PD with some other peer
 674                  */
 675         }
 676
 677         dev->flags &= ~(P2P_DEV_PD_PEER_DISPLAY |
 678                         P2P_DEV_PD_PEER_KEYPAD |
 679                         P2P_DEV_PD_PEER_P2PS);
 680
 681         if (msg.wps_config_methods & WPS_CONFIG_DISPLAY) {
 682                 p2p_dbg(p2p, "Peer " MACSTR
 683                         " requested us to show a PIN on display", MAC2STR(sa));
 684                 dev->flags |= P2P_DEV_PD_PEER_KEYPAD;
 685                 passwd_id = DEV_PW_USER_SPECIFIED;
 686         } else if (msg.wps_config_methods & WPS_CONFIG_KEYPAD) {
 687                 p2p_dbg(p2p, "Peer " MACSTR
 688                         " requested us to write its PIN using keypad",
 689                         MAC2STR(sa));
 690                 dev->flags |= P2P_DEV_PD_PEER_DISPLAY;
 691                 passwd_id = DEV_PW_REGISTRAR_SPECIFIED;
 692         } else if (msg.wps_config_methods & WPS_CONFIG_P2PS) {
 693                 p2p_dbg(p2p, "Peer " MACSTR " requesting P2PS PIN",
 694                         MAC2STR(sa));
 695                 dev->flags |= P2P_DEV_PD_PEER_P2PS;
 696                 passwd_id = DEV_PW_P2PS_DEFAULT;
 697         }
 698
 699         /* Remove stale persistent groups */
 700         if (p2p->cfg->remove_stale_groups) {
 701                 p2p->cfg->remove_stale_groups(
 702                         p2p->cfg->cb_ctx, dev->info.p2p_device_addr,
 703                         msg.persistent_dev,
 704                         msg.persistent_ssid, msg.persistent_ssid_len);
 705         }
 706
 707         reject = P2P_SC_SUCCESS;
 708
 709         /*
 710          * End of a legacy P2P PD Request processing, from this point continue
 711          * with P2PS one.
 712          */
 713         if (!msg.adv_id)
 714                 goto out;
 715
 716         remote_conncap = conncap;
 717
 718         if (!msg.status) {
 719                 unsigned int forced_freq, pref_freq;
 720
 721                 if (os_memcmp(p2p->cfg->dev_addr, msg.adv_mac, ETH_ALEN)) {
 722                         p2p_dbg(p2p,
 723                                 "P2PS PD adv mac does not match the local one");
 724                         reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
 725                         goto out;
 726                 }
 727
 728                 p2ps_adv = p2p_service_p2ps_id(p2p, adv_id);
 729                 if (!p2ps_adv) {
 730                         p2p_dbg(p2p, "P2PS PD invalid adv_id=0x%X", adv_id);
 731                         reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
 732                         goto out;
 733                 }
 734                 p2p_dbg(p2p, "adv_id: 0x%X, p2ps_adv: %p", adv_id, p2ps_adv);
 735
 736                 auto_accept = p2ps_adv->auto_accept;
 737                 conncap = p2p->cfg->p2ps_group_capability(p2p->cfg->cb_ctx,
 738                                                           conncap, auto_accept,
 739                                                           &forced_freq,
 740                                                           &pref_freq);
 741
 742                 p2p_dbg(p2p, "Conncap: local:%d remote:%d result:%d",
 743                         auto_accept, remote_conncap, conncap);
 744
 745                 p2p_prepare_channel(p2p, dev, forced_freq, pref_freq, 0);
 746
 747                 resp_fcap.cpt = p2ps_own_preferred_cpt(p2ps_adv->cpt_priority,
 748                                                        req_fcap->cpt);
 749
 750                 p2p_dbg(p2p, "cpt: service:0x%x remote:0x%x result:0x%x",
 751                         p2ps_adv->cpt_mask, req_fcap->cpt, resp_fcap.cpt);
 752
 753                 if (!resp_fcap.cpt) {
 754                         p2p_dbg(p2p,
 755                                 "Incompatible P2PS feature capability CPT bitmask");
 756                         reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
 757                 } else if (p2ps_adv->config_methods &&
 758                            !(msg.wps_config_methods &
 759                              p2ps_adv->config_methods)) {
 760                         p2p_dbg(p2p,
 761                                 "Unsupported config methods in Provision Discovery Request (own=0x%x peer=0x%x)",
 762                                 p2ps_adv->config_methods,
 763                                 msg.wps_config_methods);
 764                         reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
 765                 } else if (!p2ps_adv->state) {
 766                         p2p_dbg(p2p, "P2PS state unavailable");
 767                         reject = P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
 768                 } else if (!conncap) {
 769                         p2p_dbg(p2p, "Conncap resolution failed");
 770                         reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
 771                 }
 772
 773                 if (msg.wps_config_methods & WPS_CONFIG_KEYPAD) {
 774                         p2p_dbg(p2p, "Keypad - always defer");
 775                         auto_accept = 0;
 776                 }
 777
 778                 if ((remote_conncap & (P2PS_SETUP_NEW | P2PS_SETUP_CLIENT) ||
 779                      msg.persistent_dev) && conncap != P2PS_SETUP_NEW &&
 780                     msg.channel_list && msg.channel_list_len &&
 781                     p2p_peer_channels_check(p2p, &p2p->channels, dev,
 782                                             msg.channel_list,
 783                                             msg.channel_list_len) < 0) {
 784                         p2p_dbg(p2p,
 785                                 "No common channels - force deferred flow");
 786                         auto_accept = 0;
 787                 }
 788
 789                 if (((remote_conncap & P2PS_SETUP_GROUP_OWNER) ||
 790                      msg.persistent_dev) && msg.operating_channel) {
 791                         struct p2p_channels intersect;
 792
 793                         /*
 794                          * There are cases where only the operating channel is
 795                          * provided. This requires saving the channel as the
 796                          * supported channel list, and verifying that it is
 797                          * supported.
 798                          */
 799                         if (dev->channels.reg_classes == 0 ||
 800                             !p2p_channels_includes(&dev->channels,
 801                                                    msg.operating_channel[3],
 802                                                    msg.operating_channel[4])) {
 803                                 struct p2p_channels *ch = &dev->channels;
 804
 805                                 os_memset(ch, 0, sizeof(*ch));
 806                                 ch->reg_class[0].reg_class =
 807                                         msg.operating_channel[3];
 808                                 ch->reg_class[0].channel[0] =
 809                                         msg.operating_channel[4];
 810                                 ch->reg_class[0].channels = 1;
 811                                 ch->reg_classes = 1;
 812                         }
 813
 814                         p2p_channels_intersect(&p2p->channels, &dev->channels,
 815                                                &intersect);
 816
 817                         if (intersect.reg_classes == 0) {
 818                                 p2p_dbg(p2p,
 819                                         "No common channels - force deferred flow");
 820                                 auto_accept = 0;
 821                         }
 822                 }
 823
 824                 if (auto_accept || reject != P2P_SC_SUCCESS) {
 825                         struct p2ps_provision *tmp;
 826
 827                         if (p2ps_setup_p2ps_prov(p2p, adv_id, session_id,
 828                                                  msg.wps_config_methods,
 829                                                  session_mac, adv_mac) < 0) {
 830                                 reject = P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
 831                                 goto out;
 832                         }
 833
 834                         tmp = p2p->p2ps_prov;
 835                         tmp->force_freq = forced_freq;
 836                         tmp->pref_freq = pref_freq;
 837                         if (conncap) {
 838                                 tmp->conncap = conncap;
 839                                 tmp->status = P2P_SC_SUCCESS;
 840                         } else {
 841                                 tmp->conncap = auto_accept;
 842                                 tmp->status = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
 843                         }
 844
 845                         if (reject != P2P_SC_SUCCESS)
 846                                 goto out;
 847                 }
 848         }
 849
 850         if (!msg.status && !auto_accept &&
 851             (!p2p->p2ps_prov || p2p->p2ps_prov->adv_id != adv_id)) {
 852                 struct p2ps_provision *tmp;
 853
 854                 if (!conncap) {
 855                         reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
 856                         goto out;
 857                 }
 858
 859                 if (p2ps_setup_p2ps_prov(p2p, adv_id, session_id,
 860                                          msg.wps_config_methods,
 861                                          session_mac, adv_mac) < 0) {
 862                         reject = P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
 863                         goto out;
 864                 }
 865                 tmp = p2p->p2ps_prov;
 866                 reject = P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE;
 867                 tmp->status = reject;
 868         }
 869
 870         /* Not a P2PS Follow-on PD */
 871         if (!msg.status)
 872                 goto out;
 873
 874         if (*msg.status && *msg.status != P2P_SC_SUCCESS_DEFERRED) {
 875                 reject = *msg.status;
 876                 goto out;
 877         }
 878
 879         if (*msg.status != P2P_SC_SUCCESS_DEFERRED || !p2p->p2ps_prov)
 880                 goto out;
 881
 882         if (p2p->p2ps_prov->adv_id != adv_id ||
 883             os_memcmp(p2p->p2ps_prov->adv_mac, msg.adv_mac, ETH_ALEN)) {
 884                 p2p_dbg(p2p,
 885                         "P2PS Follow-on PD with mismatch Advertisement ID/MAC");
 886                 goto out;
 887         }
 888
 889         if (p2p->p2ps_prov->session_id != session_id ||
 890             os_memcmp(p2p->p2ps_prov->session_mac, msg.session_mac, ETH_ALEN)) {
 891                 p2p_dbg(p2p, "P2PS Follow-on PD with mismatch Session ID/MAC");
 892                 goto out;
 893         }
 894
 895         method = p2p->p2ps_prov->method;
 896
 897         conncap = p2p->cfg->p2ps_group_capability(p2p->cfg->cb_ctx,
 898                                                   remote_conncap,
 899                                                   p2p->p2ps_prov->conncap,
 900                                                   &p2p->p2ps_prov->force_freq,
 901                                                   &p2p->p2ps_prov->pref_freq);
 902
 903         resp_fcap.cpt = p2ps_own_preferred_cpt(p2p->p2ps_prov->cpt_priority,
 904                                                req_fcap->cpt);
 905
 906         p2p_dbg(p2p, "cpt: local:0x%x remote:0x%x result:0x%x",
 907                 p2p->p2ps_prov->cpt_mask, req_fcap->cpt, resp_fcap.cpt);
 908
 909         p2p_prepare_channel(p2p, dev, p2p->p2ps_prov->force_freq,
 910                             p2p->p2ps_prov->pref_freq, 0);
 911
 912         /*
 913          * Ensure that if we asked for PIN originally, our method is consistent
 914          * with original request.
 915          */
 916         if (method & WPS_CONFIG_DISPLAY)
 917                 method = WPS_CONFIG_KEYPAD;
 918         else if (method & WPS_CONFIG_KEYPAD)
 919                 method = WPS_CONFIG_DISPLAY;
 920
 921         if (!conncap || !(msg.wps_config_methods & method)) {
 922                 /*
 923                  * Reject this "Deferred Accept*
 924                  * if incompatible conncap or method
 925                  */
 926                 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
 927         } else if (!resp_fcap.cpt) {
 928                 p2p_dbg(p2p,
 929                         "Incompatible P2PS feature capability CPT bitmask");
 930                 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
 931         } else if ((remote_conncap & (P2PS_SETUP_NEW | P2PS_SETUP_CLIENT) ||
 932                     msg.persistent_dev) && conncap != P2PS_SETUP_NEW &&
 933                    msg.channel_list && msg.channel_list_len &&
 934                    p2p_peer_channels_check(p2p, &p2p->channels, dev,
 935                                            msg.channel_list,
 936                                            msg.channel_list_len) < 0) {
 937                 p2p_dbg(p2p,
 938                         "No common channels in Follow-On Provision Discovery Request");
 939                 reject = P2P_SC_FAIL_NO_COMMON_CHANNELS;
 940         } else {
 941                 reject = P2P_SC_SUCCESS;
 942         }
 943
 944         dev->oper_freq = 0;
 945         if (reject == P2P_SC_SUCCESS || reject == P2P_SC_SUCCESS_DEFERRED) {
 946                 u8 tmp;
 947
 948                 if (msg.operating_channel)
 949                         dev->oper_freq =
 950                                 p2p_channel_to_freq(msg.operating_channel[3],
 951                                                     msg.operating_channel[4]);
 952
 953                 if ((conncap & P2PS_SETUP_GROUP_OWNER) &&
 954                     p2p_go_select_channel(p2p, dev, &tmp) < 0)
 955                         reject = P2P_SC_FAIL_NO_COMMON_CHANNELS;
 956         }
 957
 958         p2p->p2ps_prov->status = reject;
 959         p2p->p2ps_prov->conncap = conncap;
 960
 961 out:
 962         if (reject == P2P_SC_SUCCESS ||
 963             reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE)
 964                 config_methods = msg.wps_config_methods;
 965         else
 966                 config_methods = 0;
 967
 968         /*
 969          * Send PD Response for an initial PD Request or for follow-on
 970          * PD Request with P2P_SC_SUCCESS_DEFERRED status.
 971          */
 972         if (!msg.status || *msg.status == P2P_SC_SUCCESS_DEFERRED) {
 973                 resp = p2p_build_prov_disc_resp(p2p, dev, msg.dialog_token,
 974                                                 reject, config_methods, adv_id,
 975                                                 msg.group_id, msg.group_id_len,
 976                                                 msg.persistent_ssid,
 977                                                 msg.persistent_ssid_len,
 978                                                 (const u8 *) &resp_fcap,
 979                                                 sizeof(resp_fcap));
 980                 if (!resp) {
 981                         p2p_parse_free(&msg);
 982                         return;
 983                 }
 984                 p2p_dbg(p2p, "Sending Provision Discovery Response");
 985                 if (rx_freq > 0)
 986                         freq = rx_freq;
 987                 else
 988                         freq = p2p_channel_to_freq(p2p->cfg->reg_class,
 989                                                    p2p->cfg->channel);
 990                 if (freq < 0) {
 991                         p2p_dbg(p2p, "Unknown regulatory class/channel");
 992                         wpabuf_free(resp);
 993                         p2p_parse_free(&msg);
 994                         return;
 995                 }
 996                 p2p->pending_action_state = P2P_PENDING_PD_RESPONSE;
 997                 if (p2p_send_action(p2p, freq, sa, p2p->cfg->dev_addr,
 998                                     p2p->cfg->dev_addr,
 999                                     wpabuf_head(resp), wpabuf_len(resp),
1000                                     50) < 0)
1001                         p2p_dbg(p2p, "Failed to send Action frame");
1002                 else
1003                         p2p->send_action_in_progress = 1;
1004
1005                 wpabuf_free(resp);
1006         }
1007
1008         if (!dev) {
1009                 p2p_parse_free(&msg);
1010                 return;
1011         }
1012
1013         freq = 0;
1014         if (reject == P2P_SC_SUCCESS && conncap == P2PS_SETUP_GROUP_OWNER) {
1015                 freq = p2p_channel_to_freq(p2p->op_reg_class,
1016                                            p2p->op_channel);
1017                 if (freq < 0)
1018                         freq = 0;
1019         }
1020
1021         if (!p2p->cfg->p2ps_prov_complete) {
1022                 /* Don't emit anything */
1023         } else if (msg.status && *msg.status != P2P_SC_SUCCESS &&
1024                    *msg.status != P2P_SC_SUCCESS_DEFERRED) {
1025                 reject = *msg.status;
1026                 p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, reject,
1027                                              sa, adv_mac, session_mac,
1028                                              NULL, adv_id, session_id,
1029                                              0, 0, msg.persistent_ssid,
1030                                              msg.persistent_ssid_len,
1031                                              0, 0, NULL, NULL, 0, freq,
1032                                              NULL, 0);
1033         } else if (msg.status && *msg.status == P2P_SC_SUCCESS_DEFERRED &&
1034                    p2p->p2ps_prov) {
1035                 p2p->p2ps_prov->status = reject;
1036                 p2p->p2ps_prov->conncap = conncap;
1037
1038                 if (reject != P2P_SC_SUCCESS)
1039                         p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, reject,
1040                                                      sa, adv_mac, session_mac,
1041                                                      NULL, adv_id,
1042                                                      session_id, conncap, 0,
1043                                                      msg.persistent_ssid,
1044                                                      msg.persistent_ssid_len, 0,
1045                                                      0, NULL, NULL, 0, freq,
1046                                                      NULL, 0);
1047                 else
1048                         p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx,
1049                                                      *msg.status,
1050                                                      sa, adv_mac, session_mac,
1051                                                      group_mac, adv_id,
1052                                                      session_id, conncap,
1053                                                      passwd_id,
1054                                                      msg.persistent_ssid,
1055                                                      msg.persistent_ssid_len, 0,
1056                                                      0, NULL,
1057                                                      (const u8 *) &resp_fcap,
1058                                                      sizeof(resp_fcap), freq,
1059                                                      NULL, 0);
1060         } else if (msg.status && p2p->p2ps_prov) {
1061                 p2p->p2ps_prov->status = P2P_SC_SUCCESS;
1062                 p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, *msg.status, sa,
1063                                              adv_mac, session_mac, group_mac,
1064                                              adv_id, session_id, conncap,
1065                                              passwd_id,
1066                                              msg.persistent_ssid,
1067                                              msg.persistent_ssid_len,
1068                                              0, 0, NULL,
1069                                              (const u8 *) &resp_fcap,
1070                                              sizeof(resp_fcap), freq, NULL, 0);
1071         } else if (msg.status) {
1072         } else if (auto_accept && reject == P2P_SC_SUCCESS) {
1073                 p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, P2P_SC_SUCCESS,
1074                                              sa, adv_mac, session_mac,
1075                                              group_mac, adv_id, session_id,
1076                                              conncap, passwd_id,
1077                                              msg.persistent_ssid,
1078                                              msg.persistent_ssid_len,
1079                                              0, 0, NULL,
1080                                              (const u8 *) &resp_fcap,
1081                                              sizeof(resp_fcap), freq,
1082                                              msg.group_id ?
1083                                              msg.group_id + ETH_ALEN : NULL,
1084                                              msg.group_id ?
1085                                              msg.group_id_len - ETH_ALEN : 0);
1086         } else if (reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE &&
1087                    (!msg.session_info || !msg.session_info_len)) {
1088                 p2p->p2ps_prov->method = msg.wps_config_methods;
1089
1090                 p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, P2P_SC_SUCCESS,
1091                                              sa, adv_mac, session_mac,
1092                                              group_mac, adv_id, session_id,
1093                                              conncap, passwd_id,
1094                                              msg.persistent_ssid,
1095                                              msg.persistent_ssid_len,
1096                                              0, 1, NULL,
1097                                              (const u8 *) &resp_fcap,
1098                                              sizeof(resp_fcap), freq, NULL, 0);
1099         } else if (reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) {
1100                 size_t buf_len = msg.session_info_len;
1101                 char *buf = os_malloc(2 * buf_len + 1);
1102
1103                 if (buf) {
1104                         p2p->p2ps_prov->method = msg.wps_config_methods;
1105
1106                         utf8_escape((char *) msg.session_info, buf_len,
1107                                     buf, 2 * buf_len + 1);
1108
1109                         p2p->cfg->p2ps_prov_complete(
1110                                 p2p->cfg->cb_ctx, P2P_SC_SUCCESS, sa,
1111                                 adv_mac, session_mac, group_mac, adv_id,
1112                                 session_id, conncap, passwd_id,
1113                                 msg.persistent_ssid, msg.persistent_ssid_len,
1114                                 0, 1, buf,
1115                                 (const u8 *) &resp_fcap, sizeof(resp_fcap),
1116                                 freq, NULL, 0);
1117
1118                         os_free(buf);
1119                 }
1120         }
1121
1122         /*
1123          * prov_disc_req callback is used to generate P2P-PROV-DISC-ENTER-PIN,
1124          * P2P-PROV-DISC-SHOW-PIN, and P2P-PROV-DISC-PBC-REQ events.
1125          * Call it either on legacy P2P PD or on P2PS PD only if we need to
1126          * enter/show PIN.
1127          *
1128          * The callback is called in the following cases:
1129          * 1. Legacy P2P PD request, response status SUCCESS
1130          * 2. P2PS advertiser, method: DISPLAY, autoaccept: TRUE,
1131          *    response status: SUCCESS
1132          * 3. P2PS advertiser, method  DISPLAY, autoaccept: FALSE,
1133          *    response status: INFO_CURRENTLY_UNAVAILABLE
1134          * 4. P2PS advertiser, method: KEYPAD, autoaccept==any,
1135          *    response status: INFO_CURRENTLY_UNAVAILABLE
1136          * 5. P2PS follow-on with SUCCESS_DEFERRED,
1137          *    advertiser role: DISPLAY, autoaccept: FALSE,
1138          *    seeker: KEYPAD, response status: SUCCESS
1139          */
1140         if (p2p->cfg->prov_disc_req &&
1141             ((reject == P2P_SC_SUCCESS && !msg.adv_id) ||
1142              (!msg.status &&
1143              (reject == P2P_SC_SUCCESS ||
1144               reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) &&
1145               passwd_id == DEV_PW_USER_SPECIFIED) ||
1146              (!msg.status &&
1147               reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE &&
1148               passwd_id == DEV_PW_REGISTRAR_SPECIFIED) ||
1149              (reject == P2P_SC_SUCCESS &&
1150               msg.status && *msg.status == P2P_SC_SUCCESS_DEFERRED &&
1151                passwd_id == DEV_PW_REGISTRAR_SPECIFIED))) {
1152                 const u8 *dev_addr = sa;
1153
1154                 if (msg.p2p_device_addr)
1155                         dev_addr = msg.p2p_device_addr;
1156                 p2p->cfg->prov_disc_req(p2p->cfg->cb_ctx, sa,
1157                                         msg.wps_config_methods,
1158                                         dev_addr, msg.pri_dev_type,
1159                                         msg.device_name, msg.config_methods,
1160                                         msg.capability ? msg.capability[0] : 0,
1161                                         msg.capability ? msg.capability[1] :
1162                                         0,
1163                                         msg.group_id, msg.group_id_len);
1164         }
1165
1166         if (reject != P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE)
1167                 p2ps_prov_free(p2p);
1168
1169         if (reject == P2P_SC_SUCCESS) {
1170                 switch (config_methods) {
1171                 case WPS_CONFIG_DISPLAY:
1172                         dev->wps_prov_info = WPS_CONFIG_KEYPAD;
1173                         break;
1174                 case WPS_CONFIG_KEYPAD:
1175                         dev->wps_prov_info = WPS_CONFIG_DISPLAY;
1176                         break;
1177                 case WPS_CONFIG_PUSHBUTTON:
1178                         dev->wps_prov_info = WPS_CONFIG_PUSHBUTTON;
1179                         break;
1180                 case WPS_CONFIG_P2PS:
1181                         dev->wps_prov_info = WPS_CONFIG_P2PS;
1182                         break;
1183                 default:
1184                         dev->wps_prov_info = 0;
1185                         break;
1186                 }
1187
1188                 if (msg.intended_addr)
1189                         os_memcpy(dev->interface_addr, msg.intended_addr,
1190                                   ETH_ALEN);
1191         }
1192         p2p_parse_free(&msg);
1193 }
1194
1195
1196 static int p2p_validate_p2ps_pd_resp(struct p2p_data *p2p,
1197                                      struct p2p_message *msg)
1198 {
1199         u8 conn_cap_go = 0;
1200         u8 conn_cap_cli = 0;
1201         u32 session_id;
1202         u32 adv_id;
1203
1204 #define P2PS_PD_RESP_CHECK(_val, _attr) \
1205         do { \
1206                 if ((_val) && !msg->_attr) { \
1207                         p2p_dbg(p2p, "P2PS PD Response missing " #_attr); \
1208                         return -1; \
1209                 } \
1210         } while (0)
1211
1212         P2PS_PD_RESP_CHECK(1, status);
1213         P2PS_PD_RESP_CHECK(1, adv_id);
1214         P2PS_PD_RESP_CHECK(1, adv_mac);
1215         P2PS_PD_RESP_CHECK(1, capability);
1216         P2PS_PD_RESP_CHECK(1, p2p_device_info);
1217         P2PS_PD_RESP_CHECK(1, session_id);
1218         P2PS_PD_RESP_CHECK(1, session_mac);
1219         P2PS_PD_RESP_CHECK(1, feature_cap);
1220
1221         session_id = WPA_GET_LE32(msg->session_id);
1222         adv_id = WPA_GET_LE32(msg->adv_id);
1223
1224         if (p2p->p2ps_prov->session_id != session_id) {
1225                 p2p_dbg(p2p,
1226                         "Ignore PD Response with unexpected Session ID");
1227                 return -1;
1228         }
1229
1230         if (os_memcmp(p2p->p2ps_prov->session_mac, msg->session_mac,
1231                       ETH_ALEN)) {
1232                 p2p_dbg(p2p,
1233                         "Ignore PD Response with unexpected Session MAC");
1234                 return -1;
1235         }
1236
1237         if (p2p->p2ps_prov->adv_id != adv_id) {
1238                 p2p_dbg(p2p,
1239                         "Ignore PD Response with unexpected Advertisement ID");
1240                 return -1;
1241         }
1242
1243         if (os_memcmp(p2p->p2ps_prov->adv_mac, msg->adv_mac, ETH_ALEN) != 0) {
1244                 p2p_dbg(p2p,
1245                         "Ignore PD Response with unexpected Advertisement MAC");
1246                 return -1;
1247         }
1248
1249         if (msg->listen_channel) {
1250                 p2p_dbg(p2p,
1251                         "Ignore malformed PD Response - unexpected Listen Channel");
1252                 return -1;
1253         }
1254
1255         if (*msg->status == P2P_SC_SUCCESS &&
1256             !(!!msg->conn_cap ^ !!msg->persistent_dev)) {
1257                 p2p_dbg(p2p,
1258                         "Ignore malformed PD Response - either conn_cap or persistent group should be present");
1259                 return -1;
1260         }
1261
1262         if (msg->persistent_dev && *msg->status != P2P_SC_SUCCESS) {
1263                 p2p_dbg(p2p,
1264                         "Ignore malformed PD Response - persistent group is present, but the status isn't success");
1265                 return -1;
1266         }
1267
1268         if (msg->conn_cap) {
1269                 conn_cap_go = *msg->conn_cap == P2PS_SETUP_GROUP_OWNER;
1270                 conn_cap_cli = *msg->conn_cap == P2PS_SETUP_CLIENT;
1271         }
1272
1273         P2PS_PD_RESP_CHECK(msg->persistent_dev || conn_cap_go || conn_cap_cli,
1274                            channel_list);
1275         P2PS_PD_RESP_CHECK(msg->persistent_dev || conn_cap_go || conn_cap_cli,
1276                            config_timeout);
1277
1278         P2PS_PD_RESP_CHECK(conn_cap_go, group_id);
1279         P2PS_PD_RESP_CHECK(conn_cap_go, intended_addr);
1280         P2PS_PD_RESP_CHECK(conn_cap_go, operating_channel);
1281         /*
1282          * TODO: Also validate that operating channel is present if the device
1283          * is a GO in a persistent group. We can't do it here since we don't
1284          * know what is the role of the peer. It should be probably done in
1285          * p2ps_prov_complete callback, but currently operating channel isn't
1286          * passed to it.
1287          */
1288
1289 #undef P2PS_PD_RESP_CHECK
1290
1291         return 0;
1292 }
1293
1294
1295 void p2p_process_prov_disc_resp(struct p2p_data *p2p, const u8 *sa,
1296                                 const u8 *data, size_t len)
1297 {
1298         struct p2p_message msg;
1299         struct p2p_device *dev;
1300         u16 report_config_methods = 0, req_config_methods;
1301         u8 status = P2P_SC_SUCCESS;
1302         u32 adv_id = 0;
1303         u8 conncap = P2PS_SETUP_NEW;
1304         u8 adv_mac[ETH_ALEN];
1305         const u8 *group_mac;
1306         int passwd_id = DEV_PW_DEFAULT;
1307         int p2ps_seeker;
1308
1309         if (p2p_parse(data, len, &msg))
1310                 return;
1311
1312         if (p2p->p2ps_prov && p2p_validate_p2ps_pd_resp(p2p, &msg)) {
1313                 p2p_parse_free(&msg);
1314                 return;
1315         }
1316
1317         /* Parse the P2PS members present */
1318         if (msg.status)
1319                 status = *msg.status;
1320
1321         group_mac = msg.intended_addr;
1322
1323         if (msg.adv_mac)
1324                 os_memcpy(adv_mac, msg.adv_mac, ETH_ALEN);
1325         else
1326                 os_memset(adv_mac, 0, ETH_ALEN);
1327
1328         if (msg.adv_id)
1329                 adv_id = WPA_GET_LE32(msg.adv_id);
1330
1331         if (msg.conn_cap) {
1332                 conncap = *msg.conn_cap;
1333
1334                 /* Switch bits to local relative */
1335                 switch (conncap) {
1336                 case P2PS_SETUP_GROUP_OWNER:
1337                         conncap = P2PS_SETUP_CLIENT;
1338                         break;
1339                 case P2PS_SETUP_CLIENT:
1340                         conncap = P2PS_SETUP_GROUP_OWNER;
1341                         break;
1342                 }
1343         }
1344
1345         p2p_dbg(p2p, "Received Provision Discovery Response from " MACSTR
1346                 " with config methods 0x%x",
1347                 MAC2STR(sa), msg.wps_config_methods);
1348
1349         dev = p2p_get_device(p2p, sa);
1350         if (dev == NULL || !dev->req_config_methods) {
1351                 p2p_dbg(p2p, "Ignore Provision Discovery Response from " MACSTR
1352                         " with no pending request", MAC2STR(sa));
1353                 p2p_parse_free(&msg);
1354                 return;
1355         } else if (msg.wfd_subelems) {
1356                 wpabuf_free(dev->info.wfd_subelems);
1357                 dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems);
1358         }
1359
1360         if (dev->dialog_token != msg.dialog_token) {
1361                 p2p_dbg(p2p, "Ignore Provision Discovery Response with unexpected Dialog Token %u (expected %u)",
1362                         msg.dialog_token, dev->dialog_token);
1363                 p2p_parse_free(&msg);
1364                 return;
1365         }
1366
1367         if (p2p->pending_action_state == P2P_PENDING_PD) {
1368                 os_memset(p2p->pending_pd_devaddr, 0, ETH_ALEN);
1369                 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
1370         }
1371
1372         p2ps_seeker = p2p->p2ps_prov && p2p->p2ps_prov->pd_seeker;
1373
1374         /*
1375          * Use a local copy of the requested config methods since
1376          * p2p_reset_pending_pd() can clear this in the peer entry.
1377          */
1378         req_config_methods = dev->req_config_methods;
1379
1380         /*
1381          * If the response is from the peer to whom a user initiated request
1382          * was sent earlier, we reset that state info here.
1383          */
1384         if (p2p->user_initiated_pd &&
1385             os_memcmp(p2p->pending_pd_devaddr, sa, ETH_ALEN) == 0)
1386                 p2p_reset_pending_pd(p2p);
1387
1388         if (msg.wps_config_methods != req_config_methods) {
1389                 p2p_dbg(p2p, "Peer rejected our Provision Discovery Request (received config_methods 0x%x expected 0x%x",
1390                         msg.wps_config_methods, req_config_methods);
1391                 if (p2p->cfg->prov_disc_fail)
1392                         p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx, sa,
1393                                                  P2P_PROV_DISC_REJECTED,
1394                                                  adv_id, adv_mac, NULL);
1395                 p2p_parse_free(&msg);
1396                 p2ps_prov_free(p2p);
1397                 goto out;
1398         }
1399
1400         report_config_methods = req_config_methods;
1401         dev->flags &= ~(P2P_DEV_PD_PEER_DISPLAY |
1402                         P2P_DEV_PD_PEER_KEYPAD |
1403                         P2P_DEV_PD_PEER_P2PS);
1404         if (req_config_methods & WPS_CONFIG_DISPLAY) {
1405                 p2p_dbg(p2p, "Peer " MACSTR
1406                         " accepted to show a PIN on display", MAC2STR(sa));
1407                 dev->flags |= P2P_DEV_PD_PEER_DISPLAY;
1408                 passwd_id = DEV_PW_REGISTRAR_SPECIFIED;
1409         } else if (msg.wps_config_methods & WPS_CONFIG_KEYPAD) {
1410                 p2p_dbg(p2p, "Peer " MACSTR
1411                         " accepted to write our PIN using keypad",
1412                         MAC2STR(sa));
1413                 dev->flags |= P2P_DEV_PD_PEER_KEYPAD;
1414                 passwd_id = DEV_PW_USER_SPECIFIED;
1415         } else if (msg.wps_config_methods & WPS_CONFIG_P2PS) {
1416                 p2p_dbg(p2p, "Peer " MACSTR " accepted P2PS PIN",
1417                         MAC2STR(sa));
1418                 dev->flags |= P2P_DEV_PD_PEER_P2PS;
1419                 passwd_id = DEV_PW_P2PS_DEFAULT;
1420         }
1421
1422         if ((status == P2P_SC_SUCCESS || status == P2P_SC_SUCCESS_DEFERRED) &&
1423             p2p->p2ps_prov) {
1424                 dev->oper_freq = 0;
1425
1426                 /*
1427                  * Save the reported channel list and operating frequency.
1428                  * Note that the specification mandates that the responder
1429                  * should include in the channel list only channels reported by
1430                  * the initiator, so this is only a sanity check, and if this
1431                  * fails the flow would continue, although it would probably
1432                  * fail. Same is true for the operating channel.
1433                  */
1434                 if (msg.channel_list && msg.channel_list_len &&
1435                     p2p_peer_channels_check(p2p, &p2p->channels, dev,
1436                                             msg.channel_list,
1437                                             msg.channel_list_len) < 0)
1438                         p2p_dbg(p2p, "P2PS PD Response - no common channels");
1439
1440                 if (msg.operating_channel) {
1441                         if (p2p_channels_includes(&p2p->channels,
1442                                                   msg.operating_channel[3],
1443                                                   msg.operating_channel[4]) &&
1444                             p2p_channels_includes(&dev->channels,
1445                                                   msg.operating_channel[3],
1446                                                   msg.operating_channel[4])) {
1447                                 dev->oper_freq =
1448                                         p2p_channel_to_freq(
1449                                                 msg.operating_channel[3],
1450                                                 msg.operating_channel[4]);
1451                         } else {
1452                                 p2p_dbg(p2p,
1453                                         "P2PS PD Response - invalid operating channel");
1454                         }
1455                 }
1456
1457                 if (p2p->cfg->p2ps_prov_complete) {
1458                         int freq = 0;
1459
1460                         if (conncap == P2PS_SETUP_GROUP_OWNER) {
1461                                 u8 tmp;
1462
1463                                 /*
1464                                  * Re-select the operating channel as it is
1465                                  * possible that original channel is no longer
1466                                  * valid. This should not really fail.
1467                                  */
1468                                 if (p2p_go_select_channel(p2p, dev, &tmp) < 0)
1469                                         p2p_dbg(p2p,
1470                                                 "P2PS PD channel selection failed");
1471
1472                                 freq = p2p_channel_to_freq(p2p->op_reg_class,
1473                                                            p2p->op_channel);
1474                                 if (freq < 0)
1475                                         freq = 0;
1476                         }
1477
1478                         p2p->cfg->p2ps_prov_complete(
1479                                 p2p->cfg->cb_ctx, status, sa, adv_mac,
1480                                 p2p->p2ps_prov->session_mac,
1481                                 group_mac, adv_id, p2p->p2ps_prov->session_id,
1482                                 conncap, passwd_id, msg.persistent_ssid,
1483                                 msg.persistent_ssid_len, 1, 0, NULL,
1484                                 msg.feature_cap, msg.feature_cap_len, freq,
1485                                 msg.group_id ? msg.group_id + ETH_ALEN : NULL,
1486                                 msg.group_id ? msg.group_id_len - ETH_ALEN : 0);
1487                 }
1488                 p2ps_prov_free(p2p);
1489         } else if (status != P2P_SC_SUCCESS &&
1490                    status != P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE &&
1491                    status != P2P_SC_SUCCESS_DEFERRED && p2p->p2ps_prov) {
1492                 if (p2p->cfg->p2ps_prov_complete)
1493                         p2p->cfg->p2ps_prov_complete(
1494                                 p2p->cfg->cb_ctx, status, sa, adv_mac,
1495                                 p2p->p2ps_prov->session_mac,
1496                                 group_mac, adv_id, p2p->p2ps_prov->session_id,
1497                                 0, 0, NULL, 0, 1, 0, NULL, NULL, 0, 0, NULL, 0);
1498                 p2ps_prov_free(p2p);
1499         }
1500
1501         if (status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) {
1502                 if (p2p->cfg->remove_stale_groups) {
1503                         p2p->cfg->remove_stale_groups(p2p->cfg->cb_ctx,
1504                                                       dev->info.p2p_device_addr,
1505                                                       NULL, NULL, 0);
1506                 }
1507
1508                 if (msg.session_info && msg.session_info_len) {
1509                         size_t info_len = msg.session_info_len;
1510                         char *deferred_sess_resp = os_malloc(2 * info_len + 1);
1511
1512                         if (!deferred_sess_resp) {
1513                                 p2p_parse_free(&msg);
1514                                 p2ps_prov_free(p2p);
1515                                 goto out;
1516                         }
1517                         utf8_escape((char *) msg.session_info, info_len,
1518                                     deferred_sess_resp, 2 * info_len + 1);
1519
1520                         if (p2p->cfg->prov_disc_fail)
1521                                 p2p->cfg->prov_disc_fail(
1522                                         p2p->cfg->cb_ctx, sa,
1523                                         P2P_PROV_DISC_INFO_UNAVAILABLE,
1524                                         adv_id, adv_mac,
1525                                         deferred_sess_resp);
1526                         os_free(deferred_sess_resp);
1527                 } else
1528                         if (p2p->cfg->prov_disc_fail)
1529                                 p2p->cfg->prov_disc_fail(
1530                                         p2p->cfg->cb_ctx, sa,
1531                                         P2P_PROV_DISC_INFO_UNAVAILABLE,
1532                                         adv_id, adv_mac, NULL);
1533         } else if (status != P2P_SC_SUCCESS) {
1534                 p2p_dbg(p2p, "Peer rejected our Provision Discovery Request");
1535                 if (p2p->cfg->prov_disc_fail)
1536                         p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx, sa,
1537                                                  P2P_PROV_DISC_REJECTED,
1538                                                  adv_id, adv_mac, NULL);
1539                 p2p_parse_free(&msg);
1540                 p2ps_prov_free(p2p);
1541                 goto out;
1542         }
1543
1544         /* Store the provisioning info */
1545         dev->wps_prov_info = msg.wps_config_methods;
1546         if (msg.intended_addr)
1547                 os_memcpy(dev->interface_addr, msg.intended_addr, ETH_ALEN);
1548
1549         p2p_parse_free(&msg);
1550
1551 out:
1552         dev->req_config_methods = 0;
1553         p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
1554         if (dev->flags & P2P_DEV_PD_BEFORE_GO_NEG) {
1555                 p2p_dbg(p2p, "Start GO Neg after the PD-before-GO-Neg workaround with "
1556                         MACSTR, MAC2STR(dev->info.p2p_device_addr));
1557                 dev->flags &= ~P2P_DEV_PD_BEFORE_GO_NEG;
1558                 p2p_connect_send(p2p, dev);
1559                 return;
1560         }
1561
1562         /*
1563          * prov_disc_resp callback is used to generate P2P-PROV-DISC-ENTER-PIN,
1564          * P2P-PROV-DISC-SHOW-PIN, and P2P-PROV-DISC-PBC-REQ events.
1565          * Call it only for a legacy P2P PD or for P2PS PD scenarios where
1566          * show/enter PIN events are needed.
1567          *
1568          * The callback is called in the following cases:
1569          * 1. Legacy P2P PD response with a status SUCCESS
1570          * 2. P2PS, advertiser method: DISPLAY, autoaccept: true,
1571          *    response status: SUCCESS, local method KEYPAD
1572          * 3. P2PS, advertiser method: KEYPAD,Seeker side,
1573          *    response status: INFO_CURRENTLY_UNAVAILABLE,
1574          *    local method: DISPLAY
1575          */
1576         if (p2p->cfg->prov_disc_resp &&
1577             ((status == P2P_SC_SUCCESS && !adv_id) ||
1578              (p2ps_seeker && status == P2P_SC_SUCCESS &&
1579               passwd_id == DEV_PW_REGISTRAR_SPECIFIED) ||
1580              (p2ps_seeker &&
1581               status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE &&
1582               passwd_id == DEV_PW_USER_SPECIFIED)))
1583                 p2p->cfg->prov_disc_resp(p2p->cfg->cb_ctx, sa,
1584                                          report_config_methods);
1585
1586         if (p2p->state == P2P_PD_DURING_FIND) {
1587                 p2p_stop_listen_for_freq(p2p, 0);
1588                 p2p_continue_find(p2p);
1589         }
1590 }
1591
1592
1593 int p2p_send_prov_disc_req(struct p2p_data *p2p, struct p2p_device *dev,
1594                            int join, int force_freq)
1595 {
1596         struct wpabuf *req;
1597         int freq;
1598
1599         if (force_freq > 0)
1600                 freq = force_freq;
1601         else
1602                 freq = dev->listen_freq > 0 ? dev->listen_freq :
1603                         dev->oper_freq;
1604         if (freq <= 0) {
1605                 p2p_dbg(p2p, "No Listen/Operating frequency known for the peer "
1606                         MACSTR " to send Provision Discovery Request",
1607                         MAC2STR(dev->info.p2p_device_addr));
1608                 return -1;
1609         }
1610
1611         if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) {
1612                 if (!(dev->info.dev_capab &
1613                       P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) {
1614                         p2p_dbg(p2p, "Cannot use PD with P2P Device " MACSTR
1615                                 " that is in a group and is not discoverable",
1616                                 MAC2STR(dev->info.p2p_device_addr));
1617                         return -1;
1618                 }
1619                 /* TODO: use device discoverability request through GO */
1620         }
1621
1622         if (p2p->p2ps_prov) {
1623                 if (p2p->p2ps_prov->status == P2P_SC_SUCCESS_DEFERRED) {
1624                         if (p2p->p2ps_prov->method == WPS_CONFIG_DISPLAY)
1625                                 dev->req_config_methods = WPS_CONFIG_KEYPAD;
1626                         else if (p2p->p2ps_prov->method == WPS_CONFIG_KEYPAD)
1627                                 dev->req_config_methods = WPS_CONFIG_DISPLAY;
1628                         else
1629                                 dev->req_config_methods = WPS_CONFIG_P2PS;
1630                 } else {
1631                         /* Order of preference, based on peer's capabilities */
1632                         if (p2p->p2ps_prov->method)
1633                                 dev->req_config_methods =
1634                                         p2p->p2ps_prov->method;
1635                         else if (dev->info.config_methods & WPS_CONFIG_P2PS)
1636                                 dev->req_config_methods = WPS_CONFIG_P2PS;
1637                         else if (dev->info.config_methods & WPS_CONFIG_DISPLAY)
1638                                 dev->req_config_methods = WPS_CONFIG_DISPLAY;
1639                         else
1640                                 dev->req_config_methods = WPS_CONFIG_KEYPAD;
1641                 }
1642                 p2p_dbg(p2p,
1643                         "Building PD Request based on P2PS config method 0x%x status %d --> req_config_methods 0x%x",
1644                         p2p->p2ps_prov->method, p2p->p2ps_prov->status,
1645                         dev->req_config_methods);
1646
1647                 if (p2p_prepare_channel(p2p, dev, p2p->p2ps_prov->force_freq,
1648                                         p2p->p2ps_prov->pref_freq, 1) < 0)
1649                         return -1;
1650         }
1651
1652         req = p2p_build_prov_disc_req(p2p, dev, join);
1653         if (req == NULL)
1654                 return -1;
1655
1656         if (p2p->state != P2P_IDLE)
1657                 p2p_stop_listen_for_freq(p2p, freq);
1658         p2p->pending_action_state = P2P_PENDING_PD;
1659         if (p2p_send_action(p2p, freq, dev->info.p2p_device_addr,
1660                             p2p->cfg->dev_addr, dev->info.p2p_device_addr,
1661                             wpabuf_head(req), wpabuf_len(req), 200) < 0) {
1662                 p2p_dbg(p2p, "Failed to send Action frame");
1663                 wpabuf_free(req);
1664                 return -1;
1665         }
1666
1667         os_memcpy(p2p->pending_pd_devaddr, dev->info.p2p_device_addr, ETH_ALEN);
1668
1669         wpabuf_free(req);
1670         return 0;
1671 }
1672
1673
1674 int p2p_prov_disc_req(struct p2p_data *p2p, const u8 *peer_addr,
1675                       struct p2ps_provision *p2ps_prov,
1676                       u16 config_methods, int join, int force_freq,
1677                       int user_initiated_pd)
1678 {
1679         struct p2p_device *dev;
1680
1681         dev = p2p_get_device(p2p, peer_addr);
1682         if (dev == NULL)
1683                 dev = p2p_get_device_interface(p2p, peer_addr);
1684         if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
1685                 p2p_dbg(p2p, "Provision Discovery Request destination " MACSTR
1686                         " not yet known", MAC2STR(peer_addr));
1687                 os_free(p2ps_prov);
1688                 return -1;
1689         }
1690
1691         p2p_dbg(p2p, "Provision Discovery Request with " MACSTR
1692                 " (config methods 0x%x)",
1693                 MAC2STR(peer_addr), config_methods);
1694         if (config_methods == 0 && !p2ps_prov) {
1695                 os_free(p2ps_prov);
1696                 return -1;
1697         }
1698
1699         if (p2ps_prov && p2ps_prov->status == P2P_SC_SUCCESS_DEFERRED &&
1700             p2p->p2ps_prov) {
1701                 /* Use cached method from deferred provisioning */
1702                 p2ps_prov->method = p2p->p2ps_prov->method;
1703         }
1704
1705         /* Reset provisioning info */
1706         dev->wps_prov_info = 0;
1707         p2ps_prov_free(p2p);
1708         p2p->p2ps_prov = p2ps_prov;
1709
1710         dev->req_config_methods = config_methods;
1711         if (join)
1712                 dev->flags |= P2P_DEV_PD_FOR_JOIN;
1713         else
1714                 dev->flags &= ~P2P_DEV_PD_FOR_JOIN;
1715
1716         if (p2p->state != P2P_IDLE && p2p->state != P2P_SEARCH &&
1717             p2p->state != P2P_LISTEN_ONLY) {
1718                 p2p_dbg(p2p, "Busy with other operations; postpone Provision Discovery Request with "
1719                         MACSTR " (config methods 0x%x)",
1720                         MAC2STR(peer_addr), config_methods);
1721                 return 0;
1722         }
1723
1724         p2p->user_initiated_pd = user_initiated_pd;
1725         p2p->pd_force_freq = force_freq;
1726
1727         if (p2p->user_initiated_pd)
1728                 p2p->pd_retries = MAX_PROV_DISC_REQ_RETRIES;
1729
1730         /*
1731          * Assign dialog token here to use the same value in each retry within
1732          * the same PD exchange.
1733          */
1734         dev->dialog_token++;
1735         if (dev->dialog_token == 0)
1736                 dev->dialog_token = 1;
1737
1738         return p2p_send_prov_disc_req(p2p, dev, join, force_freq);
1739 }
1740
1741
1742 void p2p_reset_pending_pd(struct p2p_data *p2p)
1743 {
1744         struct p2p_device *dev;
1745
1746         dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
1747                 if (os_memcmp(p2p->pending_pd_devaddr,
1748                               dev->info.p2p_device_addr, ETH_ALEN))
1749                         continue;
1750                 if (!dev->req_config_methods)
1751                         continue;
1752                 if (dev->flags & P2P_DEV_PD_FOR_JOIN)
1753                         continue;
1754                 /* Reset the config methods of the device */
1755                 dev->req_config_methods = 0;
1756         }
1757
1758         p2p->user_initiated_pd = 0;
1759         os_memset(p2p->pending_pd_devaddr, 0, ETH_ALEN);
1760         p2p->pd_retries = 0;
1761         p2p->pd_force_freq = 0;
1762 }
1763
1764
1765 void p2ps_prov_free(struct p2p_data *p2p)
1766 {
1767         os_free(p2p->p2ps_prov);
1768         p2p->p2ps_prov = NULL;
1769 }