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