From c5b6f461321e9b3075eed9f55989ca1d0d18394e Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 8 Mar 2011 15:03:51 +0100
Subject: [PATCH 01/38] comment typo fixed

---
 src/dscache.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dscache.c b/src/dscache.c
index a4d045e1..683c5c1c 100644
--- a/src/dscache.c
+++ b/src/dscache.c
@@ -212,7 +212,7 @@ int cacheFreeOneEntry(void) {
         }
     }
     if (best == NULL) {
-        /* Was not able to fix a single object... we should check if our
+        /* Not able to free a single object? we should check if our
          * IO queues have stuff in queue, and try to consume the queue
          * otherwise we'll use an infinite amount of memory if changes to
          * the dataset are faster than I/O */

From e09b51869b355644e4f481634729ed2903acad97 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 8 Mar 2011 15:10:20 +0100
Subject: [PATCH 02/38] useless function removed

---
 TODO          | 2 ++
 src/dscache.c | 7 -------
 2 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/TODO b/TODO
index edcd2b32..48ea8ac6 100644
--- a/TODO
+++ b/TODO
@@ -20,6 +20,8 @@ DISKSTORE TODO
 * Fix DBSIZE to really do something interesting
 * Add a DEBUG command to check if an entry is or not in memory currently
 
+* dscache.c near 236, kobj = createStringObject... we could use static obj.
+
 APPEND ONLY FILE
 ================
 
diff --git a/src/dscache.c b/src/dscache.c
index 683c5c1c..66e6ee63 100644
--- a/src/dscache.c
+++ b/src/dscache.c
@@ -240,13 +240,6 @@ int cacheFreeOneEntry(void) {
     return REDIS_OK;
 }
 
-/* Return true if it's safe to swap out objects in a given moment.
- * Basically we don't want to swap objects out while there is a BGSAVE
- * or a BGAEOREWRITE running in backgroud. */
-int dsCanTouchDiskStore(void) {
-    return (server.bgsavechildpid == -1 && server.bgrewritechildpid == -1);
-}
-
 /* ==================== Disk store negative caching  ========================
  *
  * When disk store is enabled, we need negative caching, that is, to remember

From 3a21cb99e51403eb0469803abc6f894f468948f1 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 8 Mar 2011 15:55:34 +0100
Subject: [PATCH 03/38] same final call of two if branches moved outside

---
 src/dscache.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/dscache.c b/src/dscache.c
index 66e6ee63..0448d2cb 100644
--- a/src/dscache.c
+++ b/src/dscache.c
@@ -383,11 +383,10 @@ void vmThreadedIOCompletedJob(aeEventLoop *el, int fd, void *privdata,
             }
             cacheScheduleIODelFlag(j->db,j->key,REDIS_IO_LOADINPROG);
             handleClientsBlockedOnSwappedKey(j->db,j->key);
-            freeIOJob(j);
         } else if (j->type == REDIS_IOJOB_SAVE) {
             cacheScheduleIODelFlag(j->db,j->key,REDIS_IO_SAVEINPROG);
-            freeIOJob(j);
         }
+        freeIOJob(j);
         processed++;
         if (privdata == NULL) cacheScheduleIOPushJobs(0);
         if (processed == toprocess) return;

From e270a7fa58d242d3cef9ebfe4724719b92afe7d6 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 8 Mar 2011 16:52:39 +0100
Subject: [PATCH 04/38] removed useless call

---
 src/dscache.c | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/dscache.c b/src/dscache.c
index 0448d2cb..2dbc1134 100644
--- a/src/dscache.c
+++ b/src/dscache.c
@@ -587,8 +587,6 @@ void queueIOJob(iojob *j) {
     redisLog(REDIS_DEBUG,"Queued IO Job %p type %d about key '%s'\n",
         (void*)j, j->type, (char*)j->key->ptr);
     listAddNodeTail(server.io_newjobs,j);
-    if (server.io_active_threads < server.vm_max_threads)
-        spawnIOThread();
 }
 
 /* Consume all the IO scheduled operations, and all the thread IO jobs

From b1a8e3e89e7824e0375b149e487f9ff1012a2100 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 9 Mar 2011 15:44:21 +0100
Subject: [PATCH 05/38] byte ordering detection in config.h

---
 src/config.h | 64 +++++++++++++++++++++++++++++++++++++++++++++++-----
 src/sha1.c   | 50 +---------------------------------------
 2 files changed, 59 insertions(+), 55 deletions(-)

diff --git a/src/config.h b/src/config.h
index 40f22fa5..07700bed 100644
--- a/src/config.h
+++ b/src/config.h
@@ -21,7 +21,7 @@
 #define redis_malloc_size(p) malloc_size(p)
 #endif
 
-/* define redis_fstat to fstat or fstat64() */
+/* Tefine redis_fstat to fstat or fstat64() */
 #if defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_6)
 #define redis_fstat fstat64
 #define redis_stat stat64
@@ -30,22 +30,22 @@
 #define redis_stat stat
 #endif
 
-/* test for proc filesystem */
+/* Test for proc filesystem */
 #ifdef __linux__
 #define HAVE_PROCFS 1
 #endif
 
-/* test for task_info() */
+/* Test for task_info() */
 #if defined(__APPLE__)
 #define HAVE_TASKINFO 1
 #endif
 
-/* test for backtrace() */
+/* Test for backtrace() */
 #if defined(__APPLE__) || defined(__linux__)
 #define HAVE_BACKTRACE 1
 #endif
 
-/* test for polling API */
+/* Test for polling API */
 #ifdef __linux__
 #define HAVE_EPOLL 1
 #endif
@@ -54,11 +54,63 @@
 #define HAVE_KQUEUE 1
 #endif
 
-/* define aof_fsync to fdatasync() in Linux and fsync() for all the rest */
+/* Define aof_fsync to fdatasync() in Linux and fsync() for all the rest */
 #ifdef __linux__
 #define aof_fsync fdatasync
 #else
 #define aof_fsync fsync
 #endif
 
+/* Byte ordering detection */
+#include <sys/types.h> /* This will likely define BYTE_ORDER */
+
+#ifndef BYTE_ORDER
+#if (BSD >= 199103)
+# include <machine/endian.h>
+#else
+#if defined(linux) || defined(__linux__)
+# include <endian.h>
+#else
+#define	LITTLE_ENDIAN	1234	/* least-significant byte first (vax, pc) */
+#define	BIG_ENDIAN	4321	/* most-significant byte first (IBM, net) */
+#define	PDP_ENDIAN	3412	/* LSB first in word, MSW first in long (pdp)*/
+
+#if defined(vax) || defined(ns32000) || defined(sun386) || defined(__i386__) || \
+    defined(MIPSEL) || defined(_MIPSEL) || defined(BIT_ZERO_ON_RIGHT) || \
+    defined(__alpha__) || defined(__alpha)
+#define BYTE_ORDER	LITTLE_ENDIAN
+#endif
+
+#if defined(sel) || defined(pyr) || defined(mc68000) || defined(sparc) || \
+    defined(is68k) || defined(tahoe) || defined(ibm032) || defined(ibm370) || \
+    defined(MIPSEB) || defined(_MIPSEB) || defined(_IBMR2) || defined(DGUX) ||\
+    defined(apollo) || defined(__convex__) || defined(_CRAY) || \
+    defined(__hppa) || defined(__hp9000) || \
+    defined(__hp9000s300) || defined(__hp9000s700) || \
+    defined (BIT_ZERO_ON_LEFT) || defined(m68k) || defined(__sparc)
+#define BYTE_ORDER	BIG_ENDIAN
+#endif
+#endif /* linux */
+#endif /* BSD */
+#endif /* BYTE_ORDER */
+
+#if defined(__BYTE_ORDER) && !defined(BYTE_ORDER)
+#if (__BYTE_ORDER == __LITTLE_ENDIAN)
+#define BYTE_ORDER LITTLE_ENDIAN
+#else
+#define BYTE_ORDER BIG_ENDIAN
+#endif
+#endif
+
+#if !defined(BYTE_ORDER) || \
+    (BYTE_ORDER != BIG_ENDIAN && BYTE_ORDER != LITTLE_ENDIAN && \
+    BYTE_ORDER != PDP_ENDIAN)
+	/* you must determine what the correct bit order is for
+	 * your compiler - the next line is an intentional error
+	 * which will force your compiles to bomb until you fix
+	 * the above macros.
+	 */
+#error "Undefined or invalid BYTE_ORDER"
+#endif
+
 #endif
diff --git a/src/sha1.c b/src/sha1.c
index 2c50433e..26a5565e 100644
--- a/src/sha1.c
+++ b/src/sha1.c
@@ -28,55 +28,7 @@ A million repetitions of "a"
 #include "solarisfixes.h"
 #endif
 #include "sha1.h"
-
-#ifndef BYTE_ORDER
-#if (BSD >= 199103)
-# include <machine/endian.h>
-#else
-#if defined(linux) || defined(__linux__)
-# include <endian.h>
-#else
-#define	LITTLE_ENDIAN	1234	/* least-significant byte first (vax, pc) */
-#define	BIG_ENDIAN	4321	/* most-significant byte first (IBM, net) */
-#define	PDP_ENDIAN	3412	/* LSB first in word, MSW first in long (pdp)*/
-
-#if defined(vax) || defined(ns32000) || defined(sun386) || defined(__i386__) || \
-    defined(MIPSEL) || defined(_MIPSEL) || defined(BIT_ZERO_ON_RIGHT) || \
-    defined(__alpha__) || defined(__alpha)
-#define BYTE_ORDER	LITTLE_ENDIAN
-#endif
-
-#if defined(sel) || defined(pyr) || defined(mc68000) || defined(sparc) || \
-    defined(is68k) || defined(tahoe) || defined(ibm032) || defined(ibm370) || \
-    defined(MIPSEB) || defined(_MIPSEB) || defined(_IBMR2) || defined(DGUX) ||\
-    defined(apollo) || defined(__convex__) || defined(_CRAY) || \
-    defined(__hppa) || defined(__hp9000) || \
-    defined(__hp9000s300) || defined(__hp9000s700) || \
-    defined (BIT_ZERO_ON_LEFT) || defined(m68k) || defined(__sparc)
-#define BYTE_ORDER	BIG_ENDIAN
-#endif
-#endif /* linux */
-#endif /* BSD */
-#endif /* BYTE_ORDER */
-
-#if defined(__BYTE_ORDER) && !defined(BYTE_ORDER)
-#if (__BYTE_ORDER == __LITTLE_ENDIAN)
-#define BYTE_ORDER LITTLE_ENDIAN
-#else
-#define BYTE_ORDER BIG_ENDIAN
-#endif
-#endif
-
-#if !defined(BYTE_ORDER) || \
-    (BYTE_ORDER != BIG_ENDIAN && BYTE_ORDER != LITTLE_ENDIAN && \
-    BYTE_ORDER != PDP_ENDIAN)
-	/* you must determine what the correct bit order is for
-	 * your compiler - the next line is an intentional error
-	 * which will force your compiles to bomb until you fix
-	 * the above macros.
-	 */
-#error "Undefined or invalid BYTE_ORDER"
-#endif
+#include "config.h"
 
 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
 

From e12cb14308ab2719b506762e662ab179f31aceb9 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 9 Mar 2011 16:24:18 +0100
Subject: [PATCH 06/38] endianess conversion API, to be applied to specially
 encoded data types for arch agnostic encoding.

---
 src/endian.c | 63 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/endian.h |  8 +++++++
 2 files changed, 71 insertions(+)
 create mode 100644 src/endian.c
 create mode 100644 src/endian.h

diff --git a/src/endian.c b/src/endian.c
new file mode 100644
index 00000000..aff2425a
--- /dev/null
+++ b/src/endian.c
@@ -0,0 +1,63 @@
+/* Toggle the 16 bit unsigned integer pointed by *p from little endian to
+ * big endian */
+void memrev16(void *p) {
+    unsigned char *x = p, t;
+
+    t = x[0];
+    x[0] = x[1];
+    x[1] = t;
+}
+
+/* Toggle the 32 bit unsigned integer pointed by *p from little endian to
+ * big endian */
+void memrev32(void *p) {
+    unsigned char *x = p, t;
+
+    t = x[0];
+    x[0] = x[3];
+    x[3] = t;
+    t = x[1];
+    x[1] = x[2];
+    x[2] = t;
+}
+
+/* Toggle the 64 bit unsigned integer pointed by *p from little endian to
+ * big endian */
+void memrev64(void *p) {
+    unsigned char *x = p, t;
+
+    t = x[0];
+    x[0] = x[7];
+    x[7] = t;
+    t = x[1];
+    x[1] = x[6];
+    x[6] = t;
+    t = x[2];
+    x[2] = x[5];
+    x[5] = t;
+    t = x[3];
+    x[3] = x[4];
+    x[4] = t;
+}
+
+#ifdef TESTMAIN
+#include <stdio.h>
+
+int main(void) {
+    char buf[32];
+
+    sprintf(buf,"ciaoroma");
+    memrev16(buf);
+    printf("%s\n", buf);
+
+    sprintf(buf,"ciaoroma");
+    memrev32(buf);
+    printf("%s\n", buf);
+
+    sprintf(buf,"ciaoroma");
+    memrev64(buf);
+    printf("%s\n", buf);
+
+    return 0;
+}
+#endif
diff --git a/src/endian.h b/src/endian.h
new file mode 100644
index 00000000..ea295ee5
--- /dev/null
+++ b/src/endian.h
@@ -0,0 +1,8 @@
+#ifndef __ENDIAN_H
+#define __ENDIAN_H
+
+void memrev16(void *p);
+void memrev32(void *p);
+void memrev64(void *p);
+
+#endif

From 48e46215909d5161db838a596bb3ec334c86c6d7 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 9 Mar 2011 16:33:09 +0100
Subject: [PATCH 07/38] Ehm... sorry if we don't support PDP endianess

---
 src/config.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/config.h b/src/config.h
index 07700bed..d98067c1 100644
--- a/src/config.h
+++ b/src/config.h
@@ -103,8 +103,7 @@
 #endif
 
 #if !defined(BYTE_ORDER) || \
-    (BYTE_ORDER != BIG_ENDIAN && BYTE_ORDER != LITTLE_ENDIAN && \
-    BYTE_ORDER != PDP_ENDIAN)
+    (BYTE_ORDER != BIG_ENDIAN && BYTE_ORDER != LITTLE_ENDIAN)
 	/* you must determine what the correct bit order is for
 	 * your compiler - the next line is an intentional error
 	 * which will force your compiles to bomb until you fix

From bcde63785d6c6e54ae71216df8bec276f2c85155 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 9 Mar 2011 16:36:02 +0100
Subject: [PATCH 08/38] TODO updated

---
 TODO | 1 +
 1 file changed, 1 insertion(+)

diff --git a/TODO b/TODO
index 48ea8ac6..580adda6 100644
--- a/TODO
+++ b/TODO
@@ -31,6 +31,7 @@ APPEND ONLY FILE
 OPTIMIZATIONS
 =============
 
+* Avoid COW due to incrementing the dict iterators counter.
 * SORT: Don't copy the list into a vector when BY argument is constant.
 * Write the hash table size of every db in the dump, so that Redis can resize the hash table just one time when loading a big DB.
 * Read-only mode for slaves.

From b5325132f1c8bc90e6c87392c54724ca33388ee8 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 9 Mar 2011 17:28:16 +0100
Subject: [PATCH 09/38] memrev variants only doing the work if the target host
 is big endian

---
 src/endian.h | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/endian.h b/src/endian.h
index ea295ee5..327cc570 100644
--- a/src/endian.h
+++ b/src/endian.h
@@ -5,4 +5,14 @@ void memrev16(void *p);
 void memrev32(void *p);
 void memrev64(void *p);
 
+/* variants of the function doing the actual convertion only if the target
+ * host is big endian */
+#if (BYTE_ORDER == LITTLE_ENDIAN)
+#define memrev16ifbe(p)
+#define memrev32ifbe(p)
+#define memrev64ifbe(p)
+#else
+#define memrev16ifbe(p) memrev16(p)
+#define memrev32ifbe(p) memrev32(p)
+#define memrev64ifbe(p) memrev64(p)
 #endif

From 336c82d58379205b789f3ca9cefc7c2090808fb8 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 9 Mar 2011 17:31:02 +0100
Subject: [PATCH 10/38] zipmaps are now endianess agnostic, needed for on disk
 serialization of zipmaps without convertions layers

---
 src/Makefile | 2 +-
 src/endian.h | 2 ++
 src/zipmap.c | 3 +++
 3 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/Makefile b/src/Makefile
index 4d0f86db..acbc9b5f 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -25,7 +25,7 @@ PREFIX= /usr/local
 INSTALL_BIN= $(PREFIX)/bin
 INSTALL= cp -p
 
-OBJ = adlist.o ae.o anet.o dict.o redis.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o dscache.o pubsub.o multi.o debug.o sort.o intset.o syncio.o diskstore.o
+OBJ = adlist.o ae.o anet.o dict.o redis.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o dscache.o pubsub.o multi.o debug.o sort.o intset.o syncio.o diskstore.o endian.o
 BENCHOBJ = ae.o anet.o redis-benchmark.o sds.o adlist.o zmalloc.o
 CLIOBJ = anet.o sds.o adlist.o redis-cli.o zmalloc.o release.o
 CHECKDUMPOBJ = redis-check-dump.o lzf_c.o lzf_d.o
diff --git a/src/endian.h b/src/endian.h
index 327cc570..bef82272 100644
--- a/src/endian.h
+++ b/src/endian.h
@@ -16,3 +16,5 @@ void memrev64(void *p);
 #define memrev32ifbe(p) memrev32(p)
 #define memrev64ifbe(p) memrev64(p)
 #endif
+
+#endif
diff --git a/src/zipmap.c b/src/zipmap.c
index 693db7b9..9f0fc718 100644
--- a/src/zipmap.c
+++ b/src/zipmap.c
@@ -80,6 +80,7 @@
 #include <string.h>
 #include <assert.h>
 #include "zmalloc.h"
+#include "endian.h"
 
 #define ZIPMAP_BIGLEN 254
 #define ZIPMAP_END 255
@@ -108,6 +109,7 @@ static unsigned int zipmapDecodeLength(unsigned char *p) {
 
     if (len < ZIPMAP_BIGLEN) return len;
     memcpy(&len,p+1,sizeof(unsigned int));
+    memrev32ifbe(&len);
     return len;
 }
 
@@ -123,6 +125,7 @@ static unsigned int zipmapEncodeLength(unsigned char *p, unsigned int len) {
         } else {
             p[0] = ZIPMAP_BIGLEN;
             memcpy(p+1,&len,sizeof(len));
+            memrev32ifbe(p+1);
             return 1+sizeof(len);
         }
     }

From f22043745015281f76f3d3bc7f16afe3de731af9 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 9 Mar 2011 18:49:59 +0100
Subject: [PATCH 11/38] ziplist are now endianess agnostic

---
 src/ziplist.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/ziplist.c b/src/ziplist.c
index 524f7238..55bb662b 100644
--- a/src/ziplist.c
+++ b/src/ziplist.c
@@ -68,6 +68,7 @@
 #include <limits.h>
 #include "zmalloc.h"
 #include "ziplist.h"
+#include "endian.h"
 
 int ll2string(char *s, size_t len, long long value);
 
@@ -207,6 +208,7 @@ static unsigned int zipPrevDecodeLength(unsigned char *p, unsigned int *lensize)
     } else {
         if (lensize) *lensize = 1+sizeof(len);
         memcpy(&len,p+1,sizeof(len));
+        memrev32ifbe(&len);
     }
     return len;
 }
@@ -223,6 +225,7 @@ static unsigned int zipPrevEncodeLength(unsigned char *p, unsigned int len) {
         } else {
             p[0] = ZIP_BIGLEN;
             memcpy(p+1,&len,sizeof(len));
+            memrev32ifbe(p+1);
             return 1+sizeof(len);
         }
     }
@@ -234,6 +237,7 @@ static void zipPrevEncodeLengthForceLarge(unsigned char *p, unsigned int len) {
     if (p == NULL) return;
     p[0] = ZIP_BIGLEN;
     memcpy(p+1,&len,sizeof(len));
+    memrev32ifbe(p+1);
 }
 
 /* Return the difference in number of bytes needed to store the new length
@@ -287,12 +291,15 @@ static void zipSaveInteger(unsigned char *p, int64_t value, unsigned char encodi
     if (encoding == ZIP_INT_16B) {
         i16 = value;
         memcpy(p,&i16,sizeof(i16));
+        memrev16ifbe(p);
     } else if (encoding == ZIP_INT_32B) {
         i32 = value;
         memcpy(p,&i32,sizeof(i32));
+        memrev32ifbe(p);
     } else if (encoding == ZIP_INT_64B) {
         i64 = value;
         memcpy(p,&i64,sizeof(i64));
+        memrev64ifbe(p);
     } else {
         assert(NULL);
     }
@@ -305,12 +312,15 @@ static int64_t zipLoadInteger(unsigned char *p, unsigned char encoding) {
     int64_t i64, ret = 0;
     if (encoding == ZIP_INT_16B) {
         memcpy(&i16,p,sizeof(i16));
+        memrev16ifbe(&i16);
         ret = i16;
     } else if (encoding == ZIP_INT_32B) {
         memcpy(&i32,p,sizeof(i32));
+        memrev16ifbe(&i32);
         ret = i32;
     } else if (encoding == ZIP_INT_64B) {
         memcpy(&i64,p,sizeof(i64));
+        memrev16ifbe(&i64);
         ret = i64;
     } else {
         assert(NULL);

From dc75b1edfb2d5935246d2b3f97a04474c1296008 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 9 Mar 2011 19:14:04 +0100
Subject: [PATCH 12/38] encoding agnostic intsets

---
 src/intset.c | 36 +++++++++++++++++++++++++++---------
 1 file changed, 27 insertions(+), 9 deletions(-)

diff --git a/src/intset.c b/src/intset.c
index 13bd220e..4dd0141d 100644
--- a/src/intset.c
+++ b/src/intset.c
@@ -3,6 +3,7 @@
 #include <string.h>
 #include "intset.h"
 #include "zmalloc.h"
+#include "endian.h"
 
 /* Note that these encodings are ordered, so:
  * INTSET_ENC_INT16 < INTSET_ENC_INT32 < INTSET_ENC_INT64. */
