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_mbssid_support(const char *ifname, int *buf)
1028 {
1029         /* Test whether we can create another interface */
1030         char *nif = madwifi_ifadd(ifname);
1031
1032         if( nif )
1033         {
1034                 *buf = iwinfo_ifup(nif);
1035
1036                 iwinfo_ifdown(nif);
1037                 madwifi_ifdel(nif);
1038
1039                 return 0;
1040         }
1041
1042         return -1;
1043 }
1044
1045 static int madwifi_get_hardware_id(const char *ifname, char *buf)
1046 {
1047         char vendor[64];
1048         char device[64];
1049         struct iwinfo_hardware_id *ids;
1050         struct iwinfo_hardware_entry *e;
1051         const char *phy = madwifi_phyname(ifname);
1052
1053         if (wext_ops.hardware_id(phy, buf))
1054                 return iwinfo_hardware_id_from_mtd((struct iwinfo_hardware_id *)buf);
1055
1056         return 0;
1057 }
1058
1059 static const struct iwinfo_hardware_entry *
1060 madwifi_get_hardware_entry(const char *ifname)
1061 {
1062         struct iwinfo_hardware_id id;
1063
1064         if (madwifi_get_hardware_id(ifname, (char *)&id))
1065                 return NULL;
1066
1067         return iwinfo_hardware(&id);
1068 }
1069
1070 static int madwifi_get_hardware_name(const char *ifname, char *buf)
1071 {
1072         const struct iwinfo_hardware_entry *hw;
1073
1074         if (!(hw = madwifi_get_hardware_entry(ifname)))
1075                 sprintf(buf, "Generic Atheros");
1076         else
1077                 sprintf(buf, "%s %s", hw->vendor_name, hw->device_name);
1078
1079         return 0;
1080 }
1081
1082 static int madwifi_get_txpower_offset(const char *ifname, int *buf)
1083 {
1084         const struct iwinfo_hardware_entry *hw;
1085
1086         if (!(hw = madwifi_get_hardware_entry(ifname)))
1087                 return -1;
1088
1089         *buf = hw->txpower_offset;
1090         return 0;
1091 }
1092
1093 static int madwifi_get_frequency_offset(const char *ifname, int *buf)
1094 {
1095         const struct iwinfo_hardware_entry *hw;
1096
1097         if (!(hw = madwifi_get_hardware_entry(ifname)))
1098                 return -1;
1099
1100         *buf = hw->frequency_offset;
1101         return 0;
1102 }
1103
1104 const struct iwinfo_ops madwifi_ops = {
1105         .name             = "madwifi",
1106         .probe            = madwifi_probe,
1107         .channel          = madwifi_get_channel,
1108         .frequency        = madwifi_get_frequency,
1109         .frequency_offset = madwifi_get_frequency_offset,
1110         .txpower          = madwifi_get_txpower,
1111         .txpower_offset   = madwifi_get_txpower_offset,
1112         .bitrate          = madwifi_get_bitrate,
1113         .signal           = madwifi_get_signal,
1114         .noise            = madwifi_get_noise,
1115         .quality          = madwifi_get_quality,
1116         .quality_max      = madwifi_get_quality_max,
1117         .mbssid_support   = madwifi_get_mbssid_support,
1118         .hwmodelist       = madwifi_get_hwmodelist,
1119         .mode             = madwifi_get_mode,
1120         .ssid             = madwifi_get_ssid,
1121         .bssid            = madwifi_get_bssid,
1122         .country          = madwifi_get_country,
1123         .hardware_id      = madwifi_get_hardware_id,
1124         .hardware_name    = madwifi_get_hardware_name,
1125         .encryption       = madwifi_get_encryption,
1126         .phyname          = madwifi_get_phyname,
1127         .assoclist        = madwifi_get_assoclist,
1128         .txpwrlist        = madwifi_get_txpwrlist,
1129         .scanlist         = madwifi_get_scanlist,
1130         .freqlist         = madwifi_get_freqlist,
1131         .countrylist      = madwifi_get_countrylist,
1132         .close            = madwifi_close
1133 };