nutcracker 0.4.0.16 → 0.4.1.18

data/ext/nutcracker/src/nc_server.h

@@ -70,13 +70,12 @@ struct server {
     uint32_t           idx;           /* server index */
     struct server_pool *owner;        /* owner pool */
 
-    struct string      pname;         /* name:port:weight (ref in conf_server) */
-    struct string      name;          /* name (ref in conf_server) */
+    struct string      pname;         /* hostname:port:weight (ref in conf_server) */
+    struct string      name;          /* hostname:port or [name] (ref in conf_server) */
+    struct string      addrstr;       /* hostname (ref in conf_server) */
     uint16_t           port;          /* port */
     uint32_t           weight;        /* weight */
-    int                family;        /* socket family */
-    socklen_t          addrlen;       /* socket length */
-    struct sockaddr    *addr;         /* socket address (ref in conf_server) */
+    struct sockinfo    info;          /* server socket info */
 
     uint32_t           ns_conn_q;     /* # server connection */
     struct conn_tqh    s_conn_q;      /* server connection q */
@@ -101,21 +100,23 @@ struct server_pool {
     int64_t            next_rebuild;         /* next distribution rebuild time in usec */
 
     struct string      name;                 /* pool name (ref in conf_pool) */
-    struct string      addrstr;              /* pool address (ref in conf_pool) */
+    struct string      addrstr;              /* pool address - hostname:port (ref in conf_pool) */
     uint16_t           port;                 /* port */
-    int                family;               /* socket family */
-    socklen_t          addrlen;              /* socket length */
-    struct sockaddr    *addr;                /* socket address (ref in conf_pool) */
+    struct sockinfo    info;                 /* listen socket info */
+    mode_t             perm;                 /* socket permission */
     int                dist_type;            /* distribution type (dist_type_t) */
     int                key_hash_type;        /* key hash type (hash_type_t) */
     hash_t             key_hash;             /* key hasher */
     struct string      hash_tag;             /* key hash tag (ref in conf_pool) */
     int                timeout;              /* timeout in msec */
     int                backlog;              /* listen backlog */
+    int                redis_db;             /* redis database to connect to */
     uint32_t           client_connections;   /* maximum # client connection */
     uint32_t           server_connections;   /* maximum # server connection */
     int64_t            server_retry_timeout; /* server retry timeout in usec */
     uint32_t           server_failure_limit; /* server failure limit */
+    struct string      redis_auth;           /* redis_auth password (matches requirepass on redis) */
+    unsigned           require_auth;         /* require_auth? */
     unsigned           auto_eject_hosts:1;   /* auto_eject_hosts? */
     unsigned           preconnect:1;         /* preconnect? */
     unsigned           redis:1;              /* redis? */

data/ext/nutcracker/src/nc_string.h

@@ -77,12 +77,29 @@ int string_compare(const struct string *s1, const struct string *s2);
 #define nc_strndup(_s, _n)              \
     (uint8_t *)strndup((char *)(_s), (size_t)(_n));
 
+/*
+ * snprintf(s, n, ...) will write at most n - 1 of the characters printed into
+ * the output string; the nth character then gets the terminating `\0'; if
+ * the return value is greater than or equal to the n argument, the string
+ * was too short and some of the printed characters were discarded; the output
+ * is always null-terminated.
+ *
+ * Note that, the return value of snprintf() is always the number of characters
+ * that would be printed into the output string, assuming n were limited not
+ * including the trailing `\0' used to end output.
+ *
+ * scnprintf(s, n, ...) is same as snprintf() except, it returns the number
+ * of characters printed into the output string not including the trailing '\0'
+ */
 #define nc_snprintf(_s, _n, ...)        \
     snprintf((char *)(_s), (size_t)(_n), __VA_ARGS__)
 
 #define nc_scnprintf(_s, _n, ...)       \
     _scnprintf((char *)(_s), (size_t)(_n), __VA_ARGS__)
 
+#define nc_vsnprintf(_s, _n, _f, _a)    \
+    vsnprintf((char *)(_s), (size_t)(_n), _f, _a)
+
 #define nc_vscnprintf(_s, _n, _f, _a)   \
     _vscnprintf((char *)(_s), (size_t)(_n), _f, _a)
 

data/ext/nutcracker/src/nc_util.c

@@ -489,8 +489,12 @@ nc_resolve_inet(struct string *name, int port, struct sockinfo *si)
 
     nc_snprintf(service, NC_UINTMAX_MAXLEN, "%d", port);
 
+    /*
+     * getaddrinfo() returns zero on success or one of the error codes listed
+     * in gai_strerror(3) if an error occurs
+     */
     status = getaddrinfo(node, service, &hints, &ai);
-    if (status < 0) {
+    if (status != 0) {
         log_error("address resolution of node '%s' service '%s' failed: %s",
                   node, service, gai_strerror(status));
         return -1;

data/ext/nutcracker/src/proto/Makefile.in

@@ -1,7 +1,7 @@
-# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# Makefile.in generated by automake 1.15 from Makefile.am.
 # @configure_input@
 
-# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+# Copyright (C) 1994-2014 Free Software Foundation, Inc.
 
 # This Makefile.in is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -16,7 +16,17 @@
 
 
 VPATH = @srcdir@
-am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
 am__make_running_with_option = \
   case $${target_option-} in \
       ?) ;; \
@@ -80,8 +90,6 @@ POST_UNINSTALL = :
 build_triplet = @build@
 host_triplet = @host@
 subdir = src/proto
-DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
-	$(top_srcdir)/config/depcomp $(noinst_HEADERS)
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \
 	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
@@ -89,6 +97,8 @@ am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \
 	$(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
 	$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(noinst_HEADERS) \
+	$(am__DIST_COMMON)
 mkinstalldirs = $(install_sh) -d
 CONFIG_HEADER = $(top_builddir)/config.h
 CONFIG_CLEAN_FILES =
@@ -168,6 +178,7 @@ am__define_uniq_tagged_files = \
   done | $(am__uniquify_input)`
 ETAGS = etags
 CTAGS = ctags
+am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/config/depcomp
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
 AMTAR = @AMTAR@
@@ -212,6 +223,7 @@ LIBTOOL = @LIBTOOL@
 LIPO = @LIPO@
 LN_S = @LN_S@
 LTLIBOBJS = @LTLIBOBJS@
+LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 MAKEINFO = @MAKEINFO@
 MANIFEST_TOOL = @MANIFEST_TOOL@
 MKDIR_P = @MKDIR_P@
@@ -314,7 +326,6 @@ $(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
 	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/proto/Makefile'; \
 	$(am__cd) $(top_srcdir) && \
 	  $(AUTOMAKE) --foreign src/proto/Makefile
-.PRECIOUS: Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	@case '$?' in \
 	  *config.status*) \
@@ -581,6 +592,8 @@ uninstall-am:
 	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
 	tags tags-am uninstall uninstall-am
 
+.PRECIOUS: Makefile
+
 
 # Tell versions [3.59,3.63) of GNU make to not export all variables.
 # Otherwise a system limit (for SysV at least) may be exceeded.

data/ext/nutcracker/src/proto/nc_memcache.c

@@ -121,6 +121,20 @@ memcache_delete(struct msg *r)
     return false;
 }
 
+/*
+ * Return true, if the memcache command is a touch command, otherwise
+ * return false
+ */
+static bool
+memcache_touch(struct msg *r)
+{
+    if (r->type == MSG_REQ_MC_TOUCH) {
+        return true;
+    }
+
+    return false;
+}
+
 void
 memcache_parse_req(struct msg *r)
 {
@@ -243,6 +257,14 @@ memcache_parse_req(struct msg *r)
 
                     break;
 
+                case 5:
+                    if (str5cmp(m, 't', 'o', 'u', 'c', 'h')) {
+                      r->type = MSG_REQ_MC_TOUCH;
+                      break;
+                    }
+
+                    break;
+
                 case 6:
                     if (str6cmp(m, 'a', 'p', 'p', 'e', 'n', 'd')) {
                         r->type = MSG_REQ_MC_APPEND;
@@ -282,6 +304,7 @@ memcache_parse_req(struct msg *r)
                 case MSG_REQ_MC_PREPEND:
                 case MSG_REQ_MC_INCR:
                 case MSG_REQ_MC_DECR:
+                case MSG_REQ_MC_TOUCH:
                     if (ch == CR) {
                         goto error;
                     }
@@ -320,13 +343,17 @@ memcache_parse_req(struct msg *r)
             }
             if (ch == ' ' || ch == CR) {
                 struct keypos *kpos;
-
-                if ((p - r->token) > MEMCACHE_MAX_KEY_LENGTH) {
+                int keylen = p - r->token;
+                if (keylen > MEMCACHE_MAX_KEY_LENGTH) {
                     log_error("parsed bad req %"PRIu64" of type %d with key "
                               "prefix '%.*s...' and length %d that exceeds "
                               "maximum key length", r->id, r->type, 16,
                               r->token, p - r->token);
                     goto error;
+                } else if (keylen == 0) {
+                    log_error("parsed bad req %"PRIu64" of type %d with an "
+                              "empty key", r->id, r->type);
+                    goto error;
                 }
 
                 kpos = array_push(r->keys);
@@ -342,7 +369,7 @@ memcache_parse_req(struct msg *r)
                 /* get next state */
                 if (memcache_storage(r)) {
                     state = SW_SPACES_BEFORE_FLAGS;
-                } else if (memcache_arithmetic(r)) {
+                } else if (memcache_arithmetic(r) || memcache_touch(r) ) {
                     state = SW_SPACES_BEFORE_NUM;
                 } else if (memcache_delete(r)) {
                     state = SW_RUNTO_CRLF;
@@ -531,7 +558,7 @@ memcache_parse_req(struct msg *r)
 
         case SW_SPACES_BEFORE_NUM:
             if (ch != ' ') {
-                if (!isdigit(ch)) {
+                if (!(isdigit(ch) || ch == '-')) {
                     goto error;
                 }
                 /* num_start <- p; num <- ch - '0'  */
@@ -562,7 +589,7 @@ memcache_parse_req(struct msg *r)
                 break;
 
             case 'n':
-                if (memcache_storage(r) || memcache_arithmetic(r) || memcache_delete(r)) {
+                if (memcache_storage(r) || memcache_arithmetic(r) || memcache_delete(r) || memcache_touch(r)) {
                     /* noreply_start <- p */
                     r->token = p;
                     state = SW_NOREPLY;
@@ -593,7 +620,7 @@ memcache_parse_req(struct msg *r)
             case CR:
                 m = r->token;
                 if (((p - m) == 7) && str7cmp(m, 'n', 'o', 'r', 'e', 'p', 'l', 'y')) {
-                    ASSERT(memcache_storage(r) || memcache_arithmetic(r) || memcache_delete(r));
+                    ASSERT(memcache_storage(r) || memcache_arithmetic(r) || memcache_delete(r) || memcache_touch(r));
                     r->token = NULL;
                     /* noreply_end <- p - 1 */
                     r->noreply = 1;
@@ -854,6 +881,11 @@ memcache_parse_rsp(struct msg *r)
                         break;
                     }
 
+                    if (str7cmp(m, 'T', 'O', 'U', 'C', 'H', 'E', 'D')) {
+                        r->type = MSG_RSP_MC_TOUCHED;
+                        break;
+                    }
+
                     break;
 
                 case 9:
@@ -895,6 +927,7 @@ memcache_parse_rsp(struct msg *r)
                 case MSG_RSP_MC_EXISTS:
                 case MSG_RSP_MC_NOT_FOUND:
                 case MSG_RSP_MC_DELETED:
+                case MSG_RSP_MC_TOUCHED:
                     state = SW_CRLF;
                     break;
 
@@ -1167,6 +1200,12 @@ error:
                 r->state);
 }
 
+bool
+memcache_failure(struct msg *r)
+{
+    return false;
+}
+
 static rstatus_t
 memcache_append_key(struct msg *r, uint8_t *key, uint32_t keylen)
 {
@@ -1377,9 +1416,8 @@ memcache_pre_coalesce(struct msg *r)
 }
 
 /*
- * copy one response from src to dst
- * return bytes copied
- * */
+ * Copy one response from src to dst and return bytes copied
+ */
 static rstatus_t
 memcache_copy_bulk(struct msg *dst, struct msg *src)
 {
@@ -1403,9 +1441,10 @@ memcache_copy_bulk(struct msg *dst, struct msg *src)
     }
     p = mbuf->pos;
 
-    /* get : VALUE key 0 len\r\nval\r\n */
-    /* gets: VALUE key 0 len cas\r\nval\r\n */
-
+    /*
+     * get : VALUE key 0 len\r\nval\r\n
+     * gets: VALUE key 0 len cas\r\nval\r\n
+     */
     ASSERT(*p == 'V');
     for (i = 0; i < 3; i++) {                 /*  eat 'VALUE key 0 '  */
         for (; *p != ' ';) {
@@ -1495,3 +1534,28 @@ memcache_post_coalesce(struct msg *request)
         return;
     }
 }
+
+void
+memcache_post_connect(struct context *ctx, struct conn *conn, struct server *server)
+{
+}
+
+void
+memcache_swallow_msg(struct conn *conn, struct msg *pmsg, struct msg *msg)
+{
+}
+
+rstatus_t
+memcache_add_auth(struct context *ctx, struct conn *c_conn, struct conn *s_conn)
+{
+    NOT_REACHED();
+    return NC_OK;
+}
+
+rstatus_t
+memcache_reply(struct msg *r)
+{
+    NOT_REACHED();
+    return NC_OK;
+}
+

data/ext/nutcracker/src/proto/nc_proto.h

@@ -140,15 +140,24 @@
 
 void memcache_parse_req(struct msg *r);
 void memcache_parse_rsp(struct msg *r);
+bool memcache_failure(struct msg *r);
 void memcache_pre_coalesce(struct msg *r);
 void memcache_post_coalesce(struct msg *r);
+rstatus_t memcache_add_auth(struct context *ctx, struct conn *c_conn, struct conn *s_conn);
 rstatus_t memcache_fragment(struct msg *r, uint32_t ncontinuum, struct msg_tqh *frag_msgq);
+rstatus_t memcache_reply(struct msg *r);
+void memcache_post_connect(struct context *ctx, struct conn *conn, struct server *server);
+void memcache_swallow_msg(struct conn *conn, struct msg *pmsg, struct msg *msg);
 
 void redis_parse_req(struct msg *r);
 void redis_parse_rsp(struct msg *r);
+bool redis_failure(struct msg *r);
 void redis_pre_coalesce(struct msg *r);
 void redis_post_coalesce(struct msg *r);
+rstatus_t redis_add_auth(struct context *ctx, struct conn *c_conn, struct conn *s_conn);
 rstatus_t redis_fragment(struct msg *r, uint32_t ncontinuum, struct msg_tqh *frag_msgq);
 rstatus_t redis_reply(struct msg *r);
+void redis_post_connect(struct context *ctx, struct conn *conn, struct server *server);
+void redis_swallow_msg(struct conn *conn, struct msg *pmsg, struct msg *msg);
 
 #endif

data/ext/nutcracker/src/proto/nc_redis.c

@@ -17,10 +17,24 @@
 
 #include <stdio.h>
 #include <ctype.h>
+#include <math.h>
 
 #include <nc_core.h>
 #include <nc_proto.h>
 
+#define RSP_STRING(ACTION)                                                          \
+    ACTION( ok,               "+OK\r\n"                                           ) \
+    ACTION( pong,             "+PONG\r\n"                                         ) \
+    ACTION( invalid_password, "-ERR invalid password\r\n"                         ) \
+    ACTION( auth_required,    "-NOAUTH Authentication required\r\n"               ) \
+    ACTION( no_password,      "-ERR Client sent AUTH, but no password is set\r\n" ) \
+
+#define DEFINE_ACTION(_var, _str) static struct string rsp_##_var = string(_str);
+    RSP_STRING( DEFINE_ACTION )
+#undef DEFINE_ACTION
+
+static rstatus_t redis_handle_auth_req(struct msg *request, struct msg *response);
+
 /*
  * Return true, if the redis command take no key, otherwise
  * return false
@@ -51,7 +65,6 @@ redis_arg0(struct msg *r)
     case MSG_REQ_REDIS_EXISTS:
     case MSG_REQ_REDIS_PERSIST:
     case MSG_REQ_REDIS_PTTL:
-    case MSG_REQ_REDIS_SORT:
     case MSG_REQ_REDIS_TTL:
     case MSG_REQ_REDIS_TYPE:
     case MSG_REQ_REDIS_DUMP:
@@ -75,8 +88,8 @@ redis_arg0(struct msg *r)
     case MSG_REQ_REDIS_SPOP:
 
     case MSG_REQ_REDIS_ZCARD:
-
     case MSG_REQ_REDIS_PFCOUNT:
+    case MSG_REQ_REDIS_AUTH:
         return true;
 
     default:
@@ -198,6 +211,8 @@ static bool
 redis_argn(struct msg *r)
 {
     switch (r->type) {
+    case MSG_REQ_REDIS_SORT:
+
     case MSG_REQ_REDIS_BITCOUNT:
 
     case MSG_REQ_REDIS_SET:
@@ -300,6 +315,37 @@ redis_argeval(struct msg *r)
     return false;
 }
 
+/*
+ * Return true, if the redis response is an error response i.e. a simple
+ * string whose first character is '-', otherwise return false.
+ */
+static bool
+redis_error(struct msg *r)
+{
+    switch (r->type) {
+    case MSG_RSP_REDIS_ERROR:
+    case MSG_RSP_REDIS_ERROR_ERR:
+    case MSG_RSP_REDIS_ERROR_OOM:
+    case MSG_RSP_REDIS_ERROR_BUSY:
+    case MSG_RSP_REDIS_ERROR_NOAUTH:
+    case MSG_RSP_REDIS_ERROR_LOADING:
+    case MSG_RSP_REDIS_ERROR_BUSYKEY:
+    case MSG_RSP_REDIS_ERROR_MISCONF:
+    case MSG_RSP_REDIS_ERROR_NOSCRIPT:
+    case MSG_RSP_REDIS_ERROR_READONLY:
+    case MSG_RSP_REDIS_ERROR_WRONGTYPE:
+    case MSG_RSP_REDIS_ERROR_EXECABORT:
+    case MSG_RSP_REDIS_ERROR_MASTERDOWN:
+    case MSG_RSP_REDIS_ERROR_NOREPLICAS:
+        return true;
+
+    default:
+        break;
+    }
+
+    return false;
+}
+
 /*
  * Reference: http://redis.io/topics/protocol
  *
@@ -625,6 +671,12 @@ redis_parse_req(struct msg *r)
                     break;
                 }
 
+                if (str4icmp(m, 'a', 'u', 't', 'h')) {
+                    r->type = MSG_REQ_REDIS_AUTH;
+                    r->noforward = 1;
+                    break;
+                }
+
                 break;
 
             case 5:
@@ -1051,6 +1103,8 @@ redis_parse_req(struct msg *r)
             case LF:
                 if (redis_argz(r)) {
                     goto done;
+                } else if (r->narg == 1) {
+                    goto error;
                 } else if (redis_argeval(r)) {
                     state = SW_ARG1_LEN;
                 } else {
@@ -1074,11 +1128,6 @@ redis_parse_req(struct msg *r)
             } else if (isdigit(ch)) {
                 r->rlen = r->rlen * 10 + (uint32_t)(ch - '0');
             } else if (ch == CR) {
-                if (r->rlen == 0) {
-                    log_error("parsed bad req %"PRIu64" of type %d with empty "
-                              "key", r->id, r->type);
-                    goto error;
-                }
                 if (r->rlen >= mbuf_data_size()) {
                     log_error("parsed bad req %"PRIu64" of type %d with key "
                               "length %d that greater than or equal to maximum"
@@ -1178,8 +1227,8 @@ redis_parse_req(struct msg *r)
                     }
                     state = SW_KEY_LEN;
                 } else if (redis_argkvx(r)) {
-                    if (r->rnarg == 0) {
-                        goto done;
+                    if (r->narg % 2 == 0) {
+                        goto error;
                     }
                     state = SW_ARG1_LEN;
                 } else if (redis_argeval(r)) {
@@ -1672,6 +1721,7 @@ redis_parse_rsp(struct msg *r)
         SW_ERROR,
         SW_INTEGER,
         SW_INTEGER_START,
+        SW_SIMPLE,
         SW_BULK,
         SW_BULK_LF,
         SW_BULK_ARG,
@@ -1748,8 +1798,125 @@ redis_parse_rsp(struct msg *r)
             break;
 
         case SW_ERROR:
-            /* rsp_start <- p */
-            state = SW_RUNTO_CRLF;
+            if (r->token == NULL) {
+                if (ch != '-') {
+                    goto error;
+                }
+              /* rsp_start <- p */
+              r->token = p;
+            }
+            if (ch == ' ' || ch == CR) {
+                m = r->token;
+                r->token = NULL;
+                switch (p - m) {
+
+                case 4:
+                    /*
+                     * -ERR no such key\r\n
+                     * -ERR syntax error\r\n
+                     * -ERR source and destination objects are the same\r\n
+                     * -ERR index out of range\r\n
+                     */
+                    if (str4cmp(m, '-', 'E', 'R', 'R')) {
+                        r->type = MSG_RSP_REDIS_ERROR_ERR;
+                        break;
+                    }
+
+                    /* -OOM command not allowed when used memory > 'maxmemory'.\r\n */
+                    if (str4cmp(m, '-', 'O', 'O', 'M')) {
+                        r->type = MSG_RSP_REDIS_ERROR_OOM;
+                        break;
+                    }
+
+                    break;
+
+                case 5:
+                    /* -BUSY Redis is busy running a script. You can only call SCRIPT KILL or SHUTDOWN NOSAVE.\r\n" */
+                    if (str5cmp(m, '-', 'B', 'U', 'S', 'Y')) {
+                        r->type = MSG_RSP_REDIS_ERROR_BUSY;
+                        break;
+                    }
+
+                    break;
+
+                case 7:
+                    /* -NOAUTH Authentication required.\r\n */
+                    if (str7cmp(m, '-', 'N', 'O', 'A', 'U', 'T', 'H')) {
+                        r->type = MSG_RSP_REDIS_ERROR_NOAUTH;
+                        break;
+                    }
+
+                    break;
+
+                case 8:
+                    /* rsp: "-LOADING Redis is loading the dataset in memory\r\n" */
+                    if (str8cmp(m, '-', 'L', 'O', 'A', 'D', 'I', 'N', 'G')) {
+                        r->type = MSG_RSP_REDIS_ERROR_LOADING;
+                        break;
+                    }
+
+                    /* -BUSYKEY Target key name already exists.\r\n */
+                    if (str8cmp(m, '-', 'B', 'U', 'S', 'Y', 'K', 'E', 'Y')) {
+                        r->type = MSG_RSP_REDIS_ERROR_BUSYKEY;
+                        break;
+                    }
+
+                    /* "-MISCONF Redis is configured to save RDB snapshots, but is currently not able to persist on disk. Commands that may modify the data set are disabled. Please check Redis logs for details about the error.\r\n" */
+                    if (str8cmp(m, '-', 'M', 'I', 'S', 'C', 'O', 'N', 'F')) {
+                        r->type = MSG_RSP_REDIS_ERROR_MISCONF;
+                        break;
+                    }
+
+                    break;
+
+                case 9:
+                    /* -NOSCRIPT No matching script. Please use EVAL.\r\n */
+                    if (str9cmp(m, '-', 'N', 'O', 'S', 'C', 'R', 'I', 'P', 'T')) {
+                        r->type = MSG_RSP_REDIS_ERROR_NOSCRIPT;
+                        break;
+                    }
+
+                    /* -READONLY You can't write against a read only slave.\r\n */
+                    if (str9cmp(m, '-', 'R', 'E', 'A', 'D', 'O', 'N', 'L', 'Y')) {
+                        r->type = MSG_RSP_REDIS_ERROR_READONLY;
+                        break;
+                    }
+
+                    break;
+
+                case 10:
+                    /* -WRONGTYPE Operation against a key holding the wrong kind of value\r\n */
+                    if (str10cmp(m, '-', 'W', 'R', 'O', 'N', 'G', 'T', 'Y', 'P', 'E')) {
+                        r->type = MSG_RSP_REDIS_ERROR_WRONGTYPE;
+                        break;
+                    }
+
+                    /* -EXECABORT Transaction discarded because of previous errors.\r\n" */
+                    if (str10cmp(m, '-', 'E', 'X', 'E', 'C', 'A', 'B', 'O', 'R', 'T')) {
+                        r->type = MSG_RSP_REDIS_ERROR_EXECABORT;
+                        break;
+                    }
+
+                    break;
+
+                case 11:
+                    /* -MASTERDOWN Link with MASTER is down and slave-serve-stale-data is set to 'no'.\r\n */
+                    if (str11cmp(m, '-', 'M', 'A', 'S', 'T', 'E', 'R', 'D', 'O', 'W', 'N')) {
+                        r->type = MSG_RSP_REDIS_ERROR_MASTERDOWN;
+                        break;
+                    }
+
+                    /* -NOREPLICAS Not enough good slaves to write.\r\n */
+                    if (str11cmp(m, '-', 'N', 'O', 'R', 'E', 'P', 'L', 'I', 'C', 'A', 'S')) {
+                        r->type = MSG_RSP_REDIS_ERROR_NOREPLICAS;
+                        break;
+                    }
+
+                    break;
+                }
+                state = SW_RUNTO_CRLF;
+            }
+
             break;
 
         case SW_INTEGER:
@@ -1758,6 +1925,13 @@ redis_parse_rsp(struct msg *r)
             r->integer = 0;
             break;
 
+        case SW_SIMPLE:
+            if (ch == CR) {
+              state = SW_MULTIBULK_ARGN_LF;
+              r->rnarg--;
+            }
+            break;
+
         case SW_INTEGER_START:
             if (ch == CR) {
                 state = SW_ALMOST_DONE;
@@ -1897,6 +2071,7 @@ redis_parse_rsp(struct msg *r)
                     /* response is '*0\r\n' */
                     goto done;
                 }
+
                 state = SW_MULTIBULK_ARGN_LEN;
                 break;
 
@@ -1938,9 +2113,17 @@ redis_parse_rsp(struct msg *r)
                     break;
                 }
 
-                if (ch != '$' && ch != ':') {
+                if (ch == ':' || ch == '+' || ch == '-') {
+                    /* handles not-found reply = '$-1' or integer reply = ':<num>' */
+                    /* and *2\r\n$2\r\nr0\r\n+OK\r\n or *1\r\n+OK\r\n */
+                    state = SW_SIMPLE;
+                    break;
+                }
+
+                if (ch != '$') {
                     goto error;
                 }
+
                 r->token = p;
                 r->rlen = 0;
             } else if (isdigit(ch)) {
@@ -1952,8 +2135,7 @@ redis_parse_rsp(struct msg *r)
                     goto error;
                 }
 
-                if ((r->rlen == 1 && (p - r->token) == 3) || *r->token == ':') {
-                    /* handles not-found reply = '$-1' or integer reply = ':<num>' */
+                if ((r->rlen == 1 && (p - r->token) == 3)) {
                     r->rlen = 0;
                     state = SW_MULTIBULK_ARGN_LF;
                 } else {
@@ -2062,6 +2244,37 @@ error:
                 r->state);
 }
 
+/*
+ * Return true, if redis replies with a transient server failure response,
+ * otherwise return false
+ *
+ * Transient failures on redis are scenarios when it is temporarily
+ * unresponsive and responds with the following protocol specific error
+ * reply:
+ * -OOM, when redis is out-of-memory
+ * -BUSY, when redis is busy
+ * -LOADING when redis is loading dataset into memory
+ *
+ * See issue: https://github.com/twitter/twemproxy/issues/369
+ */
+bool
+redis_failure(struct msg *r)
+{
+    ASSERT(!r->request);
+
+    switch (r->type) {
+    case MSG_RSP_REDIS_ERROR_OOM:
+    case MSG_RSP_REDIS_ERROR_BUSY:
+    case MSG_RSP_REDIS_ERROR_LOADING:
+        return true;
+
+    default:
+        break;
+    }
+
+    return false;
+}
+
 /*
  * copy one bulk from src to dst
  *
@@ -2443,8 +2656,10 @@ redis_fragment(struct msg *r, uint32_t ncontinuum, struct msg_tqh *frag_msgq)
     case MSG_REQ_REDIS_MGET:
     case MSG_REQ_REDIS_DEL:
         return redis_fragment_argx(r, ncontinuum, frag_msgq, 1);
+
     case MSG_REQ_REDIS_MSET:
         return redis_fragment_argx(r, ncontinuum, frag_msgq, 2);
+
     default:
         return NC_OK;
     }
@@ -2453,13 +2668,23 @@ redis_fragment(struct msg *r, uint32_t ncontinuum, struct msg_tqh *frag_msgq)
 rstatus_t
 redis_reply(struct msg *r)
 {
+    struct conn *c_conn;
     struct msg *response = r->peer;
 
-    ASSERT(response != NULL);
+    ASSERT(response != NULL && response->owner != NULL);
+
+    c_conn = response->owner;
+    if (r->type == MSG_REQ_REDIS_AUTH) {
+        return redis_handle_auth_req(r, response);
+    }
+
+    if (!conn_authenticated(c_conn)) {
+        return msg_append(response, rsp_auth_required.data, rsp_auth_required.len);
+    }
 
     switch (r->type) {
     case MSG_REQ_REDIS_PING:
-        return msg_append(response, (uint8_t *)"+PONG\r\n", 7);
+        return msg_append(response, rsp_pong.data, rsp_pong.len);
 
     default:
         NOT_REACHED();
@@ -2470,10 +2695,10 @@ redis_reply(struct msg *r)
 void
 redis_post_coalesce_mset(struct msg *request)
 {
-    struct msg *response = request->peer;
     rstatus_t status;
+    struct msg *response = request->peer;
 
-    status = msg_append(response, (uint8_t *)"+OK\r\n", 5);
+    status = msg_append(response, rsp_ok.data, rsp_ok.len);
     if (status != NC_OK) {
         response->error = 1;        /* mark this msg as err */
         response->err = errno;
@@ -2546,11 +2771,168 @@ redis_post_coalesce(struct msg *r)
     switch (r->type) {
     case MSG_REQ_REDIS_MGET:
         return redis_post_coalesce_mget(r);
+
     case MSG_REQ_REDIS_DEL:
         return redis_post_coalesce_del(r);
+
     case MSG_REQ_REDIS_MSET:
         return redis_post_coalesce_mset(r);
+
     default:
         NOT_REACHED();
     }
 }
+
+static rstatus_t
+redis_handle_auth_req(struct msg *req, struct msg *rsp)
+{
+    struct conn *conn = (struct conn *)rsp->owner;
+    struct server_pool *pool;
+    struct keypos *kpos;
+    uint8_t *key;
+    uint32_t keylen;
+    bool valid;
+
+    ASSERT(conn->client && !conn->proxy);
+
+    pool = (struct server_pool *)conn->owner;
+
+    if (!pool->require_auth) {
+        /*
+         * AUTH command from the client in absence of a redis_auth:
+         * directive should be treated as an error
+         */
+        return msg_append(rsp, rsp_no_password.data, rsp_no_password.len);
+    }
+
+    kpos = array_get(req->keys, 0);
+    key = kpos->start;
+    keylen = (uint32_t)(kpos->end - kpos->start);
+    valid = (keylen == pool->redis_auth.len) &&
+            (memcmp(pool->redis_auth.data, key, keylen) == 0) ? true : false;
+    if (valid) {
+        conn->authenticated = 1;
+        return msg_append(rsp, rsp_ok.data, rsp_ok.len);
+    }
+
+    /*
+     * Password in the AUTH command doesn't match the one configured in
+     * redis_auth: directive
+     *
+     * We mark the connection has unauthenticated until the client
+     * reauthenticates with the correct password
+     */
+    conn->authenticated = 0;
+    return msg_append(rsp, rsp_invalid_password.data, rsp_invalid_password.len);
+}
+
+rstatus_t
+redis_add_auth(struct context *ctx, struct conn *c_conn, struct conn *s_conn)
+{
+    rstatus_t status;
+    struct msg *msg;
+    struct server_pool *pool;
+
+    ASSERT(!s_conn->client && !s_conn->proxy);
+    ASSERT(!conn_authenticated(s_conn));
+
+    pool = c_conn->owner;
+
+    msg = msg_get(c_conn, true, c_conn->redis);
+    if (msg == NULL) {
+        c_conn->err = errno;
+        return NC_ENOMEM;
+    }
+
+    status = msg_prepend_format(msg, "*2\r\n$4\r\nAUTH\r\n$%d\r\n%s\r\n",
+                                pool->redis_auth.len, pool->redis_auth.data);
+    if (status != NC_OK) {
+        msg_put(msg);
+        return status;
+    }
+
+    msg->swallow = 1;
+    s_conn->enqueue_inq(ctx, s_conn, msg);
+    s_conn->authenticated = 1;
+
+    return NC_OK;
+}
+
+void
+redis_post_connect(struct context *ctx, struct conn *conn, struct server *server)
+{
+    rstatus_t status;
+    struct server_pool *pool = server->owner;
+    struct msg *msg;
+    int digits;
+
+    ASSERT(!conn->client && conn->connected);
+    ASSERT(conn->redis);
+
+    /*
+     * By default, every connection to redis uses the database DB 0. You
+     * can select a different one on a per-connection basis by sending
+     * a request 'SELECT <redis_db>', where <redis_db> is the configured
+     * on a per pool basis in the configuration
+     */
+    if (pool->redis_db <= 0) {
+        return;
+    }
+
+    /*
+     * Create a fake client message and add it to the pipeline. We force this
+     * message to be head of queue as it might already contain a command
+     * that triggered the connect.
+     */
+    msg = msg_get(conn, true, conn->redis);
+    if (msg == NULL) {
+        return;
+    }
+
+    digits = (pool->redis_db >= 10) ? (int)log10(pool->redis_db) + 1 : 1;
+    status = msg_prepend_format(msg, "*2\r\n$6\r\nSELECT\r\n$%d\r\n%d\r\n", digits, pool->redis_db);
+    if (status != NC_OK) {
+        msg_put(msg);
+        return;
+    }
+    msg->type = MSG_REQ_REDIS_SELECT;
+    msg->result = MSG_PARSE_OK;
+    msg->swallow = 1;
+    msg->owner = NULL;
+
+    /* enqueue as head and send */
+    req_server_enqueue_imsgq_head(ctx, conn, msg);
+    msg_send(ctx, conn);
+
+    log_debug(LOG_NOTICE, "sent 'SELECT %d' to %s | %s", pool->redis_db,
+              pool->name.data, server->name.data);
+}
+
+void
+redis_swallow_msg(struct conn *conn, struct msg *pmsg, struct msg *msg)
+{
+    if (pmsg != NULL && pmsg->type == MSG_REQ_REDIS_SELECT &&
+        msg != NULL && redis_error(msg)) {
+        struct server* conn_server;
+        struct server_pool* conn_pool;
+        struct mbuf* rsp_buffer;
+        uint8_t message[128];
+        size_t copy_len;
+
+        /*
+         * Get a substring from the message so that the inital - and the trailing
+         * \r\n is removed.
+         */
+        conn_server = (struct server*)conn->owner;
+        conn_pool = conn_server->owner;
+        rsp_buffer = STAILQ_LAST(&msg->mhdr, mbuf, next);
+        copy_len = MIN(mbuf_length(rsp_buffer) - 3, sizeof(message) - 1);
+
+        nc_memcpy(message, &rsp_buffer->start[1], copy_len);
+        message[copy_len] = 0;
+
+        log_warn("SELECT %d failed on %s | %s: %s",
+                 conn_pool->redis_db, conn_pool->name.data,
+                 conn_server->name.data, message);
+    }
+}