1 /* 2 * Copyright 2001 The Aerospace Corporation. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 3. The name of The Aerospace Corporation may not be used to endorse or 13 * promote products derived from this software. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AEROSPACE CORPORATION ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AEROSPACE CORPORATION BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 * 27 * $FreeBSD: src/sbin/ifconfig/ifieee80211.c,v 1.18.2.9 2006/03/07 17:50:23 sam Exp $ 28 * $DragonFly: src/sbin/ifconfig/ifieee80211.c,v 1.11 2006/05/18 13:51:45 sephe Exp $ 29 */ 30 31 /*- 32 * Copyright (c) 1997, 1998, 2000 The NetBSD Foundation, Inc. 33 * All rights reserved. 34 * 35 * This code is derived from software contributed to The NetBSD Foundation 36 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility, 37 * NASA Ames Research Center. 38 * 39 * Redistribution and use in source and binary forms, with or without 40 * modification, are permitted provided that the following conditions 41 * are met: 42 * 1. Redistributions of source code must retain the above copyright 43 * notice, this list of conditions and the following disclaimer. 44 * 2. Redistributions in binary form must reproduce the above copyright 45 * notice, this list of conditions and the following disclaimer in the 46 * documentation and/or other materials provided with the distribution. 47 * 3. All advertising materials mentioning features or use of this software 48 * must display the following acknowledgement: 49 * This product includes software developed by the NetBSD 50 * Foundation, Inc. and its contributors. 51 * 4. Neither the name of The NetBSD Foundation nor the names of its 52 * contributors may be used to endorse or promote products derived 53 * from this software without specific prior written permission. 54 * 55 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 56 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 57 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 58 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 59 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 60 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 61 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 62 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 63 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 64 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 65 * POSSIBILITY OF SUCH DAMAGE. 66 */ 67 68 #include <sys/param.h> 69 #include <sys/ioctl.h> 70 #include <sys/socket.h> 71 #include <sys/sysctl.h> 72 #include <sys/time.h> 73 74 #include <net/ethernet.h> 75 #include <net/if.h> 76 #include <net/if_dl.h> 77 #include <net/if_types.h> 78 #include <net/if_media.h> 79 #include <net/route.h> 80 81 #include <netproto/802_11/ieee80211.h> 82 #include <netproto/802_11/ieee80211_crypto.h> 83 #include <netproto/802_11/ieee80211_ioctl.h> 84 85 #include <ctype.h> 86 #include <err.h> 87 #include <errno.h> 88 #include <fcntl.h> 89 #include <inttypes.h> 90 #include <stdio.h> 91 #include <stdlib.h> 92 #include <string.h> 93 #include <unistd.h> 94 #include <stdarg.h> 95 96 #include "ifconfig.h" 97 98 static void set80211(int s, int type, int val, int len, u_int8_t *data); 99 static const char *get_string(const char *val, const char *sep, 100 u_int8_t *buf, int *lenp); 101 static void print_string(const u_int8_t *buf, int len); 102 103 static int 104 isanyarg(const char *arg) 105 { 106 return (strcmp(arg, "-") == 0 || 107 strcasecmp(arg, "any") == 0 || strcasecmp(arg, "off") == 0); 108 } 109 110 static void 111 set80211ssid(const char *val, int d, int s, const struct afswtch *rafp) 112 { 113 int ssid; 114 int len; 115 u_int8_t data[IEEE80211_NWID_LEN]; 116 117 ssid = 0; 118 len = strlen(val); 119 if (len > 2 && isdigit(val[0]) && val[1] == ':') { 120 ssid = atoi(val)-1; 121 val += 2; 122 } 123 124 bzero(data, sizeof(data)); 125 len = sizeof(data); 126 if (get_string(val, NULL, data, &len) == NULL) 127 exit(1); 128 129 set80211(s, IEEE80211_IOC_SSID, ssid, len, data); 130 } 131 132 static void 133 set80211stationname(const char *val, int d, int s, const struct afswtch *rafp) 134 { 135 int len; 136 u_int8_t data[33]; 137 138 bzero(data, sizeof(data)); 139 len = sizeof(data); 140 get_string(val, NULL, data, &len); 141 142 set80211(s, IEEE80211_IOC_STATIONNAME, 0, len, data); 143 } 144 145 /* 146 * Convert IEEE channel number to MHz frequency. 147 */ 148 static u_int 149 ieee80211_ieee2mhz(u_int chan) 150 { 151 if (chan == 14) 152 return 2484; 153 if (chan < 14) /* 0-13 */ 154 return 2407 + chan*5; 155 if (chan < 27) /* 15-26 */ 156 return 2512 + ((chan-15)*20); 157 return 5000 + (chan*5); 158 } 159 160 /* 161 * Convert MHz frequency to IEEE channel number. 162 */ 163 static u_int 164 ieee80211_mhz2ieee(u_int freq) 165 { 166 if (freq == 2484) 167 return 14; 168 if (freq < 2484) 169 return (freq - 2407) / 5; 170 if (freq < 5000) 171 return 15 + ((freq - 2512) / 20); 172 return (freq - 5000) / 5; 173 } 174 175 static void 176 set80211channel(const char *val, int d, int s, const struct afswtch *rafp) 177 { 178 if (!isanyarg(val)) { 179 int v = atoi(val); 180 if (v > 255) /* treat as frequency */ 181 v = ieee80211_mhz2ieee(v); 182 set80211(s, IEEE80211_IOC_CHANNEL, v, 0, NULL); 183 } else 184 set80211(s, IEEE80211_IOC_CHANNEL, IEEE80211_CHAN_ANY, 0, NULL); 185 } 186 187 static void 188 set80211authmode(const char *val, int d, int s, const struct afswtch *rafp) 189 { 190 int mode; 191 192 if (strcasecmp(val, "none") == 0) { 193 mode = IEEE80211_AUTH_NONE; 194 } else if (strcasecmp(val, "open") == 0) { 195 mode = IEEE80211_AUTH_OPEN; 196 } else if (strcasecmp(val, "shared") == 0) { 197 mode = IEEE80211_AUTH_SHARED; 198 } else if (strcasecmp(val, "8021x") == 0) { 199 mode = IEEE80211_AUTH_8021X; 200 } else if (strcasecmp(val, "wpa") == 0) { 201 mode = IEEE80211_AUTH_WPA; 202 } else { 203 errx(1, "unknown authmode"); 204 } 205 206 set80211(s, IEEE80211_IOC_AUTHMODE, mode, 0, NULL); 207 } 208 209 static void 210 set80211powersavemode(const char *val, int d, int s, const struct afswtch *rafp) 211 { 212 int mode; 213 214 if (strcasecmp(val, "off") == 0) { 215 mode = IEEE80211_POWERSAVE_OFF; 216 } else if (strcasecmp(val, "on") == 0) { 217 mode = IEEE80211_POWERSAVE_ON; 218 } else if (strcasecmp(val, "cam") == 0) { 219 mode = IEEE80211_POWERSAVE_CAM; 220 } else if (strcasecmp(val, "psp") == 0) { 221 mode = IEEE80211_POWERSAVE_PSP; 222 } else if (strcasecmp(val, "psp-cam") == 0) { 223 mode = IEEE80211_POWERSAVE_PSP_CAM; 224 } else { 225 errx(1, "unknown powersavemode"); 226 } 227 228 set80211(s, IEEE80211_IOC_POWERSAVE, mode, 0, NULL); 229 } 230 231 static void 232 set80211powersave(const char *val, int d, int s, const struct afswtch *rafp) 233 { 234 if (d == 0) 235 set80211(s, IEEE80211_IOC_POWERSAVE, IEEE80211_POWERSAVE_OFF, 236 0, NULL); 237 else 238 set80211(s, IEEE80211_IOC_POWERSAVE, IEEE80211_POWERSAVE_ON, 239 0, NULL); 240 } 241 242 static void 243 set80211powersavesleep(const char *val, int d, int s, const struct afswtch *rafp) 244 { 245 set80211(s, IEEE80211_IOC_POWERSAVESLEEP, atoi(val), 0, NULL); 246 } 247 248 static void 249 set80211wepmode(const char *val, int d, int s, const struct afswtch *rafp) 250 { 251 int mode; 252 253 if (strcasecmp(val, "off") == 0) { 254 mode = IEEE80211_WEP_OFF; 255 } else if (strcasecmp(val, "on") == 0) { 256 mode = IEEE80211_WEP_ON; 257 } else if (strcasecmp(val, "mixed") == 0) { 258 mode = IEEE80211_WEP_MIXED; 259 } else { 260 errx(1, "unknown wep mode"); 261 } 262 263 set80211(s, IEEE80211_IOC_WEP, mode, 0, NULL); 264 } 265 266 static void 267 set80211wep(const char *val, int d, int s, const struct afswtch *rafp) 268 { 269 set80211(s, IEEE80211_IOC_WEP, d, 0, NULL); 270 } 271 272 static int 273 isundefarg(const char *arg) 274 { 275 return (strcmp(arg, "-") == 0 || strncasecmp(arg, "undef", 5) == 0); 276 } 277 278 static void 279 set80211weptxkey(const char *val, int d, int s, const struct afswtch *rafp) 280 { 281 if (isundefarg(val)) 282 set80211(s, IEEE80211_IOC_WEPTXKEY, IEEE80211_KEYIX_NONE, 0, NULL); 283 else 284 set80211(s, IEEE80211_IOC_WEPTXKEY, atoi(val)-1, 0, NULL); 285 } 286 287 static void 288 set80211wepkey(const char *val, int d, int s, const struct afswtch *rafp) 289 { 290 int key = 0; 291 int len; 292 u_int8_t data[IEEE80211_KEYBUF_SIZE]; 293 294 if (isdigit(val[0]) && val[1] == ':') { 295 key = atoi(val)-1; 296 val += 2; 297 } 298 299 bzero(data, sizeof(data)); 300 len = sizeof(data); 301 get_string(val, NULL, data, &len); 302 303 set80211(s, IEEE80211_IOC_WEPKEY, key, len, data); 304 } 305 306 /* 307 * This function is purely a NetBSD compatability interface. The NetBSD 308 * interface is too inflexible, but it's there so we'll support it since 309 * it's not all that hard. 310 */ 311 static void 312 set80211nwkey(const char *val, int d, int s, const struct afswtch *rafp) 313 { 314 int txkey; 315 int i, len; 316 u_int8_t data[IEEE80211_KEYBUF_SIZE]; 317 318 set80211(s, IEEE80211_IOC_WEP, IEEE80211_WEP_ON, 0, NULL); 319 320 if (isdigit(val[0]) && val[1] == ':') { 321 txkey = val[0]-'0'-1; 322 val += 2; 323 324 for (i = 0; i < 4; i++) { 325 bzero(data, sizeof(data)); 326 len = sizeof(data); 327 val = get_string(val, ",", data, &len); 328 if (val == NULL) 329 exit(1); 330 331 set80211(s, IEEE80211_IOC_WEPKEY, i, len, data); 332 } 333 } else { 334 bzero(data, sizeof(data)); 335 len = sizeof(data); 336 get_string(val, NULL, data, &len); 337 txkey = 0; 338 339 set80211(s, IEEE80211_IOC_WEPKEY, 0, len, data); 340 341 bzero(data, sizeof(data)); 342 for (i = 1; i < 4; i++) 343 set80211(s, IEEE80211_IOC_WEPKEY, i, 0, data); 344 } 345 346 set80211(s, IEEE80211_IOC_WEPTXKEY, txkey, 0, NULL); 347 } 348 349 static void 350 set80211rtsthreshold(const char *val, int d, int s, const struct afswtch *rafp) 351 { 352 set80211(s, IEEE80211_IOC_RTSTHRESHOLD, 353 isundefarg(val) ? IEEE80211_RTS_MAX : atoi(val), 0, NULL); 354 } 355 356 static void 357 set80211protmode(const char *val, int d, int s, const struct afswtch *rafp) 358 { 359 int mode; 360 361 if (strcasecmp(val, "off") == 0) { 362 mode = IEEE80211_PROTMODE_OFF; 363 } else if (strcasecmp(val, "cts") == 0) { 364 mode = IEEE80211_PROTMODE_CTS; 365 } else if (strcasecmp(val, "rtscts") == 0) { 366 mode = IEEE80211_PROTMODE_RTSCTS; 367 } else { 368 errx(1, "unknown protection mode"); 369 } 370 371 set80211(s, IEEE80211_IOC_PROTMODE, mode, 0, NULL); 372 } 373 374 static void 375 set80211txpower(const char *val, int d, int s, const struct afswtch *rafp) 376 { 377 set80211(s, IEEE80211_IOC_TXPOWER, atoi(val), 0, NULL); 378 } 379 380 #define IEEE80211_ROAMING_DEVICE 0 381 #define IEEE80211_ROAMING_AUTO 1 382 #define IEEE80211_ROAMING_MANUAL 2 383 384 static void 385 set80211roaming(const char *val, int d, int s, const struct afswtch *rafp) 386 { 387 int mode; 388 389 if (strcasecmp(val, "device") == 0) { 390 mode = IEEE80211_ROAMING_DEVICE; 391 } else if (strcasecmp(val, "auto") == 0) { 392 mode = IEEE80211_ROAMING_AUTO; 393 } else if (strcasecmp(val, "manual") == 0) { 394 mode = IEEE80211_ROAMING_MANUAL; 395 } else { 396 errx(1, "unknown roaming mode"); 397 } 398 set80211(s, IEEE80211_IOC_ROAMING, mode, 0, NULL); 399 } 400 401 static void 402 set80211wme(const char *val, int d, int s, const struct afswtch *rafp) 403 { 404 set80211(s, IEEE80211_IOC_WME, d, 0, NULL); 405 } 406 407 static void 408 set80211hidessid(const char *val, int d, int s, const struct afswtch *rafp) 409 { 410 set80211(s, IEEE80211_IOC_HIDESSID, d, 0, NULL); 411 } 412 413 static void 414 set80211apbridge(const char *val, int d, int s, const struct afswtch *rafp) 415 { 416 set80211(s, IEEE80211_IOC_APBRIDGE, d, 0, NULL); 417 } 418 419 static void 420 set80211chanlist(const char *val, int d, int s, const struct afswtch *rafp) 421 { 422 struct ieee80211req_chanlist chanlist; 423 #define MAXCHAN (sizeof(chanlist.ic_channels)*NBBY) 424 char *temp, *cp, *tp; 425 426 temp = malloc(strlen(val) + 1); 427 if (temp == NULL) 428 errx(1, "malloc failed"); 429 strcpy(temp, val); 430 memset(&chanlist, 0, sizeof(chanlist)); 431 cp = temp; 432 for (;;) { 433 int first, last, f; 434 435 tp = strchr(cp, ','); 436 if (tp != NULL) 437 *tp++ = '\0'; 438 switch (sscanf(cp, "%u-%u", &first, &last)) { 439 case 1: 440 if (first > MAXCHAN) 441 errx(-1, "channel %u out of range, max %zu", 442 first, MAXCHAN); 443 setbit(chanlist.ic_channels, first); 444 break; 445 case 2: 446 if (first > MAXCHAN) 447 errx(-1, "channel %u out of range, max %zu", 448 first, MAXCHAN); 449 if (last > MAXCHAN) 450 errx(-1, "channel %u out of range, max %zu", 451 last, MAXCHAN); 452 if (first > last) 453 errx(-1, "void channel range, %u > %u", 454 first, last); 455 for (f = first; f <= last; f++) 456 setbit(chanlist.ic_channels, f); 457 break; 458 } 459 if (tp == NULL) 460 break; 461 while (isspace(*tp)) 462 tp++; 463 if (!isdigit(*tp)) 464 break; 465 cp = tp; 466 } 467 set80211(s, IEEE80211_IOC_CHANLIST, 0, 468 sizeof(chanlist), (uint8_t *) &chanlist); 469 #undef MAXCHAN 470 } 471 472 static void 473 set80211bssid(const char *val, int d, int s, const struct afswtch *rafp) 474 { 475 476 if (!isanyarg(val)) { 477 char *temp; 478 struct sockaddr_dl sdl; 479 480 temp = malloc(strlen(val) + 2); /* ':' and '\0' */ 481 if (temp == NULL) 482 errx(1, "malloc failed"); 483 temp[0] = ':'; 484 strcpy(temp + 1, val); 485 sdl.sdl_len = sizeof(sdl); 486 link_addr(temp, &sdl); 487 free(temp); 488 if (sdl.sdl_alen != IEEE80211_ADDR_LEN) 489 errx(1, "malformed link-level address"); 490 set80211(s, IEEE80211_IOC_BSSID, 0, 491 IEEE80211_ADDR_LEN, LLADDR(&sdl)); 492 } else { 493 uint8_t zerobssid[IEEE80211_ADDR_LEN]; 494 memset(zerobssid, 0, sizeof(zerobssid)); 495 set80211(s, IEEE80211_IOC_BSSID, 0, 496 IEEE80211_ADDR_LEN, zerobssid); 497 } 498 } 499 500 static int 501 getac(const char *ac) 502 { 503 if (strcasecmp(ac, "ac_be") == 0 || strcasecmp(ac, "be") == 0) 504 return WME_AC_BE; 505 if (strcasecmp(ac, "ac_bk") == 0 || strcasecmp(ac, "bk") == 0) 506 return WME_AC_BK; 507 if (strcasecmp(ac, "ac_vi") == 0 || strcasecmp(ac, "vi") == 0) 508 return WME_AC_VI; 509 if (strcasecmp(ac, "ac_vo") == 0 || strcasecmp(ac, "vo") == 0) 510 return WME_AC_VO; 511 errx(1, "unknown wme access class %s", ac); 512 } 513 514 static 515 DECL_CMD_FUNC2(set80211cwmin, ac, val) 516 { 517 set80211(s, IEEE80211_IOC_WME_CWMIN, atoi(val), getac(ac), NULL); 518 } 519 520 static 521 DECL_CMD_FUNC2(set80211cwmax, ac, val) 522 { 523 set80211(s, IEEE80211_IOC_WME_CWMAX, atoi(val), getac(ac), NULL); 524 } 525 526 static 527 DECL_CMD_FUNC2(set80211aifs, ac, val) 528 { 529 set80211(s, IEEE80211_IOC_WME_AIFS, atoi(val), getac(ac), NULL); 530 } 531 532 static 533 DECL_CMD_FUNC2(set80211txoplimit, ac, val) 534 { 535 set80211(s, IEEE80211_IOC_WME_TXOPLIMIT, atoi(val), getac(ac), NULL); 536 } 537 538 static 539 DECL_CMD_FUNC(set80211acm, ac, d) 540 { 541 set80211(s, IEEE80211_IOC_WME_ACM, 1, getac(ac), NULL); 542 } 543 static 544 DECL_CMD_FUNC(set80211noacm, ac, d) 545 { 546 set80211(s, IEEE80211_IOC_WME_ACM, 0, getac(ac), NULL); 547 } 548 549 static 550 DECL_CMD_FUNC(set80211ackpolicy, ac, d) 551 { 552 set80211(s, IEEE80211_IOC_WME_ACKPOLICY, 1, getac(ac), NULL); 553 } 554 static 555 DECL_CMD_FUNC(set80211noackpolicy, ac, d) 556 { 557 set80211(s, IEEE80211_IOC_WME_ACKPOLICY, 0, getac(ac), NULL); 558 } 559 560 static 561 DECL_CMD_FUNC2(set80211bsscwmin, ac, val) 562 { 563 set80211(s, IEEE80211_IOC_WME_CWMIN, atoi(val), 564 getac(ac)|IEEE80211_WMEPARAM_BSS, NULL); 565 } 566 567 static 568 DECL_CMD_FUNC2(set80211bsscwmax, ac, val) 569 { 570 set80211(s, IEEE80211_IOC_WME_CWMAX, atoi(val), 571 getac(ac)|IEEE80211_WMEPARAM_BSS, NULL); 572 } 573 574 static 575 DECL_CMD_FUNC2(set80211bssaifs, ac, val) 576 { 577 set80211(s, IEEE80211_IOC_WME_AIFS, atoi(val), 578 getac(ac)|IEEE80211_WMEPARAM_BSS, NULL); 579 } 580 581 static 582 DECL_CMD_FUNC2(set80211bsstxoplimit, ac, val) 583 { 584 set80211(s, IEEE80211_IOC_WME_TXOPLIMIT, atoi(val), 585 getac(ac)|IEEE80211_WMEPARAM_BSS, NULL); 586 } 587 588 static 589 DECL_CMD_FUNC(set80211dtimperiod, val, d) 590 { 591 set80211(s, IEEE80211_IOC_DTIM_PERIOD, atoi(val), 0, NULL); 592 } 593 594 static 595 DECL_CMD_FUNC(set80211bintval, val, d) 596 { 597 set80211(s, IEEE80211_IOC_BEACON_INTERVAL, atoi(val), 0, NULL); 598 } 599 600 static void 601 set80211macmac(int s, int op, const char *val) 602 { 603 char *temp; 604 struct sockaddr_dl sdl; 605 606 temp = malloc(strlen(val) + 2); /* ':' and '\0' */ 607 if (temp == NULL) 608 errx(1, "malloc failed"); 609 temp[0] = ':'; 610 strcpy(temp + 1, val); 611 sdl.sdl_len = sizeof(sdl); 612 link_addr(temp, &sdl); 613 free(temp); 614 if (sdl.sdl_alen != IEEE80211_ADDR_LEN) 615 errx(1, "malformed link-level address"); 616 set80211(s, op, 0, IEEE80211_ADDR_LEN, LLADDR(&sdl)); 617 } 618 619 static 620 DECL_CMD_FUNC(set80211addmac, val, d) 621 { 622 set80211macmac(s, IEEE80211_IOC_ADDMAC, val); 623 } 624 625 static 626 DECL_CMD_FUNC(set80211delmac, val, d) 627 { 628 set80211macmac(s, IEEE80211_IOC_DELMAC, val); 629 } 630 631 static 632 DECL_CMD_FUNC(set80211kickmac, val, d) 633 { 634 char *temp; 635 struct sockaddr_dl sdl; 636 struct ieee80211req_mlme mlme; 637 638 temp = malloc(strlen(val) + 2); /* ':' and '\0' */ 639 if (temp == NULL) 640 errx(1, "malloc failed"); 641 temp[0] = ':'; 642 strcpy(temp + 1, val); 643 sdl.sdl_len = sizeof(sdl); 644 link_addr(temp, &sdl); 645 free(temp); 646 if (sdl.sdl_alen != IEEE80211_ADDR_LEN) 647 errx(1, "malformed link-level address"); 648 memset(&mlme, 0, sizeof(mlme)); 649 mlme.im_op = IEEE80211_MLME_DEAUTH; 650 mlme.im_reason = IEEE80211_REASON_AUTH_EXPIRE; 651 memcpy(mlme.im_macaddr, LLADDR(&sdl), IEEE80211_ADDR_LEN); 652 set80211(s, IEEE80211_IOC_MLME, 0, sizeof(mlme), (u_int8_t *) &mlme); 653 } 654 655 static 656 DECL_CMD_FUNC(set80211maccmd, val, d) 657 { 658 set80211(s, IEEE80211_IOC_MACCMD, d, 0, NULL); 659 } 660 661 static void 662 set80211pureg(const char *val, int d, int s, const struct afswtch *rafp) 663 { 664 set80211(s, IEEE80211_IOC_PUREG, d, 0, NULL); 665 } 666 667 static void 668 set80211burst(const char *val, int d, int s, const struct afswtch *rafp) 669 { 670 set80211(s, IEEE80211_IOC_BURST, d, 0, NULL); 671 } 672 673 static 674 DECL_CMD_FUNC(set80211mcastrate, val, d) 675 { 676 set80211(s, IEEE80211_IOC_MCAST_RATE, (int) 2*atof(val), 0, NULL); 677 } 678 679 static 680 DECL_CMD_FUNC(set80211fragthreshold, val, d) 681 { 682 set80211(s, IEEE80211_IOC_FRAGTHRESHOLD, 683 isundefarg(val) ? IEEE80211_FRAG_MAX : atoi(val), 0, NULL); 684 } 685 686 static int 687 getmaxrate(uint8_t rates[15], uint8_t nrates) 688 { 689 int i, maxrate = -1; 690 691 for (i = 0; i < nrates; i++) { 692 int rate = rates[i] & IEEE80211_RATE_VAL; 693 if (rate > maxrate) 694 maxrate = rate; 695 } 696 return maxrate / 2; 697 } 698 699 static const char * 700 getcaps(int capinfo) 701 { 702 static char capstring[32]; 703 char *cp = capstring; 704 705 if (capinfo & IEEE80211_CAPINFO_ESS) 706 *cp++ = 'E'; 707 if (capinfo & IEEE80211_CAPINFO_IBSS) 708 *cp++ = 'I'; 709 if (capinfo & IEEE80211_CAPINFO_CF_POLLABLE) 710 *cp++ = 'c'; 711 if (capinfo & IEEE80211_CAPINFO_CF_POLLREQ) 712 *cp++ = 'C'; 713 if (capinfo & IEEE80211_CAPINFO_PRIVACY) 714 *cp++ = 'P'; 715 if (capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE) 716 *cp++ = 'S'; 717 if (capinfo & IEEE80211_CAPINFO_PBCC) 718 *cp++ = 'B'; 719 if (capinfo & IEEE80211_CAPINFO_CHNL_AGILITY) 720 *cp++ = 'A'; 721 if (capinfo & IEEE80211_CAPINFO_SHORT_SLOTTIME) 722 *cp++ = 's'; 723 if (capinfo & IEEE80211_CAPINFO_RSN) 724 *cp++ = 'R'; 725 if (capinfo & IEEE80211_CAPINFO_DSSSOFDM) 726 *cp++ = 'D'; 727 *cp = '\0'; 728 return capstring; 729 } 730 731 static void 732 printie(const char* tag, const uint8_t *ie, size_t ielen, int maxlen) 733 { 734 printf("%s", tag); 735 if (verbose) { 736 maxlen -= strlen(tag)+2; 737 if (2*ielen > maxlen) 738 maxlen--; 739 printf("<"); 740 for (; ielen > 0; ie++, ielen--) { 741 if (maxlen-- <= 0) 742 break; 743 printf("%02x", *ie); 744 } 745 if (ielen != 0) 746 printf("-"); 747 printf(">"); 748 } 749 } 750 751 /* 752 * Copy the ssid string contents into buf, truncating to fit. If the 753 * ssid is entirely printable then just copy intact. Otherwise convert 754 * to hexadecimal. If the result is truncated then replace the last 755 * three characters with "...". 756 */ 757 static int 758 copy_essid(char buf[], size_t bufsize, const u_int8_t *essid, size_t essid_len) 759 { 760 const u_int8_t *p; 761 size_t maxlen; 762 int i; 763 764 if (essid_len > bufsize) 765 maxlen = bufsize; 766 else 767 maxlen = essid_len; 768 /* determine printable or not */ 769 for (i = 0, p = essid; i < maxlen; i++, p++) { 770 if (*p < ' ' || *p > 0x7e) 771 break; 772 } 773 if (i != maxlen) { /* not printable, print as hex */ 774 if (bufsize < 3) 775 return 0; 776 strlcpy(buf, "0x", bufsize); 777 bufsize -= 2; 778 p = essid; 779 for (i = 0; i < maxlen && bufsize >= 2; i++) { 780 sprintf(&buf[2+2*i], "%02x", p[i]); 781 bufsize -= 2; 782 } 783 if (i != essid_len) 784 memcpy(&buf[2+2*i-3], "...", 3); 785 } else { /* printable, truncate as needed */ 786 memcpy(buf, essid, maxlen); 787 if (maxlen != essid_len) 788 memcpy(&buf[maxlen-3], "...", 3); 789 } 790 return maxlen; 791 } 792 793 /* unaligned little endian access */ 794 #define LE_READ_4(p) \ 795 ((u_int32_t) \ 796 ((((const u_int8_t *)(p))[0] ) | \ 797 (((const u_int8_t *)(p))[1] << 8) | \ 798 (((const u_int8_t *)(p))[2] << 16) | \ 799 (((const u_int8_t *)(p))[3] << 24))) 800 801 static int __inline 802 iswpaoui(const u_int8_t *frm) 803 { 804 return frm[1] > 3 && LE_READ_4(frm+2) == ((WPA_OUI_TYPE<<24)|WPA_OUI); 805 } 806 807 static int __inline 808 iswmeoui(const u_int8_t *frm) 809 { 810 return frm[1] > 3 && LE_READ_4(frm+2) == ((WME_OUI_TYPE<<24)|WME_OUI); 811 } 812 813 static int __inline 814 isatherosoui(const u_int8_t *frm) 815 { 816 return frm[1] > 3 && LE_READ_4(frm+2) == ((ATH_OUI_TYPE<<24)|ATH_OUI); 817 } 818 819 static void 820 printies(const u_int8_t *vp, int ielen, int maxcols) 821 { 822 while (ielen > 0) { 823 switch (vp[0]) { 824 case IEEE80211_ELEMID_VENDOR: 825 if (iswpaoui(vp)) 826 printie(" WPA", vp, 2+vp[1], maxcols); 827 else if (iswmeoui(vp)) 828 printie(" WME", vp, 2+vp[1], maxcols); 829 else if (isatherosoui(vp)) 830 printie(" ATH", vp, 2+vp[1], maxcols); 831 else 832 printie(" VEN", vp, 2+vp[1], maxcols); 833 break; 834 case IEEE80211_ELEMID_RSN: 835 printie(" RSN", vp, 2+vp[1], maxcols); 836 break; 837 default: 838 printie(" ???", vp, 2+vp[1], maxcols); 839 break; 840 } 841 ielen -= 2+vp[1]; 842 vp += 2+vp[1]; 843 } 844 } 845 846 static void 847 list_scan(int s) 848 { 849 uint8_t buf[24*1024]; 850 struct ieee80211req ireq; 851 char ssid[IEEE80211_NWID_LEN+1]; 852 uint8_t *cp; 853 int len, ssidmax; 854 855 (void) memset(&ireq, 0, sizeof(ireq)); 856 (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name)); 857 ireq.i_type = IEEE80211_IOC_SCAN_RESULTS; 858 ireq.i_data = buf; 859 ireq.i_len = sizeof(buf); 860 if (ioctl(s, SIOCG80211, &ireq) < 0) 861 errx(1, "unable to get scan results"); 862 len = ireq.i_len; 863 if (len < sizeof(struct ieee80211req_scan_result)) 864 return; 865 866 ssidmax = verbose ? IEEE80211_NWID_LEN : 14; 867 printf("%-*.*s %-17.17s %4s %4s %-5s %3s %4s\n" 868 , ssidmax, ssidmax, "SSID" 869 , "BSSID" 870 , "CHAN" 871 , "RATE" 872 , "S:N" 873 , "INT" 874 , "CAPS" 875 ); 876 cp = buf; 877 do { 878 struct ieee80211req_scan_result *sr; 879 uint8_t *vp; 880 881 sr = (struct ieee80211req_scan_result *) cp; 882 vp = (u_int8_t *)(sr+1); 883 printf("%-*.*s %s %3d %3dM %2d:%-2d %3d %-4.4s" 884 , ssidmax 885 , copy_essid(ssid, ssidmax, vp, sr->isr_ssid_len) 886 , ssid 887 , ether_ntoa((const struct ether_addr *) sr->isr_bssid) 888 , ieee80211_mhz2ieee(sr->isr_freq) 889 , getmaxrate(sr->isr_rates, sr->isr_nrates) 890 , sr->isr_rssi, sr->isr_noise 891 , sr->isr_intval 892 , getcaps(sr->isr_capinfo) 893 ); 894 printies(vp + sr->isr_ssid_len, sr->isr_ie_len, 24);; 895 printf("\n"); 896 cp += sr->isr_len, len -= sr->isr_len; 897 } while (len >= sizeof(struct ieee80211req_scan_result)); 898 } 899 900 #include <netproto/802_11/ieee80211_dragonfly.h> 901 902 static void 903 scan_and_wait(int s) 904 { 905 struct ieee80211req ireq; 906 int sroute; 907 908 sroute = socket(PF_ROUTE, SOCK_RAW, 0); 909 if (sroute < 0) { 910 perror("socket(PF_ROUTE,SOCK_RAW)"); 911 return; 912 } 913 (void) memset(&ireq, 0, sizeof(ireq)); 914 (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name)); 915 ireq.i_type = IEEE80211_IOC_SCAN_REQ; 916 /* NB: only root can trigger a scan so ignore errors */ 917 if (ioctl(s, SIOCS80211, &ireq) >= 0) { 918 char buf[2048]; 919 struct if_announcemsghdr *ifan; 920 struct rt_msghdr *rtm; 921 922 do { 923 if (read(sroute, buf, sizeof(buf)) < 0) { 924 perror("read(PF_ROUTE)"); 925 break; 926 } 927 rtm = (struct rt_msghdr *) buf; 928 if (rtm->rtm_version != RTM_VERSION) 929 break; 930 ifan = (struct if_announcemsghdr *) rtm; 931 } while (rtm->rtm_type != RTM_IEEE80211 || 932 ifan->ifan_what != RTM_IEEE80211_SCAN); 933 } 934 close(sroute); 935 } 936 937 static 938 DECL_CMD_FUNC(set80211scan, val, d) 939 { 940 scan_and_wait(s); 941 list_scan(s); 942 } 943 944 static void 945 list_stations(int s) 946 { 947 uint8_t buf[24*1024]; 948 struct ieee80211req ireq; 949 uint8_t *cp; 950 int len; 951 952 (void) memset(&ireq, 0, sizeof(ireq)); 953 (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name)); 954 ireq.i_type = IEEE80211_IOC_STA_INFO; 955 ireq.i_data = buf; 956 ireq.i_len = sizeof(buf); 957 if (ioctl(s, SIOCG80211, &ireq) < 0) 958 errx(1, "unable to get station information"); 959 len = ireq.i_len; 960 if (len < sizeof(struct ieee80211req_sta_info)) 961 return; 962 963 printf("%-17.17s %4s %4s %4s %4s %4s %6s %6s %4s %3s\n" 964 , "ADDR" 965 , "AID" 966 , "CHAN" 967 , "RATE" 968 , "RSSI" 969 , "IDLE" 970 , "TXSEQ" 971 , "RXSEQ" 972 , "CAPS" 973 , "ERP" 974 ); 975 cp = buf; 976 do { 977 struct ieee80211req_sta_info *si; 978 uint8_t *vp; 979 980 si = (struct ieee80211req_sta_info *) cp; 981 vp = (u_int8_t *)(si+1); 982 printf("%s %4u %4d %3dM %4d %4d %6d %6d %-4.4s %3x" 983 , ether_ntoa((const struct ether_addr*) si->isi_macaddr) 984 , IEEE80211_AID(si->isi_associd) 985 , ieee80211_mhz2ieee(si->isi_freq) 986 , (si->isi_rates[si->isi_txrate] & IEEE80211_RATE_VAL)/2 987 , si->isi_rssi 988 , si->isi_inact 989 , si->isi_txseqs[0] 990 , si->isi_rxseqs[0] 991 , getcaps(si->isi_capinfo) 992 , si->isi_erp 993 ); 994 printies(vp, si->isi_ie_len, 24); 995 printf("\n"); 996 cp += si->isi_len, len -= si->isi_len; 997 } while (len >= sizeof(struct ieee80211req_sta_info)); 998 } 999 1000 static void 1001 print_chaninfo(const struct ieee80211_channel *c) 1002 { 1003 #define IEEE80211_IS_CHAN_PASSIVE(_c) \ 1004 (((_c)->ic_flags & IEEE80211_CHAN_PASSIVE)) 1005 char buf[14]; 1006 1007 buf[0] = '\0'; 1008 if (IEEE80211_IS_CHAN_FHSS(c)) 1009 strlcat(buf, " FHSS", sizeof(buf)); 1010 if (IEEE80211_IS_CHAN_A(c)) 1011 strlcat(buf, " 11a", sizeof(buf)); 1012 /* XXX 11g schizophrenia */ 1013 if (IEEE80211_IS_CHAN_G(c) || 1014 IEEE80211_IS_CHAN_PUREG(c)) 1015 strlcat(buf, " 11g", sizeof(buf)); 1016 else if (IEEE80211_IS_CHAN_B(c)) 1017 strlcat(buf, " 11b", sizeof(buf)); 1018 if (IEEE80211_IS_CHAN_T(c)) 1019 strlcat(buf, " Turbo", sizeof(buf)); 1020 printf("Channel %3u : %u%c Mhz%-14.14s", 1021 ieee80211_mhz2ieee(c->ic_freq), c->ic_freq, 1022 IEEE80211_IS_CHAN_PASSIVE(c) ? '*' : ' ', buf); 1023 #undef IEEE80211_IS_CHAN_PASSIVE 1024 } 1025 1026 static void 1027 list_channels(int s, int allchans) 1028 { 1029 struct ieee80211req ireq; 1030 struct ieee80211req_chaninfo chans; 1031 struct ieee80211req_chaninfo achans; 1032 const struct ieee80211_channel *c; 1033 int i, half; 1034 1035 (void) memset(&ireq, 0, sizeof(ireq)); 1036 (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name)); 1037 ireq.i_type = IEEE80211_IOC_CHANINFO; 1038 ireq.i_data = &chans; 1039 ireq.i_len = sizeof(chans); 1040 if (ioctl(s, SIOCG80211, &ireq) < 0) 1041 errx(1, "unable to get channel information"); 1042 if (!allchans) { 1043 struct ieee80211req_chanlist active; 1044 1045 ireq.i_type = IEEE80211_IOC_CHANLIST; 1046 ireq.i_data = &active; 1047 ireq.i_len = sizeof(active); 1048 if (ioctl(s, SIOCG80211, &ireq) < 0) 1049 errx(1, "unable to get active channel list"); 1050 memset(&achans, 0, sizeof(achans)); 1051 for (i = 0; i < chans.ic_nchans; i++) { 1052 c = &chans.ic_chans[i]; 1053 if (isset(active.ic_channels, ieee80211_mhz2ieee(c->ic_freq)) || allchans) 1054 achans.ic_chans[achans.ic_nchans++] = *c; 1055 } 1056 } else 1057 achans = chans; 1058 half = achans.ic_nchans / 2; 1059 if (achans.ic_nchans % 2) 1060 half++; 1061 for (i = 0; i < achans.ic_nchans / 2; i++) { 1062 print_chaninfo(&achans.ic_chans[i]); 1063 print_chaninfo(&achans.ic_chans[half+i]); 1064 printf("\n"); 1065 } 1066 if (achans.ic_nchans % 2) { 1067 print_chaninfo(&achans.ic_chans[i]); 1068 printf("\n"); 1069 } 1070 } 1071 1072 static void 1073 list_keys(int s) 1074 { 1075 } 1076 1077 #define IEEE80211_C_BITS \ 1078 "\020\1WEP\2TKIP\3AES\4AES_CCM\6CKIP\11IBSS\12PMGT\13HOSTAP\14AHDEMO" \ 1079 "\15SWRETRY\16TXPMGT\17SHSLOT\20SHPREAMBLE\21MONITOR\22TKIPMIC\30WPA1" \ 1080 "\31WPA2\32BURST\33WME" 1081 1082 static void 1083 list_capabilities(int s) 1084 { 1085 struct ieee80211req ireq; 1086 u_int32_t caps; 1087 1088 (void) memset(&ireq, 0, sizeof(ireq)); 1089 (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name)); 1090 ireq.i_type = IEEE80211_IOC_DRIVER_CAPS; 1091 if (ioctl(s, SIOCG80211, &ireq) < 0) 1092 errx(1, "unable to get driver capabilities"); 1093 caps = (((u_int16_t) ireq.i_val) << 16) | ((u_int16_t) ireq.i_len); 1094 printb(name, caps, IEEE80211_C_BITS); 1095 putchar('\n'); 1096 } 1097 1098 static void 1099 list_wme(int s) 1100 { 1101 static const char *acnames[] = { "AC_BE", "AC_BK", "AC_VI", "AC_VO" }; 1102 struct ieee80211req ireq; 1103 int ac; 1104 1105 (void) memset(&ireq, 0, sizeof(ireq)); 1106 (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name)); 1107 ireq.i_len = 0; 1108 for (ac = WME_AC_BE; ac <= WME_AC_VO; ac++) { 1109 again: 1110 if (ireq.i_len & IEEE80211_WMEPARAM_BSS) 1111 printf("\t%s", " "); 1112 else 1113 printf("\t%s", acnames[ac]); 1114 1115 ireq.i_len = (ireq.i_len & IEEE80211_WMEPARAM_BSS) | ac; 1116 1117 /* show WME BSS parameters */ 1118 ireq.i_type = IEEE80211_IOC_WME_CWMIN; 1119 if (ioctl(s, SIOCG80211, &ireq) != -1) 1120 printf(" cwmin %2u", ireq.i_val); 1121 ireq.i_type = IEEE80211_IOC_WME_CWMAX; 1122 if (ioctl(s, SIOCG80211, &ireq) != -1) 1123 printf(" cwmax %2u", ireq.i_val); 1124 ireq.i_type = IEEE80211_IOC_WME_AIFS; 1125 if (ioctl(s, SIOCG80211, &ireq) != -1) 1126 printf(" aifs %2u", ireq.i_val); 1127 ireq.i_type = IEEE80211_IOC_WME_TXOPLIMIT; 1128 if (ioctl(s, SIOCG80211, &ireq) != -1) 1129 printf(" txopLimit %3u", ireq.i_val); 1130 ireq.i_type = IEEE80211_IOC_WME_ACM; 1131 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1132 if (ireq.i_val) 1133 printf(" acm"); 1134 else if (verbose) 1135 printf(" -acm"); 1136 } 1137 /* !BSS only */ 1138 if ((ireq.i_len & IEEE80211_WMEPARAM_BSS) == 0) { 1139 ireq.i_type = IEEE80211_IOC_WME_ACKPOLICY; 1140 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1141 if (!ireq.i_val) 1142 printf(" -ack"); 1143 else if (verbose) 1144 printf(" ack"); 1145 } 1146 } 1147 printf("\n"); 1148 if ((ireq.i_len & IEEE80211_WMEPARAM_BSS) == 0) { 1149 ireq.i_len |= IEEE80211_WMEPARAM_BSS; 1150 goto again; 1151 } else 1152 ireq.i_len &= ~IEEE80211_WMEPARAM_BSS; 1153 } 1154 } 1155 1156 static void 1157 list_mac(int s) 1158 { 1159 struct ieee80211req ireq; 1160 struct ieee80211req_maclist *acllist; 1161 int i, nacls, policy; 1162 char c; 1163 1164 (void) memset(&ireq, 0, sizeof(ireq)); 1165 (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name)); /* XXX ?? */ 1166 ireq.i_type = IEEE80211_IOC_MACCMD; 1167 ireq.i_val = IEEE80211_MACCMD_POLICY; 1168 if (ioctl(s, SIOCG80211, &ireq) < 0) { 1169 if (errno == EINVAL) { 1170 printf("No acl policy loaded\n"); 1171 return; 1172 } 1173 err(1, "unable to get mac policy"); 1174 } 1175 policy = ireq.i_val; 1176 1177 ireq.i_val = IEEE80211_MACCMD_LIST; 1178 ireq.i_len = 0; 1179 if (ioctl(s, SIOCG80211, &ireq) < 0) 1180 err(1, "unable to get mac acl list size"); 1181 if (ireq.i_len == 0) /* NB: no acls */ 1182 return; 1183 1184 ireq.i_data = malloc(ireq.i_len); 1185 if (ireq.i_data == NULL) 1186 err(1, "out of memory for acl list"); 1187 1188 if (ioctl(s, SIOCG80211, &ireq) < 0) 1189 err(1, "unable to get mac acl list"); 1190 if (policy == IEEE80211_MACCMD_POLICY_OPEN) { 1191 if (verbose) 1192 printf("policy: open\n"); 1193 c = '*'; 1194 } else if (policy == IEEE80211_MACCMD_POLICY_ALLOW) { 1195 if (verbose) 1196 printf("policy: allow\n"); 1197 c = '+'; 1198 } else if (policy == IEEE80211_MACCMD_POLICY_DENY) { 1199 if (verbose) 1200 printf("policy: deny\n"); 1201 c = '-'; 1202 } else { 1203 printf("policy: unknown (%u)\n", policy); 1204 c = '?'; 1205 } 1206 nacls = ireq.i_len / sizeof(*acllist); 1207 acllist = (struct ieee80211req_maclist *) ireq.i_data; 1208 for (i = 0; i < nacls; i++) 1209 printf("%c%s\n", c, ether_ntoa( 1210 (const struct ether_addr *) acllist[i].ml_macaddr)); 1211 } 1212 1213 static 1214 DECL_CMD_FUNC(set80211list, arg, d) 1215 { 1216 #define iseq(a,b) (strncasecmp(a,b,sizeof(b)-1) == 0) 1217 1218 if (iseq(arg, "sta")) 1219 list_stations(s); 1220 else if (iseq(arg, "scan") || iseq(arg, "ap")) 1221 list_scan(s); 1222 else if (iseq(arg, "chan") || iseq(arg, "freq")) 1223 list_channels(s, 1); 1224 else if (iseq(arg, "active")) 1225 list_channels(s, 0); 1226 else if (iseq(arg, "keys")) 1227 list_keys(s); 1228 else if (iseq(arg, "caps")) 1229 list_capabilities(s); 1230 else if (iseq(arg, "wme")) 1231 list_wme(s); 1232 else if (iseq(arg, "mac")) 1233 list_mac(s); 1234 else 1235 errx(1, "Don't know how to list %s for %s", arg, name); 1236 #undef iseq 1237 } 1238 1239 static enum ieee80211_opmode 1240 get80211opmode(int s) 1241 { 1242 struct ifmediareq ifmr; 1243 1244 (void) memset(&ifmr, 0, sizeof(ifmr)); 1245 (void) strncpy(ifmr.ifm_name, name, sizeof(ifmr.ifm_name)); 1246 1247 if (ioctl(s, SIOCGIFMEDIA, (caddr_t)&ifmr) >= 0) { 1248 if (ifmr.ifm_current & IFM_IEEE80211_ADHOC) 1249 return IEEE80211_M_IBSS; /* XXX ahdemo */ 1250 if (ifmr.ifm_current & IFM_IEEE80211_HOSTAP) 1251 return IEEE80211_M_HOSTAP; 1252 if (ifmr.ifm_current & IFM_IEEE80211_MONITOR) 1253 return IEEE80211_M_MONITOR; 1254 } 1255 return IEEE80211_M_STA; 1256 } 1257 1258 static const struct ieee80211_channel * 1259 getchaninfo(int s, int chan) 1260 { 1261 struct ieee80211req ireq; 1262 static struct ieee80211req_chaninfo chans; 1263 static struct ieee80211_channel undef; 1264 const struct ieee80211_channel *c; 1265 int i, freq; 1266 1267 (void) memset(&ireq, 0, sizeof(ireq)); 1268 (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name)); 1269 ireq.i_type = IEEE80211_IOC_CHANINFO; 1270 ireq.i_data = &chans; 1271 ireq.i_len = sizeof(chans); 1272 if (ioctl(s, SIOCG80211, &ireq) < 0) 1273 errx(1, "unable to get channel information"); 1274 freq = ieee80211_ieee2mhz(chan); 1275 for (i = 0; i < chans.ic_nchans; i++) { 1276 c = &chans.ic_chans[i]; 1277 if (c->ic_freq == freq) 1278 return c; 1279 } 1280 return &undef; 1281 } 1282 1283 #if 0 1284 static void 1285 printcipher(int s, struct ieee80211req *ireq, int keylenop) 1286 { 1287 switch (ireq->i_val) { 1288 case IEEE80211_CIPHER_WEP: 1289 ireq->i_type = keylenop; 1290 if (ioctl(s, SIOCG80211, ireq) != -1) 1291 printf("WEP-%s", 1292 ireq->i_len <= 5 ? "40" : 1293 ireq->i_len <= 13 ? "104" : "128"); 1294 else 1295 printf("WEP"); 1296 break; 1297 case IEEE80211_CIPHER_TKIP: 1298 printf("TKIP"); 1299 break; 1300 case IEEE80211_CIPHER_AES_OCB: 1301 printf("AES-OCB"); 1302 break; 1303 case IEEE80211_CIPHER_AES_CCM: 1304 printf("AES-CCM"); 1305 break; 1306 case IEEE80211_CIPHER_CKIP: 1307 printf("CKIP"); 1308 break; 1309 case IEEE80211_CIPHER_NONE: 1310 printf("NONE"); 1311 break; 1312 default: 1313 printf("UNKNOWN (0x%x)", ireq->i_val); 1314 break; 1315 } 1316 } 1317 #endif 1318 1319 #define MAXCOL 78 1320 static int col; 1321 static char spacer; 1322 1323 static void 1324 LINE_BREAK(void) 1325 { 1326 if (spacer != '\t') { 1327 printf("\n"); 1328 spacer = '\t'; 1329 } 1330 col = 8; /* 8-col tab */ 1331 } 1332 1333 static void 1334 LINE_CHECK(const char *fmt, ...) 1335 { 1336 char buf[80]; 1337 va_list ap; 1338 int n; 1339 1340 va_start(ap, fmt); 1341 n = vsnprintf(buf+1, sizeof(buf)-1, fmt, ap); 1342 va_end(ap); 1343 col += 1+n; 1344 if (col > MAXCOL) { 1345 LINE_BREAK(); 1346 col += n; 1347 } 1348 buf[0] = spacer; 1349 printf("%s", buf); 1350 spacer = ' '; 1351 } 1352 1353 static void 1354 printkey(const struct ieee80211req_key *ik) 1355 { 1356 static const uint8_t zerodata[IEEE80211_KEYBUF_SIZE]; 1357 int keylen = ik->ik_keylen; 1358 int printcontents; 1359 1360 printcontents = printkeys && 1361 (memcmp(ik->ik_keydata, zerodata, keylen) != 0 || verbose); 1362 if (printcontents) 1363 LINE_BREAK(); 1364 switch (ik->ik_type) { 1365 case IEEE80211_CIPHER_WEP: 1366 /* compatibility */ 1367 LINE_CHECK("wepkey %u:%s", ik->ik_keyix+1, 1368 keylen <= 5 ? "40-bit" : 1369 keylen <= 13 ? "104-bit" : "128-bit"); 1370 break; 1371 case IEEE80211_CIPHER_TKIP: 1372 if (keylen > 128/8) 1373 keylen -= 128/8; /* ignore MIC for now */ 1374 LINE_CHECK("TKIP %u:%u-bit", ik->ik_keyix+1, 8*keylen); 1375 break; 1376 case IEEE80211_CIPHER_AES_OCB: 1377 LINE_CHECK("AES-OCB %u:%u-bit", ik->ik_keyix+1, 8*keylen); 1378 break; 1379 case IEEE80211_CIPHER_AES_CCM: 1380 LINE_CHECK("AES-CCM %u:%u-bit", ik->ik_keyix+1, 8*keylen); 1381 break; 1382 case IEEE80211_CIPHER_CKIP: 1383 LINE_CHECK("CKIP %u:%u-bit", ik->ik_keyix+1, 8*keylen); 1384 break; 1385 case IEEE80211_CIPHER_NONE: 1386 LINE_CHECK("NULL %u:%u-bit", ik->ik_keyix+1, 8*keylen); 1387 break; 1388 default: 1389 LINE_CHECK("UNKNOWN (0x%x) %u:%u-bit", 1390 ik->ik_type, ik->ik_keyix+1, 8*keylen); 1391 break; 1392 } 1393 if (printcontents) { 1394 int i; 1395 1396 printf(" <"); 1397 for (i = 0; i < keylen; i++) 1398 printf("%02x", ik->ik_keydata[i]); 1399 printf(">"); 1400 if (ik->ik_type != IEEE80211_CIPHER_WEP && 1401 (ik->ik_keyrsc != 0 || verbose)) 1402 printf(" rsc %ju", (uintmax_t)ik->ik_keyrsc); 1403 if (ik->ik_type != IEEE80211_CIPHER_WEP && 1404 (ik->ik_keytsc != 0 || verbose)) 1405 printf(" tsc %ju", (uintmax_t)ik->ik_keytsc); 1406 if (ik->ik_flags != 0 && verbose) { 1407 const char *sep = " "; 1408 1409 if (ik->ik_flags & IEEE80211_KEY_XMIT) 1410 printf("%stx", sep), sep = "+"; 1411 if (ik->ik_flags & IEEE80211_KEY_RECV) 1412 printf("%srx", sep), sep = "+"; 1413 if (ik->ik_flags & IEEE80211_KEY_DEFAULT) 1414 printf("%sdef", sep), sep = "+"; 1415 } 1416 LINE_BREAK(); 1417 } 1418 } 1419 1420 static void 1421 ieee80211_status(int s) 1422 { 1423 static const uint8_t zerobssid[IEEE80211_ADDR_LEN]; 1424 enum ieee80211_opmode opmode = get80211opmode(s); 1425 int i, num, wpa, wme; 1426 struct ieee80211req ireq; 1427 u_int8_t data[32]; 1428 const struct ieee80211_channel *c; 1429 1430 (void) memset(&ireq, 0, sizeof(ireq)); 1431 (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name)); 1432 ireq.i_data = &data; 1433 1434 wpa = 0; /* unknown/not set */ 1435 1436 ireq.i_type = IEEE80211_IOC_SSID; 1437 ireq.i_val = -1; 1438 if (ioctl(s, SIOCG80211, &ireq) < 0) { 1439 /* If we can't get the SSID, this isn't an 802.11 device. */ 1440 return; 1441 } 1442 num = 0; 1443 ireq.i_type = IEEE80211_IOC_NUMSSIDS; 1444 if (ioctl(s, SIOCG80211, &ireq) >= 0) 1445 num = ireq.i_val; 1446 printf("\tssid "); 1447 if (num > 1) { 1448 ireq.i_type = IEEE80211_IOC_SSID; 1449 for (ireq.i_val = 0; ireq.i_val < num; ireq.i_val++) { 1450 if (ioctl(s, SIOCG80211, &ireq) >= 0 && ireq.i_len > 0) { 1451 printf(" %d:", ireq.i_val + 1); 1452 print_string(data, ireq.i_len); 1453 } 1454 } 1455 } else 1456 print_string(data, ireq.i_len); 1457 1458 ireq.i_type = IEEE80211_IOC_CHANNEL; 1459 if (ioctl(s, SIOCG80211, &ireq) < 0) 1460 goto end; 1461 c = getchaninfo(s, ireq.i_val); 1462 if (ireq.i_val != -1) { 1463 printf(" channel %d", ireq.i_val); 1464 if (verbose) 1465 printf(" (%u)", c->ic_freq); 1466 } else if (verbose) 1467 printf(" channel UNDEF"); 1468 1469 ireq.i_type = IEEE80211_IOC_BSSID; 1470 ireq.i_len = IEEE80211_ADDR_LEN; 1471 if (ioctl(s, SIOCG80211, &ireq) >= 0 && 1472 (memcmp(ireq.i_data, zerobssid, sizeof(zerobssid)) != 0 || verbose)) 1473 printf(" bssid %s", ether_ntoa(ireq.i_data)); 1474 1475 ireq.i_type = IEEE80211_IOC_STATIONNAME; 1476 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1477 printf("\n\tstationname "); 1478 print_string(data, ireq.i_len); 1479 } 1480 1481 spacer = ' '; /* force first break */ 1482 LINE_BREAK(); 1483 1484 ireq.i_type = IEEE80211_IOC_AUTHMODE; 1485 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1486 switch (ireq.i_val) { 1487 case IEEE80211_AUTH_NONE: 1488 LINE_CHECK("authmode NONE"); 1489 break; 1490 case IEEE80211_AUTH_OPEN: 1491 LINE_CHECK("authmode OPEN"); 1492 break; 1493 case IEEE80211_AUTH_SHARED: 1494 LINE_CHECK("authmode SHARED"); 1495 break; 1496 case IEEE80211_AUTH_8021X: 1497 LINE_CHECK("authmode 802.1x"); 1498 break; 1499 case IEEE80211_AUTH_WPA: 1500 ireq.i_type = IEEE80211_IOC_WPA; 1501 if (ioctl(s, SIOCG80211, &ireq) != -1) 1502 wpa = ireq.i_val; 1503 if (!wpa) 1504 wpa = 1; /* default to WPA1 */ 1505 switch (wpa) { 1506 case 2: 1507 LINE_CHECK("authmode WPA2/802.11i"); 1508 break; 1509 case 3: 1510 LINE_CHECK("authmode WPA1+WPA2/802.11i"); 1511 break; 1512 default: 1513 LINE_CHECK("authmode WPA"); 1514 break; 1515 } 1516 break; 1517 case IEEE80211_AUTH_AUTO: 1518 LINE_CHECK("authmode AUTO"); 1519 break; 1520 default: 1521 LINE_CHECK("authmode UNKNOWN (0x%x)", 1522 ireq.i_val); 1523 break; 1524 } 1525 } 1526 1527 ireq.i_type = IEEE80211_IOC_WEP; 1528 if (ioctl(s, SIOCG80211, &ireq) != -1 && 1529 ireq.i_val != IEEE80211_WEP_NOSUP) { 1530 int firstkey, wepmode; 1531 1532 wepmode = ireq.i_val; 1533 switch (wepmode) { 1534 case IEEE80211_WEP_OFF: 1535 LINE_CHECK("privacy OFF"); 1536 break; 1537 case IEEE80211_WEP_ON: 1538 LINE_CHECK("privacy ON"); 1539 break; 1540 case IEEE80211_WEP_MIXED: 1541 LINE_CHECK("privacy MIXED"); 1542 break; 1543 default: 1544 LINE_CHECK("privacy UNKNOWN (0x%x)", wepmode); 1545 break; 1546 } 1547 1548 /* 1549 * If we get here then we've got WEP support so we need 1550 * to print WEP status. 1551 */ 1552 1553 ireq.i_type = IEEE80211_IOC_WEPTXKEY; 1554 if (ioctl(s, SIOCG80211, &ireq) < 0) { 1555 warn("WEP support, but no tx key!"); 1556 goto end; 1557 } 1558 if (ireq.i_val != -1) 1559 LINE_CHECK("deftxkey %d", ireq.i_val+1); 1560 else if (wepmode != IEEE80211_WEP_OFF || verbose) 1561 LINE_CHECK("deftxkey UNDEF"); 1562 1563 ireq.i_type = IEEE80211_IOC_NUMWEPKEYS; 1564 if (ioctl(s, SIOCG80211, &ireq) < 0) { 1565 warn("WEP support, but no NUMWEPKEYS support!"); 1566 goto end; 1567 } 1568 num = ireq.i_val; 1569 1570 firstkey = 1; 1571 for (i = 0; i < num; i++) { 1572 struct ieee80211req_key ik; 1573 1574 memset(&ik, 0, sizeof(ik)); 1575 ik.ik_keyix = i; 1576 ireq.i_type = IEEE80211_IOC_WPAKEY; 1577 ireq.i_data = &ik; 1578 ireq.i_len = sizeof(ik); 1579 if (ioctl(s, SIOCG80211, &ireq) < 0) { 1580 warn("WEP support, but can get keys!"); 1581 goto end; 1582 } 1583 if (ik.ik_keylen != 0) { 1584 if (verbose) 1585 LINE_BREAK(); 1586 printkey(&ik); 1587 firstkey = 0; 1588 } 1589 } 1590 } 1591 1592 ireq.i_type = IEEE80211_IOC_POWERSAVE; 1593 if (ioctl(s, SIOCG80211, &ireq) != -1 && 1594 ireq.i_val != IEEE80211_POWERSAVE_NOSUP ) { 1595 if (ireq.i_val != IEEE80211_POWERSAVE_OFF || verbose) { 1596 switch (ireq.i_val) { 1597 case IEEE80211_POWERSAVE_OFF: 1598 LINE_CHECK("powersavemode OFF"); 1599 break; 1600 case IEEE80211_POWERSAVE_CAM: 1601 LINE_CHECK("powersavemode CAM"); 1602 break; 1603 case IEEE80211_POWERSAVE_PSP: 1604 LINE_CHECK("powersavemode PSP"); 1605 break; 1606 case IEEE80211_POWERSAVE_PSP_CAM: 1607 LINE_CHECK("powersavemode PSP-CAM"); 1608 break; 1609 } 1610 ireq.i_type = IEEE80211_IOC_POWERSAVESLEEP; 1611 if (ioctl(s, SIOCG80211, &ireq) != -1) 1612 LINE_CHECK("powersavesleep %d", ireq.i_val); 1613 } 1614 } 1615 1616 ireq.i_type = IEEE80211_IOC_TXPOWMAX; 1617 if (ioctl(s, SIOCG80211, &ireq) != -1) 1618 LINE_CHECK("txpowmax %d", ireq.i_val); 1619 1620 if (verbose) { 1621 ireq.i_type = IEEE80211_IOC_TXPOWER; 1622 if (ioctl(s, SIOCG80211, &ireq) != -1) 1623 LINE_CHECK("txpower %d", ireq.i_val); 1624 } 1625 1626 ireq.i_type = IEEE80211_IOC_RTSTHRESHOLD; 1627 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1628 if (ireq.i_val != IEEE80211_RTS_MAX || verbose) 1629 LINE_CHECK("rtsthreshold %d", ireq.i_val); 1630 } 1631 1632 ireq.i_type = IEEE80211_IOC_MCAST_RATE; 1633 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1634 if (ireq.i_val != 2*1 || verbose) { 1635 if (ireq.i_val == 11) 1636 LINE_CHECK("mcastrate 5.5"); 1637 else 1638 LINE_CHECK("mcastrate %d", ireq.i_val/2); 1639 } 1640 } 1641 1642 ireq.i_type = IEEE80211_IOC_FRAGTHRESHOLD; 1643 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1644 if (ireq.i_val != IEEE80211_FRAG_MAX || verbose) 1645 LINE_CHECK("fragthreshold %d", ireq.i_val); 1646 } 1647 1648 if (IEEE80211_IS_CHAN_G(c) || IEEE80211_IS_CHAN_PUREG(c) || verbose) { 1649 ireq.i_type = IEEE80211_IOC_PUREG; 1650 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1651 if (ireq.i_val) 1652 LINE_CHECK("pureg"); 1653 else if (verbose) 1654 LINE_CHECK("-pureg"); 1655 } 1656 ireq.i_type = IEEE80211_IOC_PROTMODE; 1657 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1658 switch (ireq.i_val) { 1659 case IEEE80211_PROTMODE_OFF: 1660 LINE_CHECK("protmode OFF"); 1661 break; 1662 case IEEE80211_PROTMODE_CTS: 1663 LINE_CHECK("protmode CTS"); 1664 break; 1665 case IEEE80211_PROTMODE_RTSCTS: 1666 LINE_CHECK("protmode RTSCTS"); 1667 break; 1668 default: 1669 LINE_CHECK("protmode UNKNOWN (0x%x)", 1670 ireq.i_val); 1671 break; 1672 } 1673 } 1674 } 1675 1676 ireq.i_type = IEEE80211_IOC_WME; 1677 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1678 wme = ireq.i_val; 1679 if (wme) 1680 LINE_CHECK("wme"); 1681 else if (verbose) 1682 LINE_CHECK("-wme"); 1683 } else 1684 wme = 0; 1685 1686 ireq.i_type = IEEE80211_IOC_BURST; 1687 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1688 if (ireq.i_val) 1689 LINE_CHECK("burst"); 1690 else if (verbose) 1691 LINE_CHECK("-burst"); 1692 } 1693 1694 if (opmode == IEEE80211_M_HOSTAP) { 1695 ireq.i_type = IEEE80211_IOC_HIDESSID; 1696 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1697 if (ireq.i_val) 1698 LINE_CHECK("ssid HIDE"); 1699 else if (verbose) 1700 LINE_CHECK("ssid SHOW"); 1701 } 1702 1703 ireq.i_type = IEEE80211_IOC_APBRIDGE; 1704 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1705 if (!ireq.i_val) 1706 LINE_CHECK("-apbridge"); 1707 else if (verbose) 1708 LINE_CHECK("apbridge"); 1709 } 1710 1711 ireq.i_type = IEEE80211_IOC_DTIM_PERIOD; 1712 if (ioctl(s, SIOCG80211, &ireq) != -1) 1713 LINE_CHECK("dtimperiod %u", ireq.i_val); 1714 } else { 1715 ireq.i_type = IEEE80211_IOC_ROAMING; 1716 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1717 if (ireq.i_val != IEEE80211_ROAMING_AUTO || verbose) { 1718 switch (ireq.i_val) { 1719 case IEEE80211_ROAMING_DEVICE: 1720 LINE_CHECK("roaming DEVICE"); 1721 break; 1722 case IEEE80211_ROAMING_AUTO: 1723 LINE_CHECK("roaming AUTO"); 1724 break; 1725 case IEEE80211_ROAMING_MANUAL: 1726 LINE_CHECK("roaming MANUAL"); 1727 break; 1728 default: 1729 LINE_CHECK("roaming UNKNOWN (0x%x)", 1730 ireq.i_val); 1731 break; 1732 } 1733 } 1734 } 1735 } 1736 ireq.i_type = IEEE80211_IOC_BEACON_INTERVAL; 1737 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1738 if (ireq.i_val) 1739 LINE_CHECK("bintval %u", ireq.i_val); 1740 else if (verbose) 1741 LINE_CHECK("bintval %u", ireq.i_val); 1742 } 1743 1744 if (wme && verbose) { 1745 LINE_BREAK(); 1746 list_wme(s); 1747 } 1748 1749 if (wpa) { 1750 ireq.i_type = IEEE80211_IOC_COUNTERMEASURES; 1751 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1752 if (ireq.i_val) 1753 LINE_CHECK("countermeasures"); 1754 else if (verbose) 1755 LINE_CHECK("-countermeasures"); 1756 } 1757 #if 0 1758 /* XXX not interesting with WPA done in user space */ 1759 ireq.i_type = IEEE80211_IOC_KEYMGTALGS; 1760 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1761 } 1762 1763 ireq.i_type = IEEE80211_IOC_MCASTCIPHER; 1764 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1765 LINE_CHECK("mcastcipher "); 1766 printcipher(s, &ireq, IEEE80211_IOC_MCASTKEYLEN); 1767 spacer = ' '; 1768 } 1769 1770 ireq.i_type = IEEE80211_IOC_UCASTCIPHER; 1771 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1772 LINE_CHECK("ucastcipher "); 1773 printcipher(s, &ireq, IEEE80211_IOC_UCASTKEYLEN); 1774 } 1775 1776 if (wpa & 2) { 1777 ireq.i_type = IEEE80211_IOC_RSNCAPS; 1778 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1779 LINE_CHECK("RSN caps 0x%x", ireq.i_val); 1780 spacer = ' '; 1781 } 1782 } 1783 1784 ireq.i_type = IEEE80211_IOC_UCASTCIPHERS; 1785 if (ioctl(s, SIOCG80211, &ireq) != -1) { 1786 } 1787 #endif 1788 LINE_BREAK(); 1789 } 1790 LINE_BREAK(); 1791 1792 end: 1793 return; 1794 } 1795 1796 static void 1797 set80211(int s, int type, int val, int len, u_int8_t *data) 1798 { 1799 struct ieee80211req ireq; 1800 1801 (void) memset(&ireq, 0, sizeof(ireq)); 1802 (void) strncpy(ireq.i_name, name, sizeof(ireq.i_name)); 1803 ireq.i_type = type; 1804 ireq.i_val = val; 1805 ireq.i_len = len; 1806 ireq.i_data = data; 1807 if (ioctl(s, SIOCS80211, &ireq) < 0) 1808 err(1, "SIOCS80211"); 1809 } 1810 1811 static const char * 1812 get_string(const char *val, const char *sep, u_int8_t *buf, int *lenp) 1813 { 1814 int len; 1815 int hexstr; 1816 u_int8_t *p; 1817 1818 len = *lenp; 1819 p = buf; 1820 hexstr = (val[0] == '0' && tolower((u_char)val[1]) == 'x'); 1821 if (hexstr) 1822 val += 2; 1823 for (;;) { 1824 if (*val == '\0') 1825 break; 1826 if (sep != NULL && strchr(sep, *val) != NULL) { 1827 val++; 1828 break; 1829 } 1830 if (hexstr) { 1831 if (!isxdigit((u_char)val[0])) { 1832 warnx("bad hexadecimal digits"); 1833 return NULL; 1834 } 1835 if (!isxdigit((u_char)val[1])) { 1836 warnx("odd count hexadecimal digits"); 1837 return NULL; 1838 } 1839 } 1840 if (p >= buf + len) { 1841 if (hexstr) 1842 warnx("hexadecimal digits too long"); 1843 else 1844 warnx("string too long"); 1845 return NULL; 1846 } 1847 if (hexstr) { 1848 #define tohex(x) (isdigit(x) ? (x) - '0' : tolower(x) - 'a' + 10) 1849 *p++ = (tohex((u_char)val[0]) << 4) | 1850 tohex((u_char)val[1]); 1851 #undef tohex 1852 val += 2; 1853 } else 1854 *p++ = *val++; 1855 } 1856 len = p - buf; 1857 /* The string "-" is treated as the empty string. */ 1858 if (!hexstr && len == 1 && buf[0] == '-') 1859 len = 0; 1860 if (len < *lenp) 1861 memset(p, 0, *lenp - len); 1862 *lenp = len; 1863 return val; 1864 } 1865 1866 static void 1867 print_string(const u_int8_t *buf, int len) 1868 { 1869 int i; 1870 int hasspc; 1871 1872 i = 0; 1873 hasspc = 0; 1874 for (; i < len; i++) { 1875 if (!isprint(buf[i]) && buf[i] != '\0') 1876 break; 1877 if (isspace(buf[i])) 1878 hasspc++; 1879 } 1880 if (i == len) { 1881 if (hasspc || len == 0 || buf[0] == '\0') 1882 printf("\"%.*s\"", len, buf); 1883 else 1884 printf("%.*s", len, buf); 1885 } else { 1886 printf("0x"); 1887 for (i = 0; i < len; i++) 1888 printf("%02x", buf[i]); 1889 } 1890 } 1891 1892 static struct cmd ieee80211_cmds[] = { 1893 DEF_CMD_ARG("ssid", set80211ssid), 1894 DEF_CMD_ARG("nwid", set80211ssid), 1895 DEF_CMD_ARG("stationname", set80211stationname), 1896 DEF_CMD_ARG("station", set80211stationname), /* BSD/OS */ 1897 DEF_CMD_ARG("channel", set80211channel), 1898 DEF_CMD_ARG("authmode", set80211authmode), 1899 DEF_CMD_ARG("powersavemode", set80211powersavemode), 1900 DEF_CMD("powersave", 1, set80211powersave), 1901 DEF_CMD("-powersave", 0, set80211powersave), 1902 DEF_CMD_ARG("powersavesleep", set80211powersavesleep), 1903 DEF_CMD_ARG("wepmode", set80211wepmode), 1904 DEF_CMD("wep", 1, set80211wep), 1905 DEF_CMD("-wep", 0, set80211wep), 1906 DEF_CMD_ARG("deftxkey", set80211weptxkey), 1907 DEF_CMD_ARG("weptxkey", set80211weptxkey), 1908 DEF_CMD_ARG("wepkey", set80211wepkey), 1909 DEF_CMD_ARG("nwkey", set80211nwkey), /* NetBSD */ 1910 DEF_CMD("-nwkey", 0, set80211wep), /* NetBSD */ 1911 DEF_CMD_ARG("rtsthreshold", set80211rtsthreshold), 1912 DEF_CMD_ARG("protmode", set80211protmode), 1913 DEF_CMD_ARG("txpower", set80211txpower), 1914 DEF_CMD_ARG("roaming", set80211roaming), 1915 DEF_CMD("wme", 1, set80211wme), 1916 DEF_CMD("-wme", 0, set80211wme), 1917 DEF_CMD("hidessid", 1, set80211hidessid), 1918 DEF_CMD("-hidessid", 0, set80211hidessid), 1919 DEF_CMD("apbridge", 1, set80211apbridge), 1920 DEF_CMD("-apbridge", 0, set80211apbridge), 1921 DEF_CMD_ARG("chanlist", set80211chanlist), 1922 DEF_CMD_ARG("bssid", set80211bssid), 1923 DEF_CMD_ARG("ap", set80211bssid), 1924 DEF_CMD("scan", 0, set80211scan), 1925 DEF_CMD_ARG("list", set80211list), 1926 DEF_CMD_ARG2("cwmin", set80211cwmin), 1927 DEF_CMD_ARG2("cwmax", set80211cwmax), 1928 DEF_CMD_ARG2("aifs", set80211aifs), 1929 DEF_CMD_ARG2("txoplimit", set80211txoplimit), 1930 DEF_CMD_ARG("acm", set80211acm), 1931 DEF_CMD_ARG("-acm", set80211noacm), 1932 DEF_CMD_ARG("ack", set80211ackpolicy), 1933 DEF_CMD_ARG("-ack", set80211noackpolicy), 1934 DEF_CMD_ARG2("bss:cwmin", set80211bsscwmin), 1935 DEF_CMD_ARG2("bss:cwmax", set80211bsscwmax), 1936 DEF_CMD_ARG2("bss:aifs", set80211bssaifs), 1937 DEF_CMD_ARG2("bss:txoplimit", set80211bsstxoplimit), 1938 DEF_CMD_ARG("dtimperiod", set80211dtimperiod), 1939 DEF_CMD_ARG("bintval", set80211bintval), 1940 DEF_CMD("mac:open", IEEE80211_MACCMD_POLICY_OPEN, set80211maccmd), 1941 DEF_CMD("mac:allow", IEEE80211_MACCMD_POLICY_ALLOW, set80211maccmd), 1942 DEF_CMD("mac:deny", IEEE80211_MACCMD_POLICY_DENY, set80211maccmd), 1943 DEF_CMD("mac:flush", IEEE80211_MACCMD_FLUSH, set80211maccmd), 1944 DEF_CMD("mac:detach", IEEE80211_MACCMD_DETACH, set80211maccmd), 1945 DEF_CMD_ARG("mac:add", set80211addmac), 1946 DEF_CMD_ARG("mac:del", set80211delmac), 1947 DEF_CMD_ARG("mac:kick", set80211kickmac), 1948 DEF_CMD("pureg", 1, set80211pureg), 1949 DEF_CMD("-pureg", 0, set80211pureg), 1950 DEF_CMD_ARG("mcastrate", set80211mcastrate), 1951 DEF_CMD_ARG("fragthreshold", set80211fragthreshold), 1952 DEF_CMD("burst", 1, set80211burst), 1953 DEF_CMD("-burst", 0, set80211burst), 1954 }; 1955 static struct afswtch af_ieee80211 = { 1956 .af_name = "af_ieee80211", 1957 .af_af = AF_UNSPEC, 1958 .af_other_status = ieee80211_status, 1959 }; 1960 1961 static __constructor void 1962 ieee80211_ctor(void) 1963 { 1964 #define N(a) (sizeof(a) / sizeof(a[0])) 1965 int i; 1966 1967 for (i = 0; i < N(ieee80211_cmds); i++) 1968 cmd_register(&ieee80211_cmds[i]); 1969 af_register(&af_ieee80211); 1970 #undef N 1971 } 1972