[redis.git] / src / config.c

#include "redis.h"

/*-----------------------------------------------------------------------------
 * Config file parsing
 *----------------------------------------------------------------------------*/

int yesnotoi(char *s) {
    if (!strcasecmp(s,"yes")) return 1;
    else if (!strcasecmp(s,"no")) return 0;
    else return -1;
}

void appendServerSaveParams(time_t seconds, int changes) {
    server.saveparams = zrealloc(server.saveparams,sizeof(struct saveparam)*(server.saveparamslen+1));
    server.saveparams[server.saveparamslen].seconds = seconds;
    server.saveparams[server.saveparamslen].changes = changes;
    server.saveparamslen++;
}

void resetServerSaveParams() {
    zfree(server.saveparams);
    server.saveparams = NULL;
    server.saveparamslen = 0;
}

/* I agree, this is a very rudimental way to load a configuration...
   will improve later if the config gets more complex */
void loadServerConfig(char *filename) {
    FILE *fp;
    char buf[REDIS_CONFIGLINE_MAX+1], *err = NULL;
    int linenum = 0;
    sds line = NULL;

    if (filename[0] == '-' && filename[1] == '\0')
        fp = stdin;
    else {
        if ((fp = fopen(filename,"r")) == NULL) {
            redisLog(REDIS_WARNING, "Fatal error, can't open config file '%s'", filename);
            exit(1);
        }
    }

    while(fgets(buf,REDIS_CONFIGLINE_MAX+1,fp) != NULL) {
        sds *argv;
        int argc, j;

        linenum++;
        line = sdsnew(buf);
        line = sdstrim(line," \t\r\n");

        /* Skip comments and blank lines*/
        if (line[0] == '#' || line[0] == '\0') {
            sdsfree(line);
            continue;
        }

        /* Split into arguments */
        argv = sdssplitargs(line,&argc);
        sdstolower(argv[0]);

        /* Execute config directives */
        if (!strcasecmp(argv[0],"timeout") && argc == 2) {
            server.maxidletime = atoi(argv[1]);
            if (server.maxidletime < 0) {
                err = "Invalid timeout value"; goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"port") && argc == 2) {
            server.port = atoi(argv[1]);
            if (server.port < 1 || server.port > 65535) {
                err = "Invalid port"; goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"bind") && argc == 2) {
            server.bindaddr = zstrdup(argv[1]);
        } else if (!strcasecmp(argv[0],"unixsocket") && argc == 2) {
            server.unixsocket = zstrdup(argv[1]);
        } else if (!strcasecmp(argv[0],"save") && argc == 3) {
            int seconds = atoi(argv[1]);
            int changes = atoi(argv[2]);
            if (seconds < 1 || changes < 0) {
                err = "Invalid save parameters"; goto loaderr;
            }
            appendServerSaveParams(seconds,changes);
        } else if (!strcasecmp(argv[0],"dir") && argc == 2) {
            if (chdir(argv[1]) == -1) {
                redisLog(REDIS_WARNING,"Can't chdir to '%s': %s",
                    argv[1], strerror(errno));
                exit(1);
            }
        } else if (!strcasecmp(argv[0],"loglevel") && argc == 2) {
            if (!strcasecmp(argv[1],"debug")) server.verbosity = REDIS_DEBUG;
            else if (!strcasecmp(argv[1],"verbose")) server.verbosity = REDIS_VERBOSE;
            else if (!strcasecmp(argv[1],"notice")) server.verbosity = REDIS_NOTICE;
            else if (!strcasecmp(argv[1],"warning")) server.verbosity = REDIS_WARNING;
            else {
                err = "Invalid log level. Must be one of debug, notice, warning";
                goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"logfile") && argc == 2) {
            FILE *logfp;

            server.logfile = zstrdup(argv[1]);
            if (!strcasecmp(server.logfile,"stdout")) {
                zfree(server.logfile);
                server.logfile = NULL;
            }
            if (server.logfile) {
                /* Test if we are able to open the file. The server will not
                 * be able to abort just for this problem later... */
                logfp = fopen(server.logfile,"a");
                if (logfp == NULL) {
                    err = sdscatprintf(sdsempty(),
                        "Can't open the log file: %s", strerror(errno));
                    goto loaderr;
                }
                fclose(logfp);
            }
        } else if (!strcasecmp(argv[0],"syslog-enabled") && argc == 2) {
            if ((server.syslog_enabled = yesnotoi(argv[1])) == -1) {
                err = "argument must be 'yes' or 'no'"; goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"syslog-ident") && argc == 2) {
            if (server.syslog_ident) zfree(server.syslog_ident);
            server.syslog_ident = zstrdup(argv[1]);
        } else if (!strcasecmp(argv[0],"syslog-facility") && argc == 2) {
            struct {
                const char     *name;
                const int       value;
            } validSyslogFacilities[] = {
                {"user",    LOG_USER},
                {"local0",  LOG_LOCAL0},
                {"local1",  LOG_LOCAL1},
                {"local2",  LOG_LOCAL2},
                {"local3",  LOG_LOCAL3},
                {"local4",  LOG_LOCAL4},
                {"local5",  LOG_LOCAL5},
                {"local6",  LOG_LOCAL6},
                {"local7",  LOG_LOCAL7},
                {NULL, 0}
            };
            int i;

            for (i = 0; validSyslogFacilities[i].name; i++) {
                if (!strcasecmp(validSyslogFacilities[i].name, argv[1])) {
                    server.syslog_facility = validSyslogFacilities[i].value;
                    break;
                }
            }

            if (!validSyslogFacilities[i].name) {
                err = "Invalid log facility. Must be one of USER or between LOCAL0-LOCAL7";
                goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"databases") && argc == 2) {
            server.dbnum = atoi(argv[1]);
            if (server.dbnum < 1) {
                err = "Invalid number of databases"; goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"include") && argc == 2) {
            loadServerConfig(argv[1]);
        } else if (!strcasecmp(argv[0],"maxclients") && argc == 2) {
            server.maxclients = atoi(argv[1]);
        } else if (!strcasecmp(argv[0],"maxmemory") && argc == 2) {
            server.maxmemory = memtoll(argv[1],NULL);
        } else if (!strcasecmp(argv[0],"maxmemory-policy") && argc == 2) {
            if (!strcasecmp(argv[1],"volatile-lru")) {
                server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_LRU;
            } else if (!strcasecmp(argv[1],"volatile-random")) {
                server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_RANDOM;
            } else if (!strcasecmp(argv[1],"volatile-ttl")) {
                server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_TTL;
            } else if (!strcasecmp(argv[1],"allkeys-lru")) {
                server.maxmemory_policy = REDIS_MAXMEMORY_ALLKEYS_LRU;
            } else if (!strcasecmp(argv[1],"allkeys-random")) {
                server.maxmemory_policy = REDIS_MAXMEMORY_ALLKEYS_RANDOM;
            } else if (!strcasecmp(argv[1],"noeviction")) {
                server.maxmemory_policy = REDIS_MAXMEMORY_NO_EVICTION;
            } else {
                err = "Invalid maxmemory policy";
                goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"maxmemory-samples") && argc == 2) {
            server.maxmemory_samples = atoi(argv[1]);
            if (server.maxmemory_samples <= 0) {
                err = "maxmemory-samples must be 1 or greater";
                goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"slaveof") && argc == 3) {
            server.masterhost = sdsnew(argv[1]);
            server.masterport = atoi(argv[2]);
            server.replstate = REDIS_REPL_CONNECT;
        } else if (!strcasecmp(argv[0],"masterauth") && argc == 2) {
        	server.masterauth = zstrdup(argv[1]);
        } else if (!strcasecmp(argv[0],"slave-serve-stale-data") && argc == 2) {
            if ((server.repl_serve_stale_data = yesnotoi(argv[1])) == -1) {
                err = "argument must be 'yes' or 'no'"; goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"glueoutputbuf") && argc == 2) {
            if ((server.glueoutputbuf = yesnotoi(argv[1])) == -1) {
                err = "argument must be 'yes' or 'no'"; goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"rdbcompression") && argc == 2) {
            if ((server.rdbcompression = yesnotoi(argv[1])) == -1) {
                err = "argument must be 'yes' or 'no'"; goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"activerehashing") && argc == 2) {
            if ((server.activerehashing = yesnotoi(argv[1])) == -1) {
                err = "argument must be 'yes' or 'no'"; goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"daemonize") && argc == 2) {
            if ((server.daemonize = yesnotoi(argv[1])) == -1) {
                err = "argument must be 'yes' or 'no'"; goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"appendonly") && argc == 2) {
            if ((server.appendonly = yesnotoi(argv[1])) == -1) {
                err = "argument must be 'yes' or 'no'"; goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"appendfilename") && argc == 2) {
            zfree(server.appendfilename);
            server.appendfilename = zstrdup(argv[1]);
        } else if (!strcasecmp(argv[0],"no-appendfsync-on-rewrite")
                   && argc == 2) {
            if ((server.no_appendfsync_on_rewrite= yesnotoi(argv[1])) == -1) {
                err = "argument must be 'yes' or 'no'"; goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"appendfsync") && argc == 2) {
            if (!strcasecmp(argv[1],"no")) {
                server.appendfsync = APPENDFSYNC_NO;
            } else if (!strcasecmp(argv[1],"always")) {
                server.appendfsync = APPENDFSYNC_ALWAYS;
            } else if (!strcasecmp(argv[1],"everysec")) {
                server.appendfsync = APPENDFSYNC_EVERYSEC;
            } else {
                err = "argument must be 'no', 'always' or 'everysec'";
                goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"requirepass") && argc == 2) {
            server.requirepass = zstrdup(argv[1]);
        } else if (!strcasecmp(argv[0],"pidfile") && argc == 2) {
            zfree(server.pidfile);
            server.pidfile = zstrdup(argv[1]);
        } else if (!strcasecmp(argv[0],"dbfilename") && argc == 2) {
            zfree(server.dbfilename);
            server.dbfilename = zstrdup(argv[1]);
        } else if (!strcasecmp(argv[0],"diskstore-enabled") && argc == 2) {
            if ((server.ds_enabled = yesnotoi(argv[1])) == -1) {
                err = "argument must be 'yes' or 'no'"; goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"diskstore-path") && argc == 2) {
            zfree(server.ds_path);
            server.ds_path = zstrdup(argv[1]);
        } else if (!strcasecmp(argv[0],"cache-max-memory") && argc == 2) {
            server.cache_max_memory = memtoll(argv[1],NULL);
        } else if (!strcasecmp(argv[0],"hash-max-zipmap-entries") && argc == 2) {
            server.hash_max_zipmap_entries = memtoll(argv[1], NULL);
        } else if (!strcasecmp(argv[0],"hash-max-zipmap-value") && argc == 2) {
            server.hash_max_zipmap_value = memtoll(argv[1], NULL);
        } else if (!strcasecmp(argv[0],"list-max-ziplist-entries") && argc == 2){
            server.list_max_ziplist_entries = memtoll(argv[1], NULL);
        } else if (!strcasecmp(argv[0],"list-max-ziplist-value") && argc == 2) {
            server.list_max_ziplist_value = memtoll(argv[1], NULL);
        } else if (!strcasecmp(argv[0],"set-max-intset-entries") && argc == 2) {
            server.set_max_intset_entries = memtoll(argv[1], NULL);
        } else if (!strcasecmp(argv[0],"rename-command") && argc == 3) {
            struct redisCommand *cmd = lookupCommand(argv[1]);
            int retval;

            if (!cmd) {
                err = "No such command in rename-command";
                goto loaderr;
            }

            /* If the target command name is the emtpy string we just
             * remove it from the command table. */
            retval = dictDelete(server.commands, argv[1]);
            redisAssert(retval == DICT_OK);

            /* Otherwise we re-add the command under a different name. */
            if (sdslen(argv[2]) != 0) {
                sds copy = sdsdup(argv[2]);

                retval = dictAdd(server.commands, copy, cmd);
                if (retval != DICT_OK) {
                    sdsfree(copy);
                    err = "Target command name already exists"; goto loaderr;
                }
            }
        } else {
            err = "Bad directive or wrong number of arguments"; goto loaderr;
        }
        for (j = 0; j < argc; j++)
            sdsfree(argv[j]);
        zfree(argv);
        sdsfree(line);
    }
    if (fp != stdin) fclose(fp);
    return;

loaderr:
    fprintf(stderr, "\n*** FATAL CONFIG FILE ERROR ***\n");
    fprintf(stderr, "Reading the configuration file, at line %d\n", linenum);
    fprintf(stderr, ">>> '%s'\n", line);
    fprintf(stderr, "%s\n", err);
    exit(1);
}

