#include "system.h"

#ifdef	WITH_LUA

#include <lua.h>

#include <lualib.h>

#include <lauxlib.h>

#include <lposix.h>

#include <lrexlib.h>

/* replaced in 5.1 */

#ifndef lua_open

#define lua_open()	luaL_newstate()

#endif

/* defined as lua_objlen in 5.1 */

#ifndef lua_strlen

#define lua_strlen(L,i)	lua_rawlen(L, (i))

#endif

/* deprecated in 5.1, defined as lua_objlen in 5.1 */

#ifndef luaL_getn

#define luaL_getn(L,i)	((int)lua_rawlen(L, i))

#endif

/* define added in 5.2 */

#ifndef lua_pushglobaltable

#define lua_pushglobaltable(L)	lua_pushvalue(L, LUA_GLOBALSINDEX)

#endif

#include <unistd.h>

#include <assert.h>

#include <rpm/rpmio.h>

#include <rpm/rpmmacro.h>

#include <rpm/rpmlog.h>

#include <rpm/rpmurl.h>

#include <rpm/rpmfileutil.h>

#include <rpm/rpmbase64.h>

#include "rpmio/rpmhook.h"

#define _RPMLUA_INTERNAL

#include "rpmio/rpmlua.h"

#include "debug.h"

#define INITSTATE(_lua, lua) \

    rpmlua lua = _lua ? _lua : \

	    (globalLuaState ? globalLuaState : \

			\

			(globalLuaState = rpmluaNew()) \

			\

	    )

struct rpmluapb_s {

    size_t alloced;

    size_t used;

    char *buf;

    rpmluapb next;

};

static rpmlua globalLuaState = NULL;

static char *(*nextFileFunc)(void *) = NULL;

static void *nextFileFuncParam = NULL;

static int luaopen_rpm(lua_State *L);

static int rpm_print(lua_State *L);

rpmlua rpmluaGetGlobalState(void)

{

    INITSTATE(NULL, lua);

    return lua;

}

rpmlua rpmluaNew()

{

    rpmlua lua = (rpmlua) xcalloc(1, sizeof(*lua));

    struct stat st;

    const luaL_Reg *lib;

    char *initlua = rpmGenPath(rpmConfigDir(), "init.lua", NULL);

    static const luaL_Reg extlibs[] = {

	{"posix", luaopen_posix},

	{"rex", luaopen_rex},

	{"rpm", luaopen_rpm},

	{"os",	luaopen_rpm_os},

	{NULL, NULL},

    };

    lua_State *L = lua_open();

    luaL_openlibs(L);

    lua->L = L;

    for (lib = extlibs; lib->name; lib++) {

	lua_pushcfunction(L, lib->func);

	lua_pushstring(L, lib->name);

	lua_call(L, 1, 0);

	lua_settop(L, 0);

    }

#ifndef LUA_GLOBALSINDEX

    lua_pushglobaltable(L);

#endif

    lua_pushliteral(L, "LUA_PATH");

    lua_pushfstring(L, "%s/%s", rpmConfigDir(), "/lua/?.lua");

#ifdef LUA_GLOBALSINDEX

    lua_rawset(L, LUA_GLOBALSINDEX);

#else

    lua_settable(L, -3);

#endif

    lua_pushliteral(L, "print");

    lua_pushcfunction(L, rpm_print);

#ifdef LUA_GLOBALSINDEX

    lua_rawset(L, LUA_GLOBALSINDEX);

#else

    lua_settable(L, -3);

#endif

#ifndef LUA_GLOBALSINDEX

    lua_pop(L, 1);

#endif

    rpmluaSetData(lua, "lua", lua);

    if (stat(initlua, &st) != -1)

	(void)rpmluaRunScriptFile(lua, initlua);

    free(initlua);

    return lua;

}

rpmlua rpmluaFree(rpmlua lua)

{

    if (lua) {

	if (lua->L) lua_close(lua->L);

	free(lua->printbuf);

	free(lua);

	if (lua == globalLuaState) globalLuaState = NULL;

    }

    return NULL;

}

void rpmluaSetData(rpmlua _lua, const char *key, const void *data)

