src/daemon/main.c

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