contrib/wpa_supplicant/src/fst/fst_group.c

   1 /*
   2  * FST module - FST group object implementation
   3  * Copyright (c) 2014, Qualcomm Atheros, Inc.
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "utils/includes.h"
  10 #include "utils/common.h"
  11 #include "common/defs.h"
  12 #include "common/ieee802_11_defs.h"
  13 #include "common/ieee802_11_common.h"
  14 #include "drivers/driver.h"
  15 #include "fst/fst_internal.h"
  16 #include "fst/fst_defs.h"
  17
  18
  19 struct dl_list fst_global_groups_list;
  20
  21
  22 static void fst_dump_mb_ies(const char *group_id, const char *ifname,
  23                             struct wpabuf *mbies)
  24 {
  25         const u8 *p = wpabuf_head(mbies);
  26         size_t s = wpabuf_len(mbies);
  27
  28         while (s >= 2) {
  29                 const struct multi_band_ie *mbie =
  30                         (const struct multi_band_ie *) p;
  31                 WPA_ASSERT(mbie->eid == WLAN_EID_MULTI_BAND);
  32                 WPA_ASSERT(2U + mbie->len >= sizeof(*mbie));
  33
  34                 fst_printf(MSG_WARNING,
  35                            "%s: %s: mb_ctrl=%u band_id=%u op_class=%u chan=%u bssid="
  36                            MACSTR
  37                            " beacon_int=%u tsf_offs=[%u %u %u %u %u %u %u %u] mb_cc=0x%02x tmout=%u",
  38                            group_id, ifname,
  39                            mbie->mb_ctrl, mbie->band_id, mbie->op_class,
  40                            mbie->chan, MAC2STR(mbie->bssid), mbie->beacon_int,
  41                            mbie->tsf_offs[0], mbie->tsf_offs[1],
  42                            mbie->tsf_offs[2], mbie->tsf_offs[3],
  43                            mbie->tsf_offs[4], mbie->tsf_offs[5],
  44                            mbie->tsf_offs[6], mbie->tsf_offs[7],
  45                            mbie->mb_connection_capability,
  46                            mbie->fst_session_tmout);
  47
  48                 p += 2 + mbie->len;
  49                 s -= 2 + mbie->len;
  50         }
  51 }
  52
  53
  54 static void fst_fill_mb_ie(struct wpabuf *buf, const u8 *bssid,
  55                            const u8 *own_addr, enum mb_band_id band, u8 channel)
  56 {
  57         struct multi_band_ie *mbie;
  58         size_t len = sizeof(*mbie);
  59
  60         if (own_addr)
  61                 len += ETH_ALEN;
  62
  63         mbie = wpabuf_put(buf, len);
  64
  65         os_memset(mbie, 0, len);
  66
  67         mbie->eid = WLAN_EID_MULTI_BAND;
  68         mbie->len = len - 2;
  69 #ifdef HOSTAPD
  70         mbie->mb_ctrl = MB_STA_ROLE_AP;
  71         mbie->mb_connection_capability = MB_CONNECTION_CAPABILITY_AP;
  72 #else /* HOSTAPD */
  73         mbie->mb_ctrl = MB_STA_ROLE_NON_PCP_NON_AP;
  74         mbie->mb_connection_capability = 0;
  75 #endif /* HOSTAPD */
  76         if (bssid)
  77                 os_memcpy(mbie->bssid, bssid, ETH_ALEN);
  78         mbie->band_id = band;
  79         mbie->op_class = 0;  /* means all */
  80         mbie->chan = channel;
  81         mbie->fst_session_tmout = FST_DEFAULT_SESSION_TIMEOUT_TU;
  82
  83         if (own_addr) {
  84                 mbie->mb_ctrl |= MB_CTRL_STA_MAC_PRESENT;
  85                 os_memcpy(&mbie[1], own_addr, ETH_ALEN);
  86         }
  87 }
  88
  89
  90 static unsigned fst_fill_iface_mb_ies(struct fst_iface *f, struct wpabuf *buf)
  91 {
  92         const  u8 *bssid;
  93
  94         bssid = fst_iface_get_bssid(f);
  95         if (bssid) {
  96                 enum hostapd_hw_mode hw_mode;
  97                 u8 channel;
  98
  99                 if (buf) {
 100                         fst_iface_get_channel_info(f, &hw_mode, &channel);
 101                         fst_fill_mb_ie(buf, bssid, fst_iface_get_addr(f),
 102                                        fst_hw_mode_to_band(hw_mode), channel);
 103                 }
 104                 return 1;
 105         } else {
 106                 unsigned bands[MB_BAND_ID_WIFI_60GHZ + 1] = {};
 107                 struct hostapd_hw_modes *modes;
 108                 enum mb_band_id b;
 109                 int num_modes = fst_iface_get_hw_modes(f, &modes);
 110                 int ret = 0;
 111
 112                 while (num_modes--) {
 113                         b = fst_hw_mode_to_band(modes->mode);
 114                         modes++;
 115                         if (b >= ARRAY_SIZE(bands) || bands[b]++)
 116                                 continue;
 117                         ret++;
 118                         if (buf)
 119                                 fst_fill_mb_ie(buf, NULL, fst_iface_get_addr(f),
 120                                                b, MB_STA_CHANNEL_ALL);
 121                 }
 122                 return ret;
 123         }
 124 }
 125
 126
 127 static struct wpabuf * fst_group_create_mb_ie(struct fst_group *g,
 128                                               struct fst_iface *i)
 129 {
 130         struct wpabuf *buf;
 131         struct fst_iface *f;
 132         unsigned int nof_mbies = 0;
 133         unsigned int nof_ifaces_added = 0;
 134
 135         foreach_fst_group_iface(g, f) {
 136                 if (f == i)
 137                         continue;
 138                 nof_mbies += fst_fill_iface_mb_ies(f, NULL);
 139         }
 140
 141         buf = wpabuf_alloc(nof_mbies *
 142                            (sizeof(struct multi_band_ie) + ETH_ALEN));
 143         if (!buf) {
 144                 fst_printf_iface(i, MSG_ERROR,
 145                                  "cannot allocate mem for %u MB IEs",
 146                                  nof_mbies);
 147                 return NULL;
 148         }
 149
 150         /* The list is sorted in descending order by priorities, so MB IEs will
 151          * be arranged in the same order, as required by spec (see corresponding
 152          * comment in.fst_attach().
 153          */
 154         foreach_fst_group_iface(g, f) {
 155                 if (f == i)
 156                         continue;
 157
 158                 fst_fill_iface_mb_ies(f, buf);
 159                 ++nof_ifaces_added;
 160
 161                 fst_printf_iface(i, MSG_DEBUG, "added to MB IE");
 162         }
 163
 164         if (!nof_ifaces_added) {
 165                 wpabuf_free(buf);
 166                 buf = NULL;
 167                 fst_printf_iface(i, MSG_INFO,
 168                                  "cannot add MB IE: no backup ifaces");
 169         } else {
 170                 fst_dump_mb_ies(fst_group_get_id(g), fst_iface_get_name(i),
 171                                 buf);
 172         }
 173
 174         return buf;
 175 }
 176
 177
 178 static const u8 * fst_mbie_get_peer_addr(const struct multi_band_ie *mbie)
 179 {
 180         const u8 *peer_addr = NULL;
 181
 182         switch (MB_CTRL_ROLE(mbie->mb_ctrl)) {
 183         case MB_STA_ROLE_AP:
 184                 peer_addr = mbie->bssid;
 185                 break;
 186         case MB_STA_ROLE_NON_PCP_NON_AP:
 187                 if (mbie->mb_ctrl & MB_CTRL_STA_MAC_PRESENT &&
 188                     (size_t) 2 + mbie->len >= sizeof(*mbie) + ETH_ALEN)
 189                         peer_addr = (const u8 *) &mbie[1];
 190                 break;
 191         default:
 192                 break;
 193         }
 194
 195         return peer_addr;
 196 }
 197
 198
 199 static const u8 * fst_mbie_get_peer_addr_for_band(const struct wpabuf *mbies,
 200                                                   u8 band_id)
 201 {
 202         const u8 *p = wpabuf_head(mbies);
 203         size_t s = wpabuf_len(mbies);
 204
 205         while (s >= 2) {
 206                 const struct multi_band_ie *mbie =
 207                         (const struct multi_band_ie *) p;
 208
 209                 if (mbie->eid != WLAN_EID_MULTI_BAND) {
 210                         fst_printf(MSG_INFO, "unexpected eid %d", mbie->eid);
 211                         return NULL;
 212                 }
 213
 214                 if (mbie->len < sizeof(*mbie) - 2 || mbie->len > s - 2) {
 215                         fst_printf(MSG_INFO, "invalid mbie len %d",
 216                                    mbie->len);
 217                         return NULL;
 218                 }
 219
 220                 if (mbie->band_id == band_id)
 221                         return fst_mbie_get_peer_addr(mbie);
 222
 223                 p += 2 + mbie->len;
 224                 s -= 2 + mbie->len;
 225         }
 226
 227         fst_printf(MSG_INFO, "mbie doesn't contain band %d", band_id);
 228         return NULL;
 229 }
 230
 231
 232 struct fst_iface * fst_group_get_iface_by_name(struct fst_group *g,
 233                                                const char *ifname)
 234 {
 235         struct fst_iface *f;
 236
 237         foreach_fst_group_iface(g, f) {
 238                 const char *in = fst_iface_get_name(f);
 239
 240                 if (os_strncmp(in, ifname, os_strlen(in)) == 0)
 241                         return f;
 242         }
 243
 244         return NULL;
 245 }
 246
 247
 248 u8 fst_group_assign_dialog_token(struct fst_group *g)
 249 {
 250         g->dialog_token++;
 251         if (g->dialog_token == 0)
 252                 g->dialog_token++;
 253         return g->dialog_token;
 254 }
 255
 256
 257 u32 fst_group_assign_fsts_id(struct fst_group *g)
 258 {
 259         g->fsts_id++;
 260         return g->fsts_id;
 261 }
 262
 263
 264 /**
 265  * fst_group_get_peer_other_connection_1 - Find peer's "other" connection
 266  * (iface, MAC tuple) by using peer's MB IE on iface.
 267  *
 268  * @iface: iface on which FST Setup Request was received
 269  * @peer_addr: Peer address on iface
 270  * @band_id: "other" connection band id
 271  * @other_peer_addr (out): Peer's MAC address on the "other" connection (on the
 272  *   "other" iface)
 273  *
 274  * This function parses peer's MB IE on iface. It looks for peer's MAC address
 275  * on band_id (tmp_peer_addr). Next all interfaces are iterated to find an
 276  * interface which correlates with band_id. If such interface is found, peer
 277  * database is iterated to see if tmp_peer_addr is connected over it.
 278  */
 279 static struct fst_iface *
 280 fst_group_get_peer_other_connection_1(struct fst_iface *iface,
 281                                       const u8 *peer_addr, u8 band_id,
 282                                       u8 *other_peer_addr)
 283 {
 284         const struct wpabuf *mbies;
 285         struct fst_iface *other_iface;
 286         const u8 *tmp_peer_addr;
 287
 288         /* Get peer's MB IEs on iface */
 289         mbies = fst_iface_get_peer_mb_ie(iface, peer_addr);
 290         if (!mbies)
 291                 return NULL;
 292
 293         /* Get peer's MAC address on the "other" interface */
 294         tmp_peer_addr = fst_mbie_get_peer_addr_for_band(mbies, band_id);
 295         if (!tmp_peer_addr) {
 296                 fst_printf(MSG_INFO,
 297                            "couldn't extract other peer addr from mbies");
 298                 return NULL;
 299         }
 300
 301         fst_printf(MSG_DEBUG, "found other peer addr from mbies: " MACSTR,
 302                    MAC2STR(tmp_peer_addr));
 303
 304         foreach_fst_group_iface(fst_iface_get_group(iface), other_iface) {
 305                 if (other_iface == iface ||
 306                     band_id != fst_iface_get_band_id(other_iface))
 307                         continue;
 308                 if (fst_iface_is_connected(other_iface, tmp_peer_addr, FALSE)) {
 309                         os_memcpy(other_peer_addr, tmp_peer_addr, ETH_ALEN);
 310                         return other_iface;
 311                 }
 312         }
 313
 314         return NULL;
 315 }
 316
 317
 318 /**
 319  * fst_group_get_peer_other_connection_2 - Find peer's "other" connection
 320  * (iface, MAC tuple) by using MB IEs of other peers.
 321  *
 322  * @iface: iface on which FST Setup Request was received
 323  * @peer_addr: Peer address on iface
 324  * @band_id: "other" connection band id
 325  * @other_peer_addr (out): Peer's MAC address on the "other" connection (on the
 326  *   "other" iface)
 327  *
 328  * This function iterates all connection (other_iface, cur_peer_addr tuples).
 329  * For each connection, MB IE (of cur_peer_addr on other_iface) is parsed and
 330  * MAC address on iface's band_id is extracted (this_peer_addr).
 331  * this_peer_addr is then compared to peer_addr. A match indicates we have
 332  * found the "other" connection.
 333  */
 334 static struct fst_iface *
 335 fst_group_get_peer_other_connection_2(struct fst_iface *iface,
 336                                       const u8 *peer_addr, u8 band_id,
 337                                       u8 *other_peer_addr)
 338 {
 339         u8 this_band_id = fst_iface_get_band_id(iface);
 340         const u8 *cur_peer_addr, *this_peer_addr;
 341         struct fst_get_peer_ctx *ctx;
 342         struct fst_iface *other_iface;
 343         const struct wpabuf *cur_mbie;
 344
 345         foreach_fst_group_iface(fst_iface_get_group(iface), other_iface) {
 346                 if (other_iface == iface ||
 347                     band_id != fst_iface_get_band_id(other_iface))
 348                         continue;
 349                 cur_peer_addr = fst_iface_get_peer_first(other_iface, &ctx,
 350                                                          TRUE);
 351                 for (; cur_peer_addr;
 352                      cur_peer_addr = fst_iface_get_peer_next(other_iface, &ctx,
 353                                                              TRUE)) {
 354                         cur_mbie = fst_iface_get_peer_mb_ie(other_iface,
 355                                                             cur_peer_addr);
 356                         if (!cur_mbie)
 357                                 continue;
 358                         this_peer_addr = fst_mbie_get_peer_addr_for_band(
 359                                 cur_mbie, this_band_id);
 360                         if (!this_peer_addr)
 361                                 continue;
 362                         if (os_memcmp(this_peer_addr, peer_addr, ETH_ALEN) ==
 363                             0) {
 364                                 os_memcpy(other_peer_addr, cur_peer_addr,
 365                                           ETH_ALEN);
 366                                 return other_iface;
 367                         }
 368                 }
 369         }
 370
 371         return NULL;
 372 }
 373
 374
 375 /**
 376  * fst_group_get_peer_other_connection - Find peer's "other" connection (iface,
 377  * MAC tuple).
 378  *
 379  * @iface: iface on which FST Setup Request was received
 380  * @peer_addr: Peer address on iface
 381  * @band_id: "other" connection band id
 382  * @other_peer_addr (out): Peer's MAC address on the "other" connection (on the
 383  *   "other" iface)
 384  *
 385  * This function is called upon receiving FST Setup Request from some peer who
 386  * has peer_addr on iface. It searches for another connection of the same peer
 387  * on different interface which correlates with band_id. MB IEs received from
 388  * peer (on the two different interfaces) are used to identify same peer.
 389  */
 390 struct fst_iface *
 391 fst_group_get_peer_other_connection(struct fst_iface *iface,
 392                                     const u8 *peer_addr, u8 band_id,
 393                                     u8 *other_peer_addr)
 394 {
 395         struct fst_iface *other_iface;
 396
 397         fst_printf(MSG_DEBUG, "%s: %s:" MACSTR ", %d", __func__,
 398                    fst_iface_get_name(iface), MAC2STR(peer_addr), band_id);
 399
 400         /*
 401          * Two search methods are used:
 402          * 1. Use peer's MB IE on iface to extract peer's MAC address on
 403          *    "other" connection. Then check if such "other" connection exists.
 404          * 2. Iterate peer database, examine each MB IE to see if it points to
 405          *    (iface, peer_addr) tuple
 406          */
 407
 408         other_iface = fst_group_get_peer_other_connection_1(iface, peer_addr,
 409                                                             band_id,
 410                                                             other_peer_addr);
 411         if (other_iface) {
 412                 fst_printf(MSG_DEBUG, "found by method #1. %s:" MACSTR,
 413                            fst_iface_get_name(other_iface),
 414                            MAC2STR(other_peer_addr));
 415                 return other_iface;
 416         }
 417
 418         other_iface = fst_group_get_peer_other_connection_2(iface, peer_addr,
 419                                                             band_id,
 420                                                             other_peer_addr);
 421         if (other_iface) {
 422                 fst_printf(MSG_DEBUG, "found by method #2. %s:" MACSTR,
 423                            fst_iface_get_name(other_iface),
 424                            MAC2STR(other_peer_addr));
 425                 return other_iface;
 426         }
 427
 428         fst_printf(MSG_INFO, "%s: other connection not found", __func__);
 429         return NULL;
 430 }
 431
 432
 433 struct fst_group * fst_group_create(const char *group_id)
 434 {
 435         struct fst_group *g;
 436
 437         g = os_zalloc(sizeof(*g));
 438         if (g == NULL) {
 439                 fst_printf(MSG_ERROR, "%s: Cannot alloc group", group_id);
 440                 return NULL;
 441         }
 442
 443         dl_list_init(&g->ifaces);
 444         os_strlcpy(g->group_id, group_id, sizeof(g->group_id));
 445
 446         dl_list_add_tail(&fst_global_groups_list, &g->global_groups_lentry);
 447         fst_printf_group(g, MSG_DEBUG, "instance created");
 448
 449         foreach_fst_ctrl_call(on_group_created, g);
 450
 451         return g;
 452 }
 453
 454
 455 void fst_group_attach_iface(struct fst_group *g, struct fst_iface *i)
 456 {
 457         struct dl_list *list = &g->ifaces;
 458         struct fst_iface *f;
 459
 460         /*
 461          * Add new interface to the list.
 462          * The list is sorted in descending order by priority to allow
 463          * multiple MB IEs creation according to the spec (see 10.32 Multi-band
 464          * operation, 10.32.1 General), as they should be ordered according to
 465          * priorities.
 466          */
 467         foreach_fst_group_iface(g, f) {
 468                 if (fst_iface_get_priority(f) < fst_iface_get_priority(i))
 469                         break;
 470                 list = &f->group_lentry;
 471         }
 472         dl_list_add(list, &i->group_lentry);
 473 }
 474
 475
 476 void fst_group_detach_iface(struct fst_group *g, struct fst_iface *i)
 477 {
 478         dl_list_del(&i->group_lentry);
 479 }
 480
 481
 482 void fst_group_delete(struct fst_group *group)
 483 {
 484         struct fst_session *s;
 485
 486         dl_list_del(&group->global_groups_lentry);
 487         WPA_ASSERT(dl_list_empty(&group->ifaces));
 488         foreach_fst_ctrl_call(on_group_deleted, group);
 489         fst_printf_group(group, MSG_DEBUG, "instance deleted");
 490         while ((s = fst_session_global_get_first_by_group(group)) != NULL)
 491                 fst_session_delete(s);
 492         os_free(group);
 493 }
 494
 495
 496 Boolean fst_group_delete_if_empty(struct fst_group *group)
 497 {
 498         Boolean is_empty = !fst_group_has_ifaces(group) &&
 499                 !fst_session_global_get_first_by_group(group);
 500
 501         if (is_empty)
 502                 fst_group_delete(group);
 503
 504         return is_empty;
 505 }
 506
 507
 508 void fst_group_update_ie(struct fst_group *g)
 509 {
 510         struct fst_iface *i;
 511
 512         foreach_fst_group_iface(g, i) {
 513                 struct wpabuf *mbie = fst_group_create_mb_ie(g, i);
 514
 515                 if (!mbie)
 516                         fst_printf_iface(i, MSG_WARNING, "cannot create MB IE");
 517
 518                 fst_iface_attach_mbie(i, mbie);
 519                 fst_iface_set_ies(i, mbie);
 520                 fst_printf_iface(i, MSG_DEBUG, "multi-band IE set to %p", mbie);
 521         }
 522 }