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