redisDb *db;
int dictid;
sds querybuf;
- robj **argv;
- int argc;
+ robj **argv, **mbargv;
+ int argc, mbargc;
int bulklen; /* bulk read len. -1 if not in bulk read mode */
+ int multibulk; /* multi bulk command format active */
list *reply;
int sentlen;
time_t lastinteraction; /* time of the last interaction, used for timeout */
redisClient *master; /* client that is master for this slave */
int replstate;
unsigned int maxclients;
- unsigned int maxmemory;
+ unsigned long maxmemory;
/* Sort parameters - qsort_r() is only available under BSD so we
* have to take this state global, in order to pass it to sortCompare() */
int sort_desc;
static int processCommand(redisClient *c);
static void setupSigSegvAction(void);
static void rdbRemoveTempFile(pid_t childpid);
+static size_t stringObjectLen(robj *o);
+static void processInputBuffer(redisClient *c);
static void authCommand(redisClient *c);
static void pingCommand(redisClient *c);
static void mgetCommand(redisClient *c);
static void monitorCommand(redisClient *c);
static void expireCommand(redisClient *c);
-static void getSetCommand(redisClient *c);
+static void getsetCommand(redisClient *c);
static void ttlCommand(redisClient *c);
static void slaveofCommand(redisClient *c);
static void debugCommand(redisClient *c);
+static void msetCommand(redisClient *c);
+static void msetnxCommand(redisClient *c);
+
/*================================= Globals ================================= */
/* Global vars */
{"smembers",sinterCommand,2,REDIS_CMD_INLINE},
{"incrby",incrbyCommand,3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM},
{"decrby",decrbyCommand,3,REDIS_CMD_INLINE|REDIS_CMD_DENYOOM},
- {"getset",getSetCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM},
+ {"getset",getsetCommand,3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM},
+ {"mset",msetCommand,-3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM},
+ {"msetnx",msetnxCommand,-3,REDIS_CMD_BULK|REDIS_CMD_DENYOOM},
{"randomkey",randomkeyCommand,1,REDIS_CMD_INLINE},
{"select",selectCommand,2,REDIS_CMD_INLINE},
{"move",moveCommand,3,REDIS_CMD_INLINE},
} else if (!strcasecmp(argv[0],"maxclients") && argc == 2) {
server.maxclients = atoi(argv[1]);
} else if (!strcasecmp(argv[0],"maxmemory") && argc == 2) {
- server.maxmemory = atoi(argv[1]);
+ server.maxmemory = strtoll(argv[1], NULL, 10);
} else if (!strcasecmp(argv[0],"slaveof") && argc == 3) {
server.masterhost = sdsnew(argv[1]);
server.masterport = atoi(argv[2]);
for (j = 0; j < c->argc; j++)
decrRefCount(c->argv[j]);
+ for (j = 0; j < c->mbargc; j++)
+ decrRefCount(c->mbargv[j]);
c->argc = 0;
+ c->mbargc = 0;
}
static void freeClient(redisClient *c) {
server.replstate = REDIS_REPL_CONNECT;
}
zfree(c->argv);
+ zfree(c->mbargv);
zfree(c);
}
static void resetClient(redisClient *c) {
freeClientArgv(c);
c->bulklen = -1;
+ c->multibulk = 0;
}
/* If this function gets called we already read a whole
/* Free some memory if needed (maxmemory setting) */
if (server.maxmemory) freeMemoryIfNeeded();
+ /* Handle the multi bulk command type. This is an alternative protocol
+ * supported by Redis in order to receive commands that are composed of
+ * multiple binary-safe "bulk" arguments. The latency of processing is
+ * a bit higher but this allows things like multi-sets, so if this
+ * protocol is used only for MSET and similar commands this is a big win. */
+ if (c->multibulk == 0 && c->argc == 1 && ((char*)(c->argv[0]->ptr))[0] == '*') {
+ c->multibulk = atoi(((char*)c->argv[0]->ptr)+1);
+ if (c->multibulk <= 0) {
+ resetClient(c);
+ return 1;
+ } else {
+ decrRefCount(c->argv[c->argc-1]);
+ c->argc--;
+ return 1;
+ }
+ } else if (c->multibulk) {
+ if (c->bulklen == -1) {
+ if (((char*)c->argv[0]->ptr)[0] != '$') {
+ addReplySds(c,sdsnew("-ERR multi bulk protocol error\r\n"));
+ resetClient(c);
+ return 1;
+ } else {
+ int bulklen = atoi(((char*)c->argv[0]->ptr)+1);
+ decrRefCount(c->argv[0]);
+ if (bulklen < 0 || bulklen > 1024*1024*1024) {
+ c->argc--;
+ addReplySds(c,sdsnew("-ERR invalid bulk write count\r\n"));
+ resetClient(c);
+ return 1;
+ }
+ c->argc--;
+ c->bulklen = bulklen+2; /* add two bytes for CR+LF */
+ /*
+ if (sdslen(c->querybuf) > 0)
+ processInputBuffer(c);
+ */
+ return 1;
+ }
+ } else {
+ c->mbargv = zrealloc(c->mbargv,(sizeof(robj*))*(c->mbargc+1));
+ c->mbargv[c->mbargc] = c->argv[0];
+ c->mbargc++;
+ c->argc--;
+ c->multibulk--;
+ if (c->multibulk == 0) {
+ robj **auxargv;
+ int auxargc;
+
+ /* Here we need to swap the multi-bulk argc/argv with the
+ * normal argc/argv of the client structure. */
+ auxargv = c->argv;
+ c->argv = c->mbargv;
+ c->mbargv = auxargv;
+
+ auxargc = c->argc;
+ c->argc = c->mbargc;
+ c->mbargc = auxargc;
+
+ /* We need to set bulklen to something different than -1
+ * in order for the code below to process the command without
+ * to try to read the last argument of a bulk command as
+ * a special argument. */
+ c->bulklen = 0;
+ /* continue below and process the command */
+ } else {
+ c->bulklen = -1;
+ /*
+ if (sdslen(c->querybuf) > 0)
+ processInputBuffer(c);
+ */
+ return 1;
+ }
+ }
+ }
+ /* -- end of multi bulk commands processing -- */
+
/* The QUIT command is handled as a special case. Normal command
* procs are unable to close the client connection safely */
if (!strcasecmp(c->argv[0]->ptr,"quit")) {
robj *lenobj;
lenobj = createObject(REDIS_STRING,
- sdscatprintf(sdsempty(),"%d\r\n",sdslen(argv[j]->ptr)));
+ sdscatprintf(sdsempty(),"%d\r\n",
+ stringObjectLen(argv[j])));
lenobj->refcount = 0;
outv[outc++] = lenobj;
}
if (outv != static_outv) zfree(outv);
}
-static void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {
- redisClient *c = (redisClient*) privdata;
- char buf[REDIS_IOBUF_LEN];
- int nread;
- REDIS_NOTUSED(el);
- REDIS_NOTUSED(mask);
-
- nread = read(fd, buf, REDIS_IOBUF_LEN);
- if (nread == -1) {
- if (errno == EAGAIN) {
- nread = 0;
- } else {
- redisLog(REDIS_DEBUG, "Reading from client: %s",strerror(errno));
- freeClient(c);
- return;
- }
- } else if (nread == 0) {
- redisLog(REDIS_DEBUG, "Client closed connection");
- freeClient(c);
- return;
- }
- if (nread) {
- c->querybuf = sdscatlen(c->querybuf, buf, nread);
- c->lastinteraction = time(NULL);
- } else {
- return;
- }
-
+static void processInputBuffer(redisClient *c) {
again:
if (c->bulklen == -1) {
/* Read the first line of the query */
c->argv[c->argc] = createStringObject(c->querybuf,c->bulklen-2);
c->argc++;
c->querybuf = sdsrange(c->querybuf,c->bulklen,-1);
- processCommand(c);
+ /* Process the command. If the client is still valid after
+ * the processing and there is more data in the buffer
+ * try to parse it. */
+ if (processCommand(c) && sdslen(c->querybuf)) goto again;
+ return;
+ }
+ }
+}
+
+static void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {
+ redisClient *c = (redisClient*) privdata;
+ char buf[REDIS_IOBUF_LEN];
+ int nread;
+ REDIS_NOTUSED(el);
+ REDIS_NOTUSED(mask);
+
+ nread = read(fd, buf, REDIS_IOBUF_LEN);
+ if (nread == -1) {
+ if (errno == EAGAIN) {
+ nread = 0;
+ } else {
+ redisLog(REDIS_DEBUG, "Reading from client: %s",strerror(errno));
+ freeClient(c);
return;
}
+ } else if (nread == 0) {
+ redisLog(REDIS_DEBUG, "Client closed connection");
+ freeClient(c);
+ return;
+ }
+ if (nread) {
+ c->querybuf = sdscatlen(c->querybuf, buf, nread);
+ c->lastinteraction = time(NULL);
+ } else {
+ return;
}
+ processInputBuffer(c);
}
static int selectDb(redisClient *c, int id) {
c->argc = 0;
c->argv = NULL;
c->bulklen = -1;
+ c->multibulk = 0;
+ c->mbargc = 0;
+ c->mbargv = NULL;
c->sentlen = 0;
c->flags = 0;
c->lastinteraction = time(NULL);
}
}
+/* Check if the nul-terminated string 's' can be represented by a long
+ * (that is, is a number that fits into long without any other space or
+ * character before or after the digits).
+ *
+ * If so, the function returns REDIS_OK and *longval is set to the value
+ * of the number. Otherwise REDIS_ERR is returned */
+static int isStringRepresentableAsLong(char *s, long *longval) {
+ char buf[32], *endptr;
+ long value;
+ int slen;
+
+ value = strtol(s, &endptr, 10);
+ if (endptr[0] != '\0') return REDIS_ERR;
+ slen = snprintf(buf,32,"%ld",value);
+
+ /* If the number converted back into a string is not identical
+ * then it's not possible to encode the string as integer */
+ if (strlen(buf) != (unsigned)slen || memcmp(buf,s,slen)) return REDIS_ERR;
+ if (longval) *longval = value;
+ return REDIS_OK;
+}
+
/* Try to encode a string object in order to save space */
static int tryObjectEncoding(robj *o) {
long value;
- char *endptr, buf[32];
sds s = o->ptr;
if (o->encoding != REDIS_ENCODING_RAW)
/* Currently we try to encode only strings */
assert(o->type == REDIS_STRING);
- /* Check if it's possible to encode this value as a long. We are assuming
- * that sizeof(long) = sizeof(void) in all the supported archs. */
- value = strtol(s, &endptr, 10);
- if (endptr[0] != '\0') return REDIS_ERR;
- snprintf(buf,32,"%ld",value);
-
- /* If the number converted back into a string is not identical
- * then it's not possible to encode the string as integer */
- if (strlen(buf) != sdslen(s) || memcmp(buf,s,sdslen(s))) return REDIS_ERR;
+ /* Check if we can represent this string as a long integer */
+ if (isStringRepresentableAsLong(s,&value) == REDIS_ERR) return REDIS_ERR;
/* Ok, this object can be encoded */
o->encoding = REDIS_ENCODING_INT;
}
}
+static int compareStringObjects(robj *a, robj *b) {
+ assert(a->type == REDIS_STRING && b->type == REDIS_STRING);
+
+ if (a->encoding == REDIS_ENCODING_INT && b->encoding == REDIS_ENCODING_INT){
+ return (long)a->ptr - (long)b->ptr;
+ } else {
+ int retval;
+
+ incrRefCount(a);
+ incrRefCount(b);
+ if (a->encoding != REDIS_ENCODING_RAW) a = getDecodedObject(a);
+ if (b->encoding != REDIS_ENCODING_RAW) b = getDecodedObject(a);
+ retval = sdscmp(a->ptr,b->ptr);
+ decrRefCount(a);
+ decrRefCount(b);
+ return retval;
+ }
+}
+
+static size_t stringObjectLen(robj *o) {
+ assert(o->type == REDIS_STRING);
+ if (o->encoding == REDIS_ENCODING_RAW) {
+ return sdslen(o->ptr);
+ } else {
+ char buf[32];
+
+ return snprintf(buf,32,"%ld",(long)o->ptr);
+ }
+}
+
/*============================ DB saving/loading ============================ */
static int rdbSaveType(FILE *fp, unsigned char type) {
}
}
-static void getSetCommand(redisClient *c) {
+static void getsetCommand(redisClient *c) {
getCommand(c);
if (dictAdd(c->db->dict,c->argv[1],c->argv[2]) == DICT_ERR) {
dictReplace(c->db->dict,c->argv[1],c->argv[2]);
robj *ele = listNodeValue(ln);
next = fromtail ? ln->prev : ln->next;
- if (sdscmp(ele->ptr,c->argv[3]->ptr) == 0) {
+ if (compareStringObjects(ele,c->argv[3]) == 0) {
listDelNode(list,ln);
server.dirty++;
removed++;
if (byval->encoding == REDIS_ENCODING_RAW) {
vector[j].u.score = strtod(byval->ptr,NULL);
} else {
- if (byval->encoding == REDIS_ENCODING_INT)
+ if (byval->encoding == REDIS_ENCODING_INT) {
vector[j].u.score = (long)byval->ptr;
- else
+ } else
assert(1 != 1);
}
}
info = sdscatprintf(sdsempty(),
"redis_version:%s\r\n"
+ "arch_bits:%s\r\n"
"uptime_in_seconds:%d\r\n"
"uptime_in_days:%d\r\n"
"connected_clients:%d\r\n"
"total_commands_processed:%lld\r\n"
"role:%s\r\n"
,REDIS_VERSION,
+ (sizeof(long) == 8) ? "64" : "32",
uptime,
uptime/(3600*24),
listLength(server.clients)-listLength(server.slaves),
addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",ttl));
}
+static void msetGenericCommand(redisClient *c, int nx) {
+ int j;
+
+ if ((c->argc % 2) == 0) {
+ addReplySds(c,sdsnew("-ERR wrong number of arguments\r\n"));
+ return;
+ }
+ /* Handle the NX flag. The MSETNX semantic is to return zero and don't
+ * set nothing at all if at least one already key exists. */
+ if (nx) {
+ for (j = 1; j < c->argc; j += 2) {
+ if (dictFind(c->db->dict,c->argv[j]) != NULL) {
+ addReply(c, shared.czero);
+ return;
+ }
+ }
+ }
+
+ for (j = 1; j < c->argc; j += 2) {
+ dictAdd(c->db->dict,c->argv[j],c->argv[j+1]);
+ incrRefCount(c->argv[j]);
+ incrRefCount(c->argv[j+1]);
+ removeExpire(c->db,c->argv[j]);
+ }
+ server.dirty += (c->argc-1)/2;
+ addReply(c, nx ? shared.cone : shared.ok);
+}
+
+static void msetCommand(redisClient *c) {
+ msetGenericCommand(c,0);
+}
+
+static void msetnxCommand(redisClient *c) {
+ msetGenericCommand(c,1);
+}
+
/* =============================== Replication ============================= */
static int syncWrite(int fd, char *ptr, ssize_t size, int timeout) {
#ifdef HAVE_BACKTRACE
static struct redisFunctionSym symsTable[] = {
+{"compareStringObjects", (unsigned long)compareStringObjects},
+{"isStringRepresentableAsLong", (unsigned long)isStringRepresentableAsLong},
{"dictEncObjKeyCompare", (unsigned long)dictEncObjKeyCompare},
{"dictEncObjHash", (unsigned long)dictEncObjHash},
{"incrDecrCommand", (unsigned long)incrDecrCommand},
{"mgetCommand", (unsigned long)mgetCommand},
{"monitorCommand", (unsigned long)monitorCommand},
{"expireCommand", (unsigned long)expireCommand},
-{"getSetCommand", (unsigned long)getSetCommand},
+{"getsetCommand", (unsigned long)getsetCommand},
{"ttlCommand", (unsigned long)ttlCommand},
{"slaveofCommand", (unsigned long)slaveofCommand},
{"debugCommand", (unsigned long)debugCommand},
{"setupSigSegvAction", (unsigned long)setupSigSegvAction},
{"readQueryFromClient", (unsigned long)readQueryFromClient},
{"rdbRemoveTempFile", (unsigned long)rdbRemoveTempFile},
+{"msetGenericCommand", (unsigned long)msetGenericCommand},
+{"msetCommand", (unsigned long)msetCommand},
+{"msetnxCommand", (unsigned long)msetnxCommand},
{NULL,0}
};
projects / redis.git / blobdiff