/*-----------------------------------------------------------------------------
 * CONFIG command for remote configuration
 *----------------------------------------------------------------------------*/

void configSetCommand(redisClient *c) {
    robj *o;
    long long ll;
    redisAssert(c->argv[2]->encoding == REDIS_ENCODING_RAW);
    redisAssert(c->argv[3]->encoding == REDIS_ENCODING_RAW);
    o = c->argv[3];

    if (!strcasecmp(c->argv[2]->ptr,"dbfilename")) {
        zfree(server.dbfilename);
        server.dbfilename = zstrdup(o->ptr);
    } else if (!strcasecmp(c->argv[2]->ptr,"requirepass")) {
        zfree(server.requirepass);
        server.requirepass = zstrdup(o->ptr);
    } else if (!strcasecmp(c->argv[2]->ptr,"masterauth")) {
        zfree(server.masterauth);
        server.masterauth = zstrdup(o->ptr);
    } else if (!strcasecmp(c->argv[2]->ptr,"maxmemory")) {
        if (getLongLongFromObject(o,&ll) == REDIS_ERR ||
            ll < 0) goto badfmt;
        server.maxmemory = ll;
        if (server.maxmemory) freeMemoryIfNeeded();
    } else if (!strcasecmp(c->argv[2]->ptr,"maxmemory-policy")) {
        if (!strcasecmp(o->ptr,"volatile-lru")) {
            server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_LRU;
        } else if (!strcasecmp(o->ptr,"volatile-random")) {
            server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_RANDOM;
        } else if (!strcasecmp(o->ptr,"volatile-ttl")) {
            server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_TTL;
        } else if (!strcasecmp(o->ptr,"allkeys-lru")) {
            server.maxmemory_policy = REDIS_MAXMEMORY_ALLKEYS_LRU;
        } else if (!strcasecmp(o->ptr,"allkeys-random")) {
            server.maxmemory_policy = REDIS_MAXMEMORY_ALLKEYS_RANDOM;
        } else if (!strcasecmp(o->ptr,"noeviction")) {
            server.maxmemory_policy = REDIS_MAXMEMORY_NO_EVICTION;
        } else {
            goto badfmt;
        }
    } else if (!strcasecmp(c->argv[2]->ptr,"maxmemory-samples")) {
        if (getLongLongFromObject(o,&ll) == REDIS_ERR ||
            ll <= 0) goto badfmt;
        server.maxmemory_samples = ll;
    } else if (!strcasecmp(c->argv[2]->ptr,"timeout")) {
        if (getLongLongFromObject(o,&ll) == REDIS_ERR ||
            ll < 0 || ll > LONG_MAX) goto badfmt;
        server.maxidletime = ll;
    } else if (!strcasecmp(c->argv[2]->ptr,"appendfsync")) {
        if (!strcasecmp(o->ptr,"no")) {
            server.appendfsync = APPENDFSYNC_NO;
        } else if (!strcasecmp(o->ptr,"everysec")) {
            server.appendfsync = APPENDFSYNC_EVERYSEC;
        } else if (!strcasecmp(o->ptr,"always")) {
            server.appendfsync = APPENDFSYNC_ALWAYS;
        } else {
            goto badfmt;
        }
    } else if (!strcasecmp(c->argv[2]->ptr,"no-appendfsync-on-rewrite")) {
        int yn = yesnotoi(o->ptr);

        if (yn == -1) goto badfmt;
        server.no_appendfsync_on_rewrite = yn;
    } else if (!strcasecmp(c->argv[2]->ptr,"appendonly")) {
        int old = server.appendonly;
        int new = yesnotoi(o->ptr);

        if (new == -1) goto badfmt;
        if (old != new) {
            if (new == 0) {
                stopAppendOnly();
            } else {
                if (startAppendOnly() == REDIS_ERR) {
                    addReplyError(c,
                        "Unable to turn on AOF. Check server logs.");
                    return;
                }
            }
        }
    } else if (!strcasecmp(c->argv[2]->ptr,"save")) {
        int vlen, j;
        sds *v = sdssplitlen(o->ptr,sdslen(o->ptr)," ",1,&vlen);

        /* Perform sanity check before setting the new config:
         * - Even number of args
         * - Seconds >= 1, changes >= 0 */
        if (vlen & 1) {
            sdsfreesplitres(v,vlen);
            goto badfmt;
        }
        for (j = 0; j < vlen; j++) {
            char *eptr;
            long val;

            val = strtoll(v[j], &eptr, 10);
            if (eptr[0] != '\0' ||
                ((j & 1) == 0 && val < 1) ||
                ((j & 1) == 1 && val < 0)) {
                sdsfreesplitres(v,vlen);
                goto badfmt;
            }
        }
        /* Finally set the new config */
        resetServerSaveParams();
        for (j = 0; j < vlen; j += 2) {
            time_t seconds;
            int changes;

            seconds = strtoll(v[j],NULL,10);
            changes = strtoll(v[j+1],NULL,10);
            appendServerSaveParams(seconds, changes);
        }
        sdsfreesplitres(v,vlen);
    } else if (!strcasecmp(c->argv[2]->ptr,"slave-serve-stale-data")) {
        int yn = yesnotoi(o->ptr);

        if (yn == -1) goto badfmt;
        server.repl_serve_stale_data = yn;
    } else {
        addReplyErrorFormat(c,"Unsupported CONFIG parameter: %s",
            (char*)c->argv[2]->ptr);
        return;
    }
    addReply(c,shared.ok);
    return;

badfmt: /* Bad format errors */
    addReplyErrorFormat(c,"Invalid argument '%s' for CONFIG SET '%s'",
            (char*)o->ptr,
            (char*)c->argv[2]->ptr);
}

