src/daemon/daemon-conf.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2006 Lennart Poettering
   5   Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
   6
   7   PulseAudio is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU Lesser General Public License as published
   9   by the Free Software Foundation; either version 2.1 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <errno.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31 #include <fcntl.h>
  32 #include <sys/stat.h>
  33
  34 #ifdef HAVE_SCHED_H
  35 #include <sched.h>
  36 #endif
  37
  38 #include <pulse/xmalloc.h>
  39 #include <pulse/timeval.h>
  40 #include <pulse/i18n.h>
  41 #include <pulse/version.h>
  42
  43 #include <pulsecore/core-error.h>
  44 #include <pulsecore/core-util.h>
  45 #include <pulsecore/strbuf.h>
  46 #include <pulsecore/conf-parser.h>
  47 #include <pulsecore/resampler.h>
  48 #include <pulsecore/macro.h>
  49
  50 #include "daemon-conf.h"
  51
  52 #define DEFAULT_SCRIPT_FILE PA_DEFAULT_CONFIG_DIR PA_PATH_SEP "default.pa"
  53 #define DEFAULT_SCRIPT_FILE_USER PA_PATH_SEP "default.pa"
  54 #define DEFAULT_SYSTEM_SCRIPT_FILE PA_DEFAULT_CONFIG_DIR PA_PATH_SEP "system.pa"
  55
  56 #define DEFAULT_CONFIG_FILE PA_DEFAULT_CONFIG_DIR PA_PATH_SEP "daemon.conf"
  57 #define DEFAULT_CONFIG_FILE_USER PA_PATH_SEP "daemon.conf"
  58
  59 #define ENV_SCRIPT_FILE "PULSE_SCRIPT"
  60 #define ENV_CONFIG_FILE "PULSE_CONFIG"
  61 #define ENV_DL_SEARCH_PATH "PULSE_DLPATH"
  62
  63 static const pa_daemon_conf default_conf = {
  64     .cmd = PA_CMD_DAEMON,
  65     .daemonize = FALSE,
  66     .fail = TRUE,
  67     .high_priority = TRUE,
  68     .nice_level = -11,
  69     .realtime_scheduling = TRUE,
  70     .realtime_priority = 5,  /* Half of JACK's default rtprio */
  71     .disallow_module_loading = FALSE,
  72     .disallow_exit = FALSE,
  73     .flat_volumes = TRUE,
  74     .exit_idle_time = 20,
  75     .scache_idle_time = 20,
  76     .auto_log_target = 1,
  77     .script_commands = NULL,
  78     .dl_search_path = NULL,
  79     .load_default_script_file = TRUE,
  80     .default_script_file = NULL,
  81     .log_target = PA_LOG_SYSLOG,
  82     .log_level = PA_LOG_NOTICE,
  83     .log_backtrace = 0,
  84     .log_meta = FALSE,
  85     .log_time = FALSE,
  86     .resample_method = PA_RESAMPLER_AUTO,
  87     .disable_remixing = FALSE,
  88     .disable_lfe_remixing = TRUE,
  89     .config_file = NULL,
  90     .use_pid_file = TRUE,
  91     .system_instance = FALSE,
  92 #ifdef HAVE_DBUS
  93     .local_server_type = PA_SERVER_TYPE_UNSET, /* The actual default is _USER, but we have to detect when the user doesn't specify this option. */
  94 #endif
  95     .no_cpu_limit = TRUE,
  96     .disable_shm = FALSE,
  97     .lock_memory = FALSE,
  98     .sync_volume = TRUE,
  99     .default_n_fragments = 4,
 100     .default_fragment_size_msec = 25,
 101     .sync_volume_safety_margin_usec = 8000,
 102     .sync_volume_extra_delay_usec = 0,
 103     .default_sample_spec = { .format = PA_SAMPLE_S16NE, .rate = 44100, .channels = 2 },
 104     .default_channel_map = { .channels = 2, .map = { PA_CHANNEL_POSITION_LEFT, PA_CHANNEL_POSITION_RIGHT } },
 105     .shm_size = 0
 106 #ifdef HAVE_SYS_RESOURCE_H
 107    ,.rlimit_fsize = { .value = 0, .is_set = FALSE },
 108     .rlimit_data = { .value = 0, .is_set = FALSE },
 109     .rlimit_stack = { .value = 0, .is_set = FALSE },
 110     .rlimit_core = { .value = 0, .is_set = FALSE }
 111 #ifdef RLIMIT_RSS
 112    ,.rlimit_rss = { .value = 0, .is_set = FALSE }
 113 #endif
 114 #ifdef RLIMIT_NPROC
 115    ,.rlimit_nproc = { .value = 0, .is_set = FALSE }
 116 #endif
 117 #ifdef RLIMIT_NOFILE
 118    ,.rlimit_nofile = { .value = 256, .is_set = TRUE }
 119 #endif
 120 #ifdef RLIMIT_MEMLOCK
 121    ,.rlimit_memlock = { .value = 0, .is_set = FALSE }
 122 #endif
 123 #ifdef RLIMIT_AS
 124    ,.rlimit_as = { .value = 0, .is_set = FALSE }
 125 #endif
 126 #ifdef RLIMIT_LOCKS
 127    ,.rlimit_locks = { .value = 0, .is_set = FALSE }
 128 #endif
 129 #ifdef RLIMIT_SIGPENDING
 130    ,.rlimit_sigpending = { .value = 0, .is_set = FALSE }
 131 #endif
 132 #ifdef RLIMIT_MSGQUEUE
 133    ,.rlimit_msgqueue = { .value = 0, .is_set = FALSE }
 134 #endif
 135 #ifdef RLIMIT_NICE
 136    ,.rlimit_nice = { .value = 31, .is_set = TRUE }     /* nice level of -11 */
 137 #endif
 138 #ifdef RLIMIT_RTPRIO
 139    ,.rlimit_rtprio = { .value = 9, .is_set = TRUE }    /* One below JACK's default for the server */
 140 #endif
 141 #ifdef RLIMIT_RTTIME
 142    ,.rlimit_rttime = { .value = PA_USEC_PER_SEC, .is_set = TRUE }
 143 #endif
 144 #endif
 145 };
 146
 147 pa_daemon_conf *pa_daemon_conf_new(void) {
 148     pa_daemon_conf *c;
 149
 150     c = pa_xnewdup(pa_daemon_conf, &default_conf, 1);
 151
 152 #ifdef OS_IS_WIN32
 153     c->dl_search_path = pa_sprintf_malloc("%s" PA_PATH_SEP "lib" PA_PATH_SEP "pulse-%d.%d" PA_PATH_SEP "modules",
 154                                           pa_win32_get_toplevel(NULL), PA_MAJOR, PA_MINOR);
 155 #else
 156     if (pa_run_from_build_tree()) {
 157         pa_log_notice("Detected that we are run from the build tree, fixing search path.");
 158         c->dl_search_path = pa_xstrdup(PA_BUILDDIR "/.libs/");
 159     } else
 160         c->dl_search_path = pa_xstrdup(PA_DLSEARCHPATH);
 161 #endif
 162
 163     return c;
 164 }
 165
 166 void pa_daemon_conf_free(pa_daemon_conf *c) {
 167     pa_assert(c);
 168
 169     pa_log_set_fd(-1);
 170
 171     pa_xfree(c->script_commands);
 172     pa_xfree(c->dl_search_path);
 173     pa_xfree(c->default_script_file);
 174     pa_xfree(c->config_file);
 175     pa_xfree(c);
 176 }
 177
 178 int pa_daemon_conf_set_log_target(pa_daemon_conf *c, const char *string) {
 179     pa_assert(c);
 180     pa_assert(string);
 181
 182     if (!strcmp(string, "auto"))
 183         c->auto_log_target = 1;
 184     else if (!strcmp(string, "syslog")) {
 185         c->auto_log_target = 0;
 186         c->log_target = PA_LOG_SYSLOG;
 187     } else if (!strcmp(string, "stderr")) {
 188         c->auto_log_target = 0;
 189         c->log_target = PA_LOG_STDERR;
 190     } else if (pa_startswith(string, "file:")) {
 191         char file_path[512];
 192         int log_fd;
 193
 194         pa_strlcpy(file_path, string + 5, sizeof(file_path));
 195
 196         /* Open target file with user rights */
 197         if ((log_fd = open(file_path, O_RDWR|O_TRUNC|O_CREAT, S_IRWXU)) >= 0) {
 198              c->auto_log_target = 0;
 199              c->log_target = PA_LOG_FD;
 200              pa_log_set_fd(log_fd);
 201         } else {
 202             printf("Failed to open target file %s, error : %s\n", file_path, pa_cstrerror(errno));
 203             return -1;
 204         }
 205     } else
 206         return -1;
 207
 208     return 0;
 209 }
 210
 211 int pa_daemon_conf_set_log_level(pa_daemon_conf *c, const char *string) {
 212     uint32_t u;
 213     pa_assert(c);
 214     pa_assert(string);
 215
 216     if (pa_atou(string, &u) >= 0) {
 217         if (u >= PA_LOG_LEVEL_MAX)
 218             return -1;
 219
 220         c->log_level = (pa_log_level_t) u;
 221     } else if (pa_startswith(string, "debug"))
 222         c->log_level = PA_LOG_DEBUG;
 223     else if (pa_startswith(string, "info"))
 224         c->log_level = PA_LOG_INFO;
 225     else if (pa_startswith(string, "notice"))
 226         c->log_level = PA_LOG_NOTICE;
 227     else if (pa_startswith(string, "warn"))
 228         c->log_level = PA_LOG_WARN;
 229     else if (pa_startswith(string, "err"))
 230         c->log_level = PA_LOG_ERROR;
 231     else
 232         return -1;
 233
 234     return 0;
 235 }
 236
 237 int pa_daemon_conf_set_resample_method(pa_daemon_conf *c, const char *string) {
 238     int m;
 239     pa_assert(c);
 240     pa_assert(string);
 241
 242     if ((m = pa_parse_resample_method(string)) < 0)
 243         return -1;
 244
 245     c->resample_method = m;
 246     return 0;
 247 }
 248
 249 int pa_daemon_conf_set_local_server_type(pa_daemon_conf *c, const char *string) {
 250     pa_assert(c);
 251     pa_assert(string);
 252
 253     if (!strcmp(string, "user"))
 254         c->local_server_type = PA_SERVER_TYPE_USER;
 255     else if (!strcmp(string, "system")) {
 256         c->local_server_type = PA_SERVER_TYPE_SYSTEM;
 257     } else if (!strcmp(string, "none")) {
 258         c->local_server_type = PA_SERVER_TYPE_NONE;
 259     } else
 260         return -1;
 261
 262     return 0;
 263 }
 264
 265 static int parse_log_target(const char *filename, unsigned line, const char *section, const char *lvalue, const char *rvalue, void *data, void *userdata) {
 266     pa_daemon_conf *c = data;
 267
 268     pa_assert(filename);
 269     pa_assert(lvalue);
 270     pa_assert(rvalue);
 271     pa_assert(data);
 272
 273     if (pa_daemon_conf_set_log_target(c, rvalue) < 0) {
 274         pa_log(_("[%s:%u] Invalid log target '%s'."), filename, line, rvalue);
 275         return -1;
 276     }
 277
 278     return 0;
 279 }
 280
 281 static int parse_log_level(const char *filename, unsigned line, const char *section, const char *lvalue, const char *rvalue, void *data, void *userdata) {
 282     pa_daemon_conf *c = data;
 283
 284     pa_assert(filename);
 285     pa_assert(lvalue);
 286     pa_assert(rvalue);
 287     pa_assert(data);
 288
 289     if (pa_daemon_conf_set_log_level(c, rvalue) < 0) {
 290         pa_log(_("[%s:%u] Invalid log level '%s'."), filename, line, rvalue);
 291         return -1;
 292     }
 293
 294     return 0;
 295 }
 296
 297 static int parse_resample_method(const char *filename, unsigned line, const char *section, const char *lvalue, const char *rvalue, void *data, void *userdata) {
 298     pa_daemon_conf *c = data;
 299
 300     pa_assert(filename);
 301     pa_assert(lvalue);
 302     pa_assert(rvalue);
 303     pa_assert(data);
 304
 305     if (pa_daemon_conf_set_resample_method(c, rvalue) < 0) {
 306         pa_log(_("[%s:%u] Invalid resample method '%s'."), filename, line, rvalue);
 307         return -1;
 308     }
 309
 310     return 0;
 311 }
 312
 313 #ifdef HAVE_SYS_RESOURCE_H
 314 static int parse_rlimit(const char *filename, unsigned line, const char *section, const char *lvalue, const char *rvalue, void *data, void *userdata) {
 315     struct pa_rlimit *r = data;
 316
 317     pa_assert(filename);
 318     pa_assert(lvalue);
 319     pa_assert(rvalue);
 320     pa_assert(r);
 321
 322     if (rvalue[strspn(rvalue, "\t ")] == 0) {
 323         /* Empty string */
 324         r->is_set = 0;
 325         r->value = 0;
 326     } else {
 327         int32_t k;
 328         if (pa_atoi(rvalue, &k) < 0) {
 329             pa_log(_("[%s:%u] Invalid rlimit '%s'."), filename, line, rvalue);
 330             return -1;
 331         }
 332         r->is_set = k >= 0;
 333         r->value = k >= 0 ? (rlim_t) k : 0;
 334     }
 335
 336     return 0;
 337 }
 338 #endif
 339
 340 static int parse_sample_format(const char *filename, unsigned line, const char *section, const char *lvalue, const char *rvalue, void *data, void *userdata) {
 341     pa_daemon_conf *c = data;
 342     pa_sample_format_t f;
 343
 344     pa_assert(filename);
 345     pa_assert(lvalue);
 346     pa_assert(rvalue);
 347     pa_assert(data);
 348
 349     if ((f = pa_parse_sample_format(rvalue)) < 0) {
 350         pa_log(_("[%s:%u] Invalid sample format '%s'."), filename, line, rvalue);
 351         return -1;
 352     }
 353
 354     c->default_sample_spec.format = f;
 355     return 0;
 356 }
 357
 358 static int parse_sample_rate(const char *filename, unsigned line, const char *section, const char *lvalue, const char *rvalue, void *data, void *userdata) {
 359     pa_daemon_conf *c = data;
 360     uint32_t r;
 361
 362     pa_assert(filename);
 363     pa_assert(lvalue);
 364     pa_assert(rvalue);
 365     pa_assert(data);
 366
 367     if (pa_atou(rvalue, &r) < 0 || r > (uint32_t) PA_RATE_MAX || r <= 0) {
 368         pa_log(_("[%s:%u] Invalid sample rate '%s'."), filename, line, rvalue);
 369         return -1;
 370     }
 371
 372     c->default_sample_spec.rate = r;
 373     return 0;
 374 }
 375
 376 struct channel_conf_info {
 377     pa_daemon_conf *conf;
 378     pa_bool_t default_sample_spec_set;
 379     pa_bool_t default_channel_map_set;
 380 };
 381
 382 static int parse_sample_channels(const char *filename, unsigned line, const char *section, const char *lvalue, const char *rvalue, void *data, void *userdata) {
 383     struct channel_conf_info *i = data;
 384     int32_t n;
 385
 386     pa_assert(filename);
 387     pa_assert(lvalue);
 388     pa_assert(rvalue);
 389     pa_assert(data);
 390
 391     if (pa_atoi(rvalue, &n) < 0 || n > (int32_t) PA_CHANNELS_MAX || n <= 0) {
 392         pa_log(_("[%s:%u] Invalid sample channels '%s'."), filename, line, rvalue);
 393         return -1;
 394     }
 395
 396     i->conf->default_sample_spec.channels = (uint8_t) n;
 397     i->default_sample_spec_set = TRUE;
 398     return 0;
 399 }
 400
 401 static int parse_channel_map(const char *filename, unsigned line, const char *section, const char *lvalue, const char *rvalue, void *data, void *userdata) {
 402     struct channel_conf_info *i = data;
 403
 404     pa_assert(filename);
 405     pa_assert(lvalue);
 406     pa_assert(rvalue);
 407     pa_assert(data);
 408
 409     if (!pa_channel_map_parse(&i->conf->default_channel_map, rvalue)) {
 410         pa_log(_("[%s:%u] Invalid channel map '%s'."), filename, line, rvalue);
 411         return -1;
 412     }
 413
 414     i->default_channel_map_set = TRUE;
 415     return 0;
 416 }
 417
 418 static int parse_fragments(const char *filename, unsigned line, const char *section, const char *lvalue, const char *rvalue, void *data, void *userdata) {
 419     pa_daemon_conf *c = data;
 420     int32_t n;
 421
 422     pa_assert(filename);
 423     pa_assert(lvalue);
 424     pa_assert(rvalue);
 425     pa_assert(data);
 426
 427     if (pa_atoi(rvalue, &n) < 0 || n < 2) {
 428         pa_log(_("[%s:%u] Invalid number of fragments '%s'."), filename, line, rvalue);
 429         return -1;
 430     }
 431
 432     c->default_n_fragments = (unsigned) n;
 433     return 0;
 434 }
 435
 436 static int parse_fragment_size_msec(const char *filename, unsigned line, const char *section, const char *lvalue, const char *rvalue, void *data, void *userdata) {
 437     pa_daemon_conf *c = data;
 438     int32_t n;
 439
 440     pa_assert(filename);
 441     pa_assert(lvalue);
 442     pa_assert(rvalue);
 443     pa_assert(data);
 444
 445     if (pa_atoi(rvalue, &n) < 0 || n < 1) {
 446         pa_log(_("[%s:%u] Invalid fragment size '%s'."), filename, line, rvalue);
 447         return -1;
 448     }
 449
 450     c->default_fragment_size_msec = (unsigned) n;
 451     return 0;
 452 }
 453
 454 static int parse_nice_level(const char *filename, unsigned line, const char *section, const char *lvalue, const char *rvalue, void *data, void *userdata) {
 455     pa_daemon_conf *c = data;
 456     int32_t level;
 457
 458     pa_assert(filename);
 459     pa_assert(lvalue);
 460     pa_assert(rvalue);
 461     pa_assert(data);
 462
 463     if (pa_atoi(rvalue, &level) < 0 || level < -20 || level > 19) {
 464         pa_log(_("[%s:%u] Invalid nice level '%s'."), filename, line, rvalue);
 465         return -1;
 466     }
 467
 468     c->nice_level = (int) level;
 469     return 0;
 470 }
 471
 472 static int parse_rtprio(const char *filename, unsigned line, const char *section, const char *lvalue, const char *rvalue, void *data, void *userdata) {
 473     pa_daemon_conf *c = data;
 474     int32_t rtprio;
 475
 476     pa_assert(filename);
 477     pa_assert(lvalue);
 478     pa_assert(rvalue);
 479     pa_assert(data);
 480
 481 #ifndef OS_IS_WIN32
 482 # ifdef HAVE_SCHED_H
 483     if (pa_atoi(rvalue, &rtprio) < 0 || rtprio < sched_get_priority_min(SCHED_FIFO) || rtprio > sched_get_priority_max(SCHED_FIFO)) {
 484         pa_log("[%s:%u] Invalid realtime priority '%s'.", filename, line, rvalue);
 485         return -1;
 486     }
 487 # endif
 488 #endif
 489
 490     c->realtime_priority = (int) rtprio;
 491     return 0;
 492 }
 493
 494 #ifdef HAVE_DBUS
 495 static int parse_server_type(const char *filename, unsigned line, const char *section, const char *lvalue, const char *rvalue, void *data, void *userdata) {
 496     pa_daemon_conf *c = data;
 497
 498     pa_assert(filename);
 499     pa_assert(lvalue);
 500     pa_assert(rvalue);
 501     pa_assert(data);
 502
 503     if (pa_daemon_conf_set_local_server_type(c, rvalue) < 0) {
 504         pa_log(_("[%s:%u] Invalid server type '%s'."), filename, line, rvalue);
 505         return -1;
 506     }
 507
 508     return 0;
 509 }
 510 #endif
 511
 512 int pa_daemon_conf_load(pa_daemon_conf *c, const char *filename) {
 513     int r = -1;
 514     FILE *f = NULL;
 515     struct channel_conf_info ci;
 516     pa_config_item table[] = {
 517         { "daemonize",                  pa_config_parse_bool,     &c->daemonize, NULL },
 518         { "fail",                       pa_config_parse_bool,     &c->fail, NULL },
 519         { "high-priority",              pa_config_parse_bool,     &c->high_priority, NULL },
 520         { "realtime-scheduling",        pa_config_parse_bool,     &c->realtime_scheduling, NULL },
 521         { "disallow-module-loading",    pa_config_parse_bool,     &c->disallow_module_loading, NULL },
 522         { "allow-module-loading",       pa_config_parse_not_bool, &c->disallow_module_loading, NULL },
 523         { "disallow-exit",              pa_config_parse_bool,     &c->disallow_exit, NULL },
 524         { "allow-exit",                 pa_config_parse_not_bool, &c->disallow_exit, NULL },
 525         { "use-pid-file",               pa_config_parse_bool,     &c->use_pid_file, NULL },
 526         { "system-instance",            pa_config_parse_bool,     &c->system_instance, NULL },
 527 #ifdef HAVE_DBUS
 528         { "local-server-type",          parse_server_type,        c, NULL },
 529 #endif
 530         { "no-cpu-limit",               pa_config_parse_bool,     &c->no_cpu_limit, NULL },
 531         { "cpu-limit",                  pa_config_parse_not_bool, &c->no_cpu_limit, NULL },
 532         { "disable-shm",                pa_config_parse_bool,     &c->disable_shm, NULL },
 533         { "enable-shm",                 pa_config_parse_not_bool, &c->disable_shm, NULL },
 534         { "flat-volumes",               pa_config_parse_bool,     &c->flat_volumes, NULL },
 535         { "lock-memory",                pa_config_parse_bool,     &c->lock_memory, NULL },
 536         { "enable-sync-volume",         pa_config_parse_bool,     &c->sync_volume, NULL },
 537         { "exit-idle-time",             pa_config_parse_int,      &c->exit_idle_time, NULL },
 538         { "scache-idle-time",           pa_config_parse_int,      &c->scache_idle_time, NULL },
 539         { "realtime-priority",          parse_rtprio,             c, NULL },
 540         { "dl-search-path",             pa_config_parse_string,   &c->dl_search_path, NULL },
 541         { "default-script-file",        pa_config_parse_string,   &c->default_script_file, NULL },
 542         { "log-target",                 parse_log_target,         c, NULL },
 543         { "log-level",                  parse_log_level,          c, NULL },
 544         { "verbose",                    parse_log_level,          c, NULL },
 545         { "resample-method",            parse_resample_method,    c, NULL },
 546         { "default-sample-format",      parse_sample_format,      c, NULL },
 547         { "default-sample-rate",        parse_sample_rate,        c, NULL },
 548         { "default-sample-channels",    parse_sample_channels,    &ci,  NULL },
 549         { "default-channel-map",        parse_channel_map,        &ci,  NULL },
 550         { "default-fragments",          parse_fragments,          c, NULL },
 551         { "default-fragment-size-msec", parse_fragment_size_msec, c, NULL },
 552         { "sync-volume-safety-margin-usec", pa_config_parse_unsigned, &c->sync_volume_safety_margin_usec, NULL },
 553         { "sync-volume-extra-delay-usec", pa_config_parse_int, &c->sync_volume_extra_delay_usec, NULL },
 554         { "nice-level",                 parse_nice_level,         c, NULL },
 555         { "disable-remixing",           pa_config_parse_bool,     &c->disable_remixing, NULL },
 556         { "enable-remixing",            pa_config_parse_not_bool, &c->disable_remixing, NULL },
 557         { "disable-lfe-remixing",       pa_config_parse_bool,     &c->disable_lfe_remixing, NULL },
 558         { "enable-lfe-remixing",        pa_config_parse_not_bool, &c->disable_lfe_remixing, NULL },
 559         { "load-default-script-file",   pa_config_parse_bool,     &c->load_default_script_file, NULL },
 560         { "shm-size-bytes",             pa_config_parse_size,     &c->shm_size, NULL },
 561         { "log-meta",                   pa_config_parse_bool,     &c->log_meta, NULL },
 562         { "log-time",                   pa_config_parse_bool,     &c->log_time, NULL },
 563         { "log-backtrace",              pa_config_parse_unsigned, &c->log_backtrace, NULL },
 564 #ifdef HAVE_SYS_RESOURCE_H
 565         { "rlimit-fsize",               parse_rlimit,             &c->rlimit_fsize, NULL },
 566         { "rlimit-data",                parse_rlimit,             &c->rlimit_data, NULL },
 567         { "rlimit-stack",               parse_rlimit,             &c->rlimit_stack, NULL },
 568         { "rlimit-core",                parse_rlimit,             &c->rlimit_core, NULL },
 569 #ifdef RLIMIT_RSS
 570         { "rlimit-rss",                 parse_rlimit,             &c->rlimit_rss, NULL },
 571 #endif
 572 #ifdef RLIMIT_NOFILE
 573         { "rlimit-nofile",              parse_rlimit,             &c->rlimit_nofile, NULL },
 574 #endif
 575 #ifdef RLIMIT_AS
 576         { "rlimit-as",                  parse_rlimit,             &c->rlimit_as, NULL },
 577 #endif
 578 #ifdef RLIMIT_NPROC
 579         { "rlimit-nproc",               parse_rlimit,             &c->rlimit_nproc, NULL },
 580 #endif
 581 #ifdef RLIMIT_MEMLOCK
 582         { "rlimit-memlock",             parse_rlimit,             &c->rlimit_memlock, NULL },
 583 #endif
 584 #ifdef RLIMIT_LOCKS
 585         { "rlimit-locks",               parse_rlimit,             &c->rlimit_locks, NULL },
 586 #endif
 587 #ifdef RLIMIT_SIGPENDING
 588         { "rlimit-sigpending",          parse_rlimit,             &c->rlimit_sigpending, NULL },
 589 #endif
 590 #ifdef RLIMIT_MSGQUEUE
 591         { "rlimit-msgqueue",            parse_rlimit,             &c->rlimit_msgqueue, NULL },
 592 #endif
 593 #ifdef RLIMIT_NICE
 594         { "rlimit-nice",                parse_rlimit,             &c->rlimit_nice, NULL },
 595 #endif
 596 #ifdef RLIMIT_RTPRIO
 597         { "rlimit-rtprio",              parse_rlimit,             &c->rlimit_rtprio, NULL },
 598 #endif
 599 #ifdef RLIMIT_RTTIME
 600         { "rlimit-rttime",              parse_rlimit,             &c->rlimit_rttime, NULL },
 601 #endif
 602 #endif
 603         { NULL,                         NULL,                     NULL, NULL },
 604     };
 605
 606     pa_xfree(c->config_file);
 607     c->config_file = NULL;
 608
 609     f = filename ?
 610         pa_fopen_cloexec(c->config_file = pa_xstrdup(filename), "r") :
 611         pa_open_config_file(DEFAULT_CONFIG_FILE, DEFAULT_CONFIG_FILE_USER, ENV_CONFIG_FILE, &c->config_file);
 612
 613     if (!f && errno != ENOENT) {
 614         pa_log_warn(_("Failed to open configuration file: %s"), pa_cstrerror(errno));
 615         goto finish;
 616     }
 617
 618     ci.default_channel_map_set = ci.default_sample_spec_set = FALSE;
 619     ci.conf = c;
 620
 621     r = f ? pa_config_parse(c->config_file, f, table, NULL) : 0;
 622
 623     if (r >= 0) {
 624
 625         /* Make sure that channel map and sample spec fit together */
 626
 627         if (ci.default_sample_spec_set &&
 628             ci.default_channel_map_set &&
 629             c->default_channel_map.channels != c->default_sample_spec.channels) {
 630             pa_log_error(_("The specified default channel map has a different number of channels than the specified default number of channels."));
 631             r = -1;
 632             goto finish;
 633         } else if (ci.default_sample_spec_set)
 634             pa_channel_map_init_extend(&c->default_channel_map, c->default_sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
 635         else if (ci.default_channel_map_set)
 636             c->default_sample_spec.channels = c->default_channel_map.channels;
 637     }
 638
 639 finish:
 640     if (f)
 641         fclose(f);
 642
 643     return r;
 644 }
 645
 646 int pa_daemon_conf_env(pa_daemon_conf *c) {
 647     char *e;
 648     pa_assert(c);
 649
 650     if ((e = getenv(ENV_DL_SEARCH_PATH))) {
 651         pa_xfree(c->dl_search_path);
 652         c->dl_search_path = pa_xstrdup(e);
 653     }
 654     if ((e = getenv(ENV_SCRIPT_FILE))) {
 655         pa_xfree(c->default_script_file);
 656         c->default_script_file = pa_xstrdup(e);
 657     }
 658
 659     return 0;
 660 }
 661
 662 const char *pa_daemon_conf_get_default_script_file(pa_daemon_conf *c) {
 663     pa_assert(c);
 664
 665     if (!c->default_script_file) {
 666         if (c->system_instance)
 667             c->default_script_file = pa_find_config_file(DEFAULT_SYSTEM_SCRIPT_FILE, NULL, ENV_SCRIPT_FILE);
 668         else
 669             c->default_script_file = pa_find_config_file(DEFAULT_SCRIPT_FILE, DEFAULT_SCRIPT_FILE_USER, ENV_SCRIPT_FILE);
 670     }
 671
 672     return c->default_script_file;
 673 }
 674
 675 FILE *pa_daemon_conf_open_default_script_file(pa_daemon_conf *c) {
 676     FILE *f;
 677     pa_assert(c);
 678
 679     if (!c->default_script_file) {
 680         if (c->system_instance)
 681             f = pa_open_config_file(DEFAULT_SYSTEM_SCRIPT_FILE, NULL, ENV_SCRIPT_FILE, &c->default_script_file);
 682         else
 683             f = pa_open_config_file(DEFAULT_SCRIPT_FILE, DEFAULT_SCRIPT_FILE_USER, ENV_SCRIPT_FILE, &c->default_script_file);
 684     } else
 685         f = pa_fopen_cloexec(c->default_script_file, "r");
 686
 687     return f;
 688 }
 689
 690 char *pa_daemon_conf_dump(pa_daemon_conf *c) {
 691     static const char* const log_level_to_string[] = {
 692         [PA_LOG_DEBUG] = "debug",
 693         [PA_LOG_INFO] = "info",
 694         [PA_LOG_NOTICE] = "notice",
 695         [PA_LOG_WARN] = "warning",
 696         [PA_LOG_ERROR] = "error"
 697     };
 698
 699 #ifdef HAVE_DBUS
 700     static const char* const server_type_to_string[] = {
 701         [PA_SERVER_TYPE_UNSET] = "!!UNSET!!",
 702         [PA_SERVER_TYPE_USER] = "user",
 703         [PA_SERVER_TYPE_SYSTEM] = "system",
 704         [PA_SERVER_TYPE_NONE] = "none"
 705     };
 706 #endif
 707
 708     pa_strbuf *s;
 709     char cm[PA_CHANNEL_MAP_SNPRINT_MAX];
 710
 711     pa_assert(c);
 712
 713     s = pa_strbuf_new();
 714
 715     if (c->config_file)
 716         pa_strbuf_printf(s, _("### Read from configuration file: %s ###\n"), c->config_file);
 717
 718     pa_assert(c->log_level < PA_LOG_LEVEL_MAX);
 719
 720     pa_strbuf_printf(s, "daemonize = %s\n", pa_yes_no(c->daemonize));
 721     pa_strbuf_printf(s, "fail = %s\n", pa_yes_no(c->fail));
 722     pa_strbuf_printf(s, "high-priority = %s\n", pa_yes_no(c->high_priority));
 723     pa_strbuf_printf(s, "nice-level = %i\n", c->nice_level);
 724     pa_strbuf_printf(s, "realtime-scheduling = %s\n", pa_yes_no(c->realtime_scheduling));
 725     pa_strbuf_printf(s, "realtime-priority = %i\n", c->realtime_priority);
 726     pa_strbuf_printf(s, "allow-module-loading = %s\n", pa_yes_no(!c->disallow_module_loading));
 727     pa_strbuf_printf(s, "allow-exit = %s\n", pa_yes_no(!c->disallow_exit));
 728     pa_strbuf_printf(s, "use-pid-file = %s\n", pa_yes_no(c->use_pid_file));
 729     pa_strbuf_printf(s, "system-instance = %s\n", pa_yes_no(c->system_instance));
 730 #ifdef HAVE_DBUS
 731     pa_strbuf_printf(s, "local-server-type = %s\n", server_type_to_string[c->local_server_type]);
 732 #endif
 733     pa_strbuf_printf(s, "cpu-limit = %s\n", pa_yes_no(!c->no_cpu_limit));
 734     pa_strbuf_printf(s, "enable-shm = %s\n", pa_yes_no(!c->disable_shm));
 735     pa_strbuf_printf(s, "flat-volumes = %s\n", pa_yes_no(c->flat_volumes));
 736     pa_strbuf_printf(s, "lock-memory = %s\n", pa_yes_no(c->lock_memory));
 737     pa_strbuf_printf(s, "enable-sync-volume = %s\n", pa_yes_no(c->sync_volume));
 738     pa_strbuf_printf(s, "exit-idle-time = %i\n", c->exit_idle_time);
 739     pa_strbuf_printf(s, "scache-idle-time = %i\n", c->scache_idle_time);
 740     pa_strbuf_printf(s, "dl-search-path = %s\n", pa_strempty(c->dl_search_path));
 741     pa_strbuf_printf(s, "default-script-file = %s\n", pa_strempty(pa_daemon_conf_get_default_script_file(c)));
 742     pa_strbuf_printf(s, "load-default-script-file = %s\n", pa_yes_no(c->load_default_script_file));
 743     pa_strbuf_printf(s, "log-target = %s\n", c->auto_log_target ? "auto" : (c->log_target == PA_LOG_SYSLOG ? "syslog" : "stderr"));
 744     pa_strbuf_printf(s, "log-level = %s\n", log_level_to_string[c->log_level]);
 745     pa_strbuf_printf(s, "resample-method = %s\n", pa_resample_method_to_string(c->resample_method));
 746     pa_strbuf_printf(s, "enable-remixing = %s\n", pa_yes_no(!c->disable_remixing));
 747     pa_strbuf_printf(s, "enable-lfe-remixing = %s\n", pa_yes_no(!c->disable_lfe_remixing));
 748     pa_strbuf_printf(s, "default-sample-format = %s\n", pa_sample_format_to_string(c->default_sample_spec.format));
 749     pa_strbuf_printf(s, "default-sample-rate = %u\n", c->default_sample_spec.rate);
 750     pa_strbuf_printf(s, "default-sample-channels = %u\n", c->default_sample_spec.channels);
 751     pa_strbuf_printf(s, "default-channel-map = %s\n", pa_channel_map_snprint(cm, sizeof(cm), &c->default_channel_map));
 752     pa_strbuf_printf(s, "default-fragments = %u\n", c->default_n_fragments);
 753     pa_strbuf_printf(s, "default-fragment-size-msec = %u\n", c->default_fragment_size_msec);
 754     pa_strbuf_printf(s, "sync-volume-safety-margin-usec = %u\n", c->sync_volume_safety_margin_usec);
 755     pa_strbuf_printf(s, "sync-volume-extra-delay-usec = %d\n", c->sync_volume_extra_delay_usec);
 756     pa_strbuf_printf(s, "shm-size-bytes = %lu\n", (unsigned long) c->shm_size);
 757     pa_strbuf_printf(s, "log-meta = %s\n", pa_yes_no(c->log_meta));
 758     pa_strbuf_printf(s, "log-time = %s\n", pa_yes_no(c->log_time));
 759     pa_strbuf_printf(s, "log-backtrace = %u\n", c->log_backtrace);
 760 #ifdef HAVE_SYS_RESOURCE_H
 761     pa_strbuf_printf(s, "rlimit-fsize = %li\n", c->rlimit_fsize.is_set ? (long int) c->rlimit_fsize.value : -1);
 762     pa_strbuf_printf(s, "rlimit-data = %li\n", c->rlimit_data.is_set ? (long int) c->rlimit_data.value : -1);
 763     pa_strbuf_printf(s, "rlimit-stack = %li\n", c->rlimit_stack.is_set ? (long int) c->rlimit_stack.value : -1);
 764     pa_strbuf_printf(s, "rlimit-core = %li\n", c->rlimit_core.is_set ? (long int) c->rlimit_core.value : -1);
 765 #ifdef RLIMIT_RSS
 766     pa_strbuf_printf(s, "rlimit-rss = %li\n", c->rlimit_rss.is_set ? (long int) c->rlimit_rss.value : -1);
 767 #endif
 768 #ifdef RLIMIT_AS
 769     pa_strbuf_printf(s, "rlimit-as = %li\n", c->rlimit_as.is_set ? (long int) c->rlimit_as.value : -1);
 770 #endif
 771 #ifdef RLIMIT_NPROC
 772     pa_strbuf_printf(s, "rlimit-nproc = %li\n", c->rlimit_nproc.is_set ? (long int) c->rlimit_nproc.value : -1);
 773 #endif
 774 #ifdef RLIMIT_NOFILE
 775     pa_strbuf_printf(s, "rlimit-nofile = %li\n", c->rlimit_nofile.is_set ? (long int) c->rlimit_nofile.value : -1);
 776 #endif
 777 #ifdef RLIMIT_MEMLOCK
 778     pa_strbuf_printf(s, "rlimit-memlock = %li\n", c->rlimit_memlock.is_set ? (long int) c->rlimit_memlock.value : -1);
 779 #endif
 780 #ifdef RLIMIT_LOCKS
 781     pa_strbuf_printf(s, "rlimit-locks = %li\n", c->rlimit_locks.is_set ? (long int) c->rlimit_locks.value : -1);
 782 #endif
 783 #ifdef RLIMIT_SIGPENDING
 784     pa_strbuf_printf(s, "rlimit-sigpending = %li\n", c->rlimit_sigpending.is_set ? (long int) c->rlimit_sigpending.value : -1);
 785 #endif
 786 #ifdef RLIMIT_MSGQUEUE
 787     pa_strbuf_printf(s, "rlimit-msgqueue = %li\n", c->rlimit_msgqueue.is_set ? (long int) c->rlimit_msgqueue.value : -1);
 788 #endif
 789 #ifdef RLIMIT_NICE
 790     pa_strbuf_printf(s, "rlimit-nice = %li\n", c->rlimit_nice.is_set ? (long int) c->rlimit_nice.value : -1);
 791 #endif
 792 #ifdef RLIMIT_RTPRIO
 793     pa_strbuf_printf(s, "rlimit-rtprio = %li\n", c->rlimit_rtprio.is_set ? (long int) c->rlimit_rtprio.value : -1);
 794 #endif
 795 #ifdef RLIMIT_RTTIME
 796     pa_strbuf_printf(s, "rlimit-rttime = %li\n", c->rlimit_rttime.is_set ? (long int) c->rlimit_rttime.value : -1);
 797 #endif
 798 #endif
 799
 800     return pa_strbuf_tostring_free(s);
 801 }