| 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 |
bool fst_group_delete_if_empty(struct fst_group *group) |
| 497 |
{ |
| 498 |
bool 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 |
} |