disconnect when we cannot read from the socket

[redis.git] / redis.c

diff --git a/redis.c b/redis.c
index cf3d667567129b96739e5da5ec88a2b3cc12f832..7f1cc3b6187541a1a49806833b732e45c77e5d47 100644 (file)
--- a/redis.c
+++ b/redis.c
@@ -27,7 +27,9 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
  * POSSIBILITY OF SUCH DAMAGE.
  */
 

-#define REDIS_VERSION "0.08"
+#define REDIS_VERSION "0.100"
+
+#include "fmacros.h"

 
 #include <stdio.h>
 #include <stdlib.h>
 
 #include <stdio.h>
 #include <stdlib.h>


@@ -54,6 +56,7 @@
 #include "dict.h"   /* Hash tables */
 #include "adlist.h" /* Linked lists */
 #include "zmalloc.h" /* total memory usage aware version of malloc/free */
 #include "dict.h"   /* Hash tables */
 #include "adlist.h" /* Linked lists */
 #include "zmalloc.h" /* total memory usage aware version of malloc/free */

+#include "lzf.h"

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


@@ -62,13 +65,14 @@
 /* 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 */

 
 /* 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% */


@@ -85,6 +89,7 @@
 #define REDIS_HASH 3
 
 /* Object types only used for dumping to disk */
 #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
 


@@ -104,7 +109,7 @@
 #define REDIS_RDB_6BITLEN 0
 #define REDIS_RDB_14BITLEN 1
 #define REDIS_RDB_32BITLEN 2
 #define REDIS_RDB_6BITLEN 0
 #define REDIS_RDB_14BITLEN 1
 #define REDIS_RDB_32BITLEN 2

-#define REDIS_RDB_64BITLEN 3
+#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
 #define REDIS_RDB_LENERR UINT_MAX
 
 /* When a length of a string object stored on disk has the first two bits


@@ -113,7 +118,7 @@
 #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_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_FLZ 3         /* string compressed with FASTLZ */
+#define REDIS_RDB_ENC_LZF 3         /* string compressed with FASTLZ */

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


@@ -121,11 +126,20 @@
 #define REDIS_MASTER 4      /* This client is a master server */
 #define REDIS_MONITOR 8      /* This client is a slave monitor, see MONITOR */
 
 #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


