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

Sources/iwinfo/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_GCMP)
 65                 pos += sprintf(pos, "GCMP, ");
 66 
 67         if (ciphers & IWINFO_CIPHER_WRAP)
 68                 pos += sprintf(pos, "WRAP, ");
 69 
 70         if (ciphers & IWINFO_CIPHER_AESOCB)
 71                 pos += sprintf(pos, "AES-OCB, ");
 72 
 73         if (ciphers & IWINFO_CIPHER_CKIP)
 74                 pos += sprintf(pos, "CKIP, ");
 75 
 76         if (!ciphers || (ciphers & IWINFO_CIPHER_NONE))
 77                 pos += sprintf(pos, "NONE, ");
 78 
 79         *(pos - 2) = 0;
 80 
 81         return str;
 82 }
 83 
 84 static char * iwinfo_crypto_print_suites(int suites)
 85 {
 86         static char str[64] = { 0 };
 87         char *pos = str;
 88 
 89         if (suites & IWINFO_KMGMT_PSK)
 90                 pos += sprintf(pos, "PSK/");
 91 
 92         if (suites & IWINFO_KMGMT_8021x)
 93                 pos += sprintf(pos, "802.1X/");
 94 
 95         if (suites & IWINFO_KMGMT_SAE)
 96                 pos += sprintf(pos, "SAE/");
 97 
 98         if (suites & IWINFO_KMGMT_OWE)
 99                 pos += sprintf(pos, "OWE/");
100 
101         if (!suites || (suites & IWINFO_KMGMT_NONE))
102                 pos += sprintf(pos, "NONE/");
103 
104         *(pos - 1) = 0;
105 
106         return str;
107 }
108 
109 static char * iwinfo_crypto_desc(struct iwinfo_crypto_entry *c)
110 {
111         static char desc[512] = { 0 };
112         char *pos = desc;
113         int i, n;
114 
115         if (c)
116         {
117                 if (c->enabled)
118                 {
119                         /* WEP */
120                         if (c->auth_algs && !c->wpa_version)
121                         {
122                                 if ((c->auth_algs & IWINFO_AUTH_OPEN) &&
123                                     (c->auth_algs & IWINFO_AUTH_SHARED))
124                                 {
125                                         sprintf(desc, "WEP Open/Shared (%s)",
126                                                 iwinfo_crypto_print_ciphers(c->pair_ciphers));
127                                 }
128                                 else if (c->auth_algs & IWINFO_AUTH_OPEN)
129                                 {
130                                         sprintf(desc, "WEP Open System (%s)",
131                                                 iwinfo_crypto_print_ciphers(c->pair_ciphers));
132                                 }
133                                 else if (c->auth_algs & IWINFO_AUTH_SHARED)
134                                 {
135                                         sprintf(desc, "WEP Shared Auth (%s)",
136                                                 iwinfo_crypto_print_ciphers(c->pair_ciphers));
137                                 }
138                         }
139 
140                         /* WPA */
141                         else if (c->wpa_version)
142                         {
143                                 for (i = 0, n = 0; i < 3; i++)
144                                         if (c->wpa_version & (1 << i))
145                                                 n++;
146 
147                                 if (n > 1)
148                                         pos += sprintf(pos, "mixed ");
149 
150                                 for (i = 0; i < 3; i++)
151                                         if (c->wpa_version & (1 << i))
152                                                 if (i)
153                                                         pos += sprintf(pos, "WPA%d/", i + 1);
154                                                 else
155                                                         pos += sprintf(pos, "WPA/");
156 
157                                 pos--;
158 
159                                 sprintf(pos, " %s (%s)",
160                                         iwinfo_crypto_print_suites(c->auth_suites),
161                                         iwinfo_crypto_print_ciphers(
162                                                 c->pair_ciphers | c->group_ciphers));
163                         }
164                         else
165                         {
166                                 sprintf(desc, "None");
167                         }
168                 }
169                 else
170                 {
171                         sprintf(desc, "None");
172                 }
173         }
174         else
175         {
176                 sprintf(desc, "Unknown");
177         }
178 
179         return desc;
180 }
181 
182 /* Build Lua table from crypto data */
183 static void iwinfo_L_cryptotable(lua_State *L, struct iwinfo_crypto_entry *c)
184 {
185         int i, j;
186 
187         lua_newtable(L);
188 
189         lua_pushboolean(L, c->enabled);
190         lua_setfield(L, -2, "enabled");
191 
192         lua_pushstring(L, iwinfo_crypto_desc(c));
193         lua_setfield(L, -2, "description");
194 
195         lua_pushboolean(L, (c->enabled && !c->wpa_version));
196         lua_setfield(L, -2, "wep");
197 
198         lua_pushinteger(L, c->wpa_version);
199         lua_setfield(L, -2, "wpa");
200 
201         lua_newtable(L);
202         for (i = 0, j = 1; i < ARRAY_SIZE(IWINFO_CIPHER_NAMES); i++)
203         {
204                 if (c->pair_ciphers & (1 << i))
205                 {
206                         lua_pushstring(L, IWINFO_CIPHER_NAMES[i]);
207                         lua_rawseti(L, -2, j++);
208                 }
209         }
210         lua_setfield(L, -2, "pair_ciphers");
211 
212         lua_newtable(L);
213         for (i = 0, j = 1; i < ARRAY_SIZE(IWINFO_CIPHER_NAMES); i++)
214         {
215                 if (c->group_ciphers & (1 << i))
216                 {
217                         lua_pushstring(L, IWINFO_CIPHER_NAMES[i]);
218                         lua_rawseti(L, -2, j++);
219                 }
220         }
221         lua_setfield(L, -2, "group_ciphers");
222 
223         lua_newtable(L);
224         for (i = 0, j = 1; i < ARRAY_SIZE(IWINFO_KMGMT_NAMES); i++)
225         {
226                 if (c->auth_suites & (1 << i))
227                 {
228                         lua_pushstring(L, IWINFO_KMGMT_NAMES[i]);
229                         lua_rawseti(L, -2, j++);
230                 }
231         }
232         lua_setfield(L, -2, "auth_suites");
233 
234         lua_newtable(L);
235         for (i = 0, j = 1; i < ARRAY_SIZE(IWINFO_AUTH_NAMES); i++)
236         {
237                 if (c->auth_algs & (1 << i))
238                 {
239                         lua_pushstring(L, IWINFO_AUTH_NAMES[i]);
240                         lua_rawseti(L, -2, j++);
241                 }
242         }
243         lua_setfield(L, -2, "auth_algs");
244 }
245 
246 
247 /* Wrapper for mode */
248 static int iwinfo_L_mode(lua_State *L, int (*func)(const char *, int *))
249 {
250         int mode;
251         const char *ifname = luaL_checkstring(L, 1);
252 
253         if ((*func)(ifname, &mode))
254                 mode = IWINFO_OPMODE_UNKNOWN;
255 
256         lua_pushstring(L, IWINFO_OPMODE_NAMES[mode]);
257         return 1;
258 }
259 
260 static void set_rateinfo(lua_State *L, struct iwinfo_rate_entry *r, bool rx)
261 {
262         lua_pushnumber(L, r->rate);
263         lua_setfield(L, -2, rx ? "rx_rate" : "tx_rate");
264 
265         lua_pushboolean(L, r->is_ht);
266         lua_setfield(L, -2, rx ? "rx_ht" : "tx_ht");
267 
268         lua_pushboolean(L, r->is_vht);
269         lua_setfield(L, -2, rx ? "rx_vht" : "tx_vht");
270 
271         lua_pushboolean(L, r->is_he);
272         lua_setfield(L, -2, rx ? "rx_he" : "tx_he");
273 
274         lua_pushnumber(L, r->mhz);
275         lua_setfield(L, -2, rx ? "rx_mhz" : "tx_mhz");
276 
277         if (r->is_ht)
278         {
279                 lua_pushboolean(L, r->is_40mhz);
280                 lua_setfield(L, -2, rx ? "rx_40mhz" : "tx_40mhz");
281 
282                 lua_pushnumber(L, r->mcs);
283                 lua_setfield(L, -2, rx ? "rx_mcs" : "tx_mcs");
284 
285                 lua_pushboolean(L, r->is_short_gi);
286                 lua_setfield(L, -2, rx ? "rx_short_gi" : "tx_short_gi");
287         }
288         else if (r->is_vht || r->is_he)
289         {
290                 lua_pushnumber(L, r->mcs);
291                 lua_setfield(L, -2, rx ? "rx_mcs" : "tx_mcs");
292 
293                 lua_pushnumber(L, r->nss);
294                 lua_setfield(L, -2, rx ? "rx_nss" : "tx_nss");
295 
296                 if (r->is_he) {
297                         lua_pushnumber(L, r->he_gi);
298                         lua_setfield(L, -2, rx ? "rx_he_gi" : "tx_he_gi");
299 
300                         lua_pushnumber(L, r->he_dcm);
301                         lua_setfield(L, -2, rx ? "rx_he_dcm" : "tx_he_dcm");
302                 }
303 
304                 if (r->is_vht) {
305                         lua_pushboolean(L, r->is_short_gi);
306                         lua_setfield(L, -2, rx ? "rx_short_gi" : "tx_short_gi");
307                 }
308         }
309 }
310 
311 /* Wrapper for assoclist */
312 static int iwinfo_L_assoclist(lua_State *L, int (*func)(const char *, char *, int *))
313 {
314         int i, len;
315         char rv[IWINFO_BUFSIZE];
316         char macstr[18];
317         const char *ifname = luaL_checkstring(L, 1);
318         struct iwinfo_assoclist_entry *e;
319 
320         lua_newtable(L);
321         memset(rv, 0, sizeof(rv));
322 
323         if (!(*func)(ifname, rv, &len))
324         {
325                 for (i = 0; i < len; i += sizeof(struct iwinfo_assoclist_entry))
326                 {
327                         e = (struct iwinfo_assoclist_entry *) &rv[i];
328 
329                         sprintf(macstr, "%02X:%02X:%02X:%02X:%02X:%02X",
330                                 e->mac[0], e->mac[1], e->mac[2],
331                                 e->mac[3], e->mac[4], e->mac[5]);
332 
333                         lua_newtable(L);
334 
335                         lua_pushnumber(L, e->signal);
336                         lua_setfield(L, -2, "signal");
337 
338                         lua_pushnumber(L, e->noise);
339                         lua_setfield(L, -2, "noise");
340 
341                         lua_pushnumber(L, e->inactive);
342                         lua_setfield(L, -2, "inactive");
343 
344                         lua_pushnumber(L, e->rx_packets);
345                         lua_setfield(L, -2, "rx_packets");
346 
347                         lua_pushnumber(L, e->tx_packets);
348                         lua_setfield(L, -2, "tx_packets");
349 
350                         set_rateinfo(L, &e->rx_rate, true);
351                         set_rateinfo(L, &e->tx_rate, false);
352 
353                         if (e->thr) {
354                                 lua_pushnumber(L, e->thr);
355                                 lua_setfield(L, -2, "expected_throughput");
356                         }
357 
358                         lua_setfield(L, -2, macstr);
359                 }
360         }
361 
362         return 1;
363 }
364 
365 /* Wrapper for tx power list */
366 static int iwinfo_L_txpwrlist(lua_State *L, int (*func)(const char *, char *, int *))
367 {
368         int i, x, len;
369         char rv[IWINFO_BUFSIZE];
370         const char *ifname = luaL_checkstring(L, 1);
371         struct iwinfo_txpwrlist_entry *e;
372 
373         memset(rv, 0, sizeof(rv));
374 
375         if (!(*func)(ifname, rv, &len))
376         {
377                 lua_newtable(L);
378 
379                 for (i = 0, x = 1; i < len; i += sizeof(struct iwinfo_txpwrlist_entry), x++)
380                 {
381                         e = (struct iwinfo_txpwrlist_entry *) &rv[i];
382 
383                         lua_newtable(L);
384 
385                         lua_pushnumber(L, e->mw);
386                         lua_setfield(L, -2, "mw");
387 
388                         lua_pushnumber(L, e->dbm);
389                         lua_setfield(L, -2, "dbm");
390 
391                         lua_rawseti(L, -2, x);
392                 }
393 
394                 return 1;
395         }
396 
397         return 0;
398 }
399 
400 /* Wrapper for scan list */
401 static int iwinfo_L_scanlist(lua_State *L, int (*func)(const char *, char *, int *))
402 {
403         int i, x, len = 0;
404         char rv[IWINFO_BUFSIZE];
405         char macstr[18];
406         const char *ifname = luaL_checkstring(L, 1);
407         struct iwinfo_scanlist_entry *e;
408 
409         lua_newtable(L);
410         memset(rv, 0, sizeof(rv));
411 
412         if (!(*func)(ifname, rv, &len))
413         {
414                 for (i = 0, x = 1; i < len; i += sizeof(struct iwinfo_scanlist_entry), x++)
415                 {
416                         e = (struct iwinfo_scanlist_entry *) &rv[i];
417 
418                         lua_newtable(L);
419 
420                         /* BSSID */
421                         sprintf(macstr, "%02X:%02X:%02X:%02X:%02X:%02X",
422                                 e->mac[0], e->mac[1], e->mac[2],
423                                 e->mac[3], e->mac[4], e->mac[5]);
424 
425                         lua_pushstring(L, macstr);
426                         lua_setfield(L, -2, "bssid");
427 
428                         /* ESSID */
429                         if (e->ssid[0])
430                         {
431                                 lua_pushstring(L, (char *) e->ssid);
432                                 lua_setfield(L, -2, "ssid");
433                         }
434 
435                         /* Channel */
436                         lua_pushinteger(L, e->channel);
437                         lua_setfield(L, -2, "channel");
438 
439                         /* Mode */
440                         lua_pushstring(L, IWINFO_OPMODE_NAMES[e->mode]);
441                         lua_setfield(L, -2, "mode");
442 
443                         /* Quality, Signal */
444                         lua_pushinteger(L, e->quality);
445                         lua_setfield(L, -2, "quality");
446 
447                         lua_pushinteger(L, e->quality_max);
448                         lua_setfield(L, -2, "quality_max");
449 
450                         lua_pushnumber(L, (e->signal - 0x100));
451                         lua_setfield(L, -2, "signal");
452 
453                         /* Crypto */
454                         iwinfo_L_cryptotable(L, &e->crypto);
455                         lua_setfield(L, -2, "encryption");
456 
457                         lua_rawseti(L, -2, x);
458                 }
459         }
460 
461         return 1;
462 }
463 
464 /* Wrapper for frequency list */
465 static int iwinfo_L_freqlist(lua_State *L, int (*func)(const char *, char *, int *))
466 {
467         int i, x, len;
468         char rv[IWINFO_BUFSIZE];
469         const char *ifname = luaL_checkstring(L, 1);
470         struct iwinfo_freqlist_entry *e;
471 
472         lua_newtable(L);
473         memset(rv, 0, sizeof(rv));
474 
475         if (!(*func)(ifname, rv, &len))
476         {
477                 for (i = 0, x = 1; i < len; i += sizeof(struct iwinfo_freqlist_entry), x++)
478                 {
479                         e = (struct iwinfo_freqlist_entry *) &rv[i];
480 
481                         lua_newtable(L);
482 
483                         /* MHz */
484                         lua_pushinteger(L, e->mhz);
485                         lua_setfield(L, -2, "mhz");
486 
487                         /* Channel */
488                         lua_pushinteger(L, e->channel);
489                         lua_setfield(L, -2, "channel");
490 
491                         /* Restricted (DFS/TPC/Radar) */
492                         lua_pushboolean(L, e->restricted);
493                         lua_setfield(L, -2, "restricted");
494 
495                         lua_rawseti(L, -2, x);
496                 }
497         }
498 
499         return 1;
500 }
501 
502 /* Wrapper for crypto settings */
503 static int iwinfo_L_encryption(lua_State *L, int (*func)(const char *, char *))
504 {
505         const char *ifname = luaL_checkstring(L, 1);
506         struct iwinfo_crypto_entry c = { 0 };
507 
508         if (!(*func)(ifname, (char *)&c))
509         {
510                 iwinfo_L_cryptotable(L, &c);
511                 return 1;
512         }
513 
514         lua_pushnil(L);
515         return 1;
516 }
517 
518 /* Wrapper for hwmode list */
519 static int iwinfo_L_hwmodelist(lua_State *L, int (*func)(const char *, int *))
520 {
521         const char *ifname = luaL_checkstring(L, 1);
522         int hwmodes = 0;
523 
524         if (!(*func)(ifname, &hwmodes))
525         {
526                 lua_newtable(L);
527 
528                 lua_pushboolean(L, hwmodes & IWINFO_80211_A);
529                 lua_setfield(L, -2, "a");
530 
531                 lua_pushboolean(L, hwmodes & IWINFO_80211_B);
532                 lua_setfield(L, -2, "b");
533 
534                 lua_pushboolean(L, hwmodes & IWINFO_80211_G);
535                 lua_setfield(L, -2, "g");
536 
537                 lua_pushboolean(L, hwmodes & IWINFO_80211_N);
538                 lua_setfield(L, -2, "n");
539 
540                 lua_pushboolean(L, hwmodes & IWINFO_80211_AC);
541                 lua_setfield(L, -2, "ac");
542 
543                 lua_pushboolean(L, hwmodes & IWINFO_80211_AD);
544                 lua_setfield(L, -2, "ad");
545 
546                 lua_pushboolean(L, hwmodes & IWINFO_80211_AX);
547                 lua_setfield(L, -2, "ax");
548 
549                 return 1;
550         }
551 
552         lua_pushnil(L);
553         return 1;
554 }
555 
556 /* Wrapper for htmode list */
557 static int iwinfo_L_htmodelist(lua_State *L, int (*func)(const char *, int *))
558 {
559         const char *ifname = luaL_checkstring(L, 1);
560         int i, htmodes = 0;
561 
562         if (!(*func)(ifname, &htmodes))
563         {
564                 lua_newtable(L);
565 
566                 for (i = 0; i < ARRAY_SIZE(IWINFO_HTMODE_NAMES); i++)
567                 {
568                         lua_pushboolean(L, htmodes & (1 << i));
569                         lua_setfield(L, -2, IWINFO_HTMODE_NAMES[i]);
570                 }
571 
572                 return 1;
573         }
574 
575         lua_pushnil(L);
576         return 1;
577 }
578 
579 /* Wrapper for mbssid_support */
580 static int iwinfo_L_mbssid_support(lua_State *L, int (*func)(const char *, int *))
581 {
582         const char *ifname = luaL_checkstring(L, 1);
583         int support = 0;
584 
585         if (!(*func)(ifname, &support))
586         {
587                 lua_pushboolean(L, support);
588                 return 1;
589         }
590 
591         lua_pushnil(L);
592         return 1;
593 }
594 
595 /* Wrapper for hardware_id */
596 static int iwinfo_L_hardware_id(lua_State *L, int (*func)(const char *, char *))
597 {
598         const char *ifname = luaL_checkstring(L, 1);
599         struct iwinfo_hardware_id ids;
600 
601         if (!(*func)(ifname, (char *)&ids))
602         {
603                 lua_newtable(L);
604 
605                 lua_pushnumber(L, ids.vendor_id);
606                 lua_setfield(L, -2, "vendor_id");
607 
608                 lua_pushnumber(L, ids.device_id);
609                 lua_setfield(L, -2, "device_id");
610 
611                 lua_pushnumber(L, ids.subsystem_vendor_id);
612                 lua_setfield(L, -2, "subsystem_vendor_id");
613 
614                 lua_pushnumber(L, ids.subsystem_device_id);
615                 lua_setfield(L, -2, "subsystem_device_id");
616         }
617         else
618         {
619                 lua_pushnil(L);
620         }
621 
622         return 1;
623 }
624 
625 /* Wrapper for country list */
626 static char * iwinfo_L_country_lookup(char *buf, int len, int iso3166)
627 {
628         int i;
629         struct iwinfo_country_entry *c;
630 
631         for (i = 0; i < len; i += sizeof(struct iwinfo_country_entry))
632         {
633                 c = (struct iwinfo_country_entry *) &buf[i];
634 
635                 if (c->iso3166 == iso3166)
636                         return c->ccode;
637         }
638 
639         return NULL;
640 }
641 
642 static int iwinfo_L_countrylist(lua_State *L, int (*func)(const char *, char *, int *))
643 {
644         int len, i;
645         char rv[IWINFO_BUFSIZE], alpha2[3];
646         char *ccode;
647         const char *ifname = luaL_checkstring(L, 1);
648         const struct iwinfo_iso3166_label *l;
649 
650         lua_newtable(L);
651         memset(rv, 0, sizeof(rv));
652 
653         if (!(*func)(ifname, rv, &len))
654         {
655                 for (l = IWINFO_ISO3166_NAMES, i = 1; l->iso3166; l++)
656                 {
657                         if ((ccode = iwinfo_L_country_lookup(rv, len, l->iso3166)) != NULL)
658                         {
659                                 sprintf(alpha2, "%c%c",
660                                         (l->iso3166 / 256), (l->iso3166 % 256));
661 
662                                 lua_newtable(L);
663 
664                                 lua_pushstring(L, alpha2);
665                                 lua_setfield(L, -2, "alpha2");
666 
667                                 lua_pushstring(L, ccode);
668                                 lua_setfield(L, -2, "ccode");
669 
670                                 lua_pushstring(L, l->name);
671                                 lua_setfield(L, -2, "name");
672 
673                                 lua_rawseti(L, -2, i++);
674                         }
675                 }
676         }
677 
678         return 1;
679 }
680 
681 
682 #ifdef USE_WL
683 /* Broadcom */
684 LUA_WRAP_INT_OP(wl,channel)
685 LUA_WRAP_INT_OP(wl,frequency)
686 LUA_WRAP_INT_OP(wl,frequency_offset)
687 LUA_WRAP_INT_OP(wl,txpower)
688 LUA_WRAP_INT_OP(wl,txpower_offset)
689 LUA_WRAP_INT_OP(wl,bitrate)
690 LUA_WRAP_INT_OP(wl,signal)
691 LUA_WRAP_INT_OP(wl,noise)
692 LUA_WRAP_INT_OP(wl,quality)
693 LUA_WRAP_INT_OP(wl,quality_max)
694 LUA_WRAP_STRING_OP(wl,ssid)
695 LUA_WRAP_STRING_OP(wl,bssid)
696 LUA_WRAP_STRING_OP(wl,country)
697 LUA_WRAP_STRING_OP(wl,hardware_name)
698 LUA_WRAP_STRING_OP(wl,phyname)
699 LUA_WRAP_STRUCT_OP(wl,mode)
700 LUA_WRAP_STRUCT_OP(wl,assoclist)
701 LUA_WRAP_STRUCT_OP(wl,txpwrlist)
702 LUA_WRAP_STRUCT_OP(wl,scanlist)
703 LUA_WRAP_STRUCT_OP(wl,freqlist)
704 LUA_WRAP_STRUCT_OP(wl,countrylist)
705 LUA_WRAP_STRUCT_OP(wl,hwmodelist)
706 LUA_WRAP_STRUCT_OP(wl,htmodelist)
707 LUA_WRAP_STRUCT_OP(wl,encryption)
708 LUA_WRAP_STRUCT_OP(wl,mbssid_support)
709 LUA_WRAP_STRUCT_OP(wl,hardware_id)
710 #endif
711 
712 #ifdef USE_MADWIFI
713 /* Madwifi */
714 LUA_WRAP_INT_OP(madwifi,channel)
715 LUA_WRAP_INT_OP(madwifi,frequency)
716 LUA_WRAP_INT_OP(madwifi,frequency_offset)
717 LUA_WRAP_INT_OP(madwifi,txpower)
718 LUA_WRAP_INT_OP(madwifi,txpower_offset)
719 LUA_WRAP_INT_OP(madwifi,bitrate)
720 LUA_WRAP_INT_OP(madwifi,signal)
721 LUA_WRAP_INT_OP(madwifi,noise)
722 LUA_WRAP_INT_OP(madwifi,quality)
723 LUA_WRAP_INT_OP(madwifi,quality_max)
724 LUA_WRAP_STRING_OP(madwifi,ssid)
725 LUA_WRAP_STRING_OP(madwifi,bssid)
726 LUA_WRAP_STRING_OP(madwifi,country)
727 LUA_WRAP_STRING_OP(madwifi,hardware_name)
728 LUA_WRAP_STRING_OP(madwifi,phyname)
729 LUA_WRAP_STRUCT_OP(madwifi,mode)
730 LUA_WRAP_STRUCT_OP(madwifi,assoclist)
731 LUA_WRAP_STRUCT_OP(madwifi,txpwrlist)
732 LUA_WRAP_STRUCT_OP(madwifi,scanlist)
733 LUA_WRAP_STRUCT_OP(madwifi,freqlist)
734 LUA_WRAP_STRUCT_OP(madwifi,countrylist)
735 LUA_WRAP_STRUCT_OP(madwifi,hwmodelist)
736 LUA_WRAP_STRUCT_OP(madwifi,htmodelist)
737 LUA_WRAP_STRUCT_OP(madwifi,encryption)
738 LUA_WRAP_STRUCT_OP(madwifi,mbssid_support)
739 LUA_WRAP_STRUCT_OP(madwifi,hardware_id)
740 #endif
741 
742 #ifdef USE_NL80211
743 /* NL80211 */
744 LUA_WRAP_INT_OP(nl80211,channel)
745 LUA_WRAP_INT_OP(nl80211,frequency)
746 LUA_WRAP_INT_OP(nl80211,frequency_offset)
747 LUA_WRAP_INT_OP(nl80211,txpower)
748 LUA_WRAP_INT_OP(nl80211,txpower_offset)
749 LUA_WRAP_INT_OP(nl80211,bitrate)
750 LUA_WRAP_INT_OP(nl80211,signal)
751 LUA_WRAP_INT_OP(nl80211,noise)
752 LUA_WRAP_INT_OP(nl80211,quality)
753 LUA_WRAP_INT_OP(nl80211,quality_max)
754 LUA_WRAP_STRING_OP(nl80211,ssid)
755 LUA_WRAP_STRING_OP(nl80211,bssid)
756 LUA_WRAP_STRING_OP(nl80211,country)
757 LUA_WRAP_STRING_OP(nl80211,hardware_name)
758 LUA_WRAP_STRING_OP(nl80211,phyname)
759 LUA_WRAP_STRUCT_OP(nl80211,mode)
760 LUA_WRAP_STRUCT_OP(nl80211,assoclist)
761 LUA_WRAP_STRUCT_OP(nl80211,txpwrlist)
762 LUA_WRAP_STRUCT_OP(nl80211,scanlist)
763 LUA_WRAP_STRUCT_OP(nl80211,freqlist)
764 LUA_WRAP_STRUCT_OP(nl80211,countrylist)
765 LUA_WRAP_STRUCT_OP(nl80211,hwmodelist)
766 LUA_WRAP_STRUCT_OP(nl80211,htmodelist)
767 LUA_WRAP_STRUCT_OP(nl80211,encryption)
768 LUA_WRAP_STRUCT_OP(nl80211,mbssid_support)
769 LUA_WRAP_STRUCT_OP(nl80211,hardware_id)
770 #endif
771 
772 /* Wext */
773 LUA_WRAP_INT_OP(wext,channel)
774 LUA_WRAP_INT_OP(wext,frequency)
775 LUA_WRAP_INT_OP(wext,frequency_offset)
776 LUA_WRAP_INT_OP(wext,txpower)
777 LUA_WRAP_INT_OP(wext,txpower_offset)
778 LUA_WRAP_INT_OP(wext,bitrate)
779 LUA_WRAP_INT_OP(wext,signal)
780 LUA_WRAP_INT_OP(wext,noise)
781 LUA_WRAP_INT_OP(wext,quality)
782 LUA_WRAP_INT_OP(wext,quality_max)
783 LUA_WRAP_STRING_OP(wext,ssid)
784 LUA_WRAP_STRING_OP(wext,bssid)
785 LUA_WRAP_STRING_OP(wext,country)
786 LUA_WRAP_STRING_OP(wext,hardware_name)
787 LUA_WRAP_STRING_OP(wext,phyname)
788 LUA_WRAP_STRUCT_OP(wext,mode)
789 LUA_WRAP_STRUCT_OP(wext,assoclist)
790 LUA_WRAP_STRUCT_OP(wext,txpwrlist)
791 LUA_WRAP_STRUCT_OP(wext,scanlist)
792 LUA_WRAP_STRUCT_OP(wext,freqlist)
793 LUA_WRAP_STRUCT_OP(wext,countrylist)
794 LUA_WRAP_STRUCT_OP(wext,hwmodelist)
795 LUA_WRAP_STRUCT_OP(wext,htmodelist)
796 LUA_WRAP_STRUCT_OP(wext,encryption)
797 LUA_WRAP_STRUCT_OP(wext,mbssid_support)
798 LUA_WRAP_STRUCT_OP(wext,hardware_id)
799 
800 #ifdef USE_WL
801 /* Broadcom table */
802 static const luaL_reg R_wl[] = {
803         LUA_REG(wl,channel),
804         LUA_REG(wl,frequency),
805         LUA_REG(wl,frequency_offset),
806         LUA_REG(wl,txpower),
807         LUA_REG(wl,txpower_offset),
808         LUA_REG(wl,bitrate),
809         LUA_REG(wl,signal),
810         LUA_REG(wl,noise),
811         LUA_REG(wl,quality),
812         LUA_REG(wl,quality_max),
813         LUA_REG(wl,mode),
814         LUA_REG(wl,ssid),
815         LUA_REG(wl,bssid),
816         LUA_REG(wl,country),
817         LUA_REG(wl,assoclist),
818         LUA_REG(wl,txpwrlist),
819         LUA_REG(wl,scanlist),
820         LUA_REG(wl,freqlist),
821         LUA_REG(wl,countrylist),
822         LUA_REG(wl,hwmodelist),
823         LUA_REG(wl,htmodelist),
824         LUA_REG(wl,encryption),
825         LUA_REG(wl,mbssid_support),
826         LUA_REG(wl,hardware_id),
827         LUA_REG(wl,hardware_name),
828         LUA_REG(wl,phyname),
829         { NULL, NULL }
830 };
831 #endif
832 
833 #ifdef USE_MADWIFI
834 /* Madwifi table */
835 static const luaL_reg R_madwifi[] = {
836         LUA_REG(madwifi,channel),
837         LUA_REG(madwifi,frequency),
838         LUA_REG(madwifi,frequency_offset),
839         LUA_REG(madwifi,txpower),
840         LUA_REG(madwifi,txpower_offset),
841         LUA_REG(madwifi,bitrate),
842         LUA_REG(madwifi,signal),
843         LUA_REG(madwifi,noise),
844         LUA_REG(madwifi,quality),
845         LUA_REG(madwifi,quality_max),
846         LUA_REG(madwifi,mode),
847         LUA_REG(madwifi,ssid),
848         LUA_REG(madwifi,bssid),
849         LUA_REG(madwifi,country),
850         LUA_REG(madwifi,assoclist),
851         LUA_REG(madwifi,txpwrlist),
852         LUA_REG(madwifi,scanlist),
853         LUA_REG(madwifi,freqlist),
854         LUA_REG(madwifi,countrylist),
855         LUA_REG(madwifi,hwmodelist),
856         LUA_REG(madwifi,htmodelist),
857         LUA_REG(madwifi,encryption),
858         LUA_REG(madwifi,mbssid_support),
859         LUA_REG(madwifi,hardware_id),
860         LUA_REG(madwifi,hardware_name),
861         LUA_REG(madwifi,phyname),
862         { NULL, NULL }
863 };
864 #endif
865 
866 #ifdef USE_NL80211
867 /* NL80211 table */
868 static const luaL_reg R_nl80211[] = {
869         LUA_REG(nl80211,channel),
870         LUA_REG(nl80211,frequency),
871         LUA_REG(nl80211,frequency_offset),
872         LUA_REG(nl80211,txpower),
873         LUA_REG(nl80211,txpower_offset),
874         LUA_REG(nl80211,bitrate),
875         LUA_REG(nl80211,signal),
876         LUA_REG(nl80211,noise),
877         LUA_REG(nl80211,quality),
878         LUA_REG(nl80211,quality_max),
879         LUA_REG(nl80211,mode),
880         LUA_REG(nl80211,ssid),
881         LUA_REG(nl80211,bssid),
882         LUA_REG(nl80211,country),
883         LUA_REG(nl80211,assoclist),
884         LUA_REG(nl80211,txpwrlist),
885         LUA_REG(nl80211,scanlist),
886         LUA_REG(nl80211,freqlist),
887         LUA_REG(nl80211,countrylist),
888         LUA_REG(nl80211,hwmodelist),
889         LUA_REG(nl80211,htmodelist),
890         LUA_REG(nl80211,encryption),
891         LUA_REG(nl80211,mbssid_support),
892         LUA_REG(nl80211,hardware_id),
893         LUA_REG(nl80211,hardware_name),
894         LUA_REG(nl80211,phyname),
895         { NULL, NULL }
896 };
897 #endif
898 
899 /* Wext table */
900 static const luaL_reg R_wext[] = {
901         LUA_REG(wext,channel),
902         LUA_REG(wext,frequency),
903         LUA_REG(wext,frequency_offset),
904         LUA_REG(wext,txpower),
905         LUA_REG(wext,txpower_offset),
906         LUA_REG(wext,bitrate),
907         LUA_REG(wext,signal),
908         LUA_REG(wext,noise),
909         LUA_REG(wext,quality),
910         LUA_REG(wext,quality_max),
911         LUA_REG(wext,mode),
912         LUA_REG(wext,ssid),
913         LUA_REG(wext,bssid),
914         LUA_REG(wext,country),
915         LUA_REG(wext,assoclist),
916         LUA_REG(wext,txpwrlist),
917         LUA_REG(wext,scanlist),
918         LUA_REG(wext,freqlist),
919         LUA_REG(wext,countrylist),
920         LUA_REG(wext,hwmodelist),
921         LUA_REG(wext,htmodelist),
922         LUA_REG(wext,encryption),
923         LUA_REG(wext,mbssid_support),
924         LUA_REG(wext,hardware_id),
925         LUA_REG(wext,hardware_name),
926         LUA_REG(wext,phyname),
927         { NULL, NULL }
928 };
929 
930 /* Common */
931 static const luaL_reg R_common[] = {
932         { "type", iwinfo_L_type },
933         { "__gc", iwinfo_L__gc  },
934         { NULL, NULL }
935 };
936 
937 
938 LUALIB_API int luaopen_iwinfo(lua_State *L) {
939         luaL_register(L, IWINFO_META, R_common);
940 
941 #ifdef USE_WL
942         luaL_newmetatable(L, IWINFO_WL_META);
943         luaL_register(L, NULL, R_common);
944         luaL_register(L, NULL, R_wl);
945         lua_pushvalue(L, -1);
946         lua_setfield(L, -2, "__index");
947         lua_setfield(L, -2, "wl");
948 #endif
949 
950 #ifdef USE_MADWIFI
951         luaL_newmetatable(L, IWINFO_MADWIFI_META);
952         luaL_register(L, NULL, R_common);
953         luaL_register(L, NULL, R_madwifi);
954         lua_pushvalue(L, -1);
955         lua_setfield(L, -2, "__index");
956         lua_setfield(L, -2, "madwifi");
957 #endif
958 
959 #ifdef USE_NL80211
960         luaL_newmetatable(L, IWINFO_NL80211_META);
961         luaL_register(L, NULL, R_common);
962         luaL_register(L, NULL, R_nl80211);
963         lua_pushvalue(L, -1);
964         lua_setfield(L, -2, "__index");
965         lua_setfield(L, -2, "nl80211");
966 #endif
967 
968         luaL_newmetatable(L, IWINFO_WEXT_META);
969         luaL_register(L, NULL, R_common);
970         luaL_register(L, NULL, R_wext);
971         lua_pushvalue(L, -1);
972         lua_setfield(L, -2, "__index");
973         lua_setfield(L, -2, "wext");
974 
975         return 1;
976 }
977 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt