utils: fix segfault in iwinfo_hardware_id_from_mtd()
[project/iwinfo.git] / 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_wext.h"
24 #include "api/madwifi.h"
25
26
27 /*
28  * Madwifi ISO 3166 to Country/Region Code mapping.
29  */
30
31 static 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
199 static 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
211 static 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
231 static 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
241 static 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
273 static 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
294 static 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
331 static 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
340 static int madwifi_probe(const char *ifname)
341 {
342         return ( !!madwifi_isvap(ifname, NULL) || madwifi_iswifi(ifname) );
343 }
344
345 static void madwifi_close(void)
346 {
347         /* Nop */
348 }
349
350 static int madwifi_get_mode(const char *ifname, int *buf)
351 {
352         return wext_ops.mode(ifname, buf);
353 }
354
355 static int madwifi_get_ssid(const char *ifname, char *buf)
356 {
357         return wext_ops.ssid(ifname, buf);
358 }
359
360 static int madwifi_get_bssid(const char *ifname, char *buf)
361 {
362         return wext_ops.bssid(ifname, buf);
363 }
364
365 static int 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
397 static int 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
410 static int madwifi_get_txpower(const char *ifname, int *buf)
411 {
412         return wext_ops.txpower(ifname, buf);
413 }
414
415 static int 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_ops.bitrate(ifname, buf);
456         }
457
458         return -1;
459 }
460
461 static int 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_ops.signal(ifname, buf);
502         }
503
504         return -1;
505 }
506
507 static int madwifi_get_noise(const char *ifname, int *buf)
508 {
509         return wext_ops.noise(ifname, buf);
510 }
511
512 static int 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_ops.quality(ifname, buf);
553         }
554
555         return -1;
556 }
557
558 static int madwifi_get_quality_max(const char *ifname, int *buf)
559 {
560         return wext_ops.quality_max(ifname, buf);
561 }
562
563 static int 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
724 static int madwifi_get_phyname(const char *ifname, char *buf)
725 {
726         const char *wifidev;
727
728         wifidev = madwifi_isvap(ifname, NULL);
729
730         if (wifidev)
731         {
732                 strcpy(buf, wifidev);
733                 return 0;
734         }
735         else if (madwifi_iswifi(ifname))
736         {
737                 strcpy(buf, madwifi_phyname(ifname));
738                 return 0;
739         }
740
741         return -1;
742 }
743
744 static int madwifi_get_assoclist(const char *ifname, char *buf, int *len)
745 {
746         int bl, tl, noise;
747         uint8_t *cp;
748         uint8_t tmp[24*1024];
749         struct ieee80211req_sta_info *si;
750         struct iwinfo_assoclist_entry entry;
751
752         if( (tl = get80211priv(ifname, IEEE80211_IOCTL_STA_INFO, tmp, 24*1024)) > 0 )
753         {
754                 cp = tmp;
755                 bl = 0;
756
757                 if( madwifi_get_noise(ifname, &noise) )
758                         noise = 0;
759
760                 do {
761                         si = (struct ieee80211req_sta_info *) cp;
762
763                         memset(&entry, 0, sizeof(entry));
764
765                         entry.signal = (si->isi_rssi - 95);
766                         entry.noise  = noise;
767                         memcpy(entry.mac, &si->isi_macaddr, 6);
768
769                         entry.inactive = si->isi_inact * 1000;
770
771                         entry.tx_packets = (si->isi_txseqs[0] & IEEE80211_SEQ_SEQ_MASK)
772                                 >> IEEE80211_SEQ_SEQ_SHIFT;
773
774                         entry.rx_packets = (si->isi_rxseqs[0] & IEEE80211_SEQ_SEQ_MASK)
775                                 >> IEEE80211_SEQ_SEQ_SHIFT;
776
777                         entry.tx_rate.rate =
778                                 (si->isi_rates[si->isi_txrate] & IEEE80211_RATE_VAL) * 500;
779
780                         /* XXX: this is just a guess */
781                         entry.rx_rate.rate = entry.tx_rate.rate;
782
783                         entry.rx_rate.mcs = -1;
784                         entry.tx_rate.mcs = -1;
785
786                         memcpy(&buf[bl], &entry, sizeof(struct iwinfo_assoclist_entry));
787
788                         bl += sizeof(struct iwinfo_assoclist_entry);
789                         cp += si->isi_len;
790                         tl -= si->isi_len;
791                 } while (tl >= sizeof(struct ieee80211req_sta_info));
792
793                 *len = bl;
794                 return 0;
795         }
796
797         return -1;
798 }
799
800 static int madwifi_get_txpwrlist(const char *ifname, char *buf, int *len)
801 {
802         int rc = -1;
803         char *res;
804
805         /* A wifiX device? */
806         if( madwifi_iswifi(ifname) )
807         {
808                 if( (res = madwifi_ifadd(ifname)) != NULL )
809                 {
810                         rc = wext_ops.txpwrlist(res, buf, len);
811                         madwifi_ifdel(res);
812                 }
813         }
814
815         /* Its an athX ... */
816         else if( !!madwifi_isvap(ifname, NULL) )
817         {
818                 rc = wext_ops.txpwrlist(ifname, buf, len);
819         }
820
821         return rc;
822 }
823
824 static int madwifi_get_scanlist(const char *ifname, char *buf, int *len)
825 {
826         int ret;
827         char *res;
828         DIR *proc;
829         struct dirent *e;
830
831         ret = -1;
832
833         /* We got a wifiX device passed, try to lookup a vap on it */
834         if( madwifi_iswifi(ifname) )
835         {
836                 if( (proc = opendir("/proc/sys/net/")) != NULL )
837                 {
838                         while( (e = readdir(proc)) != NULL )
839                         {
840                                 if( !!madwifi_isvap(e->d_name, ifname) )
841                                 {
842                                         if( iwinfo_ifup(e->d_name) )
843                                         {
844                                                 ret = wext_ops.scanlist(e->d_name, buf, len);
845                                                 break;
846                                         }
847                                 }
848                         }
849
850                         closedir(proc);
851                 }
852
853                 /* Still nothing found, try to create a vap */
854                 if( ret == -1 )
855                 {
856                         if( (res = madwifi_ifadd(ifname)) != NULL )
857                         {
858                                 if( iwinfo_ifup(res) )
859                                 {
860                                         wext_ops.scanlist(res, buf, len);
861                                         sleep(1);
862
863                                         wext_ops.scanlist(res, buf, len);
864                                         sleep(1);
865
866                                         ret = wext_ops.scanlist(res, buf, len);
867                                 }
868
869                                 iwinfo_ifdown(res);
870                                 madwifi_ifdel(res);
871                         }
872                 }
873         }
874
875         /* Got athX device? */
876         else if( !!madwifi_isvap(ifname, NULL) )
877         {
878                 ret = wext_ops.scanlist(ifname, buf, len);
879         }
880
881         return ret;
882 }
883
884 static int madwifi_get_freqlist(const char *ifname, char *buf, int *len)
885 {
886         int i, bl;
887         int rc = -1;
888         char *res;
889         struct ieee80211req_chaninfo chans;
890         struct iwinfo_freqlist_entry entry;
891
892         /* A wifiX device? */
893         if( madwifi_iswifi(ifname) )
894         {
895                 if( (res = madwifi_ifadd(ifname)) != NULL )
896                 {
897                         rc = get80211priv(res, IEEE80211_IOCTL_GETCHANINFO,
898                                                           &chans, sizeof(chans));
899
900                         madwifi_ifdel(res);
901                 }
902         }
903
904         /* Its an athX ... */
905         else if( !!madwifi_isvap(ifname, NULL) )
906         {
907                 rc = get80211priv(ifname, IEEE80211_IOCTL_GETCHANINFO,
908                                                   &chans, sizeof(chans));
909         }
910
911
912         /* Got chaninfo? */
913         if( rc >= 0 )
914         {
915                 bl = 0;
916
917                 for( i = 0; i < chans.ic_nchans; i++ )
918                 {
919                         entry.mhz        = chans.ic_chans[i].ic_freq;
920                         entry.channel    = chans.ic_chans[i].ic_ieee;
921                         entry.restricted = 0;
922
923                         memcpy(&buf[bl], &entry, sizeof(struct iwinfo_freqlist_entry));
924                         bl += sizeof(struct iwinfo_freqlist_entry);
925                 }
926
927                 *len = bl;
928                 return 0;
929         }
930
931         return -1;
932 }
933
934 static int madwifi_get_country(const char *ifname, char *buf)
935 {
936         int i, fd, ccode = -1;
937         char buffer[34];
938         char *wifi = madwifi_iswifi(ifname)
939                 ? (char *)ifname : madwifi_isvap(ifname, NULL);
940
941         struct ISO3166_to_CCode *e;
942
943         if( wifi )
944         {
945                 snprintf(buffer, sizeof(buffer), "/proc/sys/dev/%s/countrycode", wifi);
946
947                 if( (fd = open(buffer, O_RDONLY)) > -1 )
948                 {
949                         memset(buffer, 0, sizeof(buffer));
950
951                         if( read(fd, buffer, sizeof(buffer)-1) > 0 )
952                                 ccode = atoi(buffer);
953
954                         close(fd);
955                 }
956         }
957
958         for( i = 0; i < (sizeof(CountryCodes)/sizeof(CountryCodes[0])); i++ )
959         {
960                 e = &CountryCodes[i];
961
962                 if( e->ccode == ccode )
963                 {
964                         sprintf(buf, "%c%c", e->iso3166 / 256, e->iso3166 % 256);
965                         return 0;
966                 }
967         }
968
969         return -1;
970 }
971
972 static int madwifi_get_countrylist(const char *ifname, char *buf, int *len)
973 {
974         int i, count;
975         struct ISO3166_to_CCode *e, *p = NULL;
976         struct iwinfo_country_entry *c = (struct iwinfo_country_entry *)buf;
977
978         count = 0;
979
980         for( int i = 0; i < (sizeof(CountryCodes)/sizeof(CountryCodes[0])); i++ )
981         {
982                 e = &CountryCodes[i];
983
984                 if( !p || (e->iso3166 != p->iso3166) )
985                 {
986                         c->iso3166 = e->iso3166;
987                         snprintf(c->ccode, sizeof(c->ccode), "%i", e->ccode);
988
989                         c++;
990                         count++;
991                 }
992
993                 p = e;
994         }
995
996         *len = (count * sizeof(struct iwinfo_country_entry));
997         return 0;
998 }
999
1000 static int madwifi_get_hwmodelist(const char *ifname, int *buf)
1001 {
1002         char chans[IWINFO_BUFSIZE] = { 0 };
1003         struct iwinfo_freqlist_entry *e = NULL;
1004         int len = 0;
1005
1006         if( !madwifi_get_freqlist(ifname, chans, &len) )
1007         {
1008                 for( e = (struct iwinfo_freqlist_entry *)chans; e->channel; e++ )
1009                 {
1010                         if( e->channel <= 14 )
1011                         {
1012                                 *buf |= IWINFO_80211_B;
1013                                 *buf |= IWINFO_80211_G;
1014                         }
1015                         else
1016                         {
1017                                 *buf |= IWINFO_80211_A;
1018                         }
1019                 }
1020
1021                 return 0;
1022         }
1023
1024         return -1;
1025 }
1026
1027 static int madwifi_get_htmodelist(const char *ifname, int *buf)
1028 {
1029         /* OpenWrt's madwifi did never support any HT rates */
1030         return -1;
1031 }
1032
1033 static int madwifi_get_mbssid_support(const char *ifname, int *buf)
1034 {
1035         /* Test whether we can create another interface */
1036         char *nif = madwifi_ifadd(ifname);
1037
1038         if( nif )
1039         {
1040                 *buf = iwinfo_ifup(nif);
1041
1042                 iwinfo_ifdown(nif);
1043                 madwifi_ifdel(nif);
1044
1045                 return 0;
1046         }
1047
1048         return -1;
1049 }
1050
1051 static int madwifi_get_hardware_id(const char *ifname, char *buf)
1052 {
1053         char vendor[64];
1054         char device[64];
1055         struct iwinfo_hardware_id *ids;
1056         struct iwinfo_hardware_entry *e;
1057         const char *phy = madwifi_phyname(ifname);
1058
1059         if (wext_ops.hardware_id(phy, buf))
1060                 return iwinfo_hardware_id_from_mtd((struct iwinfo_hardware_id *)buf);
1061
1062         return 0;
1063 }
1064
1065 static const struct iwinfo_hardware_entry *
1066 madwifi_get_hardware_entry(const char *ifname)
1067 {
1068         struct iwinfo_hardware_id id;
1069
1070         if (madwifi_get_hardware_id(ifname, (char *)&id))
1071                 return NULL;
1072
1073         return iwinfo_hardware(&id);
1074 }
1075
1076 static int madwifi_get_hardware_name(const char *ifname, char *buf)
1077 {
1078         const struct iwinfo_hardware_entry *hw;
1079
1080         if (!(hw = madwifi_get_hardware_entry(ifname)))
1081                 sprintf(buf, "Generic Atheros");
1082         else
1083                 sprintf(buf, "%s %s", hw->vendor_name, hw->device_name);
1084
1085         return 0;
1086 }
1087
1088 static int madwifi_get_txpower_offset(const char *ifname, int *buf)
1089 {
1090         const struct iwinfo_hardware_entry *hw;
1091
1092         if (!(hw = madwifi_get_hardware_entry(ifname)))
1093                 return -1;
1094
1095         *buf = hw->txpower_offset;
1096         return 0;
1097 }
1098
1099 static int madwifi_get_frequency_offset(const char *ifname, int *buf)
1100 {
1101         const struct iwinfo_hardware_entry *hw;
1102
1103         if (!(hw = madwifi_get_hardware_entry(ifname)))
1104                 return -1;
1105
1106         *buf = hw->frequency_offset;
1107         return 0;
1108 }
1109
1110 const struct iwinfo_ops madwifi_ops = {
1111         .name             = "madwifi",
1112         .probe            = madwifi_probe,
1113         .channel          = madwifi_get_channel,
1114         .frequency        = madwifi_get_frequency,
1115         .frequency_offset = madwifi_get_frequency_offset,
1116         .txpower          = madwifi_get_txpower,
1117         .txpower_offset   = madwifi_get_txpower_offset,
1118         .bitrate          = madwifi_get_bitrate,
1119         .signal           = madwifi_get_signal,
1120         .noise            = madwifi_get_noise,
1121         .quality          = madwifi_get_quality,
1122         .quality_max      = madwifi_get_quality_max,
1123         .mbssid_support   = madwifi_get_mbssid_support,
1124         .hwmodelist       = madwifi_get_hwmodelist,
1125         .htmodelist       = madwifi_get_htmodelist,
1126         .mode             = madwifi_get_mode,
1127         .ssid             = madwifi_get_ssid,
1128         .bssid            = madwifi_get_bssid,
1129         .country          = madwifi_get_country,
1130         .hardware_id      = madwifi_get_hardware_id,
1131         .hardware_name    = madwifi_get_hardware_name,
1132         .encryption       = madwifi_get_encryption,
1133         .phyname          = madwifi_get_phyname,
1134         .assoclist        = madwifi_get_assoclist,
1135         .txpwrlist        = madwifi_get_txpwrlist,
1136         .scanlist         = madwifi_get_scanlist,
1137         .freqlist         = madwifi_get_freqlist,
1138         .countrylist      = madwifi_get_countrylist,
1139         .close            = madwifi_close
1140 };