config.c

/* Configuration file parsing and CONFIG GET/SET commands implementation.
 *
 * Copyright (c) 2009-2012, Salvatore Sanfilippo <antirez at gmail dot com>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 * * Neither the name of Redis nor the names of its contributors may be used
 * to endorse or promote products derived from this software without
 * specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include"server.h"
#include"cluster.h"

#include<fcntl.h>
#include<sys/stat.h>

/*-----------------------------------------------------------------------------
 * Config file name-value maps.
 *----------------------------------------------------------------------------*/

typedefstructconfigEnum {
constchar*name;
constintval;
} configEnum;

configEnummaxmemory_policy_enum[] = {
 {"volatile-lru", MAXMEMORY_VOLATILE_LRU},
 {"volatile-lfu", MAXMEMORY_VOLATILE_LFU},
 {"volatile-random",MAXMEMORY_VOLATILE_RANDOM},
 {"volatile-ttl",MAXMEMORY_VOLATILE_TTL},
 {"allkeys-lru",MAXMEMORY_ALLKEYS_LRU},
 {"allkeys-lfu",MAXMEMORY_ALLKEYS_LFU},
 {"allkeys-random",MAXMEMORY_ALLKEYS_RANDOM},
 {"noeviction",MAXMEMORY_NO_EVICTION},
 {NULL, 0}
};

