[redis.git] / src / scripting.c

#include "redis.h"
#include "sha1.h"

#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>

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);

/* 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
 * clients, it is trvial to implement the redis() lua function.
 *
 * Basically we take the arguments, execute the Redis 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 Redis internals API. Basically 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 Redis directly. This allows use to go faster.
 * The reply string can be altered during the parsing as it is discared
 * after the conversion is completed.
 *
 * Errors are returned as a table with a single 'err' field set to the
 * error string.
 */

char *redisProtocolToLuaType(lua_State *lua, char* reply) {
    char *p = reply;

    switch(*p) {
    case ':':
        p = redisProtocolToLuaType_Int(lua,reply);
        break;
    case '$':
        p = redisProtocolToLuaType_Bulk(lua,reply);
        break;
    case '+':
        p = redisProtocolToLuaType_Status(lua,reply);
        break;
    case '-':
        p = redisProtocolToLuaType_Error(lua,reply);
        break;
    case '*':
        p = redisProtocolToLuaType_MultiBulk(lua,reply);
        break;
    }
    return p;
}

char *redisProtocolToLuaType_Int(lua_State *lua, char *reply) {
    char *p = strchr(reply+1,'\r');
    long long value;

    string2ll(reply+1,p-reply-1,&value);
    lua_pushnumber(lua,(lua_Number)value);
    return p+2;
}

char *redisProtocolToLuaType_Bulk(lua_State *lua, char *reply) {
    char *p = strchr(reply+1,'\r');
    long long bulklen;

    string2ll(reply+1,p-reply-1,&bulklen);
    if (bulklen == -1) {
        lua_pushnil(lua);
        return p+2;
    } else {
        lua_pushlstring(lua,p+2,bulklen);
        return p+2+bulklen+2;
    }
}

char *redisProtocolToLuaType_Status(lua_State *lua, char *reply) {
    char *p = strchr(reply+1,'\r');

    lua_newtable(lua);
    lua_pushstring(lua,"ok");
    lua_pushlstring(lua,reply+1,p-reply-1);
    lua_settable(lua,-3);
    return p+2;
}

char *redisProtocolToLuaType_Error(lua_State *lua, char *reply) {
    char *p = strchr(reply+1,'\r');

    lua_newtable(lua);
    lua_pushstring(lua,"err");
    lua_pushlstring(lua,reply+1,p-reply-1);
    lua_settable(lua,-3);
    return p+2;
}

char *redisProtocolToLuaType_MultiBulk(lua_State *lua, char *reply) {
    char *p = strchr(reply+1,'\r');
    long long mbulklen;
    int j = 0;

    string2ll(reply+1,p-reply-1,&mbulklen);
    p += 2;
    if (mbulklen == -1) {
        lua_pushnil(lua);
        return p;
    }
    lua_newtable(lua);
    for (j = 0; j < mbulklen; j++) {
        lua_pushnumber(lua,j+1);
        p = redisProtocolToLuaType(lua,p);
        lua_settable(lua,-3);
    }
    return p;
}

void luaPushError(lua_State *lua, char *error) {
    lua_newtable(lua);
    lua_pushstring(lua,"err");
    lua_pushstring(lua, error);
    lua_settable(lua,-3);
}

