/*

* Copyright (c) 2006-2009, Salvatore Sanfilippo <antirez at gmail dot com>

* 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.

*/

#define REDIS_VERSION "0.101"

#include "fmacros.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <unistd.h>

#define __USE_POSIX199309

#include <signal.h>

#include <execinfo.h>

#include <ucontext.h>

#include <sys/wait.h>

#include <errno.h>

#include <assert.h>

#include <ctype.h>

#include <stdarg.h>

#include <inttypes.h>

#include <arpa/inet.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <sys/time.h>

#include <sys/resource.h>

#include <limits.h>

#include <execinfo.h>

#include "redis.h"

#include "ae.h" /* Event driven programming library */

#include "sds.h" /* Dynamic safe strings */

#include "anet.h" /* Networking the easy way */

#include "dict.h" /* Hash tables */

#include "adlist.h" /* Linked lists */

#include "adRRlist.h" /* Round Robin lists */

#include "zmalloc.h" /* total memory usage aware version of malloc/free */

#include "lzf.h" /* LZF compression library */

#include "pqsort.h" /* Partial qsort for SORT+LIMIT */

#include "config.h"

/* Error codes */

#define REDIS_OK 0

#define REDIS_ERR -1

/* Static server configuration */

#define REDIS_SERVERPORT 6379 /* TCP port */

#define REDIS_MAXIDLETIME (60*5) /* default client timeout */

#define REDIS_IOBUF_LEN 1024

#define REDIS_LOADBUF_LEN 1024

#define REDIS_STATIC_ARGS 4

#define REDIS_DEFAULT_DBNUM 16

#define REDIS_CONFIGLINE_MAX 1024

#define REDIS_OBJFREELIST_MAX 1000000 /* Max number of objects to cache */

#define REDIS_MAX_SYNC_TIME 60 /* Slave can't take more to sync */

#define REDIS_EXPIRELOOKUPS_PER_CRON 100 /* try to expire 100 keys/second */

#define REDIS_MAX_WRITE_PER_EVENT (1024*64)

/* Hash table parameters */

#define REDIS_HT_MINFILL 10 /* Minimal hash table fill 10% */

/* Command flags */

#define REDIS_CMD_BULK 1 /* Bulk write command */

#define REDIS_CMD_INLINE 2 /* Inline command */

/* REDIS_CMD_DENYOOM reserves a longer comment: all the commands marked with

this flags will return an error when the 'maxmemory' option is set in the

config file and the server is using more than maxmemory bytes of memory.

In short this commands are denied on low memory conditions. */

#define REDIS_CMD_DENYOOM 4

/* Object types */

#define REDIS_STRING 0

#define REDIS_LIST 1

#define REDIS_SET 2

#define REDIS_HASH 3

#define REDIS_RRS 4

/* Object types only used for dumping to disk */

#define REDIS_EXPIRETIME 253

#define REDIS_SELECTDB 254

#define REDIS_EOF 255

/* Defines related to the dump file format. To store 32 bits lengths for short

* keys requires a lot of space, so we check the most significant 2 bits of

* the first byte to interpreter the length:

*

* 00|000000 => if the two MSB are 00 the len is the 6 bits of this byte

* 01|000000 00000000 => 01, the len is 14 byes, 6 bits + 8 bits of next byte

* 10|000000 [32 bit integer] => if it's 01, a full 32 bit len will follow

* 11|000000 this means: specially encoded object will follow. The six bits

* number specify the kind of object that follows.

* See the REDIS_RDB_ENC_* defines.

*

* Lenghts up to 63 are stored using a single byte, most DB keys, and may

* values, will fit inside. */

#define REDIS_RDB_6BITLEN 0

#define REDIS_RDB_14BITLEN 1

#define REDIS_RDB_32BITLEN 2

#define REDIS_RDB_ENCVAL 3

#define REDIS_RDB_LENERR UINT_MAX

/* When a length of a string object stored on disk has the first two bits

* set, the remaining two bits specify a special encoding for the object

* accordingly to the following defines: */

#define REDIS_RDB_ENC_INT8 0 /* 8 bit signed integer */

#define REDIS_RDB_ENC_INT16 1 /* 16 bit signed integer */

#define REDIS_RDB_ENC_INT32 2 /* 32 bit signed integer */

#define REDIS_RDB_ENC_LZF 3 /* string compressed with FASTLZ */

/* Client flags */

