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