@@ -56,6 +56,7 @@ extern int redis_disable_time_param;

 extern int redis_allowed_timeouts_param;

 extern int redis_flush_on_reconnect_param;

 extern int redis_allow_dynamic_nodes_param;

+extern int ndb_redis_debug;

 /* backwards compatibility with hiredis < 0.12 */

 #if (HIREDIS_MAJOR == 0) && (HIREDIS_MINOR < 12)

@@ -198,8 +199,8 @@ int redisc_init(void)

 									}

 								}

 							}

-							LM_DBG("slave for %s: %s:%d\n", sentinel_group,

-									addr, port);

+							LOG(ndb_redis_debug, "slave for %s: %s:%d\n",

+									sentinel_group, addr, port);

 						}

 					}

 				}

@@ -207,15 +208,15 @@ int redisc_init(void)

 		}

 		if(sock != 0) {

-			LM_DBG("Connecting to unix socket: %s\n", unix_sock_path);

+			LOG(ndb_redis_debug, "Connecting to unix socket: %s\n", unix_sock_path);

 			rsrv->ctxRedis = redisConnectUnixWithTimeout(unix_sock_path,

 					tv_conn);

 		} else {

-			LM_DBG("Connecting to %s:%d\n", addr, port);

+			LOG(ndb_redis_debug, "Connecting to %s:%d\n", addr, port);

 			rsrv->ctxRedis = redisConnectWithTimeout(addr, port, tv_conn);

 		}

-		LM_DBG("rsrv->ctxRedis = %p\n", rsrv->ctxRedis);

+		LOG(ndb_redis_debug, "rsrv->ctxRedis = %p\n", rsrv->ctxRedis);

 		if(!rsrv->ctxRedis) {

 			LM_ERR("Failed to create REDIS-Context.\n");

@@ -390,18 +391,21 @@ redisc_server_t *redisc_get_server(str *name)

 	unsigned int hname;

 	hname = get_hash1_raw(name->s, name->len);

-	LM_DBG("Hash %u (%.*s)\n", hname, name->len, name->s);

+	LOG(ndb_redis_debug, "Hash %u (%.*s)\n", hname, name->len, name->s);

 	rsrv=_redisc_srv_list;

 	while(rsrv!=NULL)

 	{

 		LM_DBG("Entry %u (%.*s)\n", rsrv->hname,

 				rsrv->sname->len, rsrv->sname->s);

 		if(rsrv->hname==hname && rsrv->sname->len==name->len

-				&& strncmp(rsrv->sname->s, name->s, name->len)==0)

+				&& strncmp(rsrv->sname->s, name->s, name->len)==0) {

+			LOG(ndb_redis_debug, "Using entry %u (%.*s)\n", rsrv->hname,

+				rsrv->sname->len, rsrv->sname->s);

 			return rsrv;

+		}

 		rsrv=rsrv->next;

 	}

-	LM_DBG("No entry found.\n");

+	LOG(ndb_redis_debug, "No entry found.\n");

 	return NULL;

 }

@@ -497,7 +501,7 @@ int redisc_reconnect_server(redisc_server_t *rsrv)

 						strncpy(addr, res->element[0]->str,

 								res->element[0]->len + 1);

 						port = atoi(res->element[1]->str);

-						LM_DBG("sentinel replied: %s:%d\n", addr, port);

+						LOG(ndb_redis_debug, "sentinel replied: %s:%d\n", addr, port);

 					}

 				}

 				else {

@@ -520,7 +524,7 @@ int redisc_reconnect_server(redisc_server_t *rsrv)

 								}

 							}

 						}

-						LM_DBG("slave for %s: %s:%d\n", sentinel_group,

+						LOG(ndb_redis_debug, "slave for %s: %s:%d\n", sentinel_group,

 								addr, port);

 					}

 				}

