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