[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],"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 {
                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],"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],"vm-enabled") && argc == 2) {
            if ((server.vm_enabled = yesnotoi(argv[1])) == -1) {
                err = "argument must be 'yes' or 'no'"; goto loaderr;
            }
        } else if (!strcasecmp(argv[0],"vm-swap-file") && argc == 2) {
            zfree(server.vm_swap_file);
            server.vm_swap_file = zstrdup(argv[1]);
        } else if (!strcasecmp(argv[0],"vm-max-memory") && argc == 2) {
            server.vm_max_memory = memtoll(argv[1],NULL);
        } else if (!strcasecmp(argv[0],"vm-page-size") && argc == 2) {
            server.vm_page_size = memtoll(argv[1], NULL);
        } else if (!strcasecmp(argv[0],"vm-pages") && argc == 2) {
            server.vm_pages = memtoll(argv[1], NULL);
        } else if (!strcasecmp(argv[0],"vm-max-threads") && argc == 2) {
            server.vm_max_threads = strtoll(argv[1], NULL, 10);
        } 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 {
            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 {
        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;
        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++;
    }
    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	}
	117	} else if (!strcasecmp(argv[0],"databases") && argc == 2) {
	118	server.dbnum = atoi(argv[1]);
	119	if (server.dbnum < 1) {
	120	err = "Invalid number of databases"; goto loaderr;
	121	}
	122	} else if (!strcasecmp(argv[0],"include") && argc == 2) {
	123	loadServerConfig(argv[1]);
	124	} else if (!strcasecmp(argv[0],"maxclients") && argc == 2) {
	125	server.maxclients = atoi(argv[1]);
	126	} else if (!strcasecmp(argv[0],"maxmemory") && argc == 2) {
	127	server.maxmemory = memtoll(argv[1],NULL);
165346ca	128	} else if (!strcasecmp(argv[0],"maxmemory-policy") && argc == 2) {
	129	if (!strcasecmp(argv[1],"volatile-lru")) {
	130	server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_LRU;
	131	} else if (!strcasecmp(argv[1],"volatile-random")) {
	132	server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_RANDOM;
	133	} else if (!strcasecmp(argv[1],"volatile-ttl")) {
	134	server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_TTL;
	135	} else if (!strcasecmp(argv[1],"allkeys-lru")) {
	136	server.maxmemory_policy = REDIS_MAXMEMORY_ALLKEYS_LRU;
	137	} else if (!strcasecmp(argv[1],"allkeys-random")) {
	138	server.maxmemory_policy = REDIS_MAXMEMORY_ALLKEYS_RANDOM;
	139	} else {
	140	err = "Invalid maxmemory policy";
	141	goto loaderr;
	142	}
a3687929	143	} else if (!strcasecmp(argv[0],"maxmemory-samples") && argc == 2) {
	144	server.maxmemory_samples = atoi(argv[1]);
	145	if (server.maxmemory_samples <= 0) {
	146	err = "maxmemory-samples must be 1 or greater";
	147	goto loaderr;
	148	}
e2641e09	149	} else if (!strcasecmp(argv[0],"slaveof") && argc == 3) {
	150	server.masterhost = sdsnew(argv[1]);
	151	server.masterport = atoi(argv[2]);
	152	server.replstate = REDIS_REPL_CONNECT;
	153	} else if (!strcasecmp(argv[0],"masterauth") && argc == 2) {
	154	server.masterauth = zstrdup(argv[1]);
	155	} else if (!strcasecmp(argv[0],"glueoutputbuf") && argc == 2) {
	156	if ((server.glueoutputbuf = yesnotoi(argv[1])) == -1) {
	157	err = "argument must be 'yes' or 'no'"; goto loaderr;
	158	}
	159	} else if (!strcasecmp(argv[0],"rdbcompression") && argc == 2) {
	160	if ((server.rdbcompression = yesnotoi(argv[1])) == -1) {
	161	err = "argument must be 'yes' or 'no'"; goto loaderr;
	162	}
	163	} else if (!strcasecmp(argv[0],"activerehashing") && argc == 2) {
	164	if ((server.activerehashing = yesnotoi(argv[1])) == -1) {
	165	err = "argument must be 'yes' or 'no'"; goto loaderr;
	166	}
	167	} else if (!strcasecmp(argv[0],"daemonize") && argc == 2) {
	168	if ((server.daemonize = yesnotoi(argv[1])) == -1) {
	169	err = "argument must be 'yes' or 'no'"; goto loaderr;
	170	}
	171	} else if (!strcasecmp(argv[0],"appendonly") && argc == 2) {
	172	if ((server.appendonly = yesnotoi(argv[1])) == -1) {
	173	err = "argument must be 'yes' or 'no'"; goto loaderr;
	174	}
	175	} else if (!strcasecmp(argv[0],"appendfilename") && argc == 2) {
	176	zfree(server.appendfilename);
	177	server.appendfilename = zstrdup(argv[1]);
	178	} else if (!strcasecmp(argv[0],"no-appendfsync-on-rewrite")
	179	&& argc == 2) {
	180	if ((server.no_appendfsync_on_rewrite= yesnotoi(argv[1])) == -1) {
	181	err = "argument must be 'yes' or 'no'"; goto loaderr;
	182	}
	183	} else if (!strcasecmp(argv[0],"appendfsync") && argc == 2) {
	184	if (!strcasecmp(argv[1],"no")) {
	185	server.appendfsync = APPENDFSYNC_NO;
	186	} else if (!strcasecmp(argv[1],"always")) {
	187	server.appendfsync = APPENDFSYNC_ALWAYS;
	188	} else if (!strcasecmp(argv[1],"everysec")) {
	189	server.appendfsync = APPENDFSYNC_EVERYSEC;
	190	} else {
	191	err = "argument must be 'no', 'always' or 'everysec'";
	192	goto loaderr;
	193	}
	194	} else if (!strcasecmp(argv[0],"requirepass") && argc == 2) {
	195	server.requirepass = zstrdup(argv[1]);
	196	} else if (!strcasecmp(argv[0],"pidfile") && argc == 2) {
	197	zfree(server.pidfile);
	198	server.pidfile = zstrdup(argv[1]);
	199	} else if (!strcasecmp(argv[0],"dbfilename") && argc == 2) {
	200	zfree(server.dbfilename);
	201	server.dbfilename = zstrdup(argv[1]);
	202	} else if (!strcasecmp(argv[0],"vm-enabled") && argc == 2) {
	203	if ((server.vm_enabled = yesnotoi(argv[1])) == -1) {
	204	err = "argument must be 'yes' or 'no'"; goto loaderr;
	205	}
	206	} else if (!strcasecmp(argv[0],"vm-swap-file") && argc == 2) {
	207	zfree(server.vm_swap_file);
	208	server.vm_swap_file = zstrdup(argv[1]);
	209	} else if (!strcasecmp(argv[0],"vm-max-memory") && argc == 2) {
	210	server.vm_max_memory = memtoll(argv[1],NULL);
	211	} else if (!strcasecmp(argv[0],"vm-page-size") && argc == 2) {
	212	server.vm_page_size = memtoll(argv[1], NULL);
213	} else if (!strcasecmp(argv[0],"vm-pages") && argc == 2) {
214	server.vm_pages = memtoll(argv[1], NULL);
215	} else if (!strcasecmp(argv[0],"vm-max-threads") && argc == 2) {
216	server.vm_max_threads = strtoll(argv[1], NULL, 10);
8d3e063a	217	} else if (!strcasecmp(argv[0],"hash-max-zipmap-entries") && argc == 2) {
e2641e09	218	server.hash_max_zipmap_entries = memtoll(argv[1], NULL);
8d3e063a	219	} else if (!strcasecmp(argv[0],"hash-max-zipmap-value") && argc == 2) {
e2641e09	220	server.hash_max_zipmap_value = memtoll(argv[1], NULL);
	221	} else if (!strcasecmp(argv[0],"list-max-ziplist-entries") && argc == 2){
	222	server.list_max_ziplist_entries = memtoll(argv[1], NULL);
8d3e063a	223	} else if (!strcasecmp(argv[0],"list-max-ziplist-value") && argc == 2) {
e2641e09	224	server.list_max_ziplist_value = memtoll(argv[1], NULL);
8d3e063a	225	} else if (!strcasecmp(argv[0],"set-max-intset-entries") && argc == 2) {
96ffb2fe	226	server.set_max_intset_entries = memtoll(argv[1], NULL);
8d3e063a	227	} else if (!strcasecmp(argv[0],"rename-command") && argc == 3) {
	228	struct redisCommand *cmd = lookupCommand(argv[1]);
	229	int retval;
	230
	231	if (!cmd) {
	232	err = "No such command in rename-command";
	233	goto loaderr;
	234	}
	235
	236	/* If the target command name is the emtpy string we just
	237	* remove it from the command table. */
	238	retval = dictDelete(server.commands, argv[1]);
	239	redisAssert(retval == DICT_OK);
	240
	241	/* Otherwise we re-add the command under a different name. */
	242	if (sdslen(argv[2]) != 0) {
	243	sds copy = sdsdup(argv[2]);
	244
	245	retval = dictAdd(server.commands, copy, cmd);
	246	if (retval != DICT_OK) {
	247	sdsfree(copy);
	248	err = "Target command name already exists"; goto loaderr;
	249	}
	250	}
e2641e09	251	} else {
	252	err = "Bad directive or wrong number of arguments"; goto loaderr;
	253	}
	254	for (j = 0; j < argc; j++)
	255	sdsfree(argv[j]);
	256	zfree(argv);
	257	sdsfree(line);
	258	}
	259	if (fp != stdin) fclose(fp);
	260	return;
	261
	262	loaderr:
	263	fprintf(stderr, "\n* FATAL CONFIG FILE ERROR *\n");
	264	fprintf(stderr, "Reading the configuration file, at line %d\n", linenum);
	265	fprintf(stderr, ">>> '%s'\n", line);
	266	fprintf(stderr, "%s\n", err);
	267	exit(1);
	268	}
	269
	270	/*-----------------------------------------------------------------------------
	271	* CONFIG command for remote configuration
	272	----------------------------------------------------------------------------/
	273
	274	void configSetCommand(redisClient *c) {
a375b077	275	robj *o;
e2641e09	276	long long ll;
a375b077 PN	277	redisAssert(c->argv[2]->encoding == REDIS_ENCODING_RAW);
	278	redisAssert(c->argv[3]->encoding == REDIS_ENCODING_RAW);
	279	o = c->argv[3];
e2641e09	280
	281	if (!strcasecmp(c->argv[2]->ptr,"dbfilename")) {
	282	zfree(server.dbfilename);
	283	server.dbfilename = zstrdup(o->ptr);
	284	} else if (!strcasecmp(c->argv[2]->ptr,"requirepass")) {
	285	zfree(server.requirepass);
	286	server.requirepass = zstrdup(o->ptr);
	287	} else if (!strcasecmp(c->argv[2]->ptr,"masterauth")) {
	288	zfree(server.masterauth);
	289	server.masterauth = zstrdup(o->ptr);
	290	} else if (!strcasecmp(c->argv[2]->ptr,"maxmemory")) {
	291	if (getLongLongFromObject(o,&ll) == REDIS_ERR \|\|
	292	ll < 0) goto badfmt;
	293	server.maxmemory = ll;
b4f2e412	294	if (server.maxmemory) freeMemoryIfNeeded();
165346ca	295	} else if (!strcasecmp(c->argv[2]->ptr,"maxmemory-policy")) {
	296	if (!strcasecmp(o->ptr,"volatile-lru")) {
	297	server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_LRU;
	298	} else if (!strcasecmp(o->ptr,"volatile-random")) {
	299	server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_RANDOM;
	300	} else if (!strcasecmp(o->ptr,"volatile-ttl")) {
	301	server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_TTL;
	302	} else if (!strcasecmp(o->ptr,"allkeys-lru")) {
	303	server.maxmemory_policy = REDIS_MAXMEMORY_ALLKEYS_LRU;
	304	} else if (!strcasecmp(o->ptr,"allkeys-random")) {
	305	server.maxmemory_policy = REDIS_MAXMEMORY_ALLKEYS_RANDOM;
	306	} else {
	307	goto badfmt;
	308	}
a3687929	309	} else if (!strcasecmp(c->argv[2]->ptr,"maxmemory-samples")) {
	310	if (getLongLongFromObject(o,&ll) == REDIS_ERR \|\|
	311	ll <= 0) goto badfmt;
	312	server.maxmemory_samples = ll;
e2641e09	313	} else if (!strcasecmp(c->argv[2]->ptr,"timeout")) {
	314	if (getLongLongFromObject(o,&ll) == REDIS_ERR \|\|
	315	ll < 0 \|\| ll > LONG_MAX) goto badfmt;
	316	server.maxidletime = ll;
	317	} else if (!strcasecmp(c->argv[2]->ptr,"appendfsync")) {
	318	if (!strcasecmp(o->ptr,"no")) {
	319	server.appendfsync = APPENDFSYNC_NO;
	320	} else if (!strcasecmp(o->ptr,"everysec")) {
	321	server.appendfsync = APPENDFSYNC_EVERYSEC;
	322	} else if (!strcasecmp(o->ptr,"always")) {
	323	server.appendfsync = APPENDFSYNC_ALWAYS;
	324	} else {
	325	goto badfmt;
	326	}
	327	} else if (!strcasecmp(c->argv[2]->ptr,"no-appendfsync-on-rewrite")) {
	328	int yn = yesnotoi(o->ptr);
	329
	330	if (yn == -1) goto badfmt;
	331	server.no_appendfsync_on_rewrite = yn;
	332	} else if (!strcasecmp(c->argv[2]->ptr,"appendonly")) {
	333	int old = server.appendonly;
	334	int new = yesnotoi(o->ptr);
	335
	336	if (new == -1) goto badfmt;
	337	if (old != new) {
	338	if (new == 0) {
	339	stopAppendOnly();
	340	} else {
	341	if (startAppendOnly() == REDIS_ERR) {
3ab20376 PN	342	addReplyError(c,
3ab20376 PN	343	"Unable to turn on AOF. Check server logs.");
e2641e09	344	return;
	345	}
	346	}
	347	}
	348	} else if (!strcasecmp(c->argv[2]->ptr,"save")) {
	349	int vlen, j;
	350	sds *v = sdssplitlen(o->ptr,sdslen(o->ptr)," ",1,&vlen);
	351
	352	/* Perform sanity check before setting the new config:
	353	* - Even number of args
	354	* - Seconds >= 1, changes >= 0 */
	355	if (vlen & 1) {
	356	sdsfreesplitres(v,vlen);
	357	goto badfmt;
	358	}
	359	for (j = 0; j < vlen; j++) {
	360	char *eptr;
	361	long val;
	362
	363	val = strtoll(v[j], &eptr, 10);
	364	if (eptr[0] != '\0' \|\|
	365	((j & 1) == 0 && val < 1) \|\|
	366	((j & 1) == 1 && val < 0)) {
	367	sdsfreesplitres(v,vlen);
	368	goto badfmt;
	369	}
	370	}
	371	/* Finally set the new config */
	372	resetServerSaveParams();
	373	for (j = 0; j < vlen; j += 2) {
	374	time_t seconds;
	375	int changes;
	376
	377	seconds = strtoll(v[j],NULL,10);
	378	changes = strtoll(v[j+1],NULL,10);
	379	appendServerSaveParams(seconds, changes);
	380	}
	381	sdsfreesplitres(v,vlen);
	382	} else {
3ab20376 PN	383	addReplyErrorFormat(c,"Unsupported CONFIG parameter: %s",
3ab20376 PN	384	(char*)c->argv[2]->ptr);
e2641e09	385	return;
e2641e09	386	}
e2641e09	387	addReply(c,shared.ok);
	388	return;
	389
	390	badfmt: /* Bad format errors */
