#include "server.h"

#include "cluster.h"

#include <dlfcn.h>

#define REDISMODULE_CORE 1

#include "redismodule.h"

struct RedisModule {

};

typedef struct RedisModule RedisModule;

static dict *modules; /* Hash table of modules. SDS -> RedisModule ptr.*/

struct AutoMemEntry {

void *ptr;

int type;

};

#define REDISMODULE_AM_KEY 0

#define REDISMODULE_AM_STRING 1

#define REDISMODULE_AM_REPLY 2

#define REDISMODULE_AM_FREED 3 /* Explicitly freed by user already. */

#define REDISMODULE_POOL_ALLOC_MIN_SIZE (1024*8)

#define REDISMODULE_POOL_ALLOC_ALIGN (sizeof(void*))

typedef struct RedisModulePoolAllocBlock {

} RedisModulePoolAllocBlock;

struct RedisModuleBlockedClient;

struct RedisModuleCtx {

};

typedef struct RedisModuleCtx RedisModuleCtx;

#define REDISMODULE_CTX_INIT {(void*)(unsigned long)&RM_GetApi, NULL, NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL, NULL, 0, NULL}

#define REDISMODULE_CTX_MULTI_EMITTED (1<<0)

#define REDISMODULE_CTX_AUTO_MEMORY (1<<1)

#define REDISMODULE_CTX_KEYS_POS_REQUEST (1<<2)

#define REDISMODULE_CTX_BLOCKED_REPLY (1<<3)

#define REDISMODULE_CTX_BLOCKED_TIMEOUT (1<<4)

#define REDISMODULE_CTX_THREAD_SAFE (1<<5)

#define REDISMODULE_CTX_BLOCKED_DISCONNECTED (1<<6)

struct RedisModuleKey {

};

typedef struct RedisModuleKey RedisModuleKey;

#define REDISMODULE_ZSET_RANGE_NONE 0 /* This must always be 0. */

#define REDISMODULE_ZSET_RANGE_LEX 1

#define REDISMODULE_ZSET_RANGE_SCORE 2

#define REDISMODULE_ZSET_RANGE_POS 3

struct RedisModuleBlockedClient;

typedef int (*RedisModuleCmdFunc) (RedisModuleCtx *ctx, void **argv, int argc);

typedef void (*RedisModuleDisconnectFunc) (RedisModuleCtx *ctx, struct RedisModuleBlockedClient *bc);

struct RedisModuleCommandProxy {

};

typedef struct RedisModuleCommandProxy RedisModuleCommandProxy;

#define REDISMODULE_REPLYFLAG_NONE 0

#define REDISMODULE_REPLYFLAG_TOPARSE (1<<0) /* Protocol must be parsed. */

#define REDISMODULE_REPLYFLAG_NESTED (1<<1) /* Nested reply object. No proto

typedef struct RedisModuleCallReply {

} RedisModuleCallReply;

typedef struct RedisModuleBlockedClient {

} RedisModuleBlockedClient;

static pthread_mutex_t moduleUnblockedClientsMutex = PTHREAD_MUTEX_INITIALIZER;

static list *moduleUnblockedClients;

static pthread_mutex_t moduleGIL = PTHREAD_MUTEX_INITIALIZER;

typedef int (*RedisModuleNotificationFunc) (RedisModuleCtx *ctx, int type, const char *event, RedisModuleString *key);

typedef struct RedisModuleKeyspaceSubscriber {

} RedisModuleKeyspaceSubscriber;

static list *moduleKeyspaceSubscribers;

static client *moduleKeyspaceSubscribersClient;

void RM_FreeCallReply(RedisModuleCallReply *reply);

void RM_CloseKey(RedisModuleKey *key);

void autoMemoryCollect(RedisModuleCtx *ctx);

robj **moduleCreateArgvFromUserFormat(const char *cmdname, const char *fmt, int *argcp, int *flags, va_list ap);

void moduleReplicateMultiIfNeeded(RedisModuleCtx *ctx);

void RM_ZsetRangeStop(RedisModuleKey *kp);

static void zsetKeyReset(RedisModuleKey *key);

void *RM_Alloc(size_t bytes) {

return zmalloc(bytes);

}

