update-scala-client script added

[redis.git] / redis.c

diff --git a/redis.c b/redis.c
index fa0d6158f4ae173ac313667a9af60bfe2ad3b094..607c827a4cb63d48ff1b342ef7949d6db60d4486 100644 (file)
--- a/redis.c
+++ b/redis.c
@@ -27,14 +27,24 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
  * POSSIBILITY OF SUCH DAMAGE.
  */
 

-#define REDIS_VERSION "0.07"
+#define REDIS_VERSION "0.900"
+
+#include "fmacros.h"
+#include "config.h"

 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>

+#define __USE_POSIX199309

 #include <signal.h>
 #include <signal.h>

+
+#ifdef HAVE_BACKTRACE
+#include <execinfo.h>
+#include <ucontext.h>
+#endif /* HAVE_BACKTRACE */
+

 #include <sys/wait.h>
 #include <errno.h>
 #include <assert.h>
 #include <sys/wait.h>
 #include <errno.h>
 #include <assert.h>


@@ -46,13 +56,17 @@
 #include <fcntl.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <fcntl.h>
 #include <sys/time.h>
 #include <sys/resource.h>

+#include <limits.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 "zmalloc.h" /* total memory usage aware version of malloc/free */
 #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 "zmalloc.h" /* total memory usage aware version of malloc/free */

+#include "lzf.h"    /* LZF compression library */
+#include "pqsort.h" /* Partial qsort for SORT+LIMIT */

 
 /* Error codes */
 #define REDIS_OK                0
 
 /* Error codes */
 #define REDIS_OK                0


@@ -61,40 +75,87 @@
 /* Static server configuration */
 #define REDIS_SERVERPORT        6379    /* TCP port */
 #define REDIS_MAXIDLETIME       (60*5)  /* default client timeout */
 /* Static server configuration */
 #define REDIS_SERVERPORT        6379    /* TCP port */
 #define REDIS_MAXIDLETIME       (60*5)  /* default client timeout */

-#define REDIS_QUERYBUF_LEN      1024
+#define REDIS_IOBUF_LEN         1024

 #define REDIS_LOADBUF_LEN       1024
 #define REDIS_LOADBUF_LEN       1024

-#define REDIS_MAX_ARGS          16
+#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_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)
+#define REDIS_REQUEST_MAX_SIZE  (1024*1024*256) /* max bytes in inline command */

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

-#define REDIS_HT_MINSLOTS       16384   /* Never resize the HT under this */

 
 /* Command flags */
 
 /* Command flags */

-#define REDIS_CMD_BULK          1
-#define REDIS_CMD_INLINE        2
+#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
 
 /* Object types */
 #define REDIS_STRING 0
 #define REDIS_LIST 1
 #define REDIS_SET 2
 #define REDIS_HASH 3

+
+/* Object types only used for dumping to disk */
+#define REDIS_EXPIRETIME 253

 #define REDIS_SELECTDB 254
 #define REDIS_EOF 255
 
 #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 */
 /* 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 */

 
 

-/* Server replication state */
+/* 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 */
 
 #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
 /* List related stuff */
 #define REDIS_HEAD 0
 #define REDIS_TAIL 1