#define REDIS_CLOSE 1 /* This client connection should be closed ASAP */

#define REDIS_SLAVE 2 /* This client is a slave server */

#define REDIS_MASTER 4 /* This client is a master server */

#define REDIS_MONITOR 8 /* This client is a slave monitor, see MONITOR */

/* Slave replication state - slave side */

#define REDIS_REPL_NONE 0 /* No active replication */

#define REDIS_REPL_CONNECT 1 /* Must connect to master */

#define REDIS_REPL_CONNECTED 2 /* Connected to master */

/* Slave replication state - from the point of view of master

* Note that in SEND_BULK and ONLINE state the slave receives new updates

* in its output queue. In the WAIT_BGSAVE state instead the server is waiting

* to start the next background saving in order to send updates to it. */

#define REDIS_REPL_WAIT_BGSAVE_START 3 /* master waits bgsave to start feeding it */

#define REDIS_REPL_WAIT_BGSAVE_END 4 /* master waits bgsave to start bulk DB transmission */

#define REDIS_REPL_SEND_BULK 5 /* master is sending the bulk DB */

#define REDIS_REPL_ONLINE 6 /* bulk DB already transmitted, receive updates */

/* List related stuff */

#define REDIS_HEAD 0

#define REDIS_TAIL 1

/* Sort operations */

#define REDIS_SORT_GET 0

#define REDIS_SORT_DEL 1

#define REDIS_SORT_INCR 2

#define REDIS_SORT_DECR 3

#define REDIS_SORT_ASC 4

#define REDIS_SORT_DESC 5

#define REDIS_SORTKEY_MAX 1024

/* Log levels */

#define REDIS_DEBUG 0

#define REDIS_NOTICE 1

#define REDIS_WARNING 2

/* Anti-warning macro... */

#define REDIS_NOTUSED(V) ((void) V)

/*================================= Data types ============================== */

/* A redis object, that is a type able to hold a string / list / set */

typedef struct redisObject {

void *ptr;

int type;

int refcount;

} robj;

typedef struct redisDb {

dict *dict;

dict *expires;

int id;

} redisDb;

/* With multiplexing we need to take per-clinet state.

* Clients are taken in a liked list. */

typedef struct redisClient {

int fd;

redisDb *db;

int dictid;

sds querybuf;

robj **argv;

int argc;

int bulklen; /* bulk read len. -1 if not in bulk read mode */

list *reply;

int sentlen;

time_t lastinteraction; /* time of the last interaction, used for timeout */

int flags; /* REDIS_CLOSE | REDIS_SLAVE | REDIS_MONITOR */

int slaveseldb; /* slave selected db, if this client is a slave */

int authenticated; /* when requirepass is non-NULL */

int replstate; /* replication state if this is a slave */

int repldbfd; /* replication DB file descriptor */

long repldboff; /* replication DB file offset */

off_t repldbsize; /* replication DB file size */

} redisClient;

struct saveparam {

time_t seconds;

int changes;

};

/* Global server state structure */

struct redisServer {

int port;

int fd;

redisDb *db;

dict *sharingpool;

unsigned int sharingpoolsize;

long long dirty; /* changes to DB from the last save */

list *clients;

list *slaves, *monitors;

char neterr[ANET_ERR_LEN];

aeEventLoop *el;

int cronloops; /* number of times the cron function run */

list *objfreelist; /* A list of freed objects to avoid malloc() */

time_t lastsave; /* Unix time of last save succeeede */

size_t usedmemory; /* Used memory in megabytes */

/* Fields used only for stats */

time_t stat_starttime; /* server start time */

long long stat_numcommands; /* number of processed commands */

long long stat_numconnections; /* number of connections received */

/* Configuration */

int verbosity;

int glueoutputbuf;

int maxidletime;

int dbnum;

int daemonize;

char *pidfile;

int bgsaveinprogress;

pid_t bgsavechildpid;

struct saveparam *saveparams;

int saveparamslen;

char *logfile;

char *bindaddr;

char *dbfilename;

char *requirepass;

int shareobjects;

/* Replication related */

int isslave;

char *masterhost;

int masterport;

redisClient *master; /* client that is master for this slave */

int replstate;

unsigned int maxclients;

unsigned int maxmemory;

/* Sort parameters - qsort_r() is only available under BSD so we

* have to take this state global, in order to pass it to sortCompare() */

int sort_desc;

int sort_alpha;

int sort_bypattern;

};