int luaRedisCommand(lua_State *lua) {
    int j, argc = lua_gettop(lua);
    struct redisCommand *cmd;
    robj **argv;
    redisClient *c = server.lua_client;
    sds reply;

    /* Build the arguments vector */
    argv = zmalloc(sizeof(robj*)*argc);
    for (j = 0; j < argc; j++) {
        if (!lua_isstring(lua,j+1)) break;
        argv[j] = createStringObject((char*)lua_tostring(lua,j+1),
                                     lua_strlen(lua,j+1));
    }
    
    /* 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) {
        j--;
        while (j >= 0) {
            decrRefCount(argv[j]);
            j--;
        }
        zfree(argv);
        luaPushError(lua,
            "Lua redis() command arguments must be strings or integers");
        return 1;
    }

    /* 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;
    }

    /* Run the command in the context of a fake client */
    c->argv = argv;
    c->argc = argc;
    cmd->proc(c);

    /* Convert the result of the Redis command into a suitable Lua type.
     * The first thing we need is to create a single string from the client
     * output buffers. */
    reply = sdsempty();
    if (c->bufpos) {
        reply = sdscatlen(reply,c->buf,c->bufpos);
        c->bufpos = 0;
    }
    while(listLength(c->reply)) {
        robj *o = listNodeValue(listFirst(c->reply));

        reply = sdscatlen(reply,o->ptr,sdslen(o->ptr));
        listDelNode(c->reply,listFirst(c->reply));
    }
    redisProtocolToLuaType(lua,reply);
    sdsfree(reply);

    /* 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++)
        decrRefCount(c->argv[j]);
    zfree(c->argv);

    return 1;
}

void scriptingInit(void) {
    lua_State *lua = lua_open();
    luaL_openlibs(lua);

    /* Register the 'r' command */
    lua_pushcfunction(lua,luaRedisCommand);
    lua_setglobal(lua,"redis");

    /* Create the (non connected) client that we use to execute Redis commands
     * inside the Lua interpreter */
    server.lua_client = createClient(-1);
    server.lua_client->flags |= REDIS_LUA_CLIENT;

    server.lua = lua;
}

/* Hash the scripit into a SHA1 digest. We use this as Lua function name.
 * Digest should point to a 41 bytes buffer: 40 for SHA1 converted into an
 * hexadecimal number, plus 1 byte for null term. */
void hashScript(char *digest, char *script, size_t len) {
    SHA1_CTX ctx;
    unsigned char hash[20];
    char *cset = "0123456789abcdef";
    int j;

    SHA1Init(&ctx);
    SHA1Update(&ctx,(unsigned char*)script,len);
    SHA1Final(hash,&ctx);

    for (j = 0; j < 20; j++) {
        digest[j*2] = cset[((hash[j]&0xF0)>>4)];
        digest[j*2+1] = cset[(hash[j]&0xF)];
    }
    digest[40] = '\0';
}

void luaReplyToRedisReply(redisClient *c, lua_State *lua) {
    int t = lua_type(lua,1);

    switch(t) {
    case LUA_TSTRING:
        addReplyBulkCBuffer(c,(char*)lua_tostring(lua,1),lua_strlen(lua,1));
        break;
    case LUA_TBOOLEAN:
        addReply(c,lua_toboolean(lua,1) ? shared.cone : shared.czero);
        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 elment table with 'ok' field */
        lua_pushstring(lua,"err");
        lua_gettable(lua,-2);
        t = lua_type(lua,-1);
        if (t == LUA_TSTRING) {
            addReplySds(c,sdscatprintf(sdsempty(),
                    "-%s\r\n",(char*)lua_tostring(lua,-1)));
            lua_pop(lua,2);
            return;
        }

        lua_pop(lua,1);
        lua_pushstring(lua,"ok");
        lua_gettable(lua,-2);
        t = lua_type(lua,-1);
        if (t == LUA_TSTRING) {
            addReplySds(c,sdscatprintf(sdsempty(),
                    "+%s\r\n",(char*)lua_tostring(lua,-1)));
            lua_pop(lua,1);
        } else {
            void *replylen = addDeferredMultiBulkLength(c);
            int j = 1, mbulklen = 0;

            lua_pop(lua,1); /* Discard the 'ok' field value we popped */
            while(1) {
                lua_pushnumber(lua,j++);
                lua_gettable(lua,-2);
                t = lua_type(lua,-1);
                if (t == LUA_TNIL) {
                    lua_pop(lua,1);
                    break;
                } else if (t == LUA_TSTRING) {
                    size_t len;
                    char *s = (char*) lua_tolstring(lua,-1,&len);

                    addReplyBulkCBuffer(c,s,len);
                    mbulklen++;
                } else if (t == LUA_TNUMBER) {
                    addReplyLongLong(c,(long long)lua_tonumber(lua,-1));
                    mbulklen++;
                }
                lua_pop(lua,1);
            }
            setDeferredMultiBulkLength(c,replylen,mbulklen);
        }
        break;
    default:
        addReply(c,shared.nullbulk);
    }
    lua_pop(lua,1);
}

