/*

 * Copyright (C) 2009  J. Ali Harlow <ali@juiblex.co.uk>

 *

 * 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.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 */

#include "config.h"

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include <errno.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <lua.h>

#include <lualib.h>

#include <lauxlib.h>

#include "razor.h"

#include "razor-internal.h"

#define MAX_ARGS		2

#define ARG_FLAG_OPT		0x1

#define ARG_FLAG_BYPASS		0x2

#define ARG(flags, swtch, index, type) \

				((flags) << 26 | (swtch) << 21 | \

				 (index) << 16 | type)

#define ARG_FLAGS(arg)		((unsigned)(arg) >> 26)

#define ARG_SWTCH(arg)		((unsigned)(arg) >> 21 & 0x1F)

#define ARG_INDEX(arg)		((unsigned)(arg) >> 16 & 0x1F)

#define ARG_TYPE(arg)		((unsigned)(arg) & 0xFFFF)

#define ARG_NONE		0

#define ARG_STRING(n)		ARG(0, 0, n, LUA_TSTRING)

#define ARG_OPT_STRING(n)	ARG(ARG_FLAG_OPT, 0, n, LUA_TSTRING)

#define ARG_BYP_STRING(n, s)	ARG(ARG_FLAG_BYPASS, s, n, LUA_TSTRING)

struct razor_proxy {

	char *table, *name;

	int result;

	unsigned args[MAX_ARGS];

};

static struct razor_proxy proxy[] = {

	{ NULL, "dofile", LUA_TNONE, { ARG_STRING(1) } },

	{ NULL, "loadfile", LUA_TNONE, { ARG_OPT_STRING(1) } },

	{ "io", "input", LUA_TNONE, { ARG_OPT_STRING(1) } },

	{ "io", "output", LUA_TNONE, { ARG_OPT_STRING(1) } },

	{ "io", "lines", LUA_TNONE, { ARG_OPT_STRING(1) } },

	{ "io", "open", LUA_TNONE, { ARG_STRING(1) } },

	{ "io", "popen", LUA_TNONE, { ARG_STRING(1) } },

	/*

	 * Note: We do not proxy os.execute

	 * We can't do it properly (there is no way to distinguish filenames

	 * in arguments from any other strings) so it's better not to try.

	 * Scripts that attempt to be portable should use posix.exec[p]

	 */

	{ "os", "remove", LUA_TNONE, { ARG_STRING(1) } },

	{ "os", "rename", LUA_TNONE, { ARG_STRING(1), ARG_STRING(2) } },

	/*

	 * Note: We do not proxy os.tmpname

	 * It should never be used. scripts should use io.tmpfile instead

	 * if the rather limited functionality it provides suffices. The

	 * proper solution is to implement posix.mkstemp

	 */

	{ "posix", "access", LUA_TNONE, { ARG_STRING(1) } },

	{ "posix", "chdir", LUA_TNONE, { ARG_STRING(1) } },

	{ "posix", "chmod", LUA_TNONE, { ARG_STRING(1) } },

	{ "posix", "chown", LUA_TNONE, { ARG_STRING(1) } },

	{ "posix", "dir", LUA_TNONE, { ARG_OPT_STRING(1) } },

	{ "posix", "exec", LUA_TNONE, { ARG_STRING(1) } },

	{ "posix", "execp", LUA_TNONE, { ARG_STRING(1) } },

	{ "posix", "files", LUA_TNONE, { ARG_OPT_STRING(1) } },

	{ "posix", "getcwd", LUA_TSTRING, { ARG_NONE } },

	{ "posix", "glob", LUA_TTABLE, { ARG_STRING(1) } },

	{ "posix", "link", LUA_TNONE, { ARG_BYP_STRING(1, 3), ARG_STRING(2) } },

	{ "posix", "mkdir", LUA_TNONE, { ARG_STRING(1) } },

	{ "posix", "mkfifo", LUA_TNONE, { ARG_STRING(1) } },

	{ "posix", "pathconf", LUA_TNONE, { ARG_STRING(1) } },

	{ "posix", "readlink", LUA_TNONE, { ARG_STRING(1) } },

	{ "posix", "rmdir", LUA_TNONE, { ARG_STRING(1) } },

	{ "posix", "stat", LUA_TNONE, { ARG_STRING(1) } },

	{ "posix", "unlink", LUA_TNONE, { ARG_STRING(1) } },

	{ "posix", "utime", LUA_TNONE, { ARG_STRING(1) } },

};

static lua_CFunction execp_handler;

struct razor_lua {

	const char *root;

	lua_CFunction handler[ARRAY_SIZE(proxy)];

};

static void *alloc_lua(void *user_data, void *ptr, size_t osize, size_t nsize)

{

	if (!nsize) {

		free(ptr);

		return NULL;

	} else

		return realloc(ptr, nsize);

}

static int proxy_execp(lua_State *L)