@@ -689,7 +693,7 @@ int redisc_create_pipelined_message(redisc_server_t *rsrv)

 	if (rsrv->ctxRedis->err)

 	{

-		LM_DBG("Reconnecting server because of error %d: \"%s\"",

+		LOG(ndb_redis_debug, "Reconnecting server because of error %d: \"%s\"",

 				rsrv->ctxRedis->err,rsrv->ctxRedis->errstr);

 		if (redisc_reconnect_server(rsrv))

 		{

@@ -868,10 +872,10 @@ int check_cluster_reply(redisReply *reply, redisc_server_t **rsrv)

 			name.len = snprintf(buffername, sizeof(buffername), "%.*s:%i",

 					addr.len, addr.s, port);

 			name.s = buffername;

-			LM_DBG("Name of new connection: %.*s\n", name.len, name.s);

+			LOG(ndb_redis_debug, "Name of new connection: %.*s\n", name.len, name.s);

 			rsrv_new = redisc_get_server(&name);

 			if(rsrv_new) {

-				LM_DBG("Reusing Connection\n");

+				LOG(ndb_redis_debug, "Reusing connection\n");

 				*rsrv = rsrv_new;

 				return 1;

 			} else if(redis_allow_dynamic_nodes_param) {

@@ -908,8 +912,8 @@ int check_cluster_reply(redisReply *reply, redisc_server_t **rsrv)

 						*rsrv = rsrv_new;

 						/* Need to connect to the new server now */

 						if(redisc_reconnect_server(rsrv_new) == 0) {

-							LM_DBG("Connected to the new server with name: "

-								   "%.*s\n",

+							LOG(ndb_redis_debug, "Connected to the new server"

+									" with name: %.*s\n",

 									name.len, name.s);

 							return 1;

 						} else {

@@ -1159,13 +1163,14 @@ again:

 	/* null reply, reconnect and try again */

 	if(rsrv->ctxRedis->err)

 	{

-		LM_DBG("Redis error: %s\n", rsrv->ctxRedis->errstr);

+		LOG(ndb_redis_debug, "Redis error: %s\n", rsrv->ctxRedis->errstr);

 	}

 	if(res)

 	{

 		if (check_cluster_reply(res, &rsrv)) {

 			freeReplyObject(res);

+			LOG(ndb_redis_debug, "Retrying the command directly\n");

 			goto again;

 		}

 		return res;

@@ -1173,10 +1178,12 @@ again:

 	if(redisc_reconnect_server(rsrv)==0)

 	{

+		LOG(ndb_redis_debug, "Trying to reconnect to server\n");

 		res = redisCommandArgv(rsrv->ctxRedis, argc, argv, argvlen);

 		if (res) {

 			if (check_cluster_reply(res, &rsrv)) {

 				freeReplyObject(res);

+				LOG(ndb_redis_debug, "Retrying the command after reconnect\n");

 				goto again;

 			}

 		}

@@ -1264,6 +1271,7 @@ int redisc_free_reply(str *name)

 	}

 	/* reply entry not found. */

+	LOG(ndb_redis_debug, "reply entry not found: %.*s\n", name->len, name->s);

 	return -1;

 }

@@ -1165,6 +1165,7 @@ again:

 	if(res)

 	{

 		if (check_cluster_reply(res, &rsrv)) {

+			freeReplyObject(res);

 			goto again;

 		}

 		return res;

@@ -1175,6 +1176,7 @@ again:

 		res = redisCommandArgv(rsrv->ctxRedis, argc, argv, argvlen);

 		if (res) {

 			if (check_cluster_reply(res, &rsrv)) {

+				freeReplyObject(res);

 				goto again;

 			}

 		}

@@ -39,8 +39,10 @@

 #include "redis_client.h"

-#define redisCommandNR(a...) (int)({ void *__tmp; __tmp = redisCommand(a); \

-		if (__tmp) freeReplyObject(__tmp); __tmp ? 0 : -1;})

+#define redisCommandNR(a...) (int)({ \

+		void *__tmp; __tmp = redisCommand(a); \

+		if (__tmp) { freeReplyObject(__tmp); }; \

+		__tmp ? 0 : -1;})

 static redisc_server_t * _redisc_srv_list=NULL;

@@ -1269,6 +1269,10 @@ int redisc_check_auth(redisc_server_t *rsrv, char *pass)

 	int retval = 0;

 	reply = redisCommand(rsrv->ctxRedis, "AUTH %s", pass);

+	if(!reply) {

+		LM_ERR("Redis authentication error\n");

+		return -1;

+	}

 	if (reply->type == REDIS_REPLY_ERROR) {

 		LM_ERR("Redis authentication error\n");

 		retval = -1;

@@ -1059,6 +1059,11 @@ int redisc_exec(str *srv, str *res, str *cmd, ...)

 			if(redisc_reconnect_server(rsrv)==0)

 			{

 				rpl->rplRedis = redisvCommand(rsrv->ctxRedis, cmd->s, ap4);

+				if(rpl->rplRedis == NULL)

+				{

+					redis_count_err_and_disable(rsrv);

+					goto error_exec;

+				}

 			} else {

 				LM_ERR("unable to reconnect to redis server: %.*s\n",

 						srv->len, srv->s);

@@ -1011,7 +1011,7 @@ int redisc_exec(str *srv, str *res, str *cmd, ...)

 		/* null reply, reconnect and try again */

 		if(rsrv->ctxRedis->err)

 		{

-			LM_ERR("Redis error: %s\n", rsrv->ctxRedis->errstr);

+			LM_DBG("Redis error: %s\n", rsrv->ctxRedis->errstr);

 		}

 		if(redisc_reconnect_server(rsrv)==0)

 		{

@@ -1054,7 +1054,7 @@ int redisc_exec(str *srv, str *res, str *cmd, ...)

 			/* null reply, reconnect and try again */

 			if(rsrv->ctxRedis->err)

 			{

-				LM_ERR("Redis error: %s\n", rsrv->ctxRedis->errstr);

+				LM_DBG("Redis error: %s\n", rsrv->ctxRedis->errstr);

 			}

 			if(redisc_reconnect_server(rsrv)==0)

 			{

@@ -1152,7 +1152,7 @@ again:

 	/* null reply, reconnect and try again */

 	if(rsrv->ctxRedis->err)

 	{

-		LM_ERR("Redis error: %s\n", rsrv->ctxRedis->errstr);

+		LM_DBG("Redis error: %s\n", rsrv->ctxRedis->errstr);

 	}

 	if(res)

@@ -770,7 +770,7 @@ int redisc_exec_pipelined(redisc_server_t *rsrv)

 		/* null reply, reconnect and try again */

 		if (rsrv->ctxRedis->err)

 		{

-			LM_ERR("Redis error: %s\n", rsrv->ctxRedis->errstr);

+			LM_DBG("Redis error: %s\n", rsrv->ctxRedis->errstr);

 		}

 		if (redisc_create_pipelined_message(rsrv) == 0)

 		{

@@ -1032,13 +1032,6 @@ int redisc_exec(str *srv, str *res, str *cmd, ...)

 		}

 	}

-	LM_DBG("rpl->rplRedis->type:%d\n", rpl->rplRedis->type);

-	if(rpl->rplRedis->type == REDIS_REPLY_ERROR) {

-		LM_ERR("Redis error:%.*s\n",

-			(int)rpl->rplRedis->len, rpl->rplRedis->str);

-		goto error_exec;

-	}

-

 	if (check_cluster_reply(rpl->rplRedis, &rsrv)) {

 		LM_DBG("rsrv->ctxRedis = %p\n", rsrv->ctxRedis);

 		if(rsrv->ctxRedis==NULL)

@@ -1073,14 +1066,15 @@ int redisc_exec(str *srv, str *res, str *cmd, ...)

 				goto error_exec;

 			}

 		}

+	}

-		LM_DBG("rpl->rplRedis->type:%d\n", rpl->rplRedis->type);

-		if(rpl->rplRedis->type == REDIS_REPLY_ERROR) {

-			LM_ERR("Redis error:%.*s\n",

-				(int)rpl->rplRedis->len, rpl->rplRedis->str);

-			goto error_exec;

-		}

+	LM_DBG("rpl->rplRedis->type:%d\n", rpl->rplRedis->type);

+	if(rpl->rplRedis->type == REDIS_REPLY_ERROR) {

+		LM_ERR("Redis error:%.*s\n",

+			(int)rpl->rplRedis->len, rpl->rplRedis->str);

+		goto error_exec;

 	}

+

 	STR_ZTOV(cmd->s[cmd->len], c);

 	rsrv->disable.consecutive_errors = 0;

 	va_end(ap);

@@ -408,8 +408,11 @@ redisc_server_t *redisc_get_server(str *name)

  */

 int redisc_reconnect_server(redisc_server_t *rsrv)

 {

-	char addr[256], pass[256], unix_sock_path[256];

-	unsigned int port, db, sock = 0, haspass = 0;

+	char addr[256], pass[256], unix_sock_path[256], sentinel_group[256];

+	unsigned int port, db, sock = 0, haspass = 0, sentinel_master = 1;

+	char sentinels[MAXIMUM_SENTINELS][256];

+	uint8_t sentinels_count = 0;

+	int i, row;

 	param_t *pit = NULL;

 	struct timeval tv_conn;

 	struct timeval tv_cmd;

@@ -442,6 +445,84 @@ int redisc_reconnect_server(redisc_server_t *rsrv)

 		} else if(pit->name.len==4 && strncmp(pit->name.s, "pass", 4)==0) {

 			snprintf(pass, sizeof(pass)-1, "%.*s", pit->body.len, pit->body.s);

 			haspass = 1;

+		} else if(pit->name.len==14 && strncmp(pit->name.s,

+					"sentinel_group", 14)==0) {

+			snprintf(sentinel_group, sizeof(sentinel_group)-1, "%.*s",

+					pit->body.len, pit->body.s);

+		} else if(pit->name.len==15 && strncmp(pit->name.s,

+					"sentinel_master", 15)==0) {

+			if(str2int(&pit->body, &sentinel_master) < 0)

+				sentinel_master = 1;

+		} else if(pit->name.len==8 && strncmp(pit->name.s,

+					"sentinel", 8)==0) {

+			if( sentinels_count < MAXIMUM_SENTINELS ){

+				snprintf(sentinels[sentinels_count],

+						sizeof(sentinels[sentinels_count])-1, "%.*s",

+						pit->body.len, pit->body.s);

+				sentinels_count++;

+			}

+			else {

+				LM_ERR("too many sentinels, maximum %d supported.\n",

+						MAXIMUM_SENTINELS);

+				return -1;

+			}

+		}

+	}

+

+	// if sentinels are provided, we need to connect to them and retrieve the redis server

+	// address / port

+	if(sentinels_count > 0) {

+		for(i= 0; i< sentinels_count; i++) {

+			char *sentinelAddr = sentinels[i];

+			char *pos;

+			redisContext *redis;

+			redisReply *res, *res2;

+

+			port = 6379;

+			if( (pos = strchr(sentinelAddr, ':')) != NULL ) {

+				port = atoi(pos+1);

+				pos[i] = '\0';

+			}

+

+			redis = redisConnectWithTimeout(sentinelAddr, port, tv_conn);

+			if( redis ) {

+				if(sentinel_master != 0) {

+					res = redisCommand(redis,

+							"SENTINEL get-master-addr-by-name %s",

+							sentinel_group);

+					if( res && (res->type == REDIS_REPLY_ARRAY)

+							&& (res->elements == 2) ) {

+						strncpy(addr, res->element[0]->str,

+								res->element[0]->len + 1);

+						port = atoi(res->element[1]->str);

+						LM_DBG("sentinel replied: %s:%d\n", addr, port);

+					}

+				}

+				else {

+					res = redisCommand(redis, "SENTINEL slaves %s",

+							sentinel_group);

+					if( res && (res->type == REDIS_REPLY_ARRAY) ) {

+						for(row = 0; row< res->elements; row++){

+							res2 = res->element[row];

+							for(i= 0; i< res2->elements; i+= 2) {

+								if( strncmp(res2->element[i]->str,

+											"ip", 2) == 0 ) {

+									strncpy(addr, res2->element[i+1]->str,

+											res2->element[i+1]->len);

+									addr[res2->element[i+1]->len] = '\0';

+								}

+								else if( strncmp(res2->element[i]->str,

+											"port", 4) == 0) {

+									port = atoi(res2->element[i+1]->str);

+									break;

+								}

+							}

+						}

+						LM_DBG("slave for %s: %s:%d\n", sentinel_group,

+								addr, port);

+					}

+				}

+			}

 		}

 	}

@@ -950,6 +950,14 @@ int redisc_exec(str *srv, str *res, str *cmd, ...)

 			goto error_exec;

 		}

 	}

+

+	LM_DBG("rpl->rplRedis->type:%d\n", rpl->rplRedis->type);

+	if(rpl->rplRedis->type == REDIS_REPLY_ERROR) {

+		LM_ERR("Redis error:%.*s\n",

+			(int)rpl->rplRedis->len, rpl->rplRedis->str);

+		goto error_exec;

+	}

+

 	if (check_cluster_reply(rpl->rplRedis, &rsrv)) {

 		LM_DBG("rsrv->ctxRedis = %p\n", rsrv->ctxRedis);

 		if(rsrv->ctxRedis==NULL)

@@ -984,6 +992,13 @@ int redisc_exec(str *srv, str *res, str *cmd, ...)

 				goto error_exec;

 			}

 		}