void *RM_Calloc(size_t nmemb, size_t size) {

return zcalloc(nmemb*size);

}

void* RM_Realloc(void *ptr, size_t bytes) {

return zrealloc(ptr,bytes);

}

void RM_Free(void *ptr) {

zfree(ptr);

}

char *RM_Strdup(const char *str) {

return zstrdup(str);

}

void poolAllocRelease(RedisModuleCtx *ctx) {

RedisModulePoolAllocBlock *head = ctx->pa_head, *next;

while(head != NULL) {

next = head->next;

zfree(head);

head = next;

}

ctx->pa_head = NULL;

}

void *RM_PoolAlloc(RedisModuleCtx *ctx, size_t bytes) {

if (bytes == 0) return NULL;

RedisModulePoolAllocBlock *b = ctx->pa_head;

size_t left = b ? b->size - b->used : 0;

/* Fix alignment. */

if (left >= bytes) {

size_t alignment = REDISMODULE_POOL_ALLOC_ALIGN;

while (bytes < alignment && alignment/2 >= bytes) alignment /= 2;

if (b->used % alignment)

b->used += alignment - (b->used % alignment);

left = (b->used > b->size) ? 0 : b->size - b->used;

}

/* Create a new block if needed. */

if (left < bytes) {

size_t blocksize = REDISMODULE_POOL_ALLOC_MIN_SIZE;

if (blocksize < bytes) blocksize = bytes;

b = zmalloc(sizeof(*b) + blocksize);

b->size = blocksize;

b->used = 0;

b->next = ctx->pa_head;

ctx->pa_head = b;

}

char *retval = b->memory + b->used;

b->used += bytes;

return retval;

}

int moduleCreateEmptyKey(RedisModuleKey *key, int type) {

robj *obj;

/* The key must be open for writing and non existing to proceed. */

if (!(key->mode & REDISMODULE_WRITE) || key->value)

return REDISMODULE_ERR;

switch(type) {

case REDISMODULE_KEYTYPE_LIST:

obj = createQuicklistObject();

quicklistSetOptions(obj->ptr, server.list_max_ziplist_size,

server.list_compress_depth);

break;

case REDISMODULE_KEYTYPE_ZSET:

obj = createZsetZiplistObject();

break;

case REDISMODULE_KEYTYPE_HASH:

obj = createHashObject();

break;

default: return REDISMODULE_ERR;

}

dbAdd(key->db,key->key,obj);

key->value = obj;

return REDISMODULE_OK;

}

int moduleDelKeyIfEmpty(RedisModuleKey *key) {

if (!(key->mode & REDISMODULE_WRITE) || key->value == NULL) return 0;

int isempty;

robj *o = key->value;

switch(o->type) {

case OBJ_LIST: isempty = listTypeLength(o) == 0; break;

case OBJ_SET: isempty = setTypeSize(o) == 0; break;

case OBJ_ZSET: isempty = zsetLength(o) == 0; break;

case OBJ_HASH : isempty = hashTypeLength(o) == 0; break;

default: isempty = 0;

}

if (isempty) {

dbDelete(key->db,key->key);

key->value = NULL;

return 1;

} else {

return 0;

}

}

int RM_GetApi(const char *funcname, void **targetPtrPtr) {

dictEntry *he = dictFind(server.moduleapi, funcname);

if (!he) return REDISMODULE_ERR;

*targetPtrPtr = dictGetVal(he);

return REDISMODULE_OK;

}

void moduleFreeContext(RedisModuleCtx *ctx) {

autoMemoryCollect(ctx);

poolAllocRelease(ctx);

if (ctx->postponed_arrays) {

zfree(ctx->postponed_arrays);

ctx->postponed_arrays_count = 0;

serverLog(LL_WARNING,

"API misuse detected in module %s: "

"RedisModule_ReplyWithArray(REDISMODULE_POSTPONED_ARRAY_LEN) "

"not matched by the same number of RedisModule_SetReplyArrayLen() "

"calls.",

ctx->module->name);

}

if (ctx->flags & REDISMODULE_CTX_THREAD_SAFE) freeClient(ctx->client);

}