@@ -16,16 +17,29 @@ static uint8_t _intsetValueEncoding(int64_t v) {
         return INTSET_ENC_INT64;
     else if (v < INT16_MIN || v > INT16_MAX)
         return INTSET_ENC_INT32;
-    return INTSET_ENC_INT16;
+    else
+        return INTSET_ENC_INT16;
 }
 
 /* Return the value at pos, given an encoding. */
 static int64_t _intsetGetEncoded(intset *is, int pos, uint8_t enc) {
-    if (enc == INTSET_ENC_INT64)
-        return ((int64_t*)is->contents)[pos];
-    else if (enc == INTSET_ENC_INT32)
-        return ((int32_t*)is->contents)[pos];
-    return ((int16_t*)is->contents)[pos];
+    int64_t v64;
+    int32_t v32;
+    int16_t v16;
+
+    if (enc == INTSET_ENC_INT64) {
+        memcpy(&v64,((int64_t*)is->contents)+pos,sizeof(v64));
+        memrev64ifbe(&v64);
+        return v64;
+    } else if (enc == INTSET_ENC_INT32) {
+        memcpy(&v32,((int32_t*)is->contents)+pos,sizeof(v32));
+        memrev32ifbe(&v32);
+        return v32;
+    } else {
+        memcpy(&v16,((int16_t*)is->contents)+pos,sizeof(v16));
+        memrev16ifbe(&v16);
+        return v16;
+    }
 }
 
 /* Return the value at pos, using the configured encoding. */
@@ -35,12 +49,16 @@ static int64_t _intsetGet(intset *is, int pos) {
 
 /* Set the value at pos, using the configured encoding. */
 static void _intsetSet(intset *is, int pos, int64_t value) {
-    if (is->encoding == INTSET_ENC_INT64)
+    if (is->encoding == INTSET_ENC_INT64) {
         ((int64_t*)is->contents)[pos] = value;
-    else if (is->encoding == INTSET_ENC_INT32)
+        memrev64ifbe(((int64_t*)is->contents)+pos);
+    } else if (is->encoding == INTSET_ENC_INT32) {
         ((int32_t*)is->contents)[pos] = value;
-    else
+        memrev32ifbe(((int32_t*)is->contents)+pos);
+    } else {
         ((int16_t*)is->contents)[pos] = value;
+        memrev16ifbe(((int16_t*)is->contents)+pos);
+    }
 }
 
 /* Create an empty intset. */

From 7493d2a0325fe33dc75317bfedf9b1c1e5b0d0b5 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 10 Mar 2011 16:39:19 +0100
Subject: [PATCH 13/38] fixed diskstore race condition

---
 src/dscache.c | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/dscache.c b/src/dscache.c
index 2dbc1134..cbe9bb01 100644
--- a/src/dscache.c
+++ b/src/dscache.c
@@ -890,8 +890,16 @@ int waitForSwappedKey(redisClient *c, robj *key) {
     listAddNodeTail(l,c);
 
     /* Are we already loading the key from disk? If not create a job */
-    if (de == NULL)
-        cacheScheduleIO(c->db,key,REDIS_IO_LOAD);
+    if (de == NULL) {
+        int flags = cacheScheduleIOGetFlags(c->db,key);
+
+        /* It is possible that even if there are no clients waiting for
+         * a load operation, still we have a load operation in progress.
+         * For instance think to a client performing a GET and then
+         * closing the connection */
+        if ((flags & (REDIS_IO_LOAD|REDIS_IO_LOADINPROG)) == 0)
+            cacheScheduleIO(c->db,key,REDIS_IO_LOAD);
+    }
     return 1;
 }
 

From 4eddb121563a9e50cf2ee66e2a0ff7c186dd696a Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 15 Mar 2011 10:47:04 +0100
Subject: [PATCH 14/38] gitignore updated

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 9fad5da7..06ebf60d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+.*.swp
 *.o
 *.rdb
 *.log

From 612810af6e4456d14a7d68f01ce35905b2ff89d9 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Sun, 20 Mar 2011 18:24:49 +0100
Subject: [PATCH 15/38] sdscatrepr() fixed. Now newlines and other special
 chars are escaped correctly

---
 src/sds.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/sds.c b/src/sds.c
index 67e2d456..5f78f1eb 100644
--- a/src/sds.c
+++ b/src/sds.c
@@ -399,11 +399,11 @@ sds sdscatrepr(sds s, char *p, size_t len) {
         case '"':
             s = sdscatprintf(s,"\\%c",*p);
             break;
-        case '\n': s = sdscatlen(s,"\\n",1); break;
-        case '\r': s = sdscatlen(s,"\\r",1); break;
-        case '\t': s = sdscatlen(s,"\\t",1); break;
-        case '\a': s = sdscatlen(s,"\\a",1); break;
-        case '\b': s = sdscatlen(s,"\\b",1); break;
+        case '\n': s = sdscatlen(s,"\\n",2); break;
+        case '\r': s = sdscatlen(s,"\\r",2); break;
+        case '\t': s = sdscatlen(s,"\\t",2); break;
+        case '\a': s = sdscatlen(s,"\\a",2); break;
+        case '\b': s = sdscatlen(s,"\\b",2); break;
         default:
             if (isprint(*p))
                 s = sdscatprintf(s,"%c",*p);

From 03af999cb0befed9d2556c2df1eb0511de2d96d2 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 22 Mar 2011 19:35:42 +0100
Subject: [PATCH 16/38] command table altered for the new API to get position
 of keys arguments in commands

---
 src/redis.c | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/redis.c b/src/redis.c
index 866ac360..51e58f58 100644
--- a/src/redis.c
+++ b/src/redis.c
@@ -70,12 +70,12 @@ struct redisServer server; /* server global state */
 struct redisCommand *commandTable;
 struct redisCommand redisCommandTable[] = {
     {"get",getCommand,2,0,NULL,1,1,1,0,0},
-    {"set",setCommand,3,REDIS_CMD_DENYOOM,NULL,0,0,0,0,0},
-    {"setnx",setnxCommand,3,REDIS_CMD_DENYOOM,NULL,0,0,0,0,0},
-    {"setex",setexCommand,4,REDIS_CMD_DENYOOM,NULL,0,0,0,0,0},
+    {"set",setCommand,3,REDIS_CMD_DENYOOM,noPreloadGetKeys,1,1,1,0,0},
+    {"setnx",setnxCommand,3,REDIS_CMD_DENYOOM,noPreloadGetKeys,1,1,1,0,0},
+    {"setex",setexCommand,4,REDIS_CMD_DENYOOM,noPreloadGetKeys,2,2,1,0,0},
     {"append",appendCommand,3,REDIS_CMD_DENYOOM,NULL,1,1,1,0,0},
     {"strlen",strlenCommand,2,0,NULL,1,1,1,0,0},
-    {"del",delCommand,-2,0,NULL,0,0,0,0,0},
+    {"del",delCommand,-2,0,noPreloadGetKeys,1,-1,1,0,0},
     {"exists",existsCommand,2,0,NULL,1,1,1,0,0},
     {"setbit",setbitCommand,4,REDIS_CMD_DENYOOM,NULL,1,1,1,0,0},
     {"getbit",getbitCommand,3,0,NULL,1,1,1,0,0},
@@ -94,7 +94,7 @@ struct redisCommand redisCommandTable[] = {
     {"lpop",lpopCommand,2,0,NULL,1,1,1,0,0},
     {"brpop",brpopCommand,-3,0,NULL,1,1,1,0,0},
     {"brpoplpush",brpoplpushCommand,4,REDIS_CMD_DENYOOM,NULL,1,2,1,0,0},
-    {"blpop",blpopCommand,-3,0,NULL,1,1,1,0,0},
+    {"blpop",blpopCommand,-3,0,NULL,1,-2,1,0,0},
     {"llen",llenCommand,2,0,NULL,1,1,1,0,0},
     {"lindex",lindexCommand,3,0,NULL,1,1,1,0,0},
     {"lset",lsetCommand,4,REDIS_CMD_DENYOOM,NULL,1,1,1,0,0},
@@ -121,8 +121,8 @@ struct redisCommand redisCommandTable[] = {
     {"zrem",zremCommand,3,0,NULL,1,1,1,0,0},
     {"zremrangebyscore",zremrangebyscoreCommand,4,0,NULL,1,1,1,0,0},
     {"zremrangebyrank",zremrangebyrankCommand,4,0,NULL,1,1,1,0,0},
-    {"zunionstore",zunionstoreCommand,-4,REDIS_CMD_DENYOOM,zunionInterBlockClientOnSwappedKeys,0,0,0,0,0},
-    {"zinterstore",zinterstoreCommand,-4,REDIS_CMD_DENYOOM,zunionInterBlockClientOnSwappedKeys,0,0,0,0,0},
+    {"zunionstore",zunionstoreCommand,-4,REDIS_CMD_DENYOOM,zunionInterGetKeys,0,0,0,0,0},
+    {"zinterstore",zinterstoreCommand,-4,REDIS_CMD_DENYOOM,zunionInterGetKeys,0,0,0,0,0},
     {"zrange",zrangeCommand,-4,0,NULL,1,1,1,0,0},
     {"zrangebyscore",zrangebyscoreCommand,-4,0,NULL,1,1,1,0,0},
     {"zrevrangebyscore",zrevrangebyscoreCommand,-4,0,NULL,1,1,1,0,0},
@@ -152,10 +152,10 @@ struct redisCommand redisCommandTable[] = {
     {"randomkey",randomkeyCommand,1,0,NULL,0,0,0,0,0},
     {"select",selectCommand,2,0,NULL,0,0,0,0,0},
     {"move",moveCommand,3,0,NULL,1,1,1,0,0},
-    {"rename",renameCommand,3,0,NULL,1,1,1,0,0},
-    {"renamenx",renamenxCommand,3,0,NULL,1,1,1,0,0},
-    {"expire",expireCommand,3,0,NULL,0,0,0,0,0},
-    {"expireat",expireatCommand,3,0,NULL,0,0,0,0,0},
+    {"rename",renameCommand,3,0,renameGetKeys,1,2,1,0,0},
+    {"renamenx",renamenxCommand,3,0,renameGetKeys,1,2,1,0,0},
+    {"expire",expireCommand,3,0,NULL,1,1,1,0,0},
+    {"expireat",expireatCommand,3,0,NULL,1,1,1,0,0},
     {"keys",keysCommand,2,0,NULL,0,0,0,0,0},
     {"dbsize",dbsizeCommand,1,0,NULL,0,0,0,0,0},
     {"auth",authCommand,2,0,NULL,0,0,0,0,0},
@@ -168,7 +168,7 @@ struct redisCommand redisCommandTable[] = {
     {"lastsave",lastsaveCommand,1,0,NULL,0,0,0,0,0},
     {"type",typeCommand,2,0,NULL,1,1,1,0,0},
     {"multi",multiCommand,1,0,NULL,0,0,0,0,0},
-    {"exec",execCommand,1,REDIS_CMD_DENYOOM,execBlockClientOnSwappedKeys,0,0,0,0,0},
+    {"exec",execCommand,1,REDIS_CMD_DENYOOM,execGetKeys,0,0,0,0,0},
     {"discard",discardCommand,1,0,NULL,0,0,0,0,0},
     {"sync",syncCommand,1,0,NULL,0,0,0,0,0},
     {"flushdb",flushdbCommand,1,0,NULL,0,0,0,0,0},
@@ -186,7 +186,7 @@ struct redisCommand redisCommandTable[] = {
     {"psubscribe",psubscribeCommand,-2,0,NULL,0,0,0,0,0},
     {"punsubscribe",punsubscribeCommand,-1,0,NULL,0,0,0,0,0},
     {"publish",publishCommand,3,REDIS_CMD_FORCE_REPLICATION,NULL,0,0,0,0,0},
-    {"watch",watchCommand,-2,0,NULL,0,0,0,0,0},
+    {"watch",watchCommand,-2,0,noPreloadGetKeys,1,-1,1,0,0},
     {"unwatch",unwatchCommand,1,0,NULL,0,0,0,0,0}
 };
 

From e360e3bb7e58fd493c71911caab948e05e7fbe85 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 22 Mar 2011 22:49:12 +0100
Subject: [PATCH 17/38] Fixed sdssplitargs() handling of hex-style escapes.

---
 src/sds.c | 49 ++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 48 insertions(+), 1 deletion(-)

diff --git a/src/sds.c b/src/sds.c
index 5f78f1eb..7cb43962 100644
--- a/src/sds.c
+++ b/src/sds.c
@@ -26,6 +26,12 @@
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * History:
+ *
+ * - 22 March 2011: History section created on top of sds.c
+ * - 22 March 2011: Fixed a problem with "\xab" escapes convertion in
+ *                  function sdssplitargs().
  */
 
 #define SDS_ABORT_ON_OOM
@@ -416,6 +422,37 @@ sds sdscatrepr(sds s, char *p, size_t len) {
     return sdscatlen(s,"\"",1);
 }
 
+/* Helper function for sdssplitargs() that returns non zero if 'c'
+ * is a valid hex digit. */
+int is_hex_digit(char c) {
+    return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
+           (c >= 'A' && c <= 'F');
+}
+
+/* Helper function for sdssplitargs() that converts an hex digit into an
+ * integer from 0 to 15 */
+int hex_digit_to_int(char c) {
+    switch(c) {
+    case '0': return 0;
+    case '1': return 1;
+    case '2': return 2;
+    case '3': return 3;
+    case '4': return 4;
+    case '5': return 5;
+    case '6': return 6;
+    case '7': return 7;
+    case '8': return 8;
+    case '9': return 9;
+    case 'a': case 'A': return 10;
+    case 'b': case 'B': return 11;
+    case 'c': case 'C': return 12;
+    case 'd': case 'D': return 13;
+    case 'e': case 'E': return 14;
+    case 'f': case 'F': return 15;
+    default: return 0;
+    }
+}
+
 /* Split a line into arguments, where every argument can be in the
  * following programming-language REPL-alike form:
  *
@@ -445,7 +482,17 @@ sds *sdssplitargs(char *line, int *argc) {
             if (current == NULL) current = sdsempty();
             while(!done) {
                 if (inq) {
-                    if (*p == '\\' && *(p+1)) {
+                    if (*p == '\\' && *(p+1) == 'x' &&
+                                             is_hex_digit(*(p+2)) &&
+                                             is_hex_digit(*(p+3)))
+                    {
+                        unsigned char byte;
+
+                        byte = (hex_digit_to_int(*(p+2))*16)+
+                                hex_digit_to_int(*(p+3));
+                        current = sdscatlen(current,(char*)&byte,1);
+                        p += 3;
+                    } else if (*p == '\\' && *(p+1)) {
                         char c;
 
                         p++;

From 9791f0f8ceb18e2e3c297a8c479307b7af0f9830 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 23 Mar 2011 18:09:17 +0100
Subject: [PATCH 18/38] new preloading implemented, still EXEC not handled
 correctly, everything to test

---
 src/db.c      | 72 +++++++++++++++++++++++++++++++++++++++++++++++++++
 src/dscache.c | 14 ++++++----
 src/redis.c   |  2 +-
 src/redis.h   | 26 ++++++++++++-------
 4 files changed, 98 insertions(+), 16 deletions(-)

diff --git a/src/db.c b/src/db.c
index 9daa5ddb..9bc299ca 100644
--- a/src/db.c
+++ b/src/db.c
@@ -616,3 +616,75 @@ void persistCommand(redisClient *c) {
         }
     }
 }
+
+/* -----------------------------------------------------------------------------
+ * API to get key arguments from commands
+ * ---------------------------------------------------------------------------*/
+
+int *getKeysUsingCommandTable(struct redisCommand *cmd,robj **argv, int argc, int *numkeys) {
+    int j, i = 0, last, *keys;
+    REDIS_NOTUSED(argv);
+
+    if (cmd->firstkey == 0) {
+        *numkeys = 0;
+        return NULL;
+    }
+    last = cmd->lastkey;
+    if (last < 0) last = argc+last;
+    keys = zmalloc(sizeof(int)*((last - cmd->firstkey)+1));
+    for (j = cmd->firstkey; j <= last; j += cmd->keystep) {
+        redisAssert(j < argc);
+        keys[i] = j;
+    }
+    return keys;
+}
+
+int *getKeysFromCommand(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags) {
+    if (cmd->getkeys_proc) {
+        return cmd->getkeys_proc(cmd,argv,argc,numkeys,flags);
+    } else {
+        return getKeysUsingCommandTable(cmd,argv,argc,numkeys);
+    }
+}
+
+void getKeysFreeResult(int *result) {
+    zfree(result);
+}
+
+int *noPreloadGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags) {
+    if (flags & REDIS_GETKEYS_PRELOAD) {
+        *numkeys = 0;
+        return NULL;
+    } else {
+        return getKeysUsingCommandTable(cmd,argv,argc,numkeys);
+    }
+}
+
+int *renameGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags) {
+    if (flags & REDIS_GETKEYS_PRELOAD) {
+        int *keys = zmalloc(sizeof(int));
+        *numkeys = 1;
+        keys[0] = 1;
+        return NULL;
+    } else {
+        return getKeysUsingCommandTable(cmd,argv,argc,numkeys);
+    }
+}
+
+int *zunionInterGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags) {
+    int i, num, *keys;
+    REDIS_NOTUSED(cmd);
+    REDIS_NOTUSED(flags);
+
+    num = atoi(argv[2]->ptr);
+    /* Sanity check. Don't return any key if the command is going to
+     * reply with syntax error. */
+    if (num > (argc-3)) {
+        *numkeys = 0;
+        return NULL;
+    }
+    keys = zmalloc(num);
+    for (i = 0; i < num; i++) keys[i] = 3+i;
+    *numkeys = num;
+    return keys;
+}
diff --git a/src/dscache.c b/src/dscache.c
index cbe9bb01..5813052e 100644
--- a/src/dscache.c
+++ b/src/dscache.c
@@ -903,6 +903,7 @@ int waitForSwappedKey(redisClient *c, robj *key) {
     return 1;
 }
 
+#if 0
 /* Preload keys for any command with first, last and step values for
  * the command keys prototype, as defined in the command table. */
 void waitForMultipleSwappedKeys(redisClient *c, struct redisCommand *cmd, int argc, robj **argv) {
@@ -955,6 +956,7 @@ void execBlockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd, int
         }
     }
 }
+#endif
 
 /* Is this client attempting to run a command against swapped keys?
  * If so, block it ASAP, load the keys in background, then resume it.
@@ -967,11 +969,13 @@ void execBlockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd, int
  * Return 1 if the client is marked as blocked, 0 if the client can
  * continue as the keys it is going to access appear to be in memory. */
 int blockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd) {
-    if (cmd->vm_preload_proc != NULL) {
-        cmd->vm_preload_proc(c,cmd,c->argc,c->argv);
-    } else {
-        waitForMultipleSwappedKeys(c,cmd,c->argc,c->argv);
-    }
+    int *keyindex, numkeys, j;
+
+    keyindex = getKeysFromCommand(cmd,c->argv,c->argc,&numkeys,REDIS_GETKEYS_PRELOAD);
+    for (j = 0; j < numkeys; j++) waitForSwappedKey(c,c->argv[keyindex[j]]);
+    getKeysFreeResult(keyindex);
+
+#warning "Handle EXEC here"
 
     /* If the client was blocked for at least one key, mark it as blocked. */
     if (listLength(c->io_keys)) {
diff --git a/src/redis.c b/src/redis.c
index 51e58f58..19fd912c 100644
--- a/src/redis.c
+++ b/src/redis.c
@@ -168,7 +168,7 @@ struct redisCommand redisCommandTable[] = {
     {"lastsave",lastsaveCommand,1,0,NULL,0,0,0,0,0},
     {"type",typeCommand,2,0,NULL,1,1,1,0,0},
     {"multi",multiCommand,1,0,NULL,0,0,0,0,0},
-    {"exec",execCommand,1,REDIS_CMD_DENYOOM,execGetKeys,0,0,0,0,0},
+    {"exec",execCommand,1,REDIS_CMD_DENYOOM,NULL,0,0,0,0,0},
     {"discard",discardCommand,1,0,NULL,0,0,0,0,0},
     {"sync",syncCommand,1,0,NULL,0,0,0,0,0},
     {"flushdb",flushdbCommand,1,0,NULL,0,0,0,0,0},
diff --git a/src/redis.h b/src/redis.h
index cdddb601..b5188330 100644
--- a/src/redis.h
+++ b/src/redis.h
@@ -507,20 +507,19 @@ typedef struct pubsubPattern {
 } pubsubPattern;
 
 typedef void redisCommandProc(redisClient *c);
-typedef void redisVmPreloadProc(redisClient *c, struct redisCommand *cmd, int argc, robj **argv);
+typedef int *redisGetKeysProc(struct redisCommand *cmd, robj **argv, int argc, int *numkeys, int flags);
 struct redisCommand {
     char *name;
     redisCommandProc *proc;
     int arity;
     int flags;
-    /* Use a function to determine which keys need to be loaded
-     * in the background prior to executing this command. Takes precedence
-     * over vm_firstkey and others, ignored when NULL */
-    redisVmPreloadProc *vm_preload_proc;
+    /* Use a function to determine keys arguments in a command line.
+     * Used both for diskstore preloading and Redis Cluster. */
+    redisGetKeysProc *getkeys_proc;
     /* What keys should be loaded in background when calling this command? */
-    int vm_firstkey; /* The first argument that's a key (0 = no keys) */
-    int vm_lastkey;  /* THe last argument that's a key */
-    int vm_keystep;  /* The step between first and last key */
+    int firstkey; /* The first argument that's a key (0 = no keys) */
+    int lastkey;  /* THe last argument that's a key */
+    int keystep;  /* The step between first and last key */
     long long microseconds, calls;
 };
 
@@ -829,8 +828,6 @@ void freeIOJob(iojob *j);
 void queueIOJob(iojob *j);
 void waitEmptyIOJobsQueue(void);
 void processAllPendingIOJobs(void);
-void zunionInterBlockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd, int argc, robj **argv);
-void execBlockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd, int argc, robj **argv);
 int blockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd);
 int dontWaitForSwappedKey(redisClient *c, robj *key);
 void handleClientsBlockedOnSwappedKey(redisDb *db, robj *key);
@@ -917,6 +914,15 @@ int selectDb(redisClient *c, int id);
 void signalModifiedKey(redisDb *db, robj *key);
 void signalFlushedDb(int dbid);
 
+/* API to get key arguments from commands */
+#define REDIS_GETKEYS_ALL 0
+#define REDIS_GETKEYS_PRELOAD 1
+int *getKeysFromCommand(struct redisCommand *cmd, robj **argv, int argc, int *numkeys, int flags);
+void getKeysFreeResult(int *result);
+int *noPreloadGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags);
+int *renameGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags);
+int *zunionInterGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags);
+
 /* Git SHA1 */
 char *redisGitSHA1(void);
 char *redisGitDirty(void);

