Import luanet library

Relicensed with author's permission
Thanks John

20 files changed, 2177 insertions, 0 deletions

diff --git a/libs/luanet/Makefile b/libs/luanet/Makefile
new file mode 100644
index 000000000..702f866b0
--- /dev/null
+++ b/libs/luanet/Makefile
@@ -0,0 +1,18 @@
+ifeq ($(CFLAGS),)
+	MYLDFLAGS ?= -L../../../contrib/uci/dist/usr/lib/
+endif
+
+include ../../build/module.mk
+include ../../build/config.mk
+include ../../build/gccconfig.mk
+
+compile: 
+	make -Csrc \
+		CFLAGS="$(CFLAGS) $(FPIC) $(LUA_CFLAGS) $(EXTRA_CFLAGS)" \
+		LDFLAGS="$(LDFLAGS)" \
+		MYLDFLAGS="$(MYLDFLAGS)"
+	mkdir -p dist/usr/lib/lua/
+	cp src/luanet.so dist/usr/lib/lua
+
+clean: luaclean
+	make -Csrc clean
diff --git a/libs/luanet/src/Makefile b/libs/luanet/src/Makefile
new file mode 100644
index 000000000..852a7c4f4
--- /dev/null
+++ b/libs/luanet/src/Makefile
@@ -0,0 +1,18 @@
+PROGS=luanet.so
+STRIP?=strip
+CFLAGS?=
+CFLAGS+=-pedantic -Werror -Wall -I/usr/include/lua5.1/ -std=gnu99
+LDFLAGS?=
+LDFLAGS+=
+OBJS=ifconfig.o bridge.o iwconfig.o helper.o route.o vconfig.o main.o df.o base64.o
+
+all: $(PROGS)
+
+$(PROGS): $(OBJS)
+	$(CC) $(CFLAGS) -shared -Wl,-soname,luanet -liw $(LDFLAGS) $^ -o $@
+
+clean:
+	rm -f $(PROGS) *.o *.so
+
+%.o: %.c
+	$(CC) $(CFLAGS) -c  $^ -o $@
diff --git a/libs/luanet/src/base64.c b/libs/luanet/src/base64.c
new file mode 100644
index 000000000..f897cf7aa
--- /dev/null
+++ b/libs/luanet/src/base64.c
@@ -0,0 +1,121 @@
+/*
+ * Base64.c
+ * Copyright (c) 2006 Ryan Martell. (rdm4@martellventures.com)
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+
+unsigned char map2[] =
+{
+    0x3e, 0xff, 0xff, 0xff, 0x3f, 0x34, 0x35, 0x36,
+    0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01,
+    0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+    0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11,
+    0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1a, 0x1b,
+    0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
+    0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
+    0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33
+};
+
+int b64_decode(lua_State *L)
+{
+    int i, v;
+	unsigned char out[512];
+	unsigned char *dst = out;
+	char *in;
+	if(lua_gettop(L) != 1)
+	{
+		lua_pushstring(L, "invalid arg list");
+		lua_error(L);
+		return 0;
+	}
+	in = (char *)lua_tostring (L, 1);
+    v = 0;
+    for (i = 0; in[i] && in[i] != '='; i++) {
+        unsigned int index= in[i]-43;
+        if (index>=(sizeof(map2)/sizeof(map2[0])) || map2[index] == 0xff)
+            return -1;
+        v = (v << 6) + map2[index];
+        if (i & 3) {
+            if (dst - out < 512) {
+                *dst++ = v >> (6 - 2 * (i & 3));
+            }
+        }
+    }
+	if(!(dst - out))
+		return 0;
+	 lua_pushstring(L, (char*)out);
+    return 1;
+}
+
+/*****************************************************************************
+* b64_encode: stolen from VLC's http.c
+* simplified by michael
+* fixed edge cases and made it work from data (vs. strings) by ryan.
+*****************************************************************************/
+
+int b64_encode(lua_State *L)
+{
+    static const char b64[] =
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    char *ret, *dst, *src, tmp[1024];
+    unsigned i_bits = 0;
+    int i_shift = 0;
+    int bytes_remaining, len;
+	if(lua_gettop(L) != 1)
+	{
+		lua_pushstring(L, "invalid arg list");
+		lua_error(L);
+		return 0;
+	}
+	src = (char *)lua_tostring (L, 1);
+    bytes_remaining = len = strlen(src);
+	if (len < 512) {
+        ret = dst = tmp;
+    } else
+        return 0;
+
+    if (len) {                  // special edge case, what should we really do here?
+        while (bytes_remaining) {
+            i_bits = (i_bits << 8) + *src++;
+            bytes_remaining--;
+            i_shift += 8;
+
+            do {
+                *dst++ = b64[(i_bits << 6 >> i_shift) & 0x3f];
+                i_shift -= 6;
+            } while (i_shift > 6 || (bytes_remaining == 0 && i_shift > 0));
+        }
+        while ((dst - ret) & 3)
+            *dst++ = '=';
+    }
+    *dst = '\0';
+	lua_pushstring(L, tmp);
+    return 1;
+}
diff --git a/libs/luanet/src/base64.h b/libs/luanet/src/base64.h
new file mode 100644
index 000000000..e32365f8d
--- /dev/null
+++ b/libs/luanet/src/base64.h
@@ -0,0 +1,23 @@
+/*
+ * Base64.c
+ * Copyright (c) 2006 Ryan Martell. (rdm4@martellventures.com)
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+int b64_decode(lua_State *L);
+int b64_encode(lua_State *L);
diff --git a/libs/luanet/src/bridge.c b/libs/luanet/src/bridge.c
new file mode 100644
index 000000000..478f8b14f
--- /dev/null
+++ b/libs/luanet/src/bridge.c
@@ -0,0 +1,171 @@
+/*
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *   Copyright (C) 2008 John Crispin <blogic@openwrt.org> 
+ *   Copyright (C) 2008 Steven Barth <steven@midlink.org>
+ */
+
+#include <string.h>
+#include <net/if.h>
+#include <linux/sockios.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+static int sock_bridge = 0;
+int bridge_startup()
+{
+	if(!sock_bridge)
+		sock_bridge = socket(AF_LOCAL, SOCK_STREAM, 0);
+	return sock_bridge;
+}
+
+void bridge_shutdown(void)
+{
+	if(!sock_bridge)
+		return;
+	close(sock_bridge);
+	sock_bridge = 0;
+}
+
+static inline int _bridge_new(lua_State *L, int i)
+{
+	char *ifname;
+	if(lua_gettop(L) != 1)
+	{
+		lua_pushstring(L, "invalid arg list");
+		lua_error(L);
+		return 0;
+	}
+
+	ifname = (char *)lua_tostring (L, 1);
+	if(!ioctl(sock_bridge, i, ifname))
+		lua_pushboolean(L, 1);
+	else
+		lua_pushboolean(L, 0);
+	return 1;
+}
+
+int bridge_new(lua_State *L)
+{
+	return _bridge_new(L, SIOCBRADDBR);
+}
+
+int bridge_del(lua_State *L)
+{
+	return _bridge_new(L, SIOCBRDELBR);
+}
+
+static inline int _bridge_addif(lua_State *L, int i)
+{
+	struct ifreq ifr;
+	char *br, *ifname;
+	if(lua_gettop(L) != 2)
+	{
+		lua_pushstring(L, "invalid arg list");
+		lua_error(L);
+		return 0;
+	}
+	br = (char *)lua_tostring (L, 1);
+	ifname = (char *)lua_tostring (L, 2);
+	strncpy(ifr.ifr_name, br, IFNAMSIZ);
+	ifr.ifr_ifindex = if_nametoindex(ifname);
+	if(ifr.ifr_ifindex == 0)
+	{
+		lua_pushboolean(L, 0);
+		return 1;
+	}
+	if(!ioctl(sock_bridge, i, &ifr))
+		lua_pushboolean(L, 1);
+	else
+		lua_pushboolean(L, 0);
+	return 1;
+}
+
+int bridge_addif(lua_State *L)
+{
+	return _bridge_addif(L, SIOCBRADDIF);
+}
+
+int bridge_delif(lua_State *L)
+{
+	return _bridge_addif(L, SIOCBRDELIF);
+}
+
+#define SYSFS_PATH_MAX	512
+#define SYSFS_CLASS_NET "/sys/class/net/"
+static int isbridge(const struct dirent *entry)
+{
+	char path[SYSFS_PATH_MAX];
+	struct stat st;
+
+	snprintf(path, SYSFS_PATH_MAX, SYSFS_CLASS_NET "%s/bridge", entry->d_name);
+	return stat(path, &st) == 0 && S_ISDIR(st.st_mode);
+}
+
+static int isdev(const struct dirent *entry)
+{
+	if(*entry->d_name == '.')
+		return 0;
+	return 1;
+}
+
+static inline void bridge_getifs(lua_State *L, const char *ifname)
+{
+	struct dirent **namelist;
+	int i, count = 0;
+	char path[SYSFS_PATH_MAX];
+	snprintf(path, SYSFS_PATH_MAX, SYSFS_CLASS_NET "%s/brif", ifname);
+	count = scandir(path, &namelist, isdev, alphasort);
+	if(count < 0)
+		return;
+
+	for(i = 0; i < count; i++)
+	{
+		lua_pushinteger(L, i + 1);
+		lua_pushstring(L, namelist[i]->d_name);
+		lua_settable(L, -3);
+		free(namelist[i]);
+	}
+	free(namelist);
+	return;
+}
+
+int bridge_getall(lua_State *L)
+{
+	struct dirent **namelist;
+	int i, count = 0;
+	count = scandir(SYSFS_CLASS_NET, &namelist, isbridge, alphasort);
+	if (count < 0)
+		return 0;
+
+	lua_newtable(L);
+	for (i = 0; i < count; i++)
+	{
+		lua_pushstring(L, namelist[i]->d_name);
+		lua_newtable(L);
+		bridge_getifs(L, namelist[i]->d_name);
+		free(namelist[i]);
+		lua_settable(L, -3);
+	}
+	free(namelist);
+	return 1;
+}
diff --git a/libs/luanet/src/bridge.h b/libs/luanet/src/bridge.h
new file mode 100644
index 000000000..87202f64f
--- /dev/null
+++ b/libs/luanet/src/bridge.h
@@ -0,0 +1,27 @@
+/*
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *   Copyright (C) 2008 John Crispin <blogic@openwrt.org> 
+ *   Copyright (C) 2008 Steven Barth <steven@midlink.org>
+ */
+
+#ifndef _BRIDGE_H__
+#define _BRIDGE_H__
+int bridge_startup(void);
+void bridge_shutdown(void);
+int bridge_new(lua_State *L);
+int bridge_del(lua_State *L);
+int bridge_addif(lua_State *L);
+int bridge_delif(lua_State *L);
+int bridge_getall(lua_State *L);
+#endif
diff --git a/libs/luanet/src/df.c b/libs/luanet/src/df.c
new file mode 100644
index 000000000..be582f6ef
--- /dev/null
+++ b/libs/luanet/src/df.c
@@ -0,0 +1,122 @@
+/* based on busybox code */
+#include <stdio.h>
+#include <string.h>
+#include <mntent.h>
+#include <sys/vfs.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+#include "helper.h"
+
+struct mntent *find_mount_point(const char *name, const char *table)
+{
+	struct stat s;
+	dev_t mountDevice;
+	FILE *mountTable;
+	struct mntent *mountEntry;
+
+	if (stat(name, &s) != 0)
+		return 0;
+
+	if ((s.st_mode & S_IFMT) == S_IFBLK)
+		mountDevice = s.st_rdev;
+	else
+		mountDevice = s.st_dev;
+
+
+	mountTable = setmntent(table ? table : "/etc/mtab", "r");
+	if (!mountTable)
+		return 0;
+
+	while ((mountEntry = getmntent(mountTable)) != 0) {
+		if (strcmp(name, mountEntry->mnt_dir) == 0
+			|| strcmp(name, mountEntry->mnt_fsname) == 0
+			) { /* String match. */
+			break;
+			}
+		if (stat(mountEntry->mnt_fsname, &s) == 0 && s.st_rdev == mountDevice)  /* Match the device. */
+			break;
+		if (stat(mountEntry->mnt_dir, &s) == 0 && s.st_dev == mountDevice)  /* Match the directory's mount point. */
+			break;
+	}
+	endmntent(mountTable);
+	return mountEntry;
+}
+
+static unsigned long kscale(unsigned long b, unsigned long bs)
+{
+	return (b * (unsigned long long) bs + 1024/2) / 1024;
+}
+
+int df(lua_State *L)
+{
+	unsigned long blocks_used;
+	unsigned blocks_percent_used;
+	FILE *mount_table;
+	struct mntent *mount_entry = 0;
+	struct statfs s;
+	/* default display is kilobytes */
+	const char *disp_units_hdr = "1k-blocks";
+	int cnt = 0;
+	printf("Filesystem           %-15sUsed Available Use%% Mounted on\n",
+			disp_units_hdr);
+
+	mount_table = NULL;
+	mount_table = setmntent("/etc/mtab", "r");
+	lua_newtable(L);
+	while (1) {
+		const char *device;
+		const char *mount_point;
+
+		if (mount_table) {
+			mount_entry = getmntent(mount_table);
+			if (!mount_entry) {
+				endmntent(mount_table);
+				break;
+			}
+		}
+
+		device = mount_entry->mnt_fsname;
+		mount_point = mount_entry->mnt_dir;
+
+		if (statfs(mount_point, &s) != 0) {
+			perror(mount_point);
+			continue;
+		}
+
+		if ((s.f_blocks > 0) || !mount_table)
+		{
+			blocks_used = s.f_blocks - s.f_bfree;
+			blocks_percent_used = 0;
+			if (blocks_used + s.f_bavail)
+			{
+				blocks_percent_used = (blocks_used * 100ULL	+ (blocks_used + s.f_bavail) / 2 )
+					/ (blocks_used + s.f_bavail);
+			}
+			lua_pushinteger(L, ++cnt);
+	        lua_newtable(L);
+
+			add_table_entry_int(L, "blocks", kscale(s.f_blocks, s.f_bsize));
+			add_table_entry_int(L, "used", kscale(s.f_blocks-s.f_bfree, s.f_bsize));
+			add_table_entry_int(L, "avail", kscale(s.f_bavail, s.f_bsize));
+			add_table_entry_int(L, "percent", blocks_percent_used);
+			add_table_entry(L, "device", device);
+			add_table_entry(L, "mountpoint", mount_point);
+			add_table_entry_int(L, "blocksize",  s.f_bsize);
+			lua_settable(L, -3);
+
+			/*printf("\n%-20s" + 1, device)
+			printf(" %9lu %9lu %9lu %3u%% %s\n",
+				kscale(s.f_blocks, s.f_bsize),
+				kscale(s.f_blocks-s.f_bfree, s.f_bsize),
+				kscale(s.f_bavail, s.f_bsize),
+				blocks_percent_used, mount_point);*/
+		}
+	}
+	return 1;
+}
diff --git a/libs/luanet/src/df.h b/libs/luanet/src/df.h
new file mode 100644
index 000000000..7fe3f6e43
--- /dev/null
+++ b/libs/luanet/src/df.h
@@ -0,0 +1,23 @@
+/*
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *   Copyright (C) 2008 John Crispin <blogic@openwrt.org> 
+ *   Copyright (C) 2008 Steven Barth <steven@midlink.org>
+ */
+
+#ifndef _DF_H__
+#define _DF_H__
+
+int df(lua_State *L);
+
+#endif
diff --git a/libs/luanet/src/helper.c b/libs/luanet/src/helper.c
new file mode 100644
index 000000000..57679925b
--- /dev/null
+++ b/libs/luanet/src/helper.c
@@ -0,0 +1,73 @@
+/*
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *   Copyright (C) 2008 John Crispin <blogic@openwrt.org> 
+ *   Copyright (C) 2008 Steven Barth <steven@midlink.org>
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+int char2ipv4(char *c, char *ip)
+{
+	int i;
+	char *tmp = strdup(c);
+	char *t = tmp;
+	char *e = NULL;
+	int ret = -1;
+	for(i = 0; i < 4; i++)
+	{
+		int j = strtol(t, &e, 10);
+		if((j < 0) || (j > 255))
+			goto error;
+		if(i != 3)
+			if(*e != '.')
+				goto error;
+		*ip++ = j;
+		t = e + 1;
+	}
+	ret = 0;
+error:
+	free(tmp);
+	return ret;
+}
+
+void ipv42char(char *b, char *ip)
+{
+	sprintf(ip, "%d.%d.%d.%d", b[0] & 0xff, b[1] & 0xff, b[2] & 0xff, b[3] & 0xff);
+}
+
+void mac2char(char *b, char *mac)
+{
+	sprintf(mac, "%02X:%02X:%02X:%02X:%02X:%02X",
+		b[0] & 0xff, b[1] & 0xff, b[2] & 0xff, b[3] & 0xff, b[4] & 0xff, b[5] & 0xff);
+}
+
+void add_table_entry(lua_State *L, const char *k, const char *v)
+{
+	lua_pushstring(L, k);
+	lua_pushstring(L, v);
+	lua_settable(L, -3);
+}
+
+void add_table_entry_int(lua_State *L, const char *k, int v)
+{
+	lua_pushstring(L, k);
+	lua_pushinteger(L, v);
+	lua_settable(L, -3);
+}
diff --git a/libs/luanet/src/helper.h b/libs/luanet/src/helper.h
new file mode 100644
index 000000000..dec55529b
--- /dev/null
+++ b/libs/luanet/src/helper.h
@@ -0,0 +1,31 @@
+/*
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *   Copyright (C) 2008 John Crispin <blogic@openwrt.org> 
+ *   Copyright (C) 2008 Steven Barth <steven@midlink.org>
+ */
+
+#ifndef _HELPER_H__
+#define _HELPER_H__
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+int char2ipv4(char *c, char *ip);
+void ipv42char(char *b, char *ip);
+void mac2char(char *b, char *mac);
+void add_table_entry(lua_State *L, const char *k, const char *v);
+void add_table_entry_int(lua_State *L, const char *k, int v);
+
+#endif
diff --git a/libs/luanet/src/ifconfig.c b/libs/luanet/src/ifconfig.c
new file mode 100644
index 000000000..58ce45e90
--- /dev/null
+++ b/libs/luanet/src/ifconfig.c
@@ -0,0 +1,250 @@
+/*
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *   Copyright (C) 2008 John Crispin <blogic@openwrt.org> 
+ *   Copyright (C) 2008 Steven Barth <steven@midlink.org>
+ */
+
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <linux/sockios.h>
+#include <sys/ioctl.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+#include "helper.h"
+
+int sock_ifconfig = 0;
+
+int ifc_startup(void)
+{
+	if(!sock_ifconfig)
+		sock_ifconfig = socket(AF_INET, SOCK_DGRAM, 0);
+	return sock_ifconfig;
+}
+
+void ifc_shutdown(void)
+{
+	if(!sock_ifconfig)
+		return;
+	close(sock_ifconfig);
+	sock_ifconfig = 0;
+}
+
+static int isdev(const struct dirent *entry)
+{
+	if(*entry->d_name == '.')
+		return 0;
+	return 1;
+}
+
+static void ifc_addif(lua_State *L, char *ifname)
+{
+	char *ip = malloc(32);
+	struct ifreq ifr;
+	lua_pushstring(L, ifname);
+	lua_newtable(L);
+	strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
+
+	if(!ioctl(sock_ifconfig, SIOCGIFADDR, &ifr))
+	{
+		ipv42char(&ifr.ifr_addr.sa_data[2], ip);
+		add_table_entry(L, "ip", ip);
+	}
+
+	if(!ioctl(sock_ifconfig, SIOCGIFNETMASK, &ifr))
+	{
+		ipv42char(&ifr.ifr_netmask.sa_data[2], ip);
+		add_table_entry(L, "netmask", ip);
+	}
+
+	if(!ioctl(sock_ifconfig, SIOCGIFBRDADDR, &ifr))
+	{
+		ipv42char(&ifr.ifr_broadaddr.sa_data[2], ip);
+		add_table_entry(L, "broadaddr", ip);
+	}
+
+	if(!ioctl(sock_ifconfig, SIOCGIFHWADDR, &ifr))
+	{
+		mac2char(ifr.ifr_hwaddr.sa_data, ip);
+		add_table_entry(L, "mac", ip);
+	}
+
+	if(!ioctl(sock_ifconfig, SIOCGIFFLAGS, &ifr))
+	{
+		if(ifr.ifr_flags & IFF_UP)
+			add_table_entry(L, "up", "1");
+		else
+			add_table_entry(L, "up", "0");
+	}
+
+	ioctl(sock_ifconfig, SIOCGIFMTU, &ifr);
+	lua_pushstring(L, "mtu");
+	lua_pushinteger(L, ifr.ifr_mtu);
+	lua_settable(L, -3);
+	free(ip);
+	lua_settable(L, -3);
+}
+
+#define SYSFS_CLASS_NET	"/sys/class/net/"
+int ifc_getall(lua_State *L)
+{
+	int numreqs = 50;
+	struct dirent **namelist;
+	int i, count = 0;
+	struct ifconf ifc;
+	struct ifreq *ifr;
+	ifc.ifc_buf = NULL;
+	count = scandir(SYSFS_CLASS_NET, &namelist, isdev, alphasort);
+	if (count < 0)
+	{
+		return 0;
+	}
+	lua_newtable(L);
+	for (i = 0; i < count; i++)
+	{
+		ifc_addif(L, namelist[i]->d_name);
+		free(namelist[i]);
+	}
+	free(namelist);
+
+	ifc.ifc_len = sizeof(struct ifreq) * numreqs;
+	ifc.ifc_buf = malloc(ifc.ifc_len);
+	if(ioctl(sock_ifconfig, SIOCGIFCONF, &ifc) < 0)
+		goto out;
+	ifr = ifc.ifc_req;
+	for(i = 0; i < ifc.ifc_len; i += sizeof(struct ifreq))
+	{
+		if(strchr(ifr->ifr_name, ':'))
+			ifc_addif(L, ifr->ifr_name);
+		ifr++;
+	}
+out:
+	free(ifc.ifc_buf);
+	return 1;
+}
+
+static inline int _ifc_setip(lua_State *L, int i)
+{
+	struct ifreq ifr;
+	char *ifname, *ip;
+	if(lua_gettop(L) != 2)
+	{
+		lua_pushstring(L, "invalid arg list");
+		lua_error(L);
+		return 0;
+	}
+    ifname = (char *)lua_tostring (L, 1);
+    ip = (char *)lua_tostring (L, 2);
+	strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
+	ifr.ifr_addr.sa_family = AF_INET;
+	if(char2ipv4(ip, &ifr.ifr_addr.sa_data[2]))
+	{
+		lua_pushstring(L, "invalid ip");
+		lua_error(L);
+		return 0;
+	}
+	if(!ioctl(sock_ifconfig, i, &ifr))
+		lua_pushboolean(L, 1);
+	else
+		lua_pushboolean(L, 0);
+	return 1;
+}
+
+int ifc_setip(lua_State *L)
+{
+	return _ifc_setip(L, SIOCSIFADDR);
+}
+
+int ifc_setnetmask(lua_State *L)
+{
+	return _ifc_setip(L, SIOCGIFNETMASK);
+}
+
+int ifc_setbroadcast(lua_State *L)
+{
+	return _ifc_setip(L, SIOCSIFBRDADDR);
+}
+
+int ifc_setmtu(lua_State *L)
+{
+	struct ifreq ifr;
+	char *ifname;
+	int mtu;
+	if(lua_gettop(L) != 2)
+	{
+		lua_pushstring(L, "invalid arg list");
+		lua_error(L);
+		return 0;
+	}
+	ifname = (char *)lua_tostring (L, 1);
+	mtu = (int)lua_tointeger (L, 2);
+	strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
+	ifr.ifr_mtu = mtu;
+	if(!ioctl(sock_ifconfig, SIOCSIFMTU, &ifr))
+		lua_pushboolean(L, 1);
+	else
+		lua_pushboolean(L, 0);
+	return 1;
+}
+
+static int _ifc_up(lua_State *L, int up)
+{
+	struct ifreq ifr;
+	char *ifname;
+	if(lua_gettop(L) != 1)
+	{
+		lua_pushstring(L, "invalid arg list");
+		lua_error(L);
+		return 0;
+	}
+
+	ifname = (char *)lua_tostring (L, 1);
+	strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
+
+	if(ioctl(sock_ifconfig, SIOCGIFFLAGS, &ifr) < 0)
+	{
+		lua_pushboolean(L, 0);
+		return 1;
+	}
+	if(up)
+		ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
+	else
+		ifr.ifr_flags &= ~IFF_UP;
+	if(!ioctl(sock_ifconfig, SIOCSIFFLAGS, &ifr))
+		lua_pushboolean(L, 1);
+	else
+		lua_pushboolean(L, 0);
+	return 1;
+}
+
+int ifc_up(lua_State *L)
+{
+	return _ifc_up(L, 1);
+}
+
+int ifc_down(lua_State *L)
+{
+	return _ifc_up(L, 0);
+}
+
diff --git a/libs/luanet/src/ifconfig.h b/libs/luanet/src/ifconfig.h
new file mode 100644
index 000000000..dffffd583
--- /dev/null
+++ b/libs/luanet/src/ifconfig.h
@@ -0,0 +1,30 @@
+/*
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *   Copyright (C) 2008 John Crispin <blogic@openwrt.org> 
+ *   Copyright (C) 2008 Steven Barth <steven@midlink.org>
+ */
+
+#ifndef _IFCONFIG_H__
+#define _IFCONFIG_H__
+int ifc_startup(void);
+void ifc_shutdown(void);
+
+int ifc_getall(lua_State *L);
+int ifc_setip(lua_State *L);
+int ifc_setnetmask(lua_State *L);
+int ifc_setbroadcast(lua_State *L);
+int ifc_setmtu(lua_State *L);
+int ifc_up(lua_State *L);
+int ifc_down(lua_State *L);
+#endif
diff --git a/libs/luanet/src/iwconfig.c b/libs/luanet/src/iwconfig.c
new file mode 100644
index 000000000..5fc65b607
--- /dev/null
+++ b/libs/luanet/src/iwconfig.c
@@ -0,0 +1,829 @@
+/*
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *   Copyright (C) 2008 John Crispin <blogic@openwrt.org> 
+ *   Copyright (C) 2008 Steven Barth <steven@midlink.org>
+ */
+
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <net/route.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <linux/sockios.h>
+#include "iwlib.h"
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+#include "helper.h"
+
+static int sock_iwconfig = 0;
+
+typedef struct iwscan_state
+{
+	/* State */
+	int ap_num;     /* Access Point number 1->N */
+	int val_index;  /* Value in table 0->(N-1) */
+} iwscan_state;
+
+int iwc_startup(void)
+{
+	if(!sock_iwconfig)
+		sock_iwconfig = iw_sockets_open();
+	return sock_iwconfig;
+}
+
+void iwc_shutdown(void)
+{
+	if(!sock_iwconfig)
+		return;
+	iw_sockets_close(sock_iwconfig);
+	sock_iwconfig = 0;
+}
+
+/* taken from wireless tools */
+static int
+get_info(char * ifname, struct wireless_info * info)
+{
+	struct iwreq wrq;
+
+	memset((char*) info, 0, sizeof(struct wireless_info));
+
+	/* Get basic information */
+	if(iw_get_basic_config(sock_iwconfig, ifname, &(info->b)) < 0)
+	{
+		/* If no wireless name : no wireless extensions */
+		/* But let's check if the interface exists at all */
+		struct ifreq ifr;
+
+		strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
+		if(ioctl(sock_iwconfig, SIOCGIFFLAGS, &ifr) < 0)
+			return(-ENODEV);
+		else
+			return(-ENOTSUP);
+	}
+
+	/* Get ranges */
+	if(iw_get_range_info(sock_iwconfig, ifname, &(info->range)) >= 0)
+		info->has_range = 1;
+
+	/* Get AP address */
+	if(iw_get_ext(sock_iwconfig, ifname, SIOCGIWAP, &wrq) >= 0)
+	{
+		info->has_ap_addr = 1;
+		memcpy(&(info->ap_addr), &(wrq.u.ap_addr), sizeof (sockaddr));
+	}
+
+	/* Get bit rate */
+	if(iw_get_ext(sock_iwconfig, ifname, SIOCGIWRATE, &wrq) >= 0)
+	{
+		info->has_bitrate = 1;
+		memcpy(&(info->bitrate), &(wrq.u.bitrate), sizeof(iwparam));
+	}
+
+	/* Get Power Management settings */
+	wrq.u.power.flags = 0;
+	if(iw_get_ext(sock_iwconfig, ifname, SIOCGIWPOWER, &wrq) >= 0)
+	{
+		info->has_power = 1;
+		memcpy(&(info->power), &(wrq.u.power), sizeof(iwparam));
+	}
+
+	/* Get stats */
+	if(iw_get_stats(sock_iwconfig, ifname, &(info->stats),
+		&info->range, info->has_range) >= 0)
+	{
+		info->has_stats = 1;
+	}
+
+	/* Get NickName */
+	wrq.u.essid.pointer = (caddr_t) info->nickname;
+	wrq.u.essid.length = IW_ESSID_MAX_SIZE + 1;
+	wrq.u.essid.flags = 0;
+	if(iw_get_ext(sock_iwconfig, ifname, SIOCGIWNICKN, &wrq) >= 0)
+		if(wrq.u.data.length > 1)
+			info->has_nickname = 1;
+
+	if((info->has_range) && (info->range.we_version_compiled > 9))
+	{
+		/* Get Transmit Power */
+		if(iw_get_ext(sock_iwconfig, ifname, SIOCGIWTXPOW, &wrq) >= 0)
+		{
+			info->has_txpower = 1;
+			memcpy(&(info->txpower), &(wrq.u.txpower), sizeof(iwparam));
+		}
+	}
+
+	/* Get sensitivity */
+	if(iw_get_ext(sock_iwconfig, ifname, SIOCGIWSENS, &wrq) >= 0)
+	{
+		info->has_sens = 1;
+		memcpy(&(info->sens), &(wrq.u.sens), sizeof(iwparam));
+	}
+
+	if((info->has_range) && (info->range.we_version_compiled > 10))
+	{
+		/* Get retry limit/lifetime */
+		if(iw_get_ext(sock_iwconfig, ifname, SIOCGIWRETRY, &wrq) >= 0)
+		{
+			info->has_retry = 1;
+			memcpy(&(info->retry), &(wrq.u.retry), sizeof(iwparam));
+		}
+	}
+
+	/* Get RTS threshold */
+	if(iw_get_ext(sock_iwconfig, ifname, SIOCGIWRTS, &wrq) >= 0)
+	{
+		info->has_rts = 1;
+		memcpy(&(info->rts), &(wrq.u.rts), sizeof(iwparam));
+	}
+
+	/* Get fragmentation threshold */
+	if(iw_get_ext(sock_iwconfig, ifname, SIOCGIWFRAG, &wrq) >= 0)
+	{
+		info->has_frag = 1;
+		memcpy(&(info->frag), &(wrq.u.frag), sizeof(iwparam));
+	}
+
+	return(0);
+}
+
+void iwc_get(lua_State *L, char *ifname)
+{
+	struct wireless_info info;
+	int rc = get_info(ifname, &info);
+	char buffer[128];
+	if(rc)
+		return;
+
+	lua_pushstring(L, ifname);
+	lua_newtable(L);
+
+	if(info.b.has_essid)
+	{
+		if(info.b.essid_on)
+			add_table_entry(L, "essid", info.b.essid);
+		else
+			add_table_entry(L, "essid", "off");
+	}
+
+	if(info.b.has_mode)
+		add_table_entry(L, "mode", iw_operation_mode[info.b.mode]);
+
+	if(info.b.has_freq)
+	{
+		double freq = info.b.freq;    /* Frequency/channel */
+		int channel = -1;       /* Converted to channel */
+		char tmp[4];
+		if(info.has_range && (freq < KILO))
+			channel = iw_channel_to_freq((int) freq, &freq, &info.range);
+		iw_print_freq(buffer, sizeof(buffer), freq, -1, info.b.freq_flags);
+		snprintf(tmp, 4, "%d", channel);
+		add_table_entry(L, "channel", tmp);
+		add_table_entry(L, "freq", buffer);
+	}
+
+	if(info.has_ap_addr)
+		add_table_entry(L, "macap", iw_sawap_ntop(&info.ap_addr, buffer));
+
+	if(info.has_bitrate)
+	{
+		iw_print_bitrate(buffer, sizeof(buffer), info.bitrate.value);
+		add_table_entry(L, "bitrate", buffer);
+	}
+
+	if(info.has_txpower)
+	{
+		iw_print_txpower(buffer, sizeof(buffer), &info.txpower);
+		add_table_entry(L, "txpower", buffer);
+	}
+	lua_settable(L, -3);
+}
+
+int iwc_getall(lua_State *L)
+{
+	FILE *fp;
+	char buffer[128];
+	char *b = buffer;
+	fp = fopen("/proc/net/wireless", "r");
+	if(!fp)
+		return -1;
+	fgets(buffer, 128, fp);
+	fgets(buffer, 128, fp);
+	lua_newtable(L);
+	while(fgets(buffer, 128, fp))
+	{
+		char *t;
+		b = buffer;
+		while(*b == ' ')
+			b++;
+		t = strstr(b, ":");
+		if(t)
+			*t = '\0';
+		iwc_get(L, b);
+	}
+	return 1;
+}
+
+/* taken from wireless tools */
+int iwc_set_essid(lua_State *L)
+{
+	struct iwreq wrq;
+	int i = 1;
+	char essid[IW_ESSID_MAX_SIZE + 1];
+	int we_kernel_version;
+	char *ifname, *e;
+	if(lua_gettop(L) != 2)
+	{
+		lua_pushstring(L, "invalid arg list");
+		lua_error(L);
+		return 0;
+	}
+	ifname = (char *)lua_tostring (L, 1);
+	e = (char *)lua_tostring (L, 2);
+
+	if((!strcasecmp(e, "off")) | (!strcasecmp(e, "any")))
+	{
+		wrq.u.essid.flags = 0;
+		essid[0] = '\0';
+	} else if(!strcasecmp(e, "on"))
+	{
+		/* Get old essid */
+		memset(essid, '\0', sizeof(essid));
+		wrq.u.essid.pointer = (caddr_t) essid;
+		wrq.u.essid.length = IW_ESSID_MAX_SIZE + 1;
+		wrq.u.essid.flags = 0;
+		if(iw_get_ext(sock_iwconfig, ifname, SIOCGIWESSID, &wrq) < 0)
+			return 0;
+		wrq.u.essid.flags = 1;
+	} else {
+		wrq.u.essid.flags = 1;
+		strcpy(essid, e); /* Size checked, all clear */
+		i++;
+	}
+
+	/* Get version from kernel, device may not have range... */
+	we_kernel_version = iw_get_kernel_we_version();
+
+	/* Finally set the ESSID value */
+	wrq.u.essid.pointer = (caddr_t) essid;
+	wrq.u.essid.length = strlen(essid);
+	if(we_kernel_version < 21)
+		wrq.u.essid.length++;
+
+	if(!iw_set_ext(sock_iwconfig, ifname, SIOCSIWESSID, &wrq))
+		lua_pushboolean(L, 1);
+	else
+		lua_pushboolean(L, 0);
+	return 1;
+}
+
+/* taken from wireless tools */
+int iwc_set_mode(lua_State *L)
+{
+	struct iwreq wrq;
+	unsigned int k;      /* Must be unsigned */
+	char *ifname, *mode;
+
+	if(lua_gettop(L) != 2)
+	{
+		lua_pushstring(L, "invalid arg list");
+		lua_error(L);
+		return 0;
+	}
+	ifname = (char *)lua_tostring (L, 1);
+	mode = (char *)lua_tostring (L, 2);
+
+	/* Check if it is a uint, otherwise get is as a string */
+	if(sscanf(mode, "%ui", &k) != 1)
+	{
+		k = 0;
+		while((k < IW_NUM_OPER_MODE) &&	strncasecmp(mode, iw_operation_mode[k], 3))
+			k++;
+	}
+	if(k >= IW_NUM_OPER_MODE)
+		return 0;
+
+	wrq.u.mode = k;
+	if(!iw_set_ext(sock_iwconfig, ifname, SIOCSIWMODE, &wrq))
+		lua_pushboolean(L, 1);
+	else
+		lua_pushboolean(L, 0);
+	return 1;
+}
+
+int iwc_set_channel(lua_State *L)
+{
+	struct iwreq wrq;
+	char *ifname;
+	int channel;
+	if(lua_gettop(L) != 2)
+	{
+		lua_pushstring(L, "invalid arg list");
+		lua_error(L);
+		return 0;
+	}
+	ifname = (char *)lua_tostring (L, 1);
+	channel = (int)lua_tointeger(L, 2);
+
+	if(channel == -1)
+	{
+		wrq.u.freq.m = -1;
+		wrq.u.freq.e = 0;
+		wrq.u.freq.flags = 0;
+	} else {
+		iw_float2freq(channel, &wrq.u.freq);
+		wrq.u.freq.flags = IW_FREQ_FIXED;
+	}
+	if(!iw_set_ext(sock_iwconfig, ifname, SIOCSIWFREQ, &wrq))
+		lua_pushboolean(L, 1);
+	else
+		lua_pushboolean(L, 0);
+	return 1;
+}
+
+static const char *	iw_ie_cypher_name[] = {
+	"none",
+	"WEP-40",
+	"TKIP",
+	"WRAP",
+	"CCMP",
+	"WEP-104",
+};
+#define IW_ARRAY_LEN(x) (sizeof(x)/sizeof((x)[0]))
+#define	IW_IE_CYPHER_NUM	IW_ARRAY_LEN(iw_ie_cypher_name)
+
+static const char *	iw_ie_key_mgmt_name[] = {
+	"none",
+	"802.1x",
+	"PSK",
+};
+#define	IW_IE_KEY_MGMT_NUM	IW_ARRAY_LEN(iw_ie_key_mgmt_name)
+
+static inline void iw_print_ie_wpa(lua_State *L, unsigned char * iebuf, int buflen)
+{
+	int ielen = iebuf[1] + 2;
+	int offset = 2; /* Skip the IE id, and the length. */
+	unsigned char wpa1_oui[3] = {0x00, 0x50, 0xf2};
+	unsigned char wpa2_oui[3] = {0x00, 0x0f, 0xac};
+	unsigned char *wpa_oui;
+	int i;
+	uint16_t ver = 0;
+	uint16_t cnt = 0;
+	int wpa1 = 0, wpa2 = 0;
+	char buf[256];
+	if(ielen > buflen)
+		ielen = buflen;
+
+	switch(iebuf[0])
+	{
+	case 0x30:      /* WPA2 */
+		/* Check if we have enough data */
+		if(ielen < 4)
+			return;
+		wpa_oui = wpa2_oui;
+		break;
+
+	case 0xdd:      /* WPA or else */
+		wpa_oui = wpa1_oui;
+		/* Not all IEs that start with 0xdd are WPA. 
+		*        * So check that the OUI is valid. */
+		if((ielen < 8)
+			|| ((memcmp(&iebuf[offset], wpa_oui, 3) != 0)
+			&& (iebuf[offset+3] == 0x01)))
+		{
+			return;
+		}
+
+		offset += 4;
+		break;
+
+	default:
+		return;
+	}
+
+	/* Pick version number (little endian) */
+	ver = iebuf[offset] | (iebuf[offset + 1] << 8);
+	offset += 2;
+
+	if(iebuf[0] == 0xdd)
+		wpa1 = 1;
+	if(iebuf[0] == 0x30)
+		wpa2 = 1;
+
+	if(ielen < (offset + 4))
+	{
+		if(wpa1)
+		{
+			add_table_entry(L, "wpa1gcipher", "TKIP");
+			add_table_entry(L, "wpa1pcipher", "TKIP");
+		} else {
+			add_table_entry(L, "wpa2gcipher", "TKIP");
+            add_table_entry(L, "wpa2pcipher", "TKIP");
+		}
+		return;
+	}
+
+	if(memcmp(&iebuf[offset], wpa_oui, 3) != 0)
+	{
+		if(wpa1)
+			add_table_entry(L, "wpa1gcipher", "Proprietary");
+		else
+			add_table_entry(L, "wpa2gcipher", "Proprietary");
+	} else {
+		if(wpa1)
+			add_table_entry(L, "wpa1gcipher", iebuf[offset+3][iw_ie_cypher_name]);
+		else
+			add_table_entry(L, "wpa2gcipher", iebuf[offset+3][iw_ie_cypher_name]);
+	}
+	offset += 4;
+
+	if(ielen < (offset + 2))
+	{
+		if(wpa1)
+			add_table_entry(L, "wpa1pcipher", "TKIP");
+		else
+			add_table_entry(L, "wpa2pcipher", "TKIP");
+		return;
+	}
+	/* Otherwise, we have some number of pairwise ciphers. */
+	cnt = iebuf[offset] | (iebuf[offset + 1] << 8);
+	offset += 2;
+	if(ielen < (offset + 4*cnt))
+		return;
+	*buf = '\0';
+	for(i = 0; i < cnt; i++)
+	{
+		if(i > 0)
+			strncat(buf, " ", 256);
+		if(memcmp(&iebuf[offset], wpa_oui, 3) != 0)
+		{
+			strncat(buf, "Proprietary", 256);
+		} else {
+			if(iebuf[offset+3] <= IW_IE_CYPHER_NUM)
+				strncat(buf, iw_ie_cypher_name[iebuf[offset+3]], 256);
+			else
+				strncat(buf, "unknown", 256);
+		}
+		offset+=4;
+	}
+	if(wpa1)
+		add_table_entry(L, "wpa1pcipher", buf);
+	else
+		add_table_entry(L, "wpa2pcipher", buf);
+
+	/* Check if we are done */
+	if(ielen < (offset + 2))
+		return;
+
+	/* Now, we have authentication suites. */
+	cnt = iebuf[offset] | (iebuf[offset + 1] << 8);
+	offset += 2;
+	*buf = '\0';
+	if(ielen < (offset + 4*cnt))
+		return;
+
+	for(i = 0; i < cnt; i++)
+	{
+		if(i != 0)
+			strncat(buf, " ", 256);
+		if(memcmp(&iebuf[offset], wpa_oui, 3) != 0)
+		{
+			strncat(buf, "Proprietary", 256);
+		} else {
+			if(iebuf[offset+3] <= IW_IE_KEY_MGMT_NUM)
+				strncat(buf, iw_ie_key_mgmt_name[iebuf[offset+3]], 256);
+			else
+				strncat(buf, "unknown", 256);
+		}
+		offset+=4;
+	}
+	if(wpa1)
+		add_table_entry(L, "wpa1auth", buf);
+	else
+		add_table_entry(L, "wpa2auth", buf);
+	/* Check if we are done */
+	if(ielen < (offset + 1))
+		return;
+}
+
+static inline void print_scanning_token(lua_State *L, struct stream_descr *stream,
+	struct iw_event *event, struct iwscan_state *state, struct iw_range *iw_range, int has_range)
+{
+	char buffer[128];    /* Temporary buffer */
+
+	/* Now, let's decode the event */
+	switch(event->cmd)
+	{
+	case SIOCGIWAP:
+		add_table_entry(L, "addr", iw_saether_ntop(&event->u.ap_addr, buffer));
+		state->ap_num++;
+		break;
+	case SIOCGIWFREQ:
+		{
+		double freq;           /* Frequency/channel */
+		int channel = -1;       /* Converted to channel */
+		freq = iw_freq2float(&(event->u.freq));
+		/* Convert to channel if possible */
+		if(has_range)
+			channel = iw_freq_to_channel(freq, iw_range);
+			snprintf(buffer, 128, "%1.3f", freq);
+			add_table_entry(L, "frequency", buffer);
+			snprintf(buffer, 128, "%d", channel);
+			add_table_entry(L, "channel", buffer);
+			//iw_print_freq(buffer, sizeof(buffer), freq, channel, event->u.freq.flags);
+			//printf("                    %s\n", buffer);
+		}
+		break;
+	case SIOCGIWMODE:
+		/* Note : event->u.mode is unsigned, no need to check <= 0 */
+		if(event->u.mode >= IW_NUM_OPER_MODE)
+			event->u.mode = IW_NUM_OPER_MODE;
+		add_table_entry(L, "mode", iw_operation_mode[event->u.mode]);
+		break;
+	case SIOCGIWESSID:
+		{
+		char essid[IW_ESSID_MAX_SIZE+1];
+		memset(essid, '\0', sizeof(essid));
+		if((event->u.essid.pointer) && (event->u.essid.length))
+			memcpy(essid, event->u.essid.pointer, event->u.essid.length);
+		if(event->u.essid.flags)
+			add_table_entry(L, "essid", essid);
+		else
+			add_table_entry(L, "essid", "off/any/hidden");
+		}
+		break;
+	case SIOCGIWENCODE:
+		{
+		unsigned char   key[IW_ENCODING_TOKEN_MAX];
+		if(event->u.data.pointer)
+			memcpy(key, event->u.data.pointer, event->u.data.length);
+		else
+			event->u.data.flags |= IW_ENCODE_NOKEY;
+		if(event->u.data.flags & IW_ENCODE_DISABLED)
+		{
+			add_table_entry(L, "key", "off");
+		} else {
+			iw_print_key(buffer, sizeof(buffer), key, event->u.data.length,
+				event->u.data.flags);
+			add_table_entry(L, "key", buffer);
+		}
+		}
+		break;
+	case SIOCGIWRATE:
+		if(state->val_index == 0)
+		{
+			lua_pushstring(L, "bitrates");
+			lua_newtable(L);
+		}
+		//iw_print_bitrate(buffer, sizeof(buffer), event->u.bitrate.value);
+		snprintf(buffer, sizeof(buffer), "%d", event->u.bitrate.value);
+		lua_pushinteger(L, state->val_index + 1);
+		lua_pushstring(L, buffer);
+		lua_settable(L, -3);
+
+		/* Check for termination */
+		if(stream->value == NULL)
+		{
+			lua_settable(L, -3);
+			state->val_index = 0;
+		} else
+			state->val_index++;
+		break;
+	 case IWEVGENIE:
+		{
+			int offset = 0;
+			unsigned char *buffer = event->u.data.pointer;
+			int buflen = event->u.data.length;
+			while(offset <= (buflen - 2))
+			{
+				switch(buffer[offset])
+				{
+				case 0xdd:  /* WPA1 (and other) */
+				case 0x30:  /* WPA2 */
+					iw_print_ie_wpa(L, buffer + offset, buflen);
+					break;
+				default:
+					break;
+				}
+				offset += buffer[offset+1] + 2;
+			}
+		}
+		break;
+	default:
+		break;
+	}    /* switch(event->cmd) */
+}
+
+int iwc_scan(lua_State *L)
+{
+	struct iwreq wrq;
+	struct iw_scan_req scanopt;        /* Options for 'set' */
+	int scanflags = 0;      /* Flags for scan */
+	unsigned char *buffer = NULL;      /* Results */
+	int buflen = IW_SCAN_MAX_DATA; /* Min for compat WE<17 */
+	struct iw_range range;
+	int has_range;
+	struct timeval tv;             /* Select timeout */
+	int timeout = 15000000;     /* 15s */
+	char *ifname;
+	if(lua_gettop(L) != 1)
+	{
+		lua_pushstring(L, "invalid arg list");
+		lua_error(L);
+		return 0;
+	}
+	ifname = (char *)lua_tostring (L, 1);
+
+	/* Debugging stuff */
+	if((IW_EV_LCP_PK2_LEN != IW_EV_LCP_PK_LEN) || (IW_EV_POINT_PK2_LEN != IW_EV_POINT_PK_LEN))
+	{
+		fprintf(stderr, "*** Please report to jt@hpl.hp.com your platform details\n");
+		fprintf(stderr, "*** and the following line :\n");
+		fprintf(stderr, "*** IW_EV_LCP_PK2_LEN = %zu ; IW_EV_POINT_PK2_LEN = %zu\n\n",
+			IW_EV_LCP_PK2_LEN, IW_EV_POINT_PK2_LEN);
+	}
+
+	/* Get range stuff */
+	has_range = (iw_get_range_info(sock_iwconfig, ifname, &range) >= 0);
+
+	/* Check if the interface could support scanning. */
+	if((!has_range) || (range.we_version_compiled < 14))
+	{
+		lua_pushstring(L, "interface does not support scanning");
+		lua_error(L);
+		return 0;
+	}
+
+	/* Init timeout value -> 250ms between set and first get */
+	tv.tv_sec = 0;
+	tv.tv_usec = 250000;
+
+	/* Clean up set args */
+	memset(&scanopt, 0, sizeof(scanopt));
+
+	wrq.u.data.pointer = NULL;
+	wrq.u.data.flags = 0;
+	wrq.u.data.length = 0;
+
+	/* Initiate Scanning */
+	if(iw_set_ext(sock_iwconfig, ifname, SIOCSIWSCAN, &wrq) < 0)
+	{
+		if((errno != EPERM) || (scanflags != 0))
+		{
+			lua_pushstring(L, "interface does not support scanning");
+			lua_error(L);
+			return 0;
+		}
+		/* If we don't have the permission to initiate the scan, we may
+		*        * still have permission to read left-over results.
+		*               * But, don't wait !!! */
+		#if 0
+		/* Not cool, it display for non wireless interfaces... */
+		fprintf(stderr, "%-8.16s  (Could not trigger scanning, just reading left-over results)\n", ifname);
+		#endif
+		tv.tv_usec = 0;
+	}
+	timeout -= tv.tv_usec;
+
+	/* Forever */
+	while(1)
+	{
+		fd_set rfds;       /* File descriptors for select */
+		int last_fd;    /* Last fd */
+		int ret;
+
+		/* Guess what ? We must re-generate rfds each time */
+		FD_ZERO(&rfds);
+		last_fd = -1;
+		/* In here, add the rtnetlink fd in the list */
+
+		/* Wait until something happens */
+		ret = select(last_fd + 1, &rfds, NULL, NULL, &tv);
+
+		/* Check if there was an error */
+		if(ret < 0)
+		{
+			if(errno == EAGAIN || errno == EINTR)
+				continue;
+			lua_pushstring(L, "unhandled signal");
+			lua_error(L);
+			return 0;
+		}
+
+		/* Check if there was a timeout */
+		if(ret == 0)
+		{
+			unsigned char *   newbuf;
+
+realloc:
+			/* (Re)allocate the buffer - realloc(NULL, len) == malloc(len) */
+			newbuf = realloc(buffer, buflen);
+			if(newbuf == NULL)
+			{
+				if(buffer)
+					free(buffer);
+				fprintf(stderr, "%s: Allocation failed\n", __FUNCTION__);
+				return 0;
+			}
+			buffer = newbuf;
+
+			/* Try to read the results */
+			wrq.u.data.pointer = buffer;
+			wrq.u.data.flags = 0;
+			wrq.u.data.length = buflen;
+			if(iw_get_ext(sock_iwconfig, ifname, SIOCGIWSCAN, &wrq) < 0)
+			{
+				/* Check if buffer was too small (WE-17 only) */
+				if((errno == E2BIG) && (range.we_version_compiled > 16))
+				{
+					/* Some driver may return very large scan results, either
+					 * because there are many cells, or because they have many
+					 * large elements in cells (like IWEVCUSTOM). Most will
+					 * only need the regular sized buffer. We now use a dynamic
+					 * allocation of the buffer to satisfy everybody. Of course,
+					 * as we don't know in advance the size of the array, we try
+					 * various increasing sizes. Jean II */
+
+					/* Check if the driver gave us any hints. */
+					if(wrq.u.data.length > buflen)
+						buflen = wrq.u.data.length;
+					else
+						buflen *= 2;
+
+					/* Try again */
+					goto realloc;
+				}
+
+				/* Check if results not available yet */
+				if(errno == EAGAIN)
+				{
+					/* Restart timer for only 100ms*/
+					tv.tv_sec = 0;
+					tv.tv_usec = 100000;
+					timeout -= tv.tv_usec;
+					if(timeout > 0)
+						continue;   /* Try again later */
+				}
+
+				/* Bad error */
+				free(buffer);
+				fprintf(stderr, "%-8.16s  Failed to read scan data : %s\n\n",
+				ifname, strerror(errno));
+				return 0;
+			} else
+				/* We have the results, go to process them */
+				break;
+		}
+
+		/* In here, check if event and event type
+		*        * if scan event, read results. All errors bad & no reset timeout */
+	}
+
+	if(wrq.u.data.length)
+	{
+		struct iw_event       iwe;
+		struct stream_descr   stream;
+		struct iwscan_state   state = { .ap_num = 1, .val_index = 0 };
+		int           ret;
+		int table = 0;
+		iw_init_event_stream(&stream, (char *) buffer, wrq.u.data.length);
+		lua_newtable(L);
+		do
+		{
+			/* Extract an event and print it */
+			ret = iw_extract_event_stream(&stream, &iwe,
+				range.we_version_compiled);
+			if(ret > 0)
+			{
+				if(iwe.cmd == SIOCGIWAP)
+				{
+					if(table)
+						lua_settable(L, -3);
+					table = 1;
+					lua_pushinteger(L, state.ap_num);
+					lua_newtable(L);
+				}
+				print_scanning_token(L, &stream, &iwe, &state, &range, has_range);
+			}
+		} while(ret > 0);
+		lua_settable(L, -3);
+		free(buffer);
+		return 1;
+	}
+	free(buffer);
+	return 0;
+}
diff --git a/libs/luanet/src/iwconfig.h b/libs/luanet/src/iwconfig.h
new file mode 100644
index 000000000..59240d570
--- /dev/null
+++ b/libs/luanet/src/iwconfig.h
@@ -0,0 +1,28 @@
+/*
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *   Copyright (C) 2008 John Crispin <blogic@openwrt.org> 
+ *   Copyright (C) 2008 Steven Barth <steven@midlink.org>
+ */
+
+#ifndef _IWCONFIG_H__
+#define _IWCONFIG_H__
+int iwc_startup(void);
+void iwc_shutdown(void);
+int iwc_get(lua_State *L);
+int iwc_getall(lua_State *L);
+int iwc_set_essid(lua_State *L);
+int iwc_set_mode(lua_State *L);
+int iwc_set_channel(lua_State *L);
+int iwc_scan(lua_State *L);
+#endif
diff --git a/libs/luanet/src/main.c b/libs/luanet/src/main.c
new file mode 100644
index 000000000..0a42276cb
--- /dev/null
+++ b/libs/luanet/src/main.c
@@ -0,0 +1,95 @@
+/*
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *   Copyright (C) 2008 John Crispin <blogic@openwrt.org> 
+ *   Copyright (C) 2008 Steven Barth <steven@midlink.org>
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+#include "route.h"
+#include "bridge.h"
+#include "ifconfig.h"
+#include "iwconfig.h"
+#include "vconfig.h"
+#include "df.h"
+#include "base64.h"
+
+int psleep(lua_State *L)
+{
+	int s;
+	if(lua_gettop(L) != 1)
+	{
+		lua_pushstring(L, "invalid arg list");
+		lua_error(L);
+		return 0;
+	}
+
+	s = (int)lua_tointeger (L, 1);
+	sleep(s);
+	return 0;
+}
+
+static luaL_reg func[] = {
+	{"ifc_getall", ifc_getall},
+	{"ifc_setip", ifc_setip},
+	{"ifc_setnetmask", ifc_setnetmask},
+	{"ifc_setbroadcast", ifc_setbroadcast},
+	{"ifc_setmtu", ifc_setmtu},
+	{"ifc_up", ifc_up},
+	{"ifc_down", ifc_down},
+	{"bridge_getall", bridge_getall},
+	{"bridge_new", bridge_new},
+	{"bridge_del", bridge_del},
+	{"bridge_addif", bridge_addif},
+	{"bridge_delif", bridge_delif},
+	{"iwc_getall", iwc_getall},
+	{"iwc_set_essid", iwc_set_essid},
+	{"iwc_set_mode", iwc_set_mode},
+	{"iwc_set_channel", iwc_set_channel},
+	{"iwc_scan", iwc_scan},
+	{"vlan_getall", vlan_getall},
+	{"vlan_add", vlan_add},
+	{"vlan_del", vlan_del},
+	{"df", df},
+	{"b64_encode", b64_encode},
+	{"b64_decode", b64_decode},
+	{"sleep", psleep},
+	{NULL, NULL}
+};
+
+int luaopen_luanet(lua_State *L)
+{
+	ifc_startup();
+	bridge_startup();
+	iwc_startup();
+	luaL_openlib(L, "luanet", func, 0);
+	lua_pushstring(L, "_VERSION");
+	lua_pushstring(L, "1.0");
+	lua_rawset(L, -3);
+	return 1;
+}
+
+int luaclose_luanet(lua_State *L)
+{
+	ifc_shutdown();
+	bridge_shutdown();
+	iwc_shutdown();
+	lua_pushstring(L, "Called");
+	return 1;
+}
diff --git a/libs/luanet/src/route.c b/libs/luanet/src/route.c
new file mode 100644
index 000000000..1690b74b7
--- /dev/null
+++ b/libs/luanet/src/route.c
@@ -0,0 +1,45 @@
+/*
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *   Copyright (C) 2008 John Crispin <blogic@openwrt.org> 
+ *   Copyright (C) 2008 Steven Barth <steven@midlink.org>
+ */
+
+#include <linux/sockios.h>
+#include <net/route.h>
+#include <sys/ioctl.h>
+
+#include "helper.h"
+
+extern int sock_ifconfig;
+
+int route_add(char *dev, int flag_gateway, int flag_host, char *dst, char *gateway, char *mask)
+{
+	struct rtentry r;
+	char ip[4];
+	r.rt_flags = RTF_UP;
+	if(flag_gateway)
+		r.rt_flags |= RTF_GATEWAY;
+	if(flag_host)
+		r.rt_flags |= RTF_HOST;
+	r.rt_dst.sa_family = AF_INET;
+	r.rt_gateway.sa_family = AF_INET;
+	r.rt_genmask.sa_family = AF_INET;
+	char2ipv4(dst, ip);
+	((struct sockaddr_in *) &r.rt_dst)->sin_addr.s_addr = (unsigned int)ip;
+	char2ipv4(gateway, ip);
+	((struct sockaddr_in *) &r.rt_gateway)->sin_addr.s_addr = (unsigned int)ip;
+	char2ipv4(mask, ip);
+	((struct sockaddr_in *) &r.rt_genmask)->sin_addr.s_addr = (unsigned int)ip;
+	return ioctl(sock_ifconfig, SIOCADDRT, (void *) &r);
+}
diff --git a/libs/luanet/src/route.h b/libs/luanet/src/route.h
new file mode 100644
index 000000000..53f6e98b9
--- /dev/null
+++ b/libs/luanet/src/route.h
@@ -0,0 +1,21 @@
+/*
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *   Copyright (C) 2008 John Crispin <blogic@openwrt.org> 
+ *   Copyright (C) 2008 Steven Barth <steven@midlink.org>
+ */
+
+#ifndef _ROUTE_H__
+#define _ROUTE_H__
+int route_add(char *dev, int flag_gateway, int flag_host, char *dst, char *gateway, char *mask);
+#endif
diff --git a/libs/luanet/src/test.lua b/libs/luanet/src/test.lua
new file mode 100755
index 000000000..713836b55
--- /dev/null
+++ b/libs/luanet/src/test.lua
@@ -0,0 +1,132 @@
+#!/usr/bin/lua
+
+print("luanet test")
+local luanet = require("luanet")
+
+print("sleeping 4 secs")
+luanet.sleep(4)
+
+print("---ifconfig---\n")
+print("set ip wlan0 -> 192.168.1.2")
+print(luanet.ifc_setip("wlan0", "192.168.1.2"))
+print("set ip wlan0:1 -> 192.168.2.2")
+print(luanet.ifc_setip("wlan0:1", "192.168.2.2"))
+print("set mtu wlan0 -> 1400")
+print(luanet.ifc_setmtu("wlan0", "1400"))
+--print("set down wlan0 ->")
+--print(luanet.ifc_down("wlan0"))
+--print("set up wlan0 ->")
+--print(luanet.ifc_up("wlan0"))
+local devs = luanet.ifc_getall()
+for i,v in pairs(devs) do
+	print("\ndev -> "..i)
+	print(devs[i].ip)
+	print(devs[i].netmask)
+	print(devs[i].broadaddr)
+	print(devs[i].mac)
+	print(devs[i].mtu)
+	print(devs[i].up)
+end
+
+
+print("\n\n---bridge---\n")
+print("add bridge br-test ->")
+print(luanet.bridge_new("br-test"))
+
+print("add wlan0 to br-test ->")
+print(luanet.bridge_addif("br-test", "wlan0"))
+
+print("listing bridges")
+local brs = luanet.bridge_getall()
+if brs then
+	for i,v in pairs(brs) do
+		print(i)
+		for j,k in pairs(v) do
+			print(j.."->"..k)
+		end
+	end
+end
+print("del wlan0 from br-test ->")
+print(luanet.bridge_delif("br-test", "wlan0"))
+
+print("del bridge br-test ->")
+print(luanet.bridge_del("br-test"))
+
+
+print("\n\n---wifi---\n")
+print("set wlan0 essid test123")
+print(luanet.iwc_set_essid("wlan0", "test123"))
+print("set wifi channel to 3")
+print(luanet.iwc_set_channel("wlan0", 3))
+print("set wifi to managed")
+print(luanet.iwc_set_mode("wlan0", "managed"))
+print("\nget all wifi devices")
+local wifidevs = luanet.iwc_getall()
+if wifidevs then
+	for i,v in pairs(wifidevs) do
+		print(i)
+		for j,k in pairs(v) do
+			print("  "..j.."->"..k)
+		end
+	end
+end
+local scan = luanet.iwc_scan("wlan0")
+print("\nscanning wifi on wlan0")
+if scan then
+	for i,v in pairs(scan) do
+		print("\n"..i)
+		print("  mac -> "..v.addr)
+		print("  frequency -> "..v.frequency)
+		print("  channel -> "..v.channel)
+		print("  mode -> "..v.mode)
+		print("  essid -> "..v.essid)
+		print("  key -> "..v.key)
+		print("  wpa1gcipher -> "..(v.wpa1gcipher or ""))
+		print("  wpa1pcipher -> "..(v.wpa1pcipher or ""))
+		print("  wpa1auth -> "..(v.wpa1auth or ""))
+		print("  wpa2gcipher -> "..(v.wpa2gcipher or ""))
+		print("  wpa2pcipher -> "..(v.wpa2pcipher or ""))
+		print("  wpa2auth -> "..(v.wpa2auth or ""))
+		print("  bitrates")
+		for j,k in ipairs(v.bitrates) do
+			--print(j.."->"..k)
+		end
+	end
+end
+
+
+print("\n\n---vlan---\n")
+print("add wlan0 to vlan0")
+print(luanet.vlan_add("wlan0", 0));
+print("add wlan0 to vlan1")
+print(luanet.vlan_add("wlan0", 1));
+print("del wlan0 from all vlans")
+print(luanet.vlan_del("wlan0.0"));
+print("add wlan0 to vlan6")
+print(luanet.vlan_add("wlan0", 6));
+local vlans = luanet.vlan_getall()
+if vlans then
+	for i,v in ipairs(vlans) do
+		print(i.."->"..v)
+	end
+end
+
+
+print("\n\n---df---\n")
+
+print("getting disc usage")
+local discs = luanet.df()
+if discs then
+	for i,v in ipairs(discs) do
+		print(i.."->")
+		for k,l in pairs(v) do
+			print("  "..k.."->"..l)
+		end
+	end
+end
+
+
+print("\n\n---b64---\n")
+print("test2 -->"..(luanet.b64_encode("test2") or "fail"))
+print("dGVzdDI= -->"..(luanet.b64_decode("dGVzdDI=") or "fail"))
+
diff --git a/libs/luanet/src/vconfig.c b/libs/luanet/src/vconfig.c
new file mode 100644
index 000000000..7adccc9a9
--- /dev/null
+++ b/libs/luanet/src/vconfig.c
@@ -0,0 +1,93 @@
+/*
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *   Copyright (C) 2008 John Crispin <blogic@openwrt.org> 
+ *   Copyright (C) 2008 Steven Barth <steven@midlink.org>
+ */
+
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <net/route.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <linux/sockios.h>
+#include <linux/if_vlan.h>
+#include <iwlib.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+extern int sock_ifconfig;
+
+
+static inline int _vlan_add(lua_State *L, int i)
+{
+	struct vlan_ioctl_args ifr;
+	int a = (i == ADD_VLAN_CMD)?(2):(1);
+	char *ifname;
+	if(lua_gettop(L) != a)
+	{
+		lua_pushstring(L, "invalid arg list");
+		lua_error(L);
+		return 0;
+	}
+	ifname = (char *)lua_tostring (L, 1);
+	ifr.cmd = i;
+	if(i == ADD_VLAN_CMD)
+		ifr.u.VID = (int)lua_tointeger (L, 2);
+	strncpy(ifr.device1, ifname, IFNAMSIZ);
+	if(!ioctl(sock_ifconfig, SIOCSIFVLAN, &ifr))
+		lua_pushboolean(L, 1);
+	else
+		lua_pushboolean(L, 0);
+	return 1;
+}
+
+int vlan_add(lua_State *L)
+{
+	return _vlan_add(L, ADD_VLAN_CMD);
+}
+
+int vlan_del(lua_State *L)
+{
+	return _vlan_add(L, DEL_VLAN_CMD);
+}
+
+int vlan_getall(lua_State *L)
+{
+	struct dirent **namelist;
+	int n = 0, i, count = 0;
+	count = scandir("/proc/net/vlan/", &namelist, NULL, alphasort);
+	if (count < 0)
+		return 0;
+	lua_newtable(L);
+	for (i = 0; i < count; i++)
+	{
+		if(strcmp(namelist[i]->d_name, "config") && (*namelist[i]->d_name != '.'))
+		{
+			n++;
+			lua_pushinteger(L, n);
+			lua_pushstring(L, namelist[i]->d_name);
+			lua_settable(L, -3);
+		}
+		free(namelist[i]);
+	}
+	free(namelist);
+	return 1;
+}
diff --git a/libs/luanet/src/vconfig.h b/libs/luanet/src/vconfig.h
new file mode 100644
index 000000000..25bb6161d
--- /dev/null
+++ b/libs/luanet/src/vconfig.h
@@ -0,0 +1,27 @@
+/*
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
+ *
+ *   Copyright (C) 2008 John Crispin <blogic@openwrt.org> 
+ *   Copyright (C) 2008 Steven Barth <steven@midlink.org>
+ */
+
+#ifndef _VCONFIG_H__
+#define _VCONFIG_H__
+
+int vlan_add(lua_State *L);
+int vlan_del(lua_State *L);
+int vlan_getall(lua_State *L);
+
+#endif