• source navigation  • diff markup  • identifier search  • freetext search  • 

Sources/iwinfo/iwinfo_cli.c

  1 /*
  2  * iwinfo - Wireless Information Library - Command line frontend
  3  *
  4  *   Copyright (C) 2011 Jo-Philipp Wich <xm@subsignal.org>
  5  *
  6  * The iwinfo library is free software: you can redistribute it and/or
  7  * modify it under the terms of the GNU General Public License version 2
  8  * as published by the Free Software Foundation.
  9  *
 10  * The iwinfo library is distributed in the hope that it will be useful,
 11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 13  * See the GNU General Public License for more details.
 14  *
 15  * You should have received a copy of the GNU General Public License along
 16  * with the iwinfo library. If not, see http://www.gnu.org/licenses/.
 17  */
 18 
 19 #include <stdio.h>
 20 #include <glob.h>
 21 
 22 #include "iwinfo.h"
 23 
 24 
 25 static char * format_bssid(unsigned char *mac)
 26 {
 27         static char buf[18];
 28 
 29         snprintf(buf, sizeof(buf), "%02X:%02X:%02X:%02X:%02X:%02X",
 30                 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
 31 
 32         return buf;
 33 }
 34 
 35 static char * format_ssid(char *ssid)
 36 {
 37         static char buf[IWINFO_ESSID_MAX_SIZE+3];
 38 
 39         if (ssid && ssid[0])
 40                 snprintf(buf, sizeof(buf), "\"%s\"", ssid);
 41         else
 42                 snprintf(buf, sizeof(buf), "unknown");
 43 
 44         return buf;
 45 }
 46 
 47 static char * format_channel(int ch)
 48 {
 49         static char buf[8];
 50 
 51         if (ch <= 0)
 52                 snprintf(buf, sizeof(buf), "unknown");
 53         else
 54                 snprintf(buf, sizeof(buf), "%d", ch);
 55 
 56         return buf;
 57 }
 58 
 59 static char * format_frequency(int freq)
 60 {
 61         static char buf[11];
 62 
 63         if (freq <= 0)
 64                 snprintf(buf, sizeof(buf), "unknown");
 65         else
 66                 snprintf(buf, sizeof(buf), "%.3f GHz", ((float)freq / 1000.0));
 67 
 68         return buf;
 69 }
 70 
 71 static char * format_txpower(int pwr)
 72 {
 73         static char buf[10];
 74 
 75         if (pwr < 0)
 76                 snprintf(buf, sizeof(buf), "unknown");
 77         else
 78                 snprintf(buf, sizeof(buf), "%d dBm", pwr);
 79 
 80         return buf;
 81 }
 82 
 83 static char * format_quality(int qual)
 84 {
 85         static char buf[8];
 86 
 87         if (qual < 0)
 88                 snprintf(buf, sizeof(buf), "unknown");
 89         else
 90                 snprintf(buf, sizeof(buf), "%d", qual);
 91 
 92         return buf;
 93 }
 94 
 95 static char * format_quality_max(int qmax)
 96 {
 97         static char buf[8];
 98 
 99         if (qmax < 0)
100                 snprintf(buf, sizeof(buf), "unknown");
101         else
102                 snprintf(buf, sizeof(buf), "%d", qmax);
103 
104         return buf;
105 }
106 
107 static char * format_signal(int sig)
108 {
109         static char buf[10];
110 
111         if (!sig)
112                 snprintf(buf, sizeof(buf), "unknown");
113         else
114                 snprintf(buf, sizeof(buf), "%d dBm", sig);
115 
116         return buf;
117 }
118 
119 static char * format_noise(int noise)
120 {
121         static char buf[10];
122 
123         if (!noise)
124                 snprintf(buf, sizeof(buf), "unknown");
125         else
126                 snprintf(buf, sizeof(buf), "%d dBm", noise);
127 
128         return buf;
129 }
130 
131 static char * format_rate(int rate)
132 {
133         static char buf[18];
134 
135         if (rate <= 0)
136                 snprintf(buf, sizeof(buf), "unknown");
137         else
138                 snprintf(buf, sizeof(buf), "%d.%d MBit/s",
139                         rate / 1000, (rate % 1000) / 100);
140 
141         return buf;
142 }
143 
144 static char * format_enc_ciphers(int ciphers)
145 {
146         static char str[128] = { 0 };
147         char *pos = str;
148 
149         if (ciphers & IWINFO_CIPHER_WEP40)
150                 pos += sprintf(pos, "WEP-40, ");
151 
152         if (ciphers & IWINFO_CIPHER_WEP104)
153                 pos += sprintf(pos, "WEP-104, ");
154 
155         if (ciphers & IWINFO_CIPHER_TKIP)
156                 pos += sprintf(pos, "TKIP, ");
157 
158         if (ciphers & IWINFO_CIPHER_CCMP)
159                 pos += sprintf(pos, "CCMP, ");
160 
161         if (ciphers & IWINFO_CIPHER_GCMP)
162                 pos += sprintf(pos, "GCMP, ");
163 
164         if (ciphers & IWINFO_CIPHER_WRAP)
165                 pos += sprintf(pos, "WRAP, ");
166 
167         if (ciphers & IWINFO_CIPHER_AESOCB)
168                 pos += sprintf(pos, "AES-OCB, ");
169 
170         if (ciphers & IWINFO_CIPHER_CKIP)
171                 pos += sprintf(pos, "CKIP, ");
172 
173         if (!ciphers || (ciphers & IWINFO_CIPHER_NONE))
174                 pos += sprintf(pos, "NONE, ");
175 
176         *(pos - 2) = 0;
177 
178         return str;
179 }
180 
181 static char * format_enc_suites(int suites)
182 {
183         static char str[64] = { 0 };
184         char *pos = str;
185 
186         if (suites & IWINFO_KMGMT_PSK)
187                 pos += sprintf(pos, "PSK/");
188 
189         if (suites & IWINFO_KMGMT_8021x)
190                 pos += sprintf(pos, "802.1X/");
191 
192         if (suites & IWINFO_KMGMT_SAE)
193                 pos += sprintf(pos, "SAE/");
194 
195         if (suites & IWINFO_KMGMT_OWE)
196                 pos += sprintf(pos, "OWE/");
197 
198         if (!suites || (suites & IWINFO_KMGMT_NONE))
199                 pos += sprintf(pos, "NONE/");
200 
201         *(pos - 1) = 0;
202 
203         return str;
204 }
205 
206 static char * format_encryption(struct iwinfo_crypto_entry *c)
207 {
208         static char buf[512];
209         char *pos = buf;
210         int i, n;
211 
212         if (!c)
213         {
214                 snprintf(buf, sizeof(buf), "unknown");
215         }
216         else if (c->enabled)
217         {
218                 /* WEP */
219                 if (c->auth_algs && !c->wpa_version)
220                 {
221                         if ((c->auth_algs & IWINFO_AUTH_OPEN) &&
222                                 (c->auth_algs & IWINFO_AUTH_SHARED))
223                         {
224                                 snprintf(buf, sizeof(buf), "WEP Open/Shared (%s)",
225                                         format_enc_ciphers(c->pair_ciphers));
226                         }
227                         else if (c->auth_algs & IWINFO_AUTH_OPEN)
228                         {
229                                 snprintf(buf, sizeof(buf), "WEP Open System (%s)",
230                                         format_enc_ciphers(c->pair_ciphers));
231                         }
232                         else if (c->auth_algs & IWINFO_AUTH_SHARED)
233                         {
234                                 snprintf(buf, sizeof(buf), "WEP Shared Auth (%s)",
235                                         format_enc_ciphers(c->pair_ciphers));
236                         }
237                 }
238 
239                 /* WPA */
240                 else if (c->wpa_version)
241                 {
242                         for (i = 0, n = 0; i < 3; i++)
243                                 if (c->wpa_version & (1 << i))
244                                         n++;
245 
246                         if (n > 1)
247                                 pos += sprintf(pos, "mixed ");
248 
249                         for (i = 0; i < 3; i++)
250                                 if (c->wpa_version & (1 << i))
251                                         if (i)
252                                                 pos += sprintf(pos, "WPA%d/", i + 1);
253                                         else
254                                                 pos += sprintf(pos, "WPA/");
255 
256                         pos--;
257 
258                         sprintf(pos, " %s (%s)",
259                                 format_enc_suites(c->auth_suites),
260                                 format_enc_ciphers(c->pair_ciphers | c->group_ciphers));
261                 }
262                 else
263                 {
264                         snprintf(buf, sizeof(buf), "none");
265                 }
266         }
267         else
268         {
269                 snprintf(buf, sizeof(buf), "none");
270         }
271 
272         return buf;
273 }
274 
275 static char * format_hwmodes(int modes)
276 {
277         static char buf[17];
278 
279         if (modes <= 0)
280                 snprintf(buf, sizeof(buf), "unknown");
281         else
282                 snprintf(buf, sizeof(buf), "802.11%s%s%s%s%s%s%s",
283                         (modes & IWINFO_80211_A) ? "a" : "",
284                         (modes & IWINFO_80211_B) ? "b" : "",
285                         (modes & IWINFO_80211_G) ? "g" : "",
286                         (modes & IWINFO_80211_N) ? "n" : "",
287                         (modes & IWINFO_80211_AC) ? "ac" : "",
288                         (modes & IWINFO_80211_AD) ? "ad" : "",
289                         (modes & IWINFO_80211_AX) ? "ax" : "");
290 
291         return buf;
292 }
293 
294 static char * format_assocrate(struct iwinfo_rate_entry *r)
295 {
296         static char buf[80];
297         char *p = buf;
298         int l = sizeof(buf);
299 
300         if (r->rate <= 0)
301         {
302                 snprintf(buf, sizeof(buf), "unknown");
303         }
304         else
305         {
306                 p += snprintf(p, l, "%s", format_rate(r->rate));
307                 l = sizeof(buf) - (p - buf);
308 
309                 if (r->is_ht)
310                 {
311                         p += snprintf(p, l, ", MCS %d, %dMHz", r->mcs, r->mhz);
312                         l = sizeof(buf) - (p - buf);
313                 }
314                 else if (r->is_vht)
315                 {
316                         p += snprintf(p, l, ", VHT-MCS %d, %dMHz", r->mcs, r->mhz);
317                         l = sizeof(buf) - (p - buf);
318 
319                         if (r->nss)
320                         {
321                                 p += snprintf(p, l, ", VHT-NSS %d", r->nss);
322                                 l = sizeof(buf) - (p - buf);
323                         }
324                 }
325                 else if (r->is_he)
326                 {
327                         p += snprintf(p, l, ", HE-MCS %d, %dMHz", r->mcs, r->mhz);
328                         l = sizeof(buf) - (p - buf);
329 
330                         p += snprintf(p, l, ", HE-NSS %d", r->nss);
331                         l = sizeof(buf) - (p - buf);
332 
333                         p += snprintf(p, l, ", HE-GI %d", r->he_gi);
334                         l = sizeof(buf) - (p - buf);
335 
336                         p += snprintf(p, l, ", HE-DCM %d", r->he_dcm);
337                         l = sizeof(buf) - (p - buf);
338                 }
339         }
340 
341         return buf;
342 }
343 
344 static const char* format_chan_width(uint16_t width)
345 {
346         switch (width) {
347                 case 20: return "20 MHz";
348                 case 2040: return "40 MHz and upper or 20 MHz with intolerant bit";
349                 case 40: return "40 MHz or lower";
350                 case 80: return "80 MHz";
351                 case 8080: return "80+80 MHz";
352                 case 160: return "160 MHz";
353         }
354 
355         return "unknown";
356 }
357 
358 
359 static const char * print_type(const struct iwinfo_ops *iw, const char *ifname)
360 {
361         const char *type = iwinfo_type(ifname);
362         return type ? type : "unknown";
363 }
364 
365 static char * print_hardware_id(const struct iwinfo_ops *iw, const char *ifname)
366 {
367         static char buf[20];
368         struct iwinfo_hardware_id ids;
369 
370         if (!iw->hardware_id(ifname, (char *)&ids))
371         {
372                 snprintf(buf, sizeof(buf), "%04X:%04X %04X:%04X",
373                         ids.vendor_id, ids.device_id,
374                         ids.subsystem_vendor_id, ids.subsystem_device_id);
375         }
376         else
377         {
378                 snprintf(buf, sizeof(buf), "unknown");
379         }
380 
381         return buf;
382 }
383 
384 static char * print_hardware_name(const struct iwinfo_ops *iw, const char *ifname)
385 {
386         static char buf[128];
387 
388         if (iw->hardware_name(ifname, buf))
389                 snprintf(buf, sizeof(buf), "unknown");
390 
391         return buf;
392 }
393 
394 static char * print_txpower_offset(const struct iwinfo_ops *iw, const char *ifname)
395 {
396         int off;
397         static char buf[12];
398 
399         if (iw->txpower_offset(ifname, &off))
400                 snprintf(buf, sizeof(buf), "unknown");
401         else if (off != 0)
402                 snprintf(buf, sizeof(buf), "%d dB", off);
403         else
404                 snprintf(buf, sizeof(buf), "none");
405 
406         return buf;
407 }
408 
409 static char * print_frequency_offset(const struct iwinfo_ops *iw, const char *ifname)
410 {
411         int off;
412         static char buf[12];
413 
414         if (iw->frequency_offset(ifname, &off))
415                 snprintf(buf, sizeof(buf), "unknown");
416         else if (off != 0)
417                 snprintf(buf, sizeof(buf), "%.3f GHz", ((float)off / 1000.0));
418         else
419                 snprintf(buf, sizeof(buf), "none");
420 
421         return buf;
422 }
423 
424 static char * print_ssid(const struct iwinfo_ops *iw, const char *ifname)
425 {
426         char buf[IWINFO_ESSID_MAX_SIZE+1] = { 0 };
427 
428         if (iw->ssid(ifname, buf))
429                 memset(buf, 0, sizeof(buf));
430 
431         return format_ssid(buf);
432 }
433 
434 static char * print_bssid(const struct iwinfo_ops *iw, const char *ifname)
435 {
436         static char buf[18] = { 0 };
437 
438         if (iw->bssid(ifname, buf))
439                 snprintf(buf, sizeof(buf), "00:00:00:00:00:00");
440 
441         return buf;
442 }
443 
444 static char * print_mode(const struct iwinfo_ops *iw, const char *ifname)
445 {
446         int mode;
447         static char buf[128];
448 
449         if (iw->mode(ifname, &mode))
450                 mode = IWINFO_OPMODE_UNKNOWN;
451 
452         snprintf(buf, sizeof(buf), "%s", IWINFO_OPMODE_NAMES[mode]);
453 
454         return buf;
455 }
456 
457 static char * print_channel(const struct iwinfo_ops *iw, const char *ifname)
458 {
459         int ch;
460         if (iw->channel(ifname, &ch))
461                 ch = -1;
462 
463         return format_channel(ch);
464 }
465 
466 static char * print_center_chan1(const struct iwinfo_ops *iw, const char *ifname)
467 {
468         int ch;
469         if (iw->center_chan1(ifname, &ch))
470                 ch = -1;
471 
472         return format_channel(ch);
473 }
474 
475 static char * print_center_chan2(const struct iwinfo_ops *iw, const char *ifname)
476 {
477         int ch;
478         if (iw->center_chan2(ifname, &ch))
479                 ch = -1;
480 
481         return format_channel(ch);
482 }
483 
484 static char * print_frequency(const struct iwinfo_ops *iw, const char *ifname)
485 {
486         int freq;
487         if (iw->frequency(ifname, &freq))
488                 freq = -1;
489 
490         return format_frequency(freq);
491 }
492 
493 static char * print_txpower(const struct iwinfo_ops *iw, const char *ifname)
494 {
495         int pwr, off;
496         if (iw->txpower_offset(ifname, &off))
497                 off = 0;
498 
499         if (iw->txpower(ifname, &pwr))
500                 pwr = -1;
501         else
502                 pwr += off;
503 
504         return format_txpower(pwr);
505 }
506 
507 static char * print_quality(const struct iwinfo_ops *iw, const char *ifname)
508 {
509         int qual;
510         if (iw->quality(ifname, &qual))
511                 qual = -1;
512 
513         return format_quality(qual);
514 }
515 
516 static char * print_quality_max(const struct iwinfo_ops *iw, const char *ifname)
517 {
518         int qmax;
519         if (iw->quality_max(ifname, &qmax))
520                 qmax = -1;
521 
522         return format_quality_max(qmax);
523 }
524 
525 static char * print_signal(const struct iwinfo_ops *iw, const char *ifname)
526 {
527         int sig;
528         if (iw->signal(ifname, &sig))
529                 sig = 0;
530 
531         return format_signal(sig);
532 }
533 
534 static char * print_noise(const struct iwinfo_ops *iw, const char *ifname)
535 {
536         int noise;
537         if (iw->noise(ifname, &noise))
538                 noise = 0;
539 
540         return format_noise(noise);
541 }
542 
543 static char * print_rate(const struct iwinfo_ops *iw, const char *ifname)
544 {
545         int rate;
546         if (iw->bitrate(ifname, &rate))
547                 rate = -1;
548 
549         return format_rate(rate);
550 }
551 
552 static char * print_encryption(const struct iwinfo_ops *iw, const char *ifname)
553 {
554         struct iwinfo_crypto_entry c = { 0 };
555         if (iw->encryption(ifname, (char *)&c))
556                 return format_encryption(NULL);
557 
558         return format_encryption(&c);
559 }
560 
561 static char * print_hwmodes(const struct iwinfo_ops *iw, const char *ifname)
562 {
563         int modes;
564         if (iw->hwmodelist(ifname, &modes))
565                 modes = -1;
566 
567         return format_hwmodes(modes);
568 }
569 
570 static char * print_mbssid_supp(const struct iwinfo_ops *iw, const char *ifname)
571 {
572         int supp;
573         static char buf[4];
574 
575         if (iw->mbssid_support(ifname, &supp))
576                 snprintf(buf, sizeof(buf), "no");
577         else
578                 snprintf(buf, sizeof(buf), "%s", supp ? "yes" : "no");
579 
580         return buf;
581 }
582 
583 static char * print_phyname(const struct iwinfo_ops *iw, const char *ifname)
584 {
585         static char buf[32];
586 
587         if (!iw->phyname(ifname, buf))
588                 return buf;
589 
590         return "?";
591 }
592 
593 
594 static void print_info(const struct iwinfo_ops *iw, const char *ifname)
595 {
596         printf("%-9s ESSID: %s\n",
597                 ifname,
598                 print_ssid(iw, ifname));
599         printf("          Access Point: %s\n",
600                 print_bssid(iw, ifname));
601         printf("          Mode: %s  Channel: %s (%s)\n",
602                 print_mode(iw, ifname),
603                 print_channel(iw, ifname),
604                 print_frequency(iw, ifname));
605         if (iw->center_chan1 != NULL) {
606                 printf("          Center Channel 1: %s",
607                         print_center_chan1(iw, ifname));
608                 printf(" 2: %s\n", print_center_chan2(iw, ifname));
609         }
610         printf("          Tx-Power: %s  Link Quality: %s/%s\n",
611                 print_txpower(iw, ifname),
612                 print_quality(iw, ifname),
613                 print_quality_max(iw, ifname));
614         printf("          Signal: %s  Noise: %s\n",
615                 print_signal(iw, ifname),
616                 print_noise(iw, ifname));
617         printf("          Bit Rate: %s\n",
618                 print_rate(iw, ifname));
619         printf("          Encryption: %s\n",
620                 print_encryption(iw, ifname));
621         printf("          Type: %s  HW Mode(s): %s\n",
622                 print_type(iw, ifname),
623                 print_hwmodes(iw, ifname));
624         printf("          Hardware: %s [%s]\n",
625                 print_hardware_id(iw, ifname),
626                 print_hardware_name(iw, ifname));
627         printf("          TX power offset: %s\n",
628                 print_txpower_offset(iw, ifname));
629         printf("          Frequency offset: %s\n",
630                 print_frequency_offset(iw, ifname));
631         printf("          Supports VAPs: %s  PHY name: %s\n",
632                 print_mbssid_supp(iw, ifname),
633                 print_phyname(iw, ifname));
634 }
635 
636 
637 static void print_scanlist(const struct iwinfo_ops *iw, const char *ifname)
638 {
639         int i, x, len;
640         char buf[IWINFO_BUFSIZE];
641         struct iwinfo_scanlist_entry *e;
642 
643         if (iw->scanlist(ifname, buf, &len))
644         {
645                 printf("Scanning not possible\n\n");
646                 return;
647         }
648         else if (len <= 0)
649         {
650                 printf("No scan results\n\n");
651                 return;
652         }
653 
654         for (i = 0, x = 1; i < len; i += sizeof(struct iwinfo_scanlist_entry), x++)
655         {
656                 e = (struct iwinfo_scanlist_entry *) &buf[i];
657 
658                 printf("Cell %02d - Address: %s\n",
659                         x,
660                         format_bssid(e->mac));
661                 printf("          ESSID: %s\n",
662                         format_ssid(e->ssid));
663                 printf("          Mode: %s  Channel: %s\n",
664                         IWINFO_OPMODE_NAMES[e->mode],
665                         format_channel(e->channel));
666                 printf("          Signal: %s  Quality: %s/%s\n",
667                         format_signal(e->signal - 0x100),
668                         format_quality(e->quality),
669                         format_quality_max(e->quality_max));
670                 printf("          Encryption: %s\n",
671                         format_encryption(&e->crypto));
672                 printf("          HT Operation:\n");
673                 printf("                    Primary Channel: %d\n",
674                         e->ht_chan_info.primary_chan);
675                 printf("                    Secondary Channel Offset: %s\n",
676                         ht_secondary_offset[e->ht_chan_info.secondary_chan_off]);
677                 printf("                    Channel Width: %s\n",
678                         format_chan_width(e->ht_chan_info.chan_width));
679 
680                 if (e->vht_chan_info.center_chan_1) {
681                         printf("          VHT Operation:\n");
682                         printf("                    Channel Width: %s\n",
683                                 format_chan_width(e->vht_chan_info.chan_width));
684                         printf("                    Center Frequency 1: %d\n",
685                                  e->vht_chan_info.center_chan_1);
686                         printf("                    Center Frequency 2: %d\n",
687                                  e->vht_chan_info.center_chan_2);
688                 }
689 
690                 printf("\n");
691         }
692 }
693 
694 
695 static void print_txpwrlist(const struct iwinfo_ops *iw, const char *ifname)
696 {
697         int len, pwr, off, i;
698         char buf[IWINFO_BUFSIZE];
699         struct iwinfo_txpwrlist_entry *e;
700 
701         if (iw->txpwrlist(ifname, buf, &len) || len <= 0)
702         {
703                 printf("No TX power information available\n");
704                 return;
705         }
706 
707         if (iw->txpower(ifname, &pwr))
708                 pwr = -1;
709 
710         if (iw->txpower_offset(ifname, &off))
711                 off = 0;
712 
713         for (i = 0; i < len; i += sizeof(struct iwinfo_txpwrlist_entry))
714         {
715                 e = (struct iwinfo_txpwrlist_entry *) &buf[i];
716 
717                 printf("%s%3d dBm (%4d mW)\n",
718                         (pwr == e->dbm) ? "*" : " ",
719                         e->dbm + off,
720                         iwinfo_dbm2mw(e->dbm + off));
721         }
722 }
723 
724 
725 static void print_freqlist(const struct iwinfo_ops *iw, const char *ifname)
726 {
727         int i, len, ch;
728         char buf[IWINFO_BUFSIZE];
729         struct iwinfo_freqlist_entry *e;
730 
731         if (iw->freqlist(ifname, buf, &len) || len <= 0)
732         {
733                 printf("No frequency information available\n");
734                 return;
735         }
736 
737         if (iw->channel(ifname, &ch))
738                 ch = -1;
739 
740         for (i = 0; i < len; i += sizeof(struct iwinfo_freqlist_entry))
741         {
742                 e = (struct iwinfo_freqlist_entry *) &buf[i];
743 
744                 printf("%s %s (Channel %s)%s\n",
745                         (ch == e->channel) ? "*" : " ",
746                         format_frequency(e->mhz),
747                         format_channel(e->channel),
748                         e->restricted ? " [restricted]" : "");
749         }
750 }
751 
752 
753 static void print_assoclist(const struct iwinfo_ops *iw, const char *ifname)
754 {
755         int i, len;
756         char buf[IWINFO_BUFSIZE];
757         struct iwinfo_assoclist_entry *e;
758 
759         if (iw->assoclist(ifname, buf, &len))
760         {
761                 printf("No information available\n");
762                 return;
763         }
764         else if (len <= 0)
765         {
766                 printf("No station connected\n");
767                 return;
768         }
769 
770         for (i = 0; i < len; i += sizeof(struct iwinfo_assoclist_entry))
771         {
772                 e = (struct iwinfo_assoclist_entry *) &buf[i];
773 
774                 printf("%s  %s / %s (SNR %d)  %d ms ago\n",
775                         format_bssid(e->mac),
776                         format_signal(e->signal),
777                         format_noise(e->noise),
778                         (e->signal - e->noise),
779                         e->inactive);
780 
781                 printf("        RX: %-38s  %8d Pkts.\n",
782                         format_assocrate(&e->rx_rate),
783                         e->rx_packets
784                 );
785 
786                 printf("        TX: %-38s  %8d Pkts.\n",
787                         format_assocrate(&e->tx_rate),
788                         e->tx_packets
789                 );
790 
791                 printf("        expected throughput: %s\n\n",
792                         format_rate(e->thr));
793         }
794 }
795 
796 
797 static char * lookup_country(char *buf, int len, int iso3166)
798 {
799         int i;
800         struct iwinfo_country_entry *c;
801 
802         for (i = 0; i < len; i += sizeof(struct iwinfo_country_entry))
803         {
804                 c = (struct iwinfo_country_entry *) &buf[i];
805 
806                 if (c->iso3166 == iso3166)
807                         return c->ccode;
808         }
809 
810         return NULL;
811 }
812 
813 static void print_countrylist(const struct iwinfo_ops *iw, const char *ifname)
814 {
815         int len;
816         char buf[IWINFO_BUFSIZE];
817         char *ccode;
818         char curcode[3];
819         const struct iwinfo_iso3166_label *l;
820 
821         if (iw->countrylist(ifname, buf, &len))
822         {
823                 printf("No country code information available\n");
824                 return;
825         }
826 
827         if (iw->country(ifname, curcode))
828                 memset(curcode, 0, sizeof(curcode));
829 
830         for (l = IWINFO_ISO3166_NAMES; l->iso3166; l++)
831         {
832                 if ((ccode = lookup_country(buf, len, l->iso3166)) != NULL)
833                 {
834                         printf("%s %4s  %c%c\n",
835                                 strncmp(ccode, curcode, 2) ? " " : "*",
836                                 ccode, (l->iso3166 / 256), (l->iso3166 % 256));
837                 }
838         }
839 }
840 
841 static void print_htmodelist(const struct iwinfo_ops *iw, const char *ifname)
842 {
843         int i, htmodes = 0;
844 
845         if (iw->htmodelist(ifname, &htmodes))
846         {
847                 printf("No HT mode information available\n");
848                 return;
849         }
850 
851         for (i = 0; i < ARRAY_SIZE(IWINFO_HTMODE_NAMES); i++)
852                 if (htmodes & (1 << i))
853                         printf("%s ", IWINFO_HTMODE_NAMES[i]);
854 
855         printf("\n");
856 }
857 
858 static void lookup_phy(const struct iwinfo_ops *iw, const char *section)
859 {
860         char buf[IWINFO_BUFSIZE];
861 
862         if (!iw->lookup_phy)
863         {
864                 fprintf(stderr, "Not supported\n");
865                 return;
866         }
867 
868         if (iw->lookup_phy(section, buf))
869         {
870                 fprintf(stderr, "Phy not found\n");
871                 return;
872         }
873 
874         printf("%s\n", buf);
875 }
876 
877 
878 int main(int argc, char **argv)
879 {
880         int i, rv = 0;
881         char *p;
882         const struct iwinfo_ops *iw;
883         glob_t globbuf;
884 
885         if (argc > 1 && argc < 3)
886         {
887                 fprintf(stderr,
888                         "Usage:\n"
889                         "       iwinfo <device> info\n"
890                         "       iwinfo <device> scan\n"
891                         "       iwinfo <device> txpowerlist\n"
892                         "       iwinfo <device> freqlist\n"
893                         "       iwinfo <device> assoclist\n"
894                         "       iwinfo <device> countrylist\n"
895                         "       iwinfo <device> htmodelist\n"
896                         "       iwinfo <backend> phyname <section>\n"
897                 );
898 
899                 return 1;
900         }
901 
902         if (argc == 1)
903         {
904                 glob("/sys/class/net/*", 0, NULL, &globbuf);
905 
906                 for (i = 0; i < globbuf.gl_pathc; i++)
907                 {
908                         p = strrchr(globbuf.gl_pathv[i], '/');
909 
910                         if (!p)
911                                 continue;
912 
913                         iw = iwinfo_backend(++p);
914 
915                         if (!iw)
916                                 continue;
917 
918                         print_info(iw, p);
919                         printf("\n");
920                 }
921 
922                 globfree(&globbuf);
923                 return 0;
924         }
925 
926         if (argc > 3)
927         {
928                 iw = iwinfo_backend_by_name(argv[1]);
929 
930                 if (!iw)
931                 {
932                         fprintf(stderr, "No such wireless backend: %s\n", argv[1]);
933                         rv = 1;
934                 }
935                 else
936                 {
937                         switch (argv[2][0])
938                         {
939                         case 'p':
940                                 lookup_phy(iw, argv[3]);
941                                 break;
942 
943                         default:
944                                 fprintf(stderr, "Unknown command: %s\n", argv[2]);
945                                 rv = 1;
946                         }
947                 }
948         }
949         else
950         {
951                 iw = iwinfo_backend(argv[1]);
952 
953                 if (!iw)
954                 {
955                         fprintf(stderr, "No such wireless device: %s\n", argv[1]);
956                         rv = 1;
957                 }
958                 else
959                 {
960                         for (i = 2; i < argc; i++)
961                         {
962                                 switch(argv[i][0])
963                                 {
964                                 case 'i':
965                                         print_info(iw, argv[1]);
966                                         break;
967 
968                                 case 's':
969                                         print_scanlist(iw, argv[1]);
970                                         break;
971 
972                                 case 't':
973                                         print_txpwrlist(iw, argv[1]);
974                                         break;
975 
976                                 case 'f':
977                                         print_freqlist(iw, argv[1]);
978                                         break;
979 
980                                 case 'a':
981                                         print_assoclist(iw, argv[1]);
982                                         break;
983 
984                                 case 'c':
985                                         print_countrylist(iw, argv[1]);
986                                         break;
987 
988                                 case 'h':
989                                         print_htmodelist(iw, argv[1]);
990                                         break;
991 
992                                 default:
993                                         fprintf(stderr, "Unknown command: %s\n", argv[i]);
994                                         rv = 1;
995                                 }
996                         }
997                 }
998         }
999 
1000         iwinfo_finish();
1001 
1002         return rv;
1003 }
1004 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt