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>
42 #ifdef HAVE_SYS_MMAN_H
46 #ifdef HAVE_SYS_IOCTL_H
47 #include <sys/ioctl.h>
63 #include <dbus/dbus.h>
66 #include <pulse/mainloop.h>
67 #include <pulse/mainloop-signal.h>
68 #include <pulse/timeval.h>
69 #include <pulse/xmalloc.h>
70 #include <pulse/i18n.h>
72 #include <pulsecore/lock-autospawn.h>
73 #include <pulsecore/winsock.h>
74 #include <pulsecore/core-error.h>
75 #include <pulsecore/core-rtclock.h>
76 #include <pulsecore/core.h>
77 #include <pulsecore/memblock.h>
78 #include <pulsecore/module.h>
79 #include <pulsecore/cli-command.h>
80 #include <pulsecore/log.h>
81 #include <pulsecore/core-util.h>
82 #include <pulsecore/sioman.h>
83 #include <pulsecore/cli-text.h>
84 #include <pulsecore/pid.h>
85 #include <pulsecore/namereg.h>
86 #include <pulsecore/random.h>
87 #include <pulsecore/macro.h>
88 #include <pulsecore/mutex.h>
89 #include <pulsecore/thread.h>
90 #include <pulsecore/once.h>
91 #include <pulsecore/shm.h>
92 #include <pulsecore/memtrap.h>
94 #include <pulsecore/dbus-shared.h>
96 #include <pulsecore/cpu-arm.h>
97 #include <pulsecore/cpu-x86.h>
100 #include "cpulimit.h"
101 #include "daemon-conf.h"
102 #include "dumpmodules.h"
104 #include "ltdl-bind-now.h"
105 #include "server-lookup.h"
108 /* Only one instance of these variables */
109 int allow_severity = LOG_INFO;
110 int deny_severity = LOG_WARNING;
113 #ifdef HAVE_OSS_WRAPPER
114 /* padsp looks for this symbol in the running process and disables
115 * itself if it finds it and it is set to 7 (which is actually a bit
116 * mask). For details see padsp. */
117 int __padsp_disabled__ = 7;
122 static void message_cb(pa_mainloop_api*a, pa_time_event*e, const struct timeval *tv, void *userdata) {
124 struct timeval tvnext;
126 while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
127 if (msg.message == WM_QUIT)
130 TranslateMessage(&msg);
131 DispatchMessage(&msg);
135 pa_timeval_add(pa_gettimeofday(&tvnext), 100000);
136 a->rtclock_time_restart(e, &tvnext);
141 static void signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
142 pa_log_info(_("Got signal %s."), pa_sig2str(sig));
147 pa_module_load(userdata, "module-cli", NULL);
153 pa_module_load(userdata, "module-cli-protocol-unix", NULL);
159 char *c = pa_full_status_string(userdata);
160 pa_log_notice("%s", c);
169 pa_log_info(_("Exiting."));
175 #if defined(HAVE_PWD_H) && defined(HAVE_GRP_H)
177 static int change_user(void) {
182 /* This function is called only in system-wide mode. It creates a
183 * runtime dir in /var/run/ with proper UID/GID and drops privs
186 if (!(pw = getpwnam(PA_SYSTEM_USER))) {
187 pa_log(_("Failed to find user '%s'."), PA_SYSTEM_USER);
191 if (!(gr = getgrnam(PA_SYSTEM_GROUP))) {
192 pa_log(_("Failed to find group '%s'."), PA_SYSTEM_GROUP);
196 pa_log_info(_("Found user '%s' (UID %lu) and group '%s' (GID %lu)."),
197 PA_SYSTEM_USER, (unsigned long) pw->pw_uid,
198 PA_SYSTEM_GROUP, (unsigned long) gr->gr_gid);
200 if (pw->pw_gid != gr->gr_gid) {
201 pa_log(_("GID of user '%s' and of group '%s' don't match."), PA_SYSTEM_USER, PA_SYSTEM_GROUP);
205 if (strcmp(pw->pw_dir, PA_SYSTEM_RUNTIME_PATH) != 0)
206 pa_log_warn(_("Home directory of user '%s' is not '%s', ignoring."), PA_SYSTEM_USER, PA_SYSTEM_RUNTIME_PATH);
208 if (pa_make_secure_dir(PA_SYSTEM_RUNTIME_PATH, 0755, pw->pw_uid, gr->gr_gid) < 0) {
209 pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_RUNTIME_PATH, pa_cstrerror(errno));
213 if (pa_make_secure_dir(PA_SYSTEM_STATE_PATH, 0700, pw->pw_uid, gr->gr_gid) < 0) {
214 pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_STATE_PATH, pa_cstrerror(errno));
218 /* We don't create the config dir here, because we don't need to write to it */
220 if (initgroups(PA_SYSTEM_USER, gr->gr_gid) != 0) {
221 pa_log(_("Failed to change group list: %s"), pa_cstrerror(errno));
225 #if defined(HAVE_SETRESGID)
226 r = setresgid(gr->gr_gid, gr->gr_gid, gr->gr_gid);
227 #elif defined(HAVE_SETEGID)
228 if ((r = setgid(gr->gr_gid)) >= 0)
229 r = setegid(gr->gr_gid);
230 #elif defined(HAVE_SETREGID)
231 r = setregid(gr->gr_gid, gr->gr_gid);
233 #error "No API to drop privileges"
237 pa_log(_("Failed to change GID: %s"), pa_cstrerror(errno));
241 #if defined(HAVE_SETRESUID)
242 r = setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid);
243 #elif defined(HAVE_SETEUID)
244 if ((r = setuid(pw->pw_uid)) >= 0)
245 r = seteuid(pw->pw_uid);
246 #elif defined(HAVE_SETREUID)
247 r = setreuid(pw->pw_uid, pw->pw_uid);
249 #error "No API to drop privileges"
253 pa_log(_("Failed to change UID: %s"), pa_cstrerror(errno));
257 pa_set_env("USER", PA_SYSTEM_USER);
258 pa_set_env("USERNAME", PA_SYSTEM_USER);
259 pa_set_env("LOGNAME", PA_SYSTEM_USER);
260 pa_set_env("HOME", PA_SYSTEM_RUNTIME_PATH);
262 /* Relevant for pa_runtime_path() */
263 if (!getenv("PULSE_RUNTIME_PATH"))
264 pa_set_env("PULSE_RUNTIME_PATH", PA_SYSTEM_RUNTIME_PATH);
266 if (!getenv("PULSE_CONFIG_PATH"))
267 pa_set_env("PULSE_CONFIG_PATH", PA_SYSTEM_CONFIG_PATH);
269 if (!getenv("PULSE_STATE_PATH"))
270 pa_set_env("PULSE_STATE_PATH", PA_SYSTEM_STATE_PATH);
272 pa_log_info(_("Successfully dropped root privileges."));
277 #else /* HAVE_PWD_H && HAVE_GRP_H */
279 static int change_user(void) {
280 pa_log(_("System wide mode unsupported on this platform."));
284 #endif /* HAVE_PWD_H && HAVE_GRP_H */
286 #ifdef HAVE_SYS_RESOURCE_H
288 static int set_one_rlimit(const pa_rlimit *r, int resource, const char *name) {
295 rl.rlim_cur = rl.rlim_max = r->value;
297 if (setrlimit(resource, &rl) < 0) {
298 pa_log_info(_("setrlimit(%s, (%u, %u)) failed: %s"), name, (unsigned) r->value, (unsigned) r->value, pa_cstrerror(errno));
305 static void set_all_rlimits(const pa_daemon_conf *conf) {
306 set_one_rlimit(&conf->rlimit_fsize, RLIMIT_FSIZE, "RLIMIT_FSIZE");
307 set_one_rlimit(&conf->rlimit_data, RLIMIT_DATA, "RLIMIT_DATA");
308 set_one_rlimit(&conf->rlimit_stack, RLIMIT_STACK, "RLIMIT_STACK");
309 set_one_rlimit(&conf->rlimit_core, RLIMIT_CORE, "RLIMIT_CORE");
311 set_one_rlimit(&conf->rlimit_rss, RLIMIT_RSS, "RLIMIT_RSS");
314 set_one_rlimit(&conf->rlimit_nproc, RLIMIT_NPROC, "RLIMIT_NPROC");
317 set_one_rlimit(&conf->rlimit_nofile, RLIMIT_NOFILE, "RLIMIT_NOFILE");
319 #ifdef RLIMIT_MEMLOCK
320 set_one_rlimit(&conf->rlimit_memlock, RLIMIT_MEMLOCK, "RLIMIT_MEMLOCK");
323 set_one_rlimit(&conf->rlimit_as, RLIMIT_AS, "RLIMIT_AS");
326 set_one_rlimit(&conf->rlimit_locks, RLIMIT_LOCKS, "RLIMIT_LOCKS");
328 #ifdef RLIMIT_SIGPENDING
329 set_one_rlimit(&conf->rlimit_sigpending, RLIMIT_SIGPENDING, "RLIMIT_SIGPENDING");
331 #ifdef RLIMIT_MSGQUEUE
332 set_one_rlimit(&conf->rlimit_msgqueue, RLIMIT_MSGQUEUE, "RLIMIT_MSGQUEUE");
335 set_one_rlimit(&conf->rlimit_nice, RLIMIT_NICE, "RLIMIT_NICE");
338 set_one_rlimit(&conf->rlimit_rtprio, RLIMIT_RTPRIO, "RLIMIT_RTPRIO");
341 set_one_rlimit(&conf->rlimit_rttime, RLIMIT_RTTIME, "RLIMIT_RTTIME");
347 static pa_dbus_connection *register_dbus_name(pa_core *c, DBusBusType bus, const char* name) {
349 pa_dbus_connection *conn;
351 dbus_error_init(&error);
353 if (!(conn = pa_dbus_bus_get(c, bus, &error)) || dbus_error_is_set(&error)) {
354 pa_log_warn("Unable to contact D-Bus: %s: %s", error.name, error.message);
358 if (dbus_bus_request_name(pa_dbus_connection_get(conn), name, DBUS_NAME_FLAG_DO_NOT_QUEUE, &error) == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
359 pa_log_debug("Got %s!", name);
363 if (dbus_error_is_set(&error))
364 pa_log_error("Failed to acquire %s: %s: %s", name, error.name, error.message);
366 pa_log_error("D-Bus name %s already taken. Weird shit!", name);
368 /* PA cannot be started twice by the same user and hence we can
369 * ignore mostly the case that a name is already taken. */
373 pa_dbus_connection_unref(conn);
375 dbus_error_free(&error);
380 int main(int argc, char *argv[]) {
382 pa_strbuf *buf = NULL;
383 pa_daemon_conf *conf = NULL;
384 pa_mainloop *mainloop = NULL;
386 int r = 0, retval = 1, d = 0;
387 pa_bool_t valid_pid_file = FALSE;
388 pa_bool_t ltdl_init = FALSE;
392 int daemon_pipe[2] = { -1, -1 };
395 pa_time_event *win32_timer;
396 struct timeval win32_tv;
398 int autospawn_fd = -1;
399 pa_bool_t autospawn_locked = FALSE;
401 pa_dbusobj_server_lookup *server_lookup = NULL; /* /org/pulseaudio/server_lookup */
402 pa_dbus_connection *lookup_service_bus = NULL; /* Always the user bus. */
403 pa_dbus_connection *server_bus = NULL; /* The bus where we reserve org.pulseaudio.Server, either the user or the system bus. */
404 pa_bool_t start_server;
407 pa_log_set_ident("pulseaudio");
408 pa_log_set_level(PA_LOG_NOTICE);
409 pa_log_set_flags(PA_LOG_COLORS|PA_LOG_PRINT_FILE|PA_LOG_PRINT_LEVEL, PA_LOG_RESET);
411 #if defined(__linux__) && defined(__OPTIMIZE__)
413 Disable lazy relocations to make usage of external libraries
414 more deterministic for our RT threads. We abuse __OPTIMIZE__ as
415 a check whether we are a debug build or not. This all is
416 admittedly a bit snake-oilish.
419 if (!getenv("LD_BIND_NOW")) {
423 /* We have to execute ourselves, because the libc caches the
424 * value of $LD_BIND_NOW on initialization. */
426 pa_set_env("LD_BIND_NOW", "1");
428 if ((canonical_rp = pa_realpath(PA_BINARY))) {
430 if ((rp = pa_readlink("/proc/self/exe"))) {
432 if (pa_streq(rp, canonical_rp))
433 pa_assert_se(execv(rp, argv) == 0);
435 pa_log_warn("/proc/self/exe does not point to %s, cannot self execute. Are you playing games?", canonical_rp);
440 pa_log_warn("Couldn't read /proc/self/exe, cannot self execute. Running in a chroot()?");
442 pa_xfree(canonical_rp);
445 pa_log_warn("Couldn't canonicalize binary path, cannot self execute.");
449 if ((e = getenv("PULSE_PASSED_FD"))) {
456 /* We might be autospawned, in which case have no idea in which
457 * context we have been started. Let's cleanup our execution
458 * context as good as possible */
460 pa_reset_personality();
462 pa_close_all(passed_fd, -1);
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 || (getuid() == 0 && 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 LTDL_SET_PRELOADED_SYMBOLS();
521 if (conf->dl_search_path)
522 lt_dlsetsearchpath(conf->dl_search_path);
527 WSAStartup(MAKEWORD(2, 0), &data);
534 case PA_CMD_DUMP_MODULES:
535 pa_dump_modules(conf, argc-d, argv+d);
539 case PA_CMD_DUMP_CONF: {
542 pa_log("Too many arguments.\n");
546 s = pa_daemon_conf_dump(conf);
553 case PA_CMD_DUMP_RESAMPLE_METHODS: {
557 pa_log("Too many arguments.\n");
561 for (i = 0; i < PA_RESAMPLER_MAX; i++)
562 if (pa_resample_method_supported(i))
563 printf("%s\n", pa_resample_method_to_string(i));
570 pa_cmdline_help(argv[0]);
574 case PA_CMD_VERSION :
577 pa_log("Too many arguments.\n");
581 printf(PACKAGE_NAME" "PACKAGE_VERSION"\n");
589 pa_log("Too many arguments.\n");
593 if (pa_pid_file_check_running(&pid, "pulseaudio") < 0)
594 pa_log_info(_("Daemon not running"));
596 pa_log_info(_("Daemon running as PID %u"), pid);
606 pa_log("Too many arguments.\n");
610 if (pa_pid_file_kill(SIGINT, NULL, "pulseaudio") < 0)
611 pa_log(_("Failed to kill daemon: %s"), pa_cstrerror(errno));
617 case PA_CMD_CLEANUP_SHM:
620 pa_log("Too many arguments.\n");
624 if (pa_shm_cleanup() >= 0)
630 pa_assert(conf->cmd == PA_CMD_DAEMON || conf->cmd == PA_CMD_START);
634 pa_log("Too many arguments.\n");
638 if (getuid() == 0 && !conf->system_instance)
639 pa_log_warn(_("This program is not intended to be run as root (unless --system is specified)."));
640 #ifndef HAVE_DBUS /* A similar, only a notice worthy check was done earlier, if D-Bus is enabled. */
641 else if (getuid() != 0 && conf->system_instance) {
642 pa_log(_("Root privileges required."));
647 if (conf->cmd == PA_CMD_START && conf->system_instance) {
648 pa_log(_("--start not supported for system instances."));
652 if (conf->system_instance && !conf->disallow_exit)
653 pa_log_warn(_("Running in system mode, but --disallow-exit not set!"));
655 if (conf->system_instance && !conf->disallow_module_loading)
656 pa_log_warn(_("Running in system mode, but --disallow-module-loading not set!"));
658 if (conf->system_instance && !conf->disable_shm) {
659 pa_log_notice(_("Running in system mode, forcibly disabling SHM mode!"));
660 conf->disable_shm = TRUE;
663 if (conf->system_instance && conf->exit_idle_time >= 0) {
664 pa_log_notice(_("Running in system mode, forcibly disabling exit idle time!"));
665 conf->exit_idle_time = -1;
668 if (conf->cmd == PA_CMD_START) {
669 /* If we shall start PA only when it is not running yet, we
670 * first take the autospawn lock to make things
673 if ((autospawn_fd = pa_autospawn_lock_init()) < 0) {
674 pa_log("Failed to initialize autospawn lock");
678 if ((pa_autospawn_lock_acquire(TRUE) < 0)) {
679 pa_log("Failed to acquire autospawn lock");
683 autospawn_locked = TRUE;
686 if (conf->daemonize) {
689 if (pa_stdio_acquire() < 0) {
690 pa_log(_("Failed to acquire stdio."));
695 if (pipe(daemon_pipe) < 0) {
696 pa_log(_("pipe() failed: %s"), pa_cstrerror(errno));
700 if ((child = fork()) < 0) {
701 pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
709 pa_assert_se(pa_close(daemon_pipe[1]) == 0);
712 if ((n = pa_loop_read(daemon_pipe[0], &retval, sizeof(retval), NULL)) != sizeof(retval)) {
715 pa_log(_("read() failed: %s"), pa_cstrerror(errno));
721 pa_log(_("Daemon startup failed."));
723 pa_log_info(_("Daemon startup successful."));
728 if (autospawn_fd >= 0) {
729 /* The lock file is unlocked from the parent, so we need
730 * to close it in the child */
732 pa_autospawn_lock_release();
733 pa_autospawn_lock_done(TRUE);
735 autospawn_locked = FALSE;
739 pa_assert_se(pa_close(daemon_pipe[0]) == 0);
743 if (conf->auto_log_target)
744 pa_log_set_target(PA_LOG_SYSLOG);
748 pa_log(_("setsid() failed: %s"), pa_cstrerror(errno));
753 /* We now are a session and process group leader. Let's fork
754 * again and let the father die, so that we'll become a
755 * process that can never acquire a TTY again, in a session and
756 * process group without leader */
759 if ((child = fork()) < 0) {
760 pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
771 signal(SIGTTOU, SIG_IGN);
774 signal(SIGTTIN, SIG_IGN);
777 signal(SIGTSTP, SIG_IGN);
783 pa_set_env_and_record("PULSE_INTERNAL", "1");
784 pa_assert_se(chdir("/") == 0);
787 #ifdef HAVE_SYS_RESOURCE_H
788 set_all_rlimits(conf);
790 pa_rtclock_hrtimer_enable();
792 pa_raise_priority(conf->nice_level);
794 if (conf->system_instance)
795 if (change_user() < 0)
798 pa_set_env_and_record("PULSE_SYSTEM", conf->system_instance ? "1" : "0");
800 pa_log_info(_("This is PulseAudio %s"), PACKAGE_VERSION);
801 pa_log_debug(_("Compilation host: %s"), CANONICAL_HOST);
802 pa_log_debug(_("Compilation CFLAGS: %s"), PA_CFLAGS);
804 s = pa_uname_string();
805 pa_log_debug(_("Running on host: %s"), s);
808 pa_log_debug(_("Found %u CPUs."), pa_ncpus());
810 pa_log_info(_("Page size is %lu bytes"), (unsigned long) PA_PAGE_SIZE);
812 #ifdef HAVE_VALGRIND_MEMCHECK_H
813 pa_log_debug(_("Compiled with Valgrind support: yes"));
815 pa_log_debug(_("Compiled with Valgrind support: no"));
818 pa_log_debug(_("Running in valgrind mode: %s"), pa_yes_no(pa_in_valgrind()));
820 pa_log_debug(_("Running in VM: %s"), pa_yes_no(pa_running_in_vm()));
823 pa_log_debug(_("Optimized build: yes"));
825 pa_log_debug(_("Optimized build: no"));
829 pa_log_debug(_("NDEBUG defined, all asserts disabled."));
830 #elif defined(FASTPATH)
831 pa_log_debug(_("FASTPATH defined, only fast path asserts disabled."));
833 pa_log_debug(_("All asserts enabled."));
836 if (!(s = pa_machine_id())) {
837 pa_log(_("Failed to get machine ID"));
840 pa_log_info(_("Machine ID is %s."), s);
843 if ((s = pa_session_id())) {
844 pa_log_info(_("Session ID is %s."), s);
848 if (!(s = pa_get_runtime_dir()))
850 pa_log_info(_("Using runtime directory %s."), s);
853 if (!(s = pa_get_state_dir()))
855 pa_log_info(_("Using state directory %s."), s);
858 pa_log_info(_("Using modules directory %s."), conf->dl_search_path);
860 pa_log_info(_("Running in system mode: %s"), pa_yes_no(pa_in_system_mode()));
862 if (pa_in_system_mode())
863 pa_log_warn(_("OK, so you are running PA in system mode. Please note that you most likely shouldn't be doing that.\n"
864 "If you do it nonetheless then it's your own fault if things don't work as expected.\n"
865 "Please read http://pulseaudio.org/wiki/WhatIsWrongWithSystemMode for an explanation why system mode is usually a bad idea."));
867 if (conf->use_pid_file) {
870 if ((z = pa_pid_file_create("pulseaudio")) != 0) {
872 if (conf->cmd == PA_CMD_START && z > 0) {
873 /* If we are already running and with are run in
874 * --start mode, then let's return this as success. */
880 pa_log(_("pa_pid_file_create() failed."));
884 valid_pid_file = TRUE;
887 pa_disable_sigpipe();
889 if (pa_rtclock_hrtimer())
890 pa_log_info(_("Fresh high-resolution timers available! Bon appetit!"));
892 pa_log_info(_("Dude, your kernel stinks! The chef's recommendation today is Linux with high-resolution timers enabled!"));
894 if (conf->lock_memory) {
895 #ifdef HAVE_SYS_MMAN_H
896 if (mlockall(MCL_FUTURE) < 0)
897 pa_log_warn("mlockall() failed: %s", pa_cstrerror(errno));
899 pa_log_info("Sucessfully locked process into memory.");
901 pa_log_warn("Memory locking requested but not supported on platform.");
905 pa_memtrap_install();
907 if (!getenv("PULSE_NO_SIMD")) {
912 pa_assert_se(mainloop = pa_mainloop_new());
914 if (!(c = pa_core_new(pa_mainloop_get_api(mainloop), !conf->disable_shm, conf->shm_size))) {
915 pa_log(_("pa_core_new() failed."));
919 c->default_sample_spec = conf->default_sample_spec;
920 c->default_channel_map = conf->default_channel_map;
921 c->default_n_fragments = conf->default_n_fragments;
922 c->default_fragment_size_msec = conf->default_fragment_size_msec;
923 c->exit_idle_time = conf->exit_idle_time;
924 c->scache_idle_time = conf->scache_idle_time;
925 c->resample_method = conf->resample_method;
926 c->realtime_priority = conf->realtime_priority;
927 c->realtime_scheduling = !!conf->realtime_scheduling;
928 c->disable_remixing = !!conf->disable_remixing;
929 c->disable_lfe_remixing = !!conf->disable_lfe_remixing;
930 c->running_as_daemon = !!conf->daemonize;
931 c->disallow_exit = conf->disallow_exit;
932 c->flat_volumes = conf->flat_volumes;
934 c->server_type = conf->local_server_type;
937 pa_assert_se(pa_signal_init(pa_mainloop_get_api(mainloop)) == 0);
938 pa_signal_new(SIGINT, signal_callback, c);
939 pa_signal_new(SIGTERM, signal_callback, c);
941 pa_signal_new(SIGUSR1, signal_callback, c);
944 pa_signal_new(SIGUSR2, signal_callback, c);
947 pa_signal_new(SIGHUP, signal_callback, c);
951 win32_timer = pa_mainloop_get_api(mainloop)->rtclock_time_new(pa_mainloop_get_api(mainloop), pa_gettimeofday(&win32_tv), message_cb, NULL);
954 if (!conf->no_cpu_limit)
955 pa_assert_se(pa_cpu_limit_init(pa_mainloop_get_api(mainloop)) == 0);
957 buf = pa_strbuf_new();
962 if (conf->load_default_script_file) {
965 if ((f = pa_daemon_conf_open_default_script_file(conf))) {
966 r = pa_cli_command_execute_file_stream(c, f, buf, &conf->fail);
972 r = pa_cli_command_execute(c, conf->script_commands, buf, &conf->fail);
974 pa_log_error("%s", s = pa_strbuf_tostring_free(buf));
977 if (r < 0 && conf->fail) {
978 pa_log(_("Failed to initialize daemon."));
982 if (!c->modules || pa_idxset_size(c->modules) == 0) {
983 pa_log(_("Daemon startup without any loaded modules, refusing to work."));
988 /* When we just provide the D-Bus server lookup service, we don't want
989 * any modules to be loaded. We haven't loaded any so far, so one might
990 * think there's no way to contact the server, but receiving certain
991 * signals could still cause modules to load. */
992 conf->disallow_module_loading = TRUE;
996 /* We completed the initial module loading, so let's disable it
997 * from now on, if requested */
998 c->disallow_module_loading = !!conf->disallow_module_loading;
1001 if (daemon_pipe[1] >= 0) {
1003 pa_loop_write(daemon_pipe[1], &ok, sizeof(ok), NULL);
1004 pa_close(daemon_pipe[1]);
1005 daemon_pipe[1] = -1;
1010 if (!conf->system_instance) {
1011 if (!(server_lookup = pa_dbusobj_server_lookup_new(c)))
1013 if (!(lookup_service_bus = register_dbus_name(c, DBUS_BUS_SESSION, "org.PulseAudio1")))
1017 if (start_server && !(server_bus = register_dbus_name(c, conf->system_instance ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, "org.pulseaudio.Server")))
1021 pa_log_info(_("Daemon startup complete."));
1024 if (pa_mainloop_run(mainloop, &retval) < 0)
1027 pa_log_info(_("Daemon shutdown initiated."));
1032 pa_dbus_connection_unref(server_bus);
1033 if (lookup_service_bus)
1034 pa_dbus_connection_unref(lookup_service_bus);
1036 pa_dbusobj_server_lookup_free(server_lookup);
1039 if (autospawn_fd >= 0) {
1040 if (autospawn_locked)
1041 pa_autospawn_lock_release();
1043 pa_autospawn_lock_done(FALSE);
1048 pa_mainloop_get_api(mainloop)->time_free(win32_timer);
1053 pa_log_info(_("Daemon terminated."));
1056 if (!conf->no_cpu_limit)
1057 pa_cpu_limit_done();
1062 if (daemon_pipe[1] >= 0)
1063 pa_loop_write(daemon_pipe[1], &retval, sizeof(retval), NULL);
1065 pa_close_pipe(daemon_pipe);
1069 pa_mainloop_free(mainloop);
1072 pa_daemon_conf_free(conf);
1075 pa_pid_file_remove();
1077 /* This has no real purpose except making things valgrind-clean */
1078 pa_unset_env_recorded();