typedef void redisCommandProc(redisClient *c);

struct redisCommand {

char *name;

redisCommandProc *proc;

int arity;

int flags;

};

struct redisFunctionSym {

char *name;

unsigned long pointer;

};

typedef struct _redisSortObject {

robj *obj;

union {

double score;

robj *cmpobj;

} u;

} redisSortObject;

typedef struct _redisSortOperation {

int type;

robj *pattern;

} redisSortOperation;

struct sharedObjectsStruct {

robj *crlf, *ok, *err, *emptybulk, *czero, *cone, *pong, *space,

*colon, *nullbulk, *nullmultibulk,

*emptymultibulk, *wrongtypeerr, *nokeyerr, *syntaxerr, *sameobjecterr,

*outofrangeerr, *plus,

*select0, *select1, *select2, *select3, *select4,

*select5, *select6, *select7, *select8, *select9,

*keyexists;

} shared;

/*================================ Prototypes =============================== */

static void freeStringObject(robj *o);

static void freeListObject(robj *o);

static void freeRRSObject(robj *o);

static void freeSetObject(robj *o);

static void decrRefCount(void *o);

static robj *createObject(int type, void *ptr);

static void freeClient(redisClient *c);

static int rdbLoad(char *filename);

static void addReply(redisClient *c, robj *obj);

static void addReplySds(redisClient *c, sds s);

static void incrRefCount(robj *o);

static int rdbSaveBackground(char *filename);

static robj *createStringObject(char *ptr, size_t len);

static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int dictid, robj **argv, int argc);

static int syncWithMaster(void);

static robj *tryObjectSharing(robj *o);

static int removeExpire(redisDb *db, robj *key);

static int expireIfNeeded(redisDb *db, robj *key);

static int deleteIfVolatile(redisDb *db, robj *key);

static int deleteKey(redisDb *db, robj *key);

static time_t getExpire(redisDb *db, robj *key);

static int setExpire(redisDb *db, robj *key, time_t when);

static void updateSalvesWaitingBgsave(int bgsaveerr);

static void freeMemoryIfNeeded(void);

static int processCommand(redisClient *c);

static void setupSigSegvAction(void);

static void authCommand(redisClient *c);

static void pingCommand(redisClient *c);

static void echoCommand(redisClient *c);

static void setCommand(redisClient *c);

static void setnxCommand(redisClient *c);

static void getCommand(redisClient *c);

static void delCommand(redisClient *c);

static void existsCommand(redisClient *c);

static void incrCommand(redisClient *c);

static void decrCommand(redisClient *c);

static void incrbyCommand(redisClient *c);

static void decrbyCommand(redisClient *c);

static void selectCommand(redisClient *c);

static void randomkeyCommand(redisClient *c);

static void keysCommand(redisClient *c);

static void dbsizeCommand(redisClient *c);

static void lastsaveCommand(redisClient *c);

static void saveCommand(redisClient *c);

static void bgsaveCommand(redisClient *c);

static void shutdownCommand(redisClient *c);

static void moveCommand(redisClient *c);

static void renameCommand(redisClient *c);

static void renamenxCommand(redisClient *c);

static void lpushCommand(redisClient *c);

static void rpushCommand(redisClient *c);

static void lpopCommand(redisClient *c);

static void rpopCommand(redisClient *c);

static void llenCommand(redisClient *c);

static void lindexCommand(redisClient *c);

static void lrangeCommand(redisClient *c);

static void ltrimCommand(redisClient *c);

static void typeCommand(redisClient *c);

static void lsetCommand(redisClient *c);

static void saddCommand(redisClient *c);

static void sremCommand(redisClient *c);

static void smoveCommand(redisClient *c);

static void sismemberCommand(redisClient *c);

static void scardCommand(redisClient *c);

static void spopCommand(redisClient *c);

static void sinterCommand(redisClient *c);

static void sinterstoreCommand(redisClient *c);

static void sunionCommand(redisClient *c);

static void sunionstoreCommand(redisClient *c);

static void sdiffCommand(redisClient *c);

static void sdiffstoreCommand(redisClient *c);

static void syncCommand(redisClient *c);

static void flushdbCommand(redisClient *c);

static void flushallCommand(redisClient *c);

static void sortCommand(redisClient *c);

static void lremCommand(redisClient *c);

static void infoCommand(redisClient *c);