void configGetCommand(redisClient *c) {
    robj *o = c->argv[2];
    void *replylen = addDeferredMultiBulkLength(c);
    char *pattern = o->ptr;
    char buf[128];
    int matches = 0;
    redisAssert(o->encoding == REDIS_ENCODING_RAW);

    if (stringmatch(pattern,"dbfilename",0)) {
        addReplyBulkCString(c,"dbfilename");
        addReplyBulkCString(c,server.dbfilename);
        matches++;
    }
    if (stringmatch(pattern,"requirepass",0)) {
        addReplyBulkCString(c,"requirepass");
        addReplyBulkCString(c,server.requirepass);
        matches++;
    }
    if (stringmatch(pattern,"masterauth",0)) {
        addReplyBulkCString(c,"masterauth");
        addReplyBulkCString(c,server.masterauth);
        matches++;
    }
    if (stringmatch(pattern,"maxmemory",0)) {
        ll2string(buf,sizeof(buf),server.maxmemory);
        addReplyBulkCString(c,"maxmemory");
        addReplyBulkCString(c,buf);
        matches++;
    }
    if (stringmatch(pattern,"maxmemory-policy",0)) {
        char *s;

        switch(server.maxmemory_policy) {
        case REDIS_MAXMEMORY_VOLATILE_LRU: s = "volatile-lru"; break;
        case REDIS_MAXMEMORY_VOLATILE_TTL: s = "volatile-ttl"; break;
        case REDIS_MAXMEMORY_VOLATILE_RANDOM: s = "volatile-random"; break;
        case REDIS_MAXMEMORY_ALLKEYS_LRU: s = "allkeys-lru"; break;
        case REDIS_MAXMEMORY_ALLKEYS_RANDOM: s = "allkeys-random"; break;
        case REDIS_MAXMEMORY_NO_EVICTION: s = "noeviction"; break;
        default: s = "unknown"; break; /* too harmless to panic */
        }
        addReplyBulkCString(c,"maxmemory-policy");
        addReplyBulkCString(c,s);
        matches++;
    }
    if (stringmatch(pattern,"maxmemory-samples",0)) {
        ll2string(buf,sizeof(buf),server.maxmemory_samples);
        addReplyBulkCString(c,"maxmemory-samples");
        addReplyBulkCString(c,buf);
        matches++;
    }
    if (stringmatch(pattern,"timeout",0)) {
        ll2string(buf,sizeof(buf),server.maxidletime);
        addReplyBulkCString(c,"timeout");
        addReplyBulkCString(c,buf);
        matches++;
    }
    if (stringmatch(pattern,"appendonly",0)) {
        addReplyBulkCString(c,"appendonly");
        addReplyBulkCString(c,server.appendonly ? "yes" : "no");
        matches++;
    }
    if (stringmatch(pattern,"no-appendfsync-on-rewrite",0)) {
        addReplyBulkCString(c,"no-appendfsync-on-rewrite");
        addReplyBulkCString(c,server.no_appendfsync_on_rewrite ? "yes" : "no");
        matches++;
    }
    if (stringmatch(pattern,"appendfsync",0)) {
        char *policy;

        switch(server.appendfsync) {
        case APPENDFSYNC_NO: policy = "no"; break;
        case APPENDFSYNC_EVERYSEC: policy = "everysec"; break;
        case APPENDFSYNC_ALWAYS: policy = "always"; break;
        default: policy = "unknown"; break; /* too harmless to panic */
        }
        addReplyBulkCString(c,"appendfsync");
        addReplyBulkCString(c,policy);
        matches++;
    }
    if (stringmatch(pattern,"save",0)) {
        sds buf = sdsempty();
        int j;

        for (j = 0; j < server.saveparamslen; j++) {
            buf = sdscatprintf(buf,"%ld %d",
                    server.saveparams[j].seconds,
                    server.saveparams[j].changes);
            if (j != server.saveparamslen-1)
                buf = sdscatlen(buf," ",1);
        }
        addReplyBulkCString(c,"save");
        addReplyBulkCString(c,buf);
        sdsfree(buf);
        matches++;
    }
    if (stringmatch(pattern,"slave-serve-stale-data",0)) {
        addReplyBulkCString(c,"slave-serve-stale-data");
        addReplyBulkCString(c,server.repl_serve_stale_data ? "yes" : "no");
        matches++;
    }
    setDeferredMultiBulkLength(c,replylen,matches*2);
}