void moduleHandlePropagationAfterCommandCallback(RedisModuleCtx *ctx) {

client *c = ctx->client;

if (c->flags & CLIENT_LUA) return;

/* Handle the replication of the final EXEC, since whatever a command

if (ctx->flags & REDISMODULE_CTX_MULTI_EMITTED) {

robj *propargv[1];

propargv[0] = createStringObject("EXEC",4);

alsoPropagate(server.execCommand,c->db->id,propargv,1,

PROPAGATE_AOF|PROPAGATE_REPL);

decrRefCount(propargv[0]);

}

}

void RedisModuleCommandDispatcher(client *c) {

RedisModuleCommandProxy *cp = (void*)(unsigned long)c->cmd->getkeys_proc;

RedisModuleCtx ctx = REDISMODULE_CTX_INIT;

ctx.module = cp->module;

ctx.client = c;

cp->func(&ctx,(void**)c->argv,c->argc);

moduleHandlePropagationAfterCommandCallback(&ctx);

moduleFreeContext(&ctx);

}

int *moduleGetCommandKeysViaAPI(struct redisCommand *cmd, robj **argv, int argc, int *numkeys) {

RedisModuleCommandProxy *cp = (void*)(unsigned long)cmd->getkeys_proc;

RedisModuleCtx ctx = REDISMODULE_CTX_INIT;

ctx.module = cp->module;

ctx.client = NULL;

ctx.flags |= REDISMODULE_CTX_KEYS_POS_REQUEST;

cp->func(&ctx,(void**)argv,argc);

int *res = ctx.keys_pos;

if (numkeys) *numkeys = ctx.keys_count;

moduleFreeContext(&ctx);

return res;

}

int RM_IsKeysPositionRequest(RedisModuleCtx *ctx) {

return (ctx->flags & REDISMODULE_CTX_KEYS_POS_REQUEST) != 0;

}

void RM_KeyAtPos(RedisModuleCtx *ctx, int pos) {

if (!(ctx->flags & REDISMODULE_CTX_KEYS_POS_REQUEST)) return;

if (pos <= 0) return;

ctx->keys_pos = zrealloc(ctx->keys_pos,sizeof(int)*(ctx->keys_count+1));

ctx->keys_pos[ctx->keys_count++] = pos;

}

int commandFlagsFromString(char *s) {

int count, j;

int flags = 0;

sds *tokens = sdssplitlen(s,strlen(s)," ",1,&count);

for (j = 0; j < count; j++) {

char *t = tokens[j];

if (!strcasecmp(t,"write")) flags |= CMD_WRITE;

else if (!strcasecmp(t,"readonly")) flags |= CMD_READONLY;

else if (!strcasecmp(t,"admin")) flags |= CMD_ADMIN;

else if (!strcasecmp(t,"deny-oom")) flags |= CMD_DENYOOM;

else if (!strcasecmp(t,"deny-script")) flags |= CMD_NOSCRIPT;

else if (!strcasecmp(t,"allow-loading")) flags |= CMD_LOADING;

else if (!strcasecmp(t,"pubsub")) flags |= CMD_PUBSUB;

else if (!strcasecmp(t,"random")) flags |= CMD_RANDOM;

else if (!strcasecmp(t,"allow-stale")) flags |= CMD_STALE;

else if (!strcasecmp(t,"no-monitor")) flags |= CMD_SKIP_MONITOR;

else if (!strcasecmp(t,"fast")) flags |= CMD_FAST;

else if (!strcasecmp(t,"getkeys-api")) flags |= CMD_MODULE_GETKEYS;

else if (!strcasecmp(t,"no-cluster")) flags |= CMD_MODULE_NO_CLUSTER;

else break;

}

sdsfreesplitres(tokens,count);

if (j != count) return -1; /* Some token not processed correctly. */

return flags;

}

