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