package/iwinfo/src/iwinfo_lua.c

   1 /*
   2  * iwinfo - Wireless Information Library - Lua Bindings
   3  *
   4  *   Copyright (C) 2009 Jo-Philipp Wich <xm@subsignal.org>
   5  *
   6  * The iwinfo library is free software: you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License version 2
   8  * as published by the Free Software Foundation.
   9  *
  10  * The iwinfo library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with the iwinfo library. If not, see http://www.gnu.org/licenses/.
  17  */
  18
  19 #include "iwinfo/lua.h"
  20
  21
  22 /* Determine type */
  23 static int iwinfo_L_type(lua_State *L)
  24 {
  25         const char *ifname = luaL_checkstring(L, 1);
  26         const char *type = iwinfo_type(ifname);
  27
  28         if (type)
  29                 lua_pushstring(L, type);
  30         else
  31                 lua_pushnil(L);
  32
  33         return 1;
  34 }
  35
  36 /* Shutdown backends */
  37 static int iwinfo_L__gc(lua_State *L)
  38 {
  39         iwinfo_finish();
  40         return 0;
  41 }
  42
  43 /*
  44  * Build a short textual description of the crypto info
  45  */
  46
  47 static char * iwinfo_crypto_print_ciphers(int ciphers)
  48 {
  49         static char str[128] = { 0 };
  50         char *pos = str;
  51
  52         if (ciphers & IWINFO_CIPHER_WEP40)
  53                 pos += sprintf(pos, "WEP-40, ");
  54
  55         if (ciphers & IWINFO_CIPHER_WEP104)
  56                 pos += sprintf(pos, "WEP-104, ");
  57
  58         if (ciphers & IWINFO_CIPHER_TKIP)
  59                 pos += sprintf(pos, "TKIP, ");
  60
  61         if (ciphers & IWINFO_CIPHER_CCMP)
  62                 pos += sprintf(pos, "CCMP, ");
  63
  64         if (ciphers & IWINFO_CIPHER_WRAP)
  65                 pos += sprintf(pos, "WRAP, ");
  66
  67         if (ciphers & IWINFO_CIPHER_AESOCB)
  68                 pos += sprintf(pos, "AES-OCB, ");
  69
  70         if (ciphers & IWINFO_CIPHER_CKIP)
  71                 pos += sprintf(pos, "CKIP, ");
  72
  73         if (!ciphers || (ciphers & IWINFO_CIPHER_NONE))
  74                 pos += sprintf(pos, "NONE, ");
  75
  76         *(pos - 2) = 0;
  77
  78         return str;
  79 }
  80
  81 static char * iwinfo_crypto_print_suites(int suites)
  82 {
  83         static char str[64] = { 0 };
  84         char *pos = str;
  85
  86         if (suites & IWINFO_KMGMT_PSK)
  87                 pos += sprintf(pos, "PSK/");
  88
  89         if (suites & IWINFO_KMGMT_8021x)
  90                 pos += sprintf(pos, "802.1X/");
  91
  92         if (!suites || (suites & IWINFO_KMGMT_NONE))
  93                 pos += sprintf(pos, "NONE/");
  94
  95         *(pos - 1) = 0;
  96
  97         return str;
  98 }
  99
 100 static char * iwinfo_crypto_desc(struct iwinfo_crypto_entry *c)
 101 {
 102         static char desc[512] = { 0 };
 103
 104         if (c)
 105         {
 106                 if (c->enabled)
 107                 {
 108                         /* WEP */
 109                         if (c->auth_algs && !c->wpa_version)
 110                         {
 111                                 if ((c->auth_algs & IWINFO_AUTH_OPEN) &&
 112                                     (c->auth_algs & IWINFO_AUTH_SHARED))
 113                                 {
 114                                         sprintf(desc, "WEP Open/Shared (%s)",
 115                                                 iwinfo_crypto_print_ciphers(c->pair_ciphers));
 116                                 }
 117                                 else if (c->auth_algs & IWINFO_AUTH_OPEN)
 118                                 {
 119                                         sprintf(desc, "WEP Open System (%s)",
 120                                                 iwinfo_crypto_print_ciphers(c->pair_ciphers));
 121                                 }
 122                                 else if (c->auth_algs & IWINFO_AUTH_SHARED)
 123                                 {
 124                                         sprintf(desc, "WEP Shared Auth (%s)",
 125                                                 iwinfo_crypto_print_ciphers(c->pair_ciphers));
 126                                 }
 127                         }
 128
 129                         /* WPA */
 130                         else if (c->wpa_version)
 131                         {
 132                                 switch (c->wpa_version) {
 133                                         case 3:
 134                                                 sprintf(desc, "mixed WPA/WPA2 %s (%s)",
 135                                                         iwinfo_crypto_print_suites(c->auth_suites),
 136                                                         iwinfo_crypto_print_ciphers(
 137                                                                 c->pair_ciphers & c->group_ciphers));
 138                                                 break;
 139
 140                                         case 2:
 141                                                 sprintf(desc, "WPA2 %s (%s)",
 142                                                         iwinfo_crypto_print_suites(c->auth_suites),
 143                                                         iwinfo_crypto_print_ciphers(
 144                                                                 c->pair_ciphers & c->group_ciphers));
 145                                                 break;
 146
 147                                         case 1:
 148                                                 sprintf(desc, "WPA %s (%s)",
 149                                                         iwinfo_crypto_print_suites(c->auth_suites),
 150                                                         iwinfo_crypto_print_ciphers(
 151                                                                 c->pair_ciphers & c->group_ciphers));
 152                                                 break;
 153                                 }
 154                         }
 155                         else
 156                         {
 157                                 sprintf(desc, "None");
 158                         }
 159                 }
 160                 else
 161                 {
 162                         sprintf(desc, "None");
 163                 }
 164         }
 165         else
 166         {
 167                 sprintf(desc, "Unknown");
 168         }
 169
 170         return desc;
 171 }
 172
 173 /* Build Lua table from crypto data */
 174 static void iwinfo_L_cryptotable(lua_State *L, struct iwinfo_crypto_entry *c)
 175 {
 176         int i, j;
 177
 178         lua_newtable(L);
 179
 180         lua_pushboolean(L, c->enabled);
 181         lua_setfield(L, -2, "enabled");
 182
 183         lua_pushstring(L, iwinfo_crypto_desc(c));
 184         lua_setfield(L, -2, "description");
 185
 186         lua_pushboolean(L, (c->enabled && !c->wpa_version));
 187         lua_setfield(L, -2, "wep");
 188
 189         lua_pushinteger(L, c->wpa_version);
 190         lua_setfield(L, -2, "wpa");
 191
 192         lua_newtable(L);
 193         for (i = 0, j = 1; i < 8; i++)
 194         {
 195                 if (c->pair_ciphers & (1 << i))
 196                 {
 197                         lua_pushstring(L, IWINFO_CIPHER_NAMES[i]);
 198                         lua_rawseti(L, -2, j++);
 199                 }
 200         }
 201         lua_setfield(L, -2, "pair_ciphers");
 202
 203         lua_newtable(L);
 204         for (i = 0, j = 1; i < 8; i++)
 205         {
 206                 if (c->group_ciphers & (1 << i))
 207                 {
 208                         lua_pushstring(L, IWINFO_CIPHER_NAMES[i]);
 209                         lua_rawseti(L, -2, j++);
 210                 }
 211         }
 212         lua_setfield(L, -2, "group_ciphers");
 213
 214         lua_newtable(L);
 215         for (i = 0, j = 1; i < 8; i++)
 216         {
 217                 if (c->auth_suites & (1 << i))
 218                 {
 219                         lua_pushstring(L, IWINFO_KMGMT_NAMES[i]);
 220                         lua_rawseti(L, -2, j++);
 221                 }
 222         }
 223         lua_setfield(L, -2, "auth_suites");
 224
 225         lua_newtable(L);
 226         for (i = 0, j = 1; i < 8; i++)
 227         {
 228                 if (c->auth_algs & (1 << i))
 229                 {
 230                         lua_pushstring(L, IWINFO_AUTH_NAMES[i]);
 231                         lua_rawseti(L, -2, j++);
 232                 }
 233         }
 234         lua_setfield(L, -2, "auth_algs");
 235 }
 236
 237
 238 /* Wrapper for assoclist */
 239 static int iwinfo_L_assoclist(lua_State *L, int (*func)(const char *, char *, int *))
 240 {
 241         int i, len;
 242         char rv[IWINFO_BUFSIZE];
 243         char macstr[18];
 244         const char *ifname = luaL_checkstring(L, 1);
 245         struct iwinfo_assoclist_entry *e;
 246
 247         lua_newtable(L);
 248         memset(rv, 0, sizeof(rv));
 249
 250         if (!(*func)(ifname, rv, &len))
 251         {
 252                 for (i = 0; i < len; i += sizeof(struct iwinfo_assoclist_entry))
 253                 {
 254                         e = (struct iwinfo_assoclist_entry *) &rv[i];
 255
 256                         sprintf(macstr, "%02X:%02X:%02X:%02X:%02X:%02X",
 257                                 e->mac[0], e->mac[1], e->mac[2],
 258                                 e->mac[3], e->mac[4], e->mac[5]);
 259
 260                         lua_newtable(L);
 261
 262                         lua_pushnumber(L, e->signal);
 263                         lua_setfield(L, -2, "signal");
 264
 265                         lua_pushnumber(L, e->noise);
 266                         lua_setfield(L, -2, "noise");
 267
 268                         lua_setfield(L, -2, macstr);
 269                 }
 270         }
 271
 272         return 1;
 273 }
 274
 275 /* Wrapper for tx power list */
 276 static int iwinfo_L_txpwrlist(lua_State *L, int (*func)(const char *, char *, int *))
 277 {
 278         int i, x, len;
 279         char rv[IWINFO_BUFSIZE];
 280         const char *ifname = luaL_checkstring(L, 1);
 281         struct iwinfo_txpwrlist_entry *e;
 282
 283         lua_newtable(L);
 284         memset(rv, 0, sizeof(rv));
 285
 286         if (!(*func)(ifname, rv, &len))
 287         {
 288                 for (i = 0, x = 1; i < len; i += sizeof(struct iwinfo_txpwrlist_entry), x++)
 289                 {
 290                         e = (struct iwinfo_txpwrlist_entry *) &rv[i];
 291
 292                         lua_newtable(L);
 293
 294                         lua_pushnumber(L, e->mw);
 295                         lua_setfield(L, -2, "mw");
 296
 297                         lua_pushnumber(L, e->dbm);
 298                         lua_setfield(L, -2, "dbm");
 299
 300                         lua_rawseti(L, -2, x);
 301                 }
 302         }
 303
 304         return 1;
 305 }
 306
 307 /* Wrapper for scan list */
 308 static int iwinfo_L_scanlist(lua_State *L, int (*func)(const char *, char *, int *))
 309 {
 310         int i, x, len;
 311         char rv[IWINFO_BUFSIZE];
 312         char macstr[18];
 313         const char *ifname = luaL_checkstring(L, 1);
 314         struct iwinfo_scanlist_entry *e;
 315
 316         lua_newtable(L);
 317         memset(rv, 0, sizeof(rv));
 318
 319         if (!(*func)(ifname, rv, &len))
 320         {
 321                 for (i = 0, x = 1; i < len; i += sizeof(struct iwinfo_scanlist_entry), x++)
 322                 {
 323                         e = (struct iwinfo_scanlist_entry *) &rv[i];
 324
 325                         lua_newtable(L);
 326
 327                         /* BSSID */
 328                         sprintf(macstr, "%02X:%02X:%02X:%02X:%02X:%02X",
 329                                 e->mac[0], e->mac[1], e->mac[2],
 330                                 e->mac[3], e->mac[4], e->mac[5]);
 331
 332                         lua_pushstring(L, macstr);
 333                         lua_setfield(L, -2, "bssid");
 334
 335                         /* ESSID */
 336                         if (e->ssid[0])
 337                         {
 338                                 lua_pushstring(L, (char *) e->ssid);
 339                                 lua_setfield(L, -2, "ssid");
 340                         }
 341
 342                         /* Channel */
 343                         lua_pushinteger(L, e->channel);
 344                         lua_setfield(L, -2, "channel");
 345
 346                         /* Mode */
 347                         lua_pushstring(L, (char *) e->mode);
 348                         lua_setfield(L, -2, "mode");
 349
 350                         /* Quality, Signal */
 351                         lua_pushinteger(L, e->quality);
 352                         lua_setfield(L, -2, "quality");
 353
 354                         lua_pushinteger(L, e->quality_max);
 355                         lua_setfield(L, -2, "quality_max");
 356
 357                         lua_pushnumber(L, (e->signal - 0x100));
 358                         lua_setfield(L, -2, "signal");
 359
 360                         /* Crypto */
 361                         iwinfo_L_cryptotable(L, &e->crypto);
 362                         lua_setfield(L, -2, "encryption");
 363
 364                         lua_rawseti(L, -2, x);
 365                 }
 366         }
 367
 368         return 1;
 369 }
 370
 371 /* Wrapper for frequency list */
 372 static int iwinfo_L_freqlist(lua_State *L, int (*func)(const char *, char *, int *))
 373 {
 374         int i, x, len;
 375         char rv[IWINFO_BUFSIZE];
 376         const char *ifname = luaL_checkstring(L, 1);
 377         struct iwinfo_freqlist_entry *e;
 378
 379         lua_newtable(L);
 380         memset(rv, 0, sizeof(rv));
 381
 382         if (!(*func)(ifname, rv, &len))
 383         {
 384                 for (i = 0, x = 1; i < len; i += sizeof(struct iwinfo_freqlist_entry), x++)
 385                 {
 386                         e = (struct iwinfo_freqlist_entry *) &rv[i];
 387
 388                         lua_newtable(L);
 389
 390                         /* MHz */
 391                         lua_pushinteger(L, e->mhz);
 392                         lua_setfield(L, -2, "mhz");
 393
 394                         /* Channel */
 395                         lua_pushinteger(L, e->channel);
 396                         lua_setfield(L, -2, "channel");
 397
 398                         /* Restricted (DFS/TPC/Radar) */
 399                         lua_pushboolean(L, e->restricted);
 400                         lua_setfield(L, -2, "restricted");
 401
 402                         lua_rawseti(L, -2, x);
 403                 }
 404         }
 405
 406         return 1;
 407 }
 408
 409 /* Wrapper for crypto settings */
 410 static int iwinfo_L_encryption(lua_State *L, int (*func)(const char *, char *))
 411 {
 412         const char *ifname = luaL_checkstring(L, 1);
 413         struct iwinfo_crypto_entry c = { 0 };
 414
 415         if (!(*func)(ifname, (char *)&c))
 416         {
 417                 iwinfo_L_cryptotable(L, &c);
 418                 return 1;
 419         }
 420
 421         lua_pushnil(L);
 422         return 1;
 423 }
 424
 425 /* Wrapper for hwmode list */
 426 static int iwinfo_L_hwmodelist(lua_State *L, int (*func)(const char *, int *))
 427 {
 428         const char *ifname = luaL_checkstring(L, 1);
 429         int hwmodes = 0;
 430
 431         if (!(*func)(ifname, &hwmodes))
 432         {
 433                 lua_newtable(L);
 434
 435                 lua_pushboolean(L, hwmodes & IWINFO_80211_A);
 436                 lua_setfield(L, -2, "a");
 437
 438                 lua_pushboolean(L, hwmodes & IWINFO_80211_B);
 439                 lua_setfield(L, -2, "b");
 440
 441                 lua_pushboolean(L, hwmodes & IWINFO_80211_G);
 442                 lua_setfield(L, -2, "g");
 443
 444                 lua_pushboolean(L, hwmodes & IWINFO_80211_N);
 445                 lua_setfield(L, -2, "n");
 446
 447                 return 1;
 448         }
 449
 450         lua_pushnil(L);
 451         return 1;
 452 }
 453
 454 /* Wrapper for mbbsid_support */
 455 static int iwinfo_L_mbssid_support(lua_State *L, int (*func)(const char *, int *))
 456 {
 457         const char *ifname = luaL_checkstring(L, 1);
 458         int support = 0;
 459
 460         if (!(*func)(ifname, &support))
 461         {
 462                 lua_pushboolean(L, support);
 463                 return 1;
 464         }
 465
 466         lua_pushnil(L);
 467         return 1;
 468 }
 469
 470 /* Wrapper for country list */
 471 static char * iwinfo_L_country_lookup(char *buf, int len, int iso3166)
 472 {
 473         int i;
 474         struct iwinfo_country_entry *c;
 475
 476         for (i = 0; i < len; i += sizeof(struct iwinfo_country_entry))
 477         {
 478                 c = (struct iwinfo_country_entry *) &buf[i];
 479
 480                 if (c->iso3166 == iso3166)
 481                         return c->ccode;
 482         }
 483
 484         return NULL;
 485 }
 486
 487 static int iwinfo_L_countrylist(lua_State *L, int (*func)(const char *, char *, int *))
 488 {
 489         int len, i, j;
 490         char rv[IWINFO_BUFSIZE], alpha2[3];
 491         char *ccode;
 492         const char *ifname = luaL_checkstring(L, 1);
 493         const struct iwinfo_iso3166_label *l;
 494
 495         lua_newtable(L);
 496         memset(rv, 0, sizeof(rv));
 497
 498         if (!(*func)(ifname, rv, &len))
 499         {
 500                 for (l = IWINFO_ISO3166_NAMES, j = 1; l->iso3166; l++)
 501                 {
 502                         if ((ccode = iwinfo_L_country_lookup(rv, len, l->iso3166)) != NULL)
 503                         {
 504                                 sprintf(alpha2, "%c%c",
 505                                         (l->iso3166 / 256), (l->iso3166 % 256));
 506
 507                                 lua_newtable(L);
 508
 509                                 lua_pushstring(L, alpha2);
 510                                 lua_setfield(L, -2, "alpha2");
 511
 512                                 lua_pushstring(L, ccode);
 513                                 lua_setfield(L, -2, "ccode");
 514
 515                                 lua_pushstring(L, l->name);
 516                                 lua_setfield(L, -2, "name");
 517
 518                                 lua_rawseti(L, -2, j++);
 519                         }
 520                 }
 521         }
 522
 523         return 1;
 524 }
 525
 526
 527 #ifdef USE_WL
 528 /* Broadcom */
 529 LUA_WRAP_INT(wl,channel)
 530 LUA_WRAP_INT(wl,frequency)
 531 LUA_WRAP_INT(wl,txpower)
 532 LUA_WRAP_INT(wl,bitrate)
 533 LUA_WRAP_INT(wl,signal)
 534 LUA_WRAP_INT(wl,noise)
 535 LUA_WRAP_INT(wl,quality)
 536 LUA_WRAP_INT(wl,quality_max)
 537 LUA_WRAP_STRING(wl,mode)
 538 LUA_WRAP_STRING(wl,ssid)
 539 LUA_WRAP_STRING(wl,bssid)
 540 LUA_WRAP_STRING(wl,country)
 541 LUA_WRAP_LIST(wl,assoclist)
 542 LUA_WRAP_LIST(wl,txpwrlist)
 543 LUA_WRAP_LIST(wl,scanlist)
 544 LUA_WRAP_LIST(wl,freqlist)
 545 LUA_WRAP_LIST(wl,countrylist)
 546 LUA_WRAP_LIST(wl,hwmodelist)
 547 LUA_WRAP_LIST(wl,encryption)
 548 LUA_WRAP_LIST(wl,mbssid_support)
 549 #endif
 550
 551 #ifdef USE_MADWIFI
 552 /* Madwifi */
 553 LUA_WRAP_INT(madwifi,channel)
 554 LUA_WRAP_INT(madwifi,frequency)
 555 LUA_WRAP_INT(madwifi,txpower)
 556 LUA_WRAP_INT(madwifi,bitrate)
 557 LUA_WRAP_INT(madwifi,signal)
 558 LUA_WRAP_INT(madwifi,noise)
 559 LUA_WRAP_INT(madwifi,quality)
 560 LUA_WRAP_INT(madwifi,quality_max)
 561 LUA_WRAP_STRING(madwifi,mode)
 562 LUA_WRAP_STRING(madwifi,ssid)
 563 LUA_WRAP_STRING(madwifi,bssid)
 564 LUA_WRAP_STRING(madwifi,country)
 565 LUA_WRAP_LIST(madwifi,assoclist)
 566 LUA_WRAP_LIST(madwifi,txpwrlist)
 567 LUA_WRAP_LIST(madwifi,scanlist)
 568 LUA_WRAP_LIST(madwifi,freqlist)
 569 LUA_WRAP_LIST(madwifi,countrylist)
 570 LUA_WRAP_LIST(madwifi,hwmodelist)
 571 LUA_WRAP_LIST(madwifi,encryption)
 572 LUA_WRAP_LIST(madwifi,mbssid_support)
 573 #endif
 574
 575 #ifdef USE_NL80211
 576 /* NL80211 */
 577 LUA_WRAP_INT(nl80211,channel)
 578 LUA_WRAP_INT(nl80211,frequency)
 579 LUA_WRAP_INT(nl80211,txpower)
 580 LUA_WRAP_INT(nl80211,bitrate)
 581 LUA_WRAP_INT(nl80211,signal)
 582 LUA_WRAP_INT(nl80211,noise)
 583 LUA_WRAP_INT(nl80211,quality)
 584 LUA_WRAP_INT(nl80211,quality_max)
 585 LUA_WRAP_STRING(nl80211,mode)
 586 LUA_WRAP_STRING(nl80211,ssid)
 587 LUA_WRAP_STRING(nl80211,bssid)
 588 LUA_WRAP_STRING(nl80211,country)
 589 LUA_WRAP_LIST(nl80211,assoclist)
 590 LUA_WRAP_LIST(nl80211,txpwrlist)
 591 LUA_WRAP_LIST(nl80211,scanlist)
 592 LUA_WRAP_LIST(nl80211,freqlist)
 593 LUA_WRAP_LIST(nl80211,countrylist)
 594 LUA_WRAP_LIST(nl80211,hwmodelist)
 595 LUA_WRAP_LIST(nl80211,encryption)
 596 LUA_WRAP_LIST(nl80211,mbssid_support)
 597 #endif
 598
 599 /* Wext */
 600 LUA_WRAP_INT(wext,channel)
 601 LUA_WRAP_INT(wext,frequency)
 602 LUA_WRAP_INT(wext,txpower)
 603 LUA_WRAP_INT(wext,bitrate)
 604 LUA_WRAP_INT(wext,signal)
 605 LUA_WRAP_INT(wext,noise)
 606 LUA_WRAP_INT(wext,quality)
 607 LUA_WRAP_INT(wext,quality_max)
 608 LUA_WRAP_STRING(wext,mode)
 609 LUA_WRAP_STRING(wext,ssid)
 610 LUA_WRAP_STRING(wext,bssid)
 611 LUA_WRAP_STRING(wext,country)
 612 LUA_WRAP_LIST(wext,assoclist)
 613 LUA_WRAP_LIST(wext,txpwrlist)
 614 LUA_WRAP_LIST(wext,scanlist)
 615 LUA_WRAP_LIST(wext,freqlist)
 616 LUA_WRAP_LIST(wext,countrylist)
 617 LUA_WRAP_LIST(wext,hwmodelist)
 618 LUA_WRAP_LIST(wext,encryption)
 619 LUA_WRAP_LIST(wext,mbssid_support)
 620
 621 #ifdef USE_WL
 622 /* Broadcom table */
 623 static const luaL_reg R_wl[] = {
 624         LUA_REG(wl,channel),
 625         LUA_REG(wl,frequency),
 626         LUA_REG(wl,txpower),
 627         LUA_REG(wl,bitrate),
 628         LUA_REG(wl,signal),
 629         LUA_REG(wl,noise),
 630         LUA_REG(wl,quality),
 631         LUA_REG(wl,quality_max),
 632         LUA_REG(wl,mode),
 633         LUA_REG(wl,ssid),
 634         LUA_REG(wl,bssid),
 635         LUA_REG(wl,country),
 636         LUA_REG(wl,assoclist),
 637         LUA_REG(wl,txpwrlist),
 638         LUA_REG(wl,scanlist),
 639         LUA_REG(wl,freqlist),
 640         LUA_REG(wl,countrylist),
 641         LUA_REG(wl,hwmodelist),
 642         LUA_REG(wl,encryption),
 643         LUA_REG(wl,mbssid_support),
 644         { NULL, NULL }
 645 };
 646 #endif
 647
 648 #ifdef USE_MADWIFI
 649 /* Madwifi table */
 650 static const luaL_reg R_madwifi[] = {
 651         LUA_REG(madwifi,channel),
 652         LUA_REG(madwifi,frequency),
 653         LUA_REG(madwifi,txpower),
 654         LUA_REG(madwifi,bitrate),
 655         LUA_REG(madwifi,signal),
 656         LUA_REG(madwifi,noise),
 657         LUA_REG(madwifi,quality),
 658         LUA_REG(madwifi,quality_max),
 659         LUA_REG(madwifi,mode),
 660         LUA_REG(madwifi,ssid),
 661         LUA_REG(madwifi,bssid),
 662         LUA_REG(madwifi,country),
 663         LUA_REG(madwifi,assoclist),
 664         LUA_REG(madwifi,txpwrlist),
 665         LUA_REG(madwifi,scanlist),
 666         LUA_REG(madwifi,freqlist),
 667         LUA_REG(madwifi,countrylist),
 668         LUA_REG(madwifi,hwmodelist),
 669         LUA_REG(madwifi,encryption),
 670         LUA_REG(madwifi,mbssid_support),
 671         { NULL, NULL }
 672 };
 673 #endif
 674
 675 #ifdef USE_NL80211
 676 /* NL80211 table */
 677 static const luaL_reg R_nl80211[] = {
 678         LUA_REG(nl80211,channel),
 679         LUA_REG(nl80211,frequency),
 680         LUA_REG(nl80211,txpower),
 681         LUA_REG(nl80211,bitrate),
 682         LUA_REG(nl80211,signal),
 683         LUA_REG(nl80211,noise),
 684         LUA_REG(nl80211,quality),
 685         LUA_REG(nl80211,quality_max),
 686         LUA_REG(nl80211,mode),
 687         LUA_REG(nl80211,ssid),
 688         LUA_REG(nl80211,bssid),
 689         LUA_REG(nl80211,country),
 690         LUA_REG(nl80211,assoclist),
 691         LUA_REG(nl80211,txpwrlist),
 692         LUA_REG(nl80211,scanlist),
 693         LUA_REG(nl80211,freqlist),
 694         LUA_REG(nl80211,countrylist),
 695         LUA_REG(nl80211,hwmodelist),
 696         LUA_REG(nl80211,encryption),
 697         LUA_REG(nl80211,mbssid_support),
 698         { NULL, NULL }
 699 };
 700 #endif
 701
 702 /* Wext table */
 703 static const luaL_reg R_wext[] = {
 704         LUA_REG(wext,channel),
 705         LUA_REG(wext,frequency),
 706         LUA_REG(wext,txpower),
 707         LUA_REG(wext,bitrate),
 708         LUA_REG(wext,signal),
 709         LUA_REG(wext,noise),
 710         LUA_REG(wext,quality),
 711         LUA_REG(wext,quality_max),
 712         LUA_REG(wext,mode),
 713         LUA_REG(wext,ssid),
 714         LUA_REG(wext,bssid),
 715         LUA_REG(wext,country),
 716         LUA_REG(wext,assoclist),
 717         LUA_REG(wext,txpwrlist),
 718         LUA_REG(wext,scanlist),
 719         LUA_REG(wext,freqlist),
 720         LUA_REG(wext,countrylist),
 721         LUA_REG(wext,hwmodelist),
 722         LUA_REG(wext,encryption),
 723         LUA_REG(wext,mbssid_support),
 724         { NULL, NULL }
 725 };
 726
 727 /* Common */
 728 static const luaL_reg R_common[] = {
 729         { "type", iwinfo_L_type },
 730         { "__gc", iwinfo_L__gc  },
 731         { NULL, NULL }
 732 };
 733
 734
 735 LUALIB_API int luaopen_iwinfo(lua_State *L) {
 736         luaL_register(L, IWINFO_META, R_common);
 737
 738 #ifdef USE_WL
 739         luaL_newmetatable(L, IWINFO_WL_META);
 740         luaL_register(L, NULL, R_wl);
 741         lua_pushvalue(L, -1);
 742         lua_setfield(L, -2, "__index");
 743         lua_setfield(L, -2, "wl");
 744 #endif
 745
 746 #ifdef USE_MADWIFI
 747         luaL_newmetatable(L, IWINFO_MADWIFI_META);
 748         luaL_register(L, NULL, R_madwifi);
 749         lua_pushvalue(L, -1);
 750         lua_setfield(L, -2, "__index");
 751         lua_setfield(L, -2, "madwifi");
 752 #endif
 753
 754 #ifdef USE_NL80211
 755         luaL_newmetatable(L, IWINFO_NL80211_META);
 756         luaL_register(L, NULL, R_nl80211);
 757         lua_pushvalue(L, -1);
 758         lua_setfield(L, -2, "__index");
 759         lua_setfield(L, -2, "nl80211");
 760 #endif
 761
 762         luaL_newmetatable(L, IWINFO_WEXT_META);
 763         luaL_register(L, NULL, R_wext);
 764         lua_pushvalue(L, -1);
 765         lua_setfield(L, -2, "__index");
 766         lua_setfield(L, -2, "wext");
 767
 768         return 1;
 769 }