]> git.saurik.com Git - redis.git/blob - redis.c
projects / redis.git / blob
? search:


e74910ba093e45ed9b622925838e364397806a9e
[redis.git] / redis.c
1 /*
2 * Copyright (c) 2006-2009, Salvatore Sanfilippo <antirez at gmail dot com>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * * Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * * Neither the name of Redis nor the names of its contributors may be used
14 * to endorse or promote products derived from this software without
15 * specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
21 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 * POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #define REDIS_VERSION "0.091"
31
32 #include "fmacros.h"
33
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <time.h>
38 #include <unistd.h>
39 #include <signal.h>
40 #include <sys/wait.h>
41 #include <errno.h>
42 #include <assert.h>
43 #include <ctype.h>
44 #include <stdarg.h>
45 #include <inttypes.h>
46 #include <arpa/inet.h>
47 #include <sys/stat.h>
48 #include <fcntl.h>
49 #include <sys/time.h>
50 #include <sys/resource.h>
51 #include <limits.h>
52
53 #include "ae.h" /* Event driven programming library */
54 #include "sds.h" /* Dynamic safe strings */
55 #include "anet.h" /* Networking the easy way */
56 #include "dict.h" /* Hash tables */
57 #include "adlist.h" /* Linked lists */
58 #include "zmalloc.h" /* total memory usage aware version of malloc/free */
59 #include "lzf.h"
60
61 /* Error codes */
62 #define REDIS_OK 0
63 #define REDIS_ERR -1
64
65 /* Static server configuration */
66 #define REDIS_SERVERPORT 6379 /* TCP port */
67 #define REDIS_MAXIDLETIME (60*5) /* default client timeout */
68 #define REDIS_IOBUF_LEN 1024
69 #define REDIS_LOADBUF_LEN 1024
70 #define REDIS_MAX_ARGS 16
71 #define REDIS_DEFAULT_DBNUM 16
72 #define REDIS_CONFIGLINE_MAX 1024
73 #define REDIS_OBJFREELIST_MAX 1000000 /* Max number of objects to cache */
74 #define REDIS_MAX_SYNC_TIME 60 /* Slave can't take more to sync */
75 #define REDIS_EXPIRELOOKUPS_PER_CRON 100 /* try to expire 100 keys/second */
76
77 /* Hash table parameters */
78 #define REDIS_HT_MINFILL 10 /* Minimal hash table fill 10% */
79 #define REDIS_HT_MINSLOTS 16384 /* Never resize the HT under this */
80
81 /* Command flags */
82 #define REDIS_CMD_BULK 1
83 #define REDIS_CMD_INLINE 2
84
85 /* Object types */
86 #define REDIS_STRING 0
87 #define REDIS_LIST 1
88 #define REDIS_SET 2
89 #define REDIS_HASH 3
90
91 /* Object types only used for dumping to disk */
92 #define REDIS_EXPIRETIME 253
93 #define REDIS_SELECTDB 254
94 #define REDIS_EOF 255
95
96 /* Defines related to the dump file format. To store 32 bits lengths for short
97 * keys requires a lot of space, so we check the most significant 2 bits of
98 * the first byte to interpreter the length:
99 *
100 * 00|000000 => if the two MSB are 00 the len is the 6 bits of this byte
101 * 01|000000 00000000 => 01, the len is 14 byes, 6 bits + 8 bits of next byte
102 * 10|000000 [32 bit integer] => if it's 01, a full 32 bit len will follow
103 * 11|000000 this means: specially encoded object will follow. The six bits
104 * number specify the kind of object that follows.
105 * See the REDIS_RDB_ENC_* defines.
106 *
107 * Lenghts up to 63 are stored using a single byte, most DB keys, and may
108 * values, will fit inside. */
109 #define REDIS_RDB_6BITLEN 0
110 #define REDIS_RDB_14BITLEN 1
111 #define REDIS_RDB_32BITLEN 2
112 #define REDIS_RDB_ENCVAL 3
113 #define REDIS_RDB_LENERR UINT_MAX
114
115 /* When a length of a string object stored on disk has the first two bits
116 * set, the remaining two bits specify a special encoding for the object
117 * accordingly to the following defines: */
118 #define REDIS_RDB_ENC_INT8 0 /* 8 bit signed integer */
119 #define REDIS_RDB_ENC_INT16 1 /* 16 bit signed integer */
120 #define REDIS_RDB_ENC_INT32 2 /* 32 bit signed integer */
121 #define REDIS_RDB_ENC_LZF 3 /* string compressed with FASTLZ */
122
123 /* Client flags */
124 #define REDIS_CLOSE 1 /* This client connection should be closed ASAP */
125 #define REDIS_SLAVE 2 /* This client is a slave server */
126 #define REDIS_MASTER 4 /* This client is a master server */
127 #define REDIS_MONITOR 8 /* This client is a slave monitor, see MONITOR */
128
129 /* Slave replication state - slave side */
130 #define REDIS_REPL_NONE 0 /* No active replication */
131 #define REDIS_REPL_CONNECT 1 /* Must connect to master */
132 #define REDIS_REPL_CONNECTED 2 /* Connected to master */
133
134 /* Slave replication state - from the point of view of master
135 * Note that in SEND_BULK and ONLINE state the slave receives new updates
136 * in its output queue. In the WAIT_BGSAVE state instead the server is waiting
137 * to start the next background saving in order to send updates to it. */
138 #define REDIS_REPL_WAIT_BGSAVE_START 3 /* master waits bgsave to start feeding it */
139 #define REDIS_REPL_WAIT_BGSAVE_END 4 /* master waits bgsave to start bulk DB transmission */
140 #define REDIS_REPL_SEND_BULK 5 /* master is sending the bulk DB */
141 #define REDIS_REPL_ONLINE 6 /* bulk DB already transmitted, receive updates */
142
143 /* List related stuff */
144 #define REDIS_HEAD 0
145 #define REDIS_TAIL 1
146
147 /* Sort operations */
148 #define REDIS_SORT_GET 0
149 #define REDIS_SORT_DEL 1
150 #define REDIS_SORT_INCR 2
151 #define REDIS_SORT_DECR 3
152 #define REDIS_SORT_ASC 4
153 #define REDIS_SORT_DESC 5
154 #define REDIS_SORTKEY_MAX 1024
155
156 /* Log levels */
157 #define REDIS_DEBUG 0
158 #define REDIS_NOTICE 1
159 #define REDIS_WARNING 2
160
161 /* Anti-warning macro... */
162 #define REDIS_NOTUSED(V) ((void) V)
163
164 /*================================= Data types ============================== */
165
166 /* A redis object, that is a type able to hold a string / list / set */
167 typedef struct redisObject {
168 void *ptr;
169 int type;
170 int refcount;
171 } robj;
172
173 typedef struct redisDb {
174 dict *dict;
175 dict *expires;
176 int id;
177 } redisDb;
178
179 /* With multiplexing we need to take per-clinet state.
180 * Clients are taken in a liked list. */
181 typedef struct redisClient {
182 int fd;
183 redisDb *db;
184 int dictid;
185 sds querybuf;
186 robj *argv[REDIS_MAX_ARGS];
187 int argc;
188 int bulklen; /* bulk read len. -1 if not in bulk read mode */
189 list *reply;
190 int sentlen;
191 time_t lastinteraction; /* time of the last interaction, used for timeout */
192 int flags; /* REDIS_CLOSE | REDIS_SLAVE | REDIS_MONITOR */
193 int slaveseldb; /* slave selected db, if this client is a slave */
194 int authenticated; /* when requirepass is non-NULL */
195 int replstate; /* replication state if this is a slave */
196 int repldbfd; /* replication DB file descriptor */
197 long repldboff; /* replication DB file offset */
198 off_t repldbsize; /* replication DB file size */
199 } redisClient;
200
201 struct saveparam {
202 time_t seconds;
203 int changes;
204 };
205
206 /* Global server state structure */
207 struct redisServer {
208 int port;
209 int fd;
210 redisDb *db;
211 dict *sharingpool;
212 unsigned int sharingpoolsize;
213 long long dirty; /* changes to DB from the last save */
214 list *clients;
215 list *slaves, *monitors;
216 char neterr[ANET_ERR_LEN];
217 aeEventLoop *el;
218 int cronloops; /* number of times the cron function run */
219 list *objfreelist; /* A list of freed objects to avoid malloc() */
220 time_t lastsave; /* Unix time of last save succeeede */
221 size_t usedmemory; /* Used memory in megabytes */
222 /* Fields used only for stats */
223 time_t stat_starttime; /* server start time */
224 long long stat_numcommands; /* number of processed commands */
225 long long stat_numconnections; /* number of connections received */
226 /* Configuration */
227 int verbosity;
228 int glueoutputbuf;
229 int maxidletime;
230 int dbnum;
231 int daemonize;
232 char *pidfile;
233 int bgsaveinprogress;
234 struct saveparam *saveparams;
235 int saveparamslen;
236 char *logfile;
237 char *bindaddr;
238 char *dbfilename;
239 char *requirepass;
240 int shareobjects;
241 /* Replication related */
242 int isslave;
243 char *masterhost;
244 int masterport;
245 redisClient *master; /* client that is master for this slave */
246 int replstate;
247 /* Sort parameters - qsort_r() is only available under BSD so we
248 * have to take this state global, in order to pass it to sortCompare() */
249 int sort_desc;
250 int sort_alpha;
251 int sort_bypattern;
252 };
253
254 typedef void redisCommandProc(redisClient *c);
255 struct redisCommand {
256 char *name;
257 redisCommandProc *proc;
258 int arity;
259 int flags;
260 };
261
262 typedef struct _redisSortObject {
263 robj *obj;
264 union {
265 double score;
266 robj *cmpobj;
267 } u;
268 } redisSortObject;
269
270 typedef struct _redisSortOperation {
271 int type;
272 robj *pattern;
273 } redisSortOperation;
274
275 struct sharedObjectsStruct {
276 robj *crlf, *ok, *err, *emptybulk, *czero, *cone, *pong, *space,
277 *colon, *nullbulk, *nullmultibulk,
278 *emptymultibulk, *wrongtypeerr, *nokeyerr, *syntaxerr, *sameobjecterr,
279 *outofrangeerr, *plus,
280 *select0, *select1, *select2, *select3, *select4,
281 *select5, *select6, *select7, *select8, *select9;
282 } shared;
283
284 /*================================ Prototypes =============================== */
285
286 static void freeStringObject(robj *o);
287 static void freeListObject(robj *o);
288 static void freeSetObject(robj *o);
289 static void decrRefCount(void *o);
290 static robj *createObject(int type, void *ptr);
291 static void freeClient(redisClient *c);
292 static int rdbLoad(char *filename);
293 static void addReply(redisClient *c, robj *obj);
294 static void addReplySds(redisClient *c, sds s);
295 static void incrRefCount(robj *o);
296 static int rdbSaveBackground(char *filename);
297 static robj *createStringObject(char *ptr, size_t len);
298 static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int dictid, robj **argv, int argc);
299 static int syncWithMaster(void);
300 static robj *tryObjectSharing(robj *o);
301 static int removeExpire(redisDb *db, robj *key);
302 static int expireIfNeeded(redisDb *db, robj *key);
303 static int deleteIfVolatile(redisDb *db, robj *key);
304 static int deleteKey(redisDb *db, robj *key);
305 static time_t getExpire(redisDb *db, robj *key);
306 static int setExpire(redisDb *db, robj *key, time_t when);
307 static void updateSalvesWaitingBgsave(int bgsaveerr);
308
309 static void authCommand(redisClient *c);
310 static void pingCommand(redisClient *c);
311 static void echoCommand(redisClient *c);
312 static void setCommand(redisClient *c);
313 static void setnxCommand(redisClient *c);
314 static void getCommand(redisClient *c);
315 static void delCommand(redisClient *c);
316 static void existsCommand(redisClient *c);
317 static void incrCommand(redisClient *c);
318 static void decrCommand(redisClient *c);
319 static void incrbyCommand(redisClient *c);
320 static void decrbyCommand(redisClient *c);
321 static void selectCommand(redisClient *c);
322 static void randomkeyCommand(redisClient *c);
323 static void keysCommand(redisClient *c);
324 static void dbsizeCommand(redisClient *c);
325 static void lastsaveCommand(redisClient *c);
326 static void saveCommand(redisClient *c);
327 static void bgsaveCommand(redisClient *c);
328 static void shutdownCommand(redisClient *c);
329 static void moveCommand(redisClient *c);
330 static void renameCommand(redisClient *c);
331 static void renamenxCommand(redisClient *c);
332 static void lpushCommand(redisClient *c);
333 static void rpushCommand(redisClient *c);
334 static void lpopCommand(redisClient *c);
335 static void rpopCommand(redisClient *c);
336 static void llenCommand(redisClient *c);
337 static void lindexCommand(redisClient *c);
338 static void lrangeCommand(redisClient *c);
339 static void ltrimCommand(redisClient *c);
340 static void typeCommand(redisClient *c);
341 static void lsetCommand(redisClient *c);
342 static void saddCommand(redisClient *c);
343 static void sremCommand(redisClient *c);
344 static void sismemberCommand(redisClient *c);
345 static void scardCommand(redisClient *c);
346 static void sinterCommand(redisClient *c);
347 static void sinterstoreCommand(redisClient *c);
348 static void sunionCommand(redisClient *c);
349 static void sunionstoreCommand(redisClient *c);
350 static void syncCommand(redisClient *c);
351 static void flushdbCommand(redisClient *c);
352 static void flushallCommand(redisClient *c);
353 static void sortCommand(redisClient *c);
354 static void lremCommand(redisClient *c);
355 static void infoCommand(redisClient *c);
356 static void mgetCommand(redisClient *c);
357 static void monitorCommand(redisClient *c);
358 static void expireCommand(redisClient *c);
359
360 /*================================= Globals ================================= */
361
362 /* Global vars */
363 static struct redisServer server; /* server global state */
364 static struct redisCommand cmdTable[] = {
365 {"get",getCommand,2,REDIS_CMD_INLINE},
366 {"set",setCommand,3,REDIS_CMD_BULK},
367 {"setnx",setnxCommand,3,REDIS_CMD_BULK},
368 {"del",delCommand,2,REDIS_CMD_INLINE},
369 {"exists",existsCommand,2,REDIS_CMD_INLINE},
370 {"incr",incrCommand,2,REDIS_CMD_INLINE},
371 {"decr",decrCommand,2,REDIS_CMD_INLINE},
372 {"mget",mgetCommand,-2,REDIS_CMD_INLINE},
373 {"rpush",rpushCommand,3,REDIS_CMD_BULK},
374 {"lpush",lpushCommand,3,REDIS_CMD_BULK},
375 {"rpop",rpopCommand,2,REDIS_CMD_INLINE},
376 {"lpop",lpopCommand,2,REDIS_CMD_INLINE},
377 {"llen",llenCommand,2,REDIS_CMD_INLINE},
378 {"lindex",lindexCommand,3,REDIS_CMD_INLINE},
379 {"lset",lsetCommand,4,REDIS_CMD_BULK},
380 {"lrange",lrangeCommand,4,REDIS_CMD_INLINE},
381 {"ltrim",ltrimCommand,4,REDIS_CMD_INLINE},
382 {"lrem",lremCommand,4,REDIS_CMD_BULK},
383 {"sadd",saddCommand,3,REDIS_CMD_BULK},
384 {"srem",sremCommand,3,REDIS_CMD_BULK},
385 {"sismember",sismemberCommand,3,REDIS_CMD_BULK},
386 {"scard",scardCommand,2,REDIS_CMD_INLINE},
387 {"sinter",sinterCommand,-2,REDIS_CMD_INLINE},
388 {"sinterstore",sinterstoreCommand,-3,REDIS_CMD_INLINE},
389 {"sunion",sunionCommand,-2,REDIS_CMD_INLINE},
390 {"sunionstore",sunionstoreCommand,-3,REDIS_CMD_INLINE},
391 {"smembers",sinterCommand,2,REDIS_CMD_INLINE},
392 {"incrby",incrbyCommand,3,REDIS_CMD_INLINE},
393 {"decrby",decrbyCommand,3,REDIS_CMD_INLINE},
394 {"randomkey",randomkeyCommand,1,REDIS_CMD_INLINE},
395 {"select",selectCommand,2,REDIS_CMD_INLINE},
396 {"move",moveCommand,3,REDIS_CMD_INLINE},
397 {"rename",renameCommand,3,REDIS_CMD_INLINE},
398 {"renamenx",renamenxCommand,3,REDIS_CMD_INLINE},
399 {"keys",keysCommand,2,REDIS_CMD_INLINE},
400 {"dbsize",dbsizeCommand,1,REDIS_CMD_INLINE},
401 {"auth",authCommand,2,REDIS_CMD_INLINE},
402 {"ping",pingCommand,1,REDIS_CMD_INLINE},
403 {"echo",echoCommand,2,REDIS_CMD_BULK},
404 {"save",saveCommand,1,REDIS_CMD_INLINE},
405 {"bgsave",bgsaveCommand,1,REDIS_CMD_INLINE},
406 {"shutdown",shutdownCommand,1,REDIS_CMD_INLINE},
407 {"lastsave",lastsaveCommand,1,REDIS_CMD_INLINE},
408 {"type",typeCommand,2,REDIS_CMD_INLINE},
409 {"sync",syncCommand,1,REDIS_CMD_INLINE},
410 {"flushdb",flushdbCommand,1,REDIS_CMD_INLINE},
411 {"flushall",flushallCommand,1,REDIS_CMD_INLINE},
412 {"sort",sortCommand,-2,REDIS_CMD_INLINE},
413 {"info",infoCommand,1,REDIS_CMD_INLINE},
414 {"monitor",monitorCommand,1,REDIS_CMD_INLINE},
415 {"expire",expireCommand,3,REDIS_CMD_INLINE},
416 {NULL,NULL,0,0}
417 };
418
419 /*============================ Utility functions ============================ */
420
421 /* Glob-style pattern matching. */
422 int stringmatchlen(const char *pattern, int patternLen,
423 const char *string, int stringLen, int nocase)
424 {
425 while(patternLen) {
426 switch(pattern[0]) {
427 case '*':
428 while (pattern[1] == '*') {
429 pattern++;
430 patternLen--;
431 }
432 if (patternLen == 1)
433 return 1; /* match */
434 while(stringLen) {
435 if (stringmatchlen(pattern+1, patternLen-1,
436 string, stringLen, nocase))
437 return 1; /* match */
438 string++;
439 stringLen--;
440 }
441 return 0; /* no match */
442 break;
443 case '?':
444 if (stringLen == 0)
445 return 0; /* no match */
446 string++;
447 stringLen--;
448 break;
449 case '[':
450 {
451 int not, match;
452
453 pattern++;
454 patternLen--;
455 not = pattern[0] == '^';
456 if (not) {
457 pattern++;
458 patternLen--;
459 }
460 match = 0;
461 while(1) {
462 if (pattern[0] == '\\') {
463 pattern++;
464 patternLen--;
465 if (pattern[0] == string[0])
466 match = 1;
467 } else if (pattern[0] == ']') {
468 break;
469 } else if (patternLen == 0) {
470 pattern--;
471 patternLen++;
472 break;
473 } else if (pattern[1] == '-' && patternLen >= 3) {
474 int start = pattern[0];
475 int end = pattern[2];
476 int c = string[0];
477 if (start > end) {
478 int t = start;
479 start = end;
480 end = t;
481 }
482 if (nocase) {
483 start = tolower(start);
484 end = tolower(end);
485 c = tolower(c);
486 }
487 pattern += 2;
488 patternLen -= 2;
489 if (c >= start && c <= end)
490 match = 1;
491 } else {
492 if (!nocase) {
493 if (pattern[0] == string[0])
494 match = 1;
495 } else {
496 if (tolower((int)pattern[0]) == tolower((int)string[0]))
497 match = 1;
498 }
499 }
500 pattern++;
501 patternLen--;
502 }
503 if (not)
504 match = !match;
505 if (!match)
506 return 0; /* no match */
507 string++;
508 stringLen--;
509 break;
510 }
511 case '\\':
512 if (patternLen >= 2) {
513 pattern++;
514 patternLen--;
515 }
516 /* fall through */
517 default:
518 if (!nocase) {
519 if (pattern[0] != string[0])
520 return 0; /* no match */
521 } else {
522 if (tolower((int)pattern[0]) != tolower((int)string[0]))
523 return 0; /* no match */
524 }
525 string++;
526 stringLen--;
527 break;
528 }
529 pattern++;
530 patternLen--;
531 if (stringLen == 0) {
532 while(*pattern == '*') {
533 pattern++;
534 patternLen--;
535 }
536 break;
537 }
538 }
539 if (patternLen == 0 && stringLen == 0)
540 return 1;
541 return 0;
542 }
543
544 void redisLog(int level, const char *fmt, ...)
545 {
546 va_list ap;
547 FILE *fp;
548
549 fp = (server.logfile == NULL) ? stdout : fopen(server.logfile,"a");
550 if (!fp) return;
551
552 va_start(ap, fmt);
553 if (level >= server.verbosity) {
554 char *c = ".-*";
555 fprintf(fp,"%c ",c[level]);
556 vfprintf(fp, fmt, ap);
557 fprintf(fp,"\n");
558 fflush(fp);
559 }
560 va_end(ap);
561
562 if (server.logfile) fclose(fp);
563 }
564
565 /*====================== Hash table type implementation ==================== */
566
567 /* This is an hash table type that uses the SDS dynamic strings libary as
568 * keys and radis objects as values (objects can hold SDS strings,
569 * lists, sets). */
570
571 static int sdsDictKeyCompare(void *privdata, const void *key1,
572 const void *key2)
573 {
574 int l1,l2;
575 DICT_NOTUSED(privdata);
576
577 l1 = sdslen((sds)key1);
578 l2 = sdslen((sds)key2);
579 if (l1 != l2) return 0;
580 return memcmp(key1, key2, l1) == 0;
581 }
582
583 static void dictRedisObjectDestructor(void *privdata, void *val)
584 {
585 DICT_NOTUSED(privdata);
586
587 decrRefCount(val);
588 }
589
590 static int dictSdsKeyCompare(void *privdata, const void *key1,
591 const void *key2)
592 {
593 const robj *o1 = key1, *o2 = key2;
594 return sdsDictKeyCompare(privdata,o1->ptr,o2->ptr);
595 }
596
597 static unsigned int dictSdsHash(const void *key) {
598 const robj *o = key;
599 return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
600 }
601
602 static dictType setDictType = {
603 dictSdsHash, /* hash function */
604 NULL, /* key dup */
605 NULL, /* val dup */
606 dictSdsKeyCompare, /* key compare */
607 dictRedisObjectDestructor, /* key destructor */
608 NULL /* val destructor */
609 };
610
611 static dictType hashDictType = {
612 dictSdsHash, /* hash function */
613 NULL, /* key dup */
614 NULL, /* val dup */
615 dictSdsKeyCompare, /* key compare */
616 dictRedisObjectDestructor, /* key destructor */
617 dictRedisObjectDestructor /* val destructor */
618 };
619
620 /* ========================= Random utility functions ======================= */
621
622 /* Redis generally does not try to recover from out of memory conditions
623 * when allocating objects or strings, it is not clear if it will be possible
624 * to report this condition to the client since the networking layer itself
625 * is based on heap allocation for send buffers, so we simply abort.
626 * At least the code will be simpler to read... */
627 static void oom(const char *msg) {
628 fprintf(stderr, "%s: Out of memory\n",msg);
629 fflush(stderr);
630 sleep(1);
631 abort();
632 }
633
634 /* ====================== Redis server networking stuff ===================== */
635 void closeTimedoutClients(void) {
636 redisClient *c;
637 listNode *ln;
638 time_t now = time(NULL);
639
640 listRewind(server.clients);
641 while ((ln = listYield(server.clients)) != NULL) {
642 c = listNodeValue(ln);
643 if (!(c->flags & REDIS_SLAVE) && /* no timeout for slaves */
644 (now - c->lastinteraction > server.maxidletime)) {
645 redisLog(REDIS_DEBUG,"Closing idle client");
646 freeClient(c);
647 }
648 }
649 }
650
651 int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
652 int j, loops = server.cronloops++;
653 REDIS_NOTUSED(eventLoop);
654 REDIS_NOTUSED(id);
655 REDIS_NOTUSED(clientData);
656
657 /* Update the global state with the amount of used memory */
658 server.usedmemory = zmalloc_used_memory();
659
660 /* If the percentage of used slots in the HT reaches REDIS_HT_MINFILL
661 * we resize the hash table to save memory */
662 for (j = 0; j < server.dbnum; j++) {
663 int size, used, vkeys;
664
665 size = dictSlots(server.db[j].dict);
666 used = dictSize(server.db[j].dict);
667 vkeys = dictSize(server.db[j].expires);
668 if (!(loops % 5) && used > 0) {
669 redisLog(REDIS_DEBUG,"DB %d: %d keys (%d volatile) in %d slots HT.",j,used,vkeys,size);
670 /* dictPrintStats(server.dict); */
671 }
672 if (size && used && size > REDIS_HT_MINSLOTS &&
673 (used*100/size < REDIS_HT_MINFILL)) {
674 redisLog(REDIS_NOTICE,"The hash table %d is too sparse, resize it...",j);
675 dictResize(server.db[j].dict);
676 redisLog(REDIS_NOTICE,"Hash table %d resized.",j);
677 }
678 }
679
680 /* Show information about connected clients */
681 if (!(loops % 5)) {
682 redisLog(REDIS_DEBUG,"%d clients connected (%d slaves), %zu bytes in use",
683 listLength(server.clients)-listLength(server.slaves),
684 listLength(server.slaves),
685 server.usedmemory,
686 dictSize(server.sharingpool));
687 }
688
689 /* Close connections of timedout clients */
690 if (!(loops % 10))
691 closeTimedoutClients();
692
693 /* Check if a background saving in progress terminated */
694 if (server.bgsaveinprogress) {
695 int statloc;
696 /* XXX: TODO handle the case of the saving child killed */
697 if (wait4(-1,&statloc,WNOHANG,NULL)) {
698 int exitcode = WEXITSTATUS(statloc);
699 if (exitcode == 0) {
700 redisLog(REDIS_NOTICE,
701 "Background saving terminated with success");
702 server.dirty = 0;
703 server.lastsave = time(NULL);
704 } else {
705 redisLog(REDIS_WARNING,
706 "Background saving error");
707 }
708 server.bgsaveinprogress = 0;
709 updateSalvesWaitingBgsave(exitcode == 0 ? REDIS_OK : REDIS_ERR);
710 }
711 } else {
712 /* If there is not a background saving in progress check if
713 * we have to save now */
714 time_t now = time(NULL);
715 for (j = 0; j < server.saveparamslen; j++) {
716 struct saveparam *sp = server.saveparams+j;
717
718 if (server.dirty >= sp->changes &&
719 now-server.lastsave > sp->seconds) {
720 redisLog(REDIS_NOTICE,"%d changes in %d seconds. Saving...",
721 sp->changes, sp->seconds);
722 rdbSaveBackground(server.dbfilename);
723 break;
724 }
725 }
726 }
727
728 /* Try to expire a few timed out keys */
729 for (j = 0; j < server.dbnum; j++) {
730 redisDb *db = server.db+j;
731 int num = dictSize(db->expires);
732
733 if (num) {
734 time_t now = time(NULL);
735
736 if (num > REDIS_EXPIRELOOKUPS_PER_CRON)
737 num = REDIS_EXPIRELOOKUPS_PER_CRON;
738 while (num--) {
739 dictEntry *de;
740 time_t t;
741
742 if ((de = dictGetRandomKey(db->expires)) == NULL) break;
743 t = (time_t) dictGetEntryVal(de);
744 if (now > t) {
745 deleteKey(db,dictGetEntryKey(de));
746 }
747 }
748 }
749 }
750
751 /* Check if we should connect to a MASTER */
752 if (server.replstate == REDIS_REPL_CONNECT) {
753 redisLog(REDIS_NOTICE,"Connecting to MASTER...");
754 if (syncWithMaster() == REDIS_OK) {
755 redisLog(REDIS_NOTICE,"MASTER <-> SLAVE sync succeeded");
756 }
757 }
758 return 1000;
759 }
760
761 static void createSharedObjects(void) {
762 shared.crlf = createObject(REDIS_STRING,sdsnew("\r\n"));
763 shared.ok = createObject(REDIS_STRING,sdsnew("+OK\r\n"));
764 shared.err = createObject(REDIS_STRING,sdsnew("-ERR\r\n"));
765 shared.emptybulk = createObject(REDIS_STRING,sdsnew("$0\r\n\r\n"));
766 shared.czero = createObject(REDIS_STRING,sdsnew(":0\r\n"));
767 shared.cone = createObject(REDIS_STRING,sdsnew(":1\r\n"));
768 shared.nullbulk = createObject(REDIS_STRING,sdsnew("$-1\r\n"));
769 shared.nullmultibulk = createObject(REDIS_STRING,sdsnew("*-1\r\n"));
770 shared.emptymultibulk = createObject(REDIS_STRING,sdsnew("*0\r\n"));
771 /* no such key */
772 shared.pong = createObject(REDIS_STRING,sdsnew("+PONG\r\n"));
773 shared.wrongtypeerr = createObject(REDIS_STRING,sdsnew(
774 "-ERR Operation against a key holding the wrong kind of value\r\n"));
775 shared.nokeyerr = createObject(REDIS_STRING,sdsnew(
776 "-ERR no such key\r\n"));
777 shared.syntaxerr = createObject(REDIS_STRING,sdsnew(
778 "-ERR syntax error\r\n"));
779 shared.sameobjecterr = createObject(REDIS_STRING,sdsnew(
780 "-ERR source and destination objects are the same\r\n"));
781 shared.outofrangeerr = createObject(REDIS_STRING,sdsnew(
782 "-ERR index out of range\r\n"));
783 shared.space = createObject(REDIS_STRING,sdsnew(" "));
784 shared.colon = createObject(REDIS_STRING,sdsnew(":"));
785 shared.plus = createObject(REDIS_STRING,sdsnew("+"));
786 shared.select0 = createStringObject("select 0\r\n",10);
787 shared.select1 = createStringObject("select 1\r\n",10);
788 shared.select2 = createStringObject("select 2\r\n",10);
789 shared.select3 = createStringObject("select 3\r\n",10);
790 shared.select4 = createStringObject("select 4\r\n",10);
791 shared.select5 = createStringObject("select 5\r\n",10);
792 shared.select6 = createStringObject("select 6\r\n",10);
793 shared.select7 = createStringObject("select 7\r\n",10);
794 shared.select8 = createStringObject("select 8\r\n",10);
795 shared.select9 = createStringObject("select 9\r\n",10);
796 }
797
798 static void appendServerSaveParams(time_t seconds, int changes) {
799 server.saveparams = zrealloc(server.saveparams,sizeof(struct saveparam)*(server.saveparamslen+1));
800 if (server.saveparams == NULL) oom("appendServerSaveParams");
801 server.saveparams[server.saveparamslen].seconds = seconds;
802 server.saveparams[server.saveparamslen].changes = changes;
803 server.saveparamslen++;
804 }
805
806 static void ResetServerSaveParams() {
807 zfree(server.saveparams);
808 server.saveparams = NULL;
809 server.saveparamslen = 0;
810 }
811
812 static void initServerConfig() {
813 server.dbnum = REDIS_DEFAULT_DBNUM;
814 server.port = REDIS_SERVERPORT;
815 server.verbosity = REDIS_DEBUG;
816 server.maxidletime = REDIS_MAXIDLETIME;
817 server.saveparams = NULL;
818 server.logfile = NULL; /* NULL = log on standard output */
819 server.bindaddr = NULL;
820 server.glueoutputbuf = 1;
821 server.daemonize = 0;
822 server.pidfile = "/var/run/redis.pid";
823 server.dbfilename = "dump.rdb";
824 server.requirepass = NULL;
825 server.shareobjects = 0;
826 ResetServerSaveParams();
827
828 appendServerSaveParams(60*60,1); /* save after 1 hour and 1 change */
829 appendServerSaveParams(300,100); /* save after 5 minutes and 100 changes */
830 appendServerSaveParams(60,10000); /* save after 1 minute and 10000 changes */
831 /* Replication related */
832 server.isslave = 0;
833 server.masterhost = NULL;
834 server.masterport = 6379;
835 server.master = NULL;
836 server.replstate = REDIS_REPL_NONE;
837 }
838
839 static void initServer() {
840 int j;
841
842 signal(SIGHUP, SIG_IGN);
843 signal(SIGPIPE, SIG_IGN);
844
845 server.clients = listCreate();
846 server.slaves = listCreate();
847 server.monitors = listCreate();
848 server.objfreelist = listCreate();
849 createSharedObjects();
850 server.el = aeCreateEventLoop();
851 server.db = zmalloc(sizeof(redisDb)*server.dbnum);
852 server.sharingpool = dictCreate(&setDictType,NULL);
853 server.sharingpoolsize = 1024;
854 if (!server.db || !server.clients || !server.slaves || !server.monitors || !server.el || !server.objfreelist)
855 oom("server initialization"); /* Fatal OOM */
856 server.fd = anetTcpServer(server.neterr, server.port, server.bindaddr);
857 if (server.fd == -1) {
858 redisLog(REDIS_WARNING, "Opening TCP port: %s", server.neterr);
859 exit(1);
860 }
861 for (j = 0; j < server.dbnum; j++) {
862 server.db[j].dict = dictCreate(&hashDictType,NULL);
863 server.db[j].expires = dictCreate(&setDictType,NULL);
864 server.db[j].id = j;
865 }
866 server.cronloops = 0;
867 server.bgsaveinprogress = 0;
868 server.lastsave = time(NULL);
869 server.dirty = 0;
870 server.usedmemory = 0;
871 server.stat_numcommands = 0;
872 server.stat_numconnections = 0;
873 server.stat_starttime = time(NULL);
874 aeCreateTimeEvent(server.el, 1000, serverCron, NULL, NULL);
875 }
876
877 /* Empty the whole database */
878 static long long emptyDb() {
879 int j;
880 long long removed = 0;
881
882 for (j = 0; j < server.dbnum; j++) {
883 removed += dictSize(server.db[j].dict);
884 dictEmpty(server.db[j].dict);
885 dictEmpty(server.db[j].expires);
886 }
887 return removed;
888 }
889
890 /* I agree, this is a very rudimental way to load a configuration...
891 will improve later if the config gets more complex */
892 static void loadServerConfig(char *filename) {
893 FILE *fp = fopen(filename,"r");
894 char buf[REDIS_CONFIGLINE_MAX+1], *err = NULL;
895 int linenum = 0;
896 sds line = NULL;
897
898 if (!fp) {
899 redisLog(REDIS_WARNING,"Fatal error, can't open config file");
900 exit(1);
901 }
902 while(fgets(buf,REDIS_CONFIGLINE_MAX+1,fp) != NULL) {
903 sds *argv;
904 int argc, j;
905
906 linenum++;
907 line = sdsnew(buf);
908 line = sdstrim(line," \t\r\n");
909
910 /* Skip comments and blank lines*/
911 if (line[0] == '#' || line[0] == '\0') {
912 sdsfree(line);
913 continue;
914 }
915
916 /* Split into arguments */
917 argv = sdssplitlen(line,sdslen(line)," ",1,&argc);
918 sdstolower(argv[0]);
919
920 /* Execute config directives */
921 if (!strcmp(argv[0],"timeout") && argc == 2) {
922 server.maxidletime = atoi(argv[1]);
923 if (server.maxidletime < 1) {
924 err = "Invalid timeout value"; goto loaderr;
925 }
926 } else if (!strcmp(argv[0],"port") && argc == 2) {
927 server.port = atoi(argv[1]);
928 if (server.port < 1 || server.port > 65535) {
929 err = "Invalid port"; goto loaderr;
930 }
931 } else if (!strcmp(argv[0],"bind") && argc == 2) {
932 server.bindaddr = zstrdup(argv[1]);
933 } else if (!strcmp(argv[0],"save") && argc == 3) {
934 int seconds = atoi(argv[1]);
935 int changes = atoi(argv[2]);
936 if (seconds < 1 || changes < 0) {
937 err = "Invalid save parameters"; goto loaderr;
938 }
939 appendServerSaveParams(seconds,changes);
940 } else if (!strcmp(argv[0],"dir") && argc == 2) {
941 if (chdir(argv[1]) == -1) {
942 redisLog(REDIS_WARNING,"Can't chdir to '%s': %s",
943 argv[1], strerror(errno));
944 exit(1);
945 }
946 } else if (!strcmp(argv[0],"loglevel") && argc == 2) {
947 if (!strcmp(argv[1],"debug")) server.verbosity = REDIS_DEBUG;
948 else if (!strcmp(argv[1],"notice")) server.verbosity = REDIS_NOTICE;
949 else if (!strcmp(argv[1],"warning")) server.verbosity = REDIS_WARNING;
950 else {
951 err = "Invalid log level. Must be one of debug, notice, warning";
952 goto loaderr;
953 }
954 } else if (!strcmp(argv[0],"logfile") && argc == 2) {
955 FILE *fp;
956
957 server.logfile = zstrdup(argv[1]);
958 if (!strcmp(server.logfile,"stdout")) {
959 zfree(server.logfile);
960 server.logfile = NULL;
961 }
962 if (server.logfile) {
963 /* Test if we are able to open the file. The server will not
964 * be able to abort just for this problem later... */
965 fp = fopen(server.logfile,"a");
966 if (fp == NULL) {
967 err = sdscatprintf(sdsempty(),
968 "Can't open the log file: %s", strerror(errno));
969 goto loaderr;
970 }
971 fclose(fp);
972 }
973 } else if (!strcmp(argv[0],"databases") && argc == 2) {
974 server.dbnum = atoi(argv[1]);
975 if (server.dbnum < 1) {
976 err = "Invalid number of databases"; goto loaderr;
977 }
978 } else if (!strcmp(argv[0],"slaveof") && argc == 3) {
979 server.masterhost = sdsnew(argv[1]);
980 server.masterport = atoi(argv[2]);
981 server.replstate = REDIS_REPL_CONNECT;
982 } else if (!strcmp(argv[0],"glueoutputbuf") && argc == 2) {
983 sdstolower(argv[1]);
984 if (!strcmp(argv[1],"yes")) server.glueoutputbuf = 1;
985 else if (!strcmp(argv[1],"no")) server.glueoutputbuf = 0;
986 else {
987 err = "argument must be 'yes' or 'no'"; goto loaderr;
988 }
989 } else if (!strcmp(argv[0],"shareobjects") && argc == 2) {
990 sdstolower(argv[1]);
991 if (!strcmp(argv[1],"yes")) server.shareobjects = 1;
992 else if (!strcmp(argv[1],"no")) server.shareobjects = 0;
993 else {
994 err = "argument must be 'yes' or 'no'"; goto loaderr;
995 }
996 } else if (!strcmp(argv[0],"daemonize") && argc == 2) {
997 sdstolower(argv[1]);
998 if (!strcmp(argv[1],"yes")) server.daemonize = 1;
999 else if (!strcmp(argv[1],"no")) server.daemonize = 0;
1000 else {
1001 err = "argument must be 'yes' or 'no'"; goto loaderr;
1002 }
1003 } else if (!strcmp(argv[0],"requirepass") && argc == 2) {
1004 server.requirepass = zstrdup(argv[1]);
1005 } else if (!strcmp(argv[0],"pidfile") && argc == 2) {
1006 server.pidfile = zstrdup(argv[1]);
1007 } else {
1008 err = "Bad directive or wrong number of arguments"; goto loaderr;
1009 }
1010 for (j = 0; j < argc; j++)
1011 sdsfree(argv[j]);
1012 zfree(argv);
1013 sdsfree(line);
1014 }
1015 fclose(fp);
1016 return;
1017
1018 loaderr:
1019 fprintf(stderr, "\n*** FATAL CONFIG FILE ERROR ***\n");
1020 fprintf(stderr, "Reading the configuration file, at line %d\n", linenum);
1021 fprintf(stderr, ">>> '%s'\n", line);
1022 fprintf(stderr, "%s\n", err);
1023 exit(1);
1024 }
1025
1026 static void freeClientArgv(redisClient *c) {
1027 int j;
1028
1029 for (j = 0; j < c->argc; j++)
1030 decrRefCount(c->argv[j]);
1031 c->argc = 0;
1032 }
1033
1034 static void freeClient(redisClient *c) {
1035 listNode *ln;
1036
1037 aeDeleteFileEvent(server.el,c->fd,AE_READABLE);
1038 aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
1039 sdsfree(c->querybuf);
1040 listRelease(c->reply);
1041 freeClientArgv(c);
1042 close(c->fd);
1043 ln = listSearchKey(server.clients,c);
1044 assert(ln != NULL);
1045 listDelNode(server.clients,ln);
1046 if (c->flags & REDIS_SLAVE) {
1047 if (c->replstate == REDIS_REPL_SEND_BULK && c->repldbfd != -1)
1048 close(c->repldbfd);
1049 list *l = (c->flags & REDIS_MONITOR) ? server.monitors : server.slaves;
1050 ln = listSearchKey(l,c);
1051 assert(ln != NULL);
1052 listDelNode(l,ln);
1053 }
1054 if (c->flags & REDIS_MASTER) {
1055 server.master = NULL;
1056 server.replstate = REDIS_REPL_CONNECT;
1057 }
1058 zfree(c);
1059 }
1060
1061 static void glueReplyBuffersIfNeeded(redisClient *c) {
1062 int totlen = 0;
1063 listNode *ln;
1064 robj *o;
1065
1066 listRewind(c->reply);
1067 while((ln = listYield(c->reply))) {
1068 o = ln->value;
1069 totlen += sdslen(o->ptr);
1070 /* This optimization makes more sense if we don't have to copy
1071 * too much data */
1072 if (totlen > 1024) return;
1073 }
1074 if (totlen > 0) {
1075 char buf[1024];
1076 int copylen = 0;
1077
1078 listRewind(c->reply);
1079 while((ln = listYield(c->reply))) {
1080 o = ln->value;
1081 memcpy(buf+copylen,o->ptr,sdslen(o->ptr));
1082 copylen += sdslen(o->ptr);
1083 listDelNode(c->reply,ln);
1084 }
1085 /* Now the output buffer is empty, add the new single element */
1086 addReplySds(c,sdsnewlen(buf,totlen));
1087 }
1088 }
1089
1090 static void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask) {
1091 redisClient *c = privdata;
1092 int nwritten = 0, totwritten = 0, objlen;
1093 robj *o;
1094 REDIS_NOTUSED(el);
1095 REDIS_NOTUSED(mask);
1096
1097 if (server.glueoutputbuf && listLength(c->reply) > 1)
1098 glueReplyBuffersIfNeeded(c);
1099 while(listLength(c->reply)) {
1100 o = listNodeValue(listFirst(c->reply));
1101 objlen = sdslen(o->ptr);
1102
1103 if (objlen == 0) {
1104 listDelNode(c->reply,listFirst(c->reply));
1105 continue;
1106 }
1107
1108 if (c->flags & REDIS_MASTER) {
1109 nwritten = objlen - c->sentlen;
1110 } else {
1111 nwritten = write(fd, ((char*)o->ptr)+c->sentlen, objlen - c->sentlen);
1112 if (nwritten <= 0) break;
1113 }
1114 c->sentlen += nwritten;
1115 totwritten += nwritten;
1116 /* If we fully sent the object on head go to the next one */
1117 if (c->sentlen == objlen) {
1118 listDelNode(c->reply,listFirst(c->reply));
1119 c->sentlen = 0;
1120 }
1121 }
1122 if (nwritten == -1) {
1123 if (errno == EAGAIN) {
1124 nwritten = 0;
1125 } else {
1126 redisLog(REDIS_DEBUG,
1127 "Error writing to client: %s", strerror(errno));
1128 freeClient(c);
1129 return;
1130 }
1131 }
1132 if (totwritten > 0) c->lastinteraction = time(NULL);
1133 if (listLength(c->reply) == 0) {
1134 c->sentlen = 0;
1135 aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
1136 }
1137 }
1138
1139 static struct redisCommand *lookupCommand(char *name) {
1140 int j = 0;
1141 while(cmdTable[j].name != NULL) {
1142 if (!strcmp(name,cmdTable[j].name)) return &cmdTable[j];
1143 j++;
1144 }
1145 return NULL;
1146 }
1147
1148 /* resetClient prepare the client to process the next command */
1149 static void resetClient(redisClient *c) {
1150 freeClientArgv(c);
1151 c->bulklen = -1;
1152 }
1153
1154 /* If this function gets called we already read a whole
1155 * command, argments are in the client argv/argc fields.
1156 * processCommand() execute the command or prepare the
1157 * server for a bulk read from the client.
1158 *
1159 * If 1 is returned the client is still alive and valid and
1160 * and other operations can be performed by the caller. Otherwise
1161 * if 0 is returned the client was destroied (i.e. after QUIT). */
1162 static int processCommand(redisClient *c) {
1163 struct redisCommand *cmd;
1164 long long dirty;
1165
1166 sdstolower(c->argv[0]->ptr);
1167 /* The QUIT command is handled as a special case. Normal command
1168 * procs are unable to close the client connection safely */
1169 if (!strcmp(c->argv[0]->ptr,"quit")) {
1170 freeClient(c);
1171 return 0;
1172 }
1173 cmd = lookupCommand(c->argv[0]->ptr);
1174 if (!cmd) {
1175 addReplySds(c,sdsnew("-ERR unknown command\r\n"));
1176 resetClient(c);
1177 return 1;
1178 } else if ((cmd->arity > 0 && cmd->arity != c->argc) ||
1179 (c->argc < -cmd->arity)) {
1180 addReplySds(c,sdsnew("-ERR wrong number of arguments\r\n"));
1181 resetClient(c);
1182 return 1;
1183 } else if (cmd->flags & REDIS_CMD_BULK && c->bulklen == -1) {
1184 int bulklen = atoi(c->argv[c->argc-1]->ptr);
1185
1186 decrRefCount(c->argv[c->argc-1]);
1187 if (bulklen < 0 || bulklen > 1024*1024*1024) {
1188 c->argc--;
1189 addReplySds(c,sdsnew("-ERR invalid bulk write count\r\n"));
1190 resetClient(c);
1191 return 1;
1192 }
1193 c->argc--;
1194 c->bulklen = bulklen+2; /* add two bytes for CR+LF */
1195 /* It is possible that the bulk read is already in the
1196 * buffer. Check this condition and handle it accordingly */
1197 if ((signed)sdslen(c->querybuf) >= c->bulklen) {
1198 c->argv[c->argc] = createStringObject(c->querybuf,c->bulklen-2);
1199 c->argc++;
1200 c->querybuf = sdsrange(c->querybuf,c->bulklen,-1);
1201 } else {
1202 return 1;
1203 }
1204 }
1205 /* Let's try to share objects on the command arguments vector */
1206 if (server.shareobjects) {
1207 int j;
1208 for(j = 1; j < c->argc; j++)
1209 c->argv[j] = tryObjectSharing(c->argv[j]);
1210 }
1211 /* Check if the user is authenticated */
1212 if (server.requirepass && !c->authenticated && cmd->proc != authCommand) {
1213 addReplySds(c,sdsnew("-ERR operation not permitted\r\n"));
1214 resetClient(c);
1215 return 1;
1216 }
1217
1218 /* Exec the command */
1219 dirty = server.dirty;
1220 cmd->proc(c);
1221 if (server.dirty-dirty != 0 && listLength(server.slaves))
1222 replicationFeedSlaves(server.slaves,cmd,c->db->id,c->argv,c->argc);
1223 if (listLength(server.monitors))
1224 replicationFeedSlaves(server.monitors,cmd,c->db->id,c->argv,c->argc);
1225 server.stat_numcommands++;
1226
1227 /* Prepare the client for the next command */
1228 if (c->flags & REDIS_CLOSE) {
1229 freeClient(c);
1230 return 0;
1231 }
1232 resetClient(c);
1233 return 1;
1234 }
1235
1236 static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int dictid, robj **argv, int argc) {
1237 listNode *ln;
1238 robj *outv[REDIS_MAX_ARGS*4]; /* enough room for args, spaces, newlines */
1239 int outc = 0, j;
1240
1241 for (j = 0; j < argc; j++) {
1242 if (j != 0) outv[outc++] = shared.space;
1243 if ((cmd->flags & REDIS_CMD_BULK) && j == argc-1) {
1244 robj *lenobj;
1245
1246 lenobj = createObject(REDIS_STRING,
1247 sdscatprintf(sdsempty(),"%d\r\n",sdslen(argv[j]->ptr)));
1248 lenobj->refcount = 0;
1249 outv[outc++] = lenobj;
1250 }
1251 outv[outc++] = argv[j];
1252 }
1253 outv[outc++] = shared.crlf;
1254
1255 /* Increment all the refcounts at start and decrement at end in order to
1256 * be sure to free objects if there is no slave in a replication state
1257 * able to be feed with commands */
1258 for (j = 0; j < outc; j++) incrRefCount(outv[j]);
1259 listRewind(slaves);
1260 while((ln = listYield(slaves))) {
1261 redisClient *slave = ln->value;
1262
1263 /* Don't feed slaves that are still waiting for BGSAVE to start */
1264 if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_START) continue;
1265
1266 /* Feed all the other slaves, MONITORs and so on */
1267 if (slave->slaveseldb != dictid) {
1268 robj *selectcmd;
1269
1270 switch(dictid) {
1271 case 0: selectcmd = shared.select0; break;
1272 case 1: selectcmd = shared.select1; break;
1273 case 2: selectcmd = shared.select2; break;
1274 case 3: selectcmd = shared.select3; break;
1275 case 4: selectcmd = shared.select4; break;
1276 case 5: selectcmd = shared.select5; break;
1277 case 6: selectcmd = shared.select6; break;
1278 case 7: selectcmd = shared.select7; break;
1279 case 8: selectcmd = shared.select8; break;
1280 case 9: selectcmd = shared.select9; break;
1281 default:
1282 selectcmd = createObject(REDIS_STRING,
1283 sdscatprintf(sdsempty(),"select %d\r\n",dictid));
1284 selectcmd->refcount = 0;
1285 break;
1286 }
1287 addReply(slave,selectcmd);
1288 slave->slaveseldb = dictid;
1289 }
1290 for (j = 0; j < outc; j++) addReply(slave,outv[j]);
1291 }
1292 for (j = 0; j < outc; j++) decrRefCount(outv[j]);
1293 }
1294
1295 static void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {
1296 redisClient *c = (redisClient*) privdata;
1297 char buf[REDIS_IOBUF_LEN];
1298 int nread;
1299 REDIS_NOTUSED(el);
1300 REDIS_NOTUSED(mask);
1301
1302 nread = read(fd, buf, REDIS_IOBUF_LEN);
1303 if (nread == -1) {
1304 if (errno == EAGAIN) {
1305 nread = 0;
1306 } else {
1307 redisLog(REDIS_DEBUG, "Reading from client: %s",strerror(errno));
1308 freeClient(c);
1309 return;
1310 }
1311 } else if (nread == 0) {
1312 redisLog(REDIS_DEBUG, "Client closed connection");
1313 freeClient(c);
1314 return;
1315 }
1316 if (nread) {
1317 c->querybuf = sdscatlen(c->querybuf, buf, nread);
1318 c->lastinteraction = time(NULL);
1319 } else {
1320 return;
1321 }
1322
1323 again:
1324 if (c->bulklen == -1) {
1325 /* Read the first line of the query */
1326 char *p = strchr(c->querybuf,'\n');
1327 size_t querylen;
1328 if (p) {
1329 sds query, *argv;
1330 int argc, j;
1331
1332 query = c->querybuf;
1333 c->querybuf = sdsempty();
1334 querylen = 1+(p-(query));
1335 if (sdslen(query) > querylen) {
1336 /* leave data after the first line of the query in the buffer */
1337 c->querybuf = sdscatlen(c->querybuf,query+querylen,sdslen(query)-querylen);
1338 }
1339 *p = '\0'; /* remove "\n" */
1340 if (*(p-1) == '\r') *(p-1) = '\0'; /* and "\r" if any */
1341 sdsupdatelen(query);
1342
1343 /* Now we can split the query in arguments */
1344 if (sdslen(query) == 0) {
1345 /* Ignore empty query */
1346 sdsfree(query);
1347 return;
1348 }
1349 argv = sdssplitlen(query,sdslen(query)," ",1,&argc);
1350 sdsfree(query);
1351 if (argv == NULL) oom("sdssplitlen");
1352 for (j = 0; j < argc && j < REDIS_MAX_ARGS; j++) {
1353 if (sdslen(argv[j])) {
1354 c->argv[c->argc] = createObject(REDIS_STRING,argv[j]);
1355 c->argc++;
1356 } else {
1357 sdsfree(argv[j]);
1358 }
1359 }
1360 zfree(argv);
1361 /* Execute the command. If the client is still valid
1362 * after processCommand() return and there is something
1363 * on the query buffer try to process the next command. */
1364 if (processCommand(c) && sdslen(c->querybuf)) goto again;
1365 return;
1366 } else if (sdslen(c->querybuf) >= 1024) {
1367 redisLog(REDIS_DEBUG, "Client protocol error");
1368 freeClient(c);
1369 return;
1370 }
1371 } else {
1372 /* Bulk read handling. Note that if we are at this point
1373 the client already sent a command terminated with a newline,
1374 we are reading the bulk data that is actually the last
1375 argument of the command. */
1376 int qbl = sdslen(c->querybuf);
1377
1378 if (c->bulklen <= qbl) {
1379 /* Copy everything but the final CRLF as final argument */
1380 c->argv[c->argc] = createStringObject(c->querybuf,c->bulklen-2);
1381 c->argc++;
1382 c->querybuf = sdsrange(c->querybuf,c->bulklen,-1);
1383 processCommand(c);
1384 return;
1385 }
1386 }
1387 }
1388
1389 static int selectDb(redisClient *c, int id) {
1390 if (id < 0 || id >= server.dbnum)
1391 return REDIS_ERR;
1392 c->db = &server.db[id];
1393 return REDIS_OK;
1394 }
1395
1396 static void *dupClientReplyValue(void *o) {
1397 incrRefCount((robj*)o);
1398 return 0;
1399 }
1400
1401 static redisClient *createClient(int fd) {
1402 redisClient *c = zmalloc(sizeof(*c));
1403
1404 anetNonBlock(NULL,fd);
1405 anetTcpNoDelay(NULL,fd);
1406 if (!c) return NULL;
1407 selectDb(c,0);
1408 c->fd = fd;
1409 c->querybuf = sdsempty();
1410 c->argc = 0;
1411 c->bulklen = -1;
1412 c->sentlen = 0;
1413 c->flags = 0;
1414 c->lastinteraction = time(NULL);
1415 c->authenticated = 0;
1416 c->replstate = REDIS_REPL_NONE;
1417 if ((c->reply = listCreate()) == NULL) oom("listCreate");
1418 listSetFreeMethod(c->reply,decrRefCount);
1419 listSetDupMethod(c->reply,dupClientReplyValue);
1420 if (aeCreateFileEvent(server.el, c->fd, AE_READABLE,
1421 readQueryFromClient, c, NULL) == AE_ERR) {
1422 freeClient(c);
1423 return NULL;
1424 }
1425 if (!listAddNodeTail(server.clients,c)) oom("listAddNodeTail");
1426 return c;
1427 }
1428
1429 static void addReply(redisClient *c, robj *obj) {
1430 if (listLength(c->reply) == 0 &&
1431 (c->replstate == REDIS_REPL_NONE ||
1432 c->replstate == REDIS_REPL_ONLINE) &&
1433 aeCreateFileEvent(server.el, c->fd, AE_WRITABLE,
1434 sendReplyToClient, c, NULL) == AE_ERR) return;
1435 if (!listAddNodeTail(c->reply,obj)) oom("listAddNodeTail");
1436 incrRefCount(obj);
1437 }
1438
1439 static void addReplySds(redisClient *c, sds s) {
1440 robj *o = createObject(REDIS_STRING,s);
1441 addReply(c,o);
1442 decrRefCount(o);
1443 }
1444
1445 static void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
1446 int cport, cfd;
1447 char cip[128];
1448 REDIS_NOTUSED(el);
1449 REDIS_NOTUSED(mask);
1450 REDIS_NOTUSED(privdata);
1451
1452 cfd = anetAccept(server.neterr, fd, cip, &cport);
1453 if (cfd == AE_ERR) {
1454 redisLog(REDIS_DEBUG,"Accepting client connection: %s", server.neterr);
1455 return;
1456 }
1457 redisLog(REDIS_DEBUG,"Accepted %s:%d", cip, cport);
1458 if (createClient(cfd) == NULL) {
1459 redisLog(REDIS_WARNING,"Error allocating resoures for the client");
1460 close(cfd); /* May be already closed, just ingore errors */
1461 return;
1462 }
1463 server.stat_numconnections++;
1464 }
1465
1466 /* ======================= Redis objects implementation ===================== */
1467
1468 static robj *createObject(int type, void *ptr) {
1469 robj *o;
1470
1471 if (listLength(server.objfreelist)) {
1472 listNode *head = listFirst(server.objfreelist);
1473 o = listNodeValue(head);
1474 listDelNode(server.objfreelist,head);
1475 } else {
1476 o = zmalloc(sizeof(*o));
1477 }
1478 if (!o) oom("createObject");
1479 o->type = type;
1480 o->ptr = ptr;
1481 o->refcount = 1;
1482 return o;
1483 }
1484
1485 static robj *createStringObject(char *ptr, size_t len) {
1486 return createObject(REDIS_STRING,sdsnewlen(ptr,len));
1487 }
1488
1489 static robj *createListObject(void) {
1490 list *l = listCreate();
1491
1492 if (!l) oom("listCreate");
1493 listSetFreeMethod(l,decrRefCount);
1494 return createObject(REDIS_LIST,l);
1495 }
1496
1497 static robj *createSetObject(void) {
1498 dict *d = dictCreate(&setDictType,NULL);
1499 if (!d) oom("dictCreate");
1500 return createObject(REDIS_SET,d);
1501 }
1502
1503 static void freeStringObject(robj *o) {
1504 sdsfree(o->ptr);
1505 }
1506
1507 static void freeListObject(robj *o) {
1508 listRelease((list*) o->ptr);
1509 }
1510
1511 static void freeSetObject(robj *o) {
1512 dictRelease((dict*) o->ptr);
1513 }
1514
1515 static void freeHashObject(robj *o) {
1516 dictRelease((dict*) o->ptr);
1517 }
1518
1519 static void incrRefCount(robj *o) {
1520 o->refcount++;
1521 #ifdef DEBUG_REFCOUNT
1522 if (o->type == REDIS_STRING)
1523 printf("Increment '%s'(%p), now is: %d\n",o->ptr,o,o->refcount);
1524 #endif
1525 }
1526
1527 static void decrRefCount(void *obj) {
1528 robj *o = obj;
1529
1530 #ifdef DEBUG_REFCOUNT
1531 if (o->type == REDIS_STRING)
1532 printf("Decrement '%s'(%p), now is: %d\n",o->ptr,o,o->refcount-1);
1533 #endif
1534 if (--(o->refcount) == 0) {
1535 switch(o->type) {
1536 case REDIS_STRING: freeStringObject(o); break;
1537 case REDIS_LIST: freeListObject(o); break;
1538 case REDIS_SET: freeSetObject(o); break;
1539 case REDIS_HASH: freeHashObject(o); break;
1540 default: assert(0 != 0); break;
1541 }
1542 if (listLength(server.objfreelist) > REDIS_OBJFREELIST_MAX ||
1543 !listAddNodeHead(server.objfreelist,o))
1544 zfree(o);
1545 }
1546 }
1547
1548 /* Try to share an object against the shared objects pool */
1549 static robj *tryObjectSharing(robj *o) {
1550 struct dictEntry *de;
1551 unsigned long c;
1552
1553 if (o == NULL || server.shareobjects == 0) return o;
1554
1555 assert(o->type == REDIS_STRING);
1556 de = dictFind(server.sharingpool,o);
1557 if (de) {
1558 robj *shared = dictGetEntryKey(de);
1559
1560 c = ((unsigned long) dictGetEntryVal(de))+1;
1561 dictGetEntryVal(de) = (void*) c;
1562 incrRefCount(shared);
1563 decrRefCount(o);
1564 return shared;
1565 } else {
1566 /* Here we are using a stream algorihtm: Every time an object is
1567 * shared we increment its count, everytime there is a miss we
1568 * recrement the counter of a random object. If this object reaches
1569 * zero we remove the object and put the current object instead. */
1570 if (dictSize(server.sharingpool) >=
1571 server.sharingpoolsize) {
1572 de = dictGetRandomKey(server.sharingpool);
1573 assert(de != NULL);
1574 c = ((unsigned long) dictGetEntryVal(de))-1;
1575 dictGetEntryVal(de) = (void*) c;
1576 if (c == 0) {
1577 dictDelete(server.sharingpool,de->key);
1578 }
1579 } else {
1580 c = 0; /* If the pool is empty we want to add this object */
1581 }
1582 if (c == 0) {
1583 int retval;
1584
1585 retval = dictAdd(server.sharingpool,o,(void*)1);
1586 assert(retval == DICT_OK);
1587 incrRefCount(o);
1588 }
1589 return o;
1590 }
1591 }
1592
1593 static robj *lookupKey(redisDb *db, robj *key) {
1594 dictEntry *de = dictFind(db->dict,key);
1595 return de ? dictGetEntryVal(de) : NULL;
1596 }
1597
1598 static robj *lookupKeyRead(redisDb *db, robj *key) {
1599 expireIfNeeded(db,key);
1600 return lookupKey(db,key);
1601 }
1602
1603 static robj *lookupKeyWrite(redisDb *db, robj *key) {
1604 deleteIfVolatile(db,key);
1605 return lookupKey(db,key);
1606 }
1607
1608 static int deleteKey(redisDb *db, robj *key) {
1609 int retval;
1610
1611 /* We need to protect key from destruction: after the first dictDelete()
1612 * it may happen that 'key' is no longer valid if we don't increment
1613 * it's count. This may happen when we get the object reference directly
1614 * from the hash table with dictRandomKey() or dict iterators */
1615 incrRefCount(key);
1616 if (dictSize(db->expires)) dictDelete(db->expires,key);
1617 retval = dictDelete(db->dict,key);
1618 decrRefCount(key);
1619
1620 return retval == DICT_OK;
1621 }
1622
1623 /*============================ DB saving/loading ============================ */
1624
1625 static int rdbSaveType(FILE *fp, unsigned char type) {
1626 if (fwrite(&type,1,1,fp) == 0) return -1;
1627 return 0;
1628 }
1629
1630 static int rdbSaveTime(FILE *fp, time_t t) {
1631 int32_t t32 = (int32_t) t;
1632 if (fwrite(&t32,4,1,fp) == 0) return -1;
1633 return 0;
1634 }
1635
1636 /* check rdbLoadLen() comments for more info */
1637 static int rdbSaveLen(FILE *fp, uint32_t len) {
1638 unsigned char buf[2];
1639
1640 if (len < (1<<6)) {
1641 /* Save a 6 bit len */
1642 buf[0] = (len&0xFF)|(REDIS_RDB_6BITLEN<<6);
1643 if (fwrite(buf,1,1,fp) == 0) return -1;
1644 } else if (len < (1<<14)) {
1645 /* Save a 14 bit len */
1646 buf[0] = ((len>>8)&0xFF)|(REDIS_RDB_14BITLEN<<6);
1647 buf[1] = len&0xFF;
1648 if (fwrite(buf,2,1,fp) == 0) return -1;
1649 } else {
1650 /* Save a 32 bit len */
1651 buf[0] = (REDIS_RDB_32BITLEN<<6);
1652 if (fwrite(buf,1,1,fp) == 0) return -1;
1653 len = htonl(len);
1654 if (fwrite(&len,4,1,fp) == 0) return -1;
1655 }
1656 return 0;
1657 }
1658
1659 /* String objects in the form "2391" "-100" without any space and with a
1660 * range of values that can fit in an 8, 16 or 32 bit signed value can be
1661 * encoded as integers to save space */
1662 int rdbTryIntegerEncoding(sds s, unsigned char *enc) {
1663 long long value;
1664 char *endptr, buf[32];
1665
1666 /* Check if it's possible to encode this value as a number */
1667 value = strtoll(s, &endptr, 10);
1668 if (endptr[0] != '\0') return 0;
1669 snprintf(buf,32,"%lld",value);
1670
1671 /* If the number converted back into a string is not identical
1672 * then it's not possible to encode the string as integer */
1673 if (strlen(buf) != sdslen(s) || memcmp(buf,s,sdslen(s))) return 0;
1674
1675 /* Finally check if it fits in our ranges */
1676 if (value >= -(1<<7) && value <= (1<<7)-1) {
1677 enc[0] = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_INT8;
1678 enc[1] = value&0xFF;
1679 return 2;
1680 } else if (value >= -(1<<15) && value <= (1<<15)-1) {
1681 enc[0] = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_INT16;
1682 enc[1] = value&0xFF;
1683 enc[2] = (value>>8)&0xFF;
1684 return 3;
1685 } else if (value >= -((long long)1<<31) && value <= ((long long)1<<31)-1) {
1686 enc[0] = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_INT32;
1687 enc[1] = value&0xFF;
1688 enc[2] = (value>>8)&0xFF;
1689 enc[3] = (value>>16)&0xFF;
1690 enc[4] = (value>>24)&0xFF;
1691 return 5;
1692 } else {
1693 return 0;
1694 }
1695 }
1696
1697 static int rdbSaveLzfStringObject(FILE *fp, robj *obj) {
1698 unsigned int comprlen, outlen;
1699 unsigned char byte;
1700 void *out;
1701
1702 /* We require at least four bytes compression for this to be worth it */
1703 outlen = sdslen(obj->ptr)-4;
1704 if (outlen <= 0) return 0;
1705 if ((out = zmalloc(outlen)) == NULL) return 0;
1706 comprlen = lzf_compress(obj->ptr, sdslen(obj->ptr), out, outlen);
1707 if (comprlen == 0) {
1708 zfree(out);
1709 return 0;
1710 }
1711 /* Data compressed! Let's save it on disk */
1712 byte = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_LZF;
1713 if (fwrite(&byte,1,1,fp) == 0) goto writeerr;
1714 if (rdbSaveLen(fp,comprlen) == -1) goto writeerr;
1715 if (rdbSaveLen(fp,sdslen(obj->ptr)) == -1) goto writeerr;
1716 if (fwrite(out,comprlen,1,fp) == 0) goto writeerr;
1717 zfree(out);
1718 return comprlen;
1719
1720 writeerr:
1721 zfree(out);
1722 return -1;
1723 }
1724
1725 /* Save a string objet as [len][data] on disk. If the object is a string
1726 * representation of an integer value we try to safe it in a special form */
1727 static int rdbSaveStringObject(FILE *fp, robj *obj) {
1728 size_t len = sdslen(obj->ptr);
1729 int enclen;
1730
1731 /* Try integer encoding */
1732 if (len <= 11) {
1733 unsigned char buf[5];
1734 if ((enclen = rdbTryIntegerEncoding(obj->ptr,buf)) > 0) {
1735 if (fwrite(buf,enclen,1,fp) == 0) return -1;
1736 return 0;
1737 }
1738 }
1739
1740 /* Try LZF compression - under 20 bytes it's unable to compress even
1741 * aaaaaaaaaaaaaaaaaa so skip it */
1742 if (len > 20) {
1743 int retval;
1744
1745 retval = rdbSaveLzfStringObject(fp,obj);
1746 if (retval == -1) return -1;
1747 if (retval > 0) return 0;
1748 /* retval == 0 means data can't be compressed, save the old way */
1749 }
1750
1751 /* Store verbatim */
1752 if (rdbSaveLen(fp,len) == -1) return -1;
1753 if (len && fwrite(obj->ptr,len,1,fp) == 0) return -1;
1754 return 0;
1755 }
1756
1757 /* Save the DB on disk. Return REDIS_ERR on error, REDIS_OK on success */
1758 static int rdbSave(char *filename) {
1759 dictIterator *di = NULL;
1760 dictEntry *de;
1761 FILE *fp;
1762 char tmpfile[256];
1763 int j;
1764 time_t now = time(NULL);
1765
1766 snprintf(tmpfile,256,"temp-%d.%ld.rdb",(int)time(NULL),(long int)random());
1767 fp = fopen(tmpfile,"w");
1768 if (!fp) {
1769 redisLog(REDIS_WARNING, "Failed saving the DB: %s", strerror(errno));
1770 return REDIS_ERR;
1771 }
1772 if (fwrite("REDIS0001",9,1,fp) == 0) goto werr;
1773 for (j = 0; j < server.dbnum; j++) {
1774 redisDb *db = server.db+j;
1775 dict *d = db->dict;
1776 if (dictSize(d) == 0) continue;
1777 di = dictGetIterator(d);
1778 if (!di) {
1779 fclose(fp);
1780 return REDIS_ERR;
1781 }
1782
1783 /* Write the SELECT DB opcode */
1784 if (rdbSaveType(fp,REDIS_SELECTDB) == -1) goto werr;
1785 if (rdbSaveLen(fp,j) == -1) goto werr;
1786
1787 /* Iterate this DB writing every entry */
1788 while((de = dictNext(di)) != NULL) {
1789 robj *key = dictGetEntryKey(de);
1790 robj *o = dictGetEntryVal(de);
1791 time_t expiretime = getExpire(db,key);
1792
1793 /* Save the expire time */
1794 if (expiretime != -1) {
1795 /* If this key is already expired skip it */
1796 if (expiretime < now) continue;
1797 if (rdbSaveType(fp,REDIS_EXPIRETIME) == -1) goto werr;
1798 if (rdbSaveTime(fp,expiretime) == -1) goto werr;
1799 }
1800 /* Save the key and associated value */
1801 if (rdbSaveType(fp,o->type) == -1) goto werr;
1802 if (rdbSaveStringObject(fp,key) == -1) goto werr;
1803 if (o->type == REDIS_STRING) {
1804 /* Save a string value */
1805 if (rdbSaveStringObject(fp,o) == -1) goto werr;
1806 } else if (o->type == REDIS_LIST) {
1807 /* Save a list value */
1808 list *list = o->ptr;
1809 listNode *ln;
1810
1811 listRewind(list);
1812 if (rdbSaveLen(fp,listLength(list)) == -1) goto werr;
1813 while((ln = listYield(list))) {
1814 robj *eleobj = listNodeValue(ln);
1815
1816 if (rdbSaveStringObject(fp,eleobj) == -1) goto werr;
1817 }
1818 } else if (o->type == REDIS_SET) {
1819 /* Save a set value */
1820 dict *set = o->ptr;
1821 dictIterator *di = dictGetIterator(set);
1822 dictEntry *de;
1823
1824 if (!set) oom("dictGetIteraotr");
1825 if (rdbSaveLen(fp,dictSize(set)) == -1) goto werr;
1826 while((de = dictNext(di)) != NULL) {
1827 robj *eleobj = dictGetEntryKey(de);
1828
1829 if (rdbSaveStringObject(fp,eleobj) == -1) goto werr;
1830 }
1831 dictReleaseIterator(di);
1832 } else {
1833 assert(0 != 0);
1834 }
1835 }
1836 dictReleaseIterator(di);
1837 }
1838 /* EOF opcode */
1839 if (rdbSaveType(fp,REDIS_EOF) == -1) goto werr;
1840
1841 /* Make sure data will not remain on the OS's output buffers */
1842 fflush(fp);
1843 fsync(fileno(fp));
1844 fclose(fp);
1845
1846 /* Use RENAME to make sure the DB file is changed atomically only
1847 * if the generate DB file is ok. */
1848 if (rename(tmpfile,filename) == -1) {
1849 redisLog(REDIS_WARNING,"Error moving temp DB file on the final destionation: %s", strerror(errno));
1850 unlink(tmpfile);
1851 return REDIS_ERR;
1852 }
1853 redisLog(REDIS_NOTICE,"DB saved on disk");
1854 server.dirty = 0;
1855 server.lastsave = time(NULL);
1856 return REDIS_OK;
1857
1858 werr:
1859 fclose(fp);
1860 unlink(tmpfile);
1861 redisLog(REDIS_WARNING,"Write error saving DB on disk: %s", strerror(errno));
1862 if (di) dictReleaseIterator(di);
1863 return REDIS_ERR;
1864 }
1865
1866 static int rdbSaveBackground(char *filename) {
1867 pid_t childpid;
1868
1869 if (server.bgsaveinprogress) return REDIS_ERR;
1870 if ((childpid = fork()) == 0) {
1871 /* Child */
1872 close(server.fd);
1873 if (rdbSave(filename) == REDIS_OK) {
1874 exit(0);
1875 } else {
1876 exit(1);
1877 }
1878 } else {
1879 /* Parent */
1880 redisLog(REDIS_NOTICE,"Background saving started by pid %d",childpid);
1881 server.bgsaveinprogress = 1;
1882 return REDIS_OK;
1883 }
1884 return REDIS_OK; /* unreached */
1885 }
1886
1887 static int rdbLoadType(FILE *fp) {
1888 unsigned char type;
1889 if (fread(&type,1,1,fp) == 0) return -1;
1890 return type;
1891 }
1892
1893 static time_t rdbLoadTime(FILE *fp) {
1894 int32_t t32;
1895 if (fread(&t32,4,1,fp) == 0) return -1;
1896 return (time_t) t32;
1897 }
1898
1899 /* Load an encoded length from the DB, see the REDIS_RDB_* defines on the top
1900 * of this file for a description of how this are stored on disk.
1901 *
1902 * isencoded is set to 1 if the readed length is not actually a length but
1903 * an "encoding type", check the above comments for more info */
1904 static uint32_t rdbLoadLen(FILE *fp, int rdbver, int *isencoded) {
1905 unsigned char buf[2];
1906 uint32_t len;
1907
1908 if (isencoded) *isencoded = 0;
1909 if (rdbver == 0) {
1910 if (fread(&len,4,1,fp) == 0) return REDIS_RDB_LENERR;
1911 return ntohl(len);
1912 } else {
1913 int type;
1914
1915 if (fread(buf,1,1,fp) == 0) return REDIS_RDB_LENERR;
1916 type = (buf[0]&0xC0)>>6;
1917 if (type == REDIS_RDB_6BITLEN) {
1918 /* Read a 6 bit len */
1919 return buf[0]&0x3F;
1920 } else if (type == REDIS_RDB_ENCVAL) {
1921 /* Read a 6 bit len encoding type */
1922 if (isencoded) *isencoded = 1;
1923 return buf[0]&0x3F;
1924 } else if (type == REDIS_RDB_14BITLEN) {
1925 /* Read a 14 bit len */
1926 if (fread(buf+1,1,1,fp) == 0) return REDIS_RDB_LENERR;
1927 return ((buf[0]&0x3F)<<8)|buf[1];
1928 } else {
1929 /* Read a 32 bit len */
1930 if (fread(&len,4,1,fp) == 0) return REDIS_RDB_LENERR;
1931 return ntohl(len);
1932 }
1933 }
1934 }
1935
1936 static robj *rdbLoadIntegerObject(FILE *fp, int enctype) {
1937 unsigned char enc[4];
1938 long long val;
1939
1940 if (enctype == REDIS_RDB_ENC_INT8) {
1941 if (fread(enc,1,1,fp) == 0) return NULL;
1942 val = (signed char)enc[0];
1943 } else if (enctype == REDIS_RDB_ENC_INT16) {
1944 uint16_t v;
1945 if (fread(enc,2,1,fp) == 0) return NULL;
1946 v = enc[0]|(enc[1]<<8);
1947 val = (int16_t)v;
1948 } else if (enctype == REDIS_RDB_ENC_INT32) {
1949 uint32_t v;
1950 if (fread(enc,4,1,fp) == 0) return NULL;
1951 v = enc[0]|(enc[1]<<8)|(enc[2]<<16)|(enc[3]<<24);
1952 val = (int32_t)v;
1953 } else {
1954 val = 0; /* anti-warning */
1955 assert(0!=0);
1956 }
1957 return createObject(REDIS_STRING,sdscatprintf(sdsempty(),"%lld",val));
1958 }
1959
1960 static robj *rdbLoadLzfStringObject(FILE*fp, int rdbver) {
1961 unsigned int len, clen;
1962 unsigned char *c = NULL;
1963 sds val = NULL;
1964
1965 if ((clen = rdbLoadLen(fp,rdbver,NULL)) == REDIS_RDB_LENERR) return NULL;
1966 if ((len = rdbLoadLen(fp,rdbver,NULL)) == REDIS_RDB_LENERR) return NULL;
1967 if ((c = zmalloc(clen)) == NULL) goto err;
1968 if ((val = sdsnewlen(NULL,len)) == NULL) goto err;
1969 if (fread(c,clen,1,fp) == 0) goto err;
1970 if (lzf_decompress(c,clen,val,len) == 0) goto err;
1971 return createObject(REDIS_STRING,val);
1972 err:
1973 zfree(c);
1974 sdsfree(val);
1975 return NULL;
1976 }
1977
1978 static robj *rdbLoadStringObject(FILE*fp, int rdbver) {
1979 int isencoded;
1980 uint32_t len;
1981 sds val;
1982
1983 len = rdbLoadLen(fp,rdbver,&isencoded);
1984 if (isencoded) {
1985 switch(len) {
1986 case REDIS_RDB_ENC_INT8:
1987 case REDIS_RDB_ENC_INT16:
1988 case REDIS_RDB_ENC_INT32:
1989 return tryObjectSharing(rdbLoadIntegerObject(fp,len));
1990 case REDIS_RDB_ENC_LZF:
1991 return tryObjectSharing(rdbLoadLzfStringObject(fp,rdbver));
1992 default:
1993 assert(0!=0);
1994 }
1995 }
1996
1997 if (len == REDIS_RDB_LENERR) return NULL;
1998 val = sdsnewlen(NULL,len);
1999 if (len && fread(val,len,1,fp) == 0) {
2000 sdsfree(val);
2001 return NULL;
2002 }
2003 return tryObjectSharing(createObject(REDIS_STRING,val));
2004 }
2005
2006 static int rdbLoad(char *filename) {
2007 FILE *fp;
2008 robj *keyobj = NULL;
2009 uint32_t dbid;
2010 int type, retval, rdbver;
2011 dict *d = server.db[0].dict;
2012 redisDb *db = server.db+0;
2013 char buf[1024];
2014 time_t expiretime = -1, now = time(NULL);
2015
2016 fp = fopen(filename,"r");
2017 if (!fp) return REDIS_ERR;
2018 if (fread(buf,9,1,fp) == 0) goto eoferr;
2019 buf[9] = '\0';
2020 if (memcmp(buf,"REDIS",5) != 0) {
2021 fclose(fp);
2022 redisLog(REDIS_WARNING,"Wrong signature trying to load DB from file");
2023 return REDIS_ERR;
2024 }
2025 rdbver = atoi(buf+5);
2026 if (rdbver > 1) {
2027 fclose(fp);
2028 redisLog(REDIS_WARNING,"Can't handle RDB format version %d",rdbver);
2029 return REDIS_ERR;
2030 }
2031 while(1) {
2032 robj *o;
2033
2034 /* Read type. */
2035 if ((type = rdbLoadType(fp)) == -1) goto eoferr;
2036 if (type == REDIS_EXPIRETIME) {
2037 if ((expiretime = rdbLoadTime(fp)) == -1) goto eoferr;
2038 /* We read the time so we need to read the object type again */
2039 if ((type = rdbLoadType(fp)) == -1) goto eoferr;
2040 }
2041 if (type == REDIS_EOF) break;
2042 /* Handle SELECT DB opcode as a special case */
2043 if (type == REDIS_SELECTDB) {
2044 if ((dbid = rdbLoadLen(fp,rdbver,NULL)) == REDIS_RDB_LENERR)
2045 goto eoferr;
2046 if (dbid >= (unsigned)server.dbnum) {
2047 redisLog(REDIS_WARNING,"FATAL: Data file was created with a Redis server configured to handle more than %d databases. Exiting\n", server.dbnum);
2048 exit(1);
2049 }
2050 db = server.db+dbid;
2051 d = db->dict;
2052 continue;
2053 }
2054 /* Read key */
2055 if ((keyobj = rdbLoadStringObject(fp,rdbver)) == NULL) goto eoferr;
2056
2057 if (type == REDIS_STRING) {
2058 /* Read string value */
2059 if ((o = rdbLoadStringObject(fp,rdbver)) == NULL) goto eoferr;
2060 } else if (type == REDIS_LIST || type == REDIS_SET) {
2061 /* Read list/set value */
2062 uint32_t listlen;
2063
2064 if ((listlen = rdbLoadLen(fp,rdbver,NULL)) == REDIS_RDB_LENERR)
2065 goto eoferr;
2066 o = (type == REDIS_LIST) ? createListObject() : createSetObject();
2067 /* Load every single element of the list/set */
2068 while(listlen--) {
2069 robj *ele;
2070
2071 if ((ele = rdbLoadStringObject(fp,rdbver)) == NULL) goto eoferr;
2072 if (type == REDIS_LIST) {
2073 if (!listAddNodeTail((list*)o->ptr,ele))
2074 oom("listAddNodeTail");
2075 } else {
2076 if (dictAdd((dict*)o->ptr,ele,NULL) == DICT_ERR)
2077 oom("dictAdd");
2078 }
2079 }
2080 } else {
2081 assert(0 != 0);
2082 }
2083 /* Add the new object in the hash table */
2084 retval = dictAdd(d,keyobj,o);
2085 if (retval == DICT_ERR) {
2086 redisLog(REDIS_WARNING,"Loading DB, duplicated key (%s) found! Unrecoverable error, exiting now.", keyobj->ptr);
2087 exit(1);
2088 }
2089 /* Set the expire time if needed */
2090 if (expiretime != -1) {
2091 setExpire(db,keyobj,expiretime);
2092 /* Delete this key if already expired */
2093 if (expiretime < now) deleteKey(db,keyobj);
2094 expiretime = -1;
2095 }
2096 keyobj = o = NULL;
2097 }
2098 fclose(fp);
2099 return REDIS_OK;
2100
2101 eoferr: /* unexpected end of file is handled here with a fatal exit */
2102 if (keyobj) decrRefCount(keyobj);
2103 redisLog(REDIS_WARNING,"Short read or OOM loading DB. Unrecoverable error, exiting now.");
2104 exit(1);
2105 return REDIS_ERR; /* Just to avoid warning */
2106 }
2107
2108 /*================================== Commands =============================== */
2109
2110 static void authCommand(redisClient *c) {
2111 if (!server.requirepass || !strcmp(c->argv[1]->ptr, server.requirepass)) {
2112 c->authenticated = 1;
2113 addReply(c,shared.ok);
2114 } else {
2115 c->authenticated = 0;
2116 addReply(c,shared.err);
2117 }
2118 }
2119
2120 static void pingCommand(redisClient *c) {
2121 addReply(c,shared.pong);
2122 }
2123
2124 static void echoCommand(redisClient *c) {
2125 addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",
2126 (int)sdslen(c->argv[1]->ptr)));
2127 addReply(c,c->argv[1]);
2128 addReply(c,shared.crlf);
2129 }
2130
2131 /*=================================== Strings =============================== */
2132
2133 static void setGenericCommand(redisClient *c, int nx) {
2134 int retval;
2135
2136 retval = dictAdd(c->db->dict,c->argv[1],c->argv[2]);
2137 if (retval == DICT_ERR) {
2138 if (!nx) {
2139 dictReplace(c->db->dict,c->argv[1],c->argv[2]);
2140 incrRefCount(c->argv[2]);
2141 } else {
2142 addReply(c,shared.czero);
2143 return;
2144 }
2145 } else {
2146 incrRefCount(c->argv[1]);
2147 incrRefCount(c->argv[2]);
2148 }
2149 server.dirty++;
2150 removeExpire(c->db,c->argv[1]);
2151 addReply(c, nx ? shared.cone : shared.ok);
2152 }
2153
2154 static void setCommand(redisClient *c) {
2155 setGenericCommand(c,0);
2156 }
2157
2158 static void setnxCommand(redisClient *c) {
2159 setGenericCommand(c,1);
2160 }
2161
2162 static void getCommand(redisClient *c) {
2163 robj *o = lookupKeyRead(c->db,c->argv[1]);
2164
2165 if (o == NULL) {
2166 addReply(c,shared.nullbulk);
2167 } else {
2168 if (o->type != REDIS_STRING) {
2169 addReply(c,shared.wrongtypeerr);
2170 } else {
2171 addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(o->ptr)));
2172 addReply(c,o);
2173 addReply(c,shared.crlf);
2174 }
2175 }
2176 }
2177
2178 static void mgetCommand(redisClient *c) {
2179 int j;
2180
2181 addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",c->argc-1));
2182 for (j = 1; j < c->argc; j++) {
2183 robj *o = lookupKeyRead(c->db,c->argv[j]);
2184 if (o == NULL) {
2185 addReply(c,shared.nullbulk);
2186 } else {
2187 if (o->type != REDIS_STRING) {
2188 addReply(c,shared.nullbulk);
2189 } else {
2190 addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(o->ptr)));
2191 addReply(c,o);
2192 addReply(c,shared.crlf);
2193 }
2194 }
2195 }
2196 }
2197
2198 static void incrDecrCommand(redisClient *c, int incr) {
2199 long long value;
2200 int retval;
2201 robj *o;
2202
2203 o = lookupKeyWrite(c->db,c->argv[1]);
2204 if (o == NULL) {
2205 value = 0;
2206 } else {
2207 if (o->type != REDIS_STRING) {
2208 value = 0;
2209 } else {
2210 char *eptr;
2211
2212 value = strtoll(o->ptr, &eptr, 10);
2213 }
2214 }
2215
2216 value += incr;
2217 o = createObject(REDIS_STRING,sdscatprintf(sdsempty(),"%lld",value));
2218 retval = dictAdd(c->db->dict,c->argv[1],o);
2219 if (retval == DICT_ERR) {
2220 dictReplace(c->db->dict,c->argv[1],o);
2221 removeExpire(c->db,c->argv[1]);
2222 } else {
2223 incrRefCount(c->argv[1]);
2224 }
2225 server.dirty++;
2226 addReply(c,shared.colon);
2227 addReply(c,o);
2228 addReply(c,shared.crlf);
2229 }
2230
2231 static void incrCommand(redisClient *c) {
2232 incrDecrCommand(c,1);
2233 }
2234
2235 static void decrCommand(redisClient *c) {
2236 incrDecrCommand(c,-1);
2237 }
2238
2239 static void incrbyCommand(redisClient *c) {
2240 int incr = atoi(c->argv[2]->ptr);
2241 incrDecrCommand(c,incr);
2242 }
2243
2244 static void decrbyCommand(redisClient *c) {
2245 int incr = atoi(c->argv[2]->ptr);
2246 incrDecrCommand(c,-incr);
2247 }
2248
2249 /* ========================= Type agnostic commands ========================= */
2250
2251 static void delCommand(redisClient *c) {
2252 if (deleteKey(c->db,c->argv[1])) {
2253 server.dirty++;
2254 addReply(c,shared.cone);
2255 } else {
2256 addReply(c,shared.czero);
2257 }
2258 }
2259
2260 static void existsCommand(redisClient *c) {
2261 addReply(c,lookupKeyRead(c->db,c->argv[1]) ? shared.cone : shared.czero);
2262 }
2263
2264 static void selectCommand(redisClient *c) {
2265 int id = atoi(c->argv[1]->ptr);
2266
2267 if (selectDb(c,id) == REDIS_ERR) {
2268 addReplySds(c,sdsnew("-ERR invalid DB index\r\n"));
2269 } else {
2270 addReply(c,shared.ok);
2271 }
2272 }
2273
2274 static void randomkeyCommand(redisClient *c) {
2275 dictEntry *de;
2276
2277 while(1) {
2278 de = dictGetRandomKey(c->db->dict);
2279 if (!de || expireIfNeeded(c->db,dictGetEntryKey(de)) == 0) break;
2280 }
2281 if (de == NULL) {
2282 addReply(c,shared.plus);
2283 addReply(c,shared.crlf);
2284 } else {
2285 addReply(c,shared.plus);
2286 addReply(c,dictGetEntryKey(de));
2287 addReply(c,shared.crlf);
2288 }
2289 }
2290
2291 static void keysCommand(redisClient *c) {
2292 dictIterator *di;
2293 dictEntry *de;
2294 sds pattern = c->argv[1]->ptr;
2295 int plen = sdslen(pattern);
2296 int numkeys = 0, keyslen = 0;
2297 robj *lenobj = createObject(REDIS_STRING,NULL);
2298
2299 di = dictGetIterator(c->db->dict);
2300 if (!di) oom("dictGetIterator");
2301 addReply(c,lenobj);
2302 decrRefCount(lenobj);
2303 while((de = dictNext(di)) != NULL) {
2304 robj *keyobj = dictGetEntryKey(de);
2305
2306 sds key = keyobj->ptr;
2307 if ((pattern[0] == '*' && pattern[1] == '\0') ||
2308 stringmatchlen(pattern,plen,key,sdslen(key),0)) {
2309 if (expireIfNeeded(c->db,keyobj) == 0) {
2310 if (numkeys != 0)
2311 addReply(c,shared.space);
2312 addReply(c,keyobj);
2313 numkeys++;
2314 keyslen += sdslen(key);
2315 }
2316 }
2317 }
2318 dictReleaseIterator(di);
2319 lenobj->ptr = sdscatprintf(sdsempty(),"$%lu\r\n",keyslen+(numkeys ? (numkeys-1) : 0));
2320 addReply(c,shared.crlf);
2321 }
2322
2323 static void dbsizeCommand(redisClient *c) {
2324 addReplySds(c,
2325 sdscatprintf(sdsempty(),":%lu\r\n",dictSize(c->db->dict)));
2326 }
2327
2328 static void lastsaveCommand(redisClient *c) {
2329 addReplySds(c,
2330 sdscatprintf(sdsempty(),":%lu\r\n",server.lastsave));
2331 }
2332
2333 static void typeCommand(redisClient *c) {
2334 robj *o;
2335 char *type;
2336
2337 o = lookupKeyRead(c->db,c->argv[1]);
2338 if (o == NULL) {
2339 type = "+none";
2340 } else {
2341 switch(o->type) {
2342 case REDIS_STRING: type = "+string"; break;
2343 case REDIS_LIST: type = "+list"; break;
2344 case REDIS_SET: type = "+set"; break;
2345 default: type = "unknown"; break;
2346 }
2347 }
2348 addReplySds(c,sdsnew(type));
2349 addReply(c,shared.crlf);
2350 }
2351
2352 static void saveCommand(redisClient *c) {
2353 if (server.bgsaveinprogress) {
2354 addReplySds(c,sdsnew("-ERR background save in progress\r\n"));
2355 return;
2356 }
2357 if (rdbSave(server.dbfilename) == REDIS_OK) {
2358 addReply(c,shared.ok);
2359 } else {
2360 addReply(c,shared.err);
2361 }
2362 }
2363
2364 static void bgsaveCommand(redisClient *c) {
2365 if (server.bgsaveinprogress) {
2366 addReplySds(c,sdsnew("-ERR background save already in progress\r\n"));
2367 return;
2368 }
2369 if (rdbSaveBackground(server.dbfilename) == REDIS_OK) {
2370 addReply(c,shared.ok);
2371 } else {
2372 addReply(c,shared.err);
2373 }
2374 }
2375
2376 static void shutdownCommand(redisClient *c) {
2377 redisLog(REDIS_WARNING,"User requested shutdown, saving DB...");
2378 /* XXX: TODO kill the child if there is a bgsave in progress */
2379 if (rdbSave(server.dbfilename) == REDIS_OK) {
2380 if (server.daemonize) {
2381 unlink(server.pidfile);
2382 }
2383 redisLog(REDIS_WARNING,"Server exit now, bye bye...");
2384 exit(1);
2385 } else {
2386 redisLog(REDIS_WARNING,"Error trying to save the DB, can't exit");
2387 addReplySds(c,sdsnew("-ERR can't quit, problems saving the DB\r\n"));
2388 }
2389 }
2390
2391 static void renameGenericCommand(redisClient *c, int nx) {
2392 robj *o;
2393
2394 /* To use the same key as src and dst is probably an error */
2395 if (sdscmp(c->argv[1]->ptr,c->argv[2]->ptr) == 0) {
2396 addReply(c,shared.sameobjecterr);
2397 return;
2398 }
2399
2400 o = lookupKeyWrite(c->db,c->argv[1]);
2401 if (o == NULL) {
2402 addReply(c,shared.nokeyerr);
2403 return;
2404 }
2405 incrRefCount(o);
2406 deleteIfVolatile(c->db,c->argv[2]);
2407 if (dictAdd(c->db->dict,c->argv[2],o) == DICT_ERR) {
2408 if (nx) {
2409 decrRefCount(o);
2410 addReply(c,shared.czero);
2411 return;
2412 }
2413 dictReplace(c->db->dict,c->argv[2],o);
2414 } else {
2415 incrRefCount(c->argv[2]);
2416 }
2417 deleteKey(c->db,c->argv[1]);
2418 server.dirty++;
2419 addReply(c,nx ? shared.cone : shared.ok);
2420 }
2421
2422 static void renameCommand(redisClient *c) {
2423 renameGenericCommand(c,0);
2424 }
2425
2426 static void renamenxCommand(redisClient *c) {
2427 renameGenericCommand(c,1);
2428 }
2429
2430 static void moveCommand(redisClient *c) {
2431 robj *o;
2432 redisDb *src, *dst;
2433 int srcid;
2434
2435 /* Obtain source and target DB pointers */
2436 src = c->db;
2437 srcid = c->db->id;
2438 if (selectDb(c,atoi(c->argv[2]->ptr)) == REDIS_ERR) {
2439 addReply(c,shared.outofrangeerr);
2440 return;
2441 }
2442 dst = c->db;
2443 selectDb(c,srcid); /* Back to the source DB */
2444
2445 /* If the user is moving using as target the same
2446 * DB as the source DB it is probably an error. */
2447 if (src == dst) {
2448 addReply(c,shared.sameobjecterr);
2449 return;
2450 }
2451
2452 /* Check if the element exists and get a reference */
2453 o = lookupKeyWrite(c->db,c->argv[1]);
2454 if (!o) {
2455 addReply(c,shared.czero);
2456 return;
2457 }
2458
2459 /* Try to add the element to the target DB */
2460 deleteIfVolatile(dst,c->argv[1]);
2461 if (dictAdd(dst->dict,c->argv[1],o) == DICT_ERR) {
2462 addReply(c,shared.czero);
2463 return;
2464 }
2465 incrRefCount(c->argv[1]);
2466 incrRefCount(o);
2467
2468 /* OK! key moved, free the entry in the source DB */
2469 deleteKey(src,c->argv[1]);
2470 server.dirty++;
2471 addReply(c,shared.cone);
2472 }
2473
2474 /* =================================== Lists ================================ */
2475 static void pushGenericCommand(redisClient *c, int where) {
2476 robj *lobj;
2477 list *list;
2478
2479 lobj = lookupKeyWrite(c->db,c->argv[1]);
2480 if (lobj == NULL) {
2481 lobj = createListObject();
2482 list = lobj->ptr;
2483 if (where == REDIS_HEAD) {
2484 if (!listAddNodeHead(list,c->argv[2])) oom("listAddNodeHead");
2485 } else {
2486 if (!listAddNodeTail(list,c->argv[2])) oom("listAddNodeTail");
2487 }
2488 dictAdd(c->db->dict,c->argv[1],lobj);
2489 incrRefCount(c->argv[1]);
2490 incrRefCount(c->argv[2]);
2491 } else {
2492 if (lobj->type != REDIS_LIST) {
2493 addReply(c,shared.wrongtypeerr);
2494 return;
2495 }
2496 list = lobj->ptr;
2497 if (where == REDIS_HEAD) {
2498 if (!listAddNodeHead(list,c->argv[2])) oom("listAddNodeHead");
2499 } else {
2500 if (!listAddNodeTail(list,c->argv[2])) oom("listAddNodeTail");
2501 }
2502 incrRefCount(c->argv[2]);
2503 }
2504 server.dirty++;
2505 addReply(c,shared.ok);
2506 }
2507
2508 static void lpushCommand(redisClient *c) {
2509 pushGenericCommand(c,REDIS_HEAD);
2510 }
2511
2512 static void rpushCommand(redisClient *c) {
2513 pushGenericCommand(c,REDIS_TAIL);
2514 }
2515
2516 static void llenCommand(redisClient *c) {
2517 robj *o;
2518 list *l;
2519
2520 o = lookupKeyRead(c->db,c->argv[1]);
2521 if (o == NULL) {
2522 addReply(c,shared.czero);
2523 return;
2524 } else {
2525 if (o->type != REDIS_LIST) {
2526 addReply(c,shared.wrongtypeerr);
2527 } else {
2528 l = o->ptr;
2529 addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",listLength(l)));
2530 }
2531 }
2532 }
2533
2534 static void lindexCommand(redisClient *c) {
2535 robj *o;
2536 int index = atoi(c->argv[2]->ptr);
2537
2538 o = lookupKeyRead(c->db,c->argv[1]);
2539 if (o == NULL) {
2540 addReply(c,shared.nullbulk);
2541 } else {
2542 if (o->type != REDIS_LIST) {
2543 addReply(c,shared.wrongtypeerr);
2544 } else {
2545 list *list = o->ptr;
2546 listNode *ln;
2547
2548 ln = listIndex(list, index);
2549 if (ln == NULL) {
2550 addReply(c,shared.nullbulk);
2551 } else {
2552 robj *ele = listNodeValue(ln);
2553 addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(ele->ptr)));
2554 addReply(c,ele);
2555 addReply(c,shared.crlf);
2556 }
2557 }
2558 }
2559 }
2560
2561 static void lsetCommand(redisClient *c) {
2562 robj *o;
2563 int index = atoi(c->argv[2]->ptr);
2564
2565 o = lookupKeyWrite(c->db,c->argv[1]);
2566 if (o == NULL) {
2567 addReply(c,shared.nokeyerr);
2568 } else {
2569 if (o->type != REDIS_LIST) {
2570 addReply(c,shared.wrongtypeerr);
2571 } else {
2572 list *list = o->ptr;
2573 listNode *ln;
2574
2575 ln = listIndex(list, index);
2576 if (ln == NULL) {
2577 addReply(c,shared.outofrangeerr);
2578 } else {
2579 robj *ele = listNodeValue(ln);
2580
2581 decrRefCount(ele);
2582 listNodeValue(ln) = c->argv[3];
2583 incrRefCount(c->argv[3]);
2584 addReply(c,shared.ok);
2585 server.dirty++;
2586 }
2587 }
2588 }
2589 }
2590
2591 static void popGenericCommand(redisClient *c, int where) {
2592 robj *o;
2593
2594 o = lookupKeyWrite(c->db,c->argv[1]);
2595 if (o == NULL) {
2596 addReply(c,shared.nullbulk);
2597 } else {
2598 if (o->type != REDIS_LIST) {
2599 addReply(c,shared.wrongtypeerr);
2600 } else {
2601 list *list = o->ptr;
2602 listNode *ln;
2603
2604 if (where == REDIS_HEAD)
2605 ln = listFirst(list);
2606 else
2607 ln = listLast(list);
2608
2609 if (ln == NULL) {
2610 addReply(c,shared.nullbulk);
2611 } else {
2612 robj *ele = listNodeValue(ln);
2613 addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(ele->ptr)));
2614 addReply(c,ele);
2615 addReply(c,shared.crlf);
2616 listDelNode(list,ln);
2617 server.dirty++;
2618 }
2619 }
2620 }
2621 }
2622
2623 static void lpopCommand(redisClient *c) {
2624 popGenericCommand(c,REDIS_HEAD);
2625 }
2626
2627 static void rpopCommand(redisClient *c) {
2628 popGenericCommand(c,REDIS_TAIL);
2629 }
2630
2631 static void lrangeCommand(redisClient *c) {
2632 robj *o;
2633 int start = atoi(c->argv[2]->ptr);
2634 int end = atoi(c->argv[3]->ptr);
2635
2636 o = lookupKeyRead(c->db,c->argv[1]);
2637 if (o == NULL) {
2638 addReply(c,shared.nullmultibulk);
2639 } else {
2640 if (o->type != REDIS_LIST) {
2641 addReply(c,shared.wrongtypeerr);
2642 } else {
2643 list *list = o->ptr;
2644 listNode *ln;
2645 int llen = listLength(list);
2646 int rangelen, j;
2647 robj *ele;
2648
2649 /* convert negative indexes */
2650 if (start < 0) start = llen+start;
2651 if (end < 0) end = llen+end;
2652 if (start < 0) start = 0;
2653 if (end < 0) end = 0;
2654
2655 /* indexes sanity checks */
2656 if (start > end || start >= llen) {
2657 /* Out of range start or start > end result in empty list */
2658 addReply(c,shared.emptymultibulk);
2659 return;
2660 }
2661 if (end >= llen) end = llen-1;
2662 rangelen = (end-start)+1;
2663
2664 /* Return the result in form of a multi-bulk reply */
2665 ln = listIndex(list, start);
2666 addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",rangelen));
2667 for (j = 0; j < rangelen; j++) {
2668 ele = listNodeValue(ln);
2669 addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(ele->ptr)));
2670 addReply(c,ele);
2671 addReply(c,shared.crlf);
2672 ln = ln->next;
2673 }
2674 }
2675 }
2676 }
2677
2678 static void ltrimCommand(redisClient *c) {
2679 robj *o;
2680 int start = atoi(c->argv[2]->ptr);
2681 int end = atoi(c->argv[3]->ptr);
2682
2683 o = lookupKeyWrite(c->db,c->argv[1]);
2684 if (o == NULL) {
2685 addReply(c,shared.nokeyerr);
2686 } else {
2687 if (o->type != REDIS_LIST) {
2688 addReply(c,shared.wrongtypeerr);
2689 } else {
2690 list *list = o->ptr;
2691 listNode *ln;
2692 int llen = listLength(list);
2693 int j, ltrim, rtrim;
2694
2695 /* convert negative indexes */
2696 if (start < 0) start = llen+start;
2697 if (end < 0) end = llen+end;
2698 if (start < 0) start = 0;
2699 if (end < 0) end = 0;
2700
2701 /* indexes sanity checks */
2702 if (start > end || start >= llen) {
2703 /* Out of range start or start > end result in empty list */
2704 ltrim = llen;
2705 rtrim = 0;
2706 } else {
2707 if (end >= llen) end = llen-1;
2708 ltrim = start;
2709 rtrim = llen-end-1;
2710 }
2711
2712 /* Remove list elements to perform the trim */
2713 for (j = 0; j < ltrim; j++) {
2714 ln = listFirst(list);
2715 listDelNode(list,ln);
2716 }
2717 for (j = 0; j < rtrim; j++) {
2718 ln = listLast(list);
2719 listDelNode(list,ln);
2720 }
2721 addReply(c,shared.ok);
2722 server.dirty++;
2723 }
2724 }
2725 }
2726
2727 static void lremCommand(redisClient *c) {
2728 robj *o;
2729
2730 o = lookupKeyWrite(c->db,c->argv[1]);
2731 if (o == NULL) {
2732 addReply(c,shared.nokeyerr);
2733 } else {
2734 if (o->type != REDIS_LIST) {
2735 addReply(c,shared.wrongtypeerr);
2736 } else {
2737 list *list = o->ptr;
2738 listNode *ln, *next;
2739 int toremove = atoi(c->argv[2]->ptr);
2740 int removed = 0;
2741 int fromtail = 0;
2742
2743 if (toremove < 0) {
2744 toremove = -toremove;
2745 fromtail = 1;
2746 }
2747 ln = fromtail ? list->tail : list->head;
2748 while (ln) {
2749 robj *ele = listNodeValue(ln);
2750
2751 next = fromtail ? ln->prev : ln->next;
2752 if (sdscmp(ele->ptr,c->argv[3]->ptr) == 0) {
2753 listDelNode(list,ln);
2754 server.dirty++;
2755 removed++;
2756 if (toremove && removed == toremove) break;
2757 }
2758 ln = next;
2759 }
2760 addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",removed));
2761 }
2762 }
2763 }
2764
2765 /* ==================================== Sets ================================ */
2766
2767 static void saddCommand(redisClient *c) {
2768 robj *set;
2769
2770 set = lookupKeyWrite(c->db,c->argv[1]);
2771 if (set == NULL) {
2772 set = createSetObject();
2773 dictAdd(c->db->dict,c->argv[1],set);
2774 incrRefCount(c->argv[1]);
2775 } else {
2776 if (set->type != REDIS_SET) {
2777 addReply(c,shared.wrongtypeerr);
2778 return;
2779 }
2780 }
2781 if (dictAdd(set->ptr,c->argv[2],NULL) == DICT_OK) {
2782 incrRefCount(c->argv[2]);
2783 server.dirty++;
2784 addReply(c,shared.cone);
2785 } else {
2786 addReply(c,shared.czero);
2787 }
2788 }
2789
2790 static void sremCommand(redisClient *c) {
2791 robj *set;
2792
2793 set = lookupKeyWrite(c->db,c->argv[1]);
2794 if (set == NULL) {
2795 addReply(c,shared.czero);
2796 } else {
2797 if (set->type != REDIS_SET) {
2798 addReply(c,shared.wrongtypeerr);
2799 return;
2800 }
2801 if (dictDelete(set->ptr,c->argv[2]) == DICT_OK) {
2802 server.dirty++;
2803 addReply(c,shared.cone);
2804 } else {
2805 addReply(c,shared.czero);
2806 }
2807 }
2808 }
2809
2810 static void sismemberCommand(redisClient *c) {
2811 robj *set;
2812
2813 set = lookupKeyRead(c->db,c->argv[1]);
2814 if (set == NULL) {
2815 addReply(c,shared.czero);
2816 } else {
2817 if (set->type != REDIS_SET) {
2818 addReply(c,shared.wrongtypeerr);
2819 return;
2820 }
2821 if (dictFind(set->ptr,c->argv[2]))
2822 addReply(c,shared.cone);
2823 else
2824 addReply(c,shared.czero);
2825 }
2826 }
2827
2828 static void scardCommand(redisClient *c) {
2829 robj *o;
2830 dict *s;
2831
2832 o = lookupKeyRead(c->db,c->argv[1]);
2833 if (o == NULL) {
2834 addReply(c,shared.czero);
2835 return;
2836 } else {
2837 if (o->type != REDIS_SET) {
2838 addReply(c,shared.wrongtypeerr);
2839 } else {
2840 s = o->ptr;
2841 addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",
2842 dictSize(s)));
2843 }
2844 }
2845 }
2846
2847 static int qsortCompareSetsByCardinality(const void *s1, const void *s2) {
2848 dict **d1 = (void*) s1, **d2 = (void*) s2;
2849
2850 return dictSize(*d1)-dictSize(*d2);
2851 }
2852
2853 static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, robj *dstkey) {
2854 dict **dv = zmalloc(sizeof(dict*)*setsnum);
2855 dictIterator *di;
2856 dictEntry *de;
2857 robj *lenobj = NULL, *dstset = NULL;
2858 int j, cardinality = 0;
2859
2860 if (!dv) oom("sinterCommand");
2861 for (j = 0; j < setsnum; j++) {
2862 robj *setobj;
2863
2864 setobj = dstkey ?
2865 lookupKeyWrite(c->db,setskeys[j]) :
2866 lookupKeyRead(c->db,setskeys[j]);
2867 if (!setobj) {
2868 zfree(dv);
2869 if (dstkey) {
2870 deleteKey(c->db,dstkey);
2871 addReply(c,shared.ok);
2872 } else {
2873 addReply(c,shared.nullmultibulk);
2874 }
2875 return;
2876 }
2877 if (setobj->type != REDIS_SET) {
2878 zfree(dv);
2879 addReply(c,shared.wrongtypeerr);
2880 return;
2881 }
2882 dv[j] = setobj->ptr;
2883 }
2884 /* Sort sets from the smallest to largest, this will improve our
2885 * algorithm's performace */
2886 qsort(dv,setsnum,sizeof(dict*),qsortCompareSetsByCardinality);
2887
2888 /* The first thing we should output is the total number of elements...
2889 * since this is a multi-bulk write, but at this stage we don't know
2890 * the intersection set size, so we use a trick, append an empty object
2891 * to the output list and save the pointer to later modify it with the
2892 * right length */
2893 if (!dstkey) {
2894 lenobj = createObject(REDIS_STRING,NULL);
2895 addReply(c,lenobj);
2896 decrRefCount(lenobj);
2897 } else {
2898 /* If we have a target key where to store the resulting set
2899 * create this key with an empty set inside */
2900 dstset = createSetObject();
2901 deleteKey(c->db,dstkey);
2902 dictAdd(c->db->dict,dstkey,dstset);
2903 incrRefCount(dstkey);
2904 }
2905
2906 /* Iterate all the elements of the first (smallest) set, and test
2907 * the element against all the other sets, if at least one set does
2908 * not include the element it is discarded */
2909 di = dictGetIterator(dv[0]);
2910 if (!di) oom("dictGetIterator");
2911
2912 while((de = dictNext(di)) != NULL) {
2913 robj *ele;
2914
2915 for (j = 1; j < setsnum; j++)
2916 if (dictFind(dv[j],dictGetEntryKey(de)) == NULL) break;
2917 if (j != setsnum)
2918 continue; /* at least one set does not contain the member */
2919 ele = dictGetEntryKey(de);
2920 if (!dstkey) {
2921 addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",sdslen(ele->ptr)));
2922 addReply(c,ele);
2923 addReply(c,shared.crlf);
2924 cardinality++;
2925 } else {
2926 dictAdd(dstset->ptr,ele,NULL);
2927 incrRefCount(ele);
2928 }
2929 }
2930 dictReleaseIterator(di);
2931
2932 if (!dstkey) {
2933 lenobj->ptr = sdscatprintf(sdsempty(),"*%d\r\n",cardinality);
2934 } else {
2935 addReply(c,shared.ok);
2936 server.dirty++;
2937 }
2938 zfree(dv);
2939 }
2940
2941 static void sinterCommand(redisClient *c) {
2942 sinterGenericCommand(c,c->argv+1,c->argc-1,NULL);
2943 }
2944
2945 static void sinterstoreCommand(redisClient *c) {
2946 sinterGenericCommand(c,c->argv+2,c->argc-2,c->argv[1]);
2947 }
2948
2949 static void sunionGenericCommand(redisClient *c, robj **setskeys, int setsnum, robj *dstkey) {
2950 dict **dv = zmalloc(sizeof(dict*)*setsnum);
2951 dictIterator *di;
2952 dictEntry *de;
2953 robj *lenobj = NULL, *dstset = NULL;
2954 int j, cardinality = 0;
2955
2956 if (!dv) oom("sunionCommand");
2957 for (j = 0; j < setsnum; j++) {
2958 robj *setobj;
2959
2960 setobj = dstkey ?
2961 lookupKeyWrite(c->db,setskeys[j]) :
2962 lookupKeyRead(c->db,setskeys[j]);
2963 if (!setobj) {
2964 dv[j] = NULL;
2965 continue;
2966 }
2967 if (setobj->type != REDIS_SET) {
2968 zfree(dv);
2969 addReply(c,shared.wrongtypeerr);
2970 return;
2971 }
2972 dv[j] = setobj->ptr;
2973 }
2974
2975 /* We need a temp set object to store our union. If the dstkey
2976 * is not NULL (that is, we are inside an SUNIONSTORE operation) then
2977 * this set object will be the resulting object to set into the target key*/
2978 dstset = createSetObject();
2979
2980 /* The first thing we should output is the total number of elements...
2981 * since this is a multi-bulk write, but at this stage we don't know
2982 * the intersection set size, so we use a trick, append an empty object
2983 * to the output list and save the pointer to later modify it with the
2984 * right length */
2985 if (!dstkey) {
2986 lenobj = createObject(REDIS_STRING,NULL);
2987 addReply(c,lenobj);
2988 decrRefCount(lenobj);
2989 } else {
2990 /* If we have a target key where to store the resulting set
2991 * create this key with an empty set inside */
2992 deleteKey(c->db,dstkey);
2993 dictAdd(c->db->dict,dstkey,dstset);
2994 incrRefCount(dstkey);
2995 server.dirty++;
2996 }
2997
2998 /* Iterate all the elements of all the sets, add every element a single
2999 * time to the result set */
3000 for (j = 0; j < setsnum; j++) {
3001 if (!dv[j]) continue; /* non existing keys are like empty sets */
3002
3003 di = dictGetIterator(dv[j]);
3004 if (!di) oom("dictGetIterator");
3005
3006 while((de = dictNext(di)) != NULL) {
3007 robj *ele;
3008
3009 /* dictAdd will not add the same element multiple times */
3010 ele = dictGetEntryKey(de);
3011 if (dictAdd(dstset->ptr,ele,NULL) == DICT_OK) {
3012 incrRefCount(ele);
3013 if (!dstkey) {
3014 addReplySds(c,sdscatprintf(sdsempty(),
3015 "$%d\r\n",sdslen(ele->ptr)));
3016 addReply(c,ele);
3017 addReply(c,shared.crlf);
3018 cardinality++;
3019 }
3020 }
3021 }
3022 dictReleaseIterator(di);
3023 }
3024
3025 if (!dstkey) {
3026 lenobj->ptr = sdscatprintf(sdsempty(),"*%d\r\n",cardinality);
3027 decrRefCount(dstset);
3028 } else {
3029 addReply(c,shared.ok);
3030 server.dirty++;
3031 }
3032 zfree(dv);
3033 }
3034
3035 static void sunionCommand(redisClient *c) {
3036 sunionGenericCommand(c,c->argv+1,c->argc-1,NULL);
3037 }
3038
3039 static void sunionstoreCommand(redisClient *c) {
3040 sunionGenericCommand(c,c->argv+2,c->argc-2,c->argv[1]);
3041 }
3042
3043 static void flushdbCommand(redisClient *c) {
3044 server.dirty += dictSize(c->db->dict);
3045 dictEmpty(c->db->dict);
3046 dictEmpty(c->db->expires);
3047 addReply(c,shared.ok);
3048 }
3049
3050 static void flushallCommand(redisClient *c) {
3051 server.dirty += emptyDb();
3052 addReply(c,shared.ok);
3053 rdbSave(server.dbfilename);
3054 server.dirty++;
3055 }
3056
3057 redisSortOperation *createSortOperation(int type, robj *pattern) {
3058 redisSortOperation *so = zmalloc(sizeof(*so));
3059 if (!so) oom("createSortOperation");
3060 so->type = type;
3061 so->pattern = pattern;
3062 return so;
3063 }
3064
3065 /* Return the value associated to the key with a name obtained
3066 * substituting the first occurence of '*' in 'pattern' with 'subst' */
3067 robj *lookupKeyByPattern(redisDb *db, robj *pattern, robj *subst) {
3068 char *p;
3069 sds spat, ssub;
3070 robj keyobj;
3071 int prefixlen, sublen, postfixlen;
3072 /* Expoit the internal sds representation to create a sds string allocated on the stack in order to make this function faster */
3073 struct {
3074 long len;
3075 long free;
3076 char buf[REDIS_SORTKEY_MAX+1];
3077 } keyname;
3078
3079 spat = pattern->ptr;
3080 ssub = subst->ptr;
3081 if (sdslen(spat)+sdslen(ssub)-1 > REDIS_SORTKEY_MAX) return NULL;
3082 p = strchr(spat,'*');
3083 if (!p) return NULL;
3084
3085 prefixlen = p-spat;
3086 sublen = sdslen(ssub);
3087 postfixlen = sdslen(spat)-(prefixlen+1);
3088 memcpy(keyname.buf,spat,prefixlen);
3089 memcpy(keyname.buf+prefixlen,ssub,sublen);
3090 memcpy(keyname.buf+prefixlen+sublen,p+1,postfixlen);
3091 keyname.buf[prefixlen+sublen+postfixlen] = '\0';
3092 keyname.len = prefixlen+sublen+postfixlen;
3093
3094 keyobj.refcount = 1;
3095 keyobj.type = REDIS_STRING;
3096 keyobj.ptr = ((char*)&keyname)+(sizeof(long)*2);
3097
3098 /* printf("lookup '%s' => %p\n", keyname.buf,de); */
3099 return lookupKeyRead(db,&keyobj);
3100 }
3101
3102 /* sortCompare() is used by qsort in sortCommand(). Given that qsort_r with
3103 * the additional parameter is not standard but a BSD-specific we have to
3104 * pass sorting parameters via the global 'server' structure */
3105 static int sortCompare(const void *s1, const void *s2) {
3106 const redisSortObject *so1 = s1, *so2 = s2;
3107 int cmp;
3108
3109 if (!server.sort_alpha) {
3110 /* Numeric sorting. Here it's trivial as we precomputed scores */
3111 if (so1->u.score > so2->u.score) {
3112 cmp = 1;
3113 } else if (so1->u.score < so2->u.score) {
3114 cmp = -1;
3115 } else {
3116 cmp = 0;
3117 }
3118 } else {
3119 /* Alphanumeric sorting */
3120 if (server.sort_bypattern) {
3121 if (!so1->u.cmpobj || !so2->u.cmpobj) {
3122 /* At least one compare object is NULL */
3123 if (so1->u.cmpobj == so2->u.cmpobj)
3124 cmp = 0;
3125 else if (so1->u.cmpobj == NULL)
3126 cmp = -1;
3127 else
3128 cmp = 1;
3129 } else {
3130 /* We have both the objects, use strcoll */
3131 cmp = strcoll(so1->u.cmpobj->ptr,so2->u.cmpobj->ptr);
3132 }
3133 } else {
3134 /* Compare elements directly */
3135 cmp = strcoll(so1->obj->ptr,so2->obj->ptr);
3136 }
3137 }
3138 return server.sort_desc ? -cmp : cmp;
3139 }
3140
3141 /* The SORT command is the most complex command in Redis. Warning: this code
3142 * is optimized for speed and a bit less for readability */
3143 static void sortCommand(redisClient *c) {
3144 list *operations;
3145 int outputlen = 0;
3146 int desc = 0, alpha = 0;
3147 int limit_start = 0, limit_count = -1, start, end;
3148 int j, dontsort = 0, vectorlen;
3149 int getop = 0; /* GET operation counter */
3150 robj *sortval, *sortby = NULL;
3151 redisSortObject *vector; /* Resulting vector to sort */
3152
3153 /* Lookup the key to sort. It must be of the right types */
3154 sortval = lookupKeyRead(c->db,c->argv[1]);
3155 if (sortval == NULL) {
3156 addReply(c,shared.nokeyerr);
3157 return;
3158 }
3159 if (sortval->type != REDIS_SET && sortval->type != REDIS_LIST) {
3160 addReply(c,shared.wrongtypeerr);
3161 return;
3162 }
3163
3164 /* Create a list of operations to perform for every sorted element.
3165 * Operations can be GET/DEL/INCR/DECR */
3166 operations = listCreate();
3167 listSetFreeMethod(operations,zfree);
3168 j = 2;
3169
3170 /* Now we need to protect sortval incrementing its count, in the future
3171 * SORT may have options able to overwrite/delete keys during the sorting
3172 * and the sorted key itself may get destroied */
3173 incrRefCount(sortval);
3174
3175 /* The SORT command has an SQL-alike syntax, parse it */
3176 while(j < c->argc) {
3177 int leftargs = c->argc-j-1;
3178 if (!strcasecmp(c->argv[j]->ptr,"asc")) {
3179 desc = 0;
3180 } else if (!strcasecmp(c->argv[j]->ptr,"desc")) {
3181 desc = 1;
3182 } else if (!strcasecmp(c->argv[j]->ptr,"alpha")) {
3183 alpha = 1;
3184 } else if (!strcasecmp(c->argv[j]->ptr,"limit") && leftargs >= 2) {
3185 limit_start = atoi(c->argv[j+1]->ptr);
3186 limit_count = atoi(c->argv[j+2]->ptr);
3187 j+=2;
3188 } else if (!strcasecmp(c->argv[j]->ptr,"by") && leftargs >= 1) {
3189 sortby = c->argv[j+1];
3190 /* If the BY pattern does not contain '*', i.e. it is constant,
3191 * we don't need to sort nor to lookup the weight keys. */
3192 if (strchr(c->argv[j+1]->ptr,'*') == NULL) dontsort = 1;
3193 j++;
3194 } else if (!strcasecmp(c->argv[j]->ptr,"get") && leftargs >= 1) {
3195 listAddNodeTail(operations,createSortOperation(
3196 REDIS_SORT_GET,c->argv[j+1]));
3197 getop++;
3198 j++;
3199 } else if (!strcasecmp(c->argv[j]->ptr,"del") && leftargs >= 1) {
3200 listAddNodeTail(operations,createSortOperation(
3201 REDIS_SORT_DEL,c->argv[j+1]));
3202 j++;
3203 } else if (!strcasecmp(c->argv[j]->ptr,"incr") && leftargs >= 1) {
3204 listAddNodeTail(operations,createSortOperation(
3205 REDIS_SORT_INCR,c->argv[j+1]));
3206 j++;
3207 } else if (!strcasecmp(c->argv[j]->ptr,"get") && leftargs >= 1) {
3208 listAddNodeTail(operations,createSortOperation(
3209 REDIS_SORT_DECR,c->argv[j+1]));
3210 j++;
3211 } else {
3212 decrRefCount(sortval);
3213 listRelease(operations);
3214 addReply(c,shared.syntaxerr);
3215 return;
3216 }
3217 j++;
3218 }
3219
3220 /* Load the sorting vector with all the objects to sort */
3221 vectorlen = (sortval->type == REDIS_LIST) ?
3222 listLength((list*)sortval->ptr) :
3223 dictSize((dict*)sortval->ptr);
3224 vector = zmalloc(sizeof(redisSortObject)*vectorlen);
3225 if (!vector) oom("allocating objects vector for SORT");
3226 j = 0;
3227 if (sortval->type == REDIS_LIST) {
3228 list *list = sortval->ptr;
3229 listNode *ln;
3230
3231 listRewind(list);
3232 while((ln = listYield(list))) {
3233 robj *ele = ln->value;
3234 vector[j].obj = ele;
3235 vector[j].u.score = 0;
3236 vector[j].u.cmpobj = NULL;
3237 j++;
3238 }
3239 } else {
3240 dict *set = sortval->ptr;
3241 dictIterator *di;
3242 dictEntry *setele;
3243
3244 di = dictGetIterator(set);
3245 if (!di) oom("dictGetIterator");
3246 while((setele = dictNext(di)) != NULL) {
3247 vector[j].obj = dictGetEntryKey(setele);
3248 vector[j].u.score = 0;
3249 vector[j].u.cmpobj = NULL;
3250 j++;
3251 }
3252 dictReleaseIterator(di);
3253 }
3254 assert(j == vectorlen);
3255
3256 /* Now it's time to load the right scores in the sorting vector */
3257 if (dontsort == 0) {
3258 for (j = 0; j < vectorlen; j++) {
3259 if (sortby) {
3260 robj *byval;
3261
3262 byval = lookupKeyByPattern(c->db,sortby,vector[j].obj);
3263 if (!byval || byval->type != REDIS_STRING) continue;
3264 if (alpha) {
3265 vector[j].u.cmpobj = byval;
3266 incrRefCount(byval);
3267 } else {
3268 vector[j].u.score = strtod(byval->ptr,NULL);
3269 }
3270 } else {
3271 if (!alpha) vector[j].u.score = strtod(vector[j].obj->ptr,NULL);
3272 }
3273 }
3274 }
3275
3276 /* We are ready to sort the vector... perform a bit of sanity check
3277 * on the LIMIT option too. We'll use a partial version of quicksort. */
3278 start = (limit_start < 0) ? 0 : limit_start;
3279 end = (limit_count < 0) ? vectorlen-1 : start+limit_count-1;
3280 if (start >= vectorlen) {
3281 start = vectorlen-1;
3282 end = vectorlen-2;
3283 }
3284 if (end >= vectorlen) end = vectorlen-1;
3285
3286 if (dontsort == 0) {
3287 server.sort_desc = desc;
3288 server.sort_alpha = alpha;
3289 server.sort_bypattern = sortby ? 1 : 0;
3290 qsort(vector,vectorlen,sizeof(redisSortObject),sortCompare);
3291 }
3292
3293 /* Send command output to the output buffer, performing the specified
3294 * GET/DEL/INCR/DECR operations if any. */
3295 outputlen = getop ? getop*(end-start+1) : end-start+1;
3296 addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",outputlen));
3297 for (j = start; j <= end; j++) {
3298 listNode *ln;
3299 if (!getop) {
3300 addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",
3301 sdslen(vector[j].obj->ptr)));
3302 addReply(c,vector[j].obj);
3303 addReply(c,shared.crlf);
3304 }
3305 listRewind(operations);
3306 while((ln = listYield(operations))) {
3307 redisSortOperation *sop = ln->value;
3308 robj *val = lookupKeyByPattern(c->db,sop->pattern,
3309 vector[j].obj);
3310
3311 if (sop->type == REDIS_SORT_GET) {
3312 if (!val || val->type != REDIS_STRING) {
3313 addReply(c,shared.nullbulk);
3314 } else {
3315 addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",
3316 sdslen(val->ptr)));
3317 addReply(c,val);
3318 addReply(c,shared.crlf);
3319 }
3320 } else if (sop->type == REDIS_SORT_DEL) {
3321 /* TODO */
3322 }
3323 }
3324 }
3325
3326 /* Cleanup */
3327 decrRefCount(sortval);
3328 listRelease(operations);
3329 for (j = 0; j < vectorlen; j++) {
3330 if (sortby && alpha && vector[j].u.cmpobj)
3331 decrRefCount(vector[j].u.cmpobj);
3332 }
3333 zfree(vector);
3334 }
3335
3336 static void infoCommand(redisClient *c) {
3337 sds info;
3338 time_t uptime = time(NULL)-server.stat_starttime;
3339
3340 info = sdscatprintf(sdsempty(),
3341 "redis_version:%s\r\n"
3342 "connected_clients:%d\r\n"
3343 "connected_slaves:%d\r\n"
3344 "used_memory:%zu\r\n"
3345 "changes_since_last_save:%lld\r\n"
3346 "last_save_time:%d\r\n"
3347 "total_connections_received:%lld\r\n"
3348 "total_commands_processed:%lld\r\n"
3349 "uptime_in_seconds:%d\r\n"
3350 "uptime_in_days:%d\r\n"
3351 ,REDIS_VERSION,
3352 listLength(server.clients)-listLength(server.slaves),
3353 listLength(server.slaves),
3354 server.usedmemory,
3355 server.dirty,
3356 server.lastsave,
3357 server.stat_numconnections,
3358 server.stat_numcommands,
3359 uptime,
3360 uptime/(3600*24)
3361 );
3362 addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",sdslen(info)));
3363 addReplySds(c,info);
3364 addReply(c,shared.crlf);
3365 }
3366
3367 static void monitorCommand(redisClient *c) {
3368 /* ignore MONITOR if aleady slave or in monitor mode */
3369 if (c->flags & REDIS_SLAVE) return;
3370
3371 c->flags |= (REDIS_SLAVE|REDIS_MONITOR);
3372 c->slaveseldb = 0;
3373 if (!listAddNodeTail(server.monitors,c)) oom("listAddNodeTail");
3374 addReply(c,shared.ok);
3375 }
3376
3377 /* ================================= Expire ================================= */
3378 static int removeExpire(redisDb *db, robj *key) {
3379 if (dictDelete(db->expires,key) == DICT_OK) {
3380 return 1;
3381 } else {
3382 return 0;
3383 }
3384 }
3385
3386 static int setExpire(redisDb *db, robj *key, time_t when) {
3387 if (dictAdd(db->expires,key,(void*)when) == DICT_ERR) {
3388 return 0;
3389 } else {
3390 incrRefCount(key);
3391 return 1;
3392 }
3393 }
3394
3395 /* Return the expire time of the specified key, or -1 if no expire
3396 * is associated with this key (i.e. the key is non volatile) */
3397 static time_t getExpire(redisDb *db, robj *key) {
3398 dictEntry *de;
3399
3400 /* No expire? return ASAP */
3401 if (dictSize(db->expires) == 0 ||
3402 (de = dictFind(db->expires,key)) == NULL) return -1;
3403
3404 return (time_t) dictGetEntryVal(de);
3405 }
3406
3407 static int expireIfNeeded(redisDb *db, robj *key) {
3408 time_t when;
3409 dictEntry *de;
3410
3411 /* No expire? return ASAP */
3412 if (dictSize(db->expires) == 0 ||
3413 (de = dictFind(db->expires,key)) == NULL) return 0;
3414
3415 /* Lookup the expire */
3416 when = (time_t) dictGetEntryVal(de);
3417 if (time(NULL) <= when) return 0;
3418
3419 /* Delete the key */
3420 dictDelete(db->expires,key);
3421 return dictDelete(db->dict,key) == DICT_OK;
3422 }
3423
3424 static int deleteIfVolatile(redisDb *db, robj *key) {
3425 dictEntry *de;
3426
3427 /* No expire? return ASAP */
3428 if (dictSize(db->expires) == 0 ||
3429 (de = dictFind(db->expires,key)) == NULL) return 0;
3430
3431 /* Delete the key */
3432 server.dirty++;
3433 dictDelete(db->expires,key);
3434 return dictDelete(db->dict,key) == DICT_OK;
3435 }
3436
3437 static void expireCommand(redisClient *c) {
3438 dictEntry *de;
3439 int seconds = atoi(c->argv[2]->ptr);
3440
3441 de = dictFind(c->db->dict,c->argv[1]);
3442 if (de == NULL) {
3443 addReply(c,shared.czero);
3444 return;
3445 }
3446 if (seconds <= 0) {
3447 addReply(c, shared.czero);
3448 return;
3449 } else {
3450 time_t when = time(NULL)+seconds;
3451 if (setExpire(c->db,c->argv[1],when))
3452 addReply(c,shared.cone);
3453 else
3454 addReply(c,shared.czero);
3455 return;
3456 }
3457 }
3458
3459 /* =============================== Replication ============================= */
3460
3461 static int syncWrite(int fd, char *ptr, ssize_t size, int timeout) {
3462 ssize_t nwritten, ret = size;
3463 time_t start = time(NULL);
3464
3465 timeout++;
3466 while(size) {
3467 if (aeWait(fd,AE_WRITABLE,1000) & AE_WRITABLE) {
3468 nwritten = write(fd,ptr,size);
3469 if (nwritten == -1) return -1;
3470 ptr += nwritten;
3471 size -= nwritten;
3472 }
3473 if ((time(NULL)-start) > timeout) {
3474 errno = ETIMEDOUT;
3475 return -1;
3476 }
3477 }
3478 return ret;
3479 }
3480
3481 static int syncRead(int fd, char *ptr, ssize_t size, int timeout) {
3482 ssize_t nread, totread = 0;
3483 time_t start = time(NULL);
3484
3485 timeout++;
3486 while(size) {
3487 if (aeWait(fd,AE_READABLE,1000) & AE_READABLE) {
3488 nread = read(fd,ptr,size);
3489 if (nread == -1) return -1;
3490 ptr += nread;
3491 size -= nread;
3492 totread += nread;
3493 }
3494 if ((time(NULL)-start) > timeout) {
3495 errno = ETIMEDOUT;
3496 return -1;
3497 }
3498 }
3499 return totread;
3500 }
3501
3502 static int syncReadLine(int fd, char *ptr, ssize_t size, int timeout) {
3503 ssize_t nread = 0;
3504
3505 size--;
3506 while(size) {
3507 char c;
3508
3509 if (syncRead(fd,&c,1,timeout) == -1) return -1;
3510 if (c == '\n') {
3511 *ptr = '\0';
3512 if (nread && *(ptr-1) == '\r') *(ptr-1) = '\0';
3513 return nread;
3514 } else {
3515 *ptr++ = c;
3516 *ptr = '\0';
3517 nread++;
3518 }
3519 }
3520 return nread;
3521 }
3522
3523 static void syncCommand(redisClient *c) {
3524 /* ignore SYNC if aleady slave or in monitor mode */
3525 if (c->flags & REDIS_SLAVE) return;
3526
3527 /* SYNC can't be issued when the server has pending data to send to
3528 * the client about already issued commands. We need a fresh reply
3529 * buffer registering the differences between the BGSAVE and the current
3530 * dataset, so that we can copy to other slaves if needed. */
3531 if (listLength(c->reply) != 0) {
3532 addReplySds(c,sdsnew("-ERR SYNC is invalid with pending input\r\n"));
3533 return;
3534 }
3535
3536 redisLog(REDIS_NOTICE,"Slave ask for synchronization");
3537 /* Here we need to check if there is a background saving operation
3538 * in progress, or if it is required to start one */
3539 if (server.bgsaveinprogress) {
3540 /* Ok a background save is in progress. Let's check if it is a good
3541 * one for replication, i.e. if there is another slave that is
3542 * registering differences since the server forked to save */
3543 redisClient *slave;
3544 listNode *ln;
3545
3546 listRewind(server.slaves);
3547 while((ln = listYield(server.slaves))) {
3548 slave = ln->value;
3549 if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_END) break;
3550 }
3551 if (ln) {
3552 /* Perfect, the server is already registering differences for
3553 * another slave. Set the right state, and copy the buffer. */
3554 listRelease(c->reply);
3555 c->reply = listDup(slave->reply);
3556 if (!c->reply) oom("listDup copying slave reply list");
3557 c->replstate = REDIS_REPL_WAIT_BGSAVE_END;
3558 redisLog(REDIS_NOTICE,"Waiting for end of BGSAVE for SYNC");
3559 } else {
3560 /* No way, we need to wait for the next BGSAVE in order to
3561 * register differences */
3562 c->replstate = REDIS_REPL_WAIT_BGSAVE_START;
3563 redisLog(REDIS_NOTICE,"Waiting for next BGSAVE for SYNC");
3564 }
3565 } else {
3566 /* Ok we don't have a BGSAVE in progress, let's start one */
3567 redisLog(REDIS_NOTICE,"Starting BGSAVE for SYNC");
3568 if (rdbSaveBackground(server.dbfilename) != REDIS_OK) {
3569 redisLog(REDIS_NOTICE,"Replication failed, can't BGSAVE");
3570 addReplySds(c,sdsnew("-ERR Unalbe to perform background save\r\n"));
3571 return;
3572 }
3573 c->replstate = REDIS_REPL_WAIT_BGSAVE_END;
3574 }
3575 c->repldbfd = -1;
3576 c->flags |= REDIS_SLAVE;
3577 c->slaveseldb = 0;
3578 if (!listAddNodeTail(server.slaves,c)) oom("listAddNodeTail");
3579 return;
3580 }
3581
3582 static void sendBulkToSlave(aeEventLoop *el, int fd, void *privdata, int mask) {
3583 redisClient *slave = privdata;
3584 REDIS_NOTUSED(el);
3585 REDIS_NOTUSED(mask);
3586 char buf[REDIS_IOBUF_LEN];
3587 ssize_t nwritten, buflen;
3588
3589 if (slave->repldboff == 0) {
3590 /* Write the bulk write count before to transfer the DB. In theory here
3591 * we don't know how much room there is in the output buffer of the
3592 * socket, but in pratice SO_SNDLOWAT (the minimum count for output
3593 * operations) will never be smaller than the few bytes we need. */
3594 sds bulkcount;
3595
3596 bulkcount = sdscatprintf(sdsempty(),"$%lld\r\n",(unsigned long long)
3597 slave->repldbsize);
3598 if (write(fd,bulkcount,sdslen(bulkcount)) != (signed)sdslen(bulkcount))
3599 {
3600 sdsfree(bulkcount);
3601 freeClient(slave);
3602 return;
3603 }
3604 sdsfree(bulkcount);
3605 }
3606 lseek(slave->repldbfd,slave->repldboff,SEEK_SET);
3607 buflen = read(slave->repldbfd,buf,REDIS_IOBUF_LEN);
3608 if (buflen <= 0) {
3609 redisLog(REDIS_WARNING,"Read error sending DB to slave: %s",
3610 (buflen == 0) ? "premature EOF" : strerror(errno));
3611 freeClient(slave);
3612 return;
3613 }
3614 if ((nwritten = write(fd,buf,buflen)) == -1) {
3615 redisLog(REDIS_DEBUG,"Write error sending DB to slave: %s",
3616 strerror(errno));
3617 freeClient(slave);
3618 return;
3619 }
3620 slave->repldboff += nwritten;
3621 if (slave->repldboff == slave->repldbsize) {
3622 close(slave->repldbfd);
3623 slave->repldbfd = -1;
3624 aeDeleteFileEvent(server.el,slave->fd,AE_WRITABLE);
3625 slave->replstate = REDIS_REPL_ONLINE;
3626 if (aeCreateFileEvent(server.el, slave->fd, AE_WRITABLE,
3627 sendReplyToClient, slave, NULL) == AE_ERR) {
3628 freeClient(slave);
3629 return;
3630 }
3631 addReplySds(slave,sdsempty());
3632 redisLog(REDIS_NOTICE,"Synchronization with slave succeeded");
3633 }
3634 }
3635
3636 static void updateSalvesWaitingBgsave(int bgsaveerr) {
3637 listNode *ln;
3638 int startbgsave = 0;
3639
3640 listRewind(server.slaves);
3641 while((ln = listYield(server.slaves))) {
3642 redisClient *slave = ln->value;
3643
3644 if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_START) {
3645 startbgsave = 1;
3646 slave->replstate = REDIS_REPL_WAIT_BGSAVE_END;
3647 } else if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_END) {
3648 struct stat buf;
3649
3650 if (bgsaveerr != REDIS_OK) {
3651 freeClient(slave);
3652 redisLog(REDIS_WARNING,"SYNC failed. BGSAVE child returned an error");
3653 continue;
3654 }
3655 if ((slave->repldbfd = open(server.dbfilename,O_RDONLY)) == -1 ||
3656 fstat(slave->repldbfd,&buf) == -1) {
3657 freeClient(slave);
3658 redisLog(REDIS_WARNING,"SYNC failed. Can't open/stat DB after BGSAVE: %s", strerror(errno));
3659 continue;
3660 }
3661 slave->repldboff = 0;
3662 slave->repldbsize = buf.st_size;
3663 slave->replstate = REDIS_REPL_SEND_BULK;
3664 aeDeleteFileEvent(server.el,slave->fd,AE_WRITABLE);
3665 if (aeCreateFileEvent(server.el, slave->fd, AE_WRITABLE, sendBulkToSlave, slave, NULL) == AE_ERR) {
3666 freeClient(slave);
3667 continue;
3668 }
3669 }
3670 }
3671 if (startbgsave) {
3672 if (rdbSaveBackground(server.dbfilename) != REDIS_OK) {
3673 listRewind(server.slaves);
3674 redisLog(REDIS_WARNING,"SYNC failed. BGSAVE failed");
3675 while((ln = listYield(server.slaves))) {
3676 redisClient *slave = ln->value;
3677
3678 if (slave->replstate == REDIS_REPL_WAIT_BGSAVE_START)
3679 freeClient(slave);
3680 }
3681 }
3682 }
3683 }
3684
3685 static int syncWithMaster(void) {
3686 char buf[1024], tmpfile[256];
3687 int dumpsize;
3688 int fd = anetTcpConnect(NULL,server.masterhost,server.masterport);
3689 int dfd;
3690
3691 if (fd == -1) {
3692 redisLog(REDIS_WARNING,"Unable to connect to MASTER: %s",
3693 strerror(errno));
3694 return REDIS_ERR;
3695 }
3696 /* Issue the SYNC command */
3697 if (syncWrite(fd,"SYNC \r\n",7,5) == -1) {
3698 close(fd);
3699 redisLog(REDIS_WARNING,"I/O error writing to MASTER: %s",
3700 strerror(errno));
3701 return REDIS_ERR;
3702 }
3703 /* Read the bulk write count */
3704 if (syncReadLine(fd,buf,1024,5) == -1) {
3705 close(fd);
3706 redisLog(REDIS_WARNING,"I/O error reading bulk count from MASTER: %s",
3707 strerror(errno));
3708 return REDIS_ERR;
3709 }
3710 dumpsize = atoi(buf+1);
3711 redisLog(REDIS_NOTICE,"Receiving %d bytes data dump from MASTER",dumpsize);
3712 /* Read the bulk write data on a temp file */
3713 snprintf(tmpfile,256,"temp-%d.%ld.rdb",(int)time(NULL),(long int)random());
3714 dfd = open(tmpfile,O_CREAT|O_WRONLY,0644);
3715 if (dfd == -1) {
3716 close(fd);
3717 redisLog(REDIS_WARNING,"Opening the temp file needed for MASTER <-> SLAVE synchronization: %s",strerror(errno));
3718 return REDIS_ERR;
3719 }
3720 while(dumpsize) {
3721 int nread, nwritten;
3722
3723 nread = read(fd,buf,(dumpsize < 1024)?dumpsize:1024);
3724 if (nread == -1) {
3725 redisLog(REDIS_WARNING,"I/O error trying to sync with MASTER: %s",
3726 strerror(errno));
3727 close(fd);
3728 close(dfd);
3729 return REDIS_ERR;
3730 }
3731 nwritten = write(dfd,buf,nread);
3732 if (nwritten == -1) {
3733 redisLog(REDIS_WARNING,"Write error writing to the DB dump file needed for MASTER <-> SLAVE synchrnonization: %s", strerror(errno));
3734 close(fd);
3735 close(dfd);
3736 return REDIS_ERR;
3737 }
3738 dumpsize -= nread;
3739 }
3740 close(dfd);
3741 if (rename(tmpfile,server.dbfilename) == -1) {
3742 redisLog(REDIS_WARNING,"Failed trying to rename the temp DB into dump.rdb in MASTER <-> SLAVE synchronization: %s", strerror(errno));
3743 unlink(tmpfile);
3744 close(fd);
3745 return REDIS_ERR;
3746 }
3747 emptyDb();
3748 if (rdbLoad(server.dbfilename) != REDIS_OK) {
3749 redisLog(REDIS_WARNING,"Failed trying to load the MASTER synchronization DB from disk");
3750 close(fd);
3751 return REDIS_ERR;
3752 }
3753 server.master = createClient(fd);
3754 server.master->flags |= REDIS_MASTER;
3755 server.replstate = REDIS_REPL_CONNECTED;
3756 return REDIS_OK;
3757 }
3758
3759 /* =================================== Main! ================================ */
3760
3761 static void daemonize(void) {
3762 int fd;
3763 FILE *fp;
3764
3765 if (fork() != 0) exit(0); /* parent exits */
3766 setsid(); /* create a new session */
3767
3768 /* Every output goes to /dev/null. If Redis is daemonized but
3769 * the 'logfile' is set to 'stdout' in the configuration file
3770 * it will not log at all. */
3771 if ((fd = open("/dev/null", O_RDWR, 0)) != -1) {
3772 dup2(fd, STDIN_FILENO);
3773 dup2(fd, STDOUT_FILENO);
3774 dup2(fd, STDERR_FILENO);
3775 if (fd > STDERR_FILENO) close(fd);
3776 }
3777 /* Try to write the pid file */
3778 fp = fopen(server.pidfile,"w");
3779 if (fp) {
3780 fprintf(fp,"%d\n",getpid());
3781 fclose(fp);
3782 }
3783 }
3784
3785 int main(int argc, char **argv) {
3786 initServerConfig();
3787 if (argc == 2) {
3788 ResetServerSaveParams();
3789 loadServerConfig(argv[1]);
3790 } else if (argc > 2) {
3791 fprintf(stderr,"Usage: ./redis-server [/path/to/redis.conf]\n");
3792 exit(1);
3793 }
3794 initServer();
3795 if (server.daemonize) daemonize();
3796 redisLog(REDIS_NOTICE,"Server started, Redis version " REDIS_VERSION);
3797 if (rdbLoad(server.dbfilename) == REDIS_OK)
3798 redisLog(REDIS_NOTICE,"DB loaded from disk");
3799 if (aeCreateFileEvent(server.el, server.fd, AE_READABLE,
3800 acceptHandler, NULL, NULL) == AE_ERR) oom("creating file event");
3801 redisLog(REDIS_NOTICE,"The server is now ready to accept connections on port %d", server.port);
3802 aeMain(server.el);
3803 aeDeleteEventLoop(server.el);
3804 return 0;
3805 }
Redis += OpenLDAP MDB