Root/package/network/utils/iwinfo/src/iwinfo_madwifi.c

1/*
2 * iwinfo - Wireless Information Library - Madwifi Backend
3 *
4 * Copyright (C) 2009-2010 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 * The signal handling code is derived from the official madwifi tools,
19 * wlanconfig.c in particular. The encryption property handling was
20 * inspired by the hostapd madwifi driver.
21 */
22
23#include "iwinfo/madwifi.h"
24#include "iwinfo/wext.h"
25
26
27/*
28 * Madwifi ISO 3166 to Country/Region Code mapping.
29 */
30
31static struct ISO3166_to_CCode
32{
33    u_int16_t iso3166;
34    u_int16_t ccode;
35} CountryCodes[] = {
36    { 0x3030 /* 00 */, 0 }, /* World */
37    { 0x4145 /* AE */, 784 }, /* U.A.E. */
38    { 0x414C /* AL */, 8 }, /* Albania */
39    { 0x414D /* AM */, 51 }, /* Armenia */
40    { 0x4152 /* AR */, 32 }, /* Argentina */
41    { 0x4154 /* AT */, 40 }, /* Austria */
42    { 0x4155 /* AU */, 36 }, /* Australia */
43    { 0x415A /* AZ */, 31 }, /* Azerbaijan */
44    { 0x4245 /* BE */, 56 }, /* Belgium */
45    { 0x4247 /* BG */, 100 }, /* Bulgaria */
46    { 0x4248 /* BH */, 48 }, /* Bahrain */
47    { 0x424E /* BN */, 96 }, /* Brunei Darussalam */
48    { 0x424F /* BO */, 68 }, /* Bolivia */
49    { 0x4252 /* BR */, 76 }, /* Brazil */
50    { 0x4259 /* BY */, 112 }, /* Belarus */
51    { 0x425A /* BZ */, 84 }, /* Belize */
52    { 0x4341 /* CA */, 124 }, /* Canada */
53    { 0x4348 /* CH */, 756 }, /* Switzerland */
54    { 0x434C /* CL */, 152 }, /* Chile */
55    { 0x434E /* CN */, 156 }, /* People's Republic of China */
56    { 0x434F /* CO */, 170 }, /* Colombia */
57    { 0x4352 /* CR */, 188 }, /* Costa Rica */
58    { 0x4359 /* CY */, 196 }, /* Cyprus */
59    { 0x435A /* CZ */, 203 }, /* Czech Republic */
60    { 0x4445 /* DE */, 276 }, /* Germany */
61    { 0x444B /* DK */, 208 }, /* Denmark */
62    { 0x444F /* DO */, 214 }, /* Dominican Republic */
63    { 0x445A /* DZ */, 12 }, /* Algeria */
64    { 0x4543 /* EC */, 218 }, /* Ecuador */
65    { 0x4545 /* EE */, 233 }, /* Estonia */
66    { 0x4547 /* EG */, 818 }, /* Egypt */
67    { 0x4553 /* ES */, 724 }, /* Spain */
68    { 0x4649 /* FI */, 246 }, /* Finland */
69    { 0x464F /* FO */, 234 }, /* Faeroe Islands */
70    { 0x4652 /* FR */, 250 }, /* France */
71    { 0x4652 /* FR */, 255 }, /* France2 */
72    { 0x4742 /* GB */, 826 }, /* United Kingdom */
73    { 0x4745 /* GE */, 268 }, /* Georgia */
74    { 0x4752 /* GR */, 300 }, /* Greece */
75    { 0x4754 /* GT */, 320 }, /* Guatemala */
76    { 0x484B /* HK */, 344 }, /* Hong Kong S.A.R., P.R.C. */
77    { 0x484E /* HN */, 340 }, /* Honduras */
78    { 0x4852 /* HR */, 191 }, /* Croatia */
79    { 0x4855 /* HU */, 348 }, /* Hungary */
80    { 0x4944 /* ID */, 360 }, /* Indonesia */
81    { 0x4945 /* IE */, 372 }, /* Ireland */
82    { 0x494C /* IL */, 376 }, /* Israel */
83    { 0x494E /* IN */, 356 }, /* India */
84    { 0x4951 /* IQ */, 368 }, /* Iraq */
85    { 0x4952 /* IR */, 364 }, /* Iran */
86    { 0x4953 /* IS */, 352 }, /* Iceland */
87    { 0x4954 /* IT */, 380 }, /* Italy */
88    { 0x4A4D /* JM */, 388 }, /* Jamaica */
89    { 0x4A4F /* JO */, 400 }, /* Jordan */
90    { 0x4A50 /* JP */, 392 }, /* Japan */
91    { 0x4A50 /* JP */, 393 }, /* Japan (JP1) */
92    { 0x4A50 /* JP */, 394 }, /* Japan (JP0) */
93    { 0x4A50 /* JP */, 395 }, /* Japan (JP1-1) */
94    { 0x4A50 /* JP */, 396 }, /* Japan (JE1) */
95    { 0x4A50 /* JP */, 397 }, /* Japan (JE2) */
96    { 0x4A50 /* JP */, 399 }, /* Japan (JP6) */
97    { 0x4A50 /* JP */, 900 }, /* Japan */
98    { 0x4A50 /* JP */, 901 }, /* Japan */
99    { 0x4A50 /* JP */, 902 }, /* Japan */
100    { 0x4A50 /* JP */, 903 }, /* Japan */
101    { 0x4A50 /* JP */, 904 }, /* Japan */
102    { 0x4A50 /* JP */, 905 }, /* Japan */
103    { 0x4A50 /* JP */, 906 }, /* Japan */
104    { 0x4A50 /* JP */, 907 }, /* Japan */
105    { 0x4A50 /* JP */, 908 }, /* Japan */
106    { 0x4A50 /* JP */, 909 }, /* Japan */
107    { 0x4A50 /* JP */, 910 }, /* Japan */
108    { 0x4A50 /* JP */, 911 }, /* Japan */
109    { 0x4A50 /* JP */, 912 }, /* Japan */
110    { 0x4A50 /* JP */, 913 }, /* Japan */
111    { 0x4A50 /* JP */, 914 }, /* Japan */
112    { 0x4A50 /* JP */, 915 }, /* Japan */
113    { 0x4A50 /* JP */, 916 }, /* Japan */
114    { 0x4A50 /* JP */, 917 }, /* Japan */
115    { 0x4A50 /* JP */, 918 }, /* Japan */
116    { 0x4A50 /* JP */, 919 }, /* Japan */
117    { 0x4A50 /* JP */, 920 }, /* Japan */
118    { 0x4A50 /* JP */, 921 }, /* Japan */
119    { 0x4A50 /* JP */, 922 }, /* Japan */
120    { 0x4A50 /* JP */, 923 }, /* Japan */
121    { 0x4A50 /* JP */, 924 }, /* Japan */
122    { 0x4A50 /* JP */, 925 }, /* Japan */
123    { 0x4A50 /* JP */, 926 }, /* Japan */
124    { 0x4A50 /* JP */, 927 }, /* Japan */
125    { 0x4A50 /* JP */, 928 }, /* Japan */
126    { 0x4A50 /* JP */, 929 }, /* Japan */
127    { 0x4A50 /* JP */, 930 }, /* Japan */
128    { 0x4A50 /* JP */, 931 }, /* Japan */
129    { 0x4A50 /* JP */, 932 }, /* Japan */
130    { 0x4A50 /* JP */, 933 }, /* Japan */
131    { 0x4A50 /* JP */, 934 }, /* Japan */
132    { 0x4A50 /* JP */, 935 }, /* Japan */
133    { 0x4A50 /* JP */, 936 }, /* Japan */
134    { 0x4A50 /* JP */, 937 }, /* Japan */
135    { 0x4A50 /* JP */, 938 }, /* Japan */
136    { 0x4A50 /* JP */, 939 }, /* Japan */
137    { 0x4A50 /* JP */, 940 }, /* Japan */
138    { 0x4A50 /* JP */, 941 }, /* Japan */
139    { 0x4B45 /* KE */, 404 }, /* Kenya */
140    { 0x4B50 /* KP */, 408 }, /* North Korea */
141    { 0x4B52 /* KR */, 410 }, /* South Korea */
142    { 0x4B52 /* KR */, 411 }, /* South Korea */
143    { 0x4B57 /* KW */, 414 }, /* Kuwait */
144    { 0x4B5A /* KZ */, 398 }, /* Kazakhstan */
145    { 0x4C42 /* LB */, 422 }, /* Lebanon */
146    { 0x4C49 /* LI */, 438 }, /* Liechtenstein */
147    { 0x4C54 /* LT */, 440 }, /* Lithuania */
148    { 0x4C55 /* LU */, 442 }, /* Luxembourg */
149    { 0x4C56 /* LV */, 428 }, /* Latvia */
150    { 0x4C59 /* LY */, 434 }, /* Libya */
151    { 0x4D41 /* MA */, 504 }, /* Morocco */
152    { 0x4D43 /* MC */, 492 }, /* Principality of Monaco */
153    { 0x4D4B /* MK */, 807 }, /* the Former Yugoslav Republic of Macedonia */
154    { 0x4D4F /* MO */, 446 }, /* Macau */
155    { 0x4D58 /* MX */, 484 }, /* Mexico */
156    { 0x4D59 /* MY */, 458 }, /* Malaysia */
157    { 0x4E49 /* NI */, 558 }, /* Nicaragua */
158    { 0x4E4C /* NL */, 528 }, /* Netherlands */
159    { 0x4E4F /* NO */, 578 }, /* Norway */
160    { 0x4E5A /* NZ */, 554 }, /* New Zealand */
161    { 0x4F4D /* OM */, 512 }, /* Oman */
162    { 0x5041 /* PA */, 591 }, /* Panama */
163    { 0x5045 /* PE */, 604 }, /* Peru */
164    { 0x5048 /* PH */, 608 }, /* Republic of the Philippines */
165    { 0x504B /* PK */, 586 }, /* Islamic Republic of Pakistan */
166    { 0x504C /* PL */, 616 }, /* Poland */
167    { 0x5052 /* PR */, 630 }, /* Puerto Rico */
168    { 0x5054 /* PT */, 620 }, /* Portugal */
169    { 0x5059 /* PY */, 600 }, /* Paraguay */
170    { 0x5141 /* QA */, 634 }, /* Qatar */
171    { 0x524F /* RO */, 642 }, /* Romania */
172    { 0x5255 /* RU */, 643 }, /* Russia */
173    { 0x5341 /* SA */, 682 }, /* Saudi Arabia */
174    { 0x5345 /* SE */, 752 }, /* Sweden */
175    { 0x5347 /* SG */, 702 }, /* Singapore */
176    { 0x5349 /* SI */, 705 }, /* Slovenia */
177    { 0x534B /* SK */, 703 }, /* Slovak Republic */
178    { 0x5356 /* SV */, 222 }, /* El Salvador */
179    { 0x5359 /* SY */, 760 }, /* Syria */
180    { 0x5448 /* TH */, 764 }, /* Thailand */
181    { 0x544E /* TN */, 788 }, /* Tunisia */
182    { 0x5452 /* TR */, 792 }, /* Turkey */
183    { 0x5454 /* TT */, 780 }, /* Trinidad y Tobago */
184    { 0x5457 /* TW */, 158 }, /* Taiwan */
185    { 0x5541 /* UA */, 804 }, /* Ukraine */
186    { 0x554B /* UK */, 826 }, /* United Kingdom */
187    { 0x5553 /* US */, 840 }, /* United States */
188    { 0x5553 /* US */, 842 }, /* United States (Public Safety)*/
189    { 0x5559 /* UY */, 858 }, /* Uruguay */
190    { 0x555A /* UZ */, 860 }, /* Uzbekistan */
191    { 0x5645 /* VE */, 862 }, /* Venezuela */
192    { 0x564E /* VN */, 704 }, /* Viet Nam */
193    { 0x5945 /* YE */, 887 }, /* Yemen */
194    { 0x5A41 /* ZA */, 710 }, /* South Africa */
195    { 0x5A57 /* ZW */, 716 }, /* Zimbabwe */
196};
197
198
199static const char * madwifi_phyname(const char *ifname)
200{
201    static char phyname[IFNAMSIZ];
202
203    if (strlen(ifname) > 5 && !strncmp(ifname, "radio", 5))
204        snprintf(phyname, sizeof(phyname), "wifi%s", ifname + 5);
205    else
206        snprintf(phyname, sizeof(phyname), "%s", ifname);
207
208    return (const char *)phyname;
209}
210
211static int madwifi_wrq(struct iwreq *wrq, const char *ifname, int cmd, void *data, size_t len)
212{
213    strncpy(wrq->ifr_name, ifname, IFNAMSIZ);
214
215    if( data != NULL )
216    {
217        if( len < IFNAMSIZ )
218        {
219            memcpy(wrq->u.name, data, len);
220        }
221        else
222        {
223            wrq->u.data.pointer = data;
224            wrq->u.data.length = len;
225        }
226    }
227
228    return iwinfo_ioctl(cmd, wrq);
229}
230
231static int get80211priv(const char *ifname, int op, void *data, size_t len)
232{
233    struct iwreq iwr;
234
235    if( madwifi_wrq(&iwr, ifname, op, data, len) < 0 )
236        return -1;
237
238    return iwr.u.data.length;
239}
240
241static char * madwifi_isvap(const char *ifname, const char *wifiname)
242{
243    int fd, ln;
244    char path[32];
245    char *ret = NULL;
246    static char name[IFNAMSIZ];
247
248    if( strlen(ifname) <= 9 )
249    {
250        sprintf(path, "/proc/sys/net/%s/%%parent", ifname);
251
252        if( (fd = open(path, O_RDONLY)) > -1 )
253        {
254            if( wifiname != NULL )
255            {
256                if( read(fd, name, strlen(wifiname)) == strlen(wifiname) )
257                    ret = strncmp(name, wifiname, strlen(wifiname))
258                        ? NULL : name;
259            }
260            else if( (ln = read(fd, name, IFNAMSIZ)) >= 4 )
261            {
262                name[ln-1] = 0;
263                ret = name;
264            }
265
266            (void) close(fd);
267        }
268    }
269
270    return ret;
271}
272
273static int madwifi_iswifi(const char *ifname)
274{
275    int ret;
276    char path[32];
277    struct stat s;
278    const char *phy;
279
280    ret = 0;
281    phy = madwifi_phyname(ifname);
282
283    if( strlen(phy) <= 7 )
284    {
285        sprintf(path, "/proc/sys/dev/%s/diversity", phy);
286
287        if( ! stat(path, &s) )
288            ret = (s.st_mode & S_IFREG);
289    }
290
291    return ret;
292}
293
294static char * madwifi_ifadd(const char *ifname)
295{
296    const char *wifidev = NULL;
297    struct ifreq ifr = { 0 };
298    struct ieee80211_clone_params cp = { 0 };
299    static char nif[IFNAMSIZ] = { 0 };
300
301    if( !(wifidev = madwifi_isvap(ifname, NULL)) && madwifi_iswifi(ifname) )
302        wifidev = madwifi_phyname(ifname);
303
304    if( wifidev )
305    {
306        snprintf(nif, sizeof(nif), "tmp.%s", ifname);
307
308        strncpy(cp.icp_name, nif, IFNAMSIZ);
309        cp.icp_opmode = IEEE80211_M_STA;
310        cp.icp_flags = IEEE80211_CLONE_BSSID;
311
312        strncpy(ifr.ifr_name, wifidev, IFNAMSIZ);
313        ifr.ifr_data = (void *)&cp;
314
315        if( !iwinfo_ioctl(SIOC80211IFCREATE, &ifr) )
316        {
317            return nif;
318        }
319        else
320        {
321            cp.icp_opmode = IEEE80211_M_MONITOR;
322
323            if( !iwinfo_ioctl(SIOC80211IFCREATE, &ifr) )
324                return nif;
325        }
326    }
327
328    return NULL;
329}
330
331static void madwifi_ifdel(const char *ifname)
332{
333    struct ifreq ifr = { 0 };
334
335    strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
336    iwinfo_ioctl(SIOC80211IFDESTROY, &ifr);
337}
338
339
340int madwifi_probe(const char *ifname)
341{
342    return ( !!madwifi_isvap(ifname, NULL) || madwifi_iswifi(ifname) );
343}
344
345void madwifi_close(void)
346{
347    /* Nop */
348}
349
350int madwifi_get_mode(const char *ifname, int *buf)
351{
352    return wext_get_mode(ifname, buf);
353}
354
355int madwifi_get_ssid(const char *ifname, char *buf)
356{
357    return wext_get_ssid(ifname, buf);
358}
359
360int madwifi_get_bssid(const char *ifname, char *buf)
361{
362    return wext_get_bssid(ifname, buf);
363}
364
365int madwifi_get_channel(const char *ifname, int *buf)
366{
367    int i;
368    uint16_t freq;
369    struct iwreq wrq;
370    struct ieee80211req_chaninfo chans;
371
372    if( madwifi_wrq(&wrq, ifname, SIOCGIWFREQ, NULL, 0) >= 0 )
373    {
374        /* Madwifi returns a Hz frequency, get it's freq list to find channel index */
375        freq = (uint16_t)(wrq.u.freq.m / 100000);
376
377        if( get80211priv(ifname, IEEE80211_IOCTL_GETCHANINFO, &chans, sizeof(chans)) >= 0 )
378        {
379            *buf = 0;
380
381            for( i = 0; i < chans.ic_nchans; i++ )
382            {
383                if( freq == chans.ic_chans[i].ic_freq )
384                {
385                    *buf = chans.ic_chans[i].ic_ieee;
386                    break;
387                }
388            }
389
390            return 0;
391        }
392    }
393
394    return -1;
395}
396
397int madwifi_get_frequency(const char *ifname, int *buf)
398{
399    struct iwreq wrq;
400
401    if( madwifi_wrq(&wrq, ifname, SIOCGIWFREQ, NULL, 0) >= 0 )
402    {
403        *buf = (uint16_t)(wrq.u.freq.m / 100000);
404        return 0;
405    }
406
407    return -1;
408}
409
410int madwifi_get_txpower(const char *ifname, int *buf)
411{
412    return wext_get_txpower(ifname, buf);
413}
414
415int madwifi_get_bitrate(const char *ifname, int *buf)
416{
417    unsigned int mode, len, rate, rate_count;
418    uint8_t tmp[24*1024];
419    uint8_t *cp;
420    struct iwreq wrq;
421    struct ieee80211req_sta_info *si;
422
423    if( madwifi_wrq(&wrq, ifname, SIOCGIWMODE, NULL, 0) >= 0 )
424    {
425        mode = wrq.u.mode;
426
427        /* Calculate bitrate average from associated stations in ad-hoc mode */
428        if( mode == 1 )
429        {
430            rate = rate_count = 0;
431
432            if( (len = get80211priv(ifname, IEEE80211_IOCTL_STA_INFO, tmp, 24*1024)) > 0 )
433            {
434                cp = tmp;
435
436                do {
437                    si = (struct ieee80211req_sta_info *) cp;
438
439                    if( si->isi_rssi > 0 )
440                    {
441                        rate_count++;
442                        rate += ((si->isi_rates[si->isi_txrate] & IEEE80211_RATE_VAL) / 2);
443                    }
444
445                    cp += si->isi_len;
446                    len -= si->isi_len;
447                } while (len >= sizeof(struct ieee80211req_sta_info));
448            }
449
450            *buf = (rate == 0 || rate_count == 0) ? 0 : (rate / rate_count) * 1000;
451            return 0;
452        }
453
454        /* Return whatever wext tells us ... */
455        return wext_get_bitrate(ifname, buf);
456    }
457
458    return -1;
459}
460
461int madwifi_get_signal(const char *ifname, int *buf)
462{
463    unsigned int mode, len, rssi, rssi_count;
464    uint8_t tmp[24*1024];
465    uint8_t *cp;
466    struct iwreq wrq;
467    struct ieee80211req_sta_info *si;
468
469    if( madwifi_wrq(&wrq, ifname, SIOCGIWMODE, NULL, 0) >= 0 )
470    {
471        mode = wrq.u.mode;
472
473        /* Calculate signal average from associated stations in ap or ad-hoc mode */
474        if( mode == 1 )
475        {
476            rssi = rssi_count = 0;
477
478            if( (len = get80211priv(ifname, IEEE80211_IOCTL_STA_INFO, tmp, 24*1024)) > 0 )
479            {
480                cp = tmp;
481
482                do {
483                    si = (struct ieee80211req_sta_info *) cp;
484
485                    if( si->isi_rssi > 0 )
486                    {
487                        rssi_count++;
488                        rssi -= (si->isi_rssi - 95);
489                    }
490
491                    cp += si->isi_len;
492                    len -= si->isi_len;
493                } while (len >= sizeof(struct ieee80211req_sta_info));
494            }
495
496            *buf = (rssi == 0 || rssi_count == 0) ? 1 : -(rssi / rssi_count);
497            return 0;
498        }
499
500        /* Return whatever wext tells us ... */
501        return wext_get_signal(ifname, buf);
502    }
503
504    return -1;
505}
506
507int madwifi_get_noise(const char *ifname, int *buf)
508{
509    return wext_get_noise(ifname, buf);
510}
511
512int madwifi_get_quality(const char *ifname, int *buf)
513{
514    unsigned int mode, len, quality, quality_count;
515    uint8_t tmp[24*1024];
516    uint8_t *cp;
517    struct iwreq wrq;
518    struct ieee80211req_sta_info *si;
519
520    if( madwifi_wrq(&wrq, ifname, SIOCGIWMODE, NULL, 0) >= 0 )
521    {
522        mode = wrq.u.mode;
523
524        /* Calculate signal average from associated stations in ad-hoc mode */
525        if( mode == 1 )
526        {
527            quality = quality_count = 0;
528
529            if( (len = get80211priv(ifname, IEEE80211_IOCTL_STA_INFO, tmp, 24*1024)) > 0 )
530            {
531                cp = tmp;
532
533                do {
534                    si = (struct ieee80211req_sta_info *) cp;
535
536                    if( si->isi_rssi > 0 )
537                    {
538                        quality_count++;
539                        quality += si->isi_rssi;
540                    }
541
542                    cp += si->isi_len;
543                    len -= si->isi_len;
544                } while (len >= sizeof(struct ieee80211req_sta_info));
545            }
546
547            *buf = (quality == 0 || quality_count == 0) ? 0 : (quality / quality_count);
548            return 0;
549        }
550
551        /* Return whatever wext tells us ... */
552        return wext_get_quality(ifname, buf);
553    }
554
555    return -1;
556}
557
558int madwifi_get_quality_max(const char *ifname, int *buf)
559{
560    return wext_get_quality_max(ifname, buf);
561}
562
563int madwifi_get_encryption(const char *ifname, char *buf)
564{
565    int ciphers = 0, key_len = 0;
566    char keybuf[IW_ENCODING_TOKEN_MAX];
567    struct iwinfo_crypto_entry *c = (struct iwinfo_crypto_entry *)buf;
568    struct iwreq wrq;
569    struct ieee80211req_key wk;
570
571    memset(&wrq, 0, sizeof(wrq));
572
573    /* Obtain key info */
574    if( madwifi_wrq(&wrq, ifname, SIOCGIWENCODE, keybuf, sizeof(keybuf)) < 0 )
575        return -1;
576
577#if 0
578    /* Have any encryption? */
579    if( (wrq.u.data.flags & IW_ENCODE_DISABLED) || (wrq.u.data.length == 0) )
580        return 0;
581#endif
582
583    /* Save key len */
584    key_len = wrq.u.data.length;
585
586    /* Get wpa protocol version */
587    wrq.u.mode = IEEE80211_PARAM_WPA;
588    if( madwifi_wrq(&wrq, ifname, IEEE80211_IOCTL_GETPARAM, NULL, 0) >= 0 )
589        c->wpa_version = wrq.u.mode;
590
591    /* Get authentication suites */
592    wrq.u.mode = IEEE80211_PARAM_AUTHMODE;
593    if( madwifi_wrq(&wrq, ifname, IEEE80211_IOCTL_GETPARAM, NULL, 0) >= 0 )
594    {
595        switch(wrq.u.mode) {
596            case IEEE80211_AUTH_8021X:
597                c->auth_suites |= IWINFO_KMGMT_8021x;
598                break;
599
600            case IEEE80211_AUTH_WPA:
601                c->auth_suites |= IWINFO_KMGMT_PSK;
602                break;
603
604            case IEEE80211_AUTH_OPEN:
605                c->auth_algs |= IWINFO_AUTH_OPEN;
606                break;
607
608            case IEEE80211_AUTH_SHARED:
609                c->auth_algs |= IWINFO_AUTH_SHARED;
610                break;
611
612            default:
613                c->auth_suites |= IWINFO_KMGMT_NONE;
614                break;
615        }
616    }
617
618    memset(&wk, 0, sizeof(wk));
619    memset(wk.ik_macaddr, 0xff, IEEE80211_ADDR_LEN);
620
621    /* Get key information */
622    if( get80211priv(ifname, IEEE80211_IOCTL_GETKEY, &wk, sizeof(wk)) >= 0 )
623    {
624        /* Type 0 == WEP */
625        if( (wk.ik_type == 0) && (c->auth_algs == 0) )
626            c->auth_algs = (IWINFO_AUTH_OPEN | IWINFO_AUTH_SHARED);
627    }
628
629    /* Get used pairwise ciphers */
630    wrq.u.mode = IEEE80211_PARAM_UCASTCIPHERS;
631    if( madwifi_wrq(&wrq, ifname, IEEE80211_IOCTL_GETPARAM, NULL, 0) >= 0 )
632    {
633        ciphers = wrq.u.mode;
634
635        if( c->wpa_version && ciphers & (1 << IEEE80211_CIPHER_TKIP) )
636            c->pair_ciphers |= IWINFO_CIPHER_TKIP;
637
638        if( c->wpa_version && ciphers & (1 << IEEE80211_CIPHER_AES_CCM) )
639            c->pair_ciphers |= IWINFO_CIPHER_CCMP;
640
641        if( c->wpa_version && ciphers & (1 << IEEE80211_CIPHER_AES_OCB) )
642            c->pair_ciphers |= IWINFO_CIPHER_AESOCB;
643
644        if( c->wpa_version && ciphers & (1 << IEEE80211_CIPHER_CKIP) )
645            c->pair_ciphers |= IWINFO_CIPHER_CKIP;
646
647        if( !c->pair_ciphers && ciphers & (1 << IEEE80211_CIPHER_WEP) )
648        {
649            switch(key_len) {
650                case 13:
651                    c->pair_ciphers |= IWINFO_CIPHER_WEP104;
652                    break;
653
654                case 5:
655                    c->pair_ciphers |= IWINFO_CIPHER_WEP40;
656                    break;
657
658                case 0:
659                    break;
660
661                default:
662                    c->pair_ciphers = IWINFO_CIPHER_WEP40 |
663                        IWINFO_CIPHER_WEP104;
664                    break;
665            }
666        }
667
668        if( ciphers & (1 << IEEE80211_CIPHER_NONE) )
669            c->pair_ciphers |= IWINFO_CIPHER_NONE;
670    }
671
672    /* Get used group cipher */
673    wrq.u.mode = IEEE80211_PARAM_MCASTCIPHER;
674    if( madwifi_wrq(&wrq, ifname, IEEE80211_IOCTL_GETPARAM, NULL, 0) >= 0 )
675    {
676        ciphers = c->wpa_version ? wrq.u.mode : IEEE80211_CIPHER_WEP;
677
678        switch(ciphers) {
679            case IEEE80211_CIPHER_TKIP:
680                c->group_ciphers |= IWINFO_CIPHER_TKIP;
681                break;
682
683            case IEEE80211_CIPHER_AES_CCM:
684                c->group_ciphers |= IWINFO_CIPHER_CCMP;
685                break;
686
687            case IEEE80211_CIPHER_AES_OCB:
688                c->group_ciphers |= IWINFO_CIPHER_AESOCB;
689                break;
690
691            case IEEE80211_CIPHER_CKIP:
692                c->group_ciphers |= IWINFO_CIPHER_CKIP;
693                break;
694
695            case IEEE80211_CIPHER_WEP:
696                switch(key_len) {
697                    case 13:
698                        c->group_ciphers |= IWINFO_CIPHER_WEP104;
699                        break;
700
701                    case 5:
702                        c->group_ciphers |= IWINFO_CIPHER_WEP40;
703                        break;
704
705                    default:
706                        break;
707                }
708                break;
709
710            case IEEE80211_CIPHER_NONE:
711                c->group_ciphers |= IWINFO_CIPHER_NONE;
712                break;
713
714            default:
715                break;
716        }
717    }
718
719    c->enabled = (c->wpa_version || (c->auth_algs && c->pair_ciphers)) ? 1 : 0;
720
721    return 0;
722}
723
724int madwifi_get_assoclist(const char *ifname, char *buf, int *len)
725{
726    int bl, tl, noise;
727    uint8_t *cp;
728    uint8_t tmp[24*1024];
729    struct ieee80211req_sta_info *si;
730    struct iwinfo_assoclist_entry entry;
731
732    if( (tl = get80211priv(ifname, IEEE80211_IOCTL_STA_INFO, tmp, 24*1024)) > 0 )
733    {
734        cp = tmp;
735        bl = 0;
736
737        if( madwifi_get_noise(ifname, &noise) )
738            noise = 0;
739
740        do {
741            si = (struct ieee80211req_sta_info *) cp;
742
743            memset(&entry, 0, sizeof(entry));
744
745            entry.signal = (si->isi_rssi - 95);
746            entry.noise = noise;
747            memcpy(entry.mac, &si->isi_macaddr, 6);
748
749            entry.inactive = si->isi_inact * 1000;
750
751            entry.tx_packets = (si->isi_txseqs[0] & IEEE80211_SEQ_SEQ_MASK)
752                >> IEEE80211_SEQ_SEQ_SHIFT;
753
754            entry.rx_packets = (si->isi_rxseqs[0] & IEEE80211_SEQ_SEQ_MASK)
755                >> IEEE80211_SEQ_SEQ_SHIFT;
756
757            entry.tx_rate.rate =
758                (si->isi_rates[si->isi_txrate] & IEEE80211_RATE_VAL) * 500;
759
760            /* XXX: this is just a guess */
761            entry.rx_rate.rate = entry.tx_rate.rate;
762
763            entry.rx_rate.mcs = -1;
764            entry.tx_rate.mcs = -1;
765
766            memcpy(&buf[bl], &entry, sizeof(struct iwinfo_assoclist_entry));
767
768            bl += sizeof(struct iwinfo_assoclist_entry);
769            cp += si->isi_len;
770            tl -= si->isi_len;
771        } while (tl >= sizeof(struct ieee80211req_sta_info));
772
773        *len = bl;
774        return 0;
775    }
776
777    return -1;
778}
779
780int madwifi_get_txpwrlist(const char *ifname, char *buf, int *len)
781{
782    int rc = -1;
783    char *res;
784
785    /* A wifiX device? */
786    if( madwifi_iswifi(ifname) )
787    {
788        if( (res = madwifi_ifadd(ifname)) != NULL )
789        {
790            rc = wext_get_txpwrlist(res, buf, len);
791            madwifi_ifdel(res);
792        }
793    }
794
795    /* Its an athX ... */
796    else if( !!madwifi_isvap(ifname, NULL) )
797    {
798        rc = wext_get_txpwrlist(ifname, buf, len);
799    }
800
801    return rc;
802}
803
804int madwifi_get_scanlist(const char *ifname, char *buf, int *len)
805{
806    int ret;
807    char *res;
808    DIR *proc;
809    struct dirent *e;
810
811    ret = -1;
812
813    /* We got a wifiX device passed, try to lookup a vap on it */
814    if( madwifi_iswifi(ifname) )
815    {
816        if( (proc = opendir("/proc/sys/net/")) != NULL )
817        {
818            while( (e = readdir(proc)) != NULL )
819            {
820                if( !!madwifi_isvap(e->d_name, ifname) )
821                {
822                    if( iwinfo_ifup(e->d_name) )
823                    {
824                        ret = wext_get_scanlist(e->d_name, buf, len);
825                        break;
826                    }
827                }
828            }
829
830            closedir(proc);
831        }
832
833        /* Still nothing found, try to create a vap */
834        if( ret == -1 )
835        {
836            if( (res = madwifi_ifadd(ifname)) != NULL )
837            {
838                if( iwinfo_ifup(res) )
839                {
840                    wext_get_scanlist(res, buf, len);
841                    sleep(1);
842
843                    wext_get_scanlist(res, buf, len);
844                    sleep(1);
845
846                    ret = wext_get_scanlist(res, buf, len);
847                }
848
849                iwinfo_ifdown(res);
850                madwifi_ifdel(res);
851            }
852        }
853    }
854
855    /* Got athX device? */
856    else if( !!madwifi_isvap(ifname, NULL) )
857    {
858        ret = wext_get_scanlist(ifname, buf, len);
859    }
860
861    return ret;
862}
863
864int madwifi_get_freqlist(const char *ifname, char *buf, int *len)
865{
866    int i, bl;
867    int rc = -1;
868    char *res;
869    struct ieee80211req_chaninfo chans;
870    struct iwinfo_freqlist_entry entry;
871
872    /* A wifiX device? */
873    if( madwifi_iswifi(ifname) )
874    {
875        if( (res = madwifi_ifadd(ifname)) != NULL )
876        {
877            rc = get80211priv(res, IEEE80211_IOCTL_GETCHANINFO,
878                              &chans, sizeof(chans));
879
880            madwifi_ifdel(res);
881        }
882    }
883
884    /* Its an athX ... */
885    else if( !!madwifi_isvap(ifname, NULL) )
886    {
887        rc = get80211priv(ifname, IEEE80211_IOCTL_GETCHANINFO,
888                          &chans, sizeof(chans));
889    }
890
891
892    /* Got chaninfo? */
893    if( rc >= 0 )
894    {
895        bl = 0;
896
897        for( i = 0; i < chans.ic_nchans; i++ )
898        {
899            entry.mhz = chans.ic_chans[i].ic_freq;
900            entry.channel = chans.ic_chans[i].ic_ieee;
901            entry.restricted = 0;
902
903            memcpy(&buf[bl], &entry, sizeof(struct iwinfo_freqlist_entry));
904            bl += sizeof(struct iwinfo_freqlist_entry);
905        }
906
907        *len = bl;
908        return 0;
909    }
910
911    return -1;
912}
913
914int madwifi_get_country(const char *ifname, char *buf)
915{
916    int i, fd, ccode = -1;
917    char buffer[34];
918    char *wifi = madwifi_iswifi(ifname)
919        ? (char *)ifname : madwifi_isvap(ifname, NULL);
920
921    struct ISO3166_to_CCode *e;
922
923    if( wifi )
924    {
925        snprintf(buffer, sizeof(buffer), "/proc/sys/dev/%s/countrycode", wifi);
926
927        if( (fd = open(buffer, O_RDONLY)) > -1 )
928        {
929            memset(buffer, 0, sizeof(buffer));
930
931            if( read(fd, buffer, sizeof(buffer)-1) > 0 )
932                ccode = atoi(buffer);
933
934            close(fd);
935        }
936    }
937
938    for( i = 0; i < (sizeof(CountryCodes)/sizeof(CountryCodes[0])); i++ )
939    {
940        e = &CountryCodes[i];
941
942        if( e->ccode == ccode )
943        {
944            sprintf(buf, "%c%c", e->iso3166 / 256, e->iso3166 % 256);
945            return 0;
946        }
947    }
948
949    return -1;
950}
951
952int madwifi_get_countrylist(const char *ifname, char *buf, int *len)
953{
954    int i, count;
955    struct ISO3166_to_CCode *e, *p = NULL;
956    struct iwinfo_country_entry *c = (struct iwinfo_country_entry *)buf;
957
958    count = 0;
959
960    for( int i = 0; i < (sizeof(CountryCodes)/sizeof(CountryCodes[0])); i++ )
961    {
962        e = &CountryCodes[i];
963
964        if( !p || (e->iso3166 != p->iso3166) )
965        {
966            c->iso3166 = e->iso3166;
967            snprintf(c->ccode, sizeof(c->ccode), "%i", e->ccode);
968
969            c++;
970            count++;
971        }
972
973        p = e;
974    }
975
976    *len = (count * sizeof(struct iwinfo_country_entry));
977    return 0;
978}
979
980int madwifi_get_hwmodelist(const char *ifname, int *buf)
981{
982    char chans[IWINFO_BUFSIZE] = { 0 };
983    struct iwinfo_freqlist_entry *e = NULL;
984    int len = 0;
985
986    if( !madwifi_get_freqlist(ifname, chans, &len) )
987    {
988        for( e = (struct iwinfo_freqlist_entry *)chans; e->channel; e++ )
989        {
990            if( e->channel <= 14 )
991            {
992                *buf |= IWINFO_80211_B;
993                *buf |= IWINFO_80211_G;
994            }
995            else
996            {
997                *buf |= IWINFO_80211_A;
998            }
999        }
1000
1001        return 0;
1002    }
1003
1004    return -1;
1005}
1006
1007int madwifi_get_mbssid_support(const char *ifname, int *buf)
1008{
1009    /* Test whether we can create another interface */
1010    char *nif = madwifi_ifadd(ifname);
1011
1012    if( nif )
1013    {
1014        *buf = iwinfo_ifup(nif);
1015
1016        iwinfo_ifdown(nif);
1017        madwifi_ifdel(nif);
1018
1019        return 0;
1020    }
1021
1022    return -1;
1023}
1024
1025int madwifi_get_hardware_id(const char *ifname, char *buf)
1026{
1027    char vendor[64];
1028    char device[64];
1029    struct iwinfo_hardware_id *ids;
1030    struct iwinfo_hardware_entry *e;
1031    const char *phy = madwifi_phyname(ifname);
1032
1033    if (wext_get_hardware_id(phy, buf))
1034        return iwinfo_hardware_id_from_mtd((struct iwinfo_hardware_id *)buf);
1035
1036    return 0;
1037}
1038
1039static const struct iwinfo_hardware_entry *
1040madwifi_get_hardware_entry(const char *ifname)
1041{
1042    struct iwinfo_hardware_id id;
1043
1044    if (madwifi_get_hardware_id(ifname, (char *)&id))
1045        return NULL;
1046
1047    return iwinfo_hardware(&id);
1048}
1049
1050int madwifi_get_hardware_name(const char *ifname, char *buf)
1051{
1052    const struct iwinfo_hardware_entry *hw;
1053
1054    if (!(hw = madwifi_get_hardware_entry(ifname)))
1055        sprintf(buf, "Generic Atheros");
1056    else
1057        sprintf(buf, "%s %s", hw->vendor_name, hw->device_name);
1058
1059    return 0;
1060}
1061
1062int madwifi_get_txpower_offset(const char *ifname, int *buf)
1063{
1064    const struct iwinfo_hardware_entry *hw;
1065
1066    if (!(hw = madwifi_get_hardware_entry(ifname)))
1067        return -1;
1068
1069    *buf = hw->txpower_offset;
1070    return 0;
1071}
1072
1073int madwifi_get_frequency_offset(const char *ifname, int *buf)
1074{
1075    const struct iwinfo_hardware_entry *hw;
1076
1077    if (!(hw = madwifi_get_hardware_entry(ifname)))
1078        return -1;
1079
1080    *buf = hw->frequency_offset;
1081    return 0;
1082}
1083

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive