nihilist/tor
1
0
Fork 0
mirror of https://gitlab.torproject.org/tpo/core/tor.git synced 2024-11-28 06:13:31 +01:00
Code Issues Packages Projects Releases Wiki Activity

Support code for resettable options, and option sets. Still needs validate-and-then-replace logic

Browse Source 
svn:r2679
This commit is contained in:
Nick Mathewson 2004-11-04 22:31:50 +00:00
parent d9e0f3f9bc
commit 1b49198081
2 changed files with 192 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

183
src/or/config.c
View File

@ -23,6 +23,11 @@ typedef enum config_type_t {
CONFIG_TYPE_CSV, /**< A list of strings, separated by commas and optional
* whitespace. */
CONFIG_TYPE_LINELIST, /**< Uninterpreted config lines */
CONFIG_TYPE_LINELIST_S, /**< Uninterpreted, context-sensitive config lines,
* mixed with other keywords. */
CONFIG_TYPE_LINELIST_V, /**< Catch-all "virtual" option to summarize
* context-sensitive config lines when fetching.
*/
CONFIG_TYPE_OBSOLETE, /**< Obsolete (ignored) option. */
} config_type_t;
@ -106,14 +111,16 @@ static config_var_t config_vars[] = {
VAR("Group", STRING, Group, NULL),
VAR("HashedControlPassword",STRING, HashedControlPassword, NULL),
VAR("HttpProxy", STRING, HttpProxy, NULL),
VAR("HiddenServiceDir", LINELIST, RendConfigLines, NULL),
VAR("HiddenServicePort", LINELIST, RendConfigLines, NULL),
VAR("HiddenServiceNodes", LINELIST, RendConfigLines, NULL),
VAR("HiddenServiceExcludeNodes", LINELIST, RendConfigLines,NULL),
VAR("HiddenServiceOptions",LINELIST_V, RendConfigLines, NULL),
VAR("HiddenServiceDir", LINELIST_S, RendConfigLines, NULL),
VAR("HiddenServicePort", LINELIST_S, RendConfigLines, NULL),
VAR("HiddenServiceNodes", LINELIST_S, RendConfigLines, NULL),
VAR("HiddenServiceExcludeNodes", LINELIST_S, RendConfigLines, NULL),
VAR("IgnoreVersion", BOOL, IgnoreVersion, "0"),
VAR("KeepalivePeriod", UINT, KeepalivePeriod, "300"),
VAR("LogLevel", LINELIST, LogOptions, NULL),
VAR("LogFile", LINELIST, LogOptions, NULL),
VAR("LogOptions", LINELIST_V, LogOptions, NULL),
VAR("LogLevel", LINELIST_S, LogOptions, NULL),
VAR("LogFile", LINELIST_S, LogOptions, NULL),
OBSOLETE("LinkPadding"),
VAR("MaxConn", UINT, MaxConn, "1024"),
VAR("MaxOnionsPending", UINT, MaxOnionsPending, "100"),
@ -137,7 +144,7 @@ static config_var_t config_vars[] = {
VAR("SocksPort", UINT, SocksPort, "9050"),
VAR("SocksBindAddress", LINELIST, SocksBindAddress, NULL),
VAR("SocksPolicy", LINELIST, SocksPolicy, NULL),
VAR("SysLog", LINELIST, LogOptions, NULL),
VAR("SysLog", LINELIST_S, LogOptions, NULL),
OBSOLETE("TrafficShaping"),
VAR("User", STRING, User, NULL),
{ NULL, CONFIG_TYPE_OBSOLETE, 0, NULL }
@ -151,13 +158,16 @@ static config_var_t config_vars[] = {
static struct config_line_t *config_get_commandlines(int argc, char **argv);
static int config_get_lines(FILE *f, struct config_line_t **result);
static void config_free_lines(struct config_line_t *front);
static int config_assign_line(or_options_t *options, struct config_line_t *c);
static int config_assign(or_options_t *options, struct config_line_t *list);
static int config_assign_line(or_options_t *options, struct config_line_t *c,
int reset);
static int config_assign(or_options_t *options, struct config_line_t *list,
int reset);
static int parse_dir_server_line(const char *line);
static int parse_redirect_line(or_options_t *options,
struct config_line_t *line);
static const char *expand_abbrev(const char *option, int commandline_only);
static config_var_t *config_find_option(const char *key);
static void reset_option(or_options_t *options, config_var_t *var);
/** If <b>option</b> is an official abbreviation for a longer option,
* return the longer option. Otherwise return <b>option</b>.
@ -216,7 +226,7 @@ config_get_commandlines(int argc, char **argv)
/** Helper: allocate a new configuration option mapping 'key' to 'val',
* prepend it to 'front', and return the newly allocated config_line_t */
static struct config_line_t *
struct config_line_t *
config_line_prepend(struct config_line_t *front,
const char *key,
const char *val)
@ -298,9 +308,13 @@ static config_var_t *config_find_option(const char *key)
}
/** If <b>c</b> is a syntactically valid configuration line, update
* <b>options</b> with its value and return 0. Otherwise return -1. */
* <b>options</b> with its value and return 0. Otherwise return -1.
*
* If 'reset' is set, and we get a line containing no value, restore the
* option to its default value.
*/
static int
config_assign_line(or_options_t *options, struct config_line_t *c)
config_assign_line(or_options_t *options, struct config_line_t *c, int reset)
{
int i, ok;
config_var_t *var;
@ -311,13 +325,17 @@ config_assign_line(or_options_t *options, struct config_line_t *c)
log_fn(LOG_WARN, "Unknown option '%s'. Failing.", c->key);
return -1;
}
/* Put keyword into canonical case. */
if (strcmp(var->name, c->key)) {
tor_free(c->key);
c->key = tor_strdup(var->name);
}
if (reset && !strlen(c->value)) {
reset_option(options, var);
return 0;
}
lvalue = ((char*)options) + var->var_offset;
switch(var->type) {
@ -357,22 +375,43 @@ config_assign_line(or_options_t *options, struct config_line_t *c)
SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
break;
case CONFIG_TYPE_LINELIST:
/* Note: this reverses the order that the lines appear in. That's
* just fine, since we build up the list of lines reversed in the
* first place. */
*(struct config_line_t**)lvalue =
config_line_prepend(*(struct config_line_t**)lvalue, c->key, c->value);
break;
case CONFIG_TYPE_LINELIST:
case CONFIG_TYPE_LINELIST_S:
/* Note: this reverses the order that the lines appear in. That's
* just fine, since we build up the list of lines reversed in the
* first place. */
*(struct config_line_t**)lvalue =
config_line_prepend(*(struct config_line_t**)lvalue, c->key, c->value);
break;
case CONFIG_TYPE_OBSOLETE:
log_fn(LOG_WARN, "Skipping obsolete configuration option '%s'", c->key);
break;
case CONFIG_TYPE_LINELIST_V:
log_fn(LOG_WARN, "Can't provide value for virtual option '%s'", c->key);
return -1;
default:
tor_assert(0);
break;
}
return 0;
}
/** restore the option named <b>key</b> in options to its default value. */
static void
config_reset_line(or_options_t *options, const char *key)
{
config_var_t *var;
var = config_find_option(key);
if (!var)
return; /* give error on next pass. */
reset_option(options, var);
}
/** Return a canonicalized list of the options assigned for key.
*/
struct config_line_t *
@ -387,10 +426,14 @@ config_get_assigned_option(or_options_t *options, const char *key)
if (!var) {
log_fn(LOG_WARN, "Unknown option '%s'. Failing.", key);
return NULL;
} else if (var->type == CONFIG_TYPE_LINELIST_S) {
log_fn(LOG_WARN, "Can't return context-sensitive '%s' on its own", key);
return NULL;
}
value = ((char*)options) + var->var_offset;
if (var->type == CONFIG_TYPE_LINELIST) {
if (var->type == CONFIG_TYPE_LINELIST ||
var->type == CONFIG_TYPE_LINELIST_V) {
/* Linelist requires special handling: we just copy and return it. */
const struct config_line_t *next_in = value;
struct config_line_t **next_out = &result;
@ -442,18 +485,36 @@ config_get_assigned_option(or_options_t *options, const char *key)
/** Iterate through the linked list of requested options <b>list</b>.
* For each item, convert as appropriate and assign to <b>options</b>.
* If an item is unrecognized, return -1 immediately,
* else return 0 for success. */
* else return 0 for success.
*
* If <b>reset</b>, then interpret empty lines as meaning "restore to
* default value", and interpret LINELIST* options as replacing (not
* extending) their previous values.
*/
static int
config_assign(or_options_t *options, struct config_line_t *list)
config_assign(or_options_t *options, struct config_line_t *list, int reset)
{
while (list) {
const char *full = expand_abbrev(list->key, 0);
if (strcmp(full,list->key)) {
tor_free(list->key);
list->key = tor_strdup(full);
}
struct config_line_t *p;
if (config_assign_line(options, list))
/* pass 1: normalize keys */
for (p = list; p; p = p->next) {
const char *full = expand_abbrev(p->key, 0);
if (strcmp(full,p->key)) {
tor_free(p->key);
p->key = tor_strdup(full);
}
}
/* pass 2: if we're reading from a resetting souurce, clear all mentioned
* linelists. */
if (reset) {
for (p = list; p; p = p->next)
config_reset_line(options, p->key);
}
/* pass 3: assign. */
while (list) {
if (config_assign_line(options, list, reset))
return -1;
list = list->next;
}
@ -604,6 +665,7 @@ free_options(or_options_t *options)
tor_free(*(char **)lvalue);
break;
case CONFIG_TYPE_LINELIST:
case CONFIG_TYPE_LINELIST_V:
config_free_lines(*(struct config_line_t**)lvalue);
*(struct config_line_t**)lvalue = NULL;
break;
@ -614,6 +676,9 @@ free_options(or_options_t *options)
*(smartlist_t**)lvalue = NULL;
}
break;
case CONFIG_TYPE_LINELIST_S:
/* will be freed by corresponding LINELIST_V. */
break;
}
}
/* XXX this last part is an exception. can we make it not needed? */
@ -625,13 +690,59 @@ free_options(or_options_t *options)
}
}
/** Replace the option indexed by <b>var</b> in <b>options</b> with its
* default value. */
static void
reset_option(or_options_t *options, config_var_t *var)
{
struct config_line_t *c;
void *lvalue;
lvalue = ((char*)options) + var->var_offset;
switch (var->type) {
case CONFIG_TYPE_STRING:
tor_free(*(char**)lvalue);
break;
case CONFIG_TYPE_DOUBLE:
*(double*)lvalue = 0.0;
break;
case CONFIG_TYPE_UINT:
case CONFIG_TYPE_BOOL:
*(int*)lvalue = 0;
break;
case CONFIG_TYPE_CSV:
if (*(smartlist_t**)lvalue) {
SMARTLIST_FOREACH(*(smartlist_t **)lvalue, char *, cp, tor_free(cp));
smartlist_free(*(smartlist_t **)lvalue);
*(smartlist_t **)lvalue = NULL;
}
break;
case CONFIG_TYPE_LINELIST:
case CONFIG_TYPE_LINELIST_S:
config_free_lines(*(struct config_line_t **)lvalue);
*(struct config_line_t **)lvalue = NULL;
break;
case CONFIG_TYPE_LINELIST_V:
/* handled by linelist_s. */
break;
case CONFIG_TYPE_OBSOLETE:
break;
}
if (var->initvalue) {
c = tor_malloc(sizeof(struct config_line_t));
c->key = tor_strdup(var->name);
c->value = tor_strdup(var->initvalue);
config_assign_line(options,c,0);
config_free_lines(c);
}
}
/** Set <b>options</b> to hold reasonable defaults for most options.
* Each option defaults to zero. */
static void
init_options(or_options_t *options)
{
int i;
struct config_line_t *c;
config_var_t *var;
memset(options,0,sizeof(or_options_t));
@ -639,11 +750,7 @@ init_options(or_options_t *options)
var = &config_vars[i];
if(!var->initvalue)
continue; /* defaults to NULL or 0 */
c = tor_malloc(sizeof(struct config_line_t));
c->key = tor_strdup(var->name);
c->value = tor_strdup(var->initvalue);
config_assign_line(options,c);
config_free_lines(c);
reset_option(options, var);
}
}
@ -1048,7 +1155,7 @@ getconfig(int argc, char **argv, or_options_t *options)
tor_free(fname);
if (config_get_lines(cf, &cl)<0)
return -1;
if (config_assign(options,cl) < 0)
if (config_assign(options,cl, 0) < 0)
return -1;
config_free_lines(cl);
fclose(cf);
@ -1056,7 +1163,7 @@ getconfig(int argc, char **argv, or_options_t *options)
/* go through command-line variables too */
cl = config_get_commandlines(argc,argv);
if (config_assign(options,cl) < 0)
if (config_assign(options,cl,0) < 0)
return -1;
config_free_lines(cl);

70
src/or/control.c
View File

@ -59,7 +59,7 @@ static void send_control_error(connection_t *conn, uint16_t error,
const char *message);
static void send_control_event(uint16_t event, uint16_t len, const char *body);
static int handle_control_setconf(connection_t *conn, uint16_t len,
const char *body);
char *body);
static int handle_control_getconf(connection_t *conn, uint16_t len,
const char *body);
static int handle_control_setevents(connection_t *conn, uint16_t len,
@ -139,58 +139,81 @@ send_control_event(uint16_t event, uint16_t len, const char *body)
static int
handle_control_setconf(connection_t *conn, uint16_t len,
const char *body)
char *body)
{
char *k, *v;
struct config_line_t *lines = NULL;
/* XXXX009 move this logic into config.c someplace. */
do {
body = parse_line_from_str(body, &k, &v);
if (!body) {
goto err;
}
if (k && v)
lines = config_line_prepend(lines, k, v);
} while (*body);
/* XXXX009 NM */
return 0;
err:
send_control_error(conn, ERR_UNSPECIFIED, "Couldn't parse configuration");
/* config_free_lines(lines); */
return 0;
}
static int handle_control_getconf(connection_t *conn, uint16_t body_len,
static int
handle_control_getconf(connection_t *conn, uint16_t body_len,
const char *body)
{
smartlist_t *answer_elements = NULL;
smartlist_t *questions = NULL;
smartlist_t *answers = NULL;
char *msg = NULL;
size_t msg_len;
if (body[body_len-1] != '\0') {
send_control_error(conn, ERR_UNSPECIFIED,
"getconf message body not nul-terminated.");
return 0;
}
/* Now we can be sure that body will end in a nul-terminated string. */
answer_elements = smartlist_create();
while (body_len) {
size_t question_len = strlen(body);
struct config_line_t *answer = config_get_assigned_option(&options,body);
questions = smartlist_create();
smartlist_split_string(questions, body, "\n",
SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
answers = smartlist_create();
SMARTLIST_FOREACH(questions, const char *, q,
{
struct config_line_t *answer = config_get_assigned_option(&options,q);
if (!answer) {
send_control_error(conn, ERR_UNRECOGNIZED_CONFIG_KEY, body);
goto done;
} else {
while (answer) {
struct config_line_t *next;
smartlist_add(answer_elements, answer->key);
smartlist_add(answer_elements, answer->value);
size_t alen = strlen(answer->key)+strlen(answer->value)+2;
char *astr = tor_malloc(alen);
tor_snprintf(astr, alen, "%s %s\n", answer->key, answer->value);
smartlist_add(answers, astr);
next = answer->next;
tor_free(answer->key);
tor_free(answer->value);
tor_free(answer);
answer = next;
}
}
body += question_len+1;
body_len -= question_len+1;
}
});
msg = smartlist_join_strings2(answer_elements, "\0", 1, 0, &msg_len);
msg = smartlist_join_strings(answers, "", 0, &msg_len);
send_control_message(conn, CONTROL_CMD_CONFVALUE,
(uint16_t)msg_len, msg);
done:
SMARTLIST_FOREACH(answer_elements, char *, cp, tor_free(cp));
smartlist_free(answer_elements);
if (answers) SMARTLIST_FOREACH(answers, char *, cp, tor_free(cp));
if (questions) SMARTLIST_FOREACH(questions, char *, cp, tor_free(cp));
smartlist_free(answers);
smartlist_free(questions);
tor_free(msg);
return 0;
}
static int handle_control_setevents(connection_t *conn, uint16_t len,
const char *body)
{
@ -218,6 +241,7 @@ static int handle_control_setevents(connection_t *conn, uint16_t len,
send_control_done(conn);
return 0;
}
static int handle_control_authenticate(connection_t *conn, uint16_t len,
const char *body)
{