{

    INITSTATE(_lua, lua);

    lua_State *L = lua->L;

    lua_pushliteral(L, "rpm_");

    lua_pushstring(L, key);

    lua_concat(L, 2);

    if (data == NULL)

	lua_pushnil(L);

    else

	lua_pushlightuserdata(L, (void *)data);

    lua_rawset(L, LUA_REGISTRYINDEX);

}

static void *getdata(lua_State *L, const char *key)

{

    void *ret = NULL;

    lua_pushliteral(L, "rpm_");

    lua_pushstring(L, key);

    lua_concat(L, 2);

    lua_rawget(L, LUA_REGISTRYINDEX);

    if (lua_islightuserdata(L, -1))

	ret = lua_touserdata(L, -1);

    lua_pop(L, 1);

    return ret;

}

void *rpmluaGetData(rpmlua _lua, const char *key)

{

    INITSTATE(_lua, lua);

    return getdata(lua->L, key);

}

void rpmluaPushPrintBuffer(rpmlua _lua)

{

    INITSTATE(_lua, lua);

    rpmluapb prbuf = xcalloc(1, sizeof(*prbuf));

    prbuf->buf = NULL;

    prbuf->alloced = 0;

    prbuf->used = 0;

    prbuf->next = lua->printbuf;

    lua->printbuf = prbuf;

}

char *rpmluaPopPrintBuffer(rpmlua _lua)

{

    INITSTATE(_lua, lua);

    rpmluapb prbuf = lua->printbuf;

    char *ret = NULL;

    if (prbuf) {

	ret = prbuf->buf;

	lua->printbuf = prbuf->next;

	free(prbuf);

    }

    return ret;

}

static int pushvar(lua_State *L, rpmluavType type, void *value)

{

    int ret = 0;

    switch (type) {

	case RPMLUAV_NIL:

	    lua_pushnil(L);

	    break;

	case RPMLUAV_STRING:

	    lua_pushstring(L, *((char **)value));

	    break;

	case RPMLUAV_NUMBER:

	    lua_pushnumber(L, *((double *)value));

	    break;

	default:

	    ret = -1;

	    break;

    }

    return ret;

}

void rpmluaSetNextFileFunc(char *(*func)(void *), void *funcParam)

{

    nextFileFunc = func;

    nextFileFuncParam = funcParam;

}

void rpmluaSetVar(rpmlua _lua, rpmluav var)

{

    INITSTATE(_lua, lua);

    lua_State *L = lua->L;

    if (var->listmode && lua->pushsize > 0) {

	if (var->keyType != RPMLUAV_NUMBER || var->key.num == (double)0) {

	    var->keyType = RPMLUAV_NUMBER;

	    var->key.num = (double) luaL_getn(L, -1);

	}

	var->key.num++;

    }

    if (!var->listmode || lua->pushsize > 0) {

	if (lua->pushsize == 0)

	    lua_pushglobaltable(L);

	if (pushvar(L, var->keyType, &var->key) != -1) {

	    if (pushvar(L, var->valueType, &var->value) != -1)

		lua_rawset(L, -3);

	    else

		lua_pop(L, 1);

	}

	if (lua->pushsize == 0)

	    lua_pop(L, 1);

    }

}

static void popvar(lua_State *L, rpmluavType *type, void *value)

{

    switch (lua_type(L, -1)) {

    case LUA_TSTRING:

	*type = RPMLUAV_STRING;

	*((const char **)value) = lua_tostring(L, -1);

	break;

    case LUA_TNUMBER:

	*type = RPMLUAV_NUMBER;

	*((double *)value) = lua_tonumber(L, -1);

	break;

    default:

	*type = RPMLUAV_NIL;

	*((void **)value) = NULL;

	break;

    }

    lua_pop(L, 1);

}

void rpmluaGetVar(rpmlua _lua, rpmluav var)

