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