src/pulsecore/conf-parser.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2006 Lennart Poettering
   5
   6   PulseAudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as published
   8   by the Free Software Foundation; either version 2.1 of the License,
   9   or (at your option) any later version.
  10
  11   PulseAudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <dirent.h>
  25 #include <string.h>
  26 #include <stdio.h>
  27 #include <errno.h>
  28
  29 #include <pulse/xmalloc.h>
  30
  31 #include <pulsecore/core-error.h>
  32 #include <pulsecore/log.h>
  33 #include <pulsecore/core-util.h>
  34 #include <pulsecore/macro.h>
  35
  36 #include "conf-parser.h"
  37
  38 #define WHITESPACE " \t\n"
  39 #define COMMENTS "#;\n"
  40
  41 /* Run the user supplied parser for an assignment */
  42 static int normal_assignment(pa_config_parser_state *state) {
  43     const pa_config_item *item;
  44
  45     pa_assert(state);
  46
  47     for (item = state->item_table; item->parse; item++) {
  48
  49         if (item->lvalue && !pa_streq(state->lvalue, item->lvalue))
  50             continue;
  51
  52         if (item->section && !state->section)
  53             continue;
  54
  55         if (item->section && !pa_streq(state->section, item->section))
  56             continue;
  57
  58         state->data = item->data;
  59
  60         return item->parse(state);
  61     }
  62
  63     pa_log("[%s:%u] Unknown lvalue '%s' in section '%s'.", state->filename, state->lineno, state->lvalue, pa_strna(state->section));
  64
  65     return -1;
  66 }
  67
  68 /* Parse a proplist entry. */
  69 static int proplist_assignment(pa_config_parser_state *state) {
  70     pa_assert(state);
  71     pa_assert(state->proplist);
  72
  73     if (pa_proplist_sets(state->proplist, state->lvalue, state->rvalue) < 0) {
  74         pa_log("[%s:%u] Failed to parse a proplist entry: %s = %s", state->filename, state->lineno, state->lvalue, state->rvalue);
  75         return -1;
  76     }
  77
  78     return 0;
  79 }
  80
  81 /* Parse a variable assignment line */
  82 static int parse_line(pa_config_parser_state *state) {
  83     char *c;
  84
  85     state->lvalue = state->buf + strspn(state->buf, WHITESPACE);
  86
  87     if ((c = strpbrk(state->lvalue, COMMENTS)))
  88         *c = 0;
  89
  90     if (!*state->lvalue)
  91         return 0;
  92
  93     if (pa_startswith(state->lvalue, ".include ")) {
  94         char *path = NULL, *fn;
  95         int r;
  96
  97         fn = pa_strip(state->lvalue + 9);
  98         if (!pa_is_path_absolute(fn)) {
  99             const char *k;
 100             if ((k = strrchr(state->filename, '/'))) {
 101                 char *dir = pa_xstrndup(state->filename, k - state->filename);
 102                 fn = path = pa_sprintf_malloc("%s" PA_PATH_SEP "%s", dir, fn);
 103                 pa_xfree(dir);
 104             }
 105         }
 106
 107         r = pa_config_parse(fn, NULL, state->item_table, state->proplist, false, state->userdata);
 108         pa_xfree(path);
 109         return r;
 110     }
 111
 112     if (*state->lvalue == '[') {
 113         size_t k;
 114
 115         k = strlen(state->lvalue);
 116         pa_assert(k > 0);
 117
 118         if (state->lvalue[k-1] != ']') {
 119             pa_log("[%s:%u] Invalid section header.", state->filename, state->lineno);
 120             return -1;
 121         }
 122
 123         pa_xfree(state->section);
 124         state->section = pa_xstrndup(state->lvalue + 1, k-2);
 125
 126         if (pa_streq(state->section, "Properties")) {
 127             if (!state->proplist) {
 128                 pa_log("[%s:%u] \"Properties\" section is not allowed in this file.", state->filename, state->lineno);
 129                 return -1;
 130             }
 131
 132             state->in_proplist = true;
 133         } else
 134             state->in_proplist = false;
 135
 136         return 0;
 137     }
 138
 139     if (!(state->rvalue = strchr(state->lvalue, '='))) {
 140         pa_log("[%s:%u] Missing '='.", state->filename, state->lineno);
 141         return -1;
 142     }
 143
 144     *state->rvalue = 0;
 145     state->rvalue++;
 146
 147     state->lvalue = pa_strip(state->lvalue);
 148     state->rvalue = pa_strip(state->rvalue);
 149
 150     if (state->in_proplist)
 151         return proplist_assignment(state);
 152     else
 153         return normal_assignment(state);
 154 }
 155
 156 #ifndef OS_IS_WIN32
 157 static int conf_filter(const struct dirent *entry) {
 158     return pa_endswith(entry->d_name, ".conf");
 159 }
 160 #endif
 161
 162 /* Go through the file and parse each line */
 163 int pa_config_parse(const char *filename, FILE *f, const pa_config_item *t, pa_proplist *proplist, bool use_dot_d,
 164                     void *userdata) {
 165     int r = -1;
 166     bool do_close = !f;
 167     pa_config_parser_state state;
 168
 169     pa_assert(filename);
 170     pa_assert(t);
 171
 172     pa_zero(state);
 173
 174     if (!f && !(f = pa_fopen_cloexec(filename, "r"))) {
 175         if (errno == ENOENT) {
 176             pa_log_debug("Failed to open configuration file '%s': %s", filename, pa_cstrerror(errno));
 177             r = 0;
 178             goto finish;
 179         }
 180
 181         pa_log_warn("Failed to open configuration file '%s': %s", filename, pa_cstrerror(errno));
 182         goto finish;
 183     }
 184     pa_log_debug("Parsing configuration file '%s'", filename);
 185
 186     state.filename = filename;
 187     state.item_table = t;
 188     state.userdata = userdata;
 189
 190     if (proplist)
 191         state.proplist = pa_proplist_new();
 192
 193     while (!feof(f)) {
 194         if (!fgets(state.buf, sizeof(state.buf), f)) {
 195             if (feof(f))
 196                 break;
 197
 198             pa_log_warn("Failed to read configuration file '%s': %s", filename, pa_cstrerror(errno));
 199             goto finish;
 200         }
 201
 202         state.lineno++;
 203
 204         if (parse_line(&state) < 0)
 205             goto finish;
 206     }
 207
 208     if (proplist)
 209         pa_proplist_update(proplist, PA_UPDATE_REPLACE, state.proplist);
 210
 211     r = 0;
 212
 213 finish:
 214     if (state.proplist)
 215         pa_proplist_free(state.proplist);
 216
 217     pa_xfree(state.section);
 218
 219     if (do_close && f)
 220         fclose(f);
 221
 222     if (use_dot_d) {
 223 #ifdef OS_IS_WIN32
 224         char *dir_name = pa_sprintf_malloc("%s.d", filename);
 225         char *pattern = pa_sprintf_malloc("%s\\*.conf", dir_name);
 226         HANDLE fh;
 227         WIN32_FIND_DATA wfd;
 228
 229         fh = FindFirstFile(pattern, &wfd);
 230         if (fh != INVALID_HANDLE_VALUE) {
 231             do {
 232                 if (!(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
 233                     char *filename2 = pa_sprintf_malloc("%s\\%s", dir_name, wfd.cFileName);
 234                     pa_config_parse(filename2, NULL, t, proplist, false, userdata);
 235                     pa_xfree(filename2);
 236                 }
 237             } while (FindNextFile(fh, &wfd));
 238             FindClose(fh);
 239         } else {
 240             DWORD err = GetLastError();
 241
 242             if (err == ERROR_PATH_NOT_FOUND) {
 243                 pa_log_debug("Pattern %s did not match any files, ignoring.", pattern);
 244             } else {
 245                 LPVOID msgbuf;
 246                 DWORD fret = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
 247                                            NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&msgbuf, 0, NULL);
 248
 249                 if (fret != 0) {
 250                     pa_log_warn("FindFirstFile(%s) failed with error %ld (%s), ignoring.", pattern, err, (char*)msgbuf);
 251                     LocalFree(msgbuf);
 252                 } else {
 253                     pa_log_warn("FindFirstFile(%s) failed with error %ld, ignoring.", pattern, err);
 254                     pa_log_warn("FormatMessage failed with error %lu", GetLastError());
 255                 }
 256             }
 257         }
 258
 259         pa_xfree(pattern);
 260         pa_xfree(dir_name);
 261 #else
 262         char *dir_name;
 263         int n;
 264         struct dirent **entries = NULL;
 265
 266         dir_name = pa_sprintf_malloc("%s.d", filename);
 267
 268         n = scandir(dir_name, &entries, conf_filter, alphasort);
 269         if (n >= 0) {
 270             int i;
 271
 272             for (i = 0; i < n; i++) {
 273                 char *filename2;
 274
 275                 filename2 = pa_sprintf_malloc("%s" PA_PATH_SEP "%s", dir_name, entries[i]->d_name);
 276                 pa_config_parse(filename2, NULL, t, proplist, false, userdata);
 277                 pa_xfree(filename2);
 278
 279                 free(entries[i]);
 280             }
 281
 282             free(entries);
 283         } else {
 284             if (errno == ENOENT)
 285                 pa_log_debug("%s does not exist, ignoring.", dir_name);
 286             else
 287                 pa_log_warn("scandir(\"%s\") failed: %s", dir_name, pa_cstrerror(errno));
 288         }
 289
 290         pa_xfree(dir_name);
 291 #endif
 292     }
 293
 294     return r;
 295 }
 296
 297 int pa_config_parse_int(pa_config_parser_state *state) {
 298     int *i;
 299     int32_t k;
 300
 301     pa_assert(state);
 302
 303     i = state->data;
 304
 305     if (pa_atoi(state->rvalue, &k) < 0) {
 306         pa_log("[%s:%u] Failed to parse numeric value: %s", state->filename, state->lineno, state->rvalue);
 307         return -1;
 308     }
 309
 310     *i = (int) k;
 311     return 0;
 312 }
 313
 314 int pa_config_parse_unsigned(pa_config_parser_state *state) {
 315     unsigned *u;
 316     uint32_t k;
 317
 318     pa_assert(state);
 319
 320     u = state->data;
 321
 322     if (pa_atou(state->rvalue, &k) < 0) {
 323         pa_log("[%s:%u] Failed to parse numeric value: %s", state->filename, state->lineno, state->rvalue);
 324         return -1;
 325     }
 326
 327     *u = (unsigned) k;
 328     return 0;
 329 }
 330
 331 int pa_config_parse_size(pa_config_parser_state *state) {
 332     size_t *i;
 333     uint32_t k;
 334
 335     pa_assert(state);
 336
 337     i = state->data;
 338
 339     if (pa_atou(state->rvalue, &k) < 0) {
 340         pa_log("[%s:%u] Failed to parse numeric value: %s", state->filename, state->lineno, state->rvalue);
 341         return -1;
 342     }
 343
 344     *i = (size_t) k;
 345     return 0;
 346 }
 347
 348 int pa_config_parse_bool(pa_config_parser_state *state) {
 349     int k;
 350     bool *b;
 351
 352     pa_assert(state);
 353
 354     b = state->data;
 355
 356     if ((k = pa_parse_boolean(state->rvalue)) < 0) {
 357         pa_log("[%s:%u] Failed to parse boolean value: %s", state->filename, state->lineno, state->rvalue);
 358         return -1;
 359     }
 360
 361     *b = !!k;
 362
 363     return 0;
 364 }
 365
 366 int pa_config_parse_not_bool(pa_config_parser_state *state) {
 367     int k;
 368     bool *b;
 369
 370     pa_assert(state);
 371
 372     b = state->data;
 373
 374     if ((k = pa_parse_boolean(state->rvalue)) < 0) {
 375         pa_log("[%s:%u] Failed to parse boolean value: %s", state->filename, state->lineno, state->rvalue);
 376         return -1;
 377     }
 378
 379     *b = !k;
 380
 381     return 0;
 382 }
 383
 384 int pa_config_parse_string(pa_config_parser_state *state) {
 385     char **s;
 386
 387     pa_assert(state);
 388
 389     s = state->data;
 390
 391     pa_xfree(*s);
 392     *s = *state->rvalue ? pa_xstrdup(state->rvalue) : NULL;
 393     return 0;
 394 }