src/daemon/main.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2006 Lennart Poettering
   5   Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
   6
   7   PulseAudio is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU Lesser General Public License as published
   9   by the Free Software Foundation; either version 2.1 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <unistd.h>
  28 #include <errno.h>
  29 #include <string.h>
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <signal.h>
  33 #include <stddef.h>
  34 #include <ltdl.h>
  35 #include <limits.h>
  36 #include <unistd.h>
  37 #include <locale.h>
  38 #include <sys/types.h>
  39 #include <sys/stat.h>
  40
  41 #include <fcntl.h>
  42
  43 #ifdef HAVE_SYS_MMAN_H
  44 #include <sys/mman.h>
  45 #endif
  46
  47 #ifdef HAVE_PWD_H
  48 #include <pwd.h>
  49 #endif
  50 #ifdef HAVE_GRP_H
  51 #include <grp.h>
  52 #endif
  53
  54 #ifdef HAVE_LIBWRAP
  55 #include <syslog.h>
  56 #include <tcpd.h>
  57 #endif
  58
  59 #ifdef HAVE_DBUS
  60 #include <dbus/dbus.h>
  61 #endif
  62
  63 #include <pulse/client-conf.h>
  64 #ifdef HAVE_X11
  65 #include <pulse/client-conf-x11.h>
  66 #endif
  67 #include <pulse/mainloop.h>
  68 #include <pulse/mainloop-signal.h>
  69 #include <pulse/timeval.h>
  70 #include <pulse/xmalloc.h>
  71
  72 #include <pulsecore/i18n.h>
  73 #include <pulsecore/lock-autospawn.h>
  74 #include <pulsecore/socket.h>
  75 #include <pulsecore/core-error.h>
  76 #include <pulsecore/core-rtclock.h>
  77 #include <pulsecore/core-scache.h>
  78 #include <pulsecore/core.h>
  79 #include <pulsecore/module.h>
  80 #include <pulsecore/cli-command.h>
  81 #include <pulsecore/log.h>
  82 #include <pulsecore/core-util.h>
  83 #include <pulsecore/sioman.h>
  84 #include <pulsecore/cli-text.h>
  85 #include <pulsecore/pid.h>
  86 #include <pulsecore/random.h>
  87 #include <pulsecore/macro.h>
  88 #include <pulsecore/shm.h>
  89 #include <pulsecore/memtrap.h>
  90 #include <pulsecore/strlist.h>
  91 #ifdef HAVE_DBUS
  92 #include <pulsecore/dbus-shared.h>
  93 #endif
  94 #include <pulsecore/cpu-arm.h>
  95 #include <pulsecore/cpu-x86.h>
  96 #include <pulsecore/cpu-orc.h>
  97
  98 #include "cmdline.h"
  99 #include "cpulimit.h"
 100 #include "daemon-conf.h"
 101 #include "dumpmodules.h"
 102 #include "caps.h"
 103 #include "ltdl-bind-now.h"
 104 #include "server-lookup.h"
 105
 106 #define PA_READY "/tmp/.pa_ready"
 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->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 (!pa_streq(pw->pw_dir, PA_SYSTEM_RUNTIME_PATH))
 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, true) < 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, true) < 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_drop_caps();
 258
 259     pa_set_env("USER", PA_SYSTEM_USER);
 260     pa_set_env("USERNAME", PA_SYSTEM_USER);
 261     pa_set_env("LOGNAME", PA_SYSTEM_USER);
 262     pa_set_env("HOME", PA_SYSTEM_RUNTIME_PATH);
 263
 264     /* Relevant for pa_runtime_path() */
 265     if (!getenv("PULSE_RUNTIME_PATH"))
 266         pa_set_env("PULSE_RUNTIME_PATH", PA_SYSTEM_RUNTIME_PATH);
 267
 268     if (!getenv("PULSE_CONFIG_PATH"))
 269         pa_set_env("PULSE_CONFIG_PATH", PA_SYSTEM_CONFIG_PATH);
 270
 271     if (!getenv("PULSE_STATE_PATH"))
 272         pa_set_env("PULSE_STATE_PATH", PA_SYSTEM_STATE_PATH);
 273
 274     pa_log_info(_("Successfully changed user to \"" PA_SYSTEM_USER "\"."));
 275
 276     return 0;
 277 }
 278
 279 #else /* HAVE_PWD_H && HAVE_GRP_H */
 280
 281 static int change_user(void) {
 282     pa_log(_("System wide mode unsupported on this platform."));
 283     return -1;
 284 }
 285
 286 #endif /* HAVE_PWD_H && HAVE_GRP_H */
 287
 288 #ifdef HAVE_SYS_RESOURCE_H
 289
 290 static int set_one_rlimit(const pa_rlimit *r, int resource, const char *name) {
 291     struct rlimit rl;
 292     pa_assert(r);
 293
 294     if (!r->is_set)
 295         return 0;
 296
 297     rl.rlim_cur = rl.rlim_max = r->value;
 298
 299     if (setrlimit(resource, &rl) < 0) {
 300         pa_log_info(_("setrlimit(%s, (%u, %u)) failed: %s"), name, (unsigned) r->value, (unsigned) r->value, pa_cstrerror(errno));
 301         return -1;
 302     }
 303
 304     return 0;
 305 }
 306
 307 static void set_all_rlimits(const pa_daemon_conf *conf) {
 308     set_one_rlimit(&conf->rlimit_fsize, RLIMIT_FSIZE, "RLIMIT_FSIZE");
 309     set_one_rlimit(&conf->rlimit_data, RLIMIT_DATA, "RLIMIT_DATA");
 310     set_one_rlimit(&conf->rlimit_stack, RLIMIT_STACK, "RLIMIT_STACK");
 311     set_one_rlimit(&conf->rlimit_core, RLIMIT_CORE, "RLIMIT_CORE");
 312 #ifdef RLIMIT_RSS
 313     set_one_rlimit(&conf->rlimit_rss, RLIMIT_RSS, "RLIMIT_RSS");
 314 #endif
 315 #ifdef RLIMIT_NPROC
 316     set_one_rlimit(&conf->rlimit_nproc, RLIMIT_NPROC, "RLIMIT_NPROC");
 317 #endif
 318 #ifdef RLIMIT_NOFILE
 319     set_one_rlimit(&conf->rlimit_nofile, RLIMIT_NOFILE, "RLIMIT_NOFILE");
 320 #endif
 321 #ifdef RLIMIT_MEMLOCK
 322     set_one_rlimit(&conf->rlimit_memlock, RLIMIT_MEMLOCK, "RLIMIT_MEMLOCK");
 323 #endif
 324 #ifdef RLIMIT_AS
 325     set_one_rlimit(&conf->rlimit_as, RLIMIT_AS, "RLIMIT_AS");
 326 #endif
 327 #ifdef RLIMIT_LOCKS
 328     set_one_rlimit(&conf->rlimit_locks, RLIMIT_LOCKS, "RLIMIT_LOCKS");
 329 #endif
 330 #ifdef RLIMIT_SIGPENDING
 331     set_one_rlimit(&conf->rlimit_sigpending, RLIMIT_SIGPENDING, "RLIMIT_SIGPENDING");
 332 #endif
 333 #ifdef RLIMIT_MSGQUEUE
 334     set_one_rlimit(&conf->rlimit_msgqueue, RLIMIT_MSGQUEUE, "RLIMIT_MSGQUEUE");
 335 #endif
 336 #ifdef RLIMIT_NICE
 337     set_one_rlimit(&conf->rlimit_nice, RLIMIT_NICE, "RLIMIT_NICE");
 338 #endif
 339 #ifdef RLIMIT_RTPRIO
 340     set_one_rlimit(&conf->rlimit_rtprio, RLIMIT_RTPRIO, "RLIMIT_RTPRIO");
 341 #endif
 342 #ifdef RLIMIT_RTTIME
 343     set_one_rlimit(&conf->rlimit_rttime, RLIMIT_RTTIME, "RLIMIT_RTTIME");
 344 #endif
 345 }
 346 #endif
 347
 348 static char *check_configured_address(void) {
 349     char *default_server = NULL;
 350     pa_client_conf *c = pa_client_conf_new();
 351
 352     pa_client_conf_load(c, NULL);
 353 #ifdef HAVE_X11
 354     pa_client_conf_from_x11(c, NULL);
 355 #endif
 356     pa_client_conf_env(c);
 357
 358     if (c->default_server && *c->default_server)
 359         default_server = pa_xstrdup(c->default_server);
 360
 361     pa_client_conf_free(c);
 362
 363     return default_server;
 364 }
 365
 366 #ifdef HAVE_DBUS
 367 static pa_dbus_connection *register_dbus_name(pa_core *c, DBusBusType bus, const char* name) {
 368     DBusError error;
 369     pa_dbus_connection *conn;
 370
 371     dbus_error_init(&error);
 372
 373     if (!(conn = pa_dbus_bus_get(c, bus, &error)) || dbus_error_is_set(&error)) {
 374         pa_log_warn("Unable to contact D-Bus: %s: %s", error.name, error.message);
 375         goto fail;
 376     }
 377
 378     if (dbus_bus_request_name(pa_dbus_connection_get(conn), name, DBUS_NAME_FLAG_DO_NOT_QUEUE, &error) == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
 379         pa_log_debug("Got %s!", name);
 380         return conn;
 381     }
 382
 383     if (dbus_error_is_set(&error))
 384         pa_log_error("Failed to acquire %s: %s: %s", name, error.name, error.message);
 385     else
 386         pa_log_error("D-Bus name %s already taken.", name);
 387
 388     /* PA cannot be started twice by the same user and hence we can
 389      * ignore mostly the case that a name is already taken. */
 390
 391 fail:
 392     if (conn)
 393         pa_dbus_connection_unref(conn);
 394
 395     dbus_error_free(&error);
 396     return NULL;
 397 }
 398 #endif
 399
 400 int main(int argc, char *argv[]) {
 401     pa_core *c = NULL;
 402     pa_strbuf *buf = NULL;
 403     pa_daemon_conf *conf = NULL;
 404     pa_mainloop *mainloop = NULL;
 405     char *s;
 406     char *configured_address;
 407     int r = 0, retval = 1, d = 0;
 408     bool valid_pid_file = false;
 409     bool ltdl_init = false;
 410     int passed_fd = -1;
 411     const char *e;
 412 #ifdef HAVE_FORK
 413     int daemon_pipe[2] = { -1, -1 };
 414     int daemon_pipe2[2] = { -1, -1 };
 415 #endif
 416 #ifdef OS_IS_WIN32
 417     pa_time_event *win32_timer;
 418     struct timeval win32_tv;
 419 #endif
 420     int autospawn_fd = -1;
 421     bool autospawn_locked = false;
 422 #ifdef HAVE_DBUS
 423     pa_dbusobj_server_lookup *server_lookup = NULL; /* /org/pulseaudio/server_lookup */
 424     pa_dbus_connection *lookup_service_bus = NULL; /* Always the user bus. */
 425     pa_dbus_connection *server_bus = NULL; /* The bus where we reserve org.pulseaudio.Server, either the user or the system bus. */
 426     bool start_server;
 427 #endif
 428
 429     pa_log_set_ident("pulseaudio");
 430     pa_log_set_level(PA_LOG_NOTICE);
 431     pa_log_set_flags(PA_LOG_COLORS|PA_LOG_PRINT_FILE|PA_LOG_PRINT_LEVEL, PA_LOG_RESET);
 432
 433 #if defined(__linux__) && defined(__OPTIMIZE__)
 434     /*
 435        Disable lazy relocations to make usage of external libraries
 436        more deterministic for our RT threads. We abuse __OPTIMIZE__ as
 437        a check whether we are a debug build or not. This all is
 438        admittedly a bit snake-oilish.
 439     */
 440
 441     if (!getenv("LD_BIND_NOW")) {
 442         char *rp;
 443         char *canonical_rp;
 444
 445         /* We have to execute ourselves, because the libc caches the
 446          * value of $LD_BIND_NOW on initialization. */
 447
 448         pa_set_env("LD_BIND_NOW", "1");
 449
 450         if ((canonical_rp = pa_realpath(PA_BINARY))) {
 451
 452             if ((rp = pa_readlink("/proc/self/exe"))) {
 453
 454                 if (pa_streq(rp, canonical_rp))
 455                     pa_assert_se(execv(rp, argv) == 0);
 456                 else
 457                     pa_log_warn("/proc/self/exe does not point to %s, cannot self execute. Are you playing games?", canonical_rp);
 458
 459                 pa_xfree(rp);
 460
 461             } else
 462                 pa_log_warn("Couldn't read /proc/self/exe, cannot self execute. Running in a chroot()?");
 463
 464             pa_xfree(canonical_rp);
 465
 466         } else
 467             pa_log_warn("Couldn't canonicalize binary path, cannot self execute.");
 468     }
 469 #endif
 470
 471     if ((e = getenv("PULSE_PASSED_FD"))) {
 472         passed_fd = atoi(e);
 473
 474         if (passed_fd <= 2)
 475             passed_fd = -1;
 476     }
 477
 478     /* We might be autospawned, in which case have no idea in which
 479      * context we have been started. Let's cleanup our execution
 480      * context as good as possible */
 481
 482     pa_reset_personality();
 483     pa_drop_root();
 484     pa_close_all(passed_fd, -1);
 485     pa_reset_sigs(-1);
 486     pa_unblock_sigs(-1);
 487     pa_reset_priority();
 488
 489     setlocale(LC_ALL, "");
 490     pa_init_i18n();
 491
 492     conf = pa_daemon_conf_new();
 493
 494     if (pa_daemon_conf_load(conf, NULL) < 0)
 495         goto finish;
 496
 497     if (pa_daemon_conf_env(conf) < 0)
 498         goto finish;
 499
 500     if (pa_cmdline_parse(conf, argc, argv, &d) < 0) {
 501         pa_log(_("Failed to parse command line."));
 502         goto finish;
 503     }
 504
 505     if (conf->log_target)
 506         pa_log_set_target(conf->log_target);
 507     else {
 508         pa_log_target target = { .type = PA_LOG_STDERR, .file = NULL };
 509         pa_log_set_target(&target);
 510     }
 511
 512     pa_log_set_level(conf->log_level);
 513     if (conf->log_meta)
 514         pa_log_set_flags(PA_LOG_PRINT_META, PA_LOG_SET);
 515     if (conf->log_time)
 516         pa_log_set_flags(PA_LOG_PRINT_TIME, PA_LOG_SET);
 517     pa_log_set_show_backtrace(conf->log_backtrace);
 518
 519 #ifdef HAVE_DBUS
 520     /* conf->system_instance and conf->local_server_type control almost the
 521      * same thing; make them agree about what is requested. */
 522     switch (conf->local_server_type) {
 523         case PA_SERVER_TYPE_UNSET:
 524             conf->local_server_type = conf->system_instance ? PA_SERVER_TYPE_SYSTEM : PA_SERVER_TYPE_USER;
 525             break;
 526         case PA_SERVER_TYPE_USER:
 527         case PA_SERVER_TYPE_NONE:
 528             conf->system_instance = false;
 529             break;
 530         case PA_SERVER_TYPE_SYSTEM:
 531             conf->system_instance = true;
 532             break;
 533         default:
 534             pa_assert_not_reached();
 535     }
 536
 537     start_server = conf->local_server_type == PA_SERVER_TYPE_USER || (getuid() == 0 && conf->local_server_type == PA_SERVER_TYPE_SYSTEM);
 538
 539     if (!start_server && conf->local_server_type == PA_SERVER_TYPE_SYSTEM) {
 540         pa_log_notice(_("System mode refused for non-root user. Only starting the D-Bus server lookup service."));
 541         conf->system_instance = false;
 542     }
 543 #endif
 544
 545     LTDL_SET_PRELOADED_SYMBOLS();
 546     pa_ltdl_init();
 547     ltdl_init = true;
 548
 549     if (conf->dl_search_path)
 550         lt_dlsetsearchpath(conf->dl_search_path);
 551
 552 #ifdef OS_IS_WIN32
 553     {
 554         WSADATA data;
 555         WSAStartup(MAKEWORD(2, 0), &data);
 556     }
 557 #endif
 558
 559     pa_random_seed();
 560
 561     switch (conf->cmd) {
 562         case PA_CMD_DUMP_MODULES:
 563             pa_dump_modules(conf, argc-d, argv+d);
 564             retval = 0;
 565             goto finish;
 566
 567         case PA_CMD_DUMP_CONF: {
 568
 569             if (d < argc) {
 570                 pa_log("Too many arguments.\n");
 571                 goto finish;
 572             }
 573
 574             s = pa_daemon_conf_dump(conf);
 575             fputs(s, stdout);
 576             pa_xfree(s);
 577             retval = 0;
 578             goto finish;
 579         }
 580
 581         case PA_CMD_DUMP_RESAMPLE_METHODS: {
 582             int i;
 583
 584             if (d < argc) {
 585                 pa_log("Too many arguments.\n");
 586                 goto finish;
 587             }
 588
 589             for (i = 0; i < PA_RESAMPLER_MAX; i++)
 590                 if (pa_resample_method_supported(i))
 591                     printf("%s\n", pa_resample_method_to_string(i));
 592
 593             retval = 0;
 594             goto finish;
 595         }
 596
 597         case PA_CMD_HELP :
 598             pa_cmdline_help(argv[0]);
 599             retval = 0;
 600             goto finish;
 601
 602         case PA_CMD_VERSION :
 603
 604             if (d < argc) {
 605                 pa_log("Too many arguments.\n");
 606                 goto finish;
 607             }
 608
 609             printf(PACKAGE_NAME" "PACKAGE_VERSION"\n");
 610             retval = 0;
 611             goto finish;
 612
 613         case PA_CMD_CHECK: {
 614             pid_t pid;
 615
 616             if (d < argc) {
 617                 pa_log("Too many arguments.\n");
 618                 goto finish;
 619             }
 620
 621             if (pa_pid_file_check_running(&pid, "pulseaudio") < 0)
 622                 pa_log_info(_("Daemon not running"));
 623             else {
 624                 pa_log_info(_("Daemon running as PID %u"), pid);
 625                 retval = 0;
 626             }
 627
 628             goto finish;
 629
 630         }
 631         case PA_CMD_KILL:
 632
 633             if (d < argc) {
 634                 pa_log("Too many arguments.\n");
 635                 goto finish;
 636             }
 637
 638             if (pa_pid_file_kill(SIGINT, NULL, "pulseaudio") < 0)
 639                 pa_log(_("Failed to kill daemon: %s"), pa_cstrerror(errno));
 640             else
 641                 retval = 0;
 642
 643             goto finish;
 644
 645         case PA_CMD_CLEANUP_SHM:
 646
 647             if (d < argc) {
 648                 pa_log("Too many arguments.\n");
 649                 goto finish;
 650             }
 651
 652             if (pa_shm_cleanup() >= 0)
 653                 retval = 0;
 654
 655             goto finish;
 656
 657         default:
 658             pa_assert(conf->cmd == PA_CMD_DAEMON || conf->cmd == PA_CMD_START);
 659     }
 660
 661     if (d < argc) {
 662         pa_log("Too many arguments.\n");
 663         goto finish;
 664     }
 665
 666 #ifdef HAVE_GETUID
 667     if (getuid() == 0 && !conf->system_instance)
 668         pa_log_warn(_("This program is not intended to be run as root (unless --system is specified)."));
 669 #ifndef HAVE_DBUS /* A similar, only a notice worthy check was done earlier, if D-Bus is enabled. */
 670     else if (getuid() != 0 && conf->system_instance) {
 671         pa_log(_("Root privileges required."));
 672         goto finish;
 673     }
 674 #endif
 675 #endif  /* HAVE_GETUID */
 676
 677     if (conf->cmd == PA_CMD_START && conf->system_instance) {
 678         pa_log(_("--start not supported for system instances."));
 679         goto finish;
 680     }
 681
 682     if (conf->cmd == PA_CMD_START && (configured_address = check_configured_address())) {
 683         /* There is an server address in our config, but where did it come from?
 684          * By default a standard X11 login will load module-x11-publish which will
 685          * inject PULSE_SERVER X11 property. If the PA daemon crashes, we will end
 686          * up hitting this code path. So we have to check to see if our configured_address
 687          * is the same as the value that would go into this property so that we can
 688          * recover (i.e. autospawn) from a crash.
 689          */
 690         char *ufn;
 691         bool start_anyway = false;
 692
 693         if ((ufn = pa_runtime_path(PA_NATIVE_DEFAULT_UNIX_SOCKET))) {
 694             char *id;
 695
 696             if ((id = pa_machine_id())) {
 697                 pa_strlist *server_list;
 698                 char formatted_ufn[256];
 699
 700                 pa_snprintf(formatted_ufn, sizeof(formatted_ufn), "{%s}unix:%s", id, ufn);
 701                 pa_xfree(id);
 702
 703                 if ((server_list = pa_strlist_parse(configured_address))) {
 704                     char *u = NULL;
 705
 706                     /* We only need to check the first server */
 707                     server_list = pa_strlist_pop(server_list, &u);
 708                     pa_strlist_free(server_list);
 709
 710                     start_anyway = (u && pa_streq(formatted_ufn, u));
 711                     pa_xfree(u);
 712                 }
 713             }
 714             pa_xfree(ufn);
 715         }
 716
 717         if (!start_anyway) {
 718             pa_log_notice(_("User-configured server at %s, refusing to start/autospawn."), configured_address);
 719             pa_xfree(configured_address);
 720             retval = 0;
 721             goto finish;
 722         }
 723
 724         pa_log_notice(_("User-configured server at %s, which appears to be local. Probing deeper."), configured_address);
 725         pa_xfree(configured_address);
 726     }
 727
 728     if (conf->system_instance && !conf->disallow_exit)
 729         pa_log_warn(_("Running in system mode, but --disallow-exit not set!"));
 730
 731     if (conf->system_instance && !conf->disallow_module_loading)
 732         pa_log_warn(_("Running in system mode, but --disallow-module-loading not set!"));
 733
 734     if (conf->system_instance && !conf->disable_shm) {
 735         pa_log_notice(_("Running in system mode, forcibly disabling SHM mode!"));
 736         conf->disable_shm = true;
 737     }
 738
 739     if (conf->system_instance && conf->exit_idle_time >= 0) {
 740         pa_log_notice(_("Running in system mode, forcibly disabling exit idle time!"));
 741         conf->exit_idle_time = -1;
 742     }
 743
 744     if (conf->cmd == PA_CMD_START) {
 745         /* If we shall start PA only when it is not running yet, we
 746          * first take the autospawn lock to make things
 747          * synchronous. */
 748
 749         if ((autospawn_fd = pa_autospawn_lock_init()) < 0) {
 750             pa_log("Failed to initialize autospawn lock");
 751             goto finish;
 752         }
 753
 754         if ((pa_autospawn_lock_acquire(true) < 0)) {
 755             pa_log("Failed to acquire autospawn lock");
 756             goto finish;
 757         }
 758
 759         autospawn_locked = true;
 760     }
 761
 762     if (conf->daemonize) {
 763 #ifdef HAVE_FORK
 764         pid_t child;
 765 #endif
 766
 767         if (pa_stdio_acquire() < 0) {
 768             pa_log(_("Failed to acquire stdio."));
 769             goto finish;
 770         }
 771
 772 #ifdef HAVE_FORK
 773         if (pipe(daemon_pipe) < 0) {
 774             pa_log(_("pipe() failed: %s"), pa_cstrerror(errno));
 775             goto finish;
 776         }
 777
 778         if ((child = fork()) < 0) {
 779             pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
 780             pa_close_pipe(daemon_pipe);
 781             goto finish;
 782         }
 783
 784         if (child != 0) {
 785             ssize_t n;
 786             /* Father */
 787
 788             pa_assert_se(pa_close(daemon_pipe[1]) == 0);
 789             daemon_pipe[1] = -1;
 790
 791             if ((n = pa_loop_read(daemon_pipe[0], &retval, sizeof(retval), NULL)) != sizeof(retval)) {
 792
 793                 if (n < 0)
 794                     pa_log(_("read() failed: %s"), pa_cstrerror(errno));
 795
 796                 retval = 1;
 797             }
 798
 799             if (retval)
 800                 pa_log(_("Daemon startup failed."));
 801             else
 802                 pa_log_info(_("Daemon startup successful."));
 803
 804             goto finish;
 805         }
 806
 807         if (autospawn_fd >= 0) {
 808             /* The lock file is unlocked from the parent, so we need
 809              * to close it in the child */
 810
 811             pa_autospawn_lock_release();
 812             pa_autospawn_lock_done(true);
 813
 814             autospawn_locked = false;
 815             autospawn_fd = -1;
 816         }
 817
 818         pa_assert_se(pa_close(daemon_pipe[0]) == 0);
 819         daemon_pipe[0] = -1;
 820 #endif
 821
 822         if (!conf->log_target) {
 823             pa_log_target target = { .type = PA_LOG_SYSLOG, .file = NULL };
 824             pa_log_set_target(&target);
 825         }
 826
 827 #ifdef HAVE_SETSID
 828         if (setsid() < 0) {
 829             pa_log(_("setsid() failed: %s"), pa_cstrerror(errno));
 830             goto finish;
 831         }
 832 #endif
 833
 834 #ifdef HAVE_FORK
 835         /* We now are a session and process group leader. Let's fork
 836          * again and let the father die, so that we'll become a
 837          * process that can never acquire a TTY again, in a session and
 838          * process group without leader */
 839
 840         if (pipe(daemon_pipe2) < 0) {
 841             pa_log(_("pipe() failed: %s"), pa_cstrerror(errno));
 842             goto finish;
 843         }
 844
 845         if ((child = fork()) < 0) {
 846             pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
 847             pa_close_pipe(daemon_pipe2);
 848             goto finish;
 849         }
 850
 851         if (child != 0) {
 852             ssize_t n;
 853             /* Father */
 854
 855             pa_assert_se(pa_close(daemon_pipe2[1]) == 0);
 856             daemon_pipe2[1] = -1;
 857
 858             if ((n = pa_loop_read(daemon_pipe2[0], &retval, sizeof(retval), NULL)) != sizeof(retval)) {
 859
 860                 if (n < 0)
 861                     pa_log(_("read() failed: %s"), pa_cstrerror(errno));
 862
 863                 retval = 1;
 864             }
 865
 866             /* We now have to take care of signalling the first fork with
 867              * the return value we've received from this fork... */
 868             pa_assert(daemon_pipe[1] >= 0);
 869
 870             pa_loop_write(daemon_pipe[1], &retval, sizeof(retval), NULL);
 871             pa_close(daemon_pipe[1]);
 872             daemon_pipe[1] = -1;
 873
 874             goto finish;
 875         }
 876
 877         pa_assert_se(pa_close(daemon_pipe2[0]) == 0);
 878         daemon_pipe2[0] = -1;
 879
 880         /* We no longer need the (first) daemon_pipe as it's handled in our child above */
 881         pa_close_pipe(daemon_pipe);
 882 #endif
 883
 884 #ifdef SIGTTOU
 885         signal(SIGTTOU, SIG_IGN);
 886 #endif
 887 #ifdef SIGTTIN
 888         signal(SIGTTIN, SIG_IGN);
 889 #endif
 890 #ifdef SIGTSTP
 891         signal(SIGTSTP, SIG_IGN);
 892 #endif
 893
 894         pa_nullify_stdfds();
 895     }
 896
 897     pa_set_env_and_record("PULSE_INTERNAL", "1");
 898     pa_assert_se(chdir("/") == 0);
 899     umask(0022);
 900
 901 #ifdef HAVE_SYS_RESOURCE_H
 902     set_all_rlimits(conf);
 903 #endif
 904     pa_rtclock_hrtimer_enable();
 905
 906     pa_raise_priority(conf->nice_level);
 907
 908     if (conf->system_instance)
 909         if (change_user() < 0)
 910             goto finish;
 911
 912     pa_set_env_and_record("PULSE_SYSTEM", conf->system_instance ? "1" : "0");
 913
 914     pa_log_info(_("This is PulseAudio %s"), PACKAGE_VERSION);
 915     pa_log_debug(_("Compilation host: %s"), CANONICAL_HOST);
 916     pa_log_debug(_("Compilation CFLAGS: %s"), PA_CFLAGS);
 917
 918     s = pa_uname_string();
 919     pa_log_debug(_("Running on host: %s"), s);
 920     pa_xfree(s);
 921
 922     pa_log_debug(_("Found %u CPUs."), pa_ncpus());
 923
 924     pa_log_info(_("Page size is %lu bytes"), (unsigned long) PA_PAGE_SIZE);
 925
 926 #ifdef HAVE_VALGRIND_MEMCHECK_H
 927     pa_log_debug(_("Compiled with Valgrind support: yes"));
 928 #else
 929     pa_log_debug(_("Compiled with Valgrind support: no"));
 930 #endif
 931
 932     pa_log_debug(_("Running in valgrind mode: %s"), pa_yes_no(pa_in_valgrind()));
 933
 934     pa_log_debug(_("Running in VM: %s"), pa_yes_no(pa_running_in_vm()));
 935
 936 #ifdef __OPTIMIZE__
 937     pa_log_debug(_("Optimized build: yes"));
 938 #else
 939     pa_log_debug(_("Optimized build: no"));
 940 #endif
 941
 942 #ifdef NDEBUG
 943     pa_log_debug(_("NDEBUG defined, all asserts disabled."));
 944 #elif defined(FASTPATH)
 945     pa_log_debug(_("FASTPATH defined, only fast path asserts disabled."));
 946 #else
 947     pa_log_debug(_("All asserts enabled."));
 948 #endif
 949
 950     if (!(s = pa_machine_id())) {
 951         pa_log(_("Failed to get machine ID"));
 952         goto finish;
 953     }
 954     pa_log_info(_("Machine ID is %s."), s);
 955     pa_xfree(s);
 956
 957     if ((s = pa_session_id())) {
 958         pa_log_info(_("Session ID is %s."), s);
 959         pa_xfree(s);
 960     }
 961
 962     if (!(s = pa_get_runtime_dir()))
 963         goto finish;
 964     pa_log_info(_("Using runtime directory %s."), s);
 965     pa_xfree(s);
 966
 967     if (!(s = pa_get_state_dir()))
 968         goto finish;
 969     pa_log_info(_("Using state directory %s."), s);
 970     pa_xfree(s);
 971
 972     pa_log_info(_("Using modules directory %s."), conf->dl_search_path);
 973
 974     pa_log_info(_("Running in system mode: %s"), pa_yes_no(pa_in_system_mode()));
 975
 976     if (pa_in_system_mode())
 977         pa_log_warn(_("OK, so you are running PA in system mode. Please note that you most likely shouldn't be doing that.\n"
 978                       "If you do it nonetheless then it's your own fault if things don't work as expected.\n"
 979                       "Please read http://pulseaudio.org/wiki/WhatIsWrongWithSystemMode for an explanation why system mode is usually a bad idea."));
 980
 981     if (conf->use_pid_file) {
 982         int z;
 983
 984         if ((z = pa_pid_file_create("pulseaudio")) != 0) {
 985
 986             if (conf->cmd == PA_CMD_START && z > 0) {
 987                 /* If we are already running and with are run in
 988                  * --start mode, then let's return this as success. */
 989
 990                 retval = 0;
 991                 goto finish;
 992             }
 993
 994             pa_log(_("pa_pid_file_create() failed."));
 995             goto finish;
 996         }
 997
 998         valid_pid_file = true;
 999     }
1000
1001     pa_disable_sigpipe();
1002
1003     if (pa_rtclock_hrtimer())
1004         pa_log_info(_("Fresh high-resolution timers available! Bon appetit!"));
1005     else
1006         pa_log_info(_("Dude, your kernel stinks! The chef's recommendation today is Linux with high-resolution timers enabled!"));
1007
1008     if (conf->lock_memory) {
1009 #if defined(HAVE_SYS_MMAN_H) && !defined(__ANDROID__)
1010         if (mlockall(MCL_FUTURE) < 0)
1011             pa_log_warn("mlockall() failed: %s", pa_cstrerror(errno));
1012         else
1013             pa_log_info("Successfully locked process into memory.");
1014 #else
1015         pa_log_warn("Memory locking requested but not supported on platform.");
1016 #endif
1017     }
1018
1019     pa_memtrap_install();
1020
1021     pa_assert_se(mainloop = pa_mainloop_new());
1022
1023     if (!(c = pa_core_new(pa_mainloop_get_api(mainloop), !conf->disable_shm, conf->shm_size))) {
1024         pa_log(_("pa_core_new() failed."));
1025         goto finish;
1026     }
1027
1028     c->default_sample_spec = conf->default_sample_spec;
1029     c->alternate_sample_rate = conf->alternate_sample_rate;
1030     c->default_channel_map = conf->default_channel_map;
1031     c->default_n_fragments = conf->default_n_fragments;
1032     c->default_fragment_size_msec = conf->default_fragment_size_msec;
1033     c->deferred_volume_safety_margin_usec = conf->deferred_volume_safety_margin_usec;
1034     c->deferred_volume_extra_delay_usec = conf->deferred_volume_extra_delay_usec;
1035     c->exit_idle_time = conf->exit_idle_time;
1036     c->scache_idle_time = conf->scache_idle_time;
1037     c->resample_method = conf->resample_method;
1038     c->realtime_priority = conf->realtime_priority;
1039     c->realtime_scheduling = !!conf->realtime_scheduling;
1040     c->disable_remixing = !!conf->disable_remixing;
1041     c->disable_lfe_remixing = !!conf->disable_lfe_remixing;
1042     c->deferred_volume = !!conf->deferred_volume;
1043     c->running_as_daemon = !!conf->daemonize;
1044     c->disallow_exit = conf->disallow_exit;
1045     c->flat_volumes = conf->flat_volumes;
1046 #ifdef HAVE_DBUS
1047     c->server_type = conf->local_server_type;
1048 #endif
1049
1050     c->cpu_info.cpu_type = PA_CPU_UNDEFINED;
1051     if (!getenv("PULSE_NO_SIMD")) {
1052         if (pa_cpu_init_x86(&(c->cpu_info.flags.x86)))
1053             c->cpu_info.cpu_type = PA_CPU_X86;
1054         if (pa_cpu_init_arm(&(c->cpu_info.flags.arm)))
1055             c->cpu_info.cpu_type = PA_CPU_ARM;
1056         pa_cpu_init_orc(c->cpu_info);
1057     }
1058
1059     pa_assert_se(pa_signal_init(pa_mainloop_get_api(mainloop)) == 0);
1060     pa_signal_new(SIGINT, signal_callback, c);
1061     pa_signal_new(SIGTERM, signal_callback, c);
1062 #ifdef SIGUSR1
1063     pa_signal_new(SIGUSR1, signal_callback, c);
1064 #endif
1065 #ifdef SIGUSR2
1066     pa_signal_new(SIGUSR2, signal_callback, c);
1067 #endif
1068 #ifdef SIGHUP
1069     pa_signal_new(SIGHUP, signal_callback, c);
1070 #endif
1071
1072 #ifdef OS_IS_WIN32
1073     win32_timer = pa_mainloop_get_api(mainloop)->time_new(pa_mainloop_get_api(mainloop), pa_gettimeofday(&win32_tv), message_cb, NULL);
1074 #endif
1075
1076     if (!conf->no_cpu_limit)
1077         pa_assert_se(pa_cpu_limit_init(pa_mainloop_get_api(mainloop)) == 0);
1078
1079     buf = pa_strbuf_new();
1080
1081 #ifdef HAVE_DBUS
1082     pa_assert_se(dbus_threads_init_default());
1083
1084     if (start_server) {
1085 #endif
1086         if (conf->load_default_script_file) {
1087             FILE *f;
1088
1089             if ((f = pa_daemon_conf_open_default_script_file(conf))) {
1090                 r = pa_cli_command_execute_file_stream(c, f, buf, &conf->fail);
1091                 fclose(f);
1092             }
1093         }
1094
1095         if (r >= 0)
1096             r = pa_cli_command_execute(c, conf->script_commands, buf, &conf->fail);
1097
1098         pa_log_error("%s", s = pa_strbuf_tostring_free(buf));
1099         pa_xfree(s);
1100
1101         if (r < 0 && conf->fail) {
1102             pa_log(_("Failed to initialize daemon."));
1103             goto finish;
1104         }
1105
1106         if (!c->modules || pa_idxset_size(c->modules) == 0) {
1107             pa_log(_("Daemon startup without any loaded modules, refusing to work."));
1108             goto finish;
1109         }
1110 #ifdef HAVE_DBUS
1111     } else {
1112         /* When we just provide the D-Bus server lookup service, we don't want
1113          * any modules to be loaded. We haven't loaded any so far, so one might
1114          * think there's no way to contact the server, but receiving certain
1115          * signals could still cause modules to load. */
1116         conf->disallow_module_loading = true;
1117     }
1118 #endif
1119
1120     /* We completed the initial module loading, so let's disable it
1121      * from now on, if requested */
1122     c->disallow_module_loading = !!conf->disallow_module_loading;
1123
1124 #ifdef HAVE_DBUS
1125     if (!conf->system_instance) {
1126         if ((server_lookup = pa_dbusobj_server_lookup_new(c))) {
1127             if (!(lookup_service_bus = register_dbus_name(c, DBUS_BUS_SESSION, "org.PulseAudio1")))
1128                 goto finish;
1129         }
1130     }
1131
1132     if (start_server)
1133         server_bus = register_dbus_name(c, conf->system_instance ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, "org.pulseaudio.Server");
1134 #endif
1135
1136 #ifdef HAVE_FORK
1137     if (daemon_pipe2[1] >= 0) {
1138         int ok = 0;
1139         pa_loop_write(daemon_pipe2[1], &ok, sizeof(ok), NULL);
1140         pa_close(daemon_pipe2[1]);
1141         daemon_pipe2[1] = -1;
1142     }
1143 #endif
1144
1145     pa_log_info(_("Daemon startup complete."));
1146     /* broadcast if we're ready */
1147     creat(PA_READY, 0644);
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 }