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