/* Set an array of Redis String Objects as a Lua array (table) stored into a
 * global variable. */
void luaSetGlobalArray(lua_State *lua, char *var, robj **elev, int elec) {
    int j;

    lua_newtable(lua);
    for (j = 0; j < elec; j++) {
        lua_pushlstring(lua,(char*)elev[j]->ptr,sdslen(elev[j]->ptr));
        lua_rawseti(lua,-2,j+1);
    }
    lua_setglobal(lua,var);
}

void evalCommand(redisClient *c) {
    lua_State *lua = server.lua;
    char funcname[43];
    long long numkeys;

    /* Get the number of arguments that are keys */
    if (getLongLongFromObjectOrReply(c,c->argv[2],&numkeys,NULL) != REDIS_OK)
        return;
    if (numkeys > (c->argc - 3)) {
        addReplyError(c,"Number of keys can't be greater than number of args");
        return;
    }

    /* We obtain the script SHA1, then check if this function is already
     * defined into the Lua state */
    funcname[0] = 'f';
    funcname[1] = '_';
    hashScript(funcname+2,c->argv[1]->ptr,sdslen(c->argv[1]->ptr));
    lua_getglobal(lua, funcname);
    if (lua_isnil(lua,1)) {
        /* Function not defined... let's define it. */
        sds funcdef = sdsempty();

        lua_pop(lua,1); /* remove the nil from the stack */
        funcdef = sdscat(funcdef,"function ");
        funcdef = sdscatlen(funcdef,funcname,42);
        funcdef = sdscatlen(funcdef," ()\n",4);
        funcdef = sdscatlen(funcdef,c->argv[1]->ptr,sdslen(c->argv[1]->ptr));
        funcdef = sdscatlen(funcdef,"\nend\n",5);
        /* printf("Defining:\n%s\n",funcdef); */

        if (luaL_loadbuffer(lua,funcdef,sdslen(funcdef),"func definition")) {
            addReplyErrorFormat(c,"Error compiling script (new function): %s\n",
                lua_tostring(lua,-1));
            lua_pop(lua,1);
            sdsfree(funcdef);
            return;
        }
        sdsfree(funcdef);
        if (lua_pcall(lua,0,0,0)) {
            addReplyErrorFormat(c,"Error running script (new function): %s\n",
                lua_tostring(lua,-1));
            lua_pop(lua,1);
            return;
        }
        lua_getglobal(lua, funcname);
    }

    /* Populate the argv and keys table accordingly to the arguments that
     * EVAL received. */
    luaSetGlobalArray(lua,"KEYS",c->argv+3,numkeys);
    luaSetGlobalArray(lua,"ARGV",c->argv+3+numkeys,c->argc-3-numkeys);

    /* Select the right DB in the context of the Lua client */
    selectDb(server.lua_client,c->db->id);
    
    /* At this point whatever this script was never seen before or if it was
     * already defined, we can call it. We have zero arguments and expect
     * a single return value. */
    if (lua_pcall(lua,0,1,0)) {
        selectDb(c,server.lua_client->db->id); /* set DB ID from Lua client */
        addReplyErrorFormat(c,"Error running script (call to %s): %s\n",
            funcname, lua_tostring(lua,-1));
        lua_pop(lua,1);
        lua_gc(lua,LUA_GCCOLLECT,0);
        return;
    }
    selectDb(c,server.lua_client->db->id); /* set DB ID from Lua client */
    luaReplyToRedisReply(c,lua);
    lua_gc(lua,LUA_GCSTEP,1);
}
Commit	Line	Data
7585836e	1	#include "redis.h"
	2	#include "sha1.h"
	3
	4	#include <lua.h>
	5	#include <lauxlib.h>
	6	#include <lualib.h>
	7
532e0f5d	8	char redisProtocolToLuaType_Int(lua_State lua, char *reply);
	9	char redisProtocolToLuaType_Bulk(lua_State lua, char *reply);
	10	char redisProtocolToLuaType_Status(lua_State lua, char *reply);
