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