src/p2p/p2p_go_neg.c

   1 /*
   2  * Wi-Fi Direct - P2P Group Owner Negotiation
   3  * Copyright (c) 2009-2010, Atheros Communications
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "includes.h"
  10
  11 #include "common.h"
  12 #include "common/ieee802_11_defs.h"
  13 #include "wps/wps_defs.h"
  14 #include "p2p_i.h"
  15 #include "p2p.h"
  16
  17
  18 static int p2p_go_det(u8 own_intent, u8 peer_value)
  19 {
  20         u8 peer_intent = peer_value >> 1;
  21         if (own_intent == peer_intent) {
  22                 if (own_intent == P2P_MAX_GO_INTENT)
  23                         return -1; /* both devices want to become GO */
  24
  25                 /* Use tie breaker bit to determine GO */
  26                 return (peer_value & 0x01) ? 0 : 1;
  27         }
  28
  29         return own_intent > peer_intent;
  30 }
  31
  32
  33 int p2p_peer_channels_check(struct p2p_data *p2p, struct p2p_channels *own,
  34                             struct p2p_device *dev,
  35                             const u8 *channel_list, size_t channel_list_len)
  36 {
  37         const u8 *pos, *end;
  38         struct p2p_channels *ch;
  39         size_t channels;
  40         struct p2p_channels intersection;
  41
  42         ch = &dev->channels;
  43         os_memset(ch, 0, sizeof(*ch));
  44         pos = channel_list;
  45         end = channel_list + channel_list_len;
  46
  47         if (end - pos < 3)
  48                 return -1;
  49         os_memcpy(dev->country, pos, 3);
  50         wpa_hexdump_ascii(MSG_DEBUG, "P2P: Peer country", pos, 3);
  51         if (pos[2] != 0x04 && os_memcmp(pos, p2p->cfg->country, 2) != 0) {
  52                 p2p_info(p2p, "Mismatching country (ours=%c%c peer's=%c%c)",
  53                         p2p->cfg->country[0], p2p->cfg->country[1],
  54                         pos[0], pos[1]);
  55                 return -1;
  56         }
  57         pos += 3;
  58
  59         while (pos + 2 < end) {
  60                 struct p2p_reg_class *cl = &ch->reg_class[ch->reg_classes];
  61                 cl->reg_class = *pos++;
  62                 if (pos + 1 + pos[0] > end) {
  63                         p2p_info(p2p, "Invalid peer Channel List");
  64                         return -1;
  65                 }
  66                 channels = *pos++;
  67                 cl->channels = channels > P2P_MAX_REG_CLASS_CHANNELS ?
  68                         P2P_MAX_REG_CLASS_CHANNELS : channels;
  69                 os_memcpy(cl->channel, pos, cl->channels);
  70                 pos += channels;
  71                 ch->reg_classes++;
  72                 if (ch->reg_classes == P2P_MAX_REG_CLASSES)
  73                         break;
  74         }
  75
  76         p2p_channels_intersect(own, &dev->channels, &intersection);
  77         p2p_dbg(p2p, "Own reg_classes %d peer reg_classes %d intersection reg_classes %d",
  78                 (int) own->reg_classes,
  79                 (int) dev->channels.reg_classes,
  80                 (int) intersection.reg_classes);
  81         if (intersection.reg_classes == 0) {
  82                 p2p_info(p2p, "No common channels found");
  83                 return -1;
  84         }
  85         return 0;
  86 }
  87
  88
  89 static int p2p_peer_channels(struct p2p_data *p2p, struct p2p_device *dev,
  90                              const u8 *channel_list, size_t channel_list_len)
  91 {
  92         return p2p_peer_channels_check(p2p, &p2p->channels, dev,
  93                                        channel_list, channel_list_len);
  94 }
  95
  96
  97 u16 p2p_wps_method_pw_id(enum p2p_wps_method wps_method)
  98 {
  99         switch (wps_method) {
 100         case WPS_PIN_DISPLAY:
 101                 return DEV_PW_REGISTRAR_SPECIFIED;
 102         case WPS_PIN_KEYPAD:
 103                 return DEV_PW_USER_SPECIFIED;
 104         case WPS_PBC:
 105                 return DEV_PW_PUSHBUTTON;
 106         default:
 107                 return DEV_PW_DEFAULT;
 108         }
 109 }
 110
 111
 112 static const char * p2p_wps_method_str(enum p2p_wps_method wps_method)
 113 {
 114         switch (wps_method) {
 115         case WPS_PIN_DISPLAY:
 116                 return "Display";
 117         case WPS_PIN_KEYPAD:
 118                 return "Keypad";
 119         case WPS_PBC:
 120                 return "PBC";
 121         default:
 122                 return "??";
 123         }
 124 }
 125
 126
 127 static struct wpabuf * p2p_build_go_neg_req(struct p2p_data *p2p,
 128                                             struct p2p_device *peer)
 129 {
 130         struct wpabuf *buf;
 131         u8 *len;
 132         u8 group_capab;
 133         size_t extra = 0;
 134
 135 #ifdef CONFIG_WIFI_DISPLAY
 136         if (p2p->wfd_ie_go_neg)
 137                 extra = wpabuf_len(p2p->wfd_ie_go_neg);
 138 #endif /* CONFIG_WIFI_DISPLAY */
 139
 140         buf = wpabuf_alloc(1000 + extra);
 141         if (buf == NULL)
 142                 return NULL;
 143
 144         p2p_buf_add_public_action_hdr(buf, P2P_GO_NEG_REQ, peer->dialog_token);
 145
 146         len = p2p_buf_add_ie_hdr(buf);
 147         group_capab = 0;
 148         if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP) {
 149                 group_capab |= P2P_GROUP_CAPAB_PERSISTENT_GROUP;
 150                 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_RECONN)
 151                         group_capab |= P2P_GROUP_CAPAB_PERSISTENT_RECONN;
 152         }
 153         if (p2p->cross_connect)
 154                 group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
 155         if (p2p->cfg->p2p_intra_bss)
 156                 group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST;
 157         p2p_buf_add_capability(buf, p2p->dev_capab &
 158                                ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY,
 159                                group_capab);
 160         p2p_buf_add_go_intent(buf, (p2p->go_intent << 1) | peer->tie_breaker);
 161         p2p_buf_add_config_timeout(buf, p2p->go_timeout, p2p->client_timeout);
 162         p2p_buf_add_listen_channel(buf, p2p->cfg->country, p2p->cfg->reg_class,
 163                                    p2p->cfg->channel);
 164         if (p2p->ext_listen_interval)
 165                 p2p_buf_add_ext_listen_timing(buf, p2p->ext_listen_period,
 166                                               p2p->ext_listen_interval);
 167         p2p_buf_add_intended_addr(buf, p2p->intended_addr);
 168         p2p_buf_add_channel_list(buf, p2p->cfg->country, &p2p->channels);
 169         p2p_buf_add_device_info(buf, p2p, peer);
 170         p2p_buf_add_operating_channel(buf, p2p->cfg->country,
 171                                       p2p->op_reg_class, p2p->op_channel);
 172         p2p_buf_update_ie_hdr(buf, len);
 173
 174         /* WPS IE with Device Password ID attribute */
 175         if (p2p_build_wps_ie(p2p, buf, p2p_wps_method_pw_id(peer->wps_method),
 176                              0) < 0) {
 177                 p2p_dbg(p2p, "Failed to build WPS IE for GO Negotiation Request");
 178                 wpabuf_free(buf);
 179                 return NULL;
 180         }
 181
 182 #ifdef CONFIG_WIFI_DISPLAY
 183         if (p2p->wfd_ie_go_neg)
 184                 wpabuf_put_buf(buf, p2p->wfd_ie_go_neg);
 185 #endif /* CONFIG_WIFI_DISPLAY */
 186
 187         return buf;
 188 }
 189
 190
 191 int p2p_connect_send(struct p2p_data *p2p, struct p2p_device *dev)
 192 {
 193         struct wpabuf *req;
 194         int freq;
 195
 196         if (dev->flags & P2P_DEV_PD_BEFORE_GO_NEG) {
 197                 u16 config_method;
 198                 p2p_dbg(p2p, "Use PD-before-GO-Neg workaround for " MACSTR,
 199                         MAC2STR(dev->info.p2p_device_addr));
 200                 if (dev->wps_method == WPS_PIN_DISPLAY)
 201                         config_method = WPS_CONFIG_KEYPAD;
 202                 else if (dev->wps_method == WPS_PIN_KEYPAD)
 203                         config_method = WPS_CONFIG_DISPLAY;
 204                 else if (dev->wps_method == WPS_PBC)
 205                         config_method = WPS_CONFIG_PUSHBUTTON;
 206                 else
 207                         return -1;
 208                 return p2p_prov_disc_req(p2p, dev->info.p2p_device_addr,
 209                                          config_method, 0, 0, 1);
 210         }
 211
 212         freq = dev->listen_freq > 0 ? dev->listen_freq : dev->oper_freq;
 213         if (freq <= 0) {
 214                 p2p_dbg(p2p, "No Listen/Operating frequency known for the peer "
 215                         MACSTR " to send GO Negotiation Request",
 216                         MAC2STR(dev->info.p2p_device_addr));
 217                 return -1;
 218         }
 219
 220         req = p2p_build_go_neg_req(p2p, dev);
 221         if (req == NULL)
 222                 return -1;
 223         p2p_dbg(p2p, "Sending GO Negotiation Request");
 224         p2p_set_state(p2p, P2P_CONNECT);
 225         p2p->pending_action_state = P2P_PENDING_GO_NEG_REQUEST;
 226         p2p->go_neg_peer = dev;
 227         dev->flags |= P2P_DEV_WAIT_GO_NEG_RESPONSE;
 228         dev->connect_reqs++;
 229         if (p2p_send_action(p2p, freq, dev->info.p2p_device_addr,
 230                             p2p->cfg->dev_addr, dev->info.p2p_device_addr,
 231                             wpabuf_head(req), wpabuf_len(req), 500) < 0) {
 232                 p2p_dbg(p2p, "Failed to send Action frame");
 233                 /* Use P2P find to recover and retry */
 234                 p2p_set_timeout(p2p, 0, 0);
 235         } else
 236                 dev->go_neg_req_sent++;
 237
 238         wpabuf_free(req);
 239
 240         return 0;
 241 }
 242
 243
 244 static struct wpabuf * p2p_build_go_neg_resp(struct p2p_data *p2p,
 245                                              struct p2p_device *peer,
 246                                              u8 dialog_token, u8 status,
 247                                              u8 tie_breaker)
 248 {
 249         struct wpabuf *buf;
 250         u8 *len;
 251         u8 group_capab;
 252         size_t extra = 0;
 253
 254         p2p_dbg(p2p, "Building GO Negotiation Response");
 255
 256 #ifdef CONFIG_WIFI_DISPLAY
 257         if (p2p->wfd_ie_go_neg)
 258                 extra = wpabuf_len(p2p->wfd_ie_go_neg);
 259 #endif /* CONFIG_WIFI_DISPLAY */
 260
 261         buf = wpabuf_alloc(1000 + extra);
 262         if (buf == NULL)
 263                 return NULL;
 264
 265         p2p_buf_add_public_action_hdr(buf, P2P_GO_NEG_RESP, dialog_token);
 266
 267         len = p2p_buf_add_ie_hdr(buf);
 268         p2p_buf_add_status(buf, status);
 269         group_capab = 0;
 270         if (peer && peer->go_state == LOCAL_GO) {
 271                 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP) {
 272                         group_capab |= P2P_GROUP_CAPAB_PERSISTENT_GROUP;
 273                         if (peer->flags & P2P_DEV_PREFER_PERSISTENT_RECONN)
 274                                 group_capab |=
 275                                         P2P_GROUP_CAPAB_PERSISTENT_RECONN;
 276                 }
 277                 if (p2p->cross_connect)
 278                         group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
 279                 if (p2p->cfg->p2p_intra_bss)
 280                         group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST;
 281         }
 282         p2p_buf_add_capability(buf, p2p->dev_capab &
 283                                ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY,
 284                                group_capab);
 285         p2p_buf_add_go_intent(buf, (p2p->go_intent << 1) | tie_breaker);
 286         p2p_buf_add_config_timeout(buf, p2p->go_timeout, p2p->client_timeout);
 287         if (peer && peer->go_state == REMOTE_GO) {
 288                 p2p_dbg(p2p, "Omit Operating Channel attribute");
 289         } else {
 290                 p2p_buf_add_operating_channel(buf, p2p->cfg->country,
 291                                               p2p->op_reg_class,
 292                                               p2p->op_channel);
 293         }
 294         p2p_buf_add_intended_addr(buf, p2p->intended_addr);
 295         if (status || peer == NULL) {
 296                 p2p_buf_add_channel_list(buf, p2p->cfg->country,
 297                                          &p2p->channels);
 298         } else if (peer->go_state == REMOTE_GO) {
 299                 p2p_buf_add_channel_list(buf, p2p->cfg->country,
 300                                          &p2p->channels);
 301         } else {
 302                 struct p2p_channels res;
 303                 p2p_channels_intersect(&p2p->channels, &peer->channels,
 304                                        &res);
 305                 p2p_buf_add_channel_list(buf, p2p->cfg->country, &res);
 306         }
 307         p2p_buf_add_device_info(buf, p2p, peer);
 308         if (peer && peer->go_state == LOCAL_GO) {
 309                 p2p_buf_add_group_id(buf, p2p->cfg->dev_addr, p2p->ssid,
 310                                      p2p->ssid_len);
 311         }
 312         p2p_buf_update_ie_hdr(buf, len);
 313
 314         /* WPS IE with Device Password ID attribute */
 315         if (p2p_build_wps_ie(p2p, buf,
 316                              p2p_wps_method_pw_id(peer ? peer->wps_method :
 317                                                   WPS_NOT_READY), 0) < 0) {
 318                 p2p_dbg(p2p, "Failed to build WPS IE for GO Negotiation Response");
 319                 wpabuf_free(buf);
 320                 return NULL;
 321         }
 322
 323 #ifdef CONFIG_WIFI_DISPLAY
 324         if (p2p->wfd_ie_go_neg)
 325                 wpabuf_put_buf(buf, p2p->wfd_ie_go_neg);
 326 #endif /* CONFIG_WIFI_DISPLAY */
 327
 328
 329         return buf;
 330 }
 331
 332
 333 /**
 334  * p2p_reselect_channel - Re-select operating channel based on peer information
 335  * @p2p: P2P module context from p2p_init()
 336  * @intersection: Support channel list intersection from local and peer
 337  *
 338  * This function is used to re-select the best channel after having received
 339  * information from the peer to allow supported channel lists to be intersected.
 340  * This can be used to improve initial channel selection done in
 341  * p2p_prepare_channel() prior to the start of GO Negotiation. In addition, this
 342  * can be used for Invitation case.
 343  */
 344 void p2p_reselect_channel(struct p2p_data *p2p,
 345                           struct p2p_channels *intersection)
 346 {
 347         struct p2p_reg_class *cl;
 348         int freq;
 349         u8 op_reg_class, op_channel;
 350         unsigned int i;
 351         const int op_classes_5ghz[] = { 124, 115, 0 };
 352         const int op_classes_ht40[] = { 126, 127, 116, 117, 0 };
 353         const int op_classes_vht[] = { 128, 0 };
 354
 355         if (p2p->own_freq_preference > 0 &&
 356             p2p_freq_to_channel(p2p->own_freq_preference,
 357                                 &op_reg_class, &op_channel) == 0 &&
 358             p2p_channels_includes(intersection, op_reg_class, op_channel)) {
 359                 p2p_dbg(p2p, "Pick own channel preference (reg_class %u channel %u) from intersection",
 360                         op_reg_class, op_channel);
 361                 p2p->op_reg_class = op_reg_class;
 362                 p2p->op_channel = op_channel;
 363                 return;
 364         }
 365
 366         if (p2p->best_freq_overall > 0 &&
 367             p2p_freq_to_channel(p2p->best_freq_overall,
 368                                 &op_reg_class, &op_channel) == 0 &&
 369             p2p_channels_includes(intersection, op_reg_class, op_channel)) {
 370                 p2p_dbg(p2p, "Pick best overall channel (reg_class %u channel %u) from intersection",
 371                         op_reg_class, op_channel);
 372                 p2p->op_reg_class = op_reg_class;
 373                 p2p->op_channel = op_channel;
 374                 return;
 375         }
 376
 377         /* First, try to pick the best channel from another band */
 378         freq = p2p_channel_to_freq(p2p->op_reg_class, p2p->op_channel);
 379         if (freq >= 2400 && freq < 2500 && p2p->best_freq_5 > 0 &&
 380             !p2p_channels_includes(intersection, p2p->op_reg_class,
 381                                    p2p->op_channel) &&
 382             p2p_freq_to_channel(p2p->best_freq_5,
 383                                 &op_reg_class, &op_channel) == 0 &&
 384             p2p_channels_includes(intersection, op_reg_class, op_channel)) {
 385                 p2p_dbg(p2p, "Pick best 5 GHz channel (reg_class %u channel %u) from intersection",
 386                         op_reg_class, op_channel);
 387                 p2p->op_reg_class = op_reg_class;
 388                 p2p->op_channel = op_channel;
 389                 return;
 390         }
 391
 392         if (freq >= 4900 && freq < 6000 && p2p->best_freq_24 > 0 &&
 393             !p2p_channels_includes(intersection, p2p->op_reg_class,
 394                                    p2p->op_channel) &&
 395             p2p_freq_to_channel(p2p->best_freq_24,
 396                                 &op_reg_class, &op_channel) == 0 &&
 397             p2p_channels_includes(intersection, op_reg_class, op_channel)) {
 398                 p2p_dbg(p2p, "Pick best 2.4 GHz channel (reg_class %u channel %u) from intersection",
 399                         op_reg_class, op_channel);
 400                 p2p->op_reg_class = op_reg_class;
 401                 p2p->op_channel = op_channel;
 402                 return;
 403         }
 404
 405         /* Select channel with highest preference if the peer supports it */
 406         for (i = 0; p2p->cfg->pref_chan && i < p2p->cfg->num_pref_chan; i++) {
 407                 if (p2p_channels_includes(intersection,
 408                                           p2p->cfg->pref_chan[i].op_class,
 409                                           p2p->cfg->pref_chan[i].chan)) {
 410                         p2p->op_reg_class = p2p->cfg->pref_chan[i].op_class;
 411                         p2p->op_channel = p2p->cfg->pref_chan[i].chan;
 412                         p2p_dbg(p2p, "Pick highest preferred channel (op_class %u channel %u) from intersection",
 413                                 p2p->op_reg_class, p2p->op_channel);
 414                         return;
 415                 }
 416         }
 417
 418         /* Try a channel where we might be able to use VHT */
 419         if (p2p_channel_select(intersection, op_classes_vht,
 420                                &p2p->op_reg_class, &p2p->op_channel) == 0) {
 421                 p2p_dbg(p2p, "Pick possible VHT channel (op_class %u channel %u) from intersection",
 422                         p2p->op_reg_class, p2p->op_channel);
 423                 return;
 424         }
 425
 426         /* Try a channel where we might be able to use HT40 */
 427         if (p2p_channel_select(intersection, op_classes_ht40,
 428                                &p2p->op_reg_class, &p2p->op_channel) == 0) {
 429                 p2p_dbg(p2p, "Pick possible HT40 channel (op_class %u channel %u) from intersection",
 430                         p2p->op_reg_class, p2p->op_channel);
 431                 return;
 432         }
 433
 434         /* Prefer a 5 GHz channel */
 435         if (p2p_channel_select(intersection, op_classes_5ghz,
 436                                &p2p->op_reg_class, &p2p->op_channel) == 0) {
 437                 p2p_dbg(p2p, "Pick possible 5 GHz channel (op_class %u channel %u) from intersection",
 438                         p2p->op_reg_class, p2p->op_channel);
 439                 return;
 440         }
 441
 442         /*
 443          * Try to see if the original channel is in the intersection. If
 444          * so, no need to change anything, as it already contains some
 445          * randomness.
 446          */
 447         if (p2p_channels_includes(intersection, p2p->op_reg_class,
 448                                   p2p->op_channel)) {
 449                 p2p_dbg(p2p, "Using original operating class and channel (op_class %u channel %u) from intersection",
 450                         p2p->op_reg_class, p2p->op_channel);
 451                 return;
 452         }
 453
 454         /*
 455          * Fall back to whatever is included in the channel intersection since
 456          * no better options seems to be available.
 457          */
 458         cl = &intersection->reg_class[0];
 459         p2p_dbg(p2p, "Pick another channel (reg_class %u channel %u) from intersection",
 460                 cl->reg_class, cl->channel[0]);
 461         p2p->op_reg_class = cl->reg_class;
 462         p2p->op_channel = cl->channel[0];
 463 }
 464
 465
 466 static int p2p_go_select_channel(struct p2p_data *p2p, struct p2p_device *dev,
 467                                  u8 *status)
 468 {
 469         struct p2p_channels tmp, intersection;
 470
 471         p2p_channels_dump(p2p, "own channels", &p2p->channels);
 472         p2p_channels_dump(p2p, "peer channels", &dev->channels);
 473         p2p_channels_intersect(&p2p->channels, &dev->channels, &tmp);
 474         p2p_channels_dump(p2p, "intersection", &tmp);
 475         p2p_channels_remove_freqs(&tmp, &p2p->no_go_freq);
 476         p2p_channels_dump(p2p, "intersection after no-GO removal", &tmp);
 477         p2p_channels_intersect(&tmp, &p2p->cfg->channels, &intersection);
 478         p2p_channels_dump(p2p, "intersection with local channel list",
 479                           &intersection);
 480         if (intersection.reg_classes == 0 ||
 481             intersection.reg_class[0].channels == 0) {
 482                 *status = P2P_SC_FAIL_NO_COMMON_CHANNELS;
 483                 p2p_dbg(p2p, "No common channels found");
 484                 return -1;
 485         }
 486
 487         if (!p2p_channels_includes(&intersection, p2p->op_reg_class,
 488                                    p2p->op_channel)) {
 489                 if (dev->flags & P2P_DEV_FORCE_FREQ) {
 490                         *status = P2P_SC_FAIL_NO_COMMON_CHANNELS;
 491                         p2p_dbg(p2p, "Peer does not support the forced channel");
 492                         return -1;
 493                 }
 494
 495                 p2p_dbg(p2p, "Selected operating channel (op_class %u channel %u) not acceptable to the peer",
 496                         p2p->op_reg_class, p2p->op_channel);
 497                 p2p_reselect_channel(p2p, &intersection);
 498         } else if (!(dev->flags & P2P_DEV_FORCE_FREQ) &&
 499                    !p2p->cfg->cfg_op_channel) {
 500                 p2p_dbg(p2p, "Try to optimize channel selection with peer information received; previously selected op_class %u channel %u",
 501                         p2p->op_reg_class, p2p->op_channel);
 502                 p2p_reselect_channel(p2p, &intersection);
 503         }
 504
 505         if (!p2p->ssid_set) {
 506                 p2p_build_ssid(p2p, p2p->ssid, &p2p->ssid_len);
 507                 p2p->ssid_set = 1;
 508         }
 509
 510         return 0;
 511 }
 512
 513
 514 void p2p_process_go_neg_req(struct p2p_data *p2p, const u8 *sa,
 515                             const u8 *data, size_t len, int rx_freq)
 516 {
 517         struct p2p_device *dev = NULL;
 518         struct wpabuf *resp;
 519         struct p2p_message msg;
 520         u8 status = P2P_SC_FAIL_INVALID_PARAMS;
 521         int tie_breaker = 0;
 522         int freq;
 523
 524         p2p_dbg(p2p, "Received GO Negotiation Request from " MACSTR "(freq=%d)",
 525                 MAC2STR(sa), rx_freq);
 526
 527         if (p2p_parse(data, len, &msg))
 528                 return;
 529
 530         if (!msg.capability) {
 531                 p2p_dbg(p2p, "Mandatory Capability attribute missing from GO Negotiation Request");
 532 #ifdef CONFIG_P2P_STRICT
 533                 goto fail;
 534 #endif /* CONFIG_P2P_STRICT */
 535         }
 536
 537         if (msg.go_intent)
 538                 tie_breaker = *msg.go_intent & 0x01;
 539         else {
 540                 p2p_dbg(p2p, "Mandatory GO Intent attribute missing from GO Negotiation Request");
 541 #ifdef CONFIG_P2P_STRICT
 542                 goto fail;
 543 #endif /* CONFIG_P2P_STRICT */
 544         }
 545
 546         if (!msg.config_timeout) {
 547                 p2p_dbg(p2p, "Mandatory Configuration Timeout attribute missing from GO Negotiation Request");
 548 #ifdef CONFIG_P2P_STRICT
 549                 goto fail;
 550 #endif /* CONFIG_P2P_STRICT */
 551         }
 552
 553         if (!msg.listen_channel) {
 554                 p2p_dbg(p2p, "No Listen Channel attribute received");
 555                 goto fail;
 556         }
 557         if (!msg.operating_channel) {
 558                 p2p_dbg(p2p, "No Operating Channel attribute received");
 559                 goto fail;
 560         }
 561         if (!msg.channel_list) {
 562                 p2p_dbg(p2p, "No Channel List attribute received");
 563                 goto fail;
 564         }
 565         if (!msg.intended_addr) {
 566                 p2p_dbg(p2p, "No Intended P2P Interface Address attribute received");
 567                 goto fail;
 568         }
 569         if (!msg.p2p_device_info) {
 570                 p2p_dbg(p2p, "No P2P Device Info attribute received");
 571                 goto fail;
 572         }
 573
 574         if (os_memcmp(msg.p2p_device_addr, sa, ETH_ALEN) != 0) {
 575                 p2p_dbg(p2p, "Unexpected GO Negotiation Request SA=" MACSTR
 576                         " != dev_addr=" MACSTR,
 577                         MAC2STR(sa), MAC2STR(msg.p2p_device_addr));
 578                 goto fail;
 579         }
 580
 581         dev = p2p_get_device(p2p, sa);
 582
 583         if (msg.status && *msg.status) {
 584                 p2p_dbg(p2p, "Unexpected Status attribute (%d) in GO Negotiation Request",
 585                         *msg.status);
 586                 goto fail;
 587         }
 588
 589         if (dev == NULL)
 590                 dev = p2p_add_dev_from_go_neg_req(p2p, sa, &msg);
 591         else if (dev->flags & P2P_DEV_PROBE_REQ_ONLY)
 592                 p2p_add_dev_info(p2p, sa, dev, &msg);
 593         if (dev && dev->flags & P2P_DEV_USER_REJECTED) {
 594                 p2p_dbg(p2p, "User has rejected this peer");
 595                 status = P2P_SC_FAIL_REJECTED_BY_USER;
 596         } else if (dev == NULL || dev->wps_method == WPS_NOT_READY) {
 597                 p2p_dbg(p2p, "Not ready for GO negotiation with " MACSTR,
 598                         MAC2STR(sa));
 599                 status = P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE;
 600                 p2p->cfg->go_neg_req_rx(p2p->cfg->cb_ctx, sa,
 601                                         msg.dev_password_id);
 602         } else if (p2p->go_neg_peer && p2p->go_neg_peer != dev) {
 603                 p2p_dbg(p2p, "Already in Group Formation with another peer");
 604                 status = P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
 605         } else {
 606                 int go;
 607
 608                 if (!p2p->go_neg_peer) {
 609                         p2p_dbg(p2p, "Starting GO Negotiation with previously authorized peer");
 610                         if (!(dev->flags & P2P_DEV_FORCE_FREQ)) {
 611                                 p2p_dbg(p2p, "Use default channel settings");
 612                                 p2p->op_reg_class = p2p->cfg->op_reg_class;
 613                                 p2p->op_channel = p2p->cfg->op_channel;
 614                                 os_memcpy(&p2p->channels, &p2p->cfg->channels,
 615                                           sizeof(struct p2p_channels));
 616                         } else {
 617                                 p2p_dbg(p2p, "Use previously configured forced channel settings");
 618                         }
 619                 }
 620
 621                 dev->flags &= ~P2P_DEV_NOT_YET_READY;
 622
 623                 if (!msg.go_intent) {
 624                         p2p_dbg(p2p, "No GO Intent attribute received");
 625                         goto fail;
 626                 }
 627                 if ((*msg.go_intent >> 1) > P2P_MAX_GO_INTENT) {
 628                         p2p_dbg(p2p, "Invalid GO Intent value (%u) received",
 629                                 *msg.go_intent >> 1);
 630                         goto fail;
 631                 }
 632
 633                 if (dev->go_neg_req_sent &&
 634                     os_memcmp(sa, p2p->cfg->dev_addr, ETH_ALEN) > 0) {
 635                         p2p_dbg(p2p, "Do not reply since peer has higher address and GO Neg Request already sent");
 636                         p2p_parse_free(&msg);
 637                         return;
 638                 }
 639
 640                 go = p2p_go_det(p2p->go_intent, *msg.go_intent);
 641                 if (go < 0) {
 642                         p2p_dbg(p2p, "Incompatible GO Intent");
 643                         status = P2P_SC_FAIL_BOTH_GO_INTENT_15;
 644                         goto fail;
 645                 }
 646
 647                 if (p2p_peer_channels(p2p, dev, msg.channel_list,
 648                                       msg.channel_list_len) < 0) {
 649                         p2p_dbg(p2p, "No common channels found");
 650                         status = P2P_SC_FAIL_NO_COMMON_CHANNELS;
 651                         goto fail;
 652                 }
 653
 654                 switch (msg.dev_password_id) {
 655                 case DEV_PW_REGISTRAR_SPECIFIED:
 656                         p2p_dbg(p2p, "PIN from peer Display");
 657                         if (dev->wps_method != WPS_PIN_KEYPAD) {
 658                                 p2p_dbg(p2p, "We have wps_method=%s -> incompatible",
 659                                         p2p_wps_method_str(dev->wps_method));
 660                                 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
 661                                 goto fail;
 662                         }
 663                         break;
 664                 case DEV_PW_USER_SPECIFIED:
 665                         p2p_dbg(p2p, "Peer entered PIN on Keypad");
 666                         if (dev->wps_method != WPS_PIN_DISPLAY) {
 667                                 p2p_dbg(p2p, "We have wps_method=%s -> incompatible",
 668                                         p2p_wps_method_str(dev->wps_method));
 669                                 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
 670                                 goto fail;
 671                         }
 672                         break;
 673                 case DEV_PW_PUSHBUTTON:
 674                         p2p_dbg(p2p, "Peer using pushbutton");
 675                         if (dev->wps_method != WPS_PBC) {
 676                                 p2p_dbg(p2p, "We have wps_method=%s -> incompatible",
 677                                         p2p_wps_method_str(dev->wps_method));
 678                                 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
 679                                 goto fail;
 680                         }
 681                         break;
 682                 default:
 683                         p2p_dbg(p2p, "Unsupported Device Password ID %d",
 684                                 msg.dev_password_id);
 685                         status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
 686                         goto fail;
 687                 }
 688
 689                 if (go && p2p_go_select_channel(p2p, dev, &status) < 0)
 690                         goto fail;
 691
 692                 dev->go_state = go ? LOCAL_GO : REMOTE_GO;
 693                 dev->oper_freq = p2p_channel_to_freq(msg.operating_channel[3],
 694                                                      msg.operating_channel[4]);
 695                 p2p_dbg(p2p, "Peer operating channel preference: %d MHz",
 696                         dev->oper_freq);
 697
 698                 if (msg.config_timeout) {
 699                         dev->go_timeout = msg.config_timeout[0];
 700                         dev->client_timeout = msg.config_timeout[1];
 701                 }
 702
 703                 p2p_dbg(p2p, "GO Negotiation with " MACSTR, MAC2STR(sa));
 704                 if (p2p->state != P2P_IDLE)
 705                         p2p_stop_find_for_freq(p2p, rx_freq);
 706                 p2p_set_state(p2p, P2P_GO_NEG);
 707                 p2p_clear_timeout(p2p);
 708                 dev->dialog_token = msg.dialog_token;
 709                 os_memcpy(dev->intended_addr, msg.intended_addr, ETH_ALEN);
 710                 p2p->go_neg_peer = dev;
 711                 status = P2P_SC_SUCCESS;
 712         }
 713
 714 fail:
 715         if (dev)
 716                 dev->status = status;
 717         resp = p2p_build_go_neg_resp(p2p, dev, msg.dialog_token, status,
 718                                      !tie_breaker);
 719         p2p_parse_free(&msg);
 720         if (resp == NULL)
 721                 return;
 722         p2p_dbg(p2p, "Sending GO Negotiation Response");
 723         if (rx_freq > 0)
 724                 freq = rx_freq;
 725         else
 726                 freq = p2p_channel_to_freq(p2p->cfg->reg_class,
 727                                            p2p->cfg->channel);
 728         if (freq < 0) {
 729                 p2p_dbg(p2p, "Unknown regulatory class/channel");
 730                 wpabuf_free(resp);
 731                 return;
 732         }
 733         if (status == P2P_SC_SUCCESS) {
 734                 p2p->pending_action_state = P2P_PENDING_GO_NEG_RESPONSE;
 735                 dev->flags |= P2P_DEV_WAIT_GO_NEG_CONFIRM;
 736                 if (os_memcmp(sa, p2p->cfg->dev_addr, ETH_ALEN) < 0) {
 737                         /*
 738                          * Peer has smaller address, so the GO Negotiation
 739                          * Response from us is expected to complete
 740                          * negotiation. Ignore a GO Negotiation Response from
 741                          * the peer if it happens to be received after this
 742                          * point due to a race condition in GO Negotiation
 743                          * Request transmission and processing.
 744                          */
 745                         dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
 746                 }
 747         } else
 748                 p2p->pending_action_state =
 749                         P2P_PENDING_GO_NEG_RESPONSE_FAILURE;
 750         if (p2p_send_action(p2p, freq, sa, p2p->cfg->dev_addr,
 751                             p2p->cfg->dev_addr,
 752                             wpabuf_head(resp), wpabuf_len(resp), 500) < 0) {
 753                 p2p_dbg(p2p, "Failed to send Action frame");
 754         }
 755
 756         wpabuf_free(resp);
 757 }
 758
 759
 760 static struct wpabuf * p2p_build_go_neg_conf(struct p2p_data *p2p,
 761                                              struct p2p_device *peer,
 762                                              u8 dialog_token, u8 status,
 763                                              const u8 *resp_chan, int go)
 764 {
 765         struct wpabuf *buf;
 766         u8 *len;
 767         struct p2p_channels res;
 768         u8 group_capab;
 769         size_t extra = 0;
 770
 771         p2p_dbg(p2p, "Building GO Negotiation Confirm");
 772
 773 #ifdef CONFIG_WIFI_DISPLAY
 774         if (p2p->wfd_ie_go_neg)
 775                 extra = wpabuf_len(p2p->wfd_ie_go_neg);
 776 #endif /* CONFIG_WIFI_DISPLAY */
 777
 778         buf = wpabuf_alloc(1000 + extra);
 779         if (buf == NULL)
 780                 return NULL;
 781
 782         p2p_buf_add_public_action_hdr(buf, P2P_GO_NEG_CONF, dialog_token);
 783
 784         len = p2p_buf_add_ie_hdr(buf);
 785         p2p_buf_add_status(buf, status);
 786         group_capab = 0;
 787         if (peer->go_state == LOCAL_GO) {
 788                 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP) {
 789                         group_capab |= P2P_GROUP_CAPAB_PERSISTENT_GROUP;
 790                         if (peer->flags & P2P_DEV_PREFER_PERSISTENT_RECONN)
 791                                 group_capab |=
 792                                         P2P_GROUP_CAPAB_PERSISTENT_RECONN;
 793                 }
 794                 if (p2p->cross_connect)
 795                         group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
 796                 if (p2p->cfg->p2p_intra_bss)
 797                         group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST;
 798         }
 799         p2p_buf_add_capability(buf, p2p->dev_capab &
 800                                ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY,
 801                                group_capab);
 802         if (go || resp_chan == NULL)
 803                 p2p_buf_add_operating_channel(buf, p2p->cfg->country,
 804                                               p2p->op_reg_class,
 805                                               p2p->op_channel);
 806         else
 807                 p2p_buf_add_operating_channel(buf, (const char *) resp_chan,
 808                                               resp_chan[3], resp_chan[4]);
 809         p2p_channels_intersect(&p2p->channels, &peer->channels, &res);
 810         p2p_buf_add_channel_list(buf, p2p->cfg->country, &res);
 811         if (go) {
 812                 p2p_buf_add_group_id(buf, p2p->cfg->dev_addr, p2p->ssid,
 813                                      p2p->ssid_len);
 814         }
 815         p2p_buf_update_ie_hdr(buf, len);
 816
 817 #ifdef CONFIG_WIFI_DISPLAY
 818         if (p2p->wfd_ie_go_neg)
 819                 wpabuf_put_buf(buf, p2p->wfd_ie_go_neg);
 820 #endif /* CONFIG_WIFI_DISPLAY */
 821
 822         return buf;
 823 }
 824
 825
 826 void p2p_process_go_neg_resp(struct p2p_data *p2p, const u8 *sa,
 827                              const u8 *data, size_t len, int rx_freq)
 828 {
 829         struct p2p_device *dev;
 830         struct wpabuf *conf;
 831         int go = -1;
 832         struct p2p_message msg;
 833         u8 status = P2P_SC_SUCCESS;
 834         int freq;
 835
 836         p2p_dbg(p2p, "Received GO Negotiation Response from " MACSTR
 837                 " (freq=%d)", MAC2STR(sa), rx_freq);
 838         dev = p2p_get_device(p2p, sa);
 839         if (dev == NULL || dev->wps_method == WPS_NOT_READY ||
 840             dev != p2p->go_neg_peer) {
 841                 p2p_dbg(p2p, "Not ready for GO negotiation with " MACSTR,
 842                         MAC2STR(sa));
 843                 return;
 844         }
 845
 846         if (p2p_parse(data, len, &msg))
 847                 return;
 848
 849         if (!(dev->flags & P2P_DEV_WAIT_GO_NEG_RESPONSE)) {
 850                 p2p_dbg(p2p, "Was not expecting GO Negotiation Response - ignore");
 851                 p2p_parse_free(&msg);
 852                 return;
 853         }
 854         dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
 855
 856         if (msg.dialog_token != dev->dialog_token) {
 857                 p2p_dbg(p2p, "Unexpected Dialog Token %u (expected %u)",
 858                         msg.dialog_token, dev->dialog_token);
 859                 p2p_parse_free(&msg);
 860                 return;
 861         }
 862
 863         if (!msg.status) {
 864                 p2p_dbg(p2p, "No Status attribute received");
 865                 status = P2P_SC_FAIL_INVALID_PARAMS;
 866                 goto fail;
 867         }
 868         if (*msg.status) {
 869                 p2p_dbg(p2p, "GO Negotiation rejected: status %d", *msg.status);
 870                 dev->go_neg_req_sent = 0;
 871                 if (*msg.status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) {
 872                         p2p_dbg(p2p, "Wait for the peer to become ready for GO Negotiation");
 873                         dev->flags |= P2P_DEV_NOT_YET_READY;
 874                         dev->wait_count = 0;
 875                         p2p_set_state(p2p, P2P_WAIT_PEER_IDLE);
 876                         p2p_set_timeout(p2p, 0, 0);
 877                 } else {
 878                         p2p_dbg(p2p, "Stop GO Negotiation attempt");
 879                         p2p_go_neg_failed(p2p, dev, *msg.status);
 880                 }
 881                 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
 882                 p2p_parse_free(&msg);
 883                 return;
 884         }
 885
 886         if (!msg.capability) {
 887                 p2p_dbg(p2p, "Mandatory Capability attribute missing from GO Negotiation Response");
 888 #ifdef CONFIG_P2P_STRICT
 889                 status = P2P_SC_FAIL_INVALID_PARAMS;
 890                 goto fail;
 891 #endif /* CONFIG_P2P_STRICT */
 892         }
 893
 894         if (!msg.p2p_device_info) {
 895                 p2p_dbg(p2p, "Mandatory P2P Device Info attribute missing from GO Negotiation Response");
 896 #ifdef CONFIG_P2P_STRICT
 897                 status = P2P_SC_FAIL_INVALID_PARAMS;
 898                 goto fail;
 899 #endif /* CONFIG_P2P_STRICT */
 900         }
 901
 902         if (!msg.intended_addr) {
 903                 p2p_dbg(p2p, "No Intended P2P Interface Address attribute received");
 904                 status = P2P_SC_FAIL_INVALID_PARAMS;
 905                 goto fail;
 906         }
 907
 908         if (!msg.go_intent) {
 909                 p2p_dbg(p2p, "No GO Intent attribute received");
 910                 status = P2P_SC_FAIL_INVALID_PARAMS;
 911                 goto fail;
 912         }
 913         if ((*msg.go_intent >> 1) > P2P_MAX_GO_INTENT) {
 914                 p2p_dbg(p2p, "Invalid GO Intent value (%u) received",
 915                         *msg.go_intent >> 1);
 916                 status = P2P_SC_FAIL_INVALID_PARAMS;
 917                 goto fail;
 918         }
 919
 920         go = p2p_go_det(p2p->go_intent, *msg.go_intent);
 921         if (go < 0) {
 922                 p2p_dbg(p2p, "Incompatible GO Intent");
 923                 status = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
 924                 goto fail;
 925         }
 926
 927         if (!go && msg.group_id) {
 928                 /* Store SSID for Provisioning step */
 929                 p2p->ssid_len = msg.group_id_len - ETH_ALEN;
 930                 os_memcpy(p2p->ssid, msg.group_id + ETH_ALEN, p2p->ssid_len);
 931         } else if (!go) {
 932                 p2p_dbg(p2p, "Mandatory P2P Group ID attribute missing from GO Negotiation Response");
 933                 p2p->ssid_len = 0;
 934                 status = P2P_SC_FAIL_INVALID_PARAMS;
 935                 goto fail;
 936         }
 937
 938         if (!msg.config_timeout) {
 939                 p2p_dbg(p2p, "Mandatory Configuration Timeout attribute missing from GO Negotiation Response");
 940 #ifdef CONFIG_P2P_STRICT
 941                 status = P2P_SC_FAIL_INVALID_PARAMS;
 942                 goto fail;
 943 #endif /* CONFIG_P2P_STRICT */
 944         } else {
 945                 dev->go_timeout = msg.config_timeout[0];
 946                 dev->client_timeout = msg.config_timeout[1];
 947         }
 948
 949         if (!msg.operating_channel && !go) {
 950                 /*
 951                  * Note: P2P Client may omit Operating Channel attribute to
 952                  * indicate it does not have a preference.
 953                  */
 954                 p2p_dbg(p2p, "No Operating Channel attribute received");
 955                 status = P2P_SC_FAIL_INVALID_PARAMS;
 956                 goto fail;
 957         }
 958         if (!msg.channel_list) {
 959                 p2p_dbg(p2p, "No Channel List attribute received");
 960                 status = P2P_SC_FAIL_INVALID_PARAMS;
 961                 goto fail;
 962         }
 963
 964         if (p2p_peer_channels(p2p, dev, msg.channel_list,
 965                               msg.channel_list_len) < 0) {
 966                 p2p_dbg(p2p, "No common channels found");
 967                 status = P2P_SC_FAIL_NO_COMMON_CHANNELS;
 968                 goto fail;
 969         }
 970
 971         if (msg.operating_channel) {
 972                 dev->oper_freq = p2p_channel_to_freq(msg.operating_channel[3],
 973                                                      msg.operating_channel[4]);
 974                 p2p_dbg(p2p, "Peer operating channel preference: %d MHz",
 975                         dev->oper_freq);
 976         } else
 977                 dev->oper_freq = 0;
 978
 979         switch (msg.dev_password_id) {
 980         case DEV_PW_REGISTRAR_SPECIFIED:
 981                 p2p_dbg(p2p, "PIN from peer Display");
 982                 if (dev->wps_method != WPS_PIN_KEYPAD) {
 983                         p2p_dbg(p2p, "We have wps_method=%s -> incompatible",
 984                                 p2p_wps_method_str(dev->wps_method));
 985                         status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
 986                         goto fail;
 987                 }
 988                 break;
 989         case DEV_PW_USER_SPECIFIED:
 990                 p2p_dbg(p2p, "Peer entered PIN on Keypad");
 991                 if (dev->wps_method != WPS_PIN_DISPLAY) {
 992                         p2p_dbg(p2p, "We have wps_method=%s -> incompatible",
 993                                 p2p_wps_method_str(dev->wps_method));
 994                         status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
 995                         goto fail;
 996                 }
 997                 break;
 998         case DEV_PW_PUSHBUTTON:
 999                 p2p_dbg(p2p, "Peer using pushbutton");
1000                 if (dev->wps_method != WPS_PBC) {
1001                         p2p_dbg(p2p, "We have wps_method=%s -> incompatible",
1002                                 p2p_wps_method_str(dev->wps_method));
1003                         status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
1004                         goto fail;
1005                 }
1006                 break;
1007         default:
1008                 p2p_dbg(p2p, "Unsupported Device Password ID %d",
1009                         msg.dev_password_id);
1010                 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
1011                 goto fail;
1012         }
1013
1014         if (go && p2p_go_select_channel(p2p, dev, &status) < 0)
1015                 goto fail;
1016
1017         p2p_set_state(p2p, P2P_GO_NEG);
1018         p2p_clear_timeout(p2p);
1019
1020         p2p_dbg(p2p, "GO Negotiation with " MACSTR, MAC2STR(sa));
1021         os_memcpy(dev->intended_addr, msg.intended_addr, ETH_ALEN);
1022
1023 fail:
1024         conf = p2p_build_go_neg_conf(p2p, dev, msg.dialog_token, status,
1025                                      msg.operating_channel, go);
1026         p2p_parse_free(&msg);
1027         if (conf == NULL)
1028                 return;
1029         p2p_dbg(p2p, "Sending GO Negotiation Confirm");
1030         if (status == P2P_SC_SUCCESS) {
1031                 p2p->pending_action_state = P2P_PENDING_GO_NEG_CONFIRM;
1032                 dev->go_state = go ? LOCAL_GO : REMOTE_GO;
1033         } else
1034                 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
1035         if (rx_freq > 0)
1036                 freq = rx_freq;
1037         else
1038                 freq = dev->listen_freq;
1039         if (p2p_send_action(p2p, freq, sa, p2p->cfg->dev_addr, sa,
1040                             wpabuf_head(conf), wpabuf_len(conf), 0) < 0) {
1041                 p2p_dbg(p2p, "Failed to send Action frame");
1042                 p2p_go_neg_failed(p2p, dev, -1);
1043                 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
1044         }
1045         wpabuf_free(conf);
1046         if (status != P2P_SC_SUCCESS) {
1047                 p2p_dbg(p2p, "GO Negotiation failed");
1048                 p2p_go_neg_failed(p2p, dev, status);
1049         }
1050 }
1051
1052
1053 void p2p_process_go_neg_conf(struct p2p_data *p2p, const u8 *sa,
1054                              const u8 *data, size_t len)
1055 {
1056         struct p2p_device *dev;
1057         struct p2p_message msg;
1058
1059         p2p_dbg(p2p, "Received GO Negotiation Confirm from " MACSTR,
1060                 MAC2STR(sa));
1061         dev = p2p_get_device(p2p, sa);
1062         if (dev == NULL || dev->wps_method == WPS_NOT_READY ||
1063             dev != p2p->go_neg_peer) {
1064                 p2p_dbg(p2p, "Not ready for GO negotiation with " MACSTR,
1065                         MAC2STR(sa));
1066                 return;
1067         }
1068
1069         if (p2p->pending_action_state == P2P_PENDING_GO_NEG_RESPONSE) {
1070                 p2p_dbg(p2p, "Stopped waiting for TX status on GO Negotiation Response since we already received Confirmation");
1071                 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
1072         }
1073
1074         if (p2p_parse(data, len, &msg))
1075                 return;
1076
1077         if (!(dev->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) {
1078                 p2p_dbg(p2p, "Was not expecting GO Negotiation Confirm - ignore");
1079                 return;
1080         }
1081         dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM;
1082         p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
1083
1084         if (msg.dialog_token != dev->dialog_token) {
1085                 p2p_dbg(p2p, "Unexpected Dialog Token %u (expected %u)",
1086                         msg.dialog_token, dev->dialog_token);
1087                 p2p_parse_free(&msg);
1088                 return;
1089         }
1090
1091         if (!msg.status) {
1092                 p2p_dbg(p2p, "No Status attribute received");
1093                 p2p_parse_free(&msg);
1094                 return;
1095         }
1096         if (*msg.status) {
1097                 p2p_dbg(p2p, "GO Negotiation rejected: status %d", *msg.status);
1098                 p2p_go_neg_failed(p2p, dev, *msg.status);
1099                 p2p_parse_free(&msg);
1100                 return;
1101         }
1102
1103         if (dev->go_state == REMOTE_GO && msg.group_id) {
1104                 /* Store SSID for Provisioning step */
1105                 p2p->ssid_len = msg.group_id_len - ETH_ALEN;
1106                 os_memcpy(p2p->ssid, msg.group_id + ETH_ALEN, p2p->ssid_len);
1107         } else if (dev->go_state == REMOTE_GO) {
1108                 p2p_dbg(p2p, "Mandatory P2P Group ID attribute missing from GO Negotiation Confirmation");
1109                 p2p->ssid_len = 0;
1110                 p2p_go_neg_failed(p2p, dev, P2P_SC_FAIL_INVALID_PARAMS);
1111                 p2p_parse_free(&msg);
1112                 return;
1113         }
1114
1115         if (!msg.operating_channel) {
1116                 p2p_dbg(p2p, "Mandatory Operating Channel attribute missing from GO Negotiation Confirmation");
1117 #ifdef CONFIG_P2P_STRICT
1118                 p2p_parse_free(&msg);
1119                 return;
1120 #endif /* CONFIG_P2P_STRICT */
1121         } else if (dev->go_state == REMOTE_GO) {
1122                 int oper_freq = p2p_channel_to_freq(msg.operating_channel[3],
1123                                                     msg.operating_channel[4]);
1124                 if (oper_freq != dev->oper_freq) {
1125                         p2p_dbg(p2p, "Updated peer (GO) operating channel preference from %d MHz to %d MHz",
1126                                 dev->oper_freq, oper_freq);
1127                         dev->oper_freq = oper_freq;
1128                 }
1129         }
1130
1131         if (!msg.channel_list) {
1132                 p2p_dbg(p2p, "Mandatory Operating Channel attribute missing from GO Negotiation Confirmation");
1133 #ifdef CONFIG_P2P_STRICT
1134                 p2p_parse_free(&msg);
1135                 return;
1136 #endif /* CONFIG_P2P_STRICT */
1137         }
1138
1139         p2p_parse_free(&msg);
1140
1141         if (dev->go_state == UNKNOWN_GO) {
1142                 /*
1143                  * This should not happen since GO negotiation has already
1144                  * been completed.
1145                  */
1146                 p2p_dbg(p2p, "Unexpected GO Neg state - do not know which end becomes GO");
1147                 return;
1148         }
1149
1150         /*
1151          * The peer could have missed our ctrl::ack frame for GO Negotiation
1152          * Confirm and continue retransmitting the frame. To reduce the
1153          * likelihood of the peer not getting successful TX status for the
1154          * GO Negotiation Confirm frame, wait a short time here before starting
1155          * the group so that we will remain on the current channel to
1156          * acknowledge any possible retransmission from the peer.
1157          */
1158         p2p_dbg(p2p, "20 ms wait on current channel before starting group");
1159         os_sleep(0, 20000);
1160
1161         p2p_go_complete(p2p, dev);
1162 }