static void mgetCommand(redisClient *c);

static void monitorCommand(redisClient *c);

static void expireCommand(redisClient *c);

static void getSetCommand(redisClient *c);

static void ttlCommand(redisClient *c);

static void slaveofCommand(redisClient *c);

static void rrsCreateCommand(redisClient *c);

static void rrsAddCommand(redisClient *c);

static void rrsGetCommand(redisClient *c);

static void rrsListCommand(redisClient *c);

static void debugCommand(redisClient *c);

/*================================= Globals ================================= */

/* Global vars */

static struct redisServer server; /* server global state */

static struct redisCommand cmdTable[] = {

{"get",getCommand,2,REDIS_CMD_INLINE},

{"set",setCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM},

{"setnx",setnxCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM},

{"del",delCommand,-2,REDIS_CMD_INLINE},

{"exists",existsCommand,2,REDIS_CMD_INLINE},

{"incr",incrCommand,2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM},

{"decr",decrCommand,2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM},

{"mget",mgetCommand,-2,REDIS_CMD_INLINE},

{"rpush",rpushCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM},

{"lpush",lpushCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM},

{"rpop",rpopCommand,2,REDIS_CMD_INLINE},

{"lpop",lpopCommand,2,REDIS_CMD_INLINE},

{"llen",llenCommand,2,REDIS_CMD_INLINE},

{"lindex",lindexCommand,3,REDIS_CMD_INLINE},

{"lset",lsetCommand,4,REDIS_CMD_BULK|REDIS_CMD_DENYOOM},

{"lrange",lrangeCommand,4,REDIS_CMD_INLINE},

{"ltrim",ltrimCommand,4,REDIS_CMD_INLINE},

{"lrem",lremCommand,4,REDIS_CMD_BULK},

{"sadd",saddCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM},

{"srem",sremCommand,3,REDIS_CMD_BULK},

{"smove",smoveCommand,4,REDIS_CMD_BULK},

{"sismember",sismemberCommand,3,REDIS_CMD_BULK},

{"scard",scardCommand,2,REDIS_CMD_INLINE},

{"spop",spopCommand,2,REDIS_CMD_INLINE},

{"sinter",sinterCommand,-2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM},

{"sinterstore",sinterstoreCommand,-3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM},

{"sunion",sunionCommand,-2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM},

{"sunionstore",sunionstoreCommand,-3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM},

{"sdiff",sdiffCommand,-2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM},

{"sdiffstore",sdiffstoreCommand,-3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM},

{"smembers",sinterCommand,2,REDIS_CMD_INLINE},

{"incrby",incrbyCommand,3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM},

{"decrby",decrbyCommand,3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM},

{"getset",getSetCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM},

{"randomkey",randomkeyCommand,1,REDIS_CMD_INLINE},

{"select",selectCommand,2,REDIS_CMD_INLINE},

{"move",moveCommand,3,REDIS_CMD_INLINE},

{"rename",renameCommand,3,REDIS_CMD_INLINE},

{"renamenx",renamenxCommand,3,REDIS_CMD_INLINE},

{"expire",expireCommand,3,REDIS_CMD_INLINE},

{"keys",keysCommand,2,REDIS_CMD_INLINE},

{"dbsize",dbsizeCommand,1,REDIS_CMD_INLINE},

{"auth",authCommand,2,REDIS_CMD_INLINE},

{"ping",pingCommand,1,REDIS_CMD_INLINE},

{"echo",echoCommand,2,REDIS_CMD_BULK},

{"save",saveCommand,1,REDIS_CMD_INLINE},

{"bgsave",bgsaveCommand,1,REDIS_CMD_INLINE},

{"shutdown",shutdownCommand,1,REDIS_CMD_INLINE},

{"lastsave",lastsaveCommand,1,REDIS_CMD_INLINE},

{"type",typeCommand,2,REDIS_CMD_INLINE},

{"sync",syncCommand,1,REDIS_CMD_INLINE},

{"flushdb",flushdbCommand,1,REDIS_CMD_INLINE},

{"flushall",flushallCommand,1,REDIS_CMD_INLINE},

{"sort",sortCommand,-2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM},

{"info",infoCommand,1,REDIS_CMD_INLINE},

{"monitor",monitorCommand,1,REDIS_CMD_INLINE},

{"ttl",ttlCommand,2,REDIS_CMD_INLINE},

{"slaveof",slaveofCommand,3,REDIS_CMD_INLINE},

{"debug",debugCommand,-2,REDIS_CMD_INLINE},

{"rrscreate",rrsCreateCommand,4,REDIS_CMD_INLINE},

{"rrsadd",rrsAddCommand,3,REDIS_CMD_INLINE},

{"rrsget",rrsGetCommand,3,REDIS_CMD_INLINE},

{"rrslist",rrsListCommand,4,REDIS_CMD_INLINE},

/*

{"rrdcreate",rrdCreateCommand,4,REDIS_CMD_INLINE},

{"rrdadd",rrdAddCommand,3,REDIS_CMD_INLINE},

{"rrdget",rrdGetCommand,3,REDIS_CMD_INLINE},

{"rrdlist",rrdListCommand,4,REDIS_CMD_INLINE},

*/

{NULL,NULL,0,0}

};

