]> code.delx.au - pulseaudio/blob - src/daemon/daemon-conf.c
delx.au / code / pulseaudio / blob


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