6adef8e2f9
This PR extends the module API to support the addition of different
scripting engines to execute user defined functions.
The scripting engine can be implemented as a Valkey module, and can be
dynamically loaded with the `loadmodule` config directive, or with the
`MODULE LOAD` command.
This PR also adds an example of a dummy scripting engine module, to show
how to use the new module API. The dummy module is implemented in
`tests/modules/helloscripting.c`.
The current module API support, only allows to load scripting engines to
run functions using `FCALL` command.
The additions to the module API are the following:
```c
/* This struct represents a scripting engine function that results from the
* compilation of a script by the engine implementation. */
struct ValkeyModuleScriptingEngineCompiledFunction
typedef ValkeyModuleScriptingEngineCompiledFunction **(*ValkeyModuleScriptingEngineCreateFunctionsLibraryFunc)(
ValkeyModuleScriptingEngineCtx *engine_ctx,
const char *code,
size_t timeout,
size_t *out_num_compiled_functions,
char **err);
typedef void (*ValkeyModuleScriptingEngineCallFunctionFunc)(
ValkeyModuleCtx *module_ctx,
ValkeyModuleScriptingEngineCtx *engine_ctx,
ValkeyModuleScriptingEngineFunctionCtx *func_ctx,
void *compiled_function,
ValkeyModuleString **keys,
size_t nkeys,
ValkeyModuleString **args,
size_t nargs);
typedef size_t (*ValkeyModuleScriptingEngineGetUsedMemoryFunc)(
ValkeyModuleScriptingEngineCtx *engine_ctx);
typedef size_t (*ValkeyModuleScriptingEngineGetFunctionMemoryOverheadFunc)(
void *compiled_function);
typedef size_t (*ValkeyModuleScriptingEngineGetEngineMemoryOverheadFunc)(
ValkeyModuleScriptingEngineCtx *engine_ctx);
typedef void (*ValkeyModuleScriptingEngineFreeFunctionFunc)(
ValkeyModuleScriptingEngineCtx *engine_ctx,
void *compiled_function);
/* This struct stores the callback functions implemented by the scripting
* engine to provide the functionality for the `FUNCTION *` commands. */
typedef struct ValkeyModuleScriptingEngineMethodsV1 {
uint64_t version; /* Version of this structure for ABI compat. */
/* Library create function callback. When a new script is loaded, this
* callback will be called with the script code, and returns a list of
* ValkeyModuleScriptingEngineCompiledFunc objects. */
ValkeyModuleScriptingEngineCreateFunctionsLibraryFunc create_functions_library;
/* The callback function called when `FCALL` command is called on a function
* registered in this engine. */
ValkeyModuleScriptingEngineCallFunctionFunc call_function;
/* Function callback to get current used memory by the engine. */
ValkeyModuleScriptingEngineGetUsedMemoryFunc get_used_memory;
/* Function callback to return memory overhead for a given function. */
ValkeyModuleScriptingEngineGetFunctionMemoryOverheadFunc get_function_memory_overhead;
/* Function callback to return memory overhead of the engine. */
ValkeyModuleScriptingEngineGetEngineMemoryOverheadFunc get_engine_memory_overhead;
/* Function callback to free the memory of a registered engine function. */
ValkeyModuleScriptingEngineFreeFunctionFunc free_function;
} ValkeyModuleScriptingEngineMethodsV1;
/* Registers a new scripting engine in the server.
*
* - `engine_name`: the name of the scripting engine. This name will match
* against the engine name specified in the script header using a shebang.
*
* - `engine_ctx`: engine specific context pointer.
*
* - `engine_methods`: the struct with the scripting engine callback functions
* pointers.
*/
int ValkeyModule_RegisterScriptingEngine(ValkeyModuleCtx *ctx,
const char *engine_name,
void *engine_ctx,
ValkeyModuleScriptingEngineMethods engine_methods);
/* Removes the scripting engine from the server.
*
* `engine_name` is the name of the scripting engine.
*
*/
int ValkeyModule_UnregisterScriptingEngine(ValkeyModuleCtx *ctx, const char *engine_name);
```
---------
Signed-off-by: Ricardo Dias <ricardo.dias@percona.com>
1783 lines
64 KiB
C
1783 lines
64 KiB
C
/*
|
|
* Copyright (c) 2009-2021, Redis Ltd.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of Redis nor the names of its contributors may be used
|
|
* to endorse or promote products derived from this software without
|
|
* specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "script_lua.h"
|
|
#include "fpconv_dtoa.h"
|
|
|
|
#include "server.h"
|
|
#include "sha1.h"
|
|
#include "rand.h"
|
|
#include "cluster.h"
|
|
#include "monotonic.h"
|
|
#include "resp_parser.h"
|
|
#include "version.h"
|
|
#include <lauxlib.h>
|
|
#include <lualib.h>
|
|
#include <ctype.h>
|
|
#include <math.h>
|
|
|
|
/* Globals that are added by the Lua libraries */
|
|
static char *libraries_allow_list[] = {
|
|
"string",
|
|
"cjson",
|
|
"bit",
|
|
"cmsgpack",
|
|
"math",
|
|
"table",
|
|
"struct",
|
|
"os",
|
|
NULL,
|
|
};
|
|
|
|
/* Lua API globals */
|
|
static char *server_api_allow_list[] = {
|
|
SERVER_API_NAME,
|
|
REDIS_API_NAME,
|
|
"__redis__err__handler", /* Backwards compatible error handler */
|
|
"__server__err__handler", /* error handler for eval, currently located on globals.
|
|
Should move to registry. */
|
|
NULL,
|
|
};
|
|
|
|
/* Lua builtins */
|
|
static char *lua_builtins_allow_list[] = {
|
|
"xpcall",
|
|
"tostring",
|
|
"getfenv",
|
|
"setmetatable",
|
|
"next",
|
|
"assert",
|
|
"tonumber",
|
|
"rawequal",
|
|
"collectgarbage",
|
|
"getmetatable",
|
|
"rawset",
|
|
"pcall",
|
|
"coroutine",
|
|
"type",
|
|
"_G",
|
|
"select",
|
|
"unpack",
|
|
"gcinfo",
|
|
"pairs",
|
|
"rawget",
|
|
"loadstring",
|
|
"ipairs",
|
|
"_VERSION",
|
|
"setfenv",
|
|
"load",
|
|
"error",
|
|
NULL,
|
|
};
|
|
|
|
/* Lua builtins which are not documented on the Lua documentation */
|
|
static char *lua_builtins_not_documented_allow_list[] = {
|
|
"newproxy",
|
|
NULL,
|
|
};
|
|
|
|
/* Lua builtins which are allowed on initialization but will be removed right after */
|
|
static char *lua_builtins_removed_after_initialization_allow_list[] = {
|
|
"debug", /* debug will be set to nil after the error handler will be created */
|
|
NULL,
|
|
};
|
|
|
|
/* Those allow lists was created from the globals that was
|
|
* available to the user when the allow lists was first introduce.
|
|
* Because we do not want to break backward compatibility we keep
|
|
* all the globals. The allow lists will prevent us from accidentally
|
|
* creating unwanted globals in the future.
|
|
*
|
|
* Also notice that the allow list is only checked on start time,
|
|
* after that the global table is locked so not need to check anything.*/
|
|
static char **allow_lists[] = {
|
|
libraries_allow_list,
|
|
server_api_allow_list,
|
|
lua_builtins_allow_list,
|
|
lua_builtins_not_documented_allow_list,
|
|
lua_builtins_removed_after_initialization_allow_list,
|
|
NULL,
|
|
};
|
|
|
|
/* Deny list contains elements which we know we do not want to add to globals
|
|
* and there is no need to print a warning message form them. We will print a
|
|
* log message only if an element was added to the globals and the element is
|
|
* not on the allow list nor on the back list. */
|
|
static char *deny_list[] = {
|
|
"dofile",
|
|
"loadfile",
|
|
"print",
|
|
NULL,
|
|
};
|
|
|
|
static int server_math_random(lua_State *L);
|
|
static int server_math_randomseed(lua_State *L);
|
|
static void redisProtocolToLuaType_Int(void *ctx, long long val, const char *proto, size_t proto_len);
|
|
static void
|
|
redisProtocolToLuaType_BulkString(void *ctx, const char *str, size_t len, const char *proto, size_t proto_len);
|
|
static void redisProtocolToLuaType_NullBulkString(void *ctx, const char *proto, size_t proto_len);
|
|
static void redisProtocolToLuaType_NullArray(void *ctx, const char *proto, size_t proto_len);
|
|
static void redisProtocolToLuaType_Status(void *ctx, const char *str, size_t len, const char *proto, size_t proto_len);
|
|
static void redisProtocolToLuaType_Error(void *ctx, const char *str, size_t len, const char *proto, size_t proto_len);
|
|
static void redisProtocolToLuaType_Array(struct ReplyParser *parser, void *ctx, size_t len, const char *proto);
|
|
static void redisProtocolToLuaType_Map(struct ReplyParser *parser, void *ctx, size_t len, const char *proto);
|
|
static void redisProtocolToLuaType_Set(struct ReplyParser *parser, void *ctx, size_t len, const char *proto);
|
|
static void redisProtocolToLuaType_Null(void *ctx, const char *proto, size_t proto_len);
|
|
static void redisProtocolToLuaType_Bool(void *ctx, int val, const char *proto, size_t proto_len);
|
|
static void redisProtocolToLuaType_Double(void *ctx, double d, const char *proto, size_t proto_len);
|
|
static void
|
|
redisProtocolToLuaType_BigNumber(void *ctx, const char *str, size_t len, const char *proto, size_t proto_len);
|
|
static void redisProtocolToLuaType_VerbatimString(void *ctx,
|
|
const char *format,
|
|
const char *str,
|
|
size_t len,
|
|
const char *proto,
|
|
size_t proto_len);
|
|
static void redisProtocolToLuaType_Attribute(struct ReplyParser *parser, void *ctx, size_t len, const char *proto);
|
|
|
|
static void luaReplyToServerReply(client *c, client *script_client, lua_State *lua);
|
|
|
|
/*
|
|
* Save the give pointer on Lua registry, used to save the Lua context and
|
|
* function context so we can retrieve them from lua_State.
|
|
*/
|
|
void luaSaveOnRegistry(lua_State *lua, const char *name, void *ptr) {
|
|
lua_pushstring(lua, name);
|
|
if (ptr) {
|
|
lua_pushlightuserdata(lua, ptr);
|
|
} else {
|
|
lua_pushnil(lua);
|
|
}
|
|
lua_settable(lua, LUA_REGISTRYINDEX);
|
|
}
|
|
|
|
/*
|
|
* Get a saved pointer from registry
|
|
*/
|
|
void *luaGetFromRegistry(lua_State *lua, const char *name) {
|
|
lua_pushstring(lua, name);
|
|
lua_gettable(lua, LUA_REGISTRYINDEX);
|
|
|
|
if (lua_isnil(lua, -1)) {
|
|
lua_pop(lua, 1); /* pops the value */
|
|
return NULL;
|
|
}
|
|
/* must be light user data */
|
|
serverAssert(lua_islightuserdata(lua, -1));
|
|
|
|
void *ptr = (void *)lua_topointer(lua, -1);
|
|
serverAssert(ptr);
|
|
|
|
/* pops the value */
|
|
lua_pop(lua, 1);
|
|
|
|
return ptr;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------------
|
|
* Server reply to Lua type conversion functions.
|
|
* ------------------------------------------------------------------------- */
|
|
|
|
/* Take a server reply in the RESP format and convert it into a
|
|
* Lua type. Thanks to this function, and the introduction of not connected
|
|
* clients, it is trivial to implement the server() lua function.
|
|
*
|
|
* Basically we take the arguments, execute the command in the context
|
|
* of a non connected client, then take the generated reply and convert it
|
|
* into a suitable Lua type. With this trick the scripting feature does not
|
|
* need the introduction of a full server internals API. The script
|
|
* is like a normal client that bypasses all the slow I/O paths.
|
|
*
|
|
* Note: in this function we do not do any sanity check as the reply is
|
|
* generated by the server directly. This allows us to go faster.
|
|
*
|
|
* Errors are returned as a table with a single 'err' field set to the
|
|
* error string.
|
|
*/
|
|
|
|
static const ReplyParserCallbacks DefaultLuaTypeParserCallbacks = {
|
|
.null_array_callback = redisProtocolToLuaType_NullArray,
|
|
.bulk_string_callback = redisProtocolToLuaType_BulkString,
|
|
.null_bulk_string_callback = redisProtocolToLuaType_NullBulkString,
|
|
.error_callback = redisProtocolToLuaType_Error,
|
|
.simple_str_callback = redisProtocolToLuaType_Status,
|
|
.long_callback = redisProtocolToLuaType_Int,
|
|
.array_callback = redisProtocolToLuaType_Array,
|
|
.set_callback = redisProtocolToLuaType_Set,
|
|
.map_callback = redisProtocolToLuaType_Map,
|
|
.bool_callback = redisProtocolToLuaType_Bool,
|
|
.double_callback = redisProtocolToLuaType_Double,
|
|
.null_callback = redisProtocolToLuaType_Null,
|
|
.big_number_callback = redisProtocolToLuaType_BigNumber,
|
|
.verbatim_string_callback = redisProtocolToLuaType_VerbatimString,
|
|
.attribute_callback = redisProtocolToLuaType_Attribute,
|
|
.error = NULL,
|
|
};
|
|
|
|
static void redisProtocolToLuaType(lua_State *lua, char *reply) {
|
|
ReplyParser parser = {.curr_location = reply, .callbacks = DefaultLuaTypeParserCallbacks};
|
|
|
|
parseReply(&parser, lua);
|
|
}
|
|
|
|
static void redisProtocolToLuaType_Int(void *ctx, long long val, const char *proto, size_t proto_len) {
|
|
UNUSED(proto);
|
|
UNUSED(proto_len);
|
|
if (!ctx) {
|
|
return;
|
|
}
|
|
|
|
lua_State *lua = ctx;
|
|
if (!lua_checkstack(lua, 1)) {
|
|
/* Increase the Lua stack if needed, to make sure there is enough room
|
|
* to push elements to the stack. On failure, exit with panic. */
|
|
serverPanic("lua stack limit reach when parsing server.call reply");
|
|
}
|
|
lua_pushnumber(lua, (lua_Number)val);
|
|
}
|
|
|
|
static void redisProtocolToLuaType_NullBulkString(void *ctx, const char *proto, size_t proto_len) {
|
|
UNUSED(proto);
|
|
UNUSED(proto_len);
|
|
if (!ctx) {
|
|
return;
|
|
}
|
|
|
|
lua_State *lua = ctx;
|
|
if (!lua_checkstack(lua, 1)) {
|
|
/* Increase the Lua stack if needed, to make sure there is enough room
|
|
* to push elements to the stack. On failure, exit with panic. */
|
|
serverPanic("lua stack limit reach when parsing server.call reply");
|
|
}
|
|
lua_pushboolean(lua, 0);
|
|
}
|
|
|
|
static void redisProtocolToLuaType_NullArray(void *ctx, const char *proto, size_t proto_len) {
|
|
UNUSED(proto);
|
|
UNUSED(proto_len);
|
|
if (!ctx) {
|
|
return;
|
|
}
|
|
lua_State *lua = ctx;
|
|
if (!lua_checkstack(lua, 1)) {
|
|
/* Increase the Lua stack if needed, to make sure there is enough room
|
|
* to push elements to the stack. On failure, exit with panic. */
|
|
serverPanic("lua stack limit reach when parsing server.call reply");
|
|
}
|
|
lua_pushboolean(lua, 0);
|
|
}
|
|
|
|
|
|
static void
|
|
redisProtocolToLuaType_BulkString(void *ctx, const char *str, size_t len, const char *proto, size_t proto_len) {
|
|
UNUSED(proto);
|
|
UNUSED(proto_len);
|
|
if (!ctx) {
|
|
return;
|
|
}
|
|
|
|
lua_State *lua = ctx;
|
|
if (!lua_checkstack(lua, 1)) {
|
|
/* Increase the Lua stack if needed, to make sure there is enough room
|
|
* to push elements to the stack. On failure, exit with panic. */
|
|
serverPanic("lua stack limit reach when parsing server.call reply");
|
|
}
|
|
lua_pushlstring(lua, str, len);
|
|
}
|
|
|
|
static void redisProtocolToLuaType_Status(void *ctx, const char *str, size_t len, const char *proto, size_t proto_len) {
|
|
UNUSED(proto);
|
|
UNUSED(proto_len);
|
|
if (!ctx) {
|
|
return;
|
|
}
|
|
|
|
lua_State *lua = ctx;
|
|
if (!lua_checkstack(lua, 3)) {
|
|
/* Increase the Lua stack if needed, to make sure there is enough room
|
|
* to push elements to the stack. On failure, exit with panic. */
|
|
serverPanic("lua stack limit reach when parsing server.call reply");
|
|
}
|
|
lua_newtable(lua);
|
|
lua_pushstring(lua, "ok");
|
|
lua_pushlstring(lua, str, len);
|
|
lua_settable(lua, -3);
|
|
}
|
|
|
|
static void redisProtocolToLuaType_Error(void *ctx, const char *str, size_t len, const char *proto, size_t proto_len) {
|
|
UNUSED(proto);
|
|
UNUSED(proto_len);
|
|
if (!ctx) {
|
|
return;
|
|
}
|
|
|
|
lua_State *lua = ctx;
|
|
if (!lua_checkstack(lua, 3)) {
|
|
/* Increase the Lua stack if needed, to make sure there is enough room
|
|
* to push elements to the stack. On failure, exit with panic. */
|
|
serverPanic("lua stack limit reach when parsing server.call reply");
|
|
}
|
|
sds err_msg = sdscatlen(sdsnew("-"), str, len);
|
|
luaPushErrorBuff(lua, err_msg);
|
|
/* push a field indicate to ignore updating the stats on this error
|
|
* because it was already updated when executing the command. */
|
|
lua_pushstring(lua, "ignore_error_stats_update");
|
|
lua_pushboolean(lua, 1);
|
|
lua_settable(lua, -3);
|
|
}
|
|
|
|
static void redisProtocolToLuaType_Map(struct ReplyParser *parser, void *ctx, size_t len, const char *proto) {
|
|
UNUSED(proto);
|
|
lua_State *lua = ctx;
|
|
if (lua) {
|
|
if (!lua_checkstack(lua, 3)) {
|
|
/* Increase the Lua stack if needed, to make sure there is enough room
|
|
* to push elements to the stack. On failure, exit with panic. */
|
|
serverPanic("lua stack limit reach when parsing server.call reply");
|
|
}
|
|
lua_newtable(lua);
|
|
lua_pushstring(lua, "map");
|
|
lua_createtable(lua, 0, len);
|
|
}
|
|
for (size_t j = 0; j < len; j++) {
|
|
parseReply(parser, lua);
|
|
parseReply(parser, lua);
|
|
if (lua) lua_settable(lua, -3);
|
|
}
|
|
if (lua) lua_settable(lua, -3);
|
|
}
|
|
|
|
static void redisProtocolToLuaType_Set(struct ReplyParser *parser, void *ctx, size_t len, const char *proto) {
|
|
UNUSED(proto);
|
|
|
|
lua_State *lua = ctx;
|
|
if (lua) {
|
|
if (!lua_checkstack(lua, 3)) {
|
|
/* Increase the Lua stack if needed, to make sure there is enough room
|
|
* to push elements to the stack. On failure, exit with panic. */
|
|
serverPanic("lua stack limit reach when parsing server.call reply");
|
|
}
|
|
lua_newtable(lua);
|
|
lua_pushstring(lua, "set");
|
|
lua_createtable(lua, 0, len);
|
|
}
|
|
for (size_t j = 0; j < len; j++) {
|
|
parseReply(parser, lua);
|
|
if (lua) {
|
|
if (!lua_checkstack(lua, 1)) {
|
|
/* Increase the Lua stack if needed, to make sure there is enough room
|
|
* to push elements to the stack. On failure, exit with panic.
|
|
* Notice that here we need to check the stack again because the recursive
|
|
* call to redisProtocolToLuaType might have use the room allocated in the stack*/
|
|
serverPanic("lua stack limit reach when parsing server.call reply");
|
|
}
|
|
lua_pushboolean(lua, 1);
|
|
lua_settable(lua, -3);
|
|
}
|
|
}
|
|
if (lua) lua_settable(lua, -3);
|
|
}
|
|
|
|
static void redisProtocolToLuaType_Array(struct ReplyParser *parser, void *ctx, size_t len, const char *proto) {
|
|
UNUSED(proto);
|
|
|
|
lua_State *lua = ctx;
|
|
if (lua) {
|
|
if (!lua_checkstack(lua, 2)) {
|
|
/* Increase the Lua stack if needed, to make sure there is enough room
|
|
* to push elements to the stack. On failure, exit with panic. */
|
|
serverPanic("lua stack limit reach when parsing server.call reply");
|
|
}
|
|
lua_createtable(lua, len, 0);
|
|
}
|
|
for (size_t j = 0; j < len; j++) {
|
|
if (lua) lua_pushnumber(lua, j + 1);
|
|
parseReply(parser, lua);
|
|
if (lua) lua_settable(lua, -3);
|
|
}
|
|
}
|
|
|
|
static void redisProtocolToLuaType_Attribute(struct ReplyParser *parser, void *ctx, size_t len, const char *proto) {
|
|
UNUSED(proto);
|
|
|
|
/* Parse the attribute reply.
|
|
* Currently, we do not expose the attribute to the Lua script so
|
|
* we just need to continue parsing and ignore it (the NULL ensures that the
|
|
* reply will be ignored). */
|
|
for (size_t j = 0; j < len; j++) {
|
|
parseReply(parser, NULL);
|
|
parseReply(parser, NULL);
|
|
}
|
|
|
|
/* Parse the reply itself. */
|
|
parseReply(parser, ctx);
|
|
}
|
|
|
|
static void redisProtocolToLuaType_VerbatimString(void *ctx,
|
|
const char *format,
|
|
const char *str,
|
|
size_t len,
|
|
const char *proto,
|
|
size_t proto_len) {
|
|
UNUSED(proto);
|
|
UNUSED(proto_len);
|
|
if (!ctx) {
|
|
return;
|
|
}
|
|
|
|
lua_State *lua = ctx;
|
|
if (!lua_checkstack(lua, 5)) {
|
|
/* Increase the Lua stack if needed, to make sure there is enough room
|
|
* to push elements to the stack. On failure, exit with panic. */
|
|
serverPanic("lua stack limit reach when parsing server.call reply");
|
|
}
|
|
lua_newtable(lua);
|
|
lua_pushstring(lua, "verbatim_string");
|
|
lua_newtable(lua);
|
|
lua_pushstring(lua, "string");
|
|
lua_pushlstring(lua, str, len);
|
|
lua_settable(lua, -3);
|
|
lua_pushstring(lua, "format");
|
|
lua_pushlstring(lua, format, 3);
|
|
lua_settable(lua, -3);
|
|
lua_settable(lua, -3);
|
|
}
|
|
|
|
static void
|
|
redisProtocolToLuaType_BigNumber(void *ctx, const char *str, size_t len, const char *proto, size_t proto_len) {
|
|
UNUSED(proto);
|
|
UNUSED(proto_len);
|
|
if (!ctx) {
|
|
return;
|
|
}
|
|
|
|
lua_State *lua = ctx;
|
|
if (!lua_checkstack(lua, 3)) {
|
|
/* Increase the Lua stack if needed, to make sure there is enough room
|
|
* to push elements to the stack. On failure, exit with panic. */
|
|
serverPanic("lua stack limit reach when parsing server.call reply");
|
|
}
|
|
lua_newtable(lua);
|
|
lua_pushstring(lua, "big_number");
|
|
lua_pushlstring(lua, str, len);
|
|
lua_settable(lua, -3);
|
|
}
|
|
|
|
static void redisProtocolToLuaType_Null(void *ctx, const char *proto, size_t proto_len) {
|
|
UNUSED(proto);
|
|
UNUSED(proto_len);
|
|
if (!ctx) {
|
|
return;
|
|
}
|
|
|
|
lua_State *lua = ctx;
|
|
if (!lua_checkstack(lua, 1)) {
|
|
/* Increase the Lua stack if needed, to make sure there is enough room
|
|
* to push elements to the stack. On failure, exit with panic. */
|
|
serverPanic("lua stack limit reach when parsing server.call reply");
|
|
}
|
|
lua_pushnil(lua);
|
|
}
|
|
|
|
static void redisProtocolToLuaType_Bool(void *ctx, int val, const char *proto, size_t proto_len) {
|
|
UNUSED(proto);
|
|
UNUSED(proto_len);
|
|
if (!ctx) {
|
|
return;
|
|
}
|
|
|
|
lua_State *lua = ctx;
|
|
if (!lua_checkstack(lua, 1)) {
|
|
/* Increase the Lua stack if needed, to make sure there is enough room
|
|
* to push elements to the stack. On failure, exit with panic. */
|
|
serverPanic("lua stack limit reach when parsing server.call reply");
|
|
}
|
|
lua_pushboolean(lua, val);
|
|
}
|
|
|
|
static void redisProtocolToLuaType_Double(void *ctx, double d, const char *proto, size_t proto_len) {
|
|
UNUSED(proto);
|
|
UNUSED(proto_len);
|
|
if (!ctx) {
|
|
return;
|
|
}
|
|
|
|
lua_State *lua = ctx;
|
|
if (!lua_checkstack(lua, 3)) {
|
|
/* Increase the Lua stack if needed, to make sure there is enough room
|
|
* to push elements to the stack. On failure, exit with panic. */
|
|
serverPanic("lua stack limit reach when parsing server.call reply");
|
|
}
|
|
lua_newtable(lua);
|
|
lua_pushstring(lua, "double");
|
|
lua_pushnumber(lua, d);
|
|
lua_settable(lua, -3);
|
|
}
|
|
|
|
/* This function is used in order to push an error on the Lua stack in the
|
|
* format used by server.pcall to return errors, which is a lua table
|
|
* with an "err" field set to the error string including the error code.
|
|
* Note that this table is never a valid reply by proper commands,
|
|
* since the returned tables are otherwise always indexed by integers, never by strings.
|
|
*
|
|
* The function takes ownership on the given err_buffer. */
|
|
void luaPushErrorBuff(lua_State *lua, sds err_buffer) {
|
|
sds msg;
|
|
sds error_code;
|
|
|
|
/* If debugging is active and in step mode, log errors resulting from
|
|
* server commands. */
|
|
if (ldbIsEnabled()) {
|
|
ldbLog(sdscatprintf(sdsempty(), "<error> %s", err_buffer));
|
|
}
|
|
|
|
/* There are two possible formats for the received `error` string:
|
|
* 1) "-CODE msg": in this case we remove the leading '-' since we don't store it as part of the lua error format.
|
|
* 2) "msg": in this case we prepend a generic 'ERR' code since all error statuses need some error code.
|
|
* We support format (1) so this function can reuse the error messages used in other places.
|
|
* We support format (2) so it'll be easy to pass descriptive errors to this function without worrying about format.
|
|
*/
|
|
if (err_buffer[0] == '-') {
|
|
/* derive error code from the message */
|
|
char *err_msg = strstr(err_buffer, " ");
|
|
if (!err_msg) {
|
|
msg = sdsnew(err_buffer + 1);
|
|
error_code = sdsnew("ERR");
|
|
} else {
|
|
*err_msg = '\0';
|
|
msg = sdsnew(err_msg + 1);
|
|
error_code = sdsnew(err_buffer + 1);
|
|
}
|
|
sdsfree(err_buffer);
|
|
} else {
|
|
msg = err_buffer;
|
|
error_code = sdsnew("ERR");
|
|
}
|
|
/* Trim newline at end of string. If we reuse the ready-made error objects (case 1 above) then we might
|
|
* have a newline that needs to be trimmed. In any case the lua server error table shouldn't end with a newline. */
|
|
msg = sdstrim(msg, "\r\n");
|
|
sds final_msg = sdscatfmt(error_code, " %s", msg);
|
|
|
|
lua_newtable(lua);
|
|
lua_pushstring(lua, "err");
|
|
lua_pushstring(lua, final_msg);
|
|
lua_settable(lua, -3);
|
|
|
|
sdsfree(msg);
|
|
sdsfree(final_msg);
|
|
}
|
|
|
|
void luaPushError(lua_State *lua, const char *error) {
|
|
luaPushErrorBuff(lua, sdsnew(error));
|
|
}
|
|
|
|
/* In case the error set into the Lua stack by luaPushError() was generated
|
|
* by the non-error-trapping version of server.pcall(), which is server.call(),
|
|
* this function will raise the Lua error so that the execution of the
|
|
* script will be halted. */
|
|
int luaError(lua_State *lua) {
|
|
return lua_error(lua);
|
|
}
|
|
|
|
|
|
/* ---------------------------------------------------------------------------
|
|
* Lua reply to server reply conversion functions.
|
|
* ------------------------------------------------------------------------- */
|
|
|
|
/* Reply to client 'c' converting the top element in the Lua stack to a
|
|
* server reply. As a side effect the element is consumed from the stack. */
|
|
static void luaReplyToServerReply(client *c, client *script_client, lua_State *lua) {
|
|
int t = lua_type(lua, -1);
|
|
|
|
if (!lua_checkstack(lua, 4)) {
|
|
/* Increase the Lua stack if needed to make sure there is enough room
|
|
* to push 4 elements to the stack. On failure, return error.
|
|
* Notice that we need, in the worst case, 4 elements because returning a map might
|
|
* require push 4 elements to the Lua stack.*/
|
|
addReplyError(c, "reached lua stack limit");
|
|
lua_pop(lua, 1); /* pop the element from the stack */
|
|
return;
|
|
}
|
|
|
|
switch (t) {
|
|
case LUA_TSTRING: addReplyBulkCBuffer(c, (char *)lua_tostring(lua, -1), lua_strlen(lua, -1)); break;
|
|
case LUA_TBOOLEAN:
|
|
if (script_client->resp == 2)
|
|
addReply(c, lua_toboolean(lua, -1) ? shared.cone : shared.null[c->resp]);
|
|
else
|
|
addReplyBool(c, lua_toboolean(lua, -1));
|
|
break;
|
|
case LUA_TNUMBER: addReplyLongLong(c, (long long)lua_tonumber(lua, -1)); break;
|
|
case LUA_TTABLE:
|
|
/* We need to check if it is an array, an error, or a status reply.
|
|
* Error are returned as a single element table with 'err' field.
|
|
* Status replies are returned as single element table with 'ok'
|
|
* field. */
|
|
|
|
/* Handle error reply. */
|
|
/* we took care of the stack size on function start */
|
|
lua_pushstring(lua, "err");
|
|
lua_rawget(lua, -2);
|
|
t = lua_type(lua, -1);
|
|
if (t == LUA_TSTRING) {
|
|
lua_pop(lua,
|
|
1); /* pop the error message, we will use luaExtractErrorInformation to get error information */
|
|
errorInfo err_info = {0};
|
|
luaExtractErrorInformation(lua, &err_info);
|
|
addReplyErrorFormatEx(
|
|
c, ERR_REPLY_FLAG_CUSTOM | (err_info.ignore_err_stats_update ? ERR_REPLY_FLAG_NO_STATS_UPDATE : 0),
|
|
"-%s", err_info.msg);
|
|
luaErrorInformationDiscard(&err_info);
|
|
lua_pop(lua, 1); /* pop the result table */
|
|
return;
|
|
}
|
|
lua_pop(lua, 1); /* Discard field name pushed before. */
|
|
|
|
/* Handle status reply. */
|
|
lua_pushstring(lua, "ok");
|
|
lua_rawget(lua, -2);
|
|
t = lua_type(lua, -1);
|
|
if (t == LUA_TSTRING) {
|
|
sds ok = sdsnew(lua_tostring(lua, -1));
|
|
sdsmapchars(ok, "\r\n", " ", 2);
|
|
addReplyStatusLength(c, ok, sdslen(ok));
|
|
sdsfree(ok);
|
|
lua_pop(lua, 2);
|
|
return;
|
|
}
|
|
lua_pop(lua, 1); /* Discard field name pushed before. */
|
|
|
|
/* Handle double reply. */
|
|
lua_pushstring(lua, "double");
|
|
lua_rawget(lua, -2);
|
|
t = lua_type(lua, -1);
|
|
if (t == LUA_TNUMBER) {
|
|
addReplyDouble(c, lua_tonumber(lua, -1));
|
|
lua_pop(lua, 2);
|
|
return;
|
|
}
|
|
lua_pop(lua, 1); /* Discard field name pushed before. */
|
|
|
|
/* Handle big number reply. */
|
|
lua_pushstring(lua, "big_number");
|
|
lua_rawget(lua, -2);
|
|
t = lua_type(lua, -1);
|
|
if (t == LUA_TSTRING) {
|
|
sds big_num = sdsnewlen(lua_tostring(lua, -1), lua_strlen(lua, -1));
|
|
sdsmapchars(big_num, "\r\n", " ", 2);
|
|
addReplyBigNum(c, big_num, sdslen(big_num));
|
|
sdsfree(big_num);
|
|
lua_pop(lua, 2);
|
|
return;
|
|
}
|
|
lua_pop(lua, 1); /* Discard field name pushed before. */
|
|
|
|
/* Handle verbatim reply. */
|
|
lua_pushstring(lua, "verbatim_string");
|
|
lua_rawget(lua, -2);
|
|
t = lua_type(lua, -1);
|
|
if (t == LUA_TTABLE) {
|
|
lua_pushstring(lua, "format");
|
|
lua_rawget(lua, -2);
|
|
t = lua_type(lua, -1);
|
|
if (t == LUA_TSTRING) {
|
|
char *format = (char *)lua_tostring(lua, -1);
|
|
lua_pushstring(lua, "string");
|
|
lua_rawget(lua, -3);
|
|
t = lua_type(lua, -1);
|
|
if (t == LUA_TSTRING) {
|
|
size_t len;
|
|
char *str = (char *)lua_tolstring(lua, -1, &len);
|
|
addReplyVerbatim(c, str, len, format);
|
|
lua_pop(lua, 4);
|
|
return;
|
|
}
|
|
lua_pop(lua, 1);
|
|
}
|
|
lua_pop(lua, 1);
|
|
}
|
|
lua_pop(lua, 1); /* Discard field name pushed before. */
|
|
|
|
/* Handle map reply. */
|
|
lua_pushstring(lua, "map");
|
|
lua_rawget(lua, -2);
|
|
t = lua_type(lua, -1);
|
|
if (t == LUA_TTABLE) {
|
|
int maplen = 0;
|
|
void *replylen = addReplyDeferredLen(c);
|
|
/* we took care of the stack size on function start */
|
|
lua_pushnil(lua); /* Use nil to start iteration. */
|
|
while (lua_next(lua, -2)) {
|
|
/* Stack now: table, key, value */
|
|
lua_pushvalue(lua, -2); /* Dup key before consuming. */
|
|
luaReplyToServerReply(c, script_client, lua); /* Return key. */
|
|
luaReplyToServerReply(c, script_client, lua); /* Return value. */
|
|
/* Stack now: table, key. */
|
|
maplen++;
|
|
}
|
|
setDeferredMapLen(c, replylen, maplen);
|
|
lua_pop(lua, 2);
|
|
return;
|
|
}
|
|
lua_pop(lua, 1); /* Discard field name pushed before. */
|
|
|
|
/* Handle set reply. */
|
|
lua_pushstring(lua, "set");
|
|
lua_rawget(lua, -2);
|
|
t = lua_type(lua, -1);
|
|
if (t == LUA_TTABLE) {
|
|
int setlen = 0;
|
|
void *replylen = addReplyDeferredLen(c);
|
|
/* we took care of the stack size on function start */
|
|
lua_pushnil(lua); /* Use nil to start iteration. */
|
|
while (lua_next(lua, -2)) {
|
|
/* Stack now: table, key, true */
|
|
lua_pop(lua, 1); /* Discard the boolean value. */
|
|
lua_pushvalue(lua, -1); /* Dup key before consuming. */
|
|
luaReplyToServerReply(c, script_client, lua); /* Return key. */
|
|
/* Stack now: table, key. */
|
|
setlen++;
|
|
}
|
|
setDeferredSetLen(c, replylen, setlen);
|
|
lua_pop(lua, 2);
|
|
return;
|
|
}
|
|
lua_pop(lua, 1); /* Discard field name pushed before. */
|
|
|
|
/* Handle the array reply. */
|
|
void *replylen = addReplyDeferredLen(c);
|
|
int j = 1, mbulklen = 0;
|
|
while (1) {
|
|
/* we took care of the stack size on function start */
|
|
lua_pushnumber(lua, j++);
|
|
lua_rawget(lua, -2);
|
|
t = lua_type(lua, -1);
|
|
if (t == LUA_TNIL) {
|
|
lua_pop(lua, 1);
|
|
break;
|
|
}
|
|
luaReplyToServerReply(c, script_client, lua);
|
|
mbulklen++;
|
|
}
|
|
setDeferredArrayLen(c, replylen, mbulklen);
|
|
break;
|
|
default: addReplyNull(c);
|
|
}
|
|
lua_pop(lua, 1);
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------------
|
|
* Lua server.* functions implementations.
|
|
* ------------------------------------------------------------------------- */
|
|
void freeLuaServerArgv(robj **argv, int argc, int argv_len);
|
|
|
|
/* Cached argv array across calls. */
|
|
static robj **lua_argv = NULL;
|
|
static int lua_argv_size = 0;
|
|
|
|
/* Cache of recently used small arguments to avoid malloc calls. */
|
|
static robj *lua_args_cached_objects[LUA_CMD_OBJCACHE_SIZE];
|
|
static size_t lua_args_cached_objects_len[LUA_CMD_OBJCACHE_SIZE];
|
|
|
|
static robj **luaArgsToServerArgv(lua_State *lua, int *argc, int *argv_len) {
|
|
int j;
|
|
/* Require at least one argument */
|
|
*argc = lua_gettop(lua);
|
|
if (*argc == 0) {
|
|
luaPushError(lua, "Please specify at least one argument for this call");
|
|
return NULL;
|
|
}
|
|
|
|
/* Build the arguments vector (reuse a cached argv from last call) */
|
|
if (lua_argv_size < *argc) {
|
|
lua_argv = zrealloc(lua_argv, sizeof(robj *) * *argc);
|
|
lua_argv_size = *argc;
|
|
}
|
|
*argv_len = lua_argv_size;
|
|
|
|
for (j = 0; j < *argc; j++) {
|
|
char *obj_s;
|
|
size_t obj_len;
|
|
char dbuf[64];
|
|
|
|
if (lua_type(lua, j + 1) == LUA_TNUMBER) {
|
|
/* We can't use lua_tolstring() for number -> string conversion
|
|
* since Lua uses a format specifier that loses precision. */
|
|
lua_Number num = lua_tonumber(lua, j + 1);
|
|
/* Integer printing function is much faster, check if we can safely use it.
|
|
* Since lua_Number is not explicitly an integer or a double, we need to make an effort
|
|
* to convert it as an integer when that's possible, since the string could later be used
|
|
* in a context that doesn't support scientific notation (e.g. 1e9 instead of 100000000). */
|
|
long long lvalue;
|
|
if (double2ll((double)num, &lvalue))
|
|
obj_len = ll2string(dbuf, sizeof(dbuf), lvalue);
|
|
else {
|
|
obj_len = fpconv_dtoa((double)num, dbuf);
|
|
dbuf[obj_len] = '\0';
|
|
}
|
|
obj_s = dbuf;
|
|
} else {
|
|
obj_s = (char *)lua_tolstring(lua, j + 1, &obj_len);
|
|
if (obj_s == NULL) break; /* Not a string. */
|
|
}
|
|
/* Try to use a cached object. */
|
|
if (j < LUA_CMD_OBJCACHE_SIZE && lua_args_cached_objects[j] && lua_args_cached_objects_len[j] >= obj_len) {
|
|
sds s = lua_args_cached_objects[j]->ptr;
|
|
lua_argv[j] = lua_args_cached_objects[j];
|
|
lua_args_cached_objects[j] = NULL;
|
|
memcpy(s, obj_s, obj_len + 1);
|
|
sdssetlen(s, obj_len);
|
|
} else {
|
|
lua_argv[j] = createStringObject(obj_s, obj_len);
|
|
}
|
|
}
|
|
|
|
/* Pop all arguments from the stack, we do not need them anymore
|
|
* and this way we guaranty we will have room on the stack for the result. */
|
|
lua_pop(lua, *argc);
|
|
|
|
/* Check if one of the arguments passed by the Lua script
|
|
* is not a string or an integer (lua_isstring() return true for
|
|
* integers as well). */
|
|
if (j != *argc) {
|
|
freeLuaServerArgv(lua_argv, j, lua_argv_size);
|
|
luaPushError(lua, "Command arguments must be strings or integers");
|
|
return NULL;
|
|
}
|
|
|
|
return lua_argv;
|
|
}
|
|
|
|
void freeLuaServerArgv(robj **argv, int argc, int argv_len) {
|
|
int j;
|
|
for (j = 0; j < argc; j++) {
|
|
robj *o = argv[j];
|
|
|
|
/* Try to cache the object in the lua_args_cached_objects array.
|
|
* The object must be small, SDS-encoded, and with refcount = 1
|
|
* (we must be the only owner) for us to cache it. */
|
|
if (j < LUA_CMD_OBJCACHE_SIZE && o->refcount == 1 &&
|
|
(o->encoding == OBJ_ENCODING_RAW || o->encoding == OBJ_ENCODING_EMBSTR) &&
|
|
sdslen(o->ptr) <= LUA_CMD_OBJCACHE_MAX_LEN) {
|
|
sds s = o->ptr;
|
|
if (lua_args_cached_objects[j]) decrRefCount(lua_args_cached_objects[j]);
|
|
lua_args_cached_objects[j] = o;
|
|
lua_args_cached_objects_len[j] = sdsalloc(s);
|
|
} else {
|
|
decrRefCount(o);
|
|
}
|
|
}
|
|
if (argv != lua_argv || argv_len != lua_argv_size) {
|
|
/* The command changed argv, scrap the cache and start over. */
|
|
zfree(argv);
|
|
lua_argv = NULL;
|
|
lua_argv_size = 0;
|
|
}
|
|
}
|
|
|
|
static int luaServerGenericCommand(lua_State *lua, int raise_error) {
|
|
int j;
|
|
scriptRunCtx *rctx = luaGetFromRegistry(lua, REGISTRY_RUN_CTX_NAME);
|
|
serverAssert(rctx); /* Only supported inside script invocation */
|
|
sds err = NULL;
|
|
client *c = rctx->c;
|
|
sds reply;
|
|
|
|
c->argv = luaArgsToServerArgv(lua, &c->argc, &c->argv_len);
|
|
if (c->argv == NULL) {
|
|
return raise_error ? luaError(lua) : 1;
|
|
}
|
|
|
|
static int inuse = 0; /* Recursive calls detection. */
|
|
|
|
/* By using Lua debug hooks it is possible to trigger a recursive call
|
|
* to luaServerGenericCommand(), which normally should never happen.
|
|
* To make this function reentrant is futile and makes it slower, but
|
|
* we should at least detect such a misuse, and abort. */
|
|
if (inuse) {
|
|
char *recursion_warning = "luaRedisGenericCommand() recursive call detected. "
|
|
"Are you doing funny stuff with Lua debug hooks?";
|
|
serverLog(LL_WARNING, "%s", recursion_warning);
|
|
luaPushError(lua, recursion_warning);
|
|
return 1;
|
|
}
|
|
inuse++;
|
|
|
|
/* Log the command if debugging is active. */
|
|
if (ldbIsEnabled()) {
|
|
sds cmdlog = sdsnew("<command>");
|
|
for (j = 0; j < c->argc; j++) {
|
|
if (j == 10) {
|
|
cmdlog = sdscatprintf(cmdlog, " ... (%d more)", c->argc - j - 1);
|
|
break;
|
|
} else {
|
|
cmdlog = sdscatlen(cmdlog, " ", 1);
|
|
cmdlog = sdscatsds(cmdlog, c->argv[j]->ptr);
|
|
}
|
|
}
|
|
ldbLog(cmdlog);
|
|
}
|
|
|
|
scriptCall(rctx, &err);
|
|
if (err) {
|
|
luaPushError(lua, err);
|
|
sdsfree(err);
|
|
/* push a field indicate to ignore updating the stats on this error
|
|
* because it was already updated when executing the command. */
|
|
lua_pushstring(lua, "ignore_error_stats_update");
|
|
lua_pushboolean(lua, 1);
|
|
lua_settable(lua, -3);
|
|
goto cleanup;
|
|
}
|
|
|
|
/* Convert the result of the command into a suitable Lua type.
|
|
* The first thing we need is to create a single string from the client
|
|
* output buffers. */
|
|
if (listLength(c->reply) == 0 && (size_t)c->bufpos < c->buf_usable_size) {
|
|
/* This is a fast path for the common case of a reply inside the
|
|
* client static buffer. Don't create an SDS string but just use
|
|
* the client buffer directly. */
|
|
c->buf[c->bufpos] = '\0';
|
|
reply = c->buf;
|
|
c->bufpos = 0;
|
|
} else {
|
|
reply = sdsnewlen(c->buf, c->bufpos);
|
|
c->bufpos = 0;
|
|
while (listLength(c->reply)) {
|
|
clientReplyBlock *o = listNodeValue(listFirst(c->reply));
|
|
|
|
reply = sdscatlen(reply, o->buf, o->used);
|
|
listDelNode(c->reply, listFirst(c->reply));
|
|
}
|
|
}
|
|
if (raise_error && reply[0] != '-') raise_error = 0;
|
|
redisProtocolToLuaType(lua, reply);
|
|
|
|
/* If the debugger is active, log the reply from the server. */
|
|
if (ldbIsEnabled())
|
|
ldbLogRespReply(reply);
|
|
|
|
if (reply != c->buf) sdsfree(reply);
|
|
c->reply_bytes = 0;
|
|
|
|
cleanup:
|
|
/* Clean up. Command code may have changed argv/argc so we use the
|
|
* argv/argc of the client instead of the local variables. */
|
|
freeLuaServerArgv(c->argv, c->argc, c->argv_len);
|
|
c->argc = c->argv_len = 0;
|
|
c->user = NULL;
|
|
c->argv = NULL;
|
|
resetClient(c);
|
|
inuse--;
|
|
|
|
if (raise_error) {
|
|
/* If we are here we should have an error in the stack, in the
|
|
* form of a table with an "err" field. Extract the string to
|
|
* return the plain error. */
|
|
return luaError(lua);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/* Our implementation to lua pcall.
|
|
* We need this implementation for backward
|
|
* comparability with older Redis OSS versions.
|
|
*
|
|
* On Redis OSS 7, the error object is a table,
|
|
* compare to older version where the error
|
|
* object is a string. To keep backward
|
|
* comparability we catch the table object
|
|
* and just return the error message. */
|
|
static int luaRedisPcall(lua_State *lua) {
|
|
int argc = lua_gettop(lua);
|
|
lua_pushboolean(lua, 1); /* result place holder */
|
|
lua_insert(lua, 1);
|
|
if (lua_pcall(lua, argc - 1, LUA_MULTRET, 0)) {
|
|
/* Error */
|
|
lua_remove(lua, 1); /* remove the result place holder, now we have room for at least one element */
|
|
if (lua_istable(lua, -1)) {
|
|
lua_getfield(lua, -1, "err");
|
|
if (lua_isstring(lua, -1)) {
|
|
lua_replace(lua, -2); /* replace the error message with the table */
|
|
}
|
|
}
|
|
lua_pushboolean(lua, 0); /* push result */
|
|
lua_insert(lua, 1);
|
|
}
|
|
return lua_gettop(lua);
|
|
}
|
|
|
|
/* server.call() */
|
|
static int luaRedisCallCommand(lua_State *lua) {
|
|
return luaServerGenericCommand(lua, 1);
|
|
}
|
|
|
|
/* server.pcall() */
|
|
static int luaRedisPCallCommand(lua_State *lua) {
|
|
return luaServerGenericCommand(lua, 0);
|
|
}
|
|
|
|
/* This adds server.sha1hex(string) to Lua scripts using the same hashing
|
|
* function used for sha1ing lua scripts. */
|
|
static int luaRedisSha1hexCommand(lua_State *lua) {
|
|
int argc = lua_gettop(lua);
|
|
char digest[41];
|
|
size_t len;
|
|
char *s;
|
|
|
|
if (argc != 1) {
|
|
luaPushError(lua, "wrong number of arguments");
|
|
return luaError(lua);
|
|
}
|
|
|
|
s = (char *)lua_tolstring(lua, 1, &len);
|
|
sha1hex(digest, s, len);
|
|
lua_pushstring(lua, digest);
|
|
return 1;
|
|
}
|
|
|
|
/* Returns a table with a single field 'field' set to the string value
|
|
* passed as argument. This helper function is handy when returning
|
|
* a RESP error or status reply from Lua:
|
|
*
|
|
* return server.error_reply("ERR Some Error")
|
|
* return server.status_reply("ERR Some Error")
|
|
*/
|
|
static int luaRedisReturnSingleFieldTable(lua_State *lua, char *field) {
|
|
if (lua_gettop(lua) != 1 || lua_type(lua, -1) != LUA_TSTRING) {
|
|
luaPushError(lua, "wrong number or type of arguments");
|
|
return 1;
|
|
}
|
|
|
|
lua_newtable(lua);
|
|
lua_pushstring(lua, field);
|
|
lua_pushvalue(lua, -3);
|
|
lua_settable(lua, -3);
|
|
return 1;
|
|
}
|
|
|
|
/* server.error_reply() */
|
|
static int luaRedisErrorReplyCommand(lua_State *lua) {
|
|
if (lua_gettop(lua) != 1 || lua_type(lua, -1) != LUA_TSTRING) {
|
|
luaPushError(lua, "wrong number or type of arguments");
|
|
return 1;
|
|
}
|
|
|
|
/* add '-' if not exists */
|
|
const char *err = lua_tostring(lua, -1);
|
|
sds err_buff = NULL;
|
|
if (err[0] != '-') {
|
|
err_buff = sdscatfmt(sdsempty(), "-%s", err);
|
|
} else {
|
|
err_buff = sdsnew(err);
|
|
}
|
|
luaPushErrorBuff(lua, err_buff);
|
|
return 1;
|
|
}
|
|
|
|
/* server.status_reply() */
|
|
static int luaRedisStatusReplyCommand(lua_State *lua) {
|
|
return luaRedisReturnSingleFieldTable(lua, "ok");
|
|
}
|
|
|
|
/* server.set_repl()
|
|
*
|
|
* Set the propagation of write commands executed in the context of the
|
|
* script to on/off for AOF and replicas. */
|
|
static int luaRedisSetReplCommand(lua_State *lua) {
|
|
int flags, argc = lua_gettop(lua);
|
|
|
|
scriptRunCtx *rctx = luaGetFromRegistry(lua, REGISTRY_RUN_CTX_NAME);
|
|
serverAssert(rctx); /* Only supported inside script invocation */
|
|
|
|
if (argc != 1) {
|
|
luaPushError(lua, "server.set_repl() requires one argument.");
|
|
return luaError(lua);
|
|
}
|
|
|
|
flags = lua_tonumber(lua, -1);
|
|
if ((flags & ~(PROPAGATE_AOF | PROPAGATE_REPL)) != 0) {
|
|
luaPushError(lua, "Invalid replication flags. Use REPL_AOF, REPL_REPLICA, REPL_ALL or REPL_NONE.");
|
|
return luaError(lua);
|
|
}
|
|
|
|
scriptSetRepl(rctx, flags);
|
|
return 0;
|
|
}
|
|
|
|
/* server.acl_check_cmd()
|
|
*
|
|
* Checks ACL permissions for given command for the current user. */
|
|
static int luaRedisAclCheckCmdPermissionsCommand(lua_State *lua) {
|
|
scriptRunCtx *rctx = luaGetFromRegistry(lua, REGISTRY_RUN_CTX_NAME);
|
|
serverAssert(rctx); /* Only supported inside script invocation */
|
|
int raise_error = 0;
|
|
|
|
int argc, argv_len;
|
|
robj **argv = luaArgsToServerArgv(lua, &argc, &argv_len);
|
|
|
|
/* Require at least one argument */
|
|
if (argv == NULL) return luaError(lua);
|
|
|
|
/* Find command */
|
|
struct serverCommand *cmd;
|
|
if ((cmd = lookupCommand(argv, argc)) == NULL) {
|
|
luaPushError(lua, "Invalid command passed to server.acl_check_cmd()");
|
|
raise_error = 1;
|
|
} else {
|
|
int keyidxptr;
|
|
if (ACLCheckAllUserCommandPerm(rctx->original_client->user, cmd, argv, argc, &keyidxptr) != ACL_OK) {
|
|
lua_pushboolean(lua, 0);
|
|
} else {
|
|
lua_pushboolean(lua, 1);
|
|
}
|
|
}
|
|
|
|
freeLuaServerArgv(argv, argc, argv_len);
|
|
if (raise_error)
|
|
return luaError(lua);
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* server.log() */
|
|
static int luaLogCommand(lua_State *lua) {
|
|
int j, argc = lua_gettop(lua);
|
|
int level;
|
|
sds log;
|
|
|
|
if (argc < 2) {
|
|
luaPushError(lua, "server.log() requires two arguments or more.");
|
|
return luaError(lua);
|
|
} else if (!lua_isnumber(lua, -argc)) {
|
|
luaPushError(lua, "First argument must be a number (log level).");
|
|
return luaError(lua);
|
|
}
|
|
level = lua_tonumber(lua, -argc);
|
|
if (level < LL_DEBUG || level > LL_WARNING) {
|
|
luaPushError(lua, "Invalid log level.");
|
|
return luaError(lua);
|
|
}
|
|
if (level < server.verbosity) return 0;
|
|
|
|
/* Glue together all the arguments */
|
|
log = sdsempty();
|
|
for (j = 1; j < argc; j++) {
|
|
size_t len;
|
|
char *s;
|
|
|
|
s = (char *)lua_tolstring(lua, (-argc) + j, &len);
|
|
if (s) {
|
|
if (j != 1) log = sdscatlen(log, " ", 1);
|
|
log = sdscatlen(log, s, len);
|
|
}
|
|
}
|
|
serverLogRaw(level, log);
|
|
sdsfree(log);
|
|
return 0;
|
|
}
|
|
|
|
/* server.setresp() */
|
|
static int luaSetResp(lua_State *lua) {
|
|
scriptRunCtx *rctx = luaGetFromRegistry(lua, REGISTRY_RUN_CTX_NAME);
|
|
serverAssert(rctx); /* Only supported inside script invocation */
|
|
int argc = lua_gettop(lua);
|
|
|
|
if (argc != 1) {
|
|
luaPushError(lua, "server.setresp() requires one argument.");
|
|
return luaError(lua);
|
|
}
|
|
|
|
int resp = lua_tonumber(lua, -argc);
|
|
if (resp != 2 && resp != 3) {
|
|
luaPushError(lua, "RESP version must be 2 or 3.");
|
|
return luaError(lua);
|
|
}
|
|
scriptSetResp(rctx, resp);
|
|
return 0;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------------
|
|
* Lua engine initialization and reset.
|
|
* ------------------------------------------------------------------------- */
|
|
|
|
static void luaLoadLib(lua_State *lua, const char *libname, lua_CFunction luafunc) {
|
|
lua_pushcfunction(lua, luafunc);
|
|
lua_pushstring(lua, libname);
|
|
lua_call(lua, 1, 0);
|
|
}
|
|
|
|
LUALIB_API int(luaopen_cjson)(lua_State *L);
|
|
LUALIB_API int(luaopen_struct)(lua_State *L);
|
|
LUALIB_API int(luaopen_cmsgpack)(lua_State *L);
|
|
LUALIB_API int(luaopen_bit)(lua_State *L);
|
|
|
|
static 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);
|
|
luaLoadLib(lua, LUA_OSLIBNAME, luaopen_os);
|
|
luaLoadLib(lua, "cjson", luaopen_cjson);
|
|
luaLoadLib(lua, "struct", luaopen_struct);
|
|
luaLoadLib(lua, "cmsgpack", luaopen_cmsgpack);
|
|
luaLoadLib(lua, "bit", luaopen_bit);
|
|
|
|
#if 0 /* Stuff that we don't load currently, for sandboxing concerns. */
|
|
luaLoadLib(lua, LUA_LOADLIBNAME, luaopen_package);
|
|
#endif
|
|
}
|
|
|
|
/* Return sds of the string value located on stack at the given index.
|
|
* Return NULL if the value is not a string. */
|
|
robj *luaGetStringObject(lua_State *lua, int index) {
|
|
if (!lua_isstring(lua, index)) {
|
|
return NULL;
|
|
}
|
|
|
|
size_t len;
|
|
const char *str = lua_tolstring(lua, index, &len);
|
|
robj *str_obj = createStringObject(str, len);
|
|
return str_obj;
|
|
}
|
|
|
|
static int luaProtectedTableError(lua_State *lua) {
|
|
int argc = lua_gettop(lua);
|
|
if (argc != 2) {
|
|
serverLog(LL_WARNING, "malicious code trying to call luaProtectedTableError with wrong arguments");
|
|
luaL_error(lua, "Wrong number of arguments to luaProtectedTableError");
|
|
}
|
|
if (!lua_isstring(lua, -1) && !lua_isnumber(lua, -1)) {
|
|
luaL_error(lua, "Second argument to luaProtectedTableError must be a string or number");
|
|
}
|
|
const char *variable_name = lua_tostring(lua, -1);
|
|
luaL_error(lua, "Script attempted to access nonexistent global variable '%s'", variable_name);
|
|
return 0;
|
|
}
|
|
|
|
/* Set a special metatable on the table on the top of the stack.
|
|
* The metatable will raise an error if the user tries to fetch
|
|
* an un-existing value.
|
|
*
|
|
* The function assumes the Lua stack have a least enough
|
|
* space to push 2 element, its up to the caller to verify
|
|
* this before calling this function. */
|
|
void luaSetErrorMetatable(lua_State *lua) {
|
|
lua_newtable(lua); /* push metatable */
|
|
lua_pushcfunction(lua, luaProtectedTableError); /* push get error handler */
|
|
lua_setfield(lua, -2, "__index");
|
|
lua_setmetatable(lua, -2);
|
|
}
|
|
|
|
static int luaNewIndexAllowList(lua_State *lua) {
|
|
int argc = lua_gettop(lua);
|
|
if (argc != 3) {
|
|
serverLog(LL_WARNING, "malicious code trying to call luaNewIndexAllowList with wrong arguments");
|
|
luaL_error(lua, "Wrong number of arguments to luaNewIndexAllowList");
|
|
}
|
|
if (!lua_istable(lua, -3)) {
|
|
luaL_error(lua, "first argument to luaNewIndexAllowList must be a table");
|
|
}
|
|
if (!lua_isstring(lua, -2) && !lua_isnumber(lua, -2)) {
|
|
luaL_error(lua, "Second argument to luaNewIndexAllowList must be a string or number");
|
|
}
|
|
const char *variable_name = lua_tostring(lua, -2);
|
|
/* check if the key is in our allow list */
|
|
|
|
char ***allow_l = allow_lists;
|
|
for (; *allow_l; ++allow_l) {
|
|
char **c = *allow_l;
|
|
for (; *c; ++c) {
|
|
if (strcmp(*c, variable_name) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
if (*c) {
|
|
break;
|
|
}
|
|
}
|
|
if (!*allow_l) {
|
|
/* Search the value on the back list, if its there we know that it was removed
|
|
* on purpose and there is no need to print a warning. */
|
|
char **c = deny_list;
|
|
for (; *c; ++c) {
|
|
if (strcmp(*c, variable_name) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
if (!*c) {
|
|
serverLog(LL_WARNING,
|
|
"A key '%s' was added to Lua globals which is not on the globals allow list nor listed on the "
|
|
"deny list.",
|
|
variable_name);
|
|
}
|
|
} else {
|
|
lua_rawset(lua, -3);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Set a metatable with '__newindex' function that verify that
|
|
* the new index appears on our globals while list.
|
|
*
|
|
* The metatable is set on the table which located on the top
|
|
* of the stack.
|
|
*/
|
|
void luaSetAllowListProtection(lua_State *lua) {
|
|
lua_newtable(lua); /* push metatable */
|
|
lua_pushcfunction(lua, luaNewIndexAllowList); /* push get error handler */
|
|
lua_setfield(lua, -2, "__newindex");
|
|
lua_setmetatable(lua, -2);
|
|
}
|
|
|
|
/* Set the readonly flag on the table located on the top of the stack
|
|
* and recursively call this function on each table located on the original
|
|
* table. Also, recursively call this function on the metatables.*/
|
|
void luaSetTableProtectionRecursively(lua_State *lua) {
|
|
/* This protect us from a loop in case we already visited the table
|
|
* For example, globals has '_G' key which is pointing back to globals. */
|
|
if (lua_isreadonlytable(lua, -1)) {
|
|
return;
|
|
}
|
|
|
|
/* protect the current table */
|
|
lua_enablereadonlytable(lua, -1, 1);
|
|
|
|
lua_checkstack(lua, 2);
|
|
lua_pushnil(lua); /* Use nil to start iteration. */
|
|
while (lua_next(lua, -2)) {
|
|
/* Stack now: table, key, value */
|
|
if (lua_istable(lua, -1)) {
|
|
luaSetTableProtectionRecursively(lua);
|
|
}
|
|
lua_pop(lua, 1);
|
|
}
|
|
|
|
/* protect the metatable if exists */
|
|
if (lua_getmetatable(lua, -1)) {
|
|
luaSetTableProtectionRecursively(lua);
|
|
lua_pop(lua, 1); /* pop the metatable */
|
|
}
|
|
}
|
|
|
|
void luaRegisterVersion(lua_State *lua) {
|
|
/* For legacy compatibility reasons include Redis versions. */
|
|
lua_pushstring(lua, "REDIS_VERSION_NUM");
|
|
lua_pushnumber(lua, REDIS_VERSION_NUM);
|
|
lua_settable(lua, -3);
|
|
|
|
lua_pushstring(lua, "REDIS_VERSION");
|
|
lua_pushstring(lua, REDIS_VERSION);
|
|
lua_settable(lua, -3);
|
|
|
|
/* Now push the Valkey version information. */
|
|
lua_pushstring(lua, "VALKEY_VERSION_NUM");
|
|
lua_pushnumber(lua, VALKEY_VERSION_NUM);
|
|
lua_settable(lua, -3);
|
|
|
|
lua_pushstring(lua, "VALKEY_VERSION");
|
|
lua_pushstring(lua, VALKEY_VERSION);
|
|
lua_settable(lua, -3);
|
|
|
|
lua_pushstring(lua, "SERVER_NAME");
|
|
lua_pushstring(lua, SERVER_NAME);
|
|
lua_settable(lua, -3);
|
|
}
|
|
|
|
void luaRegisterLogFunction(lua_State *lua) {
|
|
/* server.log and log levels. */
|
|
lua_pushstring(lua, "log");
|
|
lua_pushcfunction(lua, luaLogCommand);
|
|
lua_settable(lua, -3);
|
|
|
|
lua_pushstring(lua, "LOG_DEBUG");
|
|
lua_pushnumber(lua, LL_DEBUG);
|
|
lua_settable(lua, -3);
|
|
|
|
lua_pushstring(lua, "LOG_VERBOSE");
|
|
lua_pushnumber(lua, LL_VERBOSE);
|
|
lua_settable(lua, -3);
|
|
|
|
lua_pushstring(lua, "LOG_NOTICE");
|
|
lua_pushnumber(lua, LL_NOTICE);
|
|
lua_settable(lua, -3);
|
|
|
|
lua_pushstring(lua, "LOG_WARNING");
|
|
lua_pushnumber(lua, LL_WARNING);
|
|
lua_settable(lua, -3);
|
|
}
|
|
|
|
/*
|
|
* Adds server.* functions/fields to lua such as server.call etc.
|
|
* This function only handles fields common between Functions and LUA scripting.
|
|
* scriptingInit() and functionsInit() may add additional fields specific to each.
|
|
*/
|
|
void luaRegisterServerAPI(lua_State *lua) {
|
|
/* In addition to registering server.call/pcall API, we will throw a custom message when a script accesses
|
|
* undefined global variable. LUA stores global variables in the global table, accessible to us on stack at virtual
|
|
* index = LUA_GLOBALSINDEX. We will set __index handler in global table's metatable to a custom C function to
|
|
* achieve this - handled by luaSetAllowListProtection. Refer to https://www.lua.org/pil/13.4.1.html for
|
|
* documentation on __index and https://www.lua.org/pil/contents.html#13 for documentation on metatables. We need to
|
|
* pass global table to lua invocations as parameters. To achieve this, lua_pushvalue invocation brings global
|
|
* variable table to the top of the stack by pushing value from global index onto the stack. And lua_pop invocation
|
|
* after luaSetAllowListProtection removes it - resetting the stack to its original state. */
|
|
lua_pushvalue(lua, LUA_GLOBALSINDEX);
|
|
luaSetAllowListProtection(lua);
|
|
lua_pop(lua, 1);
|
|
|
|
/* Add default C functions provided in deps/lua codebase to handle basic data types such as table, string etc. */
|
|
luaLoadLibraries(lua);
|
|
|
|
/* Before Redis OSS 7, Lua used to return error messages as strings from pcall function. With Valkey (or Redis OSS 7), Lua now returns
|
|
* error messages as tables. To keep backwards compatibility, we wrap the Lua pcall function with our own
|
|
* implementation of C function that converts table to string. */
|
|
lua_pushcfunction(lua, luaRedisPcall);
|
|
lua_setglobal(lua, "pcall");
|
|
|
|
/* Create a top level table object on the stack to temporarily hold fields for 'server' table. We will name it as
|
|
* 'server' and send it to LUA at the very end. Also add 'call' and 'pcall' functions to the table. */
|
|
lua_newtable(lua);
|
|
lua_pushstring(lua, "call");
|
|
lua_pushcfunction(lua, luaRedisCallCommand);
|
|
lua_settable(lua, -3);
|
|
lua_pushstring(lua, "pcall");
|
|
lua_pushcfunction(lua, luaRedisPCallCommand);
|
|
lua_settable(lua, -3);
|
|
|
|
/* Add server.log function and debug level constants. LUA scripts use it to print messages to server log. */
|
|
luaRegisterLogFunction(lua);
|
|
|
|
/* Add SERVER_VERSION_NUM, SERVER_VERSION and SERVER_NAME fields with appropriate values. */
|
|
luaRegisterVersion(lua);
|
|
|
|
/* Add server.setresp function to allow LUA scripts to change the RESP version for server.call and server.pcall
|
|
* invocations. */
|
|
lua_pushstring(lua, "setresp");
|
|
lua_pushcfunction(lua, luaSetResp);
|
|
lua_settable(lua, -3);
|
|
|
|
/* Add server.sha1hex function. */
|
|
lua_pushstring(lua, "sha1hex");
|
|
lua_pushcfunction(lua, luaRedisSha1hexCommand);
|
|
lua_settable(lua, -3);
|
|
|
|
/* Add server.error_reply and server.status_reply functions. */
|
|
lua_pushstring(lua, "error_reply");
|
|
lua_pushcfunction(lua, luaRedisErrorReplyCommand);
|
|
lua_settable(lua, -3);
|
|
lua_pushstring(lua, "status_reply");
|
|
lua_pushcfunction(lua, luaRedisStatusReplyCommand);
|
|
lua_settable(lua, -3);
|
|
|
|
/* Add server.set_repl function and associated flags. */
|
|
lua_pushstring(lua, "set_repl");
|
|
lua_pushcfunction(lua, luaRedisSetReplCommand);
|
|
lua_settable(lua, -3);
|
|
|
|
lua_pushstring(lua, "REPL_NONE");
|
|
lua_pushnumber(lua, PROPAGATE_NONE);
|
|
lua_settable(lua, -3);
|
|
|
|
lua_pushstring(lua, "REPL_AOF");
|
|
lua_pushnumber(lua, PROPAGATE_AOF);
|
|
lua_settable(lua, -3);
|
|
|
|
lua_pushstring(lua, "REPL_SLAVE");
|
|
lua_pushnumber(lua, PROPAGATE_REPL);
|
|
lua_settable(lua, -3);
|
|
|
|
lua_pushstring(lua, "REPL_REPLICA");
|
|
lua_pushnumber(lua, PROPAGATE_REPL);
|
|
lua_settable(lua, -3);
|
|
|
|
lua_pushstring(lua, "REPL_ALL");
|
|
lua_pushnumber(lua, PROPAGATE_AOF | PROPAGATE_REPL);
|
|
lua_settable(lua, -3);
|
|
|
|
/* Add server.acl_check_cmd function. */
|
|
lua_pushstring(lua, "acl_check_cmd");
|
|
lua_pushcfunction(lua, luaRedisAclCheckCmdPermissionsCommand);
|
|
lua_settable(lua, -3);
|
|
|
|
/* Finally set the table as 'server' global var.
|
|
* We will also alias it to 'redis' global var for backwards compatibility. */
|
|
lua_setglobal(lua, SERVER_API_NAME);
|
|
/* lua_getglobal invocation retrieves the 'server' variable value to the stack.
|
|
* lua_setglobal invocation uses the value from stack to set 'redis' global variable.
|
|
* This is not a deep copy but is enough for our purpose here. */
|
|
lua_getglobal(lua, SERVER_API_NAME);
|
|
lua_setglobal(lua, REDIS_API_NAME);
|
|
|
|
/* Replace math.random and math.randomseed with custom implementations. */
|
|
lua_getglobal(lua, "math");
|
|
lua_pushstring(lua, "random");
|
|
lua_pushcfunction(lua, server_math_random);
|
|
lua_settable(lua, -3);
|
|
lua_pushstring(lua, "randomseed");
|
|
lua_pushcfunction(lua, server_math_randomseed);
|
|
lua_settable(lua, -3);
|
|
/* overwrite value of global variable 'math' with this modified math table present on top of stack. */
|
|
lua_setglobal(lua, "math");
|
|
}
|
|
|
|
/* Set an array of String Objects as a Lua array (table) stored into a
|
|
* global variable. */
|
|
static void luaCreateArray(lua_State *lua, robj **elev, int elec) {
|
|
int j;
|
|
|
|
lua_createtable(lua, elec, 0);
|
|
for (j = 0; j < elec; j++) {
|
|
lua_pushlstring(lua, (char *)elev[j]->ptr, sdslen(elev[j]->ptr));
|
|
lua_rawseti(lua, -2, j + 1);
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------------
|
|
* Custom provided math.random
|
|
* ------------------------------------------------------------------------- */
|
|
|
|
/* 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 serverLrand48(). */
|
|
static int server_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)(serverLrand48() % SERVER_LRAND48_MAX) /
|
|
(lua_Number)SERVER_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;
|
|
}
|
|
|
|
static int server_math_randomseed(lua_State *L) {
|
|
serverSrand48(luaL_checkint(L, 1));
|
|
return 0;
|
|
}
|
|
|
|
/* This is the Lua script "count" hook that we use to detect scripts timeout. */
|
|
static void luaMaskCountHook(lua_State *lua, lua_Debug *ar) {
|
|
UNUSED(ar);
|
|
scriptRunCtx *rctx = luaGetFromRegistry(lua, REGISTRY_RUN_CTX_NAME);
|
|
serverAssert(rctx); /* Only supported inside script invocation */
|
|
if (scriptInterrupt(rctx) == SCRIPT_KILL) {
|
|
char *err = NULL;
|
|
if (rctx->flags & SCRIPT_EVAL_MODE) {
|
|
err = "Script killed by user with SCRIPT KILL.";
|
|
} else {
|
|
err = "Script killed by user with FUNCTION KILL.";
|
|
}
|
|
serverLog(LL_NOTICE, "%s", err);
|
|
|
|
/*
|
|
* Set the hook to invoke all the time so the user
|
|
* will not be able to catch the error with pcall and invoke
|
|
* pcall again which will prevent the script from ever been killed
|
|
*/
|
|
lua_sethook(lua, luaMaskCountHook, LUA_MASKLINE, 0);
|
|
|
|
luaPushError(lua, err);
|
|
luaError(lua);
|
|
}
|
|
}
|
|
|
|
void luaErrorInformationDiscard(errorInfo *err_info) {
|
|
if (err_info->msg) sdsfree(err_info->msg);
|
|
if (err_info->source) sdsfree(err_info->source);
|
|
if (err_info->line) sdsfree(err_info->line);
|
|
}
|
|
|
|
void luaExtractErrorInformation(lua_State *lua, errorInfo *err_info) {
|
|
if (lua_isstring(lua, -1)) {
|
|
err_info->msg = sdscatfmt(sdsempty(), "ERR %s", lua_tostring(lua, -1));
|
|
err_info->line = NULL;
|
|
err_info->source = NULL;
|
|
err_info->ignore_err_stats_update = 0;
|
|
return;
|
|
}
|
|
|
|
lua_getfield(lua, -1, "err");
|
|
if (lua_isstring(lua, -1)) {
|
|
err_info->msg = sdsnew(lua_tostring(lua, -1));
|
|
}
|
|
lua_pop(lua, 1);
|
|
|
|
lua_getfield(lua, -1, "source");
|
|
if (lua_isstring(lua, -1)) {
|
|
err_info->source = sdsnew(lua_tostring(lua, -1));
|
|
}
|
|
lua_pop(lua, 1);
|
|
|
|
lua_getfield(lua, -1, "line");
|
|
if (lua_isstring(lua, -1)) {
|
|
err_info->line = sdsnew(lua_tostring(lua, -1));
|
|
}
|
|
lua_pop(lua, 1);
|
|
|
|
lua_getfield(lua, -1, "ignore_error_stats_update");
|
|
if (lua_isboolean(lua, -1)) {
|
|
err_info->ignore_err_stats_update = lua_toboolean(lua, -1);
|
|
}
|
|
lua_pop(lua, 1);
|
|
}
|
|
|
|
void luaCallFunction(scriptRunCtx *run_ctx,
|
|
lua_State *lua,
|
|
robj **keys,
|
|
size_t nkeys,
|
|
robj **args,
|
|
size_t nargs,
|
|
int debug_enabled) {
|
|
client *c = run_ctx->original_client;
|
|
int delhook = 0;
|
|
|
|
/* We must set it before we set the Lua hook, theoretically the
|
|
* Lua hook might be called wheneven we run any Lua instruction
|
|
* such as 'luaSetGlobalArray' and we want the run_ctx to be available
|
|
* each time the Lua hook is invoked. */
|
|
luaSaveOnRegistry(lua, REGISTRY_RUN_CTX_NAME, run_ctx);
|
|
|
|
if (server.busy_reply_threshold > 0 && !debug_enabled) {
|
|
lua_sethook(lua, luaMaskCountHook, LUA_MASKCOUNT, 100000);
|
|
delhook = 1;
|
|
} else if (debug_enabled) {
|
|
lua_sethook(lua, luaLdbLineHook, LUA_MASKLINE | LUA_MASKCOUNT, 100000);
|
|
delhook = 1;
|
|
}
|
|
|
|
/* Populate the argv and keys table accordingly to the arguments that
|
|
* EVAL received. */
|
|
luaCreateArray(lua, keys, nkeys);
|
|
/* On eval, keys and arguments are globals. */
|
|
if (run_ctx->flags & SCRIPT_EVAL_MODE) {
|
|
/* open global protection to set KEYS */
|
|
lua_enablereadonlytable(lua, LUA_GLOBALSINDEX, 0);
|
|
lua_setglobal(lua, "KEYS");
|
|
lua_enablereadonlytable(lua, LUA_GLOBALSINDEX, 1);
|
|
}
|
|
luaCreateArray(lua, args, nargs);
|
|
if (run_ctx->flags & SCRIPT_EVAL_MODE) {
|
|
/* open global protection to set ARGV */
|
|
lua_enablereadonlytable(lua, LUA_GLOBALSINDEX, 0);
|
|
lua_setglobal(lua, "ARGV");
|
|
lua_enablereadonlytable(lua, LUA_GLOBALSINDEX, 1);
|
|
}
|
|
|
|
/* At this point whether this script was never seen before or if it was
|
|
* already defined, we can call it.
|
|
* On eval mode, we have zero arguments and expect a single return value.
|
|
* In addition the error handler is located on position -2 on the Lua stack.
|
|
* On function mode, we pass 2 arguments (the keys and args tables),
|
|
* and the error handler is located on position -4 (stack: error_handler, callback, keys, args) */
|
|
int err;
|
|
if (run_ctx->flags & SCRIPT_EVAL_MODE) {
|
|
err = lua_pcall(lua, 0, 1, -2);
|
|
} else {
|
|
err = lua_pcall(lua, 2, 1, -4);
|
|
}
|
|
|
|
/* Call the Lua garbage collector from time to time to avoid a
|
|
* full cycle performed by Lua, which adds too latency.
|
|
*
|
|
* The call is performed every LUA_GC_CYCLE_PERIOD executed commands
|
|
* (and for LUA_GC_CYCLE_PERIOD collection steps) because calling it
|
|
* for every command uses too much CPU. */
|
|
#define LUA_GC_CYCLE_PERIOD 50
|
|
{
|
|
static long gc_count = 0;
|
|
|
|
gc_count++;
|
|
if (gc_count == LUA_GC_CYCLE_PERIOD) {
|
|
lua_gc(lua, LUA_GCSTEP, LUA_GC_CYCLE_PERIOD);
|
|
gc_count = 0;
|
|
}
|
|
}
|
|
|
|
if (err) {
|
|
/* Error object is a table of the following format:
|
|
* {err='<error msg>', source='<source file>', line=<line>}
|
|
* We can construct the error message from this information */
|
|
if (!lua_istable(lua, -1)) {
|
|
const char *msg = "execution failure";
|
|
if (lua_isstring(lua, -1)) {
|
|
msg = lua_tostring(lua, -1);
|
|
}
|
|
addReplyErrorFormat(c, "Error running script %s, %.100s\n", run_ctx->funcname, msg);
|
|
} else {
|
|
errorInfo err_info = {0};
|
|
sds final_msg = sdsempty();
|
|
luaExtractErrorInformation(lua, &err_info);
|
|
final_msg = sdscatfmt(final_msg, "-%s", err_info.msg);
|
|
if (err_info.line && err_info.source) {
|
|
final_msg =
|
|
sdscatfmt(final_msg, " script: %s, on %s:%s.", run_ctx->funcname, err_info.source, err_info.line);
|
|
}
|
|
addReplyErrorSdsEx(c, final_msg, err_info.ignore_err_stats_update ? ERR_REPLY_FLAG_NO_STATS_UPDATE : 0);
|
|
luaErrorInformationDiscard(&err_info);
|
|
}
|
|
lua_pop(lua, 1); /* Consume the Lua error */
|
|
} else {
|
|
/* On success convert the Lua return value into RESP, and
|
|
* send it to * the client. */
|
|
luaReplyToServerReply(c, run_ctx->c, lua); /* Convert and consume the reply. */
|
|
}
|
|
|
|
/* Perform some cleanup that we need to do both on error and success. */
|
|
if (delhook) lua_sethook(lua, NULL, 0, 0); /* Disable hook */
|
|
|
|
/* remove run_ctx from registry, its only applicable for the current script. */
|
|
luaSaveOnRegistry(lua, REGISTRY_RUN_CTX_NAME, NULL);
|
|
}
|
|
|
|
unsigned long luaMemory(lua_State *lua) {
|
|
return lua_gc(lua, LUA_GCCOUNT, 0) * 1024LL;
|
|
}
|