{

	int r, n, err, got_eacces = 0;

	char *file = strdup(luaL_checkstring(L, 1));

	char *exe;

	const char *s, *e, *path;

	struct razor_lua *rl;

	if (*file == '\0' || strchr(file, '/')) {

		r = execp_handler(L);

		free(file);

		return r;

	}

	(void)lua_getallocf(L, (void **)&rl);

	path = getenv("PATH");

	if (!path)

		path = ":/bin:/usr/bin";

	s = path;

	for (;;) {

		e = strchr(s, ':');

		if (!e)

			e = s + strlen(s);

		if (*s == '/') {

			n = strlen(rl->root);

			exe = malloc(n + (e - s) + 1 + strlen(file) + 1);

			memcpy(exe, rl->root, n);

			memcpy(exe + n, s, e - s);

			n += e - s;

			exe[n++] = '/';

			strcpy(exe + n, file);

		} else if (e != s) {

			exe = malloc((e - s) + 1 + strlen(file) + 1);

			memcpy(exe, s, e - s);

			n = e - s;

			exe[n++] = '/';

			strcpy(exe + n, file);

		} else {

			/* Ensure exe contains a slash to avoid PATH search */

			exe = malloc(2 + strlen(file) + 1);

			exe[0] = '.';

			exe[1] = '/';

			strcpy(exe + 2, file);

		}

		lua_pushstring(L, exe);

		lua_replace(L, 1);

		free(exe);

		n = lua_gettop(L);

		r = execp_handler(L);

		err = lua_tointeger(L, -1);

		switch (err) {

		case EACCES:

			got_eacces = 1;

			/* Fall through */

		case ENOENT:

		case ESTALE:

		case ENOTDIR:

		case ENODEV:

		case ETIMEDOUT:

			lua_pop(L, lua_gettop(L) - n);

			break;

		default:

			free(file);

			return r;

		}

		if (*e)

			s = e + 1;

		else

			break;

	}

	if (got_eacces)

		err = EACCES;

	lua_pushnil(L);

	lua_pushfstring(L, "%s: %s", file, strerror(err));

	lua_pushinteger(L, err);

	free(file);

	return 3;

}

static int real2fake(lua_State *L, struct razor_lua *rl, int indx)

{

	const char *path;

	if (indx < 0)

		indx += lua_gettop(L) + 1;

	if (lua_type(L, indx) == LUA_TSTRING) {

		path = lua_tostring(L, indx);

		if (path && !strncmp(path, rl->root, strlen(rl->root)) &&

		   (path[strlen(rl->root)] == '/' || !path[strlen(rl->root)])) {

			lua_pushstring(L, path + strlen(rl->root));

			lua_replace(L, indx);

			return 1;

		}

	}

	return 0;

}

static int proxy_handler(lua_State *L)

{

	int i, retval, cond;

	unsigned arg;

	const char *path;

	struct razor_lua *rl;

	int method = lua_tointeger(L, lua_upvalueindex(1));

	struct razor_proxy *rp = proxy + method;

	(void)lua_getallocf(L, (void **)&rl);

	for(i = 0; i < MAX_ARGS; i++) {

		arg = rp->args[i];

		if (arg == ARG_NONE)

			continue;

		switch (ARG_TYPE(arg)) {

		case LUA_TSTRING:

			if (ARG_FLAGS(arg) & ARG_FLAG_BYPASS)

				cond = !lua_toboolean(L, ARG_SWTCH(arg));

			else

				cond = 1;

			if (ARG_FLAGS(arg) & ARG_FLAG_OPT) {

				if (lua_isstring(L, ARG_INDEX(arg)))

					path = lua_tostring(L, ARG_INDEX(arg));

				else

					path = NULL;

			} else

				path = luaL_checkstring(L, ARG_INDEX(arg));

			if (cond && path && *path == '/') {

				lua_pushfstring(L, "%s%s", rl->root, path);

				lua_replace(L, ARG_INDEX(arg));

			}

			break;

		default:

			lua_pushfstring(L, "razor proxy: Unhandled type (%d)",

					ARG_TYPE(arg));

			lua_error(L);

		}

	}

	retval = rl->handler[method](L);

	if (rp->result != LUA_TNONE && !lua_isnil(L, 1)) {

		switch (rp->result) {

		case LUA_TNONE:

			break;

		case LUA_TSTRING:

			real2fake(L, rl, -1);

			break;

		case LUA_TTABLE:

			lua_pushnil(L);

			while (lua_next(L, -2)) {

				if (real2fake(L, rl, -1)) {

					i = lua_tonumber(L, -2);

					lua_rawseti(L, -3, i);

				} else

					lua_pop(L, 1);

			}

			break;

		default:

			lua_pushfstring(L, "razor proxy: Unhandled type (%d)",

					rp->result);

			lua_error(L);

		}

	}

	return retval;

}

struct razor_lua_loader {