3ab20376	391	addReplyErrorFormat(c,"Invalid argument '%s' for CONFIG SET '%s'",
e2641e09	392	(char*)o->ptr,
3ab20376	393	(char*)c->argv[2]->ptr);
e2641e09	394	}
	395
	396	void configGetCommand(redisClient *c) {
a375b077	397	robj *o = c->argv[2];
b301c1fc	398	void *replylen = addDeferredMultiBulkLength(c);
e2641e09	399	char *pattern = o->ptr;
a3687929	400	char buf[128];
e2641e09	401	int matches = 0;
a375b077	402	redisAssert(o->encoding == REDIS_ENCODING_RAW);
e2641e09	403
e2641e09	404	if (stringmatch(pattern,"dbfilename",0)) {
	405	addReplyBulkCString(c,"dbfilename");
	406	addReplyBulkCString(c,server.dbfilename);
	407	matches++;
	408	}
	409	if (stringmatch(pattern,"requirepass",0)) {
	410	addReplyBulkCString(c,"requirepass");
	411	addReplyBulkCString(c,server.requirepass);
	412	matches++;
	413	}
	414	if (stringmatch(pattern,"masterauth",0)) {
	415	addReplyBulkCString(c,"masterauth");
	416	addReplyBulkCString(c,server.masterauth);
	417	matches++;
	418	}
	419	if (stringmatch(pattern,"maxmemory",0)) {
a3687929	420	ll2string(buf,sizeof(buf),server.maxmemory);
e2641e09	421	addReplyBulkCString(c,"maxmemory");
	422	addReplyBulkCString(c,buf);
	423	matches++;
	424	}
165346ca	425	if (stringmatch(pattern,"maxmemory-policy",0)) {
	426	char *s;
	427
	428	switch(server.maxmemory_policy) {
	429	case REDIS_MAXMEMORY_VOLATILE_LRU: s = "volatile-lru"; break;
	430	case REDIS_MAXMEMORY_VOLATILE_TTL: s = "volatile-ttl"; break;
	431	case REDIS_MAXMEMORY_VOLATILE_RANDOM: s = "volatile-random"; break;
	432	case REDIS_MAXMEMORY_ALLKEYS_LRU: s = "allkeys-lru"; break;
	433	case REDIS_MAXMEMORY_ALLKEYS_RANDOM: s = "allkeys-random"; break;
	434	default: s = "unknown"; break; /* too harmless to panic */
	435	}
	436	addReplyBulkCString(c,"maxmemory-policy");
	437	addReplyBulkCString(c,s);
	438	matches++;
	439	}
a3687929	440	if (stringmatch(pattern,"maxmemory-samples",0)) {
	441	ll2string(buf,sizeof(buf),server.maxmemory_samples);
	442	addReplyBulkCString(c,"maxmemory-samples");
	443	addReplyBulkCString(c,buf);
	444	matches++;
	445	}
e2641e09	446	if (stringmatch(pattern,"timeout",0)) {
a3687929	447	ll2string(buf,sizeof(buf),server.maxidletime);
e2641e09	448	addReplyBulkCString(c,"timeout");
	449	addReplyBulkCString(c,buf);
	450	matches++;
	451	}
	452	if (stringmatch(pattern,"appendonly",0)) {
	453	addReplyBulkCString(c,"appendonly");
	454	addReplyBulkCString(c,server.appendonly ? "yes" : "no");
	455	matches++;
	456	}
	457	if (stringmatch(pattern,"no-appendfsync-on-rewrite",0)) {
	458	addReplyBulkCString(c,"no-appendfsync-on-rewrite");
	459	addReplyBulkCString(c,server.no_appendfsync_on_rewrite ? "yes" : "no");
	460	matches++;
	461	}
	462	if (stringmatch(pattern,"appendfsync",0)) {
	463	char *policy;
	464
	465	switch(server.appendfsync) {
	466	case APPENDFSYNC_NO: policy = "no"; break;
	467	case APPENDFSYNC_EVERYSEC: policy = "everysec"; break;
	468	case APPENDFSYNC_ALWAYS: policy = "always"; break;
	469	default: policy = "unknown"; break; /* too harmless to panic */
	470	}
	471	addReplyBulkCString(c,"appendfsync");
	472	addReplyBulkCString(c,policy);
	473	matches++;
	474	}
	475	if (stringmatch(pattern,"save",0)) {
	476	sds buf = sdsempty();
	477	int j;
	478
	479	for (j = 0; j < server.saveparamslen; j++) {
	480	buf = sdscatprintf(buf,"%ld %d",
	481	server.saveparams[j].seconds,
	482	server.saveparams[j].changes);
	483	if (j != server.saveparamslen-1)
	484	buf = sdscatlen(buf," ",1);
	485	}
	486	addReplyBulkCString(c,"save");
	487	addReplyBulkCString(c,buf);
	488	sdsfree(buf);
	489	matches++;
	490	}
b301c1fc	491	setDeferredMultiBulkLength(c,replylen,matches*2);
e2641e09	492	}
	493
	494	void configCommand(redisClient *c) {
	495	if (!strcasecmp(c->argv[1]->ptr,"set")) {
	496	if (c->argc != 4) goto badarity;
	497	configSetCommand(c);
	498	} else if (!strcasecmp(c->argv[1]->ptr,"get")) {
	499	if (c->argc != 3) goto badarity;
	500	configGetCommand(c);
	501	} else if (!strcasecmp(c->argv[1]->ptr,"resetstat")) {
	502	if (c->argc != 2) goto badarity;
9f8ded8c	503	server.stat_keyspace_hits = 0;
9f8ded8c	504	server.stat_keyspace_misses = 0;
e2641e09	505	server.stat_numcommands = 0;
	506	server.stat_numconnections = 0;
	507	server.stat_expiredkeys = 0;
e2641e09	508	addReply(c,shared.ok);
e2641e09	509	} else {
3ab20376 PN	510	addReplyError(c,
3ab20376 PN	511	"CONFIG subcommand must be one of GET, SET, RESETSTAT");
e2641e09	512	}
	513	return;
	514
	515	badarity:
3ab20376 PN	516	addReplyErrorFormat(c,"Wrong number of arguments for CONFIG %s",
3ab20376 PN	517	(char*) c->argv[1]->ptr);
e2641e09	518	}