net lua

This adds a lua command line interpreter with some sample code how to build
your own data types based on our internal data types.

Not meant as the final word, but as a playground for experiments for people.
Might be removed later when we find this turns out to be too awkward.

3 files changed, 396 insertions, 0 deletions

diff --git a/source3/utils/net.c b/source3/utils/net.c
index f1a5be1876..c9525ab2eb 100644
--- a/source3/utils/net.c
+++ b/source3/utils/net.c
@@ -582,6 +582,13 @@ static struct functable net_func[] = {
 		"  Use 'net help registry' to get more information about 'net "
 		"registry' commands."
 	},
+	{	"lua",
+		net_lua,
+		NET_TRANSPORT_LOCAL,
+		"Open a lua interpreter",
+		"  Use 'net help lua' to get more information about 'net "
+		"lua' commands."
+	},
 #ifdef WITH_FAKE_KASERVER
 	{	"afs",
 		net_afs,
diff --git a/source3/utils/net_lua.c b/source3/utils/net_lua.c
new file mode 100644
index 0000000000..3a5d1bdeb6
--- /dev/null
+++ b/source3/utils/net_lua.c
@@ -0,0 +1,384 @@
+/*
+ *  Unix SMB/CIFS implementation.
+ *  Lua experiments
+ *  Copyright (C) Volker Lendecke 2006
+ *
+ *  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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "includes.h"
+#include "utils/net.h"
+
+#include "lua-5.1.4/src/lualib.h"
+#include "lua-5.1.4/src/lauxlib.h"
+
+#define SOCK_METATABLE "cade1208-9029-4d76-8748-426dfc1436f7"
+
+struct sock_userdata {
+	int fd;
+};
+
+static int sock_userdata_gc(lua_State *L)
+{
+	struct sock_userdata *p = (struct sock_userdata *)
+		luaL_checkudata(L, 1, SOCK_METATABLE);
+	close(p->fd);
+	return 0;
+}
+
+static int sock_userdata_tostring(lua_State *L)
+{
+	struct sock_userdata *p = (struct sock_userdata *)
+		luaL_checkudata(L, 1, SOCK_METATABLE);
+
+	lua_pushfstring(L, "socket: %d", p->fd);
+	return 1;
+}
+
+static int sock_userdata_connect(lua_State *L)
+{
+	struct sock_userdata *p = (struct sock_userdata *)
+		luaL_checkudata(L, 1, SOCK_METATABLE);
+	const char *hostname;
+	int port;
+	struct sockaddr_in addr;
+	int res;
+
+	if (!lua_isstring(L, 2)) {
+		luaL_error(L, "connect: Expected IP-Address");
+	}
+	hostname = lua_tostring(L, 2);
+
+	if (!lua_isnumber(L, 3)) {
+		luaL_error(L, "connect: Expected port");
+	}
+	port = lua_tointeger(L, 3);
+
+	if (lua_gettop(L) == 4) {
+		/*
+		 * Here we expect an event context in the last argument to
+		 * make connect() asynchronous.
+		 */
+	}
+
+	addr.sin_family = AF_INET;
+	inet_aton(hostname, &addr.sin_addr);
+	addr.sin_port = htons(port);
+
+	res = connect(p->fd, (struct sockaddr *)&addr, sizeof(addr));
+	if (res == -1) {
+		int err = errno;
+		lua_pushnil(L);
+		lua_pushfstring(L, "connect failed: %s", strerror(err));
+		return 2;
+	}
+
+	lua_pushboolean(L, 1);
+	return 1;
+}
+
+static const struct luaL_Reg sock_methods[] = {
+	{"__gc",	sock_userdata_gc},
+	{"__tostring",	sock_userdata_tostring},
+	{"connect",	sock_userdata_connect},
+	{NULL, NULL}
+};
+
+static const struct {
+	const char *name;
+	int domain;
+} socket_domains[] = {
+	{"PF_UNIX", PF_UNIX},
+	{"PF_INET", PF_INET},
+	{NULL, 0},
+};
+
+static const struct {
+	const char *name;
+	int type;
+} socket_types[] = {
+	{"SOCK_STREAM", SOCK_STREAM},
+	{"SOCK_DGRAM", SOCK_DGRAM},
+	{NULL, 0},
+};
+
+static int sock_userdata_new(lua_State *L)
+{
+	struct sock_userdata *result;
+	const char *domain_str = luaL_checkstring(L, 1);
+	const char *type_str = luaL_checkstring(L, 2);
+	int i, domain, type;
+
+	i = 0;
+	while (socket_domains[i].name != NULL) {
+		if (strcmp(domain_str, socket_domains[i].name) == 0) {
+			break;
+		}
+		i += 1;
+	}
+	if (socket_domains[i].name == NULL) {
+		return luaL_error(L, "socket domain %s unknown", domain_str);
+	}
+	domain = socket_domains[i].domain;
+
+	i = 0;
+	while (socket_types[i].name != NULL) {
+		if (strcmp(type_str, socket_types[i].name) == 0) {
+			break;
+		}
+		i += 1;
+	}
+	if (socket_types[i].name == NULL) {
+		return luaL_error(L, "socket type %s unknown", type_str);
+	}
+	type = socket_types[i].type;
+
+	result = (struct sock_userdata *)lua_newuserdata(L, sizeof(*result));
+	ZERO_STRUCTP(result);
+
+	result->fd = socket(domain, type, 0);
+	if (result->fd == -1) {
+		int err = errno;
+		lua_pushnil(L);
+		lua_pushfstring(L, "socket() failed: %s", strerror(errno));
+		lua_pushinteger(L, err);
+		return 3;
+	}
+
+	luaL_getmetatable(L, SOCK_METATABLE);
+	lua_setmetatable(L, -2);
+	return 1;
+}
+
+static const struct luaL_Reg sock_funcs[] = {
+	{"new",		sock_userdata_new},
+	{NULL, NULL}
+};
+
+static int sock_lua_init(lua_State *L, const char *libname) {
+	luaL_newmetatable(L, SOCK_METATABLE);
+
+	lua_pushvalue(L, -1);
+	lua_setfield(L, -2, "__index");
+
+	luaL_register(L, NULL, sock_methods);
+	luaL_register(L, libname, sock_funcs);
+	return 1;
+}
+
+#define EVT_METATABLE "c42e0642-b24a-40f0-8483-d8eb4aee9ea3"
+
+/*
+ * The userdata we allocate from lua when a new event context is created
+ */
+struct evt_userdata {
+	struct event_context *ev;
+};
+
+static bool evt_is_main_thread(lua_State *L) {
+	int ret;
+
+	ret = lua_pushthread(L);
+	lua_pop(L, 1);
+	return (ret != 0);
+}
+
+/*
+ * Per event we allocate a struct thread_reference to keep the coroutine from
+ * being garbage-collected. This is also the hook to find the right thread to
+ * be resumed.
+ */
+
+struct thread_reference {
+	struct lua_State *L;
+	/*
+	 * Reference to the Thread (i.e. lua_State) this event is hanging on
+	 */
+	int thread_ref;
+};
+
+static int thread_reference_destructor(struct thread_reference *ref)
+{
+	luaL_unref(ref->L, LUA_REGISTRYINDEX, ref->thread_ref);
+	return 0;
+}
+
+static struct thread_reference *evt_reference_thread(TALLOC_CTX *mem_ctx,
+						     lua_State *L)
+{
+	struct thread_reference *result;
+
+	result = talloc(mem_ctx, struct thread_reference);
+	if (result == NULL) {
+		return NULL;
+	}
+
+	lua_pushthread(L);
+	result->thread_ref = luaL_ref(L, LUA_REGISTRYINDEX);
+	result->L = L;
+	talloc_set_destructor(result, thread_reference_destructor);
+
+	return result;
+}
+
+static int evt_userdata_gc(lua_State *L)
+{
+	struct evt_userdata *p = (struct evt_userdata *)
+		luaL_checkudata(L, 1, EVT_METATABLE);
+	TALLOC_FREE(p->ev);
+	return 0;
+}
+
+static int evt_userdata_tostring(lua_State *L) {
+	lua_pushstring(L, "event context");
+	return 1;
+}
+
+static void evt_userdata_sleep_done(struct event_context *event_ctx,
+				   struct timed_event *te,
+				   const struct timeval *now,
+				   void *priv)
+{
+	struct thread_reference *ref = talloc_get_type_abort(
+		priv, struct thread_reference);
+	lua_resume(ref->L, 0);
+	TALLOC_FREE(ref);
+}
+
+static int evt_userdata_sleep(lua_State *L)
+{
+	struct evt_userdata *p = (struct evt_userdata *)
+		luaL_checkudata(L, 1, EVT_METATABLE);
+	lua_Integer usecs = luaL_checkint(L, 2);
+	struct thread_reference *ref;
+	struct timed_event *te;
+
+	if (evt_is_main_thread(L)) {
+		/*
+		 * Block in the main thread
+		 */
+		smb_msleep(usecs/1000);
+		return 0;
+	}
+
+	ref = evt_reference_thread(p->ev, L);
+	if (ref == NULL) {
+		return luaL_error(L, "evt_reference_thread failed\n");
+	}
+
+	te = event_add_timed(p->ev, ref, timeval_current_ofs(0, usecs),
+			     "evt_userdata_sleep", evt_userdata_sleep_done,
+			     ref);
+
+	if (te == NULL) {
+		TALLOC_FREE(ref);
+		return luaL_error(L, "event_add_timed failed");
+	}
+
+	return lua_yield(L, 0);
+}
+
+static int evt_userdata_once(lua_State *L)
+{
+	struct evt_userdata *p = (struct evt_userdata *)
+		luaL_checkudata(L, 1, EVT_METATABLE);
+
+	if (!evt_is_main_thread(L)) {
+		return luaL_error(L, "event_once called from non-base thread");
+	}
+
+	lua_pushinteger(L, event_loop_once(p->ev));
+	return 1;
+}
+
+static const struct luaL_Reg evt_methods[] = {
+	{"__gc",	evt_userdata_gc},
+	{"__tostring",	evt_userdata_tostring},
+	{"sleep",	evt_userdata_sleep},
+	{"once",	evt_userdata_once},
+	{NULL, NULL}
+};
+
+static int evt_userdata_new(lua_State *L) {
+	struct evt_userdata *result;
+
+	result = (struct evt_userdata *)lua_newuserdata(L, sizeof(*result));
+	ZERO_STRUCTP(result);
+
+	result->ev = event_context_init(NULL);
+	if (result->ev == NULL) {
+		return luaL_error(L, "event_context_init failed");
+	}
+
+	luaL_getmetatable(L, EVT_METATABLE);
+	lua_setmetatable(L, -2);
+	return 1;
+}
+
+static const struct luaL_Reg evt_funcs[] = {
+	{"new",		evt_userdata_new},
+	{NULL, NULL}
+};
+
+static int evt_lua_init(lua_State *L, const char *libname) {
+	luaL_newmetatable(L, EVT_METATABLE);
+
+	lua_pushvalue(L, -1);
+	lua_setfield(L, -2, "__index");
+
+	luaL_register(L, NULL, evt_methods);
+	luaL_register(L, libname, evt_funcs);
+	return 1;
+}
+
+int net_lua(struct net_context *c, int argc, const char **argv)
+{
+	lua_State *state;
+
+	state = lua_open();
+	if (state == NULL) {
+		d_fprintf(stderr, "lua_newstate failed\n");
+		return -1;
+	}
+
+	luaL_openlibs(state);
+	evt_lua_init(state, "event");
+	sock_lua_init(state, "socket");
+
+	while (1) {
+		char *line = NULL;
+
+		line = smb_readline("lua> ", NULL, NULL);
+		if (line == NULL) {
+			break;
+		}
+
+		if (line[0] == ':') {
+			if (luaL_dofile(state, &line[1])) {
+				d_printf("luaL_dofile returned an error\n");
+				continue;
+			}
+		} else if (line[0] != '\n') {
+			if (luaL_dostring(state, line) != 0) {
+				d_printf("luaL_dostring returned an error\n");
+			}
+		}
+
+		SAFE_FREE(line);
+	}
+
+	lua_close(state);
+	return -1;
+}
diff --git a/source3/utils/net_proto.h b/source3/utils/net_proto.h
index c058a0166f..a65fbbb6eb 100644
--- a/source3/utils/net_proto.h
+++ b/source3/utils/net_proto.h
@@ -423,6 +423,11 @@ int net_usershare_usage(struct net_context *c, int argc, const char **argv);
 int net_usershare_help(struct net_context *c, int argc, const char **argv);
 int net_usershare(struct net_context *c, int argc, const char **argv);
 
+/* The following definitions come from utils/net_lua.c  */
+
+int net_lua(struct net_context *c, int argc, const char **argv);
+
+
 /* The following definitions come from utils/net_util.c  */
 
 NTSTATUS net_rpc_lookup_name(struct net_context *c,