+

+		LM_DBG("rpl->rplRedis->type:%d\n", rpl->rplRedis->type);

+		if(rpl->rplRedis->type == REDIS_REPLY_ERROR) {

+			LM_ERR("Redis error:%.*s\n",

+				(int)rpl->rplRedis->len, rpl->rplRedis->str);

+			goto error_exec;

+		}

 	}

 	STR_ZTOV(cmd->s[cmd->len], c);

 	rsrv->disable.consecutive_errors = 0;

@@ -542,9 +542,7 @@ int redisc_append_cmd(str *srv, str *res, str *cmd, ...)

 		LM_ERR("no redis reply id found: %.*s\n", res->len, res->s);

 		goto error_cmd;

 	}

-

-	c = cmd->s[cmd->len];

-	cmd->s[cmd->len] = '\0';

+	STR_VTOZ(cmd->s[cmd->len], c);

 	rsrv->piped.commands[rsrv->piped.pending_commands].len = redisvFormatCommand(

 			&rsrv->piped.commands[rsrv->piped.pending_commands].s,

 			cmd->s,

@@ -557,7 +555,7 @@ int redisc_append_cmd(str *srv, str *res, str *cmd, ...)

 	rsrv->piped.replies[rsrv->piped.pending_commands]=rpl;

 	rsrv->piped.pending_commands++;

-	cmd->s[cmd->len] = c;

+	STR_ZTOV(cmd->s[cmd->len], c);

 	va_end(ap);

 	return 0;

@@ -883,8 +881,7 @@ int redisc_exec(str *srv, str *res, str *cmd, ...)

 		goto error;

 	}