3791000f	11	char redisProtocolToLuaType_Error(lua_State lua, char *reply);
3791000f	12	char redisProtocolToLuaType_MultiBulk(lua_State lua, char *reply);
532e0f5d	13
	14	/* Take a Redis reply in the Redis protocol format and convert it into a
	15	* Lua type. Thanks to this function, and the introduction of not connected
	16	* clients, it is trvial to implement the redis() lua function.
	17	*
	18	* Basically we take the arguments, execute the Redis command in the context
	19	* of a non connected client, then take the generated reply and convert it
	20	* into a suitable Lua type. With this trick the scripting feature does not
	21	* need the introduction of a full Redis internals API. Basically the script
	22	* is like a normal client that bypasses all the slow I/O paths.
	23	*
	24	* Note: in this function we do not do any sanity check as the reply is
	25	* generated by Redis directly. This allows use to go faster.
	26	* The reply string can be altered during the parsing as it is discared
	27	* after the conversion is completed.
	28	*
	29	* Errors are returned as a table with a single 'err' field set to the
	30	* error string.
	31	*/
	32
	33	char redisProtocolToLuaType(lua_State lua, char* reply) {
	34	char *p = reply;
	35
	36	switch(*p) {
	37	case ':':
	38	p = redisProtocolToLuaType_Int(lua,reply);
	39	break;
	40	case '$':
	41	p = redisProtocolToLuaType_Bulk(lua,reply);
	42	break;
	43	case '+':
	44	p = redisProtocolToLuaType_Status(lua,reply);
	45	break;
3791000f	46	case '-':
	47	p = redisProtocolToLuaType_Error(lua,reply);
	48	break;
	49	case '*':
	50	p = redisProtocolToLuaType_MultiBulk(lua,reply);
	51	break;
532e0f5d	52	}
	53	return p;
	54	}
	55
	56	char redisProtocolToLuaType_Int(lua_State lua, char *reply) {
	57	char *p = strchr(reply+1,'\r');
	58	long long value;
	59
	60	string2ll(reply+1,p-reply-1,&value);
	61	lua_pushnumber(lua,(lua_Number)value);
	62	return p+2;
	63	}
	64
	65	char redisProtocolToLuaType_Bulk(lua_State lua, char *reply) {
	66	char *p = strchr(reply+1,'\r');
	67	long long bulklen;
	68
	69	string2ll(reply+1,p-reply-1,&bulklen);
379789cc	70	if (bulklen == -1) {
532e0f5d	71	lua_pushnil(lua);
	72	return p+2;
	73	} else {
	74	lua_pushlstring(lua,p+2,bulklen);
	75	return p+2+bulklen+2;
	76	}
	77	}
	78
	79	char redisProtocolToLuaType_Status(lua_State lua, char *reply) {
	80	char *p = strchr(reply+1,'\r');
	81
0d916763	82	lua_newtable(lua);
0d916763	83	lua_pushstring(lua,"ok");
532e0f5d	84	lua_pushlstring(lua,reply+1,p-reply-1);
0d916763	85	lua_settable(lua,-3);
532e0f5d	86	return p+2;
	87	}
	88
3791000f	89	char redisProtocolToLuaType_Error(lua_State lua, char *reply) {
	90	char *p = strchr(reply+1,'\r');
	91
	92	lua_newtable(lua);
	93	lua_pushstring(lua,"err");
	94	lua_pushlstring(lua,reply+1,p-reply-1);
	95	lua_settable(lua,-3);
	96	return p+2;
	97	}
	98
	99	char redisProtocolToLuaType_MultiBulk(lua_State lua, char *reply) {
	100	char *p = strchr(reply+1,'\r');
	101	long long mbulklen;
	102	int j = 0;
	103
3791000f	104	string2ll(reply+1,p-reply-1,&mbulklen);
	105	p += 2;
	106	if (mbulklen == -1) {
	107	lua_pushnil(lua);
	108	return p;
	109	}
3791000f	110	lua_newtable(lua);
3791000f	111	for (j = 0; j < mbulklen; j++) {
10a6da7a	112	lua_pushnumber(lua,j+1);
3791000f	113	p = redisProtocolToLuaType(lua,p);
	114	lua_settable(lua,-3);
	115	}
	116	return p;
	117	}
	118
