conf-parser.c

   1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
   2
   3 #include <string.h>
   4 #include <stdio.h>
   5 #include <errno.h>
   6 #include <assert.h>
   7 #include <stdlib.h>
   8
   9 #include "conf-parser.h"
  10 #include "util.h"
  11 #include "macro.h"
  12 #include "strv.h"
  13 #include "log.h"
  14
  15 #define COMMENTS "#;\n"
  16 #define LINE_MAX 4096
  17
  18 /* Run the user supplied parser for an assignment */
  19 static int next_assignment(
  20                 const char *filename,
  21                 unsigned line,
  22                 const char *section,
  23                 const ConfigItem *t,
  24                 const char *lvalue,
  25                 const char *rvalue,
  26                 void *userdata) {
  27
  28         assert(filename);
  29         assert(t);
  30         assert(lvalue);
  31         assert(rvalue);
  32
  33         for (; t->parse; t++) {
  34
  35                 if (t->lvalue && !streq(lvalue, t->lvalue))
  36                         continue;
  37
  38                 if (t->section && !section)
  39                         continue;
  40
  41                 if (t->section && !streq(section, t->section))
  42                         continue;
  43
  44                 return t->parse(filename, line, section, lvalue, rvalue, t->data, userdata);
  45         }
  46
  47         log_info("[%s:%u] Unknown lvalue '%s' in section '%s'. Ignoring.", filename, line, lvalue, strna(section));
  48         return 0;
  49 }
  50
  51 /* Returns non-zero when c is contained in s */
  52 static int in_string(char c, const char *s) {
  53         assert(s);
  54
  55         for (; *s; s++)
  56                 if (*s == c)
  57                         return 1;
  58
  59         return 0;
  60 }
  61
  62 /* Remove all whitepsapce from the beginning and the end of *s. *s may
  63  * be modified. */
  64 static char *strip(char *s) {
  65         char *b = s+strspn(s, WHITESPACE);
  66         char *e, *l = NULL;
  67
  68         for (e = b; *e; e++)
  69                 if (!in_string(*e, WHITESPACE))
  70                         l = e;
  71
  72         if (l)
  73                 *(l+1) = 0;
  74
  75         return b;
  76 }
  77
  78 /* Parse a variable assignment line */
  79 static int parse_line(const char *filename, unsigned line, char **section, const char* const * sections, const ConfigItem *t, char *l, void *userdata) {
  80         char *e, *c, *b;
  81
  82         b = l+strspn(l, WHITESPACE);
  83
  84         if ((c = strpbrk(b, COMMENTS)))
  85                 *c = 0;
  86
  87         if (!*b)
  88                 return 0;
  89
  90         if (startswith(b, ".include ")) {
  91                 char *path = NULL, *fn;
  92                 int r;
  93
  94                 fn = strip(b+9);
  95                 if (!is_path_absolute(fn)) {
  96                         const char *k;
  97
  98                         if ((k = strrchr(filename, '/'))) {
  99                                 char *dir;
 100
 101                                 if (!(dir = strndup(filename, k-filename)))
 102                                         return -ENOMEM;
 103
 104                                 if (asprintf(&path, "%s/%s", dir, fn) < 0)
 105                                         return -errno;
 106
 107                                 fn = path;
 108                                 free(dir);
 109                         }
 110                 }
 111
 112                 r = config_parse(fn, NULL, sections, t, userdata);
 113                 free(path);
 114                 return r;
 115         }
 116
 117         if (*b == '[') {
 118                 size_t k;
 119                 char *n;
 120
 121                 k = strlen(b);
 122                 assert(k > 0);
 123
 124                 if (b[k-1] != ']') {
 125                         log_error("[%s:%u] Invalid section header.", filename, line);
 126                         return -EBADMSG;
 127                 }
 128
 129                 if (!(n = strndup(b+1, k-2)))
 130                         return -ENOMEM;
 131
 132                 if (sections) {
 133                         const char * const * i;
 134                         bool good = false;
 135                         STRV_FOREACH(i, sections)
 136                                 if (streq(*i, n)) {
 137                                         good = true;
 138                                         break;
 139                                 }
 140
 141                         if (!good) {
 142                                 free(n);
 143                                 return -EBADMSG;
 144                         }
 145                 }
 146
 147                 free(*section);
 148                 *section = n;
 149
 150                 return 0;
 151         }
 152
 153         if (!(e = strchr(b, '='))) {
 154                 log_error("[%s:%u] Missing '='.", filename, line);
 155                 return -EBADMSG;
 156         }
 157
 158         *e = 0;
 159         e++;
 160
 161         return next_assignment(filename, line, *section, t, strip(b), strip(e), userdata);
 162 }
 163
 164 /* Go through the file and parse each line */
 165 int config_parse(const char *filename, FILE *f, const char* const * sections, const ConfigItem *t, void *userdata) {
 166         unsigned line = 0;
 167         char *section = NULL;
 168         int r;
 169
 170         assert(filename);
 171         assert(t);
 172
 173         if (!f) {
 174                 if (!(f = fopen(filename, "re"))) {
 175                         r = -errno;
 176                         log_error("Failed to open configuration file '%s': %s", filename, strerror(-r));
 177                         goto finish;
 178                 }
 179         }
 180
 181         while (!feof(f)) {
 182                 char l[LINE_MAX];
 183
 184                 if (!fgets(l, sizeof(l), f)) {
 185                         if (feof(f))
 186                                 break;
 187
 188                         r = -errno;
 189                         log_error("Failed to read configuration file '%s': %s", filename, strerror(-r));
 190                         goto finish;
 191                 }
 192
 193                 if ((r = parse_line(filename, ++line, &section, sections, t, l, userdata)) < 0)
 194                         goto finish;
 195         }
 196
 197         r = 0;
 198
 199 finish:
 200         free(section);
 201
 202         if (f)
 203                 fclose(f);
 204
 205         return r;
 206 }
 207
 208 int config_parse_int(
 209                 const char *filename,
 210                 unsigned line,
 211                 const char *section,
 212                 const char *lvalue,
 213                 const char *rvalue,
 214                 void *data,
 215                 void *userdata) {
 216
 217         int *i = data;
 218         int r;
 219
 220         assert(filename);
 221         assert(lvalue);
 222         assert(rvalue);
 223         assert(data);
 224
 225         if ((r = safe_atoi(rvalue, i)) < 0) {
 226                 log_error("[%s:%u] Failed to parse numeric value: %s", filename, line, rvalue);
 227                 return r;
 228         }
 229
 230         return 0;
 231 }
 232
 233 int config_parse_unsigned(
 234                 const char *filename,
 235                 unsigned line,
 236                 const char *section,
 237                 const char *lvalue,
 238                 const char *rvalue,
 239                 void *data,
 240                 void *userdata) {
 241
 242         unsigned *u = data;
 243         int r;
 244
 245         assert(filename);
 246         assert(lvalue);
 247         assert(rvalue);
 248         assert(data);
 249
 250         if ((r = safe_atou(rvalue, u)) < 0) {
 251                 log_error("[%s:%u] Failed to parse numeric value: %s", filename, line, rvalue);
 252                 return r;
 253         }
 254
 255         return 0;
 256 }
 257
 258 int config_parse_size(
 259                 const char *filename,
 260                 unsigned line,
 261                 const char *section,
 262                 const char *lvalue,
 263                 const char *rvalue,
 264                 void *data,
 265                 void *userdata) {
 266
 267         size_t *sz = data;
 268         unsigned u;
 269         int r;
 270
 271         assert(filename);
 272         assert(lvalue);
 273         assert(rvalue);
 274         assert(data);
 275
 276         if ((r = safe_atou(rvalue, &u)) < 0) {
 277                 log_error("[%s:%u] Failed to parse numeric value: %s", filename, line, rvalue);
 278                 return r;
 279         }
 280
 281         *sz = (size_t) u;
 282         return 0;
 283 }
 284
 285 int config_parse_bool(
 286                 const char *filename,
 287                 unsigned line,
 288                 const char *section,
 289                 const char *lvalue,
 290                 const char *rvalue,
 291                 void *data,
 292                 void *userdata) {
 293
 294         int k;
 295         bool *b = data;
 296
 297         assert(filename);
 298         assert(lvalue);
 299         assert(rvalue);
 300         assert(data);
 301
 302         if ((k = parse_boolean(rvalue)) < 0) {
 303                 log_error("[%s:%u] Failed to parse boolean value: %s", filename, line, rvalue);
 304                 return k;
 305         }
 306
 307         *b = !!k;
 308         return 0;
 309 }
 310
 311 int config_parse_string(
 312                 const char *filename,
 313                 unsigned line,
 314                 const char *section,
 315                 const char *lvalue,
 316                 const char *rvalue,
 317                 void *data,
 318                 void *userdata) {
 319
 320         char **s = data;
 321         char *n;
 322
 323         assert(filename);
 324         assert(lvalue);
 325         assert(rvalue);
 326         assert(data);
 327
 328         if (*rvalue) {
 329                 if (!(n = strdup(rvalue)))
 330                         return -ENOMEM;
 331         } else
 332                 n = NULL;
 333
 334         free(*s);
 335         *s = n;
 336
 337         return 0;
 338 }
 339
 340 int config_parse_path(
 341                 const char *filename,
 342                 unsigned line,
 343                 const char *section,
 344                 const char *lvalue,
 345                 const char *rvalue,
 346                 void *data,
 347                 void *userdata) {
 348
 349         char **s = data;
 350         char *n;
 351
 352         assert(filename);
 353         assert(lvalue);
 354         assert(rvalue);
 355         assert(data);
 356
 357         if (*rvalue != '/') {
 358                 log_error("[%s:%u] Not an absolute path: %s", filename, line, rvalue);
 359                 return -EINVAL;
 360         }
 361
 362         if (!(n = strdup(rvalue)))
 363                 return -ENOMEM;
 364
 365         free(*s);
 366         *s = n;
 367
 368         return 0;
 369 }
 370
 371 int config_parse_strv(
 372                 const char *filename,
 373                 unsigned line,
 374                 const char *section,
 375                 const char *lvalue,
 376                 const char *rvalue,
 377                 void *data,
 378                 void *userdata) {
 379
 380         char*** sv = data;
 381         char **n;
 382         char *w;
 383         unsigned k;
 384         size_t l;
 385         char *state;
 386
 387         assert(filename);
 388         assert(lvalue);
 389         assert(rvalue);
 390         assert(data);
 391
 392         k = strv_length(*sv);
 393         FOREACH_WORD_QUOTED(w, l, rvalue, state)
 394                 k++;
 395
 396         if (!(n = new(char*, k+1)))
 397                 return -ENOMEM;
 398
 399         for (k = 0; (*sv)[k]; k++)
 400                 n[k] = (*sv)[k];
 401         FOREACH_WORD_QUOTED(w, l, rvalue, state)
 402                 if (!(n[k++] = strndup(w, l)))
 403                         goto fail;
 404
 405         n[k] = NULL;
 406         free(*sv);
 407         *sv = n;
 408
 409         return 0;
 410
 411 fail:
 412         for (; k > 0; k--)
 413                 free(n[k-1]);
 414         free(n);
 415
 416         return -ENOMEM;
 417 }