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