configEnumsyslog_facility_enum[] = {
 {"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}
};

configEnumloglevel_enum[] = {
 {"debug", LL_DEBUG},
 {"verbose", LL_VERBOSE},
 {"notice", LL_NOTICE},
 {"warning", LL_WARNING},
 {NULL,0}
};

configEnumsupervised_mode_enum[] = {
 {"upstart", SUPERVISED_UPSTART},
 {"systemd", SUPERVISED_SYSTEMD},
 {"auto", SUPERVISED_AUTODETECT},
 {"no", SUPERVISED_NONE},
 {NULL, 0}
};

configEnumaof_fsync_enum[] = {
 {"everysec", AOF_FSYNC_EVERYSEC},
 {"always", AOF_FSYNC_ALWAYS},
 {"no", AOF_FSYNC_NO},
 {NULL, 0}
};

configEnumrepl_diskless_load_enum[] = {
 {"disabled", REPL_DISKLESS_LOAD_DISABLED},
 {"on-empty-db", REPL_DISKLESS_LOAD_WHEN_DB_EMPTY},
 {"swapdb", REPL_DISKLESS_LOAD_SWAPDB},
 {NULL, 0}
};

configEnumtls_auth_clients_enum[] = {
 {"no", TLS_CLIENT_AUTH_NO},
 {"yes", TLS_CLIENT_AUTH_YES},
 {"optional", TLS_CLIENT_AUTH_OPTIONAL},
 {NULL, 0}
};

configEnumoom_score_adj_enum[] = {
 {"no", OOM_SCORE_ADJ_NO},
 {"yes", OOM_SCORE_RELATIVE},
 {"relative", OOM_SCORE_RELATIVE},
 {"absolute", OOM_SCORE_ADJ_ABSOLUTE},
 {NULL, 0}
};

configEnumacl_pubsub_default_enum[] = {
 {"allchannels", USER_FLAG_ALLCHANNELS},
 {"resetchannels", 0},
 {NULL, 0}
};

configEnumsanitize_dump_payload_enum[] = {
 {"no", SANITIZE_DUMP_NO},
 {"yes", SANITIZE_DUMP_YES},
 {"clients", SANITIZE_DUMP_CLIENTS},
 {NULL, 0}
};

/* Output buffer limits presets. */
clientBufferLimitsConfigclientBufferLimitsDefaults[CLIENT_TYPE_OBUF_COUNT] = {
 {0, 0, 0}, /* normal */
 {1024*1024*256, 1024*1024*64, 60}, /* slave */
 {1024*1024*32, 1024*1024*8, 60} /* pubsub */
};

/* OOM Score defaults */
intconfigOOMScoreAdjValuesDefaults[CONFIG_OOM_COUNT] = { 0, 200, 800 };

/* Generic config infrastructure function pointers
 * int is_valid_fn(val, err)
 * Return 1 when val is valid, and 0 when invalid.
 * Optionally set err to a static error string.
 * int update_fn(val, prev, err)
 * This function is called only for CONFIG SET command (not at config file parsing)
 * It is called after the actual config is applied,
 * Return 1 for success, and 0 for failure.
 * Optionally set err to a static error string.
 * On failure the config change will be reverted.
 */

/* Configuration values that require no special handling to set, get, load or
 * rewrite. */
typedefstructboolConfigData {
int*config; /* The pointer to the server config this value is stored in */
constintdefault_value; /* The default value of the config on rewrite */
int (*is_valid_fn)(intval, constchar**err); /* Optional function to check validity of new value (generic doc above) */
int (*update_fn)(intval, intprev, constchar**err); /* Optional function to apply new value at runtime (generic doc above) */
} boolConfigData;

typedefstructstringConfigData {
char**config; /* Pointer to the server config this value is stored in. */
constchar*default_value; /* Default value of the config on rewrite. */
int (*is_valid_fn)(char*val, constchar**err); /* Optional function to check validity of new value (generic doc above) */
int (*update_fn)(char*val, char*prev, constchar**err); /* Optional function to apply new value at runtime (generic doc above) */
intconvert_empty_to_null; /* Boolean indicating if empty strings should
 be stored as a NULL value. */
} stringConfigData;

typedefstructsdsConfigData {
sds*config; /* Pointer to the server config this value is stored in. */
constchar*default_value; /* Default value of the config on rewrite. */
int (*is_valid_fn)(sdsval, constchar**err); /* Optional function to check validity of new value (generic doc above) */
int (*update_fn)(sdsval, sdsprev, constchar**err); /* Optional function to apply new value at runtime (generic doc above) */
intconvert_empty_to_null; /* Boolean indicating if empty SDS strings should
 be stored as a NULL value. */
} sdsConfigData;

typedefstructenumConfigData {
int*config; /* The pointer to the server config this value is stored in */
configEnum*enum_value; /* The underlying enum type this data represents */
constintdefault_value; /* The default value of the config on rewrite */
int (*is_valid_fn)(intval, constchar**err); /* Optional function to check validity of new value (generic doc above) */
int (*update_fn)(intval, intprev, constchar**err); /* Optional function to apply new value at runtime (generic doc above) */
} enumConfigData;

typedefenumnumericType {
NUMERIC_TYPE_INT,
NUMERIC_TYPE_UINT,
NUMERIC_TYPE_LONG,
NUMERIC_TYPE_ULONG,
NUMERIC_TYPE_LONG_LONG,
NUMERIC_TYPE_ULONG_LONG,
NUMERIC_TYPE_SIZE_T,
NUMERIC_TYPE_SSIZE_T,
NUMERIC_TYPE_OFF_T,
NUMERIC_TYPE_TIME_T,
} numericType;

typedefstructnumericConfigData {
union {
int*i;
unsigned int*ui;
long*l;
unsigned long*ul;
long long*ll;
unsigned long long*ull;
size_t*st;
ssize_t*sst;
off_t*ot;
time_t*tt;
 } config; /* The pointer to the numeric config this value is stored in */
intis_memory; /* Indicates if this value can be loaded as a memory value */
numericTypenumeric_type; /* An enum indicating the type of this value */
long longlower_bound; /* The lower bound of this numeric value */
long longupper_bound; /* The upper bound of this numeric value */
constlong longdefault_value; /* The default value of the config on rewrite */
int (*is_valid_fn)(long longval, constchar**err); /* Optional function to check validity of new value (generic doc above) */
int (*update_fn)(long longval, long longprev, constchar**err); /* Optional function to apply new value at runtime (generic doc above) */
} numericConfigData;

typedefuniontypeData {
boolConfigDatayesno;
stringConfigDatastring;
sdsConfigDatasds;
enumConfigDataenumd;
numericConfigDatanumeric;
} typeData;

typedefstructtypeInterface {
/* Called on server start, to init the server with default value */
void (*init)(typeDatadata);
/* Called on server startup and CONFIG SET, returns 1 on success, 0 on error
 * and can set a verbose err string, update is true when called from CONFIG SET */
int (*set)(typeDatadata, sdsvalue, intupdate, constchar**err);
/* Called on CONFIG GET, required to add output to the client */
void (*get)(client*c, typeDatadata);
/* Called on CONFIG REWRITE, required to rewrite the config state */
void (*rewrite)(typeDatadata, constchar*name, structrewriteConfigState*state);
} typeInterface;

typedefstructstandardConfig {
constchar*name; /* The user visible name of this config */
constchar*alias; /* An alias that can also be used for this config */
constunsigned intflags; /* Flags for this specific config */
typeInterfaceinterface; /* The function pointers that define the type interface */
typeDatadata; /* The type specific data exposed used by the interface */
} standardConfig;

#defineMODIFIABLE_CONFIG 0 /* This is the implied default for a standard 
 * config, which is mutable. */
#defineIMMUTABLE_CONFIG (1ULL<<0) /* Can this value only be set at startup? */
#defineSENSITIVE_CONFIG (1ULL<<1) /* Does this value contain sensitive information */

standardConfigconfigs[];

/*-----------------------------------------------------------------------------
 * Enum access functions
 *----------------------------------------------------------------------------*/

/* Get enum value from name. If there is no match INT_MIN is returned. */
intconfigEnumGetValue(configEnum*ce, char*name) {
while(ce->name!=NULL) {
if (!strcasecmp(ce->name,name)) returnce->val;
ce++;
 }
returnINT_MIN;
}

/* Get enum name from value. If no match is found NULL is returned. */
constchar*configEnumGetName(configEnum*ce, intval) {
while(ce->name!=NULL) {
if (ce->val==val) returnce->name;
ce++;
 }
returnNULL;
}

/* Wrapper for configEnumGetName() returning "unknown" instead of NULL if
 * there is no match. */
constchar*configEnumGetNameOrUnknown(configEnum*ce, intval) {
constchar*name=configEnumGetName(ce,val);
returnname ? name : "unknown";
}

/* Used for INFO generation. */
constchar*evictPolicyToString(void) {
returnconfigEnumGetNameOrUnknown(maxmemory_policy_enum,server.maxmemory_policy);
}

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

intyesnotoi(char*s) {
if (!strcasecmp(s,"yes")) return1;
elseif (!strcasecmp(s,"no")) return0;
elsereturn-1;
}

voidappendServerSaveParams(time_tseconds, intchanges) {
server.saveparams=zrealloc(server.saveparams,sizeof(structsaveparam)*(server.saveparamslen+1));
server.saveparams[server.saveparamslen].seconds=seconds;
server.saveparams[server.saveparamslen].changes=changes;
server.saveparamslen++;
}

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

voidqueueLoadModule(sdspath, sds*argv, intargc) {
inti;
structmoduleLoadQueueEntry*loadmod;

loadmod=zmalloc(sizeof(structmoduleLoadQueueEntry));
loadmod->argv=argc ? zmalloc(sizeof(robj*)*argc) : NULL;
loadmod->path=sdsnew(path);
loadmod->argc=argc;
for (i=0; i<argc; i++) {
loadmod->argv[i] =createRawStringObject(argv[i],sdslen(argv[i]));
 }
listAddNodeTail(server.loadmodule_queue,loadmod);
}

/* Parse an array of CONFIG_OOM_COUNT sds strings, validate and populate
 * server.oom_score_adj_values if valid.
 */

staticintupdateOOMScoreAdjValues(sds*args, constchar**err, intapply) {
inti;
intvalues[CONFIG_OOM_COUNT];

for (i=0; i<CONFIG_OOM_COUNT; i++) {
char*eptr;
long longval=strtoll(args[i], &eptr, 10);

if (*eptr!='\0'||val<-2000||val>2000) {
if (err) *err="Invalid oom-score-adj-values, elements must be between -2000 and 2000.";
returnC_ERR;
 }

values[i] =val;
 }

/* Verify that the values make sense. If they don't omit a warning but
 * keep the configuration, which may still be valid for privileged processes.
 */

if (values[CONFIG_OOM_REPLICA] <values[CONFIG_OOM_MASTER] ||
values[CONFIG_OOM_BGCHILD] <values[CONFIG_OOM_REPLICA]) {
serverLog(LOG_WARNING,
"The oom-score-adj-values configuration may not work for non-privileged processes! "
"Please consult the documentation.");
 }

/* Store values, retain previous config for rollback in case we fail. */
intold_values[CONFIG_OOM_COUNT];
for (i=0; i<CONFIG_OOM_COUNT; i++) {
old_values[i] =server.oom_score_adj_values[i];
server.oom_score_adj_values[i] =values[i];
 }

/* When parsing the config file, we want to apply only when all is done. */
if (!apply)
returnC_OK;

/* Update */
if (setOOMScoreAdj(-1) ==C_ERR) {
/* Roll back */
for (i=0; i<CONFIG_OOM_COUNT; i++)
server.oom_score_adj_values[i] =old_values[i];

if (err)
*err="Failed to apply oom-score-adj-values configuration, check server logs.";

returnC_ERR;
 }

returnC_OK;
}

voidinitConfigValues() {
for (standardConfig*config=configs; config->name!=NULL; config++) {
config->interface.init(config->data);
 }
}

voidloadServerConfigFromString(char*config) {
constchar*err=NULL;
intlinenum=0, totlines, i;
intslaveof_linenum=0;
sds*lines;
intsave_loaded=0;

lines=sdssplitlen(config,strlen(config),"\n",1,&totlines);

for (i=0; i<totlines; i++) {
sds*argv;
intargc;

linenum=i+1;
lines[i] =sdstrim(lines[i]," \t\r\n");

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

/* Split into arguments */
argv=sdssplitargs(lines[i],&argc);
if (argv==NULL) {
err="Unbalanced quotes in configuration line";
 goto loaderr;
 }

/* Skip this line if the resulting command vector is empty. */
if (argc==0) {
sdsfreesplitres(argv,argc);
continue;
 }
sdstolower(argv[0]);

/* Iterate the configs that are standard */
intmatch=0;
for (standardConfig*config=configs; config->name!=NULL; config++) {
if ((!strcasecmp(argv[0],config->name) ||
 (config->alias&& !strcasecmp(argv[0],config->alias))))
 {
if (argc!=2) {
err="wrong number of arguments";
 goto loaderr;
 }
if (!config->interface.set(config->data, argv[1], 0, &err)) {
 goto loaderr;
 }

match=1;
break;
 }
 }

if (match) {
sdsfreesplitres(argv,argc);
continue;
 }

/* Execute config directives */
if (!strcasecmp(argv[0],"bind") &&argc >= 2) {
intj, addresses=argc-1;

if (addresses>CONFIG_BINDADDR_MAX) {
err="Too many bind addresses specified"; goto loaderr;
 }
/* Free old bind addresses */
for (j=0; j<server.bindaddr_count; j++) {
zfree(server.bindaddr[j]);
 }
for (j=0; j<addresses; j++)
server.bindaddr[j] =zstrdup(argv[j+1]);
server.bindaddr_count=addresses;
 } elseif (!strcasecmp(argv[0],"unixsocketperm") &&argc==2) {
errno=0;
server.unixsocketperm= (mode_t)strtol(argv[1], NULL, 8);
if (errno||server.unixsocketperm>0777) {
err="Invalid socket file permissions"; goto loaderr;
 }
 } elseif (!strcasecmp(argv[0],"save")) {
/* We don't reset save params before loading, because if they're not part
 * of the file the defaults should be used.
 */
if (!save_loaded) {
save_loaded=1;
resetServerSaveParams();
 }

if (argc==3) {
intseconds=atoi(argv[1]);
intchanges=atoi(argv[2]);
if (seconds<1||changes<0) {
err="Invalid save parameters"; goto loaderr;
 }
appendServerSaveParams(seconds,changes);
 } elseif (argc==2&& !strcasecmp(argv[1],"")) {
resetServerSaveParams();
 }
 } elseif (!strcasecmp(argv[0],"dir") &&argc==2) {
if (chdir(argv[1]) ==-1) {
serverLog(LL_WARNING,"Can't chdir to '%s': %s",
argv[1], strerror(errno));
exit(1);
 }
 } elseif (!strcasecmp(argv[0],"logfile") &&argc==2) {
FILE*logfp;

zfree(server.logfile);
server.logfile=zstrdup(argv[1]);
if (server.logfile[0] !='\0') {
/* 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);
 }
 } elseif (!strcasecmp(argv[0],"include") &&argc==2) {
loadServerConfig(argv[1], 0, NULL);
 } elseif ((!strcasecmp(argv[0],"slaveof") ||
 !strcasecmp(argv[0],"replicaof")) &&argc==3) {
slaveof_linenum=linenum;
sdsfree(server.masterhost);
if (!strcasecmp(argv[1], "no") && !strcasecmp(argv[2], "one")) {
server.masterhost=NULL;
continue;
 }
server.masterhost=sdsnew(argv[1]);
char*ptr;
server.masterport=strtol(argv[2], &ptr, 10);
if (server.masterport<0||server.masterport>65535||*ptr!='\0') {
err="Invalid master port"; goto loaderr;
 }
server.repl_state=REPL_STATE_CONNECT;
 } elseif (!strcasecmp(argv[0],"list-max-ziplist-entries") &&argc==2){
/* DEAD OPTION */
 } elseif (!strcasecmp(argv[0],"list-max-ziplist-value") &&argc==2) {
/* DEAD OPTION */
 } elseif (!strcasecmp(argv[0],"rename-command") &&argc==3) {
structredisCommand*cmd=lookupCommand(argv[1]);
intretval;

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

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

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

retval=dictAdd(server.commands, copy, cmd);
if (retval!=DICT_OK) {
sdsfree(copy);
err="Target command name already exists"; goto loaderr;
 }
 }
 } elseif (!strcasecmp(argv[0],"cluster-config-file") &&argc==2) {
zfree(server.cluster_configfile);
server.cluster_configfile=zstrdup(argv[1]);
 } elseif (!strcasecmp(argv[0],"client-output-buffer-limit") &&
argc==5)
 {
intclass=getClientTypeByName(argv[1]);
unsigned long longhard, soft;
intsoft_seconds;

if (class==-1||class==CLIENT_TYPE_MASTER) {
err="Unrecognized client limit class: the user specified "
"an invalid one, or 'master' which has no buffer limits.";
 goto loaderr;
 }
hard=memtoll(argv[2],NULL);
soft=memtoll(argv[3],NULL);
soft_seconds=atoi(argv[4]);
if (soft_seconds<0) {
err="Negative number of seconds in soft limit is invalid";
 goto loaderr;
 }
server.client_obuf_limits[class].hard_limit_bytes=hard;
server.client_obuf_limits[class].soft_limit_bytes=soft;
server.client_obuf_limits[class].soft_limit_seconds=soft_seconds;
 } elseif (!strcasecmp(argv[0],"oom-score-adj-values") &&argc==1+CONFIG_OOM_COUNT) {
if (updateOOMScoreAdjValues(&argv[1], &err, 0) ==C_ERR) goto loaderr;
 } elseif (!strcasecmp(argv[0],"notify-keyspace-events") &&argc==2) {
intflags=keyspaceEventsStringToFlags(argv[1]);

if (flags==-1) {
err="Invalid event class character. Use 'g$lshzxeA'.";
 goto loaderr;
 }
server.notify_keyspace_events=flags;
 } elseif (!strcasecmp(argv[0],"user") &&argc >= 2) {
intargc_err;
if (ACLAppendUserForLoading(argv,argc,&argc_err) ==C_ERR) {
charbuf[1024];
constchar*errmsg=ACLSetUserStringError();
snprintf(buf,sizeof(buf),"Error in user declaration '%s': %s",
argv[argc_err],errmsg);
err=buf;
 goto loaderr;
 }
 } elseif (!strcasecmp(argv[0],"loadmodule") &&argc >= 2) {
queueLoadModule(argv[1],&argv[2],argc-2);
 } elseif (!strcasecmp(argv[0],"sentinel")) {
/* argc == 1 is handled by main() as we need to enter the sentinel
 * mode ASAP. */
if (argc!=1) {
if (!server.sentinel_mode) {
err="sentinel directive while not in sentinel mode";
 goto loaderr;
 }
queueSentinelConfig(argv+1,argc-1,linenum,lines[i]);
 }
 } else {
err="Bad directive or wrong number of arguments"; goto loaderr;
 }
sdsfreesplitres(argv,argc);
 }

/* Sanity checks. */
if (server.cluster_enabled&&server.masterhost) {
linenum=slaveof_linenum;
i=linenum-1;
err="replicaof directive not allowed in cluster mode";
 goto loaderr;
 }

/* To ensure backward compatibility and work while hz is out of range */
if (server.config_hz<CONFIG_MIN_HZ) server.config_hz=CONFIG_MIN_HZ;
if (server.config_hz>CONFIG_MAX_HZ) server.config_hz=CONFIG_MAX_HZ;

sdsfreesplitres(lines,totlines);
return;

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

/* Load the server configuration from the specified filename.
 * The function appends the additional configuration directives stored
 * in the 'options' string to the config file before loading.
 *
 * Both filename and options can be NULL, in such a case are considered
 * empty. This way loadServerConfig can be used to just load a file or
 * just load a string. */
voidloadServerConfig(char*filename, charconfig_from_stdin, char*options) {
sdsconfig=sdsempty();
charbuf[CONFIG_MAX_LINE+1];
FILE*fp;

/* Load the file content */
if (filename) {
if ((fp=fopen(filename,"r")) ==NULL) {
serverLog(LL_WARNING,
"Fatal error, can't open config file '%s': %s",
filename, strerror(errno));
exit(1);
 }
while(fgets(buf,CONFIG_MAX_LINE+1,fp) !=NULL)
config=sdscat(config,buf);
fclose(fp);
 }
/* Append content from stdin */
if (config_from_stdin) {
serverLog(LL_WARNING,"Reading config from stdin");
fp=stdin;
while(fgets(buf,CONFIG_MAX_LINE+1,fp) !=NULL)
config=sdscat(config,buf);
 }

/* Append the additional options */
if (options) {
config=sdscat(config,"\n");
config=sdscat(config,options);
 }
loadServerConfigFromString(config);
sdsfree(config);
}

/*-----------------------------------------------------------------------------
 * CONFIG SET implementation
 *----------------------------------------------------------------------------*/

#defineconfig_set_bool_field(_name,_var) \
 } else if (!strcasecmp(c->argv[2]->ptr,_name)) { \
 int yn = yesnotoi(o->ptr); \
 if (yn == -1) goto badfmt; \
 _var = yn;

#defineconfig_set_numerical_field(_name,_var,min,max) \
 } else if (!strcasecmp(c->argv[2]->ptr,_name)) { \
 if (getLongLongFromObject(o,&ll) == C_ERR) goto badfmt; \
 if (min != LLONG_MIN && ll < min) goto badfmt; \
 if (max != LLONG_MAX && ll > max) goto badfmt; \
 _var = ll;

#defineconfig_set_memory_field(_name,_var) \
 } else if (!strcasecmp(c->argv[2]->ptr,_name)) { \
 ll = memtoll(o->ptr,&err); \
 if (err || ll < 0) goto badfmt; \
 _var = ll;

#defineconfig_set_special_field(_name) \
 } else if (!strcasecmp(c->argv[2]->ptr,_name)) {

#defineconfig_set_special_field_with_alias(_name1,_name2) \
 } else if (!strcasecmp(c->argv[2]->ptr,_name1) || \
 !strcasecmp(c->argv[2]->ptr,_name2)) {

#defineconfig_set_else } else

voidconfigSetCommand(client*c) {
robj*o;
long longll;
interr;
constchar*errstr=NULL;
serverAssertWithInfo(c,c->argv[2],sdsEncodedObject(c->argv[2]));
serverAssertWithInfo(c,c->argv[3],sdsEncodedObject(c->argv[3]));
o=c->argv[3];

/* Iterate the configs that are standard */
for (standardConfig*config=configs; config->name!=NULL; config++) {
if (!(config->flags&IMMUTABLE_CONFIG) &&
 (!strcasecmp(c->argv[2]->ptr,config->name) ||
 (config->alias&& !strcasecmp(c->argv[2]->ptr,config->alias))))
 {
if (config->flags&SENSITIVE_CONFIG) {
redactClientCommandArgument(c,3);
 }
if (!config->interface.set(config->data,o->ptr,1,&errstr)) {
 goto badfmt;
 }
addReply(c,shared.ok);
return;
 }
 }

if (0) { /* this starts the config_set macros else-if chain. */

/* Special fields that can't be handled with general macros. */
config_set_special_field("bind") {
intvlen;
sds*v=sdssplitlen(o->ptr,sdslen(o->ptr)," ",1,&vlen);

if (vlen<1||vlen>CONFIG_BINDADDR_MAX) {
addReplyError(c, "Too many bind addresses specified.");
sdsfreesplitres(v, vlen);
return;
 }

if (changeBindAddr(v, vlen) ==C_ERR) {
addReplyError(c, "Failed to bind to specified addresses.");
sdsfreesplitres(v, vlen);
return;
 }
sdsfreesplitres(v, vlen);
 } config_set_special_field("save") {
intvlen, 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;
longval;

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_tseconds;
intchanges;

seconds=strtoll(v[j],NULL,10);
changes=strtoll(v[j+1],NULL,10);
appendServerSaveParams(seconds, changes);
 }
sdsfreesplitres(v,vlen);
 } config_set_special_field("dir") {
if (chdir((char*)o->ptr) ==-1) {
addReplyErrorFormat(c,"Changing directory: %s", strerror(errno));
return;
 }
 } config_set_special_field("client-output-buffer-limit") {
intvlen, j;
sds*v=sdssplitlen(o->ptr,sdslen(o->ptr)," ",1,&vlen);

/* We need a multiple of 4: <class> <hard> <soft> <soft_seconds> */
if (vlen % 4) {
sdsfreesplitres(v,vlen);
 goto badfmt;
 }

/* Sanity check of single arguments, so that we either refuse the
 * whole configuration string or accept it all, even if a single
 * error in a single client class is present. */
for (j=0; j<vlen; j++) {
longval;

if ((j % 4) ==0) {
intclass=getClientTypeByName(v[j]);
if (class==-1||class==CLIENT_TYPE_MASTER) {
sdsfreesplitres(v,vlen);
 goto badfmt;
 }
 } else {
val=memtoll(v[j], &err);
if (err||val<0) {
sdsfreesplitres(v,vlen);
 goto badfmt;
 }
 }
 }
/* Finally set the new config */
for (j=0; j<vlen; j+=4) {
intclass;
unsigned long longhard, soft;
intsoft_seconds;

class=getClientTypeByName(v[j]);
hard=memtoll(v[j+1],NULL);
soft=memtoll(v[j+2],NULL);
soft_seconds=strtoll(v[j+3],NULL,10);

server.client_obuf_limits[class].hard_limit_bytes=hard;
server.client_obuf_limits[class].soft_limit_bytes=soft;
server.client_obuf_limits[class].soft_limit_seconds=soft_seconds;
 }
sdsfreesplitres(v,vlen);
 } config_set_special_field("oom-score-adj-values") {
intvlen;
intsuccess=1;

sds*v=sdssplitlen(o->ptr, sdslen(o->ptr), " ", 1, &vlen);
if (vlen!=CONFIG_OOM_COUNT||updateOOMScoreAdjValues(v, &errstr, 1) ==C_ERR)
success=0;

sdsfreesplitres(v, vlen);
if (!success)
 goto badfmt;
 } config_set_special_field("notify-keyspace-events") {
intflags=keyspaceEventsStringToFlags(o->ptr);

if (flags==-1) goto badfmt;
server.notify_keyspace_events=flags;
/* Numerical fields.
 * config_set_numerical_field(name,var,min,max) */
 } config_set_numerical_field(
"watchdog-period",ll,0,INT_MAX) {
if (ll)
enableWatchdog(ll);
else
disableWatchdog();
/* Everything else is an error... */
 } config_set_else {
addReplyErrorFormat(c,"Unsupported CONFIG parameter: %s",
 (char*)c->argv[2]->ptr);
return;
 }

/* On success we just return a generic OK for all the options. */
addReply(c,shared.ok);
return;

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

/*-----------------------------------------------------------------------------
 * CONFIG GET implementation
 *----------------------------------------------------------------------------*/

#defineconfig_get_string_field(_name,_var) do { \
 if (stringmatch(pattern,_name,1)) { \
 addReplyBulkCString(c,_name); \
 addReplyBulkCString(c,_var ? _var : ""); \
 matches++; \
 } \
} while(0)

#defineconfig_get_bool_field(_name,_var) do { \
 if (stringmatch(pattern,_name,1)) { \
 addReplyBulkCString(c,_name); \
 addReplyBulkCString(c,_var ? "yes" : "no"); \
 matches++; \
 } \
} while(0)

#defineconfig_get_numerical_field(_name,_var) do { \
 if (stringmatch(pattern,_name,1)) { \
 ll2string(buf,sizeof(buf),_var); \
 addReplyBulkCString(c,_name); \
 addReplyBulkCString(c,buf); \
 matches++; \
 } \
} while(0)

