Tor  0.4.4.0-alpha-dev
confline.c
Go to the documentation of this file.
1 /* Copyright (c) 2001 Matej Pfajfar.
2  * Copyright (c) 2001-2004, Roger Dingledine.
3  * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
4  * Copyright (c) 2007-2020, The Tor Project, Inc. */
5 /* See LICENSE for licensing information */
6 
7 /**
8  * \file confline.c
9  *
10  * \brief Functions to manipulate a linked list of key-value pairs, of the
11  * type used in Tor's configuration files.
12  *
13  * Tor uses the config_line_t type and its associated serialized format for
14  * human-readable key-value pairs in many places, including its configuration,
15  * its state files, its consensus cache, and so on.
16  **/
17 
18 #include "lib/encoding/confline.h"
19 #include "lib/encoding/cstring.h"
20 #include "lib/log/log.h"
21 #include "lib/log/util_bug.h"
22 #include "lib/malloc/malloc.h"
25 #include "lib/string/util_string.h"
26 
27 #include <string.h>
28 
29 /** Helper: allocate a new configuration option mapping 'key' to 'val',
30  * append it to *<b>lst</b>. */
31 void
33  const char *key,
34  const char *val)
35 {
36  tor_assert(lst);
37 
38  config_line_t *newline;
39 
40  newline = tor_malloc_zero(sizeof(config_line_t));
41  newline->key = tor_strdup(key);
42  newline->value = tor_strdup(val);
43  newline->next = NULL;
44  while (*lst)
45  lst = &((*lst)->next);
46 
47  (*lst) = newline;
48 }
49 
50 /** Helper: allocate a new configuration option mapping 'key' to 'val',
51  * and prepend it to *<b>lst</b> */
52 void
54  const char *key,
55  const char *val)
56 {
57  tor_assert(lst);
58 
59  config_line_t *newline;
60 
61  newline = tor_malloc_zero(sizeof(config_line_t));
62  newline->key = tor_strdup(key);
63  newline->value = tor_strdup(val);
64  newline->next = *lst;
65  *lst = newline;
66 }
67 
68 /** Return the first line in <b>lines</b> whose key is exactly <b>key</b>, or
69  * NULL if no such key exists.
70  *
71  * (In options parsing, this is for handling commandline-only options only;
72  * other options should be looked up in the appropriate data structure.) */
73 const config_line_t *
75  const char *key)
76 {
77  const config_line_t *cl;
78  for (cl = lines; cl; cl = cl->next) {
79  if (!strcmp(cl->key, key))
80  return cl;
81  }
82  return NULL;
83 }
84 
85 /** As config_line_find(), but perform a case-insensitive comparison. */
86 const config_line_t *
88  const char *key)
89 {
90  const config_line_t *cl;
91  for (cl = lines; cl; cl = cl->next) {
92  if (!strcasecmp(cl->key, key))
93  return cl;
94  }
95  return NULL;
96 }
97 
98 /** Auxiliary function that does all the work of config_get_lines.
99  * <b>recursion_level</b> is the count of how many nested %includes we have.
100  * <b>opened_lst</b> will have a list of opened files if provided.
101  * Returns the a pointer to the last element of the <b>result</b> in
102  * <b>last</b>. */
103 int
104 config_get_lines_aux(const char *string, config_line_t **result, int extended,
105  int allow_include, int *has_include,
106  struct smartlist_t *opened_lst, int recursion_level,
107  config_line_t **last,
108  include_handler_fn handle_include)
109 {
110  config_line_t *list = NULL, **next, *list_last = NULL;
111  char *k, *v;
112  const char *parse_err;
113  int include_used = 0;
114 
115  if (recursion_level > MAX_INCLUDE_RECURSION_LEVEL) {
116  log_warn(LD_CONFIG, "Error while parsing configuration: more than %d "
117  "nested %%includes.", MAX_INCLUDE_RECURSION_LEVEL);
118  return -1;
119  }
120 
121  next = &list;
122  do {
123  k = v = NULL;
124  string = parse_config_line_from_str_verbose(string, &k, &v, &parse_err);
125  if (!string) {
126  log_warn(LD_CONFIG, "Error while parsing configuration: %s",
127  parse_err?parse_err:"<unknown>");
128  config_free_lines(list);
129  tor_free(k);
130  tor_free(v);
131  return -1;
132  }
133  if (k && v) {
134  unsigned command = CONFIG_LINE_NORMAL;
135  if (extended) {
136  if (k[0] == '+') {
137  char *k_new = tor_strdup(k+1);
138  tor_free(k);
139  k = k_new;
141  } else if (k[0] == '/') {
142  char *k_new = tor_strdup(k+1);
143  tor_free(k);
144  k = k_new;
145  tor_free(v);
146  v = tor_strdup("");
147  command = CONFIG_LINE_CLEAR;
148  }
149  }
150 
151  if (allow_include && !strcmp(k, "%include") && handle_include) {
152  tor_free(k);
153  include_used = 1;
154 
155  config_line_t *include_list;
156  if (handle_include(v, recursion_level, extended, &include_list,
157  &list_last, opened_lst) < 0) {
158  log_warn(LD_CONFIG, "Error reading included configuration "
159  "file or directory: \"%s\".", v);
160  config_free_lines(list);
161  tor_free(v);
162  return -1;
163  }
164  log_notice(LD_CONFIG, "Included configuration file or "
165  "directory at recursion level %d: \"%s\".",
166  recursion_level, v);
167  *next = include_list;
168  if (list_last)
169  next = &list_last->next;
170  tor_free(v);
171  } else {
172  /* This list can get long, so we keep a pointer to the end of it
173  * rather than using config_line_append over and over and getting
174  * n^2 performance. */
175  *next = tor_malloc_zero(sizeof(**next));
176  (*next)->key = k;
177  (*next)->value = v;
178  (*next)->next = NULL;
179  (*next)->command = command;
180  list_last = *next;
181  next = &((*next)->next);
182  }
183  } else {
184  tor_free(k);
185  tor_free(v);
186  }
187  } while (*string);
188 
189  if (last) {
190  *last = list_last;
191  }
192  if (has_include) {
193  *has_include = include_used;
194  }
195  *result = list;
196  return 0;
197 }
198 
199 /** Same as config_get_lines_include but does not allow %include */
200 int
201 config_get_lines(const char *string, config_line_t **result, int extended)
202 {
203  return config_get_lines_aux(string, result, extended, 0, NULL, NULL, 1,
204  NULL, NULL);
205 }
206 
207 /**
208  * Free all the configuration lines on the linked list <b>front</b>.
209  */
210 void
212 {
213  config_line_t *tmp;
214 
215  while (front) {
216  tmp = front;
217  front = tmp->next;
218 
219  tor_free(tmp->key);
220  tor_free(tmp->value);
221  tor_free(tmp);
222  }
223 }
224 
225 /** Return a newly allocated deep copy of the lines in <b>inp</b>. */
228 {
229  return config_lines_dup_and_filter(inp, NULL);
230 }
231 
232 /** Return a newly allocated deep copy of the lines in <b>inp</b>,
233  * but only the ones whose keys begin with <b>key</b> (case-insensitive).
234  * If <b>key</b> is NULL, do not filter. */
237  const char *key)
238 {
239  config_line_t *result = NULL;
240  config_line_t **next_out = &result;
241  while (inp) {
242  if (key && strcasecmpstart(inp->key, key)) {
243  inp = inp->next;
244  continue;
245  }
246  *next_out = tor_malloc_zero(sizeof(config_line_t));
247  (*next_out)->key = tor_strdup(inp->key);
248  (*next_out)->value = tor_strdup(inp->value);
249  inp = inp->next;
250  next_out = &((*next_out)->next);
251  }
252  (*next_out) = NULL;
253  return result;
254 }
255 
256 /**
257  * Given a linelist <b>inp</b> beginning with the key <b>header</b>, find the
258  * next line with that key, and remove that instance and all following lines
259  * from the list. Return the lines that were removed. Operate
260  * case-insensitively.
261  *
262  * For example, if the header is "H", and <b>inp</b> contains "H, A, B, H, C,
263  * H, D", this function will alter <b>inp</b> to contain only "H, A, B", and
264  * return the elements "H, C, H, D" as a separate list.
265  **/
267 config_lines_partition(config_line_t *inp, const char *header)
268 {
269  if (BUG(inp == NULL))
270  return NULL;
271  if (BUG(strcasecmp(inp->key, header)))
272  return NULL;
273 
274  /* Advance ptr until it points to the link to the next segment of this
275  list. */
276  config_line_t **ptr = &inp->next;
277  while (*ptr && strcasecmp((*ptr)->key, header)) {
278  ptr = &(*ptr)->next;
279  }
280  config_line_t *remainder = *ptr;
281  *ptr = NULL;
282  return remainder;
283 }
284 
285 /** Return true iff a and b contain identical keys and values in identical
286  * order. */
287 int
289 {
290  while (a && b) {
291  if (strcasecmp(a->key, b->key) || strcmp(a->value, b->value))
292  return 0;
293  a = a->next;
294  b = b->next;
295  }
296  if (a || b)
297  return 0;
298  return 1;
299 }
300 
301 /** Return the number of lines in <b>a</b> whose key is <b>key</b>. */
302 int
303 config_count_key(const config_line_t *a, const char *key)
304 {
305  int n = 0;
306  while (a) {
307  if (!strcasecmp(a->key, key)) {
308  ++n;
309  }
310  a = a->next;
311  }
312  return n;
313 }
314 
315 /** Given a string containing part of a configuration file or similar format,
316  * advance past comments and whitespace and try to parse a single line. If we
317  * parse a line successfully, set *<b>key_out</b> to a new string holding the
318  * key portion and *<b>value_out</b> to a new string holding the value portion
319  * of the line, and return a pointer to the start of the next line. If we run
320  * out of data, return a pointer to the end of the string. If we encounter an
321  * error, return NULL and set *<b>err_out</b> (if provided) to an error
322  * message.
323  */
324 const char *
325 parse_config_line_from_str_verbose(const char *line, char **key_out,
326  char **value_out,
327  const char **err_out)
328 {
329  /*
330  See torrc_format.txt for a description of the (silly) format this parses.
331  */
332  const char *key, *val, *cp;
333  int continuation = 0;
334 
335  tor_assert(key_out);
336  tor_assert(value_out);
337 
338  *key_out = *value_out = NULL;
339  key = val = NULL;
340  /* Skip until the first keyword. */
341  while (1) {
342  while (TOR_ISSPACE(*line))
343  ++line;
344  if (*line == '#') {
345  while (*line && *line != '\n')
346  ++line;
347  } else {
348  break;
349  }
350  }
351 
352  if (!*line) { /* End of string? */
353  *key_out = *value_out = NULL;
354  return line;
355  }
356 
357  /* Skip until the next space or \ followed by newline. */
358  key = line;
359  while (*line && !TOR_ISSPACE(*line) && *line != '#' &&
360  ! (line[0] == '\\' && line[1] == '\n'))
361  ++line;
362  *key_out = tor_strndup(key, line-key);
363 
364  /* Skip until the value. */
365  while (*line == ' ' || *line == '\t')
366  ++line;
367 
368  val = line;
369 
370  /* Find the end of the line. */
371  if (*line == '\"') { // XXX No continuation handling is done here
372  if (!(line = unescape_string(line, value_out, NULL))) {
373  if (err_out)
374  *err_out = "Invalid escape sequence in quoted string";
375  return NULL;
376  }
377  while (*line == ' ' || *line == '\t')
378  ++line;
379  if (*line == '\r' && *(++line) == '\n')
380  ++line;
381  if (*line && *line != '#' && *line != '\n') {
382  if (err_out)
383  *err_out = "Excess data after quoted string";
384  return NULL;
385  }
386  } else {
387  /* Look for the end of the line. */
388  while (*line && *line != '\n' && (*line != '#' || continuation)) {
389  if (*line == '\\' && line[1] == '\n') {
390  continuation = 1;
391  line += 2;
392  } else if (*line == '#') {
393  do {
394  ++line;
395  } while (*line && *line != '\n');
396  if (*line == '\n')
397  ++line;
398  } else {
399  ++line;
400  }
401  }
402 
403  if (*line == '\n') {
404  cp = line++;
405  } else {
406  cp = line;
407  }
408  /* Now back cp up to be the last nonspace character */
409  while (cp>val && TOR_ISSPACE(*(cp-1)))
410  --cp;
411 
412  tor_assert(cp >= val);
413 
414  /* Now copy out and decode the value. */
415  *value_out = tor_strndup(val, cp-val);
416  if (continuation) {
417  char *v_out, *v_in;
418  v_out = v_in = *value_out;
419  while (*v_in) {
420  if (*v_in == '#') {
421  do {
422  ++v_in;
423  } while (*v_in && *v_in != '\n');
424  if (*v_in == '\n')
425  ++v_in;
426  } else if (v_in[0] == '\\' && v_in[1] == '\n') {
427  v_in += 2;
428  } else {
429  *v_out++ = *v_in++;
430  }
431  }
432  *v_out = '\0';
433  }
434  }
435 
436  if (*line == '#') {
437  do {
438  ++line;
439  } while (*line && *line != '\n');
440  }
441  while (TOR_ISSPACE(*line)) ++line;
442 
443  return line;
444 }
Header for confline.c.
const char * parse_config_line_from_str_verbose(const char *line, char **key_out, char **value_out, const char **err_out)
Definition: confline.c:325
Header for cstring.c.
int config_lines_eq(const config_line_t *a, const config_line_t *b)
Definition: confline.c:288
#define CONFIG_LINE_APPEND
Definition: confline.h:22
config_line_t * config_lines_partition(config_line_t *inp, const char *header)
Definition: confline.c:267
#define tor_assert(expr)
Definition: util_bug.h:102
#define tor_free(p)
Definition: malloc.h:52
Header for util_string.c.
const config_line_t * config_line_find_case(const config_line_t *lines, const char *key)
Definition: confline.c:87
int config_count_key(const config_line_t *a, const char *key)
Definition: confline.c:303
Headers for util_malloc.c.
int config_get_lines(const char *string, config_line_t **result, int extended)
Definition: confline.c:201
config_line_t * config_lines_dup_and_filter(const config_line_t *inp, const char *key)
Definition: confline.c:236
int config_get_lines_aux(const char *string, config_line_t **result, int extended, int allow_include, int *has_include, struct smartlist_t *opened_lst, int recursion_level, config_line_t **last, include_handler_fn handle_include)
Definition: confline.c:104
config_line_t * config_lines_dup(const config_line_t *inp)
Definition: confline.c:227
void config_line_prepend(config_line_t **lst, const char *key, const char *val)
Definition: confline.c:53
Locale-independent character-type inspection (header)
const config_line_t * config_line_find(const config_line_t *lines, const char *key)
Definition: confline.c:74
void config_line_append(config_line_t **lst, const char *key, const char *val)
Definition: confline.c:32
Header for compat_string.c.
const char * unescape_string(const char *s, char **result, size_t *size_out)
Definition: cstring.c:30
void config_free_lines_(config_line_t *front)
Definition: confline.c:211
tor_cmdline_mode_t command
Definition: config.c:2444
Headers for log.c.
#define CONFIG_LINE_NORMAL
Definition: confline.h:19
Macros to manage assertions, fatal and non-fatal.
int strcasecmpstart(const char *s1, const char *s2)
Definition: util_string.c:216
#define LD_CONFIG
Definition: log.h:68