int RM_CreateCommand(RedisModuleCtx *ctx, const char *name, RedisModuleCmdFunc cmdfunc, const char *strflags, int firstkey, int lastkey, int keystep) {

int flags = strflags ? commandFlagsFromString((char*)strflags) : 0;

if (flags == -1) return REDISMODULE_ERR;

if ((flags & CMD_MODULE_NO_CLUSTER) && server.cluster_enabled)

return REDISMODULE_ERR;

struct redisCommand *rediscmd;

RedisModuleCommandProxy *cp;

sds cmdname = sdsnew(name);

/* Check if the command name is busy. */

if (lookupCommand(cmdname) != NULL) {

sdsfree(cmdname);

return REDISMODULE_ERR;

}

/* Create a command "proxy", which is a structure that is referenced

cp = zmalloc(sizeof(*cp));

cp->module = ctx->module;

cp->func = cmdfunc;

cp->rediscmd = zmalloc(sizeof(*rediscmd));

cp->rediscmd->name = cmdname;

cp->rediscmd->proc = RedisModuleCommandDispatcher;

cp->rediscmd->arity = -1;

cp->rediscmd->flags = flags | CMD_MODULE;

cp->rediscmd->getkeys_proc = (redisGetKeysProc*)(unsigned long)cp;

cp->rediscmd->firstkey = firstkey;

cp->rediscmd->lastkey = lastkey;

cp->rediscmd->keystep = keystep;

cp->rediscmd->microseconds = 0;

cp->rediscmd->calls = 0;

dictAdd(server.commands,sdsdup(cmdname),cp->rediscmd);

dictAdd(server.orig_commands,sdsdup(cmdname),cp->rediscmd);

return REDISMODULE_OK;

}

void RM_SetModuleAttribs(RedisModuleCtx *ctx, const char *name, int ver, int apiver) {

RedisModule *module;

if (ctx->module != NULL) return;

module = zmalloc(sizeof(*module));

module->name = sdsnew((char*)name);

module->ver = ver;

module->apiver = apiver;

module->types = listCreate();

ctx->module = module;

}

int RM_IsModuleNameBusy(const char *name) {

sds modulename = sdsnew(name);

dictEntry *de = dictFind(modules,modulename);

sdsfree(modulename);

return de != NULL;

}

long long RM_Milliseconds(void) {

return mstime();

}

void RM_AutoMemory(RedisModuleCtx *ctx) {

ctx->flags |= REDISMODULE_CTX_AUTO_MEMORY;

}

void autoMemoryAdd(RedisModuleCtx *ctx, int type, void *ptr) {

if (!(ctx->flags & REDISMODULE_CTX_AUTO_MEMORY)) return;

if (ctx->amqueue_used == ctx->amqueue_len) {

ctx->amqueue_len *= 2;

if (ctx->amqueue_len < 16) ctx->amqueue_len = 16;

ctx->amqueue = zrealloc(ctx->amqueue,sizeof(struct AutoMemEntry)*ctx->amqueue_len);

}

ctx->amqueue[ctx->amqueue_used].type = type;

ctx->amqueue[ctx->amqueue_used].ptr = ptr;

ctx->amqueue_used++;

}

int autoMemoryFreed(RedisModuleCtx *ctx, int type, void *ptr) {

if (!(ctx->flags & REDISMODULE_CTX_AUTO_MEMORY)) return 0;

int count = (ctx->amqueue_used+1)/2;

for (int j = 0; j < count; j++) {

for (int side = 0; side < 2; side++) {

/* For side = 0 check right side of the array, for

int i = (side == 0) ? (ctx->amqueue_used - 1 - j) : j;

if (ctx->amqueue[i].type == type &&

ctx->amqueue[i].ptr == ptr)

{

ctx->amqueue[i].type = REDISMODULE_AM_FREED;

/* Switch the freed element and the last element, to avoid growing

if (i != ctx->amqueue_used-1) {

ctx->amqueue[i] = ctx->amqueue[ctx->amqueue_used-1];

}

/* Reduce the size of the queue because we either moved the top

ctx->amqueue_used--;

return 1;

}

}

}

return 0;

}

void autoMemoryCollect(RedisModuleCtx *ctx) {

if (!(ctx->flags & REDISMODULE_CTX_AUTO_MEMORY)) return;

/* Clear the AUTO_MEMORY flag from the context, otherwise the functions

ctx->flags &= ~REDISMODULE_CTX_AUTO_MEMORY;

int j;

for (j = 0; j < ctx->amqueue_used; j++) {

void *ptr = ctx->amqueue[j].ptr;

switch(ctx->amqueue[j].type) {

case REDISMODULE_AM_STRING: decrRefCount(ptr); break;

case REDISMODULE_AM_REPLY: RM_FreeCallReply(ptr); break;

case REDISMODULE_AM_KEY: RM_CloseKey(ptr); break;

}

}

ctx->flags |= REDISMODULE_CTX_AUTO_MEMORY;

zfree(ctx->amqueue);

ctx->amqueue = NULL;

ctx->amqueue_len = 0;

ctx->amqueue_used = 0;

}

RedisModuleString *RM_CreateString(RedisModuleCtx *ctx, const char *ptr, size_t len) {

RedisModuleString *o = createStringObject(ptr,len);

autoMemoryAdd(ctx,REDISMODULE_AM_STRING,o);

return o;

}

RedisModuleString *RM_CreateStringPrintf(RedisModuleCtx *ctx, const char *fmt, ...) {

sds s = sdsempty();

va_list ap;

va_start(ap, fmt);

s = sdscatvprintf(s, fmt, ap);

va_end(ap);

RedisModuleString *o = createObject(OBJ_STRING, s);

autoMemoryAdd(ctx,REDISMODULE_AM_STRING,o);

return o;

}

RedisModuleString *RM_CreateStringFromLongLong(RedisModuleCtx *ctx, long long ll) {

char buf[LONG_STR_SIZE];

size_t len = ll2string(buf,sizeof(buf),ll);

return RM_CreateString(ctx,buf,len);

}

RedisModuleString *RM_CreateStringFromString(RedisModuleCtx *ctx, const RedisModuleString *str) {

RedisModuleString *o = dupStringObject(str);

autoMemoryAdd(ctx,REDISMODULE_AM_STRING,o);

return o;

}

void RM_FreeString(RedisModuleCtx *ctx, RedisModuleString *str) {

decrRefCount(str);

autoMemoryFreed(ctx,REDISMODULE_AM_STRING,str);

}

void RM_RetainString(RedisModuleCtx *ctx, RedisModuleString *str) {

if (!autoMemoryFreed(ctx,REDISMODULE_AM_STRING,str)) {

/* Increment the string reference counting only if we can't

incrRefCount(str);

}

}

const char *RM_StringPtrLen(const RedisModuleString *str, size_t *len) {

if (str == NULL) {

const char *errmsg = "(NULL string reply referenced in module)";

if (len) *len = strlen(errmsg);

return errmsg;

}

if (len) *len = sdslen(str->ptr);

return str->ptr;

}

int RM_StringToLongLong(const RedisModuleString *str, long long *ll) {

return string2ll(str->ptr,sdslen(str->ptr),ll) ? REDISMODULE_OK :

REDISMODULE_ERR;

}

int RM_StringToDouble(const RedisModuleString *str, double *d) {

int retval = getDoubleFromObject(str,d);

return (retval == C_OK) ? REDISMODULE_OK : REDISMODULE_ERR;

}

int RM_StringCompare(RedisModuleString *a, RedisModuleString *b) {

return compareStringObjects(a,b);

}

RedisModuleString *moduleAssertUnsharedString(RedisModuleString *str) {

if (str->refcount != 1) {

serverLog(LL_WARNING,

"Module attempted to use an in-place string modify operation "

"with a string referenced multiple times. Please check the code "

"for API usage correctness.");

return NULL;

}

if (str->encoding == OBJ_ENCODING_EMBSTR) {

/* Note: here we "leak" the additional allocation that was

str->ptr = sdsnewlen(str->ptr,sdslen(str->ptr));

str->encoding = OBJ_ENCODING_RAW;

} else if (str->encoding == OBJ_ENCODING_INT) {

/* Convert the string from integer to raw encoding. */

str->ptr = sdsfromlonglong((long)str->ptr);

str->encoding = OBJ_ENCODING_RAW;

}

return str;

}

int RM_StringAppendBuffer(RedisModuleCtx *ctx, RedisModuleString *str, const char *buf, size_t len) {

UNUSED(ctx);

str = moduleAssertUnsharedString(str);

if (str == NULL) return REDISMODULE_ERR;

str->ptr = sdscatlen(str->ptr,buf,len);

return REDISMODULE_OK;

}

int RM_WrongArity(RedisModuleCtx *ctx) {

addReplyErrorFormat(ctx->client,

"wrong number of arguments for '%s' command",

(char*)ctx->client->argv[0]->ptr);

return REDISMODULE_OK;

}