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