-	c = cmd->s[cmd->len];

-	cmd->s[cmd->len] = '\0';

+	STR_VTOZ(cmd->s[cmd->len], c);

 	rsrv = redisc_get_server(srv);

 	if(rsrv==NULL)

@@ -949,7 +946,7 @@ int redisc_exec(str *srv, str *res, str *cmd, ...)

 			redis_count_err_and_disable(rsrv);

 			LM_ERR("unable to reconnect to redis server: %.*s\n",

 					srv->len, srv->s);

-			cmd->s[cmd->len] = c;

+			STR_ZTOV(cmd->s[cmd->len], c);

 			goto error_exec;

 		}

 	}

@@ -983,12 +980,12 @@ int redisc_exec(str *srv, str *res, str *cmd, ...)

 			} else {

 				LM_ERR("unable to reconnect to redis server: %.*s\n",

 						srv->len, srv->s);

-				cmd->s[cmd->len] = c;

+				STR_ZTOV(cmd->s[cmd->len], c);

 				goto error_exec;

 			}

 		}

 	}

-	cmd->s[cmd->len] = c;

+	STR_ZTOV(cmd->s[cmd->len], c);

 	rsrv->disable.consecutive_errors = 0;

 	va_end(ap);

 	va_end(ap2);

@@ -1000,12 +997,12 @@ int redisc_exec(str *srv, str *res, str *cmd, ...)

 	return 0;

 error_exec:

-	cmd->s[cmd->len] = c;

+	STR_ZTOV(cmd->s[cmd->len], c);

 	ret = -1;

 	goto error;

 srv_disabled:

-	cmd->s[cmd->len] = c;

+	STR_ZTOV(cmd->s[cmd->len], c);

 	ret = -2;

 	goto error;