	uint32_t name;

	lua_CFunction func;

};

static struct razor_preload {

	int init;

	struct hashtable modules;

	struct array name_pool;

	struct array loaders;

} razor_preload = {0};

RAZOR_EXPORT void razor_set_lua_loader(const char *modname, void (*loader)())

{

	uint32_t name;

	struct razor_lua_loader *ploader, *end;

	if (!razor_preload.init) {

		razor_preload.init = 1;

		array_init(&razor_preload.name_pool);

		array_init(&razor_preload.loaders);

		hashtable_init(&razor_preload.modules,

			       &razor_preload.name_pool);

	}

	name = hashtable_tokenize(&razor_preload.modules, modname);

	end = razor_preload.loaders.data + razor_preload.loaders.size;

	for(ploader = razor_preload.loaders.data; ploader < end; ploader++)

		if (ploader->name == name) {

			ploader->func = loader;

			return;

		}

	ploader = array_add(&razor_preload.loaders, sizeof(*ploader));

	ploader->name = name;

	ploader->func = loader;

}

RAZOR_EXPORT void (*razor_get_lua_loader(const char *modname))()

{

	uint32_t name;

	struct razor_lua_loader *ploader, *end;

	if (!razor_preload.init)

		return 0;

	name = hashtable_lookup(&razor_preload.modules, modname);

	end = razor_preload.loaders.data + razor_preload.loaders.size;

	for(ploader = razor_preload.loaders.data; ploader < end; ploader++)

		if (ploader->name == name)

			return ploader->func;

	return 0;

}

static void razor_lua_preload(lua_State *L)

{

	struct razor_lua_loader *ploader, *end;

	if (!razor_preload.init)

		return;

	lua_getfield(L, LUA_GLOBALSINDEX, "package");

	lua_getfield(L, -1, "preload");

	lua_remove(L, -2);

	end = razor_preload.loaders.data + razor_preload.loaders.size;

	for(ploader = razor_preload.loaders.data; ploader < end; ploader++) {

		lua_pushcfunction(L, ploader->func);

		lua_setfield(L, -2,

			     razor_preload.name_pool.data + ploader->name);

	}

	lua_pop(L, 1);

}

int run_lua_script(const char *root, const char *name, const char *body,

		   ssize_t len, int arg1)

{

	int i, n;

	lua_State *L;

	struct razor_lua rl;

	if (root && strcmp(root, "/"))

		rl.root = root;

	else

		rl.root = NULL;

	L = lua_newstate(alloc_lua, &rl);

	luaL_openlibs(L);

	razor_lua_preload(L);

	lua_getglobal(L, "require");

	lua_pushstring(L, "posix");

	if (lua_pcall(L, 1, 1, 0)) {

		fprintf(stderr, "lua posix: %s\n", lua_tostring(L, -1));

		lua_pop(L, 1);

		lua_close(L);

		return -1;

	}

	if (rl.root)

		for(i = 0; i < ARRAY_SIZE(proxy); i++) {

			if (proxy[i].table) {

				lua_getglobal(L, proxy[i].table);

				n = lua_gettop(L);

			} else

				n = LUA_GLOBALSINDEX;

			lua_getfield(L, n, proxy[i].name);

			rl.handler[i] = lua_tocfunction(L, -1);

			lua_getfenv(L, -1);

			lua_remove(L, -2);

			if (proxy[i].table &&

			    !strcmp(proxy[i].table, "posix") &&

			    !strcmp(proxy[i].name, "execp")) {

				execp_handler = rl.handler[i];

				rl.handler[i] = proxy_execp;

			}

			lua_pushinteger(L, i);

			lua_pushcclosure(L, proxy_handler, 1);

			lua_pushvalue(L, -2);

			lua_setfenv(L, -2);

			lua_setfield(L, n, proxy[i].name);

			if (proxy[i].table)

				lua_pop(L, 2);

			else

				lua_pop(L, 1);

		}

	if (len < 0)

		len = strlen(body);

	if (luaL_loadbuffer(L, body, len, name)) {

		fprintf(stderr, "failed to load lua script\n");

		lua_close(L);

		return -1;

	}

	lua_newtable(L);

	lua_pushvalue(L, LUA_GLOBALSINDEX);

	lua_pushliteral(L, "arg");

	lua_pushvalue(L, -3);

	lua_rawset(L, -3);

	lua_pop(L, 1);

	lua_pushliteral(L, "<lua>");

	lua_rawseti(L, -2, 1);

	if (arg1 >= 0) {

		lua_pushinteger(L, arg1);

		lua_rawseti(L, -2, 2);

	}

	lua_pop(L, 1);

	if (lua_pcall(L, 0, 0, 0)) {

		fprintf(stderr, "lua script failed: %s\n", lua_tostring(L, -1));

		lua_pop(L, 1);

		lua_close(L);

		return -1;

	}

	lua_close(L);

	return 0;

}