/*============================ Utility functions ============================ */

/* Glob-style pattern matching. */

int stringmatchlen(const char *pattern, int patternLen,

const char *string, int stringLen, int nocase)

{

while(patternLen) {

switch(pattern[0]) {

case '*':

while (pattern[1] == '*') {

pattern++;

patternLen--;

}

if (patternLen == 1)

return 1; /* match */

while(stringLen) {

if (stringmatchlen(pattern+1, patternLen-1,

string, stringLen, nocase))

return 1; /* match */

string++;

stringLen--;

}

return 0; /* no match */

break;

case '?':

if (stringLen == 0)

return 0; /* no match */

string++;

stringLen--;

break;

case '[':

{

int not, match;

pattern++;

patternLen--;

not = pattern[0] == '^';

if (not) {

pattern++;

patternLen--;

}

match = 0;

while(1) {

if (pattern[0] == '\\') {

pattern++;

patternLen--;

if (pattern[0] == string[0])

match = 1;

} else if (pattern[0] == ']') {

break;

} else if (patternLen == 0) {

pattern--;

patternLen++;

break;

} else if (pattern[1] == '-' && patternLen >= 3) {

int start = pattern[0];

int end = pattern[2];

int c = string[0];

if (start > end) {

int t = start;

start = end;

end = t;

}

if (nocase) {

start = tolower(start);

end = tolower(end);

c = tolower(c);

}

pattern += 2;

patternLen -= 2;

if (c >= start && c <= end)

match = 1;

} else {

if (!nocase) {

if (pattern[0] == string[0])

match = 1;

} else {

if (tolower((int)pattern[0]) == tolower((int)string[0]))

match = 1;

}

}

pattern++;

patternLen--;

}

if (not)

match = !match;

if (!match)

return 0; /* no match */

string++;

stringLen--;

break;

}

case '\\':

if (patternLen >= 2) {

pattern++;

patternLen--;

}

/* fall through */

default:

if (!nocase) {

if (pattern[0] != string[0])

return 0; /* no match */

} else {

if (tolower((int)pattern[0]) != tolower((int)string[0]))

return 0; /* no match */

}

string++;

stringLen--;

break;

}

pattern++;

patternLen--;

if (stringLen == 0) {

while(*pattern == '*') {

pattern++;

patternLen--;

}

break;

}

}

if (patternLen == 0 && stringLen == 0)

return 1;

return 0;

}

static void redisLog(int level, const char *fmt, ...) {

va_list ap;

FILE *fp;

fp = (server.logfile == NULL) ? stdout : fopen(server.logfile,"a");

if (!fp) return;

va_start(ap, fmt);

if (level >= server.verbosity) {

char *c = ".-*";

char buf[64];

time_t now;

now = time(NULL);

strftime(buf,64,"%d %b %H:%M:%S",gmtime(&now));

fprintf(fp,"%s %c ",buf,c[level]);

vfprintf(fp, fmt, ap);

fprintf(fp,"\n");

fflush(fp);

}

va_end(ap);

if (server.logfile) fclose(fp);

}

/*====================== Hash table type implementation ==================== */

/* This is an hash table type that uses the SDS dynamic strings libary as

* keys and radis objects as values (objects can hold SDS strings,

* lists, sets). */

static int sdsDictKeyCompare(void *privdata, const void *key1,

const void *key2)

{

int l1,l2;

DICT_NOTUSED(privdata);

l1 = sdslen((sds)key1);

l2 = sdslen((sds)key2);

if (l1 != l2) return 0;

return memcmp(key1, key2, l1) == 0;

}