{

    INITSTATE(_lua, lua);

    lua_State *L = lua->L;

    if (!var->listmode) {

	if (lua->pushsize == 0)

	    lua_pushglobaltable(L);

	if (pushvar(L, var->keyType, &var->key) != -1) {

	    lua_rawget(L, -2);

	    popvar(L, &var->valueType, &var->value);

	}

	if (lua->pushsize == 0)

	    lua_pop(L, 1);

    } else if (lua->pushsize > 0) {

	(void) pushvar(L, var->keyType, &var->key);

	if (lua_next(L, -2) != 0)

	    popvar(L, &var->valueType, &var->value);

    }

}

#define FINDKEY_RETURN 0

#define FINDKEY_CREATE 1

#define FINDKEY_REMOVE 2

static int findkey(lua_State *L, int oper, const char *key, va_list va)

{

    char *buf;

    const char *s, *e;

    int ret = 0;

    int blen;

    blen = vsnprintf(NULL, 0, key, va);

    if (blen <= 0) {

	return -1;

    }

    buf = xmalloc(blen + 1);

    vsnprintf(buf, blen + 1, key, va);

    s = e = buf;

    lua_pushglobaltable(L);

    for (;;) {

	if (*e == '\0' || *e == '.') {

	    if (e != s) {

		lua_pushlstring(L, s, e-s);

		switch (oper) {

		case FINDKEY_REMOVE:

		    if (*e == '\0') {

			lua_pushnil(L);

			lua_rawset(L, -3);

			lua_pop(L, 1);

			break;

		    }

		case FINDKEY_RETURN:

		    lua_rawget(L, -2);

		    lua_remove(L, -2);

		    break;

		case FINDKEY_CREATE:

		    lua_rawget(L, -2);

		    if (!lua_istable(L, -1)) {

			lua_pop(L, 1);

			lua_newtable(L);

			lua_pushlstring(L, s, e-s);

			lua_pushvalue(L, -2);

			lua_rawset(L, -4);

		    }

		    lua_remove(L, -2);

		    break;

		}

	    }

	    if (*e == '\0')

		break;

	    if (!lua_istable(L, -1)) {

		lua_pop(L, 1);

		ret = -1;

		break;

	    }

	    s = e+1;

	}

	e++;

    }

    free(buf);

    return ret;

}

void rpmluaDelVar(rpmlua _lua, const char *key, ...)

{

    INITSTATE(_lua, lua);

    va_list va;

    va_start(va, key);

    (void) findkey(lua->L, FINDKEY_REMOVE, key, va);

    va_end(va);

}

int rpmluaVarExists(rpmlua _lua, const char *key, ...)

{

    INITSTATE(_lua, lua);

    lua_State *L = lua->L;

    int ret = 0;

    va_list va;

    va_start(va, key);

    if (findkey(L, FINDKEY_RETURN, key, va) == 0) {

	if (!lua_isnil(L, -1))

	    ret = 1;

	lua_pop(L, 1);

    }

    va_end(va);

    return ret;

}

void rpmluaPushTable(rpmlua _lua, const char *key, ...)

{

    INITSTATE(_lua, lua);

    va_list va;

    va_start(va, key);

    (void) findkey(lua->L, FINDKEY_CREATE, key, va);

    lua->pushsize++;

    va_end(va);

}

void rpmluaPop(rpmlua _lua)

{

    INITSTATE(_lua, lua);

    assert(lua->pushsize > 0);

    lua->pushsize--;

    lua_pop(lua->L, 1);

}

rpmluav rpmluavNew(void)

{

    rpmluav var = (rpmluav) xcalloc(1, sizeof(*var));

    return var;

}

rpmluav rpmluavFree(rpmluav var)

{

    free(var);

    return NULL;

}

void rpmluavSetListMode(rpmluav var, int flag)

{

    var->listmode = flag;

    var->keyType = RPMLUAV_NIL;

}

void rpmluavSetKey(rpmluav var, rpmluavType type, const void *value)

{

    var->keyType = type;

    switch (type) {

	case RPMLUAV_NUMBER:

	    var->key.num = *((double *)value);

	    break;

	case RPMLUAV_STRING:

	    var->key.str = (char *)value;

	    break;

	default:

	    break;

    }

}

void rpmluavSetValue(rpmluav var, rpmluavType type, const void *value)

