source: trunk/package/iwinfo/src/iwinfo_lua.c @ 29403

Last change on this file since 29403 was 29403, checked in by jow, 5 years ago

[package] add libiwinfo (moved from LuCI trunk)

File size: 16.5 KB
Line 
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 assoclist */
239static 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 */
276static 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 */
308static 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 */
372static 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 */
410static 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 */
426static 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 */
455static 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 */
471static 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
487static 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 */
529LUA_WRAP_INT(wl,channel)
530LUA_WRAP_INT(wl,frequency)
531LUA_WRAP_INT(wl,txpower)
532LUA_WRAP_INT(wl,bitrate)
533LUA_WRAP_INT(wl,signal)
534LUA_WRAP_INT(wl,noise)
535LUA_WRAP_INT(wl,quality)
536LUA_WRAP_INT(wl,quality_max)
537LUA_WRAP_STRING(wl,mode)
538LUA_WRAP_STRING(wl,ssid)
539LUA_WRAP_STRING(wl,bssid)
540LUA_WRAP_STRING(wl,country)
541LUA_WRAP_LIST(wl,assoclist)
542LUA_WRAP_LIST(wl,txpwrlist)
543LUA_WRAP_LIST(wl,scanlist)
544LUA_WRAP_LIST(wl,freqlist)
545LUA_WRAP_LIST(wl,countrylist)
546LUA_WRAP_LIST(wl,hwmodelist)
547LUA_WRAP_LIST(wl,encryption)
548LUA_WRAP_LIST(wl,mbssid_support)
549#endif
550
551#ifdef USE_MADWIFI
552/* Madwifi */
553LUA_WRAP_INT(madwifi,channel)
554LUA_WRAP_INT(madwifi,frequency)
555LUA_WRAP_INT(madwifi,txpower)
556LUA_WRAP_INT(madwifi,bitrate)
557LUA_WRAP_INT(madwifi,signal)
558LUA_WRAP_INT(madwifi,noise)
559LUA_WRAP_INT(madwifi,quality)
560LUA_WRAP_INT(madwifi,quality_max)
561LUA_WRAP_STRING(madwifi,mode)
562LUA_WRAP_STRING(madwifi,ssid)
563LUA_WRAP_STRING(madwifi,bssid)
564LUA_WRAP_STRING(madwifi,country)
565LUA_WRAP_LIST(madwifi,assoclist)
566LUA_WRAP_LIST(madwifi,txpwrlist)
567LUA_WRAP_LIST(madwifi,scanlist)
568LUA_WRAP_LIST(madwifi,freqlist)
569LUA_WRAP_LIST(madwifi,countrylist)
570LUA_WRAP_LIST(madwifi,hwmodelist)
571LUA_WRAP_LIST(madwifi,encryption)
572LUA_WRAP_LIST(madwifi,mbssid_support)
573#endif
574
575#ifdef USE_NL80211
576/* NL80211 */
577LUA_WRAP_INT(nl80211,channel)
578LUA_WRAP_INT(nl80211,frequency)
579LUA_WRAP_INT(nl80211,txpower)
580LUA_WRAP_INT(nl80211,bitrate)
581LUA_WRAP_INT(nl80211,signal)
582LUA_WRAP_INT(nl80211,noise)
583LUA_WRAP_INT(nl80211,quality)
584LUA_WRAP_INT(nl80211,quality_max)
585LUA_WRAP_STRING(nl80211,mode)
586LUA_WRAP_STRING(nl80211,ssid)
587LUA_WRAP_STRING(nl80211,bssid)
588LUA_WRAP_STRING(nl80211,country)
589LUA_WRAP_LIST(nl80211,assoclist)
590LUA_WRAP_LIST(nl80211,txpwrlist)
591LUA_WRAP_LIST(nl80211,scanlist)
592LUA_WRAP_LIST(nl80211,freqlist)
593LUA_WRAP_LIST(nl80211,countrylist)
594LUA_WRAP_LIST(nl80211,hwmodelist)
595LUA_WRAP_LIST(nl80211,encryption)
596LUA_WRAP_LIST(nl80211,mbssid_support)
597#endif
598
599/* Wext */
600LUA_WRAP_INT(wext,channel)
601LUA_WRAP_INT(wext,frequency)
602LUA_WRAP_INT(wext,txpower)
603LUA_WRAP_INT(wext,bitrate)
604LUA_WRAP_INT(wext,signal)
605LUA_WRAP_INT(wext,noise)
606LUA_WRAP_INT(wext,quality)
607LUA_WRAP_INT(wext,quality_max)
608LUA_WRAP_STRING(wext,mode)
609LUA_WRAP_STRING(wext,ssid)
610LUA_WRAP_STRING(wext,bssid)
611LUA_WRAP_STRING(wext,country)
612LUA_WRAP_LIST(wext,assoclist)
613LUA_WRAP_LIST(wext,txpwrlist)
614LUA_WRAP_LIST(wext,scanlist)
615LUA_WRAP_LIST(wext,freqlist)
616LUA_WRAP_LIST(wext,countrylist)
617LUA_WRAP_LIST(wext,hwmodelist)
618LUA_WRAP_LIST(wext,encryption)
619LUA_WRAP_LIST(wext,mbssid_support)
620
621#ifdef USE_WL
622/* Broadcom table */
623static 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 */
650static 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 */
677static 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 */
703static 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 */
728static const luaL_reg R_common[] = {
729        { "type", iwinfo_L_type },
730        { "__gc", iwinfo_L__gc  },
731        { NULL, NULL }
732};
733
734
735LUALIB_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}
Note: See TracBrowser for help on using the repository browser.