2 This file is part of PulseAudio.
4 Copyright 2004-2006 Lennart Poettering
5 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
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.
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.
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
39 #include <sys/types.h>
41 #include <liboil/liboil.h>
43 #ifdef HAVE_SYS_IOCTL_H
44 #include <sys/ioctl.h>
60 #include <dbus/dbus.h>
63 #include <pulse/mainloop.h>
64 #include <pulse/mainloop-signal.h>
65 #include <pulse/timeval.h>
66 #include <pulse/xmalloc.h>
67 #include <pulse/i18n.h>
69 #include <pulsecore/lock-autospawn.h>
70 #include <pulsecore/winsock.h>
71 #include <pulsecore/core-error.h>
72 #include <pulsecore/core.h>
73 #include <pulsecore/memblock.h>
74 #include <pulsecore/module.h>
75 #include <pulsecore/cli-command.h>
76 #include <pulsecore/log.h>
77 #include <pulsecore/core-util.h>
78 #include <pulsecore/sioman.h>
79 #include <pulsecore/cli-text.h>
80 #include <pulsecore/pid.h>
81 #include <pulsecore/namereg.h>
82 #include <pulsecore/random.h>
83 #include <pulsecore/rtsig.h>
84 #include <pulsecore/rtclock.h>
85 #include <pulsecore/macro.h>
86 #include <pulsecore/mutex.h>
87 #include <pulsecore/thread.h>
88 #include <pulsecore/once.h>
89 #include <pulsecore/shm.h>
90 #include <pulsecore/memtrap.h>
92 #include <pulsecore/dbus-shared.h>
97 #include "daemon-conf.h"
98 #include "dumpmodules.h"
100 #include "ltdl-bind-now.h"
102 #include "server-lookup.h"
105 /* Only one instance of these variables */
106 int allow_severity = LOG_INFO;
107 int deny_severity = LOG_WARNING;
111 /* padsp looks for this symbol in the running process and disables
112 * itself if it finds it and it is set to 7 (which is actually a bit
113 * mask). For details see padsp. */
114 int __padsp_disabled__ = 7;
119 static void message_cb(pa_mainloop_api*a, pa_time_event*e, const struct timeval *tv, void *userdata) {
121 struct timeval tvnext;
123 while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
124 if (msg.message == WM_QUIT)
127 TranslateMessage(&msg);
128 DispatchMessage(&msg);
132 pa_timeval_add(pa_gettimeofday(&tvnext), 100000);
133 a->time_restart(e, &tvnext);
138 static void signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
139 pa_log_info(_("Got signal %s."), pa_sig2str(sig));
144 pa_module_load(userdata, "module-cli", NULL);
150 pa_module_load(userdata, "module-cli-protocol-unix", NULL);
156 char *c = pa_full_status_string(userdata);
157 pa_log_notice("%s", c);
166 pa_log_info(_("Exiting."));
172 #if defined(HAVE_PWD_H) && defined(HAVE_GRP_H)
174 static int change_user(void) {
179 /* This function is called only in system-wide mode. It creates a
180 * runtime dir in /var/run/ with proper UID/GID and drops privs
183 if (!(pw = getpwnam(PA_SYSTEM_USER))) {
184 pa_log(_("Failed to find user '%s'."), PA_SYSTEM_USER);
188 if (!(gr = getgrnam(PA_SYSTEM_GROUP))) {
189 pa_log(_("Failed to find group '%s'."), PA_SYSTEM_GROUP);
193 pa_log_info(_("Found user '%s' (UID %lu) and group '%s' (GID %lu)."),
194 PA_SYSTEM_USER, (unsigned long) pw->pw_uid,
195 PA_SYSTEM_GROUP, (unsigned long) gr->gr_gid);
197 if (pw->pw_gid != gr->gr_gid) {
198 pa_log(_("GID of user '%s' and of group '%s' don't match."), PA_SYSTEM_USER, PA_SYSTEM_GROUP);
202 if (strcmp(pw->pw_dir, PA_SYSTEM_RUNTIME_PATH) != 0)
203 pa_log_warn(_("Home directory of user '%s' is not '%s', ignoring."), PA_SYSTEM_USER, PA_SYSTEM_RUNTIME_PATH);
205 if (pa_make_secure_dir(PA_SYSTEM_RUNTIME_PATH, 0755, pw->pw_uid, gr->gr_gid) < 0) {
206 pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_RUNTIME_PATH, pa_cstrerror(errno));
210 if (pa_make_secure_dir(PA_SYSTEM_STATE_PATH, 0700, pw->pw_uid, gr->gr_gid) < 0) {
211 pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_STATE_PATH, pa_cstrerror(errno));
215 /* We don't create the config dir here, because we don't need to write to it */
217 if (initgroups(PA_SYSTEM_USER, gr->gr_gid) != 0) {
218 pa_log(_("Failed to change group list: %s"), pa_cstrerror(errno));
222 #if defined(HAVE_SETRESGID)
223 r = setresgid(gr->gr_gid, gr->gr_gid, gr->gr_gid);
224 #elif defined(HAVE_SETEGID)
225 if ((r = setgid(gr->gr_gid)) >= 0)
226 r = setegid(gr->gr_gid);
227 #elif defined(HAVE_SETREGID)
228 r = setregid(gr->gr_gid, gr->gr_gid);
230 #error "No API to drop privileges"
234 pa_log(_("Failed to change GID: %s"), pa_cstrerror(errno));
238 #if defined(HAVE_SETRESUID)
239 r = setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid);
240 #elif defined(HAVE_SETEUID)
241 if ((r = setuid(pw->pw_uid)) >= 0)
242 r = seteuid(pw->pw_uid);
243 #elif defined(HAVE_SETREUID)
244 r = setreuid(pw->pw_uid, pw->pw_uid);
246 #error "No API to drop privileges"
250 pa_log(_("Failed to change UID: %s"), pa_cstrerror(errno));
254 pa_set_env("USER", PA_SYSTEM_USER);
255 pa_set_env("USERNAME", PA_SYSTEM_USER);
256 pa_set_env("LOGNAME", PA_SYSTEM_USER);
257 pa_set_env("HOME", PA_SYSTEM_RUNTIME_PATH);
259 /* Relevant for pa_runtime_path() */
260 pa_set_env("PULSE_RUNTIME_PATH", PA_SYSTEM_RUNTIME_PATH);
261 pa_set_env("PULSE_CONFIG_PATH", PA_SYSTEM_CONFIG_PATH);
262 pa_set_env("PULSE_STATE_PATH", PA_SYSTEM_STATE_PATH);
264 pa_log_info(_("Successfully dropped root privileges."));
269 #else /* HAVE_PWD_H && HAVE_GRP_H */
271 static int change_user(void) {
272 pa_log(_("System wide mode unsupported on this platform."));
276 #endif /* HAVE_PWD_H && HAVE_GRP_H */
278 #ifdef HAVE_SYS_RESOURCE_H
280 static int set_one_rlimit(const pa_rlimit *r, int resource, const char *name) {
287 rl.rlim_cur = rl.rlim_max = r->value;
289 if (setrlimit(resource, &rl) < 0) {
290 pa_log_info(_("setrlimit(%s, (%u, %u)) failed: %s"), name, (unsigned) r->value, (unsigned) r->value, pa_cstrerror(errno));
297 static void set_all_rlimits(const pa_daemon_conf *conf) {
298 set_one_rlimit(&conf->rlimit_fsize, RLIMIT_FSIZE, "RLIMIT_FSIZE");
299 set_one_rlimit(&conf->rlimit_data, RLIMIT_DATA, "RLIMIT_DATA");
300 set_one_rlimit(&conf->rlimit_stack, RLIMIT_STACK, "RLIMIT_STACK");
301 set_one_rlimit(&conf->rlimit_core, RLIMIT_CORE, "RLIMIT_CORE");
303 set_one_rlimit(&conf->rlimit_rss, RLIMIT_RSS, "RLIMIT_RSS");
306 set_one_rlimit(&conf->rlimit_nproc, RLIMIT_NPROC, "RLIMIT_NPROC");
309 set_one_rlimit(&conf->rlimit_nofile, RLIMIT_NOFILE, "RLIMIT_NOFILE");
311 #ifdef RLIMIT_MEMLOCK
312 set_one_rlimit(&conf->rlimit_memlock, RLIMIT_MEMLOCK, "RLIMIT_MEMLOCK");
315 set_one_rlimit(&conf->rlimit_as, RLIMIT_AS, "RLIMIT_AS");
318 set_one_rlimit(&conf->rlimit_locks, RLIMIT_LOCKS, "RLIMIT_LOCKS");
320 #ifdef RLIMIT_SIGPENDING
321 set_one_rlimit(&conf->rlimit_sigpending, RLIMIT_SIGPENDING, "RLIMIT_SIGPENDING");
323 #ifdef RLIMIT_MSGQUEUE
324 set_one_rlimit(&conf->rlimit_msgqueue, RLIMIT_MSGQUEUE, "RLIMIT_MSGQUEUE");
327 set_one_rlimit(&conf->rlimit_nice, RLIMIT_NICE, "RLIMIT_NICE");
330 set_one_rlimit(&conf->rlimit_rtprio, RLIMIT_RTPRIO, "RLIMIT_RTPRIO");
333 set_one_rlimit(&conf->rlimit_rttime, RLIMIT_RTTIME, "RLIMIT_RTTIME");
339 static pa_dbus_connection *register_dbus_name(pa_core *c, DBusBusType bus, const char* name) {
341 pa_dbus_connection *conn;
343 dbus_error_init(&error);
345 if (!(conn = pa_dbus_bus_get(c, bus, &error)) || dbus_error_is_set(&error)) {
346 pa_log_warn("Unable to contact D-Bus: %s: %s", error.name, error.message);
350 if (dbus_bus_request_name(pa_dbus_connection_get(conn), name, DBUS_NAME_FLAG_DO_NOT_QUEUE, &error) == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
351 pa_log_debug("Got %s!", name);
355 if (dbus_error_is_set(&error))
356 pa_log_error("Failed to acquire %s: %s: %s", name, error.name, error.message);
358 pa_log_error("D-Bus name %s already taken. Weird shit!", name);
360 /* PA cannot be started twice by the same user and hence we can
361 * ignore mostly the case that a name is already taken. */
365 pa_dbus_connection_unref(conn);
367 dbus_error_free(&error);
372 int main(int argc, char *argv[]) {
374 pa_strbuf *buf = NULL;
375 pa_daemon_conf *conf = NULL;
376 pa_mainloop *mainloop = NULL;
378 int r = 0, retval = 1, d = 0;
379 pa_bool_t suid_root, real_root;
380 pa_bool_t valid_pid_file = FALSE;
381 gid_t gid = (gid_t) -1;
382 pa_bool_t ltdl_init = FALSE;
386 int daemon_pipe[2] = { -1, -1 };
389 pa_time_event *win32_timer;
390 struct timeval win32_tv;
392 int autospawn_fd = -1;
393 pa_bool_t autospawn_locked = FALSE;
395 pa_dbusobj_server_lookup *server_lookup = NULL; /* /org/pulseaudio/server_lookup */
396 pa_dbus_connection *lookup_service_bus = NULL; /* Always the user bus. */
397 pa_dbus_connection *server_bus = NULL; /* The bus where we reserve org.pulseaudio.Server, either the user or the system bus. */
398 pa_bool_t start_server;
401 pa_log_set_ident("pulseaudio");
402 pa_log_set_level(PA_LOG_NOTICE);
403 pa_log_set_flags(PA_LOG_COLORS|PA_LOG_PRINT_FILE|PA_LOG_PRINT_LEVEL, PA_LOG_RESET);
405 #if defined(__linux__) && defined(__OPTIMIZE__)
407 Disable lazy relocations to make usage of external libraries
408 more deterministic for our RT threads. We abuse __OPTIMIZE__ as
409 a check whether we are a debug build or not.
412 if (!getenv("LD_BIND_NOW")) {
415 /* We have to execute ourselves, because the libc caches the
416 * value of $LD_BIND_NOW on initialization. */
418 pa_set_env("LD_BIND_NOW", "1");
420 if ((rp = pa_readlink("/proc/self/exe")))
421 pa_assert_se(execv(rp, argv) == 0);
423 pa_log_warn("Couldn't read /proc/self/exe, cannot self execute. Running in a chroot()?");
428 real_root = getuid() == 0;
429 suid_root = !real_root && geteuid() == 0;
436 /* Drop all capabilities except CAP_SYS_NICE */
439 /* Drop privileges, but keep CAP_SYS_NICE */
442 /* After dropping root, the effective set is reset, hence,
443 * let's raise it again */
446 /* When capabilities are not supported we will not be able to
447 * acquire RT sched anymore. But yes, that's the way it is. It
448 * is just too risky tun let PA run as root all the time. */
451 if ((e = getenv("PULSE_PASSED_FD"))) {
458 pa_close_all(passed_fd, -1);
463 /* At this point, we are a normal user, possibly with CAP_NICE if
464 * we were started SUID. If we are started as normal root, than we
465 * still are normal root. */
467 setlocale(LC_ALL, "");
470 conf = pa_daemon_conf_new();
472 if (pa_daemon_conf_load(conf, NULL) < 0)
475 if (pa_daemon_conf_env(conf) < 0)
478 if (pa_cmdline_parse(conf, argc, argv, &d) < 0) {
479 pa_log(_("Failed to parse command line."));
483 pa_log_set_level(conf->log_level);
484 pa_log_set_target(conf->auto_log_target ? PA_LOG_STDERR : conf->log_target);
486 pa_log_set_flags(PA_LOG_PRINT_META, PA_LOG_SET);
488 pa_log_set_flags(PA_LOG_PRINT_TIME, PA_LOG_SET);
489 pa_log_set_show_backtrace(conf->log_backtrace);
492 /* conf->system_instance and conf->local_server_type control almost the
493 * same thing; make them agree about what is requested. */
494 switch (conf->local_server_type) {
495 case PA_SERVER_TYPE_UNSET:
496 conf->local_server_type = conf->system_instance ? PA_SERVER_TYPE_SYSTEM : PA_SERVER_TYPE_USER;
498 case PA_SERVER_TYPE_USER:
499 case PA_SERVER_TYPE_NONE:
500 conf->system_instance = FALSE;
502 case PA_SERVER_TYPE_SYSTEM:
503 conf->system_instance = TRUE;
506 pa_assert_not_reached();
509 start_server = conf->local_server_type == PA_SERVER_TYPE_USER || (real_root && conf->local_server_type == PA_SERVER_TYPE_SYSTEM);
511 if (!start_server && conf->local_server_type == PA_SERVER_TYPE_SYSTEM) {
512 pa_log_notice(_("System mode refused for non-root user. Only starting the D-Bus server lookup service."));
513 conf->system_instance = FALSE;
517 pa_log_debug("Started as real root: %s, suid root: %s", pa_yes_no(real_root), pa_yes_no(suid_root));
520 /* XXX: Uhh, goto programming... as if this wasn't hard enough to follow
521 * already. But if we won't start the full server, we want to just skip all
522 * the capability stuff. */
524 if (!real_root && pa_have_caps())
526 goto after_caps_setup;
530 if (!real_root && pa_have_caps()) {
531 #ifdef HAVE_SYS_RESOURCE_H
534 pa_bool_t allow_high_priority = FALSE, allow_realtime = FALSE;
536 /* Let's better not enable high prio or RT by default */
538 if (conf->high_priority && !allow_high_priority) {
539 if (pa_own_uid_in_group(PA_REALTIME_GROUP, &gid) > 0) {
540 pa_log_info(_("We're in the group '%s', allowing high-priority scheduling."), PA_REALTIME_GROUP);
541 allow_high_priority = TRUE;
545 if (conf->realtime_scheduling && !allow_realtime) {
546 if (pa_own_uid_in_group(PA_REALTIME_GROUP, &gid) > 0) {
547 pa_log_info(_("We're in the group '%s', allowing real-time scheduling."), PA_REALTIME_GROUP);
548 allow_realtime = TRUE;
553 if (conf->high_priority && !allow_high_priority) {
554 if (pa_polkit_check("org.pulseaudio.acquire-high-priority") > 0) {
555 pa_log_info(_("PolicyKit grants us acquire-high-priority privilege."));
556 allow_high_priority = TRUE;
558 pa_log_info(_("PolicyKit refuses acquire-high-priority privilege."));
561 if (conf->realtime_scheduling && !allow_realtime) {
562 if (pa_polkit_check("org.pulseaudio.acquire-real-time") > 0) {
563 pa_log_info(_("PolicyKit grants us acquire-real-time privilege."));
564 allow_realtime = TRUE;
566 pa_log_info(_("PolicyKit refuses acquire-real-time privilege."));
570 if (!allow_high_priority && !allow_realtime) {
572 /* OK, there's no further need to keep CAP_NICE. Hence
573 * let's give it up early */
579 if (getrlimit(RLIMIT_RTPRIO, &rl) >= 0)
580 if (rl.rlim_cur > 0) {
581 pa_log_info("RLIMIT_RTPRIO is set to %u, allowing real-time scheduling.", (unsigned) rl.rlim_cur);
582 allow_realtime = TRUE;
586 if (getrlimit(RLIMIT_NICE, &rl) >= 0)
587 if (rl.rlim_cur > 20 ) {
588 pa_log_info("RLIMIT_NICE is set to %u, allowing high-priority scheduling.", (unsigned) rl.rlim_cur);
589 allow_high_priority = TRUE;
593 if ((conf->high_priority && !allow_high_priority) ||
594 (conf->realtime_scheduling && !allow_realtime))
595 pa_log_info(_("Called SUID root and real-time and/or high-priority scheduling was requested in the configuration. However, we lack the necessary privileges:\n"
596 "We are not in group '%s', PolicyKit refuse to grant us the requested privileges and we have no increase RLIMIT_NICE/RLIMIT_RTPRIO resource limits.\n"
597 "For enabling real-time/high-priority scheduling please acquire the appropriate PolicyKit privileges, or become a member of '%s', or increase the RLIMIT_NICE/RLIMIT_RTPRIO resource limits for this user."),
598 PA_REALTIME_GROUP, PA_REALTIME_GROUP);
602 conf->realtime_scheduling = FALSE;
604 if (!allow_high_priority)
605 conf->high_priority = FALSE;
608 #ifdef HAVE_SYS_RESOURCE_H
609 /* Reset resource limits. If we are run as root (for system mode)
610 * this might end up increasing the limits, which is intended
611 * behaviour. For all other cases, i.e. started as normal user, or
612 * SUID root at this point we should have no CAP_SYS_RESOURCE and
613 * increasing the limits thus should fail. Which is, too, intended
616 set_all_rlimits(conf);
619 if (conf->high_priority && !pa_can_high_priority()) {
620 pa_log_info(_("High-priority scheduling enabled in configuration but not allowed by policy."));
621 conf->high_priority = FALSE;
624 if (conf->high_priority && (conf->cmd == PA_CMD_DAEMON || conf->cmd == PA_CMD_START))
625 pa_raise_priority(conf->nice_level);
627 pa_log_debug("Can realtime: %s, can high-priority: %s", pa_yes_no(pa_can_realtime()), pa_yes_no(pa_can_high_priority()));
629 if (!real_root && pa_have_caps()) {
632 drop = (conf->cmd != PA_CMD_DAEMON && conf->cmd != PA_CMD_START) || !conf->realtime_scheduling;
637 /* At this point we still have CAP_NICE if we were loaded
638 * SUID root. If possible let's acquire RLIMIT_RTPRIO
639 * instead and give CAP_NICE up. */
641 if (getrlimit(RLIMIT_RTPRIO, &rl) >= 0) {
643 if (rl.rlim_cur >= 9)
646 rl.rlim_max = rl.rlim_cur = 9;
648 if (setrlimit(RLIMIT_RTPRIO, &rl) >= 0) {
649 pa_log_info(_("Successfully increased RLIMIT_RTPRIO"));
652 pa_log_warn(_("RLIMIT_RTPRIO failed: %s"), pa_cstrerror(errno));
659 pa_log_info(_("Giving up CAP_NICE"));
665 if (conf->realtime_scheduling && !pa_can_realtime()) {
666 pa_log_info(_("Real-time scheduling enabled in configuration but not allowed by policy."));
667 conf->realtime_scheduling = FALSE;
674 pa_log_debug("Can realtime: %s, can high-priority: %s", pa_yes_no(pa_can_realtime()), pa_yes_no(pa_can_high_priority()));
676 LTDL_SET_PRELOADED_SYMBOLS();
680 if (conf->dl_search_path)
681 lt_dlsetsearchpath(conf->dl_search_path);
686 WSAStartup(MAKEWORD(2, 0), &data);
693 case PA_CMD_DUMP_MODULES:
694 pa_dump_modules(conf, argc-d, argv+d);
698 case PA_CMD_DUMP_CONF: {
699 s = pa_daemon_conf_dump(conf);
706 case PA_CMD_DUMP_RESAMPLE_METHODS: {
709 for (i = 0; i < PA_RESAMPLER_MAX; i++)
710 if (pa_resample_method_supported(i))
711 printf("%s\n", pa_resample_method_to_string(i));
718 pa_cmdline_help(argv[0]);
722 case PA_CMD_VERSION :
723 printf(PACKAGE_NAME" "PACKAGE_VERSION"\n");
730 if (pa_pid_file_check_running(&pid, "pulseaudio") < 0)
731 pa_log_info(_("Daemon not running"));
733 pa_log_info(_("Daemon running as PID %u"), pid);
742 if (pa_pid_file_kill(SIGINT, NULL, "pulseaudio") < 0)
743 pa_log(_("Failed to kill daemon: %s"), pa_cstrerror(errno));
749 case PA_CMD_CLEANUP_SHM:
751 if (pa_shm_cleanup() >= 0)
757 pa_assert(conf->cmd == PA_CMD_DAEMON || conf->cmd == PA_CMD_START);
760 if (real_root && !conf->system_instance)
761 pa_log_warn(_("This program is not intended to be run as root (unless --system is specified)."));
762 #ifndef HAVE_DBUS /* A similar, only a notice worthy check was done earlier, if D-Bus is enabled. */
763 else if (!real_root && conf->system_instance) {
764 pa_log(_("Root privileges required."));
769 if (conf->cmd == PA_CMD_START && conf->system_instance) {
770 pa_log(_("--start not supported for system instances."));
774 if (conf->system_instance && !conf->disallow_exit)
775 pa_log_warn(_("Running in system mode, but --disallow-exit not set!"));
777 if (conf->system_instance && !conf->disallow_module_loading)
778 pa_log_warn(_("Running in system mode, but --disallow-module-loading not set!"));
780 if (conf->system_instance && !conf->disable_shm) {
781 pa_log_notice(_("Running in system mode, forcibly disabling SHM mode!"));
782 conf->disable_shm = TRUE;
785 if (conf->system_instance && conf->exit_idle_time >= 0) {
786 pa_log_notice(_("Running in system mode, forcibly disabling exit idle time!"));
787 conf->exit_idle_time = -1;
790 if (conf->cmd == PA_CMD_START) {
791 /* If we shall start PA only when it is not running yet, we
792 * first take the autospawn lock to make things
795 if ((autospawn_fd = pa_autospawn_lock_init()) < 0) {
796 pa_log("Failed to initialize autospawn lock");
800 if ((pa_autospawn_lock_acquire(TRUE) < 0)) {
801 pa_log("Failed to acquire autospawn lock");
805 autospawn_locked = TRUE;
808 if (conf->daemonize) {
812 if (pa_stdio_acquire() < 0) {
813 pa_log(_("Failed to acquire stdio."));
818 if (pipe(daemon_pipe) < 0) {
819 pa_log(_("pipe failed: %s"), pa_cstrerror(errno));
823 if ((child = fork()) < 0) {
824 pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
832 pa_assert_se(pa_close(daemon_pipe[1]) == 0);
835 if ((n = pa_loop_read(daemon_pipe[0], &retval, sizeof(retval), NULL)) != sizeof(retval)) {
838 pa_log(_("read() failed: %s"), pa_cstrerror(errno));
844 pa_log(_("Daemon startup failed."));
846 pa_log_info(_("Daemon startup successful."));
851 if (autospawn_fd >= 0) {
852 /* The lock file is unlocked from the parent, so we need
853 * to close it in the child */
855 pa_autospawn_lock_release();
856 pa_autospawn_lock_done(TRUE);
858 autospawn_locked = FALSE;
862 pa_assert_se(pa_close(daemon_pipe[0]) == 0);
866 if (conf->auto_log_target)
867 pa_log_set_target(PA_LOG_SYSLOG);
881 pa_assert_se(open("/dev/null", O_RDONLY) == 0);
882 pa_assert_se(open("/dev/null", O_WRONLY) == 1);
883 pa_assert_se(open("/dev/null", O_WRONLY) == 2);
889 signal(SIGTTOU, SIG_IGN);
892 signal(SIGTTIN, SIG_IGN);
895 signal(SIGTSTP, SIG_IGN);
899 if ((tty_fd = open("/dev/tty", O_RDWR)) >= 0) {
900 ioctl(tty_fd, TIOCNOTTY, (char*) 0);
901 pa_assert_se(pa_close(tty_fd) == 0);
906 pa_set_env("PULSE_INTERNAL", "1");
907 pa_assert_se(chdir("/") == 0);
910 if (conf->system_instance)
911 if (change_user() < 0)
914 pa_set_env("PULSE_SYSTEM", conf->system_instance ? "1" : "0");
916 pa_log_info(_("This is PulseAudio %s"), PACKAGE_VERSION);
917 pa_log_debug(_("Compilation host: %s"), CANONICAL_HOST);
918 pa_log_debug(_("Compilation CFLAGS: %s"), PA_CFLAGS);
920 s = pa_uname_string();
921 pa_log_debug(_("Running on host: %s"), s);
924 pa_log_debug(_("Found %u CPUs."), pa_ncpus());
926 pa_log_info(_("Page size is %lu bytes"), (unsigned long) PA_PAGE_SIZE);
928 #ifdef HAVE_VALGRIND_MEMCHECK_H
929 pa_log_debug(_("Compiled with Valgrind support: yes"));
931 pa_log_debug(_("Compiled with Valgrind support: no"));
934 pa_log_debug(_("Running in valgrind mode: %s"), pa_yes_no(pa_in_valgrind()));
937 pa_log_debug(_("Optimized build: yes"));
939 pa_log_debug(_("Optimized build: no"));
943 pa_log_debug(_("NDEBUG defined, all asserts disabled."));
944 #elif defined(FASTPATH)
945 pa_log_debug(_("FASTPATH defined, only fast path asserts disabled."));
947 pa_log_debug(_("All asserts enabled."));
950 if (!(s = pa_machine_id())) {
951 pa_log(_("Failed to get machine ID"));
954 pa_log_info(_("Machine ID is %s."), s);
957 if ((s = pa_session_id())) {
958 pa_log_info(_("Session ID is %s."), s);
962 if (!(s = pa_get_runtime_dir()))
964 pa_log_info(_("Using runtime directory %s."), s);
967 if (!(s = pa_get_state_dir()))
969 pa_log_info(_("Using state directory %s."), s);
972 pa_log_info(_("Running in system mode: %s"), pa_yes_no(pa_in_system_mode()));
974 if (conf->use_pid_file) {
977 if ((z = pa_pid_file_create("pulseaudio")) != 0) {
979 if (conf->cmd == PA_CMD_START && z > 0) {
980 /* If we are already running and with are run in
981 * --start mode, then let's return this as success. */
987 pa_log(_("pa_pid_file_create() failed."));
991 valid_pid_file = TRUE;
994 pa_disable_sigpipe();
996 if (pa_rtclock_hrtimer())
997 pa_log_info(_("Fresh high-resolution timers available! Bon appetit!"));
999 pa_log_info(_("Dude, your kernel stinks! The chef's recommendation today is Linux with high-resolution timers enabled!"));
1001 pa_rtclock_hrtimer_enable();
1004 /* Valgrind uses SIGRTMAX. To easy debugging we don't use it here */
1005 pa_rtsig_configure(SIGRTMIN, SIGRTMAX-1);
1008 pa_memtrap_install();
1010 pa_assert_se(mainloop = pa_mainloop_new());
1012 if (!(c = pa_core_new(pa_mainloop_get_api(mainloop), !conf->disable_shm, conf->shm_size))) {
1013 pa_log(_("pa_core_new() failed."));
1017 c->default_sample_spec = conf->default_sample_spec;
1018 c->default_channel_map = conf->default_channel_map;
1019 c->default_n_fragments = conf->default_n_fragments;
1020 c->default_fragment_size_msec = conf->default_fragment_size_msec;
1021 c->exit_idle_time = conf->exit_idle_time;
1022 c->scache_idle_time = conf->scache_idle_time;
1023 c->resample_method = conf->resample_method;
1024 c->realtime_priority = conf->realtime_priority;
1025 c->realtime_scheduling = !!conf->realtime_scheduling;
1026 c->disable_remixing = !!conf->disable_remixing;
1027 c->disable_lfe_remixing = !!conf->disable_lfe_remixing;
1028 c->running_as_daemon = !!conf->daemonize;
1029 c->disallow_exit = conf->disallow_exit;
1030 c->flat_volumes = conf->flat_volumes;
1031 c->server_type = conf->local_server_type;
1033 pa_assert_se(pa_signal_init(pa_mainloop_get_api(mainloop)) == 0);
1034 pa_signal_new(SIGINT, signal_callback, c);
1035 pa_signal_new(SIGTERM, signal_callback, c);
1037 pa_signal_new(SIGUSR1, signal_callback, c);
1040 pa_signal_new(SIGUSR2, signal_callback, c);
1043 pa_signal_new(SIGHUP, signal_callback, c);
1047 win32_timer = pa_mainloop_get_api(mainloop)->time_new(pa_mainloop_get_api(mainloop), pa_gettimeofday(&win32_tv), message_cb, NULL);
1052 if (!conf->no_cpu_limit)
1053 pa_assert_se(pa_cpu_limit_init(pa_mainloop_get_api(mainloop)) == 0);
1055 buf = pa_strbuf_new();
1060 if (conf->load_default_script_file) {
1063 if ((f = pa_daemon_conf_open_default_script_file(conf))) {
1064 r = pa_cli_command_execute_file_stream(c, f, buf, &conf->fail);
1070 r = pa_cli_command_execute(c, conf->script_commands, buf, &conf->fail);
1072 pa_log_error("%s", s = pa_strbuf_tostring_free(buf));
1075 if (r < 0 && conf->fail) {
1076 pa_log(_("Failed to initialize daemon."));
1080 if (!c->modules || pa_idxset_size(c->modules) == 0) {
1081 pa_log(_("Daemon startup without any loaded modules, refusing to work."));
1086 /* When we just provide the D-Bus server lookup service, we don't want
1087 * any modules to be loaded. We haven't loaded any so far, so one might
1088 * think there's no way to contact the server, but receiving certain
1089 * signals could still cause modules to load. */
1090 conf->disallow_module_loading = TRUE;
1094 /* We completed the initial module loading, so let's disable it
1095 * from now on, if requested */
1096 c->disallow_module_loading = !!conf->disallow_module_loading;
1099 if (daemon_pipe[1] >= 0) {
1101 pa_loop_write(daemon_pipe[1], &ok, sizeof(ok), NULL);
1102 pa_close(daemon_pipe[1]);
1103 daemon_pipe[1] = -1;
1108 if (!conf->system_instance) {
1109 if (!(server_lookup = pa_dbusobj_server_lookup_new(c)))
1111 if (!(lookup_service_bus = register_dbus_name(c, DBUS_BUS_SESSION, "org.pulseaudio.PulseAudio")))
1115 if (start_server && !(server_bus = register_dbus_name(c, conf->system_instance ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, "org.pulseaudio.Server")))
1119 pa_log_info(_("Daemon startup complete."));
1122 if (pa_mainloop_run(mainloop, &retval) < 0)
1125 pa_log_info(_("Daemon shutdown initiated."));
1130 pa_dbus_connection_unref(server_bus);
1131 if (lookup_service_bus)
1132 pa_dbus_connection_unref(lookup_service_bus);
1134 pa_dbusobj_server_lookup_free(server_lookup);
1137 if (autospawn_fd >= 0) {
1138 if (autospawn_locked)
1139 pa_autospawn_lock_release();
1141 pa_autospawn_lock_done(FALSE);
1146 pa_mainloop_get_api(mainloop)->time_free(win32_timer);
1151 pa_log_info(_("Daemon terminated."));
1154 if (!conf->no_cpu_limit)
1155 pa_cpu_limit_done();
1160 if (daemon_pipe[1] >= 0)
1161 pa_loop_write(daemon_pipe[1], &retval, sizeof(retval), NULL);
1163 pa_close_pipe(daemon_pipe);
1167 pa_mainloop_free(mainloop);
1170 pa_daemon_conf_free(conf);
1173 pa_pid_file_remove();