X-Git-Url: https://git.saurik.com/redis.git/blobdiff_plain/f9c6f39b2b0039cf29df6597d41c124048c825cd..80ad7189e8de69ce5f7950dcdea4789be7db7014:/src/scripting.c diff --git a/src/scripting.c b/src/scripting.c index 794cba5e..99ca700c 100644 --- a/src/scripting.c +++ b/src/scripting.c @@ -1,16 +1,20 @@ #include "redis.h" #include "sha1.h" +#include "rand.h" #include #include #include #include +#include char *redisProtocolToLuaType_Int(lua_State *lua, char *reply); char *redisProtocolToLuaType_Bulk(lua_State *lua, char *reply); char *redisProtocolToLuaType_Status(lua_State *lua, char *reply); char *redisProtocolToLuaType_Error(lua_State *lua, char *reply); char *redisProtocolToLuaType_MultiBulk(lua_State *lua, char *reply); +int redis_math_random (lua_State *L); +int redis_math_randomseed (lua_State *L); /* Take a Redis reply in the Redis protocol format and convert it into a * Lua type. Thanks to this function, and the introduction of not connected @@ -154,24 +158,37 @@ int luaRedisCommand(lua_State *lua) { return 1; } + /* Setup our fake client for command execution */ + c->argv = argv; + c->argc = argc; + /* Command lookup */ cmd = lookupCommand(argv[0]->ptr); if (!cmd || ((cmd->arity > 0 && cmd->arity != argc) || (argc < -cmd->arity))) { - for (j = 0; j < argc; j++) decrRefCount(argv[j]); - zfree(argv); if (cmd) luaPushError(lua, "Wrong number of args calling Redis command From Lua script"); else luaPushError(lua,"Unknown Redis command called from Lua script"); - return 1; + goto cleanup; } - /* Run the command in the context of a fake client */ - c->argv = argv; - c->argc = argc; + if (cmd->flags & REDIS_CMD_NOSCRIPT) { + luaPushError(lua, "This Redis command is not allowed from scripts"); + goto cleanup; + } + + if (cmd->flags & REDIS_CMD_WRITE && server.lua_random_dirty) { + luaPushError(lua, + "Write commands not allowed after non deterministic commands"); + goto cleanup; + } + + if (cmd->flags & REDIS_CMD_RANDOM) server.lua_random_dirty = 1; + + /* Run the command */ cmd->proc(c); /* Convert the result of the Redis command into a suitable Lua type. @@ -191,6 +208,7 @@ int luaRedisCommand(lua_State *lua) { redisProtocolToLuaType(lua,reply); sdsfree(reply); +cleanup: /* Clean up. Command code may have changed argv/argc so we use the * argv/argc of the client instead of the local variables. */ for (j = 0; j < c->argc; j++) @@ -247,9 +265,28 @@ void luaMaskCountHook(lua_State *lua, lua_Debug *ar) { } } +void luaLoadLib(lua_State *lua, const char *libname, lua_CFunction luafunc) { + lua_pushcfunction(lua, luafunc); + lua_pushstring(lua, libname); + lua_call(lua, 1, 0); +} + +void luaLoadLibraries(lua_State *lua) { + luaLoadLib(lua, "", luaopen_base); + luaLoadLib(lua, LUA_TABLIBNAME, luaopen_table); + luaLoadLib(lua, LUA_STRLIBNAME, luaopen_string); + luaLoadLib(lua, LUA_MATHLIBNAME, luaopen_math); + luaLoadLib(lua, LUA_DBLIBNAME, luaopen_debug); + +#if 0 /* Stuff that we don't load currently, for sandboxing concerns. */ + luaLoadLib(lua, LUA_LOADLIBNAME, luaopen_package); + luaLoadLib(lua, LUA_OSLIBNAME, luaopen_os); +#endif +} + void scriptingInit(void) { lua_State *lua = lua_open(); - luaL_openlibs(lua); + luaLoadLibraries(lua); /* Initialize a dictionary we use to map SHAs to scripts. * This is useful for replication, as we need to replicate EVALSHA @@ -288,6 +325,19 @@ void scriptingInit(void) { /* Finally set the table as 'redis' global var. */ lua_setglobal(lua,"redis"); + /* Replace math.random and math.randomseed with our implementations. */ + lua_getglobal(lua,"math"); + + lua_pushstring(lua,"random"); + lua_pushcfunction(lua,redis_math_random); + lua_settable(lua,-3); + + lua_pushstring(lua,"randomseed"); + lua_pushcfunction(lua,redis_math_randomseed); + lua_settable(lua,-3); + + lua_setglobal(lua,"math"); + /* Create the (non connected) client that we use to execute Redis commands * inside the Lua interpreter */ server.lua_client = createClient(-1); @@ -398,6 +448,20 @@ void evalGenericCommand(redisClient *c, int evalsha) { char funcname[43]; long long numkeys; + /* We want the same PRNG sequence at every call so that our PRNG is + * not affected by external state. */ + redisSrand48(0); + + /* We set this flag to zero to remember that so far no random command + * was called. This way we can allow the user to call commands like + * SRANDMEMBER or RANDOMKEY from Lua scripts as far as no write command + * is called (otherwise the replication and AOF would end with non + * deterministic sequences). + * + * Thanks to this flag we'll raise an error every time a write command + * is called after a random command was used. */ + server.lua_random_dirty = 0; + /* Get the number of arguments that are keys */ if (getLongLongFromObjectOrReply(c,c->argv[2],&numkeys,NULL) != REDIS_OK) return; @@ -467,7 +531,7 @@ void evalGenericCommand(redisClient *c, int evalsha) { { int retval = dictAdd(server.lua_scripts, sdsnewlen(funcname+2,40),c->argv[1]); - redisAssert(retval == DICT_OK); + redisAssertWithInfo(c,NULL,retval == DICT_OK); incrRefCount(c->argv[1]); } } @@ -519,7 +583,7 @@ void evalGenericCommand(redisClient *c, int evalsha) { if (evalsha) { robj *script = dictFetchValue(server.lua_scripts,c->argv[1]->ptr); - redisAssert(script != NULL); + redisAssertWithInfo(c,NULL,script != NULL); rewriteClientCommandArgument(c,0, resetRefCount(createStringObject("EVAL",4))); rewriteClientCommandArgument(c,1,script); @@ -541,3 +605,42 @@ void evalShaCommand(redisClient *c) { } evalGenericCommand(c,1); } + +/* We replace math.random() with our implementation that is not affected + * by specific libc random() implementations and will output the same sequence + * (for the same seed) in every arch. */ + +/* The following implementation is the one shipped with Lua itself but with + * rand() replaced by redisLrand48(). */ +int redis_math_random (lua_State *L) { + /* the `%' avoids the (rare) case of r==1, and is needed also because on + some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */ + lua_Number r = (lua_Number)(redisLrand48()%REDIS_LRAND48_MAX) / + (lua_Number)REDIS_LRAND48_MAX; + switch (lua_gettop(L)) { /* check number of arguments */ + case 0: { /* no arguments */ + lua_pushnumber(L, r); /* Number between 0 and 1 */ + break; + } + case 1: { /* only upper limit */ + int u = luaL_checkint(L, 1); + luaL_argcheck(L, 1<=u, 1, "interval is empty"); + lua_pushnumber(L, floor(r*u)+1); /* int between 1 and `u' */ + break; + } + case 2: { /* lower and upper limits */ + int l = luaL_checkint(L, 1); + int u = luaL_checkint(L, 2); + luaL_argcheck(L, l<=u, 2, "interval is empty"); + lua_pushnumber(L, floor(r*(u-l+1))+l); /* int between `l' and `u' */ + break; + } + default: return luaL_error(L, "wrong number of arguments"); + } + return 1; +} + +int redis_math_randomseed (lua_State *L) { + redisSrand48(luaL_checkint(L, 1)); + return 0; +}