From a3cf9041218518f235a297b2f2d0d08ef9a5c4e5 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 23 Mar 2011 23:13:15 +0100
Subject: [PATCH 19/38] minor style change

---
 src/dscache.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/dscache.c b/src/dscache.c
index 5813052e..faf87e84 100644
--- a/src/dscache.c
+++ b/src/dscache.c
@@ -971,7 +971,8 @@ void execBlockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd, int
 int blockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd) {
     int *keyindex, numkeys, j;
 
-    keyindex = getKeysFromCommand(cmd,c->argv,c->argc,&numkeys,REDIS_GETKEYS_PRELOAD);
+    keyindex = getKeysFromCommand(cmd,c->argv,c->argc,&numkeys,
+                                  REDIS_GETKEYS_PRELOAD);
     for (j = 0; j < numkeys; j++) waitForSwappedKey(c,c->argv[keyindex[j]]);
     getKeysFreeResult(keyindex);
 

From 42b2621cdc4dfc47f90cf1085761ad89171a6a60 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 28 Mar 2011 17:29:26 +0200
Subject: [PATCH 20/38] implemented preload of EXEC using the new getKeys()
 system

---
 src/dscache.c | 31 +++++++++++++++++++++++++------
 1 file changed, 25 insertions(+), 6 deletions(-)

diff --git a/src/dscache.c b/src/dscache.c
index faf87e84..45865264 100644
--- a/src/dscache.c
+++ b/src/dscache.c
@@ -969,14 +969,33 @@ void execBlockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd, int
  * Return 1 if the client is marked as blocked, 0 if the client can
  * continue as the keys it is going to access appear to be in memory. */
 int blockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd) {
-    int *keyindex, numkeys, j;
+    int *keyindex, numkeys, j, i;
 
-    keyindex = getKeysFromCommand(cmd,c->argv,c->argc,&numkeys,
-                                  REDIS_GETKEYS_PRELOAD);
-    for (j = 0; j < numkeys; j++) waitForSwappedKey(c,c->argv[keyindex[j]]);
-    getKeysFreeResult(keyindex);
+    /* EXEC is a special case, we need to preload all the commands
+     * queued into the transaction */
+    if (cmd->proc == execCommand) {
+        struct redisCommand *mcmd;
+        robj **margv;
+        int margc;
 
-#warning "Handle EXEC here"
+        if (!(c->flags & REDIS_MULTI)) return 0;
+        for (i = 0; i < c->mstate.count; i++) {
+            mcmd = c->mstate.commands[i].cmd;
+            margc = c->mstate.commands[i].argc;
+            margv = c->mstate.commands[i].argv;
+
+            keyindex = getKeysFromCommand(mcmd,margv,margc,&numkeys,
+                                          REDIS_GETKEYS_PRELOAD);
+            for (j = 0; j < numkeys; j++)
+                waitForSwappedKey(c,margv[keyindex[j]]);
+            getKeysFreeResult(keyindex);
+        }
+    } else {
+        keyindex = getKeysFromCommand(cmd,c->argv,c->argc,&numkeys,
+                                      REDIS_GETKEYS_PRELOAD);
+        for (j = 0; j < numkeys; j++) waitForSwappedKey(c,c->argv[keyindex[j]]);
+        getKeysFreeResult(keyindex);
+    }
 
     /* If the client was blocked for at least one key, mark it as blocked. */
     if (listLength(c->io_keys)) {

From b4b5144694a4134544221a5587b81a98aec608be Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 28 Mar 2011 17:54:42 +0200
Subject: [PATCH 21/38] Fixes to the new preloading / key discovery APIs

---
 src/db.c      |  3 ++-
 src/dscache.c | 66 +++++++--------------------------------------------
 2 files changed, 11 insertions(+), 58 deletions(-)

diff --git a/src/db.c b/src/db.c
index 9bc299ca..5bab42af 100644
--- a/src/db.c
+++ b/src/db.c
@@ -634,8 +634,9 @@ int *getKeysUsingCommandTable(struct redisCommand *cmd,robj **argv, int argc, in
     keys = zmalloc(sizeof(int)*((last - cmd->firstkey)+1));
     for (j = cmd->firstkey; j <= last; j += cmd->keystep) {
         redisAssert(j < argc);
-        keys[i] = j;
+        keys[i++] = j;
     }
+    *numkeys = i;
     return keys;
 }
 
diff --git a/src/dscache.c b/src/dscache.c
index 45865264..31498358 100644
--- a/src/dscache.c
+++ b/src/dscache.c
@@ -903,61 +903,6 @@ int waitForSwappedKey(redisClient *c, robj *key) {
     return 1;
 }
 
-#if 0
-/* Preload keys for any command with first, last and step values for
- * the command keys prototype, as defined in the command table. */
-void waitForMultipleSwappedKeys(redisClient *c, struct redisCommand *cmd, int argc, robj **argv) {
-    int j, last;
-    if (cmd->vm_firstkey == 0) return;
-    last = cmd->vm_lastkey;
-    if (last < 0) last = argc+last;
-    for (j = cmd->vm_firstkey; j <= last; j += cmd->vm_keystep) {
-        redisAssert(j < argc);
-        waitForSwappedKey(c,argv[j]);
-    }
-}
-
-/* Preload keys needed for the ZUNIONSTORE and ZINTERSTORE commands.
- * Note that the number of keys to preload is user-defined, so we need to
- * apply a sanity check against argc. */
-void zunionInterBlockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd, int argc, robj **argv) {
-    int i, num;
-    REDIS_NOTUSED(cmd);
-
-    num = atoi(argv[2]->ptr);
-    if (num > (argc-3)) return;
-    for (i = 0; i < num; i++) {
-        waitForSwappedKey(c,argv[3+i]);
-    }
-}
-
-/* Preload keys needed to execute the entire MULTI/EXEC block.
- *
- * This function is called by blockClientOnSwappedKeys when EXEC is issued,
- * and will block the client when any command requires a swapped out value. */
-void execBlockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd, int argc, robj **argv) {
-    int i, margc;
-    struct redisCommand *mcmd;
-    robj **margv;
-    REDIS_NOTUSED(cmd);
-    REDIS_NOTUSED(argc);
-    REDIS_NOTUSED(argv);
-
-    if (!(c->flags & REDIS_MULTI)) return;
-    for (i = 0; i < c->mstate.count; i++) {
-        mcmd = c->mstate.commands[i].cmd;
-        margc = c->mstate.commands[i].argc;
-        margv = c->mstate.commands[i].argv;
-
-        if (mcmd->vm_preload_proc != NULL) {
-            mcmd->vm_preload_proc(c,mcmd,margc,margv);
-        } else {
-            waitForMultipleSwappedKeys(c,mcmd,margc,margv);
-        }
-    }
-}
-#endif
-
 /* Is this client attempting to run a command against swapped keys?
  * If so, block it ASAP, load the keys in background, then resume it.
  *
@@ -986,14 +931,21 @@ int blockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd) {
 
             keyindex = getKeysFromCommand(mcmd,margv,margc,&numkeys,
                                           REDIS_GETKEYS_PRELOAD);
-            for (j = 0; j < numkeys; j++)
+            for (j = 0; j < numkeys; j++) {
+                redisLog(REDIS_WARNING,"Preloading %s",
+                    (char*)margv[keyindex[j]]->ptr);
                 waitForSwappedKey(c,margv[keyindex[j]]);
+            }
             getKeysFreeResult(keyindex);
         }
     } else {
         keyindex = getKeysFromCommand(cmd,c->argv,c->argc,&numkeys,
                                       REDIS_GETKEYS_PRELOAD);
-        for (j = 0; j < numkeys; j++) waitForSwappedKey(c,c->argv[keyindex[j]]);
+        for (j = 0; j < numkeys; j++) {
+            redisLog(REDIS_WARNING,"Preloading %s",
+                (char*)c->argv[keyindex[j]]->ptr);
+            waitForSwappedKey(c,c->argv[keyindex[j]]);
+        }
         getKeysFreeResult(keyindex);
     }
 

From 6e1b9b58ec6ae895da686015d82d4f121f1bfb85 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 28 Mar 2011 18:21:06 +0200
Subject: [PATCH 22/38] bug fixed in zunionstore specific getKeys()
 implementation

---
 src/db.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/db.c b/src/db.c
index 5bab42af..7a9c9c4c 100644
--- a/src/db.c
+++ b/src/db.c
@@ -684,7 +684,7 @@ int *zunionInterGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *num
         *numkeys = 0;
         return NULL;
     }
-    keys = zmalloc(num);
+    keys = zmalloc(sizeof(int)*num);
     for (i = 0; i < num; i++) keys[i] = 3+i;
     *numkeys = num;
     return keys;

From 4b61ca460c5d043b9d199a4e4991bfac5dde66c5 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 28 Mar 2011 18:46:22 +0200
Subject: [PATCH 23/38] fixed a bug in RENAME getKeys() function

---
 src/db.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/db.c b/src/db.c
index 7a9c9c4c..fea2f12e 100644
--- a/src/db.c
+++ b/src/db.c
@@ -666,7 +666,7 @@ int *renameGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys,
         int *keys = zmalloc(sizeof(int));
         *numkeys = 1;
         keys[0] = 1;
-        return NULL;
+        return keys;
     } else {
         return getKeysUsingCommandTable(cmd,argv,argc,numkeys);
     }

From a07bc9269234bba1f51211bff304ce9caa15a9fb Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Mon, 28 Mar 2011 19:03:57 +0200
Subject: [PATCH 24/38] Preloading messages log level changed from WARNING to
 DEBUG

---
 src/dscache.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/dscache.c b/src/dscache.c
index 31498358..46300e63 100644
--- a/src/dscache.c
+++ b/src/dscache.c
@@ -932,7 +932,7 @@ int blockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd) {
             keyindex = getKeysFromCommand(mcmd,margv,margc,&numkeys,
                                           REDIS_GETKEYS_PRELOAD);
             for (j = 0; j < numkeys; j++) {
-                redisLog(REDIS_WARNING,"Preloading %s",
+                redisLog(REDIS_DEBUG,"Preloading %s",
                     (char*)margv[keyindex[j]]->ptr);
                 waitForSwappedKey(c,margv[keyindex[j]]);
             }
@@ -942,7 +942,7 @@ int blockClientOnSwappedKeys(redisClient *c, struct redisCommand *cmd) {
         keyindex = getKeysFromCommand(cmd,c->argv,c->argc,&numkeys,
                                       REDIS_GETKEYS_PRELOAD);
         for (j = 0; j < numkeys; j++) {
-            redisLog(REDIS_WARNING,"Preloading %s",
+            redisLog(REDIS_DEBUG,"Preloading %s",
                 (char*)c->argv[keyindex[j]]->ptr);
             waitForSwappedKey(c,c->argv[keyindex[j]]);
         }

From b46251d92970468f5e55e06db1f580acf1fab1c4 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 29 Mar 2011 11:04:55 +0200
Subject: [PATCH 25/38] TODO modified

---
 TODO | 1 +
 1 file changed, 1 insertion(+)

diff --git a/TODO b/TODO
index 580adda6..e7943307 100644
--- a/TODO
+++ b/TODO
@@ -12,6 +12,7 @@ WARNING: are you a possible Redis contributor?
 DISKSTORE TODO
 ==============
 
+* Fix FLUSHALL/FLUSHDB: the queue of pending reads/writes should be handled.
 * Check that 00/00 and ff/ff exist at startup, otherwise exit with error.
 * Implement sync flush option, where data is written synchronously on disk when a command is executed.
 * Implement MULTI/EXEC as transaction abstract API to diskstore.c, with transaction_start, transaction_end, and a journal to recover.

From ecc9109434002d4667cd01a3b7c067a508c876eb Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 29 Mar 2011 17:51:15 +0200
Subject: [PATCH 26/38] Cluster branch merged to unstable.

---
 CLUSTER         |  131 +++++
 src/Makefile    |    4 +-
 src/cluster.c   | 1299 +++++++++++++++++++++++++++++++++++++++++++++++
 src/config.c    |    4 +
 src/crc16.c     |   74 +++
 src/db.c        |    9 +
 src/rdb.c       |    2 +-
 src/redis-cli.c |   21 +-
 src/redis.c     |   42 +-
 src/redis.h     |  136 ++++-
 src/syncio.c    |   14 +
 11 files changed, 1727 insertions(+), 9 deletions(-)
 create mode 100644 CLUSTER
 create mode 100644 src/cluster.c
 create mode 100644 src/crc16.c

diff --git a/CLUSTER b/CLUSTER
new file mode 100644
index 00000000..bfe5234a
--- /dev/null
+++ b/CLUSTER
@@ -0,0 +1,131 @@
+TODO
+
+- disconnect FAIL clients after some pong idle time.
+
+---------------------------------
+
+* Majority rule: the cluster con continue when there are all the hash slots covered AND when there are the majority of masters.
+* Shutdown on request rule: when a node sees many connections closed or even a timeout longer than usual on almost all the other nodes, it will usually wait for the normal timeout before to change the state, unless it receives a query from a client: in such a case it will put itself into error status.
+
+--------------------------------
+
+* When asked for a key that is not in a node's business it will reply:
+
+    -ASK 1.2.3.4:6379   (in case we want the client to ask just one time)
+    -MOVED <slotid> 1.2.3.4:6379  (in case the hash slot is permanently moved)
+
+So with -ASK a client should just retry the query against this new node, a single time.
+
+With -MOVED the client should update its hash slots table to reflect the fact that now the specified node is the one to contact for the specified hash slot.
+
+* Nodes communicate using a binary protocol.
+
+* Node failure detection.
+
+    1) Every node contains information about all the other nodes:
+        - If this node is believed to work ok or not
+        - The hash slots for which this node is responsible
+        - If the node is a master or a slave
+        - If it is a slave, the slave of which node
+        - if it is a master, the list of slave nodes
+        - The slaves are ordered for "<ip>:<port>" string from lower to higher
+          ordered lexicographically. When a master is down, the cluster will
+          try to elect the first slave in the list.
+
+    2) Every node also contains the unix time where every other node was
+       reported to work properly (that is, it replied to a ping or any other
+       protocol request correctly). For every node we also store the timestamp
+       at which we sent the latest ping, so we can easily compute the current
+       lag.
+
+    3) From time to time a node pings a random node, selected among the nodes
+       with the least recent "alive" time stamp. Three random nodes are selected
+       and the one with lower alive time stamp is pinged.
+
+    4) The ping packet contains also information about a few random nodes
+       alive time stamp. So that the receiver of the ping will update the
+       alive table if the received alive timestamp is more recent the
+       one present in the node local table.
+
+       In the ping packet every node "gossip" information is somethig like
+       this:
+
+       <ip>:<port>:<status>:<pingsent_timestamp>:<pongreceived_timestamp>
+
+       status is OK, POSSIBLE_FAILURE, FAILURE.
+
+    5) The node replies to ping with a pong packet, that also contains a random
+       selections of nodes timestamps.
+
+A given node thinks another node may be in a failure state once there is a
+ping timeout bigger than 30 seconds (configurable).
+
+When a possible failure is detected the node performs the following action:
+
+    1) Is the average between all the other nodes big? For instance bigger
+       than 30 seconds / 2 = 15 seconds? Probably *we* are disconnected.
+       In such a case we don't trust our lag data, and reset all the
+       timestamps of sent ping to zero. This way when we'll reconnect there
+       is no risk that we'll claim many nodes are down, taking inappropriate
+       actions.
+
+    2) Messages from nodes marked as failed are *always* ignored by the other
+       nodes. A new node needs to be "introduced" by a good online node.
+
+    3) If we are well connected (that is, condition "1" is not true) and a
+       node timeout is > 30 seconds, we mark the node as POSSIBLE_FAILURE
+       (a flat in the cluster node structure). Every time we sent a ping
+       to another node we inform this other nodes that we detected this
+       condition, as already stated.
+
+    4) Once a node receives a POSSIBLE_FAILURE status for a node that is
+       already marked as POSSIBLE_FAILURE locally, it sends a message
+       to all the other nodes of type NODE_FAILURE_DETECTED, communicating the
+       ip/port of the specified node.
+
+       All the nodes need to update the status of this node setting it into
+       FAILURE.
+
+    5) If the computer in FAILURE state is a master node, what is needed is
+       to perform a Slave Election.
+
+SLAVE ELECTION
+
+    1) The slave election is performed by the first slave (with slaves ordered
+       lexicographically). Actually it is the first functioning slave, so if
+       the first slave is marked as failing the next slave will perform the
+       election and so forth. Such a slave is called the "Successor".
+
+    2) The Successor starts checking that all the nodes in the cluster already
+       marked the master in FAILURE state. If at least one node does not agree
+       no action is performed.
+
+    3) If all the nodes agree that the master is failing, the Successor does
+       the following:
+
+       a) It will send a SUCCESSION message to all the other nodes, that will
+          upgrade the hash slot tables accordingly. It will make sure that all
+          the nodes are updated and if some node did not received the message
+          it will keep trying.
+       b) Once all nodes not marked as FAILURE accepted the SUCCESSION message
+          it will update his own table and will start acting as a master
+          accepting write queries.
+       c) Every node receiving the succession message, if not already informed
+          of the change will broadcast the same message to other three random
+          nodes. No action is performed if the specified host was already marked
+          as the master node.
+       d) A node that was a slave of the original master that failed will
+          switch master to the new one once the SUCCESSION message is received.
+
+RANDOM
+
+    1) When selecting a slave, the system will try to pick one with an IP different than the master and other slaves, if possible.
+
+    2) The PING packet also contains information about the local configuration checksum. This is the SHA1 of the current configuration, without the bits that normally change form one node to another (like latest ping reply, failure status of nodes, and so forth). From time to time the local config SHA1 is checked against the list of the other nodes, and if there is a mismatch between our configuration and the most common one that lasts for more than N seconds, the most common configuration is asked and retrieved from another node. The event is logged.
+
+    3) Every time a node updates its internal cluster configuration, it dumps such a config in the cluster.conf file. On startup the configuration is reloaded.
+    Nodes can share the cluster configuration when needed (for instance if SHA1 does not match) using this exact same format.
+
+CLIENTS
+
+    - Clients may be configured to use slaves to perform reads, when read-after-write consistency is not required.
diff --git a/src/Makefile b/src/Makefile
index acbc9b5f..f99be4b9 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -25,7 +25,7 @@ PREFIX= /usr/local
 INSTALL_BIN= $(PREFIX)/bin
 INSTALL= cp -p
 
-OBJ = adlist.o ae.o anet.o dict.o redis.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o dscache.o pubsub.o multi.o debug.o sort.o intset.o syncio.o diskstore.o endian.o
+OBJ = adlist.o ae.o anet.o dict.o redis.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o dscache.o pubsub.o multi.o debug.o sort.o intset.o syncio.o diskstore.o cluster.o crc16.o endian.o
 BENCHOBJ = ae.o anet.o redis-benchmark.o sds.o adlist.o zmalloc.o
 CLIOBJ = anet.o sds.o adlist.o redis-cli.o zmalloc.o release.o
 CHECKDUMPOBJ = redis-check-dump.o lzf_c.o lzf_d.o
@@ -105,6 +105,8 @@ t_zset.o: t_zset.c redis.h fmacros.h config.h ae.h sds.h dict.h adlist.h \
   zmalloc.h anet.h zipmap.h ziplist.h intset.h version.h
 util.o: util.c redis.h fmacros.h config.h ae.h sds.h dict.h adlist.h \
   zmalloc.h anet.h zipmap.h ziplist.h intset.h version.h
+cluster.o: redis.h fmacros.h config.h ae.h sds.h dict.h adlist.h \
+  zmalloc.h anet.h zipmap.h ziplist.h intset.h version.h
 ziplist.o: ziplist.c zmalloc.h ziplist.h
 zipmap.o: zipmap.c zmalloc.h
 zmalloc.o: zmalloc.c config.h
diff --git a/src/cluster.c b/src/cluster.c
new file mode 100644
index 00000000..aac52578
--- /dev/null
+++ b/src/cluster.c
@@ -0,0 +1,1299 @@
+#include "redis.h"
+
+#include <arpa/inet.h>
+
+void clusterAcceptHandler(aeEventLoop *el, int fd, void *privdata, int mask);
+void clusterReadHandler(aeEventLoop *el, int fd, void *privdata, int mask);
+void clusterSendPing(clusterLink *link, int type);
+void clusterSendFail(char *nodename);
+void clusterUpdateState(void);
+int clusterNodeGetSlotBit(clusterNode *n, int slot);
+
+/* -----------------------------------------------------------------------------
+ * Initialization
+ * -------------------------------------------------------------------------- */
+
+void clusterGetRandomName(char *p) {
+    FILE *fp = fopen("/dev/urandom","r");
+    char *charset = "0123456789abcdef";
+    int j;
+
+    if (!fp) {
+        redisLog(REDIS_WARNING,
+            "Unrecovarable error: can't open /dev/urandom:%s" ,strerror(errno));
+        exit(1);
+    }
+    fread(p,REDIS_CLUSTER_NAMELEN,1,fp);
+    for (j = 0; j < REDIS_CLUSTER_NAMELEN; j++)
+        p[j] = charset[p[j] & 0x0F];
+    fclose(fp);
+}
+
+int clusterLoadConfig(char *filename) {
+    FILE *fp = fopen(filename,"r");
+    
+    if (fp == NULL) return REDIS_ERR;
+    fclose(fp);
+
+    redisLog(REDIS_NOTICE,"Node configuration loaded, I'm %.40s",
+        server.cluster.myself->name);
+    return REDIS_OK;
+
+fmterr:
+    redisLog(REDIS_WARNING,"Unrecovarable error: corrupted cluster.conf file.");
+    fclose(fp);
+    exit(1);
+}
+
+void clusterInit(void) {
+    server.cluster.myself = createClusterNode(NULL,REDIS_NODE_MYSELF);
+    server.cluster.state = REDIS_CLUSTER_FAIL;
+    server.cluster.nodes = dictCreate(&clusterNodesDictType,NULL);
+    server.cluster.node_timeout = 15;
+    memset(server.cluster.migrating_slots_to,0,
+        sizeof(server.cluster.migrating_slots_to));
+    memset(server.cluster.importing_slots_from,0,
+        sizeof(server.cluster.importing_slots_from));
+    memset(server.cluster.slots,0,
+        sizeof(server.cluster.slots));
+    if (clusterLoadConfig("cluster.conf") == REDIS_ERR) {
+        /* No configuration found. We will just use the random name provided
+         * by the createClusterNode() function. */
+        redisLog(REDIS_NOTICE,"No cluster configuration found, I'm %.40s",
+            server.cluster.myself->name);
+    }
+    clusterAddNode(server.cluster.myself);
+    /* We need a listening TCP port for our cluster messaging needs */
+    server.cfd = anetTcpServer(server.neterr,
+            server.port+REDIS_CLUSTER_PORT_INCR, server.bindaddr);
+    if (server.cfd == -1) {
+        redisLog(REDIS_WARNING, "Opening cluster TCP port: %s", server.neterr);
+        exit(1);
+    }
+    if (aeCreateFileEvent(server.el, server.cfd, AE_READABLE,
+        clusterAcceptHandler, NULL) == AE_ERR) oom("creating file event");
+}
+
+/* -----------------------------------------------------------------------------
+ * CLUSTER communication link
+ * -------------------------------------------------------------------------- */
+
+clusterLink *createClusterLink(clusterNode *node) {
+    clusterLink *link = zmalloc(sizeof(*link));
+    link->sndbuf = sdsempty();
+    link->rcvbuf = sdsempty();
+    link->node = node;
+    link->fd = -1;
+    return link;
+}
+
+/* Free a cluster link, but does not free the associated node of course.
+ * Just this function will make sure that the original node associated
+ * with this link will have the 'link' field set to NULL. */
+void freeClusterLink(clusterLink *link) {
+    if (link->fd != -1) {
+        aeDeleteFileEvent(server.el, link->fd, AE_WRITABLE);
+        aeDeleteFileEvent(server.el, link->fd, AE_READABLE);
+    }
+    sdsfree(link->sndbuf);
+    sdsfree(link->rcvbuf);
+    if (link->node)
+        link->node->link = NULL;
+    close(link->fd);
+    zfree(link);
+}
+
+void clusterAcceptHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
+    int cport, cfd;
+    char cip[128];
+    clusterLink *link;
+    REDIS_NOTUSED(el);
+    REDIS_NOTUSED(mask);
+    REDIS_NOTUSED(privdata);
+
+    cfd = anetTcpAccept(server.neterr, fd, cip, &cport);
+    if (cfd == AE_ERR) {
+        redisLog(REDIS_VERBOSE,"Accepting cluster node: %s", server.neterr);
+        return;
+    }
+    redisLog(REDIS_VERBOSE,"Accepted cluster node %s:%d", cip, cport);
+    /* We need to create a temporary node in order to read the incoming
+     * packet in a valid contest. This node will be released once we
+     * read the packet and reply. */
+    link = createClusterLink(NULL);
+    link->fd = cfd;
+    aeCreateFileEvent(server.el,cfd,AE_READABLE,clusterReadHandler,link);
+}
+
+/* -----------------------------------------------------------------------------
+ * Key space handling
+ * -------------------------------------------------------------------------- */
+
+/* We have 4096 hash slots. The hash slot of a given key is obtained
+ * as the least significant 12 bits of the crc16 of the key. */
+unsigned int keyHashSlot(char *key, int keylen) {
+    return crc16(key,keylen) & 0x0FFF;
+}
+
+/* -----------------------------------------------------------------------------
+ * CLUSTER node API
+ * -------------------------------------------------------------------------- */
+
+/* Create a new cluster node, with the specified flags.
+ * If "nodename" is NULL this is considered a first handshake and a random
+ * node name is assigned to this node (it will be fixed later when we'll
+ * receive the first pong).
+ *
+ * The node is created and returned to the user, but it is not automatically
+ * added to the nodes hash table. */
+clusterNode *createClusterNode(char *nodename, int flags) {
+    clusterNode *node = zmalloc(sizeof(*node));
+
+    if (nodename)
+        memcpy(node->name, nodename, REDIS_CLUSTER_NAMELEN);
+    else
+        clusterGetRandomName(node->name);
+    node->flags = flags;
+    memset(node->slots,0,sizeof(node->slots));
+    node->numslaves = 0;
+    node->slaves = NULL;
+    node->slaveof = NULL;
+    node->ping_sent = node->pong_received = 0;
+    node->configdigest = NULL;
+    node->configdigest_ts = 0;
+    node->link = NULL;
+    return node;
+}
+
+int clusterNodeRemoveSlave(clusterNode *master, clusterNode *slave) {
+    int j;
+
+    for (j = 0; j < master->numslaves; j++) {
+        if (master->slaves[j] == slave) {
+            memmove(master->slaves+j,master->slaves+(j+1),
+                (master->numslaves-1)-j);
+            master->numslaves--;
+            return REDIS_OK;
+        }
+    }
+    return REDIS_ERR;
+}
+
+int clusterNodeAddSlave(clusterNode *master, clusterNode *slave) {
+    int j;
+
+    /* If it's already a slave, don't add it again. */
+    for (j = 0; j < master->numslaves; j++)
+        if (master->slaves[j] == slave) return REDIS_ERR;
+    master->slaves = zrealloc(master->slaves,
+        sizeof(clusterNode*)*(master->numslaves+1));
+    master->slaves[master->numslaves] = slave;
+    master->numslaves++;
+    return REDIS_OK;
+}
+
+void clusterNodeResetSlaves(clusterNode *n) {
+    zfree(n->slaves);
+    n->numslaves = 0;
+}
+
+void freeClusterNode(clusterNode *n) {
+    sds nodename;
+    
+    nodename = sdsnewlen(n->name, REDIS_CLUSTER_NAMELEN);
+    redisAssert(dictDelete(server.cluster.nodes,nodename) == DICT_OK);
+    sdsfree(nodename);
+    if (n->slaveof) clusterNodeRemoveSlave(n->slaveof, n);
+    if (n->link) freeClusterLink(n->link);
+    zfree(n);
+}
+
+/* Add a node to the nodes hash table */
+int clusterAddNode(clusterNode *node) {
+    int retval;
+    
+    retval = dictAdd(server.cluster.nodes,
+            sdsnewlen(node->name,REDIS_CLUSTER_NAMELEN), node);
+    return (retval == DICT_OK) ? REDIS_OK : REDIS_ERR;
+}
+
+/* Node lookup by name */
+clusterNode *clusterLookupNode(char *name) {
+    sds s = sdsnewlen(name, REDIS_CLUSTER_NAMELEN);
+    struct dictEntry *de;
+
+    de = dictFind(server.cluster.nodes,s);
+    sdsfree(s);
+    if (de == NULL) return NULL;
+    return dictGetEntryVal(de);
+}
+
+/* This is only used after the handshake. When we connect a given IP/PORT
+ * as a result of CLUSTER MEET we don't have the node name yet, so we
+ * pick a random one, and will fix it when we receive the PONG request using
+ * this function. */
+void clusterRenameNode(clusterNode *node, char *newname) {
+    int retval;
+    sds s = sdsnewlen(node->name, REDIS_CLUSTER_NAMELEN);
+   
+    redisLog(REDIS_DEBUG,"Renaming node %.40s into %.40s",
+        node->name, newname);
+    retval = dictDelete(server.cluster.nodes, s);
+    sdsfree(s);
+    redisAssert(retval == DICT_OK);
+    memcpy(node->name, newname, REDIS_CLUSTER_NAMELEN);
+    clusterAddNode(node);
+}
+
+/* -----------------------------------------------------------------------------
+ * CLUSTER messages exchange - PING/PONG and gossip
+ * -------------------------------------------------------------------------- */
+
+/* Process the gossip section of PING or PONG packets.
+ * Note that this function assumes that the packet is already sanity-checked
+ * by the caller, not in the content of the gossip section, but in the
+ * length. */
+void clusterProcessGossipSection(clusterMsg *hdr, clusterLink *link) {
+    uint16_t count = ntohs(hdr->count);
+    clusterMsgDataGossip *g = (clusterMsgDataGossip*) hdr->data.ping.gossip;
+    clusterNode *sender = link->node ? link->node : clusterLookupNode(hdr->sender);
+
+    while(count--) {
+        sds ci = sdsempty();
+        uint16_t flags = ntohs(g->flags);
+        clusterNode *node;
+
+        if (flags == 0) ci = sdscat(ci,"noflags,");
+        if (flags & REDIS_NODE_MYSELF) ci = sdscat(ci,"myself,");
+        if (flags & REDIS_NODE_MASTER) ci = sdscat(ci,"master,");
+        if (flags & REDIS_NODE_SLAVE) ci = sdscat(ci,"slave,");
+        if (flags & REDIS_NODE_PFAIL) ci = sdscat(ci,"fail?,");
+        if (flags & REDIS_NODE_FAIL) ci = sdscat(ci,"fail,");
+        if (flags & REDIS_NODE_HANDSHAKE) ci = sdscat(ci,"handshake,");
+        if (flags & REDIS_NODE_NOADDR) ci = sdscat(ci,"noaddr,");
+        if (ci[sdslen(ci)-1] == ',') ci[sdslen(ci)-1] = ' ';
+
+        redisLog(REDIS_DEBUG,"GOSSIP %.40s %s:%d %s",
+            g->nodename,
+            g->ip,
+            ntohs(g->port),
+            ci);
+        sdsfree(ci);
+
+        /* Update our state accordingly to the gossip sections */
+        node = clusterLookupNode(g->nodename);
+        if (node != NULL) {
+            /* We already know this node. Let's start updating the last
+             * time PONG figure if it is newer than our figure.
+             * Note that it's not a problem if we have a PING already 
+             * in progress against this node. */
+            if (node->pong_received < ntohl(g->pong_received)) {
+                 redisLog(REDIS_DEBUG,"Node pong_received updated by gossip");
+                node->pong_received = ntohl(g->pong_received);
+            }
+            /* Mark this node as FAILED if we think it is possibly failing
+             * and another node also thinks it's failing. */
+            if (node->flags & REDIS_NODE_PFAIL &&
+                (flags & (REDIS_NODE_FAIL|REDIS_NODE_PFAIL)))
+            {
+                redisLog(REDIS_NOTICE,"Received a PFAIL acknowledge from node %.40s, marking node %.40s as FAIL!", hdr->sender, node->name);
+                node->flags &= ~REDIS_NODE_PFAIL;
+                node->flags |= REDIS_NODE_FAIL;
+                /* Broadcast the failing node name to everybody */
+                clusterSendFail(node->name);
+                clusterUpdateState();
+            }
+        } else {
+            /* If it's not in NOADDR state and we don't have it, we
+             * start an handshake process against this IP/PORT pairs.
+             *
+             * Note that we require that the sender of this gossip message
+             * is a well known node in our cluster, otherwise we risk
+             * joining another cluster. */
+            if (sender && !(flags & REDIS_NODE_NOADDR)) {
+                clusterNode *newnode;
+
+                redisLog(REDIS_DEBUG,"Adding the new node");
+                newnode = createClusterNode(NULL,REDIS_NODE_HANDSHAKE);
+                memcpy(newnode->ip,g->ip,sizeof(g->ip));
+                newnode->port = ntohs(g->port);
+                clusterAddNode(newnode);
+            }
+        }
+
+        /* Next node */
+        g++;
+    }
+}
+
+/* IP -> string conversion. 'buf' is supposed to at least be 16 bytes. */
+void nodeIp2String(char *buf, clusterLink *link) {
+    struct sockaddr_in sa;
+    socklen_t salen = sizeof(sa);
+
+    if (getpeername(link->fd, (struct sockaddr*) &sa, &salen) == -1)
+        redisPanic("getpeername() failed.");
+    strncpy(buf,inet_ntoa(sa.sin_addr),sizeof(link->node->ip));
+}
+
+
+/* Update the node address to the IP address that can be extracted
+ * from link->fd, and at the specified port. */
+void nodeUpdateAddress(clusterNode *node, clusterLink *link, int port) {
+}
+
+/* When this function is called, there is a packet to process starting
+ * at node->rcvbuf. Releasing the buffer is up to the caller, so this
+ * function should just handle the higher level stuff of processing the
+ * packet, modifying the cluster state if needed.
+ *
+ * The function returns 1 if the link is still valid after the packet
+ * was processed, otherwise 0 if the link was freed since the packet
+ * processing lead to some inconsistency error (for instance a PONG
+ * received from the wrong sender ID). */
+int clusterProcessPacket(clusterLink *link) {
+    clusterMsg *hdr = (clusterMsg*) link->rcvbuf;
+    uint32_t totlen = ntohl(hdr->totlen);
+    uint16_t type = ntohs(hdr->type);
+    clusterNode *sender;
+
+    redisLog(REDIS_DEBUG,"--- packet to process %lu bytes (%lu) ---",
+        (unsigned long) totlen, sdslen(link->rcvbuf));
+    if (totlen < 8) return 1;
+    if (totlen > sdslen(link->rcvbuf)) return 1;
+    if (type == CLUSTERMSG_TYPE_PING || type == CLUSTERMSG_TYPE_PONG ||
+        type == CLUSTERMSG_TYPE_MEET)
+    {
+        uint16_t count = ntohs(hdr->count);
+        uint32_t explen; /* expected length of this packet */
+
+        explen = sizeof(clusterMsg)-sizeof(union clusterMsgData);
+        explen += (sizeof(clusterMsgDataGossip)*count);
+        if (totlen != explen) return 1;
+    }
+    if (type == CLUSTERMSG_TYPE_FAIL) {
+        uint32_t explen = sizeof(clusterMsg)-sizeof(union clusterMsgData);
+
+        explen += sizeof(clusterMsgDataFail);
+        if (totlen != explen) return 1;
+    }
+
+    sender = clusterLookupNode(hdr->sender);
+    if (type == CLUSTERMSG_TYPE_PING || type == CLUSTERMSG_TYPE_MEET) {
+        redisLog(REDIS_DEBUG,"Ping packet received: %p", link->node);
+
+        /* Add this node if it is new for us and the msg type is MEET.
+         * In this stage we don't try to add the node with the right
+         * flags, slaveof pointer, and so forth, as this details will be
+         * resolved when we'll receive PONGs from the server. */
+        if (!sender && type == CLUSTERMSG_TYPE_MEET) {
+            clusterNode *node;
+
+            node = createClusterNode(NULL,REDIS_NODE_HANDSHAKE);
+            nodeIp2String(node->ip,link);
+            node->port = ntohs(hdr->port);
+            clusterAddNode(node);
+        }
+
+        /* Get info from the gossip section */
+        clusterProcessGossipSection(hdr,link);
+
+        /* Anyway reply with a PONG */
+        clusterSendPing(link,CLUSTERMSG_TYPE_PONG);
+    } else if (type == CLUSTERMSG_TYPE_PONG) {
+        int update = 0;
+
+        redisLog(REDIS_DEBUG,"Pong packet received: %p", link->node);
+        if (link->node) {
+            if (link->node->flags & REDIS_NODE_HANDSHAKE) {
+                /* If we already have this node, try to change the
+                 * IP/port of the node with the new one. */
+                if (sender) {
+                    redisLog(REDIS_WARNING,
+                        "Handshake error: we already know node %.40s, updating the address if needed.", sender->name);
+                    nodeUpdateAddress(sender,link,ntohs(hdr->port));
+                    freeClusterNode(link->node); /* will free the link too */
+                    return 0;
+                }
+
+                /* First thing to do is replacing the random name with the
+                 * right node name if this was an handshake stage. */
+                clusterRenameNode(link->node, hdr->sender);
+                redisLog(REDIS_DEBUG,"Handshake with node %.40s completed.",
+                    link->node->name);
+                link->node->flags &= ~REDIS_NODE_HANDSHAKE;
+            } else if (memcmp(link->node->name,hdr->sender,
+                        REDIS_CLUSTER_NAMELEN) != 0)
+            {
+                /* If the reply has a non matching node ID we
+                 * disconnect this node and set it as not having an associated
+                 * address. */
+                redisLog(REDIS_DEBUG,"PONG contains mismatching sender ID");
+                link->node->flags |= REDIS_NODE_NOADDR;
+                freeClusterLink(link);
+                /* FIXME: remove this node if we already have it.
+                 *
+                 * If we already have it but the IP is different, use
+                 * the new one if the old node is in FAIL, PFAIL, or NOADDR
+                 * status... */
+                return 0;
+            }
+        }
+        /* Update our info about the node */
+        link->node->pong_received = time(NULL);
+
+        /* Update master/slave info */
+        if (sender) {
+            if (!memcmp(hdr->slaveof,REDIS_NODE_NULL_NAME,
+                sizeof(hdr->slaveof)))
+            {
+                sender->flags &= ~REDIS_NODE_SLAVE;
+                sender->flags |= REDIS_NODE_MASTER;
+                sender->slaveof = NULL;
+            } else {
+                clusterNode *master = clusterLookupNode(hdr->slaveof);
+
+                sender->flags &= ~REDIS_NODE_MASTER;
+                sender->flags |= REDIS_NODE_SLAVE;
+                if (sender->numslaves) clusterNodeResetSlaves(sender);
+                if (master) clusterNodeAddSlave(master,sender);
+            }
+        }
+
+        /* Update our info about served slots if this new node is serving
+         * slots that are not served from our point of view. */
+        if (sender && sender->flags & REDIS_NODE_MASTER) {
+            int newslots, j;
+
+            newslots =
+                memcmp(sender->slots,hdr->myslots,sizeof(hdr->myslots)) != 0;
+            memcpy(sender->slots,hdr->myslots,sizeof(hdr->myslots));
+            if (newslots) {
+                for (j = 0; j < REDIS_CLUSTER_SLOTS; j++) {
+                    if (clusterNodeGetSlotBit(sender,j)) {
+                        if (server.cluster.slots[j] == sender) continue;
+                        if (server.cluster.slots[j] == NULL ||
+                            server.cluster.slots[j]->flags & REDIS_NODE_FAIL)
+                        {
+                            server.cluster.slots[j] = sender;
+                            update = 1;
+                        }
+                    }
+                }
+            }
+        }
+
+        /* Get info from the gossip section */
+        clusterProcessGossipSection(hdr,link);
+
+        /* Update the cluster state if needed */
+        if (update) clusterUpdateState();
+    } else if (type == CLUSTERMSG_TYPE_FAIL && sender) {
+        clusterNode *failing;
+
+        failing = clusterLookupNode(hdr->data.fail.about.nodename);
+        if (failing && !(failing->flags & REDIS_NODE_FAIL)) {
+            redisLog(REDIS_NOTICE,
+                "FAIL message received from %.40s about %.40s",
+                hdr->sender, hdr->data.fail.about.nodename);
+            failing->flags |= REDIS_NODE_FAIL;
+            failing->flags &= ~REDIS_NODE_PFAIL;
+            clusterUpdateState();
+        }
+    } else {
+        redisLog(REDIS_NOTICE,"Received unknown packet type: %d", type);
+    }
+    return 1;
+}
+
+/* This function is called when we detect the link with this node is lost.
+   We set the node as no longer connected. The Cluster Cron will detect
+   this connection and will try to get it connected again.
+   
+   Instead if the node is a temporary node used to accept a query, we
+   completely free the node on error. */
+void handleLinkIOError(clusterLink *link) {
+    freeClusterLink(link);
+}
+
+/* Send data. This is handled using a trivial send buffer that gets
+ * consumed by write(). We don't try to optimize this for speed too much
+ * as this is a very low traffic channel. */
+void clusterWriteHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
+    clusterLink *link = (clusterLink*) privdata;
+    ssize_t nwritten;
+    REDIS_NOTUSED(el);
+    REDIS_NOTUSED(mask);
+
+    nwritten = write(fd, link->sndbuf, sdslen(link->sndbuf));
+    if (nwritten <= 0) {
+        redisLog(REDIS_NOTICE,"I/O error writing to node link: %s",
+            strerror(errno));
+        handleLinkIOError(link);
+        return;
+    }
+    link->sndbuf = sdsrange(link->sndbuf,nwritten,-1);
+    if (sdslen(link->sndbuf) == 0)
+        aeDeleteFileEvent(server.el, link->fd, AE_WRITABLE);
+}
+
+/* Read data. Try to read the first field of the header first to check the
+ * full length of the packet. When a whole packet is in memory this function
+ * will call the function to process the packet. And so forth. */
+void clusterReadHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
+    char buf[1024];
+    ssize_t nread;
+    clusterMsg *hdr;
+    clusterLink *link = (clusterLink*) privdata;
+    int readlen;
+    REDIS_NOTUSED(el);
+    REDIS_NOTUSED(mask);
+
+again:
+    if (sdslen(link->rcvbuf) >= 4) {
+        hdr = (clusterMsg*) link->rcvbuf;
+        readlen = ntohl(hdr->totlen) - sdslen(link->rcvbuf);
+    } else {
+        readlen = 4 - sdslen(link->rcvbuf);
+    }
+
+    nread = read(fd,buf,readlen);
+    if (nread == -1 && errno == EAGAIN) return; /* Just no data */
+
+    if (nread <= 0) {
+        /* I/O error... */
+        redisLog(REDIS_NOTICE,"I/O error reading from node link: %s",
+            (nread == 0) ? "connection closed" : strerror(errno));
+        handleLinkIOError(link);
+        return;
+    } else {
+        /* Read data and recast the pointer to the new buffer. */
+        link->rcvbuf = sdscatlen(link->rcvbuf,buf,nread);
+        hdr = (clusterMsg*) link->rcvbuf;
+    }
+
+    /* Total length obtained? read the payload now instead of burning
+     * cycles waiting for a new event to fire. */
+    if (sdslen(link->rcvbuf) == 4) goto again;
+
+    /* Whole packet in memory? We can process it. */
+    if (sdslen(link->rcvbuf) == ntohl(hdr->totlen)) {
+        if (clusterProcessPacket(link)) {
+            sdsfree(link->rcvbuf);
+            link->rcvbuf = sdsempty();
+        }
+    }
+}
+
+/* Put stuff into the send buffer. */
+void clusterSendMessage(clusterLink *link, unsigned char *msg, size_t msglen) {
+    if (sdslen(link->sndbuf) == 0 && msglen != 0)
+        aeCreateFileEvent(server.el,link->fd,AE_WRITABLE,
+                    clusterWriteHandler,link);
+
+    link->sndbuf = sdscatlen(link->sndbuf, msg, msglen);
+}
+
+/* Build the message header */
+void clusterBuildMessageHdr(clusterMsg *hdr, int type) {
+    int totlen;
+
+    memset(hdr,0,sizeof(*hdr));
+    hdr->type = htons(type);
+    memcpy(hdr->sender,server.cluster.myself->name,REDIS_CLUSTER_NAMELEN);
+    memcpy(hdr->myslots,server.cluster.myself->slots,
+        sizeof(hdr->myslots));
+    memset(hdr->slaveof,0,REDIS_CLUSTER_NAMELEN);
+    if (server.cluster.myself->slaveof != NULL) {
+        memcpy(hdr->slaveof,server.cluster.myself->slaveof->name,
+                                    REDIS_CLUSTER_NAMELEN);
+    }
+    hdr->port = htons(server.port);
+    hdr->state = server.cluster.state;
+    memset(hdr->configdigest,0,32); /* FIXME: set config digest */
+
+    if (type == CLUSTERMSG_TYPE_FAIL) {
+        totlen = sizeof(clusterMsg)-sizeof(union clusterMsgData);
+        totlen += sizeof(clusterMsgDataFail);
+    }
+    hdr->totlen = htonl(totlen);
+    /* For PING, PONG, and MEET, fixing the totlen field is up to the caller */
+}
+
+/* Send a PING or PONG packet to the specified node, making sure to add enough
+ * gossip informations. */
+void clusterSendPing(clusterLink *link, int type) {
+    unsigned char buf[1024];
+    clusterMsg *hdr = (clusterMsg*) buf;
+    int gossipcount = 0, totlen;
+    /* freshnodes is the number of nodes we can still use to populate the
+     * gossip section of the ping packet. Basically we start with the nodes
+     * we have in memory minus two (ourself and the node we are sending the
+     * message to). Every time we add a node we decrement the counter, so when
+     * it will drop to <= zero we know there is no more gossip info we can
+     * send. */
+    int freshnodes = dictSize(server.cluster.nodes)-2;
+
+    if (link->node && type == CLUSTERMSG_TYPE_PING)
+        link->node->ping_sent = time(NULL);
+    clusterBuildMessageHdr(hdr,type);
+        
+    /* Populate the gossip fields */
+    while(freshnodes > 0 && gossipcount < 3) {
+        struct dictEntry *de = dictGetRandomKey(server.cluster.nodes);
+        clusterNode *this = dictGetEntryVal(de);
+        clusterMsgDataGossip *gossip;
+        int j;
+
+        /* Not interesting to gossip about ourself.
+         * Nor to send gossip info about HANDSHAKE state nodes (zero info). */
+        if (this == server.cluster.myself ||
+            this->flags & REDIS_NODE_HANDSHAKE) {
+                freshnodes--; /* otherwise we may loop forever. */
+                continue;
+        }
+
+        /* Check if we already added this node */
+        for (j = 0; j < gossipcount; j++) {
+            if (memcmp(hdr->data.ping.gossip[j].nodename,this->name,
+                    REDIS_CLUSTER_NAMELEN) == 0) break;
+        }
+        if (j != gossipcount) continue;
+
+        /* Add it */
+        freshnodes--;
+        gossip = &(hdr->data.ping.gossip[gossipcount]);
+        memcpy(gossip->nodename,this->name,REDIS_CLUSTER_NAMELEN);
+        gossip->ping_sent = htonl(this->ping_sent);
+        gossip->pong_received = htonl(this->pong_received);
+        memcpy(gossip->ip,this->ip,sizeof(this->ip));
+        gossip->port = htons(this->port);
+        gossip->flags = htons(this->flags);
+        gossipcount++;
+    }
+    totlen = sizeof(clusterMsg)-sizeof(union clusterMsgData);
+    totlen += (sizeof(clusterMsgDataGossip)*gossipcount);
+    hdr->count = htons(gossipcount);
+    hdr->totlen = htonl(totlen);
+    clusterSendMessage(link,buf,totlen);
+}
+
+/* Send a message to all the nodes with a reliable link */
+void clusterBroadcastMessage(void *buf, size_t len) {
+    dictIterator *di;
+    dictEntry *de;
+
+    di = dictGetIterator(server.cluster.nodes);
+    while((de = dictNext(di)) != NULL) {
+        clusterNode *node = dictGetEntryVal(de);
+
+        if (!node->link) continue;
+        if (node->flags & (REDIS_NODE_MYSELF|REDIS_NODE_NOADDR)) continue;
+        clusterSendMessage(node->link,buf,len);
+    }
+    dictReleaseIterator(di);
+}
+
+/* Send a FAIL message to all the nodes we are able to contact.
+ * The FAIL message is sent when we detect that a node is failing
+ * (REDIS_NODE_PFAIL) and we also receive a gossip confirmation of this:
+ * we switch the node state to REDIS_NODE_FAIL and ask all the other
+ * nodes to do the same ASAP. */
+void clusterSendFail(char *nodename) {
+    unsigned char buf[1024];
+    clusterMsg *hdr = (clusterMsg*) buf;
+
+    clusterBuildMessageHdr(hdr,CLUSTERMSG_TYPE_FAIL);
+    memcpy(hdr->data.fail.about.nodename,nodename,REDIS_CLUSTER_NAMELEN);
+    clusterBroadcastMessage(buf,ntohl(hdr->totlen));
+}
+
+/* -----------------------------------------------------------------------------
+ * CLUSTER cron job
+ * -------------------------------------------------------------------------- */
+
+/* This is executed 1 time every second */
+void clusterCron(void) {
+    dictIterator *di;
+    dictEntry *de;
+    int j;
+    time_t min_ping_sent = 0;
+    clusterNode *min_ping_node = NULL;
+
+    /* Check if we have disconnected nodes and reestablish the connection. */
+    di = dictGetIterator(server.cluster.nodes);
+    while((de = dictNext(di)) != NULL) {
+        clusterNode *node = dictGetEntryVal(de);
+
+        if (node->flags & (REDIS_NODE_MYSELF|REDIS_NODE_NOADDR)) continue;
+        if (node->link == NULL) {
+            int fd;
+            clusterLink *link;
+
+            fd = anetTcpNonBlockConnect(server.neterr, node->ip,
+                node->port+REDIS_CLUSTER_PORT_INCR);
+            if (fd == -1) continue;
+            link = createClusterLink(node);
+            link->fd = fd;
+            node->link = link;
+            aeCreateFileEvent(server.el,link->fd,AE_READABLE,clusterReadHandler,link);
+            /* If the node is flagged as MEET, we send a MEET message instead
+             * of a PING one, to force the receiver to add us in its node
+             * table. */
+            clusterSendPing(link, node->flags & REDIS_NODE_MEET ?
+                    CLUSTERMSG_TYPE_MEET : CLUSTERMSG_TYPE_PING);
+            /* We can clear the flag after the first packet is sent.
+             * If we'll never receive a PONG, we'll never send new packets
+             * to this node. Instead after the PONG is received and we
+             * are no longer in meet/handshake status, we want to send
+             * normal PING packets. */
+            node->flags &= ~REDIS_NODE_MEET;
+
+            redisLog(REDIS_NOTICE,"Connecting with Node %.40s at %s:%d\n", node->name, node->ip, node->port+REDIS_CLUSTER_PORT_INCR);
+        }
+    }
+    dictReleaseIterator(di);
+
+    /* Ping some random node. Check a few random nodes and ping the one with
+     * the oldest ping_sent time */
+    for (j = 0; j < 5; j++) {
+        de = dictGetRandomKey(server.cluster.nodes);
+        clusterNode *this = dictGetEntryVal(de);
+
+        if (this->link == NULL) continue;
+        if (this->flags & (REDIS_NODE_MYSELF|REDIS_NODE_HANDSHAKE)) continue;
+        if (min_ping_node == NULL || min_ping_sent > this->ping_sent) {
+            min_ping_node = this;
+            min_ping_sent = this->ping_sent;
+        }
+    }
+    if (min_ping_node) {
+        redisLog(REDIS_DEBUG,"Pinging node %40s", min_ping_node->name);
+        clusterSendPing(min_ping_node->link, CLUSTERMSG_TYPE_PING);
+    }
+
+    /* Iterate nodes to check if we need to flag something as failing */
+    di = dictGetIterator(server.cluster.nodes);
+    while((de = dictNext(di)) != NULL) {
+        clusterNode *node = dictGetEntryVal(de);
+        int delay;
+
+        if (node->flags &
+            (REDIS_NODE_MYSELF|REDIS_NODE_NOADDR|REDIS_NODE_HANDSHAKE|
+             REDIS_NODE_FAIL)) continue;
+        /* Check only if we already sent a ping and did not received
+         * a reply yet. */
+        if (node->ping_sent == 0 ||
+            node->ping_sent <= node->pong_received) continue;
+
+        delay = time(NULL) - node->pong_received;
+        if (node->flags & REDIS_NODE_PFAIL) {
+            /* The PFAIL condition can be reversed without external
+             * help if it is not transitive (that is, if it does not
+             * turn into a FAIL state). */
+            if (delay < server.cluster.node_timeout)
+                node->flags &= ~REDIS_NODE_PFAIL;
+        } else {
+            if (delay >= server.cluster.node_timeout) {
+                redisLog(REDIS_DEBUG,"*** NODE %.40s possibly failing",
+                    node->name);
+                node->flags |= REDIS_NODE_PFAIL;
+            }
+        }
+    }
+    dictReleaseIterator(di);
+}
+
+/* -----------------------------------------------------------------------------
+ * Slots management
+ * -------------------------------------------------------------------------- */
+
+/* Set the slot bit and return the old value. */
+int clusterNodeSetSlotBit(clusterNode *n, int slot) {
+    off_t byte = slot/8;
+    int bit = slot&7;
+    int old = (n->slots[byte] & (1<<bit)) != 0;
+    n->slots[byte] |= 1<<bit;
+    return old;
+}
+
+/* Clear the slot bit and return the old value. */
+int clusterNodeClearSlotBit(clusterNode *n, int slot) {
+    off_t byte = slot/8;
+    int bit = slot&7;
+    int old = (n->slots[byte] & (1<<bit)) != 0;
+    n->slots[byte] &= ~(1<<bit);
+    return old;
+}
+
+/* Return the slot bit from the cluster node structure. */
+int clusterNodeGetSlotBit(clusterNode *n, int slot) {
+    off_t byte = slot/8;
+    int bit = slot&7;
+    return (n->slots[byte] & (1<<bit)) != 0;
+}
+
+/* Add the specified slot to the list of slots that node 'n' will
+ * serve. Return REDIS_OK if the operation ended with success.
+ * If the slot is already assigned to another instance this is considered
+ * an error and REDIS_ERR is returned. */
+int clusterAddSlot(clusterNode *n, int slot) {
+    redisAssert(clusterNodeSetSlotBit(n,slot) == 0);
+    server.cluster.slots[slot] = server.cluster.myself;
+    printf("SLOT %d added to %.40s\n", slot, n->name);
+    return REDIS_OK;
+}
+
+/* -----------------------------------------------------------------------------
+ * Cluster state evaluation function
+ * -------------------------------------------------------------------------- */
+void clusterUpdateState(void) {
+    int ok = 1;
+    int j;
+
+    for (j = 0; j < REDIS_CLUSTER_SLOTS; j++) {
+        if (server.cluster.slots[j] == NULL ||
+            server.cluster.slots[j]->flags & (REDIS_NODE_FAIL))
+        {
+            ok = 0;
+            break;
+        }
+    }
+    if (ok) {
+        if (server.cluster.state == REDIS_CLUSTER_NEEDHELP) {
+            server.cluster.state = REDIS_CLUSTER_NEEDHELP;
+        } else {
+            server.cluster.state = REDIS_CLUSTER_OK;
+        }
+    } else {
+        server.cluster.state = REDIS_CLUSTER_FAIL;
+    }
+}
+
+/* -----------------------------------------------------------------------------
+ * CLUSTER command
+ * -------------------------------------------------------------------------- */
+
+void clusterCommand(redisClient *c) {
+    if (server.cluster_enabled == 0) {
+        addReplyError(c,"This instance has cluster support disabled");
+        return;
+    }
+
+    if (!strcasecmp(c->argv[1]->ptr,"meet") && c->argc == 4) {
+        clusterNode *n;
+        struct sockaddr_in sa;
+        long port;
+
+        /* Perform sanity checks on IP/port */
+        if (inet_aton(c->argv[2]->ptr,&sa.sin_addr) == 0) {
+            addReplyError(c,"Invalid IP address in MEET");
+            return;
+        }
+        if (getLongFromObjectOrReply(c, c->argv[3], &port, NULL) != REDIS_OK ||
+                    port < 0 || port > (65535-REDIS_CLUSTER_PORT_INCR))
+        {
+            addReplyError(c,"Invalid TCP port specified");
+            return;
+        }
+
+        /* Finally add the node to the cluster with a random name, this 
+         * will get fixed in the first handshake (ping/pong). */
+        n = createClusterNode(NULL,REDIS_NODE_HANDSHAKE|REDIS_NODE_MEET);
+        strncpy(n->ip,inet_ntoa(sa.sin_addr),sizeof(n->ip));
+        n->port = port;
+        clusterAddNode(n);
+        addReply(c,shared.ok);
+    } else if (!strcasecmp(c->argv[1]->ptr,"nodes") && c->argc == 2) {
+        sds ci = sdsempty();
+        dictIterator *di;
+        dictEntry *de;
+        robj *o;
+
+        di = dictGetIterator(server.cluster.nodes);
+        while((de = dictNext(di)) != NULL) {
+            clusterNode *node = dictGetEntryVal(de);
+
+            /* Node coordinates */
+            ci = sdscatprintf(ci,"%.40s %s:%d ",
+                node->name,
+                node->ip,
+                node->port);
+
+            /* Flags */
+            if (node->flags == 0) ci = sdscat(ci,"noflags,");
+            if (node->flags & REDIS_NODE_MYSELF) ci = sdscat(ci,"myself,");
+            if (node->flags & REDIS_NODE_MASTER) ci = sdscat(ci,"master,");
+            if (node->flags & REDIS_NODE_SLAVE) ci = sdscat(ci,"slave,");
+            if (node->flags & REDIS_NODE_PFAIL) ci = sdscat(ci,"fail?,");
+            if (node->flags & REDIS_NODE_FAIL) ci = sdscat(ci,"fail,");
+            if (node->flags & REDIS_NODE_HANDSHAKE) ci =sdscat(ci,"handshake,");
+            if (node->flags & REDIS_NODE_NOADDR) ci = sdscat(ci,"noaddr,");
+            if (ci[sdslen(ci)-1] == ',') ci[sdslen(ci)-1] = ' ';
+
+            /* Slave of... or just "-" */
+            if (node->slaveof)
+                ci = sdscatprintf(ci,"%.40s ",node->slaveof->name);
+            else
+                ci = sdscatprintf(ci,"- ");
+
+            /* Latency from the POV of this node, link status */
+            ci = sdscatprintf(ci,"%ld %ld %s\n",
+                (long) node->ping_sent,
+                (long) node->pong_received,
+                node->link ? "connected" : "disconnected");
+        }
+        dictReleaseIterator(di);
+        o = createObject(REDIS_STRING,ci);
+        addReplyBulk(c,o);
+        decrRefCount(o);
+    } else if (!strcasecmp(c->argv[1]->ptr,"addslots") && c->argc >= 3) {
+        int j;
+        long long slot;
+        unsigned char *slots = zmalloc(REDIS_CLUSTER_SLOTS);
+
+        memset(slots,0,REDIS_CLUSTER_SLOTS);
+        /* Check that all the arguments are parsable and that all the
+         * slots are not already busy. */
+        for (j = 2; j < c->argc; j++) {
+            if (getLongLongFromObject(c->argv[j],&slot) != REDIS_OK ||
+                slot < 0 || slot > REDIS_CLUSTER_SLOTS)
+            {
+                addReplyError(c,"Invalid or out of range slot index");
+                zfree(slots);
+                return;
+            }
+            if (server.cluster.slots[slot]) {
+                addReplyErrorFormat(c,"Slot %lld is already busy", slot);
+                zfree(slots);
+                return;
+            }
+            if (slots[slot]++ == 1) {
+                addReplyErrorFormat(c,"Slot %d specified multiple times",
+                    (int)slot);
+                zfree(slots);
+                return;
+            }
+        }
+        for (j = 0; j < REDIS_CLUSTER_SLOTS; j++) {
+            if (slots[j]) {
+                int retval = clusterAddSlot(server.cluster.myself,j);
+                
+                redisAssert(retval == REDIS_OK);
+            }
+        }
+        zfree(slots);
+        clusterUpdateState();
+        addReply(c,shared.ok);
+    } else if (!strcasecmp(c->argv[1]->ptr,"info") && c->argc == 2) {
+        char *statestr[] = {"ok","fail","needhelp"};
+        int slots_assigned = 0, slots_ok = 0, slots_pfail = 0, slots_fail = 0;
+        int j;
+
+        for (j = 0; j < REDIS_CLUSTER_SLOTS; j++) {
+            clusterNode *n = server.cluster.slots[j];
+
+            if (n == NULL) continue;
+            slots_assigned++;
+            if (n->flags & REDIS_NODE_FAIL) {
+                slots_fail++;
+            } else if (n->flags & REDIS_NODE_PFAIL) {
+                slots_pfail++;
+            } else {
+                slots_ok++;
+            }
+        }
+
+        sds info = sdscatprintf(sdsempty(),
+            "cluster_state:%s\r\n"
+            "cluster_slots_assigned:%d\r\n"
+            "cluster_slots_ok:%d\r\n"
+            "cluster_slots_pfail:%d\r\n"
+            "cluster_slots_fail:%d\r\n"
+            , statestr[server.cluster.state],
+            slots_assigned,
+            slots_ok,
+            slots_pfail,
+            slots_fail
+        );
+        addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n",
+            (unsigned long)sdslen(info)));
+        addReplySds(c,info);
+        addReply(c,shared.crlf);
+    } else {
+        addReplyError(c,"Wrong CLUSTER subcommand or number of arguments");
+    }
+}
+
+/* -----------------------------------------------------------------------------
+ * RESTORE and MIGRATE commands
+ * -------------------------------------------------------------------------- */
+
+/* RESTORE key ttl serialized-value */
+void restoreCommand(redisClient *c) {
+    FILE *fp;
+    char buf[64];
+    robj *o;
+    unsigned char *data;
+    long ttl;
+
+    /* Make sure this key does not already exist here... */
+    if (dbExists(c->db,c->argv[1])) {
+        addReplyError(c,"Target key name is busy.");
+        return;
+    }
+
+    /* Check if the TTL value makes sense */
+    if (getLongFromObjectOrReply(c,c->argv[2],&ttl,NULL) != REDIS_OK) {
+        return;
+    } else if (ttl < 0) {
+        addReplyError(c,"Invalid TTL value, must be >= 0");
+        return;
+    }
+
+    /* rdbLoadObject() only works against file descriptors so we need to
+     * dump the serialized object into a file and reload. */
+    snprintf(buf,sizeof(buf),"redis-restore-%d.tmp",getpid());
+    fp = fopen(buf,"w+");
+    if (!fp) {
+        redisLog(REDIS_WARNING,"Can't open tmp file for RESTORE: %s",
+            strerror(errno));
+        addReplyErrorFormat(c,"RESTORE failed, tmp file creation error: %s",
+            strerror(errno));
+        return;
+    }
+    unlink(buf);
+
+    /* Write the actual data and rewind the file */
+    data = (unsigned char*) c->argv[3]->ptr;
+    if (fwrite(data+1,sdslen((sds)data)-1,1,fp) != 1) {
+        redisLog(REDIS_WARNING,"Can't write against tmp file for RESTORE: %s",
+            strerror(errno));
+        addReplyError(c,"RESTORE failed, tmp file I/O error.");
+        fclose(fp);
+        return;
+    }
+    rewind(fp);
+
+    /* Finally create the object from the serialized dump and
+     * store it at the specified key. */
+    o = rdbLoadObject(data[0],fp);
+    if (o == NULL) {
+        addReplyError(c,"Bad data format.");
+        fclose(fp);
+        return;
+    }
+    fclose(fp);
+
+    /* Create the key and set the TTL if any */
+    dbAdd(c->db,c->argv[1],o);
+    if (ttl) setExpire(c->db,c->argv[1],time(NULL)+ttl);
+    addReply(c,shared.ok);
+}
+
+/* MIGRATE host port key dbid timeout */
+void migrateCommand(redisClient *c) {
+    int fd;
+    long timeout;
+    long dbid;
+    char buf[64];
+    FILE *fp;
+    time_t ttl;
+    robj *o;
+    unsigned char type;
+    off_t payload_len;
+
+    /* Sanity check */
+    if (getLongFromObjectOrReply(c,c->argv[5],&timeout,NULL) != REDIS_OK)
+        return;
+    if (getLongFromObjectOrReply(c,c->argv[4],&dbid,NULL) != REDIS_OK)
+        return;
+    if (timeout <= 0) timeout = 1;
+
+    /* Check if the key is here. If not we reply with success as there is
+     * nothing to migrate (for instance the key expired in the meantime), but
+     * we include such information in the reply string. */
+    if ((o = lookupKeyRead(c->db,c->argv[3])) == NULL) {
+        addReplySds(c,sdsnew("+NOKEY"));
+        return;
+    }
+    
+    /* Connect */
+    fd = anetTcpNonBlockConnect(server.neterr,c->argv[1]->ptr,
+                atoi(c->argv[2]->ptr));
+    if (fd == -1) {
+        addReplyErrorFormat(c,"Can't connect to target node: %s",
+            server.neterr);
+        return;
+    }
+    if ((aeWait(fd,AE_WRITABLE,timeout*1000) & AE_WRITABLE) == 0) {
+        addReplyError(c,"Timeout connecting to the client");
+        return;
+    }
+
+    /* Create temp file */
+    snprintf(buf,sizeof(buf),"redis-migrate-%d.tmp",getpid());
+    fp = fopen(buf,"w+");
+    if (!fp) {
+        redisLog(REDIS_WARNING,"Can't open tmp file for MIGRATE: %s",
+            strerror(errno));
+        addReplyErrorFormat(c,"MIGRATE failed, tmp file creation error: %s.",
+            strerror(errno));
+        return;
+    }
+    unlink(buf);
+
+    /* Build the SELECT + RESTORE query writing it in our temp file. */
+    if (fwriteBulkCount(fp,'*',2) == 0) goto file_wr_err;
+    if (fwriteBulkString(fp,"SELECT",6) == 0) goto file_wr_err;
+    if (fwriteBulkLongLong(fp,dbid) == 0) goto file_wr_err;
+
+    ttl = getExpire(c->db,c->argv[3]);
+    type = o->type;
+    if (fwriteBulkCount(fp,'*',4) == 0) goto file_wr_err;
+    if (fwriteBulkString(fp,"RESTORE",7) == 0) goto file_wr_err;
+    if (fwriteBulkObject(fp,c->argv[3]) == 0) goto file_wr_err;
+    if (fwriteBulkLongLong(fp, (ttl == -1) ? 0 : ttl) == 0) goto file_wr_err;
+
+    /* Finally the last argument that is the serailized object payload
+     * in the form: <type><rdb-serailized-object>. */
+    payload_len = rdbSavedObjectLen(o);
+    if (fwriteBulkCount(fp,'$',payload_len+1) == 0) goto file_wr_err;
+    if (fwrite(&type,1,1,fp) == 0) goto file_wr_err;
+    if (rdbSaveObject(fp,o) == -1) goto file_wr_err;
+    if (fwrite("\r\n",2,1,fp) == 0) goto file_wr_err;
+
+    /* Tranfer the query to the other node */
+    rewind(fp);
+    {
+        char buf[4096];
+        size_t nread;
+
+        while ((nread = fread(buf,1,sizeof(buf),fp)) != 0) {
+            int nwritten;
+
+            nwritten = syncWrite(fd,buf,nread,timeout);
+            if (nwritten != (signed)nread) goto socket_wr_err;
+        }
+        if (ferror(fp)) goto file_rd_err;
+    }
+
+    /* Read back the reply */
+    {
+        char buf1[1024];
+        char buf2[1024];
+
+        /* Read the two replies */
+        if (syncReadLine(fd, buf1, sizeof(buf1), timeout) <= 0)
+            goto socket_rd_err;
+        if (syncReadLine(fd, buf2, sizeof(buf2), timeout) <= 0)
+                goto socket_rd_err;
+        if (buf1[0] == '-' || buf2[0] == '-') {
+            addReplyErrorFormat(c,"Target instance replied with error: %s",
+                (buf1[0] == '-') ? buf1+1 : buf2+1);
+        } else {
+            dbDelete(c->db,c->argv[3]);
+            addReply(c,shared.ok);
+        }
+    }
+    fclose(fp);
+    close(fd);
+    return;
+
+file_wr_err:
+    redisLog(REDIS_WARNING,"Can't write on tmp file for MIGRATE: %s",
+        strerror(errno));
+    addReplyErrorFormat(c,"MIGRATE failed, tmp file write error: %s.",
+        strerror(errno));
+    fclose(fp);
+    close(fd);
+
+file_rd_err:
+    redisLog(REDIS_WARNING,"Can't read from tmp file for MIGRATE: %s",
+        strerror(errno));
+    addReplyErrorFormat(c,"MIGRATE failed, tmp file read error: %s.",
+        strerror(errno));
+    fclose(fp);
+    close(fd);
+
+socket_wr_err:
+    redisLog(REDIS_NOTICE,"Can't write to target node for MIGRATE: %s",
+        strerror(errno));
+    addReplyErrorFormat(c,"MIGRATE failed, writing to target node: %s.",
+        strerror(errno));
+    fclose(fp);
+    close(fd);
+
+socket_rd_err:
+    redisLog(REDIS_NOTICE,"Can't read from target node for MIGRATE: %s",
+        strerror(errno));
+    addReplyErrorFormat(c,"MIGRATE failed, reading from target node: %s.",
+        strerror(errno));
+    fclose(fp);
+    close(fd);
+}
+
+/* -----------------------------------------------------------------------------
+ * Cluster functions related to serving / redirecting clients
+ * -------------------------------------------------------------------------- */
+
+/* Return the pointer to the cluster node that is able to serve the query
+ * as all the keys belong to hash slots for which the node is in charge.
+ *
+ * If keys in query spawn multiple nodes NULL is returned. */
+clusterNode *getNodeByQuery(redisClient *c, struct redisCommand *cmd, robj **argv, int argc, int *hashslot) {
+    clusterNode *n = NULL;
+    multiState *ms, _ms;
+    multiCmd mc;
+    int i;
+
+    /* We handle all the cases as if they were EXEC commands, so we have
+     * a common code path for everything */
+    if (cmd->proc == execCommand) {
+        /* If REDIS_MULTI flag is not set EXEC is just going to return an
+         * error. */
+        if (!(c->flags & REDIS_MULTI)) return server.cluster.myself;
+        ms = &c->mstate;
+    } else {
+        /* Create a fake Multi State structure, with just one command */
+        ms = &_ms;
+        _ms.commands = &mc;
+        _ms.count = 1;
+        mc.argv = argv;
+        mc.argc = argc;
+        mc.cmd = cmd;
+    }
+
+    for (i = 0; i < ms->count; i++) {
+        struct redisCommand *mcmd;
+        robj **margv;
+        int margc, *keyindex, numkeys, j;
+
+        mcmd = ms->commands[i].cmd;
+        margc = ms->commands[i].argc;
+        margv = ms->commands[i].argv;
+
+        keyindex = getKeysFromCommand(mcmd,margv,margc,&numkeys,
+                                      REDIS_GETKEYS_PRELOAD);
+        for (j = 0; j < numkeys; j++) {
+            int slot = keyHashSlot((char*)margv[keyindex[j]]->ptr,
+                sdslen(margv[keyindex[j]]->ptr));
+            struct clusterNode *slotnode;
+
+            slotnode = server.cluster.slots[slot];
+            if (hashslot) *hashslot = slot;
+            /* Node not assigned? (Should never happen actually
+             * if we reached this function).
+             * Different node than the previous one?
+             * Return NULL, the cluster can't serve multi-node requests */
+            if (slotnode == NULL || (n && slotnode != n)) {
+                getKeysFreeResult(keyindex);
+                return NULL;
+            } else {
+                n = slotnode;
+            }
+        }
+        getKeysFreeResult(keyindex);
+    }
+    return (n == NULL) ? server.cluster.myself : n;
+}
diff --git a/src/config.c b/src/config.c
index e0bf1574..e40fdeda 100644
--- a/src/config.c
+++ b/src/config.c
@@ -285,6 +285,10 @@ void loadServerConfig(char *filename) {
                     err = "Target command name already exists"; goto loaderr;
                 }
             }