{

    var->valueType = type;

    switch (type) {

	case RPMLUAV_NUMBER:

	    var->value.num = *((const double *)value);

	    break;

	case RPMLUAV_STRING:

	    var->value.str = (const char *)value;

	    break;

	default:

	    break;

    }

}

void rpmluavGetKey(rpmluav var, rpmluavType *type, void **value)

{

    *type = var->keyType;

    switch (var->keyType) {

	case RPMLUAV_NUMBER:

	    *((double **)value) = &var->key.num;

	    break;

	case RPMLUAV_STRING:

	    *((const char **)value) = var->key.str;

	    break;

	default:

	    break;

    }

}

void rpmluavGetValue(rpmluav var, rpmluavType *type, void **value)

{

    *type = var->valueType;

    switch (var->valueType) {

	case RPMLUAV_NUMBER:

	    *((double **)value) = &var->value.num;

	    break;

	case RPMLUAV_STRING:

	    *((const char **)value) = var->value.str;

	    break;

	default:

	    break;

    }

}

void rpmluavSetKeyNum(rpmluav var, double value)

{

    rpmluavSetKey(var, RPMLUAV_NUMBER, &value);

}

void rpmluavSetValueNum(rpmluav var, double value)

{

    rpmluavSetValue(var, RPMLUAV_NUMBER, &value);

}

double rpmluavGetKeyNum(rpmluav var)

{

    rpmluavType type;

    void *value;

    rpmluavGetKey(var, &type, &value);

    if (type == RPMLUAV_NUMBER)

	return *((double *)value);

    return (double) 0;

}

double rpmluavGetValueNum(rpmluav var)

{

    rpmluavType type;

    void *value;

    rpmluavGetValue(var, &type, &value);

    if (type == RPMLUAV_NUMBER)

	return *((double *)value);

    return (double) 0;

}

int rpmluavKeyIsNum(rpmluav var)

{

    return (var->keyType == RPMLUAV_NUMBER) ? 1 : 0;

}

int rpmluavValueIsNum(rpmluav var)

{

    return (var->valueType == RPMLUAV_NUMBER) ? 1 : 0;

}

int rpmluaCheckScript(rpmlua _lua, const char *script, const char *name)

{

    INITSTATE(_lua, lua);

    lua_State *L = lua->L;

    int ret = 0;

    if (name == NULL)

	name = "<lua>";

    if (luaL_loadbuffer(L, script, strlen(script), name) != 0) {

	rpmlog(RPMLOG_ERR,

		_("invalid syntax in lua scriptlet: %s\n"),

		  lua_tostring(L, -1));

	ret = -1;

    }

    lua_pop(L, 1); /* Error or chunk. */

    return ret;

}

int rpmluaRunScript(rpmlua _lua, const char *script, const char *name)

{

    INITSTATE(_lua, lua);

    lua_State *L = lua->L;

    int ret = 0;

    if (name == NULL)

	name = "<lua>";

    if (script == NULL)

	script = "";

    if (luaL_loadbuffer(L, script, strlen(script), name) != 0) {

	rpmlog(RPMLOG_ERR, _("invalid syntax in lua script: %s\n"),

		 lua_tostring(L, -1));

	lua_pop(L, 1);

	ret = -1;

    } else if (lua_pcall(L, 0, 0, 0) != 0) {

	rpmlog(RPMLOG_ERR, _("lua script failed: %s\n"),

		 lua_tostring(L, -1));

	lua_pop(L, 1);

	ret = -1;

    }

    return ret;

}

int rpmluaRunScriptFile(rpmlua _lua, const char *filename)

{

    INITSTATE(_lua, lua);

    lua_State *L = lua->L;

    int ret = 0;

    if (luaL_loadfile(L, filename) != 0) {

	rpmlog(RPMLOG_ERR, _("invalid syntax in lua file: %s\n"),

		 lua_tostring(L, -1));

	lua_pop(L, 1);

	ret = -1;

    } else if (lua_pcall(L, 0, 0, 0) != 0) {

	rpmlog(RPMLOG_ERR, _("lua script failed: %s\n"),

		 lua_tostring(L, -1));

	lua_pop(L, 1);

	ret = -1;

    }

    return ret;

}

