src/p2p/p2p.c

   1 /*
   2  * Wi-Fi Direct - P2P module
   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 "eloop.h"
  13 #include "common/ieee802_11_defs.h"
  14 #include "common/ieee802_11_common.h"
  15 #include "common/wpa_ctrl.h"
  16 #include "wps/wps_i.h"
  17 #include "p2p_i.h"
  18 #include "p2p.h"
  19
  20
  21 static void p2p_state_timeout(void *eloop_ctx, void *timeout_ctx);
  22 static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev);
  23 static void p2p_process_presence_req(struct p2p_data *p2p, const u8 *da,
  24                                      const u8 *sa, const u8 *data, size_t len,
  25                                      int rx_freq);
  26 static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da,
  27                                       const u8 *sa, const u8 *data,
  28                                       size_t len);
  29 static void p2p_ext_listen_timeout(void *eloop_ctx, void *timeout_ctx);
  30 static void p2p_scan_timeout(void *eloop_ctx, void *timeout_ctx);
  31
  32
  33 /*
  34  * p2p_scan recovery timeout
  35  *
  36  * Many drivers are using 30 second timeout on scan results. Allow a bit larger
  37  * timeout for this to avoid hitting P2P timeout unnecessarily.
  38  */
  39 #define P2P_SCAN_TIMEOUT 35
  40
  41 /**
  42  * P2P_PEER_EXPIRATION_AGE - Number of seconds after which inactive peer
  43  * entries will be removed
  44  */
  45 #define P2P_PEER_EXPIRATION_AGE 300
  46
  47 #define P2P_PEER_EXPIRATION_INTERVAL (P2P_PEER_EXPIRATION_AGE / 2)
  48
  49 static void p2p_expire_peers(struct p2p_data *p2p)
  50 {
  51         struct p2p_device *dev, *n;
  52         struct os_time now;
  53         size_t i;
  54
  55         os_get_time(&now);
  56         dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) {
  57                 if (dev->last_seen.sec + P2P_PEER_EXPIRATION_AGE >= now.sec)
  58                         continue;
  59
  60                 if (p2p->cfg->go_connected &&
  61                     p2p->cfg->go_connected(p2p->cfg->cb_ctx,
  62                                            dev->info.p2p_device_addr)) {
  63                         /*
  64                          * We are connected as a client to a group in which the
  65                          * peer is the GO, so do not expire the peer entry.
  66                          */
  67                         os_get_time(&dev->last_seen);
  68                         continue;
  69                 }
  70
  71                 for (i = 0; i < p2p->num_groups; i++) {
  72                         if (p2p_group_is_client_connected(
  73                                     p2p->groups[i], dev->info.p2p_device_addr))
  74                                 break;
  75                 }
  76                 if (i < p2p->num_groups) {
  77                         /*
  78                          * The peer is connected as a client in a group where
  79                          * we are the GO, so do not expire the peer entry.
  80                          */
  81                         os_get_time(&dev->last_seen);
  82                         continue;
  83                 }
  84
  85                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Expiring old peer "
  86                         "entry " MACSTR, MAC2STR(dev->info.p2p_device_addr));
  87                 dl_list_del(&dev->list);
  88                 p2p_device_free(p2p, dev);
  89         }
  90 }
  91
  92
  93 static void p2p_expiration_timeout(void *eloop_ctx, void *timeout_ctx)
  94 {
  95         struct p2p_data *p2p = eloop_ctx;
  96         p2p_expire_peers(p2p);
  97         eloop_register_timeout(P2P_PEER_EXPIRATION_INTERVAL, 0,
  98                                p2p_expiration_timeout, p2p, NULL);
  99 }
 100
 101
 102 static const char * p2p_state_txt(int state)
 103 {
 104         switch (state) {
 105         case P2P_IDLE:
 106                 return "IDLE";
 107         case P2P_SEARCH:
 108                 return "SEARCH";
 109         case P2P_CONNECT:
 110                 return "CONNECT";
 111         case P2P_CONNECT_LISTEN:
 112                 return "CONNECT_LISTEN";
 113         case P2P_GO_NEG:
 114                 return "GO_NEG";
 115         case P2P_LISTEN_ONLY:
 116                 return "LISTEN_ONLY";
 117         case P2P_WAIT_PEER_CONNECT:
 118                 return "WAIT_PEER_CONNECT";
 119         case P2P_WAIT_PEER_IDLE:
 120                 return "WAIT_PEER_IDLE";
 121         case P2P_SD_DURING_FIND:
 122                 return "SD_DURING_FIND";
 123         case P2P_PROVISIONING:
 124                 return "PROVISIONING";
 125         case P2P_PD_DURING_FIND:
 126                 return "PD_DURING_FIND";
 127         case P2P_INVITE:
 128                 return "INVITE";
 129         case P2P_INVITE_LISTEN:
 130                 return "INVITE_LISTEN";
 131         case P2P_SEARCH_WHEN_READY:
 132                 return "SEARCH_WHEN_READY";
 133         default:
 134                 return "?";
 135         }
 136 }
 137
 138
 139 u16 p2p_get_provisioning_info(struct p2p_data *p2p, const u8 *addr)
 140 {
 141         struct p2p_device *dev = NULL;
 142
 143         if (!addr || !p2p)
 144                 return 0;
 145
 146         dev = p2p_get_device(p2p, addr);
 147         if (dev)
 148                 return dev->wps_prov_info;
 149         else
 150                 return 0;
 151 }
 152
 153
 154 void p2p_clear_provisioning_info(struct p2p_data *p2p, const u8 *addr)
 155 {
 156         struct p2p_device *dev = NULL;
 157
 158         if (!addr || !p2p)
 159                 return;
 160
 161         dev = p2p_get_device(p2p, addr);
 162         if (dev)
 163                 dev->wps_prov_info = 0;
 164 }
 165
 166
 167 void p2p_set_state(struct p2p_data *p2p, int new_state)
 168 {
 169         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: State %s -> %s",
 170                 p2p_state_txt(p2p->state), p2p_state_txt(new_state));
 171         p2p->state = new_state;
 172 }
 173
 174
 175 void p2p_set_timeout(struct p2p_data *p2p, unsigned int sec, unsigned int usec)
 176 {
 177         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
 178                 "P2P: Set timeout (state=%s): %u.%06u sec",
 179                 p2p_state_txt(p2p->state), sec, usec);
 180         eloop_cancel_timeout(p2p_state_timeout, p2p, NULL);
 181         eloop_register_timeout(sec, usec, p2p_state_timeout, p2p, NULL);
 182 }
 183
 184
 185 void p2p_clear_timeout(struct p2p_data *p2p)
 186 {
 187         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Clear timeout (state=%s)",
 188                 p2p_state_txt(p2p->state));
 189         eloop_cancel_timeout(p2p_state_timeout, p2p, NULL);
 190 }
 191
 192
 193 void p2p_go_neg_failed(struct p2p_data *p2p, struct p2p_device *peer,
 194                        int status)
 195 {
 196         struct p2p_go_neg_results res;
 197         p2p_clear_timeout(p2p);
 198         p2p_set_state(p2p, P2P_IDLE);
 199         if (p2p->go_neg_peer)
 200                 p2p->go_neg_peer->wps_method = WPS_NOT_READY;
 201         p2p->go_neg_peer = NULL;
 202
 203         os_memset(&res, 0, sizeof(res));
 204         res.status = status;
 205         if (peer) {
 206                 os_memcpy(res.peer_device_addr, peer->info.p2p_device_addr,
 207                           ETH_ALEN);
 208                 os_memcpy(res.peer_interface_addr, peer->intended_addr,
 209                           ETH_ALEN);
 210         }
 211         p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res);
 212 }
 213
 214
 215 static void p2p_listen_in_find(struct p2p_data *p2p)
 216 {
 217         unsigned int r, tu;
 218         int freq;
 219         struct wpabuf *ies;
 220
 221         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
 222                 "P2P: Starting short listen state (state=%s)",
 223                 p2p_state_txt(p2p->state));
 224
 225         freq = p2p_channel_to_freq(p2p->cfg->country, p2p->cfg->reg_class,
 226                                    p2p->cfg->channel);
 227         if (freq < 0) {
 228                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
 229                         "P2P: Unknown regulatory class/channel");
 230                 return;
 231         }
 232
 233         os_get_random((u8 *) &r, sizeof(r));
 234         tu = (r % ((p2p->max_disc_int - p2p->min_disc_int) + 1) +
 235               p2p->min_disc_int) * 100;
 236
 237         p2p->pending_listen_freq = freq;
 238         p2p->pending_listen_sec = 0;
 239         p2p->pending_listen_usec = 1024 * tu;
 240
 241         ies = p2p_build_probe_resp_ies(p2p);
 242         if (ies == NULL)
 243                 return;
 244
 245         if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, 1024 * tu / 1000,
 246                     ies) < 0) {
 247                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
 248                         "P2P: Failed to start listen mode");
 249                 p2p->pending_listen_freq = 0;
 250         }
 251         wpabuf_free(ies);
 252 }
 253
 254
 255 int p2p_listen(struct p2p_data *p2p, unsigned int timeout)
 256 {
 257         int freq;
 258         struct wpabuf *ies;
 259
 260         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
 261                 "P2P: Going to listen(only) state");
 262
 263         freq = p2p_channel_to_freq(p2p->cfg->country, p2p->cfg->reg_class,
 264                                    p2p->cfg->channel);
 265         if (freq < 0) {
 266                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
 267                         "P2P: Unknown regulatory class/channel");
 268                 return -1;
 269         }
 270
 271         p2p->pending_listen_freq = freq;
 272         p2p->pending_listen_sec = timeout / 1000;
 273         p2p->pending_listen_usec = (timeout % 1000) * 1000;
 274
 275         if (p2p->p2p_scan_running) {
 276                 if (p2p->start_after_scan == P2P_AFTER_SCAN_CONNECT) {
 277                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
 278                                 "P2P: p2p_scan running - connect is already "
 279                                 "pending - skip listen");
 280                         return 0;
 281                 }
 282                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
 283                         "P2P: p2p_scan running - delay start of listen state");
 284                 p2p->start_after_scan = P2P_AFTER_SCAN_LISTEN;
 285                 return 0;
 286         }
 287
 288         ies = p2p_build_probe_resp_ies(p2p);
 289         if (ies == NULL)
 290                 return -1;
 291
 292         if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, timeout, ies) < 0) {
 293                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
 294                         "P2P: Failed to start listen mode");
 295                 p2p->pending_listen_freq = 0;
 296                 wpabuf_free(ies);
 297                 return -1;
 298         }
 299         wpabuf_free(ies);
 300
 301         p2p_set_state(p2p, P2P_LISTEN_ONLY);
 302
 303         return 0;
 304 }
 305
 306
 307 static void p2p_device_clear_reported(struct p2p_data *p2p)
 308 {
 309         struct p2p_device *dev;
 310         dl_list_for_each(dev, &p2p->devices, struct p2p_device, list)
 311                 dev->flags &= ~P2P_DEV_REPORTED;
 312 }
 313
 314
 315 /**
 316  * p2p_get_device - Fetch a peer entry
 317  * @p2p: P2P module context from p2p_init()
 318  * @addr: P2P Device Address of the peer
 319  * Returns: Pointer to the device entry or %NULL if not found
 320  */
 321 struct p2p_device * p2p_get_device(struct p2p_data *p2p, const u8 *addr)
 322 {
 323         struct p2p_device *dev;
 324         dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
 325                 if (os_memcmp(dev->info.p2p_device_addr, addr, ETH_ALEN) == 0)
 326                         return dev;
 327         }
 328         return NULL;
 329 }
 330
 331
 332 /**
 333  * p2p_get_device_interface - Fetch a peer entry based on P2P Interface Address
 334  * @p2p: P2P module context from p2p_init()
 335  * @addr: P2P Interface Address of the peer
 336  * Returns: Pointer to the device entry or %NULL if not found
 337  */
 338 struct p2p_device * p2p_get_device_interface(struct p2p_data *p2p,
 339                                              const u8 *addr)
 340 {
 341         struct p2p_device *dev;
 342         dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
 343                 if (os_memcmp(dev->interface_addr, addr, ETH_ALEN) == 0)
 344                         return dev;
 345         }
 346         return NULL;
 347 }
 348
 349
 350 /**
 351  * p2p_create_device - Create a peer entry
 352  * @p2p: P2P module context from p2p_init()
 353  * @addr: P2P Device Address of the peer
 354  * Returns: Pointer to the device entry or %NULL on failure
 355  *
 356  * If there is already an entry for the peer, it will be returned instead of
 357  * creating a new one.
 358  */
 359 static struct p2p_device * p2p_create_device(struct p2p_data *p2p,
 360                                              const u8 *addr)
 361 {
 362         struct p2p_device *dev, *oldest = NULL;
 363         size_t count = 0;
 364
 365         dev = p2p_get_device(p2p, addr);
 366         if (dev)
 367                 return dev;
 368
 369         dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
 370                 count++;
 371                 if (oldest == NULL ||
 372                     os_time_before(&dev->last_seen, &oldest->last_seen))
 373                         oldest = dev;
 374         }
 375         if (count + 1 > p2p->cfg->max_peers && oldest) {
 376                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
 377                         "P2P: Remove oldest peer entry to make room for a new "
 378                         "peer");
 379                 dl_list_del(&oldest->list);
 380                 p2p_device_free(p2p, oldest);
 381         }
 382
 383         dev = os_zalloc(sizeof(*dev));
 384         if (dev == NULL)
 385                 return NULL;
 386         dl_list_add(&p2p->devices, &dev->list);
 387         os_memcpy(dev->info.p2p_device_addr, addr, ETH_ALEN);
 388
 389         return dev;
 390 }
 391
 392
 393 static void p2p_copy_client_info(struct p2p_device *dev,
 394                                  struct p2p_client_info *cli)
 395 {
 396         os_memcpy(dev->info.device_name, cli->dev_name, cli->dev_name_len);
 397         dev->info.device_name[cli->dev_name_len] = '\0';
 398         dev->info.dev_capab = cli->dev_capab;
 399         dev->info.config_methods = cli->config_methods;
 400         os_memcpy(dev->info.pri_dev_type, cli->pri_dev_type, 8);
 401         dev->info.wps_sec_dev_type_list_len = 8 * cli->num_sec_dev_types;
 402         os_memcpy(dev->info.wps_sec_dev_type_list, cli->sec_dev_types,
 403                   dev->info.wps_sec_dev_type_list_len);
 404 }
 405
 406
 407 static int p2p_add_group_clients(struct p2p_data *p2p, const u8 *go_dev_addr,
 408                                  const u8 *go_interface_addr, int freq,
 409                                  const u8 *gi, size_t gi_len)
 410 {
 411         struct p2p_group_info info;
 412         size_t c;
 413         struct p2p_device *dev;
 414
 415         if (gi == NULL)
 416                 return 0;
 417
 418         if (p2p_group_info_parse(gi, gi_len, &info) < 0)
 419                 return -1;
 420
 421         /*
 422          * Clear old data for this group; if the devices are still in the
 423          * group, the information will be restored in the loop following this.
 424          */
 425         dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
 426                 if (os_memcmp(dev->member_in_go_iface, go_interface_addr,
 427                               ETH_ALEN) == 0) {
 428                         os_memset(dev->member_in_go_iface, 0, ETH_ALEN);
 429                         os_memset(dev->member_in_go_dev, 0, ETH_ALEN);
 430                 }
 431         }
 432
 433         for (c = 0; c < info.num_clients; c++) {
 434                 struct p2p_client_info *cli = &info.client[c];
 435                 if (os_memcmp(cli->p2p_device_addr, p2p->cfg->dev_addr,
 436                               ETH_ALEN) == 0)
 437                         continue; /* ignore our own entry */
 438                 dev = p2p_get_device(p2p, cli->p2p_device_addr);
 439                 if (dev) {
 440                         /*
 441                          * Update information only if we have not received this
 442                          * directly from the client.
 443                          */
 444                         if (dev->flags & (P2P_DEV_GROUP_CLIENT_ONLY |
 445                                           P2P_DEV_PROBE_REQ_ONLY))
 446                                 p2p_copy_client_info(dev, cli);
 447                         if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
 448                                 dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY;
 449                         }
 450                 } else {
 451                         dev = p2p_create_device(p2p, cli->p2p_device_addr);
 452                         if (dev == NULL)
 453                                 continue;
 454                         dev->flags |= P2P_DEV_GROUP_CLIENT_ONLY;
 455                         p2p_copy_client_info(dev, cli);
 456                         dev->oper_freq = freq;
 457                         p2p->cfg->dev_found(p2p->cfg->cb_ctx,
 458                                             dev->info.p2p_device_addr,
 459                                             &dev->info, 1);
 460                         dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
 461                 }
 462
 463                 os_memcpy(dev->interface_addr, cli->p2p_interface_addr,
 464                           ETH_ALEN);
 465                 os_get_time(&dev->last_seen);
 466                 os_memcpy(dev->member_in_go_dev, go_dev_addr, ETH_ALEN);
 467                 os_memcpy(dev->member_in_go_iface, go_interface_addr,
 468                           ETH_ALEN);
 469         }
 470
 471         return 0;
 472 }
 473
 474
 475 static void p2p_copy_wps_info(struct p2p_device *dev, int probe_req,
 476                               const struct p2p_message *msg)
 477 {
 478         os_memcpy(dev->info.device_name, msg->device_name,
 479                   sizeof(dev->info.device_name));
 480
 481         if (msg->manufacturer &&
 482             msg->manufacturer_len < sizeof(dev->info.manufacturer)) {
 483                 os_memset(dev->info.manufacturer, 0,
 484                           sizeof(dev->info.manufacturer));
 485                 os_memcpy(dev->info.manufacturer, msg->manufacturer,
 486                           msg->manufacturer_len);
 487         }
 488
 489         if (msg->model_name &&
 490             msg->model_name_len < sizeof(dev->info.model_name)) {
 491                 os_memset(dev->info.model_name, 0,
 492                           sizeof(dev->info.model_name));
 493                 os_memcpy(dev->info.model_name, msg->model_name,
 494                           msg->model_name_len);
 495         }
 496
 497         if (msg->model_number &&
 498             msg->model_number_len < sizeof(dev->info.model_number)) {
 499                 os_memset(dev->info.model_number, 0,
 500                           sizeof(dev->info.model_number));
 501                 os_memcpy(dev->info.model_number, msg->model_number,
 502                           msg->model_number_len);
 503         }
 504
 505         if (msg->serial_number &&
 506             msg->serial_number_len < sizeof(dev->info.serial_number)) {
 507                 os_memset(dev->info.serial_number, 0,
 508                           sizeof(dev->info.serial_number));
 509                 os_memcpy(dev->info.serial_number, msg->serial_number,
 510                           msg->serial_number_len);
 511         }
 512
 513         if (msg->pri_dev_type)
 514                 os_memcpy(dev->info.pri_dev_type, msg->pri_dev_type,
 515                           sizeof(dev->info.pri_dev_type));
 516         else if (msg->wps_pri_dev_type)
 517                 os_memcpy(dev->info.pri_dev_type, msg->wps_pri_dev_type,
 518                           sizeof(dev->info.pri_dev_type));
 519
 520         if (msg->wps_sec_dev_type_list) {
 521                 os_memcpy(dev->info.wps_sec_dev_type_list,
 522                           msg->wps_sec_dev_type_list,
 523                           msg->wps_sec_dev_type_list_len);
 524                 dev->info.wps_sec_dev_type_list_len =
 525                         msg->wps_sec_dev_type_list_len;
 526         }
 527
 528         if (msg->capability) {
 529                 dev->info.dev_capab = msg->capability[0];
 530                 dev->info.group_capab = msg->capability[1];
 531         }
 532
 533         if (msg->ext_listen_timing) {
 534                 dev->ext_listen_period = WPA_GET_LE16(msg->ext_listen_timing);
 535                 dev->ext_listen_interval =
 536                         WPA_GET_LE16(msg->ext_listen_timing + 2);
 537         }
 538
 539         if (!probe_req) {
 540                 dev->info.config_methods = msg->config_methods ?
 541                         msg->config_methods : msg->wps_config_methods;
 542         }
 543 }
 544
 545
 546 /**
 547  * p2p_add_device - Add peer entries based on scan results or P2P frames
 548  * @p2p: P2P module context from p2p_init()
 549  * @addr: Source address of Beacon or Probe Response frame (may be either
 550  *      P2P Device Address or P2P Interface Address)
 551  * @level: Signal level (signal strength of the received frame from the peer)
 552  * @freq: Frequency on which the Beacon or Probe Response frame was received
 553  * @ies: IEs from the Beacon or Probe Response frame
 554  * @ies_len: Length of ies buffer in octets
 555  * @scan_res: Whether this was based on scan results
 556  * Returns: 0 on success, -1 on failure
 557  *
 558  * If the scan result is for a GO, the clients in the group will also be added
 559  * to the peer table. This function can also be used with some other frames
 560  * like Provision Discovery Request that contains P2P Capability and P2P Device
 561  * Info attributes.
 562  */
 563 int p2p_add_device(struct p2p_data *p2p, const u8 *addr, int freq, int level,
 564                    const u8 *ies, size_t ies_len, int scan_res)
 565 {
 566         struct p2p_device *dev;
 567         struct p2p_message msg;
 568         const u8 *p2p_dev_addr;
 569         int i;
 570
 571         os_memset(&msg, 0, sizeof(msg));
 572         if (p2p_parse_ies(ies, ies_len, &msg)) {
 573                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
 574                         "P2P: Failed to parse P2P IE for a device entry");
 575                 p2p_parse_free(&msg);
 576                 return -1;
 577         }
 578
 579         if (msg.p2p_device_addr)
 580                 p2p_dev_addr = msg.p2p_device_addr;
 581         else if (msg.device_id)
 582                 p2p_dev_addr = msg.device_id;
 583         else {
 584                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
 585                         "P2P: Ignore scan data without P2P Device Info or "
 586                         "P2P Device Id");
 587                 p2p_parse_free(&msg);
 588                 return -1;
 589         }
 590
 591         if (!is_zero_ether_addr(p2p->peer_filter) &&
 592             os_memcmp(p2p_dev_addr, p2p->peer_filter, ETH_ALEN) != 0) {
 593                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Do not add peer "
 594                         "filter for " MACSTR " due to peer filter",
 595                         MAC2STR(p2p_dev_addr));
 596                 return 0;
 597         }
 598
 599         dev = p2p_create_device(p2p, p2p_dev_addr);
 600         if (dev == NULL) {
 601                 p2p_parse_free(&msg);
 602                 return -1;
 603         }
 604         os_get_time(&dev->last_seen);
 605         dev->flags &= ~(P2P_DEV_PROBE_REQ_ONLY | P2P_DEV_GROUP_CLIENT_ONLY);
 606
 607         if (os_memcmp(addr, p2p_dev_addr, ETH_ALEN) != 0)
 608                 os_memcpy(dev->interface_addr, addr, ETH_ALEN);
 609         if (msg.ssid &&
 610             (msg.ssid[1] != P2P_WILDCARD_SSID_LEN ||
 611              os_memcmp(msg.ssid + 2, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN)
 612              != 0)) {
 613                 os_memcpy(dev->oper_ssid, msg.ssid + 2, msg.ssid[1]);
 614                 dev->oper_ssid_len = msg.ssid[1];
 615         }
 616
 617         if (freq >= 2412 && freq <= 2484 && msg.ds_params &&
 618             *msg.ds_params >= 1 && *msg.ds_params <= 14) {
 619                 int ds_freq;
 620                 if (*msg.ds_params == 14)
 621                         ds_freq = 2484;
 622                 else
 623                         ds_freq = 2407 + *msg.ds_params * 5;
 624                 if (freq != ds_freq) {
 625                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
 626                                 "P2P: Update Listen frequency based on DS "
 627                                 "Parameter Set IE: %d -> %d MHz",
 628                                 freq, ds_freq);
 629                         freq = ds_freq;
 630                 }
 631         }
 632
 633         if (dev->listen_freq && dev->listen_freq != freq && scan_res) {
 634                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
 635                         "P2P: Update Listen frequency based on scan "
 636                         "results (" MACSTR " %d -> %d MHz (DS param %d)",
 637                         MAC2STR(dev->info.p2p_device_addr), dev->listen_freq,
 638                         freq, msg.ds_params ? *msg.ds_params : -1);
 639         }
 640         if (scan_res) {
 641                 dev->listen_freq = freq;
 642                 if (msg.group_info)
 643                         dev->oper_freq = freq;
 644         }
 645         dev->info.level = level;
 646
 647         p2p_copy_wps_info(dev, 0, &msg);
 648
 649         for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
 650                 wpabuf_free(dev->info.wps_vendor_ext[i]);
 651                 dev->info.wps_vendor_ext[i] = NULL;
 652         }
 653
 654         for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
 655                 if (msg.wps_vendor_ext[i] == NULL)
 656                         break;
 657                 dev->info.wps_vendor_ext[i] = wpabuf_alloc_copy(
 658                         msg.wps_vendor_ext[i], msg.wps_vendor_ext_len[i]);
 659                 if (dev->info.wps_vendor_ext[i] == NULL)
 660                         break;
 661         }
 662
 663         if (scan_res) {
 664                 p2p_add_group_clients(p2p, p2p_dev_addr, addr, freq,
 665                                       msg.group_info, msg.group_info_len);
 666         }
 667
 668         p2p_parse_free(&msg);
 669
 670         if (p2p_pending_sd_req(p2p, dev))
 671                 dev->flags |= P2P_DEV_SD_SCHEDULE;
 672
 673         if (dev->flags & P2P_DEV_REPORTED)
 674                 return 0;
 675
 676         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
 677                 "P2P: Peer found with Listen frequency %d MHz", freq);
 678         if (dev->flags & P2P_DEV_USER_REJECTED) {
 679                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
 680                         "P2P: Do not report rejected device");
 681                 return 0;
 682         }
 683
 684         p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,
 685                             !(dev->flags & P2P_DEV_REPORTED_ONCE));
 686         dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
 687
 688         return 0;
 689 }
 690
 691
 692 static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev)
 693 {
 694         int i;
 695
 696         if (p2p->go_neg_peer == dev) {
 697                 /*
 698                  * If GO Negotiation is in progress, report that it has failed.
 699                  */
 700                 p2p_go_neg_failed(p2p, dev, -1);
 701                 p2p->go_neg_peer = NULL;
 702         }
 703         if (p2p->invite_peer == dev)
 704                 p2p->invite_peer = NULL;
 705         if (p2p->sd_peer == dev)
 706                 p2p->sd_peer = NULL;
 707         if (p2p->pending_client_disc_go == dev)
 708                 p2p->pending_client_disc_go = NULL;
 709
 710         /* dev_lost() device, but only if it was previously dev_found() */
 711         if (dev->flags & P2P_DEV_REPORTED_ONCE)
 712                 p2p->cfg->dev_lost(p2p->cfg->cb_ctx,
 713                                    dev->info.p2p_device_addr);
 714
 715         for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
 716                 wpabuf_free(dev->info.wps_vendor_ext[i]);
 717                 dev->info.wps_vendor_ext[i] = NULL;
 718         }
 719
 720         os_free(dev);
 721 }
 722
 723
 724 static int p2p_get_next_prog_freq(struct p2p_data *p2p)
 725 {
 726         struct p2p_channels *c;
 727         struct p2p_reg_class *cla;
 728         size_t cl, ch;
 729         int found = 0;
 730         u8 reg_class;
 731         u8 channel;
 732         int freq;
 733
 734         c = &p2p->cfg->channels;
 735         for (cl = 0; cl < c->reg_classes; cl++) {
 736                 cla = &c->reg_class[cl];
 737                 if (cla->reg_class != p2p->last_prog_scan_class)
 738                         continue;
 739                 for (ch = 0; ch < cla->channels; ch++) {
 740                         if (cla->channel[ch] == p2p->last_prog_scan_chan) {
 741                                 found = 1;
 742                                 break;
 743                         }
 744                 }
 745                 if (found)
 746                         break;
 747         }
 748
 749         if (!found) {
 750                 /* Start from beginning */
 751                 reg_class = c->reg_class[0].reg_class;
 752                 channel = c->reg_class[0].channel[0];
 753         } else {
 754                 /* Pick the next channel */
 755                 ch++;
 756                 if (ch == cla->channels) {
 757                         cl++;
 758                         if (cl == c->reg_classes)
 759                                 cl = 0;
 760                         ch = 0;
 761                 }
 762                 reg_class = c->reg_class[cl].reg_class;
 763                 channel = c->reg_class[cl].channel[ch];
 764         }
 765
 766         freq = p2p_channel_to_freq(p2p->cfg->country, reg_class, channel);
 767         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Next progressive search "
 768                 "channel: reg_class %u channel %u -> %d MHz",
 769                 reg_class, channel, freq);
 770         p2p->last_prog_scan_class = reg_class;
 771         p2p->last_prog_scan_chan = channel;
 772
 773         if (freq == 2412 || freq == 2437 || freq == 2462)
 774                 return 0; /* No need to add social channels */
 775         return freq;
 776 }
 777
 778
 779 static void p2p_search(struct p2p_data *p2p)
 780 {
 781         int freq = 0;
 782         enum p2p_scan_type type;
 783         u16 pw_id = DEV_PW_DEFAULT;
 784
 785         if (p2p->drv_in_listen) {
 786                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Driver is still "
 787                         "in Listen state - wait for it to end before "
 788                         "continuing");
 789                 return;
 790         }
 791         p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
 792
 793         if (p2p->go_neg_peer) {
 794                 /*
 795                  * Only scan the known listen frequency of the peer
 796                  * during GO Negotiation start.
 797                  */
 798                 freq = p2p->go_neg_peer->listen_freq;
 799                 if (freq <= 0)
 800                         freq = p2p->go_neg_peer->oper_freq;
 801                 type = P2P_SCAN_SPECIFIC;
 802                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Starting search "
 803                         "for freq %u (GO Neg)", freq);
 804
 805                 /* Advertise immediate availability of WPS credential */
 806                 pw_id = p2p_wps_method_pw_id(p2p->go_neg_peer->wps_method);
 807         } else if (p2p->invite_peer) {
 808                 /*
 809                  * Only scan the known listen frequency of the peer
 810                  * during Invite start.
 811                  */
 812                 freq = p2p->invite_peer->listen_freq;
 813                 if (freq <= 0)
 814                         freq = p2p->invite_peer->oper_freq;
 815                 type = P2P_SCAN_SPECIFIC;
 816                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Starting search "
 817                         "for freq %u (Invite)", freq);
 818         } else if (p2p->find_type == P2P_FIND_PROGRESSIVE &&
 819                    (freq = p2p_get_next_prog_freq(p2p)) > 0) {
 820                 type = P2P_SCAN_SOCIAL_PLUS_ONE;
 821                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Starting search "
 822                         "(+ freq %u)", freq);
 823         } else {
 824                 type = P2P_SCAN_SOCIAL;
 825                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Starting search");
 826         }
 827
 828         if (p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, type, freq,
 829                                p2p->num_req_dev_types, p2p->req_dev_types,
 830                                p2p->find_dev_id, pw_id)) {
 831                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
 832                         "P2P: Scan request failed");
 833                 p2p_continue_find(p2p);
 834         } else {
 835                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Running p2p_scan");
 836                 p2p->p2p_scan_running = 1;
 837                 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
 838                 eloop_register_timeout(P2P_SCAN_TIMEOUT, 0, p2p_scan_timeout,
 839                                        p2p, NULL);
 840         }
 841 }
 842
 843
 844 static void p2p_find_timeout(void *eloop_ctx, void *timeout_ctx)
 845 {
 846         struct p2p_data *p2p = eloop_ctx;
 847         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Find timeout -> stop");
 848         p2p_stop_find(p2p);
 849 }
 850
 851
 852 static int p2p_run_after_scan(struct p2p_data *p2p)
 853 {
 854         struct p2p_device *dev;
 855         enum p2p_after_scan op;
 856
 857         if (p2p->after_scan_tx) {
 858                 /* TODO: schedule p2p_run_after_scan to be called from TX
 859                  * status callback(?) */
 860                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Send pending "
 861                         "Action frame at p2p_scan completion");
 862                 p2p->cfg->send_action(p2p->cfg->cb_ctx,
 863                                       p2p->after_scan_tx->freq,
 864                                       p2p->after_scan_tx->dst,
 865                                       p2p->after_scan_tx->src,
 866                                       p2p->after_scan_tx->bssid,
 867                                       (u8 *) (p2p->after_scan_tx + 1),
 868                                       p2p->after_scan_tx->len,
 869                                       p2p->after_scan_tx->wait_time);
 870                 os_free(p2p->after_scan_tx);
 871                 p2p->after_scan_tx = NULL;
 872                 return 1;
 873         }
 874
 875         op = p2p->start_after_scan;
 876         p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
 877         switch (op) {
 878         case P2P_AFTER_SCAN_NOTHING:
 879                 break;
 880         case P2P_AFTER_SCAN_LISTEN:
 881                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Start previously "
 882                         "requested Listen state");
 883                 p2p_listen(p2p, p2p->pending_listen_sec * 1000 +
 884                            p2p->pending_listen_usec / 1000);
 885                 return 1;
 886         case P2P_AFTER_SCAN_CONNECT:
 887                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Start previously "
 888                         "requested connect with " MACSTR,
 889                         MAC2STR(p2p->after_scan_peer));
 890                 dev = p2p_get_device(p2p, p2p->after_scan_peer);
 891                 if (dev == NULL) {
 892                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer not "
 893                                 "known anymore");
 894                         break;
 895                 }
 896                 p2p_connect_send(p2p, dev);
 897                 return 1;
 898         }
 899
 900         return 0;
 901 }
 902
 903
 904 static void p2p_scan_timeout(void *eloop_ctx, void *timeout_ctx)
 905 {
 906         struct p2p_data *p2p = eloop_ctx;
 907         int running;
 908         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: p2p_scan timeout "
 909                 "(running=%d)", p2p->p2p_scan_running);
 910         running = p2p->p2p_scan_running;
 911         /* Make sure we recover from missed scan results callback */
 912         p2p->p2p_scan_running = 0;
 913
 914         if (running)
 915                 p2p_run_after_scan(p2p);
 916 }
 917
 918
 919 static void p2p_free_req_dev_types(struct p2p_data *p2p)
 920 {
 921         p2p->num_req_dev_types = 0;
 922         os_free(p2p->req_dev_types);
 923         p2p->req_dev_types = NULL;
 924 }
 925
 926
 927 int p2p_find(struct p2p_data *p2p, unsigned int timeout,
 928              enum p2p_discovery_type type,
 929              unsigned int num_req_dev_types, const u8 *req_dev_types,
 930              const u8 *dev_id)
 931 {
 932         int res;
 933
 934         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Starting find (type=%d)",
 935                 type);
 936         if (p2p->p2p_scan_running) {
 937                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: p2p_scan is "
 938                         "already running");
 939         }
 940
 941         p2p_free_req_dev_types(p2p);
 942         if (req_dev_types && num_req_dev_types) {
 943                 p2p->req_dev_types = os_malloc(num_req_dev_types *
 944                                                WPS_DEV_TYPE_LEN);
 945                 if (p2p->req_dev_types == NULL)
 946                         return -1;
 947                 os_memcpy(p2p->req_dev_types, req_dev_types,
 948                           num_req_dev_types * WPS_DEV_TYPE_LEN);
 949                 p2p->num_req_dev_types = num_req_dev_types;
 950         }
 951
 952         if (dev_id) {
 953                 os_memcpy(p2p->find_dev_id_buf, dev_id, ETH_ALEN);
 954                 p2p->find_dev_id = p2p->find_dev_id_buf;
 955         } else
 956                 p2p->find_dev_id = NULL;
 957
 958         p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
 959         p2p_clear_timeout(p2p);
 960         p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
 961         p2p->find_type = type;
 962         p2p_device_clear_reported(p2p);
 963         p2p_set_state(p2p, P2P_SEARCH);
 964         eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);
 965         p2p->last_p2p_find_timeout = timeout;
 966         if (timeout)
 967                 eloop_register_timeout(timeout, 0, p2p_find_timeout,
 968                                        p2p, NULL);
 969         switch (type) {
 970         case P2P_FIND_START_WITH_FULL:
 971         case P2P_FIND_PROGRESSIVE:
 972                 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_FULL, 0,
 973                                          p2p->num_req_dev_types,
 974                                          p2p->req_dev_types, dev_id,
 975                                          DEV_PW_DEFAULT);
 976                 break;
 977         case P2P_FIND_ONLY_SOCIAL:
 978                 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_SOCIAL, 0,
 979                                          p2p->num_req_dev_types,
 980                                          p2p->req_dev_types, dev_id,
 981                                          DEV_PW_DEFAULT);
 982                 break;
 983         default:
 984                 return -1;
 985         }
 986
 987         if (res == 0) {
 988                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Running p2p_scan");
 989                 p2p->p2p_scan_running = 1;
 990                 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
 991                 eloop_register_timeout(P2P_SCAN_TIMEOUT, 0, p2p_scan_timeout,
 992                                        p2p, NULL);
 993         } else if (res == 1) {
 994                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Could not start "
 995                         "p2p_scan at this point - will try again after "
 996                         "previous scan completes");
 997                 res = 0;
 998                 p2p_set_state(p2p, P2P_SEARCH_WHEN_READY);
 999                 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);