@@ -151,27 +165,37 @@
 
 /* A redis object, that is a type able to hold a string / list / set */
 typedef struct redisObject {
 
 /* 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 | REDIS_MONITOR */
-    int slaveseldb; /* slave selected db, if this client is a slave */
-    int authenticated;    /* when requirepass is non-NULL */
+    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 {


@@ -183,7 +207,7 @@ 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 */
     dict *sharingpool;
     unsigned int sharingpoolsize;
     long long dirty;            /* changes to DB from the last save */


@@ -194,7 +218,7 @@ struct redisServer {
     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 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 */


@@ -218,7 +242,7 @@ struct redisServer {
     int isslave;
     char *masterhost;
     int masterport;
     int isslave;
     char *masterhost;
     int masterport;

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

     int replstate;
     /* 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 replstate;
     /* Sort parameters - qsort_r() is only available under BSD so we
      * have to take this state global, in order to pass it to sortCompare() */


@@ -274,6 +298,13 @@ static robj *createStringObject(char *ptr, size_t len);
 static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int dictid, robj **argv, int argc);
 static int syncWithMaster(void);
 static robj *tryObjectSharing(robj *o);
 static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int dictid, robj **argv, int argc);
 static int syncWithMaster(void);
 static robj *tryObjectSharing(robj *o);

+static int removeExpire(redisDb *db, robj *key);
+static int expireIfNeeded(redisDb *db, robj *key);
+static int deleteIfVolatile(redisDb *db, robj *key);
+static int deleteKey(redisDb *db, robj *key);
+static time_t getExpire(redisDb *db, robj *key);
+static int setExpire(redisDb *db, robj *key, time_t when);
+static void updateSalvesWaitingBgsave(int bgsaveerr);

 
 static void authCommand(redisClient *c);
 static void pingCommand(redisClient *c);
 
 static void authCommand(redisClient *c);
 static void pingCommand(redisClient *c);


@@ -310,10 +341,13 @@ 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 sinterCommand(redisClient *c);
 static void sinterstoreCommand(redisClient *c);
 static void sismemberCommand(redisClient *c);
 static void scardCommand(redisClient *c);
 static void sinterCommand(redisClient *c);
 static void sinterstoreCommand(redisClient *c);

+static void sunionCommand(redisClient *c);
+static void sunionstoreCommand(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);


@@ -322,6 +356,8 @@ static void lremCommand(redisClient *c);
 static void infoCommand(redisClient *c);
 static void mgetCommand(redisClient *c);
 static void monitorCommand(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);

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


@@ -331,7 +367,7 @@ static struct redisCommand cmdTable[] = {
     {"get",getCommand,2,REDIS_CMD_INLINE},
     {"set",setCommand,3,REDIS_CMD_BULK},
     {"setnx",setnxCommand,3,REDIS_CMD_BULK},
     {"get",getCommand,2,REDIS_CMD_INLINE},
     {"set",setCommand,3,REDIS_CMD_BULK},
     {"setnx",setnxCommand,3,REDIS_CMD_BULK},

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

     {"exists",existsCommand,2,REDIS_CMD_INLINE},
     {"incr",incrCommand,2,REDIS_CMD_INLINE},
     {"decr",decrCommand,2,REDIS_CMD_INLINE},
     {"exists",existsCommand,2,REDIS_CMD_INLINE},
     {"incr",incrCommand,2,REDIS_CMD_INLINE},
     {"decr",decrCommand,2,REDIS_CMD_INLINE},


@@ -348,13 +384,17 @@ static struct redisCommand cmdTable[] = {
     {"lrem",lremCommand,4,REDIS_CMD_BULK},
     {"sadd",saddCommand,3,REDIS_CMD_BULK},
     {"srem",sremCommand,3,REDIS_CMD_BULK},
     {"lrem",lremCommand,4,REDIS_CMD_BULK},
     {"sadd",saddCommand,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},
     {"sinter",sinterCommand,-2,REDIS_CMD_INLINE},
     {"sinterstore",sinterstoreCommand,-3,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},

+    {"sunion",sunionCommand,-2,REDIS_CMD_INLINE},
+    {"sunionstore",sunionstoreCommand,-3,REDIS_CMD_INLINE},

     {"smembers",sinterCommand,2,REDIS_CMD_INLINE},
     {"incrby",incrbyCommand,3,REDIS_CMD_INLINE},
     {"decrby",decrbyCommand,3,REDIS_CMD_INLINE},
     {"smembers",sinterCommand,2,REDIS_CMD_INLINE},
     {"incrby",incrbyCommand,3,REDIS_CMD_INLINE},
     {"decrby",decrbyCommand,3,REDIS_CMD_INLINE},

+    {"getset",getSetCommand,3,REDIS_CMD_BULK},

     {"randomkey",randomkeyCommand,1,REDIS_CMD_INLINE},
     {"select",selectCommand,2,REDIS_CMD_INLINE},
     {"move",moveCommand,3,REDIS_CMD_INLINE},
     {"randomkey",randomkeyCommand,1,REDIS_CMD_INLINE},
     {"select",selectCommand,2,REDIS_CMD_INLINE},
     {"move",moveCommand,3,REDIS_CMD_INLINE},


@@ -376,6 +416,7 @@ static struct redisCommand cmdTable[] = {
     {"sort",sortCommand,-2,REDIS_CMD_INLINE},
     {"info",infoCommand,1,REDIS_CMD_INLINE},
     {"monitor",monitorCommand,1,REDIS_CMD_INLINE},
     {"sort",sortCommand,-2,REDIS_CMD_INLINE},
     {"info",infoCommand,1,REDIS_CMD_INLINE},
     {"monitor",monitorCommand,1,REDIS_CMD_INLINE},

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

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


@@ -597,13 +638,11 @@ static void oom(const char *msg) {
 /* ====================== Redis server networking stuff ===================== */
 void closeTimedoutClients(void) {
     redisClient *c;
 /* ====================== Redis server networking stuff ===================== */
 void closeTimedoutClients(void) {
     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 */
              (now - c->lastinteraction > server.maxidletime)) {
         c = listNodeValue(ln);
         if (!(c->flags & REDIS_SLAVE) &&    /* no timeout for slaves */
              (now - c->lastinteraction > server.maxidletime)) {


@@ -611,11 +650,29 @@ void closeTimedoutClients(void) {
             freeClient(c);
         }
     }
             freeClient(c);
         }
     }

-    listReleaseIterator(li);
+}
+
+/* If the percentage of used slots in the HT reaches REDIS_HT_MINFILL
+ * we resize the hash table to save memory */
+void tryResizeHashTables(void) {
+    int j;
+
+    for (j = 0; j < server.dbnum; j++) {
+        long long size, used;
+
+        size = dictSlots(server.db[j].dict);
+        used = dictSize(server.db[j].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.db[j].dict);
+            redisLog(REDIS_NOTICE,"Hash table %d resized.",j);
+        }
+    }

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

-    int j, size, used, loops = server.cronloops++;
+    int j, loops = server.cronloops++;

     REDIS_NOTUSED(eventLoop);
     REDIS_NOTUSED(id);
     REDIS_NOTUSED(clientData);
     REDIS_NOTUSED(eventLoop);
     REDIS_NOTUSED(id);
     REDIS_NOTUSED(clientData);


@@ -623,30 +680,34 @@ 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]);
+        long long size, used, vkeys;
+
+        size = dictSlots(server.db[j].dict);
+        used = dictSize(server.db[j].dict);
+        vkeys = dictSize(server.db[j].expires);

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

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

             /* dictPrintStats(server.dict); */
         }
             /* 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);
-        }

     }
 
     }
 

+    /* 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",

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

-            dictGetHashTableUsed(server.sharingpool));
+            dictSize(server.sharingpool));

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


@@ -656,6 +717,7 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
     /* Check if a background saving in progress terminated */
     if (server.bgsaveinprogress) {
         int statloc;
     /* Check if a background saving in progress terminated */
     if (server.bgsaveinprogress) {
         int statloc;

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

         if (wait4(-1,&statloc,WNOHANG,NULL)) {
             int exitcode = WEXITSTATUS(statloc);
             if (exitcode == 0) {
         if (wait4(-1,&statloc,WNOHANG,NULL)) {
             int exitcode = WEXITSTATUS(statloc);
             if (exitcode == 0) {


@@ -668,6 +730,7 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
                     "Background saving error");
             }
             server.bgsaveinprogress = 0;
                     "Background saving error");
             }
             server.bgsaveinprogress = 0;

+            updateSalvesWaitingBgsave(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


@@ -685,6 +748,30 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
             }
          }
     }
             }
          }
     }