static void dictRedisObjectDestructor(void *privdata, void *val)

{

DICT_NOTUSED(privdata);

decrRefCount(val);

}

static int dictSdsKeyCompare(void *privdata, const void *key1,

const void *key2)

{

const robj *o1 = key1, *o2 = key2;

return sdsDictKeyCompare(privdata,o1->ptr,o2->ptr);

}

static unsigned int dictSdsHash(const void *key) {

const robj *o = key;

return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));

}

static dictType setDictType = {

dictSdsHash, /* hash function */

NULL, /* key dup */

NULL, /* val dup */

dictSdsKeyCompare, /* key compare */

dictRedisObjectDestructor, /* key destructor */

NULL /* val destructor */

};

static dictType hashDictType = {

dictSdsHash, /* hash function */

NULL, /* key dup */

NULL, /* val dup */

dictSdsKeyCompare, /* key compare */

dictRedisObjectDestructor, /* key destructor */

dictRedisObjectDestructor /* val destructor */

};

/* ========================= Random utility functions ======================= */

/* Redis generally does not try to recover from out of memory conditions

* when allocating objects or strings, it is not clear if it will be possible

* to report this condition to the client since the networking layer itself

* is based on heap allocation for send buffers, so we simply abort.

* At least the code will be simpler to read... */

static void oom(const char *msg) {

fprintf(stderr, "%s: Out of memory\n",msg);

fflush(stderr);

sleep(1);

abort();

}

/* ====================== Redis server networking stuff ===================== */

static void closeTimedoutClients(void) {

redisClient *c;

listNode *ln;

time_t now = time(NULL);

listRewind(server.clients);

while ((ln = listYield(server.clients)) != NULL) {

c = listNodeValue(ln);

if (!(c->flags & REDIS_SLAVE) && /* no timeout for slaves */

!(c->flags & REDIS_MASTER) && /* no timeout for masters */

(now - c->lastinteraction > server.maxidletime)) {

redisLog(REDIS_DEBUG,"Closing idle client");

freeClient(c);

}

}

}

static int htNeedsResize(dict *dict) {

long long size, used;

size = dictSlots(dict);

used = dictSize(dict);

return (size && used && size > DICT_HT_INITIAL_SIZE &&

(used*100/size < REDIS_HT_MINFILL));

}

/* If the percentage of used slots in the HT reaches REDIS_HT_MINFILL

* we resize the hash table to save memory */

static void tryResizeHashTables(void) {

int j;

for (j = 0; j < server.dbnum; j++) {

if (htNeedsResize(server.db[j].dict)) {

redisLog(REDIS_DEBUG,"The hash table %d is too sparse, resize it...",j);

dictResize(server.db[j].dict);

redisLog(REDIS_DEBUG,"Hash table %d resized.",j);

}

if (htNeedsResize(server.db[j].expires))

dictResize(server.db[j].expires);

}

}