1000         } else {
1001                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Failed to start "
1002                         "p2p_scan");
1003                 p2p_set_state(p2p, P2P_IDLE);
1004                 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);
1005         }
1006
1007         return res;
1008 }
1009
1010
1011 int p2p_other_scan_completed(struct p2p_data *p2p)
1012 {
1013         if (p2p->state != P2P_SEARCH_WHEN_READY)
1014                 return 0;
1015         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Starting pending P2P find "
1016                 "now that previous scan was completed");
1017         if (p2p_find(p2p, p2p->last_p2p_find_timeout, p2p->find_type,
1018                      p2p->num_req_dev_types, p2p->req_dev_types,
1019                      p2p->find_dev_id) < 0)
1020                 return 0;
1021         return 1;
1022 }
1023
1024
1025 void p2p_stop_find_for_freq(struct p2p_data *p2p, int freq)
1026 {
1027         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Stopping find");
1028         eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);
1029         p2p_clear_timeout(p2p);
1030         if (p2p->state == P2P_SEARCH)
1031                 wpa_msg(p2p->cfg->msg_ctx, MSG_INFO, P2P_EVENT_FIND_STOPPED);
1032         p2p_set_state(p2p, P2P_IDLE);
1033         p2p_free_req_dev_types(p2p);
1034         p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
1035         p2p->go_neg_peer = NULL;
1036         p2p->sd_peer = NULL;
1037         p2p->invite_peer = NULL;
1038         p2p_stop_listen_for_freq(p2p, freq);
1039 }
1040
1041
1042 void p2p_stop_listen_for_freq(struct p2p_data *p2p, int freq)
1043 {
1044         if (freq > 0 && p2p->drv_in_listen == freq && p2p->in_listen) {
1045                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Skip stop_listen "
1046                         "since we are on correct channel for response");
1047                 return;
1048         }
1049         if (p2p->in_listen) {
1050                 p2p->in_listen = 0;
1051                 p2p_clear_timeout(p2p);
1052         }
1053         if (p2p->drv_in_listen) {
1054                 /*
1055                  * The driver may not deliver callback to p2p_listen_end()
1056                  * when the operation gets canceled, so clear the internal
1057                  * variable that is tracking driver state.
1058                  */
1059                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Clear "
1060                         "drv_in_listen (%d)", p2p->drv_in_listen);
1061                 p2p->drv_in_listen = 0;
1062         }
1063         p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1064 }
1065
1066
1067 void p2p_stop_find(struct p2p_data *p2p)
1068 {
1069         p2p_stop_find_for_freq(p2p, 0);
1070 }
1071
1072
1073 static int p2p_prepare_channel(struct p2p_data *p2p, unsigned int force_freq)
1074 {
1075         if (force_freq) {
1076                 u8 op_reg_class, op_channel;
1077                 if (p2p_freq_to_channel(p2p->cfg->country, force_freq,
1078                                         &op_reg_class, &op_channel) < 0) {
1079                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1080                                 "P2P: Unsupported frequency %u MHz",
1081                                 force_freq);
1082                         return -1;
1083                 }
1084                 if (!p2p_channels_includes(&p2p->cfg->channels, op_reg_class,
1085                                            op_channel)) {
1086                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1087                                 "P2P: Frequency %u MHz (oper_class %u "
1088                                 "channel %u) not allowed for P2P",
1089                                 force_freq, op_reg_class, op_channel);
1090                         return -1;
1091                 }
1092                 p2p->op_reg_class = op_reg_class;
1093                 p2p->op_channel = op_channel;
1094                 p2p->channels.reg_classes = 1;
1095                 p2p->channels.reg_class[0].channels = 1;
1096                 p2p->channels.reg_class[0].reg_class = p2p->op_reg_class;
1097                 p2p->channels.reg_class[0].channel[0] = p2p->op_channel;
1098         } else {
1099                 u8 op_reg_class, op_channel;
1100
1101                 if (!p2p->cfg->cfg_op_channel && p2p->best_freq_overall > 0 &&
1102                     p2p_supported_freq(p2p, p2p->best_freq_overall) &&
1103                     p2p_freq_to_channel(p2p->cfg->country,
1104                                         p2p->best_freq_overall,
1105                                         &op_reg_class, &op_channel) == 0) {
1106                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1107                                 "P2P: Select best overall channel as "
1108                                 "operating channel preference");
1109                         p2p->op_reg_class = op_reg_class;
1110                         p2p->op_channel = op_channel;
1111                 } else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_5 > 0 &&
1112                            p2p_supported_freq(p2p, p2p->best_freq_5) &&
1113                            p2p_freq_to_channel(p2p->cfg->country,
1114                                                p2p->best_freq_5,
1115                                                &op_reg_class, &op_channel) ==
1116                            0) {
1117                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1118                                 "P2P: Select best 5 GHz channel as "
1119                                 "operating channel preference");
1120                         p2p->op_reg_class = op_reg_class;
1121                         p2p->op_channel = op_channel;
1122                 } else if (!p2p->cfg->cfg_op_channel &&
1123                            p2p->best_freq_24 > 0 &&
1124                            p2p_supported_freq(p2p, p2p->best_freq_24) &&
1125                            p2p_freq_to_channel(p2p->cfg->country,
1126                                                p2p->best_freq_24,
1127                                                &op_reg_class, &op_channel) ==
1128                            0) {
1129                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1130                                 "P2P: Select best 2.4 GHz channel as "
1131                                 "operating channel preference");
1132                         p2p->op_reg_class = op_reg_class;
1133                         p2p->op_channel = op_channel;
1134                 } else {
1135                         p2p->op_reg_class = p2p->cfg->op_reg_class;
1136                         p2p->op_channel = p2p->cfg->op_channel;
1137                 }
1138
1139                 os_memcpy(&p2p->channels, &p2p->cfg->channels,
1140                           sizeof(struct p2p_channels));
1141         }
1142         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1143                 "P2P: Own preference for operation channel: "
1144                 "Operating Class %u Channel %u%s",
1145                 p2p->op_reg_class, p2p->op_channel,
1146                 force_freq ? " (forced)" : "");
1147
1148         return 0;
1149 }
1150
1151
1152 static void p2p_set_dev_persistent(struct p2p_device *dev,
1153                                    int persistent_group)
1154 {
1155         switch (persistent_group) {
1156         case 0:
1157                 dev->flags &= ~(P2P_DEV_PREFER_PERSISTENT_GROUP |
1158                                 P2P_DEV_PREFER_PERSISTENT_RECONN);
1159                 break;
1160         case 1:
1161                 dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP;
1162                 dev->flags &= ~P2P_DEV_PREFER_PERSISTENT_RECONN;
1163                 break;
1164         case 2:
1165                 dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP |
1166                         P2P_DEV_PREFER_PERSISTENT_RECONN;
1167                 break;
1168         }
1169 }
1170
1171
1172 int p2p_connect(struct p2p_data *p2p, const u8 *peer_addr,
1173                 enum p2p_wps_method wps_method,
1174                 int go_intent, const u8 *own_interface_addr,
1175                 unsigned int force_freq, int persistent_group,
1176                 const u8 *force_ssid, size_t force_ssid_len,
1177                 int pd_before_go_neg)
1178 {
1179         struct p2p_device *dev;
1180
1181         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1182                 "P2P: Request to start group negotiation - peer=" MACSTR
1183                 "  GO Intent=%d  Intended Interface Address=" MACSTR
1184                 " wps_method=%d persistent_group=%d pd_before_go_neg=%d",
1185                 MAC2STR(peer_addr), go_intent, MAC2STR(own_interface_addr),
1186                 wps_method, persistent_group, pd_before_go_neg);
1187
1188         if (p2p_prepare_channel(p2p, force_freq) < 0)
1189                 return -1;
1190
1191         dev = p2p_get_device(p2p, peer_addr);
1192         if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
1193                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1194                         "P2P: Cannot connect to unknown P2P Device " MACSTR,
1195                         MAC2STR(peer_addr));
1196                 return -1;
1197         }
1198
1199         if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) {
1200                 if (!(dev->info.dev_capab &
1201                       P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) {
1202                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1203                                 "P2P: Cannot connect to P2P Device " MACSTR
1204                                 " that is in a group and is not discoverable",
1205                                 MAC2STR(peer_addr));
1206                         return -1;
1207                 }
1208                 if (dev->oper_freq <= 0) {
1209                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1210                                 "P2P: Cannot connect to P2P Device " MACSTR
1211                                 " with incomplete information",
1212                                 MAC2STR(peer_addr));
1213                         return -1;
1214                 }
1215
1216                 /*
1217                  * First, try to connect directly. If the peer does not
1218                  * acknowledge frames, assume it is sleeping and use device
1219                  * discoverability via the GO at that point.
1220                  */
1221         }
1222
1223         p2p->ssid_set = 0;
1224         if (force_ssid) {
1225                 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Forced SSID",
1226                                   force_ssid, force_ssid_len);
1227                 os_memcpy(p2p->ssid, force_ssid, force_ssid_len);
1228                 p2p->ssid_len = force_ssid_len;
1229                 p2p->ssid_set = 1;
1230         }
1231
1232         dev->flags &= ~P2P_DEV_NOT_YET_READY;
1233         dev->flags &= ~P2P_DEV_USER_REJECTED;
1234         dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
1235         dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM;
1236         if (pd_before_go_neg)
1237                 dev->flags |= P2P_DEV_PD_BEFORE_GO_NEG;
1238         else
1239                 dev->flags &= ~P2P_DEV_PD_BEFORE_GO_NEG;
1240         dev->connect_reqs = 0;
1241         dev->go_neg_req_sent = 0;
1242         dev->go_state = UNKNOWN_GO;
1243         p2p_set_dev_persistent(dev, persistent_group);
1244         p2p->go_intent = go_intent;
1245         os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);
1246
1247         if (p2p->state != P2P_IDLE)
1248                 p2p_stop_find(p2p);
1249
1250         if (p2p->after_scan_tx) {
1251                 /*
1252                  * We need to drop the pending frame to avoid issues with the
1253                  * new GO Negotiation, e.g., when the pending frame was from a
1254                  * previous attempt at starting a GO Negotiation.
1255                  */
1256                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Dropped "
1257                         "previous pending Action frame TX that was waiting "
1258                         "for p2p_scan completion");
1259                 os_free(p2p->after_scan_tx);
1260                 p2p->after_scan_tx = NULL;
1261         }
1262
1263         dev->wps_method = wps_method;
1264         dev->status = P2P_SC_SUCCESS;
1265
1266         if (force_freq)
1267                 dev->flags |= P2P_DEV_FORCE_FREQ;
1268         else
1269                 dev->flags &= ~P2P_DEV_FORCE_FREQ;
1270
1271         if (p2p->p2p_scan_running) {
1272                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1273                         "P2P: p2p_scan running - delay connect send");
1274                 p2p->start_after_scan = P2P_AFTER_SCAN_CONNECT;
1275                 os_memcpy(p2p->after_scan_peer, peer_addr, ETH_ALEN);
1276                 return 0;
1277         }
1278         p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
1279
1280         return p2p_connect_send(p2p, dev);
1281 }
1282
1283
1284 int p2p_authorize(struct p2p_data *p2p, const u8 *peer_addr,
1285                   enum p2p_wps_method wps_method,
1286                   int go_intent, const u8 *own_interface_addr,
1287                   unsigned int force_freq, int persistent_group,
1288                   const u8 *force_ssid, size_t force_ssid_len)
1289 {
1290         struct p2p_device *dev;
1291
1292         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1293                 "P2P: Request to authorize group negotiation - peer=" MACSTR
1294                 "  GO Intent=%d  Intended Interface Address=" MACSTR
1295                 " wps_method=%d  persistent_group=%d",
1296                 MAC2STR(peer_addr), go_intent, MAC2STR(own_interface_addr),
1297                 wps_method, persistent_group);
1298
1299         if (p2p_prepare_channel(p2p, force_freq) < 0)
1300                 return -1;
1301
1302         dev = p2p_get_device(p2p, peer_addr);
1303         if (dev == NULL) {
1304                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1305                         "P2P: Cannot authorize unknown P2P Device " MACSTR,
1306                         MAC2STR(peer_addr));
1307                 return -1;
1308         }
1309
1310         p2p->ssid_set = 0;
1311         if (force_ssid) {
1312                 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Forced SSID",
1313                                   force_ssid, force_ssid_len);
1314                 os_memcpy(p2p->ssid, force_ssid, force_ssid_len);
1315                 p2p->ssid_len = force_ssid_len;
1316                 p2p->ssid_set = 1;
1317         }
1318
1319         dev->flags &= ~P2P_DEV_NOT_YET_READY;
1320         dev->flags &= ~P2P_DEV_USER_REJECTED;
1321         dev->go_neg_req_sent = 0;
1322         dev->go_state = UNKNOWN_GO;
1323         p2p_set_dev_persistent(dev, persistent_group);
1324         p2p->go_intent = go_intent;
1325         os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);
1326
1327         dev->wps_method = wps_method;
1328         dev->status = P2P_SC_SUCCESS;
1329
1330         if (force_freq)
1331                 dev->flags |= P2P_DEV_FORCE_FREQ;
1332         else
1333                 dev->flags &= ~P2P_DEV_FORCE_FREQ;
1334
1335         return 0;
1336 }
1337
1338
1339 void p2p_add_dev_info(struct p2p_data *p2p, const u8 *addr,
1340                       struct p2p_device *dev, struct p2p_message *msg)
1341 {
1342         os_get_time(&dev->last_seen);
1343
1344         p2p_copy_wps_info(dev, 0, msg);
1345
1346         if (msg->listen_channel) {
1347                 int freq;
1348                 freq = p2p_channel_to_freq((char *) msg->listen_channel,
1349                                            msg->listen_channel[3],
1350                                            msg->listen_channel[4]);
1351                 if (freq < 0) {
1352                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1353                                 "P2P: Unknown peer Listen channel: "
1354                                 "country=%c%c(0x%02x) reg_class=%u channel=%u",
1355                                 msg->listen_channel[0],
1356                                 msg->listen_channel[1],
1357                                 msg->listen_channel[2],
1358                                 msg->listen_channel[3],
1359                                 msg->listen_channel[4]);
1360                 } else {
1361                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Update "
1362                                 "peer " MACSTR " Listen channel: %u -> %u MHz",
1363                                 MAC2STR(dev->info.p2p_device_addr),
1364                                 dev->listen_freq, freq);
1365                         dev->listen_freq = freq;
1366                 }
1367         }
1368
1369         if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
1370                 dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY;
1371                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1372                         "P2P: Completed device entry based on data from "
1373                         "GO Negotiation Request");
1374         } else {
1375                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1376                         "P2P: Created device entry based on GO Neg Req: "
1377                         MACSTR " dev_capab=0x%x group_capab=0x%x name='%s' "
1378                         "listen_freq=%d",
1379                         MAC2STR(dev->info.p2p_device_addr),
1380                         dev->info.dev_capab, dev->info.group_capab,
1381                         dev->info.device_name, dev->listen_freq);
1382         }
1383
1384         dev->flags &= ~P2P_DEV_GROUP_CLIENT_ONLY;
1385
1386         if (dev->flags & P2P_DEV_USER_REJECTED) {
1387                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1388                         "P2P: Do not report rejected device");
1389                 return;
1390         }
1391
1392         p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,
1393                             !(dev->flags & P2P_DEV_REPORTED_ONCE));
1394         dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
1395 }
1396
1397
1398 void p2p_build_ssid(struct p2p_data *p2p, u8 *ssid, size_t *ssid_len)
1399 {
1400         os_memcpy(ssid, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN);
1401         p2p_random((char *) &ssid[P2P_WILDCARD_SSID_LEN], 2);
1402         os_memcpy(&ssid[P2P_WILDCARD_SSID_LEN + 2],
1403                   p2p->cfg->ssid_postfix, p2p->cfg->ssid_postfix_len);
1404         *ssid_len = P2P_WILDCARD_SSID_LEN + 2 + p2p->cfg->ssid_postfix_len;
1405 }
1406
1407
1408 int p2p_go_params(struct p2p_data *p2p, struct p2p_go_neg_results *params)
1409 {
1410         p2p_build_ssid(p2p, params->ssid, &params->ssid_len);
1411         p2p_random(params->passphrase, 8);
1412         return 0;
1413 }
1414
1415
1416 void p2p_go_complete(struct p2p_data *p2p, struct p2p_device *peer)
1417 {
1418         struct p2p_go_neg_results res;
1419         int go = peer->go_state == LOCAL_GO;
1420         struct p2p_channels intersection;
1421         int freqs;
1422         size_t i, j;
1423
1424         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1425                 "P2P: GO Negotiation with " MACSTR " completed (%s will be "
1426                 "GO)", MAC2STR(peer->info.p2p_device_addr),
1427                 go ? "local end" : "peer");
1428
1429         os_memset(&res, 0, sizeof(res));
1430         res.role_go = go;
1431         os_memcpy(res.peer_device_addr, peer->info.p2p_device_addr, ETH_ALEN);
1432         os_memcpy(res.peer_interface_addr, peer->intended_addr, ETH_ALEN);
1433         res.wps_method = peer->wps_method;
1434         if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP) {
1435                 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_RECONN)
1436                         res.persistent_group = 2;
1437                 else
1438                         res.persistent_group = 1;
1439         }
1440
1441         if (go) {
1442                 /* Setup AP mode for WPS provisioning */
1443                 res.freq = p2p_channel_to_freq(p2p->cfg->country,
1444                                                p2p->op_reg_class,
1445                                                p2p->op_channel);
1446                 os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len);
1447                 res.ssid_len = p2p->ssid_len;
1448                 p2p_random(res.passphrase, 8);
1449         } else {
1450                 res.freq = peer->oper_freq;
1451                 if (p2p->ssid_len) {
1452                         os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len);
1453                         res.ssid_len = p2p->ssid_len;
1454                 }
1455         }
1456
1457         p2p_channels_intersect(&p2p->channels, &peer->channels,
1458                                &intersection);
1459         freqs = 0;
1460         for (i = 0; i < intersection.reg_classes; i++) {
1461                 struct p2p_reg_class *c = &intersection.reg_class[i];
1462                 if (freqs + 1 == P2P_MAX_CHANNELS)
1463                         break;
1464                 for (j = 0; j < c->channels; j++) {
1465                         int freq;
1466                         if (freqs + 1 == P2P_MAX_CHANNELS)
1467                                 break;
1468                         freq = p2p_channel_to_freq(peer->country, c->reg_class,
1469                                                    c->channel[j]);
1470                         if (freq < 0)
1471                                 continue;
1472                         res.freq_list[freqs++] = freq;
1473                 }
1474         }
1475
1476         res.peer_config_timeout = go ? peer->client_timeout : peer->go_timeout;
1477
1478         p2p_clear_timeout(p2p);
1479         p2p->ssid_set = 0;
1480         peer->go_neg_req_sent = 0;
1481         peer->wps_method = WPS_NOT_READY;
1482
1483         p2p_set_state(p2p, P2P_PROVISIONING);
1484         p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res);
1485 }
1486
1487
1488 static void p2p_rx_p2p_action(struct p2p_data *p2p, const u8 *sa,
1489                               const u8 *data, size_t len, int rx_freq)
1490 {
1491         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1492                 "P2P: RX P2P Public Action from " MACSTR, MAC2STR(sa));
1493         wpa_hexdump(MSG_MSGDUMP, "P2P: P2P Public Action contents", data, len);
1494
1495         if (len < 1)
1496                 return;
1497
1498         switch (data[0]) {
1499         case P2P_GO_NEG_REQ:
1500                 p2p_process_go_neg_req(p2p, sa, data + 1, len - 1, rx_freq);
1501                 break;
1502         case P2P_GO_NEG_RESP:
1503                 p2p_process_go_neg_resp(p2p, sa, data + 1, len - 1, rx_freq);
1504                 break;
1505         case P2P_GO_NEG_CONF:
1506                 p2p_process_go_neg_conf(p2p, sa, data + 1, len - 1);
1507                 break;
1508         case P2P_INVITATION_REQ:
1509                 p2p_process_invitation_req(p2p, sa, data + 1, len - 1,
1510                                            rx_freq);
1511                 break;
1512         case P2P_INVITATION_RESP:
1513                 p2p_process_invitation_resp(p2p, sa, data + 1, len - 1);
1514                 break;
1515         case P2P_PROV_DISC_REQ:
1516                 p2p_process_prov_disc_req(p2p, sa, data + 1, len - 1, rx_freq);
1517                 break;
1518         case P2P_PROV_DISC_RESP:
1519                 p2p_process_prov_disc_resp(p2p, sa, data + 1, len - 1);
1520                 break;
1521         case P2P_DEV_DISC_REQ:
1522                 p2p_process_dev_disc_req(p2p, sa, data + 1, len - 1, rx_freq);
1523                 break;
1524         case P2P_DEV_DISC_RESP:
1525                 p2p_process_dev_disc_resp(p2p, sa, data + 1, len - 1);
1526                 break;
1527         default:
1528                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1529                         "P2P: Unsupported P2P Public Action frame type %d",
1530                         data[0]);
1531                 break;
1532         }
1533 }
1534
1535
1536 static void p2p_rx_action_public(struct p2p_data *p2p, const u8 *da,
1537                                  const u8 *sa, const u8 *bssid, const u8 *data,
1538                                  size_t len, int freq)
1539 {
1540         if (len < 1)
1541                 return;
1542
1543         switch (data[0]) {
1544         case WLAN_PA_VENDOR_SPECIFIC:
1545                 data++;
1546                 len--;
1547                 if (len < 3)
1548                         return;
1549                 if (WPA_GET_BE24(data) != OUI_WFA)
1550                         return;
1551
1552                 data += 3;
1553                 len -= 3;
1554                 if (len < 1)
1555                         return;
1556
1557                 if (*data != P2P_OUI_TYPE)
1558                         return;
1559
1560                 p2p_rx_p2p_action(p2p, sa, data + 1, len - 1, freq);
1561                 break;
1562         case WLAN_PA_GAS_INITIAL_REQ:
1563                 p2p_rx_gas_initial_req(p2p, sa, data + 1, len - 1, freq);
1564                 break;
1565         case WLAN_PA_GAS_INITIAL_RESP:
1566                 p2p_rx_gas_initial_resp(p2p, sa, data + 1, len - 1, freq);
1567                 break;
1568         case WLAN_PA_GAS_COMEBACK_REQ:
1569                 p2p_rx_gas_comeback_req(p2p, sa, data + 1, len - 1, freq);
1570                 break;
1571         case WLAN_PA_GAS_COMEBACK_RESP:
1572                 p2p_rx_gas_comeback_resp(p2p, sa, data + 1, len - 1, freq);
1573                 break;
1574         }
1575 }
1576
1577
1578 void p2p_rx_action(struct p2p_data *p2p, const u8 *da, const u8 *sa,
1579                    const u8 *bssid, u8 category,
1580                    const u8 *data, size_t len, int freq)
1581 {
1582         if (category == WLAN_ACTION_PUBLIC) {
1583                 p2p_rx_action_public(p2p, da, sa, bssid, data, len, freq);
1584                 return;
1585         }
1586
1587         if (category != WLAN_ACTION_VENDOR_SPECIFIC)
1588                 return;
1589
1590         if (len < 4)
1591                 return;
1592
1593         if (WPA_GET_BE24(data) != OUI_WFA)
1594                 return;
1595         data += 3;
1596         len -= 3;
1597
1598         if (*data != P2P_OUI_TYPE)
1599                 return;
1600         data++;
1601         len--;
1602
1603         /* P2P action frame */
1604         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1605                 "P2P: RX P2P Action from " MACSTR, MAC2STR(sa));
1606         wpa_hexdump(MSG_MSGDUMP, "P2P: P2P Action contents", data, len);
1607
1608         if (len < 1)
1609                 return;
1610         switch (data[0]) {
1611         case P2P_NOA:
1612                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1613                         "P2P: Received P2P Action - Notice of Absence");
1614                 /* TODO */
1615                 break;
1616         case P2P_PRESENCE_REQ:
1617                 p2p_process_presence_req(p2p, da, sa, data + 1, len - 1, freq);
1618                 break;
1619         case P2P_PRESENCE_RESP:
1620                 p2p_process_presence_resp(p2p, da, sa, data + 1, len - 1);
1621                 break;
1622         case P2P_GO_DISC_REQ:
1623                 p2p_process_go_disc_req(p2p, da, sa, data + 1, len - 1, freq);
1624                 break;
1625         default:
1626                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1627                         "P2P: Received P2P Action - unknown type %u", data[0]);
1628                 break;
1629         }
1630 }
1631
1632
1633 static void p2p_go_neg_start(void *eloop_ctx, void *timeout_ctx)
1634 {
1635         struct p2p_data *p2p = eloop_ctx;
1636         if (p2p->go_neg_peer == NULL)
1637                 return;
1638         p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1639         p2p->go_neg_peer->status = P2P_SC_SUCCESS;
1640         p2p_connect_send(p2p, p2p->go_neg_peer);
1641 }
1642
1643
1644 static void p2p_invite_start(void *eloop_ctx, void *timeout_ctx)
1645 {
1646         struct p2p_data *p2p = eloop_ctx;
1647         if (p2p->invite_peer == NULL)
1648                 return;
1649         p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1650         p2p_invite_send(p2p, p2p->invite_peer, p2p->invite_go_dev_addr);
1651 }
1652
1653
1654 static void p2p_add_dev_from_probe_req(struct p2p_data *p2p, const u8 *addr,
1655                                        const u8 *ie, size_t ie_len)
1656 {
1657         struct p2p_message msg;
1658         struct p2p_device *dev;
1659
1660         os_memset(&msg, 0, sizeof(msg));
1661         if (p2p_parse_ies(ie, ie_len, &msg) < 0 || msg.p2p_attributes == NULL)
1662         {
1663                 p2p_parse_free(&msg);
1664                 return; /* not a P2P probe */
1665         }
1666
1667         if (msg.ssid == NULL || msg.ssid[1] != P2P_WILDCARD_SSID_LEN ||
1668             os_memcmp(msg.ssid + 2, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN)
1669             != 0) {
1670                 /* The Probe Request is not part of P2P Device Discovery. It is
1671                  * not known whether the source address of the frame is the P2P
1672                  * Device Address or P2P Interface Address. Do not add a new
1673                  * peer entry based on this frames.
1674                  */
1675                 p2p_parse_free(&msg);
1676                 return;
1677         }
1678
1679         dev = p2p_get_device(p2p, addr);
1680         if (dev) {
1681                 if (dev->country[0] == 0 && msg.listen_channel)
1682                         os_memcpy(dev->country, msg.listen_channel, 3);
1683                 os_get_time(&dev->last_seen);
1684                 p2p_parse_free(&msg);
1685                 return; /* already known */
1686         }
1687
1688         dev = p2p_create_device(p2p, addr);
1689         if (dev == NULL) {
1690                 p2p_parse_free(&msg);
1691                 return;
1692         }
1693
1694         os_get_time(&dev->last_seen);
1695         dev->flags |= P2P_DEV_PROBE_REQ_ONLY;
1696
1697         if (msg.listen_channel) {
1698                 os_memcpy(dev->country, msg.listen_channel, 3);
1699                 dev->listen_freq = p2p_channel_to_freq(dev->country,
1700                                                        msg.listen_channel[3],
1701                                                        msg.listen_channel[4]);
1702         }
1703
1704         p2p_copy_wps_info(dev, 1, &msg);
1705
1706         p2p_parse_free(&msg);
1707
1708         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1709                 "P2P: Created device entry based on Probe Req: " MACSTR
1710                 " dev_capab=0x%x group_capab=0x%x name='%s' listen_freq=%d",
1711                 MAC2STR(dev->info.p2p_device_addr), dev->info.dev_capab,
1712                 dev->info.group_capab, dev->info.device_name,
1713                 dev->listen_freq);
1714 }
1715
1716
1717 struct p2p_device * p2p_add_dev_from_go_neg_req(struct p2p_data *p2p,
1718                                                 const u8 *addr,
1719                                                 struct p2p_message *msg)
1720 {
1721         struct p2p_device *dev;
1722
1723         dev = p2p_get_device(p2p, addr);
1724         if (dev) {
1725                 os_get_time(&dev->last_seen);
1726                 return dev; /* already known */
1727         }
1728
1729         dev = p2p_create_device(p2p, addr);
1730         if (dev == NULL)
1731                 return NULL;
1732
1733         p2p_add_dev_info(p2p, addr, dev, msg);
1734
1735         return dev;
1736 }
1737
1738
1739 static int dev_type_match(const u8 *dev_type, const u8 *req_dev_type)
1740 {
1741         if (os_memcmp(dev_type, req_dev_type, WPS_DEV_TYPE_LEN) == 0)
1742                 return 1;
1743         if (os_memcmp(dev_type, req_dev_type, 2) == 0 &&
1744             WPA_GET_BE32(&req_dev_type[2]) == 0 &&
1745             WPA_GET_BE16(&req_dev_type[6]) == 0)
1746                 return 1; /* Category match with wildcard OUI/sub-category */
1747         return 0;
1748 }
1749
1750
1751 int dev_type_list_match(const u8 *dev_type, const u8 *req_dev_type[],
1752                         size_t num_req_dev_type)
1753 {
1754         size_t i;
1755         for (i = 0; i < num_req_dev_type; i++) {
1756                 if (dev_type_match(dev_type, req_dev_type[i]))
1757                         return 1;
1758         }
1759         return 0;
1760 }
1761
1762
1763 /**
1764  * p2p_match_dev_type - Match local device type with requested type
1765  * @p2p: P2P module context from p2p_init()
1766  * @wps: WPS TLVs from Probe Request frame (concatenated WPS IEs)
1767  * Returns: 1 on match, 0 on mismatch
1768  *
1769  * This function can be used to match the Requested Device Type attribute in
1770  * WPS IE with the local device types for deciding whether to reply to a Probe
1771  * Request frame.
1772  */
1773 int p2p_match_dev_type(struct p2p_data *p2p, struct wpabuf *wps)
1774 {
1775         struct wps_parse_attr attr;
1776         size_t i;
1777
1778         if (wps_parse_msg(wps, &attr))
1779                 return 1; /* assume no Requested Device Type attributes */
1780
1781         if (attr.num_req_dev_type == 0)
1782                 return 1; /* no Requested Device Type attributes -> match */
1783
1784         if (dev_type_list_match(p2p->cfg->pri_dev_type, attr.req_dev_type,
1785                                 attr.num_req_dev_type))
1786                 return 1; /* Own Primary Device Type matches */
1787
1788         for (i = 0; i < p2p->cfg->num_sec_dev_types; i++)
1789                 if (dev_type_list_match(p2p->cfg->sec_dev_type[i],
1790                                         attr.req_dev_type,
1791                                         attr.num_req_dev_type))
1792                 return 1; /* Own Secondary Device Type matches */
1793
1794         /* No matching device type found */
1795         return 0;
1796 }
1797
1798
1799 struct wpabuf * p2p_build_probe_resp_ies(struct p2p_data *p2p)
1800 {
1801         struct wpabuf *buf;
1802         u8 *len;
1803         int pw_id = -1;
1804
1805         buf = wpabuf_alloc(1000);
1806         if (buf == NULL)
1807                 return NULL;
1808
1809         if (p2p->go_neg_peer) {
1810                 /* Advertise immediate availability of WPS credential */
1811                 pw_id = p2p_wps_method_pw_id(p2p->go_neg_peer->wps_method);
1812         }
1813
1814         p2p_build_wps_ie(p2p, buf, pw_id, 1);
1815
1816         /* P2P IE */
1817         len = p2p_buf_add_ie_hdr(buf);
1818         p2p_buf_add_capability(buf, p2p->dev_capab, 0);
1819         if (p2p->ext_listen_interval)
1820                 p2p_buf_add_ext_listen_timing(buf, p2p->ext_listen_period,
1821                                               p2p->ext_listen_interval);
1822         p2p_buf_add_device_info(buf, p2p, NULL);
1823         p2p_buf_update_ie_hdr(buf, len);
1824
1825         return buf;
1826 }
1827
1828
1829 static int is_11b(u8 rate)
1830 {
1831         return rate == 0x02 || rate == 0x04 || rate == 0x0b || rate == 0x16;
1832 }
1833
1834
1835 static int supp_rates_11b_only(struct ieee802_11_elems *elems)
1836 {
1837         int num_11b = 0, num_others = 0;
1838         int i;
1839
1840         if (elems->supp_rates == NULL && elems->ext_supp_rates == NULL)
1841                 return 0;
1842
1843         for (i = 0; elems->supp_rates && i < elems->supp_rates_len; i++) {
1844                 if (is_11b(elems->supp_rates[i]))
1845                         num_11b++;
1846                 else
1847                         num_others++;
1848         }
1849
1850         for (i = 0; elems->ext_supp_rates && i < elems->ext_supp_rates_len;
1851              i++) {
1852                 if (is_11b(elems->ext_supp_rates[i]))
1853                         num_11b++;
1854                 else
1855                         num_others++;
1856         }
1857
1858         return num_11b > 0 && num_others == 0;
1859 }
1860
1861
1862 static enum p2p_probe_req_status
1863 p2p_reply_probe(struct p2p_data *p2p, const u8 *addr, const u8 *dst,
1864                 const u8 *bssid, const u8 *ie, size_t ie_len)
1865 {
1866         struct ieee802_11_elems elems;
1867         struct wpabuf *buf;
1868         struct ieee80211_mgmt *resp;
1869         struct p2p_message msg;
1870         struct wpabuf *ies;
1871
1872         if (!p2p->in_listen || !p2p->drv_in_listen) {
1873                 /* not in Listen state - ignore Probe Request */
1874                 return P2P_PREQ_NOT_LISTEN;
1875         }
1876
1877         if (ieee802_11_parse_elems((u8 *) ie, ie_len, &elems, 0) ==
1878             ParseFailed) {
1879                 /* Ignore invalid Probe Request frames */
1880                 return P2P_PREQ_MALFORMED;
1881         }
1882
1883         if (elems.p2p == NULL) {
1884                 /* not a P2P probe - ignore it */
1885                 return P2P_PREQ_NOT_P2P;
1886         }
1887
1888         if (dst && !is_broadcast_ether_addr(dst) &&
1889             os_memcmp(dst, p2p->cfg->dev_addr, ETH_ALEN) != 0) {
1890                 /* Not sent to the broadcast address or our P2P Device Address
1891                  */
1892                 return P2P_PREQ_NOT_PROCESSED;
1893         }
1894
1895         if (bssid && !is_broadcast_ether_addr(bssid)) {
1896                 /* Not sent to the Wildcard BSSID */
1897                 return P2P_PREQ_NOT_PROCESSED;
1898         }
1899
1900         if (elems.ssid == NULL || elems.ssid_len != P2P_WILDCARD_SSID_LEN ||
1901             os_memcmp(elems.ssid, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN) !=
1902             0) {
1903                 /* not using P2P Wildcard SSID - ignore */
1904                 return P2P_PREQ_NOT_PROCESSED;
1905         }
1906
1907         if (supp_rates_11b_only(&elems)) {
1908                 /* Indicates support for 11b rates only */
1909                 return P2P_PREQ_NOT_P2P;
1910         }
1911
1912         os_memset(&msg, 0, sizeof(msg));
1913         if (p2p_parse_ies(ie, ie_len, &msg) < 0) {
1914                 /* Could not parse P2P attributes */
1915                 return P2P_PREQ_NOT_P2P;
1916         }
1917
1918         if (msg.device_id &&
1919             os_memcmp(msg.device_id, p2p->cfg->dev_addr, ETH_ALEN) != 0) {
1920                 /* Device ID did not match */
1921                 p2p_parse_free(&msg);
1922                 return P2P_PREQ_NOT_PROCESSED;
1923         }
1924
1925         /* Check Requested Device Type match */
1926         if (msg.wps_attributes &&
1927             !p2p_match_dev_type(p2p, msg.wps_attributes)) {
1928                 /* No match with Requested Device Type */
1929                 p2p_parse_free(&msg);
1930                 return P2P_PREQ_NOT_PROCESSED;
1931         }
1932         p2p_parse_free(&msg);
1933
1934         if (!p2p->cfg->send_probe_resp) {
1935                 /* Response generated elsewhere */
1936                 return P2P_PREQ_NOT_PROCESSED;
1937         }
1938
1939         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1940                 "P2P: Reply to P2P Probe Request in Listen state");
1941
1942         /*
1943          * We do not really have a specific BSS that this frame is advertising,
1944          * so build a frame that has some information in valid format. This is
1945          * really only used for discovery purposes, not to learn exact BSS
1946          * parameters.
1947          */
1948         ies = p2p_build_probe_resp_ies(p2p);
1949         if (ies == NULL)
1950                 return P2P_PREQ_NOT_PROCESSED;
1951
1952         buf = wpabuf_alloc(200 + wpabuf_len(ies));
1953         if (buf == NULL) {
1954                 wpabuf_free(ies);
1955                 return P2P_PREQ_NOT_PROCESSED;
1956         }
1957
1958         resp = NULL;
1959         resp = wpabuf_put(buf, resp->u.probe_resp.variable - (u8 *) resp);
1960
1961         resp->frame_control = host_to_le16((WLAN_FC_TYPE_MGMT << 2) |
1962                                            (WLAN_FC_STYPE_PROBE_RESP << 4));
1963         os_memcpy(resp->da, addr, ETH_ALEN);
1964         os_memcpy(resp->sa, p2p->cfg->dev_addr, ETH_ALEN);
1965         os_memcpy(resp->bssid, p2p->cfg->dev_addr, ETH_ALEN);
1966         resp->u.probe_resp.beacon_int = host_to_le16(100);
1967         /* hardware or low-level driver will setup seq_ctrl and timestamp */
1968         resp->u.probe_resp.capab_info =
1969                 host_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE |
1970                              WLAN_CAPABILITY_PRIVACY |
1971                              WLAN_CAPABILITY_SHORT_SLOT_TIME);
1972
1973         wpabuf_put_u8(buf, WLAN_EID_SSID);
1974         wpabuf_put_u8(buf, P2P_WILDCARD_SSID_LEN);
1975         wpabuf_put_data(buf, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN);
1976
1977         wpabuf_put_u8(buf, WLAN_EID_SUPP_RATES);
1978         wpabuf_put_u8(buf, 8);
1979         wpabuf_put_u8(buf, (60 / 5) | 0x80);
1980         wpabuf_put_u8(buf, 90 / 5);
1981         wpabuf_put_u8(buf, (120 / 5) | 0x80);
1982         wpabuf_put_u8(buf, 180 / 5);
1983         wpabuf_put_u8(buf, (240 / 5) | 0x80);
1984         wpabuf_put_u8(buf, 360 / 5);
1985         wpabuf_put_u8(buf, 480 / 5);
1986         wpabuf_put_u8(buf, 540 / 5);
1987
1988         wpabuf_put_u8(buf, WLAN_EID_DS_PARAMS);
1989         wpabuf_put_u8(buf, 1);
1990         wpabuf_put_u8(buf, p2p->cfg->channel);
1991
1992         wpabuf_put_buf(buf, ies);
1993         wpabuf_free(ies);
1994
1995         p2p->cfg->send_probe_resp(p2p->cfg->cb_ctx, buf);
1996
1997         wpabuf_free(buf);
1998
1999         return P2P_PREQ_NOT_PROCESSED;
2000 }
2001
2002
2003 enum p2p_probe_req_status
2004 p2p_probe_req_rx(struct p2p_data *p2p, const u8 *addr, const u8 *dst,
2005                  const u8 *bssid, const u8 *ie, size_t ie_len)
2006 {
2007         enum p2p_probe_req_status res;
2008
2009         p2p_add_dev_from_probe_req(p2p, addr, ie, ie_len);
2010
2011         res = p2p_reply_probe(p2p, addr, dst, bssid, ie, ie_len);
2012
2013         if ((p2p->state == P2P_CONNECT || p2p->state == P2P_CONNECT_LISTEN) &&
2014             p2p->go_neg_peer &&
2015             os_memcmp(addr, p2p->go_neg_peer->info.p2p_device_addr, ETH_ALEN)
2016             == 0) {
2017                 /* Received a Probe Request from GO Negotiation peer */
2018                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2019                         "P2P: Found GO Negotiation peer - try to start GO "
2020                         "negotiation from timeout");
2021                 eloop_register_timeout(0, 0, p2p_go_neg_start, p2p, NULL);
2022                 return P2P_PREQ_PROCESSED;
2023         }
2024
2025         if ((p2p->state == P2P_INVITE || p2p->state == P2P_INVITE_LISTEN) &&
2026             p2p->invite_peer &&
2027             os_memcmp(addr, p2p->invite_peer->info.p2p_device_addr, ETH_ALEN)
2028             == 0) {
2029                 /* Received a Probe Request from Invite peer */
2030                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2031                         "P2P: Found Invite peer - try to start Invite from "
2032                         "timeout");
2033                 eloop_register_timeout(0, 0, p2p_invite_start, p2p, NULL);
2034                 return P2P_PREQ_PROCESSED;
2035         }
2036
2037         return res;
2038 }
2039
2040
2041 static int p2p_assoc_req_ie_wlan_ap(struct p2p_data *p2p, const u8 *bssid,
2042                                     u8 *buf, size_t len, struct wpabuf *p2p_ie)
2043 {
2044         struct wpabuf *tmp;
2045         u8 *lpos;
2046         size_t tmplen;
2047         int res;
2048         u8 group_capab;
2049
2050         if (p2p_ie == NULL)
2051                 return 0; /* WLAN AP is not a P2P manager */
2052
2053         /*
2054          * (Re)Association Request - P2P IE
2055          * P2P Capability attribute (shall be present)
2056          * P2P Interface attribute (present if concurrent device and
2057          *      P2P Management is enabled)
2058          */
2059         tmp = wpabuf_alloc(200);
2060         if (tmp == NULL)
2061                 return -1;
2062
2063         lpos = p2p_buf_add_ie_hdr(tmp);
2064         group_capab = 0;
2065         if (p2p->num_groups > 0) {
2066                 group_capab |= P2P_GROUP_CAPAB_GROUP_OWNER;
2067                 if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) &&
2068                     (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED) &&
2069                     p2p->cross_connect)
2070                         group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
2071         }
2072         p2p_buf_add_capability(tmp, p2p->dev_capab, group_capab);
2073         if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) &&
2074             (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED))
2075                 p2p_buf_add_p2p_interface(tmp, p2p);
2076         p2p_buf_update_ie_hdr(tmp, lpos);
2077
2078         tmplen = wpabuf_len(tmp);
2079         if (tmplen > len)
2080                 res = -1;
2081         else {
2082                 os_memcpy(buf, wpabuf_head(tmp), tmplen);
2083                 res = tmplen;
2084         }
2085         wpabuf_free(tmp);
2086
2087         return res;
2088 }
2089
2090
2091 int p2p_assoc_req_ie(struct p2p_data *p2p, const u8 *bssid, u8 *buf,
2092                      size_t len, int p2p_group, struct wpabuf *p2p_ie)
2093 {
2094         struct wpabuf *tmp;
2095         u8 *lpos;
2096         struct p2p_device *peer;
2097         size_t tmplen;
2098         int res;
2099
2100         if (!p2p_group)
2101                 return p2p_assoc_req_ie_wlan_ap(p2p, bssid, buf, len, p2p_ie);
2102
2103         /*
2104          * (Re)Association Request - P2P IE
2105          * P2P Capability attribute (shall be present)
2106          * Extended Listen Timing (may be present)
2107          * P2P Device Info attribute (shall be present)
2108          */
2109         tmp = wpabuf_alloc(200);
2110         if (tmp == NULL)
2111                 return -1;
2112
2113         peer = bssid ? p2p_get_device(p2p, bssid) : NULL;
2114
2115         lpos = p2p_buf_add_ie_hdr(tmp);
2116         p2p_buf_add_capability(tmp, p2p->dev_capab, 0);
2117         if (p2p->ext_listen_interval)
2118                 p2p_buf_add_ext_listen_timing(tmp, p2p->ext_listen_period,
2119                                               p2p->ext_listen_interval);
2120         p2p_buf_add_device_info(tmp, p2p, peer);
2121         p2p_buf_update_ie_hdr(tmp, lpos);
2122
2123         tmplen = wpabuf_len(tmp);
2124         if (tmplen > len)
2125                 res = -1;
2126         else {
2127                 os_memcpy(buf, wpabuf_head(tmp), tmplen);
2128                 res = tmplen;
2129         }
2130         wpabuf_free(tmp);
2131
2132         return res;
2133 }
2134
2135
2136 int p2p_scan_result_text(const u8 *ies, size_t ies_len, char *buf, char *end)
2137 {
2138         struct wpabuf *p2p_ie;
2139         int ret;
2140
2141         p2p_ie = ieee802_11_vendor_ie_concat(ies, ies_len, P2P_IE_VENDOR_TYPE);
2142         if (p2p_ie == NULL)
2143                 return 0;
2144
2145         ret = p2p_attr_text(p2p_ie, buf, end);
2146         wpabuf_free(p2p_ie);
2147         return ret;
2148 }
2149
2150
2151 int p2p_parse_dev_addr(const u8 *ies, size_t ies_len, u8 *dev_addr)
2152 {
2153         struct wpabuf *p2p_ie;
2154         struct p2p_message msg;
2155         int ret = -1;
2156
2157         p2p_ie = ieee802_11_vendor_ie_concat(ies, ies_len,
2158                                              P2P_IE_VENDOR_TYPE);
2159         if (p2p_ie == NULL)
2160                 return -1;
2161         os_memset(&msg, 0, sizeof(msg));
2162         if (p2p_parse_p2p_ie(p2p_ie, &msg)) {
2163                 wpabuf_free(p2p_ie);
2164                 return -1;
2165         }
2166
2167         if (msg.p2p_device_addr) {
2168                 os_memcpy(dev_addr, msg.p2p_device_addr, ETH_ALEN);
2169                 ret = 0;
2170         } else if (msg.device_id) {
2171                 os_memcpy(dev_addr, msg.device_id, ETH_ALEN);
2172                 ret = 0;
2173         }
2174
2175         wpabuf_free(p2p_ie);
2176         return ret;
2177 }
2178
2179
2180 static void p2p_clear_go_neg(struct p2p_data *p2p)
2181 {
2182         p2p->go_neg_peer = NULL;
2183         p2p_clear_timeout(p2p);
2184         p2p_set_state(p2p, P2P_IDLE);
2185 }
2186
2187
2188 void p2p_wps_success_cb(struct p2p_data *p2p, const u8 *mac_addr)
2189 {
2190         if (p2p->go_neg_peer == NULL) {
2191                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2192                         "P2P: No pending Group Formation - "
2193                         "ignore WPS registration success notification");
2194                 return; /* No pending Group Formation */
2195         }
2196
2197         if (os_memcmp(mac_addr, p2p->go_neg_peer->intended_addr, ETH_ALEN) !=
2198             0) {
2199                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2200                         "P2P: Ignore WPS registration success notification "
2201                         "for " MACSTR " (GO Negotiation peer " MACSTR ")",
2202                         MAC2STR(mac_addr),
2203                         MAC2STR(p2p->go_neg_peer->intended_addr));
2204                 return; /* Ignore unexpected peer address */
2205         }
2206
2207         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2208                 "P2P: Group Formation completed successfully with " MACSTR,
2209                 MAC2STR(mac_addr));
2210
2211         p2p_clear_go_neg(p2p);
2212 }
2213
2214
2215 void p2p_group_formation_failed(struct p2p_data *p2p)
2216 {
2217         if (p2p->go_neg_peer == NULL) {
2218                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2219                         "P2P: No pending Group Formation - "
2220                         "ignore group formation failure notification");
2221                 return; /* No pending Group Formation */
2222         }
2223
2224         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2225                 "P2P: Group Formation failed with " MACSTR,
2226                 MAC2STR(p2p->go_neg_peer->intended_addr));
2227
2228         p2p_clear_go_neg(p2p);
2229 }
2230
2231
2232 struct p2p_data * p2p_init(const struct p2p_config *cfg)
2233 {
2234         struct p2p_data *p2p;
2235
2236         if (cfg->max_peers < 1)
2237                 return NULL;
2238
2239         p2p = os_zalloc(sizeof(*p2p) + sizeof(*cfg));
2240         if (p2p == NULL)
2241                 return NULL;
2242         p2p->cfg = (struct p2p_config *) (p2p + 1);
2243         os_memcpy(p2p->cfg, cfg, sizeof(*cfg));
2244         if (cfg->dev_name)
2245                 p2p->cfg->dev_name = os_strdup(cfg->dev_name);
2246         if (cfg->manufacturer)
2247                 p2p->cfg->manufacturer = os_strdup(cfg->manufacturer);
2248         if (cfg->model_name)
2249                 p2p->cfg->model_name = os_strdup(cfg->model_name);
2250         if (cfg->model_number)
2251                 p2p->cfg->model_number = os_strdup(cfg->model_number);
2252         if (cfg->serial_number)
2253                 p2p->cfg->serial_number = os_strdup(cfg->serial_number);
2254         if (cfg->pref_chan) {
2255                 p2p->cfg->pref_chan = os_malloc(cfg->num_pref_chan *
2256                                                 sizeof(struct p2p_channel));
2257                 if (p2p->cfg->pref_chan) {
2258                         os_memcpy(p2p->cfg->pref_chan, cfg->pref_chan,
2259                                   cfg->num_pref_chan *
2260                                   sizeof(struct p2p_channel));
2261                 } else
2262                         p2p->cfg->num_pref_chan = 0;
2263         }
2264
2265         p2p->min_disc_int = 1;
2266         p2p->max_disc_int = 3;
2267
2268         os_get_random(&p2p->next_tie_breaker, 1);
2269         p2p->next_tie_breaker &= 0x01;
2270         if (cfg->sd_request)
2271                 p2p->dev_capab |= P2P_DEV_CAPAB_SERVICE_DISCOVERY;
2272         p2p->dev_capab |= P2P_DEV_CAPAB_INVITATION_PROCEDURE;
2273         if (cfg->concurrent_operations)
2274                 p2p->dev_capab |= P2P_DEV_CAPAB_CONCURRENT_OPER;
2275         p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
2276
2277         dl_list_init(&p2p->devices);
2278
2279         eloop_register_timeout(P2P_PEER_EXPIRATION_INTERVAL, 0,
2280                                p2p_expiration_timeout, p2p, NULL);
2281
2282         return p2p;
2283 }
2284
2285
2286 void p2p_deinit(struct p2p_data *p2p)
2287 {
2288         eloop_cancel_timeout(p2p_expiration_timeout, p2p, NULL);
2289         eloop_cancel_timeout(p2p_ext_listen_timeout, p2p, NULL);
2290         eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
2291         p2p_flush(p2p);
2292         p2p_free_req_dev_types(p2p);
2293         os_free(p2p->cfg->dev_name);
2294         os_free(p2p->cfg->manufacturer);
2295         os_free(p2p->cfg->model_name);
2296         os_free(p2p->cfg->model_number);
2297         os_free(p2p->cfg->serial_number);
2298         os_free(p2p->cfg->pref_chan);
2299         os_free(p2p->groups);
2300         wpabuf_free(p2p->sd_resp);
2301         os_free(p2p->after_scan_tx);
2302         p2p_remove_wps_vendor_extensions(p2p);
2303         os_free(p2p);
2304 }
2305
2306
2307 void p2p_flush(struct p2p_data *p2p)
2308 {
2309         struct p2p_device *dev, *prev;
2310         p2p_stop_find(p2p);
2311         dl_list_for_each_safe(dev, prev, &p2p->devices, struct p2p_device,
2312                               list) {
2313                 dl_list_del(&dev->list);
2314                 p2p_device_free(p2p, dev);
2315         }
2316         p2p_free_sd_queries(p2p);
2317         os_free(p2p->after_scan_tx);
2318         p2p->after_scan_tx = NULL;
2319 }
2320
2321
2322 int p2p_unauthorize(struct p2p_data *p2p, const u8 *addr)
2323 {
2324         struct p2p_device *dev;
2325
2326         dev = p2p_get_device(p2p, addr);
2327         if (dev == NULL)
2328                 return -1;
2329
2330         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Unauthorizing " MACSTR,
2331                 MAC2STR(addr));
2332
2333         if (p2p->go_neg_peer == dev)
2334                 p2p->go_neg_peer = NULL;
2335
2336         dev->wps_method = WPS_NOT_READY;
2337         dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
2338         dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM;
2339
2340         /* Check if after_scan_tx is for this peer. If so free it */
2341         if (p2p->after_scan_tx &&
2342             os_memcmp(addr, p2p->after_scan_tx->dst, ETH_ALEN) == 0) {
2343                 os_free(p2p->after_scan_tx);
2344                 p2p->after_scan_tx = NULL;
2345         }
2346
2347         return 0;
2348 }
2349
2350
2351 int p2p_set_dev_name(struct p2p_data *p2p, const char *dev_name)
2352 {
2353         os_free(p2p->cfg->dev_name);
2354         if (dev_name) {
2355                 p2p->cfg->dev_name = os_strdup(dev_name);
2356                 if (p2p->cfg->dev_name == NULL)
2357                         return -1;
2358         } else
2359                 p2p->cfg->dev_name = NULL;
2360         return 0;
2361 }
2362
2363
2364 int p2p_set_manufacturer(struct p2p_data *p2p, const char *manufacturer)
2365 {
2366         os_free(p2p->cfg->manufacturer);
2367         p2p->cfg->manufacturer = NULL;
2368         if (manufacturer) {
2369                 p2p->cfg->manufacturer = os_strdup(manufacturer);
2370                 if (p2p->cfg->manufacturer == NULL)
2371                         return -1;
2372         }
2373
2374         return 0;
2375 }
2376
2377
2378 int p2p_set_model_name(struct p2p_data *p2p, const char *model_name)
2379 {
2380         os_free(p2p->cfg->model_name);
2381         p2p->cfg->model_name = NULL;
2382         if (model_name) {
2383                 p2p->cfg->model_name = os_strdup(model_name);
2384                 if (p2p->cfg->model_name == NULL)
2385                         return -1;
2386         }
2387
2388         return 0;
2389 }
2390
2391
2392 int p2p_set_model_number(struct p2p_data *p2p, const char *model_number)
2393 {
2394         os_free(p2p->cfg->model_number);
2395         p2p->cfg->model_number = NULL;
2396         if (model_number) {
2397                 p2p->cfg->model_number = os_strdup(model_number);
2398                 if (p2p->cfg->model_number == NULL)
2399                         return -1;
2400         }
2401
2402         return 0;
2403 }
2404
2405
2406 int p2p_set_serial_number(struct p2p_data *p2p, const char *serial_number)
2407 {
2408         os_free(p2p->cfg->serial_number);
2409         p2p->cfg->serial_number = NULL;
2410         if (serial_number) {
2411                 p2p->cfg->serial_number = os_strdup(serial_number);
2412                 if (p2p->cfg->serial_number == NULL)
2413                         return -1;
2414         }
2415
2416         return 0;
2417 }
2418
2419
2420 void p2p_set_config_methods(struct p2p_data *p2p, u16 config_methods)
2421 {
2422         p2p->cfg->config_methods = config_methods;
2423 }
2424
2425
2426 void p2p_set_uuid(struct p2p_data *p2p, const u8 *uuid)
2427 {
2428         os_memcpy(p2p->cfg->uuid, uuid, 16);
2429 }
2430
2431
2432 int p2p_set_pri_dev_type(struct p2p_data *p2p, const u8 *pri_dev_type)
2433 {
2434         os_memcpy(p2p->cfg->pri_dev_type, pri_dev_type, 8);
2435         return 0;
2436 }
2437
2438
2439 int p2p_set_sec_dev_types(struct p2p_data *p2p, const u8 dev_types[][8],
2440                           size_t num_dev_types)
2441 {
2442         if (num_dev_types > P2P_SEC_DEVICE_TYPES)
2443                 num_dev_types = P2P_SEC_DEVICE_TYPES;
2444         p2p->cfg->num_sec_dev_types = num_dev_types;
2445         os_memcpy(p2p->cfg->sec_dev_type, dev_types, num_dev_types * 8);
2446         return 0;
2447 }
2448
2449
2450 void p2p_remove_wps_vendor_extensions(struct p2p_data *p2p)
2451 {
2452         int i;
2453
2454         for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
2455                 wpabuf_free(p2p->wps_vendor_ext[i]);
2456                 p2p->wps_vendor_ext[i] = NULL;
2457         }
2458 }
2459
2460
2461 int p2p_add_wps_vendor_extension(struct p2p_data *p2p,
2462                                  const struct wpabuf *vendor_ext)
2463 {
2464         int i;
2465
2466         if (vendor_ext == NULL)
2467                 return -1;
2468
2469         for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
2470                 if (p2p->wps_vendor_ext[i] == NULL)
2471                         break;
2472         }
2473         if (i >= P2P_MAX_WPS_VENDOR_EXT)
2474                 return -1;
2475
2476         p2p->wps_vendor_ext[i] = wpabuf_dup(vendor_ext);
2477         if (p2p->wps_vendor_ext[i] == NULL)
2478                 return -1;
2479
2480         return 0;
2481 }
2482
2483
2484 int p2p_set_country(struct p2p_data *p2p, const char *country)
2485 {
2486         os_memcpy(p2p->cfg->country, country, 3);
2487         return 0;
2488 }
2489
2490
2491 void p2p_continue_find(struct p2p_data *p2p)
2492 {
2493         struct p2p_device *dev;
2494         p2p_set_state(p2p, P2P_SEARCH);
2495         dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
2496                 if (dev->flags & P2P_DEV_SD_SCHEDULE) {
2497                         if (p2p_start_sd(p2p, dev) == 0)
2498                                 return;
2499                         else
2500                                 break;
2501                 } else if (dev->req_config_methods &&
2502                            !(dev->flags & P2P_DEV_PD_FOR_JOIN)) {
2503                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Send "
2504                                 "pending Provision Discovery Request to "
2505                                 MACSTR " (config methods 0x%x)",
2506                                 MAC2STR(dev->info.p2p_device_addr),
2507                                 dev->req_config_methods);
2508                         if (p2p_send_prov_disc_req(p2p, dev, 0, 0) == 0)
2509                                 return;
2510                 }
2511         }
2512
2513         p2p_listen_in_find(p2p);
2514 }
2515
2516
2517 static void p2p_sd_cb(struct p2p_data *p2p, int success)
2518 {
2519         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2520                 "P2P: Service Discovery Query TX callback: success=%d",
2521                 success);
2522         p2p->pending_action_state = P2P_NO_PENDING_ACTION;
2523
2524         if (!success) {
2525                 if (p2p->sd_peer) {
2526                         p2p->sd_peer->flags &= ~P2P_DEV_SD_SCHEDULE;
2527                         p2p->sd_peer = NULL;
2528                 }
2529                 p2p_continue_find(p2p);
2530                 return;
2531         }
2532
2533         if (p2p->sd_peer == NULL) {
2534                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2535                         "P2P: No SD peer entry known");
2536                 p2p_continue_find(p2p);
2537                 return;
2538         }
2539
2540         /* Wait for response from the peer */
2541         p2p_set_state(p2p, P2P_SD_DURING_FIND);
2542         p2p_set_timeout(p2p, 0, 200000);
2543 }
2544
2545
2546 /**
2547  * p2p_retry_pd - Retry any pending provision disc requests in IDLE state
2548  * @p2p: P2P module context from p2p_init()
2549  */
2550 static void p2p_retry_pd(struct p2p_data *p2p)
2551 {
2552         struct p2p_device *dev;
2553
2554         if (p2p->state != P2P_IDLE)
2555                 return;
2556
2557         /*
2558          * Retry the prov disc req attempt only for the peer that the user had
2559          * requested for and provided a join has not been initiated on it
2560          * in the meantime.
2561          */
2562
2563         dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
2564                 if (os_memcmp(p2p->pending_pd_devaddr,
2565                               dev->info.p2p_device_addr, ETH_ALEN) != 0)
2566                         continue;
2567                 if (!dev->req_config_methods)
2568                         continue;
2569                 if (dev->flags & P2P_DEV_PD_FOR_JOIN)
2570                         continue;
2571
2572                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Send "
2573                         "pending Provision Discovery Request to "
2574                         MACSTR " (config methods 0x%x)",
2575                         MAC2STR(dev->info.p2p_device_addr),
2576                         dev->req_config_methods);
2577                 p2p_send_prov_disc_req(p2p, dev, 0, 0);
2578                 return;
2579         }
2580 }
2581
2582
2583 static void p2p_prov_disc_cb(struct p2p_data *p2p, int success)
2584 {
2585         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2586                 "P2P: Provision Discovery Request TX callback: success=%d",
2587                 success);
2588
2589         /*
2590          * Postpone resetting the pending action state till after we actually
2591          * time out. This allows us to take some action like notifying any
2592          * interested parties about no response to the request.
2593          *
2594          * When the timer (below) goes off we check in IDLE, SEARCH, or
2595          * LISTEN_ONLY state, which are the only allowed states to issue a PD
2596          * requests in, if this was still pending and then raise notification.
2597          */
2598
2599         if (!success) {
2600                 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
2601
2602                 if (p2p->state != P2P_IDLE)
2603                         p2p_continue_find(p2p);
2604                 else if (p2p->user_initiated_pd) {
2605                         p2p->pending_action_state = P2P_PENDING_PD;
2606                         p2p_set_timeout(p2p, 0, 300000);
2607                 }
2608                 return;
2609         }
2610
2611         /*
2612          * This postponing, of resetting pending_action_state, needs to be
2613          * done only for user initiated PD requests and not internal ones.
2614          */
2615         if (p2p->user_initiated_pd)
2616                 p2p->pending_action_state = P2P_PENDING_PD;
2617         else
2618                 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
2619
2620         /* Wait for response from the peer */
2621         if (p2p->state == P2P_SEARCH)
2622                 p2p_set_state(p2p, P2P_PD_DURING_FIND);
2623         p2p_set_timeout(p2p, 0, 200000);
2624 }
2625
2626
2627 int p2p_scan_res_handler(struct p2p_data *p2p, const u8 *bssid, int freq,
2628                          int level, const u8 *ies, size_t ies_len)
2629 {
2630         p2p_add_device(p2p, bssid, freq, level, ies, ies_len, 1);
2631
2632         if (p2p->go_neg_peer && p2p->state == P2P_SEARCH &&
2633             os_memcmp(p2p->go_neg_peer->info.p2p_device_addr, bssid, ETH_ALEN)
2634             == 0) {
2635                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2636                         "P2P: Found GO Negotiation peer - try to start GO "
2637                         "negotiation");
2638                 p2p_connect_send(p2p, p2p->go_neg_peer);
2639                 return 1;
2640         }
2641
2642         return 0;
2643 }
2644
2645
2646 void p2p_scan_res_handled(struct p2p_data *p2p)
2647 {
2648         if (!p2p->p2p_scan_running) {
2649                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: p2p_scan was not "
2650                         "running, but scan results received");
2651         }
2652         p2p->p2p_scan_running = 0;
2653         eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
2654
2655         if (p2p_run_after_scan(p2p))
2656                 return;
2657         if (p2p->state == P2P_SEARCH)
2658                 p2p_continue_find(p2p);
2659 }
2660
2661
2662 void p2p_scan_ie(struct p2p_data *p2p, struct wpabuf *ies, const u8 *dev_id)
2663 {
2664         u8 *len = p2p_buf_add_ie_hdr(ies);
2665         p2p_buf_add_capability(ies, p2p->dev_capab, 0);
2666         if (dev_id)
2667                 p2p_buf_add_device_id(ies, dev_id);
2668         if (p2p->cfg->reg_class && p2p->cfg->channel)
2669                 p2p_buf_add_listen_channel(ies, p2p->cfg->country,
2670                                            p2p->cfg->reg_class,
2671                                            p2p->cfg->channel);
2672         if (p2p->ext_listen_interval)
2673                 p2p_buf_add_ext_listen_timing(ies, p2p->ext_listen_period,
2674                                               p2p->ext_listen_interval);
2675         /* TODO: p2p_buf_add_operating_channel() if GO */
2676         p2p_buf_update_ie_hdr(ies, len);
2677 }
2678
2679
2680 size_t p2p_scan_ie_buf_len(struct p2p_data *p2p)
2681 {
2682         return 100;
2683 }
2684
2685
2686 int p2p_ie_text(struct wpabuf *p2p_ie, char *buf, char *end)
2687 {
2688         return p2p_attr_text(p2p_ie, buf, end);
2689 }
2690
2691
2692 static void p2p_go_neg_req_cb(struct p2p_data *p2p, int success)
2693 {
2694         struct p2p_device *dev = p2p->go_neg_peer;
2695
2696         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2697                 "P2P: GO Negotiation Request TX callback: success=%d",
2698                 success);
2699
2700         if (dev == NULL) {
2701                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2702                         "P2P: No pending GO Negotiation");
2703                 return;
2704         }
2705
2706         if (success) {
2707                 if (dev->flags & P2P_DEV_USER_REJECTED) {
2708                         p2p_set_state(p2p, P2P_IDLE);
2709                         return;
2710                 }
2711         } else if (dev->go_neg_req_sent) {
2712                 /* Cancel the increment from p2p_connect_send() on failure */
2713                 dev->go_neg_req_sent--;
2714         }
2715
2716         if (!success &&
2717             (dev->info.dev_capab & P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY) &&
2718             !is_zero_ether_addr(dev->member_in_go_dev)) {
2719                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2720                         "P2P: Peer " MACSTR " did not acknowledge request - "
2721                         "try to use device discoverability through its GO",
2722                         MAC2STR(dev->info.p2p_device_addr));
2723                 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
2724                 p2p_send_dev_disc_req(p2p, dev);
2725                 return;
2726         }
2727
2728         /*
2729          * Use P2P find, if needed, to find the other device from its listen
2730          * channel.
2731          */
2732         p2p_set_state(p2p, P2P_CONNECT);
2733         p2p_set_timeout(p2p, 0, 100000);
2734 }
2735
2736
2737 static void p2p_go_neg_resp_cb(struct p2p_data *p2p, int success)
2738 {
2739         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2740                 "P2P: GO Negotiation Response TX callback: success=%d",
2741                 success);
2742         if (!p2p->go_neg_peer && p2p->state == P2P_PROVISIONING) {
2743                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2744                         "P2P: Ignore TX callback event - GO Negotiation is "
2745                         "not running anymore");
2746                 return;
2747         }
2748         p2p_set_state(p2p, P2P_CONNECT);
2749         p2p_set_timeout(p2p, 0, 100000);
2750 }
2751
2752
2753 static void p2p_go_neg_resp_failure_cb(struct p2p_data *p2p, int success)
2754 {
2755         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2756                 "P2P: GO Negotiation Response (failure) TX callback: "
2757                 "success=%d", success);
2758         if (p2p->go_neg_peer && p2p->go_neg_peer->status != P2P_SC_SUCCESS) {
2759                 p2p_go_neg_failed(p2p, p2p->go_neg_peer,
2760                                   p2p->go_neg_peer->status);
2761         }
2762 }
2763
2764
2765 static void p2p_go_neg_conf_cb(struct p2p_data *p2p,
2766                                enum p2p_send_action_result result)
2767 {
2768         struct p2p_device *dev;
2769
2770         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2771                 "P2P: GO Negotiation Confirm TX callback: result=%d",
2772                 result);
2773         p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
2774         if (result == P2P_SEND_ACTION_FAILED) {
2775                 p2p_go_neg_failed(p2p, p2p->go_neg_peer, -1);
2776                 return;
2777         }
2778         if (result == P2P_SEND_ACTION_NO_ACK) {
2779                 /*
2780                  * It looks like the TX status for GO Negotiation Confirm is
2781                  * often showing failure even when the peer has actually
2782                  * received the frame. Since the peer may change channels
2783                  * immediately after having received the frame, we may not see
2784                  * an Ack for retries, so just dropping a single frame may
2785                  * trigger this. To allow the group formation to succeed if the
2786                  * peer did indeed receive the frame, continue regardless of
2787                  * the TX status.
2788                  */
2789                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2790                         "P2P: Assume GO Negotiation Confirm TX was actually "
2791                         "received by the peer even though Ack was not "
2792                         "reported");
2793         }
2794
2795         dev = p2p->go_neg_peer;
2796         if (dev == NULL)
2797                 return;
2798
2799         p2p_go_complete(p2p, dev);
2800 }
2801
2802
2803 void p2p_send_action_cb(struct p2p_data *p2p, unsigned int freq, const u8 *dst,
2804                         const u8 *src, const u8 *bssid,
2805                         enum p2p_send_action_result result)
2806 {
2807         enum p2p_pending_action_state state;
2808         int success;
2809
2810         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2811                 "P2P: Action frame TX callback (state=%d freq=%u dst=" MACSTR
2812                 " src=" MACSTR " bssid=" MACSTR " result=%d",
2813                 p2p->pending_action_state, freq, MAC2STR(dst), MAC2STR(src),
2814                 MAC2STR(bssid), result);
2815         success = result == P2P_SEND_ACTION_SUCCESS;
2816         state = p2p->pending_action_state;
2817         p2p->pending_action_state = P2P_NO_PENDING_ACTION;
2818         switch (state) {
2819         case P2P_NO_PENDING_ACTION:
2820                 break;
2821         case P2P_PENDING_GO_NEG_REQUEST:
2822                 p2p_go_neg_req_cb(p2p, success);
2823                 break;
2824         case P2P_PENDING_GO_NEG_RESPONSE:
2825                 p2p_go_neg_resp_cb(p2p, success);
2826                 break;
2827         case P2P_PENDING_GO_NEG_RESPONSE_FAILURE:
2828                 p2p_go_neg_resp_failure_cb(p2p, success);
2829                 break;
2830         case P2P_PENDING_GO_NEG_CONFIRM:
2831                 p2p_go_neg_conf_cb(p2p, result);
2832                 break;
2833         case P2P_PENDING_SD:
2834                 p2p_sd_cb(p2p, success);
2835                 break;
2836         case P2P_PENDING_PD:
2837                 p2p_prov_disc_cb(p2p, success);
2838                 break;
2839         case P2P_PENDING_INVITATION_REQUEST:
2840                 p2p_invitation_req_cb(p2p, success);
2841                 break;
2842         case P2P_PENDING_INVITATION_RESPONSE:
2843                 p2p_invitation_resp_cb(p2p, success);
2844                 break;
2845         case P2P_PENDING_DEV_DISC_REQUEST:
2846                 p2p_dev_disc_req_cb(p2p, success);
2847                 break;
2848         case P2P_PENDING_DEV_DISC_RESPONSE:
2849                 p2p_dev_disc_resp_cb(p2p, success);
2850                 break;
2851         case P2P_PENDING_GO_DISC_REQ:
2852                 p2p_go_disc_req_cb(p2p, success);
2853                 break;
2854         }
2855 }
2856
2857
2858 void p2p_listen_cb(struct p2p_data *p2p, unsigned int freq,
2859                    unsigned int duration)
2860 {
2861         if (freq == p2p->pending_client_disc_freq) {
2862                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2863                         "P2P: Client discoverability remain-awake completed");
2864                 p2p->pending_client_disc_freq = 0;
2865                 return;
2866         }
2867
2868         if (freq != p2p->pending_listen_freq) {
2869                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2870                         "P2P: Unexpected listen callback for freq=%u "
2871                         "duration=%u (pending_listen_freq=%u)",
2872                         freq, duration, p2p->pending_listen_freq);
2873                 return;
2874         }
2875
2876         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2877                 "P2P: Starting Listen timeout(%u,%u) on freq=%u based on "
2878                 "callback",
2879                 p2p->pending_listen_sec, p2p->pending_listen_usec,
2880                 p2p->pending_listen_freq);
2881         p2p->in_listen = 1;
2882         p2p->drv_in_listen = freq;
2883         if (p2p->pending_listen_sec || p2p->pending_listen_usec) {
2884                 /*
2885                  * Add 20 msec extra wait to avoid race condition with driver
2886                  * remain-on-channel end event, i.e., give driver more time to
2887                  * complete the operation before our timeout expires.
2888                  */
2889                 p2p_set_timeout(p2p, p2p->pending_listen_sec,
2890                                 p2p->pending_listen_usec + 20000);
2891         }
2892
2893         p2p->pending_listen_freq = 0;
2894 }
2895
2896
2897 int p2p_listen_end(struct p2p_data *p2p, unsigned int freq)
2898 {
2899         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Driver ended Listen "
2900                 "state (freq=%u)", freq);
2901         p2p->drv_in_listen = 0;
2902         if (p2p->in_listen)
2903                 return 0; /* Internal timeout will trigger the next step */
2904
2905         if (p2p->state == P2P_CONNECT_LISTEN && p2p->go_neg_peer) {
2906                 if (p2p->go_neg_peer->connect_reqs >= 120) {
2907                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2908                                 "P2P: Timeout on sending GO Negotiation "
2909                                 "Request without getting response");
2910                         p2p_go_neg_failed(p2p, p2p->go_neg_peer, -1);
2911                         return 0;
2912                 }
2913
2914                 p2p_set_state(p2p, P2P_CONNECT);
2915                 p2p_connect_send(p2p, p2p->go_neg_peer);
2916                 return 1;
2917         } else if (p2p->state == P2P_SEARCH) {
2918                 if (p2p->p2p_scan_running) {
2919                          /*
2920                           * Search is already in progress. This can happen if
2921                           * an Action frame RX is reported immediately after
2922                           * the end of a remain-on-channel operation and the
2923                           * response frame to that is sent using an offchannel
2924                           * operation while in p2p_find. Avoid an attempt to
2925                           * restart a scan here.
2926                           */
2927                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: p2p_scan "
2928                                 "already in progress - do not try to start a "
2929                                 "new one");
2930                         return 1;
2931                 }
2932                 if (p2p->pending_listen_freq) {
2933                         /*
2934                          * Better wait a bit if the driver is unable to start
2935                          * offchannel operation for some reason. p2p_search()
2936                          * will be started from internal timeout.
2937                          */
2938                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Listen "
2939                                 "operation did not seem to start - delay "
2940                                 "search phase to avoid busy loop");
2941                         p2p_set_timeout(p2p, 0, 100000);
2942                         return 1;
2943                 }
2944                 p2p_search(p2p);
2945                 return 1;
2946         }
2947
2948         return 0;
2949 }
2950
2951
2952 static void p2p_timeout_connect(struct p2p_data *p2p)
2953 {
2954         p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
2955         if (p2p->go_neg_peer &&
2956             (p2p->go_neg_peer->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) {
2957                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Wait for GO "
2958                         "Negotiation Confirm timed out - assume GO "
2959                         "Negotiation failed");
2960                 p2p_go_neg_failed(p2p, p2p->go_neg_peer, -1);
2961                 return;
2962         }
2963         p2p_set_state(p2p, P2P_CONNECT_LISTEN);
2964         p2p_listen_in_find(p2p);
2965 }
2966
2967
2968 static void p2p_timeout_connect_listen(struct p2p_data *p2p)
2969 {
2970         if (p2p->go_neg_peer) {
2971                 if (p2p->drv_in_listen) {
2972                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Driver is "
2973                                 "still in Listen state; wait for it to "
2974                                 "complete");
2975                         return;
2976                 }
2977
2978                 if (p2p->go_neg_peer->connect_reqs >= 120) {
2979                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2980                                 "P2P: Timeout on sending GO Negotiation "
2981                                 "Request without getting response");
2982                         p2p_go_neg_failed(p2p, p2p->go_neg_peer, -1);
2983                         return;
2984                 }
2985
2986                 p2p_set_state(p2p, P2P_CONNECT);
2987                 p2p_connect_send(p2p, p2p->go_neg_peer);
2988         } else
2989                 p2p_set_state(p2p, P2P_IDLE);
2990 }
2991
2992
2993 static void p2p_timeout_wait_peer_connect(struct p2p_data *p2p)
2994 {
2995         /*
2996          * TODO: could remain constantly in Listen state for some time if there
2997          * are no other concurrent uses for the radio. For now, go to listen
2998          * state once per second to give other uses a chance to use the radio.
2999          */
3000         p2p_set_state(p2p, P2P_WAIT_PEER_IDLE);
3001         p2p_set_timeout(p2p, 0, 500000);
3002 }
3003
3004
3005 static void p2p_timeout_wait_peer_idle(struct p2p_data *p2p)
3006 {
3007         struct p2p_device *dev = p2p->go_neg_peer;
3008
3009         if (dev == NULL) {
3010                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3011                         "P2P: Unknown GO Neg peer - stop GO Neg wait");
3012                 return;
3013         }
3014
3015         dev->wait_count++;
3016         if (dev->wait_count >= 120) {
3017                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3018                         "P2P: Timeout on waiting peer to become ready for GO "
3019                         "Negotiation");
3020                 p2p_go_neg_failed(p2p, dev, -1);
3021                 return;
3022         }
3023
3024         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3025                 "P2P: Go to Listen state while waiting for the peer to become "
3026                 "ready for GO Negotiation");
3027         p2p_set_state(p2p, P2P_WAIT_PEER_CONNECT);
3028         p2p_listen_in_find(p2p);
3029 }
3030
3031
3032 static void p2p_timeout_sd_during_find(struct p2p_data *p2p)
3033 {
3034         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3035                 "P2P: Service Discovery Query timeout");
3036         if (p2p->sd_peer) {
3037                 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3038                 p2p->sd_peer->flags &= ~P2P_DEV_SD_SCHEDULE;
3039                 p2p->sd_peer = NULL;
3040         }
3041         p2p_continue_find(p2p);
3042 }
3043
3044
3045 static void p2p_timeout_prov_disc_during_find(struct p2p_data *p2p)
3046 {
3047         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3048                 "P2P: Provision Discovery Request timeout");
3049         p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3050         p2p_continue_find(p2p);
3051 }
3052
3053
3054 static void p2p_timeout_prov_disc_req(struct p2p_data *p2p)
3055 {
3056         p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3057
3058         /*
3059          * For user initiated PD requests that we have not gotten any responses
3060          * for while in IDLE state, we retry them a couple of times before
3061          * giving up.
3062          */
3063         if (!p2p->user_initiated_pd)
3064                 return;
3065
3066         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3067                 "P2P: User initiated Provision Discovery Request timeout");
3068
3069         if (p2p->pd_retries) {
3070                 p2p->pd_retries--;
3071                 p2p_retry_pd(p2p);
3072         } else {
3073                 if (p2p->cfg->prov_disc_fail)
3074                         p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx,
3075                                                  p2p->pending_pd_devaddr,
3076                                                  P2P_PROV_DISC_TIMEOUT);
3077                 p2p_reset_pending_pd(p2p);
3078         }
3079 }
3080
3081
3082 static void p2p_timeout_invite(struct p2p_data *p2p)
3083 {
3084         p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3085         p2p_set_state(p2p, P2P_INVITE_LISTEN);
3086         if (p2p->inv_role == P2P_INVITE_ROLE_ACTIVE_GO) {
3087                 /*
3088                  * Better remain on operating channel instead of listen channel
3089                  * when running a group.
3090                  */
3091                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Inviting in "
3092                         "active GO role - wait on operating channel");
3093                 p2p_set_timeout(p2p, 0, 100000);
3094                 return;
3095         }
3096         p2p_listen_in_find(p2p);
3097 }
3098
3099
3100 static void p2p_timeout_invite_listen(struct p2p_data *p2p)
3101 {
3102         if (p2p->invite_peer && p2p->invite_peer->invitation_reqs < 100) {
3103                 p2p_set_state(p2p, P2P_INVITE);
3104                 p2p_invite_send(p2p, p2p->invite_peer,
3105                                 p2p->invite_go_dev_addr);
3106         } else {
3107                 if (p2p->invite_peer) {
3108                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3109                                 "P2P: Invitation Request retry limit reached");
3110                         if (p2p->cfg->invitation_result)
3111                                 p2p->cfg->invitation_result(
3112                                         p2p->cfg->cb_ctx, -1, NULL);
3113                 }
3114                 p2p_set_state(p2p, P2P_IDLE);
3115         }
3116 }
3117
3118
3119 static void p2p_state_timeout(void *eloop_ctx, void *timeout_ctx)
3120 {
3121         struct p2p_data *p2p = eloop_ctx;
3122
3123         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Timeout (state=%s)",
3124                 p2p_state_txt(p2p->state));
3125
3126         p2p->in_listen = 0;
3127
3128         switch (p2p->state) {
3129         case P2P_IDLE:
3130                 /* Check if we timed out waiting for PD req */
3131                 if (p2p->pending_action_state == P2P_PENDING_PD)
3132                         p2p_timeout_prov_disc_req(p2p);
3133                 break;
3134         case P2P_SEARCH:
3135                 /* Check if we timed out waiting for PD req */
3136                 if (p2p->pending_action_state == P2P_PENDING_PD)
3137                         p2p_timeout_prov_disc_req(p2p);
3138                 p2p_search(p2p);
3139                 break;
3140         case P2P_CONNECT:
3141                 p2p_timeout_connect(p2p);
3142                 break;
3143         case P2P_CONNECT_LISTEN:
3144                 p2p_timeout_connect_listen(p2p);
3145                 break;
3146         case P2P_GO_NEG:
3147                 break;
3148         case P2P_LISTEN_ONLY:
3149                 /* Check if we timed out waiting for PD req */
3150                 if (p2p->pending_action_state == P2P_PENDING_PD)
3151                         p2p_timeout_prov_disc_req(p2p);
3152
3153                 if (p2p->ext_listen_only) {
3154                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3155                                 "P2P: Extended Listen Timing - Listen State "
3156                                 "completed");
3157                         p2p->ext_listen_only = 0;
3158                         p2p_set_state(p2p, P2P_IDLE);
3159                 }
3160                 break;
3161         case P2P_WAIT_PEER_CONNECT:
3162                 p2p_timeout_wait_peer_connect(p2p);
3163                 break;
3164         case P2P_WAIT_PEER_IDLE:
3165                 p2p_timeout_wait_peer_idle(p2p);
3166                 break;
3167         case P2P_SD_DURING_FIND:
3168                 p2p_timeout_sd_during_find(p2p);
3169                 break;
3170         case P2P_PROVISIONING:
3171                 break;
3172         case P2P_PD_DURING_FIND:
3173                 p2p_timeout_prov_disc_during_find(p2p);
3174                 break;
3175         case P2P_INVITE:
3176                 p2p_timeout_invite(p2p);
3177                 break;
3178         case P2P_INVITE_LISTEN:
3179                 p2p_timeout_invite_listen(p2p);
3180                 break;
3181         case P2P_SEARCH_WHEN_READY:
3182                 break;
3183         }
3184 }
3185
3186
3187 int p2p_reject(struct p2p_data *p2p, const u8 *peer_addr)
3188 {
3189         struct p2p_device *dev;
3190
3191         dev = p2p_get_device(p2p, peer_addr);
3192         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Local request to reject "
3193                 "connection attempts by peer " MACSTR, MAC2STR(peer_addr));
3194         if (dev == NULL) {
3195                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer " MACSTR
3196                         " unknown", MAC2STR(peer_addr));
3197                 return -1;
3198         }
3199         dev->status = P2P_SC_FAIL_REJECTED_BY_USER;
3200         dev->flags |= P2P_DEV_USER_REJECTED;
3201         return 0;
3202 }
3203
3204
3205 const char * p2p_wps_method_text(enum p2p_wps_method method)
3206 {
3207         switch (method) {
3208         case WPS_NOT_READY:
3209                 return "not-ready";
3210         case WPS_PIN_DISPLAY:
3211                 return "Display";
3212         case WPS_PIN_KEYPAD:
3213                 return "Keypad";
3214         case WPS_PBC:
3215                 return "PBC";
3216         }
3217
3218         return "??";
3219 }
3220
3221
3222 static const char * p2p_go_state_text(enum p2p_go_state go_state)
3223 {
3224         switch (go_state) {
3225         case UNKNOWN_GO:
3226                 return "unknown";
3227         case LOCAL_GO:
3228                 return "local";
3229         case  REMOTE_GO:
3230                 return "remote";
3231         }
3232
3233         return "??";
3234 }
3235
3236
3237 const struct p2p_peer_info * p2p_get_peer_info(struct p2p_data *p2p,
3238                                                const u8 *addr, int next)
3239 {
3240         struct p2p_device *dev;
3241
3242         if (addr)
3243                 dev = p2p_get_device(p2p, addr);
3244         else
3245                 dev = dl_list_first(&p2p->devices, struct p2p_device, list);
3246
3247         if (dev && next) {
3248                 dev = dl_list_first(&dev->list, struct p2p_device, list);
3249                 if (&dev->list == &p2p->devices)
3250                         dev = NULL;
3251         }
3252
3253         if (dev == NULL)
3254                 return NULL;
3255
3256         return &dev->info;
3257 }
3258
3259
3260 int p2p_get_peer_info_txt(const struct p2p_peer_info *info,
3261                           char *buf, size_t buflen)
3262 {
3263         struct p2p_device *dev;
3264         int res;
3265         char *pos, *end;
3266         struct os_time now;
3267
3268         if (info == NULL)
3269                 return -1;
3270
3271         dev = (struct p2p_device *) (((u8 *) info) -
3272                                      offsetof(struct p2p_device, info));
3273
3274         pos = buf;
3275         end = buf + buflen;
3276
3277         os_get_time(&now);
3278         res = os_snprintf(pos, end - pos,
3279                           "age=%d\n"
3280                           "listen_freq=%d\n"
3281                           "wps_method=%s\n"
3282                           "interface_addr=" MACSTR "\n"
3283                           "member_in_go_dev=" MACSTR "\n"
3284                           "member_in_go_iface=" MACSTR "\n"
3285                           "go_neg_req_sent=%d\n"
3286                           "go_state=%s\n"
3287                           "dialog_token=%u\n"
3288                           "intended_addr=" MACSTR "\n"
3289                           "country=%c%c\n"
3290                           "oper_freq=%d\n"
3291                           "req_config_methods=0x%x\n"
3292                           "flags=%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n"
3293                           "status=%d\n"
3294                           "wait_count=%u\n"
3295                           "invitation_reqs=%u\n",
3296                           (int) (now.sec - dev->last_seen.sec),
3297                           dev->listen_freq,
3298                           p2p_wps_method_text(dev->wps_method),
3299                           MAC2STR(dev->interface_addr),
3300                           MAC2STR(dev->member_in_go_dev),
3301                           MAC2STR(dev->member_in_go_iface),
3302                           dev->go_neg_req_sent,
3303                           p2p_go_state_text(dev->go_state),
3304                           dev->dialog_token,
3305                           MAC2STR(dev->intended_addr),
3306                           dev->country[0] ? dev->country[0] : '_',
3307                           dev->country[1] ? dev->country[1] : '_',
3308                           dev->oper_freq,
3309                           dev->req_config_methods,
3310                           dev->flags & P2P_DEV_PROBE_REQ_ONLY ?
3311                           "[PROBE_REQ_ONLY]" : "",
3312                           dev->flags & P2P_DEV_REPORTED ? "[REPORTED]" : "",
3313                           dev->flags & P2P_DEV_NOT_YET_READY ?
3314                           "[NOT_YET_READY]" : "",
3315                           dev->flags & P2P_DEV_SD_INFO ? "[SD_INFO]" : "",
3316                           dev->flags & P2P_DEV_SD_SCHEDULE ? "[SD_SCHEDULE]" :
3317                           "",
3318                           dev->flags & P2P_DEV_PD_PEER_DISPLAY ?
3319                           "[PD_PEER_DISPLAY]" : "",
3320                           dev->flags & P2P_DEV_PD_PEER_KEYPAD ?
3321                           "[PD_PEER_KEYPAD]" : "",
3322                           dev->flags & P2P_DEV_USER_REJECTED ?
3323                           "[USER_REJECTED]" : "",
3324                           dev->flags & P2P_DEV_PEER_WAITING_RESPONSE ?
3325                           "[PEER_WAITING_RESPONSE]" : "",
3326                           dev->flags & P2P_DEV_PREFER_PERSISTENT_GROUP ?
3327                           "[PREFER_PERSISTENT_GROUP]" : "",
3328                           dev->flags & P2P_DEV_WAIT_GO_NEG_RESPONSE ?
3329                           "[WAIT_GO_NEG_RESPONSE]" : "",
3330                           dev->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM ?
3331                           "[WAIT_GO_NEG_CONFIRM]" : "",
3332                           dev->flags & P2P_DEV_GROUP_CLIENT_ONLY ?
3333                           "[GROUP_CLIENT_ONLY]" : "",
3334                           dev->flags & P2P_DEV_FORCE_FREQ ?
3335                           "[FORCE_FREQ]" : "",
3336                           dev->flags & P2P_DEV_PD_FOR_JOIN ?
3337                           "[PD_FOR_JOIN]" : "",
3338                           dev->status,
3339                           dev->wait_count,
3340                           dev->invitation_reqs);
3341         if (res < 0 || res >= end - pos)
3342                 return pos - buf;
3343         pos += res;
3344
3345         if (dev->ext_listen_period) {
3346                 res = os_snprintf(pos, end - pos,
3347                                   "ext_listen_period=%u\n"
3348                                   "ext_listen_interval=%u\n",
3349                                   dev->ext_listen_period,
3350                                   dev->ext_listen_interval);
3351                 if (res < 0 || res >= end - pos)
3352                         return pos - buf;
3353                 pos += res;
3354         }
3355
3356         if (dev->oper_ssid_len) {
3357                 res = os_snprintf(pos, end - pos,
3358                                   "oper_ssid=%s\n",
3359                                   wpa_ssid_txt(dev->oper_ssid,
3360                                                dev->oper_ssid_len));
3361                 if (res < 0 || res >= end - pos)
3362                         return pos - buf;
3363                 pos += res;
3364         }
3365
3366         return pos - buf;
3367 }
3368
3369
3370 int p2p_peer_known(struct p2p_data *p2p, const u8 *addr)
3371 {
3372         return p2p_get_device(p2p, addr) != NULL;
3373 }
3374
3375
3376 void p2p_set_client_discoverability(struct p2p_data *p2p, int enabled)
3377 {
3378         if (enabled) {
3379                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Client "
3380                         "discoverability enabled");
3381                 p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
3382         } else {
3383                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Client "
3384                         "discoverability disabled");
3385                 p2p->dev_capab &= ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
3386         }
3387 }
3388
3389
3390 static struct wpabuf * p2p_build_presence_req(u32 duration1, u32 interval1,
3391                                               u32 duration2, u32 interval2)
3392 {
3393         struct wpabuf *req;
3394         struct p2p_noa_desc desc1, desc2, *ptr1 = NULL, *ptr2 = NULL;
3395         u8 *len;
3396
3397         req = wpabuf_alloc(100);
3398         if (req == NULL)
3399                 return NULL;
3400
3401         if (duration1 || interval1) {
3402                 os_memset(&desc1, 0, sizeof(desc1));
3403                 desc1.count_type = 1;
3404                 desc1.duration = duration1;
3405                 desc1.interval = interval1;
3406                 ptr1 = &desc1;
3407
3408                 if (duration2 || interval2) {
3409                         os_memset(&desc2, 0, sizeof(desc2));
3410                         desc2.count_type = 2;
3411                         desc2.duration = duration2;
3412                         desc2.interval = interval2;
3413                         ptr2 = &desc2;
3414                 }
3415         }
3416
3417         p2p_buf_add_action_hdr(req, P2P_PRESENCE_REQ, 1);
3418         len = p2p_buf_add_ie_hdr(req);
3419         p2p_buf_add_noa(req, 0, 0, 0, ptr1, ptr2);
3420         p2p_buf_update_ie_hdr(req, len);
3421
3422         return req;
3423 }
3424
3425
3426 int p2p_presence_req(struct p2p_data *p2p, const u8 *go_interface_addr,
3427                      const u8 *own_interface_addr, unsigned int freq,
3428                      u32 duration1, u32 interval1, u32 duration2,
3429                      u32 interval2)
3430 {
3431         struct wpabuf *req;
3432
3433         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Send Presence Request to "
3434                 "GO " MACSTR " (own interface " MACSTR ") freq=%u dur1=%u "
3435                 "int1=%u dur2=%u int2=%u",
3436                 MAC2STR(go_interface_addr), MAC2STR(own_interface_addr),
3437                 freq, duration1, interval1, duration2, interval2);
3438
3439         req = p2p_build_presence_req(duration1, interval1, duration2,
3440                                      interval2);
3441         if (req == NULL)
3442                 return -1;
3443
3444         p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3445         if (p2p_send_action(p2p, freq, go_interface_addr, own_interface_addr,
3446                             go_interface_addr,
3447                             wpabuf_head(req), wpabuf_len(req), 200) < 0) {
3448                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3449                         "P2P: Failed to send Action frame");
3450         }
3451         wpabuf_free(req);
3452
3453         return 0;
3454 }
3455
3456
3457 static struct wpabuf * p2p_build_presence_resp(u8 status, const u8 *noa,
3458                                                size_t noa_len, u8 dialog_token)
3459 {
3460         struct wpabuf *resp;
3461         u8 *len;
3462
3463         resp = wpabuf_alloc(100 + noa_len);
3464         if (resp == NULL)
3465                 return NULL;
3466
3467         p2p_buf_add_action_hdr(resp, P2P_PRESENCE_RESP, dialog_token);
3468         len = p2p_buf_add_ie_hdr(resp);
3469         p2p_buf_add_status(resp, status);
3470         if (noa) {
3471                 wpabuf_put_u8(resp, P2P_ATTR_NOTICE_OF_ABSENCE);
3472                 wpabuf_put_le16(resp, noa_len);
3473                 wpabuf_put_data(resp, noa, noa_len);
3474         } else
3475                 p2p_buf_add_noa(resp, 0, 0, 0, NULL, NULL);
3476         p2p_buf_update_ie_hdr(resp, len);
3477
3478         return resp;
3479 }
3480
3481
3482 static void p2p_process_presence_req(struct p2p_data *p2p, const u8 *da,
3483                                      const u8 *sa, const u8 *data, size_t len,
3484                                      int rx_freq)
3485 {
3486         struct p2p_message msg;
3487         u8 status;
3488         struct wpabuf *resp;
3489         size_t g;
3490         struct p2p_group *group = NULL;
3491         int parsed = 0;
3492         u8 noa[50];
3493         int noa_len;
3494
3495         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3496                 "P2P: Received P2P Action - P2P Presence Request");
3497
3498         for (g = 0; g < p2p->num_groups; g++) {
3499                 if (os_memcmp(da, p2p_group_get_interface_addr(p2p->groups[g]),
3500                               ETH_ALEN) == 0) {
3501                         group = p2p->groups[g];
3502                         break;
3503                 }
3504         }
3505         if (group == NULL) {
3506                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3507                         "P2P: Ignore P2P Presence Request for unknown group "
3508                         MACSTR, MAC2STR(da));
3509                 return;
3510         }
3511
3512         if (p2p_parse(data, len, &msg) < 0) {
3513                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3514                         "P2P: Failed to parse P2P Presence Request");
3515                 status = P2P_SC_FAIL_INVALID_PARAMS;
3516                 goto fail;
3517         }
3518         parsed = 1;
3519
3520         if (msg.noa == NULL) {
3521                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3522                         "P2P: No NoA attribute in P2P Presence Request");
3523                 status = P2P_SC_FAIL_INVALID_PARAMS;
3524                 goto fail;
3525         }
3526
3527         status = p2p_group_presence_req(group, sa, msg.noa, msg.noa_len);
3528
3529 fail:
3530         if (p2p->cfg->get_noa)
3531                 noa_len = p2p->cfg->get_noa(p2p->cfg->cb_ctx, da, noa,
3532                                             sizeof(noa));
3533         else
3534                 noa_len = -1;
3535         resp = p2p_build_presence_resp(status, noa_len > 0 ? noa : NULL,
3536                                        noa_len > 0 ? noa_len : 0,
3537                                        msg.dialog_token);
3538         if (parsed)
3539                 p2p_parse_free(&msg);
3540         if (resp == NULL)
3541                 return;
3542
3543         p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3544         if (p2p_send_action(p2p, rx_freq, sa, da, da,
3545                             wpabuf_head(resp), wpabuf_len(resp), 200) < 0) {
3546                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3547                         "P2P: Failed to send Action frame");
3548         }
3549         wpabuf_free(resp);
3550 }
3551
3552
3553 static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da,
3554                                       const u8 *sa, const u8 *data, size_t len)
3555 {
3556         struct p2p_message msg;
3557
3558         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3559                 "P2P: Received P2P Action - P2P Presence Response");
3560
3561         if (p2p_parse(data, len, &msg) < 0) {
3562                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3563                         "P2P: Failed to parse P2P Presence Response");
3564                 return;
3565         }
3566
3567         if (msg.status == NULL || msg.noa == NULL) {
3568                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3569                         "P2P: No Status or NoA attribute in P2P Presence "
3570                         "Response");
3571                 p2p_parse_free(&msg);
3572                 return;
3573         }
3574
3575         if (*msg.status) {
3576                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3577                         "P2P: P2P Presence Request was rejected: status %u",
3578                         *msg.status);
3579                 p2p_parse_free(&msg);
3580                 return;
3581         }
3582
3583         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3584                 "P2P: P2P Presence Request was accepted");
3585         wpa_hexdump(MSG_DEBUG, "P2P: P2P Presence Response - NoA",
3586                     msg.noa, msg.noa_len);
3587         /* TODO: process NoA */
3588         p2p_parse_free(&msg);
3589 }
3590
3591
3592 static void p2p_ext_listen_timeout(void *eloop_ctx, void *timeout_ctx)
3593 {
3594         struct p2p_data *p2p = eloop_ctx;
3595
3596         if (p2p->ext_listen_interval) {
3597                 /* Schedule next extended listen timeout */
3598                 eloop_register_timeout(p2p->ext_listen_interval_sec,
3599                                        p2p->ext_listen_interval_usec,
3600                                        p2p_ext_listen_timeout, p2p, NULL);
3601         }
3602
3603         if (p2p->state == P2P_LISTEN_ONLY && p2p->ext_listen_only) {
3604                 /*
3605                  * This should not really happen, but it looks like the Listen
3606                  * command may fail is something else (e.g., a scan) was
3607                  * running at an inconvenient time. As a workaround, allow new
3608                  * Extended Listen operation to be started.
3609                  */
3610                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Previous "
3611                         "Extended Listen operation had not been completed - "
3612                         "try again");
3613                 p2p->ext_listen_only = 0;
3614                 p2p_set_state(p2p, P2P_IDLE);
3615         }
3616
3617         if (p2p->state != P2P_IDLE) {
3618                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Skip Extended "
3619                         "Listen timeout in active state (%s)",
3620                         p2p_state_txt(p2p->state));
3621                 return;
3622         }
3623
3624         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Extended Listen timeout");
3625         p2p->ext_listen_only = 1;
3626         if (p2p_listen(p2p, p2p->ext_listen_period) < 0) {
3627                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Failed to start "
3628                         "Listen state for Extended Listen Timing");
3629                 p2p->ext_listen_only = 0;
3630         }
3631 }
3632
3633
3634 int p2p_ext_listen(struct p2p_data *p2p, unsigned int period,
3635                    unsigned int interval)
3636 {
3637         if (period > 65535 || interval > 65535 || period > interval ||
3638             (period == 0 && interval > 0) || (period > 0 && interval == 0)) {
3639                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3640                         "P2P: Invalid Extended Listen Timing request: "
3641                         "period=%u interval=%u", period, interval);
3642                 return -1;
3643         }
3644
3645         eloop_cancel_timeout(p2p_ext_listen_timeout, p2p, NULL);
3646
3647         if (interval == 0) {
3648                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3649                         "P2P: Disabling Extended Listen Timing");
3650                 p2p->ext_listen_period = 0;
3651                 p2p->ext_listen_interval = 0;
3652                 return 0;
3653         }
3654
3655         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3656                 "P2P: Enabling Extended Listen Timing: period %u msec, "
3657                 "interval %u msec", period, interval);
3658         p2p->ext_listen_period = period;
3659         p2p->ext_listen_interval = interval;
3660         p2p->ext_listen_interval_sec = interval / 1000;
3661         p2p->ext_listen_interval_usec = (interval % 1000) * 1000;
3662
3663         eloop_register_timeout(p2p->ext_listen_interval_sec,
3664                                p2p->ext_listen_interval_usec,
3665                                p2p_ext_listen_timeout, p2p, NULL);
3666
3667         return 0;
3668 }
3669
3670
3671 void p2p_deauth_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code,
3672                       const u8 *ie, size_t ie_len)
3673 {
3674         struct p2p_message msg;
3675
3676         if (bssid == NULL || ie == NULL)
3677                 return;
3678
3679         os_memset(&msg, 0, sizeof(msg));
3680         if (p2p_parse_ies(ie, ie_len, &msg))
3681                 return;
3682         if (msg.minor_reason_code == NULL)
3683                 return;
3684
3685         wpa_msg(p2p->cfg->msg_ctx, MSG_INFO,
3686                 "P2P: Deauthentication notification BSSID " MACSTR
3687                 " reason_code=%u minor_reason_code=%u",
3688                 MAC2STR(bssid), reason_code, *msg.minor_reason_code);
3689
3690         p2p_parse_free(&msg);
3691 }
3692
3693
3694 void p2p_disassoc_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code,
3695                         const u8 *ie, size_t ie_len)
3696 {
3697         struct p2p_message msg;
3698
3699         if (bssid == NULL || ie == NULL)
3700                 return;
3701
3702         os_memset(&msg, 0, sizeof(msg));
3703         if (p2p_parse_ies(ie, ie_len, &msg))
3704                 return;
3705         if (msg.minor_reason_code == NULL)
3706                 return;
3707
3708         wpa_msg(p2p->cfg->msg_ctx, MSG_INFO,
3709                 "P2P: Disassociation notification BSSID " MACSTR
3710                 " reason_code=%u minor_reason_code=%u",
3711                 MAC2STR(bssid), reason_code, *msg.minor_reason_code);
3712
3713         p2p_parse_free(&msg);
3714 }
3715
3716
3717 void p2p_set_managed_oper(struct p2p_data *p2p, int enabled)
3718 {
3719         if (enabled) {
3720                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Managed P2P "
3721                         "Device operations enabled");
3722                 p2p->dev_capab |= P2P_DEV_CAPAB_INFRA_MANAGED;
3723         } else {
3724                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Managed P2P "
3725                         "Device operations disabled");
3726                 p2p->dev_capab &= ~P2P_DEV_CAPAB_INFRA_MANAGED;
3727         }
3728 }
3729
3730
3731 int p2p_set_listen_channel(struct p2p_data *p2p, u8 reg_class, u8 channel)
3732 {
3733         if (p2p_channel_to_freq(p2p->cfg->country, reg_class, channel) < 0)
3734                 return -1;
3735
3736         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Set Listen channel: "
3737                 "reg_class %u channel %u", reg_class, channel);
3738         p2p->cfg->reg_class = reg_class;
3739         p2p->cfg->channel = channel;
3740
3741         return 0;
3742 }
3743
3744
3745 int p2p_set_ssid_postfix(struct p2p_data *p2p, const u8 *postfix, size_t len)
3746 {
3747         wpa_hexdump_ascii(MSG_DEBUG, "P2P: New SSID postfix", postfix, len);
3748         if (postfix == NULL) {
3749                 p2p->cfg->ssid_postfix_len = 0;
3750                 return 0;
3751         }
3752         if (len > sizeof(p2p->cfg->ssid_postfix))
3753                 return -1;
3754         os_memcpy(p2p->cfg->ssid_postfix, postfix, len);
3755         p2p->cfg->ssid_postfix_len = len;
3756         return 0;
3757 }
3758
3759
3760 int p2p_set_oper_channel(struct p2p_data *p2p, u8 op_reg_class, u8 op_channel,
3761                          int cfg_op_channel)
3762 {
3763         if (p2p_channel_to_freq(p2p->cfg->country, op_reg_class, op_channel)
3764             < 0)
3765                 return -1;
3766
3767         wpa_msg(p2p->cfg->msg_ctx, MSG_INFO, "P2P: Set Operating channel: "
3768                 "reg_class %u channel %u", op_reg_class, op_channel);
3769         p2p->cfg->op_reg_class = op_reg_class;
3770         p2p->cfg->op_channel = op_channel;
3771         p2p->cfg->cfg_op_channel = cfg_op_channel;
3772         return 0;
3773 }
3774
3775
3776 int p2p_set_pref_chan(struct p2p_data *p2p, unsigned int num_pref_chan,
3777                       const struct p2p_channel *pref_chan)
3778 {
3779         struct p2p_channel *n;
3780
3781         if (pref_chan) {
3782                 n = os_malloc(num_pref_chan * sizeof(struct p2p_channel));
3783                 if (n == NULL)
3784                         return -1;
3785                 os_memcpy(n, pref_chan,
3786                           num_pref_chan * sizeof(struct p2p_channel));
3787         } else
3788                 n = NULL;
3789
3790         os_free(p2p->cfg->pref_chan);
3791         p2p->cfg->pref_chan = n;
3792         p2p->cfg->num_pref_chan = num_pref_chan;
3793
3794         return 0;
3795 }
3796
3797
3798 int p2p_get_interface_addr(struct p2p_data *p2p, const u8 *dev_addr,
3799                            u8 *iface_addr)
3800 {
3801         struct p2p_device *dev = p2p_get_device(p2p, dev_addr);
3802         if (dev == NULL || is_zero_ether_addr(dev->interface_addr))
3803                 return -1;
3804         os_memcpy(iface_addr, dev->interface_addr, ETH_ALEN);
3805         return 0;
3806 }
3807
3808
3809 int p2p_get_dev_addr(struct p2p_data *p2p, const u8 *iface_addr,
3810                            u8 *dev_addr)
3811 {
3812         struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr);
3813         if (dev == NULL)
3814                 return -1;
3815         os_memcpy(dev_addr, dev->info.p2p_device_addr, ETH_ALEN);
3816         return 0;
3817 }
3818
3819
3820 void p2p_set_peer_filter(struct p2p_data *p2p, const u8 *addr)
3821 {
3822         os_memcpy(p2p->peer_filter, addr, ETH_ALEN);
3823         if (is_zero_ether_addr(p2p->peer_filter))
3824                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Disable peer "
3825                         "filter");
3826         else
3827                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Enable peer "
3828                         "filter for " MACSTR, MAC2STR(p2p->peer_filter));
3829 }
3830
3831
3832 void p2p_set_cross_connect(struct p2p_data *p2p, int enabled)
3833 {
3834         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Cross connection %s",
3835                 enabled ? "enabled" : "disabled");
3836         if (p2p->cross_connect == enabled)
3837                 return;
3838         p2p->cross_connect = enabled;
3839         /* TODO: may need to tear down any action group where we are GO(?) */
3840 }
3841
3842
3843 int p2p_get_oper_freq(struct p2p_data *p2p, const u8 *iface_addr)
3844 {
3845         struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr);
3846         if (dev == NULL)
3847                 return -1;
3848         if (dev->oper_freq <= 0)
3849                 return -1;
3850         return dev->oper_freq;
3851 }
3852
3853
3854 void p2p_set_intra_bss_dist(struct p2p_data *p2p, int enabled)
3855 {
3856         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Intra BSS distribution %s",
3857                 enabled ? "enabled" : "disabled");
3858         p2p->cfg->p2p_intra_bss = enabled;
3859 }
3860
3861
3862 void p2p_update_channel_list(struct p2p_data *p2p, struct p2p_channels *chan)
3863 {
3864         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Update channel list");
3865         os_memcpy(&p2p->cfg->channels, chan, sizeof(struct p2p_channels));
3866 }
3867
3868
3869 int p2p_send_action(struct p2p_data *p2p, unsigned int freq, const u8 *dst,
3870                     const u8 *src, const u8 *bssid, const u8 *buf,
3871                     size_t len, unsigned int wait_time)
3872 {
3873         if (p2p->p2p_scan_running) {
3874                 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Delay Action "
3875                         "frame TX until p2p_scan completes");
3876                 if (p2p->after_scan_tx) {
3877                         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Dropped "
3878                                 "previous pending Action frame TX");
3879                         os_free(p2p->after_scan_tx);
3880                 }
3881                 p2p->after_scan_tx = os_malloc(sizeof(*p2p->after_scan_tx) +
3882                                                len);
3883                 if (p2p->after_scan_tx == NULL)
3884                         return -1;
3885                 p2p->after_scan_tx->freq = freq;
3886                 os_memcpy(p2p->after_scan_tx->dst, dst, ETH_ALEN);
3887                 os_memcpy(p2p->after_scan_tx->src, src, ETH_ALEN);
3888                 os_memcpy(p2p->after_scan_tx->bssid, bssid, ETH_ALEN);
3889                 p2p->after_scan_tx->len = len;
3890                 p2p->after_scan_tx->wait_time = wait_time;
3891                 os_memcpy(p2p->after_scan_tx + 1, buf, len);
3892                 return 0;
3893         }
3894
3895         return p2p->cfg->send_action(p2p->cfg->cb_ctx, freq, dst, src, bssid,
3896                                      buf, len, wait_time);
3897 }
3898
3899
3900 void p2p_set_best_channels(struct p2p_data *p2p, int freq_24, int freq_5,
3901                            int freq_overall)
3902 {
3903         wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Best channel: 2.4 GHz: %d,"
3904                 "  5 GHz: %d,  overall: %d", freq_24, freq_5, freq_overall);
3905         p2p->best_freq_24 = freq_24;
3906         p2p->best_freq_5 = freq_5;
3907         p2p->best_freq_overall = freq_overall;
3908 }
3909
3910
3911 const u8 * p2p_get_go_neg_peer(struct p2p_data *p2p)
3912 {
3913         if (p2p == NULL || p2p->go_neg_peer == NULL)
3914                 return NULL;
3915         return p2p->go_neg_peer->info.p2p_device_addr;
3916 }
3917
3918
3919 const struct p2p_peer_info *
3920 p2p_get_peer_found(struct p2p_data *p2p, const u8 *addr, int next)
3921 {
3922         struct p2p_device *dev;
3923
3924         if (addr) {
3925                 dev = p2p_get_device(p2p, addr);
3926                 if (!dev)
3927                         return NULL;
3928
3929                 if (!next) {
3930                         if (dev->flags & P2P_DEV_PROBE_REQ_ONLY)
3931                                 return NULL;
3932
3933                         return &dev->info;
3934                 } else {
3935                         do {
3936                                 dev = dl_list_first(&dev->list,
3937                                                     struct p2p_device,
3938                                                     list);
3939                                 if (&dev->list == &p2p->devices)
3940                                         return NULL;
3941                         } while (dev->flags & P2P_DEV_PROBE_REQ_ONLY);
3942                 }
3943         } else {
3944                 dev = dl_list_first(&p2p->devices, struct p2p_device, list);
3945                 if (!dev)
3946                         return NULL;
3947                 while (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
3948                         dev = dl_list_first(&dev->list,
3949                                             struct p2p_device,
3950                                             list);
3951                         if (&dev->list == &p2p->devices)
3952                                 return NULL;
3953                 }
3954         }
3955
3956         return &dev->info;
3957 }
3958
3959
3960 int p2p_in_progress(struct p2p_data *p2p)
3961 {
3962         if (p2p == NULL)
3963                 return 0;
3964         return p2p->state != P2P_IDLE && p2p->state != P2P_PROVISIONING;
3965 }