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