Root/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 */
23static 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 */
37static 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
47static 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
81static 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
100static 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 */
174static 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 mode */
239static int iwinfo_L_mode(lua_State *L, int (*func)(const char *, int *))
240{
241    int mode;
242    const char *ifname = luaL_checkstring(L, 1);
243
244    if ((*func)(ifname, &mode))
245        mode = IWINFO_OPMODE_UNKNOWN;
246
247    lua_pushstring(L, IWINFO_OPMODE_NAMES[mode]);
248    return 1;
249}
250
251/* Wrapper for assoclist */
252static int iwinfo_L_assoclist(lua_State *L, int (*func)(const char *, char *, int *))
253{
254    int i, len;
255    char rv[IWINFO_BUFSIZE];
256    char macstr[18];
257    const char *ifname = luaL_checkstring(L, 1);
258    struct iwinfo_assoclist_entry *e;
259
260    lua_newtable(L);
261    memset(rv, 0, sizeof(rv));
262
263    if (!(*func)(ifname, rv, &len))
264    {
265        for (i = 0; i < len; i += sizeof(struct iwinfo_assoclist_entry))
266        {
267            e = (struct iwinfo_assoclist_entry *) &rv[i];
268
269            sprintf(macstr, "%02X:%02X:%02X:%02X:%02X:%02X",
270                e->mac[0], e->mac[1], e->mac[2],
271                e->mac[3], e->mac[4], e->mac[5]);
272
273            lua_newtable(L);
274
275            lua_pushnumber(L, e->signal);
276            lua_setfield(L, -2, "signal");
277
278            lua_pushnumber(L, e->noise);
279            lua_setfield(L, -2, "noise");
280
281            lua_pushnumber(L, e->inactive);
282            lua_setfield(L, -2, "inactive");
283
284            lua_pushnumber(L, e->rx_packets);
285            lua_setfield(L, -2, "rx_packets");
286
287            lua_pushnumber(L, e->tx_packets);
288            lua_setfield(L, -2, "tx_packets");
289
290            lua_pushnumber(L, e->rx_rate.rate);
291            lua_setfield(L, -2, "rx_rate");
292
293            lua_pushnumber(L, e->tx_rate.rate);
294            lua_setfield(L, -2, "tx_rate");
295
296            if (e->rx_rate.mcs >= 0)
297            {
298                lua_pushnumber(L, e->rx_rate.mcs);
299                lua_setfield(L, -2, "rx_mcs");
300
301                lua_pushboolean(L, e->rx_rate.is_40mhz);
302                lua_setfield(L, -2, "rx_40mhz");
303
304                lua_pushboolean(L, e->rx_rate.is_short_gi);
305                lua_setfield(L, -2, "rx_short_gi");
306            }
307
308            if (e->tx_rate.mcs >= 0)
309            {
310                lua_pushnumber(L, e->tx_rate.mcs);
311                lua_setfield(L, -2, "tx_mcs");
312
313                lua_pushboolean(L, e->tx_rate.is_40mhz);
314                lua_setfield(L, -2, "tx_40mhz");
315
316                lua_pushboolean(L, e->tx_rate.is_short_gi);
317                lua_setfield(L, -2, "tx_short_gi");
318            }
319
320            lua_setfield(L, -2, macstr);
321        }
322    }
323
324    return 1;
325}
326
327/* Wrapper for tx power list */
328static int iwinfo_L_txpwrlist(lua_State *L, int (*func)(const char *, char *, int *))
329{
330    int i, x, len;
331    char rv[IWINFO_BUFSIZE];
332    const char *ifname = luaL_checkstring(L, 1);
333    struct iwinfo_txpwrlist_entry *e;
334
335    lua_newtable(L);
336    memset(rv, 0, sizeof(rv));
337
338    if (!(*func)(ifname, rv, &len))
339    {
340        for (i = 0, x = 1; i < len; i += sizeof(struct iwinfo_txpwrlist_entry), x++)
341        {
342            e = (struct iwinfo_txpwrlist_entry *) &rv[i];
343
344            lua_newtable(L);
345
346            lua_pushnumber(L, e->mw);
347            lua_setfield(L, -2, "mw");
348
349            lua_pushnumber(L, e->dbm);
350            lua_setfield(L, -2, "dbm");
351
352            lua_rawseti(L, -2, x);
353        }
354    }
355
356    return 1;
357}
358
359/* Wrapper for scan list */
360static int iwinfo_L_scanlist(lua_State *L, int (*func)(const char *, char *, int *))
361{
362    int i, x, len;
363    char rv[IWINFO_BUFSIZE];
364    char macstr[18];
365    const char *ifname = luaL_checkstring(L, 1);
366    struct iwinfo_scanlist_entry *e;
367
368    lua_newtable(L);
369    memset(rv, 0, sizeof(rv));
370
371    if (!(*func)(ifname, rv, &len))
372    {
373        for (i = 0, x = 1; i < len; i += sizeof(struct iwinfo_scanlist_entry), x++)
374        {
375            e = (struct iwinfo_scanlist_entry *) &rv[i];
376
377            lua_newtable(L);
378
379            /* BSSID */
380            sprintf(macstr, "%02X:%02X:%02X:%02X:%02X:%02X",
381                e->mac[0], e->mac[1], e->mac[2],
382                e->mac[3], e->mac[4], e->mac[5]);
383
384            lua_pushstring(L, macstr);
385            lua_setfield(L, -2, "bssid");
386
387            /* ESSID */
388            if (e->ssid[0])
389            {
390                lua_pushstring(L, (char *) e->ssid);
391                lua_setfield(L, -2, "ssid");
392            }
393
394            /* Channel */
395            lua_pushinteger(L, e->channel);
396            lua_setfield(L, -2, "channel");
397
398            /* Mode */
399            lua_pushstring(L, IWINFO_OPMODE_NAMES[e->mode]);
400            lua_setfield(L, -2, "mode");
401
402            /* Quality, Signal */
403            lua_pushinteger(L, e->quality);
404            lua_setfield(L, -2, "quality");
405
406            lua_pushinteger(L, e->quality_max);
407            lua_setfield(L, -2, "quality_max");
408
409            lua_pushnumber(L, (e->signal - 0x100));
410            lua_setfield(L, -2, "signal");
411
412            /* Crypto */
413            iwinfo_L_cryptotable(L, &e->crypto);
414            lua_setfield(L, -2, "encryption");
415
416            lua_rawseti(L, -2, x);
417        }
418    }
419
420    return 1;
421}
422
423/* Wrapper for frequency list */
424static int iwinfo_L_freqlist(lua_State *L, int (*func)(const char *, char *, int *))
425{
426    int i, x, len;
427    char rv[IWINFO_BUFSIZE];
428    const char *ifname = luaL_checkstring(L, 1);
429    struct iwinfo_freqlist_entry *e;
430
431    lua_newtable(L);
432    memset(rv, 0, sizeof(rv));
433
434    if (!(*func)(ifname, rv, &len))
435    {
436        for (i = 0, x = 1; i < len; i += sizeof(struct iwinfo_freqlist_entry), x++)
437        {
438            e = (struct iwinfo_freqlist_entry *) &rv[i];
439
440            lua_newtable(L);
441
442            /* MHz */
443            lua_pushinteger(L, e->mhz);
444            lua_setfield(L, -2, "mhz");
445
446            /* Channel */
447            lua_pushinteger(L, e->channel);
448            lua_setfield(L, -2, "channel");
449
450            /* Restricted (DFS/TPC/Radar) */
451            lua_pushboolean(L, e->restricted);
452            lua_setfield(L, -2, "restricted");
453
454            lua_rawseti(L, -2, x);
455        }
456    }
457
458    return 1;
459}
460
461/* Wrapper for crypto settings */
462static int iwinfo_L_encryption(lua_State *L, int (*func)(const char *, char *))
463{
464    const char *ifname = luaL_checkstring(L, 1);
465    struct iwinfo_crypto_entry c = { 0 };
466
467    if (!(*func)(ifname, (char *)&c))
468    {
469        iwinfo_L_cryptotable(L, &c);
470        return 1;
471    }
472
473    lua_pushnil(L);
474    return 1;
475}
476
477/* Wrapper for hwmode list */
478static int iwinfo_L_hwmodelist(lua_State *L, int (*func)(const char *, int *))
479{
480    const char *ifname = luaL_checkstring(L, 1);
481    int hwmodes = 0;
482
483    if (!(*func)(ifname, &hwmodes))
484    {
485        lua_newtable(L);
486
487        lua_pushboolean(L, hwmodes & IWINFO_80211_A);
488        lua_setfield(L, -2, "a");
489
490        lua_pushboolean(L, hwmodes & IWINFO_80211_B);
491        lua_setfield(L, -2, "b");
492
493        lua_pushboolean(L, hwmodes & IWINFO_80211_G);
494        lua_setfield(L, -2, "g");
495
496        lua_pushboolean(L, hwmodes & IWINFO_80211_N);
497        lua_setfield(L, -2, "n");
498
499        return 1;
500    }
501
502    lua_pushnil(L);
503    return 1;
504}
505
506/* Wrapper for mbssid_support */
507static int iwinfo_L_mbssid_support(lua_State *L, int (*func)(const char *, int *))
508{
509    const char *ifname = luaL_checkstring(L, 1);
510    int support = 0;
511
512    if (!(*func)(ifname, &support))
513    {
514        lua_pushboolean(L, support);
515        return 1;
516    }
517
518    lua_pushnil(L);
519    return 1;
520}
521
522/* Wrapper for hardware_id */
523static int iwinfo_L_hardware_id(lua_State *L, int (*func)(const char *, char *))
524{
525    const char *ifname = luaL_checkstring(L, 1);
526    struct iwinfo_hardware_id ids;
527
528    if (!(*func)(ifname, (char *)&ids))
529    {
530        lua_newtable(L);
531
532        lua_pushnumber(L, ids.vendor_id);
533        lua_setfield(L, -2, "vendor_id");
534
535        lua_pushnumber(L, ids.device_id);
536        lua_setfield(L, -2, "device_id");
537
538        lua_pushnumber(L, ids.subsystem_vendor_id);
539        lua_setfield(L, -2, "subsystem_vendor_id");
540
541        lua_pushnumber(L, ids.subsystem_device_id);
542        lua_setfield(L, -2, "subsystem_device_id");
543    }
544    else
545    {
546        lua_pushnil(L);
547    }
548
549    return 1;
550}
551
552/* Wrapper for country list */
553static char * iwinfo_L_country_lookup(char *buf, int len, int iso3166)
554{
555    int i;
556    struct iwinfo_country_entry *c;
557
558    for (i = 0; i < len; i += sizeof(struct iwinfo_country_entry))
559    {
560        c = (struct iwinfo_country_entry *) &buf[i];
561
562        if (c->iso3166 == iso3166)
563            return c->ccode;
564    }
565
566    return NULL;
567}
568
569static int iwinfo_L_countrylist(lua_State *L, int (*func)(const char *, char *, int *))
570{
571    int len, i, j;
572    char rv[IWINFO_BUFSIZE], alpha2[3];
573    char *ccode;
574    const char *ifname = luaL_checkstring(L, 1);
575    const struct iwinfo_iso3166_label *l;
576
577    lua_newtable(L);
578    memset(rv, 0, sizeof(rv));
579
580    if (!(*func)(ifname, rv, &len))
581    {
582        for (l = IWINFO_ISO3166_NAMES, j = 1; l->iso3166; l++)
583        {
584            if ((ccode = iwinfo_L_country_lookup(rv, len, l->iso3166)) != NULL)
585            {
586                sprintf(alpha2, "%c%c",
587                    (l->iso3166 / 256), (l->iso3166 % 256));
588
589                lua_newtable(L);
590
591                lua_pushstring(L, alpha2);
592                lua_setfield(L, -2, "alpha2");
593
594                lua_pushstring(L, ccode);
595                lua_setfield(L, -2, "ccode");
596
597                lua_pushstring(L, l->name);
598                lua_setfield(L, -2, "name");
599
600                lua_rawseti(L, -2, j++);
601            }
602        }
603    }
604
605    return 1;
606}
607
608
609#ifdef USE_WL
610/* Broadcom */
611LUA_WRAP_INT(wl,channel)
612LUA_WRAP_INT(wl,frequency)
613LUA_WRAP_INT(wl,frequency_offset)
614LUA_WRAP_INT(wl,txpower)
615LUA_WRAP_INT(wl,txpower_offset)
616LUA_WRAP_INT(wl,bitrate)
617LUA_WRAP_INT(wl,signal)
618LUA_WRAP_INT(wl,noise)
619LUA_WRAP_INT(wl,quality)
620LUA_WRAP_INT(wl,quality_max)
621LUA_WRAP_STRING(wl,ssid)
622LUA_WRAP_STRING(wl,bssid)
623LUA_WRAP_STRING(wl,country)
624LUA_WRAP_STRING(wl,hardware_name)
625LUA_WRAP_STRUCT(wl,mode)
626LUA_WRAP_STRUCT(wl,assoclist)
627LUA_WRAP_STRUCT(wl,txpwrlist)
628LUA_WRAP_STRUCT(wl,scanlist)
629LUA_WRAP_STRUCT(wl,freqlist)
630LUA_WRAP_STRUCT(wl,countrylist)
631LUA_WRAP_STRUCT(wl,hwmodelist)
632LUA_WRAP_STRUCT(wl,encryption)
633LUA_WRAP_STRUCT(wl,mbssid_support)
634LUA_WRAP_STRUCT(wl,hardware_id)
635#endif
636
637#ifdef USE_MADWIFI
638/* Madwifi */
639LUA_WRAP_INT(madwifi,channel)
640LUA_WRAP_INT(madwifi,frequency)
641LUA_WRAP_INT(madwifi,frequency_offset)
642LUA_WRAP_INT(madwifi,txpower)
643LUA_WRAP_INT(madwifi,txpower_offset)
644LUA_WRAP_INT(madwifi,bitrate)
645LUA_WRAP_INT(madwifi,signal)
646LUA_WRAP_INT(madwifi,noise)
647LUA_WRAP_INT(madwifi,quality)
648LUA_WRAP_INT(madwifi,quality_max)
649LUA_WRAP_STRING(madwifi,ssid)
650LUA_WRAP_STRING(madwifi,bssid)
651LUA_WRAP_STRING(madwifi,country)
652LUA_WRAP_STRING(madwifi,hardware_name)
653LUA_WRAP_STRUCT(madwifi,mode)
654LUA_WRAP_STRUCT(madwifi,assoclist)
655LUA_WRAP_STRUCT(madwifi,txpwrlist)
656LUA_WRAP_STRUCT(madwifi,scanlist)
657LUA_WRAP_STRUCT(madwifi,freqlist)
658LUA_WRAP_STRUCT(madwifi,countrylist)
659LUA_WRAP_STRUCT(madwifi,hwmodelist)
660LUA_WRAP_STRUCT(madwifi,encryption)
661LUA_WRAP_STRUCT(madwifi,mbssid_support)
662LUA_WRAP_STRUCT(madwifi,hardware_id)
663#endif
664
665#ifdef USE_NL80211
666/* NL80211 */
667LUA_WRAP_INT(nl80211,channel)
668LUA_WRAP_INT(nl80211,frequency)
669LUA_WRAP_INT(nl80211,frequency_offset)
670LUA_WRAP_INT(nl80211,txpower)
671LUA_WRAP_INT(nl80211,txpower_offset)
672LUA_WRAP_INT(nl80211,bitrate)
673LUA_WRAP_INT(nl80211,signal)
674LUA_WRAP_INT(nl80211,noise)
675LUA_WRAP_INT(nl80211,quality)
676LUA_WRAP_INT(nl80211,quality_max)
677LUA_WRAP_STRING(nl80211,ssid)
678LUA_WRAP_STRING(nl80211,bssid)
679LUA_WRAP_STRING(nl80211,country)
680LUA_WRAP_STRING(nl80211,hardware_name)
681LUA_WRAP_STRUCT(nl80211,mode)
682LUA_WRAP_STRUCT(nl80211,assoclist)
683LUA_WRAP_STRUCT(nl80211,txpwrlist)
684LUA_WRAP_STRUCT(nl80211,scanlist)
685LUA_WRAP_STRUCT(nl80211,freqlist)
686LUA_WRAP_STRUCT(nl80211,countrylist)
687LUA_WRAP_STRUCT(nl80211,hwmodelist)
688LUA_WRAP_STRUCT(nl80211,encryption)
689LUA_WRAP_STRUCT(nl80211,mbssid_support)
690LUA_WRAP_STRUCT(nl80211,hardware_id)
691#endif
692
693/* Wext */
694LUA_WRAP_INT(wext,channel)
695LUA_WRAP_INT(wext,frequency)
696LUA_WRAP_INT(wext,frequency_offset)
697LUA_WRAP_INT(wext,txpower)
698LUA_WRAP_INT(wext,txpower_offset)
699LUA_WRAP_INT(wext,bitrate)
700LUA_WRAP_INT(wext,signal)
701LUA_WRAP_INT(wext,noise)
702LUA_WRAP_INT(wext,quality)
703LUA_WRAP_INT(wext,quality_max)
704LUA_WRAP_STRING(wext,ssid)
705LUA_WRAP_STRING(wext,bssid)
706LUA_WRAP_STRING(wext,country)
707LUA_WRAP_STRING(wext,hardware_name)
708LUA_WRAP_STRUCT(wext,mode)
709LUA_WRAP_STRUCT(wext,assoclist)
710LUA_WRAP_STRUCT(wext,txpwrlist)
711LUA_WRAP_STRUCT(wext,scanlist)
712LUA_WRAP_STRUCT(wext,freqlist)
713LUA_WRAP_STRUCT(wext,countrylist)
714LUA_WRAP_STRUCT(wext,hwmodelist)
715LUA_WRAP_STRUCT(wext,encryption)
716LUA_WRAP_STRUCT(wext,mbssid_support)
717LUA_WRAP_STRUCT(wext,hardware_id)
718
719#ifdef USE_WL
720/* Broadcom table */
721static const luaL_reg R_wl[] = {
722    LUA_REG(wl,channel),
723    LUA_REG(wl,frequency),
724    LUA_REG(wl,frequency_offset),
725    LUA_REG(wl,txpower),
726    LUA_REG(wl,txpower_offset),
727    LUA_REG(wl,bitrate),
728    LUA_REG(wl,signal),
729    LUA_REG(wl,noise),
730    LUA_REG(wl,quality),
731    LUA_REG(wl,quality_max),
732    LUA_REG(wl,mode),
733    LUA_REG(wl,ssid),
734    LUA_REG(wl,bssid),
735    LUA_REG(wl,country),
736    LUA_REG(wl,assoclist),
737    LUA_REG(wl,txpwrlist),
738    LUA_REG(wl,scanlist),
739    LUA_REG(wl,freqlist),
740    LUA_REG(wl,countrylist),
741    LUA_REG(wl,hwmodelist),
742    LUA_REG(wl,encryption),
743    LUA_REG(wl,mbssid_support),
744    LUA_REG(wl,hardware_id),
745    LUA_REG(wl,hardware_name),
746    { NULL, NULL }
747};
748#endif
749
750#ifdef USE_MADWIFI
751/* Madwifi table */
752static const luaL_reg R_madwifi[] = {
753    LUA_REG(madwifi,channel),
754    LUA_REG(madwifi,frequency),
755    LUA_REG(madwifi,frequency_offset),
756    LUA_REG(madwifi,txpower),
757    LUA_REG(madwifi,txpower_offset),
758    LUA_REG(madwifi,bitrate),
759    LUA_REG(madwifi,signal),
760    LUA_REG(madwifi,noise),
761    LUA_REG(madwifi,quality),
762    LUA_REG(madwifi,quality_max),
763    LUA_REG(madwifi,mode),
764    LUA_REG(madwifi,ssid),
765    LUA_REG(madwifi,bssid),
766    LUA_REG(madwifi,country),
767    LUA_REG(madwifi,assoclist),
768    LUA_REG(madwifi,txpwrlist),
769    LUA_REG(madwifi,scanlist),
770    LUA_REG(madwifi,freqlist),
771    LUA_REG(madwifi,countrylist),
772    LUA_REG(madwifi,hwmodelist),
773    LUA_REG(madwifi,encryption),
774    LUA_REG(madwifi,mbssid_support),
775    LUA_REG(madwifi,hardware_id),
776    LUA_REG(madwifi,hardware_name),
777    { NULL, NULL }
778};
779#endif
780
781#ifdef USE_NL80211
782/* NL80211 table */
783static const luaL_reg R_nl80211[] = {
784    LUA_REG(nl80211,channel),
785    LUA_REG(nl80211,frequency),
786    LUA_REG(nl80211,frequency_offset),
787    LUA_REG(nl80211,txpower),
788    LUA_REG(nl80211,txpower_offset),
789    LUA_REG(nl80211,bitrate),
790    LUA_REG(nl80211,signal),
791    LUA_REG(nl80211,noise),
792    LUA_REG(nl80211,quality),
793    LUA_REG(nl80211,quality_max),
794    LUA_REG(nl80211,mode),
795    LUA_REG(nl80211,ssid),
796    LUA_REG(nl80211,bssid),
797    LUA_REG(nl80211,country),
798    LUA_REG(nl80211,assoclist),
799    LUA_REG(nl80211,txpwrlist),
800    LUA_REG(nl80211,scanlist),
801    LUA_REG(nl80211,freqlist),
802    LUA_REG(nl80211,countrylist),
803    LUA_REG(nl80211,hwmodelist),
804    LUA_REG(nl80211,encryption),
805    LUA_REG(nl80211,mbssid_support),
806    LUA_REG(nl80211,hardware_id),
807    LUA_REG(nl80211,hardware_name),
808    { NULL, NULL }
809};
810#endif
811
812/* Wext table */
813static const luaL_reg R_wext[] = {
814    LUA_REG(wext,channel),
815    LUA_REG(wext,frequency),
816    LUA_REG(wext,frequency_offset),
817    LUA_REG(wext,txpower),
818    LUA_REG(wext,txpower_offset),
819    LUA_REG(wext,bitrate),
820    LUA_REG(wext,signal),
821    LUA_REG(wext,noise),
822    LUA_REG(wext,quality),
823    LUA_REG(wext,quality_max),
824    LUA_REG(wext,mode),
825    LUA_REG(wext,ssid),
826    LUA_REG(wext,bssid),
827    LUA_REG(wext,country),
828    LUA_REG(wext,assoclist),
829    LUA_REG(wext,txpwrlist),
830    LUA_REG(wext,scanlist),
831    LUA_REG(wext,freqlist),
832    LUA_REG(wext,countrylist),
833    LUA_REG(wext,hwmodelist),
834    LUA_REG(wext,encryption),
835    LUA_REG(wext,mbssid_support),
836    LUA_REG(wext,hardware_id),
837    LUA_REG(wext,hardware_name),
838    { NULL, NULL }
839};
840
841/* Common */
842static const luaL_reg R_common[] = {
843    { "type", iwinfo_L_type },
844    { "__gc", iwinfo_L__gc },
845    { NULL, NULL }
846};
847
848
849LUALIB_API int luaopen_iwinfo(lua_State *L) {
850    luaL_register(L, IWINFO_META, R_common);
851
852#ifdef USE_WL
853    luaL_newmetatable(L, IWINFO_WL_META);
854    luaL_register(L, NULL, R_wl);
855    lua_pushvalue(L, -1);
856    lua_setfield(L, -2, "__index");
857    lua_setfield(L, -2, "wl");
858#endif
859
860#ifdef USE_MADWIFI
861    luaL_newmetatable(L, IWINFO_MADWIFI_META);
862    luaL_register(L, NULL, R_madwifi);
863    lua_pushvalue(L, -1);
864    lua_setfield(L, -2, "__index");
865    lua_setfield(L, -2, "madwifi");
866#endif
867
868#ifdef USE_NL80211
869    luaL_newmetatable(L, IWINFO_NL80211_META);
870    luaL_register(L, NULL, R_nl80211);
871    lua_pushvalue(L, -1);
872    lua_setfield(L, -2, "__index");
873    lua_setfield(L, -2, "nl80211");
874#endif
875
876    luaL_newmetatable(L, IWINFO_WEXT_META);
877    luaL_register(L, NULL, R_wext);
878    lua_pushvalue(L, -1);
879    lua_setfield(L, -2, "__index");
880    lua_setfield(L, -2, "wext");
881
882    return 1;
883}
884

Archive Download this file

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



interactive