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     .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         { "disallow-exit",              pa_config_parse_bool,     &c->disallow_exit, NULL },
 445         { "use-pid-file",               pa_config_parse_bool,     &c->use_pid_file, NULL },
 446         { "system-instance",            pa_config_parse_bool,     &c->system_instance, NULL },
 447         { "no-cpu-limit",               pa_config_parse_bool,     &c->no_cpu_limit, NULL },
 448         { "disable-shm",                pa_config_parse_bool,     &c->disable_shm, NULL },
 449         { "flat-volumes",               pa_config_parse_bool,     &c->flat_volumes, NULL },
 450         { "lock-memory",                pa_config_parse_bool,     &c->lock_memory, NULL },
 451         { "exit-idle-time",             pa_config_parse_int,      &c->exit_idle_time, NULL },
 452         { "scache-idle-time",           pa_config_parse_int,      &c->scache_idle_time, NULL },
 453         { "realtime-priority",          parse_rtprio,             c, NULL },
 454         { "dl-search-path",             pa_config_parse_string,   &c->dl_search_path, NULL },
 455         { "default-script-file",        pa_config_parse_string,   &c->default_script_file, NULL },
 456         { "log-target",                 parse_log_target,         c, NULL },
 457         { "log-level",                  parse_log_level,          c, NULL },
 458         { "verbose",                    parse_log_level,          c, NULL },
 459         { "resample-method",            parse_resample_method,    c, NULL },
 460         { "default-sample-format",      parse_sample_format,      c, NULL },
 461         { "default-sample-rate",        parse_sample_rate,        c, NULL },
 462         { "default-sample-channels",    parse_sample_channels,    &ci,  NULL },
 463         { "default-channel-map",        parse_channel_map,        &ci,  NULL },
 464         { "default-fragments",          parse_fragments,          c, NULL },
 465         { "default-fragment-size-msec", parse_fragment_size_msec, c, NULL },
 466         { "nice-level",                 parse_nice_level,         c, NULL },
 467         { "disable-remixing",           pa_config_parse_bool,     &c->disable_remixing, NULL },
 468         { "disable-lfe-remixing",       pa_config_parse_bool,     &c->disable_lfe_remixing, NULL },
 469         { "load-default-script-file",   pa_config_parse_bool,     &c->load_default_script_file, NULL },
 470         { "shm-size-bytes",             pa_config_parse_size,     &c->shm_size, NULL },
 471         { "log-meta",                   pa_config_parse_bool,     &c->log_meta, NULL },
 472         { "log-time",                   pa_config_parse_bool,     &c->log_time, NULL },
 473         { "log-backtrace",              pa_config_parse_unsigned, &c->log_backtrace, NULL },
 474 #ifdef HAVE_SYS_RESOURCE_H
 475         { "rlimit-fsize",               parse_rlimit,             &c->rlimit_fsize, NULL },
 476         { "rlimit-data",                parse_rlimit,             &c->rlimit_data, NULL },
 477         { "rlimit-stack",               parse_rlimit,             &c->rlimit_stack, NULL },
 478         { "rlimit-core",                parse_rlimit,             &c->rlimit_core, NULL },
 479 #ifdef RLIMIT_RSS
 480         { "rlimit-rss",                 parse_rlimit,             &c->rlimit_rss, NULL },
 481 #endif
 482 #ifdef RLIMIT_NOFILE
 483         { "rlimit-nofile",              parse_rlimit,             &c->rlimit_nofile, NULL },
 484 #endif
 485 #ifdef RLIMIT_AS
 486         { "rlimit-as",                  parse_rlimit,             &c->rlimit_as, NULL },
 487 #endif
 488 #ifdef RLIMIT_NPROC
 489         { "rlimit-nproc",               parse_rlimit,             &c->rlimit_nproc, NULL },
 490 #endif
 491 #ifdef RLIMIT_MEMLOCK
 492         { "rlimit-memlock",             parse_rlimit,             &c->rlimit_memlock, NULL },
 493 #endif
 494 #ifdef RLIMIT_LOCKS
 495         { "rlimit-locks",               parse_rlimit,             &c->rlimit_locks, NULL },
 496 #endif
 497 #ifdef RLIMIT_SIGPENDING
 498         { "rlimit-sigpending",          parse_rlimit,             &c->rlimit_sigpending, NULL },
 499 #endif
 500 #ifdef RLIMIT_MSGQUEUE
 501         { "rlimit-msgqueue",            parse_rlimit,             &c->rlimit_msgqueue, NULL },
 502 #endif
 503 #ifdef RLIMIT_NICE
 504         { "rlimit-nice",                parse_rlimit,             &c->rlimit_nice, NULL },
 505 #endif
 506 #ifdef RLIMIT_RTPRIO
 507         { "rlimit-rtprio",              parse_rlimit,             &c->rlimit_rtprio, NULL },
 508 #endif
 509 #ifdef RLIMIT_RTTIME
 510         { "rlimit-rttime",              parse_rlimit,             &c->rlimit_rttime, NULL },
 511 #endif
 512 #endif
 513         { NULL,                         NULL,                     NULL, NULL },
 514     };
 515
 516     pa_xfree(c->config_file);
 517     c->config_file = NULL;
 518
 519     f = filename ?
 520         fopen(c->config_file = pa_xstrdup(filename), "r") :
 521         pa_open_config_file(DEFAULT_CONFIG_FILE, DEFAULT_CONFIG_FILE_USER, ENV_CONFIG_FILE, &c->config_file);
 522
 523     if (!f && errno != ENOENT) {
 524         pa_log_warn(_("Failed to open configuration file: %s"), pa_cstrerror(errno));
 525         goto finish;
 526     }
 527
 528     ci.default_channel_map_set = ci.default_sample_spec_set = FALSE;
 529     ci.conf = c;
 530
 531     r = f ? pa_config_parse(c->config_file, f, table, NULL) : 0;
 532
 533     if (r >= 0) {
 534
 535         /* Make sure that channel map and sample spec fit together */
 536
 537         if (ci.default_sample_spec_set &&
 538             ci.default_channel_map_set &&
 539             c->default_channel_map.channels != c->default_sample_spec.channels) {
 540             pa_log_error(_("The specified default channel map has a different number of channels than the specified default number of channels."));
 541             r = -1;
 542             goto finish;
 543         } else if (ci.default_sample_spec_set)
 544             pa_channel_map_init_extend(&c->default_channel_map, c->default_sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
 545         else if (ci.default_channel_map_set)
 546             c->default_sample_spec.channels = c->default_channel_map.channels;
 547     }
 548
 549 finish:
 550     if (f)
 551         fclose(f);
 552
 553     return r;
 554 }
 555
 556 int pa_daemon_conf_env(pa_daemon_conf *c) {
 557     char *e;
 558     pa_assert(c);
 559
 560     if ((e = getenv(ENV_DL_SEARCH_PATH))) {
 561         pa_xfree(c->dl_search_path);
 562         c->dl_search_path = pa_xstrdup(e);
 563     }
 564     if ((e = getenv(ENV_SCRIPT_FILE))) {
 565         pa_xfree(c->default_script_file);
 566         c->default_script_file = pa_xstrdup(e);
 567     }
 568
 569     return 0;
 570 }
 571
 572 const char *pa_daemon_conf_get_default_script_file(pa_daemon_conf *c) {
 573     pa_assert(c);
 574
 575     if (!c->default_script_file) {
 576         if (c->system_instance)
 577             c->default_script_file = pa_find_config_file(DEFAULT_SYSTEM_SCRIPT_FILE, NULL, ENV_SCRIPT_FILE);
 578         else
 579             c->default_script_file = pa_find_config_file(DEFAULT_SCRIPT_FILE, DEFAULT_SCRIPT_FILE_USER, ENV_SCRIPT_FILE);
 580     }
 581
 582     return c->default_script_file;
 583 }
 584
 585 FILE *pa_daemon_conf_open_default_script_file(pa_daemon_conf *c) {
 586     FILE *f;
 587     pa_assert(c);
 588
 589     if (!c->default_script_file) {
 590         if (c->system_instance)
 591             f = pa_open_config_file(DEFAULT_SYSTEM_SCRIPT_FILE, NULL, ENV_SCRIPT_FILE, &c->default_script_file);
 592         else
 593             f = pa_open_config_file(DEFAULT_SCRIPT_FILE, DEFAULT_SCRIPT_FILE_USER, ENV_SCRIPT_FILE, &c->default_script_file);
 594     } else
 595         f = fopen(c->default_script_file, "r");
 596
 597     return f;
 598 }
 599
 600 char *pa_daemon_conf_dump(pa_daemon_conf *c) {
 601     static const char* const log_level_to_string[] = {
 602         [PA_LOG_DEBUG] = "debug",
 603         [PA_LOG_INFO] = "info",
 604         [PA_LOG_NOTICE] = "notice",
 605         [PA_LOG_WARN] = "warning",
 606         [PA_LOG_ERROR] = "error"
 607     };
 608     pa_strbuf *s;
 609     char cm[PA_CHANNEL_MAP_SNPRINT_MAX];
 610
 611     pa_assert(c);
 612
 613     s = pa_strbuf_new();
 614
 615     if (c->config_file)
 616         pa_strbuf_printf(s, _("### Read from configuration file: %s ###\n"), c->config_file);
 617
 618     pa_assert(c->log_level < PA_LOG_LEVEL_MAX);
 619
 620     pa_strbuf_printf(s, "daemonize = %s\n", pa_yes_no(c->daemonize));
 621     pa_strbuf_printf(s, "fail = %s\n", pa_yes_no(c->fail));
 622     pa_strbuf_printf(s, "high-priority = %s\n", pa_yes_no(c->high_priority));
 623     pa_strbuf_printf(s, "nice-level = %i\n", c->nice_level);
 624     pa_strbuf_printf(s, "realtime-scheduling = %s\n", pa_yes_no(c->realtime_scheduling));
 625     pa_strbuf_printf(s, "realtime-priority = %i\n", c->realtime_priority);
 626     pa_strbuf_printf(s, "disallow-module-loading = %s\n", pa_yes_no(c->disallow_module_loading));
 627     pa_strbuf_printf(s, "disallow-exit = %s\n", pa_yes_no(c->disallow_exit));
 628     pa_strbuf_printf(s, "use-pid-file = %s\n", pa_yes_no(c->use_pid_file));
 629     pa_strbuf_printf(s, "system-instance = %s\n", pa_yes_no(c->system_instance));
 630     pa_strbuf_printf(s, "no-cpu-limit = %s\n", pa_yes_no(c->no_cpu_limit));
 631     pa_strbuf_printf(s, "disable-shm = %s\n", pa_yes_no(c->disable_shm));
 632     pa_strbuf_printf(s, "flat-volumes = %s\n", pa_yes_no(c->flat_volumes));
 633     pa_strbuf_printf(s, "lock-memory = %s\n", pa_yes_no(c->lock_memory));
 634     pa_strbuf_printf(s, "exit-idle-time = %i\n", c->exit_idle_time);
 635     pa_strbuf_printf(s, "scache-idle-time = %i\n", c->scache_idle_time);
 636     pa_strbuf_printf(s, "dl-search-path = %s\n", pa_strempty(c->dl_search_path));
 637     pa_strbuf_printf(s, "default-script-file = %s\n", pa_strempty(pa_daemon_conf_get_default_script_file(c)));
 638     pa_strbuf_printf(s, "load-default-script-file = %s\n", pa_yes_no(c->load_default_script_file));
 639     pa_strbuf_printf(s, "log-target = %s\n", c->auto_log_target ? "auto" : (c->log_target == PA_LOG_SYSLOG ? "syslog" : "stderr"));
 640     pa_strbuf_printf(s, "log-level = %s\n", log_level_to_string[c->log_level]);
 641     pa_strbuf_printf(s, "resample-method = %s\n", pa_resample_method_to_string(c->resample_method));
 642     pa_strbuf_printf(s, "disable-remixing = %s\n", pa_yes_no(c->disable_remixing));
 643     pa_strbuf_printf(s, "disable-lfe-remixing = %s\n", pa_yes_no(c->disable_lfe_remixing));
 644     pa_strbuf_printf(s, "default-sample-format = %s\n", pa_sample_format_to_string(c->default_sample_spec.format));
 645     pa_strbuf_printf(s, "default-sample-rate = %u\n", c->default_sample_spec.rate);
 646     pa_strbuf_printf(s, "default-sample-channels = %u\n", c->default_sample_spec.channels);
 647     pa_strbuf_printf(s, "default-channel-map = %s\n", pa_channel_map_snprint(cm, sizeof(cm), &c->default_channel_map));
 648     pa_strbuf_printf(s, "default-fragments = %u\n", c->default_n_fragments);
 649     pa_strbuf_printf(s, "default-fragment-size-msec = %u\n", c->default_fragment_size_msec);
 650     pa_strbuf_printf(s, "shm-size-bytes = %lu\n", (unsigned long) c->shm_size);
 651     pa_strbuf_printf(s, "log-meta = %s\n", pa_yes_no(c->log_meta));
 652     pa_strbuf_printf(s, "log-time = %s\n", pa_yes_no(c->log_time));
 653     pa_strbuf_printf(s, "log-backtrace = %u\n", c->log_backtrace);
 654 #ifdef HAVE_SYS_RESOURCE_H
 655     pa_strbuf_printf(s, "rlimit-fsize = %li\n", c->rlimit_fsize.is_set ? (long int) c->rlimit_fsize.value : -1);
 656     pa_strbuf_printf(s, "rlimit-data = %li\n", c->rlimit_data.is_set ? (long int) c->rlimit_data.value : -1);
 657     pa_strbuf_printf(s, "rlimit-stack = %li\n", c->rlimit_stack.is_set ? (long int) c->rlimit_stack.value : -1);
 658     pa_strbuf_printf(s, "rlimit-core = %li\n", c->rlimit_core.is_set ? (long int) c->rlimit_core.value : -1);
 659 #ifdef RLIMIT_RSS
 660     pa_strbuf_printf(s, "rlimit-rss = %li\n", c->rlimit_rss.is_set ? (long int) c->rlimit_rss.value : -1);
 661 #endif
 662 #ifdef RLIMIT_AS
 663     pa_strbuf_printf(s, "rlimit-as = %li\n", c->rlimit_as.is_set ? (long int) c->rlimit_as.value : -1);
 664 #endif
 665 #ifdef RLIMIT_NPROC
 666     pa_strbuf_printf(s, "rlimit-nproc = %li\n", c->rlimit_nproc.is_set ? (long int) c->rlimit_nproc.value : -1);
 667 #endif
 668 #ifdef RLIMIT_NOFILE
 669     pa_strbuf_printf(s, "rlimit-nofile = %li\n", c->rlimit_nofile.is_set ? (long int) c->rlimit_nofile.value : -1);
 670 #endif
 671 #ifdef RLIMIT_MEMLOCK
 672     pa_strbuf_printf(s, "rlimit-memlock = %li\n", c->rlimit_memlock.is_set ? (long int) c->rlimit_memlock.value : -1);
 673 #endif
 674 #ifdef RLIMIT_LOCKS
 675     pa_strbuf_printf(s, "rlimit-locks = %li\n", c->rlimit_locks.is_set ? (long int) c->rlimit_locks.value : -1);
 676 #endif
 677 #ifdef RLIMIT_SIGPENDING
 678     pa_strbuf_printf(s, "rlimit-sigpending = %li\n", c->rlimit_sigpending.is_set ? (long int) c->rlimit_sigpending.value : -1);
 679 #endif
 680 #ifdef RLIMIT_MSGQUEUE
 681     pa_strbuf_printf(s, "rlimit-msgqueue = %li\n", c->rlimit_msgqueue.is_set ? (long int) c->rlimit_msgqueue.value : -1);
 682 #endif
 683 #ifdef RLIMIT_NICE
 684     pa_strbuf_printf(s, "rlimit-nice = %li\n", c->rlimit_nice.is_set ? (long int) c->rlimit_nice.value : -1);
 685 #endif
 686 #ifdef RLIMIT_RTPRIO
 687     pa_strbuf_printf(s, "rlimit-rtprio = %li\n", c->rlimit_rtprio.is_set ? (long int) c->rlimit_rtprio.value : -1);
 688 #endif
 689 #ifdef RLIMIT_RTTIME
 690     pa_strbuf_printf(s, "rlimit-rttime = %li\n", c->rlimit_rttime.is_set ? (long int) c->rlimit_rttime.value : -1);
 691 #endif
 692 #endif
 693
 694     return pa_strbuf_tostring_free(s);
 695 }