379789cc	119	void luaPushError(lua_State lua, char error) {
	120	lua_newtable(lua);
	121	lua_pushstring(lua,"err");
	122	lua_pushstring(lua, error);
	123	lua_settable(lua,-3);
	124	}
	125
0f1d64ca	126	int luaRedisCommand(lua_State *lua) {
	127	int j, argc = lua_gettop(lua);
	128	struct redisCommand *cmd;
	129	robj **argv;
	130	redisClient *c = server.lua_client;
	131	sds reply;
	132
532e0f5d	133	/* Build the arguments vector */
0f1d64ca	134	argv = zmalloc(sizeof(robj)argc);
379789cc	135	for (j = 0; j < argc; j++) {
379789cc	136	if (!lua_isstring(lua,j+1)) break;
532e0f5d	137	argv[j] = createStringObject((char*)lua_tostring(lua,j+1),
532e0f5d	138	lua_strlen(lua,j+1));
379789cc	139	}
	140
	141	/* Check if one of the arguments passed by the Lua script
	142	* is not a string or an integer (lua_isstring() return true for
	143	* integers as well). */
	144	if (j != argc) {
	145	j--;
	146	while (j >= 0) {
	147	decrRefCount(argv[j]);
	148	j--;
	149	}
	150	zfree(argv);
	151	luaPushError(lua,
	152	"Lua redis() command arguments must be strings or integers");
	153	return 1;
	154	}
0f1d64ca	155
	156	/* Command lookup */
	157	cmd = lookupCommand(argv[0]->ptr);
3791000f	158	if (!cmd \|\| ((cmd->arity > 0 && cmd->arity != argc) \|\|
	159	(argc < -cmd->arity)))
	160	{
532e0f5d	161	for (j = 0; j < argc; j++) decrRefCount(argv[j]);
0f1d64ca	162	zfree(argv);
3791000f	163	if (cmd)
379789cc	164	luaPushError(lua,
3791000f	165	"Wrong number of args calling Redis command From Lua script");
3791000f	166	else
379789cc	167	luaPushError(lua,"Unknown Redis command called from Lua script");
532e0f5d	168	return 1;
0f1d64ca	169	}
532e0f5d	170
0f1d64ca	171	/* Run the command in the context of a fake client */
	172	c->argv = argv;
	173	c->argc = argc;
	174	cmd->proc(c);
	175
	176	/* Convert the result of the Redis command into a suitable Lua type.
	177	* The first thing we need is to create a single string from the client
	178	* output buffers. */
	179	reply = sdsempty();
	180	if (c->bufpos) {
7156f43c	181	reply = sdscatlen(reply,c->buf,c->bufpos);
0f1d64ca	182	c->bufpos = 0;
	183	}
	184	while(listLength(c->reply)) {
	185	robj *o = listNodeValue(listFirst(c->reply));
	186
09ab5591	187	reply = sdscatlen(reply,o->ptr,sdslen(o->ptr));
0f1d64ca	188	listDelNode(c->reply,listFirst(c->reply));
0f1d64ca	189	}
532e0f5d	190	redisProtocolToLuaType(lua,reply);
7156f43c	191	sdsfree(reply);
0f1d64ca	192
	193	/* Clean up. Command code may have changed argv/argc so we use the
	194	* argv/argc of the client instead of the local variables. */
	195	for (j = 0; j < c->argc; j++)
	196	decrRefCount(c->argv[j]);
	197	zfree(c->argv);
	198
	199	return 1;
	200	}
	201