void configCommand(redisClient *c) {
    if (!strcasecmp(c->argv[1]->ptr,"set")) {
        if (c->argc != 4) goto badarity;
        configSetCommand(c);
    } else if (!strcasecmp(c->argv[1]->ptr,"get")) {
        if (c->argc != 3) goto badarity;
        configGetCommand(c);
    } else if (!strcasecmp(c->argv[1]->ptr,"resetstat")) {
        if (c->argc != 2) goto badarity;
        server.stat_keyspace_hits = 0;
        server.stat_keyspace_misses = 0;
        server.stat_numcommands = 0;
        server.stat_numconnections = 0;
        server.stat_expiredkeys = 0;
        addReply(c,shared.ok);
    } else {
        addReplyError(c,
            "CONFIG subcommand must be one of GET, SET, RESETSTAT");
    }
    return;

badarity:
    addReplyErrorFormat(c,"Wrong number of arguments for CONFIG %s",
        (char*) c->argv[1]->ptr);
}
Commit	Line	Data
e2641e09	1	#include "redis.h"
	2
	3	/*-----------------------------------------------------------------------------
	4	* Config file parsing
	5	----------------------------------------------------------------------------/
	6
	7	int yesnotoi(char *s) {
	8	if (!strcasecmp(s,"yes")) return 1;
	9	else if (!strcasecmp(s,"no")) return 0;
	10	else return -1;
	11	}
	12
	13	void appendServerSaveParams(time_t seconds, int changes) {
	14	server.saveparams = zrealloc(server.saveparams,sizeof(struct saveparam)*(server.saveparamslen+1));
	15	server.saveparams[server.saveparamslen].seconds = seconds;
	16	server.saveparams[server.saveparamslen].changes = changes;
	17	server.saveparamslen++;
	18	}
	19
	20	void resetServerSaveParams() {
	21	zfree(server.saveparams);
	22	server.saveparams = NULL;
	23	server.saveparamslen = 0;
	24	}
	25
	26	/* I agree, this is a very rudimental way to load a configuration...
	27	will improve later if the config gets more complex */
	28	void loadServerConfig(char *filename) {
	29	FILE *fp;
	30	char buf[REDIS_CONFIGLINE_MAX+1], *err = NULL;
	31	int linenum = 0;
	32	sds line = NULL;
	33
	34	if (filename[0] == '-' && filename[1] == '\0')
	35	fp = stdin;
	36	else {
	37	if ((fp = fopen(filename,"r")) == NULL) {
	38	redisLog(REDIS_WARNING, "Fatal error, can't open config file '%s'", filename);
	39	exit(1);
	40	}
	41	}
	42
	43	while(fgets(buf,REDIS_CONFIGLINE_MAX+1,fp) != NULL) {
	44	sds *argv;
	45	int argc, j;
	46
	47	linenum++;
	48	line = sdsnew(buf);
	49	line = sdstrim(line," \t\r\n");
	50
	51	/* Skip comments and blank lines*/
	52	if (line[0] == '#' \|\| line[0] == '\0') {
	53	sdsfree(line);
	54	continue;
	55	}
	56
	57	/* Split into arguments */
297e77c6	58	argv = sdssplitargs(line,&argc);
e2641e09	59	sdstolower(argv[0]);
	60
	61	/* Execute config directives */
	62	if (!strcasecmp(argv[0],"timeout") && argc == 2) {
	63	server.maxidletime = atoi(argv[1]);
	64	if (server.maxidletime < 0) {
	65	err = "Invalid timeout value"; goto loaderr;
	66	}
	67	} else if (!strcasecmp(argv[0],"port") && argc == 2) {
	68	server.port = atoi(argv[1]);
	69	if (server.port < 1 \|\| server.port > 65535) {
	70	err = "Invalid port"; goto loaderr;
	71	}
	72	} else if (!strcasecmp(argv[0],"bind") && argc == 2) {
	73	server.bindaddr = zstrdup(argv[1]);
5d10923f PN	74	} else if (!strcasecmp(argv[0],"unixsocket") && argc == 2) {
5d10923f PN	75	server.unixsocket = zstrdup(argv[1]);
e2641e09	76	} else if (!strcasecmp(argv[0],"save") && argc == 3) {
	77	int seconds = atoi(argv[1]);
	78	int changes = atoi(argv[2]);
	79	if (seconds < 1 \|\| changes < 0) {
	80	err = "Invalid save parameters"; goto loaderr;
	81	}
	82	appendServerSaveParams(seconds,changes);
	83	} else if (!strcasecmp(argv[0],"dir") && argc == 2) {
	84	if (chdir(argv[1]) == -1) {
	85	redisLog(REDIS_WARNING,"Can't chdir to '%s': %s",
	86	argv[1], strerror(errno));
	87	exit(1);
	88	}
	89	} else if (!strcasecmp(argv[0],"loglevel") && argc == 2) {
	90	if (!strcasecmp(argv[1],"debug")) server.verbosity = REDIS_DEBUG;
	91	else if (!strcasecmp(argv[1],"verbose")) server.verbosity = REDIS_VERBOSE;
	92	else if (!strcasecmp(argv[1],"notice")) server.verbosity = REDIS_NOTICE;
	93	else if (!strcasecmp(argv[1],"warning")) server.verbosity = REDIS_WARNING;
	94	else {
	95	err = "Invalid log level. Must be one of debug, notice, warning";
	96	goto loaderr;
	97	}
	98	} else if (!strcasecmp(argv[0],"logfile") && argc == 2) {
	99	FILE *logfp;
	100
	101	server.logfile = zstrdup(argv[1]);
	102	if (!strcasecmp(server.logfile,"stdout")) {
	103	zfree(server.logfile);
	104	server.logfile = NULL;
	105	}
	106	if (server.logfile) {
	107	/* Test if we are able to open the file. The server will not
	108	* be able to abort just for this problem later... */
	109	logfp = fopen(server.logfile,"a");
	110	if (logfp == NULL) {
	111	err = sdscatprintf(sdsempty(),
	112	"Can't open the log file: %s", strerror(errno));
	113	goto loaderr;
	114	}
	115	fclose(logfp);
	116	}
e1a586ee JH	117	} else if (!strcasecmp(argv[0],"syslog-enabled") && argc == 2) {
	118	if ((server.syslog_enabled = yesnotoi(argv[1])) == -1) {
	119	err = "argument must be 'yes' or 'no'"; goto loaderr;
	120	}
	121	} else if (!strcasecmp(argv[0],"syslog-ident") && argc == 2) {
	122	if (server.syslog_ident) zfree(server.syslog_ident);
	123	server.syslog_ident = zstrdup(argv[1]);
	124	} else if (!strcasecmp(argv[0],"syslog-facility") && argc == 2) {
	125	struct {
	126	const char *name;
	127	const int value;
	128	} validSyslogFacilities[] = {
	129	{"user", LOG_USER},
	130	{"local0", LOG_LOCAL0},
	131	{"local1", LOG_LOCAL1},
	132	{"local2", LOG_LOCAL2},
	133	{"local3", LOG_LOCAL3},
	134	{"local4", LOG_LOCAL4},
	135	{"local5", LOG_LOCAL5},
	136	{"local6", LOG_LOCAL6},
	137	{"local7", LOG_LOCAL7},
	138	{NULL, 0}
	139	};
	140	int i;
	141
	142	for (i = 0; validSyslogFacilities[i].name; i++) {
	143	if (!strcasecmp(validSyslogFacilities[i].name, argv[1])) {
	144	server.syslog_facility = validSyslogFacilities[i].value;
	145	break;
	146	}
	147	}
	148
	149	if (!validSyslogFacilities[i].name) {
	150	err = "Invalid log facility. Must be one of USER or between LOCAL0-LOCAL7";
	151	goto loaderr;
	152	}
e2641e09	153	} else if (!strcasecmp(argv[0],"databases") && argc == 2) {
	154	server.dbnum = atoi(argv[1]);
	155	if (server.dbnum < 1) {
	156	err = "Invalid number of databases"; goto loaderr;
	157	}
	158	} else if (!strcasecmp(argv[0],"include") && argc == 2) {
	159	loadServerConfig(argv[1]);
	160	} else if (!strcasecmp(argv[0],"maxclients") && argc == 2) {
	161	server.maxclients = atoi(argv[1]);
	162	} else if (!strcasecmp(argv[0],"maxmemory") && argc == 2) {
	163	server.maxmemory = memtoll(argv[1],NULL);
165346ca	164	} else if (!strcasecmp(argv[0],"maxmemory-policy") && argc == 2) {
	165	if (!strcasecmp(argv[1],"volatile-lru")) {
	166	server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_LRU;
	167	} else if (!strcasecmp(argv[1],"volatile-random")) {
	168	server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_RANDOM;
	169	} else if (!strcasecmp(argv[1],"volatile-ttl")) {
	170	server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_TTL;
	171	} else if (!strcasecmp(argv[1],"allkeys-lru")) {
	172	server.maxmemory_policy = REDIS_MAXMEMORY_ALLKEYS_LRU;
	173	} else if (!strcasecmp(argv[1],"allkeys-random")) {
	174	server.maxmemory_policy = REDIS_MAXMEMORY_ALLKEYS_RANDOM;
5402c426	175	} else if (!strcasecmp(argv[1],"noeviction")) {
5402c426	176	server.maxmemory_policy = REDIS_MAXMEMORY_NO_EVICTION;
165346ca	177	} else {
	178	err = "Invalid maxmemory policy";
	179	goto loaderr;
	180	}
a3687929	181	} else if (!strcasecmp(argv[0],"maxmemory-samples") && argc == 2) {
	182	server.maxmemory_samples = atoi(argv[1]);
	183	if (server.maxmemory_samples <= 0) {
	184	err = "maxmemory-samples must be 1 or greater";
	185	goto loaderr;
	186	}
e2641e09	187	} else if (!strcasecmp(argv[0],"slaveof") && argc == 3) {
	188	server.masterhost = sdsnew(argv[1]);
	189	server.masterport = atoi(argv[2]);
	190	server.replstate = REDIS_REPL_CONNECT;
	191	} else if (!strcasecmp(argv[0],"masterauth") && argc == 2) {
	192	server.masterauth = zstrdup(argv[1]);
4ebfc455	193	} else if (!strcasecmp(argv[0],"slave-serve-stale-data") && argc == 2) {
	194	if ((server.repl_serve_stale_data = yesnotoi(argv[1])) == -1) {
	195	err = "argument must be 'yes' or 'no'"; goto loaderr;
	196	}
e2641e09	197	} else if (!strcasecmp(argv[0],"glueoutputbuf") && argc == 2) {
	198	if ((server.glueoutputbuf = yesnotoi(argv[1])) == -1) {
	199	err = "argument must be 'yes' or 'no'"; goto loaderr;
	200	}
	201	} else if (!strcasecmp(argv[0],"rdbcompression") && argc == 2) {
	202	if ((server.rdbcompression = yesnotoi(argv[1])) == -1) {
	203	err = "argument must be 'yes' or 'no'"; goto loaderr;
	204	}
	205	} else if (!strcasecmp(argv[0],"activerehashing") && argc == 2) {
	206	if ((server.activerehashing = yesnotoi(argv[1])) == -1) {
	207	err = "argument must be 'yes' or 'no'"; goto loaderr;
	208	}
	209	} else if (!strcasecmp(argv[0],"daemonize") && argc == 2) {
	210	if ((server.daemonize = yesnotoi(argv[1])) == -1) {
	211	err = "argument must be 'yes' or 'no'"; goto loaderr;
	212	}
	213	} else if (!strcasecmp(argv[0],"appendonly") && argc == 2) {
	214	if ((server.appendonly = yesnotoi(argv[1])) == -1) {
	215	err = "argument must be 'yes' or 'no'"; goto loaderr;
	216	}
	217	} else if (!strcasecmp(argv[0],"appendfilename") && argc == 2) {
	218	zfree(server.appendfilename);
	219	server.appendfilename = zstrdup(argv[1]);
	220	} else if (!strcasecmp(argv[0],"no-appendfsync-on-rewrite")
	221	&& argc == 2) {
	222	if ((server.no_appendfsync_on_rewrite= yesnotoi(argv[1])) == -1) {
	223	err = "argument must be 'yes' or 'no'"; goto loaderr;
	224	}
	225	} else if (!strcasecmp(argv[0],"appendfsync") && argc == 2) {
	226	if (!strcasecmp(argv[1],"no")) {
	227	server.appendfsync = APPENDFSYNC_NO;
	228	} else if (!strcasecmp(argv[1],"always")) {
	229	server.appendfsync = APPENDFSYNC_ALWAYS;
	230	} else if (!strcasecmp(argv[1],"everysec")) {
	231	server.appendfsync = APPENDFSYNC_EVERYSEC;
	232	} else {
	233	err = "argument must be 'no', 'always' or 'everysec'";
	234	goto loaderr;
	235	}
	236	} else if (!strcasecmp(argv[0],"requirepass") && argc == 2) {
	237	server.requirepass = zstrdup(argv[1]);
	238	} else if (!strcasecmp(argv[0],"pidfile") && argc == 2) {
	239	zfree(server.pidfile);
	240	server.pidfile = zstrdup(argv[1]);
	241	} else if (!strcasecmp(argv[0],"dbfilename") && argc == 2) {
	242	zfree(server.dbfilename);
	243	server.dbfilename = zstrdup(argv[1]);
16d77878	244	} else if (!strcasecmp(argv[0],"diskstore-enabled") && argc == 2) {
16d77878	245	if ((server.ds_enabled = yesnotoi(argv[1])) == -1) {
e2641e09	246	err = "argument must be 'yes' or 'no'"; goto loaderr;
e2641e09	247	}
16d77878	248	} else if (!strcasecmp(argv[0],"diskstore-path") && argc == 2) {
	249	zfree(server.ds_path);
	250	server.ds_path = zstrdup(argv[1]);
	251	} else if (!strcasecmp(argv[0],"cache-max-memory") && argc == 2) {
	252	server.cache_max_memory = memtoll(argv[1],NULL);
8d3e063a	253	} else if (!strcasecmp(argv[0],"hash-max-zipmap-entries") && argc == 2) {
e2641e09	254	server.hash_max_zipmap_entries = memtoll(argv[1], NULL);
8d3e063a	255	} else if (!strcasecmp(argv[0],"hash-max-zipmap-value") && argc == 2) {
e2641e09	256	server.hash_max_zipmap_value = memtoll(argv[1], NULL);
	257	} else if (!strcasecmp(argv[0],"list-max-ziplist-entries") && argc == 2){
	258	server.list_max_ziplist_entries = memtoll(argv[1], NULL);
8d3e063a	259	} else if (!strcasecmp(argv[0],"list-max-ziplist-value") && argc == 2) {
e2641e09	260	server.list_max_ziplist_value = memtoll(argv[1], NULL);
8d3e063a	261	} else if (!strcasecmp(argv[0],"set-max-intset-entries") && argc == 2) {
96ffb2fe	262	server.set_max_intset_entries = memtoll(argv[1], NULL);
8d3e063a	263	} else if (!strcasecmp(argv[0],"rename-command") && argc == 3) {
	264	struct redisCommand *cmd = lookupCommand(argv[1]);
	265	int retval;
	266
	267	if (!cmd) {
	268	err = "No such command in rename-command";
	269	goto loaderr;
	270	}
	271
	272	/* If the target command name is the emtpy string we just
	273	* remove it from the command table. */
	274	retval = dictDelete(server.commands, argv[1]);
	275	redisAssert(retval == DICT_OK);
	276
	277	/* Otherwise we re-add the command under a different name. */
	278	if (sdslen(argv[2]) != 0) {
	279	sds copy = sdsdup(argv[2]);
	280
	281	retval = dictAdd(server.commands, copy, cmd);
	282	if (retval != DICT_OK) {
	283	sdsfree(copy);
	284	err = "Target command name already exists"; goto loaderr;
	285	}
	286	}
e2641e09	287	} else {
	288	err = "Bad directive or wrong number of arguments"; goto loaderr;
	289	}
	290	for (j = 0; j < argc; j++)
	291	sdsfree(argv[j]);
	292	zfree(argv);
	293	sdsfree(line);
	294	}
	295	if (fp != stdin) fclose(fp);
	296	return;
	297
	298	loaderr:
	299	fprintf(stderr, "\n* FATAL CONFIG FILE ERROR *\n");
	300	fprintf(stderr, "Reading the configuration file, at line %d\n", linenum);
	301	fprintf(stderr, ">>> '%s'\n", line);
	302	fprintf(stderr, "%s\n", err);
	303	exit(1);
	304	}
	305
	306	/*-----------------------------------------------------------------------------
	307	* CONFIG command for remote configuration
	308	----------------------------------------------------------------------------/
	309
	310	void configSetCommand(redisClient *c) {
a375b077	311	robj *o;
e2641e09	312	long long ll;
a375b077 PN	313	redisAssert(c->argv[2]->encoding == REDIS_ENCODING_RAW);
	314	redisAssert(c->argv[3]->encoding == REDIS_ENCODING_RAW);
	315	o = c->argv[3];
e2641e09	316
	317	if (!strcasecmp(c->argv[2]->ptr,"dbfilename")) {
	318	zfree(server.dbfilename);
	319	server.dbfilename = zstrdup(o->ptr);
	320	} else if (!strcasecmp(c->argv[2]->ptr,"requirepass")) {
	321	zfree(server.requirepass);
	322	server.requirepass = zstrdup(o->ptr);
	323	} else if (!strcasecmp(c->argv[2]->ptr,"masterauth")) {
	324	zfree(server.masterauth);
	325	server.masterauth = zstrdup(o->ptr);
	326	} else if (!strcasecmp(c->argv[2]->ptr,"maxmemory")) {
	327	if (getLongLongFromObject(o,&ll) == REDIS_ERR \|\|
	328	ll < 0) goto badfmt;
	329	server.maxmemory = ll;
b4f2e412	330	if (server.maxmemory) freeMemoryIfNeeded();
165346ca	331	} else if (!strcasecmp(c->argv[2]->ptr,"maxmemory-policy")) {
	332	if (!strcasecmp(o->ptr,"volatile-lru")) {
	333	server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_LRU;
	334	} else if (!strcasecmp(o->ptr,"volatile-random")) {
	335	server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_RANDOM;
	336	} else if (!strcasecmp(o->ptr,"volatile-ttl")) {
	337	server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_TTL;
	338	} else if (!strcasecmp(o->ptr,"allkeys-lru")) {
	339	server.maxmemory_policy = REDIS_MAXMEMORY_ALLKEYS_LRU;
	340	} else if (!strcasecmp(o->ptr,"allkeys-random")) {
	341	server.maxmemory_policy = REDIS_MAXMEMORY_ALLKEYS_RANDOM;
5402c426	342	} else if (!strcasecmp(o->ptr,"noeviction")) {
5402c426	343	server.maxmemory_policy = REDIS_MAXMEMORY_NO_EVICTION;
165346ca	344	} else {
	345	goto badfmt;
	346	}
a3687929	347	} else if (!strcasecmp(c->argv[2]->ptr,"maxmemory-samples")) {
	348	if (getLongLongFromObject(o,&ll) == REDIS_ERR \|\|
	349	ll <= 0) goto badfmt;
	350	server.maxmemory_samples = ll;
e2641e09	351	} else if (!strcasecmp(c->argv[2]->ptr,"timeout")) {
	352	if (getLongLongFromObject(o,&ll) == REDIS_ERR \|\|
	353	ll < 0 \|\| ll > LONG_MAX) goto badfmt;
	354	server.maxidletime = ll;
	355	} else if (!strcasecmp(c->argv[2]->ptr,"appendfsync")) {
	356	if (!strcasecmp(o->ptr,"no")) {
	357	server.appendfsync = APPENDFSYNC_NO;
	358	} else if (!strcasecmp(o->ptr,"everysec")) {
	359	server.appendfsync = APPENDFSYNC_EVERYSEC;
	360	} else if (!strcasecmp(o->ptr,"always")) {
	361	server.appendfsync = APPENDFSYNC_ALWAYS;
	362	} else {
	363	goto badfmt;
	364	}
	365	} else if (!strcasecmp(c->argv[2]->ptr,"no-appendfsync-on-rewrite")) {
	366	int yn = yesnotoi(o->ptr);
	367
	368	if (yn == -1) goto badfmt;
	369	server.no_appendfsync_on_rewrite = yn;
	370	} else if (!strcasecmp(c->argv[2]->ptr,"appendonly")) {
	371	int old = server.appendonly;
	372	int new = yesnotoi(o->ptr);
	373
	374	if (new == -1) goto badfmt;
	375	if (old != new) {
	376	if (new == 0) {
	377	stopAppendOnly();
	378	} else {
	379	if (startAppendOnly() == REDIS_ERR) {
3ab20376 PN	380	addReplyError(c,
3ab20376 PN	381	"Unable to turn on AOF. Check server logs.");
e2641e09	382	return;
	383	}
	384	}
	385	}
	386	} else if (!strcasecmp(c->argv[2]->ptr,"save")) {
	387	int vlen, j;
	388	sds *v = sdssplitlen(o->ptr,sdslen(o->ptr)," ",1,&vlen);
	389
	390	/* Perform sanity check before setting the new config:
	391	* - Even number of args
	392	* - Seconds >= 1, changes >= 0 */
	393	if (vlen & 1) {
	394	sdsfreesplitres(v,vlen);
	395	goto badfmt;
	396	}
	397	for (j = 0; j < vlen; j++) {
	398	char *eptr;
	399	long val;
	400
	401	val = strtoll(v[j], &eptr, 10);
	402	if (eptr[0] != '\0' \|\|
	403	((j & 1) == 0 && val < 1) \|\|
	404	((j & 1) == 1 && val < 0)) {
	405	sdsfreesplitres(v,vlen);
	406	goto badfmt;
	407	}
	408	}
	409	/* Finally set the new config */
	410	resetServerSaveParams();
	411	for (j = 0; j < vlen; j += 2) {
	412	time_t seconds;
	413	int changes;
	414
	415	seconds = strtoll(v[j],NULL,10);
	416	changes = strtoll(v[j+1],NULL,10);
	417	appendServerSaveParams(seconds, changes);
	418	}
	419	sdsfreesplitres(v,vlen);
