OSDN Git Service

v21
[android-x86/external-wireless-tools.git] / wireless_tools / iwconfig.c
1 /*
2  *      Wireless Tools
3  *
4  *              Jean II - HPLB 97->99 - HPL 99->01
5  *
6  * Main code for "iwconfig". This is the generic tool for most
7  * manipulations...
8  * You need to link this code against "iwcommon.c" and "-lm".
9  *
10  * This file is released under the GPL license.
11  */
12
13 #include "iwcommon.h"           /* Header */
14
15 /**************************** VARIABLES ****************************/
16 char *  operation_mode[] = { "Auto",
17                              "Ad-Hoc",
18                              "Managed",
19                              "Master",
20                              "Repeater",
21                              "Secondary" };
22
23 /************************* MISC SUBROUTINES **************************/
24
25 /*------------------------------------------------------------------*/
26 /*
27  * Print usage string
28  */
29 static void
30 iw_usage(void)
31 {
32   fprintf(stderr, "Usage: iwconfig interface [essid {NN|on|off}]\n");
33   fprintf(stderr, "                          [nwid {NN|on|off}]\n");
34   fprintf(stderr, "                          [freq N.NNNN[k|M|G]]\n");
35   fprintf(stderr, "                          [channel N]\n");
36   fprintf(stderr, "                          [sens N]\n");
37   fprintf(stderr, "                          [nick N]\n");
38   fprintf(stderr, "                          [rate {N|auto|fixed}]\n");
39   fprintf(stderr, "                          [rts {N|auto|fixed|off}]\n");
40   fprintf(stderr, "                          [frag {N|auto|fixed|off}]\n");
41   fprintf(stderr, "                          [enc NNNN-NNNN]\n");
42   fprintf(stderr, "                          [power { period N|timeout N}]\n");
43   fprintf(stderr, "                          [txpower N {mW|dBm}]\n");
44   exit(1);
45 }
46
47
48 /************************* DISPLAY ROUTINES **************************/
49
50 /*------------------------------------------------------------------*/
51 /*
52  * Read /proc/net/wireless to get the latest statistics
53  */
54 static int
55 iw_getstats(char *      ifname,
56             iwstats *   stats)
57 {
58   FILE *        f=fopen("/proc/net/wireless","r");
59   char          buf[256];
60   char *        bp;
61   int           t;
62   if(f==NULL)
63     return -1;
64   /* Loop on all devices */
65   while(fgets(buf,255,f))
66     {
67       bp=buf;
68       while(*bp&&isspace(*bp))
69         bp++;
70       /* Is it the good device ? */
71       if(strncmp(bp,ifname,strlen(ifname))==0 && bp[strlen(ifname)]==':')
72         {
73           /* Skip ethX: */
74           bp=strchr(bp,':');
75           bp++;
76           /* -- status -- */
77           bp = strtok(bp, " ");
78           sscanf(bp, "%X", &t);
79           stats->status = (unsigned short) t;
80           /* -- link quality -- */
81           bp = strtok(NULL, " ");
82           if(strchr(bp,'.') != NULL)
83             stats->qual.updated |= 1;
84           sscanf(bp, "%d", &t);
85           stats->qual.qual = (unsigned char) t;
86           /* -- signal level -- */
87           bp = strtok(NULL, " ");
88           if(strchr(bp,'.') != NULL)
89             stats->qual.updated |= 2;
90           sscanf(bp, "%d", &t);
91           stats->qual.level = (unsigned char) t;
92           /* -- noise level -- */
93           bp = strtok(NULL, " ");
94           if(strchr(bp,'.') != NULL)
95             stats->qual.updated += 4;
96           sscanf(bp, "%d", &t);
97           stats->qual.noise = (unsigned char) t;
98           /* -- discarded packets -- */
99           bp = strtok(NULL, " ");
100           sscanf(bp, "%d", &stats->discard.nwid);
101           bp = strtok(NULL, " ");
102           sscanf(bp, "%d", &stats->discard.code);
103           bp = strtok(NULL, " ");
104           sscanf(bp, "%d", &stats->discard.misc);
105           fclose(f);
106           return 0;
107         }
108     }
109   fclose(f);
110   return -1;
111 }
112
113 /*------------------------------------------------------------------*/
114 /*
115  * Get wireless informations & config from the device driver
116  * We will call all the classical wireless ioctl on the driver through
117  * the socket to know what is supported and to get the settings...
118  */
119 static int
120 get_info(int                    skfd,
121          char *                 ifname,
122          struct wireless_info * info)
123 {
124   struct iwreq          wrq;
125
126   memset((char *) info, 0, sizeof(struct wireless_info));
127
128   /* Get wireless name */
129   strcpy(wrq.ifr_name, ifname);
130   if(ioctl(skfd, SIOCGIWNAME, &wrq) < 0)
131     /* If no wireless name : no wireless extensions */
132     return(-1);
133   else
134     strcpy(info->name, wrq.u.name);
135
136   /* Get ranges */
137   if(get_range_info(skfd, ifname, &(info->range)) >= 0)
138     info->has_range = 1;
139
140   /* Get network ID */
141   strcpy(wrq.ifr_name, ifname);
142   if(ioctl(skfd, SIOCGIWNWID, &wrq) >= 0)
143     {
144       info->has_nwid = 1;
145       memcpy(&(info->nwid), &(wrq.u.nwid), sizeof(iwparam));
146     }
147
148   /* Get frequency / channel */
149   strcpy(wrq.ifr_name, ifname);
150   if(ioctl(skfd, SIOCGIWFREQ, &wrq) >= 0)
151     {
152       info->has_freq = 1;
153       info->freq = freq2float(&(wrq.u.freq));
154     }
155
156   /* Get sensitivity */
157   strcpy(wrq.ifr_name, ifname);
158   if(ioctl(skfd, SIOCGIWSENS, &wrq) >= 0)
159     {
160       info->has_sens = 1;
161       memcpy(&(info->sens), &(wrq.u.sens), sizeof(iwparam));
162     }
163
164   /* Get encryption information */
165   strcpy(wrq.ifr_name, ifname);
166   wrq.u.data.pointer = (caddr_t) info->key;
167   wrq.u.data.length = 0;
168   wrq.u.data.flags = 0;
169   if(ioctl(skfd, SIOCGIWENCODE, &wrq) >= 0)
170     {
171       info->has_key = 1;
172       info->key_size = wrq.u.data.length;
173       info->key_flags = wrq.u.data.flags;
174     }
175
176   /* Get ESSID */
177   strcpy(wrq.ifr_name, ifname);
178   wrq.u.essid.pointer = (caddr_t) info->essid;
179   wrq.u.essid.length = 0;
180   wrq.u.essid.flags = 0;
181   if(ioctl(skfd, SIOCGIWESSID, &wrq) >= 0)
182     {
183       info->has_essid = 1;
184       info->essid_on = wrq.u.data.flags;
185     }
186
187   /* Get AP address */
188   strcpy(wrq.ifr_name, ifname);
189   if(ioctl(skfd, SIOCGIWAP, &wrq) >= 0)
190     {
191       info->has_ap_addr = 1;
192       memcpy(&(info->ap_addr), &(wrq.u.ap_addr), sizeof (sockaddr));
193     }
194
195   /* Get NickName */
196   strcpy(wrq.ifr_name, ifname);
197   wrq.u.essid.pointer = (caddr_t) info->nickname;
198   wrq.u.essid.length = 0;
199   wrq.u.essid.flags = 0;
200   if(ioctl(skfd, SIOCGIWNICKN, &wrq) >= 0)
201     if(wrq.u.data.length > 1)
202       info->has_nickname = 1;
203
204   /* Get bit rate */
205   strcpy(wrq.ifr_name, ifname);
206   if(ioctl(skfd, SIOCGIWRATE, &wrq) >= 0)
207     {
208       info->has_bitrate = 1;
209       memcpy(&(info->bitrate), &(wrq.u.bitrate), sizeof(iwparam));
210     }
211
212   /* Get RTS threshold */
213   strcpy(wrq.ifr_name, ifname);
214   if(ioctl(skfd, SIOCGIWRTS, &wrq) >= 0)
215     {
216       info->has_rts = 1;
217       memcpy(&(info->rts), &(wrq.u.rts), sizeof(iwparam));
218     }
219
220   /* Get fragmentation threshold */
221   strcpy(wrq.ifr_name, ifname);
222   if(ioctl(skfd, SIOCGIWFRAG, &wrq) >= 0)
223     {
224       info->has_frag = 1;
225       memcpy(&(info->frag), &(wrq.u.frag), sizeof(iwparam));
226     }
227
228   /* Get operation mode */
229   strcpy(wrq.ifr_name, ifname);
230   if(ioctl(skfd, SIOCGIWMODE, &wrq) >= 0)
231     {
232       if((wrq.u.mode < 6) && (wrq.u.mode >= 0))
233         info->has_mode = 1;
234       info->mode = wrq.u.mode;
235     }
236
237   /* Get Power Management settings */
238   strcpy(wrq.ifr_name, ifname);
239   wrq.u.power.flags = 0;
240   if(ioctl(skfd, SIOCGIWPOWER, &wrq) >= 0)
241     {
242       info->has_power = 1;
243       memcpy(&(info->power), &(wrq.u.power), sizeof(iwparam));
244     }
245
246 #if WIRELESS_EXT > 9
247   /* Get Transmit Power */
248   strcpy(wrq.ifr_name, ifname);
249   if(ioctl(skfd, SIOCGIWTXPOW, &wrq) >= 0)
250     {
251       info->has_txpower = 1;
252       memcpy(&(info->txpower), &(wrq.u.txpower), sizeof(iwparam));
253     }
254 #endif
255
256 #if WIRELESS_EXT > 10
257   /* Get retry limit/lifetime */
258   strcpy(wrq.ifr_name, ifname);
259   if(ioctl(skfd, SIOCGIWRETRY, &wrq) >= 0)
260     {
261       info->has_retry = 1;
262       memcpy(&(info->retry), &(wrq.u.retry), sizeof(iwparam));
263     }
264 #endif  /* WIRELESS_EXT > 10 */
265
266   /* Get stats */
267   if(iw_getstats(ifname, &(info->stats)) >= 0)
268     {
269       info->has_stats = 1;
270     }
271
272   return(0);
273 }
274
275 /*------------------------------------------------------------------*/
276 /*
277  * Print on the screen in a neat fashion all the info we have collected
278  * on a device.
279  */
280 static void
281 display_info(struct wireless_info *     info,
282              char *                     ifname)
283 {
284   /* One token is more of less 5 character, 14 tokens per line */
285   int   tokens = 3;     /* For name */
286
287   /* Display device name and wireless name (name of the protocol used) */
288   printf("%-8.8s  %s  ", ifname, info->name);
289
290   /* Display ESSID (extended network), if any */
291   if(info->has_essid)
292     {
293       if(info->essid_on)
294         {
295           /* Does it have an ESSID index ? */
296           if((info->essid_on & IW_ENCODE_INDEX) > 1)
297             printf("ESSID:\"%s\" [%d]  ", info->essid,
298                    (info->essid_on & IW_ENCODE_INDEX));
299           else
300             printf("ESSID:\"%s\"  ", info->essid);
301         }
302       else
303         printf("ESSID:off  ");
304     }
305
306   /* Display NickName (station name), if any */
307   if(info->has_nickname)
308     printf("Nickname:\"%s\"", info->nickname);
309
310   /* Formatting */
311   if(info->has_essid || info->has_nickname)
312     {
313       printf("\n          ");
314       tokens = 0;
315     }
316
317   /* Display Network ID */
318   if(info->has_nwid)
319     {
320       /* Note : should display right number of digit according to info
321        * in range structure */
322       if(info->nwid.disabled)
323         printf("NWID:off/any  ");
324       else
325         printf("NWID:%X  ", info->nwid.value);
326       tokens +=2;
327     }
328
329   /* Display the current mode of operation */
330   if(info->has_mode)
331     {
332       printf("Mode:%s  ", operation_mode[info->mode]);
333       tokens +=3;
334     }
335
336   /* Display frequency / channel */
337   if(info->has_freq)
338     {
339       if(info->freq < KILO)
340         printf("Channel:%g  ", info->freq);
341       else
342         {
343           if(info->freq >= GIGA)
344             printf("Frequency:%gGHz  ", info->freq / GIGA);
345           else
346             {
347               if(info->freq >= MEGA)
348                 printf("Frequency:%gMHz  ", info->freq / MEGA);
349               else
350                 printf("Frequency:%gkHz  ", info->freq / KILO);
351             }
352         }
353       tokens +=4;
354     }
355
356   /* Display the address of the current Access Point */
357   if(info->has_ap_addr)
358     {
359       /* A bit of clever formatting */
360       if(tokens > 8)
361         {
362           printf("\n          ");
363           tokens = 0;
364         }
365       tokens +=6;
366
367       /* Oups ! No Access Point in Ad-Hoc mode */
368       if((info->has_mode) && (info->mode == IW_MODE_ADHOC))
369         printf("Cell:");
370       else
371         printf("Access Point:");
372       printf(" %s", pr_ether(info->ap_addr.sa_data));
373     }
374
375   /* Display the currently used/set bit-rate */
376   if(info->has_bitrate)
377     {
378       /* A bit of clever formatting */
379       if(tokens > 11)
380         {
381           printf("\n          ");
382           tokens = 0;
383         }
384       tokens +=3;
385
386       /* Fixed ? */
387       if(info->bitrate.fixed)
388         printf("Bit Rate=");
389       else
390         printf("Bit Rate:");
391
392       if(info->bitrate.value >= GIGA)
393         printf("%gGb/s", info->bitrate.value / GIGA);
394       else
395         if(info->bitrate.value >= MEGA)
396           printf("%gMb/s", info->bitrate.value / MEGA);
397         else
398           printf("%gkb/s", info->bitrate.value / KILO);
399       printf("   ");
400     }
401
402 #if WIRELESS_EXT > 9
403   /* Display the Transmit Power */
404   if(info->has_txpower)
405     {
406       /* A bit of clever formatting */
407       if(tokens > 11)
408         {
409           printf("\n          ");
410           tokens = 0;
411         }
412       tokens +=3;
413
414       /* Disabled ? */
415       if(info->txpower.disabled)
416         printf("Tx-Power:off   ");
417       else
418         {
419           int           dbm;
420
421           /* Fixed ? */
422           if(info->txpower.fixed)
423             printf("Tx-Power=");
424           else
425             printf("Tx-Power:");
426
427           /* Convert everything to dBm */
428           if(info->txpower.flags & IW_TXPOW_MWATT)
429             dbm = mwatt2dbm(info->txpower.value);
430           else
431             dbm = info->txpower.value;
432
433           /* Display */
434           printf("%d dBm   ", dbm);
435         }
436     }
437 #endif
438
439   /* Display sensitivity */
440   if(info->has_sens)
441     {
442       /* A bit of clever formatting */
443       if(tokens > 10)
444         {
445           printf("\n          ");
446           tokens = 0;
447         }
448       tokens +=4;
449
450       /* Fixed ? */
451       if(info->sens.fixed)
452         printf("Sensitivity=");
453       else
454         printf("Sensitivity:");
455
456       if(info->has_range)
457         /* Display in dBm ? */
458         if(info->sens.value < 0)
459           printf("%d dBm  ", info->sens.value);
460         else
461           printf("%d/%d  ", info->sens.value, info->range.sensitivity);
462       else
463         printf("%d  ", info->sens.value);
464     }
465
466   printf("\n          ");
467   tokens = 0;
468
469 #if WIRELESS_EXT > 10
470   /* Display retry limit/lifetime information */
471   if(info->has_retry)
472     { 
473       printf("Retry");
474       /* Disabled ? */
475       if(info->retry.disabled)
476         printf(":off");
477       else
478         {
479           /* Let's check the value and its type */
480           if(info->retry.flags & IW_RETRY_TYPE)
481             print_retry_value(stdout, info->retry.value, info->retry.flags);
482
483           /* Let's check if nothing (simply on) */
484           if(info->retry.flags == IW_RETRY_ON)
485             printf(":on");
486         }
487       printf("   ");
488       tokens += 5;      /* Between 3 and 5, depend on flags */
489     }
490 #endif  /* WIRELESS_EXT > 10 */
491
492   /* Display the RTS threshold */
493   if(info->has_rts)
494     {
495       /* Disabled ? */
496       if(info->rts.disabled)
497         printf("RTS thr:off   ");
498       else
499         {
500           /* Fixed ? */
501           if(info->rts.fixed)
502             printf("RTS thr=");
503           else
504             printf("RTS thr:");
505
506           printf("%d B   ", info->rts.value);
507         }
508       tokens += 3;
509     }
510
511   /* Display the fragmentation threshold */
512   if(info->has_frag)
513     {
514       /* A bit of clever formatting */
515       if(tokens > 10)
516         {
517           printf("\n          ");
518           tokens = 0;
519         }
520       tokens +=4;
521
522       /* Disabled ? */
523       if(info->frag.disabled)
524         printf("Fragment thr:off");
525       else
526         {
527           /* Fixed ? */
528           if(info->frag.fixed)
529             printf("Fragment thr=");
530           else
531             printf("Fragment thr:");
532
533           printf("%d B   ", info->frag.value);
534         }
535     }
536
537   /* Formating */
538   if(tokens > 0)
539     printf("\n          ");
540
541   /* Display encryption information */
542   /* Note : we display only the "current" key, use iwlist to list all keys */
543   if(info->has_key)
544     {
545       printf("Encryption key:");
546       if((info->key_flags & IW_ENCODE_DISABLED) || (info->key_size == 0))
547         printf("off\n          ");
548       else
549         {
550           /* Display the key */
551           print_key(stdout, info->key, info->key_size, info->key_flags);
552
553           /* Other info... */
554           if((info->key_flags & IW_ENCODE_INDEX) > 1)
555             printf(" [%d]", info->key_flags & IW_ENCODE_INDEX);
556           if(info->key_flags & IW_ENCODE_RESTRICTED)
557             printf("   Encryption mode:restricted");
558           if(info->key_flags & IW_ENCODE_OPEN)
559             printf("   Encryption mode:open");
560           printf("\n          ");
561         }
562     }
563
564   /* Display Power Management information */
565   /* Note : we display only one parameter, period or timeout. If a device
566    * (such as HiperLan) has both, the user need to use iwlist... */
567   if(info->has_power)   /* I hope the device has power ;-) */
568     { 
569       printf("Power Management");
570       /* Disabled ? */
571       if(info->power.disabled)
572         printf(":off\n          ");
573       else
574         {
575           /* Let's check the value and its type */
576           if(info->power.flags & IW_POWER_TYPE)
577             print_pm_value(stdout, info->power.value, info->power.flags);
578
579           /* Let's check the mode */
580           print_pm_mode(stdout, info->power.flags);
581
582           /* Let's check if nothing (simply on) */
583           if(info->power.flags == IW_POWER_ON)
584             printf(":on");
585           printf("\n          ");
586         }
587     }
588
589   /* Display statistics */
590   if(info->has_stats)
591     {
592       info->stats.qual.updated = 0x0;   /* Not that reliable, disable */
593       printf("Link ");
594       print_stats(stdout, &info->stats.qual, &info->range, info->has_range);
595
596       printf("          Rx invalid nwid:%d  invalid crypt:%d  invalid misc:%d\n",
597              info->stats.discard.nwid,
598              info->stats.discard.code,
599              info->stats.discard.misc);
600     }
601
602   printf("\n");
603 }
604
605 /*------------------------------------------------------------------*/
606 /*
607  * Print on the screen in a neat fashion all the info we have collected
608  * on a device.
609  */
610 static void
611 print_info(int          skfd,
612            char *       ifname)
613 {
614   struct wireless_info  info;
615
616   if(get_info(skfd, ifname, &info) < 0)
617     {
618       fprintf(stderr, "%-8.8s  no wireless extensions.\n\n",
619               ifname);
620       return;
621     }
622
623   /* Display it ! */
624   display_info(&info, ifname);
625 }
626
627 /*------------------------------------------------------------------*/
628 /*
629  * Get info on all devices and print it on the screen
630  */
631 static void
632 print_devices(int       skfd)
633 {
634   char buff[1024];
635   struct ifconf ifc;
636   struct ifreq *ifr;
637   int i;
638
639   /* Get list of active devices */
640   ifc.ifc_len = sizeof(buff);
641   ifc.ifc_buf = buff;
642   if(ioctl(skfd, SIOCGIFCONF, &ifc) < 0)
643     {
644       fprintf(stderr, "SIOCGIFCONF: %s\n", strerror(errno));
645       return;
646     }
647   ifr = ifc.ifc_req;
648
649   /* Print them */
650   for(i = ifc.ifc_len / sizeof(struct ifreq); --i >= 0; ifr++)
651     print_info(skfd, ifr->ifr_name);
652 }
653
654 /************************* SETTING ROUTINES **************************/
655
656 /*------------------------------------------------------------------*/
657 /*
658  * Set the wireless options requested on command line
659  * This function is too long and probably should be split,
660  * because it look like the perfect definition of spaghetti code,
661  * but I'm way to lazy
662  */
663 static int
664 set_info(int            skfd,           /* The socket */
665          char *         args[],         /* Command line args */
666          int            count,          /* Args count */
667          char *         ifname)         /* Dev name */
668 {
669   struct iwreq          wrq;
670   int                   i;
671
672   /* Set dev name */
673   strncpy(wrq.ifr_name, ifname, IFNAMSIZ);
674
675   /* if nothing after the device name */
676   if(count<1)
677     iw_usage();
678
679   /* The other args on the line specify options to be set... */
680   for(i = 0; i < count; i++)
681     {
682       /* ---------- Set network ID ---------- */
683       if((!strcasecmp(args[i], "nwid")) ||
684          (!strcasecmp(args[i], "domain")))
685         {
686           i++;
687           if(i >= count)
688             iw_usage();
689           if((!strcasecmp(args[i], "off")) ||
690              (!strcasecmp(args[i], "any")))
691             wrq.u.nwid.disabled = 1;
692           else
693             if(!strcasecmp(args[i], "on"))
694               {
695                 /* Get old nwid */
696                 if(ioctl(skfd, SIOCGIWNWID, &wrq) < 0)
697                   {
698                     fprintf(stderr, "SIOCGIWNWID: %s\n", strerror(errno));
699                     return(-1);
700                   }
701                 strcpy(wrq.ifr_name, ifname);
702                 wrq.u.nwid.disabled = 0;
703               }
704             else
705               if(sscanf(args[i], "%lX", (unsigned long *) &(wrq.u.nwid.value))
706                  != 1)
707                 iw_usage();
708               else
709                 wrq.u.nwid.disabled = 0;
710           wrq.u.nwid.fixed = 1;
711
712           if(ioctl(skfd, SIOCSIWNWID, &wrq) < 0)
713             {
714               fprintf(stderr, "SIOCSIWNWID: %s\n", strerror(errno));
715               return(-1);
716             }
717           continue;
718         }
719
720       /* ---------- Set frequency / channel ---------- */
721       if((!strncmp(args[i], "freq", 4)) ||
722          (!strcmp(args[i], "channel")))
723         {
724           double                freq;
725
726           if(++i >= count)
727             iw_usage();
728           if(sscanf(args[i], "%lg", &(freq)) != 1)
729             iw_usage();
730           if(index(args[i], 'G')) freq *= GIGA;
731           if(index(args[i], 'M')) freq *= MEGA;
732           if(index(args[i], 'k')) freq *= KILO;
733
734           float2freq(freq, &(wrq.u.freq));
735
736           if(ioctl(skfd, SIOCSIWFREQ, &wrq) < 0)
737             {
738               fprintf(stderr, "SIOCSIWFREQ: %s\n", strerror(errno));
739               return(-1);
740             }
741           continue;
742         }
743
744       /* ---------- Set sensitivity ---------- */
745       if(!strncmp(args[i], "sens", 4))
746         {
747           if(++i >= count)
748             iw_usage();
749           if(sscanf(args[i], "%d", &(wrq.u.sens.value)) != 1)
750             iw_usage();
751
752           if(ioctl(skfd, SIOCSIWSENS, &wrq) < 0)
753             {
754               fprintf(stderr, "SIOCSIWSENS: %s\n", strerror(errno));
755               return(-1);
756             }
757           continue;
758         }
759
760       /* ---------- Set encryption stuff ---------- */
761       if((!strncmp(args[i], "enc", 3)) ||
762          (!strcmp(args[i], "key")))
763         {
764           unsigned char key[IW_ENCODING_TOKEN_MAX];
765
766           if(++i >= count)
767             iw_usage();
768
769           if(!strcasecmp(args[i], "on"))
770             {
771               /* Get old encryption information */
772               wrq.u.data.pointer = (caddr_t) key;
773               wrq.u.data.length = 0;
774               wrq.u.data.flags = 0;
775               if(ioctl(skfd, SIOCGIWENCODE, &wrq) < 0)
776                 {
777                   fprintf(stderr, "SIOCGIWENCODE: %s\n", strerror(errno));
778                   return(-1);
779                 }
780               strcpy(wrq.ifr_name, ifname);
781               wrq.u.data.flags &= ~IW_ENCODE_DISABLED;  /* Enable */
782             }
783           else
784             {
785               char *    buff;
786               char *    p;
787               int               temp;
788               int               k = 0;
789               int               gotone = 1;
790
791               wrq.u.data.pointer = (caddr_t) NULL;
792               wrq.u.data.flags = 0;
793               wrq.u.data.length = 0;
794
795               /* -- Check for the key -- */
796               if(!strncmp(args[i], "s:", 2))
797                 {
798                   /* First case : as an ASCII string */
799                   wrq.u.data.length = strlen(args[i] + 2);
800                   if(wrq.u.data.length > IW_ENCODING_TOKEN_MAX)
801                     wrq.u.data.length = IW_ENCODING_TOKEN_MAX;
802                   strncpy(key, args[i] + 2, wrq.u.data.length);
803                   wrq.u.data.pointer = (caddr_t) key;
804                   ++i;
805                   gotone = 1;
806                 }
807               else
808                 {
809                   /* Second case : has hexadecimal digits */
810                   p = buff = malloc(strlen(args[i]) + 1);
811                   strcpy(buff, args[i]);
812
813                   p = strtok(buff, "-:;.,");
814                   while(p != (char *) NULL)
815                     {
816                       if(sscanf(p, "%2X", &temp) != 1)
817                         {
818                           gotone = 0;
819                           break;
820                         }
821                       key[k++] = (unsigned char) (temp & 0xFF);
822                       if(strlen(p) > 2) /* Token not finished yet */
823                         p += 2;
824                       else
825                         p = strtok((char *) NULL, "-:;.,");
826                     }
827                   free(buff);
828
829                   if(gotone)
830                     {
831                       ++i;
832                       wrq.u.data.length = k;
833                       wrq.u.data.pointer = (caddr_t) key;
834                     }
835                 }
836
837               /* -- Check for token index -- */
838               if((i < count) &&
839                  (sscanf(args[i], "[%d]", &temp) == 1) &&
840                  (temp > 0) && (temp < IW_ENCODE_INDEX))
841                 {
842                   wrq.u.encoding.flags |= temp;
843                   ++i;
844                   gotone = 1;
845                 }
846
847               /* -- Check the various flags -- */
848               if(i < count)
849                 {
850                   if(!strcasecmp(args[i], "off"))
851                     wrq.u.data.flags |= IW_ENCODE_DISABLED;
852                   if(!strcasecmp(args[i], "open"))
853                     wrq.u.data.flags |= IW_ENCODE_OPEN;
854                   if(!strncasecmp(args[i], "restricted", 5))
855                     wrq.u.data.flags |= IW_ENCODE_RESTRICTED;
856                   if(wrq.u.data.flags & IW_ENCODE_FLAGS)
857                     {
858                       ++i;
859                       gotone = 1;
860                     }
861                 }
862
863               if(!gotone)
864                 iw_usage();
865               --i;
866             }
867
868           if(ioctl(skfd, SIOCSIWENCODE, &wrq) < 0)
869             {
870               fprintf(stderr, "SIOCSIWENCODE(%d): %s\n",
871                       errno, strerror(errno));
872               return(-1);
873             }
874           continue;
875         }
876
877       /* ---------- Set ESSID ---------- */
878       if(!strcasecmp(args[i], "essid"))
879         {
880           char          essid[IW_ESSID_MAX_SIZE + 1];
881
882           i++;
883           if(i >= count)
884             iw_usage();
885           if((!strcasecmp(args[i], "off")) ||
886              (!strcasecmp(args[i], "any")))
887             {
888               wrq.u.essid.flags = 0;
889               essid[0] = '\0';
890             }
891           else
892             if(!strcasecmp(args[i], "on"))
893               {
894                 /* Get old essid */
895                 wrq.u.essid.pointer = (caddr_t) essid;
896                 wrq.u.essid.length = 0;
897                 wrq.u.essid.flags = 0;
898                 if(ioctl(skfd, SIOCGIWESSID, &wrq) < 0)
899                   {
900                     fprintf(stderr, "SIOCGIWESSID: %s\n", strerror(errno));
901                     return(-1);
902                   }
903                 strcpy(wrq.ifr_name, ifname);
904                 wrq.u.essid.flags = 1;
905               }
906             else
907               if(strlen(args[i]) > IW_ESSID_MAX_SIZE)
908                 {
909                   fprintf(stderr, "ESSID too long (max %d): ``%s''\n",
910                           IW_ESSID_MAX_SIZE, args[i]);
911                   iw_usage();
912                 }
913               else
914                 {
915                   int           temp;
916
917                   wrq.u.essid.flags = 1;
918                   strcpy(essid, args[i]);
919
920                   /* Check for ESSID index */
921                   if(((i+1) < count) &&
922                      (sscanf(args[i+1], "[%d]", &temp) == 1) &&
923                      (temp > 0) && (temp < IW_ENCODE_INDEX))
924                     {
925                       wrq.u.essid.flags = temp;
926                       ++i;
927                     }
928                 }
929
930           wrq.u.essid.pointer = (caddr_t) essid;
931           wrq.u.essid.length = strlen(essid) + 1;
932           if(ioctl(skfd, SIOCSIWESSID, &wrq) < 0)
933             {
934               fprintf(stderr, "SIOCSIWESSID: %s\n", strerror(errno));
935               return(-1);
936             }
937           continue;
938         }
939
940       /* ---------- Set AP address ---------- */
941       if(!strcasecmp(args[i], "ap"))
942         {
943           if(++i >= count)
944             iw_usage();
945
946           /* Check if we have valid address types */
947           if(check_addr_type(skfd, ifname) < 0)
948             {
949               fprintf(stderr, "%-8.8s  Interface doesn't support MAC & IP addresses\n", ifname);
950               return(-1);
951             }
952
953           /* Get the address */
954           if(in_addr(skfd, ifname, args[i++], &(wrq.u.ap_addr)) < 0)
955             iw_usage();
956
957           if(ioctl(skfd, SIOCSIWAP, &wrq) < 0)
958             {
959               fprintf(stderr, "SIOCSIWAP: %s\n", strerror(errno));
960               return(-1);
961             }
962           continue;
963         }
964
965       /* ---------- Set NickName ---------- */
966       if(!strncmp(args[i], "nick", 4))
967         {
968           i++;
969           if(i >= count)
970             iw_usage();
971           if(strlen(args[i]) > IW_ESSID_MAX_SIZE)
972             {
973               fprintf(stderr, "Name too long (max %d) : ``%s''\n",
974                       IW_ESSID_MAX_SIZE, args[i]);
975               iw_usage();
976             }
977
978           wrq.u.essid.pointer = (caddr_t) args[i];
979           wrq.u.essid.length = strlen(args[i]) + 1;
980           if(ioctl(skfd, SIOCSIWNICKN, &wrq) < 0)
981             {
982               fprintf(stderr, "SIOCSIWNICKN: %s\n", strerror(errno));
983               return(-1);
984             }
985           continue;
986         }
987
988       /* ---------- Set Bit-Rate ---------- */
989       if((!strncmp(args[i], "bit", 3)) ||
990          (!strcmp(args[i], "rate")))
991         {
992           if(++i >= count)
993             iw_usage();
994           if(!strcasecmp(args[i], "auto"))
995             {
996               wrq.u.bitrate.value = -1;
997               wrq.u.bitrate.fixed = 0;
998             }
999           else
1000             {
1001               if(!strcasecmp(args[i], "fixed"))
1002                 {
1003                   /* Get old bitrate */
1004                   if(ioctl(skfd, SIOCGIWRATE, &wrq) < 0)
1005                     {
1006                       fprintf(stderr, "SIOCGIWRATE: %s\n", strerror(errno));
1007                       return(-1);
1008                     }
1009                   strcpy(wrq.ifr_name, ifname);
1010                   wrq.u.bitrate.fixed = 1;
1011                 }
1012               else                      /* Should be a numeric value */
1013                 {
1014                   double                brate;
1015
1016                   if(sscanf(args[i], "%lg", &(brate)) != 1)
1017                     iw_usage();
1018                   if(index(args[i], 'G')) brate *= GIGA;
1019                   if(index(args[i], 'M')) brate *= MEGA;
1020                   if(index(args[i], 'k')) brate *= KILO;
1021                   wrq.u.bitrate.value = (long) brate;
1022                   wrq.u.bitrate.fixed = 1;
1023
1024                   /* Check for an additional argument */
1025                   if(((i+1) < count) &&
1026                      (!strcasecmp(args[i+1], "auto")))
1027                     {
1028                       wrq.u.bitrate.fixed = 0;
1029                       ++i;
1030                     }
1031                   if(((i+1) < count) &&
1032                      (!strcasecmp(args[i+1], "fixed")))
1033                     {
1034                       wrq.u.bitrate.fixed = 1;
1035                       ++i;
1036                     }
1037                 }
1038             }
1039
1040           if(ioctl(skfd, SIOCSIWRATE, &wrq) < 0)
1041             {
1042               fprintf(stderr, "SIOCSIWRATE: %s\n", strerror(errno));
1043               return(-1);
1044             }
1045           continue;
1046         }
1047
1048       /* ---------- Set RTS threshold ---------- */
1049       if(!strncasecmp(args[i], "rts", 3))
1050         {
1051           i++;
1052           if(i >= count)
1053             iw_usage();
1054           wrq.u.rts.value = -1;
1055           wrq.u.rts.fixed = 1;
1056           wrq.u.rts.disabled = 0;
1057           if(!strcasecmp(args[i], "off"))
1058             wrq.u.rts.disabled = 1;     /* i.e. max size */
1059           else
1060             if(!strcasecmp(args[i], "auto"))
1061               wrq.u.rts.fixed = 0;
1062             else
1063               {
1064                 if(!strcasecmp(args[i], "fixed"))
1065                   {
1066                     /* Get old RTS threshold */
1067                     if(ioctl(skfd, SIOCGIWRTS, &wrq) < 0)
1068                       {
1069                         fprintf(stderr, "SIOCGIWRTS: %s\n", strerror(errno));
1070                         return(-1);
1071                       }
1072                     strcpy(wrq.ifr_name, ifname);
1073                     wrq.u.rts.fixed = 1;
1074                   }
1075                 else                    /* Should be a numeric value */
1076                   if(sscanf(args[i], "%ld", (unsigned long *) &(wrq.u.rts.value))
1077                      != 1)
1078                     iw_usage();
1079             }
1080
1081           if(ioctl(skfd, SIOCSIWRTS, &wrq) < 0)
1082             {
1083               fprintf(stderr, "SIOCSIWRTS: %s\n", strerror(errno));
1084               return(-1);
1085             }
1086           continue;
1087         }
1088
1089       /* ---------- Set fragmentation threshold ---------- */
1090       if(!strncmp(args[i], "frag", 4))
1091         {
1092           i++;
1093           if(i >= count)
1094             iw_usage();
1095           wrq.u.frag.value = -1;
1096           wrq.u.frag.fixed = 1;
1097           wrq.u.frag.disabled = 0;
1098           if(!strcasecmp(args[i], "off"))
1099             wrq.u.frag.disabled = 1;    /* i.e. max size */
1100           else
1101             if(!strcasecmp(args[i], "auto"))
1102               wrq.u.frag.fixed = 0;
1103             else
1104               {
1105                 if(!strcasecmp(args[i], "fixed"))
1106                   {
1107                     /* Get old fragmentation threshold */
1108                     if(ioctl(skfd, SIOCGIWFRAG, &wrq) < 0)
1109                       {
1110                         fprintf(stderr, "SIOCGIWFRAG: %s\n", strerror(errno));
1111                         return(-1);
1112                       }
1113                     strcpy(wrq.ifr_name, ifname);
1114                     wrq.u.frag.fixed = 1;
1115                   }
1116                 else                    /* Should be a numeric value */
1117                   if(sscanf(args[i], "%ld", (unsigned long *) &(wrq.u.frag.value))
1118                      != 1)
1119                     iw_usage();
1120             }
1121
1122           if(ioctl(skfd, SIOCSIWFRAG, &wrq) < 0)
1123             {
1124               fprintf(stderr, "SIOCSIWFRAG: %s\n", strerror(errno));
1125               return(-1);
1126             }
1127           continue;
1128         }
1129
1130       /* ---------- Set operation mode ---------- */
1131       if(!strcmp(args[i], "mode"))
1132         {
1133           int   k;
1134
1135           i++;
1136           if(i >= count)
1137             iw_usage();
1138
1139           if(sscanf(args[i], "%d", &k) != 1)
1140             {
1141               k = 0;
1142               while(k < 6 && strncasecmp(args[i], operation_mode[k], 3))
1143                 k++;
1144             }
1145           if((k > 5) || (k < 0))
1146             iw_usage();
1147
1148           wrq.u.mode = k;
1149           if(ioctl(skfd, SIOCSIWMODE, &wrq) < 0)
1150             {
1151               fprintf(stderr, "SIOCSIWMODE: %s\n", strerror(errno));
1152               return(-1);
1153             }
1154           continue;
1155         }
1156
1157       /* ---------- Set Power Management ---------- */
1158       if(!strncmp(args[i], "power", 3))
1159         {
1160           if(++i >= count)
1161             iw_usage();
1162
1163           if(!strcasecmp(args[i], "off"))
1164             wrq.u.power.disabled = 1;   /* i.e. max size */
1165           else
1166             if(!strcasecmp(args[i], "on"))
1167               {
1168                 /* Get old Power info */
1169                 if(ioctl(skfd, SIOCGIWPOWER, &wrq) < 0)
1170                   {
1171                     fprintf(stderr, "SIOCGIWPOWER: %s\n", strerror(errno));
1172                     return(-1);
1173                   }
1174                 strcpy(wrq.ifr_name, ifname);
1175                 wrq.u.power.disabled = 0;
1176               }
1177             else
1178               {
1179                 double          temp;
1180                 int             gotone = 0;
1181                 /* Default - nope */
1182                 wrq.u.power.flags = IW_POWER_ON;
1183                 wrq.u.power.disabled = 0;
1184
1185                 /* Check value modifier */
1186                 if(!strcasecmp(args[i], "min"))
1187                   {
1188                     wrq.u.power.flags |= IW_POWER_MIN;
1189                     if(++i >= count)
1190                       iw_usage();
1191                   }
1192                 else
1193                   if(!strcasecmp(args[i], "max"))
1194                     {
1195                       wrq.u.power.flags |= IW_POWER_MAX;
1196                       if(++i >= count)
1197                         iw_usage();
1198                     }
1199
1200                 /* Check value type */
1201                 if(!strcasecmp(args[i], "period"))
1202                   {
1203                     wrq.u.power.flags |= IW_POWER_PERIOD;
1204                     if(++i >= count)
1205                       iw_usage();
1206                   }
1207                 else
1208                   if(!strcasecmp(args[i], "timeout"))
1209                     {
1210                       wrq.u.power.flags |= IW_POWER_TIMEOUT;
1211                       if(++i >= count)
1212                         iw_usage();
1213                     }
1214
1215                 /* Is there any value to grab ? */
1216                 if(sscanf(args[i], "%lg", &(temp)) == 1)
1217                   {
1218                     temp *= MEGA;       /* default = s */
1219                     if(index(args[i], 'u')) temp /= MEGA;
1220                     if(index(args[i], 'm')) temp /= KILO;
1221                     wrq.u.power.value = (long) temp;
1222                     if((wrq.u.power.flags & IW_POWER_TYPE) == 0)
1223                       wrq.u.power.flags |= IW_POWER_PERIOD;
1224                     ++i;
1225                     gotone = 1;
1226                   }
1227
1228                 /* Now, check the mode */
1229                 if(i < count)
1230                   {
1231                     if(!strcasecmp(args[i], "all"))
1232                       wrq.u.power.flags |= IW_POWER_ALL_R;
1233                     if(!strncasecmp(args[i], "unicast", 4))
1234                       wrq.u.power.flags |= IW_POWER_UNICAST_R;
1235                     if(!strncasecmp(args[i], "multicast", 5))
1236                       wrq.u.power.flags |= IW_POWER_MULTICAST_R;
1237                     if(!strncasecmp(args[i], "force", 5))
1238                       wrq.u.power.flags |= IW_POWER_FORCE_S;
1239                     if(!strcasecmp(args[i], "repeat"))
1240                       wrq.u.power.flags |= IW_POWER_REPEATER;
1241                     if(wrq.u.power.flags & IW_POWER_MODE)
1242                       {
1243                         ++i;
1244                         gotone = 1;
1245                       }
1246                   }
1247                 if(!gotone)
1248                   iw_usage();
1249                 --i;
1250               }
1251
1252           if(ioctl(skfd, SIOCSIWPOWER, &wrq) < 0)
1253             {
1254               fprintf(stderr, "SIOCSIWPOWER(%d): %s\n",
1255                       errno, strerror(errno));
1256               return(-1);
1257             }
1258           continue;
1259         }
1260
1261 #if WIRELESS_EXT > 9
1262       /* ---------- Set Transmit-Power ---------- */
1263       if(!strncmp(args[i], "txpower", 3))
1264         {
1265           struct iw_range       range;
1266
1267           if(++i >= count)
1268             iw_usage();
1269
1270           /* Extract range info */
1271           if(get_range_info(skfd, ifname, &range) < 0)
1272             memset(&range, 0, sizeof(range));
1273
1274           /* Prepare the request */
1275           strncpy(wrq.ifr_name, ifname, IFNAMSIZ);
1276           wrq.u.txpower.value = -1;
1277           wrq.u.txpower.fixed = 1;
1278           wrq.u.txpower.disabled = 0;
1279           wrq.u.data.flags = IW_TXPOW_DBM;
1280           if(!strcasecmp(args[i], "off"))
1281             wrq.u.txpower.disabled = 1; /* i.e. turn radio off */
1282           else
1283             if(!strcasecmp(args[i], "auto"))
1284               wrq.u.txpower.fixed = 0;  /* i.e. use power control */
1285             else
1286               {
1287                 if(!strcasecmp(args[i], "fixed"))
1288                   {
1289                     /* Get old tx-power */
1290                     if(ioctl(skfd, SIOCGIWTXPOW, &wrq) < 0)
1291                       {
1292                         fprintf(stderr, "SIOCGIWTXPOW: %s\n", strerror(errno));
1293                         return(-1);
1294                       }
1295                     strcpy(wrq.ifr_name, ifname);
1296                     wrq.u.txpower.fixed = 1;
1297                   }
1298                 else                    /* Should be a numeric value */
1299                   {
1300                     int         power;
1301                     int         ismwatt = 0;
1302
1303                     /* Get the value */
1304                     if(sscanf(args[i], "%ld",
1305                               (unsigned long *) &(power)) != 1)
1306                       iw_usage();
1307
1308                     /* Check if milliwatt */
1309                     ismwatt = (index(args[i], 'm') != NULL);
1310
1311                     /* Convert */
1312                     if(!ismwatt && (range.txpower_capa & IW_TXPOW_MWATT))
1313                       {
1314                         power = dbm2mwatt(power);
1315                         wrq.u.data.flags = IW_TXPOW_MWATT;
1316                       }
1317                     if(ismwatt && !(range.txpower_capa & IW_TXPOW_MWATT))
1318                       power = mwatt2dbm(power);
1319                     wrq.u.bitrate.value = power;
1320
1321                     /* Check for an additional argument */
1322                     if(((i+1) < count) &&
1323                        (!strcasecmp(args[i+1], "auto")))
1324                       {
1325                         wrq.u.txpower.fixed = 0;
1326                         ++i;
1327                       }
1328                     if(((i+1) < count) &&
1329                        (!strcasecmp(args[i+1], "fixed")))
1330                       {
1331                         wrq.u.txpower.fixed = 1;
1332                         ++i;
1333                       }
1334                   }
1335               }
1336
1337           if(ioctl(skfd, SIOCSIWTXPOW, &wrq) < 0)
1338             {
1339               fprintf(stderr, "SIOCSIWTXPOW: %s\n", strerror(errno));
1340               return(-1);
1341             }
1342           continue;
1343         }
1344 #endif
1345
1346 #if WIRELESS_EXT > 10
1347       /* ---------- Set Power Management ---------- */
1348       if(!strncmp(args[i], "retry", 3))
1349         {
1350           double                temp;
1351           int           gotone = 0;
1352
1353           if(++i >= count)
1354             iw_usage();
1355
1356           /* Default - nope */
1357           wrq.u.retry.flags = IW_RETRY_LIMIT;
1358           wrq.u.retry.disabled = 0;
1359
1360           /* Check value modifier */
1361           if(!strcasecmp(args[i], "min"))
1362             {
1363               wrq.u.retry.flags |= IW_RETRY_MIN;
1364               if(++i >= count)
1365                 iw_usage();
1366             }
1367           else
1368             if(!strcasecmp(args[i], "max"))
1369               {
1370                 wrq.u.retry.flags |= IW_RETRY_MAX;
1371                 if(++i >= count)
1372                   iw_usage();
1373               }
1374
1375           /* Check value type */
1376           if(!strcasecmp(args[i], "limit"))
1377             {
1378               wrq.u.retry.flags |= IW_RETRY_LIMIT;
1379               if(++i >= count)
1380                 iw_usage();
1381             }
1382           else
1383             if(!strncasecmp(args[i], "lifetime", 4))
1384               {
1385                 wrq.u.retry.flags |= IW_RETRY_LIFETIME;
1386                 if(++i >= count)
1387                   iw_usage();
1388               }
1389
1390           /* Is there any value to grab ? */
1391           if(sscanf(args[i], "%lg", &(temp)) == 1)
1392             {
1393               /* Limit is absolute, on the other hand lifetime is seconds */
1394               if(!(wrq.u.retry.flags & IW_RETRY_LIMIT))
1395                 {
1396                   /* Normalise lifetime */
1397                   temp *= MEGA; /* default = s */
1398                   if(index(args[i], 'u')) temp /= MEGA;
1399                   if(index(args[i], 'm')) temp /= KILO;
1400                 }
1401               wrq.u.retry.value = (long) temp;
1402               ++i;
1403               gotone = 1;
1404             }
1405
1406           if(!gotone)
1407             iw_usage();
1408           --i;
1409
1410           if(ioctl(skfd, SIOCSIWRETRY, &wrq) < 0)
1411             {
1412               fprintf(stderr, "SIOCSIWRETRY(%d): %s\n",
1413                       errno, strerror(errno));
1414               return(-1);
1415             }
1416           continue;
1417         }
1418
1419 #endif  /* WIRELESS_EXT > 10 */
1420
1421       /* ---------- Other ---------- */
1422       /* Here we have an unrecognised arg... */
1423       fprintf(stderr, "Invalid argument : %s\n", args[i]);
1424       iw_usage();
1425       return(-1);
1426     }           /* for(index ... */
1427   return(0);
1428 }
1429
1430 /******************************* MAIN ********************************/
1431
1432 /*------------------------------------------------------------------*/
1433 /*
1434  * The main !
1435  */
1436 int
1437 main(int        argc,
1438      char **    argv)
1439 {
1440   int skfd = -1;                /* generic raw socket desc.     */
1441   int goterr = 0;
1442
1443   /* Create a channel to the NET kernel. */
1444   if((skfd = sockets_open()) < 0)
1445     {
1446       perror("socket");
1447       exit(-1);
1448     }
1449
1450   /* No argument : show the list of all device + info */
1451   if(argc == 1)
1452     {
1453       print_devices(skfd);
1454       close(skfd);
1455       exit(0);
1456     }
1457
1458   /* Special case for help... */
1459   if((!strncmp(argv[1], "-h", 9)) ||
1460      (!strcmp(argv[1], "--help")))
1461     {
1462       iw_usage();
1463       close(skfd);
1464       exit(0);
1465     }
1466
1467   /* The device name must be the first argument */
1468   if(argc == 2)
1469     {
1470       print_info(skfd, argv[1]);
1471       close(skfd);
1472       exit(0);
1473     }
1474
1475   /* The other args on the line specify options to be set... */
1476   goterr = set_info(skfd, argv + 2, argc - 2, argv[1]);
1477
1478   /* Close the socket. */
1479   close(skfd);
1480
1481   return(goterr);
1482 }