static int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {

int j, loops = server.cronloops++;

REDIS_NOTUSED(eventLoop);

REDIS_NOTUSED(id);

REDIS_NOTUSED(clientData);

/* Update the global state with the amount of used memory */

server.usedmemory = zmalloc_used_memory();

/* Show some info about non-empty databases */

for (j = 0; j < server.dbnum; j++) {

long long size, used, vkeys;

size = dictSlots(server.db[j].dict);

used = dictSize(server.db[j].dict);

vkeys = dictSize(server.db[j].expires);

if (!(loops % 5) && used > 0) {

redisLog(REDIS_DEBUG,"DB %d: %d keys (%d volatile) in %d slots HT.",j,used,vkeys,size);

/* dictPrintStats(server.dict); */

}

}

/* We don't want to resize the hash tables while a bacground saving

* is in progress: the saving child is created using fork() that is

* implemented with a copy-on-write semantic in most modern systems, so

* if we resize the HT while there is the saving child at work actually

* a lot of memory movements in the parent will cause a lot of pages

* copied. */

if (!server.bgsaveinprogress) tryResizeHashTables();

/* Show information about connected clients */

if (!(loops % 5)) {

redisLog(REDIS_DEBUG,"%d clients connected (%d slaves), %zu bytes in use",

listLength(server.clients)-listLength(server.slaves),

listLength(server.slaves),

server.usedmemory,

dictSize(server.sharingpool));

}

/* Close connections of timedout clients */

if (server.maxidletime && !(loops % 10))

closeTimedoutClients();

/* Check if a background saving in progress terminated */

if (server.bgsaveinprogress) {

int statloc;

/* XXX: TODO handle the case of the saving child killed */

if (wait4(-1,&statloc,WNOHANG,NULL)) {

int exitcode = WEXITSTATUS(statloc);

int bysignal = WIFSIGNALED(statloc);

if (!bysignal && exitcode == 0) {

redisLog(REDIS_NOTICE,

"Background saving terminated with success");

server.dirty = 0;

server.lastsave = time(NULL);

} else if (!bysignal && exitcode != 0) {

redisLog(REDIS_WARNING, "Background saving error");

} else {

redisLog(REDIS_WARNING,

"Background saving terminated by signal");

}

server.bgsaveinprogress = 0;

server.bgsavechildpid = -1;

updateSalvesWaitingBgsave(exitcode == 0 ? REDIS_OK : REDIS_ERR);

}

} else {

/* If there is not a background saving in progress check if

* we have to save now */

time_t now = time(NULL);

for (j = 0; j < server.saveparamslen; j++) {

struct saveparam *sp = server.saveparams+j;

if (server.dirty >= sp->changes &&

now-server.lastsave > sp->seconds) {

redisLog(REDIS_NOTICE,"%d changes in %d seconds. Saving...",

sp->changes, sp->seconds);

rdbSaveBackground(server.dbfilename);

break;

}

}

}

/* Try to expire a few timed out keys */

for (j = 0; j < server.dbnum; j++) {

redisDb *db = server.db+j;

int num = dictSize(db->expires);

if (num) {

time_t now = time(NULL);

if (num > REDIS_EXPIRELOOKUPS_PER_CRON)

num = REDIS_EXPIRELOOKUPS_PER_CRON;

while (num--) {

dictEntry *de;

time_t t;

if ((de = dictGetRandomKey(db->expires)) == NULL) break;

t = (time_t) dictGetEntryVal(de);

if (now > t) {

deleteKey(db,dictGetEntryKey(de));

}

}

}

}

/* Check if we should connect to a MASTER */

if (server.replstate == REDIS_REPL_CONNECT) {

redisLog(REDIS_NOTICE,"Connecting to MASTER...");

if (syncWithMaster() == REDIS_OK) {

redisLog(REDIS_NOTICE,"MASTER <-> SLAVE sync succeeded");

}

}

return 1000;

}

static void createSharedObjects(void) {

shared.crlf = createObject(REDIS_STRING,sdsnew("\r\n"));

shared.ok = createObject(REDIS_STRING,sdsnew("+OK\r\n"));

shared.err = createObject(REDIS_STRING,sdsnew("-ERR\r\n"));

shared.emptybulk = createObject(REDIS_STRING,sdsnew("$0\r\n\r\n"));

shared.czero = createObject(REDIS_STRING,sdsnew(":0\r\n"));

shared.cone = createObject(REDIS_STRING,sdsnew(":1\r\n"));

shared.nullbulk = createObject(REDIS_STRING,sdsnew("$-1\r\n"));

shared.nullmultibulk = createObject(REDIS_STRING,sdsnew("*-1\r\n"));

shared.emptymultibulk = createObject(REDIS_STRING,sdsnew("*0\r\n"));

/* no such key */

shared.pong = createObject(REDIS_STRING,sdsnew("+PONG\r\n"));

shared.wrongtypeerr = createObject(REDIS_STRING,sdsnew(

"-ERR Operation against a key holding the wrong kind of value\r\n"));

shared.nokeyerr = createObject(REDIS_STRING,sdsnew(

"-ERR no such key\r\n"));

shared.syntaxerr = createObject(REDIS_STRING,sdsnew(

"-ERR syntax error\r\n"));

shared.sameobjecterr = createObject(REDIS_STRING,sdsnew(

"-ERR source and destination objects are the same\r\n"));

shared.outofrangeerr = createObject(REDIS_STRING,sdsnew(

"-ERR index out of range\r\n"));

shared.keyexists = createObject(REDIS_STRING,sdsnew(

"-ERR key already exists\r\n"));

shared.space = createObject(REDIS_STRING,sdsnew(" "));

shared.colon = createObject(REDIS_STRING,sdsnew(":"));

shared.plus = createObject(REDIS_STRING,sdsnew("+"));

shared.select0 = createStringObject("select 0\r\n",10);

shared.select1 = createStringObject("select 1\r\n",10);

shared.select2 = createStringObject("select 2\r\n",10);

shared.select3 = createStringObject("select 3\r\n",10);

shared.select4 = createStringObject("select 4\r\n",10);

shared.select5 = createStringObject("select 5\r\n",10);

shared.select6 = createStringObject("select 6\r\n",10);

shared.select7 = createStringObject("select 7\r\n",10);

shared.select8 = createStringObject("select 8\r\n",10);

shared.select9 = createStringObject("select 9\r\n",10);

}