4ebfc455	420	} else if (!strcasecmp(c->argv[2]->ptr,"slave-serve-stale-data")) {
	421	int yn = yesnotoi(o->ptr);
	422
	423	if (yn == -1) goto badfmt;
	424	server.repl_serve_stale_data = yn;
e2641e09	425	} else {
3ab20376 PN	426	addReplyErrorFormat(c,"Unsupported CONFIG parameter: %s",
3ab20376 PN	427	(char*)c->argv[2]->ptr);
e2641e09	428	return;
e2641e09	429	}
e2641e09	430	addReply(c,shared.ok);
	431	return;
	432
	433	badfmt: /* Bad format errors */
3ab20376	434	addReplyErrorFormat(c,"Invalid argument '%s' for CONFIG SET '%s'",
e2641e09	435	(char*)o->ptr,
3ab20376	436	(char*)c->argv[2]->ptr);
e2641e09	437	}
	438
	439	void configGetCommand(redisClient *c) {
a375b077	440	robj *o = c->argv[2];
b301c1fc	441	void *replylen = addDeferredMultiBulkLength(c);
e2641e09	442	char *pattern = o->ptr;
a3687929	443	char buf[128];
e2641e09	444	int matches = 0;
a375b077	445	redisAssert(o->encoding == REDIS_ENCODING_RAW);
e2641e09	446
e2641e09	447	if (stringmatch(pattern,"dbfilename",0)) {
	448	addReplyBulkCString(c,"dbfilename");
	449	addReplyBulkCString(c,server.dbfilename);
	450	matches++;
	451	}
	452	if (stringmatch(pattern,"requirepass",0)) {
	453	addReplyBulkCString(c,"requirepass");
	454	addReplyBulkCString(c,server.requirepass);
	455	matches++;
	456	}
	457	if (stringmatch(pattern,"masterauth",0)) {
	458	addReplyBulkCString(c,"masterauth");
	459	addReplyBulkCString(c,server.masterauth);
	460	matches++;
	461	}
	462	if (stringmatch(pattern,"maxmemory",0)) {
a3687929	463	ll2string(buf,sizeof(buf),server.maxmemory);
e2641e09	464	addReplyBulkCString(c,"maxmemory");
	465	addReplyBulkCString(c,buf);
	466	matches++;
	467	}
165346ca	468	if (stringmatch(pattern,"maxmemory-policy",0)) {
	469	char *s;
	470
	471	switch(server.maxmemory_policy) {
	472	case REDIS_MAXMEMORY_VOLATILE_LRU: s = "volatile-lru"; break;
	473	case REDIS_MAXMEMORY_VOLATILE_TTL: s = "volatile-ttl"; break;
	474	case REDIS_MAXMEMORY_VOLATILE_RANDOM: s = "volatile-random"; break;
	475	case REDIS_MAXMEMORY_ALLKEYS_LRU: s = "allkeys-lru"; break;
	476	case REDIS_MAXMEMORY_ALLKEYS_RANDOM: s = "allkeys-random"; break;
5402c426	477	case REDIS_MAXMEMORY_NO_EVICTION: s = "noeviction"; break;
165346ca	478	default: s = "unknown"; break; /* too harmless to panic */
	479	}
	480	addReplyBulkCString(c,"maxmemory-policy");
	481	addReplyBulkCString(c,s);
	482	matches++;
	483	}
a3687929	484	if (stringmatch(pattern,"maxmemory-samples",0)) {
	485	ll2string(buf,sizeof(buf),server.maxmemory_samples);
	486	addReplyBulkCString(c,"maxmemory-samples");
	487	addReplyBulkCString(c,buf);
	488	matches++;
	489	}
e2641e09	490	if (stringmatch(pattern,"timeout",0)) {
a3687929	491	ll2string(buf,sizeof(buf),server.maxidletime);
e2641e09	492	addReplyBulkCString(c,"timeout");
	493	addReplyBulkCString(c,buf);
	494	matches++;
	495	}
	496	if (stringmatch(pattern,"appendonly",0)) {
	497	addReplyBulkCString(c,"appendonly");
	498	addReplyBulkCString(c,server.appendonly ? "yes" : "no");
	499	matches++;
	500	}
	501	if (stringmatch(pattern,"no-appendfsync-on-rewrite",0)) {
	502	addReplyBulkCString(c,"no-appendfsync-on-rewrite");
	503	addReplyBulkCString(c,server.no_appendfsync_on_rewrite ? "yes" : "no");
	504	matches++;
	505	}
	506	if (stringmatch(pattern,"appendfsync",0)) {
	507	char *policy;
	508
	509	switch(server.appendfsync) {
	510	case APPENDFSYNC_NO: policy = "no"; break;
	511	case APPENDFSYNC_EVERYSEC: policy = "everysec"; break;
	512	case APPENDFSYNC_ALWAYS: policy = "always"; break;
	513	default: policy = "unknown"; break; /* too harmless to panic */
	514	}
	515	addReplyBulkCString(c,"appendfsync");
	516	addReplyBulkCString(c,policy);
	517	matches++;
	518	}
	519	if (stringmatch(pattern,"save",0)) {
	520	sds buf = sdsempty();
	521	int j;
	522
	523	for (j = 0; j < server.saveparamslen; j++) {
	524	buf = sdscatprintf(buf,"%ld %d",
	525	server.saveparams[j].seconds,
	526	server.saveparams[j].changes);
	527	if (j != server.saveparamslen-1)
	528	buf = sdscatlen(buf," ",1);
	529	}
	530	addReplyBulkCString(c,"save");
	531	addReplyBulkCString(c,buf);
	532	sdsfree(buf);
	533	matches++;
	534	}
4ebfc455	535	if (stringmatch(pattern,"slave-serve-stale-data",0)) {
	536	addReplyBulkCString(c,"slave-serve-stale-data");
	537	addReplyBulkCString(c,server.repl_serve_stale_data ? "yes" : "no");
	538	matches++;
	539	}
b301c1fc	540	setDeferredMultiBulkLength(c,replylen,matches*2);
e2641e09	541	}
	542
	543	void configCommand(redisClient *c) {
	544	if (!strcasecmp(c->argv[1]->ptr,"set")) {
	545	if (c->argc != 4) goto badarity;
	546	configSetCommand(c);
	547	} else if (!strcasecmp(c->argv[1]->ptr,"get")) {
	548	if (c->argc != 3) goto badarity;
	549	configGetCommand(c);
	550	} else if (!strcasecmp(c->argv[1]->ptr,"resetstat")) {
	551	if (c->argc != 2) goto badarity;
9f8ded8c	552	server.stat_keyspace_hits = 0;
9f8ded8c	553	server.stat_keyspace_misses = 0;
e2641e09	554	server.stat_numcommands = 0;
	555	server.stat_numconnections = 0;
	556	server.stat_expiredkeys = 0;
e2641e09	557	addReply(c,shared.ok);
e2641e09	558	} else {
3ab20376 PN	559	addReplyError(c,
3ab20376 PN	560	"CONFIG subcommand must be one of GET, SET, RESETSTAT");
e2641e09	561	}
	562	return;
	563
	564	badarity:
3ab20376 PN	565	addReplyErrorFormat(c,"Wrong number of arguments for CONFIG %s",
3ab20376 PN	566	(char*) c->argv[1]->ptr);
e2641e09	567	}