ec1be43f14b1531f64f03e8889236587a9f3c517
[dragonfly.git] / sbin / ifconfig / ifieee80211.c
1 /*
2  * Copyright 2001 The Aerospace Corporation.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY THE AEROSPACE CORPORATION ``AS IS'' AND
14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AEROSPACE CORPORATION BE LIABLE
17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23  * SUCH DAMAGE.
24  *
25  * $FreeBSD: src/sbin/ifconfig/ifieee80211.c,v 1.1.2.3 2002/02/07 15:12:37 ambrisko Exp $
26  * $DragonFly: src/sbin/ifconfig/ifieee80211.c,v 1.7 2005/03/04 00:11:11 cpressey Exp $
27  */
28
29 /*-
30  * Copyright (c) 1997, 1998, 2000 The NetBSD Foundation, Inc.
31  * All rights reserved.
32  *
33  * This code is derived from software contributed to The NetBSD Foundation
34  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
35  * NASA Ames Research Center.
36  *
37  * Redistribution and use in source and binary forms, with or without
38  * modification, are permitted provided that the following conditions
39  * are met:
40  * 1. Redistributions of source code must retain the above copyright
41  *    notice, this list of conditions and the following disclaimer.
42  * 2. Redistributions in binary form must reproduce the above copyright
43  *    notice, this list of conditions and the following disclaimer in the
44  *    documentation and/or other materials provided with the distribution.
45  * 3. All advertising materials mentioning features or use of this software
46  *    must display the following acknowledgement:
47  *      This product includes software developed by the NetBSD
48  *      Foundation, Inc. and its contributors.
49  * 4. Neither the name of The NetBSD Foundation nor the names of its
50  *    contributors may be used to endorse or promote products derived
51  *    from this software without specific prior written permission.
52  *
53  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
54  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
55  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
56  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
57  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
58  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
59  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
60  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
61  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
62  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
63  * POSSIBILITY OF SUCH DAMAGE.
64  */
65
66 #include <sys/param.h>
67 #include <sys/ioctl.h>
68 #include <sys/socket.h>
69 #include <sys/sysctl.h>
70 #include <sys/time.h>
71
72 #include <net/ethernet.h>
73 #include <net/if.h>
74 #include <net/if_dl.h>
75 #include <net/if_types.h>
76 #include <net/route.h>
77 #include <netproto/802_11/ieee80211.h>
78 #include <netproto/802_11/ieee80211_ioctl.h>
79
80 #include <ctype.h>
81 #include <err.h>
82 #include <errno.h>
83 #include <fcntl.h>
84 #include <stdio.h>
85 #include <stdlib.h>
86 #include <string.h>
87 #include <unistd.h>
88
89 #include "ifconfig.h"
90
91 static void set80211(int s, int type, int val, int len, u_int8_t *data);
92 static const char *get_string(const char *val, const char *sep,
93     u_int8_t *buf, int *lenp);
94 static void print_string(const u_int8_t *buf, int len);
95
96 void
97 set80211ssid(const char *val, int d __unused, int s,
98              const struct afswtch *rafp __unused)
99 {
100         int             ssid;
101         int             len;
102         u_int8_t        data[33];
103
104         ssid = 0;
105         len = sizeof(val);
106         if (len > 2 && isdigit(val[0]) && val[1] == ':') {
107                 ssid = atoi(val)-1;
108                 val += 2;
109         }
110
111         bzero(data, sizeof(data));
112         len = sizeof(data);
113         get_string(val, NULL, data, &len);
114
115         set80211(s, IEEE80211_IOC_SSID, ssid, len, data);
116 }
117
118 void
119 set80211stationname(const char *val, int d __unused, int s,
120                     const struct afswtch *rafp __unused)
121 {
122         int                     len;
123         u_int8_t                data[33];
124
125         bzero(data, sizeof(data));
126         len = sizeof(data);
127         get_string(val, NULL, data, &len);
128
129         set80211(s, IEEE80211_IOC_STATIONNAME, 0, len, data);
130 }
131
132 void
133 set80211channel(const char *val, int d __unused, int s,
134                 const struct afswtch *rafp __unused)
135 {
136         set80211(s, IEEE80211_IOC_CHANNEL, atoi(val), 0, NULL);
137 }
138
139 void
140 set80211authmode(const char *val, int d __unused, int s,
141                  const struct afswtch *rafp __unused)
142 {
143         int     mode;
144
145         if(strcasecmp(val, "none") == 0) {
146                 mode = IEEE80211_AUTH_NONE;
147         } else if(strcasecmp(val, "open") == 0) {
148                 mode = IEEE80211_AUTH_OPEN;
149         } else if(strcasecmp(val, "shared") == 0) {
150                 mode = IEEE80211_AUTH_SHARED;
151         } else {
152                 err(1, "unknown authmode");
153         }
154
155         set80211(s, IEEE80211_IOC_AUTHMODE, mode, 0, NULL);
156 }
157
158 void
159 set80211powersavemode(const char *val, int d __unused, int s,
160                       const struct afswtch *rafp __unused)
161 {
162         int     mode;
163
164         if(strcasecmp(val, "off") == 0) {
165                 mode = IEEE80211_POWERSAVE_OFF;
166         } else if(strcasecmp(val, "on") == 0) {
167                 mode = IEEE80211_POWERSAVE_ON;
168         } else if(strcasecmp(val, "cam") == 0) {
169                 mode = IEEE80211_POWERSAVE_CAM;
170         } else if(strcasecmp(val, "psp") == 0) {
171                 mode = IEEE80211_POWERSAVE_PSP;
172         } else if(strcasecmp(val, "psp-cam") == 0) {
173                 mode = IEEE80211_POWERSAVE_PSP_CAM;
174         } else {
175                 err(1, "unknown powersavemode");
176         }
177
178         set80211(s, IEEE80211_IOC_POWERSAVE, mode, 0, NULL);
179 }
180
181 void
182 set80211powersave(const char *val __unused, int d, int s,
183                   const struct afswtch *rafp __unused)
184 {
185         if (d == 0)
186                 set80211(s, IEEE80211_IOC_POWERSAVE, IEEE80211_POWERSAVE_OFF,
187                     0, NULL);
188         else
189                 set80211(s, IEEE80211_IOC_POWERSAVE, IEEE80211_POWERSAVE_ON,
190                     0, NULL);
191 }
192
193 void
194 set80211powersavesleep(const char *val, int d __unused, int s,
195                        const struct afswtch *rafp __unused)
196 {
197         set80211(s, IEEE80211_IOC_POWERSAVESLEEP, atoi(val), 0, NULL);
198 }
199
200 void
201 set80211wepmode(const char *val, int d __unused, int s,
202                 const struct afswtch *rafp __unused)
203 {
204         int     mode;
205
206         if(strcasecmp(val, "off") == 0) {
207                 mode = IEEE80211_WEP_OFF;
208         } else if(strcasecmp(val, "on") == 0) {
209                 mode = IEEE80211_WEP_ON;
210         } else if(strcasecmp(val, "mixed") == 0) {
211                 mode = IEEE80211_WEP_MIXED;
212         } else {
213                 err(1, "unknown wep mode");
214         }
215
216         set80211(s, IEEE80211_IOC_WEP, mode, 0, NULL);
217 }
218
219 void
220 set80211wep(const char *val __unused, int d, int s,
221             const struct afswtch *rafp __unused)
222 {
223         set80211(s, IEEE80211_IOC_WEP, d, 0, NULL);
224 }
225
226 void
227 set80211weptxkey(const char *val, int d __unused, int s,
228                  const struct afswtch *rafp __unused)
229 {
230         set80211(s, IEEE80211_IOC_WEPTXKEY, atoi(val)-1, 0, NULL);
231 }
232
233 void
234 set80211wepkey(const char *val, int d __unused, int s,
235                const struct afswtch *rafp __unused)
236 {
237         int             key = 0;
238         int             len;
239         u_int8_t        data[14];
240
241         if(isdigit(val[0]) && val[1] == ':') {
242                 key = atoi(val)-1;
243                 val += 2;
244         }
245
246         bzero(data, sizeof(data));
247         len = sizeof(data);
248         get_string(val, NULL, data, &len);
249
250         set80211(s, IEEE80211_IOC_WEPKEY, key, len, data);
251 }
252
253 /*
254  * This function is purly a NetBSD compatibility interface.  The NetBSD
255  * iterface is too inflexable, but it's there so we'll support it since
256  * it's not all that hard.
257  */
258 void
259 set80211nwkey(const char *val, int d __unused, int s,
260               const struct afswtch *rafp __unused)
261 {
262         int             txkey;
263         int             i, len;
264         u_int8_t        data[14];
265
266         set80211(s, IEEE80211_IOC_WEP, IEEE80211_WEP_ON, 0, NULL);
267
268         if(isdigit(val[0]) && val[1] == ':') {
269                 txkey = val[0]-'0'-1;
270                 val += 2;
271
272                 for(i = 0; i < 4; i++) {
273                         bzero(data, sizeof(data));
274                         len = sizeof(data);
275                         val = get_string(val, ",", data, &len);
276
277                         set80211(s, IEEE80211_IOC_WEPKEY, i, len, data);
278                 }
279         } else {
280                 bzero(data, sizeof(data));
281                 len = sizeof(data);
282                 get_string(val, NULL, data, &len);
283                 txkey = 0;
284
285                 set80211(s, IEEE80211_IOC_WEPKEY, 0, len, data);
286
287                 bzero(data, sizeof(data));
288                 for(i = 1; i < 4; i++)
289                         set80211(s, IEEE80211_IOC_WEPKEY, i, 0, data);
290         }
291
292         set80211(s, IEEE80211_IOC_WEPTXKEY, txkey, 0, NULL);
293 }
294
295 void
296 ieee80211_status (int s, struct rt_addrinfo *info __unused)
297 {
298         int                     i;
299         int                     num;
300         struct ieee80211req     ireq;
301         u_int8_t                data[32];
302         char                    spacer;
303
304         memset(&ireq, 0, sizeof(ireq));
305         strncpy(ireq.i_name, name, sizeof(ireq.i_name));
306         ireq.i_data = &data;
307
308         ireq.i_type = IEEE80211_IOC_SSID;
309         ireq.i_val = -1;
310         if (ioctl(s, SIOCG80211, &ireq) < 0) {
311                 /* If we can't get the SSID, the this isn't an 802.11 device. */
312                 return;
313         }
314         printf("\tssid ");
315         print_string(data, ireq.i_len);
316         num = 0;
317         ireq.i_type = IEEE80211_IOC_NUMSSIDS;
318         if (ioctl(s, SIOCG80211, &ireq) >= 0) {
319                 num = ireq.i_val;
320         }
321         ireq.i_type = IEEE80211_IOC_SSID;
322         for (ireq.i_val = 0; ireq.i_val < num; ireq.i_val++) {
323                 if (ioctl(s, SIOCG80211, &ireq) >= 0 && ireq.i_len > 0) {
324                         printf(" %d:", ireq.i_val + 1);
325                         print_string(data, ireq.i_len);
326                 }
327         }
328         printf("\n");
329
330         ireq.i_type = IEEE80211_IOC_STATIONNAME;
331         if (ioctl(s, SIOCG80211, &ireq) != -1) {
332                 printf("\tstationname ");
333                 print_string(data, ireq.i_len);
334                 printf("\n");
335         }
336
337         ireq.i_type = IEEE80211_IOC_CHANNEL;
338         if (ioctl(s, SIOCG80211, &ireq) < 0) {
339                 goto end;
340         }
341         printf("\tchannel %d", ireq.i_val);
342
343         ireq.i_type = IEEE80211_IOC_AUTHMODE;
344         if (ioctl(s, SIOCG80211, &ireq) != -1) {
345                 printf(" authmode");
346                 switch (ireq.i_val) {
347                         case IEEE80211_AUTH_NONE:
348                                 printf(" NONE");
349                                 break;
350                         case IEEE80211_AUTH_OPEN:
351                                 printf(" OPEN");
352                                 break;
353                         case IEEE80211_AUTH_SHARED:
354                                 printf(" SHARED");
355                                 break;
356                         default:
357                                 printf(" UNKNOWN");
358                                 break;
359                 }
360         }
361
362         ireq.i_type = IEEE80211_IOC_POWERSAVE;
363         if (ioctl(s, SIOCG80211, &ireq) != -1 &&
364             ireq.i_val != IEEE80211_POWERSAVE_NOSUP ) {
365                 printf(" powersavemode");
366                 switch (ireq.i_val) {
367                         case IEEE80211_POWERSAVE_OFF:
368                                 printf(" OFF");
369                                 break;
370                         case IEEE80211_POWERSAVE_CAM:
371                                 printf(" CAM");
372                                 break;
373                         case IEEE80211_POWERSAVE_PSP:
374                                 printf(" PSP");
375                                 break;
376                         case IEEE80211_POWERSAVE_PSP_CAM:
377                                 printf(" PSP-CAM");
378                                 break;
379                 }
380
381                 ireq.i_type = IEEE80211_IOC_POWERSAVESLEEP;
382                 if (ioctl(s, SIOCG80211, &ireq) != -1) {
383                         if(ireq.i_val)
384                                 printf(" powersavesleep %d", ireq.i_val);
385                 }
386         }
387
388         printf("\n");
389
390         ireq.i_type = IEEE80211_IOC_WEP;
391         if (ioctl(s, SIOCG80211, &ireq) != -1 &&
392             ireq.i_val != IEEE80211_WEP_NOSUP) {
393                 printf("\twepmode");
394                 switch (ireq.i_val) {
395                         case IEEE80211_WEP_OFF:
396                                 printf(" OFF");
397                                 break;
398                         case IEEE80211_WEP_ON:
399                                 printf(" ON");
400                                 break;
401                         case IEEE80211_WEP_MIXED:
402                                 printf(" MIXED");
403                                 break;
404                         default:
405                                 printf(" UNKNOWN");
406                                 break;
407                 }
408
409                 /*
410                  * If we get here then we've got WEP support so we need
411                  * to print WEP status.
412                  */ 
413
414                 ireq.i_type = IEEE80211_IOC_WEPTXKEY;
415                 if (ioctl(s, SIOCG80211, &ireq) < 0) {
416                         warn("WEP support, but no tx key!");
417                         goto end;
418                 }
419                 printf(" weptxkey %d", ireq.i_val+1);
420
421                 ireq.i_type = IEEE80211_IOC_NUMWEPKEYS;
422                 if (ioctl(s, SIOCG80211, &ireq) < 0) {
423                         warn("WEP support, but no NUMWEPKEYS support!");
424                         goto end;
425                 }
426                 num = ireq.i_val;
427
428                 printf("\n");
429
430                 ireq.i_type = IEEE80211_IOC_WEPKEY;
431                 spacer = '\t';
432                 for(i = 0; i < num; i++) {
433                         ireq.i_val = i;
434                         if (ioctl(s, SIOCG80211, &ireq) < 0) {
435                                 warn("WEP support, but can get keys!");
436                                 goto end;
437                         }
438                         if(ireq.i_len == 0 || ireq.i_len > 13)
439                                 continue;
440                         printf("%cwepkey %d:%s", spacer, i+1,
441                             ireq.i_len <= 5 ? "64-bit" : "128-bit");
442                         if(spacer == '\t')
443                                 spacer = ' ';
444                 }
445                 if (spacer == ' ')
446                         printf("\n");
447         }
448
449 end:
450         return;
451 }
452
453 static void
454 set80211(int s, int type, int val, int len, u_int8_t *data)
455 {
456         struct ieee80211req     ireq;
457
458         memset(&ireq, 0, sizeof(ireq));
459         strncpy(ireq.i_name, name, sizeof(ireq.i_name));
460         ireq.i_type = type;
461         ireq.i_val = val;
462         ireq.i_len = len;
463         ireq.i_data = data;
464         if(ioctl(s, SIOCS80211, &ireq) < 0)
465                 err(1, "SIOCS80211");
466 }
467
468 static const char *
469 get_string(const char *val, const char *sep, u_int8_t *buf, int *lenp)
470 {
471         int len;
472         int hexstr;
473         u_int8_t *p;
474
475         len = *lenp;
476         p = buf;
477         hexstr = (val[0] == '0' && tolower((u_char)val[1]) == 'x');
478         if (hexstr)
479                 val += 2;
480         for (;;) {
481                 if (*val == '\0')
482                         break;
483                 if (sep != NULL && strchr(sep, *val) != NULL) {
484                         val++;
485                         break;
486                 }
487                 if (hexstr) {
488                         if (!isxdigit((u_char)val[0]) ||
489                             !isxdigit((u_char)val[1])) {
490                                 warnx("bad hexadecimal digits");
491                                 return NULL;
492                         }
493                 }
494                 if (p > buf + len) {
495                         if (hexstr)
496                                 warnx("hexadecimal digits too long");
497                         else
498                                 warnx("strings too long");
499                         return NULL;
500                 }
501                 if (hexstr) {
502 #define tohex(x)        (isdigit(x) ? (x) - '0' : tolower(x) - 'a' + 10)
503                         *p++ = (tohex((u_char)val[0]) << 4) |
504                             tohex((u_char)val[1]);
505 #undef tohex
506                         val += 2;
507                 } else
508                         *p++ = *val++;
509         }
510         len = p - buf;
511         /* The string "-" is treated as the empty string. */
512         if (!hexstr && len == 1 && buf[0] == '-')
513                 len = 0;
514         if (len < *lenp)
515                 memset(p, 0, *lenp - len);
516         *lenp = len;
517         return val;
518 }
519
520 static void
521 print_string(const u_int8_t *buf, int len)
522 {
523         int i;
524         int hasspc;
525
526         i = 0;
527         hasspc = 0;
528         for(; i < len; i++) {
529                 if (!isprint(buf[i]) && buf[i] != '\0')
530                         break;
531                 if (isspace(buf[i]))
532                         hasspc++;
533         }
534         if (i == len) {
535                 if (hasspc || len == 0 || buf[0] == '\0')
536                         printf("\"%.*s\"", len, buf);
537                 else
538                         printf("%.*s", len, buf);
539         } else {
540                 printf("0x");
541                 for (i = 0; i < len; i++)
542                         printf("%02x", buf[i]);
543         }
544 }
545