+
+    /* 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...");


@@ -785,18 +872,21 @@ static void initServer() {
     server.objfreelist = listCreate();
     createSharedObjects();
     server.el = aeCreateEventLoop();
     server.objfreelist = listCreate();
     createSharedObjects();
     server.el = aeCreateEventLoop();

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

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

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

         oom("server initialization"); /* Fatal OOM */
     server.fd = anetTcpServer(server.neterr, server.port, server.bindaddr);
     if (server.fd == -1) {
         redisLog(REDIS_WARNING, "Opening TCP port: %s", server.neterr);
         exit(1);
     }
         oom("server initialization"); /* Fatal OOM */
     server.fd = anetTcpServer(server.neterr, server.port, server.bindaddr);
     if (server.fd == -1) {
         redisLog(REDIS_WARNING, "Opening TCP port: %s", server.neterr);
         exit(1);
     }

-    for (j = 0; j < server.dbnum; j++)
-        server.dict[j] = dictCreate(&hashDictType,NULL);
+    for (j = 0; j < server.dbnum; j++) {
+        server.db[j].dict = dictCreate(&hashDictType,NULL);
+        server.db[j].expires = dictCreate(&setDictType,NULL);
+        server.db[j].id = j;
+    }

     server.cronloops = 0;
     server.bgsaveinprogress = 0;
     server.lastsave = time(NULL);
     server.cronloops = 0;
     server.bgsaveinprogress = 0;
     server.lastsave = time(NULL);


@@ -809,11 +899,22 @@ 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++)
-        dictEmpty(server.dict[j]);
+    for (j = 0; j < server.dbnum; j++) {
+        removed += dictSize(server.db[j].dict);
+        dictEmpty(server.db[j].dict);
+        dictEmpty(server.db[j].expires);
+    }
+    return removed;
+}
+
+static int yesnotoi(char *s) {
+    if (!strcasecmp(s,"yes")) return 1;
+    else if (!strcasecmp(s,"no")) return 0;
+    else return -1;

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


@@ -847,44 +948,44 @@ 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]);
             if (server.maxidletime < 1) {
                 err = "Invalid timeout value"; goto loaderr;
             }
             server.maxidletime = atoi(argv[1]);
             if (server.maxidletime < 1) {
                 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) {
+        } else if (!strcasecmp(argv[0],"logfile") && argc == 2) {

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

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

                 zfree(server.logfile);
                 server.logfile = NULL;
             }
                 zfree(server.logfile);
                 server.logfile = NULL;
             }


@@ -899,40 +1000,33 @@ static void loadServerConfig(char *filename) {
                 }
                 fclose(fp);
             }
                 }
                 fclose(fp);
             }

-        } 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],"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],"shareobjects") && argc == 2) {
-            sdstolower(argv[1]);
-            if (!strcmp(argv[1],"yes")) server.shareobjects = 1;
-            else if (!strcmp(argv[1],"no")) server.shareobjects = 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],"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],"daemonize") && argc == 2) {
+            if ((server.daemonize = 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],"requirepass") && argc == 2) {
+        } else if (!strcasecmp(argv[0],"requirepass") && argc == 2) {

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

-        } else if (!strcmp(argv[0],"pidfile") && argc == 2) {
+        } 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;
         }


@@ -973,6 +1067,8 @@ 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) {

+        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);
         list *l = (c->flags & REDIS_MONITOR) ? server.monitors : server.slaves;
         ln = listSearchKey(l,c);
         assert(ln != NULL);


@@ -982,18 +1078,19 @@ static void freeClient(redisClient *c) {
         server.master = NULL;
         server.replstate = REDIS_REPL_CONNECT;
     }
         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;


@@ -1002,14 +1099,12 @@ 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 */
         addReplySds(c,sdsnewlen(buf,totlen));
         }
         /* Now the output buffer is empty, add the new single element */
         addReplySds(c,sdsnewlen(buf,totlen));


@@ -1068,7 +1163,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;


@@ -1092,10 +1187,9 @@ static int processCommand(redisClient *c) {
     struct redisCommand *cmd;
     long long dirty;
 
     struct redisCommand *cmd;
     long long dirty;
 

-    sdstolower(c->argv[0]->ptr);

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


@@ -1148,9 +1242,9 @@ static int processCommand(redisClient *c) {
     dirty = server.dirty;
     cmd->proc(c);
     if (server.dirty-dirty != 0 && listLength(server.slaves))
     dirty = server.dirty;
     cmd->proc(c);
     if (server.dirty-dirty != 0 && listLength(server.slaves))

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

     if (listLength(server.monitors))
     if (listLength(server.monitors))

-        replicationFeedSlaves(server.monitors,cmd,c->dictid,c->argv,c->argc);
+        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 */


@@ -1163,9 +1257,18 @@ static int processCommand(redisClient *c) {
 }
 
 static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int dictid, robj **argv, int argc) {
 }
 
 static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int dictid, robj **argv, int argc) {

-    listNode *ln = slaves->head;
-    robj *outv[REDIS_MAX_ARGS*4]; /* enough room for args, spaces, newlines */
+    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;


@@ -1181,8 +1284,18 @@ static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int di
     }
     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;
 


@@ -1207,18 +1320,19 @@ static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int di
             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;


@@ -1266,9 +1380,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++;


@@ -1308,11 +1427,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));
 


@@ -1323,13 +1446,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->authenticated = 0;
     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);


@@ -1341,6 +1467,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");


@@ -1411,14 +1539,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);
 }


@@ -1437,10 +1557,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;