/* From lua.c */

static int rpmluaReadline(lua_State *L, const char *prompt)

{

   static char buffer[1024];

   if (prompt) {

      (void) fputs(prompt, stdout);

      (void) fflush(stdout);

   }

   if (fgets(buffer, sizeof(buffer), stdin) == NULL) {

      return 0;  /* read fails */

   } else {

      lua_pushstring(L, buffer);

      return 1;

   }

}

/* Based on lua.c */

static void _rpmluaInteractive(lua_State *L)

{

   (void) fputs("\n", stdout);

   printf("RPM Interactive %s Interpreter\n", LUA_VERSION);

   for (;;) {

      int rc = 0;

      if (rpmluaReadline(L, "> ") == 0)

	 break;

      if (lua_tostring(L, -1)[0] == '=') {

	 (void) lua_pushfstring(L, "print(%s)", lua_tostring(L, -1)+1);

	 lua_remove(L, -2);

      }

      for (;;) {

	 rc = luaL_loadbuffer(L, lua_tostring(L, -1),

			      lua_strlen(L, -1), "<lua>");

	 if (rc == LUA_ERRSYNTAX &&

	     strstr(lua_tostring(L, -1), "near `<eof>'") != NULL) {

	    if (rpmluaReadline(L, ">> ") == 0)

	       break;

	    lua_remove(L, -2); /* Remove error */

	    lua_concat(L, 2);

	    continue;

	 }

	 break;

      }

      if (rc == 0)

	 rc = lua_pcall(L, 0, 0, 0);

      if (rc != 0) {

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

	 lua_pop(L, 1);

      }

      lua_pop(L, 1); /* Remove line */

   }

   (void) fputs("\n", stdout);

}

void rpmluaInteractive(rpmlua _lua)

{

    INITSTATE(_lua, lua);

    _rpmluaInteractive(lua->L);

}

/* ------------------------------------------------------------------ */

/* Lua API */

static int rpm_b64encode(lua_State *L)

{

    const char *str = luaL_checkstring(L, 1);

    size_t len = lua_strlen(L, 1);

    int linelen = -1;

    if (lua_gettop(L) == 2)

	linelen = luaL_checkinteger(L, 2);

    if (str && len) {

	char *data = rpmBase64Encode(str, len, linelen);

	lua_pushstring(L, data);

	free(data);

    }

    return 1;

}

static int rpm_b64decode(lua_State *L)

{

    const char *str = luaL_checkstring(L, 1);

    if (str) {

	void *data = NULL;

	size_t len = 0;

	if (rpmBase64Decode(str, &data, &len) == 0) {

	    lua_pushlstring(L, data, len);

	} else {

	    lua_pushnil(L);

	}

	free(data);

    }

    return 1;

}

static int rpm_expand(lua_State *L)

{

    const char *str = luaL_checkstring(L, 1);

    char *val = NULL;

    if (rpmExpandMacros(NULL, str, &val, 0) < 0)

	return luaL_error(L, "error expanding macro");

    lua_pushstring(L, val);

    free(val);

    return 1;

}

static int rpm_define(lua_State *L)

{

    const char *str = luaL_checkstring(L, 1);

    if (rpmDefineMacro(NULL, str, 0))

	return luaL_error(L, "error defining macro");

    return 0;

}

static int rpm_undefine(lua_State *L)

{

    const char *str = luaL_checkstring(L, 1);

    rpmPopMacro(NULL, str);

    return 0;

}

static int rpm_load(lua_State *L)

{

    const char *str = luaL_checkstring(L, 1);

    int rc = rpmLoadMacroFile(NULL, str);

    lua_pushnumber(L, rc);

    return 1;

}

static int rpm_interactive(lua_State *L)

{

    _rpmluaInteractive(L);

    return 0;

}

static int rpm_next_file(lua_State *L)

{

    if (nextFileFunc)

	lua_pushstring(L, nextFileFunc(nextFileFuncParam));

    else

	lua_pushstring(L, NULL);

    return 1;

}

typedef struct rpmluaHookData_s {

    lua_State *L;

    int funcRef;