7585836e	202	void scriptingInit(void) {
	203	lua_State *lua = lua_open();
	204	luaL_openlibs(lua);
0f1d64ca	205
	206	/* Register the 'r' command */
	207	lua_pushcfunction(lua,luaRedisCommand);
00b7541b	208	lua_setglobal(lua,"redis");
0f1d64ca	209
	210	/* Create the (non connected) client that we use to execute Redis commands
	211	* inside the Lua interpreter */
	212	server.lua_client = createClient(-1);
7156f43c	213	server.lua_client->flags \|= REDIS_LUA_CLIENT;
0f1d64ca	214
7585836e	215	server.lua = lua;
	216	}
	217
	218	/* Hash the scripit into a SHA1 digest. We use this as Lua function name.
	219	* Digest should point to a 41 bytes buffer: 40 for SHA1 converted into an
	220	* hexadecimal number, plus 1 byte for null term. */
	221	void hashScript(char digest, char script, size_t len) {
	222	SHA1_CTX ctx;
	223	unsigned char hash[20];
	224	char *cset = "0123456789abcdef";
	225	int j;
	226
	227	SHA1Init(&ctx);
	228	SHA1Update(&ctx,(unsigned char*)script,len);
	229	SHA1Final(hash,&ctx);
	230
	231	for (j = 0; j < 20; j++) {
	232	digest[j*2] = cset[((hash[j]&0xF0)>>4)];
	233	digest[j*2+1] = cset[(hash[j]&0xF)];
	234	}
	235	digest[40] = '\0';
	236	}
	237
	238	void luaReplyToRedisReply(redisClient c, lua_State lua) {
	239	int t = lua_type(lua,1);
	240
	241	switch(t) {
	242	case LUA_TSTRING:
	243	addReplyBulkCBuffer(c,(char*)lua_tostring(lua,1),lua_strlen(lua,1));
	244	break;
	245	case LUA_TBOOLEAN:
	246	addReply(c,lua_toboolean(lua,1) ? shared.cone : shared.czero);
	247	break;
	248	case LUA_TNUMBER:
	249	addReplyLongLong(c,(long long)lua_tonumber(lua,1));
	250	break;
532e0f5d	251	case LUA_TTABLE:
0d916763	252	/* We need to check if it is an array, an error, or a status reply.
	253	* Error are returned as a single element table with 'err' field.
	254	* Status replies are returned as single elment table with 'ok' field */
532e0f5d	255	lua_pushstring(lua,"err");
	256	lua_gettable(lua,-2);
	257	t = lua_type(lua,-1);
	258	if (t == LUA_TSTRING) {
3791000f	259	addReplySds(c,sdscatprintf(sdsempty(),
3791000f	260	"-%s\r\n",(char*)lua_tostring(lua,-1)));
0d916763	261	lua_pop(lua,2);
	262	return;
	263	}
	264
	265	lua_pop(lua,1);
	266	lua_pushstring(lua,"ok");
	267	lua_gettable(lua,-2);
	268	t = lua_type(lua,-1);
	269	if (t == LUA_TSTRING) {
	270	addReplySds(c,sdscatprintf(sdsempty(),
	271	"+%s\r\n",(char*)lua_tostring(lua,-1)));
532e0f5d	272	lua_pop(lua,1);
	273	} else {
	274	void *replylen = addDeferredMultiBulkLength(c);
	275	int j = 1, mbulklen = 0;
	276
0d916763	277	lua_pop(lua,1); /* Discard the 'ok' field value we popped */
532e0f5d	278	while(1) {
	279	lua_pushnumber(lua,j++);
	280	lua_gettable(lua,-2);
	281	t = lua_type(lua,-1);
	282	if (t == LUA_TNIL) {
	283	lua_pop(lua,1);
	284	break;
	285	} else if (t == LUA_TSTRING) {
	286	size_t len;
	287	char s = (char) lua_tolstring(lua,-1,&len);
	288
	289	addReplyBulkCBuffer(c,s,len);
	290	mbulklen++;
	291	} else if (t == LUA_TNUMBER) {
	292	addReplyLongLong(c,(long long)lua_tonumber(lua,-1));
	293	mbulklen++;
	294	}
	295	lua_pop(lua,1);
	296	}
	297	setDeferredMultiBulkLength(c,replylen,mbulklen);
	298	}
	299	break;
7585836e	300	default:
	301	addReply(c,shared.nullbulk);
	302	}
	303	lua_pop(lua,1);
	304	}
	305
