libeap/src/p2p/p2p_dev_disc.c

   1 /*
   2  * Wi-Fi Direct - P2P Device Discoverability procedure
   3  * Copyright (c) 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 "p2p_i.h"
  14 #include "p2p.h"
  15
  16
  17 static struct wpabuf * p2p_build_dev_disc_req(struct p2p_data *p2p,
  18                                               struct p2p_device *go,
  19                                               const u8 *dev_id)
  20 {
  21         struct wpabuf *buf;
  22         u8 *len;
  23
  24         buf = wpabuf_alloc(100);
  25         if (buf == NULL)
  26                 return NULL;
  27
  28         go->dialog_token++;
  29         if (go->dialog_token == 0)
  30                 go->dialog_token = 1;
  31         p2p_buf_add_public_action_hdr(buf, P2P_DEV_DISC_REQ, go->dialog_token);
  32
  33         len = p2p_buf_add_ie_hdr(buf);
  34         p2p_buf_add_device_id(buf, dev_id);
  35         p2p_buf_add_group_id(buf, go->info.p2p_device_addr, go->oper_ssid,
  36                              go->oper_ssid_len);
  37         p2p_buf_update_ie_hdr(buf, len);
  38
  39         return buf;
  40 }
  41
  42
  43 void p2p_dev_disc_req_cb(struct p2p_data *p2p, int success)
  44 {
  45         p2p_dbg(p2p, "Device Discoverability Request TX callback: success=%d",
  46                 success);
  47
  48         if (!success) {
  49                 /*
  50                  * Use P2P find, if needed, to find the other device or to
  51                  * retry device discoverability.
  52                  */
  53                 p2p_set_state(p2p, P2P_CONNECT);
  54                 p2p_set_timeout(p2p, 0, 100000);
  55                 return;
  56         }
  57
  58         p2p_dbg(p2p, "GO acknowledged Device Discoverability Request - wait for response");
  59         /*
  60          * TODO: is the remain-on-channel from Action frame TX long enough for
  61          * most cases or should we try to increase its duration and/or start
  62          * another remain-on-channel if needed once the previous one expires?
  63          */
  64 }
  65
  66
  67 int p2p_send_dev_disc_req(struct p2p_data *p2p, struct p2p_device *dev)
  68 {
  69         struct p2p_device *go;
  70         struct wpabuf *req;
  71         unsigned int wait_time;
  72
  73         go = p2p_get_device(p2p, dev->member_in_go_dev);
  74         if (go == NULL || dev->oper_freq <= 0) {
  75                 p2p_dbg(p2p, "Could not find peer entry for GO and frequency to send Device Discoverability Request");
  76                 return -1;
  77         }
  78
  79         req = p2p_build_dev_disc_req(p2p, go, dev->info.p2p_device_addr);
  80         if (req == NULL)
  81                 return -1;
  82
  83         p2p_dbg(p2p, "Sending Device Discoverability Request to GO " MACSTR
  84                 " for client " MACSTR,
  85                 MAC2STR(go->info.p2p_device_addr),
  86                 MAC2STR(dev->info.p2p_device_addr));
  87
  88         p2p->pending_client_disc_go = go;
  89         os_memcpy(p2p->pending_client_disc_addr, dev->info.p2p_device_addr,
  90                   ETH_ALEN);
  91         p2p->pending_action_state = P2P_PENDING_DEV_DISC_REQUEST;
  92         wait_time = 1000;
  93         if (p2p->cfg->max_listen && wait_time > p2p->cfg->max_listen)
  94                 wait_time = p2p->cfg->max_listen;
  95         if (p2p_send_action(p2p, dev->oper_freq, go->info.p2p_device_addr,
  96                             p2p->cfg->dev_addr, go->info.p2p_device_addr,
  97                             wpabuf_head(req), wpabuf_len(req), wait_time) < 0) {
  98                 p2p_dbg(p2p, "Failed to send Action frame");
  99                 wpabuf_free(req);
 100                 /* TODO: how to recover from failure? */
 101                 return -1;
 102         }
 103
 104         wpabuf_free(req);
 105
 106         return 0;
 107 }
 108
 109
 110 static struct wpabuf * p2p_build_dev_disc_resp(u8 dialog_token, u8 status)
 111 {
 112         struct wpabuf *buf;
 113         u8 *len;
 114
 115         buf = wpabuf_alloc(100);
 116         if (buf == NULL)
 117                 return NULL;
 118
 119         p2p_buf_add_public_action_hdr(buf, P2P_DEV_DISC_RESP, dialog_token);
 120
 121         len = p2p_buf_add_ie_hdr(buf);
 122         p2p_buf_add_status(buf, status);
 123         p2p_buf_update_ie_hdr(buf, len);
 124
 125         return buf;
 126 }
 127
 128
 129 void p2p_dev_disc_resp_cb(struct p2p_data *p2p, int success)
 130 {
 131         p2p_dbg(p2p, "Device Discoverability Response TX callback: success=%d",
 132                 success);
 133         p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
 134 }
 135
 136
 137 static void p2p_send_dev_disc_resp(struct p2p_data *p2p, u8 dialog_token,
 138                                    const u8 *addr, int freq, u8 status)
 139 {
 140         struct wpabuf *resp;
 141
 142         resp = p2p_build_dev_disc_resp(dialog_token, status);
 143         if (resp == NULL)
 144                 return;
 145
 146         p2p_dbg(p2p, "Sending Device Discoverability Response to " MACSTR
 147                 " (status %u freq %d)",
 148                 MAC2STR(addr), status, freq);
 149
 150         p2p->pending_action_state = P2P_PENDING_DEV_DISC_RESPONSE;
 151         if (p2p_send_action(p2p, freq, addr, p2p->cfg->dev_addr,
 152                             p2p->cfg->dev_addr,
 153                             wpabuf_head(resp), wpabuf_len(resp), 200) < 0) {
 154                 p2p_dbg(p2p, "Failed to send Action frame");
 155         }
 156
 157         wpabuf_free(resp);
 158 }
 159
 160
 161 void p2p_process_dev_disc_req(struct p2p_data *p2p, const u8 *sa,
 162                               const u8 *data, size_t len, int rx_freq)
 163 {
 164         struct p2p_message msg;
 165         size_t g;
 166
 167         p2p_dbg(p2p, "Received Device Discoverability Request from " MACSTR
 168                 " (freq=%d)", MAC2STR(sa), rx_freq);
 169
 170         if (p2p_parse(data, len, &msg))
 171                 return;
 172
 173         if (msg.dialog_token == 0) {
 174                 p2p_dbg(p2p, "Invalid Dialog Token 0 (must be nonzero) in Device Discoverability Request");
 175                 p2p_send_dev_disc_resp(p2p, msg.dialog_token, sa, rx_freq,
 176                                        P2P_SC_FAIL_INVALID_PARAMS);
 177                 p2p_parse_free(&msg);
 178                 return;
 179         }
 180
 181         if (msg.device_id == NULL) {
 182                 p2p_dbg(p2p, "P2P Device ID attribute missing from Device Discoverability Request");
 183                 p2p_send_dev_disc_resp(p2p, msg.dialog_token, sa, rx_freq,
 184                                        P2P_SC_FAIL_INVALID_PARAMS);
 185                 p2p_parse_free(&msg);
 186                 return;
 187         }
 188
 189         for (g = 0; g < p2p->num_groups; g++) {
 190                 if (p2p_group_go_discover(p2p->groups[g], msg.device_id, sa,
 191                                           rx_freq) == 0) {
 192                         p2p_dbg(p2p, "Scheduled GO Discoverability Request for the target device");
 193                         /*
 194                          * P2P group code will use a callback to indicate TX
 195                          * status, so that we can reply to the request once the
 196                          * target client has acknowledged the request or it has
 197                          * timed out.
 198                          */
 199                         p2p->pending_dev_disc_dialog_token = msg.dialog_token;
 200                         os_memcpy(p2p->pending_dev_disc_addr, sa, ETH_ALEN);
 201                         p2p->pending_dev_disc_freq = rx_freq;
 202                         p2p_parse_free(&msg);
 203                         return;
 204                 }
 205         }
 206
 207         p2p_dbg(p2p, "Requested client was not found in any group or did not support client discoverability");
 208         p2p_send_dev_disc_resp(p2p, msg.dialog_token, sa, rx_freq,
 209                                P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE);
 210         p2p_parse_free(&msg);
 211 }
 212
 213
 214 void p2p_process_dev_disc_resp(struct p2p_data *p2p, const u8 *sa,
 215                                const u8 *data, size_t len)
 216 {
 217         struct p2p_message msg;
 218         struct p2p_device *go;
 219         u8 status;
 220
 221         p2p_dbg(p2p, "Received Device Discoverability Response from " MACSTR,
 222                 MAC2STR(sa));
 223
 224         go = p2p->pending_client_disc_go;
 225         if (go == NULL ||
 226             os_memcmp(sa, go->info.p2p_device_addr, ETH_ALEN) != 0) {
 227                 p2p_dbg(p2p, "Ignore unexpected Device Discoverability Response");
 228                 return;
 229         }
 230
 231         if (p2p_parse(data, len, &msg))
 232                 return;
 233
 234         if (msg.status == NULL) {
 235                 p2p_parse_free(&msg);
 236                 return;
 237         }
 238
 239         if (msg.dialog_token != go->dialog_token) {
 240                 p2p_dbg(p2p, "Ignore Device Discoverability Response with unexpected dialog token %u (expected %u)",
 241                         msg.dialog_token, go->dialog_token);
 242                 p2p_parse_free(&msg);
 243                 return;
 244         }
 245
 246         status = *msg.status;
 247         p2p_parse_free(&msg);
 248
 249         p2p_dbg(p2p, "Device Discoverability Response status %u", status);
 250
 251         if (p2p->go_neg_peer == NULL ||
 252             os_memcmp(p2p->pending_client_disc_addr,
 253                       p2p->go_neg_peer->info.p2p_device_addr, ETH_ALEN) != 0 ||
 254             os_memcmp(p2p->go_neg_peer->member_in_go_dev,
 255                       go->info.p2p_device_addr, ETH_ALEN) != 0) {
 256                 p2p_dbg(p2p, "No pending operation with the client discoverability peer anymore");
 257                 return;
 258         }
 259
 260         if (status == 0) {
 261                 /*
 262                  * Peer is expected to be awake for at least 100 TU; try to
 263                  * connect immediately.
 264                  */
 265                 p2p_dbg(p2p, "Client discoverability request succeeded");
 266                 if (p2p->state == P2P_CONNECT) {
 267                         /*
 268                          * Change state to force the timeout to start in
 269                          * P2P_CONNECT again without going through the short
 270                          * Listen state.
 271                          */
 272                         p2p_set_state(p2p, P2P_CONNECT_LISTEN);
 273                         p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
 274                 }
 275                 p2p_set_timeout(p2p, 0, 0);
 276         } else {
 277                 /*
 278                  * Client discoverability request failed; try to connect from
 279                  * timeout.
 280                  */
 281                 p2p_dbg(p2p, "Client discoverability request failed");
 282                 p2p_set_timeout(p2p, 0, 500000);
 283         }
 284
 285 }
 286
 287
 288 void p2p_go_disc_req_cb(struct p2p_data *p2p, int success)
 289 {
 290         p2p_dbg(p2p, "GO Discoverability Request TX callback: success=%d",
 291                 success);
 292         p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
 293
 294         if (p2p->pending_dev_disc_dialog_token == 0) {
 295                 p2p_dbg(p2p, "No pending Device Discoverability Request");
 296                 return;
 297         }
 298
 299         p2p_send_dev_disc_resp(p2p, p2p->pending_dev_disc_dialog_token,
 300                                p2p->pending_dev_disc_addr,
 301                                p2p->pending_dev_disc_freq,
 302                                success ? P2P_SC_SUCCESS :
 303                                P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE);
 304
 305         p2p->pending_dev_disc_dialog_token = 0;
 306 }
 307
 308
 309 void p2p_process_go_disc_req(struct p2p_data *p2p, const u8 *da, const u8 *sa,
 310                              const u8 *data, size_t len, int rx_freq)
 311 {
 312         unsigned int tu;
 313         struct wpabuf *ies;
 314
 315         p2p_dbg(p2p, "Received GO Discoverability Request - remain awake for 100 TU");
 316
 317         ies = p2p_build_probe_resp_ies(p2p, NULL, 0);
 318         if (ies == NULL)
 319                 return;
 320
 321         /* Remain awake 100 TU on operating channel */
 322         p2p->pending_client_disc_freq = rx_freq;
 323         tu = 100;
 324         if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, rx_freq, 1024 * tu / 1000,
 325                     ies) < 0) {
 326                 p2p_dbg(p2p, "Failed to start listen mode for client discoverability");
 327         }
 328         wpabuf_free(ies);
 329 }