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


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