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