@@ -1460,7 +1589,7 @@ static robj *tryObjectSharing(robj *o) {
     struct dictEntry *de;
     unsigned long c;
 
     struct dictEntry *de;
     unsigned long c;
 

-    if (server.shareobjects == 0) return o;
+    if (o == NULL || server.shareobjects == 0) return o;

 
     assert(o->type == REDIS_STRING);
     de = dictFind(server.sharingpool,o);
 
     assert(o->type == REDIS_STRING);
     de = dictFind(server.sharingpool,o);


@@ -1477,7 +1606,7 @@ static robj *tryObjectSharing(robj *o) {
          * 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. */
          * 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 (dictGetHashTableUsed(server.sharingpool) >=
+        if (dictSize(server.sharingpool) >=

                 server.sharingpoolsize) {
             de = dictGetRandomKey(server.sharingpool);
             assert(de != NULL);
                 server.sharingpoolsize) {
             de = dictGetRandomKey(server.sharingpool);
             assert(de != NULL);


@@ -1500,6 +1629,36 @@ static robj *tryObjectSharing(robj *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 ============================ */
 
 static int rdbSaveType(FILE *fp, unsigned char type) {
 /*============================ DB saving/loading ============================ */
 
 static int rdbSaveType(FILE *fp, unsigned char type) {


@@ -1507,6 +1666,13 @@ static int rdbSaveType(FILE *fp, unsigned char type) {
     return 0;
 }
 
     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];
 
 static int rdbSaveLen(FILE *fp, uint32_t len) {
     unsigned char buf[2];
 


@@ -1518,7 +1684,7 @@ static int rdbSaveLen(FILE *fp, uint32_t len) {
         /* Save a 14 bit len */
         buf[0] = ((len>>8)&0xFF)|(REDIS_RDB_14BITLEN<<6);
         buf[1] = len&0xFF;
         /* Save a 14 bit len */
         buf[0] = ((len>>8)&0xFF)|(REDIS_RDB_14BITLEN<<6);
         buf[1] = len&0xFF;

-        if (fwrite(buf,4,1,fp) == 0) return -1;
+        if (fwrite(buf,2,1,fp) == 0) return -1;

     } else {
         /* Save a 32 bit len */
         buf[0] = (REDIS_RDB_32BITLEN<<6);
     } else {
         /* Save a 32 bit len */
         buf[0] = (REDIS_RDB_32BITLEN<<6);


@@ -1529,9 +1695,99 @@ static int rdbSaveLen(FILE *fp, uint32_t len) {
     return 0;
 }
 
     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 */
+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);
 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;
     if (rdbSaveLen(fp,len) == -1) return -1;
     if (len && fwrite(obj->ptr,len,1,fp) == 0) return -1;
     return 0;


@@ -1544,6 +1800,7 @@ static int rdbSave(char *filename) {
     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());
     fp = fopen(tmpfile,"w");
 
     snprintf(tmpfile,256,"temp-%d.%ld.rdb",(int)time(NULL),(long int)random());
     fp = fopen(tmpfile,"w");


@@ -1553,8 +1810,9 @@ static int rdbSave(char *filename) {
     }
     if (fwrite("REDIS0001",9,1,fp) == 0) goto werr;
     for (j = 0; j < server.dbnum; j++) {
     }
     if (fwrite("REDIS0001",9,1,fp) == 0) goto werr;
     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);


@@ -1569,7 +1827,16 @@ static int rdbSave(char *filename) {
         while((de = dictNext(di)) != NULL) {
             robj *key = dictGetEntryKey(de);
             robj *o = dictGetEntryVal(de);
         while((de = dictNext(di)) != NULL) {
             robj *key = dictGetEntryKey(de);
             robj *o = dictGetEntryVal(de);

-
+            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) {
             if (rdbSaveType(fp,o->type) == -1) goto werr;
             if (rdbSaveStringObject(fp,key) == -1) goto werr;
             if (o->type == REDIS_STRING) {


@@ -1578,14 +1845,14 @@ static int rdbSave(char *filename) {
             } else if (o->type == REDIS_LIST) {
                 /* Save a list value */
                 list *list = o->ptr;
             } else if (o->type == REDIS_LIST) {
                 /* Save a list value */
                 list *list = o->ptr;

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

 
 

+                listRewind(list);

                 if (rdbSaveLen(fp,listLength(list)) == -1) goto werr;
                 if (rdbSaveLen(fp,listLength(list)) == -1) goto werr;

-                while(ln) {
+                while((ln = listYield(list))) {

                     robj *eleobj = listNodeValue(ln);
 
                     if (rdbSaveStringObject(fp,eleobj) == -1) goto werr;
                     robj *eleobj = listNodeValue(ln);
 
                     if (rdbSaveStringObject(fp,eleobj) == -1) goto werr;

-                    ln = ln->next;

                 }
             } else if (o->type == REDIS_SET) {
                 /* Save a set value */
                 }
             } else if (o->type == REDIS_SET) {
                 /* Save a set value */


@@ -1594,7 +1861,7 @@ static int rdbSave(char *filename) {
                 dictEntry *de;
 
                 if (!set) oom("dictGetIteraotr");
                 dictEntry *de;
 
                 if (!set) oom("dictGetIteraotr");

-                if (rdbSaveLen(fp,dictGetHashTableUsed(set)) == -1) goto werr;
+                if (rdbSaveLen(fp,dictSize(set)) == -1) goto werr;

                 while((de = dictNext(di)) != NULL) {
                     robj *eleobj = dictGetEntryKey(de);
 
                 while((de = dictNext(di)) != NULL) {
                     robj *eleobj = dictGetEntryKey(de);
 


@@ -1649,6 +1916,11 @@ static int rdbSaveBackground(char *filename) {
         }
     } else {
         /* Parent */
         }
     } 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;
         return REDIS_OK;
         redisLog(REDIS_NOTICE,"Background saving started by pid %d",childpid);
         server.bgsaveinprogress = 1;
         return REDIS_OK;


@@ -1662,19 +1934,38 @@ static int rdbLoadType(FILE *fp) {
     return type;
 }
 
     return type;
 }
 

-static uint32_t rdbLoadLen(FILE *fp, int rdbver) {
+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;
 
     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 {
     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;
         if (fread(buf,1,1,fp) == 0) return REDIS_RDB_LENERR;

-        if ((buf[0]&0xC0) == REDIS_RDB_6BITLEN) {
+        type = (buf[0]&0xC0)>>6;
+        if (type == REDIS_RDB_6BITLEN) {

             /* Read a 6 bit len */
             /* Read a 6 bit len */

-            return buf[0];
-        } else if ((buf[0]&0xC0) == REDIS_RDB_14BITLEN) {
+            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];
             /* Read a 14 bit len */
             if (fread(buf+1,1,1,fp) == 0) return REDIS_RDB_LENERR;
             return ((buf[0]&0x3F)<<8)|buf[1];


@@ -1686,10 +1977,68 @@ static uint32_t rdbLoadLen(FILE *fp, int rdbver) {
     }
 }
 
     }
 }
 

-static robj *rdbLoadStringObject(FILE*fp,int rdbver) {
-    uint32_t len = rdbLoadLen(fp,rdbver);
+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;
 
     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) {
     if (len == REDIS_RDB_LENERR) return NULL;
     val = sdsnewlen(NULL,len);
     if (len && fread(val,len,1,fp) == 0) {


@@ -1703,11 +2052,12 @@ static int rdbLoad(char *filename) {
     FILE *fp;
     robj *keyobj = NULL;
     uint32_t dbid;
     FILE *fp;
     robj *keyobj = NULL;
     uint32_t dbid;

-    int type;
-    int retval;
-    dict *d = server.dict[0];
+    int type, retval, rdbver;
+    dict *d = server.db[0].dict;
+    redisDb *db = server.db+0;

     char buf[1024];
     char buf[1024];

-    int rdbver;
+    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;


@@ -1728,15 +2078,22 @@ static int rdbLoad(char *filename) {
 
         /* Read type. */
         if ((type = rdbLoadType(fp)) == -1) goto eoferr;
 
         /* Read type. */
         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 ((dbid = rdbLoadLen(fp,rdbver)) == REDIS_RDB_LENERR) goto eoferr;
+            if ((dbid = rdbLoadLen(fp,rdbver,NULL)) == REDIS_RDB_LENERR)
+                goto eoferr;

             if (dbid >= (unsigned)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);
             }
             if (dbid >= (unsigned)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);
             }

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

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


@@ -1749,7 +2106,7 @@ static int rdbLoad(char *filename) {
             /* Read list/set value */
             uint32_t listlen;
 
             /* Read list/set value */
             uint32_t listlen;
 

-            if ((listlen = rdbLoadLen(fp,rdbver)) == REDIS_RDB_LENERR)
+            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 */
                 goto eoferr;
             o = (type == REDIS_LIST) ? createListObject() : createSetObject();
             /* Load every single element of the list/set */


@@ -1774,14 +2131,21 @@ static int rdbLoad(char *filename) {
             redisLog(REDIS_WARNING,"Loading DB, duplicated key (%s) found! Unrecoverable error, exiting now.", keyobj->ptr);
             exit(1);
         }
             redisLog(REDIS_WARNING,"Loading DB, duplicated key (%s) found! Unrecoverable error, exiting now.", keyobj->ptr);
             exit(1);
         }

+        /* 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 */
         keyobj = o = NULL;
     }
     fclose(fp);
     return REDIS_OK;
 
 eoferr: /* unexpected end of file is handled here with a fatal exit */

-    decrRefCount(keyobj);
-    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 */
 }
     exit(1);
     return REDIS_ERR; /* Just to avoid warning */
 }


@@ -1789,7 +2153,7 @@ eoferr: /* unexpected end of file is handled here with a fatal exit */
 /*================================== Commands =============================== */
 
 static void authCommand(redisClient *c) {
 /*================================== Commands =============================== */
 
 static void authCommand(redisClient *c) {

-    if (!strcmp(c->argv[1]->ptr, server.requirepass)) {
+    if (!server.requirepass || !strcmp(c->argv[1]->ptr, server.requirepass)) {

       c->authenticated = 1;
       addReply(c,shared.ok);
     } else {
       c->authenticated = 1;
       addReply(c,shared.ok);
     } else {


@@ -1814,10 +2178,10 @@ 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 {
             addReply(c,shared.czero);
             incrRefCount(c->argv[2]);
         } else {
             addReply(c,shared.czero);


@@ -1828,6 +2192,7 @@ static void setGenericCommand(redisClient *c, int nx) {
         incrRefCount(c->argv[2]);
     }
     server.dirty++;
         incrRefCount(c->argv[2]);
     }
     server.dirty++;

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

     addReply(c, nx ? shared.cone : shared.ok);
 }
 
     addReply(c, nx ? shared.cone : shared.ok);
 }
 


@@ -1840,14 +2205,11 @@ static void setnxCommand(redisClient *c) {
 }
 
 static void getCommand(redisClient *c) {
 }
 
 static void getCommand(redisClient *c) {

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

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

-        robj *o = dictGetEntryVal(de);
-        

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


@@ -1858,18 +2220,27 @@ static void getCommand(redisClient *c) {
     }
 }
 
     }
 }
 

+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;
   
     addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",c->argc-1));
     for (j = 1; j < c->argc; j++) {
     int j;
   
     addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",c->argc-1));
     for (j = 1; j < c->argc; j++) {

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

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

-            robj *o = dictGetEntryVal(de);
-            

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


@@ -1881,18 +2252,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 {


@@ -1904,9 +2272,10 @@ 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]);
     }
     } else {
         incrRefCount(c->argv[1]);
     }


@@ -1925,41 +2294,48 @@ static void decrCommand(redisClient *c) {
 }
 
 static void incrbyCommand(redisClient *c) {
 }
 
 static void incrbyCommand(redisClient *c) {

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

     incrDecrCommand(c,incr);
 }
 
 static void decrbyCommand(redisClient *c) {
     incrDecrCommand(c,incr);
 }
 
 static void decrbyCommand(redisClient *c) {

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

     incrDecrCommand(c,-incr);
 }
 
 /* ========================= Type agnostic commands ========================= */
 
 static void delCommand(redisClient *c) {
     incrDecrCommand(c,-incr);
 }
 
 /* ========================= Type agnostic commands ========================= */
 
 static void delCommand(redisClient *c) {

-    if (dictDelete(c->dict,c->argv[1]) == DICT_OK) {
-        server.dirty++;
-        addReply(c,shared.cone);
-    } else {
+    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);
         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.czero);
-    else
-        addReply(c,shared.cone);
+    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);
     }


@@ -1967,9 +2343,13 @@ 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.plus);
         addReply(c,shared.crlf);
     } else {
         addReply(c,shared.plus);


@@ -1986,20 +2366,23 @@ 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);


@@ -2009,7 +2392,7 @@ static void keysCommand(redisClient *c) {
 
 static void dbsizeCommand(redisClient *c) {
     addReplySds(c,
 
 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) {
 }
 
 static void lastsaveCommand(redisClient *c) {


@@ -2018,15 +2401,13 @@ static void lastsaveCommand(redisClient *c) {
 }
 
 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) {
+
+    o = lookupKeyRead(c->db,c->argv[1]);
+    if (o == NULL) {

         type = "+none";
     } else {
         type = "+none";
     } else {

-        robj *o = dictGetEntryVal(de);
-        

         switch(o->type) {
         case REDIS_STRING: type = "+string"; break;
         case REDIS_LIST: type = "+list"; break;
         switch(o->type) {
         case REDIS_STRING: type = "+string"; break;
         case REDIS_LIST: type = "+list"; break;


@@ -2039,6 +2420,10 @@ static void typeCommand(redisClient *c) {
 }
 
 static void saveCommand(redisClient *c) {
 }
 
 static void saveCommand(redisClient *c) {

+    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 {
     if (rdbSave(server.dbfilename) == REDIS_OK) {
         addReply(c,shared.ok);
     } else {


@@ -2060,10 +2445,12 @@ 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...");

+    /* XXX: TODO kill the child if there is a bgsave in progress */

     if (rdbSave(server.dbfilename) == REDIS_OK) {
         if (server.daemonize) {
     if (rdbSave(server.dbfilename) == REDIS_OK) {
         if (server.daemonize) {

-          unlink(server.pidfile);
+            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 {


@@ -2073,7 +2460,6 @@ static void shutdownCommand(redisClient *c) {
 }
 
 static void renameGenericCommand(redisClient *c, int nx) {
 }
 
 static void renameGenericCommand(redisClient *c, int nx) {

-    dictEntry *de;

     robj *o;
 
     /* To use the same key as src and dst is probably an error */
     robj *o;
 
     /* To use the same key as src and dst is probably an error */


@@ -2082,24 +2468,24 @@ static void renameGenericCommand(redisClient *c, int nx) {
         return;
     }
 
         return;
     }
 

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

         addReply(c,shared.nokeyerr);
         return;
     }
         addReply(c,shared.nokeyerr);
         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);
             addReply(c,shared.czero);
             return;
         }
         if (nx) {
             decrRefCount(o);
             addReply(c,shared.czero);
             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++;
     addReply(c,nx ? shared.cone : shared.ok);
 }
     server.dirty++;
     addReply(c,nx ? shared.cone : shared.ok);
 }


@@ -2113,21 +2499,19 @@ 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) {
         addReply(c,shared.outofrangeerr);
         return;
     }
     if (selectDb(c,atoi(c->argv[2]->ptr)) == REDIS_ERR) {
         addReply(c,shared.outofrangeerr);
         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 the user is moving using as target the same
      * DB as the source DB it is probably an error. */


@@ -2137,24 +2521,23 @@ static void moveCommand(redisClient *c) {
     }
 
     /* Check if the element exists and get a reference */
     }
 
     /* Check if the element exists and get a reference */

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

         addReply(c,shared.czero);
         return;
     }
 
     /* Try to add the element to the target DB */
         addReply(c,shared.czero);
         return;
     }
 
     /* Try to add the element to the target DB */

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

         addReply(c,shared.czero);
         return;
     }
         addReply(c,shared.czero);
         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++;
     addReply(c,shared.cone);
 }
     server.dirty++;
     addReply(c,shared.cone);
 }


@@ -2162,11 +2545,10 @@ static void moveCommand(redisClient *c) {
 /* =================================== 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) {


@@ -2174,11 +2556,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;


@@ -2204,15 +2585,14 @@ 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) {
+    o = lookupKeyRead(c->db,c->argv[1]);
+    if (o == NULL) {

         addReply(c,shared.czero);
         return;
     } else {
         addReply(c,shared.czero);
         return;
     } 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 {


@@ -2223,15 +2603,13 @@ static void llenCommand(redisClient *c) {
 }
 
 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) {
+    o = lookupKeyRead(c->db,c->argv[1]);
+    if (o == NULL) {

         addReply(c,shared.nullbulk);
     } else {
         addReply(c,shared.nullbulk);
     } 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 {


@@ -2252,15 +2630,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 {


@@ -2284,14 +2660,12 @@ 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) {
+    robj *o;
+
+    o = lookupKeyWrite(c->db,c->argv[1]);
+    if (o == NULL) {

         addReply(c,shared.nullbulk);
     } else {
         addReply(c,shared.nullbulk);
     } 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 {


@@ -2326,16 +2700,14 @@ 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) {
+
+    o = lookupKeyRead(c->db,c->argv[1]);
+    if (o == NULL) {

         addReply(c,shared.nullmultibulk);
     } else {
         addReply(c,shared.nullmultibulk);
     } 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 {


@@ -2375,16 +2747,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 {


@@ -2426,14 +2796,12 @@ static void ltrimCommand(redisClient *c) {
 }
 
 static void lremCommand(redisClient *c) {
 }
 
 static void lremCommand(redisClient *c) {

-    dictEntry *de;
+    robj *o;

     
     

-    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 {


@@ -2468,16 +2836,14 @@ 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) {
             addReply(c,shared.wrongtypeerr);
             return;
         if (set->type != REDIS_SET) {
             addReply(c,shared.wrongtypeerr);
             return;


@@ -2493,15 +2859,12 @@ static void saddCommand(redisClient *c) {
 }
 
 static void sremCommand(redisClient *c) {
 }
 
 static void sremCommand(redisClient *c) {

-    dictEntry *de;
+    robj *set;

 
 

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

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

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

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


@@ -2515,16 +2878,48 @@ static void sremCommand(redisClient *c) {
     }
 }
 
     }
 }
 

+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) {
+    set = lookupKeyRead(c->db,c->argv[1]);
+    if (set == NULL) {

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

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

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


@@ -2537,21 +2932,20 @@ static void sismemberCommand(redisClient *c) {
 }
 
 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) {
+    o = lookupKeyRead(c->db,c->argv[1]);
+    if (o == NULL) {

         addReply(c,shared.czero);
         return;
     } else {
         addReply(c,shared.czero);
         return;
     } else {

-        robj *o = dictGetEntryVal(de);

         if (o->type != REDIS_SET) {
             addReply(c,shared.wrongtypeerr);
         } else {
             s = o->ptr;
             addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",
         if (o->type != REDIS_SET) {
             addReply(c,shared.wrongtypeerr);
         } else {
             s = o->ptr;
             addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",

-                dictGetHashTableUsed(s)));
+                dictSize(s)));

         }
     }
 }
         }
     }
 }


@@ -2559,7 +2953,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) {


@@ -2572,15 +2966,20 @@ static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, r
     if (!dv) oom("sinterCommand");
     for (j = 0; j < setsnum; j++) {
         robj *setobj;
     if (!dv) oom("sinterCommand");
     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,shared.nokeyerr);
+            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);
             addReply(c,shared.wrongtypeerr);
         if (setobj->type != REDIS_SET) {
             zfree(dv);
             addReply(c,shared.wrongtypeerr);


@@ -2605,8 +3004,8 @@ 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);
+        deleteKey(c->db,dstkey);
+        dictAdd(c->db->dict,dstkey,dstset);

         incrRefCount(dstkey);
     }
 
         incrRefCount(dstkey);
     }
 


@@ -2636,10 +3035,12 @@ static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, r
     }
     dictReleaseIterator(di);
 
     }
     dictReleaseIterator(di);
 

-    if (!dstkey)
+    if (!dstkey) {

         lenobj->ptr = sdscatprintf(sdsempty(),"*%d\r\n",cardinality);
         lenobj->ptr = sdscatprintf(sdsempty(),"*%d\r\n",cardinality);

-    else
+    } else {

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

+        server.dirty++;
+    }

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


@@ -2651,16 +3052,112 @@ 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]);
 }
 

+static void sunionGenericCommand(redisClient *c, robj **setskeys, int setsnum, robj *dstkey) {
+    dict **dv = zmalloc(sizeof(dict*)*setsnum);
+    dictIterator *di;
+    dictEntry *de;
+    robj *lenobj = NULL, *dstset = NULL;
+    int j, cardinality = 0;
+
+    if (!dv) oom("sunionCommand");
+    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();
+
+    /* The first thing we should output is the total number of elements...
+     * since this is a multi-bulk write, but at this stage we don't know
+     * the intersection set size, so we use a trick, append an empty object
+     * to the output list and save the pointer to later modify it with the
+     * right length */
+    if (!dstkey) {
+        lenobj = createObject(REDIS_STRING,NULL);
+        addReply(c,lenobj);
+        decrRefCount(lenobj);
+    } else {
+        /* If we have a target key where to store the resulting set
+         * create this key with an empty set inside */
+        deleteKey(c->db,dstkey);
+        dictAdd(c->db->dict,dstkey,dstset);
+        incrRefCount(dstkey);
+        server.dirty++;
+    }
+
+    /* 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 (!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 (dictAdd(dstset->ptr,ele,NULL) == DICT_OK) {
+                incrRefCount(ele);
+                if (!dstkey) {
+                    addReplySds(c,sdscatprintf(sdsempty(),
+                            "$%d\r\n",sdslen(ele->ptr)));
+                    addReply(c,ele);
+                    addReply(c,shared.crlf);
+                    cardinality++;
+                }
+            }
+        }
+        dictReleaseIterator(di);
+    }
+
+    if (!dstkey) {
+        lenobj->ptr = sdscatprintf(sdsempty(),"*%d\r\n",cardinality);
+        decrRefCount(dstset);
+    } else {
+        addReply(c,shared.ok);
+        server.dirty++;
+    }
+    zfree(dv);
+}
+
+static void sunionCommand(redisClient *c) {
+    sunionGenericCommand(c,c->argv+1,c->argc-1,NULL);
+}
+
+static void sunionstoreCommand(redisClient *c) {
+    sunionGenericCommand(c,c->argv+2,c->argc-2,c->argv[1]);
+}
+

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

-    rdbSave(server.dbfilename);

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

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

     addReply(c,shared.ok);
     rdbSave(server.dbfilename);
     addReply(c,shared.ok);
     rdbSave(server.dbfilename);

+    server.dirty++;

 }
 
 redisSortOperation *createSortOperation(int type, robj *pattern) {
 }
 
 redisSortOperation *createSortOperation(int type, robj *pattern) {


@@ -2673,12 +3170,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) {
+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;


@@ -2686,7 +3182,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;


@@ -2706,10 +3201,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); */
     /* printf("lookup '%s' => %p\n", keyname.buf,de); */

-    if (!de) return NULL;
-    return dictGetEntryVal(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


@@ -2754,7 +3247,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;


@@ -2765,12 +3257,11 @@ 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) {
+    sortval = lookupKeyRead(c->db,c->argv[1]);
+    if (sortval == NULL) {

         addReply(c,shared.nokeyerr);
         return;
     }
         addReply(c,shared.nokeyerr);
         return;
     }

-    sortval = dictGetEntryVal(de);

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


@@ -2835,19 +3326,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 {


@@ -2873,7 +3365,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;


@@ -2909,16 +3401,17 @@ static void sortCommand(redisClient *c) {
     outputlen = getop ? getop*(end-start+1) : end-start+1;
     addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",outputlen));
     for (j = start; j <= end; j++) {
     outputlen = getop ? getop*(end-start+1) : end-start+1;
     addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",outputlen));
     for (j = start; j <= end; j++) {

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

         if (!getop) {
             addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",
                 sdslen(vector[j].obj->ptr)));
             addReply(c,vector[j].obj);
             addReply(c,shared.crlf);
         }
         if (!getop) {
             addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",
                 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) {
                 vector[j].obj);
 
             if (sop->type == REDIS_SORT_GET) {


@@ -2933,7 +3426,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;

         }
     }
 
         }
     }
 


@@ -2955,8 +3447,9 @@ static void infoCommand(redisClient *c) {
         "redis_version:%s\r\n"
         "connected_clients:%d\r\n"
         "connected_slaves:%d\r\n"
         "redis_version:%s\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"


@@ -2967,6 +3460,7 @@ static void infoCommand(redisClient *c) {
         listLength(server.slaves),
         server.usedmemory,
         server.dirty,
         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,


@@ -2978,25 +3472,100 @@ static void infoCommand(redisClient *c) {
     addReply(c,shared.crlf);
 }
 
     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;

     }
     }

-    return REDIS_OK;

 }
 
 }
 

+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);
+        else
+            addReply(c,shared.czero);
+        return;
+    }
+}
+
+/* =============================== Replication  ============================= */
+

 static int syncWrite(int fd, char *ptr, ssize_t size, int timeout) {
     ssize_t nwritten, ret = size;
     time_t start = time(NULL);
 static int syncWrite(int fd, char *ptr, ssize_t size, int timeout) {
     ssize_t nwritten, ret = size;
     time_t start = time(NULL);


@@ -3060,48 +3629,165 @@ 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];
-

     /* ignore SYNC if aleady slave or in monitor mode */
     if (c->flags & REDIS_SLAVE) return;
 
     /* ignore SYNC if aleady slave or in monitor mode */
     if (c->flags & REDIS_SLAVE) return;
 

-    redisLog(REDIS_NOTICE,"Slave ask for syncronization");
-    if (flushClientOutput(c) == REDIS_ERR ||
-        rdbSave(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;
+    /* 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");
+    }
+}
+
+static void updateSalvesWaitingBgsave(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 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 ||
+                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) {


@@ -3178,17 +3864,29 @@ static int syncWithMaster(void) {
     return REDIS_OK;
 }
 
     return REDIS_OK;
 }
 

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

 
 

-    c->flags |= (REDIS_SLAVE|REDIS_MONITOR);
-    c->slaveseldb = 0;
-    if (!listAddNodeTail(server.monitors,c)) oom("listAddNodeTail");
-    addReply(c,shared.ok);
+#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);

 }
 
 }
 

-/* =================================== Main! ================================ */
+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 'echo 1 > /proc/sys/vm/overcommit_memory' in your init scripts.");
+    }
+}
+#endif /* __linux__ */

 
 static void daemonize(void) {
     int fd;
 
 static void daemonize(void) {
     int fd;


@@ -3215,6 +3913,10 @@ static void daemonize(void) {
 }
 
 int main(int argc, char **argv) {
 }
 
 int main(int argc, char **argv) {

+#ifdef __linux__
+    linuxOvercommitMemoryWarning();
+#endif
+

     initServerConfig();
     if (argc == 2) {
         ResetServerSaveParams();
     initServerConfig();
     if (argc == 2) {
         ResetServerSaveParams();