4ae5b5e1	306	/* Set an array of Redis String Objects as a Lua array (table) stored into a
	307	* global variable. */
	308	void luaSetGlobalArray(lua_State lua, char var, robj **elev, int elec) {
	309	int j;
	310
	311	lua_newtable(lua);
	312	for (j = 0; j < elec; j++) {
	313	lua_pushlstring(lua,(char*)elev[j]->ptr,sdslen(elev[j]->ptr));
	314	lua_rawseti(lua,-2,j+1);
	315	}
	316	lua_setglobal(lua,var);
	317	}
	318
7585836e	319	void evalCommand(redisClient *c) {
	320	lua_State *lua = server.lua;
	321	char funcname[43];
4ae5b5e1	322	long long numkeys;
	323
	324	/* Get the number of arguments that are keys */
	325	if (getLongLongFromObjectOrReply(c,c->argv[2],&numkeys,NULL) != REDIS_OK)
	326	return;
	327	if (numkeys > (c->argc - 3)) {
	328	addReplyError(c,"Number of keys can't be greater than number of args");
	329	return;
	330	}
7585836e	331
	332	/* We obtain the script SHA1, then check if this function is already
	333	* defined into the Lua state */
	334	funcname[0] = 'f';
	335	funcname[1] = '_';
	336	hashScript(funcname+2,c->argv[1]->ptr,sdslen(c->argv[1]->ptr));
	337	lua_getglobal(lua, funcname);
	338	if (lua_isnil(lua,1)) {
	339	/* Function not defined... let's define it. */
	340	sds funcdef = sdsempty();
	341
	342	lua_pop(lua,1); /* remove the nil from the stack */
	343	funcdef = sdscat(funcdef,"function ");
	344	funcdef = sdscatlen(funcdef,funcname,42);
	345	funcdef = sdscatlen(funcdef," ()\n",4);
	346	funcdef = sdscatlen(funcdef,c->argv[1]->ptr,sdslen(c->argv[1]->ptr));
	347	funcdef = sdscatlen(funcdef,"\nend\n",5);
379789cc	348	/* printf("Defining:\n%s\n",funcdef); */
7585836e	349
	350	if (luaL_loadbuffer(lua,funcdef,sdslen(funcdef),"func definition")) {
	351	addReplyErrorFormat(c,"Error compiling script (new function): %s\n",
	352	lua_tostring(lua,-1));
	353	lua_pop(lua,1);
7156f43c	354	sdsfree(funcdef);
7585836e	355	return;
7585836e	356	}
7156f43c	357	sdsfree(funcdef);
7585836e	358	if (lua_pcall(lua,0,0,0)) {
	359	addReplyErrorFormat(c,"Error running script (new function): %s\n",
	360	lua_tostring(lua,-1));
	361	lua_pop(lua,1);
	362	return;
	363	}
	364	lua_getglobal(lua, funcname);
	365	}
4ae5b5e1	366
	367	/* Populate the argv and keys table accordingly to the arguments that
	368	* EVAL received. */
	369	luaSetGlobalArray(lua,"KEYS",c->argv+3,numkeys);
	370	luaSetGlobalArray(lua,"ARGV",c->argv+3+numkeys,c->argc-3-numkeys);
c2a7dd85	371
	372	/* Select the right DB in the context of the Lua client */
	373	selectDb(server.lua_client,c->db->id);
7585836e	374
	375	/* At this point whatever this script was never seen before or if it was
	376	* already defined, we can call it. We have zero arguments and expect
	377	* a single return value. */
	378	if (lua_pcall(lua,0,1,0)) {
c2a7dd85	379	selectDb(c,server.lua_client->db->id); /* set DB ID from Lua client */
7585836e	380	addReplyErrorFormat(c,"Error running script (call to %s): %s\n",
	381	funcname, lua_tostring(lua,-1));
	382	lua_pop(lua,1);
40531be0	383	lua_gc(lua,LUA_GCCOLLECT,0);
7585836e	384	return;
7585836e	385	}
c2a7dd85	386	selectDb(c,server.lua_client->db->id); /* set DB ID from Lua client */
7585836e	387	luaReplyToRedisReply(c,lua);
40531be0	388	lua_gc(lua,LUA_GCSTEP,1);
7585836e	389	}