@@ -116,30 +177,42 @@
 /* Anti-warning macro... */
 #define REDIS_NOTUSED(V) ((void) V)
 
 /* 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 {
 /*================================= Data types ============================== */
 
 /* A redis object, that is a type able to hold a string / list / set */
 typedef struct redisObject {

-    int type;

     void *ptr;
     void *ptr;

+    int type;

     int refcount;
 } robj;
 
     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;
 /* With multiplexing we need to take per-clinet state.
  * Clients are taken in a liked list. */
 typedef struct redisClient {
     int fd;

-    dict *dict;
+    redisDb *db;

     int dictid;
     sds querybuf;
     int dictid;
     sds querybuf;

-    robj *argv[REDIS_MAX_ARGS];
+    robj **argv;

     int argc;
     int argc;

-    int bulklen;    /* bulk read len. -1 if not in bulk read mode */
+    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 */
     list *reply;
     int sentlen;
     time_t lastinteraction; /* time of the last interaction, used for timeout */

-    int flags; /* REDIS_CLOSE | REDIS_SLAVE */
-    int slaveseldb; /* slave selected db, if this client is a slave */
+    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 {
 } redisClient;
 
 struct saveparam {


@@ -151,16 +224,18 @@ struct saveparam {
 struct redisServer {
     int port;
     int fd;
 struct redisServer {
     int port;
     int fd;

-    dict **dict;
+    redisDb *db;
+    dict *sharingpool;
+    unsigned int sharingpoolsize;

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

-    list *slaves;
+    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 */
     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 */

-    int usedmemory;             /* Used memory in megabytes */
+    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 */
     /* Fields used only for stats */
     time_t stat_starttime;         /* server start time */
     long long stat_numcommands;    /* number of processed commands */


@@ -173,17 +248,22 @@ struct redisServer {
     int daemonize;
     char *pidfile;
     int bgsaveinprogress;
     int daemonize;
     char *pidfile;
     int bgsaveinprogress;

+    pid_t bgsavechildpid;

     struct saveparam *saveparams;
     int saveparamslen;
     char *logfile;
     char *bindaddr;
     char *dbfilename;
     struct saveparam *saveparams;
     int saveparamslen;
     char *logfile;
     char *bindaddr;
     char *dbfilename;

+    char *requirepass;
+    int shareobjects;

     /* Replication related */
     int isslave;
     char *masterhost;
     int masterport;
     /* Replication related */
     int isslave;
     char *masterhost;
     int masterport;

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

     int replstate;
     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;
     /* 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;


@@ -199,6 +279,11 @@ struct redisCommand {
     int flags;
 };
 
     int flags;
 };
 

+struct redisFunctionSym {
+    char *name;
+    unsigned long pointer;
+};
+

 typedef struct _redisSortObject {
     robj *obj;
     union {
 typedef struct _redisSortObject {
     robj *obj;
     union {


@@ -213,10 +298,10 @@ typedef struct _redisSortOperation {
 } redisSortOperation;
 
 struct sharedObjectsStruct {
 } redisSortOperation;
 
 struct sharedObjectsStruct {

-    robj *crlf, *ok, *err, *zerobulk, *nil, *zero, *one, *pong, *space,
-    *minus1, *minus2, *minus3, *minus4,
-    *wrongtypeerr, *nokeyerr, *wrongtypeerrbulk, *nokeyerrbulk,
-    *syntaxerr, *syntaxerrbulk,
+    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;
 } shared;
     *select0, *select1, *select2, *select3, *select4,
     *select5, *select6, *select7, *select8, *select9;
 } shared;


@@ -229,15 +314,28 @@ static void freeSetObject(robj *o);
 static void decrRefCount(void *o);
 static robj *createObject(int type, void *ptr);
 static void freeClient(redisClient *c);
 static void decrRefCount(void *o);
 static robj *createObject(int type, void *ptr);
 static void freeClient(redisClient *c);

-static int loadDb(char *filename);
+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 void addReply(redisClient *c, robj *obj);
 static void addReplySds(redisClient *c, sds s);
 static void incrRefCount(robj *o);

-static int saveDbBackground(char *filename);
+static int rdbSaveBackground(char *filename);

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

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

 static int syncWithMaster(void);
 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 updateSlavesWaitingBgsave(int bgsaveerr);
+static void freeMemoryIfNeeded(void);
+static int processCommand(redisClient *c);
+static void setupSigSegvAction(void);
+static void rdbRemoveTempFile(pid_t childpid);
+
+static void authCommand(redisClient *c);

 static void pingCommand(redisClient *c);
 static void echoCommand(redisClient *c);
 static void setCommand(redisClient *c);
 static void pingCommand(redisClient *c);
 static void echoCommand(redisClient *c);
 static void setCommand(redisClient *c);


@@ -272,10 +370,16 @@ static void typeCommand(redisClient *c);
 static void lsetCommand(redisClient *c);
 static void saddCommand(redisClient *c);
 static void sremCommand(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 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 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 syncCommand(redisClient *c);
 static void flushdbCommand(redisClient *c);
 static void flushallCommand(redisClient *c);


@@ -283,46 +387,60 @@ static void sortCommand(redisClient *c);
 static void lremCommand(redisClient *c);
 static void infoCommand(redisClient *c);
 static void mgetCommand(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 debugCommand(redisClient *c);

 /*================================= Globals ================================= */
 
 /* Global vars */
 static struct redisServer server; /* server global state */
 static struct redisCommand cmdTable[] = {
     {"get",getCommand,2,REDIS_CMD_INLINE},
 /*================================= 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},
-    {"setnx",setnxCommand,3,REDIS_CMD_BULK},
-    {"del",delCommand,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},
     {"exists",existsCommand,2,REDIS_CMD_INLINE},

-    {"incr",incrCommand,2,REDIS_CMD_INLINE},
-    {"decr",decrCommand,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},
     {"mget",mgetCommand,-2,REDIS_CMD_INLINE},

-    {"rpush",rpushCommand,3,REDIS_CMD_BULK},
-    {"lpush",lpushCommand,3,REDIS_CMD_BULK},
+    {"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},
     {"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},
+    {"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},
     {"lrange",lrangeCommand,4,REDIS_CMD_INLINE},
     {"ltrim",ltrimCommand,4,REDIS_CMD_INLINE},
     {"lrem",lremCommand,4,REDIS_CMD_BULK},

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

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

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

     {"sismember",sismemberCommand,3,REDIS_CMD_BULK},
     {"scard",scardCommand,2,REDIS_CMD_INLINE},
     {"sismember",sismemberCommand,3,REDIS_CMD_BULK},
     {"scard",scardCommand,2,REDIS_CMD_INLINE},

-    {"sinter",sinterCommand,-2,REDIS_CMD_INLINE},
-    {"sinterstore",sinterstoreCommand,-3,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},
     {"smembers",sinterCommand,2,REDIS_CMD_INLINE},

-    {"incrby",incrbyCommand,3,REDIS_CMD_INLINE},
-    {"decrby",decrbyCommand,3,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},
     {"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},
     {"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},
     {"ping",pingCommand,1,REDIS_CMD_INLINE},
     {"echo",echoCommand,2,REDIS_CMD_BULK},
     {"save",saveCommand,1,REDIS_CMD_INLINE},


@@ -333,11 +451,14 @@ static struct redisCommand cmdTable[] = {
     {"sync",syncCommand,1,REDIS_CMD_INLINE},
     {"flushdb",flushdbCommand,1,REDIS_CMD_INLINE},
     {"flushall",flushallCommand,1,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},
+    {"sort",sortCommand,-2,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM},

     {"info",infoCommand,1,REDIS_CMD_INLINE},
     {"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},

     {NULL,NULL,0,0}
 };
     {NULL,NULL,0,0}
 };

-

 /*============================ Utility functions ============================ */
 
 /* Glob-style pattern matching. */
 /*============================ Utility functions ============================ */
 
 /* Glob-style pattern matching. */


@@ -463,8 +584,7 @@ int stringmatchlen(const char *pattern, int patternLen,
     return 0;
 }
 
     return 0;
 }
 

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

     va_list ap;
     FILE *fp;
 
     va_list ap;
     FILE *fp;
 


@@ -474,7 +594,12 @@ void redisLog(int level, const char *fmt, ...)
     va_start(ap, fmt);
     if (level >= server.verbosity) {
         char *c = ".-*";
     va_start(ap, fmt);
     if (level >= server.verbosity) {
         char *c = ".-*";

-        fprintf(fp,"%c ",c[level]);
+        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);
         vfprintf(fp, fmt, ap);
         fprintf(fp,"\n");
         fflush(fp);


@@ -554,27 +679,50 @@ static void oom(const char *msg) {
 }
 
 /* ====================== Redis server networking stuff ===================== */
 }
 
 /* ====================== Redis server networking stuff ===================== */

-void closeTimedoutClients(void) {
+static void closeTimedoutClients(void) {

     redisClient *c;
     redisClient *c;

-    listIter *li;

     listNode *ln;
     time_t now = time(NULL);
 
     listNode *ln;
     time_t now = time(NULL);
 

-    li = listGetIterator(server.clients,AL_START_HEAD);
-    if (!li) return;
-    while ((ln = listNextElement(li)) != NULL) {
+    listRewind(server.clients);
+    while ((ln = listYield(server.clients)) != NULL) {

         c = listNodeValue(ln);
         if (!(c->flags & REDIS_SLAVE) &&    /* no timeout for slaves */
         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);
         }
     }
              (now - c->lastinteraction > server.maxidletime)) {
             redisLog(REDIS_DEBUG,"Closing idle client");
             freeClient(c);
         }
     }

-    listReleaseIterator(li);

 }
 
 }
 

-int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
-    int j, size, used, loops = server.cronloops++;
+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);
     REDIS_NOTUSED(eventLoop);
     REDIS_NOTUSED(id);
     REDIS_NOTUSED(clientData);


@@ -582,33 +730,38 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
     /* Update the global state with the amount of used memory */
     server.usedmemory = zmalloc_used_memory();
 
     /* Update the global state with the amount of used memory */
     server.usedmemory = zmalloc_used_memory();
 

-    /* If the percentage of used slots in the HT reaches REDIS_HT_MINFILL
-     * we resize the hash table to save memory */
+    /* Show some info about non-empty databases */

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

-        size = dictGetHashTableSize(server.dict[j]);
-        used = dictGetHashTableUsed(server.dict[j]);
-        if (!(loops % 5) && used > 0) {
-            redisLog(REDIS_DEBUG,"DB %d: %d keys in %d slots HT.",j,used,size);
-            // dictPrintStats(server.dict);
-        }
-        if (size && used && size > REDIS_HT_MINSLOTS &&
-            (used*100/size < REDIS_HT_MINFILL)) {
-            redisLog(REDIS_NOTICE,"The hash table %d is too sparse, resize it...",j);
-            dictResize(server.dict[j]);
-            redisLog(REDIS_NOTICE,"Hash table %d resized.",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 || vkeys)) {
+            redisLog(REDIS_DEBUG,"DB %d: %lld keys (%lld volatile) in %lld 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)) {
     /* Show information about connected clients */
     if (!(loops % 5)) {

-        redisLog(REDIS_DEBUG,"%d clients connected (%d slaves), %d bytes in use",
+        redisLog(REDIS_DEBUG,"%d clients connected (%d slaves), %zu bytes in use, %d shared objects",

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

-            server.usedmemory);
+            server.usedmemory,
+            dictSize(server.sharingpool));

     }
 
     /* Close connections of timedout clients */
     }
 
     /* Close connections of timedout clients */

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

         closeTimedoutClients();
 
     /* Check if a background saving in progress terminated */
         closeTimedoutClients();
 
     /* Check if a background saving in progress terminated */


@@ -616,16 +769,23 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
         int statloc;
         if (wait4(-1,&statloc,WNOHANG,NULL)) {
             int exitcode = WEXITSTATUS(statloc);
         int statloc;
         if (wait4(-1,&statloc,WNOHANG,NULL)) {
             int exitcode = WEXITSTATUS(statloc);

-            if (exitcode == 0) {
+            int bysignal = WIFSIGNALED(statloc);
+
+            if (!bysignal && exitcode == 0) {

                 redisLog(REDIS_NOTICE,
                     "Background saving terminated with success");
                 server.dirty = 0;
                 server.lastsave = time(NULL);
                 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,
             } else {
                 redisLog(REDIS_WARNING,

-                    "Background saving error");
+                    "Background saving terminated by signal");
+                rdbRemoveTempFile(server.bgsavechildpid);

             }
             server.bgsaveinprogress = 0;
             }
             server.bgsaveinprogress = 0;

+            server.bgsavechildpid = -1;
+            updateSlavesWaitingBgsave(exitcode == 0 ? REDIS_OK : REDIS_ERR);

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


@@ -638,11 +798,35 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
                 now-server.lastsave > sp->seconds) {
                 redisLog(REDIS_NOTICE,"%d changes in %d seconds. Saving...",
                     sp->changes, sp->seconds);
                 now-server.lastsave > sp->seconds) {
                 redisLog(REDIS_NOTICE,"%d changes in %d seconds. Saving...",
                     sp->changes, sp->seconds);

-                saveDbBackground(server.dbfilename);
+                rdbSaveBackground(server.dbfilename);

                 break;
             }
          }
     }
                 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...");
     /* Check if we should connect to a MASTER */
     if (server.replstate == REDIS_REPL_CONNECT) {
         redisLog(REDIS_NOTICE,"Connecting to MASTER...");


@@ -657,29 +841,27 @@ 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.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.zerobulk = createObject(REDIS_STRING,sdsnew("0\r\n\r\n"));
-    shared.nil = createObject(REDIS_STRING,sdsnew("nil\r\n"));
-    shared.zero = createObject(REDIS_STRING,sdsnew("0\r\n"));
-    shared.one = createObject(REDIS_STRING,sdsnew("1\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 */
     /* no such key */

-    shared.minus1 = createObject(REDIS_STRING,sdsnew("-1\r\n"));
-    /* operation against key holding a value of the wrong type */
-    shared.minus2 = createObject(REDIS_STRING,sdsnew("-2\r\n"));
-    /* src and dest objects are the same */
-    shared.minus3 = createObject(REDIS_STRING,sdsnew("-3\r\n"));
-    /* out of range argument */
-    shared.minus4 = createObject(REDIS_STRING,sdsnew("-4\r\n"));

     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.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.wrongtypeerrbulk = createObject(REDIS_STRING,sdscatprintf(sdsempty(),"%d\r\n%s",-sdslen(shared.wrongtypeerr->ptr)+2,shared.wrongtypeerr->ptr));

     shared.nokeyerr = createObject(REDIS_STRING,sdsnew(
         "-ERR no such key\r\n"));
     shared.nokeyerr = createObject(REDIS_STRING,sdsnew(
         "-ERR no such key\r\n"));

-    shared.nokeyerrbulk = createObject(REDIS_STRING,sdscatprintf(sdsempty(),"%d\r\n%s",-sdslen(shared.nokeyerr->ptr)+2,shared.nokeyerr->ptr));

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

-    shared.syntaxerrbulk = createObject(REDIS_STRING,sdscatprintf(sdsempty(),"%d\r\n%s",-sdslen(shared.syntaxerr->ptr)+2,shared.syntaxerr->ptr));
+    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.space = createObject(REDIS_STRING,sdsnew(" "));
     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.select0 = createStringObject("select 0\r\n",10);
     shared.select1 = createStringObject("select 1\r\n",10);
     shared.select2 = createStringObject("select 2\r\n",10);


@@ -718,6 +900,11 @@ static void initServerConfig() {
     server.daemonize = 0;
     server.pidfile = "/var/run/redis.pid";
     server.dbfilename = "dump.rdb";
     server.daemonize = 0;
     server.pidfile = "/var/run/redis.pid";
     server.dbfilename = "dump.rdb";

+    server.requirepass = NULL;
+    server.shareobjects = 0;
+    server.sharingpoolsize = 1024;
+    server.maxclients = 0;
+    server.maxmemory = 0;

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


@@ -736,14 +923,17 @@ static void initServer() {
 
     signal(SIGHUP, SIG_IGN);
     signal(SIGPIPE, SIG_IGN);
 
     signal(SIGHUP, SIG_IGN);
     signal(SIGPIPE, SIG_IGN);

+    setupSigSegvAction();

 
     server.clients = listCreate();
     server.slaves = listCreate();
 
     server.clients = listCreate();
     server.slaves = listCreate();

+    server.monitors = listCreate();

     server.objfreelist = listCreate();
     createSharedObjects();
     server.el = aeCreateEventLoop();
     server.objfreelist = listCreate();
     createSharedObjects();
     server.el = aeCreateEventLoop();

-    server.dict = zmalloc(sizeof(dict*)*server.dbnum);
-    if (!server.dict || !server.clients || !server.slaves || !server.el || !server.objfreelist)
+    server.db = zmalloc(sizeof(redisDb)*server.dbnum);
+    server.sharingpool = dictCreate(&setDictType,NULL);
+    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) {
         oom("server initialization"); /* Fatal OOM */
     server.fd = anetTcpServer(server.neterr, server.port, server.bindaddr);
     if (server.fd == -1) {


@@ -751,12 +941,13 @@ static void initServer() {
         exit(1);
     }
     for (j = 0; j < server.dbnum; j++) {
         exit(1);
     }
     for (j = 0; j < server.dbnum; j++) {

-        server.dict[j] = dictCreate(&hashDictType,NULL);
-        if (!server.dict[j])
-            oom("dictCreate"); /* Fatal OOM */
+        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.cronloops = 0;
     server.bgsaveinprogress = 0;

+    server.bgsavechildpid = -1;

     server.lastsave = time(NULL);
     server.dirty = 0;
     server.usedmemory = 0;
     server.lastsave = time(NULL);
     server.dirty = 0;
     server.usedmemory = 0;


@@ -767,25 +958,41 @@ static void initServer() {
 }
 
 /* Empty the whole database */
 }
 
 /* Empty the whole database */

-static void emptyDb() {
+static long long emptyDb() {

     int j;
     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;
+}

 
 

-    for (j = 0; j < server.dbnum; j++)
-        dictEmpty(server.dict[j]);
+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) {
 }
 
 /* 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");
+    FILE *fp;

     char buf[REDIS_CONFIGLINE_MAX+1], *err = NULL;
     int linenum = 0;
     sds line = NULL;
     char buf[REDIS_CONFIGLINE_MAX+1], *err = NULL;
     int linenum = 0;
     sds line = NULL;

-    
-    if (!fp) {
-        redisLog(REDIS_WARNING,"Fatal error, can't open config file");
-        exit(1);
+
+    if (filename[0] == '-' && filename[1] == '\0')
+        fp = stdin;
+    else {
+        if ((fp = fopen(filename,"r")) == NULL) {
+            redisLog(REDIS_WARNING,"Fatal error, can't open config file");
+            exit(1);
+        }

     }
     }

+

     while(fgets(buf,REDIS_CONFIGLINE_MAX+1,fp) != NULL) {
         sds *argv;
         int argc, j;
     while(fgets(buf,REDIS_CONFIGLINE_MAX+1,fp) != NULL) {
         sds *argv;
         int argc, j;


@@ -805,83 +1012,94 @@ static void loadServerConfig(char *filename) {
         sdstolower(argv[0]);
 
         /* Execute config directives */
         sdstolower(argv[0]);
 
         /* Execute config directives */

-        if (!strcmp(argv[0],"timeout") && argc == 2) {
+        if (!strcasecmp(argv[0],"timeout") && argc == 2) {

             server.maxidletime = atoi(argv[1]);
             server.maxidletime = atoi(argv[1]);

-            if (server.maxidletime < 1) {
+            if (server.maxidletime < 0) {

                 err = "Invalid timeout value"; goto loaderr;
             }
                 err = "Invalid timeout value"; goto loaderr;
             }

-        } else if (!strcmp(argv[0],"port") && argc == 2) {
+        } else if (!strcasecmp(argv[0],"port") && argc == 2) {

             server.port = atoi(argv[1]);
             if (server.port < 1 || server.port > 65535) {
                 err = "Invalid port"; goto loaderr;
             }
             server.port = atoi(argv[1]);
             if (server.port < 1 || server.port > 65535) {
                 err = "Invalid port"; goto loaderr;
             }

-        } else if (!strcmp(argv[0],"bind") && argc == 2) {
+        } else if (!strcasecmp(argv[0],"bind") && argc == 2) {

             server.bindaddr = zstrdup(argv[1]);
             server.bindaddr = zstrdup(argv[1]);

-        } else if (!strcmp(argv[0],"save") && argc == 3) {
+        } else if (!strcasecmp(argv[0],"save") && argc == 3) {

             int seconds = atoi(argv[1]);
             int changes = atoi(argv[2]);
             if (seconds < 1 || changes < 0) {
                 err = "Invalid save parameters"; goto loaderr;
             }
             appendServerSaveParams(seconds,changes);
             int seconds = atoi(argv[1]);
             int changes = atoi(argv[2]);
             if (seconds < 1 || changes < 0) {
                 err = "Invalid save parameters"; goto loaderr;
             }
             appendServerSaveParams(seconds,changes);

-        } else if (!strcmp(argv[0],"dir") && argc == 2) {
+        } else if (!strcasecmp(argv[0],"dir") && argc == 2) {

             if (chdir(argv[1]) == -1) {
                 redisLog(REDIS_WARNING,"Can't chdir to '%s': %s",
                     argv[1], strerror(errno));
                 exit(1);
             }
             if (chdir(argv[1]) == -1) {
                 redisLog(REDIS_WARNING,"Can't chdir to '%s': %s",
                     argv[1], strerror(errno));
                 exit(1);
             }

-        } else if (!strcmp(argv[0],"loglevel") && argc == 2) {
-            if (!strcmp(argv[1],"debug")) server.verbosity = REDIS_DEBUG;
-            else if (!strcmp(argv[1],"notice")) server.verbosity = REDIS_NOTICE;
-            else if (!strcmp(argv[1],"warning")) server.verbosity = REDIS_WARNING;
+        } else if (!strcasecmp(argv[0],"loglevel") && argc == 2) {
+            if (!strcasecmp(argv[1],"debug")) server.verbosity = REDIS_DEBUG;
+            else if (!strcasecmp(argv[1],"notice")) server.verbosity = REDIS_NOTICE;
+            else if (!strcasecmp(argv[1],"warning")) server.verbosity = REDIS_WARNING;

             else {
                 err = "Invalid log level. Must be one of debug, notice, warning";
                 goto loaderr;
             }
             else {
                 err = "Invalid log level. Must be one of debug, notice, warning";
                 goto loaderr;
             }

-        } else if (!strcmp(argv[0],"logfile") && argc == 2) {
-            FILE *fp;
+        } else if (!strcasecmp(argv[0],"logfile") && argc == 2) {
+            FILE *logfp;

 
             server.logfile = zstrdup(argv[1]);
 
             server.logfile = zstrdup(argv[1]);

-            if (!strcmp(server.logfile,"stdout")) {
+            if (!strcasecmp(server.logfile,"stdout")) {

                 zfree(server.logfile);
                 server.logfile = NULL;
             }
             if (server.logfile) {
                 /* Test if we are able to open the file. The server will not
                  * be able to abort just for this problem later... */
                 zfree(server.logfile);
                 server.logfile = NULL;
             }
             if (server.logfile) {
                 /* Test if we are able to open the file. The server will not
                  * be able to abort just for this problem later... */

-                fp = fopen(server.logfile,"a");
-                if (fp == NULL) {
+                logfp = fopen(server.logfile,"a");
+                if (logfp == NULL) {

                     err = sdscatprintf(sdsempty(),
                         "Can't open the log file: %s", strerror(errno));
                     goto loaderr;
                 }
                     err = sdscatprintf(sdsempty(),
                         "Can't open the log file: %s", strerror(errno));
                     goto loaderr;
                 }

-                fclose(fp);
+                fclose(logfp);

             }
             }

-        } else if (!strcmp(argv[0],"databases") && argc == 2) {
+        } else if (!strcasecmp(argv[0],"databases") && argc == 2) {

             server.dbnum = atoi(argv[1]);
             if (server.dbnum < 1) {
                 err = "Invalid number of databases"; goto loaderr;
             }
             server.dbnum = atoi(argv[1]);
             if (server.dbnum < 1) {
                 err = "Invalid number of databases"; goto loaderr;
             }

-        } else if (!strcmp(argv[0],"slaveof") && argc == 3) {
+        } else if (!strcasecmp(argv[0],"maxclients") && argc == 2) {
+            server.maxclients = atoi(argv[1]);
+        } else if (!strcasecmp(argv[0],"maxmemory") && argc == 2) {
+            server.maxmemory = atoi(argv[1]);
+        } else if (!strcasecmp(argv[0],"slaveof") && argc == 3) {

             server.masterhost = sdsnew(argv[1]);
             server.masterport = atoi(argv[2]);
             server.replstate = REDIS_REPL_CONNECT;
             server.masterhost = sdsnew(argv[1]);
             server.masterport = atoi(argv[2]);
             server.replstate = REDIS_REPL_CONNECT;

-        } else if (!strcmp(argv[0],"glueoutputbuf") && argc == 2) {
-            sdstolower(argv[1]);
-            if (!strcmp(argv[1],"yes")) server.glueoutputbuf = 1;
-            else if (!strcmp(argv[1],"no")) server.glueoutputbuf = 0;
-            else {
+        } else if (!strcasecmp(argv[0],"glueoutputbuf") && argc == 2) {
+            if ((server.glueoutputbuf = yesnotoi(argv[1])) == -1) {

                 err = "argument must be 'yes' or 'no'"; goto loaderr;
             }
                 err = "argument must be 'yes' or 'no'"; goto loaderr;
             }

-        } else if (!strcmp(argv[0],"daemonize") && argc == 2) {
-            sdstolower(argv[1]);
-            if (!strcmp(argv[1],"yes")) server.daemonize = 1;
-            else if (!strcmp(argv[1],"no")) server.daemonize = 0;
-            else {
+        } else if (!strcasecmp(argv[0],"shareobjects") && argc == 2) {
+            if ((server.shareobjects = yesnotoi(argv[1])) == -1) {

                 err = "argument must be 'yes' or 'no'"; goto loaderr;
             }
                 err = "argument must be 'yes' or 'no'"; goto loaderr;
             }

-        } else if (!strcmp(argv[0],"pidfile") && argc == 2) {
+        } else if (!strcasecmp(argv[0],"shareobjectspoolsize") && argc == 2) {
+            server.sharingpoolsize = atoi(argv[1]);
+            if (server.sharingpoolsize < 1) {
+                err = "invalid object sharing pool size"; goto loaderr;
+            }
+        } else if (!strcasecmp(argv[0],"daemonize") && argc == 2) {
+            if ((server.daemonize = yesnotoi(argv[1])) == -1) {
+                err = "argument must be 'yes' or 'no'"; goto loaderr;
+            }
+        } else if (!strcasecmp(argv[0],"requirepass") && argc == 2) {
+          server.requirepass = zstrdup(argv[1]);
+        } else if (!strcasecmp(argv[0],"pidfile") && argc == 2) {

           server.pidfile = zstrdup(argv[1]);
           server.pidfile = zstrdup(argv[1]);

+        } else if (!strcasecmp(argv[0],"dbfilename") && argc == 2) {
+          server.dbfilename = zstrdup(argv[1]);

         } else {
             err = "Bad directive or wrong number of arguments"; goto loaderr;
         }
         } else {
             err = "Bad directive or wrong number of arguments"; goto loaderr;
         }


@@ -890,7 +1108,7 @@ static void loadServerConfig(char *filename) {
         zfree(argv);
         sdsfree(line);
     }
         zfree(argv);
         sdsfree(line);
     }

-    fclose(fp);
+    if (fp != stdin) fclose(fp);

     return;
 
 loaderr:
     return;
 
 loaderr:


@@ -922,26 +1140,30 @@ static void freeClient(redisClient *c) {
     assert(ln != NULL);
     listDelNode(server.clients,ln);
     if (c->flags & REDIS_SLAVE) {
     assert(ln != NULL);
     listDelNode(server.clients,ln);
     if (c->flags & REDIS_SLAVE) {

-        ln = listSearchKey(server.slaves,c);
+        if (c->replstate == REDIS_REPL_SEND_BULK && c->repldbfd != -1)
+            close(c->repldbfd);
+        list *l = (c->flags & REDIS_MONITOR) ? server.monitors : server.slaves;
+        ln = listSearchKey(l,c);

         assert(ln != NULL);
         assert(ln != NULL);

-        listDelNode(server.slaves,ln);
+        listDelNode(l,ln);

     }
     if (c->flags & REDIS_MASTER) {
         server.master = NULL;
         server.replstate = REDIS_REPL_CONNECT;
     }
     }
     if (c->flags & REDIS_MASTER) {
         server.master = NULL;
         server.replstate = REDIS_REPL_CONNECT;
     }

+    zfree(c->argv);

     zfree(c);
 }
 
 static void glueReplyBuffersIfNeeded(redisClient *c) {
     int totlen = 0;
     zfree(c);
 }
 
 static void glueReplyBuffersIfNeeded(redisClient *c) {
     int totlen = 0;

-    listNode *ln = c->reply->head, *next;
+    listNode *ln;

     robj *o;
 
     robj *o;
 

-    while(ln) {
+    listRewind(c->reply);
+    while((ln = listYield(c->reply))) {

         o = ln->value;
         totlen += sdslen(o->ptr);
         o = ln->value;
         totlen += sdslen(o->ptr);

-        ln = ln->next;

         /* This optimization makes more sense if we don't have to copy
          * too much data */
         if (totlen > 1024) return;
         /* This optimization makes more sense if we don't have to copy
          * too much data */
         if (totlen > 1024) return;


@@ -950,17 +1172,16 @@ static void glueReplyBuffersIfNeeded(redisClient *c) {
         char buf[1024];
         int copylen = 0;
 
         char buf[1024];
         int copylen = 0;
 

-        ln = c->reply->head;
-        while(ln) {
-            next = ln->next;
+        listRewind(c->reply);
+        while((ln = listYield(c->reply))) {

             o = ln->value;
             memcpy(buf+copylen,o->ptr,sdslen(o->ptr));
             copylen += sdslen(o->ptr);
             listDelNode(c->reply,ln);
             o = ln->value;
             memcpy(buf+copylen,o->ptr,sdslen(o->ptr));
             copylen += sdslen(o->ptr);
             listDelNode(c->reply,ln);

-            ln = next;

         }
         /* Now the output buffer is empty, add the new single element */
         }
         /* Now the output buffer is empty, add the new single element */

-        addReplySds(c,sdsnewlen(buf,totlen));
+        o = createObject(REDIS_STRING,sdsnewlen(buf,totlen));
+        if (!listAddNodeTail(c->reply,o)) oom("listAddNodeTail");

     }
 }
 
     }
 }
 


@@ -983,9 +1204,10 @@ static void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask)
         }
 
         if (c->flags & REDIS_MASTER) {
         }
 
         if (c->flags & REDIS_MASTER) {

+            /* Don't reply to a master */

             nwritten = objlen - c->sentlen;
         } else {
             nwritten = objlen - c->sentlen;
         } else {

-            nwritten = write(fd, o->ptr+c->sentlen, objlen - c->sentlen);
+            nwritten = write(fd, ((char*)o->ptr)+c->sentlen, objlen - c->sentlen);

             if (nwritten <= 0) break;
         }
         c->sentlen += nwritten;
             if (nwritten <= 0) break;
         }
         c->sentlen += nwritten;


@@ -995,6 +1217,12 @@ static void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask)
             listDelNode(c->reply,listFirst(c->reply));
             c->sentlen = 0;
         }
             listDelNode(c->reply,listFirst(c->reply));
             c->sentlen = 0;
         }

+        /* Note that we avoid to send more thank REDIS_MAX_WRITE_PER_EVENT
+         * bytes, in a single threaded server it's a good idea to server
+         * other clients as well, even if a very large request comes from
+         * super fast link that is always able to accept data (in real world
+         * terms think to 'KEYS *' against the loopback interfae) */
+        if (totwritten > REDIS_MAX_WRITE_PER_EVENT) break;

     }
     if (nwritten == -1) {
         if (errno == EAGAIN) {
     }
     if (nwritten == -1) {
         if (errno == EAGAIN) {


@@ -1016,7 +1244,7 @@ static void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask)
 static struct redisCommand *lookupCommand(char *name) {
     int j = 0;
     while(cmdTable[j].name != NULL) {
 static struct redisCommand *lookupCommand(char *name) {
     int j = 0;
     while(cmdTable[j].name != NULL) {

-        if (!strcmp(name,cmdTable[j].name)) return &cmdTable[j];
+        if (!strcasecmp(name,cmdTable[j].name)) return &cmdTable[j];

         j++;
     }
     return NULL;
         j++;
     }
     return NULL;


@@ -1040,10 +1268,12 @@ static int processCommand(redisClient *c) {
     struct redisCommand *cmd;
     long long dirty;
 
     struct redisCommand *cmd;
     long long dirty;
 

-    sdstolower(c->argv[0]->ptr);
+    /* Free some memory if needed (maxmemory setting) */
+    if (server.maxmemory) freeMemoryIfNeeded();
+

     /* The QUIT command is handled as a special case. Normal command
      * procs are unable to close the client connection safely */
     /* The QUIT command is handled as a special case. Normal command
      * procs are unable to close the client connection safely */

-    if (!strcmp(c->argv[0]->ptr,"quit")) {
+    if (!strcasecmp(c->argv[0]->ptr,"quit")) {

         freeClient(c);
         return 0;
     }
         freeClient(c);
         return 0;
     }


@@ -1057,6 +1287,10 @@ static int processCommand(redisClient *c) {
         addReplySds(c,sdsnew("-ERR wrong number of arguments\r\n"));
         resetClient(c);
         return 1;
         addReplySds(c,sdsnew("-ERR wrong number of arguments\r\n"));
         resetClient(c);
         return 1;

+    } else if (server.maxmemory && cmd->flags & REDIS_CMD_DENYOOM && zmalloc_used_memory() > server.maxmemory) {
+        addReplySds(c,sdsnew("-ERR command not allowed when used memory > 'maxmemory'\r\n"));
+        resetClient(c);
+        return 1;

     } else if (cmd->flags & REDIS_CMD_BULK && c->bulklen == -1) {
         int bulklen = atoi(c->argv[c->argc-1]->ptr);
 
     } else if (cmd->flags & REDIS_CMD_BULK && c->bulklen == -1) {
         int bulklen = atoi(c->argv[c->argc-1]->ptr);
 


@@ -1079,11 +1313,26 @@ static int processCommand(redisClient *c) {
             return 1;
         }
     }
             return 1;
         }
     }

+    /* Let's try to share objects on the command arguments vector */
+    if (server.shareobjects) {
+        int j;
+        for(j = 1; j < c->argc; j++)
+            c->argv[j] = tryObjectSharing(c->argv[j]);
+    }
+    /* Check if the user is authenticated */
+    if (server.requirepass && !c->authenticated && cmd->proc != authCommand) {
+        addReplySds(c,sdsnew("-ERR operation not permitted\r\n"));
+        resetClient(c);
+        return 1;
+    }
+

     /* Exec the command */
     dirty = server.dirty;
     cmd->proc(c);
     if (server.dirty-dirty != 0 && listLength(server.slaves))
     /* Exec the command */
     dirty = server.dirty;
     cmd->proc(c);
     if (server.dirty-dirty != 0 && listLength(server.slaves))

-        replicationFeedSlaves(cmd,c->dictid,c->argv,c->argc);
+        replicationFeedSlaves(server.slaves,cmd,c->db->id,c->argv,c->argc);
+    if (listLength(server.monitors))
+        replicationFeedSlaves(server.monitors,cmd,c->db->id,c->argv,c->argc);

     server.stat_numcommands++;
 
     /* Prepare the client for the next command */
     server.stat_numcommands++;
 
     /* Prepare the client for the next command */


@@ -1095,10 +1344,19 @@ static int processCommand(redisClient *c) {
     return 1;
 }
 
     return 1;
 }
 

-static void replicationFeedSlaves(struct redisCommand *cmd, int dictid, robj **argv, int argc) {
-    listNode *ln = server.slaves->head;
-    robj *outv[REDIS_MAX_ARGS*4]; /* enough room for args, spaces, newlines */
+static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int dictid, robj **argv, int argc) {
+    listNode *ln;

     int outc = 0, j;
     int outc = 0, j;

+    robj **outv;
+    /* (args*2)+1 is enough room for args, spaces, newlines */
+    robj *static_outv[REDIS_STATIC_ARGS*2+1];
+
+    if (argc <= REDIS_STATIC_ARGS) {
+        outv = static_outv;
+    } else {
+        outv = zmalloc(sizeof(robj*)*(argc*2+1));
+        if (!outv) oom("replicationFeedSlaves");
+    }

     
     for (j = 0; j < argc; j++) {
         if (j != 0) outv[outc++] = shared.space;
     
     for (j = 0; j < argc; j++) {
         if (j != 0) outv[outc++] = shared.space;


@@ -1114,8 +1372,18 @@ static void replicationFeedSlaves(struct redisCommand *cmd, int dictid, robj **a
     }
     outv[outc++] = shared.crlf;
 
     }
     outv[outc++] = shared.crlf;
 

-    while(ln) {
+    /* Increment all the refcounts at start and decrement at end in order to
+     * be sure to free objects if there is no slave in a replication state
+     * able to be feed with commands */
+    for (j = 0; j < outc; j++) incrRefCount(outv[j]);
+    listRewind(slaves);
+    while((ln = listYield(slaves))) {

         redisClient *slave = ln->value;
         redisClient *slave = ln->value;

+
+        /* Don't feed slaves that are still waiting for BGSAVE to start */
+        if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_START) continue;
+
+        /* Feed all the other slaves, MONITORs and so on */

         if (slave->slaveseldb != dictid) {
             robj *selectcmd;
 
         if (slave->slaveseldb != dictid) {
             robj *selectcmd;
 


@@ -1140,18 +1408,19 @@ static void replicationFeedSlaves(struct redisCommand *cmd, int dictid, robj **a
             slave->slaveseldb = dictid;
         }
         for (j = 0; j < outc; j++) addReply(slave,outv[j]);
             slave->slaveseldb = dictid;
         }
         for (j = 0; j < outc; j++) addReply(slave,outv[j]);

-        ln = ln->next;

     }
     }

+    for (j = 0; j < outc; j++) decrRefCount(outv[j]);
+    if (outv != static_outv) zfree(outv);

 }
 
 static void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {
     redisClient *c = (redisClient*) privdata;
 }
 
 static void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {
     redisClient *c = (redisClient*) privdata;

-    char buf[REDIS_QUERYBUF_LEN];
+    char buf[REDIS_IOBUF_LEN];

     int nread;
     REDIS_NOTUSED(el);
     REDIS_NOTUSED(mask);
 
     int nread;
     REDIS_NOTUSED(el);
     REDIS_NOTUSED(mask);
 

-    nread = read(fd, buf, REDIS_QUERYBUF_LEN);
+    nread = read(fd, buf, REDIS_IOBUF_LEN);

     if (nread == -1) {
         if (errno == EAGAIN) {
             nread = 0;
     if (nread == -1) {
         if (errno == EAGAIN) {
             nread = 0;


@@ -1177,6 +1446,7 @@ again:
         /* Read the first line of the query */
         char *p = strchr(c->querybuf,'\n');
         size_t querylen;
         /* Read the first line of the query */
         char *p = strchr(c->querybuf,'\n');
         size_t querylen;

+

         if (p) {
             sds query, *argv;
             int argc, j;
         if (p) {
             sds query, *argv;
             int argc, j;


@@ -1199,9 +1469,14 @@ again:
                 return;
             }
             argv = sdssplitlen(query,sdslen(query)," ",1,&argc);
                 return;
             }
             argv = sdssplitlen(query,sdslen(query)," ",1,&argc);

-            sdsfree(query);

             if (argv == NULL) oom("sdssplitlen");
             if (argv == NULL) oom("sdssplitlen");

-            for (j = 0; j < argc && j < REDIS_MAX_ARGS; j++) {
+            sdsfree(query);
+
+            if (c->argv) zfree(c->argv);
+            c->argv = zmalloc(sizeof(robj*)*argc);
+            if (c->argv == NULL) oom("allocating arguments list for client");
+
+            for (j = 0; j < argc; j++) {

                 if (sdslen(argv[j])) {
                     c->argv[c->argc] = createObject(REDIS_STRING,argv[j]);
                     c->argc++;
                 if (sdslen(argv[j])) {
                     c->argv[c->argc] = createObject(REDIS_STRING,argv[j]);
                     c->argc++;


@@ -1213,9 +1488,9 @@ again:
             /* Execute the command. If the client is still valid
              * after processCommand() return and there is something
              * on the query buffer try to process the next command. */
             /* Execute the command. If the client is still valid
              * after processCommand() return and there is something
              * on the query buffer try to process the next command. */

-            if (processCommand(c) && sdslen(c->querybuf)) goto again;
+            if (c->argc && processCommand(c) && sdslen(c->querybuf)) goto again;

             return;
             return;

-        } else if (sdslen(c->querybuf) >= 1024) {
+        } else if (sdslen(c->querybuf) >= REDIS_REQUEST_MAX_SIZE) {

             redisLog(REDIS_DEBUG, "Client protocol error");
             freeClient(c);
             return;
             redisLog(REDIS_DEBUG, "Client protocol error");
             freeClient(c);
             return;


@@ -1241,11 +1516,15 @@ again:
 static int selectDb(redisClient *c, int id) {
     if (id < 0 || id >= server.dbnum)
         return REDIS_ERR;
 static int selectDb(redisClient *c, int id) {
     if (id < 0 || id >= server.dbnum)
         return REDIS_ERR;

-    c->dict = server.dict[id];
-    c->dictid = id;
+    c->db = &server.db[id];

     return REDIS_OK;
 }
 
     return REDIS_OK;
 }
 

+static void *dupClientReplyValue(void *o) {
+    incrRefCount((robj*)o);
+    return 0;
+}
+

 static redisClient *createClient(int fd) {
     redisClient *c = zmalloc(sizeof(*c));
 
 static redisClient *createClient(int fd) {
     redisClient *c = zmalloc(sizeof(*c));
 


@@ -1256,12 +1535,16 @@ static redisClient *createClient(int fd) {
     c->fd = fd;
     c->querybuf = sdsempty();
     c->argc = 0;
     c->fd = fd;
     c->querybuf = sdsempty();
     c->argc = 0;

+    c->argv = NULL;

     c->bulklen = -1;
     c->sentlen = 0;
     c->flags = 0;
     c->lastinteraction = time(NULL);
     c->bulklen = -1;
     c->sentlen = 0;
     c->flags = 0;
     c->lastinteraction = time(NULL);

+    c->authenticated = 0;
+    c->replstate = REDIS_REPL_NONE;

     if ((c->reply = listCreate()) == NULL) oom("listCreate");
     listSetFreeMethod(c->reply,decrRefCount);
     if ((c->reply = listCreate()) == NULL) oom("listCreate");
     listSetFreeMethod(c->reply,decrRefCount);

+    listSetDupMethod(c->reply,dupClientReplyValue);

     if (aeCreateFileEvent(server.el, c->fd, AE_READABLE,
         readQueryFromClient, c, NULL) == AE_ERR) {
         freeClient(c);
     if (aeCreateFileEvent(server.el, c->fd, AE_READABLE,
         readQueryFromClient, c, NULL) == AE_ERR) {
         freeClient(c);


@@ -1273,6 +1556,8 @@ static redisClient *createClient(int fd) {
 
 static void addReply(redisClient *c, robj *obj) {
     if (listLength(c->reply) == 0 &&
 
 static void addReply(redisClient *c, robj *obj) {
     if (listLength(c->reply) == 0 &&

+        (c->replstate == REDIS_REPL_NONE ||
+         c->replstate == REDIS_REPL_ONLINE) &&

         aeCreateFileEvent(server.el, c->fd, AE_WRITABLE,
         sendReplyToClient, c, NULL) == AE_ERR) return;
     if (!listAddNodeTail(c->reply,obj)) oom("listAddNodeTail");
         aeCreateFileEvent(server.el, c->fd, AE_WRITABLE,
         sendReplyToClient, c, NULL) == AE_ERR) return;
     if (!listAddNodeTail(c->reply,obj)) oom("listAddNodeTail");


@@ -1288,6 +1573,7 @@ static void addReplySds(redisClient *c, sds s) {
 static void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
     int cport, cfd;
     char cip[128];
 static void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
     int cport, cfd;
     char cip[128];

+    redisClient *c;

     REDIS_NOTUSED(el);
     REDIS_NOTUSED(mask);
     REDIS_NOTUSED(privdata);
     REDIS_NOTUSED(el);
     REDIS_NOTUSED(mask);
     REDIS_NOTUSED(privdata);


@@ -1298,11 +1584,23 @@ static void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
         return;
     }
     redisLog(REDIS_DEBUG,"Accepted %s:%d", cip, cport);
         return;
     }
     redisLog(REDIS_DEBUG,"Accepted %s:%d", cip, cport);

-    if (createClient(cfd) == NULL) {
+    if ((c = createClient(cfd)) == NULL) {

         redisLog(REDIS_WARNING,"Error allocating resoures for the client");
         close(cfd); /* May be already closed, just ingore errors */
         return;
     }
         redisLog(REDIS_WARNING,"Error allocating resoures for the client");
         close(cfd); /* May be already closed, just ingore errors */
         return;
     }

+    /* If maxclient directive is set and this is one client more... close the
+     * connection. Note that we create the client instead to check before
+     * for this condition, since now the socket is already set in nonblocking
+     * mode and we can send an error for free using the Kernel I/O */
+    if (server.maxclients && listLength(server.clients) > server.maxclients) {
+        char *err = "-ERR max number of clients reached\r\n";
+
+        /* That's a best effort error message, don't check write errors */
+        (void) write(c->fd,err,strlen(err));
+        freeClient(c);
+        return;
+    }

     server.stat_numconnections++;
 }
 
     server.stat_numconnections++;
 }
 


@@ -1343,14 +1641,6 @@ static robj *createSetObject(void) {
     return createObject(REDIS_SET,d);
 }
 
     return createObject(REDIS_SET,d);
 }
 

-#if 0
-static robj *createHashObject(void) {
-    dict *d = dictCreate(&hashDictType,NULL);
-    if (!d) oom("dictCreate");
-    return createObject(REDIS_SET,d);
-}
-#endif
-

 static void freeStringObject(robj *o) {
     sdsfree(o->ptr);
 }
 static void freeStringObject(robj *o) {
     sdsfree(o->ptr);
 }


@@ -1369,10 +1659,19 @@ static void freeHashObject(robj *o) {
 
 static void incrRefCount(robj *o) {
     o->refcount++;
 
 static void incrRefCount(robj *o) {
     o->refcount++;

+#ifdef DEBUG_REFCOUNT
+    if (o->type == REDIS_STRING)
+        printf("Increment '%s'(%p), now is: %d\n",o->ptr,o,o->refcount);
+#endif

 }
 
 static void decrRefCount(void *obj) {
     robj *o = obj;
 }
 
 static void decrRefCount(void *obj) {
     robj *o = obj;

+
+#ifdef DEBUG_REFCOUNT
+    if (o->type == REDIS_STRING)
+        printf("Decrement '%s'(%p), now is: %d\n",o->ptr,o,o->refcount-1);
+#endif

     if (--(o->refcount) == 0) {
         switch(o->type) {
         case REDIS_STRING: freeStringObject(o); break;
     if (--(o->refcount) == 0) {
         switch(o->type) {
         case REDIS_STRING: freeStringObject(o); break;


@@ -1387,28 +1686,235 @@ static void decrRefCount(void *obj) {
     }
 }
 
     }
 }
 

+/* Try to share an object against the shared objects pool */
+static robj *tryObjectSharing(robj *o) {
+    struct dictEntry *de;
+    unsigned long c;
+
+    if (o == NULL || server.shareobjects == 0) return o;
+
+    assert(o->type == REDIS_STRING);
+    de = dictFind(server.sharingpool,o);
+    if (de) {
+        robj *shared = dictGetEntryKey(de);
+
+        c = ((unsigned long) dictGetEntryVal(de))+1;
+        dictGetEntryVal(de) = (void*) c;
+        incrRefCount(shared);
+        decrRefCount(o);
+        return shared;
+    } else {
+        /* Here we are using a stream algorihtm: Every time an object is
+         * shared we increment its count, everytime there is a miss we
+         * recrement the counter of a random object. If this object reaches
+         * zero we remove the object and put the current object instead. */
+        if (dictSize(server.sharingpool) >=
+                server.sharingpoolsize) {
+            de = dictGetRandomKey(server.sharingpool);
+            assert(de != NULL);
+            c = ((unsigned long) dictGetEntryVal(de))-1;
+            dictGetEntryVal(de) = (void*) c;
+            if (c == 0) {
+                dictDelete(server.sharingpool,de->key);
+            }
+        } else {
+            c = 0; /* If the pool is empty we want to add this object */
+        }
+        if (c == 0) {
+            int retval;
+
+            retval = dictAdd(server.sharingpool,o,(void*)1);
+            assert(retval == DICT_OK);
+            incrRefCount(o);
+        }
+        return o;
+    }
+}
+
+static robj *lookupKey(redisDb *db, robj *key) {
+    dictEntry *de = dictFind(db->dict,key);
+    return de ? dictGetEntryVal(de) : NULL;
+}
+
+static robj *lookupKeyRead(redisDb *db, robj *key) {
+    expireIfNeeded(db,key);
+    return lookupKey(db,key);
+}
+
+static robj *lookupKeyWrite(redisDb *db, robj *key) {
+    deleteIfVolatile(db,key);
+    return lookupKey(db,key);
+}
+
+static int deleteKey(redisDb *db, robj *key) {
+    int retval;
+
+    /* We need to protect key from destruction: after the first dictDelete()
+     * it may happen that 'key' is no longer valid if we don't increment
+     * it's count. This may happen when we get the object reference directly
+     * from the hash table with dictRandomKey() or dict iterators */
+    incrRefCount(key);
+    if (dictSize(db->expires)) dictDelete(db->expires,key);
+    retval = dictDelete(db->dict,key);
+    decrRefCount(key);
+
+    return retval == DICT_OK;
+}
+

 /*============================ DB saving/loading ============================ */
 
 /*============================ DB saving/loading ============================ */
 

+static int rdbSaveType(FILE *fp, unsigned char type) {
+    if (fwrite(&type,1,1,fp) == 0) return -1;
+    return 0;
+}
+
+static int rdbSaveTime(FILE *fp, time_t t) {
+    int32_t t32 = (int32_t) t;
+    if (fwrite(&t32,4,1,fp) == 0) return -1;
+    return 0;
+}
+
+/* check rdbLoadLen() comments for more info */
+static int rdbSaveLen(FILE *fp, uint32_t len) {
+    unsigned char buf[2];
+
+    if (len < (1<<6)) {
+        /* Save a 6 bit len */
+        buf[0] = (len&0xFF)|(REDIS_RDB_6BITLEN<<6);
+        if (fwrite(buf,1,1,fp) == 0) return -1;
+    } else if (len < (1<<14)) {
+        /* Save a 14 bit len */
+        buf[0] = ((len>>8)&0xFF)|(REDIS_RDB_14BITLEN<<6);
+        buf[1] = len&0xFF;
+        if (fwrite(buf,2,1,fp) == 0) return -1;
+    } else {
+        /* Save a 32 bit len */
+        buf[0] = (REDIS_RDB_32BITLEN<<6);
+        if (fwrite(buf,1,1,fp) == 0) return -1;
+        len = htonl(len);
+        if (fwrite(&len,4,1,fp) == 0) return -1;
+    }
+    return 0;
+}
+
+/* String objects in the form "2391" "-100" without any space and with a
+ * range of values that can fit in an 8, 16 or 32 bit signed value can be
+ * encoded as integers to save space */
+static int rdbTryIntegerEncoding(sds s, unsigned char *enc) {
+    long long value;
+    char *endptr, buf[32];
+
+    /* Check if it's possible to encode this value as a number */
+    value = strtoll(s, &endptr, 10);
+    if (endptr[0] != '\0') return 0;
+    snprintf(buf,32,"%lld",value);
+
+    /* If the number converted back into a string is not identical
+     * then it's not possible to encode the string as integer */
+    if (strlen(buf) != sdslen(s) || memcmp(buf,s,sdslen(s))) return 0;
+
+    /* Finally check if it fits in our ranges */
+    if (value >= -(1<<7) && value <= (1<<7)-1) {
+        enc[0] = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_INT8;
+        enc[1] = value&0xFF;
+        return 2;
+    } else if (value >= -(1<<15) && value <= (1<<15)-1) {
+        enc[0] = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_INT16;
+        enc[1] = value&0xFF;
+        enc[2] = (value>>8)&0xFF;
+        return 3;
+    } else if (value >= -((long long)1<<31) && value <= ((long long)1<<31)-1) {
+        enc[0] = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_INT32;
+        enc[1] = value&0xFF;
+        enc[2] = (value>>8)&0xFF;
+        enc[3] = (value>>16)&0xFF;
+        enc[4] = (value>>24)&0xFF;
+        return 5;
+    } else {
+        return 0;
+    }
+}
+
+static int rdbSaveLzfStringObject(FILE *fp, robj *obj) {
+    unsigned int comprlen, outlen;
+    unsigned char byte;
+    void *out;
+
+    /* We require at least four bytes compression for this to be worth it */
+    outlen = sdslen(obj->ptr)-4;
+    if (outlen <= 0) return 0;
+    if ((out = zmalloc(outlen+1)) == NULL) return 0;
+    comprlen = lzf_compress(obj->ptr, sdslen(obj->ptr), out, outlen);
+    if (comprlen == 0) {
+        zfree(out);
+        return 0;
+    }
+    /* Data compressed! Let's save it on disk */
+    byte = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_LZF;
+    if (fwrite(&byte,1,1,fp) == 0) goto writeerr;
+    if (rdbSaveLen(fp,comprlen) == -1) goto writeerr;
+    if (rdbSaveLen(fp,sdslen(obj->ptr)) == -1) goto writeerr;
+    if (fwrite(out,comprlen,1,fp) == 0) goto writeerr;
+    zfree(out);
+    return comprlen;
+
+writeerr:
+    zfree(out);
+    return -1;
+}
+
+/* Save a string objet as [len][data] on disk. If the object is a string
+ * representation of an integer value we try to safe it in a special form */
+static int rdbSaveStringObject(FILE *fp, robj *obj) {
+    size_t len = sdslen(obj->ptr);
+    int enclen;
+
+    /* Try integer encoding */
+    if (len <= 11) {
+        unsigned char buf[5];
+        if ((enclen = rdbTryIntegerEncoding(obj->ptr,buf)) > 0) {
+            if (fwrite(buf,enclen,1,fp) == 0) return -1;
+            return 0;
+        }
+    }
+
+    /* Try LZF compression - under 20 bytes it's unable to compress even
+     * aaaaaaaaaaaaaaaaaa so skip it */
+    if (1 && len > 20) {
+        int retval;
+
+        retval = rdbSaveLzfStringObject(fp,obj);
+        if (retval == -1) return -1;
+        if (retval > 0) return 0;
+        /* retval == 0 means data can't be compressed, save the old way */
+    }
+
+    /* Store verbatim */
+    if (rdbSaveLen(fp,len) == -1) return -1;
+    if (len && fwrite(obj->ptr,len,1,fp) == 0) return -1;
+    return 0;
+}
+

 /* Save the DB on disk. Return REDIS_ERR on error, REDIS_OK on success */
 /* Save the DB on disk. Return REDIS_ERR on error, REDIS_OK on success */

-static int saveDb(char *filename) {
+static int rdbSave(char *filename) {

     dictIterator *di = NULL;
     dictEntry *de;
     dictIterator *di = NULL;
     dictEntry *de;

-    uint32_t len;
-    uint8_t type;

     FILE *fp;
     char tmpfile[256];
     int j;
     FILE *fp;
     char tmpfile[256];
     int j;

+    time_t now = time(NULL);

 
 

-    snprintf(tmpfile,256,"temp-%d.%ld.rdb",(int)time(NULL),(long int)random());
+    snprintf(tmpfile,256,"temp-%d.rdb", (int) getpid());

     fp = fopen(tmpfile,"w");
     if (!fp) {
         redisLog(REDIS_WARNING, "Failed saving the DB: %s", strerror(errno));
         return REDIS_ERR;
     }
     fp = fopen(tmpfile,"w");
     if (!fp) {
         redisLog(REDIS_WARNING, "Failed saving the DB: %s", strerror(errno));
         return REDIS_ERR;
     }

-    if (fwrite("REDIS0000",9,1,fp) == 0) goto werr;
+    if (fwrite("REDIS0001",9,1,fp) == 0) goto werr;

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

-        dict *d = server.dict[j];
-        if (dictGetHashTableUsed(d) == 0) continue;
+        redisDb *db = server.db+j;
+        dict *d = db->dict;
+        if (dictSize(d) == 0) continue;

         di = dictGetIterator(d);
         if (!di) {
             fclose(fp);
         di = dictGetIterator(d);
         if (!di) {
             fclose(fp);


@@ -1416,60 +1922,52 @@ static int saveDb(char *filename) {
         }
 
         /* Write the SELECT DB opcode */
         }
 
         /* Write the SELECT DB opcode */

-        type = REDIS_SELECTDB;
-        len = htonl(j);
-        if (fwrite(&type,1,1,fp) == 0) goto werr;
-        if (fwrite(&len,4,1,fp) == 0) goto werr;
+        if (rdbSaveType(fp,REDIS_SELECTDB) == -1) goto werr;
+        if (rdbSaveLen(fp,j) == -1) goto werr;

 
         /* Iterate this DB writing every entry */
         while((de = dictNext(di)) != NULL) {
             robj *key = dictGetEntryKey(de);
             robj *o = dictGetEntryVal(de);
 
         /* Iterate this DB writing every entry */
         while((de = dictNext(di)) != NULL) {
             robj *key = dictGetEntryKey(de);
             robj *o = dictGetEntryVal(de);

-
-            type = o->type;
-            len = htonl(sdslen(key->ptr));
-            if (fwrite(&type,1,1,fp) == 0) goto werr;
-            if (fwrite(&len,4,1,fp) == 0) goto werr;
-            if (fwrite(key->ptr,sdslen(key->ptr),1,fp) == 0) goto werr;
-            if (type == REDIS_STRING) {
+            time_t expiretime = getExpire(db,key);
+
+            /* Save the expire time */
+            if (expiretime != -1) {
+                /* If this key is already expired skip it */
+                if (expiretime < now) continue;
+                if (rdbSaveType(fp,REDIS_EXPIRETIME) == -1) goto werr;
+                if (rdbSaveTime(fp,expiretime) == -1) goto werr;
+            }
+            /* Save the key and associated value */
+            if (rdbSaveType(fp,o->type) == -1) goto werr;
+            if (rdbSaveStringObject(fp,key) == -1) goto werr;
+            if (o->type == REDIS_STRING) {

                 /* Save a string value */
                 /* Save a string value */

-                sds sval = o->ptr;
-                len = htonl(sdslen(sval));
-                if (fwrite(&len,4,1,fp) == 0) goto werr;
-                if (sdslen(sval) &&
-                    fwrite(sval,sdslen(sval),1,fp) == 0) goto werr;
-            } else if (type == REDIS_LIST) {
+                if (rdbSaveStringObject(fp,o) == -1) goto werr;
+            } else if (o->type == REDIS_LIST) {

                 /* Save a list value */
                 list *list = o->ptr;
                 /* Save a list value */
                 list *list = o->ptr;

-                listNode *ln = list->head;
+                listNode *ln;

 
 

-                len = htonl(listLength(list));
-                if (fwrite(&len,4,1,fp) == 0) goto werr;
-                while(ln) {
+                listRewind(list);
+                if (rdbSaveLen(fp,listLength(list)) == -1) goto werr;
+                while((ln = listYield(list))) {

                     robj *eleobj = listNodeValue(ln);
                     robj *eleobj = listNodeValue(ln);

-                    len = htonl(sdslen(eleobj->ptr));
-                    if (fwrite(&len,4,1,fp) == 0) goto werr;
-                    if (sdslen(eleobj->ptr) && fwrite(eleobj->ptr,sdslen(eleobj->ptr),1,fp) == 0)
-                        goto werr;
-                    ln = ln->next;
+
+                    if (rdbSaveStringObject(fp,eleobj) == -1) goto werr;

                 }
                 }

-            } else if (type == REDIS_SET) {
+            } else if (o->type == REDIS_SET) {

                 /* Save a set value */
                 dict *set = o->ptr;
                 dictIterator *di = dictGetIterator(set);
                 dictEntry *de;
 
                 if (!set) oom("dictGetIteraotr");
                 /* Save a set value */
                 dict *set = o->ptr;
                 dictIterator *di = dictGetIterator(set);
                 dictEntry *de;
 
                 if (!set) oom("dictGetIteraotr");

-                len = htonl(dictGetHashTableUsed(set));
-                if (fwrite(&len,4,1,fp) == 0) goto werr;
+                if (rdbSaveLen(fp,dictSize(set)) == -1) goto werr;

                 while((de = dictNext(di)) != NULL) {
                 while((de = dictNext(di)) != NULL) {

-                    robj *eleobj;
+                    robj *eleobj = dictGetEntryKey(de);

 
 

-                    eleobj = dictGetEntryKey(de);
-                    len = htonl(sdslen(eleobj->ptr));
-                    if (fwrite(&len,4,1,fp) == 0) goto werr;
-                    if (sdslen(eleobj->ptr) && fwrite(eleobj->ptr,sdslen(eleobj->ptr),1,fp) == 0)
-                        goto werr;
+                    if (rdbSaveStringObject(fp,eleobj) == -1) goto werr;

                 }
                 dictReleaseIterator(di);
             } else {
                 }
                 dictReleaseIterator(di);
             } else {


@@ -1479,8 +1977,9 @@ static int saveDb(char *filename) {
         dictReleaseIterator(di);
     }
     /* EOF opcode */
         dictReleaseIterator(di);
     }
     /* EOF opcode */

-    type = REDIS_EOF;
-    if (fwrite(&type,1,1,fp) == 0) goto werr;
+    if (rdbSaveType(fp,REDIS_EOF) == -1) goto werr;
+
+    /* Make sure data will not remain on the OS's output buffers */

     fflush(fp);
     fsync(fileno(fp));
     fclose(fp);
     fflush(fp);
     fsync(fileno(fp));
     fclose(fp);


@@ -1505,105 +2004,226 @@ werr:
     return REDIS_ERR;
 }
 
     return REDIS_ERR;
 }
 

-static int saveDbBackground(char *filename) {
+static int rdbSaveBackground(char *filename) {

     pid_t childpid;
 
     if (server.bgsaveinprogress) return REDIS_ERR;
     if ((childpid = fork()) == 0) {
         /* Child */
         close(server.fd);
     pid_t childpid;
 
     if (server.bgsaveinprogress) return REDIS_ERR;
     if ((childpid = fork()) == 0) {
         /* Child */
         close(server.fd);

-        if (saveDb(filename) == REDIS_OK) {
+        if (rdbSave(filename) == REDIS_OK) {

             exit(0);
         } else {
             exit(1);
         }
     } else {
         /* Parent */
             exit(0);
         } else {
             exit(1);
         }
     } else {
         /* Parent */

+        if (childpid == -1) {
+            redisLog(REDIS_WARNING,"Can't save in background: fork: %s",
+                strerror(errno));
+            return REDIS_ERR;
+        }

         redisLog(REDIS_NOTICE,"Background saving started by pid %d",childpid);
         server.bgsaveinprogress = 1;
         redisLog(REDIS_NOTICE,"Background saving started by pid %d",childpid);
         server.bgsaveinprogress = 1;

+        server.bgsavechildpid = childpid;

         return REDIS_OK;
     }
     return REDIS_OK; /* unreached */
 }
 
         return REDIS_OK;
     }
     return REDIS_OK; /* unreached */
 }
 

-static int loadDb(char *filename) {
+static void rdbRemoveTempFile(pid_t childpid) {
+    char tmpfile[256];
+
+    snprintf(tmpfile,256,"temp-%d.rdb", (int) childpid);
+    unlink(tmpfile);
+}
+
+static int rdbLoadType(FILE *fp) {
+    unsigned char type;
+    if (fread(&type,1,1,fp) == 0) return -1;
+    return type;
+}
+
+static time_t rdbLoadTime(FILE *fp) {
+    int32_t t32;
+    if (fread(&t32,4,1,fp) == 0) return -1;
+    return (time_t) t32;
+}
+
+/* Load an encoded length from the DB, see the REDIS_RDB_* defines on the top
+ * of this file for a description of how this are stored on disk.
+ *
+ * isencoded is set to 1 if the readed length is not actually a length but
+ * an "encoding type", check the above comments for more info */
+static uint32_t rdbLoadLen(FILE *fp, int rdbver, int *isencoded) {
+    unsigned char buf[2];
+    uint32_t len;
+
+    if (isencoded) *isencoded = 0;
+    if (rdbver == 0) {
+        if (fread(&len,4,1,fp) == 0) return REDIS_RDB_LENERR;
+        return ntohl(len);
+    } else {
+        int type;
+
+        if (fread(buf,1,1,fp) == 0) return REDIS_RDB_LENERR;
+        type = (buf[0]&0xC0)>>6;
+        if (type == REDIS_RDB_6BITLEN) {
+            /* Read a 6 bit len */
+            return buf[0]&0x3F;
+        } else if (type == REDIS_RDB_ENCVAL) {
+            /* Read a 6 bit len encoding type */
+            if (isencoded) *isencoded = 1;
+            return buf[0]&0x3F;
+        } else if (type == REDIS_RDB_14BITLEN) {
+            /* Read a 14 bit len */
+            if (fread(buf+1,1,1,fp) == 0) return REDIS_RDB_LENERR;
+            return ((buf[0]&0x3F)<<8)|buf[1];
+        } else {
+            /* Read a 32 bit len */
+            if (fread(&len,4,1,fp) == 0) return REDIS_RDB_LENERR;
+            return ntohl(len);
+        }
+    }
+}
+
+static robj *rdbLoadIntegerObject(FILE *fp, int enctype) {
+    unsigned char enc[4];
+    long long val;
+
+    if (enctype == REDIS_RDB_ENC_INT8) {
+        if (fread(enc,1,1,fp) == 0) return NULL;
+        val = (signed char)enc[0];
+    } else if (enctype == REDIS_RDB_ENC_INT16) {
+        uint16_t v;
+        if (fread(enc,2,1,fp) == 0) return NULL;
+        v = enc[0]|(enc[1]<<8);
+        val = (int16_t)v;
+    } else if (enctype == REDIS_RDB_ENC_INT32) {
+        uint32_t v;
+        if (fread(enc,4,1,fp) == 0) return NULL;
+        v = enc[0]|(enc[1]<<8)|(enc[2]<<16)|(enc[3]<<24);
+        val = (int32_t)v;
+    } else {
+        val = 0; /* anti-warning */
+        assert(0!=0);
+    }
+    return createObject(REDIS_STRING,sdscatprintf(sdsempty(),"%lld",val));
+}
+
+static robj *rdbLoadLzfStringObject(FILE*fp, int rdbver) {
+    unsigned int len, clen;
+    unsigned char *c = NULL;
+    sds val = NULL;
+
+    if ((clen = rdbLoadLen(fp,rdbver,NULL)) == REDIS_RDB_LENERR) return NULL;
+    if ((len = rdbLoadLen(fp,rdbver,NULL)) == REDIS_RDB_LENERR) return NULL;
+    if ((c = zmalloc(clen)) == NULL) goto err;
+    if ((val = sdsnewlen(NULL,len)) == NULL) goto err;
+    if (fread(c,clen,1,fp) == 0) goto err;
+    if (lzf_decompress(c,clen,val,len) == 0) goto err;
+    zfree(c);
+    return createObject(REDIS_STRING,val);
+err:
+    zfree(c);
+    sdsfree(val);
+    return NULL;
+}
+
+static robj *rdbLoadStringObject(FILE*fp, int rdbver) {
+    int isencoded;
+    uint32_t len;
+    sds val;
+
+    len = rdbLoadLen(fp,rdbver,&isencoded);
+    if (isencoded) {
+        switch(len) {
+        case REDIS_RDB_ENC_INT8:
+        case REDIS_RDB_ENC_INT16:
+        case REDIS_RDB_ENC_INT32:
+            return tryObjectSharing(rdbLoadIntegerObject(fp,len));
+        case REDIS_RDB_ENC_LZF:
+            return tryObjectSharing(rdbLoadLzfStringObject(fp,rdbver));
+        default:
+            assert(0!=0);
+        }
+    }
+
+    if (len == REDIS_RDB_LENERR) return NULL;
+    val = sdsnewlen(NULL,len);
+    if (len && fread(val,len,1,fp) == 0) {
+        sdsfree(val);
+        return NULL;
+    }
+    return tryObjectSharing(createObject(REDIS_STRING,val));
+}
+
+static int rdbLoad(char *filename) {

     FILE *fp;
     FILE *fp;

-    char buf[REDIS_LOADBUF_LEN];    /* Try to use this buffer instead of */
-    char vbuf[REDIS_LOADBUF_LEN];   /* malloc() when the element is small */
-    char *key = NULL, *val = NULL;
-    uint32_t klen,vlen,dbid;
-    uint8_t type;
-    int retval;
-    dict *d = server.dict[0];
+    robj *keyobj = NULL;
+    uint32_t dbid;
+    int type, retval, rdbver;
+    dict *d = server.db[0].dict;
+    redisDb *db = server.db+0;
+    char buf[1024];
+    time_t expiretime = -1, now = time(NULL);

 
     fp = fopen(filename,"r");
     if (!fp) return REDIS_ERR;
     if (fread(buf,9,1,fp) == 0) goto eoferr;
 
     fp = fopen(filename,"r");
     if (!fp) return REDIS_ERR;
     if (fread(buf,9,1,fp) == 0) goto eoferr;

-    if (memcmp(buf,"REDIS0000",9) != 0) {
+    buf[9] = '\0';
+    if (memcmp(buf,"REDIS",5) != 0) {

         fclose(fp);
         redisLog(REDIS_WARNING,"Wrong signature trying to load DB from file");
         return REDIS_ERR;
     }
         fclose(fp);
         redisLog(REDIS_WARNING,"Wrong signature trying to load DB from file");
         return REDIS_ERR;
     }

+    rdbver = atoi(buf+5);
+    if (rdbver > 1) {
+        fclose(fp);
+        redisLog(REDIS_WARNING,"Can't handle RDB format version %d",rdbver);
+        return REDIS_ERR;
+    }

     while(1) {
         robj *o;
 
         /* Read type. */
     while(1) {
         robj *o;
 
         /* Read type. */

-        if (fread(&type,1,1,fp) == 0) goto eoferr;
+        if ((type = rdbLoadType(fp)) == -1) goto eoferr;
+        if (type == REDIS_EXPIRETIME) {
+            if ((expiretime = rdbLoadTime(fp)) == -1) goto eoferr;
+            /* We read the time so we need to read the object type again */
+            if ((type = rdbLoadType(fp)) == -1) goto eoferr;
+        }

         if (type == REDIS_EOF) break;
         /* Handle SELECT DB opcode as a special case */
         if (type == REDIS_SELECTDB) {
         if (type == REDIS_EOF) break;
         /* Handle SELECT DB opcode as a special case */
         if (type == REDIS_SELECTDB) {

-            if (fread(&dbid,4,1,fp) == 0) goto eoferr;
-            dbid = ntohl(dbid);
+            if ((dbid = rdbLoadLen(fp,rdbver,NULL)) == REDIS_RDB_LENERR)
+                goto eoferr;

             if (dbid >= (unsigned)server.dbnum) {
             if (dbid >= (unsigned)server.dbnum) {

-                redisLog(REDIS_WARNING,"FATAL: Data file was created with a Redis server compiled to handle more than %d databases. Exiting\n", server.dbnum);
+                redisLog(REDIS_WARNING,"FATAL: Data file was created with a Redis server configured to handle more than %d databases. Exiting\n", server.dbnum);

                 exit(1);
             }
                 exit(1);
             }

-            d = server.dict[dbid];
+            db = server.db+dbid;
+            d = db->dict;

             continue;
         }
         /* Read key */
             continue;
         }
         /* Read key */

-        if (fread(&klen,4,1,fp) == 0) goto eoferr;
-        klen = ntohl(klen);
-        if (klen <= REDIS_LOADBUF_LEN) {
-            key = buf;
-        } else {
-            key = zmalloc(klen);
-            if (!key) oom("Loading DB from file");
-        }
-        if (fread(key,klen,1,fp) == 0) goto eoferr;
+        if ((keyobj = rdbLoadStringObject(fp,rdbver)) == NULL) goto eoferr;

 
         if (type == REDIS_STRING) {
             /* Read string value */
 
         if (type == REDIS_STRING) {
             /* Read string value */

-            if (fread(&vlen,4,1,fp) == 0) goto eoferr;
-            vlen = ntohl(vlen);
-            if (vlen <= REDIS_LOADBUF_LEN) {
-                val = vbuf;
-            } else {
-                val = zmalloc(vlen);
-                if (!val) oom("Loading DB from file");
-            }
-            if (vlen && fread(val,vlen,1,fp) == 0) goto eoferr;
-            o = createObject(REDIS_STRING,sdsnewlen(val,vlen));
+            if ((o = rdbLoadStringObject(fp,rdbver)) == NULL) goto eoferr;

         } else if (type == REDIS_LIST || type == REDIS_SET) {
             /* Read list/set value */
             uint32_t listlen;
         } else if (type == REDIS_LIST || type == REDIS_SET) {
             /* Read list/set value */
             uint32_t listlen;

-            if (fread(&listlen,4,1,fp) == 0) goto eoferr;
-            listlen = ntohl(listlen);
+
+            if ((listlen = rdbLoadLen(fp,rdbver,NULL)) == REDIS_RDB_LENERR)
+                goto eoferr;

             o = (type == REDIS_LIST) ? createListObject() : createSetObject();
             /* Load every single element of the list/set */
             while(listlen--) {
                 robj *ele;
 
             o = (type == REDIS_LIST) ? createListObject() : createSetObject();
             /* Load every single element of the list/set */
             while(listlen--) {
                 robj *ele;
 

-                if (fread(&vlen,4,1,fp) == 0) goto eoferr;
-                vlen = ntohl(vlen);
-                if (vlen <= REDIS_LOADBUF_LEN) {
-                    val = vbuf;
-                } else {
-                    val = zmalloc(vlen);
-                    if (!val) oom("Loading DB from file");
-                }
-                if (vlen && fread(val,vlen,1,fp) == 0) goto eoferr;
-                ele = createObject(REDIS_STRING,sdsnewlen(val,vlen));
+                if ((ele = rdbLoadStringObject(fp,rdbver)) == NULL) goto eoferr;

                 if (type == REDIS_LIST) {
                     if (!listAddNodeTail((list*)o->ptr,ele))
                         oom("listAddNodeTail");
                 if (type == REDIS_LIST) {
                     if (!listAddNodeTail((list*)o->ptr,ele))
                         oom("listAddNodeTail");


@@ -1611,43 +2231,53 @@ static int loadDb(char *filename) {
                     if (dictAdd((dict*)o->ptr,ele,NULL) == DICT_ERR)
                         oom("dictAdd");
                 }
                     if (dictAdd((dict*)o->ptr,ele,NULL) == DICT_ERR)
                         oom("dictAdd");
                 }

-                /* free the temp buffer if needed */
-                if (val != vbuf) zfree(val);
-                val = NULL;

             }
         } else {
             assert(0 != 0);
         }
         /* Add the new object in the hash table */
             }
         } else {
             assert(0 != 0);
         }
         /* Add the new object in the hash table */

-        retval = dictAdd(d,createStringObject(key,klen),o);
+        retval = dictAdd(d,keyobj,o);

         if (retval == DICT_ERR) {
         if (retval == DICT_ERR) {

-            redisLog(REDIS_WARNING,"Loading DB, duplicated key found! Unrecoverable error, exiting now.");
+            redisLog(REDIS_WARNING,"Loading DB, duplicated key (%s) found! Unrecoverable error, exiting now.", keyobj->ptr);

             exit(1);
         }
             exit(1);
         }

-        /* Iteration cleanup */
-        if (key != buf) zfree(key);
-        if (val != vbuf) zfree(val);
-        key = val = NULL;
+        /* Set the expire time if needed */
+        if (expiretime != -1) {
+            setExpire(db,keyobj,expiretime);
+            /* Delete this key if already expired */
+            if (expiretime < now) deleteKey(db,keyobj);
+            expiretime = -1;
+        }
+        keyobj = o = NULL;

     }
     fclose(fp);
     return REDIS_OK;
 
 eoferr: /* unexpected end of file is handled here with a fatal exit */
     }
     fclose(fp);
     return REDIS_OK;
 
 eoferr: /* unexpected end of file is handled here with a fatal exit */

-    if (key != buf) zfree(key);
-    if (val != vbuf) zfree(val);
-    redisLog(REDIS_WARNING,"Short read loading DB. Unrecoverable error, exiting now.");
+    if (keyobj) decrRefCount(keyobj);
+    redisLog(REDIS_WARNING,"Short read or OOM loading DB. Unrecoverable error, exiting now.");

     exit(1);
     return REDIS_ERR; /* Just to avoid warning */
 }
 
 /*================================== Commands =============================== */
 
     exit(1);
     return REDIS_ERR; /* Just to avoid warning */
 }
 
 /*================================== Commands =============================== */
 

+static void authCommand(redisClient *c) {
+    if (!server.requirepass || !strcmp(c->argv[1]->ptr, server.requirepass)) {
+      c->authenticated = 1;
+      addReply(c,shared.ok);
+    } else {
+      c->authenticated = 0;
+      addReply(c,shared.err);
+    }
+}
+

 static void pingCommand(redisClient *c) {
     addReply(c,shared.pong);
 }
 
 static void echoCommand(redisClient *c) {
 static void pingCommand(redisClient *c) {
     addReply(c,shared.pong);
 }
 
 static void echoCommand(redisClient *c) {

-    addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",
+    addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",

         (int)sdslen(c->argv[1]->ptr)));
     addReply(c,c->argv[1]);
     addReply(c,shared.crlf);
         (int)sdslen(c->argv[1]->ptr)));
     addReply(c,c->argv[1]);
     addReply(c,shared.crlf);


@@ -1658,13 +2288,13 @@ static void echoCommand(redisClient *c) {
 static void setGenericCommand(redisClient *c, int nx) {
     int retval;
 
 static void setGenericCommand(redisClient *c, int nx) {
     int retval;
 

-    retval = dictAdd(c->dict,c->argv[1],c->argv[2]);
+    retval = dictAdd(c->db->dict,c->argv[1],c->argv[2]);

     if (retval == DICT_ERR) {
         if (!nx) {
     if (retval == DICT_ERR) {
         if (!nx) {

-            dictReplace(c->dict,c->argv[1],c->argv[2]);
+            dictReplace(c->db->dict,c->argv[1],c->argv[2]);

             incrRefCount(c->argv[2]);
         } else {
             incrRefCount(c->argv[2]);
         } else {

-            addReply(c,shared.zero);
+            addReply(c,shared.czero);

             return;
         }
     } else {
             return;
         }
     } else {


@@ -1672,52 +2302,59 @@ static void setGenericCommand(redisClient *c, int nx) {
         incrRefCount(c->argv[2]);
     }
     server.dirty++;
         incrRefCount(c->argv[2]);
     }
     server.dirty++;

-    addReply(c, nx ? shared.one : shared.ok);
+    removeExpire(c->db,c->argv[1]);
+    addReply(c, nx ? shared.cone : shared.ok);

 }
 
 static void setCommand(redisClient *c) {
 }
 
 static void setCommand(redisClient *c) {

-    return setGenericCommand(c,0);
+    setGenericCommand(c,0);

 }
 
 static void setnxCommand(redisClient *c) {
 }
 
 static void setnxCommand(redisClient *c) {

-    return setGenericCommand(c,1);
+    setGenericCommand(c,1);

 }
 
 static void getCommand(redisClient *c) {
 }
 
 static void getCommand(redisClient *c) {

-    dictEntry *de;
-    
-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL) {
-        addReply(c,shared.nil);
+    robj *o = lookupKeyRead(c->db,c->argv[1]);
+
+    if (o == NULL) {
+        addReply(c,shared.nullbulk);

     } else {
     } else {

-        robj *o = dictGetEntryVal(de);
-        

         if (o->type != REDIS_STRING) {
         if (o->type != REDIS_STRING) {

-            addReply(c,shared.wrongtypeerrbulk);
+            addReply(c,shared.wrongtypeerr);

         } else {
         } else {

-            addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",(int)sdslen(o->ptr)));
+            addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(o->ptr)));

             addReply(c,o);
             addReply(c,shared.crlf);
         }
     }
 }
 
             addReply(c,o);
             addReply(c,shared.crlf);
         }
     }
 }
 

+static void getSetCommand(redisClient *c) {
+    getCommand(c);
+    if (dictAdd(c->db->dict,c->argv[1],c->argv[2]) == DICT_ERR) {
+        dictReplace(c->db->dict,c->argv[1],c->argv[2]);
+    } else {
+        incrRefCount(c->argv[1]);
+    }
+    incrRefCount(c->argv[2]);
+    server.dirty++;
+    removeExpire(c->db,c->argv[1]);
+}
+

 static void mgetCommand(redisClient *c) {
 static void mgetCommand(redisClient *c) {

-    dictEntry *de;

     int j;
   
     int j;
   

-    addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",c->argc-1));
+    addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",c->argc-1));

     for (j = 1; j < c->argc; j++) {
     for (j = 1; j < c->argc; j++) {

-        de = dictFind(c->dict,c->argv[j]);
-        if (de == NULL) {
-            addReply(c,shared.minus1);
+        robj *o = lookupKeyRead(c->db,c->argv[j]);
+        if (o == NULL) {
+            addReply(c,shared.nullbulk);

         } else {
         } else {

-            robj *o = dictGetEntryVal(de);
-            

             if (o->type != REDIS_STRING) {
             if (o->type != REDIS_STRING) {

-                addReply(c,shared.minus1);
+                addReply(c,shared.nullbulk);

             } else {
             } else {

-                addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",(int)sdslen(o->ptr)));
+                addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(o->ptr)));

                 addReply(c,o);
                 addReply(c,shared.crlf);
             }
                 addReply(c,o);
                 addReply(c,shared.crlf);
             }


@@ -1725,18 +2362,15 @@ static void mgetCommand(redisClient *c) {
     }
 }
 
     }
 }
 

-static void incrDecrCommand(redisClient *c, int incr) {
-    dictEntry *de;
+static void incrDecrCommand(redisClient *c, long long incr) {

     long long value;
     int retval;
     robj *o;
     
     long long value;
     int retval;
     robj *o;
     

-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL) {
+    o = lookupKeyWrite(c->db,c->argv[1]);
+    if (o == NULL) {

         value = 0;
     } else {
         value = 0;
     } else {

-        robj *o = dictGetEntryVal(de);
-        

         if (o->type != REDIS_STRING) {
             value = 0;
         } else {
         if (o->type != REDIS_STRING) {
             value = 0;
         } else {


@@ -1748,61 +2382,70 @@ static void incrDecrCommand(redisClient *c, int incr) {
 
     value += incr;
     o = createObject(REDIS_STRING,sdscatprintf(sdsempty(),"%lld",value));
 
     value += incr;
     o = createObject(REDIS_STRING,sdscatprintf(sdsempty(),"%lld",value));

-    retval = dictAdd(c->dict,c->argv[1],o);
+    retval = dictAdd(c->db->dict,c->argv[1],o);

     if (retval == DICT_ERR) {
     if (retval == DICT_ERR) {

-        dictReplace(c->dict,c->argv[1],o);
+        dictReplace(c->db->dict,c->argv[1],o);
+        removeExpire(c->db,c->argv[1]);

     } else {
         incrRefCount(c->argv[1]);
     }
     server.dirty++;
     } else {
         incrRefCount(c->argv[1]);
     }
     server.dirty++;

+    addReply(c,shared.colon);

     addReply(c,o);
     addReply(c,shared.crlf);
 }
 
 static void incrCommand(redisClient *c) {
     addReply(c,o);
     addReply(c,shared.crlf);
 }
 
 static void incrCommand(redisClient *c) {

-    return incrDecrCommand(c,1);
+    incrDecrCommand(c,1);

 }
 
 static void decrCommand(redisClient *c) {
 }
 
 static void decrCommand(redisClient *c) {

-    return incrDecrCommand(c,-1);
+    incrDecrCommand(c,-1);

 }
 
 static void incrbyCommand(redisClient *c) {
 }
 
 static void incrbyCommand(redisClient *c) {

-    int incr = atoi(c->argv[2]->ptr);
-    return incrDecrCommand(c,incr);
+    long long incr = strtoll(c->argv[2]->ptr, NULL, 10);
+    incrDecrCommand(c,incr);

 }
 
 static void decrbyCommand(redisClient *c) {
 }
 
 static void decrbyCommand(redisClient *c) {

-    int incr = atoi(c->argv[2]->ptr);
-    return incrDecrCommand(c,-incr);
+    long long incr = strtoll(c->argv[2]->ptr, NULL, 10);
+    incrDecrCommand(c,-incr);

 }
 
 /* ========================= Type agnostic commands ========================= */
 
 static void delCommand(redisClient *c) {
 }
 
 /* ========================= Type agnostic commands ========================= */
 
 static void delCommand(redisClient *c) {

-    if (dictDelete(c->dict,c->argv[1]) == DICT_OK) {
-        server.dirty++;
-        addReply(c,shared.one);
-    } else {
-        addReply(c,shared.zero);
+    int deleted = 0, j;
+
+    for (j = 1; j < c->argc; j++) {
+        if (deleteKey(c->db,c->argv[j])) {
+            server.dirty++;
+            deleted++;
+        }
+    }
+    switch(deleted) {
+    case 0:
+        addReply(c,shared.czero);
+        break;
+    case 1:
+        addReply(c,shared.cone);
+        break;
+    default:
+        addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",deleted));
+        break;

     }
 }
 
 static void existsCommand(redisClient *c) {
     }
 }
 
 static void existsCommand(redisClient *c) {

-    dictEntry *de;
-    
-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL)
-        addReply(c,shared.zero);
-    else
-        addReply(c,shared.one);
+    addReply(c,lookupKeyRead(c->db,c->argv[1]) ? shared.cone : shared.czero);

 }
 
 static void selectCommand(redisClient *c) {
     int id = atoi(c->argv[1]->ptr);
     
     if (selectDb(c,id) == REDIS_ERR) {
 }
 
 static void selectCommand(redisClient *c) {
     int id = atoi(c->argv[1]->ptr);
     
     if (selectDb(c,id) == REDIS_ERR) {

-        addReplySds(c,"-ERR invalid DB index\r\n");
+        addReplySds(c,sdsnew("-ERR invalid DB index\r\n"));

     } else {
         addReply(c,shared.ok);
     }
     } else {
         addReply(c,shared.ok);
     }


@@ -1810,11 +2453,16 @@ static void selectCommand(redisClient *c) {
 
 static void randomkeyCommand(redisClient *c) {
     dictEntry *de;
 
 static void randomkeyCommand(redisClient *c) {
     dictEntry *de;

-    
-    de = dictGetRandomKey(c->dict);
+   
+    while(1) {
+        de = dictGetRandomKey(c->db->dict);
+        if (!de || expireIfNeeded(c->db,dictGetEntryKey(de)) == 0) break;
+    }

     if (de == NULL) {
     if (de == NULL) {

+        addReply(c,shared.plus);

         addReply(c,shared.crlf);
     } else {
         addReply(c,shared.crlf);
     } else {

+        addReply(c,shared.plus);

         addReply(c,dictGetEntryKey(de));
         addReply(c,shared.crlf);
     }
         addReply(c,dictGetEntryKey(de));
         addReply(c,shared.crlf);
     }


@@ -1828,51 +2476,52 @@ static void keysCommand(redisClient *c) {
     int numkeys = 0, keyslen = 0;
     robj *lenobj = createObject(REDIS_STRING,NULL);
 
     int numkeys = 0, keyslen = 0;
     robj *lenobj = createObject(REDIS_STRING,NULL);
 

-    di = dictGetIterator(c->dict);
+    di = dictGetIterator(c->db->dict);

     if (!di) oom("dictGetIterator");
     addReply(c,lenobj);
     decrRefCount(lenobj);
     while((de = dictNext(di)) != NULL) {
         robj *keyobj = dictGetEntryKey(de);
     if (!di) oom("dictGetIterator");
     addReply(c,lenobj);
     decrRefCount(lenobj);
     while((de = dictNext(di)) != NULL) {
         robj *keyobj = dictGetEntryKey(de);

+

         sds key = keyobj->ptr;
         if ((pattern[0] == '*' && pattern[1] == '\0') ||
             stringmatchlen(pattern,plen,key,sdslen(key),0)) {
         sds key = keyobj->ptr;
         if ((pattern[0] == '*' && pattern[1] == '\0') ||
             stringmatchlen(pattern,plen,key,sdslen(key),0)) {

-            if (numkeys != 0)
-                addReply(c,shared.space);
-            addReply(c,keyobj);
-            numkeys++;
-            keyslen += sdslen(key);
+            if (expireIfNeeded(c->db,keyobj) == 0) {
+                if (numkeys != 0)
+                    addReply(c,shared.space);
+                addReply(c,keyobj);
+                numkeys++;
+                keyslen += sdslen(key);
+            }

         }
     }
     dictReleaseIterator(di);
         }
     }
     dictReleaseIterator(di);

-    lenobj->ptr = sdscatprintf(sdsempty(),"%lu\r\n",keyslen+(numkeys ? (numkeys-1) : 0));
+    lenobj->ptr = sdscatprintf(sdsempty(),"$%lu\r\n",keyslen+(numkeys ? (numkeys-1) : 0));

     addReply(c,shared.crlf);
 }
 
 static void dbsizeCommand(redisClient *c) {
     addReplySds(c,
     addReply(c,shared.crlf);
 }
 
 static void dbsizeCommand(redisClient *c) {
     addReplySds(c,

-        sdscatprintf(sdsempty(),"%lu\r\n",dictGetHashTableUsed(c->dict)));
+        sdscatprintf(sdsempty(),":%lu\r\n",dictSize(c->db->dict)));

 }
 
 static void lastsaveCommand(redisClient *c) {
     addReplySds(c,
 }
 
 static void lastsaveCommand(redisClient *c) {
     addReplySds(c,

-        sdscatprintf(sdsempty(),"%lu\r\n",server.lastsave));
+        sdscatprintf(sdsempty(),":%lu\r\n",server.lastsave));

 }
 
 static void typeCommand(redisClient *c) {
 }
 
 static void typeCommand(redisClient *c) {

-    dictEntry *de;
+    robj *o;

     char *type;
     char *type;

-    
-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL) {
-        type = "none";
+
+    o = lookupKeyRead(c->db,c->argv[1]);
+    if (o == NULL) {
+        type = "+none";

     } else {
     } else {

-        robj *o = dictGetEntryVal(de);
-        

         switch(o->type) {
         switch(o->type) {

-        case REDIS_STRING: type = "string"; break;
-        case REDIS_LIST: type = "list"; break;
-        case REDIS_SET: type = "set"; break;
+        case REDIS_STRING: type = "+string"; break;
+        case REDIS_LIST: type = "+list"; break;
+        case REDIS_SET: type = "+set"; break;

         default: type = "unknown"; break;
         }
     }
         default: type = "unknown"; break;
         }
     }


@@ -1881,7 +2530,11 @@ static void typeCommand(redisClient *c) {
 }
 
 static void saveCommand(redisClient *c) {
 }
 
 static void saveCommand(redisClient *c) {

-    if (saveDb(server.dbfilename) == REDIS_OK) {
+    if (server.bgsaveinprogress) {
+        addReplySds(c,sdsnew("-ERR background save in progress\r\n"));
+        return;
+    }
+    if (rdbSave(server.dbfilename) == REDIS_OK) {

         addReply(c,shared.ok);
     } else {
         addReply(c,shared.err);
         addReply(c,shared.ok);
     } else {
         addReply(c,shared.err);


@@ -1893,7 +2546,7 @@ static void bgsaveCommand(redisClient *c) {
         addReplySds(c,sdsnew("-ERR background save already in progress\r\n"));
         return;
     }
         addReplySds(c,sdsnew("-ERR background save already in progress\r\n"));
         return;
     }

-    if (saveDbBackground(server.dbfilename) == REDIS_OK) {
+    if (rdbSaveBackground(server.dbfilename) == REDIS_OK) {

         addReply(c,shared.ok);
     } else {
         addReply(c,shared.err);
         addReply(c,shared.ok);
     } else {
         addReply(c,shared.err);


@@ -1902,54 +2555,60 @@ static void bgsaveCommand(redisClient *c) {
 
 static void shutdownCommand(redisClient *c) {
     redisLog(REDIS_WARNING,"User requested shutdown, saving DB...");
 
 static void shutdownCommand(redisClient *c) {
     redisLog(REDIS_WARNING,"User requested shutdown, saving DB...");

-    if (saveDb(server.dbfilename) == REDIS_OK) {
-        if (server.daemonize) {
-          unlink(server.pidfile);
-        }
+    /* Kill the saving child if there is a background saving in progress.
+       We want to avoid race conditions, for instance our saving child may
+       overwrite the synchronous saving did by SHUTDOWN. */
+    if (server.bgsaveinprogress) {
+        redisLog(REDIS_WARNING,"There is a live saving child. Killing it!");
+        kill(server.bgsavechildpid,SIGKILL);
+        rdbRemoveTempFile(server.bgsavechildpid);
+    }
+    /* SYNC SAVE */
+    if (rdbSave(server.dbfilename) == REDIS_OK) {
+        if (server.daemonize)
+            unlink(server.pidfile);
+        redisLog(REDIS_WARNING,"%zu bytes used at exit",zmalloc_used_memory());

         redisLog(REDIS_WARNING,"Server exit now, bye bye...");
         exit(1);
     } else {
         redisLog(REDIS_WARNING,"Server exit now, bye bye...");
         exit(1);
     } else {

+        /* Ooops.. error saving! The best we can do is to continue operating.
+         * Note that if there was a background saving process, in the next
+         * cron() Redis will be notified that the background saving aborted,
+         * handling special stuff like slaves pending for synchronization... */

         redisLog(REDIS_WARNING,"Error trying to save the DB, can't exit"); 
         addReplySds(c,sdsnew("-ERR can't quit, problems saving the DB\r\n"));
     }
 }
 
 static void renameGenericCommand(redisClient *c, int nx) {
         redisLog(REDIS_WARNING,"Error trying to save the DB, can't exit"); 
         addReplySds(c,sdsnew("-ERR can't quit, problems saving the DB\r\n"));
     }
 }
 
 static void renameGenericCommand(redisClient *c, int nx) {

-    dictEntry *de;

     robj *o;
 
     /* To use the same key as src and dst is probably an error */
     if (sdscmp(c->argv[1]->ptr,c->argv[2]->ptr) == 0) {
     robj *o;
 
     /* To use the same key as src and dst is probably an error */
     if (sdscmp(c->argv[1]->ptr,c->argv[2]->ptr) == 0) {

-        if (nx)
-            addReply(c,shared.minus3);
-        else
-            addReplySds(c,sdsnew("-ERR src and dest key are the same\r\n"));
+        addReply(c,shared.sameobjecterr);

         return;
     }
 
         return;
     }
 

-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL) {
-        if (nx)
-            addReply(c,shared.minus1);
-        else
-            addReply(c,shared.nokeyerr);
+    o = lookupKeyWrite(c->db,c->argv[1]);
+    if (o == NULL) {
+        addReply(c,shared.nokeyerr);

         return;
     }
         return;
     }

-    o = dictGetEntryVal(de);

     incrRefCount(o);
     incrRefCount(o);

-    if (dictAdd(c->dict,c->argv[2],o) == DICT_ERR) {
+    deleteIfVolatile(c->db,c->argv[2]);
+    if (dictAdd(c->db->dict,c->argv[2],o) == DICT_ERR) {

         if (nx) {
             decrRefCount(o);
         if (nx) {
             decrRefCount(o);

-            addReply(c,shared.zero);
+            addReply(c,shared.czero);

             return;
         }
             return;
         }

-        dictReplace(c->dict,c->argv[2],o);
+        dictReplace(c->db->dict,c->argv[2],o);

     } else {
         incrRefCount(c->argv[2]);
     }
     } else {
         incrRefCount(c->argv[2]);
     }

-    dictDelete(c->dict,c->argv[1]);
+    deleteKey(c->db,c->argv[1]);

     server.dirty++;
     server.dirty++;

-    addReply(c,nx ? shared.one : shared.ok);
+    addReply(c,nx ? shared.cone : shared.ok);

 }
 
 static void renameCommand(redisClient *c) {
 }
 
 static void renameCommand(redisClient *c) {


@@ -1961,60 +2620,56 @@ static void renamenxCommand(redisClient *c) {
 }
 
 static void moveCommand(redisClient *c) {
 }
 
 static void moveCommand(redisClient *c) {

-    dictEntry *de;
-    robj *o, *key;
-    dict *src, *dst;
+    robj *o;
+    redisDb *src, *dst;

     int srcid;
 
     /* Obtain source and target DB pointers */
     int srcid;
 
     /* Obtain source and target DB pointers */

-    src = c->dict;
-    srcid = c->dictid;
+    src = c->db;
+    srcid = c->db->id;

     if (selectDb(c,atoi(c->argv[2]->ptr)) == REDIS_ERR) {
     if (selectDb(c,atoi(c->argv[2]->ptr)) == REDIS_ERR) {

-        addReply(c,shared.minus4);
+        addReply(c,shared.outofrangeerr);

         return;
     }
         return;
     }

-    dst = c->dict;
-    c->dict = src;
-    c->dictid = srcid;
+    dst = c->db;
+    selectDb(c,srcid); /* Back to the source DB */

 
     /* If the user is moving using as target the same
      * DB as the source DB it is probably an error. */
     if (src == dst) {
 
     /* If the user is moving using as target the same
      * DB as the source DB it is probably an error. */
     if (src == dst) {

-        addReply(c,shared.minus3);
+        addReply(c,shared.sameobjecterr);

         return;
     }
 
     /* Check if the element exists and get a reference */
         return;
     }
 
     /* Check if the element exists and get a reference */

-    de = dictFind(c->dict,c->argv[1]);
-    if (!de) {
-        addReply(c,shared.zero);
+    o = lookupKeyWrite(c->db,c->argv[1]);
+    if (!o) {
+        addReply(c,shared.czero);

         return;
     }
 
     /* Try to add the element to the target DB */
         return;
     }
 
     /* Try to add the element to the target DB */

-    key = dictGetEntryKey(de);
-    o = dictGetEntryVal(de);
-    if (dictAdd(dst,key,o) == DICT_ERR) {
-        addReply(c,shared.zero);
+    deleteIfVolatile(dst,c->argv[1]);
+    if (dictAdd(dst->dict,c->argv[1],o) == DICT_ERR) {
+        addReply(c,shared.czero);

         return;
     }
         return;
     }

-    incrRefCount(key);
+    incrRefCount(c->argv[1]);

     incrRefCount(o);
 
     /* OK! key moved, free the entry in the source DB */
     incrRefCount(o);
 
     /* OK! key moved, free the entry in the source DB */

-    dictDelete(src,c->argv[1]);
+    deleteKey(src,c->argv[1]);

     server.dirty++;
     server.dirty++;

-    addReply(c,shared.one);
+    addReply(c,shared.cone);

 }
 
 /* =================================== Lists ================================ */
 static void pushGenericCommand(redisClient *c, int where) {
     robj *lobj;
 }
 
 /* =================================== Lists ================================ */
 static void pushGenericCommand(redisClient *c, int where) {
     robj *lobj;

-    dictEntry *de;

     list *list;
     list *list;

-    
-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL) {
+
+    lobj = lookupKeyWrite(c->db,c->argv[1]);
+    if (lobj == NULL) {

         lobj = createListObject();
         list = lobj->ptr;
         if (where == REDIS_HEAD) {
         lobj = createListObject();
         list = lobj->ptr;
         if (where == REDIS_HEAD) {


@@ -2022,11 +2677,10 @@ static void pushGenericCommand(redisClient *c, int where) {
         } else {
             if (!listAddNodeTail(list,c->argv[2])) oom("listAddNodeTail");
         }
         } else {
             if (!listAddNodeTail(list,c->argv[2])) oom("listAddNodeTail");
         }

-        dictAdd(c->dict,c->argv[1],lobj);
+        dictAdd(c->db->dict,c->argv[1],lobj);

         incrRefCount(c->argv[1]);
         incrRefCount(c->argv[2]);
     } else {
         incrRefCount(c->argv[1]);
         incrRefCount(c->argv[2]);
     } else {

-        lobj = dictGetEntryVal(de);

         if (lobj->type != REDIS_LIST) {
             addReply(c,shared.wrongtypeerr);
             return;
         if (lobj->type != REDIS_LIST) {
             addReply(c,shared.wrongtypeerr);
             return;


@@ -2052,46 +2706,43 @@ static void rpushCommand(redisClient *c) {
 }
 
 static void llenCommand(redisClient *c) {
 }
 
 static void llenCommand(redisClient *c) {

-    dictEntry *de;
+    robj *o;

     list *l;
     
     list *l;
     

-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL) {
-        addReply(c,shared.zero);
+    o = lookupKeyRead(c->db,c->argv[1]);
+    if (o == NULL) {
+        addReply(c,shared.czero);

         return;
     } else {
         return;
     } else {

-        robj *o = dictGetEntryVal(de);

         if (o->type != REDIS_LIST) {
         if (o->type != REDIS_LIST) {

-            addReply(c,shared.minus2);
+            addReply(c,shared.wrongtypeerr);

         } else {
             l = o->ptr;
         } else {
             l = o->ptr;

-            addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",listLength(l)));
+            addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",listLength(l)));

         }
     }
 }
 
 static void lindexCommand(redisClient *c) {
         }
     }
 }
 
 static void lindexCommand(redisClient *c) {

-    dictEntry *de;
+    robj *o;

     int index = atoi(c->argv[2]->ptr);
     
     int index = atoi(c->argv[2]->ptr);
     

-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL) {
-        addReply(c,shared.nil);
+    o = lookupKeyRead(c->db,c->argv[1]);
+    if (o == NULL) {
+        addReply(c,shared.nullbulk);

     } else {
     } else {

-        robj *o = dictGetEntryVal(de);
-        

         if (o->type != REDIS_LIST) {
         if (o->type != REDIS_LIST) {

-            addReply(c,shared.wrongtypeerrbulk);
+            addReply(c,shared.wrongtypeerr);

         } else {
             list *list = o->ptr;
             listNode *ln;
             
             ln = listIndex(list, index);
             if (ln == NULL) {
         } else {
             list *list = o->ptr;
             listNode *ln;
             
             ln = listIndex(list, index);
             if (ln == NULL) {

-                addReply(c,shared.nil);
+                addReply(c,shared.nullbulk);

             } else {
                 robj *ele = listNodeValue(ln);
             } else {
                 robj *ele = listNodeValue(ln);

-                addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",(int)sdslen(ele->ptr)));
+                addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(ele->ptr)));

                 addReply(c,ele);
                 addReply(c,shared.crlf);
             }
                 addReply(c,ele);
                 addReply(c,shared.crlf);
             }


@@ -2100,15 +2751,13 @@ static void lindexCommand(redisClient *c) {
 }
 
 static void lsetCommand(redisClient *c) {
 }
 
 static void lsetCommand(redisClient *c) {

-    dictEntry *de;
+    robj *o;

     int index = atoi(c->argv[2]->ptr);
     
     int index = atoi(c->argv[2]->ptr);
     

-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL) {
+    o = lookupKeyWrite(c->db,c->argv[1]);
+    if (o == NULL) {

         addReply(c,shared.nokeyerr);
     } else {
         addReply(c,shared.nokeyerr);
     } else {

-        robj *o = dictGetEntryVal(de);
-        

         if (o->type != REDIS_LIST) {
             addReply(c,shared.wrongtypeerr);
         } else {
         if (o->type != REDIS_LIST) {
             addReply(c,shared.wrongtypeerr);
         } else {


@@ -2117,7 +2766,7 @@ static void lsetCommand(redisClient *c) {
             
             ln = listIndex(list, index);
             if (ln == NULL) {
             
             ln = listIndex(list, index);
             if (ln == NULL) {

-                addReplySds(c,sdsnew("-ERR index out of range\r\n"));
+                addReply(c,shared.outofrangeerr);

             } else {
                 robj *ele = listNodeValue(ln);
 
             } else {
                 robj *ele = listNodeValue(ln);
 


@@ -2132,16 +2781,14 @@ static void lsetCommand(redisClient *c) {
 }
 
 static void popGenericCommand(redisClient *c, int where) {
 }
 
 static void popGenericCommand(redisClient *c, int where) {

-    dictEntry *de;
-    
-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL) {
-        addReply(c,shared.nil);
+    robj *o;
+
+    o = lookupKeyWrite(c->db,c->argv[1]);
+    if (o == NULL) {
+        addReply(c,shared.nullbulk);

     } else {
     } else {

-        robj *o = dictGetEntryVal(de);
-        

         if (o->type != REDIS_LIST) {
         if (o->type != REDIS_LIST) {

-            addReply(c,shared.wrongtypeerrbulk);
+            addReply(c,shared.wrongtypeerr);

         } else {
             list *list = o->ptr;
             listNode *ln;
         } else {
             list *list = o->ptr;
             listNode *ln;


@@ -2152,10 +2799,10 @@ static void popGenericCommand(redisClient *c, int where) {
                 ln = listLast(list);
 
             if (ln == NULL) {
                 ln = listLast(list);
 
             if (ln == NULL) {

-                addReply(c,shared.nil);
+                addReply(c,shared.nullbulk);

             } else {
                 robj *ele = listNodeValue(ln);
             } else {
                 robj *ele = listNodeValue(ln);

-                addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",(int)sdslen(ele->ptr)));
+                addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(ele->ptr)));

                 addReply(c,ele);
                 addReply(c,shared.crlf);
                 listDelNode(list,ln);
                 addReply(c,ele);
                 addReply(c,shared.crlf);
                 listDelNode(list,ln);


@@ -2174,18 +2821,16 @@ static void rpopCommand(redisClient *c) {
 }
 
 static void lrangeCommand(redisClient *c) {
 }
 
 static void lrangeCommand(redisClient *c) {

-    dictEntry *de;
+    robj *o;

     int start = atoi(c->argv[2]->ptr);
     int end = atoi(c->argv[3]->ptr);
     int start = atoi(c->argv[2]->ptr);
     int end = atoi(c->argv[3]->ptr);

-    
-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL) {
-        addReply(c,shared.nil);
+
+    o = lookupKeyRead(c->db,c->argv[1]);
+    if (o == NULL) {
+        addReply(c,shared.nullmultibulk);

     } else {
     } else {

-        robj *o = dictGetEntryVal(de);
-        

         if (o->type != REDIS_LIST) {
         if (o->type != REDIS_LIST) {

-            addReply(c,shared.wrongtypeerrbulk);
+            addReply(c,shared.wrongtypeerr);

         } else {
             list *list = o->ptr;
             listNode *ln;
         } else {
             list *list = o->ptr;
             listNode *ln;


@@ -2202,7 +2847,7 @@ static void lrangeCommand(redisClient *c) {
             /* indexes sanity checks */
             if (start > end || start >= llen) {
                 /* Out of range start or start > end result in empty list */
             /* indexes sanity checks */
             if (start > end || start >= llen) {
                 /* Out of range start or start > end result in empty list */

-                addReply(c,shared.zero);
+                addReply(c,shared.emptymultibulk);

                 return;
             }
             if (end >= llen) end = llen-1;
                 return;
             }
             if (end >= llen) end = llen-1;


@@ -2210,10 +2855,10 @@ static void lrangeCommand(redisClient *c) {
 
             /* Return the result in form of a multi-bulk reply */
             ln = listIndex(list, start);
 
             /* Return the result in form of a multi-bulk reply */
             ln = listIndex(list, start);

-            addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",rangelen));
+            addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",rangelen));

             for (j = 0; j < rangelen; j++) {
                 ele = listNodeValue(ln);
             for (j = 0; j < rangelen; j++) {
                 ele = listNodeValue(ln);

-                addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",(int)sdslen(ele->ptr)));
+                addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(ele->ptr)));

                 addReply(c,ele);
                 addReply(c,shared.crlf);
                 ln = ln->next;
                 addReply(c,ele);
                 addReply(c,shared.crlf);
                 ln = ln->next;


@@ -2223,16 +2868,14 @@ static void lrangeCommand(redisClient *c) {
 }
 
 static void ltrimCommand(redisClient *c) {
 }
 
 static void ltrimCommand(redisClient *c) {

-    dictEntry *de;
+    robj *o;

     int start = atoi(c->argv[2]->ptr);
     int end = atoi(c->argv[3]->ptr);
     
     int start = atoi(c->argv[2]->ptr);
     int end = atoi(c->argv[3]->ptr);
     

-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL) {
+    o = lookupKeyWrite(c->db,c->argv[1]);
+    if (o == NULL) {

         addReply(c,shared.nokeyerr);
     } else {
         addReply(c,shared.nokeyerr);
     } else {

-        robj *o = dictGetEntryVal(de);
-        

         if (o->type != REDIS_LIST) {
             addReply(c,shared.wrongtypeerr);
         } else {
         if (o->type != REDIS_LIST) {
             addReply(c,shared.wrongtypeerr);
         } else {


@@ -2267,23 +2910,21 @@ static void ltrimCommand(redisClient *c) {
                 ln = listLast(list);
                 listDelNode(list,ln);
             }
                 ln = listLast(list);
                 listDelNode(list,ln);
             }

-            addReply(c,shared.ok);

             server.dirty++;
             server.dirty++;

+            addReply(c,shared.ok);

         }
     }
 }
 
 static void lremCommand(redisClient *c) {
         }
     }
 }
 
 static void lremCommand(redisClient *c) {

-    dictEntry *de;
+    robj *o;

     
     

-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL) {
-        addReply(c,shared.minus1);
+    o = lookupKeyWrite(c->db,c->argv[1]);
+    if (o == NULL) {
+        addReply(c,shared.czero);

     } else {
     } else {

-        robj *o = dictGetEntryVal(de);
-        

         if (o->type != REDIS_LIST) {
         if (o->type != REDIS_LIST) {

-            addReply(c,shared.minus2);
+            addReply(c,shared.wrongtypeerr);

         } else {
             list *list = o->ptr;
             listNode *ln, *next;
         } else {
             list *list = o->ptr;
             listNode *ln, *next;


@@ -2297,8 +2938,9 @@ static void lremCommand(redisClient *c) {
             }
             ln = fromtail ? list->tail : list->head;
             while (ln) {
             }
             ln = fromtail ? list->tail : list->head;
             while (ln) {

-                next = fromtail ? ln->prev : ln->next;

                 robj *ele = listNodeValue(ln);
                 robj *ele = listNodeValue(ln);

+
+                next = fromtail ? ln->prev : ln->next;

                 if (sdscmp(ele->ptr,c->argv[3]->ptr) == 0) {
                     listDelNode(list,ln);
                     server.dirty++;
                 if (sdscmp(ele->ptr,c->argv[3]->ptr) == 0) {
                     listDelNode(list,ln);
                     server.dirty++;


@@ -2307,7 +2949,7 @@ static void lremCommand(redisClient *c) {
                 }
                 ln = next;
             }
                 }
                 ln = next;
             }

-            addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",removed));
+            addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",removed));

         }
     }
 }
         }
     }
 }


@@ -2315,90 +2957,145 @@ static void lremCommand(redisClient *c) {
 /* ==================================== Sets ================================ */
 
 static void saddCommand(redisClient *c) {
 /* ==================================== Sets ================================ */
 
 static void saddCommand(redisClient *c) {

-    dictEntry *de;

     robj *set;
 
     robj *set;
 

-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL) {
+    set = lookupKeyWrite(c->db,c->argv[1]);
+    if (set == NULL) {

         set = createSetObject();
         set = createSetObject();

-        dictAdd(c->dict,c->argv[1],set);
+        dictAdd(c->db->dict,c->argv[1],set);

         incrRefCount(c->argv[1]);
     } else {
         incrRefCount(c->argv[1]);
     } else {

-        set = dictGetEntryVal(de);

         if (set->type != REDIS_SET) {
         if (set->type != REDIS_SET) {

-            addReply(c,shared.minus2);
+            addReply(c,shared.wrongtypeerr);

             return;
         }
     }
     if (dictAdd(set->ptr,c->argv[2],NULL) == DICT_OK) {
         incrRefCount(c->argv[2]);
         server.dirty++;
             return;
         }
     }
     if (dictAdd(set->ptr,c->argv[2],NULL) == DICT_OK) {
         incrRefCount(c->argv[2]);
         server.dirty++;

-        addReply(c,shared.one);
+        addReply(c,shared.cone);

     } else {
     } else {

-        addReply(c,shared.zero);
+        addReply(c,shared.czero);

     }
 }
 
 static void sremCommand(redisClient *c) {
     }
 }
 
 static void sremCommand(redisClient *c) {

-    dictEntry *de;
+    robj *set;

 
 

-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL) {
-        addReply(c,shared.zero);
+    set = lookupKeyWrite(c->db,c->argv[1]);
+    if (set == NULL) {
+        addReply(c,shared.czero);

     } else {
     } else {

-        robj *set;
-
-        set = dictGetEntryVal(de);

         if (set->type != REDIS_SET) {
         if (set->type != REDIS_SET) {

-            addReply(c,shared.minus2);
+            addReply(c,shared.wrongtypeerr);

             return;
         }
         if (dictDelete(set->ptr,c->argv[2]) == DICT_OK) {
             server.dirty++;
             return;
         }
         if (dictDelete(set->ptr,c->argv[2]) == DICT_OK) {
             server.dirty++;

-            addReply(c,shared.one);
+            if (htNeedsResize(set->ptr)) dictResize(set->ptr);
+            addReply(c,shared.cone);

         } else {
         } else {

-            addReply(c,shared.zero);
+            addReply(c,shared.czero);

         }
     }
 }
 
         }
     }
 }
 

+static void smoveCommand(redisClient *c) {
+    robj *srcset, *dstset;
+
+    srcset = lookupKeyWrite(c->db,c->argv[1]);
+    dstset = lookupKeyWrite(c->db,c->argv[2]);
+
+    /* If the source key does not exist return 0, if it's of the wrong type
+     * raise an error */
+    if (srcset == NULL || srcset->type != REDIS_SET) {
+        addReply(c, srcset ? shared.wrongtypeerr : shared.czero);
+        return;
+    }
+    /* Error if the destination key is not a set as well */
+    if (dstset && dstset->type != REDIS_SET) {
+        addReply(c,shared.wrongtypeerr);
+        return;
+    }
+    /* Remove the element from the source set */
+    if (dictDelete(srcset->ptr,c->argv[3]) == DICT_ERR) {
+        /* Key not found in the src set! return zero */
+        addReply(c,shared.czero);
+        return;
+    }
+    server.dirty++;
+    /* Add the element to the destination set */
+    if (!dstset) {
+        dstset = createSetObject();
+        dictAdd(c->db->dict,c->argv[2],dstset);
+        incrRefCount(c->argv[2]);
+    }
+    if (dictAdd(dstset->ptr,c->argv[3],NULL) == DICT_OK)
+        incrRefCount(c->argv[3]);
+    addReply(c,shared.cone);
+}
+

 static void sismemberCommand(redisClient *c) {
 static void sismemberCommand(redisClient *c) {

-    dictEntry *de;
+    robj *set;

 
 

-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL) {
-        addReply(c,shared.zero);
+    set = lookupKeyRead(c->db,c->argv[1]);
+    if (set == NULL) {
+        addReply(c,shared.czero);

     } else {
     } else {

-        robj *set;
-
-        set = dictGetEntryVal(de);

         if (set->type != REDIS_SET) {
         if (set->type != REDIS_SET) {

-            addReply(c,shared.minus2);
+            addReply(c,shared.wrongtypeerr);

             return;
         }
         if (dictFind(set->ptr,c->argv[2]))
             return;
         }
         if (dictFind(set->ptr,c->argv[2]))

-            addReply(c,shared.one);
+            addReply(c,shared.cone);

         else
         else

-            addReply(c,shared.zero);
+            addReply(c,shared.czero);

     }
 }
 
 static void scardCommand(redisClient *c) {
     }
 }
 
 static void scardCommand(redisClient *c) {

-    dictEntry *de;
+    robj *o;

     dict *s;
     
     dict *s;
     

-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL) {
-        addReply(c,shared.zero);
+    o = lookupKeyRead(c->db,c->argv[1]);
+    if (o == NULL) {
+        addReply(c,shared.czero);

         return;
     } else {
         return;
     } else {

-        robj *o = dictGetEntryVal(de);

         if (o->type != REDIS_SET) {
         if (o->type != REDIS_SET) {

-            addReply(c,shared.minus2);
+            addReply(c,shared.wrongtypeerr);

         } else {
             s = o->ptr;
         } else {
             s = o->ptr;

-            addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",
-                dictGetHashTableUsed(s)));
+            addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",
+                dictSize(s)));
+        }
+    }
+}
+
+static void spopCommand(redisClient *c) {
+    robj *set;
+    dictEntry *de;
+
+    set = lookupKeyWrite(c->db,c->argv[1]);
+    if (set == NULL) {
+        addReply(c,shared.nullbulk);
+    } else {
+        if (set->type != REDIS_SET) {
+            addReply(c,shared.wrongtypeerr);
+            return;
+        }
+        de = dictGetRandomKey(set->ptr);
+        if (de == NULL) {
+            addReply(c,shared.nullbulk);
+        } else {
+            robj *ele = dictGetEntryKey(de);
+
+            addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",sdslen(ele->ptr)));
+            addReply(c,ele);
+            addReply(c,shared.crlf);
+            dictDelete(set->ptr,ele);
+            if (htNeedsResize(set->ptr)) dictResize(set->ptr);
+            server.dirty++;

         }
     }
 }
         }
     }
 }


@@ -2406,7 +3103,7 @@ static void scardCommand(redisClient *c) {
 static int qsortCompareSetsByCardinality(const void *s1, const void *s2) {
     dict **d1 = (void*) s1, **d2 = (void*) s2;
 
 static int qsortCompareSetsByCardinality(const void *s1, const void *s2) {
     dict **d1 = (void*) s1, **d2 = (void*) s2;
 

-    return dictGetHashTableUsed(*d1)-dictGetHashTableUsed(*d2);
+    return dictSize(*d1)-dictSize(*d2);

 }
 
 static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, robj *dstkey) {
 }
 
 static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, robj *dstkey) {


@@ -2416,21 +3113,26 @@ static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, r
     robj *lenobj = NULL, *dstset = NULL;
     int j, cardinality = 0;
 
     robj *lenobj = NULL, *dstset = NULL;
     int j, cardinality = 0;
 

-    if (!dv) oom("sinterCommand");
+    if (!dv) oom("sinterGenericCommand");

     for (j = 0; j < setsnum; j++) {
         robj *setobj;
     for (j = 0; j < setsnum; j++) {
         robj *setobj;

-        dictEntry *de;
-        
-        de = dictFind(c->dict,setskeys[j]);
-        if (!de) {
+
+        setobj = dstkey ?
+                    lookupKeyWrite(c->db,setskeys[j]) :
+                    lookupKeyRead(c->db,setskeys[j]);
+        if (!setobj) {

             zfree(dv);
             zfree(dv);

-            addReply(c,dstkey ? shared.nokeyerr : shared.nil);
+            if (dstkey) {
+                deleteKey(c->db,dstkey);
+                addReply(c,shared.ok);
+            } else {
+                addReply(c,shared.nullmultibulk);
+            }

             return;
         }
             return;
         }

-        setobj = dictGetEntryVal(de);

         if (setobj->type != REDIS_SET) {
             zfree(dv);
         if (setobj->type != REDIS_SET) {
             zfree(dv);

-            addReply(c,dstkey ? shared.wrongtypeerr : shared.wrongtypeerrbulk);
+            addReply(c,shared.wrongtypeerr);

             return;
         }
         dv[j] = setobj->ptr;
             return;
         }
         dv[j] = setobj->ptr;


@@ -2452,9 +3154,6 @@ static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, r
         /* If we have a target key where to store the resulting set
          * create this key with an empty set inside */
         dstset = createSetObject();
         /* If we have a target key where to store the resulting set
          * create this key with an empty set inside */
         dstset = createSetObject();

-        dictDelete(c->dict,dstkey);
-        dictAdd(c->dict,dstkey,dstset);
-        incrRefCount(dstkey);

     }
 
     /* Iterate all the elements of the first (smallest) set, and test
     }
 
     /* Iterate all the elements of the first (smallest) set, and test


@@ -2472,7 +3171,7 @@ static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, r
             continue; /* at least one set does not contain the member */
         ele = dictGetEntryKey(de);
         if (!dstkey) {
             continue; /* at least one set does not contain the member */
         ele = dictGetEntryKey(de);
         if (!dstkey) {

-            addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",sdslen(ele->ptr)));
+            addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",sdslen(ele->ptr)));

             addReply(c,ele);
             addReply(c,shared.crlf);
             cardinality++;
             addReply(c,ele);
             addReply(c,shared.crlf);
             cardinality++;


@@ -2483,10 +3182,20 @@ static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, r
     }
     dictReleaseIterator(di);
 
     }
     dictReleaseIterator(di);
 

-    if (!dstkey)
-        lenobj->ptr = sdscatprintf(sdsempty(),"%d\r\n",cardinality);
-    else
-        addReply(c,shared.ok);
+    if (dstkey) {
+        /* Store the resulting set into the target */
+        deleteKey(c->db,dstkey);
+        dictAdd(c->db->dict,dstkey,dstset);
+        incrRefCount(dstkey);
+    }
+
+    if (!dstkey) {
+        lenobj->ptr = sdscatprintf(sdsempty(),"*%d\r\n",cardinality);
+    } else {
+        addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",
+            dictSize((dict*)dstset->ptr)));
+        server.dirty++;
+    }

     zfree(dv);
 }
 
     zfree(dv);
 }
 


@@ -2498,19 +3207,135 @@ static void sinterstoreCommand(redisClient *c) {
     sinterGenericCommand(c,c->argv+2,c->argc-2,c->argv[1]);
 }
 
     sinterGenericCommand(c,c->argv+2,c->argc-2,c->argv[1]);
 }
 

+#define REDIS_OP_UNION 0
+#define REDIS_OP_DIFF 1
+
+static void sunionDiffGenericCommand(redisClient *c, robj **setskeys, int setsnum, robj *dstkey, int op) {
+    dict **dv = zmalloc(sizeof(dict*)*setsnum);
+    dictIterator *di;
+    dictEntry *de;
+    robj *dstset = NULL;
+    int j, cardinality = 0;
+
+    if (!dv) oom("sunionDiffGenericCommand");
+    for (j = 0; j < setsnum; j++) {
+        robj *setobj;
+
+        setobj = dstkey ?
+                    lookupKeyWrite(c->db,setskeys[j]) :
+                    lookupKeyRead(c->db,setskeys[j]);
+        if (!setobj) {
+            dv[j] = NULL;
+            continue;
+        }
+        if (setobj->type != REDIS_SET) {
+            zfree(dv);
+            addReply(c,shared.wrongtypeerr);
+            return;
+        }
+        dv[j] = setobj->ptr;
+    }
+
+    /* We need a temp set object to store our union. If the dstkey
+     * is not NULL (that is, we are inside an SUNIONSTORE operation) then
+     * this set object will be the resulting object to set into the target key*/
+    dstset = createSetObject();
+
+    /* Iterate all the elements of all the sets, add every element a single
+     * time to the result set */
+    for (j = 0; j < setsnum; j++) {
+        if (op == REDIS_OP_DIFF && j == 0 && !dv[j]) break; /* result set is empty */
+        if (!dv[j]) continue; /* non existing keys are like empty sets */
+
+        di = dictGetIterator(dv[j]);
+        if (!di) oom("dictGetIterator");
+
+        while((de = dictNext(di)) != NULL) {
+            robj *ele;
+
+            /* dictAdd will not add the same element multiple times */
+            ele = dictGetEntryKey(de);
+            if (op == REDIS_OP_UNION || j == 0) {
+                if (dictAdd(dstset->ptr,ele,NULL) == DICT_OK) {
+                    incrRefCount(ele);
+                    cardinality++;
+                }
+            } else if (op == REDIS_OP_DIFF) {
+                if (dictDelete(dstset->ptr,ele) == DICT_OK) {
+                    cardinality--;
+                }
+            }
+        }
+        dictReleaseIterator(di);
+
+        if (op == REDIS_OP_DIFF && cardinality == 0) break; /* result set is empty */
+    }
+
+    /* Output the content of the resulting set, if not in STORE mode */
+    if (!dstkey) {
+        addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",cardinality));
+        di = dictGetIterator(dstset->ptr);
+        if (!di) oom("dictGetIterator");
+        while((de = dictNext(di)) != NULL) {
+            robj *ele;
+
+            ele = dictGetEntryKey(de);
+            addReplySds(c,sdscatprintf(sdsempty(),
+                    "$%d\r\n",sdslen(ele->ptr)));
+            addReply(c,ele);
+            addReply(c,shared.crlf);
+        }
+        dictReleaseIterator(di);
+    } else {
+        /* If we have a target key where to store the resulting set
+         * create this key with the result set inside */
+        deleteKey(c->db,dstkey);
+        dictAdd(c->db->dict,dstkey,dstset);
+        incrRefCount(dstkey);
+    }
+
+    /* Cleanup */
+    if (!dstkey) {
+        decrRefCount(dstset);
+    } else {
+        addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",
+            dictSize((dict*)dstset->ptr)));
+        server.dirty++;
+    }
+    zfree(dv);
+}
+
+static void sunionCommand(redisClient *c) {
+    sunionDiffGenericCommand(c,c->argv+1,c->argc-1,NULL,REDIS_OP_UNION);
+}
+
+static void sunionstoreCommand(redisClient *c) {
+    sunionDiffGenericCommand(c,c->argv+2,c->argc-2,c->argv[1],REDIS_OP_UNION);
+}
+
+static void sdiffCommand(redisClient *c) {
+    sunionDiffGenericCommand(c,c->argv+1,c->argc-1,NULL,REDIS_OP_DIFF);
+}
+
+static void sdiffstoreCommand(redisClient *c) {
+    sunionDiffGenericCommand(c,c->argv+2,c->argc-2,c->argv[1],REDIS_OP_DIFF);
+}
+

 static void flushdbCommand(redisClient *c) {
 static void flushdbCommand(redisClient *c) {

-    dictEmpty(c->dict);
+    server.dirty += dictSize(c->db->dict);
+    dictEmpty(c->db->dict);
+    dictEmpty(c->db->expires);

     addReply(c,shared.ok);
     addReply(c,shared.ok);

-    saveDb(server.dbfilename);

 }
 
 static void flushallCommand(redisClient *c) {
 }
 
 static void flushallCommand(redisClient *c) {

-    emptyDb();
+    server.dirty += emptyDb();

     addReply(c,shared.ok);
     addReply(c,shared.ok);

-    saveDb(server.dbfilename);
+    rdbSave(server.dbfilename);
+    server.dirty++;

 }
 
 }
 

-redisSortOperation *createSortOperation(int type, robj *pattern) {
+static redisSortOperation *createSortOperation(int type, robj *pattern) {

     redisSortOperation *so = zmalloc(sizeof(*so));
     if (!so) oom("createSortOperation");
     so->type = type;
     redisSortOperation *so = zmalloc(sizeof(*so));
     if (!so) oom("createSortOperation");
     so->type = type;


@@ -2520,12 +3345,11 @@ redisSortOperation *createSortOperation(int type, robj *pattern) {
 
 /* Return the value associated to the key with a name obtained
  * substituting the first occurence of '*' in 'pattern' with 'subst' */
 
 /* Return the value associated to the key with a name obtained
  * substituting the first occurence of '*' in 'pattern' with 'subst' */

-robj *lookupKeyByPattern(dict *dict, robj *pattern, robj *subst) {
+static robj *lookupKeyByPattern(redisDb *db, robj *pattern, robj *subst) {

     char *p;
     sds spat, ssub;
     robj keyobj;
     int prefixlen, sublen, postfixlen;
     char *p;
     sds spat, ssub;
     robj keyobj;
     int prefixlen, sublen, postfixlen;

-    dictEntry *de;

     /* Expoit the internal sds representation to create a sds string allocated on the stack in order to make this function faster */
     struct {
         long len;
     /* Expoit the internal sds representation to create a sds string allocated on the stack in order to make this function faster */
     struct {
         long len;


@@ -2533,7 +3357,6 @@ robj *lookupKeyByPattern(dict *dict, robj *pattern, robj *subst) {
         char buf[REDIS_SORTKEY_MAX+1];
     } keyname;
 
         char buf[REDIS_SORTKEY_MAX+1];
     } keyname;
 

-

     spat = pattern->ptr;
     ssub = subst->ptr;
     if (sdslen(spat)+sdslen(ssub)-1 > REDIS_SORTKEY_MAX) return NULL;
     spat = pattern->ptr;
     ssub = subst->ptr;
     if (sdslen(spat)+sdslen(ssub)-1 > REDIS_SORTKEY_MAX) return NULL;


@@ -2553,10 +3376,8 @@ robj *lookupKeyByPattern(dict *dict, robj *pattern, robj *subst) {
     keyobj.type = REDIS_STRING;
     keyobj.ptr = ((char*)&keyname)+(sizeof(long)*2);
 
     keyobj.type = REDIS_STRING;
     keyobj.ptr = ((char*)&keyname)+(sizeof(long)*2);
 

-    de = dictFind(dict,&keyobj);
-    // printf("lookup '%s' => %p\n", keyname.buf,de);
-    if (!de) return NULL;
-    return dictGetEntryVal(de);
+    /* printf("lookup '%s' => %p\n", keyname.buf,de); */
+    return lookupKeyRead(db,&keyobj);

 }
 
 /* sortCompare() is used by qsort in sortCommand(). Given that qsort_r with
 }
 
 /* sortCompare() is used by qsort in sortCommand(). Given that qsort_r with


@@ -2601,7 +3422,6 @@ static int sortCompare(const void *s1, const void *s2) {
 /* The SORT command is the most complex command in Redis. Warning: this code
  * is optimized for speed and a bit less for readability */
 static void sortCommand(redisClient *c) {
 /* The SORT command is the most complex command in Redis. Warning: this code
  * is optimized for speed and a bit less for readability */
 static void sortCommand(redisClient *c) {

-    dictEntry *de;

     list *operations;
     int outputlen = 0;
     int desc = 0, alpha = 0;
     list *operations;
     int outputlen = 0;
     int desc = 0, alpha = 0;


@@ -2612,21 +3432,20 @@ static void sortCommand(redisClient *c) {
     redisSortObject *vector; /* Resulting vector to sort */
 
     /* Lookup the key to sort. It must be of the right types */
     redisSortObject *vector; /* Resulting vector to sort */
 
     /* Lookup the key to sort. It must be of the right types */

-    de = dictFind(c->dict,c->argv[1]);
-    if (de == NULL) {
-        addReply(c,shared.nokeyerrbulk);
+    sortval = lookupKeyRead(c->db,c->argv[1]);
+    if (sortval == NULL) {
+        addReply(c,shared.nokeyerr);

         return;
     }
         return;
     }

-    sortval = dictGetEntryVal(de);

     if (sortval->type != REDIS_SET && sortval->type != REDIS_LIST) {
     if (sortval->type != REDIS_SET && sortval->type != REDIS_LIST) {

-        addReply(c,shared.wrongtypeerrbulk);
+        addReply(c,shared.wrongtypeerr);

         return;
     }
 
     /* Create a list of operations to perform for every sorted element.
      * Operations can be GET/DEL/INCR/DECR */
     operations = listCreate();
         return;
     }
 
     /* Create a list of operations to perform for every sorted element.
      * Operations can be GET/DEL/INCR/DECR */
     operations = listCreate();

-    listSetFreeMethod(operations,free);
+    listSetFreeMethod(operations,zfree);

     j = 2;
 
     /* Now we need to protect sortval incrementing its count, in the future
     j = 2;
 
     /* Now we need to protect sortval incrementing its count, in the future


@@ -2673,7 +3492,7 @@ static void sortCommand(redisClient *c) {
         } else {
             decrRefCount(sortval);
             listRelease(operations);
         } else {
             decrRefCount(sortval);
             listRelease(operations);

-            addReply(c,shared.syntaxerrbulk);
+            addReply(c,shared.syntaxerr);

             return;
         }
         j++;
             return;
         }
         j++;


@@ -2682,19 +3501,20 @@ static void sortCommand(redisClient *c) {
     /* Load the sorting vector with all the objects to sort */
     vectorlen = (sortval->type == REDIS_LIST) ?
         listLength((list*)sortval->ptr) :
     /* Load the sorting vector with all the objects to sort */
     vectorlen = (sortval->type == REDIS_LIST) ?
         listLength((list*)sortval->ptr) :

-        dictGetHashTableUsed((dict*)sortval->ptr);
+        dictSize((dict*)sortval->ptr);

     vector = zmalloc(sizeof(redisSortObject)*vectorlen);
     if (!vector) oom("allocating objects vector for SORT");
     j = 0;
     if (sortval->type == REDIS_LIST) {
         list *list = sortval->ptr;
     vector = zmalloc(sizeof(redisSortObject)*vectorlen);
     if (!vector) oom("allocating objects vector for SORT");
     j = 0;
     if (sortval->type == REDIS_LIST) {
         list *list = sortval->ptr;

-        listNode *ln = list->head;
-        while(ln) {
+        listNode *ln;
+
+        listRewind(list);
+        while((ln = listYield(list))) {

             robj *ele = ln->value;
             vector[j].obj = ele;
             vector[j].u.score = 0;
             vector[j].u.cmpobj = NULL;
             robj *ele = ln->value;
             vector[j].obj = ele;
             vector[j].u.score = 0;
             vector[j].u.cmpobj = NULL;

-            ln = ln->next;

             j++;
         }
     } else {
             j++;
         }
     } else {


@@ -2720,7 +3540,7 @@ static void sortCommand(redisClient *c) {
             if (sortby) {
                 robj *byval;
 
             if (sortby) {
                 robj *byval;
 

-                byval = lookupKeyByPattern(c->dict,sortby,vector[j].obj);
+                byval = lookupKeyByPattern(c->db,sortby,vector[j].obj);

                 if (!byval || byval->type != REDIS_STRING) continue;
                 if (alpha) {
                     vector[j].u.cmpobj = byval;
                 if (!byval || byval->type != REDIS_STRING) continue;
                 if (alpha) {
                     vector[j].u.cmpobj = byval;


@@ -2748,31 +3568,35 @@ static void sortCommand(redisClient *c) {
         server.sort_desc = desc;
         server.sort_alpha = alpha;
         server.sort_bypattern = sortby ? 1 : 0;
         server.sort_desc = desc;
         server.sort_alpha = alpha;
         server.sort_bypattern = sortby ? 1 : 0;

-        qsort(vector,vectorlen,sizeof(redisSortObject),sortCompare);
+        if (sortby && (start != 0 || end != vectorlen-1))
+            pqsort(vector,vectorlen,sizeof(redisSortObject),sortCompare, start,end);
+        else
+            qsort(vector,vectorlen,sizeof(redisSortObject),sortCompare);

     }
 
     /* Send command output to the output buffer, performing the specified
      * GET/DEL/INCR/DECR operations if any. */
     outputlen = getop ? getop*(end-start+1) : end-start+1;
     }
 
     /* Send command output to the output buffer, performing the specified
      * GET/DEL/INCR/DECR operations if any. */
     outputlen = getop ? getop*(end-start+1) : end-start+1;

-    addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",outputlen));
+    addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",outputlen));

     for (j = start; j <= end; j++) {
     for (j = start; j <= end; j++) {

-        listNode *ln = operations->head;
+        listNode *ln;

         if (!getop) {
         if (!getop) {

-            addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",
+            addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",

                 sdslen(vector[j].obj->ptr)));
             addReply(c,vector[j].obj);
             addReply(c,shared.crlf);
         }
                 sdslen(vector[j].obj->ptr)));
             addReply(c,vector[j].obj);
             addReply(c,shared.crlf);
         }

-        while(ln) {
+        listRewind(operations);
+        while((ln = listYield(operations))) {

             redisSortOperation *sop = ln->value;
             redisSortOperation *sop = ln->value;

-            robj *val = lookupKeyByPattern(c->dict,sop->pattern,
+            robj *val = lookupKeyByPattern(c->db,sop->pattern,

                 vector[j].obj);
 
             if (sop->type == REDIS_SORT_GET) {
                 if (!val || val->type != REDIS_STRING) {
                 vector[j].obj);
 
             if (sop->type == REDIS_SORT_GET) {
                 if (!val || val->type != REDIS_STRING) {

-                    addReply(c,shared.minus1);
+                    addReply(c,shared.nullbulk);

                 } else {
                 } else {

-                    addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",
+                    addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",

                         sdslen(val->ptr)));
                     addReply(c,val);
                     addReply(c,shared.crlf);
                         sdslen(val->ptr)));
                     addReply(c,val);
                     addReply(c,shared.crlf);


@@ -2780,7 +3604,6 @@ static void sortCommand(redisClient *c) {
             } else if (sop->type == REDIS_SORT_DEL) {
                 /* TODO */
             }
             } else if (sop->type == REDIS_SORT_DEL) {
                 /* TODO */
             }

-            ln = ln->next;

         }
     }
 
         }
     }
 


@@ -2797,54 +3620,171 @@ static void sortCommand(redisClient *c) {
 static void infoCommand(redisClient *c) {
     sds info;
     time_t uptime = time(NULL)-server.stat_starttime;
 static void infoCommand(redisClient *c) {
     sds info;
     time_t uptime = time(NULL)-server.stat_starttime;

+    int j;

     
     info = sdscatprintf(sdsempty(),
         "redis_version:%s\r\n"
     
     info = sdscatprintf(sdsempty(),
         "redis_version:%s\r\n"

+        "uptime_in_seconds:%d\r\n"
+        "uptime_in_days:%d\r\n"

         "connected_clients:%d\r\n"
         "connected_slaves:%d\r\n"
         "connected_clients:%d\r\n"
         "connected_slaves:%d\r\n"

-        "used_memory:%d\r\n"
+        "used_memory:%zu\r\n"

         "changes_since_last_save:%lld\r\n"
         "changes_since_last_save:%lld\r\n"

+        "bgsave_in_progress:%d\r\n"

         "last_save_time:%d\r\n"
         "total_connections_received:%lld\r\n"
         "total_commands_processed:%lld\r\n"
         "last_save_time:%d\r\n"
         "total_connections_received:%lld\r\n"
         "total_commands_processed:%lld\r\n"

-        "uptime_in_seconds:%d\r\n"
-        "uptime_in_days:%d\r\n"
+        "role:%s\r\n"

         ,REDIS_VERSION,
         ,REDIS_VERSION,

+        uptime,
+        uptime/(3600*24),

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

+        server.bgsaveinprogress,

         server.lastsave,
         server.stat_numconnections,
         server.stat_numcommands,
         server.lastsave,
         server.stat_numconnections,
         server.stat_numcommands,

-        uptime,
-        uptime/(3600*24)
+        server.masterhost == NULL ? "master" : "slave"

     );
     );

-    addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",sdslen(info)));
+    if (server.masterhost) {
+        info = sdscatprintf(info,
+            "master_host:%s\r\n"
+            "master_port:%d\r\n"
+            "master_link_status:%s\r\n"
+            "master_last_io_seconds_ago:%d\r\n"
+            ,server.masterhost,
+            server.masterport,
+            (server.replstate == REDIS_REPL_CONNECTED) ?
+                "up" : "down",
+            (int)(time(NULL)-server.master->lastinteraction)
+        );
+    }
+    for (j = 0; j < server.dbnum; j++) {
+        long long keys, vkeys;
+
+        keys = dictSize(server.db[j].dict);
+        vkeys = dictSize(server.db[j].expires);
+        if (keys || vkeys) {
+            info = sdscatprintf(info, "db%d: keys=%lld,expires=%lld\r\n",
+                j, keys, vkeys);
+        }
+    }
+    addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",sdslen(info)));

     addReplySds(c,info);
     addReply(c,shared.crlf);
 }
 
     addReplySds(c,info);
     addReply(c,shared.crlf);
 }
 

-/* =============================== Replication  ============================= */
+static void monitorCommand(redisClient *c) {
+    /* ignore MONITOR if aleady slave or in monitor mode */
+    if (c->flags & REDIS_SLAVE) return;

 
 

-/* Send the whole output buffer syncronously to the slave. This a general operation in theory, but it is actually useful only for replication. */
-static int flushClientOutput(redisClient *c) {
-    int retval;
-    time_t start = time(NULL);
+    c->flags |= (REDIS_SLAVE|REDIS_MONITOR);
+    c->slaveseldb = 0;
+    if (!listAddNodeTail(server.monitors,c)) oom("listAddNodeTail");
+    addReply(c,shared.ok);
+}

 
 

-    while(listLength(c->reply)) {
-        if (time(NULL)-start > 5) return REDIS_ERR; /* 5 seconds timeout */
-        retval = aeWait(c->fd,AE_WRITABLE,1000);
-        if (retval == -1) {
-            return REDIS_ERR;
-        } else if (retval & AE_WRITABLE) {
-            sendReplyToClient(NULL, c->fd, c, AE_WRITABLE);
+/* ================================= Expire ================================= */
+static int removeExpire(redisDb *db, robj *key) {
+    if (dictDelete(db->expires,key) == DICT_OK) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+static int setExpire(redisDb *db, robj *key, time_t when) {
+    if (dictAdd(db->expires,key,(void*)when) == DICT_ERR) {
+        return 0;
+    } else {
+        incrRefCount(key);
+        return 1;
+    }
+}
+
+/* Return the expire time of the specified key, or -1 if no expire
+ * is associated with this key (i.e. the key is non volatile) */
+static time_t getExpire(redisDb *db, robj *key) {
+    dictEntry *de;
+
+    /* No expire? return ASAP */
+    if (dictSize(db->expires) == 0 ||
+       (de = dictFind(db->expires,key)) == NULL) return -1;
+
+    return (time_t) dictGetEntryVal(de);
+}
+
+static int expireIfNeeded(redisDb *db, robj *key) {
+    time_t when;
+    dictEntry *de;
+
+    /* No expire? return ASAP */
+    if (dictSize(db->expires) == 0 ||
+       (de = dictFind(db->expires,key)) == NULL) return 0;
+
+    /* Lookup the expire */
+    when = (time_t) dictGetEntryVal(de);
+    if (time(NULL) <= when) return 0;
+
+    /* Delete the key */
+    dictDelete(db->expires,key);
+    return dictDelete(db->dict,key) == DICT_OK;
+}
+
+static int deleteIfVolatile(redisDb *db, robj *key) {
+    dictEntry *de;
+
+    /* No expire? return ASAP */
+    if (dictSize(db->expires) == 0 ||
+       (de = dictFind(db->expires,key)) == NULL) return 0;
+
+    /* Delete the key */
+    server.dirty++;
+    dictDelete(db->expires,key);
+    return dictDelete(db->dict,key) == DICT_OK;
+}
+
+static void expireCommand(redisClient *c) {
+    dictEntry *de;
+    int seconds = atoi(c->argv[2]->ptr);
+
+    de = dictFind(c->db->dict,c->argv[1]);
+    if (de == NULL) {
+        addReply(c,shared.czero);
+        return;
+    }
+    if (seconds <= 0) {
+        addReply(c, shared.czero);
+        return;
+    } else {
+        time_t when = time(NULL)+seconds;
+        if (setExpire(c->db,c->argv[1],when)) {
+            addReply(c,shared.cone);
+            server.dirty++;
+        } else {
+            addReply(c,shared.czero);

         }
         }

+        return;

     }
     }

-    return REDIS_OK;

 }
 
 }
 

-static int syncWrite(int fd, void *ptr, ssize_t size, int timeout) {
+static void ttlCommand(redisClient *c) {
+    time_t expire;
+    int ttl = -1;
+
+    expire = getExpire(c->db,c->argv[1]);
+    if (expire != -1) {
+        ttl = (int) (expire-time(NULL));
+        if (ttl < 0) ttl = -1;
+    }
+    addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",ttl));
+}
+
+/* =============================== Replication  ============================= */
+
+static int syncWrite(int fd, char *ptr, ssize_t size, int timeout) {

     ssize_t nwritten, ret = size;
     time_t start = time(NULL);
 
     ssize_t nwritten, ret = size;
     time_t start = time(NULL);
 


@@ -2864,7 +3804,7 @@ static int syncWrite(int fd, void *ptr, ssize_t size, int timeout) {
     return ret;
 }
 
     return ret;
 }
 

-static int syncRead(int fd, void *ptr, ssize_t size, int timeout) {
+static int syncRead(int fd, char *ptr, ssize_t size, int timeout) {

     ssize_t nread, totread = 0;
     time_t start = time(NULL);
 
     ssize_t nread, totread = 0;
     time_t start = time(NULL);
 


@@ -2907,44 +3847,171 @@ static int syncReadLine(int fd, char *ptr, ssize_t size, int timeout) {
 }
 
 static void syncCommand(redisClient *c) {
 }
 
 static void syncCommand(redisClient *c) {

-    struct stat sb;
-    int fd = -1, len;
-    time_t start = time(NULL);
-    char sizebuf[32];
-
-    redisLog(REDIS_NOTICE,"Slave ask for syncronization");
-    if (flushClientOutput(c) == REDIS_ERR || saveDb(server.dbfilename) != REDIS_OK)
-        goto closeconn;
-
-    fd = open(server.dbfilename, O_RDONLY);
-    if (fd == -1 || fstat(fd,&sb) == -1) goto closeconn;
-    len = sb.st_size;
-
-    snprintf(sizebuf,32,"%d\r\n",len);
-    if (syncWrite(c->fd,sizebuf,strlen(sizebuf),5) == -1) goto closeconn;
-    while(len) {
-        char buf[1024];
-        int nread;
+    /* ignore SYNC if aleady slave or in monitor mode */
+    if (c->flags & REDIS_SLAVE) return;
+
+    /* SYNC can't be issued when the server has pending data to send to
+     * the client about already issued commands. We need a fresh reply
+     * buffer registering the differences between the BGSAVE and the current
+     * dataset, so that we can copy to other slaves if needed. */
+    if (listLength(c->reply) != 0) {
+        addReplySds(c,sdsnew("-ERR SYNC is invalid with pending input\r\n"));
+        return;
+    }

 
 

-        if (time(NULL)-start > REDIS_MAX_SYNC_TIME) goto closeconn;
-        nread = read(fd,buf,1024);
-        if (nread == -1) goto closeconn;
-        len -= nread;
-        if (syncWrite(c->fd,buf,nread,5) == -1) goto closeconn;
+    redisLog(REDIS_NOTICE,"Slave ask for synchronization");
+    /* Here we need to check if there is a background saving operation
+     * in progress, or if it is required to start one */
+    if (server.bgsaveinprogress) {
+        /* Ok a background save is in progress. Let's check if it is a good
+         * one for replication, i.e. if there is another slave that is
+         * registering differences since the server forked to save */
+        redisClient *slave;
+        listNode *ln;
+
+        listRewind(server.slaves);
+        while((ln = listYield(server.slaves))) {
+            slave = ln->value;
+            if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_END) break;
+        }
+        if (ln) {
+            /* Perfect, the server is already registering differences for
+             * another slave. Set the right state, and copy the buffer. */
+            listRelease(c->reply);
+            c->reply = listDup(slave->reply);
+            if (!c->reply) oom("listDup copying slave reply list");
+            c->replstate = REDIS_REPL_WAIT_BGSAVE_END;
+            redisLog(REDIS_NOTICE,"Waiting for end of BGSAVE for SYNC");
+        } else {
+            /* No way, we need to wait for the next BGSAVE in order to
+             * register differences */
+            c->replstate = REDIS_REPL_WAIT_BGSAVE_START;
+            redisLog(REDIS_NOTICE,"Waiting for next BGSAVE for SYNC");
+        }
+    } else {
+        /* Ok we don't have a BGSAVE in progress, let's start one */
+        redisLog(REDIS_NOTICE,"Starting BGSAVE for SYNC");
+        if (rdbSaveBackground(server.dbfilename) != REDIS_OK) {
+            redisLog(REDIS_NOTICE,"Replication failed, can't BGSAVE");
+            addReplySds(c,sdsnew("-ERR Unalbe to perform background save\r\n"));
+            return;
+        }
+        c->replstate = REDIS_REPL_WAIT_BGSAVE_END;

     }
     }

-    if (syncWrite(c->fd,"\r\n",2,5) == -1) goto closeconn;
-    close(fd);
+    c->repldbfd = -1;

     c->flags |= REDIS_SLAVE;
     c->slaveseldb = 0;
     if (!listAddNodeTail(server.slaves,c)) oom("listAddNodeTail");
     c->flags |= REDIS_SLAVE;
     c->slaveseldb = 0;
     if (!listAddNodeTail(server.slaves,c)) oom("listAddNodeTail");

-    redisLog(REDIS_NOTICE,"Syncronization with slave succeeded");

     return;
     return;

+}

 
 

-closeconn:
-    if (fd != -1) close(fd);
-    c->flags |= REDIS_CLOSE;
-    redisLog(REDIS_WARNING,"Syncronization with slave failed");
-    return;
+static void sendBulkToSlave(aeEventLoop *el, int fd, void *privdata, int mask) {
+    redisClient *slave = privdata;
+    REDIS_NOTUSED(el);
+    REDIS_NOTUSED(mask);
+    char buf[REDIS_IOBUF_LEN];
+    ssize_t nwritten, buflen;
+
+    if (slave->repldboff == 0) {
+        /* Write the bulk write count before to transfer the DB. In theory here
+         * we don't know how much room there is in the output buffer of the
+         * socket, but in pratice SO_SNDLOWAT (the minimum count for output
+         * operations) will never be smaller than the few bytes we need. */
+        sds bulkcount;
+
+        bulkcount = sdscatprintf(sdsempty(),"$%lld\r\n",(unsigned long long)
+            slave->repldbsize);
+        if (write(fd,bulkcount,sdslen(bulkcount)) != (signed)sdslen(bulkcount))
+        {
+            sdsfree(bulkcount);
+            freeClient(slave);
+            return;
+        }
+        sdsfree(bulkcount);
+    }
+    lseek(slave->repldbfd,slave->repldboff,SEEK_SET);
+    buflen = read(slave->repldbfd,buf,REDIS_IOBUF_LEN);
+    if (buflen <= 0) {
+        redisLog(REDIS_WARNING,"Read error sending DB to slave: %s",
+            (buflen == 0) ? "premature EOF" : strerror(errno));
+        freeClient(slave);
+        return;
+    }
+    if ((nwritten = write(fd,buf,buflen)) == -1) {
+        redisLog(REDIS_DEBUG,"Write error sending DB to slave: %s",
+            strerror(errno));
+        freeClient(slave);
+        return;
+    }
+    slave->repldboff += nwritten;
+    if (slave->repldboff == slave->repldbsize) {
+        close(slave->repldbfd);
+        slave->repldbfd = -1;
+        aeDeleteFileEvent(server.el,slave->fd,AE_WRITABLE);
+        slave->replstate = REDIS_REPL_ONLINE;
+        if (aeCreateFileEvent(server.el, slave->fd, AE_WRITABLE,
+            sendReplyToClient, slave, NULL) == AE_ERR) {
+            freeClient(slave);
+            return;
+        }
+        addReplySds(slave,sdsempty());
+        redisLog(REDIS_NOTICE,"Synchronization with slave succeeded");
+    }
+}
+
+/* This function is called at the end of every backgrond saving.
+ * The argument bgsaveerr is REDIS_OK if the background saving succeeded
+ * otherwise REDIS_ERR is passed to the function.
+ *
+ * The goal of this function is to handle slaves waiting for a successful
+ * background saving in order to perform non-blocking synchronization. */
+static void updateSlavesWaitingBgsave(int bgsaveerr) {
+    listNode *ln;
+    int startbgsave = 0;
+
+    listRewind(server.slaves);
+    while((ln = listYield(server.slaves))) {
+        redisClient *slave = ln->value;
+
+        if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_START) {
+            startbgsave = 1;
+            slave->replstate = REDIS_REPL_WAIT_BGSAVE_END;
+        } else if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_END) {
+            struct redis_stat buf;
+           
+            if (bgsaveerr != REDIS_OK) {
+                freeClient(slave);
+                redisLog(REDIS_WARNING,"SYNC failed. BGSAVE child returned an error");
+                continue;
+            }
+            if ((slave->repldbfd = open(server.dbfilename,O_RDONLY)) == -1 ||
+                redis_fstat(slave->repldbfd,&buf) == -1) {
+                freeClient(slave);
+                redisLog(REDIS_WARNING,"SYNC failed. Can't open/stat DB after BGSAVE: %s", strerror(errno));
+                continue;
+            }
+            slave->repldboff = 0;
+            slave->repldbsize = buf.st_size;
+            slave->replstate = REDIS_REPL_SEND_BULK;
+            aeDeleteFileEvent(server.el,slave->fd,AE_WRITABLE);
+            if (aeCreateFileEvent(server.el, slave->fd, AE_WRITABLE, sendBulkToSlave, slave, NULL) == AE_ERR) {
+                freeClient(slave);
+                continue;
+            }
+        }
+    }
+    if (startbgsave) {
+        if (rdbSaveBackground(server.dbfilename) != REDIS_OK) {
+            listRewind(server.slaves);
+            redisLog(REDIS_WARNING,"SYNC failed. BGSAVE failed");
+            while((ln = listYield(server.slaves))) {
+                redisClient *slave = ln->value;
+
+                if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_START)
+                    freeClient(slave);
+            }
+        }
+    }

 }
 
 static int syncWithMaster(void) {
 }
 
 static int syncWithMaster(void) {


@@ -2966,13 +4033,13 @@ static int syncWithMaster(void) {
         return REDIS_ERR;
     }
     /* Read the bulk write count */
         return REDIS_ERR;
     }
     /* Read the bulk write count */

-    if (syncReadLine(fd,buf,1024,5) == -1) {
+    if (syncReadLine(fd,buf,1024,3600) == -1) {

         close(fd);
         redisLog(REDIS_WARNING,"I/O error reading bulk count from MASTER: %s",
             strerror(errno));
         return REDIS_ERR;
     }
         close(fd);
         redisLog(REDIS_WARNING,"I/O error reading bulk count from MASTER: %s",
             strerror(errno));
         return REDIS_ERR;
     }

-    dumpsize = atoi(buf);
+    dumpsize = atoi(buf+1);

     redisLog(REDIS_NOTICE,"Receiving %d bytes data dump from MASTER",dumpsize);
     /* Read the bulk write data on a temp file */
     snprintf(tmpfile,256,"temp-%d.%ld.rdb",(int)time(NULL),(long int)random());
     redisLog(REDIS_NOTICE,"Receiving %d bytes data dump from MASTER",dumpsize);
     /* Read the bulk write data on a temp file */
     snprintf(tmpfile,256,"temp-%d.%ld.rdb",(int)time(NULL),(long int)random());


@@ -3010,7 +4077,7 @@ static int syncWithMaster(void) {
         return REDIS_ERR;
     }
     emptyDb();
         return REDIS_ERR;
     }
     emptyDb();

-    if (loadDb(server.dbfilename) != REDIS_OK) {
+    if (rdbLoad(server.dbfilename) != REDIS_OK) {

         redisLog(REDIS_WARNING,"Failed trying to load the MASTER synchronization DB from disk");
         close(fd);
         return REDIS_ERR;
         redisLog(REDIS_WARNING,"Failed trying to load the MASTER synchronization DB from disk");
         close(fd);
         return REDIS_ERR;


@@ -3021,8 +4088,341 @@ static int syncWithMaster(void) {
     return REDIS_OK;
 }
 
     return REDIS_OK;
 }
 

+static void slaveofCommand(redisClient *c) {
+    if (!strcasecmp(c->argv[1]->ptr,"no") &&
+        !strcasecmp(c->argv[2]->ptr,"one")) {
+        if (server.masterhost) {
+            sdsfree(server.masterhost);
+            server.masterhost = NULL;
+            if (server.master) freeClient(server.master);
+            server.replstate = REDIS_REPL_NONE;
+            redisLog(REDIS_NOTICE,"MASTER MODE enabled (user request)");
+        }
+    } else {
+        sdsfree(server.masterhost);
+        server.masterhost = sdsdup(c->argv[1]->ptr);
+        server.masterport = atoi(c->argv[2]->ptr);
+        if (server.master) freeClient(server.master);
+        server.replstate = REDIS_REPL_CONNECT;
+        redisLog(REDIS_NOTICE,"SLAVE OF %s:%d enabled (user request)",
+            server.masterhost, server.masterport);
+    }
+    addReply(c,shared.ok);
+}
+
+/* ============================ Maxmemory directive  ======================== */
+
+/* This function gets called when 'maxmemory' is set on the config file to limit
+ * the max memory used by the server, and we are out of memory.
+ * This function will try to, in order:
+ *
+ * - Free objects from the free list
+ * - Try to remove keys with an EXPIRE set
+ *
+ * It is not possible to free enough memory to reach used-memory < maxmemory
+ * the server will start refusing commands that will enlarge even more the
+ * memory usage.
+ */
+static void freeMemoryIfNeeded(void) {
+    while (server.maxmemory && zmalloc_used_memory() > server.maxmemory) {
+        if (listLength(server.objfreelist)) {
+            robj *o;
+
+            listNode *head = listFirst(server.objfreelist);
+            o = listNodeValue(head);
+            listDelNode(server.objfreelist,head);
+            zfree(o);
+        } else {
+            int j, k, freed = 0;
+
+            for (j = 0; j < server.dbnum; j++) {
+                int minttl = -1;
+                robj *minkey = NULL;
+                struct dictEntry *de;
+
+                if (dictSize(server.db[j].expires)) {
+                    freed = 1;
+                    /* From a sample of three keys drop the one nearest to
+                     * the natural expire */
+                    for (k = 0; k < 3; k++) {
+                        time_t t;
+
+                        de = dictGetRandomKey(server.db[j].expires);
+                        t = (time_t) dictGetEntryVal(de);
+                        if (minttl == -1 || t < minttl) {
+                            minkey = dictGetEntryKey(de);
+                            minttl = t;
+                        }
+                    }
+                    deleteKey(server.db+j,minkey);
+                }
+            }
+            if (!freed) return; /* nothing to free... */
+        }
+    }
+}
+
+/* ================================= Debugging ============================== */
+
+static void debugCommand(redisClient *c) {
+    if (!strcasecmp(c->argv[1]->ptr,"segfault")) {
+        *((char*)-1) = 'x';
+    } else if (!strcasecmp(c->argv[1]->ptr,"object") && c->argc == 3) {
+        dictEntry *de = dictFind(c->db->dict,c->argv[2]);
+        robj *key, *val;
+
+        if (!de) {
+            addReply(c,shared.nokeyerr);
+            return;
+        }
+        key = dictGetEntryKey(de);
+        val = dictGetEntryVal(de);
+        addReplySds(c,sdscatprintf(sdsempty(),
+            "+Key at:%p refcount:%d, value at:%p refcount:%d\r\n",
+                key, key->refcount, val, val->refcount));
+    } else {
+        addReplySds(c,sdsnew(
+            "-ERR Syntax error, try DEBUG [SEGFAULT|OBJECT <key>]\r\n"));
+    }
+}
+
+#ifdef HAVE_BACKTRACE
+static struct redisFunctionSym symsTable[] = {
+{"freeStringObject", (unsigned long)freeStringObject},
+{"freeListObject", (unsigned long)freeListObject},
+{"freeSetObject", (unsigned long)freeSetObject},
+{"decrRefCount", (unsigned long)decrRefCount},
+{"createObject", (unsigned long)createObject},
+{"freeClient", (unsigned long)freeClient},
+{"rdbLoad", (unsigned long)rdbLoad},
+{"addReply", (unsigned long)addReply},
+{"addReplySds", (unsigned long)addReplySds},
+{"incrRefCount", (unsigned long)incrRefCount},
+{"rdbSaveBackground", (unsigned long)rdbSaveBackground},
+{"createStringObject", (unsigned long)createStringObject},
+{"replicationFeedSlaves", (unsigned long)replicationFeedSlaves},
+{"syncWithMaster", (unsigned long)syncWithMaster},
+{"tryObjectSharing", (unsigned long)tryObjectSharing},
+{"removeExpire", (unsigned long)removeExpire},
+{"expireIfNeeded", (unsigned long)expireIfNeeded},
+{"deleteIfVolatile", (unsigned long)deleteIfVolatile},
+{"deleteKey", (unsigned long)deleteKey},
+{"getExpire", (unsigned long)getExpire},
+{"setExpire", (unsigned long)setExpire},
+{"updateSlavesWaitingBgsave", (unsigned long)updateSlavesWaitingBgsave},
+{"freeMemoryIfNeeded", (unsigned long)freeMemoryIfNeeded},
+{"authCommand", (unsigned long)authCommand},
+{"pingCommand", (unsigned long)pingCommand},
+{"echoCommand", (unsigned long)echoCommand},
+{"setCommand", (unsigned long)setCommand},
+{"setnxCommand", (unsigned long)setnxCommand},
+{"getCommand", (unsigned long)getCommand},
+{"delCommand", (unsigned long)delCommand},
+{"existsCommand", (unsigned long)existsCommand},
+{"incrCommand", (unsigned long)incrCommand},
+{"decrCommand", (unsigned long)decrCommand},
+{"incrbyCommand", (unsigned long)incrbyCommand},
+{"decrbyCommand", (unsigned long)decrbyCommand},
+{"selectCommand", (unsigned long)selectCommand},
+{"randomkeyCommand", (unsigned long)randomkeyCommand},
+{"keysCommand", (unsigned long)keysCommand},
+{"dbsizeCommand", (unsigned long)dbsizeCommand},
+{"lastsaveCommand", (unsigned long)lastsaveCommand},
+{"saveCommand", (unsigned long)saveCommand},
+{"bgsaveCommand", (unsigned long)bgsaveCommand},
+{"shutdownCommand", (unsigned long)shutdownCommand},
+{"moveCommand", (unsigned long)moveCommand},
+{"renameCommand", (unsigned long)renameCommand},
+{"renamenxCommand", (unsigned long)renamenxCommand},
+{"lpushCommand", (unsigned long)lpushCommand},
+{"rpushCommand", (unsigned long)rpushCommand},
+{"lpopCommand", (unsigned long)lpopCommand},
+{"rpopCommand", (unsigned long)rpopCommand},
+{"llenCommand", (unsigned long)llenCommand},
+{"lindexCommand", (unsigned long)lindexCommand},
+{"lrangeCommand", (unsigned long)lrangeCommand},
+{"ltrimCommand", (unsigned long)ltrimCommand},
+{"typeCommand", (unsigned long)typeCommand},
+{"lsetCommand", (unsigned long)lsetCommand},
+{"saddCommand", (unsigned long)saddCommand},
+{"sremCommand", (unsigned long)sremCommand},
+{"smoveCommand", (unsigned long)smoveCommand},
+{"sismemberCommand", (unsigned long)sismemberCommand},
+{"scardCommand", (unsigned long)scardCommand},
+{"spopCommand", (unsigned long)spopCommand},
+{"sinterCommand", (unsigned long)sinterCommand},
+{"sinterstoreCommand", (unsigned long)sinterstoreCommand},
+{"sunionCommand", (unsigned long)sunionCommand},
+{"sunionstoreCommand", (unsigned long)sunionstoreCommand},
+{"sdiffCommand", (unsigned long)sdiffCommand},
+{"sdiffstoreCommand", (unsigned long)sdiffstoreCommand},
+{"syncCommand", (unsigned long)syncCommand},
+{"flushdbCommand", (unsigned long)flushdbCommand},
+{"flushallCommand", (unsigned long)flushallCommand},
+{"sortCommand", (unsigned long)sortCommand},
+{"lremCommand", (unsigned long)lremCommand},
+{"infoCommand", (unsigned long)infoCommand},
+{"mgetCommand", (unsigned long)mgetCommand},
+{"monitorCommand", (unsigned long)monitorCommand},
+{"expireCommand", (unsigned long)expireCommand},
+{"getSetCommand", (unsigned long)getSetCommand},
+{"ttlCommand", (unsigned long)ttlCommand},
+{"slaveofCommand", (unsigned long)slaveofCommand},
+{"debugCommand", (unsigned long)debugCommand},
+{"processCommand", (unsigned long)processCommand},
+{"setupSigSegvAction", (unsigned long)setupSigSegvAction},
+{"readQueryFromClient", (unsigned long)readQueryFromClient},
+{"rdbRemoveTempFile", (unsigned long)rdbRemoveTempFile},
+{NULL,0}
+};
+
+/* This function try to convert a pointer into a function name. It's used in
+ * oreder to provide a backtrace under segmentation fault that's able to
+ * display functions declared as static (otherwise the backtrace is useless). */
+static char *findFuncName(void *pointer, unsigned long *offset){
+    int i, ret = -1;
+    unsigned long off, minoff = 0;
+
+    /* Try to match against the Symbol with the smallest offset */
+    for (i=0; symsTable[i].pointer; i++) {
+        unsigned long lp = (unsigned long) pointer;
+
+        if (lp != (unsigned long)-1 && lp >= symsTable[i].pointer) {
+            off=lp-symsTable[i].pointer;
+            if (ret < 0 || off < minoff) {
+                minoff=off;
+                ret=i;
+            }
+        }
+    }
+    if (ret == -1) return NULL;
+    *offset = minoff;
+    return symsTable[ret].name;
+}
+
+static void *getMcontextEip(ucontext_t *uc) {
+#if defined(__FreeBSD__)
+    return (void*) uc->uc_mcontext.mc_eip;
+#elif defined(__dietlibc__)
+    return (void*) uc->uc_mcontext.eip;
+#elif defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_6)
+    return (void*) uc->uc_mcontext->__ss.__eip;
+#elif defined(__APPLE__) && defined(MAC_OS_X_VERSION_10_6)
+  #ifdef _STRUCT_X86_THREAD_STATE64
+    return (void*) uc->uc_mcontext->__ss.__rip;
+  #else
+    return (void*) uc->uc_mcontext->__ss.__eip;
+  #endif 
+#elif defined(__i386__) || defined(__X86_64__) /* Linux x86 */
+    return (void*) uc->uc_mcontext.gregs[REG_EIP];
+#elif defined(__ia64__) /* Linux IA64 */
+    return (void*) uc->uc_mcontext.sc_ip;
+#else
+    return NULL;
+#endif
+}
+
+static void segvHandler(int sig, siginfo_t *info, void *secret) {
+    void *trace[100];
+    char **messages = NULL;
+    int i, trace_size = 0;
+    unsigned long offset=0;
+    time_t uptime = time(NULL)-server.stat_starttime;
+    ucontext_t *uc = (ucontext_t*) secret;
+    REDIS_NOTUSED(info);
+
+    redisLog(REDIS_WARNING,
+        "======= Ooops! Redis %s got signal: -%d- =======", REDIS_VERSION, sig);
+    redisLog(REDIS_WARNING, "%s", sdscatprintf(sdsempty(),
+        "redis_version:%s; "
+        "uptime_in_seconds:%d; "
+        "connected_clients:%d; "
+        "connected_slaves:%d; "
+        "used_memory:%zu; "
+        "changes_since_last_save:%lld; "
+        "bgsave_in_progress:%d; "
+        "last_save_time:%d; "
+        "total_connections_received:%lld; "
+        "total_commands_processed:%lld; "
+        "role:%s;"
+        ,REDIS_VERSION,
+        uptime,
+        listLength(server.clients)-listLength(server.slaves),
+        listLength(server.slaves),
+        server.usedmemory,
+        server.dirty,
+        server.bgsaveinprogress,
+        server.lastsave,
+        server.stat_numconnections,
+        server.stat_numcommands,
+        server.masterhost == NULL ? "master" : "slave"
+    ));
+    
+    trace_size = backtrace(trace, 100);
+    /* overwrite sigaction with caller's address */
+    if (getMcontextEip(uc) != NULL) {
+        trace[1] = getMcontextEip(uc);
+    }
+    messages = backtrace_symbols(trace, trace_size);
+
+    for (i=1; i<trace_size; ++i) {
+        char *fn = findFuncName(trace[i], &offset), *p;
+
+        p = strchr(messages[i],'+');
+        if (!fn || (p && ((unsigned long)strtol(p+1,NULL,10)) < offset)) {
+            redisLog(REDIS_WARNING,"%s", messages[i]);
+        } else {
+            redisLog(REDIS_WARNING,"%d redis-server %p %s + %d", i, trace[i], fn, (unsigned int)offset);
+        }
+    }
+    free(messages);
+    exit(0);
+}
+
+static void setupSigSegvAction(void) {
+    struct sigaction act;
+
+    sigemptyset (&act.sa_mask);
+    /* When the SA_SIGINFO flag is set in sa_flags then sa_sigaction
+     * is used. Otherwise, sa_handler is used */
+    act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND | SA_SIGINFO;
+    act.sa_sigaction = segvHandler;
+    sigaction (SIGSEGV, &act, NULL);
+    sigaction (SIGBUS, &act, NULL);
+    sigaction (SIGFPE, &act, NULL);
+    sigaction (SIGILL, &act, NULL);
+    sigaction (SIGBUS, &act, NULL);
+    return;
+}
+#else /* HAVE_BACKTRACE */
+static void setupSigSegvAction(void) {
+}
+#endif /* HAVE_BACKTRACE */
+

 /* =================================== Main! ================================ */
 
 /* =================================== Main! ================================ */
 

+#ifdef __linux__
+int linuxOvercommitMemoryValue(void) {
+    FILE *fp = fopen("/proc/sys/vm/overcommit_memory","r");
+    char buf[64];
+
+    if (!fp) return -1;
+    if (fgets(buf,64,fp) == NULL) {
+        fclose(fp);
+        return -1;
+    }
+    fclose(fp);
+
+    return atoi(buf);
+}
+
+void linuxOvercommitMemoryWarning(void) {
+    if (linuxOvercommitMemoryValue() == 0) {
+        redisLog(REDIS_WARNING,"WARNING overcommit_memory is set to 0! Background save may fail under low condition memory. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.");
+    }
+}
+#endif /* __linux__ */
+

 static void daemonize(void) {
     int fd;
     FILE *fp;
 static void daemonize(void) {
     int fd;
     FILE *fp;


@@ -3055,11 +4455,16 @@ int main(int argc, char **argv) {
     } else if (argc > 2) {
         fprintf(stderr,"Usage: ./redis-server [/path/to/redis.conf]\n");
         exit(1);
     } else if (argc > 2) {
         fprintf(stderr,"Usage: ./redis-server [/path/to/redis.conf]\n");
         exit(1);

+    } else {
+        redisLog(REDIS_WARNING,"Warning: no config file specified, using the default config. In order to specify a config file use 'redis-server /path/to/redis.conf'");

     }
     initServer();
     if (server.daemonize) daemonize();
     redisLog(REDIS_NOTICE,"Server started, Redis version " REDIS_VERSION);
     }
     initServer();
     if (server.daemonize) daemonize();
     redisLog(REDIS_NOTICE,"Server started, Redis version " REDIS_VERSION);

-    if (loadDb(server.dbfilename) == REDIS_OK)
+#ifdef __linux__
+    linuxOvercommitMemoryWarning();
+#endif
+    if (rdbLoad(server.dbfilename) == REDIS_OK)

         redisLog(REDIS_NOTICE,"DB loaded from disk");
     if (aeCreateFileEvent(server.el, server.fd, AE_READABLE,
         acceptHandler, NULL, NULL) == AE_ERR) oom("creating file event");
         redisLog(REDIS_NOTICE,"DB loaded from disk");
     if (aeCreateFileEvent(server.el, server.fd, AE_READABLE,
         acceptHandler, NULL, NULL) == AE_ERR) oom("creating file event");