voidconfigGetCommand(client*c) {
robj*o=c->argv[2];
void*replylen=addReplyDeferredLen(c);
char*pattern=o->ptr;
charbuf[128];
intmatches=0;
serverAssertWithInfo(c,o,sdsEncodedObject(o));

/* Iterate the configs that are standard */
for (standardConfig*config=configs; config->name!=NULL; config++) {
if (stringmatch(pattern,config->name,1)) {
addReplyBulkCString(c,config->name);
config->interface.get(c,config->data);
matches++;
 }
if (config->alias&&stringmatch(pattern,config->alias,1)) {
addReplyBulkCString(c,config->alias);
config->interface.get(c,config->data);
matches++;
 }
 }

/* String values */
config_get_string_field("logfile",server.logfile);

/* Numerical values */
config_get_numerical_field("watchdog-period",server.watchdog_period);

/* Everything we can't handle with macros follows. */

if (stringmatch(pattern,"dir",1)) {
charbuf[1024];

if (getcwd(buf,sizeof(buf)) ==NULL)
buf[0] ='\0';

addReplyBulkCString(c,"dir");
addReplyBulkCString(c,buf);
matches++;
 }
if (stringmatch(pattern,"save",1)) {
sdsbuf=sdsempty();
intj;

for (j=0; j<server.saveparamslen; j++) {
buf=sdscatprintf(buf,"%jd %d",
 (intmax_t)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,"client-output-buffer-limit",1)) {
sdsbuf=sdsempty();
intj;

for (j=0; j<CLIENT_TYPE_OBUF_COUNT; j++) {
buf=sdscatprintf(buf,"%s %llu %llu %ld",
getClientTypeName(j),
server.client_obuf_limits[j].hard_limit_bytes,
server.client_obuf_limits[j].soft_limit_bytes,
 (long) server.client_obuf_limits[j].soft_limit_seconds);
if (j!=CLIENT_TYPE_OBUF_COUNT-1)
buf=sdscatlen(buf," ",1);
 }
addReplyBulkCString(c,"client-output-buffer-limit");
addReplyBulkCString(c,buf);
sdsfree(buf);
matches++;
 }
if (stringmatch(pattern,"unixsocketperm",1)) {
charbuf[32];
snprintf(buf,sizeof(buf),"%lo",(unsigned long) server.unixsocketperm);
addReplyBulkCString(c,"unixsocketperm");
addReplyBulkCString(c,buf);
matches++;
 }