ieee80211_ioctl.c revision 1.60.18.9
1 /* $NetBSD: ieee80211_ioctl.c,v 1.60.18.9 2020/04/13 08:05:16 martin Exp $ */ 2 3 /*- 4 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 5 * 6 * Copyright (c) 2001 Atsushi Onoe 7 * Copyright (c) 2002-2009 Sam Leffler, Errno Consulting 8 * All rights reserved. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 #include <sys/cdefs.h> 32 #ifdef __NetBSD__ 33 __KERNEL_RCSID(0, "$NetBSD: ieee80211_ioctl.c,v 1.60.18.9 2020/04/13 08:05:16 martin Exp $"); 34 #endif 35 36 /* 37 * IEEE 802.11 ioctl support (FreeBSD-specific) 38 */ 39 40 #ifdef _KERNEL_OPT 41 #include "opt_inet.h" 42 #include "opt_wlan.h" 43 #endif 44 45 #include <sys/endian.h> 46 #include <sys/param.h> 47 #include <sys/kernel.h> 48 #include <sys/malloc.h> 49 #if __FreeBSD__ 50 #include <sys/priv.h> 51 #endif 52 #include <sys/socket.h> 53 #include <sys/sockio.h> 54 #include <sys/systm.h> 55 #include <sys/proc.h> 56 #include <sys/kauth.h> 57 #include <sys/module.h> 58 #include <sys/compat_stub.h> 59 60 #include <net/if.h> 61 #if __FreeBSD__ 62 #include <net/if_var.h> 63 #endif 64 #include <net/if_dl.h> 65 #include <net/if_media.h> 66 #if __FreeBSD__ 67 #include <net/ethernet.h> 68 #endif 69 #if __NetBSD__ 70 #include <net/if_ether.h> 71 #endif 72 73 #ifdef INET 74 #include <netinet/in.h> 75 #if __FreeBSD__ 76 #include <netinet/if_ether.h> 77 #endif 78 #if __NetBSD__ 79 #include <netinet/if_inarp.h> 80 #endif 81 #endif 82 83 #include <net80211/ieee80211_var.h> 84 #include <net80211/ieee80211_ioctl.h> 85 #include <net80211/ieee80211_regdomain.h> 86 #include <net80211/ieee80211_input.h> 87 88 #ifdef __NetBSD__ 89 #undef KASSERT 90 #define KASSERT(__cond, __complaint) FBSDKASSERT(__cond, __complaint) 91 #endif 92 93 #define IS_UP_AUTO(_vap) \ 94 (IFNET_IS_UP_RUNNING((_vap)->iv_ifp) && \ 95 (_vap)->iv_roaming == IEEE80211_ROAMING_AUTO) 96 97 static const uint8_t zerobssid[IEEE80211_ADDR_LEN]; 98 static struct ieee80211_channel *findchannel(struct ieee80211com *, 99 int ieee, int mode); 100 static int ieee80211_scanreq(struct ieee80211vap *, 101 struct ieee80211_scan_req *); 102 103 static int 104 ieee80211_ioctl_getkey(struct ieee80211vap *vap, struct ieee80211req *ireq) 105 { 106 struct ieee80211com *ic = vap->iv_ic; 107 struct ieee80211_node *ni; 108 struct ieee80211req_key ik; 109 struct ieee80211_key *wk; 110 const struct ieee80211_cipher *cip; 111 u_int kid; 112 int error; 113 114 if (ireq->i_len != sizeof(ik)) 115 return EINVAL; 116 error = copyin(ireq->i_data, &ik, sizeof(ik)); 117 if (error) 118 return error; 119 kid = ik.ik_keyix; 120 if (kid == IEEE80211_KEYIX_NONE) { 121 ni = ieee80211_find_vap_node(&ic->ic_sta, vap, ik.ik_macaddr); 122 if (ni == NULL) 123 return ENOENT; 124 wk = &ni->ni_ucastkey; 125 } else { 126 if (kid >= IEEE80211_WEP_NKID) 127 return EINVAL; 128 wk = &vap->iv_nw_keys[kid]; 129 IEEE80211_ADDR_COPY(&ik.ik_macaddr, vap->iv_bss->ni_macaddr); 130 ni = NULL; 131 } 132 cip = wk->wk_cipher; 133 ik.ik_type = cip->ic_cipher; 134 ik.ik_keylen = wk->wk_keylen; 135 ik.ik_flags = wk->wk_flags & (IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV); 136 if (wk->wk_keyix == vap->iv_def_txkey) 137 ik.ik_flags |= IEEE80211_KEY_DEFAULT; 138 if (priv_check(curthread, PRIV_NET80211_GETKEY) == 0) { 139 /* NB: only root can read key data */ 140 ik.ik_keyrsc = wk->wk_keyrsc[IEEE80211_NONQOS_TID]; 141 ik.ik_keytsc = wk->wk_keytsc; 142 memcpy(ik.ik_keydata, wk->wk_key, wk->wk_keylen); 143 if (cip->ic_cipher == IEEE80211_CIPHER_TKIP) { 144 memcpy(ik.ik_keydata+wk->wk_keylen, 145 wk->wk_key + IEEE80211_KEYBUF_SIZE, 146 IEEE80211_MICBUF_SIZE); 147 ik.ik_keylen += IEEE80211_MICBUF_SIZE; 148 } 149 } else { 150 ik.ik_keyrsc = 0; 151 ik.ik_keytsc = 0; 152 memset(ik.ik_keydata, 0, sizeof(ik.ik_keydata)); 153 } 154 if (ni != NULL) 155 ieee80211_free_node(ni); 156 return copyout(&ik, ireq->i_data, sizeof(ik)); 157 } 158 159 static int 160 ieee80211_ioctl_getchanlist(struct ieee80211vap *vap, struct ieee80211req *ireq) 161 { 162 struct ieee80211com *ic = vap->iv_ic; 163 164 if (sizeof(ic->ic_chan_active) < ireq->i_len) 165 ireq->i_len = sizeof(ic->ic_chan_active); 166 return copyout(&ic->ic_chan_active, ireq->i_data, ireq->i_len); 167 } 168 169 static int 170 ieee80211_ioctl_getchaninfo(struct ieee80211vap *vap, struct ieee80211req *ireq) 171 { 172 struct ieee80211com *ic = vap->iv_ic; 173 uint32_t space; 174 175 space = __offsetof(struct ieee80211req_chaninfo, 176 ic_chans[ic->ic_nchans]); 177 if (space > ireq->i_len) 178 space = ireq->i_len; 179 /* XXX assumes compatible layout */ 180 return copyout(&ic->ic_nchans, ireq->i_data, space); 181 } 182 183 static int 184 ieee80211_ioctl_getwpaie(struct ieee80211vap *vap, 185 struct ieee80211req *ireq, int req) 186 { 187 struct ieee80211_node *ni; 188 struct ieee80211req_wpaie2 *wpaie; 189 int error; 190 191 if (ireq->i_len < IEEE80211_ADDR_LEN) 192 return EINVAL; 193 wpaie = IEEE80211_MALLOC(sizeof(*wpaie), M_TEMP, 194 IEEE80211_M_NOWAIT | IEEE80211_M_ZERO); 195 if (wpaie == NULL) 196 return ENOMEM; 197 error = copyin(ireq->i_data, wpaie->wpa_macaddr, IEEE80211_ADDR_LEN); 198 if (error != 0) 199 goto bad; 200 ni = ieee80211_find_vap_node(&vap->iv_ic->ic_sta, vap, wpaie->wpa_macaddr); 201 if (ni == NULL) { 202 error = ENOENT; 203 goto bad; 204 } 205 if (ni->ni_ies.wpa_ie != NULL) { 206 int ielen = ni->ni_ies.wpa_ie[1] + 2; 207 if (ielen > sizeof(wpaie->wpa_ie)) 208 ielen = sizeof(wpaie->wpa_ie); 209 memcpy(wpaie->wpa_ie, ni->ni_ies.wpa_ie, ielen); 210 } 211 if (req == IEEE80211_IOC_WPAIE2) { 212 if (ni->ni_ies.rsn_ie != NULL) { 213 int ielen = ni->ni_ies.rsn_ie[1] + 2; 214 if (ielen > sizeof(wpaie->rsn_ie)) 215 ielen = sizeof(wpaie->rsn_ie); 216 memcpy(wpaie->rsn_ie, ni->ni_ies.rsn_ie, ielen); 217 } 218 if (ireq->i_len > sizeof(struct ieee80211req_wpaie2)) 219 ireq->i_len = sizeof(struct ieee80211req_wpaie2); 220 } else { 221 /* compatibility op, may overwrite wpa ie */ 222 /* XXX check ic_flags? */ 223 if (ni->ni_ies.rsn_ie != NULL) { 224 int ielen = ni->ni_ies.rsn_ie[1] + 2; 225 if (ielen > sizeof(wpaie->wpa_ie)) 226 ielen = sizeof(wpaie->wpa_ie); 227 memcpy(wpaie->wpa_ie, ni->ni_ies.rsn_ie, ielen); 228 } 229 if (ireq->i_len > sizeof(struct ieee80211req_wpaie)) 230 ireq->i_len = sizeof(struct ieee80211req_wpaie); 231 } 232 ieee80211_free_node(ni); 233 error = copyout(wpaie, ireq->i_data, ireq->i_len); 234 bad: 235 IEEE80211_FREE(wpaie, M_TEMP); 236 return error; 237 } 238 239 static int 240 ieee80211_ioctl_getstastats(struct ieee80211vap *vap, struct ieee80211req *ireq) 241 { 242 struct ieee80211_node *ni; 243 uint8_t macaddr[IEEE80211_ADDR_LEN]; 244 const size_t off = __offsetof(struct ieee80211req_sta_stats, is_stats); 245 int error; 246 247 if (ireq->i_len < off) 248 return EINVAL; 249 error = copyin(ireq->i_data, macaddr, IEEE80211_ADDR_LEN); 250 if (error != 0) 251 return error; 252 ni = ieee80211_find_vap_node(&vap->iv_ic->ic_sta, vap, macaddr); 253 if (ni == NULL) 254 return ENOENT; 255 if (ireq->i_len > sizeof(struct ieee80211req_sta_stats)) 256 ireq->i_len = sizeof(struct ieee80211req_sta_stats); 257 /* NB: copy out only the statistics */ 258 error = copyout(&ni->ni_stats, (uint8_t *) ireq->i_data + off, 259 ireq->i_len - off); 260 ieee80211_free_node(ni); 261 return error; 262 } 263 264 struct scanreq { 265 struct ieee80211req_scan_result *sr; 266 size_t space; 267 }; 268 269 static size_t 270 scan_space(const struct ieee80211_scan_entry *se, int *ielen) 271 { 272 size_t len; 273 274 *ielen = se->se_ies.len; 275 /* 276 * NB: ie's can be no more than 255 bytes and the max 802.11 277 * packet is <3Kbytes so we are sure this doesn't overflow 278 * 16-bits; if this is a concern we can drop the ie's. 279 */ 280 len = sizeof(struct ieee80211req_scan_result) + se->se_ssid[1] + 281 se->se_meshid[1] + *ielen; 282 return roundup(len, sizeof(uint32_t)); 283 } 284 285 static void 286 get_scan_space(void *arg, const struct ieee80211_scan_entry *se) 287 { 288 struct scanreq *req = arg; 289 int ielen; 290 291 req->space += scan_space(se, &ielen); 292 } 293 294 static void 295 get_scan_result(void *arg, const struct ieee80211_scan_entry *se) 296 { 297 struct scanreq *req = arg; 298 struct ieee80211req_scan_result *sr; 299 int ielen, len, nr, nxr; 300 uint8_t *cp; 301 302 len = scan_space(se, &ielen); 303 if (len > req->space) 304 return; 305 306 sr = req->sr; 307 KASSERT(len <= 65535 && ielen <= 65535, 308 ("len %u ssid %u ie %u", len, se->se_ssid[1], ielen)); 309 sr->isr_len = len; 310 sr->isr_ie_off = sizeof(struct ieee80211req_scan_result); 311 sr->isr_ie_len = ielen; 312 sr->isr_freq = se->se_chan->ic_freq; 313 sr->isr_flags = se->se_chan->ic_flags; 314 sr->isr_rssi = se->se_rssi; 315 sr->isr_noise = se->se_noise; 316 sr->isr_intval = se->se_intval; 317 sr->isr_capinfo = se->se_capinfo; 318 sr->isr_erp = se->se_erp; 319 IEEE80211_ADDR_COPY(sr->isr_bssid, se->se_bssid); 320 nr = uimin(se->se_rates[1], IEEE80211_RATE_MAXSIZE); 321 memcpy(sr->isr_rates, se->se_rates+2, nr); 322 nxr = uimin(se->se_xrates[1], IEEE80211_RATE_MAXSIZE - nr); 323 memcpy(sr->isr_rates+nr, se->se_xrates+2, nxr); 324 sr->isr_nrates = nr + nxr; 325 326 /* copy SSID */ 327 sr->isr_ssid_len = se->se_ssid[1]; 328 cp = ((uint8_t *)sr) + sr->isr_ie_off; 329 memcpy(cp, se->se_ssid+2, sr->isr_ssid_len); 330 331 /* copy mesh id */ 332 cp += sr->isr_ssid_len; 333 sr->isr_meshid_len = se->se_meshid[1]; 334 memcpy(cp, se->se_meshid+2, sr->isr_meshid_len); 335 cp += sr->isr_meshid_len; 336 337 if (ielen) 338 memcpy(cp, se->se_ies.data, ielen); 339 340 req->space -= len; 341 req->sr = (struct ieee80211req_scan_result *)(((uint8_t *)sr) + len); 342 } 343 344 static int 345 ieee80211_ioctl_getscanresults(struct ieee80211vap *vap, 346 struct ieee80211req *ireq) 347 { 348 struct scanreq req; 349 int error; 350 351 if (ireq->i_len < sizeof(struct scanreq)) 352 return EFAULT; 353 354 error = 0; 355 req.space = 0; 356 ieee80211_scan_iterate(vap, get_scan_space, &req); 357 if (req.space > ireq->i_len) 358 req.space = ireq->i_len; 359 if (req.space > 0) { 360 uint32_t space; 361 void *p; 362 363 space = req.space; 364 /* XXX M_WAITOK after driver lock released */ 365 p = IEEE80211_MALLOC(space, M_TEMP, 366 IEEE80211_M_NOWAIT | IEEE80211_M_ZERO); 367 if (p == NULL) 368 return ENOMEM; 369 req.sr = p; 370 ieee80211_scan_iterate(vap, get_scan_result, &req); 371 ireq->i_len = space - req.space; 372 error = copyout(p, ireq->i_data, ireq->i_len); 373 IEEE80211_FREE(p, M_TEMP); 374 } else 375 ireq->i_len = 0; 376 377 return error; 378 } 379 380 #ifdef OLD_IEEE80211_IOC_SCAN_RESULTS 381 /* Code to get the old version of scan results, for NetBSD 8.0 and earlier. */ 382 383 static size_t 384 old_scan_space(const struct ieee80211_scan_entry *se, int *ielen) 385 { 386 size_t len; 387 388 *ielen = se->se_ies.len; 389 /* 390 * NB: ie's can be no more than 255 bytes and the max 802.11 391 * packet is <3Kbytes so we are sure this doesn't overflow 392 * 16-bits; if this is a concern we can drop the ie's. 393 */ 394 len = sizeof(struct old_ieee80211req_scan_result) + se->se_ssid[1] + 395 se->se_meshid[1] + *ielen; 396 return roundup(len, sizeof(uint32_t)); 397 } 398 399 static void 400 old_get_scan_space(void *arg, const struct ieee80211_scan_entry *se) 401 { 402 struct scanreq *req = arg; 403 int ielen; 404 405 req->space += old_scan_space(se, &ielen); 406 } 407 408 static void 409 old_get_scan_result(void *arg, const struct ieee80211_scan_entry *se) 410 { 411 struct scanreq *req = arg; 412 struct old_ieee80211req_scan_result *sr; 413 int ielen, len, nr, nxr; 414 uint8_t *cp; 415 416 len = old_scan_space(se, &ielen); 417 if (len > req->space) 418 return; 419 420 sr = (struct old_ieee80211req_scan_result *)req->sr; 421 KASSERT(len <= 65535 && ielen <= 65535, 422 ("len %u ssid %u ie %u", len, se->se_ssid[1], ielen)); 423 sr->isr_len = len; 424 sr->isr_ie_len = ielen; 425 sr->isr_freq = se->se_chan->ic_freq; 426 sr->isr_flags = se->se_chan->ic_flags; 427 sr->isr_rssi = se->se_rssi; 428 sr->isr_noise = se->se_noise; 429 sr->isr_intval = se->se_intval; 430 sr->isr_capinfo = se->se_capinfo; 431 sr->isr_erp = se->se_erp; 432 IEEE80211_ADDR_COPY(sr->isr_bssid, se->se_bssid); 433 nr = uimin(se->se_rates[1], IEEE80211_RATE_MAXSIZE); 434 memcpy(sr->isr_rates, se->se_rates+2, nr); 435 nxr = uimin(se->se_xrates[1], IEEE80211_RATE_MAXSIZE - nr); 436 memcpy(sr->isr_rates+nr, se->se_xrates+2, nxr); 437 sr->isr_nrates = nr + nxr; 438 if (sr->isr_nrates > 15) 439 sr->isr_nrates = 15; 440 441 printf ("old_get_scan_results: ssid=%.*s\n", se->se_ssid[1], &se->se_ssid[2]); 442 443 /* copy SSID */ 444 sr->isr_ssid_len = se->se_ssid[1]; 445 cp = ((uint8_t *)sr) + sizeof(struct old_ieee80211req_scan_result); 446 memcpy(cp, se->se_ssid+2, sr->isr_ssid_len); 447 448 if (ielen) 449 memcpy(cp+sr->isr_ssid_len, se->se_ies.data, ielen); 450 451 req->space -= len; 452 req->sr = (struct ieee80211req_scan_result *)(((uint8_t *)sr) + len); 453 } 454 455 static int 456 old_ieee80211_ioctl_getscanresults(struct ieee80211vap *vap, 457 struct ieee80211req *ireq) 458 { 459 struct scanreq req; 460 int error; 461 462 if (ireq->i_len < sizeof(struct scanreq)) 463 return EFAULT; 464 465 error = 0; 466 req.space = 0; 467 ieee80211_scan_iterate(vap, old_get_scan_space, &req); 468 if (req.space > ireq->i_len) 469 req.space = ireq->i_len; 470 if (req.space > 0) { 471 uint32_t space; 472 void *p; 473 474 space = req.space; 475 /* XXX M_WAITOK after driver lock released */ 476 p = IEEE80211_MALLOC(space, M_TEMP, 477 IEEE80211_M_NOWAIT | IEEE80211_M_ZERO); 478 if (p == NULL) 479 return ENOMEM; 480 req.sr = p; 481 ieee80211_scan_iterate(vap, old_get_scan_result, &req); 482 ireq->i_len = space - req.space; 483 error = copyout(p, ireq->i_data, ireq->i_len); 484 IEEE80211_FREE(p, M_TEMP); 485 } else 486 ireq->i_len = 0; 487 488 return error; 489 } 490 491 #endif 492 493 struct stainforeq { 494 struct ieee80211req_sta_info *si; 495 size_t space; 496 }; 497 498 static size_t 499 sta_space(const struct ieee80211_node *ni, size_t *ielen) 500 { 501 *ielen = ni->ni_ies.len; 502 return roundup(sizeof(struct ieee80211req_sta_info) + *ielen, 503 sizeof(uint32_t)); 504 } 505 506 static void 507 get_sta_space(void *arg, struct ieee80211_node *ni) 508 { 509 struct stainforeq *req = arg; 510 size_t ielen; 511 512 if (ni->ni_vap->iv_opmode == IEEE80211_M_HOSTAP && 513 ni->ni_associd == 0) /* only associated stations */ 514 return; 515 req->space += sta_space(ni, &ielen); 516 } 517 518 static void 519 get_sta_info(void *arg, struct ieee80211_node *ni) 520 { 521 struct stainforeq *req = arg; 522 struct ieee80211vap *vap = ni->ni_vap; 523 struct ieee80211req_sta_info *si; 524 size_t ielen, len; 525 uint8_t *cp; 526 527 if (vap->iv_opmode == IEEE80211_M_HOSTAP && 528 ni->ni_associd == 0) /* only associated stations */ 529 return; 530 if (ni->ni_chan == IEEE80211_CHAN_ANYC) /* XXX bogus entry */ 531 return; 532 len = sta_space(ni, &ielen); 533 if (len > req->space) 534 return; 535 si = req->si; 536 si->isi_len = len; 537 si->isi_ie_off = sizeof(struct ieee80211req_sta_info); 538 si->isi_ie_len = ielen; 539 si->isi_freq = ni->ni_chan->ic_freq; 540 si->isi_flags = ni->ni_chan->ic_flags; 541 si->isi_state = ni->ni_flags; 542 si->isi_authmode = ni->ni_authmode; 543 vap->iv_ic->ic_node_getsignal(ni, &si->isi_rssi, &si->isi_noise); 544 vap->iv_ic->ic_node_getmimoinfo(ni, &si->isi_mimo); 545 si->isi_capinfo = ni->ni_capinfo; 546 si->isi_erp = ni->ni_erp; 547 IEEE80211_ADDR_COPY(si->isi_macaddr, ni->ni_macaddr); 548 si->isi_nrates = ni->ni_rates.rs_nrates; 549 if (si->isi_nrates > 15) 550 si->isi_nrates = 15; 551 memcpy(si->isi_rates, ni->ni_rates.rs_rates, si->isi_nrates); 552 si->isi_txrate = ni->ni_txrate; 553 if (si->isi_txrate & IEEE80211_RATE_MCS) { 554 const struct ieee80211_mcs_rates *mcs = 555 &ieee80211_htrates[ni->ni_txrate &~ IEEE80211_RATE_MCS]; 556 if (IEEE80211_IS_CHAN_HT40(ni->ni_chan)) { 557 if (ni->ni_flags & IEEE80211_NODE_SGI40) 558 si->isi_txmbps = mcs->ht40_rate_800ns; 559 else 560 si->isi_txmbps = mcs->ht40_rate_400ns; 561 } else { 562 if (ni->ni_flags & IEEE80211_NODE_SGI20) 563 si->isi_txmbps = mcs->ht20_rate_800ns; 564 else 565 si->isi_txmbps = mcs->ht20_rate_400ns; 566 } 567 } else 568 si->isi_txmbps = si->isi_txrate; 569 si->isi_associd = ni->ni_associd; 570 si->isi_txpower = ni->ni_txpower; 571 si->isi_vlan = ni->ni_vlan; 572 if (ni->ni_flags & IEEE80211_NODE_QOS) { 573 memcpy(si->isi_txseqs, ni->ni_txseqs, sizeof(ni->ni_txseqs)); 574 memcpy(si->isi_rxseqs, ni->ni_rxseqs, sizeof(ni->ni_rxseqs)); 575 } else { 576 si->isi_txseqs[0] = ni->ni_txseqs[IEEE80211_NONQOS_TID]; 577 si->isi_rxseqs[0] = ni->ni_rxseqs[IEEE80211_NONQOS_TID]; 578 } 579 /* NB: leave all cases in case we relax ni_associd == 0 check */ 580 if (ieee80211_node_is_authorized(ni)) 581 si->isi_inact = vap->iv_inact_run; 582 else if (ni->ni_associd != 0 || 583 (vap->iv_opmode == IEEE80211_M_WDS && 584 (vap->iv_flags_ext & IEEE80211_FEXT_WDSLEGACY))) 585 si->isi_inact = vap->iv_inact_auth; 586 else 587 si->isi_inact = vap->iv_inact_init; 588 si->isi_inact = (si->isi_inact - ni->ni_inact) * IEEE80211_INACT_WAIT; 589 si->isi_localid = ni->ni_mllid; 590 si->isi_peerid = ni->ni_mlpid; 591 si->isi_peerstate = ni->ni_mlstate; 592 593 if (ielen) { 594 cp = ((uint8_t *)si) + si->isi_ie_off; 595 memcpy(cp, ni->ni_ies.data, ielen); 596 } 597 598 req->si = (struct ieee80211req_sta_info *)(((uint8_t *)si) + len); 599 req->space -= len; 600 } 601 602 static int 603 getstainfo_common(struct ieee80211vap *vap, struct ieee80211req *ireq, 604 struct ieee80211_node *ni, size_t off) 605 { 606 struct ieee80211com *ic = vap->iv_ic; 607 struct stainforeq req; 608 size_t space; 609 void *p; 610 int error; 611 612 error = 0; 613 req.space = 0; 614 if (ni == NULL) { 615 ieee80211_iterate_nodes_vap(&ic->ic_sta, vap, get_sta_space, 616 &req); 617 } else 618 get_sta_space(&req, ni); 619 if (req.space > ireq->i_len) 620 req.space = ireq->i_len; 621 if (req.space > 0) { 622 space = req.space; 623 /* XXX M_WAITOK after driver lock released */ 624 p = IEEE80211_MALLOC(space, M_TEMP, 625 IEEE80211_M_NOWAIT | IEEE80211_M_ZERO); 626 if (p == NULL) { 627 error = ENOMEM; 628 goto bad; 629 } 630 req.si = p; 631 if (ni == NULL) { 632 ieee80211_iterate_nodes_vap(&ic->ic_sta, vap, 633 get_sta_info, &req); 634 } else 635 get_sta_info(&req, ni); 636 ireq->i_len = space - req.space; 637 error = copyout(p, (uint8_t *) ireq->i_data+off, ireq->i_len); 638 IEEE80211_FREE(p, M_TEMP); 639 } else 640 ireq->i_len = 0; 641 bad: 642 if (ni != NULL) 643 ieee80211_free_node(ni); 644 return error; 645 } 646 647 static int 648 ieee80211_ioctl_getstainfo(struct ieee80211vap *vap, struct ieee80211req *ireq) 649 { 650 uint8_t macaddr[IEEE80211_ADDR_LEN]; 651 const size_t off = __offsetof(struct ieee80211req_sta_req, info); 652 struct ieee80211_node *ni; 653 int error; 654 655 if (ireq->i_len < sizeof(struct ieee80211req_sta_req)) 656 return EFAULT; 657 error = copyin(ireq->i_data, macaddr, IEEE80211_ADDR_LEN); 658 if (error != 0) 659 return error; 660 if (IEEE80211_ADDR_EQ(macaddr, vap->iv_ifp->if_broadcastaddr)) { 661 ni = NULL; 662 } else { 663 ni = ieee80211_find_vap_node(&vap->iv_ic->ic_sta, vap, macaddr); 664 if (ni == NULL) 665 return ENOENT; 666 } 667 return getstainfo_common(vap, ireq, ni, off); 668 } 669 670 static int 671 ieee80211_ioctl_getstatxpow(struct ieee80211vap *vap, struct ieee80211req *ireq) 672 { 673 struct ieee80211_node *ni; 674 struct ieee80211req_sta_txpow txpow; 675 int error; 676 677 if (ireq->i_len != sizeof(txpow)) 678 return EINVAL; 679 error = copyin(ireq->i_data, &txpow, sizeof(txpow)); 680 if (error != 0) 681 return error; 682 ni = ieee80211_find_vap_node(&vap->iv_ic->ic_sta, vap, txpow.it_macaddr); 683 if (ni == NULL) 684 return ENOENT; 685 txpow.it_txpow = ni->ni_txpower; 686 error = copyout(&txpow, ireq->i_data, sizeof(txpow)); 687 ieee80211_free_node(ni); 688 return error; 689 } 690 691 static int 692 ieee80211_ioctl_getwmeparam(struct ieee80211vap *vap, struct ieee80211req *ireq) 693 { 694 struct ieee80211com *ic = vap->iv_ic; 695 struct ieee80211_wme_state *wme = &ic->ic_wme; 696 struct wmeParams *wmep; 697 int ac; 698 699 if ((ic->ic_caps & IEEE80211_C_WME) == 0) 700 return EINVAL; 701 702 ac = (ireq->i_len & IEEE80211_WMEPARAM_VAL); 703 if (ac >= WME_NUM_AC) 704 ac = WME_AC_BE; 705 if (ireq->i_len & IEEE80211_WMEPARAM_BSS) 706 wmep = &wme->wme_wmeBssChanParams.cap_wmeParams[ac]; 707 else 708 wmep = &wme->wme_wmeChanParams.cap_wmeParams[ac]; 709 switch (ireq->i_type) { 710 case IEEE80211_IOC_WME_CWMIN: /* WME: CWmin */ 711 ireq->i_val = wmep->wmep_logcwmin; 712 break; 713 case IEEE80211_IOC_WME_CWMAX: /* WME: CWmax */ 714 ireq->i_val = wmep->wmep_logcwmax; 715 break; 716 case IEEE80211_IOC_WME_AIFS: /* WME: AIFS */ 717 ireq->i_val = wmep->wmep_aifsn; 718 break; 719 case IEEE80211_IOC_WME_TXOPLIMIT: /* WME: txops limit */ 720 ireq->i_val = wmep->wmep_txopLimit; 721 break; 722 case IEEE80211_IOC_WME_ACM: /* WME: ACM (bss only) */ 723 wmep = &wme->wme_wmeBssChanParams.cap_wmeParams[ac]; 724 ireq->i_val = wmep->wmep_acm; 725 break; 726 case IEEE80211_IOC_WME_ACKPOLICY: /* WME: ACK policy (!bss only)*/ 727 wmep = &wme->wme_wmeChanParams.cap_wmeParams[ac]; 728 ireq->i_val = !wmep->wmep_noackPolicy; 729 break; 730 } 731 return 0; 732 } 733 734 static int 735 ieee80211_ioctl_getmaccmd(struct ieee80211vap *vap, struct ieee80211req *ireq) 736 { 737 const struct ieee80211_aclator *acl = vap->iv_acl; 738 739 return (acl == NULL ? EINVAL : acl->iac_getioctl(vap, ireq)); 740 } 741 742 static int 743 ieee80211_ioctl_getcurchan(struct ieee80211vap *vap, struct ieee80211req *ireq) 744 { 745 struct ieee80211com *ic = vap->iv_ic; 746 struct ieee80211_channel *c; 747 748 if (ireq->i_len != sizeof(struct ieee80211_channel)) 749 return EINVAL; 750 /* 751 * vap's may have different operating channels when HT is 752 * in use. When in RUN state report the vap-specific channel. 753 * Otherwise return curchan. 754 */ 755 if (vap->iv_state == IEEE80211_S_RUN || vap->iv_state == IEEE80211_S_SLEEP) 756 c = vap->iv_bss->ni_chan; 757 else 758 c = ic->ic_curchan; 759 return copyout(c, ireq->i_data, sizeof(*c)); 760 } 761 762 static int 763 getappie(const struct ieee80211_appie *aie, struct ieee80211req *ireq) 764 { 765 if (aie == NULL) 766 return EINVAL; 767 /* NB: truncate, caller can check length */ 768 if (ireq->i_len > aie->ie_len) 769 ireq->i_len = aie->ie_len; 770 return copyout(aie->ie_data, ireq->i_data, ireq->i_len); 771 } 772 773 static int 774 ieee80211_ioctl_getappie(struct ieee80211vap *vap, struct ieee80211req *ireq) 775 { 776 uint8_t fc0; 777 778 fc0 = ireq->i_val & 0xff; 779 if ((fc0 & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_MGT) 780 return EINVAL; 781 /* NB: could check iv_opmode and reject but hardly worth the effort */ 782 switch (fc0 & IEEE80211_FC0_SUBTYPE_MASK) { 783 case IEEE80211_FC0_SUBTYPE_BEACON: 784 return getappie(vap->iv_appie_beacon, ireq); 785 case IEEE80211_FC0_SUBTYPE_PROBE_RESP: 786 return getappie(vap->iv_appie_proberesp, ireq); 787 case IEEE80211_FC0_SUBTYPE_ASSOC_RESP: 788 return getappie(vap->iv_appie_assocresp, ireq); 789 case IEEE80211_FC0_SUBTYPE_PROBE_REQ: 790 return getappie(vap->iv_appie_probereq, ireq); 791 case IEEE80211_FC0_SUBTYPE_ASSOC_REQ: 792 return getappie(vap->iv_appie_assocreq, ireq); 793 case IEEE80211_FC0_SUBTYPE_BEACON|IEEE80211_FC0_SUBTYPE_PROBE_RESP: 794 return getappie(vap->iv_appie_wpa, ireq); 795 } 796 return EINVAL; 797 } 798 799 static int 800 ieee80211_ioctl_getregdomain(struct ieee80211vap *vap, 801 const struct ieee80211req *ireq) 802 { 803 struct ieee80211com *ic = vap->iv_ic; 804 805 if (ireq->i_len != sizeof(ic->ic_regdomain)) 806 return EINVAL; 807 return copyout(&ic->ic_regdomain, ireq->i_data, 808 sizeof(ic->ic_regdomain)); 809 } 810 811 static int 812 ieee80211_ioctl_getroam(struct ieee80211vap *vap, 813 const struct ieee80211req *ireq) 814 { 815 size_t len = ireq->i_len; 816 /* NB: accept short requests for backwards compat */ 817 if (len > sizeof(vap->iv_roamparms)) 818 len = sizeof(vap->iv_roamparms); 819 return copyout(vap->iv_roamparms, ireq->i_data, len); 820 } 821 822 static int 823 ieee80211_ioctl_gettxparams(struct ieee80211vap *vap, 824 const struct ieee80211req *ireq) 825 { 826 size_t len = ireq->i_len; 827 /* NB: accept short requests for backwards compat */ 828 if (len > sizeof(vap->iv_txparms)) 829 len = sizeof(vap->iv_txparms); 830 return copyout(vap->iv_txparms, ireq->i_data, len); 831 } 832 833 static int 834 ieee80211_ioctl_getdevcaps(struct ieee80211com *ic, 835 const struct ieee80211req *ireq) 836 { 837 struct ieee80211_devcaps_req *dc; 838 struct ieee80211req_chaninfo *ci; 839 int maxchans, error; 840 841 maxchans = 1 + ((ireq->i_len - sizeof(struct ieee80211_devcaps_req)) / 842 sizeof(struct ieee80211_channel)); 843 /* NB: require 1 so we know ic_nchans is accessible */ 844 if (maxchans < 1) 845 return EINVAL; 846 /* constrain max request size, 2K channels is ~24Kbytes */ 847 if (maxchans > 2048) 848 maxchans = 2048; 849 dc = (struct ieee80211_devcaps_req *) 850 IEEE80211_MALLOC(IEEE80211_DEVCAPS_SIZE(maxchans), M_TEMP, 851 IEEE80211_M_NOWAIT | IEEE80211_M_ZERO); 852 if (dc == NULL) 853 return ENOMEM; 854 dc->dc_drivercaps = ic->ic_caps; 855 dc->dc_cryptocaps = ic->ic_cryptocaps; 856 dc->dc_htcaps = ic->ic_htcaps; 857 dc->dc_vhtcaps = ic->ic_vhtcaps; 858 ci = &dc->dc_chaninfo; 859 ic->ic_getradiocaps(ic, maxchans, &ci->ic_nchans, ci->ic_chans); 860 KASSERT(ci->ic_nchans <= maxchans, 861 ("nchans %d maxchans %d", ci->ic_nchans, maxchans)); 862 ieee80211_sort_channels(ci->ic_chans, ci->ic_nchans); 863 error = copyout(dc, ireq->i_data, IEEE80211_DEVCAPS_SPACE(dc)); 864 IEEE80211_FREE(dc, M_TEMP); 865 return error; 866 } 867 868 static int 869 ieee80211_ioctl_getstavlan(struct ieee80211vap *vap, struct ieee80211req *ireq) 870 { 871 struct ieee80211_node *ni; 872 struct ieee80211req_sta_vlan vlan; 873 int error; 874 875 if (ireq->i_len != sizeof(vlan)) 876 return EINVAL; 877 error = copyin(ireq->i_data, &vlan, sizeof(vlan)); 878 if (error != 0) 879 return error; 880 if (!IEEE80211_ADDR_EQ(vlan.sv_macaddr, zerobssid)) { 881 ni = ieee80211_find_vap_node(&vap->iv_ic->ic_sta, vap, 882 vlan.sv_macaddr); 883 if (ni == NULL) 884 return ENOENT; 885 } else 886 ni = ieee80211_ref_node(vap->iv_bss); 887 vlan.sv_vlan = ni->ni_vlan; 888 error = copyout(&vlan, ireq->i_data, sizeof(vlan)); 889 ieee80211_free_node(ni); 890 return error; 891 } 892 893 /* 894 * Dummy ioctl get handler so the linker set is defined. 895 */ 896 static __unused int 897 dummy_ioctl_get(struct ieee80211vap *vap, struct ieee80211req *ireq) 898 { 899 return ENOSYS; 900 } 901 IEEE80211_IOCTL_GET(dummy, dummy_ioctl_get); 902 903 static int 904 ieee80211_ioctl_getdefault(struct ieee80211vap *vap, struct ieee80211req *ireq) 905 { 906 int error; 907 #if notyet 908 ieee80211_ioctl_getfunc * const *get; 909 910 SET_FOREACH(get, ieee80211_ioctl_getset) { 911 error = (*get)(vap, ireq); 912 if (error != ENOSYS) 913 return error; 914 } 915 #else 916 printf ("ieee80211_ioctl_getdefault called\n"); 917 error = dummy_ioctl_get(vap, ireq); 918 #endif 919 return error; 920 } 921 922 static int 923 ieee80211_ioctl_get80211(struct ieee80211vap *vap, u_long cmd, 924 struct ieee80211req *ireq) 925 { 926 #define MS(_v, _f) (((_v) & _f) >> _f##_S) 927 struct ieee80211com *ic = vap->iv_ic; 928 u_int kid, len; 929 uint8_t tmpkey[IEEE80211_KEYBUF_SIZE]; 930 char tmpssid[IEEE80211_NWID_LEN]; 931 int error = 0; 932 933 switch (ireq->i_type) { 934 case IEEE80211_IOC_SSID: 935 switch (vap->iv_state) { 936 case IEEE80211_S_INIT: 937 case IEEE80211_S_SCAN: 938 ireq->i_len = vap->iv_des_ssid[0].len; 939 memcpy(tmpssid, vap->iv_des_ssid[0].ssid, ireq->i_len); 940 break; 941 default: 942 ireq->i_len = vap->iv_bss->ni_esslen; 943 memcpy(tmpssid, vap->iv_bss->ni_essid, ireq->i_len); 944 break; 945 } 946 error = copyout(tmpssid, ireq->i_data, ireq->i_len); 947 break; 948 case IEEE80211_IOC_NUMSSIDS: 949 ireq->i_val = 1; 950 break; 951 case IEEE80211_IOC_WEP: 952 if ((vap->iv_flags & IEEE80211_F_PRIVACY) == 0) 953 ireq->i_val = IEEE80211_WEP_OFF; 954 else if (vap->iv_flags & IEEE80211_F_DROPUNENC) 955 ireq->i_val = IEEE80211_WEP_ON; 956 else 957 ireq->i_val = IEEE80211_WEP_MIXED; 958 break; 959 case IEEE80211_IOC_WEPKEY: 960 kid = (u_int) ireq->i_val; 961 if (kid >= IEEE80211_WEP_NKID) 962 return EINVAL; 963 len = (u_int) vap->iv_nw_keys[kid].wk_keylen; 964 /* NB: only root can read WEP keys */ 965 if (priv_check(curthread, PRIV_NET80211_GETKEY) == 0) { 966 bcopy(vap->iv_nw_keys[kid].wk_key, tmpkey, len); 967 } else { 968 bzero(tmpkey, len); 969 } 970 ireq->i_len = len; 971 error = copyout(tmpkey, ireq->i_data, len); 972 break; 973 case IEEE80211_IOC_NUMWEPKEYS: 974 ireq->i_val = IEEE80211_WEP_NKID; 975 break; 976 case IEEE80211_IOC_WEPTXKEY: 977 ireq->i_val = vap->iv_def_txkey; 978 break; 979 case IEEE80211_IOC_AUTHMODE: 980 if (vap->iv_flags & IEEE80211_F_WPA) 981 ireq->i_val = IEEE80211_AUTH_WPA; 982 else 983 ireq->i_val = vap->iv_bss->ni_authmode; 984 break; 985 case IEEE80211_IOC_CHANNEL: 986 ireq->i_val = ieee80211_chan2ieee(ic, ic->ic_curchan); 987 break; 988 case IEEE80211_IOC_POWERSAVE: 989 if (vap->iv_flags & IEEE80211_F_PMGTON) 990 ireq->i_val = IEEE80211_POWERSAVE_ON; 991 else 992 ireq->i_val = IEEE80211_POWERSAVE_OFF; 993 break; 994 case IEEE80211_IOC_POWERSAVESLEEP: 995 ireq->i_val = ic->ic_lintval; 996 break; 997 case IEEE80211_IOC_RTSTHRESHOLD: 998 ireq->i_val = vap->iv_rtsthreshold; 999 break; 1000 case IEEE80211_IOC_PROTMODE: 1001 ireq->i_val = ic->ic_protmode; 1002 break; 1003 case IEEE80211_IOC_TXPOWER: 1004 /* 1005 * Tx power limit is the min of max regulatory 1006 * power, any user-set limit, and the max the 1007 * radio can do. 1008 * 1009 * TODO: methodize this 1010 */ 1011 ireq->i_val = 2*ic->ic_curchan->ic_maxregpower; 1012 if (ireq->i_val > ic->ic_txpowlimit) 1013 ireq->i_val = ic->ic_txpowlimit; 1014 if (ireq->i_val > ic->ic_curchan->ic_maxpower) 1015 ireq->i_val = ic->ic_curchan->ic_maxpower; 1016 break; 1017 case IEEE80211_IOC_WPA: 1018 switch (vap->iv_flags & IEEE80211_F_WPA) { 1019 case IEEE80211_F_WPA1: 1020 ireq->i_val = 1; 1021 break; 1022 case IEEE80211_F_WPA2: 1023 ireq->i_val = 2; 1024 break; 1025 case IEEE80211_F_WPA1 | IEEE80211_F_WPA2: 1026 ireq->i_val = 3; 1027 break; 1028 default: 1029 ireq->i_val = 0; 1030 break; 1031 } 1032 break; 1033 case IEEE80211_IOC_CHANLIST: 1034 error = ieee80211_ioctl_getchanlist(vap, ireq); 1035 break; 1036 case IEEE80211_IOC_ROAMING: 1037 ireq->i_val = vap->iv_roaming; 1038 break; 1039 case IEEE80211_IOC_PRIVACY: 1040 ireq->i_val = (vap->iv_flags & IEEE80211_F_PRIVACY) != 0; 1041 break; 1042 case IEEE80211_IOC_DROPUNENCRYPTED: 1043 ireq->i_val = (vap->iv_flags & IEEE80211_F_DROPUNENC) != 0; 1044 break; 1045 case IEEE80211_IOC_COUNTERMEASURES: 1046 ireq->i_val = (vap->iv_flags & IEEE80211_F_COUNTERM) != 0; 1047 break; 1048 case IEEE80211_IOC_WME: 1049 ireq->i_val = (vap->iv_flags & IEEE80211_F_WME) != 0; 1050 break; 1051 case IEEE80211_IOC_HIDESSID: 1052 ireq->i_val = (vap->iv_flags & IEEE80211_F_HIDESSID) != 0; 1053 break; 1054 case IEEE80211_IOC_APBRIDGE: 1055 ireq->i_val = (vap->iv_flags & IEEE80211_F_NOBRIDGE) == 0; 1056 break; 1057 case IEEE80211_IOC_WPAKEY: 1058 error = ieee80211_ioctl_getkey(vap, ireq); 1059 break; 1060 case IEEE80211_IOC_CHANINFO: 1061 error = ieee80211_ioctl_getchaninfo(vap, ireq); 1062 break; 1063 case IEEE80211_IOC_BSSID: 1064 if (ireq->i_len != IEEE80211_ADDR_LEN) 1065 return EINVAL; 1066 if (vap->iv_state == IEEE80211_S_RUN || vap->iv_state == IEEE80211_S_SLEEP) { 1067 error = copyout(vap->iv_opmode == IEEE80211_M_WDS ? 1068 vap->iv_bss->ni_macaddr : vap->iv_bss->ni_bssid, 1069 ireq->i_data, ireq->i_len); 1070 } else 1071 error = copyout(vap->iv_des_bssid, ireq->i_data, 1072 ireq->i_len); 1073 break; 1074 case IEEE80211_IOC_WPAIE: 1075 case IEEE80211_IOC_WPAIE2: 1076 error = ieee80211_ioctl_getwpaie(vap, ireq, ireq->i_type); 1077 break; 1078 #ifdef OLD_IEEE80211_IOC_SCAN_RESULTS 1079 case OLD_IEEE80211_IOC_SCAN_RESULTS: 1080 error = old_ieee80211_ioctl_getscanresults(vap, ireq); 1081 break; 1082 #endif 1083 case IEEE80211_IOC_SCAN_RESULTS: 1084 error = ieee80211_ioctl_getscanresults(vap, ireq); 1085 break; 1086 case IEEE80211_IOC_STA_STATS: 1087 error = ieee80211_ioctl_getstastats(vap, ireq); 1088 break; 1089 case IEEE80211_IOC_TXPOWMAX: 1090 ireq->i_val = vap->iv_bss->ni_txpower; 1091 break; 1092 case IEEE80211_IOC_STA_TXPOW: 1093 error = ieee80211_ioctl_getstatxpow(vap, ireq); 1094 break; 1095 case IEEE80211_IOC_STA_INFO: 1096 error = ieee80211_ioctl_getstainfo(vap, ireq); 1097 break; 1098 case IEEE80211_IOC_WME_CWMIN: /* WME: CWmin */ 1099 case IEEE80211_IOC_WME_CWMAX: /* WME: CWmax */ 1100 case IEEE80211_IOC_WME_AIFS: /* WME: AIFS */ 1101 case IEEE80211_IOC_WME_TXOPLIMIT: /* WME: txops limit */ 1102 case IEEE80211_IOC_WME_ACM: /* WME: ACM (bss only) */ 1103 case IEEE80211_IOC_WME_ACKPOLICY: /* WME: ACK policy (!bss only) */ 1104 error = ieee80211_ioctl_getwmeparam(vap, ireq); 1105 break; 1106 case IEEE80211_IOC_DTIM_PERIOD: 1107 ireq->i_val = vap->iv_dtim_period; 1108 break; 1109 case IEEE80211_IOC_BEACON_INTERVAL: 1110 /* NB: get from ic_bss for station mode */ 1111 ireq->i_val = vap->iv_bss->ni_intval; 1112 break; 1113 case IEEE80211_IOC_PUREG: 1114 ireq->i_val = (vap->iv_flags & IEEE80211_F_PUREG) != 0; 1115 break; 1116 case IEEE80211_IOC_QUIET: 1117 ireq->i_val = vap->iv_quiet; 1118 break; 1119 case IEEE80211_IOC_QUIET_COUNT: 1120 ireq->i_val = vap->iv_quiet_count; 1121 break; 1122 case IEEE80211_IOC_QUIET_PERIOD: 1123 ireq->i_val = vap->iv_quiet_period; 1124 break; 1125 case IEEE80211_IOC_QUIET_DUR: 1126 ireq->i_val = vap->iv_quiet_duration; 1127 break; 1128 case IEEE80211_IOC_QUIET_OFFSET: 1129 ireq->i_val = vap->iv_quiet_offset; 1130 break; 1131 case IEEE80211_IOC_BGSCAN: 1132 ireq->i_val = (vap->iv_flags & IEEE80211_F_BGSCAN) != 0; 1133 break; 1134 case IEEE80211_IOC_BGSCAN_IDLE: 1135 ireq->i_val = vap->iv_bgscanidle*hz/1000; /* ms */ 1136 break; 1137 case IEEE80211_IOC_BGSCAN_INTERVAL: 1138 ireq->i_val = vap->iv_bgscanintvl/hz; /* seconds */ 1139 break; 1140 case IEEE80211_IOC_SCANVALID: 1141 ireq->i_val = vap->iv_scanvalid/hz; /* seconds */ 1142 break; 1143 case IEEE80211_IOC_FRAGTHRESHOLD: 1144 ireq->i_val = vap->iv_fragthreshold; 1145 break; 1146 case IEEE80211_IOC_MACCMD: 1147 error = ieee80211_ioctl_getmaccmd(vap, ireq); 1148 break; 1149 case IEEE80211_IOC_BURST: 1150 ireq->i_val = (vap->iv_flags & IEEE80211_F_BURST) != 0; 1151 break; 1152 case IEEE80211_IOC_BMISSTHRESHOLD: 1153 ireq->i_val = vap->iv_bmissthreshold; 1154 break; 1155 case IEEE80211_IOC_CURCHAN: 1156 error = ieee80211_ioctl_getcurchan(vap, ireq); 1157 break; 1158 case IEEE80211_IOC_SHORTGI: 1159 ireq->i_val = 0; 1160 if (vap->iv_flags_ht & IEEE80211_FHT_SHORTGI20) 1161 ireq->i_val |= IEEE80211_HTCAP_SHORTGI20; 1162 if (vap->iv_flags_ht & IEEE80211_FHT_SHORTGI40) 1163 ireq->i_val |= IEEE80211_HTCAP_SHORTGI40; 1164 break; 1165 case IEEE80211_IOC_AMPDU: 1166 ireq->i_val = 0; 1167 if (vap->iv_flags_ht & IEEE80211_FHT_AMPDU_TX) 1168 ireq->i_val |= 1; 1169 if (vap->iv_flags_ht & IEEE80211_FHT_AMPDU_RX) 1170 ireq->i_val |= 2; 1171 break; 1172 case IEEE80211_IOC_AMPDU_LIMIT: 1173 /* XXX TODO: make this a per-node thing; and leave this as global */ 1174 if (vap->iv_opmode == IEEE80211_M_HOSTAP) 1175 ireq->i_val = vap->iv_ampdu_rxmax; 1176 else if (vap->iv_state == IEEE80211_S_RUN || vap->iv_state == IEEE80211_S_SLEEP) 1177 /* 1178 * XXX TODO: this isn't completely correct, as we've 1179 * negotiated the higher of the two. 1180 */ 1181 ireq->i_val = MS(vap->iv_bss->ni_htparam, 1182 IEEE80211_HTCAP_MAXRXAMPDU); 1183 else 1184 ireq->i_val = vap->iv_ampdu_limit; 1185 break; 1186 case IEEE80211_IOC_AMPDU_DENSITY: 1187 /* XXX TODO: make this a per-node thing; and leave this as global */ 1188 if (vap->iv_opmode == IEEE80211_M_STA && 1189 (vap->iv_state == IEEE80211_S_RUN || vap->iv_state == IEEE80211_S_SLEEP)) 1190 /* 1191 * XXX TODO: this isn't completely correct, as we've 1192 * negotiated the higher of the two. 1193 */ 1194 ireq->i_val = MS(vap->iv_bss->ni_htparam, 1195 IEEE80211_HTCAP_MPDUDENSITY); 1196 else 1197 ireq->i_val = vap->iv_ampdu_density; 1198 break; 1199 case IEEE80211_IOC_AMSDU: 1200 ireq->i_val = 0; 1201 if (vap->iv_flags_ht & IEEE80211_FHT_AMSDU_TX) 1202 ireq->i_val |= 1; 1203 if (vap->iv_flags_ht & IEEE80211_FHT_AMSDU_RX) 1204 ireq->i_val |= 2; 1205 break; 1206 case IEEE80211_IOC_AMSDU_LIMIT: 1207 ireq->i_val = vap->iv_amsdu_limit; /* XXX truncation? */ 1208 break; 1209 case IEEE80211_IOC_PUREN: 1210 ireq->i_val = (vap->iv_flags_ht & IEEE80211_FHT_PUREN) != 0; 1211 break; 1212 case IEEE80211_IOC_DOTH: 1213 ireq->i_val = (vap->iv_flags & IEEE80211_F_DOTH) != 0; 1214 break; 1215 case IEEE80211_IOC_REGDOMAIN: 1216 error = ieee80211_ioctl_getregdomain(vap, ireq); 1217 break; 1218 case IEEE80211_IOC_ROAM: 1219 error = ieee80211_ioctl_getroam(vap, ireq); 1220 break; 1221 case IEEE80211_IOC_TXPARAMS: 1222 error = ieee80211_ioctl_gettxparams(vap, ireq); 1223 break; 1224 case IEEE80211_IOC_HTCOMPAT: 1225 ireq->i_val = (vap->iv_flags_ht & IEEE80211_FHT_HTCOMPAT) != 0; 1226 break; 1227 case IEEE80211_IOC_DWDS: 1228 ireq->i_val = (vap->iv_flags & IEEE80211_F_DWDS) != 0; 1229 break; 1230 case IEEE80211_IOC_INACTIVITY: 1231 ireq->i_val = (vap->iv_flags_ext & IEEE80211_FEXT_INACT) != 0; 1232 break; 1233 case IEEE80211_IOC_APPIE: 1234 error = ieee80211_ioctl_getappie(vap, ireq); 1235 break; 1236 case IEEE80211_IOC_WPS: 1237 ireq->i_val = (vap->iv_flags_ext & IEEE80211_FEXT_WPS) != 0; 1238 break; 1239 case IEEE80211_IOC_TSN: 1240 ireq->i_val = (vap->iv_flags_ext & IEEE80211_FEXT_TSN) != 0; 1241 break; 1242 case IEEE80211_IOC_DFS: 1243 ireq->i_val = (vap->iv_flags_ext & IEEE80211_FEXT_DFS) != 0; 1244 break; 1245 case IEEE80211_IOC_DOTD: 1246 ireq->i_val = (vap->iv_flags_ext & IEEE80211_FEXT_DOTD) != 0; 1247 break; 1248 case IEEE80211_IOC_DEVCAPS: 1249 error = ieee80211_ioctl_getdevcaps(ic, ireq); 1250 break; 1251 case IEEE80211_IOC_HTPROTMODE: 1252 ireq->i_val = ic->ic_htprotmode; 1253 break; 1254 case IEEE80211_IOC_HTCONF: 1255 if (vap->iv_flags_ht & IEEE80211_FHT_HT) { 1256 ireq->i_val = 1; 1257 if (vap->iv_flags_ht & IEEE80211_FHT_USEHT40) 1258 ireq->i_val |= 2; 1259 } else 1260 ireq->i_val = 0; 1261 break; 1262 case IEEE80211_IOC_STA_VLAN: 1263 error = ieee80211_ioctl_getstavlan(vap, ireq); 1264 break; 1265 case IEEE80211_IOC_SMPS: 1266 if (vap->iv_opmode == IEEE80211_M_STA && 1267 (vap->iv_state == IEEE80211_S_RUN || vap->iv_state == IEEE80211_S_SLEEP)) { 1268 if (vap->iv_bss->ni_flags & IEEE80211_NODE_MIMO_RTS) 1269 ireq->i_val = IEEE80211_HTCAP_SMPS_DYNAMIC; 1270 else if (vap->iv_bss->ni_flags & IEEE80211_NODE_MIMO_PS) 1271 ireq->i_val = IEEE80211_HTCAP_SMPS_ENA; 1272 else 1273 ireq->i_val = IEEE80211_HTCAP_SMPS_OFF; 1274 } else 1275 ireq->i_val = vap->iv_htcaps & IEEE80211_HTCAP_SMPS; 1276 break; 1277 case IEEE80211_IOC_RIFS: 1278 if (vap->iv_opmode == IEEE80211_M_STA && 1279 (vap->iv_state == IEEE80211_S_RUN || vap->iv_state == IEEE80211_S_SLEEP)) 1280 ireq->i_val = 1281 (vap->iv_bss->ni_flags & IEEE80211_NODE_RIFS) != 0; 1282 else 1283 ireq->i_val = 1284 (vap->iv_flags_ht & IEEE80211_FHT_RIFS) != 0; 1285 break; 1286 case IEEE80211_IOC_STBC: 1287 ireq->i_val = 0; 1288 if (vap->iv_flags_ht & IEEE80211_FHT_STBC_TX) 1289 ireq->i_val |= 1; 1290 if (vap->iv_flags_ht & IEEE80211_FHT_STBC_RX) 1291 ireq->i_val |= 2; 1292 break; 1293 case IEEE80211_IOC_LDPC: 1294 ireq->i_val = 0; 1295 if (vap->iv_flags_ht & IEEE80211_FHT_LDPC_TX) 1296 ireq->i_val |= 1; 1297 if (vap->iv_flags_ht & IEEE80211_FHT_LDPC_RX) 1298 ireq->i_val |= 2; 1299 break; 1300 1301 /* VHT */ 1302 case IEEE80211_IOC_VHTCONF: 1303 ireq->i_val = 0; 1304 if (vap->iv_flags_vht & IEEE80211_FVHT_VHT) 1305 ireq->i_val |= 1; 1306 if (vap->iv_flags_vht & IEEE80211_FVHT_USEVHT40) 1307 ireq->i_val |= 2; 1308 if (vap->iv_flags_vht & IEEE80211_FVHT_USEVHT80) 1309 ireq->i_val |= 4; 1310 if (vap->iv_flags_vht & IEEE80211_FVHT_USEVHT80P80) 1311 ireq->i_val |= 8; 1312 if (vap->iv_flags_vht & IEEE80211_FVHT_USEVHT160) 1313 ireq->i_val |= 16; 1314 break; 1315 1316 default: 1317 error = ieee80211_ioctl_getdefault(vap, ireq); 1318 break; 1319 } 1320 return error; 1321 #undef MS 1322 } 1323 1324 static int 1325 ieee80211_ioctl_setkey(struct ieee80211vap *vap, struct ieee80211req *ireq) 1326 { 1327 struct ieee80211req_key ik; 1328 struct ieee80211_node *ni; 1329 struct ieee80211_key *wk; 1330 uint16_t kid; 1331 int error, i; 1332 1333 if (ireq->i_len != sizeof(ik)) 1334 return EINVAL; 1335 error = copyin(ireq->i_data, &ik, sizeof(ik)); 1336 if (error) 1337 return error; 1338 /* NB: cipher support is verified by ieee80211_crypt_newkey */ 1339 /* NB: this also checks ik->ik_keylen > sizeof(wk->wk_key) */ 1340 if (ik.ik_keylen > sizeof(ik.ik_keydata)) 1341 return E2BIG; 1342 kid = ik.ik_keyix; 1343 if (kid == IEEE80211_KEYIX_NONE) { 1344 /* XXX unicast keys currently must be tx/rx */ 1345 if (ik.ik_flags != (IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV)) 1346 return EINVAL; 1347 if (vap->iv_opmode == IEEE80211_M_STA) { 1348 ni = ieee80211_ref_node(vap->iv_bss); 1349 if (!IEEE80211_ADDR_EQ(ik.ik_macaddr, ni->ni_bssid)) { 1350 ieee80211_free_node(ni); 1351 return EADDRNOTAVAIL; 1352 } 1353 } else { 1354 ni = ieee80211_find_vap_node(&vap->iv_ic->ic_sta, vap, 1355 ik.ik_macaddr); 1356 if (ni == NULL) 1357 return ENOENT; 1358 } 1359 wk = &ni->ni_ucastkey; 1360 } else { 1361 if (kid >= IEEE80211_WEP_NKID) 1362 return EINVAL; 1363 wk = &vap->iv_nw_keys[kid]; 1364 /* 1365 * Global slots start off w/o any assigned key index. 1366 * Force one here for consistency with IEEE80211_IOC_WEPKEY. 1367 */ 1368 if (wk->wk_keyix == IEEE80211_KEYIX_NONE) 1369 wk->wk_keyix = kid; 1370 ni = NULL; 1371 } 1372 error = 0; 1373 ieee80211_key_update_begin(vap); 1374 if (ieee80211_crypto_newkey(vap, ik.ik_type, ik.ik_flags, wk)) { 1375 wk->wk_keylen = ik.ik_keylen; 1376 /* NB: MIC presence is implied by cipher type */ 1377 if (wk->wk_keylen > IEEE80211_KEYBUF_SIZE) 1378 wk->wk_keylen = IEEE80211_KEYBUF_SIZE; 1379 for (i = 0; i < IEEE80211_TID_SIZE; i++) 1380 wk->wk_keyrsc[i] = ik.ik_keyrsc; 1381 wk->wk_keytsc = 0; /* new key, reset */ 1382 memset(wk->wk_key, 0, sizeof(wk->wk_key)); 1383 memcpy(wk->wk_key, ik.ik_keydata, ik.ik_keylen); 1384 IEEE80211_ADDR_COPY(wk->wk_macaddr, 1385 ni != NULL ? ni->ni_macaddr : ik.ik_macaddr); 1386 if (!ieee80211_crypto_setkey(vap, wk)) 1387 error = EIO; 1388 else if ((ik.ik_flags & IEEE80211_KEY_DEFAULT)) 1389 /* 1390 * Inform the driver that this is the default 1391 * transmit key. Now, ideally we'd just set 1392 * a flag in the key update that would 1393 * say "yes, we're the default key", but 1394 * that currently isn't the way the ioctl -> 1395 * key interface works. 1396 */ 1397 ieee80211_crypto_set_deftxkey(vap, kid); 1398 } else 1399 error = ENXIO; 1400 ieee80211_key_update_end(vap); 1401 if (ni != NULL) 1402 ieee80211_free_node(ni); 1403 return error; 1404 } 1405 1406 static int 1407 ieee80211_ioctl_delkey(struct ieee80211vap *vap, struct ieee80211req *ireq) 1408 { 1409 struct ieee80211req_del_key dk; 1410 int kid, error; 1411 1412 if (ireq->i_len != sizeof(dk)) 1413 return EINVAL; 1414 error = copyin(ireq->i_data, &dk, sizeof(dk)); 1415 if (error) 1416 return error; 1417 kid = dk.idk_keyix; 1418 /* XXX uint8_t -> uint16_t */ 1419 if (dk.idk_keyix == (uint8_t) IEEE80211_KEYIX_NONE) { 1420 struct ieee80211_node *ni; 1421 1422 if (vap->iv_opmode == IEEE80211_M_STA) { 1423 ni = ieee80211_ref_node(vap->iv_bss); 1424 if (!IEEE80211_ADDR_EQ(dk.idk_macaddr, ni->ni_bssid)) { 1425 ieee80211_free_node(ni); 1426 return EADDRNOTAVAIL; 1427 } 1428 } else { 1429 ni = ieee80211_find_vap_node(&vap->iv_ic->ic_sta, vap, 1430 dk.idk_macaddr); 1431 if (ni == NULL) 1432 return ENOENT; 1433 } 1434 /* XXX error return */ 1435 ieee80211_node_delucastkey(ni); 1436 ieee80211_free_node(ni); 1437 } else { 1438 if (kid >= IEEE80211_WEP_NKID) 1439 return EINVAL; 1440 /* XXX error return */ 1441 ieee80211_crypto_delkey(vap, &vap->iv_nw_keys[kid]); 1442 } 1443 return 0; 1444 } 1445 1446 struct mlmeop { 1447 struct ieee80211vap *vap; 1448 int op; 1449 int reason; 1450 }; 1451 1452 static void 1453 mlmedebug(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN], 1454 int op, int reason) 1455 { 1456 #ifdef IEEE80211_DEBUG 1457 static const struct { 1458 int mask; 1459 const char *opstr; 1460 } ops[] = { 1461 { 0, "op#0" }, 1462 { IEEE80211_MSG_IOCTL | IEEE80211_MSG_STATE | 1463 IEEE80211_MSG_ASSOC, "assoc" }, 1464 { IEEE80211_MSG_IOCTL | IEEE80211_MSG_STATE | 1465 IEEE80211_MSG_ASSOC, "disassoc" }, 1466 { IEEE80211_MSG_IOCTL | IEEE80211_MSG_STATE | 1467 IEEE80211_MSG_AUTH, "deauth" }, 1468 { IEEE80211_MSG_IOCTL | IEEE80211_MSG_STATE | 1469 IEEE80211_MSG_AUTH, "authorize" }, 1470 { IEEE80211_MSG_IOCTL | IEEE80211_MSG_STATE | 1471 IEEE80211_MSG_AUTH, "unauthorize" }, 1472 }; 1473 1474 if (op == IEEE80211_MLME_AUTH) { 1475 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_IOCTL | 1476 IEEE80211_MSG_STATE | IEEE80211_MSG_AUTH, mac, 1477 "station authenticate %s via MLME (reason: %d (%s))", 1478 reason == IEEE80211_STATUS_SUCCESS ? "ACCEPT" : "REJECT", 1479 reason, ieee80211_reason_to_string(reason)); 1480 } else if (!(IEEE80211_MLME_ASSOC <= op && op <= IEEE80211_MLME_AUTH)) { 1481 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_ANY, mac, 1482 "unknown MLME request %d (reason: %d (%s))", op, reason, 1483 ieee80211_reason_to_string(reason)); 1484 } else if (reason == IEEE80211_STATUS_SUCCESS) { 1485 IEEE80211_NOTE_MAC(vap, ops[op].mask, mac, 1486 "station %s via MLME", ops[op].opstr); 1487 } else { 1488 IEEE80211_NOTE_MAC(vap, ops[op].mask, mac, 1489 "station %s via MLME (reason: %d (%s))", ops[op].opstr, 1490 reason, ieee80211_reason_to_string(reason)); 1491 } 1492 #endif /* IEEE80211_DEBUG */ 1493 } 1494 1495 static void 1496 domlme(void *arg, struct ieee80211_node *ni) 1497 { 1498 struct mlmeop *mop = arg; 1499 struct ieee80211vap *vap = ni->ni_vap; 1500 1501 if (vap != mop->vap) 1502 return; 1503 /* 1504 * NB: if ni_associd is zero then the node is already cleaned 1505 * up and we don't need to do this (we're safely holding a 1506 * reference but should otherwise not modify it's state). 1507 */ 1508 if (ni->ni_associd == 0) 1509 return; 1510 mlmedebug(vap, ni->ni_macaddr, mop->op, mop->reason); 1511 if (mop->op == IEEE80211_MLME_DEAUTH) { 1512 IEEE80211_SEND_MGMT(ni, IEEE80211_FC0_SUBTYPE_DEAUTH, 1513 mop->reason); 1514 } else { 1515 IEEE80211_SEND_MGMT(ni, IEEE80211_FC0_SUBTYPE_DISASSOC, 1516 mop->reason); 1517 } 1518 ieee80211_node_leave(ni); 1519 } 1520 1521 static int 1522 setmlme_dropsta(struct ieee80211vap *vap, 1523 const uint8_t mac[IEEE80211_ADDR_LEN], struct mlmeop *mlmeop) 1524 { 1525 struct ieee80211_node_table *nt = &vap->iv_ic->ic_sta; 1526 struct ieee80211_node *ni; 1527 int error = 0; 1528 1529 /* NB: the broadcast address means do 'em all */ 1530 if (!IEEE80211_ADDR_EQ(mac, vap->iv_ifp->if_broadcastaddr)) { 1531 IEEE80211_NODE_LOCK(nt); 1532 ni = ieee80211_find_node_locked(nt, mac); 1533 IEEE80211_NODE_UNLOCK(nt); 1534 /* 1535 * Don't do the node update inside the node 1536 * table lock. This unfortunately causes LORs 1537 * with drivers and their TX paths. 1538 */ 1539 if (ni != NULL) { 1540 domlme(mlmeop, ni); 1541 ieee80211_free_node(ni); 1542 } else 1543 error = ENOENT; 1544 } else { 1545 ieee80211_iterate_nodes(nt, domlme, mlmeop); 1546 } 1547 return error; 1548 } 1549 1550 static int 1551 setmlme_common(struct ieee80211vap *vap, int op, 1552 const uint8_t mac[IEEE80211_ADDR_LEN], int reason) 1553 { 1554 struct ieee80211com *ic = vap->iv_ic; 1555 struct ieee80211_node_table *nt = &ic->ic_sta; 1556 struct ieee80211_node *ni; 1557 struct mlmeop mlmeop; 1558 int error; 1559 1560 error = 0; 1561 switch (op) { 1562 case IEEE80211_MLME_DISASSOC: 1563 case IEEE80211_MLME_DEAUTH: 1564 switch (vap->iv_opmode) { 1565 case IEEE80211_M_STA: 1566 mlmedebug(vap, vap->iv_bss->ni_macaddr, op, reason); 1567 /* XXX not quite right */ 1568 ieee80211_new_state(vap, IEEE80211_S_INIT, reason); 1569 break; 1570 case IEEE80211_M_HOSTAP: 1571 mlmeop.vap = vap; 1572 mlmeop.op = op; 1573 mlmeop.reason = reason; 1574 error = setmlme_dropsta(vap, mac, &mlmeop); 1575 break; 1576 case IEEE80211_M_WDS: 1577 /* XXX user app should send raw frame? */ 1578 if (op != IEEE80211_MLME_DEAUTH) { 1579 error = EINVAL; 1580 break; 1581 } 1582 #if 0 1583 /* XXX accept any address, simplifies user code */ 1584 if (!IEEE80211_ADDR_EQ(mac, vap->iv_bss->ni_macaddr)) { 1585 error = EINVAL; 1586 break; 1587 } 1588 #endif 1589 mlmedebug(vap, vap->iv_bss->ni_macaddr, op, reason); 1590 ni = ieee80211_ref_node(vap->iv_bss); 1591 IEEE80211_SEND_MGMT(ni, 1592 IEEE80211_FC0_SUBTYPE_DEAUTH, reason); 1593 ieee80211_free_node(ni); 1594 break; 1595 case IEEE80211_M_MBSS: 1596 IEEE80211_NODE_LOCK(nt); 1597 ni = ieee80211_find_node_locked(nt, mac); 1598 /* 1599 * Don't do the node update inside the node 1600 * table lock. This unfortunately causes LORs 1601 * with drivers and their TX paths. 1602 */ 1603 IEEE80211_NODE_UNLOCK(nt); 1604 if (ni != NULL) { 1605 ieee80211_node_leave(ni); 1606 ieee80211_free_node(ni); 1607 } else { 1608 error = ENOENT; 1609 } 1610 break; 1611 default: 1612 error = EINVAL; 1613 break; 1614 } 1615 break; 1616 case IEEE80211_MLME_AUTHORIZE: 1617 case IEEE80211_MLME_UNAUTHORIZE: 1618 if (vap->iv_opmode != IEEE80211_M_HOSTAP && 1619 vap->iv_opmode != IEEE80211_M_WDS) { 1620 error = EINVAL; 1621 break; 1622 } 1623 IEEE80211_NODE_LOCK(nt); 1624 ni = ieee80211_find_vap_node_locked(nt, vap, mac); 1625 /* 1626 * Don't do the node update inside the node 1627 * table lock. This unfortunately causes LORs 1628 * with drivers and their TX paths. 1629 */ 1630 IEEE80211_NODE_UNLOCK(nt); 1631 if (ni != NULL) { 1632 mlmedebug(vap, mac, op, reason); 1633 if (op == IEEE80211_MLME_AUTHORIZE) 1634 ieee80211_node_authorize(ni); 1635 else 1636 ieee80211_node_unauthorize(ni); 1637 ieee80211_free_node(ni); 1638 } else 1639 error = ENOENT; 1640 break; 1641 case IEEE80211_MLME_AUTH: 1642 if (vap->iv_opmode != IEEE80211_M_HOSTAP) { 1643 error = EINVAL; 1644 break; 1645 } 1646 IEEE80211_NODE_LOCK(nt); 1647 ni = ieee80211_find_vap_node_locked(nt, vap, mac); 1648 /* 1649 * Don't do the node update inside the node 1650 * table lock. This unfortunately causes LORs 1651 * with drivers and their TX paths. 1652 */ 1653 IEEE80211_NODE_UNLOCK(nt); 1654 if (ni != NULL) { 1655 mlmedebug(vap, mac, op, reason); 1656 if (reason == IEEE80211_STATUS_SUCCESS) { 1657 IEEE80211_SEND_MGMT(ni, 1658 IEEE80211_FC0_SUBTYPE_AUTH, 2); 1659 /* 1660 * For shared key auth, just continue the 1661 * exchange. Otherwise when 802.1x is not in 1662 * use mark the port authorized at this point 1663 * so traffic can flow. 1664 */ 1665 if (ni->ni_authmode != IEEE80211_AUTH_8021X && 1666 ni->ni_challenge == NULL) 1667 ieee80211_node_authorize(ni); 1668 } else { 1669 vap->iv_stats.is_rx_acl++; 1670 ieee80211_send_error(ni, ni->ni_macaddr, 1671 IEEE80211_FC0_SUBTYPE_AUTH, 2|(reason<<16)); 1672 ieee80211_node_leave(ni); 1673 } 1674 ieee80211_free_node(ni); 1675 } else 1676 error = ENOENT; 1677 break; 1678 default: 1679 error = EINVAL; 1680 break; 1681 } 1682 return error; 1683 } 1684 1685 struct scanlookup { 1686 const uint8_t *mac; 1687 int esslen; 1688 const uint8_t *essid; 1689 const struct ieee80211_scan_entry *se; 1690 }; 1691 1692 /* 1693 * Match mac address and any ssid. 1694 */ 1695 static void 1696 mlmelookup(void *arg, const struct ieee80211_scan_entry *se) 1697 { 1698 struct scanlookup *look = arg; 1699 1700 if (!IEEE80211_ADDR_EQ(look->mac, se->se_macaddr)) 1701 return; 1702 if (look->esslen != 0) { 1703 if (se->se_ssid[1] != look->esslen) 1704 return; 1705 if (memcmp(look->essid, se->se_ssid+2, look->esslen)) 1706 return; 1707 } 1708 look->se = se; 1709 } 1710 1711 static int 1712 setmlme_assoc_sta(struct ieee80211vap *vap, 1713 const uint8_t mac[IEEE80211_ADDR_LEN], int ssid_len, 1714 const uint8_t ssid[IEEE80211_NWID_LEN]) 1715 { 1716 struct scanlookup lookup; 1717 1718 KASSERT(vap->iv_opmode == IEEE80211_M_STA, 1719 ("expected opmode STA not %s", 1720 ieee80211_opmode_name[vap->iv_opmode])); 1721 1722 /* NB: this is racey if roaming is !manual */ 1723 lookup.se = NULL; 1724 lookup.mac = mac; 1725 lookup.esslen = ssid_len; 1726 lookup.essid = ssid; 1727 ieee80211_scan_iterate(vap, mlmelookup, &lookup); 1728 if (lookup.se == NULL) 1729 return ENOENT; 1730 mlmedebug(vap, mac, IEEE80211_MLME_ASSOC, 0); 1731 if (!ieee80211_sta_join(vap, lookup.se->se_chan, lookup.se)) 1732 return EIO; /* XXX unique but could be better */ 1733 return 0; 1734 } 1735 1736 static int 1737 setmlme_assoc_adhoc(struct ieee80211vap *vap, 1738 const uint8_t mac[IEEE80211_ADDR_LEN], int ssid_len, 1739 const uint8_t ssid[IEEE80211_NWID_LEN]) 1740 { 1741 struct ieee80211_scan_req *sr; 1742 int error; 1743 1744 KASSERT(vap->iv_opmode == IEEE80211_M_IBSS || 1745 vap->iv_opmode == IEEE80211_M_AHDEMO, 1746 ("expected opmode IBSS or AHDEMO not %s", 1747 ieee80211_opmode_name[vap->iv_opmode])); 1748 1749 if (ssid_len == 0) 1750 return EINVAL; 1751 1752 sr = IEEE80211_MALLOC(sizeof(*sr), M_TEMP, 1753 IEEE80211_M_NOWAIT | IEEE80211_M_ZERO); 1754 if (sr == NULL) 1755 return ENOMEM; 1756 1757 /* NB: IEEE80211_IOC_SSID call missing for ap_scan=2. */ 1758 memset(vap->iv_des_ssid[0].ssid, 0, IEEE80211_NWID_LEN); 1759 vap->iv_des_ssid[0].len = ssid_len; 1760 memcpy(vap->iv_des_ssid[0].ssid, ssid, ssid_len); 1761 vap->iv_des_nssid = 1; 1762 1763 sr->sr_flags = IEEE80211_IOC_SCAN_ACTIVE | IEEE80211_IOC_SCAN_ONCE; 1764 sr->sr_duration = IEEE80211_IOC_SCAN_FOREVER; 1765 memcpy(sr->sr_ssid[0].ssid, ssid, ssid_len); 1766 sr->sr_ssid[0].len = ssid_len; 1767 sr->sr_nssid = 1; 1768 1769 error = ieee80211_scanreq(vap, sr); 1770 1771 IEEE80211_FREE(sr, M_TEMP); 1772 return error; 1773 } 1774 1775 static int 1776 ieee80211_ioctl_setmlme(struct ieee80211vap *vap, struct ieee80211req *ireq) 1777 { 1778 struct ieee80211req_mlme mlme; 1779 int error; 1780 1781 if (ireq->i_len != sizeof(mlme)) 1782 return EINVAL; 1783 error = copyin(ireq->i_data, &mlme, sizeof(mlme)); 1784 if (error) 1785 return error; 1786 if (vap->iv_opmode == IEEE80211_M_STA && 1787 mlme.im_op == IEEE80211_MLME_ASSOC) 1788 return setmlme_assoc_sta(vap, mlme.im_macaddr, 1789 vap->iv_des_ssid[0].len, vap->iv_des_ssid[0].ssid); 1790 else if ((vap->iv_opmode == IEEE80211_M_IBSS || 1791 vap->iv_opmode == IEEE80211_M_AHDEMO) && 1792 mlme.im_op == IEEE80211_MLME_ASSOC) 1793 return setmlme_assoc_adhoc(vap, mlme.im_macaddr, 1794 mlme.im_ssid_len, mlme.im_ssid); 1795 else 1796 return setmlme_common(vap, mlme.im_op, 1797 mlme.im_macaddr, mlme.im_reason); 1798 } 1799 1800 static int 1801 ieee80211_ioctl_macmac(struct ieee80211vap *vap, struct ieee80211req *ireq) 1802 { 1803 uint8_t mac[IEEE80211_ADDR_LEN]; 1804 const struct ieee80211_aclator *acl = vap->iv_acl; 1805 int error; 1806 1807 if (ireq->i_len != sizeof(mac)) 1808 return EINVAL; 1809 error = copyin(ireq->i_data, mac, ireq->i_len); 1810 if (error) 1811 return error; 1812 if (acl == NULL) { 1813 acl = ieee80211_aclator_get("mac"); 1814 if (acl == NULL || !acl->iac_attach(vap)) 1815 return EINVAL; 1816 vap->iv_acl = acl; 1817 } 1818 if (ireq->i_type == IEEE80211_IOC_ADDMAC) 1819 acl->iac_add(vap, mac); 1820 else 1821 acl->iac_remove(vap, mac); 1822 return 0; 1823 } 1824 1825 static int 1826 ieee80211_ioctl_setmaccmd(struct ieee80211vap *vap, struct ieee80211req *ireq) 1827 { 1828 const struct ieee80211_aclator *acl = vap->iv_acl; 1829 1830 switch (ireq->i_val) { 1831 case IEEE80211_MACCMD_POLICY_OPEN: 1832 case IEEE80211_MACCMD_POLICY_ALLOW: 1833 case IEEE80211_MACCMD_POLICY_DENY: 1834 case IEEE80211_MACCMD_POLICY_RADIUS: 1835 if (acl == NULL) { 1836 acl = ieee80211_aclator_get("mac"); 1837 if (acl == NULL || !acl->iac_attach(vap)) 1838 return EINVAL; 1839 vap->iv_acl = acl; 1840 } 1841 acl->iac_setpolicy(vap, ireq->i_val); 1842 break; 1843 case IEEE80211_MACCMD_FLUSH: 1844 if (acl != NULL) 1845 acl->iac_flush(vap); 1846 /* NB: silently ignore when not in use */ 1847 break; 1848 case IEEE80211_MACCMD_DETACH: 1849 if (acl != NULL) { 1850 vap->iv_acl = NULL; 1851 acl->iac_detach(vap); 1852 } 1853 break; 1854 default: 1855 if (acl == NULL) 1856 return EINVAL; 1857 else 1858 return acl->iac_setioctl(vap, ireq); 1859 } 1860 return 0; 1861 } 1862 1863 static int 1864 ieee80211_ioctl_setchanlist(struct ieee80211vap *vap, struct ieee80211req *ireq) 1865 { 1866 struct ieee80211com *ic = vap->iv_ic; 1867 uint8_t *chanlist, *list; 1868 int i, nchan, maxchan, error; 1869 1870 if (ireq->i_len > sizeof(ic->ic_chan_active)) 1871 ireq->i_len = sizeof(ic->ic_chan_active); 1872 list = IEEE80211_MALLOC(ireq->i_len + IEEE80211_CHAN_BYTES, M_TEMP, 1873 IEEE80211_M_NOWAIT | IEEE80211_M_ZERO); 1874 if (list == NULL) 1875 return ENOMEM; 1876 error = copyin(ireq->i_data, list, ireq->i_len); 1877 if (error) { 1878 IEEE80211_FREE(list, M_TEMP); 1879 return error; 1880 } 1881 nchan = 0; 1882 chanlist = list + ireq->i_len; /* NB: zero'd already */ 1883 maxchan = ireq->i_len * NBBY; 1884 for (i = 0; i < ic->ic_nchans; i++) { 1885 const struct ieee80211_channel *c = &ic->ic_channels[i]; 1886 /* 1887 * Calculate the intersection of the user list and the 1888 * available channels so users can do things like specify 1889 * 1-255 to get all available channels. 1890 */ 1891 if (c->ic_ieee < maxchan && isset(list, c->ic_ieee)) { 1892 setbit(chanlist, c->ic_ieee); 1893 nchan++; 1894 } 1895 } 1896 if (nchan == 0) { 1897 IEEE80211_FREE(list, M_TEMP); 1898 return EINVAL; 1899 } 1900 if (ic->ic_bsschan != IEEE80211_CHAN_ANYC && /* XXX */ 1901 isclr(chanlist, ic->ic_bsschan->ic_ieee)) 1902 ic->ic_bsschan = IEEE80211_CHAN_ANYC; 1903 memcpy(ic->ic_chan_active, chanlist, IEEE80211_CHAN_BYTES); 1904 ieee80211_scan_flush(vap); 1905 IEEE80211_FREE(list, M_TEMP); 1906 return ENETRESET; 1907 } 1908 1909 static int 1910 ieee80211_ioctl_setstastats(struct ieee80211vap *vap, struct ieee80211req *ireq) 1911 { 1912 struct ieee80211_node *ni; 1913 uint8_t macaddr[IEEE80211_ADDR_LEN]; 1914 int error; 1915 1916 /* 1917 * NB: we could copyin ieee80211req_sta_stats so apps 1918 * could make selective changes but that's overkill; 1919 * just clear all stats for now. 1920 */ 1921 if (ireq->i_len < IEEE80211_ADDR_LEN) 1922 return EINVAL; 1923 error = copyin(ireq->i_data, macaddr, IEEE80211_ADDR_LEN); 1924 if (error != 0) 1925 return error; 1926 ni = ieee80211_find_vap_node(&vap->iv_ic->ic_sta, vap, macaddr); 1927 if (ni == NULL) 1928 return ENOENT; 1929 /* XXX require ni_vap == vap? */ 1930 memset(&ni->ni_stats, 0, sizeof(ni->ni_stats)); 1931 ieee80211_free_node(ni); 1932 return 0; 1933 } 1934 1935 static int 1936 ieee80211_ioctl_setstatxpow(struct ieee80211vap *vap, struct ieee80211req *ireq) 1937 { 1938 struct ieee80211_node *ni; 1939 struct ieee80211req_sta_txpow txpow; 1940 int error; 1941 1942 if (ireq->i_len != sizeof(txpow)) 1943 return EINVAL; 1944 error = copyin(ireq->i_data, &txpow, sizeof(txpow)); 1945 if (error != 0) 1946 return error; 1947 ni = ieee80211_find_vap_node(&vap->iv_ic->ic_sta, vap, txpow.it_macaddr); 1948 if (ni == NULL) 1949 return ENOENT; 1950 ni->ni_txpower = txpow.it_txpow; 1951 ieee80211_free_node(ni); 1952 return error; 1953 } 1954 1955 static int 1956 ieee80211_ioctl_setwmeparam(struct ieee80211vap *vap, struct ieee80211req *ireq) 1957 { 1958 struct ieee80211com *ic = vap->iv_ic; 1959 struct ieee80211_wme_state *wme = &ic->ic_wme; 1960 struct wmeParams *wmep, *chanp; 1961 int isbss, ac, aggrmode; 1962 1963 if ((ic->ic_caps & IEEE80211_C_WME) == 0) 1964 return EOPNOTSUPP; 1965 1966 isbss = (ireq->i_len & IEEE80211_WMEPARAM_BSS); 1967 ac = (ireq->i_len & IEEE80211_WMEPARAM_VAL); 1968 aggrmode = (wme->wme_flags & WME_F_AGGRMODE); 1969 if (ac >= WME_NUM_AC) 1970 ac = WME_AC_BE; 1971 if (isbss) { 1972 chanp = &wme->wme_bssChanParams.cap_wmeParams[ac]; 1973 wmep = &wme->wme_wmeBssChanParams.cap_wmeParams[ac]; 1974 } else { 1975 chanp = &wme->wme_chanParams.cap_wmeParams[ac]; 1976 wmep = &wme->wme_wmeChanParams.cap_wmeParams[ac]; 1977 } 1978 switch (ireq->i_type) { 1979 case IEEE80211_IOC_WME_CWMIN: /* WME: CWmin */ 1980 wmep->wmep_logcwmin = ireq->i_val; 1981 if (!isbss || !aggrmode) 1982 chanp->wmep_logcwmin = ireq->i_val; 1983 break; 1984 case IEEE80211_IOC_WME_CWMAX: /* WME: CWmax */ 1985 wmep->wmep_logcwmax = ireq->i_val; 1986 if (!isbss || !aggrmode) 1987 chanp->wmep_logcwmax = ireq->i_val; 1988 break; 1989 case IEEE80211_IOC_WME_AIFS: /* WME: AIFS */ 1990 wmep->wmep_aifsn = ireq->i_val; 1991 if (!isbss || !aggrmode) 1992 chanp->wmep_aifsn = ireq->i_val; 1993 break; 1994 case IEEE80211_IOC_WME_TXOPLIMIT: /* WME: txops limit */ 1995 wmep->wmep_txopLimit = ireq->i_val; 1996 if (!isbss || !aggrmode) 1997 chanp->wmep_txopLimit = ireq->i_val; 1998 break; 1999 case IEEE80211_IOC_WME_ACM: /* WME: ACM (bss only) */ 2000 wmep->wmep_acm = ireq->i_val; 2001 if (!aggrmode) 2002 chanp->wmep_acm = ireq->i_val; 2003 break; 2004 case IEEE80211_IOC_WME_ACKPOLICY: /* WME: ACK policy (!bss only)*/ 2005 wmep->wmep_noackPolicy = chanp->wmep_noackPolicy = 2006 (ireq->i_val) == 0; 2007 break; 2008 } 2009 ieee80211_wme_updateparams(vap); 2010 return 0; 2011 } 2012 2013 static int 2014 find11gchannel(struct ieee80211com *ic, int start, int freq) 2015 { 2016 const struct ieee80211_channel *c; 2017 int i; 2018 2019 for (i = start+1; i < ic->ic_nchans; i++) { 2020 c = &ic->ic_channels[i]; 2021 if (c->ic_freq == freq && IEEE80211_IS_CHAN_ANYG(c)) 2022 return 1; 2023 } 2024 /* NB: should not be needed but in case things are mis-sorted */ 2025 for (i = 0; i < start; i++) { 2026 c = &ic->ic_channels[i]; 2027 if (c->ic_freq == freq && IEEE80211_IS_CHAN_ANYG(c)) 2028 return 1; 2029 } 2030 return 0; 2031 } 2032 2033 static struct ieee80211_channel * 2034 findchannel(struct ieee80211com *ic, int ieee, int mode) 2035 { 2036 static const u_int chanflags[IEEE80211_MODE_MAX] = { 2037 [IEEE80211_MODE_AUTO] = 0, 2038 [IEEE80211_MODE_11A] = IEEE80211_CHAN_A, 2039 [IEEE80211_MODE_11B] = IEEE80211_CHAN_B, 2040 [IEEE80211_MODE_11G] = IEEE80211_CHAN_G, 2041 [IEEE80211_MODE_FH] = IEEE80211_CHAN_FHSS, 2042 [IEEE80211_MODE_TURBO_A] = IEEE80211_CHAN_108A, 2043 [IEEE80211_MODE_TURBO_G] = IEEE80211_CHAN_108G, 2044 [IEEE80211_MODE_STURBO_A] = IEEE80211_CHAN_STURBO, 2045 [IEEE80211_MODE_HALF] = IEEE80211_CHAN_HALF, 2046 [IEEE80211_MODE_QUARTER] = IEEE80211_CHAN_QUARTER, 2047 /* NB: handled specially below */ 2048 [IEEE80211_MODE_11NA] = IEEE80211_CHAN_A, 2049 [IEEE80211_MODE_11NG] = IEEE80211_CHAN_G, 2050 [IEEE80211_MODE_VHT_5GHZ] = IEEE80211_CHAN_A, 2051 [IEEE80211_MODE_VHT_2GHZ] = IEEE80211_CHAN_G, 2052 }; 2053 u_int modeflags; 2054 int i; 2055 2056 modeflags = chanflags[mode]; 2057 for (i = 0; i < ic->ic_nchans; i++) { 2058 struct ieee80211_channel *c = &ic->ic_channels[i]; 2059 2060 if (c->ic_ieee != ieee) 2061 continue; 2062 if (mode == IEEE80211_MODE_AUTO) { 2063 /* ignore turbo channels for autoselect */ 2064 if (IEEE80211_IS_CHAN_TURBO(c)) 2065 continue; 2066 /* 2067 * XXX special-case 11b/g channels so we 2068 * always select the g channel if both 2069 * are present. 2070 * XXX prefer HT to non-HT? 2071 */ 2072 if (!IEEE80211_IS_CHAN_B(c) || 2073 !find11gchannel(ic, i, c->ic_freq)) 2074 return c; 2075 } else { 2076 /* must check VHT specifically */ 2077 if ((mode == IEEE80211_MODE_VHT_5GHZ || 2078 mode == IEEE80211_MODE_VHT_2GHZ) && 2079 !IEEE80211_IS_CHAN_VHT(c)) 2080 continue; 2081 2082 /* 2083 * Must check HT specially - only match on HT, 2084 * not HT+VHT channels 2085 */ 2086 if ((mode == IEEE80211_MODE_11NA || 2087 mode == IEEE80211_MODE_11NG) && 2088 !IEEE80211_IS_CHAN_HT(c)) 2089 continue; 2090 2091 if ((mode == IEEE80211_MODE_11NA || 2092 mode == IEEE80211_MODE_11NG) && 2093 IEEE80211_IS_CHAN_VHT(c)) 2094 continue; 2095 2096 /* Check that the modeflags above match */ 2097 if ((c->ic_flags & modeflags) == modeflags) 2098 return c; 2099 } 2100 } 2101 return NULL; 2102 } 2103 2104 /* 2105 * Check the specified against any desired mode (aka netband). 2106 * This is only used (presently) when operating in hostap mode 2107 * to enforce consistency. 2108 */ 2109 static int 2110 check_mode_consistency(const struct ieee80211_channel *c, int mode) 2111 { 2112 KASSERT(c != IEEE80211_CHAN_ANYC, ("oops, no channel")); 2113 2114 switch (mode) { 2115 case IEEE80211_MODE_11B: 2116 return (IEEE80211_IS_CHAN_B(c)); 2117 case IEEE80211_MODE_11G: 2118 return (IEEE80211_IS_CHAN_ANYG(c) && !IEEE80211_IS_CHAN_HT(c)); 2119 case IEEE80211_MODE_11A: 2120 return (IEEE80211_IS_CHAN_A(c) && !IEEE80211_IS_CHAN_HT(c)); 2121 case IEEE80211_MODE_STURBO_A: 2122 return (IEEE80211_IS_CHAN_STURBO(c)); 2123 case IEEE80211_MODE_11NA: 2124 return (IEEE80211_IS_CHAN_HTA(c)); 2125 case IEEE80211_MODE_11NG: 2126 return (IEEE80211_IS_CHAN_HTG(c)); 2127 } 2128 return 1; 2129 2130 } 2131 2132 /* 2133 * Common code to set the current channel. If the device 2134 * is up and running this may result in an immediate channel 2135 * change or a kick of the state machine. 2136 */ 2137 static int 2138 setcurchan(struct ieee80211vap *vap, struct ieee80211_channel *c) 2139 { 2140 struct ieee80211com *ic = vap->iv_ic; 2141 int error; 2142 2143 if (c != IEEE80211_CHAN_ANYC) { 2144 if (IEEE80211_IS_CHAN_RADAR(c)) 2145 return EBUSY; /* XXX better code? */ 2146 if (vap->iv_opmode == IEEE80211_M_HOSTAP) { 2147 if (IEEE80211_IS_CHAN_NOHOSTAP(c)) 2148 return EINVAL; 2149 if (!check_mode_consistency(c, vap->iv_des_mode)) 2150 return EINVAL; 2151 } else if (vap->iv_opmode == IEEE80211_M_IBSS) { 2152 if (IEEE80211_IS_CHAN_NOADHOC(c)) 2153 return EINVAL; 2154 } 2155 if ((vap->iv_state == IEEE80211_S_RUN || vap->iv_state == IEEE80211_S_SLEEP) && 2156 vap->iv_bss->ni_chan == c) 2157 return 0; /* NB: nothing to do */ 2158 } 2159 vap->iv_des_chan = c; 2160 2161 error = 0; 2162 if (vap->iv_opmode == IEEE80211_M_MONITOR && 2163 vap->iv_des_chan != IEEE80211_CHAN_ANYC) { 2164 /* 2165 * Monitor mode can switch directly. 2166 */ 2167 if (IFNET_IS_UP_RUNNING(vap->iv_ifp)) { 2168 /* XXX need state machine for other vap's to follow */ 2169 ieee80211_setcurchan(ic, vap->iv_des_chan); 2170 vap->iv_bss->ni_chan = ic->ic_curchan; 2171 } else { 2172 ic->ic_curchan = vap->iv_des_chan; 2173 ic->ic_rt = ieee80211_get_ratetable(ic->ic_curchan); 2174 } 2175 } else { 2176 /* 2177 * Need to go through the state machine in case we 2178 * need to reassociate or the like. The state machine 2179 * will pickup the desired channel and avoid scanning. 2180 */ 2181 if (IS_UP_AUTO(vap)) 2182 ieee80211_new_state(vap, IEEE80211_S_SCAN, 0); 2183 else if (vap->iv_des_chan != IEEE80211_CHAN_ANYC) { 2184 /* 2185 * When not up+running and a real channel has 2186 * been specified fix the current channel so 2187 * there is immediate feedback; e.g. via ifconfig. 2188 */ 2189 ic->ic_curchan = vap->iv_des_chan; 2190 ic->ic_rt = ieee80211_get_ratetable(ic->ic_curchan); 2191 } 2192 } 2193 return error; 2194 } 2195 2196 /* 2197 * Old api for setting the current channel; this is 2198 * deprecated because channel numbers are ambiguous. 2199 */ 2200 static int 2201 ieee80211_ioctl_setchannel(struct ieee80211vap *vap, 2202 const struct ieee80211req *ireq) 2203 { 2204 struct ieee80211com *ic = vap->iv_ic; 2205 struct ieee80211_channel *c; 2206 2207 /* XXX 0xffff overflows 16-bit signed */ 2208 if (ireq->i_val == 0 || 2209 ireq->i_val == (int16_t) IEEE80211_CHAN_ANY) { 2210 c = IEEE80211_CHAN_ANYC; 2211 } else { 2212 struct ieee80211_channel *c2; 2213 2214 c = findchannel(ic, ireq->i_val, vap->iv_des_mode); 2215 if (c == NULL) { 2216 c = findchannel(ic, ireq->i_val, 2217 IEEE80211_MODE_AUTO); 2218 if (c == NULL) 2219 return EINVAL; 2220 } 2221 2222 /* 2223 * Fine tune channel selection based on desired mode: 2224 * if 11b is requested, find the 11b version of any 2225 * 11g channel returned, 2226 * if static turbo, find the turbo version of any 2227 * 11a channel return, 2228 * if 11na is requested, find the ht version of any 2229 * 11a channel returned, 2230 * if 11ng is requested, find the ht version of any 2231 * 11g channel returned, 2232 * if 11ac is requested, find the 11ac version 2233 * of any 11a/11na channel returned, 2234 * (TBD) 11acg (2GHz VHT) 2235 * otherwise we should be ok with what we've got. 2236 */ 2237 switch (vap->iv_des_mode) { 2238 case IEEE80211_MODE_11B: 2239 if (IEEE80211_IS_CHAN_ANYG(c)) { 2240 c2 = findchannel(ic, ireq->i_val, 2241 IEEE80211_MODE_11B); 2242 /* NB: should not happen, =>'s 11g w/o 11b */ 2243 if (c2 != NULL) 2244 c = c2; 2245 } 2246 break; 2247 case IEEE80211_MODE_TURBO_A: 2248 if (IEEE80211_IS_CHAN_A(c)) { 2249 c2 = findchannel(ic, ireq->i_val, 2250 IEEE80211_MODE_TURBO_A); 2251 if (c2 != NULL) 2252 c = c2; 2253 } 2254 break; 2255 case IEEE80211_MODE_11NA: 2256 if (IEEE80211_IS_CHAN_A(c)) { 2257 c2 = findchannel(ic, ireq->i_val, 2258 IEEE80211_MODE_11NA); 2259 if (c2 != NULL) 2260 c = c2; 2261 } 2262 break; 2263 case IEEE80211_MODE_11NG: 2264 if (IEEE80211_IS_CHAN_ANYG(c)) { 2265 c2 = findchannel(ic, ireq->i_val, 2266 IEEE80211_MODE_11NG); 2267 if (c2 != NULL) 2268 c = c2; 2269 } 2270 break; 2271 case IEEE80211_MODE_VHT_2GHZ: 2272 printf("%s: TBD\n", __func__); 2273 break; 2274 case IEEE80211_MODE_VHT_5GHZ: 2275 if (IEEE80211_IS_CHAN_A(c)) { 2276 c2 = findchannel(ic, ireq->i_val, 2277 IEEE80211_MODE_VHT_5GHZ); 2278 if (c2 != NULL) 2279 c = c2; 2280 } 2281 break; 2282 default: /* NB: no static turboG */ 2283 break; 2284 } 2285 } 2286 return setcurchan(vap, c); 2287 } 2288 2289 /* 2290 * New/current api for setting the current channel; a complete 2291 * channel description is provide so there is no ambiguity in 2292 * identifying the channel. 2293 */ 2294 static int 2295 ieee80211_ioctl_setcurchan(struct ieee80211vap *vap, 2296 const struct ieee80211req *ireq) 2297 { 2298 struct ieee80211com *ic = vap->iv_ic; 2299 struct ieee80211_channel chan, *c; 2300 int error; 2301 2302 if (ireq->i_len != sizeof(chan)) 2303 return EINVAL; 2304 error = copyin(ireq->i_data, &chan, sizeof(chan)); 2305 if (error != 0) 2306 return error; 2307 2308 /* XXX 0xffff overflows 16-bit signed */ 2309 if (chan.ic_freq == 0 || chan.ic_freq == IEEE80211_CHAN_ANY) { 2310 c = IEEE80211_CHAN_ANYC; 2311 } else { 2312 c = ieee80211_find_channel(ic, chan.ic_freq, chan.ic_flags); 2313 if (c == NULL) 2314 return EINVAL; 2315 } 2316 return setcurchan(vap, c); 2317 } 2318 2319 static int 2320 ieee80211_ioctl_setregdomain(struct ieee80211vap *vap, 2321 const struct ieee80211req *ireq) 2322 { 2323 struct ieee80211_regdomain_req *reg; 2324 int nchans, error; 2325 2326 nchans = 1 + ((ireq->i_len - sizeof(struct ieee80211_regdomain_req)) / 2327 sizeof(struct ieee80211_channel)); 2328 if (!(1 <= nchans && nchans <= IEEE80211_CHAN_MAX)) { 2329 IEEE80211_DPRINTF(vap, IEEE80211_MSG_IOCTL, 2330 "%s: bad # chans, i_len %d nchans %d\n", __func__, 2331 ireq->i_len, nchans); 2332 return EINVAL; 2333 } 2334 reg = (struct ieee80211_regdomain_req *) 2335 IEEE80211_MALLOC(IEEE80211_REGDOMAIN_SIZE(nchans), M_TEMP, 2336 IEEE80211_M_NOWAIT | IEEE80211_M_ZERO); 2337 if (reg == NULL) { 2338 IEEE80211_DPRINTF(vap, IEEE80211_MSG_IOCTL, 2339 "%s: no memory, nchans %d\n", __func__, nchans); 2340 return ENOMEM; 2341 } 2342 error = copyin(ireq->i_data, reg, IEEE80211_REGDOMAIN_SIZE(nchans)); 2343 if (error == 0) { 2344 /* NB: validate inline channel count against storage size */ 2345 if (reg->chaninfo.ic_nchans != nchans) { 2346 IEEE80211_DPRINTF(vap, IEEE80211_MSG_IOCTL, 2347 "%s: chan cnt mismatch, %d != %d\n", __func__, 2348 reg->chaninfo.ic_nchans, nchans); 2349 error = EINVAL; 2350 } else 2351 error = ieee80211_setregdomain(vap, reg); 2352 } 2353 IEEE80211_FREE(reg, M_TEMP); 2354 2355 return (error == 0 ? ENETRESET : error); 2356 } 2357 2358 static int 2359 ieee80211_ioctl_setroam(struct ieee80211vap *vap, 2360 const struct ieee80211req *ireq) 2361 { 2362 if (ireq->i_len != sizeof(vap->iv_roamparms)) 2363 return EINVAL; 2364 /* XXX validate params */ 2365 /* XXX? ENETRESET to push to device? */ 2366 return copyin(ireq->i_data, vap->iv_roamparms, 2367 sizeof(vap->iv_roamparms)); 2368 } 2369 2370 static int 2371 checkrate(const struct ieee80211_rateset *rs, int rate) 2372 { 2373 int i; 2374 2375 if (rate == IEEE80211_FIXED_RATE_NONE) 2376 return 1; 2377 for (i = 0; i < rs->rs_nrates; i++) 2378 if ((rs->rs_rates[i] & IEEE80211_RATE_VAL) == rate) 2379 return 1; 2380 return 0; 2381 } 2382 2383 static int 2384 checkmcs(const struct ieee80211_htrateset *rs, int mcs) 2385 { 2386 int rate_val = IEEE80211_RV(mcs); 2387 int i; 2388 2389 if (mcs == IEEE80211_FIXED_RATE_NONE) 2390 return 1; 2391 if ((mcs & IEEE80211_RATE_MCS) == 0) /* MCS always have 0x80 set */ 2392 return 0; 2393 for (i = 0; i < rs->rs_nrates; i++) 2394 if (IEEE80211_RV(rs->rs_rates[i]) == rate_val) 2395 return 1; 2396 return 0; 2397 } 2398 2399 static int 2400 ieee80211_ioctl_settxparams(struct ieee80211vap *vap, 2401 const struct ieee80211req *ireq) 2402 { 2403 struct ieee80211com *ic = vap->iv_ic; 2404 struct ieee80211_txparams_req parms; /* XXX stack use? */ 2405 struct ieee80211_txparam *src, *dst; 2406 const struct ieee80211_htrateset *rs_ht; 2407 const struct ieee80211_rateset *rs; 2408 int error, mode, changed, is11n, nmodes; 2409 2410 /* NB: accept short requests for backwards compat */ 2411 if (ireq->i_len > sizeof(parms)) 2412 return EINVAL; 2413 error = copyin(ireq->i_data, &parms, ireq->i_len); 2414 if (error != 0) 2415 return error; 2416 nmodes = ireq->i_len / sizeof(struct ieee80211_txparam); 2417 changed = 0; 2418 /* validate parameters and check if anything changed */ 2419 for (mode = IEEE80211_MODE_11A; mode < nmodes; mode++) { 2420 if (isclr(ic->ic_modecaps, mode)) 2421 continue; 2422 src = &parms.params[mode]; 2423 dst = &vap->iv_txparms[mode]; 2424 rs = &ic->ic_sup_rates[mode]; /* NB: 11n maps to legacy */ 2425 rs_ht = &ic->ic_sup_htrates; 2426 is11n = (mode == IEEE80211_MODE_11NA || 2427 mode == IEEE80211_MODE_11NG); 2428 if (src->ucastrate != dst->ucastrate) { 2429 if (!checkrate(rs, src->ucastrate) && 2430 (!is11n || !checkmcs(rs_ht, src->ucastrate))) 2431 return EINVAL; 2432 changed++; 2433 } 2434 if (src->mcastrate != dst->mcastrate) { 2435 if (!checkrate(rs, src->mcastrate) && 2436 (!is11n || !checkmcs(rs_ht, src->mcastrate))) 2437 return EINVAL; 2438 changed++; 2439 } 2440 if (src->mgmtrate != dst->mgmtrate) { 2441 if (!checkrate(rs, src->mgmtrate) && 2442 (!is11n || !checkmcs(rs_ht, src->mgmtrate))) 2443 return EINVAL; 2444 changed++; 2445 } 2446 if (src->maxretry != dst->maxretry) /* NB: no bounds */ 2447 changed++; 2448 } 2449 if (changed) { 2450 /* 2451 * Copy new parameters in place and notify the 2452 * driver so it can push state to the device. 2453 */ 2454 for (mode = IEEE80211_MODE_11A; mode < nmodes; mode++) { 2455 if (isset(ic->ic_modecaps, mode)) 2456 vap->iv_txparms[mode] = parms.params[mode]; 2457 } 2458 /* XXX could be more intelligent, 2459 e.g. don't reset if setting not being used */ 2460 return ENETRESET; 2461 } 2462 return 0; 2463 } 2464 2465 /* 2466 * Application Information Element support. 2467 */ 2468 static int 2469 setappie(struct ieee80211_appie **aie, const struct ieee80211req *ireq) 2470 { 2471 struct ieee80211_appie *app = *aie; 2472 struct ieee80211_appie *napp; 2473 int error; 2474 2475 if (ireq->i_len == 0) { /* delete any existing ie */ 2476 if (app != NULL) { 2477 *aie = NULL; /* XXX racey */ 2478 IEEE80211_FREE(app, M_80211_NODE_IE); 2479 } 2480 return 0; 2481 } 2482 if (!(2 <= ireq->i_len && ireq->i_len <= IEEE80211_MAX_APPIE)) 2483 return EINVAL; 2484 /* 2485 * Allocate a new appie structure and copy in the user data. 2486 * When done swap in the new structure. Note that we do not 2487 * guard against users holding a ref to the old structure; 2488 * this must be handled outside this code. 2489 * 2490 * XXX bad bad bad 2491 */ 2492 napp = (struct ieee80211_appie *) IEEE80211_MALLOC( 2493 sizeof(struct ieee80211_appie) + ireq->i_len, M_80211_NODE_IE, 2494 IEEE80211_M_NOWAIT); 2495 if (napp == NULL) 2496 return ENOMEM; 2497 /* XXX holding ic lock */ 2498 error = copyin(ireq->i_data, napp->ie_data, ireq->i_len); 2499 if (error) { 2500 IEEE80211_FREE(napp, M_80211_NODE_IE); 2501 return error; 2502 } 2503 napp->ie_len = ireq->i_len; 2504 *aie = napp; 2505 if (app != NULL) 2506 IEEE80211_FREE(app, M_80211_NODE_IE); 2507 return 0; 2508 } 2509 2510 static void 2511 setwparsnie(struct ieee80211vap *vap, uint8_t *ie, int space) 2512 { 2513 /* validate data is present as best we can */ 2514 if (space == 0 || 2+ie[1] > space) 2515 return; 2516 if (ie[0] == IEEE80211_ELEMID_VENDOR) 2517 vap->iv_wpa_ie = ie; 2518 else if (ie[0] == IEEE80211_ELEMID_RSN) 2519 vap->iv_rsn_ie = ie; 2520 } 2521 2522 static int 2523 ieee80211_ioctl_setappie_locked(struct ieee80211vap *vap, 2524 const struct ieee80211req *ireq, int fc0) 2525 { 2526 int error; 2527 2528 IEEE80211_LOCK_ASSERT(vap->iv_ic); 2529 2530 switch (fc0 & IEEE80211_FC0_SUBTYPE_MASK) { 2531 case IEEE80211_FC0_SUBTYPE_BEACON: 2532 if (vap->iv_opmode != IEEE80211_M_HOSTAP && 2533 vap->iv_opmode != IEEE80211_M_IBSS) { 2534 error = EINVAL; 2535 break; 2536 } 2537 error = setappie(&vap->iv_appie_beacon, ireq); 2538 if (error == 0) 2539 ieee80211_beacon_notify(vap, IEEE80211_BEACON_APPIE); 2540 break; 2541 case IEEE80211_FC0_SUBTYPE_PROBE_RESP: 2542 error = setappie(&vap->iv_appie_proberesp, ireq); 2543 break; 2544 case IEEE80211_FC0_SUBTYPE_ASSOC_RESP: 2545 if (vap->iv_opmode == IEEE80211_M_HOSTAP) 2546 error = setappie(&vap->iv_appie_assocresp, ireq); 2547 else 2548 error = EINVAL; 2549 break; 2550 case IEEE80211_FC0_SUBTYPE_PROBE_REQ: 2551 error = setappie(&vap->iv_appie_probereq, ireq); 2552 break; 2553 case IEEE80211_FC0_SUBTYPE_ASSOC_REQ: 2554 if (vap->iv_opmode == IEEE80211_M_STA) 2555 error = setappie(&vap->iv_appie_assocreq, ireq); 2556 else 2557 error = EINVAL; 2558 break; 2559 case (IEEE80211_APPIE_WPA & IEEE80211_FC0_SUBTYPE_MASK): 2560 error = setappie(&vap->iv_appie_wpa, ireq); 2561 if (error == 0) { 2562 /* 2563 * Must split single blob of data into separate 2564 * WPA and RSN ie's because they go in different 2565 * locations in the mgt frames. 2566 * XXX use IEEE80211_IOC_WPA2 so user code does split 2567 */ 2568 vap->iv_wpa_ie = NULL; 2569 vap->iv_rsn_ie = NULL; 2570 if (vap->iv_appie_wpa != NULL) { 2571 struct ieee80211_appie *appie = 2572 vap->iv_appie_wpa; 2573 uint8_t *data = appie->ie_data; 2574 2575 /* XXX ie length validate is painful, cheat */ 2576 setwparsnie(vap, data, appie->ie_len); 2577 setwparsnie(vap, data + 2 + data[1], 2578 appie->ie_len - (2 + data[1])); 2579 } 2580 if (vap->iv_opmode == IEEE80211_M_HOSTAP || 2581 vap->iv_opmode == IEEE80211_M_IBSS) { 2582 /* 2583 * Must rebuild beacon frame as the update 2584 * mechanism doesn't handle WPA/RSN ie's. 2585 * Could extend it but it doesn't normally 2586 * change; this is just to deal with hostapd 2587 * plumbing the ie after the interface is up. 2588 */ 2589 error = ENETRESET; 2590 } 2591 } 2592 break; 2593 default: 2594 error = EINVAL; 2595 break; 2596 } 2597 return error; 2598 } 2599 2600 static int 2601 ieee80211_ioctl_setappie(struct ieee80211vap *vap, 2602 const struct ieee80211req *ireq) 2603 { 2604 struct ieee80211com *ic = vap->iv_ic; 2605 int error; 2606 uint8_t fc0; 2607 2608 fc0 = ireq->i_val & 0xff; 2609 if ((fc0 & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_MGT) 2610 return EINVAL; 2611 /* NB: could check iv_opmode and reject but hardly worth the effort */ 2612 IEEE80211_LOCK(ic); 2613 error = ieee80211_ioctl_setappie_locked(vap, ireq, fc0); 2614 IEEE80211_UNLOCK(ic); 2615 return error; 2616 } 2617 2618 static int 2619 ieee80211_ioctl_chanswitch(struct ieee80211vap *vap, struct ieee80211req *ireq) 2620 { 2621 struct ieee80211com *ic = vap->iv_ic; 2622 struct ieee80211_chanswitch_req csr; 2623 struct ieee80211_channel *c; 2624 int error; 2625 2626 if (ireq->i_len != sizeof(csr)) 2627 return EINVAL; 2628 error = copyin(ireq->i_data, &csr, sizeof(csr)); 2629 if (error != 0) 2630 return error; 2631 /* XXX adhoc mode not supported */ 2632 if (vap->iv_opmode != IEEE80211_M_HOSTAP || 2633 (vap->iv_flags & IEEE80211_F_DOTH) == 0) 2634 return EOPNOTSUPP; 2635 c = ieee80211_find_channel(ic, 2636 csr.csa_chan.ic_freq, csr.csa_chan.ic_flags); 2637 if (c == NULL) 2638 return ENOENT; 2639 IEEE80211_LOCK(ic); 2640 if ((ic->ic_flags & IEEE80211_F_CSAPENDING) == 0) 2641 ieee80211_csa_startswitch(ic, c, csr.csa_mode, csr.csa_count); 2642 else if (csr.csa_count == 0) 2643 ieee80211_csa_cancelswitch(ic); 2644 else 2645 error = EBUSY; 2646 IEEE80211_UNLOCK(ic); 2647 return error; 2648 } 2649 2650 static int 2651 ieee80211_scanreq(struct ieee80211vap *vap, struct ieee80211_scan_req *sr) 2652 { 2653 #define IEEE80211_IOC_SCAN_FLAGS \ 2654 (IEEE80211_IOC_SCAN_NOPICK | IEEE80211_IOC_SCAN_ACTIVE | \ 2655 IEEE80211_IOC_SCAN_PICK1ST | IEEE80211_IOC_SCAN_BGSCAN | \ 2656 IEEE80211_IOC_SCAN_ONCE | IEEE80211_IOC_SCAN_NOBCAST | \ 2657 IEEE80211_IOC_SCAN_NOJOIN | IEEE80211_IOC_SCAN_FLUSH | \ 2658 IEEE80211_IOC_SCAN_CHECK) 2659 struct ieee80211com *ic = vap->iv_ic; 2660 int error, i; 2661 2662 /* convert duration */ 2663 if (sr->sr_duration == IEEE80211_IOC_SCAN_FOREVER) 2664 sr->sr_duration = IEEE80211_SCAN_FOREVER; 2665 else { 2666 if (sr->sr_duration < IEEE80211_IOC_SCAN_DURATION_MIN || 2667 sr->sr_duration > IEEE80211_IOC_SCAN_DURATION_MAX) 2668 return EINVAL; 2669 sr->sr_duration = msecs_to_ticks(sr->sr_duration); 2670 if (sr->sr_duration < 1) 2671 sr->sr_duration = 1; 2672 } 2673 /* convert min/max channel dwell */ 2674 if (sr->sr_mindwell != 0) { 2675 sr->sr_mindwell = msecs_to_ticks(sr->sr_mindwell); 2676 if (sr->sr_mindwell < 1) 2677 sr->sr_mindwell = 1; 2678 } 2679 if (sr->sr_maxdwell != 0) { 2680 sr->sr_maxdwell = msecs_to_ticks(sr->sr_maxdwell); 2681 if (sr->sr_maxdwell < 1) 2682 sr->sr_maxdwell = 1; 2683 } 2684 /* NB: silently reduce ssid count to what is supported */ 2685 if (sr->sr_nssid > IEEE80211_SCAN_MAX_SSID) 2686 sr->sr_nssid = IEEE80211_SCAN_MAX_SSID; 2687 for (i = 0; i < sr->sr_nssid; i++) 2688 if (sr->sr_ssid[i].len > IEEE80211_NWID_LEN) 2689 return EINVAL; 2690 /* cleanse flags just in case, could reject if invalid flags */ 2691 sr->sr_flags &= IEEE80211_IOC_SCAN_FLAGS; 2692 /* 2693 * Add an implicit NOPICK if the vap is not marked UP. This 2694 * allows applications to scan without joining a bss (or picking 2695 * a channel and setting up a bss) and without forcing manual 2696 * roaming mode--you just need to mark the parent device UP. 2697 */ 2698 if ((vap->iv_ifp->if_flags & IFF_UP) == 0) 2699 sr->sr_flags |= IEEE80211_IOC_SCAN_NOPICK; 2700 2701 IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, 2702 "%s: flags 0x%x%s duration 0x%x mindwell %u maxdwell %u nssid %d\n", 2703 __func__, sr->sr_flags, 2704 (vap->iv_ifp->if_flags & IFF_UP) == 0 ? " (!IFF_UP)" : "", 2705 sr->sr_duration, sr->sr_mindwell, sr->sr_maxdwell, sr->sr_nssid); 2706 /* 2707 * If we are in INIT state then the driver has never had a chance 2708 * to setup hardware state to do a scan; we must use the state 2709 * machine to get us up to the SCAN state but once we reach SCAN 2710 * state we then want to use the supplied params. Stash the 2711 * parameters in the vap and mark IEEE80211_FEXT_SCANREQ; the 2712 * state machines will recognize this and use the stashed params 2713 * to issue the scan request. 2714 * 2715 * Otherwise just invoke the scan machinery directly. 2716 */ 2717 IEEE80211_LOCK(ic); 2718 if (ic->ic_nrunning == 0) { 2719 IEEE80211_UNLOCK(ic); 2720 return ENXIO; 2721 } 2722 2723 if (vap->iv_state == IEEE80211_S_INIT) { 2724 /* NB: clobbers previous settings */ 2725 vap->iv_scanreq_flags = sr->sr_flags; 2726 vap->iv_scanreq_duration = sr->sr_duration; 2727 vap->iv_scanreq_nssid = sr->sr_nssid; 2728 for (i = 0; i < sr->sr_nssid; i++) { 2729 vap->iv_scanreq_ssid[i].len = sr->sr_ssid[i].len; 2730 memcpy(vap->iv_scanreq_ssid[i].ssid, 2731 sr->sr_ssid[i].ssid, sr->sr_ssid[i].len); 2732 } 2733 vap->iv_flags_ext |= IEEE80211_FEXT_SCANREQ; 2734 IEEE80211_UNLOCK(ic); 2735 ieee80211_new_state(vap, IEEE80211_S_SCAN, 0); 2736 } else { 2737 vap->iv_flags_ext &= ~IEEE80211_FEXT_SCANREQ; 2738 IEEE80211_UNLOCK(ic); 2739 if (sr->sr_flags & IEEE80211_IOC_SCAN_CHECK) { 2740 error = ieee80211_check_scan(vap, sr->sr_flags, 2741 sr->sr_duration, sr->sr_mindwell, sr->sr_maxdwell, 2742 sr->sr_nssid, 2743 /* NB: cheat, we assume structures are compatible */ 2744 (const struct ieee80211_scan_ssid *) &sr->sr_ssid[0]); 2745 } else { 2746 error = ieee80211_start_scan(vap, sr->sr_flags, 2747 sr->sr_duration, sr->sr_mindwell, sr->sr_maxdwell, 2748 sr->sr_nssid, 2749 /* NB: cheat, we assume structures are compatible */ 2750 (const struct ieee80211_scan_ssid *) &sr->sr_ssid[0]); 2751 } 2752 if (error == 0) 2753 return EINPROGRESS; 2754 } 2755 return 0; 2756 #undef IEEE80211_IOC_SCAN_FLAGS 2757 } 2758 2759 static int 2760 ieee80211_ioctl_scanreq(struct ieee80211vap *vap, struct ieee80211req *ireq) 2761 { 2762 struct ieee80211_scan_req *sr; 2763 int error; 2764 2765 if (ireq->i_len != sizeof(*sr)) 2766 return EINVAL; 2767 sr = IEEE80211_MALLOC(sizeof(*sr), M_TEMP, 2768 IEEE80211_M_NOWAIT | IEEE80211_M_ZERO); 2769 if (sr == NULL) 2770 return ENOMEM; 2771 error = copyin(ireq->i_data, sr, sizeof(*sr)); 2772 if (error != 0) 2773 goto bad; 2774 error = ieee80211_scanreq(vap, sr); 2775 bad: 2776 IEEE80211_FREE(sr, M_TEMP); 2777 return error; 2778 } 2779 2780 static int 2781 ieee80211_ioctl_setstavlan(struct ieee80211vap *vap, struct ieee80211req *ireq) 2782 { 2783 struct ieee80211_node *ni; 2784 struct ieee80211req_sta_vlan vlan; 2785 int error; 2786 2787 if (ireq->i_len != sizeof(vlan)) 2788 return EINVAL; 2789 error = copyin(ireq->i_data, &vlan, sizeof(vlan)); 2790 if (error != 0) 2791 return error; 2792 if (!IEEE80211_ADDR_EQ(vlan.sv_macaddr, zerobssid)) { 2793 ni = ieee80211_find_vap_node(&vap->iv_ic->ic_sta, vap, 2794 vlan.sv_macaddr); 2795 if (ni == NULL) 2796 return ENOENT; 2797 } else 2798 ni = ieee80211_ref_node(vap->iv_bss); 2799 ni->ni_vlan = vlan.sv_vlan; 2800 ieee80211_free_node(ni); 2801 return error; 2802 } 2803 2804 static int 2805 isvap11g(const struct ieee80211vap *vap) 2806 { 2807 const struct ieee80211_node *bss = vap->iv_bss; 2808 return bss->ni_chan != IEEE80211_CHAN_ANYC && 2809 IEEE80211_IS_CHAN_ANYG(bss->ni_chan); 2810 } 2811 2812 static int 2813 isvapht(const struct ieee80211vap *vap) 2814 { 2815 const struct ieee80211_node *bss = vap->iv_bss; 2816 return bss->ni_chan != IEEE80211_CHAN_ANYC && 2817 IEEE80211_IS_CHAN_HT(bss->ni_chan); 2818 } 2819 2820 /* 2821 * Dummy ioctl set handler so the linker set is defined. 2822 */ 2823 static __unused int 2824 dummy_ioctl_set(struct ieee80211vap *vap, struct ieee80211req *ireq) 2825 { 2826 return ENOSYS; 2827 } 2828 IEEE80211_IOCTL_SET(dummy, dummy_ioctl_set); 2829 2830 static int 2831 ieee80211_ioctl_setdefault(struct ieee80211vap *vap, struct ieee80211req *ireq) 2832 { 2833 #ifdef notyet 2834 ieee80211_ioctl_setfunc * const *set; 2835 int error; 2836 2837 SET_FOREACH(set, ieee80211_ioctl_setset) { 2838 error = (*set)(vap, ireq); 2839 if (error != ENOSYS) 2840 return error; 2841 } 2842 #else 2843 printf ("ieee80211_ioctl_setdefault called\n"); 2844 #endif 2845 return EINVAL; 2846 } 2847 2848 static int 2849 ieee80211_ioctl_set80211(struct ieee80211vap *vap, u_long cmd, struct ieee80211req *ireq) 2850 { 2851 struct ieee80211com *ic = vap->iv_ic; 2852 int error; 2853 const struct ieee80211_authenticator *auth; 2854 uint8_t tmpkey[IEEE80211_KEYBUF_SIZE]; 2855 char tmpssid[IEEE80211_NWID_LEN]; 2856 uint8_t tmpbssid[IEEE80211_ADDR_LEN]; 2857 struct ieee80211_key *k; 2858 u_int kid; 2859 uint32_t flags; 2860 2861 error = 0; 2862 switch (ireq->i_type) { 2863 case IEEE80211_IOC_SSID: 2864 if (ireq->i_val != 0 || 2865 ireq->i_len > IEEE80211_NWID_LEN) 2866 return EINVAL; 2867 error = copyin(ireq->i_data, tmpssid, ireq->i_len); 2868 if (error) 2869 break; 2870 memset(vap->iv_des_ssid[0].ssid, 0, IEEE80211_NWID_LEN); 2871 vap->iv_des_ssid[0].len = ireq->i_len; 2872 memcpy(vap->iv_des_ssid[0].ssid, tmpssid, ireq->i_len); 2873 vap->iv_des_nssid = (ireq->i_len > 0); 2874 error = ENETRESET; 2875 break; 2876 case IEEE80211_IOC_WEP: 2877 switch (ireq->i_val) { 2878 case IEEE80211_WEP_OFF: 2879 vap->iv_flags &= ~IEEE80211_F_PRIVACY; 2880 vap->iv_flags &= ~IEEE80211_F_DROPUNENC; 2881 break; 2882 case IEEE80211_WEP_ON: 2883 vap->iv_flags |= IEEE80211_F_PRIVACY; 2884 vap->iv_flags |= IEEE80211_F_DROPUNENC; 2885 break; 2886 case IEEE80211_WEP_MIXED: 2887 vap->iv_flags |= IEEE80211_F_PRIVACY; 2888 vap->iv_flags &= ~IEEE80211_F_DROPUNENC; 2889 break; 2890 } 2891 error = ENETRESET; 2892 break; 2893 case IEEE80211_IOC_WEPKEY: 2894 kid = (u_int) ireq->i_val; 2895 if (kid >= IEEE80211_WEP_NKID) 2896 return EINVAL; 2897 k = &vap->iv_nw_keys[kid]; 2898 if (ireq->i_len == 0) { 2899 /* zero-len =>'s delete any existing key */ 2900 (void) ieee80211_crypto_delkey(vap, k); 2901 break; 2902 } 2903 if (ireq->i_len > sizeof(tmpkey)) 2904 return EINVAL; 2905 memset(tmpkey, 0, sizeof(tmpkey)); 2906 error = copyin(ireq->i_data, tmpkey, ireq->i_len); 2907 if (error) 2908 break; 2909 ieee80211_key_update_begin(vap); 2910 k->wk_keyix = kid; /* NB: force fixed key id */ 2911 if (ieee80211_crypto_newkey(vap, IEEE80211_CIPHER_WEP, 2912 IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV, k)) { 2913 k->wk_keylen = ireq->i_len; 2914 memcpy(k->wk_key, tmpkey, sizeof(tmpkey)); 2915 IEEE80211_ADDR_COPY(k->wk_macaddr, vap->iv_myaddr); 2916 if (!ieee80211_crypto_setkey(vap, k)) 2917 error = EINVAL; 2918 } else 2919 error = EINVAL; 2920 ieee80211_key_update_end(vap); 2921 break; 2922 case IEEE80211_IOC_WEPTXKEY: 2923 kid = (u_int) ireq->i_val; 2924 if (kid >= IEEE80211_WEP_NKID && 2925 (uint16_t) kid != IEEE80211_KEYIX_NONE) 2926 return EINVAL; 2927 /* 2928 * Firmware devices may need to be told about an explicit 2929 * key index here, versus just inferring it from the 2930 * key set / change. Since we may also need to pause 2931 * things like transmit before the key is updated, 2932 * give the driver a chance to flush things by tying 2933 * into key update begin/end. 2934 */ 2935 ieee80211_key_update_begin(vap); 2936 ieee80211_crypto_set_deftxkey(vap, kid); 2937 ieee80211_key_update_end(vap); 2938 break; 2939 case IEEE80211_IOC_AUTHMODE: 2940 switch (ireq->i_val) { 2941 case IEEE80211_AUTH_WPA: 2942 case IEEE80211_AUTH_8021X: /* 802.1x */ 2943 case IEEE80211_AUTH_OPEN: /* open */ 2944 case IEEE80211_AUTH_SHARED: /* shared-key */ 2945 case IEEE80211_AUTH_AUTO: /* auto */ 2946 auth = ieee80211_authenticator_get(ireq->i_val); 2947 if (auth == NULL) 2948 return EINVAL; 2949 break; 2950 default: 2951 return EINVAL; 2952 } 2953 switch (ireq->i_val) { 2954 case IEEE80211_AUTH_WPA: /* WPA w/ 802.1x */ 2955 vap->iv_flags |= IEEE80211_F_PRIVACY; 2956 ireq->i_val = IEEE80211_AUTH_8021X; 2957 break; 2958 case IEEE80211_AUTH_OPEN: /* open */ 2959 vap->iv_flags &= ~(IEEE80211_F_WPA|IEEE80211_F_PRIVACY); 2960 break; 2961 case IEEE80211_AUTH_SHARED: /* shared-key */ 2962 case IEEE80211_AUTH_8021X: /* 802.1x */ 2963 vap->iv_flags &= ~IEEE80211_F_WPA; 2964 /* both require a key so mark the PRIVACY capability */ 2965 vap->iv_flags |= IEEE80211_F_PRIVACY; 2966 break; 2967 case IEEE80211_AUTH_AUTO: /* auto */ 2968 vap->iv_flags &= ~IEEE80211_F_WPA; 2969 /* XXX PRIVACY handling? */ 2970 /* XXX what's the right way to do this? */ 2971 break; 2972 } 2973 /* NB: authenticator attach/detach happens on state change */ 2974 vap->iv_bss->ni_authmode = ireq->i_val; 2975 /* XXX mixed/mode/usage? */ 2976 vap->iv_auth = auth; 2977 error = ENETRESET; 2978 break; 2979 case IEEE80211_IOC_CHANNEL: 2980 error = ieee80211_ioctl_setchannel(vap, ireq); 2981 break; 2982 case IEEE80211_IOC_POWERSAVE: 2983 switch (ireq->i_val) { 2984 case IEEE80211_POWERSAVE_OFF: 2985 if (vap->iv_flags & IEEE80211_F_PMGTON) { 2986 ieee80211_syncflag(vap, -IEEE80211_F_PMGTON); 2987 error = ERESTART; 2988 } 2989 break; 2990 case IEEE80211_POWERSAVE_ON: 2991 if ((vap->iv_caps & IEEE80211_C_PMGT) == 0) 2992 error = EOPNOTSUPP; 2993 else if ((vap->iv_flags & IEEE80211_F_PMGTON) == 0) { 2994 ieee80211_syncflag(vap, IEEE80211_F_PMGTON); 2995 error = ERESTART; 2996 } 2997 break; 2998 default: 2999 error = EINVAL; 3000 break; 3001 } 3002 break; 3003 case IEEE80211_IOC_POWERSAVESLEEP: 3004 if (ireq->i_val < 0) 3005 return EINVAL; 3006 ic->ic_lintval = ireq->i_val; 3007 error = ERESTART; 3008 break; 3009 case IEEE80211_IOC_RTSTHRESHOLD: 3010 if (!(IEEE80211_RTS_MIN <= ireq->i_val && 3011 ireq->i_val <= IEEE80211_RTS_MAX)) 3012 return EINVAL; 3013 vap->iv_rtsthreshold = ireq->i_val; 3014 error = ERESTART; 3015 break; 3016 case IEEE80211_IOC_PROTMODE: 3017 if (ireq->i_val > IEEE80211_PROT_RTSCTS) 3018 return EINVAL; 3019 ic->ic_protmode = (enum ieee80211_protmode)ireq->i_val; 3020 /* NB: if not operating in 11g this can wait */ 3021 if (ic->ic_bsschan != IEEE80211_CHAN_ANYC && 3022 IEEE80211_IS_CHAN_ANYG(ic->ic_bsschan)) 3023 error = ERESTART; 3024 break; 3025 case IEEE80211_IOC_TXPOWER: 3026 if ((ic->ic_caps & IEEE80211_C_TXPMGT) == 0) 3027 return EOPNOTSUPP; 3028 if (!(IEEE80211_TXPOWER_MIN <= ireq->i_val && 3029 ireq->i_val <= IEEE80211_TXPOWER_MAX)) 3030 return EINVAL; 3031 ic->ic_txpowlimit = ireq->i_val; 3032 error = ERESTART; 3033 break; 3034 case IEEE80211_IOC_ROAMING: 3035 if (!(IEEE80211_ROAMING_DEVICE <= ireq->i_val && 3036 ireq->i_val <= IEEE80211_ROAMING_MANUAL)) 3037 return EINVAL; 3038 vap->iv_roaming = (enum ieee80211_roamingmode)ireq->i_val; 3039 /* XXXX reset? */ 3040 break; 3041 case IEEE80211_IOC_PRIVACY: 3042 if (ireq->i_val) { 3043 /* XXX check for key state? */ 3044 vap->iv_flags |= IEEE80211_F_PRIVACY; 3045 } else 3046 vap->iv_flags &= ~IEEE80211_F_PRIVACY; 3047 /* XXX ERESTART? */ 3048 break; 3049 case IEEE80211_IOC_DROPUNENCRYPTED: 3050 if (ireq->i_val) 3051 vap->iv_flags |= IEEE80211_F_DROPUNENC; 3052 else 3053 vap->iv_flags &= ~IEEE80211_F_DROPUNENC; 3054 /* XXX ERESTART? */ 3055 break; 3056 case IEEE80211_IOC_WPAKEY: 3057 error = ieee80211_ioctl_setkey(vap, ireq); 3058 break; 3059 case IEEE80211_IOC_DELKEY: 3060 error = ieee80211_ioctl_delkey(vap, ireq); 3061 break; 3062 case IEEE80211_IOC_MLME: 3063 error = ieee80211_ioctl_setmlme(vap, ireq); 3064 break; 3065 case IEEE80211_IOC_COUNTERMEASURES: 3066 if (ireq->i_val) { 3067 if ((vap->iv_flags & IEEE80211_F_WPA) == 0) 3068 return EOPNOTSUPP; 3069 vap->iv_flags |= IEEE80211_F_COUNTERM; 3070 } else 3071 vap->iv_flags &= ~IEEE80211_F_COUNTERM; 3072 /* XXX ERESTART? */ 3073 break; 3074 case IEEE80211_IOC_WPA: 3075 if (ireq->i_val > 3) 3076 return EINVAL; 3077 /* XXX verify ciphers available */ 3078 flags = vap->iv_flags & ~IEEE80211_F_WPA; 3079 switch (ireq->i_val) { 3080 case 0: 3081 /* wpa_supplicant calls this to clear the WPA config */ 3082 break; 3083 case 1: 3084 if (!(vap->iv_caps & IEEE80211_C_WPA1)) 3085 return EOPNOTSUPP; 3086 flags |= IEEE80211_F_WPA1; 3087 break; 3088 case 2: 3089 if (!(vap->iv_caps & IEEE80211_C_WPA2)) 3090 return EOPNOTSUPP; 3091 flags |= IEEE80211_F_WPA2; 3092 break; 3093 case 3: 3094 if ((vap->iv_caps & IEEE80211_C_WPA) != IEEE80211_C_WPA) 3095 return EOPNOTSUPP; 3096 flags |= IEEE80211_F_WPA1 | IEEE80211_F_WPA2; 3097 break; 3098 default: /* Can't set any -> error */ 3099 return EOPNOTSUPP; 3100 } 3101 vap->iv_flags = flags; 3102 error = ERESTART; /* NB: can change beacon frame */ 3103 break; 3104 case IEEE80211_IOC_WME: 3105 if (ireq->i_val) { 3106 if ((vap->iv_caps & IEEE80211_C_WME) == 0) 3107 return EOPNOTSUPP; 3108 ieee80211_syncflag(vap, IEEE80211_F_WME); 3109 } else 3110 ieee80211_syncflag(vap, -IEEE80211_F_WME); 3111 error = ERESTART; /* NB: can change beacon frame */ 3112 break; 3113 case IEEE80211_IOC_HIDESSID: 3114 if (ireq->i_val) 3115 vap->iv_flags |= IEEE80211_F_HIDESSID; 3116 else 3117 vap->iv_flags &= ~IEEE80211_F_HIDESSID; 3118 error = ERESTART; /* XXX ENETRESET? */ 3119 break; 3120 case IEEE80211_IOC_APBRIDGE: 3121 if (ireq->i_val == 0) 3122 vap->iv_flags |= IEEE80211_F_NOBRIDGE; 3123 else 3124 vap->iv_flags &= ~IEEE80211_F_NOBRIDGE; 3125 break; 3126 case IEEE80211_IOC_BSSID: 3127 if (ireq->i_len != sizeof(tmpbssid)) 3128 return EINVAL; 3129 error = copyin(ireq->i_data, tmpbssid, ireq->i_len); 3130 if (error) 3131 break; 3132 IEEE80211_ADDR_COPY(vap->iv_des_bssid, tmpbssid); 3133 if (IEEE80211_ADDR_EQ(vap->iv_des_bssid, zerobssid)) 3134 vap->iv_flags &= ~IEEE80211_F_DESBSSID; 3135 else 3136 vap->iv_flags |= IEEE80211_F_DESBSSID; 3137 error = ENETRESET; 3138 break; 3139 case IEEE80211_IOC_CHANLIST: 3140 error = ieee80211_ioctl_setchanlist(vap, ireq); 3141 break; 3142 #ifdef OLD_IEEE80211_IOC_SCAN_REQ 3143 case OLD_IEEE80211_IOC_SCAN_REQ: 3144 IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, 3145 "%s: active scan request\n", __func__); 3146 printf ("old scan req\n"); 3147 /* 3148 * If we are in INIT state then the driver has never 3149 * had a chance to setup hardware state to do a scan; 3150 * use the state machine to get us up the SCAN state. 3151 * Otherwise just invoke the scan machinery to start 3152 * a one-time scan. 3153 */ 3154 if (vap->iv_state == IEEE80211_S_INIT) 3155 { printf ("calling new_state\n"); 3156 ieee80211_new_state(vap, IEEE80211_S_SCAN, 0); 3157 } 3158 else 3159 { printf("calling _start_scan()\n"); 3160 (void) ieee80211_start_scan(vap, 3161 IEEE80211_SCAN_ACTIVE | 3162 IEEE80211_SCAN_NOPICK | 3163 IEEE80211_SCAN_ONCE, 3164 IEEE80211_SCAN_FOREVER, 0, 0, 3165 /* XXX use ioctl params */ 3166 vap->iv_des_nssid, vap->iv_des_ssid); 3167 } 3168 break; 3169 #endif /* OLD_IEEE80211_IOC_SCAN_REQ */ 3170 case IEEE80211_IOC_SCAN_REQ: 3171 error = ieee80211_ioctl_scanreq(vap, ireq); 3172 break; 3173 case IEEE80211_IOC_SCAN_CANCEL: 3174 IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, 3175 "%s: cancel scan\n", __func__); 3176 #if __NetBSD__ 3177 /* Bug in FreeBSD? */ 3178 IEEE80211_LOCK(ic); 3179 #endif 3180 ieee80211_cancel_scan(vap); 3181 #if __NetBSD__ 3182 IEEE80211_UNLOCK(ic); 3183 #endif 3184 break; 3185 case IEEE80211_IOC_HTCONF: 3186 if (ireq->i_val & 1) 3187 ieee80211_syncflag_ht(vap, IEEE80211_FHT_HT); 3188 else 3189 ieee80211_syncflag_ht(vap, -IEEE80211_FHT_HT); 3190 if (ireq->i_val & 2) 3191 ieee80211_syncflag_ht(vap, IEEE80211_FHT_USEHT40); 3192 else 3193 ieee80211_syncflag_ht(vap, -IEEE80211_FHT_USEHT40); 3194 error = ENETRESET; 3195 break; 3196 case IEEE80211_IOC_ADDMAC: 3197 case IEEE80211_IOC_DELMAC: 3198 error = ieee80211_ioctl_macmac(vap, ireq); 3199 break; 3200 case IEEE80211_IOC_MACCMD: 3201 error = ieee80211_ioctl_setmaccmd(vap, ireq); 3202 break; 3203 case IEEE80211_IOC_STA_STATS: 3204 error = ieee80211_ioctl_setstastats(vap, ireq); 3205 break; 3206 case IEEE80211_IOC_STA_TXPOW: 3207 error = ieee80211_ioctl_setstatxpow(vap, ireq); 3208 break; 3209 case IEEE80211_IOC_WME_CWMIN: /* WME: CWmin */ 3210 case IEEE80211_IOC_WME_CWMAX: /* WME: CWmax */ 3211 case IEEE80211_IOC_WME_AIFS: /* WME: AIFS */ 3212 case IEEE80211_IOC_WME_TXOPLIMIT: /* WME: txops limit */ 3213 case IEEE80211_IOC_WME_ACM: /* WME: ACM (bss only) */ 3214 case IEEE80211_IOC_WME_ACKPOLICY: /* WME: ACK policy (!bss only) */ 3215 error = ieee80211_ioctl_setwmeparam(vap, ireq); 3216 break; 3217 case IEEE80211_IOC_DTIM_PERIOD: 3218 if (vap->iv_opmode != IEEE80211_M_HOSTAP && 3219 vap->iv_opmode != IEEE80211_M_MBSS && 3220 vap->iv_opmode != IEEE80211_M_IBSS) 3221 return EINVAL; 3222 if (IEEE80211_DTIM_MIN <= ireq->i_val && 3223 ireq->i_val <= IEEE80211_DTIM_MAX) { 3224 vap->iv_dtim_period = ireq->i_val; 3225 error = ENETRESET; /* requires restart */ 3226 } else 3227 error = EINVAL; 3228 break; 3229 case IEEE80211_IOC_BEACON_INTERVAL: 3230 if (vap->iv_opmode != IEEE80211_M_HOSTAP && 3231 vap->iv_opmode != IEEE80211_M_MBSS && 3232 vap->iv_opmode != IEEE80211_M_IBSS) 3233 return EINVAL; 3234 if (IEEE80211_BINTVAL_MIN <= ireq->i_val && 3235 ireq->i_val <= IEEE80211_BINTVAL_MAX) { 3236 ic->ic_bintval = ireq->i_val; 3237 error = ENETRESET; /* requires restart */ 3238 } else 3239 error = EINVAL; 3240 break; 3241 case IEEE80211_IOC_PUREG: 3242 if (ireq->i_val) 3243 vap->iv_flags |= IEEE80211_F_PUREG; 3244 else 3245 vap->iv_flags &= ~IEEE80211_F_PUREG; 3246 /* NB: reset only if we're operating on an 11g channel */ 3247 if (isvap11g(vap)) 3248 error = ENETRESET; 3249 break; 3250 case IEEE80211_IOC_QUIET: 3251 vap->iv_quiet= ireq->i_val; 3252 break; 3253 case IEEE80211_IOC_QUIET_COUNT: 3254 vap->iv_quiet_count=ireq->i_val; 3255 break; 3256 case IEEE80211_IOC_QUIET_PERIOD: 3257 vap->iv_quiet_period=ireq->i_val; 3258 break; 3259 case IEEE80211_IOC_QUIET_OFFSET: 3260 vap->iv_quiet_offset=ireq->i_val; 3261 break; 3262 case IEEE80211_IOC_QUIET_DUR: 3263 if(ireq->i_val < vap->iv_bss->ni_intval) 3264 vap->iv_quiet_duration = ireq->i_val; 3265 else 3266 error = EINVAL; 3267 break; 3268 case IEEE80211_IOC_BGSCAN: 3269 if (ireq->i_val) { 3270 if ((vap->iv_caps & IEEE80211_C_BGSCAN) == 0) 3271 return EOPNOTSUPP; 3272 vap->iv_flags |= IEEE80211_F_BGSCAN; 3273 } else 3274 vap->iv_flags &= ~IEEE80211_F_BGSCAN; 3275 break; 3276 case IEEE80211_IOC_BGSCAN_IDLE: 3277 if (ireq->i_val >= IEEE80211_BGSCAN_IDLE_MIN) 3278 vap->iv_bgscanidle = ireq->i_val*hz/1000; 3279 else 3280 error = EINVAL; 3281 break; 3282 case IEEE80211_IOC_BGSCAN_INTERVAL: 3283 if (ireq->i_val >= IEEE80211_BGSCAN_INTVAL_MIN) 3284 vap->iv_bgscanintvl = ireq->i_val*hz; 3285 else 3286 error = EINVAL; 3287 break; 3288 case IEEE80211_IOC_SCANVALID: 3289 if (ireq->i_val >= IEEE80211_SCAN_VALID_MIN) 3290 vap->iv_scanvalid = ireq->i_val*hz; 3291 else 3292 error = EINVAL; 3293 break; 3294 case IEEE80211_IOC_FRAGTHRESHOLD: 3295 if ((vap->iv_caps & IEEE80211_C_TXFRAG) == 0 && 3296 ireq->i_val != IEEE80211_FRAG_MAX) 3297 return EOPNOTSUPP; 3298 if (!(IEEE80211_FRAG_MIN <= ireq->i_val && 3299 ireq->i_val <= IEEE80211_FRAG_MAX)) 3300 return EINVAL; 3301 vap->iv_fragthreshold = ireq->i_val; 3302 error = ERESTART; 3303 break; 3304 case IEEE80211_IOC_BURST: 3305 if (ireq->i_val) { 3306 if ((vap->iv_caps & IEEE80211_C_BURST) == 0) 3307 return EOPNOTSUPP; 3308 ieee80211_syncflag(vap, IEEE80211_F_BURST); 3309 } else 3310 ieee80211_syncflag(vap, -IEEE80211_F_BURST); 3311 error = ERESTART; 3312 break; 3313 case IEEE80211_IOC_BMISSTHRESHOLD: 3314 if (!(IEEE80211_HWBMISS_MIN <= ireq->i_val && 3315 ireq->i_val <= IEEE80211_HWBMISS_MAX)) 3316 return EINVAL; 3317 vap->iv_bmissthreshold = ireq->i_val; 3318 error = ERESTART; 3319 break; 3320 case IEEE80211_IOC_CURCHAN: 3321 error = ieee80211_ioctl_setcurchan(vap, ireq); 3322 break; 3323 case IEEE80211_IOC_SHORTGI: 3324 if (ireq->i_val) { 3325 #define IEEE80211_HTCAP_SHORTGI \ 3326 (IEEE80211_HTCAP_SHORTGI20 | IEEE80211_HTCAP_SHORTGI40) 3327 if (((ireq->i_val ^ vap->iv_htcaps) & IEEE80211_HTCAP_SHORTGI) != 0) 3328 return EINVAL; 3329 if (ireq->i_val & IEEE80211_HTCAP_SHORTGI20) 3330 vap->iv_flags_ht |= IEEE80211_FHT_SHORTGI20; 3331 if (ireq->i_val & IEEE80211_HTCAP_SHORTGI40) 3332 vap->iv_flags_ht |= IEEE80211_FHT_SHORTGI40; 3333 #undef IEEE80211_HTCAP_SHORTGI 3334 } else 3335 vap->iv_flags_ht &= 3336 ~(IEEE80211_FHT_SHORTGI20 | IEEE80211_FHT_SHORTGI40); 3337 error = ERESTART; 3338 break; 3339 case IEEE80211_IOC_AMPDU: 3340 if (ireq->i_val && (vap->iv_htcaps & IEEE80211_HTC_AMPDU) == 0) 3341 return EINVAL; 3342 if (ireq->i_val & 1) 3343 vap->iv_flags_ht |= IEEE80211_FHT_AMPDU_TX; 3344 else 3345 vap->iv_flags_ht &= ~IEEE80211_FHT_AMPDU_TX; 3346 if (ireq->i_val & 2) 3347 vap->iv_flags_ht |= IEEE80211_FHT_AMPDU_RX; 3348 else 3349 vap->iv_flags_ht &= ~IEEE80211_FHT_AMPDU_RX; 3350 /* NB: reset only if we're operating on an 11n channel */ 3351 if (isvapht(vap)) 3352 error = ERESTART; 3353 break; 3354 case IEEE80211_IOC_AMPDU_LIMIT: 3355 /* XXX TODO: figure out ampdu_limit versus ampdu_rxmax */ 3356 if (!(IEEE80211_HTCAP_MAXRXAMPDU_8K <= ireq->i_val && 3357 ireq->i_val <= IEEE80211_HTCAP_MAXRXAMPDU_64K)) 3358 return EINVAL; 3359 if (vap->iv_opmode == IEEE80211_M_HOSTAP) 3360 vap->iv_ampdu_rxmax = ireq->i_val; 3361 else 3362 vap->iv_ampdu_limit = ireq->i_val; 3363 error = ERESTART; 3364 break; 3365 case IEEE80211_IOC_AMPDU_DENSITY: 3366 if (!(IEEE80211_HTCAP_MPDUDENSITY_NA <= ireq->i_val && 3367 ireq->i_val <= IEEE80211_HTCAP_MPDUDENSITY_16)) 3368 return EINVAL; 3369 vap->iv_ampdu_density = ireq->i_val; 3370 error = ERESTART; 3371 break; 3372 case IEEE80211_IOC_AMSDU: 3373 if (ireq->i_val && (vap->iv_htcaps & IEEE80211_HTC_AMSDU) == 0) 3374 return EINVAL; 3375 if (ireq->i_val & 1) 3376 vap->iv_flags_ht |= IEEE80211_FHT_AMSDU_TX; 3377 else 3378 vap->iv_flags_ht &= ~IEEE80211_FHT_AMSDU_TX; 3379 if (ireq->i_val & 2) 3380 vap->iv_flags_ht |= IEEE80211_FHT_AMSDU_RX; 3381 else 3382 vap->iv_flags_ht &= ~IEEE80211_FHT_AMSDU_RX; 3383 /* NB: reset only if we're operating on an 11n channel */ 3384 if (isvapht(vap)) 3385 error = ERESTART; 3386 break; 3387 case IEEE80211_IOC_AMSDU_LIMIT: 3388 /* XXX validate */ 3389 vap->iv_amsdu_limit = ireq->i_val; /* XXX truncation? */ 3390 break; 3391 case IEEE80211_IOC_PUREN: 3392 if (ireq->i_val) { 3393 if ((vap->iv_flags_ht & IEEE80211_FHT_HT) == 0) 3394 return EINVAL; 3395 vap->iv_flags_ht |= IEEE80211_FHT_PUREN; 3396 } else 3397 vap->iv_flags_ht &= ~IEEE80211_FHT_PUREN; 3398 /* NB: reset only if we're operating on an 11n channel */ 3399 if (isvapht(vap)) 3400 error = ERESTART; 3401 break; 3402 case IEEE80211_IOC_DOTH: 3403 if (ireq->i_val) { 3404 #if 0 3405 /* XXX no capability */ 3406 if ((vap->iv_caps & IEEE80211_C_DOTH) == 0) 3407 return EOPNOTSUPP; 3408 #endif 3409 vap->iv_flags |= IEEE80211_F_DOTH; 3410 } else 3411 vap->iv_flags &= ~IEEE80211_F_DOTH; 3412 error = ENETRESET; 3413 break; 3414 case IEEE80211_IOC_REGDOMAIN: 3415 error = ieee80211_ioctl_setregdomain(vap, ireq); 3416 break; 3417 case IEEE80211_IOC_ROAM: 3418 error = ieee80211_ioctl_setroam(vap, ireq); 3419 break; 3420 case IEEE80211_IOC_TXPARAMS: 3421 error = ieee80211_ioctl_settxparams(vap, ireq); 3422 break; 3423 case IEEE80211_IOC_HTCOMPAT: 3424 if (ireq->i_val) { 3425 if ((vap->iv_flags_ht & IEEE80211_FHT_HT) == 0) 3426 return EOPNOTSUPP; 3427 vap->iv_flags_ht |= IEEE80211_FHT_HTCOMPAT; 3428 } else 3429 vap->iv_flags_ht &= ~IEEE80211_FHT_HTCOMPAT; 3430 /* NB: reset only if we're operating on an 11n channel */ 3431 if (isvapht(vap)) 3432 error = ERESTART; 3433 break; 3434 case IEEE80211_IOC_DWDS: 3435 if (ireq->i_val) { 3436 /* NB: DWDS only makes sense for WDS-capable devices */ 3437 if ((ic->ic_caps & IEEE80211_C_WDS) == 0) 3438 return EOPNOTSUPP; 3439 /* NB: DWDS is used only with ap+sta vaps */ 3440 if (vap->iv_opmode != IEEE80211_M_HOSTAP && 3441 vap->iv_opmode != IEEE80211_M_STA) 3442 return EINVAL; 3443 vap->iv_flags |= IEEE80211_F_DWDS; 3444 if (vap->iv_opmode == IEEE80211_M_STA) 3445 vap->iv_flags_ext |= IEEE80211_FEXT_4ADDR; 3446 } else { 3447 vap->iv_flags &= ~IEEE80211_F_DWDS; 3448 if (vap->iv_opmode == IEEE80211_M_STA) 3449 vap->iv_flags_ext &= ~IEEE80211_FEXT_4ADDR; 3450 } 3451 break; 3452 case IEEE80211_IOC_INACTIVITY: 3453 if (ireq->i_val) 3454 vap->iv_flags_ext |= IEEE80211_FEXT_INACT; 3455 else 3456 vap->iv_flags_ext &= ~IEEE80211_FEXT_INACT; 3457 break; 3458 case IEEE80211_IOC_APPIE: 3459 error = ieee80211_ioctl_setappie(vap, ireq); 3460 break; 3461 case IEEE80211_IOC_WPS: 3462 if (ireq->i_val) { 3463 if ((vap->iv_caps & IEEE80211_C_WPA) == 0) 3464 return EOPNOTSUPP; 3465 vap->iv_flags_ext |= IEEE80211_FEXT_WPS; 3466 } else 3467 vap->iv_flags_ext &= ~IEEE80211_FEXT_WPS; 3468 break; 3469 case IEEE80211_IOC_TSN: 3470 if (ireq->i_val) { 3471 if ((vap->iv_caps & IEEE80211_C_WPA) == 0) 3472 return EOPNOTSUPP; 3473 vap->iv_flags_ext |= IEEE80211_FEXT_TSN; 3474 } else 3475 vap->iv_flags_ext &= ~IEEE80211_FEXT_TSN; 3476 break; 3477 case IEEE80211_IOC_CHANSWITCH: 3478 error = ieee80211_ioctl_chanswitch(vap, ireq); 3479 break; 3480 case IEEE80211_IOC_DFS: 3481 if (ireq->i_val) { 3482 if ((vap->iv_caps & IEEE80211_C_DFS) == 0) 3483 return EOPNOTSUPP; 3484 /* NB: DFS requires 11h support */ 3485 if ((vap->iv_flags & IEEE80211_F_DOTH) == 0) 3486 return EINVAL; 3487 vap->iv_flags_ext |= IEEE80211_FEXT_DFS; 3488 } else 3489 vap->iv_flags_ext &= ~IEEE80211_FEXT_DFS; 3490 break; 3491 case IEEE80211_IOC_DOTD: 3492 if (ireq->i_val) 3493 vap->iv_flags_ext |= IEEE80211_FEXT_DOTD; 3494 else 3495 vap->iv_flags_ext &= ~IEEE80211_FEXT_DOTD; 3496 if (vap->iv_opmode == IEEE80211_M_STA) 3497 error = ENETRESET; 3498 break; 3499 case IEEE80211_IOC_HTPROTMODE: 3500 if (ireq->i_val > IEEE80211_PROT_RTSCTS) 3501 return EINVAL; 3502 ic->ic_htprotmode = ireq->i_val ? 3503 IEEE80211_PROT_RTSCTS : IEEE80211_PROT_NONE; 3504 /* NB: if not operating in 11n this can wait */ 3505 if (isvapht(vap)) 3506 error = ERESTART; 3507 break; 3508 case IEEE80211_IOC_STA_VLAN: 3509 error = ieee80211_ioctl_setstavlan(vap, ireq); 3510 break; 3511 case IEEE80211_IOC_SMPS: 3512 if ((ireq->i_val &~ IEEE80211_HTCAP_SMPS) != 0 || 3513 ireq->i_val == 0x0008) /* value of 2 is reserved */ 3514 return EINVAL; 3515 if (ireq->i_val != IEEE80211_HTCAP_SMPS_OFF && 3516 (vap->iv_htcaps & IEEE80211_HTC_SMPS) == 0) 3517 return EOPNOTSUPP; 3518 vap->iv_htcaps = (vap->iv_htcaps &~ IEEE80211_HTCAP_SMPS) | 3519 ireq->i_val; 3520 /* NB: if not operating in 11n this can wait */ 3521 if (isvapht(vap)) 3522 error = ERESTART; 3523 break; 3524 case IEEE80211_IOC_RIFS: 3525 if (ireq->i_val != 0) { 3526 if ((vap->iv_htcaps & IEEE80211_HTC_RIFS) == 0) 3527 return EOPNOTSUPP; 3528 vap->iv_flags_ht |= IEEE80211_FHT_RIFS; 3529 } else 3530 vap->iv_flags_ht &= ~IEEE80211_FHT_RIFS; 3531 /* NB: if not operating in 11n this can wait */ 3532 if (isvapht(vap)) 3533 error = ERESTART; 3534 break; 3535 case IEEE80211_IOC_STBC: 3536 /* Check if we can do STBC TX/RX before changing the setting */ 3537 if ((ireq->i_val & 1) && 3538 ((vap->iv_htcaps & IEEE80211_HTCAP_TXSTBC) == 0)) 3539 return EOPNOTSUPP; 3540 if ((ireq->i_val & 2) && 3541 ((vap->iv_htcaps & IEEE80211_HTCAP_RXSTBC) == 0)) 3542 return EOPNOTSUPP; 3543 3544 /* TX */ 3545 if (ireq->i_val & 1) 3546 vap->iv_flags_ht |= IEEE80211_FHT_STBC_TX; 3547 else 3548 vap->iv_flags_ht &= ~IEEE80211_FHT_STBC_TX; 3549 3550 /* RX */ 3551 if (ireq->i_val & 2) 3552 vap->iv_flags_ht |= IEEE80211_FHT_STBC_RX; 3553 else 3554 vap->iv_flags_ht &= ~IEEE80211_FHT_STBC_RX; 3555 3556 /* NB: reset only if we're operating on an 11n channel */ 3557 if (isvapht(vap)) 3558 error = ERESTART; 3559 break; 3560 case IEEE80211_IOC_LDPC: 3561 /* Check if we can do LDPC TX/RX before changing the setting */ 3562 if ((ireq->i_val & 1) && 3563 (vap->iv_htcaps & IEEE80211_HTC_TXLDPC) == 0) 3564 return EOPNOTSUPP; 3565 if ((ireq->i_val & 2) && 3566 (vap->iv_htcaps & IEEE80211_HTCAP_LDPC) == 0) 3567 return EOPNOTSUPP; 3568 3569 /* TX */ 3570 if (ireq->i_val & 1) 3571 vap->iv_flags_ht |= IEEE80211_FHT_LDPC_TX; 3572 else 3573 vap->iv_flags_ht &= ~IEEE80211_FHT_LDPC_TX; 3574 3575 /* RX */ 3576 if (ireq->i_val & 2) 3577 vap->iv_flags_ht |= IEEE80211_FHT_LDPC_RX; 3578 else 3579 vap->iv_flags_ht &= ~IEEE80211_FHT_LDPC_RX; 3580 3581 /* NB: reset only if we're operating on an 11n channel */ 3582 if (isvapht(vap)) 3583 error = ERESTART; 3584 break; 3585 3586 /* VHT */ 3587 case IEEE80211_IOC_VHTCONF: 3588 if (ireq->i_val & 1) 3589 ieee80211_syncflag_vht(vap, IEEE80211_FVHT_VHT); 3590 else 3591 ieee80211_syncflag_vht(vap, -IEEE80211_FVHT_VHT); 3592 3593 if (ireq->i_val & 2) 3594 ieee80211_syncflag_vht(vap, IEEE80211_FVHT_USEVHT40); 3595 else 3596 ieee80211_syncflag_vht(vap, -IEEE80211_FVHT_USEVHT40); 3597 3598 if (ireq->i_val & 4) 3599 ieee80211_syncflag_vht(vap, IEEE80211_FVHT_USEVHT80); 3600 else 3601 ieee80211_syncflag_vht(vap, -IEEE80211_FVHT_USEVHT80); 3602 3603 if (ireq->i_val & 8) 3604 ieee80211_syncflag_vht(vap, IEEE80211_FVHT_USEVHT80P80); 3605 else 3606 ieee80211_syncflag_vht(vap, -IEEE80211_FVHT_USEVHT80P80); 3607 3608 if (ireq->i_val & 16) 3609 ieee80211_syncflag_vht(vap, IEEE80211_FVHT_USEVHT160); 3610 else 3611 ieee80211_syncflag_vht(vap, -IEEE80211_FVHT_USEVHT160); 3612 3613 error = ENETRESET; 3614 break; 3615 3616 default: 3617 error = ieee80211_ioctl_setdefault(vap, ireq); 3618 break; 3619 } 3620 /* 3621 * The convention is that ENETRESET means an operation 3622 * requires a complete re-initialization of the device (e.g. 3623 * changing something that affects the association state). 3624 * ERESTART means the request may be handled with only a 3625 * reload of the hardware state. We hand ERESTART requests 3626 * to the iv_reset callback so the driver can decide. If 3627 * a device does not fillin iv_reset then it defaults to one 3628 * that returns ENETRESET. Otherwise a driver may return 3629 * ENETRESET (in which case a full reset will be done) or 3630 * 0 to mean there's no need to do anything (e.g. when the 3631 * change has no effect on the driver/device). 3632 */ 3633 if (error == ERESTART) 3634 error = IFNET_IS_UP_RUNNING(vap->iv_ifp) ? 3635 vap->iv_reset(vap, ireq->i_type) : 0; 3636 if (error == ENETRESET) { 3637 /* XXX need to re-think AUTO handling */ 3638 if (IS_UP_AUTO(vap)) 3639 #if __FreeBSD__ 3640 ieee80211_init(vap); 3641 #elif __NetBSD__ 3642 /* arg is a vap in 802.11 code */ 3643 ieee80211_init((struct ifnet *)vap); 3644 #endif 3645 error = 0; 3646 } 3647 return error; 3648 } 3649 3650 int 3651 ieee80211_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 3652 { 3653 struct ieee80211vap *vap = ifp->if_softc; 3654 struct ieee80211com *ic = vap->iv_ic; 3655 int error = 0, wait = 0; 3656 struct ifreq *ifr; 3657 struct ifaddr *ifa; /* XXX */ 3658 #if __NetBSD__ 3659 struct ieee80211_nwid nwid; 3660 // struct ieee80211_nwkey *nwkey; 3661 struct ieee80211_power *power; 3662 struct ieee80211chanreq *chanreq; 3663 struct ieee80211_bssid *bssid; 3664 struct ieee80211_channel *chan; 3665 struct ieee80211req ireq; 3666 3667 ifr = (struct ifreq *)data; 3668 #endif 3669 3670 switch (cmd) { 3671 case SIOCSIFFLAGS: 3672 IEEE80211_LOCK(ic); 3673 if ((ifp->if_flags ^ vap->iv_ifflags) & IFF_PROMISC) { 3674 printf (" promisc mode\n"); 3675 /* 3676 * Enable promiscuous mode when: 3677 * 1. Interface is not a member of bridge, or 3678 * 2. Requested by user, or 3679 * 3. In monitor (or adhoc-demo) mode. 3680 */ 3681 if (ifp->if_bridge == NULL || 3682 (ifp->if_flags & IFF_PPROMISC) != 0 || 3683 vap->iv_opmode == IEEE80211_M_MONITOR || 3684 (vap->iv_opmode == IEEE80211_M_AHDEMO && 3685 (vap->iv_caps & IEEE80211_C_TDMA) == 0)) { 3686 ieee80211_promisc(vap, 3687 ifp->if_flags & IFF_PROMISC); 3688 vap->iv_ifflags ^= IFF_PROMISC; 3689 } 3690 } 3691 if ((ifp->if_flags ^ vap->iv_ifflags) & IFF_ALLMULTI) { 3692 printf (" allmulti\n"); 3693 ieee80211_allmulti(vap, ifp->if_flags & IFF_ALLMULTI); 3694 vap->iv_ifflags ^= IFF_ALLMULTI; 3695 } 3696 if (ifp->if_flags & IFF_UP) { 3697 printf (" up flag\n"); 3698 /* 3699 * Bring ourself up unless we're already operational. 3700 * If we're the first vap and the parent is not up 3701 * then it will automatically be brought up as a 3702 * side-effect of bringing ourself up. 3703 */ 3704 if (vap->iv_state == IEEE80211_S_INIT) { 3705 if (ic->ic_nrunning == 0) 3706 wait = 1; 3707 printf ("Should call start_locked ...\n"); 3708 wait = 0; 3709 // ieee80211_start_locked(vap); 3710 } 3711 #if __FreeBSD__ 3712 } else if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 3713 #elif __NetBSD__ 3714 } else if (ifp->if_flags & IFF_RUNNING) { 3715 #endif 3716 /* 3717 * Stop ourself. If we are the last vap to be 3718 * marked down the parent will also be taken down. 3719 */ 3720 if (ic->ic_nrunning == 1) 3721 wait = 1; 3722 ieee80211_stop_locked(vap); 3723 } 3724 IEEE80211_UNLOCK(ic); 3725 /* Wait for parent ioctl handler if it was queued */ 3726 if (wait) { 3727 ieee80211_waitfor_parent(ic); 3728 3729 /* 3730 * Check if the MAC address was changed 3731 * via SIOCSIFLLADDR ioctl. 3732 */ 3733 if_addr_rlock(ifp); 3734 if ((ifp->if_flags & IFF_UP) == 0 && 3735 !IEEE80211_ADDR_EQ(vap->iv_myaddr, IF_LLADDR(ifp))) { 3736 IEEE80211_ADDR_COPY(vap->iv_myaddr, 3737 IF_LLADDR(ifp)); 3738 printf ("vap->iv_myaddr changed in ioctl to %s\n", 3739 ether_sprintf(vap->iv_myaddr)); 3740 } 3741 3742 if_addr_runlock(ifp); 3743 } 3744 break; 3745 case SIOCADDMULTI: 3746 case SIOCDELMULTI: 3747 ieee80211_runtask(ic, &ic->ic_mcast_task); 3748 break; 3749 #ifdef OSIOCSIFMEDIA 3750 case OSIOCSIFMEDIA: 3751 #endif 3752 case SIOCSIFMEDIA: 3753 case SIOCGIFMEDIA: 3754 ifr = (struct ifreq *)data; 3755 error = ifmedia_ioctl(ifp, ifr, &vap->iv_media, cmd); 3756 break; 3757 case SIOCG80211: 3758 error = ieee80211_ioctl_get80211(vap, cmd, 3759 (struct ieee80211req *) data); 3760 break; 3761 case SIOCS80211: 3762 error = priv_check(curthread, PRIV_NET80211_MANAGE); 3763 if (error == 0) 3764 error = ieee80211_ioctl_set80211(vap, cmd, 3765 (struct ieee80211req *) data); 3766 break; 3767 #ifdef __NetBSD__ 3768 case OSIOCG80211STATS: 3769 case OSIOCG80211ZSTATS: 3770 (void)module_autoload("compat_20", MODULE_CLASS_EXEC); 3771 MODULE_HOOK_CALL(ieee80211_ioctl_20_hook, (vap, cmd, data), 3772 enosys(), error); 3773 break; 3774 #endif 3775 #ifdef SIOCG80211ZSTATS 3776 case SIOCG80211ZSTATS: 3777 #endif 3778 case SIOCG80211STATS: 3779 ifr = (struct ifreq *)data; 3780 #if __FreeBSD__ 3781 copyout(&vap->iv_stats, ifr_data_get_ptr(ifr), 3782 sizeof (vap->iv_stats)); 3783 #elif__NetBSD__ 3784 s = splnet(); 3785 error = copyout(&vap->iv_stats, ifr->ifr_buf, 3786 sizeof (vap->iv_stats) <= ifr->ifr_buflen 3787 ? sizeof (vap->iv_stats) : ifr->ifr_buflen); 3788 if (error == 0 && cmd == SIOCG80211ZSTATS) 3789 (void)memset(&vap->iv_stats, 0, sizeof(vap->iv_stats)); 3790 splx(s); 3791 #endif 3792 break; 3793 case SIOCSIFMTU: 3794 ifr = (struct ifreq *)data; 3795 if (!(IEEE80211_MTU_MIN <= ifr->ifr_mtu && 3796 ifr->ifr_mtu <= IEEE80211_MTU_MAX)) 3797 error = EINVAL; 3798 else if ((error = ifioctl_common(ifp, cmd, data)) == ENETRESET) 3799 error = 0; 3800 break; 3801 case SIOCSIFADDR: 3802 /* 3803 * XXX Handle this directly so we can suppress if_init calls. 3804 * XXX This should be done in ether_ioctl but for the moment 3805 * XXX there are too many other parts of the system that 3806 * XXX set IFF_UP and so suppress if_init being called when 3807 * XXX it should be. 3808 */ 3809 ifa = (struct ifaddr *) data; 3810 switch (ifa->ifa_addr->sa_family) { 3811 #ifdef INET 3812 case AF_INET: 3813 if ((ifp->if_flags & IFF_UP) == 0) { 3814 ifp->if_flags |= IFF_UP; 3815 #if __FreeBSD__ 3816 ifp->if_init(ifp->if_softc); 3817 #elif __NetBSD__ 3818 ifp->if_init(ifp); 3819 #endif 3820 } 3821 arp_ifinit(ifp, ifa); 3822 break; 3823 #endif 3824 default: 3825 if ((ifp->if_flags & IFF_UP) == 0) { 3826 ifp->if_flags |= IFF_UP; 3827 #if __FreeBSD__ 3828 ifp->if_init(ifp->if_softc); 3829 #elif __NetBSD__ 3830 ifp->if_init(ifp); 3831 #endif 3832 } 3833 break; 3834 } 3835 break; 3836 #if __NetBSD__ 3837 case SIOCS80211NWID: 3838 if ((error = copyin(ifr->ifr_data, &nwid, sizeof(nwid))) != 0) 3839 break; 3840 if (nwid.i_len > IEEE80211_NWID_LEN) { 3841 error = EINVAL; 3842 break; 3843 } 3844 memset(vap->iv_des_ssid, 0, IEEE80211_NWID_LEN); 3845 vap->iv_des_ssid[0].len = nwid.i_len; 3846 memcpy(vap->iv_des_ssid[0].ssid, nwid.i_nwid, nwid.i_len); 3847 error = ENETRESET; 3848 break; 3849 case SIOCG80211NWID: 3850 memset(&nwid, 0, sizeof(nwid)); 3851 switch (vap->iv_state) { 3852 case IEEE80211_S_INIT: 3853 case IEEE80211_S_SCAN: 3854 nwid.i_len = vap->iv_des_ssid[0].len; 3855 memcpy(nwid.i_nwid, vap->iv_des_ssid[0].ssid, 3856 nwid.i_len); 3857 break; 3858 default: 3859 nwid.i_len = vap->iv_bss->ni_esslen; 3860 memcpy(nwid.i_nwid, vap->iv_bss->ni_essid, nwid.i_len); 3861 break; 3862 } 3863 error = copyout(&nwid, ifr->ifr_data, sizeof(nwid)); 3864 break; 3865 case SIOCS80211NWKEY: 3866 case SIOCG80211NWKEY: 3867 printf ("NetBSD NWKEY ioctl\n"); // NNN 3868 error = ENOTTY; 3869 break; 3870 case SIOCS80211POWER: 3871 power = (struct ieee80211_power *)data; 3872 ic->ic_lintval = power->i_maxsleep; 3873 if (power->i_enabled != 0) { 3874 if ((ic->ic_caps & IEEE80211_C_PMGT) == 0) 3875 error = EINVAL; 3876 else if ((ic->ic_flags & IEEE80211_F_PMGTON) == 0) { 3877 ic->ic_flags |= IEEE80211_F_PMGTON; 3878 error = ENETRESET; 3879 } 3880 } else { 3881 if (ic->ic_flags & IEEE80211_F_PMGTON) { 3882 ic->ic_flags &= ~IEEE80211_F_PMGTON; 3883 error = ENETRESET; 3884 } 3885 } 3886 break; 3887 case SIOCG80211POWER: 3888 power = (struct ieee80211_power *)data; 3889 power->i_enabled = (ic->ic_flags & IEEE80211_F_PMGTON) ? 1 : 0; 3890 power->i_maxsleep = ic->ic_lintval; 3891 break; 3892 case SIOCS80211BSSID: 3893 bssid = (struct ieee80211_bssid *)data; 3894 IEEE80211_ADDR_COPY(vap->iv_des_bssid, bssid->i_bssid); 3895 if (IEEE80211_ADDR_EQ(vap->iv_des_bssid, zerobssid)) 3896 vap->iv_flags &= ~IEEE80211_F_DESBSSID; 3897 else 3898 vap->iv_flags |= IEEE80211_F_DESBSSID; 3899 error = ENETRESET; 3900 break; 3901 case SIOCG80211BSSID: 3902 bssid = (struct ieee80211_bssid *)data; 3903 switch (vap->iv_state) { 3904 case IEEE80211_S_RUN: 3905 case IEEE80211_S_SLEEP: 3906 IEEE80211_ADDR_COPY(bssid->i_bssid, 3907 vap->iv_opmode == IEEE80211_M_WDS ? 3908 vap->iv_bss->ni_macaddr : vap->iv_bss->ni_bssid); 3909 break; 3910 case IEEE80211_S_INIT: 3911 case IEEE80211_S_SCAN: 3912 if (vap->iv_opmode == IEEE80211_M_HOSTAP) 3913 IEEE80211_ADDR_COPY(bssid->i_bssid, 3914 vap->iv_myaddr); 3915 else if (vap->iv_flags & IEEE80211_F_DESBSSID) 3916 IEEE80211_ADDR_COPY(bssid->i_bssid, 3917 vap->iv_des_bssid); 3918 else 3919 memset(bssid->i_bssid, 0, IEEE80211_ADDR_LEN); 3920 3921 break; 3922 default: 3923 memset(bssid->i_bssid, 0, IEEE80211_ADDR_LEN); 3924 } 3925 break; 3926 case SIOCS80211CHANNEL: 3927 /* Use deprecated ieee80211_ioctl_setchannel code. NNN? */ 3928 chanreq = (struct ieee80211chanreq *)data; 3929 ireq.i_val = chanreq->i_channel; 3930 error = ieee80211_ioctl_setchannel(vap, &ireq); 3931 break; 3932 case SIOCG80211CHANNEL: 3933 chanreq = (struct ieee80211chanreq *)data; 3934 switch (vap->iv_state) { 3935 case IEEE80211_S_INIT: 3936 case IEEE80211_S_SCAN: 3937 if (vap->iv_opmode == IEEE80211_M_STA) 3938 chan = vap->iv_des_chan; 3939 else 3940 chan = ic->ic_bsschan; // NNN ibss chan? 3941 break; 3942 default: 3943 chan = ic->ic_curchan; 3944 break; 3945 } 3946 chanreq->i_channel = ieee80211_chan2ieee(ic, chan); 3947 break; 3948 #endif 3949 default: 3950 /* 3951 * Pass unknown ioctls first to the driver, and if it 3952 * returns ENOTTY, then to the generic Ethernet handler. 3953 */ 3954 if (ic->ic_ioctl != NULL && 3955 (error = ic->ic_ioctl(ic, cmd, data)) != ENOTTY) 3956 break; 3957 error = ether_ioctl(ifp, cmd, data); 3958 if (error == ENOTTY) { 3959 printf ("ieee80211_ioctl: cmd is 0x%lx. ('%c', %ld)\n", 3960 cmd, (char) ((cmd>>8) & 0xff), cmd & 0xff ); 3961 printf ("Unknown 802.11 IOCTL.\n"); /* NNN */ 3962 } 3963 break; 3964 } 3965 return (error); 3966 } 3967
Indexes created Tue Sep 30 07:10:03 GMT 2025