?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Nuke unnecessary setting of ural(4)'s security registers. ural(4) only
[dragonfly/vkernel-mp.git] / usr.sbin / wicontrol / wicontrol.c
bloba7f40465a41b87d92034d77cd6bf615711e3661b
1 /*
2 * Copyright (c) 1997, 1998, 1999
3 * Bill Paul <wpaul@ctr.columbia.edu>. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Bill Paul.
16 * 4. Neither the name of the author nor the names of any co-contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
30 * THE POSSIBILITY OF SUCH DAMAGE.
31 *
32 * $FreeBSD: src/usr.sbin/wicontrol/wicontrol.c,v 1.37 2003/09/29 06:32:11 imp Exp $
33 * $DragonFly: src/usr.sbin/wicontrol/wicontrol.c,v 1.6 2004/07/28 10:38:33 joerg Exp $
34 */
35
36 #include <sys/param.h>
37 #include <sys/socket.h>
38 #include <sys/ioctl.h>
39 #include <sys/socket.h>
40
41 #include <net/if.h>
42 #include <net/if_var.h>
43 #include <net/ethernet.h>
44
45 #include <netproto/802_11/ieee80211.h>
46 #include <netproto/802_11/ieee80211_ioctl.h>
47 #include <netproto/802_11/if_wavelan_ieee.h>
48
49 #include <stdio.h>
50 #include <string.h>
51 #include <stdlib.h>
52 #include <unistd.h>
53 #include <ctype.h>
54 #include <errno.h>
55 #include <err.h>
56
57 static int wi_getval(const char *, struct wi_req *);
58 static int wi_getvalmaybe(const char *, struct wi_req *);
59 static void wi_setval(const char *, struct wi_req *);
60 static void wi_printstr(struct wi_req *);
61 static void wi_setstr(const char *, int, char *);
62 static void wi_setbytes(const char *, int, char *, int);
63 static void wi_setword(const char *, int, int);
64 static void wi_sethex(const char *, int, char *);
65 static void wi_printwords(struct wi_req *);
66 static void wi_printbool(struct wi_req *);
67 static void wi_printhex(struct wi_req *);
68 static void wi_printaps(struct wi_req *);
69 static void wi_dumpinfo(const char *);
70 static void wi_dumpstats(const char *);
71 static void wi_setkeys(const char *, char *, int);
72 static void wi_printkeys(struct wi_req *);
73 static void wi_printaplist(const char *);
74 static int wi_hex2int(char);
75 static void wi_str2key(char *, struct wi_key *);
76 static void wi_readcache(const char *);
77 static void usage(const char *);
78 static int listaps;
79 static int quiet;
80
81 static int
82 _wi_getval(const char *iface, struct wi_req *wreq)
83 {
84 struct ifreq ifr;
85 int s;
86 int retval;
87
88 bzero((char *)&ifr, sizeof(ifr));
89
90 strlcpy(ifr.ifr_name, iface, sizeof(ifr.ifr_name));
91 ifr.ifr_data = (caddr_t)wreq;
92
93 s = socket(AF_INET, SOCK_DGRAM, 0);
94 if (s == -1)
95 err(1, "socket");
96 retval = ioctl(s, SIOCGWAVELAN, &ifr);
97 close(s);
98
99 return (retval);
100 }
101
102 static int
103 wi_getval(const char *iface, struct wi_req *wreq)
104 {
105 if (_wi_getval(iface, wreq) == -1) {
106 if (errno != EINPROGRESS)
107 err(1, "SIOCGWAVELAN");
108 return (-1);
109 }
110 return (0);
111 }
112
113 static int
114 wi_getvalmaybe(const char *iface, struct wi_req *wreq)
115 {
116 if (_wi_getval(iface, wreq) == -1) {
117 if (errno != EINPROGRESS && errno != EINVAL)
118 err(1, "SIOCGWAVELAN");
119 return (-1);
120 }
121 return (0);
122 }
123
124 static void
125 wi_setval(const char *iface, struct wi_req *wreq)
126 {
127 struct ifreq ifr;
128 int s;
129
130 bzero((char *)&ifr, sizeof(ifr));
131
132 strlcpy(ifr.ifr_name, iface, sizeof(ifr.ifr_name));
133 ifr.ifr_data = (caddr_t)wreq;
134
135 s = socket(AF_INET, SOCK_DGRAM, 0);
136
137 if (s == -1)
138 err(1, "socket");
139
140 if (ioctl(s, SIOCSWAVELAN, &ifr) == -1)
141 err(1, "SIOCSWAVELAN");
142
143 close(s);
144
145 return;
146 }
147
148 void
149 wi_printstr(struct wi_req *wreq)
150 {
151 char *ptr;
152 int i;
153
154 if (wreq->wi_type == WI_RID_SERIALNO) {
155 ptr = (char *)&wreq->wi_val;
156 for (i = 0; i < (wreq->wi_len - 1) * 2; i++) {
157 if (ptr[i] == '\0')
158 ptr[i] = ' ';
159 }
160 } else {
161 ptr = (char *)&wreq->wi_val[1];
162 for (i = 0; i < wreq->wi_val[0]; i++) {
163 if (ptr[i] == '\0')
164 ptr[i] = ' ';
165 }
166 }
167
168 ptr[i] = '\0';
169 printf("[ %s ]", ptr);
170
171 return;
172 }
173
174 void
175 wi_setstr(const char *iface, int code, char *str)
176 {
177 struct wi_req wreq;
178
179 if (iface == NULL)
180 errx(1, "must specify interface name");
181
182 if (str == NULL)
183 errx(1, "must specify string");
184
185 bzero((char *)&wreq, sizeof(wreq));
186
187 if (strlen(str) > 30)
188 errx(1, "string too long");
189
190 wreq.wi_type = code;
191 wreq.wi_len = 18;
192 wreq.wi_val[0] = strlen(str);
193 bcopy(str, (char *)&wreq.wi_val[1], strlen(str));
194
195 wi_setval(iface, &wreq);
196
197 return;
198 }
199
200 void
201 wi_setbytes(const char *iface, int code, char *bytes, int len)
202 {
203 struct wi_req wreq;
204
205 if (iface == NULL)
206 errx(1, "must specify interface name");
207
208 bzero((char *)&wreq, sizeof(wreq));
209
210 wreq.wi_type = code;
211 wreq.wi_len = (len / 2) + 1;
212 bcopy(bytes, (char *)&wreq.wi_val[0], len);
213
214 wi_setval(iface, &wreq);
215
216 return;
217 }
218
219 void
220 wi_setword(const char *iface, int code, int word)
221 {
222 struct wi_req wreq;
223
224 bzero((char *)&wreq, sizeof(wreq));
225
226 wreq.wi_type = code;
227 wreq.wi_len = 2;
228 wreq.wi_val[0] = word;
229
230 wi_setval(iface, &wreq);
231
232 return;
233 }
234
235 void
236 wi_sethex(const char *iface, int code, char *str)
237 {
238 struct ether_addr *addr;
239
240 if (str == NULL)
241 errx(1, "must specify address");
242
243 addr = ether_aton(str);
244
245 if (addr == NULL)
246 errx(1, "badly formatted address");
247
248 wi_setbytes(iface, code, (char *)addr, ETHER_ADDR_LEN);
249
250 return;
251 }
252
253 static int
254 wi_hex2int(char c)
255 {
256 if (c >= '0' && c <= '9')
257 return (c - '0');
258 if (c >= 'A' && c <= 'F')
259 return (c - 'A' + 10);
260 if (c >= 'a' && c <= 'f')
261 return (c - 'a' + 10);
262
263 return (0);
264 }
265
266 static void
267 wi_str2key(char *s, struct wi_key *k)
268 {
269 int n, i;
270 char *p;
271
272 /* Is this a hex string? */
273 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) {
274 /* Yes, convert to int. */
275 n = 0;
276 p = (char *)&k->wi_keydat[0];
277 for (i = 2; s[i] != '\0' && s[i + 1] != '\0'; i+= 2) {
278 *p++ = (wi_hex2int(s[i]) << 4) + wi_hex2int(s[i + 1]);
279 n++;
280 }
281 if (s[i] != '\0')
282 errx(1, "hex strings must be of even length");
283 k->wi_keylen = n;
284 } else {
285 /* No, just copy it in. */
286 bcopy(s, k->wi_keydat, strlen(s));
287 k->wi_keylen = strlen(s);
288 }
289
290 return;
291 }
292
293 static void
294 wi_setkeys(const char *iface, char *key, int idx)
295 {
296 int keylen;
297 struct wi_req wreq;
298 struct wi_ltv_keys *keys;
299 struct wi_key *k;
300 int has_wep;
301
302 bzero((char *)&wreq, sizeof(wreq));
303 wreq.wi_len = WI_MAX_DATALEN;
304 wreq.wi_type = WI_RID_WEP_AVAIL;
305
306 if (wi_getval(iface, &wreq) == 0)
307 has_wep = wreq.wi_val[0];
308 else
309 has_wep = 0;
310 if (!has_wep)
311 errx(1, "no WEP option available on this card");
312
313 bzero((char *)&wreq, sizeof(wreq));
314 wreq.wi_len = WI_MAX_DATALEN;
315 wreq.wi_type = WI_RID_DEFLT_CRYPT_KEYS;
316
317 if (wi_getval(iface, &wreq) == -1)
318 errx(1, "Cannot get default key index");
319 keys = (struct wi_ltv_keys *)&wreq;
320
321 keylen = strlen(key);
322 if (key[0] == '0' && (key[1] == 'x' || key[1] == 'X')) {
323 if (keylen != 2 && keylen != 12 && keylen != 28) {
324 errx(1, "encryption key must be 0, 10, or 26 "
325 "hex digits long");
326 }
327 } else {
328 if (keylen != 0 && keylen != 5 && keylen != 13) {
329 errx(1, "encryption key must be 0, 5, or 13 "
330 "bytes long");
331 }
332 }
333
334 if (idx > 3)
335 errx(1, "only 4 encryption keys available");
336
337 k = &keys->wi_keys[idx];
338 wi_str2key(key, k);
339
340 wreq.wi_len = (sizeof(struct wi_ltv_keys) / 2) + 1;
341 wreq.wi_type = WI_RID_DEFLT_CRYPT_KEYS;
342 wi_setval(iface, &wreq);
343
344 return;
345 }
346
347 static void
348 wi_printkeys(struct wi_req *wreq)
349 {
350 int i, j;
351 int isprintable;
352 struct wi_key *k;
353 struct wi_ltv_keys *keys;
354 char *ptr;
355
356 keys = (struct wi_ltv_keys *)wreq;
357
358 for (i = 0; i < 4; i++) {
359 k = &keys->wi_keys[i];
360 ptr = (char *)k->wi_keydat;
361 isprintable = 1;
362 for (j = 0; j < k->wi_keylen; j++) {
363 if (!isprint(ptr[j])) {
364 isprintable = 0;
365 break;
366 }
367 }
368 if (isprintable) {
369 ptr[j] = '\0';
370 printf("[ %s ]", ptr);
371 } else {
372 printf("[ 0x");
373 for (j = 0; j < k->wi_keylen; j++) {
374 printf("%02x", ptr[j] & 0xFF);
375 }
376 printf(" ]");
377
378 }
379 }
380
381 return;
382 };
383
384 void
385 wi_printwords(struct wi_req *wreq)
386 {
387 int i;
388
389 printf("[ ");
390 for (i = 0; i < wreq->wi_len - 1; i++)
391 printf("%d ", wreq->wi_val[i]);
392 printf("]");
393
394 return;
395 }
396
397 static void
398 wi_printswords(struct wi_req *wreq)
399 {
400 int i;
401
402 printf("[ ");
403 for (i = 0; i < wreq->wi_len - 1; i++)
404 printf("%d ", ((int16_t *) wreq->wi_val)[i]);
405 printf("]");
406
407 return;
408 }
409
410 static void
411 wi_printhexwords(struct wi_req *wreq)
412 {
413 int i;
414
415 printf("[ ");
416 for (i = 0; i < wreq->wi_len - 1; i++)
417 printf("%x ", wreq->wi_val[i]);
418 printf("]");
419
420 return;
421 }
422
423 void
424 wi_printbool(struct wi_req *wreq)
425 {
426 if (wreq->wi_val[0])
427 printf("[ On ]");
428 else
429 printf("[ Off ]");
430
431 return;
432 }
433
434 void
435 wi_printhex(struct wi_req *wreq)
436 {
437 int i;
438 unsigned char *c;
439
440 c = (unsigned char *)&wreq->wi_val;
441
442 printf("[ ");
443 for (i = 0; i < (wreq->wi_len - 1) * 2; i++) {
444 printf("%02x", c[i]);
445 if (i < ((wreq->wi_len - 1) * 2) - 1)
446 printf(":");
447 }
448
449 printf(" ]");
450 return;
451 }
452
453 void
454 wi_printaplist(const char *iface)
455 {
456 int prism2, len, i = 0, j, r;
457 struct wi_req wreq;
458 struct wi_scan_p2_hdr *wi_p2_h;
459 struct wi_scan_res *res;
460
461 if (!quiet)
462 printf("Available APs:\n");
463
464 /* first determine if this is a prism2 card or not */
465 wreq.wi_len = WI_MAX_DATALEN;
466 wreq.wi_type = WI_RID_PRISM2;
467
468 if (wi_getval(iface, &wreq) == 0)
469 prism2 = wreq.wi_val[0];
470 else
471 prism2 = 0;
472
473 /* send out a scan request */
474 wreq.wi_len = prism2 ? 3 : 1;
475 wreq.wi_type = WI_RID_SCAN_REQ;
476
477 if (prism2) {
478 wreq.wi_val[0] = 0x3FFF;
479 wreq.wi_val[1] = 0x000F;
480 }
481
482 wi_setval(iface, &wreq);
483
484 do {
485 /*
486 * sleep for 100 milliseconds so there's enough time for the card to
487 * respond... prism2's take a little longer.
488 */
489 usleep(prism2 ? 500000 : 100000);
490
491 /* get the scan results */
492 wreq.wi_len = WI_MAX_DATALEN;
493 wreq.wi_type = WI_RID_SCAN_RES;
494 } while (wi_getval(iface, &wreq) == -1 && errno == EINPROGRESS);
495
496 if (prism2) {
497 wi_p2_h = (struct wi_scan_p2_hdr *)wreq.wi_val;
498
499 /* if the reason is 0, this info is invalid */
500 if (wi_p2_h->wi_reason == 0)
501 return;
502
503 i = 4;
504 }
505
506 len = prism2 ? WI_PRISM2_RES_SIZE : WI_WAVELAN_RES_SIZE;
507
508 if (!quiet) {
509 int nstations = ((wreq.wi_len * 2) - i) / len;
510 if (nstations == 0) {
511 printf("No stations\n");
512 return;
513 }
514 printf("%d station%s:\n", nstations, nstations == 1 ? "" : "s");
515 printf("%-16.16s BSSID Chan SN S N Intrvl Capinfo\n", "SSID");
516 }
517 for (; i < (wreq.wi_len * 2) - len; i += len) {
518 res = (struct wi_scan_res *)((char *)wreq.wi_val + i);
519
520 res->wi_ssid[res->wi_ssid_len] = '\0';
521
522 printf("%-16.16s [ %02x:%02x:%02x:%02x:%02x:%02x ] [ %-2d ] "
523 "[ %2d %2d %2d ] %3d ", res->wi_ssid,
524 res->wi_bssid[0], res->wi_bssid[1], res->wi_bssid[2],
525 res->wi_bssid[3], res->wi_bssid[4], res->wi_bssid[5],
526 res->wi_chan, res->wi_signal - res->wi_noise,
527 res->wi_signal, res->wi_noise, res->wi_interval);
528
529 if (!quiet && res->wi_capinfo) {
530 printf("[ ");
531 if (res->wi_capinfo & WI_CAPINFO_ESS)
532 printf("ess ");
533 if (res->wi_capinfo & WI_CAPINFO_IBSS)
534 printf("ibss ");
535 if (res->wi_capinfo & IEEE80211_CAPINFO_CF_POLLABLE)
536 printf("cfp ");
537 if (res->wi_capinfo & IEEE80211_CAPINFO_CF_POLLREQ)
538 printf("cfpr ");
539 if (res->wi_capinfo & WI_CAPINFO_PRIV)
540 printf("priv ");
541 if (res->wi_capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE)
542 printf("shpr ");
543 if (res->wi_capinfo & IEEE80211_CAPINFO_PBCC)
544 printf("pbcc ");
545 if (res->wi_capinfo & IEEE80211_CAPINFO_CHNL_AGILITY)
546 printf("chna ");
547 if (res->wi_capinfo & IEEE80211_CAPINFO_SHORT_SLOTTIME)
548 printf("shst ");
549 if (res->wi_capinfo & IEEE80211_CAPINFO_DSSSOFDM)
550 printf("ofdm ");
551 printf("] ");
552 }
553
554 if (prism2 && res->wi_srates[0] != 0) {
555 printf("\n%16s [ ", "");
556 for (j = 0; j < 10 && res->wi_srates[j] != 0; j++) {
557 r = res->wi_srates[j] & IEEE80211_RATE_VAL;
558 if (r & 1)
559 printf("%d.%d", r / 2, (r % 2) * 5);
560 else
561 printf("%d", r / 2);
562 printf("%s ", res->wi_srates[j] & IEEE80211_RATE_BASIC ? "b" : "");
563 }
564 printf("]");
565 }
566 putchar('\n');
567 }
568 }
569
570 #define WI_STRING 0x01
571 #define WI_BOOL 0x02
572 #define WI_WORDS 0x03
573 #define WI_HEXBYTES 0x04
574 #define WI_KEYSTRUCT 0x05
575 #define WI_SWORDS 0x06
576 #define WI_HEXWORDS 0x07
577 #define WI_REGDOMS 0x08
578
579 struct wi_table {
580 int wi_code;
581 int wi_type;
582 const char *wi_str;
583 };
584
585 static struct wi_table wi_table[] = {
586 { WI_RID_SERIALNO, WI_STRING, "NIC serial number:\t\t\t" },
587 { WI_RID_NODENAME, WI_STRING, "Station name:\t\t\t\t" },
588 { WI_RID_OWN_SSID, WI_STRING, "SSID for IBSS creation:\t\t\t" },
589 { WI_RID_CURRENT_SSID, WI_STRING, "Current netname (SSID):\t\t\t" },
590 { WI_RID_DESIRED_SSID, WI_STRING, "Desired netname (SSID):\t\t\t" },
591 { WI_RID_CURRENT_BSSID, WI_HEXBYTES, "Current BSSID:\t\t\t\t" },
592 { WI_RID_CHANNEL_LIST, WI_HEXWORDS, "Channel list:\t\t\t\t" },
593 { WI_RID_OWN_CHNL, WI_WORDS, "IBSS channel:\t\t\t\t" },
594 { WI_RID_CURRENT_CHAN, WI_WORDS, "Current channel:\t\t\t" },
595 { WI_RID_COMMS_QUALITY, WI_WORDS, "Comms quality/signal/noise:\t\t" },
596 { WI_RID_DBM_COMMS_QUAL, WI_SWORDS, "dBm Coms Quality:\t\t\t" },
597 { WI_RID_PROMISC, WI_BOOL, "Promiscuous mode:\t\t\t" },
598 { WI_RID_PROCFRAME, WI_BOOL, "Process 802.11b Frame:\t\t\t" },
599 { WI_RID_PRISM2, WI_WORDS, "Intersil-Prism2 based card:\t\t" },
600 { WI_RID_PORTTYPE, WI_WORDS, "Port type (1=BSS, 3=ad-hoc):\t\t"},
601 { WI_RID_MAC_NODE, WI_HEXBYTES, "MAC address:\t\t\t\t"},
602 { WI_RID_TX_RATE, WI_WORDS, "TX rate (selection):\t\t\t"},
603 { WI_RID_CUR_TX_RATE, WI_WORDS, "TX rate (actual speed):\t\t\t"},
604 { WI_RID_RTS_THRESH, WI_WORDS, "RTS/CTS handshake threshold:\t\t"},
605 { WI_RID_CREATE_IBSS, WI_BOOL, "Create IBSS:\t\t\t\t" },
606 { WI_RID_SYSTEM_SCALE, WI_WORDS, "Access point density:\t\t\t" },
607 { WI_RID_PM_ENABLED, WI_WORDS, "Power Mgmt (1=on, 0=off):\t\t" },
608 { WI_RID_MAX_SLEEP, WI_WORDS, "Max sleep time:\t\t\t\t" },
609 { WI_RID_PRI_IDENTITY, WI_WORDS, "PRI Identity:\t\t\t\t" },
610 { WI_RID_STA_IDENTITY, WI_WORDS, "STA Identity:\t\t\t\t" } ,
611 { WI_RID_CARD_ID, WI_HEXWORDS, "Card ID register:\t\t\t" },
612 { WI_RID_TEMP_TYPE, WI_WORDS, "Temperature Range:\t\t\t" },
613 #ifdef WI_EXTRA_INFO
614 { WI_RID_PRI_SUP_RANGE, WI_WORDS, "PRI Sup Range:\t\t\t\t" },
615 { WI_RID_CIF_ACT_RANGE, WI_WORDS, "CFI Act Sup Range:\t\t\t" },
616 { WI_RID_STA_SUP_RANGE, WI_WORDS, "STA Sup Range:\t\t\t\t" } ,
617 { WI_RID_MFI_ACT_RANGE, WI_WORDS, "MFI Act Sup Range:\t\t\t" } ,
618 #endif
619 { 0, 0, NULL }
620 };
621
622 static struct wi_table wi_crypt_table[] = {
623 { WI_RID_ENCRYPTION, WI_BOOL, "WEP encryption:\t\t\t\t" },
624 { WI_RID_TX_CRYPT_KEY, WI_WORDS, "TX encryption key:\t\t\t" },
625 { WI_RID_DEFLT_CRYPT_KEYS, WI_KEYSTRUCT, "Encryption keys:\t\t\t" },
626 { 0, 0, NULL }
627 };
628
629 static void
630 wi_dumpinfo(const char *iface)
631 {
632 struct wi_req wreq;
633 int i, has_wep;
634 struct wi_table *w;
635
636 bzero((char *)&wreq, sizeof(wreq));
637
638 wreq.wi_len = WI_MAX_DATALEN;
639 wreq.wi_type = WI_RID_WEP_AVAIL;
640
641 if (wi_getval(iface, &wreq) == 0)
642 has_wep = wreq.wi_val[0];
643 else
644 has_wep = 0;
645
646 w = wi_table;
647
648 for (i = 0; w[i].wi_type; i++) {
649 bzero((char *)&wreq, sizeof(wreq));
650
651 wreq.wi_len = WI_MAX_DATALEN;
652 wreq.wi_type = w[i].wi_code;
653
654 if (wi_getvalmaybe(iface, &wreq) == -1)
655 continue;
656 printf("%s", w[i].wi_str);
657 switch(w[i].wi_type) {
658 case WI_STRING:
659 wi_printstr(&wreq);
660 break;
661 case WI_WORDS:
662 wi_printwords(&wreq);
663 break;
664 case WI_SWORDS:
665 wi_printswords(&wreq);
666 break;
667 case WI_HEXWORDS:
668 wi_printhexwords(&wreq);
669 break;
670 case WI_BOOL:
671 wi_printbool(&wreq);
672 break;
673 case WI_HEXBYTES:
674 wi_printhex(&wreq);
675 break;
676 default:
677 break;
678 }
679 printf("\n");
680 }
681
682 if (has_wep) {
683 w = wi_crypt_table;
684 for (i = 0; w[i].wi_type; i++) {
685 bzero((char *)&wreq, sizeof(wreq));
686
687 wreq.wi_len = WI_MAX_DATALEN;
688 wreq.wi_type = w[i].wi_code;
689
690 if (wi_getval(iface, &wreq) == -1)
691 continue;
692 printf("%s", w[i].wi_str);
693 switch(w[i].wi_type) {
694 case WI_STRING:
695 wi_printstr(&wreq);
696 break;
697 case WI_WORDS:
698 if (wreq.wi_type == WI_RID_TX_CRYPT_KEY)
699 wreq.wi_val[0]++;
700 wi_printwords(&wreq);
701 break;
702 case WI_BOOL:
703 wi_printbool(&wreq);
704 break;
705 case WI_HEXBYTES:
706 wi_printhex(&wreq);
707 break;
708 case WI_KEYSTRUCT:
709 wi_printkeys(&wreq);
710 break;
711 default:
712 break;
713 }
714 printf("\n");
715 }
716 }
717
718 if (listaps)
719 wi_printaplist(iface);
720
721 return;
722 }
723
724 static void
725 wi_dumpstats(const char *iface)
726 {
727 struct wi_req wreq;
728 struct wi_counters *c;
729
730 if (iface == NULL)
731 errx(1, "must specify interface name");
732
733 bzero((char *)&wreq, sizeof(wreq));
734 wreq.wi_len = WI_MAX_DATALEN;
735 wreq.wi_type = WI_RID_IFACE_STATS;
736
737 if (wi_getval(iface, &wreq) == -1)
738 errx(1, "Cannot get interface stats");
739
740 c = (struct wi_counters *)&wreq.wi_val;
741
742 printf("Transmitted unicast frames:\t\t%d\n",
743 c->wi_tx_unicast_frames);
744 printf("Transmitted multicast frames:\t\t%d\n",
745 c->wi_tx_multicast_frames);
746 printf("Transmitted fragments:\t\t\t%d\n",
747 c->wi_tx_fragments);
748 printf("Transmitted unicast octets:\t\t%d\n",
749 c->wi_tx_unicast_octets);
750 printf("Transmitted multicast octets:\t\t%d\n",
751 c->wi_tx_multicast_octets);
752 printf("Single transmit retries:\t\t%d\n",
753 c->wi_tx_single_retries);
754 printf("Multiple transmit retries:\t\t%d\n",
755 c->wi_tx_multi_retries);
756 printf("Transmit retry limit exceeded:\t\t%d\n",
757 c->wi_tx_retry_limit);
758 printf("Transmit discards:\t\t\t%d\n",
759 c->wi_tx_discards);
760 printf("Transmit discards due to wrong SA:\t%d\n",
761 c->wi_tx_discards_wrong_sa);
762 printf("Received unicast frames:\t\t%d\n",
763 c->wi_rx_unicast_frames);
764 printf("Received multicast frames:\t\t%d\n",
765 c->wi_rx_multicast_frames);
766 printf("Received fragments:\t\t\t%d\n",
767 c->wi_rx_fragments);
768 printf("Received unicast octets:\t\t%d\n",
769 c->wi_rx_unicast_octets);
770 printf("Received multicast octets:\t\t%d\n",
771 c->wi_rx_multicast_octets);
772 printf("Receive FCS errors:\t\t\t%d\n",
773 c->wi_rx_fcs_errors);
774 printf("Receive discards due to no buffer:\t%d\n",
775 c->wi_rx_discards_nobuf);
776 printf("Can't decrypt WEP frame:\t\t%d\n",
777 c->wi_rx_WEP_cant_decrypt);
778 printf("Received message fragments:\t\t%d\n",
779 c->wi_rx_msg_in_msg_frags);
780 printf("Received message bad fragments:\t\t%d\n",
781 c->wi_rx_msg_in_bad_msg_frags);
782
783 return;
784 }
785
786 static void
787 usage(const char *p)
788 {
789 fprintf(stderr, "usage: %s -i iface\n", p);
790 fprintf(stderr, "\t%s -i iface -o\n", p);
791 fprintf(stderr, "\t%s -i iface -l\n", p);
792 fprintf(stderr, "\t%s -i iface -L\n", p);
793 fprintf(stderr, "\t%s -i iface -t tx rate\n", p);
794 fprintf(stderr, "\t%s -i iface -n network name\n", p);
795 fprintf(stderr, "\t%s -i iface -s station name\n", p);
796 fprintf(stderr, "\t%s -i iface -c 0|1\n", p);
797 fprintf(stderr, "\t%s -i iface -q SSID\n", p);
798 fprintf(stderr, "\t%s -i iface -p port type\n", p);
799 fprintf(stderr, "\t%s -i iface -a access point density\n", p);
800 fprintf(stderr, "\t%s -i iface -m mac address\n", p);
801 fprintf(stderr, "\t%s -i iface -d max data length\n", p);
802 fprintf(stderr, "\t%s -i iface -e 0|1\n", p);
803 fprintf(stderr, "\t%s -i iface -k encryption key [-v 1|2|3|4]\n", p);
804 fprintf(stderr, "\t%s -i iface -r RTS threshold\n", p);
805 fprintf(stderr, "\t%s -i iface -f frequency\n", p);
806 fprintf(stderr, "\t%s -i iface -F 0|1\n", p);
807 fprintf(stderr, "\t%s -i iface -P 0|1\n", p);
808 fprintf(stderr, "\t%s -i iface -S max sleep duration\n", p);
809 fprintf(stderr, "\t%s -i iface -T 1|2|3|4\n", p);
810 #ifdef WICACHE
811 fprintf(stderr, "\t%s -i iface -Z zero out signal cache\n", p);
812 fprintf(stderr, "\t%s -i iface -C print signal cache\n", p);
813 #endif
814
815 exit(1);
816 }
817
818 static void
819 wi_printaps(struct wi_req *wreq)
820 {
821 struct wi_apinfo *w;
822 int i, j, nstations;
823
824 nstations = *(int *)wreq->wi_val;
825 printf("%d station%s:\n", nstations, nstations == 1 ? "" : "s");
826 w = (struct wi_apinfo *)(((char *)&wreq->wi_val) + sizeof(int));
827 for ( i = 0; i < nstations; i++, w++) {
828 printf("ap[%d]:\n", i);
829 if (w->scanreason) {
830 static const char *scanm[] = {
831 "Host initiated",
832 "Firmware initiated",
833 "Inquiry request from host"
834 };
835 printf("\tScanReason:\t\t\t[ %s ]\n",
836 scanm[w->scanreason - 1]);
837 }
838 printf("\tnetname (SSID):\t\t\t[ ");
839 for (j = 0; j < w->namelen; j++) {
840 printf("%c", w->name[j]);
841 }
842 printf(" ]\n");
843 printf("\tBSSID:\t\t\t\t[ %02x:%02x:%02x:%02x:%02x:%02x ]\n",
844 w->bssid[0]&0xff, w->bssid[1]&0xff,
845 w->bssid[2]&0xff, w->bssid[3]&0xff,
846 w->bssid[4]&0xff, w->bssid[5]&0xff);
847 printf("\tChannel:\t\t\t[ %d ]\n", w->channel);
848 printf("\tQuality/Signal/Noise [signal]:\t[ %d / %d / %d ]\n"
849 "\t [dBm]:\t[ %d / %d / %d ]\n",
850 w->quality, w->signal, w->noise,
851 w->quality, w->signal - 149, w->noise - 149);
852 printf("\tBSS Beacon Interval [msec]:\t[ %d ]\n", w->interval);
853 printf("\tCapinfo:\t\t\t[ ");
854 if (w->capinfo & IEEE80211_CAPINFO_ESS)
855 printf("ESS ");
856 if (w->capinfo & IEEE80211_CAPINFO_PRIVACY)
857 printf("WEP ");
858 printf("]\n");
859 }
860 }
861
862 static void
863 wi_dumpstations(const char *iface)
864 {
865 struct wi_req wreq;
866
867 if (iface == NULL)
868 errx(1, "must specify interface name");
869
870 bzero((char *)&wreq, sizeof(wreq));
871 wreq.wi_len = WI_MAX_DATALEN;
872 wreq.wi_type = WI_RID_READ_APS;
873
874 if (wi_getval(iface, &wreq) == -1)
875 errx(1, "Cannot get stations");
876 wi_printaps(&wreq);
877 }
878
879 static void
880 wi_readcache(const char *iface)
881 {
882 struct wi_req wreq;
883 int *wi_sigitems;
884 struct wi_sigcache *sc;
885 char * pt;
886 int i;
887
888 if (iface == NULL)
889 errx(1, "must specify interface name");
890
891 bzero((char *)&wreq, sizeof(wreq));
892 wreq.wi_len = WI_MAX_DATALEN;
893 wreq.wi_type = WI_RID_READ_CACHE;
894 if (wi_getval(iface, &wreq) == -1)
895 errx(1, "Cannot read signal cache");
896
897 wi_sigitems = (int *) &wreq.wi_val;
898 pt = ((char *) &wreq.wi_val);
899 pt += sizeof(int);
900 sc = (struct wi_sigcache *) pt;
901
902 for (i = 0; i < *wi_sigitems; i++) {
903 printf("[%d/%d]:", i+1, *wi_sigitems);
904 printf(" %02x:%02x:%02x:%02x:%02x:%02x,",
905 sc->macsrc[0]&0xff,
906 sc->macsrc[1]&0xff,
907 sc->macsrc[2]&0xff,
908 sc->macsrc[3]&0xff,
909 sc->macsrc[4]&0xff,
910 sc->macsrc[5]&0xff);
911 printf(" %d.%d.%d.%d,",((sc->ipsrc >> 0) & 0xff),
912 ((sc->ipsrc >> 8) & 0xff),
913 ((sc->ipsrc >> 16) & 0xff),
914 ((sc->ipsrc >> 24) & 0xff));
915 printf(" sig: %d, noise: %d, qual: %d\n",
916 sc->signal,
917 sc->noise,
918 sc->quality);
919 sc++;
920 }
921
922 return;
923 }
924
925 static void
926 dep(const char *flag, const char *opt)
927 {
928 warnx("warning: flag %s deprecated, migrate to ifconfig %s", flag,
929 opt);
930 }
931
932 int
933 main(int argc, char *argv[])
934 {
935 int ch;
936 const char *iface = NULL;
937 char *p = argv[0];
938 char *key = NULL;
939 int modifier = 0;
940
941 /* Get the interface name */
942 opterr = 0;
943 ch = getopt(argc, argv, "i:");
944 if (ch == 'i') {
945 iface = optarg;
946 } else {
947 if (argc > 1 && *argv[1] != '-') {
948 iface = argv[1];
949 optind = 2;
950 } else {
951 iface = "wi0";
952 optind = 1;
953 }
954 optreset = 1;
955 }
956 opterr = 1;
957
958 while((ch = getopt(argc, argv,
959 "a:c:d:e:f:hi:k:lm:n:op:q:r:s:t:v:CF:LP:QS:T")) != -1) {
960 switch(ch) {
961 case 'C':
962 wi_readcache(iface);
963 exit(0);
964 break;
965 case 'o':
966 wi_dumpstats(iface);
967 exit(0);
968 break;
969 case 'c':
970 dep("c", "mediaopt");
971 wi_setword(iface, WI_RID_CREATE_IBSS, atoi(optarg));
972 exit(0);
973 break;
974 case 'd':
975 wi_setword(iface, WI_RID_MAX_DATALEN, atoi(optarg));
976 exit(0);
977 break;
978 case 'e':
979 dep("e", "wepmode");
980 wi_setword(iface, WI_RID_ENCRYPTION, atoi(optarg));
981 exit(0);
982 break;
983 case 'f':
984 dep("f", "channel");
985 wi_setword(iface, WI_RID_OWN_CHNL, atoi(optarg));
986 exit(0);
987 break;
988 case 'F':
989 wi_setword(iface, WI_RID_PROCFRAME, atoi(optarg));
990 exit(0);
991 break;
992 case 'k':
993 dep("k", "wepkey");
994 key = optarg;
995 break;
996 case 'L':
997 listaps++;
998 break;
999 case 'l':
1000 wi_dumpstations(iface);
1001 exit(0);
1002 break;
1003 case 'p':
1004 dep("p", "mediaopt");
1005 wi_setword(iface, WI_RID_PORTTYPE, atoi(optarg));
1006 exit(0);
1007 break;
1008 case 'r':
1009 wi_setword(iface, WI_RID_RTS_THRESH, atoi(optarg));
1010 exit(0);
1011 break;
1012 case 't':
1013 dep("t", "mediaopt");
1014 wi_setword(iface, WI_RID_TX_RATE, atoi(optarg));
1015 exit(0);
1016 break;
1017 case 'n':
1018 dep("n", "ssid");
1019 wi_setstr(iface, WI_RID_DESIRED_SSID, optarg);
1020 exit(0);
1021 break;
1022 case 's':
1023 dep("s", "stationname");
1024 wi_setstr(iface, WI_RID_NODENAME, optarg);
1025 exit(0);
1026 break;
1027 case 'm':
1028 wi_sethex(iface, WI_RID_MAC_NODE, optarg);
1029 exit(0);
1030 break;
1031 case 'Q':
1032 quiet = 1;
1033 break;
1034 case 'q':
1035 dep("q", "ssid");
1036 wi_setstr(iface, WI_RID_OWN_SSID, optarg);
1037 exit(0);
1038 break;
1039 case 'S':
1040 dep("S", "powersleep");
1041 wi_setword(iface, WI_RID_MAX_SLEEP, atoi(optarg));
1042 exit(0);
1043 break;
1044 case 'T':
1045 dep("T", "weptxkey");
1046 wi_setword(iface,
1047 WI_RID_TX_CRYPT_KEY, atoi(optarg) - 1);
1048 exit(0);
1049 break;
1050 case 'P':
1051 dep("P", "powersave");
1052 wi_setword(iface, WI_RID_PM_ENABLED, atoi(optarg));
1053 exit(0);
1054 break;
1055 case 'a':
1056 wi_setword(iface, WI_RID_SYSTEM_SCALE, atoi(optarg));
1057 exit(0);
1058 break;
1059 case 'v':
1060 modifier = atoi(optarg);
1061 modifier--;
1062 break;
1063 case 'h':
1064 default:
1065 usage(p);
1066 break;
1067 }
1068 }
1069
1070 if (iface == NULL)
1071 usage(p);
1072
1073 if (key != NULL) {
1074 wi_setkeys(iface, key, modifier);
1075 exit(0);
1076 }
1077
1078 if (listaps > 1) {
1079 wi_printaplist(iface);
1080 exit(0);
1081 }
1082
1083 wi_dumpinfo(iface);
1084
1085 exit(0);
1086 }
DragonFly vkernel multiprocessor port