+        } else if (!strcasecmp(argv[0],"cluster-enabled") && argc == 2) {
+            if ((server.cluster_enabled = yesnotoi(argv[1])) == -1) {
+                err = "argument must be 'yes' or 'no'"; goto loaderr;
+            }
         } else {
             err = "Bad directive or wrong number of arguments"; goto loaderr;
         }
diff --git a/src/crc16.c b/src/crc16.c
new file mode 100644
index 00000000..37fb4ca7
--- /dev/null
+++ b/src/crc16.c
@@ -0,0 +1,74 @@
+#include "redis.h"
+
+/*      
+ * Copyright 2001-2010 Georges Menie (www.menie.org)
+ * Copyright 2010 Salvatore Sanfilippo (adapted to Redis coding style)
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the University of California, Berkeley nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* CRC16 implementation acording to CCITT standards */
+
+static const uint16_t crc16tab[256]= {
+    0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
+    0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
+    0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,0x72f7,0x62d6,
+    0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de,
+    0x2462,0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485,
+    0xa56a,0xb54b,0x8528,0x9509,0xe5ee,0xf5cf,0xc5ac,0xd58d,
+    0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,0x46b4,
+    0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc,
+    0x48c4,0x58e5,0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823,
+    0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,0x9969,0xa90a,0xb92b,
+    0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12,
+    0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a,
+    0x6ca6,0x7c87,0x4ce4,0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41,
+    0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,0x8d68,0x9d49,
+    0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70,
+    0xff9f,0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78,
+    0x9188,0x81a9,0xb1ca,0xa1eb,0xd10c,0xc12d,0xf14e,0xe16f,
+    0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,0x6067,
+    0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e,
+    0x02b1,0x1290,0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256,
+    0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,0xe54f,0xd52c,0xc50d,
+    0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405,
+    0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c,
+    0x26d3,0x36f2,0x0691,0x16b0,0x6657,0x7676,0x4615,0x5634,
+    0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,0xb98a,0xa9ab,
+    0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3,
+    0xcb7d,0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a,
+    0x4a75,0x5a54,0x6a37,0x7a16,0x0af1,0x1ad0,0x2ab3,0x3a92,
+    0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,0x8dc9,
+    0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1,
+    0xef1f,0xff3e,0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8,
+    0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,0x3eb2,0x0ed1,0x1ef0
+};
+  
+uint16_t crc16(const char *buf, int len) {
+    int counter;
+    uint16_t crc = 0;
+    for (counter = 0; counter < len; counter++)
+            crc = (crc<<8) ^ crc16tab[((crc>>8) ^ *buf++)&0x00FF];
+    return crc;
+}
diff --git a/src/db.c b/src/db.c
index fea2f12e..85a22062 100644
--- a/src/db.c
+++ b/src/db.c
@@ -307,6 +307,10 @@ void existsCommand(redisClient *c) {
 void selectCommand(redisClient *c) {
     int id = atoi(c->argv[1]->ptr);
 
+    if (server.cluster_enabled) {
+        addReplyError(c,"SELECT is not allowed in cluster mode");
+        return;
+    }
     if (selectDb(c,id) == REDIS_ERR) {
         addReplyError(c,"invalid DB index");
     } else {
@@ -428,6 +432,11 @@ void moveCommand(redisClient *c) {
     redisDb *src, *dst;
     int srcid;
 
+    if (server.cluster_enabled) {
+        addReplyError(c,"MOVE is not allowed in cluster mode");
+        return;
+    }
+
     /* Obtain source and target DB pointers */
     src = c->db;
     srcid = c->db->id;
diff --git a/src/rdb.c b/src/rdb.c
index c9fb3e83..f14467d1 100644
--- a/src/rdb.c
+++ b/src/rdb.c
@@ -245,7 +245,7 @@ int rdbSaveDoubleValue(FILE *fp, double val) {
     return rdbWriteRaw(fp,buf,len);
 }
 
-/* Save a Redis object. */
+/* Save a Redis object. Returns -1 on error, 0 on success. */
 int rdbSaveObject(FILE *fp, robj *o) {
     int n, nwritten = 0;
 
diff --git a/src/redis-cli.c b/src/redis-cli.c
index 123231d4..1b23c0b1 100644
--- a/src/redis-cli.c
+++ b/src/redis-cli.c
@@ -394,15 +394,18 @@ static sds cliFormatReplyRaw(redisReply *r) {
     switch (r->type) {
     case REDIS_REPLY_NIL:
         /* Nothing... */
-    break;
+        break;
     case REDIS_REPLY_ERROR:
+        out = sdscatlen(out,r->str,r->len);
+        out = sdscatlen(out,"\n",1);
+        break;
     case REDIS_REPLY_STATUS:
     case REDIS_REPLY_STRING:
         out = sdscatlen(out,r->str,r->len);
-    break;
+        break;
     case REDIS_REPLY_INTEGER:
         out = sdscatprintf(out,"%lld",r->integer);
-    break;
+        break;
     case REDIS_REPLY_ARRAY:
         for (i = 0; i < r->elements; i++) {
             if (i > 0) out = sdscat(out,config.mb_delim);
@@ -410,7 +413,7 @@ static sds cliFormatReplyRaw(redisReply *r) {
             out = sdscatlen(out,tmp,sdslen(tmp));
             sdsfree(tmp);
         }
-    break;
+        break;
     default:
         fprintf(stderr,"Unknown reply type: %d\n", r->type);
         exit(1);
@@ -464,7 +467,15 @@ static int cliSendCommand(int argc, char **argv, int repeat) {
         return REDIS_OK;
     }
 
-    output_raw = !strcasecmp(command,"info");
+    output_raw = 0;
+    if (!strcasecmp(command,"info") ||
+        (argc == 2 && !strcasecmp(command,"cluster") &&
+                      (!strcasecmp(argv[1],"nodes") ||
+                       !strcasecmp(argv[1],"info"))))
+    {
+        output_raw = 1;
+    }
+
     if (!strcasecmp(command,"help") || !strcasecmp(command,"?")) {
         cliOutputHelp(--argc, ++argv);
         return REDIS_OK;
diff --git a/src/redis.c b/src/redis.c
index 19fd912c..25205752 100644
--- a/src/redis.c
+++ b/src/redis.c
@@ -187,7 +187,10 @@ struct redisCommand redisCommandTable[] = {
     {"punsubscribe",punsubscribeCommand,-1,0,NULL,0,0,0,0,0},
     {"publish",publishCommand,3,REDIS_CMD_FORCE_REPLICATION,NULL,0,0,0,0,0},
     {"watch",watchCommand,-2,0,noPreloadGetKeys,1,-1,1,0,0},
-    {"unwatch",unwatchCommand,1,0,NULL,0,0,0,0,0}
+    {"unwatch",unwatchCommand,1,0,NULL,0,0,0,0,0},
+    {"cluster",clusterCommand,-2,0,NULL,0,0,0,0,0},
+    {"restore",restoreCommand,3,0,NULL,0,0,0,0,0},
+    {"migrate",migrateCommand,6,0,NULL,0,0,0,0,0}
 };
 
 /*============================ Utility functions ============================ */
@@ -440,6 +443,17 @@ dictType keylistDictType = {
     dictListDestructor          /* val destructor */
 };
 
+/* Cluster nodes hash table, mapping nodes addresses 1.2.3.4:6379 to
+ * clusterNode structures. */
+dictType clusterNodesDictType = {
+    dictSdsHash,                /* hash function */
+    NULL,                       /* key dup */
+    NULL,                       /* val dup */
+    dictSdsKeyCompare,          /* key compare */
+    dictSdsDestructor,          /* key destructor */
+    NULL                        /* val destructor */
+};
+
 int htNeedsResize(dict *dict) {
     long long size, used;
 
@@ -669,6 +683,9 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
      * to detect transfer failures. */
     if (!(loops % 10)) replicationCron();
 
+    /* Run other sub-systems specific cron jobs */
+    if (server.cluster_enabled && !(loops % 10)) clusterCron();
+
     server.cronloops++;
     return 100;
 }
@@ -823,6 +840,7 @@ void initServerConfig() {
     server.set_max_intset_entries = REDIS_SET_MAX_INTSET_ENTRIES;
     server.shutdown_asap = 0;
     server.cache_flush_delay = 0;
+    server.cluster_enabled = 0;
 
     updateLRUClock();
     resetServerSaveParams();
@@ -945,6 +963,7 @@ void initServer() {
     }
 
     if (server.ds_enabled) dsInit();
+    if (server.cluster_enabled) clusterInit();
     srand(time(NULL)^getpid());
 }
 
@@ -1051,6 +1070,27 @@ int processCommand(redisClient *c) {
         return REDIS_OK;
     }
 
+    /* If cluster is enabled, redirect here */
+    if (server.cluster_enabled &&
+                !(cmd->getkeys_proc == NULL && cmd->firstkey == 0)) {
+        int hashslot;
+
+        if (server.cluster.state != REDIS_CLUSTER_OK) {
+            addReplyError(c,"The cluster is down. Check with CLUSTER INFO for more information");
+            return REDIS_OK;
+        } else {
+            clusterNode *n = getNodeByQuery(c,cmd,c->argv,c->argc,&hashslot);
+            if (n == NULL) {
+                addReplyError(c,"Invalid cross-node request");
+                return REDIS_OK;
+            } else if (n != server.cluster.myself) {
+                addReplySds(c,sdscatprintf(sdsempty(),
+                    "-MOVED %d %s:%d\r\n",hashslot,n->ip,n->port));
+                return REDIS_OK;
+            }
+        }
+    }
+
     /* Handle the maxmemory directive.
      *
      * First we try to free some memory if possible (if there are volatile
diff --git a/src/redis.h b/src/redis.h
index b5188330..0ddd4730 100644
--- a/src/redis.h
+++ b/src/redis.h
@@ -18,6 +18,7 @@
 #include <inttypes.h>
 #include <pthread.h>
 #include <syslog.h>
+#include <netinet/in.h>
 
 #include "ae.h"     /* Event driven programming library */
 #include "sds.h"    /* Dynamic safe strings */
@@ -360,7 +361,123 @@ struct sharedObjectsStruct {
     *integers[REDIS_SHARED_INTEGERS];
 };
 
-/* Global server state structure */
+/*-----------------------------------------------------------------------------
+ * Redis cluster data structures
+ *----------------------------------------------------------------------------*/
+
+#define REDIS_CLUSTER_SLOTS 4096
+#define REDIS_CLUSTER_OK 0          /* Everything looks ok */
+#define REDIS_CLUSTER_FAIL 1        /* The cluster can't work */
+#define REDIS_CLUSTER_NEEDHELP 2    /* The cluster works, but needs some help */
+#define REDIS_CLUSTER_NAMELEN 40    /* sha1 hex length */
+#define REDIS_CLUSTER_PORT_INCR 10000 /* Cluster port = baseport + PORT_INCR */
+
+struct clusterNode;
+
+/* clusterLink encapsulates everything needed to talk with a remote node. */
+typedef struct clusterLink {
+    int fd;                     /* TCP socket file descriptor */
+    sds sndbuf;                 /* Packet send buffer */
+    sds rcvbuf;                 /* Packet reception buffer */
+    struct clusterNode *node;   /* Node related to this link if any, or NULL */
+} clusterLink;
+
+/* Node flags */
+#define REDIS_NODE_MASTER 1     /* The node is a master */
+#define REDIS_NODE_SLAVE 2      /* The node is a slave */
+#define REDIS_NODE_PFAIL 4      /* Failure? Need acknowledge */
+#define REDIS_NODE_FAIL 8       /* The node is believed to be malfunctioning */
+#define REDIS_NODE_MYSELF 16    /* This node is myself */
+#define REDIS_NODE_HANDSHAKE 32 /* We have still to exchange the first ping */
+#define REDIS_NODE_NOADDR   64  /* We don't know the address of this node */
+#define REDIS_NODE_MEET 128     /* Send a MEET message to this node */
+#define REDIS_NODE_NULL_NAME "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+
+struct clusterNode {
+    char name[REDIS_CLUSTER_NAMELEN]; /* Node name, hex string, sha1-size */
+    int flags;      /* REDIS_NODE_... */
+    unsigned char slots[REDIS_CLUSTER_SLOTS/8]; /* slots handled by this node */
+    int numslaves;  /* Number of slave nodes, if this is a master */
+    struct clusterNode **slaves; /* pointers to slave nodes */
+    struct clusterNode *slaveof; /* pointer to the master node */
+    time_t ping_sent;       /* Unix time we sent latest ping */
+    time_t pong_received;   /* Unix time we received the pong */
+    char *configdigest;         /* Configuration digest of this node */
+    time_t configdigest_ts;     /* Configuration digest timestamp */
+    char ip[16];                /* Latest known IP address of this node */
+    int port;                   /* Latest known port of this node */
+    clusterLink *link;          /* TCP/IP link with this node */
+};
+typedef struct clusterNode clusterNode;
+
+typedef struct {
+    clusterNode *myself;  /* This node */
+    int state;            /* REDIS_CLUSTER_OK, REDIS_CLUSTER_FAIL, ... */
+    int node_timeout;
+    dict *nodes;          /* Hash table of name -> clusterNode structures */
+    clusterNode *migrating_slots_to[REDIS_CLUSTER_SLOTS];
+    clusterNode *importing_slots_from[REDIS_CLUSTER_SLOTS];
+    clusterNode *slots[REDIS_CLUSTER_SLOTS];
+} clusterState;
+
+/* Redis cluster messages header */
+
+/* Note that the PING, PONG and MEET messages are actually the same exact
+ * kind of packet. PONG is the reply to ping, in the extact format as a PING,
+ * while MEET is a special PING that forces the receiver to add the sender
+ * as a node (if it is not already in the list). */
+#define CLUSTERMSG_TYPE_PING 0          /* Ping */
+#define CLUSTERMSG_TYPE_PONG 1          /* Pong (reply to Ping) */
+#define CLUSTERMSG_TYPE_MEET 2          /* Meet "let's join" message */
+#define CLUSTERMSG_TYPE_FAIL 3          /* Mark node xxx as failing */
+
+/* Initially we don't know our "name", but we'll find it once we connect
+ * to the first node, using the getsockname() function. Then we'll use this
+ * address for all the next messages. */
+typedef struct {
+    char nodename[REDIS_CLUSTER_NAMELEN];
+    uint32_t ping_sent;
+    uint32_t pong_received;
+    char ip[16];    /* IP address last time it was seen */
+    uint16_t port;  /* port last time it was seen */
+    uint16_t flags;
+    uint32_t notused; /* for 64 bit alignment */
+} clusterMsgDataGossip;
+
+typedef struct {
+    char nodename[REDIS_CLUSTER_NAMELEN];
+} clusterMsgDataFail;
+
+union clusterMsgData {
+    /* PING, MEET and PONG */
+    struct {
+        /* Array of N clusterMsgDataGossip structures */
+        clusterMsgDataGossip gossip[1];
+    } ping;
+    /* FAIL */
+    struct {
+        clusterMsgDataFail about;
+    } fail;
+};
+
+typedef struct {
+    uint32_t totlen;    /* Total length of this message */
+    uint16_t type;      /* Message type */
+    uint16_t count;     /* Only used for some kind of messages. */
+    char sender[REDIS_CLUSTER_NAMELEN]; /* Name of the sender node */
+    unsigned char myslots[REDIS_CLUSTER_SLOTS/8];
+    char slaveof[REDIS_CLUSTER_NAMELEN];
+    char configdigest[32];
+    uint16_t port;      /* Sender TCP base port */
+    unsigned char state; /* Cluster state from the POV of the sender */
+    unsigned char notused[5]; /* Reserved for future use. For alignment. */
+    union clusterMsgData data;
+} clusterMsg;
+
+/*-----------------------------------------------------------------------------
+ * Global server state
+ *----------------------------------------------------------------------------*/
+
 struct redisServer {
     /* General */
     pthread_t mainthread;
@@ -373,6 +490,7 @@ struct redisServer {
     char *unixsocket;
     int ipfd;
     int sofd;
+    int cfd;
     list *clients;
     list *slaves, *monitors;
     char neterr[ANET_ERR_LEN];
@@ -499,6 +617,8 @@ struct redisServer {
     /* Misc */
     unsigned lruclock:22;        /* clock incrementing every minute, for LRU */
     unsigned lruclock_padding:10;
+    int cluster_enabled;
+    clusterState cluster;
 };
 
 typedef struct pubsubPattern {
@@ -633,6 +753,7 @@ extern struct redisServer server;
 extern struct sharedObjectsStruct shared;
 extern dictType setDictType;
 extern dictType zsetDictType;
+extern dictType clusterNodesDictType;
 extern double R_Zero, R_PosInf, R_NegInf, R_Nan;
 dictType hashDictType;
 
@@ -747,6 +868,7 @@ int fwriteBulkString(FILE *fp, char *s, unsigned long len);
 int fwriteBulkDouble(FILE *fp, double d);
 int fwriteBulkLongLong(FILE *fp, long long l);
 int fwriteBulkObject(FILE *fp, robj *obj);
+int fwriteBulkCount(FILE *fp, char prefix, int count);
 
 /* Replication */
 void replicationFeedSlaves(list *slaves, int dictid, robj **argv, int argc);
@@ -923,6 +1045,15 @@ int *noPreloadGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numke
 int *renameGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags);
 int *zunionInterGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags);
 
+/* Cluster */
+void clusterInit(void);
+unsigned short crc16(const char *buf, int len);
+unsigned int keyHashSlot(char *key, int keylen);
+clusterNode *createClusterNode(char *nodename, int flags);
+int clusterAddNode(clusterNode *node);
+void clusterCron(void);
+clusterNode *getNodeByQuery(redisClient *c, struct redisCommand *cmd, robj **argv, int argc, int *hashslot);
+
 /* Git SHA1 */
 char *redisGitSHA1(void);
 char *redisGitDirty(void);
@@ -1045,6 +1176,9 @@ void punsubscribeCommand(redisClient *c);
 void publishCommand(redisClient *c);
 void watchCommand(redisClient *c);
 void unwatchCommand(redisClient *c);
+void clusterCommand(redisClient *c);
+void restoreCommand(redisClient *c);
+void migrateCommand(redisClient *c);
 
 #if defined(__GNUC__)
 void *calloc(size_t count, size_t size) __attribute__ ((deprecated));
diff --git a/src/syncio.c b/src/syncio.c
index 28ac1811..3d0e0451 100644
--- a/src/syncio.c
+++ b/src/syncio.c
@@ -107,6 +107,7 @@ int syncReadLine(int fd, char *ptr, ssize_t size, int timeout) {
 int fwriteBulkString(FILE *fp, char *s, unsigned long len) {
     char cbuf[128];
     int clen;
+
     cbuf[0] = '$';
     clen = 1+ll2string(cbuf+1,sizeof(cbuf)-1,len);
     cbuf[clen++] = '\r';
@@ -117,6 +118,19 @@ int fwriteBulkString(FILE *fp, char *s, unsigned long len) {
     return 1;
 }
 
+/* Write a multi bulk count in the form "*<count>\r\n" */
+int fwriteBulkCount(FILE *fp, char prefix, int count) {
+    char cbuf[128];
+    int clen;
+
+    cbuf[0] = prefix;
+    clen = 1+ll2string(cbuf+1,sizeof(cbuf)-1,count);
+    cbuf[clen++] = '\r';
+    cbuf[clen++] = '\n';
+    if (fwrite(cbuf,clen,1,fp) == 0) return 0;
+    return 1;
+}
+
 /* Write a double value in bulk format $<count>\r\n<payload>\r\n */
 int fwriteBulkDouble(FILE *fp, double d) {
     char buf[128], dbuf[128];

From 143d0077ba07fba8d662092c309d51b99270e648 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 29 Mar 2011 17:52:02 +0200
Subject: [PATCH 27/38] CLUSTER file updated with warning

---
 CLUSTER | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/CLUSTER b/CLUSTER
index bfe5234a..0e836cb1 100644
--- a/CLUSTER
+++ b/CLUSTER
@@ -1,5 +1,9 @@
 TODO
 
+*** WARNING: all the following problably has some meaning only for
+*** me (antirez), most info are not updated, so please consider this file
+*** as a private TODO list / brainstorming.
+
 - disconnect FAIL clients after some pong idle time.
 
 ---------------------------------

From e6f0a7b237b19881d73b145960ed68202f4bde49 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 29 Mar 2011 18:02:34 +0200
Subject: [PATCH 28/38] todo list for a first cluster howto guide for early
 testers

---
 CLUSTER | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/CLUSTER b/CLUSTER
index 0e836cb1..be903711 100644
--- a/CLUSTER
+++ b/CLUSTER
@@ -1,4 +1,25 @@
+CLUSTER README
+==============
+
+Redis Cluster is currenty a work in progress, however there are a few things
+that you can do already with it to see how it works.
+
+The following guide show you how to setup a three nodes cluster and issue some
+basic command against it.
+
+... WORK IN PROGRESS ...
+
+1) Show MIGRATE
+2) Show CLUSTER MEET
+3) Show link status detection with CLUSTER NODES
+4) Show how to add slots with CLUSTER ADDSLOTS
+5) Show redirection
+6) Show cluster down
+
+... WORK IN PROGRESS ...
+
 TODO
+====
 
 *** WARNING: all the following problably has some meaning only for
 *** me (antirez), most info are not updated, so please consider this file

From c7c7cfbddca1325e600e5c0fd4cfcfde38cc0758 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 30 Mar 2011 14:58:19 +0200
Subject: [PATCH 29/38] cluster configuration saving

---
 src/cluster.c | 109 ++++++++++++++++++++++++++++++++------------------
 1 file changed, 71 insertions(+), 38 deletions(-)

diff --git a/src/cluster.c b/src/cluster.c
index aac52578..b3fcd1ea 100644
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -1,6 +1,8 @@
 #include "redis.h"
 
 #include <arpa/inet.h>
+#include <fcntl.h>
+#include <unistd.h>
 
 void clusterAcceptHandler(aeEventLoop *el, int fd, void *privdata, int mask);
 void clusterReadHandler(aeEventLoop *el, int fd, void *privdata, int mask);
@@ -8,6 +10,7 @@ void clusterSendPing(clusterLink *link, int type);
 void clusterSendFail(char *nodename);
 void clusterUpdateState(void);
 int clusterNodeGetSlotBit(clusterNode *n, int slot);
+sds clusterGenNodesDescription(void);
 
 /* -----------------------------------------------------------------------------
  * Initialization
@@ -31,7 +34,8 @@ void clusterGetRandomName(char *p) {
 
 int clusterLoadConfig(char *filename) {
     FILE *fp = fopen(filename,"r");
-    
+   
+    return REDIS_ERR;
     if (fp == NULL) return REDIS_ERR;
     fclose(fp);
 
@@ -45,6 +49,25 @@ fmterr:
     exit(1);
 }
 
+/* Cluster node configuration is exactly the same as CLUSTER NODES output.
+ *
+ * This function writes the node config and returns 0, on error -1
+ * is returned. */
+int clusterSaveConfig(char *filename) {
+    sds ci = clusterGenNodesDescription();
+    int fd;
+    
+    if ((fd = open(filename,O_WRONLY|O_CREAT,0644)) == -1) goto err;
+    if (write(fd,ci,sdslen(ci)) != (ssize_t)sdslen(ci)) goto err;
+    close(fd);
+    sdsfree(ci);
+    return 0;
+
+err:
+    sdsfree(ci);
+    return -1;
+}
+
 void clusterInit(void) {
     server.cluster.myself = createClusterNode(NULL,REDIS_NODE_MYSELF);
     server.cluster.state = REDIS_CLUSTER_FAIL;
@@ -61,6 +84,10 @@ void clusterInit(void) {
          * by the createClusterNode() function. */
         redisLog(REDIS_NOTICE,"No cluster configuration found, I'm %.40s",
             server.cluster.myself->name);
+        if (clusterSaveConfig("cluster.conf") == -1) {
+            redisLog(REDIS_WARNING,"Fatal: can't update cluster config file.");
+            exit(1);
+        }
     }
     clusterAddNode(server.cluster.myself);
     /* We need a listening TCP port for our cluster messaging needs */
@@ -874,6 +901,48 @@ void clusterUpdateState(void) {
  * CLUSTER command
  * -------------------------------------------------------------------------- */
 
+sds clusterGenNodesDescription(void) {
+    sds ci = sdsempty();
+    dictIterator *di;
+    dictEntry *de;
+
+    di = dictGetIterator(server.cluster.nodes);
+    while((de = dictNext(di)) != NULL) {
+        clusterNode *node = dictGetEntryVal(de);
+
+        /* Node coordinates */
+        ci = sdscatprintf(ci,"%.40s %s:%d ",
+            node->name,
+            node->ip,
+            node->port);
+
+        /* Flags */
+        if (node->flags == 0) ci = sdscat(ci,"noflags,");
+        if (node->flags & REDIS_NODE_MYSELF) ci = sdscat(ci,"myself,");
+        if (node->flags & REDIS_NODE_MASTER) ci = sdscat(ci,"master,");
+        if (node->flags & REDIS_NODE_SLAVE) ci = sdscat(ci,"slave,");
+        if (node->flags & REDIS_NODE_PFAIL) ci = sdscat(ci,"fail?,");
+        if (node->flags & REDIS_NODE_FAIL) ci = sdscat(ci,"fail,");
+        if (node->flags & REDIS_NODE_HANDSHAKE) ci =sdscat(ci,"handshake,");
+        if (node->flags & REDIS_NODE_NOADDR) ci = sdscat(ci,"noaddr,");
+        if (ci[sdslen(ci)-1] == ',') ci[sdslen(ci)-1] = ' ';
+
+        /* Slave of... or just "-" */
+        if (node->slaveof)
+            ci = sdscatprintf(ci,"%.40s ",node->slaveof->name);
+        else
+            ci = sdscatprintf(ci,"- ");
+
+        /* Latency from the POV of this node, link status */
+        ci = sdscatprintf(ci,"%ld %ld %s\n",
+            (long) node->ping_sent,
+            (long) node->pong_received,
+            node->link ? "connected" : "disconnected");
+    }
+    dictReleaseIterator(di);
+    return ci;
+}
+
 void clusterCommand(redisClient *c) {
     if (server.cluster_enabled == 0) {
         addReplyError(c,"This instance has cluster support disabled");
@@ -905,45 +974,9 @@ void clusterCommand(redisClient *c) {
         clusterAddNode(n);
         addReply(c,shared.ok);
     } else if (!strcasecmp(c->argv[1]->ptr,"nodes") && c->argc == 2) {
-        sds ci = sdsempty();
-        dictIterator *di;
-        dictEntry *de;
         robj *o;
+        sds ci = clusterGenNodesDescription();
 
-        di = dictGetIterator(server.cluster.nodes);
-        while((de = dictNext(di)) != NULL) {
-            clusterNode *node = dictGetEntryVal(de);
-
-            /* Node coordinates */
-            ci = sdscatprintf(ci,"%.40s %s:%d ",
-                node->name,
-                node->ip,
-                node->port);
-
-            /* Flags */
-            if (node->flags == 0) ci = sdscat(ci,"noflags,");
-            if (node->flags & REDIS_NODE_MYSELF) ci = sdscat(ci,"myself,");
-            if (node->flags & REDIS_NODE_MASTER) ci = sdscat(ci,"master,");
-            if (node->flags & REDIS_NODE_SLAVE) ci = sdscat(ci,"slave,");
-            if (node->flags & REDIS_NODE_PFAIL) ci = sdscat(ci,"fail?,");
-            if (node->flags & REDIS_NODE_FAIL) ci = sdscat(ci,"fail,");
-            if (node->flags & REDIS_NODE_HANDSHAKE) ci =sdscat(ci,"handshake,");
-            if (node->flags & REDIS_NODE_NOADDR) ci = sdscat(ci,"noaddr,");
-            if (ci[sdslen(ci)-1] == ',') ci[sdslen(ci)-1] = ' ';
-
-            /* Slave of... or just "-" */
-            if (node->slaveof)
-                ci = sdscatprintf(ci,"%.40s ",node->slaveof->name);
-            else
-                ci = sdscatprintf(ci,"- ");
-
-            /* Latency from the POV of this node, link status */
-            ci = sdscatprintf(ci,"%ld %ld %s\n",
-                (long) node->ping_sent,
-                (long) node->pong_received,
-                node->link ? "connected" : "disconnected");
-        }
-        dictReleaseIterator(di);
         o = createObject(REDIS_STRING,ci);
         addReplyBulk(c,o);
         decrRefCount(o);

From 4b72c5617f1b9a53daad5bb58bfc7faf05c8169a Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 30 Mar 2011 16:51:28 +0200
Subject: [PATCH 30/38] fix to configuration saving on first start

---
 src/cluster.c | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/cluster.c b/src/cluster.c
index b3fcd1ea..1ffe0cdc 100644
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -44,7 +44,7 @@ int clusterLoadConfig(char *filename) {
     return REDIS_OK;
 
 fmterr:
-    redisLog(REDIS_WARNING,"Unrecovarable error: corrupted cluster.conf file.");
+    redisLog(REDIS_WARNING,"Unrecovarable error: corrupted redis-cluster.conf file.");
     fclose(fp);
     exit(1);
 }
@@ -69,6 +69,8 @@ err:
 }
 
 void clusterInit(void) {
+    int saveconf = 0;
+
     server.cluster.myself = createClusterNode(NULL,REDIS_NODE_MYSELF);
     server.cluster.state = REDIS_CLUSTER_FAIL;
     server.cluster.nodes = dictCreate(&clusterNodesDictType,NULL);
@@ -79,17 +81,20 @@ void clusterInit(void) {
         sizeof(server.cluster.importing_slots_from));
     memset(server.cluster.slots,0,
         sizeof(server.cluster.slots));
-    if (clusterLoadConfig("cluster.conf") == REDIS_ERR) {
+    if (clusterLoadConfig("redis-cluster.conf") == REDIS_ERR) {
         /* No configuration found. We will just use the random name provided
          * by the createClusterNode() function. */
         redisLog(REDIS_NOTICE,"No cluster configuration found, I'm %.40s",
             server.cluster.myself->name);
-        if (clusterSaveConfig("cluster.conf") == -1) {
+        saveconf = 1;
+    }
+    clusterAddNode(server.cluster.myself);
+    if (saveconf) {
+        if (clusterSaveConfig("redis-cluster.conf") == -1) {
             redisLog(REDIS_WARNING,"Fatal: can't update cluster config file.");
             exit(1);
         }
     }
-    clusterAddNode(server.cluster.myself);
     /* We need a listening TCP port for our cluster messaging needs */
     server.cfd = anetTcpServer(server.neterr,
             server.port+REDIS_CLUSTER_PORT_INCR, server.bindaddr);

From ef21ab960e061e84ee0e8ba81900750e32179215 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 30 Mar 2011 17:41:13 +0200
Subject: [PATCH 31/38] centralized cluster config file name. Assigned slots in
 CLUSTER NODES output and in cluster config file.

---
 src/cluster.c | 47 ++++++++++++++++++++++++++++++++++++-----------
 src/redis.c   |  1 +
 src/redis.h   |  1 +
 3 files changed, 38 insertions(+), 11 deletions(-)

diff --git a/src/cluster.c b/src/cluster.c
index 1ffe0cdc..225fcc54 100644
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -44,7 +44,7 @@ int clusterLoadConfig(char *filename) {
     return REDIS_OK;
 
 fmterr:
-    redisLog(REDIS_WARNING,"Unrecovarable error: corrupted redis-cluster.conf file.");
+    redisLog(REDIS_WARNING,"Unrecovarable error: corrupted cluster config file.");
     fclose(fp);
     exit(1);
 }
@@ -53,11 +53,12 @@ fmterr:
  *
  * This function writes the node config and returns 0, on error -1
  * is returned. */
-int clusterSaveConfig(char *filename) {
+int clusterSaveConfig(void) {
     sds ci = clusterGenNodesDescription();
     int fd;
     
-    if ((fd = open(filename,O_WRONLY|O_CREAT,0644)) == -1) goto err;
+    if ((fd = open(server.cluster.configfile,O_WRONLY|O_CREAT,0644)) == -1)
+        goto err;
     if (write(fd,ci,sdslen(ci)) != (ssize_t)sdslen(ci)) goto err;
     close(fd);
     sdsfree(ci);
@@ -68,6 +69,13 @@ err:
     return -1;
 }
 
+void clusterSaveConfigOrDie(void) {
+    if (clusterSaveConfig() == -1) {
+        redisLog(REDIS_WARNING,"Fatal: can't update cluster config file.");
+        exit(1);
+    }
+}
+
 void clusterInit(void) {
     int saveconf = 0;
 
@@ -81,7 +89,7 @@ void clusterInit(void) {
         sizeof(server.cluster.importing_slots_from));
     memset(server.cluster.slots,0,
         sizeof(server.cluster.slots));
-    if (clusterLoadConfig("redis-cluster.conf") == REDIS_ERR) {
+    if (clusterLoadConfig(server.cluster.configfile) == REDIS_ERR) {
         /* No configuration found. We will just use the random name provided
          * by the createClusterNode() function. */
         redisLog(REDIS_NOTICE,"No cluster configuration found, I'm %.40s",
@@ -89,12 +97,7 @@ void clusterInit(void) {
         saveconf = 1;
     }
     clusterAddNode(server.cluster.myself);
-    if (saveconf) {
-        if (clusterSaveConfig("redis-cluster.conf") == -1) {
-            redisLog(REDIS_WARNING,"Fatal: can't update cluster config file.");
-            exit(1);
-        }
-    }
+    if (saveconf) clusterSaveConfigOrDie();
     /* We need a listening TCP port for our cluster messaging needs */
     server.cfd = anetTcpServer(server.neterr,
             server.port+REDIS_CLUSTER_PORT_INCR, server.bindaddr);
@@ -910,6 +913,7 @@ sds clusterGenNodesDescription(void) {
     sds ci = sdsempty();
     dictIterator *di;
     dictEntry *de;
+    int j, start;
 
     di = dictGetIterator(server.cluster.nodes);
     while((de = dictNext(di)) != NULL) {
@@ -939,11 +943,32 @@ sds clusterGenNodesDescription(void) {
             ci = sdscatprintf(ci,"- ");
 
         /* Latency from the POV of this node, link status */
-        ci = sdscatprintf(ci,"%ld %ld %s\n",
+        ci = sdscatprintf(ci,"%ld %ld %s",
             (long) node->ping_sent,
             (long) node->pong_received,
             node->link ? "connected" : "disconnected");
+
+        /* Slots served by this instance */
+        start = -1;
+        for (j = 0; j < REDIS_CLUSTER_SLOTS; j++) {
+            int bit;
+
+            if ((bit = clusterNodeGetSlotBit(node,j)) != 0) {
+                if (start == -1) start = j;
+            }
+            if (start != -1 && (!bit || j == REDIS_CLUSTER_SLOTS-1)) {
+                if (j == REDIS_CLUSTER_SLOTS-1) j++;
+
+                if (start == j-1) {
+                    ci = sdscatprintf(ci," %d",start);
+                } else {
+                    ci = sdscatprintf(ci," %d-%d",start,j-1);
+                }
+                start = -1;
+            }
+        }
     }
+    ci = sdscatlen(ci,"\n",1);
     dictReleaseIterator(di);
     return ci;
 }
diff --git a/src/redis.c b/src/redis.c
index 25205752..8b8c49eb 100644
--- a/src/redis.c
+++ b/src/redis.c
@@ -841,6 +841,7 @@ void initServerConfig() {
     server.shutdown_asap = 0;
     server.cache_flush_delay = 0;
     server.cluster_enabled = 0;
+    server.cluster.configfile = zstrdup("nodes.conf");
 
     updateLRUClock();
     resetServerSaveParams();
diff --git a/src/redis.h b/src/redis.h
index 0ddd4730..5b403798 100644
--- a/src/redis.h
+++ b/src/redis.h
@@ -411,6 +411,7 @@ struct clusterNode {
 typedef struct clusterNode clusterNode;
 
 typedef struct {
+    char *configfile;
     clusterNode *myself;  /* This node */
     int state;            /* REDIS_CLUSTER_OK, REDIS_CLUSTER_FAIL, ... */
     int node_timeout;

From 6c390c0b2303247c16f42160fec3fd609cb99cb7 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 30 Mar 2011 18:12:51 +0200
Subject: [PATCH 32/38] minor change with no actual effects til the loading
 node config code is in place

---
 src/cluster.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cluster.c b/src/cluster.c
index 225fcc54..76ea894d 100644
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -94,9 +94,9 @@ void clusterInit(void) {
          * by the createClusterNode() function. */
         redisLog(REDIS_NOTICE,"No cluster configuration found, I'm %.40s",
             server.cluster.myself->name);
+        clusterAddNode(server.cluster.myself);
         saveconf = 1;
     }
-    clusterAddNode(server.cluster.myself);
     if (saveconf) clusterSaveConfigOrDie();
     /* We need a listening TCP port for our cluster messaging needs */
     server.cfd = anetTcpServer(server.neterr,

From 25ef31920adad5c52a1f5dbe7fd307d4abec5862 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 31 Mar 2011 16:44:43 +0200
Subject: [PATCH 33/38] Fixed issue #503. MONITOR + QUIT could crash the
 server, there are actually other interactions that could have the same effect
 (for instance Pub/Sub).

---
 src/networking.c | 23 ++++++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/src/networking.c b/src/networking.c
index 166b44c9..7f42a4cb 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -60,9 +60,6 @@ redisClient *createClient(int fd) {
 /* Set the event loop to listen for write events on the client's socket.
  * Typically gets called every time a reply is built. */
 int _installWriteEvent(redisClient *c) {
-    /* When CLOSE_AFTER_REPLY is set, no more replies may be added! */
-    redisAssert(!(c->flags & REDIS_CLOSE_AFTER_REPLY));
-
     if (c->fd <= 0) return REDIS_ERR;
     if (c->bufpos == 0 && listLength(c->reply) == 0 &&
         (c->replstate == REDIS_REPL_NONE ||
@@ -88,9 +85,15 @@ robj *dupLastObjectIfNeeded(list *reply) {
     return listNodeValue(ln);
 }
 
+/* -----------------------------------------------------------------------------
+ * Low level functions to add more data to output buffers.
+ * -------------------------------------------------------------------------- */
+
 int _addReplyToBuffer(redisClient *c, char *s, size_t len) {
     size_t available = sizeof(c->buf)-c->bufpos;
 
+    if (c->flags & REDIS_CLOSE_AFTER_REPLY) return REDIS_OK;
+
     /* If there already are entries in the reply list, we cannot
      * add anything more to the static buffer. */
     if (listLength(c->reply) > 0) return REDIS_ERR;
@@ -105,6 +108,9 @@ int _addReplyToBuffer(redisClient *c, char *s, size_t len) {
 
 void _addReplyObjectToList(redisClient *c, robj *o) {
     robj *tail;
+
+    if (c->flags & REDIS_CLOSE_AFTER_REPLY) return;
+
     if (listLength(c->reply) == 0) {
         incrRefCount(o);
         listAddNodeTail(c->reply,o);
@@ -128,6 +134,9 @@ void _addReplyObjectToList(redisClient *c, robj *o) {
  * needed it will be free'd, otherwise it ends up in a robj. */
 void _addReplySdsToList(redisClient *c, sds s) {
     robj *tail;
+
+    if (c->flags & REDIS_CLOSE_AFTER_REPLY) return;
+
     if (listLength(c->reply) == 0) {
         listAddNodeTail(c->reply,createObject(REDIS_STRING,s));
     } else {
@@ -148,6 +157,9 @@ void _addReplySdsToList(redisClient *c, sds s) {
 
 void _addReplyStringToList(redisClient *c, char *s, size_t len) {
     robj *tail;
+
+    if (c->flags & REDIS_CLOSE_AFTER_REPLY) return;
+
     if (listLength(c->reply) == 0) {
         listAddNodeTail(c->reply,createStringObject(s,len));
     } else {
@@ -165,6 +177,11 @@ void _addReplyStringToList(redisClient *c, char *s, size_t len) {
     }
 }
 
+/* -----------------------------------------------------------------------------
+ * Higher level functions to queue data on the client output buffer.
+ * The following functions are the ones that commands implementations will call.
+ * -------------------------------------------------------------------------- */
+
 void addReply(redisClient *c, robj *obj) {
     if (_installWriteEvent(c) != REDIS_OK) return;
 

From 5b94b8ac5d10dded6bb79909c660fe8d3f3ba677 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Thu, 31 Mar 2011 19:52:15 +0200
Subject: [PATCH 34/38] fixed memory leak introduced with the previous commit.
 Many thanks to Pieter Noordhuis for spotting it in no time

---
 src/networking.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/networking.c b/src/networking.c
index 7f42a4cb..32c06306 100644
--- a/src/networking.c
+++ b/src/networking.c
@@ -135,7 +135,10 @@ void _addReplyObjectToList(redisClient *c, robj *o) {
 void _addReplySdsToList(redisClient *c, sds s) {
     robj *tail;
 
-    if (c->flags & REDIS_CLOSE_AFTER_REPLY) return;
+    if (c->flags & REDIS_CLOSE_AFTER_REPLY) {
+        sdsfree(s);
+        return;
+    }
 
     if (listLength(c->reply) == 0) {
         listAddNodeTail(c->reply,createObject(REDIS_STRING,s));

From 626f6b2d644b2458184edf9318f24ce95ba83532 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Fri, 1 Apr 2011 18:59:28 +0200
Subject: [PATCH 35/38] DUMP implemented, RESTORE and MIGRATE fixed. Use
 zcalloc() instead of zmalloc()+memset() in sds.c when a new string is created
 with NULL initialization pointer.

---
 src/cluster.c | 78 +++++++++++++++++++++++++++++++++++++++++++++++++++
 src/redis.c   |  5 ++--
 src/redis.h   |  1 +
 src/sds.c     | 12 ++++----
 4 files changed, 89 insertions(+), 7 deletions(-)

diff --git a/src/cluster.c b/src/cluster.c
index 76ea894d..b57dd48c 100644
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -1270,6 +1270,7 @@ file_wr_err:
         strerror(errno));
     fclose(fp);
     close(fd);
+    return;
 
 file_rd_err:
     redisLog(REDIS_WARNING,"Can't read from tmp file for MIGRATE: %s",
@@ -1278,6 +1279,7 @@ file_rd_err:
         strerror(errno));
     fclose(fp);
     close(fd);
+    return;
 
 socket_wr_err:
     redisLog(REDIS_NOTICE,"Can't write to target node for MIGRATE: %s",
@@ -1286,6 +1288,7 @@ socket_wr_err:
         strerror(errno));
     fclose(fp);
     close(fd);
+    return;
 
 socket_rd_err:
     redisLog(REDIS_NOTICE,"Can't read from target node for MIGRATE: %s",
@@ -1294,6 +1297,81 @@ socket_rd_err:
         strerror(errno));
     fclose(fp);
     close(fd);
+    return;
+}
+
+/* DUMP keyname
+ * DUMP is actually not used by Redis Cluster but it is the obvious
+ * complement of RESTORE and can be useful for different applications. */
+void dumpCommand(redisClient *c) {
+    char buf[64];
+    FILE *fp;
+    robj *o, *dumpobj;
+    sds dump = NULL;
+    off_t payload_len;
+    unsigned int type;
+
+    /* Check if the key is here. */
+    if ((o = lookupKeyRead(c->db,c->argv[1])) == NULL) {
+        addReply(c,shared.nullbulk);
+        return;
+    }
+    
+    /* Create temp file */
+    snprintf(buf,sizeof(buf),"redis-dump-%d.tmp",getpid());
+    fp = fopen(buf,"w+");
+    if (!fp) {
+        redisLog(REDIS_WARNING,"Can't open tmp file for MIGRATE: %s",
+            strerror(errno));
+        addReplyErrorFormat(c,"DUMP failed, tmp file creation error: %s.",
+            strerror(errno));
+        return;
+    }
+    unlink(buf);
+
+    /* Dump the serailized object and read it back in memory.
+     * We prefix it with a one byte containing the type ID.
+     * This is the serialization format understood by RESTORE. */
+    if (rdbSaveObject(fp,o) == -1) goto file_wr_err;
+    payload_len = ftello(fp);
+    if (fseeko(fp,0,SEEK_SET) == -1) goto file_rd_err;
+    dump = sdsnewlen(NULL,payload_len+1);
+    if (payload_len && fread(dump+1,payload_len,1,fp) != 1) goto file_rd_err;
+    fclose(fp);
+    type = o->type;
+    if (type == REDIS_LIST && o->encoding == REDIS_ENCODING_ZIPLIST)
+        type = REDIS_LIST_ZIPLIST;
+    else if (type == REDIS_HASH && o->encoding == REDIS_ENCODING_ZIPMAP)
+        type = REDIS_HASH_ZIPMAP;
+    else if (type == REDIS_SET && o->encoding == REDIS_ENCODING_INTSET)
+        type = REDIS_SET_INTSET;
+    else
+        type = o->type;
+    dump[0] = type;
+
+    /* Transfer to the client */
+    dumpobj = createObject(REDIS_STRING,dump);
+    addReplyBulk(c,dumpobj);
+    decrRefCount(dumpobj);
+    return;
+
+file_wr_err:
+    redisLog(REDIS_WARNING,"Can't write on tmp file for DUMP: %s",
+        strerror(errno));
+    addReplyErrorFormat(c,"DUMP failed, tmp file write error: %s.",
+        strerror(errno));
+    sdsfree(dump);
+    fclose(fp);
+    return;
+
+file_rd_err:
+    redisLog(REDIS_WARNING,"Can't read from tmp file for DUMP: %s",
+        strerror(errno));
+    addReplyErrorFormat(c,"DUMP failed, tmp file read error: %s.",
+        strerror(errno));
+    sdsfree(dump);
+    fclose(fp);
+    return;
 }
 
 /* -----------------------------------------------------------------------------
diff --git a/src/redis.c b/src/redis.c
index 8b8c49eb..1cc8cc75 100644
--- a/src/redis.c
+++ b/src/redis.c
@@ -189,8 +189,9 @@ struct redisCommand redisCommandTable[] = {
     {"watch",watchCommand,-2,0,noPreloadGetKeys,1,-1,1,0,0},
     {"unwatch",unwatchCommand,1,0,NULL,0,0,0,0,0},
     {"cluster",clusterCommand,-2,0,NULL,0,0,0,0,0},
-    {"restore",restoreCommand,3,0,NULL,0,0,0,0,0},
-    {"migrate",migrateCommand,6,0,NULL,0,0,0,0,0}
+    {"restore",restoreCommand,4,0,NULL,0,0,0,0,0},
+    {"migrate",migrateCommand,6,0,NULL,0,0,0,0,0},
+    {"dump",dumpCommand,2,0,NULL,0,0,0,0,0}
 };
 
 /*============================ Utility functions ============================ */
diff --git a/src/redis.h b/src/redis.h
index 5b403798..91a64ecf 100644
--- a/src/redis.h
+++ b/src/redis.h
@@ -1180,6 +1180,7 @@ void unwatchCommand(redisClient *c);
 void clusterCommand(redisClient *c);
 void restoreCommand(redisClient *c);
 void migrateCommand(redisClient *c);
+void dumpCommand(redisClient *c);
 
 #if defined(__GNUC__)
 void *calloc(size_t count, size_t size) __attribute__ ((deprecated));
diff --git a/src/sds.c b/src/sds.c
index 7cb43962..8c754099 100644
--- a/src/sds.c
+++ b/src/sds.c
@@ -51,7 +51,11 @@ static void sdsOomAbort(void) {
 sds sdsnewlen(const void *init, size_t initlen) {
     struct sdshdr *sh;
 
-    sh = zmalloc(sizeof(struct sdshdr)+initlen+1);
+    if (init) {
+        sh = zmalloc(sizeof(struct sdshdr)+initlen+1);
+    } else {
+        sh = zcalloc(sizeof(struct sdshdr)+initlen+1);
+    }
 #ifdef SDS_ABORT_ON_OOM
     if (sh == NULL) sdsOomAbort();
 #else
@@ -59,10 +63,8 @@ sds sdsnewlen(const void *init, size_t initlen) {
 #endif
     sh->len = initlen;
     sh->free = 0;
-    if (initlen) {
-        if (init) memcpy(sh->buf, init, initlen);
-        else memset(sh->buf,0,initlen);
-    }
+    if (initlen && init)
+        memcpy(sh->buf, init, initlen);
     sh->buf[initlen] = '\0';
     return (char*)sh->buf;
 }

From f797c7dc176c833e6aa412c557d7fedd59dc1124 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Tue, 5 Apr 2011 13:57:28 +0200
Subject: [PATCH 36/38] bad data on RESTORE can no longer crash the server but
 create a memory leak with some input string

---
 src/cluster.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/cluster.c b/src/cluster.c
index b57dd48c..783c658d 100644
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -1140,8 +1140,10 @@ void restoreCommand(redisClient *c) {
 
     /* Finally create the object from the serialized dump and
      * store it at the specified key. */
-    o = rdbLoadObject(data[0],fp);
-    if (o == NULL) {
+    if ((data[0] > 4 && data[0] < 9) ||
+         data[0] > 11 ||
+        (o = rdbLoadObject(data[0],fp)) == NULL)
+    {
         addReplyError(c,"Bad data format.");
         fclose(fp);
         return;

From ece74202bbb2ff6b97b407755d5b9206db82cb17 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 6 Apr 2011 12:19:45 +0200
Subject: [PATCH 37/38] OBJECT command implemented

---
 src/object.c | 39 +++++++++++++++++++++++++++++++++++++++
 src/redis.c  |  3 ++-
 src/redis.h  |  1 +
 3 files changed, 42 insertions(+), 1 deletion(-)

diff --git a/src/object.c b/src/object.c
index e6b02da8..4de9dbaa 100644
--- a/src/object.c
+++ b/src/object.c
@@ -416,3 +416,42 @@ unsigned long estimateObjectIdleTime(robj *o) {
                     REDIS_LRU_CLOCK_RESOLUTION;
     }
 }
+
+/* This is an helper function for the DEBUG command. We need to lookup keys
+ * without any modification of LRU or other parameters. */
+robj *objectCommandLookup(redisClient *c, robj *key) {
+    dictEntry *de;
+
+    if ((de = dictFind(c->db->dict,key->ptr)) == NULL) return NULL;
+    return (robj*) dictGetEntryVal(de);
+}
+
+robj *objectCommandLookupOrReply(redisClient *c, robj *key, robj *reply) {
+    robj *o = objectCommandLookup(c,key);
+
+    if (!o) addReply(c, reply);
+    return o;
+}
+
+/* Object command allows to inspect the internals of an Redis Object.
+ * Usage: OBJECT <verb> ... arguments ... */
+void objectCommand(redisClient *c) {
+    robj *o;
+
+    if (!strcasecmp(c->argv[1]->ptr,"refcount") && c->argc == 3) {
+        if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nullbulk))
+                == NULL) return;
+        addReplyLongLong(c,o->refcount);
+    } else if (!strcasecmp(c->argv[1]->ptr,"encoding") && c->argc == 3) {
+        if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nullbulk))
+                == NULL) return;
+        addReplyBulkCString(c,strEncoding(o->encoding));
+    } else if (!strcasecmp(c->argv[1]->ptr,"idletime") && c->argc == 3) {
+        if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nullbulk))
+                == NULL) return;
+        addReplyLongLong(c,estimateObjectIdleTime(o));
+    } else {
+        addReplyError(c,"Syntax error. Try OBJECT (refcount|encoding|idletime)");
+    }
+}
+
diff --git a/src/redis.c b/src/redis.c
index 1cc8cc75..9c726151 100644
--- a/src/redis.c
+++ b/src/redis.c
@@ -191,7 +191,8 @@ struct redisCommand redisCommandTable[] = {
     {"cluster",clusterCommand,-2,0,NULL,0,0,0,0,0},
     {"restore",restoreCommand,4,0,NULL,0,0,0,0,0},
     {"migrate",migrateCommand,6,0,NULL,0,0,0,0,0},
-    {"dump",dumpCommand,2,0,NULL,0,0,0,0,0}
+    {"dump",dumpCommand,2,0,NULL,0,0,0,0,0},
+    {"object",objectCommand,-2,0,NULL,0,0,0,0,0}
 };
 
 /*============================ Utility functions ============================ */
diff --git a/src/redis.h b/src/redis.h
index 91a64ecf..3ceffd42 100644
--- a/src/redis.h
+++ b/src/redis.h
@@ -1181,6 +1181,7 @@ void clusterCommand(redisClient *c);
 void restoreCommand(redisClient *c);
 void migrateCommand(redisClient *c);
 void dumpCommand(redisClient *c);
+void objectCommand(redisClient *c);
 
 #if defined(__GNUC__)
 void *calloc(size_t count, size_t size) __attribute__ ((deprecated));

From 0b7f6d0913f96f2fe8280afc681c6e0a65ca81c9 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Wed, 6 Apr 2011 15:36:10 +0200
Subject: [PATCH 38/38] make sure that OBJECT ENCODING returns skiplist for
 sorted sets, and not raw, so that once we will merge specially encoded sorted
 sets everything will make sense.

---
 src/object.c | 6 +++++-
 src/redis.h  | 1 +
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/object.c b/src/object.c
index 4de9dbaa..6a9b0214 100644
--- a/src/object.c
+++ b/src/object.c
@@ -93,10 +93,13 @@ robj *createHashObject(void) {
 
 robj *createZsetObject(void) {
     zset *zs = zmalloc(sizeof(*zs));
+    robj *o;
 
     zs->dict = dictCreate(&zsetDictType,NULL);
     zs->zsl = zslCreate();
-    return createObject(REDIS_ZSET,zs);
+    o = createObject(REDIS_ZSET,zs);
+    o->encoding = REDIS_ENCODING_SKIPLIST;
+    return o;
 }
 
 void freeStringObject(robj *o) {
@@ -402,6 +405,7 @@ char *strEncoding(int encoding) {
     case REDIS_ENCODING_LINKEDLIST: return "linkedlist";
     case REDIS_ENCODING_ZIPLIST: return "ziplist";
     case REDIS_ENCODING_INTSET: return "intset";
+    case REDIS_ENCODING_SKIPLIST: return "skiplist";
     default: return "unknown";
     }
 }
diff --git a/src/redis.h b/src/redis.h
index 3ceffd42..26f33451 100644
--- a/src/redis.h
+++ b/src/redis.h
@@ -86,6 +86,7 @@
 #define REDIS_ENCODING_LINKEDLIST 4 /* Encoded as regular linked list */
 #define REDIS_ENCODING_ZIPLIST 5 /* Encoded as ziplist */
 #define REDIS_ENCODING_INTSET 6  /* Encoded as intset */
+#define REDIS_ENCODING_SKIPLIST 7  /* Encoded as skiplist */
 
 /* Object types only used for dumping to disk */
 #define REDIS_EXPIRETIME 253