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, see <http://www.gnu.org/licenses/>.
19 ***/
20
21 #ifdef HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24
25 #include <unistd.h>
26 #include <errno.h>
27 #include <string.h>
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <signal.h>
31 #include <stddef.h>
32 #include <ltdl.h>
33 #include <limits.h>
34 #include <unistd.h>
35 #include <locale.h>
36 #include <sys/types.h>
37 #include <sys/stat.h>
38
39 #ifdef HAVE_SYS_MMAN_H
40 #include <sys/mman.h>
41 #endif
42
43 #ifdef HAVE_PWD_H
44 #include <pwd.h>
45 #endif
46 #ifdef HAVE_GRP_H
47 #include <grp.h>
48 #endif
49
50 #ifdef HAVE_LIBWRAP
51 #include <syslog.h>
52 #include <tcpd.h>
53 #endif
54
55 #ifdef HAVE_DBUS
56 #include <dbus/dbus.h>
57 #endif
58
59 #ifdef HAVE_SYSTEMD_DAEMON
60 #include <systemd/sd-daemon.h>
61 #endif
62
63 #ifdef HAVE_WINDOWS_H
64 #include <windows.h>
65 #include <aclapi.h>
66 #include <sddl.h>
67 #endif
68
69 #include <pulse/client-conf.h>
70 #include <pulse/mainloop.h>
71 #include <pulse/mainloop-signal.h>
72 #include <pulse/timeval.h>
73 #include <pulse/xmalloc.h>
74
75 #include <pulsecore/i18n.h>
76 #include <pulsecore/lock-autospawn.h>
77 #include <pulsecore/socket.h>
78 #include <pulsecore/core-error.h>
79 #include <pulsecore/core-rtclock.h>
80 #include <pulsecore/core-scache.h>
81 #include <pulsecore/core.h>
82 #include <pulsecore/module.h>
83 #include <pulsecore/cli-command.h>
84 #include <pulsecore/log.h>
85 #include <pulsecore/core-util.h>
86 #include <pulsecore/sioman.h>
87 #include <pulsecore/cli-text.h>
88 #include <pulsecore/pid.h>
89 #include <pulsecore/random.h>
90 #include <pulsecore/macro.h>
91 #include <pulsecore/shm.h>
92 #include <pulsecore/memtrap.h>
93 #include <pulsecore/strlist.h>
94 #ifdef HAVE_DBUS
95 #include <pulsecore/dbus-shared.h>
96 #endif
97 #include <pulsecore/cpu.h>
98
99 #include "cmdline.h"
100 #include "cpulimit.h"
101 #include "daemon-conf.h"
102 #include "dumpmodules.h"
103 #include "caps.h"
104 #include "ltdl-bind-now.h"
105 #include "server-lookup.h"
106
107 #ifdef DISABLE_LIBTOOL_PRELOAD
108 /* FIXME: work around a libtool bug by making sure we have 2 elements. Bug has
109 * been reported: https://debbugs.gnu.org/cgi/bugreport.cgi?bug=29576 */
110 LT_DLSYM_CONST lt_dlsymlist lt_preloaded_symbols[] = {
111 { "@PROGRAM@", NULL },
112 { NULL, NULL }
113 };
114 #endif
115
116 #ifdef HAVE_LIBWRAP
117 /* Only one instance of these variables */
118 int allow_severity = LOG_INFO;
119 int deny_severity = LOG_WARNING;
120 #endif
121
122 #ifdef HAVE_OSS_WRAPPER
123 /* padsp looks for this symbol in the running process and disables
124 * itself if it finds it and it is set to 7 (which is actually a bit
125 * mask). For details see padsp. */
126 int __padsp_disabled__ = 7;
127 #endif
128
signal_callback(pa_mainloop_api * m,pa_signal_event * e,int sig,void * userdata)129 static void signal_callback(pa_mainloop_api* m, pa_signal_event *e, int sig, void *userdata) {
130 pa_module *module = NULL;
131
132 pa_log_info("Got signal %s.", pa_sig2str(sig));
133
134 switch (sig) {
135 #ifdef SIGUSR1
136 case SIGUSR1:
137 pa_module_load(&module, userdata, "module-cli", NULL);
138 break;
139 #endif
140
141 #ifdef SIGUSR2
142 case SIGUSR2:
143 pa_module_load(&module, userdata, "module-cli-protocol-unix", NULL);
144 break;
145 #endif
146
147 #ifdef SIGHUP
148 case SIGHUP: {
149 char *c = pa_full_status_string(userdata);
150 pa_log_notice("%s", c);
151 pa_xfree(c);
152 return;
153 }
154 #endif
155
156 case SIGINT:
157 case SIGTERM:
158 default:
159 pa_log_info("Exiting.");
160 m->quit(m, 0);
161 break;
162 }
163 }
164
165
166 #if defined(OS_IS_WIN32)
167
change_user(void)168 static int change_user(void) {
169 pa_log_info("Overriding system runtime/config base dir to '%s'.", pa_win32_get_system_appdata());
170
171 /* On other platforms, these paths are compiled into PulseAudio. This isn't
172 * suitable on Windows. Firstly, Windows doesn't follow the FHS or use Unix
173 * paths and the build system can't handle Windows-style paths properly.
174 * Secondly, the idiomatic location for a service's state and shared data is
175 * ProgramData, and the location of special folders is dynamic on Windows.
176 * Also, this method of handling paths is consistent with how they are
177 * handled on Windows in other parts of PA. Note that this is only needed
178 * in system-wide mode since paths in user instances are already handled
179 * properly.
180 */
181
182 char *run_path = pa_sprintf_malloc("%s" PA_PATH_SEP "run", pa_win32_get_system_appdata());
183 char *lib_path = pa_sprintf_malloc("%s" PA_PATH_SEP "lib", pa_win32_get_system_appdata());
184
185 /* https://docs.microsoft.com/en-us/windows/win32/secauthz/ace-strings */
186 /* https://docs.microsoft.com/en-us/windows/win32/secauthz/modifying-the-acls-of-an-object-in-c-- */
187 /* https://docs.microsoft.com/en-us/windows/win32/api/sddl/nf-sddl-convertstringsecuritydescriptortosecuritydescriptora */
188 {
189 mkdir(run_path);
190 PSECURITY_DESCRIPTOR sd;
191 if (ConvertStringSecurityDescriptorToSecurityDescriptorA(
192 "D:PAI" /* DACL, disable inheritance from parent, enable propagation to children */
193 "(A;OICI;FA;;;SY)" /* give system full access */
194 "(A;OICI;FA;;;CO)" /* give owner full access */
195 "(A;OICI;FA;;;BA)" /* give administrators full access */
196 "(A;OICI;0x1200a9;;;WD)", /* give everyone read/write/execute access */
197 SDDL_REVISION_1, &sd, NULL
198 )) {
199 PACL acl;
200 BOOL acl_present, acl_default;
201 if (GetSecurityDescriptorDacl(sd, &acl_present, &acl, &acl_default)) {
202 if (SetNamedSecurityInfo(run_path, SE_FILE_OBJECT, DACL_SECURITY_INFORMATION | PROTECTED_DACL_SECURITY_INFORMATION, NULL, NULL, acl, NULL) != ERROR_SUCCESS) {
203 pa_log_warn("Failed to set DACL for runtime dir: failed to apply DACL: error %lu.", GetLastError());
204 }
205 LocalFree(acl);
206 } else {
207 pa_log_warn("Failed to set DACL for runtime dir: failed to get security descriptor DACL: error %lu.", GetLastError());
208 }
209 } else {
210 pa_log_warn("Failed to set DACL for runtime dir: failed to parse security descriptor: error %lu.", GetLastError());
211 }
212 }
213 {
214 mkdir(lib_path);
215 PSECURITY_DESCRIPTOR sd;
216 if (ConvertStringSecurityDescriptorToSecurityDescriptorA(
217 "D:PAI" /* DACL, disable inheritance from parent, enable propagation to children */
218 "(A;OICI;FA;;;SY)" /* give system full access */
219 "(A;OICI;FA;;;CO)" /* give owner full access */
220 "(A;OICI;FA;;;BA)", /* give administrators full access */
221 SDDL_REVISION_1, &sd, NULL
222 )) {
223 PACL acl;
224 BOOL acl_present, acl_default;
225 if (GetSecurityDescriptorDacl(sd, &acl_present, &acl, &acl_default)) {
226 if (SetNamedSecurityInfo(lib_path, SE_FILE_OBJECT, DACL_SECURITY_INFORMATION | PROTECTED_DACL_SECURITY_INFORMATION, NULL, NULL, acl, NULL) != ERROR_SUCCESS) {
227 pa_log_warn("Failed to set DACL for lib dir: failed to apply DACL: error %lu.", GetLastError());
228 }
229 LocalFree(acl);
230 } else {
231 pa_log_warn("Failed to set DACL for lib dir: failed to get security descriptor DACL: error %lu.", GetLastError());
232 }
233 } else {
234 pa_log_warn("Failed to set DACL for lib dir: failed to parse security descriptor: error %lu.", GetLastError());
235 }
236 }
237
238 pa_set_env("HOME", run_path);
239 if (!getenv("PULSE_RUNTIME_PATH"))
240 pa_set_env("PULSE_RUNTIME_PATH", run_path);
241 if (!getenv("PULSE_CONFIG_PATH"))
242 pa_set_env("PULSE_CONFIG_PATH", lib_path);
243 if (!getenv("PULSE_STATE_PATH"))
244 pa_set_env("PULSE_STATE_PATH", lib_path);
245
246 pa_xfree(run_path);
247 pa_xfree(lib_path);
248
249 pa_log_info("Not changing user for system instance on Windows.");
250 return 0;
251 }
252
253 #elif defined(HAVE_PWD_H) && defined(HAVE_GRP_H)
254
change_user(void)255 static int change_user(void) {
256 struct passwd *pw;
257 struct group * gr;
258 int r;
259
260 /* This function is called only in system-wide mode. It creates a
261 * runtime dir in /var/run/ with proper UID/GID and drops privs
262 * afterwards. */
263
264 if (!(pw = getpwnam(PA_SYSTEM_USER))) {
265 pa_log(_("Failed to find user '%s'."), PA_SYSTEM_USER);
266 return -1;
267 }
268
269 if (!(gr = getgrnam(PA_SYSTEM_GROUP))) {
270 pa_log(_("Failed to find group '%s'."), PA_SYSTEM_GROUP);
271 return -1;
272 }
273
274 pa_log_info("Found user '%s' (UID %lu) and group '%s' (GID %lu).",
275 PA_SYSTEM_USER, (unsigned long) pw->pw_uid,
276 PA_SYSTEM_GROUP, (unsigned long) gr->gr_gid);
277
278 if (pw->pw_gid != gr->gr_gid) {
279 pa_log(_("GID of user '%s' and of group '%s' don't match."), PA_SYSTEM_USER, PA_SYSTEM_GROUP);
280 return -1;
281 }
282
283 if (!pa_streq(pw->pw_dir, PA_SYSTEM_RUNTIME_PATH))
284 pa_log_warn(_("Home directory of user '%s' is not '%s', ignoring."), PA_SYSTEM_USER, PA_SYSTEM_RUNTIME_PATH);
285
286 if (pa_make_secure_dir(PA_SYSTEM_RUNTIME_PATH, 0755, pw->pw_uid, gr->gr_gid, true) < 0) {
287 pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_RUNTIME_PATH, pa_cstrerror(errno));
288 return -1;
289 }
290
291 if (pa_make_secure_dir(PA_SYSTEM_STATE_PATH, 0700, pw->pw_uid, gr->gr_gid, true) < 0) {
292 pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_STATE_PATH, pa_cstrerror(errno));
293 return -1;
294 }
295
296 /* We don't create the config dir here, because we don't need to write to it */
297
298 if (initgroups(PA_SYSTEM_USER, gr->gr_gid) != 0) {
299 pa_log(_("Failed to change group list: %s"), pa_cstrerror(errno));
300 return -1;
301 }
302
303 #if defined(HAVE_SETRESGID)
304 r = setresgid(gr->gr_gid, gr->gr_gid, gr->gr_gid);
305 #elif defined(HAVE_SETEGID)
306 if ((r = setgid(gr->gr_gid)) >= 0)
307 r = setegid(gr->gr_gid);
308 #elif defined(HAVE_SETREGID)
309 r = setregid(gr->gr_gid, gr->gr_gid);
310 #else
311 #error "No API to drop privileges"
312 #endif
313
314 if (r < 0) {
315 pa_log(_("Failed to change GID: %s"), pa_cstrerror(errno));
316 return -1;
317 }
318
319 #if defined(HAVE_SETRESUID)
320 r = setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid);
321 #elif defined(HAVE_SETEUID)
322 if ((r = setuid(pw->pw_uid)) >= 0)
323 r = seteuid(pw->pw_uid);
324 #elif defined(HAVE_SETREUID)
325 r = setreuid(pw->pw_uid, pw->pw_uid);
326 #else
327 #error "No API to drop privileges"
328 #endif
329
330 if (r < 0) {
331 pa_log(_("Failed to change UID: %s"), pa_cstrerror(errno));
332 return -1;
333 }
334
335 pa_drop_caps();
336
337 pa_set_env("USER", PA_SYSTEM_USER);
338 pa_set_env("USERNAME", PA_SYSTEM_USER);
339 pa_set_env("LOGNAME", PA_SYSTEM_USER);
340 pa_set_env("HOME", PA_SYSTEM_RUNTIME_PATH);
341
342 /* Relevant for pa_runtime_path() */
343 if (!getenv("PULSE_RUNTIME_PATH"))
344 pa_set_env("PULSE_RUNTIME_PATH", PA_SYSTEM_RUNTIME_PATH);
345
346 if (!getenv("PULSE_CONFIG_PATH"))
347 pa_set_env("PULSE_CONFIG_PATH", PA_SYSTEM_CONFIG_PATH);
348
349 if (!getenv("PULSE_STATE_PATH"))
350 pa_set_env("PULSE_STATE_PATH", PA_SYSTEM_STATE_PATH);
351
352 pa_log_info("Successfully changed user to \"" PA_SYSTEM_USER "\".");
353
354 return 0;
355 }
356
357 #else /* HAVE_PWD_H && HAVE_GRP_H */
358
change_user(void)359 static int change_user(void) {
360 pa_log(_("System wide mode unsupported on this platform."));
361 return -1;
362 }
363
364 #endif /* HAVE_PWD_H && HAVE_GRP_H */
365
366 #ifdef HAVE_SYS_RESOURCE_H
367
set_one_rlimit(const pa_rlimit * r,int resource,const char * name)368 static int set_one_rlimit(const pa_rlimit *r, int resource, const char *name) {
369 struct rlimit rl;
370 pa_assert(r);
371
372 if (!r->is_set)
373 return 0;
374
375 rl.rlim_cur = rl.rlim_max = r->value;
376
377 if (setrlimit(resource, &rl) < 0) {
378 pa_log_info("setrlimit(%s, (%u, %u)) failed: %s", name, (unsigned) r->value, (unsigned) r->value, pa_cstrerror(errno));
379 return -1;
380 }
381
382 return 0;
383 }
384
set_all_rlimits(const pa_daemon_conf * conf)385 static void set_all_rlimits(const pa_daemon_conf *conf) {
386 set_one_rlimit(&conf->rlimit_fsize, RLIMIT_FSIZE, "RLIMIT_FSIZE");
387 set_one_rlimit(&conf->rlimit_data, RLIMIT_DATA, "RLIMIT_DATA");
388 set_one_rlimit(&conf->rlimit_stack, RLIMIT_STACK, "RLIMIT_STACK");
389 set_one_rlimit(&conf->rlimit_core, RLIMIT_CORE, "RLIMIT_CORE");
390 #ifdef RLIMIT_RSS
391 set_one_rlimit(&conf->rlimit_rss, RLIMIT_RSS, "RLIMIT_RSS");
392 #endif
393 #ifdef RLIMIT_NPROC
394 set_one_rlimit(&conf->rlimit_nproc, RLIMIT_NPROC, "RLIMIT_NPROC");
395 #endif
396 #ifdef RLIMIT_NOFILE
397 set_one_rlimit(&conf->rlimit_nofile, RLIMIT_NOFILE, "RLIMIT_NOFILE");
398 #endif
399 #ifdef RLIMIT_MEMLOCK
400 set_one_rlimit(&conf->rlimit_memlock, RLIMIT_MEMLOCK, "RLIMIT_MEMLOCK");
401 #endif
402 #ifdef RLIMIT_AS
403 set_one_rlimit(&conf->rlimit_as, RLIMIT_AS, "RLIMIT_AS");
404 #endif
405 #ifdef RLIMIT_LOCKS
406 set_one_rlimit(&conf->rlimit_locks, RLIMIT_LOCKS, "RLIMIT_LOCKS");
407 #endif
408 #ifdef RLIMIT_SIGPENDING
409 set_one_rlimit(&conf->rlimit_sigpending, RLIMIT_SIGPENDING, "RLIMIT_SIGPENDING");
410 #endif
411 #ifdef RLIMIT_MSGQUEUE
412 set_one_rlimit(&conf->rlimit_msgqueue, RLIMIT_MSGQUEUE, "RLIMIT_MSGQUEUE");
413 #endif
414 #ifdef RLIMIT_NICE
415 set_one_rlimit(&conf->rlimit_nice, RLIMIT_NICE, "RLIMIT_NICE");
416 #endif
417 #ifdef RLIMIT_RTPRIO
418 set_one_rlimit(&conf->rlimit_rtprio, RLIMIT_RTPRIO, "RLIMIT_RTPRIO");
419 #endif
420 #ifdef RLIMIT_RTTIME
421 set_one_rlimit(&conf->rlimit_rttime, RLIMIT_RTTIME, "RLIMIT_RTTIME");
422 #endif
423 }
424 #endif
425
check_configured_address(void)426 static char *check_configured_address(void) {
427 char *default_server = NULL;
428 pa_client_conf *c = pa_client_conf_new();
429
430 pa_client_conf_load(c, true, true);
431
432 if (c->default_server && *c->default_server)
433 default_server = pa_xstrdup(c->default_server);
434
435 pa_client_conf_free(c);
436
437 return default_server;
438 }
439
440 #ifdef HAVE_DBUS
register_dbus_name(pa_core * c,DBusBusType bus,const char * name)441 static pa_dbus_connection *register_dbus_name(pa_core *c, DBusBusType bus, const char* name) {
442 DBusError error;
443 pa_dbus_connection *conn;
444
445 dbus_error_init(&error);
446
447 if (!(conn = pa_dbus_bus_get(c, bus, &error)) || dbus_error_is_set(&error)) {
448 pa_log_warn("Unable to contact D-Bus: %s: %s", error.name, error.message);
449 goto fail;
450 }
451
452 if (dbus_bus_request_name(pa_dbus_connection_get(conn), name, DBUS_NAME_FLAG_DO_NOT_QUEUE, &error) == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
453 pa_log_debug("Got %s!", name);
454 return conn;
455 }
456
457 if (dbus_error_is_set(&error))
458 pa_log_error("Failed to acquire %s: %s: %s", name, error.name, error.message);
459 else
460 pa_log_error("D-Bus name %s already taken.", name);
461
462 /* PA cannot be started twice by the same user and hence we can
463 * ignore mostly the case that a name is already taken. */
464
465 fail:
466 if (conn)
467 pa_dbus_connection_unref(conn);
468
469 dbus_error_free(&error);
470 return NULL;
471 }
472 #endif
473
474 #ifdef OS_IS_WIN32
475 #define SVC_NAME "PulseAudio"
476 static bool is_svc = true;
477 static int argc;
478 static char **argv;
479 static int real_main(int s_argc, char *s_argv[]);
480 static SERVICE_STATUS_HANDLE svc_status;
481
svc_callback(DWORD ctl,DWORD evt,LPVOID data,LPVOID userdata)482 DWORD svc_callback(DWORD ctl, DWORD evt, LPVOID data, LPVOID userdata) {
483 pa_mainloop **m = userdata;
484 switch (ctl) {
485 case SERVICE_CONTROL_STOP:
486 case SERVICE_CONTROL_SHUTDOWN:
487 if (m) {
488 pa_log_info("Exiting.");
489 pa_mainloop_get_api(*m)->quit(pa_mainloop_get_api(*m), 0);
490 }
491 return NO_ERROR;
492 case SERVICE_CONTROL_INTERROGATE:
493 return NO_ERROR;
494 }
495 return ERROR_CALL_NOT_IMPLEMENTED;
496 }
497
main(int p_argc,char * p_argv[])498 int main(int p_argc, char *p_argv[]) {
499 argc = p_argc;
500 argv = p_argv;
501 if (StartServiceCtrlDispatcherA((SERVICE_TABLE_ENTRYA[]){
502 {SVC_NAME, (LPSERVICE_MAIN_FUNCTIONA) real_main},
503 {0},
504 })) return 0;
505 is_svc = false;
506 return real_main(0, NULL);
507 }
508
real_main(int s_argc,char * s_argv[])509 static int real_main(int s_argc, char *s_argv[]) {
510 #else
511 int main(int argc, char *argv[]) {
512 #endif
513 pa_core *c = NULL;
514 pa_strbuf *buf = NULL;
515 pa_daemon_conf *conf = NULL;
516 pa_mainloop *mainloop = NULL;
517 char *s;
518 char *configured_address;
519 int r = 0, retval = 1, d = 0;
520 bool valid_pid_file = false;
521 bool ltdl_init = false;
522 int n_fds = 0, *passed_fds = NULL;
523 const char *e;
524 #ifdef HAVE_FORK
525 int daemon_pipe[2] = { -1, -1 };
526 int daemon_pipe2[2] = { -1, -1 };
527 #endif
528 int autospawn_fd = -1;
529 bool autospawn_locked = false;
530 #ifdef HAVE_DBUS
531 pa_dbusobj_server_lookup *server_lookup = NULL; /* /org/pulseaudio/server_lookup */
532 pa_dbus_connection *lookup_service_bus = NULL; /* Always the user bus. */
533 pa_dbus_connection *server_bus = NULL; /* The bus where we reserve org.pulseaudio.Server, either the user or the system bus. */
534 bool start_server;
535 #endif
536
537 #ifdef OS_IS_WIN32
538 if (is_svc && !(svc_status = RegisterServiceCtrlHandlerExA(SVC_NAME, (LPHANDLER_FUNCTION_EX) svc_callback, &mainloop))) {
539 pa_log("Failed to register service control handler.");
540 goto finish;
541 }
542
543 if (is_svc) {
544 SetServiceStatus(svc_status, &(SERVICE_STATUS){
545 .dwServiceType = SERVICE_WIN32,
546 .dwCurrentState = SERVICE_START_PENDING,
547 .dwControlsAccepted = 0,
548 .dwWin32ExitCode = NO_ERROR,
549 .dwWaitHint = 3000,
550 });
551 }
552 #endif
553
554 pa_log_set_ident("pulseaudio");
555 pa_log_set_level(PA_LOG_NOTICE);
556 pa_log_set_flags(PA_LOG_COLORS|PA_LOG_PRINT_FILE|PA_LOG_PRINT_LEVEL, PA_LOG_RESET);
557
558 #if !defined(HAVE_BIND_NOW) && defined(__linux__) && defined(__OPTIMIZE__)
559 /*
560 Disable lazy relocations to make usage of external libraries
561 more deterministic for our RT threads. We abuse __OPTIMIZE__ as
562 a check whether we are a debug build or not. This all is
563 admittedly a bit snake-oilish.
564 */
565
566 if (!getenv("LD_BIND_NOW")) {
567 char *rp;
568 char *canonical_rp;
569
570 /* We have to execute ourselves, because the libc caches the
571 * value of $LD_BIND_NOW on initialization. */
572
573 pa_set_env("LD_BIND_NOW", "1");
574
575 if ((canonical_rp = pa_realpath(PA_BINARY))) {
576
577 if ((rp = pa_readlink("/proc/self/exe"))) {
578
579 if (pa_streq(rp, canonical_rp))
580 pa_assert_se(execv(rp, argv) == 0);
581 else
582 pa_log_warn("/proc/self/exe does not point to %s, cannot self execute. Are you playing games?", canonical_rp);
583
584 pa_xfree(rp);
585
586 } else
587 pa_log_warn("Couldn't read /proc/self/exe, cannot self execute. Running in a chroot()?");
588
589 pa_xfree(canonical_rp);
590
591 } else
592 pa_log_warn("Couldn't canonicalize binary path, cannot self execute.");
593 }
594 #endif
595
596 #ifdef HAVE_SYSTEMD_DAEMON
597 n_fds = sd_listen_fds(0);
598 if (n_fds > 0) {
599 int i = n_fds;
600
601 passed_fds = pa_xnew(int, n_fds+2);
602 passed_fds[n_fds] = passed_fds[n_fds+1] = -1;
603 while (i--)
604 passed_fds[i] = SD_LISTEN_FDS_START + i;
605 }
606 #endif
607
608 if (!passed_fds) {
609 n_fds = 0;
610 passed_fds = pa_xnew(int, 2);
611 passed_fds[0] = passed_fds[1] = -1;
612 }
613
614 if ((e = getenv("PULSE_PASSED_FD"))) {
615 int passed_fd = atoi(e);
616 if (passed_fd > 2)
617 passed_fds[n_fds] = passed_fd;
618 }
619
620 /* We might be autospawned, in which case have no idea in which
621 * context we have been started. Let's cleanup our execution
622 * context as good as possible */
623
624 pa_reset_personality();
625 pa_drop_root();
626 pa_close_allv(passed_fds);
627 pa_xfree(passed_fds);
628 pa_reset_sigs(-1);
629 pa_unblock_sigs(-1);
630 pa_reset_priority();
631
632 /* Load locale from the environment. */
633 setlocale(LC_ALL, "");
634
635 /* Set LC_NUMERIC to C so that floating point strings are consistently
636 * formatted and parsed across locales. */
637 setlocale(LC_NUMERIC, "C");
638
639 pa_init_i18n();
640
641 conf = pa_daemon_conf_new();
642
643 if (pa_daemon_conf_load(conf, NULL) < 0)
644 goto finish;
645
646 if (pa_daemon_conf_env(conf) < 0)
647 goto finish;
648
649 if (pa_cmdline_parse(conf, argc, argv, &d) < 0) {
650 pa_log(_("Failed to parse command line."));
651 goto finish;
652 }
653
654 if (conf->log_target)
655 pa_log_set_target(conf->log_target);
656 else {
657 pa_log_target target = { .type = PA_LOG_STDERR, .file = NULL };
658 pa_log_set_target(&target);
659 }
660
661 pa_log_set_level(conf->log_level);
662 if (conf->log_meta)
663 pa_log_set_flags(PA_LOG_PRINT_META, PA_LOG_SET);
664 if (conf->log_time)
665 pa_log_set_flags(PA_LOG_PRINT_TIME, PA_LOG_SET);
666 pa_log_set_show_backtrace(conf->log_backtrace);
667
668 #ifdef HAVE_DBUS
669 /* conf->system_instance and conf->local_server_type control almost the
670 * same thing; make them agree about what is requested. */
671 switch (conf->local_server_type) {
672 case PA_SERVER_TYPE_UNSET:
673 conf->local_server_type = conf->system_instance ? PA_SERVER_TYPE_SYSTEM : PA_SERVER_TYPE_USER;
674 break;
675 case PA_SERVER_TYPE_USER:
676 case PA_SERVER_TYPE_NONE:
677 conf->system_instance = false;
678 break;
679 case PA_SERVER_TYPE_SYSTEM:
680 conf->system_instance = true;
681 break;
682 default:
683 pa_assert_not_reached();
684 }
685
686 start_server = conf->local_server_type == PA_SERVER_TYPE_USER || (getuid() == 0 && conf->local_server_type == PA_SERVER_TYPE_SYSTEM);
687
688 if (!start_server && conf->local_server_type == PA_SERVER_TYPE_SYSTEM) {
689 pa_log_notice(_("System mode refused for non-root user. Only starting the D-Bus server lookup service."));
690 conf->system_instance = false;
691 }
692 #endif
693
694 LTDL_SET_PRELOADED_SYMBOLS();
695 pa_ltdl_init();
696 ltdl_init = true;
697
698 if (conf->dl_search_path)
699 lt_dlsetsearchpath(conf->dl_search_path);
700
701 #ifdef OS_IS_WIN32
702 {
703 WSADATA data;
704 WSAStartup(MAKEWORD(2, 0), &data);
705 }
706 #endif
707
708 pa_random_seed();
709
710 switch (conf->cmd) {
711 case PA_CMD_DUMP_MODULES:
712 pa_dump_modules(conf, argc-d, argv+d);
713 retval = 0;
714 goto finish;
715
716 case PA_CMD_DUMP_CONF: {
717
718 if (d < argc) {
719 pa_log("Too many arguments.");
720 goto finish;
721 }
722
723 s = pa_daemon_conf_dump(conf);
724 fputs(s, stdout);
725 pa_xfree(s);
726 retval = 0;
727 goto finish;
728 }
729
730 case PA_CMD_DUMP_RESAMPLE_METHODS: {
731 int i;
732
733 if (d < argc) {
734 pa_log("Too many arguments.");
735 goto finish;
736 }
737
738 for (i = 0; i < PA_RESAMPLER_MAX; i++)
739 if (pa_resample_method_supported(i))
740 printf("%s\n", pa_resample_method_to_string(i));
741
742 retval = 0;
743 goto finish;
744 }
745
746 case PA_CMD_HELP :
747 pa_cmdline_help(argv[0]);
748 retval = 0;
749 goto finish;
750
751 case PA_CMD_VERSION :
752
753 if (d < argc) {
754 pa_log("Too many arguments.");
755 goto finish;
756 }
757
758 printf(PACKAGE_NAME" "PACKAGE_VERSION"\n");
759 retval = 0;
760 goto finish;
761
762 case PA_CMD_CHECK: {
763 pid_t pid;
764
765 if (d < argc) {
766 pa_log("Too many arguments.");
767 goto finish;
768 }
769
770 if (pa_pid_file_check_running(&pid, "pulseaudio") < 0)
771 pa_log_info("Daemon not running");
772 else {
773 pa_log_info("Daemon running as PID %u", pid);
774 retval = 0;
775 }
776
777 goto finish;
778
779 }
780 case PA_CMD_KILL:
781
782 if (d < argc) {
783 pa_log("Too many arguments.");
784 goto finish;
785 }
786
787 if (pa_pid_file_kill(SIGINT, NULL, "pulseaudio") < 0)
788 pa_log(_("Failed to kill daemon: %s"), pa_cstrerror(errno));
789 else
790 retval = 0;
791
792 goto finish;
793
794 case PA_CMD_CLEANUP_SHM:
795
796 if (d < argc) {
797 pa_log("Too many arguments.");
798 goto finish;
799 }
800
801 if (pa_shm_cleanup() >= 0)
802 retval = 0;
803
804 goto finish;
805
806 default:
807 pa_assert(conf->cmd == PA_CMD_DAEMON || conf->cmd == PA_CMD_START);
808 }
809
810 if (d < argc) {
811 pa_log("Too many arguments.");
812 goto finish;
813 }
814
815 #ifdef HAVE_GETUID
816 if (getuid() == 0 && !conf->system_instance)
817 pa_log_warn(_("This program is not intended to be run as root (unless --system is specified)."));
818 #ifndef HAVE_DBUS /* A similar, only a notice worthy check was done earlier, if D-Bus is enabled. */
819 else if (getuid() != 0 && conf->system_instance) {
820 pa_log(_("Root privileges required."));
821 goto finish;
822 }
823 #endif
824 #endif /* HAVE_GETUID */
825
826 if (conf->cmd == PA_CMD_START && conf->system_instance) {
827 pa_log(_("--start not supported for system instances."));
828 goto finish;
829 }
830
831 if (conf->cmd == PA_CMD_START && (configured_address = check_configured_address())) {
832 /* There is an server address in our config, but where did it come from?
833 * By default a standard X11 login will load module-x11-publish which will
834 * inject PULSE_SERVER X11 property. If the PA daemon crashes, we will end
835 * up hitting this code path. So we have to check to see if our configured_address
836 * is the same as the value that would go into this property so that we can
837 * recover (i.e. autospawn) from a crash.
838 */
839 char *ufn;
840 bool start_anyway = false;
841
842 if ((ufn = pa_runtime_path(PA_NATIVE_DEFAULT_UNIX_SOCKET))) {
843 char *id;
844
845 if ((id = pa_machine_id())) {
846 pa_strlist *server_list;
847 char formatted_ufn[256];
848
849 pa_snprintf(formatted_ufn, sizeof(formatted_ufn), "{%s}unix:%s", id, ufn);
850 pa_xfree(id);
851
852 if ((server_list = pa_strlist_parse(configured_address))) {
853 char *u = NULL;
854
855 /* We only need to check the first server */
856 server_list = pa_strlist_pop(server_list, &u);
857 pa_strlist_free(server_list);
858
859 start_anyway = (u && pa_streq(formatted_ufn, u));
860 pa_xfree(u);
861 }
862 }
863 pa_xfree(ufn);
864 }
865
866 if (!start_anyway) {
867 pa_log_notice(_("User-configured server at %s, refusing to start/autospawn."), configured_address);
868 pa_xfree(configured_address);
869 retval = 0;
870 goto finish;
871 }
872
873 pa_log_notice(_("User-configured server at %s, which appears to be local. Probing deeper."), configured_address);
874 pa_xfree(configured_address);
875 }
876
877 if (conf->system_instance && !conf->disallow_exit)
878 pa_log_warn(_("Running in system mode, but --disallow-exit not set."));
879
880 if (conf->system_instance && !conf->disallow_module_loading)
881 pa_log_warn(_("Running in system mode, but --disallow-module-loading not set."));
882
883 if (conf->system_instance && !conf->disable_shm) {
884 pa_log_notice(_("Running in system mode, forcibly disabling SHM mode."));
885 conf->disable_shm = true;
886 }
887
888 if (conf->system_instance && conf->exit_idle_time >= 0) {
889 pa_log_notice(_("Running in system mode, forcibly disabling exit idle time."));
890 conf->exit_idle_time = -1;
891 }
892
893 if (conf->cmd == PA_CMD_START) {
894 /* If we shall start PA only when it is not running yet, we
895 * first take the autospawn lock to make things
896 * synchronous. */
897
898 /* This locking and thread synchronisation code doesn't work reliably
899 * on kFreeBSD (Debian bug #705435), or in upstream FreeBSD ports
900 * (bug reference: ports/128947, patched in SVN r231972). */
901 #if !defined(__FreeBSD__) && !defined(__FreeBSD_kernel__)
902 if ((autospawn_fd = pa_autospawn_lock_init()) < 0) {
903 pa_log("Failed to initialize autospawn lock");
904 goto finish;
905 }
906
907 if ((pa_autospawn_lock_acquire(true) < 0)) {
908 pa_log("Failed to acquire autospawn lock");
909 goto finish;
910 }
911
912 autospawn_locked = true;
913 #endif
914 }
915
916 if (conf->daemonize) {
917 #ifdef HAVE_FORK
918 pid_t child;
919 #endif
920
921 if (pa_stdio_acquire() < 0) {
922 pa_log(_("Failed to acquire stdio."));
923 goto finish;
924 }
925
926 #ifdef HAVE_FORK
927 if (pipe(daemon_pipe) < 0) {
928 pa_log(_("pipe() failed: %s"), pa_cstrerror(errno));
929 goto finish;
930 }
931
932 if ((child = fork()) < 0) {
933 pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
934 pa_close_pipe(daemon_pipe);
935 goto finish;
936 }
937
938 if (child != 0) {
939 ssize_t n;
940 /* Father */
941
942 pa_assert_se(pa_close(daemon_pipe[1]) == 0);
943 daemon_pipe[1] = -1;
944
945 if ((n = pa_loop_read(daemon_pipe[0], &retval, sizeof(retval), NULL)) != sizeof(retval)) {
946
947 if (n < 0)
948 pa_log(_("read() failed: %s"), pa_cstrerror(errno));
949
950 retval = 1;
951 }
952
953 if (retval)
954 pa_log(_("Daemon startup failed."));
955 else
956 pa_log_info("Daemon startup successful.");
957
958 goto finish;
959 }
960
961 if (autospawn_fd >= 0) {
962 /* The lock file is unlocked from the parent, so we need
963 * to close it in the child */
964
965 pa_autospawn_lock_release();
966 pa_autospawn_lock_done(true);
967
968 autospawn_locked = false;
969 autospawn_fd = -1;
970 }
971
972 pa_assert_se(pa_close(daemon_pipe[0]) == 0);
973 daemon_pipe[0] = -1;
974 #endif
975
976 if (!conf->log_target) {
977 #ifdef HAVE_SYSTEMD_JOURNAL
978 pa_log_target target = { .type = PA_LOG_JOURNAL, .file = NULL };
979 #else
980 pa_log_target target = { .type = PA_LOG_SYSLOG, .file = NULL };
981 #endif
982 pa_log_set_target(&target);
983 }
984
985 #ifdef HAVE_SETSID
986 if (setsid() < 0) {
987 pa_log(_("setsid() failed: %s"), pa_cstrerror(errno));
988 goto finish;
989 }
990 #endif
991
992 #ifdef HAVE_FORK
993 /* We now are a session and process group leader. Let's fork
994 * again and let the father die, so that we'll become a
995 * process that can never acquire a TTY again, in a session and
996 * process group without leader */
997
998 if (pipe(daemon_pipe2) < 0) {
999 pa_log(_("pipe() failed: %s"), pa_cstrerror(errno));
1000 goto finish;
1001 }
1002
1003 if ((child = fork()) < 0) {
1004 pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
1005 pa_close_pipe(daemon_pipe2);
1006 goto finish;
1007 }
1008
1009 if (child != 0) {
1010 ssize_t n;
1011 /* Father */
1012
1013 pa_assert_se(pa_close(daemon_pipe2[1]) == 0);
1014 daemon_pipe2[1] = -1;
1015
1016 if ((n = pa_loop_read(daemon_pipe2[0], &retval, sizeof(retval), NULL)) != sizeof(retval)) {
1017
1018 if (n < 0)
1019 pa_log(_("read() failed: %s"), pa_cstrerror(errno));
1020
1021 retval = 1;
1022 }
1023
1024 /* We now have to take care of signalling the first fork with
1025 * the return value we've received from this fork... */
1026 pa_assert(daemon_pipe[1] >= 0);
1027
1028 pa_loop_write(daemon_pipe[1], &retval, sizeof(retval), NULL);
1029 pa_close(daemon_pipe[1]);
1030 daemon_pipe[1] = -1;
1031
1032 goto finish;
1033 }
1034
1035 pa_assert_se(pa_close(daemon_pipe2[0]) == 0);
1036 daemon_pipe2[0] = -1;
1037
1038 /* We no longer need the (first) daemon_pipe as it's handled in our child above */
1039 pa_close_pipe(daemon_pipe);
1040 #endif
1041
1042 #ifdef SIGTTOU
1043 signal(SIGTTOU, SIG_IGN);
1044 #endif
1045 #ifdef SIGTTIN
1046 signal(SIGTTIN, SIG_IGN);
1047 #endif
1048 #ifdef SIGTSTP
1049 signal(SIGTSTP, SIG_IGN);
1050 #endif
1051
1052 pa_nullify_stdfds();
1053 }
1054
1055 pa_set_env_and_record("PULSE_INTERNAL", "1");
1056 pa_assert_se(chdir("/") == 0);
1057 umask(0077);
1058
1059 #ifdef HAVE_SYS_RESOURCE_H
1060 set_all_rlimits(conf);
1061 #endif
1062 pa_rtclock_hrtimer_enable();
1063
1064 if (conf->high_priority)
1065 pa_raise_priority(conf->nice_level);
1066
1067 if (conf->system_instance)
1068 if (change_user() < 0)
1069 goto finish;
1070
1071 pa_set_env_and_record("PULSE_SYSTEM", conf->system_instance ? "1" : "0");
1072
1073 pa_log_info("This is PulseAudio %s", PACKAGE_VERSION);
1074 pa_log_debug("Compilation CFLAGS: %s", PA_CFLAGS);
1075
1076 #ifdef HAVE_LIBSAMPLERATE
1077 pa_log_warn("Compiled with DEPRECATED libsamplerate support!");
1078 #endif
1079
1080 s = pa_uname_string();
1081 pa_log_debug("Running on host: %s", s);
1082 pa_xfree(s);
1083
1084 pa_log_debug("Found %u CPUs.", pa_ncpus());
1085
1086 pa_log_info("Page size is %zu bytes", pa_page_size());
1087
1088 #ifdef HAVE_VALGRIND_MEMCHECK_H
1089 pa_log_debug("Compiled with Valgrind support: yes");
1090 #else
1091 pa_log_debug("Compiled with Valgrind support: no");
1092 #endif
1093
1094 pa_log_debug("Running in valgrind mode: %s", pa_yes_no(pa_in_valgrind()));
1095
1096 pa_log_debug("Running in VM: %s", pa_yes_no(pa_running_in_vm()));
1097
1098 #ifdef HAVE_RUNNING_FROM_BUILD_TREE
1099 pa_log_debug("Running from build tree: %s", pa_yes_no(pa_run_from_build_tree()));
1100 #else
1101 pa_log_debug("Running from build tree: no");
1102 #endif
1103
1104 #ifdef __OPTIMIZE__
1105 pa_log_debug("Optimized build: yes");
1106 #else
1107 pa_log_debug("Optimized build: no");
1108 #endif
1109
1110 #ifdef NDEBUG
1111 pa_log_debug("NDEBUG defined, all asserts disabled.");
1112 #elif defined(FASTPATH)
1113 pa_log_debug("FASTPATH defined, only fast path asserts disabled.");
1114 #else
1115 pa_log_debug("All asserts enabled.");
1116 #endif
1117
1118 if (!(s = pa_machine_id())) {
1119 pa_log(_("Failed to get machine ID"));
1120 goto finish;
1121 }
1122 pa_log_info("Machine ID is %s.", s);
1123 pa_xfree(s);
1124
1125 if ((s = pa_session_id())) {
1126 pa_log_info("Session ID is %s.", s);
1127 pa_xfree(s);
1128 }
1129
1130 if (!(s = pa_get_runtime_dir()))
1131 goto finish;
1132 pa_log_info("Using runtime directory %s.", s);
1133 pa_xfree(s);
1134
1135 if (!(s = pa_get_state_dir()))
1136 goto finish;
1137 pa_log_info("Using state directory %s.", s);
1138 pa_xfree(s);
1139
1140 pa_log_info("Using modules directory %s.", conf->dl_search_path);
1141
1142 pa_log_info("Running in system mode: %s", pa_yes_no(pa_in_system_mode()));
1143
1144 if (pa_in_system_mode())
1145 pa_log_warn(_("OK, so you are running PA in system mode. Please make sure that you actually do want to do that.\n"
1146 "Please read http://www.freedesktop.org/wiki/Software/PulseAudio/Documentation/User/WhatIsWrongWithSystemWide/ for an explanation why system mode is usually a bad idea."));
1147
1148 if (conf->use_pid_file) {
1149 int z;
1150
1151 if ((z = pa_pid_file_create("pulseaudio")) != 0) {
1152
1153 if (conf->cmd == PA_CMD_START && z > 0) {
1154 /* If we are already running and with are run in
1155 * --start mode, then let's return this as success. */
1156
1157 retval = 0;
1158 goto finish;
1159 }
1160
1161 pa_log(_("pa_pid_file_create() failed."));
1162 goto finish;
1163 }
1164
1165 valid_pid_file = true;
1166 }
1167
1168 pa_disable_sigpipe();
1169
1170 if (pa_rtclock_hrtimer())
1171 pa_log_info("System supports high resolution timers");
1172 else
1173 pa_log_info("System appears to not support high resolution timers");
1174
1175 if (conf->lock_memory) {
1176 #if defined(HAVE_SYS_MMAN_H) && !defined(__ANDROID__)
1177 if (mlockall(MCL_FUTURE) < 0)
1178 pa_log_warn("mlockall() failed: %s", pa_cstrerror(errno));
1179 else
1180 pa_log_info("Successfully locked process into memory.");
1181 #else
1182 pa_log_warn("Memory locking requested but not supported on platform.");
1183 #endif
1184 }
1185
1186 pa_memtrap_install();
1187
1188 pa_assert_se(mainloop = pa_mainloop_new());
1189
1190 if (!(c = pa_core_new(pa_mainloop_get_api(mainloop), !conf->disable_shm,
1191 !conf->disable_shm && !conf->disable_memfd && pa_memfd_is_locally_supported(),
1192 conf->shm_size))) {
1193 pa_log(_("pa_core_new() failed."));
1194 goto finish;
1195 }
1196
1197 c->default_sample_spec = conf->default_sample_spec;
1198 c->alternate_sample_rate = conf->alternate_sample_rate;
1199 c->default_channel_map = conf->default_channel_map;
1200 c->default_n_fragments = conf->default_n_fragments;
1201 c->default_fragment_size_msec = conf->default_fragment_size_msec;
1202 c->deferred_volume_safety_margin_usec = conf->deferred_volume_safety_margin_usec;
1203 c->deferred_volume_extra_delay_usec = conf->deferred_volume_extra_delay_usec;
1204 c->lfe_crossover_freq = conf->lfe_crossover_freq;
1205 c->exit_idle_time = conf->exit_idle_time;
1206 c->scache_idle_time = conf->scache_idle_time;
1207 c->resample_method = conf->resample_method;
1208 c->realtime_priority = conf->realtime_priority;
1209 c->realtime_scheduling = conf->realtime_scheduling;
1210 c->avoid_resampling = conf->avoid_resampling;
1211 c->disable_remixing = conf->disable_remixing;
1212 c->remixing_use_all_sink_channels = conf->remixing_use_all_sink_channels;
1213 c->remixing_produce_lfe = conf->remixing_produce_lfe;
1214 c->remixing_consume_lfe = conf->remixing_consume_lfe;
1215 c->deferred_volume = conf->deferred_volume;
1216 c->running_as_daemon = conf->daemonize;
1217 c->disallow_exit = conf->disallow_exit;
1218 c->flat_volumes = conf->flat_volumes;
1219 c->rescue_streams = conf->rescue_streams;
1220 #ifdef HAVE_DBUS
1221 c->server_type = conf->local_server_type;
1222 #endif
1223
1224 pa_core_check_idle(c);
1225
1226 c->state = PA_CORE_RUNNING;
1227
1228 pa_cpu_init(&c->cpu_info);
1229
1230 pa_assert_se(pa_signal_init(pa_mainloop_get_api(mainloop)) == 0);
1231 pa_signal_new(SIGINT, signal_callback, c);
1232 pa_signal_new(SIGTERM, signal_callback, c);
1233 #ifdef SIGUSR1
1234 pa_signal_new(SIGUSR1, signal_callback, c);
1235 #endif
1236 #ifdef SIGUSR2
1237 pa_signal_new(SIGUSR2, signal_callback, c);
1238 #endif
1239 #ifdef SIGHUP
1240 pa_signal_new(SIGHUP, signal_callback, c);
1241 #endif
1242
1243 if (!conf->no_cpu_limit)
1244 pa_assert_se(pa_cpu_limit_init(pa_mainloop_get_api(mainloop)) == 0);
1245
1246 buf = pa_strbuf_new();
1247
1248 #ifdef HAVE_DBUS
1249 pa_assert_se(dbus_threads_init_default());
1250
1251 if (start_server)
1252 #endif
1253 {
1254 const char *command_source = NULL;
1255
1256 if (conf->load_default_script_file) {
1257 FILE *f;
1258
1259 if ((f = pa_daemon_conf_open_default_script_file(conf))) {
1260 r = pa_cli_command_execute_file_stream(c, f, buf, &conf->fail);
1261 fclose(f);
1262 command_source = pa_daemon_conf_get_default_script_file(conf);
1263 }
1264 }
1265
1266 if (r >= 0) {
1267 r = pa_cli_command_execute(c, conf->script_commands, buf, &conf->fail);
1268 command_source = _("command line arguments");
1269 }
1270
1271 pa_log_error("%s", s = pa_strbuf_to_string_free(buf));
1272 pa_xfree(s);
1273
1274 if (r < 0 && conf->fail) {
1275 pa_log(_("Failed to initialize daemon due to errors while executing startup commands. Source of commands: %s"), command_source);
1276 goto finish;
1277 }
1278
1279 if (!c->modules || pa_idxset_size(c->modules) == 0) {
1280 pa_log(_("Daemon startup without any loaded modules, refusing to work."));
1281 goto finish;
1282 }
1283 #ifdef HAVE_DBUS
1284 } else {
1285 /* When we just provide the D-Bus server lookup service, we don't want
1286 * any modules to be loaded. We haven't loaded any so far, so one might
1287 * think there's no way to contact the server, but receiving certain
1288 * signals could still cause modules to load. */
1289 conf->disallow_module_loading = true;
1290 #endif
1291 }
1292
1293 /* We completed the initial module loading, so let's disable it
1294 * from now on, if requested */
1295 c->disallow_module_loading = conf->disallow_module_loading;
1296
1297 #ifdef HAVE_DBUS
1298 if (!conf->system_instance) {
1299 if ((server_lookup = pa_dbusobj_server_lookup_new(c))) {
1300 if (!(lookup_service_bus = register_dbus_name(c, DBUS_BUS_SESSION, "org.PulseAudio1")))
1301 goto finish;
1302 }
1303 }
1304
1305 if (start_server)
1306 server_bus = register_dbus_name(c, conf->system_instance ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, "org.pulseaudio.Server");
1307 #endif
1308
1309 #ifdef HAVE_FORK
1310 if (daemon_pipe2[1] >= 0) {
1311 int ok = 0;
1312 pa_loop_write(daemon_pipe2[1], &ok, sizeof(ok), NULL);
1313 pa_close(daemon_pipe2[1]);
1314 daemon_pipe2[1] = -1;
1315 }
1316 #endif
1317
1318 pa_log_info("Daemon startup complete.");
1319
1320 #ifdef HAVE_SYSTEMD_DAEMON
1321 sd_notify(0, "READY=1");
1322 #endif
1323
1324 #ifdef OS_IS_WIN32
1325 if (is_svc) {
1326 SetServiceStatus(svc_status, &(SERVICE_STATUS){
1327 .dwServiceType = SERVICE_WIN32,
1328 .dwCurrentState = SERVICE_RUNNING,
1329 .dwControlsAccepted = SERVICE_ACCEPT_STOP|SERVICE_ACCEPT_SHUTDOWN,
1330 .dwWin32ExitCode = NO_ERROR,
1331 .dwWaitHint = 0,
1332 });
1333 }
1334 #endif
1335
1336 retval = 0;
1337 if (pa_mainloop_run(mainloop, &retval) < 0)
1338 goto finish;
1339
1340 pa_log_info("Daemon shutdown initiated.");
1341
1342 #ifdef HAVE_SYSTEMD_DAEMON
1343 sd_notify(0, "STOPPING=1");
1344 #endif
1345
1346 #ifdef OS_IS_WIN32
1347 if (is_svc) {
1348 SetServiceStatus(svc_status, &(SERVICE_STATUS){
1349 .dwServiceType = SERVICE_WIN32,
1350 .dwCurrentState = SERVICE_STOP_PENDING,
1351 .dwControlsAccepted = 0,
1352 .dwWin32ExitCode = NO_ERROR,
1353 .dwWaitHint = 2000,
1354 });
1355 }
1356 #endif
1357
1358 finish:
1359 #ifdef HAVE_DBUS
1360 if (server_bus)
1361 pa_dbus_connection_unref(server_bus);
1362 if (lookup_service_bus)
1363 pa_dbus_connection_unref(lookup_service_bus);
1364 if (server_lookup)
1365 pa_dbusobj_server_lookup_free(server_lookup);
1366 #endif
1367
1368 if (autospawn_fd >= 0) {
1369 if (autospawn_locked)
1370 pa_autospawn_lock_release();
1371
1372 pa_autospawn_lock_done(false);
1373 }
1374
1375 if (c) {
1376 /* Ensure all the modules/samples are unloaded when the core is still ref'ed,
1377 * as unlink callback hooks in modules may need the core to be ref'ed */
1378 pa_module_unload_all(c);
1379 pa_scache_free_all(c);
1380
1381 pa_core_unref(c);
1382 pa_log_info("Daemon terminated.");
1383 }
1384
1385 if (!conf->no_cpu_limit)
1386 pa_cpu_limit_done();
1387
1388 pa_signal_done();
1389
1390 #ifdef HAVE_FORK
1391 /* If we have daemon_pipe[1] still open, this means we've failed after
1392 * the first fork, but before the second. Therefore just write to it. */
1393 if (daemon_pipe[1] >= 0)
1394 pa_loop_write(daemon_pipe[1], &retval, sizeof(retval), NULL);
1395 else if (daemon_pipe2[1] >= 0)
1396 pa_loop_write(daemon_pipe2[1], &retval, sizeof(retval), NULL);
1397
1398 pa_close_pipe(daemon_pipe2);
1399 pa_close_pipe(daemon_pipe);
1400 #endif
1401
1402 if (mainloop)
1403 pa_mainloop_free(mainloop);
1404
1405 if (conf)
1406 pa_daemon_conf_free(conf);
1407
1408 if (valid_pid_file)
1409 pa_pid_file_remove();
1410
1411 /* This has no real purpose except making things valgrind-clean */
1412 pa_unset_env_recorded();
1413
1414 #ifdef OS_IS_WIN32
1415 WSACleanup();
1416 #endif
1417
1418 if (ltdl_init)
1419 pa_ltdl_done();
1420
1421 #ifdef HAVE_DBUS
1422 dbus_shutdown();
1423 #endif
1424
1425 #ifdef OS_IS_WIN32
1426 if (is_svc) {
1427 SetServiceStatus(svc_status, &(SERVICE_STATUS){
1428 .dwServiceType = SERVICE_WIN32,
1429 .dwCurrentState = SERVICE_STOPPED,
1430 .dwControlsAccepted = 0,
1431 .dwWin32ExitCode = retval ? ERROR_PROCESS_ABORTED : NO_ERROR,
1432 .dwWaitHint = 0,
1433 });
1434 }
1435 #endif
1436
1437 return retval;
1438 }
1439