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, struct wpabuf *buf)
  44 {
  45         int found;
  46         u8 intended_addr[ETH_ALEN];
  47         u8 ssid[32];
  48         size_t ssid_len;
  49         int group_iface;
  50
  51         if (!p2p->cfg->get_go_info)
  52                 return;
  53
  54         found = p2p->cfg->get_go_info(
  55                 p2p->cfg->cb_ctx, intended_addr, ssid,
  56                 &ssid_len, &group_iface);
  57         if (found) {
  58                 p2p_buf_add_group_id(buf, p2p->cfg->dev_addr,
  59                                      ssid, ssid_len);
  60                 p2p_buf_add_intended_addr(buf, intended_addr);
  61         } else {
  62                 if (!p2p->ssid_set) {
  63                         p2p_build_ssid(p2p, p2p->ssid, &p2p->ssid_len);
  64                         p2p->ssid_set = 1;
  65                 }
  66
  67                 /* Add pre-composed P2P Group ID */
  68                 p2p_buf_add_group_id(buf, p2p->cfg->dev_addr,
  69                                      p2p->ssid, p2p->ssid_len);
  70
  71                 if (group_iface)
  72                         p2p_buf_add_intended_addr(
  73                                 buf, p2p->intended_addr);
  74                 else
  75                         p2p_buf_add_intended_addr(
  76                                 buf, p2p->cfg->dev_addr);
  77         }
  78 }
  79
  80
  81 static void p2ps_add_pd_req_attrs(struct p2p_data *p2p, struct p2p_device *dev,
  82                                   struct wpabuf *buf, u16 config_methods)
  83 {
  84         struct p2ps_provision *prov = p2p->p2ps_prov;
  85         u8 feat_cap_mask[] = { 1, 0 };
  86         int shared_group = 0;
  87         u8 ssid[32];
  88         size_t ssid_len;
  89         u8 go_dev_addr[ETH_ALEN];
  90
  91         /* If we might be explicite group owner, add GO details */
  92         if (prov->conncap & (P2PS_SETUP_GROUP_OWNER |
  93                              P2PS_SETUP_NEW))
  94                 p2ps_add_new_group_info(p2p, buf);
  95
  96         if (prov->status >= 0)
  97                 p2p_buf_add_status(buf, (u8) prov->status);
  98         else
  99                 prov->method = config_methods;
 100
 101         if (p2p->cfg->get_persistent_group) {
 102                 shared_group = p2p->cfg->get_persistent_group(
 103                         p2p->cfg->cb_ctx, dev->info.p2p_device_addr, NULL, 0,
 104                         go_dev_addr, ssid, &ssid_len);
 105         }
 106
 107         /* Add Operating Channel if conncap includes GO */
 108         if (shared_group ||
 109             (prov->conncap & (P2PS_SETUP_GROUP_OWNER |
 110                               P2PS_SETUP_NEW))) {
 111                 u8 tmp;
 112
 113                 p2p_go_select_channel(p2p, dev, &tmp);
 114
 115                 if (p2p->op_reg_class && p2p->op_channel)
 116                         p2p_buf_add_operating_channel(buf, p2p->cfg->country,
 117                                                       p2p->op_reg_class,
 118                                                       p2p->op_channel);
 119                 else
 120                         p2p_buf_add_operating_channel(buf, p2p->cfg->country,
 121                                                       p2p->cfg->op_reg_class,
 122                                                       p2p->cfg->op_channel);
 123         }
 124
 125         p2p_buf_add_channel_list(buf, p2p->cfg->country, &p2p->cfg->channels);
 126
 127         if (prov->info[0])
 128                 p2p_buf_add_session_info(buf, prov->info);
 129
 130         p2p_buf_add_connection_capability(buf, prov->conncap);
 131
 132         p2p_buf_add_advertisement_id(buf, prov->adv_id, prov->adv_mac);
 133
 134         if (shared_group || prov->conncap == P2PS_SETUP_NEW ||
 135             prov->conncap ==
 136             (P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_NEW) ||
 137             prov->conncap ==
 138             (P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_CLIENT)) {
 139                 /* Add Config Timeout */
 140                 p2p_buf_add_config_timeout(buf, p2p->go_timeout,
 141                                            p2p->client_timeout);
 142         }
 143
 144         p2p_buf_add_listen_channel(buf, p2p->cfg->country, p2p->cfg->reg_class,
 145                                    p2p->cfg->channel);
 146
 147         p2p_buf_add_session_id(buf, prov->session_id, prov->session_mac);
 148
 149         p2p_buf_add_feature_capability(buf, sizeof(feat_cap_mask),
 150                                        feat_cap_mask);
 151
 152         if (shared_group)
 153                 p2p_buf_add_persistent_group_info(buf, go_dev_addr,
 154                                                   ssid, ssid_len);
 155 }
 156
 157
 158 static struct wpabuf * p2p_build_prov_disc_req(struct p2p_data *p2p,
 159                                                struct p2p_device *dev,
 160                                                int join)
 161 {
 162         struct wpabuf *buf;
 163         u8 *len;
 164         size_t extra = 0;
 165         u8 dialog_token = dev->dialog_token;
 166         u16 config_methods = dev->req_config_methods;
 167         struct p2p_device *go = join ? dev : NULL;
 168
 169 #ifdef CONFIG_WIFI_DISPLAY
 170         if (p2p->wfd_ie_prov_disc_req)
 171                 extra = wpabuf_len(p2p->wfd_ie_prov_disc_req);
 172 #endif /* CONFIG_WIFI_DISPLAY */
 173
 174         if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_PD_REQ])
 175                 extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_P2P_PD_REQ]);
 176
 177         if (p2p->p2ps_prov)
 178                 extra += os_strlen(p2p->p2ps_prov->info) + 1 +
 179                         sizeof(struct p2ps_provision);
 180
 181         buf = wpabuf_alloc(1000 + extra);
 182         if (buf == NULL)
 183                 return NULL;
 184
 185         p2p_buf_add_public_action_hdr(buf, P2P_PROV_DISC_REQ, dialog_token);
 186
 187         len = p2p_buf_add_ie_hdr(buf);
 188         p2p_buf_add_capability(buf, p2p->dev_capab &
 189                                ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY, 0);
 190         p2p_buf_add_device_info(buf, p2p, NULL);
 191         if (p2p->p2ps_prov) {
 192                 p2ps_add_pd_req_attrs(p2p, dev, buf, config_methods);
 193         } else if (go) {
 194                 p2p_buf_add_group_id(buf, go->info.p2p_device_addr,
 195                                      go->oper_ssid, go->oper_ssid_len);
 196         }
 197         p2p_buf_update_ie_hdr(buf, len);
 198
 199         /* WPS IE with Config Methods attribute */
 200         p2p_build_wps_ie_config_methods(buf, config_methods);
 201
 202 #ifdef CONFIG_WIFI_DISPLAY
 203         if (p2p->wfd_ie_prov_disc_req)
 204                 wpabuf_put_buf(buf, p2p->wfd_ie_prov_disc_req);
 205 #endif /* CONFIG_WIFI_DISPLAY */
 206
 207         if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_PD_REQ])
 208                 wpabuf_put_buf(buf, p2p->vendor_elem[VENDOR_ELEM_P2P_PD_REQ]);
 209
 210         return buf;
 211 }
 212
 213
 214 static struct wpabuf * p2p_build_prov_disc_resp(struct p2p_data *p2p,
 215                                                 u8 dialog_token,
 216                                                 u16 config_methods,
 217                                                 const u8 *group_id,
 218                                                 size_t group_id_len)
 219 {
 220         struct wpabuf *buf;
 221         size_t extra = 0;
 222
 223 #ifdef CONFIG_WIFI_DISPLAY
 224         struct wpabuf *wfd_ie = p2p->wfd_ie_prov_disc_resp;
 225         if (wfd_ie && group_id) {
 226                 size_t i;
 227                 for (i = 0; i < p2p->num_groups; i++) {
 228                         struct p2p_group *g = p2p->groups[i];
 229                         struct wpabuf *ie;
 230                         if (!p2p_group_is_group_id_match(g, group_id,
 231                                                          group_id_len))
 232                                 continue;
 233                         ie = p2p_group_get_wfd_ie(g);
 234                         if (ie) {
 235                                 wfd_ie = ie;
 236                                 break;
 237                         }
 238                 }
 239         }
 240         if (wfd_ie)
 241                 extra = wpabuf_len(wfd_ie);
 242 #endif /* CONFIG_WIFI_DISPLAY */
 243
 244         if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_PD_RESP])
 245                 extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_P2P_PD_RESP]);
 246
 247         buf = wpabuf_alloc(100 + extra);
 248         if (buf == NULL)
 249                 return NULL;
 250
 251         p2p_buf_add_public_action_hdr(buf, P2P_PROV_DISC_RESP, dialog_token);
 252
 253         /* WPS IE with Config Methods attribute */
 254         p2p_build_wps_ie_config_methods(buf, config_methods);
 255
 256 #ifdef CONFIG_WIFI_DISPLAY
 257         if (wfd_ie)
 258                 wpabuf_put_buf(buf, wfd_ie);
 259 #endif /* CONFIG_WIFI_DISPLAY */
 260
 261         if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_PD_RESP])
 262                 wpabuf_put_buf(buf, p2p->vendor_elem[VENDOR_ELEM_P2P_PD_RESP]);
 263
 264         return buf;
 265 }
 266
 267
 268 void p2p_process_prov_disc_req(struct p2p_data *p2p, const u8 *sa,
 269                                const u8 *data, size_t len, int rx_freq)
 270 {
 271         struct p2p_message msg;
 272         struct p2p_device *dev;
 273         int freq;
 274         int reject = 1;
 275         struct wpabuf *resp;
 276
 277         if (p2p_parse(data, len, &msg))
 278                 return;
 279
 280         p2p_dbg(p2p, "Received Provision Discovery Request from " MACSTR
 281                 " with config methods 0x%x (freq=%d)",
 282                 MAC2STR(sa), msg.wps_config_methods, rx_freq);
 283
 284         dev = p2p_get_device(p2p, sa);
 285         if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
 286                 p2p_dbg(p2p, "Provision Discovery Request from unknown peer "
 287                         MACSTR, MAC2STR(sa));
 288
 289                 if (p2p_add_device(p2p, sa, rx_freq, NULL, 0, data + 1, len - 1,
 290                                    0)) {
 291                         p2p_dbg(p2p, "Provision Discovery Request add device failed "
 292                                 MACSTR, MAC2STR(sa));
 293                 }
 294         } else if (msg.wfd_subelems) {
 295                 wpabuf_free(dev->info.wfd_subelems);
 296                 dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems);
 297         }
 298
 299         if (!(msg.wps_config_methods &
 300               (WPS_CONFIG_DISPLAY | WPS_CONFIG_KEYPAD |
 301                WPS_CONFIG_PUSHBUTTON))) {
 302                 p2p_dbg(p2p, "Unsupported Config Methods in Provision Discovery Request");
 303                 goto out;
 304         }
 305
 306         if (msg.group_id) {
 307                 size_t i;
 308                 for (i = 0; i < p2p->num_groups; i++) {
 309                         if (p2p_group_is_group_id_match(p2p->groups[i],
 310                                                         msg.group_id,
 311                                                         msg.group_id_len))
 312                                 break;
 313                 }
 314                 if (i == p2p->num_groups) {
 315                         p2p_dbg(p2p, "PD request for unknown P2P Group ID - reject");
 316                         goto out;
 317                 }
 318         }
 319
 320         if (dev)
 321                 dev->flags &= ~(P2P_DEV_PD_PEER_DISPLAY |
 322                                 P2P_DEV_PD_PEER_KEYPAD);
 323         if (msg.wps_config_methods & WPS_CONFIG_DISPLAY) {
 324                 p2p_dbg(p2p, "Peer " MACSTR
 325                         " requested us to show a PIN on display", MAC2STR(sa));
 326                 if (dev)
 327                         dev->flags |= P2P_DEV_PD_PEER_KEYPAD;
 328         } else if (msg.wps_config_methods & WPS_CONFIG_KEYPAD) {
 329                 p2p_dbg(p2p, "Peer " MACSTR
 330                         " requested us to write its PIN using keypad",
 331                         MAC2STR(sa));
 332                 if (dev)
 333                         dev->flags |= P2P_DEV_PD_PEER_DISPLAY;
 334         }
 335
 336         reject = 0;
 337
 338 out:
 339         resp = p2p_build_prov_disc_resp(p2p, msg.dialog_token,
 340                                         reject ? 0 : msg.wps_config_methods,
 341                                         msg.group_id, msg.group_id_len);
 342         if (resp == NULL) {
 343                 p2p_parse_free(&msg);
 344                 return;
 345         }
 346         p2p_dbg(p2p, "Sending Provision Discovery Response");
 347         if (rx_freq > 0)
 348                 freq = rx_freq;
 349         else
 350                 freq = p2p_channel_to_freq(p2p->cfg->reg_class,
 351                                            p2p->cfg->channel);
 352         if (freq < 0) {
 353                 p2p_dbg(p2p, "Unknown regulatory class/channel");
 354                 wpabuf_free(resp);
 355                 p2p_parse_free(&msg);
 356                 return;
 357         }
 358         p2p->pending_action_state = P2P_NO_PENDING_ACTION;
 359         if (p2p_send_action(p2p, freq, sa, p2p->cfg->dev_addr,
 360                             p2p->cfg->dev_addr,
 361                             wpabuf_head(resp), wpabuf_len(resp), 200) < 0) {
 362                 p2p_dbg(p2p, "Failed to send Action frame");
 363         } else
 364                 p2p->send_action_in_progress = 1;
 365
 366         wpabuf_free(resp);
 367
 368         if (!reject && p2p->cfg->prov_disc_req) {
 369                 const u8 *dev_addr = sa;
 370                 if (msg.p2p_device_addr)
 371                         dev_addr = msg.p2p_device_addr;
 372                 p2p->cfg->prov_disc_req(p2p->cfg->cb_ctx, sa,
 373                                         msg.wps_config_methods,
 374                                         dev_addr, msg.pri_dev_type,
 375                                         msg.device_name, msg.config_methods,
 376                                         msg.capability ? msg.capability[0] : 0,
 377                                         msg.capability ? msg.capability[1] :
 378                                         0,
 379                                         msg.group_id, msg.group_id_len);
 380         }
 381         p2p_parse_free(&msg);
 382 }
 383
 384
 385 void p2p_process_prov_disc_resp(struct p2p_data *p2p, const u8 *sa,
 386                                 const u8 *data, size_t len)
 387 {
 388         struct p2p_message msg;
 389         struct p2p_device *dev;
 390         u16 report_config_methods = 0, req_config_methods;
 391         int success = 0;
 392
 393         if (p2p_parse(data, len, &msg))
 394                 return;
 395
 396         p2p_dbg(p2p, "Received Provision Discovery Response from " MACSTR
 397                 " with config methods 0x%x",
 398                 MAC2STR(sa), msg.wps_config_methods);
 399
 400         dev = p2p_get_device(p2p, sa);
 401         if (dev == NULL || !dev->req_config_methods) {
 402                 p2p_dbg(p2p, "Ignore Provision Discovery Response from " MACSTR
 403                         " with no pending request", MAC2STR(sa));
 404                 p2p_parse_free(&msg);
 405                 return;
 406         }
 407
 408         if (dev->dialog_token != msg.dialog_token) {
 409                 p2p_dbg(p2p, "Ignore Provision Discovery Response with unexpected Dialog Token %u (expected %u)",
 410                         msg.dialog_token, dev->dialog_token);
 411                 p2p_parse_free(&msg);
 412                 return;
 413         }
 414
 415         if (p2p->pending_action_state == P2P_PENDING_PD) {
 416                 os_memset(p2p->pending_pd_devaddr, 0, ETH_ALEN);
 417                 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
 418         }
 419
 420         /*
 421          * Use a local copy of the requested config methods since
 422          * p2p_reset_pending_pd() can clear this in the peer entry.
 423          */
 424         req_config_methods = dev->req_config_methods;
 425
 426         /*
 427          * If the response is from the peer to whom a user initiated request
 428          * was sent earlier, we reset that state info here.
 429          */
 430         if (p2p->user_initiated_pd &&
 431             os_memcmp(p2p->pending_pd_devaddr, sa, ETH_ALEN) == 0)
 432                 p2p_reset_pending_pd(p2p);
 433
 434         if (msg.wps_config_methods != req_config_methods) {
 435                 p2p_dbg(p2p, "Peer rejected our Provision Discovery Request (received config_methods 0x%x expected 0x%x",
 436                         msg.wps_config_methods, req_config_methods);
 437                 if (p2p->cfg->prov_disc_fail)
 438                         p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx, sa,
 439                                                  P2P_PROV_DISC_REJECTED);
 440                 p2p_parse_free(&msg);
 441                 goto out;
 442         }
 443
 444         report_config_methods = req_config_methods;
 445         dev->flags &= ~(P2P_DEV_PD_PEER_DISPLAY |
 446                         P2P_DEV_PD_PEER_KEYPAD);
 447         if (req_config_methods & WPS_CONFIG_DISPLAY) {
 448                 p2p_dbg(p2p, "Peer " MACSTR
 449                         " accepted to show a PIN on display", MAC2STR(sa));
 450                 dev->flags |= P2P_DEV_PD_PEER_DISPLAY;
 451         } else if (msg.wps_config_methods & WPS_CONFIG_KEYPAD) {
 452                 p2p_dbg(p2p, "Peer " MACSTR
 453                         " accepted to write our PIN using keypad",
 454                         MAC2STR(sa));
 455                 dev->flags |= P2P_DEV_PD_PEER_KEYPAD;
 456         }
 457
 458         /* Store the provisioning info */
 459         dev->wps_prov_info = msg.wps_config_methods;
 460
 461         p2p_parse_free(&msg);
 462         success = 1;
 463
 464 out:
 465         dev->req_config_methods = 0;
 466         p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
 467         if (dev->flags & P2P_DEV_PD_BEFORE_GO_NEG) {
 468                 p2p_dbg(p2p, "Start GO Neg after the PD-before-GO-Neg workaround with "
 469                         MACSTR, MAC2STR(dev->info.p2p_device_addr));
 470                 dev->flags &= ~P2P_DEV_PD_BEFORE_GO_NEG;
 471                 p2p_connect_send(p2p, dev);
 472                 return;
 473         }
 474         if (success && p2p->cfg->prov_disc_resp)
 475                 p2p->cfg->prov_disc_resp(p2p->cfg->cb_ctx, sa,
 476                                          report_config_methods);
 477
 478         if (p2p->state == P2P_PD_DURING_FIND) {
 479                 p2p_clear_timeout(p2p);
 480                 p2p_continue_find(p2p);
 481         }
 482 }
 483
 484
 485 int p2p_send_prov_disc_req(struct p2p_data *p2p, struct p2p_device *dev,
 486                            int join, int force_freq)
 487 {
 488         struct wpabuf *req;
 489         int freq;
 490
 491         if (force_freq > 0)
 492                 freq = force_freq;
 493         else
 494                 freq = dev->listen_freq > 0 ? dev->listen_freq :
 495                         dev->oper_freq;
 496         if (freq <= 0) {
 497                 p2p_dbg(p2p, "No Listen/Operating frequency known for the peer "
 498                         MACSTR " to send Provision Discovery Request",
 499                         MAC2STR(dev->info.p2p_device_addr));
 500                 return -1;
 501         }
 502
 503         if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) {
 504                 if (!(dev->info.dev_capab &
 505                       P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) {
 506                         p2p_dbg(p2p, "Cannot use PD with P2P Device " MACSTR
 507                                 " that is in a group and is not discoverable",
 508                                 MAC2STR(dev->info.p2p_device_addr));
 509                         return -1;
 510                 }
 511                 /* TODO: use device discoverability request through GO */
 512         }
 513
 514         if (p2p->p2ps_prov) {
 515                 if (p2p->p2ps_prov->status == P2P_SC_SUCCESS_DEFERRED) {
 516                         if (p2p->p2ps_prov->method == WPS_CONFIG_DISPLAY)
 517                                 dev->req_config_methods = WPS_CONFIG_KEYPAD;
 518                         else if (p2p->p2ps_prov->method == WPS_CONFIG_KEYPAD)
 519                                 dev->req_config_methods = WPS_CONFIG_DISPLAY;
 520                         else
 521                                 dev->req_config_methods = WPS_CONFIG_P2PS;
 522                 } else {
 523                         /* Order of preference, based on peer's capabilities */
 524                         if (p2p->p2ps_prov->method)
 525                                 dev->req_config_methods =
 526                                         p2p->p2ps_prov->method;
 527                         else if (dev->info.config_methods & WPS_CONFIG_P2PS)
 528                                 dev->req_config_methods = WPS_CONFIG_P2PS;
 529                         else if (dev->info.config_methods & WPS_CONFIG_DISPLAY)
 530                                 dev->req_config_methods = WPS_CONFIG_DISPLAY;
 531                         else
 532                                 dev->req_config_methods = WPS_CONFIG_KEYPAD;
 533                 }
 534                 p2p_dbg(p2p,
 535                         "Building PD Request based on P2PS config method 0x%x status %d --> req_config_methods 0x%x",
 536                         p2p->p2ps_prov->method, p2p->p2ps_prov->status,
 537                         dev->req_config_methods);
 538         }
 539
 540         req = p2p_build_prov_disc_req(p2p, dev, join);
 541         if (req == NULL)
 542                 return -1;
 543
 544         if (p2p->state != P2P_IDLE)
 545                 p2p_stop_listen_for_freq(p2p, freq);
 546         p2p->pending_action_state = P2P_PENDING_PD;
 547         if (p2p_send_action(p2p, freq, dev->info.p2p_device_addr,
 548                             p2p->cfg->dev_addr, dev->info.p2p_device_addr,
 549                             wpabuf_head(req), wpabuf_len(req), 200) < 0) {
 550                 p2p_dbg(p2p, "Failed to send Action frame");
 551                 wpabuf_free(req);
 552                 return -1;
 553         }
 554
 555         os_memcpy(p2p->pending_pd_devaddr, dev->info.p2p_device_addr, ETH_ALEN);
 556
 557         wpabuf_free(req);
 558         return 0;
 559 }
 560
 561
 562 int p2p_prov_disc_req(struct p2p_data *p2p, const u8 *peer_addr,
 563                       struct p2ps_provision *p2ps_prov,
 564                       u16 config_methods, int join, int force_freq,
 565                       int user_initiated_pd)
 566 {
 567         struct p2p_device *dev;
 568
 569         dev = p2p_get_device(p2p, peer_addr);
 570         if (dev == NULL)
 571                 dev = p2p_get_device_interface(p2p, peer_addr);
 572         if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
 573                 p2p_dbg(p2p, "Provision Discovery Request destination " MACSTR
 574                         " not yet known", MAC2STR(peer_addr));
 575                 os_free(p2ps_prov);
 576                 return -1;
 577         }
 578
 579         p2p_dbg(p2p, "Provision Discovery Request with " MACSTR
 580                 " (config methods 0x%x)",
 581                 MAC2STR(peer_addr), config_methods);
 582         if (config_methods == 0 && !p2ps_prov) {
 583                 os_free(p2ps_prov);
 584                 return -1;
 585         }
 586
 587         if (p2ps_prov && p2ps_prov->status == P2P_SC_SUCCESS_DEFERRED &&
 588             p2p->p2ps_prov) {
 589                 /* Use cached method from deferred provisioning */
 590                 p2ps_prov->method = p2p->p2ps_prov->method;
 591         }
 592
 593         /* Reset provisioning info */
 594         dev->wps_prov_info = 0;
 595         os_free(p2p->p2ps_prov);
 596         p2p->p2ps_prov = p2ps_prov;
 597
 598         dev->req_config_methods = config_methods;
 599         if (join)
 600                 dev->flags |= P2P_DEV_PD_FOR_JOIN;
 601         else
 602                 dev->flags &= ~P2P_DEV_PD_FOR_JOIN;
 603
 604         if (p2p->state != P2P_IDLE && p2p->state != P2P_SEARCH &&
 605             p2p->state != P2P_LISTEN_ONLY) {
 606                 p2p_dbg(p2p, "Busy with other operations; postpone Provision Discovery Request with "
 607                         MACSTR " (config methods 0x%x)",
 608                         MAC2STR(peer_addr), config_methods);
 609                 return 0;
 610         }
 611
 612         p2p->user_initiated_pd = user_initiated_pd;
 613         p2p->pd_force_freq = force_freq;
 614
 615         if (p2p->user_initiated_pd)
 616                 p2p->pd_retries = MAX_PROV_DISC_REQ_RETRIES;
 617
 618         /*
 619          * Assign dialog token here to use the same value in each retry within
 620          * the same PD exchange.
 621          */
 622         dev->dialog_token++;
 623         if (dev->dialog_token == 0)
 624                 dev->dialog_token = 1;
 625
 626         return p2p_send_prov_disc_req(p2p, dev, join, force_freq);
 627 }
 628
 629
 630 void p2p_reset_pending_pd(struct p2p_data *p2p)
 631 {
 632         struct p2p_device *dev;
 633
 634         dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
 635                 if (os_memcmp(p2p->pending_pd_devaddr,
 636                               dev->info.p2p_device_addr, ETH_ALEN))
 637                         continue;
 638                 if (!dev->req_config_methods)
 639                         continue;
 640                 if (dev->flags & P2P_DEV_PD_FOR_JOIN)
 641                         continue;
 642                 /* Reset the config methods of the device */
 643                 dev->req_config_methods = 0;
 644         }
 645
 646         p2p->user_initiated_pd = 0;
 647         os_memset(p2p->pending_pd_devaddr, 0, ETH_ALEN);
 648         p2p->pd_retries = 0;
 649         p2p->pd_force_freq = 0;
 650 }