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


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