ieee80211_proto.c revision 1.26
1 /* $NetBSD: ieee80211_proto.c,v 1.26 2006/08/30 15:40:00 christos Exp $ */ 2 /*- 3 * Copyright (c) 2001 Atsushi Onoe 4 * Copyright (c) 2002-2005 Sam Leffler, Errno Consulting 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. The name of the author may not be used to endorse or promote products 16 * derived from this software without specific prior written permission. 17 * 18 * Alternatively, this software may be distributed under the terms of the 19 * GNU General Public License ("GPL") version 2 as published by the Free 20 * Software Foundation. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include <sys/cdefs.h> 35 #ifdef __FreeBSD__ 36 __FBSDID("$FreeBSD: src/sys/net80211/ieee80211_proto.c,v 1.23 2005/08/10 16:22:29 sam Exp $"); 37 #endif 38 #ifdef __NetBSD__ 39 __KERNEL_RCSID(0, "$NetBSD: ieee80211_proto.c,v 1.26 2006/08/30 15:40:00 christos Exp $"); 40 #endif 41 42 /* 43 * IEEE 802.11 protocol support. 44 */ 45 46 #include "opt_inet.h" 47 48 #include <sys/param.h> 49 #include <sys/kernel.h> 50 #include <sys/systm.h> 51 52 #include <sys/socket.h> 53 #include <sys/sockio.h> 54 #include <sys/endian.h> 55 #include <sys/errno.h> 56 #include <sys/proc.h> 57 #include <sys/sysctl.h> 58 59 #include <net/if.h> 60 #include <net/if_media.h> 61 #include <net/if_arp.h> 62 #include <net/if_ether.h> 63 #include <net/if_llc.h> 64 65 #include <net80211/ieee80211_netbsd.h> 66 #include <net80211/ieee80211_var.h> 67 68 #include <net/bpf.h> 69 70 #ifdef INET 71 #include <netinet/in.h> 72 #include <net/if_ether.h> 73 #endif 74 75 #include <net/route.h> 76 /* XXX tunables */ 77 #define AGGRESSIVE_MODE_SWITCH_HYSTERESIS 3 /* pkts / 100ms */ 78 #define HIGH_PRI_SWITCH_THRESH 10 /* pkts / 100ms */ 79 80 #define IEEE80211_RATE2MBS(r) (((r) & IEEE80211_RATE_VAL) / 2) 81 82 const char *ieee80211_mgt_subtype_name[] = { 83 "assoc_req", "assoc_resp", "reassoc_req", "reassoc_resp", 84 "probe_req", "probe_resp", "reserved#6", "reserved#7", 85 "beacon", "atim", "disassoc", "auth", 86 "deauth", "reserved#13", "reserved#14", "reserved#15" 87 }; 88 const char *ieee80211_ctl_subtype_name[] = { 89 "reserved#0", "reserved#1", "reserved#2", "reserved#3", 90 "reserved#3", "reserved#5", "reserved#6", "reserved#7", 91 "reserved#8", "reserved#9", "ps_poll", "rts", 92 "cts", "ack", "cf_end", "cf_end_ack" 93 }; 94 const char *ieee80211_state_name[IEEE80211_S_MAX] = { 95 "INIT", /* IEEE80211_S_INIT */ 96 "SCAN", /* IEEE80211_S_SCAN */ 97 "AUTH", /* IEEE80211_S_AUTH */ 98 "ASSOC", /* IEEE80211_S_ASSOC */ 99 "RUN" /* IEEE80211_S_RUN */ 100 }; 101 const char *ieee80211_wme_acnames[] = { 102 "WME_AC_BE", 103 "WME_AC_BK", 104 "WME_AC_VI", 105 "WME_AC_VO", 106 "WME_UPSD", 107 }; 108 109 static int ieee80211_newstate(struct ieee80211com *, enum ieee80211_state, int); 110 111 void 112 ieee80211_proto_attach(struct ieee80211com *ic) 113 { 114 struct ifnet *ifp = ic->ic_ifp; 115 116 /* XXX room for crypto */ 117 ifp->if_hdrlen = sizeof(struct ieee80211_qosframe_addr4); 118 119 ic->ic_rtsthreshold = IEEE80211_RTS_DEFAULT; 120 ic->ic_fragthreshold = IEEE80211_FRAG_DEFAULT; 121 ic->ic_fixed_rate = IEEE80211_FIXED_RATE_NONE; 122 ic->ic_bmiss_max = IEEE80211_BMISS_MAX; 123 ic->ic_mcast_rate = IEEE80211_MCAST_RATE_DEFAULT; 124 ic->ic_protmode = IEEE80211_PROT_CTSONLY; 125 ic->ic_roaming = IEEE80211_ROAMING_AUTO; 126 127 ic->ic_wme.wme_hipri_switch_hysteresis = 128 AGGRESSIVE_MODE_SWITCH_HYSTERESIS; 129 130 /* protocol state change handler */ 131 ic->ic_newstate = ieee80211_newstate; 132 133 /* initialize management frame handlers */ 134 ic->ic_recv_mgmt = ieee80211_recv_mgmt; 135 ic->ic_send_mgmt = ieee80211_send_mgmt; 136 } 137 138 void 139 ieee80211_proto_detach(struct ieee80211com *ic) 140 { 141 142 /* 143 * This should not be needed as we detach when reseting 144 * the state but be conservative here since the 145 * authenticator may do things like spawn kernel threads. 146 */ 147 if (ic->ic_auth->ia_detach) 148 ic->ic_auth->ia_detach(ic); 149 150 IF_PURGE(&ic->ic_mgtq); 151 152 /* 153 * Detach any ACL'ator. 154 */ 155 if (ic->ic_acl != NULL) 156 ic->ic_acl->iac_detach(ic); 157 } 158 159 /* 160 * Simple-minded authenticator module support. 161 */ 162 163 #define IEEE80211_AUTH_MAX (IEEE80211_AUTH_WPA+1) 164 /* XXX well-known names */ 165 static const char *auth_modnames[IEEE80211_AUTH_MAX] = { 166 "wlan_internal", /* IEEE80211_AUTH_NONE */ 167 "wlan_internal", /* IEEE80211_AUTH_OPEN */ 168 "wlan_internal", /* IEEE80211_AUTH_SHARED */ 169 "wlan_xauth", /* IEEE80211_AUTH_8021X */ 170 "wlan_internal", /* IEEE80211_AUTH_AUTO */ 171 "wlan_xauth", /* IEEE80211_AUTH_WPA */ 172 }; 173 static const struct ieee80211_authenticator *authenticators[IEEE80211_AUTH_MAX]; 174 175 static const struct ieee80211_authenticator auth_internal = { 176 .ia_name = "wlan_internal", 177 .ia_attach = NULL, 178 .ia_detach = NULL, 179 .ia_node_join = NULL, 180 .ia_node_leave = NULL, 181 }; 182 183 /* 184 * Setup internal authenticators once; they are never unregistered. 185 */ 186 static void 187 ieee80211_auth_setup(void) 188 { 189 ieee80211_authenticator_register(IEEE80211_AUTH_OPEN, &auth_internal); 190 ieee80211_authenticator_register(IEEE80211_AUTH_SHARED, &auth_internal); 191 ieee80211_authenticator_register(IEEE80211_AUTH_AUTO, &auth_internal); 192 } 193 194 const struct ieee80211_authenticator * 195 ieee80211_authenticator_get(int auth) 196 { 197 static int initialized = 0; 198 if (!initialized) { 199 ieee80211_auth_setup(); 200 initialized = 1; 201 } 202 if (auth >= IEEE80211_AUTH_MAX) 203 return NULL; 204 if (authenticators[auth] == NULL) 205 ieee80211_load_module(auth_modnames[auth]); 206 return authenticators[auth]; 207 } 208 209 void 210 ieee80211_authenticator_register(int type, 211 const struct ieee80211_authenticator *auth) 212 { 213 if (type >= IEEE80211_AUTH_MAX) 214 return; 215 authenticators[type] = auth; 216 } 217 218 void 219 ieee80211_authenticator_unregister(int type) 220 { 221 222 if (type >= IEEE80211_AUTH_MAX) 223 return; 224 authenticators[type] = NULL; 225 } 226 227 /* 228 * Very simple-minded ACL module support. 229 */ 230 /* XXX just one for now */ 231 static const struct ieee80211_aclator *acl = NULL; 232 233 void 234 ieee80211_aclator_register(const struct ieee80211_aclator *iac) 235 { 236 printf("wlan: %s acl policy registered\n", iac->iac_name); 237 acl = iac; 238 } 239 240 void 241 ieee80211_aclator_unregister(const struct ieee80211_aclator *iac) 242 { 243 if (acl == iac) 244 acl = NULL; 245 printf("wlan: %s acl policy unregistered\n", iac->iac_name); 246 } 247 248 const struct ieee80211_aclator * 249 ieee80211_aclator_get(const char *name) 250 { 251 if (acl == NULL) 252 ieee80211_load_module("wlan_acl"); 253 return acl != NULL && strcmp(acl->iac_name, name) == 0 ? acl : NULL; 254 } 255 256 void 257 ieee80211_print_essid(const u_int8_t *essid, int len) 258 { 259 const u_int8_t *p; 260 int i; 261 262 if (len > IEEE80211_NWID_LEN) 263 len = IEEE80211_NWID_LEN; 264 /* determine printable or not */ 265 for (i = 0, p = essid; i < len; i++, p++) { 266 if (*p < ' ' || *p > 0x7e) 267 break; 268 } 269 if (i == len) { 270 printf("\""); 271 for (i = 0, p = essid; i < len; i++, p++) 272 printf("%c", *p); 273 printf("\""); 274 } else { 275 printf("0x"); 276 for (i = 0, p = essid; i < len; i++, p++) 277 printf("%02x", *p); 278 } 279 } 280 281 void 282 ieee80211_dump_pkt(const u_int8_t *buf, int len, int rate, int rssi) 283 { 284 const struct ieee80211_frame *wh; 285 int i; 286 287 wh = (const struct ieee80211_frame *)buf; 288 switch (wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) { 289 case IEEE80211_FC1_DIR_NODS: 290 printf("NODS %s", ether_sprintf(wh->i_addr2)); 291 printf("->%s", ether_sprintf(wh->i_addr1)); 292 printf("(%s)", ether_sprintf(wh->i_addr3)); 293 break; 294 case IEEE80211_FC1_DIR_TODS: 295 printf("TODS %s", ether_sprintf(wh->i_addr2)); 296 printf("->%s", ether_sprintf(wh->i_addr3)); 297 printf("(%s)", ether_sprintf(wh->i_addr1)); 298 break; 299 case IEEE80211_FC1_DIR_FROMDS: 300 printf("FRDS %s", ether_sprintf(wh->i_addr3)); 301 printf("->%s", ether_sprintf(wh->i_addr1)); 302 printf("(%s)", ether_sprintf(wh->i_addr2)); 303 break; 304 case IEEE80211_FC1_DIR_DSTODS: 305 printf("DSDS %s", ether_sprintf((const u_int8_t *)&wh[1])); 306 printf("->%s", ether_sprintf(wh->i_addr3)); 307 printf("(%s", ether_sprintf(wh->i_addr2)); 308 printf("->%s)", ether_sprintf(wh->i_addr1)); 309 break; 310 } 311 switch (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) { 312 case IEEE80211_FC0_TYPE_DATA: 313 printf(" data"); 314 break; 315 case IEEE80211_FC0_TYPE_MGT: 316 printf(" %s", ieee80211_mgt_subtype_name[ 317 (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) 318 >> IEEE80211_FC0_SUBTYPE_SHIFT]); 319 break; 320 default: 321 printf(" type#%d", wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK); 322 break; 323 } 324 if (wh->i_fc[1] & IEEE80211_FC1_WEP) { 325 printf(" WEP [IV"); 326 for (i = 0; i < IEEE80211_WEP_IVLEN; i++) 327 printf(" %.02x", buf[sizeof(*wh)+i]); 328 printf(" KID %u]", buf[sizeof(*wh)+i] >> 6); 329 } 330 if (rate >= 0) 331 printf(" %dM", rate / 2); 332 if (rssi >= 0) 333 printf(" +%d", rssi); 334 printf("\n"); 335 if (len > 0) { 336 for (i = 0; i < len; i++) { 337 if ((i & 1) == 0) 338 printf(" "); 339 printf("%02x", buf[i]); 340 } 341 printf("\n"); 342 } 343 } 344 345 int 346 ieee80211_fix_rate(struct ieee80211_node *ni, int flags) 347 { 348 #define RV(v) ((v) & IEEE80211_RATE_VAL) 349 struct ieee80211com *ic = ni->ni_ic; 350 int i, j, ignore, error; 351 int okrate, badrate, fixedrate; 352 struct ieee80211_rateset *srs, *nrs; 353 u_int8_t r; 354 355 /* 356 * If the fixed rate check was requested but no 357 * fixed has been defined then just remove it. 358 */ 359 if ((flags & IEEE80211_F_DOFRATE) && 360 ic->ic_fixed_rate == IEEE80211_FIXED_RATE_NONE) 361 flags &= ~IEEE80211_F_DOFRATE; 362 error = 0; 363 okrate = badrate = fixedrate = 0; 364 srs = &ic->ic_sup_rates[ieee80211_chan2mode(ic, ni->ni_chan)]; 365 nrs = &ni->ni_rates; 366 for (i = 0; i < nrs->rs_nrates; ) { 367 ignore = 0; 368 if (flags & IEEE80211_F_DOSORT) { 369 /* 370 * Sort rates. 371 */ 372 for (j = i + 1; j < nrs->rs_nrates; j++) { 373 if (RV(nrs->rs_rates[i]) > RV(nrs->rs_rates[j])) { 374 r = nrs->rs_rates[i]; 375 nrs->rs_rates[i] = nrs->rs_rates[j]; 376 nrs->rs_rates[j] = r; 377 } 378 } 379 } 380 r = nrs->rs_rates[i] & IEEE80211_RATE_VAL; 381 badrate = r; 382 if (flags & IEEE80211_F_DOFRATE) { 383 /* 384 * Check any fixed rate is included. 385 */ 386 if (r == RV(srs->rs_rates[ic->ic_fixed_rate])) 387 fixedrate = r; 388 } 389 if (flags & IEEE80211_F_DONEGO) { 390 /* 391 * Check against supported rates. 392 */ 393 for (j = 0; j < srs->rs_nrates; j++) { 394 if (r == RV(srs->rs_rates[j])) { 395 /* 396 * Overwrite with the supported rate 397 * value so any basic rate bit is set. 398 * This insures that response we send 399 * to stations have the necessary basic 400 * rate bit set. 401 */ 402 nrs->rs_rates[i] = srs->rs_rates[j]; 403 break; 404 } 405 } 406 if (j == srs->rs_nrates) { 407 /* 408 * A rate in the node's rate set is not 409 * supported. If this is a basic rate and we 410 * are operating as an AP then this is an error. 411 * Otherwise we just discard/ignore the rate. 412 * Note that this is important for 11b stations 413 * when they want to associate with an 11g AP. 414 */ 415 #ifndef IEEE80211_NO_HOSTAP 416 if (ic->ic_opmode == IEEE80211_M_HOSTAP && 417 (nrs->rs_rates[i] & IEEE80211_RATE_BASIC)) 418 error++; 419 #endif /* !IEEE80211_NO_HOSTAP */ 420 ignore++; 421 } 422 } 423 if (flags & IEEE80211_F_DODEL) { 424 /* 425 * Delete unacceptable rates. 426 */ 427 if (ignore) { 428 nrs->rs_nrates--; 429 for (j = i; j < nrs->rs_nrates; j++) 430 nrs->rs_rates[j] = nrs->rs_rates[j + 1]; 431 nrs->rs_rates[j] = 0; 432 continue; 433 } 434 } 435 if (!ignore) { 436 okrate = nrs->rs_rates[i]; 437 ni->ni_txrate = i; 438 } 439 i++; 440 } 441 if (okrate == 0 || error != 0 || 442 ((flags & IEEE80211_F_DOFRATE) && fixedrate == 0)) 443 return badrate | IEEE80211_RATE_BASIC; 444 else 445 return RV(okrate); 446 #undef RV 447 } 448 449 /* 450 * Reset 11g-related state. 451 */ 452 void 453 ieee80211_reset_erp(struct ieee80211com *ic) 454 { 455 ic->ic_flags &= ~IEEE80211_F_USEPROT; 456 ic->ic_nonerpsta = 0; 457 ic->ic_longslotsta = 0; 458 /* 459 * Short slot time is enabled only when operating in 11g 460 * and not in an IBSS. We must also honor whether or not 461 * the driver is capable of doing it. 462 */ 463 ieee80211_set_shortslottime(ic, 464 ic->ic_curmode == IEEE80211_MODE_11A || 465 (ic->ic_curmode == IEEE80211_MODE_11G && 466 ic->ic_opmode == IEEE80211_M_HOSTAP && 467 (ic->ic_caps & IEEE80211_C_SHSLOT))); 468 /* 469 * Set short preamble and ERP barker-preamble flags. 470 */ 471 if (ic->ic_curmode == IEEE80211_MODE_11A || 472 (ic->ic_caps & IEEE80211_C_SHPREAMBLE)) { 473 ic->ic_flags |= IEEE80211_F_SHPREAMBLE; 474 ic->ic_flags &= ~IEEE80211_F_USEBARKER; 475 } else { 476 ic->ic_flags &= ~IEEE80211_F_SHPREAMBLE; 477 ic->ic_flags |= IEEE80211_F_USEBARKER; 478 } 479 } 480 481 /* 482 * Set the short slot time state and notify the driver. 483 */ 484 void 485 ieee80211_set_shortslottime(struct ieee80211com *ic, int onoff) 486 { 487 if (onoff) 488 ic->ic_flags |= IEEE80211_F_SHSLOT; 489 else 490 ic->ic_flags &= ~IEEE80211_F_SHSLOT; 491 /* notify driver */ 492 if (ic->ic_updateslot != NULL) 493 ic->ic_updateslot(ic->ic_ifp); 494 } 495 496 /* 497 * Check if the specified rate set supports ERP. 498 * NB: the rate set is assumed to be sorted. 499 */ 500 int 501 ieee80211_iserp_rateset(struct ieee80211com *ic, struct ieee80211_rateset *rs) 502 { 503 #define N(a) (sizeof(a) / sizeof(a[0])) 504 static const int rates[] = { 2, 4, 11, 22, 12, 24, 48 }; 505 int i, j; 506 507 if (rs->rs_nrates < N(rates)) 508 return 0; 509 for (i = 0; i < N(rates); i++) { 510 for (j = 0; j < rs->rs_nrates; j++) { 511 int r = rs->rs_rates[j] & IEEE80211_RATE_VAL; 512 if (rates[i] == r) 513 goto next; 514 if (r > rates[i]) 515 return 0; 516 } 517 return 0; 518 next: 519 ; 520 } 521 return 1; 522 #undef N 523 } 524 525 /* 526 * Mark the basic rates for the 11g rate table based on the 527 * operating mode. For real 11g we mark all the 11b rates 528 * and 6, 12, and 24 OFDM. For 11b compatibility we mark only 529 * 11b rates. There's also a pseudo 11a-mode used to mark only 530 * the basic OFDM rates. 531 */ 532 void 533 ieee80211_set11gbasicrates(struct ieee80211_rateset *rs, enum ieee80211_phymode mode) 534 { 535 static const struct ieee80211_rateset basic[] = { 536 { .rs_nrates = 0 }, /* IEEE80211_MODE_AUTO */ 537 { 3, { 12, 24, 48 } }, /* IEEE80211_MODE_11A */ 538 { 2, { 2, 4 } }, /* IEEE80211_MODE_11B */ 539 { 4, { 2, 4, 11, 22 } }, /* IEEE80211_MODE_11G (mixed b/g) */ 540 { .rs_nrates = 0 }, /* IEEE80211_MODE_FH */ 541 /* IEEE80211_MODE_PUREG (not yet) */ 542 { 7, { 2, 4, 11, 22, 12, 24, 48 } }, 543 }; 544 int i, j; 545 546 for (i = 0; i < rs->rs_nrates; i++) { 547 rs->rs_rates[i] &= IEEE80211_RATE_VAL; 548 for (j = 0; j < basic[mode].rs_nrates; j++) 549 if (basic[mode].rs_rates[j] == rs->rs_rates[i]) { 550 rs->rs_rates[i] |= IEEE80211_RATE_BASIC; 551 break; 552 } 553 } 554 } 555 556 /* 557 * WME protocol support. The following parameters come from the spec. 558 */ 559 typedef struct phyParamType { 560 u_int8_t aifsn; 561 u_int8_t logcwmin; 562 u_int8_t logcwmax; 563 u_int16_t txopLimit; 564 u_int8_t acm; 565 } paramType; 566 567 static const struct phyParamType phyParamForAC_BE[IEEE80211_MODE_MAX] = { 568 { 3, 4, 6, 0, 0, }, /* IEEE80211_MODE_AUTO */ 569 { 3, 4, 6, 0, 0, }, /* IEEE80211_MODE_11A */ 570 { 3, 5, 7, 0, 0, }, /* IEEE80211_MODE_11B */ 571 { 3, 4, 6, 0, 0, }, /* IEEE80211_MODE_11G */ 572 { 3, 5, 7, 0, 0, }, /* IEEE80211_MODE_FH */ 573 { 2, 3, 5, 0, 0, }, /* IEEE80211_MODE_TURBO_A */ 574 { 2, 3, 5, 0, 0, }, /* IEEE80211_MODE_TURBO_G */ 575 }; 576 static const struct phyParamType phyParamForAC_BK[IEEE80211_MODE_MAX] = { 577 { 7, 4, 10, 0, 0, }, /* IEEE80211_MODE_AUTO */ 578 { 7, 4, 10, 0, 0, }, /* IEEE80211_MODE_11A */ 579 { 7, 5, 10, 0, 0, }, /* IEEE80211_MODE_11B */ 580 { 7, 4, 10, 0, 0, }, /* IEEE80211_MODE_11G */ 581 { 7, 5, 10, 0, 0, }, /* IEEE80211_MODE_FH */ 582 { 7, 3, 10, 0, 0, }, /* IEEE80211_MODE_TURBO_A */ 583 { 7, 3, 10, 0, 0, }, /* IEEE80211_MODE_TURBO_G */ 584 }; 585 static const struct phyParamType phyParamForAC_VI[IEEE80211_MODE_MAX] = { 586 { 1, 3, 4, 94, 0, }, /* IEEE80211_MODE_AUTO */ 587 { 1, 3, 4, 94, 0, }, /* IEEE80211_MODE_11A */ 588 { 1, 4, 5, 188, 0, }, /* IEEE80211_MODE_11B */ 589 { 1, 3, 4, 94, 0, }, /* IEEE80211_MODE_11G */ 590 { 1, 4, 5, 188, 0, }, /* IEEE80211_MODE_FH */ 591 { 1, 2, 3, 94, 0, }, /* IEEE80211_MODE_TURBO_A */ 592 { 1, 2, 3, 94, 0, }, /* IEEE80211_MODE_TURBO_G */ 593 }; 594 static const struct phyParamType phyParamForAC_VO[IEEE80211_MODE_MAX] = { 595 { 1, 2, 3, 47, 0, }, /* IEEE80211_MODE_AUTO */ 596 { 1, 2, 3, 47, 0, }, /* IEEE80211_MODE_11A */ 597 { 1, 3, 4, 102, 0, }, /* IEEE80211_MODE_11B */ 598 { 1, 2, 3, 47, 0, }, /* IEEE80211_MODE_11G */ 599 { 1, 3, 4, 102, 0, }, /* IEEE80211_MODE_FH */ 600 { 1, 2, 2, 47, 0, }, /* IEEE80211_MODE_TURBO_A */ 601 { 1, 2, 2, 47, 0, }, /* IEEE80211_MODE_TURBO_G */ 602 }; 603 604 static const struct phyParamType bssPhyParamForAC_BE[IEEE80211_MODE_MAX] = { 605 { 3, 4, 10, 0, 0, }, /* IEEE80211_MODE_AUTO */ 606 { 3, 4, 10, 0, 0, }, /* IEEE80211_MODE_11A */ 607 { 3, 5, 10, 0, 0, }, /* IEEE80211_MODE_11B */ 608 { 3, 4, 10, 0, 0, }, /* IEEE80211_MODE_11G */ 609 { 3, 5, 10, 0, 0, }, /* IEEE80211_MODE_FH */ 610 { 2, 3, 10, 0, 0, }, /* IEEE80211_MODE_TURBO_A */ 611 { 2, 3, 10, 0, 0, }, /* IEEE80211_MODE_TURBO_G */ 612 }; 613 static const struct phyParamType bssPhyParamForAC_VI[IEEE80211_MODE_MAX] = { 614 { 2, 3, 4, 94, 0, }, /* IEEE80211_MODE_AUTO */ 615 { 2, 3, 4, 94, 0, }, /* IEEE80211_MODE_11A */ 616 { 2, 4, 5, 188, 0, }, /* IEEE80211_MODE_11B */ 617 { 2, 3, 4, 94, 0, }, /* IEEE80211_MODE_11G */ 618 { 2, 4, 5, 188, 0, }, /* IEEE80211_MODE_FH */ 619 { 2, 2, 3, 94, 0, }, /* IEEE80211_MODE_TURBO_A */ 620 { 2, 2, 3, 94, 0, }, /* IEEE80211_MODE_TURBO_G */ 621 }; 622 static const struct phyParamType bssPhyParamForAC_VO[IEEE80211_MODE_MAX] = { 623 { 2, 2, 3, 47, 0, }, /* IEEE80211_MODE_AUTO */ 624 { 2, 2, 3, 47, 0, }, /* IEEE80211_MODE_11A */ 625 { 2, 3, 4, 102, 0, }, /* IEEE80211_MODE_11B */ 626 { 2, 2, 3, 47, 0, }, /* IEEE80211_MODE_11G */ 627 { 2, 3, 4, 102, 0, }, /* IEEE80211_MODE_FH */ 628 { 1, 2, 2, 47, 0, }, /* IEEE80211_MODE_TURBO_A */ 629 { 1, 2, 2, 47, 0, }, /* IEEE80211_MODE_TURBO_G */ 630 }; 631 632 void 633 ieee80211_wme_initparams(struct ieee80211com *ic) 634 { 635 struct ieee80211_wme_state *wme = &ic->ic_wme; 636 const paramType *pPhyParam, *pBssPhyParam; 637 struct wmeParams *wmep; 638 int i; 639 640 if ((ic->ic_caps & IEEE80211_C_WME) == 0) 641 return; 642 643 for (i = 0; i < WME_NUM_AC; i++) { 644 switch (i) { 645 case WME_AC_BK: 646 pPhyParam = &phyParamForAC_BK[ic->ic_curmode]; 647 pBssPhyParam = &phyParamForAC_BK[ic->ic_curmode]; 648 break; 649 case WME_AC_VI: 650 pPhyParam = &phyParamForAC_VI[ic->ic_curmode]; 651 pBssPhyParam = &bssPhyParamForAC_VI[ic->ic_curmode]; 652 break; 653 case WME_AC_VO: 654 pPhyParam = &phyParamForAC_VO[ic->ic_curmode]; 655 pBssPhyParam = &bssPhyParamForAC_VO[ic->ic_curmode]; 656 break; 657 case WME_AC_BE: 658 default: 659 pPhyParam = &phyParamForAC_BE[ic->ic_curmode]; 660 pBssPhyParam = &bssPhyParamForAC_BE[ic->ic_curmode]; 661 break; 662 } 663 664 wmep = &wme->wme_wmeChanParams.cap_wmeParams[i]; 665 if (ic->ic_opmode == IEEE80211_M_HOSTAP) { 666 wmep->wmep_acm = pPhyParam->acm; 667 wmep->wmep_aifsn = pPhyParam->aifsn; 668 wmep->wmep_logcwmin = pPhyParam->logcwmin; 669 wmep->wmep_logcwmax = pPhyParam->logcwmax; 670 wmep->wmep_txopLimit = pPhyParam->txopLimit; 671 } else { 672 wmep->wmep_acm = pBssPhyParam->acm; 673 wmep->wmep_aifsn = pBssPhyParam->aifsn; 674 wmep->wmep_logcwmin = pBssPhyParam->logcwmin; 675 wmep->wmep_logcwmax = pBssPhyParam->logcwmax; 676 wmep->wmep_txopLimit = pBssPhyParam->txopLimit; 677 678 } 679 IEEE80211_DPRINTF(ic, IEEE80211_MSG_WME, 680 "%s: %s chan [acm %u aifsn %u log2(cwmin) %u " 681 "log2(cwmax) %u txpoLimit %u]\n", __func__ 682 , ieee80211_wme_acnames[i] 683 , wmep->wmep_acm 684 , wmep->wmep_aifsn 685 , wmep->wmep_logcwmin 686 , wmep->wmep_logcwmax 687 , wmep->wmep_txopLimit 688 ); 689 690 wmep = &wme->wme_wmeBssChanParams.cap_wmeParams[i]; 691 wmep->wmep_acm = pBssPhyParam->acm; 692 wmep->wmep_aifsn = pBssPhyParam->aifsn; 693 wmep->wmep_logcwmin = pBssPhyParam->logcwmin; 694 wmep->wmep_logcwmax = pBssPhyParam->logcwmax; 695 wmep->wmep_txopLimit = pBssPhyParam->txopLimit; 696 IEEE80211_DPRINTF(ic, IEEE80211_MSG_WME, 697 "%s: %s bss [acm %u aifsn %u log2(cwmin) %u " 698 "log2(cwmax) %u txpoLimit %u]\n", __func__ 699 , ieee80211_wme_acnames[i] 700 , wmep->wmep_acm 701 , wmep->wmep_aifsn 702 , wmep->wmep_logcwmin 703 , wmep->wmep_logcwmax 704 , wmep->wmep_txopLimit 705 ); 706 } 707 /* NB: check ic_bss to avoid NULL deref on initial attach */ 708 if (ic->ic_bss != NULL) { 709 /* 710 * Calculate agressive mode switching threshold based 711 * on beacon interval. This doesn't need locking since 712 * we're only called before entering the RUN state at 713 * which point we start sending beacon frames. 714 */ 715 wme->wme_hipri_switch_thresh = 716 (HIGH_PRI_SWITCH_THRESH * ic->ic_bss->ni_intval) / 100; 717 ieee80211_wme_updateparams(ic); 718 } 719 } 720 721 /* 722 * Update WME parameters for ourself and the BSS. 723 */ 724 void 725 ieee80211_wme_updateparams_locked(struct ieee80211com *ic) 726 { 727 static const paramType phyParam[IEEE80211_MODE_MAX] = { 728 { 2, 4, 10, 64, 0, }, /* IEEE80211_MODE_AUTO */ 729 { 2, 4, 10, 64, 0, }, /* IEEE80211_MODE_11A */ 730 { 2, 5, 10, 64, 0, }, /* IEEE80211_MODE_11B */ 731 { 2, 4, 10, 64, 0, }, /* IEEE80211_MODE_11G */ 732 { 2, 5, 10, 64, 0, }, /* IEEE80211_MODE_FH */ 733 { 1, 3, 10, 64, 0, }, /* IEEE80211_MODE_TURBO_A */ 734 { 1, 3, 10, 64, 0, }, /* IEEE80211_MODE_TURBO_G */ 735 }; 736 struct ieee80211_wme_state *wme = &ic->ic_wme; 737 const struct wmeParams *wmep; 738 struct wmeParams *chanp, *bssp; 739 int i; 740 741 /* set up the channel access parameters for the physical device */ 742 for (i = 0; i < WME_NUM_AC; i++) { 743 chanp = &wme->wme_chanParams.cap_wmeParams[i]; 744 wmep = &wme->wme_wmeChanParams.cap_wmeParams[i]; 745 chanp->wmep_aifsn = wmep->wmep_aifsn; 746 chanp->wmep_logcwmin = wmep->wmep_logcwmin; 747 chanp->wmep_logcwmax = wmep->wmep_logcwmax; 748 chanp->wmep_txopLimit = wmep->wmep_txopLimit; 749 750 chanp = &wme->wme_bssChanParams.cap_wmeParams[i]; 751 wmep = &wme->wme_wmeBssChanParams.cap_wmeParams[i]; 752 chanp->wmep_aifsn = wmep->wmep_aifsn; 753 chanp->wmep_logcwmin = wmep->wmep_logcwmin; 754 chanp->wmep_logcwmax = wmep->wmep_logcwmax; 755 chanp->wmep_txopLimit = wmep->wmep_txopLimit; 756 } 757 758 /* 759 * This implements agressive mode as found in certain 760 * vendors' AP's. When there is significant high 761 * priority (VI/VO) traffic in the BSS throttle back BE 762 * traffic by using conservative parameters. Otherwise 763 * BE uses agressive params to optimize performance of 764 * legacy/non-QoS traffic. 765 */ 766 if ((ic->ic_opmode == IEEE80211_M_HOSTAP && 767 (wme->wme_flags & WME_F_AGGRMODE) == 0) || 768 (ic->ic_opmode != IEEE80211_M_HOSTAP && 769 (ic->ic_bss->ni_flags & IEEE80211_NODE_QOS) == 0) || 770 (ic->ic_flags & IEEE80211_F_WME) == 0) { 771 chanp = &wme->wme_chanParams.cap_wmeParams[WME_AC_BE]; 772 bssp = &wme->wme_bssChanParams.cap_wmeParams[WME_AC_BE]; 773 774 chanp->wmep_aifsn = bssp->wmep_aifsn = 775 phyParam[ic->ic_curmode].aifsn; 776 chanp->wmep_logcwmin = bssp->wmep_logcwmin = 777 phyParam[ic->ic_curmode].logcwmin; 778 chanp->wmep_logcwmax = bssp->wmep_logcwmax = 779 phyParam[ic->ic_curmode].logcwmax; 780 chanp->wmep_txopLimit = bssp->wmep_txopLimit = 781 (ic->ic_caps & IEEE80211_C_BURST) ? 782 phyParam[ic->ic_curmode].txopLimit : 0; 783 IEEE80211_DPRINTF(ic, IEEE80211_MSG_WME, 784 "%s: %s [acm %u aifsn %u log2(cwmin) %u " 785 "log2(cwmax) %u txpoLimit %u]\n", __func__ 786 , ieee80211_wme_acnames[WME_AC_BE] 787 , chanp->wmep_acm 788 , chanp->wmep_aifsn 789 , chanp->wmep_logcwmin 790 , chanp->wmep_logcwmax 791 , chanp->wmep_txopLimit 792 ); 793 } 794 795 #ifndef IEEE80211_NO_HOSTAP 796 if (ic->ic_opmode == IEEE80211_M_HOSTAP && 797 ic->ic_sta_assoc < 2 && (wme->wme_flags & WME_F_AGGRMODE) == 0) { 798 static const u_int8_t logCwMin[IEEE80211_MODE_MAX] = { 799 3, /* IEEE80211_MODE_AUTO */ 800 3, /* IEEE80211_MODE_11A */ 801 4, /* IEEE80211_MODE_11B */ 802 3, /* IEEE80211_MODE_11G */ 803 4, /* IEEE80211_MODE_FH */ 804 3, /* IEEE80211_MODE_TURBO_A */ 805 3, /* IEEE80211_MODE_TURBO_G */ 806 }; 807 chanp = &wme->wme_chanParams.cap_wmeParams[WME_AC_BE]; 808 bssp = &wme->wme_bssChanParams.cap_wmeParams[WME_AC_BE]; 809 810 chanp->wmep_logcwmin = bssp->wmep_logcwmin = 811 logCwMin[ic->ic_curmode]; 812 IEEE80211_DPRINTF(ic, IEEE80211_MSG_WME, 813 "%s: %s log2(cwmin) %u\n", __func__ 814 , ieee80211_wme_acnames[WME_AC_BE] 815 , chanp->wmep_logcwmin 816 ); 817 } 818 if (ic->ic_opmode == IEEE80211_M_HOSTAP) { /* XXX ibss? */ 819 /* 820 * Arrange for a beacon update and bump the parameter 821 * set number so associated stations load the new values. 822 */ 823 wme->wme_bssChanParams.cap_info = 824 (wme->wme_bssChanParams.cap_info+1) & WME_QOSINFO_COUNT; 825 ic->ic_flags |= IEEE80211_F_WMEUPDATE; 826 } 827 #endif /* !IEEE80211_NO_HOSTAP */ 828 829 wme->wme_update(ic); 830 831 IEEE80211_DPRINTF(ic, IEEE80211_MSG_WME, 832 "%s: WME params updated, cap_info 0x%x\n", __func__, 833 ic->ic_opmode == IEEE80211_M_STA ? 834 wme->wme_wmeChanParams.cap_info : 835 wme->wme_bssChanParams.cap_info); 836 } 837 838 void 839 ieee80211_wme_updateparams(struct ieee80211com *ic) 840 { 841 842 if (ic->ic_caps & IEEE80211_C_WME) { 843 IEEE80211_BEACON_LOCK(ic); 844 ieee80211_wme_updateparams_locked(ic); 845 IEEE80211_BEACON_UNLOCK(ic); 846 } 847 } 848 849 #ifndef IEEE80211_NO_HOSTAP 850 static void 851 sta_disassoc(void *arg, struct ieee80211_node *ni) 852 { 853 struct ieee80211com *ic = arg; 854 855 if (ni->ni_associd != 0) { 856 IEEE80211_SEND_MGMT(ic, ni, IEEE80211_FC0_SUBTYPE_DISASSOC, 857 IEEE80211_REASON_ASSOC_LEAVE); 858 ieee80211_node_leave(ic, ni); 859 } 860 } 861 #endif /* !IEEE80211_NO_HOSTAP */ 862 863 void 864 ieee80211_beacon_miss(struct ieee80211com *ic) 865 { 866 867 if (ic->ic_flags & IEEE80211_F_SCAN) { 868 /* XXX check ic_curchan != ic_bsschan? */ 869 return; 870 } 871 IEEE80211_DPRINTF(ic, 872 IEEE80211_MSG_STATE | IEEE80211_MSG_DEBUG, 873 "%s\n", "beacon miss"); 874 875 /* 876 * Our handling is only meaningful for stations that are 877 * associated; any other conditions else will be handled 878 * through different means (e.g. the tx timeout on mgt frames). 879 */ 880 if (ic->ic_opmode != IEEE80211_M_STA || ic->ic_state != IEEE80211_S_RUN) 881 return; 882 883 if (++ic->ic_bmiss_count < ic->ic_bmiss_max) { 884 /* 885 * Send a directed probe req before falling back to a scan; 886 * if we receive a response ic_bmiss_count will be reset. 887 * Some cards mistakenly report beacon miss so this avoids 888 * the expensive scan if the ap is still there. 889 */ 890 ieee80211_send_probereq(ic->ic_bss, ic->ic_myaddr, 891 ic->ic_bss->ni_bssid, ic->ic_bss->ni_bssid, 892 ic->ic_bss->ni_essid, ic->ic_bss->ni_esslen, 893 ic->ic_opt_ie, ic->ic_opt_ie_len); 894 return; 895 } 896 ic->ic_bmiss_count = 0; 897 ieee80211_new_state(ic, IEEE80211_S_SCAN, 0); 898 } 899 900 #ifndef IEEE80211_NO_HOSTAP 901 static void 902 sta_deauth(void *arg, struct ieee80211_node *ni) 903 { 904 struct ieee80211com *ic = arg; 905 906 IEEE80211_SEND_MGMT(ic, ni, IEEE80211_FC0_SUBTYPE_DEAUTH, 907 IEEE80211_REASON_ASSOC_LEAVE); 908 } 909 #endif /* !IEEE80211_NO_HOSTAP */ 910 911 static int 912 ieee80211_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg) 913 { 914 struct ifnet *ifp = ic->ic_ifp; 915 struct ieee80211_node *ni; 916 enum ieee80211_state ostate; 917 918 ostate = ic->ic_state; 919 IEEE80211_DPRINTF(ic, IEEE80211_MSG_STATE, "%s: %s -> %s\n", __func__, 920 ieee80211_state_name[ostate], ieee80211_state_name[nstate]); 921 ic->ic_state = nstate; /* state transition */ 922 ni = ic->ic_bss; /* NB: no reference held */ 923 switch (nstate) { 924 case IEEE80211_S_INIT: 925 switch (ostate) { 926 case IEEE80211_S_INIT: 927 break; 928 case IEEE80211_S_RUN: 929 switch (ic->ic_opmode) { 930 case IEEE80211_M_STA: 931 IEEE80211_SEND_MGMT(ic, ni, 932 IEEE80211_FC0_SUBTYPE_DISASSOC, 933 IEEE80211_REASON_ASSOC_LEAVE); 934 ieee80211_sta_leave(ic, ni); 935 break; 936 case IEEE80211_M_HOSTAP: 937 #ifndef IEEE80211_NO_HOSTAP 938 ieee80211_iterate_nodes(&ic->ic_sta, 939 sta_disassoc, ic); 940 #endif /* !IEEE80211_NO_HOSTAP */ 941 break; 942 default: 943 break; 944 } 945 goto reset; 946 case IEEE80211_S_ASSOC: 947 switch (ic->ic_opmode) { 948 case IEEE80211_M_STA: 949 IEEE80211_SEND_MGMT(ic, ni, 950 IEEE80211_FC0_SUBTYPE_DEAUTH, 951 IEEE80211_REASON_AUTH_LEAVE); 952 break; 953 case IEEE80211_M_HOSTAP: 954 #ifndef IEEE80211_NO_HOSTAP 955 ieee80211_iterate_nodes(&ic->ic_sta, 956 sta_deauth, ic); 957 #endif /* !IEEE80211_NO_HOSTAP */ 958 break; 959 default: 960 break; 961 } 962 goto reset; 963 case IEEE80211_S_SCAN: 964 ieee80211_cancel_scan(ic); 965 goto reset; 966 case IEEE80211_S_AUTH: 967 reset: 968 ic->ic_mgt_timer = 0; 969 IF_PURGE(&ic->ic_mgtq); 970 ieee80211_reset_bss(ic); 971 break; 972 } 973 if (ic->ic_auth->ia_detach != NULL) 974 ic->ic_auth->ia_detach(ic); 975 break; 976 case IEEE80211_S_SCAN: 977 switch (ostate) { 978 case IEEE80211_S_INIT: 979 if ((ic->ic_opmode == IEEE80211_M_HOSTAP || 980 ic->ic_opmode == IEEE80211_M_IBSS || 981 ic->ic_opmode == IEEE80211_M_AHDEMO) && 982 ic->ic_des_chan != IEEE80211_CHAN_ANYC) { 983 /* 984 * AP operation and we already have a channel; 985 * bypass the scan and startup immediately. 986 */ 987 ieee80211_create_ibss(ic, ic->ic_des_chan); 988 } else { 989 ieee80211_begin_scan(ic, arg); 990 } 991 break; 992 case IEEE80211_S_SCAN: 993 /* 994 * Scan next. If doing an active scan probe 995 * for the requested ap (if any). 996 */ 997 if (ic->ic_flags & IEEE80211_F_ASCAN) 998 ieee80211_probe_curchan(ic, 0); 999 break; 1000 case IEEE80211_S_RUN: 1001 /* beacon miss */ 1002 IEEE80211_DPRINTF(ic, IEEE80211_MSG_STATE, 1003 "no recent beacons from %s; rescanning\n", 1004 ether_sprintf(ic->ic_bss->ni_bssid)); 1005 ieee80211_sta_leave(ic, ni); 1006 ic->ic_flags &= ~IEEE80211_F_SIBSS; /* XXX */ 1007 /* FALLTHRU */ 1008 case IEEE80211_S_AUTH: 1009 case IEEE80211_S_ASSOC: 1010 /* timeout restart scan */ 1011 ni = ieee80211_find_node(&ic->ic_scan, 1012 ic->ic_bss->ni_macaddr); 1013 if (ni != NULL) { 1014 ni->ni_fails++; 1015 ieee80211_unref_node(&ni); 1016 } 1017 if (ic->ic_roaming == IEEE80211_ROAMING_AUTO) 1018 ieee80211_begin_scan(ic, arg); 1019 break; 1020 } 1021 break; 1022 case IEEE80211_S_AUTH: 1023 switch (ostate) { 1024 case IEEE80211_S_INIT: 1025 case IEEE80211_S_SCAN: 1026 IEEE80211_SEND_MGMT(ic, ni, 1027 IEEE80211_FC0_SUBTYPE_AUTH, 1); 1028 break; 1029 case IEEE80211_S_AUTH: 1030 case IEEE80211_S_ASSOC: 1031 switch (arg) { 1032 case IEEE80211_FC0_SUBTYPE_AUTH: 1033 /* ??? */ 1034 IEEE80211_SEND_MGMT(ic, ni, 1035 IEEE80211_FC0_SUBTYPE_AUTH, 2); 1036 break; 1037 case IEEE80211_FC0_SUBTYPE_DEAUTH: 1038 /* ignore and retry scan on timeout */ 1039 break; 1040 } 1041 break; 1042 case IEEE80211_S_RUN: 1043 switch (arg) { 1044 case IEEE80211_FC0_SUBTYPE_AUTH: 1045 IEEE80211_SEND_MGMT(ic, ni, 1046 IEEE80211_FC0_SUBTYPE_AUTH, 2); 1047 ic->ic_state = ostate; /* stay RUN */ 1048 break; 1049 case IEEE80211_FC0_SUBTYPE_DEAUTH: 1050 ieee80211_sta_leave(ic, ni); 1051 if (ic->ic_roaming == IEEE80211_ROAMING_AUTO) { 1052 /* try to reauth */ 1053 IEEE80211_SEND_MGMT(ic, ni, 1054 IEEE80211_FC0_SUBTYPE_AUTH, 1); 1055 } 1056 break; 1057 } 1058 break; 1059 } 1060 break; 1061 case IEEE80211_S_ASSOC: 1062 switch (ostate) { 1063 case IEEE80211_S_INIT: 1064 case IEEE80211_S_SCAN: 1065 case IEEE80211_S_ASSOC: 1066 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ANY, 1067 "%s: invalid transition\n", __func__); 1068 break; 1069 case IEEE80211_S_AUTH: 1070 IEEE80211_SEND_MGMT(ic, ni, 1071 IEEE80211_FC0_SUBTYPE_ASSOC_REQ, 0); 1072 break; 1073 case IEEE80211_S_RUN: 1074 ieee80211_sta_leave(ic, ni); 1075 if (ic->ic_roaming == IEEE80211_ROAMING_AUTO) { 1076 IEEE80211_SEND_MGMT(ic, ni, 1077 IEEE80211_FC0_SUBTYPE_ASSOC_REQ, 1); 1078 } 1079 break; 1080 } 1081 break; 1082 case IEEE80211_S_RUN: 1083 if (ic->ic_flags & IEEE80211_F_WPA) { 1084 /* XXX validate prerequisites */ 1085 } 1086 switch (ostate) { 1087 case IEEE80211_S_INIT: 1088 if (ic->ic_opmode == IEEE80211_M_MONITOR) 1089 break; 1090 /* fall thru... */ 1091 case IEEE80211_S_AUTH: 1092 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ANY, 1093 "%s: invalid transition\n", __func__); 1094 /* fall thru... */ 1095 case IEEE80211_S_RUN: 1096 break; 1097 case IEEE80211_S_SCAN: /* adhoc/hostap mode */ 1098 case IEEE80211_S_ASSOC: /* infra mode */ 1099 IASSERT(ni->ni_txrate < ni->ni_rates.rs_nrates, 1100 ("%s: bogus xmit rate %u setup\n", __func__, 1101 ni->ni_txrate)); 1102 #ifdef IEEE80211_DEBUG 1103 if (ieee80211_msg_debug(ic)) { 1104 if (ic->ic_opmode == IEEE80211_M_STA) 1105 if_printf(ifp, "associated "); 1106 else 1107 if_printf(ifp, "synchronized "); 1108 printf("with %s ssid ", 1109 ether_sprintf(ni->ni_bssid)); 1110 ieee80211_print_essid(ic->ic_bss->ni_essid, 1111 ni->ni_esslen); 1112 printf(" channel %d start %uMb\n", 1113 ieee80211_chan2ieee(ic, ic->ic_curchan), 1114 IEEE80211_RATE2MBS(ni->ni_rates.rs_rates[ni->ni_txrate])); 1115 } 1116 #endif 1117 ic->ic_mgt_timer = 0; 1118 if (ic->ic_opmode == IEEE80211_M_STA) 1119 ieee80211_notify_node_join(ic, ni, 1120 arg == IEEE80211_FC0_SUBTYPE_ASSOC_RESP); 1121 (*ifp->if_start)(ifp); /* XXX not authorized yet */ 1122 break; 1123 } 1124 /* 1125 * Start/stop the authenticator when operating as an 1126 * AP. We delay until here to allow configuration to 1127 * happen out of order. 1128 */ 1129 if (ic->ic_opmode == IEEE80211_M_HOSTAP && /* XXX IBSS/AHDEMO */ 1130 ic->ic_auth->ia_attach != NULL) { 1131 /* XXX check failure */ 1132 ic->ic_auth->ia_attach(ic); 1133 } else if (ic->ic_auth->ia_detach != NULL) { 1134 ic->ic_auth->ia_detach(ic); 1135 } 1136 /* 1137 * When 802.1x is not in use mark the port authorized 1138 * at this point so traffic can flow. 1139 */ 1140 if (ni->ni_authmode != IEEE80211_AUTH_8021X) 1141 ieee80211_node_authorize(ni); 1142 /* 1143 * Enable inactivity processing. 1144 * XXX 1145 */ 1146 ic->ic_scan.nt_inact_timer = IEEE80211_INACT_WAIT; 1147 ic->ic_sta.nt_inact_timer = IEEE80211_INACT_WAIT; 1148 break; 1149 } 1150 return 0; 1151 } 1152
Indexes created Tue Sep 23 07:09:52 GMT 2025