static void appendServerSaveParams(time_t seconds, int changes) {

server.saveparams = zrealloc(server.saveparams,sizeof(struct saveparam)*(server.saveparamslen+1));

if (server.saveparams == NULL) oom("appendServerSaveParams");

server.saveparams[server.saveparamslen].seconds = seconds;

server.saveparams[server.saveparamslen].changes = changes;

server.saveparamslen++;

}

static void ResetServerSaveParams() {

zfree(server.saveparams);

server.saveparams = NULL;

server.saveparamslen = 0;

}

static void initServerConfig() {

server.dbnum = REDIS_DEFAULT_DBNUM;

server.port = REDIS_SERVERPORT;

server.verbosity = REDIS_DEBUG;

server.maxidletime = REDIS_MAXIDLETIME;

server.saveparams = NULL;

server.logfile = NULL; /* NULL = log on standard output */

server.bindaddr = NULL;

server.glueoutputbuf = 1;

server.daemonize = 0;

server.pidfile = "/var/run/redis.pid";

server.dbfilename = "dump.rdb";

server.requirepass = NULL;

server.shareobjects = 0;

server.maxclients = 0;

server.maxmemory = 0;

ResetServerSaveParams();

appendServerSaveParams(60*60,1); /* save after 1 hour and 1 change */

appendServerSaveParams(300,100); /* save after 5 minutes and 100 changes */

appendServerSaveParams(60,10000); /* save after 1 minute and 10000 changes */

/* Replication related */

server.isslave = 0;

server.masterhost = NULL;

server.masterport = 6379;

server.master = NULL;

server.replstate = REDIS_REPL_NONE;

}

static void initServer() {

int j;

signal(SIGHUP, SIG_IGN);

signal(SIGPIPE, SIG_IGN);

setupSigSegvAction();

server.clients = listCreate();

server.slaves = listCreate();

server.monitors = listCreate();

server.objfreelist = listCreate();

createSharedObjects();

server.el = aeCreateEventLoop();

server.db = zmalloc(sizeof(redisDb)*server.dbnum);

server.sharingpool = dictCreate(&setDictType,NULL);

server.sharingpoolsize = 1024;

if (!server.db || !server.clients || !server.slaves || !server.monitors || !server.el || !server.objfreelist)

oom("server initialization"); /* Fatal OOM */

server.fd = anetTcpServer(server.neterr, server.port, server.bindaddr);

if (server.fd == -1) {

redisLog(REDIS_WARNING, "Opening TCP port: %s", server.neterr);

exit(1);

}

for (j = 0; j < server.dbnum; j++) {

server.db[j].dict = dictCreate(&hashDictType,NULL);

server.db[j].expires = dictCreate(&setDictType,NULL);

server.db[j].id = j;

}

server.cronloops = 0;

server.bgsaveinprogress = 0;

server.bgsavechildpid = -1;

server.lastsave = time(NULL);

server.dirty = 0;

server.usedmemory = 0;

server.stat_numcommands = 0;

server.stat_numconnections = 0;

server.stat_starttime = time(NULL);

aeCreateTimeEvent(server.el, 1000, serverCron, NULL, NULL);

}

/* Empty the whole database */

static long long emptyDb() {

int j;

long long removed = 0;

for (j = 0; j < server.dbnum; j++) {

removed += dictSize(server.db[j].dict);

dictEmpty(server.db[j].dict);

dictEmpty(server.db[j].expires);

}

return removed;

}

static int yesnotoi(char *s) {

if (!strcasecmp(s,"yes")) return 1;

else if (!strcasecmp(s,"no")) return 0;

else return -1;

}

/* I agree, this is a very rudimental way to load a configuration...

will improve later if the config gets more complex */

static void loadServerConfig(char *filename) {

FILE *fp = fopen(filename,"r");