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