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