@@ -1019,12 +1019,12 @@ error:

 /**

  * Executes a redis command.

- * Command is coded using a vector of strings, and a vector of lenghts.

+ * Command is coded using a vector of strings, and a vector of lengths.

  *

  * @param rsrv Pointer to a redis_server_t structure.

  * @param argc number of elements in the command vector.

  * @param argv vector of zero terminated strings forming the command.

- * @param argvlen vector of command string lenghts or NULL.

+ * @param argvlen vector of command string lengths or NULL.

  * @return redisReply structure or NULL if there was an error.

  */

 redisReply* redisc_exec_argv(redisc_server_t *rsrv, int argc, const char **argv,

@@ -758,7 +758,7 @@ int check_cluster_reply(redisReply *reply, redisc_server_t **rsrv)

 	char spec_new[100];

 	if(redis_cluster_param) {

-		LM_DBG("Redis replied: \"%.*s\"\n", reply->len, reply->str);

+		LM_DBG("Redis replied: \"%.*s\"\n", (int)reply->len, reply->str);

 		if((reply->len > 7) && (strncmp(reply->str, "MOVED", 5) == 0)) {

 			port = 6379;

 			if(strchr(reply->str, ':') > 0) {

@@ -769,7 +769,7 @@ int check_cluster_reply(redisReply *reply, redisc_server_t **rsrv)

 				LM_DBG("Port \"%.*s\" [%i] => %i\n", tmpstr.len, tmpstr.s,

 						tmpstr.len, port);

 			} else {

-				LM_ERR("No Port in REDIS MOVED Reply (%.*s)\n", reply->len,

+				LM_ERR("No Port in REDIS MOVED Reply (%.*s)\n", (int)reply->len,

 						reply->str);

 				return 0;

 			}

@@ -778,7 +778,7 @@ int check_cluster_reply(redisReply *reply, redisc_server_t **rsrv)

 				addr.s = strchr(reply->str + 6, ' ') + 1;

 				LM_DBG("Host \"%.*s\" [%i]\n", addr.len, addr.s, addr.len);

 			} else {

-				LM_ERR("No Host in REDIS MOVED Reply (%.*s)\n", reply->len,

+				LM_ERR("No Host in REDIS MOVED Reply (%.*s)\n", (int)reply->len,

 						reply->str);

 				return 0;

 			}

@@ -39,7 +39,8 @@

 #include "redis_client.h"

-#define redisCommandNR(a...) (int)({ void *__tmp; __tmp = redisCommand(a); if (__tmp) freeReplyObject(__tmp); __tmp ? 0 : -1;})

+#define redisCommandNR(a...) (int)({ void *__tmp; __tmp = redisCommand(a); \

+		if (__tmp) freeReplyObject(__tmp); __tmp ? 0 : -1;})

 static redisc_server_t * _redisc_srv_list=NULL;

@@ -93,7 +94,7 @@ int redisc_init(void)

 	{

 		char sentinels[MAXIMUM_SENTINELS][256];

 		uint8_t sentinels_count = 0;

-		

+

 		port = 6379;

 		db = 0;

 		haspass = 0;

@@ -106,10 +107,12 @@ int redisc_init(void)

 		for (pit = rsrv->attrs; pit; pit=pit->next)

 		{

 			if(pit->name.len==4 && strncmp(pit->name.s, "unix", 4)==0) {

-				snprintf(unix_sock_path, sizeof(unix_sock_path)-1, "%.*s", pit->body.len, pit->body.s);

+				snprintf(unix_sock_path, sizeof(unix_sock_path)-1, "%.*s",

+						pit->body.len, pit->body.s);

 				sock = 1;

 			} else if(pit->name.len==4 && strncmp(pit->name.s, "addr", 4)==0) {

-				snprintf(addr, sizeof(addr)-1, "%.*s", pit->body.len, pit->body.s);

+				snprintf(addr, sizeof(addr)-1, "%.*s",

+						pit->body.len, pit->body.s);

 			} else if(pit->name.len==4 && strncmp(pit->name.s, "port", 4)==0) {

 				if(str2int(&pit->body, &port) < 0)

 					port = 6379;

@@ -117,25 +120,33 @@ int redisc_init(void)

 				if(str2int(&pit->body, &db) < 0)

 					db = 0;

 			} else if(pit->name.len==4 && strncmp(pit->name.s, "pass", 4)==0) {

-				snprintf(pass, sizeof(pass)-1, "%.*s", pit->body.len, pit->body.s);

+				snprintf(pass, sizeof(pass)-1, "%.*s",

+						pit->body.len, pit->body.s);

 				haspass = 1;

-			} else if(pit->name.len==14 && strncmp(pit->name.s, "sentinel_group", 14)==0) {

-				snprintf(sentinel_group, sizeof(sentinel_group)-1, "%.*s", pit->body.len, pit->body.s);

-			} else if(pit->name.len==15 && strncmp(pit->name.s, "sentinel_master", 15)==0) {

+			} else if(pit->name.len==14 && strncmp(pit->name.s,

+						"sentinel_group", 14)==0) {

+				snprintf(sentinel_group, sizeof(sentinel_group)-1, "%.*s",

+						pit->body.len, pit->body.s);

+			} else if(pit->name.len==15 && strncmp(pit->name.s,

+						"sentinel_master", 15)==0) {

 				if(str2int(&pit->body, &sentinel_master) < 0)

 					sentinel_master = 1;

-			} else if(pit->name.len==8 && strncmp(pit->name.s, "sentinel", 8)==0) {

+			} else if(pit->name.len==8 && strncmp(pit->name.s,

+						"sentinel", 8)==0) {

 				if( sentinels_count < MAXIMUM_SENTINELS ){

-					snprintf(sentinels[sentinels_count], sizeof(sentinels[sentinels_count])-1, "%.*s", pit->body.len, pit->body.s);

+					snprintf(sentinels[sentinels_count],

+							sizeof(sentinels[sentinels_count])-1, "%.*s",

+							pit->body.len, pit->body.s);

 					sentinels_count++;

 				}

 				else {

-					LM_ERR("too many sentinels, maximum %d supported.\n", MAXIMUM_SENTINELS);

+					LM_ERR("too many sentinels, maximum %d supported.\n",

+							MAXIMUM_SENTINELS);

 					return -1;

 				}

 			}

 		}

-		

+

 		// if sentinels are provided, we need to connect to them and retrieve the redis server

 		// address / port

 		if(sentinels_count > 0) {

@@ -144,46 +155,49 @@ int redisc_init(void)

 				char *pos;

 				redisContext *redis;

 				redisReply *res, *res2;

-				

+

 				port = 6379;

 				if( (pos = strchr(sentinelAddr, ':')) != NULL ) {

 					port = atoi(pos+1);

 					pos[i] = '\0';

 				}

-				

+

 				redis = redisConnectWithTimeout(sentinelAddr, port, tv_conn);

 				if( redis ) {

 					if(sentinel_master != 0) {

-						res = redisCommand(redis, "SENTINEL get-master-addr-by-name %s", sentinel_group);

-						if( res && (res->type == REDIS_REPLY_ARRAY) && (res->elements == 2) ) {

-							strncpy(addr, res->element[0]->str, res->element[0]->len + 1);

+						res = redisCommand(redis,

+								"SENTINEL get-master-addr-by-name %s",

+								sentinel_group);

+						if( res && (res->type == REDIS_REPLY_ARRAY)

+								&& (res->elements == 2) ) {

+							strncpy(addr, res->element[0]->str,

+									res->element[0]->len + 1);

 							port = atoi(res->element[1]->str);

-							

-							

-							printf("sentinel replied: %s:%d\n", addr, port);

+							LM_DBG("sentinel replied: %s:%d\n", addr, port);

 						}

 					}

 					else {

-						res = redisCommand(redis, "SENTINEL slaves %s", sentinel_group);

+						res = redisCommand(redis, "SENTINEL slaves %s",

+								sentinel_group);

 						if( res && (res->type == REDIS_REPLY_ARRAY) ) {

-							

 							for(row = 0; row< res->elements; row++){

 								res2 = res->element[row];

-								

 								for(i= 0; i< res2->elements; i+= 2) {

-									if( strncmp(res2->element[i]->str, "ip", 2) == 0 ) {

-										strncpy(addr, res2->element[i+1]->str, res2->element[i+1]->len);

+									if( strncmp(res2->element[i]->str,

+												"ip", 2) == 0 ) {

+										strncpy(addr, res2->element[i+1]->str,

+												res2->element[i+1]->len);

 										addr[res2->element[i+1]->len] = '\0';

 									}

-									else if( strncmp(res2->element[i]->str, "port", 4) == 0) {

+									else if( strncmp(res2->element[i]->str,

+												"port", 4) == 0) {

 										port = atoi(res2->element[i+1]->str);

 										break;

 									}

 								}

-								

 							}

-							

-							printf("slave for %s: %s:%d\n", sentinel_group, addr, port);

+							LM_DBG("slave for %s: %s:%d\n", sentinel_group,

+									addr, port);

 						}

 					}

 				}

@@ -206,7 +220,8 @@ int redisc_init(void)

 			goto err;

 		}

 		if (rsrv->ctxRedis->err) {

-			LM_ERR("Failed to create REDIS returned an error: %s\n", rsrv->ctxRedis->errstr);

+			LM_ERR("Failed to create REDIS returned an error: %s\n",

+					rsrv->ctxRedis->errstr);

 			goto err2;

 		}

 		if ((haspass != 0) && redisc_check_auth(rsrv, pass)) {

@@ -218,11 +233,14 @@ int redisc_init(void)

 			goto err2;

 		}

 		if (redisCommandNR(rsrv->ctxRedis, "PING")) {

-			LM_ERR("Failed to send PING (REDIS returned %s).\n", rsrv->ctxRedis->errstr);

+			LM_ERR("Failed to send PING (REDIS returned %s).\n",

+					rsrv->ctxRedis->errstr);

 			goto err2;

 		}

-		if ((redis_cluster_param == 0) && redisCommandNR(rsrv->ctxRedis, "SELECT %i", db)) {

-			LM_ERR("Failed to send \"SELECT %i\" (REDIS returned \"%s\", and not in cluster mode).\n", db, rsrv->ctxRedis->errstr);

+		if ((redis_cluster_param == 0) && redisCommandNR(rsrv->ctxRedis,

+					"SELECT %i", db)) {

+			LM_ERR("Failed to send \"SELECT %i\" (REDIS returned \"%s\","

+					" and not in cluster mode).\n", db, rsrv->ctxRedis->errstr);

 			goto err2;

 		}

 	}

@@ -374,7 +392,8 @@ redisc_server_t *redisc_get_server(str *name)

 	rsrv=_redisc_srv_list;

 	while(rsrv!=NULL)

 	{

-		LM_DBG("Entry %u (%.*s)\n", rsrv->hname, rsrv->sname->len, rsrv->sname->s);

+		LM_DBG("Entry %u (%.*s)\n", rsrv->hname,

+				rsrv->sname->len, rsrv->sname->s);

 		if(rsrv->hname==hname && rsrv->sname->len==name->len

 				&& strncmp(rsrv->sname->s, name->s, name->len)==0)

 			return rsrv;

@@ -409,7 +428,8 @@ int redisc_reconnect_server(redisc_server_t *rsrv)

 	for (pit = rsrv->attrs; pit; pit=pit->next)

 	{

 		if(pit->name.len==4 && strncmp(pit->name.s, "unix", 4)==0) {

-			snprintf(unix_sock_path, sizeof(unix_sock_path)-1, "%.*s", pit->body.len, pit->body.s);

+			snprintf(unix_sock_path, sizeof(unix_sock_path)-1, "%.*s",

+					pit->body.len, pit->body.s);

 			sock = 1;

 		} else if(pit->name.len==4 && strncmp(pit->name.s, "addr", 4)==0) {

 			snprintf(addr, sizeof(addr)-1, "%.*s", pit->body.len, pit->body.s);

@@ -447,7 +467,8 @@ int redisc_reconnect_server(redisc_server_t *rsrv)

 		goto err2;

 	if (redisCommandNR(rsrv->ctxRedis, "PING"))

 		goto err2;

-	if ((redis_cluster_param == 0) && redisCommandNR(rsrv->ctxRedis, "SELECT %i", db))

+	if ((redis_cluster_param == 0) && redisCommandNR(rsrv->ctxRedis,

+				"SELECT %i", db))

 		goto err2;

 	if (redis_flush_on_reconnect_param)

 		if (redisCommandNR(rsrv->ctxRedis, "FLUSHALL"))

@@ -511,7 +532,8 @@ int redisc_append_cmd(str *srv, str *res, str *cmd, ...)

 	}

 	if (rsrv->piped.pending_commands >= MAXIMUM_PIPELINED_COMMANDS)

 	{

-		LM_ERR("Too many pipelined commands, maximum is %d\n",MAXIMUM_PIPELINED_COMMANDS);

+		LM_ERR("Too many pipelined commands, maximum is %d\n",

+				MAXIMUM_PIPELINED_COMMANDS);

 		goto error_cmd;

 	}

 	rpl = redisc_get_reply(res);

@@ -586,17 +608,21 @@ int redisc_create_pipelined_message(redisc_server_t *rsrv)

 	if (rsrv->ctxRedis->err)

 	{

-		LM_DBG("Reconnecting server because of error %d: \"%s\"",rsrv->ctxRedis->err,rsrv->ctxRedis->errstr);

+		LM_DBG("Reconnecting server because of error %d: \"%s\"",

+				rsrv->ctxRedis->err,rsrv->ctxRedis->errstr);

 		if (redisc_reconnect_server(rsrv))

 		{

-			LM_ERR("unable to reconnect to REDIS server: %.*s\n", rsrv->sname->len,rsrv->sname->s);

+			LM_ERR("unable to reconnect to REDIS server: %.*s\n",

+					rsrv->sname->len,rsrv->sname->s);

 			return -1;

 		}

 	}

 	for (i=0;i<rsrv->piped.pending_commands;i++)

 	{

-		if (redis_append_formatted_command(rsrv->ctxRedis,rsrv->piped.commands[i].s,rsrv->piped.commands[i].len) != REDIS_OK)

+		if (redis_append_formatted_command(rsrv->ctxRedis,

+					rsrv->piped.commands[i].s,rsrv->piped.commands[i].len)

+						!= REDIS_OK)

 		{

 			LM_ERR("Error while appending command %d",i);

 			return -1;

@@ -642,7 +668,8 @@ int redisc_exec_pipelined(redisc_server_t *rsrv)

 	}

 	if(rsrv->ctxRedis==NULL)

 	{

-		LM_ERR("no redis context for server: %.*s\n", rsrv->sname->len,rsrv->sname->s);

+		LM_ERR("no redis context for server: %.*s\n",

+				rsrv->sname->len,rsrv->sname->s);

 		goto error_exec;

 	}

@@ -694,7 +721,8 @@ int redisc_exec_pipelined(redisc_server_t *rsrv)

 			freeReplyObject(rpl->rplRedis);

 			rpl->rplRedis = NULL;

 		}

-		if (redisGetReplyFromReader(rsrv->ctxRedis, (void**) &rpl->rplRedis) != REDIS_OK)

+		if (redisGetReplyFromReader(rsrv->ctxRedis, (void**) &rpl->rplRedis)

+				!= REDIS_OK)

 		{

 			LM_ERR("Unable to read reply\n");

 			continue;

@@ -1181,7 +1209,8 @@ int redis_check_server(redisc_server_t *rsrv)

 	{

 		if (get_ticks() > rsrv->disable.restore_tick)

 		{

-			LM_NOTICE("REDIS server %.*s re-enabled",rsrv->sname->len,rsrv->sname->s);

+			LM_NOTICE("REDIS server %.*s re-enabled",

+					rsrv->sname->len, rsrv->sname->s);

 			rsrv->disable.disabled = 0;

 			rsrv->disable.consecutive_errors = 0;

 		}

@@ -1205,7 +1234,8 @@ int redis_count_err_and_disable(redisc_server_t *rsrv)

 	{

 		rsrv->disable.disabled=1;

 		rsrv->disable.restore_tick=get_ticks() + redis_disable_time_param;

-		LM_WARN("REDIS server %.*s disabled for %d seconds",rsrv->sname->len,rsrv->sname->s,redis_disable_time_param);

+		LM_WARN("REDIS server %.*s disabled for %d seconds", rsrv->sname->len,

+				rsrv->sname->s, redis_disable_time_param);

 		return 1;

 	}

 	return 0;

@@ -1246,7 +1276,8 @@ void print_redis_reply(int log_level, redisReply *rpl,int offset)

 		LOG(log_level,"%sinteger reply: %lld", padding, rpl->integer);

 		break;

 	case REDIS_REPLY_ARRAY:

-		LOG(log_level,"%sarray reply with %d elements", padding, (int)rpl->elements);

+		LOG(log_level,"%sarray reply with %d elements", padding,

+				(int)rpl->elements);

 		for (i=0; i < rpl->elements; i++)

 		{

 			LOG(log_level,"%selement %d:",padding,i);

@@ -71,6 +71,7 @@ int redisc_init(void)

 	char addr[256], pass[256], unix_sock_path[256], sentinel_group[256];

 	unsigned int port, db, sock = 0, haspass = 0, sentinel_master = 1;

+	int i, row;

 	redisc_server_t *rsrv=NULL;

 	param_t *pit = NULL;

 	struct timeval tv_conn;

@@ -138,7 +139,7 @@ int redisc_init(void)

 		// if sentinels are provided, we need to connect to them and retrieve the redis server

 		// address / port

 		if(sentinels_count > 0) {

-			for(int i= 0; i< sentinels_count; i++) {

+			for(i= 0; i< sentinels_count; i++) {

 				char *sentinelAddr = sentinels[i];

 				char *pos;

 				redisContext *redis;

@@ -166,10 +167,10 @@ int redisc_init(void)

 						res = redisCommand(redis, "SENTINEL slaves %s", sentinel_group);

 						if( res && (res->type == REDIS_REPLY_ARRAY) ) {

-							for(int row = 0; row< res->elements; row++){

+							for(row = 0; row< res->elements; row++){

 								res2 = res->element[row];

-								for(int i= 0; i< res2->elements; i+= 2) {

+								for(i= 0; i< res2->elements; i+= 2) {

 									if( strncmp(res2->element[i]->str, "ip", 2) == 0 ) {

 										strncpy(addr, res2->element[i+1]->str, res2->element[i+1]->len);

 										addr[res2->element[i+1]->len] = '\0';

@@ -68,9 +68,9 @@ int redis_append_formatted_command(redisContext *c, const char *cmd, size_t len)

  */

 int redisc_init(void)

 {

-	char addr[256], pass[256], unix_sock_path[256];

+	char addr[256], pass[256], unix_sock_path[256], sentinel_group[256];

-	unsigned int port, db, sock = 0, haspass = 0;

+	unsigned int port, db, sock = 0, haspass = 0, sentinel_master = 1;

 	redisc_server_t *rsrv=NULL;

 	param_t *pit = NULL;

 	struct timeval tv_conn;

@@ -90,6 +90,9 @@ int redisc_init(void)

 	for(rsrv=_redisc_srv_list; rsrv; rsrv=rsrv->next)

 	{

+		char sentinels[MAXIMUM_SENTINELS][256];

+		uint8_t sentinels_count = 0;

+		

 		port = 6379;

 		db = 0;

 		haspass = 0;

@@ -115,6 +118,74 @@ int redisc_init(void)

 			} else if(pit->name.len==4 && strncmp(pit->name.s, "pass", 4)==0) {

 				snprintf(pass, sizeof(pass)-1, "%.*s", pit->body.len, pit->body.s);

 				haspass = 1;

+			} else if(pit->name.len==14 && strncmp(pit->name.s, "sentinel_group", 14)==0) {

+				snprintf(sentinel_group, sizeof(sentinel_group)-1, "%.*s", pit->body.len, pit->body.s);

+			} else if(pit->name.len==15 && strncmp(pit->name.s, "sentinel_master", 15)==0) {

+				if(str2int(&pit->body, &sentinel_master) < 0)

+					sentinel_master = 1;

+			} else if(pit->name.len==8 && strncmp(pit->name.s, "sentinel", 8)==0) {

+				if( sentinels_count < MAXIMUM_SENTINELS ){