ieee80211.c revision 1.14
1 /* $NetBSD: ieee80211.c,v 1.14 2008/05/06 17:29:04 dyoung Exp $ */ 2 3 /* 4 * Copyright (c) 1983, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 __RCSID("$NetBSD: ieee80211.c,v 1.14 2008/05/06 17:29:04 dyoung Exp $"); 35 #endif /* not lint */ 36 37 #include <sys/param.h> 38 #include <sys/ioctl.h> 39 #include <sys/socket.h> 40 41 #include <net/if.h> 42 #include <net/if_ether.h> 43 #include <net/if_media.h> 44 #include <net/route.h> 45 #include <net80211/ieee80211.h> 46 #include <net80211/ieee80211_ioctl.h> 47 #include <net80211/ieee80211_netbsd.h> 48 49 #include <assert.h> 50 #include <ctype.h> 51 #include <err.h> 52 #include <errno.h> 53 #include <netdb.h> 54 #include <string.h> 55 #include <stddef.h> 56 #include <stdlib.h> 57 #include <stdio.h> 58 #include <unistd.h> 59 #include <util.h> 60 61 #include "extern.h" 62 #include "ieee80211.h" 63 #include "parse.h" 64 #include "env.h" 65 66 static int set80211(prop_dictionary_t env, int, int, int, u_int8_t *); 67 static u_int ieee80211_mhz2ieee(u_int, u_int); 68 static int getmaxrate(const uint8_t [15], u_int8_t); 69 static const char * getcaps(int); 70 static void printie(const char*, const uint8_t *, size_t, int); 71 static int copy_essid(char [], size_t, const u_int8_t *, size_t); 72 static void scan_and_wait(prop_dictionary_t); 73 static void list_scan(prop_dictionary_t); 74 static int mappsb(u_int , u_int); 75 static int mapgsm(u_int , u_int); 76 77 static void printies(const u_int8_t *, int, int); 78 static void printie(const char* , const uint8_t *, size_t , int); 79 static void printwmeparam(const char *, const u_int8_t *, size_t , int); 80 static void printwmeinfo(const char *, const u_int8_t *, size_t , int); 81 static const char * wpa_cipher(const u_int8_t *); 82 static const char * wpa_keymgmt(const u_int8_t *); 83 static void printwpaie(const char *, const u_int8_t *, size_t , int); 84 static const char * rsn_cipher(const u_int8_t *); 85 static const char * rsn_keymgmt(const u_int8_t *); 86 static void printrsnie(const char *, const u_int8_t *, size_t , int); 87 static void printssid(const char *, const u_int8_t *, size_t , int); 88 static void printrates(const char *, const u_int8_t *, size_t , int); 89 static void printcountry(const char *, const u_int8_t *, size_t , int); 90 static int iswpaoui(const u_int8_t *); 91 static int iswmeinfo(const u_int8_t *); 92 static int iswmeparam(const u_int8_t *); 93 static const char * iename(int); 94 95 extern int vflag; 96 97 struct kwinst ieee80211boolkw[] = { 98 {.k_word = "hidessid", .k_key = "hidessid", .k_neg = true, 99 .k_type = KW_T_BOOL, .k_bool = true, .k_negbool = false, 100 .k_exec = sethidessid} 101 , {.k_word = "apbridge", .k_key = "apbridge", .k_neg = true, 102 .k_type = KW_T_BOOL, .k_bool = true, .k_negbool = false, 103 .k_exec = setapbridge} 104 , {.k_word = "powersave", .k_key = "powersave", .k_neg = true, 105 .k_type = KW_T_BOOL, .k_bool = true, .k_negbool = false, 106 .k_exec = setifpowersave} 107 }; 108 109 struct pkw ieee80211bool = PKW_INITIALIZER(&ieee80211bool, "ieee80211 boolean", 110 NULL, NULL, ieee80211boolkw, __arraycount(ieee80211boolkw), 111 &command_root.pb_parser); 112 113 struct pinteger parse_chan = PINTEGER_INITIALIZER1(&parse_chan, "chan", 114 0, UINT16_MAX, 10, setifchan, "chan", &command_root.pb_parser); 115 116 struct pinteger parse_frag = PINTEGER_INITIALIZER1(&parse_frag, "frag", 117 IEEE80211_FRAG_MIN, IEEE80211_FRAG_MAX, 10, 118 setiffrag, "frag", &command_root.pb_parser); 119 120 struct pstr parse_ssid = PSTR_INITIALIZER(&parse_pass, "ssid", setifssid, 121 "ssid", &command_root.pb_parser); 122 123 struct kwinst listskw[] = { 124 {.k_word = "scan", .k_exec = scan_exec} 125 }; 126 127 struct pkw lists = PKW_INITIALIZER(&lists, "lists", NULL, "list", listskw, 128 __arraycount(listskw), &command_root.pb_parser); 129 130 struct pinteger parse_powersavesleep = 131 PINTEGER_INITIALIZER1(&parse_powersavesleep, "powersavesleep", 132 0, INT_MAX, 10, setifpowersavesleep, "powersavesleep", 133 &command_root.pb_parser); 134 135 struct pstr parse_nwkey = PSTR_INITIALIZER(&parse_nwkey, "nwkey", setifnwkey, 136 "nwkey", &command_root.pb_parser); 137 138 struct pstr parse_bssid = PSTR_INITIALIZER(&parse_bssid, "bssid", setifbssid, 139 "bssid", &command_root.pb_parser); 140 141 static int 142 set80211(prop_dictionary_t env, int type, int val, int len, u_int8_t *data) 143 { 144 struct ieee80211req ireq; 145 const char *ifname; 146 int s; 147 148 if ((s = getsock(AF_UNSPEC)) == -1) 149 return -1; 150 151 if ((ifname = getifname(env)) == NULL) 152 return -1; 153 154 (void)memset(&ireq, 0, sizeof(ireq)); 155 estrlcpy(ireq.i_name, ifname, sizeof(ireq.i_name)); 156 ireq.i_type = type; 157 ireq.i_val = val; 158 ireq.i_len = len; 159 ireq.i_data = data; 160 if (ioctl(s, SIOCS80211, &ireq) == -1) { 161 warn("SIOCS80211"); 162 return -1; 163 } 164 return 0; 165 } 166 167 int 168 sethidessid(prop_dictionary_t env, prop_dictionary_t xenv) 169 { 170 prop_bool_t on; 171 172 on = (prop_bool_t)prop_dictionary_get(env, "hidessid"); 173 assert(on != NULL); 174 return set80211(env, IEEE80211_IOC_HIDESSID, 175 prop_bool_true(on) ? 1 : 0, 0, NULL); 176 } 177 178 int 179 setapbridge(prop_dictionary_t env, prop_dictionary_t xenv) 180 { 181 prop_bool_t on; 182 183 on = (prop_bool_t)prop_dictionary_get(env, "apbridge"); 184 assert(on != NULL); 185 return set80211(env, IEEE80211_IOC_APBRIDGE, 186 prop_bool_true(on) ? 1 : 0, 0, NULL); 187 } 188 189 static enum ieee80211_opmode 190 get80211opmode(prop_dictionary_t env) 191 { 192 struct ifmediareq ifmr; 193 const char *ifname; 194 int s; 195 196 if ((s = getsock(AF_UNSPEC)) == -1) 197 return -1; 198 199 if ((ifname = getifname(env)) == NULL) 200 return -1; 201 202 (void) memset(&ifmr, 0, sizeof(ifmr)); 203 estrlcpy(ifmr.ifm_name, ifname, sizeof(ifmr.ifm_name)); 204 if (ioctl(s, SIOCGIFMEDIA, (caddr_t)&ifmr) >= 0) { 205 if (ifmr.ifm_current & IFM_IEEE80211_ADHOC) 206 return IEEE80211_M_IBSS; /* XXX ahdemo */ 207 if (ifmr.ifm_current & IFM_IEEE80211_HOSTAP) 208 return IEEE80211_M_HOSTAP; 209 if (ifmr.ifm_current & IFM_IEEE80211_MONITOR) 210 return IEEE80211_M_MONITOR; 211 } 212 213 return IEEE80211_M_STA; 214 } 215 216 int 217 setifssid(prop_dictionary_t env, prop_dictionary_t xenv) 218 { 219 struct ieee80211_nwid nwid; 220 int s; 221 ssize_t len; 222 const char *ifname; 223 struct ifreq ifr; 224 225 if ((ifname = getifname(env)) == NULL) 226 return -1; 227 228 if ((s = getsock(AF_UNSPEC)) == -1) 229 err(EXIT_FAILURE, "%s: getsock", __func__); 230 231 memset(&nwid, 0, sizeof(nwid)); 232 if ((len = getargdata(env, "ssid", nwid.i_nwid, 233 sizeof(nwid.i_nwid))) == -1) 234 errx(EXIT_FAILURE, "%s: SSID too long", __func__); 235 nwid.i_len = (uint8_t)len; 236 memset(&ifr, 0, sizeof(ifr)); 237 if ((ifname = getifname(env)) == NULL) 238 err(EXIT_FAILURE, "%s: getifname", __func__); 239 estrlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); 240 ifr.ifr_data = &nwid; 241 if (ioctl(s, SIOCS80211NWID, &ifr) == -1) 242 err(EXIT_FAILURE, "SIOCS80211NWID"); 243 return 0; 244 } 245 246 int 247 unsetifbssid(prop_dictionary_t env, prop_dictionary_t xenv) 248 { 249 struct ieee80211_bssid bssid; 250 const char *ifname; 251 int s; 252 253 if ((s = getsock(AF_UNSPEC)) == -1) 254 err(EXIT_FAILURE, "%s: getsock", __func__); 255 256 memset(&bssid.i_bssid, 0, sizeof(bssid.i_bssid)); 257 258 if ((ifname = getifname(env)) == NULL) 259 return -1; 260 estrlcpy(bssid.i_name, ifname, sizeof(bssid.i_name)); 261 if (ioctl(s, SIOCS80211BSSID, &bssid) == -1) 262 err(EXIT_FAILURE, "SIOCS80211BSSID"); 263 return 0; 264 } 265 266 int 267 setifbssid(prop_dictionary_t env, prop_dictionary_t xenv) 268 { 269 char buf[24]; 270 struct ieee80211_bssid bssid; 271 const char *ifname; 272 struct ether_addr *ea; 273 int s; 274 275 if (getargstr(env, "bssid", buf, sizeof(buf)) == -1) 276 errx(EXIT_FAILURE, "%s: BSSID too long", __func__); 277 if ((s = getsock(AF_UNSPEC)) == -1) 278 err(EXIT_FAILURE, "%s: getsock", __func__); 279 280 ea = ether_aton(buf); 281 if (ea == NULL) { 282 errx(EXIT_FAILURE, "malformed BSSID: %s", buf); 283 return -1; 284 } 285 memcpy(&bssid.i_bssid, ea->ether_addr_octet, 286 sizeof(bssid.i_bssid)); 287 288 if ((ifname = getifname(env)) == NULL) 289 return -1; 290 estrlcpy(bssid.i_name, ifname, sizeof(bssid.i_name)); 291 if (ioctl(s, SIOCS80211BSSID, &bssid) == -1) 292 err(EXIT_FAILURE, "SIOCS80211BSSID"); 293 return 0; 294 } 295 296 int 297 setiffrag(prop_dictionary_t env, prop_dictionary_t xenv) 298 { 299 prop_number_t num; 300 const char *ifname; 301 struct ieee80211req ireq; 302 int s; 303 304 if ((s = getsock(AF_UNSPEC)) == -1) 305 return -1; 306 307 if ((ifname = getifname(env)) == NULL) 308 return -1; 309 310 num = (prop_number_t)prop_dictionary_get(env, "frag"); 311 assert(num != NULL); 312 313 estrlcpy(ireq.i_name, ifname, sizeof(ireq.i_name)); 314 ireq.i_type = IEEE80211_IOC_FRAGTHRESHOLD; 315 ireq.i_val = (int16_t)prop_number_integer_value(num); 316 if (ioctl(s, SIOCS80211, &ireq) == -1) 317 err(EXIT_FAILURE, "IEEE80211_IOC_FRAGTHRESHOLD"); 318 return 0; 319 } 320 321 int 322 setifchan(prop_dictionary_t env, prop_dictionary_t xenv) 323 { 324 prop_number_t num; 325 const char *ifname; 326 struct ieee80211chanreq channel; 327 int s; 328 329 if ((s = getsock(AF_UNSPEC)) == -1) 330 return -1; 331 332 if ((ifname = getifname(env)) == NULL) 333 return -1; 334 335 num = (prop_number_t)prop_dictionary_get(env, "chan"); 336 assert(num != NULL); 337 338 estrlcpy(channel.i_name, ifname, sizeof(channel.i_name)); 339 channel.i_channel = (uint16_t)prop_number_integer_value(num); 340 if (ioctl(s, SIOCS80211CHANNEL, &channel) == -1) 341 err(EXIT_FAILURE, "SIOCS80211CHANNEL"); 342 return 0; 343 } 344 345 int 346 setifnwkey(prop_dictionary_t env, prop_dictionary_t xenv) 347 { 348 const char *ifname, *val; 349 char buf[256]; 350 struct ieee80211_nwkey nwkey; 351 int i; 352 u_int8_t keybuf[IEEE80211_WEP_NKID][16]; 353 int s; 354 355 if ((s = getsock(AF_UNSPEC)) == -1) 356 err(EXIT_FAILURE, "%s: getsock", __func__); 357 358 if (getargstr(env, "nwkey", buf, sizeof(buf)) == -1) 359 errx(EXIT_FAILURE, "%s: nwkey too long", __func__); 360 361 val = buf; 362 363 nwkey.i_wepon = IEEE80211_NWKEY_WEP; 364 nwkey.i_defkid = 1; 365 for (i = 0; i < IEEE80211_WEP_NKID; i++) { 366 nwkey.i_key[i].i_keylen = sizeof(keybuf[i]); 367 nwkey.i_key[i].i_keydat = keybuf[i]; 368 } 369 if (strcasecmp("persist", val) == 0) { 370 /* use all values from persistent memory */ 371 nwkey.i_wepon |= IEEE80211_NWKEY_PERSIST; 372 nwkey.i_defkid = 0; 373 for (i = 0; i < IEEE80211_WEP_NKID; i++) 374 nwkey.i_key[i].i_keylen = -1; 375 } else if (strncasecmp("persist:", val, 8) == 0) { 376 val += 8; 377 /* program keys in persistent memory */ 378 nwkey.i_wepon |= IEEE80211_NWKEY_PERSIST; 379 goto set_nwkey; 380 } else { 381 set_nwkey: 382 if (isdigit((unsigned char)val[0]) && val[1] == ':') { 383 /* specifying a full set of four keys */ 384 nwkey.i_defkid = val[0] - '0'; 385 val += 2; 386 for (i = 0; i < IEEE80211_WEP_NKID; i++) { 387 val = get_string(val, ",", keybuf[i], 388 &nwkey.i_key[i].i_keylen); 389 if (val == NULL) { 390 errno = EINVAL; 391 return -1; 392 } 393 } 394 if (*val != '\0') { 395 errx(EXIT_FAILURE, "SIOCS80211NWKEY: too many keys."); 396 } 397 } else { 398 val = get_string(val, NULL, keybuf[0], 399 &nwkey.i_key[0].i_keylen); 400 if (val == NULL) { 401 errno = EINVAL; 402 return -1; 403 } 404 i = 1; 405 } 406 } 407 for (; i < IEEE80211_WEP_NKID; i++) 408 nwkey.i_key[i].i_keylen = 0; 409 410 if ((ifname = getifname(env)) == NULL) 411 return -1; 412 estrlcpy(nwkey.i_name, ifname, sizeof(nwkey.i_name)); 413 if (ioctl(s, SIOCS80211NWKEY, &nwkey) == -1) 414 err(EXIT_FAILURE, "SIOCS80211NWKEY"); 415 return 0; 416 } 417 418 int 419 unsetifnwkey(prop_dictionary_t env, prop_dictionary_t xenv) 420 { 421 const char *ifname; 422 struct ieee80211_nwkey nwkey; 423 int i, s; 424 425 if ((s = getsock(AF_UNSPEC)) == -1) 426 err(EXIT_FAILURE, "%s: getsock", __func__); 427 428 nwkey.i_wepon = 0; 429 nwkey.i_defkid = 1; 430 for (i = 0; i < IEEE80211_WEP_NKID; i++) { 431 nwkey.i_key[i].i_keylen = 0; 432 nwkey.i_key[i].i_keydat = NULL; 433 } 434 435 if ((ifname = getifname(env)) == NULL) 436 return -1; 437 438 estrlcpy(nwkey.i_name, ifname, sizeof(nwkey.i_name)); 439 if (ioctl(s, SIOCS80211NWKEY, &nwkey) == -1) 440 err(EXIT_FAILURE, "SIOCS80211NWKEY"); 441 return 0; 442 } 443 444 int 445 setifpowersave(prop_dictionary_t env, prop_dictionary_t xenv) 446 { 447 struct ieee80211_power power; 448 const char *ifname; 449 prop_bool_t on; 450 int s; 451 452 if ((s = getsock(AF_UNSPEC)) == -1) 453 err(EXIT_FAILURE, "%s: getsock", __func__); 454 455 if ((ifname = getifname(env)) == NULL) 456 return -1; 457 458 estrlcpy(power.i_name, ifname, sizeof(power.i_name)); 459 if (ioctl(s, SIOCG80211POWER, &power) == -1) { 460 err(EXIT_FAILURE, "SIOCG80211POWER"); 461 } 462 463 on = (prop_bool_t)prop_dictionary_get(env, "powersave"); 464 assert(on != NULL); 465 466 power.i_enabled = prop_bool_true(on) ? 1 : 0; 467 if (ioctl(s, SIOCS80211POWER, &power) == -1) { 468 warn("SIOCS80211POWER"); 469 return -1; 470 } 471 return 0; 472 } 473 474 int 475 setifpowersavesleep(prop_dictionary_t env, prop_dictionary_t xenv) 476 { 477 struct ieee80211_power power; 478 int s; 479 const char *ifname; 480 prop_number_t num; 481 482 if ((ifname = getifname(env)) == NULL) 483 return -1; 484 485 num = (prop_number_t)prop_dictionary_get(env, "powersavesleep"); 486 assert(num != NULL); 487 488 if ((s = getsock(AF_UNSPEC)) == -1) 489 err(EXIT_FAILURE, "%s: getsock", __func__); 490 491 estrlcpy(power.i_name, ifname, sizeof(power.i_name)); 492 if (ioctl(s, SIOCG80211POWER, &power) == -1) { 493 err(EXIT_FAILURE, "SIOCG80211POWER"); 494 } 495 496 power.i_maxsleep = (int)prop_number_integer_value(num); 497 if (ioctl(s, SIOCS80211POWER, &power) == -1) 498 err(EXIT_FAILURE, "SIOCS80211POWER"); 499 return 0; 500 } 501 502 int 503 scan_exec(prop_dictionary_t env, prop_dictionary_t xenv) 504 { 505 scan_and_wait(env); 506 list_scan(env); 507 return 0; 508 } 509 510 void 511 ieee80211_statistics(prop_dictionary_t env) 512 { 513 struct ieee80211_stats stats; 514 int s; 515 const char *ifname; 516 struct ifreq ifr; 517 518 if ((s = getsock(AF_UNSPEC)) == -1) 519 err(EXIT_FAILURE, "%s: getsock", __func__); 520 521 if ((ifname = getifname(env)) == NULL) 522 return; 523 524 memset(&ifr, 0, sizeof(ifr)); 525 if ((ifname = getifname(env)) == NULL) 526 err(EXIT_FAILURE, "%s: getifname", __func__); 527 estrlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); 528 ifr.ifr_buflen = sizeof(stats); 529 ifr.ifr_buf = (caddr_t)&stats; 530 estrlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); 531 if (ioctl(s, (zflag) ? SIOCG80211ZSTATS : SIOCG80211STATS, 532 (caddr_t)&ifr) == -1) 533 return; 534 #define STAT_PRINT(_member, _desc) \ 535 printf("\t" _desc ": %" PRIu32 "\n", stats._member) 536 537 STAT_PRINT(is_rx_badversion, "rx frame with bad version"); 538 STAT_PRINT(is_rx_tooshort, "rx frame too short"); 539 STAT_PRINT(is_rx_wrongbss, "rx from wrong bssid"); 540 STAT_PRINT(is_rx_dup, "rx discard 'cuz dup"); 541 STAT_PRINT(is_rx_wrongdir, "rx w/ wrong direction"); 542 STAT_PRINT(is_rx_mcastecho, "rx discard 'cuz mcast echo"); 543 STAT_PRINT(is_rx_notassoc, "rx discard 'cuz sta !assoc"); 544 STAT_PRINT(is_rx_noprivacy, "rx w/ wep but privacy off"); 545 STAT_PRINT(is_rx_unencrypted, "rx w/o wep and privacy on"); 546 STAT_PRINT(is_rx_wepfail, "rx wep processing failed"); 547 STAT_PRINT(is_rx_decap, "rx decapsulation failed"); 548 STAT_PRINT(is_rx_mgtdiscard, "rx discard mgt frames"); 549 STAT_PRINT(is_rx_ctl, "rx discard ctrl frames"); 550 STAT_PRINT(is_rx_beacon, "rx beacon frames"); 551 STAT_PRINT(is_rx_rstoobig, "rx rate set truncated"); 552 STAT_PRINT(is_rx_elem_missing, "rx required element missing"); 553 STAT_PRINT(is_rx_elem_toobig, "rx element too big"); 554 STAT_PRINT(is_rx_elem_toosmall, "rx element too small"); 555 STAT_PRINT(is_rx_elem_unknown, "rx element unknown"); 556 STAT_PRINT(is_rx_badchan, "rx frame w/ invalid chan"); 557 STAT_PRINT(is_rx_chanmismatch, "rx frame chan mismatch"); 558 STAT_PRINT(is_rx_nodealloc, "rx frame dropped"); 559 STAT_PRINT(is_rx_ssidmismatch, "rx frame ssid mismatch "); 560 STAT_PRINT(is_rx_auth_unsupported, "rx w/ unsupported auth alg"); 561 STAT_PRINT(is_rx_auth_fail, "rx sta auth failure"); 562 STAT_PRINT(is_rx_auth_countermeasures, "rx auth discard 'cuz CM"); 563 STAT_PRINT(is_rx_assoc_bss, "rx assoc from wrong bssid"); 564 STAT_PRINT(is_rx_assoc_notauth, "rx assoc w/o auth"); 565 STAT_PRINT(is_rx_assoc_capmismatch, "rx assoc w/ cap mismatch"); 566 STAT_PRINT(is_rx_assoc_norate, "rx assoc w/ no rate match"); 567 STAT_PRINT(is_rx_assoc_badwpaie, "rx assoc w/ bad WPA IE"); 568 STAT_PRINT(is_rx_deauth, "rx deauthentication"); 569 STAT_PRINT(is_rx_disassoc, "rx disassociation"); 570 STAT_PRINT(is_rx_badsubtype, "rx frame w/ unknown subtyp"); 571 STAT_PRINT(is_rx_nobuf, "rx failed for lack of buf"); 572 STAT_PRINT(is_rx_decryptcrc, "rx decrypt failed on crc"); 573 STAT_PRINT(is_rx_ahdemo_mgt, "rx discard ahdemo mgt fram"); 574 STAT_PRINT(is_rx_bad_auth, "rx bad auth request"); 575 STAT_PRINT(is_rx_unauth, "rx on unauthorized port"); 576 STAT_PRINT(is_rx_badkeyid, "rx w/ incorrect keyid"); 577 STAT_PRINT(is_rx_ccmpreplay, "rx seq# violation (CCMP)"); 578 STAT_PRINT(is_rx_ccmpformat, "rx format bad (CCMP)"); 579 STAT_PRINT(is_rx_ccmpmic, "rx MIC check failed (CCMP)"); 580 STAT_PRINT(is_rx_tkipreplay, "rx seq# violation (TKIP)"); 581 STAT_PRINT(is_rx_tkipformat, "rx format bad (TKIP)"); 582 STAT_PRINT(is_rx_tkipmic, "rx MIC check failed (TKIP)"); 583 STAT_PRINT(is_rx_tkipicv, "rx ICV check failed (TKIP)"); 584 STAT_PRINT(is_rx_badcipher, "rx failed 'cuz key type"); 585 STAT_PRINT(is_rx_nocipherctx, "rx failed 'cuz key !setup"); 586 STAT_PRINT(is_rx_acl, "rx discard 'cuz acl policy"); 587 588 STAT_PRINT(is_tx_nobuf, "tx failed for lack of buf"); 589 STAT_PRINT(is_tx_nonode, "tx failed for no node"); 590 STAT_PRINT(is_tx_unknownmgt, "tx of unknown mgt frame"); 591 STAT_PRINT(is_tx_badcipher, "tx failed 'cuz key type"); 592 STAT_PRINT(is_tx_nodefkey, "tx failed 'cuz no defkey"); 593 STAT_PRINT(is_tx_noheadroom, "tx failed 'cuz no space"); 594 STAT_PRINT(is_tx_fragframes, "tx frames fragmented"); 595 STAT_PRINT(is_tx_frags, "tx fragments created"); 596 597 STAT_PRINT(is_scan_active, "active scans started"); 598 STAT_PRINT(is_scan_passive, "passive scans started"); 599 STAT_PRINT(is_node_timeout, "nodes timed out inactivity"); 600 STAT_PRINT(is_crypto_nomem, "no memory for crypto ctx"); 601 STAT_PRINT(is_crypto_tkip, "tkip crypto done in s/w"); 602 STAT_PRINT(is_crypto_tkipenmic, "tkip en-MIC done in s/w"); 603 STAT_PRINT(is_crypto_tkipdemic, "tkip de-MIC done in s/w"); 604 STAT_PRINT(is_crypto_tkipcm, "tkip counter measures"); 605 STAT_PRINT(is_crypto_ccmp, "ccmp crypto done in s/w"); 606 STAT_PRINT(is_crypto_wep, "wep crypto done in s/w"); 607 STAT_PRINT(is_crypto_setkey_cipher, "cipher rejected key"); 608 STAT_PRINT(is_crypto_setkey_nokey, "no key index for setkey"); 609 STAT_PRINT(is_crypto_delkey, "driver key delete failed"); 610 STAT_PRINT(is_crypto_badcipher, "unknown cipher"); 611 STAT_PRINT(is_crypto_nocipher, "cipher not available"); 612 STAT_PRINT(is_crypto_attachfail, "cipher attach failed"); 613 STAT_PRINT(is_crypto_swfallback, "cipher fallback to s/w"); 614 STAT_PRINT(is_crypto_keyfail, "driver key alloc failed"); 615 STAT_PRINT(is_crypto_enmicfail, "en-MIC failed"); 616 STAT_PRINT(is_ibss_capmismatch, "merge failed-cap mismatch"); 617 STAT_PRINT(is_ibss_norate, "merge failed-rate mismatch"); 618 STAT_PRINT(is_ps_unassoc, "ps-poll for unassoc. sta"); 619 STAT_PRINT(is_ps_badaid, "ps-poll w/ incorrect aid"); 620 STAT_PRINT(is_ps_qempty, "ps-poll w/ nothing to send"); 621 STAT_PRINT(is_ff_badhdr, "fast frame rx'd w/ bad hdr"); 622 STAT_PRINT(is_ff_tooshort, "fast frame rx decap error"); 623 STAT_PRINT(is_ff_split, "fast frame rx split error"); 624 STAT_PRINT(is_ff_decap, "fast frames decap'd"); 625 STAT_PRINT(is_ff_encap, "fast frames encap'd for tx"); 626 STAT_PRINT(is_rx_badbintval, "rx frame w/ bogus bintval"); 627 } 628 629 void 630 ieee80211_status(prop_dictionary_t env, prop_dictionary_t oenv) 631 { 632 int i, nwkey_verbose; 633 struct ieee80211_nwid nwid; 634 struct ieee80211_nwkey nwkey; 635 struct ieee80211_power power; 636 u_int8_t keybuf[IEEE80211_WEP_NKID][16]; 637 struct ieee80211_bssid bssid; 638 struct ieee80211chanreq channel; 639 struct ieee80211req ireq; 640 struct ether_addr ea; 641 static const u_int8_t zero_macaddr[IEEE80211_ADDR_LEN]; 642 enum ieee80211_opmode opmode = get80211opmode(env); 643 int s; 644 const char *ifname; 645 struct ifreq ifr; 646 647 if ((s = getsock(AF_UNSPEC)) == -1) 648 err(EXIT_FAILURE, "%s: getsock", __func__); 649 650 if ((ifname = getifname(env)) == NULL) 651 err(EXIT_FAILURE, "%s: getifname", __func__); 652 653 memset(&ifr, 0, sizeof(ifr)); 654 estrlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); 655 ifr.ifr_data = &nwid; 656 estrlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); 657 if (ioctl(s, SIOCG80211NWID, &ifr) == -1) 658 return; 659 if (nwid.i_len > IEEE80211_NWID_LEN) { 660 errx(EXIT_FAILURE, "SIOCG80211NWID: wrong length of nwid (%d)", nwid.i_len); 661 } 662 printf("\tssid "); 663 print_string(nwid.i_nwid, nwid.i_len); 664 665 if (opmode == IEEE80211_M_HOSTAP) { 666 estrlcpy(ireq.i_name, ifname, sizeof(ireq.i_name)); 667 ireq.i_type = IEEE80211_IOC_HIDESSID; 668 if (ioctl(s, SIOCG80211, &ireq) != -1) { 669 if (ireq.i_val) 670 printf(" [hidden]"); 671 else if (vflag) 672 printf(" [shown]"); 673 } 674 675 ireq.i_type = IEEE80211_IOC_APBRIDGE; 676 if (ioctl(s, SIOCG80211, &ireq) != -1) { 677 if (ireq.i_val) 678 printf(" apbridge"); 679 else if (vflag) 680 printf(" -apbridge"); 681 } 682 } 683 684 estrlcpy(ireq.i_name, ifname, sizeof(ireq.i_name)); 685 ireq.i_type = IEEE80211_IOC_FRAGTHRESHOLD; 686 if (ioctl(s, SIOCG80211, &ireq) == -1) 687 ; 688 else if (ireq.i_val < IEEE80211_FRAG_MAX) 689 printf(" frag %d", ireq.i_val); 690 else if (vflag) 691 printf(" -frag"); 692 693 memset(&nwkey, 0, sizeof(nwkey)); 694 estrlcpy(nwkey.i_name, ifname, sizeof(nwkey.i_name)); 695 /* show nwkey only when WEP is enabled */ 696 if (ioctl(s, SIOCG80211NWKEY, &nwkey) == -1 || 697 nwkey.i_wepon == 0) { 698 printf("\n"); 699 goto skip_wep; 700 } 701 702 printf(" nwkey "); 703 /* try to retrieve WEP keys */ 704 for (i = 0; i < IEEE80211_WEP_NKID; i++) { 705 nwkey.i_key[i].i_keydat = keybuf[i]; 706 nwkey.i_key[i].i_keylen = sizeof(keybuf[i]); 707 } 708 if (ioctl(s, SIOCG80211NWKEY, &nwkey) == -1) { 709 printf("*****"); 710 } else { 711 nwkey_verbose = 0; 712 /* check to see non default key or multiple keys defined */ 713 if (nwkey.i_defkid != 1) { 714 nwkey_verbose = 1; 715 } else { 716 for (i = 1; i < IEEE80211_WEP_NKID; i++) { 717 if (nwkey.i_key[i].i_keylen != 0) { 718 nwkey_verbose = 1; 719 break; 720 } 721 } 722 } 723 /* check extra ambiguity with keywords */ 724 if (!nwkey_verbose) { 725 if (nwkey.i_key[0].i_keylen >= 2 && 726 isdigit(nwkey.i_key[0].i_keydat[0]) && 727 nwkey.i_key[0].i_keydat[1] == ':') 728 nwkey_verbose = 1; 729 else if (nwkey.i_key[0].i_keylen >= 7 && 730 strncasecmp("persist", 731 (const char *)nwkey.i_key[0].i_keydat, 7) == 0) 732 nwkey_verbose = 1; 733 } 734 if (nwkey_verbose) 735 printf("%d:", nwkey.i_defkid); 736 for (i = 0; i < IEEE80211_WEP_NKID; i++) { 737 if (i > 0) 738 printf(","); 739 if (nwkey.i_key[i].i_keylen < 0) 740 printf("persist"); 741 else 742 print_string(nwkey.i_key[i].i_keydat, 743 nwkey.i_key[i].i_keylen); 744 if (!nwkey_verbose) 745 break; 746 } 747 } 748 printf("\n"); 749 750 skip_wep: 751 estrlcpy(power.i_name, ifname, sizeof(power.i_name)); 752 if (ioctl(s, SIOCG80211POWER, &power) == -1) 753 goto skip_power; 754 printf("\tpowersave "); 755 if (power.i_enabled) 756 printf("on (%dms sleep)", power.i_maxsleep); 757 else 758 printf("off"); 759 printf("\n"); 760 761 skip_power: 762 estrlcpy(bssid.i_name, ifname, sizeof(bssid.i_name)); 763 if (ioctl(s, SIOCG80211BSSID, &bssid) == -1) 764 return; 765 estrlcpy(channel.i_name, ifname, sizeof(channel.i_name)); 766 if (ioctl(s, SIOCG80211CHANNEL, &channel) == -1) 767 return; 768 if (memcmp(bssid.i_bssid, zero_macaddr, IEEE80211_ADDR_LEN) == 0) { 769 if (channel.i_channel != (u_int16_t)-1) 770 printf("\tchan %d\n", channel.i_channel); 771 } else { 772 memcpy(ea.ether_addr_octet, bssid.i_bssid, 773 sizeof(ea.ether_addr_octet)); 774 printf("\tbssid %s", ether_ntoa(&ea)); 775 if (channel.i_channel != IEEE80211_CHAN_ANY) 776 printf(" chan %d", channel.i_channel); 777 printf("\n"); 778 } 779 } 780 781 static void 782 scan_and_wait(prop_dictionary_t env) 783 { 784 struct ieee80211req ireq; 785 int sroute; 786 int s; 787 const char *ifname; 788 789 if ((s = getsock(AF_UNSPEC)) == -1) 790 err(EXIT_FAILURE, "%s: getsock", __func__); 791 792 if ((ifname = getifname(env)) == NULL) 793 err(EXIT_FAILURE, "%s: getifname", __func__); 794 795 sroute = socket(PF_ROUTE, SOCK_RAW, 0); 796 if (sroute < 0) { 797 perror("socket(PF_ROUTE,SOCK_RAW)"); 798 return; 799 } 800 memset(&ireq, 0, sizeof(ireq)); 801 estrlcpy(ireq.i_name, ifname, sizeof(ireq.i_name)); 802 ireq.i_type = IEEE80211_IOC_SCAN_REQ; 803 /* NB: only root can trigger a scan so ignore errors */ 804 if (ioctl(s, SIOCS80211, &ireq) >= 0) { 805 char buf[2048]; 806 struct if_announcemsghdr *ifan; 807 struct rt_msghdr *rtm; 808 809 do { 810 if (read(sroute, buf, sizeof(buf)) < 0) { 811 perror("read(PF_ROUTE)"); 812 break; 813 } 814 rtm = (struct rt_msghdr *) buf; 815 if (rtm->rtm_version != RTM_VERSION) 816 break; 817 ifan = (struct if_announcemsghdr *) rtm; 818 } while (rtm->rtm_type != RTM_IEEE80211 || 819 ifan->ifan_what != RTM_IEEE80211_SCAN); 820 } 821 close(sroute); 822 } 823 824 static void 825 list_scan(prop_dictionary_t env) 826 { 827 u_int8_t buf[24*1024]; 828 struct ieee80211req ireq; 829 char ssid[IEEE80211_NWID_LEN+1]; 830 const u_int8_t *cp; 831 int len, ssidmax; 832 int s; 833 const char *ifname; 834 835 if ((s = getsock(AF_UNSPEC)) == -1) 836 err(EXIT_FAILURE, "%s: getsock", __func__); 837 838 if ((ifname = getifname(env)) == NULL) 839 return; 840 841 memset(&ireq, 0, sizeof(ireq)); 842 estrlcpy(ireq.i_name, ifname, sizeof(ireq.i_name)); 843 ireq.i_type = IEEE80211_IOC_SCAN_RESULTS; 844 ireq.i_data = buf; 845 ireq.i_len = sizeof(buf); 846 if (ioctl(s, SIOCG80211, &ireq) < 0) 847 errx(EXIT_FAILURE, "unable to get scan results"); 848 len = ireq.i_len; 849 if (len < sizeof(struct ieee80211req_scan_result)) 850 return; 851 852 ssidmax = IEEE80211_NWID_LEN; 853 printf("%-*.*s %-17.17s %4s %4s %-7s %3s %4s\n" 854 , ssidmax, ssidmax, "SSID" 855 , "BSSID" 856 , "CHAN" 857 , "RATE" 858 , "S:N" 859 , "INT" 860 , "CAPS" 861 ); 862 cp = buf; 863 do { 864 const struct ieee80211req_scan_result *sr; 865 const uint8_t *vp; 866 867 sr = (const struct ieee80211req_scan_result *) cp; 868 vp = (const u_int8_t *)(sr+1); 869 printf("%-*.*s %s %3d %3dM %3d:%-3d %3d %-4.4s" 870 , ssidmax 871 , copy_essid(ssid, ssidmax, vp, sr->isr_ssid_len) 872 , ssid 873 , ether_ntoa((const struct ether_addr *) sr->isr_bssid) 874 , ieee80211_mhz2ieee(sr->isr_freq, sr->isr_flags) 875 , getmaxrate(sr->isr_rates, sr->isr_nrates) 876 , sr->isr_rssi, sr->isr_noise 877 , sr->isr_intval 878 , getcaps(sr->isr_capinfo) 879 ); 880 printies(vp + sr->isr_ssid_len, sr->isr_ie_len, 24);; 881 printf("\n"); 882 cp += sr->isr_len, len -= sr->isr_len; 883 } while (len >= sizeof(struct ieee80211req_scan_result)); 884 } 885 /* 886 * Convert MHz frequency to IEEE channel number. 887 */ 888 static u_int 889 ieee80211_mhz2ieee(u_int isrfreq, u_int isrflags) 890 { 891 if ((isrflags & IEEE80211_CHAN_GSM) || (907 <= isrfreq && isrfreq <= 922)) 892 return mapgsm(isrfreq, isrflags); 893 if (isrfreq == 2484) 894 return 14; 895 if (isrfreq < 2484) 896 return (isrfreq - 2407) / 5; 897 if (isrfreq < 5000) { 898 if (isrflags & (IEEE80211_CHAN_HALF|IEEE80211_CHAN_QUARTER)) 899 return mappsb(isrfreq, isrflags); 900 else if (isrfreq > 4900) 901 return (isrfreq - 4000) / 5; 902 else 903 return 15 + ((isrfreq - 2512) / 20); 904 } 905 return (isrfreq - 5000) / 5; 906 } 907 908 static int 909 getmaxrate(const u_int8_t rates[15], u_int8_t nrates) 910 { 911 int i, maxrate = -1; 912 913 for (i = 0; i < nrates; i++) { 914 int rate = rates[i] & IEEE80211_RATE_VAL; 915 if (rate > maxrate) 916 maxrate = rate; 917 } 918 return maxrate / 2; 919 } 920 921 static const char * 922 getcaps(int capinfo) 923 { 924 static char capstring[32]; 925 char *cp = capstring; 926 927 if (capinfo & IEEE80211_CAPINFO_ESS) 928 *cp++ = 'E'; 929 if (capinfo & IEEE80211_CAPINFO_IBSS) 930 *cp++ = 'I'; 931 if (capinfo & IEEE80211_CAPINFO_CF_POLLABLE) 932 *cp++ = 'c'; 933 if (capinfo & IEEE80211_CAPINFO_CF_POLLREQ) 934 *cp++ = 'C'; 935 if (capinfo & IEEE80211_CAPINFO_PRIVACY) 936 *cp++ = 'P'; 937 if (capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE) 938 *cp++ = 'S'; 939 if (capinfo & IEEE80211_CAPINFO_PBCC) 940 *cp++ = 'B'; 941 if (capinfo & IEEE80211_CAPINFO_CHNL_AGILITY) 942 *cp++ = 'A'; 943 if (capinfo & IEEE80211_CAPINFO_SHORT_SLOTTIME) 944 *cp++ = 's'; 945 if (capinfo & IEEE80211_CAPINFO_RSN) 946 *cp++ = 'R'; 947 if (capinfo & IEEE80211_CAPINFO_DSSSOFDM) 948 *cp++ = 'D'; 949 *cp = '\0'; 950 return capstring; 951 } 952 953 static void 954 printie(const char* tag, const uint8_t *ie, size_t ielen, int maxlen) 955 { 956 printf("%s", tag); 957 958 maxlen -= strlen(tag)+2; 959 if (2*ielen > maxlen) 960 maxlen--; 961 printf("<"); 962 for (; ielen > 0; ie++, ielen--) { 963 if (maxlen-- <= 0) 964 break; 965 printf("%02x", *ie); 966 } 967 if (ielen != 0) 968 printf("-"); 969 printf(">"); 970 } 971 972 #define LE_READ_2(p) \ 973 ((u_int16_t) \ 974 ((((const u_int8_t *)(p))[0] ) | \ 975 (((const u_int8_t *)(p))[1] << 8))) 976 #define LE_READ_4(p) \ 977 ((u_int32_t) \ 978 ((((const u_int8_t *)(p))[0] ) | \ 979 (((const u_int8_t *)(p))[1] << 8) | \ 980 (((const u_int8_t *)(p))[2] << 16) | \ 981 (((const u_int8_t *)(p))[3] << 24))) 982 983 /* 984 * NB: The decoding routines assume a properly formatted ie 985 * which should be safe as the kernel only retains them 986 * if they parse ok. 987 */ 988 989 static void 990 printwmeparam(const char *tag, const u_int8_t *ie, size_t ielen, int maxlen) 991 { 992 #define MS(_v, _f) (((_v) & _f) >> _f##_S) 993 static const char *acnames[] = { "BE", "BK", "VO", "VI" }; 994 const struct ieee80211_wme_param *wme = 995 (const struct ieee80211_wme_param *) ie; 996 int i; 997 998 printf("%s", tag); 999 if (!vflag) 1000 return; 1001 printf("<qosinfo 0x%x", wme->param_qosInfo); 1002 ie += offsetof(struct ieee80211_wme_param, params_acParams); 1003 for (i = 0; i < WME_NUM_AC; i++) { 1004 const struct ieee80211_wme_acparams *ac = 1005 &wme->params_acParams[i]; 1006 1007 printf(" %s[%saifsn %u cwmin %u cwmax %u txop %u]" 1008 , acnames[i] 1009 , MS(ac->acp_aci_aifsn, WME_PARAM_ACM) ? "acm " : "" 1010 , MS(ac->acp_aci_aifsn, WME_PARAM_AIFSN) 1011 , MS(ac->acp_logcwminmax, WME_PARAM_LOGCWMIN) 1012 , MS(ac->acp_logcwminmax, WME_PARAM_LOGCWMAX) 1013 , LE_READ_2(&ac->acp_txop) 1014 ); 1015 } 1016 printf(">"); 1017 #undef MS 1018 } 1019 1020 static void 1021 printwmeinfo(const char *tag, const u_int8_t *ie, size_t ielen, int maxlen) 1022 { 1023 printf("%s", tag); 1024 if (vflag) { 1025 const struct ieee80211_wme_info *wme = 1026 (const struct ieee80211_wme_info *) ie; 1027 printf("<version 0x%x info 0x%x>", 1028 wme->wme_version, wme->wme_info); 1029 } 1030 } 1031 1032 static const char * 1033 wpa_cipher(const u_int8_t *sel) 1034 { 1035 #define WPA_SEL(x) (((x)<<24)|WPA_OUI) 1036 u_int32_t w = LE_READ_4(sel); 1037 1038 switch (w) { 1039 case WPA_SEL(WPA_CSE_NULL): 1040 return "NONE"; 1041 case WPA_SEL(WPA_CSE_WEP40): 1042 return "WEP40"; 1043 case WPA_SEL(WPA_CSE_WEP104): 1044 return "WEP104"; 1045 case WPA_SEL(WPA_CSE_TKIP): 1046 return "TKIP"; 1047 case WPA_SEL(WPA_CSE_CCMP): 1048 return "AES-CCMP"; 1049 } 1050 return "?"; /* NB: so 1<< is discarded */ 1051 #undef WPA_SEL 1052 } 1053 1054 static const char * 1055 wpa_keymgmt(const u_int8_t *sel) 1056 { 1057 #define WPA_SEL(x) (((x)<<24)|WPA_OUI) 1058 u_int32_t w = LE_READ_4(sel); 1059 1060 switch (w) { 1061 case WPA_SEL(WPA_ASE_8021X_UNSPEC): 1062 return "8021X-UNSPEC"; 1063 case WPA_SEL(WPA_ASE_8021X_PSK): 1064 return "8021X-PSK"; 1065 case WPA_SEL(WPA_ASE_NONE): 1066 return "NONE"; 1067 } 1068 return "?"; 1069 #undef WPA_SEL 1070 } 1071 1072 static void 1073 printwpaie(const char *tag, const u_int8_t *ie, size_t ielen, int maxlen) 1074 { 1075 u_int8_t len = ie[1]; 1076 1077 printf("%s", tag); 1078 if (vflag) { 1079 const char *sep; 1080 int n; 1081 1082 ie += 6, len -= 4; /* NB: len is payload only */ 1083 1084 printf("<v%u", LE_READ_2(ie)); 1085 ie += 2, len -= 2; 1086 1087 printf(" mc:%s", wpa_cipher(ie)); 1088 ie += 4, len -= 4; 1089 1090 /* unicast ciphers */ 1091 n = LE_READ_2(ie); 1092 ie += 2, len -= 2; 1093 sep = " uc:"; 1094 for (; n > 0; n--) { 1095 printf("%s%s", sep, wpa_cipher(ie)); 1096 ie += 4, len -= 4; 1097 sep = "+"; 1098 } 1099 1100 /* key management algorithms */ 1101 n = LE_READ_2(ie); 1102 ie += 2, len -= 2; 1103 sep = " km:"; 1104 for (; n > 0; n--) { 1105 printf("%s%s", sep, wpa_keymgmt(ie)); 1106 ie += 4, len -= 4; 1107 sep = "+"; 1108 } 1109 1110 if (len > 2) /* optional capabilities */ 1111 printf(", caps 0x%x", LE_READ_2(ie)); 1112 printf(">"); 1113 } 1114 } 1115 1116 static const char * 1117 rsn_cipher(const u_int8_t *sel) 1118 { 1119 #define RSN_SEL(x) (((x)<<24)|RSN_OUI) 1120 u_int32_t w = LE_READ_4(sel); 1121 1122 switch (w) { 1123 case RSN_SEL(RSN_CSE_NULL): 1124 return "NONE"; 1125 case RSN_SEL(RSN_CSE_WEP40): 1126 return "WEP40"; 1127 case RSN_SEL(RSN_CSE_WEP104): 1128 return "WEP104"; 1129 case RSN_SEL(RSN_CSE_TKIP): 1130 return "TKIP"; 1131 case RSN_SEL(RSN_CSE_CCMP): 1132 return "AES-CCMP"; 1133 case RSN_SEL(RSN_CSE_WRAP): 1134 return "AES-OCB"; 1135 } 1136 return "?"; 1137 #undef WPA_SEL 1138 } 1139 1140 static const char * 1141 rsn_keymgmt(const u_int8_t *sel) 1142 { 1143 #define RSN_SEL(x) (((x)<<24)|RSN_OUI) 1144 u_int32_t w = LE_READ_4(sel); 1145 1146 switch (w) { 1147 case RSN_SEL(RSN_ASE_8021X_UNSPEC): 1148 return "8021X-UNSPEC"; 1149 case RSN_SEL(RSN_ASE_8021X_PSK): 1150 return "8021X-PSK"; 1151 case RSN_SEL(RSN_ASE_NONE): 1152 return "NONE"; 1153 } 1154 return "?"; 1155 #undef RSN_SEL 1156 } 1157 1158 static void 1159 printrsnie(const char *tag, const u_int8_t *ie, size_t ielen, int maxlen) 1160 { 1161 printf("%s", tag); 1162 if (vflag) { 1163 const char *sep; 1164 int n; 1165 1166 ie += 2, ielen -= 2; 1167 1168 printf("<v%u", LE_READ_2(ie)); 1169 ie += 2, ielen -= 2; 1170 1171 printf(" mc:%s", rsn_cipher(ie)); 1172 ie += 4, ielen -= 4; 1173 1174 /* unicast ciphers */ 1175 n = LE_READ_2(ie); 1176 ie += 2, ielen -= 2; 1177 sep = " uc:"; 1178 for (; n > 0; n--) { 1179 printf("%s%s", sep, rsn_cipher(ie)); 1180 ie += 4, ielen -= 4; 1181 sep = "+"; 1182 } 1183 1184 /* key management algorithms */ 1185 n = LE_READ_2(ie); 1186 ie += 2, ielen -= 2; 1187 sep = " km:"; 1188 for (; n > 0; n--) { 1189 printf("%s%s", sep, rsn_keymgmt(ie)); 1190 ie += 4, ielen -= 4; 1191 sep = "+"; 1192 } 1193 1194 if (ielen > 2) /* optional capabilities */ 1195 printf(", caps 0x%x", LE_READ_2(ie)); 1196 /* XXXPMKID */ 1197 printf(">"); 1198 } 1199 } 1200 1201 /* 1202 * Copy the ssid string contents into buf, truncating to fit. If the 1203 * ssid is entirely printable then just copy intact. Otherwise convert 1204 * to hexadecimal. If the result is truncated then replace the last 1205 * three characters with "...". 1206 */ 1207 static int 1208 copy_essid(char buf[], size_t bufsize, const u_int8_t *essid, size_t essid_len) 1209 { 1210 const u_int8_t *p; 1211 size_t maxlen; 1212 int i; 1213 1214 if (essid_len > bufsize) 1215 maxlen = bufsize; 1216 else 1217 maxlen = essid_len; 1218 /* determine printable or not */ 1219 for (i = 0, p = essid; i < maxlen; i++, p++) { 1220 if (*p < ' ' || *p > 0x7e) 1221 break; 1222 } 1223 if (i != maxlen) { /* not printable, print as hex */ 1224 if (bufsize < 3) 1225 return 0; 1226 strlcpy(buf, "0x", bufsize); 1227 bufsize -= 2; 1228 p = essid; 1229 for (i = 0; i < maxlen && bufsize >= 2; i++) { 1230 sprintf(&buf[2+2*i], "%02x", p[i]); 1231 bufsize -= 2; 1232 } 1233 if (i != essid_len) 1234 memcpy(&buf[2+2*i-3], "...", 3); 1235 } else { /* printable, truncate as needed */ 1236 memcpy(buf, essid, maxlen); 1237 if (maxlen != essid_len) 1238 memcpy(&buf[maxlen-3], "...", 3); 1239 } 1240 return maxlen; 1241 } 1242 1243 static void 1244 printssid(const char *tag, const u_int8_t *ie, size_t ielen, int maxlen) 1245 { 1246 char ssid[2*IEEE80211_NWID_LEN+1]; 1247 1248 printf("%s<%.*s>", tag, copy_essid(ssid, maxlen, ie+2, ie[1]), ssid); 1249 } 1250 1251 static void 1252 printrates(const char *tag, const u_int8_t *ie, size_t ielen, int maxlen) 1253 { 1254 const char *sep; 1255 int i; 1256 1257 printf("%s", tag); 1258 sep = "<"; 1259 for (i = 2; i < ielen; i++) { 1260 printf("%s%s%d", sep, 1261 ie[i] & IEEE80211_RATE_BASIC ? "B" : "", 1262 ie[i] & IEEE80211_RATE_VAL); 1263 sep = ","; 1264 } 1265 printf(">"); 1266 } 1267 1268 static void 1269 printcountry(const char *tag, const u_int8_t *ie, size_t ielen, int maxlen) 1270 { 1271 const struct ieee80211_country_ie *cie = 1272 (const struct ieee80211_country_ie *) ie; 1273 int i, nbands, schan, nchan; 1274 1275 printf("%s<%c%c%c", tag, cie->cc[0], cie->cc[1], cie->cc[2]); 1276 nbands = (cie->len - 3) / sizeof(cie->band[0]); 1277 for (i = 0; i < nbands; i++) { 1278 schan = cie->band[i].schan; 1279 nchan = cie->band[i].nchan; 1280 if (nchan != 1) 1281 printf(" %u-%u,%u", schan, schan + nchan-1, 1282 cie->band[i].maxtxpwr); 1283 else 1284 printf(" %u,%u", schan, cie->band[i].maxtxpwr); 1285 } 1286 printf(">"); 1287 } 1288 1289 /* unaligned little endian access */ 1290 #define LE_READ_4(p) \ 1291 ((u_int32_t) \ 1292 ((((const u_int8_t *)(p))[0] ) | \ 1293 (((const u_int8_t *)(p))[1] << 8) | \ 1294 (((const u_int8_t *)(p))[2] << 16) | \ 1295 (((const u_int8_t *)(p))[3] << 24))) 1296 1297 static int 1298 iswpaoui(const u_int8_t *frm) 1299 { 1300 return frm[1] > 3 && LE_READ_4(frm+2) == ((WPA_OUI_TYPE<<24)|WPA_OUI); 1301 } 1302 1303 static int 1304 iswmeinfo(const u_int8_t *frm) 1305 { 1306 return frm[1] > 5 && LE_READ_4(frm+2) == ((WME_OUI_TYPE<<24)|WME_OUI) && 1307 frm[6] == WME_INFO_OUI_SUBTYPE; 1308 } 1309 1310 static int 1311 iswmeparam(const u_int8_t *frm) 1312 { 1313 return frm[1] > 5 && LE_READ_4(frm+2) == ((WME_OUI_TYPE<<24)|WME_OUI) && 1314 frm[6] == WME_PARAM_OUI_SUBTYPE; 1315 } 1316 1317 static const char * 1318 iename(int elemid) 1319 { 1320 switch (elemid) { 1321 case IEEE80211_ELEMID_FHPARMS: return " FHPARMS"; 1322 case IEEE80211_ELEMID_CFPARMS: return " CFPARMS"; 1323 case IEEE80211_ELEMID_TIM: return " TIM"; 1324 case IEEE80211_ELEMID_IBSSPARMS:return " IBSSPARMS"; 1325 case IEEE80211_ELEMID_CHALLENGE:return " CHALLENGE"; 1326 case IEEE80211_ELEMID_PWRCNSTR: return " PWRCNSTR"; 1327 case IEEE80211_ELEMID_PWRCAP: return " PWRCAP"; 1328 case IEEE80211_ELEMID_TPCREQ: return " TPCREQ"; 1329 case IEEE80211_ELEMID_TPCREP: return " TPCREP"; 1330 case IEEE80211_ELEMID_SUPPCHAN: return " SUPPCHAN"; 1331 case IEEE80211_ELEMID_CHANSWITCHANN:return " CSA"; 1332 case IEEE80211_ELEMID_MEASREQ: return " MEASREQ"; 1333 case IEEE80211_ELEMID_MEASREP: return " MEASREP"; 1334 case IEEE80211_ELEMID_QUIET: return " QUIET"; 1335 case IEEE80211_ELEMID_IBSSDFS: return " IBSSDFS"; 1336 case IEEE80211_ELEMID_TPC: return " TPC"; 1337 case IEEE80211_ELEMID_CCKM: return " CCKM"; 1338 } 1339 return " ???"; 1340 } 1341 1342 static void 1343 printies(const u_int8_t *vp, int ielen, int maxcols) 1344 { 1345 while (ielen > 0) { 1346 switch (vp[0]) { 1347 case IEEE80211_ELEMID_SSID: 1348 if (vflag) 1349 printssid(" SSID", vp, 2+vp[1], maxcols); 1350 break; 1351 case IEEE80211_ELEMID_RATES: 1352 case IEEE80211_ELEMID_XRATES: 1353 if (vflag) 1354 printrates(vp[0] == IEEE80211_ELEMID_RATES ? 1355 " RATES" : " XRATES", vp, 2+vp[1], maxcols); 1356 break; 1357 case IEEE80211_ELEMID_DSPARMS: 1358 if (vflag) 1359 printf(" DSPARMS<%u>", vp[2]); 1360 break; 1361 case IEEE80211_ELEMID_COUNTRY: 1362 if (vflag) 1363 printcountry(" COUNTRY", vp, 2+vp[1], maxcols); 1364 break; 1365 case IEEE80211_ELEMID_ERP: 1366 if (vflag) 1367 printf(" ERP<0x%x>", vp[2]); 1368 break; 1369 case IEEE80211_ELEMID_VENDOR: 1370 if (iswpaoui(vp)) 1371 printwpaie(" WPA", vp, 2+vp[1], maxcols); 1372 else if (iswmeinfo(vp)) 1373 printwmeinfo(" WME", vp, 2+vp[1], maxcols); 1374 else if (iswmeparam(vp)) 1375 printwmeparam(" WME", vp, 2+vp[1], maxcols); 1376 else if (vflag) 1377 printie(" VEN", vp, 2+vp[1], maxcols); 1378 break; 1379 case IEEE80211_ELEMID_RSN: 1380 printrsnie(" RSN", vp, 2+vp[1], maxcols); 1381 break; 1382 default: 1383 if (vflag) 1384 printie(iename(vp[0]), vp, 2+vp[1], maxcols); 1385 break; 1386 } 1387 ielen -= 2+vp[1]; 1388 vp += 2+vp[1]; 1389 } 1390 } 1391 1392 static int 1393 mapgsm(u_int isrfreq, u_int isrflags) 1394 { 1395 isrfreq *= 10; 1396 if (isrflags & IEEE80211_CHAN_QUARTER) 1397 isrfreq += 5; 1398 else if (isrflags & IEEE80211_CHAN_HALF) 1399 isrfreq += 10; 1400 else 1401 isrfreq += 20; 1402 /* NB: there is no 907/20 wide but leave room */ 1403 return (isrfreq - 906*10) / 5; 1404 } 1405 1406 static int 1407 mappsb(u_int isrfreq, u_int isrflags) 1408 { 1409 return 37 + ((isrfreq * 10) + ((isrfreq % 5) == 2 ? 5 : 0) - 49400) / 5; 1410 } 1411
Indexes created Sat Sep 27 14:09:57 GMT 2025