contrib/hostapd/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 "wps/wps_defs.h"
  14 #include "p2p_i.h"
  15 #include "p2p.h"
  16
  17
  18 /*
  19  * Number of retries to attempt for provision discovery requests
  20  * in case the peer is not listening.
  21  */
  22 #define MAX_PROV_DISC_REQ_RETRIES 120
  23
  24
  25 static void p2p_build_wps_ie_config_methods(struct wpabuf *buf,
  26                                             u16 config_methods)
  27 {
  28         u8 *len;
  29         wpabuf_put_u8(buf, WLAN_EID_VENDOR_SPECIFIC);
  30         len = wpabuf_put(buf, 1);
  31         wpabuf_put_be32(buf, WPS_DEV_OUI_WFA);
  32
  33         /* Config Methods */
  34         wpabuf_put_be16(buf, ATTR_CONFIG_METHODS);
  35         wpabuf_put_be16(buf, 2);
  36         wpabuf_put_be16(buf, config_methods);
  37
  38         p2p_buf_update_ie_hdr(buf, len);
  39 }
  40
  41
  42 static struct wpabuf * p2p_build_prov_disc_req(struct p2p_data *p2p,
  43                                                u8 dialog_token,
  44                                                u16 config_methods,
  45                                                struct p2p_device *go)
  46 {
  47         struct wpabuf *buf;
  48         u8 *len;
  49         size_t extra = 0;
  50
  51 #ifdef CONFIG_WIFI_DISPLAY
  52         if (p2p->wfd_ie_prov_disc_req)
  53                 extra = wpabuf_len(p2p->wfd_ie_prov_disc_req);
  54 #endif /* CONFIG_WIFI_DISPLAY */
  55
  56         buf = wpabuf_alloc(1000 + extra);
  57         if (buf == NULL)
  58                 return NULL;
  59
  60         p2p_buf_add_public_action_hdr(buf, P2P_PROV_DISC_REQ, dialog_token);
  61
  62         len = p2p_buf_add_ie_hdr(buf);
  63         p2p_buf_add_capability(buf, p2p->dev_capab &
  64                                ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY, 0);
  65         p2p_buf_add_device_info(buf, p2p, NULL);
  66         if (go) {
  67                 p2p_buf_add_group_id(buf, go->info.p2p_device_addr,
  68                                      go->oper_ssid, go->oper_ssid_len);
  69         }
  70         p2p_buf_update_ie_hdr(buf, len);
  71
  72         /* WPS IE with Config Methods attribute */
  73         p2p_build_wps_ie_config_methods(buf, config_methods);
  74
  75 #ifdef CONFIG_WIFI_DISPLAY
  76         if (p2p->wfd_ie_prov_disc_req)
  77                 wpabuf_put_buf(buf, p2p->wfd_ie_prov_disc_req);
  78 #endif /* CONFIG_WIFI_DISPLAY */
  79
  80         return buf;
  81 }
  82
  83
  84 static struct wpabuf * p2p_build_prov_disc_resp(struct p2p_data *p2p,
  85                                                 u8 dialog_token,
  86                                                 u16 config_methods,
  87                                                 const u8 *group_id,
  88                                                 size_t group_id_len)
  89 {
  90         struct wpabuf *buf;
  91         size_t extra = 0;
  92
  93 #ifdef CONFIG_WIFI_DISPLAY
  94         struct wpabuf *wfd_ie = p2p->wfd_ie_prov_disc_resp;
  95         if (wfd_ie && group_id) {
  96                 size_t i;
  97                 for (i = 0; i < p2p->num_groups; i++) {
  98                         struct p2p_group *g = p2p->groups[i];
  99                         struct wpabuf *ie;
 100                         if (!p2p_group_is_group_id_match(g, group_id,
 101                                                          group_id_len))
 102                                 continue;
 103                         ie = p2p_group_get_wfd_ie(g);
 104                         if (ie) {
 105                                 wfd_ie = ie;
 106                                 break;
 107                         }
 108                 }
 109         }
 110         if (wfd_ie)
 111                 extra = wpabuf_len(wfd_ie);
 112 #endif /* CONFIG_WIFI_DISPLAY */
 113
 114         buf = wpabuf_alloc(100 + extra);
 115         if (buf == NULL)
 116                 return NULL;
 117
 118         p2p_buf_add_public_action_hdr(buf, P2P_PROV_DISC_RESP, dialog_token);
 119
 120         /* WPS IE with Config Methods attribute */
 121         p2p_build_wps_ie_config_methods(buf, config_methods);
 122
 123 #ifdef CONFIG_WIFI_DISPLAY
 124         if (wfd_ie)
 125                 wpabuf_put_buf(buf, wfd_ie);
 126 #endif /* CONFIG_WIFI_DISPLAY */
 127
 128         return buf;
 129 }
 130
 131
 132 void p2p_process_prov_disc_req(struct p2p_data *p2p, const u8 *sa,
 133                                const u8 *data, size_t len, int rx_freq)
 134 {
 135         struct p2p_message msg;
 136         struct p2p_device *dev;
 137         int freq;
 138         int reject = 1;
 139         struct wpabuf *resp;
 140
 141         if (p2p_parse(data, len, &msg))
 142                 return;
 143
 144         p2p_dbg(p2p, "Received Provision Discovery Request from " MACSTR
 145                 " with config methods 0x%x (freq=%d)",
 146                 MAC2STR(sa), msg.wps_config_methods, rx_freq);
 147
 148         dev = p2p_get_device(p2p, sa);
 149         if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
 150                 p2p_dbg(p2p, "Provision Discovery Request from unknown peer "
 151                         MACSTR, MAC2STR(sa));
 152
 153                 if (p2p_add_device(p2p, sa, rx_freq, NULL, 0, data + 1, len - 1,
 154                                    0)) {
 155                         p2p_dbg(p2p, "Provision Discovery Request add device failed "
 156                                 MACSTR, MAC2STR(sa));
 157                 }
 158         } else if (msg.wfd_subelems) {
 159                 wpabuf_free(dev->info.wfd_subelems);
 160                 dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems);
 161         }
 162
 163         if (!(msg.wps_config_methods &
 164               (WPS_CONFIG_DISPLAY | WPS_CONFIG_KEYPAD |
 165                WPS_CONFIG_PUSHBUTTON))) {
 166                 p2p_dbg(p2p, "Unsupported Config Methods in Provision Discovery Request");
 167                 goto out;
 168         }
 169
 170         if (msg.group_id) {
 171                 size_t i;
 172                 for (i = 0; i < p2p->num_groups; i++) {
 173                         if (p2p_group_is_group_id_match(p2p->groups[i],
 174                                                         msg.group_id,
 175                                                         msg.group_id_len))
 176                                 break;
 177                 }
 178                 if (i == p2p->num_groups) {
 179                         p2p_dbg(p2p, "PD request for unknown P2P Group ID - reject");
 180                         goto out;
 181                 }
 182         }
 183
 184         if (dev)
 185                 dev->flags &= ~(P2P_DEV_PD_PEER_DISPLAY |
 186                                 P2P_DEV_PD_PEER_KEYPAD);
 187         if (msg.wps_config_methods & WPS_CONFIG_DISPLAY) {
 188                 p2p_dbg(p2p, "Peer " MACSTR
 189                         " requested us to show a PIN on display", MAC2STR(sa));
 190                 if (dev)
 191                         dev->flags |= P2P_DEV_PD_PEER_KEYPAD;
 192         } else if (msg.wps_config_methods & WPS_CONFIG_KEYPAD) {
 193                 p2p_dbg(p2p, "Peer " MACSTR
 194                         " requested us to write its PIN using keypad",
 195                         MAC2STR(sa));
 196                 if (dev)
 197                         dev->flags |= P2P_DEV_PD_PEER_DISPLAY;
 198         }
 199
 200         reject = 0;
 201
 202 out:
 203         resp = p2p_build_prov_disc_resp(p2p, msg.dialog_token,
 204                                         reject ? 0 : msg.wps_config_methods,
 205                                         msg.group_id, msg.group_id_len);
 206         if (resp == NULL) {
 207                 p2p_parse_free(&msg);
 208                 return;
 209         }
 210         p2p_dbg(p2p, "Sending Provision Discovery Response");
 211         if (rx_freq > 0)
 212                 freq = rx_freq;
 213         else
 214                 freq = p2p_channel_to_freq(p2p->cfg->reg_class,
 215                                            p2p->cfg->channel);
 216         if (freq < 0) {
 217                 p2p_dbg(p2p, "Unknown regulatory class/channel");
 218                 wpabuf_free(resp);
 219                 p2p_parse_free(&msg);
 220                 return;
 221         }
 222         p2p->pending_action_state = P2P_NO_PENDING_ACTION;
 223         if (p2p_send_action(p2p, freq, sa, p2p->cfg->dev_addr,
 224                             p2p->cfg->dev_addr,
 225                             wpabuf_head(resp), wpabuf_len(resp), 200) < 0) {
 226                 p2p_dbg(p2p, "Failed to send Action frame");
 227         }
 228
 229         wpabuf_free(resp);
 230
 231         if (!reject && p2p->cfg->prov_disc_req) {
 232                 const u8 *dev_addr = sa;
 233                 if (msg.p2p_device_addr)
 234                         dev_addr = msg.p2p_device_addr;
 235                 p2p->cfg->prov_disc_req(p2p->cfg->cb_ctx, sa,
 236                                         msg.wps_config_methods,
 237                                         dev_addr, msg.pri_dev_type,
 238                                         msg.device_name, msg.config_methods,
 239                                         msg.capability ? msg.capability[0] : 0,
 240                                         msg.capability ? msg.capability[1] :
 241                                         0,
 242                                         msg.group_id, msg.group_id_len);
 243         }
 244         p2p_parse_free(&msg);
 245 }
 246
 247
 248 void p2p_process_prov_disc_resp(struct p2p_data *p2p, const u8 *sa,
 249                                 const u8 *data, size_t len)
 250 {
 251         struct p2p_message msg;
 252         struct p2p_device *dev;
 253         u16 report_config_methods = 0, req_config_methods;
 254         int success = 0;
 255
 256         if (p2p_parse(data, len, &msg))
 257                 return;
 258
 259         p2p_dbg(p2p, "Received Provision Discovery Response from " MACSTR
 260                 " with config methods 0x%x",
 261                 MAC2STR(sa), msg.wps_config_methods);
 262
 263         dev = p2p_get_device(p2p, sa);
 264         if (dev == NULL || !dev->req_config_methods) {
 265                 p2p_dbg(p2p, "Ignore Provision Discovery Response from " MACSTR
 266                         " with no pending request", MAC2STR(sa));
 267                 p2p_parse_free(&msg);
 268                 return;
 269         }
 270
 271         if (dev->dialog_token != msg.dialog_token) {
 272                 p2p_dbg(p2p, "Ignore Provision Discovery Response with unexpected Dialog Token %u (expected %u)",
 273                         msg.dialog_token, dev->dialog_token);
 274                 p2p_parse_free(&msg);
 275                 return;
 276         }
 277
 278         if (p2p->pending_action_state == P2P_PENDING_PD) {
 279                 os_memset(p2p->pending_pd_devaddr, 0, ETH_ALEN);
 280                 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
 281         }
 282
 283         /*
 284          * Use a local copy of the requested config methods since
 285          * p2p_reset_pending_pd() can clear this in the peer entry.
 286          */
 287         req_config_methods = dev->req_config_methods;
 288
 289         /*
 290          * If the response is from the peer to whom a user initiated request
 291          * was sent earlier, we reset that state info here.
 292          */
 293         if (p2p->user_initiated_pd &&
 294             os_memcmp(p2p->pending_pd_devaddr, sa, ETH_ALEN) == 0)
 295                 p2p_reset_pending_pd(p2p);
 296
 297         if (msg.wps_config_methods != req_config_methods) {
 298                 p2p_dbg(p2p, "Peer rejected our Provision Discovery Request (received config_methods 0x%x expected 0x%x",
 299                         msg.wps_config_methods, req_config_methods);
 300                 if (p2p->cfg->prov_disc_fail)
 301                         p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx, sa,
 302                                                  P2P_PROV_DISC_REJECTED);
 303                 p2p_parse_free(&msg);
 304                 goto out;
 305         }
 306
 307         report_config_methods = req_config_methods;
 308         dev->flags &= ~(P2P_DEV_PD_PEER_DISPLAY |
 309                         P2P_DEV_PD_PEER_KEYPAD);
 310         if (req_config_methods & WPS_CONFIG_DISPLAY) {
 311                 p2p_dbg(p2p, "Peer " MACSTR
 312                         " accepted to show a PIN on display", MAC2STR(sa));
 313                 dev->flags |= P2P_DEV_PD_PEER_DISPLAY;
 314         } else if (msg.wps_config_methods & WPS_CONFIG_KEYPAD) {
 315                 p2p_dbg(p2p, "Peer " MACSTR
 316                         " accepted to write our PIN using keypad",
 317                         MAC2STR(sa));
 318                 dev->flags |= P2P_DEV_PD_PEER_KEYPAD;
 319         }
 320
 321         /* Store the provisioning info */
 322         dev->wps_prov_info = msg.wps_config_methods;
 323
 324         p2p_parse_free(&msg);
 325         success = 1;
 326
 327 out:
 328         dev->req_config_methods = 0;
 329         p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
 330         if (dev->flags & P2P_DEV_PD_BEFORE_GO_NEG) {
 331                 p2p_dbg(p2p, "Start GO Neg after the PD-before-GO-Neg workaround with "
 332                         MACSTR, MAC2STR(dev->info.p2p_device_addr));
 333                 dev->flags &= ~P2P_DEV_PD_BEFORE_GO_NEG;
 334                 p2p_connect_send(p2p, dev);
 335                 return;
 336         }
 337         if (success && p2p->cfg->prov_disc_resp)
 338                 p2p->cfg->prov_disc_resp(p2p->cfg->cb_ctx, sa,
 339                                          report_config_methods);
 340
 341         if (p2p->state == P2P_PD_DURING_FIND) {
 342                 p2p_clear_timeout(p2p);
 343                 p2p_continue_find(p2p);
 344         }
 345 }
 346
 347
 348 int p2p_send_prov_disc_req(struct p2p_data *p2p, struct p2p_device *dev,
 349                            int join, int force_freq)
 350 {
 351         struct wpabuf *req;
 352         int freq;
 353
 354         if (force_freq > 0)
 355                 freq = force_freq;
 356         else
 357                 freq = dev->listen_freq > 0 ? dev->listen_freq :
 358                         dev->oper_freq;
 359         if (freq <= 0) {
 360                 p2p_dbg(p2p, "No Listen/Operating frequency known for the peer "
 361                         MACSTR " to send Provision Discovery Request",
 362                         MAC2STR(dev->info.p2p_device_addr));
 363                 return -1;
 364         }
 365
 366         if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) {
 367                 if (!(dev->info.dev_capab &
 368                       P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) {
 369                         p2p_dbg(p2p, "Cannot use PD with P2P Device " MACSTR
 370                                 " that is in a group and is not discoverable",
 371                                 MAC2STR(dev->info.p2p_device_addr));
 372                         return -1;
 373                 }
 374                 /* TODO: use device discoverability request through GO */
 375         }
 376
 377         req = p2p_build_prov_disc_req(p2p, dev->dialog_token,
 378                                       dev->req_config_methods,
 379                                       join ? dev : NULL);
 380         if (req == NULL)
 381                 return -1;
 382
 383         if (p2p->state != P2P_IDLE)
 384                 p2p_stop_listen_for_freq(p2p, freq);
 385         p2p->pending_action_state = P2P_PENDING_PD;
 386         if (p2p_send_action(p2p, freq, dev->info.p2p_device_addr,
 387                             p2p->cfg->dev_addr, dev->info.p2p_device_addr,
 388                             wpabuf_head(req), wpabuf_len(req), 200) < 0) {
 389                 p2p_dbg(p2p, "Failed to send Action frame");
 390                 wpabuf_free(req);
 391                 return -1;
 392         }
 393
 394         os_memcpy(p2p->pending_pd_devaddr, dev->info.p2p_device_addr, ETH_ALEN);
 395
 396         wpabuf_free(req);
 397         return 0;
 398 }
 399
 400
 401 int p2p_prov_disc_req(struct p2p_data *p2p, const u8 *peer_addr,
 402                       u16 config_methods, int join, int force_freq,
 403                       int user_initiated_pd)
 404 {
 405         struct p2p_device *dev;
 406
 407         dev = p2p_get_device(p2p, peer_addr);
 408         if (dev == NULL)
 409                 dev = p2p_get_device_interface(p2p, peer_addr);
 410         if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
 411                 p2p_dbg(p2p, "Provision Discovery Request destination " MACSTR
 412                         " not yet known", MAC2STR(peer_addr));
 413                 return -1;
 414         }
 415
 416         p2p_dbg(p2p, "Provision Discovery Request with " MACSTR
 417                 " (config methods 0x%x)",
 418                 MAC2STR(peer_addr), config_methods);
 419         if (config_methods == 0)
 420                 return -1;
 421
 422         /* Reset provisioning info */
 423         dev->wps_prov_info = 0;
 424
 425         dev->req_config_methods = config_methods;
 426         if (join)
 427                 dev->flags |= P2P_DEV_PD_FOR_JOIN;
 428         else
 429                 dev->flags &= ~P2P_DEV_PD_FOR_JOIN;
 430
 431         if (p2p->state != P2P_IDLE && p2p->state != P2P_SEARCH &&
 432             p2p->state != P2P_LISTEN_ONLY) {
 433                 p2p_dbg(p2p, "Busy with other operations; postpone Provision Discovery Request with "
 434                         MACSTR " (config methods 0x%x)",
 435                         MAC2STR(peer_addr), config_methods);
 436                 return 0;
 437         }
 438
 439         p2p->user_initiated_pd = user_initiated_pd;
 440         p2p->pd_force_freq = force_freq;
 441
 442         if (p2p->user_initiated_pd)
 443                 p2p->pd_retries = MAX_PROV_DISC_REQ_RETRIES;
 444
 445         /*
 446          * Assign dialog token here to use the same value in each retry within
 447          * the same PD exchange.
 448          */
 449         dev->dialog_token++;
 450         if (dev->dialog_token == 0)
 451                 dev->dialog_token = 1;
 452
 453         return p2p_send_prov_disc_req(p2p, dev, join, force_freq);
 454 }
 455
 456
 457 void p2p_reset_pending_pd(struct p2p_data *p2p)
 458 {
 459         struct p2p_device *dev;
 460
 461         dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
 462                 if (os_memcmp(p2p->pending_pd_devaddr,
 463                               dev->info.p2p_device_addr, ETH_ALEN))
 464                         continue;
 465                 if (!dev->req_config_methods)
 466                         continue;
 467                 if (dev->flags & P2P_DEV_PD_FOR_JOIN)
 468                         continue;
 469                 /* Reset the config methods of the device */
 470                 dev->req_config_methods = 0;
 471         }
 472
 473         p2p->user_initiated_pd = 0;
 474         os_memset(p2p->pending_pd_devaddr, 0, ETH_ALEN);
 475         p2p->pd_retries = 0;
 476         p2p->pd_force_freq = 0;
 477 }