ieee80211_ioctl.c revision 1.1.1.5
1 /*- 2 * Copyright (c) 2001 Atsushi Onoe 3 * Copyright (c) 2002-2005 Sam Leffler, Errno Consulting 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. The name of the author may not be used to endorse or promote products 15 * derived from this software without specific prior written permission. 16 * 17 * Alternatively, this software may be distributed under the terms of the 18 * GNU General Public License ("GPL") version 2 as published by the Free 19 * Software Foundation. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #include <sys/cdefs.h> 34 __FBSDID("$FreeBSD: src/sys/net80211/ieee80211_ioctl.c,v 1.25 2005/07/06 15:38:27 sam Exp $"); 35 36 /* 37 * IEEE 802.11 ioctl support (FreeBSD-specific) 38 */ 39 40 #include "opt_inet.h" 41 #include "opt_ipx.h" 42 43 #include <sys/endian.h> 44 #include <sys/param.h> 45 #include <sys/kernel.h> 46 #include <sys/socket.h> 47 #include <sys/sockio.h> 48 #include <sys/systm.h> 49 50 #include <net/if.h> 51 #include <net/if_arp.h> 52 #include <net/if_media.h> 53 #include <net/ethernet.h> 54 55 #ifdef INET 56 #include <netinet/in.h> 57 #include <netinet/if_ether.h> 58 #endif 59 60 #ifdef IPX 61 #include <netipx/ipx.h> 62 #include <netipx/ipx_if.h> 63 #endif 64 65 #include <net80211/ieee80211_var.h> 66 #include <net80211/ieee80211_ioctl.h> 67 68 #include <dev/wi/if_wavelan_ieee.h> 69 70 #define IS_UP(_ic) \ 71 (((_ic)->ic_ifp->if_flags & (IFF_RUNNING|IFF_UP)) == (IFF_RUNNING|IFF_UP)) 72 #define IS_UP_AUTO(_ic) \ 73 (IS_UP(_ic) && (_ic)->ic_roaming == IEEE80211_ROAMING_AUTO) 74 75 /* 76 * XXX 77 * Wireless LAN specific configuration interface, which is compatible 78 * with wicontrol(8). 79 */ 80 81 struct wi_read_ap_args { 82 int i; /* result count */ 83 struct wi_apinfo *ap; /* current entry in result buffer */ 84 caddr_t max; /* result buffer bound */ 85 }; 86 87 static void 88 wi_read_ap_result(void *arg, struct ieee80211_node *ni) 89 { 90 struct ieee80211com *ic = ni->ni_ic; 91 struct wi_read_ap_args *sa = arg; 92 struct wi_apinfo *ap = sa->ap; 93 struct ieee80211_rateset *rs; 94 int j; 95 96 if ((caddr_t)(ap + 1) > sa->max) 97 return; 98 memset(ap, 0, sizeof(struct wi_apinfo)); 99 if (ic->ic_opmode == IEEE80211_M_HOSTAP) { 100 IEEE80211_ADDR_COPY(ap->bssid, ni->ni_macaddr); 101 ap->namelen = ic->ic_des_esslen; 102 if (ic->ic_des_esslen) 103 memcpy(ap->name, ic->ic_des_essid, 104 ic->ic_des_esslen); 105 } else { 106 IEEE80211_ADDR_COPY(ap->bssid, ni->ni_bssid); 107 ap->namelen = ni->ni_esslen; 108 if (ni->ni_esslen) 109 memcpy(ap->name, ni->ni_essid, 110 ni->ni_esslen); 111 } 112 ap->channel = ieee80211_chan2ieee(ic, ni->ni_chan); 113 ap->signal = ic->ic_node_getrssi(ni); 114 ap->capinfo = ni->ni_capinfo; 115 ap->interval = ni->ni_intval; 116 rs = &ni->ni_rates; 117 for (j = 0; j < rs->rs_nrates; j++) { 118 if (rs->rs_rates[j] & IEEE80211_RATE_BASIC) { 119 ap->rate = (rs->rs_rates[j] & 120 IEEE80211_RATE_VAL) * 5; /* XXX */ 121 } 122 } 123 sa->i++; 124 sa->ap++; 125 } 126 127 struct wi_read_prism2_args { 128 int i; /* result count */ 129 struct wi_scan_res *res;/* current entry in result buffer */ 130 caddr_t max; /* result buffer bound */ 131 }; 132 133 static void 134 wi_read_prism2_result(void *arg, struct ieee80211_node *ni) 135 { 136 struct ieee80211com *ic = ni->ni_ic; 137 struct wi_read_prism2_args *sa = arg; 138 struct wi_scan_res *res = sa->res; 139 140 if ((caddr_t)(res + 1) > sa->max) 141 return; 142 res->wi_chan = ieee80211_chan2ieee(ic, ni->ni_chan); 143 res->wi_noise = 0; 144 res->wi_signal = ic->ic_node_getrssi(ni); 145 IEEE80211_ADDR_COPY(res->wi_bssid, ni->ni_bssid); 146 res->wi_interval = ni->ni_intval; 147 res->wi_capinfo = ni->ni_capinfo; 148 res->wi_ssid_len = ni->ni_esslen; 149 memcpy(res->wi_ssid, ni->ni_essid, IEEE80211_NWID_LEN); 150 /* NB: assumes wi_srates holds <= ni->ni_rates */ 151 memcpy(res->wi_srates, ni->ni_rates.rs_rates, 152 sizeof(res->wi_srates)); 153 if (ni->ni_rates.rs_nrates < 10) 154 res->wi_srates[ni->ni_rates.rs_nrates] = 0; 155 res->wi_rate = ni->ni_rates.rs_rates[ni->ni_txrate]; 156 res->wi_rsvd = 0; 157 158 sa->i++; 159 sa->res++; 160 } 161 162 struct wi_read_sigcache_args { 163 int i; /* result count */ 164 struct wi_sigcache *wsc;/* current entry in result buffer */ 165 caddr_t max; /* result buffer bound */ 166 }; 167 168 static void 169 wi_read_sigcache(void *arg, struct ieee80211_node *ni) 170 { 171 struct ieee80211com *ic = ni->ni_ic; 172 struct wi_read_sigcache_args *sa = arg; 173 struct wi_sigcache *wsc = sa->wsc; 174 175 if ((caddr_t)(wsc + 1) > sa->max) 176 return; 177 memset(wsc, 0, sizeof(struct wi_sigcache)); 178 IEEE80211_ADDR_COPY(wsc->macsrc, ni->ni_macaddr); 179 wsc->signal = ic->ic_node_getrssi(ni); 180 181 sa->wsc++; 182 sa->i++; 183 } 184 185 int 186 ieee80211_cfgget(struct ieee80211com *ic, u_long cmd, caddr_t data) 187 { 188 struct ifnet *ifp = ic->ic_ifp; 189 int i, j, error; 190 struct ifreq *ifr = (struct ifreq *)data; 191 struct wi_req wreq; 192 struct wi_ltv_keys *keys; 193 194 error = copyin(ifr->ifr_data, &wreq, sizeof(wreq)); 195 if (error) 196 return error; 197 wreq.wi_len = 0; 198 switch (wreq.wi_type) { 199 case WI_RID_SERIALNO: 200 /* nothing appropriate */ 201 break; 202 case WI_RID_NODENAME: 203 strcpy((char *)&wreq.wi_val[1], hostname); 204 wreq.wi_val[0] = htole16(strlen(hostname)); 205 wreq.wi_len = (1 + strlen(hostname) + 1) / 2; 206 break; 207 case WI_RID_CURRENT_SSID: 208 if (ic->ic_state != IEEE80211_S_RUN) { 209 wreq.wi_val[0] = 0; 210 wreq.wi_len = 1; 211 break; 212 } 213 wreq.wi_val[0] = htole16(ic->ic_bss->ni_esslen); 214 memcpy(&wreq.wi_val[1], ic->ic_bss->ni_essid, 215 ic->ic_bss->ni_esslen); 216 wreq.wi_len = (1 + ic->ic_bss->ni_esslen + 1) / 2; 217 break; 218 case WI_RID_OWN_SSID: 219 case WI_RID_DESIRED_SSID: 220 wreq.wi_val[0] = htole16(ic->ic_des_esslen); 221 memcpy(&wreq.wi_val[1], ic->ic_des_essid, ic->ic_des_esslen); 222 wreq.wi_len = (1 + ic->ic_des_esslen + 1) / 2; 223 break; 224 case WI_RID_CURRENT_BSSID: 225 if (ic->ic_state == IEEE80211_S_RUN) 226 IEEE80211_ADDR_COPY(wreq.wi_val, ic->ic_bss->ni_bssid); 227 else 228 memset(wreq.wi_val, 0, IEEE80211_ADDR_LEN); 229 wreq.wi_len = IEEE80211_ADDR_LEN / 2; 230 break; 231 case WI_RID_CHANNEL_LIST: 232 memset(wreq.wi_val, 0, sizeof(wreq.wi_val)); 233 /* 234 * Since channel 0 is not available for DS, channel 1 235 * is assigned to LSB on WaveLAN. 236 */ 237 if (ic->ic_phytype == IEEE80211_T_DS) 238 i = 1; 239 else 240 i = 0; 241 for (j = 0; i <= IEEE80211_CHAN_MAX; i++, j++) 242 if (isset(ic->ic_chan_active, i)) { 243 setbit((u_int8_t *)wreq.wi_val, j); 244 wreq.wi_len = j / 16 + 1; 245 } 246 break; 247 case WI_RID_OWN_CHNL: 248 wreq.wi_val[0] = htole16( 249 ieee80211_chan2ieee(ic, ic->ic_ibss_chan)); 250 wreq.wi_len = 1; 251 break; 252 case WI_RID_CURRENT_CHAN: 253 wreq.wi_val[0] = htole16( 254 ieee80211_chan2ieee(ic, ic->ic_bss->ni_chan)); 255 wreq.wi_len = 1; 256 break; 257 case WI_RID_COMMS_QUALITY: 258 wreq.wi_val[0] = 0; /* quality */ 259 wreq.wi_val[1] = htole16(ic->ic_node_getrssi(ic->ic_bss)); 260 wreq.wi_val[2] = 0; /* noise */ 261 wreq.wi_len = 3; 262 break; 263 case WI_RID_PROMISC: 264 wreq.wi_val[0] = htole16((ifp->if_flags & IFF_PROMISC) ? 1 : 0); 265 wreq.wi_len = 1; 266 break; 267 case WI_RID_PORTTYPE: 268 wreq.wi_val[0] = htole16(ic->ic_opmode); 269 wreq.wi_len = 1; 270 break; 271 case WI_RID_MAC_NODE: 272 IEEE80211_ADDR_COPY(wreq.wi_val, ic->ic_myaddr); 273 wreq.wi_len = IEEE80211_ADDR_LEN / 2; 274 break; 275 case WI_RID_TX_RATE: 276 if (ic->ic_fixed_rate == -1) 277 wreq.wi_val[0] = 0; /* auto */ 278 else 279 wreq.wi_val[0] = htole16( 280 (ic->ic_sup_rates[ic->ic_curmode].rs_rates[ic->ic_fixed_rate] & 281 IEEE80211_RATE_VAL) / 2); 282 wreq.wi_len = 1; 283 break; 284 case WI_RID_CUR_TX_RATE: 285 wreq.wi_val[0] = htole16( 286 (ic->ic_bss->ni_rates.rs_rates[ic->ic_bss->ni_txrate] & 287 IEEE80211_RATE_VAL) / 2); 288 wreq.wi_len = 1; 289 break; 290 case WI_RID_RTS_THRESH: 291 wreq.wi_val[0] = htole16(ic->ic_rtsthreshold); 292 wreq.wi_len = 1; 293 break; 294 case WI_RID_CREATE_IBSS: 295 wreq.wi_val[0] = 296 htole16((ic->ic_flags & IEEE80211_F_IBSSON) ? 1 : 0); 297 wreq.wi_len = 1; 298 break; 299 case WI_RID_MICROWAVE_OVEN: 300 wreq.wi_val[0] = 0; /* no ... not supported */ 301 wreq.wi_len = 1; 302 break; 303 case WI_RID_ROAMING_MODE: 304 wreq.wi_val[0] = htole16(ic->ic_roaming); /* XXX map */ 305 wreq.wi_len = 1; 306 break; 307 case WI_RID_SYSTEM_SCALE: 308 wreq.wi_val[0] = htole16(1); /* low density ... not supp */ 309 wreq.wi_len = 1; 310 break; 311 case WI_RID_PM_ENABLED: 312 wreq.wi_val[0] = 313 htole16((ic->ic_flags & IEEE80211_F_PMGTON) ? 1 : 0); 314 wreq.wi_len = 1; 315 break; 316 case WI_RID_MAX_SLEEP: 317 wreq.wi_val[0] = htole16(ic->ic_lintval); 318 wreq.wi_len = 1; 319 break; 320 case WI_RID_CUR_BEACON_INT: 321 wreq.wi_val[0] = htole16(ic->ic_bss->ni_intval); 322 wreq.wi_len = 1; 323 break; 324 case WI_RID_WEP_AVAIL: 325 wreq.wi_val[0] = htole16(1); /* always available */ 326 wreq.wi_len = 1; 327 break; 328 case WI_RID_CNFAUTHMODE: 329 wreq.wi_val[0] = htole16(1); /* TODO: open system only */ 330 wreq.wi_len = 1; 331 break; 332 case WI_RID_ENCRYPTION: 333 wreq.wi_val[0] = 334 htole16((ic->ic_flags & IEEE80211_F_PRIVACY) ? 1 : 0); 335 wreq.wi_len = 1; 336 break; 337 case WI_RID_TX_CRYPT_KEY: 338 wreq.wi_val[0] = htole16(ic->ic_def_txkey); 339 wreq.wi_len = 1; 340 break; 341 case WI_RID_DEFLT_CRYPT_KEYS: 342 keys = (struct wi_ltv_keys *)&wreq; 343 /* do not show keys to non-root user */ 344 error = suser(curthread); 345 if (error) { 346 memset(keys, 0, sizeof(*keys)); 347 error = 0; 348 break; 349 } 350 for (i = 0; i < IEEE80211_WEP_NKID; i++) { 351 keys->wi_keys[i].wi_keylen = 352 htole16(ic->ic_nw_keys[i].wk_keylen); 353 memcpy(keys->wi_keys[i].wi_keydat, 354 ic->ic_nw_keys[i].wk_key, 355 ic->ic_nw_keys[i].wk_keylen); 356 } 357 wreq.wi_len = sizeof(*keys) / 2; 358 break; 359 case WI_RID_MAX_DATALEN: 360 wreq.wi_val[0] = htole16(ic->ic_fragthreshold); 361 wreq.wi_len = 1; 362 break; 363 case WI_RID_IFACE_STATS: 364 /* XXX: should be implemented in lower drivers */ 365 break; 366 case WI_RID_READ_APS: 367 /* 368 * Don't return results until active scan completes. 369 */ 370 if ((ic->ic_flags & (IEEE80211_F_SCAN|IEEE80211_F_ASCAN)) == 0) { 371 struct wi_read_ap_args args; 372 373 args.i = 0; 374 args.ap = (void *)((char *)wreq.wi_val + sizeof(i)); 375 args.max = (void *)(&wreq + 1); 376 ieee80211_iterate_nodes(&ic->ic_scan, 377 wi_read_ap_result, &args); 378 memcpy(wreq.wi_val, &args.i, sizeof(args.i)); 379 wreq.wi_len = (sizeof(int) + 380 sizeof(struct wi_apinfo) * args.i) / 2; 381 } else 382 error = EINPROGRESS; 383 break; 384 case WI_RID_PRISM2: 385 /* NB: we lie so WI_RID_SCAN_RES can include rates */ 386 wreq.wi_val[0] = 1; 387 wreq.wi_len = sizeof(u_int16_t) / 2; 388 break; 389 case WI_RID_SCAN_RES: /* compatibility interface */ 390 if ((ic->ic_flags & (IEEE80211_F_SCAN|IEEE80211_F_ASCAN)) == 0) { 391 struct wi_read_prism2_args args; 392 struct wi_scan_p2_hdr *p2; 393 394 /* NB: use Prism2 format so we can include rate info */ 395 p2 = (struct wi_scan_p2_hdr *)wreq.wi_val; 396 args.i = 0; 397 args.res = (void *)&p2[1]; 398 args.max = (void *)(&wreq + 1); 399 ieee80211_iterate_nodes(&ic->ic_scan, 400 wi_read_prism2_result, &args); 401 p2->wi_rsvd = 0; 402 p2->wi_reason = args.i; 403 wreq.wi_len = (sizeof(*p2) + 404 sizeof(struct wi_scan_res) * args.i) / 2; 405 } else 406 error = EINPROGRESS; 407 break; 408 case WI_RID_READ_CACHE: { 409 struct wi_read_sigcache_args args; 410 args.i = 0; 411 args.wsc = (struct wi_sigcache *) wreq.wi_val; 412 args.max = (void *)(&wreq + 1); 413 ieee80211_iterate_nodes(&ic->ic_scan, wi_read_sigcache, &args); 414 wreq.wi_len = sizeof(struct wi_sigcache) * args.i / 2; 415 break; 416 } 417 default: 418 error = EINVAL; 419 break; 420 } 421 if (error == 0) { 422 wreq.wi_len++; 423 error = copyout(&wreq, ifr->ifr_data, sizeof(wreq)); 424 } 425 return error; 426 } 427 428 static int 429 findrate(struct ieee80211com *ic, enum ieee80211_phymode mode, int rate) 430 { 431 #define IEEERATE(_ic,_m,_i) \ 432 ((_ic)->ic_sup_rates[_m].rs_rates[_i] & IEEE80211_RATE_VAL) 433 int i, nrates = ic->ic_sup_rates[mode].rs_nrates; 434 for (i = 0; i < nrates; i++) 435 if (IEEERATE(ic, mode, i) == rate) 436 return i; 437 return -1; 438 #undef IEEERATE 439 } 440 441 /* 442 * Prepare to do a user-initiated scan for AP's. If no 443 * current/default channel is setup or the current channel 444 * is invalid then pick the first available channel from 445 * the active list as the place to start the scan. 446 */ 447 static int 448 ieee80211_setupscan(struct ieee80211com *ic, const u_int8_t chanlist[]) 449 { 450 int i; 451 452 /* 453 * XXX don't permit a scan to be started unless we 454 * know the device is ready. For the moment this means 455 * the device is marked up as this is the required to 456 * initialize the hardware. It would be better to permit 457 * scanning prior to being up but that'll require some 458 * changes to the infrastructure. 459 */ 460 if (!IS_UP(ic)) 461 return EINVAL; 462 if (ic->ic_ibss_chan == NULL || 463 isclr(chanlist, ieee80211_chan2ieee(ic, ic->ic_ibss_chan))) { 464 for (i = 0; i <= IEEE80211_CHAN_MAX; i++) 465 if (isset(chanlist, i)) { 466 ic->ic_ibss_chan = &ic->ic_channels[i]; 467 goto found; 468 } 469 return EINVAL; /* no active channels */ 470 found: 471 ; 472 } 473 if (ic->ic_bss->ni_chan == IEEE80211_CHAN_ANYC || 474 isclr(chanlist, ieee80211_chan2ieee(ic, ic->ic_bss->ni_chan))) 475 ic->ic_bss->ni_chan = ic->ic_ibss_chan; 476 memcpy(ic->ic_chan_active, chanlist, sizeof(ic->ic_chan_active)); 477 /* 478 * We force the state to INIT before calling ieee80211_new_state 479 * to get ieee80211_begin_scan called. We really want to scan w/o 480 * altering the current state but that's not possible right now. 481 */ 482 /* XXX handle proberequest case */ 483 ic->ic_state = IEEE80211_S_INIT; /* XXX bypass state machine */ 484 return 0; 485 } 486 487 int 488 ieee80211_cfgset(struct ieee80211com *ic, u_long cmd, caddr_t data) 489 { 490 struct ifnet *ifp = ic->ic_ifp; 491 int i, j, len, error, rate; 492 struct ifreq *ifr = (struct ifreq *)data; 493 struct wi_ltv_keys *keys; 494 struct wi_req wreq; 495 u_char chanlist[roundup(IEEE80211_CHAN_MAX, NBBY)]; 496 497 error = copyin(ifr->ifr_data, &wreq, sizeof(wreq)); 498 if (error) 499 return error; 500 len = wreq.wi_len ? (wreq.wi_len - 1) * 2 : 0; 501 switch (wreq.wi_type) { 502 case WI_RID_SERIALNO: 503 case WI_RID_NODENAME: 504 return EPERM; 505 case WI_RID_CURRENT_SSID: 506 return EPERM; 507 case WI_RID_OWN_SSID: 508 case WI_RID_DESIRED_SSID: 509 if (le16toh(wreq.wi_val[0]) * 2 > len || 510 le16toh(wreq.wi_val[0]) > IEEE80211_NWID_LEN) { 511 error = ENOSPC; 512 break; 513 } 514 memset(ic->ic_des_essid, 0, sizeof(ic->ic_des_essid)); 515 ic->ic_des_esslen = le16toh(wreq.wi_val[0]) * 2; 516 memcpy(ic->ic_des_essid, &wreq.wi_val[1], ic->ic_des_esslen); 517 error = ENETRESET; 518 break; 519 case WI_RID_CURRENT_BSSID: 520 return EPERM; 521 case WI_RID_OWN_CHNL: 522 if (len != 2) 523 return EINVAL; 524 i = le16toh(wreq.wi_val[0]); 525 if (i < 0 || 526 i > IEEE80211_CHAN_MAX || 527 isclr(ic->ic_chan_active, i)) 528 return EINVAL; 529 ic->ic_ibss_chan = &ic->ic_channels[i]; 530 if (ic->ic_opmode == IEEE80211_M_MONITOR) 531 error = IS_UP(ic) ? ic->ic_reset(ic->ic_ifp) : 0; 532 else 533 error = ENETRESET; 534 break; 535 case WI_RID_CURRENT_CHAN: 536 return EPERM; 537 case WI_RID_COMMS_QUALITY: 538 return EPERM; 539 case WI_RID_PROMISC: 540 if (len != 2) 541 return EINVAL; 542 if (ifp->if_flags & IFF_PROMISC) { 543 if (wreq.wi_val[0] == 0) { 544 ifp->if_flags &= ~IFF_PROMISC; 545 error = ENETRESET; 546 } 547 } else { 548 if (wreq.wi_val[0] != 0) { 549 ifp->if_flags |= IFF_PROMISC; 550 error = ENETRESET; 551 } 552 } 553 break; 554 case WI_RID_PORTTYPE: 555 if (len != 2) 556 return EINVAL; 557 switch (le16toh(wreq.wi_val[0])) { 558 case IEEE80211_M_STA: 559 break; 560 case IEEE80211_M_IBSS: 561 if (!(ic->ic_caps & IEEE80211_C_IBSS)) 562 return EINVAL; 563 break; 564 case IEEE80211_M_AHDEMO: 565 if (ic->ic_phytype != IEEE80211_T_DS || 566 !(ic->ic_caps & IEEE80211_C_AHDEMO)) 567 return EINVAL; 568 break; 569 case IEEE80211_M_HOSTAP: 570 if (!(ic->ic_caps & IEEE80211_C_HOSTAP)) 571 return EINVAL; 572 break; 573 default: 574 return EINVAL; 575 } 576 if (le16toh(wreq.wi_val[0]) != ic->ic_opmode) { 577 ic->ic_opmode = le16toh(wreq.wi_val[0]); 578 error = IS_UP(ic) ? ic->ic_reset(ic->ic_ifp) : 0; 579 } 580 break; 581 #if 0 582 case WI_RID_MAC_NODE: 583 if (len != IEEE80211_ADDR_LEN) 584 return EINVAL; 585 IEEE80211_ADDR_COPY(LLADDR(ifp->if_sadl), wreq.wi_val); 586 /* if_init will copy lladdr into ic_myaddr */ 587 error = ENETRESET; 588 break; 589 #endif 590 case WI_RID_TX_RATE: 591 if (len != 2) 592 return EINVAL; 593 if (wreq.wi_val[0] == 0) { 594 /* auto */ 595 ic->ic_fixed_rate = -1; 596 break; 597 } 598 rate = 2 * le16toh(wreq.wi_val[0]); 599 if (ic->ic_curmode == IEEE80211_MODE_AUTO) { 600 /* 601 * In autoselect mode search for the rate. We take 602 * the first instance which may not be right, but we 603 * are limited by the interface. Note that we also 604 * lock the mode to insure the rate is meaningful 605 * when it is used. 606 */ 607 for (j = IEEE80211_MODE_11A; 608 j < IEEE80211_MODE_MAX; j++) { 609 if ((ic->ic_modecaps & (1<<j)) == 0) 610 continue; 611 i = findrate(ic, j, rate); 612 if (i != -1) { 613 /* lock mode too */ 614 ic->ic_curmode = j; 615 goto setrate; 616 } 617 } 618 } else { 619 i = findrate(ic, ic->ic_curmode, rate); 620 if (i != -1) 621 goto setrate; 622 } 623 return EINVAL; 624 setrate: 625 ic->ic_fixed_rate = i; 626 error = IS_UP(ic) ? ic->ic_reset(ic->ic_ifp) : 0; 627 break; 628 case WI_RID_CUR_TX_RATE: 629 return EPERM; 630 case WI_RID_RTS_THRESH: 631 if (len != 2) 632 return EINVAL; 633 if (le16toh(wreq.wi_val[0]) != IEEE80211_MAX_LEN) 634 return EINVAL; /* TODO: RTS */ 635 break; 636 case WI_RID_CREATE_IBSS: 637 if (len != 2) 638 return EINVAL; 639 if (wreq.wi_val[0] != 0) { 640 if ((ic->ic_caps & IEEE80211_C_IBSS) == 0) 641 return EINVAL; 642 if ((ic->ic_flags & IEEE80211_F_IBSSON) == 0) { 643 ic->ic_flags |= IEEE80211_F_IBSSON; 644 if (ic->ic_opmode == IEEE80211_M_IBSS && 645 ic->ic_state == IEEE80211_S_SCAN) 646 error = IS_UP_AUTO(ic) ? ENETRESET : 0; 647 } 648 } else { 649 if (ic->ic_flags & IEEE80211_F_IBSSON) { 650 ic->ic_flags &= ~IEEE80211_F_IBSSON; 651 if (ic->ic_flags & IEEE80211_F_SIBSS) { 652 ic->ic_flags &= ~IEEE80211_F_SIBSS; 653 error = IS_UP_AUTO(ic) ? ENETRESET : 0; 654 } 655 } 656 } 657 break; 658 case WI_RID_MICROWAVE_OVEN: 659 if (len != 2) 660 return EINVAL; 661 if (wreq.wi_val[0] != 0) 662 return EINVAL; /* not supported */ 663 break; 664 case WI_RID_ROAMING_MODE: 665 if (len != 2) 666 return EINVAL; 667 i = le16toh(wreq.wi_val[0]); 668 if (i > IEEE80211_ROAMING_MANUAL) 669 return EINVAL; /* not supported */ 670 ic->ic_roaming = i; 671 break; 672 case WI_RID_SYSTEM_SCALE: 673 if (len != 2) 674 return EINVAL; 675 if (le16toh(wreq.wi_val[0]) != 1) 676 return EINVAL; /* not supported */ 677 break; 678 case WI_RID_PM_ENABLED: 679 if (len != 2) 680 return EINVAL; 681 if (wreq.wi_val[0] != 0) { 682 if ((ic->ic_caps & IEEE80211_C_PMGT) == 0) 683 return EINVAL; 684 if ((ic->ic_flags & IEEE80211_F_PMGTON) == 0) { 685 ic->ic_flags |= IEEE80211_F_PMGTON; 686 error = IS_UP(ic) ? ic->ic_reset(ic->ic_ifp) : 0; 687 } 688 } else { 689 if (ic->ic_flags & IEEE80211_F_PMGTON) { 690 ic->ic_flags &= ~IEEE80211_F_PMGTON; 691 error = IS_UP(ic) ? ic->ic_reset(ic->ic_ifp) : 0; 692 } 693 } 694 break; 695 case WI_RID_MAX_SLEEP: 696 if (len != 2) 697 return EINVAL; 698 ic->ic_lintval = le16toh(wreq.wi_val[0]); 699 if (ic->ic_flags & IEEE80211_F_PMGTON) 700 error = IS_UP(ic) ? ic->ic_reset(ic->ic_ifp) : 0; 701 break; 702 case WI_RID_CUR_BEACON_INT: 703 return EPERM; 704 case WI_RID_WEP_AVAIL: 705 return EPERM; 706 case WI_RID_CNFAUTHMODE: 707 if (len != 2) 708 return EINVAL; 709 i = le16toh(wreq.wi_val[0]); 710 if (i > IEEE80211_AUTH_WPA) 711 return EINVAL; 712 ic->ic_bss->ni_authmode = i; /* XXX ENETRESET? */ 713 error = ENETRESET; 714 break; 715 case WI_RID_ENCRYPTION: 716 if (len != 2) 717 return EINVAL; 718 if (wreq.wi_val[0] != 0) { 719 if ((ic->ic_caps & IEEE80211_C_WEP) == 0) 720 return EINVAL; 721 if ((ic->ic_flags & IEEE80211_F_PRIVACY) == 0) { 722 ic->ic_flags |= IEEE80211_F_PRIVACY; 723 error = ENETRESET; 724 } 725 } else { 726 if (ic->ic_flags & IEEE80211_F_PRIVACY) { 727 ic->ic_flags &= ~IEEE80211_F_PRIVACY; 728 error = ENETRESET; 729 } 730 } 731 break; 732 case WI_RID_TX_CRYPT_KEY: 733 if (len != 2) 734 return EINVAL; 735 i = le16toh(wreq.wi_val[0]); 736 if (i >= IEEE80211_WEP_NKID) 737 return EINVAL; 738 ic->ic_def_txkey = i; 739 error = IS_UP(ic) ? ic->ic_reset(ic->ic_ifp) : 0; 740 break; 741 case WI_RID_DEFLT_CRYPT_KEYS: 742 if (len != sizeof(struct wi_ltv_keys)) 743 return EINVAL; 744 keys = (struct wi_ltv_keys *)&wreq; 745 for (i = 0; i < IEEE80211_WEP_NKID; i++) { 746 len = le16toh(keys->wi_keys[i].wi_keylen); 747 if (len != 0 && len < IEEE80211_WEP_KEYLEN) 748 return EINVAL; 749 if (len > IEEE80211_KEYBUF_SIZE) 750 return EINVAL; 751 } 752 for (i = 0; i < IEEE80211_WEP_NKID; i++) { 753 struct ieee80211_key *k = &ic->ic_nw_keys[i]; 754 755 len = le16toh(keys->wi_keys[i].wi_keylen); 756 k->wk_keylen = len; 757 k->wk_flags = IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV; 758 memset(k->wk_key, 0, sizeof(k->wk_key)); 759 memcpy(k->wk_key, keys->wi_keys[i].wi_keydat, len); 760 #if 0 761 k->wk_type = IEEE80211_CIPHER_WEP; 762 #endif 763 } 764 error = ENETRESET; 765 break; 766 case WI_RID_MAX_DATALEN: 767 if (len != 2) 768 return EINVAL; 769 len = le16toh(wreq.wi_val[0]); 770 if (len < 350 /* ? */ || len > IEEE80211_MAX_LEN) 771 return EINVAL; 772 ic->ic_fragthreshold = len; 773 error = IS_UP(ic) ? ic->ic_reset(ic->ic_ifp) : 0; 774 break; 775 case WI_RID_IFACE_STATS: 776 error = EPERM; 777 break; 778 case WI_RID_SCAN_REQ: /* XXX wicontrol */ 779 if (ic->ic_opmode == IEEE80211_M_HOSTAP) 780 break; 781 error = ieee80211_setupscan(ic, ic->ic_chan_avail); 782 if (error == 0) 783 error = ieee80211_new_state(ic, IEEE80211_S_SCAN, -1); 784 break; 785 case WI_RID_SCAN_APS: 786 if (ic->ic_opmode == IEEE80211_M_HOSTAP) 787 break; 788 len--; /* XXX: tx rate? */ 789 /* FALLTHRU */ 790 case WI_RID_CHANNEL_LIST: 791 memset(chanlist, 0, sizeof(chanlist)); 792 /* 793 * Since channel 0 is not available for DS, channel 1 794 * is assigned to LSB on WaveLAN. 795 */ 796 if (ic->ic_phytype == IEEE80211_T_DS) 797 i = 1; 798 else 799 i = 0; 800 for (j = 0; i <= IEEE80211_CHAN_MAX; i++, j++) { 801 if ((j / 8) >= len) 802 break; 803 if (isclr((u_int8_t *)wreq.wi_val, j)) 804 continue; 805 if (isclr(ic->ic_chan_active, i)) { 806 if (wreq.wi_type != WI_RID_CHANNEL_LIST) 807 continue; 808 if (isclr(ic->ic_chan_avail, i)) 809 return EPERM; 810 } 811 setbit(chanlist, i); 812 } 813 error = ieee80211_setupscan(ic, chanlist); 814 if (wreq.wi_type == WI_RID_CHANNEL_LIST) { 815 /* NB: ignore error from ieee80211_setupscan */ 816 error = ENETRESET; 817 } else if (error == 0) 818 error = ieee80211_new_state(ic, IEEE80211_S_SCAN, -1); 819 break; 820 default: 821 error = EINVAL; 822 break; 823 } 824 if (error == ENETRESET && !IS_UP_AUTO(ic)) 825 error = 0; 826 return error; 827 } 828 829 static struct ieee80211_channel * 830 getcurchan(struct ieee80211com *ic) 831 { 832 switch (ic->ic_state) { 833 case IEEE80211_S_INIT: 834 case IEEE80211_S_SCAN: 835 return ic->ic_des_chan; 836 default: 837 return ic->ic_ibss_chan; 838 } 839 } 840 841 static int 842 cap2cipher(int flag) 843 { 844 switch (flag) { 845 case IEEE80211_C_WEP: return IEEE80211_CIPHER_WEP; 846 case IEEE80211_C_AES: return IEEE80211_CIPHER_AES_OCB; 847 case IEEE80211_C_AES_CCM: return IEEE80211_CIPHER_AES_CCM; 848 case IEEE80211_C_CKIP: return IEEE80211_CIPHER_CKIP; 849 case IEEE80211_C_TKIP: return IEEE80211_CIPHER_TKIP; 850 } 851 return -1; 852 } 853 854 static int 855 ieee80211_ioctl_getkey(struct ieee80211com *ic, struct ieee80211req *ireq) 856 { 857 struct ieee80211_node *ni; 858 struct ieee80211req_key ik; 859 struct ieee80211_key *wk; 860 const struct ieee80211_cipher *cip; 861 u_int kid; 862 int error; 863 864 if (ireq->i_len != sizeof(ik)) 865 return EINVAL; 866 error = copyin(ireq->i_data, &ik, sizeof(ik)); 867 if (error) 868 return error; 869 kid = ik.ik_keyix; 870 if (kid == IEEE80211_KEYIX_NONE) { 871 ni = ieee80211_find_node(&ic->ic_sta, ik.ik_macaddr); 872 if (ni == NULL) 873 return EINVAL; /* XXX */ 874 wk = &ni->ni_ucastkey; 875 } else { 876 if (kid >= IEEE80211_WEP_NKID) 877 return EINVAL; 878 wk = &ic->ic_nw_keys[kid]; 879 IEEE80211_ADDR_COPY(&ik.ik_macaddr, ic->ic_bss->ni_macaddr); 880 ni = NULL; 881 } 882 cip = wk->wk_cipher; 883 ik.ik_type = cip->ic_cipher; 884 ik.ik_keylen = wk->wk_keylen; 885 ik.ik_flags = wk->wk_flags & (IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV); 886 if (wk->wk_keyix == ic->ic_def_txkey) 887 ik.ik_flags |= IEEE80211_KEY_DEFAULT; 888 if (suser(curthread) == 0) { 889 /* NB: only root can read key data */ 890 ik.ik_keyrsc = wk->wk_keyrsc; 891 ik.ik_keytsc = wk->wk_keytsc; 892 memcpy(ik.ik_keydata, wk->wk_key, wk->wk_keylen); 893 if (cip->ic_cipher == IEEE80211_CIPHER_TKIP) { 894 memcpy(ik.ik_keydata+wk->wk_keylen, 895 wk->wk_key + IEEE80211_KEYBUF_SIZE, 896 IEEE80211_MICBUF_SIZE); 897 ik.ik_keylen += IEEE80211_MICBUF_SIZE; 898 } 899 } else { 900 ik.ik_keyrsc = 0; 901 ik.ik_keytsc = 0; 902 memset(ik.ik_keydata, 0, sizeof(ik.ik_keydata)); 903 } 904 if (ni != NULL) 905 ieee80211_free_node(ni); 906 return copyout(&ik, ireq->i_data, sizeof(ik)); 907 } 908 909 static int 910 ieee80211_ioctl_getchanlist(struct ieee80211com *ic, struct ieee80211req *ireq) 911 { 912 913 if (sizeof(ic->ic_chan_active) > ireq->i_len) 914 ireq->i_len = sizeof(ic->ic_chan_active); 915 return copyout(&ic->ic_chan_active, ireq->i_data, ireq->i_len); 916 } 917 918 static int 919 ieee80211_ioctl_getchaninfo(struct ieee80211com *ic, struct ieee80211req *ireq) 920 { 921 struct ieee80211req_chaninfo chans; /* XXX off stack? */ 922 int i, space; 923 924 /* 925 * Since channel 0 is not available for DS, channel 1 926 * is assigned to LSB on WaveLAN. 927 */ 928 if (ic->ic_phytype == IEEE80211_T_DS) 929 i = 1; 930 else 931 i = 0; 932 memset(&chans, 0, sizeof(chans)); 933 for (; i <= IEEE80211_CHAN_MAX; i++) 934 if (isset(ic->ic_chan_avail, i)) { 935 struct ieee80211_channel *c = &ic->ic_channels[i]; 936 chans.ic_chans[chans.ic_nchans].ic_freq = c->ic_freq; 937 chans.ic_chans[chans.ic_nchans].ic_flags = c->ic_flags; 938 chans.ic_nchans++; 939 } 940 space = __offsetof(struct ieee80211req_chaninfo, 941 ic_chans[chans.ic_nchans]); 942 if (space > ireq->i_len) 943 space = ireq->i_len; 944 return copyout(&chans, ireq->i_data, space); 945 } 946 947 static int 948 ieee80211_ioctl_getwpaie(struct ieee80211com *ic, struct ieee80211req *ireq) 949 { 950 struct ieee80211_node *ni; 951 struct ieee80211req_wpaie wpaie; 952 int error; 953 954 if (ireq->i_len < IEEE80211_ADDR_LEN) 955 return EINVAL; 956 error = copyin(ireq->i_data, wpaie.wpa_macaddr, IEEE80211_ADDR_LEN); 957 if (error != 0) 958 return error; 959 ni = ieee80211_find_node(&ic->ic_sta, wpaie.wpa_macaddr); 960 if (ni == NULL) 961 return EINVAL; /* XXX */ 962 memset(wpaie.wpa_ie, 0, sizeof(wpaie.wpa_ie)); 963 if (ni->ni_wpa_ie != NULL) { 964 int ielen = ni->ni_wpa_ie[1] + 2; 965 if (ielen > sizeof(wpaie.wpa_ie)) 966 ielen = sizeof(wpaie.wpa_ie); 967 memcpy(wpaie.wpa_ie, ni->ni_wpa_ie, ielen); 968 } 969 ieee80211_free_node(ni); 970 if (ireq->i_len > sizeof(wpaie)) 971 ireq->i_len = sizeof(wpaie); 972 return copyout(&wpaie, ireq->i_data, ireq->i_len); 973 } 974 975 static int 976 ieee80211_ioctl_getstastats(struct ieee80211com *ic, struct ieee80211req *ireq) 977 { 978 struct ieee80211_node *ni; 979 u_int8_t macaddr[IEEE80211_ADDR_LEN]; 980 const int off = __offsetof(struct ieee80211req_sta_stats, is_stats); 981 int error; 982 983 if (ireq->i_len < off) 984 return EINVAL; 985 error = copyin(ireq->i_data, macaddr, IEEE80211_ADDR_LEN); 986 if (error != 0) 987 return error; 988 ni = ieee80211_find_node(&ic->ic_sta, macaddr); 989 if (ni == NULL) 990 return EINVAL; /* XXX */ 991 if (ireq->i_len > sizeof(struct ieee80211req_sta_stats)) 992 ireq->i_len = sizeof(struct ieee80211req_sta_stats); 993 /* NB: copy out only the statistics */ 994 error = copyout(&ni->ni_stats, (u_int8_t *) ireq->i_data + off, 995 ireq->i_len - off); 996 ieee80211_free_node(ni); 997 return error; 998 } 999 1000 static void 1001 get_scan_result(struct ieee80211req_scan_result *sr, 1002 const struct ieee80211_node *ni) 1003 { 1004 struct ieee80211com *ic = ni->ni_ic; 1005 1006 memset(sr, 0, sizeof(*sr)); 1007 sr->isr_ssid_len = ni->ni_esslen; 1008 if (ni->ni_wpa_ie != NULL) 1009 sr->isr_ie_len += 2+ni->ni_wpa_ie[1]; 1010 if (ni->ni_wme_ie != NULL) 1011 sr->isr_ie_len += 2+ni->ni_wme_ie[1]; 1012 sr->isr_len = sizeof(*sr) + sr->isr_ssid_len + sr->isr_ie_len; 1013 sr->isr_len = roundup(sr->isr_len, sizeof(u_int32_t)); 1014 if (ni->ni_chan != IEEE80211_CHAN_ANYC) { 1015 sr->isr_freq = ni->ni_chan->ic_freq; 1016 sr->isr_flags = ni->ni_chan->ic_flags; 1017 } 1018 sr->isr_rssi = ic->ic_node_getrssi(ni); 1019 sr->isr_intval = ni->ni_intval; 1020 sr->isr_capinfo = ni->ni_capinfo; 1021 sr->isr_erp = ni->ni_erp; 1022 IEEE80211_ADDR_COPY(sr->isr_bssid, ni->ni_bssid); 1023 sr->isr_nrates = ni->ni_rates.rs_nrates; 1024 if (sr->isr_nrates > 15) 1025 sr->isr_nrates = 15; 1026 memcpy(sr->isr_rates, ni->ni_rates.rs_rates, sr->isr_nrates); 1027 } 1028 1029 static int 1030 ieee80211_ioctl_getscanresults(struct ieee80211com *ic, struct ieee80211req *ireq) 1031 { 1032 union { 1033 struct ieee80211req_scan_result res; 1034 char data[512]; /* XXX shrink? */ 1035 } u; 1036 struct ieee80211req_scan_result *sr = &u.res; 1037 struct ieee80211_node_table *nt; 1038 struct ieee80211_node *ni; 1039 int error, space; 1040 u_int8_t *p, *cp; 1041 1042 p = ireq->i_data; 1043 space = ireq->i_len; 1044 error = 0; 1045 /* XXX locking */ 1046 nt = &ic->ic_scan; 1047 TAILQ_FOREACH(ni, &nt->nt_node, ni_list) { 1048 /* NB: skip pre-scan node state */ 1049 if (ni->ni_chan == IEEE80211_CHAN_ANYC) 1050 continue; 1051 get_scan_result(sr, ni); 1052 if (sr->isr_len > sizeof(u)) 1053 continue; /* XXX */ 1054 if (space < sr->isr_len) 1055 break; 1056 cp = (u_int8_t *)(sr+1); 1057 memcpy(cp, ni->ni_essid, ni->ni_esslen); 1058 cp += ni->ni_esslen; 1059 if (ni->ni_wpa_ie != NULL) { 1060 memcpy(cp, ni->ni_wpa_ie, 2+ni->ni_wpa_ie[1]); 1061 cp += 2+ni->ni_wpa_ie[1]; 1062 } 1063 if (ni->ni_wme_ie != NULL) { 1064 memcpy(cp, ni->ni_wme_ie, 2+ni->ni_wme_ie[1]); 1065 cp += 2+ni->ni_wme_ie[1]; 1066 } 1067 error = copyout(sr, p, sr->isr_len); 1068 if (error) 1069 break; 1070 p += sr->isr_len; 1071 space -= sr->isr_len; 1072 } 1073 ireq->i_len -= space; 1074 return error; 1075 } 1076 1077 static void 1078 get_sta_info(struct ieee80211req_sta_info *si, const struct ieee80211_node *ni) 1079 { 1080 struct ieee80211com *ic = ni->ni_ic; 1081 1082 si->isi_ie_len = 0; 1083 if (ni->ni_wpa_ie != NULL) 1084 si->isi_ie_len += 2+ni->ni_wpa_ie[1]; 1085 if (ni->ni_wme_ie != NULL) 1086 si->isi_ie_len += 2+ni->ni_wme_ie[1]; 1087 si->isi_len = sizeof(*si) + si->isi_ie_len, sizeof(u_int32_t); 1088 si->isi_len = roundup(si->isi_len, sizeof(u_int32_t)); 1089 si->isi_freq = ni->ni_chan->ic_freq; 1090 si->isi_flags = ni->ni_chan->ic_flags; 1091 si->isi_state = ni->ni_flags; 1092 si->isi_authmode = ni->ni_authmode; 1093 si->isi_rssi = ic->ic_node_getrssi(ni); 1094 si->isi_capinfo = ni->ni_capinfo; 1095 si->isi_erp = ni->ni_erp; 1096 IEEE80211_ADDR_COPY(si->isi_macaddr, ni->ni_macaddr); 1097 si->isi_nrates = ni->ni_rates.rs_nrates; 1098 if (si->isi_nrates > 15) 1099 si->isi_nrates = 15; 1100 memcpy(si->isi_rates, ni->ni_rates.rs_rates, si->isi_nrates); 1101 si->isi_txrate = ni->ni_txrate; 1102 si->isi_associd = ni->ni_associd; 1103 si->isi_txpower = ni->ni_txpower; 1104 si->isi_vlan = ni->ni_vlan; 1105 if (ni->ni_flags & IEEE80211_NODE_QOS) { 1106 memcpy(si->isi_txseqs, ni->ni_txseqs, sizeof(ni->ni_txseqs)); 1107 memcpy(si->isi_rxseqs, ni->ni_rxseqs, sizeof(ni->ni_rxseqs)); 1108 } else { 1109 si->isi_txseqs[0] = ni->ni_txseqs[0]; 1110 si->isi_rxseqs[0] = ni->ni_rxseqs[0]; 1111 } 1112 if (ic->ic_opmode == IEEE80211_M_IBSS || ni->ni_associd != 0) 1113 si->isi_inact = ic->ic_inact_run; 1114 else if (ieee80211_node_is_authorized(ni)) 1115 si->isi_inact = ic->ic_inact_auth; 1116 else 1117 si->isi_inact = ic->ic_inact_init; 1118 si->isi_inact = (si->isi_inact - ni->ni_inact) * IEEE80211_INACT_WAIT; 1119 } 1120 1121 static int 1122 ieee80211_ioctl_getstainfo(struct ieee80211com *ic, struct ieee80211req *ireq) 1123 { 1124 union { 1125 struct ieee80211req_sta_info info; 1126 char data[512]; /* XXX shrink? */ 1127 } u; 1128 struct ieee80211req_sta_info *si = &u.info; 1129 struct ieee80211_node_table *nt; 1130 struct ieee80211_node *ni; 1131 int error, space; 1132 u_int8_t *p, *cp; 1133 1134 nt = &ic->ic_sta; 1135 p = ireq->i_data; 1136 space = ireq->i_len; 1137 error = 0; 1138 /* XXX locking */ 1139 TAILQ_FOREACH(ni, &nt->nt_node, ni_list) { 1140 get_sta_info(si, ni); 1141 if (si->isi_len > sizeof(u)) 1142 continue; /* XXX */ 1143 if (space < si->isi_len) 1144 break; 1145 cp = (u_int8_t *)(si+1); 1146 if (ni->ni_wpa_ie != NULL) { 1147 memcpy(cp, ni->ni_wpa_ie, 2+ni->ni_wpa_ie[1]); 1148 cp += 2+ni->ni_wpa_ie[1]; 1149 } 1150 if (ni->ni_wme_ie != NULL) { 1151 memcpy(cp, ni->ni_wme_ie, 2+ni->ni_wme_ie[1]); 1152 cp += 2+ni->ni_wme_ie[1]; 1153 } 1154 error = copyout(si, p, si->isi_len); 1155 if (error) 1156 break; 1157 p += si->isi_len; 1158 space -= si->isi_len; 1159 } 1160 ireq->i_len -= space; 1161 return error; 1162 } 1163 1164 static int 1165 ieee80211_ioctl_getstatxpow(struct ieee80211com *ic, struct ieee80211req *ireq) 1166 { 1167 struct ieee80211_node *ni; 1168 struct ieee80211req_sta_txpow txpow; 1169 int error; 1170 1171 if (ireq->i_len != sizeof(txpow)) 1172 return EINVAL; 1173 error = copyin(ireq->i_data, &txpow, sizeof(txpow)); 1174 if (error != 0) 1175 return error; 1176 ni = ieee80211_find_node(&ic->ic_sta, txpow.it_macaddr); 1177 if (ni == NULL) 1178 return EINVAL; /* XXX */ 1179 txpow.it_txpow = ni->ni_txpower; 1180 error = copyout(&txpow, ireq->i_data, sizeof(txpow)); 1181 ieee80211_free_node(ni); 1182 return error; 1183 } 1184 1185 static int 1186 ieee80211_ioctl_getwmeparam(struct ieee80211com *ic, struct ieee80211req *ireq) 1187 { 1188 struct ieee80211_wme_state *wme = &ic->ic_wme; 1189 struct wmeParams *wmep; 1190 int ac; 1191 1192 if ((ic->ic_caps & IEEE80211_C_WME) == 0) 1193 return EINVAL; 1194 1195 ac = (ireq->i_len & IEEE80211_WMEPARAM_VAL); 1196 if (ac >= WME_NUM_AC) 1197 ac = WME_AC_BE; 1198 if (ireq->i_len & IEEE80211_WMEPARAM_BSS) 1199 wmep = &wme->wme_wmeBssChanParams.cap_wmeParams[ac]; 1200 else 1201 wmep = &wme->wme_wmeChanParams.cap_wmeParams[ac]; 1202 switch (ireq->i_type) { 1203 case IEEE80211_IOC_WME_CWMIN: /* WME: CWmin */ 1204 ireq->i_val = wmep->wmep_logcwmin; 1205 break; 1206 case IEEE80211_IOC_WME_CWMAX: /* WME: CWmax */ 1207 ireq->i_val = wmep->wmep_logcwmax; 1208 break; 1209 case IEEE80211_IOC_WME_AIFS: /* WME: AIFS */ 1210 ireq->i_val = wmep->wmep_aifsn; 1211 break; 1212 case IEEE80211_IOC_WME_TXOPLIMIT: /* WME: txops limit */ 1213 ireq->i_val = wmep->wmep_txopLimit; 1214 break; 1215 case IEEE80211_IOC_WME_ACM: /* WME: ACM (bss only) */ 1216 wmep = &wme->wme_wmeBssChanParams.cap_wmeParams[ac]; 1217 ireq->i_val = wmep->wmep_acm; 1218 break; 1219 case IEEE80211_IOC_WME_ACKPOLICY: /* WME: ACK policy (!bss only)*/ 1220 wmep = &wme->wme_wmeChanParams.cap_wmeParams[ac]; 1221 ireq->i_val = !wmep->wmep_noackPolicy; 1222 break; 1223 } 1224 return 0; 1225 } 1226 1227 /* 1228 * When building the kernel with -O2 on the i386 architecture, gcc 1229 * seems to want to inline this function into ieee80211_ioctl() 1230 * (which is the only routine that calls it). When this happens, 1231 * ieee80211_ioctl() ends up consuming an additional 2K of stack 1232 * space. (Exactly why it needs so much is unclear.) The problem 1233 * is that it's possible for ieee80211_ioctl() to invoke other 1234 * routines (including driver init functions) which could then find 1235 * themselves perilously close to exhausting the stack. 1236 * 1237 * To avoid this, we deliberately prevent gcc from inlining this 1238 * routine. Another way to avoid this is to use less agressive 1239 * optimization when compiling this file (i.e. -O instead of -O2) 1240 * but special-casing the compilation of this one module in the 1241 * build system would be awkward. 1242 */ 1243 #ifdef __GNUC__ 1244 __attribute__ ((noinline)) 1245 #endif 1246 static int 1247 ieee80211_ioctl_get80211(struct ieee80211com *ic, u_long cmd, struct ieee80211req *ireq) 1248 { 1249 const struct ieee80211_rsnparms *rsn = &ic->ic_bss->ni_rsn; 1250 int error = 0; 1251 u_int kid, len, m; 1252 u_int8_t tmpkey[IEEE80211_KEYBUF_SIZE]; 1253 char tmpssid[IEEE80211_NWID_LEN]; 1254 1255 switch (ireq->i_type) { 1256 case IEEE80211_IOC_SSID: 1257 switch (ic->ic_state) { 1258 case IEEE80211_S_INIT: 1259 case IEEE80211_S_SCAN: 1260 ireq->i_len = ic->ic_des_esslen; 1261 memcpy(tmpssid, ic->ic_des_essid, ireq->i_len); 1262 break; 1263 default: 1264 ireq->i_len = ic->ic_bss->ni_esslen; 1265 memcpy(tmpssid, ic->ic_bss->ni_essid, 1266 ireq->i_len); 1267 break; 1268 } 1269 error = copyout(tmpssid, ireq->i_data, ireq->i_len); 1270 break; 1271 case IEEE80211_IOC_NUMSSIDS: 1272 ireq->i_val = 1; 1273 break; 1274 case IEEE80211_IOC_WEP: 1275 if ((ic->ic_flags & IEEE80211_F_PRIVACY) == 0) 1276 ireq->i_val = IEEE80211_WEP_OFF; 1277 else if (ic->ic_flags & IEEE80211_F_DROPUNENC) 1278 ireq->i_val = IEEE80211_WEP_ON; 1279 else 1280 ireq->i_val = IEEE80211_WEP_MIXED; 1281 break; 1282 case IEEE80211_IOC_WEPKEY: 1283 kid = (u_int) ireq->i_val; 1284 if (kid >= IEEE80211_WEP_NKID) 1285 return EINVAL; 1286 len = (u_int) ic->ic_nw_keys[kid].wk_keylen; 1287 /* NB: only root can read WEP keys */ 1288 if (suser(curthread) == 0) { 1289 bcopy(ic->ic_nw_keys[kid].wk_key, tmpkey, len); 1290 } else { 1291 bzero(tmpkey, len); 1292 } 1293 ireq->i_len = len; 1294 error = copyout(tmpkey, ireq->i_data, len); 1295 break; 1296 case IEEE80211_IOC_NUMWEPKEYS: 1297 ireq->i_val = IEEE80211_WEP_NKID; 1298 break; 1299 case IEEE80211_IOC_WEPTXKEY: 1300 ireq->i_val = ic->ic_def_txkey; 1301 break; 1302 case IEEE80211_IOC_AUTHMODE: 1303 if (ic->ic_flags & IEEE80211_F_WPA) 1304 ireq->i_val = IEEE80211_AUTH_WPA; 1305 else 1306 ireq->i_val = ic->ic_bss->ni_authmode; 1307 break; 1308 case IEEE80211_IOC_CHANNEL: 1309 ireq->i_val = ieee80211_chan2ieee(ic, getcurchan(ic)); 1310 break; 1311 case IEEE80211_IOC_POWERSAVE: 1312 if (ic->ic_flags & IEEE80211_F_PMGTON) 1313 ireq->i_val = IEEE80211_POWERSAVE_ON; 1314 else 1315 ireq->i_val = IEEE80211_POWERSAVE_OFF; 1316 break; 1317 case IEEE80211_IOC_POWERSAVESLEEP: 1318 ireq->i_val = ic->ic_lintval; 1319 break; 1320 case IEEE80211_IOC_RTSTHRESHOLD: 1321 ireq->i_val = ic->ic_rtsthreshold; 1322 break; 1323 case IEEE80211_IOC_PROTMODE: 1324 ireq->i_val = ic->ic_protmode; 1325 break; 1326 case IEEE80211_IOC_TXPOWER: 1327 if ((ic->ic_caps & IEEE80211_C_TXPMGT) == 0) 1328 return EINVAL; 1329 ireq->i_val = ic->ic_txpowlimit; 1330 break; 1331 case IEEE80211_IOC_MCASTCIPHER: 1332 ireq->i_val = rsn->rsn_mcastcipher; 1333 break; 1334 case IEEE80211_IOC_MCASTKEYLEN: 1335 ireq->i_val = rsn->rsn_mcastkeylen; 1336 break; 1337 case IEEE80211_IOC_UCASTCIPHERS: 1338 ireq->i_val = 0; 1339 for (m = 0x1; m != 0; m <<= 1) 1340 if (rsn->rsn_ucastcipherset & m) 1341 ireq->i_val |= 1<<cap2cipher(m); 1342 break; 1343 case IEEE80211_IOC_UCASTCIPHER: 1344 ireq->i_val = rsn->rsn_ucastcipher; 1345 break; 1346 case IEEE80211_IOC_UCASTKEYLEN: 1347 ireq->i_val = rsn->rsn_ucastkeylen; 1348 break; 1349 case IEEE80211_IOC_KEYMGTALGS: 1350 ireq->i_val = rsn->rsn_keymgmtset; 1351 break; 1352 case IEEE80211_IOC_RSNCAPS: 1353 ireq->i_val = rsn->rsn_caps; 1354 break; 1355 case IEEE80211_IOC_WPA: 1356 switch (ic->ic_flags & IEEE80211_F_WPA) { 1357 case IEEE80211_F_WPA1: 1358 ireq->i_val = 1; 1359 break; 1360 case IEEE80211_F_WPA2: 1361 ireq->i_val = 2; 1362 break; 1363 case IEEE80211_F_WPA1 | IEEE80211_F_WPA2: 1364 ireq->i_val = 3; 1365 break; 1366 default: 1367 ireq->i_val = 0; 1368 break; 1369 } 1370 break; 1371 case IEEE80211_IOC_CHANLIST: 1372 error = ieee80211_ioctl_getchanlist(ic, ireq); 1373 break; 1374 case IEEE80211_IOC_ROAMING: 1375 ireq->i_val = ic->ic_roaming; 1376 break; 1377 case IEEE80211_IOC_PRIVACY: 1378 ireq->i_val = (ic->ic_flags & IEEE80211_F_PRIVACY) != 0; 1379 break; 1380 case IEEE80211_IOC_DROPUNENCRYPTED: 1381 ireq->i_val = (ic->ic_flags & IEEE80211_F_DROPUNENC) != 0; 1382 break; 1383 case IEEE80211_IOC_COUNTERMEASURES: 1384 ireq->i_val = (ic->ic_flags & IEEE80211_F_COUNTERM) != 0; 1385 break; 1386 case IEEE80211_IOC_DRIVER_CAPS: 1387 ireq->i_val = ic->ic_caps>>16; 1388 ireq->i_len = ic->ic_caps&0xffff; 1389 break; 1390 case IEEE80211_IOC_WME: 1391 ireq->i_val = (ic->ic_flags & IEEE80211_F_WME) != 0; 1392 break; 1393 case IEEE80211_IOC_HIDESSID: 1394 ireq->i_val = (ic->ic_flags & IEEE80211_F_HIDESSID) != 0; 1395 break; 1396 case IEEE80211_IOC_APBRIDGE: 1397 ireq->i_val = (ic->ic_flags & IEEE80211_F_NOBRIDGE) == 0; 1398 break; 1399 case IEEE80211_IOC_OPTIE: 1400 if (ic->ic_opt_ie == NULL) 1401 return EINVAL; 1402 /* NB: truncate, caller can check length */ 1403 if (ireq->i_len > ic->ic_opt_ie_len) 1404 ireq->i_len = ic->ic_opt_ie_len; 1405 error = copyout(ic->ic_opt_ie, ireq->i_data, ireq->i_len); 1406 break; 1407 case IEEE80211_IOC_WPAKEY: 1408 error = ieee80211_ioctl_getkey(ic, ireq); 1409 break; 1410 case IEEE80211_IOC_CHANINFO: 1411 error = ieee80211_ioctl_getchaninfo(ic, ireq); 1412 break; 1413 case IEEE80211_IOC_BSSID: 1414 if (ireq->i_len != IEEE80211_ADDR_LEN) 1415 return EINVAL; 1416 error = copyout(ic->ic_state == IEEE80211_S_RUN ? 1417 ic->ic_bss->ni_bssid : 1418 ic->ic_des_bssid, 1419 ireq->i_data, ireq->i_len); 1420 break; 1421 case IEEE80211_IOC_WPAIE: 1422 error = ieee80211_ioctl_getwpaie(ic, ireq); 1423 break; 1424 case IEEE80211_IOC_SCAN_RESULTS: 1425 error = ieee80211_ioctl_getscanresults(ic, ireq); 1426 break; 1427 case IEEE80211_IOC_STA_STATS: 1428 error = ieee80211_ioctl_getstastats(ic, ireq); 1429 break; 1430 case IEEE80211_IOC_TXPOWMAX: 1431 ireq->i_val = ic->ic_bss->ni_txpower; 1432 break; 1433 case IEEE80211_IOC_STA_TXPOW: 1434 error = ieee80211_ioctl_getstatxpow(ic, ireq); 1435 break; 1436 case IEEE80211_IOC_STA_INFO: 1437 error = ieee80211_ioctl_getstainfo(ic, ireq); 1438 break; 1439 case IEEE80211_IOC_WME_CWMIN: /* WME: CWmin */ 1440 case IEEE80211_IOC_WME_CWMAX: /* WME: CWmax */ 1441 case IEEE80211_IOC_WME_AIFS: /* WME: AIFS */ 1442 case IEEE80211_IOC_WME_TXOPLIMIT: /* WME: txops limit */ 1443 case IEEE80211_IOC_WME_ACM: /* WME: ACM (bss only) */ 1444 case IEEE80211_IOC_WME_ACKPOLICY: /* WME: ACK policy (bss only) */ 1445 error = ieee80211_ioctl_getwmeparam(ic, ireq); 1446 break; 1447 case IEEE80211_IOC_DTIM_PERIOD: 1448 ireq->i_val = ic->ic_dtim_period; 1449 break; 1450 case IEEE80211_IOC_BEACON_INTERVAL: 1451 /* NB: get from ic_bss for station mode */ 1452 ireq->i_val = ic->ic_bss->ni_intval; 1453 break; 1454 case IEEE80211_IOC_PUREG: 1455 ireq->i_val = (ic->ic_flags & IEEE80211_F_PUREG) != 0; 1456 break; 1457 default: 1458 error = EINVAL; 1459 break; 1460 } 1461 return error; 1462 } 1463 1464 static int 1465 ieee80211_ioctl_setoptie(struct ieee80211com *ic, struct ieee80211req *ireq) 1466 { 1467 int error; 1468 void *ie; 1469 1470 /* 1471 * NB: Doing this for ap operation could be useful (e.g. for 1472 * WPA and/or WME) except that it typically is worthless 1473 * without being able to intervene when processing 1474 * association response frames--so disallow it for now. 1475 */ 1476 if (ic->ic_opmode != IEEE80211_M_STA) 1477 return EINVAL; 1478 if (ireq->i_len > IEEE80211_MAX_OPT_IE) 1479 return EINVAL; 1480 /* NB: data.length is validated by the wireless extensions code */ 1481 MALLOC(ie, void *, ireq->i_len, M_DEVBUF, M_WAITOK); 1482 if (ie == NULL) 1483 return ENOMEM; 1484 error = copyin(ireq->i_data, ie, ireq->i_len); 1485 /* XXX sanity check data? */ 1486 if (ic->ic_opt_ie != NULL) 1487 FREE(ic->ic_opt_ie, M_DEVBUF); 1488 ic->ic_opt_ie = ie; 1489 ic->ic_opt_ie_len = ireq->i_len; 1490 return 0; 1491 } 1492 1493 static int 1494 ieee80211_ioctl_setkey(struct ieee80211com *ic, struct ieee80211req *ireq) 1495 { 1496 struct ieee80211req_key ik; 1497 struct ieee80211_node *ni; 1498 struct ieee80211_key *wk; 1499 u_int16_t kid; 1500 int error; 1501 1502 if (ireq->i_len != sizeof(ik)) 1503 return EINVAL; 1504 error = copyin(ireq->i_data, &ik, sizeof(ik)); 1505 if (error) 1506 return error; 1507 /* NB: cipher support is verified by ieee80211_crypt_newkey */ 1508 /* NB: this also checks ik->ik_keylen > sizeof(wk->wk_key) */ 1509 if (ik.ik_keylen > sizeof(ik.ik_keydata)) 1510 return E2BIG; 1511 kid = ik.ik_keyix; 1512 if (kid == IEEE80211_KEYIX_NONE) { 1513 /* XXX unicast keys currently must be tx/rx */ 1514 if (ik.ik_flags != (IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV)) 1515 return EINVAL; 1516 if (ic->ic_opmode == IEEE80211_M_STA) { 1517 ni = ieee80211_ref_node(ic->ic_bss); 1518 if (!IEEE80211_ADDR_EQ(ik.ik_macaddr, ni->ni_bssid)) { 1519 ieee80211_free_node(ni); 1520 return EADDRNOTAVAIL; 1521 } 1522 } else { 1523 ni = ieee80211_find_node(&ic->ic_sta, ik.ik_macaddr); 1524 if (ni == NULL) 1525 return ENOENT; 1526 } 1527 wk = &ni->ni_ucastkey; 1528 } else { 1529 if (kid >= IEEE80211_WEP_NKID) 1530 return EINVAL; 1531 wk = &ic->ic_nw_keys[kid]; 1532 ni = NULL; 1533 } 1534 error = 0; 1535 ieee80211_key_update_begin(ic); 1536 if (ieee80211_crypto_newkey(ic, ik.ik_type, ik.ik_flags, wk)) { 1537 wk->wk_keylen = ik.ik_keylen; 1538 /* NB: MIC presence is implied by cipher type */ 1539 if (wk->wk_keylen > IEEE80211_KEYBUF_SIZE) 1540 wk->wk_keylen = IEEE80211_KEYBUF_SIZE; 1541 wk->wk_keyrsc = ik.ik_keyrsc; 1542 wk->wk_keytsc = 0; /* new key, reset */ 1543 memset(wk->wk_key, 0, sizeof(wk->wk_key)); 1544 memcpy(wk->wk_key, ik.ik_keydata, ik.ik_keylen); 1545 if (!ieee80211_crypto_setkey(ic, wk, 1546 ni != NULL ? ni->ni_macaddr : ik.ik_macaddr)) 1547 error = EIO; 1548 else if ((ik.ik_flags & IEEE80211_KEY_DEFAULT)) 1549 ic->ic_def_txkey = kid; 1550 } else 1551 error = ENXIO; 1552 ieee80211_key_update_end(ic); 1553 if (ni != NULL) 1554 ieee80211_free_node(ni); 1555 return error; 1556 } 1557 1558 static int 1559 ieee80211_ioctl_delkey(struct ieee80211com *ic, struct ieee80211req *ireq) 1560 { 1561 struct ieee80211req_del_key dk; 1562 int kid, error; 1563 1564 if (ireq->i_len != sizeof(dk)) 1565 return EINVAL; 1566 error = copyin(ireq->i_data, &dk, sizeof(dk)); 1567 if (error) 1568 return error; 1569 kid = dk.idk_keyix; 1570 /* XXX u_int8_t -> u_int16_t */ 1571 if (dk.idk_keyix == (u_int8_t) IEEE80211_KEYIX_NONE) { 1572 struct ieee80211_node *ni; 1573 1574 if (ic->ic_opmode == IEEE80211_M_STA) { 1575 ni = ieee80211_ref_node(ic->ic_bss); 1576 if (!IEEE80211_ADDR_EQ(dk.idk_macaddr, ni->ni_bssid)) { 1577 ieee80211_free_node(ni); 1578 return EADDRNOTAVAIL; 1579 } 1580 } else { 1581 ni = ieee80211_find_node(&ic->ic_sta, dk.idk_macaddr); 1582 if (ni == NULL) 1583 return ENOENT; 1584 } 1585 /* XXX error return */ 1586 ieee80211_crypto_delkey(ic, &ni->ni_ucastkey); 1587 ieee80211_free_node(ni); 1588 } else { 1589 if (kid >= IEEE80211_WEP_NKID) 1590 return EINVAL; 1591 /* XXX error return */ 1592 ieee80211_crypto_delkey(ic, &ic->ic_nw_keys[kid]); 1593 } 1594 return 0; 1595 } 1596 1597 static void 1598 domlme(void *arg, struct ieee80211_node *ni) 1599 { 1600 struct ieee80211com *ic = ni->ni_ic; 1601 struct ieee80211req_mlme *mlme = arg; 1602 1603 if (ni->ni_associd != 0) { 1604 IEEE80211_SEND_MGMT(ic, ni, 1605 mlme->im_op == IEEE80211_MLME_DEAUTH ? 1606 IEEE80211_FC0_SUBTYPE_DEAUTH : 1607 IEEE80211_FC0_SUBTYPE_DISASSOC, 1608 mlme->im_reason); 1609 } 1610 ieee80211_node_leave(ic, ni); 1611 } 1612 1613 static int 1614 ieee80211_ioctl_setmlme(struct ieee80211com *ic, struct ieee80211req *ireq) 1615 { 1616 struct ieee80211req_mlme mlme; 1617 struct ieee80211_node *ni; 1618 int error; 1619 1620 if (ireq->i_len != sizeof(mlme)) 1621 return EINVAL; 1622 error = copyin(ireq->i_data, &mlme, sizeof(mlme)); 1623 if (error) 1624 return error; 1625 switch (mlme.im_op) { 1626 case IEEE80211_MLME_ASSOC: 1627 if (ic->ic_opmode != IEEE80211_M_STA) 1628 return EINVAL; 1629 /* XXX must be in S_SCAN state? */ 1630 1631 if (mlme.im_ssid_len != 0) { 1632 /* 1633 * Desired ssid specified; must match both bssid and 1634 * ssid to distinguish ap advertising multiple ssid's. 1635 */ 1636 ni = ieee80211_find_node_with_ssid(&ic->ic_scan, 1637 mlme.im_macaddr, 1638 mlme.im_ssid_len, mlme.im_ssid); 1639 } else { 1640 /* 1641 * Normal case; just match bssid. 1642 */ 1643 ni = ieee80211_find_node(&ic->ic_scan, mlme.im_macaddr); 1644 } 1645 if (ni == NULL) 1646 return EINVAL; 1647 if (!ieee80211_sta_join(ic, ni)) { 1648 ieee80211_free_node(ni); 1649 return EINVAL; 1650 } 1651 break; 1652 case IEEE80211_MLME_DISASSOC: 1653 case IEEE80211_MLME_DEAUTH: 1654 switch (ic->ic_opmode) { 1655 case IEEE80211_M_STA: 1656 /* XXX not quite right */ 1657 ieee80211_new_state(ic, IEEE80211_S_INIT, 1658 mlme.im_reason); 1659 break; 1660 case IEEE80211_M_HOSTAP: 1661 /* NB: the broadcast address means do 'em all */ 1662 if (!IEEE80211_ADDR_EQ(mlme.im_macaddr, ic->ic_ifp->if_broadcastaddr)) { 1663 if ((ni = ieee80211_find_node(&ic->ic_sta, 1664 mlme.im_macaddr)) == NULL) 1665 return EINVAL; 1666 domlme(&mlme, ni); 1667 ieee80211_free_node(ni); 1668 } else { 1669 ieee80211_iterate_nodes(&ic->ic_sta, 1670 domlme, &mlme); 1671 } 1672 break; 1673 default: 1674 return EINVAL; 1675 } 1676 break; 1677 case IEEE80211_MLME_AUTHORIZE: 1678 case IEEE80211_MLME_UNAUTHORIZE: 1679 if (ic->ic_opmode != IEEE80211_M_HOSTAP) 1680 return EINVAL; 1681 ni = ieee80211_find_node(&ic->ic_sta, mlme.im_macaddr); 1682 if (ni == NULL) 1683 return EINVAL; 1684 if (mlme.im_op == IEEE80211_MLME_AUTHORIZE) 1685 ieee80211_node_authorize(ic, ni); 1686 else 1687 ieee80211_node_unauthorize(ic, ni); 1688 ieee80211_free_node(ni); 1689 break; 1690 default: 1691 return EINVAL; 1692 } 1693 return 0; 1694 } 1695 1696 static int 1697 ieee80211_ioctl_macmac(struct ieee80211com *ic, struct ieee80211req *ireq) 1698 { 1699 u_int8_t mac[IEEE80211_ADDR_LEN]; 1700 const struct ieee80211_aclator *acl = ic->ic_acl; 1701 int error; 1702 1703 if (ireq->i_len != sizeof(mac)) 1704 return EINVAL; 1705 error = copyin(ireq->i_data, mac, ireq->i_len); 1706 if (error) 1707 return error; 1708 if (acl == NULL) { 1709 acl = ieee80211_aclator_get("mac"); 1710 if (acl == NULL || !acl->iac_attach(ic)) 1711 return EINVAL; 1712 ic->ic_acl = acl; 1713 } 1714 if (ireq->i_type == IEEE80211_IOC_ADDMAC) 1715 acl->iac_add(ic, mac); 1716 else 1717 acl->iac_remove(ic, mac); 1718 return 0; 1719 } 1720 1721 static int 1722 ieee80211_ioctl_maccmd(struct ieee80211com *ic, struct ieee80211req *ireq) 1723 { 1724 const struct ieee80211_aclator *acl = ic->ic_acl; 1725 1726 switch (ireq->i_val) { 1727 case IEEE80211_MACCMD_POLICY_OPEN: 1728 case IEEE80211_MACCMD_POLICY_ALLOW: 1729 case IEEE80211_MACCMD_POLICY_DENY: 1730 if (acl == NULL) { 1731 acl = ieee80211_aclator_get("mac"); 1732 if (acl == NULL || !acl->iac_attach(ic)) 1733 return EINVAL; 1734 ic->ic_acl = acl; 1735 } 1736 acl->iac_setpolicy(ic, ireq->i_val); 1737 break; 1738 case IEEE80211_MACCMD_FLUSH: 1739 if (acl != NULL) 1740 acl->iac_flush(ic); 1741 /* NB: silently ignore when not in use */ 1742 break; 1743 case IEEE80211_MACCMD_DETACH: 1744 if (acl != NULL) { 1745 ic->ic_acl = NULL; 1746 acl->iac_detach(ic); 1747 } 1748 break; 1749 default: 1750 return EINVAL; 1751 } 1752 return 0; 1753 } 1754 1755 static int 1756 ieee80211_ioctl_setchanlist(struct ieee80211com *ic, struct ieee80211req *ireq) 1757 { 1758 struct ieee80211req_chanlist list; 1759 u_char chanlist[IEEE80211_CHAN_BYTES]; 1760 int i, j, error; 1761 1762 if (ireq->i_len != sizeof(list)) 1763 return EINVAL; 1764 error = copyin(ireq->i_data, &list, sizeof(list)); 1765 if (error) 1766 return error; 1767 memset(chanlist, 0, sizeof(chanlist)); 1768 /* 1769 * Since channel 0 is not available for DS, channel 1 1770 * is assigned to LSB on WaveLAN. 1771 */ 1772 if (ic->ic_phytype == IEEE80211_T_DS) 1773 i = 1; 1774 else 1775 i = 0; 1776 for (j = 0; i <= IEEE80211_CHAN_MAX; i++, j++) { 1777 /* 1778 * NB: silently discard unavailable channels so users 1779 * can specify 1-255 to get all available channels. 1780 */ 1781 if (isset(list.ic_channels, j) && isset(ic->ic_chan_avail, i)) 1782 setbit(chanlist, i); 1783 } 1784 if (ic->ic_ibss_chan == NULL || 1785 isclr(chanlist, ieee80211_chan2ieee(ic, ic->ic_ibss_chan))) { 1786 for (i = 0; i <= IEEE80211_CHAN_MAX; i++) 1787 if (isset(chanlist, i)) { 1788 ic->ic_ibss_chan = &ic->ic_channels[i]; 1789 goto found; 1790 } 1791 return EINVAL; /* no active channels */ 1792 found: 1793 ; 1794 } 1795 memcpy(ic->ic_chan_active, chanlist, sizeof(ic->ic_chan_active)); 1796 if (ic->ic_bss->ni_chan == IEEE80211_CHAN_ANYC || 1797 isclr(chanlist, ieee80211_chan2ieee(ic, ic->ic_bss->ni_chan))) 1798 ic->ic_bss->ni_chan = ic->ic_ibss_chan; 1799 return IS_UP_AUTO(ic) ? ENETRESET : 0; 1800 } 1801 1802 static int 1803 ieee80211_ioctl_setstatxpow(struct ieee80211com *ic, struct ieee80211req *ireq) 1804 { 1805 struct ieee80211_node *ni; 1806 struct ieee80211req_sta_txpow txpow; 1807 int error; 1808 1809 if (ireq->i_len != sizeof(txpow)) 1810 return EINVAL; 1811 error = copyin(ireq->i_data, &txpow, sizeof(txpow)); 1812 if (error != 0) 1813 return error; 1814 ni = ieee80211_find_node(&ic->ic_sta, txpow.it_macaddr); 1815 if (ni == NULL) 1816 return EINVAL; /* XXX */ 1817 ni->ni_txpower = txpow.it_txpow; 1818 ieee80211_free_node(ni); 1819 return error; 1820 } 1821 1822 static int 1823 ieee80211_ioctl_setwmeparam(struct ieee80211com *ic, struct ieee80211req *ireq) 1824 { 1825 struct ieee80211_wme_state *wme = &ic->ic_wme; 1826 struct wmeParams *wmep, *chanp; 1827 int isbss, ac; 1828 1829 if ((ic->ic_caps & IEEE80211_C_WME) == 0) 1830 return EINVAL; 1831 1832 isbss = (ireq->i_len & IEEE80211_WMEPARAM_BSS); 1833 ac = (ireq->i_len & IEEE80211_WMEPARAM_VAL); 1834 if (ac >= WME_NUM_AC) 1835 ac = WME_AC_BE; 1836 if (isbss) { 1837 chanp = &wme->wme_bssChanParams.cap_wmeParams[ac]; 1838 wmep = &wme->wme_wmeBssChanParams.cap_wmeParams[ac]; 1839 } else { 1840 chanp = &wme->wme_chanParams.cap_wmeParams[ac]; 1841 wmep = &wme->wme_wmeChanParams.cap_wmeParams[ac]; 1842 } 1843 switch (ireq->i_type) { 1844 case IEEE80211_IOC_WME_CWMIN: /* WME: CWmin */ 1845 if (isbss) { 1846 wmep->wmep_logcwmin = ireq->i_val; 1847 if ((wme->wme_flags & WME_F_AGGRMODE) == 0) 1848 chanp->wmep_logcwmin = ireq->i_val; 1849 } else { 1850 wmep->wmep_logcwmin = chanp->wmep_logcwmin = 1851 ireq->i_val; 1852 } 1853 break; 1854 case IEEE80211_IOC_WME_CWMAX: /* WME: CWmax */ 1855 if (isbss) { 1856 wmep->wmep_logcwmax = ireq->i_val; 1857 if ((wme->wme_flags & WME_F_AGGRMODE) == 0) 1858 chanp->wmep_logcwmax = ireq->i_val; 1859 } else { 1860 wmep->wmep_logcwmax = chanp->wmep_logcwmax = 1861 ireq->i_val; 1862 } 1863 break; 1864 case IEEE80211_IOC_WME_AIFS: /* WME: AIFS */ 1865 if (isbss) { 1866 wmep->wmep_aifsn = ireq->i_val; 1867 if ((wme->wme_flags & WME_F_AGGRMODE) == 0) 1868 chanp->wmep_aifsn = ireq->i_val; 1869 } else { 1870 wmep->wmep_aifsn = chanp->wmep_aifsn = ireq->i_val; 1871 } 1872 break; 1873 case IEEE80211_IOC_WME_TXOPLIMIT: /* WME: txops limit */ 1874 if (isbss) { 1875 wmep->wmep_txopLimit = ireq->i_val; 1876 if ((wme->wme_flags & WME_F_AGGRMODE) == 0) 1877 chanp->wmep_txopLimit = ireq->i_val; 1878 } else { 1879 wmep->wmep_txopLimit = chanp->wmep_txopLimit = 1880 ireq->i_val; 1881 } 1882 break; 1883 case IEEE80211_IOC_WME_ACM: /* WME: ACM (bss only) */ 1884 wmep->wmep_acm = ireq->i_val; 1885 if ((wme->wme_flags & WME_F_AGGRMODE) == 0) 1886 chanp->wmep_acm = ireq->i_val; 1887 break; 1888 case IEEE80211_IOC_WME_ACKPOLICY: /* WME: ACK policy (!bss only)*/ 1889 wmep->wmep_noackPolicy = chanp->wmep_noackPolicy = 1890 (ireq->i_val) == 0; 1891 break; 1892 } 1893 ieee80211_wme_updateparams(ic); 1894 return 0; 1895 } 1896 1897 static int 1898 cipher2cap(int cipher) 1899 { 1900 switch (cipher) { 1901 case IEEE80211_CIPHER_WEP: return IEEE80211_C_WEP; 1902 case IEEE80211_CIPHER_AES_OCB: return IEEE80211_C_AES; 1903 case IEEE80211_CIPHER_AES_CCM: return IEEE80211_C_AES_CCM; 1904 case IEEE80211_CIPHER_CKIP: return IEEE80211_C_CKIP; 1905 case IEEE80211_CIPHER_TKIP: return IEEE80211_C_TKIP; 1906 } 1907 return 0; 1908 } 1909 1910 static int 1911 ieee80211_ioctl_set80211(struct ieee80211com *ic, u_long cmd, struct ieee80211req *ireq) 1912 { 1913 static const u_int8_t zerobssid[IEEE80211_ADDR_LEN]; 1914 struct ieee80211_rsnparms *rsn = &ic->ic_bss->ni_rsn; 1915 int error; 1916 const struct ieee80211_authenticator *auth; 1917 u_int8_t tmpkey[IEEE80211_KEYBUF_SIZE]; 1918 char tmpssid[IEEE80211_NWID_LEN]; 1919 u_int8_t tmpbssid[IEEE80211_ADDR_LEN]; 1920 struct ieee80211_key *k; 1921 int j, caps; 1922 u_int kid; 1923 1924 error = 0; 1925 switch (ireq->i_type) { 1926 case IEEE80211_IOC_SSID: 1927 if (ireq->i_val != 0 || 1928 ireq->i_len > IEEE80211_NWID_LEN) 1929 return EINVAL; 1930 error = copyin(ireq->i_data, tmpssid, ireq->i_len); 1931 if (error) 1932 break; 1933 memset(ic->ic_des_essid, 0, IEEE80211_NWID_LEN); 1934 ic->ic_des_esslen = ireq->i_len; 1935 memcpy(ic->ic_des_essid, tmpssid, ireq->i_len); 1936 error = ENETRESET; 1937 break; 1938 case IEEE80211_IOC_WEP: 1939 switch (ireq->i_val) { 1940 case IEEE80211_WEP_OFF: 1941 ic->ic_flags &= ~IEEE80211_F_PRIVACY; 1942 ic->ic_flags &= ~IEEE80211_F_DROPUNENC; 1943 break; 1944 case IEEE80211_WEP_ON: 1945 ic->ic_flags |= IEEE80211_F_PRIVACY; 1946 ic->ic_flags |= IEEE80211_F_DROPUNENC; 1947 break; 1948 case IEEE80211_WEP_MIXED: 1949 ic->ic_flags |= IEEE80211_F_PRIVACY; 1950 ic->ic_flags &= ~IEEE80211_F_DROPUNENC; 1951 break; 1952 } 1953 error = ENETRESET; 1954 break; 1955 case IEEE80211_IOC_WEPKEY: 1956 kid = (u_int) ireq->i_val; 1957 if (kid >= IEEE80211_WEP_NKID) 1958 return EINVAL; 1959 k = &ic->ic_nw_keys[kid]; 1960 if (ireq->i_len == 0) { 1961 /* zero-len =>'s delete any existing key */ 1962 (void) ieee80211_crypto_delkey(ic, k); 1963 break; 1964 } 1965 if (ireq->i_len > sizeof(tmpkey)) 1966 return EINVAL; 1967 memset(tmpkey, 0, sizeof(tmpkey)); 1968 error = copyin(ireq->i_data, tmpkey, ireq->i_len); 1969 if (error) 1970 break; 1971 ieee80211_key_update_begin(ic); 1972 k->wk_keyix = kid; /* NB: force fixed key id */ 1973 if (ieee80211_crypto_newkey(ic, IEEE80211_CIPHER_WEP, 1974 IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV, k)) { 1975 k->wk_keylen = ireq->i_len; 1976 memcpy(k->wk_key, tmpkey, sizeof(tmpkey)); 1977 if (!ieee80211_crypto_setkey(ic, k, ic->ic_myaddr)) 1978 error = EINVAL; 1979 } else 1980 error = EINVAL; 1981 ieee80211_key_update_end(ic); 1982 if (!error) /* NB: for compatibility */ 1983 error = ENETRESET; 1984 break; 1985 case IEEE80211_IOC_WEPTXKEY: 1986 kid = (u_int) ireq->i_val; 1987 if (kid >= IEEE80211_WEP_NKID && 1988 (u_int16_t) kid != IEEE80211_KEYIX_NONE) 1989 return EINVAL; 1990 ic->ic_def_txkey = kid; 1991 error = ENETRESET; /* push to hardware */ 1992 break; 1993 case IEEE80211_IOC_AUTHMODE: 1994 switch (ireq->i_val) { 1995 case IEEE80211_AUTH_WPA: 1996 case IEEE80211_AUTH_8021X: /* 802.1x */ 1997 case IEEE80211_AUTH_OPEN: /* open */ 1998 case IEEE80211_AUTH_SHARED: /* shared-key */ 1999 case IEEE80211_AUTH_AUTO: /* auto */ 2000 auth = ieee80211_authenticator_get(ireq->i_val); 2001 if (auth == NULL) 2002 return EINVAL; 2003 break; 2004 default: 2005 return EINVAL; 2006 } 2007 switch (ireq->i_val) { 2008 case IEEE80211_AUTH_WPA: /* WPA w/ 802.1x */ 2009 ic->ic_flags |= IEEE80211_F_PRIVACY; 2010 ireq->i_val = IEEE80211_AUTH_8021X; 2011 break; 2012 case IEEE80211_AUTH_OPEN: /* open */ 2013 ic->ic_flags &= ~(IEEE80211_F_WPA|IEEE80211_F_PRIVACY); 2014 break; 2015 case IEEE80211_AUTH_SHARED: /* shared-key */ 2016 case IEEE80211_AUTH_8021X: /* 802.1x */ 2017 ic->ic_flags &= ~IEEE80211_F_WPA; 2018 /* both require a key so mark the PRIVACY capability */ 2019 ic->ic_flags |= IEEE80211_F_PRIVACY; 2020 break; 2021 case IEEE80211_AUTH_AUTO: /* auto */ 2022 ic->ic_flags &= ~IEEE80211_F_WPA; 2023 /* XXX PRIVACY handling? */ 2024 /* XXX what's the right way to do this? */ 2025 break; 2026 } 2027 /* NB: authenticator attach/detach happens on state change */ 2028 ic->ic_bss->ni_authmode = ireq->i_val; 2029 /* XXX mixed/mode/usage? */ 2030 ic->ic_auth = auth; 2031 error = ENETRESET; 2032 break; 2033 case IEEE80211_IOC_CHANNEL: 2034 /* XXX 0xffff overflows 16-bit signed */ 2035 if (ireq->i_val == 0 || 2036 ireq->i_val == (int16_t) IEEE80211_CHAN_ANY) 2037 ic->ic_des_chan = IEEE80211_CHAN_ANYC; 2038 else if ((u_int) ireq->i_val > IEEE80211_CHAN_MAX || 2039 isclr(ic->ic_chan_active, ireq->i_val)) { 2040 return EINVAL; 2041 } else 2042 ic->ic_ibss_chan = ic->ic_des_chan = 2043 &ic->ic_channels[ireq->i_val]; 2044 switch (ic->ic_state) { 2045 case IEEE80211_S_INIT: 2046 case IEEE80211_S_SCAN: 2047 error = ENETRESET; 2048 break; 2049 default: 2050 /* 2051 * If the desired channel has changed (to something 2052 * other than any) and we're not already scanning, 2053 * then kick the state machine. 2054 */ 2055 if (ic->ic_des_chan != IEEE80211_CHAN_ANYC && 2056 ic->ic_bss->ni_chan != ic->ic_des_chan && 2057 (ic->ic_flags & IEEE80211_F_SCAN) == 0) 2058 error = ENETRESET; 2059 break; 2060 } 2061 if (error == ENETRESET && ic->ic_opmode == IEEE80211_M_MONITOR) 2062 error = IS_UP(ic) ? ic->ic_reset(ic->ic_ifp) : 0; 2063 break; 2064 case IEEE80211_IOC_POWERSAVE: 2065 switch (ireq->i_val) { 2066 case IEEE80211_POWERSAVE_OFF: 2067 if (ic->ic_flags & IEEE80211_F_PMGTON) { 2068 ic->ic_flags &= ~IEEE80211_F_PMGTON; 2069 error = ENETRESET; 2070 } 2071 break; 2072 case IEEE80211_POWERSAVE_ON: 2073 if ((ic->ic_caps & IEEE80211_C_PMGT) == 0) 2074 error = EINVAL; 2075 else if ((ic->ic_flags & IEEE80211_F_PMGTON) == 0) { 2076 ic->ic_flags |= IEEE80211_F_PMGTON; 2077 error = ENETRESET; 2078 } 2079 break; 2080 default: 2081 error = EINVAL; 2082 break; 2083 } 2084 break; 2085 case IEEE80211_IOC_POWERSAVESLEEP: 2086 if (ireq->i_val < 0) 2087 return EINVAL; 2088 ic->ic_lintval = ireq->i_val; 2089 error = IS_UP(ic) ? ic->ic_reset(ic->ic_ifp) : 0; 2090 break; 2091 case IEEE80211_IOC_RTSTHRESHOLD: 2092 if (!(IEEE80211_RTS_MIN < ireq->i_val && 2093 ireq->i_val < IEEE80211_RTS_MAX)) 2094 return EINVAL; 2095 ic->ic_rtsthreshold = ireq->i_val; 2096 error = IS_UP(ic) ? ic->ic_reset(ic->ic_ifp) : 0; 2097 break; 2098 case IEEE80211_IOC_PROTMODE: 2099 if (ireq->i_val > IEEE80211_PROT_RTSCTS) 2100 return EINVAL; 2101 ic->ic_protmode = ireq->i_val; 2102 /* NB: if not operating in 11g this can wait */ 2103 if (ic->ic_curmode == IEEE80211_MODE_11G) 2104 error = IS_UP(ic) ? ic->ic_reset(ic->ic_ifp) : 0; 2105 break; 2106 case IEEE80211_IOC_TXPOWER: 2107 if ((ic->ic_caps & IEEE80211_C_TXPMGT) == 0) 2108 return EINVAL; 2109 if (!(IEEE80211_TXPOWER_MIN < ireq->i_val && 2110 ireq->i_val < IEEE80211_TXPOWER_MAX)) 2111 return EINVAL; 2112 ic->ic_txpowlimit = ireq->i_val; 2113 error = IS_UP(ic) ? ic->ic_reset(ic->ic_ifp) : 0; 2114 break; 2115 case IEEE80211_IOC_ROAMING: 2116 if (!(IEEE80211_ROAMING_DEVICE <= ireq->i_val && 2117 ireq->i_val <= IEEE80211_ROAMING_MANUAL)) 2118 return EINVAL; 2119 ic->ic_roaming = ireq->i_val; 2120 /* XXXX reset? */ 2121 break; 2122 case IEEE80211_IOC_PRIVACY: 2123 if (ireq->i_val) { 2124 /* XXX check for key state? */ 2125 ic->ic_flags |= IEEE80211_F_PRIVACY; 2126 } else 2127 ic->ic_flags &= ~IEEE80211_F_PRIVACY; 2128 break; 2129 case IEEE80211_IOC_DROPUNENCRYPTED: 2130 if (ireq->i_val) 2131 ic->ic_flags |= IEEE80211_F_DROPUNENC; 2132 else 2133 ic->ic_flags &= ~IEEE80211_F_DROPUNENC; 2134 break; 2135 case IEEE80211_IOC_WPAKEY: 2136 error = ieee80211_ioctl_setkey(ic, ireq); 2137 break; 2138 case IEEE80211_IOC_DELKEY: 2139 error = ieee80211_ioctl_delkey(ic, ireq); 2140 break; 2141 case IEEE80211_IOC_MLME: 2142 error = ieee80211_ioctl_setmlme(ic, ireq); 2143 break; 2144 case IEEE80211_IOC_OPTIE: 2145 error = ieee80211_ioctl_setoptie(ic, ireq); 2146 break; 2147 case IEEE80211_IOC_COUNTERMEASURES: 2148 if (ireq->i_val) { 2149 if ((ic->ic_flags & IEEE80211_F_WPA) == 0) 2150 return EINVAL; 2151 ic->ic_flags |= IEEE80211_F_COUNTERM; 2152 } else 2153 ic->ic_flags &= ~IEEE80211_F_COUNTERM; 2154 break; 2155 case IEEE80211_IOC_WPA: 2156 if (ireq->i_val > 3) 2157 return EINVAL; 2158 /* XXX verify ciphers available */ 2159 ic->ic_flags &= ~IEEE80211_F_WPA; 2160 switch (ireq->i_val) { 2161 case 1: 2162 ic->ic_flags |= IEEE80211_F_WPA1; 2163 break; 2164 case 2: 2165 ic->ic_flags |= IEEE80211_F_WPA2; 2166 break; 2167 case 3: 2168 ic->ic_flags |= IEEE80211_F_WPA1 | IEEE80211_F_WPA2; 2169 break; 2170 } 2171 error = ENETRESET; /* XXX? */ 2172 break; 2173 case IEEE80211_IOC_WME: 2174 if (ireq->i_val) { 2175 if ((ic->ic_caps & IEEE80211_C_WME) == 0) 2176 return EINVAL; 2177 ic->ic_flags |= IEEE80211_F_WME; 2178 } else 2179 ic->ic_flags &= ~IEEE80211_F_WME; 2180 error = ENETRESET; /* XXX maybe not for station? */ 2181 break; 2182 case IEEE80211_IOC_HIDESSID: 2183 if (ireq->i_val) 2184 ic->ic_flags |= IEEE80211_F_HIDESSID; 2185 else 2186 ic->ic_flags &= ~IEEE80211_F_HIDESSID; 2187 error = ENETRESET; 2188 break; 2189 case IEEE80211_IOC_APBRIDGE: 2190 if (ireq->i_val == 0) 2191 ic->ic_flags |= IEEE80211_F_NOBRIDGE; 2192 else 2193 ic->ic_flags &= ~IEEE80211_F_NOBRIDGE; 2194 break; 2195 case IEEE80211_IOC_MCASTCIPHER: 2196 if ((ic->ic_caps & cipher2cap(ireq->i_val)) == 0 && 2197 !ieee80211_crypto_available(ireq->i_val)) 2198 return EINVAL; 2199 rsn->rsn_mcastcipher = ireq->i_val; 2200 error = (ic->ic_flags & IEEE80211_F_WPA) ? ENETRESET : 0; 2201 break; 2202 case IEEE80211_IOC_MCASTKEYLEN: 2203 if (!(0 < ireq->i_val && ireq->i_val < IEEE80211_KEYBUF_SIZE)) 2204 return EINVAL; 2205 /* XXX no way to verify driver capability */ 2206 rsn->rsn_mcastkeylen = ireq->i_val; 2207 error = (ic->ic_flags & IEEE80211_F_WPA) ? ENETRESET : 0; 2208 break; 2209 case IEEE80211_IOC_UCASTCIPHERS: 2210 /* 2211 * Convert user-specified cipher set to the set 2212 * we can support (via hardware or software). 2213 * NB: this logic intentionally ignores unknown and 2214 * unsupported ciphers so folks can specify 0xff or 2215 * similar and get all available ciphers. 2216 */ 2217 caps = 0; 2218 for (j = 1; j < 32; j++) /* NB: skip WEP */ 2219 if ((ireq->i_val & (1<<j)) && 2220 ((ic->ic_caps & cipher2cap(j)) || 2221 ieee80211_crypto_available(j))) 2222 caps |= 1<<j; 2223 if (caps == 0) /* nothing available */ 2224 return EINVAL; 2225 /* XXX verify ciphers ok for unicast use? */ 2226 /* XXX disallow if running as it'll have no effect */ 2227 rsn->rsn_ucastcipherset = caps; 2228 error = (ic->ic_flags & IEEE80211_F_WPA) ? ENETRESET : 0; 2229 break; 2230 case IEEE80211_IOC_UCASTCIPHER: 2231 if ((rsn->rsn_ucastcipherset & cipher2cap(ireq->i_val)) == 0) 2232 return EINVAL; 2233 rsn->rsn_ucastcipher = ireq->i_val; 2234 break; 2235 case IEEE80211_IOC_UCASTKEYLEN: 2236 if (!(0 < ireq->i_val && ireq->i_val < IEEE80211_KEYBUF_SIZE)) 2237 return EINVAL; 2238 /* XXX no way to verify driver capability */ 2239 rsn->rsn_ucastkeylen = ireq->i_val; 2240 break; 2241 case IEEE80211_IOC_DRIVER_CAPS: 2242 /* NB: for testing */ 2243 ic->ic_caps = (((u_int16_t) ireq->i_val) << 16) | 2244 ((u_int16_t) ireq->i_len); 2245 break; 2246 case IEEE80211_IOC_KEYMGTALGS: 2247 /* XXX check */ 2248 rsn->rsn_keymgmtset = ireq->i_val; 2249 error = (ic->ic_flags & IEEE80211_F_WPA) ? ENETRESET : 0; 2250 break; 2251 case IEEE80211_IOC_RSNCAPS: 2252 /* XXX check */ 2253 rsn->rsn_caps = ireq->i_val; 2254 error = (ic->ic_flags & IEEE80211_F_WPA) ? ENETRESET : 0; 2255 break; 2256 case IEEE80211_IOC_BSSID: 2257 /* NB: should only be set when in STA mode */ 2258 if (ic->ic_opmode != IEEE80211_M_STA) 2259 return EINVAL; 2260 if (ireq->i_len != sizeof(tmpbssid)) 2261 return EINVAL; 2262 error = copyin(ireq->i_data, tmpbssid, ireq->i_len); 2263 if (error) 2264 break; 2265 IEEE80211_ADDR_COPY(ic->ic_des_bssid, tmpbssid); 2266 if (IEEE80211_ADDR_EQ(ic->ic_des_bssid, zerobssid)) 2267 ic->ic_flags &= ~IEEE80211_F_DESBSSID; 2268 else 2269 ic->ic_flags |= IEEE80211_F_DESBSSID; 2270 error = ENETRESET; 2271 break; 2272 case IEEE80211_IOC_CHANLIST: 2273 error = ieee80211_ioctl_setchanlist(ic, ireq); 2274 break; 2275 case IEEE80211_IOC_SCAN_REQ: 2276 if (ic->ic_opmode == IEEE80211_M_HOSTAP) /* XXX ignore */ 2277 break; 2278 error = ieee80211_setupscan(ic, ic->ic_chan_avail); 2279 if (error == 0) /* XXX background scan */ 2280 error = ieee80211_new_state(ic, IEEE80211_S_SCAN, -1); 2281 break; 2282 case IEEE80211_IOC_ADDMAC: 2283 case IEEE80211_IOC_DELMAC: 2284 error = ieee80211_ioctl_macmac(ic, ireq); 2285 break; 2286 case IEEE80211_IOC_MACCMD: 2287 error = ieee80211_ioctl_maccmd(ic, ireq); 2288 break; 2289 case IEEE80211_IOC_STA_TXPOW: 2290 error = ieee80211_ioctl_setstatxpow(ic, ireq); 2291 break; 2292 case IEEE80211_IOC_WME_CWMIN: /* WME: CWmin */ 2293 case IEEE80211_IOC_WME_CWMAX: /* WME: CWmax */ 2294 case IEEE80211_IOC_WME_AIFS: /* WME: AIFS */ 2295 case IEEE80211_IOC_WME_TXOPLIMIT: /* WME: txops limit */ 2296 case IEEE80211_IOC_WME_ACM: /* WME: ACM (bss only) */ 2297 case IEEE80211_IOC_WME_ACKPOLICY: /* WME: ACK policy (bss only) */ 2298 error = ieee80211_ioctl_setwmeparam(ic, ireq); 2299 break; 2300 case IEEE80211_IOC_DTIM_PERIOD: 2301 if (ic->ic_opmode != IEEE80211_M_HOSTAP && 2302 ic->ic_opmode != IEEE80211_M_IBSS) 2303 return EINVAL; 2304 if (IEEE80211_DTIM_MIN <= ireq->i_val && 2305 ireq->i_val <= IEEE80211_DTIM_MAX) { 2306 ic->ic_dtim_period = ireq->i_val; 2307 error = ENETRESET; /* requires restart */ 2308 } else 2309 error = EINVAL; 2310 break; 2311 case IEEE80211_IOC_BEACON_INTERVAL: 2312 if (ic->ic_opmode != IEEE80211_M_HOSTAP && 2313 ic->ic_opmode != IEEE80211_M_IBSS) 2314 return EINVAL; 2315 if (IEEE80211_BINTVAL_MIN <= ireq->i_val && 2316 ireq->i_val <= IEEE80211_BINTVAL_MAX) { 2317 ic->ic_lintval = ireq->i_val; 2318 error = ENETRESET; /* requires restart */ 2319 } else 2320 error = EINVAL; 2321 break; 2322 case IEEE80211_IOC_PUREG: 2323 if (ireq->i_val) 2324 ic->ic_flags |= IEEE80211_F_PUREG; 2325 else 2326 ic->ic_flags &= ~IEEE80211_F_PUREG; 2327 /* NB: reset only if we're operating on an 11g channel */ 2328 if (ic->ic_curmode == IEEE80211_MODE_11G) 2329 error = ENETRESET; 2330 break; 2331 default: 2332 error = EINVAL; 2333 break; 2334 } 2335 if (error == ENETRESET && !IS_UP_AUTO(ic)) 2336 error = 0; 2337 return error; 2338 } 2339 2340 int 2341 ieee80211_ioctl(struct ieee80211com *ic, u_long cmd, caddr_t data) 2342 { 2343 struct ifnet *ifp = ic->ic_ifp; 2344 int error = 0; 2345 struct ifreq *ifr; 2346 struct ifaddr *ifa; /* XXX */ 2347 2348 switch (cmd) { 2349 case SIOCSIFMEDIA: 2350 case SIOCGIFMEDIA: 2351 error = ifmedia_ioctl(ifp, (struct ifreq *) data, 2352 &ic->ic_media, cmd); 2353 break; 2354 case SIOCG80211: 2355 error = ieee80211_ioctl_get80211(ic, cmd, 2356 (struct ieee80211req *) data); 2357 break; 2358 case SIOCS80211: 2359 error = suser(curthread); 2360 if (error == 0) 2361 error = ieee80211_ioctl_set80211(ic, cmd, 2362 (struct ieee80211req *) data); 2363 break; 2364 case SIOCGIFGENERIC: 2365 error = ieee80211_cfgget(ic, cmd, data); 2366 break; 2367 case SIOCSIFGENERIC: 2368 error = suser(curthread); 2369 if (error) 2370 break; 2371 error = ieee80211_cfgset(ic, cmd, data); 2372 break; 2373 case SIOCG80211STATS: 2374 ifr = (struct ifreq *)data; 2375 copyout(&ic->ic_stats, ifr->ifr_data, sizeof (ic->ic_stats)); 2376 break; 2377 case SIOCSIFMTU: 2378 ifr = (struct ifreq *)data; 2379 if (!(IEEE80211_MTU_MIN <= ifr->ifr_mtu && 2380 ifr->ifr_mtu <= IEEE80211_MTU_MAX)) 2381 error = EINVAL; 2382 else 2383 ifp->if_mtu = ifr->ifr_mtu; 2384 break; 2385 case SIOCSIFADDR: 2386 /* 2387 * XXX Handle this directly so we can supress if_init calls. 2388 * XXX This should be done in ether_ioctl but for the moment 2389 * XXX there are too many other parts of the system that 2390 * XXX set IFF_UP and so supress if_init being called when 2391 * XXX it should be. 2392 */ 2393 ifa = (struct ifaddr *) data; 2394 switch (ifa->ifa_addr->sa_family) { 2395 #ifdef INET 2396 case AF_INET: 2397 if ((ifp->if_flags & IFF_UP) == 0) { 2398 ifp->if_flags |= IFF_UP; 2399 ifp->if_init(ifp->if_softc); 2400 } 2401 arp_ifinit(ifp, ifa); 2402 break; 2403 #endif 2404 #ifdef IPX 2405 /* 2406 * XXX - This code is probably wrong, 2407 * but has been copied many times. 2408 */ 2409 case AF_IPX: { 2410 struct ipx_addr *ina = &(IA_SIPX(ifa)->sipx_addr); 2411 2412 if (ipx_nullhost(*ina)) 2413 ina->x_host = *(union ipx_host *) 2414 IFP2ENADDR(ifp); 2415 else 2416 bcopy((caddr_t) ina->x_host.c_host, 2417 (caddr_t) IFP2ENADDR(ifp), 2418 ETHER_ADDR_LEN); 2419 /* fall thru... */ 2420 } 2421 #endif 2422 default: 2423 if ((ifp->if_flags & IFF_UP) == 0) { 2424 ifp->if_flags |= IFF_UP; 2425 ifp->if_init(ifp->if_softc); 2426 } 2427 break; 2428 } 2429 break; 2430 default: 2431 error = ether_ioctl(ifp, cmd, data); 2432 break; 2433 } 2434 return error; 2435 } 2436
Indexes created Tue Sep 30 06:09:59 GMT 2025